There’s no way around it. If you want to gain a competitive edge in UI/UX design, web development, or anything to do with mobile and desktop web apps, then you need to know Angular JS. Better yet, you need to know Angular 2, the latest version. This Angular 2 crash course will refresh your memory and get you updated on the essentials of the latest version. And if you’re just getting started with Angular JS, don’t worry = this is the perfect introduction too.
Get Up to Speed with Angular 2
Upgrade your Programming Skills
With 71 lectures and 5 hours of content, this Angular 2 online course will give you a thorough understanding of how Angular 2 solutions are designed, administered, and developed. If you’re a web, mobile or service app developer, architect, UI designer, tester or administrator, or if you just want to know how to get Angular 2 projects up and running, then this is the course for you.
The course will begin with an introduction to TypeScript, the Cloud9 IDE and using Angular 2 modules. Then you’ll get stuck into Angular 2’s components, building a UI and binding your data. After that things get a little more challenging with a breakdown of advanced component concepts and component composition. From there you’ll jump into services, web services, and routing before setting up Angular 2 from scratch.
By the end of this course you’ll be able to set up and get going on your own Angular 2 projects quickly, easily, and efficiently.
About Angular JS
This course teaches you how to design and build components, how to use templates to create your application’s user interface, how to extend HTML with directives and data binding, and how routing is done.
Please download the attached document for course project source files information
What is Angular? Why should we use Angular? Why is there an Angular2?
Let’s understand what we’ll do over the life of this course and how we’ll do it.
We can get a Cloud9 account set up if necessary and get our initial project set up in the cloud.
We now understand what to expect in the sections of this course and what we can expect to learn.
Prepare ourselves with some significant background info and a functioning development environment.
TypeScript is the language of choice for Angular2. Let’s learn why.
We need to get our Cloud9 online IDE set up and ready for development.
We’ll code every concept that we learn in our course project. Let’s set it up and get it ready for our first lesson.
Modules are a foundational part of Angular2. Let’s be sure to understand what they are and how we’ll use them.
We are now primed and ready to dive into Angular2.
Take a close look at what Angular2 components are and learn the steps involved in creating one.
Let’s learn what components are and what they’re made of.
Components consist of 3 parts. Let’s learn what they are and what each part does.
Let’s learn the interactions of the 3 component parts and how to stitch them together to create a complete component.
The App Component is the heart of an Angular2 application. Let’s learn to create it.
With enough ammunition to get an app up and running, let’s learn how to do it.
We learned enough to get an app up and running. With a very app is simple and very high-level Angular2 knowledge, we’re ready to dive deep into the Angular2 depths.
We will learn to define the visible aspects of components as HTML within a template.
Our view is defined in HTML which can then be inserted into our component’s template.
We can create a template in a separate file.
There are 3 steps in using a component as a directive.
Binding data from our component’s class to it’s template is easy with interpolation.
Angular2 has tons of built-in directives that we need.
We learned to work with templates within components, to bind data in those components, and how to use components as directives.
When data changes in our class, we need to reflect the change in our HTML. Let’s learn how this works.
Certain user interactions with our web page need to update properties in our class. We can use Event Binding to have this happen automatically.
We can use both Property binding and Event binding at the same time to synchronize class properties and page elements.
Let’s learn to use Pipes to transform bound properties before they are displayed.
In this section we learned to use Property binding & Event binding and how to combine them for 2-Way binding. We also learned how Pipes help us control the display of our data.
We will learn several ways to improve upon our components.
Let’s see how to make the most of Angular2’s TypeScript benefits thru use of Interfaces.
There is a better way to do styling in Angular2 than simply referencing a CSS file. Let’s learn how!
Let’s learn to listen to an Angular2 application and react to it’s many events.
We can transform and apply logic to data before we display it in the browser. Let’s see how it works.
In this section we learned to leverage TypeScript strong typing with interfaces, saw how to encapsulate styling within a component, and how to tap into component lifecycle events to trigger operations.
We will discus how to build components designed to be nested within other components and have these components talk to one another.
Let’s see how components can work “inside” other components.
We can use a Nested Component as a Directive. Let’s discuss how this is done..
Let’s learn how a Nested Component can take input from its Par
A Nested Component can send data to its Parent Component. Let’s examine this functionality.
In this section we learned how Components can nest within one another and still maintain normal data binding.
We can use Services when we have data or logic that is not associated with a specific view or that we want to share across components.
Let’s learn how Dependency Injection can make Services most effective
Services are created quite similarly to Components and Pipes. Let’s see how simple it really is.
Let’s learn to get Services into play by registering them as Providers.
We can leverage Dependency Injection to expose services where they’re needed.
In this section we learned to create Services, register them as Providers, and how to expose them most efficiently with Dependency Injection.
We will learn how to use HTTP with observable to retrieve data from the interwebs.
We can use Reactive Extensions (RxJS) to implement Angular2’s Observables instead of simply using Promises.
Let’s learn to get Reactive Extensions (RxJS) into play along with Angular2’s HTTP library.
We’ll learn to send HTTP requests in Angular2.
Let’s see how to use Observables to work with data requested via HTTP.
In this section we learned about using Reactive Extensions (RxJS) and it’s Observables instead of relying on Promises. We learned how Angular2’s HTTP library gets us HTTP requests and how to use Observables to handle data in an HTTP response.
We will learn to define routes for navigate between multiple views in an Angular2 application.
In Angular2 routing is component based. Let’s learn to configure routing targets and to define routes for components.
We will discuss the technique of tying routes to user actions for effective navigation within an application.
Oftentimes routes need to be passed a parameter. Let’s discover how this works in Angular2.
Let’s find out how to do routing with code vs. user interactions. We can implement Angular2’s RouterService to make this happen.
In this section we walked through how to configure routes, tie routes to actions, and define where the routed component’s view should appear. We also uncovered some additional routing techniques, including passing parameters to a route and activating a route with code.
At Stone River eLearning, technology is all we teach. If you're interested in programming, development or design - we have it covered.
Check out our huge catalog of courses and join the over 450,000 students currently taking Stone River eLearning courses. We currently offer 100+ different technology training courses on our Stone River eLearning website and are adding new courses on hot and trending topics every month. A subscription option is available for those with a real passion for learning.