Angular 2+ Notes for Professionals Angular 2+ Notes for Professionals 200+ pages of professional hints and tricks GoalKicker.com Free Programming Books Disclaimer This is an unocial free book created for educational purposes and is not aliated with ocial Angular 2+ group(s) or company(s). All trademarks and registered trademarks are the property of their respective owners Contents About ................................................................................................................................................................................... 1 Chapter 1: Getting started with Angular 2+ ..................................................................................................... 2 Section 1.1: Getting started with Angular 2 with node.js/expressjs backend (http example included) Section 1.2: Install angular2 with angular-cli Section 1.3: Getting started with Angular 2 without angular-cli Section 1.4: Getting through that pesky company proxy Section 1.5: Keeping Visual Studios in sync with NPM and NODE Updates Section 1.6: Let's dive into Angular 4! ......................................................................................................................... ........................................................................................ .............................................................................. .............................................................................................................. 7 .......................................................... ................. 2 Chapter 2: Components ........................................................................................................................................... 20 Section 2.1: A simple component Section 2.2: Templates & Styles Section 2.3: Testing a Component Section 2.4: Nesting components ............................................................................................................................... ................................................................................................................................. ............................................................................................................................. 21 .............................................................................................................................. 22 Chapter 3: Component interactions .................................................................................................................. 24 Section 3.1: Pass data from parent to child with input binding Section 3.2: Parent - Child interaction using @Input & @Output properties Section 3.3: Parent - Child interaction using ViewChild Section 3.4: Bidirectional parent-child interaction through a service ........................................................................................... .................................................................... ............................................................................... 24 ........................................................ 30 ................................................................................................................................................ ....................................................................................................................................................... ................................................................................................................................... Chapter 4: Directives Section 4.1: *ngFor Section 4.2: Attribute directive Section 4.3: Component is a directive with template Section 4.4: Structural directives Section 4.5: Custom directive Section 4.6: Copy to Clipboard directive Section 4.7: Testing a custom directive .............................................................................................. 36 ............................................................................................................................... ..................................................................................................................................... ................................................................................................................... ..................................................................................................................... 38 Chapter 5: Page title ................................................................................................................................................. 40 Section 5.1: changing the page title ........................................................................................................................... 40 Chapter 6: Templates ............................................................................................................................................... 41 Section 6.1: Angular 2 Templates ............................................................................................................................... 41 Chapter 7: Commonly built-in directives and services ............................................................................ 42 Section 7.1: Location Class Section 7.2: AsyncPipe Section 7.3: Displaying current Angular 2 version used in your project Section 7.4: Currency Pipe .......................................................................................................................................... ................................................................................................................................................ .......................................................................................................................................... 43 ................................................................ 43 Chapter 8: Directives & components : @Input @Output ........................................................................ 44 Section 8.1: Angular 2 @Input and @Output in a nested component Section 8.2: Input example Section 8.3: Angular 2 @Input with asynchronous data ......................................................................................................................................... ......................................................................................... ................................................................... 44 Chapter 9: Attribute directives to aect the value of properties on the host node by using the @HostBinding decorator. .................................................................................................................. 48 Section 9.1: @HostBinding Chapter 10: How to Use ngif .......................................................................................................................................... 48 .................................................................................................................................. 49 Section 10.1: To run a function at the start or end of *ngFor loop Using *ngIf Section 10.2: Display a loading message Section 10.3: Show Alert Message on a condition .................................................................................................................. .................................................................................................... ...................................................... 49 10 14 15 16 20 20 31 32 35 35 36 36 36 36 42 42 45 46 49 49 Section 10.4: Use *ngIf with*ngFor Chapter 11: How to use ngfor Section 11.1: *ngFor with pipe Section 11.2: Unordered list example Section 11.3: More complext template example Section 11.4: Tracking current interaction example Section 11.5: Angular 2 aliased exported values ............................................................................................................................. ................................................................................................................................ ...................................................................................................................................... ......................................................................................................................... ....................................................................................................... ................................................................................................. 51 ....................................................................................................... 52 Chapter 12: Angular - ForLoop ............................................................................................................................. 53 Section 12.1: NgFor - Markup For Loop Section 12.2: *ngFor with component Section 12.3: Angular 2 for-loop Section 12.4: *ngFor X amount of items per row Section 12.5: *ngFor in the Table Rows ..................................................................................................................... ........................................................................................................................ ................................................................................................................................. ...................................................................................................... 54 ..................................................................................................................... 54 Chapter 13: Modules .................................................................................................................................................. 55 Section 13.1: A simple module Section 13.2: Nesting modules ..................................................................................................................................... 55 .................................................................................................................................... 55 Chapter 14: Pipes ........................................................................................................................................................ 57 .......................................................................................................................................... .......................................................................................................................................... ....................................................................................................................................... .................................................................................................................... ......................................................................................................................................... ................................................................................................ 60 ......................................................................................................................................... ........................................................................................................................... ........................................................................................................... .................................................................................................................. Section 14.1: Custom Pipes Section 14.2: Built-in Pipes Section 14.3: Chaining Pipes Section 14.4: Debugging With JsonPipe Section 14.5: Dynamic Pipe Section 14.6: Unwrap async values with async pipe Section 14.7: Stateful Pipes Section 14.8: Creating Custom Pipe Section 14.9: Globally Available Custom Pipe Section 14.10: Extending an Existing Pipe Section 14.11: Testing a pipe Chapter 15: OrderBy Pipe Section 15.1: The Pipe ........................................................................................................................................ ....................................................................................................................................... ................................................................................................................................................... Chapter 16: Angular 2 Custom Validations .................................................................................................... 68 Section 16.1: get/set formBuilder controls parameters Section 16.2: Custom validator examples: Section 16.3: Using validators in the Formbuilder ................................................................................................................. .................................................................................................... ........................................................................................... 68 Chapter 17: Routing ................................................................................................................................................... 70 Section 17.1: ResolveData Section 17.2: Routing with Children Section 17.3: Basic Routing Section 17.4: Child Routes Chapter 18: Routing (3.0.0+) ............................................................................................................................................ 70 ............................................................................................................................ 72 ......................................................................................................................................... ........................................................................................................................................... .................................................................................................................................. Section 18.1: Controlling Access to or from a Route Section 18.2: Add guard to route configuration Section 18.3: Using Resolvers and Guards Section 18.4: Use Guard in app bootstrap Section 18.5: Bootstrapping Section 18.6: Configuring router-outlet Section 18.7: Changing routes (using templates & directives) Section 18.8: Setting the Routes ........................................................................................................................................ ..................................................................................................................... ................................................................................................................................. 83 ................................................................................ 82 ................................................................................................ ....................................................................................................... ................................................................................................................ ................................................................................................................ Chapter 19: Dynamically add components using ViewContainerRef.createComponent ...... 85 50 51 51 51 51 53 53 53 57 58 58 59 59 61 62 63 63 63 65 65 68 69 73 76 78 78 79 80 81 81 82 Section 19.1: A wrapper component that adds dynamic components declaratively Section 19.2: Dynamically add component on specific event(click) Section 19.3: Rendered dynamically created component array on template HTML in Angular 2 ...................................................................... ........................................... ..................... 87 85 86 Chapter 20: Installing 3rd party plugins with angular-cli@1.0.0-beta.10 ....................................... 91 Section 20.1: Add 3rd party library that does not have typings Section 20.2: Adding jquery library in angular-cli project ............................................................................. 91 ...................................................................................... 91 94 94 94 94 95 95 96 96 98 98 102 105 108 109 109 109 109 Chapter 21: Lifecycle Hooks Section 21.1: OnChanges Section 21.2: OnInit Section 21.3: OnDestroy Section 21.4: AfterContentInit Section 21.5: AfterContentChecked Section 21.6: AfterViewInit Section 21.7: AfterViewChecked Section 21.8: DoCheck .................................................................................................................................. ............................................................................................................................................. ...................................................................................................................................................... .............................................................................................................................................. ..................................................................................................................................... ........................................................................................................................... 95 ........................................................................................................................................... ................................................................................................................................. ................................................................................................................................................. Chapter 22: Angular RXJS Subjects and Observables with API requests ...................................... 98 Section 22.1: Wait for multiple requests Section 22.2: Basic request Section 22.3: Encapsulating API requests .................................................................................................................... ........................................................................................................................................ ................................................................................................................. 98 Chapter 23: Services and Dependency Injection ...................................................................................... 100 Section 23.1: Example service Section 23.2: Example with Promise.resolve Section 23.3: Testing a Service Chapter 24: Service Worker ................................................................................................................................... 100 ........................................................................................................... 101 ................................................................................................................................ ............................................................................................................................... Section 24.1: Add Service Worker to our app ......................................................................................................... 105 .................................................................................................................... 108 Chapter 25: EventEmitter Service Section 25.1: Catching the event Section 25.2: Live example Section 25.3: Class Component Section 25.4: Class Overview Section 25.5: Emmiting Events .............................................................................................................................. ....................................................................................................................................... ............................................................................................................................... ................................................................................................................................... ................................................................................................................................. Chapter 26: Optimizing rendering using ChangeDetectionStrategy ............................................. 110 Section 26.1: Default vs OnPush ............................................................................................................................... 110 Chapter 27: Angular 2 Forms Update ............................................................................................................ 111 Section 27.1: Angular 2 : Template Driven Forms Section 27.2: Angular 2 Form - Custom Email/Password Validation Section 27.3: Simple Password Change Form with Multi Control Validation Section 27.4: Angular 2 Forms ( Reactive Forms ) with registration form and confirm password validation .................................................................................................. .................................................................. ...................................................... 111 111 113 ............................................................................................................................................................................. 114 Section 27.5: Angular 2: Reactive Forms (a.k.a Model-driven Forms) Section 27.6: Angular 2 - Form Builder Chapter 28: Detecting resize events ................................................................................................................... .............................................................................................................. ................................................................. 116 117 119 Section 28.1: A component listening in on the window resize event .................................................................... 119 Chapter 29: Testing ngModel ............................................................................................................................. 120 Section 29.1: Basic test .............................................................................................................................................. 120 Chapter 30: Feature Modules ............................................................................................................................. 122 Section 30.1: A Feature Module ................................................................................................................................ 122 Chapter 31: Bootstrap Empty module in angular 2 ................................................................................. 123 Section 31.1: An empty module Section 31.2: Application Root Module Section 31.3: Bootstrapping your module Section 31.4: A module with networking on the web browser Section 31.5: Static bootstrapping with factory classes ................................................................................................................................. .................................................................................................................... ............................................................................................................... 123 123 123 .............................................................................. 123 ........................................................................................ 124 Chapter 32: Lazy loading a module Section 32.1: Lazy loading example ................................................................................................................ 125 ......................................................................................................................... 125 Chapter 33: Advanced Component Examples ............................................................................................ 127 Section 33.1: Image Picker with Preview Section 33.2: Filter out table values by the input .................................................................................................................. 127 ................................................................................................... 128 Chapter 34: Bypassing Sanitizing for trusted values Section 34.1: Bypassing Sanitizing with pipes (for code re-use) ............................................................................ 130 .......................................................................... 130 Chapter 35: Angular 2 Data Driven Forms .................................................................................................. 133 Section 35.1: Data driven form ................................................................................................................................. 133 ................................................................................................. 135 .................................................................................................. Chapter 36: Angular 2 In Memory Web API Section 36.1: Setting Up Multiple Test API Routes Section 36.2: Basic Setup Chapter 37: Ahead-of-time (AOT) compilation with Angular 2 ......................................................... 137 .......................................................................................................................................... Section 37.1: Why we need compilation, Flow of events compilation and example? Section 37.2: Using AoT Compilation with Angular CLI Section 37.3: Install Angular 2 dependencies with compiler Section 37.4: Add `angularCompilerOptions` to your `tsconfig.json` file Section 37.5: Run ngc, the angular compiler Section 37.6: Modify `main.ts` file to use NgFactory and static platform browser ......................................................................................... ................................................................................. .............................................................. .......................................................................................................... ............................................. ........................................ 137 Chapter 38: CRUD in Angular 2 with Restful API Section 38.1: Read from an Restful API in Angular 2 ....................................................................................... 140 ............................................................................................. Chapter 39: Use native webcomponents in Angular 2 Section 39.1: Include custom elements schema in your module Section 39.2: Use your webcomponent in a template ........................................................................... .......................................................................... 141 .......................................................................................... 141 Chapter 40: Update typings ............................................................................................................................... 142 Section 40.1: Update typings when: typings WARN deprecated .......................................................................... 142 Chapter 41: Mocking @ngrx/Store .................................................................................................................. 143 Section 41.1: Unit Test For Component With Mock Store Section 41.2: Angular 2 - Mock Observable ( service + component ) Section 41.3: Observer Mock Section 41.4: Unit Test For Component Spying On Store Section 41.5: Simple Store .................................................................................................................................... ...................................................................................... ......................................................................................................................................... ...................................................................................... 143 .................................................................. 144 Chapter 42: ngrx ....................................................................................................................................................... 151 Section 42.1: Complete example : Login/logout a user ......................................................................................... 151 Chapter 43: Http Interceptor ............................................................................................................................. 157 Section 43.1: Using our class instead of Angular's Http Section 43.2: Simple Class Extending angular's Http class Section 43.3: Simple HttpClient AuthToken Interceptor (Angular 4.3+) ........................................................................................ ................................................................................... ............................................................... 158 Chapter 44: Animation .......................................................................................................................................... 160 Section 44.1: Transition between null states Section 44.2: Animating between multiple states ........................................................................................................... 160 .................................................................................................. 160 Chapter 45: Zone.js ................................................................................................................................................. 162 Section 45.1: Getting reference to NgZone ............................................................................................................. 162 135 135 138 138 138 138 139 140 141 147 147 148 157 157 Section 45.2: Using NgZone to do multiple HTTP requests before showing the data ...................................... 162 Chapter 46: Angular 2 Animations .................................................................................................................. 163 Section 46.1: Basic Animation - Transitions an element between two states driven by a model attribute ............................................................................................................................................................................. 163 Chapter 47: Create an Angular 2+ NPM package ................................................................................... 165 Section 47.1: Simplest package ................................................................................................................................ 165 Chapter 48: Angular 2 CanActivate Section 48.1: Angular 2 CanActivate Chapter 49: Angular 2 - Protractor ................................................................................................................ 169 ........................................................................................................................ ................................................................................................................. Section 49.1: Angular 2 Protractor - Installation Section 49.2: Testing Navbar routing with Protractor .................................................................................................... ........................................................................................... 171 Chapter 50: Example for routes such as /route/subroute for static urls .................................. 173 Section 50.1: Basic route example with sub routes tree ........................................................................................ 173 Chapter 51: Angular 2 Input() output() .......................................................................................................... 174 Section 51.1: Input() Section 51.2: Simple example of Input Properties .................................................................................................................................................... 174 .................................................................................................. 175 Chapter 52: Angular-cli .......................................................................................................................................... 176 Section 52.1: New project with scss/sass as stylesheet Section 52.2: Set yarn as default package manager for @angular/cli Section 52.3: Create empty Angular 2 application with angular-cli Section 52.4: Generating Components, Directives, Pipes and Services Section 52.5: Adding 3rd party libs Section 52.6: build with angular-cli ........................................................................................ 176 .............................................................. 176 .................................................................... ............................................................... .......................................................................................................................... .......................................................................................................................... 169 170 170 176 177 177 177 Chapter 53: Angular 2 Change detection and manual triggering ................................................... 178 Section 53.1: Basic example ...................................................................................................................................... 178 Chapter 54: Angular 2 Databinding ................................................................................................................ 180 Section 54.1: @Input() ............................................................................................................................................... 180 Chapter 55: Brute Force Upgrading ............................................................................................................... 182 Section 55.1: Scaolding a New Angular CLI Project ............................................................................................. 182 Chapter 56: Angular 2 provide external data to App before bootstrap ..................................... 183 Section 56.1: Via Dependency Injection ................................................................................................................... 183 Chapter 57: custom ngx-bootstrap datepicker + input ........................................................................ 184 Section 57.1: custom ngx-bootstrap datepicker ..................................................................................................... 184 Chapter 58: Using third party libraries like jQuery in Angular 2 ...................................................... 187 Section 58.1: Configuration using angular-cli Section 58.2: Using jQuery in Angular 2.x components ......................................................................................................... 187 ........................................................................................ 187 Chapter 59: Configuring ASP.net Core application to work with Angular 2 and TypeScript .................................................................................................................................................................... 188 Section 59.1: Asp.Net Core + Angular 2 + Gulp Section 59.2: [Seed] Asp.Net Core + Angular 2 + Gulp on Visual Studio 2017 Section 59.3: MVC <-> Angular 2 ....................................................................................................... 188 .................................................... 192 ............................................................................................................................. 192 Chapter 60: Angular 2 using webpack Section 60.1: Angular 2 webpack setup Chapter 61: Angular material design ........................................................................................................... 194 .................................................................................................................. .............................................................................................................. Section 61.1: Md2Accordion and Md2Collapse Section 61.2: Md2Select Section 61.3: Md2Toast ............................................................................................................................................. ............................................................................................................................................. ....................................................................................................... 198 194 198 198 199 Section 61.4: Md2Datepicker Section 61.5: Md2Tooltip .................................................................................................................................... 199 ........................................................................................................................................... 199 Chapter 62: Dropzone in Angular 2 ................................................................................................................. 200 Section 62.1: Dropzone Chapter 63: angular redux Section 63.1: Basic Section 63.2: Get current state Section 63.3: change state Section 63.4: Add redux chrome tool .............................................................................................................................................. 200 ................................................................................................................................... 201 ..................................................................................................................................................... ................................................................................................................................. ....................................................................................................................................... ...................................................................................................................... 203 Chapter 64: Creating an Angular npm library Section 64.1: Minimal module with service class .......................................................................................... 204 .................................................................................................... 204 Chapter 65: Barrel .................................................................................................................................................... 208 Section 65.1: Using Barrel ......................................................................................................................................... 208 Chapter 66: Testing an Angular 2 App ........................................................................................................... 209 Section 66.1: Setting up testing with Gulp, Webpack, Karma and Jasmine Section 66.2: Installing the Jasmine testing framework Section 66.3: Testing Http Service Section 66.4: Testing Angular Components - Basic ........................................................................................................................... ............................................................................................... ........................................................ 209 ....................................................................................... 201 202 202 213 213 215 Chapter 67: angular-cli test coverage .......................................................................................................... 217 Section 67.1: A simple angular-cli command base test coverage Section 67.2: Detailed individual component base graphical test coverage reporting ....................................................................... 217 ..................................... 217 Chapter 68: Debugging Angular 2 TypeScript application using Visual Studio Code ........... 219 Section 68.1: Launch.json setup for you workspace .............................................................................................. 219 Chapter 69: unit testing Section 69.1: Basic unit test ......................................................................................................................................... 221 ....................................................................................................................................... 221 Credits ............................................................................................................................................................................ 222 You may also like ...................................................................................................................................................... 225 About Please feel free to share this PDF with anyone for free, latest version of this book can be downloaded from: https://goalkicker.com/Angular2Book This Angular 2+ Notes for Professionals book is compiled from Stack Overflow Documentation, the content is written by the beautiful people at Stack Overflow. Text content is released under Creative Commons BY-SA, see credits at the end of this book whom contributed to the various chapters. Images may be copyright of their respective owners unless otherwise specified This is an unofficial free book created for educational purposes and is not affiliated with official Angular 2+ group(s) or company(s) nor Stack Overflow. All trademarks and registered trademarks are the property of their respective company owners The information presented in this book is not guaranteed to be correct nor accurate, use at your own risk Please send feedback and corrections to web@petercv.com GoalKicker.com – Angular 2+ Notes for Professionals 1 Chapter 1: Getting started with Angular 2+ Version Release Date 6.0.0 2018-05-04 6.0.0-rc.5 2018-04-14 6.0.0-beta.0 2018-01-25 5.0.0 4.3.3 4.3.2 4.3.1 4.3.0 4.2.0 4.1.0 4.0.0 2.3.0 2.2.0 2.1.0 2.0.2 2.0.1 2.0.0 2017-11-01 2017-08-02 2017-07-26 2017-07-19 2017-07-14 2017-06-08 2017-04-26 2017-03-23 2016-12-08 2016-11-14 2016-10-13 2016-10-05 2016-09-23 2016-09-14 2.0.0-rc.7 2016-09-13 2.0.0-rc.6 2016-08-31 2.0.0-rc.5 2016-08-09 2.0.0-rc.4 2016-06-30 2.0.0-rc.3 2016-06-21 2.0.0-rc.2 2016-06-15 2.0.0-rc.1 2016-05-03 2.0.0-rc.0 2016-05-02 Section 1.1: Getting started with Angular 2 with node.js/expressjs backend (http example included) We will create a simple "Hello World!" app with Angular2 2.4.1 (@NgModule change) with a node.js (expressjs) backend. Prerequisites Node.js v4.x.x or higher npm v3.x.x or higher or yarn Then run npm install -g typescript or yarn global add typescriptto install typescript globally Roadmap Step 1 Create a new folder (and the root dir of our back-end) for our app. Let's call it Angular2-express. command line: GoalKicker.com – Angular 2+ Notes for Professionals 2 mkdir Angular2-express cd Angular2-express Step2 Create the package.json (for dependencies) and app.js (for bootstrapping) for our node.js app. package.json: { "name": "Angular2-express", "version": "1.0.0", "description": "", "scripts": { "start": "node app.js" }, "author": "", "license": "ISC", "dependencies": { "body-parser": "^1.13.3", "express": "^4.13.3" } } app.js: var express = require('express'); var app = express(); var server = require('http').Server(app); var bodyParser = require('body-parser'); server.listen(process.env.PORT || 9999, function(){ console.log("Server connected. Listening on port: " + (process.env.PORT || 9999)); }); app.use(bodyParser.json()); app.use(bodyParser.urlencoded({extended: true}) ); app.use( express.static(__dirname + '/front' ) ); app.get('/test', function(req,res){ //example http request receiver return res.send(myTestVar); }); //send the index.html on every page refresh and let angular handle the routing app.get('/*', function(req, res, next) { console.log("Reloading"); res.sendFile('index.html', { root: __dirname }); }); Then run an npm install or yarn to install the dependencies. Now our back-end structure is complete. Let's move on to the front-end. Step3 Our front-end should be in a folder named front inside our Angular2-express folder. command line: GoalKicker.com – Angular 2+ Notes for Professionals 3 mkdir front cd front Just like we did with our back-end our front-end needs the dependency files too. Let's go ahead and create the following files: package.json, systemjs.config.js, tsconfig.json package.json: { "name": "Angular2-express", "version": "1.0.0", "scripts": { "tsc": "tsc", "tsc:w": "tsc -w" }, "licenses": [ { "type": "MIT", "url": "https://github.com/angular/angular.io/blob/master/LICENSE" } ], "dependencies": { "@angular/common": "~2.4.1", "@angular/compiler": "~2.4.1", "@angular/compiler-cli": "^2.4.1", "@angular/core": "~2.4.1", "@angular/forms": "~2.4.1", "@angular/http": "~2.4.1", "@angular/platform-browser": "~2.4.1", "@angular/platform-browser-dynamic": "~2.4.1", "@angular/platform-server": "^2.4.1", "@angular/router": "~3.4.0", "core-js": "^2.4.1", "reflect-metadata": "^0.1.8", "rxjs": "^5.0.2", "systemjs": "0.19.40", "zone.js": "^0.7.4" }, "devDependencies": { "@types/core-js": "^0.9.34", "@types/node": "^6.0.45", "typescript": "2.0.2" } } systemjs.config.js: /** * System configuration for Angular samples * Adjust as necessary for your application needs. */ (function (global) { System.config({ defaultJSExtensions:true, paths: { // paths serve as alias 'npm:': 'node_modules/' }, // map tells the System loader where to look for things map: { GoalKicker.com – Angular 2+ Notes for Professionals 4 // our app is within the app folder app: 'app', // angular bundles '@angular/core': 'npm:@angular/core/bundles/core.umd.js', '@angular/common': 'npm:@angular/common/bundles/common.umd.js', '@angular/compiler': 'npm:@angular/compiler/bundles/compiler.umd.js', '@angular/platform-browser': 'npm:@angular/platform-browser/bundles/platform-browser.umd.js', '@angular/platform-browser-dynamic': 'npm:@angular/platform-browser-dynamic/bundles/platform- browser-dynamic.umd.js', '@angular/http': 'npm:@angular/http/bundles/http.umd.js', '@angular/router': 'npm:@angular/router/bundles/router.umd.js', '@angular/forms': 'npm:@angular/forms/bundles/forms.umd.js', // other libraries 'rxjs': 'npm:rxjs', 'angular-in-memory-web-api': 'npm:angular-in-memory-web-api', }, // packages tells the System loader how to load when no filename and/or no extension packages: { app: { main: './main.js', defaultExtension: 'js' }, rxjs: { defaultExtension: 'js' } } }); })(this); tsconfig.json: { "compilerOptions": { "target": "es5", "module": "commonjs", "moduleResolution": "node", "sourceMap": true, "emitDecoratorMetadata": true, "experimentalDecorators": true, "removeComments": false, "noImplicitAny": false }, "compileOnSave": true, "exclude": [ "node_modules/*" ] } Then run an npm install or yarn to install the dependencies. Now that our dependency files are complete. Let's move on to our index.html: index.html: Angular2-express GoalKicker.com – Angular 2+ Notes for Professionals 5 Loading... Now we're ready to create our first component. Create a folder named app inside our front folder. command line: mkdir app cd app Let's make the following files named main.ts, app.module.ts, app.component.ts main.ts: import { platformBrowserDynamic } from '@angular/platform-browser-dynamic'; import { AppModule } from './app.module'; const platform = platformBrowserDynamic(); platform.bootstrapModule(AppModule); app.module.ts: import { NgModule } from '@angular/core'; import { BrowserModule } from '@angular/platform-browser'; import { HttpModule } from "@angular/http"; import { AppComponent } from './app.component'; @NgModule({ imports: [ BrowserModule, HttpModule ], declarations: [ AppComponent ], providers:[ ], bootstrap: [ AppComponent ] }) export class AppModule {} app.component.ts: GoalKicker.com – Angular 2+ Notes for Professionals 6 import { Component } from '@angular/core'; import { Http } from '@angular/http'; @Component({ selector: 'my-app', template: 'Hello World!', providers: [] }) export class AppComponent { constructor(private http: Http){ //http get example this.http.get('/test') .subscribe((res)=>{ console.log(res); }); } } After this, compile the typescript files to javascript files. Go 2 levels up from the current dir (inside Angular2-express folder) and run the command below. command line: cd .. cd .. tsc -p front Our folder structure should look like: Angular2-express ├── app.js ├── node_modules ├── package.json ├── front │ ├── package.json │ ├── index.html │ ├── node_modules │ ├── systemjs.config.js │ ├── tsconfig.json │ ├── app │ │ ├── app.component.ts │ │ ├── app.component.js.map │ │ ├── app.component.js │ │ ├── app.module.ts │ │ ├── app.module.js.map │ │ ├── app.module.js │ │ ├── main.ts │ │ ├── main.js.map │ │ ├── main.js Finally, inside Angular2-express folder, run node app.js command in the command line. Open your favorite browser and check localhost:9999 to see your app. Section 1.2: Install angular2 with angular-cli This example is a quick setup of Angular 2 and how to generate a quick example project. GoalKicker.com – Angular 2+ Notes for Professionals 7 Prerequisites: Node.js v4 or greater. npm v3 or greater or yarn. Open a terminal and run the commands one by one: npm install -g @angular/cli or yarn global add @angular/cli depending on your choice of package manager. The previous command installs @angular/cli globally, adding the executable ng to PATH. To setup a new project Navigate with the terminal to a folder where you want to set up the new project. Run the commands: ng new PROJECT_NAME cd PROJECT_NAME ng serve That is it, you now have a simple example project made with Angular 2. You can now navigate to the link displayed in terminal and see what it is running. To add to an existing project Navigate to the root of your current project. Run the command: ng init This will add the necessary scaffolding to your project. The files will be created in the current directory so be sure to run this in an empty directory. Running The Project Locally In order to see and interact with your application while it's running in the browser you must start a local development server hosting the files for your project. ng serve If the server started successfully it should display an address at which the server is running. Usually is this: http://localhost:4200 Out of the box this local development server is hooked up with Hot Module Reloading, so any changes to the html, typescript, or css, will trigger the browser to be automatically reloaded (but can be disabled if desired). GoalKicker.com – Angular 2+ Notes for Professionals 8 Generating Components, Directives, Pipes and Services The ng generate (or simply ng g ) command allows you to automatically generate Angular components: # The command below will generate a component in the folder you are currently at ng generate component my-generated-component # Using the alias (same outcome as above) ng g component my-generated-component There are several possible types of scaffolds angular-cli can generate: Scaffold Type Module Usage ng g module my-new-module Component ng g component my-new-component Directive ng g directive my-new-directive Pipe Service Class Interface Enum ng g pipe my-new-pipe ng g service my-new-service ng g class my-new-class ng g interface my-new-interface ng g enum my-new-enum You can also replace the type name by its first letter. For example: ng g m my-new-module to generate a new module or ng g c my-new-component to create a component. Building/Bundling When you are all finished building your Angular 2 web app and you would like to install it on a web server like Apache Tomcat, all you need to do is run the build command either with or without the production flag set. Production will minifiy the code and optimize for a production setting. ng build or ng build --prod Then look in the projects root directory for a /dist folder, which contains the build. If you'd like the benefits of a smaller production bundle, you can also use Ahead-of-Time template compilation, which removes the template compiler from the final build: ng build --prod --aot Unit Testing Angular 2 provides built-in unit testing, and every item created by angular-cli generates a basic unit test, that can be expanded. The unit tests are written using jasmine, and executed through Karma. In order to start testing execute the following command: ng test GoalKicker.com – Angular 2+ Notes for Professionals 9 This command will execute all the tests in the project, and will re-execute them every time a source file changes, whether it is a test or code from the application. For more info also visit: angular-cli github page Section 1.3: Getting started with Angular 2 without angular-cli Angular 2.0.0-rc.4 In this example we'll create a "Hello World!" app with only one root component (AppComponent) for the sake of simplicity. Prerequisites: Node.js v5 or later npm v3 or later Note: You can check versions by running node -v and npm -v in the console/terminal. Step 1 Create and enter a new folder for your project. Let's call it angular2-example. mkdir angular2-example cd angular2-example Step 2 Before we start writing our app code, we'll add the 4 files provided below: package.json, tsconfig.json, typings.json, and systemjs.config.js. Disclaimer: The same files can be found in the Official 5 Minute Quickstart. package.json - Allows us to download all dependencies with npm and provides simple script execution to make life easier for simple projects. (You should consider using something like Gulp in the future to automate tasks). { "name": "angular2-example", "version": "1.0.0", "scripts": { "start": "tsc && concurrently \"npm run tsc:w\" \"npm run lite\" ", "lite": "lite-server", "postinstall": "typings install", "tsc": "tsc", "tsc:w": "tsc -w", "typings": "typings" }, "license": "ISC", "dependencies": { "@angular/common": "2.0.0-rc.4", "@angular/compiler": "2.0.0-rc.4", "@angular/core": "2.0.0-rc.4", "@angular/forms": "0.2.0", "@angular/http": "2.0.0-rc.4", GoalKicker.com – Angular 2+ Notes for Professionals 10 "@angular/platform-browser": "2.0.0-rc.4", "@angular/platform-browser-dynamic": "2.0.0-rc.4", "@angular/router": "3.0.0-beta.1", "@angular/router-deprecated": "2.0.0-rc.2", "@angular/upgrade": "2.0.0-rc.4", "systemjs": "0.19.27", "core-js": "^2.4.0", "reflect-metadata": "^0.1.3", "rxjs": "5.0.0-beta.6", "zone.js": "^0.6.12", "angular2-in-memory-web-api": "0.0.14", "bootstrap": "^3.3.6" }, "devDependencies": { "concurrently": "^2.0.0", "lite-server": "^2.2.0", "typescript": "^1.8.10", "typings":"^1.0.4" } } tsconfig.json - Configures the TypeScript transpiler. { "compilerOptions": { "target": "es5", "module": "commonjs", "moduleResolution": "node", "sourceMap": true, "emitDecoratorMetadata": true, "experimentalDecorators": true, "removeComments": false, "noImplicitAny": false } } typings.json - Makes TypeScript recognize libraries we're using. { "globalDependencies": { "core-js": "registry:dt/core-js#0.0.0+20160602141332", "jasmine": "registry:dt/jasmine#2.2.0+20160621224255", "node": "registry:dt/node#6.0.0+20160621231320" } } systemjs.config.js - Configures SystemJS (you can also use webpack). /** * System configuration for Angular 2 samples * Adjust as necessary for your application's needs. */ (function(global) { // map tells the System loader where to look for things var map = { 'app': 'app', // 'dist', '@angular': 'node_modules/@angular', 'angular2-in-memory-web-api': 'node_modules/angular2-in-memory-web-api', 'rxjs': 'node_modules/rxjs' }; GoalKicker.com – Angular 2+ Notes for Professionals 11 // packages tells the System loader how to load when no filename and/or no extension var packages = { 'app': { main: 'main.js', defaultExtension: 'js' }, 'rxjs': { defaultExtension: 'js' }, 'angular2-in-memory-web-api': { main: 'index.js', defaultExtension: 'js' }, }; var ngPackageNames = [ 'common', 'compiler', 'core', 'forms', 'http', 'platform-browser', 'platform-browser-dynamic', 'router', 'router-deprecated', 'upgrade', ]; // Individual files (~300 requests): function packIndex(pkgName) { packages['@angular/'+pkgName] = { main: 'index.js', defaultExtension: 'js' }; } // Bundled (~40 requests): function packUmd(pkgName) { packages['@angular/'+pkgName] = { main: '/bundles/' + pkgName + '.umd.js', defaultExtension: 'js' }; } // Most environments should use UMD; some (Karma) need the individual index files var setPackageConfig = System.packageWithIndex ? packIndex : packUmd; // Add package entries for angular packages ngPackageNames.forEach(setPackageConfig); var config = { map: map, packages: packages }; System.config(config); })(this); Step 3 Let's install the dependencies by typing npm install in the console/terminal. Step 4 Create index.html inside of the angular2-example folder. Angular2 example GoalKicker.com – Angular 2+ Notes for Professionals 12 Your application will be rendered between the my-app tags. However, Angular still doesn't know what to render. To tell it that, we'll define AppComponent. Step 5 Create a subfolder called app where we can define the components and services that make up our app. (In this case, it'll just contain the AppComponent code and main.ts.) mkdir app Step 6 Create the file app/app.component.ts import { Component } from '@angular/core'; @Component({ selector: 'my-app', template: `

{{title}}

  • {{message}}
` }) export class AppComponent { title = "Angular2 example"; messages = [ "Hello World!", "Another string", "Another one" ]; } What's happening? First, we're importing the @Component decorator which we use to give Angular the HTML tag and template for this component. Then, we're creating the class AppComponent with title and messages variables that we can use in the template. Now let's look at that template:

{{title}}

    GoalKicker.com – Angular 2+ Notes for Professionals 13
  • {{message}}
We're displaying the title variable in an h1 tag and then making a list showing each element of the messages array by using the *ngFor directive. For each element in the array, *ngFor creates a message variable that we use within the li element. The result will be:

Angular 2 example

  • Hello World!
  • Another string
  • Another one
Step 7 Now we create a main.ts file, which will be the first file that Angular looks at. Create the file app/main.ts. import { bootstrap } from '@angular/platform-browser-dynamic'; import { AppComponent } from './app.component'; bootstrap(AppComponent); We're importing the bootstrap function and AppComponent class, then using bootstrap to tell Angular which component to use as the root. Step 8 It's time to fire up your first app. Type npm start in your console/terminal. This will run a prepared script from package.json that starts lite-server, opens your app in a browser window, and runs the TypeScript transpiler in watch mode (so .ts files will be transpiled and the browser will refresh when you save changes). What now? Check out the official Angular 2 guide and the other topics on StackOverflow's documentation. You can also edit AppComponent to use external templates, styles or add/edit component variables. You should see your changes immediately after saving files. Section 1.4: Getting through that pesky company proxy If you are attempting to get an Angular2 site running on your Windows work computer at XYZ MegaCorp the chances are that you are having problems getting through the company proxy. There are (at least) two package managers that need to get through the proxy: 1. 2. NPM Typings GoalKicker.com – Angular 2+ Notes for Professionals 14 For NPM you need to add the following lines to the .npmrc file: proxy=http://[DOMAIN]%5C[USER]:[PASS]@[PROXY]:[PROXYPORT]/ https-proxy=http://[DOMAIN]%5C[USER]:[PASS]@[PROXY]:[PROXYPORT]/ For Typings you need to add the following lines to the .typingsrc file: proxy=http://[DOMAIN]%5C[USER]:[PASS]@[PROXY]:[PROXYPORT]/ https-proxy=http://[DOMAIN]%5C[USER]:[PASS]@[PROXY]:[PROXYPORT]/ rejectUnauthorized=false These files probably don't exist yet, so you can create them as blank text files. They can be added to the project root (same place as package.json or you can put them in %HOMEPATH% and they will be available to all your projects. The bit that isn't obvious and is the main reason people think the proxy settings aren't working is the %5C which is the URL encode of the \ to separate the domain and user names. Thanks to Steve Roberts for that one: Using npm behind corporate proxy .pac Section 1.5: Keeping Visual Studios in sync with NPM and NODE Updates Step 1: Locate your download of Node.js, typically it is installed under C:/program files/nodejs Step 2: Open Visual Studios and navigate to "Tools>Options" Step 3: In the options window navigate to "Projects and Solutions>External Web Tools" Step 4: Add new entry with you Node.js file location (C:/program files/nodejs), IMPORTANT use the arrow buttons on menu to move your reference to the top of the list. Step 5: Restart Visual Studios and Run an npm install, against your project, from npm command window GoalKicker.com – Angular 2+ Notes for Professionals 15 Section 1.6: Let's dive into Angular 4! Angular 4 is now available! Actually Angular uses semver since Angular 2, which requires the major number being increased when breaking changes were introduced. The Angular team postponed features that cause breaking changes, which will be released with Angular 4. Angular 3 was skipped to be able to align the version numbers of the core modules, because the Router already had version 3. As per the Angular team, Angular 4 applications are going to be less space consuming and faster than before. They have separated animation package from @angular/core package. If anybody is not using animation package so extra space of code will not end up in the production. The template binding syntax now supports if/else style syntax. Angular 4 is now compatible with most recent version of Typescript 2.1 and 2.2. So, Angular 4 is going to be more exciting. Now I’ll show you how to do setup of Angular 4 in your project. Let’s start Angular setup with three different ways: You can use Angular-CLI (Command Line Interface) , It will install all dependencies for you. You can migrate from Angular 2 to Angular 4. You can use github and clone the Angular4-boilerplate. (It is the easiest one.???? ) Angular Setup using Angular-CLI(command Line Interface). Before You start using Angular-CLI , make sure You have node installed in your machine. Here, I am using node v7.8.0. Now, Open your terminal and type the following command for Angular-CLI. npm install -g @angular/cli or yarn global add @angular/cli depending on the package manager you use. Let’s install Angular 4 using Angular-CLI. ng new Angular4-boilerplate cd Angular4-boilerplate We are all set for Angular 4. Its pretty easy and straightforward method.???? Angular Setup by migrating from Angular 2 to Angular 4 Now Let’s see the second approach. I ll show you how to migrate Angular 2 to Angular 4. For that You need clone any Angular 2 project and update Angular 2 dependencies with the Angular 4 Dependency in your package.json as following: "dependencies": { "@angular/animations": "^4.1.0", "@angular/common": "4.0.2", "@angular/compiler": "4.0.2", "@angular/core": "^4.0.1", "@angular/forms": "4.0.2", "@angular/http": "4.0.2", "@angular/material": "^2.0.0-beta.3", GoalKicker.com – Angular 2+ Notes for Professionals 16 "@angular/platform-browser": "4.0.2", "@angular/platform-browser-dynamic": "4.0.2", "@angular/router": "4.0.2", "typescript": "2.2.2" } These are the main dependencies for Angular 4. Now You can npm install and then npm start to run the application. For reference my package.json. Angular setup from github project Before starting this step make sure you have git installed in your machine. Open your terminal and clone the angular4-boilerplate using below command: git@github.com:CypherTree/angular4-boilerplate.git Then install all dependencies and run it. npm install npm start And you are done with the Angular 4 setup. All the steps are very straightforward so you can opt any of them. Directory Structure of the angular4-boilerplate Angular4-boilerplate -karma -node_modules -src -mocks -models -loginform.ts -index.ts -modules -app -app.component.ts -app.component.html -login -login.component.ts -login.component.html -login.component.css -widget -widget.component.ts -widget.component.html -widget.component.css ........ -services -login.service.ts -rest.service.ts -app.routing.module.ts -app.module.ts -bootstrap.ts -index.html -vendor.ts -typings -webpack -package.json -tsconfig.json GoalKicker.com – Angular 2+ Notes for Professionals 17 -tslint.json -typings.json Basic understanding for Directory structure: All the code resides in src folder. mocks folder is for mock data that is used in testing purpose. model folder contains the class and interface that used in component. modules folder contains list of components such as app, login, widget etc. All component contains typescript, html and css file. index.ts is for exporting all the class. services folder contains list of services used in application. I have separated rest service and different component service. In rest service contains different http methods. Login service works as mediator between login component and rest service. app.routing.ts file describes all possible routes for the application. app.module.ts describes app module as root component. bootstrap.ts will run the whole application. webpack folder contains webpack configuration file. package.json file is for all list of dependencies. karma contains karma configuration for unit test. node_modules contains list of package bundles. Lets start with Login component. In login.component.html
Dreamfactory - Addressbook 2.0
In login.component.ts import { Component } from '@angular/core'; import { Router } from '@angular/router'; import { Form, FormGroup } from '@angular/forms'; import { LoginForm } from '../../models'; import { LoginService } from '../../services/login.service'; @Component({ selector: 'login', template: require('./login.component.html'), styles: [require('./login.component.css')] }) export class LoginComponent { constructor(private loginService: LoginService, private router: Router, form: LoginForm) { } GoalKicker.com – Angular 2+ Notes for Professionals 18 getLogin(form: LoginForm): void { let username = form.email; let password = form.password; this.loginService.getAuthenticate(form).subscribe(() => { this.router.navigate(['/calender']); }); } } We need to export this component to in index.ts. export * from './login/login.component'; we need to set routes for login in app.routes.ts const appRoutes: Routes = [ { path: 'login', component: LoginComponent }, ........ { path: '', pathMatch: 'full', redirectTo: '/login' } ]; In root component, app.module.ts file you just need to import that component. ..... import { LoginComponent } from './modules'; ...... @NgModule({ bootstrap: [AppComponent], declarations: [ LoginComponent ..... ..... ] ..... }) export class AppModule { } and after that npm install and npm start. Here, you go! You can check login screen in your localhost. In case of any difficulty, You can refer the angular4-boilerplate. Basically I can feel less building package and more faster response with Angular 4 application and Although I found Exactly similar to Angular 2 in coding. GoalKicker.com – Angular 2+ Notes for Professionals 19 Chapter 2: Components Angular components are elements composed by a template that will render your application. Section 2.1: A simple component To create a component we add @Component decorator in a class passing some parameters: providers: Resources that will be injected into the component constructor selector: The query selector that will find the element in the HTML and replace by the component styles: Inline styles. NOTE: DO NOT use this parameter with require, it works on development but when you build the application in production all your styles are lost styleUrls: Array of path to style files template: String that contains your HTML templateUrl: Path to a HTML file There are other parameters you can configure, but the listed ones are what you will use the most. A simple example: import { Component } from '@angular/core'; @Component({ selector: 'app-required', styleUrls: ['required.component.scss'], // template: `This field is required.`, templateUrl: 'required.component.html', }) export class RequiredComponent { } Section 2.2: Templates & Styles Templates are HTML files that may contain logic. You can specify a template in two ways: Passing template as a file path @Component({ templateUrl: 'hero.component.html', }) Passing a template as an inline code @Component({ template: `
My template here
`, }) Templates may contain styles. The styles declared in @Component are different from your application style file, anything applied in the component will be restricted to this scope. For example, say you add: div { background: red; } All divs inside the component will be red, but if you have other components, other divs in your HTML they will not be changed at all. GoalKicker.com – Angular 2+ Notes for Professionals 20 The generated code will look like this: You can add styles to a component in two ways: Passing an array of file paths @Component({ styleUrls: ['hero.component.css'], }) Passing an array of inline codes styles: [ `div { background: lime; }` ] You shouldn't use styles with require as it will not work when you build your application to production. Section 2.3: Testing a Component hero.component.html
hero.component.ts import { FormControl, FormGroup, Validators } from '@angular/forms'; import { Component } from '@angular/core'; @Component({ selector: 'app-hero', templateUrl: 'hero.component.html', }) export class HeroComponent { public form = new FormGroup({ name: new FormControl('', Validators.required), }); submit(event) { console.log(event); console.log(this.form.controls.name.value); } } hero.component.spec.ts import { ComponentFixture, TestBed, async } from '@angular/core/testing'; import { HeroComponent } from './hero.component'; import { ReactiveFormsModule } from '@angular/forms'; describe('HeroComponent', () => { let component: HeroComponent; let fixture: ComponentFixture; beforeEach(async(() => { GoalKicker.com – Angular 2+ Notes for Professionals 21 TestBed.configureTestingModule({ declarations: [HeroComponent], imports: [ReactiveFormsModule], }).compileComponents(); fixture = TestBed.createComponent(HeroComponent); component = fixture.componentInstance; fixture.detectChanges(); })); it('should be created', () => { expect(component).toBeTruthy(); }); it('should log hero name in the console when user submit form', async(() => { const heroName = 'Saitama'; const element = fixture.debugElement.nativeElement.querySelector('form'); spyOn(console, 'log').and.callThrough(); component.form.controls['name'].setValue(heroName); element.querySelector('button').click(); fixture.whenStable().then(() => { fixture.detectChanges(); expect(console.log).toHaveBeenCalledWith(heroName); }); })); it('should validate name field as required', () => { component.form.controls['name'].setValue(''); expect(component.form.invalid).toBeTruthy(); }); }); Section 2.4: Nesting components Components will render in their respective selector, so you can use that to nest components. If you have a component that shows a message: import { Component, Input } from '@angular/core'; @Component({ selector: 'app-required', template: `{{name}} is required.` }) export class RequiredComponent { @Input() public name: String = ''; } You can use it inside another component using app-required (this component's selector): import { Component, Input } from '@angular/core'; @Component({ selector: 'app-sample', template: ` GoalKicker.com – Angular 2+ Notes for Professionals 22 ` }) export class RequiredComponent { @Input() public name: String = ''; } GoalKicker.com – Angular 2+ Notes for Professionals 23 Chapter 3: Component interactions Name Value pageCount Used to tell number of pages to be created to the child component. pageNumberClicked Name of output variable in the child component. pageChanged Function at parent component that listening for child components output. Section 3.1: Pass data from parent to child with input binding HeroChildComponent has two input properties, typically adorned with @Input decorations. import { Component, Input } from '@angular/core'; import { Hero } from './hero'; @Component({ selector: 'hero-child', template: `

{{hero.name}} says:

I, {{hero.name}}, am at your service, {{masterName}}.

` }) export class HeroChildComponent { @Input() hero: Hero; @Input('master') masterName: string; } Intercept input property changes with a setter Use an input property setter to intercept and act upon a value from the parent. The setter of the name input property in the child NameChildComponent trims the whitespace from a name and replaces an empty value with default text. import { Component, Input } from '@angular/core'; @Component({ selector: 'name-child', template: '

"{{name}}"

' }) export class NameChildComponent { private _name = ''; @Input() set name(name: string) { this._name = (name && name.trim()) || ''; } get name(): string { return this._name; } } Here's the NameParentComponent demonstrating name variations including a name with all spaces: import { Component } from '@angular/core'; @Component({ selector: 'name-parent', template: `

Master controls {{names.length}} names

` }) export class NameParentComponent { GoalKicker.com – Angular 2+ Notes for Professionals 24 // Displays 'Mr. IQ', '', 'Bombasto' names = ['Mr. IQ', ' ', ' Bombasto ']; } Parent listens for child event The child component exposes an EventEmitter property with which it emits events when something happens. The parent binds to that event property and reacts to those events. The child's EventEmitter property is an output property, typically adorned with an @Output decoration as seen in this VoterComponent: import { Component, EventEmitter, Input, Output } from '@angular/core'; @Component({ selector: 'my-voter', template: `

{{name}}

` }) export class VoterComponent { @Input() name: string; @Output() onVoted = new EventEmitter(); voted = false; vote(agreed: boolean) { this.onVoted.emit(agreed); this.voted = true; } } Clicking a button triggers emission of a true or false (the boolean payload). The parent VoteTakerComponent binds an event handler (onVoted) that responds to the child event payload ($event) and updates a counter. import { Component } from '@angular/core'; @Component({ selector: 'vote-taker', template: `

Should mankind colonize the Universe?

Agree: {{agreed}}, Disagree: {{disagreed}}

` }) export class VoteTakerComponent { agreed = 0; disagreed = 0; voters = ['Mr. IQ', 'Ms. Universe', 'Bombasto']; onVoted(agreed: boolean) { agreed ? this.agreed++ : this.disagreed++; } } Parent interacts with child via local variable GoalKicker.com – Angular 2+ Notes for Professionals 25 A parent component cannot use data binding to read child properties or invoke child methods. We can do both by creating a template reference variable for the child element and then reference that variable within the parent template as seen in the following example. We have a child CountdownTimerComponent that repeatedly counts down to zero and launches a rocket. It has start and stop methods that control the clock and it displays a countdown status message in its own template. import { Component, OnDestroy, OnInit } from '@angular/core'; @Component({ selector: 'countdown-timer', template: '

{{message}}

' }) export class CountdownTimerComponent implements OnInit, OnDestroy { intervalId = 0; message = ''; seconds = 11; clearTimer() { clearInterval(this.intervalId); } ngOnInit() { this.start(); } ngOnDestroy() { this.clearTimer(); } start() { this.countDown(); } stop() { this.clearTimer(); this.message = `Holding at T-${this.seconds} seconds`; } private countDown() { this.clearTimer(); this.intervalId = window.setInterval(() => { this.seconds -= 1; if (this.seconds === 0) { this.message = 'Blast off!'; } else { if (this.seconds < 0) { this.seconds = 10; } // reset this.message = `T-${this.seconds} seconds and counting`; } }, 1000); } } Let's see the CountdownLocalVarParentComponent that hosts the timer component. import { Component } from '@angular/core'; import { CountdownTimerComponent } from './countdown-timer.component'; @Component({ selector: 'countdown-parent-lv', template: `

Countdown to Liftoff (via local variable)

{{timer.seconds}}
`, styleUrls: ['demo.css'] }) export class CountdownLocalVarParentComponent { } The parent component cannot data bind to the child's start and stop methods nor to its seconds property. We can place a local variable (#timer) on the tag () representing the child component. That gives us a reference to the child component itself and the ability to access any of its properties or methods from within the parent GoalKicker.com – Angular 2+ Notes for Professionals 26 template. In this example, we wire parent buttons to the child's start and stop and use interpolation to display the child's seconds property. Here we see the parent and child working together. Parent calls a ViewChild The local variable approach is simple and easy. But it is limited because the parent-child wiring must be done entirely within the parent template. The parent component itself has no access to the child. We can't use the local variable technique if an instance of the parent component class must read or write child component values or must call child component methods. When the parent component class requires that kind of access, we inject the child component into the parent as a ViewChild. We'll illustrate this technique with the same Countdown Timer example. We won't change its appearance or behavior. The child CountdownTimerComponent is the same as well. We are switching from the local variable to the ViewChild technique solely for the purpose of demonstration. Here is the parent, CountdownViewChildParentComponent: import { AfterViewInit, ViewChild } from '@angular/core'; import { Component } from '@angular/core'; import { CountdownTimerComponent } from './countdown-timer.component'; @Component({ selector: 'countdown-parent-vc', template: `

Countdown to Liftoff (via ViewChild)

{{ seconds() }}
`, styleUrls: ['demo.css'] }) export class CountdownViewChildParentComponent implements AfterViewInit { @ViewChild(CountdownTimerComponent) private timerComponent: CountdownTimerComponent; seconds() { return 0; } ngAfterViewInit() { // Redefine `seconds()` to get from the `CountdownTimerComponent.seconds` ... // but wait a tick first to avoid one-time devMode // unidirectional-data-flow-violation error setTimeout(() => this.seconds = () => this.timerComponent.seconds, 0); } start() { this.timerComponent.start(); } stop() { this.timerComponent.stop(); } } It takes a bit more work to get the child view into the parent component class. We import references to the ViewChild decorator and the AfterViewInit lifecycle hook. We inject the child CountdownTimerComponent into the private timerComponent property via the @ViewChild property decoration. GoalKicker.com – Angular 2+ Notes for Professionals 27 The #timer local variable is gone from the component metadata. Instead we bind the buttons to the parent component's own start and stop methods and present the ticking seconds in an interpolation around the parent component's seconds method. These methods access the injected timer component directly. The ngAfterViewInit lifecycle hook is an important wrinkle. The timer component isn't available until after Angular displays the parent view. So we display 0 seconds initially. Then Angular calls the ngAfterViewInit lifecycle hook at which time it is too late to update the parent view's display of the countdown seconds. Angular's unidirectional data flow rule prevents us from updating the parent view's in the same cycle. We have to wait one turn before we can display the seconds. We use setTimeout to wait one tick and then revise the seconds method so that it takes future values from the timer component. Parent and children communicate via a service A parent component and its children share a service whose interface enables bi-directional communication within the family. The scope of the service instance is the parent component and its children. Components outside this component subtree have no access to the service or their communications. This MissionService connects the MissionControlComponent to multiple AstronautComponent children. import { Injectable } from '@angular/core'; import { Subject } from 'rxjs/Subject'; @Injectable() export class MissionService { // Observable string sources private missionAnnouncedSource = new Subject(); private missionConfirmedSource = new Subject(); // Observable string streams missionAnnounced$ = this.missionAnnouncedSource.asObservable(); missionConfirmed$ = this.missionConfirmedSource.asObservable(); // Service message commands announceMission(mission: string) { this.missionAnnouncedSource.next(mission); } confirmMission(astronaut: string) { this.missionConfirmedSource.next(astronaut); } } The MissionControlComponent both provides the instance of the service that it shares with its children (through the providers metadata array) and injects that instance into itself through its constructor: import { Component } from '@angular/core'; import { MissionService } from './mission.service'; @Component({ selector: 'mission-control', template: `

Mission Control

GoalKicker.com – Angular 2+ Notes for Professionals 28

History

  • {{event}}
`, providers: [MissionService] }) export class MissionControlComponent { astronauts = ['Lovell', 'Swigert', 'Haise']; history: string[] = []; missions = ['Fly to the moon!', 'Fly to mars!', 'Fly to Vegas!']; nextMission = 0; constructor(private missionService: MissionService) { missionService.missionConfirmed$.subscribe( astronaut => { this.history.push(`${astronaut} confirmed the mission`); }); } announce() { let mission = this.missions[this.nextMission++]; this.missionService.announceMission(mission); this.history.push(`Mission "${mission}" announced`); if (this.nextMission >= this.missions.length) { this.nextMission = 0; } } } The AstronautComponent also injects the service in its constructor. Each AstronautComponent is a child of the MissionControlComponent and therefore receives its parent's service instance: import { Component, Input, OnDestroy } from '@angular/core'; import { MissionService } from './mission.service'; import { Subscription } from 'rxjs/Subscription'; @Component({ selector: 'my-astronaut', template: `

{{astronaut}}: {{mission}}

` }) export class AstronautComponent implements OnDestroy { @Input() astronaut: string; mission = ''; confirmed = false; announced = false; subscription: Subscription; constructor(private missionService: MissionService) { this.subscription = missionService.missionAnnounced$.subscribe( mission => { this.mission = mission; this.announced = true; this.confirmed = false; }); } GoalKicker.com – Angular 2+ Notes for Professionals 29 confirm() { this.confirmed = true; this.missionService.confirmMission(this.astronaut); } ngOnDestroy() { // prevent memory leak when component destroyed this.subscription.unsubscribe(); } } Notice that we capture the subscription and unsubscribe when the AstronautComponent is destroyed. This is a memory-leak guard step. There is no actual risk in this app because the lifetime of a AstronautComponent is the same as the lifetime of the app itself. That would not always be true in a more complex application. We do not add this guard to the MissionControlComponent because, as the parent, it controls the lifetime of the MissionService. The History log demonstrates that messages travel in both directions between the parent MissionControlComponent and the AstronautComponent children, facilitated by the service: Section 3.2: Parent - Child interaction using @Input & @Output properties We have a DataListComponent that shows a data we pull from a service. DataListComponent also has a PagerComponent as it's child. PagerComponent creates page number list based on total number of pages it gets from the DataListComponent. PagerComponent also lets the DataListComponent know when user clicks any page number via Output property. import { Component, NgModule } from '@angular/core'; import { CommonModule } from '@angular/common'; import { DataListService } from './dataList.service'; import { PagerComponent } from './pager.component'; @Component({ selector: 'datalist', template: `
{{person.name}} {{person.surname}}
` }) export class DataListComponent { private personsData = null; private pageCount: number; constructor(private dataListService: DataListService) { var response = this.dataListService.getData(1); //Request first page from the service this.personsData = response.persons; this.pageCount = response.totalCount / 10;//We will show 10 records per page. } pageChanged(pageNumber: number){ var response = this.dataListService.getData(pageNumber); //Request data from the service with new page number this.personsData = response.persons; GoalKicker.com – Angular 2+ Notes for Professionals 30 } } @NgModule({ imports: [CommonModule], exports: [], declarations: [DataListComponent, PagerComponent], providers: [DataListService], }) export class DataListModule { } PagerComponent lists all the page numbers. We set click event on each of them so we can let the parent know about the clicked page number. import { Component, Input, Output, EventEmitter } from '@angular/core'; @Component({ selector: 'pager', template: `
{{page}}
` }) export class PagerComponent { @Input() pageCount: number; @Output() pageNumberClicked = new EventEmitter(); constructor() { } pageClicked(pageNum){ this.pageNumberClicked.emit(pageNum); //Send clicked page number as output } } Section 3.3: Parent - Child interaction using ViewChild Viewchild offers one way interaction from parent to child. There is no feedback or output from child when ViewChild is used. We have a DataListComponent that shows some information. DataListComponent has PagerComponent as it's child. When user makes a search on DataListComponent, it gets a data from a service and ask PagerComponent to refresh paging layout based on new number of pages. import { Component, NgModule, ViewChild } from '@angular/core'; import { CommonModule } from '@angular/common'; import { DataListService } from './dataList.service'; import { PagerComponent } from './pager.component'; @Component({ selector: 'datalist', template: `
{{person.name}} {{person.surname}}
GoalKicker.com – Angular 2+ Notes for Professionals 31 ` }) export class DataListComponent { private personsData = null; private searchText: string; @ViewChild(PagerComponent) private pagerComponent: PagerComponent; constructor(private dataListService: DataListService) {} getData(){ var response = this.dataListService.getData(this.searchText); this.personsData = response.data; this.pagerComponent.setPaging(this.personsData / 10); //Show 10 records per page } } @NgModule({ imports: [CommonModule], exports: [], declarations: [DataListComponent, PagerComponent], providers: [DataListService], }) export class DataListModule { } In this way you can call functions defined at child components. Child component is not available until parent component is rendered. Attempting to access to the child before parents AfterViewInit life cyle hook will cause exception. Section 3.4: Bidirectional parent-child interaction through a service Service that is used for communication: import { Injectable } from '@angular/core'; import { Subject } from 'rxjs/Subject'; @Injectable() export class ComponentCommunicationService { private componentChangeSource = new Subject(); private newDateCreationSource = new Subject(); componentChanged$ = this.componentChangeSource.asObservable(); dateCreated$ = this.newDateCreationSource.asObservable(); refresh() { this.componentChangeSource.next(); } broadcastDate(date: Date) { this.newDateCreationSource.next(date); } } Parent component: GoalKicker.com – Angular 2+ Notes for Professionals 32 import { Component, Inject } from '@angular/core'; import { ComponentCommunicationService } from './component-refresh.service'; @Component({ selector: 'parent', template: `

Last date from child received: {{lastDate}}

` }) export class ParentComponent implements OnInit { lastDate: Date; constructor(private communicationService: ComponentCommunicationService) { } ngOnInit() { this.communicationService.dateCreated$.subscribe(newDate => { this.lastDate = newDate; }); } refreshSubsribed() { this.communicationService.refresh(); } } Child component: import { Component, OnInit, Inject } from '@angular/core'; import { ComponentCommunicationService } from './component-refresh.service'; @Component({ selector: 'child-component', template: `

Last refresh from parent: {{lastRefreshed}}

` }) export class ChildComponent implements OnInit { lastRefreshed: Date; constructor(private communicationService: ComponentCommunicationService) { } ngOnInit() { this.communicationService.componentChanged$.subscribe(event => { this.onRefresh(); }); } sendNewDate() { this.communicationService.broadcastDate(new Date()); } onRefresh() { this.lastRefreshed = new Date(); } } AppModule: GoalKicker.com – Angular 2+ Notes for Professionals 33 @NgModule({ declarations: [ ParentComponent, ChildComponent ], providers: [ComponentCommunicationService], bootstrap: [AppComponent] // not included in the example }) export class AppModule {} GoalKicker.com – Angular 2+ Notes for Professionals 34 Chapter 4: Directives Section 4.1: *ngFor form1.component.ts: import { Component } from '@angular/core'; // Defines example component and associated template @Component({ selector: 'example', template: `
{{f}}
` }) // Create a class for all functions, objects, and variables export class ExampleComponent { // Array of fruit to be iterated by *ngFor fruit = ['Apples', 'Oranges', 'Bananas', 'Limes', 'Lemons']; } Output:
Apples
Oranges
Bananas
Limes
Lemons
In its most simple form, *ngFor has two parts : let >variableName of object/array In the case of fruit = ['Apples', 'Oranges', 'Bananas', 'Limes', 'Lemons'];, Apples, Oranges, and so on are the values inside the array fruit. [value]="f" will be equal to each current fruit (f) that *ngFor has iterated over. Unlike AngularJS, Angular2 has not continued with the use of ng-options for The this.myName value of your component will stay in sync with the input value. *: THE ASTERISK Indicates that this directive treats this component as a template and will not draw it as-is. For example, ngFor takes our and stamps it out for each item in items, but it never renders our initial since it’s a template: Other similar directives that work on templates rather than rendered components are *ngIf and *ngSwitch. GoalKicker.com – Angular 2+ Notes for Professionals 41 Chapter 7: Commonly built-in directives and services @angular/common - commonly needed directives and services @angular/core - the angular core framework Section 7.1: Location Class Location is a service that applications can use to interact with a browser's URL. Depending on which LocationStrategy is used, Location will either persist to the URL's path or the URL's hash segment. Location is responsible for normalizing the URL against the application's base href. import {Component} from '@angular/core'; import {Location} from '@angular/common'; @Component({ selector: 'app-component' }) class AppCmp { constructor(_location: Location) { //Changes the browsers URL to the normalized version of the given URL, //and pushes a new item onto the platform's history. _location.go('/foo'); } backClicked() { //Navigates back in the platform's history. this._location.back(); } forwardClicked() { //Navigates forward in the platform's history. this._location.back(); } } Section 7.2: AsyncPipe The async pipe subscribes to an Observable or Promise and returns the latest value it has emitted. When a new value is emitted, the async pipe marks the component to be checked for changes. When the component gets destroyed, the async pipe unsubscribes automatically to avoid potential memory leaks. @Component({ selector: 'async-observable-pipe', template: '
observable|async: Time: {{ time | async }}
' }) export class AsyncObservablePipeComponent { time = new Observable((observer: Subscriber) => { setInterval(() => observer.next(new Date().toString()), 1000); }); } GoalKicker.com – Angular 2+ Notes for Professionals 42 Section 7.3: Displaying current Angular 2 version used in your project To display current version, we can use VERSION from @angular/core package. import { Component, VERSION } from '@angular/core'; @Component({ selector: 'my-app', template: `

Hello {{name}}

Current Version: {{ver}}

`, }) export class AppComponent { name = 'Angular2'; ver = VERSION.full; } Section 7.4: Currency Pipe The currency pipe allows you to work with you data as regular numbers but display it with standard currency formatting (currency symbol, decimal places, etc.) in the view. @Component({ selector: 'currency-pipe', template: `

A: {{myMoney | currency:'USD':false}}

B: {{yourMoney | currency:'USD':true:'4.2-2'}}

` }) export class CurrencyPipeComponent { myMoney: number = 100000.653; yourMoney: number = 5.3495; } The pipe takes three optional parameters: currencyCode: Allows you to specify the ISO 4217 currency code. symbolDisplay: Boolean indicating whether to use the currency symbol digitInfo: Allows you to specify how the decimal places should be displayed. More documentation on the currency pipe: https://angular.io/docs/ts/latest/api/common/index/CurrencyPipe-pipe.html GoalKicker.com – Angular 2+ Notes for Professionals 43 Chapter 8: Directives & components : @Input @Output Section 8.1: Angular 2 @Input and @Output in a nested component A Button directive which accepts an @Input() to specify a click limit until the button gets disabled. The parent component can listen to an event which will be emitted when the click limit is reached via @Output: import { Component, Input, Output, EventEmitter } from '@angular/core'; @Component({ selector: 'limited-button', template: ``, directives: [] }) export class LimitedButton { @Input() clickLimit: number; @Output() limitReached: EventEmitter = new EventEmitter(); disabled: boolean = false; private clickCount: number = 0; onClick() { this.clickCount++; if (this.clickCount === this.clickLimit) { this.disabled = true; this.limitReached.emit(this.clickCount); } } } Parent component which uses the Button directive and alerts a message when the click limit is reached: import { Component } from '@angular/core'; import { LimitedButton } from './limited-button.component'; @Component({ selector: 'my-parent-component', template: ` You can only click me twice `, directives: [LimitedButton] }) export class MyParentComponent { onLimitReached(clickCount: number) { alert('Button disabled after ' + clickCount + ' clicks.'); } } GoalKicker.com – Angular 2+ Notes for Professionals 44 Section 8.2: Input example @input is useful to bind data between components First, import it in your component import { Input } from '@angular/core'; Then, add the input as a property of your component class @Input() car: any; Let's say that the selector of your component is 'car-component', when you call the component, add the attribute 'car' Now your car is accessible as an attribute in your object (this.car) Full Example : 1. car.entity.ts export class CarEntity { constructor(public brand : string, public color : string) { } } 2. car.component.ts import { Component, Input } from '@angular/core'; import {CarEntity} from "./car.entity"; @Component({ selector: 'car-component', template: require('./templates/car.html'), }) export class CarComponent { @Input() car: CarEntity; constructor() { console.log('gros'); } } 3. garage.component.ts import { Component } from '@angular/core'; import {CarEntity} from "./car.entity"; import {CarComponent} from "./car.component"; @Component({ selector: 'garage', template: require('./templates/garage.html'), directives: [CarComponent] }) export class GarageComponent { GoalKicker.com – Angular 2+ Notes for Professionals 45 public cars : Array; constructor() { var carOne : CarEntity = new CarEntity('renault', 'blue'); var carTwo : CarEntity = new CarEntity('fiat', 'green'); var carThree : CarEntity = new CarEntity('citroen', 'yellow'); this.cars = [carOne, carTwo, carThree]; } } 4. garage.html
5. car.html
{{ car.brand }} | {{ car.color }}
Section 8.3: Angular 2 @Input with asynchronous data Sometimes you need to fetch data asynchronously before passing it to a child component to use. If the child component tries to use the data before it has been received, it will throw an error. You can use ngOnChanges to detect changes in a components' @Inputs and wait until they are defined before acting upon them. Parent component with async call to an endpoint import { Component, OnChanges, OnInit } from '@angular/core'; import { Http, Response } from '@angular/http'; import { ChildComponent } from './child.component'; @Component ({ selector : 'parent-component', template : ` ` }) export class ParentComponent { asyncData : any; constructor( private _http : Http ){} ngOnInit () { this._http.get('some.url') .map(this.extractData) .subscribe(this.handleData) .catch(this.handleError); } extractData (res:Response) { let body = res.json(); return body.data || { }; } GoalKicker.com – Angular 2+ Notes for Professionals 46 handleData (data:any) { this.asyncData = data; } handleError (error:any) { console.error(error); } } Child component which has async data as input This child component takes the async data as input. Therefore it must wait for the data to exist before Using it. We use ngOnChanges which fires whenever a component's input changes, check if the data exists and use it if it does. Notice that the template for the child will not show if a property that relies on the data being passed in is not true. import { Component, OnChanges, Input } from '@angular/core'; @Component ({ selector : 'child-component', template : `

Hello child

` }) export class ChildComponent { doesDataExist: boolean = false; @Input('data') data : any; // Runs whenever component @Inputs change ngOnChanges () { // Check if the data exists before using it if (this.data) { this.useData(data); { } // contrived example to assign data to reliesOnData useData (data) { this.doesDataExist = true; } } GoalKicker.com – Angular 2+ Notes for Professionals 47 Chapter 9: Attribute directives to aect the value of properties on the host node by using the @HostBinding decorator. Section 9.1: @HostBinding The @HostBinding decorator allows us to programmatically set a property value on the directive's host element. It works similarly to a property binding defined in a template, except it specifically targets the host element. The binding is checked for every change detection cycle, so it can change dynamically if desired. For example, lets say that we want to create a directive for buttons that dynamically adds a class when we press on it. That could look something like: import { Directive, HostBinding, HostListener } from '@angular/core'; @Directive({ selector: '[appButtonPress]' }) export class ButtonPressDirective { @HostBinding('attr.role') role = 'button'; @HostBinding('class.pressed') isPressed: boolean; @HostListener('mousedown') hasPressed() { this.isPressed = true; } @HostListener('mouseup') hasReleased() { this.isPressed = false; } } Notice that for both use cases of @HostBinding we are passing in a string value for which property we want to affect. If we don't supply a string to the decorator, then the name of the class member will be used instead. In the first @HostBinding, we are statically setting the role attribute to button. For the second example, the pressed class will be applied when isPressed is true GoalKicker.com – Angular 2+ Notes for Professionals 48 Chapter 10: How to Use ngif *NgIf: It removes or recreates a part of DOM tree depending on an expression evaluation. It is a structural directive and structural directives alter the layout of the DOM by adding, replacing and removing its elements. Section 10.1: To run a function at the start or end of *ngFor loop Using *ngIf NgFor provides Some values that can be aliased to local variables index -(variable) position of the current item in the iterable starting at 0 first -(boolean) true if the current item is the first item in the iterable last -(boolean) true if the current item is the last item in the iterable even -(boolean) true if the current index is an even number odd -(boolean) true if the current index is an odd number

{{i}}

<-- to show index position

{{note}}

{{anyfunction()}} <-- this lastcall boolean value will be true only if this is last in loop // anyfunction() will run at the end of loop same way we can do at start
Section 10.2: Display a loading message If our component is not ready and waiting for data from server, then we can add loader using *ngIf. Steps: First declare a boolean: loading: boolean = false; Next, in your component add a lifecycle hook called ngOnInit ngOnInit() { this.loading = true; } and after you get complete data from server set you loading boolean to false. this.loading=false; In your html template use *ngIf with the loading property:
Section 10.3: Show Alert Message on a condition

Currently there are more than 2 names!

GoalKicker.com – Angular 2+ Notes for Professionals 49 Section 10.4: Use *ngIf with*ngFor While you are not allowed to use *ngIf and *ngFor in the same div (it will gives an error in the runtime) you can nest the *ngIf in the *ngFor to get the desired behavior. Example 1: General syntax
Example 2: Display elements with even index
{{ item }}
The downside is that an additional outer div element needs to be added. But consider this use case where a div element needs to be iterated (using *ngFor) and also includes a check whether the element need to be removed or not (using *ngIf), but adding an additional div is not preferred. In this case you can use the template tag for the *ngFor: This way adding an additional outer div is not needed and furthermore the