.l-main-section
p.
As long as you already
have the Dart SDK,
getting started with Angular 2 is simple:
ol
li Depend on the angular2 pub package.
li Create a Dart file that defines (directly or indirectly) a
root component and bootstraps Angular.
li Create an HTML file that uses the root component and points to the Dart file
p.
You can use whichever editor or IDE you like,
or just use the command-line tools that the Dart SDK provides.
See Dart Tools
for more information.
h2#section-install Depend on angular2
p.
To use Angular2 in your app, include angular2 as a dependency in
your app's pubspec.yaml file. For example:
pre.prettyprint.lang-yaml
code.
# pubspec.yaml
name: getting_started
description: Dart version of Angular 2 example, Getting Started
version: 0.0.1
dependencies:
angular2: 2.0.0-alpha.20
browser: any
p.
Run pub get to download the packages your app depends on.
(Dart-savvy editors and IDEs
typically run pub get for you.)
.l-main-section
h2#section-set-up-the-starting-component Write the Dart code
p.
Next to your pubspec.yaml file,
create a web subdirectory containing a Dart file
(main.dart).
Edit main.dart, adding a component class (AppComponent),
configuring it to bind to the <my-app> element,
and creating a top-level main() function that calls
Angular's bootstrap() function.
pre.prettyprint.lang-dart
code.
// web/main.dart
import 'package:angular2/angular2.dart';
import 'package:angular2/src/reflection/reflection.dart' show reflector;
import 'package:angular2/src/reflection/reflection_capabilities.dart' show ReflectionCapabilities;
@Component(
selector: 'my-app'
)
@View(
template: '<h1>My first Angular 2 App</h1>'
)
class AppComponent {
}
main() {
reflector.reflectionCapabilities = new ReflectionCapabilities();
bootstrap(AppComponent);
}
.l-main-section
h2#section-create-an-entry-point Create an HTML file
p.
In the web/ directoryapp, create an HTML file (index.html).
Edit index.html to add a <my-app> element
and call main.dart.
pre.prettyprint.lang-html
code.
<!-- web/index.html -->
<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="style.css">
</head>
<body>
<my-app></my-app>
<script type="application/dart" src="main.dart"></script>
<script src="packages/browser/dart.js"></script>
</body>
</html>
.l-main-section
h2#section-run-it Run the app!
p.
Now run the app. How you do this depends on your tools.
ul
li.
If you're using Dart Editor,
right-click web/index.html,
and choose Open in Dartium.
This starts a web server
and opens your app in Dartium,
an experimental version of the Chromium browser that contains the Dart VM.
li.
If you're using WebStorm or IntelliJ IDEA,
right-click web/index.html,
and choose Run 'index.html'.
li.
If you're using the command line and don't have Dartium,
serve the app using pub serve,
and then run it by visiting http://localhost:8080 in a browser.
Generating the JavaScript takes a few seconds when you first visit the page,
and the generated JavaScript is currently large.
The generated JavaScript will be smaller once
Angular's transformer becomes available.
p.
You should see something like this:
div(align='center')
img(src='setup-example1.png')
.l-main-section
h2#section-explanations Explanations
p This basic Angular app contains the structure for any app you'll build.
.l-sub-section
h3 It's all a tree
p.
You can think of an Angular app as a tree of components.
The root component acts as the top-level container for the rest of your application.
You've named this one AppComponent, but there's
nothing special about the name; you can use whatever makes sense to you.
p.
The root component's job is to give a location in the HTML file where
your application can
render through its element—in this case, <my-app>.
There's nothing special about the HTML filename or the element name;
you can pick whatever you like.
p.
The root component loads the initial template for the application,
which loads other components to perform
whatever functions your application needs—menu bars, views, forms, and so on.
We'll walk through examples of all of
these in the following pages.
.l-sub-section
h3 @Component and @View annotations
p.
A component annotation describes details about the component.
An annotation can be identified by its at-sign (@).
p.
The @Component annotation defines the HTML tag for
the component by specifying the component's CSS selector.
p.
The @View annotation defines the HTML that
represents the component.
The component you wrote uses an inline template,
but you can also have an external template.
To use an external template,
specify a templateUrl property and
give it the path to the HTML file.
p.
Exciting! Not excited yet?
Let's move on to Displaying Data.