自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

前端基礎知識整理匯總二

作者：佚名
開發(fā) 前端
接上昨天的《前端基礎知識整理匯總（上）》，這些知識雖然是很基礎的，但是對于系統(tǒng)的梳理還是非常有幫助的，也希望這些內(nèi)容對你有所幫助。

[[384422]]

接上昨天的《前端基礎知識整理匯總(上)》，這些知識雖然是很基礎的，但是對于系統(tǒng)的梳理還是非常有幫助的，也希望這些內(nèi)容對你有所幫助。

Call, bind, apply實現(xiàn)

  1. // call 
  2. Function.prototype.myCall = function (context) { 
  3.   context = context ? Object(context) : window  
  4.   context.fn = this; 
  5.  
  6.   let args = [...arguments].slice(1); 
  7.   const result = context.fn(...args); 
  8.   delete context.fn; 
  9.   return result; 
  10. } 
  11.  
  12. // apply 
  13. Function.prototype.myApply = function (context) { 
  14.   context = context ? Object(context) : window; 
  15.   context.fn = this; 
  16.  
  17.   let args = [...arguments][1]; 
  18.   let result; 
  19.   if (args.length === 0) { 
  20.       result = context.fn(); 
  21.   } else { 
  22.       result = context.fn(args); 
  23.   } 
  24.   delete context.fn; 
  25.   return result; 
  26. } 
  27.  
  28. // bind 
  29. Function.prototype.myBind = function (context) { 
  30.   let self = this; 
  31.   let args = [...arguments].slice(1);  
  32.   return function() { 
  33.     let newArgs = [...arguments]; 
  34.     return self.apply(context, args.concat(newArgs)); 
  35.   } 
  36. } 

原型與原型鏈

每一個JavaScript對象(null除外)在創(chuàng)建的時候會關(guān)聯(lián)另一個對象，這個被關(guān)聯(lián)的對象就是原型。每一個JavaScript對象(除了 null)都具有的__proto__屬性會指向該對象的原型。JavaScript中所有的對象都是由它的原型對象繼承而來，而原型也是一個對象，它也有自己的原型對象，這樣層層上溯，就形成了一個類似鏈表的結(jié)構(gòu)，這就是原型鏈。每一個對象都會從原型"繼承"屬性。

實例對象和構(gòu)造函數(shù)都可以指向原型, 原型可以指向構(gòu)造函數(shù)，不能指向?qū)嵗?因為可以有多個實例)。

原型對象有兩個屬性，constructor 和 __proto__。

  1. function Person() {} 
  2. var person = new Person(); 
  3.  
  4. // 實例原型 === 構(gòu)造函數(shù)原型 
  5. person.__proto__ === Person.prototype // true 
  6. // 原型構(gòu)造函數(shù) === 構(gòu)造函數(shù) 
  7. Person.prototype.constructor === Person // true 

react diff

  • React 通過制定大膽的 diff 策略，將 O(n3) 復雜度的問題轉(zhuǎn)換成 O(n) 復雜度的問題;
  • React 通過分層求異的策略，對 tree diff 進行算法優(yōu)化;
  • 對樹進行分層比較，兩棵樹只會對同一層次的節(jié)點進行比較。
  • React 通過相同類生成相似樹形結(jié)構(gòu)，不同類生成不同樹形結(jié)構(gòu)的策略，對 component diff 進行算法優(yōu)化;
  1. 如果是同一類型的組件，按照原策略繼續(xù)比較 virtual DOM tree。
  2. 如果不是，則將該組件判斷為 dirty component，從而替換整個組件下的所有子節(jié)點。
  3. 對于同一類型的組件，有可能其 Virtual DOM 沒有任何變化，如果能夠確切的知道這點那可以節(jié)省大量的 diff 運算時間，因此 React 允許用戶通過 shouldComponentUpdate() 來判斷該組件是否需要進行 diff。
  • React 通過設置唯一 key的策略，對 element diff 進行算法優(yōu)化;
  • 建議，在開發(fā)組件時，保持穩(wěn)定的 DOM 結(jié)構(gòu)會有助于性能的提升;

遍歷對象

對象遍歷方法總結(jié)：

  • for...in：遍歷對象自身， 包含繼承， 可枚舉，不含 Symbol 的屬性。
  • Object.keys(obj)：遍歷對象自身, 不含繼承，可枚舉，不含 Symbol 的屬性?！緑alues， entries】
  • Object.getOwnPropertyNames(obj)：遍歷對象自身, 不含繼承, 不含 Symbol 的屬性, 不管是否可枚舉
  • Object.getOwnPropertySymbols(obj): 遍歷對象自身, 不含繼承, 所有 Symbol 的屬性, 不管是否可枚舉
  • Reflect.ownKeys(obj): 遍歷對象自身，不含繼承，所有鍵名，不管是否Symbol 和可枚舉。
  • 對象其他方法：
  • JSON.stringify()：只串行化對象自身，不含繼承，可枚舉，不含 Symbol屬性?！緁unction，undefined, Symbol會丟失， set、map會處理成空對象】
  • Object.assign()：只拷貝對象自身，不含繼承， 可枚舉屬性, 不管是否是Symbol 。【全部數(shù)據(jù)類型屬性值】

異步加載腳本

默認情況下，瀏覽器是同步加載 JavaScript 腳本，即渲染引擎遇到<script>標簽就會停下來，等到執(zhí)行完腳本，再繼續(xù)向下渲染。如果是外部腳本，還必須加入腳本下載的時間。

異步加載腳本方法：defer與async。

defer與async的區(qū)別是：defer要等到整個頁面在內(nèi)存中正常渲染結(jié)束（DOM 結(jié)構(gòu)完全生成，以及其他腳本執(zhí)行完成），才會執(zhí)行；async一旦下載完，渲染引擎就會中斷渲染，執(zhí)行這個腳本以后，再繼續(xù)渲染。一句話，defer是“渲染完再執(zhí)行”，async是“下載完就執(zhí)行”。另外，如果有多個defer腳本，會按照它們在頁面出現(xiàn)的順序加載，而多個async腳本是不能保證加載順序的。

瀏覽器對于帶有type="module"的<script>，都是異步加載，不會造成堵塞瀏覽器，即等到整個頁面渲染完，再執(zhí)行模塊腳本，等同于打開了<script>標簽的defer屬性。

ES6 模塊與 CommonJS 模塊的差異

  • CommonJS 模塊輸出的是一個值的拷貝，ES6 模塊輸出的是值的引用。
  • CommonJS 模塊是運行時加載，ES6 模塊是編譯時輸出接口。
  • 因為 CommonJS 加載的是一個對象（即module.exports屬性），該對象只有在腳本運行完才會生成。而 ES6 模塊不是對象，它的對外接口只是一種靜態(tài)定義，在代碼靜態(tài)解析階段就會生成。
  • CommonJS 模塊的require()是同步加載模塊，ES6 模塊的import命令是異步加載，有一個獨立的模塊依賴的解析階段。

回流Reflow與重繪Repaint
回流：元素的大小或者位置發(fā)生了變化，觸發(fā)了重新布局，導致渲染樹重新計算布局和渲染。頁面第一次加載的時候，至少發(fā)生一次回流。

  1. 添加或刪除可見的DOM元素；
  2. 元素的位置發(fā)生變化；
  3. 元素的尺寸發(fā)生變化；
  4. 內(nèi)容發(fā)生變化（比如文本變化或圖片被另一個不同尺寸的圖片所替代）；
  5. 頁面一開始渲染的時候（這個無法避免）；
  6. 瀏覽器的窗口尺寸變化， 因為回流是根據(jù)視口的大小來計算元素的位置和大小的；

重繪：元素的外觀，風格改變，而不會影響布局（不包含寬高、大小、位置等不變）。
如：outline, visibility, color, background-color......等

Reflow 的成本比 Repaint 高得多的多。DOM Tree 里的每個結(jié)點都會有 reflow 方法，一個結(jié)點的 reflow 很有可能導致子結(jié)點，甚至父點以及同級結(jié)點的 reflow。。回流一定會觸發(fā)重繪，而重繪不一定會回流

減少重繪與回流

1.CSS方法

  • 使用 visibility 替換 display: none ，因為前者只會引起重繪，后者會引發(fā)回流
  • 避免使用table布局，可能很小的一個小改動會造成整個 table 的重新布局。
  • 避免設置多層內(nèi)聯(lián)樣式，CSS 選擇符從右往左匹配查找，避免節(jié)點層級過多。
  • 將動畫效果應用到position屬性為absolute或fixed的元素上，避免影響其他元素的布局，這樣只是一個重繪，而不是回流，同時，控制動畫速度可以選擇 requestAnimationFrame
  • 避免使用CSS表達式，可能會引發(fā)回流。
  • 將頻繁重繪或者回流的節(jié)點設置為圖層，圖層能夠阻止該節(jié)點的渲染行為影響別的節(jié)點，例如will-change、video、iframe等標簽，瀏覽器會自動將該節(jié)點變?yōu)閳D層。
  • CSS3 硬件加速（GPU加速），使用css3硬件加速，可以讓transform、opacity、filters這些動畫不會引起回流重繪 。但是對于動畫的其它屬性，比如background-color這些，還是會引起回流重繪的，不過它還是可以提升這些動畫的性能。

2.JavaScript方法

  • 避免頻繁操作樣式，最好一次性重寫style屬性，或者將樣式列表定義為class并一次性更改class屬性。
  • 避免頻繁操作DOM，創(chuàng)建一個documentFragment，在它上面應用所有DOM操作，最后再把它添加到文檔中。
  • 避免頻繁讀取會引發(fā)回流/重繪的屬性，如果確實需要多次使用，就用一個變量緩存起來。

CSS3硬件加速（GPU加速）

CSS3 硬件加速又叫做 GPU 加速，是利用 GPU 進行渲染，減少 CPU 操作的一種優(yōu)化方案。

render tree -> 渲染元素 -> 圖層 -> GPU 渲染 -> 瀏覽器復合圖層 -> 生成最終的屏幕圖像。

瀏覽器在獲取 render tree后，渲染樹中包含了大量的渲染元素，每一個渲染元素會被分到一個個圖層中，每個圖層又會被加載到 GPU 形成渲染紋理。GPU 中 transform 是不會觸發(fā) repaint ，最終這些使用 transform 的圖層都會由獨立的合成器進程進行處理。

CSS3觸發(fā)硬件加速的屬性：

  1. transform
  2. opacity
  3. filter
  4. will-change

http請求方法
HTTP1.0定義了三種請求方法：GET, POST 和 HEAD方法。
HTTP1.1新增了五種請求方法：OPTIONS, PUT, DELETE, TRACE 和 CONNECT 方法。

  1. OPTIONS：即預檢請求，可用于檢測服務器允許的http方法。當發(fā)起跨域請求時，由于安全原因，觸發(fā)一定條件時瀏覽器會在正式請求之前自動先發(fā)起OPTIONS請求，即CORS預檢請求，服務器若接受該跨域請求，瀏覽器才繼續(xù)發(fā)起正式請求。
  2. HEAD: 向服務器索與GET請求相一致的響應，只不過響應體將不會被返回，用于獲取報頭。
  3. GET：向特定的資源發(fā)出請求。注意：GET方法不應當被用于產(chǎn)生“副作用”的操作中
  4. POST：向指定資源提交數(shù)據(jù)進行處理請求（例如提交表單或者上傳文件）。數(shù)據(jù)被包含在請求體中。POST請求可能會導致新的資源的建立和/或已有資源的修改。
  5. PUT：向指定資源位置上傳其最新內(nèi)容
  6. DELETE：請求服務器刪除Request-URL所標識的資源
  7. TRACE：回顯服務器收到的請求，主要用于測試或診斷
  8. CONNECT：HTTP/1.1協(xié)議中預留給能夠?qū)⑦B接改為管道方式的代理服務器

js判斷數(shù)據(jù)類型

1. typeof 操作符

  • 對于基本類型，除 null 以外，均可以返回正確的結(jié)果。
  • 對于引用類型，除 function 以外，一律返回 object 類型。
  • 對于 null ，返回 object 類型。
  • 對于 function 返回 function 類型。

2. instanceof

用來判斷 A 是否為 B 的實例，檢測的是原型。instanceof 只能用來判斷兩個對象是否屬于實例關(guān)系， 而不能判斷一個對象實例具體屬于哪種類型。

instanceof 主要的實現(xiàn)原理就是只要右邊變量的 prototype 在左邊變量的原型鏈上即可。

3. constructor

  • null 和 undefined 是無效的對象，不會有 constructor 存在的
  • 函數(shù)的 constructor 是不穩(wěn)定的，這個主要體現(xiàn)在自定義對象上，當開發(fā)者重寫 prototype 后，原有的 constructor 引用會丟失，constructor 會默認為 Object。為了規(guī)范開發(fā)，在重寫對象原型時一般都需要重新給 constructor 賦值。

4. toString

toString() 是 Object 的原型方法，調(diào)用該方法，默認返回當前對象的 [[Class]] 。這是一個內(nèi)部屬性，其格式為 [object Xxx] ，其中 Xxx 就是對象的類型。

 瀏覽器事件模型

DOM事件流(event flow )存在三個階段：事件捕獲階段、處于目標階段、事件冒泡階段。

  1. // useCapture：true, 即采用事件捕獲方式 
  2. window.addEventListener("click", function(e){ 
  3.   console.log("window 捕獲"); 
  4. }, true); 
  5.  
  6. // useCapture：false【默認為false】，即采用事件冒泡方式 
  7. window.addEventListener("click", function(e){ 
  8.   console.log("window 冒泡"); 
  9. }, false); 

目標元素(被點擊的元素)綁定的事件都會發(fā)生在目標階段，在綁定捕獲代碼之前寫了綁定的冒泡階段的代碼，所以在目標元素上就不會遵守先發(fā)生捕獲后發(fā)生冒泡這一規(guī)則，而是先綁定的事件先發(fā)生。

不是目標元素，它上面綁定的事件會遵守先發(fā)生捕獲后發(fā)生冒泡的規(guī)則。

e.stopPropagation()：阻止事件傳播。不僅可以阻止事件在冒泡階段的傳播，還能阻止事件在捕獲階段的傳播。

e.preventDefault(): 阻止事件的默認行為。默認行為是指：點擊a標簽就轉(zhuǎn)跳到其他頁面、拖拽一個圖片到瀏覽器會自動打開、點擊表單的提交按鈕會提交表單等

http緩存: 強制緩存和協(xié)商緩存

良好的緩存策略可以降低資源的重復加載提高網(wǎng)頁的整體加載速度。

緩存原理

  1. 瀏覽器在加載資源時，根據(jù)請求頭的expires和cache-control判斷是否命中強緩存，是則直接從緩存讀取資源，不會發(fā)請求到服務器。
  2. 如果沒有命中強緩存，瀏覽器會發(fā)送一個請求到服務器，通過last-modified和etag驗證是否命中協(xié)商緩存。當向服務端發(fā)起緩存校驗的請求時，服務端會返回 200 ok表示返回正常的結(jié)果或者 304 Not Modified(不返回body)表示瀏覽器可以使用本地緩存文件。304的響應頭也可以同時更新緩存文檔的過期時間
  3. 如果前面兩者都沒有命中，直接從服務器加載資源。

實現(xiàn)方式

強緩存通過Expires和Cache-Control實現(xiàn)。

協(xié)商緩存是利用的是【Last-Modified，If-Modified-Since】和【ETag、If-None-Match】這兩對Header來管理的。

Expires

Expires是http1.0提出的一個表示資源過期時間的header，它是一個絕對時間，由服務器返回。Expires 受限于本地時間，如果修改了本地時間，可能會造成緩存失效。

Expires: Wed, 11 May 2018 07:20:00 GMT

Cache-Control

Cache-Control 出現(xiàn)于 HTTP / 1.1，優(yōu)先級高于 Expires , 表示的是相對時間。

  1. no-store：沒有緩存。緩存中不得存儲任何關(guān)于客戶端請求和服務端響應的內(nèi)容。每次由客戶端發(fā)起的請求都會下載完整的響應內(nèi)容。 
  2. no-cache: 緩存但重新驗證。每次有請求發(fā)出時，緩存會將此請求發(fā)到服務器（譯者注：該請求應該會帶有與本地緩存相關(guān)的驗證字段），服務器端會驗證請求中所描述的緩存是否過期，若未過期（返回304），則緩存才使用本地緩存副本。 
  3. private：只允許客戶端瀏覽器緩存。 
  4. public: 允許所有用戶緩存。例如中間代理、CDN等 
  5. max-age=<seconds>：表示資源能夠被緩存的最大時間。相對Expires而言，max-age是距離請求發(fā)起的時間的秒數(shù)。針對應用中那些不會改變的文件，通?？梢允謩釉O置一定的時長以保證緩存有效，例如圖片、css、js等靜態(tài)資源。 
  6. must-revalidate:觸發(fā)緩存驗證。驗證它的狀態(tài)，已過期的緩存將不被使用 

Last-Modified，If-Modified-Since

Last-Modifie表示本地文件最后修改日期，瀏覽器會在request header加 If-Modified-Since(上次返回的Last-Modified的值)，詢問服務器在該日期后資源是否有更新，有更新的話就會將新的資源發(fā)送回來。

但是如果在本地打開緩存文件，就會造成 Last-Modified 被修改，所以在 HTTP / 1.1 出現(xiàn)了 ETag。

ETag、If-None-Match

Etag就像一個指紋，資源變化都會導致ETag變化，跟最后修改時間沒有關(guān)系，ETag可以保證每一個資源是唯一的。

If-None-Match的header會將上次返回的Etag發(fā)送給服務器，詢問該資源的Etag是否有更新，有變動就會發(fā)送新的資源回來。

ETag的優(yōu)先級比Last-Modified更高。

具體為什么要用ETag，主要出于下面幾種情況考慮：

  • 一些文件也許會周期性的更改，但是他的內(nèi)容并不改變(僅僅改變的修改時間)，這個時候我們并不希望客戶端認為這個文件被修改了，而重新GET;
  • 某些文件修改非常頻繁，比如在秒以下的時間內(nèi)進行修改，(比方說1s內(nèi)修改了N次)，If-Modified-Since能檢查到的粒度是s級的，這種修改無法判斷(或者說UNIX記錄MTIME只能精確到秒);
  • 某些服務器不能精確的得到文件的最后修改時間。

防抖和節(jié)流

防抖：當你在頻繁調(diào)用方法時，并不會執(zhí)行，只有當你在指定間隔內(nèi)沒有再調(diào)用，才會執(zhí)行函數(shù)。

節(jié)流：在一個單位時間內(nèi)，只能觸發(fā)一次函數(shù)。如果這個單位時間內(nèi)觸發(fā)多次函數(shù)，只有一次生效。

防抖

  1. function debounce(fn, wait) { 
  2.   let time = null; 
  3.  
  4.   return (function() { 
  5.     const context = this; 
  6.     const args = arguments; 
  7.  
  8.     if (time) { 
  9.       clearTimeout(time); 
  10.       time = null; 
  11.     } 
  12.     time = setTimeout(() => { 
  13.       fn.call(context, args); 
  14.     }, wait); 
  15.   }); 
  16. } 

節(jié)流

  1. function throttle(fn, wait)  
  2. { 
  3.   let lastTime; 
  4.  
  5.   return ( 
  6.     function() { 
  7.       const context = this; 
  8.       const args = arguments; 
  9.       let nowTime = + new Date(); 
  10.  
  11.       if (nowTime > lastTime + wait || !lastTime) { 
  12.         fn.call(context, args); 
  13.         lastTime = nowTime; 
  14.       } 
  15.     } 
  16.   ); 

大小單位區(qū)別

px：像素。

em：參考物是父元素的font-size，具有繼承的特點。如果自身定義了font-size按自身來計算，整個頁面內(nèi)1em不是一個固定的值。

rem：相對于根元素html的font-size計算，不會像em那樣，依賴于父元素的字體大小，而造成混亂。

vw：視窗寬度，1vw等于視窗寬度的1%。

vh：視窗高度，1vh等于視窗高度的1%。

vm：min(vw, vh)。

%：是相對于父元素的大小設定的比率，position:absolute;的元素是相對于已經(jīng)定位的父元素，position：fixed;的元素是相對可視窗口。

  • 瀏覽器默認字體是16px, body設置font-size：62.5%, 那么1rem =62.5% * 16=10px 。
  • 谷歌瀏覽器強制最小字體為12號，即使設置成 10px 最終都會顯示成 12px，當把html的font-size設置成10px,子節(jié)點rem的計算還是以12px為基準。

Box-sizing

  • content-box：這是默認情況，整個元素的高度和寬度就是元素內(nèi)容
  • border-box：這種情況下，你設置的width和height屬性值就是針對整個元素，包括了border，padding，和元素內(nèi)容。

函數(shù)聲明和函數(shù)表達式

  1. // 函數(shù)聲明 
  2. function wscat(type){ 
  3.   return 'wscat'; 
  4. } 
  5.  
  6. // 函數(shù)表達式 
  7. var oaoafly = function(type){ 
  8.   return "oaoafly"; 
  9. } 
  • JavaScript 解釋器中存在一種變量聲明被提升的機制，也就是說函數(shù)聲明會被提升到作用域的最前面，即使寫代碼的時候是寫在最后面，也還是會被提升至最前面。
  • 用函數(shù)表達式創(chuàng)建的函數(shù)是在運行時進行賦值，且要等到表達式賦值完成后才能調(diào)用

函數(shù)聲明在JS解析時進行函數(shù)提升，因此在同一個作用域內(nèi)，不管函數(shù)聲明在哪里定義，該函數(shù)都可以進行調(diào)用。而函數(shù)表達式的值是在JS運行時確定，并且在表達式賦值完成后，該函數(shù)才能調(diào)用。這個微小的區(qū)別，可能會導致JS代碼出現(xiàn)意想不到的bug，讓你陷入莫名的陷阱中。

事件循環(huán)EventLoop

JavaScript是一個單線程的腳本語言。

所有同步任務都在主線程上執(zhí)行，形成一個執(zhí)行棧 (Execution Context Stack);而異步任務會被放置到 Task Table(異步處理模塊)，當異步任務有了運行結(jié)果，就將注冊的回調(diào)函數(shù)移入任務隊列(兩種隊列)。

一旦執(zhí)行棧中的所有同步任務執(zhí)行完畢，引擎就會讀取任務隊列，然后將任務隊列中的第一個任務取出放到執(zhí)行棧中運行。(所有會進入的異步都是指的事件回調(diào)中的那部分代碼)

只要主線程空了，就會去讀取任務隊列，該過程不斷重復，這就是所謂的 事件循環(huán)。

宏任務和微任務

宏任務會進入一個隊列，微任務會進入到另一個隊列，且微任務要優(yōu)于宏任務執(zhí)行。

宏任務：script(整體代碼)、setTimeout、setInterval、I/O、事件、postMessage、 MessageChannel、setImmediate (Node.js)

微任務：Promise.then、 MutaionObserver、process.nextTick (Node.js)

宏任務會進入一個隊列，而微任務會進入到另一個不同的隊列，且微任務要優(yōu)于宏任務執(zhí)行。

Promise

  1. 1. Promise.all: 全部fulfilled,  才進入then, 否則 catch 
  2. 2. Promise.race: 任一個返回，不管是fulfilled還是rejected,  進入相應的then/catch 
  3. 3. Promise.allSettled: 全部返回，不管是fulfilled還是rejected,  進入then 
  4. 4. Promise.any: 任一個返回fulfilled,  就進入then, 否則 catch 

虛擬dom原理

Virtual DOM是對DOM的抽象,本質(zhì)上是JavaScript對象,這個對象就是更加輕量級的對DOM的描述.

箭頭函數(shù)與普通函數(shù)區(qū)別

  • 語法更加簡潔、清晰
  • 不綁定this，會捕獲其所在的上下文的this值，作為自己的this值
  • 箭頭函數(shù)繼承而來的this指向永遠不變
  • .call()/.apply()/.bind()無法改變箭頭函數(shù)中this的指向
  • 不能作為構(gòu)造函數(shù)使用， 因為沒有自己的 this，無法調(diào)用 call，apply;沒有 prototype 屬性 ，而 new 命令在執(zhí)行時需要將構(gòu)造函數(shù)的 prototype 賦值給新的對象的__prpto__ 。
  • 沒有自己的arguments，在箭頭函數(shù)中訪問arguments實際上獲得的是外層局部(函數(shù))執(zhí)行環(huán)境中的值。如果要用，可以用 rest 參數(shù)代替。
  • 沒有原型prototype, 指向 undefined
  • 不能使用yeild關(guān)鍵字

new

new 關(guān)鍵字會進行如下的操作：

  1. 創(chuàng)建一個空的簡單JavaScript對象(即{});
  2. 鏈接該對象(設置該對象的__proto__)到構(gòu)造器函數(shù)的原型 ;
  3. 將新創(chuàng)建的對象作為this的上下文 ;
  4. 返回。如果該函數(shù)沒有返回對象，則返回this。
  1. function newFunc(father, ...rest) { 
  2.   // 首先創(chuàng)建一個空對象 
  3.   var result = {}; 
  4.   // 將空對象的原型賦值為構(gòu)造器函數(shù)的原型 
  5.   result.__proto__ = father.prototype; 
  6.   // 更改構(gòu)造器函數(shù)內(nèi)部this，將其指向新創(chuàng)建的空對象 
  7.   var result2 = father.apply(result, rest); 
  8.  
  9.   if ((typeof result2 === 'object' || typeof result2 === 'function') && result2 !== null) { 
  10.     return result2; 
  11.   } 
  12.   return result; 
  13. } 

水平與垂直居中實現(xiàn)方式

水平居中

  • text-align: center; 行內(nèi)元素適用
  • margin: 0 auto; 適用塊級元素
  • width: fit-content; 若子元素包含 float:left 屬性, 為了讓子元素水平居中, 則可讓父元素寬度設置為fit-content, 并且配合margin。
  1. .parent { 
  2.   width:fit-content; 
  3.   margin:0 auto; 
  4. } 

flex

  1. .parent { 
  2.   display: flex; 
  3.   justify-content: center; 
  4. } 

盒模型, 使用flex 2009年版本

  1. .parent { 
  2.   display: box; 
  3.   box-orient: horizontal; 
  4.   box-pack: center; 
  5. } 

transform

  1. .son { 
  2.   position: absolute; 
  3.   left: 50%; 
  4.   transform: translate(-50%, 0); 
  5. } 

兩種不同的絕對定位方法

  1. .son { 
  2.   position: absolute; 
  3.   width: 固定； 
  4.   left: 50%; 
  5.   margin-left: -0.5 * 寬度; 
  6. } 
  7.  
  8. .son { 
  9.   position: absolute; 
  10.   width: 固定； 
  11.   left: 0; 
  12.   right: 0; 
  13.   margin: 0 auto; 
  14. } 

垂直居中

  • 單行文本, line-height
  • 行內(nèi)塊級元素, 使用 display: inline-block, vertical-align: middle; 加上偽元素輔助實現(xiàn)
  1. .parent::after, .son { 
  2.     display:inline-block; 
  3.     vertical-align:middle; 
  4. } 
  5. .parent::after { 
  6.     content:''; 
  7.     height:100%; 
  8. } 
  •  vertical-align。vertical-align只有在父層為 td 或者 th 時, 才會生效, 對于其他塊級元素, 例如 div、p 等, 默認情況是不支持的. 為了使用vertical-align, 我們需要設置父元素display:table, 子元素 display:table-cell;vertical-align:middle;

flex

  1. .parent { 
  2.   display: flex; 
  3.   align-items: center; 
  4. } 

盒模型

  1. .parent { 
  2.   display: box; 
  3.   box-orient: vertical; 
  4.   box-pack: center; 
  5. } 

transform

  1. .son { 
  2.   position: absolute; 
  3.   top: 50%; 
  4.   transform: translate(0, -50%); 
  5. } 

兩種不同的絕對定位方法

  1. .son { 
  2.   position: absolute; 
  3.   height: 固定; 
  4.   top: 50%; 
  5.   margin-top: -0.5 * height; 
  6. } 
  7.  
  8. .son { 
  9.   position: absolute; 
  10.   height: 固定; 
  11.   top: 0; 
  12.   bottom: 0; 
  13.   margin: auto 0; 
  14. } 

flex, 盒模型, transform, 絕對定位, 這幾種方法同時適用于水平居中和垂直居中

排序

冒泡排序

  1. function bubbleSort(arr) { 
  2.   const len = arr.length; 
  3.   for (let i = 0; i < len - 1; i++) { 
  4.     for (let j = i + 1; j < len; j++) { 
  5.       if (arr[j] < arr[i]) { 
  6.         [arr[j], arr[i]] = [arr[i], arr[j]]; 
  7.       } 
  8.     } 
  9.   } 
  10.   return arr; 
  11. } 

選擇排序

選擇排序(Selection-sort)是一種簡單直觀的排序算法。它的工作原理：首先在未排序序列中找到最小(大)元素，存放到排序序列的起始位置，然后，再從剩余未排序元素中繼續(xù)尋找最小(大)元素，然后放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。

  1. function selectionSort(arr) { 
  2.   const len = arr.length; 
  3.   for (let i = 0; i < len - 1; i++) { 
  4.     let index = i; 
  5.     for (let j = i + 1; j < len; j++) { 
  6.       if (arr[j] < arr[index]) { 
  7.         index = j; 
  8.       } 
  9.     } 
  10.     if (index !== i) { 
  11.       [arr[i], arr[index]] = [arr[index], arr[i]]; 
  12.     } 
  13.   } 
  14.   return arr; 
  15. } 

插入排序

插入排序(Insertion-Sort)的算法描述是一種簡單直觀的排序算法。它的工作原理是通過構(gòu)建有序序列，對于未排序數(shù)據(jù)，在已排序序列中從后向前掃描，找到相應位置并插入。

插入排序在實現(xiàn)上，通常采用in-place排序(即只需用到O(1)的額外空間的排序)，因而在從后向前掃描過程中，需要反復把已排序元素逐步向后挪位，為最新元素提供插入空間。

  1. function insertionSort(arr) { 
  2.   const len = arr.length; 
  3.   for (let i = 1; i < len; i++) { 
  4.     let j = i - 1; 
  5.     const value = arr[i]; 
  6.     while (arr[j] > value && j >= 0) { 
  7.       arr[j + 1] = arr[j]; 
  8.       j--; 
  9.     } 
  10.     arr[j + 1] = value; 
  11.   } 
  12.   return arr; 
  13. } 

歸并排序

歸并排序是建立在歸并操作上的一種有效的排序算法。該算法是采用分治法(Divide and Conquer)的一個非常典型的應用。歸并排序是一種穩(wěn)定的排序方法。先使每個子序列有序，再使子序列段間有序。若將兩個有序表合并成一個有序表，稱為2-路歸并。

  1. function mergeSort(arr) {  //采用自上而下的遞歸方法 
  2.   var len = arr.length; 
  3.   if (len < 2) return arr; 
  4.  
  5.   const middle = Math.floor(len / 2); 
  6.   let left = arr.slice(0, middle); 
  7.   let right = arr.slice(middle); 
  8.   return merge(mergeSort(left), mergeSort(right)); 
  9. } 
  10.  
  11. function merge(left, right) { 
  12.   let result = []; 
  13.   while (left.length && right.length) { 
  14.     if (left[0] <= right[0]) { 
  15.       result.push(left.shift()); 
  16.     } else { 
  17.       result.push(right.shift()); 
  18.     } 
  19.   } 
  20.   return result.concat(left).concat(right); 
  21. } 

快速排序

快速排序的基本思想：通過一趟排序?qū)⒋庞涗浄指舫瑟毩⒌膬刹糠郑渲幸徊糠钟涗浀年P(guān)鍵字均比另一部分的關(guān)鍵字小，則可分別對這兩部分記錄繼續(xù)進行排序，以達到整個序列有序。

  1. function quickSort(arr) { 
  2.   if (arr.length <= 1) return arr; 
  3.   const pivotIndex = Math.floor(arr.length / 2); 
  4.   const pivot = arr.splice(pivotIndex, 1)[0]; 
  5.   let left = []; 
  6.   let right = []; 
  7.   for (let i = 0; i < arr.length; i++){ 
  8.     if (arr[i] < pivot) { 
  9.       left.push(arr[i]); 
  10.     } else { 
  11.       right.push(arr[i]); 
  12.     } 
  13.   } 
  14.   return quickSort(left).concat([pivot], quickSort(right)); 
  15. }; 
  16. }; 

洗牌算法

  1. function shuffle(arr){ 
  2.   const length = arr.length; 
  3.   while (length > 0) { 
  4.     const random = Math.floor(Math.random() * length); 
  5.     length--; 
  6.     [arr[length], arr[random]] = [arr[random], arr[length]]; 
  7.   } 
  8.   return arr; 
  9. } 
  10.  
  11. // 或 
  12. arr.sort(function(){ 
  13.   return .5 - Math.random(); 
  14. }); 

本文完〜

 

責任編輯：姜華 來源： 大遷世界
前端開發(fā)技術(shù)熱點
相關(guān)推薦

2021-03-01 08:03:16

前端開發(fā)技術(shù)熱點

2021-03-03 08:04:44

前端開發(fā)技術(shù)熱點

2024-05-22 08:03:39

2010-05-24 16:58:00

MySQL數(shù)據(jù)庫備份

2018-02-01 13:59:44

Linux命令磁盤管理

2010-03-17 11:21:40

Linux 系統(tǒng)

2011-07-21 17:18:52

java

2021-04-01 13:44:50

開發(fā)前端Web

2009-09-23 11:07:11

Hibernate基礎

2010-07-16 10:53:30

Perl基礎

2015-06-01 13:35:43

數(shù)據(jù)中心DCIM

2009-04-17 14:22:40

XPathXML基礎

2010-03-18 15:07:13

Linux操作系統(tǒng)

2011-09-16 10:13:02

Emacs

2011-03-29 14:11:20

Cacti基礎知識

2009-04-10 09:35:00

WCDMA基礎無線網(wǎng)絡

2023-07-04 07:31:06

MapReduce數(shù)據(jù)處理編程模型

2010-07-16 11:22:31

Perl

2014-08-20 10:15:45

2018-08-30 11:11:32

前端程序員基礎知識
點贊
收藏

51CTO技術(shù)棧公眾號