美丽姑娘在线观看免费,国产精品无码亚洲8090,韩国电影免费观看高清完整版在线观看

面試驅動技術合集（初中級iOS開發），關注倉庫，及時獲取更新 Interview-series

image

I. Category

Category相關面試題

Category實現原理？
實際開發中，你用Category做了哪些事？
Category能否添加成員變量，如果可以，如何添加？
load 、initialize方法的區別是什么，他們在category中的調用順序？以及出現繼承時他們之間的調用過程？
Category 和 Class Extension的區別是什么？
為什么分類會“覆蓋”宿主類的方法？

1.Category的特點

運行時決議
- 通過 runtime 動態將分類的方法合并到類對象、元類對象中
- 實例方法合并到類對象中，類方法合并到元類對象中
可以為系統類添加分類

2.分類中可以添加哪些內容

實例方法
類方法
協議
屬性

分類中原理解析

使用 xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc MNPerson+Test.m 函數，生產一個cpp文件,窺探其底層結構(編譯狀態)

struct _category_t {
    //宿主類名稱 - 這里的MNPerson
    const char *name;
    
    //宿主類對象,里面有isa
    struct _class_t *cls;
    
    //實例方法列表
    const struct _method_list_t *instance_methods;
    
    //類方法列表
    const struct _method_list_t *class_methods;
    
    //協議列表
    const struct _protocol_list_t *protocols;
    
    //屬性列表
    const struct _prop_list_t *properties;
};

//_class_t 結構
struct _class_t {
    struct _class_t *isa;
    struct _class_t *superclass;
    void *cache;
    void *vtable;
    struct _class_ro_t *ro;
};

每個分類都是獨立的
每個分類的結構都一致，都是category_t

函數轉換

@implementation MNPerson (Test)

- (void)test{
    NSLog(@"test - rua~");
}

@end

image

static void 
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
    if (!cats) return;
    if (PrintReplacedMethods) printReplacements(cls, cats);

    bool isMeta = cls->isMetaClass();

    // fixme rearrange to remove these intermediate allocations
    
    /* 二維數組( **mlists => 兩顆星星，一個)
     [
        [method_t,],
        [method_t,method_t],
        [method_t,method_t,method_t],
     ]
     
     */
    method_list_t **mlists = (method_list_t **)
        malloc(cats->count * sizeof(*mlists));
    property_list_t **proplists = (property_list_t **)
        malloc(cats->count * sizeof(*proplists));
    protocol_list_t **protolists = (protocol_list_t **)
        malloc(cats->count * sizeof(*protolists));

    // Count backwards through cats to get newest categories first
    int mcount = 0;
    int propcount = 0;
    int protocount = 0;
    int i = cats->count;//宿主類，分類的總數
    bool fromBundle = NO;
    while (i--) {//倒序遍歷，最先訪問最后編譯的分類
        
        // 獲取某一個分類
        auto& entry = cats->list[i];

        // 分類的方法列表
        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
        if (mlist) {
            //最后編譯的分類，最先添加到分類數組中
            mlists[mcount++] = mlist;
            fromBundle |= entry.hi->isBundle();
        }

        property_list_t *proplist = 
            entry.cat->propertiesForMeta(isMeta, entry.hi);
        if (proplist) {
            proplists[propcount++] = proplist;
        }

        protocol_list_t *protolist = entry.cat->protocols;
        if (protolist) {
            protolists[protocount++] = protolist;
        }
    }

    auto rw = cls->data();

    prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
    
    // 核心：將所有分類的對象方法，附加到類對象的方法列表中
    rw->methods.attachLists(mlists, mcount);
    free(mlists);
    if (flush_caches  &&  mcount > 0) flushCaches(cls);

    rw->properties.attachLists(proplists, propcount);
    free(proplists);

    rw->protocols.attachLists(protolists, protocount);
    free(protolists);
}

void attachLists(List* const * addedLists, uint32_t addedCount) {
    if (addedCount == 0) return;
    
    if (hasArray()) {
        // many lists -> many lists
        uint32_t oldCount = array()->count;
        uint32_t newCount = oldCount + addedCount;
        
        //realloc - 重新分配內存 - 擴容了
        setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
        array()->count = newCount;
        
        //memmove,內存挪動
        //array()->lists 原來的方法列表
        memmove(array()->lists + addedCount,
                array()->lists,
                oldCount * sizeof(array()->lists[0]));
        
        //memcpy - 將分類的方法列表 copy 到原來的方法列表中
        memcpy(array()->lists,
               addedLists,
               addedCount * sizeof(array()->lists[0]));
    }
    ...
}

畫圖分析就是

image

3.實際開發中，你用Category做了哪些事？

聲明私有方法
分解體積龐大的類文件
- 把Framework的私有方法公開
。。。

4.Category實現原理？

Category編譯之后，底層結構是category_t，里面存儲著分類的各種信息，包括對象方法、類方法、屬性、協議信息
分類的在編譯后，方法并不會直接添加到類信息中，而是要在程序運行的時候，通過 runtime, 講Category的數據，

5.為什么分類會“覆蓋”宿主類的方法？

其實不是真正的“覆蓋”，宿主類的同名方法還是存在
分類將附加到類對象的方法列表中，整合的時候，分類的方法優先放到前面
OC的函數調用底層走的是msg_send() 函數，它做的是方法查找，因為分類的方法優先放在前面，所以通過選擇器查找到分類的方法之后直接調用，宿主類的方法看上去就像被“覆蓋”而沒有生效

6.Category 和 Class Extension的區別是什么？

Class Extension(擴展)

聲明私有屬性
聲明私有方法
聲明私有成員變量
編譯時決議，Category 運行時決議
不能為系統類添加擴展
只能以聲明的形式存在，多數情況下，寄生于宿主類的.m文件中

II. load 、initialize

load實現原理

類第一次加載進內存的時候，會調用 + load 方法，無需導入，無需使用

每個類、分類的 + load 在程序運行過程中只會執行一次

+ load 走的不是消息發送的 objc_msgSend 調用，而是找到 + load 函數的地址，直接調用

void call_load_methods(void)
{
    static bool loading = NO;
    bool more_categories;

    loadMethodLock.assertLocked();

    // Re-entrant calls do nothing; the outermost call will finish the job.
    if (loading) return;
    loading = YES;

    void *pool = objc_autoreleasePoolPush();

    do {
        // 1. Repeatedly call class +loads until there aren’t any more
        while (loadable_classes_used > 0) {
            //先加載宿主類的load方法(按照編譯順序，調用load方法)
            call_class_loads();
        }

        // 2. Call category +loads ONCE
        more_categories = call_category_loads();

        // 3. Run more +loads if there are classes OR more untried categories
    } while (loadable_classes_used > 0  ||  more_categories);

    objc_autoreleasePoolPop(pool);

    loading = NO;
}

static void schedule_class_load(Class cls)
{
    if (!cls) return;
    assert(cls->isRealized());  // _read_images should realize

    if (cls->data()->flags & RW_LOADED) return;

    // Ensure superclass-first ordering
    // 遞歸調用，先將父類添加到load方法列表中，再將自己加進去
    schedule_class_load(cls->superclass);

    add_class_to_loadable_list(cls);
    cls->setInfo(RW_LOADED); 
}

調用順序

先調用宿主類的+ load 函數
- 按照編譯先后順序調用（先編譯，先調用）
- 調用子類的+load之前會先調用父類的+load
再調用分類的的+ load 函數
- 按照編譯先后順序調用（先編譯，先調用）

實驗證明：宿主類先調用，分類再調用

2019-02-27 17:28:00.519862+0800 load-Initialize-Demo[91107:2281575] MNPerson + load
2019-02-27 17:28:00.520032+0800 load-Initialize-Demo[91107:2281575] MNPerson (Play) + load
2019-02-27 17:28:00.520047+0800 load-Initialize-Demo[91107:2281575] MNPerson (Eat) + load

image

2019-02-27 17:39:10.354050+0800 load-Initialize-Demo[91308:2303030] MNDog + load (宿主類1)
2019-02-27 17:39:10.354237+0800 load-Initialize-Demo[91308:2303030] MNPerson + load (宿主類2)
2019-02-27 17:39:10.354252+0800 load-Initialize-Demo[91308:2303030] MNDog (Rua) + load (分類1)
2019-02-27 17:39:10.354263+0800 load-Initialize-Demo[91308:2303030] MNPerson (Play) + load(分類2)
2019-02-27 17:39:10.354274+0800 load-Initialize-Demo[91308:2303030] MNPerson (Eat) + load(分類3)
2019-02-27 17:39:10.354285+0800 load-Initialize-Demo[91308:2303030] MNDog (Run) + load(分類4)

Initialize實現原理

類第一次接收到消息的時候，會調用該方法，需導入，并使用

+ Initialize 走的是消息發送的 objc_msgSend 調用

Initialize題目出現

/*父類*/
@interface MNPerson : NSObject

@end

@implementation MNPerson

+ (void)initialize{
    NSLog(@"MNPerson + initialize");
}

@end

/*子類1*/
@interface MNTeacher : MNPerson

@end

@implementation MNTeacher

@end

/*子類2*/
@interface MNStudent : MNPerson

@end

@implementation MNStudent

@end


---------------------------------------------
問題出現:以下會輸出什么結果
int main(int argc, const char * argv[]) {
    @autoreleasepool {

        [MNTeacher alloc];
        [MNStudent alloc];
    }
    return 0;
}

結果如下：

2019-02-27 17:57:33.305655+0800 load-Initialize-Demo[91661:2331296] MNPerson + initialize
2019-02-27 17:57:33.305950+0800 load-Initialize-Demo[91661:2331296] MNPerson + initialize
2019-02-27 17:57:33.306476+0800 load-Initialize-Demo[91661:2331296] MNPerson + initialize

exo me? 為啥打印三次呢

image

原理分析：

initialize 在類第一次接收消息的時候會調用，OC里面的 [ xxx ] 調用都可以看成 objc_msgSend,所以這時候，[MNTeacher alloc] 其實內部會調用 [MNTeacher initialize]
initialize 調用的時候，要先實現自己父類的 initialize 方法，第一次調用的時候，MNPerson 沒被使用過，所以未被初始化，要先調用一下父類的 [MNPerson initialize],輸出第一個MNPerson + initialize
MNPerson 調用了 initialize 之后，輪到MNTeacher 類自己了，由于他內部沒有實現 initialize方法，所以調用父類的initialize, 輸出第二個MNPerson + initialize
然后輪到[MNStudent alloc]，內部也是調用 [MNStudent initialize], 然后判斷得知父類MNPerson類調用過initialize了，因此調用自身的就夠了，由于他和MNTeacher 一樣，也沒實現initialize 方法，所以同理調用父類的[MNPerson initialize],輸出第3個MNPerson + initialize

initialize 與 load 的區別

load 是類第一次加載的時候調用，initialize 是類第一次接收到消息的時候調用，每個類只會initialize一次（父類的initialize方法可能被調用多次）
load 和 initialize，加載or調用的時候，都會先調用父類對應的 load or initialize 方法，再調用自己本身的;
load 和 initialize 都是系統自動調用的話，都只會調用一次
調用方式也不一樣，load 是根據函數地址直接調用，initialize 是通過objc_msgSend
調用時刻，load是runtime加載類、分類的時候調用（只會調用一次）
調用順序:
- load:
  - 先調用類的load
    - 先編譯的類，優先調用load
    - 調用子類的load之前，會先調用父類的load
  - 在調用分類的load
- initialize：
  - 先初始化父列
  - 再初始化子類（可能最終調用的是父類的初始化方法）

/*父類*/
@interface MNPerson : NSObject

@end

@implementation MNPerson

+ (void)initialize{
    NSLog(@"MNPerson + initialize");
}

+ (void)load{
    NSLog(@"MNPerson + load");
}

/*子類1*/
@interface MNTeacher : MNPerson

@end

@implementation MNTeacher

+ (void)load{
    NSLog(@"MNTeacher + load");
}

/*子類2*/
@interface MNStudent : MNPerson

@end

@implementation MNStudent

+ (void)load{
    NSLog(@"MNStudent + load");
}


------------------------------------
問題出現:以下會輸出什么結果?

int main(int argc, const char * argv[]) {
    @autoreleasepool {

        [MNTeacher load];
    }
    return 0;
}

答案出現！！！

2019-02-27 18:17:12.034392+0800 load-Initialize-Demo[92064:2370496] MNPerson + load
2019-02-27 18:17:12.034555+0800 load-Initialize-Demo[92064:2370496] MNStudent + load
2019-02-27 18:17:12.034569+0800 load-Initialize-Demo[92064:2370496] MNTeacher + load
2019-02-27 18:17:12.034627+0800 load-Initialize-Demo[92064:2370496] MNPerson + initialize
2019-02-27 18:17:12.034645+0800 load-Initialize-Demo[92064:2370496] MNPerson + initialize
2019-02-27 18:17:12.034658+0800 load-Initialize-Demo[92064:2370496] MNTeacher + load

exo me again！怎么這么多！連load 也有了？

image

解釋：

前三個load不多bb了吧，程序一運行，runtime直接將全部的類加載到內存中，肯定最先輸出；
第一個 MNPerson + initialize，因為是MNTeacher的調用，所以會先讓父類MNPerson 調用一次initialize，輸出第一個 MNPerson + initialize
第二個 MNPerson + initialize, MNTeacher 自身調用，由于他自己沒有實現 initialize, 調用父類的initialize，輸出第二個 MNPerson + initialize
最后一個MNTeacher + load可能其實有點奇怪，不是說 load只會加載一次嗎，而且他還不走 objc_msgSend 嗎，怎么還能調用這個方法？
- 因為！當類第一次加載進內存的時候，調用的 load 方法是系統調的，這時候不走 objc_msgSend
- 但是，你現在是[MNTeacher load]啊，這個就是objc_msgSend(MNTeacher,@selector(MNTeacher))，這就跑到MNTeacher + load里了！
- 只是一般沒人手動調用load 函數，但是，還是可以調用的！

III. 關聯對象AssociatedObject

Category能否添加成員變量，如果可以，如何添加？

這道題實際上考的就是關聯對象

如果是普通類聲明生命屬性的話

@interface MNPerson : NSObject

@property (nonatomic, copy)NSString *property;

@end

上述代碼系統內部會自動三件事：

幫我們生成一個生成變量_property
生成一個 get 方法 - (NSString *)property
生成一個 set 方法 - (void)setProperty:(NSString *)property

@implementation MNPerson{
    NSString *_property;
}

- (void)setProperty:(NSString *)property{
    _property = property;
}

- (NSString *)property{
    return _property;
}

@end

分類也是可以添加屬性的 - 類結構里面，有個properties 列表，里面就是
存放屬性的;

分類里面，生成屬性，只會生成方法的聲明，不會生成成員變量 && 方法實現！

image

人工智障翻譯：實例變量不能放在分類中

所以：

不能直接給category 添加成員變量，但是可以間接實現分類有成員變量的效果(效果上感覺像成員變量)

@interface MNPerson (Test)

@property (nonatomic, assign) NSInteger age;

@end

@implementation MNPerson (Test)

@end

image

person.age = 10等價于 [person setAge:10]，所以證明了，給分類聲明屬性之后，并沒有添加其對應的實現！

關聯對象

objc_setAssociatedObject Api

objc_setAssociatedObject(    <#id  _Nonnull object#>, (對象)
                             <#const void * _Nonnull key#>,(key)
                             <#id  _Nullable value#>,(關聯的值)
                             <#objc_AssociationPolicy policy#>)(關聯策略)

關聯策略，等價于屬性聲明

typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) {
    OBJC_ASSOCIATION_ASSIGN = 0,          
    OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, 
    OBJC_ASSOCIATION_COPY_NONATOMIC = 3,  
    OBJC_ASSOCIATION_RETAIN = 01401,      
    OBJC_ASSOCIATION_COPY = 01403         
};

image

比如這里的age屬性，默認聲明是@property (nonatomic, assign) NSInteger age;，就是 assign，所以這里選擇OBJC_ASSOCIATION_ASSIGN

取值

objc_getAssociatedObject(<#id  _Nonnull object#>, <#const void * _Nonnull key#>)

面試題 - 以下代碼輸出的結果是啥

int main(int argc, const char * argv[]) {
    @autoreleasepool {

        MNPerson *person = [[MNPerson alloc]init];

        {
            MNPerson *test = [[MNPerson alloc]init];
            objc_setAssociatedObject(person,
                                     @"test",
                                     test,
                                     OBJC_ASSOCIATION_ASSIGN);
        }
        
        NSLog(@"%@",objc_getAssociatedObject(person, @"test"));
    }
    return 0;
}

image

原因，關聯的對象是person，關聯的value是 test，test變量出了他們的{} 作用域之后，就會銷毀;
此時通過key 找到對應的對象，訪問對象內部的value，因為test變量已經銷毀了，所以程序崩潰了，這也說明了 => 內部 test 對 value是強引用！

關聯對象的本質

在分類中，因為類的實例變量的布局已經固定，使用 @property 已經無法向固定的布局中添加新的實例變量（這樣做可能會覆蓋子類的實例變量），所以我們需要使用關聯對象以及兩個方法來模擬構成屬性的三個要素。

引用自關聯對象 AssociatedObject 完全解析

關聯對象的原理

實現關聯對象技術的核心對象有

AssociationsManager
AssociationsHashMap
ObjectAssociationMap
ObjcAssociation

class AssociationsManager {
    static spinlock_t _lock;//自旋鎖，保證線程安全
    static AssociationsHashMap *_map;
}

class AssociationsHashMap : public unordered_map<disguised_ptr_t, ObjectAssociationMap>

class ObjectAssociationMap : public std::map<void *, ObjcAssociation>

class ObjcAssociation {
    uintptr_t _policy;
    id _value;
}

以關聯對象代碼為例:

  objc_setAssociatedObject(obj, @selector(key), @"hello world", OBJC_ASSOCIATION_COPY_NONATOMIC);

image

關聯對象并不是存儲在被關聯對象本身的內存中的
關聯對象，存儲在全局的一個統一的AssociationsManager中
關聯對象其實就是 ObjcAssociation 對象,關聯的 value 就放在 ObjcAssociation 內
關聯對象由 AssociationsManager 管理并在 AssociationsHashMap 存儲
對象的指針以及其對應 ObjectAssociationMap 以鍵值對的形式存儲在 AssociationsHashMap 中
ObjectAssociationMap 則是用于存儲關聯對象的數據結構
每一個對象都有一個標記位 has_assoc 指示對象是否含有關聯對象
存儲在全局的一個統一的AssociationsManager 內部有一持有一個_lock，他其實是一個spinlock_t(自旋鎖),用來保證AssociationsHashMap操作的時候，是線程安全的

Category 相關的問題一般初中級問的比較多，一般最深的就問到關聯對象，上面的問題以及解答已經把比較常見的 Category 的問題都羅列解決了一下，如果還有其他常見的 Category 的試題歡迎補充~

傳言的互聯網寒冬貌似真的來臨了，在這種環境下，無法得知公司是否不裁員，還是讓自己??起來！19年的 銅三鐵四 從明天就要開始拉開帷幕了，也希望近期找工作的iOS們能找到一份滿意的工作，看下寒冬下，iOS開發是不是叕沒人要了~

本文基于 MJ老師的基礎知識之上，結合了包括 draveness 在內的一系列大神的文章總結的，如果不當之處，歡迎討論~

友情演出:小馬哥MJ

參考資料:

關聯對象 AssociatedObject 完全解析

associated-objects

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

面試驅動技術 - Category 相關考點

面試驅動技術 - Category 相關考點

I. Category

Category相關面試題

1.Category的特點

2.分類中可以添加哪些內容

分類中原理解析

函數轉換

3.實際開發中，你用Category做了哪些事？

4.Category實現原理？

5.為什么分類會“覆蓋”宿主類的方法？

6.Category 和 Class Extension的區別是什么？

Class Extension(擴展)

II. load 、initialize

load實現原理

調用順序

Initialize實現原理

Initialize題目出現

initialize 與 load 的區別

答案出現！！！

III. 關聯對象AssociatedObject

Category能否添加成員變量，如果可以，如何添加？

關聯對象

面試題 - 以下代碼輸出的結果是啥

關聯對象的本質

關聯對象的原理

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

面試驅動技術 - Category 相關考點

I. Category

Category相關面試題

1.Category的特點

2.分類中可以添加哪些內容

分類中原理解析

函數轉換

3.實際開發中，你用Category做了哪些事？

4.Category實現原理？

5.為什么分類會“覆蓋”宿主類的方法？

6.Category 和 Class Extension的區別是什么？

Class Extension(擴展)

II. load 、initialize

load實現原理

調用順序

Initialize實現原理

Initialize題目出現

initialize 與 load 的區別

答案出現！！！

III. 關聯對象AssociatedObject

Category能否添加成員變量，如果可以，如何添加？

關聯對象

面試題 - 以下代碼輸出的結果是啥

關聯對象的本質

關聯對象的原理

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频