zoukankan      html  css  js  c++  java

  • swift

    Swift3.0 基础学习梳理笔记(一)

    http://stackoverflow.com/

    • Xcode版本>=6.0
    • Mac 版本>=10.9.3
    • 文件扩展名.swift
    • 不需要编写main函数,按顺序从上往下执行
    • 不用在每条语句后加;，同一行有多条语句必须加;
    • 多行注释可嵌套注释

          /*外层注释

         /*内层注释

         内层注释*/

         外层注释*/

    • 用 let 关键字声明常量，用 var 关键字声明变量，可以在一行中声明多个常量或多个变量，由逗号分隔：var x = 0.0, y = 0.0, z = 0.0
    • 可以为常量或变量添加类型标注(type annotation)，var welcomeMessage: String
    • 字符串通过+号连接
    • 字符串插值是一种全新的构建字符串的方式，可以在其中包含常量、变量、字面量和表达式。你插入字符串字面量的每一项需要包裹在以反斜线为前缀的圆括号中：let multiplier = 3 ；let message = "(multiplier) times 2.5 is (Double(multiplier) * 2.5)"
    • println 输出后自动换行   print 少了自动换行
    • 可以使用任何字符命名常量和变量名，包括Unicode。常量与变量名不能包含数学符号、箭头、保留的（或者非法的）Unicode 码、连线与制表符。不能以数字开头，但是可以在变量名的其他地方包含数字。
    • 元组（tuples）是把多个值组合成一个复合值。元组内的值可以使任意类型，并不要求是相同类型。比如(404, "Not Found")    let http404Error = (404, "Not Found"),
      • 可以将一个元组的内容分解成单独的常量或变量 let http404Error = (404, "Not Found")   let (statusCode, statusMessage) = http404Error
        println("The status code is (statusCode)")  // prints "The status code is 404"

      • 如果只需要一部分元组的值，忽略的部分用下划线(_)标记:let (justTheStatusCode, _) = http404Error
      • 可以使用索引访问元组中的各个元素，索引数字从0开始:println("The status code is (http404Error.0)") // prints "The status code is 404"
        println("The status message is (http404Error.1)")
        // prints "The status message is Not Found"
      • 可以给元组的各个元素进行命名:let http200Status = (statusCode: 200, description: "OK") 

        可以使用元素名来访问这些元素的值:

        println("The status code is (http200Status.statusCode)")
        // prints "The status code is 200"
    • 使用可选（optionals）来处理可能缺失值的情况。
    • Swift 提供了8，16，32和64位的有符号和无符号整数类型。这些整数命名约定类似于C语言，如8位无符号整数类型是 UInt8，32位有符号整数类型是 Int32。像所有Swift的其他类型一样，整数类型采用大写命名法。可以访问每个整数类型的 min 和 max 属性获取其最小值和最大值。

      Swift 提供了一个特殊的整数类型：Int，长度与当前平台的字长相同。

          在32位平台上，Int和Int32长度相同。
          在64位平台上，Int和Int64长度相同。                                                                                                                                                 Swift 还提供了一个特殊的无符号类型UInt，长度与当前平台的字长相同：
          在32位平台上，UInt和UInt32长度相同。
          在64位平台上，UInt和UInt64长度相同。

    • 浮点数是由整数和小数部分组成，如 3.14159，0.1，-273.15。
      浮点数类型可以表示比整数类型更大范围的值，可以存储比 Int 类型更大或者更小的数字。Swift 提供了两种浮点数类型:

          Double：64位浮点数。当你需要存储很大或者很高精度的浮点数时使用此类型。
          Float：32位浮点数。精度要求不高时使用此类型。

      注意：Double 精确度很高，至少15位数字，而Float最少只有6位数字。选择哪个类型取决于你的代码需要处理的值的范围。

    • 数值类面值可以包括额外的格式来增强可读性。整数和浮点数都可以添加额外的零并且包含下划线，这不会影响字面量：

      let paddedDouble = 000123.456；let money = 001999
      let oneMillion = 1_000_000
      let justOverOneMillion = 1_000_000.000_000_1

    • 整数和浮点数之间的转换必须显示的指定类型:

      let three = 3
      let pointOneFourOneFiveNine = 0.14159
      let pi = Double(three) + pointOneFourOneFiveNine
      // pi equals 3.14159, and is inferred to be of type Double

      通过常量 three 的值创建一个新类型 Double 的值，所以，加号两边是相同的类型。如果不转换，是不允许相加的。

    • 类型别名就是给一个类型定义的一个小名。通过 typealias 关键字进行定义。
      类型别名是非常有用的，特别是一个非常有意义的名称时。比如，处理特定大小的外部来源的数据：

      typealias AudioSample = UInt16
    • 赋值运算没有返回值
    • 取余支持浮点运算 8 % 2.5 = 0.5
    • 布尔型（Bool）。布尔值是逻辑值，他们只能是真或假。Swift 提供了两个布尔常量值：true ，false。（不能是1和0）
    • 闭区间运算符（a...b）：包含从 a 到 b (包括 a 和 b )之间的所有的值。for index in 1...5 {
          println("(index) times 5 is (index * 5)")
      }  
    • 半闭区间运算符（a..b）：定包含从 a 到 b 但不包括 b 的区间内的所有的值。半闭区间主要用于从 0 开始的列表(如数组)，可以方便地取值从 0 到列表的长度(但不包括)。for index in 0..<5 {
    • 对整数进行益处运算（上溢出、下溢出），在取值范围内来回循环，上溢出到最小值，下溢出到最大值
    • if 语句来判断一个可选的是否包含一个值。如果包含一个值，结果为 true ；否则 false。
      • 如果你确定可选包含一个值，你可以在名称后面加惊叹号 ( ! ) 访问可选的值。惊叹号 ( !)表示：“ 这个可选有值，请使用它。” 这就是所谓的 强制解析（forced unwrapping）可选的值。

      • 可选绑定（optional binding）用来判断可选是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定一般用在 if 和 while 语句中，对可选的值进行判断并把值赋给一个常量或者变量。

        if let  constantName  =  someOptional  {
             statements
        }
    • 流程控制
      • For 循环
        • 可以使用for-in循环去迭代集合项，例如数字范围，数组项或者字符串中的字符for index in 1...5 {
              println("(index) times 5 is (index * 5)")
          }
        • 条件判断和递增的For循环for var index = 0; index < 3; ++index {
              println("index is (index)")
          }
      • while 循环
        • 循环从判断一个循环条件开始：如果条件为true，重复执行一组代码，直到条件变为false。
        • do-while 是while 循环的另一种形式，它和 while 的区别是：先执行一次循环的代码块，再在判断循环条件，然后重复执行循环的代码块直到循环条件为 false 。
      • 条件语句
        • if

        • switch

          1. 语句最简单的形式就是把某个值与若干个相同类型的值作匹配：

            switch  some value to consider  {
             case  value 1 :
               respond to value 1
             case  value 2 , value 3 :
               respond to value 2 or 3
             default:
               otherwise, do something else
            }
          2. 不需要在 case 分支中显式地使用 break 语句 

    一个 case 可以包含多个模式，用逗号将它们分开（如果太长，可以分行写）：

    switch  some value to consider  {
    case  value 1 ,
    value 2 :
         statements
    }
    4.case 分支的模式也可以是一个值区间。case 1...3:
        naturalCount = "a few"
    case 4...9:
        naturalCount = "several"

    5. switch 语句中可以使用 元组 测试多个值。元组中的元素可以是值，也可以是区间。另外，使用下划线（_）来匹配所有可能的值。
    下面的例子展示了如何使用一个(Int, Int)类型的元组来分类下图中的点(x, y)：

    let somePoint = (1, 1)
    switch somePoint {
     case (0, 0):
      println("(0, 0) is at the origin")
     case (_, 0):
      println("((somePoint.0), 0) is on the x-axis")
     case (0, _):
      println("(0, (somePoint.1)) is on the y-axis")
     case (-2...2, -2...2):
      println("((somePoint.0), (somePoint.1)) is inside the box")
     default:
      println("((somePoint.0), (somePoint.1)) is outside of the box")
    }
    // prints "(1, 1) is inside the box"   Swift 允许多个 case 匹配同一个值,但是，如果存在多个匹配，那么只会执行第一个被匹配到的 case 分支。
     

    6.值绑定（value binding）：case 分支允许将要匹配的值绑定给临时常量或变量，这些常量或变量在该 case 分支可以被引用。

     下面的例子展示了如何在一个(Int, Int)类型的元组中使用值绑定来分类下图中的点(x, y)：

    let anotherPoint = (2, 0)
    switch anotherPoint {
    case (let x, 0):
        println("on the x-axis with an x value of (x)")
    case (0, let y):
        println("on the y-axis with a y value of (y)")
    case let (x, y):
        println("somewhere else at ((x), (y))")
    }
    // prints "on the x-axis with an x value of 2"
     

    7.case 分支模式可以使用 where 语句判断额外的条件。

    下面的例子把下图中的点(x, y)进行了分类：

    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")
    }
    // prints "(1, -1) is on the line x == -y"

    8.如果你确实需要 C 风格的贯穿（fallthrough）的特性，你可以在每个需要该特性的 case 分支中使用fallthrough关键字。下面的例子使用fallthrough来创建一个数字的描述语句。

     let integerToDescribe = 5

    var description = "The number (integerToDescribe) is"
    switch integerToDescribe {
    case 2, 3, 5, 7, 11, 13, 17, 19:
        description += " a prime number, and also"
        fallthrough
    default:
        description += " an integer."
    }
    println(description)
    // prints "The number 5 is a prime number, and also an integer."
      • 控制转移语句,

        控制转移语句可以改变代码的执行顺序，通过它可以实现代码的跳转。Swift 有四种控制转移语句。

         continue
         break
         fallthrough
         return

      • 可以使用标签来标记一个循环体或者switch代码块，当使用break或者continue时，带上这个标签，可以控制该标签代表对象的中断或者执行。label name: while condition {
        statements
        }  例：    gameLoop: while square != finalSquare {
            if ++diceRoll == 7 { diceRoll = 1 }
            switch square + diceRoll {
            case finalSquare:
                // 到达最后一个方块，游戏结束
                break gameLoop
            case let newSquare where newSquare > finalSquare:
                // 超出最后一个方块，再掷一次骰子
                continue gameLoop
            default:
                // 本次移动有效
                square += diceRoll
                square += board[square]
            }
        }
        println("Game over!")
    • 函数：用来完成特定任务的功能独立的代码块。每个函数都有一种类型，包括函数的参数值类型和返回值类型。可以把函数类型当做变量类型一样处理，函数可以作为其他的函数的参数，函数也可以作为其他函数的返回值；函数也可以定义在其他函数中，即函数嵌套，方便在函数内部实现功能封装。
      • 函数定义以 func 关键字开头。指定函数返回类型时，用返回箭头 ->（一个减号和一个右尖括号）紧跟返回类型的方式来表示。func sayHello(personName: String) -> String {
            let greeting = "Hello, " + personName + "! "
            return greeting
        }
      • 如果函数没有返回值，函数的定义中不需要 箭头（->）和返回类型。严格上来说，虽然没有定义返回值，但 sayGoodbye 函数仍然返回了值，叫 Void；它是一个特殊的值，是一个空的元组（tuple），没有任何元素，也就是()。
      • 使用元组（tuple）类型组合多个值为一个复合值作为函数的返回值。
      • 函数的使用者在调用函数时提供参数名字，那就需要给每个参数（除了局部参数）外再定义一个外部参数名。外部参数名写在局部参数名之前，用空格分开。当调用函数时，外部参数名必须使用

        为了让这些字符串的用途更明确，我们为 join 函数添加外部参数名：

        func join(string s1: String, toString s2: String, withJoiner joiner: String) -> String {
                return s1 + joiner + s2
        }

        在这个版本的 join 函数中，第一个参数有一个叫 string 的外部参数名和叫 s1 的局部参数名，第二个参数有一个叫 toString 的外部参数名和叫 s2 的局部参数名，第三个参数有一个叫 withJoiner 的外部参数名和叫 joiner 的局部参数名。


        现在，使用这些外部参数名调用函数，这样会更清晰：

        join(string: "hello", toString: "world", withJoiner: ", ")
        // returns "hello, world"
      • 如果需要提供外部参数名，而局部参数名的定义已经非常明确了，那么你不需要写两次这个参数名。只写一次参数名，并用井号（#）作为前缀就可以了。这说明这个参数名既作为局部参数名也作为外部参数名。
      • 定义函数的时候可以为每个参数定义默认值，这样调用这个函数时可以略去这个参数。
      • 可变参数（variadic parameter）可以接受一个或多个实参值。函数调用时，可以传入不确定数量的实参。在变量名后面加 ... 来定义可变参数。
        传入可变参数的实参值在函数体内是参数类型的数组。
      • 函数参数默认是常量。所以，试图在函数体中更改参数值将会导致编译错误。
        但是，有时候，传入参数的变量值有副本将是很有用的。指定一个或多个参数为变量参数，来避免在函数中定义新的变量。变量参数不是常量，在函数体中，它是可修改副本。
      • 输入输出参数不能有默认值，不能是可变参数。如果一个参数被 inout 标记，这个参数就不能被 var 或 let 标记。当传入的实参作为输入输出参数时，需要在实参前加 & 符，表示这个值可以被函数修改。

      • 可以定义一个类型为函数的常量或变量，并将函数赋值给它：

        var mathFunction: (Int, Int) -> Int = addTwoInt

        理解为：定义一个叫做 mathFunction 的变量，类型是“有2个Int类型参数，返回Int类型值的函数类型”，是 addTwoInts 函数的引用。
        addTwoInts 和 mathFunction 都是(Int, Int) -> Int类型，所以这个赋值在类型检查时是允许的。

      • 函数类型可以作为参数。这样可以将函数的一部分功能交给给函数类型的参数。
        比如用(Int, Int) -> Int 的函数类型作为另一个函数的参数类型：

        func printMathResult(mathFunction: (Int, Int) -> Int, a: Int, b: Int) {
            println("Result: (mathFunction(a, b))")
        }
        printMathResult(addTwoInts, 3, 5)
        // prints "Result: 8"

    参考：http://www.ioswift.org/
  • 相关阅读:
    NSURLSession 网络请求
    NSData 数据
    NSStream文件流
    NSFileManager文件管理
    NSCache 缓存
    NSUserDefaults数据存储
    NSKeyedArchiver数据归档
    子线程定时器的创建
    NSEnumerator迭代器
    NSDate 时间
  • 原文地址：https://www.cnblogs.com/ecollab/p/6127497.html
Copyright © 2011-2022 走看看