一篇入门swift的学习笔记

单侧区间运算符（a.../...b）可以表达往一侧无限延伸的区间

Swift 的 String 和 Character 类型提供了一种快速且兼容 Unicode 的方式来处理代码中的文本内容, 因此可以用任何字符。有趣的是，变量或者常量命名可以采用emoji表情或者汉字。

for character in "Dog!🐶" {
    print(character)
}
// D
// o
// g
// !
// 🐶

在书中介绍了String是基于 Unicode 标量 建立的. 因此需要了解一下Unicode中的码点, utf-8等概念. 在说到 count和objective-c的length返回的值不一样, 也是由于采取的编码格式不同.

String是值类型，对于String的使用不再赘述。

1）if

if的条件必须是一个布尔表达式——这意味着像 if score { ... } 这样的直接传值的代码将报错，swift不会隐形地与 0 做对比。

let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
  // swift的if语句可以像其他编程语言的一样，格式一样
	// 可以采用之前的写法
	if (score > 50) {
    // ...
  }
	// 也可以不写括号，裸奔~
  if score > 50 {
      teamScore += 3
   } else {
       teamScore += 1
   }
}
print(teamScore)

// guard语句对比：相当于if 相反的执行
if 条件为真 {
  // 执行
}

guard 条件为真else {
  // 执行
}

// guard也可以进行可选绑定
let str : String?;
guard let value = str else {
	//解绑失败，即数据为空进入  
}

2）switch

switch 支持任意类型的数据（区间、元组…………）以及各种比较 *** 作——不仅仅是整数以及测试相等。

case还支持多个条件

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

在 Swift 中，当匹配的 case 分支中的代码执行完毕后，程序会终止 switch 语句，而不会继续执行下一个 case 分支。这也就是说，不需要在 case 分支中显式地使用 break 语句。如果需要产生case穿透，则可以在case结束后，增加fallthrough

1）函数的定义

// 定义格式
func funcName(parameters) -> returnType {
    function body
}
// 例子
func greet(person: String) -> String {
    let greeting = "Hello, " + person + "!"
    return greeting
}

这里函数的格式类似JavaScript的格式，只是多了返回值类型

2）参数列表

这里重点说明参数列表。

a）参数标签和参数名称：每个函数参数都有一个参数标签（argument label）以及一个参数名称（parameter name）。参数标签在调用函数的时候使用；调用的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，参数名称来作为它们的参数标签。

// 参数列表
func someFunction(parameterName: Int) {
    // 在函数体内，parameterName 代表参数值
}

b）如果你不希望为某个参数添加一个标签，可以使用一个下划线（_）来代替一个明确的参数标签。

func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
     // 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(1, secondParameterName: 2)

c）当然也可以类似C++使用缺省参数，即就是提供默认值

func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
    // 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 12 传入到函数体中。
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) 
// parameterWithDefault = 6
someFunction(parameterWithoutDefault: 4) 
// parameterWithDefault = 12

d）当然你还可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入（...）的方式来定义可变参数。可变参数的传入值在函数体中变为此类型的一个数组。例如，一个叫做 numbers 的 Double... 型可变参数，在函数体内可以当做一个叫 numbers 的 [Double] 型的数组常量。

func arithmeticMean(_ numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// 返回 3.0, 是这 5 个数的平均数。
arithmeticMean(3, 8.25, 18.75)
// 返回 10.0, 是这 3 个数的平均数。

e）函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数

定义一个输入输出参数时，在参数定义前加 inout 关键字，且这个值需要时变量而不是常量

当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改。

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

3）函数类型

函数类型就像是函数指针一样。实则，还是那句话"万物皆对象"。

在 Swift 中，每个函数都有种特定的函数类型，函数的类型由函数的参数类型和返回类型组成。使用函数类型就像使用其他类型一样。

func addTwoInts(_ a: Int, _ b: Int) -> Int {
    return a + b
}

func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
    return a * b
}

var mathFunction: (Int, Int) -> Int = addTwoInts

函数类型可以作为参数类型，返回值类型等。

1) 闭包简介

OC有Block，C++有lambda表达式，swift则有闭包。

闭包采用如下三种形式之一：

闭包的语法

{ (parameters) -> return type in
    statements
}

// 使用
var blockOne:(String, Int) = {(parma1:String, parma2:Int) -> void in 
                             }

// 还有很多精巧的语法
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
// 单行表达式闭包可以通过省略 return 关键字来隐式返回单行表达式的结果
reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )
// 直接通过 =，， 来顺序调用闭包的参数，以此类推。
reversedNames . namessorted(:by0 { $1 > $} ) =
// Swift 的 String 类型定义了关于大于号（>）的字符串实现，其作为一个函数接受两个 String 类型的参数并返回 Bool 类型的值
reversedNames . namessorted(:by) >//  @escaping，用来指明这个闭包是允许“逃逸”出这个函数的。

另外要注意的是闭包表达式是引用类型。

2) 逃逸闭包

当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。当你定义接受闭包作为参数的函数时，你可以在参数名之前标注 @escaping，用来指明这个闭包是允许“逃逸”出这个函数的。

var
: completionHandlers[ ()- Void> ]= [ ]func
someFunctionWithEscapingClosure (:completionHandler( @escaping )- Void> ). {
    completionHandlersappend()completionHandler}
func

3)尾随闭包
如果你需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以将闭包书写在函数圆括号之后，函数支持将其作为最后一个参数调用。在使用尾随闭包时，你不用写出它的参数标签

someFunctionThatTakesAClosure (:closure( )- Void> )// 函数体部分 {
    }
func
mySug ()// 以下是不使用尾随闭包进行函数调用 {
    someFunctionThatTakesAClosure
    (:closure// 闭包主体部分 {
        }
    )// 以下是使用尾随闭包进行函数调用

    someFunctionThatTakesAClosure
    ()// 闭包主体部分 {
        }
    }
// 枚举的定义

1）枚举

Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为原始值），则该值的类型可以是字符串、字符，或是一个整型值或浮点数。

enum
SomeEnumeration // 枚举定义放在这里 {
    // 使用 case 关键字来定义一个新的枚举成员值。
    }
// 枚举的定义例子
enum
CompassPoint case {
    case north
    case south
    case east
    } west
// 可以在一个枚举中定义一组相关的枚举成员，每一个枚举成员都可以有适当类型的关联值。
enum
Barcode case {
    upc (Int,Int ,Int ,Int )case
    qrCode (String)}
// 枚举的遍历
enum
TestEnum :CaseIterable} {
  
for
in item TestEnum .}allCases {
  
struct

2）结构体与类

定义语法：

SomeStructure // 在这里定义结构体 {
    }
class
SomeClass // 在这里定义类 {
    }
// 结构体是值类型

// 类是引用类型
// 结构体也可以当类来使用，但是不建议
// 还要很多相同点, 但是class就是定义类的, 不过多赘述struct
class

注意：

3）类的属性与方法

a）属性

swift中类的属性分为存储属性与计算属性。

存储属性就是存储在特定类或结构体实例里的一个常量或变量。

FixedLengthRange var {
    : firstValueInt let
    : lengthInt }
struct

计算属性就是不直接存储值，而是提供一个 getter 和一个可选的 setter，来间接获取和设置其他属性或变量的值。

Point var {
    = x 0.0 ,= y 0.0 }
struct
Size var {
    = width 0.0 ,= height 0.0 }
struct
Rect var {
    = origin Point ()var
    = size Size ()var
    : centerPoint get {
        let {
            = centerX . origin+x ( .size/width 2 )let
            = centerY . origin+y ( .size/height 2 )return
            Point (:x, centerX: y) centerY}
        set
        ()newCenter. {
            origin=x . newCenter-x ( .size/width 2 ).
            origin=y . newCenter-y ( .size/height 2 )}
        }
    }
static

swift还有一个类属性，类似C++的static成员。

使用关键字 class 来定义类型属性。在为类定义计算型类型属性时，可以改用关键字 struct 来支持子类对父类的实现进行重写。

SomeStructure static {
    var = storedTypeProperty "Some value." static
    var : computedTypePropertyInt return {
        1 }
    }
enum
SomeEnumeration static {
    var = storedTypeProperty "Some value." static
    var : computedTypePropertyInt return {
        6 }
    }
class
SomeClass static {
    var = storedTypeProperty "Some value." static
    var : computedTypePropertyInt return {
        27 }
    class
    var : overrideableComputedTypePropertyInt return {
        107 }
    }
self

b）方法

实例方法同普通方法一样，方法体可以使用func关键字

类方法在方法的 static 关键字之前加上关键字 class，来指定类型方法。类还可以用关键字 // 默认构造 来指定，从而允许子类重写父类该方法的实现。

1）基础说明
类的构造与析构和C++的构造与析构类似，唯一不同的可能就是在语法上不同了。
比如：全缺省构造，默认构造等等。
列出几个比较重要的构造函数语法：

init
()// 在构造函数中，如果没有明企鹅super.init()，那么系统会自动添加 {
  // 使用KVC构造时，一定要先super.init()
  }
// 参数构造
init
(:parmaterNmae ) type// 有歧义则加self {
	self
  .=xxx ; parmaterNmae}
init
?(:parmaterNmae ) type// 可能返回空，获取时为可选类型{
  }
// 必要构造
required
init (:parmaterNmae ) type} {
class

下面挨个举例：

Color let {
    , red, green: blueDouble init
    ( )// 默认构造 {
    }
    init
    (:redDouble ,: greenDouble ,: blueDouble )// 逐一成员构造器 {
    self
        .=red   self red
        .=green self green
        .=blue  } blue
    init
    (:whiteDouble )// 形参构造：同函数的参数标签一样 {
    =
        red   = white
        green = white
        blue  } white
    }
    
struct

2）构造代理
构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理，它能避免多个构造器间的代码重复。在《effective OC2.0》中也说到，在设置构造函数的时候，提供一个基础构造方法，共其他构造使用。
由于结构体以及枚举为值类型，无法继承，它们只能代理给自己的其它构造器。

Rect var {
    = origin Point ()var
    = size Size ()init
    ()} {init

    (:originPoint ,: sizeSize )self {
        .=origin self origin
        .=size } size
    init

    (:centerPoint ,: sizeSize )let {
        = originX . center-x ( .size/width 2 )let
        = originY . center-y ( .size/height 2 )self
        .init(:originPoint (:x, originX: y) originY,: size) size}
    }
 
 前提是你为子类中引入的所有新属性都提供了默认值如果子类没有定义任何指定构造器，它将自动继承父类所有的指定构造器。如果子类提供了所有父类指定构造器的实现——无论是通过规则 1 继承过来的，还是提供了自定义实现——它将自动继承父类所有的便利构造器。 

类则不同，它可以继承自其它类。这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。
针对类的构造器，有两种，就是指定构造器和便利构造器。(swift针对构造器的设计是真的够啰嗦的)。
简单总结下：
如果一个类是基类，那么构造器就和前面一样写就可以，未初始化的属性一定要初始化。
重点是不是基类的情况：
子类的指定构造器一定要先初始化自己类中的属性，然后再调用父类的指定构造器。重写同理。
便利构造器就是你可以提供简化一下参数，然后调用类中的指定构造器。
类是不继承构造器的。如果触发以下情况，会自动继承：

3）可失败构造
给构造器传入无效的形参，或缺少某种所需的外部资源，又或是不满足某种必要的条件的时候可以构造失败。

Document var {
    : nameString ?// 该构造器创建了一个 name 属性的值为 nil 的 document 实例
    init
    ()} {// 该构造器创建了一个 name 属性的值为非空字符串的 document 实例
    init
    ?(:nameString )if {
        . nameisEmptyreturn { nil } self
        .=name } name
    }
class

4）必要构造器
在类的构造器前添加 required 修饰符表明所有该类的子类都必须实现该构造器

SomeClass required {
    init ()// 构造器的实现代码 {
        }
    }
// 在子类重写父类的必要构造器时，必须在子类的构造器前也添加 required 修饰符

// 表明该构造器要求也应用于继承链后面的子类。
// 在重写父类中必要的指定构造器时，不需要添加 override 修饰符
class

SomeSubclass :SomeClass required {
    init ()// 构造器的实现代码 {
        }
    }
deinit

5）析构
析构器只适用于类类型，当一个类的实例被释放之前，析构器会被立即调用。析构器用关键字 deinit 来标示，类似于构造器要用 init 来标示。

// 执行析构过程 {
    }
class

SomeClass : NSObject var {
  : name String // 属性即将改变 {
    willSet
    } {
      
    // 属性已经改变
    didSet
    } {
      
    }
  }
// 即使设置相同的值仍会触发
// 不能同setter同时存在
// 
class

面向对象语言的三大特性之一继承，作为复用代码的一种手段，在swift中也是一样。swift和OC不一样，OC中所有的类都是都是基于NSObject的。但是Swift 中的类并不是从一个通用的基类继承而来的。如果你不为自己定义的类指定一个超类的话，这个类就会自动成为基类。
继承的基础语法：

SomeClass :SomeSuperclass // 这里是子类的定义 {
    }
// 父类

举个例子：

class
Vehicle var {
    = currentSpeed 0.0 var
    : descriptionString return {
        \( "traveling at )currentSpeed} miles per hour"
    func
    makeNoise ()// 什么也不做——因为车辆不一定会有噪音 {
        }
    }
// 子类
class
Bicycle :Vehicle var {
    = hasBasket false }
// 重写

重写

// 重写某个特性，你需要在重写定义的前面加上 override 关键字。
class
Train :Vehicle override {
    func makeNoise ()print {
        ("Choo Choo")}
    }
// 如果你在重写属性中提供了 setter，那么你也一定要提供 getter。

// 如果你不想在重写版本中的 getter 里修改继承来的属性值，
// 你可以直接通过 super.someProperty 来返回继承来的值，其中 someProperty 是你要重写的属性的名字。
// 语法

final关键字
你可以通过把方法，属性或下标标记为 final 来防止它们被重写，只需要在声明关键字前加上 final 修饰符即可（例如：final var、final func、final class func 以及 final subscript）。
任何试图对带有 final 标记的方法、属性或下标进行重写的代码，都会在编译时会报错。在类扩展中的方法，属性或下标也可以在扩展的定义里标记为 final。
可以通过在关键字 class 前添加 final 修饰符（final class）来将整个类标记为 final 。这样的类是不可被继承的，试图继承这样的类会导致编译报错。

扩展可以给一个现有的类，结构体，枚举，还有协议添加新的功能。它还拥有不需要访问被扩展类型源代码就能完成扩展的能力（即逆向建模）

extension
SomeType // 在这里给 SomeType 添加新的功能 {
  }
// 给一个类添加多个协议
extension
SomeType :SomeProtocol ,AnotherProtocol // 协议所需要的实现写在这里 {
  }
protocol

关键字protocol定义协议。

SomeProtocol // 这里是协议的定义部分 {
    }
class

使某个类遵循协议

SomeStructure :FirstProtocol ,AnotherProtocol // 这里是结构体的定义部分 {
    }
// 若是一个类拥有父类，应该将父类名放在遵循的协议名之前，以逗号分隔：

class
SomeClass :SomeSuperClass ,FirstProtocol ,AnotherProtocol // 这里是类的定义部分 {
    }
protocol

协议定义属性

SomeProtocol // 可读可写 {
var
    : mustBeSettableInt get { set } // 只读
var
    : doesNotNeedToBeSettableInt get { } }
// swift

1）基础语法
对于泛型可以类比C++的模板，C++的标准模板库STL就是泛型编程的经典。

swift的泛型语法也和模板类似——。

// 函数
func
< swapTwoValues(T>_: ainout , T_ : binout ) Tlet {
    = temporaryA = a
    a = b
    b } temporaryA
// 类
class
SomeClass <}T> {

// C++
// 函数
template ;
void swapTwoValues(T& a, T& b) {
  T tmp = a;
  a = b;
  b = tmp;
}
// 类
template ;
class SomeClass {
T _someClass;
};

由于时间关系，总结的比较草率，还有很多需要补充的地方。对于swift语言，只是对语法进行了简单的学习。其核心思想还需进一步的深入学习——实践+概念。