Swift学习(四:调节流)

作者: 网络工程  发布:2019-09-15
1. For- In循环
 for index in 1...5{ print  }

注意:index是三个老是循环遍历开首时被自动赋值的常量。这种情状下没有需要评释,只必要将它包罗在循环的宣示中,就能够对其开展隐式申明,而无需选拔let关键字评释。

  • 就算不须要通晓种种的值,能够选拔_代表变量名来忽略对值的拜谒。

     for _ in 1...10{ print }
    
  • 遍历数组

     let names = ["aa","ss","dd"] for name in names { print("hello }
    
  • 遍历字典

     let dic = ["aa" : "AA", "ss" : "SS","dd" :"DD"] for (key,value) in dic{ print :  }
    

// 控制流
// “满含能够频频实行职分的while循环,基于特定条件选取实施不一代码分支的if、guard和switch语句,还应该有调节流程跳转到其余代码地点的break和continue语句。”

2.While循环
  • while巡回,每一回在循环初步时总结口径是或不是合乎

     while condition { statements }
    
  • repeat-while巡回,每回在循环结束时总结口径是不是吻合

 repeat { statements } while condition

//“Swift还提供了for-in循环,用来更简明地遍历数组(array),字典(dictionary),区间(range),字符串(string)和别的体系类型。”

3. 准则语句
 var a = 10 if a <=11{ print }else if{ print } //haha
//1. for-in
// for-in可以遍历collection中的所有元素,数组或者字典都可以遍历。
for index in 1...5{
print("index is (index)")
}

//“如果你不需要区间序列内每一项的值,你可以使用下划线(_)替代变量名来忽略这个值”
for _ in 1...5{
print("不需要值")
}
4.Switch

每一个 case 都以代码施行的一条分支,那与if语句类似。与之不相同的是,switch语句会决定哪一条分支应该被施行。switch讲话必得是兼备的。那便是说,每贰个可能的值都不可能不至少有八个case分层与之相应。在好几不也许包蕴全部值的情况下,你能够使用暗中认可(default)分支满足该供给,这些默许分支必需在switch讲话的最后面。

 let index : Character = "e" switch index { case "a","b","c": print case "s","d","f": print default: print") }

留意:*在 Swift 中,当相称的 case 分支中的代码实践达成后,程序会告一段落switch语句,而不会继续实施下八个case 分支。那约等于,不供给在 case 分支中显式地行使break语句。那使得switch语句更安全、更易用,也制止了因忘记写break语句而发生的荒唐。每贰个case 分支都必须含有至少一条语句

  • 一个 case 也得以包括五个方式,用逗号把它们分别(借使太长了也能够分行写):

     switch index { case value1, value2: statements }
    
  • 区间相称

     let a = 20 var c : String switch a { case 0 : c = "no" case 1..<5: c = "a few" case 5..<10: c = "several" default: c = "many" } print //many
    
  • 元组

     let a =  switch a { case: print case: print case: print case(-2...2,-2...2): pint } //4
    

上面包车型地铁例证体现了何等在三个门类的元组中使用值绑定来分类下图中的点:

 let anotherPoint =  switch anotherPoint { case : print("on the x-axis with an x value of  case : print("on the y-axis with a y value of  case let : print("somewhere else at ,  } // 输出 "on the x-axis with an x value of 2"
  • wherecase 分支的格局能够使用where语句来判别额外的原则

     let yetAnotherPoint =  switch yetAnotherPoint { case let  where x == y: print,  is on the line x == y") case let  where x == -y: print,  is on the line x == -y") case let : print,  is just some arbitrary point") } // 输出 " is on the line x == -y"
    

//2. while循环
// “while循环会一贯运维一段语句直到条件成为false。 那类循环适合选取在第三回迭代前,迭代次数未知的景观下

5.决定转移语句

swift有5种调节转移语句:continue,break,fallthrough,return,throw

  • Continuecontinue讲话告诉循环体结束本次循环,重新开首后一次巡回,并非甘休整个循环。

     let input = "great minds think alike" var b = " " for c in input.characters { switch c { case "a","e","i","o","u"," ": continue default: b.append } } print
    
  • Break登时甘休全数调控流的施行

     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 } if let integerValue = possibleIntegerValue { print("The integer value of  (numberSymbol) is (integerValue).") } else { print("An integer value could not be found for (numberSymbol).") } // 输出 "The integer value of 三 is 3."
    
  • 贯穿 Fallthrough

Swift 中的switch不会从上一个case分段落入到下多少个 case支行中。相反,只要第三个门户大致到的 case分段完结了它要求进行的言语,整个switch代码块达成了它的进行。相比较之下,C 语言必要你显式地插入break语句到种种switch分支的末梢来阻止自动落入到下一个 case分段中。Swift的这种制止暗中认可落入到下二个分层中的性格意味着它的switch 成效要比 C 语言的越来越清晰和可预测,能够幸免无意识地施行多少个case分层进而吸引的不当。即便您确实需求C 风格的贯通的特色,你能够在每种须求该性情的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." } print(description) // 输出 "The number 5 is a prime number, and also an integer."
  • 提早退出 guard

    a = 7guard a >= 10 else { return }//return

  • 检测API可用性

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

//“while循环,每便在循环开端时总括口径是还是不是适合;
//repeat-while循环,每便在循环结束时计算口径是不是相符,会至少推行一遍。

//2.1: “while循环从计算一个条件开始。如果条件为true,会重复运行一段语句,直到条件变为false。”
var i = 1
while i<5 {
    i+=1
}

//2.2:“while循环的其余一种样式是repeat-while,它和while的区分是在认清循环条件此前,先推行三回巡回的代码块。然后再一次循环直到条件为false。”

//“Swift语言的repeat-while循环和其他语言中的do-while循环是类似的”
repeat {
i+=1
}while i<10

//3. 准则语句

//3.1: “if语句最简单的形式就是只包含一个条件,只有该条件为true时,才执行相关代码”
if i>5 {
  print("jack")
}

//“if语句允许二选一执行,叫做else从句”
if i<5 {
print("rose")
}else{
print("jack")
}

//“多个if语句链接在一起,来实现更多分支”
if i<5 {
print("rose")
}else if i<8 {
print("rose")
}else{
print("jack")
}

//“当不需要完整判断情况的时候,最后的else语句是可选的”
if i < 5 {
print("rose")
}else if i < 8 {
print("rose")
}

//3.2: “switch语句会尝试把某部值与若干个格局(pattern)举办相配。依据第一个门道卓越成功的情势,switch语句会实施相应的代码。当有希望的情况非常多时,日常用switch语句替换if语句”
//“switch语句由三个 case 构成,每种由case关键字开首。为了合营某个更特定的值,Swift提供了二种方法来拓宽更复杂的形式相配,这几个格局就要本节的稍后有的关联”
//“switch语句必得是万事俱备的。那正是说,每二个可能的值都必需至少有叁个 case 分支与之对应。在一些不恐怕带有全部值的状态下,你能够利用暗许(default)分支来含有别的具备未有相应的值,那一个暗许分支必需在switch语句的最终边。”

let someCharacter: Character = "z"
switch someCharacter {
case "a":
    print("the first leter of the alphabet")
case  "z":
    print("the last letter of the alphabet")
default:
    print("some other character")
}

// 子虚乌有隐式的贯通
//“与 C 和 Objective-C 中的switch语句分歧,在 Swift 中,当相配的 case 分支中的代码施行达成后,程序会停下switch语句,而不会继续试行下贰个 case 分支。那也实属,不需求在 case 分支中显式地使用break语句”
//注意:即使在Swift中break不是必需的,但您仍然得以在 case 分支中的代码实行达成前使用break跳出”

//“每一个 case 分支都必须包含至少一条语句。像下面这样书写代码是无效的,因为第一个 case 分支是空的:”
//let anotherCharacter: Character = "a"
//switch anotherCharacter {
//case "a":
//case "A":
//    print("letter A")
//default:
//    print("Not the letter A")
//}
//“不像 C 语言里的switch语句,在 Swift 中,switch语句不会一起匹配"a"和"A"。相反的,上面的代码会引起编译期错误:case "a": 不包含任何可执行语句”

//“可以将这个两个值组合成一个复合匹配,并且用逗号分开:”
let anotherCharacter: Character = "a"
switch anotherCharacter {
case  "a","A":
    print("letter a")
default:
    print("no letter a")
}

//区间匹配
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"
default:
    naturalCount = "many"
}
print(naturalCount)

//switch与元组
//“大家能够利用元组在同二个switch语句中测量试验七个值。元组中的成分得以是值,也得以是距离。别的,使用下划线(_)来同盟全部望的值”

let somePoint = (1,1)
switch somePoint {
case (0,0):
    print("0,0 is at the origin")
case  (_,0):
    print("somePoint,0 is on the x-axis")
case (0,_):
    print("0,somePoint is on the y-axis")
case (-2...2,-2...2):
    print("(somePoint.0,somePoint.1) is inside of the box")
default:
    print("is out side the box")
}

//“不像 C 语言,Swift 允许多少个 case 相称同一个值。实际上,在这么些例子中,点(0, 0)能够包容全数多个case。然则,借使存在三个门户相当,那么只会实行第三个被匹配到的 case 分支。

//switch与值绑定
//“case 分支允许将特别的值绑定到叁个一时半刻的常量或变量,并且在case分支体内使用 —— 这种作为被称为值绑定(value binding),因为门户特别的值在case分支体内,与一时的常量或变量绑定”

let anotherPoint = (2,2)
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 an y value of (y)")
case let (x,y):
    print("some else at (x,y)")
}

//“这么些switch语句不分包默许分支。那是因为最后一个 case ——case let(x, y)注脚了一个得以相配余下全体值的元组。那使得switch语句已经完备了,因而无需再挥洒暗许分支。”

//switch与where

//“case 分支的模式可以使用where语句来判断额外的条件”
let yetAnothePoint = (1,-1)
switch yetAnothePoint {
case let (x,y) where x == y:
    print("(x,y) is on the line x==y")
case let (x,y) where x == -y:
    print("(x,y) is on the line x==-y")
case let (x,y):
    print("(x,y) is just some arbitrary point")
}

//switch与复合相称
//“当三个规范得以采纳一样种格局来管理时,能够将这两种大概位于同二个case前边,并且用逗号隔开分离。当case前面包车型地铁随机一种格局相称的时候,那条分支就能够被匹配。并且,如若匹配列表过长,还足以分钟鼓文写”

let myCharacter: Character = "e"
switch myCharacter {
case "a","e","i","o","u":
    print("(someCharacter) is a vowel")
case "b","c","d","f","g","h","i","j",
     "k","l" :
    print("(someCharacter) is a consonant")
default:
    print("(someCharacter) is not vowel or a consonant")
}

//“复合相配同样能够包涵值绑定。复合匹配里全部的相配格局,都不可能不带有同样的值绑定。并且每三个绑定都必得得到到同样类其他值。那保证了,无论复合相配中的哪个格局发生了协作,分支体内的代码,都能博获得绑定的值,何况绑定的值都有同一的品种”

let stillAnotherPoint = (9,0)
switch stillAnotherPoint {
case (let distance,0),(0,let distance):
    print("On an axis , (distance) from the origin")
default:
    print("not on an axis")
}

//4. 调控转移语句 ***
//“调控转移语句退换您代码的施行各种,通过它能够落成代码的跳转。Swift有七种调节转移语句:

/* continue
   break
   fallthrough
   return
   throw
*/

//4.1:“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)

//4.2:“break语句会登时终止全体调整流的举办。当您想要更早的停止三个switch代码块或许二个循环体时,你都足以选取break语句。”

//“循环语句中的 break,当在贰个循环体中应用break时,会登时制动踏板该循环体的实行,然后跳转到表示循环体结束的大括号(})后的首先行代码。不会再有本次巡回的代码被实践,也不会再有下一次的循环发生。”

for i in 1..<5 {
    print(i)
    if i>3 {
        break
    }
}

//“Switch 语句中的 break,当在一个switch代码块中利用break时,会即时暂停该switch代码块的实施,而且跳转到表示switch代码块截止的大括号(})后的率先行代码”
//“被用来协作只怕忽视三个或多少个支行。因为 Swift的switch须要富含全数的分层况兼不允许有为空的分支,一时为了使您的筹算更猛烈,要求特意相称也许忽视有些分支。那么当你想忽视某些分支时,能够在该分支援内地建设写上break语句。当那么些分支被相称到时,分支援内地建设的break语句立刻终止switch代码块”

let numberSymbol: Character = "二"
var possibleIntegerValue : Int?
switch numberSymbol {
case "1","一","n":
    possibleIntegerValue = 1
case "2","二","e","n":
    possibleIntegerValue = 2
case "3","s","三","j":
    break
default:
    break
}

if let integerValue = possibleIntegerValue {
print("the integer value of (numberSymbol) is (integerValue) ")
}else{
print("an integer value could not be found")
}

//“在上边的事例中,想要把Character全体的的或许都枚举出来是不具体的,所以采取default分支来含有全数方面未有相称到字符的气象”

//4.3:贯穿 “斯维夫特中的switch不会从上一个 case 分支落入到下八个 case 分支中。只要第一个分外到的 case 分支完毕了它须要实行的语句,整个switch代码块实现了它的实施”“比较之下,C 语言供给您显式地插入break语句到各样 case 分支的终极来堵住自动落入到下三个 case 分支中”
//“假若您真的必要 C 风格的贯通的特征,你能够在各样必要该天性的 case 分支中央银行使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"
}
print(description) //the number 5 is a prime number, and also an integer

//“使用fallthrough关键字来“贯穿”到default分支中”
//注意:fallthrough关键字不会检查它下三个将会落入实行的 case 中的相配原则。fallthrough轻便地使代码继续连接到下三个 case 中的代码,那和 C 语言专门的学问中的switch语句脾气是一模二样的。

//4.4 带标签的言辞
//“在 Swift中,你能够在循环体和标准语句中嵌套循环体和规范语句来制造复杂的调整流结构。况兼,循环体和条件语句都足以运用break语句来提前甘休整个代码块。因而,显式地指明break语句想要终止的是哪个循环体只怕条件语句,会很有用。类似地,假设您有数不尽嵌套的循环体,显式指明continue语句想要影响哪多少个循环体也会特别管用。”
//“你能够接纳标签(statement label)来标识一个循环体也许条件语句,对于三个规范化语句,你能够应用break加标签的格局,来收尾这一个被标识的讲话。对于多个循环语句,你可以选择break可能continue加标签,来停止或许接二连三这条被标识语句的施行”

for i in 1...10 {
    for j in 1...10 {
        if j>2 {
            print("i:(i),j:(j)")
            break   //影响内循环
        }
    }
    if i>4 {
        print("外循环i:(i)")
        break // 影响外循环
    }
}

outLoop: for i in 1...10 {
    insideLoop: for j in 1...10 {
        if j>2 {
        print("insieLoop: i:(i),j:(j)")
            break insideLoop
        }
    }
    if i>4 {
    print("outLoop: i:(i)")
        break outLoop
    }
}
//使用循环标签会让层级更明显。

//5. 提前退出
//“像if语句同样,guard的实践取决于三个表明式的布尔值。大家得以行使guard语句来要求标准必得为真时,以实践guard语句后的代码。差别于if语句,一个guard语句总是有一个else从句,要是基准不为真则实施else从句中的代码”

func greet(_ peason : [ String : String ] ){
    guard let name = peason["name"] else {
        return
    }
    print("hello (name)")
    guard let location = peason["location"]  else {
        print("i hope the weather is nice in near you")
        return
    }
    print("i hope the weather is nice in (location)")

}

greet(["name":"jack"])
//hello jack
//i hope the weather is nice in near you

greet(["name":"rose","location":"Cupertino"])
//hello rose
//i hope the weather is nice in Cupertino

//“要是guard语句的尺度被满意,则继续推行guard语句大括号 后 的代码。将变量大概常量的可选绑定作为guard语句的基准,都得以保险guard语句前面包车型地铁代码。“假如基准不被满意,在else分支上的代码就能被实行。那个分支必需更改调节以脱离guard语句出现的代码段”“它能够用调整转移语句如return,break,continue可能throw做那事,恐怕调用二个不回去的措施或函数,举个例子fatalError()”
//“比较于能够兑现平等效力的if语句,按需接纳guard语句会提高大家代码的可读性。它能够使您的代码连贯的被试行而不须要将它包在else块中,它能够使您在相邻条件推断的地点,管理不合法的情景。”
//guard非常好用的。

//6. 检验API的可用性
//“Swift内置支持检查 API 可用性,那能够保证我们不会在当下配备机器上,一点都不小心地运用了不可用的API。”

if #available(iOS 10,macOS 10.12, watchOS 1.0,tvOS 1.0,*){
    print("API可用,语句将执行")
}else{
    print("API不可用,语句不会执行")
}

本文由今晚买四不像发布于网络工程,转载请注明出处:Swift学习(四:调节流)

关键词:

上一篇:没有了
下一篇:没有了