do语句 swift_swift while语句 - CSDN
  • do { try functionWillThrowError() } catch { // deal with error }
     do {
        try functionWillThrowError()
      } catch {
        // deal with error
      }

    展开全文
  • Swift 中,有两种类型的语句:简单语句和控制流语句。简单语句是最常见的,用于构造表达式和声明。控制流语句则用于控制程序执行的流程,Swift 中有三种类型的控制流语句:循环语句、分支语句和控制传递语句。 ...
    在 Swift 中,有两种类型的语句:简单语句和控制流语句。简单语句是最常见的,用于构造表达式和声明。控制流语句则用于控制程序执行的流程,Swift 中有三种类型的控制流语句:循环语句、分支语句和控制传递语句。
     
    循环语句用于重复执行代码块;分支语句用于执行满足特定条件的代码块;控制传递语句则用于修改代码的执行顺序。在稍后的叙述中,将会详细地介绍每一种类型的控制流语句。
     
    是否将分号(;)添加到语句的结尾处是可选的。但若要在同一行内写多条独立语句,请务必使用分号。
     
    GRAMMAR OF A STATEMENT
     
    statement → expression; opt
     
    statement → declaration; opt
     
    statement → loop-statement; opt
     
    statement → branch-statement; opt
     
    statement → labeled-statement
     
    statement → control-transfer-statement; opt
     
    statement → statment statements; opt
     
    循环语句
    取决于特定的循环条件,循环语句允许重复执行代码块。Swift 提供四种类型的循环语句:for语句、for-in语句、while语句和do-while语句。
     
    通过break语句和continue语句可以改变循环语句的控制流。有关这两条语句,详情参见 Break 语句和 Continue 语句。
     
    GRAMMAR OF A LOOP STATEMENT
     
    loop-statement → for-statement
     
    loop-statement → for-in-statement
     
    loop-statement → while-statement
     
    loop-statement → do-while-statement
     
    For 语句
    for语句允许在重复执行代码块的同时,递增一个计数器。
     
    for语句的形式如下:
    1. for `initialzation`; `condition`; `increment` { 
    2.     `statements` 
    initialzation、condition 和 increment 之间的分号,以及包围循环体 statements 的大括号都是不可省略的。
     
    for语句的执行流程如下:
     
    1、initialzation 只会被执行一次,通常用于声明和初始化在接下来的循环中需要使用的变量。
    2、计算 condition 表达式: 如果为true,statements 将会被执行,然后转到第3步。如果为false,statements 和 increment 都不会被执行,for至此执行完毕。
    3、计算 increment 表达式,然后转到第2步。
     
    定义在 initialzation 中的变量仅在for语句的作用域以内有效。condition 表达式的值的类型必须遵循LogicValue协议。
     
    GRAMMAR OF A FOR STATEMENT
     
    for-statement → for for-init opt ; expression opt ; expression opt code-block
     
    for-statement → for ( for-init opt ; expression opt ; expression opt ) code-block
     
    for-statement → variable-declaration | expression-list
     
    For-In 语句
    for-in语句允许在重复执行代码块的同时,迭代集合(或遵循Sequence协议的任意类型)中的每一项。
     
    for-in语句的形式如下:
    1. for `item` in `collection` { 
    2.     `statements` 
    for-in语句在循环开始前会调用 collection 表达式的generate方法来获取一个生成器类型(这是一个遵循Generator协议的类型)的值。接下来循环开始,调用 collection 表达式的next方法。如果其返回值不是None,它将会被赋给 item,然后执行 statements,执行完毕后回到循环开始处;否则,将不会赋值给 item 也不会执行 statements,for-in至此执行完毕。
     
    GRAMMAR OF A FOR-IN STATEMENT
     
    for-in-statement → for pattern in expression code-block
     
    While 语句
    while语句允许重复执行代码块。
     
    while语句的形式如下:
    1. while `condition` { 
    2.     `statements` 
    while语句的执行流程如下:
     
    1、计算 condition 表达式: 如果为真true,转到第2步。如果为false,while至此执行完毕。
    2、执行 statements ,然后转到第1步。
     
    由于 condition 的值在 statements 执行前就已计算出,因此while语句中的 statements 可能会被执行若干次,也可能不会被执行。
     
    condition 表达式的值的类型必须遵循LogicValue协议。同时,condition 表达式也可以使用可选绑定,详情参见可选绑定。
     
    GRAMMAR OF A WHILE STATEMENT
     
    while-statement → while while-condition code-block
     
    while-condition → expression | declaration
     
    Do-While 语句
    do-while语句允许代码块被执行一次或多次。
     
    do-while语句的形式如下:
    1. do { 
    2.     `statements` 
    3. while `condition` 
    do-while语句的执行流程如下:
     
    1、执行 statements,然后转到第2步。
    2、计算 condition 表达式: 如果为true,转到第1步。如果为false,do-while至此执行完毕。
     
    由于 condition 表达式的值是在 statements 执行后才计算出,因此do-while语句中的 statements 至少会被执行一次。
     
    condition 表达式的值的类型必须遵循LogicValue协议。同时,condition 表达式也可以使用可选绑定,详情参见可选绑定。
     
    GRAMMAR OF A DO-WHILE STATEMENT
     
    do-while-statement → do code-block while while-condition
     
    分支语句
    取决于一个或者多个条件的值,分支语句允许程序执行指定部分的代码。显然,分支语句中条件的值将会决定如何分支以及执行哪一块代码。Swift 提供两种类型的分支语句:if语句和switch语句。
     
    switch语句中的控制流可以用break语句修改,详情请见Break 语句。
     
    GRAMMAR OF A BRANCH STATEMENT
     
    branch-statement → if-statement
     
    branch-statement → switch-statement
     
    If 语句
    取决于一个或多个条件的值,if语句将决定执行哪一块代码。
     
    if语句有两种标准形式,在这两种形式里都必须有大括号。
     
    第一种形式是当且仅当条件为真时执行代码,像下面这样:
    1. if `condition` { 
    2.     `statements` 
    第二种形式是在第一种形式的基础上添加 else 语句,当只有一个 else 语句时,像下面这样:
    1. if `condition` { 
    2.     `statements to execute if condition is true
    3. else { 
    4.     `statements to execute if condition is false
    5.  
    同时,else 语句也可包含if语句,从而形成一条链来测试更多的条件,像下面这样:
    1. if `condition 1` { 
    2.     `statements to execute if condition 1 is true
    3. else if `condition 2` { 
    4.     `statements to execute if condition 2 is true
    5. else { 
    6.     `statements to execute if both conditions are false
    if语句中条件的值的类型必须遵循LogicValue协议。同时,条件也可以使用可选绑定,详情参见可选绑定。
     
    GRAMMAR OF AN IF STATEMENT
     
    if-statement → if if-condition code-block else-clause opt
     
    if-condition → expression | declaration
     
    else-clause → else code-block | else if-statement opt
     
    Switch 语句
    取决于switch语句的控制表达式(control expression),switch语句将决定执行哪一块代码。
     
    switch语句的形式如下:
    1. switch `control expression` { 
    2.     case `pattern 1`: 
    3.         `statements` 
    4.     case `pattern 2` where `condition`: 
    5.         `statements` 
    6.     case `pattern 3` where `condition`, 
    7.     `pattern 4` where `condition`: 
    8.         `statements` 
    9.     default
    10.         `statements` 
    switch语句的控制表达式(control expression)会首先被计算,然后与每一个 case 的模式(pattern)进行匹配。如果匹配成功,程序将会执行对应的 case 分支里的 statements。另外,每一个 case 分支都不能为空,也就是说在每一个 case 分支中至少有一条语句。如果你不想在匹配到的 case 分支中执行代码,只需在该分支里写一条break语句即可。
     
    可以用作控制表达式的值是十分灵活的,除了标量类型(scalar types,如Int、Character)外,你可以使用任何类型的值,包括浮点数、字符串、元组、自定义类的实例和可选(optional)类型,甚至是枚举类型中的成员值和指定的范围(range)等。关于在switch语句中使用这些类型,详情参见控制流一章的 Switch。
     
    你可以在模式后面添加一个起保护作用的表达式(guard expression)。起保护作用的表达式是这样构成的:关键字where后面跟着一个作为额外测试条件的表达式。因此,当且仅当控制表达式匹配一个case的某个模式且起保护作用的表达式为真时,对应 case 分支中的 statements 才会被执行。在下面的例子中,控制表达式只会匹配含两个相等元素的元组,如(1, 1):
    1. case let (x, y) where x == y: 
    正如上面这个例子,也可以在模式中使用let(或var)语句来绑定常量(或变量)。这些常量(或变量)可以在其对应的起保护作用的表达式和其对应的case块里的代码中引用。但是,如果 case 中有多个模式匹配控制表达式,那么这些模式都不能绑定常量(或变量)。
     
    switch语句也可以包含默认(default)分支,只有其它 case 分支都无法匹配控制表达式时,默认分支中的代码才会被执行。一个switch语句只能有一个默认分支,而且必须在switch语句的最后面。
     
    尽管模式匹配操作实际的执行顺序,特别是模式的计算顺序是不可知的,但是 Swift 规定switch语句中的模式匹配的顺序和书写源代码的顺序保持一致。因此,当多个模式含有相同的值且能够匹配控制表达式时,程序只会执行源代码中第一个匹配的 case 分支中的代码。
     
    Switch 语句必须是完备的
    在 Swift 中,switch语句中控制表达式的每一个可能的值都必须至少有一个 case 分支与之对应。在某些情况下(例如,表达式的类型是Int),你可以使用默认块满足该要求。
     
    不存在隐式的贯穿(fall through)
    当匹配的 case 分支中的代码执行完毕后,程序会终止switch语句,而不会继续执行下一个 case 分支。这就意味着,如果你想执行下一个 case 分支,需要显式地在你需要的 case 分支里使用fallthrough语句。关于fallthrough语句的更多信息,详情参见 Fallthrough 语句。
     
    GRAMMAR OF A SWITCH STATEMENT
     
    switch-statement → switch expression { switch-cases opt }
     
    switch-cases → switch-case switch-cases opt
     
    switch-case → case-label statement | default-label statements
     
    switch-case → case-label ; | default-label ;
     
    case-label → case case-item-list :
     
    case-item-list → pattern guard-clause opt | pattern guard-clause opt, case-item-list
     
    default-label → default :
     
    guard-clause → where guard-expression
     
    guard-expression → expression
     
    带标签的语句
    你可以在循环语句或switch语句前面加上标签,它由标签名和紧随其后的冒号(:)组成。在break和continue后面跟上标签名可以显式地在循环语句或switch语句中更改控制流,把控制权传递给指定标签标记的语句。关于这两条语句用法,详情参见 Break 语句和 Continue 语句。
     
    标签的作用域是该标签所标记的语句之后的所有语句。你可以不使用带标签的语句,但只要使用它,标签名就必唯一。
     
    关于使用带标签的语句的例子,详情参见控制流一章的带标签的语句。
     
    GRAMMAR OF A LABELED STATEMENT
     
    labeled-statement → statement-label loop-statement | statement-label switch-statement
     
    statement-label → label-name :
     
    label-name → identifier
     
    控制传递语句
    通过无条件地把控制权从一片代码传递到另一片代码,控制传递语句能够改变代码执行的顺序。Swift 提供四种类型的控制传递语句:break语句、continue语句、fallthrough语句和return语句。
     
    GRAMMAR OF A CONTROL TRANSER STATEMENT
     
    control-transfer-statement → break-statement
     
    control-transfer-statement → continue-statement
     
    control-transfer-statement → fallthrough-statement
     
    control-transfer-statement → return-statement
     
    Break 语句
    break语句用于终止循环或switch语句的执行。使用break语句时,可以只写break这个关键词,也可以在break后面跟上标签名(label name),像下面这样:
    1. break 
    2. break `label name` 
    当break语句后面带标签名时,可用于终止由这个标签标记的循环或switch语句的执行。
     
    而当只写break时,则会终止switch语句或上下文中包含break语句的最内层循环的执行。
     
    在这两种情况下,控制权都会被传递给循环或switch语句外面的第一行语句。
     
    关于使用break语句的例子,详情参见控制流一章的 Break 和带标签的语句。
     
    GRAMMAR OF A BREAK STATEMENT
     
    break-statement → break label-name opt
     
    Continue 语句
    continue语句用于终止循环中当前迭代的执行,但不会终止该循环的执行。使用continue语句时,可以只写continue这个关键词,也可以在continue后面跟上标签名(label name),像下面这样:
    1. continue 
    2. continue `label name` 
    当continue语句后面带标签名时,可用于终止由这个标签标记的循环中当前迭代的执行。
     
    而当只写break时,可用于终止上下文中包含continue语句的最内层循环中当前迭代的执行。
     
    在这两种情况下,控制权都会被传递给循环外面的第一行语句。
     
    在for语句中,continue语句执行后,increment 表达式还是会被计算,这是因为每次循环体执行完毕后 increment 表达式都会被计算。
     
    关于使用continue语句的例子,详情参见控制流一章的 Continue 和带标签的语句。
     
    GRAMMAR OF A CONTINUE STATEMENT
     
    continue-statement → continue label-name opt
     
    Fallthrough 语句
    fallthrough语句用于在switch语句中传递控制权。fallthrough语句会把控制权从switch语句中的一个 case 传递给下一个 case 。这种传递是无条件的,即使下一个 case 的模式与switch语句的控制表达式的值不匹配。
     
    fallthrough语句可出现在switch语句中的任意 case 里,但不能出现在最后一个 case 分支中。同时,fallthrough语句也不能把控制权传递给使用了可选绑定的 case 分支。
     
    关于在switch语句中使用fallthrough语句的例子,详情参见控制流一章的控制传递语句。
     
    GRAMMAR OF A FALLTHROUGH STATEMENT
     
    continue-statement → fallthrough
     
    Return 语句
    return语句用于在函数或方法的实现中将控制权传递给调用者,接着程序将会从调用者的位置继续向下执行。
     
    使用return语句时,可以只写return这个关键词,也可以在return后面跟上表达式,像下面这样:
    1. return 
    2. return `expression` 
    当return语句后面带表达式时,表达式的值将会返回给调用者。如果表达式值的类型与调用者期望的类型不匹配,Swift 则会在返回表达式的值之前将表达式值的类型转换为调用者期望的类型。
     
    而当只写return时,仅仅是将控制权从该函数或方法传递给调用者,而不返回一个值。(这就是说,该函数或方法的返回类型为Void或())
     
    GRAMMAR OF A RETURN STATEMENT
     
    return-statement → return expression opt
    展开全文
  • Swift控制语句

    2016-07-13 09:45:04
    原文出自:标哥的技术博客 前言Swift提供了类似C语言的流程控制结构,包括可以多次执行任务的for和while循环。还有基于特定条件选择执行不同代码分支的if、guard和...Swift的switch语句比C语言中更加强大。在C语言中

    原文出自:标哥的技术博客

    前言

    Swift提供了类似C语言的流程控制结构,包括可以多次执行任务的for和while循环。还有基于特定条件选择执行不同代码分支的if、guard和switch语句,还有控制流程跳转到其他代码的break和continue语句。

    Swift增加了for-in循环,用来更简单地遍历数组、字典、区间、字符串和其他序列类型。

    Swift的switch语句比C语言中更加强大。在C语言中,如果某个case不小心漏写了break,这个case就会贯穿至下一个case,而Swift无需写break,所以不会发生这种贯穿的情况。case 还可以匹配更多的类型模式,包括区间匹配(range matching)、元组(tuple)和特定类型的描述。switch的case语句中匹配的值可以是由case体内部临时的常量或者变量决定,也可以由where分句描述更复杂的匹配条件。

    for循环(For Loops Statement)

    • for:与C语言一样的for循环
    • for-in:快速遍历集合、序列等

    for-in遍历range(其中…表示闭区间[1,5]):

    for index in 1...5 {
        print("\(index) times 5 is \(index * 5)")
    }
    // 1 times 5 is 5
    // 2 times 5 is 10
    // 3 times 5 is 15
    // 4 times 5 is 20
    // 5 times 5 is 25
    
    // 它可以转换for循环为:
    for var index = 1; index <= 5; ++index {
       // ...
    }

    若我们不要获取值,可以用下划线(_)过滤,这种用法很常见:

    let base = 3
    let power = 10
    var answer = 1
    
    // 三个点表示全闭区间[1, power]
    for _ in 1...power {
        answer *= base
    }
    
    // 两个点加一个<就是左闭右开[1, 5)
    var sum = 0
    for _ in 1..<5 {
      sum += 1
    }

    常见的遍历数组方法:

    let names = ["Anna", "Alex", "Brian", "Jack"]
    for name in names {
        print("Hello, \(name)!")
    }
    
    // or 
    for (name, index) in names.enumerate() {
       // 也是很常用的
    }

    常见的遍历字典:

    let numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
    for (animalName, legCount) in numberOfLegs {
        print("\(animalName)s have \(legCount) legs")
    }
    
    // 我们知道字典中的键值对是用元组表示的,所以可以直接通过元组来访问

    while循环(While Loop Statement)

    • while循环,每次在循环开始时计算条件是否符合;
    • repeat-while循环,每次在循环结束时计算条件是否符合。用法与Objective-C中的do-while完全一样。

    注意:没有do-while而是repeat-while

    var index = 10
    while index > 0 {
      index--
    }
    print(index)// 0
    
    index = 0
    repeat {// 没有do-while了,只有repeat-while
      print("test repeat")
      index++
    } while index < 3

    if条件语句(If Condition Statement)

    If条件为真假值,要么为true,要么为false。

    // 条件只有index值为3,结果才为true,才会打印。
    if index == 3 {
      print("3")
    }

    guide语句(Guide Condition Statement)

    guide语法与if不同,如果条件为真,则不进入else分支,否则进入。guide语义是守卫的意思,也就是说,只要满足条件,什么事都没有,否则就会进入else分支。

    // 在函数内部,判断必传参数为空时,直接退出函数,这种用法很常用。
    guard let name = dict["name"] else {
        return
    }

    switch语句(Switch Statement)

    swift中的Switch分支与Objective-C中的switch有很多不同的地方:

    • swift中不需要为每个case手动写break
    • swift中case支持区间匹配
    • swift中的case支持元组
    • swift中的case支持值绑定
    • swift中的case支持where条件过滤
    • swift中的case可以放置多个值

    不用手写break,也不会隐式贯穿:

    var value = 1
    switch value {
    case 1:
      print("only print 1")
    case 2:
      print("only print 2")
    default:
      print("on matched value")
    }
    // "only print 1\n"

    支持匹配区间:

    let approximateCount = 62
    let countedThings = "moons orbiting Saturn"
    var naturalCount: String
    switch approximateCount {
    case 0:
        naturalCount = "no"
    case 1..<5:
        naturalCount = "a few"
    case 5..<12:
        naturalCount = "several"
    case 12..<100:
        naturalCount = "dozens of"
    case 100..<1000:
        naturalCount = "hundreds of"
    default:
        naturalCount = "many"
    }
    print("There are \(naturalCount) \(countedThings).")
    // 输出 "There are dozens of moons orbiting Saturn."

    支持元组,对于不需要获取的值,可以用_过滤:

    let httpError = (404, "Http Not Found")
    switch httpError {
    case let (code, _) where code == 404:
      print(httpError.1)
    case let (code, msg) where code == 502:
      print(msg)
    
    default:
      print("default")
    }

    支持值绑定:

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

    支持where过滤条件:

    let point = (1, 3)
    switch point {
    case let (x, y) where x > y:
      print("x > y")
    case let (x, _) where x > 2:
      print("x > 2")
    case let (1, y) where y > 4:
      print("y > 4 and x == 1")
    case let (x, y) where x >= 1 && y <= 10:
      print("ok")// ok
    default:
      print("error")
    }

    支持一个case多个值:

    let numberSymbol: Character = "三"  // 简体中文里的数字 3
    var possibleIntegerValue: Int?
    switch numberSymbol {
    case "1", "١", "一", "๑":
        possibleIntegerValue = 1
    case "2", "٢", "二", "๒":
        possibleIntegerValue = 2
    case "3", "٣", "三", "๓":
        possibleIntegerValue = 3
    case "4", "٤", "四", "๔":
        possibleIntegerValue = 4
    default:
        break
    }

    控制转移语句(Control Transfer Statements)

    swift有五种控制转移语句:

    • continue:跳过本次循环,直接进入下一循环
    • break:中断最近的循环或者中断某个标签(下一小节说明)
    • fallthrough:用于switch分支贯穿分支
    • return:用于函数返回
    • throw:用于抛出异常

    continue跳过不满足条件的:

    let puzzleInput = "great minds think alike"
    var puzzleOutput = ""
    for character in puzzleInput.characters {
        switch character {
        case "a", "e", "i", "o", "u", " ":
            continue
        default:
            puzzleOutput.append(character)
        }
    }
    print(puzzleOutput)
    // 输出 "grtmndsthnklk"

    用break退出循环:

    for index in 1...5 {
      if index >= 3 {
        break
      }
    }
    
    // 在swift中用break,就会直接退出该swift语句
    index = 10
    for index in 20..<100 {
        switch index {
            case let x where x < 40:
            print(x)
        case let x where x > 100:
            break
        default:
            break
    }

    用fallthrough贯穿swift的case:

    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."
    }
    print(description)
    // 输出 "The number 5 is a prime number, and also an integer."

    标签语句

    比如有时候需要在满足某个条件的时候就跳去执行某段代码,那么这时候用标签语句就很好用:

    语法如下:

    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]
        }
    }
    print("Game over!")

    检查API可用性

    语法如下:

    if #available(iOS 9, OSX 10.10, *) {
        // 在 iOS 使用 iOS 9 的 API, 在 OS X 使用 OS X v10.10 的 API
    } else {
        // 使用先前版本的 iOS 和 OS X 的 API
    }

    详细如何使用,请阅读文章:Swift检测API可用性

    写在最后

    本篇博文是笔者在学习Swift 2.1的过程中记录下来的,可能有些翻译不到位,还请指出。另外,所有例子都是笔者练习写的,若有不合理之处,还望指出。

    学习一门语言最好的方法不是看万遍书,而是动手操作、动手练习。如果大家喜欢,可以关注哦,尽量2-3天整理一篇Swift 2.1的文章。这里所写的是基础知识,如果您已经是大神,还请绕路!

    关注我

    如果在使用过程中遇到问题,或者想要与我交流,可加入有问必答QQ群:324400294

    关注微信公众号:iOSDevShares

    关注新浪微博账号:标哥Jacky

    支持并捐助

    如果您觉得文章对您很有帮助,希望得到您的支持。您的捐肋将会给予我最大的鼓励,感谢您的支持!

    支付宝捐助 微信捐助
    image image
    展开全文
  • 判断语句//判断语句 let count = 4 if(count == 4){ print(&quot;YES&quot;) } else { print(&quot;NO&quot;) } //小括号可以省略 if count == 4 { print(&quot;YES&quot;) } else { ...

    判断语句

    //判断语句
    let count = 4
    if(count == 4){
        print("YES")
    }
    else
    {
        print("NO")
    }
    //小括号可以省略
    if count == 4 {
        print("YES")
    }
    else
    {
        print("NO")
    }
    
    /*
      if ...else..可以使用三目运算符
    */
    let name:String = "xiaoming"
    var namestr = name.characters.count<1 ? "" : name
    

    switch语句

    /*
    switch 语句的小括号可以省略
    */
    switch(count)
    {
        case 1:
            print(1)
            break
        case 2:
            print(2)
            break
        case 3:
            print(3)
            break
        case 4:
            print(4)
            break
        default:
            break
    }
    

    for循环

    /*
    for 语句的小括号可以省略
    */
    for var i = 0;i<10;i++
    {
        print(i)
    }
    /*
    小于10的一个循环
    ".."表示省略0——10不包括10
    */
    for i in 0..<10
    {
        print(1)
    }
    /*
        "_"表示忽略,不关心i是什么的时候
    */
    for _ in 0..<10
    {
        print("_表示忽略,不关心i的值的时候");
    }
    
    
    //for循环的自增减
    for i in (1...10).reversed() {
    print(i)
    }
    //自增或者自减 自定义步进数
    //stride(from: <#T##Strideable#>, to: <#T##Strideable#>, by: <#T##Comparable & SignedNumeric#>)
    //              开始              结束          步进
    for i in stride(from: 0, to: 8, by: 1) {
        print(i);
    }
    for i in stride(from: 8, to: 0, by: -2) {
        print(i);
    }
    
    
    

    while的语句

    /*
        while循环,开发过程中一般很少使用到
    */
    let listCunt = 9
    
    while listCunt < 9
    {
        print(listCunt);
    }
    /*
       do。。while循环,没有do了。换了一个关键字repeat
    */
    repeat
    {
        print(listCunt);
        
    }while listCunt < 9
    
    
    
    
    
    
    
    

    ?和!的用法

    /*
    “!”表示告诉编译器,可选类型中一定有值,强制解析
    "?"表示可选的返回,不一定有值
    */
    let url = NSURL(string: "www.baidu.com")
    print(url);
    
    if url != nil
    {
      let urlRequest = NSURLRequest(URL: url!)
    }
    
    //可选的绑定 把url的赋值给urlFinal,如果不为空可以进去{}
    if let urlFinal = url
    {
        let urlRequest = NSURLRequest(URL: urlFinal)
    }
    
    展开全文
  • swift while、do-while循环

    2016-01-15 17:15:33
    // while 循环执行一系列语句直到条件变成 false 。while 循环使用于第一次迭代时迭代值未知的情况下 // while 循环:在每次循环开始时判断条件是否为 true; // do-while 循环:在每次循环结束时判断条件...
  • 1.do语句块: Swift编程语言中可使用 do 语句块作为类似C语言中的一般语句块进行使用。与C语言的语句块类似,Swift中的 do 语句块单独作为一个作用域,该语句块中声明的局部对象在其外部将无法被访问。如果在 do ...
  • /**  while 循环    while 循环保持条件  {  // 执行指令  }    */    var i:Int = 1  var sum:I
  • Swift中的循环语句

    2014-09-09 14:09:33
    Swift编程语言支持4种循环构造类型:while、do while、for和for in。for和while循环是在执行循环体之前测试循环条件,而do while是在执行循环体之后测试循环条件。这就意味着for和while循环可能连一次循环体都未执行...
  • 完整的do-try-catch错误处理模式的语法如下: do {    try 语句    成功处理语句组   } catch 匹配错误 {    错误处理语句组   } catch 匹配错误 {    
  • swift 提供了 4 种 循环语句 while 、 do-while 、for 和 for-in 其中 while 、do-while和for 与java语言中是一样的,所以这里重点记录 for-in
  • import UIKit class HomeViewController: UIViewController { override func viewDidLoad() { super.viewDidLoad() /* [运算符] 运算符是一个符号,用于告诉编译器执行一个数学或逻辑运算。...
  • Swift-(do/repeat)while循环

    2016-07-31 18:13:32
    1. while循环 ...swift的 while 循环while后的圆括号可以省略 只能以bool作为条件语句, 没有非零即真, 只有 true和false 如果只有条指令while后面的大括号不可以省略 //OC: //格式:while(循环保持条件){
  • 格式:while(循环保持条件){需要执行的语句} int i = 0; int sum = 0; while (i <= 10) { sum = i++; } NSLog(@"%d",sum); 输出结果:10 int i = 0; int sum = 0; while (i <= 10) sum = i++; ...
  • 格式:while(循环保持条件){需要执行的语句} OC: int i = 0; int sum = 0; while (i ) { sum = i++; }while (i ) sum = i++;NSLog(@"%d", sum); 如果只有一条指令while后面的大括号可以省略Swift: 0.while后的圆...
  • swift的条件语句在写法和新功能有什么特殊的,让我们一起来了解一下吧。 1) if语句 if 条件语句 {} 这里条件语句的值必须是Bool类型,Bool类型就两个值,要么是true和false,这和c/oc不一样,不像他们非0就真,...
  • swift的控制语句

    2015-09-03 09:09:15
    1 for循环语句的例子  //定义一个分数 var score=80; //定义一个数组  var scores=[90,98]; var minScord=0; var maxScore=0; var avgScore=0.0; var count=scores....
  • 1 // 2 // ViewController.swift 3 // Swift-循环语句 4 // 5 // Created by luorende on 16/12/08. 6 // Copyright © 2016年 luorende. All rights reserved. 7 // 8 9 import UIKit 10 11 c...
  • Swift 语句(Statements)

    2016-06-27 21:47:50
    Swift 中,有两种类型的语句:简单语句和控制流语句。简单语句是最常见的,用于构造表达式或者声明。控制流语句则用于控制程序执行的流程,Swift 中有三种类型的控制流语句:循环语句、分支语句和控制传递语句。 ...
1 2 3 4 5 ... 20
收藏数 3,506
精华内容 1,402
关键字:

do语句 swift