var PI = "a";
if (true) {
console.log(PI); // ReferenceError:没法在初始化以前访问“PI”
const PI = "3.1415926";
}
-----------------------------
var str = "Hi!";
if (true) {
console.log(str); // ReferenceError:没法在初始化以前访问“str”
let str = "Hello World!";
}
复制代码
let [a, [[b], c]] = [1, [[2], 3]];
// a = 1
// b = 2
// c = 3
---------------------------
let [a, , b] = [1, 2, 3];
// a = 1
// b = 3
---------------------------
let [a = 1, b] = []; // a = 1, b = undefined
---------------------------
let [a, ...b] = [1, 2, 3];
//a = 1
//b = [2, 3]
复制代码
let [a, b, c, d, e] = 'hello';
// a = 'h'
// b = 'e'
// c = 'l'
// d = 'l'
// e = 'o'
复制代码
let [a = 2] = [undefined]; // a = 2
当匹配结果未undefined时才会触发返回默认值基本html
let { foo, bar } = { foo: 'aaa', bar: 'bbb' };
// foo = 'aaa'
// bar = 'bbb'
let { baz : foo } = { baz : 'ddd' };
// foo = 'ddd'
复制代码
可嵌套可忽略es6
let obj = {p: ['hello', {y: 'world'}] };
let {p: [x, { y }] } = obj;
// x = 'hello'
// y = 'world'
let obj = {p: ['hello', {y: 'world'}] };
let {p: [x, { }] } = obj;
// x = 'hello'
复制代码
不彻底解构正则表达式
let obj = {p: [{y: 'world'}] };
let {p: [{ y }, x ] } = obj;
// x = undefined
// y = 'world'
复制代码
剩余运算符数组
let {a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40};
// a = 10
// b = 20
// rest = {c: 30, d: 40}
复制代码
解构默认值bash
let {a = 10, b = 5} = {a: 3};
// a = 3; b = 5;
let {a: aa = 10, b: bb = 5} = {a: 3};
// aa = 3; bb = 5;
复制代码
let sy = Symbol("KK");
console.log(sy); // Symbol(KK)
typeof(sy); // "symbol"
// 相同参数 Symbol() 返回的值不相等
let sy1 = Symbol("kk");
sy === sy1; // false
复制代码
let sy = Symbol("key1");
// 写法1
let syObject = {};
syObject[sy] = "kk";
console.log(syObject); // {Symbol(key1): "kk"}
// 写法2
let syObject = {
[sy]: "kk"
};
console.log(syObject); // {Symbol(key1): "kk"}
// 写法3
let syObject = {};
Object.defineProperty(syObject, sy, {value: "kk"});
console.log(syObject); // {Symbol(key1): "kk"}
复制代码
let yellow = Symbol("Yellow");//单例模式
let yellow1 = Symbol.for("Yellow");
yellow === yellow1; // false
let yellow2 = Symbol.for("Yellow");
yellow1 === yellow2; // true
复制代码
简单说Symbol.for()定义,若是有对应字符串的Symbol就返回,没有就新建。在Symbol.for()定义的时候会把对应字符串的Symbol登记在全局环境中,给以后搜索用。app
var myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "one");
// 将会显示两个 log。 一个是 "0 = zero" 另外一个是 "1 = one"
for (var [key, value] of myMap) {
console.log(key + " = " + value);
}
--------------------------
// 将会显示两个 logs。 一个是 "0 = zero" 另外一个是 "1 = one"
myMap.forEach(function(value, key) {
console.log(key + " = " + value);
}, myMap)
复制代码
var kvArray = [["key1", "value1"], ["key2", "value2"]];
// Map 构造函数能够将一个 二维 键值对数组转换成一个 Map 对象
var myMap = new Map(kvArray);
// 使用 Array.from 函数能够将一个 Map 对象转换成一个二维键值对数组
var outArray = Array.from(myMap);
复制代码
var myMap1 = new Map([["key1", "value1"], ["key2", "value2"]]);
var myMap2 = new Map(myMap1);
console.log(myMap1 === myMap2);
// 打印 false。 Map 对象构造函数生成实例,迭代出新的对象。
复制代码
var first = new Map([[1, 'one'], [2, 'two'], [3, 'three'],]);
var second = new Map([[1, 'uno'], [2, 'dos']]);
// 合并两个 Map 对象时,若是有重复的键值,则后面的会覆盖前面的,对应值即 uno,dos, three
var merged = new Map([...first, ...second]);
复制代码
let string = "apple,banana,orange";
string.includes("banana"); // true
string.startsWith("apple"); // true
string.endsWith("apple"); // false
string.startsWith("banana",6) // true
复制代码
console.log("h".padStart(5,"o")); // "ooooh"
console.log("h".padEnd(5,"o")); // "hoooo"
console.log("h".padStart(5)); // " h"
复制代码
function f(){
return "have fun!";
}
let string2= `Game start,${f()}`;
console.log(string2); // Game start,have fun!
复制代码
alert`Hello world!`;
// 等价于
alert('Hello world!');
复制代码
const person = {age, name};
//等同于
const person = {age: age, name: name}
复制代码
const person = {
sayHi(){
console.log("Hi");
}
}
//等同于
const person = {
sayHi:function(){
console.log("Hi");
}
}
复制代码
const obj = {
["he"+"llo"](){
return "Hi";
}
}
复制代码
let person = {name: "Amy", age: 15};
let someone = { ...person };
someone; //{name: "Amy", age: 15}
--------------------------
//合并对象
let age = {age: 15};
let name = {name: "Amy"};
let person = {...age, ...name};
person; //{age: 15, name: "Amy"}
复制代码
let target = {a: 1};
let object2 = {b: 2};
let object3 = {c: 3};
Object.assign(target,object2,object3);
// 第一个参数是目标对象,后面的参数是源对象
target; // {a: 1, b: 2, c: 3}
-----------------
//非对象,先转为对象后返回
Object.assign(3); // Number {3}
typeof Object.assign(3); // "object"
复制代码
//一是+0不等于-0
Object.is(+0,-0); //false
+0 === -0 //true
//二是NaN等于自己
Object.is(NaN,NaN); //true
NaN === NaN //false
复制代码
console.log(Array.of(1, 2, 3, 4)); // [1, 2, 3, 4]
Array.from(arrayLike[,mapFn[,thisArg]])
console.log(Array.from([1, , 3])); // [1, undefined, 3]
------------------------
console.log(Array.from([1, 2, 3], (n) => n * 2)); // [2, 4, 6]
------------------------
//thisArg用于指定map函数执行时的 this 对象。
let map = {
do: function(n) {
return n * 2;
}
}
let arrayLike = [1, 2, 3];
console.log(Array.from(arrayLike, function (n){
return this.do(n);
}, map)); // [2, 4, 6]
复制代码
转换类数组必须含有length属性,也可用转换map、set、字符串函数
let arr = Array.of(1, 2, 3, 4);
console.log(arr.find(item => item > 2)); // 3
复制代码
let arr = Array.of(1, 2, 1, 3);
// 参数1:回调函数
// 参数2(可选):指定回调函数中的 this 值
console.log(arr.findIndex(item => item = 1)); // 0
复制代码
let arr = Array.of(1, 2, 3, 4);
// 参数1:用来填充的值
// 参数2:被填充的起始索引
// 参数3(可选):被填充的结束索引,默认为数组末尾
console.log(arr.fill(0,1,2)); // [1, 0, 3, 4]
复制代码
// 参数1:被修改的起始索引
// 参数2:被用来覆盖的数据的起始索引
// 参数3(可选):被用来覆盖的数据的结束索引,默认为数组末尾
console.log([1, 2, 3, 4].copyWithin(0,2,4)); // [3, 4, 3, 4]
复制代码
for(let [key, value] of ['a', 'b'].entries()){
console.log(key, value);
}
// 0 "a"
// 1 "b"
// 不使用 for... of 循环
let entries = ['a', 'b'].entries();
console.log(entries.next().value); // [0, "a"]
console.log(entries.next().value); // [1, "b"]
---------------------------
for(let key of ['a', 'b'].keys()){
console.log(key);
}
// 0
// 1
---------------------------
for(let value of ['a', 'b'].values()){
console.log(value);
}
// "a"
// "b"
复制代码
// 参数1:包含的指定值
[1, 2, 3].includes(1); // true
// 参数2:可选,搜索的起始索引,默认为0
[1, 2, 3].includes(1, 2); // false
复制代码
console.log([1 ,[2, 3]].flat()); // [1, 2, 3]
// 指定转换的嵌套层数
console.log([1, [2, [3, [4, 5]]]].flat(2)); // [1, 2, 3, [4, 5]]
// 无论嵌套多少层
console.log([1, [2, [3, [4, 5]]]].flat(Infinity)); // [1, 2, 3, 4, 5]
// 自动跳过空位
console.log([1, [2, , 3]].flat());<p> // [1, 2, 3]
-------------------------------
// 参数1:遍历函数,该遍历函数可接受3个参数:当前元素、当前元素索引、原数组
// 参数2:指定遍历函数中 this 的指向
console.log([1, 2, 3].flatMap(n => [n * 2])); // [2, 4, 6]
复制代码