Hello, welcome, and congratulations on completing the angular core deep dive course, let's quickly
summarize everything that we have learned in this course.
So we have started this course by quickly scaffolding, a simple Engelhard application and going over
some of the main benefits of the angular framework.
We have covered in detail everything about the view layer, including a local template, queering content
projection and much more.
We have talked about angular templates, dynamic template instantiation and how templates can be used
as inputs for more advanced components.
We have then moved on to the service layer.
We have learned how to use the angular built in ETP client and we have learned how to pass observable
data streams to our templates using the async pipe.
We then went on to build our own custom injectable service from scratch.
A key part of the service layer is the dependency injection system of ANGULAR.
We have learned all about three shockable injectables.
We have learned how the angular hierarchical dependency injection system works and we have learned how
to build our own custom providers and injection tokens if necessary.
We have then covered in detail angular change detection.
We have covered how the default change detection mechanism works and we have also learned an alternative
change detection mechanism on Bush.
We know when to use each and why.
We know some of the pitfalls of unperceived detection and we even learn how to build our own custom
change detection mechanism if we need it.
We have then covered the angular component lifecycle hooks.
We know a couple of use cases for each lifecycle, a hook, and we also understand the exact sequence
on which those lifecycle hooks are going to be called by the angular framework.
We have then talked about angular modules and we have built our own custom feature module from scratch.
We did a deep dive into angular pipes.
We have talked about how pipes relate to the angular dependency injection system and we have written
our own custom pipe.
We have talked about the difference between pure and impure pipes.
After that, we do the complete section on angular internationalization and we have learned how to translate
our application into an alternative language.
We have then completed our course by talking about angular elements.
We have learned how can we make our components much more reusable in the larger variety of scenarios.
We can even use our components in third party applications that are being controlled not by the angular
framework, but by some third party framework, such as, for example, react or view.
I hope that the course gave you a complete overview of everything that is available on the angular core
and common modules.
Let's quickly summarize some of the main features and talk about some of its main use cases.
Let's talk about when to use each feature and why.
So first, there is the most commonly used part of the angular framework.
This is the part that we presented in the beginning of this course, and this is what you will be using
maybe 90 percent of the time.
I I'm talking about plain angular component functionality, including inputs, outputs, custom events,
building our own Kree of components, passing data to components, using the async pipe that is the
most commonly used part of ANGULAR and the one that you should spend the most time trying to master
next.
We have talked about the angular view layer in detail.
We have started by talking about local template Quairading with view child and view children.
Notice that in many cases you won't be needing to use these decorators in your application.
Many times all that we need is a template reference in order to grab a hold of a reference to a component
or a DOM element that we need in our template.
But if we need programmatic excessed these elements, then the view child and children decorator's are
the right tool to use for that use case.
Next, we have covered in detail angular content projection, so content projection allows us to build
some very customizable components that can take as an input the content provided by a user of the components
so we can provide content that then gets queried by the component and reused inside the component itself.
We have then talked about angular directives.
Directives are a really powerful functionality to have in our applications.
However, when compared to components, they are much less used.
Or most of your application is going to be custom angular components with a few directives here and
there, so we won't be building very often our own custom attribute or structural directives.
But without a doubt, we will be using all the time the angular core built in directives such as Engy
for NGF, etc. So those are the ones that it makes sense to spend the most time learning so that you
can take advantage of all its features.
We have then talked about angular view encapsulation.
One of the things that we have learned is that we still have the ability of building an application
without using any view.
Encapsulation features we an external stylesheet, just like any other application in general.
But I recommend you that you use the default view encapsulation mechanism, which is turned on by default.
This is a very useful functionality that allows you to write simpler styles that only target your component
without affecting the rest of the page.
We have then talked about dependency injection in detail and we have learned how to build our own custom
providers and injection tokens.
This was just an exercise so that you understand how the dependency injection system works under the
hood.
So the goal was to understand that if something is getting injected in the NAINGGOLAN application,
there is always an injection token and there is always a provider involved in general.
We should use the simplified configuration mechanisms that we have available and only resort to writing
our own providers and injection tokens for the more advanced dependency injection cases that we come
across.
We should also prefer to always use traditional providers because these will implicitly reduce the size
of our application bundle.
After that, we did a deep dive on angular change detection.
So we have learned the differences between the default angular change detection mechanism and on push
change detection.
I would recommend that you use the default mechanism as much as possible and only resort to using on
push.
If you run into a performance issue and you are sure that the problem is being caused by the change
detection mechanism itself.
This should only occur whenever you are displaying a lot of data on the screen in a situation where
you have a lot of binding expressions in your templates.
So if you are not in that case, most likely the performance bottleneck that you have found is not related
to the angular change detection mechanism.
It's most likely related to something else, such as, for example, backend latency.
So I would recommend you to profile your application before switching everything to on push, because
as we have seen on Bush, although it provides a bit more of performance to your application, it's
also trickier to use.
You're going to run into more situations where, surprisingly, the view is not reflecting the latest
changes in the model and you will have to do some extra debugging.
Next, we have covered in detail the angular component lifecycle hooks.
So some of the hooks, as we have seen, such as, for example, engy only need we are going to be using
nearly all the time while most of the other lifecycle hooks are only rarely needed.
And with these, we have reached the end of the course.
And I hope that you have enjoyed to learn about all these wonderful advanced features that the angular
framework provides us.
Now, if you are just getting started with the angular ecosystem and some of the parts of this course
were maybe a bit overwhelming.
Here is some final advice I would recommend to you to concentrate on the features of ANGULAR that you're
going to be using nearly every day.
So I am talking about what we covered in the first sections of this course, which is angular components,
inputs, outputs, template references and custom injectable services.
How to pass observable data to our view layer using the async pipe.
So again, congratulations for completing the angular core deep dive course.
I hope that you enjoyed it.
If you have any issues or questions, please let me know in the comments section below and I will get
back to you.
I would like to take the opportunity to ask you what other content would you like to see from the angular
diversity?
Please let me know in the comments below.
I want to thank you for watching and I will see you next time.