• 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 = 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.


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


    予不同的值。枚举的别名数值和裸值是不同的:裸值对全部的枚举实例来说都是同样值,你能够在定义


    枚举的时候就提供裸值。


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


    算错误信息,程序例如以下


    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的过程机制。


    协议和扩展: 


    我们使用protocolkeyword定义协议


    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的枚举类型。


    注意上文程序中使用mutatingkeyword在SimpleStructure结构中对方法进行改动(结构是静态的)。而 


    SimpleClass类不须要使用 mutatingkeyword修饰 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>.相等同的。
  • 相关阅读:
    docker清理无用资源
    为什么不需要在 Docker 容器中运行 sshd
    转载:SQL注入演示demo
    docker方式安装prometheus主控
    promethus监控结构
    oracle的函数
    oracle冷备份后恢复
    oracle的冷备份
    oracle常用
    oracle的系统文件的查询
  • 原文地址:https://www.cnblogs.com/blfshiye/p/4019700.html
Copyright © 2020-2023  润新知