數(shù)組
/*:
數(shù)組(有序數(shù)據(jù)的集)
*格式 : [] / [Int]() / Array<Int>()
* let 不可變數(shù)組
* var 可變數(shù)組
注意：
* 不需要改變集合的時候創(chuàng)建不可變集合是很好的實踐。如此 Swift 編譯器可以優(yōu)化我們創(chuàng)建的集合。
*/
// 聲明數(shù)組
let arr1: Array<Int>
// 推薦
let arr2: [Int]
arr2 = [10, 20] // 先定義再初始化
//arr2 = [30, 40]
var arr3: [Double]
arr3 = [10.1, 10.2]
arr3 = [8.1, 9.0]
// 定時的同時初始化
let arr4 = [10, 20, 30]
var arr5 = [10.1, 10.2, 10.3]
// 取值
arr5[0]
// 遍歷
for item in arr5 {
print(item)
}
// Swift中可以同時遍歷
for (index, item) in arr5.enumerate() {
print(index)
print(item)
}
// 添加
arr5.append(9.1)
// 刪除
arr5.removeAtIndex(1)
arr5
arr5.removeAll()
// 合并
var arr6 = [1, 3, 5]
var arr7 = [2, 4, 6]
//arr6 += arr7
arr6 += arr7[0..<2]
// 初始化一個帶默認(rèn)值的數(shù)組
var arr8 = Array(count: 5, repeatedValue: 0)
//數(shù)組如何分配存儲空間, 按照2的倍數(shù)來分配
var arr9 = [Int]()
arr9.capacity // 0
arr9.append(10)
arr9.capacity // 2
arr9.append(11)
arr9.capacity // 2
arr9.append(12)
arr9.capacity // 4
arr9.append(13)
arr9.capacity // 4
arr9.append(15)
字典
/*:
字典(無序數(shù)據(jù)集)
* Swift 的Dictionary類型被橋接到Foundation的NSDictionary類。
* 格式 [:] / Dictionary<Key, Value>()
* let 不可變字典
* var 可變字典
注意：
* 一個字典的Key類型必須遵循Hashable協(xié)議
*/
// 聲明字典
let dict: [String: Double]
// 初始化字典
dict = ["score": 99.9]
//dict = ["age": 30]
// 定義空字典
let dict1 = [String: Int]()
// 定義有值的字典
// [String : NSObject] 類型是做iOS開發(fā)中最最常見的類型
var dict2 = ["name": "bob", "age": 31, "score": 59.5]
// 獲取
dict2["name"]
// 增加
// 只要字典中沒有對應(yīng)的key就會新增
dict2["rank"] = 1
dict2
// 刪除
dict2.removeValueForKey("rank")
dict2
// 遍歷
for key in dict2.keys
{
print(key)
}
for value in dict2.values
{
print(value)
}
for (key, value) in dict2
{
print(key)
print(value)
}
// 合并
var dict3 = ["name": "bob", "age": 31]
var dict4 = ["rank": 1, "score": 99.9]
for (key, value) in dict4 {
dict3[key] = value
}
dict3
字符串
/*:
字符串
* Swift 的String類型與 Foundation NSString類進(jìn)行了無縫橋接
* OC語言中的字符串也是以\0結(jié)尾, Swift不是
* OC中字符串是一個對象, Swift中使用String是一個結(jié)構(gòu)體,效率更高, 支持遍歷
注意
* Swift 的String類型是值類型。 如果您創(chuàng)建了一個新的字符串，那么當(dāng)其進(jìn)行常量、變量賦值操作，或在函數(shù)/方法中傳遞時，會進(jìn)行值拷貝。 任何情況下，都會對已有字符串值創(chuàng)建新副本，并對該新副本進(jìn)行傳遞或賦值操作
*/
let str = "xnw\0bob"
for ch in str.characters {
print(ch)
}
// 拼接
var str1 = "xnw"
var str2 = "nx"
str1 += str2
str1
// 插值
let name = "bob"
let age = 25
let result = "name = \(name), age = \(age)"
// 格式化
//01.png
//02.png
//...
//10.png
for i in 0...5
{
let name = String(format: "%02d.png", arguments: [i])
print(name)
}
// 截取
let str3 = "www.baidu.com"
// 截取xnw
// 注意: Swift中截取字符串的方法, 接收的參數(shù)和OC中不一樣
// 前期, 為了大家開發(fā)方便, 建議轉(zhuǎn)換為NSString之后再截取
// 轉(zhuǎn)換
let str4 = str3 as NSString
let result2 = str4.substringFromIndex(10)
//Swift字符串中的 .startIndex ,用于獲取字符串中第一個字符的位置
//Swift字符串中的 .endIndex, 用于獲取字符串中最后一個字符串`下一位`的位置
let result3 = str3.substringFromIndex(str3.endIndex.advancedBy(-3))
let result4 = str3.substringFromIndex(str3.startIndex.advancedBy(10))
函數(shù)
/*:
函數(shù):
* 函數(shù)是用來完成特定任務(wù)的獨立的代碼塊。你給一個函數(shù)起一個合適的名字，用來標(biāo)識函數(shù)做什么，并且當(dāng)函數(shù)需要執(zhí)行的時候，這個名字會被用于“調(diào)用”函數(shù)
* 格式:
* func 函數(shù)名稱(參數(shù)名:參數(shù)類型, 參數(shù)名:參數(shù)類型...) -> 函數(shù)返回值 {
函數(shù)實現(xiàn)部分
}
*/
/*
沒有參數(shù)沒有返回值
1. 可以寫為 ->Void
2. 可以寫為 ->()
3. 可以省略
* Void。它其實是一個空的元組（tuple），沒有任何元素，可以寫成()
*/
func say() -> Void {
print("hello")
}
say()
func say1() -> () {
print("hello")
}
say1()
// 推薦
func say2() {
print("hello")
}
say2()
/*:
有參數(shù)沒有返回值
內(nèi)部/外部參數(shù)
* 內(nèi)部參數(shù): Swift2.0以前, 默認(rèn)情況下的參數(shù)都是內(nèi)部參數(shù)
* Swift2.0開始, 默認(rèn)將第二個參數(shù)名稱作為外部參數(shù)
* 如果沒有明確地指定外部參數(shù), 那么系統(tǒng)默認(rèn)會從第二個參數(shù)開始, 將參數(shù)的名稱作為外部參數(shù)
* 外部參數(shù)只能外部用, 函數(shù)內(nèi)部不能使用, 函數(shù)內(nèi)部只能使用內(nèi)部參數(shù)
* 忽略外部參數(shù): 在內(nèi)部參數(shù)前加_
*/
// Swift2.0之前, 默認(rèn)是不會將第二個參數(shù)開始的參數(shù)名稱作為外部參數(shù)的, 必須自己手動指定
func sum(i: Int, j: Int) {
print(i + j)
}
sum(10, j: 20)
func sum1(first i: Int, second j: Int) {
print(i + j)
}
sum1(first: 10, second: 20)
/*:
默認(rèn)參數(shù)（Default Parameter Values）
* 格式: func method(parameter: Int = 0){}
* 當(dāng)默認(rèn)值被定義后，調(diào)用這個函數(shù)時可以忽略這個參數(shù)
* 其它語言的默認(rèn)參數(shù)必須寫在最后面, Swift可以寫在任意位置
注意
* 將帶有默認(rèn)值的參數(shù)放在函數(shù)參數(shù)列表的最后。這樣可以保證在函數(shù)調(diào)用時，非默認(rèn)參數(shù)的順序是一致的，同時使得相同的函數(shù)在不同情況下調(diào)用時顯得更為清晰。
*/
func sum2(i: Int, j: Int = 10) {
print(i + j)
}
//sum2(10, j: 20)
sum2(10)
// 不推薦這樣寫, 最好將默認(rèn)參數(shù)寫在最后
func sum3(i: Int = 20, j: Int) {
print(i + j)
}
/*:
常量參數(shù)和變量參數(shù)（Constant and Variable Parameters）
* 函數(shù)參數(shù)默認(rèn)是常量, 在函數(shù)內(nèi)部不能修改
* 如果想在函數(shù)中修改參數(shù), 必須在參數(shù)前加上var
注意
* 對變量參數(shù)所進(jìn)行的修改在函數(shù)調(diào)用結(jié)束后便消失了，并且對于函數(shù)體外是不可見的。變量參數(shù)僅僅存在于函數(shù)調(diào)用的生命周期中
*/
func sum4(let i: Int, let j: Int) {
print(i + j)
}
sum4(10, j: 20)
var num1 = 10
var num2 = 20
//func swap(value1: Int, value2: Int){
// let temp = value1
// value1 = value2
// value2 = temp
//}
// 注意: 操作的是局部變量, 對實參沒有影響
func swap1(var value1: Int, var value2: Int){
print("交互前: value1 = \(value1), value2 = \(value2)")
let temp = value1
value1 = value2
value2 = temp
print("交互后: value1 = \(value1), value2 = \(value2)")
}
swap1(num1, value2: num2)
print(num1)
print(num2)
/*:
輸入輸出參數(shù)（In-Out Parameters）
* 變量參數(shù)，正如上面所述，僅僅能在函數(shù)體內(nèi)被更改。如果你想要一個函數(shù)可以修改參數(shù)的值，并且想要在這些修改在函數(shù)調(diào)用結(jié)束后仍然存在，那么就應(yīng)該把這個參數(shù)定義為輸入輸出參數(shù)（In-Out Parameters）
* 定義一個輸入輸出參數(shù)時，在參數(shù)定義前加 inout 關(guān)鍵字
注意
* 輸入輸出參數(shù)不能有默認(rèn)值，而且可變參數(shù)不能用 inout 標(biāo)記。如果你用 inout 標(biāo)記一個參數(shù)，這個參數(shù)不能被 var 或者 let 標(biāo)記。
*/
func swap2(inout value1: Int, inout value2: Int){
print("交互前: value1 = \(value1), value2 = \(value2)")
let temp = value1
value1 = value2
value2 = temp
print("交互后: value1 = \(value1), value2 = \(value2)")
}
swap2(&num1, value2: &num2)
print(num1)
print(num2)
/*:
可變參數(shù)（Variadic Parameters）
* 一個可變參數(shù)可以接收零個或多個值
* 如果沒有變參函數(shù) , 并且函數(shù)的參數(shù)個數(shù)又不確定那么只能寫多個方法或者用將函數(shù)參數(shù)改為集合
* 格式 func method(parameter: Int...){}
* 可變參數(shù)在函數(shù)中可以當(dāng)做一個數(shù)組
注意
* 一個函數(shù)最多只能有一個可變參數(shù)
* 變參只能是同種類型的數(shù)據(jù)
* 變參必須指定數(shù)據(jù)類型
* 如果函數(shù)有一個或多個帶默認(rèn)值的參數(shù)，而且還有一個可變參數(shù)，那么把可變參數(shù)放在參數(shù)表的最后
*/
func sum5(numbers: Int...) {
// print(numbers)
var sum = 0
for number in numbers {
sum += number
}
print(sum)
}
sum5(1, 2, 3)
// 不推薦寫法, 和默認(rèn)值一樣, 變參最好寫在最后
func sum6(numbers: Int..., var sum: Int) {
// print(numbers)
for number in numbers {
sum += number
}
print(sum)
}
sum6(1, 2, 3, sum: 0)
// 推薦寫法
func sum7(var sum: Int = 100, numbers: Int...) {
// print(numbers)
for number in numbers {
sum += number
}
print(sum)
}
sum7(numbers: 1, 2, 3)
// 一個函數(shù)中只能有一個變參
//func sum8(numbers: Int..., values: Int...){
// print(numbers)
// print(values)
//}
// 有參數(shù)有返回值
func sum8(i: Int, j: Int) -> Int {
return i + j
}
let result = sum8(10, j: 20)
print(result)
