Building an Application with AngularJS
0.0 (0 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
90 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Building an Application with AngularJS to your Wishlist.

Add to Wishlist

Building an Application with AngularJS

Get creative with AngularJS to develop exciting applications
0.0 (0 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
90 students enrolled
Created by Packt Publishing
Last updated 2/2015
English
Current price: $10 Original price: $85 Discount: 88% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 2.5 hours on-demand video
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Utilize controllers to create a neat workflow and business logic for your app
  • Use Dependency Injection in controllers, services, and other Angular objects to give a professional touch to your app
  • Understand JavaScript promises and use them in your code to deal with asynchronous operations effectively
  • Write and execute end-to-end tests to produce robust code for your application
  • Implement views and tie them with controllers using data binding
  • Maximize your efficiency by creating your own custom services
  • Create and implementing custom directives that wrap arbitrary content for you
View Curriculum
Requirements
  • You will learn to use your knowledge of HTML, CSS, and JavaScript to become an AngularJS expert.
Description

AngularJS helps you build dynamic web apps quickly and easily. If you are looking for scalability and modularity in your apps, then AngularJS is the technology for you. It provides you with all the tools necessary to develop apps that are both attractive and functional.

This video course will show you how to write a complex application using AngularJS, one step at a time.

You will begin with preparing the system by setting up the necessary prerequisites. Then you will scaffold your application and write your first controllers and views using data binding to stitch them together. You will then move on to implementing your own custom services as well as directives to make your app flexible and extensible. Finally, you will turn your attention to testing the code before the course ends and you are ready to write your own Angular application.

You will start with an empty slate but by the end of the course, creating and implementing complex AngularJS applications will be easier than ever.

About the Author

Gabriel Schenker grew up in Switzerland on a wonderful farm located on top of a hill where the stars seem to touch the earth. He studied Physics at the Federal Institute of Technology in Zurich, Switzerland. There, he also got his PhD. in Physics. After working in behavioral science for a couple of years, which included training trainers, he went freelance as a software developer, consultant, mentor, and trainer. In 2009 he moved to Austin, Texas, where he is currently working as Chief Software Architect for a company writing software for pharmaceuticals, hospitals, and universities working in the area of new drug development.

Who is the target audience?
  • This video course is aimed at JavaScript developers who want to explore AngularJS and write complex single page applications (SPAs) quickly and easily.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
41 Lectures
02:22:04
+
Getting Started
5 Lectures 16:51

Whenever we learn a new programming language or framework, we want to know how the hello world program is implemented.

Introducing a Minimal Angular Application
03:42

Learning a lot of facts and techniques of angular is important, but it is also important to see all these isolated methods work together in a sample application.

Showcasing the Application
02:55

Before we can start to develop an angular application, we need to prepare our system and install some tools that facilitate and automate our development process.

Installing the Prerequisites
03:10

When writing a complex application in a team, it is important to set the stage properly and include some conventions. All team members need to be on the same page.

Scaffolding an Angular Application
03:57

We all want to use the right tool for the job; developing an angular application is no exception. We get a quick overview of the most popular editors and IDEs

Selecting an Editor or IDE
03:07
+
Introducing the View and the Controller
6 Lectures 20:32

With directives, we attach behavior to DOM elements and make our application dynamic and an angular application.

Preview 03:16

Angular encourages the use of the MVC pattern. Behavior, that is, code belongs in the controller and not in the view.

Introducing a Controller
03:38

In angular, the model is the data that we want to interact within our application. The scope is an object on which we define the model and the behavior, and it is the execution context for expressions.

Explaining the Scope and the Model
03:31

Data binding is used to automatically synchronize data between the model and the view components. The view and controller are glued together by data binding.

Using Two-way Data Binding
03:02

When a user interacts with view components such as buttons, events are triggered. In angular code that is executed as a result of the event is implemented in the controller.

Implementing Behaviors in the Controller
03:22

A dynamic web application needs to show and hide certain areas of the view depending on the state of the application.

Showing and Hiding Elements
03:43
+
Advanced Views and Controllers
5 Lectures 16:28

Most line of business (LOB) applications provide some data entry for the user. Angular forms assist us in accepting and validating user input.

Preview 03:25

Views can get pretty complex quickly. We can use templates to componentize our views.

Using Static Templates
03:54

Sometimes, the use of static templates is not enough. We can use dynamic templates to change the display based on some criteria.

Working with Dynamic Templates
03:37

Often, we want to present the data we get from the backend in a sorted way, or we want to only show part of the data. Angular filters allow us to map, reduce, and sort data.

Using Filters to Message Data
02:10

Realistic angular applications consist of many views. Using client-side routing, we can navigate from view to view.

Introducing Client-side Routing in Our Application
03:22
+
Dependency Injection (DI)
3 Lectures 08:52

Controllers and services often need to collaborate with or use other services. We can get hold of external dependencies using the dependency injection.

Preview 02:58

When we minify the JavaScript files variable, parameter names get shortened. Angular provides mechanisms that help avoid minification adversely affect dependency injection.

DI and Minifying JavaScript Files
02:44

There are situations where we want to explicitly claim external services. In this case, we can use the angular injector service.

Introducing the Angular $injector Service
03:10
+
Services
5 Lectures 19:02

When do we put code into a controller and when do we create a service?

Preview 03:21

Services have a special life cycle in being singletons. Understanding its implications is crucial.

Understanding the Life Cycle of a Service
02:49

In a typical application, we need to load data from a server and push data changes to the server. Angular provides us with the $http service for such tasks.

Using the $http Service to Access Server Resources
04:24

If we want to share the data of business logic among controllers, then we should create our own custom services.

Defining a Simple Custom Service
03:54

When creating a service, we can choose among five different recipes. We will learn how to choose the right one in different situations.

Introducing Five Recipes to Create a Service
04:34
+
Mastering Asynchronous Programming
4 Lectures 15:08

A lot of JavaScript code is asynchronous. Promises help us keep the complexity low.

Preview 04:10

The angular $q library provides us with the tools we need in order to write our own promises.

Using the Angular $q Library
03:53

Often, we need to launch multiple asynchronous requests. Promises make it easy to run them either in parallel or in a sequence.

Chaining Multiple Asynchronous Requests
03:39

Often, remote requests to the server can take some time and the user wants to cancel the request. We will learn how to do this.

Canceling a $http Request
03:26
+
Covering Code with Unit Tests
5 Lectures 17:08

To execute tests written in JavaScript for our angular components, we need a test runner. The Karma test runner was developed by the angular team.

Preview 04:40

To write high-quality, maintainable unit tests, we need to understand the individual parts of a test.

Explaining the Anatomy of a Unit Test
03:43

JavaScript is a dynamic language. To create robust code, we need to cover the code with unit tests.

Writing a Simple Unit Test
02:43

Unit tests need some setup. The module and inject functions help us achieve this.

Discussing the Module and the Inject Functions
02:39

Most applications communicate with a server. To test components in isolation, we need to mock server calls.

Using the $httpBackend Mock
03:23
+
Exploring Directives
5 Lectures 18:26

The HTML vocabulary is limited. We can define directives that extend the vocabulary.

Preview 03:18

Directives are components that should be isolated from their environment. This can be achieved by defining a private scope.

Understanding the Scope of a Directive
03:16

Directives often need to interact with their hosting environment. One-way and two-way data binding and callback binding can be used.

Interacting with the Parent Scope
03:41

Sometimes, directives need to wrap arbitrary content. We can use transclusion for this.

Demystifying Transclusion
03:47

Directives can be complex and as such, need to be thoroughly unit tested.

Testing a Directive
04:24
+
Writing End-to-End Tests
3 Lectures 09:37

To run end-to-end tests, we need a test runner. The angular team has created Protractor for this job.

Preview 03:26

Manual tests are inefficient at best. Writing automated tests solves this problems.

Writing a Simple End-to-End test
03:02

Our views are complex and we need to access various elements in them.

Analyzing Strategies to Access Elements in a View
03:09
About the Instructor
Packt Publishing
3.9 Average rating
7,196 Reviews
51,386 Students
616 Courses
Tech Knowledge in Motion

Packt has been committed to developer learning since 2004. A lot has changed in software since then - but Packt has remained responsive to these changes, continuing to look forward at the trends and tools defining the way we work and live. And how to put them to work.

With an extensive library of content - more than 4000 books and video courses -Packt's mission is to help developers stay relevant in a rapidly changing world. From new web frameworks and programming languages, to cutting edge data analytics, and DevOps, Packt takes software professionals in every field to what's important to them now.

From skills that will help you to develop and future proof your career to immediate solutions to every day tech challenges, Packt is a go-to resource to make you a better, smarter developer.

Packt Udemy courses continue this tradition, bringing you comprehensive yet concise video courses straight from the experts.