如何在自己的网站上做友情链接,网站设为首页代码,wordpress系统是什么,seo快排优化个人主页#xff1a;学习前端的小z 个人专栏#xff1a;JavaScript 精粹 本专栏旨在分享记录每日学习的前端知识和学习笔记的归纳总结#xff0c;欢迎大家在评论区交流讨论#xff01; ES5、ES6介绍 文章目录 #x1f4af;ES6函数扩展#x1f353;1 默认参数#x1f35… 个人主页学习前端的小z 个人专栏JavaScript 精粹 本专栏旨在分享记录每日学习的前端知识和学习笔记的归纳总结欢迎大家在评论区交流讨论 ES5、ES6介绍 文章目录 ES6函数扩展1 默认参数1.1 之前写法1.2 ES6 写法1.3 注意点 2 reset 参数3 name属性4 箭头函数4.1 this指向4.2 练习 ES6对象扩展1 表示方法2 属性名表达式3 属性的可枚举性和遍历3.1 可枚举性3.2 属性的遍历 4 super 关键字5 对象拷贝与解构5.1 对象解构5.2 对象拷贝5.3 链判断运算符 ES6函数扩展
1 默认参数 javascript函数中 我们经常需要给必要参数加以默认值 防止参数为传的情况下出现错误 1.1 之前写法
function count(x,y){return x y;
}
count(3); //因为参数y没有传递 默认值为 undefined 3undefined返回 NaNfunction count(x,y){x x||0;y y||0; //如果参数y为undefined 返回0设置给yreturn x y;
}
count(3); //3 function count(x,y){x x??0;y y??0;//ES2019新增 空值合并运算符?? 详见对应文档return x y;
}
count(3); //3 1.2 ES6 写法 ES6 的写法不仅简洁 而且易读 让其他开发者能够快速了解参数类型 是否可省等信息, 也不会对函数体代码造成过多负担 有利于后期优化重构 function count(x 0,y 0){return x y;
}
count(3); //3 1.3 注意点
// 使用默认参数 无法在函数体内重新声明同名变量
function count(x 0,y 0){let x; //报错 const y; //报错
}//参数默认值不是传值的而是每次都重新计算默认值表达式的值。也就是说参数默认值是惰性求值的。let num 1;
function count(x num 1 , y 0){return x;
}
count() // 2num 99;count(); // 100//参数也可以作为默认值 但要注意顺序function fn(x 10, y x){console.log(x,y);
}fn(20); //20 20
fn(); // 10 10----------------------------
//错误写法 x参数调用y时 y还未定义
function fn(x y, y 10){console.log(x,y);
}fn(); //Cannot access y before initialization//参数默认值为变量时 如果外部作用域有对应变量 指向外部变量对应值
let w 10;
function fn(x w){let w 20;return x;
}
fn(); //10;//在() 阶段 x已经赋值 后续修改w 也无法改变x的值
let w 10;
function fn(x w){w 20;return x;
}
fn(); //10;2 reset 参数 ES6 引入 rest 参数形式为...变量名用于获取函数的多余参数这样就不需要使用arguments对象了。rest 参数搭配的变量是一个数组该变量将多余的参数放入数组中。 //类似结构赋值 以后就不用call来使arguments可以调用数组方法了
function count(...values) {console.log(values); //[2,5,3]return values.reduce((acc,curr) acc curr);
}
add(2, 5, 3) // 10//注意 reset参数必须作为函数最后一个参数function count(...values,a) { //ERROR Rest parameter must be last formal parameterconsole.log(values); //[2,5,3]return values.reduce((acc,curr) acc curr);
}
3 name属性 函数的name属性返回该函数的函数名。 function count(){}
console.log(count.name); //count(new Function).name // anonymousfunction foo() {};
foo.bind({}).name // bound foofunction foo() {};
foo.bind({}).name // bound foo(function(){}).bind({}).name // bound // bound (function(){}).name // 4 箭头函数 ES6 容许使用 “箭头” 定义函数 function count(x,y){return x y;
}let count (x, y) x y;let getName o o.name; //getName({name:小z}) 小z//函数体可以 直接书写表达式 或()内书写表达式 或 {} 书写多行语句let count (x,y){y 100;x x * y;return x y;
}count(3,4); //400//()内可以通过,书写多个短语语句, 最后一个 , 之后的值为返回值
let count (x,y)(x 100, y 10, x y);
count(3,4); //110 // 报错 会识别{}为函数体
let count id { id: id, name: Kyogre };// 不报错
let count id ({ id: id, name: Kyogre });4.1 this指向
/*函数体内的this对象就是定义时所在的对象而不是使用时所在的对象。*/
//箭头函数可以让setInterval里面的this绑定定义时所在的作用域而不是指向运行
const DATE {time:0
}
function clock(){setInterval((){this.time; //this指向 clock作用域内的thisconsole.log(this.time);},100);
}
clock.call(DATE);---------------------------------const DATE {time:0
}
function clock(){setInterval(function(){}{this.time; //this通过bind绑定为clock作用域的thisconsole.log(this.time);}.bind(this),100);
}
clock.call(DATE);*注意: 箭头函数里面根本没有自己的this而是引用外层的this。由于箭头函数没有自己的this所以当然也就不能用call()、apply()、bind()这些方法去改变this的指向。
(function() {return [(() this.x).bind({ x: inner })()];
}).call({ x: outer });
//[outer]//注意避免
const PERSON {name:kyogre,showName:(){return this.name;}
}PERSON.showName(); // showName使用箭头函数 this指向了 全局作用域//addEventListener回调函数内部this指向oBtn 如果使用了箭头函数 this指向就错了
let oBtn document.querySelector(.btn);
oBtn.addEventListener(click, () {this.classList.toggle(on);
});4.2 练习
//pipeline 通道组合函数function double(x) {return x x;
}function triple(x) {return 3 * x;
}function quarter(x) {return x / 4;
}function pipe() {var funs Array.prototype.slice.call(arguments);return function (input) {return funs.reduce(function (acc, currFn) {return currFn(acc);}, input)}
}var result pipe(quarter, double);-----------------------------------
const double x x x;
const triple x 3 * x;
const quarter x x / 4;const pipe (...functions) input functions.reduce((acc, fn) fn(acc),input
);const result pipe(quarter, double);
result(10); //5ES6对象扩展
1 表示方法 ES6 允许在大括号里面直接写入变量和函数作为对象的属性和方法。这样的书写更加简洁。 const foo bar;
const baz {foo};
baz // {foo: bar}// 等同于
const baz {foo: foo};//变量foo直接写在大括号里面。这时属性名就是变量名, 属性值就是变量值。下面是另一个例子。function f(x, y) {return {x, y};
}// 等同于function f(x, y) {return {x: x, y: y};
}f(1, 2) // Object {x: 1, y: 2}方法简写const o {method() {return Hello!;}
};// 等同于const o {method: function() {return Hello!;}
};setter/getter写法
const cart {_wheels: 4,get wheels () {return this._wheels;},set wheels (value) {if (value this._wheels) {throw new Error(数值太小了);}this._wheels value;}
}2 属性名表达式
// 方法一
obj.foo true;// 方法二
obj[a bc] 123;上面代码的方法一是直接用标识符作为属性名方法二是用表达式作为属性名这时要将表达式放在方括号之内。
但是如果使用字面量方式定义对象使用大括号在 ES5 中只能使用方法一标识符定义属性。
ES6 允许字面量定义对象时用方法二表达式作为对象的属性名即把表达式放在方括号内。
let propKey foo;let obj {[propKey]: true,[a bc]: 123
};let lastWord last word;const a {first word: hello,[lastWord]: world
};a[first word] // hello
a[lastWord] // world
a[last word] // world注意属性名表达式与简洁表示法不能同时使用会报错。
// 报错
const foo bar;
const bar abc;
const baz { [foo] };// 正确
const foo bar;
const baz { [foo]: abc};注意属性名表达式如果是一个对象默认情况下会自动将对象转为字符串[object Object]这一点要特别小心。
const keyA {a: 1};
const keyB {b: 2};const myObject {[keyA]: valueA,[keyB]: valueB
};myObject // Object {[object Object]: valueB}上面代码中[keyA]和[keyB]得到的都是[object Object]所以[keyB]会把[keyA]覆盖掉而myObject最后只有一个[object Object]属性。
3 属性的可枚举性和遍历
3.1 可枚举性
对象的每个属性都有一个描述对象Descriptor用来控制该属性的行为。Object.getOwnPropertyDescriptor方法可以获取该属性的描述对象。
let obj { foo: 123 };
Object.getOwnPropertyDescriptor(obj, foo)
// {
// value: 123,
// writable: true, //可写
// enumerable: true, //可枚举
// configurable: true //可配置
// }描述对象的enumerable属性称为“可枚举性”如果该属性为false就表示某些操作会忽略当前属性。
目前有四个操作会忽略enumerable为false的属性。
for...in循环只遍历对象自身的和继承的可枚举的属性。Object.keys()返回对象自身的所有可枚举的属性的键名。JSON.stringify()只串行化对象自身的可枚举的属性。Object.assign() 忽略enumerable为false的属性只拷贝对象自身的可枚举的属性。
这四个操作之中前三个是 ES5 就有的最后一个Object.assign()是 ES6 新增的。其中只有for...in会返回继承的属性其他三个方法都会忽略继承的属性只处理对象自身的属性。实际上引入“可枚举”enumerable这个概念的最初目的就是让某些属性可以规避掉for...in操作不然所有内部属性和方法都会被遍历到。比如对象原型的toString方法以及数组的length属性就通过“可枚举性”从而避免被for...in遍历到。
Object.getOwnPropertyDescriptor(Object.prototype, toString).enumerable
// falseObject.getOwnPropertyDescriptor([], length).enumerable
// false上面代码中toString和length属性的enumerable都是false因此for...in不会遍历到这两个继承自原型的属性。
另外ES6 规定所有 Class 的原型的方法都是不可枚举的。
Object.getOwnPropertyDescriptor(class {foo() {}}.prototype, foo).enumerable
// false总的来说操作中引入继承的属性会让问题复杂化大多数时候我们只关心对象自身的属性。所以尽量不要用for...in循环而用Object.keys()代替。
3.2 属性的遍历
ES6 一共有 5 种方法可以遍历对象的属性。
1for…in
for...in循环遍历对象自身的和继承的可枚举属性不含 Symbol 属性。
2Object.keys(obj)
Object.keys返回一个数组包括对象自身的不含继承的所有可枚举属性不含 Symbol 属性的键名。
3Object.getOwnPropertyNames(obj)
Object.getOwnPropertyNames返回一个数组包含对象自身的所有属性不含 Symbol 属性但是包括不可枚举属性的键名。
4Object.getOwnPropertySymbols(obj)
Object.getOwnPropertySymbols返回一个数组包含对象自身的所有 Symbol 属性的键名。
5Reflect.ownKeys(obj)
Reflect.ownKeys返回一个数组包含对象自身的不含继承的所有键名不管键名是 Symbol 或字符串也不管是否可枚举。
以上的 5 种方法遍历对象的键名都遵守同样的属性遍历的次序规则。
首先遍历所有数值键按照数值升序排列。其次遍历所有字符串键按照加入时间升序排列。最后遍历所有 Symbol 键按照加入时间升序排列。
Reflect.ownKeys({ [Symbol()]:0, b:0, 10:0, 2:0, a:0 })
// [2, 10, b, a, Symbol()]上面代码中Reflect.ownKeys方法返回一个数组包含了参数对象的所有属性。这个数组的属性次序是这样的首先是数值属性2和10其次是字符串属性b和a最后是 Symbol 属性。
4 super 关键字
我们知道this关键字总是指向函数所在的当前对象ES6 又新增了另一个类似的关键字super指向当前对象的原型对象。
const proto {foo: hello
};const obj {foo: world,find() {return super.foo;}
};Object.setPrototypeOf(obj, proto);
obj.find() // hello上面代码中对象obj.find()方法之中通过super.foo引用了原型对象proto的foo属性。
注意super关键字表示原型对象时只能用在对象的方法之中用在其他地方都会报错。
// 报错
const obj {foo: super.foo
}// 报错
const obj {foo: () super.foo
}// 报错
const obj {foo: function () {return super.foo}
}上面三种super的用法都会报错因为对于 JavaScript 引擎来说这里的super都没有用在对象的方法之中。第一种写法是super用在属性里面第二种和第三种写法是super用在一个函数里面然后赋值给foo属性。目前只有对象方法的简写法可以让 JavaScript 引擎确认定义的是对象的方法。
JavaScript 引擎内部super.foo等同于Object.getPrototypeOf(this).foo属性或Object.getPrototypeOf(this).foo.call(this)方法。
const proto {x: hello,foo() {console.log(this.x);},
};const obj {x: world,foo() {super.foo();}
}Object.setPrototypeOf(obj, proto);obj.foo() // world上面代码中super.foo指向原型对象proto的foo方法但是绑定的this却还是当前对象obj因此输出的就是world。
5 对象拷贝与解构
5.1 对象解构
let z { a: 3, b: 4 };
let n { ...z };
n // { a: 3, b: 4 }5.2 对象拷贝
let aClone { ...a };
// 等同于
let aClone Object.assign({}, a);上面的例子只是拷贝了对象实例的属性如果想完整克隆一个对象还拷贝对象原型的属性可以采用下面的写法。
// 写法一
const clone1 {__proto__: Object.getPrototypeOf(obj),...obj
};// 写法二
const clone2 Object.assign(Object.create(Object.getPrototypeOf(obj)),obj
);// 写法三
const clone3 Object.create(Object.getPrototypeOf(obj),Object.getOwnPropertyDescriptors(obj)
)上面代码中写法一的__proto__属性在非浏览器的环境不一定部署因此推荐使用写法二和写法三。
扩展运算符可以用于合并两个对象。
5.3 链判断运算符
编程实务中如果读取对象内部的某个属性往往需要判断一下该对象是否存在。比如要读取message.body.user.firstName安全的写法是写成下面这样。
// 错误的写法
const firstName message.body.user.firstName;// 正确的写法
const firstName (message message.body message.body.user message.body.user.firstName) || default;const fooInput myForm.querySelector(input[namefoo])
const fooValue fooInput ? fooInput.value : undefined-------------------------------
//链判断运算符 const firstName message?.body?.user?.firstName || default;
const fooValue myForm.querySelector(input[namefoo])?.value下面是判断对象方法是否存在如果存在就立即执行的例子。
iterator.return?.()链判断运算符有三种用法。
obj?.prop // 对象属性obj?.[expr] // 同上func?.(...args) // 函数或对象方法的调用
a?.b
// 等同于
a null ? undefined : a.ba?.[x]
// 等同于
a null ? undefined : a[x]a?.b()
// 等同于
a null ? undefined : a.b()a?.()
// 等同于
a null ? undefined : a()使用这个运算符有几个注意点。
1短路机制
?.运算符相当于一种短路机制只要不满足条件就不再往下执行。
a?.[x]
// 等同于
a null ? undefined : a[x]上面代码中如果a是undefined或null那么x不会进行递增运算。也就是说链判断运算符一旦为真右侧的表达式就不再求值。
2delete 运算符
delete a?.b
// 等同于
a null ? undefined : delete a.b上面代码中如果a是undefined或null会直接返回undefined而不会进行delete运算。
3括号的影响
如果属性链有圆括号链判断运算符对圆括号外部没有影响只对圆括号内部有影响。
(a?.b).c
// 等价于
(a null ? undefined : a.b).c上面代码中?.对圆括号外部没有影响不管a对象是否存在圆括号后面的.c总是会执行。
一般来说使用?.运算符的场合不应该使用圆括号。
4报错场合
以下写法是禁止的会报错。
// 构造函数
new a?.()
new a?.b()// 链判断运算符的右侧有模板字符串
a?.{b}
a?.b{c}// 链判断运算符的左侧是 super
super?.()
super?.foo// 链运算符用于赋值运算符左侧
a?.b c5右侧不得为十进制数值
为了保证兼容以前的代码允许foo?.3:0被解析成foo ? .3 : 0因此规定如果?.后面紧跟一个十进制数字那么?.不再被看成是一个完整的运算符而会按照三元运算符进行处理也就是说那个小数点会归属于后面的十进制数字形成一个小数。 JavaScript: https://developer.mozilla.org/en-US/docs/Web/JavaScript
