Angular JS interview Questions

1) What is AngularJS?

AngularJS is a javascript framework used for creating single web page applications.  It allows you to use HTML as your template language and enables you to extend HTML’s syntax to express your application’s components clearly

2) Explain what are the key features of AngularJS ?

The key features of AngularJS are

• Scope
• Controller
• Model
• View
• Services
• Data Binding
• Directives
• Filters
• Testable

3) Explain what is scope in AngularJS ?

Scope refers to the application model, it acts like glue between application controller and the view.  Scopes are arranged in hierarchical structure and impersonate the DOM ( Document Object Model) structure of the application.  It can watch expressions and propagate events.

4) Explain what is services in AngularJS ?

In AngularJS services are the singleton objects or functions that are used for carrying out specific tasks.  It holds some business logic and these function can be called as controllers, directive, filters and so on.

5) Explain what is Angular Expression? Explain what is key difference between angular expressions and JavaScript expressions?

Like JavaScript,  Angular expressions are code snippets that are usually placed in binding such as {{ expression }}

The key difference between the JavaScript expressions and Angular expressions

• Context : In Angular, the expressions are evaluated against a scope object, while the Javascript expressions are evaluated against the global window
• Forgiving: In Angular expression evaluation is forgiving to null and undefined, while in Javascript undefined properties generates TypeError or ReferenceError
• No Control Flow Statements: Loops, conditionals or exceptions cannot be used in an angular expression
• Filters: To format data before displaying it you can use filters

6) With options on page load how you can initialize a select box ?

You can initialize a select box with options on page load by using ng-init directive

• <div ng-controller = “ apps/dashboard/account ” ng-switch
• On = “! ! accounts” ng-init = “ loadData ( ) ”>

7) Explain what are directives ? Mention some of the most commonly used directives in AngularJS application ? 

A directive is something that introduces new syntax, they are like markers on DOM element which attaches a special behavior to it. In any AngularJS application, directives are the most important components.

Some of the commonly used directives are ng-model, ng-App, ng-bind, ng-repeat , ng-show etc.

8) Mention what are the advantages of using AngularJS ?

AngularJS has several advantages in web development.

• AngularJS supports MVC pattern
• Can do two ways data binding using AngularJS
• It has per-defined form validations
• It supports both client server communication
• It supports animations

9) Explain what Angular JS routes does ?

Angular js routes enable you to create different URLs for different content in your application.  Different URLs for different content enables user to bookmark URLs to specific content.  Each such bookmarkable URL in AngularJS is called a route

A value in Angular JS is a simple object.  It can be a number, string or JavaScript object.  Values are typically used as configuration injected into factories, services or controllers. A value should be belong to an AngularJS module.

Injecting a value into an AngularJS controller function is done by adding a parameter with the same name as the value

10)  Explain what is data binding in AngularJS ?

Automatic synchronization of data between the model and view components is referred as data binding in AngularJS.  There are two ways for data binding

1. Data mining in classical template systems
2. Data binding in angular templates

11)  What makes AngularJS better ?

• Registering Callbacks: There is no need to register callbacks . This makes your code simple and easy to debug.
• Control HTML DOM programmatically:  All the application that are created using Angular never have to manipulate the DOM although it can be done if it is required
• Transfer data to and from the UI: AngularJS helps to eliminate almost all of the boiler plate like validating the form, displaying validation errors, returning to an internal model and so on which occurs due to flow of marshalling data
• No initilization code: With AngularJS you can bootstrap your app easily using services, which auto-injected into your application in Guice like dependency injection style

12)  Explain what is string interpolation in Angular.js ?

In Angular.js the compiler during the compilation process matches text and attributes using interpolate service to see if they contains embedded expressions.  As part of normal digest cycle these expressions are updated and registered as watches.

13)  Mention the steps for the compilation process of HTML happens?

Compilation of HTML process occurs in following ways

• Using the standard browser API, first the HTML is parsed into DOM
• By using the call to the $compile () method, compilation of the DOM is performed.  The method traverses the DOM and matches the directives.
• Link the template with scope by calling the linking function returned from the previous step

14)  Explain what is directive and Mention what are the different types of Directive?

During compilation process when specific HTML constructs are encountered a behaviour or function is triggered, this function is referred as directive.  It is executed when the compiler encounters it in the DOM.

Different types of directives are

• Element directives
• Attribute directives
• CSS class directives
• Comment directives

15)  Explain what is linking function and type of linking function?

Link combines the directives with a scope and produce a live view.  For registering DOM listeners as well as updating the DOM, link function is responsible. After the template is cloned it is executed.

• Pre-linking function: Pre-linking function is executed before the child elements are linked.  It is not considered as the safe way for DOM transformation.

• Post linking function: Post linking function is executed after the child elements are linked. It is safe to do DOM transformation by post-linking function

16)  Explain what is injector?

An injector is a service locator.  It is used to retrieve object instances as defined by provider, instantiate types, invoke methods and load modules.  There is a single injector per Angular application, it helps to look up an object instance by its name.

17)  Explain what is the difference between link and compile in Angular.js?

• Compile function: It is used for template DOM Manipulation and collect all of the directives.
• Link function: It is used for registering DOM listeners as well as instance DOM manipulation. It is executed once the template has been cloned.

18)  Explain what is factory method in AngularJS?

For creating the directive, factory method is used.  It is invoked only once, when compiler matches the directive for the first time.  By using $injector.invoke the factory method is invoked.

19)  Mention what are the styling form that ngModel adds to CSS classes ?

ngModel adds these CSS classes to allow styling of form as well as control

• ng- valid
• ng- invalid
• ng-pristine
• ng-dirty

20)  Mention what are the characteristics of “Scope”?

• To observer model mutations scopes provide APIs ($watch)
• To propagate any model changes through the system into the view from outside of the Angular realm
• A scope inherits properties from its parent scope,  while providing access to shared model properties, scopes can be nested to isolate application components
• Scope provides context against which expressions are evaluated

21)  Explain what is DI (Dependency Injection ) and how an object or function can get a hold of its dependencies ?

DI or Dependency Injection is a software design pattern that deals with how code gets hold of its dependencies.  In order to retrieve elements of the application which is required to be configured when module gets loaded , the operation “config” uses dependency injection.

These are the ways that object uses to hold of its dependencies

• Typically using the new operator, dependency can be created
• By referring to a global variable, dependency can be looked up
• Dependency can be passed into where it is required

22)  Mention what are the advantages of using Angular.js framework ?

Advantages of using Angular.js as framework are

• Supports two way data-binding
• Supports MVC pattern
• Support static template and angular template
• Can add custom directive
• Supports REST full services
• Supports form validations
• Support both client and server communication
• Support dependency injection
• Applying Animations
• Event Handlers

23)  Explain the concept of scope hierarchy?  How many scope can an application have?

Each angular application consist of one root scope but may have several child scopes. As child controllers and some directives create new child scopes, application can have multiple scopes. When new scopes are formed or created they are added as a children of their parent scope. Similar to DOM, they also creates a hierarchical structure.

24)  Explain what is the difference between AngularJS and backbone.js?

AngularJS combines the functionalities of most of the 3^rd party libraries, it supports individual functionalities required to develop HTML5 Apps.  While Backbone.js do their jobs individually.

25)  Who created Angular JS ?

Intially it was developed by Misko Hevery and Adam Abrons. Currently it is being developed by Google.

Assign, retain, copy in Obj-C

Assign, retain, copy in Obj-C property accessors

In this post, I'll look at some very subtle problems that can occur if a getter or setter method chooses the wrong memory management pattern and in the process, explain why NSDictionary copies its keys rather than simply retains them.

Scope of this article: in this post I'll be discussing basic memory and mutability considerations in Objective-C accessor methods. If you're interested in atomicity and thread safety issues in accessor methods, please read my earlier post on Memory and thread-safe custom property methods. This post will only look at non-atomic accessors.

Why implement your own accessors?

If you know about Objective-C's properties, you may already be asking, "Why implement your own accessors at all?". For simple accessors, you can (and probably should) use the synthesized@property accessors and not worry about the implementation. The reason for this post is that you will often need to implement accessor methods yourself to attach additional behaviors to the get or set action, so you always need to know how the accessor should work.

The one you already know: the assign pattern

Since you're reading this blog, it's probably safe to assume that you already know how a basic assign accessor looks:

- (SomeVariable)someValue {     return someValue; }

and a setter method looks like this:

- (void)setSomeValue:(SomeVariable)aSomeVariableValue {     someValue = aSomeVariableValue; }

For most non-object data, that's all you need. This is the implementation you'd get with a non-atomic assign synthesized @property.

Retain: first opportunities for failure

If you're working with retain/released objects in Objective-C, your object will become invalid if your setter does not retain it, so the setter must handle this.
The most completely through, all purpose way of handling retain and release issues in a setter looks like this:

- (void)setSomeInstance:(SomeClass *)aSomeInstanceValue {     if (someInstance == aSomeInstanceValue)     {         return;     }     SomeClass *oldValue = someInstance;     someInstance = [aSomeInstanceValue retain];     [oldValue release]; }

This is obviously much more complicated than a simple assignment.
The biggest point that stands out i the weird retain/release dance occupying the last three lines of this code block. We do this to avoid problems where the object pointed to byaSomeInstanceValue and someInstance is the same. Imagine the following:

- (void)setSomeInstance:(SomeClass *)aSomeInstanceValue {     [someInstance release]; // <-- original value is released     someInstance = [aSomeInstanceValue retain]; }

If aSomeInstanceValue and someInstance are the same object, then the first line could release the underlying object before the second line retains it — meaning that the object is destroyed and invalid by the time it is retained again.
You'll notice that we use the C equality operator to compare the two objects instead of theisEqual: method. Normally, this is a bad idea (Objective-C objects may be "equal" even if they do not point to the same location in memory) but in this case, we are specifically interested in cases where the memory location (and hence the retain counts) are identical. The comparison is not strictly necessary to prevent premature release (since the retain precedes the release) but it's an optimization and safety measure.
In reality though, all this is a bit painful to write: the comparison, the annoying temporary value and the careful ordering of everything. In practice, we normally use a shorter version of the setter method that is basically just as good and is certainly far easier to write:

- (void)setSomeInstance:(SomeClass *)aSomeInstanceValue {     [someInstance autorelease];     someInstance = [aSomeInstanceValue retain]; }

In this case, we don't care about the comparison optimisation and we use the autorelease pool to temporarily hold the original value instead of our own stack value.
This method has the same safety as the retain/release dance but requires an autorelease pool and is marginally slower if someInstance and aSomeInstanceValue are actually the same. In reality, there's almost always an autorelease pool in a Cocoa application and the performance difference is more theoretical than real (you'd have difficulty constructing a test program to ever show a difference) until you start creating copy setters (see below).

Not all Objective-C setters should retain: There are some situations where a setter method that takes an Objective-C object should not retain its parameter. Specifically: objects in a hierarchy should not normally retain their parents. Look at Rules to avoid retain cycles for more on this topic.

The other half of the retain access pattern

In reality, even if you forget to perform the if (newInstance == oldInstance) return; check in your accessor method, you are highly unlikely to see a problem even if you actually do pass the current value to a setter method.
The reason why you are normally safe, even if you make a mistake, is because the parameter you pass into a method normally has another retain count held elsewhere.
Specifically: most objects you access on the stack have an autoreleased retain count held by an autorelease pool on the stack or a longer lived object somewhere in the heap.
Theoretically, you could help this idea along by implementing your getter methods like this for retained objects:

- (SomeClass *)someInstance {     return [[someInstance retain] autorelease]; }

This will ensure that if your object is used like this:

SomeClass *stackInstance = [anObject someInstance]; [anObject release]; // anObject releases its someInstance ivar in its dealloc method [stackInstance doSomething];

Then the stackInstance variable will still be valid when doSomething is invoked on it.
Generally though, I don't bother doing this in non-atomic getter methods.
Why not? Speed, redundancy and common sense.
While retaining and autoreleasing something is not a gigantic overhead, it is normally just not needed for a get accessor method. The programmer using the get accessor should understand that the lifetime is bound to the source object.
However, you may want to use this pattern in a situation where it is not immediately clear that the value returned is a getter method. For example:

@implementation ThisClassIsReallyJustAString   - (NSString *)description {     return [[internalValue retain] autorelease]; }   @end

The description method (which returns an NSString representation of an object) does not normally return an instance variable directly so it would not ordinarily be considered an accessor method. In this situation, it is implemented as an accessor but due to the expectation that the description is a generated value, we need to retain and autorelease the returned value.
Any instance variable returned from a method where the method is not obviously an accessor method should always go through a retain/autorelease since it is not immediately obvious that its lifetime would be bound to the lifetime of the source object.

Copy accessors

The reason why retain accessors exist is obvious — you don't want the value to be deallocated while it is set on the object.
The reason for the final accessor pattern in Objective-C — copy accessors — is less broadly understood but nonetheless relevant.
You should use a copy accessor when the setter parameter may be mutable but you can't have the internal state of a property changing without warning. Consider the following example:

NSMutableString *mutableString = [NSMutableString stringWithString:@"initial value"]; [someObject setStringValue:mutableString]; [mutableString setString:@"different value"];

In this situation, if the setStringValue: method followed the retain pattern, then the setString:method invoked on the next line would change the internal value of this property without warningsomeObject.
Sometimes, you don't care if the internal state of a property change without warning. However, if you do care about the internal state of a property changing, then you'll want to use a copy setter.
The implementation of a non-atomic copy setter is as simple as you'd imagine:

- (void)setStringValue:(NSString *)aString {     if (stringValue == aString)     {         return;     }     NSString *oldValue = stringValue;     stringValue = [aString copy];     [oldValue release]; }

Correction: I had previously stated that you don't need the equality comparison for a copy (since I wrongly claimed the copy would ensure you always have a different block of memory). I was wrong, of course. As was immediately pointed out in the comments: copydoes not always return a copy; for immutable objects, copy can return the same object. I forgot about this, even though I've certainly written copy setters that work this way (see theSynthesizeSingleton code). The result is that we still need the comparison to ensure that setting the property to the same value doesn't cause the same potential release problems that the previous retain pattern had. Did I mention it is possible to screw up property accessors?

This finally explains why NSDictionary copies its keys.
NSDictionary stores all its value objects in locations according to the result of each corresponding key object's hash method.
If a key object were to change in such a way that the hash method result changed, then theNSDictionary would not be able to find the corresponding value object any more.
Key objects are not set by a property accessor on an NSDictionary but the effect is the same: the copy pattern is used to ensure that outside objects cannot change the internal state of the dictionary without warning.
Of course, the downside to properties that follow the copy pattern is speed. It's not normally an issue for objects up to a few kilobytes but beyond that point, you'll need to consider whether copy is the right pattern for the resources involved.

Conclusion

Getter and setter methods are frequently given as the simplest kind of method to implement. But you can see that even within this very simple kind of method, there are subtle ways that they can go wrong.
Overall, this post is a much simpler level than my typical posts but that doesn't mean its only for novice Objective-C developers. Experienced programmers are far from immune to mistakes in this area. Some of the potential quirks with getter and setter methods are so rare you may never see a problem (even if your code is doing things in an unsafe manner) so learning from experience can take time in this area.
Of course, if you don't need any customization in your accessor methods, you should simply use a synthesized @property implementation. This will avoid any possibility of introducing mistakes.