swift小結01--基礎篇

2014年推出的swift目前已來到了3.0，日趨穩定，這個是之前學習整理的關於swift的資料，分享給大家，希望有用，寫的不足的地方還請見諒。

語言背景：

        Swift 語言由蘋果公司在 2014 年推出，用來撰寫 OS X 和 iOS 應用程式。

 

 語言優勢：

• 讓應用開發更簡單、更快、更穩定
• 確保最終應用有著更好的質量

 

一些簡單的特點：  

1. 不用；號結束
2. 方法和屬性都是用.來使用  區別是方法後有( ),而屬性沒有( )
3. 在 Swift 中使用 print() 替代 OC 中的 NSLog
4. 在 Swift 中要例項化一個物件可以使用 類名() 的格式，與 OC 中的 alloc/init 等價
5. OC 中的 [[類名 alloc] initWithXXX], [類名 類名WithXXX]在 Swift 中通常可以使用 類名(XXX: ) 找到對應的函式
6. OC 中的 [UIColor redColor] 類方法，在 Swift 中通常可以使用 類名.XXX() 找到對應的函式

 

常量和變數

• 在Swift中規定:在定義一個識別符號時必須明確說明該識別符號是一個常量還是變數
• 使用let來定義常量,定義之後不可以修改
• 使用var來定義變數,定義之後可以修改
• Swift中型別要求異常嚴格,不一樣的型別不能直接操作
• Swift中所有型別的第一個字母都是大寫的:Double, Int, Float, String
• Swift中型別轉換 型別(要轉換的物件)   如果不想讓Swift自動推導型別,可以在定義的時候指定型別

型別強轉有2種方式 let aa:Float = 值     let aa = Float(變數/值)

 

---

Swift中基本運算

• Swift中在進行基本運算時必須保證型別一致,否則會出錯
  • 相同型別之間才可以進行運算
  • 因為Swift中沒有隱式轉換
• 資料型別的轉化
  • Int型別轉成Double型別:Double(識別符號)
  • Double型別轉成Int型別:Int(識別符號)

 

 

---

字串

• • OC和Swift中字串的區別
    • 在OC中字串型別時NSString,在Swift中字串型別是String
    • OC中字串@"",Swift中字串""
  • 使用 String 的原因
    • String 是一個結構體（棧裡），效能更高
    • NSString 是一個 OC 物件（堆裡），效能略差
    • String 支援直接遍歷
    • Swift 提供了 String 和 NSString 之間的無縫轉換

 

var str = "及法規和第三"

 

//遍歷字串

for i in str.characters{

    print(i)

}

//字串的長度

let count = str.characters.count

 

//字串與字串的拼接

let a = "hhhhhhh"

let b = "jjjjjjj"

let c = a + " " + b

 

//非字串(需轉換成字串)與字串拼接

let a1 = 23

let b1 = "kkkk"

let c1 = String(a1) + b1

let c2 = "\(a1)"+b1  // "\()"在括號中可以傳入任何型別然後轉變成字串

 

//字串格式化

let p = 3.1415926

let format = String(format: "%f", p)

let format1 = String(format: "%d %f", arguments: [p,p])

 

 

//判斷一個地址是否字尾是gif

//方法一

let add = "www.baidu.com/aa/bb/cc.gif"

//轉小寫

let add1 = add.lowercaseString

//判斷

add1.hasSuffix("gif")

//方法二

//將String轉換NSString

let addr2 = add as NSString

let gif = addr2.substringFromIndex(add.characters.count - 3)

gif == "gif"

 

---

if語句

    Swift沒有非0即真, Bool只有2個值 true表示真, false表示假

    Swift中 if 後面的條件可以不需要()

    Swift中if後面的程式碼即使只有一行,也不能省略{}

    if 後面的條件可以是 Bool型別或者Bool型別的表示式

 

 

let isNb = true

if !isNb {

    print("ture")

}

 

if(isNb){

    print("true")

}

 

let pass = "及格"

let fail = "不及格"

let score = 69

if score > 60{

    print(pass)

}else{

    print(fail)

}

 

//三目運算子  問號前面一定要有一個空格

let ss = score > 60 ?pass : fail

 

---

可選型別

     Swift為了解決忘記對沒有值進行判斷,搞了可選型別,可選型別的作用:時刻提示你,這個變數或常量有可能有值,也有可能沒有,可選如果沒有值為nil

    定義可選: 在普通的變數或常量的型別後面加?

 

 

//定義可選型別,不能直接使用，要先拆包，而拆包前需判斷是否包為空，或者將包賦值

//兩種寫法，一般是第一種

let a:Int? = 1000

let a1 = Int?(1000)

 

//拆包： 變數！ 操作時沒有進行拆包判斷的話，如果包為nil會出錯

 

//拆包需要判斷是否為nil

if a1 != nil{

    let sum1 = a1! + 100

}else{

    print("拆包為空")

}

 

//let aaa = a1這個式子裡先將a1拆包，然後將拆出來的值賦給aaa

if let aaa = a1{

    let sum1 = aaa + 100

}else{

    print("拆包為空")

}

---

for迴圈

 

for var i = 0; i < 5; i++ {

   

}

 

for var i = 0;i < 10; i++ {

   

}

 

for i in 1...9{

    print(i)

}

 

for i1 in 0..<9{

    print(i1)

}

 

 0...5 範圍(區間)運算子: 閉合運算子[a, b], 包含a也包含b: 0,1,2,3,4,5

 0..<5 範圍(區間)運算子: 半閉合運算子[a,b),包含a不包含b: 0,1,2,3,4

---

switch語句

Swift中的每個case後面可以不加break,不會跑到下一個case去執行

    fallthrough: 貫穿,執行下一個case

    如果沒有匹配完所有的條件必須使用default

    

let score = 77

switch score {

    case 90...100:

        print("優秀")

    case 80..<90:

        print("良好")

    case 76..<80:

        print("中上")

    case 70...75:

        print("中下")

    case 60..<70:

        print("及格")

        break

    default:

        print("不及格")

        break

}

 

swift中的switch可以匹配String, Float, Bool

 

let weekDay = "Thursday"

switch weekDay {

    case "Monday":

        print("星期一")

    case "Friday":

        print("星期五")

    default:

        print("未知")

}

---

陣列

 OC中定義陣列:

        NSArray *arr = [NSArray array];

        NSArray *arr2 = @[元素1, 元素2, 元素3];

 

    Swift中:

        var修飾的可變陣列

        let修飾的是不可變陣列

 

//陣列

let arr = ["aaa","bbb","ccc"]//[String],元素是sting型別

let arr1 = ["aaa",123]//[NSObject],元素是物件，不建議這樣使用

//指定陣列型別

let arr2 :[Int] = [1,2,3]

//指定了就不能亂賦值

//let arr3 :[String] = ["aaa",123]

 

 

//定義空陣列

let arr3 = [Int]()

let arr4:[Float] = []

 

//遍歷陣列

let arr5 = ["aaa","bbb","ccc"]

for var i = 0;i < arr5.count; i++ {

//    print(arr5[i])

}

 

for value in arr5{

//    print("value :\(value)")

//    print("value:\(value)")

}

 

//可同時獲取下標和原始的值

for value in arr5.enumerate(){

//    print("下標：\(value.index) 元素：\(value.element)")

    /*

    下標：0 元素：aaa

    下標：1 元素：bbb

    下標：2 元素：ccc

    */

}

//另一種寫法

for (a,b)in arr5.enumerate(){

//    print("下標:\(a),元素:\(b)")

}

 

//陣列的增刪改查

var arr6 = ["zhuzhuxia","dawang","xiaoming","55"]

//增加

arr6.append("xxx")//在最後新增

arr6.insert("yyy", atIndex: 0)//在指定下標新增

//刪

arr6.removeLast()//刪除最後一個

//arr6.removeAll()//刪除全部

arr6.removeFirst()//刪除第一個

arr6.removeAtIndex(2)//刪除第幾個

//修改

arr6[2] = "libai"

 

//檢視

arr6.count//陣列的元素個數

arr6.isEmpty//判斷是否為空

 

//陣列相加

let arr7 = [1,2]

let arr8 = [4,5]

let arr9 = ["aa","bb"]

let arr10 = arr7 + arr8  //[1, 2, 4, 5]

//不同型別的陣列不能相加

//let arr11 = arr8 +arr9

---

字典

let dict  = ["name":"libai","age":55] //[String : NSObject]字典key是String,value是NSObjct型別

var dict1 = ["name":"libai","place":"taiwan"]//[String : String]

//指定字典型別

let dict2 :[String:String] = ["name":"gg","xxx":"ggg"]

 

 

//定義空字典

let dict3:[String:String] = [:]

 

let dict7 = [String:String]()

let dict4 = [String : NSString]()

 

let dict5 = [String:NSObject]()

let dict6 = [String:AnyObject]()

 

//通過key值獲取value

let name = dict1["name"]

//遍歷

for obj in dict1{

    print("key = \(obj.0),value = \(obj.1)")

}

for(key1,key2) in dict1{

    print("key = \(key1),value = \(key2)")

}

//增刪改查

//增

dict1["ee"] = "什麼？"

print(dict1)

//刪

dict1["place"] = nil

dict1.removeValueForKey("ee")

//改

dict1["place"] = "guangzhou"

 

//字典不能相加

let dict9 = ["name": "a"]

let dict10 = ["age": "55"]

//let dict11 = dict9 + dict10

//print(dict1)

---

列舉

      /*

    OC定義列舉型別:

        enum Season {

            Spring = 1,

            Summer = 2,

            Autumn = 20,

            Winter

        };

    定義列舉變數

        enum Season s = Spring;

*/

 

// 定義列舉型別

enum Season {

    case Spring

    case Summer

    case Autumn

    case Winter

}

 

// 定義列舉變數: 列舉名稱.成員名稱

var s = Season.Spring

s = Season.Summer

 

// 當要修改列舉可以直接 .成員名稱

s = .Summer

s = .Winter

 

// 列舉switch

switch s {

    case Season.Spring:

        print("春天")

    case Season.Summer:

        print("夏天")

    case .Autumn:

        print("秋天")

    case .Winter:

        print("冬天")

}

 

// 列舉原始值

enum Direction: Int {

    case east = 1

    case south = 10

    case west = 66

    case north = 88

}

 

// 建立列舉常量

let dir1 = Direction.north

// 獲取列舉的原始值

print(dir1.rawValue)

 

// 通過原始值建立列舉常量

let dir2 = Direction(rawValue: 88)

 

print(dir2)

 

if let dir3 = dir2 {

    switch dir3 {

    case Direction.east:

        print("東")

    case Direction.south:

        print("南")

    case Direction.west:

        print("西")

    case Direction.north:

        print("北")

    }

} else {

    print("列舉沒有值")

}

---

函式

         C語言函式:
        int sum(int a, int b) {
            return a + b
        }
        呼叫函式: int c = sum(10, 5);

    Swift中定義函式:
        func: 關鍵字
        func 函式名稱(函式的形引數: 引數型別, ...) -> 返回值型別 {
            函式程式碼
        }

    函式沒有返回值:
        1.返回值什麼都不寫
        2. -> Void

        3. -> ()

 

// 函式有返回值

func sum(a: Int, b: Int) -> Int {
    return a + b
}

// 函式沒有返回值
func sayHello() {
    print("hello world")

}

 

// 呼叫函式
let c = sum(10, b: 5)

print(c)

 

sayHello()

// 自定義外部引數名: 在形參前面再新增一個名稱就是外部引數名
func addStudent(stu_name name: String, age: Int, no: Int) {
    print("新增學生: name = \(name), age = \(age), no = \(no)")
}

// 10000行程式碼
// 呼叫
// 外部引數名,作用提示我們每個引數的作用,預設第一個引數不生成外部引數名,其他引數的外部引數名和形參一樣
addStudent(stu_name: "liudehua", age: 55, no: 55)

func addStudent2(stu_name name: String, stu_age age: Int, stu_no no: Int) {
    print("新增學生: name = \(name), age = \(age), no = \(no)")
}

addStudent2(stu_name: "liudehua", stu_age: 55, stu_no: 55)

---

閉包

      和OC的Block類似,都是一段先準備好的程式碼,在需要的時候執行,函式其實也是這樣 Block和函式最大的區別:Block可以作為引數傳遞

    閉包表示式的格式:
        //  in 必須要的,用於區分
        { (形參: 型別, 形參: 型別) -> 返回值 in
            // 閉包程式碼

        }

     // 1.定義閉包常量：無引數無返回值
        let coluse = { () -> Void in
            print("我是一個閉包")
        }
       
        // 2.呼叫閉包
        coluse()

       
        // 1.定義一個有引數的閉包
        // 閉包型別: (Int, Int) -> Int
        let coluse2 = { (a: Int, b: Int) -> Int in
            return a + b
        }
       
        // 呼叫閉包
        let c = coluse2(10, 5)

        print(c）

---

 待續。。。