swift自学注意点

1.swift字符串用””表示，不再使用@“”，事实上只有OC才使用@“”。

2.字符串拼接可以直接使用”+”进行，例如

     var str = “I am “ + “a student"

3.在字符串中插入变量，直接使用”\(xxx)”即可，例如

     var age = 21

     var str = “I am \(age) years old”          // I am 21 years old

4.函数调用使用点，而不使用中括号。

5.句尾的分号可以省略

6.支持自动类型推导，浮点数默认是Double类型，且不同数据类型之间不可进行运算，需要进行类型转换。

7.数字中可以添加多余的0和下划线以方便阅读，例如：

     001999 == 1999

     1_999 == 1999

8.赋值语句不再有返回值，例如

     在OC和C中：value = 100;    此句在对value变量赋值的同时返回值为100

     在swift中：    value = 100     此句单纯赋值，不再有返回值

9.OC中使用的typedef关键字变为typealias，且经过typealias定义的类型可以使用在任何原类型出现的地方，例如：

     typealias myInt = Int     //为Int类型起别名为myInt，以后可以使用myInt代替Int

10.求余运算符可以用于浮点数，例如

     7 % 2.5 == 0.5

11.Bool类型严格表示，真为true，假为false。0不再表示假，非0也不再表示真，并且在所有判断真假的地方，必须使用true和false，不使用0和1，例如if语句，for语句，三目运算符等，并且比较运算语句的返回值也是Bool类型，不再是0或1。

12.swift新增了范围运算符，闭合范围运算符”…"，半闭合范围运算符 ”..<“ or ”>..”。例如：

     在swift中，for循环的写法如下：

          for i in 0…5 {

               println(i)

          }                                   //输出0到5

注意在for循环中，不用再重新定义i变量，直接写i即可，且不再需要括号，直接使用for in即可。

如果不需要在循环中使用i的值，可以使用下划线忽略，例如：

for _ in 0…5 {

     println(i)

}

13.新增溢出运算符”&”，可以和算术运算符组合成为：”&+”, “&-“, “&*”, “&/“。溢出运算符可以自动进位，突破数据类型的最大最小值限制，如果不使用溢出运算符，数据大小溢出的话则会报错。

14.新增元组类型，元组中可以存放任意个任意类型的数据，例如：

     let position = (x : 10.5, y : 12)

     var person = (name : “小明")

使用let声明的元组，其内容不能修改，而使用var声明的元组内容可以修改。

取得元组内部的数据可以使用成员的名称，或者像数组一样取数据：

     position.x == 10.5

     position.0 == 10.5     //表示取第0个元素

定义元组时可以省略元素的名称，例如：

     let position = (10, 12)

定义元组时可以明确的指定数据类型，例如：

     let person : (age : Int, name : String) = (20, “小明")

可以用多个变量接收元组数据，例如：

     var (x, y) = (10, 20)

     var position = (x, y)

可以将元组元素分别赋值给多个变量，例如：

     var position = (10, 20)

     var (x, y) = position

可以使用下划线忽略某个元素的值，例如：

     var person = (20, “小明")

     var (_, name) = person     //20被忽略，name赋值为”小明"

15.在swift中，switch语句的判断条件不仅限于Int类型，可以是字符串等类型，且不用再写break关键字，例如：

     var grade = “A"

     switch grade {

          case “A”:

               println(“成绩优秀")

          case “B”:

               println(“成绩良好")

          default :

               println(“成绩未知")

     }

且每一个case之后必须有可以执行的语句。即不可以像C一样几个case使用同样的处理逻辑，例如：

     switch value {

          case 0:

          case 1:

          case 2:

               println(“xxx”)

     }

这样的代码在swift中会报错，如果想多个case公用一样的处理逻辑，可以把这几个case写在同一个case中，用逗号隔开，例如：

     switch value {

          case 0, 1, 2:

               println(“xxx")

     }

这样就不会报错了。

还可以在switch的case中使用范围匹配，例如：

     switch score {

          case 90…100 :

               println(“优秀")

          case 60…89 :

               println(“良好")

          default :

               println(“不及格")

     }

需要注意的是，在swift中，switch语句必须囊括所有的情况，也即default的情况不能省略，如果没有包括所有的情况，直接报错。

switch还可以与元组混合使用，例如：

     let point = (1, 1)

     switch point {

          case (0, 0):

               println(“点在00")

          case (-2…2, -2…2):

               println(“点在以原点为中心的边长为4的正方形中")

          default:

               println(“error")

     }

switch还支持数值绑定，可以将switch中的值绑定为一个特定的常量或变量，以便在case后面的语句中使用，例如：

     switch (10, 0) {

          case (let x, 0):

               println(“点在x轴上，x值是\(x)")

          case (0, let y):

               println(“点在y轴上，y值是\(y)")

          case let (x, y):

               println(“点不在坐标轴上，坐标为\(x), \(y)")

     }

switch语句可以使用where来增加判断的条件，例如：

     var point : (x : Int, y : Int) = (1, 0)

     switch point {

          case let (x, y) where x == y :

               println(“点在45度斜线上")

          case let (x, y) where x == -y :

               println(“点在135度斜线上")

          default :

               println(“点不在以上两条线上")

     }

新增fallthrough关键字，如果在case语句的执行语句末尾写上fall through，则执行完该case句柄后会继续执行该case句柄后面的case句柄或者default句柄，例如：

     var x = 20

     var str = “\(x) 是个"

     switch x {

          case 0…50 :

               str += “0~50之间的"

               fallthrough

          default :

               str += “整数”               // str == “20是个0~50之间的整数"

     }

需要注意的是，fall through后面的case或default句柄不能定义变量和常量。

16.swift支持标签，可以用于标记，例如：

     out_loop :

     for _ in 1…2 {

          for item in 1…3 {

               println(“做俯卧撑")

               if item == 2 {

                    break out_loop          //跳出out_loop循环

               }

          }

          println(“休息一会儿")

     }

此处标签用于明确指定跳出哪个循环

17.swift中的函数格式：

     func 函数名(形参列表) -> 返回值类型 {

     }

例如：

     func sum(x: Int, y: Int) -> Int {

          return x + y

     }

如果函数没有返回值，则可以在返回值类型处写”Void”或”()”，也可以直接省略”-> 返回值类型”，这几种做法都表示没有返回值。注意在swift中，Void就是空元组的typealias，二者等价。

18.swift的函数可以返回元组类型的数据，可以利用这个特性使得函数返回多个值，例如：

     func find(id: Int) -> (name: String, age: Int) {

          if id > 0 {

               return (“Jack”, 20)

          } else {

               return (“nobody”, 0)

          }

     }

     var people = find(1)

     println(“查找到的姓名为\(people.name), 年龄为\(people.age)")

19.由于函数的形式参数是使用于函数内部的，所以有时候我们调用了一个函数之后，回头再看调用的代码，会不清楚参数的含义，而要去翻看函数的定义来确定参数的含义。对于这个问题，swift提供了外部参数名的机制，可以在定义函数时为形式参数指定一个外部参数名，这样在调用函数的时候，就必须在传入的参数前面写上外部参数名，这样就可以明确参数的作用了。例如：

     func addStudent(name: String, age: Int, no: Int) {

          ………..

     }

这个函数未指定外部参数名，调用时的代码如下：

     addStudent(“Jack”, 20, 21)

可是再次阅读代码时会有疑问，20和21哪个是年龄，哪个是学号呢，此时就不得不翻看函数的定义，而如果使用了外部参数名，就可以避免这个问题，例如：

     func addStudent(name: String, stu_age age: Int, stu_no no: Int) {

          ……….

     }

这样再调用该函数时就会变成：

     addStudent(“Jack”, stu_age: 20, stu_no: 21)

这样就一目了然了。

也可以使用”#”来定义外部参数名，使得外部参数名和形式参数同名：

     func addStudent(name: String, #age: Int, #no: Int) {

          ……….

     }

20.swift在定义函数时可以为形参指定默认值，例如：

     func addStudent(name: String, age: Int = 0, no: Int = 0) {

          ……….

     }

这样定义之后，调用函数时就可以不传age和no参数，默认都为0，而如果传入了这两个参数，就按传入的参数来执行，且如果使用了默认参数值，那么该参数将自动生成同名的外部参数名。

21.swift的函数的形参默认是let类型的，不可修改。如果想在函数中修改形参的值，在定义函数的时候声明形参是var类型即可。

22.swift函数中修改了形参的值，但是只是修改了形参，传入的外部变量值并没有真正修改，而如果想在函数内部修改外部变量的值，可以在形参定义时使用inout关键字，声明该参数是一个输入输出参数，这样在函数中修改该参数，其结果就可以影响到外部变量了，例如：

     func swap(inout x: Int, inout y: Int) {

          var temp = x

          x = y

          y = temp

     }

var (a, b) = (10, 20)     //a == 10, b == 20

swap(&a, &b)             //a == 20, b == 10     需要注意在调用时，参数前面要加上&

需要注意的是，形参被声明为inout之后，传入的就必须是外部变量，不能是常量，因为声明为inout的目的就是更改外部变量，而常量的值是不可修改的。

23.不使用第三个变量交换两个变量的值：

     num1 = num1 + num2

     num2 = num1 - num2

     num1 = num1 - num2

     num1 = num1 ^ num2

     num2 = num1 ^ num2

     num1 = num1 ^ num2

24.在swift中，值类型被赋予给一个变量、常量或者本身被传递给一个函数的时候,实际上操作的是其的拷贝。

在 Swift 中,所有的基本类型:整数(Integer)、浮点 数(floating-point)、布尔值(Boolean)、字符串(string)、数组(array)和字典(dictionary),都是值 类型,并且都是以结构体的形式在后台所实现。

在 Swift 中,所有的结构体和枚举类型都是值类型。这意味着它们的实例,以及实例中所包含的任何值类型属 性,在代码中传递的时候都会被复制。

25.在swift中，类是引用类型，结构体是值类型，它们可以拥有存储属性，即内部定义的变量和常量，定义为变量的叫做变量存储属性，定义为常量的叫做常量存储属性，变量存储属性在赋值后可以修改，常量存储属性在赋值后不可以修改。但是，如果将一个结构体的实例赋值给一个常量，那么即使它内部拥有变量存储属性，也不可以再修改该属性，因为结构体是值类型，将一个值类型的数据赋值给一个常量，那么这个常量就是不可修改的，例如：

let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)      // 该区间表示整数0,1,2,3

rangeOfFourItems.firstValue = 6          // 尽管 firstValue 是个变量属性,这里还是会报错

但是如果是类的实例就不一样了，因为类的实例不是值类型，而是引用类型，即使将一个类的实例”赋值”(其实是创建一个新的引用)给一个常量，该实例中的可变存储属性还是可以修改，因为对于引用类型来说，一个常量引用了它，不可修改的是这个引用本身，而不是引用的对象。

26.存储属性在定义时可以加上lazy关键字，其作用等同于OC中的懒加载，只是OC中的懒加载需要我们写代码去控制，而在swift中只需要在变量存储属性声明时，在var前加上lazy关键字。全局的常量或变量默认就是lazy的，不用写lazy关键字。局部的则不是。

27.自定义的结构体会由系统自动生成一个包括结构体内部变量的构造器，而类则不会自动生成这样的构造器。

28.上面说得属性都是实例属性，即结构体，枚举或类的实例所拥有的属性，比如一个类的很多个实例之间，每个实例都有各自的属性，例如：

     Class Person {

          var name: String?

          var age: Int = 0

     }

     var person1 = Person()

     var person2 = Person()

以上的两个Person的实例person1和person2都有各自的name和age，两个实例都拥有各自的一份实例属性name和age。

还有一种属性叫做类型属性，这种属性不属于实例，而是属于类，不管这个类有多少个实例，类型属性都只有一份，类的每个实例都可以访问类型属性。

类型属性使用static关键字声明。

跟实例的存储属性不同，类型属性必须在定义时给一个初始值，因为类型本身无法在初始化构造过程中使用构造器给类型属性赋值。

类型属性是通过类名来获取和修改，并不是通过实例名。

29.除了存储属性，还有计算属性，计算属性本身不存储值，而是通过计算属性来获取一些特定的值或者设定一些值，使用set和get函数来定义计算属性，例如：

     struct Point {

          var x: Double = 0.0

          var y: Double = 0.0

     }

     struct Size {

          var width = 0.0, height = 0.0

     }

     struct Rect {

          var origin = Point()

          var size = Size()

          var center: Point {

               get{

                    return Point(x: origin.x + size.width / 2, y: origin.y + size.height / 2)

               }

               set{

                    origin.x = newValue.x - size.width / 2

                    origin.y = newValue.y - size.height / 2

               }     

          }

     }

set函数可以手动指定将要设置的值得名称，在set关键字后面加一个小括号，写入名称即可。

30.属性这一概念不仅用在类中，也用在结构体和枚举中。

31.属性观察器的作用是，监听属性的设置，包括willSet和didSet这两个方法，类似于OC中的观察者，当一个属性被设置时，如果该属性绑定了观察器，则会依次调用willSet和didSet，如果不手动指定，则在willSet中使用newValue作为新值的名称，在didSet中使用oldValue作为原值得名称。

32.在swift中，类，结构体，枚举都可以定义自己的类型方法和实例方法，而OC中只有类可以拥有方法，这是主要区别之一。

33.self与OC中的self等价，对于实例来说，self就指该实例本身。

34.如果类型的属性名和实例方法的局部变量名相同，这时在实例方法内部，局部变量优先级更高，而这种情况下要表示属性的话，使用"self.实例属性名”即可。

35.结构体和枚举是值类型，一般情况下，值类型不允许在实例方法改变其属性值。但是如果确实需要在值类型的实例方法中修改其属性，需要在实例方法声明时加上mutating关键字在func关键字之前，表示该方法是一个变异方法即可。

变异方法还可以对self进行操作，对self赋值将达到替换整个实例的效果。

枚举的变异方法可以将自己重新设置成为枚举中的其它类型，例如：

     enum TriStateSwitch {

          case off, low, high

          mutating func changeState() {

               switch self {

                    case off:

                         self = low

                    case low:

                         self = high

                    case high:

                         self = off

               }     

          }

     }

36.类型方法的声明，在func关键字前加上static关键字即可，对类，结构体，枚举均适用。对于类，可能还会使用class关键字，以表示允许子类重写该类方法。在类型方法中，self就指代类型，而不是实例。

37.类型方法中可以调用同类型中别的类型方法，且调用时不需要像在外部调用一样加上类型名称前缀，直接使用类型方法名称调用即可。类型方法可以访问类型属性。而实例方法不行。

38.字典在使用时，如果定义时就指定其键和值得类型，或者直接初始化字典时使用类型一致的键和值。那么该字典的类型固定，每一对键值都必须严格按照规定的类型，否则会报错。

如果字典在初始化时使用了不同类型的键或不同类型的值，那么该字典类型不固定，任何类型都可以放入该字典。

39.创建空数组和空字典是有条件的，如果上下文已经提供了类型信息，就可以直接使用[]和[:]来创建空数组，例如作为函数的参数，或者已经定义好类型的常量或变量：

     var array = [“1”, “2”, “3”]     //array已经被指定为[String]类型

     array = []          //array现在是一个类型为[String]的空数组

而如果想直接创建一个空数组，则必须在创建时指定类型，如果类型不确定，可以使用NSObject。