Swift 语法篇

[b]一、输出语句[/b]

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

　　

[b]二、简单值[/b]

　　常量使用 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 inscoreList {
if(score > 50) {
tmpScore += 3
}
else {
tmpScore += 1
}
}
print(tmpScore)

　　在

if

语句中，条件必须是一个布尔表达式——像

ifscore { ...} 

这样的代码是错误的。可以使用 if和 let 来处理这种可选变量值 (可选变量值：有可能是一个具体的值，也有可能是 nil 表示缺失)

var optionalName: String? = "Eileen Leung"
optionalName = nil
var greeting = "Hello"

iflet 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?;

switchmyString {
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) innumberDict {
for num innumbers {
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) inmyDictionary {
print(key, ": [")
for value invalueList {
print("\t", value, ",")
}
print("}")
}

　　使用

while

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

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

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

　　在循环中使用

..<

和

...

来表示范围，其中

..<

创建的范围不包含上界，如果想包含的话需要使用

...。

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

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

　　

四、函数和闭包

　　使用

func

来声明一个函数，使用名字和参数来调用函数。使用

->

来指定函数返回值。

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

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

　　返回多个参数。

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

　　参数数量可变。

funcsumOf(numbers: Int...) ->Int {
var sum = 0
for number innumbers {
sum += number
}
return sum
}

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

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

funcreturnFifteen() ->Int {
var y = 10

funcadd() {
y += 5
}

add()
return y
}

// 调用处
print(returnFifteen())

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

funcmakeIncrementer() ->(Int ->Int) {
funcaddOne(number: Int) ->Int {
return 1 + number
}
return addOne
}

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

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

funchasAnyMatches(list: Array<Int>, condition: Int ->Bool) ->Bool {
for item inlist {
ifcondition(item) {
return true
}
}
return false
}

funclessThanTen(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)")