swift语言的学习笔记七(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

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

如果定义一个汽车类

 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] = "C"
     garage[3] = "D"
     garage[2] = "CC"

     println("index 1 = \(garage[0]) ,index 2 = \(garage[1]),index 3 = \(garage[2]) ,index 4 = \(garage[3])")
 }

输出

 index 1 = A ,index 2 = B,index 3 = CC ,index 4 = D

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

范围或集合操作

 let str = "123456"
 for c in str
 {
      println(c)
 }

fallthrough

由于swift中的switch语句中可以省去了break的写法，但在其它语言中省去break里，会继续往后一个case跑，直到碰到break或default才完成。在这里fallthrough就如同其它语言中忘记写break一样的功效。

 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)

输出：

 The number 1 is a prime number, and also an integer

where

swift中引入了where 来进行条件判断。

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

当switch的条件满足where 后面的条件时，才执行语句。

is

as

is 常用于对某变量类型的判断，就像ＯＣ中 isKindClass ，as 就有点像强制类型转换的意思了。

 for view : AnyObject in self.view.subviews
 {
     if view is UIButton
     {
         let btn = view as UIButton;
         println(btn)
     }
 }

OC的写法：

 for (UIView *view  in self.view.subviews)
 {
       if ([view isKindOfClass:[UIButton class]])         //is 操作
      {
              UIButton *btn =(UIButton *)view             //as 操作
       }
 }

super

基类的关键语，通常称父类

__COLUMN__, __FILE__, __FUNCTION__, __LINE__

是不是有点像宏定义啊。

 println(__COLUMN__ ,__FILE__, __FUNCTION__, __LINE__)

输出：

 (17, /Users/apple/Desktop/swiftDemo/swiftDemo/ViewController.swift, viewDidLoad(), 62)

set,get

常用于类属性的setter getter操作。

willSet，didSet

在swift中对set操作进行了扩展，willset 在set新值成功前发生，didset在设置新值成功后发生。

inout

对函数参数作为输出参数进行修饰。

 func swapTwoInts(inout a: Int, inout b: Int) {
     let temporaryA = a
     a = b
     b = temporaryA
 }

mutating

具体不是很理解，好像是专为结构体使用而设置的变体声明

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

测试

 func testMutating()
 {
     var a = SimpleClass()
     a.adjust()
     let aDescription = a.simpleDescription
     println(aDescription)

     var b = SimpleStructure()
     b.adjust()
     let bDescription = b.simpleDescription
     println(bDescription)
 }

override
父子类之间的函数重写，即复盖。

unowned, unowned(safe), unowned(unsafe)

无宿主引用。

[unowned self] 或[unowned(safe) self] 或[unowned(unsafe) self]

weak

弱引用，使得对象不会被持续占有