swift学习笔记

1、常量和变量
a、声明和定义一个常量和变量
常量用let，变量用var

let maximumNuberOfLoginAttempts = 10
var currentLoginAttempt = 0

声明多个常量和变量用逗号隔开
var x = 0.0, y = 0.0, z= 0.0

2 、类型标注

var welcomeMessage : String
这句话的意思是定义了一个String类型的变量welcomeMessage，变量名和类型中间用冒号隔开
同时定义多个同一指定类型的变量，用逗号隔开
var red, green, blue: Double

welcomeMesssage = “dont welcome you”

3、给一个常量和变量命名
基本没限制，除苹果保留关键字外，其他各种语言都可以用来命名

注意：a、不能以数字开头、有空格、数学符号、箭头、连字符、制表符
b、常量不能转为变量，变量也不能改为常量
c、常量类型不能修改

var
中国人 : String =
“Chinese"
var q =
123

4、打印当前常量和变量
print(_:)函数
print("welcom you
\(welcomeMessage)")

print("2 + 3 =
\(2+5)”)

5、注释
/*
用于注释多行/*可嵌套注释*/
*/

//用于注释单行

6、分号
一般情况都不需要以分号结尾
但是当一行要写多句的时候需要
let b =
"a"
let a =
“b";print("\(b)")

7、Integers
整形自然就没有小数部分，既包括有符号（正数、0，负数）和无符号（正数、0）
swift提供了8、16、32、64位的整数类型
let num_Int8 :Int8 = -12
let num_UInt8 :UInt8 =
21

8、整数类型范围
let minValue =
UInt8.min

let maxValue =
UInt8.max

9、 Int
•
在32位平台上，Int和Int32长度相同。
•
在64位平台上，Int和Int64长度相同。

10、 UInt
•
在32位平台上，Int和Int32长度相同。
•
在64位平台上，Int和Int64长度相同。
苹果官方建议：尽量使用Int类型，少用UInt，以提高代码的可复用性和避免不同类型数字之间的转换

11、浮点数
可存储比整数类型范围更大或更小的数字
swift提供了两种
Double ：64位浮点数，很大很精的时候用（最少15位）
Float：32位浮点数，精度要求不是很高用（最少6位）

12、类型安全和类型推断
swift是类型安全的语言
当你没有指定类型时，swift会推断出适合的类型

let inttype =
12
var doubletype =
4.2323535324342

当推断浮点数的类型时，Swift 总是会选择Double而不是Float。

12、数值型字面量
a、十进制没有前缀
b、二进制前缀0b
c、八进制前缀0o
d、十六进制前缀0x
let decimalInteger = 17
let binaryInteger = 0b10001
// 二进制的17
let octalInteger = 0o21
// 八进制的17
let hexadecimalInteger = 0x11
// 十六进制的17

如果一个十进制数的指数为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。
下面的这些浮点字面量都等于十进制的12.1875：
let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0

对于大数可以加下划线提高可读性
let oneMillion = 1_000_000

13、数值类型转换
let a1 :
UInt8 = 13
var a2 :
Int8 = 12
a2 = Int8(a1)

14、类型别名
关键字 typealias
可以给任何类型设置别名
typealias CountType =
Int

let a4 :
CountType = 32

15、布尔值
swift有两个布尔常量：true和false

16、元组
元组把多个值组合成一个复合值，可以是任何类型，并且不要求类型相同
let tuples = (404 ,"Not Found")

let element0 =
tuples.0
let element1 =
tuples.1

let (string1, num2) = ("abc" ,
123)

print(string1)

let (string,
_) = ("bcd",
232)

let http200Status = (status:
200, description : "ok")

print(http200Status.status)

17、 可选类型（optionals）
要么有指定类型的值，要么没有值

let string12 :
String = "hello"

let num1 =
string12.toInt()
num1推测为可选的int类型

18、nil
可以给一个可选的变量设置为nil
var serverResponseCode :Int? =
404
serverResponseCode = nil
但是不是可选类型的变量或者常量不能设置为nil
如果一个可选类型没有给一个初始值，将默认设置为nil
swift的nil和oc 的nil不一样
oc中nil是一个没有指向任何对象的指针
swift中nil不是一个指针，它是一个确定的值，用来表示值缺失，任何可选类型都能被设置为nil，不仅仅是对象类型

19、if语句以及强制解析

20、可选绑定
使用可选绑定（optional binding）来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。
像下面这样在if语句中写一个可选绑定：
if let constantName = someOptional {
statements
}

21、隐式解析可选类型
var temp :
String! = "abd"

temp = nil
如果你不确定变量是否一定有值，最好不要用隐式可选类型

22、错误处理
抛出异常关键字throws

do {
try canThrowAnError()
} catch {

}

func makeAsandwich() throws {

}

do {
try makeASandwich()
eatASandwich()
}catch Error.OutOfCleanDishes {
washDishes()
} catch Error.MissingIngredients(let ingredients){
buyGroceries(ingredients)
}
上面例子里，如果没有买配料那么在做三明治的时候会发生异常，将会跳到买配料里面去
然后继续，如果没有洗盘子，那么在吃三明治的时候将发生异常，将跳到洗盘子里面去

22、断言
aseert(_:_:)
两个参数，第一个判断是否为真，第二个为错误发生时的提示信息,第二个参数可缺省
例：
let age = -3
assert(age >= 0, “A person’s age cannot be less than zero”)
当age >= 0不成立，则运行时错误，程序终止
一般适用情况:
•
整数类型的下标索引被传入一个自定义下标脚本实现，但是下标索引值可能太小或者太大。
•
需要给函数传入一个值，但是非法的值可能导致函数不能正常执行。
•
一个可选值现在是nil，但是后面的代码运行需要一个非nil值。

23、字符串和字符
字符串是由一串有序的字符组成
字符：类字形单位或符号的基本信息

24、字符串字面量

let someString = "Some string literal value”
字符串字面量可以包含特殊字符
转义字符:\0 \\ \t \n \r \” \’
Unicode \u{n} 其中n为任意一到八位十六进制数

25、初始化空字符串
var emptyString = “”
var anotherEmptyString = String()

判断是否为空字符串
if emptyString.isEmpty {
print(“nothing to see here”)
}

26、 可变字符串
var variableString = “Horse”
variableString += “ and carriage”(必须是var，如果let，将报编译错误)
//variableString is now “Horse and carriage”

27、字符串是值类型
因为字符串是值类型，所以在传递时，都会对字符串进行复制传递，可以放心修改

28、字符的使用
swift1:
for character
in "abc" {
print(character)
}
swift2:
for character
in "abc".characters {
print(character)
}

let catCharacters : [Character] = ["c","a","t","!"]
let catString =
String(catCharacters)

29、计算字符串长度
count(_)

count(catString) //4

swift2: catString.characters.count

30、连接字符串和字符
连字符 ：“＋” “+=” append

let string1 = “hello”
let string2 = “there”

var welcom = string1 + string2

var string1 =
"append"
let exclamationMark :Character =
"!"
string1.append(exclamationMark)

31、字符串插值
let multiplier = 3

let message = “\(multiplier) 乘以2.5 是 \(Double(multiplier)*2.5)”

32、比较字符串
==

33、前缀／后缀相等
hasPrefix/hasSuffix

34、大写小写字符串转换
uppercaseString（转换为大写）、lowercaseString（转换为小写字符串）

35、字符串脚标
startIndex,endIndex
let greeting = “Guten tag”
greeting[greeting.startIndex]//“G”
greeting[greeting.endIndex.predecessor()]//“g”
greeting[greeting.startIndex.successor()]//“u”

36、插入和移除字符和字符串
var welcome = “hello”

welcome.insert(“!”, atIndex: welcome.endIndex)//插入字符
welcome.insert(“there”.characters, atIndex:welcome.endIndex.predecessor())//插入字符串
welcome.removeAtIndex(welcome.endIndex.predecessor())//移除字符

let range = advance(welcome.endIndex, -6)..< welcome.endIndex
welcome.removeRange(range) //删除字符串区域

37、集合类型
swift集合类型：数组（Arrays），集合（sets），字典（Dictionaries），集合的可变性（Mutability of Collections）
38、数组
用来存储同一类型的多个值，相同的值可以多次出现在一个数组的不同位置中。

39、数组的简单语法
数组形式：Array<SomeType> or [SomeType]

40、创建数组
var arr =
Array<Int>()
var shoppList: [String] = ["eggs",
“milk"]
var bookList = [String]()
var fruitList = [String](count:
3, repeatedValue:
“apple")

41、创建一个用两个数组相加
var oneArr = [Double](count:
3, repeatedValue:
2)
var twoArr = [Double](count:
3, repeatedValue:
4)
var threeArr =
oneArr + twoArr
类型必须一致

42、访问修改数组
var shoppingList = [“Eggs”, “Mild”]
计算数组元素个素：shoppingList.count

判断个数是否为0
shoppingList.isEmpty

添加新元素
shoppingList.append(“flour”)
或者追加同类型数据数组 shoppingList += [“abc”]

获取数组中的元素
var firstItem = shoppingList[0]

通过下表改变数组中的元素
shoppingList[0] = “six eggs”
shoppingList[4 … 6] = [“bananas”, “apples”]

通过下标在指定位置插入元素
shoppingList.insert(“maple syrup”, atIndex:0)

移除指定位置元素
shoppingList.removeAtIndex(0)
shoppingList.removeLast()

43、数组的遍历
for item in shoppingList {
print(item)
}

for (index, value)
in enumerate(shoppingList) {
print("item
\(String(index +
2)):\(value)")
}

44、集合
基本语法与数组一致
特性：
a.intersects(b)//a与b的交集
a.exclusiveOr(b)//a与b不相容区域
a.union(b)//a与b的并集
a.subtract(b)//a中不与b重合的区域

sorted（a）对a中元素进行排序

45、集合比较
•
使用“是否等”运算符(==)来判断两个集合是否包含相同的值。
•
使用isSubsetOf(_:)方法来判断一个集合中的值是否也被包含在另外一个集合中。
•
使用isSupersetOf(_:)方法来判断一个集合中包含的值是另一个集合中所有的值。
•
使用isStrictSubsetOf(_:)或者isStrictSupersetOf(_:)方法来判断一个集合是否是另外一个集合的子集合或者父集合并且和特定集合不相等。
•
使用isDisjointWith(_:)方法来判断两个结合是否不含有相同的值。

46、字典
var airports : [String:
String] = ["tyo" :
"tokyo", “dub":"dublin"]
var namesOfIntegers = Dictionary<Int, String>()

var emptyDic =
Dictionary<String,
String>()
emptyDic["key"] =
"value"

print(emptyDic[“key"])

emptyDic.updateValue("vlauenew", forKey:
“key”)//更新值

emptyDic.removeValueForKey(“key")

emptyDic["keynew"] = ["valuenew"]

for (key,value)
in emptyDic {
print("\(key):\(value)")
}

47、控制流
For循环
While循环
条件语句
控制转移语句

48、for循环
1、for－in用来遍历range，sequence，collection，progression
2、for条件递增（for－condition－increment）

49、for－in
for index
in 1...5 {
print(index)
}

let names = ["Anna",
"Alex", "Brian",
"Jack"]
for name
in names {
println("Hello,
\(name)!")
}
// Hello, Anna!
// Hello, Alex!
// Hello, Brian!
// Hello, Jack!

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

for var index = 0; index < 3; index ++ {
print(“index is \(index)”)
}

50、while循环

51、if语句

52、switch
let someCharacter :Character =
"e"

switch
someCharacter {
case
"a","e","i","o","u":
print("\(someCharacter) is a vowel")
case
"b":
print("\(someCharacter) is not a vowel")
default:
print("\(someCharacter) is not a vowel or a consonant")
}
不需要break结束，当匹配的case分支中的代码执行完毕后，程序会终止switch语句

53、匹配区间
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.”

54、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”

55、控制转移语句
continue,break,fallthrough,return
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.”

56、guard(swift2)
和if挺像，但是guard后面必须有else，当guard后面的判断为假时，else执行
guard let name = person[“name”] else {

}

57、检查API可用性(ios9)
if #available(iOS 9, OS X 10.10,*){

}else {

}

if #available (platform name version, …, *){

}else {

}

58、函数多参数写法
func methodName(parames1 : Dobule,…) ->Double
这个多参数表示parames是一个数组，如果是多参数类型，则最后数组时最后一个参数的类型

59、inout关键字
如果方法传进来的参数前面用inout修饰，那么里面修改了，外面的值也变了，相当于指针传递

60、使用函数类型
var mathFunction : (Int ,Int) -> Int = addTwoInts

61、函数类型也可以作为一个参数类型
func printMathResult(mathFunction: (Int, Int) -> Int, _ a : Int,_ b : Int) {
print(“Result:\(mathFunction(a,b))”)
}

62、函数类型可以作为一个返回类型

63、函数可嵌套
func chooseStepFunction(backwards :Bool)->(Int) -> Int {

func stepForward(input : Int) -> Int {return input+1}
func stepBackward(input : Int) -> Int {return input+1}
return backwards ? stepBackward : stepForward

}

64、闭包
(parametes) -> returnvalue in

65、枚举
关键字enum
enum CompassPoint {
case North
case South
case East
case West
}

enum Planet {
case Mercury, Venus, Earth, Mars, Jupiter, Saturn,Uranus, Neptune
}
var directionToHead = CompassPoint.West

directionToHead = .East

let somePlanet = Planet.Earth
switch somePlanet {
case .Earth:
print(“”)
default:
print()
}

65、枚举相关值、原始值

66、类和结构体
类和结构体共性：
a、定义属性用于存储值
b、定义方法用于提供功能
c、定义附属脚本用于访问值
d、通过扩展以增加默认实现的功能
e、符合协议已对某类提供标准功能

类的特性：
a、允许继承另一个类的特征
b、类型转换允许在运行时检查和解释一个类实例的类型
c、解构器允许一个类实例释放任何其所被分配的资源
d、引用计数允许对一个类的多次引用

66、定义
关键字class和struct来分别表示类和结构体
class SomeClass {}

struct SomeStructure {}

struct Resolution {
var width = 0
var height = 0
}

class VideoMode {
var resolution = Resolution()
var interlaced = false
var frameRate = 0.0
var name: String?
}

67、类和结构体实例
let someResolution = Resolution()
let someVideoMode = VideoMode()

68、结构体类型会自动生成一个成员逐一构造器
let vga = Resolution(width: 640, height: 480)

69、结构体和枚举是值类型
作为参数传递时，实际上操作的是其拷贝

70、类是引用类型

71、恒等运算符
＝＝＝、＝＝
＝＝＝一般用于引用类型，判断是否引用同一类实例
＝＝用语判断值是否相等

72、指针
一个swift常量或者变量引用一个引用类型的实例与c语言中的指针类似，不同的是并不直接指向内存中的某个地址，而且也不要求你使用星号＊来表明你在创建一个引用

73、类和结构体的选择
下列情况一般请考虑用结构体
a、结构体的主要目的用来封装少量相关简单数据值
b、预计一个结构体实例在赋值或传递时，封装的数据将会被拷贝而不是被引用
c、任何在结构体中存储的值类型属性，也将会被拷贝，而不是被引用
d、结构体不需要去继承另一个已存在的类型的属性或者行为

74、属性
a、存储属性（懒加载 关键字lazy）
b、计算属性
struct AlternativeRect {
var origin = Point()
var size = Size()
var center: Point {
get {
let centerX = origin.x + (size.width /
2)
let centerY = origin.y + (size.height /
2)
return Point(x: centerX, y: centerY)
}
set {
origin.x = newValue.x - (size.width / 2)
origin.y = newValue.y - (size.height / 2)
}
}
}
只读属性只实现get方法
var totolStep :Int =
0 {

willSet (newTotalSteps){
print("newTotalSteps:\(newTotalSteps)")
}
didSet {
print("total:\(totolStep) old:\(oldValue)")
}
}

75、全局变量和局部变量
注意：
全局的常量或变量都是延迟计算的，跟延迟存储属性相似，不同的地方在于，全局的常量或变量不需要标记lazy特性。
局部范围的常量或变量不会延迟计算。

76、计算属性必须给一个初始值，因为无法在类型本身初始化过程中使用构造器给类型属性赋值

77、类型属性语法:关键字static
struct SomeStructure {
static var storeTypeProperty = “Some value”
static var computedTypeProperty : Int {
//这里返回一个Int值
}
}
SomeStructure.storeTypeProperty = “abc”
78、方法:实例方法、类型方法
类、结构体、枚举均可定义实例方法

79、命名
在参数名前加一个＃则外部名和本地名一样
如果不想提供外部名，则在变量前加一个_下划线即可

80、结构体等值类型的类型中，不能在实例方法中修改变量，如果一定要修改，需要加mutating关键字修饰方法名

81、类型方法关键字class，在func前加class关键字

82、下标脚本：关键字（subscript）
subscript (index: Int) -> Int {
get {

}

set (newValue) {

}
}

83、继承
重写关键字override，访问负累属性super.someProperty
重写属性：必须将他的名字和类型都写出来，编译器才能确定重写的属性是超类中同名同类型的属性相匹配，可重写getter和setter方法，如果提供了setter方法，那么必须提供getter方法。

重写属性观察器：不可为继承来的常量存储型属性或继承来只读属性添加属性观察器

防止重写关键字：final

84、构造方法
构造方法中可以修改常量属性
都会默认生成一个构造函数
结构体会形成一个逐一成员构造器，也就是调用构造函数可以初始化结构体里的成员变量
注意：如果自己定义了一个定制的构造器，则无法访问默认构造器（如果是结构体，则无法访问逐一构造器），不过貌似写在扩展（extension）中就可以了