Swift-Objective-C到底哪家强

2016-08-22

swift出世后，人们茶余饭后就会讨论Swift和OC到底哪家强？Swift好用吗？下面主要从用法和性能方面来讨论。

语法

毫无疑问，从第一眼看到Swift。就看到了它的简洁，语法更清楚，更容易被理解。这要归结于Swift的设计，它借鉴了
很多语言（C、JavaScript、Python、Java）的优点，特别是动态语言。让你写起来更简单有趣。同时，Swift也提供了
面向对象编程。

性能

测试平台：MacMini 2.6 GHz Intel Core i5， Xcode8.2，Swift3.0

循环

循环一百万次，里面什么事也不做

swift

let oneMillion = 1000000
let startTimes = NSDate().timeIntervalSince1970 * 1000
func loop() {
	for _ in 1...oneMillion {
	
	}
}
loop()
let endTimes = NSDate().timeIntervalSince1970 * 1000
let usedTimes = endTimes - startTimes
print("loop a million times used \(usedTimes) ms")

int oneMillion = 1000000;
NSTimeInterval startTimes = [[NSDate date] timeIntervalSince1970] * 1000;
for (NSUInteger i = 0; i < oneMillion; i++){
}
NSTimeInterval endTimes = [[NSDate date] timeIntervalSince1970] * 1000;
NSTimeInterval usedTimes = endTimes - startTimes;
printf("used times %f ms", usedTimes);

用时（运行十次取平均值）
Swift： 3.62075195ms（3.333984375, 3.486083984375, 5.197998046875, 3.31982421875, 3.321044921875,
3.31982421875, 3.338134765625, 4.220947265625, 3.32177734375, 3.347900390625,）
Objective-C：2.4488037ms (2.345947, 2.363037, 2.292725, 2.596924, 2.352051,
2.587158, 2.348145, 2.649902, 2.412109, 2.540039,)

快速排序

快速排序就取10k个数，分为三种情况（正常，倒序，均值）

正常

swift

let count = 10000
let arr = Array(1...count)
let startTimes = NSDate().timeIntervalSince1970 * 1000
// *** Simple but inefficient version of quicksort ***
func quicksort<T: Comparable>(_ a: [T]) -> [T] {
    guard a.count > 1 else { return a }
    
    let pivot = a[a.count/2]
    let less = a.filter { $0 < pivot }
    let equal = a.filter { $0 == pivot }
    let greater = a.filter { $0 > pivot }
    
    // Uncomment this following line to see in detail what the
    // pivot is in each step and how the subarrays are partitioned.
    //print(pivot, less, equal, greater)  return quicksort(less) + equal + quicksort(greater)
    
    return quicksort(less) + equal + quicksort(greater)
}
quicksort(arr)
let endTimes = NSDate().timeIntervalSince1970 * 1000
let usedTimes = endTimes - startTimes
print("times used \(usedTimes) ms")

NSUInteger cap = 10000;
NSMutableArray *arr = [NSMutableArray arrayWithCapacity:cap];
for (NSUInteger i = 0; i < cap; i++) {
    NSNumber *num = [NSNumber numberWithInteger:i];
    arr[i] =num;
}
NSTimeInterval startTimes = [[NSDate date] timeIntervalSince1970] * 1000;
[self QuickSorkOC:arr Count:[arr count]];
NSTimeInterval endTimes = [[NSDate date] timeIntervalSince1970] * 1000;
NSTimeInterval usedTimes = endTimes - startTimes;
printf("used times %f ms", usedTimes);

用时（运行十次取平均值）
Swift： 201.352221ms（226.079833984375, 180.364990234375, 182.054931640625, 195.965087890625, 197.198974609375,
193.84375, 268.726806640625, 191.621826171875, 188.782958984375, 188.883056640625,）
Objective-C：1551.05075ms (1497.709961, 1507.664062, 1505.760254, 1498.334961, 1578.202148,
1499.712158, 1531.479736, 1492.811035, 1684.247070, 1714.586182)

倒序

考虑最坏的情况，数据是从大到小的。只需要把数组倒序过来

swift

1 2	var arr = Array(1...count) arr.sort(by: >)

1	arr = (NSMutableArray *)[[arr reverseObjectEnumerator] allObjects];

用时（运行十次取平均值）
Swift： 193.266601ms（184.419189453125, 255.409912109375, 189.22509765625, 198.416259765625, 190.2978515625,
181.308837890625, 187.583984375, 184.344970703125, 183.385009765625, 178.27490234375,）
Objective-C：1644.0257ms(1911.626709, 1546.142090, 1542.587158, 1929.552979, 1553.895020,
1576.763672, 1586.454102, 1558.053955, 1548.708252, 1686.473145,)

均值

swift

1 2	let count = 10000 var arr = Array(repeating: 0, count: count)

for (NSUInteger i = 0; i < cap; i++) {
    NSNumber *num = [NSNumber numberWithInteger:0];
    arr[i] = num;
}

用时（运行十次取平均值）
Swift： 16.3355224ms（13.64892578125, 21.63916015625, 15.175048828125, 21.05322265625, 17.60595703125,
13.64111328125, 17.98193359375, 13.454833984375, 14.905029296875, 14.25, ）
Objective-C： 10.8430176ms (18.000977, 10.387207, 10.093994, 10.768066, 9.725098,
10.739014, 10.843018, 12.367188, 16.007812, 10.340820, )

内存管理

Swift也是采用了自动引用计数（ARC）来管理内存，这样可以是程序员专注于核心的应用逻辑以及新的功能特性上。把内存
管理交给编译器去做。但值得注意的是，要避免循环引用造成的内存泄漏。

安全

用OC的时候，比较经常遇到的崩溃是空指针（nil、null）和数组越界。在OC中你对nil发送消息，是被允许的，它什么事情都
不会发生。而这就是得看起来并不会崩溃，但其实它隐藏着一个巨大的bug。这种bug是随机的，并且很能复现。这就造成在修复的时候
必须发大力气来寻找问题所在。
在Swift中提供了可选类型使得一个nil可选值的可能性变得非常的明确，这样你就很明白了。如果你不小心写了不明确的代码时
编译器会报错。问题就在编写的时候就修复好了，这就大大节省了修复OC指针逻辑的bug时间。

维护

历史遗留下来的问题，使得OC不得不用两个文件。如果C没有改进的话，OC也就没办法跟着改变。在OC中，优化构建的时间以及创建App的
效率就比不上Swift了。OC的两份文件系统就多了额外的工作，特别是在维护的时候，不得不来回的切换，幸好有快捷键，但也会觉得繁琐。

BTW：良好的编程规范是很重要的

好不好用？用了才知道，语言它只是个表现手法，编程思想才是最重要的。适合团队的开发工具，能够高效的工作才是首选！