Swift基础知识(持续更新)

1.初始化数组、字典

//Array
var array = Array<T>()
//Dictionary
var name = Dictionary<String,value>()

更推荐的写法:

//Array
var array = [T]()
//Dictionary
var name = [String:Value]()

并且这个”() ” 表示调用Array和Dictionary的初始化方法
比如我创建一个class

class CalculatorBrain{
     init()
}
//会调用init()方法
let instance = CalculatorBran()

2.如果不给方法显示的加private修饰符，那么这个方法就是public的

3.enum可以包含函数，也可以只包含属性，就像calss一样,enum中的case可以和数据类型管理起来

enum op{
     case A(Double) //Operand和Double关联起来
     case B(String,Double->Double) //UnaryOperation和一个元祖关联
     case C(String,(Double,Double)->Double)//二元函数
}

4.函数的参数 默认是以let修饰的不可修改的变量

func evaluate(ops: [op]) -> String {
     if !ops.isEmpty {
          let op = ops.removeLast()
     }     
}

会报错 ：ops是一个不可修改对象，不能被修改
这是因为function在参数前都会默认隐藏一个let，以上的这种写法其实和下面是一样的

func evaluate(let ops:[op]->String){
    ...
}

所以如果把let修改成var的话就不会报错了
如下：

func evaluate(var ops:[op]->String){
    ...
}

以上的这种写法和下面是一样的

func evaluate(ops:[op]->String){
    var ops1 = ops
    ...
}

但是要知道的是，这样写并不会改变给函数外的数组。
因为：在Swift中 数组和Struct都做为参数传递的话 都是按值传递。

5.Struct和calss非常相似，Struct也可以有方法。

区别是：

①Struct不能有继承
②Struct是按值传递，class是按引用传递。

6.判断Enum中的值的好办法是使用switch

enum op{
     case Operand(Double) //Operand和Double关联起来
     case UnaryOperation(String,Double->Double) //UnaryOperation和一个元祖关联
     case BinaryOperaion(String,(Double,Double)->Double)//二元函数
}

func evaluate(ops: [op]) -> String {
     if !ops.isEmpty {
          var tmp = ops
          let op = tmp.removeLast()
          switch op {
               case .Operand(let operand) //注意这边直接使用了一个"." 这是因为完整的写法是Op.Operand(Double)，这里可以直接省略掉.号前面的Op
          }
     }     
}

注意 不要对所有的switch 都加上default的处理。switch一个enum如果穷尽了enum里面的项，那么就不需要再加default处理

7.在项目中如果需要print出对象的具体信息，需要让对象可以转换成String

这个时候就需要如下2个步奏(对struct,enum也适用)：

①添加一个属性“description”

var description：String {
     get{
         return ....
     }
} 

②并且需要这个对象加上一个协议：Printable

完整例子：

enum op:Printable{
     case Operand(Double)
     case UnaryOperation(String,Double->Double)
     case BinaryOperation(String,(Double,Double)->Double)

     var description:String {
          get{
               switch self {
                    case .Operand(let operand):
                         return "\(operand )"
                    case .UnaryOperation(let symbol,_):
                         return symbol
                    case .BinaryOperation(let symbol,_):
                         return symbol
               }
          }
     }
}

8.在swift中你可以在一个func中嵌套另外一个func

func test(){
     func say(word:String){
          print(word)
     }
     say("hello")
     say("world")
}

9.我们一直讨论过的Optional就是一个enum类型

enum Optional<T> {
     case None
     case Some<T>
}

如：

let x:String? = nil
//实际等于
let x = Optional<String>.None

let x:String? = "hello"
//实际等于
let x = Optional<String>.Some("hello")

所以说解包一个optional （感叹号加后面）
let y = x!
实际上等于：

switch x{
     case Some(let value): y = value;
     case None: //抛出一个异常
}

10.如果要遍历一个Array 可以使用for in

//用一个tuple（元祖）配合for in 遍历一个Dictionary
for (key,value) in dictionary {
     print("key is \(key) = \(value)")
}

11.range的用法

let array = ["a","b","c","d","e"]
//[c,d,e]
let subArray = array[2...4] 
//[c,d]
let subArray1 = array[2..<4]

12.函数的参数名

在swift中如果一个函数需要多个参数，一般第一个参数不需要externalName 因为一般函数的第一个参数跟函数名要有对应关系

比如如下一个函数：

func getSomeById(id:String,secondExternalName secondInternalName:String){
   ...
}

函数名是getSomeById那么一般第一个参数就是id
但是第二个参数需要加上externalName，因为对于第二个参数用户并不知道要传入什么信息。所以这个时候externalName就显的很重要了
所以调用起来如下：

let result = getSomeById(1,secondExternalName:2)

13.什么时候，并且何时使用willSet/didSet:

很常见的用在UI的更新方面，比如你要更新某个数据，更新数据一般意味着界面也要做出更新，那么在willSet和didset{}里面就可以对界面做对应的更新

需要注意的是：用 willSet /didSet不能和get/set共同使用的，在使用willSet /didSet时，变量需要有初始值。

如果在一个属性声明前加上 lazy 关键字 表示这个属性只有在被用到的时候才会被初始化。
只有var申明的属性才可以搭配lazy关键字

14.Array的一些总结

1.一个Array可以用 += 符号加上另一个Array组合成一个新的Array

这里要注意的是 += 号后面的参数必须要是一个Array。
所以如果你要往一个Array中加入一个String，必须写成 a += [“test”]

2.可以通过 array.first 和 array.last 来返回array的第一个个元素和最后一个元素

3.append(T)——可以往Array中添加一个元素

4.insert(T, atIndex: Int)—— 往Array中指定位置添加一个元素

var a = [a,b,c]
a.insert(d, atIndex: 1)  //a = [a,d,b,c]

5.splice(Array, atIndex: Int)—— 往Array中的指定位置添加一组数组

var a = [a,b,c]
a.splice([d,e], atIndex:1) //a = [a,d,e,b,c]

6.removeAtIndex(Int) ——移出指定位置的元素

7.removeRange(Range)——移出指定范围的元素

var a = [a,b,c] 
a.removeRange(0..<2) , a = [c]

8.replaceRange(Range, [T])

var a = [a,b,c] 
a.replaceRange(0...1,with:[x,y,z]) , a = [x,y,z,b])

9.sort((T,T)->bool) ——对array进行排序，参数是一个函数，判断两个值谁更大。

var a = [a,b,c]
a.sort( $0 < $1)

10.filter(includeElement:(T) -> bool) -> [T]—— 返回一个新的数组过滤掉你不想要的元素

11.map( transform: (T) -> U) -> [U]——array映射，返回一个新array，旧array元素通过transform映射函数生成新array中的元素

let Stringified:[String] = [1,2,3].map( "\($0)" )

12.reduce(inital:U, combine:(U, T) -> U ) -> U——通过指定的计算方法，把一个数组计算生成一个参数

let sum:Int = [1,2,3].reduce(0,{ $0 + $1 }) 
====> 0 + 1 + 2 + 3

13.Array 和 String可以互相转换

let a = Array("abc") //a = ["a","b","c"]
let s = String(["a","b","c"]) //s = "abc"