发布于

less小记

@new: hsl(hue(@old), 45%, 90%);

hsl: h:代表的是色相，s:代表的是饱和度，l：代表的是明度

@new会有hue(@old)的色调，但是饱和度和亮度不一样
发布于

script加载

script默认是同步加载：先下载，然后执行（暂停渲染）

defer 和 async都是异步下载：

defer：先下载等页面渲染结束后再按顺序执行

async：下载完就执行，无法保证执行顺序

发布于

js class的继承

class A {
}

class B {
}

// B 的实例继承 A 的实例
Object.setPrototypeOf(B.prototype, A.prototype);

// B 的实例继承 A 的静态属性
Object.setPrototypeOf(B, A);

const b = new B();


Object.setPrototypeOf = function (obj, proto) {
  obj.__proto__ = proto;
  return obj;
}
发布于

Thunk Generator 小记

// Thunkify 源码
function thunkify(fn) {
    return function() {
        var args = new Array(arguments.length);
        var ctx = this;

        for (var i = 0; i < args.length; ++i) {
            args[i] = arguments[i];
        }
// yield 执行完后实际上返回的是一个function
        return function (done) {
            var called;

// 增加回调方法
            args.push(function () {
                if (called) return;
                called = true;
// timeout计时结束后调用value传进来的方法
                done.apply(null, arguments);
            });

            try {
// 执行最开始的读文件的方法
                fn.apply(ctx, args);
            } catch (err) {
                done(err);
            }
        }
    }
};

var readFile = function (name, callback) {
    setTimeout(() => callback(null, name), 1000);
}

var readFileThunk = thunkify(readFile);

var gen = function* (){
    var t1 = yield readFileThunk('test1');
    console.log(t1.toString());
    var t2 = yield readFileThunk('test2');
    console.log(t2.toString());
}

//var g = gen();

//var r1 = g.next();

var run = function (fn) {
    var g = fn();
    var next = function (err, data) {
// 一个操作结束的回调
        var result = g.next(data);
        if (result.done) return;
// value是一个function
// 执行这个value方法，并且传入一个next方法
        result.value(next);
    }
    next();
}

run(gen);
发布于

js反射

Reflect将一些操作对象的方法放到Reflect上：

eg:给obj增加toString方法

  • Reflect.apply(Function.prototype.toString, obj, args)
  • Function.prototype.toString.apply(obj, args)     (函数对象)
发布于

js 原型笔记

function A() {
  this.a = 'a';
}

A.prototype.b = 'b';

var a = new A();
console.log(a.a);

var b = {};
b.__proto__ = A.prototype;
A.call(b);
console.log(b.a);

__proto__指向创建该对象的构造函数的原型对象
prototype指向构造函数的原型对象