算法
删除链表的倒数第N个节点
给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
var removeNthFromEnd = function(head, n) {
let dummy = new ListNode(0)
dummy.next = head
let first = dummy
let second = dummy
for (let i = 1; i <= n + 1; i++){
first = first.next
}
console.log(first)
while(first != null){
first = first.next
second = second.next
}
second.next = second.next.next
return dummy.next
};
proxy、Reflect、promise、generator、async
proxy
Proxy 用于修改某些操作的默认行为，等同于在语言层面做出修改，所以属于一种“元编程”（meta programming），即对编程语言进行编程。
Proxy 可以理解成，在目标对象之前架设一层“拦截”，外界对该对象的访问，都必须先通过这层拦截，因此提供了一种机制，可以对外界的访问进行过滤和改写。Proxy 这个词的原意是代理，用在这里表示由它来“代理”某些操作，可以译为“代理器”。
Proxy 实际上重载（overload）了点运算符，即用自己的定义覆盖了语言的原始定义。但是 this 会有问题
var obj = new Proxy({}, {
get: function (target, key, receiver) {
console.log(`getting ${key}!`);
return Reflect.get(target, key, receiver);
},
set: function (target, key, value, receiver) {
console.log(`setting ${key}!`);
return Reflect.set(target, key, value, receiver);
}
});
obj.count = 1
// setting count!
++obj.count
// getting count!
// setting count!
// 2
复杂一点的例子
var handler = {
get: function(target, name) {
if (name === 'prototype') {
return Object.prototype;
}
return 'Hello, ' + name;
},
apply: function(target, thisBinding, args) {
return args[0];
},
construct: function(target, args) {
return {value: args[1]};
}
};
var fproxy = new Proxy(function(x, y) {
return x + y;
}, handler);
fproxy(1, 2) // 1
new fproxy(1, 2) // {value: 2}
fproxy.prototype === Object.prototype // true
fproxy.foo === "Hello, foo" // true
Reflect
将Object对象的一些明显属于语言内部的方法（比如Object.defineProperty），放到Reflect对象上。现阶段，某些方法同时在Object和Reflect对象上部署，未来的新方法将只部署在Reflect对象上。也就是说，从Reflect对象上可以拿到语言内部的方法。
修改某些Object方法的返回结果，让其变得更合理。比如，Object.defineProperty(obj, name, desc)在无法定义属性时，会抛出一个错误，而Reflect.defineProperty(obj, name, desc)则会返回false。
让Object操作都变成函数行为。某些Object操作是命令式，比如name in obj和delete obj[name]，而Reflect.has(obj, name)和Reflect.deleteProperty(obj, name)让它们变成了函数行为。
Reflect对象的方法与Proxy对象的方法一一对应，只要是Proxy对象的方法，就能在Reflect对象上找到对应的方法。这就让Proxy对象可以方便地调用对应的Reflect方法，完成默认行为，作为修改行为的基础。也就是说，不管Proxy怎么修改默认行为，你总可以在Reflect上获取默认行为。
var loggedObj = new Proxy(obj, {
get(target, name) {
console.log('get', target, name);
return Reflect.get(target, name);
},
deleteProperty(target, name) {
console.log('delete' + name);
return Reflect.deleteProperty(target, name);
},
has(target, name) {
console.log('has' + name);
return Reflect.has(target, name);
}
});
promise
- Promise.prototype.catch：promise 内部发生错误时的回调
- Promise.prototype.finally：不管 Promise 状态如何都会执行 finally 方法
- Promise.all()：所有的 promise 都是 resolve 才会进 resolve，只要有一个 reject 就会进 reject
- Promise.race()：第一个返回的结果作为 race 的结果
// 三种状态
const PENDING = Symbol()
const FULFILLED = Symbol()
const REJECTED = Symbol()
function Prometheus (fn) {
// fn 必须是函数
if (typeof fn !== 'function') {
throw new Error('fn must be a function!')
}
let state = PENDING // 初始状态是 PENDING
let value = null // 返回值
let handler = {}
function fulfill (result) {
state = FULFILLED
value = result
next(handler)
}
// 完成时调用的方法，这里做了容错
function resolve (result) {
try {
fulfill(result)
} catch (err) {
reject(err)
}
}
// 拒绝时调用的方法
function reject (error) {
state = REJECTED
value = error
next(handler)
}
function next({ onFulfill, onReject }) {
switch (state) {
case FULFILLED:
onFulfill && onFulfill(value)
break
case REJECTED:
onReject && onReject(value)
break
case PENDING:
handler = { onFulfill, onReject }
}
}
this.then = function (onFulfill, onReject) {
return new Prometheus((resolve, reject) => {
next({
onFulfill: val => {
resolve(onFulfill(val))
},
onReject: err => {
reject(onReject(err))
}
})
})
}
fn(resolve, reject)
}
async 和 generator
// readFile 是个 promise
// generator
const gen = function* () {
const f1 = yield readFile('/etc/fstab');
const f2 = yield readFile('/etc/shells');
console.log(f1.toString());
console.log(f2.toString());
}
// async reject 需要 try catch 来捕获
const asyncReadFile = async function () {
const f1 = await readFile('/etc/fstab');
const f2 = await readFile('/etc/shells');
console.log(f1.toString());
console.log(f2.toString());
};