成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

【前端】一網打盡──前端進階和面試必會的8個手寫代碼

作者：一川
開發 前端
我們知道在前端進階和面試的時候，會考察到很多手寫源碼的問題，這些是通過學習和練習是可以掌握的，下面列舉了八個手寫的代碼系列，希望能夠對你有所幫助。

[[401822]]

寫在前面

我們知道在前端進階和面試的時候，會考察到很多手寫源碼的問題，這些是通過學習和練習是可以掌握的，下面列舉了八個手寫的代碼系列，希望能夠對你有所幫助。

1 手寫Promise系列

在Promise的學習中，之前也寫過相關的分享文章，敬請參見《從小白視角上手Promise、Async/Await和手撕代碼》。

1.1 Promise.all

  1. //手寫promise.all 
  2. Promise.prototype._all = promiseList => { 
  3.   // 當輸入的是一個promise列表 
  4.   const len = promiseList.length; 
  5.   const result = []; 
  6.   let count = 0; 
  7.   //  
  8.   return new Promise((resolve,reject)=>{ 
  9.     // 循環遍歷promise列表中的promise事件 
  10.     for(let i = 0; i < len; i++){ 
  11.       // 遍歷到第i個promise事件，判斷其事件是成功還是失敗 
  12.       promiseList[i].then(data=>{ 
  13.         result[i] = data; 
  14.         count++; 
  15.         // 當遍歷到最后一個promise時，結果的數組長度和promise列表長度一致，說明成功 
  16.         count === len && resolve(result); 
  17.       },error=>{ 
  18.         return reject(error); 
  19.       }) 
  20.     } 
  21.   }) 
  22. } 

1.2 Promise.race

  1. // 手寫promise.race 
  2. Promise.prototype._race = promiseList => { 
  3.   const len = promiseList.length; 
  4.   return new Promise((resolve,reject)=>{ 
  5.     // 循環遍歷promise列表中的promise事件 
  6.     for(let i = 0; i < len; i++){ 
  7.       promiseList[i]().then(data=>{ 
  8.         return resolve(data); 
  9.       },error=>{ 
  10.         return reject(error); 
  11.       }) 
  12.     } 
  13.   }) 
  14. } 

1.3 Promise.finally

  1. Promise.prototype._finally = function(promiseFunc){ 
  2.   return this.then(data=>Promise.resolve(promiseFunc()).then(data=>data) 
  3.   ,error=>Promise.reject(promiseFunc()).then(error=>{throw error})) 
  4. } 

2 手寫Aysnc/Await

  1. function asyncGenertor(genFunc){ 
  2.   return new Promise((resolve,reject)=>{ 
  3.     // 生成一個迭代器 
  4.     const gen = genFunc(); 
  5.     const step = (type,args)=>{ 
  6.       let next; 
  7.       try{ 
  8.         next = gen[type](args); 
  9.       }catch(e){ 
  10.         return reject(e); 
  11.       } 
  12.       // 從next中獲取done和value的值 
  13.       const {done,value} = next; 
  14.       // 如果迭代器的狀態是true 
  15.       if(done) return resolve(value); 
  16.       Promise.resolve(value).then( 
  17.         val=>step("next",val), 
  18.         err=>step("throw",err) 
  19.       ) 
  20.     } 
  21.     step("next"); 
  22.   }) 
  23. } 

3 深拷貝

深拷貝：拷貝所有的屬性值，以及屬性地址指向的值的內存空間。

3.1 丟失引用的深拷貝

當遇到對象時，就再新開一個對象，然后將第二層源對象的屬性值，完整地拷貝到這個新開的對象中。

  1. // 丟失引用的深拷貝 
  2. function deepClone(obj){ 
  3.   // 判斷obj的類型是否為object類型 
  4.   if(!obj && typeof obj !== "object") return; 
  5.   // 判斷對象是數組類型還是對象類型 
  6.   let newObj = Array.isArray(obj) ? [] : {}; 
  7.   // 遍歷obj的鍵值對 
  8.   for(const [key,value] of Object.entries(obj)){ 
  9.     newObj[key] = typeof value === "string" ? deepClone(value) : value; 
  10.   }; 
  11.   return newObj; 
  12. } 

3.2 終極方案的深拷貝(棧和深度優先的思想)

其思路是：引入一個數組 uniqueList 用來存儲已經拷貝的數組，每次循環遍歷時，先判斷對象是否在 uniqueList 中了，如果在的話就不執行拷貝邏輯了。

  1. function deepCopy(obj){ 
  2.   // 用于去重 
  3.   const uniqueList = []; 
  4.   // 設置根節點 
  5.   let root = {}; 
  6.   // 遍歷數組 
  7.   const loopList = [{ 
  8.     parent: root, 
  9.     key: undefined, 
  10.     data: obj 
  11.   }]; 
  12.   // 遍歷循環 
  13.   while(loopList.length){ 
  14.     // 深度優先-將數組最后的元素取出 
  15.     const {parent,key,data} = loopList.pop(); 
  16.     // 初始化賦值目標，key--undefined時拷貝到父元素，否則拷貝到子元素 
  17.     let result = parent; 
  18.     if(typeof key !== "undefined") result = parent[key] = {}; 
  19.     // 數據已存在時 
  20.     let uniqueData = uniqueList.find(item=>item.source === data); 
  21.     if(uniqueData){ 
  22.       parent[key] = uniqueData.target; 
  23.       // 中斷本次循環 
  24.       continue; 
  25.     } 
  26.     // 數據不存在時 
  27.     // 保存源數據，在拷貝數據中對應的引用 
  28.     uniqueList.push({ 
  29.       source:data, 
  30.       target:result 
  31.     }); 
  32.     // 遍歷數據 
  33.     for(let k in data){ 
  34.       if(data.hasOwnProperty(k)){ 
  35.         typeof data[k] === "object"  
  36.         ? 
  37.           // 下一次循環 
  38.           loopList.push({ 
  39.             parent:result, 
  40.             key:k, 
  41.             data:data[k] 
  42.           }) 
  43.         :  
  44.         result[k] = data[k]; 
  45.          
  46.       } 
  47.     } 
  48.   } 
  49.   return root; 
  50. } 

4 手寫一個單例模式

單例模式：保證一個類僅有一個實例，并提供一個訪問它的全局訪問點。實現方法一般是先判斷實例是否存在，如果存在直接返回，如果不存在就先創建再返回。

  1. // 創建單例對象，使用閉包 
  2. const getSingle = function(func){ 
  3.   let result; 
  4.   return function(){ 
  5.     return result || (result = func.apply(this,arguments)); 
  6.   } 
  7. } 
  8.  
  9. // 使用Proxy攔截 
  10. const proxy = function(func){ 
  11.   let reuslt; 
  12.   const handler = { 
  13.     construct:function(){ 
  14.       if(!result) result = Reflect.construct(func,arguments); 
  15.       return result; 
  16.     } 
  17.   } 
  18.   return new Proxy(func,hendler); 
  19. } 

5 手寫封裝一個ajax函數

  1. /*  
  2. 封裝自己的ajax函數 
  3. 參數1：{string} method 請求方法 
  4. 參數2：{string} url 請求地址 
  5. 參數2：{Object} params 請求參數 
  6. 參數3：{function} done 請求完成后執行的回調函數 
  7. */ 
  8.  
  9. function ajax(method,url,params,done){ 
  10.   // 1.創建xhr對象，兼容寫法 
  11.   let xhr = window.XMLHttpRequest  
  12.   ? new XMLHttpRequest() 
  13.   : new ActiveXObject("Microsoft.XMLHTTP"); 
  14.  
  15.   // 將method轉換成大寫 
  16.   method = method.toUpperCase(); 
  17.   // 參數拼接 
  18.   let newParams = []; 
  19.   for(let key in params){ 
  20.     newParams.push(`${key}=${params[k]}`); 
  21.   } 
  22.   let str = newParams.join("&"); 
  23.   // 判斷請求方法 
  24.   if(method === "GET") url += `?${str}`; 
  25.  
  26.   // 打開請求方式 
  27.   xhr.open(method,url); 
  28.  
  29.   let data = null; 
  30.   if(method === "POST"){ 
  31.     // 設置請求頭 
  32.     xhr.setRequestHeader(("Content-Type","application/x-www-form-urlencoded")); 
  33.     data = str; 
  34.   } 
  35.   xhr.send(data); 
  36.  
  37.   // 指定xhr狀態變化事件處理函數 
  38.   // 執行回調函數 
  39.   xhr.onreadystatechange = function(){ 
  40.     if(this.readyState === 4) done(JSON.parse(xhr.responseText)); 
  41.   } 
  42. } 

6 手寫“防抖”和“節流”

在Promise的學習中，之前也寫過相關的分享文章，敬請參見《一網打盡──他們都在用這些”防抖“和”節流“方法》。

6.1 防抖

  1. /*  
  2. func：要進行防抖處理的函數 
  3. delay：要進行延時的時間 
  4. immediate：是否使用立即執行 true立即執行 false非立即執行 
  5. */ 
  6. function debounce(func,delay,immediate){ 
  7.   let timeout; //定時器 
  8.   return function(arguments){ 
  9.     // 判斷定時器是否存在，存在的話進行清除，重新進行定時器計數 
  10.     if(timeout) clearTimeout(timeout); 
  11.     // 判斷是立即執行的防抖還是非立即執行的防抖 
  12.     if(immediate){//立即執行 
  13.       const flag = !timeout;//此處是取反操作 
  14.       timeout = setTimeout(()=>{ 
  15.         timeout = null; 
  16.       },delay); 
  17.       // 觸發事件后函數會立即執行，然后 n 秒內不觸發事件才能繼續執行函數的效果。 
  18.       if(flag) func.call(this,arguments); 
  19.     }else{//非立即執行 
  20.       timeout = setTimeout(()=>{ 
  21.         func.call(this,arguments); 
  22.       },delay) 
  23.     } 
  24.  
  25.   } 
  26. } 

6.2 節流

  1. // 節流--定時器版 
  2.  function throttle(func,delay){ 
  3.    let timeout;//定義一個定時器標記 
  4.    return function(arguments){ 
  5.      // 判斷是否存在定時器 
  6.      if(!timeout){  
  7.        // 創建一個定時器 
  8.        timeout = setTimeout(()=>{ 
  9.          // delay時間間隔清空定時器 
  10.          clearTimeout(timeout); 
  11.          func.call(this,arguments); 
  12.        },delay) 
  13.      } 
  14.    } 
  15.  } 

7 手寫apply、bind、call

7.1 apply

傳遞給函數的參數處理，不太一樣，其他部分跟call一樣。

apply接受第二個參數為類數組對象, 這里用了《JavaScript權威指南》中判斷是否為類數組對象的方法。

  1. Function.prototype._apply = function (context) { 
  2.     if (context === null || context === undefined) { 
  3.         context = window // 指定為 null 和 undefined 的 this 值會自動指向全局對象(瀏覽器中為window) 
  4.     } else { 
  5.         context = Object(context) // 值為原始值（數字，字符串，布爾值）的 this 會指向該原始值的實例對象 
  6.     } 
  7.     // JavaScript權威指南判斷是否為類數組對象 
  8.     function isArrayLike(o) { 
  9.         if (o &&                                    // o不是null、undefined等 
  10.             typeof o === 'object' &&                // o是對象 
  11.             isFinite(o.length) &&                   // o.length是有限數值 
  12.             o.length >= 0 &&                        // o.length為非負值 
  13.             o.length === Math.floor(o.length) &&    // o.length是整數 
  14.             o.length < 4294967296)                  // o.length < 2^32 
  15.             return true 
  16.         else 
  17.             return false 
  18.     } 
  19.     const specialPrototype = Symbol('特殊屬性Symbol') // 用于臨時儲存函數 
  20.     context[specialPrototype] = this; // 隱式綁定this指向到context上 
  21.     let args = arguments[1]; // 獲取參數數組 
  22.     let result 
  23.     // 處理傳進來的第二個參數 
  24.     if (args) { 
  25.         // 是否傳遞第二個參數 
  26.         if (!Array.isArray(args) && !isArrayLike(args)) { 
  27.             throw new TypeError('myApply 第二個參數不為數組并且不為類數組對象拋出錯誤'); 
  28.         } else { 
  29.             args = Array.from(args) // 轉為數組 
  30.             result = context[specialPrototype](...args); // 執行函數并展開數組，傳遞函數參數 
  31.         } 
  32.     } else { 
  33.         result = context[specialPrototype](); // 執行函數  
  34.     } 
  35.     delete context[specialPrototype]; // 刪除上下文對象的屬性 
  36.     return result; // 返回函數執行結果 
  37. }; 

7.2 bind

拷貝源函數:

  • 通過變量儲存源函數
  • 使用Object.create復制源函數的prototype給fToBind

返回拷貝的函數

調用拷貝的函數：

  • new調用判斷：通過instanceof判斷函數是否通過new調用，來決定綁定的context
  • 綁定this+傳遞參數
  • 返回源函數的執行結果
  1. Function.prototype._bind = function (objThis, ...params) { 
  2.     const thisFn = this; // 存儲源函數以及上方的params(函數參數) 
  3.     // 對返回的函數 secondParams 二次傳參 
  4.     let fToBind = function (...secondParams) { 
  5.         const isNew = this instanceof fToBind // this是否是fToBind的實例 也就是返回的fToBind是否通過new調用 
  6.         const context = isNew ? this : Object(objThis) // new調用就綁定到this上,否則就綁定到傳入的objThis上 
  7.         return thisFn.call(context, ...params, ...secondParams); // 用call調用源函數綁定this的指向并傳遞參數,返回執行結果 
  8.     }; 
  9.     if (thisFn.prototype) { 
  10.         // 復制源函數的prototype給fToBind 一些情況下函數沒有prototype，比如箭頭函數 
  11.         fToBind.prototype = Object.create(thisFn.prototype); 
  12.     } 
  13.     return fToBind; // 返回拷貝的函數 
  14. }; 

7.3 call

根據call的規則設置上下文對象,也就是this的指向。

通過設置context的屬性,將函數的this指向隱式綁定到context上

通過隱式綁定執行函數并傳遞參數。

刪除臨時屬性，返回函數執行結果

  1. Function.prototype._call = function (context, ...arr) { 
  2.     if (context === null || context === undefined) { 
  3.        // 指定為 null 和 undefined 的 this 值會自動指向全局對象(瀏覽器中為window) 
  4.         context = window  
  5.     } else { 
  6.         context = Object(context) // 值為原始值（數字，字符串，布爾值）的 this 會指向該原始值的實例對象 
  7.     } 
  8.     const specialPrototype = Symbol('特殊屬性Symbol') // 用于臨時儲存函數 
  9.     context[specialPrototype] = this; // 函數的this指向隱式綁定到context上 
  10.     let result = context[specialPrototype](...arr); // 通過隱式綁定執行函數并傳遞參數 
  11.     delete context[specialPrototype]; // 刪除上下文對象的屬性 
  12.     return result; // 返回函數執行結果 
  13. }; 

8 手寫繼承

8.1 構造函數式繼承

構造函數式繼承并沒有繼承父類原型上的方法。

  1. function fatherUser(username, password) { 
  2.   let _password = password  
  3.   this.username = username  
  4.   fatherUser.prototype.login = function () { 
  5.       console.log(this.username + '要登錄父親賬號，密碼是' + _password) 
  6.   } 
  7. } 
  8.  
  9. function sonUser(username, password) { 
  10.   fatherUser.call(this, username, password) 
  11.   this.articles = 3 // 文章數量 
  12. } 
  13.  
  14. const yichuanUser = new sonUser('yichuan', 'xxx') 
  15. console.log(yichuanUser.username) // yichuan 
  16. console.log(yichuanUser.username) // xxx 
  17. console.log(yichuanUser.login()) // TypeError: yichuanUser.login is not a function 

8.2 組合式繼承

  1. function fatherUser(username, password) { 
  2.   let _password = password  
  3.   this.username = username  
  4.   fatherUser.prototype.login = function () { 
  5.       console.log(this.username + '要登錄fatherUser，密碼是' + _password) 
  6.   } 
  7. } 
  8.  
  9. function sonUser(username, password) { 
  10.   fatherUser.call(this, username, password) // 第二次執行 fatherUser 的構造函數 
  11.   this.articles = 3 // 文章數量 
  12. } 
  13.  
  14. sonUser.prototype = new fatherUser(); // 第二次執行 fatherUser 的構造函數 
  15. const yichuanUser = new sonUser('yichuan', 'xxx') 

8.3 寄生組合繼承

上面的繼承方式有所缺陷，所以寫這種方式即可。

  1. function Parent() { 
  2.   this.name = 'parent'; 
  3. } 
  4. function Child() { 
  5.   Parent.call(this); 
  6.   this.type = 'children'; 
  7. } 
  8. Child.prototype = Object.create(Parent.prototype); 
  9. Child.prototype.constructor = Child; 

參考文章

  • 《前端進階之必會的JavaScript技巧總結》
  • 《js基礎-面試官想知道你有多理解call,apply,bind?[不看后悔系列]》

 

責任編輯：姜華 來源： 前端萬有引力
前端開發技術熱點
相關推薦

2019-12-13 16:00:11

Dubbo面試題Java

2024-06-12 00:00:05

2024-04-26 00:25:52

Rust語法生命周期

2024-02-27 10:11:36

前端CSS@規則

2021-08-05 06:54:05

流程控制default

2021-10-11 07:55:42

瀏覽器語法Webpack

2024-06-24 12:51:50

2013-08-02 10:52:10

Android UI控件

2024-04-07 08:41:34

2024-08-26 10:01:50

2023-09-06 18:37:45

CSS選擇器符號

2010-08-25 01:59:00

2011-12-02 09:22:23

網絡管理NetQos

2015-06-01 10:37:41

數字取證數字取證工具

2019-07-24 15:30:00

SQL注入數據庫

2020-02-21 08:45:45

PythonWeb開發框架

2013-10-16 14:18:02

工具圖像處理

2023-04-06 09:08:41

BPM流程引擎

2021-05-20 11:17:49

加密貨幣區塊鏈印度

2021-10-29 09:32:33

springboot 靜態變量項目
點贊
收藏

51CTO技術棧公眾號

主站蜘蛛池模板： 欧美激情在线播放 | 国产美女精品视频 | 国产美女视频黄a视频免费 国产精品福利视频 | 午夜资源 | 欧美极品在线 | 人人鲁人人莫人人爱精品 | 国产激情一区二区三区 | 日本在线一区二区三区 | 成人在线免费观看 | 国产福利91精品一区二区三区 | 国产欧美在线 | 狠狠狠色丁香婷婷综合久久五月 | 国产精品久久久久久久久久 | 久操av在线 | 久久99久久 | 欧美在线一二三 | 九九九视频在线观看 | 国产精品91视频 | 自拍偷拍视频网 | 一级做a爰片性色毛片 | 99国产精品久久久 | 国产蜜臀 | 91麻豆产精品久久久久久夏晴子 | 欧美综合久久 | 久久久久久久久久久福利观看 | 国产 欧美 日韩 一区 | 久久精品久久久 | 国产福利在线看 | avhd101在线成人播放 | 久久久久国产精品一区二区 | 日本欧美视频 | 中文字幕精品一区二区三区精品 | 综合精品久久久 | 中国一级特黄毛片大片 | 五月天天色 | 精品中文字幕在线 | 黄色毛片在线播放 | a级在线 | 波霸ol一区二区 | 国产成人在线视频免费观看 | 青青草av网站 |