Since the imageWithData function of UIImage decompresses Data into ARGB images every time the drawing is done, there will be a decompression operation every time the drawing is done, which is very inefficient, but only requires instantaneous memory. To improve efficiency, the SDWebImageDecoder unzip the resources wrapped under Data and then draw them on another image, so that the new image does not need to be decompressed repeatedly

What about SEL and Method and IMP?

Method

Let’s look at the definition

1. runtime.h 2. /// An opaque type that represents a method in a class definition. Typedef struct objc_method *Method; 4. 5. struct objc_method { 6. SEL method_name OBJC2_UNAVAILABLE; 7. char *method_types OBJC2_UNAVAILABLE; 8. IMP method_imp OBJC2_UNAVAILABLE; 9.}Copy the code

A Method is a piece of code that can perform a function independently. For example:

1. - (void)logName 2. { 3. NSLog(@"name"); 4.}Copy the code

This code right here, it’s just a function.

Let’s look at the contents of the objc_method structure:

• SEL method_name Method name
• Char *method_types Method type
• IMP method_IMP implementation

In this structure weight, we have seen SEL and IMP, indicating that SEL and IMP are in fact properties of Method.

Let’s move on to SEL.

SEL

So let’s look at the definition first

1. Objc.h 2. /// An opaque type that represents a method selector. Typedef struct objc_selector *SEL;Copy the code

Now, just to clarify the relationship between selectors and SEL, when I was writing this article, I was actually searching for selectors, until I looked at the definition of selectors, and I realized I was getting it wrong.

1. @property SEL selector;
Copy the code

In the documentation, the definition of a selector is declared like this, that is, a selector is an instance of SEL, and it’s only in iOS that we use selectors so much that we think of them as a concept.

What do you mean by selector? If you think about the stock market, for example, there are so many companies listed on nasdaq, and their names are very long, or there are companies with similar names, which are ** limited. So when the market goes to designate a stock, it’s very inefficient. When you’re in a hurry to buy a stock, you say to your broker, “Hi, Peter, buy me a hundred shares of Tuniu Limited Liability Company?” Maybe by the time you finish, the broker enters it and the market changes, so Nasdaq usually uses a code like “TOUR”. The selector here does a similar thing, which is it allows us to quickly find the corresponding function.

Here’s what the document says:

A method selector is A C string that has been registered (or “mapped”) with the objective-C runtime. Selectors generated by the compiler are automatically mapped by the runtime when the class is loaded.

In iOS, runtime maps all methodhash into the set via the load function while running. So at runtime, you can find selectors very quickly, without sacrificing too much performance because of the Runtime feature.

Since selector is a string, I think it should be a combination of className and method. There are two naming rules:

• You can’t duplicate selectors for the same class
• Selector can be repeated for different classes

One of the disadvantages of this is that when we’re writing C code, we often use function overloading, which is the same function name, different arguments, but that doesn’t work in Objective-C, because the selector only has the name of the method, no arguments, so there’s no way to distinguish between different methods.

Such as:

1. - (void)caculate(NSInteger)num;
2. 
3. - (void)caculate(CGFloat)num;
Copy the code

There will be an error.

We can only tell by name:

1. - (void)caculateWithInt(NSInteger)num;
2. 
3. - (void)caculateWithFloat(CGFloat)num;
Copy the code

IMP

Take a look at the definition of IMP

1. /// A pointer to the function of a method implementation. Typedef id (*IMP)(id, SEL...) ; 3. #endifCopy the code

This is a little bit easier to understand, it’s a pointer to the memory address of the final implementation.

In summary, in the iOS Runtime, Method implements a quick query Method and implementation through the selector and IMP properties, which relatively improves performance while maintaining flexibility.

31: How does Autorelease work?

• Under ARC, we use @autoreleasepool{} to use an Autoreleasepool, actually UIKit via a RunLoopObserver Pop and Push the Autoreleasepool between the second Sleep of the RunLoop. The autorelease object generated by this Loop will be released to the compiler as follows:

1. void *DragonLiContext = objc_ AutoreleasepoolPush(); 2. // {} code 3. objc_ AutoreleasepoolPop(DragonLiContext);Copy the code

• Release time: Release when the current RunLoop iteration ends.

Thirty-two: How ARC works

• The ARC compiler has two parts: the front-end compiler and the optimizer

• Front-end compiler: The front-end compiler inserts a release statement for each “owned” object. If the object’s ownership modifier is __strong, it is owned. If an object is created within a method, the front-end compiler automatically destroys it by inserting a release statement at the end of the method. Objects (instance variables/properties) owned by the class are released in the dealloc method. In fact, you don’t need to write dealloc methods or call the superclass dealloc methods, ARC will do everything for you automatically. In addition, the code generated by the compiler will perform even better than the release statements you wrote yourself, because the editor can make some assumptions. In ARC, there is no class to override the release method, nor is there any need to call it. ARC will optimize the call process by using objc_Release directly. And we do the same thing with Retain. ARC calls objc_retain instead of preserving the message

• ARC optimizer: While the front-end compiler sounds great, sometimes there are several repeated calls to retain and release in your code. The ARC optimizer is responsible for removing redundant Retain and release statements, ensuring that the generated code runs faster than manual reference counting

Thirty-three: the user needs to upload and download an important information file, how should judge whether the user uploaded and downloaded successfully?

• Verify file integrity with MD5! (It is not possible to judge the end of the current request or the end of the data received only by the code)
• When the client uploads a file, it adds the MD5 value of the file in the request body to inform the server. After receiving the file, the server verifies the MD5 value of the received file and the MD5 value in the request body to determine whether the upload is successful
• When the client downloads a file, it receives the MD5 value of the file sent by the server in the response header. After the file is downloaded, it compares the MD5 value of the downloaded file with the MD5 value in the response header returned by the server to determine whether the download is successful
• MD5 is a one-way operation that converts an arbitrarily long data string into a short fixed-length value. No two strings should have the same hash value
• MD5 verification can be used in many fields, such as confidential data verification, download file verification, plaintext password encryption, etc. Example of MD5 verification: Such as customer to our data center sync a file, the file using MD5 check, so customers in sending files at the same time, there will be sending a check code file, do after we get the file MD5 algorithm, the calculation results compared with the customer to send check code, if the customer agree that sending the file without error, Otherwise, the file is considered incorrect and needs to be resend.

Thirty-four: The role of the ISA pointer

• An object’s ISA points to a class, a class’s ISA points to a meta class, and a metaclass isa points to the metaclass’s root class. Isa helps an object find its methods

• Is a pointer to the Class type. Each instance object has a pointer to ISA, which points to the object’s Class, and there is also a pointer to ISA, which points to meteClass(metaclass). A metaclass holds a list of class methods. When a class method is called, it first looks for the implementation of the class method from itself; if not, the metaclass looks for the method from its parent class. Also note that a meteClass is also a class, which is also an object. Metaclasses also have isa Pointers, and its ISA pointer ultimately points to a root meteClass. The root metaclass’s ISA pointer points to itself, thus forming a closed inner loop.

35: How does NSURLsession improve over NSURLConnection?

• You can configure caches, protocols, cookies, and credential policies per session, and even share this information across programs

• The session of task. It handles the loading of data and the uploading and downloading of files and data between the client and server. NSURLSessionTask is most similar to NSURLConnection in that it is also responsible for loading data. The biggest difference is that all tasks share a common delegate that is their creator, NSURLSession.

What is the effect of using drawRect?

The drawRect method relies on the Core Graphics framework for custom drawing

• Disadvantages: It handles touch events by forcing a redraw with setNeddsDisplay every time a button is clicked; And more than once, each single point event triggers two executions. From a performance point of view, this is bad for both CPU and memory. In particular, if we have multiple UIButton instances like this on our interface, that’s going to be bad

• The method invocation mechanism is also very special. When you call setNeedsDisplay, UIKit will mark the current layer as dirty, but the original content will still be displayed. Until the next view rendering cycle, the Core Graphics context will be rebuilt for the layer marked as dirty, and then the data in memory will be recovered, and then the drawing will be done using CGContextRef

When does an unrecognized Selector exception occur? How to avoid it?

• When a method is called on an object that does not implement the method, it can be resolved by “message forwarding”, and if it still fails, an unrecognized selector exception will be reported

• Objc is a dynamic language. Each method is dynamically converted to a message at run time, i.e., objc_msgSend(Receiver, selector). The process is described as follows:

  • When OBJc sends a message to an object, the Runtime library finds the actual class that object belongs to based on the object’s ISA pointer and then looks for a method to run in the list of methods in that class and in the list of methods in its parent class and if it still doesn’t find the corresponding method in the uppermost parent class, The program will die at runtime and throw an exception unrecognized selector sent to XXX. But before that happens, objc’s runtime gives you three chances to save the program from a crash

• Three chances to save the program from crashing

  • Method resolution: The objc runtime calls +resolveInstanceMethod: or +resolveClassMethod:, giving you the opportunity to provide a function implementation. If you add the function and return YES, the runtime will restart the process of sending the message once. If the resolve method returns NO, the runtime will move to the next step, message forwarding
  • Fast forwarding: realized – forwardingTargetForSelector: if the target object, the Runtime will call this method at this moment, give you the opportunity to put forward this message to other objects As long as this method returns not nil, and the self, The whole process of sending the message will be restarted, and of course the object you sent will become the object you returned. Otherwise, it would continue Normal Fowarding. It’s called Fast, just to distinguish the next forwarding mechanism. Because this step doesn’t create any new objects, but the Normal Forwarding Invocation creates an NSInvocation object, and it’s much faster than Normal forwarding, so it’s called Fast Forwarding
  • Normal Forwarding is Runtime’s last chance to save you. First of all, it will send – methodSignatureForSelector: message function parameters and return values of the type. If – methodSignatureForSelector: returns nil, the Runtime will send – doesNotRecognizeSelector: news, program will hang up now. If a function signature is returned, Runtime creates an NSInvocation object and sends the -forwardInvocation: message to the target object

38: What are the common data storage methods in iOS?

• comprehensive

  • All local persistent data stores are written to files by nature and can only be stored in sandboxes.
  • Sandbox is apple’s security mechanism, which essentially means that each application is assigned a folder to store data, and each application can only access the folder assigned to it. Other applications’ folders are not accessible.
  • At its core, data stores are written files. There are four main types of persistence: property list, object serialization, SQLite database, and CoreData
  • Property list: Applies to a small number of data stores, such as logged-out user information, application configuration information, etc. Only NSString, NSArray, NSDictory, NSData can WriteToFile; Storage is still a PList file, plist file can store 7 types of data: array, dictory, string, bool, data, date, number.

• detailed

  • Object serialization: finally, it is saved as a property list file. If the program needs to store, it is more convenient to store the object directly. For example, there is a setting class, we can store the object of the setting class directly, there is no need to save each property in the file. Object serialization is taking an object that implements the NSCoding protocol, using the form of serialization (NSKeydArchiver), extracting the properties from the object, and turning them into a binary stream, which is NSData, NSData can be written to file or stored in NSUserdefault. Two methods that must be implemented encodeWithCoder, initWithCoder. The nature of object serialization is object NSData.
  • SQLite: Suitable for large, repetitive, and regular data storage. And frequently read, delete, and filter data, which is suitable for using databases (iOS uses third-party FMDB)
  • CoreData: Sqlite is a relational database. CoreData is based on the idea of or-mapping. O stands for Object, R stands for relationship, and Mapping stands for Mapping. Simplify the programmer’s burden and operate the database in an object-oriented manner. ORMapping is an idea. CoreData implements this idea. In Java, Hibernate is also an implementation of ORMapping, which is only implemented in Java.
  • CoreData is essentially a database, but it’s much more object-oriented. Instead of focusing on two-dimensional table structures, you only need to focus on objects, pure object-oriented data manipulation. When we use a database directly, if we insert data into the database, it is usually a one-to-one mapping of the attributes of an object to the fields of a table in the database, and then the attributes of the object are stored in the specific table fields. When fetching a row of data from a table, it also needs to be encapsulated in the attributes of the object, which is a bit tedious, not object-oriented. The problem CoreData solves is that you don’t need this intermediate transformation process. It looks like you just store the objects in and out, and you don’t care about the table, but you actually do the mapping internally.

39: Describes the life cycle of a ViewController

• When we call the VIEW of UIViewControlller,
• The system first determines if the current UIViewControlller has * views. If so, it returns a view.
• If not, the loadView method is called,
• Then determine if the loadView method is a custom method,
• If it’s a custom method, it executes the custom method,
• If not, determine whether the view controller has * xiB and stroyBoard.
• Load the XIB and StroyBoard if they exist.
• If you don’t create a blank view.
• Call the viewDidLoad method.
• And then we go back to view

Can global, global, and local static variables be modified in a Block?

• Yes. Delve into how Block captures external variables and __block is implemented

  • Global variables and static global variables change in value, and they are captured by the Block because they are global and have wide scope

  • Static and automatic variables, captured by blocks from the outside, become members of the __main_block_IMPL_0 structure

  • Automatic variables are passed by value to the Block constructor. Block only captures variables that will be used in the Block. Since only the value of the automatic variable is captured, not the memory address, the value of the automatic variable cannot be changed inside the Block.

  • The external variables that Block captures that can change value are static variables, static global variables, and global variables

  • There are three types of blocks

    • _NSConcreteStackBlock: Blocks that use only external local variables and member property variables and do not have strong Pointers are stackblocks. The life cycle of a StackBlock is controlled by the system. Once a StackBlock returns, it is destroyed by the system and does not hold objects

      • As soon as the _NSConcreteStackBlock field ends, the Block will be destroyed. In ARC, the compiler automatically copies blocks from the stack to the heap. For example, when a Block is returned as a function, it will copy onto the heap

    • _NSConcreteMallocBlock: A block that has a strong pointer reference to a member property or a copy modifier will be copied to the stack as a MallocBlock. Without a strong pointer reference, it will be destroyed. The life cycle is controlled by the programmer and holds the object

    • _NSConcreteGlobalBlock: A block that uses no external variables or only global or static variables is _NSConcreteGlobalBlock and has a lifetime from creation to the end of the application and does not hold an object

• In an ARC environment, once a Block is assigned, a copy is triggered, __block is copied to the heap, and a Block is also __NSMallocBlock. ARC environments also have __NSStackBlock, in which case __block is on the stack

• In ARC, if a Block refers to an ID type, it is an retain. If a base variable does not have an __block, it cannot change its value. If a base variable does, it must change its structure so that its internal forwarding pointer points to the address after the copy

Portal:

IOS Interview collection + Answer (1) (juejin.cn)

IOS Interview collection + Answer (3) (juejin.cn)

IOS Interview collection + Answer (4) (juejin.cn)

IOS Interview collection + Answer (5) (juejin.cn)

IOS Interview Guide (QQ.com)