前端面试基础题：JavaScript变量声明、装箱和拆箱...

for (var i = 0; i < 5; i++) {
  console.log(i);
}
// 输出：0 1 2 3 4
​
for (var i = 0; i < 5; i++) {
  setTimeout(() => {
    console.log(i);
  }, 1000);
}
// 输出：5 5 5 5 5
​
for (let i = 0; i < 5; i++) {
  setTimeout(() => {
    console.log(i);
  }, 1000);
}
// 输出：0 1 2 3 4

function render(template, data) {
    const reg = /\$\{(\w+)\}/;
    if (reg.test(template)) {
        const key = reg.exec(template)[1];
        template = template.replace(reg, data[key]);
        return render(template, data);
    }
    return template;
}

let sym = Symbol();
console.log(typeof sym); // symbol
​
let genericSymbol = Symbol();
let otherGenericSymbol = Symbol();
let fooSymbol = Symbol('foo');
let otherFooSymbol = Symbol('foo');
​
console.log(genericSymbol == otherGenericSymbol); // false
console.log(fooSymbol == otherFooSymbol); // false
​
console.log(genericSymbol); // Symbol()
console.log(fooSymbol); // Symbol(foo)

// 方式1：字面量
var star = {
    name: 'pink',
    age: 18,
    sex: '男',
    sayHi() { alert("Hi~"); }
}
​
// 方式2：Object构造函数
var andy = new Object();
andy.name = 'pink';
andy.age = 18;
andy.sex = '男';
andy.sayHi() = function () { alert("Hi~"); }
​
// 方式3：自定义构造函数
function Person(name, age, sex) {
    this.name = name;
    this.age = age;
    this.sex = sex;
    this.sayHi = function () { alert("Hi~"); }
}
var bigBai = Person('大白', 100, '男');

for (var k in obj) {
    console.log(k);
    console.log(obj[k]);
}

function myNew(fn, ...args) {
    const obj = {};
    obj.__proto__ = fn.prototype;
    fn.apply(obj, args);
    return obj;
}

const arr = [1, 3, 5, 6, 4, 2];
// 总和
let tolValue = arr.reduce((prev, item) => {
  return prev + item;
}, 0);
// 最值
let maxValue = arr.reduce((prev, item) => {
  return Math.max(prev, item);
}, Number.MIN_VALUE);

const arr = [1, 2, 3, 4, 5, 4, 3, 2, 1];
const quchong = (arr) => {
  let res = [];
  arr.reduce((prev, item) => {
    if (!prev.has(item)) {
      prev.set(item, 1);
      res.push(item);
    }
    return prev;
  }, new Map());
  return res;
}
console.log(quchong(arr));  // [1, 2, 3, 4, 5]

const f1 = x => x + 1;
const f2 = x => x + 2;
const f3 = x => x + 3;
const f4 = x => x + 4;
function compose(...fns) {
    if (fns.length === 0) return x => x;
    if (fns.length === 1) return fns[0];
    return fns.reduce((prev, next) => {
        return (num) => prev(next(num));
    })
}
console.log(compose(f1, f2, f3, f4)(1));

const arr = [[1, 2], [3, 4], [5, 6]];
let flattened = arr.reduce((prev, item) => {
    return prev.concat(item);
}, []);

const votes = ['vue', 'react', 'angular', 'vue', 'react', 'vue'];
let count = votes.reduce((prev, item) => {
  if (!prev[item]) {
    prev[item] = 1;
  } else {
    prev[item]++;
  }
  return prev;
}, {});

var 变量名 = new RegExp(/表达式/);
var 变量名 = /表达式/;

reg.test(str);  // 用来测试某个字符串是否与正则匹配，匹配就返回true，否则返回false
reg.exec(str);  // 返回的是一个数组，数组中第0个元素是匹配的子字符串，第1个元素是正则中的第一个子分组匹配的结果...
str.match(reg);  // 是String对象的方法

const template = '我叫{{name}}，今年{{age}}岁。'
const reg = /\{\{(\w+)\}\}/;
​
// test方法
let res_test = reg.test(template);
console.log(res_test);  // true
​
// exec方法
let res_exec = reg.exec(template);
console.log(res_exec);
// [
//   '{{name}}',
//   'name',
//   index: 2,
//   input: '我叫{{name}}，今年{{age}}岁。',
//   groups: undefined
// ]
​
// match方法
let res_match = template.match(reg);
console.log(res_match);
// [
//   '{{name}}',
//   'name',
//   index: 2,
//   input: '我叫{{name}}，今年{{age}}岁。',
//   groups: undefined
// ]

const str = 'happy happily';
const pattn1 = /happ(?=ily)/;
const pattn2 = /happ(?!ily)/;
console.log(pattn1.exec(str));
// 匹配happily [ 'happ', index: 6, input: 'happy happily', groups: undefined ]
console.log(pattn2.exec(str));
// 匹配happy [ 'happ', index: 0, input: 'happy happily', groups: undefined ]

// 匹配两个连续相同的单词
const str = 'Hello what what is the first thing, and I am am scq000.';
const pattn = /\b(\w+)\s\1/;
console.log(pattn.exec(str));
// [
//   'what what',
//   'what',
//   index: 6,
//   input: 'Hello what what is the first thing, and I am am scq000.',
//   groups: undefined
// ]

new Date()
new Date(milliseconds)
new Date(dateString)
new Date(year, month, day, hours, minutes, seconds)

date.valueOf()
date.getTime()
Date.now()
+new Date()

function funcName (arg1, arg2, …) {}
var fn = function () {};  // 匿名函数
() => {}  // 箭头函数
(function () {}) ();  // 立即执行函数
(function () {} ());  // 立即执行函数

function isObj(item) {
    // typeof 会将 Array 也判断为 Object
    // 还要排除空对象的可能
    return typeof item === 'object' && item !== null;
}

function deepClone(obj) {
    // 判断要拷贝的对象是数组还是对象
    const newObj = obj instanceof Array? []: {};
    for (const key in obj) {
        const item = obj[key];
        // 简单数据类型只需要赋值，如果是复杂数据类型需要递归进行深拷贝
        newObj[key] = isObj(item)? deepClone(item): item;
    }
    return newObj;
}

typeof 1 // number
typeof '1'  // string
typeof undefined  // 'undefined'
typeof true  // 'boolean'
typeof Symbol()  // 'symbol'
typeof null  // 'object'
typeof []  // 'object'
typeof {}  // 'object'
typeof new Date()  // 'object'
typeof console.log;  // 'function'

const Person = function() {}
const p1 = new Person()
p1 instanceof Person // true

var str1 = 'hello world'
str1 instanceof String // false

var str2 = new String('hello world')
str2 instanceof String // true

function myInstanceof(L, R) {  // L代表instanceof左边，R代表右边
    var RP = R.prototype;  // 构造函数原型（显式原型）
    var LP = L.__proto__;  // 对象原型（隐式原型）
    while (true) {
        if (LP === null) return false;
        if (LP === RP) return true;
        LP = LP.__proto__;
    }
}

var d = new Number(1)
var e = 1
function fn() {
  console.log("ming");
}
var date = new Date();
var arr = [1, 2, 3];
var reg = /[hbc]at/gi;
​
console.log(e.constructor);//ƒ Number() { [native code] }
console.log(e.constructor.name);//Number
console.log(fn.constructor.name) // Function 
console.log(date.constructor.name)// Date 
console.log(arr.constructor.name) // Array 
console.log(reg.constructor.name) // RegExp

console.log(Object.prototype.toString.call(undefined)); // "[object Undefined]" 
console.log(Object.prototype.toString.call(null)); // "[object Null]" 
console.log(Object.prototype.toString.call(123)); // "[object Number]" 
console.log(Object.prototype.toString.call("abc")); // "[object String]" 
console.log(Object.prototype.toString.call(true)); // "[object Boolean]" 
function fn() {
  console.log("ming");
}
var date = new Date();
var arr = [1, 2, 3];
var reg = /[hbc]at/gi;
console.log(Object.prototype.toString.call(fn));// "[object Function]" 
console.log(Object.prototype.toString.call(date));// "[object Date]" 
console.log(Object.prototype.toString.call(arr)); // "[object Array]"
console.log(Object.prototype.toString.call(reg));// "[object RegExp]"

function is(x, y) {
    if (x === y) {
        // 1 / +0 = +Infinity, 1 / -0 = -Infinity是不一样的
        return x !== 0 || y !== 0 || 1 / x === 1 / y;
    } 
    else {
        return x !== x && y !== y;
    }
}

const name = new String('Uni');
console.log(name.length);  // 3

const name = 'Uni';
console.log(name.length);  // 3

// 内部执行过程
let newName = new String(name);
console.log(newName.length);
newName = null;

const bool = new Boolean(false);
console.log(bool);  // [Boolean: false]
console.log(bool.valueOf());  // false
​
console.log(!bool);  // false
console.log(!bool.valueOf());  // true