沐鳴測速註冊_一組網頁邊欄過渡動畫【附源碼下載】

今天我們想與大家分享另一套過渡效果。這一次,我們將探討如何實現側邊欄的過渡動畫,就像我們已經在多級推出菜單中使用的。我們的想法是,以細微的過渡動畫显示一些隱藏的側邊欄,其餘的內容也是。通常側邊欄滑入,把其他內容推到一邊。這個可過程中可以加入很多微妙而奇特的效果,而今天這篇文章能夠給你一些啟示。

溫馨提示:為保證最佳的效果,請在 IE10+、Chrome、Firefox 和 Safari 等現代瀏覽器中瀏覽。

 

 

立即下載      在線演示

沐鳴平台_前端工程師和設計師必讀文章推薦【系列三十五】

這篇文章收集了一組前端開發相關文摘,分享提升網站用戶體驗的優秀 jQuery 插件,展示前沿的 HTML5 和 CSS3 技術應用,共享精美的設計素材和優秀的 Web 開發工具,希望這些精心整理的前端技術文章能夠幫助到您。

HTML5 & CSS3

  • Swiper – 經典的移動觸摸滑塊插件【免費】
  • Kickoff – 創造可擴展的,響應式的網站
  • 16種基於 CSS3 & SVG 的創意的彈窗效果
  • BookBlock – 效果非常真實的書本翻頁預覽
  • 很贊的效果!互動的頁面元素拖放着色實驗
  • SVG Drawing Animation – SVG 繪製動畫
  • Filter Effects – 使用 CSS3 濾鏡處理圖片
  • Space.js – HTML 驅動的頁面 3D 滾動效果
  • Primer – 支撐 GitHub 的 CSS 工具包和準則
  • 贊!15個來自 CodePen 的酷炫 CSS 動畫效果

JS 框架和工具

  • Electron – 創建跨平台的桌面客戶的應用程序
  • Lazyr.js – 延遲加載圖片(Lazy Loading)
  • Rainyday.js – 使用 JavaScript 實現雨滴效果
  • 6to5 – 讓你即刻體驗 ECMAScript 6 編程
  • Dom Animator – 提供 Dom 註釋動畫的 JS 庫
  • Awesomplete – 零依賴的簡單自動完成插件
  • T3 – 構建大型 Web 應用的 JavaScript 框架
  • Restive.js – 輕鬆讓網站變成響應式和自適應
  • BasicModal – 簡單易用的現代 Web App 彈窗
  • Mega Dropdown – 帶子分類的響應式下拉菜單

網站素材

  • EventRay UI Kit – Web & Mobile 的素材
  • 基於 Bootstrap 的響應式後台管理面板
  • 1001Freedownloads – 免費下載海量素材
  • 免費的 Photoshop Apple Watch 原型設計素材
  • 錯誤的藝術!20個創意的404錯誤頁面設計
  • 20個最新的照片 PS 技巧,提升攝影水平

實用工具

  • Pexels Videos – 可以免費商業使用的短視頻
  • Dropplets – 極簡的 Markdown 博客平台
  • Click Magick – 下一代點擊跟蹤和鏈接管理
  • Ratatype – 在線打字教程,提高打字速度
  • Slides – 在線製作效果精美的幻燈片(PPT)

同系列文章

  • Web 前端開發人員和設計師必讀文章推薦【系列一】
  • Web 前端開發人員和設計師必讀文章推薦【系列二】
  • Web 前端開發人員和設計師必讀文章推薦【系列三】
  • Web 前端開發人員和設計師必讀文章推薦【系列四】
  • Web 前端開發人員和設計師必讀文章推薦【系列五】
  • Web 前端開發人員和設計師必讀文章推薦【系列六】
  • Web 前端開發人員和設計師必讀文章推薦【系列七】
  • Web 前端開發人員和設計師必讀文章推薦【系列八】
  • Web 前端開發人員和設計師必讀文章推薦【系列九】
  • Web 前端開發人員和設計師必讀文章推薦【系列十】
  • Web 前端開發人員和設計師必讀文章推薦【系列十一】
  • Web 前端開發人員和設計師必讀文章推薦【系列十二】
  • Web 前端開發人員和設計師必讀文章推薦【系列十三】
  • Web 前端開發人員和設計師必讀文章推薦【系列十四】
  • Web 前端開發人員和設計師必讀文章推薦【系列十五】
  • Web 前端開發人員和設計師必讀文章推薦【系列十六】
  • Web 前端開發人員和設計師必讀文章推薦【系列十七】
  • Web 前端開發人員和設計師必讀文章推薦【系列十八】
  • Web 前端開發人員和設計師必讀文章推薦【系列十九】
  • Web 前端開發人員和設計師必讀文章推薦【系列二十】
  • Web 前端開發人員和設計師必讀文章推薦【系列二十一】
  • Web 前端開發人員和設計師必讀文章推薦【系列二十二】
  • Web 前端開發人員和設計師必讀文章推薦【系列二十三】
  • Web 前端開發人員和設計師必讀文章推薦【系列二十四】
  • Web 前端開發人員和設計師必讀文章推薦【系列二十五】
  • Web 前端開發人員和設計師必讀文章推薦【系列二十六】
  • Web 前端開發人員和設計師必讀文章推薦【系列二十七】
  • Web 前端開發人員和設計師必讀文章推薦【系列二十八】
  • Web 前端開發人員和設計師必讀文章推薦【系列二十九】
  • Web 前端開發人員和設計師必讀文章推薦【系列三十】
  • Web 前端開發人員和設計師必讀文章推薦【系列三十一】
  • Web 前端開發人員和設計師必讀文章推薦【系列三十二】
  • Web 前端開發人員和設計師必讀文章推薦【系列三十三】
  • Web 前端開發人員和設計師必讀文章推薦【系列三十四】

沐鳴:_Vue.js vs React vs Angular 深度對比

這個頁面無疑是最難編寫的,但我們認為它也是非常重要的。或許你曾遇到了一些問題並且已經用其他的框架解決了。你來這裏的目的是看看 Vue 是否有更好的解決方案。這也是我們在此想要回答的。

客觀來說,作為核心團隊成員,顯然我們會更偏愛 Vue,認為對於某些問題來講用 Vue 解決會更好。如果沒有這點信念,我們也就不會整天為此忙活了。但是在此,我們想盡可能地公平和準確地來描述一切。其他的框架也有顯著的優點,例如 React 龐大的生態系統,或者像是 Knockout 對瀏覽器的支持覆蓋到了 IE6。我們會嘗試着把這些內容全部列出來。

我們也希望得到的幫助,來使文檔保持最新狀態,因為 JavaScript 的世界進步的太快。如果你注意到一個不準確或似乎不太正確的地方,請提交問題讓我們知道。

React

React 和 Vue 有許多相似之處,它們都有:

  • 使用 Virtual DOM
  • 提供了響應式(Reactive)和組件化(Composable)的視圖組件。
  • 將注意力集中保持在核心庫,伴隨於此,有配套的路由和負責處理全局狀態管理的庫。

由於有着眾多的相似處,我們會用更多的時間在這一塊進行比較。這裏我們不只保證技術內容的準確性,同時也兼顧了平衡的考量。我們需要指出 React 比 Vue 更好的地方,像是他們的生態系統和豐富的自定義渲染器。

React社區為我們準確進行平衡的考量提供了非常积極地幫助,特別感謝來自 React 團隊的 Dan Abramov 。他非常慷慨的花費時間來貢獻專業知識,幫助我們完善這篇文檔,最後我們對最終結果都十分滿意。

性能簡介

到目前為止,針對現實情況的測試中,Vue 的性能是優於 React 的。如果你對此表示懷疑,請繼續閱讀。我們會解釋為什麼會這樣(並且會提供一個與 React 團隊共同約定的比較基準)。

渲染性能

在渲染用戶界面的時候,DOM 的操作成本是最高的,不幸的是沒有庫可以讓這些原始操作變得更快。
我們能做到的最好效果就是:

  1. Minimize the number of necessary DOM mutations. Both React and Vue use virtual DOM abstractions to accomplish this and both implementations work about equally well.
  2. Add as little overhead (pure JavaScript computations) as possible on top of those DOM manipulations. This is an area where Vue and React differ.

The JavaScript overhead is directly related to the mechanisms of computing the necessary DOM operations. Both Vue and React utilizes Virtual DOM to achieve that, but Vue’s Virtual DOM implementation (a fork of snabbdom) is much lighter-weight and thus introduces less overhead than React’s.

Vue 和 React 也提供功能性組件,這些組件因為都是沒有聲明,沒有實例化的,因此會花費更少的開銷。當這些都用於關鍵性能的場景時,Vue 將會更快。為了證明這點,我們建立了一個簡單的參照項目,它負責渲染 10,000 個列表項 100 次。我們鼓勵你基於此去嘗試運行一下。然而在實際上,由於瀏覽器和硬件的差異甚至 JavaScript 引擎的不同,結果都會相應有所不同。

如果你懶得去做,下面的數值是來自於一個 2014 年產的 MacBook Air 並在 Chrome 52 版本下運行所產生的。為了避免偶然性,每個參照項目都分別運行 20 次並取自最好的結果:

Vue React
Fastest 23ms 63ms
Median 42ms 81ms
Average 51ms 94ms
95th Perc. 73ms 164ms
Slowest 343ms 453ms

更新性能

In React, when a component’s state changes, it triggers the re-render of the entire component sub-tree, starting at that component as root.

To avoid unnecessary re-renders of child components, you need to implementshouldComponentUpdate everywhere and use immutable data structures. In Vue, a component’s dependencies are automatically tracked during its render, so the system knows precisely which components actually need to re-render.

這意味着,未經優化的 Vue 相比未經優化的 React 要快的多。由於 Vue 改進過渲染性能,甚至全面優化過的 React 通常也會慢於開箱即用的 Vue。

開發中

顯然,在生產環境中的性能是至關重要的,目前為止我們所具體討論的便是針對此環境。但開發過程中的表現也不容小視。不錯的是用 Vue 和 React 開發大多數應用的速度都是足夠快的。

然而,假如你要開發一個對性能要求比較高的數據可視化或者動畫的應用時,你需要了解到下面這點:在開發中,Vue 每秒最高處理 10 幀,而 React 每秒最高處理不到 1 幀。

Both Vue and React remain fast enough in development for most normal applications. However, when prototyping high frame-rate data visualizations or animations, we’ve seen cases of Vue handling 10 frames per second in development while React dropping to about 1 frame per second.

這是由於 React 有大量的檢查機制,這會讓它提供許多有用的警告和錯誤提示信息。我們同樣認為這些是很重要的,但是我們在實現這些檢查時,也更加密切地關注了性能方面。

HTML & CSS

在 React 中,它們都是 JavaScript 編寫的,聽起來這十分簡單和優雅。然而不幸的事實是,JavaScript 內的 HTML 和 CSS 會產生很多痛點。在 Vue 中我們採用 Web 技術並在其上進行擴展。接下來將通過一些實例向你展示這意味的是什麼。

JSX vs Templates

在 React 中,所有的組件的渲染功能都依靠 JSX。JSX 是使用 XML 語法編寫 Javascript 的一種語法糖。這有一個通過React社區審核過的例子:

render () { let { items } = this.props let children if ( items.length > 0 ) { children = ( <ul> {items.map( item => <li key={item.id}>{item.name} </li> )} </ul> ) } else { children = <p>No items found.</p> } return ( <div className = ‘list-container’> {children} </div> ) }

JSX 的渲染功能有下面這些優勢:

  • 你可以使用完整的編程語言 JavaScript 功能來構建你的視圖頁面。
  • 工具對 JSX 的支持相比於現有可用的其他 Vue 模板還是比較先進的(比如,linting、類型檢查、編輯器的自動完成)。

在 Vue 中,由於有時需要用這些功能,我們也提供了渲染功能 並且支持了 JSX。然而,對於大多數組件來說,渲染功能是不推薦使用了。

在這方面,我們提供的是更簡單的模板:

<template> <div class=“list-container”> <ul v-if=“items.length”> <li v-for=“item in items”> {{ item.name }} </li> </ul> <p v-else>No items found. </p> </div> </template>

優點如下:

  • 在寫模板的過程中,樣式風格已定並涉及更少的功能實現。
  • 模板總是會被聲明的。
  • 模板中任何 HTML 語法都是有效的。
  • 閱讀起來更貼合英語(比如,for each item in items)。
  • 不需要高級版本的 JavaScript 語法,來增加可讀性。

這樣,不僅開發人員更容易編寫代碼,設計人員和開發人員也可以更容易的分析代碼和貢獻代碼。

這還沒有結束。Vue 擁抱 HTML,而不是用 JavaScript 去重塑它。在模板內,Vue 也允許你用預處理器比如 Pug(原名 Jade)。

div.list-container ul(v-if=”items.length”) li(v-for=”item in items”) {{ item.name }} p(v-else) No items found.

CSS 的組件作用域

除非你把組件分佈在多個文件上(例如 CSS Modules),要不在 React 中作用域內的 CSS 就會產生警告。非常簡單的 CSS 還可以工作,但是稍微複雜點的,比如懸停狀態、媒體查詢、偽類選擇符等要麼通過沉重的依賴來重做要麼就直接不能用。

而 Vue 可以讓你在每個單文件組件中完全訪問 CSS。

<style scoped> @ media (min-width: 250px) { .list-container :hover { background: orange; } } </style>

這個可選 scoped 屬性會自動添加一個唯一的屬性(比如 data-v-21e5b78)為組件內 CSS 指定作用域,編譯的時候 .list-container:hover 會被編譯成類似.list-container[data-v-21e5b78]:hover

最後,就像 HTML 一樣,你可以選擇自己偏愛的 CSS 預處理器編寫 CSS。這可以讓你圍繞設計為中心展開工作,而不是引入專門的庫來增加你應用的體積和複雜度。

規模

向上擴展

Vue 和 React 都提供了強大的路由來應對大型應用。React 社區在狀態管理方面非常有創新精神(比如Flux、Redux),而這些狀態管理模式甚至 Redux 本身也可以非常容易的集成在 Vue 應用中。實際上,Vue 更進一步地採用了這種模式(Vuex),更加深入集成 Vue 的狀態管理解決方案 Vuex 相信能為你帶來更好的開發體驗。

兩者另一個重要差異是,Vue 的路由庫和狀態管理庫都是由官方維護支持且與核心庫同步更新的。React 則是選擇把這些問題交給社區維護,因此創建了一個更分散的生態系統。但相對的,React 的生態系統相比 Vue 更加繁榮。

最後,Vue 提供了Vue-cli 腳手架,能讓你非常容易地構建項目,包含了 Webpack,Browserify, 甚至 no build system。React 在這方面也提供了create-react-app,但是現在還存在一些局限性:

  • 它不允許在項目生成時進行任何配置,而 Vue 支持 Yeoman-like 定製。
  • 它只提供一個構建單頁面應用的單一模板,而 Vue 提供了各種用途的模板。
  • 它不能用用戶自建的模板構建項目,而自建模板對企業環境下預先建立協議是特別有用的。

而要注意的是這些限制是故意設計的,這有它的優勢。例如,如果你的項目需求非常簡單,你就不需要自定義生成過程。你能把它作為一個依賴來更新。如果閱讀更多關於不同的設計理念。

向下擴展

React 學習曲線陡峭,在你開始學 React 前,你需要知道 JSX 和 ES2015,因為許多示例用的是這些語法。你需要學習構建系統,雖然你在技術上可以用 Babel 來實時編譯代碼,但是這並不推薦用於生產環境。

就像 Vue 向上擴展好比 React 一樣,Vue 向下擴展后就類似於 jQuery。你只要把如下標籤放到頁面就可以運行:

<script src="https://unpkg.com/vue/dist/vue.js"></script>

然後你就可以編寫 Vue 代碼並應用到生產中,你只要用 min 版 Vue 文件替換掉就不用擔心其他的性能問題。

由於起步階段不需學 JSX,ES2015 以及構建系統,所以開發者只需不到一天的時間閱讀指南就可以建立簡單的應用程序。

本地渲染

ReactNative 能使你用相同的組件模型編寫有本地渲染能力的 APP(IOS 和 Android)。能同時跨多平台開發,對開發者是非常棒的。相應地,Vue 和 Weex 會進行官方合作,Weex 是阿里的跨平台用戶界面開發框架,Weex 的 JavaScript 框架運行時用的就是 Vue。這意味着在 Weex 的幫助下,你使用 Vue 語法開發的組件不僅僅可以運行在瀏覽器端,還能被用於開發 IOS 和 Android 上的原生應用。

在現在,Weex 還在积極發展,成熟度也不能和 ReactNative 相抗衡。但是,Weex 的發展是由世界上最大的电子商務企業的需求在驅動,Vue 團隊也會和 Weex 團隊积極合作確保為開發者帶來良好的開發體驗。

MobX

Mobx 在 React 社區很流行,實際上在 Vue 也採用了幾乎相同的反應系統。在有限程度上,React + Mobx 也可以被認為是更繁瑣的 Vue,所以如果你習慣組合使用它們,那麼選擇 Vue 會更合理。

Angular 1

Vue 的一些語法和 Angular 的很相似(例如 v-if vs ng-if)。因為 Angular 是 Vue 早期開發的靈感來源。然而,Augular 中存在的許多問題,在 Vue 中已經得到解決。

複雜性

在 API 與設計兩方面上 Vue.js 都比 Angular 1 簡單得多,因此你可以快速地掌握它的全部特性並投入開發。

靈活性和模塊化

Vue.js 是一個更加靈活開放的解決方案。它允許你以希望的方式組織應用程序,而不是在任何時候都必須遵循 Angular 1 制定的規則,這讓 Vue 能適用於各種項目。我們知道把決定權交給你是非常必要的。
這也就是為什麼我們提供 Webpack template,讓你可以用幾分鐘,去選擇是否啟用高級特性,比如熱模塊加載、linting、CSS 提取等等。

數據綁定

Angular 1 使用雙向綁定,Vue 在不同組件間強制使用單向數據流。這使應用中的數據流更加清晰易懂。

指令與組件

在 Vue 中指令和組件分得更清晰。指令只封裝 DOM 操作,而組件代表一個自給自足的獨立單元 —— 有自己的視圖和數據邏輯。在 Angular 中兩者有不少相混的地方。

性能

Vue 有更好的性能,並且非常非常容易優化,因為它不使用臟檢查。

在 Angular 1 中,當 watcher 越來越多時會變得越來越慢,因為作用域內的每一次變化,所有 watcher 都要重新計算。並且,如果一些 watcher 觸發另一個更新,臟檢查循環(digest cycle)可能要運行多次。Angular 用戶常常要使用深奧的技術,以解決臟檢查循環的問題。有時沒有簡單的辦法來優化有大量 watcher 的作用域。

Vue 則根本沒有這個問題,因為它使用基於依賴追蹤的觀察系統並且異步隊列更新,所有的數據變化都是獨立觸發,除非它們之間有明確的依賴關係。

有意思的是,Angular 2 和 Vue 用相似的設計解決了一些 Angular 1 中存在的問題。

Angular 2

我們單獨將 Augluar 2 作分類,因為它完全是一個全新的框架。例如:它具有優秀的組件系統,並且許多實現已經完全重寫,API 也完全改變了。

TypeScript

Angular 1 面向的是較小的應用程序,Angular 2 已轉移焦點,面向的是大型企業應用。在這一點上 TypeScript 經常會被引用,它對那些喜歡用 Java 或者 C# 等類型安全的語言的人是非常有用的。

Vue 也十分適合製作企業應用,你也可以通過使用官方類型或用戶貢獻的裝飾器來支持 TypeScript,這完全是自由可選的。

大小和性能

在性能方面,這兩個框架都非常的快。但目前尚沒有足夠的數據用例來具體展示。如果你一定要量化這些數據,你可以查看第三方參照,它表明 Vue 2 相比 Angular2 是更快的。

在大小方面,雖然 Angular 2 使用 tree-shaking 和離線編譯技術使代碼體積減小了許多。但包含編譯器和全部功能的 Vue2(23kb) 相比 Angular 2(50kb) 還是要小的多。但是要注意,用 Angular 2 的 App 的體積縮減是使用了 tree-shaking 移除了那些框架中沒有用到的功能,但隨着功能引入的不斷增多,尺寸會變得越來越大。

靈活性

Vue 相比於 Angular 2 則更加靈活,Vue 官方提供了構建工具來協助你構建項目,但它並不限制你去如何構建。有人可能喜歡用統一的方式來構建,也有很多開發者喜歡這種靈活自由的方式。

學習曲線

開始使用 Vue,你使用的是熟悉的 HTML、符合 ES5 規則的 JavaScript(也就是純 JavaScript)。有了這些基本的技能,你可以快速地掌握它(指南)並投入開發 。

Angular 2 的學習曲線是非常陡峭的。即使不包括 TypeScript,它的開始指南中所用的就有 ES2015 標準的 JavaScript,18個 NPM 依賴包,4 個文件和超過 3 千多字的介紹,這一切都是為了完成個 Hello World。而Vue’s Hello World就非常簡單。甚至我們並不用花費一整個頁面去介紹它。

Ember

Ember 是一個全能框架。它提供了大量的約定,一旦你熟悉了它們,開發會變得很高效。不過,這也意味着學習曲線較高,而且並不靈活。這意味着在框架和庫(加上一系列鬆散耦合的工具)之間做權衡選擇。後者會更自由,但是也要求你做更多架構上的決定。

也就是說,我們最好比較的是 Vue 內核和 Ember 的模板與數據模型層:

  • Vue 在普通 JavaScript 對象上建立響應,提供自動化的計算屬性。在 Ember 中需要將所有東西放在 Ember 對象內,並且手工為計算屬性聲明依賴。
  • Vue 的模板語法可以用全功能的 JavaScript 表達式,而 Handlebars 的語法和幫助函數相比來說非常受限。
  • 在性能上,Vue 甩開 Ember 幾條街,即使是 Ember 2.0 的最新 Glimmer 引擎。Vue 能夠自動批量更新,而 Ember 在關鍵性能場景時需要手動管理。

Knockout

Knockout 是 MVVM 領域內的先驅,並且追蹤依賴。它的響應系統和 Vue 也很相似。它在瀏覽器支持以及其他方面的表現也是讓人印象深刻的。它最低能支持到 IE6,而 Vue 最低只能支持到 IE9。

隨着時間的推移,Knockout 的發展已有所放緩,並且略顯有點老舊了。比如,它的組件系統缺少完備的生命周期事件方法,儘管這些在現在是非常常見的。以及相比於 Vue 調用子組件的接口它的方法顯得有點笨重。

如果你有興趣研究,你還會發現二者在接口設計的理念上是不同的。這可以通過各自創建的simple Todo List 體現出來。或許有點主觀,但是很多人認為 Vue 的 API 接口更簡單結構更優雅。

Polymer

Polymer 是另一個由谷歌贊助的項目,事實上也是 Vue 的一個靈感來源。Vue 的組件可以粗略的類比於 Polymer 的自定義元素,並且兩者具有相似的開發風格。最大的不同之處在於,Polymer 是基於最新版的 Web Components 標準之上,並且需要重量級的 polyfills 來幫助工作(性能下降),瀏覽器本身並不支持這些功能。相比而言,Vue 在支持到 IE9 的情況下並不需要依賴 polyfills 來工作,。

在 Polymer 1.0 版本中,為了彌補性能,團隊非常有限的使用數據綁定系統。例如,在 Polymer 中唯一支持的表達式只有布爾值否定和單一的方法調用,它的 computed 方法的實現也並不是很靈活。

Polymer 自定義的元素是用 HTML 文件來創建的,這會限制使用 JavaScript/CSS(和被現代瀏覽器普遍支持的語言特性)。相比之下,Vue 的單文件組件允許你非常容易的使用 ES2015 和你想用的 CSS 預編譯處理器。

在部署生產環境時,Polymer 建議使用 HTML Imports 加載所有資源。而這要求服務器和客戶端都支持 Http 2.0 協議,並且瀏覽器實現了此標準。這是否可行就取決於你的目標用戶和部署環境了。如果狀況不佳,你必須用 Vulcanizer 工具來打包 Polymer 元素。而在這方面,Vue 可以結合異步組件的特性和 Webpack 的代碼分割特性來實現懶加載(lazy-loaded)。這同時確保了對舊瀏覽器的兼容且又能更快加載。

而 Vue 和 Web Component 標準進行深層次的整合也是完全可行的,比如使用 Custom Elements、Shadow DOM 的樣式封裝。然而在我們做出嚴肅的實現承諾之前,我們目前仍在等待相關標準成熟,進而再廣泛應用於主流的瀏覽器中。

Riot

Riot 2.0 提供了一個類似於基於組件的開發模型(在 Riot 中稱之為 Tag),它提供了小巧精美的 API。Riot 和 Vue 在設計理念上可能有許多相似處。儘管相比 Riot ,Vue 要顯得重一點,Vue 還是有很多顯著優勢的:

  • 根據真實條件來渲染,Riot 根據是否有分支簡單显示或隱藏所有內容。
  • 功能更加強大的路由機制,Riot 的路由功能的 API 是極少的。
  • 更多成熟工具的支持。Vue 提供官方支持Webpack、Browserify和SystemJS,而 Riot 是依靠社區來建立集成系統。
  • 過渡效果系統。Riot 現在還沒有提供。
  • 更好的性能。Riot 儘管聲稱其使用了虛擬 DOM,但實際上用的還是臟檢查機制,因此和 Angular 1 患有相同的性能問題。

沐鳴怎麼當代理?_JavaScript ES6特性(ECMAScript 6 and ES2015+)

JavaScript在過去幾年發生了很大的變化。 這篇文章整理了 JS 的12個新特性,你今天就開始使用!ES6是JavaScript語言的下一個版本,也稱作 ECMAScript 6 和 ES2015+。ES6中包含了許多新的語言特性,它們將使JS變得更加強大,更富表現力。

JavaScript 歷史

The new additions to the language are called ECMAScript 6. It is also referred as ES6 or ES2015+.

Since JavaScript conception on 1995, it has been evolving slowly. New additions happened every few years. ECMAScript came to be in 1997 to guide the path of JavaScript. It has been releasing versions such as ES3, ES5, ES6 and so on.

As you can see, there are gaps of 10 and 6 years between the ES3, ES5, and ES6. The new model is to make small incremental changes every year. Instead of doing massive changes at once like happened with ES6.

瀏覽器兼容

All modern browser and environments support ES6 already!

source: https://kangax.github.io/compat-table/es6/

Chrome, MS Edge, Firefox, Safari, Node and many others have already built-in support for most of the features of JavaScript ES6. So, everything that you are going to learn in this tutorial you can start using it right now.

Let’s get started with ECMAScript 6!

ES6 核心特性

You can test all these code snippets on your browser console!

So don’t take my word and test every ES5 and ES6 example. Let’s dig in

Block scope variables

With ES6, we went from declaring variables with var to use let/const.

What was wrong with var?

The issue with var is the variable leaks into other code block such as for loops or ifblocks.

ES5

1 2 3 4 5 6 7 8 9 10 11 var x = ‘outer’; function test(inner) { if (inner) { var x = ‘inner’; // scope whole function return x; } return x; // gets redefined because line 4 declaration is hoisted } test( false); // undefined test( true); // inner

For test(false) you would expect to return outer, BUT NO, you get undefined.

Why?

Because even though the if-block is not executed, the expression var x in line 4 is hoisted.

var hoisting:

  • var is function scoped. It is availble in the whole function even before being declared.
  • Declarations are Hoisted. So you can use a variable before it has been declared.
  • Initializations are NOT hoisted. If you are using var ALWAYS declare your variables at the top.
  • After applying the rules of hoisting we can understand better what’s happening:
    ES5
    1 2 3 4 5 6 7 8 9 var x = ‘outer’; function test(inner) { var x; // HOISTED DECLARATION if (inner) { x = ‘inner’; // INITIALIZATION NOT HOISTED return x; } return x; }

ECMAScript 2015 comes to the rescue:

ES6

1 2 3 4 5 6 7 8 9 10 11 let x = ‘outer’; function test(inner) { if (inner) { let x = ‘inner’; return x; } return x; // gets result from line 1 as expected } test( false); // outer test( true); // inner

Changing var for let makes things work as expected. If the if block is not called the variable x doesn’t get hoisted out of the block.

Let hoisting and “temporal dead zone”

  • In ES6, let will hoist the variable to the top of the block (NOT at the top of function like ES5).
  • However, referencing the variable in the block before the variable declaration results in aReferenceError.
  • let is blocked scoped. You cannot use it before it is declared.
  • “Temporal dead zone” is the zone from the start of the block until the variable is declared.

IIFE

Let’s show an example before explaining IIFE. Take a look here:

ES5

1 2 3 4 5 { var private = 1; } console.log(private); // 1

As you can see, private leaks out. You need to use IIFE (immediately-invoked function expression) to contain it:

ES5

1 2 3 4 5 ( function(){ var private2 = 1; })(); console.log(private2); // Uncaught ReferenceError

If you take a look at jQuery/lodash or other open source projects you will notice they have IIFEto avoid polluting the global environment and just defining on global such as _$ orjQuery.

On ES6 is much cleaner, We also don’t need to use IIFE anymore when we can just use blocks and let:

ES6

1 2 3 4 5 { let private3 = 1; } console.log(private3); // Uncaught ReferenceError

Const

You can also use const if you don’t want a variable to change at all.

Bottom line: ditch var for let and const.

  • Use const for all your references; avoid using var.
  • If you must reassign references, use let instead of const.

Template Literals

We don’t have to do more nesting concatenations when we have template literals. Take a look:

ES5

1 2 3 var first = ‘Adrian’; var last = ‘Mejia’; console.log( ‘Your name is ‘ + first + ‘ ‘ + last + ‘.’);

Now you can use backtick (`) and string interpolation ${}:

ES6

1 2 3 const first = ‘Adrian’; const last = ‘Mejia’; console.log( `Your name is ${first} ${last}.`);

Multi-line strings

We don’t have to concatenate strings + \n anymore like this:

ES5

1 2 3 4 5 6 7 8 9 var template = ‘<li *ngFor=”let todo of todos” [ngClass]=”{completed: todo.isDone}” >\n’ + ‘ <div class=”view”>\n’ + ‘ <input class=”toggle” type=”checkbox” [checked]=”todo.isDone”>\n’ + ‘ <label></label>\n’ + ‘ <button class=”destroy”></button>\n’ + ‘ </div>\n’ + ‘ <input class=”edit” value=””>\n’ + ‘</li>’; console.log(template);

On ES6 we can use the backtick again to solve this:

ES6

1 2 3 4 5 6 7 8 9 const template = `<li *ngFor=”let todo of todos” [ngClass]=”{completed: todo.isDone}” > <div class=”view”> <input class=”toggle” type=”checkbox” [checked]=”todo.isDone”> <label></label> <button class=”destroy”></button> </div> <input class=”edit” value=””> </li>`; console.log(template);

Both pieces of code will have exactly the same result.

Destructuring Assignment

ES6 desctructing is very useful and consise. Follow this examples:

Getting elements from an arrays

ES5

1 2 3 4 5 6 var array = [ 1, 2, 3, 4]; var first = array[ 0]; var third = array[ 2]; console.log(first, third); // 1 3

Same as:

ES6

1 2 3 4 5 const array = [ 1, 2, 3, 4]; const [first, ,third] = array; console.log(first, third); // 1 3

Swapping values

ES5

1 2 3 4 5 6 7 8 var a = 1; var b = 2; var tmp = a; a = b; b = tmp; console.log(a, b); // 2 1

same as

ES6

1 2 3 4 5 6 let a = 1; let b = 2; [a, b] = [b, a]; console.log(a, b); // 2 1

Destructuring for multiple return values

ES5

1 2 3 4 5 6 7 8 9 10 function margin() { var left= 1, right= 2, top= 3, bottom= 4; return { left: left, right: right, top: top, bottom: bottom }; } var data = margin(); var left = data.left; var bottom = data.bottom; console.log(left, bottom); // 1 4

In line 3, you could also return it in an array like this (and save some typing):

1 return [left, right, top, bottom];

but then, the caller needs to think about the order of return data.

1 2 var left = data[ 0]; var bottom = data[ 3];

With ES6, the caller selects only the data they need (line 6):

ES6

1 2 3 4 5 6 7 8 function margin() { const left= 1, right= 2, top= 3, bottom= 4; return { left, right, top, bottom }; } const { left, bottom } = margin(); console.log(left, bottom); // 1 4

Notice: Line 3, we have some other ES6 features going on. We can compact { left: left } to just { left }. Look how much concise it is compare to the ES5 version. Isn’t that cool?

Destructuring for parameters matching

ES5

1 2 3 4 5 6 7 8 9 10 var user = { firstName: ‘Adrian’, lastName: ‘Mejia’}; function getFullName(user) { var firstName = user.firstName; var lastName = user.lastName; return firstName + ‘ ‘ + lastName; } console.log(getFullName(user)); // Adrian Mejia

Same as (but more concise):

ES6

1 2 3 4 5 6 7 const user = { firstName: ‘Adrian’, lastName: ‘Mejia’}; function getFullName({ firstName, lastName }) { return `${firstName} ${lastName}`; } console.log(getFullName(user)); // Adrian Mejia

Deep Matching

ES5

1 2 3 4 5 6 7 8 9 function settings() { return { display: { color: ‘red’ }, keyboard: { layout: ‘querty’} }; } var tmp = settings(); var displayColor = tmp.display.color; var keyboardLayout = tmp.keyboard.layout; console.log(displayColor, keyboardLayout); // red querty

Same as (but more concise):

ES6

1 2 3 4 5 6 7 function settings() { return { display: { color: ‘red’ }, keyboard: { layout: ‘querty’} }; } const { display: { color: displayColor }, keyboard: { layout: keyboardLayout }} = settings(); console.log(displayColor, keyboardLayout); // red querty

This is also called object destructing.

As you can see, destructing is very useful and encourages good coding styles.

Best practices:

  • Use array destructing to get elements out or swap variables. It saves you from creating temporary references.
  • Don’t use array destructuring for multiple return values, instead use object destructuring

Classes and Objects

With ECMAScript 6, We went from “constructor functions” to “classes” .

In JavaScript every single object has a prototype, which is another object. All JavaScript objects inherit their methods and properties from their prototype.

In ES5, we did Object Oriented programming (OOP) using constructor functions to create objects as follows:

ES5

1 2 3 4 5 6 7 8 9 10 11 12 var Animal = ( function () { function MyConstructor(name) { this.name = name; } MyConstructor.prototype.speak = function speak() { console.log( this.name + ‘ makes a noise.’); }; return MyConstructor; })(); var animal = new Animal( ‘animal’); animal.speak(); // animal makes a noise.

In ES6, we have some syntax sugar. We can do the same with less boiler plate and new keywords such as class and constructor. Also, notice how clearly we define methodsconstructor.prototype.speak = function () vs speak():

ES6

1 2 3 4 5 6 7 8 9 10 11 class Animal { constructor(name) { this.name = name; } speak() { console.log( this.name + ‘ makes a noise.’); } } const animal = new Animal( ‘animal’); animal.speak(); // animal makes a noise.

As we saw, both styles (ES5/6) produces the same results behind the scenes and are used in the same way.

Best practices:

  • Always use class syntax and avoid manipulating the prototype directly. Why? because it makes the code more concise and easier to understand.
  • Avoid having an empty constructor. Classes have a default constructor if one is not specified.

Inheritance

Building on the previous Animal class. Let’s say we want to extend it and define a Lionclass

In ES5, It’s a little more involved with prototypal inheritance.

ES5

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 var Lion = ( function () { function MyConstructor(name){ Animal.call( this, name); } // prototypal inheritance MyConstructor.prototype = Object.create(Animal.prototype); MyConstructor.prototype.constructor = Animal; MyConstructor.prototype.speak = function speak() { Animal.prototype.speak.call( this); console.log( this.name + ‘ roars ‘); }; return MyConstructor; })(); var lion = new Lion( ‘Simba’); lion.speak(); // Simba makes a noise. // Simba roars.

I won’t go over all details but notice:

  • Line 3, we explicitly call Animal constructor with the parameters.
  • Line 7-8, we assigned the Lion prototype to Animal‘s prototype.
  • Line 11, we call the speak method from the parent class Animal.

In ES6, we have a new keywords extends and super .

ES6

1 2 3 4 5 6 7 8 9 10 class Lion extends Animal { speak() { super.speak(); console.log( this.name + ‘ roars ‘); } } const lion = new Lion( ‘Simba’); lion.speak(); // Simba makes a noise. // Simba roars.

Looks how legible this ES6 code looks compared with ES5 and they do exactly the same. Win!

Best practices:

  • Use the built-in way for inherintance with extends.

Native Promises

We went from callback hell to promises

ES5

1 2 3 4 5 6 7 8 9 10 11 12 13 14 function printAfterTimeout(string, timeout, done){ setTimeout( function(){ done(string); }, timeout); } printAfterTimeout( ‘Hello ‘, 2e3, function(result){ console.log(result); // nested callback printAfterTimeout(result + ‘Reader’, 2e3, function(result){ console.log(result); }); });

We have one function that receives a callback to execute when is done. We have to execute it twice one after another. That’s why we called the 2nd time printAfterTimeout in the callback.

This can get messy pretty quickly if you need a 3rd or 4th callback. Let’s see how we can do it with promises:

ES6

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 function printAfterTimeout(string, timeout){ return new Promise( (resolve, reject) => { setTimeout( function(){ resolve(string); }, timeout); }); } printAfterTimeout( ‘Hello ‘, 2e3).then( (result) => { console.log(result); return printAfterTimeout(result + ‘Reader’, 2e3); }).then( (result) => { console.log(result); });

As you can see, with promises we can use then to do something after another function is done. No more need to keep nesting functions.

Arrow functions

ES6 didn’t remove the function expressions but it added a new one called arrow functions.

In ES5, we have some issues with this:

ES5

1 2 3 4 5 6 7 8 9 var _this = this; // need to hold a reference $( ‘.btn’).click( function(event){ _this.sendData(); // reference outer this }); $( ‘.input’).on( ‘change’, function(event){ this.sendData(); // reference outer this }.bind( this)); // bind to outer this

You need to use a temporary this to reference inside a function or use bind. In ES6, you can use the arrow function!

ES6

1 2 3 4 5 6 // this will reference the outer one $( ‘.btn’).click( (event) => this.sendData()); // implicit returns const ids = [ 291, 288, 984]; const messages = ids.map( value => `ID is ${value}`);

For…of

We went from for to forEach and then to for...of:

ES5

1 2 3 4 5 6 7 8 9 10 11 // for var array = [ ‘a’, ‘b’, ‘c’, ‘d’]; for ( var i = 0; i < array.length; i++) { var element = array[i]; console.log(element); } // forEach array.forEach( function (element) { console.log(element); });

The ES6 for…of also allow us to do iterations.

ES6

1 2 3 4 5 // for …of const array = [ ‘a’, ‘b’, ‘c’, ‘d’]; for ( const element of array) { console.log(element); }

Default parameters

We went from checking if the variable was defined to assign a value to default parameters. Have you done something like this before?

ES5

1 2 3 4 5 6 7 8 9 10 11 function point(x, y, isFlag){ x = x || 0; y = y || -1; isFlag = isFlag || true; console.log(x,y, isFlag); } point( 0, 0) // 0 -1 true point( 0, 0, false) // 0 -1 true point( 1) // 1 -1 true point() // 0 -1 true

Probably yes, it’s a common pattern to check is the variable has a value or assign a default. Yet, notice there are some issues:

  • Line 8, we pass 0, 0 and get 0, -1
  • Line 9, we pass false but get true.

If you have a boolean as a default parameter or set the value to zero, it doesn’t work. Do you know why??? I’ll tell you after the ES6 example

With ES6, Now you can do better with less code!

ES6

1 2 3 4 5 6 7 8 function point(x = 0, y = -1, isFlag = true){ console.log(x,y, isFlag); } point( 0, 0) // 0 0 true point( 0, 0, false) // 0 0 false point( 1) // 1 -1 true point() // 0 -1 true

Notice line 5 and 6 we get the expected results. The ES5 example didn’t work. We have to check for undefined first since falsenullundefined and 0 are falsy values. We can get away with numbers:

ES5

1 2 3 4 5 6 7 8 9 10 11 function point(x, y, isFlag){ x = x || 0; y = typeof(y) === ‘undefined’ ? -1 : y; isFlag = typeof(isFlag) === ‘undefined’ ? true : isFlag; console.log(x,y, isFlag); } point( 0, 0) // 0 0 true point( 0, 0, false) // 0 0 false point( 1) // 1 -1 true point() // 0 -1 true

Now it works as expected when we check for undefined.

Rest parameters

We went from arguments to rest parameters and spread operator.

On ES5, it’s clumpsy to get an arbitrary number of arguments:

ES5

1 2 3 4 5 6 7 function printf(format) { var params = [].slice.call( arguments, 1); console.log( ‘params: ‘, params); console.log( ‘format: ‘, format); } printf( ‘%s %d %.2f’, ‘adrian’, 321, Math.PI);

We can do the same using the rest operator ....

ES6

1 2 3 4 5 6 function printf(format, …params) { console.log( ‘params: ‘, params); console.log( ‘format: ‘, format); } printf( ‘%s %d %.2f’, ‘adrian’, 321, Math.PI);

Spread operator

We went from apply() to the spread operator. Again we have ... to the rescue:

Reminder: we use apply() to convert an array into a list of arguments. For instance,Math.max() takes a list of parameters, but if we have an array we can use apply to make it work.

As we saw in earlier, we can use apply to pass arrays as list of arguments:

ES5

1 Math.max.apply( Math, [ 2, 100, 1, 6, 43]) // 100

In ES6, you can use the spread operator:

ES6

1 Math.max(…[ 2, 100, 1, 6, 43]) // 100

Also, we went from concat arrays to use spread operator:

ES5

1 2 3 4 5 var array1 = [ 2, 100, 1, 6, 43]; var array2 = [ ‘a’, ‘b’, ‘c’, ‘d’]; var array3 = [ false, true, null, undefined]; console.log(array1.concat(array2, array3));

In ES6, you can flatten nested arrays using the spread operator:

ES6

1 2 3 4 5 const array1 = [ 2, 100, 1, 6, 43]; const array2 = [ ‘a’, ‘b’, ‘c’, ‘d’]; const array3 = [ false, true, null, undefined]; console.log([…array1, …array2, …array3]);

沐鳴總代_實用教程——CSS3 Flexbox 屬性可視化指南

Flexbox 布局(國內很多人稱為彈性布局)正式的全稱為 CSS Flexible Box布局模塊,它是CSS3新增的一種布局模式。它可以很方便地用來改善動態或未知大小的元素的對齊,方向和順序等等。flex容器的主要特性是它可以調整其子元素的寬度或高度去填充可用的空白區,以最優的方式達到兼容不同屏幕大小。

很多設計人員和開發人員發現使用Flexbox來布局很容易,可以使用更少的代碼,更簡單的方式實現更複雜的布局,也使整個開發過程更為簡單。Flexbox布局算法不同於那些基於垂直或水平的塊或內聯布局。Flexbox布局應該用於小的應用程序組件之中,而新的CSS 網格布局模塊正在興起,來處理大規模布局。

本指南將以可視化的方式重點介紹 flex 屬性是如何影響布局的,不是解釋 flex 屬性是如何工作。

基礎

在我們開始介紹 flexbox屬性之前,讓我們先稍微介紹一下 flexbox模型。flex布局由被稱為 flex container(flex容器) 的父容器 和被稱為 flex item(flex項)的直接子元素構成。

在上面的圖片中,您可以看到用於描述 flex container(flex容器) 及其子元素的屬性和術語。關於他們意義的更多信息,請閱讀 W3C flexbox模型 的官方文檔。

愚人碼頭注:
要是看英文比較吃力,你可以查看 《Flexbox布局(CSS3 彈性布局,Flexible Box)之 基本概念解析》 這篇文章。

從2009年的最初草案開始,flexbox布局經歷了多次迭代和幾個版本的語法變更,所以為了避免混亂,我們將只使用最新的工作草案(2014年9月)中的語法。如果你需要維護舊的瀏覽器兼容性,你可以閱讀這篇文章,了解如何以最好的方式做到這一點。

愚人碼頭注:
目前解決flexbox版本兼容性問題,一般可以使用Autoprefixer后處理程序來實現css3代碼自動補全;
如果你使用 Sass,也可以使用 @mixin (混入)來解決 flexbox版本兼容,推薦一個github項目:sass-flex-mixin。

瀏覽器對最新flexbox規範的支持情況:

  • Chrome 29+
  • Firefox 28+
  • Internet Explorer 11+
  • Opera 17+
  • Safari 6.1+ (加前綴 -webkit-)
  • Android 4.4+
  • iOS 7.1+ (加前綴 -webkit-)

如果你需要查看更多瀏覽器兼容性,你可以看這裏。

使用

使用flexbox布局只要在父級HTML元素上設置display屬性:

css 代碼:
  1. .flex-container {
  2. display: -webkit-flex;/* Safari */
  3. display: flex;
  4. }

或者如果你想將它像一個內聯元素显示使用:

css 代碼:
  1. .flex-container {
  2. display: -webkit-inline-flex;/* Safari */
  3. display: inline-flex;
  4. }

注意:這是需要你在父容器上設置的唯一屬性,並且其所有直接子元素將自動成為 flex item(flex項)。

有幾種方法可以將 flexbox 屬性進行分組,迄今為止,我發現的了解 flexbox 選項的最簡單的方法是將 flexbox 屬性分成 flex container(flex容器)和 flex item(flex項) 兩組。下面,我們將按照這兩個分組解釋每個flexbox 屬性是如何在視覺上影響布局的。

Flexbox container 屬性

flex-direction

這個屬性通過設置 flex container(flex容器) 的主軸方向,來指定 flex item(flex項) 在 flex container(flex容器) 中是如何布局的。flex item(flex項) 可以在兩個主軸方向上排列布局,水平橫向和垂直縱向兩種。

屬性值:

css 代碼:
  1. .flex-container {
  2. -webkit-flex-direction: row;/* Safari */
  3. flex-direction: row;
  4. }

值為 row 方向,那麼在ltr上下文中,所有 flex item(flex項) 從左到右排成一行。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-flex-direction: row-reverse;/* Safari */
  3. flex-direction: row-reverse;
  4. }

值為 row-reverse 方向,那麼在ltr上下文中,所有 flex item(flex項) 從右到左排成一行。( 愚人碼頭注:reverse 為相反方向,很好記憶吧)如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-flex-direction: column;/* Safari */
  3. flex-direction: column;
  4. }

值為 column 方向,那麼所有 flex item(flex項) 從上到下排成一列。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-flex-direction: column-reverse;/* Safari */
  3. flex-direction: column-reverse;
  4. }

值為 column-reverse 方向,那麼所有 flex item(flex項) 從下到上排成一列。如圖:

默認值: row

注意:rowrow-reverse的排列方式取決於書寫模式,所以如果是在rtl上下文中,它們會反向排序。

flex-wrap

默認情況下,flexbox 理念是將容器中的所有子元素設置在一行中。flex-wrap屬性可以控制 flex container(flex容器) 以單行還是多行布局其flex item(flex項),以及在新行上的排列方向。

屬性值:

css 代碼:
  1. .flex-container {
  2. -webkit-flex-wrap: nowrap;/* Safari */
  3. flex-wrap: nowrap;
  4. }

flex item(flex項) 會显示成一行,默認情況下,它們會自動伸縮,以適應 flex container(flex容器)的寬度。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-flex-wrap: wrap;/* Safari */
  3. flex-wrap: wrap;
  4. }

flex item(flex項)會在flex container(flex容器)中, 按照從左到右,從上到下的順序显示成多行。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-flex-wrap: wrap-reverse;/* Safari */
  3. flex-wrap: wrap-reverse;
  4. }

flex item(flex項)會在flex container(flex容器)中, 按照從左到右,從下到上的順序显示成多行。如圖:

默認值: nowrap

注意:這些屬性取決於書寫模式,所以如果是在rtl上下文中,它們會反向排序。

flex-flow

這個屬性是設置flex-directionflex-wrap屬性的速記寫法(簡寫或縮寫)。

屬性值:

css 代碼:
  1. .flex-container {
  2. -webkit-flex-flow:||;/* Safari */
  3. flex-flow:||;
  4. }

默認值: row nowrap

justify-content

justify-content屬性用來指定 flex item(flex項)在當前 flex container(flex容器)主軸線(main axis)上的對齊方式。當所有flex item(flex項)都在同一行並且不可伸縮,或是可伸縮但已經達到它們最大尺寸的時候,它可以分配主軸線(main axis)上的剩餘空間。

屬性值:

css 代碼:
  1. .flex-container {
  2. -webkit-justify-content: flex-start;/* Safari */
  3. justify-content: flex-start;
  4. }

在ltr上下文中, flex item(flex項)會在 flex container(flex容器)中靠左對齊。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-justify-content: flex-end;/* Safari */
  3. justify-content: flex-end;
  4. }

在ltr上下文中, flex item(flex項)會在 flex container(flex容器)中靠右對齊。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-justify-content: center;/* Safari */
  3. justify-content: center;
  4. }

flex item(flex項)會在 flex container(flex容器)中靠中間對齊(居中對齊)。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-justify-content: space-between;/* Safari */
  3. justify-content: space-between;
  4. }

flex item(flex項)之間以相等的間距显示,第一個和最後一個flex item(flex項)會在 flex container(flex容器)中靠兩側邊緣對齊(愚人碼頭注:類似於常說的兩端對齊)。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-justify-content: space-around;/* Safari */
  3. justify-content: space-around;
  4. }

flex item(flex項)以相同的空間間隔显示,甚至第一個和最後一個flex item(flex項)。如圖:

默認值: flex-start

愚人碼頭注:
特別說明的是:上面都是flex container(flex容器)主軸線 橫向的例子,即flex-direction:row;。縱向的例子可以使用flex-direction:column;試試…。

align-items

flex item(flex項)可以在 flex container(flex容器)的當前交叉軸(cross axis)上對齊方式,類似於justify-content,但是在垂直方向。
此屬性設置所有flex item(flex項)的默認對齊方式,並且包括匿名元素。

愚人碼頭注:
justify-content是設置flex item(flex項)在主軸線(main axis)上的對齊方式;
align-items是設置flex item(flex項)在交叉軸(cross axis)上對齊方式;

屬性值:

css 代碼:
  1. .flex-container {
  2. -webkit-align-items: stretch;/* Safari */
  3. align-items: stretch;
  4. }

flex item(flex項)會從cross startcross end結束,填滿整個 flex container(flex容器)的高度(或寬度)。如圖:

愚人碼頭注:
這裏解釋一下填滿整個 flex container(flex容器)的寬度的情況:
當 flex-direction:column; 或者 flex-direction:column-reverse;時,將flex item(flex項)的寬度設置auto或者100%就可以了。

css 代碼:
  1. .flex-container {
  2. -webkit-align-items: flex-start;/* Safari */
  3. align-items: flex-start;
  4. }

flex item(flex項)會以flex container(flex容器) 的交叉軸起始(cross start)線對齊。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-align-items: flex-end;/* Safari */
  3. align-items: flex-end;
  4. }

flex item(flex項)會以flex container(flex容器) 的交叉軸結尾(cross end)線對齊。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-align-items: center;/* Safari */
  3. align-items: center;
  4. }

flex item(flex項)會以flex container(flex容器) 的交叉軸(cross axis)的中間對齊。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-align-items: baseline;/* Safari */
  3. align-items: baseline;
  4. }

flex item(flex項)會按照她們的文本基線(baseline)對象。

愚人碼頭注:
科普:文本基線(英語:Baseline)指的是多数字母排列的基準線。詳細說明請查看維基百科中關於Baseline的說明

默認值: stretch

注意:有關於文本基線計算的更多說明可以查看這裏。

align-content

當flex container(flex容器)的交叉軸(cross axis)上存在多餘空間(愚人碼頭注:未被填充滿)時,align-content 屬性可以控制 flex item(flex項)在 flex container(flex容器)的交叉軸(cross axis)上的對齊方式。類似於justify-content在主軸(main axis)方向上各個 flex item(flex項)的對齊。

屬性值:

css 代碼:
  1. .flex-container {
  2. -webkit-align-content: stretch;/* Safari */
  3. align-content: stretch;
  4. }
  5.  

flex item(flex項)在每行flex item(flex項)的後面都显示分佈式空間。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-align-content: flex-start;/* Safari */
  3. align-content: flex-start;
  4. }

flex item(flex項)會堆砌在flex container(flex容器)的交叉軸(cross axis)的起始位置上。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-align-content: flex-end;/* Safari */
  3. align-content: flex-end;
  4. }

flex item(flex項)會堆砌在 flex container(flex容器)的交叉軸(cross axis)的結束位置上。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-align-content: center;/* Safari */
  3. align-content: center;
  4. }

flex item(flex項)會堆砌在flex container(flex容器)的交叉軸(cross axis)的居中位置上。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-align-content: space-between;/* Safari */
  3. align-content: space-between;
  4. }

flex item(flex項)的行與行之間以相等的間隔显示,第一行和最後一行分別显示在flex container(flex容器)的交叉軸(cross axis)的兩端。如圖:

css 代碼:
  1. .flex-container {
  2. -webkit-align-content: space-around;/* Safari */
  3. align-content: space-around;
  4. }

flex item(flex項)的每一行以相等的間隔显示。如圖:

默認值: stretch

注意:這個屬性只有當 flex container(flex容器)有多行 flex item(flex項)時才生效,如果只有一行,那麼這個屬性沒有效果。

flex container(flex容器)的注意點

  • 所有的column-*屬性在flex container(flex容器)上都不會有效果
  • ::first-line 與 ::first-letter偽類在flex container(flex容器)上不會被應用。

flex item(flex項)的屬性

order

order屬性用來控制 flex container(flex容器)中 flex item(flex項)的排列順序。默認情況下,以它們被添加到 flex container(flex容器)中的順序排序(愚人碼頭注:可以理解為以HTML結構的順序排序)。

屬性值:

css 代碼:
  1. .flex-item {
  2. -webkit-order:;/* Safari */
  3. order:;
  4. }

flex item(flex項)可以使用這個簡單的屬性重新排序,而不需要重新修改HTML代碼。

默認值: 0

flex-grow

當 flex container(flex容器)存在剩餘空間時,可以用flex-grow這個屬性來確定 flex item(flex項)的拉伸比例。

屬性值:

css 代碼:
  1. .flex-item {
  2. -webkit-flex-grow:;/* Safari */
  3. flex-grow:;
  4. }

如果所有 flex item(flex項)具有相同的flex-grow值,那麼所有 flex item(flex項)在 flex container(flex容器)中具有相同的大小。

第二個 flex item(flex項) 相對於其他 flex item(flex項) 佔用更多空間。

默認值: 0

注意:負數值無效。

flex-shrink

當 flex container(flex容器)空間不足時,可以用flex-shrink這個屬性來確定 flex item(flex項)的收縮比例。

屬性值:

css 代碼:
  1. .flex-item {
  2. -webkit-flex-shrink:;/* Safari */
  3. flex-shrink:;
  4. }

默認情況下,所有 flex item(flex項)都可以收縮,但如果我們將它設置為 0(不收縮),它們將保持原來的大小。

默認值: 1

注意:負數值無效。

flex-basis

這個屬性看作widthheight屬性相同的值,並在 flex 伸縮比例分配剩餘空間之前,指定 flex item(flex項)的初始主要大小(愚人碼頭注: flex-grow 和 flex-shrink 伸縮比例分配剩餘空間之前)。

屬性值:

css 代碼:
  1. .flex-item {
  2. -webkit-flex-basis: auto |<width>;/* Safari */
  3. flex-basis: auto |<width>;
  4. }


flex-basis
指定了第4個 flex item(flex項)元素的初始大小。如圖:

默認值: 1

注意: auto 值存在一個問題,將在未來解決。

flex

這個屬性是flex-growflex-shrinkflex-basis屬性的速記寫法(簡寫或縮寫)。 除了其他值,它也可以設置為auto(即:1 1 auto)和none(即:0 0 auto)。

css 代碼:
  1. .flex-item {
  2. -webkit-flex: none | auto |[?||];/* Safari */
  3. flex: none | auto |[?||];
  4. }

默認值: 0 1 auto

注意:W3C鼓勵使用 flex 簡寫,而不是每個屬性都分開寫,因為速記正確地重置了未指定的屬性,以適應常見用途。

align-self

這個align-self屬性允許覆蓋單個的 flex item(flex項)默認對齊方式(或由align-items指定的值)。請參閱 flex container(flex容器)的align-items說明以了解可用的值。

屬性值:

css 代碼:
  1. .flex-item {
  2. -webkit-align-self: auto | flex-start | flex-end | center | baseline | stretch;/* Safari */
  3. align-self: auto | flex-start | flex-end | center | baseline | stretch;
  4. }

第3和第4個 flex item(flex項)通過align-self屬性覆蓋了其默認的對齊方式。如圖:

默認值: auto

注意:align-self 取值為auto值時,其值被計算為父級元素的align-items屬性的值,或者如果元素沒有父元素,那麼其值為stretch

flex item(flex項)的注意點

float,clearvertical-align在flex item(flex項)上都不會起作用,也不會讓它脫離文檔流。

Flexbox 演習場

這是一個flex 演習場,在這裏你可以玩完不同的flex屬性,並探索flexbox布局的力量。你可以結合多個flex屬性來獲取更加複雜的布局。

沐鳴:_Seen.js – 使用 SVG & Canvas 渲染 3D 場景

Seen.js 渲染3D場景為 SVG 或者 HTML5 畫布。Seen.js 包含對於 SVG 和 HTML5 Canvas 元素的圖形功能的最簡單的抽象。所有這個庫的其它組件都是不用關心將要渲染的上下文的類型。

 

官方網站      立即下載

沐鳴平台首頁_新手入門指導:Vue 2.0 的建議學習順序

起步

1. 紮實的 JavaScript / HTML / CSS 基本功。這是前置條件。

2. 通讀官方教程 (guide) 的基礎篇。不要用任何構建工具,就只用最簡單的 <script>,把教程里的例子模仿一遍,理解用法。不推薦上來就直接用 vue-cli 構建項目,尤其是如果沒有 Node/Webpack 基礎。

3. 照着官網上的示例,自己想一些類似的例子,模仿着實現來練手,加深理解。

4. 閱讀官方教程進階篇的前半部分,到『自定義指令 (Custom Directive) 』為止。着重理解 Vue 的響應式機制和組件生命周期。『渲染函數(Render Function)』如果理解吃力可以先跳過。

5. 閱讀教程里關於路由和狀態管理的章節,然後根據需要學習 vue-router 和 vuex。同樣的,先不要管構建工具,以跟着文檔里的例子理解用法為主。
6. 走完基礎文檔后,如果你對於基於 Node 的前端工程化不熟悉,就需要補課了。下面這些嚴格來說並不是 Vue 本身的內容,也不涵蓋所有的前端工程化知識,但對於大型的 Vue 工程是前置條件,也是合格的『前端工程師』應當具備的知識。

前端生態/工程化

1. 了解 JavaScript 背後的規範,ECMAScript 的歷史和目前的規範制定方式。學習 ES2015/16 的新特性,理解 ES2015 modules,適當關注還未成為標準的提案

2. 學習命令行的使用。建議用 Mac。

3. 學習 Node.js 基礎。建議使用 nvm 這樣的工具來管理機器上的 Node 版本,並且將 npm 的 registry 註冊表配置為淘寶的鏡像源至少要了解 npm 的常用命令,npm scripts 如何使用,語義化版本號規則,CommonJS 模塊規範(了解它和 ES2015 Modules 的異同),Node 包的解析規則,以及 Node 的常用 API。應當做到可以自己寫一些基本的命令行程序。注意最新版本的 Node (6+) 已經支持絕大部分 ES2015 的特性,可以藉此鞏固 ES2015。

4. 了解如何使用 / 配置 Babel 來將 ES2015 編譯到 ES5 用於瀏覽器環境。

5. 學習 Webpack。Webpack 是一個極其強大同時也複雜的工具,作為起步,理解它的『一切皆模塊』的思想,並基本了解其常用配置選項和 loader 的概念/使用方法即可,比如如何搭配 Webpack 使用 Babel。學習 Webpack 的一個挑戰在於其本身文檔的混亂,建議多搜索搜索,應該還是有質量不錯的第三方教程的。英文好的建議閱讀 Webpack 2.0 的文檔,比起 1.0 有極大的改善,但需要注意和 1.0 的不兼容之處

Vue 進階

1. 有了 Node 和 Webpack 的基礎,可以通過 vue-cli 來搭建基於 Webpack ,並且支持單文件組件的項目了。建議用 webpack-simple 這個模板開始,並閱讀官方教程進階篇剩餘的內容以及 vue-loader 的文檔,了解一些進階配置。有興趣的可以自己親手從零開始搭一個項目加深理解。

2. 根據 例子 嘗試在 Webpack 模板基礎上整合 vue-router 和 vuex
3. 深入理解 Virtual DOM 和『渲染函數 (Render Functions)』這一章節(可選擇性使用 JSX),理解模板和渲染函數之間的對應關係,了解其使用方法和適用場景。

4. (可選)根據需求,了解服務端渲染的使用(需要配合 Node 服務器開發的知識)。其實更重要的是理解它所解決的問題並搞清楚你是否需要它。
5. 閱讀開源的 Vue 應用、組件、插件源碼,自己嘗試編寫開源的 Vue 組件、插件。

6. 參考 貢獻指南 閱讀 Vue 的源碼,理解內部實現細節。(需要了解 Flow

7. 參与 Vue GitHub issue 的定位 -> 貢獻 PR -> 加入核心團隊 -> 升任 CTO -> 迎娶白富美…(誤

沐鳴平台首頁_35個讓人驚訝的 CSS3 動畫效果演示

本文收集了35個驚人的 CSS3 動畫演示,它們將證明 CSS3 Transform 和 Transition 屬性的強大能力。CSS 是網頁設計非常重要的一部分,隨着越來越多的瀏覽器對 CSS3 支持的不斷完善,設計師和開發者們有了更多的選擇。如今,用純 CSS 就可以實現各種各樣很酷的效果,甚至是動畫。

1. Pure CSS Coke Can

 

 

2. Colorful Clock

 

 

3. jQuery DJ Hero

 

 

4. Animated Pricing Column

 

 

5. Slick jQuery Menu

 

 

6. Frame-by-Frame Animation (Hover to Play)

 

 

7. AT-AT Walker

 

 

8. Contextual Slideout Tips With jQuery & CSS3

 

 

9. CSS3 & jQuery Slide Out Button

 

 

10. A Fresh Bottom Slide Out Menu with jQuery

 

 

11. Drop-In Modals

 

 

12. CSS3 Lightbox Gallery With jQuery

 

 

13. Easily Turn Your Images Into Polaroids with CSS3

 

 

14. Beautiful Looking Custom Dialog Box With jQuery and CSS3

 

 

15. Cross-Browser Rounded Buttons with CSS3 and jQuery

 

 

16. CSS3 DropDown Menu

 

 

17. CSS3 Search Form

 

 

18. CSS3 Dynamic Shadow

 

 

19. CSS3 Music Player Menu

 

 

20. Elastic Thumbnail Menu

 

 

21. Create Depth And Nice 3D Ribbons Only Using CSS3

 

 

22. CSS3 Chunky Menu

 

 

23. CSS3-only horizontal drop line tab menu

 

 

24. javascript-effect alternatives using CSS3 for webkit browsers

 

 

25. CSS3 Flying Menu

 


夢想天空關注前端開發,展示HTML5和CSS3應用,分享jQuery插件,推薦優秀網頁設計案例。  

26. Twitter-like Input Using CSS3

 

 

27. Animated wicked CSS3 3d bar chart

 

 

28. Wicked CSS3 3d bar chart

 

 

29. Pure CSS3 bokeh effect

 

 

30. Query & CSS3 Gallery With Animated Shine Effects

 

 

31. Interactive Image Vamp up with jQuery, CSS3 and PHP

 

 

32. How to Create a “Stay-On-Top” Menu with CSS3 and jQuery

 

 

33. Halftone Navigation Menu With jQuery & CSS3

 

 

34. 3D Meninas

 

 

35. Sliding Vinyl

 

 

36. Spotlight Cast Shadow

 

杏耀註冊平台官網_使用 Vue 2.0 實現服務端渲染的 HackerNews

Vue 2.0 支持服務端渲染 (SSR),並且是流式的,可以做組件級的緩存,這使得極速渲染成為可能。vue-hackernews-2.0 是 Vue 作者在GitHub上面放的 Vue 2.0 的一個示例項目,結合 Express、vue-router & vuex 來構建,是很好的學習案例。

 

Features

  • Server Side Rendering
    • Vue + vue-router + vuex working together
    • Server-side data pre-fetching
    • Client-side state & DOM hydration
  • Single-file Vue Components
    • Hot-reload in development
    • CSS extraction for production
  • Real-time List Updates with FLIP Animation

Architecture Overview

Build Setup

Requires Node.js 6+

# install dependencies
npm install

# serve in dev mode, with hot reload at localhost:8080
npm run dev

# build for production
npm run build

# serve in production mode
npm start

 

沐鳴:_20個不可思議的 WebGL 示例和演示

WebGL 是一項在網頁瀏覽器呈現3D畫面的技術,有別於過去需要安裝瀏覽器插件,通過 WebGL 的技術,只需要編寫網頁代碼即可實現3D圖像的展示。WebGL 可以為 Canvas 提供硬件3D加速渲染,這樣 Web 開發人員就可以藉助系統顯卡來在瀏覽器里更流暢地展示3D場景和模型了。

在這篇文章中20個不可思議的 WebGL 示例來增強你對於這個新技術的理解。

1. Aquarium

Image Source:www.webglsamples.org

Created by Greggman and Human Engines. The aquarium runs almost entirely based on a clock.That means the position of the camera and every fish will be the same across machines if their clocks are in sync. When in networked mode each machine keeps its clock in sync by periodically asking the server for the current time.

2. 3 Dreams of Black

Image Source:www.ro.me

A Semi-Intereactive film authored by Chris Milk. It was developed using technology developed by Google and other sources.

It works with chrome mixing 2D and 3D computer graphics, showcasing the song “Black” by Danger Mouse and Daniel Luppi ,with Norah Jones and Jack White.

3. Cube

Image Source:www.playmapscube.com

A WebGL innovative game inspired with Google maps technology. It consists of elements you see in Google Maps and analog labyrinth games combined with amazing controls that can break an experience.

4. Chemdoodle

Image Source:www.web.chemdoodle.com

Chemdoodle is a scientific visualization which lets you pick one of a number of medicines and see a 3D display of its chemical structure on compatible browsers, developed by iChemLabs.

5. Chrysaora

Image Source:www.aleksandarrodic.com

A dynamic Jellyfish WebGL demo built with Vladimir Vuki?evi?’s mjs matrix library. It showcases simulated skeletons, partial server-side simulation and synchronization with WebSocket, and camera facing a particle system and volumetric light effect.

6. WebGL Bookcase

Image Source:www.workshop.chromeexperiments.com

Google Books’ new flashy interface styled after a helix. Within the spiral books are sorted by subject and clicking on any book takes you to the entry in Google Books.

7. Just a Reflektor

Image Source:www.justareflektor.com

Just a Reflektor is a band Arcade Fire music video which was collaborated by Google. Using your mouse you can adjust various real-time filters and effects. This WebGL will require a webcam or simply your mouse.

8. WebGL Earth

Image Source:www.webglearth.com

An open source software enabling exploration, zooming and “playing” with the 3D globe in a web browser. The project is sustained through the support and cooperation of the developer community.

9. 3Dtin

Image Source:www.3dtin.com

3Dtin is an easy to use tool for creating shapes with a natural voxel-oriented 3D pixel approach, with the feature to export your project in 3D printing services.

10. The Biodigital Human

Image Source:www.biodigitalhuman.com

The BioDigital Human is a virtual 3D body that brings to life thousands of medically accurate anatomy objects and health conditions, in an interactive Web-based platform.

11. WebGL Rubik’s Cube

Image Source:www.randelshofer.ch

A Rubik’s Cube applets from Java to WebGL developed by Werner Randelshofer. Parts of the code are from the WebGL demo repository. Codes use in this WebGL are copyrighted by Apple Inc. and by Google Inc. and is used under permission.

12. GLGE

Image Source:www.glge.org

A framework for making WebGL developed by by Paul Brunt. It is a javascript library intended to ease the use of WebGL; which is basically a native browser javascript API giving direct access to openGL ES2, allowing for the use of hardware accelerated 2D/3D applications without having to download any plugins.

13. Ctrl+[P]aper

Image Source:www.grouek.com

Digital studio Grouek designed this Web GL website, that allows anyone to create its paper toy in 3 easy steps. Once you’re done, print the PDF, cut, fold and glue following instructions. In less time than you think, a beautiful, unique, self-created paper toy will proudly stand on your desktop.

14. A holiday message

Image Source:www.itsamessage.com

Developed by @thespite and @mrdoob. It will first require you to put on your address before proceeding. Once entered you’ll see a beautiful 3D scene that has a holiday greetings on it, where as you can move along using your mouse to view the whole 3D models.

15. Materials: Cars

Image Source:www.alteredqualia.com

With this WebGL you can choose to view 3D looks of Bugatti Veyron, Lamborghini Gallardo, Ferrari F50 and Chevrolet Camaro in your browser. Pick your ride and enjoy the view. Guest what, you can even choose their colors.

16. Quake 3

Image Source:www.media.tojicode.com

Developed by Brandon Jones, it is an impressive WebGL game demo complete with music. You can play it by just using your keyboard and mouse.

17. WebGL Image Filter

Image Source:www.evanw.github.io

A WebGL graphic editor application by Evan Wondrasek ,with a smooth and fast interface. You can play around with filter effects like the brightness and contrast, similar to the features you see in Photoshop.

18. From Dust

Image Source:www.bing.com

A WebGL game originally released a couple years ago on some traditional gaming platforms. Ubisoft has ported this game to WebGL and contains amusing and amazing effects and controls on it.

19. Acko.net

Image Source:www.acko.net

A WebGL that offers 3D logo on the header with a basic setting of a site when scrolled down. It offers a possibility that WebGL can be used as a practical setting to a website or software application.

20. WebGL Terrain

Image Source:www.alteredqualia.com

A WebGL demo with dynamic procedural terrain using 3d simplex nois. It features birds from ro.me and the background sound by Kevin Maclead.