My favorite part of the JavaScript community is that everyone seems to always be asking
why.
Why do we do things the way that we do them?
Generally, the answer to that question is full of reason and historical context, but
sometimes the answer tends to be more simple because that's what we've always done.
Here, I have just a normal ES6 class, we have some properties in the constructor, and then
we have some methods.
So nothing fancy here.
Looking at this code, is there any way we can make it a little bit more intuitive?
These methods are fine, those come pretty natural, but what about the constructor?
Pretend like you've never even heard that word before, pretend like you're brand new
to this idea of classes.
What even is a constructor and why do we have to define instance values there?
Now, there are answers to both of those questions but why can't we just add state to our instances
just like we did with the methods?
Something that looks like this.
Where instead of having a constructor function, what if we just added all of these to the
class itself rather than using the constructor, and rather than using the this keyword?
So that seems pretty cool, you have a class, you have methods, and then you have any instance
values here.
It turns out this is actually the foundation for the class fields proposal which is currently
stage three in the TC39 process.
So, as you just saw this proposal will allow you to add instance properties directly as
a property in the class without having to use the constructor method.
Now, that seems pretty cool but where this proposal really shines is when it comes to
react code, so let's take a look at a typical react component.
And if you've never used react before, think of this just as you would a normal class,
all of this is just JavaScript.
So with this new class fields proposal what we can do is instead of having this.state
right here as we just barely saw, we can add state directly as a property on the class.
So we can say username is going to be an empty string, that allows us to get rid of this
line right here.
So that's pretty cool, but nothing too exciting so far.
So let's keep going.
According to the ES6 class specification, we can come in here and add static methods
to a class but you'll notice we have some static values.
We don't actually have any static methods so that really doesn't do us any good.
But again why can't we just, just as we did with a method, and just as we did with these
methods, and just as we did with this property, why can't we just add static properties directly
onto the class body itself?
Well, the good news is this is encompassed in the class fields proposal as well.
So instead of just being able to define static methods in the class body, we can also now
define static values.
So what that means is we can take prop types and then come on up here, and add them directly
onto the class body and we can do the exact same thing with default props.
So that's nice but we still have this ugly constructor method, and this weird super invocation
right here.
Again the reason we need the constructor right now is in order to bind the handle change
method to the correct context.
If we could figure out another way to make sure handleChange was always invoked in the
correct context, we could get rid of the constructor altogether because we would be able to get
rid of this line right here.
So if you've used arrow functions before, you'd know that they don't have their own
this keyword, instead, the this keyword is bound lexically.
That's a fancy way of saying when you use the this keyword inside of an arrow function
things behave kind of how you'd expect them to.
Now, taking that knowledge and combining it with the class fields proposal, what if we
swapped out the handle change method for an arrow function?
Now, this seems a little bit weird but by doing this we'd get rid of the bind issue
altogether, since again, arrow functions bind this lexically.
So what we can do is let's change this to an arrow function.
And then, now, the this keyword inside this method is going to be bound lexically which
means this is going to reference the component as it should.
That allows us to get rid of the constructor altogether.
So now this is looking much better, let's go ahead and look at the initial code we had
in here.
So initially, it looked like this.
But with the class fields proposal that again is currently stage three, we were able to
move all of the static values up into the class body itself, we were able to move the
state out of the constructor by adding it as a property on the class itself, and then
we were able to get rid of our constructor altogether, and this.handleChange.bind invocation
because we swapped out handleChange to be an arrow function rather than a method.
So from a developer experience standpoint, class fields are an obvious one, however,
there are some downsides to them that are rarely talked about.
When you create a class using ES6 classes, let's say we had just a simple Animal class
here with an eat method.
This is really just sugar over this pattern where we have an Animal constructor function
and then we add eat as a method on the animals prototype.
This way anytime we create an instance of Animal, all of those instances are going to
share all of these methods.
But what does this have to do with class fields?
Well as we just saw class fields are added to the instance.
This means that for each instance we create, we will be creating a new eat method.
So if we add a sleep method here using an arrow function because of the class fields
proposal, what that's going to get compiled into is something that looks like this, where
we are adding sleep directly on the instance itself rather than on the prototype.
Is this a bad thing?
Well, it can be, making broad statements about performance without actually measuring it,
for the most part, is a bad idea.
The question you need answer in your application is if the developer experience you gain from
class fields outweighs the potential performance set.
That's something I can't answer for you that's something you need to decide for yourself.
So another aspect of the class fields proposal that's pretty cool are called private fields.
Sometimes when you're building a class, you want to have private values that aren't exposed
to the outside world.
Historically in JavaScript because we've lacked the ability to have truly private values,
we've marked them with an underscore.
So in this example, we're relying on the consumer of the car class to get the car's mileage
by invoking getMilesDriven.
However, because there's really nothing making _milesDriven private, any instance can access
it.
So what we could do is we can create a new car, we can call tesla.drive, and then if
we wanted to, we could console.log this and get access to the supposedly private property.
We're just kind of hoping that the consumer of cars I mention uses getMilesDriven and
not the property or the value directly itself.
Now, there are some fancy arguably hacky ways around this problem using week maps but it
would be nice if a simpler solution existed.
Again, the class fields proposal can help us out here.
According to the proposal, you can create a private field using, this isn't a joke,
a pound sign or as the kids call them hashtags.
So by doing something like this, and then referencing this as #milesDriven throughout
our class, now if someone were to try to access this outside of the class itself, it would
throw an error saying it's invalid.
We can take this a step further.
When you're using private class fields, you don't need to use the this keyword, so that's
pretty cool.
There's currently no way to actually test this out, there's...as of filming this video,
there is an open pool request to Babel to add this into Babel so we can transpile this
code.
Hopefully that will hit sometime soon, but for now if you wanted to use the class properties
we talked about earlier, you can do that using the babel-plugin-transform-class-properties
plugin with Babel.
And as I mentioned, if you want to use private class fields, you'll have to wait a little
longer until the pool request lands in Babel.
For more infomation >> Research into public health, productivity and employees' wellbeing - Duration: 4:31. 
For more infomation >> Family of man shot and killed outside elementary school pleads for public's help - Duration: 1:44. 
For more infomation >> Enterprise to hold Business Owner Public Forum - Duration: 0:32. 
For more infomation >> TRAFFIC ALERT: Public Feedback Brings Change to Widening of Route 160 - Duration: 0:36. 
For more infomation >> Community Conflict: Public Meetings - Duration: 4:52. 
For more infomation >> Some Stanislaus County Public Sector Workers Striking - Duration: 0:20. 
Không có nhận xét nào:
Đăng nhận xét