Swift 语法篇

一、输出语句

print("Hello World")
print("Hello World 11", "Hello World 22", separator: "*****", terminator: "\n")

　　

二、简单值

　　常量使用 let (只能赋值一次，赋值后值不能改变)，变量使用 var。

let myConst = 10
var myVariable = 50
myVariable = 15    

　　常量和变量在声明时候指定类型是可选的，如果声明的时候没有给定类型，编译器会自动推断类型。如果初始值不能提供足够的类型说明，则需要在声明的时候显示声明类型。　　

let myDoubleConst: Double = 70;

　　值永远不会被隐式转换为其他类型。如果你需要把一个值转换成其他类型，请显式转换。

let myString = "Hello World"
let myFloat = 4.0

let sum = myString + String(myFloat)
print("sum =", sum)

　　简单的把值转换成字符串。　　

let myConst1 = 50
let myConst2 = 100
print("myConst1 = \(myConst1); myConst2 = \(myConst2)")
print("sum = \(myConst1 + myConst2)")

　　使用 [] 定义 Array 和 Dictionary，以及修改其内容。

var myArray = ["apple", "boy", "cat", "dog"]
myArray[0] = "www"
print(myArray)
        
        
var myDict = [
    "key1" : "value1",
    "key2" : "value2"
]
myDict["key3"] = "value3"
print(myDict)

　　创建空 Array 和 Dictionary -- 确定类型。

let emptyArray = [String]()
let emptyDict = [String: Float]()

　　创建空 Array 和 Dictionary -- 不确定类型。

let emptyArray1 = []
let emptyDict1 = [:]

　

三、控制流

　　使用 if 和 switch 来进行条件操作，使用 for-in、for、while 和 do-while 来进行循环。包裹条件和循环变量括号可以省略，但是语句体的大括号是必须的。　　

let scoreList = [11, 22, 33, 44, 55, 66]
var tmpScore = 0
for score in scoreList {
    if (score > 50) {
        tmpScore += 3
    }
    else {
        tmpScore += 1
    }
}
print(tmpScore)

 

　　在 if 语句中，条件必须是一个布尔表达式——像 if score { ... } 这样的代码是错误的。可以使用 if 和 let 来处理这种可选变量值 (可选变量值：有可能是一个具体的值，也有可能是 nil 表示缺失)

var optionalName: String? = "Eileen Leung"
optionalName = nil
var greeting = "Hello"
        
if let name = optionalName {  // 相当于 optionalName != nil
    greeting = "\(greeting), \(optionalName)"
}
else {
    greeting = "\(greeting), Stranger"
}
print(greeting)

　　switch 支持任意类型的数据以及各种比较操作——不限于整数或等值测试。default 不能缺少。运行 switch 中匹配到的子句之后，程序会退出 switch 语句，并不会继续向下运行，所以不需要在每个子句结尾写 break。

let myString = "Eileen Leung"
let result: String?;
        
switch myString {
    case "Ada":
        result = "This is \(myString)"
    case "Cherry", "Wing":  // Cherry 或者 Wing
        result = "This Cherry Or Wing"
    case let x where x.hasPrefix("Eileen"):
        result = "This is Eileen"
    default:
        result = nil
}
print(result)

// 输出结果： This is Eileen    

　　使用 for-in 来遍历字典。

let numberDict = [
    "key1": [10, 20, 30, 40, 50, 100],
    "key2": [1, 3, 5, 7],
    "key3": [2, 4, 6, 8, 10]
]
        
var sum = 0
for (key, numbers) in numberDict {
    for num in numbers {
        sum += num
    }
}
print(sum)

let myDictionary = [
    "key1": [10, 20, 30, 40, 50, 100],
    "key2": ["apple", "boy", "cat", "dog", "egg", "flight", "green", "hat", "island", "jail"],
    "key3": [1.5, 2.5, 3.5]
]
        
for (key, valueList) in myDictionary {
    print(key, ": [")
     for value in valueList {
        print("\t", value, ",")
    }
    print("}")
}

　　使用 while 来重复运行一段代码直到不满足条件。循环条件可以在开头也可以在结尾。

var n = 2
while n < 100 {
    n = n * 2
}

var m = 2
repeat {
    m = m * 2
} while m < 100

　　在循环中使用 ..< 和 ... 来表示范围，其中 ..< 创建的范围不包含上界，如果想包含的话需要使用 ... 。

var firstForLoop = 0
for i in 0..<3 {  // 相当于 for var i = 0; i < 3; ++i
    firstForLoop += i
}

var secondForLoop = 0
for j in 0...3 {  // 相当于 for var j = 0; j <= 3; ++j
    secondForLoop += 1
}

　　

四、函数和闭包

　　使用 func 来声明一个函数，使用名字和参数来调用函数。使用 -> 来指定函数返回值。

func sum(numbers: Array<Int>, base: Int) -> Int {
    var sum = base
    for number in numbers {
        sum += number
    }
    return sum
}


// 调用
let myNumbers = [1, 3, 5, 7, 9]
let sumValue = sum(myNumbers, base: 50)
print(sumValue)

　　返回多个参数。

func getFloatValue() -> (value1: Float, value2: Float, value3: Float) {
    return (1.0, 5.0, 3.5)
}

　　参数数量可变。

func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}    

// 调用处
print(sumOf(5))
print(sumOf(10, 20, 30))

　　函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂的函数。

func returnFifteen() -> Int {
    var y = 10
        
    func add() {
        y += 5
    }
        
    add()
    return y
}


// 调用处
print(returnFifteen())

　　函数可以作为另一个函数的返回值。

func makeIncrementer() -> (Int -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}

// 调用处
let increment = makeIncrementer()
print(increment(7))

　　函数也可以当做参数传入另一个函数。

func hasAnyMatches(list: Array<Int>, condition: Int -> Bool) -> Bool {
    for item in list {
        if condition(item) {
            return true
        }
    }
    return false
}
    
func lessThanTen(number: Int) -> Bool {
    return number < 10
}

// 调用处
let numbers = [20, 19, 7, 12]
let result = hasAnyMatches(numbers,  condition: lessThanTen)
print("result = \(result)")

　　函数实际上是一种特殊的闭包，你可以使用{}来创建一个匿名闭包。使用 in 来分割参数并返回类型。

　　闭包完整格式:

{
    (参数名: 参数类型) -> 返回类型 in
    
    执行代码

    return 返回值
}

　　完整格式例子:

let numbers = [20, 19, 7, 12]
let result = hasAnyMatches(numbers, condition: ({
            (number: Int) -> Bool in
            return number > 10
    }))
print("result = \(result)")