首页 > 代码库 > Swift语言入门之旅

Swift语言入门之旅

Swift语言入门之旅 




学习一门新的计算机语言,传统来说都是从编写一个在屏幕上打印“Hello world”的程序开始的。那在


Swift,我们使用一句话来实现它:


println("Hello, world")


如果你编写过C或者Objective-C语言,Swift中的这个语法看起来便很熟悉,这句话却是一个完整的程序


。你无须为了得到输入/输出或字符串处理去导入一个独立的功能库。编写全局代码通常用于程序的进入


点。你不需要写一个main函数,你也不需要为每个语句写个逗号作为结尾。


这个入门之旅将给你足够的信息去开始编写Swift代码,你可以实现许多的编程任务。这个过程中如果你


有些内容不理解也不要担心,我们将在本书的其他章节细节处为您解释。 


批注:


为了更好的体验开发,请在Xcode中使用playground编辑这个章节的代码。Playgrounds允许你在一边编


辑代码的同时看到代码的即时运行结果。


简单赋值:


用于你把一个常量和变量作为成变量。常量的值不必每次都传给编译器,但你必须提前赋个数值给它。


就是说常量可以赋值一次而多处引用。


var myVariable = 42


myVariable = 50


let myConstant = 42


相同的类型才能进行常量和变量的赋值,但是,你不用每次都显式地定义类型,编译器可以自动判断。


创建常量或变量的时候顺便赋值可以让编译器知道它属于什么类型。上面的例子,编译器指定


myVariable变量属于整数类型,因为它用一个整数进行初始化。


如果初始值不能表达足够的类型信息(或没有初始值),则在变量后面加一个冒号和指定的类型。


let implicitInteger = 70


let implicitDouble = 70.0


let explicitDouble: Double = 70


练习:


显式创建一个值为4的浮点类型的常量


 赋值不会自动隐式地变成另外一种类型,如果你需要把一个赋值变更到另外一种类型,你需要显式地创


建目标类型的实例。


let label = "The width is "


let width = 94


let widthLabel = label + String(width)


练习: 


试着把最后一行的字符串转换声明去掉,看看会出什么错误?


这里有更简便的方法把数值包含在字符串里面:把数值写在括号里面,把斜杠写在括号前面,示例如下





let apples = 3


let oranges = 5


let appleSummary = "I have \(apples) apples."


let fruitSummary = "I have \(apples + oranges) pieces of fruit."


试验:


在字符串中使用 \()包含一个浮点计算结果,同时也包含对某个人的名字和祝词。


使用方括号([])创建数组和字典,然后在方括号中使用索引下标存取各元素的值。


var


shoppingList = ["catfish", "water", "tulips", "blue paint"]


shoppingList[1] = "bottle of water"


var occupations = [


    "Malcolm": "Captain",


    "Kaylee": "Mechanic",


]


occupations["Jayne"] = "Public Relations"


我们使用初始化语法来创建空数组和字典


let emptyArray = String[]()


let emptyDictionary = Dictionary<String, Float>()


如果能推断指定类型,你可以写一个空数组[]和空字典[:]- 例如: 当你设置一个新给变量或传值给函


数的参数的时候。


shoppingList = []   // 购物和放置各种东西.


控制流:


使用if和switch来创建一个条件选择逻辑,使用 for-in , for,while,和do-while来创建循环,大括号


里面放置在条件或循环变量是可选的内容,而方括号在声明主体中则是必备项。


let individualScores = [75, 43, 103, 87, 12]


var teamScore = 0


for score in individualScores {


    if score > 50 {


        teamScore += 3


    } else {


        teamScore += 1


    }


}


teamScore


在一个if的语句中,条件值必须是布尔表达式,所以象这样的代码是会出错的:if score{...}, score不


会隐式地返回零值。


你可以一起使用if和let语句赋值,但有可能赋值是空的,这些值代表它是可选的。一个可选值可以是包


含实际值或是一个代表数值是空值的nil值。在类型声明后面加上一个问号代表这个定义的数值是可空的





var optionalString: String? = "Hello"


optionalString == nil


var optionalName: String? = "John Appleseed"


var greeting = "Hello!"


if let name = optionalName {


    greeting = "Hello, \(name)"


}


试验:


将optionalName设置为nil. 请看那个输出祝福语句的结果有什么变化?判断optionName是空值时加上其


他子句设置输出不同的祝语。


如果可选值是nil,条件判断为假,大括号中的代码也将不会被执行。如果可选项不是nil的话,数值将被


赋值给let后面指定的变量,同时,在后面的大括号中的代码中,该变量将是可以访问得到的。


开关语句(switch)支持所有的的类型和丰富多样的各式比较,他们并不是只限定于整数或只是测试它是


否相等。


let vegetable = "red pepper"


switch vegetable {


case "celery":


    let vegetableComment = "Add some raisins and make ants on a log."


case "cucumber", "watercress":


    let vegetableComment = "That would make a good tea sandwich."


case let x where x.hasSuffix("pepper"):


    let vegetableComment = "Is it a spicy \(x)?"


default:


    let vegetableComment = "Everything tastes good in soup."


}


试验:


请尝试去掉这个最后这个默认的default case选项,看看会得到什么错误。


当执行完对应的case分支代码后,程序将退出switch语句,不再接着遍历下一个case,所以也不用在每


个case分支的结尾声明跳转出switch。你可以使用for-in来遍历所有的字典里面的分项。


l


largest


试验:


和程序里面检查最大数字的变量相类似,在程序中加入另外一个变量跟踪哪类的数字是最大的。


我们使用while语句以重复一个代码块的执行,直到条件变化而退出。循环的条件可以放置在语句块的最


后面,只要语句执行到最后就可以击发判断。


var n = 2


while n < 100 {


    n = n * 2


}


n


var m = 2


do {


    m = m * 2


} while m < 100


m


你可以在循环中使用一个循环指标,使用两个点 (“..”) 来隔开起始值和终值表述它范围或者明确定


义它的起始值,终止条件或步进值,下面是两个相同功能的循环语句。


var firstForLoop = 0


for i in 0..3 {


    firstForLoop += i


}


firstForLoop


var secondForLoop = 0


for var i = 0; i < 3; ++i {


    secondForLoop += 1


}


secondForLoop


使用两个点号表示循环指标不包含终点值,使用三个点号表示循环指标包含终点值。


函数和闭包:


使用func来定义一个函数。给出函数名字和在括号中指出参数后我们就可以访问一个函数,同时我们在


定义函数的输入参数的名字类型和输出的类型之间使用“->”来隔开。


func greet(name: String, day: String) -> String {


    return "Hello \(name), today is \(day)."


}


greet("Bob", "Tuesday")


试验:


移除名称为day 的输入参数,加入一个参数,使函数返回今天的特殊祝福语句。


使用元组来表达函数返回多个值


func getGasPrices() -> (Double, Double, Double) {


    return (3.59, 3.69, 3.79)


}


getGasPrices()


函数同样也可以输入可变数量的参数组


 func sumOf(numbers: Int...) -> Int {


    var sum = 0


    for number in numbers {


        sum += number


    }


    return sum


}


sumOf()


sumOf(42, 597, 12)


试验:


编写一个函数用于计算它的输入函数的平均值。


函数可以嵌套。嵌套函数可以使用调用它的上级函数的变量。 如果代码太长或太复杂,您可以使用嵌套


函数来优化代码。


 func returnFifteen() -> Int {


    var y = 10


    func add() {


        y += 5


    }


    add()


    return y


}


returnFifteen()


函数是优先级最高的类型,它可以使函数用另外一个函数作为返回值。


func makeIncrementer() -> (Int -> Int) {


    func addOne(number: Int) -> Int {


        return 1 + number


    }


    return addOne


}


var increment = makeIncrementer()


increment(7)


函数可以把另外一个函数作为参数。


func 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, 7, 12]


hasAnyMatches(numbers, lessThanTen)


函数是一个特例的闭包,你可以使用大括号包含一段没有名字的代码闭包。输入参数和输出参数之间应


使用in语法隔开函数的主体。


numbers.map({


    (number: Int) -> Int in


    let result = 3 * number


    return result


    })


试验:


请重写上面的代码段判断输入值为奇数则返回零值。


你有更几个更简练的方法编写代码闭包,当闭包的类型是确定的,比如是一个回调或代理代码,你可以


忽略输入参数的类型或返回的类型。单个语句的代码闭包隐含地返回语句的值(不须return)。


numbers.map({ number in 3 * number })


你可以使用位置编号引用参数值而不是使用它的名字,这样写有利于我们编写非常短的代码闭包。 一个


代码闭包可以在函数圆括号后面传给函数作为最后一个输入参数。


sort([1, 5, 3, 12, 2]) { $0 > $1 }


对象和类:


类名


我们使用class语法定义类,类的属性和定义和普通定义一个变量或常量一样没有区别,但属性要定义在


类的定义块里面,类的方法和函数亦然。


class Shape {


    var numberOfSides = 0


    func simpleDescription() -> String {


        return "A shape with \(numberOfSides) sides."


    }


}


实验:


在上面的类定义中使用let语法增加一个常量属性,增加另外一个带有一个参数的方法。


创建类的实例就是在类名后面加上一对圆括号。 使用点语法存储这个类实例的属性和程序方法。


var shape = Shape()


shape.numberOfSides = 7


var shapeDescription = shape.simpleDescription()


这个版本的shape类看起来好象缺少了什么东西:一段初始化类实例的程序,那么我们使用init函数来创


建一个。


class NamedShape {


    var numberOfSides: Int = 0


    var name: String


    


    init(name: String) {


        self.name = name


    }


    


    func simpleDescription() -> String {


        return "A shape with \(numberOfSides) sides."


    }


}


注意我们使用self修饰符来区别类的name属性和构造函数的name输入参数。创建一个类的实例,参数传


给类的构造函数就象调用普通函数一样。类中所有的属性需要附于指定值,可以在定义的时候赋值,比


如上面代码中的numberOfSides,也可以在类实例初始化过程中赋值,比如上文的name。


我们使用deinit来创建一个析构过程,当你准备释放对象,需要执行一些精理的代码你会用到它。


子类的命名是在其继承的父类名字后面加上一个冒号和它的名字。不是所有类都需要继承自标准根类。


你可以在子类中定义一个与父类同名的方法,使用override保留字定义和覆盖它。如果没有使用


override而重名覆盖父类的方法。编译器侦测和给出错误 。如果使用了override但却没有实际覆盖父类


的任何方法的话,编译器也将侦测到。


class Square: NamedShape {


    var sideLength: Double


    init(sideLength: Double, name: String) {


        self.sideLength = sideLength


        super.init(name: name)


        numberOfSides = 4


    }


    


    func area() ->  Double {


        return sideLength * sideLength


    }


    


    override func simpleDescription() -> String {


        return "A square with sides of length \(sideLength)."


    }


}


let test = Square(sideLength: 5.2, name: "my test square")


test.area()


test.simpleDescription()


实验:


编写一个NamedShape的子类,命名为Circle,使用半径值和名字作为构造函数的参数。和上面的代码类


似,实现Circle类的area和describe方法。


类属性除了存储,我们还可以定义的getter和setter,即写入的方法和读取的方法。


class EquilateralTriangle: NamedShape {


    var sideLength: Double = 0.0


    


    init(sideLength: Double, name: String) {


        self.sideLength = sideLength


        super.init(name: name)


        numberOfSides = 3


    }


    


    var perimeter: Double {


    get {


        return 3.0 * sideLength


    }


    set {


        sideLength = newValue / 3.0


    }


   }


    


    override func simpleDescription() -> String {


        return "An equilateral triagle with sides of length \(sideLength)."


    }


}


var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")


triangle.perimeter


triangle.perimeter = 9.9


triangle.sideLength


在周长的setter设置方法上,用于更新的数值默认为newValue,你可以提供显式的名字在set符号后面的


圆括号中。 


请注意 EquilateralTriangle类的构造函数有以下三个步骤的内容:


1、初始化继承后的各子类属性。


2、调用父类的构造函数。


3、更新父类定义的属性值、完成所有其他初始化工作,比如调用其他方法,其他getter和setter读取与


设置方法都可以在这里实现。


如果你不需要计算属性的值,而是要在代码运行之前或设置新数值之后执行其他代码,那就要使用


willSet和didSet。例如下面的类定义中实现正方形的边与等边三角形相同的边长。


class TriangleAndSquare {


    var triangle: EquilateralTriangle {


    willSet {


        square.sideLength = newValue.sideLength


    }


    }


    var square: Square {


    willSet {


        triangle.sideLength = newValue.sideLength


    }


    }


    init(size: Double, name: String) {


        square = Square(sideLength: size, name: name)


        triangle = EquilateralTriangle(sideLength: size, name: name)


}


}


var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")


triangleAndSquare.square.sideLength


triangleAndSquare.triangle.sideLength


triangleAndSquare.square = Square(sideLength: 50, name: "larger square")


triangleAndSquare.triangle.sideLength


类的方法有一个与函数不同的地方。函数的参数只能在函数内使用,而方法可以调用你本地的变量(除


了方法的第一个参数名)。方法的参数名字在方法里面是不变的,你可以定义它的别名,在方法体内代


替默认的参数名使用。


class Counter {


    var count: Int = 0


    func incrementBy(amount: Int, numberOfTimes times: Int) {


        count += amount * times


    }


}


var counter = Counter()


counter.incrementBy(2, numberOfTimes: 7)


当你需要使用可选值的时候,你也可将问号附加在方法,属性名字之前。如果问号前的值是nil空值,所


有的在问号之后的都被忽略,整个表达式都将置空(nil)。不为空值的话,该值将解包,所有的在问号之


后的值将生效和附值。对于整个表达式来说,以上两种情况使整个表达式的值变成可选值。


let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")


let sideLength = optionalSquare?.sideLength


枚举和结构:


使用enum来创建枚举。就象类和其他命名类型一样,枚举能包含存储枚举值的方法定义。


enum Rank: Int {


    case Ace = 1


    case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten


    case Jack, Queen, King


    func simpleDescription() -> String {


        switch self {


        case .Ace:


            return "ace"


        case .Jack:


            return "jack"


        case .Queen:


            return "queen"


        case .King:


            return "king"


        default:


            return String(self.toRaw())


        }


    }


}


let ace = Rank.Ace


let aceRawValue = http://www.mamicode.com/ace.toRaw()


实验:


写一个通过对比枚举的裸数值来对比它的序列值的函数。


在上文的示例程序中,枚举的裸值类型是整数,所以你只要指定好第一个枚举的裸值,其他剩余的数值


将按序存放,当然你也可以使用字符串和浮点数值作为枚举的裸值类型。


你可以使用toRaw和fromRaw函数转换枚举的裸值和它的序列值。


 if let convertedRank = Rank.fromRaw(3) {


    let threeDescription = convertedRank.simpleDescription()


}


 枚举的成员值是一个可调用的实际值,不是裸数据的别名。除非裸数据没有可读性,你无需提供名字的


转换。


enum Suit {


    case Spades, Hearts, Diamonds, Clubs


    func simpleDescription() -> String {


        switch self {


        case .Spades:


            return "spades"


        case .Hearts:


            return "hearts"


        case .Diamonds:


            return "diamonds"


        case .Clubs:


            return "clubs"


        }


    }


}


let hearts = Suit.Hearts


let heartsDescription = hearts.simpleDescription()


试验:


添加一个color方法到suit枚举中,对应spades和clubs返回”black”,对应hearts和diamonds返回”


red”


注意这里的两种hearts枚举成员引用的方式: 当对hearts常量附值的时候,枚举成员suit.hearts是使


用枚举全名,因为常量没有显式指定类型(所以无法判断是否来自枚举)。而在switch里面,枚举使用


简写的.Hearts就可以访问主要是因数它的self已指向suit类型。所以你只要确定所属的类型就可以对成


员进行简写式的访问。


使用struct来创建结构。结构支持很多和类一样的行为,包括方法和构造函数。两者之间最重要的区别


是结构使用拷贝方式传值,而类使用引用方式传值。


struct Card {


    var rank: Rank


    var suit: Suit


    func simpleDescription() -> String {


        return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"


    }


}


let threeOfSpades = Card(rank: .Three, suit: .Spades)


let threeOfSpadesDescription = threeOfSpades.simpleDescription()


试验:


Add a method to Card that creates a full deck of cards, with one card of each combination 


of rank and suit.


枚举成员的实例可以有对应的数值,名字相同的枚举成员可以有不同值。你可以在创建它们的时候再给


予不同的值。枚举的别名数值和裸值是不同的:裸值对所有的枚举实例来说都是相同值,你可以在定义


枚举的时候就提供裸值。


例如,我们写一个服务器程序提供获取太阳的升起和日落的时间计算功能,程序返回计算结果或返回计


算错误信息,程序如下


enum ServerResponse {


    case Result(String, String)


    case Error(String)


}


let success = ServerResponse.Result("6:00 am", "8:09 pm")


let failure = ServerResponse.Error("Out of cheese.")


switch success {


case let .Result(sunrise, sunset):


    let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."


case let .Error(error):


    let serverResponse = "Failure...  \(error)"


}


试验:


为ServerResponse和 switch添加第三个case。


请注意代码中经过switch判断,从ServerResponse返回的surise和sunset times的过程机制。


协议和扩展: 


我们使用protocol关键字定义协议


protocol ExampleProtocol {


    var simpleDescription: String { get }


    mutating func adjust()





类、枚举和结构可以采用和声明协议(protocols)。


class SimpleClass: ExampleProtocol {


    var simpleDescription: String = "A very simple class."


    var anotherProperty: Int = 69105


    func adjust() {


        simpleDescription += "  Now 100% adjusted."


    }


}


var a = SimpleClass()


a.adjust()


let aDescription = a.simpleDescription


struct SimpleStructure: ExampleProtocol {


    var simpleDescription: String = "A simple structure"


    mutating func adjust() {


        simpleDescription += " (adjusted)"


    }


}


var b = SimpleStructure()


b.adjust()


let bDescription = b.simpleDescription


试验:


编写一个遵守这个protocol的枚举类型。


注意上文程序中使用mutating关键字在SimpleStructure结构中对方法进行修改(结构是静态的)。而 


SimpleClass类不需要使用 mutating关键字修饰 adjust 主要是因为类中就可以进行类的修改(类是动


态的)。


使用extension对现有的类型添加新功能,比如新的方法或计算属性。你可以使用extension对定义在其


他地方的类型添加协议,甚至是你从其他的框架和库导入的类。


extension Int: ExampleProtocol {


    var simpleDescription: String {


    return "The number \(self)"


    }


    mutating func adjust() {


        self += 42


    }


}


7.simpleDescription


试验:


为Double类型添加了个absoluteValue属性作为对该类型的扩展。


你可以和使用其他命名类型一样使用协议,比如你创建一个不同类的对象实例集合,但又实现自相同的


协议。


当你继承协议,你可以存储它的属性数值,但直接调用它的方法将会报错(协议方法需要在继承中另外


实现)。


let protocolValue: ExampleProtocol = a


protocolValue.simpleDescription


// protocolValue.anotherProperty  // Uncomment to see the error


虽然protocolValue是 ExampleProtocol的实例,而 ExampleProtocol有一个继承类叫SimpleClass,但


编译把它当然是独立的解释ExampleProtocol的类型,并不是对协议的扩展,你不能在独立实例化


ExampleProtocol的ProtocolValue中调用它的方法和属性。


泛型


在一对尖括号之间的命名代表泛化的类型或函数


func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] {


    var result = ItemType[]()


    for i in 0..times {


        result += item


    }


    return result


}


repeat("knock", 4)


你可以编写泛化后的函数和方法,也可以编写泛化类、泛化枚举、结构。


// Reimplement the Swift standard library‘s optional type


enum OptionalValue<T> {


    case None


    case Some(T)


}


var possibleInteger: OptionalValue<Int> = .None


possibleInteger = .Some(100)


在类名后面使用where命令来指定类型必须满足的条件,比如下面的代码是要实现一个协议接口,需要满


足where规定的两个类型约束条件。


func  anyCommonElements <T, U where T: Sequence, U: Sequence, T.GeneratorType.Element: 


Equatable, T.GeneratorType.Element == U.GeneratorType.Element> (lhs: T, rhs: U) -> Bool {


    for lhsItem in lhs {


        for rhsItem in rhs {


            if lhsItem == rhsItem {


                return true


            }


        }


    }


    return false


}


anyCommonElements([1, 2, 3], [3])


试验:


修改anyCommonElements函数,实现把两个序列的共同元素组成数组并返回。


在简单的情况下,你可以忽略where命令简单把protocol或类名写在冒号后面。编写 <T: Equatable>是


和 <T where T: Equatable>.相等同的。