Swift初體驗

//1.swift應(yīng)用程序的入口
@UIApplicationMain

//2.swift中引用框架只需要引入框架的名字
import UIKit

//3.swift引用OC的框架方法名都一樣,只是寫法不一樣

//4.swift類的所有的聲名和實現(xiàn)都寫在class最外層的大括號里面

//5.重寫方法需要加上override
    override func viewDidLoad() {
        super.viewDidLoad()
    }

//6.swift使用點語法調(diào)用一個方法
        super.viewDidLoad()

swift單條語句不需要加分號

//var聲明一個變量,let聲明一個常量
        let firstView = UIView(frame: CGRect(x: 10, y: 30, width: 200, height: 200))

基本數(shù)據(jù)類型

//: [Previous](@previous)

import Foundation

//基本數(shù)據(jù)類型
var a:Int = 10
var f:Float = 10.5
var d:Double = 100.5
var t:Bool = true
var fa:Bool = false

//douple元組:可以表示多個值的基本類型
var douple = (a,f)
var a1 = douple.0

var douple2 = (first: a,second: d)
var a2 = douple2.first
var a3 = douple2.0

//運算符
//賦值運算符 =
//算數(shù)運算符 + - * / %
//比較運算符 > < >= <= !=
//邏輯運算符 || &&
//三目運算符 ? :

//swift中特殊運算符
//?? 空合運算符
//_ 忽略運算符
//... 區(qū)間運算符
//0...5 代表>=0 && <=5

變量和常量

//1.用var來定義一個變量,用let定義一個常量
//變量一旦定義,其值可以改變,常量一旦定義,其值不可以改變
//如果不確定使用let還是var,可以先定義成let.報錯時再改回來
var a:Int = 10
a = 5
let a1: Int = 15
//a1 = 20

//2.變量和常量可以根據(jù)等號右邊的值,自動推導(dǎo)類型
var a3 = 15
let view = UIView()
var f = 10.5 //小數(shù)會被默認推斷成Double類型

//3.swift對類型的要求極其嚴格,不同類型不能參與運算
//必須要強轉(zhuǎn)
var result = Double(a3) + f
var result2 = a3 + Int(f)

控制流

//: [Previous](@previous)

import Foundation
//if條件語句的小括號可以省略,執(zhí)行語句的大括號一定不能省略
var a = 10

if (a > 5) {
    print("hello,world")
}

//使用for in + 區(qū)間運算符做循環(huán)
//0...10 [0,10]
//0..<10 [0,10)
for i in 0..<10 {
    print(i)
}
//倒序遍歷
//從10循環(huán)到0
for i in (0...10).reversed() {
    print("love \(i)")
}

//忽略運算符 _:如果不想使用某個值,可以將該值忽略
for _ in 0...5 {
    print("hello")
}

//while
//swift放棄了 ++ 和 -- 運算符
var i = 10
while i > 0 {
    i -= 1
    print("while \(i)")
}

//swift把do while 換成了repeat while
var m = 10
repeat {
    m -= 1
    print("repeat while\(m)")
} while m > 0

//switch
var score = 75
switch score {
case 60,75:
    print("及格")
default:
    print("仍需努力")
}
//可以判斷任何類型
var scorestr = "75"
switch scorestr {
case "60":
    print("及格")
default:
    print("仍需努力2")
}
//可以做區(qū)間判斷
//綁定:定義一個臨時的變量或常量,把要判斷的值賦值給該變量或常量,后面直接使用這個臨時的變量或常量
//where是swift的關(guān)鍵,可以接條件判斷語句  
//default 如果case不能覆蓋所有條件,則必須加default
//如果多個case同時滿足條件,case的條件之間用逗號隔開
switch score {
case let score where score < 60:
    print("不及格")
case let x where x >= 60 && x < 70:
    print("及格")
case let x where x >= 70 && x < 80:
    print("良好")
case let x where x >= 80 && x < 90:
    print("優(yōu)秀")
case let x where x >= 90:
    print("牛逼")
default:
    print("仍需努力")
}

可選值

//: [Previous](@previous)

import UIKit

//可選值:一個變量或常量,可能有值,可能沒有值(nil),一個變量或常量有可能會被設(shè)為nil,那么這個值就叫可選值
//對于對象,OC可以將其設(shè)為nil
//OC會給變量賦初值,swift不會,swift默認不能將對象設(shè)為nil;swift中,如果將對象設(shè)為可選值,則任何數(shù)據(jù)類型都可以設(shè)為nil
var view: UIView?
view = nil

//在變量的數(shù)據(jù)類型后面接一個 ? 代表定義一個可選值
//一旦該變量設(shè)為可選,就代表該變量可以設(shè)為nil
//對于可選的變量,如果沒有初始值,它的初始值為nil
var a:Int?
a = nil
//Optional :可選
var view1: UIView? = UIView()
print(view1)

//可選值不能直接參與運算,需要強制解包,在該值的后面接一個 !
//使用!時,如果該可選值為nil,則會崩潰
//value of optional type 'Int?' not unwrapped;提示使用一個可選值時需要強制解包
//unexpectedly found nil while unwrapping an Optional value 強制解包一個可選值時,發(fā)現(xiàn)其值為nil
//? 告訴編譯器,我是一個可選值,不要拿我做運算
//! 告訴編譯器,我一定有值,可以使用,一旦編譯器發(fā)現(xiàn)沒有值,就會蹦會
var b:Int? = 10
var c:Int? = 10
var result = b! + 10
//如果不確定可選值是否有值,需要先判斷是否為nil
//1.直接判斷,在使用可選值的時候,仍然需要使用!
if b != nil {
    var result = b! + 10
}
//2.可選綁定
//對于可選值,條件判斷語句中,定義一個臨時的變量/常量 x,將可選值賦值給x,如果x有值,則綁定成功,后面可以直接使用,如果x沒有值,則綁定不成功,可以異常處理;如果需要接條件判斷,可以用逗號隔開
//可選綁定,使用可選值最廣泛的用法
if let b = b,b > 15 {
    var result = b + 10
}
//對多個可選值做可選綁定
if let b = b,let c = c {
    var result = b + c
}
//可選值的使用
let url = URL(string: "http://www.baidu.com")

let request = URLRequest(url: url!)

if let url = url {
    let request = URLRequest(url: url)
}

空合運算符

var a: Int? = 5
//空合運算符:在使用可選值時,如果可選值有值,則使用可選值的值,如果沒有值,則使用空合運算符后面的值
//空合運算符的優(yōu)先級比算數(shù)運算符低
var b = a ?? 10 + 3

字符串

//: [Previous](@previous)

import Foundation

//用var創(chuàng)建一個可變的字符串,用let創(chuàng)建一個不可變的字符串
//自變量創(chuàng)建
var str = "hello"
//構(gòu)造方法創(chuàng)建
var str2 = String("hello2")
var str3 = String.init("hello3")

//字符串和字符串的拼接
var str4 = "hello,"
var str5 = "world"
var str6 = str4 + str5;
str4 += str5;

//字符串和常量,變量的拼接 \
var classIndex = 5
var str7 = "world"
var str8 = "hello\(str7)"
var str9 = "hello\(classIndex)"

//stringWithFormat
//05:05:05
let h = 5
let m = 5
let s = 5
var time = String(format: "%02d: %02d: %02d", h,m,s)

//字符串的比較
var str10 = "hello"
var str11 = "hello"
var str12 = "helll"
if str10 == str11 {
    print("一樣")
}
if str11 != str12 {
    print("不一樣")
}

//取字符串的長度
//let count = str12.lengthOfBytes(using: .utf8)
let count = str12.characters.count

//判斷是否有前綴
if str12.hasPrefix("h") {
    print("h開頭")
}
if str12.hasSuffix("l") {
    print("l結(jié)尾")
}
//正常情況下,swift的api可以解決問題,如果解決不了,可以將swift字符串轉(zhuǎn)成oc字符串
let swiftStr = "hello,world"
//as代表類型轉(zhuǎn)換
let ocString = swiftStr as NSString
ocString.substring(with: NSMakeRange(0, 5))

數(shù)組

//: [Previous](@previous)

import Foundation


//數(shù)組的創(chuàng)建
//用var創(chuàng)建一個可變的數(shù)組,用let創(chuàng)建一個不可變的數(shù)組
var array = ["dog","cat","pig"]
var emptyArr:[String] = []
array.append("fish")
//用初始化的方式創(chuàng)建數(shù)組,一定要指定類型
var array2: [String] = Array()

//數(shù)組的遍歷
for item in array {
    print(item)
}
//遍歷同時拿到index
for item in array.enumerated() {
    print("\(item.offset):\(item.offset)")
}
//倒序遍歷
for item in array.reversed() {
    print(item)
}

//數(shù)組的操作
//數(shù)組的合并
var array3 = ["goat","snake"]
var array4 = ["dog","cat","pig"]
var array5 = array3 + array4
//刪除元素
let removed = array5.remove(at: 0)
//修改
array5[0] = "sheep"
//和OC的數(shù)組互轉(zhuǎn)
let ocArray = array5 as NSArray
ocArray.subarray(with: NSMakeRange(0, 3))

字典

//: [Previous](@previous)

import Foundation


//定義一個字典
//用var定義一個可變的字典,用let定義一個不可變的字典
var dict = ["first":"dog","second":"cat"]
//定義一個空的字典
var dict1: [String: String] = Dictionary()
var dict2: [String: String] = [:]

//遍歷字典
for (k,v) in dict {
    print("key:\(k),value:\(v)")
}
//字典的操作,增刪改查,字典的操作都是圍繞key值做操作
//增
dict["third"] = "pig"
//刪
dict["second"] = nil
//查:從字典中取出的值是一個可選值,使用的時候最好做一次可選綁定
let first = dict["first"]
//改
dict["first"] = "duck"
print(dict)

集合

//: [Previous](@previous)

import UIKit

//let定義不可變集合,var定義可變集合
//無序,不可重復(fù)
//空集合
var set: Set<String> = []
var set1: Set<String> = Set()
var Set2 = Set<String>()

//增加元素
set.insert("a")
set.insert("b")
//創(chuàng)建一個帶有默認值的集合
let set4: Set = ["cat","dog","cow"]

//集合的遍歷
for item in set {
    print(item)
}
//集合中刪除一個元素
set.remove("a")
print(set)
//集合的交集,并集的判斷
var setaa: Set = [1,2,3,4]
var setbb: Set = [1,2]
var setcc: Set = [3,4,5]
var setdd: Set = [1,2]

if setbb.isSubset(of: setaa) {
    print("bb是aa的子集")
}
if setbb.isStrictSubset(of: setaa) {
    print("bb是aa的真子集")
}
if setbb.isSuperset(of: setdd) {
    print("bb是dd的交集")
}

函數(shù)

//: [Previous](@previous)

import Foundation

//用func來創(chuàng)建一個函數(shù)
//函數(shù)名后面接小括號,小括號不能省略
//小括號里面放參數(shù),參數(shù)必須指定類型,多個參數(shù)用逗號隔開
//如果沒有返回值,返回值的部分可以省略
func add(a:Int,b:Int) -> Int {
   return a + b
}
let funcadd = add

//函數(shù)沒有返回值,本質(zhì)上返回一個空的元組
func addOne(a:Int,b:Int){
   print(a + b)
}
func addTwo(a:Int,b:Int) -> (){
   print(a + b)
}
func addThree(a:Int,b:Int) -> Void{
   print(a + b)
}
let funcaddOne = addOne

//沒有參數(shù),沒有返回值
func methodOne() {
   print("hello,world")
}


//有參數(shù),沒有返回值
func methodTwo(a:Int,b:Int) {
   print(a + b)
}
//有參數(shù),有返回值,返回的值和返回值的類型必須保持一致
func methdThird(a:Int,b:Int) -> Int {
   return a + b
}
//函數(shù)的調(diào)用
methodOne()

外部參數(shù)名

//: [Previous](@previous)

import Foundation

//函數(shù)的參數(shù)默認有一個外部參數(shù)名
//外部參數(shù)名:就是對參數(shù)做解釋說明用的字符串
//默認情況下,swift會給每個參數(shù)加一個和形參一樣的外部參數(shù)名
//外部參數(shù)名,就是對參數(shù)做解釋說明的字符串
//外部參數(shù)名,在調(diào)用的時候,必須寫
func add(a: Int,b: Int) {
    return a + b
}
//add(a: <#T##Int#>, b: <#T##Int#>)
//也可以自定義外部參數(shù)名
func addOne(first a: Int,second b: Int){
    return a + b
}
//addOne(first: <#T##Int#>, second: <#T##Int#>)

//也可以忽略外部參數(shù)名
//使用忽略運算符忽略外部參數(shù)名
func addTwo(_ a: Int,_ b: Int) {
    return a + b
}
//addTwo(<#T##a: Int##Int#>, <#T##b: Int##Int#>)

函數(shù)默認參數(shù)

//: [Previous](@previous)

import UIKit

//swift語言函數(shù)的參數(shù)可以設(shè)默認值
//如果參數(shù)有默認值,則該參數(shù)可傳,可不傳
func add(a: Int,b: Int = 10) -> Int {
    return a + b
}

add(a: 5)
add(a: 5, b: 15)

func customLabel(title: String, fontSize: CGFloat = 13,alignment: NSTextAlignment = .left,numberOfLines: Int = 0) -> UILabel {
    let label = UILabel()
    label.text = title
    label.font = UIFont.systemFont(ofSize: fontSize)
    label.textAlignment = alignment
    label.numberOfLines = numberOfLines
    return label
}

//let label = customLabel(title: <#T##String#>)

閉包的定義和調(diào)用

//: [Previous](@previous)

import Foundation

//閉包是一個匿名的函數(shù)快
//閉包被完成的包裹在大括號里面
//閉包的調(diào)用方式和函數(shù)一樣
//閉包可以作為參數(shù)傳遞,也可以作為返回值

//閉包的定義和調(diào)用
//沒有參數(shù),沒有返回值的閉包
let clousureOne = {
    print("hello,world")
}
clousureOne()

//有參數(shù),沒有返回值
//參數(shù)和執(zhí)行語句都寫在大括號里面,用 in 隔開
//閉包沒有外部參數(shù)名
let clousureTwo = {
    (a: Int,b: Int) in
    print(a + b)
}
clousureTwo(5,10)

//有參數(shù),有返回值
let clousureThree = {
    (a: Int,b: Int) -> Int in
    return a + b
}
let result = clousureThree(3,4)

閉包的使用

//需求:下載movie,更新UI
//1.下載,定義成函數(shù)
//2.更新,使用閉包
//使用最多的場景:異步加載數(shù)據(jù),加載完成之后刷新UI
//異步加載數(shù)據(jù):定義成函數(shù)
//加載完成數(shù)據(jù)之后刷新UI,定義成閉包
//把閉包作為參數(shù)傳遞
//在函數(shù)中執(zhí)行閉包
import UIKit

class ViewController: UIViewController {

    func customLabel(title: String, fontSize: CGFloat = 13,alignment: NSTextAlignment = .left,numberOfLines: Int = 0,backgroundColor: UIColor = UIColor.yellow) -> UILabel {
        let label = UILabel(frame: CGRect(x: 20,y: 40,width: 300,height: 40))
        label.text = title
        label.font = UIFont.systemFont(ofSize: fontSize)
        label.textAlignment = alignment
        label.numberOfLines = numberOfLines
        label.backgroundColor = backgroundColor
        return label
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let label = customLabel(title: "正在下載...")
        view.addSubview(label)
        
//        func updateUI(movieName: String){
//            label.text = "\(movieName),下載完成"
//        }
        let updateUI = {
            (movieName: String) in
            label.text = "\(movieName),下載完成"
        }
        //下載電影,完成后更新UI
        downloadMovie(callBack: updateUI)
    }
    
    func downloadMovie(callBack:@escaping (String) -> ()) {
        //模擬異步加載數(shù)據(jù)
        DispatchQueue.global().async {
            Thread.sleep(forTimeInterval: 2)
            let movieName = "電影"
            DispatchQueue.main.async {
                //刷新UI
                callBack(movieName)
            }
        }
    }
}

尾隨閉包

//尾隨閉包:當閉包表達式作為函數(shù)的最后一個參數(shù)的時候,可以把閉包寫在小括號外面,如果函數(shù)的參數(shù),只有閉包一個參數(shù),則連小括號都可以省略
//        DispatchQueue.global().async(execute: ??)
        DispatchQueue.global().async {
            Thread.sleep(forTimeInterval: 2)
            let movieName = "電影"
            DispatchQueue.main.async {
                //刷新UI
                callBack(movieName)
                
            }
        }

//下載電影,完成后更新UI
        //downloadMovie(callBack: updateUI)
        //尾隨閉包的寫法
        downloadMovie {
            (movieName: String) in
            label.text = "\(movieName),下載完成"
        }

guard的用法

//guard:保證
//guard:引導(dǎo)一個條件判斷
//guard和if邏輯相同,寫法相反
//if條件滿足時,執(zhí)行語句寫在大括號里面,guard條件滿足時,執(zhí)行語句寫在大括號外面,在大括號里面需要return,continue,break
//guard可以提前過濾條件不滿足的情況,減少代碼的層級

func testif() {
    var a = 10
    if a > 5 {
        print("hello")
    }
}
testif()

func testGuard() {
    var a = 10
    guard a > 5 else{
        return
    }
    print("hello,world")
}
testGuard()

func testUrl() {
    let url = URL(string: "http://www.baidu.com")
    if let url = url {
        let request = NSURLRequest(url: url)
    }
    
    guard let urls = url else {
        return
    }
    let request = NSURLRequest(url: urls)
}

閉包的循環(huán)引用

downloadMovie {
            //解除循環(huán)引用
            //[weak self]時,代表self是可以被釋放的,一旦釋放,就代表self設(shè)為nil,self就是一個可選值
            [weak self](movieName: String) in
            label.text = "\(movieName),下載完成"
            print(self!)
        }