SWIFT基础语法 (一)

SWIFT的main函数是隐藏的main函数，运行的时候会直接被调用，没有分号（加上也不会报错），用let定义常量，var定义变量。

常量和变量

常量和变量

let myValue = 40
var anotherValue = 30
anotherValue = 20

编译器可以通过你的赋值判断你所创建的常量或变量的类型。如果要是不能准确判断的话，就在变量名后指定类型。

let valueDouble = 2.0
let valueInteger = 2
let valueDouble:Double = 2

值转化类型

值转化类型

let strLable = "The width is"
let width = 94
let withLable = strLable + String(width)
//还有一种非常方便的方法，在字符串里添加值，在圆括号中书写值，并在括号前添加反斜线 \
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples)apples"
let fruitSummary = "I have \(apples + oranges) piece of fruit"

字典、数组

使用[]来创建数组和字典，通过方括号中的索引或键名来访问其中的元素。

var shoppingList = ["a","b"]
shoppingList[1]="26 of b" //修改数组中的元素值
var occupations = ["name":"candy","age":19]
occupations["job"] = "iOS"  //向字典里添加键值对

//用初始化语法创建一个空的数组或者字典
let emptyArray = String[]()
let emptyDictionary = Dictionary<String,Float>()

//如果无法推断类型信息，可以用[]来创建一个空数组，使用[:]来创建一个空字典。
var shoppingListArray = []
var shoppingListDictionary = [:]

循环语句

用if和switch来作为条件控制，使用for-in、for、while、do-while来构造循环。包装条件或者循环变量的圆括号可以省略，但是主体外的花括号是必须的。

let individualScores = [76,78,98,0]
var teamScore = 0
var score in individualScores{
if score > 50{
teamScore +=3
else{
teamScore +=1
}
}
print("%@",teamScore)
//在if语句中，条件必须是一个布尔表达式-------这表示如“if score{。。。。。}”这样写的代码是错误的，并不能隐式的同0进行比较。

可以同时使用if 和let来防止值的丢失。这些值是可选的，可通过包含另一个值或者包含nil来指明该值不存在。通过在类型后添加问号来标记一个值为可选。

var optionalString:String? = "hello"
optionalString = nil
var optionalName:String? = "John"
if let name = optionalName
{
//如果optionalName不是nil的话， let name = optionalName 为true
NSLog("hello"+name)
}
//如果可选值为nil，则条件判断为false，花括号中的代码会被跳过。反之，可选值去包装并且赋值给let后面的常量（去包装：不再是可选的，成为了一个确切的值，不再存在为空的情况），使得去包装的值可以在代码块内访问。

switch

switch支持所有类型的数据，以及多种比较运算—没有限制必须是整数，也没有限制必须相等。

let vegetable = "red pepper"
switch vegetable{
case "celery":
let vegetableComment = "hahahha"
case "red pepper":
let vegetableComment = "red pepper"
case let x where x.hasSuffix("pepper"):
let vegetableComment = "is it a spicy \(x)?"
default:
let vegetableComment = "Everything tastes good in soup."
}
//执行完匹配到的case后，程序会跳出switch，而不是继续执行下一个case，所以不需要在case的代码后添加break来跳出switch。

使用for-in来迭代字典中的元素，需要提供一对名字来访问每一个键值对。

let interestingNumbers = [
"prime":[2,3,4,5,5],
"Fibonacci":[2,4,56,5],
"Square":[2,5,7,8,6,4]
]
var largest = 0
for (kind,numbers) in interestingNumbers{
for number in numbers{
if number > largest{
largest = number
}
}
}

使用while来重复执行一个代码块直到条件改变，循环条件可以放到最后，用于保证循环至少被执行一遍。

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

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

可以在循环中维持一个索引。一种方法是使用..来表示一段索引区域，另一种方法是显式的指明初始值、判断条件以及每次循环的增量。以下的两个循环做的是同样的事情：

var firstForLoop = o
for i in 0..3
{
firstForLoop += i
}

var secondForLoop = 0
for var i = 0; i < 3; i++ {
secondForLoop += 1
}
//使用..来创建一个或略最高值的取值区间，使用...构造的范围则同时包含最高值和最低值。

函数、闭包

函数和闭包：使用func来声明一个函数。通过在函数名后面添加包含参数列表的花括号来执行函数，使用->来分离参数和返回类型。

func greet (name:String,day:String)->String{
return "Hello \(name),today is \(day)"
}

元组

使用元组（tuple）来返回多个值

func getGasPrices() -> (String,Double,Int){
return ("name",168.0,19)
}

函数可以有可变长度的参数，通过数组来包含它们。

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

函数可以嵌套。嵌套函数可以访问在外部函数中声明的变量。可以使用嵌套函数来包装冗长和复杂的代码。

funcc returnFifteen() -> Int{
var y = 10

return  add(y)
}
func add(number:Int){
number += 5
}

一个函数可以使用另一个函数作为参数。

fun hasAnyMatches(list:Int[],condition:Int -> Bool) -> Bool{
for item in list{
if condition(item){
return true
}
}
return false
}
func lessThanTen(number:Int) -> Bool{
return number < 10
}
var numbers = [20,19,3]
hasAnyMatches(numbers,lessThanTen)