石家庄城乡建设部网站首页,网站建设 徐州,网站开发如何修改域名,宜春做网站 黑酷seoES6新特性
1.ES6引入来严格模式变量必须声明后在使用函数的参数不能有同名属性, 否则报错不能使用with语句 (说实话我基本没用过)不能对只读属性赋值, 否则报错不能使用前缀0表示八进制数,否则报错 (说实话我基本没用过)不能删除不可删除的数据, 否则报错不能删除变量delete p…ES6新特性
1.ES6引入来严格模式变量必须声明后在使用函数的参数不能有同名属性, 否则报错不能使用with语句 (说实话我基本没用过)不能对只读属性赋值, 否则报错不能使用前缀0表示八进制数,否则报错 (说实话我基本没用过)不能删除不可删除的数据, 否则报错不能删除变量delete prop, 会报错, 只能删除属性delete global[prop]eval不会在它的外层作用域引入变量eval和arguments不能被重新赋值arguments不会自动反映函数参数的变化不能使用arguments.caller (说实话我基本没用过)不能使用arguments.callee (说实话我基本没用过)禁止this指向全局对象不能使用fn.caller和fn.arguments获取函数调用的堆栈 (说实话我基本没用过)增加了保留字比如protected、static和interface2.关于let和const新增的变量声明3.变量的解构赋值4.字符串的扩展includes()返回布尔值表示是否找到了参数字符串。startsWith()返回布尔值表示参数字符串是否在原字符串的头部。endsWith()返回布尔值表示参数字符串是否在原字符串的尾部。
5.数值的扩展Number.isFinite()用来检查一个数值是否为有限的finite。Number.isNaN()用来检查一个值是否为NaN。
6.函数的扩展函数参数指定默认值
7.数组的扩展扩展运算符
8.对象的扩展对象的解构
9.新增symbol数据类型10.Set 和 Map 数据结构 ES6 提供了新的数据结构 Set。它类似于数组但是成员的值都是唯一的没有重复的值。 Set 本身是一个构造函数用来生成 Set 数据结构。Map它类似于对象也是键值对的集合但是“键”的范围不限于字符串各种类型的值包括对象都可以当作键。
11.ProxyProxy 可以理解成在目标对象之前架设一层“拦截”外界对该对象的访问都必须先通过这层拦截因此提供了一种机制可以对外界的访问进行过滤和改写。Proxy 这个词的原意是代理用在这里表示由它来“代理”某些操作可以译为“代理器”。Vue3.0使用了proxy
12.PromisePromise 是异步编程的一种解决方案比传统的解决方案——回调函数和事件——更合理和更强大。特点是对象的状态不受外界影响。一旦状态改变就不会再变任何时候都可以得到这个结果。
13.async 函数 async函数对 Generator 函数的区别1内置执行器。Generator 函数的执行必须靠执行器而async函数自带执行器。也就是说async函数的执行与普通函数一模一样只要一行。2更好的语义。async和await比起星号和yield语义更清楚了。async表示函数里有异步操作await表示紧跟在后面的表达式需要等待结果。3正常情况下await命令后面是一个 Promise 对象。如果不是会被转成一个立即resolve的 Promise 对象。4返回值是 Promise。async函数的返回值是 Promise 对象这比 Generator 函数的返回值是 Iterator 对象方便多了。你可以用then方法指定下一步的操作。
14.Class class跟let、const一样不存在变量提升、不能重复声明...ES6 的class可以看作只是一个语法糖它的绝大部分功能ES5 都可以做到新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已。
15.ModuleES6 的模块自动采用严格模式不管你有没有在模块头部加上use strict;。import和export命令以及export和export default的区别
常见的HTTP请求方法
GET: 向服务器获取数据POST将实体提交到指定的资源通常会造成服务器资源的修改PUT上传文件更新数据DELETE删除服务器上的对象HEAD获取报文首部与GET相比不返回报文主体部分OPTIONS询问支持的请求方法用来跨域请求CONNECT要求在与代理服务器通信时建立隧道使用隧道进行TCP通信TRACE: 回显服务器收到的请求主要⽤于测试或诊断。
介绍下 promise 的特性、优缺点内部是如何实现的动手实现 Promise
1Promise基本特性
1、Promise有三种状态pending(进行中)、fulfilled(已成功)、rejected(已失败)2、Promise对象接受一个回调函数作为参数, 该回调函数接受两个参数分别是成功时的回调resolve和失败时的回调reject另外resolve的参数除了正常值以外 还可能是一个Promise对象的实例reject的参数通常是一个Error对象的实例。3、then方法返回一个新的Promise实例并接收两个参数onResolved(fulfilled状态的回调)onRejected(rejected状态的回调该参数可选)4、catch方法返回一个新的Promise实例5、finally方法不管Promise状态如何都会执行该方法的回调函数不接受任何参数6、Promise.all()方法将多个多个Promise实例包装成一个新的Promise实例该方法接受一个由Promise对象组成的数组作为参数(Promise.all()方法的参数可以不是数组但必须具有Iterator接口且返回的每个成员都是Promise实例)注意参数中只要有一个实例触发catch方法都会触发Promise.all()方法返回的新的实例的catch方法如果参数中的某个实例本身调用了catch方法将不会触发Promise.all()方法返回的新实例的catch方法7、Promise.race()方法的参数与Promise.all方法一样参数中的实例只要有一个率先改变状态就会将该实例的状态传给Promise.race()方法并将返回值作为Promise.race()方法产生的Promise实例的返回值8、Promise.resolve()将现有对象转为Promise对象如果该方法的参数为一个Promise对象Promise.resolve()将不做任何处理如果参数thenable对象(即具有then方法)Promise.resolve()将该对象转为Promise对象并立即执行then方法如果参数是一个原始值或者是一个不具有then方法的对象则Promise.resolve方法返回一个新的Promise对象状态为fulfilled其参数将会作为then方法中onResolved回调函数的参数如果Promise.resolve方法不带参数会直接返回一个fulfilled状态的 Promise 对象。需要注意的是立即resolve()的 Promise 对象是在本轮“事件循环”event loop的结束时执行而不是在下一轮“事件循环”的开始时。9、Promise.reject()同样返回一个新的Promise对象状态为rejected无论传入任何参数都将作为reject()的参数
2Promise优点
①统一异步 API Promise 的一个重要优点是它将逐渐被用作浏览器的异步 API 统一现在各种各样的 API 以及不兼容的模式和手法。 ②Promise 与事件对比 和事件相比较 Promise 更适合处理一次性的结果。在结果计算出来之前或之后注册回调函数都是可以的都可以拿到正确的值。 Promise 的这个优点很自然。但是不能使用 Promise 处理多次触发的事件。链式处理是 Promise 的又一优点但是事件却不能这样链式处理。 ③Promise 与回调对比 解决了回调地狱的问题将异步操作以同步操作的流程表达出来。 ④Promise 带来的额外好处是包含了更好的错误处理方式包含了异常处理并且写起来很轻松因为可以重用一些同步的工具比如 Array.prototype.map() 。
3Promise缺点
1、无法取消Promise一旦新建它就会立即执行无法中途取消。2、如果不设置回调函数Promise内部抛出的错误不会反应到外部。3、当处于Pending状态时无法得知目前进展到哪一个阶段刚刚开始还是即将完成。4、Promise 真正执行回调的时候定义 Promise 那部分实际上已经走完了所以 Promise 的报错堆栈上下文不太友好。
4简单代码实现 最简单的Promise实现有7个主要属性, state(状态), value(成功返回值), reason(错误信息), resolve方法, reject方法, then方法
class Promise{constructor(executor) {this.state pending;this.value undefined;this.reason undefined;let resolve value {if (this.state pending) {this.state fulfilled;this.value value;}};let reject reason {if (this.state pending) {this.state rejected;this.reason reason;}};try {// 立即执行函数executor(resolve, reject);} catch (err) {reject(err);}}then(onFulfilled, onRejected) {if (this.state fulfilled) {let x onFulfilled(this.value);};if (this.state rejected) {let x onRejected(this.reason);};}
}5面试够用版
function myPromise(constructor){ let selfthis;self.statuspending //定义状态改变前的初始状态 self.valueundefined;//定义状态为resolved的时候的状态 self.reasonundefined;//定义状态为rejected的时候的状态 function resolve(value){//两个pending保证了了状态的改变是不不可逆的 if(self.statuspending){self.valuevalue;self.statusresolved; }}function reject(reason){//两个pending保证了了状态的改变是不不可逆的if(self.statuspending){self.reasonreason;self.statusrejected; }}//捕获构造异常 try{constructor(resolve,reject);}catch(e){reject(e);}
}
myPromise.prototype.thenfunction(onFullfilled,onRejected){ let selfthis;switch(self.status){case resolved: onFullfilled(self.value); break;case rejected: onRejected(self.reason); break;default: }
}// 测试
var pnew myPromise(function(resolve,reject){resolve(1)});
p.then(function(x){console.log(x)})
//输出16大厂专供版
const PENDING pending;
const FULFILLED fulfilled;
const REJECTED rejected;
const resolvePromise (promise, x, resolve, reject) {if (x promise) {// If promise and x refer to the same object, reject promise with a TypeError as the reason.reject(new TypeError(循环引用))}// if x is an object or function,if (x ! null typeof x object || typeof x function) {// If both resolvePromise and rejectPromise are called, or multiple calls to the same argument are made, the first call takes precedence, and any further calls are ignored.let calledtry { // If retrieving the property x.then results in a thrown exception e, reject promise with e as the reason.let then x.then // Let then be x.then// If then is a function, call it with x as thisif (typeof then function) {// If/when resolvePromise is called with a value y, run [[Resolve]](promise, y)// If/when rejectPromise is called with a reason r, reject promise with r.then.call(x, y {if (called) returncalled trueresolvePromise(promise, y, resolve, reject)}, r {if (called) returncalled truereject(r)})} else {// If then is not a function, fulfill promise with x.resolve(x)}} catch (e) {if (called) returncalled truereject(e)}} else {// If x is not an object or function, fulfill promise with xresolve(x)}
}
function Promise(excutor) {let that this; // 缓存当前promise实例例对象that.status PENDING; // 初始状态that.value undefined; // fulfilled状态时 返回的信息that.reason undefined; // rejected状态时 拒绝的原因 that.onFulfilledCallbacks []; // 存储fulfilled状态对应的onFulfilled函数that.onRejectedCallbacks []; // 存储rejected状态对应的onRejected函数function resolve(value) { // value成功态时接收的终值if(value instanceof Promise) {return value.then(resolve, reject);}// 实践中要确保 onFulfilled 和 onRejected ⽅方法异步执⾏行行且应该在 then ⽅方法被调⽤用的那⼀一轮事件循环之后的新执⾏行行栈中执⾏行行。setTimeout(() {// 调⽤用resolve 回调对应onFulfilled函数if (that.status PENDING) {// 只能由pending状态 fulfilled状态 (避免调⽤用多次resolve reject)that.status FULFILLED;that.value value;that.onFulfilledCallbacks.forEach(cb cb(that.value));}});}function reject(reason) { // reason失败态时接收的拒因setTimeout(() {// 调⽤用reject 回调对应onRejected函数if (that.status PENDING) {// 只能由pending状态 rejected状态 (避免调⽤用多次resolve reject)that.status REJECTED;that.reason reason;that.onRejectedCallbacks.forEach(cb cb(that.reason));}});}// 捕获在excutor执⾏行行器器中抛出的异常// new Promise((resolve, reject) {// throw new Error(error in excutor)// })try {excutor(resolve, reject);} catch (e) {reject(e);}
}
Promise.prototype.then function(onFulfilled, onRejected) {const that this;let newPromise;// 处理理参数默认值 保证参数后续能够继续执⾏行行onFulfilled typeof onFulfilled function ? onFulfilled : value value;onRejected typeof onRejected function ? onRejected : reason {throw reason;};if (that.status FULFILLED) { // 成功态return newPromise new Promise((resolve, reject) {setTimeout(() {try{let x onFulfilled(that.value);resolvePromise(newPromise, x, resolve, reject); //新的promise resolve 上⼀一个onFulfilled的返回值} catch(e) {reject(e); // 捕获前⾯面onFulfilled中抛出的异常then(onFulfilled, onRejected);}});})}if (that.status REJECTED) { // 失败态return newPromise new Promise((resolve, reject) {setTimeout(() {try {let x onRejected(that.reason);resolvePromise(newPromise, x, resolve, reject);} catch(e) {reject(e);}});});}if (that.status PENDING) { // 等待态
// 当异步调⽤用resolve/rejected时 将onFulfilled/onRejected收集暂存到集合中return newPromise new Promise((resolve, reject) {that.onFulfilledCallbacks.push((value) {try {let x onFulfilled(value);resolvePromise(newPromise, x, resolve, reject);} catch(e) {reject(e);}});that.onRejectedCallbacks.push((reason) {try {let x onRejected(reason);resolvePromise(newPromise, x, resolve, reject);} catch(e) {reject(e);}});});}
};对事件委托的理解
1事件委托的概念
事件委托本质上是利用了浏览器事件冒泡的机制。因为事件在冒泡过程中会上传到父节点父节点可以通过事件对象获取到目标节点因此可以把子节点的监听函数定义在父节点上由父节点的监听函数统一处理多个子元素的事件这种方式称为事件委托事件代理。
使用事件委托可以不必要为每一个子元素都绑定一个监听事件这样减少了内存上的消耗。并且使用事件代理还可以实现事件的动态绑定比如说新增了一个子节点并不需要单独地为它添加一个监听事件它绑定的事件会交给父元素中的监听函数来处理。
2事件委托的特点
减少内存消耗
如果有一个列表列表之中有大量的列表项需要在点击列表项的时候响应一个事件
ul idlistliitem 1/liliitem 2/liliitem 3/li......liitem n/li
/ul
如果给每个列表项一一都绑定一个函数那对于内存消耗是非常大的效率上需要消耗很多性能。因此比较好的方法就是把这个点击事件绑定到他的父层也就是 ul 上然后在执行事件时再去匹配判断目标元素所以事件委托可以减少大量的内存消耗节约效率。
动态绑定事件
给上述的例子中每个列表项都绑定事件在很多时候需要通过 AJAX 或者用户操作动态的增加或者去除列表项元素那么在每一次改变的时候都需要重新给新增的元素绑定事件给即将删去的元素解绑事件如果用了事件委托就没有这种麻烦了因为事件是绑定在父层的和目标元素的增减是没有关系的执行到目标元素是在真正响应执行事件函数的过程中去匹配的所以使用事件在动态绑定事件的情况下是可以减少很多重复工作的。
// 来实现把 #list 下的 li 元素的事件代理委托到它的父层元素也就是 #list 上
// 给父层元素绑定事件
document.getElementById(list).addEventListener(click, function (e) {// 兼容性处理var event e || window.event;var target event.target || event.srcElement;// 判断是否匹配目标元素if (target.nodeName.toLocaleLowerCase li) {console.log(the content is: , target.innerHTML);}
});
在上述代码中 target 元素则是在 #list 元素之下具体被点击的元素然后通过判断 target 的一些属性比如nodeNameid 等等可以更精确地匹配到某一类 #list li 元素之上
3局限性
当然事件委托也是有局限的。比如 focus、blur 之类的事件没有事件冒泡机制所以无法实现事件委托mousemove、mouseout 这样的事件虽然有事件冒泡但是只能不断通过位置去计算定位对性能消耗高因此也是不适合于事件委托的。
当然事件委托不是只有优点它也是有缺点的事件委托会影响页面性能主要影响因素有
元素中绑定事件委托的次数点击的最底层元素到绑定事件元素之间的DOM层数
在必须使用事件委托的地方可以进行如下的处理
只在必须的地方使用事件委托比如ajax的局部刷新区域尽量的减少绑定的层级不在body元素上进行绑定减少绑定的次数如果可以那么把多个事件的绑定合并到一次事件委托中去由这个事件委托的回调来进行分发。
代码输出问题
window.number 2;
var obj {number: 3,db1: (function(){console.log(this);this.number * 4;return function(){console.log(this);this.number * 5;}})()
}
var db1 obj.db1;
db1();
obj.db1();
console.log(obj.number); // 15
console.log(window.number); // 40
这道题目看清起来有点乱但是实际上是考察this指向的:
执行db1()时this指向全局作用域所以window.number * 4 8然后执行匿名函数 所以window.number * 5 40执行obj.db1();时this指向obj对象执行匿名函数所以obj.numer * 5 15。
说一下怎么把类数组转换为数组?
//通过call调用数组的slice方法来实现转换
Array.prototype.slice.call(arrayLike)//通过call调用数组的splice方法来实现转换
Array.prototype.splice.call(arrayLike,0)//通过apply调用数组的concat方法来实现转换
Array.prototype.concat.apply([],arrayLike)//通过Array.from方法来实现转换
Array.from(arrayLike)
参考 前端进阶面试题详细解答
代码输出结果
Promise.resolve(1).then(res {console.log(res)}).finally(() {console.log(finally)})
Promise.resolve(2).finally(() {console.log(finally2)return 我是finally2返回的值}).then(res {console.log(finally2后面的then函数, res)})
输出结果如下
1
finally2
finally
finally2后面的then函数 2
.finally()一般用的很少只要记住以下几点就可以了
.finally()方法不管Promise对象最后的状态如何都会执行.finally()方法的回调函数不接受任何的参数也就是说你在.finally()函数中是无法知道Promise最终的状态是resolved还是rejected的它最终返回的默认会是一个上一次的Promise对象值不过如果抛出的是一个异常则返回异常的Promise对象。finally本质上是then方法的特例
.finally()的错误捕获
Promise.resolve(1).finally(() {console.log(finally1)throw new Error(我是finally中抛出的异常)}).then(res {console.log(finally后面的then函数, res)}).catch(err {console.log(捕获错误, err)})
输出结果为
finally1
捕获错误 Error: 我是finally中抛出的异常
代码输出结果
function Person(name) {this.name name
}
var p2 new Person(king);
console.log(p2.__proto__) //Person.prototype
console.log(p2.__proto__.__proto__) //Object.prototype
console.log(p2.__proto__.__proto__.__proto__) // null
console.log(p2.__proto__.__proto__.__proto__.__proto__)//null后面没有了报错
console.log(p2.__proto__.__proto__.__proto__.__proto__.__proto__)//null后面没有了报错
console.log(p2.constructor)//Person
console.log(p2.prototype)//undefined p2是实例没有prototype属性
console.log(Person.constructor)//Function 一个空函数
console.log(Person.prototype)//打印出Person.prototype这个对象里所有的方法和属性
console.log(Person.prototype.constructor)//Person
console.log(Person.prototype.__proto__)// Object.prototype
console.log(Person.__proto__) //Function.prototype
console.log(Function.prototype.__proto__)//Object.prototype
console.log(Function.__proto__)//Function.prototype
console.log(Object.__proto__)//Function.prototype
console.log(Object.prototype.__proto__)//null
这道义题目考察原型、原型链的基础记住就可以了。
代码输出结果
async function async1 () {console.log(async1 start);await new Promise(resolve {console.log(promise1)})console.log(async1 success);return async1 end
}
console.log(srcipt start)
async1().then(res console.log(res))
console.log(srcipt end)
输出结果如下
script start
async1 start
promise1
script end
这里需要注意的是在async1中await后面的Promise是没有返回值的也就是它的状态始终是pending状态所以在await之后的内容是不会执行的包括async1后面的 .then。
代码输出结果
function foo() {console.log( this.a );
}function doFoo() {foo();
}var obj {a: 1,doFoo: doFoo
};var a 2;
obj.doFoo()
输出结果2
在Javascript中this指向函数执行时的当前对象。在执行foo的时候执行环境就是doFoo函数执行环境为全局。所以foo中的this是指向window的所以会打印出2。
setInterval 模拟 setTimeout
描述使用setInterval模拟实现setTimeout的功能。
思路setTimeout的特性是在指定的时间内只执行一次我们只要在setInterval内部执行 callback 之后把定时器关掉即可。
实现
const mySetTimeout (fn, time) {let timer null;timer setInterval(() {// 关闭定时器保证只执行一次fn也就达到了setTimeout的效果了clearInterval(timer);fn();}, time);// 返回用于关闭定时器的方法return () clearInterval(timer);
}// 测试
const cancel mySetTimeout(() {console.log(1);
}, 1000);
// 一秒后打印 1
说一下vue3.0你了解多少? !-- 响应式原理的改变 Vue3.x 使用Proxy取代 Vue2.x 版本的Object.defineProperty --!-- 组件选项声明方式Vue3.x 使用Composition API setup 是Vue3.x新增的一个选项他是组件内使用Composition API 的入口 --!-- 模板语法变化slot具名插槽语法 自定义指令 v-model 升级 --!-- 其它方面的更改Suspense支持Fragment(多个根节点) 和Protal (在dom其他部分渲染组建内容)组件针对一些特殊的场景做了处理。基于treeshaking优化提供了更多的内置功能。 --
代码输出结果
function runAsync (x) {const p new Promise(r setTimeout(() r(x, console.log(x)), 1000))return p
}Promise.all([runAsync(1), runAsync(2), runAsync(3)]).then(res console.log(res))
输出结果如下
1
2
3
[1, 2, 3]
首先定义了一个Promise来异步执行函数runAsync该函数传入一个值x然后间隔一秒后打印出这个x。
之后再使用Promise.all来执行这个函数执行的时候看到一秒之后输出了123同时输出了数组[1, 2, 3]三个函数是同步执行的并且在一个回调函数中返回了所有的结果。并且结果和函数的执行顺序是一致的。
Promise.race
描述只要promises中有一个率先改变状态就返回这个率先改变的Promise实例的返回值。
实现
Promise.race function(promises){return new Promise((resolve, reject) {if(Array.isArray(promises)) {if(promises.length 0) return resolve(promises);promises.forEach((item) {Promise.resolve(item).then(value resolve(value), reason reject(reason));})}else return reject(new TypeError(Argument is not iterable));});
}
异步任务调度器
描述实现一个带并发限制的异步调度器 Scheduler保证同时运行的任务最多有 limit 个。
实现
class Scheduler {queue []; // 用队列保存正在执行的任务runCount 0; // 计数正在执行的任务个数constructor(limit) {this.maxCount limit; // 允许并发的最大个数}add(time, data){const promiseCreator () {return new Promise((resolve, reject) {setTimeout(() {console.log(data);resolve();}, time);});}this.queue.push(promiseCreator);// 每次添加的时候都会尝试去执行任务this.request();}request() {// 队列中还有任务才会被执行if(this.queue.length this.runCount this.maxCount) {this.runCount;// 执行先加入队列的函数this.queue.shift()().then(() {this.runCount--;// 尝试进行下一次任务this.request();});}}
}// 测试
const scheduler new Scheduler(2);
const addTask (time, data) {scheduler.add(time, data);
}addTask(1000, 1);
addTask(500, 2);
addTask(300, 3);
addTask(400, 4);
// 输出结果 2 3 1 4
说一下常见的检测数据类型的几种方式?
typeof 其中数组、对象、null都会被判断为Object其他判断都正确instanceof 只能判断引用数据类型,不能判断基本数据类型constructor 它有2个作用 一是判断数据的类型二是对象实例通过constructor对象访问它的构造函数。需要注意的事情是如果创建一个对象来改变它的原型,constructor就不能来判断数据类型了Object.prototype.toString.call()
Number() 的存储空间是多大如果后台发送了一个超过最大自己的数字怎么办
Math.pow(2, 53) 53 为有效数字会发生截断等于 JS 能支持的最大数字。
Promise.allSettled
描述等到所有promise都返回结果就返回一个promise实例。
实现
Promise.allSettled function(promises) {return new Promise((resolve, reject) {if(Array.isArray(promises)) {if(promises.length 0) return resolve(promises);let result [];let count 0;promises.forEach((item, index) {Promise.resolve(item).then(value {count;result[index] {status: fulfilled,value: value};if(count promises.length) resolve(result);}, reason {count;result[index] {status: rejected.reason: reason};if(count promises.length) resolve(result);});});}else return reject(new TypeError(Argument is not iterable));});
}
Object.is 实现
题目描述:
Object.is不会转换被比较的两个值的类型这点和更为相似他们之间也存在一些区别。1. NaN在中是不相等的而在Object.is中是相等的2. 0和-0在中是相等的而在Object.is中是不相等的
实现代码如下:
Object.is function (x, y) {if (x y) {// 当前情况下只有一种情况是特殊的即 0 -0// 如果 x ! 0则返回true// 如果 x 0则需要判断0和-0则可以直接使用 1/0 Infinity 和 1/-0 -Infinity来进行判断return x ! 0 || 1 / x 1 / y;}// x ! y 的情况下只需要判断是否为NaN如果x!x则说明x是NaN同理y也一样// x和y同时为NaN时返回truereturn x ! x y ! y;
};
大数相加
题目描述:实现一个add方法完成两个大数相加
let a 9007199254740991;
let b 1234567899999999999;function add(a ,b){//...
}
实现代码如下:
function add(a ,b){//取两个数字的最大长度let maxLength Math.max(a.length, b.length);//用0去补齐长度a a.padStart(maxLength , 0);//0009007199254740991b b.padStart(maxLength , 0);//1234567899999999999//定义加法过程中需要用到的变量let t 0;let f 0; //进位let sum ;for(let imaxLength-1 ; i0 ; i--){t parseInt(a[i]) parseInt(b[i]) f;f Math.floor(t/10);sum t%10 sum;}if(f!0){sum f sum;}return sum;
}
