最近重温《凡人修仙传》，韩立缔结元婴的篇章令人感慨万千。一位灵根平凡、谨小慎微的修仙者，凭借坚定的道心和不懈的努力，终于踏上修仙巅峰。回望韩立的结婴之路，灵根、炼丹、法宝、符箓、资源、运气，缺一不可。无数修仙者中，能登顶者寥寥无几，韩立的成功离不开天时、地利、人和，更离不开他善于隐藏、把握时机的智慧和刻苦修炼的毅力。

大道是自己走出来的，但成败往往取决于内外因的交织。这与交易之路何其相似！

交易之路：从偶然盈利到长期生存

交易市场如修仙世界，短期盈利或许不难，但要实现持续的成功却需付出巨大努力。交易的成功离不开以下要素：

• 稳定的交易策略：通过实践打磨出可执行、可持续的交易体系。
• 极致的风险管理：在市场波动中保持理性和纪律，控制每一笔交易的风险。
• 情绪的磨砺：克服贪婪与恐惧，修炼一颗“交易道心”。
• 持续的学习：洞悉市场逻辑，紧跟变化，保持竞争力。

只有在这些方面下足功夫，才能在变幻莫测的市场中长期生存。

个人经历：从迷茫到破局

在经济下行、互联网寒冬和“35岁危机”的多重压力下，我终于完成了硕士论文，却面临长达两年的职业空窗期。这段时间，我尝试了A股、港股、美股、国内期货市场和外汇交易，学习了CFA一级课程，研究了文华财经、TBQuant、聚宽、QMT、MT4/MT5等平台，编写了数十个交易策略。然而，资源的有限与市场的无限让我深刻体会到个人精力的渺小。

曾几何时，听到新闻报道全国有1亿多人月收入不足1000元，我拿着2万元的月薪觉得不可思议。但当空有理想却换不来“馒头”时，我才明白自己也可能成为“可笑之人”。这让我理解了为何许多中年人会选择进入A股或沉迷赌博——当向上的通道被锁死，搏命似乎成了另一种出路。

转机与感悟：回归本职与交易的平衡

幸运的是，在储蓄几乎耗尽之际，我得到了现在公司的机会，找到了一份稳定的本职工作，解决了现金流的燃眉之急。稳定的收入让我无需通过频繁交易来谋生，从而能更专注于完善交易策略。最近，我完成了一次FTMO模拟账号挑战，收益率曲线颇为优美，这让我对再次启动实盘交易充满信心。

以下是我的最新FTMO模拟账号挑战结果：

凡人交易：与市场共舞，尽人事听天命

“你我皆凡人”。交易之路是与人性、与市场的博弈。市场瞬息万变，我们只能不断适应、跟随。对于普通人而言，照顾好家庭已需耗费巨大心力，能否实现财富自由往往需要“尽人事，听天命”。

最后，我想与大家分享《天道》中的一首自嘲诗，愿我们都能在平凡中坚守，在市场中砥砺前行：

本是后山人，偶作前堂客。
醉舞经阁半卷书，坐井说天阔。
大志戏功名，海斗量福祸。
论到囊中羞涩时，怒指乾坤错。

前言

从结束创业合伙人的身份，到裸辞跨城市找工作，已经有两个月的时间了。创业3年的感悟，还不如这两个月来得猛烈。人间酸甜苦辣，都深深的尝了一遍。

第一次深刻感觉病不起，缺钱是多么的无助！这也是为什么我在别人逃离一线城市的时候，反而离开家人，只身前往上海的主要原因。

我只想在下次风暴来临之前，拥有足够的资本来抵抗风险。

1.裸辞，离开合伙创办的公司

当你的技术创新促进不了业务的发展，或者业务不足以让你有更好的发挥，那么你就变得可有可无，危机感也就随之而来。

作为技术合伙创办公司的创始人之一，占有少量股份，决定权和主导权都不在自己的手上。公司不上市，股份不会变现，约定也都是一纸空谈。所以创业很考验是否跟对人，和合伙人的职业素养。

当商用的只是你能力的一下部分，自己的能力没有办法进一步提舍，你自己主导的产品一直处于自嗨状态，那么离开只是早晚的事。

因为已经觉得是在浪费时间，所以妻子问我是否后悔裸辞，我说依然坚定的说不后悔。

2.裸辞，遇上感冒和手术

也许人生就是这么奇妙，你永远不知道下一刻迎接你的是什么？

本来决定在金三的月份开启新的旅程。在裸辞之后，决定找外地工作之前，决定先带小孩去复查，得出的诊断结果是：需要立即住院进行手术。

然后这段求职之旅就在：
– 职业选择：ios/前端开发，
– 区域选择：上海/杭州/武汉，
– 时间选择：等待手术期间/手术后

这三个选择中徘徊，兼顾家庭(武汉找)，还是父母团聚(杭州)，还是选择发展(上海)。

遇上流感高发，我和小宝都重度感冒了，还相互传染。而手术要避免炎症，再加上医院排队手术，整个时间跨度足足有一个半月。这段时间，整个家庭都处在压抑的阴霾下，无法释怀、无心工作。

长时间的失业担忧，手术风险，金钱的压力，当手术顺利结束的回家的那一刻，压抑的心情释放一大部分，终于可以无顾忌的放手一博。

3.裸辞找工作

也许这是找工作最纠结的一次。也暴露了创业带来的严重技术脱节。

这职场从来是凭本事说话。当我在幻想回到2年IOS研发，主推IOS开发，简历却无人问津；职场对3年的高级前端岗位需求和热度明显更高。

前期的准备不足，导致期间进行过蚂蚁金服的两次岗位电话面试，均以惨败收场，只能对推荐人报以深深的歉意。不知ES6、不用框架(ReactJS、VueJS、AngularJS三选其一)、不涉及太多js编码，面试表现得一塌糊涂。这反而激发我在这1个多月的时间内，专门研究React技术栈开发和学习ES6语法。

每一次面试，都是和技术人员的一次深度交流。面试多家公司，持续的积累面经，终于对面试游刃有余。感谢找油网CTO提供的职业建议，唯有选定一个方向的进行技术专精，才有更多的余力进行技术拓展。面试，和面试官聊第一句话就可以决定去留。

很感谢现在的公司提供的平台、负责招聘的架构师和直属领导。从他们身上有很多可以学习的职业化的东西，可以持续自我提升的地方。现在所做的一切，是在为你的明天加分，那么一切都值得。

跨区域找工作这段时间，时间越长，家人和周围人给自己的压力越大。当接到心仪的公司offer的时候，一段时间以来累积的压力瞬间释放了。回首，才发觉在上海逗留才一周时间不到。

4.总结：创业的失与得

首先感谢每一段经历和遇见的人。失败，只是因为自己还不足够好，还缺少达到成功的能量！

总结这次合伙创业的失与得：

失：
1、改变了职业轨迹，从IOS研发，转成了前端开发；从研发产品，变成了项目交付驱动，导致技术深度没办法很好的积累和转化；
2、title虽然是开发总监，但品牌溢价不够；
3、长时间的业务驱动，很容易受项目影响。有项目忧心项目质量，没有项目忧心业务；
4、经历过创业，很多公司会将它作为稳定性的考量；
5、对之前拉入伙的同事，没有给到很好的交代。

得：
1、熟悉公司的基础运作流程和操作流程；
2、看穿商业运作的本质(资源、人脉、资金)；
3、掌握了一门新的开发语言；
4、自己的不成熟，需要经过失败来洗礼，才能变得更成熟；
5、更明确自己想要什么，和如何学会拒绝。

生活还在继续，唯一不变的是一颗想要生存和发展的心！
献给正在或即将创业的猿类，且行且珍惜！

进行jQuery插件开发前，首先要知道两个问题：什么是jQuery插件？jQuery插件如何使用？

第一个问题，jQuery插件就是用来扩展jQuery原型对象的一个方法，简单来说就是jQuery插件是jQuery对象的一个方法。其实回答了第一个问题，也就知道第二个问题的答案了，jQuery插件的使用方式就是jQuery对象方法的调用。

我们先看个例子：$("a").css("color","red")。我们知道每个jQuery对象都会包含jQuery中定义的DOM操作方法,这里使用$方法来选择a元素，返回一个a元素的jQuery对象，这个对象就可以使用jQuery中定义的DOM操作方法。那么jQuery对象是如何获取这些方法的呢？其实jQuery内部定义了一个jQuery.fn对象，查看jQuery源码可以发现jQuery.fn=jQuery.prototype，也就是说jQuery.fn对象是jQuery的原型对象,jQuery的DOM操作方法都在jQuery.fn对象上定义的，然后jQuery对象就可以通过原型继承这些方法。

基础版jQuery插件

知道了上面这些知识，我们就可以来写一个简单的jQuery插件。假如我现在需要一个jQuery插件用来改变标签内容颜色，就可以按下面的方式来实现这个插件：

$.fn.changeStyle = function(colorStr){
         this.css("color",colorStr);
}

然后按下面的方式来使用插件：

$("p").changeStyle("red");

插件调用的时候，插件内部的this就是当前调用插件的jQuery对象，这样的话每个使用$()方法选择的标签，在调用changeStyle()插件时都会使用css()方法重设color样式。

满足链式调用的jQuery插件

链式调用时jQuery的一大特色，一个通用的插件应该遵循jQuery风格，满足链式调用要求。实现链式调用的方式也很简单：

$.fn.changeStyle = function(colorStr){
         this.css("color",colorStr);
         return this;
}

然后使用的时候就可以链式调用其他方法了：

$("p").changeStyle("red").addClass("red-color");

实现链式调用的关键点就一行代码return this，插件中加了这行代码，那么在插件执行完之后，就会把当前的jQuery对象返回，然后就可以在插件方法后面继续调用其它jQuery方法。

防止$符号污染的jQuery插件

有很多js库都会使用$符号，虽然jQuery可以使用jQuery.noConflict()方法交出$符号的使用权，但是如果定义插件的时候，使用$.fn对象来定义的，那么这些插件使用的时候就会受到其它使用$变量的js库的影响。对于这种情况，我们可以使用立即执行函数通过传参的方式封装插件。形式如下：

(function($){
     $.fn.changeStyle = function(colorStr){
         this.css("color",colorStr);        
         return this;
     }
}(jQuery));

因为使用了立即执行函数，所以此时的$只属于这个立即执行函数的函数作用域，这样就可以避免$符号的污染。

可以接受参数的jQuery插件

继续上面的例子，假如我还想为这个插件添加一个设置标签元素内容文字大小的功能，那么我可以这么来实现：

(function($){
     $.fn.changeStyle = function(colorStr，fontSize){
            this.css("color",colorStr).css("fontSize",fontSize+"px");        
         return this;
     }
}(jQuery));

上面这种插件传参方式适用于参数比较少的情况，如果需要传给插件内部的参数比较多，我们可以定义一个参数对象，然后把需要传给插件的参数放在参数对象中。插件定义时如下：

(function($){
     $.fn.changeStyle = function(option){
         this.css("color",option.colorStr).css("fontSize",option.fontSize+"px");        
         return this;
     }

}(jQuery));

使用方式：$("p").changeStyle({colorStr:"red",fontSize:14});

把参数放到一个对象中传给插件还有一个好处就是我们可以在插件内部为一些参数定义一些缺省值，例如：

(function($){

     $.fn.changeStyle = function(option){
          var defaultSetting = { colorStr:"green",fontSize:12};
          var setting = $.extend(defaultSetting,option);
          this.css("color",setting.colorStr).css("fontSize",setting.fontSize+"px");        
         return this;
     }
}(jQuery));

上面的代码用到了$.extend方法，这个方法在这里的用法就是合并两个对象，即把后面一个对象的存在的属性值赋值给第一个对象，具体用法可以参考这里。$.extend方法还有一种作用是用来扩展jQuery对象本身。

这样定义的插件，我们在使用时如果不传fontSize，那么使用这个插件的jQuery对象标签的内容会被设置成默认的12px。

使用方式：$("p").changeStyle({colorStr:"red"});

注意：在为插件定义默认参数时，一定要把默认参数写在插件方法内部，这样默认参数的作用域就在插件内部。

总结

定义插件的方式除了上面说的用$.fn来定义，还有另外一种方式来定义插件，那就是使用$.fn.extend方法。类似下面的写法：

(function($){
     $.fn.extend({         
         changeStyle:function(option){             
         var defaultSetting = { colorStr:"green",fontSize:12};
         var setting = $.extend(defaultSetting,option);
         this.css("color",setting.colorStr).css("fontSize",setting.fontSize+"px");        
         return this; 
          }
     });
}(jQuery));

PS:$.extend方法和$.fn.extend方法都可以用来扩展jQuery功能，通过阅读jQuery源码我们可以发现这两个方法的本质区别，那就是$.extend方法是在jQuery全局对象上扩展方法，$.fn.extend方法是在$选择符选择的jQuery对象上扩展方法。所以扩展jQuery的公共方法一般用$.extend方法，定义插件一般用$.fn.extend方法。

参考资料

jQuery源码
How to Create a Basic Plugin

作者：留七七
链接：https://www.jianshu.com/p/518d424d4994
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

本文导航：

1. gulp的安装
2. 开始使用gulp
3. gulp的API介绍
4. 一些常用的gulp插件

1、gulp的安装

首先确保你已经正确安装了nodejs环境。然后以全局方式安装gulp：

npm install -g gulp

全局安装gulp后，还需要在每个要使用gulp的项目中都单独安装一次。把目录切换到你的项目文件夹中，然后在命令行中执行：

npm install gulp

如果想在安装的时候把gulp写进项目package.json文件的依赖中，则可以加上–save-dev：

npm install --save-dev gulp

这样就完成了gulp的安装。至于为什么在全局安装gulp后，还需要在项目中本地安装一次，有兴趣的可以看下stackoverflow上有人做出的回答：why-do-we-need-to-install-gulp-globally-and-locally、what-is-the-point-of-double-install-in-gulp。大体就是为了版本的灵活性，但如果没理解那也不必太去纠结这个问题，只需要知道通常我们是要这样做就行了。

2、开始使用gulp

2.1 建立gulpfile.js文件

就像gruntjs需要一个Gruntfile.js文件一样，gulp也需要一个文件作为它的主文件，在gulp中这个文件叫做gulpfile.js。新建一个文件名为gulpfile.js的文件，然后放到你的项目目录中。之后要做的事情就是在gulpfile.js文件中定义我们的任务了。下面是一个最简单的gulpfile.js文件内容示例，它定义了一个默认的任务。

var gulp = require('gulp');
gulp.task('default',function(){
    console.log('hello world');
});

此时我们的目录结构是这样子的：

├── gulpfile.js
├── node_modules
│ └── gulp
└── package.json

2.2 运行gulp任务

要运行gulp任务，只需切换到存放gulpfile.js文件的目录(windows平台请使用cmd或者Power Shell等工具)，然后在命令行中执行gulp命令就行了，gulp后面可以加上要执行的任务名，例如gulp task1，如果没有指定任务名，则会执行任务名为default的默认任务。

3、gulp的API介绍

使用gulp，仅需知道4个API即可：gulp.task(),gulp.src(),gulp.dest(),gulp.watch()，所以很容易就能掌握，但有几个地方需理解透彻才行，我会在下面一一说明。为了避免出现理解偏差，建议先看一遍官方文档。

3.1 gulp.src()

在介绍这个API之前我们首先来说一下Grunt.js和Gulp.js工作方式的一个区别。Grunt主要是以文件为媒介来运行它的工作流的，比如在Grunt中执行完一项任务后，会把结果写入到一个临时文件中，然后可以在这个临时文件内容的基础上执行其它任务，执行完成后又把结果写入到临时文件中，然后又以这个为基础继续执行其它任务…就这样反复下去。而在Gulp中，使用的是Nodejs中的stream(流)，首先获取到需要的stream，然后可以通过stream的pipe()方法把流导入到你想要的地方，比如Gulp的插件中，经过插件处理后的流又可以继续导入到其他插件中，当然也可以把流写入到文件中。所以Gulp是以stream为媒介的，它不需要频繁的生成临时文件，这也是Gulp的速度比Grunt快的一个原因。再回到正题上来，gulp.src()方法正是用来获取流的，但要注意这个流里的内容不是原始的文件流，而是一个虚拟文件对象流(Vinyl files)，这个虚拟文件对象中存储着原始文件的路径、文件名、内容等信息，这个我们暂时不用去深入理解，你只需简单的理解可以用这个方法来读取你需要操作的文件就行了。其语法为：

gulp.src(globs[, options])

globs参数是文件匹配模式(类似正则表达式)，用来匹配文件路径(包括文件名)，当然这里也可以直接指定某个具体的文件路径。当有多个匹配模式时，该参数可以为一个数组。
options为可选参数。通常情况下我们不需要用到。

下面我们重点说说Gulp用到的glob的匹配规则以及一些文件匹配技巧。
Gulp内部使用了node-glob模块来实现其文件匹配功能。我们可以使用下面这些特殊的字符来匹配我们想要的文件：

• * 匹配文件路径中的0个或多个字符，但不会匹配路径分隔符，除非路径分隔符出现在末尾
• ** 匹配路径中的0个或多个目录及其子目录,需要单独出现，即它左右不能有其他东西了。如果出现在末尾，也能匹配文件。
• ? 匹配文件路径中的一个字符(不会匹配路径分隔符)
• [...] 匹配方括号中出现的字符中的任意一个，当方括号中第一个字符为^或!时，则表示不匹配方括号中出现的其他字符中的任意一个，类似js正则表达式中的用法
• !(pattern|pattern|pattern) 匹配任何与括号中给定的任一模式都不匹配的
• ?(pattern|pattern|pattern) 匹配括号中给定的任一模式0次或1次，类似于js正则中的(pattern|pattern|pattern)?
• +(pattern|pattern|pattern) 匹配括号中给定的任一模式至少1次，类似于js正则中的(pattern|pattern|pattern)+
• *(pattern|pattern|pattern) 匹配括号中给定的任一模式0次或多次，类似于js正则中的(pattern|pattern|pattern)*
• @(pattern|pattern|pattern) 匹配括号中给定的任一模式1次，类似于js正则中的(pattern|pattern|pattern)

下面以一系列例子来加深理解

• * 能匹配 a.js,x.y,abc,abc/,但不能匹配a/b.js
• *.* 能匹配 a.js,style.css,a.b,x.y
• */*/*.js 能匹配 a/b/c.js,x/y/z.js,不能匹配a/b.js,a/b/c/d.js
• ** 能匹配 abc,a/b.js,a/b/c.js,x/y/z,x/y/z/a.b,能用来匹配所有的目录和文件
• **/*.js 能匹配 foo.js,a/foo.js,a/b/foo.js,a/b/c/foo.js
• a/**/z 能匹配 a/z,a/b/z,a/b/c/z,a/d/g/h/j/k/z
• a/**b/z 能匹配 a/b/z,a/sb/z,但不能匹配a/x/sb/z,因为只有单**单独出现才能匹配多级目录
• ?.js 能匹配 a.js,b.js,c.js
• a?? 能匹配 a.b,abc,但不能匹配ab/,因为它不会匹配路径分隔符
• [xyz].js 只能匹配 x.js,y.js,z.js,不会匹配xy.js,xyz.js等,整个中括号只代表一个字符
• [^xyz].js 能匹配 a.js,b.js,c.js等,不能匹配x.js,y.js,z.js

当有多种匹配模式时可以使用数组

//使用数组的方式来匹配多种文件
gulp.src(['js/*.js','css/*.css','*.html'])

使用数组的方式还有一个好处就是可以很方便的使用排除模式，在数组中的单个匹配模式前加上!即是排除模式，它会在匹配的结果中排除这个匹配，要注意一点的是不能在数组中的第一个元素中使用排除模式

gulp.src([*.js,'!b*.js']) //匹配所有js文件，但排除掉以b开头的js文件
gulp.src(['!b*.js',*.js]) //不会排除任何文件，因为排除模式不能出现在数组的第一个元素中

此外，还可以使用展开模式。展开模式以花括号作为定界符，根据它里面的内容，会展开为多个模式，最后匹配的结果为所有展开的模式相加起来得到的结果。展开的例子如下：

a{b,c}d 会展开为 abd,acd
a{b,}c 会展开为 abc,ac
a{0..3}d 会展开为 a0d,a1d,a2d,a3d
a{b,c{d,e}f}g 会展开为 abg,acdfg,acefg
a{b,c}d{e,f}g 会展开为 abdeg,acdeg,abdeg,abdfg

3.2 gulp.dest()

gulp.dest()方法是用来写文件的，其语法为：

gulp.dest(path[,options])

path为写入文件的路径
options为一个可选的参数对象，通常我们不需要用到

要想使用好gulp.dest()这个方法，就要理解给它传入的路径参数与最终生成的文件的关系。
gulp的使用流程一般是这样子的：首先通过gulp.src()方法获取到我们想要处理的文件流，然后把文件流通过pipe方法导入到gulp的插件中，最后把经过插件处理后的流再通过pipe方法导入到gulp.dest()中，gulp.dest()方法则把流中的内容写入到文件中，这里首先需要弄清楚的一点是，我们给gulp.dest()传入的路径参数，只能用来指定要生成的文件的目录，而不能指定生成文件的文件名，它生成文件的文件名使用的是导入到它的文件流自身的文件名，所以生成的文件名是由导入到它的文件流决定的，即使我们给它传入一个带有文件名的路径参数，然后它也会把这个文件名当做是目录名，例如：

var gulp = require('gulp');
gulp.src('script/jquery.js')
    .pipe(gulp.dest('dist/foo.js'));
//最终生成的文件路径为 dist/foo.js/jquery.js,而不是dist/foo.js

要想改变文件名，可以使用插件gulp-rename

下面说说生成的文件路径与我们给gulp.dest()方法传入的路径参数之间的关系。
gulp.dest(path)生成的文件路径是我们传入的path参数后面再加上gulp.src()中有通配符开始出现的那部分路径。例如：

var gulp = reruire('gulp');
//有通配符开始出现的那部分路径为 **/*.js
gulp.src('script/**/*.js')
    .pipe(gulp.dest('dist')); //最后生成的文件路径为 dist/**/*.js
//如果 **/*.js 匹配到的文件为 jquery/jquery.js ,则生成的文件路径为 dist/jquery/jquery.js

再举更多一点的例子

gulp.src('script/avalon/avalon.js') //没有通配符出现的情况
    .pipe(gulp.dest('dist')); //最后生成的文件路径为 dist/avalon.js

//有通配符开始出现的那部分路径为 **/underscore.js
gulp.src('script/**/underscore.js')
    //假设匹配到的文件为script/util/underscore.js
    .pipe(gulp.dest('dist')); //则最后生成的文件路径为 dist/util/underscore.js

gulp.src('script/*') //有通配符出现的那部分路径为 *
    //假设匹配到的文件为script/zepto.js    
    .pipe(gulp.dest('dist')); //则最后生成的文件路径为 dist/zepto.js

通过指定gulp.src()方法配置参数中的base属性，我们可以更灵活的来改变gulp.dest()生成的文件路径。
当我们没有在gulp.src()方法中配置base属性时，base的默认值为通配符开始出现之前那部分路径，例如：

gulp.src('app/src/**/*.css') //此时base的值为 app/src

上面我们说的gulp.dest()所生成的文件路径的规则，其实也可以理解成，用我们给gulp.dest()传入的路径替换掉gulp.src()中的base路径，最终得到生成文件的路径。

gulp.src('app/src/**/*.css') //此时base的值为app/src,也就是说它的base路径为app/src
     //设该模式匹配到了文件 app/src/css/normal.css
    .pipe(gulp.dest('dist')) //用dist替换掉base路径，最终得到 dist/css/normal.css

所以改变base路径后，gulp.dest()生成的文件路径也会改变

gulp.src(script/lib/*.js) //没有配置base参数，此时默认的base路径为script/lib
    //假设匹配到的文件为script/lib/jquery.js
    .pipe(gulp.dest('build')) //生成的文件路径为 build/jquery.js

gulp.src(script/lib/*.js, {base:'script'}) //配置了base参数，此时base路径为script
    //假设匹配到的文件为script/lib/jquery.js
    .pipe(gulp.dest('build')) //此时生成的文件路径为 build/lib/jquery.js

用gulp.dest()把文件流写入文件后，文件流仍然可以继续使用。

3.3 gulp.task()

gulp.task方法用来定义任务，内部使用的是Orchestrator，其语法为：

gulp.task(name[, deps], fn)

name 为任务名
deps 是当前定义的任务需要依赖的其他任务，为一个数组。当前定义的任务会在所有依赖的任务执行完毕后才开始执行。如果没有依赖，则可省略这个参数
fn 为任务函数，我们把任务要执行的代码都写在里面。该参数也是可选的。

gulp.task('mytask', ['array', 'of', 'task', 'names'], function() { //定义一个有依赖的任务
  // Do something
});

gulp.task()这个API没什么好讲的，但需要知道执行多个任务时怎么来控制任务执行的顺序。
gulp中执行多个任务，可以通过任务依赖来实现。例如我想要执行one,two,three这三个任务，那我们就可以定义一个空的任务，然后把那三个任务当做这个空的任务的依赖就行了：

//只要执行default任务，就相当于把one,two,three这三个任务执行了
gulp.task('default',['one','two','three']);

如果任务相互之间没有依赖，任务会按你书写的顺序来执行，如果有依赖的话则会先执行依赖的任务。
但是如果某个任务所依赖的任务是异步的，就要注意了，gulp并不会等待那个所依赖的异步任务完成，而是会接着执行后续的任务。例如：

gulp.task('one',function(){
  //one是一个异步执行的任务
  setTimeout(function(){
    console.log('one is done')
  },5000);
});

//two任务虽然依赖于one任务,但并不会等到one任务中的异步操作完成后再执行
gulp.task('two',['one'],function(){
  console.log('two is done');
});

上面的例子中我们执行two任务时，会先执行one任务，但不会去等待one任务中的异步操作完成后再执行two任务，而是紧接着执行two任务。所以two任务会在one任务中的异步操作完成之前就执行了。

那如果我们想等待异步任务中的异步操作完成后再执行后续的任务，该怎么做呢？
有三种方法可以实现：
第一：在异步操作完成后执行一个回调函数来通知gulp这个异步任务已经完成,这个回调函数就是任务函数的第一个参数。

gulp.task('one',function(cb){ //cb为任务函数提供的回调，用来通知任务已经完成
  //one是一个异步执行的任务
  setTimeout(function(){
    console.log('one is done');
    cb();  //执行回调，表示这个异步任务已经完成
  },5000);
});

//这时two任务会在one任务中的异步操作完成后再执行
gulp.task('two',['one'],function(){
  console.log('two is done');
});

第二：定义任务时返回一个流对象。适用于任务就是操作gulp.src获取到的流的情况。

gulp.task('one',function(cb){
  var stream = gulp.src('client/**/*.js')
      .pipe(dosomething()) //dosomething()中有某些异步操作
      .pipe(gulp.dest('build'));
    return stream;
});

gulp.task('two',['one'],function(){
  console.log('two is done');
});

第三：返回一个promise对象，例如

var Q = require('q'); //一个著名的异步处理的库 https://github.com/kriskowal/q
gulp.task('one',function(cb){
  var deferred = Q.defer();
  // 做一些异步操作
  setTimeout(function() {
     deferred.resolve();
  }, 5000);
  return deferred.promise;
});

gulp.task('two',['one'],function(){
  console.log('two is done');
});

gulp.task()就这些了，主要是要知道当依赖是异步任务时的处理。

3.4 gulp.watch()

gulp.watch()用来监视文件的变化，当文件发生变化后，我们可以利用它来执行相应的任务，例如文件压缩等。其语法为

gulp.watch(glob[, opts], tasks)

glob 为要监视的文件匹配模式，规则和用法与gulp.src()方法中的glob相同。
opts 为一个可选的配置对象，通常不需要用到
tasks 为文件变化后要执行的任务，为一个数组

gulp.task('uglify',function(){
  //do something
});
gulp.task('reload',function(){
  //do something
});
gulp.watch('js/**/*.js', ['uglify','reload']);

gulp.watch()还有另外一种使用方式：

gulp.watch(glob[, opts, cb])

glob和opts参数与第一种用法相同
cb参数为一个函数。每当监视的文件发生变化时，就会调用这个函数,并且会给它传入一个对象，该对象包含了文件变化的一些信息，type属性为变化的类型，可以是added,changed,deleted；path属性为发生变化的文件的路径

gulp.watch('js/**/*.js', function(event){
    console.log(event.type); //变化类型 added为新增,deleted为删除，changed为改变 
    console.log(event.path); //变化的文件的路径
});

4、一些常用的gulp插件

gulp的插件数量虽然没有grunt那么多，但也可以说是应有尽有了，下面列举一些常用的插件。

4.1 自动加载插件

使用gulp-load-plugins
安装：npm install --save-dev gulp-load-plugins
要使用gulp的插件，首先得用require来把插件加载进来，如果我们要使用的插件非常多，那我们的gulpfile.js文件开头可能就会是这个样子的：

var gulp = require('gulp'),
    //一些gulp插件,abcd这些命名只是用来举个例子
    a = require('gulp-a'), 
    b = require('gulp-b'),
    c = require('gulp-c'),
    d = require('gulp-d'),
    e = require('gulp-e'),
    f = require('gulp-f'),
    g = require('gulp-g'),
    //更多的插件...
    z = require('gulp-z');

虽然这没什么问题，但会使我们的gulpfile.js文件变得很冗长，看上去不那么舒服。gulp-load-plugins插件正是用来解决这个问题。
gulp-load-plugins这个插件能自动帮你加载package.json文件里的gulp插件。例如假设你的package.json文件里的依赖是这样的:

{
  "devDependencies": {
    "gulp": "~3.6.0",
    "gulp-rename": "~1.2.0",
    "gulp-ruby-sass": "~0.4.3",
    "gulp-load-plugins": "~0.5.1"
  }
}

然后我们可以在gulpfile.js中使用gulp-load-plugins来帮我们加载插件：

var gulp = require('gulp');
//加载gulp-load-plugins插件，并马上运行它
var plugins = require('gulp-load-plugins')();

然后我们要使用gulp-rename和gulp-ruby-sass这两个插件的时候，就可以使用plugins.rename和plugins.rubySass来代替了,也就是原始插件名去掉gulp-前缀，之后再转换为驼峰命名。
实质上gulp-load-plugins是为我们做了如下的转换

plugins.rename = require('gulp-rename');
plugins.rubySass = require('gulp-ruby-sass');

gulp-load-plugins并不会一开始就加载所有package.json里的gulp插件，而是在我们需要用到某个插件的时候，才去加载那个插件。
最后要提醒的一点是，因为gulp-load-plugins是通过你的package.json文件来加载插件的，所以必须要保证你需要自动加载的插件已经写入到了package.json文件里，并且这些插件都是已经安装好了的。

4.2 重命名

使用gulp-rename
安装：npm install --save-dev gulp-rename
用来重命名文件流中的文件。用gulp.dest()方法写入文件时，文件名使用的是文件流中的文件名，如果要想改变文件名，那可以在之前用gulp-rename插件来改变文件流中的文件名。

var gulp = require('gulp'),
    rename = require('gulp-rename'),
    uglify = require("gulp-uglify");

gulp.task('rename', function () {
    gulp.src('js/jquery.js')
    .pipe(uglify())  //压缩
    .pipe(rename('jquery.min.js')) //会将jquery.js重命名为jquery.min.js
    .pipe(gulp.dest('js'));
    //关于gulp-rename的更多强大的用法请参考https://www.npmjs.com/package/gulp-rename
});

4.3 js文件压缩

使用gulp-uglify
安装：npm install --save-dev gulp-uglify
用来压缩js文件，使用的是uglify引擎

var gulp = require('gulp'),
    uglify = require("gulp-uglify");

gulp.task('minify-js', function () {
    gulp.src('js/*.js') // 要压缩的js文件
    .pipe(uglify())  //使用uglify进行压缩,更多配置请参考：
    .pipe(gulp.dest('dist/js')); //压缩后的路径
});

4.4 css文件压缩

使用gulp-minify-css
安装：npm install --save-dev gulp-minify-css
要压缩css文件时可以使用该插件

var gulp = require('gulp'),
    minifyCss = require("gulp-minify-css");

gulp.task('minify-css', function () {
    gulp.src('css/*.css') // 要压缩的css文件
    .pipe(minifyCss()) //压缩css
    .pipe(gulp.dest('dist/css'));
});

4.5 html文件压缩

使用gulp-minify-html
安装：npm install --save-dev gulp-minify-html
用来压缩html文件

var gulp = require('gulp'),
    minifyHtml = require("gulp-minify-html");

gulp.task('minify-html', function () {
    gulp.src('html/*.html') // 要压缩的html文件
    .pipe(minifyHtml()) //压缩
    .pipe(gulp.dest('dist/html'));
});

4.6 js代码检查

使用gulp-jshint
安装：npm install --save-dev gulp-jshint
用来检查js代码

var gulp = require('gulp'),
    jshint = require("gulp-jshint");

gulp.task('jsLint', function () {
    gulp.src('js/*.js')
    .pipe(jshint())
    .pipe(jshint.reporter()); // 输出检查结果
});

4.7 文件合并

使用gulp-concat
安装：npm install --save-dev gulp-concat
用来把多个文件合并为一个文件,我们可以用它来合并js或css文件等，这样就能减少页面的http请求数了

var gulp = require('gulp'),
    concat = require("gulp-concat");

gulp.task('concat', function () {
    gulp.src('js/*.js')  //要合并的文件
    .pipe(concat('all.js'))  // 合并匹配到的js文件并命名为 "all.js"
    .pipe(gulp.dest('dist/js'));
});

4.8 less和sass的编译

less使用gulp-less,安装：npm install --save-dev gulp-less

var gulp = require('gulp'),
    less = require("gulp-less");

gulp.task('compile-less', function () {
    gulp.src('less/*.less')
    .pipe(less())
    .pipe(gulp.dest('dist/css'));
});

sass使用gulp-sass,安装：npm install --save-dev gulp-sass

var gulp = require('gulp'),
    sass = require("gulp-sass");

gulp.task('compile-sass', function () {
    gulp.src('sass/*.sass')
    .pipe(sass())
    .pipe(gulp.dest('dist/css'));
});

4.9 图片压缩

可以使用gulp-imagemin插件来压缩jpg、png、gif等图片。
安装：npm install --save-dev gulp-imagemin

var gulp = require('gulp');
var imagemin = require('gulp-imagemin');
var pngquant = require('imagemin-pngquant'); //png图片压缩插件

gulp.task('default', function () {
    return gulp.src('src/images/*')
        .pipe(imagemin({
            progressive: true,
            use: [pngquant()] //使用pngquant来压缩png图片
        }))
        .pipe(gulp.dest('dist'));
});

gulp-imagemin的使用比较复杂一点，而且它本身也有很多插件，建议去它的项目主页看看文档

4.10 自动刷新

使用gulp-livereload插件，安装:npm install --save-dev gulp-livereload。
当代码变化时，它可以帮我们自动刷新页面
该插件最好配合谷歌浏览器来使用，且要安装livereload chrome extension扩展插件,不能下载的请自行FQ。

var gulp = require('gulp'),
    less = require('gulp-less'),
    livereload = require('gulp-livereload');

gulp.task('less', function() {
  gulp.src('less/*.less')
    .pipe(less())
    .pipe(gulp.dest('css'))
    .pipe(livereload());
});

gulp.task('watch', function() {
  livereload.listen(); //要在这里调用listen()方法
  gulp.watch('less/*.less', ['less']);
});

仅作技术分享，原文链接地址: https://www.cnblogs.com/2050/p/4198792.html

近期苹果发布了ios11系统、iPhone8、iPhone 8 Plus、iPhone X等，but 网上的设计规范零散，于是入行两年的我做了一些总结，如有雷同请各位体谅，此次总结望对各位设计界的同仁有所帮助。（如有错误，请各位指出）！

iOS 11

iOS 11是苹果公司研发的操作系统。北京时间2017年6月6日凌晨1点， WWDC（苹果全球开发者大会）2017在加州圣何塞麦克恩利会议中心召开，苹果系统iOS 11正式亮相。
正式版iOS 11在2017年9月份随着新品iPhone的发布推送更新升级。2017年9月20日，iOS 11正式版发布，增加的特定功能是：二维码扫描、诈骗短信识别、拼音键盘以及上海话语音识别等,其中，二维码扫描还支持“扫码解锁”摩拜单车。

动态效果

Dock 可以出现在任何应用的界面上，只要从屏幕下方划出就可以了。长按一个应用图标，可以将它拖到正在使用的应用之上。
也就是说，屏幕上会同时显示出两个应用，再次拖动一个应用的边缘，界面就演化成 1：1 或者 1：2 的分屏。这个操作的过程有些细节，比如拖动应用边框，界面较大的那个会在边缘向内收缩——这是在告诉你它即将缩小、另一个应用要出现在隔壁了。

动态特效

比如录屏，点击它你会看到一个从 3 到 1 的倒计时，然后它才开始录屏；电池图标点一下会变成黄色，用来开启省电模式。更多的情况下，长按图标会进入一个二级页面，比如屏幕明暗的调节。这让你更直观的看到亮度的变化。

锁屏界面

Apple Music 在锁屏上占据的位置更少，它变成了一张卡片，显示歌名和控制按键。原本 Music 会占据一整个锁屏，有些第三方应用还会在这里展示滚动歌词。现在的样子更清新一些了。

搜索顺序

在Spotlight 键入关键词，紧接着它的是推荐的关键词、通讯录、短信内容等等融合在一起的一个下拉菜单，在这下方才是与这个关键词有关的应用程序。在 iOS 10 上，这个顺序是反过来的。以及，Spotlight 会一直顶在主屏左边、也就是摆放各种插件的界面。

模块变样

Apple Music 在控制中心中有点特殊，如果你长按，会看到这个框上不仅显示正在播放的歌曲名称、以及暂停播放和前后首按钮，右上角还有一个小小的信号图标，这里可以让你切换正在使用的蓝牙设备，比如 AirPods、各种音响。相比之下，iOS 10 切换蓝牙设备的时候还需要你到设置中找到“蓝牙”，再一个个查看。

拖动图标

同时拖动多个图标到文件夹，这也是效率提升的体现，如果你要把几个应用拖进某个文件夹，iOS 11 上可以长按一个图标、同时点选其他应用，就可以把它们几个同时拖进目标文件夹之中。手机上也支持这个操作。

相关UI

一、图标
在比较中寻求进步
iOS 10 VS iOS11

2PX线性图标

特点：
1. 未选中时图标是以2px线框形展现，选中后的当前页以填充形态展现；
2. 设计、语言一致性，图标精致轻巧。

面性图标

特点：用轻量化的面性图标代替2 PX的线性图标，以较为圆润的外观展现，使整体更加具有亲和力。

二、字体

iOS 11粗体标题

粗体
特点：粗体，且字体像素大，标题醒目（开个玩笑：典型的老夫设计）

在扁平化设计中的优点：在扁平化设计中文字排版影响着信息层级展示的清晰与否，通过文字的字号、字重、颜色等的对比去建立清晰的信息层级，而不用太多的装饰元素。

三、设计元素

圆角、卡片化、投影元素

特点：圆角弧度的增大让用户的视觉更轻快，柔和；卡片式设计贯穿在界面各个图文排版中，起到了规整图文内容的作用。投影元素的加入，令设计元素更加独立醒目，强有力的抓住用户的注意力。

四、界面布局中的留白

特点：大标题文本包含一组带有图片和描素的元素，组元素和组元素之间保持较大的间距。
优点：设计元素和元素之间保持足够的间距，可以减少用来区分层级关系的不必要装饰块元素，使界面简洁、干练。

支持设备

iphone5s及5s以上
ipad air/air2及以上
ipod touch第六代

iPhone X

iPhone界面规范

不同机型升级iOS 11效果展

iPhone X规范

分享iOS11 GUI视觉规范（附PSD+Sketch+Adobe XD源文件）

百度网盘下载地址：

1. 665M PSD格式下载地址：链接: https://pan.baidu.com/s/1i5CFD8D 密码: v3km
2. 38.5M sketch格式下载地址：链接: https://pan.baidu.com/s/1c163YcK 密码: j4hs
3. 7.7M Illustrator格式下载地址： 链接: https://pan.baidu.com/s/1i5nDgBr 密码: 5c27
4. 三个打包下载地址：链接: https://pan.baidu.com/s/1slFNbtV 密码: xaqt

本文作技术分享，原始文章链接：
1、iPhone8和iPhoneX发布了，iOS11视觉规范源文件也来了
2、ios11 and iphoneX UI设计规范

一个完整的3D环境包含以下元素:

1.场景(Scene)：是物体、光源等元素的容器，
2.相机（Camera）：控制视角的位置、范围以及视觉焦点的位置,一个3D环境中只能存在一个相机
3.物体对象（Mesh）：包括二维物体（点、线、面）、三维物体、粒子
4.光源（Light）：包括全局光、平行光、点光源
5.渲染器（Renderer）:指定渲染方式，如webGL\canvas2D\Css2D\Css3D等。
6.控制器(Control): 相机控件，可通过键盘、鼠标控制相机的移动

场景(Scene)

物体、光源、控制器的添加必须使用secen.add(object)添加到场景中才能渲染出来。
一个3D项目中可同时存在多个scene，通过切换render的scene来切换显示场景

var scene = new THREE.Scene();
var mesh=scene.getObjectByName("sky");//获取场景中name=sky的物体；

相机（Camera）

相机根据投影方式分两种：正交投影相机和透视投影相机

正交投影相机:THREE.OrthographicCamera(left, right, top, bottom, near, far),大小不因远近而变化
透视投影相机:THREE.PerspectiveCamera(fov, aspect, near, far)，遵循近大远小的空间规则

一般情况下，我们使用的是透视投影相机，其参数为：

fov: 垂直方向夹角
aspect:可视区域长宽比 width/height
near:渲染区域离摄像机最近的距离
far:渲染区域离摄像机最远的距离，3仅在距离摄像机near和far间的区域会被渲染到 canvas中

相机有两个重要的参数：

camera.position：控制相机在整个3D环境中的位置（取值为3维坐标对象-THREE.Vector3(x,y,z)）
camera.lookAt：控制相机的焦点位置，决定相机的朝向（取值为3维坐标对象-THREE.Vector3(x,y,z)）

主要应用

1.设置相机焦点位置为原点坐标或某物体的位置坐标：camera.lookAt(new THREE.Vector3(0,0,0))，循环改变camera.position的位置，可以实现围绕物体旋转 360度观看物体的动画。

2.同时循环设置camera.lookAt和camera.position,可以实现以第一人称视角在空间自由移动的动画

物体（Mesh）

一个完整的物体对象mesh包括形状Geometry和材质Material

• Mesh：三维物体，包括Geometry、Material，设置其name属性可以通过scene.getObjectByName(name)获取该物体对象;
• Geometry：包括平面Plane、圆形Circle、立方体Cube、球体Sphere、圆柱Cylinder、多面体Polyhedron等，拥有以下属性：
• Material：包括基础材质MeshBasicMaterial，深度材质MeshDepthMaterial、法向材质MeshNormalMaterial、面材质MeshFacelMaterial、朗柏材质MeshLambertMaterial、phone材质MeshPhongMaterial、着色器材质ShaderMaterial

以下代码以创建name为sky一个立方体为例，使用6张图片作为材质贴到立方体内部

var path = "resource/sky/";
var format = '.jpg';
var urls = [
        path + 'px' + format, path + 'nx' + format,
        path + 'py' + format, path + 'ny' + format,
        path + 'pz' + format, path + 'nz' + format
    ];
var materials = []; 
for (var i = 0; i < urls.length; ++i) {
    var loader = new THREE.TextureLoader();
    loader.setCrossOrigin( this.crossOrigin );
    var texture = loader.load( urls[i], function(){}, undefined, function(){} );
    materials.push(new THREE.MeshBasicMaterial({
        map: texture, 
        overdraw: true,
        side: THREE.BackSide,
        //transparent: true,
        //needsUpdate:true
    })
    ); 
} 
var cube = new THREE.Mesh(new THREE.CubeGeometry(9000,9000,9000), new THREE.MeshFaceMaterial(materials)); 
cube.name="sky";
scene.add(cube);

记住以下几点：

1. 物体mesh的大小是由构成三维物体形状的顶点坐标mesh.geometry.vertices和缩放级别mesh.scale(vector3)决定的,初始化创建物体时由传入的参数确定了形状顶点坐标mesh.geometry.vertices，后面需要修改物体大小使用mesh.scale进行缩放
2. 物体的透明度是材质的透明度属性mesh.material.opacity决定的，若需要设置透明度，需将材质的是否支持半透明属性mesh.material.transparent设置为true
3. 在页面运行期间需要改变物体的材质或属性需要同步设置mesh.material.needsUpdate=true
4. 若物体使用了THREE.MultiMaterial材质（如上面的例子如果多张图作为贴图材质），则会将所有材质放到mesh.meterials数组中，修改材质需要对每一个材质mesh.materials.material进行单独修改
5. 修改mesh.rotation、mesh.position、mesh.visible可设置物体旋转角度、位置、可见性。注意将物体的visible从false改成true,可能会造成画面卡顿

光源（Light）

全局光：THREE.AmbientLight，影响整个scene的光源，一般是为了弱化阴影或调整整体色调，可设置光照颜色，以颜色的明度确定光源亮度
平行光：THREE.DirectionalLight，模拟类似太阳的光源，所有被照射的区域亮度是一致的，可设置光照颜色、光照方向（通过向量确定方向），以颜色的明度确定光源亮度
点光源：THREE.PointLight：单点发光，照射所有方向，可设置光照强度，光照半径和光颜色

以下分别在 scene中添加了全局光，1个平行光及5个点光源，项目中平行光作为主要光源、点光源主要用于暗部补光。

var ambient = new THREE.AmbientLight( 0xcccccc );
scene.add( ambient );
var directionalLight = new THREE.DirectionalLight( 0xcccccc );
directionalLight.position.set( -2, 9, 1).normalize();//设置平行光方向
scene.add( directionalLight );
var pointlight = new THREE.PointLight(0xffffff, 1, 3000); 
pointlight.position.set(0, 0, 2000);//设置点光源位置
scene.add( pointlight );
var pointlight2 = new THREE.PointLight(0xffffff, 1, 2000);
pointlight2.position.set(-1000, 1000, 1000);
scene.add( pointlight2 );
var pointlight_back = new THREE.PointLight(0xffffff, 1, 2000); 
pointlight_back.position.set(0, 0, -2000);
scene.add( pointlight_back );
var pointlight_left = new THREE.PointLight(0xffffff, 1, 2000); 
pointlight_left.position.set( -2000, 0,0);
scene.add( pointlight_left );
var pointlight_right = new THREE.PointLight(0xffffff, 1, 2000); 
pointlight_right.position.set(0,  -2000, 0);
scene.add( pointlight_right );

渲染器(Renderer)

一般情况下我们使用的是WebGL渲染器。

var renderer = new THREE.WebGLRenderer();
renderer.setPixelRatio( window.devicePixelRatio );//设置canvas的像素比为当前设备的屏幕像素比，避免高分屏下模糊
renderer.setSize( _container.offsetWidth, _container.offsetHeight );//设置渲染器大小,即canvas画布的大小
container.appendChild( renderer.domElement );//在页面中添加canvas

控制器（Controls）

FlyControls:飞行控制，用键盘和鼠标控制相机的移动和转动
OrbitControls::轨道控制器，模拟轨道中的卫星，绕某个对象旋转平移，用键盘和鼠标控制相机位置
PointerLockControls:指针锁定，鼠标离开画布依然能被捕捉到鼠标交互，主要用于游戏
TrackballControls：轨迹球控制器，通过键盘和鼠标控制前后左右平移和缩放场景
TransformControls:变换物体控制器，可以通过鼠标对物体的进行拖放等操作

示例：

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title></title>
    </head>
    <body>
    <div id="space"></div>  
    <script   src="https://code.jquery.com/jquery-1.12.4.min.js"   integrity="sha256-ZosEbRLbNQzLpnKIkEdrPv7lOy9C27hHQ+Xp8a4MxAQ="   crossorigin="anonymous"></script>
    <script src="../js/lib/threejs/three.js"></script>

    <script src="../js/lib/threejs/OrbitControls.js"></script>
    <script>


            var container, stats;

            var camera, scene, renderer;

            var mouseX = 0, mouseY = 0;

            var windowHalfX = window.innerWidth / 2;
            var windowHalfY = window.innerHeight / 2;


            init();
            animate();
            var mesh;

            function init() {

                container = document.getElementById("space")
                camera = new THREE.PerspectiveCamera( 45, window.innerWidth / window.innerHeight, 1, 5000 );
                camera.position.set(0, 0, 1500);

                scene = new THREE.Scene();

                var ambient = new THREE.AmbientLight( 0xffffff );
                scene.add( ambient );


                var directionalLight = new THREE.DirectionalLight( 0xffffff );
                directionalLight.position.set( -5, 5, 5).normalize();
                scene.add( directionalLight );

                var pointlight = new THREE.PointLight(0x63d5ff, 1, 200); 
                pointlight.position.set(0, 0, 200);
                scene.add( pointlight );                
                var pointlight2 = new THREE.PointLight(0xffffff, 1, 200); 
                pointlight2.position.set(-200, 200, 200);
                scene.add( pointlight2 );
                var pointlight3 = new THREE.PointLight(0xffffff, 1.5, 200); 
                pointlight3.position.set(-200, 200, 0);
                scene.add( pointlight3 );

                var controls = new THREE.OrbitControls(camera,container);
            //controls.maxPolarAngle=1.5;
            //controls.minPolarAngle=1;
            controls.enableDamping=true;
            controls.enableKeys=false;
            controls.enablePan=false;
            controls.dampingFactor = 0.1;
            controls.rotateSpeed=0.1;
    //      controls.enabled = false;
            //controls.minDistance=1000;
            //controls.maxDistance=3000;



                var path = "../resource/sky/";
                var format = '.jpg';
                var urls = [
                        path + 'px' + format, path + 'nx' + format,
                        path + 'py' + format, path + 'ny' + format,
                        path + 'pz' + format, path + 'nz' + format
                    ];
                var skyMaterials = []; 
                for (var i = 0; i < urls.length; ++i) {
                    var loader = new THREE.TextureLoader();
                    loader.setCrossOrigin( this.crossOrigin );
                    var texture = loader.load( urls[i], function(){}, undefined, function(){} );

                    skyMaterials.push(new THREE.MeshBasicMaterial({
                        //map: THREE.ImageUtils.loadTexture(urls[i], {},function() { }), 
                        map: texture, 
                        overdraw: true,
                        side: THREE.BackSide,
                        //transparent: true,
                        //needsUpdate:true,
                        premultipliedAlpha: true
                        //depthWrite:true,

        //              wireframe:false,
                    })
                    ); 

                } 

                var cube = new THREE.Mesh(new THREE.CubeGeometry(500, 500,500), new THREE.MeshFaceMaterial(skyMaterials)); 
                cube.name="sky";
                scene.add(cube);
                renderer = new THREE.WebGLRenderer();
                renderer.setPixelRatio( window.devicePixelRatio );
                renderer.setSize( window.innerWidth, window.innerHeight );
                container.appendChild( renderer.domElement );

                document.addEventListener( 'mousemove', onDocumentMouseMove, false );
                window.addEventListener( 'resize', onWindowResize, false );

            }

            function onWindowResize() {

                windowHalfX = window.innerWidth / 2;
                windowHalfY = window.innerHeight / 2;

                camera.aspect = window.innerWidth / window.innerHeight;
                camera.updateProjectionMatrix();
                renderer.setSize( window.innerWidth, window.innerHeight );

            }

            function onDocumentMouseMove( event ) {

                mouseX = ( event.clientX - windowHalfX ) / 2;
                mouseY = ( event.clientY - windowHalfY ) / 2;

            }

            //

            function animate() {

                requestAnimationFrame( animate );
                render();

            }

            function render() {

//              camera.position.x += ( mouseX - camera.position.x ) ;
//              camera.position.y += ( mouseY - camera.position.y ) ;

                camera.lookAt( scene.position );

                renderer.render( scene, camera );

            }

    </script>
    </body>
</html>

手机阅读请扫描下方二维码：

本文仅供技术分享。原文链接地址： http://feg.netease.com/archives/266.html

交互规范

• 分屏切换，支持横向和竖向，滑动指引需清晰
• 若详情页加载较慢，需设计loading页，给予用户友好的提示
• 如有视频，需在底部加上“建议在Wi-Fi环境下播放”提示
• 建议一个页面不超过两种以上交互操作

设计规范

• 页面尺寸建议：640像素×1100像素
• 最小按钮宽度：160像素
• 最小按钮高度：60像素
• 页面最小字号：不小于24像素
• 二维码最小尺寸：200像素×200像素 ，边距至少为10像素
• 背景音乐规范：必须支持音乐可循环及可关闭，并采用渐强的方式出现
• 音乐播放/关闭按钮，参考下图规范，并放置于页面右上角位置

H5页面内嵌入全屏视频规范

• 建议：使用流媒体播放，并添加可跳过播放按钮
• 时长：≤ 45 秒
• 视频编码：H.264/AVC
• FPS：推荐 24fps
• 码率：≤ 800 kbit/s
• 音频格式：AAC
• 音频码率：≤ 96 kbit/sec
• 音频采样率：推荐 44.1 kHz
• 文件大小限制：≤ 5MB ( 实际大小与时长及码率对应，如20秒视频，大小为 20秒×（800码率÷8）÷1024=1.95MB )

自定义H5设计规范

自定义H5页面请严格遵守《微信广告制作规范》中关于“广告详情页制作基础规范”等规范。

更多设计、广告规范，请移步 微信广告

1. canvas位图处理

HTML5 canvas为我们提供了一块画布，让前端也有了操作位图的功能：图片旋转、缩放、滤镜、压缩等都可以通过JS来实现。

图像基本处理

通过设置drawImage参数可以实现图片绘制、缩放、拉伸和裁剪等操作(注意: canvas无法绘制体积过大图片，否则会卡甚至崩掉，大图可以分块读取绘制)：

详细用法参考 drawImage()，DEMO源码戳这里 JS Bin.

只需要drawImage一个方法，就可以实现基本图形处理功能，再结合鼠标或滚轮事件，就可以实现更复杂的局部放大预览，缩放等功能了。

图像滤镜处理

现在的朋友圈发个图都要用滤镜美一下，复古清纯胶片LOMO各种风格应有尽有。canvas提供了getImageData方法来获取图像上每一个像素点的RGBA信息，这样我们就能对图片进行像素级处理了。通过特定算法来重写imageData中的像素信息，然后用setImageData方法把新的数据重新绘制在canvas上，这样就可以实现图像滤镜打码加特效等一系列功能。

比如我们现在要实现一个复古滤镜:

// 复古滤镜处理算法：获取每个像素的RGB信息，并按特定权重返回其加权平均值
let sepiaFilter = function(imgData) {
  let d = imgData.data
  for (let i = 0; i < d.length; i += 4) {
    let r = d[i]
    let g = d[i + 1]
    let b = d[i + 2]
    d[i] = (r * 0.393) + (g * 0.769) + (b * 0.189) // red
    d[i + 1] = (r * 0.349) + (g * 0.686) + (b * 0.168) // green
    d[i + 2] = (r * 0.272) + (g * 0.534) + (b * 0.131) // blue
  }
  return imgData
}
//图像地址必须和当前页面同域，否则会报cross-origin错误 
img.src = '/img/logo@2x.png' 
img.onload = () => {
  ctx.drawImage(img, 0, 0) // 绘制原图
  let imgData = ctx.getImageData(0, 0, img.width, img.height) // 获取图片信息
  ctx.putImageData(sepiaFilter(imgData), 100, 0) // 绘制处理后图片
}

详细用法参考 getImageData() 和 putImageData()，DEMO源码戳这里 JSFiddle

滤镜处理关键在于滤镜算法，要想写出更高级的特效需要有计算机图形学基础，对卷积矩阵、拉普拉斯变换、傅里叶变换等数学知识也要了解，这个坑很大我就不挖了。

图像base64存储
加完特效后如果我们想把图像保存下来，就可以用toDataURL方法来对图片进行格式转换、压缩存储了。

// 支持三种文件类型：image/png(默认) | image/jpeg | image/webp(仅Chrome)
canvas.toDataURL() // 默认存储为png
// 仅jpeg/webp支持质量参数(0~1,默认0.92)
canvas.toDataURL("image/jpeg", 0.1) // 存储为质量为0.1的jpeg

由于存储形式是base64编码，原来图片的每三个字节都会被扩展成4字节，所以整体上编码后数据会比原来多约1/3。以下是通过toDataURL存储后的图片和原图大小相关对比数据(数据仅供参考，不具通用性)：

可见存储后图片体积并不是原来的4/3，实际上处理后的图片都会比原图大好几倍，并且不同的图片增大的体积也是不确定的。如果是要上传图片到服务器，可以把base64转化成Blob二进制数据压缩上传；如果要直接在前端显示或供用户下载，jpg还好可以设置质量参数，要是png就没法压缩了。

只是用toDataURL还不够，用户需要通过手动点击图片-右键图片存储为来保存图片，如果要实现点击下载按钮自动下载图片还需要修改图片类型为octet-stream，然后利用HTML5的download属性强制让浏览器下载。

详细用法参考toDataURL(). 自动下载图片DEMO源码快戳我 JSFiddle.

程序员的备胎

有了以上基础，再结合成熟的图形处理算法，我们可以完成日常工作中大部分图像处理需求，以下列出了一些相关轮子可做备胎。备胎这种东西多多益善，万一以后用到了呢？

html2canvas

将web页面通过canvas来实现截屏，其原理就是遍历DOM结构和样式，然后在canvas中绘制出来，通过toDataURL输出图片。但由于canvas图片的同源策略限制，如果图片和网站不同源的话会截取不出来的。另外在微信中测试时，即使用同源的图片截取出来的图片也有问题，所以要想将其用于生产环境，还是得看场景，有很多坑要踩。

code-to-image

代码转图片工具。有时候你在不同的平台写文章贴代码，由于不同平台代码格式化规范不一，所以经常会出现代码排版问题，通过这个工具将代码转成图片就可以避免排版问题了。

Cropper

一个专门用来做图片裁剪的应用。

tracking.js

这是一个专业的计算机视觉处理JS库，包含了大量图形处理算法，可用来做人脸识别，色彩追踪等酷炫功能。

qrcode2

用JS动态生成二维码，这个库还是很实用的，原理就是qrcode算法+canvas绘图，不支持canvas的用table兼容。

AlloyImage
腾讯出的基于HTML5的专业级图像处理开源引擎，功能很强大，简直就是Web版的PS。

以上列举部分，更多备胎在此： https://github.com/0326/canvas

2. SVG矢量图处理

讲完位图再说矢量图。矢量图在绘制图标、商业LOGO、动画元素上应用非常广范。Web最开始支持的矢量图形并不是现在的SVG，而是微软主推的VML，所以在低版本IE下面只支持VML而不支持SVG，直到后来SVG成为W3C标准并被普及，微软才在IE9中支持SVG。

SVG遵循XML规范，可以很好的集成在HTML里面，同时支持JS脚本控制，还有基于SMIL标准的动态内容支持，做起动画来也是非常方便。目前基于SVG的JS图形库轮子也是非常多，如svg.js, Snap.svg, Velocity.js, D3.js等等，目前暂无SVG应用需求，等用的时候再翻牌子吧。

3. CSS图像处理

如果你的图像特效只是用来给用户展示，并不需要存储的话，可以直接用CSS处理，基本的调整图片大小、拉伸、旋转、裁切等操作直接几个CSS属性width/height/skew/rotate/clip-path等就能搞定了。如果想加特效，使用CSS滤镜Duang的一下就出来了，不需要任何图形学基础和数学知识：

详细说明见 CSS filter – MDN, DEMO 源码见JS Bin.

4. 总结

最后介绍个小工具TrimPNG。大家都知道TinyPNG可以压缩PNG, TrimPNG顾名思义就是去除图片空白和白边的，实现了自动抠图和切图的功能（logo我是直接抄的TinyPNG，都是熊猫，应该不要紧?）

用到的技术点上面都说到了，裁切实现原理就是横向纵向分别扫描两次像素点阵，找出上下左右最外面的非透明点，然后定位出有效图像区域。去除白边算法目前还比较傻逼，只要是接近白色的点都被我干掉了，后面再完善好了 去白边算法优化了一下，采用标记清除策略（听着耳熟吧，其实就是从GC受的启发…），先扫描一遍标记出可疑白点，然后再扫描一遍，凡是与透明区域相邻的可疑白点就清除，当然这个算法也比较死，如果有更专业更智能的请务必告诉我。

体验地址：http://quanfeng.tech/trimpng/

本文仅作技术分享和学习。原文地址：https://segmentfault.com/a/1190000008044204。

常用的制作平台有：ih5、BlueMP、maka、易企秀、木疙瘩等。

总的来说各家的产品在功能上都差不多，都是将组件拖拽到画布上，然后调节各页的图片、动画之后，就可以发布到微信朋友圈了，大致的操作其实和做PPT差不多。

但对于0基础的朋友，想制作好的H5页面，可能不仅仅需要一个H5制作平台。好的H5，需要创意+设计+制作+推广一系列环节的紧密配合。

对于一个H5页面的制作，首先要有良好的页面设计、良好的用户观感，才能让里面的内容更清晰、更明确的得以展现。

我个人在制作H5页面的过程中，会配合使用这些以下创意工具。有需要的可以自行搜索。

1. 灵感获取：

可以到Dribbble、Behance、Pinterest、花瓣等国内外设计师汇聚的设计类聚合平台，借鉴学习顶尖设计师们的优秀设计

2. 图片素材：

向X度图片搜索说再见，微软的Bing图库、wallhaven、500px都是非常高质量的图库。

需要一些小的图标推荐阿里的iconfont图标库，有大量精美的icon可以免费使用。

3.色彩搭配：

很多人做H5的时候，很少考虑色彩的搭配，都是挑一些自己喜欢的、看着顺眼的就行了。其实色彩搭配的选择，对H5页面设计感的提升非常大。小白的话推荐coolors，直接从推荐的色彩主题里进行选择，记下色彩的值，在H5制作工具里输入使用就好了。

作者：老嘴
链接：https://www.zhihu.com/question/45723553/answer/150061371
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。