Difference between ES 5 and ES 6
Let me summarises the difference es5 vs es6
Template literals
`Renu`
By using the template literal ( ), it becomes unnecessary to escape special characters and describe consolidation operators.
Also, within a template literal ${variable}
, variables can be described as they are.
ES5
var name = "Renu";
var age = 9;
console.log ("My name is \" "+ name +" \ "and I 'm" + age + "years old.");
// My name is "Renu" and I 'm 9 years old.
ES6
let name = 'Renu';
let age = 9;
console.log(`My name is ${name}, I'm ${age} years old .`);
// My name is "Renu" and I 'm 9years old.
Arrow function
Function declaration in ES 5
There are three methods of function declaration in ES5.
Normal function instruction
function str (arg1, arg2) {
console.log ('Renu');
}
Function constructor (not used much)
var str = new Function ("arg1", "arg2", "console.log ('Renu')");
Function literals (using anonymous functions)
var str = function (arg1, arg2) {
console.log ('Renu');
}
Arrow function declaration
In ES 6, it is possible to simply describe function literals by using arrow functions.
Note that this
the behaviors described below are different from function literals .
var str = (arg1, arg2) => {
console.log ('Renu');
}
Arrow functions, only if there is only one argument,
var str = arg1 => console.log (arg1);
()
You can omit the argument as in (like in the case of 0 arguments can not be omitted).
Also, when it fits in one line as in the above example, you {}
may omit it.
If the Arrow function returns an object literal,
var str = func => ({id: '8'});
It ()
is necessary to enclose the whole as shown in .
Behavioral difference of this
(1) Method call
var obj = {
value: 10,
show: function () {
console.log (this.value); // 10
}
}
obj.show ();
In a method that is a function associated with an this
object, means a calling object.
That is, the case of the above this
are obj
are in, this.value
the teeth obj.value
points to.
(2) Function call
function func () {
var value = 2;
console.log (this.value) // undefined
}
func ();
When calling an ordinary function as described above, (even function declared in the object) this
points to global.
For this reason, this.value
we do not refer to the value value in the function in the function, and see the global value value (undefined). var value = 1;
If you write it outside the function , the result is 1
.
(3) Calling the constructor
function Obj (value) {
this.value = value;
}
var obj = new Obj (0);
console.log (obj.value); // 0
If instantiated in the constructor, this
is the generated instance.
In the case of this time, this
the teeth obj
refers to.
(4) apply, call, bind
var obj = {
value: 1,
show: function () {
console.log (this.value);
}
};
var newObj = {
value: 5
};
obj.show (); // 1
obj.show.call (newObj); // 5
obj.show.apply (newObj); // 5
callapply
By using methods you can bind the value of the first argument to this.
That is, newObj = { value: 5 }
but this
because of, the this.value
value 5
changes.
Arguments to be passed to the function after the second argument. Pass in ascending call
order, apply
as array. Also, bind
when using methods, write as follows ( this
generate a function that binds).
var newFunc = obj.show.bind (newObj);
newFunc ();
(5) Arrow function [ES 6 ~]
In the arrow function, the scope when the function is declared this
is automatically bound.
var obj = {
value: 10, // Method call
show: function () {
console.log (this.value); // 10 // Function call
function show_ 01 () {
console.log (this.value); // undefined
}
show_ 01 (); // Arrow function
var show _ 02 = () => {
console.log (this.value); // 10 this refers to obj
}
show_02 ();
}
}
obj.show ();
Declaring variables
var, let, const
In ES6, it became possible to use the var
new letconst
syntax in addition to the conventional one.
let
...... Unable const
to re-declare variables ...... Can not redeclare and reassign variables
var
Variable declaration using, for example, does not cause an error even in the following cases.
var x = 10;
x = 15;
console.log (x); // 15
var x = 12;
console.log (x); // 12
let
, You can not declare variables with the same name as variables once declared as shown below (you can reassign variables).
let x = 10;
x = 15;
console.log (x); // 15
let x = 12; // Identifier 'x' has already been declared
Also, const
has a role like a constant, and reassignment to a variable initialized once is not allowed.
const x = 10;
console.log (x); // 10
x = 15; // TypeError: Assignment to constant variable.
However, const
if you declare a reference type (object or array) with, you can not replace the reference itself, but you can change the contents of the reference.
var ary 1 = () => {
const aryFalse = [1, 2, 3];
aryFalse = [4, 5, 6]; // Error
console.log (aryFalse);
}
ary1 (); // Errorvar ary 2 = () => {
const aryTrue = [1, 2, 3];
aryTrue [1] = 10;
console.log (aryTrue);
}
ary2 (); // [1, 10, 3]
Block scope of variables
letconst
If you declare within a block enclosed in {, if}, etc., you can not refer to those variables outside the block.
if (true) {
var i = 0;
}
console.log (i); // 0if (true) {
let j = 10;
}
console.log (j); // ReferenceErrorif (true) {
const k = 100;
}
console.log (k); // ReferenceError
letconst
A variable (constant) declared outside the block can be referred to from within the block.
const i = 5;
if (true) {
sonsole.log (i); // 5
}
module
Before ES 5, basically it was impossible to manage and develop by dividing each JS file for each function. However, with ES 6 you can import another file.
(Postscript) It
var obj = obj || {}
seems that it is possible to do using a name space pattern .
require
js / - - - script.js
|
--- slider.js
In the case of a file configuration such as
index.html
< script src = "slider.js" > </ script >
< script src = "script.js" > </ script >
I wrote what I was writing,
script.js
var slider = require (. / slider . js );
By doing so, slider.js
you can import ( ./slider
may be written as).
In this way, require
you can read the file itself by using.
(Postscript) require has existed as CommonJS specification since the time of ES 5. However, browser still
browserify
does not support yet ( without conversion process using etc).
import / export
A module is a group of programs for realizing a certain function, and it refers to a group of variables / functions to be passed to another file.
When loading a module such as a class to be described later, import
it export
can be realized by using and .
When exchanging only one module
Load moduleimport 'importoldname' from 'File path'
Output of moduleexport default 'module'
script.js
import Carousel from '. / carousel ' ;
const carousel = new Carousel ();
carousel.js
export default class Carousel {
constructor () {
this . calc ();
}
calc () {
console . log ( 10 );
}
}
When multiple modules are handed over
On the output side, export
attach the things you want to deliver , and the import side should write import {a1, a2, ...} from 'file path'
like this.
script.js
import { multi , SuperMulti } from './Multiply' ;
console . log ( multi ( 5 )); // 50
console . log ( SuperMulti ( 6 )); // 600
multiply.js
export const i = 10 ;export function multi ( x ) {
return i * x ;
}export function superMulti ( x ) {
return i * x * 10 ;
}
If you pass all modules, import * as 'object name ' from 'file path'
you can write on the import side .
In the case of the above example, write as follows.
script.js
import * as lib from './multiply' ;
console . log ( lib . multi ( 5 )); // 50
class
Class declaration
In ES 5, class definitions realized by using prototype can be written by introducing the class instruction in ES 6.
ES5
var Add = function (arg1, arg2) {
this.arg1 = arg1;
this.arg2 = arg2;
};Add.prototype.calc = function () {
return this.arg1 + '+' + this.arg2 + '=' + (this.arg1 + this.arg2);
};var num = new Add (5, 8);
console.log (num.calc ()); // 5 + 8 = 13
ES6
class Add {
constructor (arg1, arg2) {
this.arg1 = arg1;
this.arg2 = arg2;
}
calc () {
return this.arg1 + '+' + this.arg2 + '=' + (this.arg1 + this.arg2);
}
}var num = new Add (5, 8);
console.log (num.calc ()); // 5 + 8 = 13
Class inheritance
Class inheritance and overriding super
can now be done using.
ES 5 (premise that Ad is already declared)
var AddSquare = function (arg1, arg2) {
Add.call (this, arg1, arg2);
};Object.assign (AddSquare.prototype, Add.prototype);AddSquare.prototype = {
calc: function () {// Method can not be omitted
Add.prototype.calc.call (this);
},
calcSquare: function () {
this.pow = Math.pow (this.arg1 + this.arg2, 2)
return '(' + this.arg1 + '+' + this.arg2 + ') ^ 2 =' + this.pow;
}
};var numSquare = new AddSquare (5, 8);
console.log (numSquare.calc ()); // 5 + 8 = 13
console.log (numSquare.calcSquare ()); // (5 + 8) ^ 2 = 169
ES 6 (Assumption that Ad class is already declared)
class AddSquare extends Add {
constructor (arg1, arg2) {
super (arg1, arg2);
}
calc () {// Optional for each method
super.calc ();
}
calcSquare () {
this.pow = Math.pow (this.arg1 + this.arg2, 2)
return '(' + this.arg1 + '+' + this.arg2 + ') ^ 2 =' + this.pow;
}
}var numSquare = new AddSquare (5, 8);
console.log (numSquare.calc ()); // 5 + 8 = 13
console.log (numSquare.calcSquare ()); // (5 + 8) ^ 2 = 169