IOS Interview Questions and Answers

• The reuseIdentifier is used to point out that a cell can be re-used in a UITableView. For example when the cell phone appears the same, however has special content.

• The UITableView will keep an inner cache of UITableViewCell’s with the reuseIdentifier and permit them to be re-used when dequeueReusableCellWithIdentifier: is called.

• By re-using table cell’s the scroll overall performance of the table view is higher because new views do now not need to be created.

Four data types that you’ll definitely want your developer to be aware of are as follows:

• NSStrin : Represents a string.
• CGfloat : Represents a floating point value.
• NSInteger : Represents an integer.
• BOOL : Represents a boolean.

Multitasking function is supported by using the iOS 4 & the different high-level series. These sequence helps the app to run in the backgrounds soon as they are launched and they hold running unless they are terminated. This is the highly wonderful future showcased by the iOS application platform.

Synchronous: It waits till the completion of the task.

 Asynchronous: Completes a task in the background and can notify you when complete

iOS supports SBJson framework.

SBJson is a JSON parser and generator for Objective-C.

It provides flexible APIs and additional control, making JSON handling easier.

Compilation Conditions to use if DEBUG … endif structure is to include or disable given block of code have separate targets.

• iOS supports the SBJson framework.

• It is a well superior and fantastically flexible framework that helps the flexible functioning of APIs & and some different greater added features that make the JSON handling a lot easier.

• SBJson is a distinctly superior concept of the iOS software program platform.

• Buttons,text fields, images, labels, and any different factors that are seen inside the application are referred to as UI elements.

• These  also be interactive and comprise the user interface (hence the term “UI”) of an application. In iOS
• development, UI factors can be quickly added through Xcode’s interface builder, or coded from scratch and laid out using NSLayoutConstraints and Auto Layout.

• Alternatively, every component can additionally be placed at precise coordinates using the UIView “(id)initWithFrame:(CGRect)frame” method.

• Atomic and non-atomic refers to whether the setters/getters for a property will atomically examine and write values to the property.

• When the atomic key-word is used on a property, any get entry to to it will be “synchronized”.

• Therefore a call to the getter will be guaranteed to return a legitimate value, however this does come with a small overall performance penalty.

• Hence in some conditions non-atomic is used to provide faster access to a property, but there is a chance of a race condition causing the property to be nil under rare circumstances (when a value is being set from another thread and the historic cost was once released from memory however the new value hasn’t yet been fully assigned to the area in memory for the property).

• SBJson framework is supported by iOS.It is a JSON parser and generator for Objective-C (Objective-C is the primary programming language we use when writing software for OS X and iOS.
• It is a superset of the C programming language and provides object-oriented capabilities and a dynamic run time).
• SBJson provides flexible APIs and additional control that makes JSON handling easy.

• Retaining an object means the retain count will increase by one.

• This means the instance of the object will be stored in reminiscence till it’s retain count drops to zero.

• The property will keep a reference to this occasion and will share the identical instance with anyone else who retained it too. Copy means the object will be cloned with replica values. It is no longer shared with any one else.

• (id)initWithStyle:(UITableViewCellStyle)style reuseIdentifier:(NSString *)reuseIdentifier

• The reuseIdentifier tells UITableView which cells may be reused within the table, effectively grouping together rows in a UITableView that differ only in content but have similar layouts. This improves scroll performance by alleviating the need to create new views while scrolling. Instead the cell is reused whenever dequeueReusableCellWithIdentifier: is called.

• A bundle can simply be defined as a directory which groups up all the related resources together at one place within the file system.

• For example, if you build an iOS app, Xcode packages then it can be called as a bundle. Inside an iOS app bundle, it contains all the applications files which can be executable.

• App Bundle also supports the resource different files which include localized content, image files and app icons. These elements help in delivering the best application performance to the iOS software.

There are three parts of NSError object a domain, an error code, and a user info dictionary. The domain is a string that identifies what categories of errors this error is coming from.

• Properties designated as atomic usually return a wholly initialized object. This also occurs to be the default state for synthesized properties.

• But, if you have a property for which you understand that retrieving an uninitialized value is not a risk (e.g. if all access to the property is already synchronized by different means), then setting it to nonatomic can give you better overall performance than atomic.

The bounding box is a term used in geometry; it refers to the smallest measure (area or volume) within which a given set of points.

Because enums aren’t objects, so we don’t specify strong or weak here.

synthesize generates getter and setter methods for your property.

• Both OS X & iOS are having different application development environments. Cocoa and Cocoa touch can simply be interpreted as the application development environment for the same OS X and iOS. 

• Having the main objective of developing applications for different platforms, Cocoa is extensively been designed to develop applications that run on OS X platform and whereas Cocoa touch is being used for developing applications that run on iOS platform.

• Fetch requests are extensively used for fetching predefined objects which match the exact requirement in-relation to individual values, criteria and much more.

• The main use of this NSFetcherRequest is to fetch from the core data.  

• Subscripts can definitely be interpreted as a set of shortcuts which are used for accessing the member elements of a list or any sequence.

• Different classes, structures and enumerations can be described as the set of subscripts.

The common execution states are as follows:

• Not Running :The app is completely switched off, no code is being executed.
• Inactive :The app is running in the foreground without receiving any events.
• Active :The app is running in the foreground and receiving events.
• Background :The app is executing code in the background.
• Suspended :The app is in the background but is not executing any code.

• Method swizzling allows the implementation of an existing selector to be switched at run time for a different implementation in a classes dispatch table.

• Swizzling allows you to write code that can be executed before and/or after the original method. For example perhaps to track the time method execution took, or to insert log statements

#import “UIViewController+Log.h”

@implementation UIViewController (Log)

    + (void)load {

        static dispatch_once_t once_token;

        dispatch_once(&once_token,  ^{

            SEL viewWillAppearSelector = @selector(viewDidAppear:);

            SEL viewWillAppearLoggerSelector = @selector(log_viewDidAppear:);

            Method originalMethod = class_getInstanceMethod(self, viewWillAppearSelector);

            Method extendedMethod = class_getInstanceMethod(self, viewWillAppearLoggerSelector);

            method_exchangeImplementations(originalMethod, extendedMethod);

        });

    }

    – (void) log_viewDidAppear:(BOOL)animated {

        [self log_viewDidAppear:animated];

        NSLog(@”viewDidAppear executed for %@”, [self class]);

    }

@end

• HTTP live streams that have their media encrypted will not be recorded by QuickTime Player on Yosemite while screen recording. These will blackout in the recording.
• HTTP live streaming:It sends live and on‐demand audio and video to iPhone, iPad, Mac, Apple TV, and PC with HTTP live streaming (HLS) technology from Apple.
• Using the equal protocol that powers the web, HLS lets us set up the content material using regular internet servers and content material delivery networks.
• HLS is designed for reliability and dynamically adapts to community prerequisites by optimizing playback for the on hand velocity of wired and wireless connections.

• Not running : The app has not been launched or was running but was terminated by the system.
• Inactive : The app is running in the foreground but is currently not receiving events.(It may be executing other code though.) An app usually stays in this state only briefly as it transitions to a different state.
• Active : The app is running in the foreground and is receiving events. This is the normal mode for foreground apps.
• Background : The app is in the background and executing code. Most apps enter this state briefly on their way to being suspended. However, an app that requests extra execution time may remain in this state for a period of time. In addition, an app being launched directly into the background enters this state instead of the inactive state.
• Suspended : The app is in the background but is not executing code. The system moves apps to this state automatically and does not notify them before doing so. While suspended, an app remains in memory but does not execute any code.When a low-memory condition occurs, the system may purge suspended apps without notice to make more space for the foreground app.

A category is a way of adding additional methods to a class without extending it. It is often used to add a collection of related methods. A common use case is to add additional methods to built in classes in the Cocoa frameworks.

For example adding async download methods to the UIImage class.

• viewDidLoad is called when the view is loaded, whether from a Xib file, storyboard or pro-grammatically created in loadView. 

• viewDidAppear-is called every time when the view is presented on the device. used to depends on the use case for your data. If the data is fairly static and not likely to change then it can be loaded in viewDidLoad and cached. However if the data changes regularly then using viewDidAppear to load it is better. In both situations, the data should be loaded asynchronously on a background thread to avoid blocking the UI.

• Managed object context exists for three reasons: life-cycle management, notifications, and concurrency.

• It permits the developer to fetch an object from a continual store and make the necessary changes before finding out whether to discard or commit these changes back to the persistent store.

• The managed object context tracks these changes and allows the developer to undo and redo changes.

• NS Persistent Container can be interpreted as property which has been developed in order to create and return a container which has loaded the store for the software to it.

• Actually, this is a critical process to get performed and it may fail to supply reliable error conditions. 

NSFetchedResultsCounter is a most liked part by the developers as it makes their lives by simply abstracting away much of the coding part which is used to synchronize a table view that has a data source backed by a core data. Though it is a controller it’s not a view controller and has no user interface.

We use dynamic for subclasses of NSManagedObject. @dynamic tells the compiler that getter and setters are implemented somewhere else.

Synchronized guarantees only one thread can be executing that code in the block at given time.

The three ways to achieve concurrency in iOS are:

• Threads
• Dispatch queues
• Operation queues

The different iOS application states are:

• Not running state:when the app has not been launched or was running but was terminated by the system.
• Inactive state:when the app is running in the foreground but is currently not receiving events. An app stays in this state briefly as it transitions to a different state. The only time it stays inactive is when the user locks the screen or the system prompts the user to respond to some event such as a phone call or SMS message.
• Active state: when the app is running in the foreground and is receiving events.This is the normal mode for foreground apps.
• Background state: when the app is in the background and executing code.Most apps enter this state briefly on their way to being suspended.However, an app that requests extra execution time can remain in this state for some time.Also,an app being launched directly into the background enters this state instead of the inactive state.
• Suspended state:A suspended app remains in memory but does not execute any code. When a low-memory condition occurs, the system may purge suspended apps without notice to make more space for the foreground app.

The UIKit framework is used to develop application’s user interface for iOS. It provides event handling, drawing model, windows, views, and controls specifically designed for a touch screen interface.

Here are a few common ways to specify the layout of elements in UIView:

• Using InterfaceBuilder,we can add an XIB file to our project, layout elements within it, and then load XIB in our application code (either automatically, based on naming conventions, or manually). Also,using InterfaceBuilder, we can create a storyboard for our application.
• We can write our own code to use NSLayoutConstraints and have elements in a view arranged by Auto Layout.
• We can create CGRects describing the exact coordinates for each element and pass them to UIView’s (id)initWithFrame:(CGRect)frame method.

• Properties specified as atomic are assured to continually return a totally initialized object.

• This additionally takes place to be the default state for synthesized properties. While it is a good practice to specify atomic properties to remove the potential for confusion, if we leave it off,he properties will still be atomic.

• This guarantee of atomic properties comes at the price of performance. However, if we have a property for which we know that retrieving an uninitialized value is now not a risk (e.g., if all access to the property is already synchronized with the aid of different means), then putting it to non-atomic can raise the performance.

A managed object context (represented by an instance of NSManagedObjectContext) is a temporary ‘scratchpad’ in an application for a (presumably) related collection of objects. These objects collectively represent an internally consistent view of one or more persistent stores.

A single-managed object instance exists in one and only one context, but multiple copies of an object can exist in different contexts.

The key functions of the managed object context include the following:

• Life-cycle management: Here, the context provides validation,inverse relationship handling, and undo/redo.
• Notifications: It refers to context posts’ notifications at various points that can be optionally monitored elsewhere in our application.
• Concurrency: Here,the Core Data uses thread (or serialized queue) confinement to protect managed objects and managed object contexts.

There’s no right or wrong answer to this, but it’s great way of seeing if you understand the benefits and challenges with each approach. Here’s the common answers I hear:

• Storyboard’s and Xib’s are great for quickly producing UI’s that match a design spec. They are also really easy for product managers to visually see how far along a screen is.
• Storyboard’s are also great at representing a flow through an application and allowing a high-level visualization of an entire application.
• Storyboard’s drawbacks are that in a team environment they are difficult to work on collaboratively because they’re a single file and merge’s become difficult to manage.
• Storyboards and Xib files can also suffer from duplication and become difficult to update.
• For example if all button’s need to look identical and suddenly need a color change, then it can be a long/difficult process to do this across storyboards and xibs.
• Pro grammatically constructing UIView’s can be verbose and tedious, but it can allow for greater control and also easier separation and sharing of code.They can also be more easily unit tested.

Most developers will propose a combination of all 3 where it makes sense to share code, then re-usable UIViews or Xib files.

var a1 = [1, 2, 3, 4, 5]

var a2 = a1

a2.append(6)

var x = a1.count

In Swift, arrays are implemented as structs, making them value types rather than reference types (i.e., classes). When a value type is assigned to a variable as an argument to a function or method, a copy is created and assigned or passed. As a result, the value of “x” or the count of array “a1” remains equal to 5 while the count of array “a2” is equal to 6, appending the integer “6” onto a copy of the array “a1.” The arrays appear in the box below.

a1 = [1, 2, 3, 4, 5]

a2 = [1, 2, 3, 4, 5, 6]

This question tests the developer’s understanding of enumeration in Swift. Enumeration provides a type-safe method of working with a group of related values. Raw values are compile time-set values directly assigned to every case within an enumeration, as in the example detailed below:

enum Alphabet: Int {

case A = 1

case B

case C

}

In the above example code, case “A” was explicitly assigned a raw value integer of 1, while cases “B” and “C” were implicitly assigned raw value integers of 2 and 3, respectively. Associated values allow you to store values of other types alongside case values, as demonstrated below:

enum Alphabet: Int {

case A(Int)

case B

case C(String)

}

Guard is an advanced component of iOS which has is being used extensively. Going deep into the aspects of the guard things will be pretty fascinating. There are two major advantages of a guard.
The first benefit of using guard is that it helps in avoiding the Pyramid of Doom. This is very much useful as it can be considered in the case where the nested statements have a tendency to go further ahead towards the right.

The other benefit of the usage of the guard is that with the aid of making use of the break or return functions it creates an probability for an early exit from the loop.

• KVC-The term KVC relates to Key-Value Coding. It is a technique in which the properties of the object can be accessed within the run time by using the concept of strings and it helps to know the different property names within the time of development. 

• KVO-The term KVO stands for Key-Value Observing. The main function of this is to observe the changes that occur to property value.  The other specification of KVO is that an object it helps in notifying the user whenever a specific property changes its value.

• Layer objects are one among the simple software factors that are delivered to perform various applications. In general, layer objects can be interpreted as the data objects that represent visible content.

• These layer objects will assist the views to render their content. The best feature if this is that custom layer objects can be created and get them added to the interface to function complex animations and different such related tremendously sophisticated visual effects.early exit from the loop.

It is quite obvious in seeing the applications getting crashed and the performance goes down. In such cases the sequential steps which are done to find the best solution to the mentioned problem are

* At first, get the exact steps to reproduce the crashed application.

* Then the next thing to be done is to find out the iOS version of that particular device.

* Then check if the version is latest or not?

* And at the end try to get device logs if possible.

• It can simply be interpreted as the functions that take up the value of another function as a parameter, or a return function.

• These higher-order functions are collective type and the filter is expressed as a basic higher-order function.

A ResponderChain is a hierarchy of objects that have the opportunity to respond to events received.

Regular expressions are special string patterns that describe how to search through a string.

Operator overloading allows us to change how existing operators behave with types that both already exist. Operators are those little symbols like +, *, and /