但是这里并不是手把手教你如何自定义操作符，而是来说说在 Swift 2 和 3 中自定义操作符有什么不同吧，至于英文好的小伙伴可以参考SE-0077。

在 Swift 2 的情况下，我们通常通过下面的代码来定义自己的操作符:

// Swift 2
infix operator || {  
associativity: left  
precedence: 140  
}

func ||<T>(left: T, right: T) -> T {  
    // do something
}

而在 Swift 3 中我们则通过下面方式来进行替代:

// Swift 3
precedencegroup OrGroup {  
    associativity: left
    higherThan: AdditionPrecedence
    lowerThan: MultiplicationPrecedence
}

infix operator ||: OrGroup

func ||<T>(left: T, right: T) -> T {  
    // do something
}

整体上来说 Swift 2 和 3 之间是没有特别大的改动，只是将格式方面进行一种更加优雅的进化而已。虽然进行了这样的调整，但是有一点让宝宝不爽的是，已经定义的 group 在 Xcode 中竟然不给自动提示，特别是对于一些标准库中已经定义的 group 竟然也不给提示，这就让宝宝不开心了。目前的解决方案就是通过SE-0077这里来查询。

好了，最后我们来简单说说如何实现三元操作符吧，也当是给个自定义操作符的小结。我们都知道 Swift 跟其他大多数语言一样，对于三元操作符只提供了条件操作符 _ ? _ : _ ，那么如果我们想自己定义三元操作符怎么办呢？记得有一句话是这么说的，方法总比问题多~

其实我们可以创造一个伪三元操作符，就是用两个二元操作符来结合产生一个三元操作符,例如我们用 _ ??? _ ||| _ 来实现一下条件操作符的功能。首先我们先定义一下两个操作符：

// Swift 3
precedencegroup QuesGroup {  
    associativity: left
}

infix operator ???: QuesGroup

precedencegroup OrGroup {  
    associativity: left
    higherThan: QuesGroup
}

infix operator |||: OrGroup  

为什么这里的 OrGroup 要用 higherThan: QuesGroup 呢？我们设想一下，如果是 QuesGroup 中用 higherThan: OrGroup 的话，那么我们自定义的条件表达式就变成了 (_ ??? _) ||| _ 这种形式了，而是不是 _ ??? (_ ||| _) 这种形式。

其次我们来考虑一下条件操作符的流程，它是先查看?前的布尔值，然后再根据布尔值来决定返回哪一个部分，那么我们可以认为后面一部人是需要一个布尔值作为参数，返回数据的方法。并且根据其有短路的功能，我们可以采用 @autoclosure 来实现延迟加载以及短路的功能。并且根据上面的说法我们知道第二个参数和第三个参数其实是一个整体，并且根据前面来返回一个值。具体实现就如下面:

// Swift 3
func |||<T>(left: @autoclosure @escaping () -> T, right: @autoclosure @escaping () -> T) -> (Bool) -> T {  
    return { condition in
        if condition {
            return left()
        } else {
            return right()
        }
    }
}

func ???<T>(condition: @autoclosure @escaping () -> Bool, value: (Bool) -> T) -> T {  
    return value(condition())
}

代码非常简单，测试代码就更简单了：

let bTrue = true  
let bFalse = false

bTrue ??? "true value" ||| "false value"  
// 输出 true value
bFalse ??? "true value" ||| "false value"  
// 输出 false value

到这里就搞定了自定义"三元操作符"了~炒鸡简单。那么既然回了三元，那要定义四元，五元甚至更多元都可以采用相同的方式。只要分析好逻辑，并写出来就好了，好吧~就这样了。

宝宝去被窝里蓝瘦，香菇了~在录一个视频吓死你们

PS:具体代码可以从Github上获取。

如有问题或纠正, 可以联系@叫什么都不如叫Pluto-Y或在Github

我们在写OC的过程中经常有这么一种情况，就是我们需要写一个单例的情况。当然我们都会提供一个类方法类似于+(instancetype)sharedInstance之类的方法，巴特(but)我们的类的开山鼻祖都是NSObject,而这个鼻祖竟然提供了- (instancetype)init让别人来调用。这样宝宝就不开心了，宝宝很委屈，可是宝宝不说，我就是想让别人调用我的类方法来获得单例嘛~(呕吐~)

那么我们有没有办法让init方法私有化呢？或者是让小伙伴不要去调用它呢？答案是木有，因为我们知道OC没有私有化父类方法的做法，并且OC有非常强大的Runtime机制，致使我们没有办法私有化init方法。通常这个时候都会有个但是，要不然还写这篇文章干嘛。

其实虽然没有完全私有init的方法，但是我们可以通过一些手段来私有化它，让我们来一个一个的看看吧。

首先，我们可以用Clang的Attributes中的unavailable来让产生一个编译错误。怎么做呢？简单的要命,只要添加如下的声明即可:

- (instancetype)init __attribute__((unavailable("Disabled. Use +sharedInstance instead")));

那么会产生什么效果呢？

个人比较喜欢第一种，特别是在写一些开源的情况下，能在其他小伙伴调用的时候就直接给出编译错误。而且也能给出有用的信息提示小伙伴调用其他的方法进行替代。

第二种，通过使用NS_UNAVAILABLE来声明，具体使用方法与第一种类似:

- (instancetype)init NS_UNAVAILABLE;

效果如下：

而这种方式也是产生了一个编译错误，只是这种方式没有办法给出更加具体的提示信息，而细心的小伙伴可以发现，第二种方式的提示信息和第一种方式很像，为什么呢？我们来看看关于NS_UNAVAILABLE的定义:

#if !defined(NS_UNAVAILABLE)
#define NS_UNAVAILABLE UNAVAILABLE_ATTRIBUTE
#endif

我们可以从名字UNAVAILABLE_ATTRIBUTE看的出来，它应该也是用到了__attribute__只是应该提示信息是空字符串，应该等价于下面这两种情况，至少从展现的形式上来看应该是等价的。

- (instancetype)init __attribute__((unavailable));
- (instancetype)init __attribute__((unavailable));

第三种是在init方法中调用doesNotRecognizeSelector来搞定，也非常简单，大概如下

- (instancetype)init {
    [super doesNotRecognizeSelector:_cmd];
    return nil;
}

这种方法则会在调用的时候抛出一个类似于"unrecognized selector"信息的错误。这种形式其实没有直接指明真正的原因，可能会让用户丈二和尚摸不着头脑的赶脚，可能分分钟给你差评，所以这种方法可能会被以欺君罪分分钟被分尸~

第四种则是在init中通过断言或者异常的形式来让用户在运行的时候crash来提示用户，这个点很像第三点，但是通过断言或者异常我们可以通过给出相对应的错误信息提示用户来用其他方式来替代的方法，代码可以如下:

// 通过断言
- (instancetype)init {
    NSAssert(false,@"unavailable, use sharedInstance instead");
    return nil;
}

// 或者通过异常
- (instancetype)init {
    [NSException raise:NSGenericException
                format:@"Disabled. Use +[%@ %@] instead",
     NSStringFromClass([self class]),
     NSStringFromSelector(@selector(sharedInstance))];
    return nil;
}

这种方式虽然能提示正确的信息，可是用户必须要到运行的时候才能看到错误的信息，所以个人感觉还是偏迟了一点。

小小的总结一下，虽然提供了四种方式，但是本来还是喜欢第一种方式，毕竟第一种方式能在编译的过程中就能获得有用的信息，让其他的小伙伴即使使用正确的方式。好啦，就酱紫啦，小伙伴可以自己去动手尝试一下了~

PS:具体代码可以从Github上获取。

如有问题或纠正, 可以联系@叫什么都不如叫Pluto-Y或在Github

然而就UIButton是不是类簇，本王就纠结了。To be or not to be, that's a question. 这时候就应该装逼了，搬出莎士比亚这句话。 顺带就带着这个来说说类簇的问题。关于为什么纠结呢？因为很多地方包括书籍都提到UIButton是类簇，而我再Stack Overflow却找到这样一段话:

UIButton is not a class cluster at all. A class cluster is represented by a public abstract class, that means no instance variables, with a bunch of private concrete subclasses that provide the implementation of the abstract methods of the abstract class. UIButton on the other hand is a concrete class, none of its methods is abstract, and it has instance variables to store the value you pass through its arguments. The only problematic part is that +buttonWithType can instantiate subclasses instead of UIButton directly, thus it can be seen as a factory method, not a class-cluster...

然后我就懵逼了，根据类簇大体的概念我们知道至少说如果UIButton是一个抽象类的话，那么应该还存在一些private的私有类来实现具体的细节。那么我们的任务就是就是找到这些私有类，之前看了@我就叫Sunny怎么了 的一篇文章从NSArray看类簇后发现至少UIButton中没办法用这种方法，于是就想说用LLDB断点一下，用了下面这条命令：

breakpoint set -F '+[UIButton buttonWithType:]'  

得到了这样一段汇编：

UIKit`+[UIButton buttonWithType:]:  
->  0x1063251e5 <+0>:    pushq  %rbp
..... // 省略
    0x106325297 <+178>:  movq   0x972c02(%rip), %rdi      ; (void *)0x0000000106cbabf8: UIButton
    0x10632529e <+185>:  movq   0x93cf6b(%rip), %rsi      ; "alloc"
    0x1063252a5 <+192>:  movq   0x9c0f34(%rip), %rbx      ; (void *)0x0000000105650800: objc_msgSend
    0x1063252ac <+199>:  callq  *%rbx
    0x1063252ae <+201>:  movq   0x93ce2b(%rip), %rsi      ; "initWithFrame:"
..... // 省略
    0x10632531c <+311>:  movq   0x97427d(%rip), %rdi      ; (void *)0x0000000106cbad10: UIPopoverButton
    0x106325323 <+318>:  movq   0x93cee6(%rip), %rsi      ; "alloc"
    0x10632532a <+325>:  movq   0x9c0eaf(%rip), %rbx      ; (void *)0x0000000105650800: objc_msgSend
    0x106325331 <+332>:  callq  *%rbx
    0x106325333 <+334>:  movq   0x9557a6(%rip), %rsi      ; "initWithFrame:buttonType:"
    0x10632533a <+341>:  movq   -0x38(%rbp), %rcx
..... // 省略
    0x1063253c5 <+480>:  movq   0x9741c4(%rip), %rdi      ; (void *)0x0000000106cbac48: UIRoundedRectButton
    0x1063253cc <+487>:  jmp    0x106325553               ; <+878>
    0x1063253d1 <+492>:  movb   %r14b, -0x81(%rbp)
    0x1063253d8 <+499>:  movq   0x972ac1(%rip), %rdi      ; (void *)0x0000000106cbabf8: UIButton
    0x1063253df <+506>:  jmp    0x106325553               ; <+878>
    0x1063253e4 <+511>:  movb   %r14b, -0x81(%rbp)
    0x1063253eb <+518>:  movq   %rbx, -0x80(%rbp)
    0x1063253ef <+522>:  movq   0x973262(%rip), %rdi      ; (void *)0x0000000106cb45a0: UINavigationButton
    0x1063253f6 <+529>:  movq   0x93ce13(%rip), %rsi      ; "alloc"
    0x1063253fd <+536>:  movq   0x9c0ddc(%rip), %rbx      ; (void *)0x0000000105650800: objc_msgSend
    0x106325404 <+543>:  callq  *%rbx
    0x106325406 <+545>:  movq   0x9556cb(%rip), %rsi      ; "initWithTitle:style:"
    0x10632540d <+552>:  xorl   %edx, %edx
    0x10632540f <+554>:  xorl   %ecx, %ecx
    0x106325411 <+556>:  jmp    0x106325475               ; <+656>
    0x106325413 <+558>:  movb   %r14b, -0x81(%rbp)
    0x10632541a <+565>:  movq   %rbx, -0x80(%rbp)
    0x10632541e <+569>:  movq   0x973233(%rip), %rdi      ; (void *)0x0000000106cb45a0: UINavigationButton
    0x106325425 <+576>:  movq   0x93cde4(%rip), %rsi      ; "alloc"
    0x10632542c <+583>:  movq   0x9c0dad(%rip), %rbx      ; (void *)0x0000000105650800: objc_msgSend
    0x106325433 <+590>:  callq  *%rbx
    0x106325435 <+592>:  movq   0x95569c(%rip), %rsi      ; "initWithTitle:style:"
    0x10632543c <+599>:  xorl   %edx, %edx
    0x10632543e <+601>:  movl   $0x1, %ecx
    0x106325443 <+606>:  jmp    0x106325475               ; <+656>
    0x106325445 <+608>:  movb   %r14b, -0x81(%rbp)
    0x10632544c <+615>:  movq   %rbx, -0x80(%rbp)
    0x106325450 <+619>:  movq   0x973201(%rip), %rdi      ; (void *)0x0000000106cb45a0: UINavigationButton
    0x106325457 <+626>:  movq   0x93cdb2(%rip), %rsi      ; "alloc"
    0x10632545e <+633>:  movq   0x9c0d7b(%rip), %rbx      ; (void *)0x0000000105650800: objc_msgSend
    0x106325465 <+640>:  callq  *%rbx
    0x106325467 <+642>:  movq   0x95566a(%rip), %rsi      ; "initWithTitle:style:"
..... // 省略
    0x10632549e <+697>:  movq   0x9740f3(%rip), %rdi      ; (void *)0x0000000106cbacc0: UITexturedButton
    0x1063254a5 <+704>:  jmp    0x106325553               ; <+878>
    0x1063254aa <+709>:  movb   %r14b, -0x81(%rbp)
    0x1063254b1 <+716>:  movq   %rbx, -0x80(%rbp)
    0x1063254b5 <+720>:  movq   0x9740d4(%rip), %rdi      ; (void *)0x0000000106cbac48: UIRoundedRectButton
    0x1063254bc <+727>:  movq   0x93cd4d(%rip), %rsi      ; "alloc"
    0x1063254c3 <+734>:  movq   0x9c0d16(%rip), %r14      ; (void *)0x0000000105650800: objc_msgSend
..... // 省略
    0x106325538 <+851>:  movq   0x974069(%rip), %rdi      ; (void *)0x0000000106cbad60: _UIPlacardButton
    0x10632553f <+858>:  jmp    0x106325553               ; <+878>
    0x106325541 <+860>:  movb   %r14b, -0x81(%rbp)
    0x106325548 <+867>:  movq   %rbx, -0x80(%rbp)
    0x10632554c <+871>:  movq   0x97405d(%rip), %rdi      ; (void *)0x0000000106cbadb0: _UIShortPlacardButton
    0x106325553 <+878>:  movq   0x93ccb6(%rip), %rsi      ; "alloc"
    0x10632555a <+885>:  movq   0x9c0c7f(%rip), %rbx      ; (void *)0x0000000105650800: objc_msgSend
    0x106325561 <+892>:  callq  *%rbx
    0x106325563 <+894>:  movq   0x93cb76(%rip), %rsi      ; "initWithFrame:"
..... // 省略

看到这里小伙伴不要害怕，吃口粑粑冷静一下。我不是要大家看每一句话是什么意思，大家可以注意一下每一行最后又Button关键字的地方，会发现一堆我们平时没见过的一些Button,如UIPopoverButton, UIRoundedRectButton, UINavigationButton, UITexturedButton, _UIPlacardButton以及_UIShortPlacardButton等。至少我们发现了我们所说的private的私有类，那么我们就可以知道其实这里的UIButton是一个类簇。

那么我们也用官网的图来说说类簇的用处：

可以从上图看到虽然官方的实现细节根据不同的类型有不同的实现，但是我们所需要记得以及交互的接口都可以通过NSNumer来进行交互。而如果我们自己在设计类簇的时候也可能通过这种方式来进行隐藏一些细节的实现。

但是在设计自己的类簇的过程中需要注意一下几点：

• 首先要定义好抽象基类
• 其次需要指明子类需要重写的方法
• 最后提供一个比较好的文档说明方面其他人读写

最后就到这吧，小伙伴各回各家，各找各妈吧~

PS:具体代码可以从Github上获取。

如有问题或纠正, 可以联系@叫什么都不如叫Pluto-Y或在Github

那么不废话，新来看看今天的素材都有哪些吧：

// <objc/runtime.h>
void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)  
id objc_getAssociatedObject(id object, const void *key)  
void objc_removeAssociatedObjects(id object)  

首先可以看到最开始的<objc/runtime.h>知道如果要用要建立关联的话，首先要引入这个头文件。其次，在iOS4以及OS X 10.6以后提供了这三个API，而这三个API有点类似NSDictionary(或者Dictionary)的key:value模式，只不过这里需要指定需要绑定哪个对象上。

这样说好像有点乏味，我们拿一个开源库里面最牛逼库之一的AFN里面的代码来看下:

@interface UIImageView (_AFNetworking)
@property (readwrite, nonatomic, strong, setter = af_setActiveImageDownloadReceipt:) AFImageDownloadReceipt *af_activeImageDownloadReceipt;
@end

@implementation UIImageView (_AFNetworking)

- (AFImageDownloadReceipt *)af_activeImageDownloadReceipt {
    return (AFImageDownloadReceipt *)objc_getAssociatedObject(self, @selector(af_activeImageDownloadReceipt));
}

- (void)af_setActiveImageDownloadReceipt:(AFImageDownloadReceipt *)imageDownloadReceipt {
    objc_setAssociatedObject(self, @selector(af_activeImageDownloadReceipt), imageDownloadReceipt, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

@end

可以看得出，这里使用了Associated Object为UIImageView的Category添加了一个新的属性。其实这个也是Associated Object最常用的场景，就是为Category添加属性。总所周知，在Objective-C中的Category是没有办法添加新的属性，这个可以说是一个非常麻烦的地方，因为我们经常为一个已经存在的类中希望添加一个属性来完善这个类新添加的功能。

But，苹果不如我们意啊，竟然不给我们权限为Category添加属性，然后程序员是伟大的，老是能找到方法搞小动作。

其实整体用法上面就可以看到了，这里最后说一句，关于其中的key，通常的做法有两种，一种是通过属性的getter方法的@selector作为key（比如上面的方式），还有一种方式通过一个静态变量的地址作为key，比如下面的方式：

static char kAssociatedObjectKey;  
objc_getAssociatedObject(self, &kAssociatedObjectKey);  

好了，到此为止吧。好像这节没什么代码~别打我哟

PS:具体代码可以从Github上获取。

如有问题或纠正, 可以联系@叫什么都不如叫Pluto-Y或在Github

OC中将这两种分别用NS_ENUM与NS_OPTIONS来区分，而Swift中则用普通的enum以及OptionSetType来搞定。那么该如何使用以及在使用过程中有什么需要注意的呢？且听下回分解(分解你大爷啊！)

咳咳，首先我们先来看看NS_ENUM以及NS_OPTIONS是个什么东东吧~

#if (__cplusplus && __cplusplus >= 201103L      \
        && (__has_extension(cxx_strong_enums)   \
        || __has_feature(objc_fixed_enum))      \
    ) ||                                        \
    (!__cplusplus && __has_feature(objc_fixed_enum))
        #define NS_ENUM(_type, _name) enum _name : _type _name; enum _name : _type
    #if (__cplusplus)
        #define NS_OPTIONS(_type, _name) _type _name; enum : _type
    #else
        #define NS_OPTIONS(_type, _name) enum _name : _type _name; enum _name : _type
    #endif
#else
    #define NS_ENUM(_type, _name) _type _name; enum
    #define NS_OPTIONS(_type, _name) _type _name; enum
#endif

其实呢，他就是一个宏定义。那么我们来一个一个的分析每个宏定义是如何生效的。假设我们写下下面这段话:

typedef NS_ENUM(NSUInteger, MyNSEnum) {  
    MyNSEnumValue1,
    MyNSEnumValue2,
    MyNSEnumValue3,
    MyNSEnumValue4
};

那么通过上面的宏定义应该就会变成下面这段话:

// 情况一：如果满足上面一堆的条件
typedef enum MyNSEnum : NSUInteger;  
enum MyNSEnum : NSUInteger {  
    //具体内容
};
// 情况二：如果不满足上面一堆的条件
typedef NSUInteger MyNSEnum;  
enum {  
    //具体内容
};

可以看出来NS_ENUM是做到向下兼容了，在一些低版本的，不兼容一些特性的情况下则用情况二的方式来定义枚举，而在新版本的情况下，则采用情况一来定义。当然对于上面一些条件，有兴趣的小伙伴可以自己查查资料了解一下。

估计还有一部分小伙伴习惯直接用enum之类的来定义枚举，但是还是建议大家尽量用NS_ENUM以及NS_OPTIONS，毕竟苹果提供了这个新的特性，而且它也支持了向下兼容。并且现在大家的都习惯性用这个，如果写这个也方面大家读懂以及直观看懂是NS_ENUM还是NS_OPTIONS。而且这也是目前许多网站和数据推荐的做法，也是一个共识。（路人甲：我就不用，我就不用，你特么来打我啊~）额，你老大，你了不起咯。

那么除了这个好处以外还有没有什么其他的好处呢？在switch块中，我们如果用到的是NS_ENUM的话，尽量不要用default:，这样的话如果没有写全所有的枚举类型的话，会出现warning，这样也方便了我们如果在使用枚举+switch的过程中，如果添加了一个新的枚举的值，那么同时也会出现warning。就像下图:

然后普通的枚举就尽量用NS_ENUM。对于那些可以同时存在的，比如一些配置项，一些控制某些事件的开关之类的枚举我们就尽量用NS_OPTIONS，例如我们在用NSCalendarUnit，还有动画里面的UIViewAnimationOptions以及Autoresizing里面用到的UIViewAutoresizing都是NS_OPTIONS类型，而这种类型我们经常都会用位操作符来进行控制。

我们从UIKit中看下UIViewAutoresizing吧，代码如下:

typedef NS_OPTIONS(NSUInteger, UIViewAutoresizing) {  
    UIViewAutoresizingNone                 = 0,
    UIViewAutoresizingFlexibleLeftMargin   = 1 << 0,
    UIViewAutoresizingFlexibleWidth        = 1 << 1,
    UIViewAutoresizingFlexibleRightMargin  = 1 << 2,
    UIViewAutoresizingFlexibleTopMargin    = 1 << 3,
    UIViewAutoresizingFlexibleHeight       = 1 << 4,
    UIViewAutoresizingFlexibleBottomMargin = 1 << 5
};

而通常NS_OPTIONS都是这样定义的，即通过所需的类型在二进制中的某一个位置的不为0来进行操作，这样也方便了我们通过或(或者与)来进行控制那些属性是需要的，那些属性不需要的来进行不同的操作。

看完OC中的做法，那么我们来看看Swift中是怎么操作的呢？估计普通的枚举大家都用到烂了，就是enum了，那我就不多说废话了，对于NS_OPTIONS在Swift中的替代方案是什么呢？

如果用过Swift1.2的小伙伴估计想到了以前用的Xcode snippet，通常都是这个:

struct <# Options #> : RawOptionSetType, BooleanType {  
    let rawValue: UInt
    init(nilLiteral: ()) { self.value = 0 }
    init(_ value: UInt = 0) { self.value = value }
    init(rawValue value: UInt) { self.value = value }
    var boolValue: Bool { return value != 0 }
    var rawValue: UInt { return value }
    static var allZeros: <# Options #> { return self(0) }

    static var None: <# Options #>         { return self(0b0000) }
    static var <# Option #>: <# Options #>     { return self(0b0001) }
    // ...
}

看到这里，估计小伙伴可以体会到在1.2的时候那酸爽真是够了，如果自己手写一行一行的敲，估计好浪费时间啊。所以之前都是通过用Xcode snippet来进行操作的。而在2.2中我们有事如何写的呢？我们来尝试一下：

struct NSCOptions : OptionSetType {  
    let rawValue: UInt
    static let None = NSCOptions(rawValue: 0)
    static let Value1 = NSCOptions(rawValue: 0b0001)
    static let Value2 = NSCOptions(rawValue: 0b0010)
    static let Value3 = NSCOptions(rawValue: 0b0100)
    static let Value4 = NSCOptions(rawValue: 0b1000)
}

发现没相对Swift1.2简洁了不是一点两点，是不是很高兴。好哒，妹子上来亲我一口吧~（pia~流氓）。咳咳，言归正传，是不是比之前方便很多，那么我们来看下OptionSetType是什么鬼？

可以看得出来左边这个就是我们经常enum中用来创建的构造方法，右边这个从最上面说起，上面的Equatable是用来判等用的，也就是我们经常用的!=和==的协议，而右边这个则是我们之前说过的字面量里面的数组字面量(关于字面量一节小伙伴们可以看看字面量(Literal))，也就是我们可以用[]来表示一组Options的集合，而不是通过|来表达，这样用起来也更加人性化。而SetAlgebraType则提供了集合的操作，比如并集，交集，异或，插入等等。这里就不对他们进行深究了，放过他们吧。俗话说得好，冤冤相报何时了~

好了，最终关于枚举我们就说到这里吧，剩下的小伙伴们可以自己去玩玩。不过别玩出火哟~

PS:具体代码可以从Github上获取。

如有问题或纠正, 可以联系@叫什么都不如叫Pluto-Y或在Github

记得以前学Java的时候最喜欢这种不断点方法调用了，以前一直在想如果在OC中要实现链式编程的话会是怎么样子的呢？嗯~大概应该是这样的吧:

// str是一个NSString
[[str substringFromIndex:10] substringToIndex:12];

想到这个我真的是日了🐶了，要让我不断用空格来调用，OMG，算了吧。知道后来Block的出现，我看到了曙光，因为我看到了Block竟然可以用()来调用Block，终于又看到了我可爱的()了。

但是接下来我还是一步一步的来看看如何做。那么我们假设我们现在要在OC中实现链式编程，那么最直接的做法就是在方法调用后直接返回对应的对象即可，那么假设我们有一个NSCStudent对象，他有study和play的方法，如果按照OC的方法来进行链式的话，应该就是这样[[student study] play], 那么NSCStudent的方法实现大概应该是这样：

@implementation NSCStudent

- (instancetype)study {
    NSLog(@"The student study");
    return self;
}

- (instancetype)play {
    NSLog(@"The student play");
    return self;
}

@end

这样我们就可以用[[student study] play]来调用了。（路人甲：“不对啊，我试过，如果是这样实现也可以用student.study.play来调用啊”）保安，保安，有人来打乱，拖出去乱棍打死~。 好吧，我承认如果是这种实现可以，那么如果带参数的情况下呢，那你是不是日了🐶了。

其实这种方式也没有什么，就是'['和']'特别多，有的时候都分不清楚哪一层是哪一层了，这个是我我就怀念起了Java里面通过'.'来调用方法了。那么接下来我们想想如何像Mansory通过'.'和'()'来实现一些带参数的链式编程呢？

其实上面也提到了，既然Block可以通过'()'来调用，并且我们也能通过'.'来调用不带参数的方法，那么我们通过写一个不带参数的方法，并且返回Block，且把原来的参数放到Block中即可。我们把上面的NSCStudent中添加一个方法playWith并且返回Block，那么代码应该如下：

- (NSCStudent * (^)(NSString *))playWith {
    return ^id(NSString *name) {
        NSLog(@"The student play with %@", name);
        return self;
    };
}

接下来我们来分析一下如果我写了student.study.playWith的话会出现什么，当然首先肯定是study还是跟原来一样，那么调用playWith之后将返回一个Block，并且Block需要一个NSString的参数。那么按照之前的理论就是可以通过'()'来调用Block的话，我们可以这样写student.study.playWith(@"Girl")，并且从代码中我们可以看得出来调用Block的结果是返回了一个NSCStudent的Block。那么酱紫的话，劳资是不是有可以继续点来调用NSCStudent的方法了。

那么我就可以student.study.playWith(@"Girl1").playWith(@"Girl2").playWith(@"Girl3").playWith(@"Girl4").playWith(@"Girl5")....，我去，那么不是我可以群*了，咳咳，说错了，是我就可以无限调用函数了，其实就是这么简单。

那么如果在Swift中要实现链式编程的话，就更特么简单了。毕竟Swift就是通过'.'和'()'来调用的，只要在方法后返回自身就好了。那么我们来稍微看下代码吧:

struct NSCStudent {  
    func study() -> NSCStudent {
        print("The student study")
        return self
    }

    func playWith(name: String) -> NSCStudent {
        print("The student play with \(name)")
        return self
    }
}

let student = NSCStudent()  
student.study().playWith("Girl")  

好了，就酱紫吧，各位小老婆们伺候我就寝吧~

PS:具体代码可以从Github上获取。

如有问题或纠正, 可以联系@叫什么都不如叫Pluto-Y或在Github

当然，其实问大部分人说这两个是什么作用，或者是除了这两个还知道什么的情况下。很多人都只知道这两个是用来组织代码的。然而这样说也对也不对，确实我们常用的情况是都是用这两个来组织代码的，但是如果看过很多开源的人肯定看过一下的形式的代码：

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-retain-cycles"
.... //一些代码
#pragma clang diagnostic pop

那么这些代码是拿来干嘛的呢？且听我慢慢道来。

确实在我们日常工作中，经常用到#pragma mark或者// MARK:来组织代码，并且大家都知道组织代码有两种形式: 一种是用来分组，一种是用来标注。具体如何展示大家也当我废话，看下下面的代码吧：

// Objective-C 代码
- (void)viewDidLoad {
    [super viewDidLoad];
    [self initAll];
}

#pragma mark Custom functions
- (void)initAll {
    ...
}

#pragma mark - UITableViewDataSources
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
    return 10;
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    return [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:@"CELL"];
}

#pragma mark - UITableViewDelegate
- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    NSLog(@"点击了%li行", indexPath.row);
}

下面是Swift代码：

// Swift 代码
override func viewDidLoad() {  
    super.viewDidLoad()
    initAll()
}

// MARK: Custom function
private func initAll() {  
    ...
}

// MARK: - UITableViewDataSource
func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {  
    return 10
}

func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {  
    return UITableViewCell(style: .Default, reuseIdentifier: "CELL")
}

// MARK: - UITableViewDelegate
func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {  
    print("点击了\(indexPath.row)行")
}

那么效果呢，大家也都知道，就是下图这样：

其实主要就是两点，一个就是后面没有跟'-'的情况，这种情况就不会出现分组，只是当单纯的有注释，另一种就是带'-'的情况，那么这种情况就会添加一条水平分割线，也就是出现了分组。那么在我们写代码的过程中最好将代码相关性比较强的都分到同一个组别当中去。这样针对以后维护的人员对代码的也能跟快读懂代码。这也就是我们常说的要做注释，增加代码的可读性。

关于这个的用法就不多说了，大家去试试，并且大部分都知道这个特性。那么我们围绕着这个说说其他的特性吧，首先我们先来说说一个可以装逼的神器，就是用它来局部的控制某个警告的开启与关闭，也就是我们文章开头说的那个：

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-variable"
// 一段代码
#pragma clang diagnostic pop

估计很多小伙伴经常在很多开源代码里面可以看到这段代码，这个代码呢，其实就用来关闭警告的，这样在你有些写一些代码的时候需要忽略某些警告的时候特别有用。具体用法我们就用上面这个来试试吧。

#pragma mark - UITableViewDataSources
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-variable"
    int unusedInt;
#pragma clang diagnostic pop
    return 10;
}

通过下面这段代码忽略没有使用unsedInt这个属性的警告了。那么问题来了，就有人问了：“我怎么知道后面那个"-Wunsed-variable"这个字符串应该是什么呢”？想知道吗？你猜啊，就不告诉你就不告诉你，就不告诉你！(pia~一脱鞋过来，这是三天不打上房揭瓦！)

好吧，其实有两种手段，一种就是网上有人整理了一个网站Which Clang Warning Is Generating This Message?，里面包含了许多警告抑制的字符串，大家可以参考一下。另外一个方案呢，就是通过Xcode来查找，具体步骤如下图:

先选择Report Navigator，然后选择最后一个日志，选择所有信息，然后去日志中查看你需要的警告信息，并且在哪里警告它都会罗列出来。通过这种手段，我们就可以装逼添加#pragma clang diagnostic ignored的信息了。

当然对于上面这种特殊的为使用的警告，还可以用下面这种形式来关闭警告：

// Objective-C 代码
NSString *unsedString;  
#pragma unused(unsedString)

好了，学了这一招就可以在自己代码里面装逼了，那么我们在说说OC中还有哪些好用的功能呢？竟然说到警告，那么我们可以在说如何自己手动的产生警告吧，有两种方式，具体可以看下面的代码:

#pragma message "This is a warning"
#warning "This is another warning"

具体效果如何呢？看看下面这张图:

是不是觉得很神奇，其实在我们日常工作中可以通过这种代码为暂时还没有打算好填写内容的地方打上一个warnings,然后这样我们在我们写代码的过程中就可以注意到这些warning，这样之后我们就可以来填坑了。毕竟我是一个有代码洁癖的人，对于自己代码中有很多警告是完全不能够忍受的，希望大家也能养成这个习惯。 其实除了警告以外，还有一个#error可以用，大家可以尝试一下。

下面我们来说说在Swift中除了MARK以外我们还可以用什么呢：其实还有两个我们可以用的，在大家写Swift过程中可以用到// TODO:与// FIXME:相当于OC中只有警告来指定，我更喜欢Swift中的这种用法，因为它的目的性更明确，其用法与MARK一致，具体用法和效果就看下面吧:

具体内容就到此为止吧，深入的地方就等你们告诉我了哟。感谢大家的阅读，退下吧，朕要洗白白去了。

PS:具体代码可以从Github上获取。

如有问题或纠正, 可以联系@叫什么都不如叫Pluto-Y或在Github

// Objective-C
NSString *aString = @"Hello";  
NSNumber *aNumber = @5;  
BOOL aBool = YES;  
NSArray *arr = @[@"Hello", @"World"];  
NSDictionary *dic = @{@"key1": @"value1", @"key2": @"value2"};

// Swift
let aString = "World"  
let aNumber = 6  
let aBool = false  
let arr = ["Hello", "World"]  
let dic = ["key1": "value1", "key2": "value2"]  

字面量在我们工作中几乎是无处不在，然而其实Objective-C与Swift中这两个的区别还是挺大的。Objective-C几乎不可以自定义字面量转换成类型，毕竟OC中的字面量转换成类型是在Clang中进行支持的。而在Swift中是通过一些列的字面量转换协议(Literal Convertible Protocols)来进行字面量转换成具体类型就好了。所以Swift中我们可以通过自定义某一个字面量转换成具体类型。

那么Objective-C是如何实现这些，我们一次来说吧，就说说这些常见的字面量。

这里我们通过clang -rewrite-objc NSCLiteralController.m来进行看看Clang都为我们做了什么

我们来看看结果吧:

#ifndef __NSCONSTANTSTRINGIMPL
struct __NSConstantStringImpl {  
  int *isa;
  int flags;
  char *str;
#if _WIN64
  long long length;
#else
  long length;
#endif
};
#ifdef CF_EXPORT_CONSTANT_STRING
extern "C" __declspec(dllexport) int __CFConstantStringClassReference[];  
#else
__OBJC_RW_DLLIMPORT int __CFConstantStringClassReference[];  
#endif
#define __NSCONSTANTSTRINGIMPL

static __NSConstantStringImpl __NSConstantStringImpl__var_folders_fm_xbb226bx49n28m4sg6sbf_hr0000gn_T_NSCLiteralController_a32604_mi_1 __attribute__ ((section ("__DATA, __cfstring"))) = {__CFConstantStringClassReference,0x000007c8,"Hello",5};  
static __NSConstantStringImpl __NSConstantStringImpl__var_folders_fm_xbb226bx49n28m4sg6sbf_hr0000gn_T_NSCLiteralController_a32604_mi_2 __attribute__ ((section ("__DATA, __cfstring"))) = {__CFConstantStringClassReference,0x000007c8,"Hello",5};  
static __NSConstantStringImpl __NSConstantStringImpl__var_folders_fm_xbb226bx49n28m4sg6sbf_hr0000gn_T_NSCLiteralController_a32604_mi_3 __attribute__ ((section ("__DATA, __cfstring"))) = {__CFConstantStringClassReference,0x000007c8,"World",5};  
static __NSConstantStringImpl __NSConstantStringImpl__var_folders_fm_xbb226bx49n28m4sg6sbf_hr0000gn_T_NSCLiteralController_a32604_mi_4 __attribute__ ((section ("__DATA, __cfstring"))) = {__CFConstantStringClassReference,0x000007c8,"key1",4};  
static __NSConstantStringImpl __NSConstantStringImpl__var_folders_fm_xbb226bx49n28m4sg6sbf_hr0000gn_T_NSCLiteralController_a32604_mi_5 __attribute__ ((section ("__DATA, __cfstring"))) = {__CFConstantStringClassReference,0x000007c8,"value1",6};  
static __NSConstantStringImpl __NSConstantStringImpl__var_folders_fm_xbb226bx49n28m4sg6sbf_hr0000gn_T_NSCLiteralController_a32604_mi_6 __attribute__ ((section ("__DATA, __cfstring"))) = {__CFConstantStringClassReference,0x000007c8,"key2",4};  
static __NSConstantStringImpl __NSConstantStringImpl__var_folders_fm_xbb226bx49n28m4sg6sbf_hr0000gn_T_NSCLiteralController_a32604_mi_7 __attribute__ ((section ("__DATA, __cfstring"))) = {__CFConstantStringClassReference,0x000007c8,"value2",6};


// 真实代码通过转换后的c++源码
NSString *aString = (NSString *)&__NSConstantStringImpl__var_folders_fm_xbb226bx49n28m4sg6sbf_hr0000gn_T_NSCLiteralController_a32604_mi_1;  
NSNumber *aNumber = ((NSNumber *(*)(Class, SEL, int))(void *)objc_msgSend)(objc_getClass("NSNumber"), sel_registerName("numberWithInt:"), 5);  
BOOL aBool = ((bool)1);  
NSArray *arr = ((NSArray *(*)(Class, SEL, const ObjectType *, NSUInteger))(void *)objc_msgSend)(objc_getClass("NSArray"), sel_registerName("arrayWithObjects:count:"), (const id *)__NSContainer_literal(2U, (NSString *)&__NSConstantStringImpl__var_folders_fm_xbb226bx49n28m4sg6sbf_hr0000gn_T_NSCLiteralController_a32604_mi_2, (NSString *)&__NSConstantStringImpl__var_folders_fm_xbb226bx49n28m4sg6sbf_hr0000gn_T_NSCLiteralController_a32604_mi_3).arr, 2U);  
NSDictionary *dic = ((NSDictionary *(*)(Class, SEL, const ObjectType *, const id *, NSUInteger))(void *)objc_msgSend)(objc_getClass("NSDictionary"), sel_registerName("dictionaryWithObjects:forKeys:count:"), (const id *)__NSContainer_literal(2U, (NSString *)&__NSConstantStringImpl__var_folders_fm_xbb226bx49n28m4sg6sbf_hr0000gn_T_NSCLiteralController_a32604_mi_5, (NSString *)&__NSConstantStringImpl__var_folders_fm_xbb226bx49n28m4sg6sbf_hr0000gn_T_NSCLiteralController_a32604_mi_7).arr, (const id *)__NSContainer_literal(2U, (NSString *)&__NSConstantStringImpl__var_folders_fm_xbb226bx49n28m4sg6sbf_hr0000gn_T_NSCLiteralController_a32604_mi_4, (NSString *)&__NSConstantStringImpl__var_folders_fm_xbb226bx49n28m4sg6sbf_hr0000gn_T_NSCLiteralController_a32604_mi_6).arr, 2U);  

或许有小伙伴看到上面一堆看不懂的东东直呼，尼玛，太长了，不看。然而请稍安勿躁，难道我还会骗你吗？（我去，上次你说去看那美女洗澡，结果是80岁的老太太。）咳咳，开玩笑。不要急我们一点一点分析，先从具体的运行代码开始分析。

我们可以看到字符串的字面量被转换成了struct __NSConstantStringImpl的类型,也就是字符串的字面量转换成了一个结构常量，然后通过类型转换成了NSString类型。而NSNumber则是通过[NSNumber numberWithInt:]的函数将其转换成了NSNumber类型,而如果小伙伴试试其他的数字，比如float或者double等数字的话，会发现clang会替我们自动选择最适合的构造函数进行转换，不过目前有点纠结的一点就是long double类型是没有办法通过@来进行转换， 并且如果之前看过Tagged Pointer一节的小伙伴可以尝试一下，会发现其实这里的NSNumber其实是一个Tagged Pointer，感兴趣的小伙伴可以自己去看下。

而至于数组和字典则是在调用其自己的构造函数，[NSArray arrayWithObjects:count:]和[NSDictionary dictionaryWithObjects:forKeys:count:],然后其中的拿一些一大长串的都是字符串字面量的结构体的常量名称。跟上面说到的字符串的字面量一样。

而这里比较特别的是一个布尔类型，其实OC中的BOOL类型只是通过typedef转换了一下，其实其本质就是一个signed char， 而其中的YES和NO就是通过一些宏定义定义的，具体的代码可以查看objc/objc.h中查看，下面我贴出这些代码：

/// Type to represent a boolean value.
#if (TARGET_OS_IPHONE && __LP64__)  ||  TARGET_OS_WATCH
#define OBJC_BOOL_IS_BOOL 1
typedef bool BOOL;  
#else
#define OBJC_BOOL_IS_CHAR 1
typedef signed char BOOL;  
// BOOL is explicitly signed so @encode(BOOL) == "c" rather than "C" 
// even if -funsigned-char is used.
#endif

#if __has_feature(objc_bool)
#define YES __objc_yes
#define NO  __objc_no
#else
#define YES ((BOOL)1)
#define NO  ((BOOL)0)
#endif

当然初次之外，我们还可以用的比较多的是所谓的Boxed Expressions,那么具体是什么样子的呢？其实很简单就是'@'加上个括号，@( <expression> )的形式，其实这种形式非常常见，可以用在字符串，算术表达式，枚举以及struct中。

typedef NS_ENUM(NSInteger, NSCLietralEnum) {  
    NSCLietralEnum1,
    NSCLietralEnum2,
    NSCLietralEnum3,
    NSCLietralEnum4
};

typedef struct __attribute__((objc_boxable)) _NSCPosition {  
    float x, y;
} NSCPosition;

// Boxed Expressions
NSNumber *piOverTwo = @(M_PI / 2);  
NSNumber *favoriteColor = @(NSCLietralEnum1);  
NSValue *value = @(self.view.frame);  
NSCPosition pos;  
NSValue *value2 = @(pos);  

看到上面代码我们可以注意到其实需要一个struct，需要其通过__attribute__((objc_boxable))加以修饰，否则就不可以通过@()进行字面量的转换。当然还有关于数组和字典中下标的内容这里就不说了，其实也就是通过判断其是读还是写，将其转换成对应的msg_send()的方法调用。这里就不说了，有兴趣的小伙伴可以自己做一些试验。

最后说说我们所谓的"自定义下标"，其实所谓的自定义下标就是通过实现两个方法即可。 这里我们用一个字典来实现这两个方法，如果想实现自己的方法的话，可以例如通过数据库去获取信息啊之类的。看下面代码：

@interface NSCSubscriptableObject : NSObject

//  Object subscripting
- (id)objectForKeyedSubscript:(id <NSCopying>)key;
- (void)setObject:(id)obj forKeyedSubscript:(id <NSCopying>)key;

@end

@implementation NSCSubscriptableObject {
    NSMutableDictionary     *_dictionary;
}

- (id)init {
    self = [super init];
    if (self) {
        _dictionary = [NSMutableDictionary dictionary];
    }
    return self;
}

- (id)objectForKeyedSubscript:(id <NSCopying>)key {
    return _dictionary[key];
}

- (void)setObject:(id)obj forKeyedSubscript:(id <NSCopying>)key {
    _dictionary[key] = obj;
}

@end

NSCSubscriptableObject *subsObj = [[NSCSubscriptableObject alloc] init];

subsObj[@"string"] = @"Value 1";  
subsObj[@"number"] = @2;  
subsObj[@"array"] = @[@"Arr1", @"Arr2", @"Arr3"];

NSLog(@"String: %@", subsObj[@"string"]);  
NSLog(@"Number: %@", subsObj[@"number"]);  
NSLog(@"Array: %@", subsObj[@"array"]);  

好了好了，关于Objective C的字面量内容说的有点多了。主要是连得内容也多，如果有兴趣的小伙伴可以看Objective-C Literals来看更多详细的内容。

具体的代码也可以从Github下载，如果对Swift的字面量没兴趣的小伙伴就滚吧(靠，你说什么，找死啊~)。咳咳，说错了。 请各位大神留下来看一眼吧，求求你们了。

其实Swift的非常简单，只要完成其指定协议即可。而至于Swift中都挺提供了哪些字面量转换协议，大家可以通过下面这些来参考一下：

• ArrayLiteralConvertible
• BooleanLiteralConvertible
• DictionaryLiteralConvertible
• ExtendedGraphemeClusterLiteralConvertible
• FloatLiteralConvertible
• NilLiteralConvertible
• IntegerLiteralConvertible
• StringLiteralConvertible
• StringInterpolationConvertible
• UnicodeScalarLiteralConvertible

只要某一个对象实现了具体的转换协议，我们就可以通过对应的字面量进行转换了，下面我们来看一个例子：

// Swift 字面量转换协议
class NSCPerson : StringLiteralConvertible {  
    let name: String

    init(withName name: String) {
        self.name = name
    }

    required convenience init(stringLiteral value: String) {
        self.init(withName:value)
    }

    required convenience init(unicodeScalarLiteral value: String) {
        self.init(withName:value)
    }

    required convenience init(extendedGraphemeClusterLiteral value: String) {
        self.init(withName:value)
    }

}

let person: NSCPerson = "NSCookies"  
print("person.name:\(person.name)")

// 输出
// person.name:NSCookies

是不是非常简单，简单到就是实现一个接口而已。来小伙伴可以给我鼓鼓掌，我会更爱你们哟~（pia~一脱鞋过来）呜呜~，不要这么暴力，年轻人还是斯文一点比较好。

好吧，言归正传。当我们需要自定义字面量转换成具体类型的时候，可以根据上面的协议中挑选需要的字面量协议类型即可，剩下的就交给Swift自带的机制吧。

可以看到这个例子中用字符串的字面量来创建了NSCPerson对象。我特别喜欢Swift这个特性， 因为这个特性可以给我们带来许多的方便，例如我们可以用在创建NSURL时通过字符串来创建，我们可以通过一个ID去创建一个对象，创建的同时可以通过本地缓存或者数据缓存来获得等等等，非常有用。小伙伴要好好利用这个特性。

PS:具体代码可以从Github上获取。

如有问题或纠正, 可以联系@叫什么都不如叫Pluto-Y或在Github

那么，既然是isa替换，那主角当然就是isa啦。那么这个技术出现在什么场景呢？其实这个技术在官方文档中关于KVO的文档中有提到过, 里面说到了，KVO是通过isa-swizzling来实现的。

Automatic key-value observing is implemented using a technique called isa-swizzling.

The isa pointer, as the name suggests, points to the object's class which maintains a dispatch table. This dispatch table essentially contains pointers to the methods the class implements, among other data.

When an observer is registered for an attribute of an object the isa pointer of the observed object is modified, pointing to an intermediate class rather than at the true class. As a result the value of the isa pointer does not necessarily reflect the actual class of the instance.

You should never rely on the isa pointer to determine class membership. Instead, you should use the class method to determine the class of an object instance.

最后一段中也说到了，永远不要用用isa来判断一个类的继承关系，而是应该用class方法来判断类的实例。

看着好像很厉害的技术耶~(双眼bling~bling~发光)。那么为了验证这个技术真正的实现了，也就是isa替换了，我们写了下面一段代码来验证。大家一起来观摩一下：

// 这里用来说明printInfo方法都做了说明
@implementation Person

- (void)printInfo {
    NSLog(@"isa:%@, supper class:%@", NSStringFromClass(object_getClass(self)), class_getSuperclass(object_getClass(self)));
    NSLog(@"self:%@, [self superclass]:%@", self, [self superclass]);
    NSLog(@"age setter function pointer:%p", class_getMethodImplementation(object_getClass(self), @selector(setAge:)));
    NSLog(@"name setter function pointer:%p", class_getMethodImplementation(object_getClass(self), @selector(setName:)));
    NSLog(@"printInfo function pointer:%p", class_getMethodImplementation(object_getClass(self), @selector(printInfo)));

}

@end

// 既然是KVO嘛，那我们就来模拟一个虚假的KVO的情况，并且打印对应的信息
Person *person = [[Person alloc] init];  
NSLog(@"Before add observer--------------------------------------------------------------------------");  
[person printInfo];
[person addObserver:self forKeyPath:@"age" options:NSKeyValueObservingOptionNew context:&PrivateKVOContext];
NSLog(@"After add observer--------------------------------------------------------------------------");  
[person printInfo];
[person removeObserver:self forKeyPath:@"age"];
NSLog(@"After remove observer--------------------------------------------------------------------------");  
[person printInfo];

根据之前一篇历史冤案之isKindOfClass与isMemberOfClass中提到，object_getClass其实打印的就是isa指针。

其中第一个Person的实现中，我们打印了isa, supperclass, 两个方法的setter的函数指针以及printInfo的函数指针。而运行代码中分别在添加Observer前，添加Observer以及删除Observer后分别打印出该类的信息。那么输出的结果是什么呢？

Before add observer--------------------------------------------------------------------------  
isa:Person, supper class:NSObject  
self:<Person: 0x7ffe5aeeb340>, [self superclass]:NSObject  
age setter function pointer:0x10fe03c40  
name setter function pointer:0x10fe03be0  
printInfo function pointer:0x10fe03a30  
After add observer--------------------------------------------------------------------------  
isa:NSKVONotifying_Person, supper class:Person  
self:<Person: 0x7ffe5aeeb340>, [self superclass]:NSObject  
age setter function pointer:0x10ff04c7f  
name setter function pointer:0x10fe03be0  
printInfo function pointer:0x10fe03a30  
After remove observer--------------------------------------------------------------------------  
isa:Person, supper class:NSObject  
self:<Person: 0x7ffe5aeeb340>, [self superclass]:NSObject  
age setter function pointer:0x10fe03c40  
name setter function pointer:0x10fe03be0  
printInfo function pointer:0x10fe03a30  

我们可以分别对比一下添加Observer前以及添加Observer之后(同样也可以比较添加Observer之后与删除Observer之后)，我们发现isa, 通过class_getSuperclass, 以及age的setter方法都发生了变化。而且我们发现其添加Observer之后的class_getSuperclass得到的结果竟然是Person, isa竟然是NSKVONotifying_Person。 What the hell?这是在逗我？

不对，看看文章的标题，其实在添加KVO之后，isa已经替换成了NSKVONotifying_Person,而根据class_getSuperclass得到的结果竟然是Person, 然后age是使我们KVO需要观察的属性，它的setter函数指针变了。而我们也知道，所谓的OC的消息机制是通过isa去查找实现的，那么我们现在可以进行大胆的猜想：

其实KVO的实现可能是：

• 添加Observer
  • 通过runtime偷偷实现了一个子类，并且以NSKVONotifying_+类名来命名
  • 将之前那个对象的isa指针指向了这个子类。
  • 重写了观察的对象setter方法，并且在重写的中添加了willChangeValueForKey:以及didChangeValueForKey:
• 移除Observer
  • 只是简单的将其的isa指向原来的类对象中

然后我们在分析一下， 在真正调用的setAge:的情况下, 根据消息机制我们知道它先通过isa找到对应对象的类， 也就是现在NSKVONotifying_Person, 然后再去找setAge:，由于NSKVONotifying_Person这个对象重写了这个方法， 那么就会直接取当前的实现， 也就是带有willChangeValueForKey:以及didChangeValueForKey:， 那么自然就实现了对KVO的实现了。

最后在看看一幅图吧，稍微总结一下isa-swizzling是搞什么东东：

最后就酱紫了，退下吧，朕要翻牌子了~哇哈哈

PS:具体代码可以从Github上获取。

如有问题或纠正, 可以联系@叫什么都不如叫Pluto-Y或在Github

背景：一手抓住女神，一首抓住楼主

“移形换影大法”

几秒钟后...

“讨厌，死相，这什么武功嘛，好厉害的呢，好厉害的呢！”

“pia~，赶紧说正题”（一脱鞋过来！）

咳咳，其实今天要说的这个，估计很多童鞋看到这个名字就知道是什么了。对了，这个就是大家最最熟悉的黑魔法之一。(其实也就是前面开头中用到的那个移形换影大法，人家没有不正经，只是举了个例子而已啦~嗲~)我们常说OC的动态性是OC的一大特点之一，其中非常好的一个例子就是这个Method Swizzling，用得好它能做出非常恶心的功能————如果Xcode很多插件。但是如果滥用的话，它也会造成非常大的麻烦————最明显的就是很多程序中莫名其妙的bug。

但是作为最为流行的黑魔法我们要知道，如果有童鞋做安全，逆向或者hack别人App，那估计这个是基础的基础了吧。并且很多开源库中都用了这个“魔法”，所以知道这个还是非常有必要的。

我们知道OC底层的实现中，对象的实现方法都存在类中，存在一个叫做objc_method_list，而这里真正存储的是一个关于函数名、参数列表以及函数实现的指针的dispatch table。而其实真正的Method Swizzling的实现就是一个替换函数指针的过程。

怎么个替换方法呢？其实也非常简单， 看下下面两幅图就知道里面是怎么实现的了。 在没有交换前，Class中的两个方法对应的函数指针都是正常的，如下图：

而在交换后，其实就是将Selector A指向了Implementation B而Selector B则指向了Implementation A,如下图：

那么在交换后调用Selector A的情况下，其实跳转到了Implementation B的指针所指向的代码段。自然就形成了方法A与B的替换了。

那么具体代码是如何实现的呢？其实实现的方式有特别多种，不过我最喜欢下面这一种：

+ (void)swizzleWithOriginalSelector:(SEL)originalSelector swizzledSelector:(SEL) swizzledSelector isClassMethod:(BOOL)isClassMethod
{
    Class cls = [self class];

    Method originalMethod;
    Method swizzledMethod;

    if (isClassMethod) {
        originalMethod = class_getClassMethod(cls, originalSelector);
        swizzledMethod = class_getClassMethod(cls, swizzledSelector);
    } else {
        originalMethod = class_getInstanceMethod(cls, originalSelector);
        swizzledMethod = class_getInstanceMethod(cls, swizzledSelector);
    }

    if (!originalMethod) {
        NSLog(@"Error: originalMethod is nil, did you spell it incorrectly? %@", originalMethod);
        return;
    }

    method_exchangeImplementations(originalMethod, swizzledMethod);
}

既然知道了这个，那么我们来验证一下上面所说的指针的替换吧，看下下面的代码：

MethodSwizzlingDemo *methodSizzling = [MethodSwizzlingDemo new];  
NSLog(@"Before swizzle method");  
NSLog(@"methodOrigin pointer :%p", class_getMethodImplementation([MethodSwizzlingDemo class], @selector(methodOrigin)));  
NSLog(@"methodSizzled pointer :%p", class_getMethodImplementation([MethodSwizzlingDemo class], @selector(methodSizzled)));  
[methodSizzling methodOrigin];
[methodSizzling methodSizzled];

NSLog(@"------------------------------------------------------------------------------------");  
[MethodSwizzlingDemo swizzleWithOriginalSelector:@selector(methodOrigin) swizzledSelector:@selector(methodSizzled) isClassMethod:NO];
NSLog(@"After swizzle method");  
NSLog(@"methodOrigin pointer :%p", class_getMethodImplementation([MethodSwizzlingDemo class], @selector(methodOrigin)));  
NSLog(@"methodSizzled pointer :%p", class_getMethodImplementation([MethodSwizzlingDemo class], @selector(methodSizzled)));  
[methodSizzling methodOrigin];
[methodSizzling methodSizzled];

上面代码中前面一半为未替换前的关于个方法信息以及调用后的结果，而后面一半则为执行Method Swizzling之后个方法信息以及调用后的结果，其后台输出如下：

Before swizzle method

methodOrigin pointer :0x104ad46c0

methodSizzled pointer :0x104ad4700

-[MethodSwizzlingDemo methodOrigin]

-[MethodSwizzlingDemo methodSizzled]

---

After swizzle method

methodOrigin pointer :0x104ad4700

methodSizzled pointer :0x104ad46c0

-[MethodSwizzlingDemo methodSizzled]

-[MethodSwizzlingDemo methodOrigin]

可以看出其中在为调用前，methodOrigin的指针为0x104ad46c0，而methodSizzled的指针为0x104ad4700,而在Method Swizzling之后这两个方法的指针调换了，从而实现了函数的“移形换影大法”。从后面的函数调用也可以看得出来。从而也证明了上面的图。

"死鬼， 这下你明白了没？没明白晚上我们慢慢聊~嗲~"

Method Swizzling是一个非常强而有力的魔法，在非常多的开源以及hack代码中都有用到，我记得我第一次接触到这个是在了解如何写自己的Xcode plugin， 那时候觉得能写一个Xcode plugin是一个非常酷的事情。（喂偏题了！）好吧，关于这个下次有空再说。

虽然说Method Swizzling是一个非常强大的黑魔法，但是还是建议能不用的情况下就少用，毕竟如果在多人都在替换之后，整体的函数指针都会特别乱，特别是在用第三方库的情况下，很多库都替换来替换去，最终导致程序经常出现莫名其妙的错误，但是自己分析情况下又很难判断出是否替换过，寻找起来不是特别的方便。

PS:具体代码可以从Github上获取。

如有问题或纠正, 可以联系@叫什么都不如叫Pluto-Y或在Github

其实这次跟大家讲的是很多人都知道的OC的对象模型，也就是下面这张图，大家先有个印象先：

然后我们看看它的“冤”在哪，先来看一段代码吧。

BOOL res1 = [(id)[NSObject class] isKindOfClass:[NSObject class]];  
BOOL res2 = [(id)[NSObject class] isMemberOfClass:[NSObject class]];  
BOOL res3 = [(id)[Pluto class] isKindOfClass:[Pluto class]];  
BOOL res4 = [(id)[Pluto class] isMemberOfClass:[Pluto class]];  

这段代码来自@sunny大神的博客里的文章——神经病院objc runtime入院考试。（并对其中做了一些修改）里面还有其他的三道题，其中第二道和第三道题的原因有异曲同工之妙。

而很多人都会认为，这明显是四个YES,因为我们不是平常说isKindOfClass就是用判断前面是不是后面那个的子类或者就是那个类，而isMemberOfClass就是用来判断前面那个是不是就是后面那个类型的。非也非也，正确的说话应该前面那个"实例"是否是后面那个类型的（针对isKindOfClass和isMemberOfClass），或者是任何前面那个"实例"是否是后面那个类型或者是那个子类型。 下面来看看苹果官网是如何描述的：

isKindOfClass: Returns a Boolean value that indicates whether the receiver is an instance of given class or an instance of any class that inherits from that class.

isMemberOfClass: Returns a Boolean value that indicates whether the receiver is an instance of a given class.

为什么这里的实例加了引号呢，其实是这样的，我们常说的实例都是指左边那一列，而其实这里提到的实例不当是指左边这一列，还包含中间这一列。我们可以这样说我们通常认为的实例是Class的实例，而苹果官网中的文档还有另一重意思就是Class其实是Meta Class的实例。

不好意思这里有点绕，我们举一个实际的🌰。就说说前面这个板栗吧，这个板栗是一个具体的实例，而他的Class则应该是板栗这个类别，而板栗有是具有某一特性的植物，而这里指的某一特性的植物则是板栗这个Class的Meta Class，大家好好去体会一下。

接下来说说NSObject class和object_getClass之间的区别，咋一看很多人觉得这个不是应该是同一个东西吗，其实非也非也，且听我慢慢说来。其实NSObject class这个方法获得的永远是中间这个Class的级别，而object_getClass通常都是用来获得isa指向的那个，不行我们用下面这段代码来试试：

BOOL res5 = [NSObject class] == [[NSObject class] class];  
BOOL res6 = [NSObject class] == [[[NSObject class] class] class];  
BOOL res7 = [NSObject class] == object_getClass([NSObject class]);  
BOOL res8 = object_getClass([NSObject class]) == object_getClass(object_getClass([NSObject class]));  
BOOL res9 = [NSObject class] == class_getSuperclass(object_getClass([NSObject class]));  

其中5和6其实不管调用多少次的class方法都会返回YES，而5和7说明了class方法和object_getClass方法是不一样的，而根据文章开头的图片以及前面说到object_getClass是isa指向的那个可以得出8和9都是YES。

好了，到这里要是都理解的话，我们最后在来看看苹果官方中关于isKindOfClass方法和isMemberOfClass的源码:

+ (BOOL)isMemberOfClass:(Class)cls {
    return object_getClass((id)self) == cls;
}

- (BOOL)isMemberOfClass:(Class)cls {
    return [self class] == cls;
}

+ (BOOL)isKindOfClass:(Class)cls {
    for (Class tcls = object_getClass((id)self); tcls; tcls = class_getSuperclass(tcls)) {
        if (tcls == cls) return YES;
    }
    return NO;
}

- (BOOL)isKindOfClass:(Class)cls {
    for (Class tcls = [self class]; tcls; tcls = class_getSuperclass(tcls)) {
        if (tcls == cls) return YES;
    }
    return NO;
}

看到这里很多童鞋要说"Holy Shit", 然而本宝宝不喜欢说粗话的小盆友， 来人啊， 把说出话的人拖出去斩了（不用这么狠吧！）。好吧，没错，苹果官方关于这两个方法都提供了实例方法和类方法。而我们最开始的Demo调用的都是类方法，再加上我们前面说的object_getClass的含义以及第一副关于对象模型的图片得知，res1的路径为Root Class->Root Meta Class -> Root Class，所以返回的是YES。同理可证res2, res3, res4为NO。

上面老是说因为所以让我想起以前正面题目的∴,∵还有同理可证什么的，看来我还是一个爱学习的好孩子嘛(偷笑)。

PS:具体代码可以从Github上获取。

如有问题或纠正, 可以联系@叫什么都不如叫Pluto-Y或在Github

soga，原来是这个回事。好了，这节就到这里了。(赶紧说，别废话!)既然你诚心诚意的发问了,为了防止世界被破坏,为了维护世界的和平...&%%&^&&^$。谁用拖鞋扔我！

好吧，且听我静静装逼，不对，且听我慢慢说来。所谓的Tagged Pointer其实就是一个带着"真实"的数据信息的指针。说到底他也就是一个伪指针。为什么这么说呢？

我们来先看两个例子：

NSNumber *num1 = [NSNumber numberWithInt:10];  
NSNumber *num2 = [NSNumber numberWithInt:10];  
NSLog(@"pointer of num 1: %p", num1);  
NSLog(@"pointer of num 2: %p", num2);  
NSNumber *num3 = [NSNumber numberWithInt:0xfffff];  
NSNumber *num4 = [NSNumber numberWithInt:0xfffff];  
NSLog(@"pointer of num 3: %p", num3);  
NSLog(@"pointer of num 4: %p", num4);

// 其输出结果为:
2016-07-31 23:32:08.066 OCCodes[3773:205937] pointer of num 1: 0xb0000000000000a2  
2016-07-31 23:32:08.066 OCCodes[3773:205937] pointer of num 2: 0xb0000000000000a2  
2016-07-31 23:32:08.066 OCCodes[3773:205937] pointer of num 3: 0xb000000000fffff2  
2016-07-31 23:32:08.066 OCCodes[3773:205937] pointer of num 4: 0xb000000000fffff2  

非常奇怪，正常我们创建两个实例的时候，它应该前后两个实例地址的指针应该是不一样的，可是例子中的两组实例中，没组的实例的指针都是一样的。而且很奇怪的是指针的地址都是这种0xb....2形式，并且2旁边的数值正好是NSNumber存的值。难道这些都是巧合吗？

答案是：并不是的。其实这个正是Tagged Pointer的真实面目，表面上看他是一个指针，可是实际上他并不是真正的指针，而是包含了NSNumber具体信息的伪指针。但是这种"指针"只能存储数值较小的情况下，例如如下的例子则不能保存成Tagged Pointer的形式：

NSNumber *num5 = [NSNumber numberWithDouble:M_PI];  
NSNumber *num6 = [NSNumber numberWithDouble:M_PI];  
NSLog(@"pointer of num 5: %p", num5);  
NSLog(@"pointer of num 6: %p", num6);

// 其输出结果为:
2016-07-31 23:39:34.375 OCCodes[3822:210131] pointer of num 5: 0x7fe70140e030  
2016-07-31 23:39:34.375 OCCodes[3822:210131] pointer of num 6: 0x7fe70170aab0  

可以看出当如果存储的数值所需的字节数较大的情况下，则以正确的指针来进行保存，而只有当存储的数值所需的位数较少时，则以Tagged Pointer的形式进行存储。那么，有人就要问了。为什么不都以真实的指针来进行存储呢？你猜！(瞬间一双拖鞋就过来了！)

好吧，其实是在iPhone 5s引入的过程中其实也引入了64位的处理器，而在引入64位处理器的过程中，指针所占的位数也相应的变为了64位(而在以前的32位处理器的时候指针都是以32位的形式存储)。而如果我需要创建一个NSNumber的实例，则我需要一个8个字节(64位)的指针以及在堆中分配一定空间来进行存储(大概是在8字节左右)。也就是说我需要16个字节才能存储一个NSNumber的对象。而对于一个4个字节的存储空间来说以及可以存储20+亿的整数了。

这个时候Tagged Pointer就闪亮登场了。它的目的就在于，当处于64位处理器的系统中将所有信息都存在栈的指针中，并通过一定的的特殊标记位来说明该指针为一个Tagged Pointer，剩余的一些指针的位数则用来存储NSNumber的具体数值(如上方的0xb000000000fffff2)。

其实这么做除了能节省CPU的空间以外，还能提高处理NSNumber的速度，因为他不需要再从堆中申请和释放空间，同时在读取和存储上的速度也加快了。

根据WWDC2013的Session 404 Advanced in Objective-C中提到了，在内存上读取的速度快了3倍，创建时的速度比以前快乐106倍。

同时除了NSNumber能以这种这种形式存储外，NSDate也是做了同样的优化。而以上所说的这些Tagged Pointer是针对64位处理器来说的，在32位系统的情况下，这些还是以指针+堆中的对象进行存储的。在64位处理器并且其存储的实际数值没法用Tagged Pointer保存的情况下，也是与32位系统中一样的存储方式。

由于Tagged Pointer是一个伪指针，所以在使用过程中有两点需要注意的： * 对于NSObject中的isa指针其实是没有的，毕竟它不是一个真正的对象 * 对于在MRC下，其retainCount也是不正确的，它采用了一个非常大的整数来进行返回，这样也能保证其能在内存中长时间的存在

总的来说，Tagged Pointer的出现是为了在64位系统中提升速度的。而Tagged Pointer则是通过一定的标志位以及将真实信息存入在指针中。所以Tagged Point并不是一个真正意义上的指针，而是包含了真实信息的指针。就是这样啦。

顺带献上Swift代码，请各位大王笑纳:

// MARK: Tagged Pointer
let num1 = NSNumber(long: 0xffff)  
let num2 = NSNumber(long: 0xffff)  
let pointFormatStr1 = NSString(format: "tagged point :%p", num1)  
let pointFormatStr2 = NSString(format: "tagged point :%p", num2)


let num3 = NSNumber(float: Float(M_PI))  
let num4 = NSNumber(float: Float(M_PI))  
let pointFormatStr3 = NSString(format: "tagged point :%p", num3)  
let pointFormatStr4 = NSString(format: "tagged point :%p", num4)

let date1 = NSDate(timeIntervalSince1970: 10)  
let date2 = NSDate(timeIntervalSince1970: 10)  
let pointFormatStr5 = NSString(format: "tagged point :%p", date1)  
let pointFormatStr6 = NSString(format: "tagged point :%p", date2)

let date3 = NSDate(timeIntervalSinceNow: 10)  
let date4 = NSDate(timeIntervalSinceNow: 10)  
let pointFormatStr7 = NSString(format: "tagged point :%p", date3)  
let pointFormatStr8 = NSString(format: "tagged point :%p", date4)

PS:具体代码可以从Github上获取。

如有问题或纠正, 可以联系@叫什么都不如叫Pluto-Y或在Github

FOUNDATION_EXPORT void NSLog(NSString *format, ...) NS_FORMAT_FUNCTION(1,2);  

这个代码然我瞬间感觉好熟悉，想起了之前Java中的可变参数函数。可是再仔细一看就发现，尼玛后面的可变参数竟然是没有参数名，而且也没有类型之类的信息，瞬间我就懵逼了。

于是我就找了我的大哥--谷歌，经过一番查找之后发现其实也不是特别难。乍一看虽然跟Java中将参数默认识别为一个具体类型的数据完全不同，但是其实还是换汤不换药，其实只是我们将Java中帮我们做的那一份我们自己实现了而已。

其实说是OC的可变参数的实现不如说是C的可变参数的实现，因为OC是C的超集，而且在许多方面来说OC并没有完全的摆脱C的影子。好了不废话了，看招：

// 可变参数的实现
-(NSNumber *)sumAllValues:(NSNumber *)initValue, ... {
    va_list args; // 1.
    va_start(args, initValue); // 2.
    NSNumber *arg = va_arg(args, NSNumber *); // 3.
    NSNumber *result = initValue;
    float sum = [result floatValue];
    while (arg != nil) {
        sum += [arg floatValue];
        arg = va_arg(args, NSNumber *); // 4.
    }
    va_end(args); // 5.
    result = @(sum);
    return result;
}

可以看出其实我们只是将Java帮我们做的事情让我们自己做而已。也不是特别难嘛。 这里稍微给大家讲解一下：

• 1.声明了一个变量用来装可变参数,其类型是在C中定义的va_list, 其本质上来说是一个指针
• 2.调用C函数va_start, 其第一个参数是将可变参数的第一个参数的指针传递给该参数，第二个参数指明了可变参数是跟在哪个参数之后的
• 3、4.都是用来去多参数的下一个参数的C函数，其第一个参数传递的是1中声明的变量，第二个参数是讲多参数的数据转换成什么类型，其实这个好像是forin的形式
• 5.在遍历完可变参数之后记得要调用va_end来表明结束，并且释放该变量

其实这个过程很想是在写原生sqlite3的时候，获取数据之后进行遍历数据的情况。需要去某个地方(va_start第二个参数之后的位置)"获取"数据，然后遍历数据，最后结束的时候还要关闭“数据库”(释放变量)的感觉。是不是很简单？

那么接下来我们再看看Swift是如何实现的，更简单的就来了~

func sumAllValues(nums: Float...) -> Float {  
    var sum: Float = 0.0
    for num in nums {
        sum += num
    }
    return sum
}

sumAllValues(5.0, 4.0, 5.0, 3.3)  

有没有觉得很像是一个语法糖一样，只是将可变参数转换成一个数据，于是我又一次“手贱”(怪我咯?)的查看了一下nums的类型:

看出来没，其实所谓的可变参数都是骗子。就不能少一点套路，多一点真诚吗？其实就是讲所谓的可变参数编程了一个Array了。所以总体来说Swift的可变参数函数实现起来就是讲可变参数变成了数组。

然而其实在OC中大部分情况下没必要用到可变参数函数, 我们可以用NSArray等集合工具来实现即可。并且用集合来实现相对更安全一点。毕竟用集合可以通过集合的许多属性和方法来做一些特殊的处理和判断。所以，切记可变函数参数在极少的情况下才会用到，大部分情况我们只要了解其中的实现以及看见的时候知道是怎么回事即可。

PS:具体代码可以从Github上获取。

如有问题或纠正, 可以联系@叫什么都不如叫Pluto-Y或在Github