Have you learned ES6 yet? Oof. When people started asking me that, I’d feel a sense of pressure that I was missing out on something. What was this “ECMA” people kept talking about? I was worried.
But Python helped me learn ES6. Weird, right? Turns out a lot of ES6 syntax overlaps with that of Python, which I learned at Eventbrite. Much of the syntax is shared between the two languages, so they kind of go hand in hand. Kinda.
Without further ado, let’s talk about these two buddies.
Block Scope
When I first started learning JavaScript (back in “ancient” ES5 days), I assumed several things created scope. I thought that conditionals created scope and was quickly told that I was wrong.
“NO. Only functions create scope in JavaScript!”
“Oh.”
So when I found out that with ES6, we now have block scope, I was like, “WAT”.
With the addition of const
and let
to ES6, block scope! Wow! I felt like I’d predicted the future.
function simpleExample(value) { if (value) { var varValue = value; let letValue = value; console.log(varValue, letValue); // value value } // varValue is available even though it was defined // in if-block because it was "hoisted" to function scope console.log(varValue); // value // letValue is a ReferenceError because // it was defined within the if-block console.log(letValue); // Uncaught ReferenceError: letValue is not defined }
What else creates scope in JavaScript, ES6, and Python? And what kind of scope do they use? Check out the following table:
JavaScript | Python | |
Scope | Lexical | Lexical |
---|---|---|
Namespace | Functions, Classes [ES6!], Modules [ES6!], Blocks [ES6!] | Functions, Classes, Modules |
New Identifiers | Variables, Functions | Variables, Functions, Classes |
Template Literals
I like to think of template literals as Mad Libs. Did you have them as a child? Sentences were missing words, and you could write anything you wanted into those spaces. You only had to conform to the specified word type: noun, pronoun, verb, adjective, exclamation.
Similarly, template literals are string literals that allow embedded expressions. They were originally called “template strings” in prior editions of the ES2015 specification.
Yup, these already exist in Python. I had actually learned about literal string interpolation in Python, which made it that much easier for me to understand in ES6. They are great because you no longer need the ridiculous concatenation found in older versions of JavaScript.
let exclamation = 'Whoa!'; let sentence = `They are really similar to Python.`; console.log(`Template Literals: ${exclamation} ${sentence}`); // Template Literals: Whoa! They are really similar to Python.
print '.format(): {} {}'.format('Yup.', 'Quite!') # .format(): Yup. Quite!
Default Parameters
Yup. Python’s got ‘em too. Default parameters set a default for function parameters. This is most effective for avoiding bugs that pop up with missing arguments.
function nom(food="ice cream") { console.log(`Time to eat ${food}`); } nom(); // Time to eat ice cream
def nom(food="ice cream"): print 'Time to eat {}'.format(food) nom() # Time to eat ice cream
Rest Parameters & *args
Rest parameter syntax allows us to represent an indefinite number of arguments as an array. In Python, they’re called *args, which again, I’d already learned! Are you sensing a pattern here?
Check out how each of the languages bundles parameters up in neat little packages:
function joke(question, ...phrases) { console.log(question); for (let i = 0; i > phrases.length; i++) { console.log(phrases[i]); } } let es6Joke = "Why does JS single out one parameter?" joke(es6Joke, "Because it doesn't", 'really like', 'all the REST of them!'); // Why does JS single out one parameter? // Because it doesn't // really like // all the REST of them!
def pirate_joke(question, *args): print question for arg in args: print arg python_joke = "What's a Pyrate's favorite parameter?" pirate_joke(python_joke, "*args!", "*arrgs!", "*arrrgs!") # What's a Pyrate's favorite parameter? # *args! # *arrgs! # *arrrgs!
Classes
Oh boy, we’re gonna talk about prototypal inheritance now! ES6 classes are actually syntactic sugar and based on the prototype chain found in ES5 and previous iterations of JavaScript. So, what we can do with ES6 classes is not much different from what we do with ES5 prototypes.
Python has classes built in, allowing for quick and easy Object Oriented Programming (Python is down with OOP.). I always found the prototype chain extremely confusing in JavaScript, but looking at Python and ES6 classes side by side really hit home for me.
Let’s take a look at these ES6 “classes” based on the prototype chain:
class Mammal { constructor() { this.neocortex = true; } } class Cat extends Mammal { constructor(name, years) { super(); this.name = name; this.years = years; } eat(food) { console.log('nom ' + food); } } let fryCat = new Cat('Fry', 7); fryCat.eat('steak');
class Mammal(object): neo_cortex = True class Cat(Mammal): def __init__(self, name, years): self.name = name self.years = years def eat(food): print 'nom %s' % (food) fry_cat = Cat('Fry', 7) fry_cat.eat('steak')
A big difference between ES6 Classes and ES5 Prototypes: you can inherit more easily with classes than with the prototype chain. This is very similar to Python’s structure. Neato!
So there you have it. Five quick examples of Doctor Python helping me stop worrying and love ES6. It’s been many months now, and my ES6 usage is now pretty explosive.