前端列表去重設計

㈠ 前端面試時被問到前端布局，這個怎麼回答

前端面試時被問到前端布局，這個怎麼回答

你可以說，你對DIV+CSS布局的了解，不懂你先網路吧，我不可能一一說明的。
然後說，盒子模型的了解，還是那句，不懂你網路吧。
然後說，清除浮動的了解，還是那句，不懂你網路。
然後說，內聯、內聯塊和內聯元素的了解。
還有一些加分的，例如overflow的深入理解。overflow，如果理解得深入，對布局有一定的影響。
差不多就這樣了，面試官也許問得更細，我就不清楚了。

前端面試，被問到vue的元件是怎麼寫，我怎麼回答

vue框架中狀態管理。在main.js引入store，注入。新建了一個目錄store，….. export 。場景有：單頁應用中，元件之間的狀態。音樂播放、登入狀態、加入購物車

web前端面試被問到為什麼離職

實話實說，但是注意言辭，回答過程中千萬不要抱怨、或是「吐槽」前東家的種種不好，請客觀磨模悄地敘述與自己現在狀態有哪些不相契合的點。
參考：原東家的發展空間達不到我的期望，我想要尋找新的機會挑戰自己，同時創造更大的價值。
注意：避免假大空的官話，會讓人覺得不真誠，另外，點到為止，無需細談。

前端面試時問到：怎麼解決瀏覽器相容性？該怎麼回答比較碼型好？

IE6/IE7對FE當然很不友好，但專業的FE決不應該因為這兩個瀏覽器難處理就不處理了。假如使用者需要，我的目標是在力所能及的情況下為使用者提供最好的前端展現。相容性的問題從來都不只是IE6/7的問題，各個手機、瀏覽器、版本的相容性同樣有各種各樣的問題，比IE奇葩多了。我的經驗是，每遇到一個坑爹問題，做這么幾件事：確認觸發場景，什麼瀏覽器、版本、什麼情況下會出現這個問題，做到穩定復現；找到問題原因，為什麼會出現這樣的問題（網上搜、自己琢磨甚至郵件問相應公司開發者等等都是可行的）；確瞎渣定解決法，有沒有什麼框架級的解決法，總之是定規范，避免類似問題；比如不使用某些屬性；用某種布局方法規避一些問題等等；有沒有什麼臨時的法可以快速繞過去？不是每次都有時間搞框架級的法來著。怎麼hack過去把這些都積累起來，就會有用處。不要想著IE6、7沒了就不用考慮瀏覽器相容性問題，chrome/firefox、webkit的各種版本，手機的各種瀏覽器、各種終端都要處理瀏覽器相容性問題，恩，對，偶爾還有flash來著。相容各種終端、相容各種解析度、相容瀏覽器都是相容性問題，這是FE的命，得認。抱著讓使用者有最好體驗的想法去做，收獲更大。

前端面試被問到，vue實現資料雙向系結，原理是啥

其原理大致是這樣：
在資料渲染時使用prop渲染資料
將prop系結到子元件自身的資料上，修改資料時修改自身資料來替代prop
watch子元件自身資料的改變，觸發事件通知父元件更改系結到prop的資料
這樣做的好處是：父元件資料改變時，不會修改儲存prop的子元件資料，只是以子元件資料為媒介，完成對prop的雙向修改。

web前端面試怎麼說

面試方法

• 程式碼編寫筆試

• 問答式

過程遵循 STAR 面試法 。

校招和社招的是不一樣的，校招會更加關注基礎知識，而社招會更加關注之前做過的專案情況。

專案相關

面試其實說白了就是根據一個人之前的經歷，來判斷出後續這人會做得怎樣，如果你之前從沒做成過一件事情，憑什麼讓別人相信你之後能做成呢？因此無論哪裡的面試都會問你之前做過的專案

專案可以是多人協助開發一個產品，也可以是自己個人做過的業余應用，只需介紹 1、2 個就夠了，需要注意的是 1 + 1 != 2，做了兩個平庸的專案不如做了一個好專案。

一般來說會問如下幾方面的問題：

• 做過最滿意的專案是什麼？

• 專案背景

• 為什麼要做這件事情？

• 最終達到什麼效果？

• 你處於什麼樣的角色，起到了什麼方面的作用？

• 在專案中遇到什麼技術問題？具體是如何解決的？

• 如果再做這個專案，你會在哪些方面進行改善？

技術相關 - 1 面

技術一面主要判斷對基礎知識的掌握

• 描述一個你遇到過的技術問題，你是如何解決的？

• 這個問題很常見，有沒有遇到過很不常見的問題？比如在網上根本搜不到解決方法的？

• 是否有設計過通用的元件？

• 請設計一個 Dialog（彈出層） / Suggestion（自動完成） / Slider（圖片輪播） 等元件

• 你會提供什麼介面？

• 呼叫過程是怎樣的？可能會遇到什麼細節問題？

技術二面主要判斷技術深度及廣度

• 你最擅長的技術是什麼？

• 你覺得你在這個技術上的水平到什麼程度了？你覺得最高級別應該是怎樣的？

• 瀏覽器及效能

• 這些優化方法背後的原理是什麼？

• 除了這些常規的，你還了解什麼最新的方法么？

• （這個問既考察技術深度又考察技術廣度，其實要答好是相當難的，注意越詳細越好）

• 一個頁面從輸入 URL 到頁面載入完的過程中都發生了什麼事情？越詳細越好

• 談一下你所知道的頁面效能優化方法？

• 如何分析頁面效能？

• 其它

• 除了前端以外還了解什麼其它技術么？

• 對計算機基礎的了解情況，比如常見資料結構、編譯原理等

興趣相關

• 最近在學什麼？接下來半年你打算學習什麼？

• 做什麼方面的事情最讓你有成就感？需求設計？規劃？具體開發？

• 後續想做什麼？3 年後你希望自己是什麼水平？

主動性相關

• 在之前做過的專案中，有沒有什麼功能或改進點是由你提出來的？

• 是否有參與和改進其它開源專案

頁面前端面試經常問到的問題

其實，不管是什麼樣的面試形，問的問題都差不多，萬變不離其宗，都有規律可尋。其實對所有的面試官而言，只有一個目的：在最短的時間里了解到你最多的資訊。想高效率的准備面試，先從這七個大方面著手吧！
一、基本情況
1、請用最簡潔的語言描述您從前的工作經歷和工作成果。
二、專業背景
您認為此工作崗位應當具備哪些素質？
三、工作模式
您平時習慣於單獨工作還是團隊工作？
四、價值取向
您對原來的單位和上司的看法如何？
五、資質特性
您如何描述自己的個性？
六、薪資待遇
是否方便告訴我您目前的待遇是多少？
七、背景調查
您是否介意我們通過您原來的單位迚行一些調查？
95%的面試基本上都離不開這些問題，當然還有可能問一些專業問題，我想如果你做過的話應該都不是什麼難事，一般面試官都不會過多的問專業方面的問題的。以上資訊直接參考楚湘人才網面試寶典篇之化繁為簡，把HR的上百道問題匯總成七大類和面試常問經典問題。更多更全面的面試資訊 面試技巧 面試問題請登陸楚湘人才網或關注微信公眾平台：楚湘人才網

如何用ecshop修改頁面前端布局

網站是在伺服器上的慶，你朋友給你FTP或伺服器的帳號密碼沒。如果沒有的話要下，是在網站的檔案目錄里

web前端面試怎麼介紹

• 你的筆試題, 根據其做延伸.

• 你的簡歷, 技術棧、工作外學習情況、專案經驗. 第一頁很重要, 最好都能掌握, 有亮點更好.

• 面試官額外的延展的知識點, 隨機問,看你運氣和積累(一般會提及到 ES6、解決實際問題的方法、資料結構與演演算法都有可能).

應對

• 刷題, 各種基礎題會幫你快速回憶起來, 比你看書快, 如果基礎不好的話, 看書好好學學吧.

• 簡歷上自己寫的東西, 要能說出來.

• 積累, 每次面試不成功就回來填坑吧, 還是有掌握不到位的. 我覺得能堅持下來的話, 找工作只是時間問題.

• 據公司業務不同, 著重點不一樣, 公司能把你簡歷挑出來, 就說明有用人單位感興趣的部分.

• 可能你寫的是熟練使用 Vue, 公司也是這個技術棧.

• 可能你知識寫的全面, 公司想面面你實際掌握怎麼樣.

• 可能你專案寫的貼合用人單位需要, 比如都是做後台管理的.

框架問題: (Vue 舉例, 3框架實質問題差不多, 具體有些差異)

• 封裝過哪些元件?有自己寫過 UI 元件嗎?

• 什麼是 MVVM , 和 MVC 是什麼區別, 原理是什麼?

• 父子元件怎麼通訊的?

• 兄弟元件怎麼通訊的?

• 生命周期有哪些, 怎麼用?

• Vue 全家桶都用過哪些?具體怎麼用?

HTML5 + CSS3

• 盒子模型

• 如何給未知寬高的圖片垂直居中對齊? 有幾種方法?

• 移動端的 rem 布局.

• 前端可以做哪些優化, 或問你 SEO, 基本都問.

• 清除浮動方式和原理, 基本都問. 幾種方式? 原理? 為什麼要用偽元素? 具體程式碼怎麼寫,為什麼這么寫?

• 清除浮動就會涉及到 BFC 的問題.

• 給你實際頁面例子, 讓你口述布局或手寫實現細節, 可以使用幾種方法, 怎麼寫相容性好, 拓展性好.

• 具體 API 哪個 CSS 版本的?

• CSS3 新增了哪些 API?

• 可能問你哪些 API 是 CSS 哪個版本的? 相容性怎麼樣.

• CSS hack 是什麼? 包含什麼? 怎麼處理相容性問題?

• HTML5 新增了哪些 API? 哪些比較常用? 用來做什麼? 實際怎麼用?

• cookie, session, localStrorage, sessionStorage 區別, 具體怎麼用程式碼去操作?

JavaScript

• 變數宣告提升的問題.

• 閉包的原理, 閉包的各種題, 基本都問.

• DOM2 事件流, 冒泡和捕獲問題?

• this 指向問題, 一般都是在筆試題里, 拿著問你, 問的比較多.

• call 和 apply 區別? 有的還會加問 bind?

• 面向物件程式設計中的繼承問題, 原型鏈問題在筆試題里比較常見.

• jQuery API , 各種操作 DOM 用法, 還有一些新的 API, 這種在不用 3 大框架的公司會問的很詳細.

• 可能有些考演演算法結構的, 可以了解一下, 一般前端掌握的很少.

• Ajax 基本都問, 問的細節可能不同, 比如 get 和 post 有什麼區別?

• 陣列的方法 - es6 以下基本都能熟練使用, 應該會加分不少

• 字串的方法 - 拼接, 擷取, 帶些正則

• 陣列去重問的挺多的(解法很多, ES6 有很多簡短寫法)

• ES6 的 Promise , 很多都會問. 如果公司用框架或者你寫了, 還會問你 Class.

• var, let, const區別, 問的多.

• 棧和佇列結構, 有的會問.

• 跨域問題: 同源策略, 解決方案, 解決原理(比如 jsonp 的原理), 這里都是高發區.

網頁前端布局都用什麼工具

一般應該都是用ps或者類似的作圖軟體先把圖畫出來，然後再手寫程式碼。
用ps等做出軟體是方便作圖後修改，因為不管是內部用還是給客戶總是要多修改的

㈡ 前端開發設計

1.用於UI設計的Sketch app

Sketch正在迅速取代Photoshop，用於從低保真線框到高保真模型和設計圖標的所有的UI設計任務。

Sketch app是一個專為web和移動設計人員製作的Mac應用程序。它的功能，靈活性和速度滿足了你對於一個輕量級，易於使用的軟體包的想像。有了這個app，你就可以專注於創作最佳的設計了。

它提供了一個順暢的工作環境，為任何界面提供工藝化的矢量元素，而且還有你想從Photoshop得到的許多功能，瞎蘆如文本效果和圖層樣式。

如果Sketch能夠繼續提供最佳的UI設計體驗，那麼它在2016年及以後必然還會繼續保持輝煌。

2.基於瀏覽器的IDE

桌面IDE已經存在了幾十年，從Notepad到Xcode和visual Studio。IDE通過提供建議和語法高亮等功能使得我們可以卜燃更容易地編寫代碼。在IDE中寫代碼非常簡單，而且很易於閱讀。

但傳統的IDE是作為桌面應用程序發布的。從過去的幾年裡，基於瀏覽器的雲IDE發生了戲劇性的變化。除了web瀏覽器，我們不再需要任何軟體，因為瀏覽器型神虛允許設備操作來自於任何有互聯網接入的計算機的代碼。

雲IDE的功能更像是web應用程序，你可以保存代碼到你的帳戶進行共享或個人存儲。CodePen是目前最流行的IDE，支持HTML/ CSS/JS，具備像Jade/Haml 和LESS/SCSS一樣自定義的預處理。

CodePen主攻web前端。它可以顯示你最近的創造，並從其他網路資源上得到反饋。為惱人的bug建立一個測試案例。你還可以從CodePen上為你的項目找到設計模式和靈感。

3.card layouts（卡片布局）

網站的卡片布局在幾年前通過Pinterest而普及，從此成為了內容繁多網頁的趨勢。免費插件，如jQuery Masonry可用來模仿這種布局風格，它的動畫卡片可適應不同的高度和寬度。

卡片布局最適合用在信息很多卻又希望能被瀏覽的頁面。Google Now就使用卡片布局來為它的app做廣告。

你可以將卡片式布局看成是很多動態的網格，網格中只呈現最簡明的重要內容，這些內容條目組合在一起就形成了基本的列表。在線雜志就是完美的例子，如UGSMAG和The Next Web，就使用了卡片布局來展示其最新懂得帖子和內容。

4.自定義的解說視頻

形狀各異的組織都趨向於自定義解說視頻。使用動畫，例如Crazy Egg來製作這些視頻。即使如此，不同的視頻依賴於真正的鏡頭，例如Instagram Direct。

解說視頻的目的是說明產品或服務是如何工作的。訪問者有可能在瀏覽了一系列功能之後，依然不知道如何操作這個產品。而可視化的視頻則可以在短短幾分鍾的時間內一一說明功能，並涵蓋所有重要的內容。最關鍵的是人們喜歡觀看視頻而不怎麼喜歡閱讀文章。他們可以很容易地從視頻中明白你想表達什麼。

如果你想自己嘗試做一個自定義的解說視頻，那麼可以閱讀Udemy課程。這是一個側重登陸頁面設計視頻講解的深入學習課程。Udemy課程不僅僅說明了如何使用動畫視頻軟體，它也會告訴你如何使用視頻來吸引和隱蔽訪問者。

5.實況產品預覽

登陸頁面設計因網路速度的提高和瀏覽器功能的擴大，而發生了令人難以置信的改變。我注意到一個重要趨勢是，就是主頁或自定義登陸頁面增加了實時產品預覽。

以Slack的產品頁面作為例子。一個視頻演示和矢量圖形覆蓋了它的界面。這些產品預覽是讓潛在用戶第一眼就知道產品是如何操作的。

不只是消息，所有的文件，圖像，PDF文件，文檔和電子表格都可以放到Slack，和你想要分享的任何人共享。你可以添加註釋，標注星號供以後參考，這一切完全都是可以搜索的。

6.自動化任務運行器

前端開發的世界，隨著一堆針對網站創新而出現的新的最佳實踐，發生了巨大的改變。任務運行器/構建系統，例如Gulp和Grunt，替代了以前事先需要大量手動去完成的任務，越來越被我們廣泛使用。

自動化是快速周轉和高質量代碼的命脈。眾所周知，機器不會出錯，所以自動化程度越高，產生的問題越少。

這些工具基本上運行的是JS代碼，可以自動化實現部分工作流程——無論是自定義的JS代碼還是其他人寫的腳本。

7.用於設計的協作工具

即時消息和群聊已經出現了十多年。人們喜歡這個功能，並在今後他們可以繼續使用此功能。然而，這些資源在傳統上依賴於純文本附加文件的一些功能。

但是，我們在討論的是未來，未來一個新出現的趨勢是，在聊天應用程序中共享實時設計文檔。Notable就是其中一個例子，創新和注釋可以被分層在文檔的頂部。通過快速迭代它提供了更好的界面。從草圖到完全編碼的網頁，Notable讓團隊在設計過程的每一步得到更快的反饋。

Slack是當下最流行的聊天應用程序，支持許多類似的功能。

8.響應式前端框架

前端框架，例如Bootstrap，已經存在了相當長的時間，並將繼續展現其價值。響應式設計，受其成為框架方式的制約，可以成為前端代碼，而不是僅僅只是後端（Django，Laravel，等等）。

邁入2016年，我認為我們會閱讀到更多關於響應式前端框架以及它們在web項目中的價值的內容。並且在接下來的一年時間里，可能會發布很多前端框架的app，比現在的功能更強大。許多設備正在急切等待Foundation 6以及Bootstrap4公共V1版本的發布。

9.更關注UX設計

UX設計是通過改進可用性，可訪問性，以及用戶和產品之間互動產生的愉悅感來加強用戶滿意度的過程。

用戶體驗設計領域將隨著更多設計師和開發者的關注而繼續快速增長。UI設計是UX設計的一部分，但不是最終目標。UI是手段而不是目的，最終目的是提供一個夢幻般的用戶體驗。

目前，針對這些目的的資源有UX Stack Exchange和free UX ebooks。如果你還沒有涉獵用戶體驗，那麼現在是學習和了解UX原則如何應用到所有數字界面窗口的最佳時機。

10.支持觸摸的網站功能

智能手機瀏覽器，支持所有站點的觸摸功能，以保持reverse similarity。我們也可以看到更多的插件和自定義元素添至站點，關注觸摸事件的特定對象。

我們希望網站可以實現觸摸功能。而且這種網站也會因為其獨特的功能而提升訪問量。如Photoswipe和Dragend.js等內置的插件可以處理觸摸屏上的滑動和點擊手勢。web開發人員不僅要會構建響應式網站，還得能構建具備觸摸功能的網站。

這些插件提供了觸摸功能，但是網站還需要具備其他的手勢功能。如果你多搜索一下的話，你會發現一些真正令人印象深刻的，針對web的，內置的，純粹依靠觸摸事件的功能。

這些就是3.0時代的Web設計趨勢，它們的到來和發展將使得構建網站變得更容易和更簡單。

㈢ access相同課程只顯示一次

當多個用戶同時訪問一個網站或應用程序時，可能會出現多次顯示相同課程的情況。為了解決這個問題，可以採用以下幾種方法：
1. 資料庫去重
在資料庫中，可以對課程名稱和其他相關信息進行去重處理。這樣，當多個用戶訪問同一課程時，系統只會顯示一次。這種方法可以有效地減少數據冗餘，提高系統運行效率。
2. 緩存機制
可以使用緩存機制來減少重復數據的顯示。當用戶訪問一個頁面時，系統會將相關數據存儲在緩存中，以便下一次訪問時可以直接從緩存中獲取答賣數據，而不需要再次從伺服器上獲取。這樣就可以有效地減少伺服器負載，提高系統性能。
3. 全局變數
可以使用全局變數來薯游記錄已經顯示過的課程。當用戶訪問頁面時，系統會檢查全局變數中是否已經顯示過該課程，如果已經顯示過，就不會再次顯示。這種方法適用於小型應用程序，因為全局變數可能會佔用過多的內存空間。
4. 前端去重
在前端頁面中，可以使用JavaScript等技術來對數據進行去重。當數據載入到頁面上時，系統會檢查是否已經顯示過該課程，如果已經顯示過，就不會再次顯示。這種方法可以減少伺服器負載，清手逗提高頁面載入速度。
綜上所述，通過資料庫去重、緩存機制、全局變數和前端去重等方法，可以有效地解決多個用戶同時訪問同一課程時重復顯示的問題。這些方法不僅可以提高系統性能，還可以提升用戶體驗。

㈣ 數組去重方法 js

js數組去重的方法可以利用數組排序，通過相鄰元素比較,去除型世重復元素。

去重，一般都是在面試的時候才會碰到，一般是要求手寫數組去重方法的代碼。在真實的項目中碰到的數組去重，一般都是後台去處理，很少讓前端處理卜穗肢數組去重。雖然日常項目用到的概率比較低，但還是需要了解一下，以防面試的時候可能回被問到。

利用for嵌套for，然後splice去重（ES5中最常用）。雙層循環，外層循環元素，內層循環時比較值。值相同時，則刪去這個值。想快速學習更多常用的ES6語法，可以看一些相關的文章如《學習ES6筆記──工作中常用到的ES6語法》。

js數組去重的幾種方法

利用數組排序，通過相鄰元素比較，去除重復元素，可以嚴格匹配以區分數據類型。

借用對象屬性方法，將數組中的元素添加為對象的屬性。族慎遍歷數組元素的時候查詢對象是否已經有該屬性，如果有則不重復添加。

借用正則匹配的方法，將新數組轉換為字元串。原數組中的每個元素與在字元串中查找，如果匹配到，則不添加。

使用js新特性的Map對象，使用鍵值對的方式修改第二種方法。或者利用Set對象，自動過濾掉重復項，而且可以判斷數據類型。

㈤ js怎麼實現<select>下拉框去重

這個應該是從數據源里取出來, 然後插入到前端頁面中的, 去重應該從它取數據的位置去操作, 這個要看項目使用什麼框架寫的
如果後台的代碼不能修改, 那你可以用js在前台頁面載入完以後進行去重

㈥ 前端數組排序

第一種：簡單的sort排序
2.冒泡排序
3.選擇排序
4.數組sort加splice截取去重(推薦)
5.數組splice截取方法去重
6.數組indexOf方法去重(推薦)

㈦ 前端演算法詳解——二分法(查找、排序、去重、最小值)

需求：針對一有序數組查找某一個姿納數是否在該數組中。
分析與思路： 二分法，一分為二。將數組分為兩個進行查找，若該數小於中間值，則向左查找，否則向右查找。然後遞歸再次查找（這樣每一次都是排除掉一半的不可能）

需求：將無序數組進行排序。
分析與思路： 將原始數組一分為二個數組（left、right），再講這兩個數組利用遞歸再次進行拆分...最後再將左右兩個數組進行排氏燃序。

分析與思路：殲冊虛同理將數組一分為二，左右分別去重，在一起去重

㈧ 如何高效實現批量插入數據，並去重

c#，sqlserver。寫一下我將前端獲取到的緩存數據批量插入資料庫的表。
在sqlserver資料庫下，展開（可編程性）-->（類型）-->（用戶自定義表類型）。建一個自定義表類型，表類型結構即是前端傳過來的表格數據結構。例如：
CREATE TYPE [dbo].[DT_SAP_ASN] AS TABLE(
[GUID] [nvarchar](50) NULL,
[VBELN_SIP] [nvarchar](30) NULL,
[POSNR_SIP] [nvarchar](30) NULL
)
GO
然後再寫個存儲，用於調用此存儲批量將前端傳入的datatable緩存數據批量插入資料庫的某個表。例如：
CREATE PROC [dbo].[SP_EDI_SAP_ASN]
(
@DT_SAP_ASN DT_SAP_ASN READONLY --輸入參數，剛剛自定義的表類型
)
AS
BEGIN
SET NOCOUNT OFF
INSERT INTO dbo.EDI_ASN_Log
( ID ,
GUID ,
VBELN_SIP ,
POSNR_SIP ,
)
SELECT NEWID() ,
GUID ,
VBELN_SIP ,
POSNR_SIP
FROM @DT_SAP_ASN
SET NOCOUNT ON
END
當然，去重的話在inset那邊select表#DT_SAP_ASN distinct一下即可

㈨ 前端常用的一些演算法

/*去重*/

function delRepeat(arr){

var newArray=new Array();

var len=arr.length;

for(var i=0;i

for(var j=i+1;j

{

if(arr[i]==arr[j])

{

++i;

}

}

newArray.push(arr[i]);

}

return newArray;

}

var arr=new Array("red","red","1","5","2");

alert(delRepeat(arr));

/*二分法*/

又稱為折半查找演算法，但是有缺陷就是要求數字是預先排序好的

function binary(items,value){

var startIndex=0,

stopIndex=items.length-1,

midlleIndex=(startIndex+stopIndex)>>>1;

while(items[middleIndex]!=value && startIndex

if(items[middleIndex]>value){

stopIndex=middleIndex-1;

}else{

startIndex=middleIndex+1;

}

middleIndex=(startIndex+stopIndex)>>>1;

}

return items[middleIndex]!=value ? false:true;

}

/*十六進制顏色值的隨機生成*/

function randomColor(){

var arrHex=["0","2","3","4","5","6","7","8","9","a","b","c","d"],

strHex="#",

index;

for(var i=0;i<6;i++){

index=Math.round(Math.random()*15);

strHex+=arrHex[index];

}

return strHex;

}

/*一個求字元串長度的方法*/

function GetBytes(str){

var len=str.length,

bytes=len;

for(var i=0;i

if(str.CharCodeAt>255){

bytes++;

}

}

return bytes;

}

/*插入排序*/

所謂的插入排序，就是將序列中的第一個元素看成一個有序的子序列，然後不段向後比較交換比較交換。

function insertSort(arr){

var key;

for(var j = 1; j < arr.length ; j++){

//排好序的

var i = j - 1;

key = arr[j];

while(i >= 0 && arr[i] > key){

arr[i + 1] = arr[i];

i --;

}

arr[i + 1] = key;

}

return arr;

}

/*希爾排序*/

希爾排序 ，也稱 遞減增量排序演算法

其實說到底也是插入排序的變種

function shellSort(array){

var stepArr = [1750, 701, 301, 132, 57, 23, 10, 4, 1]; // reverse()在維基上看到這個最優的步長較小數組

var i = 0;

var stepArrLength = stepArr.length;

var len = array.length;

var len2 =  parseInt(len/2);

for(;i < stepArrLength; i++){

if(stepArr[i] > len2){

continue;

}

stepSort(stepArr[i]);

}

//排序一個步長

function stepSort(step){

//console.log(step)使用的步長統計

var i = 0, j = 0, f, tem, key;

var stepLen = len%step > 0 ?  parseInt(len/step) + 1 : len/step;

for(;i < step; i++){//依次循環列

for(j=1;/*j < stepLen && */step * j + i < len; j++){//依次循環每列的每行

tem = f = step * j + i;

key = array[f];

while((tem-=step) >= 0){//依次向上查找

if(array[tem] > key){

array[tem+step] = array[tem];

}else{

break;

}

}

array[tem + step ] = key;

}

}

}

return array;

}

/*快速排序*/

快速排序演算法就系對冒泡排序的一種改進，採用的就是演算法理論中的分治遞歸的思想。

具體做法：通過一趟排序將待排序的紀錄分割成兩部分，其中一部分的紀錄值比另外一部分的紀錄值要小，就可以繼續分別對這兩部分紀錄進行排序；不段的遞歸實施上面兩個操作，從而實現紀錄值的排序。

function sort(arr){

return quickSort(arr,0,arr.length-1);

function quickSort(arr,l,r){

if(l

var mid=arr[parseInt((l+r)/2)],i=l-1,j=r+1;

while(true){

//大的放到右邊，小的放到左邊, i與j均為游標

while(arr[++i]

while(arr[--j]>mid);

if(i>=j)break;//判斷條件

var temp = arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

quickSort(arr,l,i-1);

quickSort(arr,j+1,r);

}

return arr;

}

}

function main(){

var list=new Array(49,38,65,97,76,13,27);

document.write(sort(list).valueOf());

}

main();

/*冒泡法*/

function bullSort(array){

var temp;

for(var i=0;i

for(var j=array.length-1;j>i;j--){

if(array[j]

temp = array[j];

array[j]=array[j-1];

array[j-1]=temp;

}

}

}

return array;

}

/*js遞歸實現方案*/

遞歸函數是在一個函數通過調用自身的情況下去解決的：

方式如下：

function factorial(num){

if(num<=1){

return 1;

}else{

return num*factorial(num-1);

}

}

但是這在js裡面可能會出現錯誤：

var anotherFactorial = factorial;

factorial=null;

alert(anoterFactorial(4));

因為在調用anoterFactorial時內部的factorial已經不存在了。

解決方法是通過arguments.callee來解決。

如下：

function factorial(num){

if(num<=1){

return 1;

}else{

return num*arguments.callee(num-1);

}

var anotherFactorial = factorial;

factorial = null;

alert(anotherFactorial(4));

成功！！！！

}

/**js模擬多線程**/

if (Array.prototype.shift==null)

Array.prototype.shift = function (){

var rs = this[0];

for (var i=1;i

this.length=this.length-1

return rs;

}

if (Array.prototype.push==null)

Array.prototype.push = function (){

for (var i=0;i

return this.length;

}

var commandList = [];

var nAction = 0;//控制每次運行多少個動作

var functionConstructor = function(){}.constructor;

function executeCommands(){

for (var i=0;i

if (commandList.length>0){

var command = commandList.shift();

if (command.constructor == functionConstructor)

if (command.scheleTime == null || new Date()-command.scheleTime>0)

command();

else

commandList.push(command);

}

}

function startNewTask(){

var resultTemp = document.getElementById("sampleResult").cloneNode(true);

with (resultTemp){

id="";style.display="block";style.color=(Math.floor(Math.random()* (1<<23)).toString(16)+"00000").substring(0,6);

}

document.body.insertBefore(resultTemp,document.body.lastChild);

commandList.push(function(){simThread(resultTemp,1);});

nAction++;

}

function  simThread(temp,n){

if (temp.stop) n--;

else temp.innerHTML = temp.innerHTML - (-n);

if (n<1000)

commandList.push(function(){simThread(temp,++n)});

else{

var command = function(){document.body.removeChild(temp);;nAction--;};

command.scheleTime = new Date()-(-2000);

commandList.push(command);

}

}

window.onload = function(){setInterval("executeCommands()",1);}

/

/*選擇法排序*/

選擇法主要有三種：

《1》簡單的選擇排序：簡單的前後交互。

/*簡單選擇法排序*/

其實基本的思想就是從待排序的數組中選擇最小或者最大的，放在起始位置，然後從剩下的數組中選擇最小或者最大的排在這公司數的後面。

function selectionSort(data)

{

var i, j, min, temp , count=data.length;

for(i = 0; i < count - 1; i++) {

/* find the minimum */

min = i;

for (j = i+1; j < count; j++)

{    if (data[j] < data[min])

{ min = j;}

}

/* swap data[i] and data[min] */

temp = data[i];

data[i] = data[min];

data[min] = temp;

}

return data;

}

《2》樹型排序：又稱錦標賽排序，首先對n個元素進行兩兩比較，然後在其中[n/2]個較小者再進行兩兩比較如此重復直至選出最小的關鍵字的紀錄為止。（可用完全二差樹表示）。缺點：輔助空間需求過大，和「最大值」進行多餘比較

《3》堆排序：（不適用於紀錄數較少的文件）

堆排序演算法的過程如下:

1)得到當前序列的最小(大)的元素

2)把這個元素和最後一個元素進行交換,這樣當前的最小(大)的元素就放在了序列的最後,而原先的最後一個元素放到了序列的最前面

3)的交換可能會破壞堆序列的性質(注意此時的序列是除去已經放在最後面的元素),因此需要對序列進行調整,使之滿足於上面堆的性質.

重復上面的過程,直到序列調整完畢為止.

js實現：

/**

*堆排序

* @param items數組

* @return排序後的數組

*/

function heapSort(items)

{

items = array2heap(items); //將數組轉化為堆

for(var i = items.length - 1; i >= 0; i--)

{

items = swap(items, 0, i); //將根和位置i的數據交換(用於將最大值放在最後面)

items = moveDown(items, 0, i - 1); //數據交換後恢復堆的屬性

}

return items;

}

/**

*將數組轉換為堆

* @param items數組

* @return堆

*/

function array2heap(items)

{

for(var i = Math.ceil(items.length / 2) - 1; i >= 0; i--)

{

items = moveDown(items, i, items.length - 1); //轉換為堆屬性

}

return items;

}

/**

*轉換為堆

* @param items數組

* @param first第一個元素

* @param last最後一個元素

* @return堆

*/

function moveDown(items, first, last)

{

var largest = 2 * first + 1;

while(largest <= last)

{

if(largest < last && items[largest] < items[largest + 1])

{

largest++;

}

if(items[first] < items[largest])

{

items = swap(items, first, largest); //交換數據

first = largest;   //往下移

largest = 2 * first + 1;

}

else

{

largest = last + 1; //跳出循環

}

}

return items;

}

/**

*交換數據

* @param items數組

* @param index1索引1

* @param index2索引2

* @return數據交換後的數組

*/

function swap(items, index1, index2)

{

var tmp = items[index1];

items[index1] = items[index2];

items[index2] = tmp;

return items;

}

var a = [345,44,6,454,10,154,3,12,11,4,78,9,0,47,88,9453,4,65,1,5];

document.write(heapSort(a));

所謂歸並就是將兩個或者兩個以上的有序表合成一個新的有序表。

遞歸形式的演算法在形式上較為簡潔但實用性較差，與快速排序和堆排序相比，歸並排序的最大特點是，它是一種穩定的排序方法。

js實現歸並：

function MemeryArray(Arr,n, Brr, m)

{      var i, j, k;

var Crr=new Array();

i = j = k = 0;

while (i < n && j < m)

{

if (Arr[i] < Brr[j])

Crr[k++] = Arr[i++];

else

Crr[k++] = Brr[j++];

}

while (i < n)

Crr[k++] = Arr[i++];

while (j < m)

Crr[k++] = Brr[j++];

return Crr;

}

var Arr=new Array(45,36,89,75,65);

var Brr=new Array(48,76,59,49,25);

alert(MemeryArray(Arr , Arr.length , Brr , Brr.length));

歸並排序待續，先睡了：

歸並排序：

//將有二個有序數列a[first...mid]和a[mid...last]合並。

function mergearray(Arr,first,mid,last,tempArr)

{

var i = first, j = mid + 1;

var m = mid,   n = last;

var k = 0;

while (i <= m && j <= n)

{

if (Arr[i] < Arr[j])

tempArr[k++] = Arr[i++];

else

tempArr[k++] = Arr[j++];

}

while (i <= m)

tempArr[k++] = Arr[i++];

while (j <= n)

tempArr[k++] = Arr[j++];

for (i = 0; i < k; i++)

Arr[first + i] = tempArr[i];

}

function mergesort(Arr,first,last)

{

var tempArr=new Array();

if (first < last)

{

var mid = (first + last)>>>1;

mergesort(Arr, first, mid, tempArr);    //左邊有序

mergesort(Arr, mid + 1, last, tempArr);  //右邊有序

mergearray(Arr, first, mid, last, tempArr);  //再將二個有序數列合並

}

return  Arr;

}

var Arr=new Array(1,65,45,98,56,78);

alert(mergesort(Arr,0,Arr.length-1));

/*比較兩個字元串的相似性－Levenshtein演算法簡介*/

問題與描述：

近似字元串匹配問題

說明：設給定樣本，對於任意文本串，樣本P在文本T中的K-近似匹配（K-approximate match）是指P在T中包含最多K個差異的匹配，這里的差別指：

（1）修改：P與T中對應的字元不同

（2）刪除：T中含有一個未出現在P中的字元

（3）插入：T中不包含出現在P中的一個字元

（也就是編輯距離問題）

例如：

T: a p r o x i o m a l l y

P: a p p r o x i m a t l y

經過1：插入2：刪除3：修改

那麼就是一個3-近似問題

事實上，兩個字元串可能有不得出不同的差別數量，所以K-近似匹配要求：

（1）差別數最多為K個

（2）差別數為所有匹配方式下最少的稱為編輯距離

（字元串T到P最少的差別數稱為T和P的編輯距離）

試驗要求：

（1）利用動態規劃方法給出兩個字元串編輯距離的演算法

（2）分析復雜度

（3）考慮其它方法

Levenshtein Distance來文史特距離

goodzzp

LD也叫edit distance，它用來表示2個字元串的相似度，不同於Hamming Distance，它可以用來比較2個長度不同的字元串。LD定義為需要最少多少步基本操作才能讓2個字元串相等，基本操作包含3個：

1，插入；

2，刪除；

3，替換；

比如，kiteen和sitting之間的距離可以這么計算：

1，kitten – > sitten,替換k為s；

2，sitten – > sittin,替換e為i;

3，sittin – > sitting,增加g；

所以，其LD為3；

計算LD的演算法表示為：

int LevenshteinDistance(char str1[1..lenStr1], char str2[1..lenStr2])

// d is a table with lenStr1+1 rows and lenStr2+1 columns

declare int d[0..lenStr1, 0..lenStr2]

// i and j are used to iterate over str1 and str2

declare int i, j, cost

for i from 0 to lenStr1

d[i, 0] := i

for j from 0 to lenStr2

d[0, j] := j

for i from 1 to lenStr1

for j from 1 to lenStr2

if str1[i] = str2[j] then cost := 0

else cost := 1

d[i, j] := minimum(

d[i-1, j ] + 1,// deletion

d[i , j-1] + 1,// insertion

d[i-1, j-1] + cost// substitution

)

return d[lenStr1, lenStr2]；

這個演算法其實就是一個矩陣的計算：

k i t t e n

0 1 2 3 4 5 6

s 1 1 2 3 4 5 6

i 2 2 1 2 3 4 5

t 3 3 2 1 2 3 4

t 4 4 3 2 1 2 3

i 5 5 4 3 2 2 3

n 6 6 5 4 3 3 2

g 7 7 6 5 4 4 3

首先給定第一行和第一列，然後，每個值d[i,j]這樣計算：d[i,j] = min(d[i-1,j]+ 1,d[i,j-1] +1,d[i-1,j-1]+(str1[i] == str2[j]?0:1));

最後一行，最後一列的那個值就是LD的結果。

LD(str1,str2) <= max(str1.len,str2.len)；

有人提出了Levenshtein automaton（Levenshtein自動機）來計算和某個字元串距離小於某個值的集合。這樣能夠加快近似字元串的計算過程。見文獻：Klaus U. Schulz, Stoyan Mihov, Fast String Correction with Levenshtein-Automata. International Journal of Document Analysis and Recognition, 5(1):67--85, 2002.

A Guided Tour to Approximate String Matching GONZALONAVARRO

這篇文章裡面對這個方面（字元串相似）進行了很多描述。其中，包含了動態規劃法計算Edit distance的方法。

js實現：

//求兩個字元串的相似度,返回差別字元數,Levenshtein Distance演算法實現

function Levenshtein_Distance(s,t){

var n=s.length;// length of s

var m=t.length;// length of t

var d=[];// matrix

var i;// iterates through s

var j;// iterates through t

var s_i;// ith character of s

var t_j;// jth character of t

var cost;// cost

// Step 1

if (n == 0) return m;

if (m == 0) return n;

// Step 2

for (i = 0; i <= n; i++) {

d[i]=[];

d[i][0] = i;

}

for (j = 0; j <= m; j++) {

d[0][j] = j;

}

// Step 3

for (i = 1; i <= n; i++) {

s_i = s.charAt (i - 1);

// Step 4

for (j = 1; j <= m; j++) {

t_j = t.charAt (j - 1);

// Step 5

if (s_i == t_j) {

cost = 0;

}else{

cost = 1;

}

// Step 6

d[i][j] = Minimum (d[i-1][j]+1, d[i][j-1]+1, d[i-1][j-1] + cost);

}

}

// Step 7

return d[n][m];

}

//求兩個字元串的相似度,返回相似度百分比

function Levenshtein_Distance_Percent(s,t){

var l=s.length>t.length?s.length:t.length;

var d=Levenshtein_Distance(s,t);

return (1-d/l).toFixed(4);

}

//求三個數字中的最小值

function Minimum(a,b,c){

return a

}

var str1="ddsddf",str2="xdsfsx";

alert(Levenshtein_Distance_Percent(str1,str2));

㈩ Web前端工程師應該知道的JavaScript使用小技巧

今天小編要跟大家分享的文章是關於Web前端工程師應該知道的JavaScript使用小技巧。任何一門技術在實際中都會有一些屬於自己的小技巧。同樣的，在使用JavaScript時也有一些自己的小技巧，只不過很多時候有可能容易被大家忽略。而在互聯網上，時不時的有很多同行朋友會總結(或收集)一些這方面的小技巧。

今天在這篇文章中，小編會整理一些大家熟悉或不熟悉的有關於JavaScript的小技巧，希望能夠對大家的學習和工作有所幫助。


一、數組


先來看使用數組中常用的一些小技巧。


01、數組去重


ES6提供了幾種簡潔的數組去重的方法，但該方法並不適合處理非基本類型的數組。對於基本類型的數組去重，可以使用...new
Set()來過濾掉數組中重復的值，創建一個只有唯一值的新數組。constarray=[1,1,2,3,5,5,1]

constuniqueArray=[...newSet(array)];

console.log(uniqueArray);

>Result:(4)[1,2,3,5]

這是ES6中的新特性，在ES6之前，要實現同樣的效果，我們需要使用更多的代碼。該技巧適用於包含基本類型的數組：undefined、null、boolean、string和number。如果數組中包含了一個object,function或其他數組，那就需要使用另一種方法。


除了上面的方法之外，還可以使用Array.from(newSet())來實現：constarray=[1,1,2,3,5,5,1]

Array.from(newSet(array))

>Result:(4)[1,2,3,5]

另外，還可以使用Array的.filter及indexOf()來實現：

constarray=[1,1,2,3,5,5,1]

array.filter((arr,index)=>array.indexOf(arr)===index)

>Result:(4)[1,2,3,5]

注意，indexOf()方法將返回數組中第一個出現的數組項。這就是為什麼我們可以在每次迭代中將indexOf()方法返回的索引與當索索引進行比較，以確定當前項是否重復。


02、確保數組的長度


在處理網格結構時，如果原始數據每行的長度不相等，就需要重新創建該數據。為轎並了確保每行的數據長度相等，可以使用Array.fill來處理：letarray=Array(5).fill('');

console.log(array);

>Result:(5)["","","","",""]

03、數組映射


不使用Array.map來映射數組值的方法。constarray=[

{

ame:'大漠',

email:'w3cplus@#'

},

{

ame:'Airen',

email:'airen@#'

}

]

constname=Array.from(array,({name})=>name)

>Result:(2)["大漠","Airen"]

04、數組截斷


如果你想從數組末尾刪除值(刪除數組中的最後一項)，有比使用飢沖splice()更快的替代方法。


例如，你知道原始數組的大小，可以重新定義數組的length屬性的值，就可以實現從數組末尾刪除值：

letarray=[0,1,2,3,4,5,6,7,8,9]

console.log(array.length)

>Result:10

array.length=4

console.log(array)

>Result:(4)[0,1,2,3]

這是一個特別簡潔的解決方案。但是，slice()方法運行更閉肢跡快，性能更好：

letarray=[0,1,2,3,4,5,6,7,8,9];

array=array.slice(0,4);

console.log(array);

>Result:[0,1,2,3]

05、過濾掉數組中的falsy值

如果你想過濾數組中的falsy值，比如0、undefined、null、false，那麼可以通過map和filter方法實現：

constarray=[0,1,Ɔ',Ƈ','大漠','#',undefined,true,false,null,'undefined','null',NaN,'NaN',Ƈ'+0]

array.map(item=>{

returnitem

}).filter(Boolean)

>Result:(10)[1,"0","1","大漠","#",true,"undefined","null","NaN","10"]

06、獲取數組的最後一項


數組的slice()取值為正值時，從數組的開始處截取數組的項，如果取值為負整數時，可以從數組末屬開始獲取數組項。

letarray=[1,2,3,4,5,6,7]

constfirstArrayVal=array.slice(0,1)

>Result:[1]

constlastArrayVal=array.slice(-1)

>Result:[7]

console.log(array.slice(1))

>Result:(6)[2,3,4,5,6,7]

console.log(array.slice(array.length))

>Result:[]

正如上面示例所示，使用array.slice(-1)獲取數組的最後一項，除此之外還可以使用下面的方式來獲取數組的最後一項：

console.log(array.slice(array.length-1))

>Result:[7]

07、過濾並排序字元串列表


你可能有一個很多名字組成的列表，需要過濾掉重復的名字並按字母表將其排序。


在我們的例子里准備用不同版本語言的JavaScript
保留字的列表，但是你能發現，有很多重復的關鍵字而且它們並沒有按字母表順序排列。所以這是一個完美的字元串列表(數組)來測試我們的JavaScript小知識。

varkeywords=['do','if','in','for','new','try','var','case','else','enum','null','this','true','void','with','break','catch','class','const','false','super','throw','while','delete','export','import','return','switch','typeof','default','extends','finally','continue','debugger','function','do','if','in','for','int','new','try','var','byte','case','char','else','enum','goto','long','null','this','true','void','with','break','catch','class','const','false','final','float','short','super','throw','while','delete','double','export','import','native','public','return','static','switch','throws','typeof','boolean','default','extends','finally','package','private','abstract','continue','debugger','function','volatile','interface','protected','transient','implements','instanceof','synchronized','do','if','in','for','let','new','try','var','case','else','enum','eval','null','this','true','void','with','break','catch','class','const','false','super','throw','while','yield','delete','export','import','public','return','static','switch','typeof','default','extends','finally','package','private','continue','debugger','function','arguments','interface','protected','implements','instanceof','do','if','in','for','let','new','try','var','case','else','enum','eval','null','this','true','void','with','await','break','catch','class','const','false','super','throw','while','yield','delete','export','import','public','return','static','switch','typeof','default','extends','finally','package','private','continue','debugger','function','arguments','interface','protected','implements','instanceof'];

因為我們不想改變我們的原始列表，所以我們准備用高階函數叫做filter，它將基於我們傳遞的回調方法返回一個新的過濾後的數組。回調方法將比較當前關鍵字在原始列表裡的索引和新列表中的索引，僅當索引匹配時將當前關鍵字push到新數組。


最後我們准備使用sort方法排序過濾後的列表，sort只接受一個比較方法作為參數，並返回按字母表排序後的列表。


在ES6下使用箭頭函數看起來更簡單:

=keywords

.filter((keyword,index)=>keywords.lastIndexOf(keyword)===index)

.sort((a,b)=>a
這是最後過濾和排序後的JavaScript保留字列表：

console.log(filteredAndSortedKeywords);

>Result:['abstract','arguments','await','boolean','break','byte','case','catch','char','class','const','continue','debugger','default','delete','do','double','else','enum','eval','export','extends','false','final','finally','float','for','function','goto','if','implements','import','in','instanceof','int','interface','let','long','native','new','null','package','private','protected','public','return','short','static','super','switch','synchronized','this','throw','throws','transient','true','try','typeof','var','void','volatile','while','with','yield']

08、清空數組


如果你定義了一個數組，然後你想清空它。通常，你會這樣做：

letarray=[1,2,3,4];

functionemptyArray(){

array=[];

}

emptyArray();

但是，這有一個效率更高的方法來清空數組。你可以這樣寫:

letarray=[1,2,3,4];

functionemptyArray(){

array.length=0;

}

emptyArray();

09、拍平多維數組


使用...運算符，將多維數組拍平：


10、從數組中獲取最大值和最小值


可以使用Math.max和Math.min取出數組中的最大小值和最小值：

constnumbers=[15,80,-9,90,-99]

constmaxInNumbers=Math.max.apply(Math,numbers)

constminInNumbers=Math.min.apply(Math,numbers)

console.log(maxInNumbers)

>Result:90

console.log(minInNumbers)

>Result:-99

另外還可以使用ES6的...運算符來完成：

constnumbers=[1,2,3,4];

Math.max(...numbers)

>Result:4

Math.min(...numbers)

>>Result:1

二、對象


在操作對象時也有一些小技巧。


01、使用...運算符合並對象或數組中的對象


同樣使用ES的...運算符可以替代人工操作，合並對象或者合並數組中的對象。

//合並對象

constobj1={

ame:'大漠',

url:'#'

}

constobj2={

ame:'airen',

age:30

}

constmergingObj={...obj1,...obj2}

>Result:{name:"airen",url:"#",age:30}

//合並數組中的對象

constarray=[

{

ame:'大漠',

email:'w3cplus@#'

},

{

ame:'Airen',

email:'airen@#'

}

]

constresult=array.rece((accumulator,item)=>{

return{

...accumulator,

[item.name]:item.email

}

},{})

>Result:{大漠:"w3cplus@#",Airen:"airen@#"}

02、有條件的添加對象屬性


不再需要根據一個條件創建兩個不同的對象，以使它具有特定的屬性。為此，使用...操作符是最簡單的。

constgetUser=(emailIncluded)=>{

return{

ame:'大漠',

blog:'w3cplus',

...emailIncluded&&{email:'w3cplus@#'}

}

}

constuser=getUser(true)

console.log(user)

>Result:{name:"大漠",blog:"w3cplus",email:"w3cplus@#"}

constuserWithoutEmail=getUser(false)

console.log(userWithoutEmail)

>Result:{name:"大漠",blog:"w3cplus"}

03、解構原始數據


你可以在使用數據的時候，把所有數據都放在一個對象中。同時想在這個數據對象中獲取自己想要的數據。


在這里可以使用ES6的Destructuring特性來實現。比如你想把下面這個obj中的數據分成兩個部分：

constobj={

ame:'大漠',

blog:'w3cplus',

email:'w3cplus@#',

joined:񟭓-06-19',

followers:45

}

letuser={},userDetails={}

({name:user.name,email:user.email,...userDetails}=obj)

>{name:"大漠",blog:"w3cplus",email:"w3cplus@#",joined:"2019-06-19",followers:45}

console.log(user)

>Result:{name:"大漠",email:"w3cplus@#"}

console.log(userDetails)

>Result:{blog:"w3cplus",joined:"2019-06-19",followers:45}

04、動態更改對象的key


在過去，我們首先必須聲明一個對象，然後在需要動態屬性名的情況下分配一個屬性。在以前，這是不可能以聲明的方式實現的。不過在ES6中，我們可以實現：

constdynamicKey='email'

letobj={

ame:'大漠',

blog:'w3cplus',

[dynamicKey]:'w3cplus@#'

}

console.log(obj)

>Result:{name:"大漠",blog:"w3cplus",email:"w3cplus@#"}

05、判斷對象的數據類型


使用Object.prototype.toString配合閉包來實現對象數據類型的判斷：

constisType=type=>target=>`[object${type}]`===Object.prototype.toString.call(target)

constisArray=isType('Array')([1,2,3])

console.log(isArray)

>Result:true

上面的代碼相當於：

functionisType(type){

returnfunction(target){

return`[object${type}]`===Object.prototype.toString.call(target)

}

}

isType('Array')([1,2,3])

>Result:true

或者：

constisType=type=>target=>`[object${type}]`===Object.prototype.toString.call(target)

constisString=isType('String')

constres=isString((Ƈ'))

console.log(res)

>Result:true

06、檢查某對象是否有某屬性


當你需要檢查某屬性是否存在於一個對象，你可能會這樣做：

varobj={

ame:'大漠'

}

if(obj.name){

console.l