《Effective Objective-C》概念篇

时间  2019-11-12
标签 effective objective 概念 栏目 C&C++ 繁體版
原文   原文链接
1.运行时
  • OC 语言由 Smalltalk(20世纪70年代出现的一种面向对象的语言) 演化而来，后者是消息型语言的鼻祖。
  • OC 使用动态绑定的消息结构，在运行时检查对象类型。
  • 使用消息结构的语言，其运行时执行的代码由运行环境来决定。而使用函数调用的语言，则由编译器决定。
  • OC 对象所占内存老是分配在“堆空间”，毫不会分配在“栈”上。分配在堆中的内存必须直接管理，而分配在栈上用于保存变量的内存会在栈帧弹出时自动清理。
  • OC 运行期内存管理架构，名叫“引用计数”。
  • OC 中会遇到定义中不含 * 的变量，也是会使用“栈空间”。好比 CoreGraphics 框架的 CGRect，整个系统框架都在使用这种结构体，若是使用 OC 对象，性能会受影响。
2.属性
  • 用来封装对象中的数据。
  • 若是使用了属性的话，那么编译器就会主动编写访问这些属性所需的方法，此过程叫作“自动合成”。这个过程在编译期执行，点语法是编译时特性。
  • @synthesize 语法来指定实例变量的名字。
@synthesize testString = _testString;
  • @dynamic 关键字会告诉编译器不要建立实现属性所用的实例变量，也不要为其建立存取方法。并且，在编译访问属性的代码时，即便编译器发现没有定义存取方法也不会报错，它相信这些方法能在运行时找到。
@dynamic testString;
_testString //Use of undeclared identifier '_testString'
  • 属性特质的设定也会影响编译器所生成的存取方法。属性特质包括：原子性、读写属性、内存管理语义（assign、strong、weak、unsafe_unretained、copy）、方法名（getter== …）。
  • 若是想在其余方法里设置属性值，一样要遵照属性定义中所宣称的语义，由于“属性定义”就至关于“类”和“待设置的属性值”之间所达成的契约
    好比在指定构造器中对成员变量的赋值
@interface TestObject ()
//虽然这个属性已是只读性质，也要写上具体的语义，以此代表初始化方法在设置这些值时所用方法
@property(copy,readonly) NSString *testString;
@end

@implementation TestObject
- initWithString:(NSString *)string {
    
    self = [super init];
    
    if (self) {
        //用初始化方法设置好属性值以后，就不要再改变了，此时属性应设为“只读”
        _testString = [string copy];
    }
    return  self;
}
@end
3.对象等同性
  • “==”操做符比较的是两个指针自己，而不是所指的对象。应该使用 NSObject 协议中声明的“isEqual”方法来判断两个对象的等同性。
NSString *textA = @"textA";
    NSString *textAnother = [NSString stringWithFormat:@"textA"];
    NSLog(@"%d",textA == textAnother);// 0
    NSLog(@"%d",[textA isEqual:textAnother]);// 1
    NSLog(@"%d",[textA isEqualToString:textAnother]);// 1
  • 在自定义的对象中正确复写“isEqual”"hash"方法，来断定两个方法是否相等。
  • 若是 “isEqual”方法断定两个对象相等，那么其 hash 方法也必须返回同一个值。
    好比下面这个类
@interface TestObject : NSObject
@property NSString *testString;
@end

@implementation TestObject
- (BOOL)isEqual:(id)object {
    if (self == object)  return YES;
    if ([self class] != [object class]) return NO;
    
    TestObject *otherObject = (TestObject *)object;
    if (![self.testString isEqualToString:otherObject.testString]) {
        return  NO;
    }
    return YES;
}
-(NSUInteger)hash {
    //在没有性能问题下，hash 方法能够直接返回一个数
    return 1227;
}

@end

在继承体系中判断等同性，还需判断是不是其子类
相同的对象必须具备相同的哈希码，可是相同哈希码的对象却未必相同程序员

特定类型等同性判断
  • 本身建立等同性判断方法，无需检测参数类型，大大提高检测速度。就像“isEqualToString”同样。
- (BOOL)isEqualToTestObject:(TestObject *)testobject {
    
    if (self == testobject) {
        return YES;
    }
    if (![self.testString isEqualToString:testobject.testString]) {
        return  NO;
    }
    return YES;
}
- (BOOL)isEqual:(id)object {
    
    if ([self class] == [object class]) {
        return [self isEqualToTestObject:(TestObject *)object];
    }else {
        return [super isEqual:object];
    }
}

  • 有时候无需将全部数据逐个比较，只根据其中部分数据便可判明两者是否相等。objective-c

    比方说一个模型类的实例是根据数据库的数据建立而来，那么其中可能会含有一个惟一标识符（unique identifier），在数据库中用做主键。这时候，咱们就能够根据标识符来断定等同性，尤为是此属性声明为 readonly 时更应该如此。只要标识符相等，就能够说明这两个对象是由相同数据源建立，据此判定，其余数据也相等。
    固然，只有类的编写者才知道那个关键属性是什么。数据库

要点：不要盲目的逐个检测每条属性，而是应该按照具体需求制定检测方案编程

4.理解 objc_msgSend
  • 在对象上调用方法是 OC 中常用的方法。专业术语叫作“传递消息”，消息有名称（或叫选择子），能够接受参数，或许还有返回值。

  • 在 OC 中，对象收到消息以后，究竟该调用哪一个方法彻底于运行期决定，甚至能够在运行时改变，这些特性使 OC 成为一门真正的动态语言。
    给对象发送消息能够这样写：缓存

    id value = [obj messageName:parameter]安全

obj 叫作接收者，messageName 叫作 selector，selector 和参数合起来称为消息
编译器看到此消息后，将其转换为一条标准的 C 语言函数调用网络

void objc_msgSend(id _Nullable self, SEL _Nonnull op, ...)session

第一个参数表明接收者，第二个表明 selector(SEL是selector类型)
这是个“参数个数可变的函数”，”…“ 表明后续参数，就是消息中的参数数据结构

  • objc_msgSend 方法在接收者所属的类中搜寻其”方法列表“，若是能找到与 selector 名称相符的方法，就跳至其实现代码。如果找不到，就沿着继承体系继续向上查找，等找到合适的方法以后再跳转。若是最终仍是找不到相符的方法，就执行”消息转发“（在以后解释）。
  • 看起来，想调用一个方法彷佛须要不少步骤。所幸 objc_msgSend 会将匹配结果缓存在”快速映射表“中，每一个类都有这样一个缓存，如果后来还向该类发送相同的消息，那么执行起来就会很快了。
  • 其余消息发送函数
//Sends a message with a simple return value to the superclass of an instance of a class.
objc_msgSendSuper(struct objc_super * _Nonnull super, SEL _Nonnull op, ...)
//Sends a message with a data-structure return value to an instance of a class.
objc_msgSend_stret(id _Nullable self, SEL _Nonnull op, ...)
//Sends a message with a data-structure return value to the superclass of an instance of a class.
objc_msgSendSuper_stret(struct objc_super * _Nonnull super,  SEL _Nonnull op, ...)
  • 刚才提到 objc_msgSend 找到合适的方法以后，就会”跳转过去“。之因此能够这样作是由于 OC 对象的每一个方法均可以视为简单的 C 函数，原型以下：
<return_type> Class_selector(id self, SEL _cmd, ...)

每一个类都有一张表格，selector 的名称就是查表时所用的 key多线程

  • 原型的样子和 objc_msgSend 很像，并且函数的最后一项操做是调用另外一个函数并且不会将其返回值另做他用，就能够利用”尾调用优化“技术，令”跳至方法实现“变得简单。

    尾调用技术：编译器会生成跳转至另外一函数所需的指令码，并且不会向调用堆栈中推入新的”栈帧“

  • 要点：发给某对象的所有消息都要由“动态消息派发系统”来处理，该系统会查出对应的方法，并执行其代码

5.消息转发机制
  • 对象在收到没法解读的消息以后会发生什么状况？若是在控制台中看到上面这种提示信息，那就说明你给对象发送了一条其没法解读的消息，启动了消息转发机制
- 由于在运行期能够继续向类中添加方法，因此编译器在编译期还没法确知类中是否有某个方法的具体实现。
- 当对象接收到没法解读的消息，就会触发“消息转发机制”，程序员能够经由此过程告诉对象如何处理未知消息

消息转发分为两大阶段

  • 第一阶段：征询接收者，可否动态添加方法，处理当前这个“未知的 selector”
//当未知的 selector 是实例方法时的调用
+ (BOOL)resolveInstanceMethod:(SEL)sel ;
//当未知的 selector 是类方法时的调用
+ (BOOL)resolveClassMethod:(SEL)sel;

使用这种办法的前提是：相关方法的实现代码已经写好，只等着运行时加入类里面

  • 第二阶段：运行时系统会请求接收者以其余手段处理与消息相关的方法调用，可细分为两小步。
//第一步:询问能不能把未知的消息转给其余接收者处理
- (id)forwardingTargetForSelector:(SEL)aSelector ;

若当前接收者能找到备援接收者，则将其返回，若找不到，则返回 nil
-若是返回一个对象，则运行期系统把消息转给那个对象，因而消息转发结束
若是返回 nil，执行第二步👇

//第二步：把消息相关的细节封装在 NSInvocation对象中，再给接收者最后一次机会
- (void)forwardInvocation:(NSInvocation *)anInvocation

能够在触发消息前，先以某种方式改变消息内容，好比追加一个参数，或改换 selector，等等
若是实现此方法时，发现某调用操做不该由本类处理，则调用超类的调用方法。若是继承体系的类都不处理此调用请求，那就最后调用 NSObject 类的方法，那么该方法会执行👇方法

//抛出异常，代表 selector 未能处理
- (void)doesNotRecognizeSelector:(SEL)aSelector;

图片来自：《Effective Objective-C 》

  • 接收者在每一步均有机会处理消息。步骤越日后，处理消息的代价就越大。最好能在第一步处理完，这样的话运行期系统就能够把消息缓存起来了。若是这个类的实例稍后还收到同名 selector，那么根本无需启动消息转发流程。
  • 接下来给一个添加方法的具体实现
+ (BOOL)resolveInstanceMethod:(SEL)sel {
    
    NSString *selString = NSStringFromSelector(sel);
    if ([selString hasPrefix:@"set"]) {
        //最后一个参数表示待添加方法的类型编码(type encoding)
        class_addMethod([self class], sel, (IMP)autoDictionarySetter, "v@:@");
    }else {
        class_addMethod([self class], sel, (IMP)autoDictionaryGetter, "@@:");
    }
    return [super resolveInstanceMethod:sel];
}

注
SEL 是方法编号，SEL类型经过 @selector() 提取
IMP 是一个函数指针，保存了方法的地址
type encoding：
v 表明 void
： 表明 (method selector)SEL
@ 表明 object(whether statically typed or typed id);

在 setter 实现的时候给一个字典添加键值对，getter 从字典获取值，这样的实现就在 iOS 的 CoreAnimation 框架中的 CALayer 类里面。CALayer 是一种“兼容于键值编码的”容器类，能向其中随意添加属性，而后以键值对的方式访问。

6.类对象的用意
  • 首先开看看 OC 对象的声明
NSString *pointerVariable = @"Some string";

pointerVariable 是存放内存地址的变量，而 NSString 自身的数据就存于那个地址中

//对于通用的对象类型 id ，其自己已是指针了，能够这样写
    id genericTypeString = "id String"

上面两种不一样的定义方式的区别在于，若是声明时指定了类型，在实例上调用没有的方法时，编译器会发出警告。而 id 类型，编译器默认它能响应全部本项目中存在的方法。

  • 描述 OC 对象所用的数据结构定义在运行期程序库的头文件里 可见对象是一个含有 isa 指针的结构体，isa 指针表示这个对象是一个(is a)什么类。
  • 那么 isa 指向的 Class 是什么？原来 Class 是指向 objc_class 的指针。
  • objc/runtime.h 中 对 objc_class 的定义以下结构体中包含的具体内容：
    1.能够看到，结构体内也有一个 isa 指针，也就是说“类也是有类的”。由此说明，类也是一个对象。
    2.下面的内容就是这个类方法列表（method_list)(实际是对象方法）、成员变量列表（ivar_list）、cache 列表、协议列表，还有 super_class 变量，等等

自此，咱们知道的了对象就是一个含有指向 Class 类的 isa 指针的结构体，Class 也是一个对象，它其中也有一个 isa 指针。那么类对象的 isa 指针指向哪里，类对象的父类又是什么呢？看下图

这样 OC 中类和对象的关系就清楚了。对象的 isa 指针指向类对象，类对象的 isa 指针指向 metaClass，译为元类。元类的 isa 指针指向根元类
由此能够看出来 Apple 设计类对象的用意就是为了存储对象的信息，好比对象方法，对象属性，遵照的协议，对象的类的父类，等等，而类对象的相关信息被存储在元类中。

7.理解 Objective-C 错误类型
  • 当前不少编程语言都有“异常”机制，OC 也不例外
    首先要注意的是，“自动引用计数”（Automatic Reference Counting, ARC）在默认状况下不是“异常安全的“。这意味着：若是抛出异常，那么本应在做用域末尾释放的对象如今却不会自动释放了。
    OC 如今采用的办法是：只在极其罕见的状况下抛出异常，异常抛出以后无需考虑恢复问题，并且应用程序此时也应该退出。
  • 异常只应该用于极其严重的错误。好比说，你编写了一个抽象基类，它的正确用法是先从中继承一个子类，而后使用这个子类。在这种状况下，能够在那些子类必须复写的超类方法里抛出异常。这样的话，只要有人建立抽象基类并使用它，就会抛出异常。
    下面图片是在 Masonry 中的异常的使用
  • 异常只用于出现严重错误，当出现“不那么严重的错误”，OC 使用的编程范式是，令方法返回 nil/0，或是使用 NSError，代表其中有错误产生。
    好比初始化方法没法根据传入的参数来初始化当前实例，就返回nil/0;
- initWithString:(NSString *)string {
    
    if (self = [super init]) {

        if (string == nil) {
            self = nil;
        }else {
            //Initialize instance
        }
    }
    return  self;
}

NSError 的用法更加灵活，由于经过此对象，咱们能够获知错误的具体信息。NSError 对象里封装了三条消息：

  • Error domain（错误范围，类型为字符串）
    错误发生的范围。也就是错误发生的根源。好比在网络请求时获取数据失败或解析数据发生错误，就使用 NSURLEroorDomain 来表示错误范围fmAFNetworkingClient.m

  • Error code（错误码，其类型为整数）
    独有的错误代码，用来指明在某个范围内具体发生了何种错误。某个特定范围内可能会发生一系列相关错误，这些错误状况一般采用 enum 来定义。例如：当 http 请求出错时，把 HTTP 状态码设为错误码.NSURLErrorDomain

  • User info（用户信息，类型为字典）
    有关此错误的额外信息，其中或许包含一段本地化的描述（localized description），或许还含有致使该错误发生的另外一个错误。好比 SDWebImage 中
@{NSLocalizedDescriptionKey : @"Image data is nil"}
  • 在设计 API 时，NSError 第一种使用方式是经过协议传递此错误。例如 NSURLSessionTaskDelegate中定义的方法：
/* Sent as the last message related to a specific task.  Error may be
 * nil, which implies that no error occurred and this task is complete. 
 */
- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task
                           didCompleteWithError:(nullable NSError *)error;

这个委托方法未必非得实现不可，是否是必须处理此错误，可交由用户来处理。
NSError 的另外一种常见用法：经由方法的“输出参数”返回给调用者。好比在 MJExtension 中：

/**
 *  经过字典来建立一个模型
 *  @param keyValues 字典
 *  @return 新建的对象
 */
+ (instancetype)objectWithKeyValues:(id)keyValues;
+ (instancetype)objectWithKeyValues:(id)keyValues error:(NSError **)error;

入参是一个指针，指向另外一个指针，那个指针指向 NSError 对象。使用以下方式获取错误信息。

NSError *error = nil;
 MyModel *model = [MyModel objectWithKeyValues:responseObject error:&error];
        
if (error) {
  //获取 error 信息
}

实际上，在使用 ARC 时，编译器会把方法签名中的 NSError ** 转换成 NSError *__autoreleasing *，也就是说，指针所指的对象会在方法执行完毕后自动释放。
MJ 经过如下代码把 NSError 对象传递到“输出参数”中：

// 构建错误
#define MJBuildError(error, msg) \
if (error) *error = [NSError errorWithDomain:msg code:250 userInfo:nil];

-这段代码以 *error 语法为 error 参数”解引用“，也就是说，error 所指的那个指针如今要指向一个新的 NSError 对象了。在解引用前，必须确保 error 不是 nil，由于空指针解引用会致使“段错误”并使程序奔溃。

  • 为本身的程序库中所发生的错误指定一个专用的”错误范围“ 字符串，使用此字符串建立 NSError 对象，返回给库的使用者，这样的话，使用者能够肯定：该错误是由你的程序库所回报的。
8.理解引用计数

  • Objective-C 语言使用引用计数来管理内存，也就是说，每一个对象都有一个能够递增递减的计数器，若是想要保留对象，就递增，用完了以后就递减，当计数为 0 时，对象就销毁。要写出优秀的 OC 代码，除了知道这些，还必须知道其中的原理。

    引用计数工做原理
  • 在引用计数架构下，每一个对象都有一个计数器，用来表示当前一共有多少调用者想让此对象存活。NSObject 协议中有如下三个方法操做计数器
- (void)retain;//使递增
- (void)release;//使递减
- (void)autorelease;//稍后清理“自动释放池”时再进行递减

查看引用计数的方法是 retainCount，不过这个方法不是很准确，苹果官方也不推荐
应用程序在生命期内会建立不少对象，这些对象相互联系着。例如表示我的信息的对象会引用表示名字的字符串对象。对象若是持有其余对象的强引用，那么前者就拥有后者。也就是说，对象想让它所引用的对象继续存活，可将其“保留”。等用完了以后再释放。
下图表示了一个对象从保留到释放的过程图片来自Effective Objective-C

按图能够想象，有一些其余对象想要保持 B 或 C 对象存活，而引用程序中又会有另一些对象想让这些对象存活。若是按“引用树”回溯，那么最终会发现有一个“根对象”。在 iOS 中，就是 UIApplication 对象。是在应用程序启动时建立的对象。

当对象的引用计数为 0 ，对象所占内存”解除分配“以后，就被放回”可用内存池“。此时再去调用该对象，可能会有不一样状况发生：若是此时内存对象已经作了他用，就会引发程序奔溃；若是此时对象内存未被复写，就可能正常运行。因而可知，由过早释放对象而致使的 bug 很难调试。

  • 为避免无心间使用无效对象，通常调用完 release 以后都会清空指针。
属性存取方法中的内存管理
  • 当对象要保留其余对象的时候，通常经过访问属性来实现。好比一个属性名为 foo，其属性内存管理语义为”strog“，那么他的设置方法为：
- (void)setFoo:(id)foo {
    [foo retain];
    [_foo release];
    _foo = foo;
}

此方法保留新值，释放旧值，而后更新变量指向新值。顺序很重要。若是先释放旧值，那此对象就被回收。后续操做就都没有意义了。

自动释放池
  • 调用 release 会当即递减对象的引用计数，若是想要延迟释放，那么能够调用 autorelease，加入自动释放池，它会在以后清空的时候给其中的全部对象发送一条 release 消息。
保留环
  • 使用引用计数，常常要注意的问题就是“保留环”，也就是呈环状相互引用的多个对象。
  • 可使用弱引用，或者经过外界命令循环中的一个对象再也不保留另外一个对象，打破保留环，避免内存泄漏。
9.以 ARC 简化引用计数
此处没有完全看懂，暂时先放一放
10.理解“块”这一律念

块是一种可在 C 、C++、OC 代码中使用的“词法闭包”，它很是有用，能够把一段代码像对象同样传递。在定义“块”的范围内，它能够访问到其中全部的变量。

  • 说“块”必须离不开说多线程。苹果公司设计的多线程编程的核心就是“块”（block）和“大中枢派发”（GCD），这虽然是两种不一样的技术，但他们是一并引入的。

  • GCD 提供了对线程的抽象，而这种抽象基于“派发队列”。开发者可将块排入队列中，由 GCD 处理全部调度事宜。

块的基础知识
  • 块能够实现闭包。这种语言特性是作为扩展加入 GCC 编译器中的，在近期版本中的 Clang 均可以使用。
    块其实就是个值，并且自有其相关类型。能够把块赋给变量，语法与函数指针相似。块用符号 “^" 来表示
int adder = 8;
//定义一个变量名为 myBlock 的块
//语法结构：return_type (^blockName) (parameters)
int (^addBlock)(int num) = ^(int num){
        //在块内部可使用外部变量
        return num+ adder;
 };

int addEight = addBlock(5);
  • 默认状况下，在块内部不能够更改变量的值。想要改变值，须要在声明变量时使用 __block 修饰。
    这里有个疑问，块里面的实例变量在没有 __block 修饰的状况下却也是能够改变值的，为何？
  • 若是块所捕获的变量是对象，那么就会自动保留它。块也是对象，当块的引用计数为 0 ，系统释放块的时候，也会释放它所捕获的对象，以便平衡捕获时的保留操做。
块的内部结构

图片来自Effective Objective-C块自己是对象，因此他也有内存空间。

  • 首个变量是指向 Class 对象的指针，该指针叫作 isa。
  • 最重要的是 invoke 变量，是个函数指针，指向块的实现代码。
  • descriptor 变量是指向结构体的指针，其中声明了块对象的整体大小，还声明了 copy 和 dispose 这两个辅助函数对应的函数指针。
  • 块还会把它捕获到的变量都拷贝一份，放在 descriptor 后面。拷贝的是指向变量的指针。捕获了多少个变量，就要占据多少个内存空间。
全局块 栈块 堆块
  • 定义块的时候，其所占的内存区域是在栈中的。也就是说，块只在定义它的那个范围内有效。好比下面代码，就是有危险的：
void (^myBlock)();
    if (/* some condition*/) {
        myBlock = ^{};
    }else {
        myBlock = ^{};
    }
    myBlock();

定义在 if 和 else 里面的两个块都分配在栈内存中。编译器会给每一个块分配好栈内存，可是等离开了相应的范围以后，编译器就可能把分配给块的内存覆写掉。这样写出来的代码时而正确时而错误。

为解决此问题，可给块对象发送 copy 消息以拷贝之。这样就把块对象从栈内存移到了堆内存中，拷贝后的块，就能够在定义它的范围以外使用了。并且，一旦复制到堆上，块对象就成了具备引用计数的对象了。后续的复制操做就只是递增引用计数了。

明白了这一点，咱们只要给代码加上两个 copy 调用就安全了。

void (^myBlock)();
    if (/* some condition*/) {
        myBlock = [^{} copy];
    }else {
        myBlock = [^{} copy];
    }
    myBlock();
  • 还有一种块叫作”全局块”，像这样的
void (^myBlock)() = ^{
        NSLog(@"This is a block");
    };

因为运行该块的全部信息都能在编译的时候肯定，因此可把他作成全局块。
这种块不会捕捉任何状态（好比外围的变量等），能够声明在全局内存中，不须要在每次用到的时候于栈中建立。这种块实际上至关于单例。

10.熟悉系统框架
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程