数组
/*:
数组(有序数据的集)
*格式 : [] / [Int]() / Array<Int>()
* let 不可变数组
* var 可变数组
注意：
* 不需要改变集合的时候创建不可变集合是很好的实践。如此 Swift 编译器可以优化我们创建的集合。
*/
// 声明数组
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]
// 初始化一个带默认值的数组
var arr8 = Array(count: 5, repeatedValue: 0)
//数组如何分配存储空间, 按照2的倍数来分配
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)
字典
/*:
字典(无序数据集)
* Swift 的Dictionary类型被桥接到Foundation的NSDictionary类。
* 格式 [:] / Dictionary<Key, Value>()
* let 不可变字典
* var 可变字典
注意：
* 一个字典的Key类型必须遵循Hashable协议
*/
// 声明字典
let dict: [String: Double]
// 初始化字典
dict = ["score": 99.9]
//dict = ["age": 30]
// 定义空字典
let dict1 = [String: Int]()
// 定义有值的字典
// [String : NSObject] 类型是做iOS开发中最最常见的类型
var dict2 = ["name": "bob", "age": 31, "score": 59.5]
// 获取
dict2["name"]
// 增加
// 只要字典中没有对应的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类进行了无缝桥接
* OC语言中的字符串也是以\0结尾, Swift不是
* OC中字符串是一个对象, Swift中使用String是一个结构体,效率更高, 支持遍历
注意
* Swift 的String类型是值类型。 如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作，或在函数/方法中传递时，会进行值拷贝。 任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值操作
*/
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中截取字符串的方法, 接收的参数和OC中不一样
// 前期, 为了大家开发方便, 建议转换为NSString之后再截取
// 转换
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))
函数
/*:
函数:
* 函数是用来完成特定任务的独立的代码块。你给一个函数起一个合适的名字，用来标识函数做什么，并且当函数需要执行的时候，这个名字会被用于“调用”函数
* 格式:
* func 函数名称(参数名:参数类型, 参数名:参数类型...) -> 函数返回值 {
函数实现部分
}
*/
/*
没有参数没有返回值
1. 可以写为 ->Void
2. 可以写为 ->()
3. 可以省略
* Void。它其实是一个空的元组（tuple），没有任何元素，可以写成()
*/
func say() -> Void {
print("hello")
}
say()
func say1() -> () {
print("hello")
}
say1()
// 推荐
func say2() {
print("hello")
}
say2()
/*:
有参数没有返回值
内部/外部参数
* 内部参数: Swift2.0以前, 默认情况下的参数都是内部参数
* Swift2.0开始, 默认将第二个参数名称作为外部参数
* 如果没有明确地指定外部参数, 那么系统默认会从第二个参数开始, 将参数的名称作为外部参数
* 外部参数只能外部用, 函数内部不能使用, 函数内部只能使用内部参数
* 忽略外部参数: 在内部参数前加_
*/
// Swift2.0之前, 默认是不会将第二个参数开始的参数名称作为外部参数的, 必须自己手动指定
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)
/*:
默认参数（Default Parameter Values）
* 格式: func method(parameter: Int = 0){}
* 当默认值被定义后，调用这个函数时可以忽略这个参数
* 其它语言的默认参数必须写在最后面, Swift可以写在任意位置
注意
* 将带有默认值的参数放在函数参数列表的最后。这样可以保证在函数调用时，非默认参数的顺序是一致的，同时使得相同的函数在不同情况下调用时显得更为清晰。
*/
func sum2(i: Int, j: Int = 10) {
print(i + j)
}
//sum2(10, j: 20)
sum2(10)
// 不推荐这样写, 最好将默认参数写在最后
func sum3(i: Int = 20, j: Int) {
print(i + j)
}
/*:
常量参数和变量参数（Constant and Variable Parameters）
* 函数参数默认是常量, 在函数内部不能修改
* 如果想在函数中修改参数, 必须在参数前加上var
注意
* 对变量参数所进行的修改在函数调用结束后便消失了，并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中
*/
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)
/*:
输入输出参数（In-Out Parameters）
* 变量参数，正如上面所述，仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）
* 定义一个输入输出参数时，在参数定义前加 inout 关键字
注意
* 输入输出参数不能有默认值，而且可变参数不能用 inout 标记。如果你用 inout 标记一个参数，这个参数不能被 var 或者 let 标记。
*/
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)
/*:
可变参数（Variadic Parameters）
* 一个可变参数可以接收零个或多个值
* 如果没有变参函数 , 并且函数的参数个数又不确定那么只能写多个方法或者用将函数参数改为集合
* 格式 func method(parameter: Int...){}
* 可变参数在函数中可以当做一个数组
注意
* 一个函数最多只能有一个可变参数
* 变参只能是同种类型的数据
* 变参必须指定数据类型
* 如果函数有一个或多个带默认值的参数，而且还有一个可变参数，那么把可变参数放在参数表的最后
*/
func sum5(numbers: Int...) {
// print(numbers)
var sum = 0
for number in numbers {
sum += number
}
print(sum)
}
sum5(1, 2, 3)
// 不推荐写法, 和默认值一样, 变参最好写在最后
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)
// 一个函数中只能有一个变参
//func sum8(numbers: Int..., values: Int...){
// print(numbers)
// print(values)
//}
// 有参数有返回值
func sum8(i: Int, j: Int) -> Int {
return i + j
}
let result = sum8(10, j: 20)
print(result)
