链式调用的核心：调用完每个方法之后，返回自身示例this

    1. class Method {
    2.   method(param) {
    3.     console.log(param);
    4.     return this; //由于new 在实例化的时候this会指向创建的对象， 所以this.method这个方法会在原型链中找到。
    5.   }
    6. }
    7. let m = new Method();
    9. m.method('第一次调用').method('第二次链式调用').method('第三次链式调用');
    1. var obj = {
    2.     a: function() {
    3.         console.log("a");
    4.         return this;
    5.     },
    6.     b: function() {
    7.         console.log("b");
    8.         return this;
    9.     },
    10. };
    11. obj.a().b();
    1. class LazyMan {
    2.   constructor(name) {
    3.     this.cb = [];
    4.     console.log(`懒汉->${name}`);
    5.     setTimeout(() => {
    6.       this.next();
    7.     });
    8.   }
    10.   sleep(time) {
    11.     this.cb.push(() => {
    12.       setTimeout(() => {
    13.         console.log(`睡 --> ${time}s`);
    14.         this.next();
    15.       }, time * 1000);
    16.     });
    17.     return this;
    18.   }
    20.   sleepFirst(time) {
    21.     this.cb.unshift(() => {
    22.       setTimeout(() => {
    23.         console.log(`先睡 --> ${time}s`);
    24.         this.next();
    25.       }, time * 1000);
    26.     });
    27.     return this;
    28.   }
    30.   eat(time) {
    31.     this.cb.push(() => {
    32.       setTimeout(() => {
    33.         console.log(`吃 --> ${time}s`);
    34.         this.next();
    35.       }, time * 1000);
    36.     });
    37.     return this;
    38.   }
    40.   drink(time) {
    41.     this.cb.push(() => {
    42.       setTimeout(() => {
    43.         console.log(`喝 --> ${time}s`);
    44.         this.next();
    45.       }, time * 1000);
    46.     });
    47.     return this;
    48.   }
    50.   next() {
    51.     const fn = this.cb.shift();
    52.     fn && fn();
    53.   }
    54. }
    56. const lz = new LazyMan('sf');
    57. lz.eat(2).sleep(1).sleepFirst(5).drink(3);