数组API:

var pageIds = new Array();
pageIds.push('A');
//数组长度
pageIds.length;
//shift:删除原数组第一项,并返回删除元素的值;如果数组为空则返回undefined
var a = [1,2,3,4,5];
var b = a.shift(); //a:[2,3,4,5] b:1
//unshift:将参数添加到原数组开头,并返回数组的长度
var a = [1,2,3,4,5];
var b = a.unshift(-2,-1); //a:[-2,-1,1,2,3,4,5] b:7
//注:在IE6.0下测试返回值总为undefined,FF2.0下测试返回值为7,所以这个方法的返回值不可靠,需要用返回值时可用splice代替本方法来使用。
//pop:删除原数组最后一项,并返回删除元素的值;如果数组为空则返回undefined
var a = [1,2,3,4,5];
var b = a.pop(); //a:[1,2,3,4] b:5
//push:将参数添加到原数组末尾,并返回数组的长度
var a = [1,2,3,4,5];
var b = a.push(6,7); //a:[1,2,3,4,5,6,7] b:7
//concat:返回一个新数组,是将参数添加到原数组中构成的
var a = [1,2,3,4,5];
var b = a.concat(6,7); //a:[1,2,3,4,5] b:[1,2,3,4,5,6,7]
//splice(start,deleteCount,val1,val2,):从start位置开始删除deleteCount项,并从该位置起插入val1,val2,
var a = [1,2,3,4,5];
var b = a.splice(2,2,7,8,9); //a:[1,2,7,8,9,5] b:[3,4]
var b = a.splice(0,1); //同shift
a.splice(0,0,-2,-1); var b = a.length; //同unshift
var b = a.splice(a.length-1,1); //同pop
a.splice(a.length,0,6,7); var b = a.length; //同push
//reverse:将数组反序
var a = [1,2,3,4,5];
var b = a.reverse(); //a:[5,4,3,2,1] b:[5,4,3,2,1]
//sort(orderfunction):按指定的参数对数组进行排序
var a = [1,2,3,4,5];
var b = a.sort(); //a:[1,2,3,4,5] b:[1,2,3,4,5]
//slice(start,end):返回从原数组中指定开始下标到结束下标之间的项组成的新数组
var a = [1,2,3,4,5];
var b = a.slice(2,5); //a:[1,2,3,4,5] b:[3,4,5]
//join(separator):将数组的元素组起一个字符串,以separator为分隔符,省略的话则用默认用逗号为分隔符
var a = [1,2,3,4,5];
var b = a.join("|"); //a:[1,2,3,4,5] b:"1|2|3|4|5"

DOM常用API:

getElementById(id) Node 返回指定结点的引用
getElementsByTagName(name) NodeList 返回文档中所有匹配的元素的集合
createElement(name) Node Node
createTextNode(text) Node 创建一个纯文本结点
ownerDocument Document 指向这个节点所属的文档
documentElement Node 返回html节点
document.body Node 返回body节点
//element方法:
getAttribute(attributeName) String 返回指定属性的值
setAttribute(attributeName,value) String 给属性赋值
removeAttribute(attributeName) String 移除指定属性和它的值
getElementsByTagName(name) NodeList 返回结点内所有匹配的元素的集合
//node方法:
appendChild(child) Node 给指定结点添加一个新的子结点
removeChild(child) Node 移除指定结点的子结点
replaceChild(newChild,oldChild) Node 替换指定结点的子结点
insertBefore(newChild,refChild) Node 在同一层级的结点前面插入新结点
hasChildNodes() Boolean 如果结点有子结点则返回true
//node属性:
nodeName String 以字符串的格式存放结点的名称
nodeType String 以整型数据格式存放结点的类型
nodeValue String 以可用的格式存放结点的值
parentNode Node 指向结点的父结点的引用
childNodes NodeList 指向子结点的引用的集合
firstChild Node 指向子结点结合中的第一个子结点的引用
lastChild Node 指向子结点结合中的最后一个子结点的引用
previousSibling Node 指向前一个兄弟节点;如果这个节点就是兄弟节点,那么该值为null
nextSibling Node 指向后一个兄弟节点;如果这个节点就是兄弟节点,那么该值为null

数字方法API

//·数字型(Number)
//1.声明
var i = 1;
var i = new Number(1);
//2.字符串与数字间的转换
var i = 1;
var str = i.toString(); //结果: "1"
var str = new String(i); //结果: "1"
i = parseInt(str); //结果: 1
i = parseFloat(str); //结果: 1.0
//注意: parseInt,parseFloat会把一个类似于"32G"的字符串,强制转换成32
//3.判断是否为有效的数字
var i = 123; var str = "string";
if( typeof i == "number" ){ } //true
//某些方法(如:parseInt,parseFloat)会返回一个特殊的值NaN(Not a Number)
//请注意第2点中的[注意],此方法不完全适合判断一个字符串是否是数字型!!
i = parseInt(str);
if( isNaN(i) ){ }
//4.数字型比较
//此知识与[字符串比较]相同
///5.小数转整数
var f = 1.5;
var i = Math.round(f); //结果:2 (四舍五入)
var i = Math.ceil(f); //结果:2 (返回大于f的最小整数)
var i = Math.floor(f); //结果:1 (返回小于f的最大整数)
//6.格式化显示数字
var i = 3.14159;
//格式化为两位小数的浮点数
var str = i.toFixed(2); //结果: "3.14"
//格式化为五位数字的浮点数(从左到右五位数字,不够补零)
var str = i.toPrecision(5); //结果: "3.1415"
//7.X进制数字的转换
//不是很懂 -.-
var i = parseInt("0x1f",16);
var i = parseInt(i,10);
var i = parseInt("11010011",2);
//8.随机数
//返回0-1之间的任意小数
var rnd = Math.random();
//返回0-n之间的任意整数(不包括n)
var rnd = Math.floor(Math.random() * n)

日期方法API

js简单获取时间格式

var nowDate = new Date();
var DateStr = nowDate.getFullYear()+"-"+((nowDate.getMonth()+1)>=10?+(nowDate.getMonth()+1):"0"+(nowDate.getMonth()+1))+"-"+((nowDate.getDate())>=10?nowDate.getDate():'0'+nowDate.getDate())+"-"+((nowDate.getHours())>=10?nowDate.getHours():'0'+nowDate.getHours())+"-"+((nowDate.getMinutes())>=10?nowDate.getMinutes():'0'+nowDate.getMinutes())+"-"+((nowDate.getSeconds())>=10?nowDate.getSeconds():'0'+nowDate.getSeconds());

//·日期型(Date)
//1.声明
var myDate = new Date(); //系统当前时间
var myDate = new Date(yyyy, mm, dd, hh, mm, ss);
var myDate = new Date(yyyy, mm, dd);
var myDate = new Date("monthName dd, yyyy hh:mm:ss");
var myDate = new Date("monthName dd, yyyy");
var myDate = new Date(epochMilliseconds);
//2.获取时间的某部份
var myDate = new Date();
myDate.getYear(); //获取当前年份(2位)
myDate.getFullYear(); //获取完整的年份(4位,1970-????)
myDate.getMonth(); //获取当前月份(0-11,0代表1月)
myDate.getDate(); //获取当前日(1-31)
myDate.getDay(); //获取当前星期X(0-6,0代表星期天)
myDate.getTime(); //获取当前时间(从1970.1.1开始的毫秒数) 时间戳!!
myDate.getHours(); //获取当前小时数(0-23)
myDate.getMinutes(); //获取当前分钟数(0-59)
myDate.getSeconds(); //获取当前秒数(0-59)
myDate.getMilliseconds(); //获取当前毫秒数(0-999)
myDate.toLocaleDateString(); //获取当前日期
myDate.toLocaleTimeString(); //获取当前时间
myDate.toLocaleString( ); //获取日期与时间
//3.计算之前或未来的时间
var myDate = new Date();
myDate.setDate(myDate.getDate() + 10); //当前时间加10天
//类似的方法都基本相同,以set开头,具体参考第2点
//4.计算两个日期的偏移量
var i = daysBetween(beginDate,endDate); //返回天数
var i = beginDate.getTimezoneOffset(endDate); //返回分钟数
//5.检查有效日期
//checkDate() 只允许"mm-dd-yyyy"或"mm/dd/yyyy"两种格式的日期
if( checkDate("2006-01-01") ){ }
//正则表达式(自己写的检查 yyyy-mm-dd, yy-mm-dd, yyyy/mm/dd, yy/mm/dd 四种)
var r = /^(\d{2}|\d{4})[/-]\d{1,2}[/-]\d{1,2}$/;
if( r.test( myString ) ){ }

字符串方法API

//·字符串(String)
//1.声明
var myString = new String("Every good boy does fine.");
var myString = "Every good boy does fine.";
//2.字符串连接
var myString = "Every " + "good boy " + "does fine.";
var myString = "Every "; myString += "good boy does fine.";
//3.截取字符串
//截取第 6 位开始的字符
var myString = "Every good boy does fine.";
var section = myString.substring(6); //结果: "good boy does fine."
//截取第 0 位开始至第 10 位为止的字符
var myString = "Every good boy does fine.";
var section = myString.substring(0,10); //结果: "Every good"
//截取从第 11 位到倒数第 6 位为止的字符
var myString = "Every good boy does fine.";
var section = myString.slice(11,-6); //结果: "boy does"
//从第 6 位开始截取长度为 4 的字符
var myString = "Every good boy does fine.";
var section = myString.substr(6,4); //结果: "good"
//4.转换大小写
var myString = "Hello";
var lcString = myString.toLowerCase(); //结果: "hello"
var ucString = myString.toUpperCase(); //结果: "HELLO"
//5.字符串比较
var aString = "Hello!";
var bString = new String("Hello!");
if( aString == "Hello!" ){ } //结果: true
if( aString == bString ){ } //结果: true
if( aString === bString ){ } //结果: false (两个对象不同,尽管它们的值相同)
//6.检索字符串
var myString = "hello everybody.";
// 如果检索不到会返回-1,检索到的话返回在该串中的起始位置
if( myString.indexOf("every") > -1 ){ } //结果: true
////7.查找替换字符串
var myString = "I is your father.";
var result = myString.replace("is","am"); //结果: "I am your father."
//8.特殊字符:
//\b : 后退符 \t : 水平制表符
//\n : 换行符 \v : 垂直制表符
//\f : 分页符 \r : 回车符
//" : 双引号 ' : 单引号
//\ : 反斜杆
//9.将字符转换成Unicode编码
var myString = "hello";
var code = myString.charCodeAt(3); //返回"l"的Unicode编码(整型)
var char = String.fromCharCode(66); //返回Unicode为66的字符
//10.将字符串转换成URL编码
var myString = "hello all";
var code = encodeURI(myString); //结果: "hello%20all"
var str = decodeURI(code); //结果: "hello all"
//相应的还有: encodeURIComponent() decodeURIComponent()

数学方法API

  1. Math.abs(num) : 返回num的绝对值
  2. Math.acos(num) : 返回num的反余弦值
  3. Math.asin(num) : 返回num的反正弦值
  4. Math.atan(num) : 返回num的反正切值
  5. Math.atan2(y,x) : 返回y除以x的商的反正切值
  6. Math.ceil(num) : 返回大于num的最小整数
  7. Math.cos(num) : 返回num的余弦值
  8. Math.exp(x) : 返回以自然数为底,x次幂的数
  9. Math.floor(num) : 返回小于num的最大整数
    10.Math.log(num) : 返回num的自然对数
    11.Math.max(num1,num2) : 返回num1和num2中较大的一个
    12.Math.min(num1,num2) : 返回num1和num2中较小的一个
    13.Math.pow(x,y) : 返回x的y次方的值
    14.Math.random() : 返回0到1之间的一个随机数
    15.Math.round(num) : 返回num四舍五入后的值
    16.Math.sin(num) : 返回num的正弦值
    17.Math.sqrt(num) : 返回num的平方根
    18.Math.tan(num) : 返回num的正切值
    19.Math.E : 自然数(2.718281828459045)
    20.Math.LN2 : 2的自然对数(0.6931471805599453)
    21.Math.LN10 : 10的自然对数(2.302585092994046)
    22.Math.LOG2E : log 2 为底的自然数(1.4426950408889634)
    23.Math.LOG10E : log 10 为底的自然数(0.4342944819032518)
    24.Math.PI : π(3.141592653589793)
    25.Math.SQRT1_2 : 1/2的平方根(0.7071067811865476)
    26.Math.SQRT2 : 2的平方根(1.4142135623730951)

获取时间戳字符串

new Date() 
<!-- new一个data对象,当前日期和时间 -->
let time = Date.parse(new Date())
toLocaleString() 
<!-- 方法可根据本地时间把 Date 对象转换为字符串,并返回结果 -->

sessionStorage存取

var cun = sessionStorage.setItem('cun')
var qu = sessionStorage.getItem('qu')
var cun1 = localStorage.setItem('cun1')
var qu1 = localStorage.getItem('qu1')

常用正则

<!-- 身份证 -->
let idCardReg = /^(\d{15}$|^\d{18}$|^\d{17}(\d|X|x))$/;
<!-- 手机号 -->
let phoneReg = /(^1\d{10}$)|(^[0-9]\d{7}$)/;
<!-- 银行卡 16 - 19位数字 -->
let pattern = /^([1-9]{1})(\d{16}|\d{19})$/;

<!-- 将时间戳转换成时间格式,使用正则将时间格式中的中文替换为空,并将 / 替换为 -  -->
var a = new Date(parseInt(updateTime)).toLocaleString().replace(/[\u4e00-\u9fa5]+/g,' ');
var b = a.replace(/\//g,'-')

<!-- 正则全局替换,将所有的a替换为b -->
var result = res.data.replace(/a/g, 'b');

防抖 (debounce): 将多次高频操作优化为只在最后一次执行,通常使用的场景是:用户输入,只需再输入完成后做一次输入校验即可。

<!-- 1.  -->
function debounce(fn, wait, immediate) {
    let timer = null
    return function() {
        let args = arguments
        let context = this
        if (immediate && !timer) {
            fn.apply(context, args)
        }
        if (timer) clearTimeout(timer)
        timer = setTimeout(() => {
            fn.apply(context, args)
        }, wait)
    }
}
<!-- 2. -->
function debounce(func, wait) {
    let timeout = null
    return function() {
        let context = this
        let args = arguments
        if (timeout) clearTimeout(timeout)
        timeout = setTimeout(() => {
            func.apply(context, args)
        }, wait)
    }
}

节流(throttle): 每隔一段时间后执行一次,也就是降低频率,将高频操作优化成低频操作,通常使用场景: 滚动条事件 或者 resize 事件,通常每隔 100~500 ms执行一次即可

<!-- 1. -->
function throttle(fn, wait, immediate) {
    let timer = null
    let callNow = immediate
    return function() {
        let context = this,
            args = arguments
        if (callNow) {
            fn.apply(context, args)
            callNow = false
        }
        if (!timer) {
            timer = setTimeout(() => {
                fn.apply(context, args)
                timer = null
            }, wait)
        }
    }
}
<!-- 2. -->
function throttle(func, wait) {
    let timeout = null
    return function() {
        let context = this
        let args = arguments
        if (!timeout) {
            timeout = setTimeout(() => {
                timeout = null
                func.apply(context, args)
            }, wait)
        }
    }
}
<!-- 3. -->
function throttle(func, wait) {
    var prev = 0;
    return function() {
        let now = Date.now();
        let context = this;
        let args = arguments;
        if (now - prev > wait) {
            func.apply(context, args);
            prev = now;
        }
    }
}

js 定时器有以下两个方法:

setInterval() :按照指定的周期(以毫秒计)来调用函数或计算表达式。方法会不停地调用函数,直到 clearInterval() 被调用或窗口被关闭。 setTimeout() :在指定的毫秒数后调用函数或计算表达式
setTimeout (function() {
    alert(456)
},2000)
<!-- ES61写法 -->
setTimeout(() => {
    
}2000)

手机号中间四位隐藏

this.newTel = this.tel.substr(0,3) + "****" + this.tel.substr(7);

数组扁平化

对于[1, [1,2], [1,2,3]]这样多层嵌套的数组,我们如何将其扁平化为[1, 1, 2, 1, 2, 3]这样的一维数组呢:

// 1.ES6的flat()
const arr = [1, [1,2], [1,2,3]]
arr.flat(Infinity)  // [1, 1, 2, 1, 2, 3]

// 2.序列化后正则
const arr = [1, [1,2], [1,2,3]]
const str = `[${JSON.stringify(arr).replace(/(\[|\])/g, '')}]`
JSON.parse(str)   // [1, 1, 2, 1, 2, 3]

// 3.递归 对于树状结构的数据,最直接的处理方式就是递归
const arr = [1, [1,2], [1,2,3]]
function flat(arr) {
  let result = []
  for (const item of arr) {
    item instanceof Array ? result = result.concat(flat(item)) : result.push(item)
  }
  return result
}
flat(arr) // [1, 1, 2, 1, 2, 3]

// 4.reduce()递归
const arr = [1, [1,2], [1,2,3]]
function flat(arr) {
  return arr.reduce((prev, cur) => {
    return prev.concat(cur instanceof Array ? flat(cur) : cur)
  }, [])
}
flat(arr)  // [1, 1, 2, 1, 2, 3]

// 5.迭代+展开运算符
let arr = [1, [1,2], [1,2,3]]
while (arr.some(Array.isArray)) {
  arr = [].concat(...arr);
}
console.log(arr)  // [1, 1, 2, 1, 2, 3]

延迟函数delay

const delay = ms => new Promise((resolve, reject) => setTimeout(resolve, ms))
const getData = status => new Promise((resolve, reject) => {
    status ? resolve('done') : reject('fail')
})
const getRes = async (data) => {
    try {
        const res = await getData(data)
        const timestamp = new Date().getTime()
        await delay(1000)
        console.log(res, new Date().getTime() - timestamp)
    } catch (error) {
        console.log(error)
    }
}
getRes(true) // 隔了1秒

分割指定长度的元素数组

const listChunk = (list, size = 1, cacheList = []) => {
    const tmp = [...list]
    if (size <= 0) {
        return cacheList
    }
    while (tmp.length) {
        cacheList.push(tmp.splice(0, size))
    }
    return cacheList
}
console.log(listChunk([1, 2, 3, 4, 5, 6, 7, 8, 9])) // [[1], [2], [3], [4], [5], [6], [7], [8], [9]]
console.log(listChunk([1, 2, 3, 4, 5, 6, 7, 8, 9], 3)) // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
console.log(listChunk([1, 2, 3, 4, 5, 6, 7, 8, 9], 0)) // []
console.log(listChunk([1, 2, 3, 4, 5, 6, 7, 8, 9], -1)) // []

函数柯里化

const curring = fn => {
    const { length } = fn
    const curried = (...args) => {
        return (args.length >= length
              ? fn(...args)
              : (...args2) => curried(...args.concat(args2)))
    }
    return curried
}
const listMerge = (a, b, c) => [a, b, c]
const curried = curring(listMerge)
console.log(curried(1)(2)(3)) // [1, 2, 3]
console.log(curried(1, 2)(3)) // [1, 2, 3]
console.log(curried(1, 2, 3)) // [1, 2, 3]

字符串前面空格去除与替换

const trimStart = str => str.replace(new RegExp('^([\\s]*)(.*)$'), '$2')
console.log(trimStart(' abc ')) // abc  
console.log(trimStart('123 ')) // 123  

字符串后面空格去除与替换

const trimEnd = str => str.replace(new RegExp('^(.*?)([\\s]*)$'), '$1')
console.log(trimEnd(' abc ')) //   abc  
console.log(trimEnd('123 ')) // 123  

去除字符串中的html代码

const removeHTML = (str = '') => str.replace(/<[\/\!]*[^<>]*>/ig, '')
console.log(removeHTML('<h1>哈哈哈哈<呵呵呵</h1>')) // 哈哈哈哈<呵呵呵

判断屏幕是否旋转

function orientationChange() {
	switch (window.orientation) {  
		case 0:
			alert("肖像模式 0,screen-width: " + screen.width + "; screen-height:" + screen.height);
			break;  
		case -90:
			alert("左旋 -90,screen-width: " + screen.width + "; screen-height:" + screen.height);
			break;  
		case 90:
			alert("右旋 90,screen-width: " + screen.width + "; screen-height:" + screen.height);
			break;  
		case 180:
			  alert("风景模式 180,screen-width: " + screen.width + "; screen-height:" + screen.height);  
			break;
	};
};

jquery 去除字符串首尾空格

var str = '      123      '
var res = $.trim(str)

获取昨天日期格式

var time=(new Date).getTime()-24*60*60*1000;
var yesterday=new Date(time);
var month=yesterday.getMonth();
var day=yesterday.getDate();
// yesterday=yesterday.getFullYear() + "-" + (yesterday.getMonth()> 9 ? (yesterday.getMonth() + 1) : "0" + (yesterday.getMonth() + 1)) + "-" +(yesterday.getDate()> 9 ? (yesterday.getDate()) : "0" + (yesterday.getDate()));

js 获取 url 地址上拼接的参数

function getQueryVariable(variable){
        var query = window.location.search.substring(1);
        var vars = query.split("&");
        for (var i=0;i<vars.length;i++) {
                var pair = vars[i].split("=");
                if(pair[0] == variable){return pair[1];}
        }
        return(false);
}
var userId = getQueryVariable("userId")
var isOa = getQueryVariable("isOa")
console.log('userId===>', userId, 'isOa--->', isOa) 

数组方法

sort()

var arr = ['1','2','7','9','3'];
// 对数组进行升序排序
arr.sort((a,b) => {
    return a-b
});
// 对数组进行降序排序
arr.sort((a,b) => {
    return b-a
});

forEach()

arr.forEach((item) => {})

map()

arr.map((item,index) => {})

find() 查找数组中指定的数据

let obj = arr.find(function(e) {
    return e.id = id
})
<!-- 在数组中有很多对象,对象里面有唯一id和其他元素,此时我有数组中某一个对象的id值,需要获取到id所对应的对象的所有数据,就可以使用 数组方法find来进行匹配,然后返回需要获取到的那个对象即可 -->

filter()

let res = arr.filter(item => item.id !== id);
<!-- filter 可以过滤掉不满足条件的数组元素,保留符合条件的元素 -->

监听点击页面某处获取坐标

window.addEventListener('click', (event) => {
    console.log(event.pageX, event.pageY)
})

jQuery小技巧

var temp= $("#test").is(":hidden");//是否隐藏
var temp1= $("#test").is(":visible");//是否可见

this

web 环境中获取全局对象使用 window、this、self、frames
node 环境中获取全局对象使用 global
worker 环境中获取全局对象使用 self
JS环境中获取全局对象的通用方式 globalThis

Promise

ES6新增对象是一种异步编程解决方案,用来传递异步操作的信息,代表了某个未来才会知道结果的的事件(通常是异步的)并且这个事件提供了统一的API,可以进一步处理
特点: Promise的状态不受外界控制影响,他有三种状态,分别是 等待中pending、已完成resolved、已失败rejected, 只有异步的执行结果可以决定当前处于哪一状态,任何其他操作都无法改变这一状态;
Promise 一旦由等待状态变为其他状态就无法再改变了,比如状态由 pending 变为了 resolved,此处就永远会是 resolved不会更改

优缺点: Promise 可以很好的解决回调地狱的问题,使异步代码书写起来更加有条理和简洁优雅。缺点是promise一旦新建就会立即开始执行并且无法中断。而且错误是需要回调函数来捕获的,相对麻烦了一点

回调地狱: 回调地狱有两个很致命的问题,一个是嵌套调用,后面的任务依赖前一个任务的请求结果,并且上个任务的回调函数内部执行新的业务逻辑,当嵌套的层次多了之后,代码的阅读性和可维护性就会很差。第二个是不确定性,每一步的异步执行都有可能有两个结果,执行成功或者失败,就需要每一步的成功和失败多添加很多的业务逻辑来判断,对每一步的错误结果都需要进行错误处理,增加了代码的混乱程度。 解决的办法就是消灭多层的嵌套关系和统一错误处理。

Promise解决回调地狱: Promise 会通过 then 实现回调函数的延时绑定,所谓延时绑定就是指,先创建一个 Promise 对象 P1, 通过构造函数的executor 来执行业务逻辑,创建好Promise对象后,再使用P1进行来调用设置回调函数。Promise还可以通过.catch语句来捕获异常,不论哪个对象里抛出异常,都可以在最后使用 .catch 统一捕获进行处理。通过这种方式可以将所有的 Promise 对象的错误合并到一个函数中进行处理,这样就避免来在每一个任务都要单独解决异常的麻烦。而之所以可以在最后使用 .catch 捕获所有异常是因为 Promise 对象的错误具有冒泡性质,错误会一直向后传递,直到被 onReject 或者 .catch 捕获为止,具备这样的冒泡性质,就不需要在每一个任务中单独进行捕获处理了。

// 创建executor函数并执行业务逻辑
function executor(resolve, reject) {
    resolve(100)
}
// 创建一个 Promise对象传入业务逻辑处理函数
let P1 = new Promise(executor)
// P1 延时绑定需要调用的回调函数
function onResolve(value) {
    console.log(value)
}
// 延时
P1.then(onResolve)