Swift:蘋果在2014年推出的面向?qū)ο箝_發(fā)的語言,用來撰寫OS X 和 iOS 應(yīng)用程序的強類型語言,順帶提一下Chris Lattner~克里斯·拉特納Swift的親爹,Swift的大部分基礎(chǔ)架構(gòu)均由他1人完成,他本人也對Swift的開源化作出了貢獻(xiàn).

語言特點:讓開發(fā)變得 ---> 簡快穩(wěn)

• 語法簡單、代碼簡潔懊蒸、使用方便
• 可以和Objective-C混合使用;
• 提供了命名空間(namespace)垄懂、泛型(generic)谅辣、運算對象的重載(operator overloading)

Swift基本語法

• 導(dǎo)入框架import UIKit
• 語句結(jié)束不需要加 ;
• 打印語句print(內(nèi)容)
• 定義標(biāo)識符時,必須聲明標(biāo)識符是變量還是常量 ,使用let聲明常量,使用var聲明變量.標(biāo)識符的類型必須和你賦給它們的值一樣.聲明的同時賦值,編譯器會自動判斷類型的方式稱作類型推導(dǎo)

import UIKit
var a = 20
a = 30
var b : Int = 40
let value1 = 7.0
let value2 :Double = 7.77

Swift中基本運算

Swift中在進(jìn)行基本運算時必須保證類型一致,同類型之間才可以進(jìn)行運算,Swift中沒有隱式轉(zhuǎn)換

let label = "hello world "
let width = 50
let widthLabel = label + String(width)
print(widthLabel) // "hello world 50"

if語句

• 判斷句可以不加()
• 判斷句中必須有明確的真假(不再有非0即真)
• 條件必須是Bool表達(dá)式,取值:true/false

let score = 87

if score < 60 {
    print("不及格")
} else if score <= 70 {
    print("及格")
} else if score <= 80 {
    print("良好")
} else if score <= 90 {
    print("優(yōu)秀")
} else {
    print("完美")
}

三目運算符

var a = 10
var b = 50

var result = a > b ? a : b
println(result) // 50

guard的使用

• guard是Swift新增語法.
• guard語句必須帶有else語句當(dāng)條件表達(dá)式為true時候跳過else語句中的內(nèi)容挠进，執(zhí)行語句組內(nèi)容;條件表達(dá)式為false時候執(zhí)行else語句中的內(nèi)容爽室，跳轉(zhuǎn)語句一般是return亿遂、break吃既、continue和throw

guard 條件 else {
    //條件語句
    break
}
代碼...

例:

var age = 18

func online(age : Int) -> Void {
    guard age >= 18 else {
        print("回家去")
        return
    }

    print("可以上網(wǎng)")
}

online(age) // 可以上網(wǎng)

switch

• 蘋果對switch進(jìn)行了加強,swich后可以不加() ,case后可以不跟break(默認(rèn)會有)

let sex = 0

switch sex {
case 0 :
    print("男")
case 1 :
    print("女")
default :
    print("其他")
}

• 一個case可以判斷多個值 以,隔開

let sex = 0

switch sex {
case 0, 1:
    print("正常人")
default:
    print("其他")
}

• case的穿透,可以使用關(guān)鍵字fallthrough

let sex = 0

switch sex {
case 0:
    fallthrough
case 1:
    print("正常人")
default:
    print("其他")
}

• 支持多種數(shù)據(jù)類型:字符串,浮點型,重點提一下區(qū)間型
  開區(qū)間: 0..<10 表示:0-9
  閉區(qū)間: 0...10 表示:0-10

let score = 88

switch score {
case 0..<60:
    print("不及格")
case 60..<80:
    print("幾個")
case 80..<90:
    print("良好")
case 90..<100:
    print("優(yōu)秀")
default:
    print("滿分")
}

循環(huán):for/while/do while

//一般寫法
for var i = 0; i < 5; i++ {
    print(i)
}
//特殊寫法:如果不需要用到下角標(biāo)
for _ in 0..<5 {
    print("666666")
}
//需要用到下角標(biāo)的區(qū)間循環(huán)
for i in 0..<5 { // 0-4
    print(i)
}

for i in 0...5 { // 0-5
    print(i)
}
//while后面()可以省略
var a = 0
while a < 10 {
    a++
}
//do while循環(huán):使用repeat關(guān)鍵字代替do
var b = 0
repeat {
    print(b)
    b++
} while b < 10

Swift中的字符串String

OC和Swift中字符串的區(qū)別:

• 在OC中字符串類型時NSString,在Swift中字符串類型是String
• OC中字符串@"",Swift中字符串""
• String 是一個結(jié)構(gòu)體，性能更高
• NSString 是一個 OC 對象号显，性能略差
• String 支持直接遍歷
• Swift 提供了 String 和 NSString 之間的無縫轉(zhuǎn)換

//字符串的遍歷
var str = "Hello, Swift"
for c in str.characters {
    print(c)
}
//字符串的拼接
let str1 = "Hello"
let str2 = "World"
let str3 = str1 + str2 // "HelloWorld"

//和其他數(shù)據(jù)類型的拼接 使用 \\\\\\\\()
let name = "shei"
let age = 18
let info = "my name is \\\\\\\\(name), age is \\\\\\\\(age)"

//字符串的格式化
let min = 3
let second = 4
let time = String(format: "%02d:%02d", arguments: [min, second]) // 03:04

//字符串的截取
//只提簡單的方式,將String轉(zhuǎn)成NSString來使用.格式:(標(biāo)識符 as NSString)
let myStr = "www.baidu.com"
var subStr = (myStr as NSString).substringFromIndex(2)
subStr = (myStr as NSString).substringToIndex(3)
subStr = (myStr as NSString).substringWithRange(NSRange(location: 4, length: 5))

數(shù)組(Array):你猜對了沒有NS開頭,swift中的數(shù)組是一個泛型集合.let修飾不可變數(shù)組;var修飾可變數(shù)組.

//聲明一個Array類型
var array1:Array<String>
var array2: [String]

// 定義一個可變數(shù)組,必須初始化才能使用
var array3 : [String] = [String]()
// 定義一個不可變數(shù)組
let array4 : [NSObject] = ["666", 66]

// 定義時直接初始化
var array5 = ["Sasuke", "Naruto", "Sakura"]
// 先定義,后初始化
var array6 : Array<String>
array6 = ["Sasuke", "Naruto", "Sakura"]

//對數(shù)組的操作 
//增
array6.append("abc")
//刪
array6.removeLast()
//改
array6[0] = "IU"
//查
array6[2]

//數(shù)組的遍歷
// 遍歷數(shù)組
for i in 0..<array6.count {
    print(array6[i])
}

// forin方式
for item in array6 {
    print(item)
}

// 設(shè)置遍歷的區(qū)間
for item in array6[0..<2] {
    print(item)
}

//數(shù)組的合并
// 注意:只有相同類型的數(shù)組才能合并
var huo = ["Sasuke", "Naruto"]
var ying = ["Sakura"]
var huoYing = huo + ying;

字典:swift中的字典Dictionary,是個泛型集合

// 定義一個可變字典
var dict1 : [String : NSObject] = [String : AnyObject]()
// 定義一個不可變字典
let dict2 = ["name" : "Sakura", "age" : 18]

//聲明
var dict3: Dictionary<Int, String>
var dict4: [Int: String]

// 定時字典的同時,進(jìn)行初始化
var dict = ["name" : "Sakura", "age" : 18]
// swift中任意對象,通常不使用NSObject,使用AnyObject
var dict : Dictionary<String, AnyObject>
dict = ["name" : "Sakura", "age" : 18]

//增
dict["height"] = 1.75
dict["weight"] = 62.0
//刪
dict.removeValueForKey("name")
//改
dict["name"] = "abc"
//查
dict["name"]

//遍歷字典
// 遍歷字典中所有的值
for value in dict.values {
    print(value)
}
// 遍歷字典中所有的鍵
for key in dict.keys {
    print(key)
}

// 遍歷所有的鍵值對
for (key, value) in dict {
    print(key)
    print(value)
}

//字典的合并:字典不可以相加合并
var dict1 = ["name" : "hz", "age" : 20]
var dict2 = ["height" : 1.80, "phoneNum" : "114"]
for (key, value) in dict1 {
    dict2[key] = value
}

元組

• 元組:swift中特有的,它是一種數(shù)據(jù)結(jié)構(gòu),類似字典或數(shù)組,用于定義一組數(shù)據(jù),內(nèi)容成為元素.

//使用方法一
let man = ("mfk",27)
print(man.0) //通過.角標(biāo)的形式取值
print(man.1)

//使用方法二
let man = (name : "mfk", age : 27)
print(man.name) //通過取別名的方式取出值
print(man.age)

//使用方法三
let (name, age)= ( "mfk",  27)
print(name) 
print(age)

可選類型:在swift開發(fā)中,nil是一個特殊的類型,由于賦值時要明確真實類型,所以不能賦值為nil.但開發(fā)中需要賦值nil,因此推出可選類型.

• 取值包括空值和有值
• 定義可選類型一般使用語法糖

//定義的一般寫法
let name : Optional<String> = nil // 使用關(guān)鍵字Optional
//語法糖
let name : String? = nil //可選類型中只能存放字符串
name = "mfk"
print(name)  // Optional("mfk")\\\\\\\\n 打印結(jié)果是可選類型的字符串

print(name!) //mfk\\\\\\\\n 相當(dāng)是一個強制解包操作,此操作是危險的
//注意:若果可選類型是nil,強制解包,系統(tǒng)會報錯.要進(jìn)行一次判斷
if name != nil {
   print(name!)
}
//簡單寫法(可選綁定)
if let nameStr = name {
   print(nameStr)
}

函數(shù)

• 格式: func 函數(shù)名(標(biāo)識符 : 數(shù)據(jù)類型 , 等等) -> 返回值類型 {
  代碼塊
  return 返回值
  }
• func為關(guān)鍵字,形參列表內(nèi)多個參數(shù)之間用,號隔開(可以沒有參數(shù)).箭頭是指向的意思,沒有返回值可以寫Void,也可以省略不寫,具體看代碼部分

// 1.沒有參數(shù),沒用返回值
func about() -> Void {
    print("666666")
}
// 調(diào)用函數(shù)
about()

// 簡單寫法
// 如果沒用返回值,Void可以寫成()
func about1() -> () {
    print("666666")
}
// 如果沒有返回值,后面的內(nèi)容可以都不寫
func about2() {
    print("666666")
}

about2()

// 2.有參數(shù),沒用返回值
func callPhone(phoneNum : String) {
    print("打電話給\\\\\\\\(phoneNum)")
}
callPhone(" 110")

// 3.沒用參數(shù),有返回值
func readMessage() -> String {
    return "吃飯了嗎?"
}
var str = readMessage()
print(str)

// 4.有參數(shù),有返回值
func sum(num1 : Int, num2 : Int) -> Int {
    return num1 + num2
}
var result = sum(20, num2: 30)
print(result)

• 在函數(shù)內(nèi)部可以看到的參數(shù),就是內(nèi)部參數(shù)
  在函數(shù)外面可以看到的參數(shù),就是外部參數(shù)
  默認(rèn)情況下,從第二個參數(shù)開始,參數(shù)名稱既是內(nèi)部參數(shù)也是外部參數(shù)
  如果第一個參數(shù)也想要有外部參數(shù),可以設(shè)置標(biāo)簽:在變量名前加標(biāo)簽即可
  如果不想要外部參數(shù),可以在參數(shù)名稱前加_

// num1和a是外部參數(shù)的名稱
func ride(num1 num1 : Int, a num2 : Int, b num3 : Int) -> Int {
    return num1 * num2 * num3
}
var result1 = ride(num1: 20, a: 4, b: 5)

// 方法的重載:方法名稱相同,但是參數(shù)不同,可以稱之為方法的重載(了解)
func ride(num1: Int, _ num2 :Int) -> Int {
    return num1 * num2
}

var result2 = ride(20, 20)

• 默認(rèn)參數(shù):若果沒有傳入具體的參數(shù),可以使用默認(rèn)參數(shù)

func giveme(type :String = "coffee") -> String {
    return "給我\\\\\\\\(type)臭猜。"
}

let me1 = giveme("面包") //給我面包
let me2 = giveme()  // 給我coffee

• 可變參數(shù): 可以接受不確定數(shù)量的輸入類型參數(shù),它們必須具有相同的類型,通過在參數(shù)類型名后面加入（...）的方式來指示這是可變參數(shù)

func sum(numbers:Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total
}

sum(100.0, 200, 300)
sum(3.3, 10.1)

• 引用類型(指針類型):默認(rèn)情況下,函數(shù)的參數(shù)是值傳遞.如果想改變外面的變量,則需要傳遞變量的地址,必須是變量,因為需要在內(nèi)部改變其值,Swift提供的inout關(guān)鍵字就可以實現(xiàn)

// 函數(shù)一:值傳遞
func swap(var a : Int, var b : Int) {
    let temp = a;
    a = b;
    b = temp

    print("a:\\\\\\\\(a), b:\\\\\\\\(b)")
}

var a = 10
var b = 20
swap(a, b: b)
print("a:\\\\\\\\(a), b:\\\\\\\\(b)")

// 函數(shù)二:指針的傳遞
func swap1(inout a : Int, inout b : Int) {
    let temp = a
    a = b
    b = temp

    print("a:\\\\\\\\(a), b:\\\\\\\\(b)")
}

swap1(&a, b: &b)
print("a:\\\\\\\\(a), b:\\\\\\\\(b)")

• 函數(shù)的嵌套使用:swift中func可以嵌套使用,方法不推薦(可閱讀性差),不多舉例子

Swift 中的類

• Swift 中class為定義類的關(guān)鍵字,定義的類,可以沒有父類.那么該類是rootClass,通常,定義類時繼承自NSObject(非OC的NSObject)
• 類的屬性
  (1)存儲屬性:存儲實例的常量和變量
  • 存儲屬性是最簡單的屬性,它作為類實例的一部分,用于存儲常量和變量;可以給存儲屬性提供一個默認(rèn)值,也可以在初始化方法中對其進(jìn)行初始化.

class Student : NSObject {
    // 定義屬性
    // 存儲屬性
    var age : Int = 0
    var name : String?

    var chineseScore : Double = 0.0
    var mathScore : Double = 0.0
}

// 創(chuàng)建學(xué)生對象
let stu = Student()

// 給存儲屬性賦值
stu.age = 10
stu.name = "why"

stu.chineseScore = 89.0
stu.mathScore = 98.0

(2) 計算屬性:通過某種方式計算出來的屬性

• 計算屬性并不存儲實際的值，而是提供一個getter和一個可選的setter來間接獲取和設(shè)置其它屬性,計算屬性一般只提供getter方法,則該計算屬性為只讀屬性,并且可以省略get{}

class Student : NSObject {
    // 定義屬性
    // 存儲屬性
    var age : Int = 0
    var name : String?

    var chineseScore : Double = 0.0
    var mathScore : Double = 0.0

    // 計算屬性
    var averageScore : Double {
        get {
            return (chineseScore + mathScore) / 2
        }

        // 沒有意義,因為之后獲取值時依然是計算得到的
        // newValue是系統(tǒng)分配的變量名,內(nèi)部存儲著新值
        set {
            self.averageScore = newValue
        }
    }
}

// 獲取計算屬性的值
print(stu.averageScore)

(3) 類屬性:與整個類自身相關(guān)的屬性

• 類屬性是與類相關(guān)聯(lián)的咙轩，而不是與類的實例相關(guān)聯(lián)
  所有的類和實例都共有一份類屬性.因此在某一處修改之后,該類屬性就會被修改,類屬性的設(shè)置和修改,需要通過類來完成

class Student : NSObject {
    // 定義屬性
    // 存儲屬性
    var age : Int = 0
    var name : String?

    var chineseScore : Double = 0.0
    var mathScore : Double = 0.0

    // 計算屬性
    var averageScore : Double {
        get {
            return (chineseScore + mathScore) / 2
        }

        // 沒有意義.newValue是系統(tǒng)分配的變量名,內(nèi)部存儲著新值
        set {
            self.averageScore = newValue
        }
    }

    // 類屬性
    static var corseCount : Int = 0
}

// 設(shè)置類屬性的值
Student.corseCount = 3
// 取出類屬性的值
print(Student.corseCount)

監(jiān)聽屬性的改變

• 在OC中我們可以重寫set方法來監(jiān)聽屬性的改變
• Swift中可以通過屬性觀察者來監(jiān)聽和響應(yīng)屬性值的變化
• 通常是監(jiān)聽存儲屬性和類屬性的改變.(對于計算屬性获讳，我們不需要定義屬性觀察者，因為我們可以在計算屬性的setter中直接觀察并響應(yīng)這種值的變化)
• 我們通過設(shè)置以下觀察方法來定義觀察者
  • willSet：在屬性值被存儲之前設(shè)置活喊。此時新屬性值作為一個常量參數(shù)被傳入丐膝。該參數(shù)名默認(rèn)為newValue，我們可以自己定義該參數(shù)名
  • didSet：在新屬性值被存儲后立即調(diào)用钾菊。與willSet相同帅矗，此時傳入的是屬性的舊值，默認(rèn)參數(shù)名為oldValue
  • willSet與didSet只有在屬性第一次被設(shè)置時才會調(diào)用煞烫，在初始化時浑此，不會去調(diào)用這些監(jiān)聽方法

//監(jiān)聽age和name的變化
class Person : NSObject {
    var name : String? {
        // 可以給newValue自定義名稱
        willSet (new){ // 屬性即將改變,還未改變時會調(diào)用的方法
            // 在該方法中有一個默認(rèn)的系統(tǒng)屬性newValue,用于存儲新值
            print(name)
            print(new)
        }
        // 可以給oldValue自定義名稱
        didSet (old) { // 屬性值已經(jīng)改變了,會調(diào)用的方法
            // 在該方法中有一個默認(rèn)的系統(tǒng)屬性oldValue,用于存儲舊值
            print(name)
            print(old)
        }
    }
    var age : Int = 0
    var height : Double = 0.0
}

let p : Person = Person()

// 在賦值時,監(jiān)聽該屬性的改變
// 在OC中是通過重寫set方法
// 在swift中,可以給屬性添加監(jiān)聽器
p.name = "why"

//p.name = "yz"