2019-11-15

动态规划

You are climbing a stair case. It takes n steps to reach to the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

上楼梯、斐波那契数列、泰波那契序列问题。

常规解法

1	function f (n) {if (n<=2) {return n;} return f(n-1)+f(n-2);}

闭包，memory cache

var gen = () => {
	let memory = [];
	return function fib(n) {
		if (n <= 1) {
			return 1;	
		}
		if (memory[n] > 0) {
			return memory[n];
		}
		let num = fib(n-1) + fib(n-2);
		memory[n] = num;
		return num;
	}
}

深度优先搜索

var fff = (n) => {
	let memory = [0];
	for(let i = 1; i <= n; i++) {
		if (i <= 2) {
			memory[i] = i;
		} else {
			memory[i] = memory[i-1] + memory[i-2];
		}
	}
	return memory[n];
}

2019-11-14

svelte介绍

virtual-dom-is-pure-overhead

Unlike traditional UI frameworks, Svelte is a compiler that knows at build time how things could change in your app, rather than waiting to do the work at run time.

The danger of defaulting to doing unnecessary work, even if that work is trivial, is that your app will eventually succumb to ‘death by a thousand cuts’ with no clear bottleneck to aim at once it’s time to optimise.

Svelte is explicitly designed to prevent you from ending up in that situation.

Why do frameworks use the virtual DOM then?

It’s important to understand that virtual DOM isn’t a feature. It’s a means to an end, the end being declarative, state-driven UI development. Virtual DOM is valuable because it allows you to build apps without thinking about state transitions, with performance that is generally good enough. That means less buggy code, and more time spent on creative tasks instead of tedious ones.

But it turns out that we can achieve a similar programming model without using virtual DOM — and that’s where Svelte comes in.
但是事实证明，我们无需使用虚拟DOM就可以实现类似的编程模型-这就是Svelte的用武之地。

2019-11-12

snippets

debounce

export function debounce (fn, delay) {
    let timer = null;

    return function () {
      if (timer) {
        clearTimeout(timer);
        timer = null;
      }

      timer = setTimeout(() => {
        fn();
        timer = null;
      }, delay);
    };
}

deepclone

export function deepClone (obj) {
    if (typeof obj === 'object') {
        if (obj instanceof Array) {
            var newArr = [];
            for (var i = 0; i < obj.length; i++) newArr.push(deepClone(obj[i]));
            return newArr;
        } else {
            var newObj = {};
            for (var key in obj) {
                newObj[key] = deepClone(obj[key]);
            }
            return newObj;
        }
    } else {
        return obj;
    }
}

objectFilter对象根据属性过滤

export default function objectFilter (obj) {
    if (typeof obj !== 'object') {
        return obj;
    }

    var newObj = {};

    for (var i in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, i)) {
            if (obj[i] !== '' && typeof obj[i] !== 'undefined') {
                newObj[i] = obj[i];
            }
        }
    }

    return newObj;
}

观察者模式

let uuid = 0;
function Observer () {
    this.listeners = {};
    this.id = uuid++;
}
Observer.prototype = {
    constructor: Observer,
    sub: function (type, fn) {
        this.listeners[type] = this.listeners[type] || [];
        this.listeners[type].push(fn);
    },
    pub: function (type) {
        if (this.listeners && this.listeners[type]) {
            for (var i = 0; i < this.listeners[type].length; i++) {
                this.listeners[type][i].apply(this, [].slice.call(arguments, 1));
            }
        }
    },
    one: function (type, fn) {
        this.sub(type, function tmp (ev) {
            /* eslint-disable no-invalid-this */
            fn.call(this, ev);
            this.unbind(type, tmp);
            /* eslint-enable no-invalid-this */
        });
    },
    unbind: function (type, fn) {
        setTimeout(() => { // 如果一个事件被多个监听者监听，第一个监听者在监听的时候unbind后，这里splice去掉第1个监听，会导致pub里面的循环执行的函数减少一个，导致第二个监听handler在当前这次循环中无法执行，所以将unbind放到异步事件的宏队列执行，防止正在进行的循环的listeners会有监听handler没有执行的情况
            if (this.listeners && this.listeners[type]) {
                if (typeof fn !== 'function') {
                    delete this.listeners[type];
                } else {
                    for (var i = 0; i < this.listeners[type].length; i++) {
                        if (this.listeners[type][i] === fn) {
                            this.listeners[type].splice(i--, 1);
                        }
                    }
                }
            }
        }, 0);
    },
    unbindAll: function () {
        for (var key in this.listeners) {
            if (this.listeners.hasOwnProperty(key)) {
                delete this.listeners[key];
            }
        }
    }
};

module.exports = {
    Observer: Observer,
    observer: new Observer()
};

手写Promise

(function () {

  // Store setTimeout reference so promise-polyfill will be unaffected by
  // other code modifying setTimeout (like sinon.useFakeTimers())
  var setTimeoutFunc = setTimeout;

  function noop() {}

  // Polyfill for Function.prototype.bind
  function bind(fn, thisArg) {
    return function () {
      fn.apply(thisArg, arguments);
    };
  }

  function Promise(fn) {
    if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new');
    if (typeof fn !== 'function') throw new TypeError('not a function');
    this._state = 0;
    this._handled = false;
    this._value = undefined;
    this._deferreds = [];

    doResolve(fn, this);
  }

  function handle(self, deferred) {
    while (self._state === 3) {
      self = self._value;
    }
    if (self._state === 0) {
      self._deferreds.push(deferred);
      return;
    }
    self._handled = true;
    Promise._immediateFn(function () {
      var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
      if (cb === null) {
        (self._state === 1 ? resolve : reject)(deferred.promise, self._value);
        return;
      }
      var ret;
      try {
        ret = cb(self._value);
      } catch (e) {
        reject(deferred.promise, e);
        return;
      }
      resolve(deferred.promise, ret);
    });
  }

  function resolve(self, newValue) {
    try {
      // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
      if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.');
      if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
        var then = newValue.then;
        if (newValue instanceof Promise) {
          self._state = 3;
          self._value = newValue;
          finale(self);
          return;
        } else if (typeof then === 'function') {
          doResolve(bind(then, newValue), self);
          return;
        }
      }
      self._state = 1;
      self._value = newValue;
      finale(self);
    } catch (e) {
      reject(self, e);
    }
  }

  function reject(self, newValue) {
    self._state = 2;
    self._value = newValue;
    finale(self);
  }

  function finale(self) {
    if (self._state === 2 && self._deferreds.length === 0) {
      Promise._immediateFn(function() {
        if (!self._handled) {
          Promise._unhandledRejectionFn(self._value);
        }
      });
    }

    for (var i = 0, len = self._deferreds.length; i < len; i++) {
      handle(self, self._deferreds[i]);
    }
    self._deferreds = null;
  }

  function Handler(onFulfilled, onRejected, promise) {
    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
    this.onRejected = typeof onRejected === 'function' ? onRejected : null;
    this.promise = promise;
  }

  /**
   * Take a potentially misbehaving resolver function and make sure
   * onFulfilled and onRejected are only called once.
   *
   * Makes no guarantees about asynchrony.
   */
  function doResolve(fn, self) {
    var done = false;
    try {
      fn(function (value) {
        if (done) return;
        done = true;
        resolve(self, value);
      }, function (reason) {
        if (done) return;
        done = true;
        reject(self, reason);
      });
    } catch (ex) {
      if (done) return;
      done = true;
      reject(self, ex);
    }
  }

  Promise.prototype['catch'] = function (onRejected) {
    return this.then(null, onRejected);
  };

  Promise.prototype.then = function (onFulfilled, onRejected) {
    var prom = new (this.constructor)(noop);

    handle(this, new Handler(onFulfilled, onRejected, prom));
    return prom;
  };

  Promise.all = function (arr) {
    var args = Array.prototype.slice.call(arr);

    return new Promise(function (resolve, reject) {
      if (args.length === 0) return resolve([]);
      var remaining = args.length;

      function res(i, val) {
        try {
          if (val && (typeof val === 'object' || typeof val === 'function')) {
            var then = val.then;
            if (typeof then === 'function') {
              then.call(val, function (val) {
                res(i, val);
              }, reject);
              return;
            }
          }
          args[i] = val;
          if (--remaining === 0) {
            resolve(args);
          }
        } catch (ex) {
          reject(ex);
        }
      }

      for (var i = 0; i < args.length; i++) {
        res(i, args[i]);
      }
    });
  };

  Promise.resolve = function (value) {
    if (value && typeof value === 'object' && value.constructor === Promise) {
      return value;
    }

    return new Promise(function (resolve) {
      resolve(value);
    });
  };

  Promise.reject = function (value) {
    return new Promise(function (resolve, reject) {
      reject(value);
    });
  };

  Promise.race = function (values) {
    return new Promise(function (resolve, reject) {
      for (var i = 0, len = values.length; i < len; i++) {
        values[i].then(resolve, reject);
      }
    });
  };

  // Use polyfill for setImmediate for performance gains
  Promise._immediateFn = (typeof setImmediate === 'function' && function (fn) { setImmediate(fn); }) ||
    function (fn) {
      setTimeoutFunc(fn, 0);
    };

  Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {
    if (typeof console !== 'undefined' && console) {
      console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console
    }
  };

  /**
   * Set the immediate function to execute callbacks
   * @param fn {function} Function to execute
   * @deprecated
   */
  Promise._setImmediateFn = function _setImmediateFn(fn) {
    Promise._immediateFn = fn;
  };

  /**
   * Change the function to execute on unhandled rejection
   * @param {function} fn Function to execute on unhandled rejection
   * @deprecated
   */
  Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {
    Promise._unhandledRejectionFn = fn;
  };

  module.exports = Promise;

})();

2019-11-04

生产者

TODO List:

2019-10-31

数据库主从问题

参考链接

为什么主从

Master负责写操作的负载，也就是说一切写的操作都在Master上进行，而读的操作则分摊到Slave上进行。这样一来的可以大大提高读取的效率。
在一般的互联网应用中，经过一些数据调查得出结论，读/写的比例大概在 10：1左右，也就是说大量的数据操作是集中在读的操作，这也就是为什么我们会有多个Slave的原因。

为什么分离

因为写操作涉及到锁的问题，不管是行锁还是表锁还是块锁，都是比较降低系统执行效率的事情。我们这样的分离是把写操作集中在一个节点上，而读操作其其他的N个节点上进行，从另一个方面有效的提高了读的效率，保证了系统的高可用性。

问题？

数据库集群,读写分离现在可以说是项目必备的了，但是我们如何保证其每个数据库的数据一致性

2019-09-11

傅里叶变换

链接

2019-09-06

常用数学知识归纳

链接

2019-09-04

git指南

Git基础

gitbook

Git 和其它版本控制系统（包括 Subversion 和近似工具）的主要差别在于 Git 对待数据的方法。

概念上来区分，其它大部分系统以文件变更列表的方式存储信息。这类系统（CVS、Subversion、Perforce、Bazaar 等等）将它们保存的信息看作是一组基本文件和每个文件随时间逐步累积的差异。反之，Git 更像是把数据看作是对小型文件系统的一组快照。每次你提交更新，或在 Git 中保存项目状态时，它主要对当时的全部文件制作一个快照并保存这个快照的索引。为了高效，如果文件没有修改，Git 不再重新存储该文件，而是只保留一个链接指向之前存储的文件。 Git 对待数据更像是一个快照流。

Git 的分支实质上仅是包含所指对象校验和（长度为 40 的 SHA-1 值字符串）的文件，所以它的创建和销毁都异常高效。创建一个新分支就相当于往一个文件中写入 41 个字节（40 个字符和 1 个换行符），如此的简单能不快吗？

这与过去大多数版本控制系统形成了鲜明的对比，它们在创建分支时，将所有的项目文件都复制一遍，并保存到一个特定的目录。完成这样繁琐的过程通常需要好几秒钟，有时甚至需要好几分钟。所需时间的长短，完全取决于项目的规模。而在 Git 中，任何规模的项目都能在瞬间创建新分支。同时，由于每次提交都会记录父对象，所以寻找恰当的合并基础（译注：即共同祖先）也是同样的简单和高效。这些高效的特性使得 Git 鼓励开发人员频繁地创建和使用分支。

2019-09-03

调用堆栈

执行上下文的类型

全局执行上下文：只有一个，浏览器中的全局对象是window对象，node里面是global。
函数执行上下文：多个，只有在函数被调用的时候才会被创建，每次调用函数都会创建一个新的执行上下文。
Eval函数执行上下文：指运行在eval函数中的代码，很少用且不建议使用。

执行栈

2019-08-12

二进制1的个数

最简单的方式

1	const n = num => num.toString(2).replace(/0/g, '').length

就只有这样？

ZY

芝兰生于深谷，不以无人而不芳君子修身养德，不以穷困而改志

动态规划

svelte介绍

Why do frameworks use the virtual DOM then?

snippets

debounce

deepclone

objectFilter对象根据属性过滤

观察者模式

手写Promise

生产者

数据库主从问题

为什么主从

为什么分离

问题？

傅里叶变换

常用数学知识归纳

git指南

Git基础

调用堆栈

执行上下文的类型

执行栈

二进制1的个数