function func() {
    let obj1 = {};
    let obj2 = {};
    obj1.a = obj2; // obj1 引用 obj2
    obj2.a = obj1; // obj2 引用 obj1
    // 手动清除
    obj1 = null;
    obj2 = null;
}

function fn3(){
    var a = 10;
    return function(){
        a--;
        console.log(a);
    }
}
fn3()(); // 9
fn3()(); // 9

function fn3(){
    var a = 10;
    return function(){
        a--;
        console.log(a);
    }
}
var val = fn3();
val(); // 9
val(); // 8

// encrypt.js 加密文件
var CryptoJS = require('crypto-js');
var config = require('../config');
function encrypt(content, path) {
  var str = content.toString();
  // 密钥 16 位
  var key = config.encrypt.key;
  // 初始向量 initial vector 16 位
  var iv = config.encrypt.iv;
  // key 和 iv 可以一致
  key = CryptoJS.enc.Utf8.parse(key);
  iv = CryptoJS.enc.Utf8.parse(iv);
  var encrypted = CryptoJS.AES.encrypt(str, key, {
    iv: iv,
    mode: CryptoJS.mode.CBC,
    padding: CryptoJS.pad.Pkcs7,
  });
  // 转换为字符串
  encrypted = encrypted.toString();
  // mode 支持 CBC、CFB、CTR、ECB、OFB, 默认 CBC
  // padding 支持 Pkcs7、AnsiX923、Iso10126
  // 、NoPadding、ZeroPadding, 默认 Pkcs7, 即 Pkcs5
  return encrypted;
}
module.exports = encrypt;

// decrypt.js 解密文件
var CryptoJS = require('crypto-js');
var config = require('../config');
function decrypt(content) {
  var key = config.encrypt.key;
  var iv = config.encrypt.iv;
  key = CryptoJS.enc.Utf8.parse(key);
  iv = CryptoJS.enc.Utf8.parse(iv);
  // DES 解密
  var decrypted = CryptoJS.AES.decrypt(content, key, {
    iv: iv,
    mode: CryptoJS.mode.CBC,
    padding: CryptoJS.pad.Pkcs7,
  });
  // 转换为 utf8 字符串
  decrypted = CryptoJS.enc.Utf8.stringify(decrypted);
  return decrypted;
}
module.exports = decrypt;

// webpack.config.js webpack 配置
const CopyWebpackPlugin = require('copy-webpack-plugin')
...
plugins: [
  new CopyWebpackPlugin([
    {
      from: path.resolve(__dirname, '../../static/info'),
      to: 'static',
      transform (content, path) {
        return encrypt(content, path)
      }
    }
  ]),
]
// static/info 输入版权信息的静态文件
console.log(
  '%c未授权 xxxx公司 版权所有 copyright@2020',
  '\n\tfont-size: 16px;\n\tcolor: red;\n'
);
// 代码中读取加密后的静态文件，解密后执行
axios.get('static/info').then(result => {
  eval(decrypt(result.data));
});

const os = require('os');
const chalk = require('chalk');
const getMAC = require('getmac');
const path = require('path');
// 输出 mac 地址，可做校验
console.log(getMAC.default());
// 读取项目目录下 static/config.json 文件，可做校验
const configJSON = require(path.resolve(
  process.cwd(),
  '../../static/config.json'
));
console.log('====', configJSON);
// 用户输入指定信息，可做校验
process.stdout.write(`${chalk.cyan('Please input token:')}`);
process.stdin.on('data', (input) => {
  const token = input.toString().trim();
  if (token !== 'aaa') {
    console.log('认证失败，结束安装！');
    process.exit(1);
  }
  console.log('认证成功，开始安装...');
  process.stdin.pause();
});

// generateLicense.js 生成授权文件
var fs = require('fs');
var path = require('path');
var chalk = require('chalk');
var encrypt = require('./encrypt');
/*
 * static/license 为加密前的明文文件
 * 生产环境指定 type 为 production，添加 domains
 * 开发环境指定 type 为 development，添加 created 创建时间、expired 过期天数
 */
const buffer = fs.readFileSync(path.resolve(__dirname, '../static/license'));
// 写入文件，项目根目录下 license，不会被提交
var ws = fs.createWriteStream('./license');
ws.write(encrypt(buffer));
ws.end();
console.log(chalk.green('已生成 license 文件'));

// webpack.config.js webpack 配置
const CopyWebpackPlugin = require('copy-webpack-plugin')
...
plugins: [
  new CopyWebpackPlugin([
    {
      from: path.resolve(__dirname, '../../static/validate'),
      to: 'static',
      transform (content, path) {
        return encrypt(content, path)
      }
    }
  ]),
]
// 项目入口进行授权校验
/* eslint-disable */
let validate = false;
try {
  // 获取授权文件
  const result = await axios.get('static/license');
  const FORMAT = 'YYYY-MM-DD';
  const str = decrypt(result.data);
  const data = JSON.parse(str);
  const nowDate = moment().format(FORMAT);
  // 获取加密后的校验逻辑文件，执行校验
  const validate = await axios.get('static/validate')
  eval(decrypt(validate.data));
} catch (error) {
  console.error(error);
}
/* eslint-enable */
if (!validate) {
  // 校验失败处理
  return;
}
// 校验通过，向下运行
...
// static/validate 校验逻辑静态文件
if (data.type === 'production' && data.domains.includes(window.location.host)) {
  validate = true;
}
if (data.type === 'development') {
  const expiredDate = moment(data.created, 'YYYY-MM-DD')
    .add(data.expired, 'days')
    .format('YYYY-MM-DD');
  if (nowDate <= expiredDate) {
    validate = true;
  }
}

let fs = require('fs');
let path = require('path');
let JsZip = require('jszip');
let zip = new JsZip();
// 读取目录及文件
function readDir(obj, nowPath, nowFolder) {
  // 读取目录中的所有文件及文件夹
  let files = fs.readdirSync(nowPath);
  files.forEach(function (fileName, index) {
    // 遍历检测目录中的文件
    let fillPath = nowPath + '/' + fileName;
    let file = fs.statSync(fillPath);
    if (file.isDirectory()) {
      // 如果是目录的话，继续查询
      let folder = nowFolder + '/' + fileName;
      // 压缩对象中生成该目录
      let dirList = zip.folder(folder);
      // 重新检索目录文件
      readDir(dirList, fillPath, folder);
    } else {
      // 如果是文件压缩目录添加文件
      obj.file(fileName, fs.readFileSync(fillPath));
    }
  });
}
// 开始压缩文件
function startZIP() {
  var currPath = __dirname;
  // 要压缩的文件夹目录
  var sourceDir = path.join(currPath, '../../dist:source/');
  // 生成压缩包的目录
  var targetDir = path.join(currPath, '../../dist:app/static/source.zip');
  readDir(zip, sourceDir, '');
  zip
    .generateAsync({
      type: 'nodebuffer',
      compression: 'DEFLATE',
      compressionOptions: {
        level: 9,
      },
    })
    .then(function (content) {
      fs.writeFileSync(targetDir, content, 'utf-8');
      console.log('压缩完成');
    });
}
startZIP();

node zip.js

"scripts": {
  "postinstall": "node bin/copy.js"
},

output: {
  path: config.buildSource.assetsRoot,
  filename: 'index.js',
  libraryTarget: 'umd',
  libraryExport: 'default',
  library: config.buildSource.name,
},

// import 方式
import Library from 'lib';
// script 标签方式
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width,initial-scale=1.0">
    <link rel="stylesheet" href="./lib.css"/>
    <script src="./lib.js"></script>
    <title>测试包引入</title>
  </head>
  <body>
    <div id="app"></div>
    <script>
      const viewer = new Library.App.Viewer("app");
    </script>
  </body>
</html>

let files = fs.readdirSync(path.join(__dirname, '../../static/app/source/'));
files.forEach(function (fileName) {
  if (fileName.endsWith('.zip')) {
    sourceZipList.push(fileName);
  }
});
...
plugins: [
  new webpack.DefinePlugin({
    'sourceZipList': JSON.stringify(sourceZipList),
  }),
  ...
]

// demo{/#/cesium|参考样例}
exports.handlers = {
  beforeParse: (e) => {
    const result = e.source.match(/demo\{[^\}]+\}/);
    if (result && result[0]) {
      const value = result[0].replace('demo{', '').replace('}', '').split('|');
      if (value && value.length > 1) {
        e.source = e.source.replace(result[0], `<a href="${value[0]}">${value[1]}</a>`);
      }
    }
  },
};

jsdoc -c conf.json source/**/* -d static/doc

// CommonJS 模块就是对象，输入时必须查找对象属性。这种加载称为“运行时加载”，因为只有运行时才能得到这个对象。
let { stat, exists, readfile } = require('fs');
// 等同于
let _fs = require('fs');
let stat = _fs.stat;
let exists = _fs.exists;
let readfile = _fs.readfile;
// ES6 模块不是对象，而是通过 export 命令显式指定输出的代码，再通过 import 命令输入指定方法，其他方法不加载。这种加载称为“编译时加载”或者静态加载。
import { stat, exists, readFile } from 'fs';

export var firstName = 'Michael';
export var lastName = 'Jackson';
export var year = 1958;
var firstName = 'Michael';
var lastName = 'Jackson';
var year = 1958;
export { firstName, lastName, year };
export {
  firstName as f,
  lastName as l,
  lastName as L
};
export function multiply(x, y) {
  return x * y;
};
// 默认输出
export default function () {
  console.log('foo');
}
// 因为 export default 命令的本质是将后面的值，赋给 default 变量，所以可以直接将一个值写在 export default 之后
export default 42;

import { firstName, lastName, year } from './profile.js';
import { lastName as surname } from './profile.js';
import 'lodash';
import * as circle from './circle';
// 加载默认输出
import customName from './export-default';

export { foo, bar } from 'my_module';
export { foo as myFoo } from 'my_module';
// 忽略 my_module 模块的 default 方法
export * from 'my_module';
export { default } from 'foo';
export { es6 as default } from './someModule';
export { default as es6 } from './someModule';
export * as ns from "mod";
// 等同于
import * as ns from "mod";
export {ns};

const main = document.querySelector('main');
import(`./section-modules/${someVariable}.js`)
  .then(module => {
    module.loadPageInto(main);
  })
  .catch(err => {
    main.textContent = err.message;
  });

// 指定脚本或子目录的别名
{
  "exports": {
    "./submodule": "./src/submodule.js"
  }
}
import submodule from 'es-module-package/submodule';
// 模块的主入口
{
  "exports": {
    ".": "./main.js"
  }
}
// 等同于
{
  "exports": "./main.js"
}
// 条件加载
{
  "type": "module",
  "exports": {
    ".": {
      "require": "./main.cjs",
      "default": "./main.js"
    }
  }
}
// 等同于，如果同时还有其他别名，就不能采用简写
{
  "exports": {
    "require": "./main.cjs",
    "default": "./main.js"
  }
}

// a.js
exports.done = false;
var b = require('./b.js');
console.log('在 a.js 之中，b.done = %j', b.done);
exports.done = true;
console.log('a.js 执行完毕');
// b.js
exports.done = false;
var a = require('./a.js');
console.log('在 b.js 之中，a.done = %j', a.done);
exports.done = true;
console.log('b.js 执行完毕');
// main.js
var a = require('./a.js');
var b = require('./b.js');
console.log('在 main.js 之中, a.done=%j, b.done=%j', a.done, b.done);
// 在 b.js 之中，a.done = false
// b.js 执行完毕
// 在 a.js 之中，b.done = true
// a.js 执行完毕
// 在 main.js 之中, a.done=true, b.done=true

// a.mjs
import {bar} from './b';
console.log('a.mjs');
console.log(bar);
export let foo = 'foo';
// b.mjs
import {foo} from './a';
console.log('b.mjs');
console.log(foo);
export let bar = 'bar';
// $ node --experimental-modules a.mjs
// b.mjs
// ReferenceError: foo is not defined