tingxins

iOS 主题/皮肤之 SakuraKit

Sun, 27 Aug 2017 14:30:00 +0000

前言

目前市场上很多 App 都有主题变更、皮肤切换的功能。随着项目代码量的不断增长，业务不断完善，功能性代码逐渐趋于模块化，尤其是在多人协作开发同一个项目时，模块解耦尤为重要，同时，公共基础库的功能性代码使用越简单越好。

前段时间在维护旧项目时，收到 App 主题变更、皮肤切换的需求，其包括 App 中各种图标、色值、文字、字体等都包括在内，都需实现主题化。主要用于：

活动主题展示：比较典型的是类似京东618、天猫淘宝购物节主题变更。
用户夜间模式：类似阅读相关 App 的夜间模式，如：简书等。
用户主题变更：用户可通过本地或者远程下载喜欢的主题，如：网易云音乐、QQ 音乐等 App 主题变更。

由于老项目代码比较混乱，功能模块耦合严重以及开发时间等综合因素，在实现 App 主题变更、皮肤切换的功能的同时，想要在尽量不修改旧代码的基础上增加新的功能是比较麻烦的。

由于没有合适的第三方库，于是自己手撸了一个库 SakuraKit，并开源，希望能帮到需要的朋友。

下面我们开始介绍 SakuraKit 及快速入门。

SakuraKit

SakuraKit，是一个轻量级的、专门用于 App 主题变更、皮肤切换的开源库（灵感源自 SwiftTheme、DKNightVersion等），采用函数式 + 链式的编码方式，简单实用、方便理解、利于维护。

快速入门

效果

在体验前，我们先来看看效果图：

体验

下面以 UIButton 为例，介绍如何使用 SakuraKit 进行主题化：

UIButton *button = [[UIButton alloc] initWithFrame:CGRectMake(100, 100, 100, 100)];
    
button.sakura
.backgroundColor(@"Home.buttonBackgroundColor")
.titleColor(@"Home.buttonTitleColor", UIControlStateNormal);

上述代码是给一个 button 的背景色（backgroundColor）以及标题颜色（titleColor）进行主题化。其中 Home.buttonBackgroundColor 与 Home.buttonTitleColor 属配置文件中的 KeyPath，配置文件的功能有点类似语言本地化文件（Localizable.strings）。后文会重点介绍如何设置配置文件。

到此为止，我们已经实现了 button 按钮主题化功能，如果你想切换主题，可以调用如下 API：


+ (BOOL)shiftSakuraWithName:(TXSakuraName *)name type:(TXSakuraType)type;

其中 name 参数代表主题的名称，type 参数代表主题类型（目前有两种：沙盒和本地）。

现在我们再具体的介绍一下如何使用 SakuraKit。

配置文件

做过 App 语言本地化的童鞋，应该比较熟悉 Localizable.strings 文件配置，同理，我们在使用 SakuraKit 对 App 进行主题化时，也需要进行类似的配置。目前支持 .json 和 .plist 两种文件格式。

下面我们以 .json 文件格式做示例：

{
	"Home":{
            "buttonBackgroundColor":"#BB503D",
            "buttonTitleColor":"#4AF2A1"
        }
}

在上述体验代码中，我们看到这样的字符串：Home.buttonBackgroundColor 和 Home.buttonTitleColor，这其实就是配置文件中字典的 KeyPath，通过 KeyPath 可以取得不同主题下的值，如：色值、图片名称、文字、字体大小等等。

注意事项：

每个主题都有自己配置文件，包括本地和沙盒主题。（本地主题名叫 default）。
主题名称与配置文件名称一致，如：某个主题名叫 fish，那么该主题相应的配置文件就应命名为fish.json。（建议遵守该约定）
不同本地主题的切图命名要做区分，不同远程主题的切图命名应一致。

本地主题

本地主题，即用户无需下载的主题，在 App Bundle 中。除了 App 本身自带的默认主题外，SakuraKit 还能够为 App 新增多种本地主题。

配置步骤如下：

步骤一

新建 .json 配置文件，比如新建一个名叫 typewriter 的主题，因此配置文件命名为 typewriter.json。

步骤二

配置一套切图，并且命名与已有的主题要做区分。

步骤三

完成上述步骤后，在 AppDelegate 中 -application:application didFinishLaunchingWithOptions:launchOptions API 注册所有本地主题：

// 注意：本地默认主题无需注册
[TXSakuraManager registerLocalSakuraWithNames:@[@"typewriter"]];

步骤四

调用切换主题 API 即可切换至该指定主题：

[TXSakuraManager shiftSakuraWithName:@"typewriter" type:TXSakuraTypeMainBundle];
    

远程主题

远程主题（资源压缩包.zip），即用户通过网络下载的主题，后台可动态配置。同本地主题一致，分为两部分：配置文件 + 切图。当配置文件和切图都弄好后，将文件夹打包成zip文件，传给后台即可。主题数据格式如下（仅供参考）：

{
    "name": "嘻多猴",
    "sakuraName": "monkey",
    "url": "http:\\image.tingxins.cn\sakura\monkey.zip"
}

sakuraName 是切换主题时用的名称，而 url 是该主题的下载地址。（注：如果 sakuraName 字段传空，那么主题的名称将默认为下载的压缩包名称）

当远程主题下载完毕后，可以这样切换主题：


[TXSakuraManager shiftSakuraWithName:sakuraName type:TXSakuraTypeSandBox];

值得一提的是，SakuraKit 提供了一些主题下载的简单接口，支持多种主题同时下载等操作，并且支持 Block 和 Delegate 两种方式的回调，同时用户还可自定义下载操作。

下面我们来依次介绍一下主题下载。

Block 方式

我们直接来介绍 API ：

[[TXSakuraManager manager] tx_sakuraDownloadWithInfos:sakuraModel downloadProgressHandler:^(int64_t bytesWritten, int64_t totalBytesWritten, int64_t totalBytesExpectedToWrite) {
    // 下载进度回调
} downloadErrorHandler:^(NSError * _Nullable error) {
    // 下载过程出现错误回调
} unzipProgressHandler:^(unsigned long long loaded, unsigned long long total) {
    // 主题下载完成后，解压进度回调
} completedHandler:^(id<TXSakuraDownloadProtocol> _Nullable infos, NSURL * _Nullable location) {
    // 主题包解压完毕回调
} ];

其中 sakuraModel 模型数据遵守了 TXSakuraDownloadProtocol 协议，具体使用详见 SakuraDemo_OC，在 DownloadSakuraController 控制器演示了该操作。

Delegate 方式

步骤一

直接调用 API 实现主题下载：

[[TXSakuraManager manager] tx_sakuraDownloadWithInfos:sakuraModel delegate:self];

步骤二

如果针对步骤一的下载操作需要回调，那么可以选择性的再实现以下方法：

// 重复点击下载某一主题，如果该主题已经处于下载中或者本地存在时将会回调，其中 status 标识该 downloadTask 状态。
- (void)sakuraManagerDownload:(TXSakuraManager *)manager
                 downloadTask:(NSURLSessionDownloadTask *)downloadTask
                       status:(TXSakuraDownloadTaskStatus)status;

// 主题下载完毕时回调，其中 infos 包括主题名称，可通过该参数直接切换至该主题
- (void)sakuraManagerDownload:(TXSakuraManager *)manager
                 downloadTask:(NSURLSessionDownloadTask *)downloadTask
                  sakuraInfos:(id<TXSakuraDownloadProtocol>)infos
    didFinishDownloadingToURL:(NSURL *)location;

// 主题下载进度
- (void)sakuraManagerDownload:(TXSakuraManager *)manager
                downloadTask:(NSURLSessionDownloadTask *)downloadTask
                didWriteData:(int64_t)bytesWritten
           totalBytesWritten:(int64_t)totalBytesWritten
   totalBytesExpectedToWrite:(int64_t)totalBytesExpectedToWrite;

/** Reserved for future use */
- (void)sakuraManagerDownload:(TXSakuraManager *)manager
                downloadTask:(NSURLSessionDownloadTask *)downloadTask
           didResumeAtOffset:(int64_t)fileOffset
          expectedTotalBytes:(int64_t)expectedTotalBytes;

// 下载操作出现错误时回调
- (void)sakuraManagerDownload:(TXSakuraManager *)manager
                 sessionTask:(NSURLSessionTask *)downloadTask
        didCompleteWithError:(nullable NSError *)error;

// 主题下载包解压进度回调
- (void)sakuraManagerDownload:(TXSakuraManager *)manager
                 downloadTask:(NSURLSessionDownloadTask *)downloadTask
                progressEvent:(unsigned long long)loaded
                        total:(unsigned long long)total;

具体使用详见 SakuraDemo_OC，在 AppDelegate 中演示了该操作。

自定义下载操作

除了上述自带的下载操作外，SakuraKit 还提供了自定义下载操作相关的 API ：

// sakuraModel 模型数据遵守了 TXSakuraDownloadProtocol 协议，location 即自定义下载下来的主题包地址。
[[TXSakuraManager manager] tx_generatePathWithInfos:sakuraModel downloadFileLocalURL:location successHandler:^(NSString *toFilePath, NSString *sakuraPath, TXSakuraName *sakuraName) {
                  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

      BOOL isSuccess = [SSZipArchive unzipFileAtPath:toFilePath toDestination:sakuraPath delegate:self];

      // 注意：自定义下载操作，必须进行 Sakura 路径格式化！Required！
      [TXSakuraManager formatSakuraPath:sakuraPath cleanCachePath:toFilePath];
      
      dispatch_sync(dispatch_get_main_queue(), ^{
          if (isSuccess) {
              [TXSakuraManager shiftSakuraWithName:sakuraName type:TXSakuraTypeSandBox];
          }
      });
   });
} errorHandler:^(NSError * _Nullable error) {
   NSLog(@"errorDescription:%@",error);
}];

FQA

1.为何每个主题都有自己配置文件？

答：由于每个主题，除了切图的命名是是一致的外，不同的主题背景色、字体大小可能不一样，因此，每个主题都要有自己的配置文件，除非只对切图进行本地化。

2.为何主题名称与配置文件名称一致？

答：这只是一个约定，SakuraKit 会通过主题名称找到该主题在本地或者在沙盒中的路径，使得主题名称与配置文件名称一致，可以减少不必要的工作量。

3.本地与沙盒主题有什么区别？

答：在本地主题称为 mainBundle 主题，远程主题称为 Sandbox 主题。

开源

关于 SakuraKit 具体使用，详见 Demo。

GitHub 项目地址：https://github.com/tingxins/SakuraKit

有什么问题或者更好的建议，GitHub 上直接提 issue 或者 PR。感谢支持

Demo 素材来源：网易云音乐等第三方 App，如有不妥之处，请及时联系并予以删除，谢谢。

What's New in Swift 4 ?

Tue, 11 Jul 2017 15:01:30 +0000

前言

本文主要是笔者小结 WWDC2017 中《What’s New in Swift》的 Session ，其中也掺杂了些《What’s New in Foundation》，仅作记录。

下面步入主题。

私有访问控制（”Private” Access Control）

SE-0169

在 Swift 4 中，private 修饰的属性可以在 Extension 中访问了，再也不要用 fileprivate 修饰属性了😎。

下面我们来区分 Swift 3 与 Swift 4 中的区别。

Swift 3：

Swift 4：

类与协议（Class and Subtype Existentials）

SE-0156

在 Swift 3 中，有些童鞋使用代理时，无法同时继承类和协议

Swift 4 中，针对此处进行了改进，直接上 WWDC17 示例代码：

func shareEm(control: UIControl & Shakeable) {
    control.share()
}

protocol Shakeable {
    func share()
}

extension Shakeable {
    func share() {
        print("starting share!")
    }
}

extension UIButton: Shakeable { }

extension UISlider: Shakeable { }

Smart KeyPaths

SE-0161

在 Swift 4 中新增了一种 Key-Path 表达式，该表达式可用于 KVC & KVO 中的 APIs，格式如下：


\[Type Name].[Property Name]

示例代码如下：

struct SomeStructure {
    var someProperty: Int
}

func smartKeyPath() {

    let s = SomeStructure(someProperty: 12)
    let keyPath = \SomeStructure.someProperty
       
    let value = s[keyPath: keyPath]
    print(value)
    // value is 12
}

如果在上下文中，能隐含的推断出其类型，那么 Key-Path 表达式中的 Type Name 可以省略，即


\.[Property Name]

如：

@objcMembers class SomeClass: NSObject {
    dynamic var someProperty: Int
    init(someProperty: Int) {
        self.someProperty = someProperty
    }
}

var observe: NSKeyValueObservation?
let c = SomeClass(someProperty: 10)
    
func smarkKVO() {
   observe = c.observe(\.someProperty) { object, change in
       // ...
       print(object.someProperty, change)
   }
   c.someProperty = 10
}

Archival & Serialization

SE-0166

Excerpt From: Apple Inc. “Using Swift with Cocoa and Objective-C (Swift 4 beta).

我们以下面这段 JSON 为例，来看 Swift 4 中针对 JSON 进行解析的新方法

{
     "name": "Banana",
     "points": 200,
     "description": "A banana grown in Ecuador.",
     "varieties": [
         "yellow",
         "green",
         "brown"
      ]
}

首先，我们要遵循 Codable 协议：

struct GroceryProduct: Codable {
    let name: String
    let points: Int
    let description: String
    let varieties: [String]
}

使用 JSONDecoder 进行解析：

let json = """
    {
         "name": "Banana",
         "points": 200,
         "description": "A banana grown in Ecuador.",
         "varieties": [
             "yellow",
             "green",
             "brown"
          ]
    }
""".data(using: .utf8)!
 
let decoder = JSONDecoder()
let banana = try! decoder.decode(GroceryProduct.self, from: json)
 
print("\(banana.name) (\(banana.points) points): \(banana.description)")
// Prints "Banana (200 points): A banana grown in Ecuador.

Encoders

SE-0167

本节主要展示 JSONEncoder 编码，直接上代码：

struct University: Codable {
    enum Level: String, Codable {
        case one, two, three
    }
    
    var name: String
    var founds: Int
    var type: Level
}


func codableTest (_ obj: University) {
   let encoder = JSONEncoder()
   let decoder = JSONDecoder()
   guard let data = try? encoder.encode(obj) else { return }
   guard let jsonData = try? decoder.decode(University.self, from: data) else { return }
   print("jsonData:", jsonData)
}

关于字符串（String）

字形群集（Grapheme Cluster）

在 Swift 4 中，修复了字形群集长度计算的一些问题，如 emoji 表情。关于字形群集或者 Unicode 编码概念生疏的童鞋可以看笔者之前写的两篇文章《字符编码（一）》、《Swift3.0 中 Strings/Characters 闲聊》。下面我们来看看 WWDC17 上的的示例：

var family = "👩"
family += "\u{200D}👩"
family += "\u{200D}👧"
family += "\u{200D}👧"
   
print("\(family):\(family.count)")
// result --> 👩‍👩‍👧‍👧:1

在之前 family.count 会等于 4（\u{200D} 是一个零宽度的 joiner）。

笔者在 Xcode 9 beta1 上运行，选择 Swift 编译语言版本时，测试结果无效，只有在 Xcode 8 测试时 family.count = 4。

字符串改版（String Revision）

SE-0163

在 Swift 2 中，String 的集合这一特性被遗弃，在 Swift 3 中，String 也没有遵守集合的相关协议（如：RangeReplaceableCollection, BidirectionalCollection），因此自 Swift 2 起，String 不是一个集合，而是把这一特性赋予给了 String 的一个属性 –> characters (A view of the string’s contents as a collection of characters.)，该属性是 String.CharacterView 类型，并且遵守 RangeReplaceableCollection 协议。


extension String.CharacterView : RangeReplaceableCollection {···}

因此我们在遍历或者操作 String 时，经常会这么写：

Excerpt From: Apple Inc. “The Swift Programming Language (Swift 3.1).” iBooks. https://itunes.apple.com/us/book/the-swift-programming-language-swift-3-1/id881256329?mt=11

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

.characters.····。

但，直至 Swift 4，String 又开始遵循集合相关协议，从此可以这么写了：

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

当然在 Swift 4 中又出现了一个新的结构体 Substring，Substring 无法直接赋值给 String 的。

关于 Substring 与 String 之间的转换可以这么写：

let label = UILabel()
let superStr = "tingxins"
let subStr = superStr.prefix(4)
label.text = String(subStr)
print(subStr)

字符串跨行写法(Multi-Line String Literals)

SE-0168

如果字符串需要跨多行，可以这么写：

Excerpt From: Apple Inc. “The Swift Programming Language (Swift 4).”.

let quotation = """
The White Rabbit put on his spectacles.  
"Where shall I begin, please your Majesty?" he asked.
 
"Begin at the beginning," the King said gravely, "and go on
till you come to the end; then stop."
"""

没错，三对引号。

如果字符串本身包含三个连续的 ‘””“‘ 引号时，可以采用反斜杠进行转义处理（\），如：

let threeDoubleQuotes = """
Escaping the first quote \"""
Escaping all three quotes \"\"\"
"""

单面区间语法（One-Sided Ranges）

SE-0172

在 Swift 3 中，区间运算符只有两种：闭区间运算符（Closed Range Operator）、半闭区间运算符（Half-Open Range Operator）。在 Swift 4 中，又新增了一种更加简单方便的区间运算符–>单面区间（One-Sided Ranges）。

Excerpt From: Apple Inc. “The Swift Programming Language (Swift 4).

你可以这样写：

let names = ["Anna", "Alex", "Brian", "Jack"]

for name in names[2...] {
    print(name)
}
// Brian
// Jack

for name in names[...2] {
    print(name)
}
// Anna
// Alex
// Brian

当然也和结合半闭区间运算符，可以这么写：

for name in names[..<2] {
    print(name)
}
// Anna
// Alex

判断区间是否包含，可以这么写：（for语句中要注意死循环哈）

let range = ...5
range.contains(7)   // false
range.contains(4)   // true
range.contains(-1)  // true”

WWDC17 示例代码：

序列协议（Sequence）

SE-0142

在 Swift 3 中，假设我们要为 Sequence 扩展一个方法，要这么写：

extension Sequence where Iterator.Element: Equatable {
    func containsOnly(_ value: Iterator.Element) -> Bool {
        return contains { (element) -> Bool in
            return element == value
        }
    }
}

但在 Swift 4 中，针对 Sequence 做了一些小改进，使我们代码更加轻便，看起来更加清爽：

extension Sequence where Element: Equatable {
    func containsOnly(_ value: Element) -> Bool {
        return contains { (element) -> Bool in
            return element == value
        }
    }
}

这是怎么实现的呢？因为在 Swift 4 中，我们在声明一个 associatedtype 的 placeholder 时，我们可以使用 where 语句了。

下面我们来对比一下 Swift 3 与 Swift 4 中 Sequence 的区别：

在 Swift 3 中 Sequence 协议是这么写的：

在 Swift 4 中进行改进后，是这么写的：

对比看完后，想必读者一目了然。

下面针对 associatedtype 中使用 where 语句，我们再来看个例子：

Excerpt From: Apple Inc. “The Swift Programming Language (Swift 4).

protocol Container {
    associatedtype Item
    mutating func append(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }
    
    associatedtype Iterator: IteratorProtocol where Iterator.Element == Item
    func makeIterator() -> Iterator
}

如果在 Swift 3 下写，Xcode 会出现这样的编译错误:

有了上面这些特性后，我们在使用 Swift 4 时，可以省略一些冗余约束，这里直接上 WWDC17 的示例代码：

在 Swift 3 中，是这样写的：

在 Swift 4 中，现在我们可以这么写：

泛型下标（Generic Subscripts）

SE-0148

在 Swift 4 中，现在支持泛型下标了，直接上代码：

Excerpt From: Apple Inc. “The Swift Programming Language (Swift 4).

extension Container {
    subscript<Indices: Sequence>(indices: Indices) -> [Item]
        where Indices.Iterator.Element == Int {
            var result = [Item]()
            for index in indices {
                result.append(self[index])
            }
            return result
    }
} 

上述代码我们为 Container 添加了下标取值能力，在这个泛型下标中有 3 个约束：

泛型参数 Indices 遵守 Sequence 协议
indices 是 Indices 类型的一个实例
泛型 where 语句筛选 Indices.Iterator.Element 为 Int 类型

关于整型（Protocol-oriented integers）

SE-0104

字典与集合（Dictionary & Set enhancements）

SE-0165

Number 对象桥接（NSNumber bridging and Numeric types）

SE-0170

Swift 3 中，NSNumber 转换有个 Bug，如：

let n = NSNumber(value: UInt32(543))
let v = n as? Int8
// v is 31

Swift 4 中已修复：

可变集合（MutableCollection）

SE-0173

现在可变集合增加了一个方法，我们可以直接使用 swapAt 方法，而非 swap 。

let university0 = University(name: "Qsting", founds: 1870, type: .one)
let university1 = University(name: "tingxins", founds: 1870, type: .one)
var mutableCollection = [university0, university1]

print(mutableCollection)   
mutableCollection.swapAt(0, 1) //交换数组中0、1元素的位置
print(mutableCollection)

Change filter to return Self for RangeReplaceableCollection

SE-0174

参考链接

https://developer.apple.com/videos/play/wwdc2017/402/
https://github.com/apple/swift-evolution/tree/master/proposals
https://github.com/ole/whats-new-in-swift-4
https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/index.html
https://developer.apple.com/library/content/documentation/Swift/Conceptual/BuildingCocoaApps/MixandMatch.html

self.delegate = self?

Sat, 01 Jul 2017 15:23:00 +0000

前言

在 Objective-C 项目中，不少开发者们可能会写或者曾看到过这样的代码：


self.delegate = self

？？把自己的代理设置为自己？？这种做法到底妥不妥呢？

本文将采用自问自答、通俗易懂的方式讨论 self.delegate = self 这种做法是否妥当，以及这种做法将会带来的问题，或者说致命的问题。

为何这么写？

首先，我们先回顾一下 Delegate 的出现的原因是什么呢？再反思一下，我们为何会这么写呢？以及出现的场景有哪些？

笔者觉得 Delegate 模式其实就是 NSProxy 设计模式的一种衍生版，它们共同的特点可以理解为都是传递对象的消息，主要区别如下：

两者消息传递方式不同，我们使用 NSProxy 会实现消息转发功能，而 Delegate 一般不会实现，仅作消息传递。
Delegate 是一对一的消息传递（A->B），而 NSProxy 可以一对多的进行消息传递(A->B/A->C/A->D)。

Delegate 无非就是把 A 的消息传递给代理对象 B，self.delegate = self 直接把代理对象设置为自己，这样省去了引入第三方代理，这种做法大部分情况是为了图个方便，一般出现在使用第三方闭源代码以及系统类（如：UITextField等）的情况下，因为我们无法获知内部消息是如何传递的，只能通过代理对象获知消息。

self.delegate = self 这种做法笔者并不推荐，因为它可能会带来一些安全隐患（特别是在依赖第三方库非常多的项目中），后文会做说明。

本文以系统类 UITextField 的子类为例展开讨论。

莫名奇妙的现象

在项目中我们经常会用到 UITextField 类或者其子类，有时候为了图其方便会把 UITextField 的 delegate 设置为自己（self.delegate = self），然而在使用 UITextField 控件时，发现程序不响应了，过了几秒后程序出现闪退现象。

既然 Bug 来了，那当然就是找 Bug，于是我们开始排查原因（先撇开调用栈信息）：

首先针对新增的部分代码进行注释，把 self.delegate = self 代码注释掉，然后重新运行程序，发现问题得到解决。
控制变量法开始排查。难道是 self.delegate = self 导致的？

于是新建工程，写了一份一模一样的代码（注：TXLimitedTextField 继承自 UITextField）：

    
@implementation ViewController
   
- (void)viewDidLoad {
  [super viewDidLoad];
  
  TXLimitedTextField *textField = [[TXLimitedTextField alloc] initWithFrame:CGRectMake(100, 100, 100, 30)];
  textField.backgroundColor = [UIColor redColor];
  textField.delegate = textField;
  [self.view addSubview:textField];
}
    
@end
    

运行新建的工程后，发现没有这问题。于是在 TXLimitedTextField.m 文件中再实现自己的代理方法：

@interface TXLimitedTextField ()

@end
    
@implementation TXLimitedTextField
    
- (BOOL)textFieldShouldReturn:(UITextField *)textField {
   [textField endEditing:YES];
   return YES;
}
    
@end

运行工程，使用 TXLimitedTextField 控件，发现还是没有这问题。

What‘s fuck?? 原项目代码有毒？？

进行全局断点后，重新再次运行项目，发现调用栈无限递归，直到栈溢出，最后导致程序崩溃。

下面我们来看是什么原因导致的。

什么问题？

self.delegate = self（self 指 TXLimitedTextField 实例）调用栈无限递归？于是，我们针对 TXLimitedTextField 类查找一下整个项目中有没有这种代码：

- (void)doSomething {
    if ([self.delegate respondsToSelector:@selector(doSomething)]) {
        [self.delegate performSelector:@selector(doSomething)];
    }
}

首先，这种写法一定要避免，尤其是在使用系统类或者第三方闭源框架时应特别注意，因为你并不知道其实现代码是如何写的。

如果整个项目中没有这种代码，检查一下是否存在 UITextField 运行时相关代码或者第三方框架，比如：BlocksKit等等。下面笔者举个具体的例子：

这段时间在维护一个旧项目，最近发现项目出现上述的问题，仔细排查后发现项目中用到了 BlocksKit，其中有一个 Category（UITextField + BlocksKit），其中针对 UITextField 的 delegate 进行动态调剂，把 delegate 替换成 A2DynamicUITextFieldDelegate（父类为 A2DynamicDelegate，根类为 NSProxy 类）的实例，NSProxy 类主要用于消息转发的（不熟悉的，请查阅官方文档）。

断点至自定义的 UITextField 中的 -respondsToSelector: 方法以及 A2DynamicDelegate 中的如下方法：

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
	A2BlockInvocation *invocation = nil;
	.
	.
	.(略)
	else if (class_respondsToSelector(object_getClass(self), aSelector))
		return [object_getClass(self) methodSignatureForSelector:aSelector];
	return [[NSObject class] methodSignatureForSelector:aSelector];
}

- (void)forwardInvocation:(NSInvocation *)outerInv {
	SEL selector = outerInv.selector;
	A2BlockInvocation *innerInv = nil;
	.
	.
	.(略)
	} else if ([self.realDelegate respondsToSelector:selector]) {
		[outerInv invokeWithTarget:self.realDelegate];
	}
}

- (BOOL)respondsToSelector:(SEL)selector {
    NSLog(@"%s--%@", __func__, NSStringFromSelector(aSelector));
	return [self.invocationsBySelectors bk_objectForSelector:selector] || class_respondsToSelector(object_getClass(self), selector) || [self.realDelegate respondsToSelector:selector];
}

发现程序一直在这四个方法中循环执行，直到栈溢出，最终致使程序崩溃。相信大家遇到的问题都与此类似，下面笔者将以此例进行具体分析并究其原因。

什么原因？

找到了程序的崩溃点后，通过 NSLog 输出上述方法中的选择器 selector，发现是 -keyboardInputChangedSelection: 方法，于是设置条件断点（[NSStringFromSelector(aSelector) isEqualToString:@”keyboardInputChangedSelection:”]）如图所示：

进入断点调试后，发现一个有意思的事，如图所示：

这说明，在 UITextField 中，伪代码如下：

- (id)keyboardInputChangedSelection:(id)obj {
    // self == UITextField
    if ([self.delegate respondsToSelector:@selector(keyboardInputChangedSelection:)]) {
        [self.delegate keyboardInputChangedSelection:obj];
    }
    
}

看到这个方法后，读者应该发现 -keyboardInputChangedSelection: 方法与本节开头所提 -doSomething: 方法结构是一模一样的？只是方法名不同而已。

此时，细心的读者可能会产生一个疑惑，如果如上所述，那么上文提到新建的工程（TXLimitedTextField 类，如果写了 self.delegate = self）也应该会出现无限递归（死循环）才对啊？

然而事实上却没发生死循环。

笔者通过断点调试，发现 TXLimitedTextField 同样会调用 -keyboardInputChangedSelection:，断点截图同上，但不会出现死循环，最终导致程序崩溃的现象，笔者猜测分析，UITextField 类应该针对 self.delegate = self 做了一些特殊的处理，具体什么处理，就得问苹果爸爸了。可以肯定的是，在没有任何方法调剂的情况下，即 “self.delegate == self”，是不会出现死循环的问题的。

但是，此处存在方法调剂，即 BlocksKit 动态替换了 UITextField 类中 delegate（在其子类亦生效），因此 delegate 其实是 A2DynamicDelegate 实例，为了帮助读者理解，笔者简单画了一张图：

当点击 UITextField 控件时调用栈如下（省略部分）：

[UITextField respondsToSelector:] // return YES
[UITextField keyboardInputChangedSelection:]
[TXLimitedTextField.delegate respondsToSelector] // 由于self.realDelegate（realDelegate 是 A2DynamicDelegate 实例持有的弱引用对象，感兴趣的读者可以看看 BlocksKit 源码）响应该方法，于是 return YES
[TXLimitedTextField.delegate keyboardInputChangedSelection:] // 实际上 A2DynamicDelegate 并未实现 keyboardInputChangedSelection: 方法，于是进入消息转发阶段
[TXLimitedTextField.delegate methodSignatureForSelector:]
[TXLimitedTextField.delegate forwardInvocation:] // 将消息再次转发给 self.realDelegate，于是开始死循环。

该如何解决？

通过上文主要以 UITextField 为例进行讨论分析，那么这种问题应当如何解决？

在没有考虑清楚前，避免使用 self.delegate = self。
破除死循环，解决上述问题，只需停止消息转发即可（不过会存在一些小问题），可以在 -forwardInvocation: 方法中处理。

至于在 BlocksKit 中具体怎么处理该问题，在笔者的一个开源项目中进行了实践，在使用 InputKit 过程中，即使 self.delegate = self，也不会出现上述死循环的问题，本文不做详述，详见InputKit.

闲谈

笔者遇到上述的问题，其实属消息转发间接导致，可以说是第三方框架 BlocksKit 的一个 Bug，作者已经有一年多未更新该框架了哈（可能有由于 Swift 不再推荐使用 runtime 相关的方法，特别是消息转发相关 API，作者无力更新 Objective-C，哈哈）。

iOS 输入限制之 InputKit

Wed, 28 Jun 2017 15:22:00 +0000

前言

最近接手了两个 O2O 的老项目，其中的 Bug 也不言而喻，单看项目中的布局就有 n 种不同的方式，有用纯代码的，有用 Masonry 的，有用 VFL 的，也有用 Xib 的，更有用代码约束等等等，🐮。不扯远了，回归正题。

由于这两个项目是 O2O 项目，因此针对输入组件的限制相比其他类型的项目要多一些，比如商品价格输入（如：保留3位整数，2位小数等）、买家留言字数限制、不能输入中文、不能输入英文、只能输入数字等等限制。

于是输入限制 InputKit 诞生了！本文主要简单介绍 InputKit 的使用及相关注意事项。

InputKit

InputKit 是一个轻量级的，专门用于做输入限制的第三方库，灵感源自 BlocksKit，在项目中，主要为了解决三个问题：

解耦
需求
Bug

解耦

所谓解耦，即在开发项目中工程师不需要仅仅只为做个输入限制，就在项目中到处写 UITextFieldDelegate 协议中的方法，如：

- (BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string {
    // Coding
}

只需继承 InputKit 中的类即可，然后设置相关的限制属性即可，无需设置 delegate。以 TXLimitedTextFieldTypePrice 类型为例，如：

Objective-C

// 创建 TXLimitedTextField 实例
TXLimitedTextField *textField = [[TXLimitedTextField alloc] initWithFrame:CGRectMake(20, 200, 100, 30)];
// 如 limitedType 不设置，默认 TXLimitedTextFieldTypeDefault
textField.limitedType = TXLimitedTextFieldTypePrice;
// 限制 10 的输入长度
textField.limitedNumber = 10;
// 保留 5 位整数位
textField.limitedPrefix = 5;
// 保留 2 位小数位
textField.limitedSuffix = 2;
[self.view addSubview:textField];

Swift

let textField = LimitedTextField(frame: CGRect(x: 20, y: 200, width: 100, height: 30))
textField.limitedType = .price
textField.limitedNumber = 10
textField.limitedPrefix = 5
textField.limitedSuffix = 2
view.addSubview(textField)

如果想设置 textField 的 delegate 也可以（即 textField.delegate = self），不会影响其限制功能，就像使用普通的 UITextField 一样，毫无差异，非常方便。

Demo 截图：

需求

文章开头提到过，需求即针对商品价格输入（如：保留3位整数，2位小数等）、买家留言字数限制、不能输入中文、不能输入英文、只能输入数字等等做限制。

如果针对上述的部分需求做定制键盘，是完全没必要的，因为工作量增多且并不能从源头解决问题，比如：用户使用粘贴功能、使用键盘提示文本等等，导致定制的键盘也是白搭。因此 InputKit 从源头解决该问题，针对用户的输入进行筛选并限制。比如我们只能让用户输入中文：

Objective-C

TXLimitedTextField *textField = [[TXLimitedTextField alloc] initWithFrame:CGRectMake(20, 200, 100, 30)];

// 自定义输入限制类型
textField.limitedType = TXLimitedTextFieldTypeCustom;

// 限制最大输入长度
textField.limitedNumber = 10;

// limitedRegExs 是一个数组类型的参数，数组元素类型即正则表达式，如：kTXLimitedTextFieldChineseOnlyRegex 是一个常量，其值为：“^[\u4e00-\u9fa5]{0,}$”，即代表匹配中文的正则
textField.limitedRegExs = @[kTXLimitedTextFieldChineseOnlyRegex];

[self.view addSubview:textField];

（Swift 代码略）

关于上述的正则表达式，在 InputKit 中的 TXMatchConst.h 头文件中提供了一些常用的，比如：只能输入数字、中文、字母等等，欢迎大家在 GitHub 上 PR。（注意：此处的正则表达式限制的是输入源头，而非结果！不然会导致用户无法输入。体会一下哈）。

Demo 截图：

Bug

在没使用 InputKit 之前，有时候，运行到程序的某处，点击输入框，程序莫名其妙的卡死，过会儿就闪退了。相信不少人遇到过，后来发现是 self.delegate = self（self 即输入框对象）导致的。注释后，发现没问题，打开后，程序又闪退，后来发现原来是 self.delegate = self 引起的死循环，因此不得不注释该句代码。

上述的这些问题，如：在项目中 UITextFieldDelegate 协议方法遍地都是，以及一不小心使用了 self.delegate = self 时，还会出现死循环等等，InputKit 都解决了。

使用 InputKit 后，self.delegate = self 程序不再卡死。（晚点会再发一篇软文针对 self.delegate = self 的问题进行剖析）。

至此，需求、Bug 均已解决。👀

开源

GitHub 项目及 Demo 地址：https://github.com/tingxins/InputKit。有什么问题或者更好的建议，直接提 issue 或者 PR。

Objective-C 中的对象、类、元类

Tue, 30 May 2017 15:22:00 +0000

前言

现在写文章拖延症特别严重啊 (😂)……

本文我们将复习一下 Objective-C 中的一些关于类的知识。

在开发过程中，类与对象相信大家再熟悉不过了，有时我们也会接触一个比较陌生的概念，元类（metaclass），甚至在回头来想时，发现类与对象是什么都开始犯糊涂了，本文主要探讨这三者之间的关系以及在消息转发中各自扮演的角色，希望读者看完本文能有所收获。如有不妥的地方还望大家及时帮忙纠正。

什么是类？

在面向对象编程语言中，类是一个非常重要的概念，理解了它，能更好的造轮子、能更好的面向对象编程、能写出模块化的代码、更能提高代码的可读性及后期维护性。

类是数据及行为的封装体，在 Objective-C 中，在数据上，类定义了内存分配大小、内存布局以及成员变量数据类型等，在行为上，类定义了实例方法等。我们可以简单的把类比作为某个产品的设计稿。

通过查阅 Apple 官方开源的 objc 源码（官方最新版—>传送门），得知类的数据结构（其中字段本文不做解释，可自行 Google），如下：

typedef struct objc_class *Class;

struct objc_class : objc_object {
    // Class ISA;
    Class superclass;
    // formerly cache pointer and vtable
    cache_t cache;  
    // class_rw_t * plus custom rr/alloc flags              
    class_data_bits_t bits;    

    class_rw_t *data() { 
        return bits.data();
    }
    .
    .
    .
    ...(省略)
}
    

看完这小段代码，细心的同学会发现，objc_class 继承自 objc_object，没错，类其实也是一个对象，既然类是一个对象，那么它一定是某个类的实例。先不讨论此问题，我们先来谈谈对象。

什么是对象？

对象一定是某个类具体的一个实例，可以简单理解为类的“值”，可直接使用，就像洗衣机（对象）一样可以直接用来洗衣服（数据），但洗衣机的设计稿（类）却不能。对象具有动态性，它有自己的生命周期，对象在生命周期结束时会调用 dealloc 方法。

在 Objective-C 中，含有一个 isa 指针并且可以正确指向某个类的数据结构，都可以视作为一个对象，其中 isa 指针指向当前对象所属的类。通过查阅 Apple 官方开源的 objc 源码（官方最新版—>传送门），得知类的数据结构（其中字段本文不做解释，可自行 Google），如下：

struct objc_object {
private:
    isa_t isa;
    .
    .
    .
    ...(省略)
}

每当要向某个对象发送一个消息时，都会通过 isa 指针找到该对象所属的类（因为类定义了对象的行为），然后再遍历其方法缓存表或者方法列表（行为），通过 SEL 找到后取出方法（Method）中的 IMP 函数入口指针，并执行该函数，如果找不到该方法，则进入消息转发等等，此处本文不做概述。

讨论完对象之后，我们再来回顾上文遗留的一个问题：类既然是一个对象，那么这个对象的类是什么呢？接下来我们将讨论此问题。

什么是元类？

元类是类对象的类。简单的说类描述的是对象，那么元类描述的就是类。同理，元类定义了类的行为（类方法），每当要向某个类发送一个消息时，都会通过 isa 指针找到该类所属的元类，然后遍历其方法缓存表或者方法列表，通过 SEL 找到后取出方法中的 IMP 函数入口指针，并执行该方法，否则进行消息转发阶段等等。

说到元类，那么定会有人问，元类的类是什么？元类也是一个对象，元类的类是根元类，根元类在继承体系中是根类的元类，那么根类的元类是属于哪个类呢？根元类的类就是自己（即 isa 指针指向自己），根元类的父类 superClass 指针指向根类。

对象、类与元类的关系

Greg Parker (@gparker) 给出了一张图，使得整个结构清晰明了：

理解与探究

理解

如果上述都理解了，那么下面这段代码看懂就没问题了。 -(IMP)methodForSelector:(SEL)aSelector 是 NSObject 类的一个实例方法，以下两种调用方式都是正确的：

[NSObject methodForSelector:@selector(test)];
[[[NSObject alloc] init] methodForSelector:@selector(test)];

探究

为了验证本文的一些说法，下面我们写个测试代码进行验证，输出结果本文不做分析，有兴趣的读者可以对照上文自行分析：

Class currentClass = [UITextField class];
for (int index = 0; index < 5; ++ index) {
   
   NSLog(@"## index:%d ## isa:%p --- superClass:%p", index, currentClass, class_getSuperclass(currentClass));
   currentClass = object_getClass(currentClass);
}
NSLog(@"NSObject:%p --- NSObject Meta Class:%p\nMeta super Class:%p --- Meta root Class:%p", [NSObject class], object_getClass([NSObject class]), class_getSuperclass(object_getClass([NSObject class])), object_getClass(object_getClass([NSObject class])));

运行上述代码后，输出结果如下：

By the way, happy Children’s Day!🤡🤡🤡

参考链接

iOS 中网络请求同步

Sun, 30 Apr 2017 00:00:00 +0000

场景

在开发过程中，有时候会遇到这样一些问题，比如：

在某些业务要求下，需发送同步请求。
在某些界面需请求多个接口，且各个接口返回的数据之间或者整体存在依赖关系。
···

那么在上述的这些场景下应如何发送网络请求？发同步请求 or 异步请求？请求嵌套？······

本文将简单探究开发过程中网络请求同步的问题以及相关注意点。

NSURLConnection 中的同步请求

我们都知道 NSURLConnection 中有一个同步请求的 API :

+ (NSData *)sendSynchronousRequest:(NSURLRequest *)request
returningResponse:(NSURLResponse **)response
error:(NSError **)error

针对上述的第一种情况 A，该 API 可满足要求。如果同步请求阻塞主线程的时间过长，存在被 watchdog kill 的可能。想避免这种情况，建议在子线程中调用此 API。(感兴趣的同学可以看看，关于 watchdog timeout crashes/Understanding and Analyzing Application Crash Reports)

同步请求相对异步请求而言存在一些缺陷，如：

请求发出后，就无法取消
返回的数据只能放到请求结束后进行处理
···

很遗憾，NSURLConnection 目前已被苹果全面弃用，并且 AFNetworking 在 3.x 中已经移除此类 API，因此同步请求不建议采用此种方式。

Dispatch_semaphore（信号量）

信号量机制，我们可以简单理解为资源管理分配的一种抽象方式。在 GCD 中，提供了以下这么几个函数，可用于请求同步等处理，模拟同步请求：

dispatch_semaphore_t semaphore = dispatch_semaphore_create(value);
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
dispatch_semaphore_signal(semaphore);

value 可以理解为资源数量，以 value = 0 为例，调用 dispatch_semaphore_wait 操作成功后，当资源数量 value 等于 0 时，就会阻塞当前线程（反之，value 就会减 1），直到有 dispatch_semaphore_signal 通知信号发出，当 value 大于 0 时，当前线程就会被唤醒继续执行其他操作。

下面我们展示一段代码来模拟同步请求：

Objective-C:

    // 1.创建信号量
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    NSLog(@"0");
    // 开始异步请求操作（部分代码略）
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"1");
        // This function returns non-zero if a thread is woken. Otherwise, zero is returned.
        // 2.在网络请求结束后发送通知信号
        dispatch_semaphore_signal(semaphore);
    });
    // Returns zero on success, or non-zero if the timeout occurred.
    // 3.发送等待信号
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"2");

    // print 0、1、2
    

Swift:

    func sendSynchronousDataTask(with url: URL) -> (Data?, URLResponse?, Error?) {
        var data: Data?
        var response: URLResponse?
        var error: Error?
        // 1.创建信号量
        let semaphore = DispatchSemaphore(value: 0)
        // 开始异步请求操作
        let dataTask = URLSession.shared.dataTask(with: url) {
            data = $0
            response = $1
            error = $2
            // 2.在网络请求结束后发送通知信号
            semaphore.signal()
        }
        dataTask.resume()
        // 3.发送等待信号
        _ = semaphore.wait(timeout: .distantFuture)
        
        return (data, response, error)
    }

在 iOS 系统中，如果应用不能及时的响应用户界面交互事件（如启动、暂停、恢复和终止），watchdog 就会杀死程序并生成一个 watchdog 超时崩溃报告，据官方说法，watchdog timeout 时间并没有明文规定，但一般会少于网络请求超时时间。

In order to keep the user interface responsive, iOS includes a watchdog mechanism. If your application fails to respond to certain user interface events (launch, suspend, resume, terminate) in time, the watchdog will kill your application and generate a watchdog timeout crash report. The amount of time the watchdog gives you is not formally documented, but it’s always less than a network timeout.

这里有一个奇怪的现象，经测试，笔者采用信号量机制一直阻塞主线程时并没有被 watchdog kill，但 NSURLConnection 中的同步请求方法 + sendSynchronousRequest:returningResponse:error: 在慢速网络下与其说 crash 了，不如说被 watchdog kill 了。不扯远了，开始下一个话题 —— dispatch_group_t

Dispatch_group（组）

继续本文话题，回顾文章开头提到的问题，如果针对单个请求进行同步处理，那么使用同步请求即可，上述两种方式都可以。如果在某些界面需请求多个接口，且各个接口返回的数据之间或者整体存在依赖关系，那怎么办呢？虽然采用嵌套请求的方式能解决此问题，但存在很多问题，如：其中一个请求失败会导致后续请求无法正常进行、多个请求在时间上没有复用，即无并发性。

A dispatch group is a mechanism for monitoring a set of blocks. Your application can monitor the blocks in the group synchronously or asynchronously depending on your needs. By extension, a group can be useful for synchronizing for code that depends on the completion of other tasks.

针对这种情形，即某个操作依赖于其他几个任务的完成时，我们可采用 dispatch_group。主要使用如下两个函数：

dispatch_group_enter(group);
dispatch_group_leave(group);

以上这两个函数必须配对使用，否则 dispatch_group_notify 不会触发。贴一段代码 + 一张效果图（源码）：

    // 创建 dispatch 组
    dispatch_group_t group = dispatch_group_create();
    
    // 第一个请求：
    dispatch_group_enter(group);
    [self sendGetAddressByPinWithURLs:REQUEST(@"getAddressByPin.json") completionHandler:^(NSDictionary * _Nullable data, NSError * _Nullable error) {
        NSArray *addressList = [TXAddressModel mj_objectArrayWithKeyValuesArray:data[@"addressList"]];
        self.addressList = addressList;
        dispatch_group_leave(group);
    }];
    
    // 第二个请求
    dispatch_group_enter(group);
    [self sendCurrentOrderWithURLs:REQUEST(@"currentOrder.json") completionHandler:^(NSDictionary * _Nullable data, NSError * _Nullable error) {
        TXCurrentOrderModel *currentOrderModel = [TXCurrentOrderModel mj_objectWithKeyValues:data];
        self.currentOrderModel = currentOrderModel;
        dispatch_group_leave(group);
    }];
    
    // 当上面两个请求都结束后，回调此 Block
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"OVER:%@", [NSThread currentThread]);
        [self setupOrderDataSource];
    });

对于熟悉 dispatch_group 的同学来说，可能会想，为何不用 dispatch_group_async？对于网络请求而言，请求发出时它就已经执行完毕，也就是 block 中还有个 completeHandler 的情况下，dispatch_group_async 并不会等待网络请求的回调，所以不符合我们要求。

总结

通过本文简单探究，展示了如何采用信号量机制模拟同步请求，在开发过程中，我们应尽量避免发送同步请求；并且在某个操作依赖于其他几个任务的完成时，采用 dispatch_group_async or dispatch_group_enter/dispatch_group_leave 来实现同步等处理。如果是进行网络请求同步，应采用后者。当然，如果感兴趣，我们可以在第三方网络库的基础上封装一层自己网络库。（相关源码）

02-希尔排序(Shell Sort)--(C语言)

Thu, 16 Mar 2017 15:21:00 +0000

前言

希尔排序算法其本质就是插入排序，是直接插入排序算法的一种改进，因 D.L shell 于 1959 年提出而得名，通常我们也称希尔排序为缩小增量排序，所谓增量，即将待排序的序列按该增量分割一个或多个子序列，所谓缩小，即当以某个增量分成的所有子序列都排序完后，增量会逐渐缩小（ps：最后一定会缩小到1）。如：先以3为增量，则将待排序的序列下标1、4、7···分成一组，将下标为2、5、8···分成另一组···，当以3为增量分割的所有子序列都排序好后（默认递增），再以1为增量分割该序列（ps：其实就是对基本有序的序列进行直接插入排序），最后完成整个希尔排序。

希尔排序算法依然可采用嵌套 for 循环的方式实现，本文将只采用递归的方法实现该算法。对于 for 循环的方式，感兴趣的童鞋可以参考笔者之前写的一篇文章哥德巴赫猜想。下面我们开始进入正题。

分析

我们以下面10个数字组成的序列来做分析：

13, 12, 2, 22, 16, 11, 10, 1, 21, 15

首先我们要明白希尔排序算法的执行时间依赖于增量序列，关于增量序列，要注意两点：

增量序列最后一个增量必须为1.
应尽量避免增量序列中的值互为倍数（避免重复排序），如：1、2、4、8。

针对上面给出的序列，我们以5、3、1为增量序列，下面模拟排序，以增量5为例，下面是每个子序列完成排序后的结果：

13 12 2 22 16 11 10 1 21 15
11 12 2 22 16 13 10 1 21 15 //11 与 13 互换
11 10 2 22 16 13 12 1 21 15 //10 与 12 互换
11 10 1 22 16 13 12 2 21 15 //1 与 2 互换
11 10 1 21 16 13 12 2 22 15 //21 与 22 互换
11 10 1 21 15 13 12 2 22 16 //15 与 16 互换

此时以5为增量分割的五个子序列都已排序完成：

11 10 1 21 15 13 12 2 22 16

然后在对上面得出的结果以增量3进行分割，重复相同的操作，最后在以1为增量进行分割（即进行一趟直接插入排序），从而完成希尔排序。

思路

采用递归方式，上文也提到过，希尔排序本质就是一种插入排序，是直接插入排序的一种改进。通过上述分析，我们可以划分如下几个步骤：

递归增量序列。
递归增量分割的所有子序列。
针对子序列进行直接插入排序（递归方式）。
返回步骤1，知道增量序列递归完毕。

针对这几个步骤，我们来把握一个临界值：

只有当前增量 delta > 1 时，我们才需要继续递归增量序列，反之，代表希尔排序已经完成。

实现

通过上述分析，想必大部分读者已经有思路，现在我们上代码。程序主要分四个模块：

专门处理特定子序列排序递归函数（采用直接插入排序）

    
 /**
 针对特定子序列进行直接插入排序，比较每一趟排序的数字并排排序
 
 @param data 待排序的序列
 @param tmp 寻找插入位置的当前元素
 @param n 序列长度
 @param delta 本趟排序增量
 */
 int StraightInsertionSortInnerRecursionCompare(int data[], int tmp, int n,  int delta) {
     if (n < 0) return n + delta; // 直接返回当前比较待插入的位置
     if (tmp < data[n]) {
        data[n + delta] = data[n]; // 把大的元素往后挪
     }else {
         return n + delta; // 返回当前比较待插入的位置
     }
     return StraightInsertionSortInnerRecursionCompare(data, tmp, n - delta, delta);// 子序列递归方式排序
 }
 // 得出索引值
 int StraightInsertionSortInnerRecursionIndex(int data[], int n, int delta) {
     return StraightInsertionSortInnerRecursionCompare(data, data[n], n - delta, delta);
 }
    

处理所有子序列排序的递归函数

    
 // 递归增量分割的所有子序列，针对排序递归！
 void StraightInsertionSortInnerRecursion(int data[], int n, int currentIndex, int delta)  {
     if (currentIndex >= n) return;
     int tmp =  data[currentIndex];
     data[StraightInsertionSortInnerRecursionIndex(data, currentIndex, delta)] = tmp; // 根据返回的索引修改该值，表示一趟排序完成
     StraightInsertionSortInnerRecursion(data, n, currentIndex + delta, delta);
 }
    

处理增量序列的递归函数

    
 /**
 递归增量序列，希尔排序，注意delta 为素数，
 
 @param data 待排序的序列
 @param n 序列长度
 @param currentIndex 子序列排序起点
 @param delta 本趟排序增量
 */
 void shellSort(int data[], int n, int currentIndex, int delta) {
     if (delta % 2 == 0) {
         printf("Delta error!");
         return;
     }
     if (delta < 1) return;
    
     if (currentIndex + delta > n) {
         shellSort(data, n, 0, delta - 2);
     }else {
         StraightInsertionSortInnerRecursion(data, n, currentIndex + delta, delta);
         if (delta > 1) {
             shellSort(data, n, currentIndex + 1, delta);//开始递归下一个子序列
         }
     }
 }
    

主函数模块

 int main() {
     int data[] = {13, 12, 2, 22, 16, 11, 10, 1, 21, 15};//为了方便，先固定该序列
     int n = 10;
     shellSort(data, n, 0, 5); // 开始希尔排序
     return 0;
 }
    

时间复杂度

希尔排序的复杂度分析较为复杂，笔者高数较水，此处不做分析，感兴趣的同学可以参考：传送门。源码地址

01-哥德巴赫猜想(Goldbach's Conjecture)--(C语言)

Mon, 13 Mar 2017 15:16:00 +0000

前言

哥德巴赫猜想是(Goldbach’s Conjecture)是数论中存在最久的未解问题之一，是一个伟大的世界性的数学猜想，其基本思想可以陈述为：

任何一个大于2的偶数，都能表示成两个素数之和。

如： 4 = 2 + 2 6 = 3 + 3 96= 23 + 73

本文将采用两种不同的算法来求出给定范围 n 内的哥德巴赫数字，并对比其时间复杂度，得出更优算法。

分析

根据哥德巴赫猜想，我们可以得出如下信息：

哥德巴赫数字是一个大于2的偶数。
哥德巴赫数字等于两个素数相加。

思路A

思路A与之前见过的很多想法一样，简单粗暴，采用嵌套 for 循环。思路如下：

for 循环依次遍历 [4, n] 范围内的偶数。
然后，针对每个数字（c）再次进行 for 循环找出两个数字（a,b）之和等于该数字的数字。（即 c = a + b）
判断 a,b 是否都为素数。
输出结果。

Show the (garbage) code!

实现A

我们把思路A实现的程序分成两个功能模块：

判断是否为素数模块 int isPrime(int i)，返回 1 即为素数。

    
 int isPrime(int i) {
     int j;
     if (i <= 1) return 0;
     if (i == 2) return 1;
     for (j = 2; j < i; j ++) {
         number ++;
         if (i % j == 0) {
         return 0;
         }else if(i != j + 1) {
             continue;
         }else {
             return 1;
         }
     }
 }
    

主程序模块：针对 [4, n] 之间的正偶数进行数值拆分，然后再用isPrime函数进行筛选，如果k，j都为素数，即满足哥德巴赫猜想，输出该数字。

 do {
     printf("please enter a number:");
     int number = 0;
     scanf("%d", &number);
     int i, j, k;
     for (int i = 4; i <= number; i += 2) {
         for (k = 2; k<= i/2; k ++) {
             j = i - k;
             if (isPrime(k)) {
                 if (isPrime(j)) {
                     printf("%d=%d+%d\n",i, k, j);
                 }
             }
         }
     }
 }while (1);
    

思路B

递归算法，也是我业余时间自己写的一个，递归路径类似鱼骨头，基本思路如下：

针对输入的 n 进行拆分（c = a + b 的形式）并递归。
如果拆分的数字 a,b 为偶数，则可能为符合哥德巴赫猜想，回到1。
如果 c 为偶数，且 a,b 为素数，即满足哥德巴赫猜想，输出该数字。

这里笔者画了一张抽象的鱼骨头图，帮助读者理解：

实现B

思路B实现的程序主要分成三个功能模块，为了区分思路A，判断素数的模块也采用递归的形式：

判断是否为素数 int isPrime(int i)，返回 1 即为素数。

    
 // 判断偶数
 int isEven(int original) {
     return (original % 2 == 0);
 }
    
 int isPrimeInner(int original, int current) {
     if (current<=0 || original<=0 || original == 1) return 0;
     if (original % 2 == 0) {
         if (original == 2) return 1;
         return 0;
     }
     if (current > (original / 2) + 1) return 1;
     if (original % current == 0 && current != 1) return 0;
     return isPrimeInner(original, current + 2);
 }
    
 // 判断是否为偶数
 int isPrime(int original) {
     return isPrimeInner(original, 1);
 }
    

递归模块

参数 current: 代表分裂初始值，参数 flag: 代表是否深入遍历，此处用于控制重复遍历的情况，如：original=10 时，second=8 时，两次会都会重复遍历 6/4/2，因此加入flag进行限制，只进行一次深入遍历！！

    
 void splitSumInner(int c, int current, int flag) {
     // 哥德巴赫为大于2的偶数
     if (c <= 2) return;
     // 如果 current 大于 c 的一半，即代表遍历完毕
     if (current >= (c / 2) + 1) return;
    
     // 第一次分裂 c 数值
     int a = current;
     int b = c - current;

     // 递归遍历并分裂 c 数值
     splitSumInner(c, ++ current, flag);
    
     // 判断能否深入遍历
     if (flag && a > 2 && isEven(a)) {
         // 深入遍历 分裂第一个子偶数
         splitSum(a, 0);
     }
    
     if (flag && b > 2 && isEven(b)) {
         // 深入遍历 分裂第二个子偶数
         splitSum(b, 0);
     }
        
     // 如果 c 为偶数，且 a,b 为素数，即满足哥德巴赫猜想，输出该数字。
     if (isEven(c) && isPrime(a) && isPrime(b)) {
         printf("\n%d=%d+%d\n",c, a, b);
     }
 }
    
 // original: 待分裂的原始数值（ps：会自动分裂 小于 original 下的所有数值）
 // flag: 1 代表分裂小于 original 下的所有数值；0 代表分裂当前 original 数值
 void splitSum(int original, int flag) {
     splitSumInner(original, 1, flag);
 }
    

主程序模块

    
 void goldbachConjecture(int n) {
     splitSum(n, 1);
 }

 int main() {
     do {
         printf("please enter a number:");
         int number = 0;
         scanf("%d", &number);
         goldbachConjecture(number);
     } while (1);
     return 0;
 }
    

时间复杂度对比

时间复杂度说白了就是算法中基本操作的执行次数，更通俗的说法，就是最深层循环内的语句。基本操作的重复执行次数是和算法的执行时间成正比的。下面我们来粗略计算一下上述算法的时间复杂度。

A 算法分析

在程序 A 中，与下面的代码相同，采用嵌套三层 for 循环的方式进行遍历：

```

for (int i = 1; i <= n; i ++) { // 第一层循环
        for (int j = 1; j <= i; j ++) { // 第二层循环
            for (int k = 1; k <= j; k ++) { // 第三层循环
                count ++;
                printf("%d*%d*%d\n", i, j, k);
            }
        }
    }

```

下面我们来剖析一下基本操作：

第一层 for 循环执行 n 次。
第二层 for 循环以 i 为规模分别执行 1,2,3,4……n-1,n 次，集一个公差为 1 的等差数列，总次数为 (n+1)*n/2。
第三层 for 循环采用排列组合来计算，举个例子，当 n = 3 时，有 10 次基本操作，我们把执行路径格式定义成 ijk，如下:
```
    
 111
 211  221  222
 311  321  322  331  332  333
    
```

B 算法分析

结论

以上时间复杂度只是笔者通过简单粗略的分析得出，仅供参考。通过上述分析，我们发现算法A与算法B时间复杂度是一样的，感兴趣的童鞋可以自己计算上述两种算法的时间复杂度。笔者通过测试发现，相同的问题规模，随着 n 的增大，算法B的时间复杂度要远小于算法A。如：n = 100 时，算法B遍历次数是 6380 次左右，算法A遍历次数高达 15569 次（论算法糟糕的可怕性…）。源码地址

Swift3.0 中 Strings/Characters 闲聊

Sun, 19 Feb 2017 09:37:00 +0000

前言

本篇文章主要浅析字符串\字符在 Swift 和 Objective-C 之间的区别及其简单用法。如有不妥的地方还望大家及时帮忙纠正。

字符串判空

在 swift 语言中空字符串初始化方式常用的有两种：

// 方式一：
let testEmptyString0 = ""

// 方式二：
let testEmptyString1 = String()

在开发过程中，我们应该如何用正确的方式来对字符串进行判空处理呢？

// 方式一：这种方式其实就是判断 characters.count 是否为0
if testEmptyString0.isEmpty {
    // empty
}

// 方式二：
if testEmptyString0.characters.count {
    // empty
}

// 方式三：
if (testEmptyString0 as NSString).length {
    // empty
}

字符串长度计算

Objective-C

首先我们来回忆一下，在 Objective-C 中字符串是怎么计算长度的？我想大家都应该知道。来看看苹果是怎么说的：

A string object is implemented as an array of Unicode characters (in other words, a text string). An immutable string is a text string that is defined when it is created and subsequently cannot be changed. To create and manage an immutable string, use the NSString class. To construct and manage a string that can be changed after it has been created, use NSMutableString.

A string object presents itself as an array of Unicode characters. You can determine how many characters it contains with the length method and can retrieve a specific character with the characterAtIndex: method.

看完这段话，想必大家都明白 NSString 是怎么实现的，以及如何获取其长度。通过 length 方法即可，那么 length 方法是如何实现的呢？苹果官方是这样说的：length 方法利用的是 UTF-16 表示的十六位编码单元数字为单位进行计算的（The number of UTF-16 code units in the receiver.）。UTF-16是什么？（感兴趣的童鞋可以看一下我之前写的一篇文章，字符编码（一）），此处不再详述。

Swift 3.0

Unicode 标量表示

在 Swift 中，字符和字符串都是基于 Unicode 标量建立的，采用21位二进制进行编码，共17个平面（除了基本多文种平面中的 UTF-16 代理对码位外，即U+D800至U+DFFF的编码空间），也就是说编码范围是U+0000-U+D7FFF 或者 U+E000-U+10FFFF。

A Unicode scalar is any Unicode code point in the range U+0000 to U+D7FF inclusive or U+E000 to U+10FFFF inclusive. Unicode scalars do not include the Unicode surrogate pair code points, which are the code points in the range U+D800 to U+DFFF inclusive.”

因此在 Swift 中，我们可直接采用 Unicode 标量的形式来表示字符或字符串，如：

let tingC = "\u{542C}" // 听

let xinC = "\u{5FC3}" // 心

可扩展的字形群集（簇）

在 Swift 中，每一个 Character 类型实例都代表单个可扩展的字形群集——即由一个或多个 Unicode 标量的序列组成的一个可读字符。

汉字 “听” 拼音为 tīng，以字母 ī 为例，用两种方式表示。第一种，可以直接用单个 Unicode 标量 ī (LATIN SMALL LETTER I WITH MACRON) 来表示，即 U+012B，该字形群集中包含一个 Unicode 标量。第二种，可以采用两个 Unicode 标量来表示，一个拉丁字母 i (LATIN SMALL LETTER I) 加上一个音调符（元音，COMBINING MACRON ACCENT）的标量，即 U+0069 U+0304，这样，当字母 i 被 Unicode 文字渲染系统时就会转换成 ī，该字形群集中包含两个 Unicode 标量。

let tingO = "t" + "\u{0069}" + "ng" // Prints "ting "

let tingPS = "t" + "\u{0069}" + "\u{0304}" + "ng" // Prints "tīng"

let tingPD = "t" + "\u{012B}" + "ng" // Prints "tīng"

这两种情况中，字母 ī 即代表了 Swift 中单个 Character 类型实例，也代表了一个可扩展的字形群集。想了解更多关于可扩展的字形群集，可参考此链接。

字符串长度

我们已经简单了解了可扩展的字形群集，现在我们再来看看 Swift 字符串中一些有意思的事。

Swift 中 String 类型，说白了就是 Character 类型实例的集合，在开发过程中，我们一般采用两种方式来求字符串的长度，第一种是转成 Objective-C 中的 NSString 类型，通过 length 方法来获取其长度，第二种是通过字符串属性 characters.count 的方式获得。本小节主要讨论第二种，本文会在结尾针对这两种方式进行比较。

在 Swift 中，细心的同学或许已经发现 tingPD 与 tingPS 字符串的字符数量是一样的：

print("tingPD-Count:\(tingPD.characters.count), tingPS-Count:\(tingPS.characters.count)") 
// Prints "tingPD-Count:4, tingPS-Count:4"

下面我们来解决此疑惑，笔者已在前文说过，Swift 中 String\Character 都是基于 Unicode 标量建立的，且 String 是 Character 的集合（即包含关系），而 String 属性 characters.count 其实就是计算 Character 的数量，那么 character 是怎么定义的呢，或者说什么才算是一个 character？此时又引出了一个概念——字形群集界限（Grapheme Cluster Boundaries），而”什么才算是一个 character？“这个问题就是字形群集界限给出的答案，想深入了解的同学请看：传送门。从用户感观（user-perceived）角度讲，不管是字符 ī(U+012B) 或者是 i(U+0069) 再加上一个音调符（U+0304），这两种表示最终的结果都是组成一个相同的可读的字符，因此 tingPD 与 tingPS 字符串中的字符数量是一样的。

通过上文的简单解释，可以得出两个结论：

一个字符串拼接一个字符时，不一定会更改字符串的数量，即 characters.count 的值。
在没有获取到字形群集界限的时候，无法计算出该字符串的字符数量，因此必须遍历字符串中全部的 Unicode 标量以获取字形群集界限，进而确定字符串的字符数量。

下面在看一个例子，相信大家都已明白输出结果的原因：

var iWord = "i"

print("iword-Count: \(iWord.characters.count)")
// Prints "iword-Count: 1"

iWord += "\u{0304}" // ī
print("iword-Count: \(iWord.characters.count)")
// Prints "iword-Count: 1"

.length 与 .characters.count 的区别

首先 .length 是 Objective-C 中字符串长度计算方法，而 .characters.count 可以说是 Swift 中字符串长度计算方法，由于 Swift 中 String 类型可以转成 Objective-C 中的 NSString 类型，因此在 Swift 开发过程中可能有如下两种写法：

print("tingPS.characters.count")
// Prints "4"
print("(tingPS as NSString).length")
// Prints "5"

从上述结果可看出，.length 方法得到的字符串长度为5，而 .characters.count 等于4，可能读者会有点懵，同一个字符串怎么计算的长度不一致？其实 .length 与 .characters.count 的计算原理在上文已经做了解释，本小节就简单总结一下：

.length 与 .characters.count 返回值不总是相同的，.length 方法是采用 UTF-16 表示的编码单元为单位进行计算并返回的，即字母 i(U+0069) 、音调符（U+0304）会当做两个字符，因而长度为2。.character.count 的值是通过字形群集界限来确定字符数量的，如还不理解请查看上文。（PS：其实这里也是 Swift 中采用索引的方式访问字符串的原因）

字符编码（一）

Fri, 27 Jan 2017 15:14:00 +0000

最近在看书的时候突然纠结于Unicode相关字符编码，查了一些资料，并写了这篇文章，顺带做下笔记，希望能帮到一些人。文章如果有写的不妥的或者不正确的地方还请大家纠正。

Unicode 编码

Unicode是一个符号集，它对世界上大部分的文字系统进行了整理、编码，使得电脑可以用更为简单的方式来呈现和处理文字。解决传统的字符编码方案的局限。

历史上存在两个独立的尝试创立单一字符集的组织，即国际标准化组织（ISO）和非营利机构统一码联盟。前者开发的 ISO/IEC 10646 项目，后者开发的统一码项目。因此最初制定了不同的标准。他们不久便发现对方的存在，大家为着相同的目的而工作，最后他们合并双方的工作成果。统一码（Unicode）的编码方式与ISO 10646的通用字符集（Universal Character Set, 简称UCS）概念相对应。

统一码的编码方式使用16位编码空间，也就是每个字符占用2个字节，最多可表示2^(16)个字符，基本满足各种语言的需求，且实际上16为编码空间并未完全使用，其中保留了大量空间作为未来备用。这里所说的16位编码空间即统一码的0号平面（也称“基本多文种平面”，Basic Multilingual Plane，简称BMP），目前统一码版本中另外定义了16个辅助平面，这样就需求21位编码空间，即 16+5 位，一共17个平面（不局限于），每个平面拥有2^(16)个代码点。如下表所示（摘自Wikipedia）：

ASCII

ASCII（“阿斯柯”）是国际上普遍采用的一种字符编码系统，由8位二进制进行编码，最高位恒为0，因此可以定义128个字符，其中包括10个十进制数字、52个英文大小写字母（A~Z, a~z）等。

UTF-8

UTF（Unicode Transformation Format, Unicode字符集转换格式），UTF-7、UTF-8、UTF-16、UTF-32、GB18030…只是Unicode的一种实现方式，即怎样将 Unicode 定义的数字转换成程序数据。

UTF-8 编码，以8位无符号整数为单位进行编码，是针对Unicode的可变长字符编码，UTF-8 是 ASCII 编码的父集，也就是说，UTF-8 与 ASCII 编码兼容，如：对于0x000000-0x00007F之间的字符，即前128个字符，UTF-8 编码与 ASCII 编码完全相同。这使得原来处理 ASCII 码字符的软件无须或只须做少部分修改，即可继续使用，UTF-8 编码应用广泛，基本所有互联网协议都支持 UTF-8 编码，是目前编码方式中优先采用的方式之一。

关于Unicode 与 UTF-8 编码之间的转换关系，如下表所示：

在基本多文种平面中约定00D800-00DFFF这范围用于UTF-16扩展标识辅助平面（即低位两个字节），在UTF-16 中会详细介绍。

举个例子，汉字“听”的 Unicode 编码是U+542C，转成UTF-8，步骤如下：

由上表可得出，“听”字的 Unicode 编码属于U+0800到U+D7FF区域，说明该字占用3个字节，按照1110xxxx-10xxxxxx-10xxxxxx进行填充。
U+542C换算成二进制：0101-0100-0010-1100。
从低位向高位填充，代替x，11100101-10010000-10101100。
得出汉字“听”的UTF-8编码：0xE590AC。

从Unicode 2.0开始，Unicode采用了与ISO 10646-1相同的字库和字码；ISO也承诺，ISO 10646将不会替超出U+10FFFF的UCS-4编码赋值，以使得两者保持一致。2003年11月 UTF-8 被 RFC 3629重新规范，只能使用原来Unicode定义的区域，U+0000到U+10FFFF。如果以上都能理解，那么下表就非常好理解了（摘自Wikipedia）：

之前有较多的人在微博上私信我@tingxins，关于这表格，疑惑颇多，因此在此处进行补充并简单解释一下，希望能帮到读者。C0，C1非常好理解，不再详述。我们来看看F5-FF的头字节，为什么是非法的？我们可以以 U+10FFFF 为例，转UTF-8编码后，可以得出头字节二进制流为11110100，即F4，基于 RFC 3629 规范，因此可得出大于F4头字节的可以理解成非法的或者不可能出现的编码，就7或8字节序列的头字节而言，更是违反了早期UTF-8编码不可超过6字节序列的规范。（更新于 2017-2-18）

UTF-8 小结

在UTF-8文件的开首，以EF,BB,BF代表，以显示这个文本文件是以UTF-8编码。
字节0xFE和0xFF在UTF-8编码中从未用到，同时，UTF-8以字节为编码单元，它的字节顺序在所有系统中都是一様的，没有字节序的问题，也因此它实际上并不需要BOM（字节顺序标记，Byte-Order Mark），但在UTF-16中用来标记存储方式（大端小端）。
ASCII和UTF-8两种编码方式下是一样的，可以说UTF-8是ASCII编码的父集。

现在我们已经知道了UTF-8的含义，以及其编码原理，下面我们来探究一下 UTF-16 编码方式。

UTF-16

UTF-16 编码，以16位无符号整数为单位进行编码。上文中所提及到的“基本多文种平面”的编码空间中保留了一块区域（从U+D800到U+DFFF），该区域不映射Unicode字符，UTF-16就是利用保留下来的0xD800-0xDFFF编码空间来对U+10000到U+10FFFF（即辅助平面）进行字符映射的。

在 UTF-16 编码中，从U+0000至U+D7FF以及从U+E000至U+FFFF的编码空间的映射关系同 Unicode，相对应于ISO通用字符集中的USC-2。从U+10000到U+10FFFF的编码空间，UTF-16用一对16比特长的码元（即32bit,4Bytes）进行编码，熟称代理对（Surrogate Pair）.

0xD800-0xDFFF编码空间分成两部分（即上述所说的代理对）：

UTF-16的高位代理：从U+D800至U+DBFF，也称前导代理（lead surrogates）。
UTF-16的低位代理：从U+DC00至U+DFFF，也称后尾代理（trail surrogates）。

UTF-16 辅助平面编码方式比较巧妙，从U+10000到U+10FFFF，共计FFFFF个，即2^(20)个，至少需要20位来表示，我们再来看代理对，先看高半区，从U+D800到U+DBFF，共计3FF个，即2^(10)个，同理低半区也是2^(10)个，正好为2^(20)个代理对，这也是“基本多语言平面”中保留不对应于Unicode字符的2048个码位的原因。下面我们来看一张表：

举个例子，古意大利字母”𐌀”的Unicode编码为U+10300，转成UTF-16，步骤如下：

在0x10300的基础上先减去0x10000 –> 0x00300，转成二进制：0000-0000-0011-0000-0000。
得出高10位（0000-0000-00）和低10位（11-0000-0000）
添加0xD800到高10位（不足补0），得出UTF-16高位：0xD800 + 0x0000 –> 0xD800
添加0xDC00到低10位（不足补0），得出UTF-16低位：0xDC00 + 0x0300 –> 0xDF00
得出古意大利字母”𐌀”的UTF-16BE编码：U+D800DF00

关于Unicode 与 UTF-16 编码之间的转换关系，如下表所示：

由上表可看出，UTF-16无法兼容ASCII编码。

UTF-16 存储形式

想必读者现在有这样一个疑惑，UTF-16 是以16位无符号整数位单位进行编码，即每个字符占用两个字节，如：在Mac和Window上，对字节顺序的理解是不一样的，这时就出现了一个问题，同一字节流可能会被解释为不同内容，以字符“心“为例，该字符十六进制编码为U+5FC3，按两个字节进行拆分：5F和C3，在Mac上读取时是从低字节开始，那么在Mac OS会认为此U+5FC3编码为U+C35F，显示字符为”썟”，而在Windows上从高字节开始读取，则编码为U+5FC3的字符为“心”。为了解决该问题，字节顺序标记（Byte-Order Mark, BOM）诞生，字符U+FEFF如果出现在字节流的开头，则用来标识该字节流的字节序，是高位在前还是低位在前，反之同理。这两种字节序在计算机我们通常称大端和小端，下面我们来继续探究一下。

大端存储和小端存储

大端存储（Big Endian, 简称BE）：一个字中的高位字节放在内存中这个字区域的低地址。小端存储（Little Endian, 简称LE）：即一个字中的低位字节放在内存中这个字区域的低地址处。

还是以古意大利字母”𐌀”为例，我们刚已计算出其UTF-16编码为U+D800DF00，如果采用大端存储，编码存储的序列为D800 DF00，采用小端存储，则为00D8 00DF。这个两个存储模式的区别在于字中字节的存储顺序不同，而字的存储顺序是相同的。再看几个例子（摘自Wikipedia）：

UTF-16 小结

在UTF-16文件的开首，以FEFF 或者 FFFE代表，以显示这个文本文件是以BE存储编码还是以LE存储编码。
UTF-16编码可以说是UCS-2的父集，对于小于0x10000的Unicode码，UTF-16编码就等于UCS码，也可以说UTF-16编码就等于Unicode标量值。
UTF-16 VS UTF-8，个人觉得这两种编码方式没有可比性，主要取决于字符本身主要集中在哪个平面，两者都是可变长度编码。
UTF-16 VS UCS-2¹，如果这个字超过U+FFFF（如：U+10000至U+10FFFF），那么就无法用UCS-2的格式编码，UTF-16可看成是UCS-2的父集。

tingxins

iOS 主题/皮肤之 SakuraKit

前言

SakuraKit

快速入门

效果

体验

配置文件

本地主题

步骤一

步骤二

步骤三

步骤四

远程主题

Block 方式

Delegate 方式

步骤一

步骤二

自定义下载操作

FQA

开源

广告

What's New in Swift 4 ?

前言

私有访问控制（”Private” Access Control）

类与协议（Class and Subtype Existentials）

Smart KeyPaths

Archival & Serialization

Encoders

关于字符串（String）

字形群集（Grapheme Cluster）

字符串改版（String Revision）

字符串跨行写法(Multi-Line String Literals)

单面区间语法（One-Sided Ranges）

序列协议（Sequence）

泛型下标（Generic Subscripts）

关于整型（Protocol-oriented integers）

字典与集合（Dictionary & Set enhancements）

Number 对象桥接（NSNumber bridging and Numeric types）

可变集合（MutableCollection）

Change filter to return Self for RangeReplaceableCollection

参考链接

广告

self.delegate = self?

前言

为何这么写？

莫名奇妙的现象

什么问题？

什么原因？

该如何解决？

闲谈

广告

iOS 输入限制之 InputKit

前言

InputKit

解耦

需求

Bug

开源

广告

Objective-C 中的对象、类、元类

前言

什么是类？

什么是对象？

什么是元类？

对象、类与元类的关系

理解与探究

理解

探究

By the way, happy Children’s Day!🤡🤡🤡

参考链接

广告

iOS 中网络请求同步

场景

NSURLConnection 中的同步请求

Dispatch_semaphore（信号量）

Dispatch_group（组）

总结

广告

02-希尔排序(Shell Sort)--(C语言)