A Guide to Building Quality Angular 1.5 Components
In Angular 1, components are the mechanism which allows you to create your own custom HTML elements. This has been possible with Angular directives in the past, but components build on the various improvements that have been made to Angular and enforce best practices in how they are built and designed.
In this article, we’re going to dig into the design of components and how to put them to use inside of your applications. If you haven’t already started to use components in Angular 1, you can read about their syntax and design in one of our recent tutorials. My goal is to outline some best practices that will improve the quality of your application.
It should also be noted that many of the best practices of Angular 2 are brought into Angular 1 through the new components API, allowing you to build applications that are more easily refactored later. Angular 2 has influenced the way that we think about and design Angular 1 components, but there are still a number of distinct differences. Angular 1 is still a very powerful tool for building applications, so I believe it is worthwhile to invest in improving your applications with components even if you aren’t planning or ready to migrate to Angular 2.
What Makes a Good Component?
Components should be designed with a number of key characteristics in mind to make them a powerful building block for your application. We’ll dig into each of these in more detail, but here are the primary concepts components should adhere to.
- Isolated – The logic of the component should be encapsulated to remain internal and private. This helps create less coupling between components.
- Focused – Components should act as a single unit for one primary task, which makes them easy to reason about and often more reusable.
- One-Way Binding – When possible, components should leverage one-way binding to reduce the load on the digest cycle.
- Use Lifecycle Events – The lifecycle of a component starts with instanciation and ends with removal from the page. It is to best to hook into these events to maintain the component over time.
- Well Defined API – Components should accept configuration as attributes in a consistent manner, so it is easy to know how to use them.
- Emit Events – In order to communicate with other components, they should emit events with appropriate names and data.
Now let’s start by looking at why and how components should be isolated and encapsulated from the rest of the application.
Components Should Be Isolated
The evolution of Angular 1 capabilities has been to enable isolated and encapsulated components, and for good reason. Some of the early applications were highly coupled with the use of
$scope and nested controllers. Originally Angular didn’t provide a solution, but now it does.
Good components do not expose their internal logic. Thanks to the way they are designed, this is pretty easy to accomplish. However, resist any temptation to abuse components by using
$scope unless absolutely necessary, such as emitting/broadcasting events.
Components Should Be Focused
Components should take on a single role. This is important for testability, reusability, and simplicity. It is better to make additional components rather than overload a single one. This doesn’t mean you won’t have larger or more complex components, it simply means each component should remain focused on its primary job.
I’ve classified components into four primary groups based on their role in the application to help you think about how you design your components. There is no different syntax to build these different types of components — it is just important to consider the specific role a component takes.
These types are based on my 5+ years of Angular experience. You may choose to organize slightly differently, but the underlying concept is to ensure your components have a clear role.
There can be only one app component that acts like the root of your application. You can think of it like having only one component in the body of your web application, and all other logic is loaded through it.
<body> <app></app> </body>
This is recommended primarily for Angular 2 design parity, so it will be easier to migrate some day should you wish. It also helps with testing by moving all of the the root content of your application into a single component, instead of having some of it in the
index.html file. The app component also gives you a place to do app instantiation so you don’t have to do it in the app
run method, enhancing testability and decreasing reliance upon
This component should be as simple as possible. It probably will contain just a template and not contain any bindings or a controller if possible. It does not replace
ng-app or the need to bootstrap your application, however.
In the past, we’ve linked controllers and templates in a ui-router state (or ngRoute route). Now it is possible to link a route directly to a component, so the component is still the place in which a controller and template are paired, but with the benefit of being also routable.
Continue reading %A Guide to Building Quality Angular 1.5 Components%