So starting with ES6, this is where a lot of the changes really started to happen. One of the new things is default parameters. This allows us to add default values to our function parameters so that we can avoid passing them in when calling on functions. There’s the idea of string interpolation added as well. This allows us to pass values into strings and convert them in real time, rather than breaking our strings up. As well, multiline strings further prevent us from breaking strings up by allowing us to build strings over multiple lines. There’s the idea of constants which are essentially values or variables that do not change.
Next up we have a whole host of highly efficient and highly functional array functions introduced in this version. We have also arrow functions, which are ways to simplify our function syntax and creates really quick functions that have very fast and quick to implement functionality (it basically makes our process even faster). There’s the idea of deconstructing, which is essentially allowing our compiler to interpret values without us explicitly having to state them, especially when dealing with dictionaries and objects.
There’s also the concept of promises. Now promises is a little bit more complex, so we’ll be exploring promises in much greater detail. Essentially they provide a clean and safe way to guarantee that something will have a value, especially when paired with asynchronous functions.
Now in ES7, we have the array.prototype.includes function, so this is just yet another array function. It’s a way to just determine if an array contains a value. There’s also the exponentiation operator. This is essentially just raising something to the power of something else. For example, we can now do five to the power of two to get 25, rather than just having to multiply things out a bunch of times.
In ES8 we have asynchronous functions. This is, again, a massive new feature. Asynchronous functions are functions that do not work one after the other; that would be synchronous. Instead, they work in parallel and allow us to execute multiple functions all at the same time. There’s also the concept of shared memory and atomics. This is actually a little beyond the scope of this course, so we won’t really be talking too much about that.
There are object.values and object.entries. This is a way to treat our objects kind of like dictionaries, wherein we can get the parameter names and the actual, or rather, the field names and the actual values associated with them by either the values or entries respectively. There’s also the string.padend and padstart functions. This is just a way to add extra characters to the end or to the beginning of a string. Object.getownpropertydescriptors is a way to print out a big string description of an object and all of its entities.
And they’re also trailing commas now this isn’t huge, but it’s nice if in case we forget to close off or rather end a comma if we’re listing a bunch of items. It doesn’t matter if we include that final extra one.
So ES9 is our last one. First up we have RegEx changes, so this is regular expression changes. To be honest, I personally don’t like using regular expressions when possible, and I found I actually don’t have to use them too much, so we won’t really be covering the regular expressions changes so much. Rather if you are super interested, you can definitely check those out. ES9 has added a bunch of support.
There are also Rest and spread properties. These are really cool, as they allow us to essentially build up ranges of values through using three ellipses put together, and this allows a compiler to interpret what values come next in a series of values. After this, we have asynchronous iteration. That’s actually the last big one, and it just lends more powerful support to our asynchronous functionality.
So next up we’ll be actually installing the tools that we’ll need and learning how to set up and run our project, so stay tuned for that. Thanks very much for watching, I will see you guys in the next section.
But for those of you who are interested, I personally will be using Atom for most of my functionality. So let’s get started. Now, the first thing you might want to do is actually update Atom itself, so this is what it looks like if I have Atom started up with no project going right now. If I want to just update it, I can simply go to Atom, up to check for update, and it actually even tells you the version there. It says no update available. 1.36.0 is the latest version at this time, but depending on when you’re watching it you might have a later version, so just go ahead and update it that way.
If you don’t already have this then you can simply open the browser, go for download Atom, select this first link here, Atom.io. And then go to select your correct platform. For me it auto comes up as MacOS, and I think it should automatically select your system. Then go ahead and click Download, open up the file, and run through the installation with it once you are done.
Now as I said before, you really don’t have to use Atom if you don’t want. I will be using Atom to write most of my codes, so if you do use a different text editor, then things will look a little different. I will show you in a couple of tutorials how to create an NPM project or a node.js project and run through things just using Node.js and the Terminal. That’s going to be an important skill to have, as we’ll need that for some of the packages we’ll install anyway. So like I said if you don’t want to do this, that’s fine you can stick with just Terminal and a basic text editor.
However this next section is going to be configuring Atom, so if you don’t want to use Atom just skip over it and move on to the Node.js part. Okay, so thanks for watching we’ll see you guys in the next one.