swift基础知识学习

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› 移动开发›Swift 教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

用let来声明常量，用var来声明变量

声明变量：

var x = 0.0, y = 0.0, z = 0.0

var welcomeMessage: String

常量和变量的命名

你可以用任何你喜欢的字符作为常量和变量名，包括 Unicode 字符

常量与变量名不能包含数学符号，箭头，保留的（或者非法的）Unicode 码位，连线与制表符。也不能以数字开头，但是可以在常量与变量名的其他地方包含数字。

一旦你将常量或者变量声明为确定的类型，你就不能使用相同的名字再次进行声明，或者改变其存储的值的类型。同时，你也不能将常量与变量进行互转。

注意：如果你需要使用与Swift保留关键字相同的名称作为常量或者变量名，你可以使用反引号（`）将关键字包围的方式将其作为名字使用。无论如何，你应当避免使用关键字作为常量或变量名，除非你别无选择

println 输出的内容会在最后换行 (另一种函数叫print，唯一区别是在输出内容最后不会换行。)

println函数可以输出更复杂的信息。这些信息可以包含当前常量和变量的值。

Double表示64位浮点数

Float表示32位浮点数

Swift 是一个类型安全(type safe )的语言,

Swift 会使用类型推测(type inference)来选择合适的类型，编译器可以在编译代码的时候自动推测出表达式的类型。原理很简单，只要检查你赋的值即可。

数值型字面量

整数字面量可以被写作：

一个十进制数，没有前缀
一个二进制数，前缀是0b
一个八进制数，前缀是0o
一个十六进制数，前缀是0x

如果一个十进制数的指数为exp，那这个数相当于基数和$10^{exp}$的乘积：

1.25e2 表示 $1.25 × 10^{2}$，等于 125.0。
1.25e-2 表示 $1.25 × 10^{-2}$，等于 0.0125。

如果一个十六进制数的指数为exp，那这个数相当于基数和$2^{exp}$的乘积：

0xFp2 表示 $15 × 2^{2}$，等于 60.0。
0xFp-2 表示 $15 × 2^{-2}$，等于 3.75。

数值类字面量可以包括额外的格式来增强可读性。整数和浮点数都可以添加额外的零并且包含下划线，并不会影响字面量：

let paddedDouble = 000123.456
let oneMillion = 1_000_000
let justOverOneMillion = 1_000_000.000_000_1

简单类型转换

let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)

类型别名

typealias MyType = UInt16
var myMinValue : MyType = MyType.min
var myMaxValue : MyType = MyType.max

元组

//声明方式1
let http404Error = (404, "Not Found") // http404Error 的类型是 (Int, String)，值是 (404, "Not Found")

//分解元祖取值
let (statusCode,statusMsg) = http404Error

println("code:\(statusCode)");

println(statusMsg)

//取部分值
let (justNeedCode,_) = http404Error

println("justNeedCode:\(justNeedCode)")

//通过下标访问

println("\(http404Error.0) \(http404Error.1)")

//声明方式2
let http200Status = (statusCode: 200, description: "OK")

println("\(http200Status.statusCode) \(http200Status.description)")

强制解析

let possibleNumber = "123" //"123a"
let convertedNumber = possibleNumber.toInt()
// convertedNumber 被推测为类型 "Int?"，或者类型 "optional Int"

//强制解析
if (convertedNumber != nil) {
println("\(possibleNumber) has an integer value of \(convertedNumber!)")
} else {
println("\(possibleNumber) could not be converted to an integer")

}

这个惊叹号表示“我知道这个可选有值，请使用它。

注意：Swift 的nil和 Objective-C 中的nil并不一样。在 Objective-C 中，nil是一个指向不存在对象的指针。在 Swift 中，nil不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选都可以被设置为nil，不只是对象类型

隐式解析可选

var possibleString: String? = "An optional string."
println(possibleString!) // 需要惊叹号来获取值
// 输出 "An optional string."

var assumedString : String! = "An implicitly unwrapped optional string."
println(assumedString) // 不需要感叹号
// 输出 "An implicitly unwrapped optional string."

//possibleString = nil

//assumedString = nil

if (assumedString != nil) {
println(assumedString)
}
// 输出 "An implicitly unwrapped optional string."

if let definiteString = assumedString {
println(definiteString)
}

注意：如果一个变量之后可能变成nil的话请不要使用隐式解析可选。如果你需要在变量的生命周期中判断是否是nil的话，请使用普通可选类型。

断言

如果条件判断为true，代码运行会继续进行；如果条件判断为false，代码运行停止，你的应用被终止。

let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
// 因为 age < 0，所以断言会触发

数值运算

加法运算符也用于String的拼接：

"hello, " + "world" // 等于 "hello, world"

区间运算符

for index in 1...5 {
println("\(index) * 5 = \(index * 5)")
}

半闭区间

半闭区间（a..b）定义一个从a到b但不包括b的区间。之所以称为半闭区间，是因为该区间包含第一个值而不包括最后的值。

let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count {
    println("第 \(i + 1) 个人叫 \(names[i])")
}  
// 第 1 个人叫 Anna
// 第 2 个人叫 Alex
// 第 3 个人叫 Brian
// 第 4 个人叫 Jack

 字符串字面量

字符串字面量可以包含以下特殊字符：

转移特殊字符 \0 (空字符)、\\(反斜线)、\t (水平制表符)、\n (换行符)、\r (回车符)、\" (双引号)、\' (单引号)。
单字节 Unicode 标量，写成 \xnn，其中 nn 为两位十六进制数。
双字节 Unicode 标量，写成 \unnnn，其中 nnnn 为四位十六进制数。
四字节 Unicode 标量，写成 \Unnnnnnnn，其中 nnnnnnnn 为八位十六进制数。

初始化空字符串

var emptyString = ""               // 空字符串字面量
var anotherEmptyString = String()  // 初始化 String 实例
// 两个字符串均为空并等价。

字符串可变性

var variableString = "Horse"
variableString += " and carriage"  // variableString 现在为 "Horse and carriage"
let constantString = "Highlander"
constantString += " and another Highlander" // 这会报告一个编译错误(compile-time error) - 常量不可以被修改。

注意：在 Objective-C 和 Cocoa 中，您通过选择两个不同的类( NSString 和 NSMutableString )来指定该字符串是否可以被修改，Swift中的字符串是否可以修改仅通过定义的是变量还是常量来决定，实现了多种类型可变性操作的统一。

字符串是值类型

任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值。
注意：其 Cocoa 中的 NSString 不同，当您在 Cocoa 中创建了一个 NSString 实例，并将其传递给一个函数/方法，或者赋值给一个变量，您永远都是传递或赋值同一个 NSString 实例的一个引用。除非您特别要求其进行值拷贝，否则字符串不会进行赋值新副本操作。

使用字符(Characters)

遍历字符串

for character in "Dog!" {
println(character)
}

计算长度
let unusualMenagerie = "Koala ????, Snail ????, Penguin ????, Dromedary ????"println("unusualMenagerie has \(countElements(unusualMenagerie)) characters\(unusualMenagerie.utf16Count)"// prints "unusualMenagerie has 40 characters 44"

另外需要注意的是通过 countElements 返回的字符数量并不总是与包含相同字符的 NSString 的 length 属性相同。NSString 的 length 属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。为了解决这个问题，NSString 的 length 属性在被 Swift的 String 访问时会成为 utf16count。

比较字符串

如果两个字符串以同一顺序包含完全相同的字符，则认为两者字符串相等

数组(Array)

var shoppingList: String[] = ["Eggs", "Milk"]
// shoppingList 用两个元素完成初始化

等价于得益于Swift的类型推断

var shoppingList = ["Eggs", "Milk"]

使用Boolean型的isEmpty属性，可以快速检查count属性是否为0

let bookList : [String] = ["悲惨世界","我的处女地"]

println(bookList.count)

var bookList2 = ["悲惨世界","我的处女地"]

bookList2.append("我的新书")

bookList2 += ["Chocolate Spread", "Cheese", "Butter"]
//无效
//bookList2 += "Chocolate Spread"
//遍历数组
for book in bookList2
{
print(book)
}

print(bookList2[0])

print(bookList2[1...3])

print(bookList2[1..<3])
//指定位置添加
bookList2.insert("第一本书", atIndex: 0)

//指定位置删除
bookList2.removeAtIndex(0)
bookList2.removeLast()

//遍历数组
//enumerate方法对每个元素都会返回一个由索引值及对应元素值组成的元组
for(index,value) in enumerate(bookList2)
{
println("\(index) : \(value)")

}

//初始化int数组
var someInts = [Int]()
someInts += [1,2,3,4,5]
//错误必须是int类型
//someInts.append("2")

//生成若干个重复元素组成的数组的初始化函数
var threeDoubles = [Double](count: 3, repeatedValue: 1.0)

// threeDoubles类型为Double[]，值为[1.0, 1.0, 1.0]

//根据Swift的类型推断，在使用这个初始化函数的时候，不必精确说明该数组的类型，因为这能从默认值中推断出
var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)

anotherThreeDoubles.append(333)

字典（Dictionary）

//[key 1: value 1, key 2: value 2, key 3: value 3]
var airports: Dictionary<String, String> = ["TYO": "Tokyo", "DUB": "Dublin"]

var airports2 = ["TYO": "Tokyo", "DUB": "Dublin"]
//airports airports2等价

//新建
airports["LHR"] = "London"

//更新1
airports["LHR"] = "London2"

//更新2 updateValue(forKey:)函数在键不存在的时候就设置一个新值，在键存在的时候就更新该值
//updateValue(forKey:)函数在更新一个值之后，会返回原来的老值,这让你能够检测是否发生了值的更新。
var returnOldValue = airports.updateValue("china", forKey: "LHR")
println("updateValue return Old Value \(returnOldValue)")
//updateValue(forKey:)函数返回一个值的类型的可选值。例如一个值类型为String的字典，该函数返回值的类型为String?。如果更新前该键的值存在，函数返回值就是该键更新前的值，如果不存在，函数返回值就是nil：

//删除key
//从字典中删除键值对也可以使用removeValueForKey函数。如果该键值对存在，该函数就返回本删掉的值，如果不存在，就返回nil：
airports.removeValueForKey("LHR")

//遍历字典
for dic in airports{
    println(dic)
}

if let airportName = airports["DUB"] {
    println("The name of the airport is \(airportName).")
} else {
    println("That airport is not in the airports dictionary.")
}
// 输出 "The name of the airport is Dublin International."

airports["APL"] = "Apple International"
// "Apple International" 不是APL的机场，所以要删除它 airports["APL"] = nil
// APL键值对已经从字典中删除了

airports["APL"]=nil

//遍历字典
for dic in airports{
    println(dic)
}

//字典的迭代访问
for (airportCode, airportName) in airports {
println("\(airportCode): \(airportName)")
}

//生成一个空字典

var namesOfIntegers = Dictionary<Int, String>()

namesOfIntegers[16] = "sixteen"

namesOfIntegers = [:]

// namesOfIntegers又成为一个类型为Int，String的空字典

注意：实际上，Swift的数组和字典类型是通过泛型集合实现的。要获得关于泛型类型和集合的更多资料，请查看Generics。

For Loops - For循环

//如果不需要范围的值，可以用下划线替代变量名来忽略这些值:
let base = 3
let power = 10
var answer = 1
for _ in 1...power {
    answer *= base
}
println("\(base) to the power of \(power) is \(answer)")
// prints "3 to the power of 10 is 59049"

let numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
for (animalName, legCount) in numberOfLegs {
    println("\(animalName)s have \(legCount) legs")
}

var index: Int
for index = 0; index < 3; ++index {
    println("index is \(index)")
}
println("The loop statements were executed \(index) times")
// prints "The loop statements were executed 3 times"
//最后一次执行增量表达式调用了++index，把index设为3

//如果有多个匹配对象的，可以用逗号隔开
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")
}
// prints "e is a vowel"

//Range Matching - 范围匹配

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).")

// prints "There are millions and millions of stars in the Milky Way."

Tuples 元组

你可以使用元组在相同的switch语句中测试多个值。每一个元组中的元素都可以试着和范围中不同的值进行匹配。另外，用下划线（_）标示符来匹配任意可能的值。

//使用一个点坐标（x,y），用元组型(Int, Int)来表示，可以在下面的图中分类出来：
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")
}
// prints "(1, 1) is inside the box"

Value Bindings 值绑定

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

Control Transfer Statements - 控制转移语句

Swift有四个句子：

continue
break
fallthrough
return

fallthrough关键字不检查case里的条件，会直接掉入下一个case。fallthrough简单的让代码执行到下一个case（或default）的代码块中，和标准C语言的特性一样。

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)

// prints "The number 5 is a prime number, and also an integer."