![\"joy\"](\"/static/lib/simditor-emoji/images/emoji/joy.png\")
，又慢又挫的，就像如花姑娘：[转自：https://www.jianshu.com/p/97b6259f9773]
React是现在最流行的前端框架之一，它的轻量化，组件化，单向数据流等特性把前端引入了一个新的高度，现在它又引入的Hooks，一个神奇的东东，来看一看。
你还在为该使用无状态组件（Function）还是有状态组件（Class）而烦恼吗？——拥有了hooks，你再也不需要写Class了，你的所有组件都将是Function。
你还在为搞不清使用哪个生命周期钩子函数而日夜难眠吗？——拥有了Hooks，生命周期钩子函数可以先丢一边了。
你在还在为组件中的this指向而晕头转向吗？——既然Class都丢掉了，哪里还有this？你的人生第一次不再需要面对this。
一个最简单的Hooks
首先让我们看一下一个简单的有状态组件：
class Example extends React.Component {\n constructor(props) {\n super(props);\n this.state = {\n count: 0\n };\n }\n render() {\n return (\n <div>\n <p>You clicked {this.state.count} timesp>\n <button onClick={() => this.setState({ count: this.state.count + 1 })}>\n Click me\n button>\n div>\n );\n }\n}\n我们再来看一下使用hooks后的版本：
import { useState } from 'react';\n\nfunction Example() {\n const [count, setCount] = useState(0);\n return (\n <div>\n <p>You clicked {count} timesp>\n <button onClick={() => setCount(count + 1)}>\n Click me\n button>\n div>\n );\n}\n是不是简单多了！可以看到， Example变成了一个函数，但这个函数却有自己的状态（count），同时它还可以更新自己的状态（setCount）。这个函数之所以这么了不得，就是因为它注入了一个hook-- useState，就是这个hook让我们的函数变成了一个有状态的函数。
除了 useState这个hook外，还有很多别的hook，比如 useEffect提供了类似于 componentDidMount等生命周期钩子的功能， useContext提供了上下文（context）的功能等等。
Hooks本质上就是一类特殊的函数，它们可以为你的函数型组件（function component）注入一些特殊的功能。咦？这听起来有点像被诟病的Mixins啊？难道是Mixins要在react中死灰复燃了吗？当然不会了，等会我们再来谈两者的区别。总而言之，这些hooks的目标就是让你不再写class，让function一统江湖。
React为什么要搞一个Hooks？
想要复用一个有状态的组件太麻烦了！
我们都知道react都核心思想就是，将一个页面拆成一堆独立的，可复用的组件，并且用自上而下的单向数据流的形式将这些组件串联起来。但假如你在大型的工作项目中用react，你会发现你的项目中实际上很多react组件冗长且难以复用。尤其是那些写成class的组件，它们本身包含了状态（state），所以复用这类组件就变得很麻烦。
那之前，官方推荐怎么解决这个问题呢？答案是：渲染属性（Render Props）和高阶组件（Higher-Order Components）。我们可以稍微跑下题简单看一下这两种模式。
渲染属性指的是使用一个值为函数的prop来传递需要动态渲染的nodes或组件。如下面的代码可以看到我们的 DataProvider组件包含了所有跟状态相关的代码，而 Cat组件则可以是一个单纯的展示型组件，这样一来 DataProvider就可以单独复用了。
import Cat from 'components/cat'\n\nclass DataProvider extends React.Component {\n constructor(props) {\n super(props);\n this.state = { target: 'Zac' };\n }\n\n render() {\n return (\n <div>\n {this.props.render(this.state)}\n div>\n )\n }\n}\n\n<DataProvider render={data => (\n <Cat target={data.target} />\n)}/>\n虽然这个模式叫Render Props，但不是说非用一个叫render的props不可，习惯上大家更常写成下面这种：
...\n\n<DataProvider>\n {data => (\n <Cat target={data.target} />\n )}\nDataProvider>\n高阶组件这个概念就更好理解了，说白了就是一个函数接受一个组件作为参数，经过一系列加工后，最后返回一个新的组件。看下面的代码示例， withUser函数就是一个高阶组件，它返回了一个新的组件，这个组件具有了它提供的获取用户信息的功能。
const withUser = WrappedComponent => {\n const user = sessionStorage.getItem(\"user\");\n return props => <WrappedComponent user={user} {...props} />;\n};\n\nconst UserPage = props => (\n <div class=\"user-container\">\n <p>My name is {props.user}!p>\n div>\n);\n\nexport default withUser(UserPage);\n以上这两种模式看上去都挺不错的，很多库也运用了这种模式，比如我们常用的React Router。但我们仔细看这两种模式，会发现它们会增加我们代码的层级关系。最直观的体现，打开devtool看看你的组件层级嵌套是不是很夸张吧。这时候再回过头看我们上一节给出的hooks例子，是不是简洁多了，没有多余的层级嵌套。把各种想要的功能写成一个一个可复用的自定义hook，当你的组件想用什么功能时，直接在组件里调用这个hook即可。
生命周期钩子函数里的逻辑太乱了吧！
我们通常希望一个函数只做一件事情，但我们的生命周期钩子函数里通常同时做了很多事情。比如我们需要在 componentDidMount中发起ajax请求获取数据，绑定一些事件监听等等。同时，有时候我们还需要在 componentDidUpdate做一遍同样的事情。当项目变复杂后，这一块的代码也变得不那么直观。
classes真的太让人困惑了！
我们用class来创建react组件时，还有一件很麻烦的事情，就是this的指向问题。为了保证this的指向正确，我们要经常写这样的代码： this.handleClick=this.handleClick.bind(this)，或者是这样的代码： this.handleClick(e)}>。一旦我们不小心忘了绑定this，各种bug就随之而来，很麻烦。
还有一件让我很苦恼的事情。我在之前的react系列文章当中曾经说过，尽可能把你的组件写成无状态组件的形式，因为它们更方便复用，可独立测试。然而很多时候，我们用function写了一个简洁完美的无状态组件，后来因为需求变动这个组件必须得有自己的state，我们又得很麻烦的把function改成class。
在这样的背景下，Hooks便横空出世了！
什么是State Hooks？
回到一开始我们用的例子，我们分解来看到底state hooks做了什么：
import { useState } from 'react';\n\nfunction Example() {\n const [count, setCount] = useState(0);\n return (\n <div>\n <p>You clicked {count} timesp>\n <button onClick={() => setCount(count + 1)}>\n Click me\n button>\n div>\n );\n}\n声明一个状态变量
import { useState } from 'react';\n\nfunction Example() {\n const [count, setCount] = useState(0);\n}\nuseState是react自带的一个hook函数，它的作用就是用来声明状态变量。 useState这个函数接收的参数是我们的状态初始值（initial state），它返回了一个数组，这个数组的第 [0]项是当前当前的状态值，第 [1]项是可以改变状态值的方法函数。
所以我们做的事情其实就是，声明了一个状态变量count，把它的初始值设为0，同时提供了一个可以更改count的函数setCount。
如果不用数组解构的话，可以写成下面这样。实际上数组解构是一件开销很大的事情，用下面这种写法，或者改用对象解构，性能会有很大的提升。具体可以去这篇文章的分析：Array destructuring for multi-value returns (in light of React hooks)，这里不详细展开，我们就按照官方推荐使用数组解构就好。
let _useState = useState(0);\nlet count = _useState[0];\nlet setCount = _useState[1];\n读取状态值
<p>You clicked {count} timesp>\n是不是超简单？因为我们的状态count就是一个单纯的变量而已，我们再也不需要写成 {this.state.count}这样了。
更新状态
当用户点击按钮时，我们调用setCount函数，这个函数接收的参数是修改过的新状态值。接下来的事情就交给react了，react将会重新渲染我们的Example组件，并且使用的是更新后的新的状态，即count=1。这里我们要停下来思考一下，Example本质上也是一个普通的函数，为什么它可以记住之前的状态？
一个至关重要的问题
这里我们就发现了问题，通常来说我们在一个函数中声明的变量，当函数运行完成后，这个变量也就销毁了（这里我们先不考虑闭包等情况），比如考虑下面的例子：
function add(n) {\n const result = 0;\n return result + 1;\n}\n\nadd(1); //1\nadd(1); //1\n不管我们反复调用add函数多少次，结果都是1。因为每一次我们调用add时，result变量都是从初始值0开始的。那为什么上面的Example函数每次执行的时候，都是拿的上一次执行完的状态值作为初始值？答案是：是react帮我们记住的。至于react是用什么机制记住的，我们可以再思考一下。
假如一个组件有多个状态值怎么办？
首先，useState是可以多次调用的，所以我们完全可以这样写：
function ExampleWithManyStates() {\n const [age, setAge] = useState(42);\n const [fruit, setFruit] = useState('banana');\n const [todos, setTodos] = useState([{ text: 'Learn Hooks' }]);\n}\n其次，useState接收的初始值没有规定一定要是string/number/boolean这种简单数据类型，它完全可以接收对象或者数组作为参数。唯一需要注意的点是，之前我们的 this.setState做的是合并状态后返回一个新状态，而 useState是直接替换老状态后返回新状态。最后，react也给我们提供了一个useReducer的hook，如果你更喜欢redux式的状态管理方案的话。
从ExampleWithManyStates函数我们可以看到，useState无论调用多少次，相互之间是独立的。这一点至关重要。为什么这么说呢？
其实我们看hook的“形态”，有点类似之前被官方否定掉的Mixins这种方案，都是提供一种“插拔式的功能注入”的能力。而mixins之所以被否定，是因为Mixins机制是让多个Mixins共享一个对象的数据空间，这样就很难确保不同Mixins依赖的状态不发生冲突。
而现在我们的hook，一方面它是直接用在function当中，而不是class；另一方面每一个hook都是相互独立的，不同组件调用同一个hook也能保证各自状态的独立性。这就是两者的本质区别了。
react是怎么保证多个useState的相互独立的？
还是看上面给出的ExampleWithManyStates例子，我们调用了三次useState，每次我们传的参数只是一个值（如42，‘banana’），我们根本没有告诉react这些值对应的key是哪个，那react是怎么保证这三个useState找到它对应的state呢？
答案是，react是根据useState出现的顺序来定的。我们具体来看一下：
//第一次渲染\n useState(42); //将age初始化为42\n useState('banana'); //将fruit初始化为banana\n useState([{ text: 'Learn Hooks' }]); //...\n //第二次渲染\n useState(42); //读取状态变量age的值（这时候传的参数42直接被忽略）\n useState('banana'); //读取状态变量fruit的值（这时候传的参数banana直接被忽略）\n useState([{ text: 'Learn Hooks' }]); //...\n假如我们改一下代码：
let showFruit = true;\nfunction ExampleWithManyStates() {\n const [age, setAge] = useState(42);\n if(showFruit) {\n const [fruit, setFruit] = useState('banana');\n showFruit = false;\n }\n const [todos, setTodos] = useState([{ text: 'Learn Hooks' }]);\n}\n这样一来，
//第一次渲染\n useState(42); //将age初始化为42\n useState('banana'); //将fruit初始化为banana\n useState([{ text: 'Learn Hooks' }]); //...\n\n //第二次渲染\n useState(42); //读取状态变量age的值（这时候传的参数42直接被忽略）\n // useState('banana'); \n useState([{ text: 'Learn Hooks' }]); //读取到的却是状态变量fruit的值，导致报错\n鉴于此，react规定我们必须把hooks写在函数的最外层，不能写在ifelse等条件语句当中，来确保hooks的执行顺序一致。
什么是Effect Hooks?
我们在上一节的例子中增加一个新功能：
import { useState, useEffect } from 'react';\n\nfunction Example() {\n const [count, setCount] = useState(0);\n // 类似于componentDidMount 和 componentDidUpdate:\n useEffect(() => {\n // 更新文档的标题\n document.title = `You clicked ${count} times`;\n });\n\n return (\n <div>\n <p>You clicked {count} timesp>\n <button onClick={() => setCount(count + 1)}>\n Click me\n button>\n div>\n );\n}\n我们对比着看一下，如果没有hooks，我们会怎么写？
class Example extends React.Component {\n constructor(props) {\n super(props);\n this.state = {\n count: 0\n };\n }\n\n componentDidMount() {\n document.title = `You clicked ${this.state.count} times`;\n }\n\n componentDidUpdate() {\n document.title = `You clicked ${this.state.count} times`;\n }\n\n render() {\n return (\n <div>\n <p>You clicked {this.state.count} timesp>\n <button onClick={() => this.setState({ count: this.state.count + 1 })}>\n Click me\n button>\n div>\n );\n }\n}\n我们写的有状态组件，通常会产生很多的副作用（side effect），比如发起ajax请求获取数据，添加一些监听的注册和取消注册，手动修改dom等等。我们之前都把这些副作用的函数写在生命周期函数钩子里，比如componentDidMount，componentDidUpdate和componentWillUnmount。而现在的useEffect就相当与这些声明周期函数钩子的集合体。它以一抵三。
同时，由于前文所说hooks可以反复多次使用，相互独立。所以我们合理的做法是，给每一个副作用一个单独的useEffect钩子。这样一来，这些副作用不再一股脑堆在生命周期钩子里，代码变得更加清晰。
useEffect做了什么？
我们再梳理一遍下面代码的逻辑：
function Example() {\n const [count, setCount] = useState(0);\n\n useEffect(() => {\n document.title = `You clicked ${count} times`;\n });\n}\n首先，我们声明了一个状态变量 count，将它的初始值设为0。然后我们告诉react，我们的这个组件有一个副作用。我们给 useEffecthook传了一个匿名函数，这个匿名函数就是我们的副作用。在这个例子里，我们的副作用是调用browser API来修改文档标题。当react要渲染我们的组件时，它会先记住我们用到的副作用。等react更新了DOM之后，它再依次执行我们定义的副作用函数。
这里要注意几点：
第一，react首次渲染和之后的每次渲染都会调用一遍传给useEffect的函数。而之前我们要用两个声明周期函数来分别表示首次渲染（componentDidMount），和之后的更新导致的重新渲染（componentDidUpdate）。
第二，useEffect中定义的副作用函数的执行不会阻碍浏览器更新视图，也就是说这些函数是异步执行的，而之前的componentDidMount或componentDidUpdate中的代码则是同步执行的。这种安排对大多数副作用说都是合理的，但有的情况除外，比如我们有时候需要先根据DOM计算出某个元素的尺寸再重新渲染，这时候我们希望这次重新渲染是同步发生的，也就是说它会在浏览器真的去绘制这个页面前发生。
useEffect怎么解绑一些副作用
这种场景很常见，当我们在componentDidMount里添加了一个注册，我们得马上在componentWillUnmount中，也就是组件被注销之前清除掉我们添加的注册，否则内存泄漏的问题就出现了。
怎么清除呢？让我们传给useEffect的副作用函数返回一个新的函数即可。这个新的函数将会在组件下一次重新渲染之后执行。这种模式在一些pubsub模式的实现中很常见。看下面的例子：
import { useState, useEffect } from 'react';\n\nfunction FriendStatus(props) {\n const [isOnline, setIsOnline] = useState(null);\n\n function handleStatusChange(status) {\n setIsOnline(status.isOnline);\n }\n\n useEffect(() => {\n ChatAPI.subscribeToFriendStatus(props.friend.id, handleStatusChange);\n // 一定注意下这个顺序：告诉react在下次重新渲染组件之后，同时是下次调用ChatAPI.subscribeToFriendStatus之前执行cleanup\n return function cleanup() {\n ChatAPI.unsubscribeFromFriendStatus(props.friend.id, handleStatusChange);\n };\n });\n\n if (isOnline === null) {\n return 'Loading...';\n }\n return isOnline ? 'Online' : 'Offline';\n}\n这里有一个点需要重视！这种解绑的模式跟componentWillUnmount不一样。componentWillUnmount只会在组件被销毁前执行一次而已，而useEffect里的函数，每次组件渲染后都会执行一遍，包括副作用函数返回的这个清理函数也会重新执行一遍。所以我们一起来看一下下面这个问题。
为什么要让副作用函数每次组件更新都执行一遍？
我们先看以前的模式：
componentDidMount() {\n ChatAPI.subscribeToFriendStatus(\n this.props.friend.id,\n this.handleStatusChange\n );\n }\n\n componentWillUnmount() {\n ChatAPI.unsubscribeFromFriendStatus(\n this.props.friend.id,\n this.handleStatusChange\n );\n }\n很清楚，我们在componentDidMount注册，再在componentWillUnmount清除注册。但假如这时候 props.friend.id变了怎么办？我们不得不再添加一个componentDidUpdate来处理这种情况：
...\n\n componentDidUpdate(prevProps) {\n // 先把上一个friend.id解绑\n ChatAPI.unsubscribeFromFriendStatus(\n prevProps.friend.id,\n this.handleStatusChange\n );\n\n // 再重新注册新但friend.id\n ChatAPI.subscribeToFriendStatus(\n this.props.friend.id,\n this.handleStatusChange\n );\n }\n...\n看到了吗？很繁琐，而我们但useEffect则没这个问题，因为它在每次组件更新后都会重新执行一遍。所以代码的执行顺序是这样的：
怎么跳过一些不必要的副作用函数
按照上一节的思路，每次重新渲染都要执行一遍这些副作用函数，显然是不经济的。怎么跳过一些不必要的计算呢？我们只需要给useEffect传第二个参数即可。用第二个参数来告诉react只有当这个参数的值发生改变时，才执行我们传的副作用函数（第一个参数）。
useEffect(() => {\n document.title = `You clicked ${count} times`;\n}, [count]); // 只有当count的值发生变化时，才会重新执行`document.title`这一句\n当我们第二个参数传一个空数组[]时，其实就相当于只在首次渲染的时候执行。也就是componentDidMount加componentWillUnmount的模式。不过这种用法可能带来bug，少用。
还有哪些自带的Effect Hooks?
除了上文重点介绍的useState和useEffect，react还给我们提供来很多有用的hooks：
怎么写自定义的Effect Hooks?
为什么要自己去写一个Effect Hooks? 这样我们才能把可以复用的逻辑抽离出来，变成一个个可以随意插拔的“插销”，哪个组件要用来，我就插进哪个组件里，so easy！看一个完整的例子，你就明白了。
比如我们可以把上面写的FriendStatus组件中判断朋友是否在线的功能抽出来，新建一个useFriendStatus的hook专门用来判断某个id是否在线。
import { useState, useEffect } from 'react';\n\nfunction useFriendStatus(friendID) {\n const [isOnline, setIsOnline] = useState(null);\n\n function handleStatusChange(status) {\n setIsOnline(status.isOnline);\n }\n\n useEffect(() => {\n ChatAPI.subscribeToFriendStatus(friendID, handleStatusChange);\n return () => {\n ChatAPI.unsubscribeFromFriendStatus(friendID, handleStatusChange);\n };\n });\n\n return isOnline;\n}\n这时候FriendStatus组件就可以简写为：
function FriendStatus(props) {\n const isOnline = useFriendStatus(props.friend.id);\n\n if (isOnline === null) {\n return 'Loading...';\n }\n return isOnline ? 'Online' : 'Offline';\n}\n简直Perfect！假如这个时候我们又有一个朋友列表也需要显示是否在线的信息：
function FriendListItem(props) {\n const isOnline = useFriendStatus(props.friend.id);\n return (\n <li style={{ color: isOnline ? 'green' : 'black' }}>\n {props.friend.name}\n li>\n );\n}\n简直Fabulous!
","excerpt":"[转自：https://www.jianshu.com/p/97b6259f9773]React是现在最流行的前端框架之一，它的轻量化，组件化，单向数据流等特性把前端引入了一个新的高度，现在它又引入的Hooks，一个神奇的东东，来看一看。你还在为该使用无状态组件（Function）还是有状态组件（Class）而烦恼吗？——拥有了hooks，你再也不需要写Class了，你的所有组件都将是Function。你还在为搞不清使用哪个生命周期钩子函数而日夜难眠吗？——拥有了Hooks，生命周期钩子函数可以先丢一边了。你在还在为组件中的this指向而晕头转向吗？——","title":"React 新特性——React Hooks","author":"老鼠AI大米_Java全栈","type":"tech","en_gallery":false,"enable":true,"tag":["前端","React"],"img":[],"thumb":[],"mid":[],"raw":[],"createdAt":"2020-04-27T08:07:22.720Z","updatedAt":"2020-05-14T10:21:04.827Z","pv_count":808,"article_id":"5ea692ba950d432b5b7e4634","id":"5ea692ba950d432b5b7e4634"}],"prevPage":false,"nextPage":false,"allPages":1,"currentPage":1,"hotArticleList":[{"content":"Karat克拉这个网站，就是基于sails开发的，前后端都启用了es6+es7特性的开发。
我在github上传了部署代码和文档：https://github.com/xunuoi/sails-babel
修改变动比较多，github上可能不是最新的代码和文档。
主要是用了一个支持babel的hook和babel的gulp组件，来支援es6~
新建一个空sails项目，不包含前端：
sails new withu.cc --no-frontend --template=swig修改.sailssrc
1、添加如下，否则启动sails lift会有找不到grunt的warn
{\n \"generators\": {\n \"modules\": {}\n },\n \"hooks\": {\n \"grunt\": false\n },\n \"paths\": {\n \"views\": \"views\"\n }\n\n}2、修改模板引擎配置
安装swig： 目录下，npm install swig
config/views文件：
engine: {\n 'name': 'swig',\n 'ext': 'html',\n fn: function (pathName, locals, cb) {\n var swig = require('swig')\n swig.setDefaults({ \n loader: swig.loaders.fs('./views') \n })\n return swig.renderFile(pathName, locals, cb);\n }\n },3、简历 views和assets目录
assets目录：
js
lib： for bower
img
font
css
scss 或者less
==================================
4、安装bower
assets目录下 bower init
assets下目录static
.bowerrc:
{\n \"directory\": \"./static/lib/\",\n \"analytics\": false,\n \"timeout\": 120000\n}\n5、配置nginx静态目录和upstream
vhost
assets目录下，设置bower和gulpfile.js
npm install安装时可能会有问题：
Error: pngquant failed to build, make sure that libpng-dev is installed
This error means that the system is lacking libpng development library, which is needed to installimagemin Node.JS module. To install it on CentOS 6, you need to issue this command:
yum install libpng-devel另外简单介绍下assets/gulpfile.js中的babel配置，完整文件请戳到github上： https://github.com/xunuoi/sails-babel/blob/master/assets/gulpfile.js
通过配置来启用你想要的es6、7特性：
var babelOptional = [\n \"es7.asyncFunctions\",\n \"es7.objectRestSpread\",\n \"es7.functionBind\",\n \"es7.comprehensions\",\n]\n在gulp task中引用这个option：
gulp.task('es6', function() {\n return gulp.src([\n j(ASSETS_ROOT, 'es6/**/*.es6'), \n ])\n .pipe(p.babel({\n optional: babelOptional,\n }))\n .pipe(gulp.dest(\n j(ASSETS_ROOT, '.tmp')\n ))\n})==========================================================================
前端构建中，涉及到配合es6中的import 语句（相当于烂大街的require等）来打包构建（browserify来构建），并且增加md5防止缓存问题，需要对一个gulp插件修改一下，这个插件是gulp-md5-plus，但是本身不支持文件搜索定位，所以修改下来支持，详细如下：
修改gulp-md5-plus ，增加root选项
module.exports = function (size, ifile, rootpath) {\nsize = size | 0;\nrootpath = rootpath || '\nxxx\n}) var match_file_path = path.join(rootpath, relativepath)\n var md5_filename = filename.split('.').map(function(item, i, arr){\n return i == arr.length-2 ? item + '_'+ d : item;\n }).join('.');\n var relative_dir = path.relative(file.base, dir)\n var md5_file_path = path.join(rootpath,relative_dir, md5_filename)\n console.log('debug: gulp-md5-plus: \\n', md5_file_path)\n \n然后替换replace：
replace(new RegExp(match_file_path), md5_file_path);修改后的完整代码（安装完gulp-md5-plus，他的目录下index.js的代码）：
var path = require('path')\n, gutil = require('gulp-util')\n, through = require('through2')\n, crypto = require('crypto')\n, fs = require('fs')\n, glob = require('glob');\nmodule.exports = function (size, ifile, rootpath) {\n size = size | 0;\n rootpath = rootpath || ''\n return through.obj(function (file, enc, cb) {\n if (file.isStream()) {\n this.emit('error', new gutil.PluginError('gulp-debug', 'Streaming not supported'));\n return cb();\n }\n if(!file.contents){\n return cb();\n }\n var d = calcMd5(file, size)\n , filename = path.basename(file.path)\n , relativepath = path.relative(file.base ,file.path)\n , sub_namepath = relativepath\n .replace(new RegExp(filename) , \"\").split(path.sep).join('/')\n , dir;\n if(file.path[0] == '.'){\n dir = path.join(file.base, file.path);\n } else {\n dir = file.path;\n }\n dir = path.dirname(dir);\n var match_file_path = path.join(rootpath, relativepath)\n var md5_filename = filename.split('.').map(function(item, i, arr){\n return i == arr.length-2 ? item + '_'+ d : item;\n }).join('.');\n var relative_dir = path.relative(file.base, dir)\n var md5_file_path = path.join(rootpath,relative_dir, md5_filename)\n console.log('debug: gulp-md5-plus: \\n', match_file_path)\n console.log('debug: gulp-md5-plus: \\n', md5_file_path)\n \n if(Object.prototype.toString.call(ifile) == \"[object Array]\"){\n ifile.forEach(function(i_ifile){\n i_ifile && glob(i_ifile,function(err, i_files){\n if(err) return console.log(err);\n i_files.forEach(function(i_ilist){\n var result = fs.readFileSync(i_ilist,'utf8').replace(new RegExp(match_file_path), md5_file_path);\n fs.writeFileSync(i_ilist, result, 'utf8');\n })\n })\n })\n }else{\n ifile && glob(ifile,function(err, files){\n if(err) return console.log(err);\n files.forEach(function(ilist){\n var result = fs.readFileSync(ilist,'utf8').replace(new RegExp(match_file_path), md5_file_path);\n fs.writeFileSync(ilist, result, 'utf8');\n })\n })\n }\n file.path = path.join(dir, md5_filename);\n this.push(file);\n cb();\n }, function (cb) {\n cb();\n });\n};\nfunction calcMd5(file, slice){\n var md5 = crypto.createHash('md5');\n md5.update(file.contents, 'utf8');\n return slice >0 ? md5.digest('hex').slice(0, slice) : md5.digest('hex');\n}\n==========================================================================
关于 gulpfile.js
两个gulpfile。assets和根目录下各一个
browserify只能打包js，也就是转化成es5的js文件。通过添加paths这个函数，可以设置全局模块的路径，注意此时paths必须是转成js的模块，不是es6的路径。
部分打包代码：
function browserifyOne(fpath){\n return browserify({\n entries: fpath,\n debug: true,\n sourceMaps: false,\n extensions: ['.es6', '.jsx', '.js'],\n paths: [\n j(ASSETS_ROOT, 'lib'),\n j(ASSETS_ROOT, '.tmp/common')\n ]\n })\n /*.transform(babelify.configure({\n optional: babelOptional\n }))*/\n /*.require(require.resolve('babel/polyfill'),{expose: 'babel/polyfill'} )*/ // use regenerators\n .bundle()\n .pipe(source(fpath))\n .pipe(buffer())\n .pipe(p.rename(function(path) {\n path['dirname'] = path['dirname'].replace('.tmp', 'js').replace(j(ASSETS_ROOT,'/'), '')\n }))\n /*.on('error', function(err){\n throw Error(err)\n })*/\n}
安装sails-babel-hook的钩子，自动调用babel转化，不需要再手工写gulp来转了
8、配置js和lib
让jquery能打包进入js中正常使用
//main.js\n\nimport 'jquery/dist/jquery'\n$('body').html('i am jquery googog')\nexport { foo, bar }修改jquery源代码
(function( global, factory ) {\n\tif (false && typeof module === \"object\" && typeof module.exports === \"object\" ) {9、适配mongodb
npm install --save-dev sails-mongo
创建对应model
","excerpt":"Karat克拉这个网站，就是基于sails开发的，前后端都启用了es6+es7特性的开发。我在github上传了部署代码和文档：https://github.com/xunuoi/sails-babel 修改变动比较多，github上可能不是最新的代码和文档。主要是用了一个支持babel的hook和babel的gulp组件，来支援es6~新建一个空sails项目，不包含前端：sails new withu.cc --no-frontend --template=swig修改.sailssrc1、添加如下，否则启动sails lift会有找不到grunt的","img":[],"title":"全栈es6、7的js开发－基于Sails","author":"Cloud","type":"tech","en_gallery":false,"enable":true,"tag":["前端","Web","Sails","Express"],"thumb":[],"mid":[],"createdAt":"2015-10-27T12:34:27.378Z","updatedAt":"2015-11-18T10:04:36.053Z","pv_count":2864,"article_id":"562f6f53d6db69011de1bbe0","id":"562f6f53d6db69011de1bbe0"},{"content":"可以像FIS一样，具有模块化的前端目录结构。
基于gulp，简单、灵活，容易扩展和修改，懂点gulp的童鞋都可以自己修改、使用、组合。
不需要任何服务端的整合工作，这个与FIS有很大不同，不需要修改服务端代码来适配，就像正常的html一样，去引用你的js、css、img、fonts等资源，无侵入。
整合SCSS ES6 Browserify|cssnano|uglify|imagmein|rev等前端常用套件，同时有监视文件变动功能(watch)，可配置的发布目录、资源目录、CDN等，方便开发，简单易用，一站式搞定。
更新说明：
gulpman 1.4.6版本更新：\n新增支持cdn_prefix的数组/函数/字符串传参方式，更灵活和强大\n新增支持内联嵌入CSS/JS到html。 只需要再url后面添加 ?_gm_inline\n完善内联资源嵌入后的自动更新引用文件(html和CSS)\n完善文档\ngulpman 1.3.6版本更新：\n\n新增对React/jsx支持，可以直接写ReactJS了gulpman 1.3.3版本更新：\n\n1、新增对复杂目录和多级目录设定支持:\n比如下面这种模板、静态文件复杂的、多级的路径：\ngulpman.config({\n 'components': 'components/cc',\n 'runtime_views': 'runtime_views/rv',\n 'dist_views': 'dist_views/dv/dv',\n 'runtime_assets': 'runtime_assets/ra/ra',\n 'dist_assets': 'dist_assets/da'\n \n})\n\n2、增加彩色log\n\n3、增加base64关联的资源文件的自动关联编译，比如跟这个base64图片有关的html、css都会自动编译(监视模式下)\n先来个大致的介绍：
./components(默认，可配置)，如果你有个模块是foo，那么应该有如下目录：./components/foo，然后跟foo模块相关的html|js|css|fonts|image等资源文件都放到foo下，这个结构下，做开发时非常清晰、高效，便于模块组织、资源定位等。gm:publish命令构建后，会自动生成模板views目录，和静态资源assets目录。Github源码： https://github.com/xunuoi/gulpman
cd into your project dir and install:
npm install gulpman --save-dev只需要require gulpman模块，就会自动加载gm:publish、gm:develop（开发监视模式）等预置的task，使用时在命令行直接输入gulp gm:publish即可执行
/**\n * Gulpfile.js\n */\n\n\nvar gulp = require('gulp'),\n gman = require('gulpman')\n\n\n// your other tasks ...你的其他task\n\n\n\n\n// 设置路径、CDN、资源URL前缀等，API超级简单。\n// 你也可以不设置，全部采用默认值!\n// if you want to set the dir, you can use config API:\n\ngman.config({\n\n // 是否使用绝对路径，默认true,推荐使用，方便服务器配置。比如`/static/home/main.js`这种风格。\n // 如果is_absolute是false, 那么可能是`../../assets/static/home/main.js`这种风格。\n // 具体取决于项目情况、服务端配置等。\n // if set the assets url prefix as absolute or relative, default: true\n 'is_absolute': true,\n\n // cdn prefix 配置CDN\n 'cdn_prefix': '', \n\n // 配置资源URL前缀，建议 /xxx这种\n // usually set as /static, this involves the server config ,such as the static path of nginx\n 'url_prefix': '/static' \n\n\n // 模块COMPONENTS目录，同一个模块的html和资源文件在一起。默认 'components'即可\n 'components': 'components',\n\n // develop和publish下的views目录，跟服务端框架的views目录配置一致，比如express\n 'runtime_views': 'views',\n 'dist_views': 'views_dist',\n\n // develop和publish下的assets静态目录，跟服务器配置有关，比如nginx的static目录指向\n 'runtime_assets': 'assets',\n 'dist_assets': 'assets_dist',\n\n // 第三方JS类库、模块的目录，推荐设置为`lib`或`bower_components`（这样bower可以直接安装到这个目录）\n // 这个目录默认打包时为全局模块目录，可以直接`require('xxx')`，而不用加相对路径\n // the js library dir, set as a global module. Also you can set as bower_components\n 'lib': 'lib', \n\n // 可以添加一个自定的全局模块目录，该目录下的js模块，也作为全局模块来require，不需要相对路径。\n // the global module dir\n 'global': 'common' \n})\n\n1. config的配置中，lib和global都是全局模块目录。举个例子说明：你的components/lib目录下有一个模块 foo.js，就是： components/lib/foo.js，那么你在你的es6文件中，就可以这样使用：` import foo from 'foo' `，不需要写成 ` import foo from '../lib/foo' `。
2. 同理global那个配置也是这样的，推荐将lib目录设置成跟bower一致的，全部来存放第三方类库，而global设置的目录，比如common，可以存放自己的 公用模块。
3. 这样开发会更加灵活、方便。注意全局模块不要用同名冲突。
就是普通的调用gulp 的task
# 初始化目录，建立components目录并添加一份html的demo文件\n# init components dir and a html demo\ngulp gm:init\n\n# publish 发布资源，包括合并、压缩资源、rev产生MD5等\ngulp gm:publish\n\n# develop and watch 开发模式，监视相关文件变动，增量更新\ngulp gm:develop\n\n# clean 清理构建输出的目录和文件\ngulp gm:clean\n\n# 编译输出一份运行时资源文件，但是不进入监视状态\n# compile for develop, not watch\ngulp gm:compile\n什么Ajax、Pjax、Njax。。。神马玩意？ 有Njax吗？ 木有。。。不过真有Pjax！！
其实pjax就是用到了html5的新history api： pushState和replaceState。如果浏览器不支持，会自动降级为普通http访问，跟正常a链接一样
具体啥区别？先视觉通感感受下！！上图：
1、普通的http切换页面的请求方式，闪烁、白屏、卡顿、加载等，就是完整加载一坨页面嘛，又慢又挫的，就像如花姑娘：
![\"1.jpg\"](\"/img/large/559038a7-2d21-4123-a03c-f1a3970a56ff.jpg\")
2、通过Ajax来开发页面，只加在部分数据，没有切换和闪烁，清新宜人哦，就像街上MM、邻家小妹![\"stuck_out_tongue_winking_eye\"](\"/static/lib/simditor-emoji/images/emoji/stuck_out_tongue_winking_eye.png\")
如果只是ajax的话，不能保存页面状态！一刷新就没了啊！！转瞬即逝啊！！
街上的MM都走远了，童鞋别看了，找不到了！！
如果要保存的话，结合hash#，其实很坑爹啊！
很多时候引入hash,导致开发复杂不说，关键是影响SEO，百度不认识 #! 啊 只有谷歌认识有毛线用啊被墙了!![\"sob\"](\"/static/lib/simditor-emoji/images/emoji/sob.png\")
![\"2.JPG\"](\"/img/large/031ecc7d-3564-4884-abfa-bbfea938d786.JPG\")
3、Pjax来了啊，喜大普奔！既能无切换、高性能加载显示html，又能跟普通url兼容，前后端开发逻辑也简单！
就像下面的女神吉田沙世和摄影模特啊！关键是你还能抱回家，轻松hold住，各种调戏啊！卧槽。。说漏嘴了。。咳说正事！
![\"3.jpg\"](\"/img/large/2394c653-c8dc-43d9-9861-5e9be3035e2d.jpg\")
![\"4.jpg\"](\"/img/large/091ea772-e6c9-41c7-8740-883003bf1253.jpg\")
说完了视觉上的通感感受，我们再看一眼开发的区别，是不是开发很麻烦啊 ！！！上代码:
MO.go('.ctn a', '#ttt')然后呢？
木有了啊！只要后台再根据请求头区分下是否是pjax来返回片段html代码就可以了！
浏览器不支持pjax怎么办？ 自动将极为普通http啊！！不用担心的！
艾玛、这么happy！真幸福！
简直就是修炼玉女心经的节奏啊！ 耶，操练起来！
- 首先需要jQuery这个基础库~其实可以用纯js写这个pjax类库的，但是，我懒。。。
- 引入编译es5后到dist目录下的 mo.pjax.es5.js 脚本文件到html文件，如果使用es6，请import并配置编译
src=\"./dist/mo.pjax.es5.js\"可以去github上下载： https://github.com/xunuoi/MO.Pjax
用法:
Api Params Desc 参数注释:
_fetch : 是否请求网络，比如这次pjax的url参数是/about ,如果_fetch为false，那么不发送http 请求或读取缓存，只执行回调。
多用在复杂web/app设计中，比如当前内容已存在于html中，不想更新和获取.
* MO.state默认值是false，因为只是重新定义本页面状态，不需要更新已有数据和HTML
* MO.touch中默认值是true，因为要从http或缓存中 更新数据、html
_fire：是否立刻触发onpopfn ，立刻执行回调函数。false表示popstate 事件触发后才执行
* MO.state中默认值是false, 只有popstate事件触发后才执行
* MO.go中调用了MO.state，并传参_fire值为false.
* MO.define中调用了MO.state，并传参_fire值为true.
调教一下，再美的女神也不是天生就符合你的口味，来这定制下啊！
MO.config({\n 'type': 'POST',\n\n // this can be used for you back-end ,to detect if it is a pjax request\n 'pjaxHeader': {\n 'X-Http-Pjax': 'Pjax'\n }\n})详细配置和注解:
{\n 'type': 'POST',// post is default http请求方式\n\n // if cache data， 是否缓存\n 'cache': true,\n // 'cacheExpires': 10000, // 0 means always avaliable, default none 缓存时间\n\n // if store data in localStorage , default true \n 'storage': true, //是否启用localStorage\n //如果storageExpires设置为0或false，永不过期\n 'storageExpires': 43200000, // 12 hours ,default 12 \n\n // the res data type, default html\n 'dataType': 'html', //返回数据类型，默认html\n\n // you can set your own header ,just use `pjaxHeader` opts, \n // which you can detect if it is an pjax request in back-end \n // 你可以自己定义请求头，方便后端判断是否是pjax请求，如果是pjax, 返回部分html， fragment\n 'pjaxHeader': {\n 'Http-Request-Pjax': 'Fragment'\n },\n\n // you can set the fn which will triggered before MO.touch and popstate event happened\n // 触发pjax操作前和 出现popstate的事件时的事件函数, 参数是state，包含url、title等信息\n before (state) { ... } //默认无\n\n // you can set the beforeSend fn , before ajax request send.\n // jquery的ajax方法调用，请求前设置请求头，可以覆盖\n beforeSend (req){\n let ph = this['pjaxHeader']\n for (let h in ph ){\n let v = ph[h]\n req.setRequestHeader(h, v)\n }\n }\n}看看美女哪里长得最漂亮啊![\"heart_eyes\"](\"/static/lib/simditor-emoji/images/emoji/heart_eyes.png\")
一、MO.go 最简单！
MO.go(aSelector, ctnSelector, onSuccess)这个是最简单和常用的api， 只需要go一下，传入2个参数即可，一个是点击后触发pjax的元素选择器，一般是a，第二个是更新返回内容的html 。第三个是回调函数，可选。
MO.go添加处理错误的函数，比如出现网络请求错误，比如404，会在此处捕获
MO.go('.ctn a', '#ttt', \nfunction onSuccess(res, $aEle){\n console.log(res, $aEle)\n}, \nfunction onError(err, $aEle){\n console.log(err, $aEle)\n})二、MO.define 不常用
定义当前页面的state状态，不常用
MO.define(ctn, htmlData)三、MO.state 适合复杂开发
* MO.state和MO.go两者经常配合使用，比较灵活
详细定义当前页面state状态，以及是否请求次url, 和是否立刻触发onpopFn_fire
MO.state(url, title, onpopFn, _data=null, _fetch=false, _fire=false)\n四、MO.go 复杂开发，很好用啊！！！
做复杂交互和逻辑时，比较常用
* 更强大和灵活的使用pjax， 可以定义 pjax的操作的url、回调、是否发起此url的网络请求等，同样可以添加fail的错误处理函数
MO.touch(apiUrl, title, onpopFn, _fetch=true)给touch添加fail处理网络请求错误，添加方式如下
MO.touch(apiUrl, title, onpopFn, _fetch=true)\n.fail(function(err) {\n console.log('There is an error ', err)\n})\n服务端处理：
服务端只需要判断是普通请求(完整html)还是pjax请求（fragment html）
可以通过MO.config({'pjaxHeader': {xxx: yyy}})来设置请求头，或者修改type为POST\\GET等，只要让服务端能判断即可！
说明：
- 通过MO.touch和MO.state，可以做非常复杂的pjax 应用，自定义事件\\UI等
- 如果要简单使用，就是直接 MO.go(), 传入你想要pjax的a元素的selector即可
- 配合启用cache/localStorage(默认都启用), 给用户更好操作体验，减少等待、卡顿
本地存储：store/removeStore
原来还有这么个福利！！！
可以在引入MO.Pjax的任何页面，来store数据，当其他页面pjax到此页面的时候，数据直接从storage获取就可以啦！这个在做多重请求方式的web开发时，经常用到哦！
- 提供本地存储和自动过期机制，
- 过期时间通过MO.config({'storageExpires': xxx})来设定
- 自动创建一个item来跟踪这条数据的时间: { k+'createdAt': (new Date).getTime() },
Store的Api
\nMO.store(k, v)\nMO.removeStore(k, v)\n\n<div class=\"ctn\">\n <h3>Test Mo.pjaxh3>\n <p>\n <a href=\"/about.html\">Abouta>\n <a href=\"/toxic.html\">Toxica> \n p>\ndiv>\n<div id=\"ttt\" style=\"margin-top: 30px;\">\n <p>This is index htmlp>\ndiv>\n\n\n\n------------------------------------------------------------------\n\n\n<div>This is about htmldiv>\n\n\n\n------------------------------------------------------------------\n\n\n<div>This is toxic htmldiv>\nMO.go('.ctn a', '#ttt')So easy! 搞定收工！
就似这么简单！就似这么任性！
我娘再也不用担心我无刷新更新页面内容了！Pjax大法\b好！
赶紧把pjax女神抱回家！！！![\"smile\"](\"/static/lib/simditor-emoji/images/emoji/smile.png\")
SVG动画，结合了CSS3的transition， 先看下效果图 ![\"屏幕快照](\"/img/081b72c0-8ffa-429a-a643-fa44adc6d3a3.png\")
动画效果： 直接参见本页面的导航菜单![\"laughing\"](\"http://karat.cc/static/lib/simditor-emoji/images/emoji/laughing.png\")
鼠标一上去，会有border变长，通过border的dashoffset的变化，包围住整个菜单矩形。
用到了css3的animation，详细用法大家可以看下： http://www.ruanyifeng.com/blog/2014/02/css_transition_and_animation.html 讲的比较好
注意，Firefox中跟webkit计算dash-offset方法有不同，需要fix一下：
/**\n * FIX Firefox bugs: anti-direcion，\n * and dashoffset is different with Chrome\n */\n@keyframes moz_draw {\n 0% {\n stroke-dasharray: $dash_len $dash_space_len;\n stroke-dashoffset: $dash_offset;\n stroke-width: $stroke_max_width;\n }\n 100% {\n stroke-dasharray: $dash_full_len+$dash_space_len;\n stroke-dashoffset: -$dash_offset;\n stroke-width: $stroke_min_width;\n }\n}\n然后单独对Firefox进行CSS Hack：
&:hover .shape {\n -webkit-animation: 0.5s linear 0s normal forwards 1 draw;\n animation: 0.5s linear 0s normal forwards 1 draw;\n\n //fix Firefox :stroke-dashoffset not 0 ??\n @-moz-document url-prefix() {\n animation: 0.5s linear 0s normal forwards 1 moz_draw;\n }\n}Firefox的差异，稍后有时间我再研究下。这种东西比较坑爹~
其他不多说，上代码，算法代码总有注释：
1. 先上html结构参考：
<header>\n <nav>\n <div class=\"menu active\">\n <svg version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" width=\"180px\" height=\"48px\">\n <rect width=\"180px\" height=\"48px\" class=\"shape\"></rect>\n </svg>\n <a href=\"/\" class=\"text\">HOME</a>\n </div>\n <div class=\"menu\">\n <svg version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" width=\"180px\" height=\"48px\">\n <rect width=\"180px\" height=\"48px\" class=\"shape\"></rect>\n </svg>\n <a href=\"/toxic\" class=\"text\">TOXIC</a> \n </div>\n <div class=\"menu\">\n <svg version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" width=\"180px\" height=\"48px\">\n <rect width=\"180px\" height=\"48px\" class=\"shape\"></rect>\n </svg>\n \n <a href=\"/gallery\" class=\"text\">GALLERY</a>\n </div>\n </nav>\n</header>2. 这块是定义变量和动画， \b注意下stroke和dash、dash offset的值的定义：
@import 'define';\n@import 'util';\n\n/**\n * Stroke Calculator =====================\n * @type {[type]}\n * @description: stroke-dashoffset ,\n * 是起点偏移量，在svg的rect中，从左上角开始，\n * 如果offset为负值，那么线段向右偏移移动。\n * dasharray第一个是线段长度，\n * 第二个是空白间隔长度，\n * 当空白间隔小于 offset的时候，\n * 起点处会进入一部分线段（起点之前的线段）。\n * 线段是无穷循环的，\n * 但是都会没入结点中，超过结点后，被覆盖。\n */\n$stroke_color: #19f6e8;\n$menu_w: 180px;\n$menu_h: 48px;\n$stroke_max_width: 6px;\n$stroke_min_width: 2px;\n$dash_len: 120px;\n$dash_space_len: $menu_w + $menu_h + ($menu_w - $dash_len)/2;\n$dash_offset: - $dash_space_len;\n \n$dash_full_len: 2*($menu_w + $menu_h);\n//======================================\n/**\n * A text center size\n */\n$text_size: 18px;\n$text_bottom: $text_size + ($menu_h - $text_size)/2 + $stroke_min_width;\n@keyframes draw {\n 0% {\n stroke-dasharray: $dash_len $dash_space_len;\n stroke-dashoffset: $dash_offset;\n stroke-width: $stroke_max_width;\n }\n 100% {\n stroke-dasharray: $dash_full_len;\n stroke-dashoffset: 0;\n stroke-width: $stroke_min_width;\n }\n}\n/**\n * FIX Firefox bugs: anti-direcion，\n * and dashoffset is different with Chrome\n */\n@keyframes moz_draw {\n 0% {\n stroke-dasharray: $dash_len $dash_space_len;\n stroke-dashoffset: $dash_offset;\n stroke-width: $stroke_max_width;\n }\n 100% {\n stroke-dasharray: $dash_full_len+$dash_space_len;\n stroke-dashoffset: -$dash_offset;\n stroke-width: $stroke_min_width;\n }\n}\n3. 这块是CSS样式
\n\n .menu { \n width: $menu_w;\n height: $menu_h;\n display: inline-block;\n margin: 2px;\n // margin: 0 auto;\n text-align: center;\n position: relative;\n\n /**\n * @debug Firefox和一些safair版本中，不识别CSS中的width和height\n * 必须将width写在svg代码中\n */\n svg{\n width: $menu_w;\n height: $menu_h;\n .shape {\n \n // @extend .hardware;\n\n width: $menu_w;\n height: $menu_h;\n\n fill: transparent;\n stroke-dasharray: $dash_len $dash_space_len;\n stroke-dashoffset: $dash_offset;\n stroke-width: 0;\n stroke: $stroke_color;\n \n // 选中状态的\n @at-root nav .menu.active svg .shape {\n stroke-width: $stroke_max_width;\n }\n\n }\n }\n\n &:hover .shape {\n -webkit-animation: 0.5s linear 0s normal forwards 1 draw;\n animation: 0.5s linear 0s normal forwards 1 draw;\n\n //fix Firefox :stroke-dashoffset not 0 ??\n @-moz-document url-prefix() {\n animation: 0.5s linear 0s normal forwards 1 moz_draw;\n }\n }\n\n .text {\n // 具有子菜单的一级菜单，具有交互模糊效果\n @at-root .menu.on .text{\n @include blur(2px);\n }\n @include trans-all(); \n \n color: $nav_a_color;\n font-size: $text_size;\n letter-spacing: 3px;\n line-height: $text_size;\n position: relative;\n bottom: $text_bottom;\n // font-family: 'roboto';\n text-decoration: none; \n \n &:hover {\n color: $nav_a_color;\n letter-spacing: 4px;\n }\n }\n }\n\n\n黑白摄影从古至今一直很流行，景观摄影是一大流派，许多摄影师选择拍摄单色照片。但黑色和白色在每张照片里的效果是不一样的。它需要时间和实践，提高你对黑色白色的理解。下面这些技巧将有助于你更好的拍摄黑白风景照片。
1.了解什么场景拍摄黑白照片更好
有了彩色景观照片，可以依靠色彩的力量来创造内容和兴趣。良好的色彩景观摄影的关键是找到一个值得拍摄的场景，并有最美丽的光作支撑。这就是为什么这么多的彩色景观照片是在黄金时段或日落后拍摄的。
黑白是不同的。没有颜色，你就必须更加努力地创造出强大的作品。你需要学习寻找摄影构图的技巧，如引线，形状，图案，色调对比度和纹理。真的，你要将你看到的色彩在脑中转换成黑白，所剩下的图案就是你要学习的。
例如，这张黑色摄影作品，用的是双瀑布和黑暗的岩石之间的对比。
![\"ceSjMjJG6580w.jpg\"](\"/img/large/31ad11c8-debb-4f61-973d-4bd892c69520.jpg\")
2.寻找文理和色调的对比
色调对比度是用来描述图像的不同部分之间的亮度变化的术语。以下面的照片为例。码头，映衬着傍晚的天空，码头是黑暗的，天空则更浅。这是色调对比。海中的灰色比天空暗一点，但又亮于码头。
![\"ceOCnQh07Q7cw.jpg\"](\"/img/large/f3eaf83c-9515-49e3-a550-2b42e216acd7.jpg\")
如果你想在拍摄悬崖，岩石，草，树，山上出现的东西，海和人造的物体，如码头和码头他们都有不同的纹理。
在下面的照片中，石拱，远处的悬崖，和岩石在前景都是沉重的纹理。大海和天空都更光滑。这是岩石的粗糙度与触感和平静的海面和天空之间的强烈对比。
![\"ceny4bjWodmw.jpg\"](\"/img/large/f7c6c9d6-9da4-4d9a-b655-3c4bddec20fc.jpg\")
3.黑白模式拍摄
用码相机拍摄的好处是，他们可以帮助你理解黑白颜色下的世界。你所要做的就是把你的相机设置为黑白（单色）模式。然后在相机的取景器上查看当前现场的黑白效果。
![\"ceZuAsO1EStIg.jpg\"](\"/img/large/b276c816-562d-4a1a-b5e9-24b415d63926.jpg\")
这有助于你只看到黑色和白色，不会被其他杂乱的颜色分心。这个方法是有用的，因为它使你更容易看到色调的对比度，纹理，线条，形状，图案和光。
4.学习使用中灰密度滤光镜
中灰密度滤光镜是景观摄影师的秘密武器，要了解为什么他们是如此有用，让我们思考一下景观照片的典型设置。首先，您设置您ISO尽可能低来保证最佳的图像质量。下一步，你设置一个光圈，大多数的景观照片都是在F / 11或F / 16。
有了这些变量，快门速度取决于环境光的水平。在明亮的阳光下，它可能是约1 / 125s。在低光，它可以低至1 / 2s。但是，如果你想使用一个较慢的快门速度创意效果呢？如果ISO和光圈是固定的，你得到更长快门速度的唯一的方式就是通过使用中灰密度滤光镜。
下面是一个例子。这张照片是在黄昏的光圈的F / 11在ISO 200和快门速度的1 /5th下。这是慢到水面模糊，你甚至可以看到前景的岩石。
![\"1.jpg\"](\"/img/large/b1e561be-ab30-4d91-978b-62e47492538e.jpg\")
然后我添加了一个中灰密度滤光镜，并使这张照片（下面）的快门速度为180秒（3分钟）。水是完全平静的，云在空中移动形成了一个条纹。
![\"2.jpg\"](\"/img/large/0e9ffe97-0abc-4176-86d8-ac9e27e699fa.jpg\")
5.不要被其他摄影作品影响
摄影师Cole Thompson有一个有趣的想法。他练习他所谓的摄影禁欲，不看其他摄影师的作品。该理论是，他能够通过自己的眼睛看到的景观绝不受其他人的照片的影响。
![\"3.jpg\"](\"/img/large/34cc3b0f-bd43-4091-8e58-416fc9eed2cd.jpg\")
我不是很相信这个极端的方法，因为当你缺乏灵感的时候，其他摄影师的作品或许会给你新的想法。但问题是，你在研究过程中看到的最优秀的摄影作品往往会印在你的脑海中。之后你的大脑自然趋势就是要创建类似的图像。这样做的结果就会导致你最后的照片看起来像其他人的。
![\"4.jpg\"](\"/img/large/4b77b067-647a-4076-8446-3950627e23bd.jpg\")
6.旅行
所有的照片，我已经展示给你的都是在西班牙北部拍的。除非你也足够的幸运的生活在这样一个地区，否则你需要旅行来找到类似鼓舞人心的风景照片。
即使你住在一个风景优美的地方，你也需要旅行来扩大你的经验，并增加你照片的深度。我最喜欢的风景照片是在旅行时拍摄的，这两个活动很好地结合在一起，当它背后有一个目的时，旅行更有趣，更令人兴奋。风景摄影是种可以给你的目的感的东西之一。
![\"5.jpg\"](\"/img/large/6e0b277c-d3aa-4c04-b255-2157cfb3d99d.jpg\")
没有旅行，我永远不会有经验和这么优秀的作品。
[From: http://www.andrewsgibson.com/blog/2016/01/the-power-of-the-black-white-landscape/]
","excerpt":"黑白摄影从古至今一直很流行，景观摄影是一大流派，许多摄影师选择拍摄单色照片。但黑色和白色在每张照片里的效果是不一样的。它需要时间和实践，提高你对黑色白色的理解。下面这些技巧将有助于你更好的拍摄黑白风景照片。 1.了解什么场景拍摄黑白照片更好 有了彩色景观照片，可以依靠色彩的力量来创造内容和兴趣。良好的色彩景观摄影的关键是找到一个值得拍摄的场景，并有最美丽的光作支撑。这就是为什么这么多的彩色景观照片是在黄金时段或日落后拍摄的。 黑白是不同的。没有颜色，你就必须更加努力地创造出强大的作品。你需要学习寻找摄影构图的技巧，如引线，形状，图案，色调对比度和纹","img":["/img/large/31ad11c8-debb-4f61-973d-4bd892c69520.jpg","/img/large/f3eaf83c-9515-49e3-a550-2b42e216acd7.jpg","/img/large/f7c6c9d6-9da4-4d9a-b655-3c4bddec20fc.jpg","/img/large/b276c816-562d-4a1a-b5e9-24b415d63926.jpg","/img/large/b1e561be-ab30-4d91-978b-62e47492538e.jpg","/img/large/0e9ffe97-0abc-4176-86d8-ac9e27e699fa.jpg","/img/large/34cc3b0f-bd43-4091-8e58-416fc9eed2cd.jpg","/img/large/4b77b067-647a-4076-8446-3950627e23bd.jpg","/img/large/6e0b277c-d3aa-4c04-b255-2157cfb3d99d.jpg"],"title":"黑白摄影技巧","author":"Andrew S. Gibson","type":"essay","en_gallery":true,"enable":true,"tag":["摄影"],"thumb":["/img/thumb/31ad11c8-debb-4f61-973d-4bd892c69520.jpg","/img/thumb/f3eaf83c-9515-49e3-a550-2b42e216acd7.jpg","/img/thumb/f7c6c9d6-9da4-4d9a-b655-3c4bddec20fc.jpg","/img/thumb/b276c816-562d-4a1a-b5e9-24b415d63926.jpg","/img/thumb/b1e561be-ab30-4d91-978b-62e47492538e.jpg","/img/thumb/0e9ffe97-0abc-4176-86d8-ac9e27e699fa.jpg","/img/thumb/34cc3b0f-bd43-4091-8e58-416fc9eed2cd.jpg","/img/thumb/4b77b067-647a-4076-8446-3950627e23bd.jpg","/img/thumb/6e0b277c-d3aa-4c04-b255-2157cfb3d99d.jpg"],"mid":["/img/mid/31ad11c8-debb-4f61-973d-4bd892c69520.jpg","/img/mid/f3eaf83c-9515-49e3-a550-2b42e216acd7.jpg","/img/mid/f7c6c9d6-9da4-4d9a-b655-3c4bddec20fc.jpg","/img/mid/b276c816-562d-4a1a-b5e9-24b415d63926.jpg","/img/mid/b1e561be-ab30-4d91-978b-62e47492538e.jpg","/img/mid/0e9ffe97-0abc-4176-86d8-ac9e27e699fa.jpg","/img/mid/34cc3b0f-bd43-4091-8e58-416fc9eed2cd.jpg","/img/mid/4b77b067-647a-4076-8446-3950627e23bd.jpg","/img/mid/6e0b277c-d3aa-4c04-b255-2157cfb3d99d.jpg"],"raw":["/img/31ad11c8-debb-4f61-973d-4bd892c69520.jpg","/img/f3eaf83c-9515-49e3-a550-2b42e216acd7.jpg","/img/f7c6c9d6-9da4-4d9a-b655-3c4bddec20fc.jpg","/img/b276c816-562d-4a1a-b5e9-24b415d63926.jpg","/img/b1e561be-ab30-4d91-978b-62e47492538e.jpg","/img/0e9ffe97-0abc-4176-86d8-ac9e27e699fa.jpg","/img/34cc3b0f-bd43-4091-8e58-416fc9eed2cd.jpg","/img/4b77b067-647a-4076-8446-3950627e23bd.jpg","/img/6e0b277c-d3aa-4c04-b255-2157cfb3d99d.jpg"],"createdAt":"2020-05-07T06:41:30.975Z","updatedAt":"2020-05-07T06:41:30.975Z","pv_count":1573,"id":"5eb3ad9a82b94de52f13b5ff"},{"content":"Русское слово
2015-7-20
1. Июль : July
2. Аигуст : Autumn
3. фотография : photograph
4. вода : water
5. адрес : address
6. автобус : bus
7. английски : English
8. без : not exist, have not [thing]
9. воздух : the air
10. ветер : wind, breeze
11. На свете : On the world,
12. На : on the ...
13. фильмов : movie，film
2015-7-21
14. Элегантные девушка ： elegant girl
15. девушка ：girl
16. дурак :【阳】 fool ,stupid guy； дура： 【阴】; дурацкий 【形容词】
17. очень красивый : very nice ,beautiful
18. самая ： the most xxx
19. сексуальная женщина ： sexy women
20. мира ： the world
2015-7-24
21. жаркая погода : hot weather
22. В моей комнате : in my room
23. большой : big, large
24. магазин ： shop, store
25. жаркая ： hot
2015-7-26
26. Я учусь ： I‘m studying
2015-7-27
27. Доброе утро : good morning
28. Привет : hi, hello
29. Спасибо : thanks
30. Нормально : fine , I am fine
31. восхитительна : happy, pleasure
32. добрый день : good afternoon
33. где учил русский язык ? 在哪儿学的俄语吗？
34. Я могу говорить простой русский
eg.
ах, русский язык ? Я могу говорить простой русский )) Я больше знаю с английского и китайский .
啊，俄语吗？我能说简单的俄语））我更知道英语和中文
35. Ты в пекин? : Are you in Beijing ？
36. русский язык очень интересно ： Russian is interesting
37. Да, я живу Пекине : Yes, I live in Beijing.
38. в минувшие выходные я пошел плавать ： I went swimming on last weekend
39. Ты где работаешь ? ： where do you work ?
40. работаешь ： work, do jobs
41. Какие метро станция ты живешь рядом? : which subway station do you live near?
42. Я только пришел домой с работы ： 我刚下班回家
43. кушай и отдыхай : eating and reset
44. Шел дождь . : It is raining.
45. Я чувствую себя очень комфортно : I feel very comfortable .
46. ты был в России ? : 你曾经在俄罗斯吗？
47. Сейчас на улице очень хорошо 😌 не жарко ： 现在大街上是很不错的😌不热
48. Почему ？： why？
49. когда вы пришли в Пекин?
50. Ты где учил русский язык ?
51. Ты умеешь разговаривать по русски ? : Can you speak in Russian?
52. больше общайся с русскими друзьями : 更多的沟通与俄罗斯朋友
53. Хорошо ： OK
54. Я хочу поехать в Москву : I want to go to Moscow
55. Приятного аппетита : 好好享受吃好
56. Спасибо, вы очень добры : thanks, you are so kind
57. место дая тебя : the place gives to you
58. любят ： like， like to do, love
59. нравлюсь ： like some one， love some one
60. то что ваш любимый китайской кушанье? ： what is your favorite Chinese dish?
61. познакомиться : 认识，熟悉
2015-7-30
62. Мне очень нравится китайская кухня ： I really like Chinese food
63. Мне все нравися ： I like everything
64. Я люблю фотографию : I love photograph
65. Отобразить некоторые фотографию : show some photograph
2015-8-2
66. Привет, друг. Я найду тебя в VK : Hi， friend. I find you on VK
67. Я люблю тебя ： I love you
68. Извините： sorry
==================================
2015-9-4
69. Сегодня день рождения у Tom : Today is Tom's birthday.
2015-9-10
70. Добрый вечер： good evening
71. доброй ночи: good night
2015-9-14
72. До свидания： good bye
2015 - 10 -28
- Это дом. :This is room
- Это он. this is him
2015-10-31
как поживаете эти дни ？: how are these days ?
2015-11-30
прекрасный 非常好看的，漂亮的 ~ая женщина非常漂亮的女人.
去年公司在三元桥远洋新干线的时候，在楼下溜达时看到的，可爱的萝莉和正太，老爸领着在下面玩
1. 奔跑
![\"1.jpg\"](\"/img/large/b12bc630-59e1-4c7f-a696-2585b47471d9.jpg\")
2. 看
![\"2.jpg\"](\"/img/large/9d8bc092-3dc9-4d14-8628-4897bb8afe4f.jpg\")
3. 害羞
![\"3.jpg\"](\"/img/large/82901e1e-e2a8-4ed3-b6b6-e3446a7be949.jpg\")
1. 选择一个焦点
自动对焦时，相机会选取最近镜头的物体来对焦，容易造成对焦不准的情况，所以把自动对焦模式抛弃使用吧。选择一个对焦点，这是摄影人必须要学会的。
![\"793d5ac1-4f4d-4d76-9448-d68bd0fb0077.jpg\"](\"http://karat.cc/img/575957eb-a1ab-4b89-ae27-89c4ef6c549d.jpg\")
2. 把焦点放在眼睛
眼睛是心灵的窗口。眼睛是脸上最敏锐的一个点，也是好照片最重要的部分。当光圈全开时，把焦点堆在眼睛，连皮肤都会模糊起来，这时候你也可以为磨皮省事了。
![\"9015eee1-e203-45c2-9cc3-734c6c17d412.jpg\"](\"http://karat.cc/img/4534a01f-c07d-4e87-bcb1-8f518bb8f6b5.jpg\")
3. 全开光圈，小景深
有相当多理由的理由给你去买一个大光圈的镜头。最能引起共识的就是为了拍摄小景深效果。令人惊讶的光线效果和迷人的背景模糊，都能从大光圈里获得。
![\"5a3abbc2-fbce-4daa-9d35-b8f067dc456d.jpg\"](\"/img/a2edeffb-e0c7-49fe-ac80-f7548c1182f9.jpg\")
4. 尝试用70mm或以上的镜头拍摄
很多mm 看完照片后都会有这样的疑问：“为什么我的脸看上去肿了?” 。任何70mm以下的镜头拍摄都会引起不同程度的变形。长焦会产生压缩空间的效果，也能加深背景的模糊。
![\"4}@T`@G_D[%9)Z6BRVFA85Y.jpg\"](\"/img/abc16db5-4327-4601-bb37-fc2bd921ce8e.jpg\")
![\"bd4daef1cf63f6d5a020f34684183336.jpg\"](\"http://karat.cc/img/7111514a-71ca-42c7-afa2-faba79675a66.jpg\")
![\"2cb92c03-8314-499b-b082-bb78427134c7.jpg\"](\"http://karat.cc/img/e6a4dba5-6827-49a7-ad06-c7e3302302ae.jpg\")
![\"M$(7VI~KNRG6_8{Y3BLJOON.jpg\"](\"/img/e2385c65-ffb1-4a03-ad91-1d7f5d74da35.jpg\")
![\"4692dcc7-63c2-44dd-9ebd-ad4cf5de4c46.jpg\"](\"/img/fd44f342-df03-4ff5-a22d-199f61bf027c.jpg\")
![\"`7OB7BBP@1UK]6`[T[~_`C6.jpg\"](\"/img/641f6b22-5e55-49dc-83f5-7122a2784aa1.jpg\")
![\"222.jpg\"](\"http://karat.cc/img/4c7233aa-39be-49b9-9a55-8dddb8413541.jpg\")
![\"bf07033e-f6e0-4098-84a9-7a0bca2ba959.jpg\"](\"/img/747244bc-6d45-4862-850a-c669772d6d19.jpg\")
作者： 阮一峰
你遇到过性能很差的网页吗？
这种网页响应非常缓慢，占用大量的CPU和内存，浏览起来常常有卡顿，页面的动画效果也不流畅。
![\"\"](\"http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091508.jpg\")
你会有什么反应？我猜想，大多数用户会关闭这个页面，改为访问其他网站。作为一个开发者，肯定不愿意看到这种情况，那么怎样才能提高性能呢？
本文将详细介绍性能问题的出现原因，以及解决方法。
要理解网页性能为什么不好，就要了解网页是怎么生成的。
![\"\"](\"http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091501.png\")
网页的生成过程，大致可以分成五步。
- HTML代码转化成DOM
- CSS代码转化成CSSOM（CSS Object Model）
- 结合DOM和CSSOM，生成一棵渲染树（包含每个节点的视觉信息）
- 生成布局（layout），即将所有渲染树的所有节点进行平面合成
- 将布局绘制（paint）在屏幕上
这五步里面，第一步到第三步都非常快，耗时的是第四步和第五步。
\"生成布局\"（flow）和\"绘制\"（paint）这两步，合称为\"渲染\"（render）。
![\"\"](\"http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091502.png\")
网页生成的时候，至少会渲染一次。用户访问的过程中，还会不断重新渲染。
以下三种情况，会导致网页重新渲染。
- 修改DOM
- 修改样式表
- 用户事件（比如鼠标悬停、页面滚动、输入框键入文字、改变窗口大小等等）
重新渲染，就需要重新生成布局和重新绘制。前者叫做\"重排\"（reflow），后者叫做\"重绘\"（repaint）。
需要注意的是，\"重绘\"不一定需要\"重排\"，比如改变某个网页元素的颜色，就只会触发\"重绘\"，不会触发\"重排\"，因为布局没有改变。但是，\"重排\"必然导致\"重绘\"，比如改变一个网页元素的位置，就会同时触发\"重排\"和\"重绘\"，因为布局改变了。
重排和重绘会不断触发，这是不可避免的。但是，它们非常耗费资源，是导致网页性能低下的根本原因。
提高网页性能，就是要降低\"重排\"和\"重绘\"的频率和成本，尽量少触发重新渲染。
前面提到，DOM变动和样式变动，都会触发重新渲染。但是，浏览器已经很智能了，会尽量把所有的变动集中在一起，排成一个队列，然后一次性执行，尽量避免多次重新渲染。
div.style.color = 'blue';\ndiv.style.marginTop = '30px';\n
上面代码中，div元素有两个样式变动，但是浏览器只会触发一次重排和重绘。
如果写得不好，就会触发两次重排和重绘。
div.style.color = 'blue';\nvar margin = parseInt(div.style.marginTop);\ndiv.style.marginTop = (margin + 10) + 'px';\n
上面代码对div元素设置背景色以后，第二行要求浏览器给出该元素的位置，所以浏览器不得不立即重排。
一般来说，样式的写操作之后，如果有下面这些属性的读操作，都会引发浏览器立即重新渲染。
- offsetTop/offsetLeft/offsetWidth/offsetHeight
- scrollTop/scrollLeft/scrollWidth/scrollHeight
- clientTop/clientLeft/clientWidth/clientHeight
- getComputedStyle()
所以，从性能角度考虑，尽量不要把读操作和写操作，放在一个语句里面。
\n// bad\ndiv.style.left = div.offsetLeft + 10 + \"px\";\ndiv.style.top = div.offsetTop + 10 + \"px\";\n\n// good\nvar left = div.offsetLeft;\nvar top = div.offsetTop;\ndiv.style.left = left + 10 + \"px\";\ndiv.style.top = top + 10 + \"px\";\n
一般的规则是：
- 样式表越简单，重排和重绘就越快。
- 重排和重绘的DOM元素层级越高，成本就越高。
- table元素的重排和重绘成本，要高于div元素
有一些技巧，可以降低浏览器重新渲染的频率和成本。
第一条是上一节说到的，DOM 的多个读操作（或多个写操作），应该放在一起。不要两个读操作之间，加入一个写操作。
第二条，如果某个样式是通过重排得到的，那么最好缓存结果。避免下一次用到的时候，浏览器又要重排。
第三条，不要一条条地改变样式，而要通过改变class，或者csstext属性，一次性地改变样式。
\n// bad\nvar left = 10;\nvar top = 10;\nel.style.left = left + \"px\";\nel.style.top = top + \"px\";\n\n// good \nel.className += \" theclassname\";\n\n// good\nel.style.cssText += \"; left: \" + left + \"px; top: \" + top + \"px;\";\n
第四条，尽量使用离线DOM，而不是真实的网面DOM，来改变元素样式。比如，操作Document Fragment对象，完成后再把这个对象加入DOM。再比如，使用 cloneNode() 方法，在克隆的节点上进行操作，然后再用克隆的节点替换原始节点。
第五条，先将元素设为display: none（需要1次重排和重绘），然后对这个节点进行100次操作，最后再恢复显示（需要1次重排和重绘）。这样一来，你就用两次重新渲染，取代了可能高达100次的重新渲染。
第六条，position属性为absolute或fixed的元素，重排的开销会比较小，因为不用考虑它对其他元素的影响。
第七条，只在必要的时候，才将元素的display属性为可见，因为不可见的元素不影响重排和重绘。另外，visibility : hidden的元素只对重绘有影响，不影响重排。
第八条，使用虚拟DOM的脚本库，比如React等。
第九条，使用 window.requestAnimationFrame()、window.requestIdleCallback() 这两个方法调节重新渲染（详见后文）。
很多时候，密集的重新渲染是无法避免的，比如scroll事件的回调函数和网页动画。
网页动画的每一帧（frame）都是一次重新渲染。每秒低于24帧的动画，人眼就能感受到停顿。一般的网页动画，需要达到每秒30帧到60帧的频率，才能比较流畅。如果能达到每秒70帧甚至80帧，就会极其流畅。
![\"\"](\"http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091509.jpg\")
大多数显示器的刷新频率是60Hz，为了与系统一致，以及节省电力，浏览器会自动按照这个频率，刷新动画（如果可以做到的话）。
![\"\"](\"http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091510.jpg\")
所以，如果网页动画能够做到每秒60帧，就会跟显示器同步刷新，达到最佳的视觉效果。这意味着，一秒之内进行60次重新渲染，每次重新渲染的时间不能超过16.66毫秒。
![\"\"](\"http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091511.png\")
一秒之间能够完成多少次重新渲染，这个指标就被称为\"刷新率\"，英文为FPS（frame per second）。60次重新渲染，就是60FPS。
如果想达到60帧的刷新率，就意味着JavaScript线程每个任务的耗时，必须少于16毫秒。一个解决办法是使用Web Worker，主线程只用于UI渲染，然后跟UI渲染不相干的任务，都放在Worker线程。
Chrome浏览器开发者工具的Timeline面板，是查看\"刷新率\"的最佳工具。这一节介绍如何使用这个工具。
首先，按下 F12 打开\"开发者工具\"，切换到Timeline面板。
![\"\"](\"http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091512.png\")
左上角有一个灰色的圆点，这是录制按钮，按下它会变成红色。然后，在网页上进行一些操作，再按一次按钮完成录制。
Timeline面板提供两种查看方式：横条的是\"事件模式\"（Event Mode），显示重新渲染的各种事件所耗费的时间；竖条的是\"帧模式\"（Frame Mode），显示每一帧的时间耗费在哪里。
先看\"事件模式\"，你可以从中判断，性能问题发生在哪个环节，是JavaScript的执行，还是渲染？
![\"\"](\"http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091514.png\")
不同的颜色表示不同的事件。
![\"\"](\"http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091503.png\")
- 蓝色：网络通信和HTML解析
- 黄色：JavaScript执行
- 紫色：样式计算和布局，即重排
- 绿色：重绘
哪种色块比较多，就说明性能耗费在那里。色块越长，问题越大。
![\"\"](\"http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091515.png\")
![\"\"](\"http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091516.png\")
帧模式（Frames mode）用来查看单个帧的耗时情况。每帧的色柱高度越低越好，表示耗时少。
![\"\"](\"http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091505.png\")
你可以看到，帧模式有两条水平的参考线。
![\"\"](\"http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091517.png\")
下面的一条是60FPS，低于这条线，可以达到每秒60帧；上面的一条是30FPS，低于这条线，可以达到每秒30次渲染。如果色柱都超过30FPS，这个网页就有性能问题了。
此外，还可以查看某个区间的耗时情况。
![\"\"](\"http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091518.png\")
或者点击每一帧，查看该帧的时间构成。
![\"\"](\"http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091519.png\")
有一些JavaScript方法可以调节重新渲染，大幅提高网页性能。
其中最重要的，就是 window.requestAnimationFrame() 方法。它可以将某些代码放到下一次重新渲染时执行。
function doubleHeight(element) {\n var currentHeight = element.clientHeight;\n element.style.height = (currentHeight * 2) + 'px';\n}\nelements.forEach(doubleHeight);\n
上面的代码使用循环操作，将每个元素的高度都增加一倍。可是，每次循环都是，读操作后面跟着一个写操作。这会在短时间内触发大量的重新渲染，显然对于网页性能很不利。
我们可以使用window.requestAnimationFrame()，让读操作和写操作分离，把所有的写操作放到下一次重新渲染。
function doubleHeight(element) {\n var currentHeight = element.clientHeight;\n window.requestAnimationFrame(function () {\n element.style.height = (currentHeight * 2) + 'px';\n });\n}\nelements.forEach(doubleHeight);\n
页面滚动事件（scroll）的监听函数，就很适合用 window.requestAnimationFrame() ，推迟到下一次重新渲染。
$(window).on('scroll', function() {\n window.requestAnimationFrame(scrollHandler);\n});\n
当然，最适用的场合还是网页动画。下面是一个旋转动画的例子，元素每一帧旋转1度。
var rAF = window.requestAnimationFrame;\n\nvar degrees = 0;\nfunction update() {\n div.style.transform = \"rotate(\" + degrees + \"deg)\";\n console.log('updated to degrees ' + degrees);\n degrees = degrees + 1;\n rAF(update);\n}\nrAF(update);\n
还有一个函数window.requestIdleCallback()，也可以用来调节重新渲染。
它指定只有当一帧的末尾有空闲时间，才会执行回调函数。
requestIdleCallback(fn);\n
上面代码中，只有当前帧的运行时间小于16.66ms时，函数fn才会执行。否则，就推迟到下一帧，如果下一帧也没有空闲时间，就推迟到下下一帧，以此类推。
它还可以接受第二个参数，表示指定的毫秒数。如果在指定 的这段时间之内，每一帧都没有空闲时间，那么函数fn将会强制执行。
requestIdleCallback(fn, 5000);\n
上面的代码表示，函数fn最迟会在5000毫秒之后执行。
函数 fn 可以接受一个 deadline 对象作为参数。
requestIdleCallback(function someHeavyComputation(deadline) {\n while(deadline.timeRemaining() > 0) {\n doWorkIfNeeded();\n }\n\n if(thereIsMoreWorkToDo) {\n requestIdleCallback(someHeavyComputation);\n }\n});\n
上面代码中，回调函数 someHeavyComputation 的参数是一个 deadline 对象。
deadline对象有一个方法和一个属性：timeRemaining() 和 didTimeout。
（1）timeRemaining() 方法
timeRemaining() 方法返回当前帧还剩余的毫秒。这个方法只能读，不能写，而且会动态更新。因此可以不断检查这个属性，如果还有剩余时间的话，就不断执行某些任务。一旦这个属性等于0，就把任务分配到下一轮requestIdleCallback。
前面的示例代码之中，只要当前帧还有空闲时间，就不断调用doWorkIfNeeded方法。一旦没有空闲时间，但是任务还没有全执行，就分配到下一轮requestIdleCallback。
（2）didTimeout属性
deadline对象的 didTimeout 属性会返回一个布尔值，表示指定的时间是否过期。这意味着，如果回调函数由于指定时间过期而触发，那么你会得到两个结果。
- timeRemaining方法返回0
- didTimeout 属性等于 true
因此，如果回调函数执行了，无非是两种原因：当前帧有空闲时间，或者指定时间到了。
function myNonEssentialWork (deadline) {\n while ((deadline.timeRemaining() > 0 || deadline.didTimeout) && tasks.length > 0)\n doWorkIfNeeded();\n\n if (tasks.length > 0)\n requestIdleCallback(myNonEssentialWork);\n}\n\nrequestIdleCallback(myNonEssentialWork, 5000);\n
上面代码确保了，doWorkIfNeeded 函数一定会在将来某个比较空闲的时间（或者在指定时间过期后）得到反复执行。
requestIdleCallback 是一个很新的函数，刚刚引入标准，目前只有Chrome支持，不过其他浏览器可以用垫片库。
（完）
","excerpt":"转自：http://www.ruanyifeng.com/blog/2015/09/web-page-performance-in-depth.html作者： 阮一峰 你遇到过性能很差的网页吗？这种网页响应非常缓慢，占用大量的CPU和内存，浏览起来常常有卡顿，页面的动画效果也不流畅。你会有什么反应？我猜想，大多数用户会关闭这个页面，改为访问其他网站。作为一个开发者，肯定不愿意看到这种情况，那么怎样才能提高性能呢？本文将详细介绍性能问题的出现原因，以及解决方法。一、网页生成的过程要理解网页性能为什么不好，就要了解网页是怎么生成的。网页的生成过程，大致可以分","img":["http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091508.jpg","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091501.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091502.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091509.jpg","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091510.jpg","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091511.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091512.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091514.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091503.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091515.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091516.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091505.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091517.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091518.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091519.png"],"title":"网页性能管理详解","author":"阮一峰 ","type":"tech","en_gallery":false,"enable":true,"tag":["前端","Web"],"thumb":["http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091508.jpg","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091501.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091502.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091509.jpg","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091510.jpg","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091511.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091512.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091514.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091503.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091515.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091516.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091505.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091517.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091518.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091519.png"],"mid":["http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091508.jpg","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091501.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091502.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091509.jpg","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091510.jpg","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091511.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091512.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091514.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091503.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091515.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091516.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091505.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091517.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091518.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091519.png"],"raw":["http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091508.jpg","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091501.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091502.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091509.jpg","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091510.jpg","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091511.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091512.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091514.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091503.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091515.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091516.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091505.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091517.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091518.png","http://www.ruanyifeng.com/blogimg/asset/2015/bg2015091519.png"],"createdAt":"2015-12-05T05:08:25.460Z","updatedAt":"2015-12-05T05:11:48.574Z","pv_count":1324,"article_id":"56627149dbde3d97180380d3","id":"56627149dbde3d97180380d3"},{"content":"![\"4a7f6fdbd58b4b29a783b9530e83d99c.jpg\"](\"/img/large/6f868e96-67e7-4da0-b92a-56f5dc73ae56.jpg\")
所谓人像摄影，就是以人物为主要创作对象的摄影形式。人像摄影与一般的人物摄影不同：人像摄影以刻画与表现被摄者的具体相貌和神态为自身的首要创作任务，虽然有些人像摄影作品也包含一定的情节，但它仍以表现被照者的相貌为主。那么，我们今天来讨论下人像的相机参数吧！
标准的人像摄影镜头，一般是指在镜头1.5m—2m的距离上照人的镜头，也就是70mm-135mm的镜头。按照一般的美学观点，在1.5至2米外看一个人的五官是最漂亮的。比方说如果想要拍摄带环境的人像，建议选择 50mm 以下的镜头，而如果想要拍半身以上的肖像照并且有很明显的虚化将主体和背景分离，那么 85mm 以上的中长焦镜头可能是更好的选择。
![\"2954a9b0c96f4a458cb1b6d2ddfd12a6.jpg\"](\"/img/large/173b8f80-20ea-408f-b160-6ca917f5aa51.jpg\")
好用的头就是又容易与被拍摄人沟通，又不发生明显的变形的镜头。
对于135相机来说，70mm-135mm镜头是公认的人像镜头。
而对于APS-C相机来说，因为同样的镜头能得到的像场比135相机小，所以50mm-90mm焦距的135相机镜头才是APS-C相机的人像镜头。
那如果是拍儿童呢？按理说我们要用比普通人像镜头焦距更大（放大倍数更大）的镜头才能使小孩的头肩充满整个像场，但是由于儿童的五官没有成人那么突出，我们可以在更近的距离拍摄而不影响审美，所以我们用普通人像镜头在1米外拍就行了。
![\"8f2174d3f3e54c35b98d36479b006b60.jpg\"](\"/img/large/6e6aa160-73e0-4d32-a354-b66e55cb5a1a.jpg\")
想要背景虚化，仅仅靠开大光圈是不够的，它需要满足三个要素，一是光圈，还有就是镜头的焦段和主体的位置。
简单来说，在其他两个元素不变的前提下，光圈越大，景深越浅，虚化效果就越明显。
同样的，镜头的焦段越长，虚化效果也就越明显，比方说，在人像在画面中的大小不变的前提下，85mm f/2.8 的虚化效果肯定要比 50mm f/2.8 的虚化效果要好，而就算是 35mm f/2 的虚化效果，可能都不如 85mm f/4 的虚化效果来的好。
![\"47ecb8adf9004a6cbd67cdda7d7932ea.jpg\"](\"/img/large/66db5f18-6bdb-4fd4-b761-26bdda06fd44.jpg\")
而想要拍出更明显的虚化效果，还需要第三个要素作用，就是被摄主体的位置，同样，也是在其他两个要素相同的前提下，主体距离拍摄者（相机）越近，或者主体距离背景越远，虚化效果就越明显。
但是要明确的一个观点是，并不是景深越浅越好，就拿肖像照来说，太浅的景深也会导致面部部分失去焦点，同时也并不是所有镜头都是最大光圈可用的，大部分镜头开足光圈会不可避免的带来锐度的损失，让画面模糊，一切都还是要以合适为主，不能一味的追求极端。
![\"4e657d161c5e487aa6f33ba7a42f232f.jpg\"](\"/img/large/93fcfcc0-e796-4a80-9688-b201f72d30a8.jpg\")
在光线充足的环境下，快门并不是一个很重要的问题，拍摄静止人像的时候，在安全快门以上就可以，但是如果想要拍摄运动中的人像，就得提高快门速度，如果是弱光环境，会比较难办，只能通过开大光圈或者增加感光度来解决。但是有的时候即使光圈开到最大也不足以满足快门，感光度拉的太高又会影响画质，因此在弱光环境下拍摄还是要多试验，根据现场光线来选择最合适的设置以免拍出自己并不满意的照片。
虽然在弱光环境下并不容易捕捉高速运动中的人，但是我们也可以利用慢快门来捕捉人物运动的轨迹。思想是活的，就看你能想到什么样的画面，然后用技术去实现它。
![\"26b20b950f034f488dece6488043af96.jpg\"](\"/img/large/3e7fc3d0-4b5e-45d4-895e-ecc6a96005df.jpg\")
而感光度则是一个更加单纯的因素，每一台相机的高感的处理能力都不同，有些相机可以使用高达 6400 的感光度也能够拍出让自己满意的画面，而有些相机感光度超过 1600 可能就难以接受。拉高感光度所产生的噪点不同于胶片产生的颗粒，胶片颗粒的规则性会带来一定的美感，而杂乱的噪点只会让人想到古老电视机屏幕上的雪花点，看起来很不舒服。因此，高感的选择取决于你对你自己的相机的理解，在你认为可以接受的高感范围内，选择合适的感光度。
![\"0905ef1735004c7190e2c1e26cd833ca.jpg\"](\"/img/large/ef528c18-2546-4936-b267-293c9a6b6628.jpg\")