Swift基本语法

var 声明变量
let 声明常量
var myVariable = 42 赋值的类型必须与初始化一样
let myVariable ：Double = 0.1
let label = "like"
let width = 94.5
let widthLabel = label + String(width)
let sumStr = "Sum is \(myVariable + width)";
\()把结果转换成字符串

字典/数组
var myArray = ["a","b","c"]
var myDic = ["key1":"value1"]
获取值
var arrValue = myValue[1]
var dicValue = myDic["key1"]
创建空数组和空字典
var emptyArray = String[]()
var emptyDic = Dictionary<String,Float>()
如果类型信息可以被推断出来，那么就可以用[]和[:]来创建数组和空字典

条件语句中，条件的（）可以省略，但是{}必须留下
在if语句中条件必须是Bool类型的表达式
if 2{}//错误

控制流语句
for in循环语句
for score in ScoreArray{}
可以使用if 和let来使用缺值得情况，有些变量的值是可选的，一个可选的值可能是一个具体的值或者是nil。在类型后面加一个？标记变量，表示这个变量是可选的。
var optionName:String? = "Swift"
if let name = optionName {
println("hello \(name)")
}

如果optionName的可选值是nil，条件会判断为false，不会把值赋给let后面的常量

Switch后面的判断条件支持任意类型的数据以及各种比较操作。当switch匹配到子句后，就会跳出，不会继续执行下去

可以使用for in 来遍历字典
for (key,value) in myDic{}

for循环中，你可以使用..来表示范围，也可以使用传统的写法，两者等价
for i in 1..3{}
不包括上界
如果想要包括上界使用...

函数
使用func来定义一个函数
func testFun()//无参,无返回值
func testFun(name：String) ->String//有参数，有返回值
testFun("xiaoming")

使用一个元组返回多个值
func testTuple() -> (Double,Int,String)
函数的参数是可变的情况，用数组来获取他们
func variableFun (numvbers:Int...){
var sum = 0;
for num in numbers{
sum += num;
}
return sum;
}
variableFun (1,2,3)

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

func funInFun() -> Int
{
Int y
func add(){
y += 1
}
add()
return y
}

函数可以当做参数传给另一个函数
func funVariable(list:Int[],condition:Int ->Bool) ->Bool
{
for item in list{
if condition(item){
return ture
}
}
return false
}
函数是一等公民，意味着函数可以作为一个函数的返回值
func backVariable() ->(Int ->Int )
{
func add(num:Int) ->Int
{
return num + 1
}
return add(1)
}

闭包
函数其实是一种特俗的闭包，你可以使用{}来创建一个匿名的闭包
闭包是一种功能性自包含模块，可以在代码中被传递和使用，Swift的闭包和C语言OC语言的block代码以及其他语言的lambdas比较相似
闭包可以捕获和存储所在上下文中任意常量和变量的引用。这就是所谓的闭合并包裹这些常量和变量。Swift会为您管理在捕获过程中设计到的内存操作
闭包采用如下三种方式之一：
1、全局函数是一个有名字但是不会捕获任何值的闭包
2、嵌套函数是一个有名字并且可以捕获其封闭函数域内值得闭包
3、闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的没有名字的闭包
Swift的闭包表达式拥有简介的风格，并鼓励在常见场景下以实现语法优化，主要优化如下：
1、利用上下文推断参数和返回值类型
2、单表达式闭包可以省略return关键字
4、参数名称简写
5、Trailing闭包语法
闭包表达式
闭包表达式的一般语法如下：
{
(parameters) ->returnType in
statements
}
in表示闭包的参数和返回值类型定义已经完成，闭包的函数体即将开始。
闭包表达式的语法可以提供常量、变量和inout作为参数，但是不提供默认值。也可以在参数列表的最后使用可变参数。元组也可以.作为参数和返回值
例子：
reversed = sort(name,{//内联闭包
(s1:String,s2:String) ->Bool in
return s1>s2
})
以上闭包的参数类型和返回值类型都可以被推断出来，所以可以省略

reversed = sort(name,{//内联闭包
s1,s2 in
return s1>s2
})
实际上，通过内联闭包表达式构造的闭包作为参数传递给函数时，都可以推断出闭包的参数和返回值的类型，这意味着几乎不需要利用完整格式来构造任何内联闭包

单行表达式闭包可以省略return隐式返回单行表达式的结果

reversed = sort(name,{s1,s2 in s1>s2})

参数名简写
Swift自动为内联函数提供了函数名简写的功能，你可以直接通过＄0，＄1等名称来引用闭包参数的值。
如果在闭包表达式中使用参数名称简写，可以在闭包参数列表中省略对其的定义，对应类型会·通过函数的类型进行推断，in也可以省略，因为此时的比表表达式直接由闭包函数体构成
reversed = sort(name,{＄0>＄1})

运算符函数
Swift的String类型定义了关于>的字符串实现，这正好与sort的第二个参数吻合。因此可以只传递一个>，Swift可以自动判断
reversed = sort(name,>)

Trailing闭包
如果你想要将一个很长的闭包表达式作为函数的最后一个参数，可以使用Trailing闭包来增强函数的可读性
func someFun(coluser:()->()){
//函数体
}
//不使用trailing闭包的情况下进行函数调用
someFun({
//闭包主体
})

//使用Trailing闭包进行函数调用
someFun（）{
//闭包主体
}

reversed = sort(name）{＄0>＄1}
如果函数只需要闭包表达式一个参数，那么可以把（）省略。
Array的map方法，是将数组中的每一个元素都调用一次闭包函数，并返回元素所映射的值。map方法返回一个映射后的数组。map方法只有闭包表达式这个唯一的参数
let digitNames = [
0: "Zero", 1: "One", 2: "Two", 3: "Three", 4: "Four",
5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"]

let numbers = [16, 58, 510]
var strings = numbers.map{
mapFun(value:Int)->String in
var outPut = ""
if value == 0
{
outPut = digitNames[0]
}else{
while(value > 0)
{
outPut = digitNames[value % 10]!+outPut
value /= 10
}
return outPut
}
}
字典中下标跟着一个!，因为字典返回的是一个可选值，表明即使key不存在也不会查找失败。digitNames[value % 10]返回的总是有效的下标，所以！用于强展开在可选下标中的值