箭头函数与this语法

发布时间：2023-04-12 08:49:01 所属栏目：教程来源：

导读：箭头函数用 => 来代表一个函数，语法上类似于C#, Java8和CoffeeScript中的相关特性。他同时支持表达式（Expression bodies）和语句（Statement bodies）的写法。值得注意的是，与一般的函数不同，箭头函数与包裹它的

箭头函数用 => 来代表一个函数，语法上类似于C#, Java8和CoffeeScript中的相关特性。他同时支持表达式（Expression bodies）和语句（Statement bodies）的写法。值得注意的是，与一般的函数不同，箭头函数与包裹它的代码共享相同的this对象，如果箭头函数在其他函数的内部，它也将共享该函数的arguments变量。

// 表达式写法 Expression bodies
var odds = evens.map(v => v + 1);
var nums = evens.map((v, i) => v + i);

// 语句写法 Statement bodies
nums.forEach(v => {
if (v % 5 === 0)
fives.push(v);
});

// this 对象
var bob = {
_name: "Bob",
_friends: [],
printFriends() {
this._friends.forEach(f =>
console.log(this._name + " kNows " + f));
}
};

// arguments 对象
function square() {
let example = () => {
let numbers = [];
for (let number of arguments) {
numbers.push(number * number);
}

return numbers;
};

return example();
}

square(2, 4, 7.5, 8, 11.5, 21); // returns: [4, 16, 56.25, 64, 132.25, 441]
类(Classes)
ES2015的类只是一个语法糖，通过class关键字让语法更接近传统的面向对象模式，本质上还是基于原型的。使用单一便捷的声明格式，使得类使用起来更方便，也更具互操作性。类支持基于原型的继承，调用父类的构造函数，生成实例，静态方法和构造函数。

class SkinnedMesh extends THREE.Mesh {
constructor(geometry, materials) {
// 调用父类的构造函数 super是父类的实例
super(geometry, materials);

this.idMatrix = SkinnedMesh.defaultMatrix();
this.bones = [];
this.boneMatrices = [];
//...
}
update(camera) {
//调用this.update()
super.update();
}

// 静态方法
static defaultMatrix() {
return new THREE.Matrix4();
}
}
增强的对象字面量(Enhanced Object Literals)
经扩展后的对象字面量，允许在结构中设置原型，简化了foo: foo这样的赋值，定义方法和调用父级。这样使得对象字面量更接近类的声明，并且使得基于对象的设计更加方便。

var obj = {
// 设置 prototype
__proto__: theProtoObj,
// 计算属性不会重复设置__proto__，或者将直接触发错误。
['__proto__']: somethingElse,
// ‘handler: handler’ 简写
handler,
// 方法
toString() {
// 调用父级方法
return "d " + super.toString();
},
// 设置动态的属性名
[ "prop_" + (() => 42)() ]: 42
};
__proto__ 需要原生支持, 并且在之前的ECMAScript 版本中已被弃用。虽然现在大多数引擎支持, 但是仍有些引擎是不支持的。另外，值得注意的是，如同附录 B所示，只有 web 浏览器仍然需要支持该属性。在node中已经被支持。

模版字符串(Template Strings)
模版字符串提供了构建字符串的语法糖，类似于Perl，Python等语言中的字符串插值。可以构建一个自定义标签，避免注入攻击或者从字符串内容中构建更加高级的数据结构。

// 创建基本的模板字符串
`This is a pretty little template string.`

// 多行字符串
`In ES5 this is
not legal.`

// 插入变量
var name = "Bob", time = "today";
`Hello ${name}, how are you ${time}?`

// 不用转义
String.raw`In ES5 "\n" is a line-Feed.`

// 创建一个HTTP请求头的模版字符串，通过替换内容来构建请求
GET`http://foo.org/bar?a=${a}&b=${b}
Content-Type: application/json
X-Credentials: ${credentials}
{ "foo": ${foo},
"bar": ${bar}}`(myOnReadyStateChangeHandler);
解构(Destructuring)
解构允许使用模式匹配的方式进行绑定，并支持匹配数组和对象。解构具有一定的容错机制，就像查找普通对象foo['foo']这样，当没有找到时会返回undefined（而不会直接报错）。

译者注：当上层结构都不存在时，解构是会报错的，如const [{id: id}] = []，解构数组为空，导致整个obj为undefined，此时再去找obj.id就会报错。

// 列表（数组）匹配
var [a, , b] = [1,2,3];

// 对象匹配
var { op: a, lhs: { op: b }, rhs: c }
= getASTNode()

// 对象匹配的简写
// 绑定当前作用域的 `op`, `lhs` 和 `rhs`
var {op, lhs, rhs} = getASTNode()

// 可以用在函数的参数中
function g({name: x}) {
console.log(x);
}
g({name: 5})

// 解构容错机制
var [a] = [];
a === undefined;

// 带默认值的解构容错
var [a = 1] = [];
a === 1;

// 解构 + 默认参数
function r({x, y, w = 10, h = 10}) {
return x + y + w + h;
}
r({x:1, y:2}) === 23
默认参数(Default) + 不定参数(Rest) + 扩展运算符(Spread)
默认参数(default)的功能是在函数被调用时对参数做自动估值(若没被赋值，则自动赋值)，扩展运算符(spread)则可以将数组转换为连续的函数参数，不定参数(rest)用在参数末尾，将最末尾的参数转换为数组。不定参数(rest)让我们不再需要arguments，更直接地解决了一些常见的问题。

function f(x, y=12) {
// 如果没有传入y或传入了undefined，y的默认值为12
return x + y;
}
f(3) == 15
function f(x, ...y) {
// y是一个数组
return x * y.length;
}
f(3, "hello", true) == 6
function f(x, y, z) {
return x + y + z;
}
// 将数组中的每个元素展开为函数参数
f(...[1,2,3]) == 6
Let(定义变量) + Const(定义常量)
这两个关键字具有块级作用域。let是var的升级版。const仅允许被赋值一次，通过静态限制（Static restrictions ）的方式阻止变量在赋值前被使用。

function f() {
{
let x;
{
// 这是正确的，因为const具有块级作用域
const x = "sneaky";
// 错误，"x"已被定义为const常量，不允许再赋值
x = "foo";
}
// 这是正确的，因为这里的"x"是被let定义的
x = "bar";
// 错误，"x"已经被定义，不允许再重复定义
let x = "inner";
}
}
迭代器(Iterators) + For..Of循环
ES6中的迭代器对象允许像 CLR(Common Language Runtime)的IEnumerable 接口或者 Java 的 Iterable 一样创建自定义迭代器，可以将for..in这种遍历模式更加一般化为for..of的形式。它是支持惰性模式的，不需要真正实现一个数组（只需要实现Iterator接口），就像LINQ语言那样。

// 实现斐波那契数列的迭代器
let fibonacci = {
[Symbol.iterator]() {
let pre = 0, cur = 1;
return {
next() {
[pre, cur] = [cur, pre + cur];
return { done: false, value: cur }
}
}
}
}

for (var n of fibonacci) {
// 循环将在n > 1000 时结束
if (n > 1000)
break;
console.log(n);
}
迭代器还可以基于"鸭子类型"来实现（使用TypeScript 这种基于类型的语法来说明）：

interface IteratorResult {
done: boolean;
value: any;
}
interface Iterator {
next(): IteratorResult;
}
interface Iterable {
[Symbol.iterator](): Iterator
}
通过 polyfill 支持为了使用迭代器你必须引入Babel的 polyfill.

（编辑：汽车网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!