Swift基础（四）：闭包、枚举

目录：

1.闭包

闭包语法规则，闭包简化，尾随闭包，捕获值，闭包是引用类型，非逃逸闭包，自动闭包

2.枚举

switch穷举枚举，枚举关联值，枚举的原始值，递归枚举

//1.闭包

/* 闭包的语法规则

{ (parameters) -> returnType in

    statements

}

*/

var varArray = ["aaaa","gggg","bbbb","uuuu"];

let varRet =varArray.sort({(para1:String,para2:String) ->Bool inreturn para1 > para2});

varRet;//排序完成的结果：["uuuu", "gggg", "bbbb", "aaaa"]

//闭包简化

let varRet2 =varArray.sort({s1,s2 ->Boolinreturn s1 > s2});

let varRet3 =varArray.sort({s1,s2 ->Boolin  s1 > s2});

let varRet4 =varArray.sort({$0 > $1});

let varRet5 =varArray.sort(>);

//尾随闭包

/*

如果您需要将一个很长的闭包表达式作为最后一个参数传递给函数,可以使用尾随闭包来增强函数的可读性。尾

随闭包是一个书写在函数括号之后的闭包表达式,函数支持将其作为最后一个参数调用.

*/

//将上面排序的闭包改为尾随闭包：

let varRet6 =varArray.sort() { $0 > $1 }

//如果函数只需要闭包表达式一个参数,当您使用尾随闭包时,您甚至可以把 ()省略掉:

let varRet7 =varArray.sort { $0 > $1 }

//捕获值

func makeIncrementor(forIncrement amount:Int) -> () ->Int//返回值是一个函数类型

{

    var runningTotal =0

    func incrementor() ->Int

    {

        runningTotal += amount

        return runningTotal//runningTotal值被外部函数引用，保证被调用完成后不会消失

    }

    returnincrementor

}

let makeIncrementorByEight =makeIncrementor(forIncrement:8);

makeIncrementorByEight();//返回8

makeIncrementorByEight();//返回16

//闭包是引用类型

//非逃逸闭包

//自动闭包

//2.枚举

enum Direction {case West, East, South, North};

// North , South , East和 West不会被隐式地赋值为 0 , 1 , 2和 3。相反,这些枚举成员本身就是完备的值.

let letValEnum =Direction.North;

switch(letValEnum)//swith穷举枚举

{

case .South:

    print("Direction:South");

    break;

case .North:

    print("Direction:North");

    break;

case .East:

    print("Direction:East");

    break;

case .West:

    print("Direction:West");

    break;

default:

    break;

}

//枚举关联值

enum Barcode {

    case UPCA(Int, Int, Int, Int)

    case QRCode(String)

}

/*

以上代码可以这么理解:

“定义一个名为 Barcode的枚举类型,它的一个成员值是具有 (Int,Int,Int,Int)类型关联值的 UPCA ,另一个成员值是具有 String类型关联值的 QRCode。”

*/

var productBarcode =Barcode.UPCA(8,85909,51226,3);

productBarcode = .QRCode("ABCDEFGHIJKLMNOP");

switchproductBarcode

{

case .UPCA(let numberSystem,let manufacturer,let product,let check):

    print("UPC-A:\(numberSystem),\(manufacturer),\(product),\(check).");

    break;

case .QRCode(let productCode):

    print("QR code:\(productCode).");

    break;

}

// 输出 "QR code: ABCDEFGHIJKLMNOP."

//枚举，原始值

enum ASCIIControlCharacter:Character

{

    case Tab ="\t"

    case LineFeed ="\n"

    case CarriageReturn ="\r"

}

/*

枚举类型 ASCIIControlCharacter的原始值类型被定义为 Character ,并设置了一些比较常见的 ASCII控制字符。

*/

//原始值的隐式赋值

enum Planet:Int

{

    case Mercury =1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune

}

print(Planet.Venus.rawValue);//Venus隐式赋值为2，.rawValue可输出原始值

enum CompassPoint:String

{

    case North, South, East, West

}

print(CompassPoint.South.rawValue);//South隐式赋值为“South”，.rawValue可输出原始值

//通过原始值来访问初始化枚举项

let positionToFind =5

iflet somePlanet =Planet(rawValue:positionToFind)

{

    switch somePlanet

    {

    case .Earth:

        print("Mostly harmless")

    default:

        print("Not a safe place for humans")//print

    }

}

else

{

    print("There isn't a planet at position\(positionToFind)");

}

//递归枚举

indirect enum ArithmeticExpression

{

    case Number(Int);

    case Addition(ArithmeticExpression, ArithmeticExpression);//递归ArithmeticExpression枚举

    case Multiplication(ArithmeticExpression, ArithmeticExpression);

}

func evaluate(expression: ArithmeticExpression) -> Int

{

    switch(expression)

    {

    case .Number(let value):

        return value;

    case .Addition(let left,let right):

        return evaluate(left) +evaluate(right);//递归运算

    case .Multiplication(let left,let right):

        return evaluate(left) *evaluate(right);

    }

}

// 计算 (5 + 4) * 2

let five = ArithmeticExpression.Number(5);

let four = ArithmeticExpression.Number(4);

let sum = ArithmeticExpression.Addition(five,four);

let product = ArithmeticExpression.Multiplication(sum,ArithmeticExpression.Number(2));

print(evaluate(product));//输出 "18"