let xhr = new XMLHttpRequest();
xhr.open(url);
xhr.send();
xhr.onload = function(){}

fetch([url,options]).then(res = > {});

// http.js文件
import axios from 'axios';
import qs from 'qs'; //请求格式的转换第三方库

// webpack中可配置在什么模式下对应的地址，生产模式有两种，默认为生产环境
/* 
	根据环境变量区分接口的默认地址
*/
switch(process.env.NODE_ENV){
	case "production":
		axios.default.baseURL = "上线地址";     //在路径前面统一加上该基本地址
		break;
	case "test":
		axios.default.baseURL = "公司给的测试地址";
		break;
	defalut:
		axios.default.baseURL = "localhost:8080";
}
/* 
	设置超时时间和跨域是否允许携带凭证，如果不能携带，则你的登录校验走不了session，cookie路径
*/
axios.defaults.timeout = 10000;
axios.defaults.withCredentials = true;
/*  
	设置请求传递的数据格式,有后端决定，因为get请求是这种数据格式（xxx=xxx&&sss=sss），所以数据格式类型设置为x-www-form-urlencoded
*/
axios.defaults.headers['Content-Type'] = 'application/x-www-form-urlencoded';
/*
	以下这种请求格式的转换一般适用于post请求
*/
axios.defaults.transformRequest = data => {
    qs.stringify(data);  //将数据格式转为aaa=xxx的格式
};

/*
	设置请求拦截器
	客户端发送请求->[请求拦截器]->服务器
	TOKEN校验【JWT】，接收服务器返回的TOKEN，存储到vuex/本地存储中，每次向服务器发起请求，我们都需要吧token带上
*/
axios.interceptors.request.use(config=> {
    // 获取本地的token，有者带上本地token发给后端
    let token = localStorage.getItem('token');
    token && (config.headers.Aythorization = token);
    //必须返回配置项，否则根本更改不了发给后端的头权限
    return config;
},err => {
    return Promise.reject(err);
});
/*
	响应拦截器
	服务器返回信息 -> 【拦截的统一处理】 -> 客户端js获取到信息
*/
axios.defaults.validateStatus = status => {
    //自定义响应成功的HTTP状态码
    return /^(2|3)\d{2}$/.test(status);
};
axios.interceptors.response.use( res => {},err ==> {})

{
    "posts": [
      { "id": 1, "title": "json-server", "author": "typicode" }
    ],
    "comments": [
      { "id": 1, "body": "some comment", "postId": 1 }
    ],
    "profile": { "name": "typicode" }
  }

const RandomId = len => Math.random().toString(36).substr(3,len);
const id = RandomId(10);

const RandomColor = () => '#' + Math.floor(Math.random() * 0xffffff).toString(16).padEnd(6,'0');

const StarScore = rate => '★★★★★☆☆☆☆☆'.slice(5 - rate, 10 - rate);

const params = new URLSearchParams(location.search.replace(/\?/ig,""));    //location.search="?name=young&sex=male"
params.has("young");    //true
params.get("sex");    //male

const num1 = ~~1.69;
const nums2 = 1.69 | 0;
const num3 = 1.69 >> 0;
/*
num1   1
num2   1
num3   1
*/

const FillZero = (num,len) => num.toString().padstart(len,"0");
const num = FillZero(152,5);
// num => "00152"

const num1 = +null;
const num2 = +"";
const num3 = +false;
const num4 = +"169";
// num1  num2  num3  num4 => 0 0 0 169

const RoundNum = (num,decimal) => Math.round(num * 10 ** decimal) / 10 ** decimal;
const num = RoundNum(1.69,1);
// num =>  1.7

const OddEven = num => !!(num & 1) ? 'odd' : "even";
const num = OddEven(2);
// num => "even"

const a = d && 1;  //满足条件赋值：取假运算，从左到右依次判断，遇到假值返回假值，后面不再执行，否则返回最后一个真值。
const b = d || 1;  //默认赋值：取真运算，从左到右依次运判断，遇到真值，后面不再执行，否则返回最后一个假值。
const c = !d;   //取假赋值：单个表达式转换为true则返回false，否则返回true。

function DateType(tgt,type){
	const dataType = Object.prototype.toString.call(tgt).replace(/\[object (\w+)\]/,"$1").toLowerCase();
	return type ? dataType === type : dataType;
}
DataType("young"); // "string"
DataType(20190214); // "number"
DataType(true); // "boolean"
DataType([], "array"); // true
DataType({}, "array"); // false

const arr = [];
const flag = Array.isArray(arr) && !arr.length;
// flag => true

const obj = {};
const flag = DataType(obj,"object") && !Object.keys(obj).length;
// flag => true

const flagA = true;
const flagB = false;
(flagA || flagB) && Func();  // 满足A或B时执行
(flagA || !flagB) && Func();   //满足A或不满足B时执行
flagA && flagB && Func();  //同时满足A和B时执行
flagA && ！flagB && Func();   //满足A且不满足B时执行

const flag = false; // undefined、null、""、0、false、NaN
!flag && Func();

const obj = { a: 0, b: 1, c: 2 };
Object.keys(obj).length && Func();

if (flag) {
    Func();
    return false;
}
// 换成
if (flag) {
    return Func();
}

const age = 26;
switch (true) {
    case isNaN(age):
        console.log("not a number");
        break;
    case (age < 18):
        console.log("under age");
        break;
    case (age >= 18):
        console.log("adult");
        break;
    default:
        console.log("please set your age");
        break;
}

const _arr = [0,1,2];
const arr = [...arr];
// arr => [0,1,2]

const arr = [...new Set([0,1,0,1,null,null])];
// arr => [0,1,null]

const arr = [0,1,2,3,4,5].slice().sort(() => Math.random() - 0.5);
// arr => [1,0,2,5,3,4]

const arr = [0,1,2];
arr.length = 2;
arr => [0,1]

let a = 0;
let b = 1;
[a,b] = [b,a];
// a b => 1 0

const arr = [undefined,null,“”,0,false,NaN,1,2].filter(Boolean);
// arr => [1,2]

const obj = Object.create(null);
Object.prototype.a = 0;
// obj => {}

const obj = { a: 0, b: 1, c: 2 }; // 只想拿b和c
const { a, ...rest } = obj;
// rest => { b: 1, c: 2 }

const obj = { a: 0, b: 1, c: { d: 2, e: 3 } };
const { c: { d, e } } = obj;
// d e => 2 3

const obj = { a: 0, b: 1, c: 2 };
const { a, b: d, c: e } = obj;
// a d e => 0 1 2

const obj = { a: 0, b: 1, c: 2 };
const { a, b = 2, d = 3 } = obj;
// a b d => 0 1 3

const Func = function() {}(); // 常用

(function() {})(); // 常用
(function() {}()); // 常用
[function() {}()];

+ function() {}();
- function() {}();
~ function() {}();
! function() {}();

new function() {};
new function() {}();
void function() {}();
typeof function() {}();
delete function() {}();

1, function() {}();
1 ^ function() {}();
1 > function() {}();

const Func = function(name) {
    return "I Love " + name;
};
// 换成
const Func = name => "I Love " + name;

function Func() {
    console.log("x");
    Func = function() {
        console.log("y");
    }
}

function Func() {
    if (a === b) {
        console.log("x");
    } else {
        console.log("y");
    }
}
// 换成
function Func() {
    if (a === b) {
        Func = function() {
            console.log("x");
        }
    } else {
        Func = function() {
            console.log("y");
        }
    }
    return Func();
}

function IsRequired() {
    throw new Error("param is required");
}
function Func(name = IsRequired()) {
    console.log("I Love " + name);
}
Func(); // "param is required"
Func("You"); // "I Love You"

const Func = new Function("name", "console.log(\"I Love \" + name)");

try {
    Func();
} catch (e) {
    location.href = "https://stackoverflow.com/search?q=[js]+" + e.message;
}

function AsyncTo(promise) {
    return promise.then(data => [null, data]).catch(err => [err]);
}
const [err, res] = await AsyncTo(Func());

function Func() {
    return Promise.all([
        fetch("/user"),
        fetch("/comment")
    ]);
}
const [user, comment] = await Func(); // 需在async包围下使用

[].forEach.call($$("*"), dom => {
    dom.style.outline = "1px solid #" + (~~(Math.random() * (1 << 24))).toString(16);
});

function AutoResponse(width = 750) {
    const target = document.documentElement;
    target.clientWidth >= 600
        ? (target.style.fontSize = "80px")
        : (target.style.fontSize = target.clientWidth / width * 100 + "px");
}

function FilterXss(content) {
    let elem = document.createElement("div");
    elem.innerText = content;
    const result = elem.innerHTML;
    elem = null;
    return result;
}

const love = JSON.parse(localStorage.getItem("love"));
localStorage.setItem("love", JSON.stringify("I Love You"));

(_=>[..."`1234567890-=~~QWERTYUIOP[]\\~ASDFGHJKL;'~~ZXCVBNM,./~"].map(x=>(o+=`/${b='_'.repeat(w=x<y?2:' 667699'[x=["Bs","Tab","Caps","Enter"][p++]||'Shift',p])}\\|`,m+=y+(x+'    ').slice(0,w)+y+y,n+=y+b+y+y,l+=' __'+b)[73]&&(k.push(l,m,n,o),l='',m=n=o=y),m=n=o=y='|',p=l=k=[])&&k.join`
`)()

const arr = [3, 5, 1, 4, 2];
const a = arr.reduce((t, v) => t + v);
// 等同于
const b = arr.reduce((t, v) => t + v, 0);

function Accumulation(...vals){
	return vals.reduce((total,value) => {
		total + value
	},0);
}

function Multiplication(...vals){
	return vals.reduce((total,value) => {
		total * value
	},1);
}

const scores = [
    { score: 90, subject: "chinese", weight: 0.5 },
    { score: 95, subject: "math", weight: 0.3 },
    { score: 85, subject: "english", weight: 0.2 }
];
const result = scores.reduce((t, v) => t + v.score * v.weight, 0); // 90.5

function Reverse(arr = []) {
    return arr.reduceRight((t, v) => (t.push(v), t), []);
}

Reverse([1, 2, 3, 4, 5]); // [5, 4, 3, 2, 1]

const arr = [0,1,2,3];

// 代替map：[0, 2, 4, 6]
const a = arr.map(v => v * 2);
const b = arr.reduce((t, v) => [...t, v * 2], []);

// 代替filter：[2, 3]
const c = arr.filter(v => v > 1);
const d = arr.reduce((t, v) => v > 1 ? [...t, v] : t, []);

// 代替map和filter：[4, 6]
const e = arr.map(v => v * 2).filter(v => v > 2);
const f = arr.reduce((t, v) => v * 2 > 2 ? [...t, v * 2] : t, []);

const scores = [
    { score: 45, subject: "chinese" },
    { score: 90, subject: "math" },
    { score: 60, subject: "english" }
];

// 代替some：至少一门合格
const isAtLeastOneQualified = scores.reduce((t, v) => t || v.score >= 60, false); // true

// 代替every：全部合格
const isAllQualified = scores.reduce((t, v) => t && v.score >= 60, true); // false

function Chunk(arr = [], size = 1) {
    return arr.length ? arr.reduce((t, v) => (t[t.length - 1].length === size ? t.push([v]) : t[t.length - 1].push(v), t), [[]]) : [];
}
 
const arr = [1, 2, 3, 4, 5];
Chunk(arr, 2); // [[1, 2], [3, 4], [5]]

function Difference(arr = [], oarr = []) {
    return arr.reduce((t, v) => (!oarr.includes(v) && t.push(v), t), []);
}
 
const arr1 = [1, 2, 3, 4, 5];
const arr2 = [2, 3, 6]
Difference(arr1, arr2); // [1, 4, 5]

function Fill(arr = [], val = "", start = 0, end = arr.length) {
    if (start < 0 || start >= end || end > arr.length) return arr;
    return [
        ...arr.slice(0, start),
        ...arr.slice(start, end).reduce((t, v) => (t.push(val || v), t), []),
        ...arr.slice(end, arr.length)
    ];
}
 
const arr = [0, 1, 2, 3, 4, 5, 6];
Fill(arr, "aaa", 2, 5); // [0, 1, "aaa", "aaa", "aaa", 5, 6]

function Flat(arr = []) {
    return arr.reduce((t, v) => t.concat(Array.isArray(v) ? Flat(v) : v), [])
}
 
const arr = [0, 1, [2, 3], [4, 5, [6, 7]], [8, [9, 10, [11, 12]]]];
Flat(arr); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

function Uniq(arr = []) {
    return arr.reduce((t, v) => t.includes(v) ? t : [...t, v], []);
}
 
const arr = [2, 1, 0, 3, 2, 1, 2];
Uniq(arr); // [2, 1, 0, 3]

function Max(arr = []) {
    return arr.reduce((t, v) => t > v ? t : v);
}

function Min(arr = []) {
    return arr.reduce((t, v) => t < v ? t : v);
}
 
const arr = [12, 45, 21, 65, 38, 76, 108, 43];
Max(arr); // 108
Min(arr); // 12

function Unzip(arr = []) {
    return arr.reduce(
        (t, v) => (v.forEach((w, i) => t[i].push(w)), t),
        Array.from({ length: Math.max(...arr.map(v => v.length)) }).map(v => [])
    );
}
 js
const arr = [["a", 1, true], ["b", 2, false]];
Unzip(arr); // [["a", "b"], [1, 2], [true, false]]

function Count(arr = []) {
    return arr.reduce((t, v) => (t[v] = (t[v] || 0) + 1, t), {});
}

const arr = [0, 1, 1, 2, 2, 2];
Count(arr); // { 0: 1, 1: 2, 2: 3 }

function Position(arr = [], val) {
    return arr.reduce((t, v, i) => (v === val && t.push(i), t), []);
}
const arr = [2, 1, 5, 4, 2, 1, 6, 6, 7];
Position(arr, 2); // [0, 4]

function Group(arr = [], key) {
    return key ? arr.reduce((t, v) => (!t[v[key]] && (t[v[key]] = []), t[v[key]].push(v), t), {}) : {};
}
复制代码
const arr = [
    { area: "GZ", name: "YZW", age: 27 },
    { area: "GZ", name: "TYJ", age: 25 },
    { area: "SZ", name: "AAA", age: 23 },
    { area: "FS", name: "BBB", age: 21 },
    { area: "SZ", name: "CCC", age: 19 }
]; // 以地区area作为分组依据
Group(arr, "area"); // { GZ: Array(2), SZ: Array(2), FS: Array(1) }

function Keyword(arr = [], keys = []) {
    return keys.reduce((t, v) => (arr.some(w => w.includes(v)) && t.push(v), t), []);
}
const text = [
    "今天天气真好，我想出去钓鱼",
    "我一边看电视，一边写作业",
    "小明喜欢同桌的小红，又喜欢后桌的小君，真TM花心",
    "最近上班喜欢摸鱼的人实在太多了，代码不好好写，在想入非非"
];
const keyword = ["偷懒", "喜欢", "睡觉", "摸鱼", "真好", "一边", "明天"];
Keyword(text, keyword); // ["喜欢", "摸鱼", "真好", "一边"]

function ReverseStr(str = "") {
    return str.split("").reduceRight((t, v) => t + v);
}
const str = "reduce最牛逼";
ReverseStr(str); // "逼牛最ecuder"

function ThousandNum(num = 0) {
    const str = (+num).toString().split(".");
    const int = nums => nums.split("").reverse().reduceRight((t, v, i) => t + (i % 3 ? v : `${v},`), "").replace(/^,|,$/g, "");
    const dec = nums => nums.split("").reduce((t, v, i) => t + ((i + 1) % 3 ? v : `${v},`), "").replace(/^,|,$/g, "");
    return str.length > 1 ? `${int(str[0])}.${dec(str[1])}` : int(str[0]);
}

ThousandNum(1234); // "1,234"
ThousandNum(1234.00); // "1,234"
ThousandNum(0.1234); // "0.123,4"
ThousandNum(1234.5678); // "1,234.567,8"

async function AsyncTotal(arr = []) {
    return arr.reduce(async(t, v) => {
        const at = await t;
        const todo = await Todo(v);
        at[v] = todo;
        return at;
    }, Promise.resolve({}));
}
const result = await AsyncTotal(); // 需要在async包围下使用

function Fibonacci(len = 2) {
    const arr = [...new Array(len).keys()];
    return arr.reduce((t, v, i) => (i > 1 && t.push(t[i - 1] + t[i - 2]), t), [0, 1]);
}

Fibonacci(10); // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

function ParseUrlSearch() {
    return location.search.replace(/(^\?)|(&$)/g, "").split("&").reduce((t, v) => {
        const [key, val] = v.split("=");
        t[key] = decodeURIComponent(val);
        return t;
    }, {});
}

// 假设URL为：https://www.baidu.com?age=25&name=TYJ
ParseUrlSearch(); // { age: "25", name: "TYJ" }

function StringifyUrlSearch(search = {}) {
    return Object.entries(search).reduce(
        (t, v) => `${t}${v[0]}=${encodeURIComponent(v[1])}&`,
        Object.keys(search).length ? "?" : ""
    ).replace(/&$/, "");
}
StringifyUrlSearch({ age: 27, name: "YZW" }); // "?age=27&name=YZW"

function GetKeys(obj = {}, keys = []) {
    return Object.keys(obj).reduce((t, v) => (keys.includes(v) && (t[v] = obj[v]), t), {});
}
复制代码
const target = { a: 1, b: 2, c: 3, d: 4 };
const keyword = ["a", "d"];
GetKeys(target, keyword); // { a: 1, d: 4 }

const people = [
    { area: "GZ", name: "YZW", age: 27 },
    { area: "SZ", name: "TYJ", age: 25 }
];
const map = people.reduce((t, v) => {
    const { name, ...rest } = v;
    t[name] = rest;
    return t;
}, {}); // { YZW: {…}, TYJ: {…} }

function Compose(...funs) {
    if (funs.length === 0) {
        return arg => arg;
    }
    if (funs.length === 1) {
        return funs[0];
    }
    return funs.reduce((t, v) => (...arg) => t(v(...arg)));
}

const duplicatedValues = [...new Set(arr1)].filter(item => arr2.includes(item))

const diffValues = [...new Set([...arr1,...arr2])].filter(item => !b.includes(item) || !a.includes(item))

const arr = [1, 2, 3, 4]
const newObj = {...arr} // {0: 1, 1: 2, 2: 3, 3: 4}
const obj = {0: 0, 1: 1, 2: 2, length: 3}
// 对象转数组不能用展开操作符，因为展开操作符必须用在可迭代对象上
let newArr = [...obj] // Uncaught TypeError: object is not iterable...
// 可以使用Array.form()将类数组对象转为数组
let newArr = Array.from(obj) // [0, 1, 2]

/**
 * @param {number[]} nums
 * @return {number}
 */
var findRepeatNumber = function(nums) {
    for(let i = 0; i < nums.length; i++){
        // 利用向前遍历的与向后遍历的下标值不同找出重复值
        if(nums.lastIndexOf(nums[i]) != i){
            return nums[i];
        }
    }
};

// 使用set,因为set自动忽略重复元素，遍历数组中元素，若长度未增加，则输出当前元素
/**
 * @param {number[]} nums
 * @return {number}
 */
var findRepeatNumber = function(nums) {
    let s=new Set();
    for(var i in nums){
        var curLenth=s.size;
        s.add(nums[i]);
        if(s.size==curLenth)
        return nums[i];
    }
};

/**
 * @param {number[][]} matrix
 * @param {number} target
 * @return {boolean}
 */
var findNumberIn2DArray = function(matrix, target) {
    return matrix.flat(Infinity).includes(target);
}

/**
 * @param {number[][]} matrix
 * @param {number} target
 * @return {boolean}
 */
// 从左上角看，其上的数值都比该值小，右边的数值都比该值大
var findNumberIn2DArray = function (matrix, target) {
    if (matrix.length == 0) return false;
    let x = 0;
    let y = matrix.length - 1;
    while (x < matrix[0].length  && y >= 0) {
        if (matrix[y][x] > target) {
            y--;
        } else if (matrix[y][x] < target) {
            x++;
        } else {
            return true;
        }
    }
    return false;
};

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function (nums, target) {
    // 第一种方法
    // var count = 0;
    // for(let val of nums){
    //     if(val == target){
    //         count++;
    //     }
    // }
    // return count;
    // 第二种方法
    // let left = 0,
    //     len = nums.length;
    //     right = len - 1;
    // while(left < len && nums[left] != target){
    //     left++;
    // }
    // while(right > 0 && nums[right] != target){
    //     right--;
    // }
    // return left <= right ? right - left + 1 : 0;

    // 第三种方法
    let left = nums.indexOf(target);
    let right = nums.lastIndexOf(target);
    if(left != -1 && right != -1){
        return right - left + 1;
    }
    return 0;
};