Swift 3.0學習總結

1.數據類型

1).元組

//元組賦值
let http404Error = (404,"Not Found");
//元組分解
let (statusCode,statusMessage) = http404Error;
//元組分解不須要的用_代替
let (justTheStatusCode,_) = http404Error;
//索引數字訪問元組
print(http404Error.0,http404Error.1);
print(statusCode,statusMessage,justTheStatusCode);
//給元組內部元素命名，能夠經過其訪問元素
let http200Status = (statusCode:200,description:"OK");
print(http200Status.statusCode,http200Status.description);

 2).類型轉換

swift沒有隱式轉換，數據類型須要轉換到相同類型才能共同操做。

let m = 3；
let n = 2.14；
let result = Double(m)+n;

2.運算符

1).??

合併空值運算符 （ a ?? b ）若是可選項 a  有值則展開，若是沒有值，是 nil  ，則返回默認值 b 。表達式a 必須是一個可選類型。表達式 b  必須與 a  的儲存類型相同。

a != nil ? a! : b

let defaultColorName = "red"
var userDefinedColorName: String? // defaults to nil
var colorNameToUse = userDefinedColorName ?? defaultColorName

print(colorNameToUse) //red

2).閉區間運算符（ a...b ）

3).半開區間運算符（ a..<b 

for index in 1...5 {
    print("\(index) times 5 is \(index * 5)")
}
for index in 1..<5 {
    print("\(index) times 5 is \(index * 5)")
}

3.集合類型

1).遍歷數組的key和value

使用 enumerated()方法來遍歷數組。 enumerated()方法返回數組中每個元素的元組，
包含了這個元素的索引和值。你能夠分解元組爲臨時的常量或者變量做爲遍歷的一部分：
for (index, value) in shoppingList.enumerated() {
    print("Item \(index + 1): \(value)")
}

2).有序遍歷合集

Swift 的 Set類型是無序的。要以特定的順序遍歷合集的值，使用 sorted()方法，
它把合集的元素做爲使用 < 運算符排序了的數組返回。
for genre in favoriteGenres.sorted() {
    print("\(genre)")
}
// Classical
// Hip hop
// Jazz

3).Dictionary的鍵值能夠任意值

Set<Element>,Dictionary<Key, Value>，其中的Element,Key是用來做爲字典鍵的值類型， 
Value就是字典爲這些鍵儲存的值的類型。
值類型是遵循Hashable協議.全部 Swift 的基礎類型（好比 String, Int, Double, 和 Bool）
默認都是可哈希的，而且能夠用於合集或者字典的鍵。
沒有關聯值的枚舉成員值（如同枚舉當中描述的那樣）一樣默承認哈希。

就像數組，你能夠用初始化器語法來建立一個空 Dictionary：
var namesOfIntegers = [Int: String]()

2.邏輯語句

1).數字範圍縮寫

//半開半閉區間 0~9 => 0..<10
//閉區間 0~9 => 0...9

let source = 72;

switch source{
case 0..<60:
    print("不及格");
case 60...80:
    print("及格");
default:
    break;
}

2).if

    判斷的條件必須只能是Bool類型，再也不存在非0即真

    新增guard，else語句中通常是return、break、continue和throw

func online(age:Int){
    
    guard age >= 18 else{
        print("未成年");
        return;
    }
    
    guard age <= 60 else{
        print("年齡太老");
        return;
    }
    
    guard age < 30 || age > 50 else{
        print("回家");
        return;
    }

    print("能夠上網");
}

online(40);

3).switch

//switch 支持int、string、dobule
//1.swift switch默認case後補break，若是想要穿透使用fallthrough
let sex = 0;

switch sex {
case 0:
    print("人妖");
    fallthrough;
case 1:
    print("男");
case 2:
    print("女");
default:
    print("未知")
}

//2.數字範圍縮寫
//半開半閉區間 0~9 => 0..<10
//閉區間 0~9 => 0...9

let source = 72;

switch source{
case 0..<60:
    print("不及格");
case 60...80:
    print("及格");
default:
    break;
}

3.循環語句

1)for

//swift3只支持這種寫法了
for i in 0..<10{
    print(i);
}

//不須要用到下標
for _ in 0...10{

2)while

var m = 0;
while m < 10 {
    m += 1;//swift3再也不支持m++這種寫法了
    print(m);
}

repeat {
    m -= 1;
}while m > 0

4.函數

//內部參數 忽略參數名
func sum(num1:Int,_ num2:Int) ->Int{
    return num1+num2;
}
sum(2,5);

//可變函數
func sums(nums:Int...) ->Int{
    var total = 0;
    for n in nums{
        total += n;
    }
    return total;
}
sums(2,3,4,5,6);

//默認函數
func sex(s:String = "女"){
    print("sex:\(s)");
}
sex()

//指針函數
var m:Int = 3;
var n:Int = 2;

func swapNum(num1:inout Int,num2:inout Int){
    let temp = num1;
    num1 = num2;
    num2 = temp;
}

swapNum(&m, num2: &n);
print("m:\(m) n:\(n)");

5.枚舉

//1.枚舉類型的定義以及寫法
enum MethodType1{
    case get
    case post
    case put
    case delete
}

enum MethodType2:String {
    case get="get"
    case post="post"
    case put="put"
    case delete="delete"
}

enum MethodType3 {
    case get,post,put,delete
}

//2.建立枚舉具體的值
let type1 : MethodType1 = .get
let type2 = MethodType1.get
let type3 = MethodType1(rawValue:"put")
let str = type3?.rawValue

6.結構體

結構體是值類型，在方法中是值傳遞（對象是對象類型，在方法中是指針傳遞）

//1.定義結構體
struct Location {
    //成員屬性
    var x : Double
    var y : Double
    
    //方法
    func test() {
        print("...")
    }
    
    //改變成員屬性：涉及到改變成員屬性的方法前需加上mutating
    mutating func moveH(distance : Double) {
        self.x += distance
    }
    
    //構造函數
    //1.默認下，會爲結構體初始化一個帶全部屬性的構造函數
    //2.構造函數都是以init開頭，而且構造函數不須要返回值
    //3.新構造的構造函數，必須保證因此的成員屬性都被初始化
    init(x : Double, y: Double) {
        self.x = x
        self.y = y
    }
    
    //擴充構造函數
    init(xyStr : String) {
        let array = xyStr.components(separatedBy: ",")
        let item1 = array[0]
        let item2 = array[1]
        
        //Double(item1)是可選類型，有可能值爲nil。若是強制解包let x = Double(item1)！ 可能會崩潰
        /*
        if let x = Double(item1) {
            self.x = x
        }else{
            self.x = 0
        }
        if let y = Double(item2) {
            self.y = y
        }else{
            self.y = 0
        }*/
        
        //是上面的縮寫，當值爲nil的時候等於後值
        self.x = Double(item1) ?? 0
        self.y = Double(item2) ?? 0
    }
}


//2.建立結構體
let center = Location(x: 20, y: 30)
let moveH = Location(xyStr:"20,30")

7.類

1).類的定義

//1.OC定義類
//@interface Person : NSObject
//@end
//
//@impelment
//@end

//2.Swift定義類
class Person {
    
    //若是屬性是值類型，則初始化爲空值
    //若是屬性是對象類型，則初始化爲nil值（？的默認值是nil）
    
    //1.存儲屬性:用戶存儲實例的常量和變量
    var mathScore : Double = 0.0
    var chineseScore : Double = 0.0
    
    var view : UIView?
    
    //2.計算屬性:經過某種方法計算得來結果的屬性，就是計算屬性
    var averageScore : Double {
        
        //簡介寫法
        //在類內部訪問屬性不須要加self.
        return (chineseScore + mathScore) * 0.5
        
        //完整寫法
        /*
        set {
            
        }
        
        get {
            return (chineseScore + mathScore) * 0.5
        }
         */
        
    }
    
    //3.類屬性 : 經過類名進行訪問
    static var courseCount : Int = 0
    
    
    //OC中處理參數的方法 在swift中能夠寫成計算屬性
    func getAverageScore() -> Double {
        return (chineseScore + mathScore) * 0.5
    }
}

//3.建立類的對象
let p = Person()
//類儲存屬性
p.view = UIView()
//類計算屬性
p.mathScore = 90
p.chineseScore = 100
print(p.averageScore)
//類屬性設置
Person.courseCount = 2

2.屬性監聽

class Person {
    
    var name : String = ""{
        
        //監聽屬性即將改變
        willSet(newValue){
            print(newValue) //打印新值 = "why"
            print(name)     //打印舊值 = ""，屬性還沒改變
        }
        //監聽屬性已經發生改變
        didSet(oldValue){
            print(oldValue) //打印舊值 = ""
            print(name)     //打印新值 = "why",屬性已經改變
        }
    }
}

let p = Person()
p.name = "why"

3.構造函數

/*
 使用KVC條件
   1>必須繼承自NSObject
   2>必須在構造函數中，先調用super.init()
   3>調用setValuesForKeys
   4>若是擔憂新建對象的時候，字典裏含有的key不屬於成員變量，則複寫setValue forUndefinedKey
 */

class Person:NSObject {
    
    var name : String = ""
    var age  : Int = 0
    
    //若是須要擴展構造函數，須要先實現init，不然會被覆蓋
    override init(){
        
    }
    
    init(dict : [String : Any]) {
        //swift開發中，若是在對象函數中，用到成員屬性,那麼self.能夠省略
        //可是若是在函數中，有和成員屬性重名的局部變量，那麼self.不能省略
        
        //通用屬性少的時候咱們能夠這樣寫
        /*
         if let name = dict["name"] as? String {
         
         self.name = name;
         }
         if let age = dict["age"] as? Int {
         self.age = age;
         }
         */
        
        //屬性多的時候咱們能夠使用KVC賦值
        super.init()
        setValuesForKeys(dict)
    }
    
    override func setValue(_ value: Any?, forUndefinedKey key: String) {}
    
}

let p = Person()
let e = Person(dict:["name":"why","age":18,"height":1.88])
print(e.age,e.name)

4.析構函數

//和OC的delloc方法同樣，監聽對象的銷燬
class Person:NSObject {
    
    var name : String = ""
    var age  : Int = 0
    
    //重寫析構函數，監聽對象的銷燬
    deinit {
        print("delloc")
    }
}

var p : Person? = Person()
p = nil

5.循環引用

class Person {
    var book : Book?
    
    deinit {
        print("person -- deinit")
    }
}

class Book {
    
    /*
     OC中的標識弱引用
      __weak/__unsafe_unretianed(當對象釋放了，指針依然指向舊地址，因此容易野指針)
     Swift中表示弱引用
      weak/unowned(野指針)
     */
    
    //unowned 不能修飾可選類型
//    unowned var person : Person = Person()
    weak var person : Person?
    
    deinit {
        print("book -- deinit")
    }
    
}

var person : Person? = Person()
var book : Book? = Book()

person!.book = book;
book!.person = person;

//若是不使用弱引用這個時候析構函數不打印
person = nil;
book = nil;

6.可選鏈使用

class Person {
    var name : String = ""
    var dog : Dog?
}
class Dog {
    var weight : Double = 0
    var toy : Toy?
}
class Toy {
    var price : Int = 0
    
    func flying(){
        print("fly")
    }
}

let p = Person()
p.name = "why"
let d = Dog()
d.weight = 100.5
let t = Toy()
t.price = 5

p.dog = d
d.toy = t

//可選鏈 .? 系統會自動判斷可選類型是否有值
//可選鏈--取值
/*
 寫法很是危險，儘可能不要強制解包
let dog = p.dog
let toy = dog!.toy
let price = toy!.price
 */

/*
 寫法很繁雜
if let dog = p.dog {
    if let toy = dog.toy {
        let price = toy.price
    }
}
 */

let price = p.dog?.toy?.price

//可選鏈--賦值
p.dog?.toy?.price = 100

//可選鏈調用方法
p.dog?.toy?.flying()

8.協議

//: Playground - noun: a place where people can play

import UIKit

var str = "Hello, playground"

//1.協議的定義，默認協議中的方法都是必須實現
protocol SportProtocol {
    func playBasketll()
}

//2.遵照協議,能夠遵循多個協議，逗號個隔開
class Teacher : NSObject,SportProtocol{
    func playBasketll() {
        print("踢足球")
    }
}

//3.協議的代理設計模式
/*
 定義協議時，協議後面最好跟上:class，
由於delegate的屬性避免循環引用，用week修飾，而week只能修飾類、屬性。協議能夠被類遵照，也能夠被枚舉、結構體
 */
protocol BuyTicketDelegate : class {
    func buyTicket()
}

class Person {
    
    //定義代理屬性
    weak var delegate : BuyTicketDelegate?
    
    func gotoBeijing() {
        delegate?.buyTicket()
    }
}

class Stundnt : BuyTicketDelegate {

    internal func buyTicket() {
        print("買票")
    }
}

let p = Person()
let s = Stundnt()
p.delegate = s
s.buyTicket()


//4.協議的可選方法
//optional屬於OC特性，若是協議中有可選方法，那麼必須在protocol前加@objc
@objc protocol TestPro {
    @objc optional func test()
}

9.檢查API的可用性

Swift 擁有內置的對 API 可用性的檢查功能，它可以確保你不會悲劇地使用了對部屬目標不可用的 API。

if #available(iOS 10, macOS 10.12, *) {
    // Use iOS 10 APIs on iOS, and use macOS 10.12 APIs on macOS
} else {
    // Fall back to earlier iOS and macOS APIs
}