四月八日

// 老写法
try {
  Object.defineProperty(target, property, attributes);
  // success
} catch (e) {
  // failure
}

// 新写法
if (Reflect.defineProperty(target, property, attributes)) {
  // success
} else {
  // failure
}

// 老写法
'assign' in Object // true

// 新写法
Reflect.has(Object, 'assign') // true

var object = { proxy: new Proxy(target, handler) };

var proxy = new Proxy({}, {
  get: function(target, propKey) {
    return 35;
  }
});

let obj = Object.create(proxy);
obj.time // 35

const target = Object.defineProperties({}, {
  foo: {
    value: 123,
    writable: false,
    configurable: false
  },
});

const handler = {
  get(target, propKey) {
    return 'abc';
  }
};

const proxy = new Proxy(target, handler);

proxy.foo
// TypeError: Invariant check failed

var obj = { a: 10 };
Object.preventExtensions(obj);

var p = new Proxy(obj, {
  has: function(target, prop) {
    return false;
  }
});

'a' in p // TypeError is thrown

const p = new Proxy(function() {}, {
  construct: function(target, argumentsList) {
    return 1;
  }
});

new p() // 报错
// Uncaught TypeError: 'construct' on proxy: trap returned non-object ('1')

const p = new Proxy({}, {
  construct: function(target, argumentsList) {
    return {};
  }
});

new p() // 报错
// Uncaught TypeError: p is not a constructor

const handler = {
  construct: function(target, args) {
    console.log(this ===  handler);
    return new target(...args);
  }
}

let p = new Proxy(function () {}, handler);
new p() // true

class Queue {
    constructor() {
        this.count = 0;
        this.lowestCount = 0;
        this.items = {};
    }
    enqueue(element) {
        this.items[this.count] = element;
        this.count++;
    }
    dequeue() {
        if (this.isEmpty()) {
            return undefined;
        }
        const result = this.items[this.lowestCount];
        delete this.items[this.lowestCount];
        this.lowestCount++;
        return result; 
    }
    peek() {
        if (this.isEmpty()) {
            return undefined;
        }
        return this.items[this.lowestCount];
    }
    isEmpty() {
        return this.count - this.lowestCount === 0;
    }
    size() {
        return this.count - this.lowestCount;
    }
    clear() {
        this.items = {};
        this.count = 0;
        this.lowestCount = 0;
    }
    toString() {
        if (this.isEmpty()) {
            return '';
        }
        let objString = `${this.items[this.lowestCount]}`;
        for (let i = this.lowestCount + 1; i < this.count; i++) {
            objString = `${objString},${this.items[i]}`;
        }
        return objString;
    }
}

class Deque {
    constructor() {
        this.count = 0;
        this.lowestCount = 0;
        this.items = {};
    }
    addFront(element) {
        this.lowestCount--;
        this.items[this.lowestCount] = element;
    }
    addBack(element) {
        this.items[this.count] = element;
        this.count++;
    }
    removeFront() {
        if (this.isEmpty()) return;
        const ele = this.items[this.lowestCount];
        delete this.items[this.lowestCount];
        this.lowestCount++;
        return ele;
    }
    removeBack() {
        if (this.isEmpty()) return;
        const ele = this.items[this.count];
        delete this.items[this.count];
        this.lowestCount--;
        return ele;
    }
    peekFront() {
        return this.items[this.lowestCount];
    }
    peekBack() {
        return this.items[this.count - 1];
    }
    isEmpty() {
        return this.count === this.lowestCount
    }
    size() {
        return this.count - this.lowestCount
    }
    clear() {
        this.count = 0;
        this.lowestCount = 0;
        this.items = {};
    }
}

const player = ['John', 'Jack', 'Camila', 'Ingrid', 'Carl'];
const queue = new Queue();

for (let p of player) {
    queue.enqueue(p);
}

function game(queue, nums) {
    while (queue.size() > 1) {
        for (let i = 0; i < nums; i++) {
            queue.enqueue(queue.dequeue());
        }
        console.log("淘汰==" + queue.dequeue())
    }
    console.log('获胜==' + queue.peek());
}
game(queue, 7)

Object.defineProperty(Object, 'is', {
  value: function(x, y) {
    if (x === y) {
      // x===y 是前提，x!==0排除为零的情况，如果xy为0通过转为Infinity判断
      return x !== 0 || 1 / x === 1 / y;
    }
    // 针对NaN的情况， NaN!==NaN
    return x !== x && y !== y;
  },
  configurable: true,
  enumerable: false,
  writable: true
});

Object.assign(undefined) // 报错
Object.assign(null) // 报错

let obj = {a: 1};
Object.assign(obj, undefined) === obj // true
Object.assign(obj, null) === obj // true

Object(true) // {[[PrimitiveValue]]: true}
Object(10)  //  {[[PrimitiveValue]]: 10}
Object('abc') // {0: "a", 1: "b", 2: "c", length: 3, [[PrimitiveValue]]: "abc"}

Object.assign([1, 2, 3], [4, 5])
// [4, 5, 3]

const source = {
  get foo() { return 1 }
};
const target = {};

Object.assign(target, source)
// { foo: 1 }

Object.create(proto[, propertiesObject])

// proto 新创建对象的原型对象。

// propertiesObject 可选。需要传入一个对象，该对象的属性类型参照Object.defineProperties()的第二个参数。如果该参数被指定且不为 undefined，该传入对象的自有可枚举属性(即其自身定义的属性，而不是其原型链上的枚举属性)将为新创建的对象添加指定的属性值和对应的属性描述符。

function clone(origin) {
  let originProto = Object.getPrototypeOf(origin);
  return Object.assign(Object.create(originProto), origin);
}

const merge =
  (target, ...sources) => Object.assign(target, ...sources);

Object.assign({}, DEFAULTS, options);

function getOwnPropertyDescriptors(obj) {
  const result = {};
  for (let key of Reflect.ownKeys(obj)) {
    result[key] = Object.getOwnPropertyDescriptor(obj, key);
  }
  return result;
}

const merge = (target, source) => Object.defineProperties(
    target,
    Object.getOwnPropertyDescriptors(source)
)

const shallowClone = (obj) => Object.create(
  Object.getPrototypeOf(obj),
  Object.getOwnPropertyDescriptors(obj)
);

let mix = (object) => ({
  with: (...mixins) => mixins.reduce(
    (c, mixin) => Object.create(
      c, Object.getOwnPropertyDescriptors(mixin)
    ), object)
});

Object.defineProperty(Object.prototype, '__proto__', {
  get() {
    let _thisObj = Object(this);
    return Object.getPrototypeOf(_thisObj);
  },
  set(proto) {
    if (this === undefined || this === null) {
      throw new TypeError();
    }
    if (!isObject(this)) {
      return undefined;
    }
    if (!isObject(proto)) {
      return undefined;
    }
    let status = Reflect.setPrototypeOf(this, proto);
    if (!status) {
      throw new TypeError();
    }
  },
});

function isObject(value) {
  return Object(value) === value;
}

Object.getPrototypeOf({ __proto__: null })

function setPrototypeOf(obj, proto) {
  obj.__proto__ = proto;
  return obj;
}

Object.setPrototypeOf(1, {}) === 1 // true
Object.setPrototypeOf('foo', {}) === 'foo' // true
Object.setPrototypeOf(true, {}) === true // true

// 等同于 Object.getPrototypeOf(Number(1))
Object.getPrototypeOf(1)
// Number {[[PrimitiveValue]]: 0}

// 等同于 Object.getPrototypeOf(String('foo'))
Object.getPrototypeOf('foo')
// String {length: 0, [[PrimitiveValue]]: ""}

// 等同于 Object.getPrototypeOf(Boolean(true))
Object.getPrototypeOf(true)
// Boolean {[[PrimitiveValue]]: false}

Object.getPrototypeOf(1) === Number.prototype // true
Object.getPrototypeOf('foo') === String.prototype // true
Object.getPrototypeOf(true) === Boolean.prototype // true

// Generator函数的版本
function* entries(obj) {
  for (let key of Object.keys(obj)) {
    yield [key, obj[key]];
  }
}

// 非Generator函数的版本
function entries(obj) {
  let arr = [];
  for (let key of Object.keys(obj)) {
    arr.push([key, obj[key]]);
  }
  return arr;
}
Object.from

// 例一
const entries = new Map([
  ['foo', 'bar'],
  ['baz', 42]
]);

Object.fromEntries(entries)
// { foo: "bar", baz: 42 }

// 例二
const map = new Map().set('foo', true).set('bar', false);
Object.fromEntries(map)
// { foo: true, bar: false }

var arr = [];
for (var i = 1; i <= 6; i++) {
    arr[i] = 1;
}

var arr = [];
for (var i = 1; i <= 6; i++) {
    for (var j = 1; j <= 6; j++) {
        var sum = i + j;
        if (arr[sum] === undefined) arr[sum] = 0;
        arr[sum] += 1;
    }
}

var arr = [];
var n = 2;

function recursion(loop, sum) {
  if (loop <= n) {
    for (var i = 1; i <= 6; i++) {
      recursion(loop + 1, sum + i);
      if (loop !== n) continue;
      if (arr[sum + i] === undefined) arr[sum + i] = 0;
      arr[sum + i]++;
    }
  }
}
recursion(1, 0)

var arr = [];
var n = 2;

function recursion(loop, sum) {
    if (loop > n) {
        if (arr[sum] === undefined) arr[sum] = 0;
        arr[sum]++;
        return arr;
    }
    for (var i = 1; i <= 6; i++) {
        recursion(loop + 1, sum + i);
    }
}
recursion(1, 0)

function twoSum(n) {
    var arr = [];
    var mount = Math.pow(6, n)

    function recursion(loop, sum) {
        if (loop > n) {
            if (arr[sum] === undefined) arr[sum] = 0;
            arr[sum]++;
            return arr;
        }
        for (var i = 1; i <= 6; i++) {
            recursion(loop + 1, sum + i);
        }
    }
    recursion(1, 0);
    var res = [];
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] !== undefined) {
            res.push(Number((arr[i] / mount).toFixed(5)))
        }
    }
    return res;
}

function twoSum(n) {
    var arr = [];
    var mount = Math.pow(6, n)

    function recursion(loop, sum) {
        if (loop > n) {
            if (arr[sum] === undefined) arr[sum] = 0;
            arr[sum]++;
            return arr;
        }
        for (var i = 1; i <= 6; i++) {
            recursion(loop + 1, sum + i);
        }
    }
    recursion(1, 0);
    var res = [];
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] !== undefined) {
            res.push(Number((arr[i] / mount).toFixed(5)))
        }
    }
    return res;
}

function twoSum(n) {
    var sum = Math.pow(6, n);
    var f = [];
    f.push([], new Array(6 + 1).fill(1, 1));
    for (var i = 2; i <= n; i++) {
        if (f[i] === undefined) f[i] = [];
        for (var j = i; j <= 6 * i; j++) {
            if (f[i][j] === undefined) f[i][j] = 0
            for (var k = 1; k <= 6; k++) {
                f[i][j] += f[i - 1][j - k] || 0
            }
        }
    }
    var res = []
    var arr = f[n];
    var len = f[n].length
    for (var i = 0; i < len; i++) {
        if (arr[i] == undefined) continue;
        res.push(Number((arr[i] / sum).toFixed(5)));
    }
    return res;
}

var multiply = function(num1, num2) {
  return BigInt(num1) * BigInt(num2) + '';
}

var multiply = function (num1, num2) {
    const stack = new Array(num1.length + num2.length).fill(0);
    let res = '';
    for (let i = num1.length - 1; i >= 0; i--) {
        for (let j = num2.length - 1; j >= 0; j--) {
            const sum = stack[i + j + 1] + num1[i] * num2[j];
            stack[i + j + 1] = sum % 10;
            stack[i + j] += sum / 10 >> 0;
        }
    }
    let make = false;
    for (let i = 0; i < stack.length; i++) {
        if (!make && stack[i] === 0) {
            continue;
        }
        make = true;
        res += stack[i];
    }
    return res || '0'
};

var multiply = function (num1, num2) {
    if (num1 === '0' || num2 === '0') {
        return '0'
    }
    const stack = new Array(num1.length + num2.length).fill(0);
    let res = '';
    for (let i = num1.length - 1; i >= 0; i--) {
        for (let j = num2.length - 1; j >= 0; j--) {
            const sum = stack[i + j + 1] + num1[i] * num2[j];
            stack[i + j + 1] = sum % 10;
            stack[i + j] += sum / 10 >> 0;
        }
    }
    for (let i = 0; i < stack.length; i++) {
        if (i == 0 && stack[i] === 0) {
            continue;
        }
        res += stack[i];
    }
    return res;
};