(function() {
  function test() {
    console.log(this); // window 或者 global
  }
  test(); // 非全局作用域下的直接调用
})();

function SuperType() {
  this.property = true;
}

SuperType.prototype.getSuperValue = function() {
  return this.property;
};

function SubType() {
  this.subproperty = false;
}

//继承了SuperType
SubType.prototype = new SuperType();

SubType.prototype.getSubValue = function() {
  return this.subproperty;
};

var instance = new SubType();

alert(instance.getSuperValue()); //true

alert(instance instanceof Object); //true
alert(instance instanceof SuperType); //true
alert(instance instanceof SubType); //true

alert(Object.prototype.isPrototypeOf(instance)); //true
alert(SuperType.prototype.isPrototypeOf(instance)); //true
alert(SubType.prototype.isPrototypeOf(instance)); //true

var o = {
  a: 1,
  b: 2,
  c: 3
};

for (prop in o) {
  console.log(prop); // 依次输出 a, b, c
}

var scope = "global scope";
function checkscope() {
  var scope = "local scope";
  function f() {
    return scope;
  }
  return f;
}

var foo = checkscope();
foo();

fContext = {
  Scope: [AO, checkscopeContext.AO, globalContext.VO]
};

function Person(name) {
  this.getName = function() {
    return name;
  };

  this.setName = function(value) {
    name = value;
  };
}

var person = new Person("Nicholas");
alert(person.getName()); //"Nicholas"
person.setName("Greg");
alert(person.getName()); //"Greg"

var singleton = (function() {
  //私有变量和私有函数
  var privateVariable = 10;

  //特权/公有方法和属性
  return {
    publicProperty: true,

    publicMethod: function() {
      privateVariable++;
    }
  };
})();

function Person(name, age, job) {
  //属性
  this.name = name;
  this.age = age;
  this.job = job;

  //方法
  if (typeof this.sayName != "function") {
    Person.prototype.sayName = function() {
      alert(this.name);
    };
  }
}

var friend = new Person("Nicholas", 29, "Software Engineer");
friend.sayName();

class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }

  toString() {
    return "(" + this.x + ", " + this.y + ")";
  }
}

function SuperType() {
  this.property = true;
}

SuperType.prototype.getSuperValue = function() {
  return this.property;
};

function SubType() {
  this.subproperty = false;
}

//继承了SuperType
SubType.prototype = new SuperType();

function SuperType(name) {
  this.name = name;
}

function SubType() {
  //让超类型的构造函数执行时, this 指向新创建的子类型实例
  SuperType.call(this, "Garrik");
}

var instance1 = new SubType();

function SuperType(name) {
  this.name = name;
  this.colors = ["red", "blue", "green"];
}

SuperType.prototype.sayName = function() {
  alert(this.name);
};

function SubType(name, age) {
  //继承属性
  // 因为在这里传递参数, SubType 原型中的 SuperType 属性会被覆盖
  SuperType.call(this, name);

  this.age = age;
}

//继承方法
SubType.prototype = new SuperType();

// 因为 SubType 原型是 SuperType 实例, 所以 原型的 construtor 指向的是超类型, 要手动设置.
SubType.prototype.constructor = SubType;

class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
}

class ColorPoint extends Point {
  constructor(x, y, color) {
    super(x, y); // 调用父类的 constructor(x, y)
    this.color = color;
  }

  toString() {
    return this.color + " " + super.toString(); // 调用父类的toString()
  }
}

let cp = new ColorPoint(25, 8, "green");

cp instanceof ColorPoint; // true
cp instanceof Point; // true

Object.getPrototypeOf(ColorPoint) === Point;

let mySymbol = Symbol();

// 第一种写法
let a = {};
a[mySymbol] = "Hello!";

// 第二种写法
let a = {
  [mySymbol]: "Hello!"
};

a[mySymbol]; // "Hello!"

// 例子 4-1

// bad
const TYPE_AUDIO = "AUDIO";
const TYPE_VIDEO = "VIDEO";
const TYPE_IMAGE = "IMAGE";

// good
const TYPE_AUDIO = Symbol();
const TYPE_VIDEO = Symbol();
const TYPE_IMAGE = Symbol();

function handleFileResource(resource) {
  switch (resource.type) {
    case TYPE_AUDIO:
      playAudio(resource);
      break;
    case TYPE_VIDEO:
      playVideo(resource);
      break;
    case TYPE_IMAGE:
      previewImage(resource);
      break;
    default:
      throw new Error("Unknown type of resource");
  }
}

const Example = (function() {
  var _private = Symbol("private");

  class Example {
    constructor() {
      this[_private] = "private";
    }
    getName() {
      return this[_private];
    }
  }

  return Example;
})();

var ex = new Example();

console.log(ex.getName()); // private
console.log(ex.name); // undefined

let obj = {
  [Symbol("my_key")]: 1,
  enum: 2,
  nonEnum: 3
};

Reflect.ownKeys(obj);
//  ["enum", "nonEnum", Symbol(my_key)]

const set = new Set([1, 2, 3, 4, 4]);
// 转换为数组
[...set];
// [1, 2, 3, 4]

let set = new Set(["red", "green", "blue"]);

for (let item of set) {
  console.log(item);
}
// red
// green
// blue

for (let item of set.keys()) {
  console.log(item);
}
// red
// green
// blue

for (let item of set.values()) {
  console.log(item);
}
// red
// green
// blue

for (let item of set.entries()) {
  console.log(item);
}
// ["red", "red"]
// ["green", "green"]
// ["blue", "blue"]

const m = new Map();
const o = { p: "Hello World" };

m.set(o, "content");
m.get(o); // "content"

m.has(o); // true
m.delete(o); // true
m.has(o); // false

const map = new Map([["name", "张三"], ["title", "Author"]]);

map.size; // 2
map.has("name"); // true
map.get("name"); // "张三"
map.has("title"); // true
map.get("title"); // "Author"

const map = new Map([["F", "no"], ["T", "yes"]]);

for (let [key, value] of map) {
  console.log(key, value);
}
// "F" "no"
// "T" "yes"

for (let key of map.keys()) {
  console.log(key);
}
// "F"
// "T"

for (let value of map.values()) {
  console.log(value);
}
// "no"
// "yes"

for (let item of map.entries()) {
  console.log(item[0], item[1]);
}
// "F" "no"
// "T" "yes"

// bad
function test(color) {
  switch (color) {
    case "red":
      return ["apple", "strawberry"];
    case "yellow":
      return ["banana", "pineapple"];
    case "purple":
      return ["grape", "plum"];
    default:
      return [];
  }
}

// better
const fruitColor = new Map()
  .set("red", ["apple", "strawberry"])
  .set("yellow", ["banana", "pineapple"])
  .set("purple", ["grape", "plum"]);

function test(color) {
  return fruitColor.get(color) || [];
}

const items = ["zero", "one", "two"];
const it = items[Symbol.iterator]();

it.next();
// {value: "zero", done: false}
it.next();
// {value: "one", done: false}
it.next();
// {value: "two", done: false}
it.next();
// {value: undefined, done: true}

doA(function() {
  doC();
  doD(function() {
    doF();
  });
  doE();
});
doB();

const myPromise = new Promise(function(resolve, reject) {
  // ... some code

  if (/* 异步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});

myPromise.then(
    function(value) {
    // success
    },
    function(error) {
    // failure
    }
);

const p = Promise.all([p1, p2, p3]);

const p = Promise.race([p1, p2, p3]);

let thenable = {
  then: function(resolve, reject) {
    resolve(42);
  }
};

let p1 = Promise.resolve(thenable);
p1.then(function(value) {
  console.log(value); // 42
});

const p = Promise.resolve("Hello");

p.then(function(s) {
  console.log(s);
});
// Hello

function* helloWorldGenerator() {
  yield "hello";
  yield "world";
  return "ending";
}

var hw = helloWorldGenerator();

hw.next();
// { value: 'hello', done: false }

hw.next();
// { value: 'world', done: false }

hw.next();
// { value: 'ending', done: true }

hw.next();
// { value: undefined, done: true }

const asyncFun = async function() {
  let a = await new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve("Hello");
    }, 1000);
  });

  let b = await new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve("World");
    }, 1000);
  });

  return a + " " + b;
};

asyncFun().then(result => {
  console.log(result); // Hello World
});

async function main() {
  try {
    const val1 = await firstStep();
    const val2 = await secondStep(val1);
    const val3 = await thirdStep(val1, val2);

    console.log("Final: ", val3);
  } catch (err) {
    console.error(err);
  }
}

async function async1(){
  console.log('async1 start');
  await async2();
  console.log('async1 end')
}
async function async2(){
  console.log('async2')
}
console.log('script start');
setTimeout(function(){
  console.log('setTimeout')
},0);
async1();
new Promise(function(resolve){
  console.log('promise1');
  resolve();
}).then(function(){
  console.log('promise2')
});
console.log('script end')

// script start
// async1 start
// async2
// promise1
// script end
// async1 end
// promise2
// setTimeout

Function.prototype.call2 = function(context) {
  if (typeof this !== "function") {
    throw new Error("不是函数");
  }

  var context = context || window;
  context.fn = this;

  var args = [];
  for (var i = 1, len = arguments.length; i < len; i++) {
    args.push("arguments[" + i + "]");
  }

  var result = eval("context.fn(" + args + ")");

  delete context.fn;
  return result;
};

Function.prototype.apply = function(context, arr) {
  if (typeof this !== "function") {
    throw new Error("不是函数");
  }

  var context = Object(context) || window;
  context.fn = this;

  var result;
  if (!arr) {
    result = context.fn();
  } else {
    var args = [];
    for (var i = 0, len = arr.length; i < len; i++) {
      args.push("arr[" + i + "]");
    }
    result = eval("context.fn(" + args + ")");
  }

  delete context.fn;
  return result;
};

Function.prototype.bind2 = function(context) {
  if (typeof this !== "function") {
    throw new Error("不是函数");
  }

  var fn = this;
  var args = Array.prototype.slice.call(arguments, 1);

  var fNOP = function() {};

  var fBound = function() {
    var bindArgs = Array.prototype.slice.call(arguments);
    return fn.apply(
      this instanceof fNOP ? this : context,
      args.concat(bindArgs)
    );
  };

  fNOP.prototype = this.prototype;
  fBound.prototype = new fNOP();

  return fBound;
};

var arrayLike = {
  0: "name",
  1: "age",
  2: "gender",
  length: 3
};

var arrayLike = { 0: "name", 1: "age", 2: "sex", length: 3 };

Array.prototype.join.call(arrayLike, "&"); // name&age&sex

Array.prototype.slice.call(arrayLike, 0); // ["name", "age", "sex"]
// slice可以做到类数组转数组

Array.prototype.map.call(arrayLike, function(item) {
  return item.toUpperCase();
});

var arrayLike = { 0: "name", 1: "age", 2: "sex", length: 3 };
// 1. slice
Array.prototype.slice.call(arrayLike, 0); // ["name", "age", "sex"]
// 2. splice
Array.prototype.splice.call(arrayLike, 0); // ["name", "age", "sex"]
// 3. ES6 Array.from
Array.from(arrayLike); // ["name", "age", "sex"]
// 4. apply
Array.prototype.concat.apply([], arrayLike);
// 5. Object.assign
Object.assign([], arrayLike);

/**
 * 防抖函数，返回函数连续调用时，空闲时间必须大于或等于 wait，func 才会执行
 *
 * @param  {function} func        回调函数
 * @param  {number}   wait        表示时间窗口的间隔
 * @param  {boolean}  immediate   设置为 ture 时，是否立即调用函数
 * @return {function}             返回客户调用函数
 */
function debounce(func, wait = 50, immediate = true) {
  let timer, context, args;

  // 延迟执行函数
  const later = () =>
    setTimeout(() => {
      // 延迟函数执行完毕，清空缓存的定时器序号
      timer = null;
      // 延迟执行的情况下，函数会在延迟函数中执行
      // 使用到之前缓存的参数和上下文
      if (!immediate) {
        func.apply(context, args);
        context = args = null;
      }
    }, wait);

  // 这里返回的函数是每次实际调用的函数
  return function(...params) {
    // 如果没有创建延迟执行函数（later），就创建一个
    if (!timer) {
      timer = later();
      // 如果是立即执行，调用函数
      // 否则缓存参数和调用上下文
      if (immediate) {
        func.apply(this, params);
      } else {
        context = this;
        args = params;
      }
      // 如果已有延迟执行函数（later），调用的时候清除原来的并重新设定一个
      // 这样做延迟函数会重新计时
    } else {
      clearTimeout(timer);
      timer = later();
    }
  };
}

// 第一版
function throttle(func, wait = 1000) {
  var context, args;
  var previous = 0;

  return function() {
    // 使用 + 将时间转换成 Number 类型
    var now = +new Date();
    context = this;
    args = arguments;
    if (now - previous > wait) {
      func.apply(context, args);
      previous = now;
    }
  };
}

function throttle(func, wait = 1000) {
  var timer, context, args;
  return function() {
    context = this;
    args = arguments;
    if (!timer) {
      timer = setTimeout(() => {
        func.apply(context, args);
        timer = null;
      }, wait);
    }
  };
}

// 实例化
let xhr = new XMLHttpRequest();
// 初始化
xhr.open(method, url, async);
// 发送请求。如果请求是异步的（默认），那么该方法将在请求发送后立即返回
xhr.send(data)
// 设置状态变化回调函数, 处理请求结果
xhr.onreadystatechange = () => {
  if (xhr.readyStatus === 4 && xhr.status === 200) {
    console.log(xhr.responseText)
  }
}

function ajax (options) {
  // 请求地址
  const url = options.url
  // 请求方法
  const method = options.method.toLocaleLowerCase() || 'get'
  // 默认为异步true
  const async = options.async
  // 请求参数
  const data = options.data
  // 实例化
  const xhr = new XMLHttpRequest()
  // 请求超时
  if (options.timeout && options.timeout > 0) {
    xhr.timeout = options.timeout
  }
  // 返回一个Promise实例
  return new Promise ((resolve, reject) => {
    xhr.ontimeout = () => reject && reject('请求超时')
    // 监听状态变化回调
    xhr.onreadystatechange = () => {
      if (xhr.readyState == 4) {
        // 200-300 之间表示请求成功，304资源未变，取缓存
        if (xhr.status >= 200 && xhr.status < 300 || xhr.status == 304) {
          resolve && resolve(xhr.responseText)
        } else {
          reject && reject()
        }
      }
    }
    // 错误回调
    xhr.onerror = err => reject && reject(err)
    let paramArr = []
    let encodeData
    // 处理请求参数
    if (data instanceof Object) {
      for (let key in data) {
        // 参数拼接需要通过 encodeURIComponent 进行编码
        paramArr.push(encodeURIComponent(key) + '=' + encodeURIComponent(data[key]))
      }
      encodeData = paramArr.join('&')
    }
    // get请求拼接参数
    if (method === 'get') {
      // 检测url中是否已存在 ? 及其位置
      const index = url.indexOf('?')
      if (index === -1) url += '?'
      else if (index !== url.length -1) url += '&'
      // 拼接url
      url += encodeData
    }

    // 初始化
    xhr.open(method, url, async)
    // 发送请求
    if (method === 'get') xhr.send(null)
    else {
      // post 方式需要设置请求头
      xhr.setRequestHeader('Content-Type','application/x-www-form-urlencoded;charset=UTF-8')
      xhr.send(encodeData)
    }
  })
}

function removeDuplicates(arr) {
  const obj = {};
  for (let i = 0; i < arr.length; i++) {
    const item = arr[i];
    if (obj.hasOwnProperty(item)) {
      arr.splice(i, 1);
      i--;
    }
    obj[item] = item;
  }

  return arr.length;
}

function arrRotate(arr, num) {
  if (num <= 0) return arr;
  for (let i = 0; i < num; i++) {
    arr.unshift(arr[arr.length - 1]);
    arr.pop();
  }
}

function maxProfit(arr) {
  let totalProfit = 0;

  for (let i = 0; i < arr.length - 1; i++) {
    const curValue = arr[i];
    const nextValue = arr[i + 1];
    if (nextValue > curValue) {
      totalProfit += nextValue - curValue;
    }
  }

  return totalProfit;
}

function maxProfit2(arr) {
  const record = [];
  let totalProfit = 0;
  let buyIndex = 0;
  let sellIndex = 0;

  for (let i = 0; i < arr.length - 1; i++) {
    const curValue = arr[i];
    const nextValue = arr[i + 1];
    if (nextValue >= curValue) {
      sellIndex = i + 1;
    } else {
      if (sellIndex !== buyIndex) {
        totalProfit += arr[sellIndex] - arr[buyIndex];
        record.push({
          buy: buyIndex,
          sell: sellIndex
        });
      }
      buyIndex = i + 1;
      sellIndex = i + 1;
    }
  }

  if (sellIndex !== buyIndex) {
    totalProfit += arr[sellIndex] - arr[buyIndex];
    record.push({
      buy: buyIndex,
      sell: sellIndex
    });
  }

  return totalProfit;
}

function LinkedList() {
  this.head = null;
}

function LinkedNode(value) {
  this.value = value;
  this.next = null;
}

LinkedList.prototype.insertNode = function(value, index) {
  const node = new LinkedNode(value);
  if (this.head === null) this.head = node;
  else {
    let current = this.head;
    let curIndex = 0;
    while (current.next && index !== curIndex) {
      current = current.next;
      curIndex++;
    }
    node.next = current.next;
    current.next = node;
  }
  return this.head;
};

LinkedList.prototype.deleteNode = function(index) {
  let current = this.head;
  let previous = null;
  let curIndex = 0;
  if (index === 0) this.head = current.next;
  else {
    while (current.next && curIndex !== index) {
      previous = current;
      current = current.next;
      curIndex++;
    }
    previous.next = current.next;
  }
};

LinkedList.prototype.reverse = function() {
  if (this.head === null || this.head.next === null) return this.head;
  let current = this.head;
  let previous = null;
  let next = current.next;
  current.next = null;

  while (next) {
    previous = current;
    current = next;
    next = current.next;
    current.next = previous;
  }
  this.head = current;
};

LinkedList.prototype.reverse = function() {
  if (this.head === null || this.head.next === null) return this.head;
  const current = this.head;
  const reverse = function(previous, current) {
    let head = null;
    const next = current.next;

    if (next) head = reverse(current, next);
    else head = current;
    current.next = previous;

    return head;
  };
  this.head = reverse(current, current.next);
  current.next = null;
};

function DoubleLinkedList() {
  this.head = null;
  this.tail = null;
}

function DoubleLinkedNode(value) {
  this.value = value;
  this.prev = null;
  this.next = null;
}

DoubleLinkedList.prototype.insertNode = function(value, index) {
  const node = new DoubleLinkedNode(value);
  let current = this.head;
  let curIndex = 0;

  // 插入到头部
  if (index <= 0 || current === null) {
    node.next = current;
    this.head = node;
    return this.head;
  }

  //找到目标节点
  while (current.next && index !== curIndex) {
    current = current.next;
    curIndex++;
  }

  //插入到尾部
  if (current.next === null) {
    node.prev = current;
    node.next = current.next;
    current.next = node;
    this.tail = node;
    // 插入到目标节点处
  } else {
    current.prev.next = node;
    node.prev = current.prev;
    node.next = current;
    current.prev = node;
  }

  return this.head;
};

DoubleLinkedList.prototype.deleteNode = function(index) {
  if (this.head === null || this.head.next === null) {
    this.head = null;
    return this.head;
  }

  if (index <= 0) {
    this.head = this.head.next;
    this.head.prev = null;
    return this.head;
  }

  let current = this.head;
  let curIndex = 0;

  while (current.next && index !== curIndex) {
    current = current.next;
    curIndex++;
  }

  if (current.next === null) {
    current.prev.next = null;
    this.tail = current.prev;
  } else {
    current.prev.next = current.next;
    current.next.prev = current.prev;
  }

  return this.head;
};

function bubble_sort(unsorted) {
  // 外循环: 每次循环确定一个项的正确顺序.
  for (let i = 0; i < unsorted.length; i++) {
    // 内循环: 每次循环对比相邻两个项的大小, 小的放在前, 大的放在后.
    for (let j = 0; j < unsorted.length - i - i; j++) {
      if (unsorted[j] > unsorted[j + 1]) {
        const temp = unsorted[j];
        unsorted[j] = unsorted[j + 1];
        unsorted[j + 1] = temp;
      }
    }
  }
}

function select_sort(unsorted) {
  for (let i = 0; i < unsorted.length; i++) {
    let minIndex = i;
    for (let j = i + 1; j < unsorted.length; j++) {
      minIndex = unsorted[j] < unsorted[minIndex] ? j : minIndex;
    }
    let temp = unsorted[i];
    unsorted[i] = unsorted[minIndex];
    unsorted[minIndex] = temp;
  }
}

function insert_sort(unsorted) {
  for (let i = 1; i < unsorted.length; i++) {
    let temp = unsorted[i];
    let j = i;
    while (j > 0 && unsorted[j - 1] > temp) {
      unsorted[j] = unsorted[j - 1];
      j--;
    }
    unsorted[j] = temp;
  }
}

function merge_sort(unsorted) {
  const merge = function(left, right) {
    const result = [];
    let i = 0,
      j = 0;

    while (i < left.length && j < right.length) {
      if (left[i] <= right[j]) {
        result.push(left[i]);
        i++;
      } else {
        result.push(right[j]);
        j++;
      }
    }
    while (i < left.length) {
      result.push(left[i]);
      i++;
    }
    while (j < right.length) {
      result.push(right[j]);
      j++;
    }

    return result;
  };

  const divide = function(arr) {
    if (arr.length <= 1) return arr;
    const mid = Math.floor(arr.length / 2);
    const left = arr.slice(0, mid);
    const right = arr.slice(mid, arr.length);
    return merge(divide(left), divide(right));
  };

  return divide(unsorted);
}

function quick_sort(unsorted) {
  const partition = function(arr, left, right) {
    const index = Math.floor((left + right) / 2);
    const pivot = arr[index];
    let i = left;
    let j = right;
    while (i <= j) {
      while (arr[i] < pivot) {
        i++;
      }
      while (arr[j] > pivot) {
        j--;
      }
      if (i <= j) {
        const temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        i++;
        j--;
      }
    }
    return i;
  };
  const quick = function(arr, left, right) {
    if (right - left < 1) return;
    let index = partition(arr, left, right);
    if (left < index - 1) {
      quick(arr, left, index - 1);
    }
    if (right > index) {
      quick(arr, index, right);
    }
  };
  quick(unsorted, 0, unsorted.length - 1);
}

// 判断字符串是否包含数字
var regx = /\d/;

// 判断电话号码
var regx = /^1[34578]\d{9}$/;

// 判断是否符合指定格式 XXX-XXX-XXXX, X 为 Number 类型
var regx = /^(\d{3}-){2}\d{4}&/;

// 判断连续重复字母
var regExp = /([a-zA-Z])\1/;

// 获取 url 参数
var regx = /\??(\w+)=(\w+)&?/g;

// 验证邮箱
var regx = /^([a-zA-Z0-9_\-])+@([a-zA-Z0-9_\-])+(\.[a-zA-Z0-9_\-])+$/;

// 去除首尾的'/'
var regx = /^\/*|\/*$/g;

// 写一个正则表达式,匹配 "<OPTION value="待处理">"
var str = '<OPTION value="待处理">待处理</OPTION>';
var regx = /^<.*?>/;

// 敏感词过滤
var str = '我草你妈哈哈背景天胡景涛哪肉涯剪短发欲望';
var regExp = /草|肉|欲|胡景涛/g;

// moduleA.js
module.exports = function( value ){
    return value * 2;
}

// moduleB.js
var multiplyBy2 = require('./moduleA');
var result = multiplyBy2(4);

/** 网页中引入require.js及main.js **/
<script src="js/require.js" data-main="js/main"></script>

/** main.js 入口文件/主模块 **/
// 首先用config()指定各模块路径和引用名
require.config({
  baseUrl: "js/lib",
  paths: {
    "jquery": "jquery.min",  //实际路径为js/lib/jquery.min.js
    "underscore": "underscore.min",
  }
});
// 执行基本操作
require(["jquery","underscore"], function($,_){
  // some code here
});

// 定义math.js模块
define(function () {
    var basicNum = 0;
    var add = function (x, y) {
        return x + y;
    };
    return {
        add: add,
        basicNum :basicNum
    };
});

// 定义一个依赖underscore.js的模块
define(['underscore'], function(_){
  var classify = function(list){
    _.countBy(list,function(num){
      return num > 30 ? 'old' : 'young';
    })
  };
  return {
    classify :classify
  };
})

// 引用模块，将模块放在[]内
require(['jquery', 'math'], function($, math){
  var sum = math.add(10,20);
  $("#sum").html(sum);
});

/** AMD写法 **/
define(["a", "b", "c", "d", "e", "f"], function(a, b, c, d, e, f) { 
     // 等于在最前面声明并初始化了要用到的所有模块
    a.doSomething();
    if (false) {
        // 即便没用到某个模块 b，但 b 还是提前执行了
        b.doSomething()
    } 
});

/** CMD写法 **/
define(function(require, exports, module) {
    var a = require('./a'); // 依赖可以就近书写
    a.doSomething();
    if (false) {
        var b = require('./b');
        b.doSomething();
    }
});

/** sea.js **/
// 定义模块 math.js
define(function(require, exports, module) {
    var $ = require('jquery.js');
    var add = function(a,b){
        return a+b;
    }
    exports.add = add;
});

// 加载模块
seajs.use(['math.js'], function(math){
    var sum = math.add(1+2);
});

/** 定义模块 math.js **/
var basicNum = 0;
var add = function (a, b) {
    return a + b;
};
export { basicNum, add };

/** 引用模块 **/
import { basicNum, add } from './math';
function test(ele) {
    ele.textContent = add(99 + basicNum);
}

/** export default **/
//定义输出
export default { basicNum, add };
//引入
import math from './math';
function test(ele) {
    ele.textContent = math.add(99 + math.basicNum);
}

<script src="http://domain/api?param1=a&param2=b&callback=jsonp"></script>
<script>
function jsonp(data) {
  console.log(data)
}
</script>

handleCallback({"status": true, "user": "admin"});

Access-Control-Allow-Origin: *

// 使用方法存储数据
locaStorage.setItem("name", "Srtian")
// 使用属性存储数据
locaStorage.say = "Hello world"
// 使用方法读取数据
const name = locaStorage.getItem("name")
// 使用属性读取数据
const say = locaStorage.say
// 删除数据
locaStorage.removeItem("name")

// 保存数据到sessionStorage
sessionStorage.setItem('name', 'Srtian');

// 从sessionStorage获取数据
var data = sessionStorage.getItem('name');

// 从sessionStorage删除保存的数据
sessionStorage.removeItem('name');

// 从sessionStorage删除所有保存的数据
sessionStorage.clear();

function escape(str) {
  str = str.replace(/&/g, '&')
  str = str.replace(/</g, '&lt;')
  str = str.replace(/>/g, '&gt;')
  str = str.replace(/"/g, '&quto;')
  str = str.replace(/'/g, '&#39;')
  str = str.replace(/`/g, '&#96;')
  str = str.replace(/\//g, '&#x2F;')
  return str
}

// 只允许加载本站资源
Content-Security-Policy: default-src ‘self’
// 只允许加载 HTTPS 协议图片
Content-Security-Policy: img-src https://*