const isUrl = urlStr => {
    try {
        const { href, origin, host, hostname, pathname } = new URL(urlStr)
        return href && origin && host && hostname && pathname && true
    } catch (e) {
        return false
    }
}

/**
 * 
 * @param {number[]} arr1 
 * @param {number} m 
 * @param {number[]} arr2 
 * @param {number} n 
 */
function merge(arr1,m,arr2,n) {
    let i=m-1,j=n-1,k=m+n-1;
    while (i>=0 && j>=0) {
        if(arr1[i]>arr2[j]){
            arr1[k]=arr1[i]
            i--
            k--
        }else{
            arr1[k]=arr2[j]
            j--
            k--
        }
    }
    while(j>=0){
        arr1[k]=arr2[j]
        j--
        k--
    }
}
let nums1=[1,3,5,7]
let nums2=[2,4,6,7,12,16]
merge(nums1,4,nums2,6)

LazyMan('Tom');
// Hi I am Tom

LazyMan('Tom').sleep(10).eat('lunch');
// Hi I am Tom
// 等待了10秒...
// I am eating lunch

LazyMan('Tom').eat('lunch').drink('500ml牛奶').sleep(10).eat('dinner')
// Hi I am Tom
// I am eating lunch
//喝了500ml牛奶...
// 等待了10秒...
// I am eating diner

LazyMan('Tom').eat('lunch').eat('dinner').sleepFirst(5).sleep(10).eat('junk food').drink('10000ml奶茶');
// Hi I am Tom
// 等待了5秒...
// I am eating lunch
// I am eating dinner
// 等待了10秒...
// I am eating junk food
//喝了10000ml奶茶...

function Foo() {
    Foo.a = function() {
        console.log(1)
    }
    this.a = function() {
        console.log(2)
    }
}
Foo.prototype.a = function() {
    console.log(3)
}
Foo.a = function() {
    console.log(4)
}
Foo.a();
let obj = new Foo();
obj.a();
Foo.a();

function Foo() {
    Foo.a = function() {
        console.log(1)
    }
    this.a = function() {
        console.log(2)
    }
}
// 以上只是 Foo 的构建方法，没有产生实例，此刻也没有执行
Foo.prototype.a = function() {
    console.log(3)
}
// 现在在 Foo 上挂载了原型方法 a ，方法输出值为 3
Foo.a = function() {
    console.log(4)
}
// 现在在 Foo 上挂载了直接方法 a ，输出值为 4

Foo.a();
// 立刻执行了 Foo 上的 a 方法，也就是刚刚定义的，所以
// # 输出 4

let obj = new Foo();
/* 这里调用了 Foo 的构建方法。Foo 的构建方法主要做了两件事：
1. 将全局的 Foo 上的直接方法 a 替换为一个输出 1 的方法。
2. 在新对象上挂载直接方法 a ，输出值为 2。
*/

obj.a();
// 因为有直接方法 a ，不需要去访问原型链，所以使用的是构建方法里所定义的 this.a，
// # 输出 2

Foo.a();
// 构建方法里已经替换了全局 Foo 上的 a 方法，所以
// # 输出 1

var a = {n: 1};
var b = a;
a.x = a = {n: 2};

console.log(a.x) 	
console.log(b.x)

/* -- 位运算 -- */
// 先定义位运算加法
function bitAdd(m, n){
    while(m){
        [m, n] = [(m & n) << 1, m ^ n];
    }
    return n;
}

// 位运算实现方式 1 - 循环累加7次
let multiply7_bo_1 = (num)=>
{
  let sum = 0,counter = new Array(7); // 得到 [empty × 7]
  while(counter.length){
    sum = bitAdd(sum, num);
    counter.shift();
  }
  return sum;
}

// 位运算实现方式 2 - 二进制进3位(乘以8)后，加自己的补码(乘以-1)
let multiply7_bo_2 = (num) => bitAdd(num << 3, -num) ;

/* -- JS hack -- */

// hack 方式 1 - 利用 Function 的构造器 & 乘号的字节码
let multiply7_hack_1 = (num) => 
    new Function(["return ",num,String.fromCharCode(42),"7"].join(""))();

// hack 方式 2 - 利用 eval 执行器 & 乘号的字节码
let multiply7_hack_2 = (num) => 
		eval([num,String.fromCharCode(42),"7"].join(""));

// hack 方式 3 - 利用 SetTimeout 的参数 & 乘号的字节码
setTimeout(["window.multiply7_hack_3=(num)=>(7",String.fromCharCode(42),"num)"].join(""))

/* -- 进制转换 -- */

// 进制转换方式 - 利用 toString 转为七进制整数；然后末尾补0(左移一位)后通过 parseInt 转回十进制
let multiply7_base7 = 
    (num)=>parseInt([num.toString(7),'0'].join(''),7);

function print(n){
  setTimeout(() => {
    console.log(n);
  }, Math.floor(Math.random() * 1000));
}
for(var i = 0; i < 100; i++){
  print(i);
}

function print(n){
  setTimeout((() => {
    console.log(n)
    return ()=>{}
  }).call(n,[]), Math.floor(Math.random() * 1000));
}
for(var i = 0; i < 100; i++){
  print(i);
}

function Stack(){
    let items=[]
    this.push=function(item){
        items.push(item)
    }
    this.pop=function () {
        return items.pop()
    }
    this.peek=function () {
        return items[items.length-1]
    }
    this.clear=function(){
        items=[]
    }
    this.print=function () {
        console.log(items.toString())
    }
    this.size=function(){
        return items.length()
    }
    this.isEmpty=function(){
        return items.length==0
    }

}

class Stack{
    constructor(){
        this.items=[]
    }
    push(item){
        this.items.push(item)
    }
    pop(){
        return this.items.pop()
    }
    peek(){
        let length=this.items.length
        return this.items[length-1]
    }
    isEmpty(){
        return this.items.length==0
    }
    clear(){
        this.items=[]
    }
    size(){
        return this.items.length
    }
    print(){
        console.log(this.items.toString())
    }
}

function Queue() {
    let items=[]
    this.enqueue=function (item) {
        items.push(item)
    }
    this.dequeue=function () {
        return items.shift()
    }
    this.front=function(){
        return items[0]
    }
    this.isEmpty=function(){
        return items.length==0
    }
    this.size=function(){
        return items.length
    }
    this.print=function(){
        console.log(items.toString())
    }
}

let Queue=(function () {
    let items=new WeakMap()
    class Queue{
        constructor(){
            items.set(this,[])
        }
        enqueue(item){
            let arr=items.get(this)
            arr.push(item)
        }
        dequeue(){
            let arr=items.get(this)
            return arr.shift()
        }
        front(){
            let arr=items.get(this)
            return arr[0]
        }
        isEmpty(){
            let arr=items.get(this)
            return arr.length==0
        }
        size(){
            let arr=items.get(this)
            return arr.length
        }
        print(){
            let arr=items.get(this)
            console.log(arr.toString())
        }
    }
    return Queue
})()

function changeObjProperty(o) {
  o.siteUrl = "http://www.baidu.com"
  o = new Object()
  o.siteUrl = "http://www.google.com"
} 
let webSite = new Object();
changeObjProperty(webSite);
console.log(webSite.siteUrl);

function getmaxlen(str){
   if(str){
       let matchStr=str.match(/(\w)\1*/g);
       let lenArr=matchStr.map(item=>item.length);
       let maxLen=Math.max(...lenArr);
       return matchStr.reduce((res,cur)=>{
                if(cur.length===maxLen){
                  res[cur]=maxLen
                }
                return res
              },{})
   }
   return {}
}
getmaxlen('abbkejsbcccwqaa')
// => {ccc: 3}

输入: nums = [1,2,3]
输出:
[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

const computedWatcherOptions = { computed: true }
function initComputed (vm: Component, computed: Object) {
  // $flow-disable-line
  const watchers = vm._computedWatchers = Object.create(null)
  // computed properties are just getters during SSR
  const isSSR = isServerRendering()

  for (const key in computed) {
    const userDef = computed[key]
    const getter = typeof userDef === 'function' ? userDef : userDef.get
    if (process.env.NODE_ENV !== 'production' && getter == null) {
      warn(
        `Getter is missing for computed property "${key}".`,
        vm
      )
    }

    if (!isSSR) {
      // create internal watcher for the computed property.
      watchers[key] = new Watcher(
        vm,
        getter || noop,
        noop,
        computedWatcherOptions
      )
    }

    // component-defined computed properties are already defined on the
    // component prototype. We only need to define computed properties defined
    // at instantiation here.
    if (!(key in vm)) {
      defineComputed(vm, key, userDef)
    } else if (process.env.NODE_ENV !== 'production') {
      if (key in vm.$data) {
        warn(`The computed property "${key}" is already defined in data.`, vm)
      } else if (vm.$options.props && key in vm.$options.props) {
        warn(`The computed property "${key}" is already defined as a prop.`, vm)
      }
    }
  }
}

export function defineComputed (
  target: any,
  key: string,
  userDef: Object | Function
) {
  const shouldCache = !isServerRendering()
  if (typeof userDef === 'function') {
    sharedPropertyDefinition.get = shouldCache
      ? createComputedGetter(key)
      : userDef
    sharedPropertyDefinition.set = noop
  } else {
    sharedPropertyDefinition.get = userDef.get
      ? shouldCache && userDef.cache !== false
        ? createComputedGetter(key)
        : userDef.get
      : noop
    sharedPropertyDefinition.set = userDef.set
      ? userDef.set
      : noop
  }
  if (process.env.NODE_ENV !== 'production' &&
      sharedPropertyDefinition.set === noop) {
    sharedPropertyDefinition.set = function () {
      warn(
        `Computed property "${key}" was assigned to but it has no setter.`,
        this
      )
    }
  }
  Object.defineProperty(target, key, sharedPropertyDefinition)
}

function createComputedGetter (key) {
  return function computedGetter () {
    const watcher = this._computedWatchers && this._computedWatchers[key]
    if (watcher) {
      watcher.depend()
      return watcher.evaluate()
    }
  }
}

var vm = new Vue({
  data: {
    firstName: 'Foo',
    lastName: 'Bar'
  },
  computed: {
    fullName: function () {
      return this.firstName + ' ' + this.lastName
    }
  }
})

constructor (
  vm: Component,
  expOrFn: string | Function,
  cb: Function,
  options?: ?Object,
  isRenderWatcher?: boolean
) {
  // ...
  if (this.computed) {
    this.value = undefined
    this.dep = new Dep()
  } else {
    this.value = this.get()
  }
}  

/**
  * Depend on this watcher. Only for computed property watchers.
  */
depend () {
  if (this.dep && Dep.target) {
    this.dep.depend()
  }
}

/**
  * Evaluate and return the value of the watcher.
  * This only gets called for computed property watchers.
  */
evaluate () {
  if (this.dirty) {
    this.value = this.get()
    this.dirty = false
  }
  return this.value
}

/* istanbul ignore else */
if (this.computed) {
  // A computed property watcher has two modes: lazy and activated.
  // It initializes as lazy by default, and only becomes activated when
  // it is depended on by at least one subscriber, which is typically
  // another computed property or a component's render function.
  if (this.dep.subs.length === 0) {
    // In lazy mode, we don't want to perform computations until necessary,
    // so we simply mark the watcher as dirty. The actual computation is
    // performed just-in-time in this.evaluate() when the computed property
    // is accessed.
    this.dirty = true
  } else {
    // In activated mode, we want to proactively perform the computation
    // but only notify our subscribers when the value has indeed changed.
    this.getAndInvoke(() => {
      this.dep.notify()
    })
  }
} else if (this.sync) {
  this.run()
} else {
  queueWatcher(this)
}

this.getAndInvoke(() => {
  this.dep.notify()
})

getAndInvoke (cb: Function) {
  const value = this.get()
  if (
    value !== this.value ||
    // Deep watchers and watchers on Object/Arrays should fire even
    // when the value is the same, because the value may
    // have mutated.
    isObject(value) ||
    this.deep
  ) {
    // set new value
    const oldValue = this.value
    this.value = value
    this.dirty = false
    if (this.user) {
      try {
        cb.call(this.vm, value, oldValue)
      } catch (e) {
        handleError(e, this.vm, `callback for watcher "${this.expression}"`)
      }
    } else {
      cb.call(this.vm, value, oldValue)
    }
  }
}

if (opts.watch && opts.watch !== nativeWatch) {
  initWatch(vm, opts.watch)
}

function initWatch (vm: Component, watch: Object) {
  for (const key in watch) {
    const handler = watch[key]
    if (Array.isArray(handler)) {
      for (let i = 0; i < handler.length; i++) {
        createWatcher(vm, key, handler[i])
      }
    } else {
      createWatcher(vm, key, handler)
    }
  }
}

function createWatcher (
  vm: Component,
  expOrFn: string | Function,
  handler: any,
  options?: Object
) {
  if (isPlainObject(handler)) {
    options = handler
    handler = handler.handler
  }
  if (typeof handler === 'string') {
    handler = vm[handler]
  }
  return vm.$watch(expOrFn, handler, options)
}

Vue.prototype.$watch = function (
  expOrFn: string | Function,
  cb: any,
  options?: Object
): Function {
  const vm: Component = this
  if (isPlainObject(cb)) {
    return createWatcher(vm, expOrFn, cb, options)
  }
  options = options || {}
  options.user = true
  const watcher = new Watcher(vm, expOrFn, cb, options)
  if (options.immediate) {
    cb.call(vm, watcher.value)
  }
  return function unwatchFn () {
    watcher.teardown()
  }

if (options) {
  this.deep = !!options.deep
  this.user = !!options.user
  this.computed = !!options.computed
  this.sync = !!options.sync
  // ...
} else {
  this.deep = this.user = this.computed = this.sync = false
}

var vm = new Vue({
  data() {
    a: {
      b: 1
    }
  },
  watch: {
    a: {
      handler(newVal) {
        console.log(newVal)
      }
    }
  }
})
vm.a.b = 2

watch: {
  a: {
    deep: true,
    handler(newVal) {
      console.log(newVal)
    }
  }
}

get() {
  let value = this.getter.call(vm, vm)
  // ...
  if (this.deep) {
    traverse(value)
  }
}

import { _Set as Set, isObject } from '../util/index'
import type { SimpleSet } from '../util/index'
import VNode from '../vdom/vnode'

const seenObjects = new Set()

/**
 * Recursively traverse an object to evoke all converted
 * getters, so that every nested property inside the object
 * is collected as a "deep" dependency.
 */
export function traverse (val: any) {
  _traverse(val, seenObjects)
  seenObjects.clear()
}

function _traverse (val: any, seen: SimpleSet) {
  let i, keys
  const isA = Array.isArray(val)
  if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
    return
  }
  if (val.__ob__) {
    const depId = val.__ob__.dep.id
    if (seen.has(depId)) {
      return
    }
    seen.add(depId)
  }
  if (isA) {
    i = val.length
    while (i--) _traverse(val[i], seen)
  } else {
    keys = Object.keys(val)
    i = keys.length
    while (i--) _traverse(val[keys[i]], seen)
  }
}

get() {
  if (this.user) {
    handleError(e, vm, `getter for watcher "${this.expression}"`)
  } else {
    throw e
  }
},
getAndInvoke() {
  // ...
  if (this.user) {
    try {
      this.cb.call(this.vm, value, oldValue)
    } catch (e) {
      handleError(e, this.vm, `callback for watcher "${this.expression}"`)
    }
  } else {
    this.cb.call(this.vm, value, oldValue)
  }
}

update () {
  if (this.computed) {
    // ...
  } else if (this.sync) {
    this.run()
  } else {
    queueWatcher(this)
  }
}

let regex = /\d{2,5}?/g;
let string = "123 1234 12345 123456";
console.log( string.match(regex) ); 
// => ["12", "12", "34", "12", "34", "12", "34", "56"]

let regex = /\d{2,5}/g;
let string = "123 1234 12345 123456";
console.log( string.match(regex) ); 
// => ["123", "1234", "12345", "12345"]

// 例如要匹配"good"和"nice"可以使用/good|nice/。
// 测试如下：
let regex = /good|nice/g;
let string = "good idea, nice try.";
console.log( string.match(regex) ); 
// => ["good", "nice"]
//但有个事实我们应该注意，比如我用/good|goodbye/，去匹配"goodbye"字符串时，
//结果是"good"：
let regex = /good|goodbye/g;
let string = "goodbye";
console.log( string.match(regex) ); 
// => ["good"]
//把正则改成/goodbye|good/，结果是：
let regex = /goodbye|good/g;
let string = "goodbye";
console.log( string.match(regex) ); 
// => ["goodbye"]
//也就是说，分支结构也是惰性的，即当前面的匹配上了，后面的就不再尝试了。

//要求从 <div id="container" class="main"></div> 提取出id="container"
// 最开始想到的正则可能是
let regex=/id=".*"/
let str="<div id="container" class="main"></div>"
console.log(str.match(regex))
//=> id="container" class="main"
// 因为.是通配符，本身就匹配双引号的，而量词*又是贪婪的，当遇到container后面的双引号时，又不会停下来，就会继续匹配，直到遇到最后一个双引号为止

//

let regex=/id=".*?"/
let str="<div id="container" class="main"></div>"
console.log(str.match(regex))
//=> id="container"

const s = new Set([1,2,3,4,1,2,3,4,2,2,2,3,3,4])
for(let i of s){
  console.log(i) // 1、2、3、4
}
// 去除重复的数组对象
[...s] // [1, 2, 3, 4]  Set 转 Array

let s = new Set();
let a = NaN;
let b= NaN;
s.add(a);
s.add(b);
console.log(s,a==b) // Set(1) {NaN} false

let s1= new Set();
s1.add(3);
s1.add('3');
console.log([...s1]) // [3, "3"]

let s = new Set([1,2,3,2,1,3,4,5,3,2,1,2,3,5]);
console.log(s.size) // 5

let s = new Set()
s.add(1).add(2).add(3).add(1)
s.has(1) // true
s.has(0) // false
s.delete(1)
s.has(1) //false
console.log(s) //Set(2) {2, 3}
s.clear()
console.log(s) //Set(0) {}

// 利用ES6扩展**...*** 运算符
let set = new Set([1,2,3,4,5])
console.log([...set]) //[1, 2, 3, 4, 5]

// 利用 Array.from()
console.log(Array.from(set)) // [1, 2, 3, 4, 5]

let set = new Set([1,2,3,4,5])
let keys=set.keys();
let entries=set.entries();
console.log(keys) //SetIterator {1, 2, 3, 4, 5}
console.log(set.values()) //SetIterator {1, 2, 3, 4, 5}
console.log(entries) //SetIterator {1 => 1, 2 => 2, 3 => 3, 4 => 4, 5 => 5}

for(let item of keys){
   console.log(item) // 1  2  3  4  5
}
for(let item of entries){
   console.log(item) // [1,1]  [2,2]  [3,3]  [4,4]  [5,5]  
}
set.forEach((value,key)=>{
  console.log(key+":"+value) // 1:1  2:2  3:3  4:4  5:5  
})

Set.prototype[Symbol.iterator]===Set.prototype.values // true

let set = new Set([1,2,3,4,5])
set=new Set([...set].map(item=>item*item))
console.log([...set]) //[1, 4, 9, 16, 25]

set=new Set([...set].filter(item=>item>10))
console.log([...set]) //[16, 25]

let set1 = new Set([1,2,3]);
let set2 = new Set([0,2,4]);
let intersect= new Set([...set1].filter(item=>set2.has(item)))
let union= new Set([...set1,...set2])
let difference= new Set([...set1].filter(item=>!set2.has(item)))

console.log(intersect) //Set(1) {2}
console.log(union) //Set(5) {1,2,3,0,4}
console.log(difference) //Set(2) {1,3}

var testobj={
    num: 0,
    str: '',
    boolean: true,
    unf: undefined,
    nul: null,
    obj: {
        name: '我是一个对象',
        id: 1,
        qwe: {
            a: 1
        }
    },
    arr: [0, 1, 2, {b: 2}],
    date: new Date(0),
    reg: /我是一个正则/ig,
    [Symbol('1')]: 1,
    func() {
        console.log(123)
    }
}

function deepclone(obj,map=new WeakMap()){
    if(obj instanceof Date) return new Date(obj);
    if(obj instanceof RegExp) return new RegExp(obj)
    if(obj==null || typeof obj !='object'){
        return obj
    }
    if(map.has(obj)){
        return map.get(obj)
    }
    let t = new obj.constructor()
    map.set(obj,t)
    let keys=[...Object.getOwnPropertyNames(obj),...Object.getOwnPropertySymbols(obj)]
    for(let key of keys){
        t[key]=deepclone(obj[key],map)
    }

    return t
}

let result=deepclone(testobj)
result.data=new Date()
console.log(result,testobj)

{
  num: 0,
  str: '',
  boolean: true,
  unf: undefined,
  nul: null,
  obj: { name: '我是一个对象', id: 1, qwe: { a: 1 } },
  arr: [ 0, 1, 2, { b: 2 } ],
  date: 1970-01-01T00:00:00.000Z,
  reg: /我是一个正则/gi,
  func: [Function: func],
  data: 2020-08-21T11:30:05.269Z,
  [Symbol(1)]: 1
} {
  num: 0,
  str: '',
  boolean: true,
  unf: undefined,
  nul: null,
  obj: { name: '我是一个对象', id: 1, qwe: { a: 1 } },
  arr: [ 0, 1, 2, { b: 2 } ],
  date: 1970-01-01T00:00:00.000Z,
  reg: /我是一个正则/gi,
  func: [Function: func],
  [Symbol(1)]: 1
}

let res="hello".replace(/^|$/,'#');
console.log(res) 
// => "#hello#"

let res="I\nlove\njavascript".replace(/^|$/gm,"#")
console.log(result)
/*
#I#
#love#
#javascript#
*/

let res="[js] lesson_01.mp4".replace(/\b/g,"#")
console.log(res)
//=> "[#js#] #lesson_01#.#mp4#"

let res="[js] lesson_01.mp4".replace(/\B/g,"#")
console.log(res)
//=> "#[j#s]# l#e#s#s#o#n#_#0#1.m#p#4"

let res="hello".replace(/(?=l)/g,"#")
// => "he#l#lo"

let res="hello".replace(/(?!l)/g,"#")
// => "#h#ell#o#"

"hello" == "" + "h" + "" + "e" + "" + "l" + "" + "l" + "o" + "";

var result = /^^hello?$/.test("hello");
console.log(result); 
// => true

var result = /(?=he)^^he(?=\w)llo$\b\b$/.test("hello");
console.log(result); 
// => true

let res="12345678".replace(/(?=\d{3}$)/g,',')
// => "12345,678"

let res='12345678'.replace(/(?=(\d{3})+$)/g,',')
// => "12,345,678"

//以上匹配存在问题
let res='123456789'.replace(/(?=(\d{3})+$)/g,',')
// => ",123,456,789"

// 因为以上正则仅仅把从结尾向前数，一旦是3的倍数，就把其前面的位置换成 ',' 因此才出现这个问题
// 解决 要求匹配这个位置不能是开头 


// 要求这个位置不能是开头怎么办 (?!^)

let res='123456789'.replace(/(?!^)(?=(\d{3})+$)/g,',')
// => "123,456,789"

let res="12345678 123456789".replace(/(?!\b)(?=(\d{3})+\b)/g,',')
// => "12,345,678 123,456,789"

let res="12345678 123456789".replace(/\B(?=(\d{3})+\b)/g,',')
// => "12,345,678 123,456,789"

 let reg=/[0-9a-zA-Z]{6,12}$/

let reg=/(?=.*[0-9])^[0-9a-zA-Z]{6-12}$/

let reg=/(?=.*[0-9])(?=.*[a-z])^[0-9a-zA-Z]{6,12}$/

'study'.replace(/(?=s)/, '#') // #study
'study'.replace(/(?=d)/, '#') // stu#dy
'study'.replace(/(?=^)/, '#') // #study

/^^study/.test('study') // true

/(?=\d)^/.test('9') // true
/(?=\d)^/.test('9l') // true
/(?=\d)^/.test('l9') // false

/(?=.*[0-9])^/.test('9') // true
/(?=.*[0-9])^/.test('9l') // true
/(?=.*[0-9])^/.test('l9') // true

1、
`study`.replace(/$/, '#') // study#
`study`.replace(/$(?<=y)/, '#') //study#
`study`.replace(/(?<=d)/, '#') // stud#y

2、
`study1`.replace(/(?![a-z])/g, '#') //study#1#
`study`.replace(/(?![a-z])/g, '#') //study#

let reg=/((?=.*[0-9])(?=.*[a-z])|(?=.*[0-9])(?=.*[A-Z]|(?=.*[a-z])(?=.*[A-Z])))^[0-9A-Za-z]{6,12}$/;
console.log( reg.test("1234567") ); // false 全是数字
console.log( reg.test("abcdef") ); // false 全是小写字母
console.log( reg.test("ABCDEFGH") ); // false 全是大写字母
console.log( reg.test("ab23C") ); // false 不足6位
console.log( reg.test("ABCDEF234") ); // true 大写字母和数字
console.log( reg.test("abcdEF234") ); // true 三者都有

let  reg = /(?!^[0-9]{6,12}$)^[0-9A-Za-z]{6,12}$/;

var reg = /(?!^[0-9]{6,12}$)(?!^[a-z]{6,12}$)(?!^[A-Z]{6,12}$)^[0-9A-Za-z]{6,12}$/;
console.log( reg.test("1234567") ); // false 全是数字
console.log( reg.test("abcdef") ); // false 全是小写字母
console.log( reg.test("ABCDEFGH") ); // false 全是大写字母
console.log( reg.test("ab23C") ); // false 不足6位
console.log( reg.test("ABCDEF234") ); // true 大写字母和数字
console.log( reg.test("abcdEF234") ); // true 三者都有

var regex = /(ab)+/g;
var string = "ababa abbb ababab";
console.log( string.match(regex) ); 
// => ["abab", "ab", "ababab"]

var regex = /^I love (JavaScript|Regular Expression)$/;
console.log( regex.test("I love JavaScript") );
console.log( regex.test("I love Regular Expression") );
// => true
// => true

var regex = /\d{4}-\d{2}-\d{2}/;

let regex=/(\d{4})-(\d{2})-(\d{2})/;
let str="2020-08-11"
console.log(str.match(regex))
// => ["2020-08-11", "2020", "08", "11", index: 0, input: "2020-08-11", groups: undefined]
regex=/(\d{4})-(\d{2})-(\d{2})/g;
console.log(str.match(regex))
// => ["2020-08-11"]

let regex=/(\d{4})-(\d{2})-(\d{2})/;
let str="2020-08-11"
console.log(regex.exec(str))
// => ["2020-08-11", "2020", "08", "11", index: 0, input: "2020-08-11", groups: undefined]

var regex = /(\d{4})-(\d{2})-(\d{2})/;
var string = "2017-06-12";

regex.test(string); // 正则操作即可，例如
//regex.exec(string);
//string.match(regex);

console.log(RegExp.$1); // "2017"
console.log(RegExp.$2); // "06"
console.log(RegExp.$3); // "12"

var regex = /(\d{4})-(\d{2})-(\d{2})/;
var string = "2017-06-12";
var result = string.replace(regex, "$2/$3/$1");
console.log(result); 
// => "06/12/2017"

var regex = /(\d{4})-(\d{2})-(\d{2})/;
var string = "2017-06-12";
var result = string.replace(regex, function(){
    return RegExp.$2+"/"+RegExp.$3+"/"+RegExp.$1;
});
console.log(result); 
// => "06/12/2017"

var regex = /(\d{4})-(\d{2})-(\d{2})/;
var string = "2017-06-12";
var result = string.replace(regex, function(match,year,month,day){
    return month+"/"+day+"/"+year;
});
console.log(result); 
// => "06/12/2017"

var regex = /\d{4}(-|\/|\.)\d{2}(-|\/|\.)\d{2}/;
var string1 = "2017-06-12";
var string2 = "2017/06/12";
var string3 = "2017.06.12";
var string4 = "2016-06/12";
console.log( regex.test(string1) ); // true
console.log( regex.test(string2) ); // true
console.log( regex.test(string3) ); // true
console.log( regex.test(string4) ); // true

var regex = /\d{4}(-|\/|\.)\d{2}\1\d{2}/;
var string1 = "2017-06-12";
var string2 = "2017/06/12";
var string3 = "2017.06.12";
var string4 = "2016-06/12";
console.log( regex.test(string1) ); // true
console.log( regex.test(string2) ); // true
console.log( regex.test(string3) ); // true
console.log( regex.test(string4) ); // false

var regex = /^((\d)(\d(\d)))\1\2\3\4$/;
var string = "1231231233";
console.log( regex.test(string) ); // true
console.log( RegExp.$1 ); // 123
console.log( RegExp.$2 ); // 1
console.log( RegExp.$3 ); // 23
console.log( RegExp.$4 ); // 3

var regex = /(1)(2)(3)(4)(5)(6)(7)(8)(9)(#) \10+/;
var string = "123456789# ######"
console.log( regex.test(string) );
// => true

ar regex = /\1\2\3\4\5\6\7\8\9/;
console.log( regex.test("\1\2\3\4\5\6\7\8\9") ); 
console.log( "\1\2\3\4\5\6\7\8\9".split("") );
// =>  ["�", "�", "�", "�", "�", "�", "�", "8", "9"]

var regex =/(?:ab)+/g;
var str='ababa abbb ababab';
console.log(str.match(regex));
// => ["abab", "ab", "ababab"]

function trim(str){
    return str.replace(/^\s+|\s+$/g,'')
}
console.log(trim('  hello world  '))

function trim(str){
    return str.replace(/^\s*(.*?)\s*$/g,'$1')
}
console.log(trim('  hello world  '))

function titleize(str){
    return str.toLowerCase().replace(/(?:^|\s)\w/g,function(c){
        console.log(c)
        return c.toUpperCase()
    })
}
console.log(titleize('hello everyone'))
// => Hello Everyone

function camelize(str){
    return str.replace(/[-_\s]+(.)?/g,function(match,c){
        console.log(c)
        return c?c.toUpperCase():'';
    })
} 
console.log(camelize('-moz-transform'))
// => MozTransform

function dasherize(str){
    return str.replace(/([A-Z])/g,'-$1').replace(/[-_\s]+/g,'-').toLowerCase()
}
console.log( dasherize('MozTransform') ); 

// 将HTML特殊字符转换成等值的实体
function escapeHTML(str) {
	var escapeChars = {
	  '¢' : 'cent',
	  '£' : 'pound',
	  '¥' : 'yen',
	  '€': 'euro',
	  '©' :'copy',
	  '®' : 'reg',
	  '<' : 'lt',
	  '>' : 'gt',
	  '"' : 'quot',
	  '&' : 'amp',
	  '\'' : '#39'
	};
	return str.replace(new RegExp('[' + Object.keys(escapeChars).join('') +']', 'g'), function(match) {
        console.log(match)
		return '&' + escapeChars[match] + ';';
	});
}
console.log( escapeHTML('<div>Blah blah blah</div>') );
// => "&lt;div&gt;Blah blah blah&lt;/div&gt";

/ 实体字符转换为等值的HTML。
function unescapeHTML(str) {
	var htmlEntities = {
	  nbsp: ' ',
	  cent: '¢',
	  pound: '£',
	  yen: '¥',
	  euro: '€',
	  copy: '©',
	  reg: '®',
	  lt: '<',
	  gt: '>',
	  quot: '"',
	  amp: '&',
	  apos: '\''
	};
	return str.replace(/\&([^;]+);/g, function(match, key) {
		if (key in htmlEntities) {
			return htmlEntities[key];
		}
		return match;
	});
}
console.log( unescapeHTML('&lt;div&gt;Blah blah blah&lt;/div&gt;') );
// => "<div>Blah blah blah</div>"

var regex=/<([^>]+)>[\d\D]*<\/\1>/
var string1 = "<title>regular expression</title>";
var string2 = "<p>laoyao bye bye</p>";
var string3 = "<title>wrong!</p>";
console.log( regex.test(string1) ); // true
console.log( regex.test(string2) ); // true
console.log( regex.test(string3) ); // false

// 原始 list 如下
let list =[
    {id:1,name:'部门A',parentId:0},
    {id:2,name:'部门B',parentId:0},
    {id:3,name:'部门C',parentId:1},
    {id:4,name:'部门D',parentId:1},
    {id:5,name:'部门E',parentId:2},
    {id:6,name:'部门F',parentId:3},
    {id:7,name:'部门G',parentId:2},
    {id:8,name:'部门H',parentId:4}
];
const result = convert(list, ...);

// 转换后的结果如下
let result = [
    {
      id: 1,
      name: '部门A',
      parentId: 0,
      children: [
        {
          id: 3,
          name: '部门C',
          parentId: 1,
          children: [
            {
              id: 6,
              name: '部门F',
              parentId: 3
            }, {
              id: 16,
              name: '部门L',
              parentId: 3
            }
          ]
        },
        {
          id: 4,
          name: '部门D',
          parentId: 1,
          children: [
            {
              id: 8,
              name: '部门H',
              parentId: 4
            }
          ]
        }
      ]
    },
  ···
];

let numSum=[-1, 0, 1, 2, -1, -4]
let sum=0

function numSumArr(arr,sum){
    let result=[],len=arr.length;
    arr=arr.sort((a,b)=>a-b)
    for(let i=0;i<len-2;i++){
        let j=i+1,k=len-1;
        if(i>0 && arr[i]==arr[i-1]){
            continue
        }
        while (j<k) {
            if(arr[i]+arr[j]+arr[k]<sum){
                j++
                while (j<k && arr[j]==arr[j-1]) {
                    j++
                }
            }else if (arr[i]+arr[j]+arr[k]>sum) {
                k--
                while(j<k && arr[k]==arr[k+1]){
                    k--
                }
            }else{
                result.push([arr[i],arr[j],arr[k]])
                j++
                k--
                while (j<k && arr[j]==arr[j-1]) {
                    j++
                }
                while (j<k && arr[k]==arr[k+1]) {
                    k--
                }
            }
        }
    }
    console.log('result',result)
    return result
}

numSumArr(numSum,0)

const ParallelUglifyPlugin = require('webpack-parallel-uglify-plugin');

// ...
optimization: {
    minimizer: [
        new ParallelUglifyPlugin({ // 多进程压缩
            cacheDir: '.cache/',
            uglifyJS: {
                output: {
                    comments: false,
                    beautify: false
                },
                compress: {
                    warnings: false,
                    drop_console: true,
                    collapse_vars: true,
                    reduce_vars: true
                }
            }
        }),
    ]
}

optimization: {
    minimize: env === 'production' ? true : false, // 开发环境不压缩
    splitChunks: {
        chunks: "async", // 共有三个值可选：initial(初始模块)、async(按需加载模块)和all(全部模块)
        minSize: 30000, // 模块超过30k自动被抽离成公共模块
        minChunks: 1, // 模块被引用>=1次，便分割
        maxAsyncRequests: 5,  // 异步加载chunk的并发请求数量<=5
        maxInitialRequests: 3, // 一个入口并发加载的chunk数量<=3
        name: true, // 默认由模块名+hash命名，名称相同时多个模块将合并为1个，可以设置为function
        automaticNameDelimiter: '~', // 命名分隔符
        cacheGroups: { // 缓存组，会继承和覆盖splitChunks的配置
            default: { // 模块缓存规则，设置为false，默认缓存组将禁用
                minChunks: 2, // 模块被引用>=2次，拆分至vendors公共模块
                priority: -20, // 优先级
                reuseExistingChunk: true, // 默认使用已有的模块
            },
            vendors: {
                test: /[\\/]node_modules[\\/]/, // 表示默认拆分node_modules中的模块
                priority: -10
            }
        }
    }
}

splitChunks: {
    // ...
    cacheGroups: {    
        elementUI: {
            name: "chunk-elementUI", // 单独将 elementUI 拆包
            priority: 15, // 权重需大于其它缓存组
            test: /[\/]node_modules[\/]element-ui[\/]/
        }
    }
}

const HappyPack = require('happypack');
const happyThreadPool = HappyPack.ThreadPool({ size: os.cpus().length });
const createHappyPlugin = (id, loaders) => new HappyPack({
    id: id,
    loaders: loaders,
    threadPool: happyThreadPool,
    verbose: process.env.HAPPY_VERBOSE === '1' // make happy more verbose with HAPPY_VERBOSE=1
});