swift学习文档(笔记)-百家乐凯发k8

这篇文章主要介绍了学习swift的笔记，swift最近也比较热，需要的朋友可以参考下

swift是供ios和os x应用编程的新编程语言，基于c和objective-c，而却没有c的一些兼容约束。swift采用了安全的编程模式和添加现代的功能来是的编程更加简单、灵活和有趣。界面则基于广受人民群众爱戴的cocoa和cocoa touch框架，展示了软件开发的新方向。

变量与常量

变量定义使用var，常量使用let，类型安全，有自动类型推导，注意赋值的=号两边必须有空格。变量和常量名是可以几乎所有字符，这些都非常像javascript。中文编程一下牛逼了。

var a = 123 //a为int
let b = "helo" //b为string
var 猫叫 ＝ "喵"

数字

十进制
二进制 0b101
八进制 0o5
十六进制 0x5

比较长的数字间可以加上_用来提高程序的可读性，比如0_0其实就是0，_线不能加在开头

布尔类型

true和false，流程控制if的时候，判断语句返回必须是一个bool值，比如：

let i = 1
if i {
 //编译报错
}

这样就可以通过

if i == 1 {
}

它不像js里会有自动类型转换

类型别名

给现在的类型添加别名，同样可以提高程序的可读性，如

typealias 音频采样 = uint16

可以在别的地方使用 var 已发现的最大振幅 = 音频采样.min

元组

它可以是一组值，这些值不必是相同的类型，例如，定义我自己：

var jserme = ("183cm", 26, "76kg")

可以像数组一样访问

println(jserme.0) //返回183cm

元组还原为独立的变量或者常量

let jserme = ("183cm",26,"76kg")
let (身高, 年龄, 体重) = jserme
println("身高是 \(身高)")

也可以给每个值命名（这就像在js里把数组搞成了对象了。。。）

let jserme = (身高:"183cm",年龄:26,体重:"76kg")
println("身高是 \(jserme.身高)")

字符串

字符串字面量只能用""来定义，string本质上是character的有序集合。

for char in "一言既出"{
 println(char)
}
 
/*
一
言
既
出
*/

字面量与判断是否为空

var 字符串 = "我是字符串"
var 空字符串 = ""
 
if 空字符串.isempty {
 println("这是一个空的字符串")
}
 
if 空字符串 == "" {
 println("这是一个空的字符串")
}

字符串实例有两个方法hasprefix与hassuffix，如：

var 成语数组 = [
 "一言既出",
 "一触即发",
 "一呼百应",
 "一槌定音",
 "一无所有",
 "一生一世",
 "一见钟情"
]
 
var count = 0
for 成语 in 成语数组 {
 if(成语.hasprefix("一")){
  count  
 }
}
 
println(count) //输出7

与js一样，string也是传值引用，下面的两个变量的修改不会影响到彼此

var 一串 = "我是字符串一"
var 二串 = 一串
 
二串 = "我是字符串二"
 
println("字符串一:\(一串)， 字符串二:\(二串)")

区间运算符

闭区间使用a...b，从a到b，包含a与b，半区间a..b，从a到b，不包含b，例如：

var 成语数组 = [
 "一言既出",
 "一触即发",
 "一呼百应"
]
 
for i in 0..成语数组.count {
 println("第\(i)个成语是:\(成语数组[i])")
}
//这里如何使用...会报错，因为成语数组[3]是没有值的

两种集合,array 和 dictionaries

相对于js对数组和对象成员松散的要求，swift要求数组和dictionaries里成员类型必须一致

var 购物清单: string[] = ["鸡蛋", "牛奶"]
//也可以是下面的这样
//var 购物清单 = ["鸡蛋", "牛奶"]

数组的修改可以使用append方法或者 =

var 购物清单 = ["鸡蛋", "牛奶"]
 
购物清单.append("苹果")
 
购物清单  = "草莓"
 
println("\(购物清单)") //[鸡蛋, 牛奶, 苹果, 草莓]

数组的获取，可以通过索引，也可以通过区间运算符

var 购物清单 = ["鸡蛋", "牛奶"]
 
println("\(购物清单[0])") //鸡蛋
println("\(购物清单[0..1])") //[鸡蛋]
println("\(购物清单[0...1])") //[鸡蛋, 牛奶]
println("\(购物清单[0...2])") //[鸡蛋, 牛奶, ]

dictionaries的定义

var airports: dictionary = ["tyo": "tokyo", "dub": "dublin"]
 
//也可以简化为
//var airports = ["tyo": "tokyo", "dub": "dublin"]

它的修改与读取使用[],而不能使用.

airports["bj"] = "beijin"

控制语句

如前面的几个例子所示，控制语句的条件不像js有小括号

for var index = 0; index < 3; index   {
 println("index is \(index)")
}
//index is 0
//index is 1
//index is 2

函数

函数的声明与调用：

func sayhello(personname: string) -> string {
 let greeting = "hello, "   personname   "!"
 return greeting
}
 
println(sayhello("jserme"))

无返回的函数，其实质是返回一个void，它等同于一个空的元组()

多返回值的函数与默认参数：

func info(word:string = "aha") -> (length:int, containa:bool){
 var containa = false
 for char in word {
  if( char == "a") {
   containa = true
   break
  }
 }
 
 return (word.utf16count, containa)
}
 
println(info(word: "波波")) //(2, false)
println(info()) //(3, true)

便于阅读的外部参数名，在参数定义之前，与参数定义以空格隔开，如下面的多个参数

func join(string s1: string, tostring s2: string, withjoiner joiner: string)
 -> string {
 return s1   joiner   s2
}
 
//调用的时候
join(string: "hello", tostring: "world", withjoiner: ", ")
// returns "hello, world"

参数名与外部参数名一致，可以给参数名加#标识：

func containscharacter(#string: string, #charactertofind: character) -> bool {
 for character in string {
  if character == charactertofind {
   return true
  }
 }
 return false
}
let containsavee = containscharacter(string: "aardvark", charactertofind: "v")
// containsavee equals true, because "aardvark" contains a "v"

函数的参数是常量，不可以修改，如果在函数内修改，变量定义前加var

func alignright(var string: string, count: int, pad: character) -> string {
 let amounttopad = count - countelements(string)
 for _ in 1...amounttopad {
  string = pad   string
 }
 return string
}
 
let originalstring = "hello"
let paddedstring = alignright(originalstring, 10, "-")
// paddedstring is equal to "-----hello"
// originalstring is still equal to "hello"

如果想在函数内修改传入的参数，可以使用inout关键字来标识，传入的参数需要前缀&，这内部实现应该是指针。

func swaptwoints(inout a: int, inout b: int) {
 let temporarya = a
 a = b
 b = temporarya
}
var someint = 3
var anotherint = 107
swaptwoints(&someint, &anotherint)
println("someint is now \(someint), and anotherint is now \(anotherint)")
// prints "someint is now 107, and anotherint is now 3"

函数类型，可以像js一样使用函数作为参数及返回值

func addtwoints(a: int, b: int) -> int {
 return a   b
} //函数类型为 (int, int) -> int
func multiplytwoints(a: int, b: int) -> int {
 return a * b
}//函数类型为 (int, int) -> int
 
//接收名为mathfunction的函数类型
func printmathresult(mathfunction: (int, int) -> int, a: int, b: int) {
 println("result: \(mathfunction(a, b))")
}
printmathresult(addtwoints, 3, 5)
// prints "result: 8"
 
//返回函数类型
func stepforward(input: int) -> int {
 return input   1
}
func stepbackward(input: int) -> int {
 return input - 1
}
func choosestepfunction(backwards: bool) -> (int) -> int {
 return backwards ? stepbackward : stepforward
}
var currentvalue = 3
let movenearertozero = choosestepfunction(currentvalue > 0)
// movenearertozero now refers to the stepbackward() function

闭包

函数与它包含的上下文的变量在一起称为闭包。如sort函数:

let names = ["chris", "alex", "ewa", "barry", "daniella"]
 
func backwards(s1: string, s2: string) -> bool {
 return s1 > s2
}
var reversed = sort(names, backwards)
println(reversed)
// reversed is equal to ["ewa", "daniella", "chris", "barry", "alex"]s

使用闭包可以表示为:

let names = ["chris", "alex", "ewa", "barry", "daniella"]
 
var reversed = sort(names, {(s1:string, s2:string) -> bool in
 return s1 > s2
})
println(reversed)
// reversed is equal to ["ewa", "daniella", "chris", "barry", "alex"]

也可以简化为

let names = ["chris", "alex", "ewa", "barry", "daniella"]
 
var reversed = sort(names, { s1, s2 in s1 > s2 } )
 
println(reversed)

枚举

通过下面的语法声明

enum barcode {
 case upca(int, int, int) = (1,2,3)
 case qrcode(string) = "hello"
}

类与结构体

推荐使用首字母大写来命名

struct resolution {
 var width = 0
 var heigth = 0
}
class videomode {
 var resolution = resolution()
 var interlaced = false
 var framerate = 0.0
 var name: string?
}

生成实例：

let someresolution = resolution()
let somevideomode = videomode()

属性访问与修改，使用.语法：

println("the width of somevideomode is \(somevideomode.resolution.width)")
somevideomode.resolution.width = 12880
println("the width of somevideomode is now \(somevideomode.resolution.width)")

结构体有自动成员初始化器，类实例没有：

let vga = resolution（width:640, heigth: 480）

结构体与枚举都是值类型，类是引用类型

对于引用了同一个实例的值，可以使用===和!==来进行判断

延迟属性,@lazy，设置在调用的时候才初始化特定的属性

class dataimporter {
 /*
 dataimporter 是一个将外部文件中的数据导入的类。
 这个类的初始化会消耗不少时间。
 */
 var filename = "data.txt"
 // 这是提供数据导入功能
}
 
class datamanager {
 @lazy var importer = dataimporter()
 var data = string[]()
 // 这是提供数据管理功能
}
 
let manager = datamanager()
manager.data  = "some data"
manager.data  = "some more data"
// dataimporter 实例的 importer 属性还没有被创建

类、结构体、枚举都可以通过设置setter与getter来

struct alternativerect {
 var origin = point()
 var size = size()
 var center: point {
 get {
  let centerx = origin.x   (size.width / 2)
  let centery = origin.y   (size.height / 2)
  return point(x: centerx, y: centery)
 }
 set { //这里setter 没有定义表示新值的参数名，则可以使用默认名称newvalue
  origin.x = newvalue.x - (size.width / 2)
  origin.y = newvalue.y - (size.height / 2)
 }
 }
}

只读属性去掉get与set

属性监视可以使用willset和didset来处理

类型属性有点像静态变量，以static关键字声明

struct somestructure {
 static var storedtypeproperty = "some value."
 static var computedtypeproperty: int {
 // 这里返回一个 int 值
 }
}

下标

类、结构体、枚举都可以有下标，它有像给它们增加了一个快捷方式，如下：

struct timestable {
 let multiplier: int
 subscript(index: int) -> int {
  return multiplier * index
 }
}
let threetimestable = timestable(multiplier: 3)
println("3的6倍是\(threetimestable[6])")
// 输出 "3的6倍是18"

继承

定义一个类

class vehicle {
 var numberofwheels: int
 var maxpassengers: int
 func description() -> string {
  return "\(numberofwheels) wheels; up to \(maxpassengers) passengers"
 }
 init() {
  numberofwheels = 0
  maxpassengers = 1
 }
}

继承类

class bicycle: vehicle {
 init() {
  super.init()
  numberofwheels = 2
 }
}

重写属性与方法

class car: vehicle {
 var speed: double = 0.0
 override var speed: double {
 get {
  return super.speed
 }
 set {
  super.speed = min(newvalue, 40.0)
 }
 }
 init() {
  super.init()
  maxpassengers = 5
  numberofwheels = 4
 }
 override func description() -> string {
  return super.description()   "; "
     "traveling at \(speed) mph"
 }
}

防止重写，在方法与属性前加关键字@final，编译时会出错

构造函数

声明里可以写多个init，这有点像重载

struct celsius {
 var temperatureincelsius: double = 0.0
 init(fromfahrenheit fahrenheit: double) {
  temperatureincelsius = (fahrenheit - 32.0) / 1.8
 }
 init(fromkelvin kelvin: double) {
  temperatureincelsius = kelvin - 273.15
 }
}
 
let boilingpointofwater = celsius(fromfahrenheit: 212.0)
// boilingpointofwater.temperatureincelsius 是 100.0
let freezingpointofwater = celsius(fromkelvin: 273.15)
// freezingpointofwater.temperatureincelsius 是 0.0”

类的析构

有些地方叫反初始化，很别扭的名字哦

class player {
 var coinsinpurse: int
 init(coins: int) {
  coinsinpurse = bank.vendcoins(coins)
 }
 
 func wincoins(coins: int) {
  coinsinpurse  = bank.vendcoins(coins)
 }
 
 deinit {
  bank.receivecoins(coinsinpurse)
 }
}
 
var player = player(coins:200)
player = nil //调用deinit方法

扩展

对于类、结构体、枚举，可以扩展它们的一切

class player{
 var age:int
}
 
extension player{
 func repetitions(task: () -> ()) {
  for i in 0..self {
   task()
  }
 }
}

协议

其实就是接口描述

 protocol someprotocol {
  var mustbesettable: int { get set }
  var doesnotneedtobesettable: int { get }
  func sometypemethod()
 }

协议继承

 protocol inheritingprotocol: someprotocol, anotherprotocol {
  // protocol definition goes here
 }

泛型

这个函数的泛型版本使用了节点类型命名（通常此情况下用字母t来表示）来代替实际类型名（如int、string或double）。节点类型名并不是表示t必须是任何类型，但是其规定a和b必须是同一类型的t，而不管t表示任何类型。只有swaptwovalues函数在每次调用时所传入的实际类型决定了t所代表的类型。

 func swaptwovalues(inout a: t, inout b: t) {
  let temporarya = a
  a = b
  b = temporarya
 }

运算符重载

这里演示重载号运算符

struct vector2d {
 var x = 0.0, y = 0.0
}
@infix func   (left: vector2d, right: vector2d) -> vector2d {
 return vector2d(x: left.x   right.x, y: left.y   right.y)
}

前置运算符 @prefix
后置运算符 @postfix
组合赋值运算符 @assignment
比较运算符 @infix

@prefix @assignment func    (inout vector: vector2d) -> vector2d {
 vector  = vector2d(x: 1.0, y: 1.0)
 return vector
}

自定义运算符

个性的运算符只能使用这些字符 / = - * % < >！& | ^。~

operator prefix     {}
@prefix @assignment func     (inout vector: vector2d) -> vector2d {
 vector  = vector
 return vector
}

结合性(associativity)的值默认为none,可用left,right,none，优先级(precedence)默认为100。

operator infix  - { associativity left precedence 140 }
func  - (left: vector2d, right: vector2d) -> vector2d {
 return vector2d(x: left.x   right.x, y: left.y - right.y)
}
let firstvector = vector2d(x: 1.0, y: 2.0)
let secondvector = vector2d(x: 3.0, y: 4.0)
let plusminusvector = firstvector  - secondvector
// plusminusvector 此时的值为 (4.0, -2.0)

来自：http://jser.me