- Overview
- Transcript
4.6 The `NgClass` and `NgStyle` Directives
The NgClass
and NgStyle
directives are very similar to the class and style bindings, but they can set multiple classes or styles simultaneously. In this lesson we'll focus on these useful directives.
1.Introduction6 lessons, 42:00
1.1Introduction00:48
1.2Get Started With Angular-CLI11:09
1.3Developing With Angular-CLI13:17
1.4TypeScript vs. JavaScript06:54
1.5Angular Modules From the CLI04:31
1.6CLI Options05:21
2.Get Started With Angular7 lessons, 42:38
2.1Bootstrapping the Application04:30
2.2The Application Module04:15
2.3The Application Component08:06
2.4Component Styling03:06
2.5Global Styling05:11
2.6Creating a Component With the CLI09:34
2.7Creating a Service With the CLI07:56
3.Core Concepts7 lessons, 55:20
3.1Component Trees06:20
3.2Dependency Injection06:52
3.3Content Projection05:38
3.4Component and Directive Lifecycle Methods06:31
3.5Component-Only Lifecycle Methods05:28
3.6Decorators07:36
3.7Models16:55
4.Template Deep Dive11 lessons, 1:10:56
4.1Basic Data Binding With Interpolation05:35
4.2Property Bindings07:07
4.3Attribute Bindings03:29
4.4Event Bindings08:16
4.5Class and Style Bindings05:44
4.6The `NgClass` and `NgStyle` Directives05:04
4.7The `*ngIf` Directive04:41
4.8The `*ngFor` Directive09:29
4.9Inputs05:33
4.10Using Pipes in a Template07:31
4.11Using Pipes in a Class08:27
5.Forms10 lessons, 1:45:41
5.1Handling User Input With Template Reference Variables07:06
5.2Template-Driven Forms11:10
5.3Template-Driven Forms: Validation and Submission14:00
5.4Reactive Forms11:26
5.5Using a `FormBuilder`08:01
5.6Reactive Validation With Built-in Validators14:53
5.7Creating Custom Validators for Template-Driven Forms12:18
5.8Creating Custom Validators for Reactive Forms08:26
5.9Observing Form State Changes12:40
5.10Working With the `@HostListener` Decorator05:41
6.Routing9 lessons, 1:15:10
6.1Defining and Configuring Routes07:53
6.2Rendering Components With Router Outlets10:14
6.3Using Router Links for Navigation05:25
6.4Navigating Routes Using the Router06:24
6.5Determining the Active Route Using an Activated Route07:16
6.6Working With Route Parameters10:42
6.7Using Route Guards07:36
6.8Observing Router Events10:55
6.9Adding Child Routes08:45
7.Using the HTTP Client5 lessons, 56:24
7.1Sending an HTTP Request10:52
7.2Handling an HTTP Response11:22
7.3Setting Request Headers12:33
7.4Intercepting Requests09:04
7.5Finishing the Example Application12:33
8.Testing10 lessons, 1:23:27
8.1Service Unit Test Preparation10:45
8.2Unit Testing Services13:24
8.3Component Unit Test Preparation12:35
8.4Unit Testing Components07:27
8.5Unit Testing Component Templates06:58
8.6Unit Testing Pipes04:41
8.7Unit Testing Directives04:56
8.8Unit Testing Validators04:48
8.9Unit Testing Observables11:37
8.10Unit Testing HTTP Interceptors06:16
9.Building for Production1 lesson, 03:40
9.1Building for Production03:40
10.Conclusion1 lesson, 01:32
10.1Conclusion01:32
4.6 The `NgClass` and `NgStyle` Directives
Hi folks. In this lesson, we're going to take a look at the NgClass and NgStyle directives, which are similar in intent to the class and style bindings, except that with these directives, we aren't restricted to setting a single class name or a single style. We can set many at the same time. Like Angular 1.X, modern versions of Angular also include directives. And in fact components are just specialized directives. Directives function in the same way that they did before. They are used to alter the behavior or appearance of elements or components. Let's take a look at the NgClass directive first. It's on of Angular's built-in directives, of which there are many, and it's very commonly used. So, in the start component, let's say that we want to show a couple of different states for the name input and label, like an error state or a warning state depending on the values entered into the input. We won't add proper validation. We do that in the form section later in the course, we'll just simulate it for now. We use square brackets around the directive NgClass and the expression points to an object in the component class called states. The object doesn't exist yet, so let's add it to the component. The type of property is going to be an object, so let's initialize the property now in the Ng, on in-it life cycle method. So let's just hardcode the values for now. We've got two properties warning and error. Warning is set to true and error is set to false. So the property is an object, and each key in this object is a class name. If the value for that class name is true, the class name will be added to the element that the directive is applied to. So, let's add some SESS for these states to the forms.sess, SESS file. So, inside the label we can add this SESS. And then inside the input we can add some more. The ampersand at the end targets the parent of the current selector, which is where we've added the directive. So let's go back to the browser now. And we find that the label and the input now have the orange styling. And we can see that the parent row has the warning class. So let's go back and just set the error state to true as well. And we'll go back to the browser, and we'll see that the styling is now red, and the parent row has both the classes, warning and error. We won't be using the Ng style directive in the example app, so let's just revert things back. The NgStyle directive works in a very similar way to the NgClass directive, except that in the template we use NgStyle instead of NgClass. In the objects back in the component class, we use the names of style properties as keys instead of class names. So now we can see that the style property has set the color to red. We don't want to use NgStyle in the example app however, so let's just revert that back to NgClass. The NgClass and NgStyle directives are known as attribute directives because they are added to the elements as attributes. They are distinguished by square brackets. Other types of directives might use a different syntax. So in this lesson we learned how to use the NgClass and NgStyle directives, which are both very commonly used. The reason for using these directives instead of the Class or Style bindings is that with directives we can set multiple class names or styles at once. With the bindings that we looked at in the last lesson, we can only set a single class or style. Thanks for watching.