Will's Blog

//: Playground - noun: a place where people can play

import UIKit

//: 闭包是自包含的函数代码块

//: Swift 的闭包表达式有简洁的风格，带来很多便利：利用上下文类型推断/隐式返回单表达式/参数名缩写/尾随

//: 闭包表达式（Closure Expressions）
//: { (parameters) -> returnType in statements }

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
var reversed = names.sort( { (s1: String, s2: String) -> Bool in return s1 > s2 } )
print(reversed)

//: 根据上下文推断类型（Inferring Type From Context）
reversed = names.sort( { s1, s2 in return s1 > s2 } )
print(reversed)

//: 单表达式闭包隐式返回（Implicit Return From Single-Expression Closures），但是表达不够直接不建议
reversed = names.sort( { s1, s2 in s1 > s2 } )
print(reversed)

//: 参数名缩写（shorthand Argument Names）,简洁到这种形式还叫闭包？
reversed = names.sort( { $0 > $1 } )
print(reversed)

//: 运算符函数（Operator Functions）, 到这个时候就完全是Swift来推断或者来猜了，而作为代码给人看过于抽象化了
reversed = names.sort(>)

//: 尾随闭包（Trailing Closures），就是把闭包的大括号放在小括号外面，形式上更像一个函数，或者结构上大段的闭包放在后面更符合一般的书写习惯而已，这个用法是一个语法糖，避免头重脚轻。让懂的人看的舒服，不懂的人可能莫名其妙。记得Swfit调用 AFNetworking 就会智能补全成尾随闭包。
func someFunction(closure: () -> Void) {
    // function do something
}

someFunction ( {
    // closure do something
} )

// Magic Time
someFunction() {
    // closure can alse do something at here
}

reversed = names.sort() { $0 > $1 }
print(reversed)


//: 捕获值（Capturing Values）
//: 闭包是引用类型（Closure Are Reference Types），函数和闭包都可以赋值给变量或常量

//: Playground - noun: a place where people can play

import UIKit

//: 函数参数名称（Function Parameter Names）
//: 一个参数可以有内部参数和外部参数的区别，就是外部调用时要不要写的那个参数，如上面的 arr：。默认情况下：第一个参数没有外部参数名，后面的内外一致。
//: 指定外部参数名(Specifying External Parameter Names)
//: 均可指定外部参数名：自定义或者可以用 _ 表示可以省略


func minMax(arr array: [Int], _ x: Int, t: Double) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    
    var currentMin = array[0]
    var currentMax = array[0]
    
    for value in array[1..<array.count]{
    if value < currentMin {
    currentMin = value
    } else if  value > currentMax {
    currentMax = value
    }
    }
    return (currentMin, currentMax)
}

minMax(arr: [1, -1, 2, 23, 934, -234], 3, t: 2.0)
minMax(arr: [], 2, t: 1.0)



//: 默认参数值（Default Parameter Values）
func someFunciton(x: Int = 11) {
    print(x)
}

someFunciton()
someFunciton(22)

//: 可变参数（Variadic Parameters）
func arithmeticMean(numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    
    return total
}

arithmeticMean(1, 2, 3, 32.232432, 32432.32423)
arithmeticMean(3)
arithmeticMean(1, 3)


//: 常量参数和变量参数（Constant and Variable Parameters）
func alignRight(var string: String, var totalLength: Int, pad: Character) -> String {
    totalLength++
    
    let amountToPad = totalLength - string.characters.count
    if amountToPad < 1 {
        return string
    }
    let padString = String(pad)
    
    for _ in 1...amountToPad {
        string = padString + string
    }
    
    return string
}

alignRight("fdsf", totalLength: 8, pad: "*")

//: 输入输出参数（In-Out Patameters）

func swapTwoInts(inout a: Int, inout _ b: Int) {
    let tmporaryA = a
    a = b
    b = tmporaryA
}

var a = 3
var b = 5
swapTwoInts(&a, &b)
a - b


//: 函数类型（Funciton Types）
//: (Int, Int) -> Int
//: () -> Void

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

func multiplyTwoInts(a: Int, _ b: Int) -> Int {
    return a * b
}

func printHelloWorld() {
    print("Hello world!")
}

//: 使用函数类型（Using Function Types)
var mathFunction: (Int, Int) -> Int = addTwoInts
print("Result: \(mathFunction(2, 4))")

mathFunction = multiplyTwoInts
mathFunction(2, 4)

//: 函数类型作为参数类型（Function Types as Parameter Types）
func printMathResult(mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 7)

//: 函数类型作为返回类型（Function Types as Return Types）
func stepForward(input: Int) -> Int {
    return input + 1
}

func stepBackward(input: Int) -> Int {
    return input - 1
}

func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
    return backwards ? stepBackward : stepForward
}

var currentValue = 3
let moveNearerToZero = chooseStepFunction(currentValue > 0)

print("Counting to zero:")
while currentValue != 0 {
    print("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")


//: 嵌套函数（Nested Functions）
func chooseStepFunction1(backwards: Bool) -> (Int) -> Int {
    func stepForward(input: Int) -> Int { return input + 1 }
    func stepBackward(input: Int) -> Int { return input - 1 }
    return backwards ? stepBackward : stepForward
}

var currentValue1 = -4
let moveNearerToZero1 = chooseStepFunction1(currentValue > 0)

print("Counting to zero:")
while currentValue1 != 0 {
    print("\(currentValue1)... ")
    currentValue1 = moveNearerToZero1(currentValue1)
}
print("zero!")

//: Playground - noun: a place where people can play

import UIKit

//数组
var array1 = [Double](count: 3, repeatedValue: 4.3)
print(array1)

var array2 = array1 + array1

if array1.isEmpty {
  print("array1 is empty.")
} else {
  print("array1 is not empty, have \(array1.count) numbers.")}

array1.insert(3.2, atIndex: 0)

print(array1)

for item in array1 {
  print(item)
}

//集合
var letters = Set<Character>()
letters.insert("a")
letters = []
var set1: Set<String> = ["aaa", "b"]
var set2: Set  = ["aaa", "b"]
set2.count
set2.insert("33")
set2.remove("b")
set2
for genre in set2.sort() {
  print(genre)
}

set1.union(set2)
set1.subtract(set2)
set1.exclusiveOr(set2)
set1.intersect(set2)

let set3: Set<String>  = ["33"]

set3.isDisjointWith(set2)
set3.isStrictSubsetOf(set2)
set3.isSubsetOf(set2)


//字典
var dict = [Int: String]()
dict[12] = "12222"
dict = [:]
dict = [12: "1222", 23: "232423", 322: "23dsfsaf"]
for (num, value) in dict {
  print("\(num) is \(value)")
}
dict[12] = "tw"

for value in dict.values {
  print(value)
}

//控制流
var i = 3
while i < 0  {
  print(1)
}

//元组
let somePoint = (0, 1)

switch somePoint {
case (0, 0):
  print("0")
case (_, 0):
  print("is on the x-axis")
case (0, _):
  print("is on the y-axis")
default:
  print("is outside of the box")
}


//检测API是否可用
if #available(iOS 9, *) {
  print(2)
} else {
  print(1)
}

//if
var temperatureInFahrenheit = 90
if temperatureInFahrenheit <= 32 {
    print("It's very cold. Consider wearing a scarf.")
} else if temperatureInFahrenheit >= 86 {
    print("It's really warm. Don't forget to wear sunscreen.")
} else {
    print("It's not that cold. Wear a t-shirt.")
}
//


//switch 默认遇到符合case，立即终止
let someCharacter: Character = "e"
switch someCharacter {
case "a", "e", "i", "o", "u":
    print("\(someCharacter) is a vowel")
case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
"n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
    print("\(someCharacter) is a consonant")
default:
    print("\(someCharacter) is not a vowel or a consonant")
}
//

//where
let yetAnotherPoint = (1, -1)
switch yetAnotherPoint {
case let (x, y) where x == y:
    print("(\(x), \(y)) is on the line x == y")
case let (x, y) where x == -y:
    print("(\(x), \(y)) is on the line x == -y")
case let (x, y):
    print("(\(x), \(y)) is just some arbitrary point")
}
//

//Continue
let puzzleInput = "great minds think alike"
var puzzleOutput = ""
for character in puzzleInput.characters {
  switch character {
  case "a", "e", "i", "o", "u", " ":
    continue
  default:
    puzzleOutput.append(character)
  }
}
print(puzzleOutput)
// prints "grtmndsthnklk”

//break
let numberSymbol: Character = "二"  // Simplified Chinese for the number 3
var possibleIntegerValue: Int?
switch numberSymbol {
case "1", "١", "一", "๑":
  possibleIntegerValue = 1
case "2", "٢", "二", "๒":
  possibleIntegerValue = 2
  print("test")
  break
case "3", "٣", "三", "๓":
  possibleIntegerValue = 3
case "4", "٤", "四", "๔":
  possibleIntegerValue = 4
default:
  break
}
if let integerValue = possibleIntegerValue {
  print("The integer value of \(numberSymbol) is \(integerValue).")
} else {
  print("An integer value could not be found for \(numberSymbol).")
}
// prints "The integer value of 三 is 3."

//Fallthrough
let integerToDescribe = 5
var description = "The number \(integerToDescribe) is"
switch integerToDescribe {
case 2, 3, 5, 7, 11, 13, 17, 19:
    description += " a prime number, and also"
  
default:
    description += " an integer."
}
print(description)
//

//提前退出
func greet(person: [String: String]) {
    guard let name = person["name"] else {
        return
    }
    print("Hello \(name)")

    guard let location = person["location"] else {
        print("I hope the weather is nice near you.")
        return
    }
    print("I hope the weather is nice in \(location).")
}
greet(["name": "John"])
// prints "Hello John!"
// prints "I hope the weather is nice near you."
greet(["name": "Jane", "location": "Cupertino"])
// prints "Hello Jane!"
// prints "I hope the weather is nice in Cupertino."

//: Playground - noun: a place where people can play

import UIKit

//: 元组（Tuples）把多个值组合成一个复合值，类似数组加字典混合体
let http404Error = (404, "Not Found")

//: 可以分解取值
let (statusCode, statusMessage) = http404Error
//: 下标访问
http404Error.0
//: 单个元素命名
let http200Status = (statusCode: 200, description: "OK")
http200Status.description


//: nil
var serverResponseCode: Int? = 404
serverResponseCode = nil

//: 声明可选的变量或常量，没有赋值则自动设置nil
var surveyAnswer: String?

//: if语句和强制解析
let convertedNumber = Int("1")

if convertedNumber != nil {
    print(convertedNumber!)
}

//: 可选绑定（Optional Binding）
if let actualNumber = Int("32431") {
    print(actualNumber)
}

//: 隐式解析可选类型: 你可以把隐式解析可选类型当做一个可以自动解析的可选类型。你要做的只是声明的时候把感叹号放到类型的结尾，而不是每次取值的可选名字的结尾。
let possibleString: String? = "An apple"
let forcedString: String = possibleString!

let assumedString: String! = ""
let implicitString: String = assumedString

//: 错误处理（error handling）
func canThrowAnErrow() throws {
    
}

do {
    try canThrowAnErrow()
} catch {
    
}

// BEGIN avkit_ios_config
override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?)
{
    if segue.identifier == "videoSegue"
    {
        // set up the player
        let videoURL = NSBundle.mainBundle().URLForResource("TestVideo",
                                                       withExtension: "m4v")
        let videoViewController =
                   segue.destinationViewController as! AVPlayerViewController
        videoViewController.player = AVPlayer(URL: videoURL)
    }
}
// END avkit_ios_config