1.var声明变量
var x = 1; //全局变量
function def(){
var x = 2; //局部变量
console.log(x)
}
def() //2
console.log(x) //1
-var在方法中定义的变量是局部变量,在全局作用域定义的变量是全局变量,var存在变量提升。
-ES5之前没有块级作用域的概念,只能通过函数作用域来解决全局变量的问题。没有块级作用域导致了if和for块级的问题,这也是JavaScript设计之初的缺陷。
<button>按钮1</button>
<button>按钮2</button>
<button>按钮3</button>
<button>按钮4</button>
<button>按钮5</button>
<script>
var btns = document.getElementsByTagName('button')
for (var i = 0; i < btns.length; i++) {
btns[i].addEventListener('click', function () {
console.log('第' + i + '个按钮被点击');
})
}
</script>
-全局作用域导致点击每一个按钮的变量i都是5,因为for没有块级作用域,所以在给按钮添加点击事件的时候就把i循环了5次,而点击事件是回调函数,因此每一个按钮的变量i都一样。
var btns = document.getElementsByTagName('button');
for (var i = 0; i < btns.length; i++) {
(function (i) {
btns[i].addEventListener('click', function () {
console.log('第' + i + '个按钮被点击')
})
})(i)
}
-闭包就很好地解决了这个问题,闭包其实也是利用了作用域的概念,在每次定义函数的时候就执行一次,不会出现全局作用域的问题。
2.let声明变量
let不存在变量提升
-ES6 明确规定,如果区块中存在let和const命令,这个区块对这些命令声明的变量,从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量,就会报错。
// var 的情况
console.log(foo); // 输出undefined
var foo = 2;
// let 的情况
console.log(bar); // 报错ReferenceError
let bar = 2;
let提供块级作用域
-在代码块内,使用let命令声明变量之前,该变量都是不可用的。这在语法上,称为“暂时性死区”
var a = [];
for (let i = 0; i < 10; i++) {
a[i] = function () {
console.log(i)
}
}
a[6](); //6
function f1() {
let n = 5;
if (true) {
let n = 10;
}
console.log(n)
}
f1() //5
-let的暂时性死区也使得typeof不再是一个百分之百安全的操作
typeof x; // ReferenceError
let x;
-for循环有一个特别之处,设置循环变量的那部分是一个父作用域,而循环体内部是一个单独的子作用域。使用let也可以解决上面按钮点击事件的问题。
const btns = document.getElementsByTagName('button');
for (let i = 0; i < btns.length; i++) {
btns[i].addEventListener('click', function () {
console.log('第' + i + '个按钮被点击')
})
}
不允许重复声明
let x = 1;
{
var x = 2; // SyntaxError for re-declaration
}
-ES6 的块级作用域必须有大括号,如果没有大括号,JavaScript 引擎就认为不存在块级作用域。
// 第一种写法,报错
if (true) let x = 1;
// 第二种写法,不报错
if (true) {
let x = 1;
}
3.const声明变量
const声明一个只读的常量。一旦声明,常量的值就不能改变。
const PI = 3.1415;
PI // 3.1415
PI = 3;
// TypeError: Assignment to constant variable.
const一旦声明变量,就必须立即初始化
const foo;
// SyntaxError: Missing initializer in const declaration
const也具有块级作用域
const实际上是保证变量指向的那个地址不能修改,而不是变量的值不能修改。对于简单类型的数据(数值、字符串、布尔值),值就保存在变量指向的那个内存地址。对于复合类型的数据(主要是对象和数组),保存的只是一个指向实际数据的指针。
const obj = {
name: 'abc',
age: 18,
height: 1.88
}
obj.age = 20;
obj.prop = 123;
// 将 obj 指向另一个对象,就会报错
obj = {}; // TypeError: "obj" is read-only
4.function声明变量
//ES5之前表达形式
function() {}
//ES6表达形式
() => {}
-ES6允许为函数的参数设置默认值,即直接写在参数定义的后面。
function log(x , y = "World"){
console.log(x,y);
}
log('Hello'); //Hello World
5.import声明变量
-ES6 模块不是对象,而是通过export
命令显式指定输出的代码,再通过import
命令输入。
Module 语法是 JavaScript 模块的标准写法,使用import
取代require
import { func1, func2 } from 'moduleA';
导入导出时可以起别名
import {reallyReallyLongModuleExportName as shortName} from '/modules/my-module.js';
动态导入也可以适用
(async () => {
if (somethingIsTrue) {
// import module for side effects
await import('/modules/my-module.js');
}
})();
导入文件实例
//test.html
<body>
<script type="module">
import {helloWorld,notUseUrl,add} from '../js/common.js'
helloWorld()
console.log(add(5,5))
console.log(notUseUrl)
</script>
</body>
//common.js
let notUseUrl = ['material/submateriallist']
const add = (a, b = 6) => a + b
export function helloWorld(){
console.log("Hello World")
}
export {
notUseUrl,
add
};
-html脚本使用import必须将type设置为module,必须开启服务器否则会发生跨域问题,没有后台服务器的同学可以安装Live Server插件,右键开启本地服务。
6.class声明变量
-ES6 的class可以看作只是一个语法糖,它的绝大部分功能,ES5 都可以做到,新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法。
ES5类的定义
function Point(x, y) {
this.x = x;
this.y = y;
}
Point.prototype.toString = function () {
return '(' + this.x + ', ' + this.y + ')';
};
var p = new Point(1, 2);
ES6类的定义
class Point {
constructor(x, y) {
this.x = x;
this.y = y;
}
toString() {
return '(' + this.x + ', ' + this.y + ')';
}
}
typeof Point // "function"
Point === Point.prototype.constructor // true
-ES5 的构造函数Point,对应 ES6 的Point类的构造方法
-类的数据类型就是函数,类本身就指向构造函数
类的实例
class Bar {
doStuff() {
console.log('stuff');
}
}
var b = new Bar();
b.doStuff() // "stuff"
在类的实例上面调用方法,其实就是调用原型上的方法
class B {}
let b = new B();
b.constructor === B.prototype.constructor // true
Object.assign方法可以很方便地一次向类添加多个方法
class Point {
constructor(){
// ...
}
}
Object.assign(Point.prototype, {
toString(){},
toValue(){}
});
类的内部所有定义的方法,都是不可枚举的
class Point {
constructor(x, y) {
// ...
}
toString() {
// ...
}
}
Object.keys(Point.prototype)
// []
Object.getOwnPropertyNames(Point.prototype)
// ["constructor","toString"]