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

// 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时,带上这个标签,可以控制该标签代表对象的中断或者执行。
*/

运行结果:

时间: 2024-09-26 19:02:39

swift学习之数组、字典、控制流的相关文章

Swift学习—字符串&amp;数组&amp;字典

字符串 OC和Swift中字符串的区别 在OC中字符串类型时NSString,在Swift中字符串类型是String OC中字符串@"",Swift中字符串"" Swift中String是第一个结构体,性能更高 String支持直接遍历 Swift提供了String和NSString之间的无缝转换 字符串的使用 用反斜线 \ 和小括号 () 做字符串插值(把常量\变量插入到字符串中) let hand = 2var age1 = 20let string1 = &q

Swift学习笔记(5)--字典

1.定义 //1.基本定义 [key 1: value 1, key 2: value 2, key 3: value 3] var dict = ["name":"Xiaoqin","sex":"female","age":"20"] for (key,value) in dict { println(key,value) } //2.类型强制定义 Dictionary<keyT

swift学习笔记-数组

swift中数组用[]表示 1.创建一个空数组 let emptyArr = [String]() let emptyArr1 : [NSNumber] = [] 这两种方式都可以 2.访问元素 var numArr=["1","2","3"] println("第一个元素:\(test1Array[0])") println("最后一个元素:\(test1Array.last)") 3.判断数组是否为空

Swift学习笔记数组与字典

swift中数组和字典都是以结构体的形式实现的. 首先,这个很奇葩,我不知道为什么这样设计,这样是出于一个什么样的考虑. 在C#中使用字典: Dictionary<int, string> dic = new Dictionary<int, string>(); Dictionary<int, string> dic1 = dic; dic.Add(1,"123"); dic1[1]="456"; Console.WriteLin

swift学习之数组(一)

首先数组的定义:以有序的方式存储相同类型的值 (1)数组的速写(shorthand)语法 你可以通过Array<Element>,在这里,Element时数组存储元素的值的类型,也可以通过中括号来写[Element] (2)创建一个空数组 var emptyArr = [Int]()(这里使用初始化方法创建一个Int型的空数组) emptyArr.append(3) emptyArr = [] (这里是用字面语句创建空数组) note:emptyArr is now an empty arra

swift学习之数组

首先数组的定义:以有序的方式存储同样类型的值 (1)数组的简写(shorthand)语法 你能够通过Array<Element>,在这里,Element时数组存储元素的值的类型.也能够通过中括号来写[Element] (2)创建一个空数组 var emptyArr = [Int]()(这里使用初始化方法创建一个Int型的空数组) emptyArr.append(3) emptyArr = [] (这里是用字面语句创建空数组) note:emptyArr is now an empty arra

Swift学习笔记四:数组和字典

最近一个月都在专心做unity3d的斗地主游戏,从早到晚,最后总算是搞出来了,其中的心酸只有自己知道.最近才有功夫闲下来,还是学习学习之前的老本行--asp.net,现在用.net做项目流行MVC,而不是之前的三层,既然技术在更新,只能不断学习,以适应新的技术潮流! 创建MVC工程 1.打开Visual studio2012,新建MVC4工程 2.选择工程属性,创建MVC工程 3.生成工程的目录 App_Start:启动文件的配置信息,包括很重要的RouteConfig路由注册信息 Conten

Swift学习笔记(12)--数组和字典的复制

Swift中,数组Array和字典Dictionary是用结构来实现的,但是数组与字典和其它结构在进行赋值或者作为参数传递给函数的时候有一些不同. 并且数组和字典的这些操作,又与Foundation中的NSArray和NSDictionary不同,它们是用类来实现的. 注意:下面的小节将会介绍数组,字典,字符串等的复制操作.这些复制操作看起来都已经发生,但是Swift只会在确实需要复制的时候才会完整复制,从而达到最优的性能. 字典的赋值和复制操作 每次将一个字典Dictionary类型赋值给一个

swift学习第五章-字典的使用

//下面是关于字典的 //字典的格式[key:value] //字典可以存放基本类型和对象类型的 //声明一个字典 var dictionary1=["key1":"鸭鸭","key2":"肉包"] var keyValueCount=dictionary1.count//获取这个字典里面键值对的个数 dictionary1["key1"]="鸡鸡"//改变对应健的值 //updateV