lihuakkk / blog Goto Github PK

const h1Element = document.createElement('h1');
h1Element.innerText = ctrl.title;

document.createElement('h1').nodeName;

"scripts": {
  ...,
  "compile": "ngc"
}

"scripts": {
    npm run compile
}

<h1>Hi, {{title + title}}</h1>

const safeDistance = 180;

function isFocus() {
  return document.hasFocus();
}

function ifChatting(chatId, element) {
  if (!element) return false;
  // 聊天对象是目标
  const isCurrentChatItem = currentChatId === chatId;
  // 聊天面板在底部或者距离底部只有一点距离
  const { scrollHeight, clientHeight, scrollTop } = element;
  const isSafeDistance = scrollHeight === clientHeight || scrollHeight - clientHeight - scrollTop < safeDistance;
  // isFocus 当前窗口获取焦点
  return isFocus() && isCurrentChatItem && isSafeDistance;
}

const chatting = ifChatting(chatId, scrollElement);
if (chatting || isSelfSend) {
  // 新增未读
  addReadMask()
  // 新消息提示
  newNotifatication()
  // 滚动到底部
  scrollBottom()
}

const childZone = Zone.current.fork(ZoneSpec);
childZone.run(Fn)。

const parentZoneSpec = {
  name: 'parentZone',
  onInvokeTask(parentZoneDelegate, currentZone, targetZone, task) {
    console.log('parentZoneSpec, onInvokeTask');
    return parentZoneDelegate.invokeTask(targetZone, task);
  },
  onFork(parentZoneDelegate, currentZone, targetZone, zoneSpec) {
    console.log('parentZone onFork');
    return parentZoneDelegate.fork(targetZone, zoneSpec)
  }
}

const childZoneSpec = {
  name: 'childZone',
  onInvoke(parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source) {
    console.log('childZone > onInvoke', arguments);
    return parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source);
  },
  onFork(parentZoneDelegate, currentZone, targetZone, zoneSpec) {
    console.log('childZoneSpec onFork');
    return parentZoneDelegate.fork(targetZone, zoneSpec)
  },
  onInvokeTask(parentZoneDelegate, currentZone, targetZone, task) {
    console.log('childZoneSpec, onInvokeTask');
    return parentZoneDelegate.invokeTask(targetZone, task);
  },
}

const grandSonZoneSpec = {
  name: 'grandSonZone',
}

function settime() {
  console.log('settime Schedule')
  setTimeout(function() {
    console.log('settime callback')
  }, 1000)
}

const grandSonZone = Zone.current.fork(parentZoneSpec).fork(childZoneSpec);
grandSonZone.run(settime)

parentZone onFork
childZone > onInvoke
normal function
childZoneSpec, onInvokeTask
parentZoneSpec, onInvokeTask
settime

this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS);
 ...
ZoneDelegate.prototype.fork = function (targetZone, zoneSpec) {
  return this._forkZS ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec) :
  new Zone(targetZone, zoneSpec);
};

this._zone.onMicrotaskEmpty.subscribe({next: () => { this._zone.run(() => { this.tick(); }); }});

// 消息promise封装
import { sendMessage } from 'message/index';

sendMessage({
  // pn2RequestPatch.js rules定义
  operation: 'request_offline_message',
  data: {
    /* ... */
  }
})
  .then(() => {})
  .catch(() => {})

Input: n = 1;
Return: [
  "1:00",
  "2:00",
  "4:00",
  "8:00",
  "0:01",
  "0:02",
  "0:04",
  "0:08",
  "0:16",
  "0:32"
];

var readBinaryWatch = function(num) {
  if (num === 0) return ["0:00"];
  function zuHe(array, n) {
    if (array.length === n) {
      return [array.reduce((sum, a) => sum + a)];
    }
    if (n === 1) {
      return array.concat();
    }
    let _temp = array.concat();
    const char = _temp.shift();
    return zuHe(_temp, n - 1)
      .map(item => char + item)
      .concat(zuHe(_temp, n));
  }
  const hourMap = {
    0: ["0"]
  };
  const minMap = {
    0: ["00"]
  };
  function initMap(obj, array, max, prefix) {
    let len = array.length;
    while (len > 0) {
      obj[len] = zuHe(array.concat(), len)
        .filter(item => item < max)
        .map(item => (item < 10 ? prefix + item : String(item)));
      len--;
    }
  }
  initMap(hourMap, [1, 2, 4, 8], 12, "");
  initMap(minMap, [1, 2, 4, 8, 16, 32], 60, "0");

  const result = [];
  let _num = 0;
  while (_num <= num) {
    const _hourArray = hourMap[_num];
    if (_hourArray && _hourArray.length > 0) {
      const _minArray = minMap[num - _num];
      if (_minArray && _minArray.length > 0) {
        _hourArray.forEach(_hour => {
          _minArray.forEach(_min => result.push(_hour + ":" + _min));
        });
      }
    }
    _num++;
  }
  return result;
};

/**
这种解法是将所有的灯的情况列举出来。
核心方法是zuHe这个函数，这个函数对无序排列组合的一个实现。
array表示元素，n表示从array中取几个元素进行组合。
例：array = ['a', 'b', 'c', 'd', 'e'], n = 3;
第一步：移除第一个元素'a'，在剩下的元素里面['b', 'c', 'd', 'e']中取（n-1）个进行组合，将组合结果每个加上'a'
第二部：移除第一个元素'a'，在剩下的元素里面['b', 'c', 'd', 'e']中取n个进行组合
当n=1的时候返回当前的array
当array.length === n，返回array里面每个元素相加的结果。
状态转移函数：
first = array.shift()
array2 = array

zuHe(array, n) = (first + zuHe(array2, n - 1)) + zuHe(array2, n);
if(n = 1) return array;
if(array.length === n) return array[0]+array[1]+...array[n-1]

*/

function zuHe(array, n) {
  if (array.length === n) {
    return [array.reduce((sum, a) => sum + a)];
  }
  if (n === 1) {
    return array.concat();
  }
  let _temp = array.concat();
  const char = _temp.shift();
  return zuHe(_temp, n - 1)
    .map(item => char + item)
    .concat(zuHe(_temp, n));
}

nums1 = [1, 3]
nums2 = [2]
The median is 2.0

nums1 = [1, 2]
nums2 = [3, 4]
The median is (2 + 3)/2 = 2.5

var findMedianSortedArrays = function(nums1, nums2) {
    function findIndex(arr, num, offset) {
      const length = arr.length;
      const first = arr[0];
      const last = arr[length - 1];
      const midIndex = Math.floor(length / 2);
      const mid = arr[midIndex];
      if(num <= first) {
        return offset + 0;
      }
      if(num >= last) {
        return offset + length;
      }
      if(num === mid) {
        return offset + midIndex;
      }
      if(num > mid) {
        return findIndex(arr.splice(midIndex), num, offset + midIndex);
      } else {
        return findIndex(arr.splice(0, midIndex), num, offset);
      }

    }
    function concatSortedArrays(array1, array2) {
      const len1 = array1.length;
      const len2 = array2.length;
      let dist, sour;
      if(len1 < len2) {
        dist = array2;
        sour = array1;
      } else {
        dist = array1;
        sour = array2;
      }
      for(let i = 0; i < sour.length; i++) {
        const num = sour[i];
        const insertIndex = findIndex(dist.concat(), num, 0);
        dist.splice(insertIndex, 0, num);
      }
      return dist;
    }
    const array = concatSortedArrays(nums1, nums2);
    const length = array.length;
    if(length % 2 === 0) {
      return (array[length / 2 - 1] + array[length / 2]) / 2 
    } else {
      return array[Math.floor(length/2)];
    }
};

/**
上面的解法只是我想这么做，受业务影响更倾向于找到一个通用的解法。
先将两个数组合并，然后找到中位数。
核心是findIndex这个函数，利用的二分法的**查找插入Index。
*/

compose(f, g, h) = (...args) => f(g(h(...args)))

export default function compose(...funcs) {
  if (funcs.length === 0) {
    return arg => arg
  }
  
  if (funcs.length === 1) {
    return funcs[0]
  } 
  
  return funcs.reduce((a, b) => (...args) => a(b(...args)))
}

compose(f, g, h, j) = compose(compose(f, g), h, j);
compose(f, g, h, j) = compose(f, compose(g, h, j));

function compose2(...funcs) {
  const [a, ...funcs2] = funcs;
  
  if(funcs.length === 0) {
    return arg => arg;
  }
  
  if(funcs.length === 1) {
    return funcs[0];
  }
  
  if(funcs.length === 2) {
    const [b] = funcs2;
    return (...args) => a(b(...args));
  }
  
  return compose2(...[a, compose2(...funcs2)])
}
    

@Component({
  ...
  changeDetection: ChangeDetectionStrategy.OnPush
})

var vData = someAPIForImmutables.create({
              name: 'Pascal Precht'
            });
var vData2 = vData.set('name', 'Christoph Burgdorf');
vData1 === vData2 // false

constructor(private cd: ChangeDetectorRef) {}
ngOnInit() {
  this.dataStream.subscribe(() => {
    this.counter++; // application state changed
    this.cd.markForCheck(); // marks path
  })
}}

$watchCollection => $watch => $evalAsync => $browser.defer => setTimeout

function link(scope, elem, attrs) {
  var dragulaScope = scope.dragulaScope || scope.$parent;
  var container = elem[0];
  var name = scope.$eval(attrs.dragula);
  var drake;

  var bag = dragulaService.find(dragulaScope, name);
  if (bag) {
    drake = bag.drake;
    drake.containers.push(container);
  } else {
    drake = dragula({
      containers: [container]
    });
    dragulaService.add(dragulaScope, name, drake);
  }

  scope.$watch("dragulaModel", function(newValue, oldValue) {
    if (!newValue) {
      return;
    }

    if (drake.models) {
      var modelIndex = oldValue ? drake.models.indexOf(oldValue) : -1;
      if (modelIndex >= 0) {
        drake.models.splice(modelIndex, 1, newValue);
      } else {
        drake.models.push(newValue);
      }
    } else {
      drake.models = [newValue];
    }

    dragulaService.handleModels(dragulaScope, drake);
  });
}

import { packedRequestFactroy } from 'packRequest';

function request(ids) {
  return fetch(url, {
    data: ids
  });
}

const fetchAvatar = packedRequestFactroy(request);

export { fetchAvatar };

// flexible.js 源码
(function(win, lib) {
  var doc = win.document;
  var docEl = doc.documentElement;
  var metaEl = doc.querySelector('meta[name="viewport"]');
  var flexibleEl = doc.querySelector('meta[name="flexible"]');
  var dpr = 0;
  var scale = 0;
  var tid;
  var flexible = lib.flexible || (lib.flexible = {});

  if (metaEl) {
    var match = metaEl.getAttribute('content').match(/initial\-scale=([\d\.]+)/);
    if (match) {
      scale = parseFloat(match[1]);
      dpr = parseInt(1 / scale);
    }
  } else if (flexibleEl) {
    var content = flexibleEl.getAttribute('content');
    if (content) {
      var initialDpr = content.match(/initial\-dpr=([\d\.]+)/);
      var maximumDpr = content.match(/maximum\-dpr=([\d\.]+)/);
      if (initialDpr) {
        dpr = parseFloat(initialDpr[1]);
        scale = parseFloat((1 / dpr).toFixed(2));
      }
      if (maximumDpr) {
        dpr = parseFloat(maximumDpr[1]);
        scale = parseFloat((1 / dpr).toFixed(2));
      }
    }
  }
  if (!dpr && !scale) {
    var isAndroid = win.navigator.appVersion.match(/android/gi);
    var isIPhone = win.navigator.appVersion.match(/iphone/gi);
    var devicePixelRatio = win.devicePixelRatio;
    if (isIPhone) {
      // iOS下，对于2和3的屏，用2倍的方案，其余的用1倍方案
      if (devicePixelRatio >= 3 && (!dpr || dpr >= 3)) {
        dpr = 3;
      } else if (devicePixelRatio >= 2 && (!dpr || dpr >= 2)) {
        dpr = 2;
      } else {
        dpr = 1;
      }
    } else {
      // 其他设备下，仍旧使用1倍的方案
      dpr = 1;
    }
    scale = 1 / dpr;
  }
  docEl.setAttribute('data-dpr', dpr);
  if (!metaEl) {
    metaEl = doc.createElement('meta');
    metaEl.setAttribute('name', 'viewport');
    metaEl.setAttribute(
      'content',
      'initial-scale=' +
        scale +
        ', maximum-scale=' +
        scale +
        ', minimum-scale=' +
        scale +
        ', user-scalable=no'
    );
    if (docEl.firstElementChild) {
      docEl.firstElementChild.appendChild(metaEl);
    } else {
      var wrap = doc.createElement('div');
      wrap.appendChild(metaEl);
      doc.write(wrap.innerHTML);
    }
  }
  function refreshRem() {
    var width = docEl.getBoundingClientRect().width;
    if (width / dpr > 540) {
      width = 540 * dpr;
    }
    var rem = width / 10;
    docEl.style.fontSize = rem + 'px';
    flexible.rem = win.rem = rem;
  }
  win.addEventListener(
    'resize',
    function() {
      clearTimeout(tid);
      tid = setTimeout(refreshRem, 300);
    },
    false
  );
  win.addEventListener(
    'pageshow',
    function(e) {
      if (e.persisted) {
        clearTimeout(tid);
        tid = setTimeout(refreshRem, 300);
      }
    },
    false
  );
  if (doc.readyState === 'complete') {
    doc.body.style.fontSize = 12 * dpr + 'px';
  } else {
    doc.addEventListener(
      'DOMContentLoaded',
      function(e) {
        doc.body.style.fontSize = 12 * dpr + 'px';
      },
      false
    );
  }

  refreshRem();
  flexible.dpr = win.dpr = dpr;
  flexible.refreshRem = refreshRem;
  flexible.rem2px = function(d) {
    var val = parseFloat(d) * this.rem;
    if (typeof d === 'string' && d.match(/rem$/)) {
      val += 'px';
    }
    return val;
  };
  flexible.px2rem = function(d) {
    var val = parseFloat(d) / this.rem;
    if (typeof d === 'string' && d.match(/px$/)) {
      val += 'rem';
    }
    return val;
  };
})(window, window['lib'] || (window['lib'] = {}));

const array1 = [1, 2, 3, 4];
const reducer = (accumulator, currentValue) => accumulator + currentValue;

// 1 + 2 + 3 + 4
console.log(array1.reduce(reducer));
// expected output: 10

function getNestedState (state, path) {
  return path.reduce((state, key) => state[key], state)
}

const state = {a: {b: {c: {d: 'd'}}}} 
const path = ['a', 'b', 'c']
getNestedState(state, path) 
// => { d: 'd' }

export default function compose(...funcs: Function[]) {
  if (funcs.length === 0) {
    // infer the argument type so it is usable in inference down the line
    return <T>(arg: T) => arg
  }

  if (funcs.length === 1) {
    return funcs[0]
  }

  return funcs.reduce((a, b) => (...args: any) => a(b(...args)))
}

function runPromiseByQueue(promises) {
  promises.reduce(
    (currentPromise, nextPromise) => currentPromise.then(() => nextPromise()),
    Promise.resolve()
  );
}

import uploadFileFactory from 'index';
/*
* fileList Array[formatFile]
* formatFile = {
  file: File, // 本地文件
  name,
  type,  // PICTURE | VIDEO | DOC 
  size,
  fileId,
  key,
  bucket,
  uploadStatus: 'wait', // 'wait' | 'uploading' | 'finished' | 'failed'
}
**/
const uploadCancel = uploadFileFactory(
  fileList,
  function onprogress(data) {
    // progress && speed
    console.log('progress', data);
  },
  function onerror(error) {
    console.log(error);
  },
  function onend() {
    console.log('end');
  }
);

uploadCancel(); // 取消上传

Input: 3;
Output: 3;

Input: 11
Output: 0
Explanation: 在队列1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ... 第11个数字是10中的第二个数0。

var findNthDigit = function(n) {
  if (n < 10) return n;
  let temp;
  function getN(index) {
    let sum = 0,
      n = 1;
    while (sum < index) {
      temp = sum;
      sum += 9 * Math.pow(10, n - 1) * n;
      n++;
    }
    return n - 1;
  }
  const N = getN(n);
  const _index = Math.ceil((n - temp) / N) - 1;
  const num = Math.pow(10, N - 1) + _index;
  let y = (n - temp) % N;
  if (y === 0) {
    y = N;
  }
  return ("" + num).charAt(y - 1);
};

先找到第n个数所在的数字，然后在找到对应的位置。

Input: [-2,1,-3,4,-1,2,1,-5,4]
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.

var maxSubArray = function(nums) {
  const len = nums.length;
  let lastSum;
  let max = nums[0];
  if (max < 0) {
    lastSum = 0;
  } else {
    lastSum = max;
  }
  for (let i = 1; i < len; i++) {
    const value = nums[i];
    lastSum += value;
    if (lastSum > max) {
      max = lastSum;
    }
    if (lastSum < 0) {
      lastSum = 0;
    }
  }
  return max;
};

max表示当前最大的字串和，lastSum用作探针查找比当前更大字串和。

/**
 * 二分法获取在有序数组插入新元素的位置
 * @param { sortedArray } 有序数组，可以为对象
 * @param { targetValue } 要插入的元素
 * @param { mapFn } 转换函数
 * @returns number 插入位置
 * @example
 *
 * getInsertPositionInSortedArray([{a:1}, {a:3}, 2, (item) => item.a])
 * // => 1
 * getInsertPositionInSortedArray([1, 3], 2)
 * // => 1
 */

function getInsertPositionInSortedArray(sortedArray = [], targetValue = 0, mapFn) {
  if (sortedArray.length === 0) return 0;
  if (!mapFn) {
    mapFn = value => value;
  }

  function findIndex(searchingArray, offset) {
    const length = searchingArray.length;
    const first = mapFn(searchingArray[0]);
    const last = mapFn(searchingArray[length - 1]);
    const midIndex = Math.floor(length / 2);
    const mid = mapFn(searchingArray[midIndex]);
    if (targetValue <= first) {
      return offset + 0;
    }
    if (targetValue >= last) {
      return offset + length;
    }
    if (targetValue === mid) {
      return offset + midIndex;
    }
    if (targetValue > mid) {
      return findIndex(searchingArray.splice(midIndex), offset + midIndex);
    } else {
      return findIndex(searchingArray.splice(0, midIndex), offset);
    }
  }

  return findIndex(sortedArray, 0)
}

/**
 * 全角输入转半角，通常用于搜索输入格式化
 * @param { str } 全角字符串
 * @returns number 半角字符串
 * @example
 *
 * ToCDB(`ｅ`)
 * // => 'e'
 */

function ToCDB(str) {
  var tmp = "";
  for (var i = 0; i < str.length; i++) {
    if (str.charCodeAt(i) == 12288) {
      tmp += String.fromCharCode(str.charCodeAt(i) - 12256);
      continue;
    }
    if (str.charCodeAt(i) > 65280 && str.charCodeAt(i) < 65375) {
      tmp += String.fromCharCode(str.charCodeAt(i) - 65248);
    } else {
      tmp += String.fromCharCode(str.charCodeAt(i));
    }
  }
  return tmp
}

/**
 * 获取对应的大写首字母，拼音排序时使用
 * @param { str } 字符
 * @returns str
 * @example
 *
 * getFristLetterOfCharacter('L')
 * // => 'L'
 * getFristLetterOfCharacter('l')
 * // => 'L'
 * getFristLetterOfCharacter('李')
 * // => 'L'
 * getFristLetterOfCharacter('3')
 * // => '#'
 */

function getFristLetterOfCharacter(str = '') {
  const character = str[0];
  const letters = 'ABCDEFGHJKLMNOPQRSTWXYZ';
  const specialLetter = '#';
  let firstLetter = specialLetter;

  // if (/[^\u4e00-\u9fa5]/.test(character)) {
  if (/[a-zA-Z]/.test(character)) {
    try {
      firstLetter = character.toUpperCase();
    } catch (error) {
      console.log('getFristLetterOfCharacter', firstLetter);
    }
  } else if (/[0-9]/.test(character)) {
    firstLetter = specialLetter;
  } else {
    const boundaryChar = '驁簿錯鵽樲鰒餜靃攟鬠纙鞪黁漚曝裠鶸蜶籜鶩鑂韻糳';
    try {
      if (!String.prototype.localeCompare) {
        throw Error('String.prototype.localeCompare not supported.');
      }
      for (let i = 0; i < boundaryChar.length; i++) {
        if (boundaryChar[i].localeCompare(character, 'zh-CN-u-co-pinyin') >= 0) {
          firstLetter = letters[i];
          break;
        }
      }
    } catch (e) {
      console.log('getFristLetterOfCharacter', e);
    }
  }
  return firstLetter;
}

/**
 * 根据字符的首字母进行排序
 * @param { sortArray } 要排序的数组
 * @returns `{"A":[],"B":[],"C":[],"D":[],"E":[],"F":[],"G":[],"H":[],"I":[],"J":[],"K":[],"L":["李","l"],"M":[],"N":[],"O":[],"P":[],"Q":[],"R":[],"S":["s"],"T":[],"U":[],"V":[],"W":[],"X":[],"Y":[],"Z":[],"#":[]}`
 * @example
 *
 * sortByFirstLetter(['l','s','李'])
 * // => `{"A":[],"B":[],"C":[],"D":[],"E":[],"F":[],"G":[],"H":[],"I":[],"J":[],"K":[],"L":["李","l"],"M":[],"N":[],"O":[],"P":[],"Q":[],"R":[],"S":["s"],"T":[],"U":[],"V":[],"W":[],"X":[],"Y":[],"Z":[],"#":[]}`
 */

function sortByFirstLetter(sortArray = [], mapFn) {
  const _sortArray = sortArray.concat([]);
  if (!mapFn) {
    mapFn = value => value;
  }

  if (!typeof mapFn === 'function') {
    return _sortArray;
  }

  const sortMap = {
    // '#': []
  };
  const [charCodeStart, charCodeEnd] = ['A'.charCodeAt(), 'Z'.charCodeAt()];
  // init sortMap
  for (let code = charCodeStart; code <= charCodeEnd; code++) {
    sortMap[String.fromCharCode(code)] = [];
  }

  sortMap['#'] = [];

  _sortArray.forEach(item => {
    const firstLetter = getFristLetterOfCharacter(mapFn(item));
    sortMap[firstLetter].push(item);
  });

  //排序
  for (const firstLetter in sortMap) {
    const list = sortMap[firstLetter];
    if (list.length != 0) {
      list.sort((a, b) => mapFn(a).localeCompare(mapFn(b), 'zh-CN-u-co-pinyin'));
    }
  }

  return sortMap;
}

/**
 * 检测当前操作系统
 * @returns windows | mac | linux | web
*/

function detectOs() {
  let ua = navigator.userAgent
  let isWin = (navigator.platform == "Win32") || (navigator.platform == "Windows")
  let isMac = (navigator.platform == "Mac68K") || (navigator.platform == "MacPPC") || (navigator.platform == "Macintosh") || (navigator.platform == "MacIntel")
  let isUnix = (navigator.platform == "X11") && !isWin && !isMac
  if (isWin) return 'windows'
  if (isMac) return 'mac'
  if (isUnix) return 'linux'
  return 'web'
}

/**
 * 检测当前操作系统的时间与系统时间偏移
*/

let offset = 0;

function getLocalTime() {
  return Date.now()
}

// 默认请求往返耗时相同
// 接口响应速度越快，修正的时间越准
// 允许存在0.5s的时间错位
function syncServeTimestamp() {
  const obj = {
    requestTime: getLocalTime()
  }
  return getServeTime()
    .then(res => {
      obj.responseTime = getLocalTime()
      obj.serverTime = res.data.data;
      const trafficSpend = (obj.responseTime - obj.requestTime) / 2;
      const currentTime = obj.serverTime - trafficSpend; // 请求发出去的时候服务器时间
      offset = Math.floor((currentTime - obj.requestTime));
      if (Math.abs(offset) <= 500) {
        offset = 0
      }
      console.log(`比服务器时间${offset > 0 ? '慢' : '快' }，${Math.abs(offset / 1000)}秒`);
    })
    .catch(error => {
      console.log('get serveTime error', error);
      throw(error);
    })
}

function getCurrentTime() {
  return Date.now() + offset
}

/**
 * 异步函数未结束前再次调用无效
 * @param { asyncFn } 要lock的异步函数
 * @param { identity } 标识，通常时函数名
 * @returns function
 * @example
 * 
 * fn = promisePendingLock(asyncFn))
 * fn() // 返回正确promise
 * fn() // 返回error pendingLocked
 */

export function promisePendingLock(asyncFn, identity) {
  identity = identity || asyncFn.name;
  let asyncFnStatus = 'wait';
  return (...params) => {
    if (asyncFnStatus === 'wait') {
      asyncFnStatus = 'execute';
      return asyncFn(...params)
        .then(r => {
          asyncFnStatus = 'wait';
          return r;
        })
        .catch(e => {
          asyncFnStatus = 'wait';
          throw(e)
        });
    }
    asyncFnStatus = 'pendingLocked';
    return Promise.reject('pendingLocked')
  };
}

/**
 * lodash 节流函数
 */

export function throttle(func, wait) {
  let ctx, args, rtn, timeoutID; // caching
  let last = 0;

  return function throttled() {
    ctx = this;
    args = arguments;
    let delta = new Date() - last;
    if (!timeoutID)
      if (delta >= wait) call();
      else timeoutID = setTimeout(call, wait - delta);
    return rtn;
  };

  function call() {
    timeoutID = 0;
    last = +new Date();
    rtn = func.apply(ctx, args);
    ctx = null;
    args = null;
  }
}

/**
 * 获取对象中指定的key
 * @param { object } 目标对象
 * @param { keys } 数组，指定获取的key
 * @returns object
 * @example
 * 
 * pick({a: '1', b: '2', c: '3'}, ['a', 'c'])
 * // => {a: '1', c: '3'}
 */

function pick(object, keys) {
  return keys.reduce((obj, key) => {
    if (object && object.hasOwnProperty(key)) {
      obj[key] = object[key];
    }
    return obj;
  }, {});
}

/**
 * 邮箱格式
 */

function checkEmail(email) {
  const reg = /\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*/
  return reg.test(email);
}

function Ctrl($interval, $scope) {
  $interval(function() {
      $scope.m = 'mm';
  }, 10 * 1000)
}

$scope.$on('$destroy', function() {
  $interval.cancel(intervalId);
})

UserService.onNameChange(function(newName) {
  $scope.userName = newName;
});

Input: [2,2,1]
Output: 1

Input: [4,1,2,1,2]
Output: 4

var singleNumber = function(nums) {
    return nums.reduce((result, num) => result ^= num, 0);
};

a ^ b = b ^ a
(a ^ b) ^ c = a ^ (b ^ c)
a ^ a = 0
a ^ 0 = a
a ^ b ^ b ^ c ^ c = a ^ 0 ^ 0 = a

Input: a = 1, b = 2
Output: 3

Input: a = -2, b = 3
Output: 1

var getSum = function(a, b) {
    return b === 0 ? a : getSum(a^b, (a&b) << 1);
};

/**
    10101010
  + 01001010

  通过a^b相加对应的比特位，通过a&b获取进位的比特位
*/

import localName from 'localName';

localName.set('gittttt')
localName.get() // gittttt

localName.remove() 
localName.get() // null

ng new ivy-internals

"angularCompilerOptions": {
  "enableIvy": true
}

node_modules/.bin/ngc

 i0.ɵE(0, "div", _c0);
 i0.ɵE(1, "h1");
 i0.ɵT(2);
 i0.ɵe();
 i0.ɵE(3, "img", _c1);
 i0.ɵe();
 i0.ɵe();
 i0.ɵE(4, "h2");
 i0.ɵT(5, "Here are some links to help you start: ");
 i0.ɵe();

var i0 = require("@angular/core");

var core = require("angular/core");
//...
core.elementStart(0, "div", _c0);
core.elementStart(1, "h1");
core.text(2);
core.elementEnd();
core.elementStart(3, "img", _c1);
core.elementEnd();
core.elementEnd();
core.elementStart(4, "h2");
core.text(5, "Here are some links to help you start: ");
core.elementEnd();

import { Component } from '@angular/core';

@Component({
selector: 'manual-component',
template: '<h2>Hello, Component</h2>',
})

export class ManualComponent {
}

import * as core from '@angular/core';

export class ManualComponent {
  static ngComponentDef = core.ɵdefineComponent({
    type: ManualComponent,
    selectors: [['manual-component']],
    factory: () => new ManualComponent(),
    template: (rf: core.ɵRenderFlags, ctx: ManualComponent) => {
      // Compiled template goes here
    },
  });
}

template: (rf: core.ɵRenderFlags, ctx: ManualComponent) => {
      core.ɵE(0, 'h2');                 // Open h2 element
      core.ɵT(1, 'Hello, Component');   // Add text
      core.ɵe();                        // Close h2 element
    },

core.ɵrenderComponent(ManualComponent);

export class ManualComponent {
  name = 'Component';

  updateName(newName: string) {
    this.name = newName;
  }
  
  // ...
}

template: (rf: core.ɵRenderFlags, ctx: ManualComponent) => {
  if (rf & 1) {   // Create: This runs only on first render
    core.ɵE(0, 'h2'); 
    core.ɵT(1, 'Hello, ');
    core.ɵT(2);   // <-- Placeholder for the name
    core.ɵe();
  }
  if (rf & 2) {   // Update: This runs on every change detection
   core.ɵt(2, ctx.name);  // ctx is our component instance
  }
},

template: (rf: core.ɵRenderFlags, ctx: ManualComponent) => {
  if (rf & 1) {
    core.ɵE(0, 'h2'); 
    core.ɵT(1, 'Hello, ');
    core.ɵT(2);
    core.ɵe();
    core.ɵT(3, 'Your name: ');
    core.ɵE(4, 'input'); 
    core.ɵL('input', $event => ctx.updateName($event.target.value));
    core.ɵe();
  }
  // ...
},

template: (rf: core.ɵRenderFlags, ctx: ManualComponent) => {
  if (rf & 1) { ... }
  if (rf & 2) {
    core.ɵt(2, ctx.name);
    core.ɵp(4, 'value', ctx.name);
  }
}

static ngComponentDef = core.ɵdefineComponent({
  directives: [NgIf],
  // ...
});

function ifTemplate(rf: core.ɵRenderFlags, ctx: ManualComponent) {
  if (rf & 1) {
    core.ɵE(0, 'div');
    core.ɵE(1, 'img', ['src', 'https://pbs.twimg.com/tweet_video_thumb/C80o289UQAAKIqp.jpg']);
    core.ɵe();
  }
}

template: (rf: core.ɵRenderFlags, ctx: ManualComponent) => {
  if (rf & 1) {
    // ...
    core.ɵC(5, ifTemplate, null, ['ngIf']);
  }
  if (rf & 2) {
    // ...
    core.ɵp(5, 'ngIf', (ctx.name === 'Igor'));
  }

  function ifTemplate(rf: core.ɵRenderFlags, ctx: ManualComponent) {
    // ...
  }
},