前端编程题

mycall 实现

	function.call 的实现
	/**
	 *  @param context  传入的对象，作用类似于指针
	 *  @param args   传入的参数数组
	 * */
	Function.prototype.myCall = function (context=window, ...args) {
	    // 给context对象临时增加一个方法
	    context.fn = this
	    // 执行临时的方法
	    context.fn(...args)
	    // 删除临时添加的方法
	    delete context.fn
	}
	
	/**
	 * product 有两个参数，名称和种类
	 * */
	function Product(name, category) {
	    this.name = name
	    this.category = category
	}
	
	function test(name, category, price) {
	    Product.myCall(this, name, category)  //call 个人理解，有点类似于继承的作用
	    this.price = price
	}
	
	console.log(new test('蔬菜', '胡萝卜', 500))

debounce 实现

	 思路：事件被触发的时候，产生一个计时器 
	        1、计时器执行的期间，事件被再次触发 ，清空计时器，重新计时
	        2、计时器走完，触发函数。
	 /**   
		* debounce(防抖) 的作用是，让函数在短时间内被大量触发的时候，只会执行一次
		* @param fn  需要防抖的函数
		* @param wait  时间 ，毫秒
		* /
		function debounce(fn,wait){
		    let timer = null  //计时器
		    // 借助闭包 ，timer可以全局存在
		    return function () {
		        if(timer){
		            // timer有值，说明函数正在被触发
		            clearTimeout(timer) //清空计时器
		        }
		        timer = setTimeout(fn,wait)  //重新开始计时
		    }
		}

promise 实现

   /**
	 * 要求：
	 * 1、所有promise 返回resolve的时候，返回结果
	 * 2、存在reject的情况，直接返回reject信息
	 * @param arr  接收一个数组类型的参数，内部为promise对象
	 * */
	
	function promiseAll(arr) {
	    let results = new Array(arr.length)  // 创建全空的数组
	    let resultLength = 0   //记录返回resolve的数量
	    // 返回promise对象
	    return new Promise(((resolve, reject) => {
	        // 遍历并执行传入的promise数组
	        for (let i = 0; i < arr.length; i++) {
	            arr[i].then(value => {
	                // 处理正常返回情况
	                debugger
	                resultLength++;
	                results[i] = value
	                // 判断是否全部为resolve的状态
	                if (resultLength === arr.length) {
	                    return resolve(results)
	                }
	            }, error => {
	                debugger
	                // 处理返回reject的情况
	                reject(error)
	            })
	        }
	    }))
	}
	
	let p1 = new Promise(resolve => resolve('p1'))
	let p2 = new Promise(resolve => resolve('p2'))
	let p3 = new Promise((resolve, reject) => reject('p3 -reject'))
	
	promiseAll([p1, p2]).then(res => console.log(res)).catch(err => console.log(err))
	promiseAll([p1, p2, p3]).then(res => console.log(res)).catch(err => console.log(err))

bigNumberAdd 实现

	思路：
	1、字符串转换为数组，位数补齐 ，末尾开始加起
	num1 ='1000000000000000'
	num2 ='99'
	function bigNumberAdd(num1,num2) {
	  // 默认num1 为较大的数
	    let len  = num1.length - num2.length
	    let number1 = '0'  //默认为较大的数
	    let number2 = '0'  //默认为较小的数
	    if(len>0){
	        number1= num1
	        number2 =num2
	    }else {
	        number1 = num2
	        number2 = num1
	    }
	    number2 = '0'.repeat(Math.abs(len)) +number2
	    let result = new Array(number1.length).fill(0) //储存最后的结果
	    number1 = number1.split('')
	    number2 = number2.split('')
	    console.log(number1,number2)
	    for(let i =number1.length-1;i>-1;i--){
	        const res = result[i] + Number(number1[i])+ Number(number2[i])
	        if(res>=10){
	            if(i>0){
	                result[i] = res-10
	                result[i-1] = 1
	            }else{
	                result[i] = res-10
	                result.unshift(1)
	            }
	        }else {
	            result[i] =res
	        }
	    }
	    // console.log(result.join(''))
	    return result.join('')
	
	
	}
	bigNumberAdd(num1,num2)