Swift快速上手

【《Pro Swift》阅读笔记】03 - 类型

2018-01-15  本文已影响122人  Lebron_James

书籍链接:《Pro Swift》 (链接需要梯子才能打得开)。

一、很有用的初始化函数

1. repeating:count:

当我们想重复某个值时,可以使用repeating:count:

例如,在一个标题下面加上一串等号:

let heading = "This is a heading"
let underline = String(repeating: "=", count: heading.count)

// 结果
This is a heading
=================

创建10x10的空字符串二维数组:

var board = [[String]](repeating: [String](repeating: "", count: 10), count: 10)

2. 数字与字符串的转换

将数字转换成某种进制,并以字符串表示:

let str1 = String(28, radix: 16)
// str1 = "1c"

// 如果想要转换成大写
let str2 = String(28, radix: 16, uppercase: true)
// str2 = "1C"

3. 剔除数组中重复的元素

使用Set的初始化函数来快速实现,因为Set里面的元素是唯一的:

let scores = [5, 3, 6, 1, 3, 5, 3, 9]
let scoresSet = Set(scores) // 剔除重复值
let uniqueScores = Array(scoresSet)

4. 字典的容量

在我们创建一个字典的时候,如果我们确定这个字典的最小容量,我们优先使用minimumCapacity:

var dictionary = [String: String](minimumCapacity: 100)

如果不使用最小容量去创建,Swift会默认开辟一定大小的空间,在使用过程中,如果不够,再去申请更多内存,这样频繁申请的话,会一定程度的降低性能。如果我们创建的时候就告诉Swift我们最小容量,这样就能尽量保证在使用字典过程中,不会频繁地去申请更多的内存,提高程序的性能。当然,如果实际使用中超过了我们指定的最小容量,Swift还是会自动申请内存的。Swift是以2的次幂去申请内存的,例如我们这里指定最小容量是100,他会创建128的容量。

5. Enum的使用

在使用Enum的某个case时,可以省略Enum的名称,代码更简洁:

enum Color {
   case unknown, blue, green, pink, purple, red
}

struct Toy {
   let name: String
   let color: Color
}

let barbie = Toy(name: "Barbie", color: .pink)
let raceCar = Toy(name: "Lightning McQueen", color: .red)

除了Enum之外,类型属性也可以用这种方式,例如我们常用的通知:

NotificationCenter.default.addObserver(self,
                                       selector: #selector(appDidEnterBackground),
                                       name: .UIApplicationDidEnterBackground,
                                       object: nil)

二、数组

如果数组元素类型实现了Comparable协议,我们可以使用sorted()sort()来排序,sorted()返回经过排序的数组,而sort()会对原有数组进行排序。

var names = ["Taylor", "Timothy", "Tyler", "Thomas", "Tobias", "Tabitha"]
let sorted = names.sorted()


// 排序后sorted = ["Tabitha", "Taylor", "Thomas", "Timothy", "Tobias", "Tyler"]

另外还可以使用min()max()来求最小值和最大值。

let numbers = [5, 3, 1, 9, 5, 2, 7, 8]
let lowest = numbers.min()
let highest = numbers.max()

1. 添加或删除数组元素

我们经常用append()insert()remove(at:)等函数对数组元素进行操作。

其实我们还可以用++=进行添加元素:

let poppy = Dog(breed: "Poodle", age: 5)
let rusty = Dog(breed: "Labrador", age: 2)
let rover = Dog(breed: "Corgi", age: 11)
var dogs = [poppy, rusty, rover]

let beethoven = Dog(breed: "St Bernard", age: 8)
dogs += [beethoven]

如果我们想删除最后一个元素,可以使用removeLast()popLast()。但他们的不同之处在于:1) 使用removeLast()的前提是数组中至少有一个元素,否则程序会crash;2) 而popLast()则不会有问题,尽管是空数组,也不会crash。removeLast()对应有一个removeFirst(),而popLast()则没有。

2. 数组容量和是否为空

判断数组是否为空,使用更简短的isEmpty即可,不必使用array.count == 0

如果我们能确定数组要存储的元素个数,在初始化数组的时候就可以使用reserveCapacity()指定数组的容量,这样Swift就可以在内存中开辟一块连续的内存地址,尽量避免了不必要的多次开辟内存空间和移动数组元素。当然,如果后面元素个数操作了之前指定的数组容量,也是没有问题的。

reserveCapacity()的运行时间是O(n)n是数组的个数。所以我们在添加元素之前,要先调用这个方法。

3. ContiguousArray

根据苹果的官方文档:ContiguousArray总是会把它的元素存储在内存的连续区域。如果数组元素是class类型或者遵循@objc协议、或者数组不需要把桥接到NSArray、或者不需要暴露给Objective-C使用,使用ContiguousArray将会有更高的性能。

另外还说到:如果数组元素是Struct或者Enum,ArrayContiguousArray有类似的性能。可是经过测试,还是有比较大的区别的: 使用ArrayContiguousArray分辨创建包含1到1百万的的数组,并计算所有元素的和,使用Array的时间大概是0.25s,而使用ContiguousArray的时间大概是0.13s

ContiguousArray和Array的比较

三、字典

mapValues()改变key对应的value:

let cities = ["Shanghai": 24_256_800, "Karachi": 23_500_000, "Beijing": 21_516_000, "Seoul": 9_995_000];
let roundedCities = cities.mapValues { "\($0 / 1_000_000)million people" }
// roundedCities = ["Shanghai": "24million people", "Karachi": "23million people", "Beijing": "21million people", "Seoul": "9million people"]

用分组初始化函数对原有字典进行分组:

// 根据key的首字母进行分组
let groupedCities = Dictionary(grouping: cities.keys) { $0.first! }
print(groupedCities)
// ["B": ["Beijing"], "S": ["Shanghai", "Seoul"], "K": ["Karachi"]]

// 根据key的长度进行分组
let groupedCities = Dictionary(grouping: cities.keys) { $0.count }
print(groupedCities)
// [5: ["Seoul"], 7: ["Karachi", "Beijing"], 8: ["Shanghai"]]

访问某个值,并且提供一个默认值:

let person = ["name": "Taylor", "city": "Nashville"]
let name = person["name", default: "Anonymous"] // 如果"name"对应的值为空,那么变量`name`为"Anonymous"

有些同学可能会说,我用这种形式写也行:

let name = person["name"] ?? "Anonymous"

没错,但是使用person["name", default: "Anonymous"]这种形式访问键对应的值还是有好处的。如果name对应的值为空,他可以把我们提供的默认值赋给name对应的值,例如,统计favoriteTVShows数组中每个TV shows出现的次数:

var favoriteTVShows = ["Red Dwarf", "Blackadder", "Fawlty Towers", "Red Dwarf"]
var favoriteCounts = [String: Int]()
for show in favoriteTVShows {
  favoriteCounts[show, default: 0] += 1
}

四、集合

集合可以看作是没有重复元素的无序数组,性能方面比数组更高。例如,我们要检查集合和数组是否包含某个元素,集合所需的时间是O(1),而数组所需的时间是O(n),因为集合的每个元素对应一个hash值,不管有多少个元素,查询的速度都是相同的;而数组在最差的情况下,需要检查每个元素。

五、NSCountedSet

Set一样,Foundation框架中的NSCountedSet也是不能出现重复的元素,但是我们在添加元素时,如果是之前已经存在的元素,他会记录这个元素的个数。例如:

import Foundation

var spaceships = ["Serenity", "Nostromo", "Enterprise"]
spaceships += ["Voyager", "Serenity", "Star Destroyer"]
spaceships += ["Galactica", "Sulaco", "Minbari"]

let countedSet = NSCountedSet(array: spaceships)

print(countedSet.count(for: "Serenity")) // 2
print(countedSet.count(for: "Sulaco")) // 1

六、Tuple

1. tuple的类型

tuple是有类型的:

var singer = ("Taylor", "Swift") // tuple类型是(String, String)
singer = ("Taylor", "Swift", 26) // 不能再更改为(String, String, Int)

2. tuple元素的访问

如果没有给tuple的元素指定名称,可以根据元素所在的位置来访问:

var singer = ("Taylor", "Swift")
print(singer.0)

如果tuple中有包含tuple,则可以用类似0.0来访问:

var singer = (first: "Taylor", last: "Swift", address: ("555 Taylor Swift Avenue", "No, this isn't real", "Nashville"))
print(singer.2.2) // Nashville

不过,在实际使用中,最好给每个元素指定名称:

var singer = (first: "Taylor", last: "Swift")
print(singer.last)

3. closure作为tuple的元素

我们不能把方法作为tuple的元素,但是closure可以:

var singer = (first: "Taylor", last: "Swift", sing: { (lyrics: String) in
   print("\(lyrics)")
})
singer.sing("Haters gonna hate")

4. tuple作为返回值

把tuple作为函数的返回值:

func fetchWeather() -> (type: String, cloudCover: Int, high: Int, low: Int) {
   return ("Sunny", 50, 32, 26)
}

let weather = fetchWeather()
print(weather.type)

5. 可选类型的tuples

声明的时候必须写清楚类型,因为Swift无法推断:

let optionalElements: (String?, String?) = ("Taylor", nil)
let optionalTuple: (String, String)? = ("Taylor", "Swift")
let optionalBoth: (String?, String?)? = (nil, "Swift")

6. tuples之间的比较

只要两个tuples的类型相同,Swift可以支持包含多达6个元素的tuple之间的比较:

let singer = (first: "Taylor", last: "Swift")
let person = (first: "Justin", last: "Bieber")

if singer == person {
    print("Match!")
} else {
    print("No match")
}

如果类型不同,则不能比较。

7. 给Tuple设置别名

通常地,给tuple设置一个有意义的别名,能增强代码可读性,并且让代码更简洁:

typealias Name = (first: String, last: String)

七、泛型

通常我们给泛型起名字的时候,首选T,其次U,第三个是V等。

1. 泛型限制

例如,下面把类型限制为BinaryInteger

func square<T: Numeric>(_ value: T) -> T {
   return value * value
}

2. 泛型的创建

泛型的创建也很简单,注意代码中的T

struct deque<T> {

    var array = [T]()
    
    mutating func pushBack(_ obj: T) {
        array.append(obj)
    }
    
    mutating func pushFront(_ obj: T) {
        array.insert(obj, at: 0)
    }
    
    mutating func popBack() -> T? {
        return array.popLast()
    }
    
    mutating func popFront() -> T? {
        if array.isEmpty {
            return nil
        } else {
            return array.removeFirst()
        }
    }
    
}

有任何问题,欢迎大家留言!

欢迎加入我管理的Swift开发群:536353151,本群只讨论Swift相关内容。

原创文章,转载请注明出处。谢谢!

上一篇下一篇

猜你喜欢

热点阅读