这期主要讲一下关于常用控制语句以及方法的使用

首先是循环语句

常用的for in（这个在上期就有简单的涉及，跟其它语言也类似）

vararrayBu=["法师","圣骑士","术士","德鲁伊","盗贼"]

foriteminarrayBu{
println(item)
}

vardictionaryBu=["职业":"法师","模式":"竞技场"]

for(key,value)indictionaryBu{
println("\(key):\(value)")
}

forvari=0;i<=5;i++{
println(i)
}

foriin0...5{
println(i)
}

forcharin"sunWanhua"{
println(char)
}

然后是while与do while（跟其它语言类似，不做过多说明）

varx=0
varresult=0

whilex<10{
result+=x
x++
}

println(result)

vary=0

do{
y--
}whiley>-5

println(y)

接下来是条件语句

常用的if else （跟其它语言类似，不做过多说明）

vartemp=30

iftemp<32{
println(0)
}elseiftemp>33&&temp<40{
println(1)
}else{
println(2)
}

然后是switch，这个跟其他语言有点不一样，我们可以多练习练习

varflag="sse"

//同时满足几个条件，只走第一个条件
//这里不用再加break了，每次执行后默认走break
//这个已经不是单一的只能放整数类型与枚举类型了哦，我们还可以放字符串与元祖等类型做依据哦
switch(flag){
case"happy":
println("高兴")

case"sad","lose":
println("悲伤")

caselettestwheretest.hasSuffix("se"):
println("你猜我在干吗")

default:
println("没什么感觉")
}

varnumber=-5

switch(number){
case0...9:
println("这是个位数")
case10...99:
println("这是十位数")
case100...9999:
println("这是很大的数")
default:
println("这是负数")
}

letpoint=(6,6)

switch(point){
case(0,0):
println("原点")
case(_,0):
println("x轴")
case(0,lety):
println("y轴上的点\(y)")
case(-2...2,-2...2):
println("矩形-2...2区域")
caselet(x,y)wherex==y||x==-y:
println("在对角线上")
case(letx,lety):
println("随意的点\(x),\(y)")
default:
println("某一点")
}

接下来是转移语句

常用的有continue，break，return，fallthrough(常与switch嵌套使用)

前三种跟其它语言一样，没有过多解释

etstr="greatmindsthinkalick"

forcharinstr{
switchchar{
case"a","e","i","o","u","":
continue
default:println(char)
}
}

foriin1...10{
println(i)
ifi>5{
break
}
}

lettempNumber=5
vardescript="数字\(tempNumber)是"

//这里用fallthrough来起到桥梁的作用，让这两个语句关联一起并执行
switchtempNumber{
case2,3,5,7,11,13:
descript+="一个素数，同时也是一个"
fallthrough
default:
descript+="整数"
}

println(descript)

然后就来介绍一下方法的基本介绍与使用吧

在这里我们用func来定义方法

一般为： func 方法名(参数,参数) ->返回参数类型 {}

调用的时候为：方法名(参数,参数)

//单参数
funcsayHello(username:String)->String{
letgreeting="你好,\(username)"
returngreeting
}

println(sayHello("swh"))

//多参数
funcsumOf(numberA:Int,numberB:Int)->Int{
returnnumberA+numberB
}

println(sumOf(10,5))

//无返回值
funcsayGoodbye(username:String){
println("欢迎\(username)下次再来")
}

sayGoodbye("kutian")

//无返回值无参数
funcsayWelcome(){
println("欢迎来到Swift")
}

sayWelcome()

//单参数，返回值为多参数，类似元祖
funccountString(value:String)->(vowels:Int,consonants:Int,others:Int){
varvowels=0,consonants=0,others=0
forcharinvalue{
switchString(char).lowercaseString{
case"a","u":
vowels++
case"b","c":
others++
default:
consonants++
}
}
return(vowels,consonants,others)
}

letcount=countString("somestringinEnglish!")

println(count.vowels)

//多参数，且最后一个参数给出默认值
funcjoinString(firstValuevalue1:String,secondValuevalue2:String,betweenerjoiner:String="-")->String{
returnvalue1+joiner+value2
}

println(joinString(firstValue:"a",secondValue:"b"))

//"#"为上面方式的简写，主要是给出参数的解释，类似O-C，易读
funcjoinStringNew(#firstValue:String,#secondValue:String,betweener:String="-")->String{
returnfirstValue+betweener+secondValue
}

println(joinStringNew(firstValue:"w",secondValue:"a",betweener:"+"))

//不定参数，可传任意个
funcsumOfNumbers(numbers:Double...)->Double{
vartotal:Double=0
fornuminnumbers{
total+=num
}
returntotal
}

println(sumOfNumbers(1,8))

//inout表示所传参数为其地址，所以我们再传参数时需要加上"&"
//这里跟C语言函数类似
funcmodifyInt(inouta:Int,inoutb:Int){
a+=3
b=6
}

varsomeInt=3
varanotherInt=9

modifyInt(&someInt,&anotherInt)
println("\(someInt),\(anotherInt)")

funcaddTwoInt(a:Int,b:Int)->Int{
returna+b
}

//方法在swift中也算一个类，那么也可以定义成变量的类型
varmathFunc:(Int,Int)->Int=addTwoInt

println(mathFunc(1,2))

//方法也可以在其它方法中充当参数或者返回值
funcprintMathResult(mathFunction:(Int,Int)->Int,a:Int,b:Int){
println(mathFunction(a,b))
}

println(printMathResult(addTwoInt,5))

funcfirstFunction(i:Int)->Int{
returni+1
}

funcsecondFunction(i:Int)->Int{
returni+2
}

funcchooseFunction(which:Bool)->(Int)->Int{
returnwhich?firstFunction:secondFunction
}

//这里targetFunction就等价于first与second某一个方法()
lettargetFunction=chooseFunction(false)

println(targetFunction(1))

//嵌套使用

//在方法中，我们还可以定义方法，并且调用这些定义的
funcnewChooseFunction(which:Bool)->(Int)->Int{

funcfirstFunctionNew(i:Int)->Int{
returni+1
}

funcsecondFunctionNew(i:Int)->Int{
returni+2
}

returnwhich?firstFunction:secondFunction
}

lettargetFunctionNew=newChooseFunction(false)

println(targetFunctionNew(1))

好啦，就介绍这么多吧