通常来说，编程语言教程中的第一个程序应该在屏幕上打印“Hello, world”。在 Swift 中，可以用一行代码实现：
print("Hello, world!")
如果你写过 C 或者 Objective-C 代码，那你应该很熟悉这种形式——在 Swift 中，这行代码就是一个完整的程序。你不需要为了输入输出或者字符串处理导入一个单独的库。全局作用域中的代码会被自动当做程序的入口点，所以你也不需要
main()函数。你同样不需要在每个语句结尾写上分号。这个教程会通过一系列编程例子来让你对 Swift 有初步了解，如果你有什么不理解的地方也不用担心——任何本章介绍的内容都会在后面的章节中详细讲解到。
简单值
使用 let 来声明常量，使用 var 来声明变量。一个常量的值，在编译的时候，并不需要有明确的值，但是你只能为它赋值一次。这说明你可以用一个常量来命名一个值，一次赋值就可在多个地方使用。
//标识符 常量变量函数名等
字面量 就是值
值类型（枚举（optional） 机构体(int float string array dictionary set bool)）
引用类型（类）
var myVariable = 42
myVariable = 50
let myConstant = 42
常量或者变量的类型必须和你赋给它们的值一样。然而，你不用明确地声明类型。当你通过一个值来声明变量和常量时，编译器会自动推断其类型。在上面的例子中，编译器推断出 myVariable 是一个整数类型，因为它的初始值是整数。
如果初始值没有提供足够的信息（或者没有初始值），那你需要在变量后面声明类型，用冒号分割。
let implicitInteger = 70
let implicitDouble = 70.0
let explicitDouble: Double = 70
值永远不会被隐式转换为其他类型。如果你需要把一个值转换成其他类型，请显式转换。
let label = "The width is "
let width = 94
let widthLabel = label + String(width)
有一种更简单的把值转换成字符串的方法：把值写到括号中，并且在括号之前写一个反斜杠（\）。例如：
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."
使用三个双引号（"""）来包含多行字符串内容。每行行首的缩进会被去除，只要和结尾引号的缩进相匹配。举个例子：
let quotation = """
I said "I have \(apples) apples."
And then I said "I have \(apples + oranges) pieces of fruit."
"""
使用方括号 [] 来创建数组和字典，并使用下标或者键（key）来访问元素。最后一个元素后面允许有个逗号。
var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"
var occupations = ["Malcolm": "Captain","Kaylee": "Mechanic",]
occupations["Jayne"] = "Public Relations"
数组在添加元素时会自动变大。
shoppingList.append("blue paint")
使用初始化语法来创建一个空数组或者空字典。
let emptyArray: [String] = []
let emptyDictionary: [String: Float] = [:]
如果类型信息可以被推断出来，你可以用 [] 和 [:] 来创建空数组和空字典——比如，在给变量赋新值或者给函数传参数的时候。
shoppingList = []
occupations = [:]
//你可以在一行中声明多个常量或者多个变量，用逗号隔开：
var x = 0, y = 1
//swift 是强类型语言 所以声明时要确定常量变量类型
//类型注解
var message:String = "message"
print("the message is (message)")
let maxValue = UInt64.max
//SomeType(ofInitialValue) 是调用 Swift 构造器并传入一个初始值的默认方法
var count = String(y)
let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFiveNine
//常量 three 的值被用来创建一个 Double 类型的值，所以加号两边的数类型须相同。如果不进行转换，两者无法相加
let integerPi = Int(pi)
//当用这种方式来初始化一个新的整数值时，浮点值会被截断。也就是说 4.75 会变成 4，-3.9 会变成 -3
//结合数字类常量和变量不同于结合数字类字面量。字面量 3 可以直接和字面量 0.14159 相加，因为数字字面量本身没有明确的类型
//类型别名（type aliases）就是给现有类型定义另一个名字。你可以使用 typealias 关键字来定义类型别名
typealias sap = UInt64
//元组（tuples）把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。
let httpError = (404,"Not Fond")
let http200Status = (statusCode: 200, description: "OK")
print("The status code is (http200Status.statusCode)")
//使用可选类型（optionals）来处理值可能缺失的情况。可选类型表示两种可能： 或者有值， 你可以解析可选类型访问这个值， 或者根本没有值。
let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)
// convertedNumber 被推测为类型 "Int?"， 或者类型 "optional Int"
//如果你声明一个可选常量或者变量但是没有赋值，它们会自动被设置为 nil：
//当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（!）来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的强制解析（forced unwrapping）：
if convertedNumber != nil {
print("convertedNumber has an integer value of (convertedNumber!).")
}
// 输出“convertedNumber has an integer value of 123.
//可选类型暗示了常量或者变量可以“没有值”。可选可以通过 if 语句来判断是否有值，如果有值的话可以通过可选绑定来解析值。
if let actualNumber = Int(possibleNumber) {
print("'(possibleNumber)' has an integer value of (actualNumber)")
} //Swift 语言提供数组（Array）、集合（Set）和字典（Dictionary）三种基本的集合类型用来存储集合数据。数组是有序数据的集。集合是无序无重复数据的集。字典是无序的键值对的集。
var someInts = Int//你可以使用构造语法来创建一个由特定数据类型构成的空数组：
//Swift 中的 Array 类型还提供一个可以创建特定大小并且所有数据都被默认的构造方法。可以把准备加入新数组的数据项数量（count）和适当类型的初始值（repeating）传入数组构造函数：
var threeDoubles = Array(repeating: 0.1, count: 3)
//你可以使用加法操作符（+）来组合两个已存在的相同类型数组。新数组的数据类型会从两个数组的数据类型中推断出来
var anotherThreeDoubles = Array(repeating: 2.5, count: 3)
var sixDoubles = threeDoubles + anotherThreeDoubles
//你可以使用数组字面量来进行数组构造
var shippingList :[String] = ["1"]
var shoppingList = ["Eggs", "Milk"]
if shoppingList.isEmpty {
}else{
print(shoppingList.count)
}
shoppingList.append("news")
shoppingList += ["Baking Powder"]//使用加法赋值运算符（+=）直接将另一个相同类型数组中的数据添加到该数组后面：
var firstItem = shoppingList[0]
shoppingList[1...3] = ["Bananas", "Apples"]
//通过调用数组的 insert(_:at:) 方法在某个指定索引值之前添加数据项：
shoppingList.insert("news", at: 2)
shoppingList.remove(at: 0)
for item in shoppingList {
print(item)
}
for (index,value) in shoppingList.enumerated() {
print("item (String(index+1)):(value)")
}
//集合
var letters = Set()
//用数组字面量创建集合
var favoriteGenres1:Set = ["apples"]
var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]
//字典是一种无序的集合，它存储的是键值对之间的关系，其所有键的值需要是相同的类型，所有值的类型也需要相同
var namesOfIntegers = Int:String
namesOfIntegers = [:]
//你可以使用字典字面量来构造字典，这和刚才介绍过的数组字面量拥有相似语法
var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
if airports.isEmpty {
print("The airports dictionary is empty.")
}
airports["LHR"] = "London"
airports.removeValue(forKey: "LHR")
func acept(arr:[Int])->[Int:String]{
return [1:"1"]
}
//遍历字典时，字典的每项元素会以 (key, value) 元组的形式返回，你可以在 for-in 循环中使用显式的常量名称来解读 (key, value) 元组
let numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
for (animalName, legCount) in numberOfLegs {
print("(animalName)s have (legCount) legs")
}
let minutes = 60
let minuteInterval = 5
for tickMark in stride(from: 0, to: minutes, by: minuteInterval) {
// 每5分钟渲染一个刻度线（0, 5, 10, 15 ... 45, 50, 55）
print(tickMark)
}
let anotherCharacter: Character = "a"
switch anotherCharacter {
case "a", "A":
print("The letter A")
default:
print("Not the letter A")
}
操作符
for _ in 1...four {
print("1")
}
let range = ...5
range.contains(3)
//间隔区间
for tickMark in stride(from: 1, through: 10, by: 3) {
print(tickMark)
}
var numbers = [10 ,20,-30,-40]
var sum = 0
for number in numbers where number>0 {//where过滤条件
sum+=number
}
空合运算符（a ?? b）将对可选类型 a 进行空判断，如果 a 包含一个值就进行解包，否则就返回一个默认值 b。表达式 a 必须是 Optional 类型。默认值 b 的类型必须要和 a 存储值的类型保持一致。
逻辑运算符的操作对象是逻辑布尔值。Swift 支持基于 C 语言的三个标准逻辑运算。
- 逻辑非（
!a） - 逻辑与（
a && b） - 逻辑或（
a || b）
控制流
使用 if 和 switch 来进行条件操作，使用 for-in、while 和 repeat-while 来进行循环。包裹条件和循环变量的括号可以省略，但是语句体的大括号是必须的。
let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
if score > 50 {
teamScore += 3
} else {
teamScore += 1
}
}
print(teamScore)
在 if 语句中，条件必须是一个布尔表达式——这意味着像 if score { ... } 这样的代码将报错，而不会隐形地与 0 做对比。
你可以一起使用 if 和 let 一起来处理值缺失的情况。这些值可由可选值来代表。一个可选的值是一个具体的值或者是 nil 以表示值缺失。在类型后面加一个问号（?）来标记这个变量的值是可选的。
var optionalString: String? = "Hello"
print(optionalString == nil)
var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
greeting = "Hello, \(name)"
}
如果变量的可选值是 nil，条件会判断为 false，大括号中的代码会被跳过。如果不是 nil，会将值解包并赋给 let 后面的常量，这样代码块中就可以使用这个值了。
另一种处理可选值的方法是通过使用 ?? 操作符来提供一个默认值。如果可选值缺失的话，可以使用默认值来代替。
let nickName: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickName ?? fullName)"
你还可以使用较短的代码解包一个值，并且对该被包装值使用相同的名称。
if let nickname {
print("Hey, \(nickName)")
}
switch 支持任意类型的数据以及各种比较操作——不仅仅是整数以及测试相等。
let vegetable = "red pepper"
switch vegetable {
case "celery":
print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
print("That would make a good tea sandwich.")
case let x where x.hasSuffix("pepper"):
print("Is it a spicy \(x)?")
default:
print("Everything tastes good in soup.")
}
注意 let 在上述例子的等式中是如何使用的，它将匹配等式的值赋给常量 x。
运行 switch 中匹配到的 case 语句之后，程序会退出 switch 语句，并不会继续向下运行，所以不需要在每个子句结尾写 break。
你可以使用 for-in 来遍历字典，需要一对儿变量来表示每个键值对。字典是一个无序的集合，所以他们的键和值以任意顺序迭代结束。
let interestingNumbers = [
"Prime": [2, 3, 5, 7, 11, 13],
"Fibonacci": [1, 1, 2, 3, 5, 8],
"Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (_, numbers) in interestingNumbers {
for number in numbers {
if number > largest {
largest = number
}
}
}
print(largest)
// 输出 "25"
使用 while 来重复运行一段代码直到条件改变。循环条件也可以在结尾，保证能至少循环一次。
var n = 2
while n < 100 {
n *= 2
}
print(n)
var m = 2
repeat {
m *= 2
} while m < 100
print(m)
你可以在循环中使用 `..<` 来表示下标范围。
var total = 0
for i in 0..<4 {
total += i
}
使用 ..< 创建的范围不包含上界，如果想包含的话需要使用 ...。
函数和闭包
使用 func 来声明一个函数，使用名字和参数来调用函数。使用 -> 来指定函数返回值的类型。
func greet(person: String, day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet(person:"Bob", day: "Tuesday")
默认情况下，函数使用它们的参数名称作为它们参数的标签，在参数名称前可以自定义参数标签，或者使用 _ 表示不使用参数标签。
func greet(_ person: String, on day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")
使用元组来生成复合值，比如让一个函数返回多个值。该元组的元素可以用名称或数字来获取。
func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
var min = scores[0]
var max = scores[0]
var sum = 0
for score in scores {
if score > max {
max = score
} else if score < min {
min = score
}
sum += score
}
return (min, max, sum)
}
let statistics = calculateStatistics(scores:[5, 3, 100, 3, 9])
print(statistics.sum)
print(statistics.2)
函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂的函数。
func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
returnFifteen()
函数是第一等类型，这意味着函数可以作为另一个函数的返回值。
func makeIncrementer() -> ((Int) -> Int) {
func addOne(number: Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
increment(7)
函数也可以当做参数传入另一个函数。
func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {
for item in list {
if condition(item) {
return true
}
}
return false
}
func lessThanTen(number: Int) -> Bool {
return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(list: numbers, condition: lessThanTen)
函数实际上是一种特殊的闭包:它是一段能之后被调取的代码。闭包中的代码能访问闭包作用域中的变量和函数，即使闭包是在一个不同的作用域被执行的——你已经在嵌套函数的例子中看过了。你可以使用 {} 来创建一个匿名闭包。使用 in 将参数和返回值类型的声明与闭包函数体进行分离。
numbers.map({
(number: Int) -> Int in
let result = 3 * number
return result
})
有很多种创建更简洁的闭包的方法。如果一个闭包的类型已知，比如作为一个代理的回调，你可以忽略参数，返回值，甚至两个都忽略。单个语句闭包会把它语句的值当做结果返回。
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)
你可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在圆括号后面。当一个闭包是传给函数的唯一参数，你可以完全忽略圆括号。
let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)
func greet(person:String) ->String{
let greeting = "Hello," + person + "!"
return greeting
}
func minMax(array:[Int])->(max:Int,min:Int)?{
if array.isEmpty {
return nil
}
return (array[0],array[1])
}
let bounds = minMax(array: [2,3,4])
//print(bounds.min)
if let bounds2=minMax(array: []) {
print(bounds2.min)
}
//每个函数参数都有一个参数标签（argument label）以及一个参数名称（parameter name）。参数标签在调用函数的时候使用；调用的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，函数参数使用参数名称来作为它们的参数标签
func greet(person: String = "david", from hometown: String) -> String {
return "Hello (person)! Glad you could visit from (hometown)."
}
print(greet(person: "Bill", from: "Cupertino"))
//函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。这意味着你不能错误地更改参数值。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数
func swapTwoInts(_ a:inout Int,_ b:inout Int){//intout 可变参数不能标记为inout 参数不能有默认值 本质是地址传递
let tempa = a
a = b
b = tempa
}
var someint = 3
var anotherint = 107
swapTwoInts(&someint, &anotherint)
//每个函数都有种特定的函数类型，函数的类型由函数的参数类型和返回类型组成。
func addTwoInts(_ a: Int, _ b: Int) -> Int {
return a + b
}
var mathFunction: (Int, Int) -> Int = addTwoInts
var mathFunction2 = addTwoInts
//”定义一个叫做 mathFunction 的变量，类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’，并让这个新变量指向 addTwoInts 函数”。
func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
print("Result: (mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// 打印“Result: 8”
//函数类型作为返回类型
func stepForward(_ input: Int) -> Int {
return input + 1
}
func stepBackward(_ input: Int) -> Int {
return input - 1
}
func chooseStepFunction(backward: Bool) -> (Int) -> Int {
return backward ? stepBackward : stepForward
}
//可变参数 func sum(_ numbers:Int...){
}
sum(10,20,30)
//输入输出参数
var value = 10
func change(changeValue:inout Int){
changeValue=20
}
change(changeValue: &value)//地址传递
print(value)
//闭包
let demoFunc = {(x :Int ,y :Int) ->Int in
return x+y
}
//循环引用
class Pers{
var fn :((Int)->())?
func run(){}
deinit {
print("结束")
}
}
func test() {
let p = Pers()
p.fn={
weak p in //捕获列表
p?.run()//对外层对象产生额外的强引用 导致无法释放
}
}
class Pers2{
lazy var fn :(()->())={//想在闭包内用self 必须使用lazy 因为初始化完毕才能弄self
[weak self] in
self?.run()
}
func run(){}
deinit {
print("结束")
}
}
对象和类
使用 class 和类名来创建一个类。类中属性的声明和常量、变量声明一样，唯一的区别就是它们的上下文是类。同样，方法和函数声明也一样。
class Shape {
var numberOfSides = 0
func simpleDescription() -> String {
return "A shape with \(numberOfSides) sides."
}
}
要创建一个类的实例，在类名后面加上括号。使用点语法来访问实例的属性和方法。
var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()
这个版本的 Shape 类缺少了一些重要的东西：一个构造函数来初始化类实例。使用 init 来创建一个构造器。
class NamedShape {
var numberOfSides: Int = 0
var name: String
init(name: String) {
self.name = name
}
func simpleDescription() -> String {
return "A shape with \(numberOfSides) sides."
}
}
注意 self 被用来区别实例变量 name 和构造器的参数 name。当你创建实例的时候，像传入函数参数一样给类传入构造器的参数。每个属性都需要赋值——无论是通过声明（就像 numberOfSides）还是通过构造器（就像 name）。
如果你需要在对象释放之前进行一些清理工作，使用 deinit 创建一个析构函数。
子类的定义方法是在它们的类名后面加上父类的名字，用冒号分割。创建类的时候并不需要一个标准的根类，所以你可以根据需要添加或者忽略父类。
子类如果要重写父类的方法的话，需要用 override 标记——如果没有添加 override 就重写父类方法的话编译器会报错。编译器同样会检测 override 标记的方法是否确实在父类中。
class Square: NamedShape {
var sideLength: Double
init(sideLength: Double, name: String) {
self.sideLength = sideLength
super.init(name: name)
numberOfSides = 4
}
func area() -> Double {
return sideLength * sideLength
}
override func simpleDescription() -> String {
return "A square with sides of length \(sideLength)."
}
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()
除了简单的存储属性，还有使用 getter 和 setter 的计算属性。
class EquilateralTriangle: NamedShape {
var sideLength: Double = 0.0
init(sideLength: Double, name: String) {
self.sideLength = sideLength
super.init(name: name)
numberOfSides = 3
}
var perimeter: Double {
get {
return 3.0 * sideLength
}
set {
sideLength = newValue / 3.0
}
}
override func simpleDescription() -> String {
return "An equilateral triangle with sides of length \(sideLength)."
}
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
print(triangle.perimeter)
triangle.perimeter = 9.9
print(triangle.sideLength)
//继承
class Ani{
func sp() {
}
class func speak() {
}
//重写实例属性
var radio = 0
var tab:Int{
set{
}
get{
return 10
}
}
}
class Cat: Ani {
override func sp() {
}
override class func speak() {
}
//父类的属性只能重写为计算属性 var才可以重写
override var radio: Int{
set{
super.radio=newValue
}
get{
return super.radio
}
}
//子类可以为父类属性增加属性观察器
override var tab: Int{
willSet{
}
didSet{
}
}
}
//多态 父类指针指向子类对象
var ani = Ani()
ani.sp()
ani = Cat()
ani.sp()
//栈空间 堆 代码区 全局区
在 perimeter 的 setter 中，新值的名字是 newValue。你可以在 set 之后的圆括号中显式地设置一个名字。
注意 EquilateralTriangle 类的构造器执行了三步：
设置子类声明的属性值
调用父类的构造器
改变父类定义的属性值。其他的工作比如调用方法、getters 和 setters 也可以在这个阶段完成。
如果你不需要计算属性，但是仍然需要在设置一个新值之前或者之后运行代码，使用 willSet 和 didSet。写入的代码会在属性值发生改变时调用，但不包含构造器中发生值改变的情况。比如，下面的类确保三角形的边长总是和正方形的边长相同。
class TriangleAndSquare {
var triangle: EquilateralTriangle {
willSet {
square.sideLength = newValue.sideLength
}
}
var square: Square {
willSet {
triangle.sideLength = newValue.sideLength
}
}
init(size: Double, name: String) {
square = Square(sideLength: size, name: name)
triangle = EquilateralTriangle(sideLength: size, name: name)
}
}
var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
print(triangleAndSquare.square.sideLength)
print(triangleAndSquare.triangle.sideLength)
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
print(triangleAndSquare.triangle.sideLength)
处理变量的可选值时，你可以在操作（比如方法、属性和子脚本）之前加 ?。如果 ? 之前的值是 nil，? 后面的东西都会被忽略，并且整个表达式返回 nil。否则，可选值会被解包，之后的所有代码都会按照解包后的值运行。在这两种情况下，整个表达式的值也是一个可选值。
let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength
//属性
//一个存储属性就是存储在特定类或结构体实例里的一个常量或变量 计算属性不直接存储值，而是提供一个 getter 和一个可选的 setter，来间接获取和设置其他属性或变量的值
struct Cuboid{
var width = 0.0 , height = 0.0
var volume : Double{
get{
return width*height
}
}
}
//属性观察器
class StepCount{
var totalSteps :Int = 0{
willSet{
print("totalSteps 将变为 (newValue)")
}
didSet{
print("totalSteps 之前为 (oldValue)")
}
}
}
let step = StepCount()
step.totalSteps = 200 let p = Pointlet(x: 10, y: 10)
//p=Pointlet(x: 10, y: 10) 报错 p内存不可改
//p.x=20 报错 成员也在栈空间的内存中
let s=Size(width: 10, height: 10)
//s=Size(width: 11, height: 11)报错 s内存不可改
s.width=19 //没问题 因为s没变 改变的是它指向的堆中的空间
//初始化器
class Sizeinit{
var width : Int
var height : Int
//指定初始化器
init(width:Int,height:Int) {
self.height=height
self.width=width
}
required init(){
self.width=0
self.height=0
}
init?(height:Int) {
if height<0 {
return nil
}
self.height=height
self.width=0
}
//便捷初始化器 必须包含一个指定初始化器 不能被子类调用
convenience init(width:Int){
self.init(width:width,height:0)
}
}
class Subsize: Sizeinit {
var long : Int
//如果子类没有指定初始化器 则默认继承所有父类的指定初始化器
init(width:Int,height:Int,long:Int) {
self.long=long
//子类的指定初始化器必须调用父类的指定初始化器 确保自己的属性先初始化完成再调
super.init(width: width, height: height)
//先调用父类初始化器后 才可以给继承的属性设置值
self.width=10
}
//父类的require 初始化器 必须在子类实现 且加require 修饰
required init() {
self.long=0
super.init()
}
//重写初始化器 只能重写指定的
override init(width: Int, height: Int) {
self.long=0
super.init(width: 0, height: 0)
}
}
class dein{
//类似oc的dealloc
deinit {
print("对象被销毁了")
}
func eat() {
print("")
}
}
枚举和结构体
使用 enum 来创建一个枚举。就像类和其他所有命名类型一样，枚举可以包含方法。
结构体的成员逐一构造函数 结构体是值类型传递会复制 实际上，Swift 中所有的基本类型：整数（integer）、浮点数（floating-point number）、布尔值（boolean）、字符串（string)、数组（array）和字典（dictionary），都是值类型
enum Rank: Int {
case ace = 1
case two, three, four, five, six, seven, eight, nine, ten
case jack, queen, king
func simpleDescription() -> String {
switch self {
case .ace:
return "ace"
case .jack:
return "jack"
case .queen:
return "queen"
case .king:
return "king"
default:
return String(self.rawValue)
}
}
}
let ace = Rank.ace
let aceRawValue = ace.rawValue
默认情况下，Swift 按照从 0 开始每次加 1 的方式为原始值进行赋值，不过你可以通过显式赋值进行改变。在上面的例子中，Ace 被显式赋值为 1，并且剩下的原始值会按照顺序赋值。你也可以使用字符串或者浮点数作为枚举的原始值。使用 rawValue 属性来访问一个枚举成员的原始值。
使用 init?(rawValue:) 初始化构造器来从原始值创建一个枚举实例。如果存在与原始值相应的枚举成员就返回该枚举成员，否则就返回 nil。
if let convertedRank = Rank(rawValue: 3) {
let threeDescription = convertedRank.simpleDescription()
}
枚举值是实际值，并不是原始值的另一种表达方法。实际上，如果没有比较有意义的原始值，你就不需要提供原始值。
enum Suit {
case spades, hearts, diamonds, clubs
func simpleDescription() -> String {
switch self {
case .spades:
return "spades"
case .hearts:
return "hearts"
case .diamonds:
return "diamonds"
case .clubs:
return "clubs"
}
}
}
let hearts = Suit.hearts
let heartsDescription = hearts.simpleDescription()
注意在上面的例子中用了两种方式引用 hearts 枚举成员：给 hearts 常量赋值时，枚举成员 Suit.hearts 需要用全名来引用，因为常量没有显式指定类型。在 switch 里，枚举成员使用缩写 .hearts 来引用，因为 self 的值已经是一个 suit 类型。在任何已知变量类型的情况下都可以使用缩写。
如果枚举成员的实例有原始值，那么这些值是在声明的时候就已经决定了，这意味着不同枚举实例的枚举成员总会有一个相同的原始值。当然我们也可以为枚举成员设定关联值，关联值是在创建实例时决定的。这意味着同一枚举成员不同实例的关联值可以不相同。你可以把关联值想象成枚举成员实例的存储属性。例如，考虑从服务器获取日出和日落的时间的情况。服务器会返回正常结果或者错误信息。
enum ServerResponse {
case result(String, String)
case failure(String)
}
let success = ServerResponse.result("6:00 am", "8:09 pm")
let failure = ServerResponse.failure("Out of cheese.")
switch success {
case let .result(sunrise, sunset):
print("Sunrise is at \(sunrise) and sunset is at \(sunset)")
case let .failure(message):
print("Failure... \(message)")
}
注意 ServerResponse 的值在与 switch 的分支匹配时，日升和日落时间是如何从该值中提取出来的。
使用 struct 来创建一个结构体。结构体和类有很多相同的地方，包括方法和构造器。它们之间最大的一个区别就是结构体是传值，类是传引用。
struct Card {
var rank: Rank
var suit: Suit
func simpleDescription() -> String {
return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
}
}
let threeOfSpades = Card(rank: .three, suit: .spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()
//类型属性
struct Type{
static var count:Int=0//整个程序运行过程中 只有一分内存 定义时必须有初始值 如果在类里 可用class替换static 枚举也可以定义类型属性
static func getc(){
count+1//类型方法中可以访问类型属性
}
}
Type.count
//单例
public class FileManager{
public static let shared = FileManager()
func open() {
}
}
FileManager.shared.open()
struct Pointx{
var x = 0
var y = 0
mutating func changeX(){//结构体和枚举不能再自己方法中修改属性 需加mutating
x+=1
}
//下标
subscript(index:Int)->Int{
set{
if index==0{
x=newValue
}else if index==1{
y=newValue
}
}
get{
if index==0{
return x
}else if index==1{
return y
}else{
return 0
}
}
}
}
var pointx = Pointx()
pointx[0]=1
pointx
并发性
使用 async 标记异步运行的函数
func fetchUserID(from server: String) async -> Int {
if server == "primary" {
return 97
}
return 501
}
您还可以通过在函数名前添加 `await` 来标记对异步函数的调用
func fetchUsername(from server: String) async -> String {
let userID = await fetchUserID(from: server)
if userID == 501 {
return "John Appleseed"
}
return "Guest"
}
使用 `async let` 来调用异步函数，并让其与其它异步函数并行运行。 使用 `await` 以使用该异步函数返回的值。
func connectUser(to server: String) async {
async let userID = fetchUserID(from: server)
async let username = fetchUsername(from: server)
let greeting = await "Hello \(username), user ID \(userID)"
print(greeting)
}
使用 `Task` 从同步代码中调用异步函数且不等待它们返回结果
Task {
await connectUser(to: "primary")
}
//Prints "Hello Guest, user ID 97"
协议和扩展
使用 protocol 来声明一个协议。
protocol ExampleProtocol {
var simpleDescription: String { get }
mutating func adjust()
}
类、枚举和结构体都可以遵循协议。
class SimpleClass: ExampleProtocol {
var simpleDescription: String = "A very simple class."
var anotherProperty: Int = 69105
func adjust() {
simpleDescription += " Now 100% adjusted."
}
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription
struct SimpleStructure: ExampleProtocol {
var simpleDescription: String = "A simple structure"
mutating func adjust() {
simpleDescription += " (adjusted)"
}
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription
注意声明 SimpleStructure 时候 mutating 关键字用来标记一个会修改结构体的方法。SimpleClass 的声明不需要标记任何方法，因为类中的方法通常可以修改类属性（类的性质）。
//扩展协议 可增加未声明的新方法 增加默认实现
protocol Testprotocol{
func test()
}
extension Testprotocol{
func test(){
}
func test2(){
}
}
使用 extension 来为现有的类型添加功能，比如新的方法和计算属性。你可以使用扩展让某个在别处声明的类型来遵守某个协议，这同样适用于从外部库或者框架引入的类型。
extension Int: ExampleProtocol {
var simpleDescription: String {
return "The number \(self)"
}
mutating func adjust() {
self += 42
}
}
print(7.simpleDescription)
你可以像使用其他命名类型一样使用协议名——例如，创建一个有不同类型但是都实现一个协议的对象集合。当你处理类型是协议的值时，协议外定义的方法不可用。
let protocolValue: ExampleProtocol = a
print(protocolValue.simpleDescription)
// print(protocolValue.anotherProperty) // 去掉注释可以看到错误
即使 protocolValue 变量运行时的类型是 simpleClass ，编译器还是会把它的类型当做 ExampleProtocol。这表示你不能调用在协议之外的方法或者属性。
错误处理
使用采用 Error 协议的类型来表示错误。
enum PrinterError: Error {
case outOfPaper
case noToner
case onFire
}
使用 throw 来抛出一个错误和使用 throws 来表示一个可以抛出错误的函数。如果在函数中抛出一个错误，这个函数会立刻返回并且调用该函数的代码会进行错误处理。
func send(job: Int, toPrinter printerName: String) throws -> String {
if printerName == "Never Has Toner" {
throw PrinterError.noToner
}
return "Job sent"
}
有多种方式可以用来进行错误处理。一种方式是使用 `do-catch` 。在 `do` 代码块中，使用 `try` 来标记可以抛出错误的代码。在 `catch` 代码块中，除非你另外命名，否则错误会自动命名为 `error` 。
do {
let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
print(printerResponse)
} catch {
print(error)
}
可以使用多个 catch 块来处理特定的错误。参照 switch 中的 case 风格来写 catch。
do {
let printerResponse = try send(job: 1440, toPrinter: "Gutenberg")
print(printerResponse)
} catch PrinterError.onFire {
print("I'll just put this over here, with the rest of the fire.")
} catch let printerError as PrinterError {
print("Printer error: \(printerError).")
} catch {
print(error)
}
另一种处理错误的方式使用 try? 将结果转换为可选的。如果函数抛出错误，该错误会被抛弃并且结果为 nil。否则，结果会是一个包含函数返回值的可选值。
let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler")
let printerFailure = try? send(job: 1885, toPrinter: "Never Has Toner")
使用 defer 代码块来表示在函数返回前，函数中最后执行的代码。无论函数是否会抛出错误，这段代码都将执行。使用 defer，可以把函数调用之初就要执行的代码和函数调用结束时的扫尾代码写在一起，虽然这两者的执行时机截然不同。
var fridgeIsOpen = false
let fridgeContent = ["milk", "eggs", "leftovers"]
func fridgeContains(_ food: String) -> Bool {
fridgeIsOpen = true
defer {
fridgeIsOpen = false
}
let result = fridgeContent.contains(food)
return result
}
fridgeContains("banana")
print(fridgeIsOpen)
泛型
func makeArray<Item>(repeating item: Item, numberOfTimes: Int) -> [Item] {
var result: [Item] = []
for _ in 0..<numberOfTimes {
result.append(item)
}
return result
}
makeArray(repeating: "knock", numberOfTimes: 4)
在尖括号里写一个名字来创建一个泛型函数或者类型。
你也可以创建泛型函数、方法、类、枚举和结构体。
// 重新实现 Swift 标准库中的可选类型
enum OptionalValue<Wrapped> {
case none
case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possibleInteger = .some(100)
在类型名后面使用 where 来指定对类型的一系列需求，比如，限定类型实现某一个协议，限定两个类型是相同的，或者限定某个类必须有一个特定的父类。
func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool
where T.Element: Equatable, T.Element == U.Element
{
for lhsItem in lhs {
for rhsItem in rhs {
if lhsItem == rhsItem {
return true
}
}
}
return false
}
anyCommonElements([1, 2, 3], [3])
<T: Equatable> 和 <T> ... where T: Equatable 的写法是等价的。
参考 SwiftGG
