1. What is angular 2?
2. What are the main elements of Angular 2?
• Modules: this is utilized for breaking the application into logical pieces of code. Each of the pieces are then designed so as to perform a single task.
• Templates: these would be used to define the views of the application.
• Metadata: this can be used in order to add additional data to the Angular JS class.
• Component: this may be utilized to bring the modules together.
• Service: this is utilized for creating components that can be shared across the application.
3. What are components in Angular 2?
Each application has components and each component is a logical boundary that provides functionality to the application. One needs to have layered services that are used for sharing the functionality across the different components. A component entails the following:
• Class: this is like a Java class or C which has properties and methods.
• Metadata: this is utilized for decorating the class and extending the functionality of the class.
• Template: this may be used for the definition of the HTML perspective that is displayed within the application.
4. What are Modules in Angular 2?
The modules are used to place logical boundaries in the application. As such, as opposed to coding everything into one application, there is the option of building everything into separate modules for the purpose of separating the functionality of the application. The Module entails the following parts:
• Bootstrap array: this can be used to tell the framework which components need to be loaded such that the functionality can be accessed within the application. At the time, the component within the bootstrap has been included; you need to declare them such that they would be used across the other components within the framework.
• Import array: the import array can be used to import the functionality from the other modules.
• Export array: this is used for the exportation of directives, components and popes that can be utilized within some of the other modules.
5. What are the new features of Angular 2?
Angular 2 is written completely in typescript and meets the ECMAScript 6 particulars. That is to say:
• It is component based: angular 2 is component based. The $scope and controllers are no longer relevant. They have been replaced by directives and components.
• Directives: directive specifications are still very simplified though they are subject to much change. With the @Directive annotation, a directive may be declared.
• Lambdas with TypeScript: In TypeScript, lambdas are available.
• Dependency injection: because of the improvement dependency injection model within Angular 2, there are more chances for the component or object based work.
• Generics: TypeScript has a number of generics, which would be utilized in the frontend.
• Forms and validation: forms and validations are one of the significant elements of frontend development. In Angular 2, the Form Builder as well as, the Control Group are defined.
6. What is the significance of Angular 2?
Angular 2 is not just the usual upgrade but represents a complete overhaul of the previous platform. The entire framework was rewritten from scratch. Angular 2 got rid of things such as controllers, $scope, DDO, jqLite, Angular.module and so forth. The components are used for practically everything. Imagine that the entire application is currently ne big component. It also benefits from ES6 or TypeScript syntax. The development of Angular 2 apps in TypeScript has made it even stronger apart from that, several things have evolved and have been re-designed.
7. What is TypeScript?
8. What is ECMAScript?
9. What is @ngmodule?
NgModule refers to a decorator function. This provides the chance for users to mark something like Angular 2 and it allows you to provide additional data, which determines how the Angular 2 thing is going to be processed, instantiated and utilized during the runtime. That means whenever the user writes @NgModule, it communicates to the Angular 2 module what is going to be included and utilized within the module.
10. What is Traceur Compiler?
11. What is @inputs when it comes to Angular 2?
@input allows one to pass data into the controller and the templates through the html and defining the custom properties. That would allow one to reuse the components and then have them illustrate the different values for each scenario of the renderer.
12. How does one define transition between two different states in angular?
The transitions made between two states take place so that it is possible to build some animations between the two states driven by a model attribute. The concept of transition means the navigation from the present state to a new one. In angular, the transition is an animation specific type of function that is used within the framework’s animation DSL language. Transition declares the sequence of the animation steps, which are going to be implemented when the entered value is satisfied. A function is then given an argument for a transition and it is implemented each time that the state change happens. In this way, if the function is correct, the animation is going to run or else it is not going to be implemented. These animation transitions are then situated within the animation triggers. The transition may be dependent on what the animation was in the previous state and what it is going to be in the next state. That would mean if a transition is defined according to a way that matches the old or present state criteria then the associated animation is going to be triggered.
13. How do you declare a component in Angular 2?
The components in Angular 2 are just directives, which are linked with a direct template. Angular 2 components have a very well defined life cycle. When working with angular components, it becomes possible to make use of interfaces, which allow for the implementation of functionality at different times in the lifecycle of a component. The component has to belong to an NgModule for it to be utilized by another application or component. The components may even control their runtime behavior through the implementation of different lifecycle hooks. Components always have a template and only one of the components may be instantiated for every element within a template. When the component has been instantiated Angular then creates a change detector that propagates the construction of the component.
14. What is the difference between promises and observable?
• An observable is like a stream that allows passing zero or more events where the callback is called for each of the events. On the other hand, a promise eventually calls the success or failed callback even at the time when you do not need the notification or result that is given anymore.
• Observable is a significant way to handle the HTTP asynchronous requests. Though, a promise just handles a single event when an asynchronous operation fails or completes.
• Observable works with a number of values for a set time though promises work with and even return a single value at one time.
• The observables support the map, filter and reduce as well as, similar operators. The promises happen to have more readable codes with async/await and try/catch.
• Promises cannot be canceled but observables can be canceled.
• When it comes to observables, an operator ‘retry’ may be utilized to retry when it is needed. On the other hand, promises cannot be retired. A promise ought to have access to the original function that returned the promise so as to have a retry type of capability.
15. What are the differences between directives and Angular 2 components?
Apart from the components, the directives are also utilized when it comes to Angular 2 and that allows for the attachment of behavior to the elements in DOM. There are particular differences between the components and directives in Angular 2. They would include:
• In Angular 2, the component is a directive with a view though a directive is a decorator that does not have a view. Components would be the particular type of directive, which allows for the utilization of web component functionality throughout the application. Directive refers to the mechanism through which behavior is attained to the elements.
• A component can be used for breaking up the application into smaller parts. Though, the directive is used for designing the reusable components.
• Components can also be used in the definition of pipes. Though, it is not possible to define pipes with the use of directives.
• The components can be present for every DOM element. The directive on the other hand, is used for adding behavior to one of the existing DOM elements.
16. When is the optimal time to use constructor and NgOnInit in Angular 2?
Constructors are utilized for the initialization of class members and also for dependency injection. NgOnInit is utilized for the initialization. Both of them are called at the time the component is created. It is important that you should know how and when they are used. They are utilized for giving the best structure for the code of the component. The constructor method is one of the pre-defined means in the constructor class that is only called when the class has been instantiated. It may also be used for the proper initialization of the fields. The constructor then in Angular 2 may be used for creating a new instance of the class. NgOnInit would be the class that is imported when you implement the constructor to use it within a class. The approach that is used in this case is the ngOnInit(). This approach assists in the initialization of the directive or the component after the data bound set of properties is illustrated and the directive or the input of the components has been set.
17. What would be there is a shared module in Angular 2?
The shared module is used for importing the services in both the lazy loaded and eager modules. It is apparent that the lazy loaded type modules create their branch on the dependency injection tree. The shared module consists of services, which are registered by the angular in the root app injector. For this, there is no need to import it within the lazy module considering the lazy loaded modules already had access to the services as defined at the root. The pipes, directives and components are also defined within the shared module. The other modules, which import the shared module, would be able to utilize it in their templates. That would mean the modules would be imported normally in the lazy loaded module. The shared type module has the code, which is going to be used across the applications and the modules as featured. It also entails the common template components. The ‘Dumb components’ also need to be present within the shared module. It usually entails some of the common angular modules as well. When one is importing the shared module, there is going to be a need to import the module with its providers as there is no app module within the test.
18. What is the concept of lazy loading when it comes to Angular 2?
Lazy loading refers to a module that is utilized for decreasing the startup time. When the lazy module is utilized, the system application does not have to load everything at the same time. There is only a need to load what the user would expect to see at the time the application first loads. The modules that experience lazy loading are only going to be loaded when the user navigates to their particular routes. Lazy loading allows for the improvement of the performance of the system applications. It also keeps the initial payload at the minimum and these smaller type payloads may lead to a faster download speed. This would assist in the lowering of the resource costing particularly when it comes to the mobile networks. In the event that the user does not visit a section of the application, they may not download these resources. The idea of lazy loading when it comes to Angular requires the user to format the application in a particular manner. Each of the assets, which are to be loaded have to be added to their own module. It overcomes the problem of slow loading of applications, in their separate ways, which then assist with the loading time of the application. Lazy loading can be implemented in the following.
• Update the route file
• Install of the angular-router-loader and add the loader to the webpack configuration file.
• Define the lazy routes.
• Import the routes for the module.
19. What is meant by structural directive in Angular 2?
Structural directives can be used for the manipulation of DOM in Angular. Their obligation concerns the HTML layout. Through the adding, removal and manipulation of the LMNs within angular, they reshape the structure of DOM. This structural directive is applied to the host element with the assistance of other directives. The directives do whatever they are meant to do with the host element and the descendants. The structural directives may also be easily recognized. They can also delay the instantiation of the element or component. They may also be used for cosmetic effect or the manual handling of the timing of the loading the components. The structural directives then are bound to a particular template. The two common structural directives would be ‘nglf’ and ‘ngFor’. As such, the process that is occurring in a structural directive is dynamic.
20. What is the difference between ActivatedRoute and RouterState, with particular reference to Angular 2?
• ActivatedRoute entails the information about a route that is linked with a component loaded in an outlet. Though, the RouterState represents the state that the writer is.
• ActivatedRouterSnapchat is needed in order to traverse all of the activated routes. However, during navigation after redirects have been applied, the router would create the RouterStateSnapshot.
• ActivatedRouteSnapshot has old data. When the route changes, ActivateRouteSnapshot has data from the previous route. The RouterState may care about the application components or to be more particular about their arrangements.
21. What is routing?
Routing assists in directing the users to different pages according to options chosen on the main page. Thus, according to the option, which is chosen, the Angular Component is going to be rendered to the user.
22. What is CLI?
This is the command line interface that may be used to create the Angular application. It may also assist in the construction of unit and end-to-end tests for the application.
23. How does routing work in Angular 2?
The angular application has a single instance of Router service and when the URL alters then a corresponding Route is then matched from the routing configuration array. Upon successful matching, it applies redirects and the router would construct a tree of ActivatedRoute objects and has the current state of the router. Before redirection, the router is going to check if the new state would be permitted by running guards. The Route Guards are simply an interface method, which the router runs in order to check the route authorization. After the guard runs, it may resolve the route data and then activate the router state through instantiation of the needed components into the
24. What are the event emitters and how do they work within Angular 2?
Angular 2 does not have a bi-directional digest cycle. In Angular 2, any of the changes attained within the component is propagated from the present component to all of the children in hierarchy. In the event the change from one of the components needs to be reflected to any of the parent components in hierarchy, it is possible to emit the event through the use of Event Emitter API.
EventEmitter is class defined within @angular/core module that can be utilized by directives and components for emit custom events
@output () somethingChanged = new EventEmitter ();
You use somethingChanged.emit(value) method in order to emit the event. This can be done in the setter when the value is being changed within the class. This event emit may be subscribed by any of the components of the modules through the use of the subscribe approach. myObj.somethingChanged. subscribe(val) => this.myLocalMethod(val));
25. How does one optimize the Angular 2 application for the purpose of better performance?
Optimization is dependent on the size and the type of the application and other factors. Though in general, there should be consideration for a number of points during the optimization of the Angular 2 application.
• Consideration of the AOT compilation.
• Make sure the application has been bundled and tree shaking has been done.
• Make certain the application does not have unnecessary import statements.
• Make certain the 3rd party library, which has not been utilized, can be removed from the application.
• Have all of the dev-dependencies and the dependencies clearly separated.
• Loading ought to be considered as opposed to fully bundled app if the app size is more
26. How possible is it to define the custom typing for one to avoid the editor warnings?
27. What is the Shadow Dom? How is it helping Angular 2 to do better?
28. What is Angular 2 hidden property?
The hidden property within Angular 2 represents a special case.
• The property is more powerful and can be utilized for binding any of the properties of the elements.
• It is found to be the closest relation to ngshow and nghide.
• It sets the display property ‘display: none’.
29. What are the host decorators in Angular 2?
The host decorators within Angular 2 bind the properties of the components that have User Interface element values. The properties that are within a component class definition which are decorated with @HostBinding may be accessed in a template from the set property which is @HostBinding()title=’Our title'( whatever the title is).
30. Why are decorators used in Angular 2?
The decorators can be utilized as an identifier of class or type of the object, which is created by the TypeScript. The Angular 2 identifies the class; below the decorator call as the definition of the class and would extend the decorator specific properties with class definition.
31. How is it possible to handle errors within Angular 2 applications?
The Angular 2 applications give the option of error handling. The errors, which are in Angular 2, may be handled through the inclusion of the ReactJS catch library and later with the use of the catch function.
• Thus, the catch function that is used after adding the catch library has the link to the error handler.
• And in this error, the handler function, the errors would be sent to the error console and the errors would be thrown to continue the implementation.
• That means when an error occurs it is going to be redirected to the error console of the web.
32. What are the pros and cons of AoT compilation?
• A lesser number of Http Requests- if the application has not been bundled for the purpose of supporting lazy loading, (for each of the linked CSS and HTML) there is a separate request that goes to the server. The precompiled application in lines all of the templates and styles with components thus the number of the Http requests to the server is going to be lesser.
• The errors can be detected at build time: because the compilation happens before-hand, a lot of the compile time error can be found and this allows for a better degree of stability for the application.
• There is no watch mode as yet but they have to be done manually and it compiles all of the files.
• It only works with HTML and CSS. The other file types require a previous build step.