每一种语言都有相应的关键词，每个关键词都有他独特的作用，来看看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

用来定义一个类，相信大家并不陌生。

如果定义一个汽车类

class Car  
{  
      init()  
      {  
            //to do init something.  
       }  
}  

init

相对于类的构造方法的修饰。

 deinit

相对于类的释构方法的修饰。

对于类的构造和释构在swift 中需要使用关键词来修饰，而很多高级语言并不需要特别的指定，便C++ 只需要类名与构造函数名相同就可以，不需要额外的关键词。

 enum

 枚举类型的声明，这个与很多语方都相通。

 

extension

扩展，有点像oc中的categories 。

Swift 中的可以扩展以下几个：
添加计算型属性和计算静态属性
定义实例方法和类型方法
提供新的构造器
定义下标
定义和使用新的嵌套类型
使一个已有类型符合某个接口

如下面扩展字符串：

 

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]  
    }  
}  

测试：

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]")  
}  

输出：

1234567890  
使用下标索引访问第13个字符 n  
使用负号下标即变为从右往左访问字符 界  
使用负号下标即变为从右往左访问字符 世  
使用下标Range来访问范围 ina o  
- china[1:4]: hina  
- china[10:13]: atin 

func

 用来修饰函数的关键词。

import

 导入头文件，相信大家都不陌生，但在swift 中好像被用来导入包，如import UIKit。 因为swift中没有了头文件的概念。

let

用来修改某一常量的关键词。像const 限定差不多

var

用来声明变量。

 protocol

协议，也有称为接口，这个往往在很多高级语言中不能多重继承的情况下使用协议是一个比较好的多态方式。

 static

用来修饰变量或函数为静态

 struct

用来修饰结构体。

 subscript

下标修饰，可以使类(class)，结构体(struct)，枚举(enum) 使用下标访问。

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)  
            }  
              
        }  
    }  
}  

测试：

func testSubscript()  
{  
    var garage = Garage()  
    garage[0] = "A"  
    garage[1] = "B"  
    garage[2]