Your first Angular 2 app
Download the seed project and extract it somewhere on your machine. Inside this project, you’ll find a few configuration files, an index.html and an app folder, which includes the source files for our application.
Inside the app folder, we have a couple of TypeScript files: boot.ts, which is the main or starting module of our application, and app.component.ts, which is the root componentof our application. Every Angular 2 app has at least one component, which we call root component.
tsconfig.json is the configuration file TypeScript compiler uses to determine how to transpile our TypeScript code into Javascript.
typings.json is another configuration file for Typescript. When using external Javascript libraries in TypeScript, we need to import a typescript definition file. A type definition file gives us static type checking and IntelliSense for that Javascript library.
Next to that, we have package.json, which is a standard Node package configuration file, where we define the dependencies of our app.
{
"name": "angular2-quickstart",
"version": "1.0.0",
"scripts": {
"start": "concurrent \"npm run tsc:w\" \"npm run lite\" ",
"tsc": "tsc",
"tsc:w": "tsc -w",
"lite": "lite-server",
"typings": "typings",
"postinstall": "typings install"
},
"license": "ISC",
"dependencies": {
"angular2": "2.0.0-beta.7",
"systemjs": "0.19.22",
"es6-promise": "^3.0.2",
"es6-shim": "^0.33.3",
"reflect-metadata": "0.1.2",
"rxjs": "5.0.0-beta.2",
"zone.js": "0.5.15"
},
"devDependencies": {
"concurrently": "^2.0.0",
"lite-server": "^2.1.0",
"typescript": "^1.7.5"
}
}
Now, we need to install these dependencies. So, open up Command Prompt on Windows or Terminal on Mac, and go to the folder where you’ve extracted the seed project. Then, run:
npm install
This is going to take several minutes for the first time, so be patient. If you get several errors, that’s most likely due to administrative privileges. So, on Mac, be sure to add sudo before npm.
Once these dependencies are installed, you’ll see a new folder called node_modules. All our application dependencies will be stored there.
Now, have one more look at package.json. Under the scripts section, we can have a few custom node commands:
"scripts": {
"start": "concurrent \"npm run tsc:w\" \"npm run lite\" ",
"tsc": "tsc",
"tsc:w": "tsc -w",
"lite": "lite-server",
"typings": "typings",
"postinstall": "typings install"
}
The one we’ll be using a lot is start.
"start": "concurrent \"npm run tsc:w\" \"npm run lite\" ",
It’s a shortcut for concurrently running two commands:
- npm run tsc:w: which runs TypeScript compiler in the watch mode. When we save a TypeScript file, TypeScript compiler will automatically detect the changes and transpile our TypeScript code into Javascript. We never have to view or modify these Javascript files. So we code purely in TypeScript.
- npm run lite: this will run the lite web server for our Angular app.
Now, back in the terminal and run the following command from the project folder:
npm start
When the lite web server starts, it’ll launch your default browser navigating tohttp://localhost:3000. This is our first Angular 2.0 app.
What is a component?
A component is one of the most fundamental building blocks in Angular 2 apps. Every app consists of at least one component, which we call the root component. A component can include other components, which we call child components. A real-world app is essentially a tree of components.
But what are these components really? A component is a TypeScript class that encapsulates the template, data and behaviour for a view. So, it’s more accurate to call it a view component. That’s what they’re called in React.
As an example, think of Twitter. If you want to build a similar app in Angular 2, you may model your application components like this:
- app
- navbar
- sidebar
- content
- tweets
- tweet
- tweets
Root component
Open up app/app.component.ts. This is the root component of our app:
import {Component} from 'angular2/core';
@Component({
selector: 'my-app',
template: '<h1>My First Angular 2 App</h1>'
})
export class AppComponent { }
As you see, a component is a TypeScript class decorated with @Component decorator. We use decorators (also called annotations) to add metadata to a class. This@Component decorator tells Angular that AppComponent is a component. Note that these decorators are actually functions. So, here, @Component is called and given an object which includes metadata about AppComponent:
@Component({
selector: 'my-app',
template: '<h1>My First Angular 2 App</h1>'
})
This object has two properties: template, which specifies the markup that should be rendered when this component is used, and selector, which tells Angular where in the DOM it should render this component. This is a CSS selector. So, my-app here represents an element with the name my-app.
When Angular sees an element like that in the DOM, it’ll create an instance ofAppComponent and render it (according to its template) inside that element. Open upindex.html and scroll down a bit. Note the my-app element.
Rendering data
Back in app.component.ts, let’s define a field in this class:
export class AppComponent {
title = "Hello World";
}
So, as I explained earlier, a component encapsulates the template, data and the behaviour for a view. We use fields to store data. Now, let’s render the value of this field in the template. Modify the template as follows:
template: 'Hello {{title}}'
We use double curly braces syntax, called interpolation, to render data.
Now, save the file. Since TypeScript compiler is running in the background, it will re-compile our AppComponent. Our lite web server uses a module called BrowserSync, which automatically refreshes the browser when it detects a change in the source files. So, if you switch back to your browser, you should see the new content.
Handling events
Let’s extend our component and add a button. First, replace the single quote character in the template with backtick. That’s the character to the left of number 1 on your keyboard. By using backtick, we can break up our template into multiple lines and make it more readable.
@Component({
selector: 'my-app',
template: `
<h1>Hello {{title}}</h1>
`
})
Now, add a button and a span to the template:
<h1>Hello {{title}}</h1>
<span><span>
<button>Click me</button>
We want to display a counter on this view. Every time we click the button, the counter will be increased by one. So, first declare a new field in the component:
export class AppComponent {
count = 0;
title = "Hello World";
}
Then, modify the span and use interpolation to render the value of count:
<span>Clicks: {{count}}<span>
Finally, to handle the click event, we need to bind it to a method in our component. When we click the button, the corresponding method in the component will be called.
Change the button declaration as follows:
<button (click)="increaseCount()">Click me</button>
Note the syntax. This is called event binding. So, we put the event name in parentheses and then set to a method in the component.
Now, let’s create this method:
export class AppComponent {
count = 0;
title = "Hello World";
increaseCount(){
this.count++;
}
}
Save the file and switch back to your browser. Click the button a few times and note the counter.
So, in this article, you learned the basics of components in Angular 2.0 apps. A component encapsulates the template, data and behaviour of a view. We used interpolation to render data and event binding to handle events raised from DOM elements.
In the next part, we’ll look at services and dependency injection. If you want to be notified when I publish the next part, subscribe to my blog below.
Good markup: