swift学习之数组、字典、控制流

浏览数：19 / 时间：2015年06月08日
// Playground - noun: a place where people can play

import UIKit
//2014-09-23 集合类型 Collection Types

//.............................................

//1.数组
/*
1. 数组是类型安全的


*/

//1.1定义一个数组变量
var shoppingList:[String]=["apple","Eggs"]
if shoppingList.isEmpty {
    println("The shopping list is empty.")
} else {
    println("The shopping list is not empty.")
}

shoppingList.append("orangle") //数组添加元素
shoppingList+=["1","2"] //数组加法运算符

shoppingList[0]="six apples" //修改数组元素
shoppingList

//1.2 可以利用下标来一次改变一系列数据值，即使新数据和原有数据的数量是不一样的。
//但下标不能越界
shoppingList[2...4]=["A","B"]  //把2、3、4三个元素变成两个元素，牛逼
shoppingList
//1.3 插入元素
shoppingList.insert("Z", atIndex: 2)
shoppingList

//1.4 移除元素
shoppingList.removeAtIndex(0) //移除第一项
shoppingList
//1.5 数组的遍历
//1.51

for item in shoppingList{
    print(item+" ")
}
println()

//1.52 可以使用全局enumerate函数来进行数组遍历
for (index,value) in enumerate(shoppingList){
    println("Index is \(index) :value \(value)")

}
//1.53 使用构造语法来创建一个由特定数据类型构成的空数组
var someInt=[Int]()

someInt+=[1,2,3]
someInt=[] //变成空的整形数组

//1.54 Swift 中的Array类型还提供一个可以创建特定大小并且所有数据都被默认的构造方法。

var threeDoubles=[Double](count: 3, repeatedValue: 0.0)
var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)

var sixDoubles=threeDoubles+anotherThreeDoubles



//2. 字典
/*
在 Swift 中，在某个特定字典中可以存储的键和值必须提前定义清楚，方法是通过显性类型标注或者类型推断。
*/

//2.1
var airports:Dictionary<String,String>=["TYO":"Tokyo","DUB":"Dublin"]
var charts=["A":"a","B":"b"]

//2.2 插入新值
charts["C"]="c"
charts
//2.3.1 修改
charts["C"]="CC"
charts
/*
2.3.2
updateValue(forKey:)函数会返回包含一个字典值类型的可选值。举例来说：对于存储String值的字典，这个函数会返回一个String?或者“可选 String”类型的值。如果值存在，则这个可选值值等于被替换的值，否则将会是nil。
*/


if let oldValue=charts.updateValue("CCCC", forKey: "C"){
    println("C's old value is :\(oldValue)")
}

charts["D"]="d"
charts
//2.3.3 使用下标语法来通过给某个键的对应值赋值为nil来从字典里移除一个键值对
charts["D"]=nil
charts

/*
2.3.4 removeValueForKey方法也可以用来在字典中移除键值对。这个方法在键值对存在的情况下会移除该键值对并且返回被移除的value或者在没有值的情况下返回nil：
*/

//2.4 字典遍历

println()
//2.4.1 使用for-in循环来遍历某个字典中的键值对
for (charKey,charValue) in charts{
    println("\(charKey):\(charValue)")

}
//2.4.2 charts.values 类似
for charKey in charts.keys{
    println("key,\(charKey)")
}

//2.4.3 获得键值的数组
let chartKeyArray=Array(charts.keys)

/*
注意：
Swift 的字典类型是无序集合类型。其中字典键，值，键值对在遍历的时候会重新排列，而且其中顺序是不固定的
*/

//2.5 创建空字典
var namesOfIntergers=Dictionary<Int,String>()
namesOfIntergers[1]="First"
namesOfIntergers
//namesOfIntegers 又成为了一个 Int, String类型的空字典
namesOfIntergers=[:]

//..........................................................

//3. 控制流

//3.1 如果你不需要知道区间内每一项的值，你可以使用下划线（_）替代变量名来忽略对值的访问：

let base = 3
let power = 10
var answer = 1
for _ in 1...power {
    answer *= base
    println(answer)
}
println("\(base) 的 \(power) 次幂是 \(answer)")


//3.2 for 条件自增
for var index=0;index<3;++index{
    println(index)
    
}

//3.3 switch
/*
与 C 语言和 Objective-C 中的switch语句不同，在 Swift 中，当匹配的 case 分支中的代码执行完毕后，程序会终止switch语句，而不会继续执行下一个 case 分支。这也就是说，不需要在 case 分支中显式地使用break语句。这使得switch语句更安全、更易用，也避免了因忘记写break语句而产生的错误。
*/
let someCharacter: Character = "e"
switch someCharacter {
case "a", "e", "i", "o", "u":
    println("\(someCharacter) is a vowel")
case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
"n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
    println("\(someCharacter) is a consonant")
default:
    println("\(someCharacter) is not a vowel or a consonant")
}
// 输出 "e is a vowel"

//3.3.2 区间匹配
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).")
// 输出 "There are millions and millions of stars in the Milky Way."

//3.3.3 元组匹配
/*你可以使用元组在同一个switch语句中测试多个值。元组中的元素可以是值，也可以是区间。另外，使用下划线（_）来匹配所有可能的值。
*/

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")
}
// 输出 "(1, 1) is inside the box"

//3.3.4 值绑定（Value Bindings）
/*
case 分支的模式允许将匹配的值绑定到一个临时的常量或变量，这些常量或变量在该 case 分支里就可以被引用了——这种行为被称为值绑定（value binding）。
*/


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))")
}
// 输出 "on the x-axis with an x value of 2"


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


//3.4 控制转移语句（Control Transfer Statements）
//贯穿（Fallthrough）

/*
Swift 中的switch不会从上一个 case 分支落入到下一个 case 分支中。相反，只要第一个匹配到的 case 分支完成了它需要执行的语句，整个switch代码块完成了它的执行。相比之下，C 语言要求你显示的插入break语句到每个switch分支的末尾来阻止自动落入到下一个 case 分支中。Swift 的这种避免默认落入到下一个分支中的特性意味着它的switch 功能要比 C 语言的更加清晰和可预测，可以避免无意识地执行多个 case 分支从而引发的错误。

如果你确实需要 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)
// 输出 "The number 5 is a prime number, and also an integer."

//3.5 带标签的语句（Labeled Statements）

/*
使用标签来标记一个循环体或者switch代码块，当使用break或者continue时，带上这个标签，可以控制该标签代表对象的中断或者执行。
*/
运行结果：