(一)類型

常見類型

Int,String,Double,struct,enum,class,tuple

//typle 元組類型
//聲明
let someTuple:(Int,Int) = (10,23)
//元組可以設(shè)置名稱
var person = (name:"liuyw",age:30)
//取值方式1
person.0
person.1
//取值方式2
person.age
person.name
//取值方式3
var (personName,personAge) = person
personName
personAge

someTuple.0或者tuple.1

//typealias
//類型的別名關(guān)鍵字

//函數(shù)類型
func

//可選類型
var num:Int? = nil
var num1:Optional<Int> = nil

//隱式解析可選
var num:Int!
var num1:ImplicitlyUnwrappedOptional<Int>

//協(xié)議合成類型
var someProtocol:protocol<protocol1,protocol2>

Array

//聲明
var array1:[String] = ["0","1","2","3"]
var array = [String]()

//修改值
array1 += ["4","5"]
array1[1...3] = ["a","b","c","d","e"]
//array1.append
//array1.removeAtIndex(<index:Int Int>)
//array1.insert(<newElement:Element>, atIndex:<Int>)

//獲取值
print(array1)
print(array1[0])
print(array1.last)
print(array1.first)

var str:String = ""

//遍歷
for item:String in array1{
    
}


for bgen in array1.enumerate()
{
    print("元素下標(biāo):\(bgen.0)  元素值:\(bgen.1)")
}

dictionary

 
//聲明
var dic:Dictionary<String,String> = ["name":"liu","age":"30"]
var dic1 = Dictionary<String,String>()

//修改值
dic["name"] = "liuyanwei"
dic["name1"] = "liuyanwei1"
dic.updateValue("liuyw", forKey: "name")//返回原值
dic1.indexForKey("name1")
dic.removeValueForKey("name")

//獲取值
dic["name"]

//字典的循環(huán)
for (key,value) in dictionary{
    println("key is: \(key) value is : \(value)");
}

枚舉enum

//整形的枚舉
enum Sharp:Int{
    case Rect=1,Circle,Star
    //switch中的選項(xiàng)可以用.表示
    func desc()->String{
        switch self{
        case .Rect:
            return "this is rect"
        case .Circle:
            return "this is circle"
        case .Star:
            return "this is star"
        }
    }
}
//enum的值
Sharp.RawValue(1)
//調(diào)用枚舉的方法
Sharp.Rect.desc()

結(jié)構(gòu)struct

//結(jié)構(gòu)
//結(jié)構(gòu)和類的最重要的區(qū)別就是架構(gòu)是傳值设塔，類是傳引用
struct Sharp{
    //屬性
    var width:Int
    var height:Int
    //方法
    func area()->Int{
        return self.width*self.height;
    }
    //允許修改屬性的方法前綴 mutating
    mutating func zoomIn() {
        self.width += 100
        self.height += 100
    }
}

協(xié)議

//可以被class茉贡，struct眯牧，enum實(shí)現(xiàn)
protocol Sharp{
    //屬性
    var width:String{get}
    var heiht:String{get set}
    //方法
    func area()->Int
    
}

//swift 可選和必選協(xié)議
//只能被class實(shí)現(xiàn)觅彰，無(wú)法給struct和enum實(shí)現(xiàn)
@objc protocol OptionalProtocol {
    //可選協(xié)議
    optional func optionalMethod()
    //必選協(xié)議
    func necessaryMethod()
}

對(duì)象

class Card: NSObject {
    
}
class Person: NSObject {

    //私有對(duì)象
    private var _name:String?
    
    var gender:String
    var gender1:String?
    
    //arc
    /*
    weak 用于可空對(duì)象鳍侣，unowned用于非空對(duì)象
    weak 調(diào)用被釋放的對(duì)象會(huì)返回nil抡医，unowned 調(diào)用被釋放的對(duì)象會(huì)出異常
    建議 如果能夠確定在訪問(wèn)時(shí)不會(huì)已被釋放的話英融，盡量使用 unowned癣防，如果存在被釋放的可能趴俘，那就選擇用 weak
    */
    weak var bastFriend:Person?
    unowned var identityCard:Card
    

    //構(gòu)造函數(shù)
    init(name: String) {
        gender = "male"
        identityCard = Card()
        super.init()
        //初始化睹簇。。寥闪。
        self.name = name
    }
    //便利構(gòu)造函數(shù)
    convenience init(name:String,gender:String)
    {
        self.init(name:name)
        self.gender = gender
    }
    
    //析構(gòu)函數(shù)
    deinit{
        
    }
    
    //屬性
    var name:String{
        get{
            return _name!
        }
        set{
            _name = newValue;
        }
        //可以自定newValue的名稱
        //set(newName){
        //   _gender = newName
        //}
    }
    
    //觀察者模式的屬性
    //newValue 和 oldValue 
    var age:Int = 0{
        willSet{}
        didSet{}
    }
    
    //方法
    func sayName(){
        print("hello name")
    }
    
    //靜態(tài)方法
    static func say(){
        print("hello")
    }
    
    //類方法
    class func say1(){
        print("hello1")
    }
    
    //方法重載
    override func copy() -> AnyObject {
        return ""
    }
    
    //懶屬性
    //兩種方式太惠，方法加載和閉包加載
    lazy var friends:[String] = self.findfriends()
    func findfriends()->[String]{
        return ["bob","bill","jobs"]
    }
    lazy var bastFirends:String = {
        print(" print bastFirends")
        return "liuyanwei"
        }()
    //調(diào)用
    //NSLog("bastFirends:%@ and friends is:[%@] ",p.bastFirends,p.friends)
    
    //下標(biāo)腳本
    subscript(name:String)->String{
        get{
            return self.name
        }
        set{
            self.name = newValue;
        }
    }
    

}

（二）語(yǔ)法

流程控制

if語(yǔ)句

//判斷是Option類是否有值
if let theStr = str2 {
    print("ture")
}

switch

//switch 數(shù)字區(qū)間
var condition1 = 888_888_888;
switch condition1{
    case -999_999...38: print("case1");
    case 40...88: print("case2");
    case 100...188: print("case3");
    case 200...999_999_999_999: print("case3");
    default:break;
}

//switch  元組
var condition2 = (100,88);
switch condition2{
    case (-99999...0,-99999...0),(40...88,0..<100): print("case1")//匹配多個(gè)條件
case let (_,y): print(y); fallthrough // 值綁定,fallthrough 墜落下一個(gè)條件
    case (_,0...100): print("case3");// “_” 匹配所有
    default:break;
}

//switch 值綁定和where語(yǔ)句
var condition3 = 100
switch condition3{
    case let i where i<50 :print("case1")
    case let i where i<120 && i>50 :print("case2")
    default :break;
}

//switch 枚舉
enum BarCode{
    case UPCA(Int,Int,Int)
    case QRCode(String)
}
var condition4 = BarCode.UPCA(10, 5, 2)
switch condition4{
    case let .UPCA(a,b,c): print("a:\(a)|b:\(b)|c:\(c)")
    case .QRCode: print("case:2")
//    default: break
}

//對(duì)option的判斷
let num: Int? = nil
switch num {
    case nil: println("沒(méi)值")
    default:  println("\(num!)")
}

函數(shù)

//無(wú)參數(shù)
func hello(){}

//有參數(shù)
func hello(name:String){}

//有參數(shù)和返回值
func hello(name:String)->String{}

//多個(gè)參數(shù)
func hello(name:String,age:Int){}
    
//多個(gè)返回值
func hello()->(String,Int){
    return (num1,num2,num3)
}

//可變參數(shù)
func hello(name:String...){}

//函數(shù)的嵌套
func hello1(){
    func hello2(){}
}

//參數(shù)的默認(rèn)值
func hello1(msg:String = "defaultMsg"){}

//返回值是函數(shù)
func hello()->(String->String){
     func hello1(name:String)->String{}
     return hello1
}


//參數(shù)是函數(shù)
fun hello(msg:String,callback(Void->Void)){
    callback()
}

//函數(shù)參數(shù)是變量
//若不聲明var ，默認(rèn)參數(shù)類型是let疲憋，就無(wú)法修改參數(shù)的值
func hello(var msg:String){
    msg += "hello"
    print(msg)
}

//函數(shù)參數(shù)的命名
func hello(name name:String ,withAge age:Int){}
func hello1(name:String ,age:Int){}
//調(diào)用
hello(name:<String>, withAge:<Int>)//默認(rèn)的參數(shù)命名
hello1(<name:String  String>, age: <Int>)//指定的參數(shù)命名

//匿名函數(shù)
//{}可以作為匿名函數(shù)
//例如調(diào)用上面的hello方法（參數(shù)是函數(shù)）
hello("hi",
    {
     //dosthing
    }
)

//有參數(shù)的匿名函數(shù)
{
    (msg:String)->String in
    return msg
}

//泛型參數(shù)
//輸入輸出參數(shù)的函數(shù)
func myswap<T>(inout obj1:T,inout _ obj2:T){
    let temp:T = obj1
    obj1 = obj2
    obj2 = temp
}

閉包

var array = ["f","a","c","d","e"]

//完整寫法
//{ (參數(shù):類型) in 執(zhí)行方法 return 返回值}
array.sort({
    (s1:String,s2:String) -> Bool in
    return s2 > s1;
})

//省略參數(shù)類型和括號(hào)
//{ 參數(shù)$1,$2 in 執(zhí)行方法 return 返回值}
array.sort({
    s1,s2 -> Bool in
    return s1 > s2;
})

//省略參數(shù)類型和return關(guān)鍵字
//{ 參數(shù)$1,$2 in 返回值}
array.sort({
    s1,s2 ->Bool in
    s1 < s2
})

//省略參數(shù)名
array.sort({
    $1 < $0
})

//尾隨閉包
array.sort(){
    $1 < $0
}


//上面的幾個(gè)其實(shí)只是匿名函數(shù)凿渊，不是真正的閉包。swift里面稱他們是閉包缚柳，那就算是吧埃脏。真正的閉包是下面這個(gè)
//閉包（closure）就是封閉的意思
//閉包的概念,閉包概念有很多，我覺(jué)得比較好理解的的是松本行弘給的定義：將局部變量這一環(huán)境封閉起來(lái)的結(jié)構(gòu)秋忙，叫做閉包
func count()->(()->Int){
    var i = 0;
    return {
        ()->Int in
        return ++i
    }
}
//測(cè)試使用
var touch = count()
touch()//1
touch()//2
touch()//3
touch()//4

異常處理

enum AwfulError: ErrorType {
    case Bad
    case Worse
    case Terrible
}

func hello () throws{
    throw AwfulError.Bad
}

do {
    try hello()
    print("final")
}
catch AwfulError.Bad {
    print("Bad")
}
catch AwfulError.Worse {
    print("Worse")
}
catch AwfulError.Terrible {
    print("Terrible")
}
catch  {
    print("all error")
}

斷言

assert(assert(<condition:Bool Bool>)
assert(<condition: Bool Bool>, <message: String String>)
assertionFailure()
assertionFailure(<message: String String>)

typealias

這個(gè)關(guān)鍵字可以給類彩掐，結(jié)構(gòu)，枚舉等增加別名灰追，也常常用于合并協(xié)議后的別名
typealias PetLike = protocol<KittenLike, DogLike>

編譯標(biāo)記

//MARK :
//MARK -:
// TODO:
// FIXME:

Selector

objc里面有@Selector(),在swift可以使用 let someMethod = Selector("someMethodName")得到堵幽。大多數(shù)情況無(wú)需這樣

    func callMe() {
        NSLog("this is callMe")
    }
    
    func callMeWithParam(timer:NSTimer) {
       NSLog("this is callMeWithParam,prarm is :\(timer.userInfo as! String)")
    }
   
    //無(wú)參數(shù)
    NSTimer.scheduledTimerWithTimeInterval(2, target:self, selector:"callMe", userInfo: nil, repeats: true)
    //帶參數(shù),不使用Selector
    NSTimer.scheduledTimerWithTimeInterval(2, target:self, selector: "callMeWithParam:", userInfo: "i'm prarm", repeats: true)

擴(kuò)展

extension Person{
    func anotherHello(){
        NSLog("another hello")
    }
}

defer

defer{} 可以將大括號(hào)中的代碼段延遲到它所在的作用于結(jié)束后在執(zhí)行

    print("1-1")
    defer{
      print("1-2")
    }
    print("1-3")

    輸出：
        1-1
        1-3
        1-2

Guard

guard充當(dāng)了警衛(wèi)員一職，保證條件滿足情況下弹澎，才會(huì)讓你通過(guò)朴下，否則只能else讓你返回了！切記else中一定需要有返回的語(yǔ)句裁奇，比如return桐猬、continue、break刽肠、throw這種提早退出的關(guān)鍵字

  // 這里使用if 和 guard進(jìn)行對(duì)比 你會(huì)懂的更多
  if age < 13 {
      return  //當(dāng)年齡小于13時(shí) 程序返回 不進(jìn)行之后的操作
  }

  guard age >= 13 else{
    return
  }

OptionSetType

OptionSetType是NSOption在swift的替代

public struct UIViewAutoresizing : OptionSetType {
    public init(rawValue: UInt)
    public static var None: UIViewAutoresizing { get }
    public static var FlexibleLeftMargin: UIViewAutoresizing { get }
    public static var FlexibleWidth: UIViewAutoresizing { get }
    public static var FlexibleRightMargin: UIViewAutoresizing { get }
    public static var FlexibleTopMargin: UIViewAutoresizing { get }
    public static var FlexibleHeight: UIViewAutoresizing { get }
    public static var FlexibleBottomMargin: UIViewAutoresizing { get }
}

//使用,選擇多個(gè)
[FlexibleLeftMargin,FlexibleWidth]

（三）高級(jí)

柯里化 (Currying)

柯里化是一種量產(chǎn)類似方法的好辦法溃肪，可以通過(guò)柯里化一個(gè)方法模板來(lái)避免寫出很多重復(fù)代碼

func addTwoNumbers(a: Int)(num: Int) -> Int {
    return a + num
}
let addToFour = addTwoNumbers(4)    // addToFour 是一個(gè) Int -> Int
let result = addToFour(num: 6)      // result = 10

封裝局部變量

封裝局部變量可以減少變量之間的沖突

var str:String = {
    //局部變量被封裝
    let str1 = "hello",str2 = "world"
    return "\(str1) \(str2) !"
}()

方法調(diào)用的另一種方式

class Person {
    
    //普通方法
    func hi(name:String) -> String{
        return "hi \(name)"
    }

    //靜態(tài)方法
    class func hello(){
        NSLog("hello")
    }
}

let person = Person()

//常規(guī)方法調(diào)用
person.hi("liuyanwei")
Person.hello()

//利用方法名調(diào)用
let funcOnPerson1 = Person.hi
funcOnPerson1(person)("liuyanwei")

//調(diào)用靜態(tài)方法
let funcOnPerson2 = Person.hello
funcOnPerson2()

swift單例標(biāo)準(zhǔn)寫法

class MyManager  {
    static private let sharedInstance = MyManager()
    class var sharedManager : MyManager {
        return sharedInstance
    }
}