JavaScript Fundamentals for ES6

This course covers the features of ECMAScript 6, the next version of JavaScript, and how you can use them today.
Course info
Rating
(612)
Level
Intermediate
Updated
Sep 17, 2014
Duration
4h 51m
Table of contents
Introduction
Variables and Parameters
Classes
Functional Programming
Built-In Objects
Asynchronous Development in ES6
Objects in ES6
Modules
Using ES6 Today
Description
Course info
Rating
(612)
Level
Intermediate
Updated
Sep 17, 2014
Duration
4h 51m
Description

ECMAScript 6, or ES6, is the next version of JavaScript, and includes many enhancements and new features that make JavaScript coding easier and more maintainable. This course will teach you all of the features of this newest version, with an emphasis on the tools and technologies that will let you leverage these features today, even before they are fully implemented by browsers and Node.

About the author
About the author

Scott has over 15 years of experience in commercial software development and is a frequent speaker at national conferences, and local user groups. Scott is a Microsoft MVP and has authored books on several Microsoft technologies, including ASP.NET, C#, and Windows Workflow.

More from the author
More courses by Scott Allen
About the author

Joe has been a web developer for the last 13 of his 16+ years as a professional developer. He has specialized in front end and middle tier development . Although his greatest love is writing code, he also enjoys teaching and speaking about code.

More from the author
Angular Crash Course
Intermediate
58m
1 Nov 2018
Unit Testing in Angular
Beginner
3h 20m
22 May 2018
More courses by Joe Eames
Section Introduction Transcripts
Section Introduction Transcripts

Introduction
Hi, this is Scott Allen, and this course is all about the new features added to the JavaScript language by the ECMAScript 6 standard, the ES6 specification as we call it. It's been a long time coming for JavaScript, because the language has been hampered by its own success. Not only is JavaScript the ubiquitous language for the web, it's reached beyond the web. It now runs inside of database engines, web servers, game consoles, and refrigerators. Backward compatibility is important when there is so much code depending on a language, but ES6 is finally here to move the language forward and it's adding some features that we've come to love in other languages, as well as some fixes and some capabilities unique to JavaScript itself. This course will cover all that's new for ES6, so let's get started by taking an overview of what ES6 is all about, when and where we can use ES6, and some of the tools you can use to try out ES6 today.

Variables and Parameters
Hi, this is Scott Allen, and this module is about new features in ECMAScript 6 for variables and parameters. These features were designed to make JavaScript code easier to read, easier to write, and also to make the code safer, because a few of these features were designed to avoid some of the strange and dangerous behaviors of JavaScript. We'll be looking at features like the two new keywords for declaring variables, that is let and const, as well as how to assign default parameters, use rest parameters, and much more in this module on working with variables and parameters.

Classes
Hi, this is Scott Allen, and in this module we'll talk about the class keyword in ECMAScript 6. The class keyword brings the vocabulary of object-oriented programming to JavaScript. It's not like JavaScript didn't have objects before ES6, we could build objects, and those objects could hold data and expose methods for a caller to invoke, but the class keyword simplifies the syntax. In this module we'll see how to define a class, give a class a constructor method to provide initialization logic, we'll add methods and properties to a class, including custom get and set logic for what happens when you read and write a property, and we'll also see how to use inheritance by defining a super class for a given class.

Functional Programming
Hi, this is Scott Allen, and this module is about functional programming with JavaScript. JavaScript has always been a functional programming language, but ECMAScript 6 improves the functional ability of the language by adding new features, features like arrow functions. Arrow functions not only give us a compact syntax for defining functions, but they can also make some scenarios safer. We will also look at iterators and generators, which give us the lazy evaluation features so many other functional programming languages offer. So we'll see a number of examples where ECMAScript 6 has introduced a new syntax for a common programming operation. We'll start this module by looking at arrow functions.

Built-In Objects
Hello, I'm Joe Eames. In this module we'll be looking at some changes that ECMAScript 6 will be bringing to built-in objects, which will include existing objects and some new ones. we'll look at how Numbers are different in ES6 and some new functionality on the Math object. we'll also see how the array object is changing, and we'll look at some new objects, Sets and Maps, which have both a regular version and a weak reference version. In order to look at the examples from this module, I'll be using two different browsers, Chrome and Firefox Nightly. Now by the time you watch this, all the functionality may be available in the released version of Chrome or Firefox, or by some miracle, Internet Explorer. So even though you'll easily be able to identify which browser I'm using, check the ES6 compatibility chart, try out the functionality in your favorite browser, and then if it doesn't work, use the same browser that I'm using.

Asynchronous Development in ES6
Hello, and welcome to the module on asynchronous coding with ES6. This module is going to be one of the more difficult modules conceptually. Asynchronous coding is never simple, so you'll want to put on your thinking cap. In this module, I don't use Tracer at all, all the demos are done with Chrome, but again, by the time you watch this, other browsers may support all the functionality, so be sure to try it in your favorite browser.

Objects in ES6
Hello, I'm Joe Eames. In this module, we'll be looking at the changes to object in ES6. We'll be focusing on three areas, two new functions on object, creating object literals, and using proxies to intercept operations on objects. The two new functions we'll look at are the is function, which is an alternative for === and handles a few edge cases differently, and the assign function, which is a built-in replacement for the very common extend function that you'll find in libraries like jQuery or underscore for adding functionality through mixins to existing objects. After that, we'll look at some new features in shorthand syntax when declaring object literals. Then we'll follow that up by looking at the new proxy object, which lets us do things like listen to an object and intercept whenever a property is read or updated, and many other operations. Because of the differing support for these two features, we'll start out this module by using tracer when looking at the new functions, and object literals. When we move onto proxies, we'll drop tracer and just use Firefox Nightly, since currently that's about the only environment that supports proxies.

Modules
Hi, this is Scott Allen, and this video module is about JavaScript modules. Just like a video module organizes a collection of video clips into a single place for consumption, JavaScript modules give us the ability to organize JavaScript code into a single unit for other pieces of code to consume. Modules also give us the ability to hide information by not publicly exposing implementation details and avoiding global variables. These capabilities are something we JavaScript programmers have needed for years. We've needed them so much that we've been using other patterns and frameworks to make up for the lack of a module system in the JavaScript language. And in order to understand and use this new module system, we do need to know about the current state of packaging JavaScript code. So let's start off by looking at what we've been using.