Swift编程权威指南第2版 读后收获

　　自从参加工做一直在用OC作iOS开发。在2015年的时候苹果刚推出swift1.0不久，当时毕竟是新推出的语言，你们也都颇有激情的学习。不过在学完后发现很难在实际项目中使用，再加上当时公司项目都是基于OC来作的开发，就把swift放一边了。

　　后来也不断看到网上对swift的各类评价，有好有坏，总之是一门刚推出的语言吧。语法设计，与OC无缝衔接等存在一些问题仍是能够接受的。

　　自从2017年9月苹果推出swift4.0后，基本大的语法变更没有了。慢慢的有不少公司开始使用swift开发公司项目了。这也说明swift已经稳定的能够解决实际项目问题了。

　　2018年由于工做变更，入职如今的公司。公司的项目是大部分基于swift开发，少许使用OC。这个时候我感受须要系统学习下swift了。在网上搜了搜有没有比较好的swift书籍。看了不少评价发现《Swift编程权威指南》不管从入门难度仍是讲解方式都挺适合个人。索性就选它了。我是用kindle看的。时间是在上下班的地铁上和下班后的休息时间。先后用时一个月左右。

　　阅读这本书对个人感觉仍是挺多的。索性把读完的感觉写下来。由于人的记忆力太弱了，一星期忘一半，二星期忘七成。我怕不写下来。半年后我基本上不记得说了都是讲什么了。

　　这里讲的基本上是与OC的对比，还后后面三章的三个项目做者的开发方式对我目前开发方式的反思。

 

1、swift对比OC来讲它要表达的哲学是：安全，简洁。

这两点在平时的编程中无处不在，举个例子：

classDog: NSObject{
    letorigin: String= "中国"
    fileprivatevarname: String?
    privatevarage: Int?
    
    init(_name: String?, age: Int= 1) {
        self.name= name ?? "旺财"
        self.age= age
    }
}

　　定义了一个Dog类，一个常量“origin”，当一个变量被定义成let型，则只能被赋值一次。“name”和”age”是两个可空类型的变量。重载了一个init方法，在init方法中有两个形参。“name”为可空类型，”age”的默认值为一。在init方法中将这两个变量赋值给属性。其中判断name有值就设置name,为空时设置默认值“旺财”。

　　定义一个类只需这么几行代码，相比OC简洁了不少。安全上：显示标识出哪些变量可空，哪些变量不可修改。即提升了性能，又提升了安全性。

 

2.OC中的block代码块被swift中的闭包替代

在swift中，函数也是一等公民，同基本类型同样。能够作属性，函数参数，返回值自由使用。

其定义方式同OC区别很大，如：

swift定义与OC的定义

    let sum: ((Int,Int) -> Int) = {(a, b) in
            returna + b
     }
     let res = sum(1, 2)
     print(res)

    int(^SumBlock) (int, int) = ^(intx, inty) {
        return  x + y;
    };

 

3.字符串使用的区别

对于平时使用较多的字符串处理，变化仍是比较大的。

let str = "hello world"
var str0 = str.prefix(2)//前两个
var str1 = str.suffix(2)//后两个
        
let index0 = str.index(str.endIndex, offsetBy: -4)
var str2 = str[index0..<str.endIndex]//后4个
        
let index1 = str.index(str.startIndex, offsetBy: 4)
var str3 = str[str.startIndex..<index1]//前4个

与OC的对比

    NSString*str = @"hello world";
    id str0 = [str substringToIndex:2];
    id str1 = [str substringFromIndex:str.length-2];
    id str2 = [str substringWithRange:NSMakeRange(2, 3)];

 

4.在swift中，结构体的使用很是普遍，它的做用和用法与类类似，主要区别是结构体不能被继承。因此考虑到若是类型不会被继承生成子类，均可以使用结构体替换。此外结构体嵌套也是swift与OC相比变化较大的部分。

struct Animal {
    let region = "中国"
    var name: String?
    var color = UIColor.red
     
    init(name: String,color: UIColor) {
        self.name= name
        self.color= color
    }
    
    struct Dog {
        let legNum = 4
        func run() -> String{
            return"跑回家"
        }
    }
}

 

5.枚举。

swift提供的枚举比OC强大太多。枚举中能够继续定义枚举，结构体，类，方法。很是灵活。

 

enum SDCEnumType: Int{
    case circle = 20
    case check
    
    func enumTypeString(type: SDCEnumType) -> String{
        switch type {
        case .circle:
            return"circle"
        default:
            if type.rawValue== 21{
                return"check"
            } else{
                return"其余状况"
            }
        }
    }
    
    enum SDCEnumSubType {
        case square(SDCEnumType)
        case ellipse(SDCEnumType)
    }
}

 

6.swift提供的协议也是很是的灵活,能够进行协议扩展，协议继承，定于初始化方法，协议关联等。

protocol Student {
    var name: String{getset}
    var age: Int{get}
    static func study(date:Date) -> Date
    
    init(name:String)
}
extension Student{
    var score:Float{
        return80.8
    }
    
}
protocol Childe:Student{
    
}

 

7.后面的Mac,iPhone,OC与Swift混合项目让我对编程过程的理解：

1.平时不多关注Mac程序开发，这本书在后面的例子中写了一个Mac应用的demo。算是对Mac应用有了必定的认识。

2.编程步骤分两步：

一，实现功能。

二，进行设计模式调整。

这个两个步骤在平时的编程中，我只是进行代码实现，对于完成功能后的设计模式优化却没有作。想一想工做了这么久，编程都是只走了一半，真是汗颜。

 

8.范型的使用。

在OC中范型经常使用的场景是对集合内容的限制，而在swift中，范型已经涉及到函数。这样瞬间使函数的战斗力增长了10倍。

swift是强类型语言，同一个运算符两边的类型必须是一致的。

func SwapTwoValues <T> (inout a: T,inout b :T){
    let  tempValue = a
    a = b
    b = tempValue
}
 
structIntStack{
    var items = [Int]()
    //压栈
    mutating func push(item:Int){
        items.append(item)
    }
    //出栈
    mutating func pop()->Int{
        return items.removeLast()
    }
}
 
struct Stack<Ele>{
    var items = [Ele]()
    mutating func push(item:Ele){
        items.append(item)
    }
    mutating func pop()->Ele{
        return items.removeLast()
    }
}

 

9.在swift中，每一个运算符其实也是一个函数。这个与OC比起来有着概念性的差异。

 

//前置运算符，表示2的var0次方
prefix operator ^
prefix func^ ( var0: Double) -> Double{
    return pow(2, var0)
}
//后置运算符，表示var0的2次方
postfix operator ^
postfix func ^ (var0: Double) -> Double{
    return var0*var0
}