Explore topic-wise InterviewSolutions in .

GCD (Grand Central Dispatch) is a low-level API for controlling several operations at the same TIME. This notion is employed to aid in the enhancement of APPLICATION performance. This procedure is used to handle numerous jobs at once. The most relevant API for multitasking with Async and Sync programming in iOS is Grand Central Dispatch (GCD).

• Dispatch Queue: The task is managed in FIFO (First In First Out) order by the Dispatch Queue. Dispatch QUEUES are thread-safe because they can be accessed by several threads at the same time.
• Concurrent: This process has started numerous TASKS at the same time but does not know when they will finish. It can be completed in whatever sequence you want. They perform one or more things concurrently at the same time. The work is finished in the order in which it was queued, not in the order in which it was completed.
• Serial: A single task will be executed at a time. It is possible to use it to synchronize access to a certain resource.
• Sync: After the work is completed, a synchronous function returns control to the caller.
• Asynchronous: An asynchronous function returns instantly after ordering a job to begin but does not wait for it to finish.

A single unit of code distribution in IOS Swift is REFERRED to as a module. The Swift "import" KEYWORD can be used to import a framework or application that has been created and shipped as a single unit. In Swift, each Xcode build target is treated as an INDEPENDENT module. An example of using the "import" keyword is given below:

The several methods for unwrapping an optional in Swift are as follows:

• Forced unwrapping: It consists in adding a ! after an Optional value, to automatically unwrap it, without having to check whether it is nil or not. Example - let v:STRING = b!
  Optional chaining: The technique of querying and calling properties, methods, and subscripts on an optional that is currently nil is known as optional chaining. The PROPERTY, method, or subscript call SUCCEEDS if the optional includes a value; if the optional is nil, the property, method, or subscript call returns nil. Multiple inquiries can be chained together, and if any link in the chain is nil, the entire chain will fail gracefully. Example - 

• Nil coalescing operator: If there is a value inside an optional, the nil coalescing operator unwraps it and returns it. If no value is provided – for example, if the optional is nil – a default value is used instead. The result will not be optional in either case: it will be either the value from within the optional or the default value used as a backup. Example - 

• Optional pattern: An optional pattern matches items wrapped in an Optional<Wrapped> enumeration's some(Wrapped) case. Optional patterns appear in the same places as enumeration case patterns and consist of an identifier pattern followed by a question mark. An example is given below:

• Guard statement: When certain requirements are not met, the guard statement in Swift is used to shift PROGRAM control out of scope. With one key exception, the guard statement is comparable to the if statement. When a given condition is met, the if statement is executed. The guard statement, on the other hand, is executed when a given condition is not met. Example is given below:

• Optional binding: Optional binding is used to determine whether or not an optional has a value. If it does have a value, unwrap it and save it in a temporary variable or constant. Example is given below:

• Implicitly unwrapped variable declaration: Because a variable may start life as nil, but will always have a value before you need to use it, implicitly unwrapped optionals exist. It's helpful not to have to write if let all the time because you know they'll have value by the time you need them. Example: 

Apple's Core Data framework is one of the most POWERFUL frameworks for macOS and iOS programmes. In our applications, core data is used to manage the model layer object. Within iOS applications, we may USE Core Data as a framework to FILTER, alter, save, and track data. Core Data is not a relational database in the traditional sense. Without learning SQL, we can easily connect the objects in our APP to the table records in the database using core data. The M in the MVC structure STANDS for core data.

Some features of Core data are listed below:

• Integration with the iOS and macOS toolchains is seamless.
• Data organisation, filtering, and grouping in memory and in the user interface (User Interface).
• Object storage is supported automatically.
• Property values are validated automatically.
• The first object graph management framework.
• The object graph's life cycle is managed using the Core Data framework.

When two instances have a strong connection to one other, a circular REFERENCE occurs, resulting in a memory leak because neither of the two instances will ever be deallocated. The reason for this is that you can't deallocate an INSTANCE if it has a strong reference to it, yet each instance maintains the other alive due to the strong reference. This might LEAD to a deadlock which is EXTREMELY bad for the application.

Breaking the strong circular reference by replacing one of the strong references with a weak or unowned reference would fix the problem of a circular reference.

The FOLLOWING are the most prevalent reasons for using implicitly unwrapped optionals:

• When you can't INITIALISE a PROPERTY that is not nil (absence of value) by definition at the MOMENT of instantiation. An Interface Builder outlet, for example, is always initialised after its owner. In this case, you have ensured that the outlet is non-nil before using it, provided it's properly configured in Interface Builder.
• To tackle the problem of a strong reference cycle, which occurs when two instances refer to each other and one of them requires a non-nil reference to the other. In this situation, one side of the reference is MARKED as unowned, while the other employs an implicitly unwrapped optional.

An optional, in ios Swift, allows any type of variable to reflect a lack of value. The absence of value in Objective C is only available in reference types that use the nil special value. This is not possible with value types like int or float.

With optionals, ios Swift EXTENDS the absence of value ideas to both reference and value types. An optional variable can be set to either a value or nil, which indicates that it has no value. An EXAMPLE of an optional is GIVEN below:

Generics are a way to avoid code duplication. It is USUAL to repeat a method that takes one type of parameter to accommodate a parameter of a different type. Generics can be used in both functions and data types in Swift, such as classes, structures, and enumerations.

For example, the second function in the above code is a "clone" of the first, but it accepts texts rather than numbers.

You can consolidate the two functions into one and maintain type SAFETY at the same time by using generics. Given above is the way to do it in general.

Because you are testing equality here, you can USE any type that implements the Equatable protocol as a parameter. This code achieves the desired outcome while preventing the use of non-typed parameters.

When one or more conditions are not met, a GUARD statement is used to TRANSFER PROGRAM control out of the scope. This remark AIDS in AVOIDING the doomsday pyramid.  The following is the syntax of a GUARD statement:

The nil-coalescing operator "??" is a SHORTHAND for the ternary conditional operator, which we used to test for nil. A double question MARK can also be used to set a variable's default value.

"default STRING" stringVar??

This does PRECISELY what you would EXPECT: if stringVar is not nil, it is returned; otherwise, the "default string" is returned.

Delegate, in ios Swift, is a design pattern that allows data or communication to be passed across structs or classes. Delegate allows one object to deliver a message to ANOTHER when a certain event occurs, and it is used to handle table and collection view events. Delegates have a one on one INTERACTION and communicate with one another. 

An example of a delegate is given below:

The enums used in the above delegate are:

There is a distinction between Self (CAPITAL S) and self (small S) when WRITING protocols and protocol EXTENSIONS. When USED with a capital S, Self refers to the protocol COMPLIANT type, such as String or Int. When used with a lowercase S, self refers to the value contained within that type, such as "hi" or 999, for instance.

Consider the following SquareInteger extension as an example:

Remember that Self with a capital S refers to any type that follows the protocol. Because Int conforms to SquareInteger in the example above, when called on Int, the method returns an Int.  Self with a lowercase S, on the other hand, refers to the type's current value. If the preceding example were run on an Int containing the value 4, the result would be 4 * 4.

By default, function parameters are constants. CHANGING the value of a function parameter from within the function's body causes a compile-time error. Modifying the local variable also modifies the passed in arguments, which is KNOWN as the "inout" parameter. The passed-in arguments will have the same value if it is not present. Trying to remember the reference type while using inout and the value type when not using it. The SWAP function, which modifies the parameters handed in, is an excellent example. Consider REDUCING the copying overhead as well. If you have a function that takes a memory-intensive large value type as an argument (say, a huge structure type) and returns the same type, and the function return is only used to replace the caller argument, the inout parameter is the associated function parameter to use. As we can see in the example given below, a CALL to the function "demoFunction" copies arguments to function property 'aBigStruct'(copy 1) and the function property is mutated after which, the function returns a copy of the mutated property to the caller (copy 2). However, in the function "demoFunctionWithLessCopyOverhead", call by reference is being done and zero value copy overhead is there because of the usage of inout optimization.

In Swift, the self property of an instance is a special property that holds the instance itself. In most cases, self appears in a class, structure, or ENUMERATION's initializer or method. The most common use of self is in initializers when you are likely to WANT parameter names that match your TYPE's property names, such as this:

If all of the following conditions are met, you should use a set rather than an array:

• You only want to add each item once. DUPLICATES are never PERMITTED in sets.
• The order of the items in the COLLECTION is irrelevant to you.
• You are storing Hashable types, either your own or those provided by Swift, such as strings and integers. Hash values are used in sets to look for things QUICKLY.

ASK yourself, "Am I dealing with REFERENCE types?" to see if you need to worry about strong, weak, or unowned. If you are working with Structs or Enums, ARC is not in charge of memory management, so you do not have to worry about defining weak or unowned constants or variables.

In hierarchical relationships, strong references are acceptable when the parent REFERS to the child, but not when the child refers to the parent. Strong references are, in fact, the most appropriate type of reference the majority of the time.

If two instances are optionally linked, make sure ONE of them has a weak reference to the other. 

When two instances are linked to the point where one cannot exist without the other, the instance with the OBLIGATORY dependency must keep an unowned reference to the other instance.

• A protocol, in its most basic form, explains what an UNKNOWN sort of object can accomplish. It has TWO or three different sorts of properties, as well as procedures. Protocol NEVER INCLUDES anything inside the methods, nor does it provide actual storage for the properties. You can build extensions to your protocols that give default implementations of the methods in a more advanced form. However, you are still unable to provide storage for properties.

• Classes are tangible objects. They are not needed to embrace protocols, which means they do not have to implement the required attributes and methods. Classes can be used to generate objects, whereas protocols are simply typed declarations. Consider protocols to be abstract definitions, whereas classes and structs are actual objects that can be created. An example of a class is given below:

Many iOS Swift functions accept MULTIPLE parameters, the last of which is a closure. Trailing closure syntax is a small amount of syntactic sugar that makes READING and writing common CODE easier. 

For example, CONSIDER the following code snippet:

Instead of the above code snippet, we can write the following code (which is way cleaner than the previous one):

The abbreviation PLIST in ios stands for Property List. PLIST is a value and key dictionary that can be saved in our file system using the .plist file EXTENSION. The property list is used to store a smaller quantity of data in a portable and lightweight MANNER. In most CASES, they are written in XML.

The following are examples of several sorts of property lists:

• BINARY Property List
• XML Property List