swift关键字
每一种语言都有相应的关键词，每个关键词都有他独特的作用，来看看swfit中的关键词：
关键词：
用来声明的：
“ class, deinit, enum, extension, func, import, init, let, protocol, static, struct, subscript, typealias, var.”
用于子句的：
“ break, case, continue, default, do, else, fallthrough, if, in, for, return, switch, where, while.”
表达式和类型的：
“ as, dynamicType, is, new, super, self, __COLUMN__, __FILE__, __FUNCTION__, __LINE__”
//特殊语境使用的:
“didSet, get, inout, mutating, override, set, unowned, unowned(safe), unowned(unsafe), weak , willSet”
class
用来定义一个类，相信大家并不陌生。
如果定义一个汽车类
<span style="font-family:Comic Sans MS;font-size:14px;">class Car
{
init()
{
//to do init something.
}
}</span>
init
相对于类的构造方法的修饰。
deinit
相对于类的释构方法的修饰。
对于类的构造和释构在swift 中需要使用关键词来修饰，而很多高级语言并不需要特别的指定，便C++ 只需要类名与构造函数名相同就可以，不需要额外的关键词。
enum
枚举类型的声明，这个与很多语方都相通。
extension
扩展，有点像oc中的categories 。
Swift 中的可以扩展以下几个：
添加计算型属性和计算静态属性
定义实例方法和类型方法
提供新的构造器
定义下标
定义和使用新的嵌套类型
使一个已有类型符合某个接口
如下面扩展字符串：
<span style="font-family:Comic Sans MS;font-size:14px;">extension String{
struct _Dummy {
var idxVal: Int
var _padding: Int
var _padding2: Int
var _padding3: Int
}
//过虑出数字
func fitlerCharater() -> String
{
var numberstr : String = ""
for character in self
{
let s :String = String(character)
//println(s.toInt())
if let hs = s.toInt()
{
numberstr += character
}
}
return numberstr
}
//扩展使用下标访问
subscript (i: Int) -> Character {
var dummy: _Dummy = reinterpretCast(i >= 0 ? self.startIndex : self.endIndex)
dummy.idxVal += i
let idx: String.Index = reinterpretCast(dummy)
return self[idx]
}
//扩展使用Range访问
subscript (subRange: Range<Int>) -> String {
var start: _Dummy = reinterpretCast(self.startIndex)
var end = start
start.idxVal = subRange._startIndex
end.idxVal = subRange._endIndex
let startIndex: String.Index = reinterpretCast(start)
let endIndex: String.Index = reinterpretCast(end)
return self[startIndex..endIndex]
}
}</span>
测试：
<span style="font-family:Comic Sans MS;font-size:14px;">func testExtension()
{
var str : String = "1234ab5国6cd7中8i90"
println(str.fitlerCharater())
let china: String = "china operating system public to 世界"
println("使用下标索引访问第13个字符 \(china[13])")
println("使用负号下标即变为从右往左访问字符 \(china[-1])")
println("使用负号下标即变为从右往左访问字符 \(china[-2])")
println("使用下标Range来访问范围 \(china[2...6])")
dump(china[1..5], name: "china[1:4]") //使用dump输出
dump(china[10...13], name: "china[10:13]")
}</span>
输出：
<span style="font-family:Comic Sans MS;font-size:14px;">1234567890 使用下标索引访问第13个字符 n 使用负号下标即变为从右往左访问字符 界 使用负号下标即变为从右往左访问字符 世 使用下标Range来访问范围 ina o - china[1:4]: hina - china[10:13]: atin</span>
func
用来修饰函数的关键词。
import
导入头文件，相信大家都不陌生，但在swift 中好像被用来导入包，如import UIKit。 因为swift中没有了头文件的概念。
let
用来修改某一常量的关键词。像const 限定差不多
var
用来声明变量。
protocol
协议，也有称为接口，这个往往在很多高级语言中不能多重继承的情况下使用协议是一个比较好的多态方式。
static
用来修饰变量或函数为静态
struct
用来修饰结构体。
subscript
下标修饰，可以使类(class)，结构体(struct)，枚举(enum) 使用下标访问。
<span style="font-family:Comic Sans MS;font-size:14px;">class Garage
{
var products : String[] = Array()
subscript(index:Int) -> String
{
get
{
return products[index]
}
set
{
if index < products.count //&& !products.isEmpty
{
products[index] = newValue
}
else
{
products.append(newValue)
}
}
}
}
</span>
测试：
<span style="font-family:Comic Sans MS;font-size:14px;">func testSubscript()
{
var garage = Garage()
garage[0] = "A"
garage[1] = "B"
garage[2] = "C"
garage[3] = "D"
garage[2] = "CC"
println("index 1 = \(garage[0]) ,index 2 = \(garage[1]),index 3 = \(garage[2]) ,index 4 = \(garage[3])")
}</span>
输出
<span style="font-family:Comic Sans MS;font-size:14px;">index 1 = A ,index 2 = B,index 3 = CC ,index 4 = D</span>
typealias
类型别名，就像typedef一样。借typedef unsigned long int UInt64同样在swift中也可能自定义类型。
break
跳出循环，通常用于for,while,do-while,switch
case
case相信大家并不陌生，常在switch中使用，但如今在swift中多了一个地方使用哪就是枚举类型。
continue
跳过本次循环，继续往后执行。
default
缺省声明。常见在switch中。
do, else,if, for, return, switch, while
这几个就不用多说了，越说越混。
in
范围或集合操作
<span style="font-family:Comic Sans MS;font-size:14px;">let str = "123456"
for c in str
{
println(c)
}</span>
fallthrough
由于swift中的switch语句中可以省去了break的写法，但在其它语言中省去break里，会继续往后一个case跑，直到碰到break或default才完成。在这里fallthrough就如同其它语言中忘记写break一样的功效。
<span style="font-family:Comic Sans MS;font-size:14px;"> let integerToDescribe = 1
var description = "The number \(integerToDescribe) is"
switch integerToDescribe {
case 1, 3, 5, 7, 11, 13, 17, 19:
description += " a prime number, and also";
fallthrough
case 5:
description += " an integer"
default :
description += " finished"
}
println(description)</span>
输出：
<span style="font-family:Comic Sans MS;font-size:14px;">The number 1 is a prime number, and also an integer</span>
where
swift中引入了where 来进行条件判断。
<span style="font-family:Comic Sans MS;font-size:14px;">let yetAnotherPoint = (1, -1)
switch yetAnotherPoint {
case let (x, y) where x == y:
println("(\(x), \(y)) is on the line x == y")
case let (x, y) where x == -y:
println("(\(x), \(y)) is on the line x == -y")
case let (x, y):
println("(\(x), \(y)) is just some arbitrary point")
}</span>
当switch的条件满足where 后面的条件时，才执行语句。
is
as
is 常用于对某变量类型的判断，就像ＯＣ中 isKindClass ，as 就有点像强制类型转换的意思了。
<span style="font-family:Comic Sans MS;font-size:14px;"> for view : AnyObject in self.view.subviews
{
if view is UIButton
{
let btn = view as UIButton;
println(btn)
}
}</span>
OC的写法：
<span style="font-family:Comic Sans MS;font-size:14px;">for (UIView *view in self.view.subviews)
{
if ([view isKindOfClass:[UIButton class]]) //is 操作
{
UIButton *btn =(UIButton *)view //as 操作
}
}</span>
super
基类的关键语，通常称父类 __COLUMN__, __FILE__, __FUNCTION__, __LINE__
是不是有点像宏定义啊。
<span style="font-family:Comic Sans MS;font-size:14px;">println(__COLUMN__ ,__FILE__, __FUNCTION__, __LINE__)</span>
输出：
<span style="font-family:Comic Sans MS;font-size:14px;">(17, /Users/apple/Desktop/swiftDemo/swiftDemo/ViewController.swift, viewDidLoad(), 62)</span>
set,get
常用于类属性的setter getter操作。
willSet，didSet
在swift中对set操作进行了扩展，willset 在set新值成功前发生，didset在设置新值成功后发生。inout
对函数参数作为输出参数进行修饰。
<span style="font-family:Comic Sans MS;font-size:14px;">func swapTwoInts(inout a: Int, inout b: Int) {
let temporaryA = a
a = b
b = temporaryA
}
</span>
mutating
具体不是很理解，好像是专为结构体使用而设置的变体声明
<span style="font-family:Comic Sans MS;font-size:14px;">protocol ExampleProtocol {
var simpleDescription: String { get }
mutating func adjust()
}
class SimpleClass: ExampleProtocol {
var simpleDescription: String = "A very simple class."
func adjust() {
simpleDescription += " Now 100% adjusted."
}
}
struct SimpleStructure: ExampleProtocol {
var simpleDescription: String = "A simple structure"
mutating func adjust() { //如果去除mutating 报Could not find an overload for '+=' that accepts the supplied arguments
simpleDescription += " (adjusted)"
}
}</span>
测试<span style="font-family:Comic Sans MS;font-size:14px;">func testMutating()
{
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription
println(aDescription)
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription
println(bDescription)
}</span>
override父子类之间的函数重写，即复盖。
unowned, unowned(safe), unowned(unsafe)
无宿主引用。
[unowned self] 或[unowned(safe) self] 或[unowned(unsafe) self]
weak
弱引用，使得对象不会被持续占有