function loadJS(files, done) {
  // 獲取head標簽
  const head = document.getElementsByTagName('head')[0];
  Promise.all(files.map(file => {
    return new Promise(resolve => {
      // 創(chuàng)建script標簽并添加到head
      const s = document.createElement('script');
      s.type = "text/javascript";
      s.async = true;
      s.src = file;
      // 監(jiān)聽load事件，如果加載完成則resolve
      s.addEventListener('load', (e) => resolve(), false);
      head.appendChild(s);
    });
  })).then(done);  // 所有均完成，執(zhí)行用戶的回調事件
}

loadJS(["test1.js", "test2.js"], () => {
  // 用戶的回調邏輯
});

// 這是包含了js代碼的動態(tài)模板
var template =
'My avorite sports:' +
'<%if(this.showSports) {%>' +
    '<% for(var index in this.sports) {   %>' +
    '<a><%this.sports[index]%></a>' +
    '<%}%>' +
'<%} else {%>' +
    '<p>none</p>' +
'<%}%>';
// 這是我們要拼接的函數(shù)字符串
const code = `with(obj) {
  var r=[];
  r.push("My avorite sports:");
  if(this.showSports) {
    for(var index in this.sports) {
      r.push("<a>");
      r.push(this.sports[index]);
      r.push("</a>");
    }
  } else {
    r.push("<span>none</span>");
  }
  return r.join("");
}`
// 動態(tài)渲染的數(shù)據(jù)
const options = {
  sports: ["swimming", "basketball", "football"],
  showSports: true
}
// 構建可行的函數(shù)并傳入?yún)?shù)，改變函數(shù)執(zhí)行時this的指向
result = new Function("obj", code).apply(options, [options]);
console.log(result);

const arr = [
    { classId: "1", name: "張三", age: 16 },
    { classId: "1", name: "李四", age: 15 },
    { classId: "2", name: "王五", age: 16 },
    { classId: "3", name: "趙六", age: 15 },
    { classId: "2", name: "孔七", age: 16 }
];

groupArrayByKey(arr, "classId");

function groupArrayByKey(arr = [], key) {
    return arr.reduce((t, v) => (!t[v[key]] && (t[v[key]] = []), t[v[key]].push(v), t), {})
}

function double() {
    return value *2
}

// 不傳的話給一個默認值0
function double(value = 0) {
    return value * 2
}

// 用戶必須要傳一個參數(shù)，不傳參數(shù)就拋出一個錯誤

const required = () => {
    throw new Error("This function requires one parameter.")
}
function double(value = required()) {
    return value * 2
}

double(3) // 6
double() // throw Error

export function once (fn) {
  // 利用閉包判斷函數(shù)是否執(zhí)行過
  let called = false
  return function () {
    if (!called) {
      called = true
      fn.apply(this, arguments)
    }
  }
}

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(this, args);
    } else {
      return function(...args2) {
        return curried.apply(this, args.concat(args2));
      };
    }
  };
}

function add(x, y) {
  return x + y;
}

const curriedAdd = curry(add);

console.log(curriedAdd(1)(2)); // 輸出 3
console.log(curriedAdd(1, 2)); // 輸出 3

let cache;
class A {
  // ...
}

function getInstance() {
  if (cache) return cache;
  return cache = new A();
}

const x = getInstance();
const y = getInstance();

console.log(x === y); // true

// id：完整的文件名
const path = require('path');
const fs = require('fs');
function Module(id){
    // 用來唯一標識模塊
    this.id = id;
    // 用來導出模塊的屬性和方法
    this.exports = {};
}

function myRequire(filePath) {
    // 直接調用Module的靜態(tài)方法進行文件的加載
    return Module._load(filePath);
}

Module._cache = {};
Module._load = function(filePath) {
    // 首先通過用戶傳入的filePath尋址文件的絕對路徑
    // 因為再CommnJS中，模塊的唯一標識是文件的絕對路徑
    const realPath = Module._resoleveFilename(filePath);
    // 緩存優(yōu)先，如果緩存中存在即直接返回模塊的exports屬性
    let cacheModule = Module._cache[realPath];
    if(cacheModule) return cacheModule.exports;
    // 如果第一次加載，需要new一個模塊，參數(shù)是文件的絕對路徑
    let module = new Module(realPath);
    // 調用模塊的load方法去編譯模塊
    module.load(realPath);
    return module.exports;
}

// node文件暫不討論
Module._extensions = {
   // 對js文件處理
  ".js": handleJS,
  // 對json文件處理
  ".json": handleJSON
}

function handleJSON(module) {
 // 如果是json文件，直接用fs.readFileSync進行讀取，
 // 然后用JSON.parse進行轉化，直接返回即可
  const json = fs.readFileSync(module.id, 'utf-8')
  module.exports = JSON.parse(json)
}

function handleJS(module) {
  const js = fs.readFileSync(module.id, 'utf-8')
  let fn = new Function('exports', 'myRequire', 'module', '__filename', '__dirname', js)
  let exports = module.exports;
  // 組裝后的函數(shù)直接執(zhí)行即可
  fn.call(exports, exports, myRequire, module,module.id,path.dirname(module.id))
}

Module._resolveFilename = function (filePath) {
  // 拼接絕對路徑，然后去查找，存在即返回
  let absPath = path.resolve(__dirname, filePath);
  let exists = fs.existsSync(absPath);
  if (exists) return absPath;
  // 如果不存在，依次拼接.js,.json,.node進行嘗試
  let keys = Object.keys(Module._extensions);
  for (let i = 0; i < keys.length; i++) {
    let currentPath = absPath + keys[i];
    if (fs.existsSync(currentPath)) return currentPath;
  }
};

Module.prototype.load = function(realPath) {
  // 獲取文件擴展名，交由相對應的方法進行處理
  let extname = path.extname(realPath)
  Module._extensions[extname](this)
}

const user = {
  info: {
    name: "張三",
    address: { home: "Shaanxi", company: "Xian" },
  },
};

// obj是獲取屬性的對象，path是路徑，fallback是默認值
function get(obj, path, fallback) {
  const parts = path.split(".");
  const key = parts.shift();
  if (typeof obj[key] !== "undefined") {
    return parts.length > 0 ?
      get(obj[key], parts.join("."), fallback) :
      obj[key];
  }
  // 如果沒有找到key返回fallback
  return fallback;
}

console.log(get(user, "info.name")); // 張三
console.log(get(user, "info.address.home")); // Shaanxi
console.log(get(user, "info.address.company")); // Xian
console.log(get(user, "info.address.abc", "fallback")); // fallback