let orangesAreOrange = true//自动推断为bool
let turnipsAreDelicious = false
if turnipAreDelicious{
println("Mmm,tasty turnips!")
} else {
println("Eww, turnips are horrible.")
}
let i = 1
if i{
//if语句不能用非bool值
}
if i==1{
//这样就可以
}
//5.元组tuple
let http404Error = (404,"Not Found")
let (statusCode,StatusMessage)= http404Error
println("The status code is \(statusCode)")
println("The status message is \(statusMessage)")
let (justTheStatusCode,_) = http404Error
println("The status code is \(justTheStatusCode)")
println("The status code is \(http404Error.0)")
println("The status message is \(http404Error.1)")
//tuple里的别名
let http200Status = (statusCode: 200, description: "OK")
println("The status code is \(http200Status.statusCode)")
println("The status message is\(http200Status.description)")
//Optional:有值或者不存在。这个地方看起来，java里很多的nullPointerException在swfit里可以避免了。
//也就是说我不用try catch
let possibleNumber = "123"
let convertedNumber = possibleNumber.toInt() //这个变量的类型推断结果是 Int? 或者optional Int
//用if来判断optional是否有值
if convertedNumber{
println("\(possibleNumber) has an Integer value of \(convertedNumber!)")
}else{
println(("\possibleNumber") could not be converted to an integer)
}
if let actualNumber = possibleNumber.toInt(){
println("\(possibleNumber) has an Integer value of \(actualNumber!)")
}
else{
println(("\possibleNumber") could not be converted to an integer)
}
//optional变量的初始化
var serverResponseCode:Int? = 404 //值为404
serverResponseCode = nil //空值
var surveyAnswer:String?//自动nil
let possibleString: String? = "An optional string"
println(possibleString!)
let assumedString: String! = "An implicitly unwrapped optional string."
println(assumedString)
if assumedString{
println(assumedString)
}
if let definiteString = assumedString {
println(definiteString)
}
let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
assert(age >= 0)
let b = 10
var a =5
a = b
let (x,y) = (1,2)
if x = y {
//invalid, no return value
}
1+2
5-3
2*3
10.0/2.5 //=4.0
"hello,"+"world"
let dog:Character = "dog"
let cow:Character = "cow"
let dogCow = dog + cow//="dogcow"
let num = 5
//let combine = dog + num // 报错
let combine = dog + String(num)
9%4//=1
-9%4//=-1
8%2.5//0.5
var i = 0
++i
var a = 0
let b = ++a//a=1,b=1
let c = a++//a=2,c=1
let three = 3
let minusThree = -three
let plusThree = -minusThree
let minusSix = -6
let alsoMinusSix = +minusSix//=-6
var a = 1
a += 2
let name = "world"
if name == "world" {
println("hello,world")
} else {
println("I'm sorry \(name), but I don't recognize you")
}
let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight +(hasHeader ? 50 : 20)
//6.Range
//1到5，包括1也包括5
for index in 1...5{
println ("\(index) times 5 is \(index * 5)")
}
let names = ["Anna","Alex.","Brian","Jack"]
let count = names.count
//0到count，包括0不包括count，所以其实是0到count-1
for i in 0..count{
println("Person \(i+1)" is called \(names[i]))
}
let allowedEntry = false
if !allowedEntry{
println("ACCESS DENIED")
}
let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan{
println("Welcome!")
} else {
println("ACCESS DENIED")
}
if (enteredDoor && passedRetinaScan) || hasDoorKey || knowsOveridePassword{
println("Welcome!")
} else {
println("ACCESS DENIED")
}
let someString = "Some string literal value"
let wiseWords = "\"Imagination is more important than knowledge\" - Einstein"
let dollorSign = "\x24"
let blackHeart = "\u2665"
let sparkingHeart = "\U0001F496"
var emptyString = ""
var anotherEmptyString = String()
if emptyString.isEmpty {
println("Nothing to see here")
}
var variableString = "Horse"
variableString += " and carriage"
let constantString = "highlander"
constantString += " and another Highlander" // compile-time error
for character in "Dog!"{
println(character)
}
let yenSign:Character = "¥" //need the type annotation or it will be a string
let unusualMenagerie = "Koala , Snail ,Penguin ,Dromedary "
println("unusualMenagerie has \(countElements(unusualMenagerie)) characters")
let string1 = "hello"
let string2 = " there"
let character1:Character = "!"
let character2:Character = "?"
let stringPlusCharacter = string1 + character1
let stringPlusString = string1 + string2
let characterPlusString = character1 + string1
let characterPlusCharacter = character1 + character2
var instruction = "look over"
instruction += string2
var welcome = "good morning"
welcome += character1
let multiplier = 3
let message = "\(multiplier) times 2.5 is \(Double(multiplier)*2.5)"
let quotation = "We're a lot alike, you and I."
let sameQuotation = "We're a lot alike, you and I."
if quotation == sameQuotation{
println("These two strings are considered equal")
}
let romeoAndJuliet = [
"Act 1 Scene 1: Verona, A public place",
"Act 1 Scene 2: Capulet's mansion",
"Act 1 Scene 3: A room in Capulet's mansion",
"Act 1 Scene 4: A street outside Capulet's mansion",
"Act 1 Scene 5: The Great Hall in Capulet's mansion",
"Act 2 Scene 1: Outside Capulet's mansion",
"Act 2 Scene 2: Capulet's orchard",
"Act 2 Scene 3: Outside Friar Lawrence's cell",
"Act 2 Scene 4: A street in Verona",
"Act 2 Scene 5: Capulet's mansion",
"Act 2 Scene 6: Friar Lawrence's cell"
]
var act1SceneCount = 0
for scene in romeoAndJuliet{
if scene.hasPrefix("Act 1"){
++act1SceneCount
}
}
println("There are \(act1SceneCount) scenes in Act 1")
var mansionCount = 0
var cellCount = 0
for scene in romeoAndJuliet{
if scene.hasSuffix("Capulet's mansion"){
++mansionCount
} else if scene.hasSuffix("Friar Lawrence's cell"){
++cellCount
}
}
println("\(mansionCount) mansion scenes;\(cellCount) cell scenes")
let normal = "Could you help me,please?"
let shouty = normal.uppercaseString
let whispered = normal.lowercaseString
let dogString = "Dog!"
for codeUnit in dogString.utf8{
print("\(codeUnit)")
}
print("\n")
for codeUnit in dogString.utf16{
print("\(codeUnit)")
}
print("\n")
for scalar in dogString.unicodeScalars{
print("\(scalar.value)")
}
print("\n")
var shoppingList:String[]=["Eggs","Milk"] //var所以可以再加元素，let就不行了
var shoppingList = ["Eggs","Milk"] //因为类型推断，一个array必须包含同类元素，所以能推断出来是string类
println("The shopping list contains \(shoppingList.count) items.")
if shoppingList.isEmpty{
println("The shopping list is empty.")
} else {
println("The shopping list is not empty.")
}
shoppingList.append("Flour")
shoppingList += "Baking Powder"
shoppingList += ["Chocolate Spread","Cheese","Butter"]
var firstItem = shoppingList[0]
shoppingList[0] = "Six eggs"
shoppingList[4...6]=["Bananas","Apples"] //4...6有3个元素，所以3个元素被换成了2个。不能越界哦。
shoppingList.insert("Maple Syrup",atIndex:0)
let mapleSyrup = shoppingList.removeAtIndex(0)//删除并放到mapSyrup里，而且所有元素都往前移了一格
firstItem = shoppingList[0]
let apples = shoppingList.removeLast()//删除并赋值，减少了array长度
for item in shoppingList{ //遍历
println(item)
}
for (index,value) in enumerate(shoppingList){
println("Item \(index + 1):\(value)")
}
//Item 1:Six eggs
//Item 2:Milk
//...
var someInts = Int[]() //var someInts:Int[] = [1,2,3] var someInts = [1,2,3]
println("someInts is of type Int[] with \(someInts.count) items.")
someInts.append(3)
someInts = []
var threeDoubles = Double[](count:3,repeatedValue:0.0)
var anotherThreeDoubles = Array(count:3,repeatedValue:2.5)//inferred as Double[]
var sixDoubles = threeDoubles + anotherThreeDoubles
var airports:Dictionary<String,String> = ["TYO":"Tokyo","DUB":"Dublin"]
var airports = ["TYO":"Tokyo","DUB":"Dublin"]
println("The dictionary of airports contains \(airports.count) items.")
airports["LHR"] = "London"
airports["LHR"] = "London Heathrow"
if let oldValue = aiports.updateValue("Dublin International", forKey:"DUB"){
println("The old value for DUB was \(oldValue).")
}
if let airportName = airports["DUB"]{
println("The name of the airport is \(airportName).")
} else {
println("That airport is not in the airports dictionary")
}
airports["APL"] = "Apple International"
airports["APL"] = nil //从字典里删元素
if let removedValue = airports.removeValueForKey("DUB"){
println("The removed airport's name is \(removedValue).")
} else {
println("The airports dictionary does not contain a value for DUB.")
}
for(airportCode, airportName) in airports{
println("\(airportCode):\(airportName)")
}
for airportCode in airports.keys{
println("Airport code:\(airportCode)")
}
for airportName in airports.values{
println("Airport name:\(airportName)")
}
let airportCodes = Arrary(airports.keys)
let airportNames = Arrary(airports.values)
//dictionary里元素没有顺序，所以遍历时顺序不确定和插入时顺序一致
var namesOfIntegers = Dictionary<Int,String>()//初始化一个空字典
namesOfIntegers[16]="sixteen"//可以类型推断出来
namesOfIntegers = [:]//再次置为空值，但类型不变
//let的immutable的dictionary不能改变key，一旦设定value后也不能改变key的对应value。arrary则可以改变value。都不能增加长度
//如果长度固定，尽量用let
for index 1...5{ //index隐式声明，不用let
println("\(index) times 5 is \(index * 5)")
}
let base = 3
let power = 10
var answer = 1
for _ in 1...power{//如果元素无所谓，可以下划线代替
answer *= base
}
println("\(base) to power of \(power) is \(answer)")
let names = ["Anna","Alex","Brian","Jack"]
for name in names{
println("Hello,\(name)!")
}
let numberOfLegs = ["spider":8,"ant":6,"cat":4]
for (animalName,legCount) in numberOfLegs{
println("\(animalName)s have \(legCount) legs")
}
for character in "Hello"{}
println(character)
}
for var index = 0; index < 3; ++index{
println("index is \(index)")
}
var index:Int
for index = 0; index <3; ++index{
println("index is \(index)")
}
println("The loop statements were executed (\index) times")
let finalSquare = 25
var board = Int[](count: finalSquare + 1,repeatedValue:0)
board[03]=+08;board[06]=+11;board[09]=+09;board[10]=+02
board[14]=-10;board[19]=-11;board[22]=-02;board[24]=-08
var square = 0
var diceRoll = 0
while square < finalSquare{
//roll the dice
if ++diceRoll==7{diceRoll = 1}
//move by the rolled amount
square += diceRoll
if square < board.count{
square +=board[square]
}
}
println("Game over!")
do{
square += board[square]
if ++diceRoll == 7 {diceRoll = 1}
square += diceRoll
} while square < finalSquare
println("Game over!")
var temperatureInFahrenheit = 30
if temperatureInFahrenheit <= 32{
println("It's very cold. Consider wearing a scarf.")
}
//###############################################################################
temperatureInFahrenheit = 40
if temperatureInFahrenheit <= 32{
println("It's very cold. Consider wearing a scarf.")
} else {
println("it's not that cold. Wear a t-shit.")
}
temperatureInFahrenheit = 90
if temperatureInFahrenheit <= 32{
println("It's very cold. Consider wearing a scarf.")
} else if temperatureInFahrenheit >= 86{
println("It's really warm. Don't forget to wear sunscreen")
} else {
println("it's not that cold. Wear a t-shit.")
}
let someCaracter:Character = "e"
switch someCharacter{
case "a","e","i","o","u":
println("\(someCharacter) is a vowel")
case "b","c":
println("\(someCharacter)is a consonant")
default:
println("\(someCharacter) is not a vowel or a consonant")
}
//switf 的switch语句的各个case之间没有顺序执行关系。跑完一个case之后会直接结束，而不是接着跑下一个case
//一般不用写break了。但想用的时候还是可以用break的。
//case后面必须至少包含一个可执行语句，否则会报错。
let anotherCharacter:Character = "a"
switch anotherCharacter{
case "a":
case "A":
println("The letter A")
default:
println("Not the letter A")
}
//那要多项匹配时就可以用逗号隔开
//Range匹配
let count = 3_000_000_000_000
let countedThings = "stars in the Milky Way"
var naturalCount:String
switch count {
case 0:
naturalCount = "no"
case 1...3:
naturalCount = "a few"
case 4...9:
naturalCount = "several"
case 10...99:
naturalCount = "tens of"
case 100...999:
naturalCount = "hundreds of"
case 1000...999_999:
naturalCount = "thousands of"
default:
naturalCount = "millions and millions of"
}
println("There are \(naturalCount) \(countedThings)")
//tuple.0里的0是index下标
//如果同时匹配上了多个case，则第一个生效，其他忽略
let somePoint = (1,1)
switch somePoint{
case(0,0):
println("(0,0) is at the origin")
case(_,0):
prinltn("(\(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")
}
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))")
}
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")
}
let puzzleInput = "great minds think alike"
var puzzleOutput = ""
for character in puzzileInput {
switch character{
case "a","e","i","o","u"," ":
continue
default:
puzzleOutput += character
}
}
println(puzzleOutput)
//switch中可以用break来表示忽略一个case
let numberSymbol:Character = "三"
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{
println("THe integer value of \(numberSymbol) is \(integerValue)")
} else {
println("An integer value could not be found for \(numberSymbol)")
}
let integerToDescribe = 5
var description = "The number \(integerToDescribe) is"
switch integerToDescribe{
description += "a prime number, and also"
fallthrough
default:
description += "an integer."
}
println(description)
let finalSquare = 25
var board = Int[](count: finalSquare + 1,repeatedValue:0)
board[03]=+08;board[06]=+11;board[09]=+09;board[10]=+02
board[14]=-10;board[19]=-11;board[22]=-02;board[24]=-08
var square = 0
var diceRoll = 0
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 sayHello(personName:String) -> String{
let greeting = "Hello," + personName + "!"
return greeting
}
println(sayHello("Anna"))
println(sayHello("Brian"))
func sayHelloAgain(personName:String) -> String{
return "Hello again," + personName + "!"
}
println(sayHelloAgain("Anna"))
func halfOpenRangeLength(start:Int,end:Int) -> Int{
return end - start
}
println(halfOpenRangeLength(1,10))
func sayHelloWorld() -> String{
return "hello,world"
}
println(sayHelloWorld())
//其实返回了空tuple()
func sayGoodbye(personName:String){
println("Goodbye,\(personName)!")
}
sayGoodbye("Dave")
func printAndCount(stringToPrint:String) -> Int{
println(stringToPrint)
return countElements(stringToPrint)
}
func printWithoutCounting(stringToPrint:String){
printAndCount(stringToPrint)
}
printAndCount("hello,world")
printWithoutCount("Hello,world")
//func里用tuple返回多个值
func count(string:String) ->(vowels:Int,consonants:Int,others:Int){
var vowels = 0, consonants = 0, others = 0
for character in string{
switch String(character).lowercaseString{
case "a","e","i","o","u":
++vowels
case "b","c",xxxxxxxxxxxxxxxx:
++consonants
default:
++others
}
}
return (vowels,consonants,others)
}
let total = count("some arbitrary string!")
println("\(total.vowels) vowels and \(total.consonants) consonants")
//patameterName是局部变量，只在func体内生效
func someFunction(parameterName:Int){
}
//如果定义了external paramter name，那调用时必须使用他
func someFunction(externalParameterName localParameterName:Int){
}
//不用external paramter name时，调用方法的时候看不出来每个参数是什么
func join(s1:String,s2:String,joiner:String) -> String{
return s1 + joiner + s2
}
join("hello","world",",")
//用了external paramter name的话
func join(string s1:String, toString s2:String, withJoiner joiner:String) -> String{
return s1 + joiner +s2
}
join(string:"hello",toString:"world",withJoiner:",")
//external parameter简写
func containsCharacter(#string:String,#characterToFind:Character) -> Bool{
for character in string{
if character == characterToFind{
return true
}
}
return false
}
let containsAVee = containsCharacter(string:"aardvark",characterToFind:"v")
//默认值
func join(string s1:String, toString s2:String, withJoiner joiner:String = "") ->{
return s1 + joiner +s2
}
//如果有传值，就正常调用
join(string:"hello",toString:"world",withJoiner:"=")
//如果没有传，就用默认值了
join(string:"hello",toString:"world")
//如果有了默认值，就自动有了external parameter name
func join(s1:String, s2:String, joiner:String = " ")->String{
return s1 + joiner + s2
}
join("hello","world",joiner:"-")
//variadic parameter加三个点.一个数组。每个方法最多一个可变参数，一定要放最后
func arithmeticMean(numbers:Double...)->Double{
var total:Double = 0
for number in numbers{
total += number
}
return total / Double(numbers.count)
}
arithmeticMean(1,2,3,4,5) //3.0
arithmeticMean(3.8.19)//10.0
//constant and variable parameters
//默认都是constant。而variable参数是copy一个参数的值来用。可以改。
func alinRight(var string:String, count:Int, pad:Character) -> String{
let amountToPad = count- countElements(string)
for _ in 1...amountToPad{
string = pad + string
}
return string
}
let originalString = "hello"
let paddedString = alignRight(originalString,10,"-")
//-----hello
//注意，这里，originalString值没改。
//inout 参数
//这个类型的参数跟上面这个不同，会影响original string
//inout不能是可变参数，
//inout 不能用var、let来标记，默认var
func swapTwoInts(inout a:Int, inout b:Int){
let temporaryA = a
a = b
b = temporaryA
}
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt,&anotherInt)
//这里注意加了&符号，这样才能用于inout参数
func addTwoInts(a: Int, b: Int) -> Int{
return a + b
}
func multiplyTwoInts(a: Int, b: Int) -> Int{
return a * b
}
func printHelloWorld(){
println("hello, world")
}
// (Int, Int) -> Int 是func的type，addTwoInts是一个func，这里把这个func赋值给一个var
var mathFunction: (Int, Int) -> Int = addTwoInts
println("Result: \(mathFunction(2,3))")//5
mathFunction = multiplyTwoInts
println("Result: \(mathFunction(2,3))")//6
let anotherMathFunction = addTwoInts //类型推断也可以适用
//func做参数
func printMathResult(mathFunction: (Int, Int) -> Int, a: Int, b: Int){
println("Result: \(mathFunction(a,b))")
}
printMathResult(addTwoInts, 3, 5)
printMathResult(multiTwoInts, 3, 5)
//func做返回值
func stepForward(input: Int) -> Int{
return input + 1
}
func stepBackward(input: Int) -> Int{
return input - 1
}
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
return backwards ? stepBackward : stepForward
}
var currentValue = 3
let moveNearerToZero = chooseStepFunction(currentValue > 0)//然后moveNearerToZero就指向了stepBackward()了
println("Counting to zero:")
//Counting to zero:
while currentValue != 0 {
println("\(currentValue)...")
currentValue = moveNearerToZero(currentValue)
}
println("zero!")
//3...
//2...
//1...
//zero!
//nested func
func chooseStepFunction(backwards: Bool) -> (Int) -> Int{
func stepForward(input: Int) -> Int { return input + 1 }
func stepBackward(input: Int) -> Int { return input - 1 }
return backwards ? stepBackward : stepForward
}
var currentValue = -4
let moveNearerToZero = chooseStepFunction(currentValue > 0)
//now it refers to the nested stepForward() function
while currentValue != 0{
println("\(currentValue)...")
currentValue = moveNearerToZero(currentValue)
}
println("zero!")
//-4...
//-3...
//-2...
//-1...
//zero!
let names = ["Chris","Alex","Ewa","Barry","Daniella"]
func backwards(s1: String, s2: String) -> Bool {
return s1 > s2
}
var reversed = sorted(names, backwards)
reversed = sorted( names, { (s1: String, s2: String) -> Bool in
return s1 > s2
})
reversed = sorted(names, {s1,s2 in return s1 > s2})
reversed = sorted(names, {s1, s2 in s1 > s2})
reversed = sorted(names, {$0 > $1})
reversed = sorted(names, >)
func someFunctionThatTakesAClosure(closure: () -> ()){
//xxxxxxxxxxxxxxxxx
}
//普通调用
someFunctionThatTakesAClosure({
//xxxx
})
//trailing closure调用
someFunctionThatTakesAClosure(){
//xxxx
}
reversed = sorted(names){$0 > $1}
let digitNames = [0: "Zero", 1: "One", 2: "Two", 3: "Three", 4: "Four",
5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine",
]
let numbers = [16,58,150]
let strings = numbers.map {
(var number) -> String in
var output = ""
while number > 0 {
output = digitNames[number % 10]! + output
number /= 10
}
return output
}
func makeIncrementor(forIncrement amount: Int) -> () -> Int{
var runningTotal = 0
func incrementor() -> Int{
runningTotal += amount
return runningTotal
}
return incrementor
}
let incrementByTen = makeIncrementor(forIncrement: 10)
incrementByTen()// 10
incrementByTen()// 20
let incrementBySeven = makeIncrementor(forIncrement: 7)
incrementBySeven()//7
incrementByTen()// 30
let alsoIncrementByTen = incrementByTen
alsoIncrementByTen()//40
enum SomeEnumeration {
//enumeration definition here
}
