Font size:

Description:

This is a bundled training package. It contains training for each of the bundled items below:

Course Price
Using Animation and Supporting Mobile Devices $74.95
Client-side Routing and Using HTTP $74.95
Testing Angular Apps $74.95
Creating a Basic Angular Application $74.95
Angular 2 Template Syntax, Directives, and Pipes $74.95
Creating and Maintaining Forms $74.95
Angular Security and the Angular CLI $74.95

Bundle Price: $259.00
Total Savings: $265.65


Using Animation and Supporting Mobile Devices

Angular app experiences are made richer by using animations and also ensuring that apps display and perform well on mobile devices. This course will cover the basics of animation in Angular and also the basics of using NativeScript to make Angular apps cross platforms.
  • start the course
  • import the necessary functions for animating an Angular app
  • create animation triggers to define animations
  • set up states that can animate to and from
  • set up transitions between animations states
  • attach an animation to a view element
  • use the wildcard state to match any animation state
  • use the void state to set up enter and leave animations
  • set up complex animations with keyframes
  • configure timing for animations that happen in parallel
  • use callbacks to take action when an animation starts or ends
  • install the NativeScript CLI
  • create a new app using the NativeScript CLI
  • initialize platform specific projects
  • run a NativeScript app in a mobile emulator
  • use NativeScript UI elements to create app interface
  • use NativeScript built-in layouts to help define app interface
  • use css to style NativeScript apps
  • set up routing for NativeScript mobile apps
  • set up animations for NativeScript mobile apps
  • access device specific APIs from NativeScript
  • add animations to an Angular 2 app

Client-side Routing and Using HTTP

Angular apps are typically front-end based and therefore client-side dominant. This course will cover setting up client-side routes and navigation in an Angular app. This course will also cover how to use HTTP requests to communicate with a server from within an Angular app.
  • start the course
  • install the modules needed for Angular routing
  • set up routes for an Angular application
  • set up a router-outlet element to display routed views
  • use the RouterLink directive to define navigation links
  • separate routing into distinct modules in an Angular app
  • group components together to create feature specific modules that can be imported into larger Angular apps
  • define and use child routes for use in external modules
  • create custom services for use in Angular apps
  • inject and make use of a custom Angular service
  • use the Angular router to perform explicit routing from within a controller class
  • use the ActivatedRoute service in a component to access details like route parameters
  • use the Angular router to pass optional parameters while navigating
  • define child routes that display relative to parent components and router outlets
  • define and use named router outlets as secondary destinations in Angular apps
  • import and install Angular's HttpModule for use in an app
  • retrieve data from the network into an Angular app
  • use the observable object in an Angular app
  • use observable route parameters to facilitate component re-use in Angular 2
  • restrict access to app routes by using the CanActivate guard
  • detect when apps attempt to navigate away from certain routes and allow or cancel the navigation
  • create an Angular 2 app capable of handling client-side routes

Testing Angular Apps

Testing is a major part of the app development process. This course covers setting up a test environment, creating unit tests, executing unit tests, and debugging Angular applications.
  • start the course
  • install the Jasmine test framework
  • install the Karma test runner
  • create a test spec file and define a unit test
  • execute unit tests and view results
  • debug unit tests using breakpoints
  • test custom pipes you create
  • test custom services you create
  • test custom services that make use of external dependencies
  • create an Angular testing module using Testbed
  • test custom components you create
  • use the detectChanges method effectively in Angular 2 testing
  • set up async compilation for components that use external templates and stylesheets
  • set up test stubs that can be used when components depend on services
  • test custom components that depend on services with async functionality
  • test custom components that are decorated with inputs and outputs
  • test components that are embedded in other components
  • test components that make use of Angular routes
  • test components while ignoring template elements that are irrelevant to those tests
  • test custom attribute directives you create
  • create and execute unit tests to verify expected functionality in an Angular app

Creating a Basic Angular Application

Configuring the environment is the first step in the Angular app development process. In this course, you’ll learn how to install and set up the prerequisite parts for creating an Angular development environment. The course will cover creating an app root module, root component, and also custom components as part of building a basic Angular application.
  • start the course
  • install the NodeJS runtime
  • install and update the node package manager
  • install and set up a text editor with support for creating Angular 2 applications
  • create and put in place configuration files Angular 2 relies upon
  • download and install the Angular source files
  • create the root module for an Angular app
  • create the root component for an Angular app
  • create bootstrap logic needed to start up an Angular app
  • create the index.html file that hosts an Angular 2 application
  • set up global styles for an Angular 2 app
  • start up an Angular application in a browser environment
  • create external template files for components
  • create a new component in an Angular app
  • set up a component-specific css when defining a component
  • set up template expressions for runtime evaluation using curly braces
  • bind html attributes to component values using square brackets
  • bind html events to components using brackets
  • set up two-way data binding between a component and its markup
  • pass input data into a component using the @Input decorator
  • pass event information out of a component using @Output and EventEmitter
  • create and run a simple Angular 2 app

Angular 2 Template Syntax, Directives, and Pipes

Angular comes with a template syntax, as well as some built-in directives and pipes that you can use as part of creating apps. This course will cover those built-in features as well as describe how to create custom directives and pipes based on app requirements.
  • start the course
  • set single classes on elements in Angular 2 using a class binding
  • set simple inline styles on elements in Angular 2 using style bindings
  • avoid null and undefined values in properties and property paths
  • set multiple classes on elements using ngClass
  • toggle element rendering based on set conditions
  • set multiple styles on elements using ngStyle
  • display one element tree from a set of multiple possible trees
  • present multiple elements in a concise way
  • use the ngFor directive along with an index value
  • optimize ngFor performance by providing a tracking function
  • modify html layout using templates
  • create and use a custom attribute directive
  • easily convert text case of a string
  • easily display data in a JSON format
  • easily display data in an appropriate currency format
  • slice strings and lists before display in Angular apps
  • easily display formatted dates using the date pipe and display substrings or subsets using the slice pipe
  • create and use a custom pipe
  • create and use a custom pipe in an Angular 2 application

Creating and Maintaining Forms

Collecting data via Forms and Inputs is typically a major part of web apps. This course will cover how to create forms in Angular using both a template-driven approach and an alternative model-driven approach. This course will also cover form validation and submission.
  • start the course
  • create a model class to back an Angular form
  • create a component class to support an Angular form
  • create template markup to display an Angular form
  • bind form input fields to component properties
  • set up variables within templates that can be used to access elements
  • set up two-way binding in a form with ngModel and ngModelChange
  • use class changes to determine when form is changing state
  • use CSS to display visual cues depending on whether a form is valid or invalid
  • use form state to display informative error messages depending on whether a form is valid or invalid
  • easily reset a form in Angular
  • submit a form using ngSubmit
  • setup ReactiveFormsModule need to work with model driven forms
  • create a component class to support an Angular model driven form
  • create an html view for a model driven form
  • define an initialize a FormGroup instance to back a model driven form
  • link FormControl objects to html inputs
  • set default form values at some point in time after form has been initialized
  • set default values for individual form controls at some point in time after form has been initialized
  • detect and respond to changes in model driven forms
  • create a model-driven form in Angular 2

Angular Security and the Angular CLI

Securing Angular apps ensures user data and resources are safe from malicious agents. This course covers best practices relating to Angular web apps as well as supporting authentication via web tokens. This course also covers the Angular command line interface that provides utilities, which make working with Angular even easier.
  • start the course
  • identify best practices that can be followed to make apps more secure
  • identify Angular built-in support for defending against XSS
  • use DomSanitizer to bypass Angular's default url security
  • identify Angular built-in support for defending against XSRF
  • install a library that facilitates working with JSON web tokens
  • create a service capable of checking that a user is authenticated
  • implement login and logout functionality
  • restrict access to front end routes which require authentication
  • implement transmission of authenticated requests to a server
  • install the Angular command line interface on a development machine
  • create a new app using the command line
  • create app components using the command line
  • create app directives using the command line
  • create custom pipes using the command line
  • create custom services using the command line
  • create separate modules using the command line
  • create and configure routes using the command line
  • use AngularCLI commands to create a working Angular app
Register Now
AngularJS 2.0 e-learning bundle
  • Course ID:
    271298
  • Duration:
    n/a
  • Price:
    $259