并且把这个类型作为常量和变量的类型,不同类

(范围区间和跨步这三个词,中文翻译过来非常别扭。下文尽可能使用Range,Interval,Stride。)

高阶函数(Higher-order function)

  • Swift不允许隐式类型转换

  • [玩转Swift字符串]:https://www.swiftmi.com/topic/104.html

  • [Swift中数组(Array)及成员方法介绍] https://www.swiftmi.com/topic/71.html

  • [窥探 Swift 之数组与字典]http://www.cocoachina.com/swift/20151230/14802.html

  • [Swift 中枚举高级用法及实践]http://swift.gg/2015/11/20/advanced-practical-enum-examples/)

  • [初學Swift:愛恨交織的 Optional]http://www.appcoda.com.tw/swift-optional/)

  • [Swift 烧脑体操(一) - Optional 的嵌套]http://www.infoq.com/cn/articles/swift-brain-gym-optional

  • 类的属性:使用static修饰,是懒加载的,线程安全的

  • 类的构造函数:必须全部属性都初始化或有默认值,否则编译不过

  • 继承类的构造函数原则,必须先初始化好本身的属性,然后才初始化父类的属性

  • Swift中类的构造与析构

  • Swift:什么时候使用结构体和类

  • guard & defer

  • Swift:类型转换

  • 错误和异常处理

  • PROTOCOL EXTENSION

  • “错误”的使用 Swift 中的 Extension

  • 访问控制

1. 基本类型

Closuresare self-contained blocks of functionality that can be passed around and used in your code. Closures in Swift are similar to blocks in C and Objective-C and to lambdas in other programming languages.

Rangs表示整数范围的有序集合。有两种定义方法,第一种是闭合的Ranges,也就是说包含两个端点的整数。第二种是半开的。使用两个点和小于号。例如:

在数学和计算机科学中,高阶函数是至少满足下列一个条件的函数:

图片 1

1.0 常量、变量和申明

  • Swift中用let关键字申明常量
  let num = 1000

在编程中一个量被申明出来赋予初值后不再改变了,在这种情况下苹果建议我们把这些量申明成常量,这样对整个计算机资源的消耗比较小,整个程序更加的优化

  • Swift中用var关键字申明变量
  var index = 2

闭包是自包含的函数代码块,可以在代码中被传递和使用。Swift 中的闭包与 C 和 Objective-C 中的代码块(blocks)以及其他一些编程语言中的匿名函数比较相似。

var x = 1...5for i in x {println}//输出为 1 2 3 4 5x = 4..<6for i in x {println}//输出为4 5
  • 接受一个或多个函数作为输入
  • 输出一个函数

图片.png

1.1 类型推断

从上面的列子中,我们定义常量和变量的时候,并没有指定它的类型,这样的写法在编译器中并没有报错,这似乎有些不合常理。因为在OC中声明一个变量时,必须要指定它的数据类型,eg:

const int count = 8;
NSString *str = @"Objective-C";

这个是因为在声明变量的时候,不需要指定数据类型的特性依托于Swift强大的类型推断功能。
在Swift中,声明常量和变量可以通过在初始化时判断传递给它的具体值得类型,并且把这个类型作为常量和变量的类型,eg:

let count = 8 // count 会被推断为Int类型
var str = "Swift" // str会被推断为String类型

当然,Swift也支持在声明时显式地指定常量或者变量的数值类型:

var name:String = "DeveloperLY"

Closures can capture and store references to any constants and variables from the context in which they are defined. This is known asclosing overthose constants and variables. Swift handles all of the memory management of capturing for you.

在Swift内部,闭合Range被转换成半开的标准格式。如下例子:

函数式编程中,高阶函数比较常见了。

  • Swift -- 访问控制Access Control

  • 内存管理,WEAK 和 UNOWNED

  • Swift之自动引用计数

1.2 注释

有编程经验的朋友对注释肯定不会陌生,Swift中也分为单行注释和多行注释。这里面Swift的多行注释不同于其它语言,Swift支持嵌套注释。

/*
 这里是多行注释
 /*
 Swift的多行注释不同于其它语言,Swift支持嵌套注释
 */
 */

闭包可以捕获和存储其所在上下文中任意常量和变量的引用。被称为包裹常量和变量。 Swift 会为你管理在捕获过程中涉及到的所有内存操作。

 var xx = 4...6 print //输出为 4..<7

注:$0, $1, $2... 表示闭包第一个参数,第二个参数,第三个参数...。 详细可参考以撸代码的形式学习Swift-7:闭包

3.0[TOC]

1.3 控制台输出常量和变量

如果要把常量和变量在控制台中打印,则用print函数。Swift2.0开始println()print()已经整合成print()。所以这个函数是默认换行的。
print(items: Any...)是默认换行的,参数items是可变参数。

print("Hello, Swift") // 会自动换行
print("Hello, Swift", terminator: "") // 设定结束符为空字符串,不进入下一行(不换行)

你也可以对items中的参数指定分隔符和终止符,即使用另一个重载的print方法:

 print("a", "b", "c", separator: "+", terminator: "end")

打印结果:
a+b+cend

  • 注意:带有分隔符和终止符的print方法是不换行的。

Swift是采用字符串插值的方式在输出的内容中加入常量或者变量的值。eg:

let name = "DeveloperLY"
print("我的名字是(name)")

打印结果:
我的名字是DeveloperLY

Note

Don’t worry if you are not familiar with the concept of capturing. It is explained in detail below inCapturing Values.

如果你不熟悉捕获(capturing)这个概念也不用担心,你可以在值捕获章节对其进行详细了解。

Range有两个有用的属性,startIndex和endIndex。如下例:

1 sorted

根据给定的条件(一个用于比较的闭包)来对数组进行排序。

函数原型:

public func sorted(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> [Element]

let numbers = [1, 4, 2, 3]let res = numbers.sorted { $0 < $1}print(res.description)

变量和常量

2. 基本数据类型

Global and nested functions, as introduced inFunctions, are actually special cases of closures. Closures take one of three forms:

var xx = 2...5println(xx.startIndex) //输出2println(xx.endIndex) //输出为6. endIndex指的是转换为标准半开格式后的endIndex

2 map

返回一个包含对原数组每个元素进行给定闭包处理后元素的数组。(也就是每个元素进行相同处理)

函数原型:

public func map<T>(_ transform:  throws -> T) rethrows -> [T]

let arr = [1, 2, 4]let brr = arr.map { "No." + String}// brr = ["No.1", "No.2", "No.4"]

声明常量和变量

var  Name =  Value
//: Integer
var hours = 24

//: Double
var PI = 3.14

//: Bool
var swiftIsFun = true

//: String
var swift = “swift”
// tuple 元组类型,可按索引访问成员,用在函数上,可以有多个返回值,很好用
var me = (“James”, 18, "11@session.cn”)
me.0
me.1
  • Type annotation 类型注释
    通过:Type指定变量类型的形式,在Swift中叫做Type annotation。比如
var x: Int
var s: String
  • Type inference 类型推导
    Swift编译器会根据我们为变量的赋值自动推导变量的类型,这个特性,在Swift里叫做Type Inference
  • 输出常量和变量
    用 let 修饰,表示常量不可被修改
let minutes = 30

用 var 修饰,表示变量,可被修改

var fireIsHot = true

2.1 整数

Swift提供了IntUInt两种整数类型,分别表示有符号和无符号的整数类型。另外IntUInt后面可以带有数组8、16、32和64,以表示8、16、32和64位的整数。一般来说,我们并不需要指定整数的长度,使用UInt的情况也很少,在开发中使用Int类型即可。IntUInt都是可以自适应平台的类型。

在函数章节中介绍的全局和嵌套函数实际上也是特殊的闭包,闭包采取如下三种形式之一:

如第一个例子所示,Ranges经常在for in loop里面使用。

3 reduce

Returns the result of combining the elements of the sequence using the given closure.( 返回使用给定闭包组合序列元素的结果。)

函数原型:

public func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result

let crr = arr.reduce { (prevSum: Int, element: Int) in return prevSum + element} // crr = 7let drr = arr.reduce { if $0 == "" { return String } else { return $0 + " " + String }}print // drr = "1 2 4"let res2 = [3,5,8,9].reduce { (prevSum: Int, element: Int) in return prevSum + element}print // 27。 2+3+5+8+9 = 27

整数与浮点数

  • Swift编译器会根据目标编译平台,把Int或UInt转换成对应的整数类型,在64位平台上,分别使用min和max方法,来查看Int和Int64可以表达的数值范围:
Int.min   // -9223372036854775808
Int.max   // 9223372036854775807
Int64.min // -9223372036854775808
Int64.max // 9223372036854775807

let fifteenInDecimal = 15  10进制
let fifteenInHex = 0xF  16进制
let fifteenInOctal = 0o17 8进制
let fifteenInBinary = 0b1111 2进制

在数字中,使用分隔符:

let million = 1_000_000  等价于 1000000
  • Float: 最多表达6位精度的浮点数;
  • Double: 至少可以表达15位精度的浮点数;
    如不是有明确的需求,我们应该统一使用Double来定义浮点数
    在Swift里,我们使用一个整数,编译器会把它推导成Int,使用一个浮点数,编译器会把它推导成 Double
var three = 3
type(of: three) // Int.Type
var zeroPointForteen = 0.14
type(of: zeroPointForteen) // Double.Type

不同类型数字的字面值直接进行运算(类型转换格式 Double(Value))

PI = Double(three) + zeroPointForteen

2.2 浮点型

Swift提供了两种浮点数类型:FloatDoubleFloat表示32位浮点数,而Double表示64位浮点数。选择哪种类型根据业务对精度的要求。

  1. Global functions are closures that have a name and do not capture any values.

全局函数是一个有名字但不会捕获任何值的闭包

  1. Nested functions are closures that have a name and can capture values from their enclosing function.

嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包

  1. Closure expressions are unnamed closures written in a lightweight syntax that can capture values from their surrounding context.

闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包

Interval是一个表示区间的数据类型。但只能使用“在不在这个区间里”这个判断,不能用for in loop遍历区间。所以Intervals 的端点可以是浮点数。简单说,Intervals就是有start,end属性,以及contains()方法的数据类型。

4 forEach

Calls the given closure on each element in the sequence in the same order as a for-in loop.(与for-in类似)

函数原型:

public func forEach(_ body:  throws -> Void) rethrows

["Swift","OC","iOS","macOS"].forEach { print}

Swift中的字符串

Swift中,我们可以使用u{1F496}这样的方式,来表示一个unicode scalar :

图片 2

Swift里,String已经彻底不再是一个集合类型。而是一个提供了从多个维度展现一个Unicode视图的类型。你可以得到它的多个Characters,可以看到它的UTF-8
/ UTF-16 / Unicode scalar值等等
面对unicode复杂的组合规则,我们很难保证所有的集合算法都是安全并且语义正确的。为了解决这个问题,Swift中的String不是一个集合类型。

  • 理解表达字符串的view
    因为字符串看上去就一个一连串单个字符的组合。所以,Swift的开发者还是决定让这个类型用起来像一个集合类型。
    为了达到这个目的,第一个要解决的就是,如何让Swift理解字符串中的“字符集合”。为了不存在歧义,String为开发者提供了一些不同的"view"。简单来说,就是告诉String类型如何去理解字符串中的内容,它们是String的不同属性。

  • unicode scalar的编码方式划分的“view”
    unicodeScalar:按照字符串中每一个字符的unicode scalar来形成集合;
    utf8:按照字符串中每一个字符的UTF-8编码来形成集合;
    utf16:按照字符串中每一个字符的UTF-16编码来形成集合;

let cafee = "cafu{0065}u{0301}" // café
cafee.unicodeScalars.dropLast(1) // cafe  使用unicodeScalars这个view,移除最后一个元素
cafee.utf16.dropLast(1)          // cafe   使用utf16这个view,移除最后一个元素
cafee.utf8.dropLast(1)          // cafe      使用utf8这个view,移除最后一个元素 ,由于声调符需要两个UTF-8编码,因此最后一个会留意下无法识别的乱码
  • String的另外一个view:characters
    它是一个String.CharacterView类型的属性。这个“view”是按照unicode grapheme clusters计算字符串的字符个数,也就是最接近我们肉眼看到的字符的view。因此String.characters形式上就可以理解为“由我们看到的字符构成的字符数组”。
  • 获取前缀
    不建议使用 cafee[0 ..< 3] 来获取前缀,因为这样的操作的复杂度是 O(n2)的,Swift提供了一个叫做prefix(_:)的方法,它返回一个特定的CharacterView:
String(cafee.characters.prefix(3)) // Caf
  • 遍历字符串中的每一个字符
var mixStr = "Swift很有趣"
for (index, value) in mixStr.characters.enumerated() {
    print("(index): (value)")
}

⁃ 插入内容

if let index = mixStr.characters.index(of: "很") {
    mixStr.insert(contentsOf: " 3.0".characters, at: index)
    // "Swift 3.0很有趣"
}
  • 基于Range的查找和替换
if let cnIndex = mixStr.index(of: "很") {
    // 2. Replace a specific range
    mixStr.replaceSubrange(
        cnIndex ..< mixStr.endIndex,
        with: " is interesting!")
    // Swift 3.0 is interesting!
}
  • 字符串切片
let swiftView = mixStr.characters.suffix(12).dropLast()
String(swiftView) // interesting

let strViews = mixStr.characters.split(separator: " ")  //按空格分割
strViews.map(String.init)  // 将数组每个元素生成字符串对象
// ["Swift", "3.0", "is", "interesting!"]

// 通过闭包指定分割条件 :每个奇数位置的字符当成分隔符
var i = 0
let singleCharViews = mixStr.characters.split { _ in
    if i > 0 {
        i = 0
        return true
    }
    else {
        i += 1
        return false
    }
}

singleCharViews.map(String.init)  // ["S", "i", "t", "3", "0", "i", " ", "n", "e", "e", "t", "n", "!"]
  • Tuple 元组类型
    定义方式:
let success = (200, "HTTP OK")  //

不指定参数名称方式,只能通过下标访问

success.0
success.1
let me = (name: “Jams”, no: 18, email: “session.cn”) //指定参数名称方式
可以通过参数名称访问
me.name
me.no
me.email
  • Tuple Decomposition
    把一个Tuple的值,一一对应的拆分到不同的变量上
var (successCode, successMessage) = success
print(successCode) // 200
print(successMessage) // HTTP OK
修改部分值: “_”表示
let (_, errorMessage) = fileNotFound
print(errorMessage)
  • tuple 的比较:只有元素个数相同的Tuple变量之间(最多包含6个元素的Tuple变量进行比较,超过这个数量,Swift会报错)
let tuple11 = (1, 1)
let tuple12 = (1, 2)
tuple11 < tuple12 // true
  • 运算操作符
    • Swift 3不再允许浮点数取模。
      例如:8 % 2.5这样的写法在Swift 3中将会报错。如果要对浮点数取模,只能这样: 8.truncatingRemainder(dividingBy: 2.5)
    • Swift不会把数字自动转换成Bool类型。在需要Bool值的地方,你必须明确使用一个Bool变量。
    • Swift 3中不再支持自增(++)和自减(--)操作符,使用它们的前缀和后缀版本都会得到一个编译器错误。因此,需要+1/-1的时候,只能使用b += 1 / b -= 1来实现。
    • Swift特有的操作符,用来处理和Optional有关的判断
var userInput: String? = "A user input"
let value = userInput ?? "A default input"
如果opt是一个optional,当其不为Nil时,就使用optional变量自身的值,否则,就使用??后面的“默认值”
  • 闭区间
// begin...end
for index in 1...5 {
    print(index)
}
  • 半开半闭区间
// begin..<end [begin, end)
for index in 1..<5 {
    print(index)
}

2.3 布尔类型

Swift提供了一个非真即假的逻辑类型---布尔类型(Bool)。布尔类型有两个布尔常量:true 和 false。
这里需要注意的是:Swift中的布尔类型不同于OC中的BOOL类型,不再接受0代表false、0<代表true的用法。

Swift’s closure expressions have a clean, clear style, with optimizations that encourage brief, clutter-free syntax in common scenarios. These optimizations include:

例如:

5 flatMap

Returns an array containing the concatenated results of calling the given transformation with each element of this sequence.(返回一个数组,其中包含使用此序列的每个元素调用给定转换的连接结果。)

函数原型:

public func flatMap(_ transform:  throws -> String?) rethrows -> [String]

let collections = [[5, 2, 7], [4, 8], [9, 1, 3]]let flat = collections.flatMap { $0 }// [5, 2, 7, 4, 8, 9, 1, 3]

flatMap和map的区别是,对二维数组时flatMap有个降维处理,对于一位数组,两者没有明显区别

let numbersCompound = [[1,2,3],[4,5,6]]let mapped = numbersCompound.map { $0.map{ "-map" } }print // [["1-map", "2-map", "3-map"], ["4-map", "5-map", "6-map"]]let flatMapped = numbersCompound.flatMap { $0.map{ "-flatMap" } }print(flatMapped) // ["1-flatMap", "2-flatMap", "3-flatMap", "4-flatMap", "5-flatMap", "6-flatMap"]let numbers2 = [1, 2, 3, 4]let mapres = numbers2.map { Array(repeating: $0, count: $0) }// [[1], [2, 2], [3, 3, 3], [4, 4, 4, 4]]let flatMapres = numbers2.flatMap { Array(repeating: $0, count: $0) }// [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]

注:新版Swift使用了Sequence.compactMap来替代Sequence.flatMap,详细

Control Flow

  • 条件分支判断语句
switch light {
    case "red":
        action = "stop"
    case "yellow":
        action = "caution"
    case "green":
        action = "go"
    default:
        action = "invalid"
}

和C++/Java这样语言相比:

  • 每个case语句不会自动“贯通”到下一个case,因此我们也无需在每个case最后一行写break表示结束
  • 必须考虑default情况,不写编译器会报错;明确表示你考虑到了其他的情况,只是你不需要更多额外处理而已

2.4 元组类型

Swift中给我们提供了一个非常好用的数据类型---元组。它可以把多个值成员复合成一个值吗,并且这些值成员的数据类型可以不同。eg:

let info = ("DeveloperLY", 18, "iOS开发者")   // 一个包含三个成员值得元组
// 取出元组中的成员值(根据索引)
let name = info.0
let age = info.1
let job = info.2

// 我们也可以给每个成员值赋值
let info1 = (name: "DeveloperLY", age:18, job: "iOS开发者")
// 调用的时候也可以使用名称调用
let showName = info1.name
let showAge = info1.age
let showJob = info1.job
// 另外如果想忽略元组中不重要的信息时,可以把元组传递到一个新的元组中,把需要忽略的值用“_”表示忽略
let (showName, _, _) = info1
print("name is (showName)")  // "打印结果:name is DeveloperLY"

Swift 的闭包表达式拥有简洁的风格,并鼓励在常见场景中进行语法优化,主要优化如下:

var x = 1.0...6.0println(x.contains //输出trueprintln //输出1.0println //输出6.0

6 filter

Returns an array containing, in order, the elements of the sequence that satisfy the given predicate.(返回一个数组,该数组按顺序包含满足给定闭包的序列元素。)

函数原型:

public func filter(_ isIncluded:  throws -> Bool) rethrows -> [Element]

let err = arr.filter { $0 % 2 == 0}// err = [2, 4]

playground文件在andyRon/LearnSwift

循环控制语句

遍历一个集合类型或者范围
let vowel = ["a", "e", "i", "o", "u"]
for char in vowel {
    print(char)
}
// aeiou

for number in 1...10 {
    print(number)
}
// 12345678910

传统C风格的三段式for循环,已经在Swift 3中被移除
// for var i = 0; i < 10; i += 1 {
//    print(i)
// }

var i  = 0
while i < 10 {
    print(i)
    i += 1
}

// do ... while
repeat {
    print(i)
    i -= 1
} while i > 0

2.5 可选型

可选型Optionals是Swift的新特性,它允许你存储两种状态的值给Optional,变量:有效值或者nil,可选型用于某些不确定是否有值的情况,定义可选型只需在常规类型后面加一个“?”即可表示这个值是Optional
Swift要求所有的Optional属性都必须有明确的值,如果为空,则必须明确设定为nil
Optional<T>是一个枚举类型。

var someOptionalString: Optional<String> = "Optional"
var someOptionalString2: String? = "Optional" // 这句等价于上面一句,这句是推荐写法,因为它更简洁,问号(?)是Swift提供的语法糖

// 可选型不能直接使用,使用需要解包
if someOptionalString != nil {
    // 变量不为空
    if someOptionalString!.hasPrefix("Opt") {
        print("has the perfix")
    }
    let empty = someOptionalString?.isEmpty
}
someOptionalString = nil

/*
 使用(!)可以解决无法访问Optional值得运行错误。若要使用(!)强制解析,一定要确保Optional里不是nil参数
 */

// 显示解包Optional 变量
var unwrappedString: String! = "Value is expected."
var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Value is expected." // 和上面完全等价,(!)也是语法糖,推荐写法
if let someOptionalStringConstant = someOptionalString {
    // 由于变量someOptionalString 有值,不为空,所以 if 条件为真
    if !someOptionalStringConstant.hasSuffix("ok") {
        // does not have the prefix
    }
}

someOptionalString2 = nil
func fooGuard() {
    // 还有一种是先处理为空的
    guard someOptionalString2 != nil else {
        print("value is nil")
        return
    }
}
  1. Inferring parameter and return value types from context

利用上下文推断参数和返回值类型

  1. Implicit returns from single-expression closures

隐式返回单表达式闭包,即单表达式闭包可以省略return关键字

  1. Shorthand argument names

参数名称缩写

  1. Trailing closure syntax

尾随闭包语法

注意上例如果不用1.0和6.0,而用了1和6, 编译器会认为是Ranges,而没有contains方法,所以会报错的。两个端点里面只要用了一个浮点数,编译器则会正确的推断出类型。换句话说:

匹配值的方式

  • case 匹配的值 = 要检查的对象

    let origin = (x: 0, y: 0)
    if case (0, 0) = pt1 {
    print("@Origin")
    }
    用(_, 0)和(0, _)表示忽略掉_的部分,仅对tuple中某一部分的值进行匹配
    
  • 循环语句,用于控制循环条件

    let array1 = [1, 1, 2, 2, 2]
    for case 2 in array1 {
    print("found two") // Three times
    }
    
  • 把匹配的内容绑定到变量 value binding

    switch pt1 {
    case (let x, 0):
        print("((x), 0) is on x axis")
    case (0, let y):
        print("(0, (y)) is on y axis")
    default:
    break
    }
    
  • 绑定enum中的关联值

    enum Direction {
    case north, south, east, west(abbr: String)
    }
    
    let west = Direction.west(abbr: "W")
    if case .west = west {
    print(west) // west("W")
    }
    访问enum的关联值
    if case .west(let direction) = west {
    print(direction) // W
    }
    
  • 自动提取optional的值

    let skills: [String?] =
    ["Swift", nil, "PHP", "JavaScirpt", nil]
    
    打印出不为nil的元素
    for case let skill? in skills {
    print(skill) // Swift PHP JavaScript
    }
    
  • 自动绑定类型转换的结果

    let someValues: [Any] = [1, 1.0, "One"]
    for value in someValues {
        switch value {
            case let v as Int:
                print("Integer (v)")
            case let v as Double:
                print("Double (v)")
            case let v as String:
                 print("String (v)")
         default:
                print("Invalid value")
        }
    }
    // Integer 1
    // Double 1.0
    // String One
    仅仅想判断类型,而不需要知道具体内容
    for value in someValues {
        switch value {
            case is Int:
            print("Integer")
            // omit for simplicity...
        }
    }
    
  • 使用where约束条件

    for i in 1...10 where i % 2 == 0 {
        print(i)
    }
    
    搭配switch
    switch battery {
    case .normal(let percentage) where percentage <= 0.1:
        print("Almost out of power")
    case .normal(let percentage) where percentage >= 0.8:
        print("Almost fully charged")
    default:
        print("Normal battery status")
    }
    
  • 使用逗号串联条件

    switch halfPower {
    // ...
    case .fullyCharged, .outOfPower
        print("Fully charged or out of power")
    // ...
    }
    
    if case .normal(let percentage) = battery,
             case 0...0.1 = percentage {      // 要比较的值的范围是写在等号左侧,而不是 percentage =  case 0...0.1
        print("Almost out of power")
    }
    
    if嵌套
    应该这样写
    if A, B, C {
    
    }
    不应该这样写
    if A {
        if B {
            if C {
    
            }
        }
    }
    
  • tuple简化多个条件的比较

    //原始方式
    let username = "ssession.cn"
    let password = 11111111
    if username == "ssession.cn" && password == 11111111 {
        print("correct")
    }
    //更简洁的方式
    if case ("ssession.cn", 11111111) = (username, password) {
        print("correct")
    }
    

3. 基本运算符

Closure Expressions (闭包表达式)

Nested functions, as introduced inNested Functions, are a convenient means of naming and defining self-contained blocks of code as part of a larger function. However, it is sometimes useful to write shorter versions of function-like constructs without a full declaration and name. This is particularly true when you work with functions or methods that take functions as one or more of their arguments.

嵌套函数是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。当然,有时候编写小巧的没有完整定义和命名的类函数结构也是很有用处的,尤其是在你处理一些函数并需要将另外一些函数作为该函数的参数时。

Closure expressionsare a way to write inline closures in a brief, focused syntax. Closure expressions provide several syntax optimizations for writing closures in a shortened form without loss of clarity or intent. The closure expression examples below illustrate these optimizations by refining a single example of thesorted(by:)method over several iterations, each of which expresses the same functionality in a more succinct way.

闭包表达式是一种利用简洁语法构建内联闭包的方式。闭包表达式提供了一些语法优化,使得撰写闭包变得简单明了。下面闭包表达式的例子通过使用几次迭代展示了sorted(by:)方法定义和语法优化的方式。每一次迭代都用更简洁的方式描述了相同的功能。

本文由必威发布于必威-编程,转载请注明出处:并且把这个类型作为常量和变量的类型,不同类

相关阅读