iOS開發之高級面試題（一）

時間 2019-12-15

標籤 ios 開發高級面試欄目 iOS 简体版

原文原文鏈接

小編加了一個不錯的面試題和iOS技巧分享羣，883872094羣資料能夠自取html

《招聘一個靠譜的 iOS》，其中共55題，除第一題爲糾錯題外，其餘54道均爲簡答題。ios

傳送門
iOS開發之高級面試題（二）git

iOS開發之高級面試題（三)github

iOS開發之高級面試題（四）面試

1. 風格糾錯題

修改完的代碼：安全

修改方法有不少種，現給出一種作示例：網絡

// .h文件
// http://weibo.com/luohanchenyilong/
// https://github.com/ChenYilong
// 修改完的代碼，這是第一種修改方法，後面會給出第二種修改方法

typedef NS_ENUM(NSInteger, CYLSex) {
    CYLSexMan,
    CYLSexWoman
};

@interface CYLUser : NSObject<NSCopying>

@property (nonatomic, readonly, copy) NSString *name;
@property (nonatomic, readonly, assign) NSUInteger age;
@property (nonatomic, readonly, assign) CYLSex sex;

- (instancetype)initWithName:(NSString *)name age:(NSUInteger)age sex:(CYLSex)sex;
+ (instancetype)userWithName:(NSString *)name age:(NSUInteger)age sex:(CYLSex)sex;

@end

下面對具體修改的地方，分兩部分作下介紹：硬傷部分和優化部分。由於硬傷部分沒什麼技術含量，爲了節省你們時間，放在後面講，大神請直接看優化部分。數據結構

優化部分

enum 建議使用 NS_ENUM 和 NS_OPTIONS 宏來定義枚舉類型，參見官方的 Adopting Modern Objective-C 一文：
```
//定義一個枚舉
typedef NS_ENUM(NSInteger, CYLSex) {
    CYLSexMan,
    CYLSexWoman
};
```
（僅僅讓性別包含男和女可能並不嚴謹，最嚴謹的作法能夠參考這裏。）
age 屬性的類型：應避免使用基本類型，建議使用 Foundation 數據類型，對應關係以下：
```
int -> NSInteger
  unsigned -> NSUInteger
  float -> CGFloat
  動畫時間 -> NSTimeInterval
```
同時考慮到 age 的特色，應使用 NSUInteger ，而非 int 。這樣作的是基於64-bit 適配考慮，詳情可參考出題者的博文《64-bit Tips》。
若是工程項目很是龐大，須要拆分紅不一樣的模塊，能夠在類、typedef宏命名的時候使用前綴。
doLogIn方法不該寫在該類中：

~~雖然LogIn的命名不太清晰，但筆者猜想是login的意思，（勘誤：Login是名詞，LogIn 是動詞，都表示登錄的意思。見： Log in vs. login ）~~

登陸操做屬於業務邏輯，觀察類名 UserModel ，以及屬性的命名方式，該類應該是一個 Model 而不是一個「 MVVM 模式下的 ViewModel 」：

不管是 MVC 模式仍是 MVVM 模式，業務邏輯都不該當寫在 Model 裏：MVC 應在 C，MVVM 應在 VM。

（若是拋開命名規範，假設該類真的是 MVVM 模式裏的 ViewModel ，那麼 UserModel 這個類可能對應的是用戶註冊頁面，若是有特殊的業務需求，好比： -logIn 對應的應當是註冊並登陸的一個 Button ，出現 -logIn 方法也多是合理的。）
doLogIn 方法命名不規範：添加了多餘的動詞前綴。請牢記：

若是方法表示讓對象執行一個動做，使用動詞打頭來命名，注意不要使用 do，does 這種多餘的關鍵字，動詞自己的暗示就足夠了。

應爲 -logIn （注意： Login 是名詞， LogIn 是動詞，都表示登錄。見 Log in vs. login ）
-(id)initUserModelWithUserName: (NSString*)name withAge:(int)age;方法中不要用 with 來鏈接兩個參數: withAge:應當換爲age:，age: 已經足以清晰說明參數的做用，也不建議用 andAge: ：一般狀況下，即便有相似 withA:withB:的命名需求，也一般是使用withA:andB: 這種命名，用來表示方法執行了兩個相對獨立的操做（從設計上來講，這時候也能夠拆分紅兩個獨立的方法），它不該該用做闡明有多個參數，好比下面的：
```
//錯誤，不要使用"and"來鏈接參數
- (int)runModalForDirectory:(NSString *)path andFile:(NSString *)name andTypes:(NSArray *)fileTypes;
//錯誤，不要使用"and"來闡明有多個參數
- (instancetype)initWithName:(CGFloat)width andAge:(CGFloat)height;
//正確，使用"and"來表示兩個相對獨立的操做
- (BOOL)openFile:(NSString *)fullPath withApplication:(NSString *)appName andDeactivate:(BOOL)flag;
```
因爲字符串值可能會改變，因此要把相關屬性的「內存管理語義」聲明爲 copy 。(緣由在下文有詳細論述：用@property聲明的NSString（或NSArray，NSDictionary）常用copy關鍵字，爲何？)
「性別」(sex）屬性的：該類中只給出了一種「初始化方法」 (initializer)用於設置「姓名」(Name)和「年齡」(Age)的初始值，那如何對「性別」(Sex）初始化？

Objective-C 有 designated 和 secondary 初始化方法的觀念。 designated 初始化方法是提供全部的參數，secondary 初始化方法是一個或多個，而且提供一個或者更多的默認參數來調用 designated 初始化方法的初始化方法。舉例說明：
```
// .m文件
  // http://weibo.com/luohanchenyilong/
  // https://github.com/ChenYilong
  //

  @implementation CYLUser

  - (instancetype)initWithName:(NSString *)name
                           age:(NSUInteger)age
                           sex:(CYLSex)sex {
      if(self = [super init]) {
          _name = [name copy];
          _age = age;
          _sex = sex;
      }
      return self;
  }

  - (instancetype)initWithName:(NSString *)name
                           age:(NSUInteger)age {
      return [self initWithName:name age:age sex:nil];
  }

  @end
```
上面的代碼中initWithName:age:sex: 就是 designated 初始化方法，另外的是 secondary 初始化方法。由於僅僅是調用類實現的 designated 初始化方法。

由於出題者沒有給出 .m 文件，因此有兩種猜想：1：原本打算只設計一個 designated 初始化方法，但漏掉了「性別」(sex）屬性。那麼最終的修改代碼就是上文給出的第一種修改方法。2：不打算初始時初始化「性別」(sex）屬性，打算後期再修改，若是是這種狀況，那麼應該把「性別」(sex）屬性設爲 readwrite 屬性，最終給出的修改代碼應該是：
```
// .h文件
  // http://weibo.com/luohanchenyilong/
  // https://github.com/ChenYilong
  // 第二種修改方法（基於第一種修改方法的基礎上）

  typedef NS_ENUM(NSInteger, CYLSex) {
      CYLSexMan,
      CYLSexWoman
  };

  @interface CYLUser : NSObject<NSCopying>

  @property (nonatomic, readonly, copy) NSString *name;
  @property (nonatomic, readonly, assign) NSUInteger age;
  @property (nonatomic, readwrite, assign) CYLSex sex;

  - (instancetype)initWithName:(NSString *)name age:(NSUInteger)age sex:(CYLSex)sex;
  - (instancetype)initWithName:(NSString *)name age:(NSUInteger)age;
  + (instancetype)userWithName:(NSString *)name age:(NSUInteger)age sex:(CYLSex)sex;

  @end
```
.h 中暴露 designated 初始化方法，是爲了方便子類化（想了解更多，請戳--》《禪與 Objective-C 編程藝術（Zen and the Art of the Objective-C Craftsmanship 中文翻譯）》。）
按照接口設計的慣例，若是設計了「初始化方法」 (initializer)，也應當搭配一個快捷構造方法。而快捷構造方法的返回值，建議爲 instancetype，爲保持一致性，init 方法和快捷構造方法的返回類型最好都用 instancetype。
若是基於第一種修改方法：既然該類中已經有一個「初始化方法」 (initializer)，用於設置「姓名」(Name)、「年齡」(Age)和「性別」(Sex）的初始值: 那麼在設計對應 @property 時就應該儘可能使用不可變的對象：其三個屬性都應該設爲「只讀」。用初始化方法設置好屬性值以後，就不能再改變了。在本例中，仍需聲明屬性的「內存管理語義」。因而能夠把屬性的定義改爲這樣

```source-objc
      @property (nonatomic, readonly, copy) NSString *name;
      @property (nonatomic, readonly, assign) NSUInteger age;
      @property (nonatomic, readonly, assign) CYLSex sex;
```

```
因爲是隻讀屬性，因此編譯器不會爲其建立對應的「設置方法」，即使如此，咱們仍是要寫上這些屬性的語義，以此代表初始化方法在設置這些屬性值時所用的方式。要是不寫明語義的話，該類的調用者就不知道初始化方法裏會拷貝這些屬性，他們有可能會在調用初始化方法以前自行拷貝屬性值。這種操做多餘並且低效。

```

initUserModelWithUserName 若是改成 initWithName 會更加簡潔，並且足夠清晰。
UserModel 若是改成 User 會更加簡潔，並且足夠清晰。
UserSex若是改成Sex 會更加簡潔，並且足夠清晰。
第二個 @property 中 assign 和 nonatomic 調換位置。推薦按照下面的格式來定義屬性

```source-objc
@property (nonatomic, readwrite, copy) NSString *name;
```

屬性的參數應該按照下面的順序排列： 原子性，讀寫 和 內存管理。 這樣作你的屬性更容易修改正確，而且更好閱讀。這在[《禪與Objective-C編程藝術 >》](https://github.com/oa414/objc-zen-book-cn#%E5%B1%9E%E6%80%A7%E5%AE%9A%E4%B9%89)裏有介紹。並且習慣上修改某個屬性的修飾符時，通常從屬性名從右向左搜索須要修動的修飾符。最可能從最右邊開始修改這些屬性的修飾符，根據經驗這些修飾符被修改的可能性從高到底應爲：內存管理 > 讀寫權限 >原子操做。

硬傷部分

在-和(void)之間應該有一個空格
enum 中駝峯命名法和下劃線命名法混用錯誤：枚舉類型的命名規則和函數的命名規則相同：命名時使用駝峯命名法，勿使用下劃線命名法。
enum 左括號前加一個空格，或者將左括號換到下一行
enum 右括號後加一個空格
UserModel :NSObject 應爲UserModel : NSObject，也就是:右側少了一個空格。
@interface 與 @property 屬性聲明中間應當間隔一行。
兩個方法定義之間不須要換行，有時爲了區分方法的功能也可間隔一行，但示例代碼中間隔了兩行。
-(id)initUserModelWithUserName: (NSString*)name withAge:(int)age;方法中方法名與參數之間多了空格。並且 - 與 (id) 之間少了空格。
-(id)initUserModelWithUserName: (NSString*)name withAge:(int)age;方法中方法名與參數之間多了空格：(NSString*)name 前多了空格。
-(id)initUserModelWithUserName: (NSString*)name withAge:(int)age; 方法中 (NSString*)name,應爲 (NSString *)name，少了空格。
doLogIn方法中的 LogIn 命名不清晰：筆者猜想是login的意思，應該是粗心手誤形成的。（勘誤： Login 是名詞， LogIn 是動詞，都表示登錄的意思。見： Log in vs. login ）

2. 什麼狀況使用 weak 關鍵字，相比 assign 有什麼不一樣？

什麼狀況使用 weak 關鍵字？

在 ARC 中,在有可能出現循環引用的時候,每每要經過讓其中一端使用 weak 來解決,好比: delegate 代理屬性
自身已經對它進行一次強引用,沒有必要再強引用一次,此時也會使用 weak,自定義 IBOutlet 控件屬性通常也使用 weak；固然，也可使用strong。在下文也有論述：《IBOutlet連出來的視圖屬性爲何能夠被設置成weak?》

不一樣點：

weak 此特質代表該屬性定義了一種「非擁有關係」 (nonowning relationship)。爲這種屬性設置新值時，設置方法既不保留新值，也不釋放舊值。此特質同assign相似，然而在屬性所指的對象遭到摧毀時，屬性值也會清空(nil out)。而 assign的「設置方法」只會執行鍼對「純量類型」 (scalar type，例如 CGFloat 或 NSlnteger 等)的簡單賦值操做。
assigin 能夠用非 OC 對象,而 weak 必須用於 OC 對象

3. 怎麼用 copy 關鍵字？

用途：

NSString、NSArray、NSDictionary 等等常用copy關鍵字，是由於他們有對應的可變類型：NSMutableString、NSMutableArray、NSMutableDictionary；
block 也常用 copy 關鍵字，具體緣由見官方文檔：Objects Use Properties to Keep Track of Blocks：

block 使用 copy 是從 MRC 遺留下來的「傳統」,在 MRC 中,方法內部的 block 是在棧區的,使用 copy 能夠把它放到堆區.在 ARC 中寫不寫都行：對於 block 使用 copy 仍是 strong 效果是同樣的，但寫上 copy 也無傷大雅，還能時刻提醒咱們：編譯器自動對 block 進行了 copy 操做。若是不寫 copy ，該類的調用者有可能會忘記或者根本不知道「編譯器會自動對 block 進行了 copy 操做」，他們有可能會在調用以前自行拷貝屬性值。這種操做多餘而低效。

下面作下解釋： copy 此特質所表達的所屬關係與 strong 相似。然而設置方法並不保留新值，而是將其「拷貝」 (copy)。當屬性類型爲 NSString 時，常常用此特質來保護其封裝性，由於傳遞給設置方法的新值有可能指向一個 NSMutableString 類的實例。這個類是 NSString 的子類，表示一種可修改其值的字符串，此時如果不拷貝字符串，那麼設置完屬性以後，字符串的值就可能會在對象不知情的狀況下遭人更改。因此，這時就要拷貝一份「不可變」 (immutable)的字符串，確保對象中的字符串值不會無心間變更。只要實現屬性所用的對象是「可變的」 (mutable)，就應該在設置新屬性值時拷貝一份。

用 @property 聲明 NSString、NSArray、NSDictionary 常用 copy 關鍵字，是由於他們有對應的可變類型：NSMutableString、NSMutableArray、NSMutableDictionary，他們之間可能進行賦值操做，爲確保對象中的字符串值不會無心間變更，應該在設置新屬性值時拷貝一份。

該問題在下文中也有論述：用@property聲明的NSString（或NSArray，NSDictionary）常用copy關鍵字，爲何？若是改用strong關鍵字，可能形成什麼問題？

4. 這個寫法會出什麼問題： `@property (copy) NSMutableArray *array;`

兩個問題：一、添加,刪除,修改數組內的元素的時候,程序會由於找不到對應的方法而崩潰.由於 copy 就是複製一個不可變 NSArray 的對象；二、使用了 atomic 屬性會嚴重影響性能；

第1條的相關緣由在下文中有論述《用@property聲明的NSString（或NSArray，NSDictionary）常用 copy 關鍵字，爲何？若是改用strong關鍵字，可能形成什麼問題？》以及上文《怎麼用 copy 關鍵字？》也有論述。

好比下面的代碼就會發生崩潰

// .h文件
// http://weibo.com/luohanchenyilong/
// https://github.com/ChenYilong
// 下面的代碼就會發生崩潰

@property (nonatomic, copy) NSMutableArray *mutableArray;

// .m文件
// http://weibo.com/luohanchenyilong/
// https://github.com/ChenYilong
// 下面的代碼就會發生崩潰

NSMutableArray *array = [NSMutableArray arrayWithObjects:@1,@2,nil];
self.mutableArray = array;
[self.mutableArray removeObjectAtIndex:0];

接下來就會奔潰：

-[__NSArrayI removeObjectAtIndex:]: unrecognized selector sent to instance 0x7fcd1bc30460

第2條緣由，以下：

該屬性使用了同步鎖，會在建立時生成一些額外的代碼用於幫助編寫多線程程序，這會帶來性能問題，經過聲明 nonatomic 能夠節省這些雖然很小可是沒必要要額外開銷。

在默認狀況下，由編譯器所合成的方法會經過鎖定機制確保其原子性(atomicity)。若是屬性具有 nonatomic 特質，則不使用同步鎖。請注意，儘管沒有名爲「atomic」的特質(若是某屬性不具有 nonatomic 特質，那它就是「原子的」(atomic))。

在iOS開發中，你會發現，幾乎全部屬性都聲明爲 nonatomic。

通常狀況下並不要求屬性必須是「原子的」，由於這並不能保證「線程安全」 ( thread safety)，若要實現「線程安全」的操做，還需採用更爲深層的鎖定機制才行。例如，一個線程在連續屢次讀取某屬性值的過程當中有別的線程在同時改寫該值，那麼即使將屬性聲明爲 atomic，也仍是會讀到不一樣的屬性值。

所以，開發iOS程序時通常都會使用 nonatomic 屬性。可是在開發 Mac OS X 程序時，使用 atomic 屬性一般都不會有性能瓶頸。

5. 如何讓本身的類用 copy 修飾符？如何重寫帶 copy 關鍵字的 setter？

若想令本身所寫的對象具備拷貝功能，則需實現 NSCopying 協議。若是自定義的對象分爲可變版本與不可變版本，那麼就要同時實現 NSCopying 與 NSMutableCopying 協議。

具體步驟：

需聲明該類聽從 NSCopying 協議
實現 NSCopying 協議。該協議只有一個方法:
```
- (id)copyWithZone:(NSZone *)zone;
```
注意：一提到讓本身的類用 copy 修飾符，咱們老是想覆寫copy方法，其實真正須要實現的倒是「copyWithZone」方法。

以第一題的代碼爲例：

// .h文件
    // http://weibo.com/luohanchenyilong/
    // https://github.com/ChenYilong
    // 修改完的代碼

    typedef NS_ENUM(NSInteger, CYLSex) {
        CYLSexMan,
        CYLSexWoman
    };

    @interface CYLUser : NSObject<NSCopying>

    @property (nonatomic, readonly, copy) NSString *name;
    @property (nonatomic, readonly, assign) NSUInteger age;
    @property (nonatomic, readonly, assign) CYLSex sex;

    - (instancetype)initWithName:(NSString *)name age:(NSUInteger)age sex:(CYLSex)sex;
    + (instancetype)userWithName:(NSString *)name age:(NSUInteger)age sex:(CYLSex)sex;

    @end

而後實現協議中規定的方法：

- (id)copyWithZone:(NSZone *)zone {
    CYLUser *copy = [[[self class] allocWithZone:zone] 
                     initWithName:_name
                                  age:_age
                                  sex:_sex];
    return copy;
}

但在實際的項目中，不可能這麼簡單，遇到更復雜一點，好比類對象中的數據結構可能並未在初始化方法中設置好，須要另行設置。舉個例子，假如 CYLUser 中含有一個數組，與其餘 CYLUser 對象創建或解除朋友關係的那些方法都須要操做這個數組。那麼在這種狀況下，你得把這個包含朋友對象的數組也一併拷貝過來。下面列出了實現此功能所需的所有代碼:

// .h文件
// http://weibo.com/luohanchenyilong/
// https://github.com/ChenYilong
// 以第一題《風格糾錯題》裏的代碼爲例

typedef NS_ENUM(NSInteger, CYLSex) {
    CYLSexMan,
    CYLSexWoman
};

@interface CYLUser : NSObject<NSCopying>

@property (nonatomic, readonly, copy) NSString *name;
@property (nonatomic, readonly, assign) NSUInteger age;
@property (nonatomic, readonly, assign) CYLSex sex;

- (instancetype)initWithName:(NSString *)name age:(NSUInteger)age sex:(CYLSex)sex;
+ (instancetype)userWithName:(NSString *)name age:(NSUInteger)age sex:(CYLSex)sex;
- (void)addFriend:(CYLUser *)user;
- (void)removeFriend:(CYLUser *)user;

@end

// .m文件

// .m文件
// http://weibo.com/luohanchenyilong/
// https://github.com/ChenYilong
//

@implementation CYLUser {
    NSMutableSet *_friends;
}

- (void)setName:(NSString *)name {
    _name = [name copy];
}

- (instancetype)initWithName:(NSString *)name
                         age:(NSUInteger)age
                         sex:(CYLSex)sex {
    if(self = [super init]) {
        _name = [name copy];
        _age = age;
        _sex = sex;
        _friends = [[NSMutableSet alloc] init];
    }
    return self;
}

- (void)addFriend:(CYLUser *)user {
    [_friends addObject:user];
}

- (void)removeFriend:(CYLUser *)user {
    [_friends removeObject:person];
}

- (id)copyWithZone:(NSZone *)zone {
    CYLUser *copy = [[[self class] allocWithZone:zone]
                     initWithName:_name
                     age:_age
                     sex:_sex];
    copy->_friends = [_friends mutableCopy];
    return copy;
}

- (id)deepCopy {
    CYLUser *copy = [[[self class] allocWithZone:zone]
                     initWithName:_name
                     age:_age
                     sex:_sex];
    copy->_friends = [[NSMutableSet alloc] initWithSet:_friends
                                             copyItems:YES];
    return copy;
}

@end

以上作法能知足基本的需求，可是也有缺陷：

若是你所寫的對象須要深拷貝，那麼可考慮新增一個專門執行深拷貝的方法。

【注：深淺拷貝的概念，在下文中有介紹，詳見下文的：用@property聲明的 NSString（或NSArray，NSDictionary）常用 copy 關鍵字，爲何？若是改用 strong 關鍵字，可能形成什麼問題？】

在例子中，存放朋友對象的 set 是用「copyWithZone:」方法來拷貝的，這種淺拷貝方式不會逐個複製 set 中的元素。若須要深拷貝的話，則可像下面這樣，編寫一個專供深拷貝所用的方法:

- (id)deepCopy {
    CYLUser *copy = [[[self class] allocWithZone:zone]
                     initWithName:_name
                     age:_age
                     sex:_sex];
    copy->_friends = [[NSMutableSet alloc] initWithSet:_friends
                                             copyItems:YES];
    return copy;
}

至於如何重寫帶 copy 關鍵字的 setter這個問題，

若是拋開本例來回答的話，以下：

- (void)setName:(NSString *)name {
    //[_name release];
    _name = [name copy];
}

不過也有爭議，有人說「蘋果若是像下面這樣幹，是否是效率會高一些？」

- (void)setName:(NSString *)name {
    if (_name != name) {
        //[_name release];//MRC
        _name = [name copy];
    }
}

這樣真得高效嗎？不見得！這種寫法「看上去很美、很合理」，但在實際開發中，它更像下圖裏的作法：

克強總理這樣評價你的代碼風格：

我和總理的意見基本一致：

老百姓 copy 一下，咋就這麼難？

你可能會說：

之因此在這裏作if判斷 這個操做：是由於一個 if 可能避免一個耗時的copy，仍是很划算的。 (在剛剛講的：《如何讓本身的類用 copy 修飾符？》裏的那種複雜的copy，咱們能夠稱之爲「耗時的copy」，可是對 NSString 的 copy 還稱不上。)

可是你有沒有考慮過代價：

你每次調用 setX: 都會作 if 判斷，這會讓 setX: 變慢，若是你在 setX:寫了一串複雜的 if+elseif+elseif+... 判斷，將會更慢。

要回答「哪一個效率會高一些？」這個問題，不能脫離實際開發，就算 copy 操做十分耗時，if 判斷也不見得必定會更快，除非你把一個「 @property他當前的值」賦給了他本身，代碼看起來就像：

[a setX:x1];
[a setX:x1];    //你肯定你要這麼幹？與其在setter中判斷，爲何不把代碼寫好？

或者

[a setX:[a x]];   //隊友咆哮道：你在幹嗎？！！

不要在 setter 裏進行像 if(_obj != newObj) 這樣的判斷。（該觀點參考連接： How To Write Cocoa Object Setters： Principle 3: Only Optimize After You Measure ）

什麼狀況會在 copy setter 裏作 if 判斷？例如，車速可能就有最高速的限制，車速也不可能出現負值，若是車子的最高速爲300，則 setter 的方法就要改寫成這樣：

-(void)setSpeed:(int)_speed{
    if(_speed < 0) speed = 0;
    if(_speed > 300) speed = 300;
    _speed = speed;
}

回到這個題目，若是單單就上文的代碼而言，咱們不須要也不能重寫 name 的 setter ：因爲是 name 是隻讀屬性，因此編譯器不會爲其建立對應的「設置方法」，用初始化方法設置好屬性值以後，就不能再改變了。（在本例中，之因此還要聲明屬性的「內存管理語義」--copy，是由於：若是不寫 copy，該類的調用者就不知道初始化方法裏會拷貝這些屬性，他們有可能會在調用初始化方法以前自行拷貝屬性值。這種操做多餘而低效）。

那如何確保 name 被 copy？在初始化方法(initializer)中作：

- (instancetype)initWithName:(NSString *)name 
                                 age:(NSUInteger)age 
                                 sex:(CYLSex)sex {
         if(self = [super init]) {
            _name = [name copy];
            _age = age;
            _sex = sex;
            _friends = [[NSMutableSet alloc] init];
         }
         return self;
    }

6. @property 的本質是什麼？ivar、getter、setter 是如何生成並添加到這個類中的

@property 的本質是什麼？

@property = ivar + getter + setter;

下面解釋下：

「屬性」 (property)有兩大概念：ivar（實例變量）、存取方法（access method ＝ getter + setter）。

「屬性」 (property)做爲 Objective-C 的一項特性，主要的做用就在於封裝對象中的數據。 Objective-C 對象一般會把其所須要的數據保存爲各類實例變量。實例變量通常經過「存取方法」(access method)來訪問。其中，「獲取方法」 (getter)用於讀取變量值，而「設置方法」 (setter)用於寫入變量值。這個概念已經定型，而且經由「屬性」這一特性而成爲 Objective-C 2.0 的一部分。而在正規的 Objective-C 編碼風格中，存取方法有着嚴格的命名規範。正由於有了這種嚴格的命名規範，因此 Objective-C 這門語言才能根據名稱自動建立出存取方法。其實也能夠把屬性當作一種關鍵字，其表示:

編譯器會自動寫出一套存取方法，用以訪問給定類型中具備給定名稱的變量。因此你也能夠這麼說：

@property = getter + setter;

例以下面這個類：

@interface Person : NSObject
@property NSString *firstName;
@property NSString *lastName;
@end

上述代碼寫出來的類與下面這種寫法等效：

@interface Person : NSObject
- (NSString *)firstName;
- (void)setFirstName:(NSString *)firstName;
- (NSString *)lastName;
- (void)setLastName:(NSString *)lastName;
@end

ivar、getter、setter 是如何生成並添加到這個類中的?

「自動合成」( autosynthesis)

完成屬性定義後，編譯器會自動編寫訪問這些屬性所需的方法，此過程叫作「自動合成」(autosynthesis)。須要強調的是，這個過程由編譯器在編譯期執行，因此編輯器裏看不到這些「合成方法」(synthesized method)的源代碼。除了生成方法代碼 getter、setter 以外，編譯器還要自動向類中添加適當類型的實例變量，而且在屬性名前面加下劃線，以此做爲實例變量的名字。在前例中，會生成兩個實例變量，其名稱分別爲 _firstName 與 _lastName。也能夠在類的實現代碼裏經過 @synthesize語法來指定實例變量的名字.

@implementation Person
@synthesize firstName = _myFirstName;
@synthesize lastName = _myLastName;
@end

我爲了搞清屬性是怎麼實現的,曾經反編譯過相關的代碼,他大體生成了五個東西

OBJC_IVAR_$類名$屬性名稱 ：該屬性的「偏移量」 (offset)，這個偏移量是「硬編碼」 (hardcode)，表示該變量距離存放對象的內存區域的起始地址有多遠。
setter 與 getter 方法對應的實現函數
ivar_list ：成員變量列表
method_list ：方法列表
prop_list ：屬性列表

也就是說咱們每次在增長一個屬性,系統都會在 ivar_list 中添加一個成員變量的描述,在 method_list 中增長 setter 與 getter 方法的描述,在屬性列表中增長一個屬性的描述,而後計算該屬性在對象中的偏移量,而後給出 setter 與 getter 方法對應的實現,在 setter 方法中從偏移量的位置開始賦值,在 getter 方法中從偏移量開始取值,爲了可以讀取正確字節數,系統對象偏移量的指針類型進行了類型強轉.

7. @protocol 和 category 中如何使用 @property

在 protocol 中使用 property 只會生成 setter 和 getter 方法聲明,咱們使用屬性的目的,是但願遵照我協議的對象能實現該屬性
category 使用 @property 也是隻會生成 setter 和 getter 方法的聲明,若是咱們真的須要給 category 增長屬性的實現,須要藉助於運行時的兩個函數：
1. objc_setAssociatedObject
2. objc_getAssociatedObject

8. runtime 如何實現 weak 屬性

要實現 weak 屬性，首先要搞清楚 weak 屬性的特色：

weak 此特質代表該屬性定義了一種「非擁有關係」 (nonowning relationship)。爲這種屬性設置新值時，設置方法既不保留新值，也不釋放舊值。此特質同 assign 相似，然而在屬性所指的對象遭到摧毀時，屬性值也會清空(nil out)。

那麼 runtime 如何實現 weak 變量的自動置nil？

runtime 對註冊的類，會進行佈局，對於 weak 對象會放入一個 hash 表中。用 weak 指向的對象內存地址做爲 key，當此對象的引用計數爲0的時候會 dealloc，假如 weak 指向的對象內存地址是a，那麼就會以a爲鍵，在這個 weak 表中搜索，找到全部以a爲鍵的 weak 對象，從而設置爲 nil。

（注：在下文的《使用runtime Associate方法關聯的對象，須要在主對象dealloc的時候釋放麼？》裏給出的「對象的內存銷燬時間表」也提到__weak引用的解除時間。）

咱們能夠設計一個函數（僞代碼）來表示上述機制：

objc_storeWeak(&a, b)函數：

objc_storeWeak函數把第二個參數--賦值對象（b）的內存地址做爲鍵值key，將第一個參數--weak修飾的屬性變量（a）的內存地址（&a）做爲value，註冊到 weak 表中。若是第二個參數（b）爲0（nil），那麼把變量（a）的內存地址（&a）從weak表中刪除，

你能夠把objc_storeWeak(&a, b)理解爲：objc_storeWeak(value, key)，而且當key變nil，將value置nil。

在b非nil時，a和b指向同一個內存地址，在b變nil時，a變nil。此時向a發送消息不會崩潰：在Objective-C中向nil發送消息是安全的。

而若是a是由 assign 修飾的，則：在 b 非 nil 時，a 和 b 指向同一個內存地址，在 b 變 nil 時，a 仍是指向該內存地址，變野指針。此時向 a 發送消息極易崩潰。

下面咱們將基於objc_storeWeak(&a, b)函數，使用僞代碼模擬「runtime如何實現weak屬性」：

// 使用僞代碼模擬：runtime如何實現weak屬性
// http://weibo.com/luohanchenyilong/
// https://github.com/ChenYilong

 id obj1;
 objc_initWeak(&obj1, obj);
/*obj引用計數變爲0，變量做用域結束*/
 objc_destroyWeak(&obj1);

下面對用到的兩個方法objc_initWeak和objc_destroyWeak作下解釋：

整體說來，做用是：經過objc_initWeak函數初始化「附有weak修飾符的變量（obj1）」，在變量做用域結束時經過objc_destoryWeak函數釋放該變量（obj1）。

下面分別介紹下方法的內部實現：

objc_initWeak函數的實現是這樣的：在將「附有weak修飾符的變量（obj1）」初始化爲0（nil）後，會將「賦值對象」（obj）做爲參數，調用objc_storeWeak函數。

obj1 = 0；
obj_storeWeak(&obj1, obj);

也就是說：

weak 修飾的指針默認值是 nil （在Objective-C中向nil發送消息是安全的）

而後obj_destroyWeak函數將0（nil）做爲參數，調用objc_storeWeak函數。

objc_storeWeak(&obj1, 0);

前面的源代碼與下列源代碼相同。

// 使用僞代碼模擬：runtime如何實現weak屬性
// http://weibo.com/luohanchenyilong/
// https://github.com/ChenYilong

id obj1;
obj1 = 0;
objc_storeWeak(&obj1, obj);
/* ... obj的引用計數變爲0，被置nil ... */
objc_storeWeak(&obj1, 0);

objc_storeWeak 函數把第二個參數--賦值對象（obj）的內存地址做爲鍵值，將第一個參數--weak修飾的屬性變量（obj1）的內存地址註冊到 weak 表中。若是第二個參數（obj）爲0（nil），那麼把變量（obj1）的地址從 weak 表中刪除，在後面的相關一題會詳解。

使用僞代碼是爲了方便理解，下面咱們「真槍實彈」地實現下：

如何讓不使用weak修飾的@property，擁有weak的效果。

咱們從setter方法入手：

- (void)setObject:(NSObject *)object
{
    objc_setAssociatedObject(self, "object", object, OBJC_ASSOCIATION_ASSIGN);
    [object cyl_runAtDealloc:^{
        _object = nil;
    }];
}

也就是有兩個步驟：

在setter方法中作以下設置：

objc_setAssociatedObject(self, "object", object, OBJC_ASSOCIATION_ASSIGN);

在屬性所指的對象遭到摧毀時，屬性值也會清空(nil out)。作到這點，一樣要藉助 runtime：

//要銷燬的目標對象
id objectToBeDeallocated;
//能夠理解爲一個「事件」：當上面的目標對象銷燬時，同時要發生的「事件」。
id objectWeWantToBeReleasedWhenThatHappens;
objc_setAssociatedObject(objectToBeDeallocted,
                     someUniqueKey,
                     objectWeWantToBeReleasedWhenThatHappens,
                     OBJC_ASSOCIATION_RETAIN);

知道了思路，咱們就開始實現 cyl_runAtDealloc 方法，實現過程分兩部分：

第一部分：建立一個類，能夠理解爲一個「事件」：當目標對象銷燬時，同時要發生的「事件」。藉助 block 執行「事件」。

// .h文件

// .h文件
// http://weibo.com/luohanchenyilong/
// https://github.com/ChenYilong
// 這個類，能夠理解爲一個「事件」：當目標對象銷燬時，同時要發生的「事件」。藉助block執行「事件」。

typedef void (^voidBlock)(void);

@interface CYLBlockExecutor : NSObject

- (id)initWithBlock:(voidBlock)block;

@end

// .m文件

// .m文件
// http://weibo.com/luohanchenyilong/
// https://github.com/ChenYilong
// 這個類，能夠理解爲一個「事件」：當目標對象銷燬時，同時要發生的「事件」。藉助block執行「事件」。

#import "CYLBlockExecutor.h"

@interface CYLBlockExecutor() {
    voidBlock _block;
}
@implementation CYLBlockExecutor

- (id)initWithBlock:(voidBlock)aBlock
{
    self = [super init];

    if (self) {
        _block = [aBlock copy];
    }

    return self;
}

- (void)dealloc
{
    _block ? _block() : nil;
}

@end

第二部分：核心代碼：利用runtime實現cyl_runAtDealloc方法

// CYLNSObject+RunAtDealloc.h文件
// http://weibo.com/luohanchenyilong/
// https://github.com/ChenYilong
// 利用runtime實現cyl_runAtDealloc方法

#import "CYLBlockExecutor.h"

const void *runAtDeallocBlockKey = &runAtDeallocBlockKey;

@interface NSObject (CYLRunAtDealloc)

- (void)cyl_runAtDealloc:(voidBlock)block;

@end

// CYLNSObject+RunAtDealloc.m文件
// http://weibo.com/luohanchenyilong/
// https://github.com/ChenYilong
// 利用runtime實現cyl_runAtDealloc方法

#import "CYLNSObject+RunAtDealloc.h"
#import "CYLBlockExecutor.h"

@implementation NSObject (CYLRunAtDealloc)

- (void)cyl_runAtDealloc:(voidBlock)block
{
    if (block) {
        CYLBlockExecutor *executor = [[CYLBlockExecutor alloc] initWithBlock:block];

        objc_setAssociatedObject(self,
                                 runAtDeallocBlockKey,
                                 executor,
                                 OBJC_ASSOCIATION_RETAIN);
    }
}

@end

使用方法：導入

#import "CYLNSObject+RunAtDealloc.h"

而後就可使用了：

NSObject *foo = [[NSObject alloc] init];

[foo cyl_runAtDealloc:^{
    NSLog(@"正在釋放foo!");
}];

若是對 cyl_runAtDealloc 的實現原理有興趣，能夠看下這篇博文 Fun With the Objective-C Runtime: Run Code at Deallocation of Any Object

iOS開發之高級面試題（二）

iOS開發之高級面試題（三)

iOS開發之高級面試題（四）

圖文來源於網絡，若有侵權請聯繫小編刪除

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。