一、输出语句
print("Hello World")
print("Hello World 11", "Hello World 22", separator: "*****", terminator: "
")
二、简单值
常量使用 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(" ", 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)")