Angular Best Practices

As you learn a new technology, it's easy to miss or forget some of the best practices. This course will teach you some of those best practices within Angular.
Course info
Rating
(157)
Level
Intermediate
Updated
Oct 23, 2017
Duration
1h 41m
Table of contents
Description
Course info
Rating
(157)
Level
Intermediate
Updated
Oct 23, 2017
Duration
1h 41m
Description

It's easy to create simple applications in Angular, but once you start building larger, more complex applications, you can quickly run into legibility, scalability, and performance issues if you're not careful. In this course, Angular Best Practices, you'll learn best practices in Angular. First, you'll discover the Angular project and folder organization. Next, you'll explore Angular module organization and how to use Core, shared, and feature modules. Then, you'll learn about Angular component, service best practices, and some really important performance best practices to ensure you're building fast and scalable Angular applications. Finally, you'll cover a few basic coding best practices while you're at it. By the end of this course, you'll know all the key best practices to help you build respectable, high quality, and scalable Angular applications.

About the author
About the author

Jim Cooper is a software developer at Pluralsight. With more than 20 years of software development experience, he has gained a passion for Agile software development -- especially Lean.

More from the author
Vue.js Fundamentals
Intermediate
5h 5m
21 Jun 2018
Angular Fundamentals
Intermediate
9h 35m
18 Jan 2017
JavaScript Objects and Prototypes
Intermediate
48m
10 Dec 2015
More courses by Jim Cooper
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hello everyone. This is Jim Cooper, and welcome to my course on Angular Best Practices. This is the best practices course for Angular 2 and above. I've been a developer for over 20 years, and I've been building Angular applications ever since the 1. 0 release of AngularJS in 2012. As we learn a new technology, it's easy to miss or forget some of the best practices, so I've complied the most important Angular best practices into a simple and condensed course where you can learn best practices, pro tips, and how to avoid pitfalls all in about an hour and a half. In this course, you'll learn best practices around Angular project and folder organization, Angular module organization, and how to use core, shared, and featured modules, Angular components, and services best practices, and some really important performance best practices to ensure you're building fast and scalable Angular applications. Plus, we'll cover a few basic coding best practices while we're at it. By the end of this course, you'll know all the key best practices to help you build respectable, high-quality, and scalable Angular applications. Before beginning the course, you should be familiar with the fundamentals of building Angular applications. If you would like to start there first, check out my Angular Fundamentals course before jumping in to these best practices. I look forward to joining you on this journey to learn Angular Best Practices with Pluralsight.

General Coding Best Practices
Hi, this is Jim Cooper, and welcome to this Angular Best Practices module on General Coding Best Practices. In this module, we'll cover a few general best practices that are important for Angular applications, and most of them apply even outside of Angular applications. We'll start off by discussing the single responsibility principle and the importance of breaking files and services up into small pieces with just a single responsibility each. Then we'll take a look at some best practices around naming components, services, variables, constants, etcetera. We'll also talk about immutability and the importance of using it in JavaScript in general, and specifically, in Angular applications. And finally, we'll briefly talk about the importance of making sure the functions in your code never get too large and unwieldy. So let's take a look.

Angular Components Best Practices
Hi, this is Jim Cooper, and welcome to this Angular Best Practices module on Angular Components. In this module, we'll be taking a look at the following best practices with regard to Angular components, using prefixes in component selectors, when to separate out our CSS and template files from our component and when it's okay to have them all combined, the recommended approach for creating input and output properties on components, delegating complex component logic to services, the recommended ordering sequence of component members such as properties and methods, implementing lifecycle hook interfaces, and finally, when to and not to create components. This seems like a lot, but it's not going to take too long, so let's jump right in.

Angular Services Best Practices
Hi, this is Jim Cooper, and welcome to this Angular Best Practices module on Angular services. In this module, we'll take a real quick look at the following best practices with regard to Angular services. First, we'll take a look at the right way to mark services as injectable. And then, we'll discuss using services for data retrieval. And lastly, we'll take a look at recommendations for working with the Angular injector and how to appropriately provide services in your modules. Let's go take a look.

Performance Best Practices
Hi, this is Jim Cooper, and welcome to this Angular Best Practices module on Performance Best Practices. In this module, we'll take a look at some important performance considerations and best practices to help you get the best performance from your Angular apps. We'll start by looking at the ahead-of-time compiler and how the CLI makes it easy to get some out-of-the-box performance benefits. Then we'll look at lazy loading feature modules so the application only needs to download and process the code needed based on what parts of the site a user visits. Next we'll explore some suggestions and tooling to help make sure our deployable bundle sizes aren't getting too large. Following that, we'll investigate OnPush change detection, the disadvantages of it, how immutability enables it, and how OnPush change detection can help you with performance in some cases. Finally we'll take a look at pure and impure pipes and performance considerations that you should take into account when working with pipes. Okay, let's jump in.