图片 10

函数的性能,H5单页面手势滑屏切换原理

测试 JavaScript 函数的性能

2017/08/08 · JavaScript
· 函数,
时间

本文由 伯乐在线 –
Wing
翻译,周进林
校稿。未经许可,禁止转载!
英文出处:Peter
Bengtsson。欢迎加入翻译组。

在软件中,性能一直扮演着重要的角色。在Web应用中,性能变得更加重要,因为如果页面速度很慢的话,用户就会很容易转去访问我们的竞争对手的网站。作为专业的web开发人员,我们必须要考虑这个问题。有很多“古老”的关于性能优化的最佳实践在今天依然可行,例如最小化请求数目,使用CDN以及不编写阻塞页面渲染的代码。然而,随着越来越多的web应用都在使用JavaScript,确保我们的代码运行的很快就变得很重要。

假设你有一个正在工作的函数,但是你怀疑它运行得没有期望的那样快,并且你有一个改善它性能的计划。那怎么去证明这个假设呢?在今天,有什么最佳实践可以用来测试JavaScript函数的性能呢?一般来说,完成这个任务的最佳方式是使用内置的performance.now()函数,来衡量函数运行前和运行后的时间。

在这篇文章中,我们会讨论如何衡量代码运行时间,以及有哪些技术可以避免一些常见的“陷阱”。

H5单页面手势滑屏切换原理

2016/03/22 · HTML5 · 2
评论 ·
滑屏

原文出处: 一像素   

H5单页面手势滑屏切换是采用HTML5 触摸事件(Touch) 和
CSS3动画(Transform,Transition)来实现的,效果图如下所示,本文简单说一下其实现原理和主要思路。

图片 1

1、实现原理

假设有5个页面,每个页面占屏幕100%宽,则创建一个DIV容器viewport,将其宽度(width)
设置为500%,然后将5个页面装入容器中,并让这5个页面平分整个容器,最后将容器的默认位置设置为0,overflow设置为hidden,这样屏幕就默认显示第一个页面。

<div id=”viewport” class=”viewport”> <div class=”pageview”
style=”background: #3b76c0″ > <h3 >页面-1</h3>
</div> <div class=”pageview” style=”background: #58c03b;”>
<h3>页面-2</h3> </div> <div class=”pageview”
style=”background: #c03b25;”> <h3>页面-3</h3>
</div> <div class=”pageview” style=”background: #e0a718;”>
<h3>页面-4</h3> </div> <div class=”pageview”
style=”background: #c03eac;”> <h3>页面-5</h3>
</div> </div>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<div id="viewport" class="viewport">
    <div class="pageview" style="background: #3b76c0" >
        <h3 >页面-1</h3>
    </div>
    <div class="pageview" style="background: #58c03b;">
        <h3>页面-2</h3>
    </div>
    <div class="pageview" style="background: #c03b25;">
        <h3>页面-3</h3>
    </div>
    <div class="pageview" style="background: #e0a718;">
        <h3>页面-4</h3>
    </div>
    <div class="pageview" style="background: #c03eac;">
        <h3>页面-5</h3>
    </div>
</div>

CSS样式:

.viewport{ width: 500%; height: 100%; display: -webkit-box; overflow:
hidden; pointer-events: none; -webkit-transform: translate3d(0,0,0);
backface-visibility: hidden; position: relative; }

1
2
3
4
5
6
7
8
9
10
.viewport{
   width: 500%;
   height: 100%;
   display: -webkit-box;
   overflow: hidden;
   pointer-events: none;
   -webkit-transform: translate3d(0,0,0);
   backface-visibility: hidden;
   position: relative;
}

注册touchstart,touchmove和touchend事件,当手指在屏幕上滑动时,使用CSS3的transform来实时设置viewport的位置,比如要显示第二个页面,就设置viewport的transform:translate3d(100%,0,0)
即可,
在这里我们使用translate3d来代替translateX,translate3d可以主动开启手机GPU加速渲染,页面滑动更流畅。

2、主要思路

从手指放在屏幕上、滑动操作、再到离开屏幕是一个完整的操作过程,对应的操作会触发如下事件:

手指放在屏幕上:ontouchstart

手指在屏幕上滑动:ontouchmove

手指离开屏幕:ontouchend

我们需要捕获触摸事件的这三个阶段来完成页面的滑动:

ontouchstart: 初始化变量, 记录手指所在的位置,记录当前时间

/*手指放在屏幕上*/ document.addEventListener(“touchstart”,function(e){
e.preventDefault(); var touch = e.touches[0]; startX = touch.pageX;
startY = touch.pageY; initialPos = currentPosition;
//本次滑动前的初始位置 viewport.style.webkitTransition = “”;
//取消动画效果 startT = new Date().getTime(); //记录手指按下的开始时间
isMove = false; //是否产生滑动 }.bind(this),false);

1
2
3
4
5
6
7
8
9
10
11
/*手指放在屏幕上*/
document.addEventListener("touchstart",function(e){
   e.preventDefault();
   var touch = e.touches[0];
   startX = touch.pageX;
   startY = touch.pageY;
   initialPos = currentPosition;   //本次滑动前的初始位置
   viewport.style.webkitTransition = ""; //取消动画效果
   startT = new Date().getTime(); //记录手指按下的开始时间
   isMove = false; //是否产生滑动
}.bind(this),false);

ontouchmove:
获得当前所在位置,计算手指在屏幕上的移动差量deltaX,然后使页面跟随移动

/*手指在屏幕上滑动,页面跟随手指移动*/
document.addEventListener(“touchmove”,function(e){ e.preventDefault();
var touch = e.touches[0]; var deltaX = touch.pageX – startX; var
deltaY = touch.pageY – startY;
//如果X方向上的位移大于Y方向,则认为是左右滑动 if (Math.abs(deltaX) >
Math.abs(deltaY)){ moveLength = deltaX; var translate = initialPos +
deltaX; //当前需要移动到的位置 //如果translate>0 或 if (translate =
maxWidth){ //移动页面 this.transform.call(viewport,translate); isMove =
true; } direction = deltaX>0?”right”:”left”; //判断手指滑动的方向 }
}.bind(this),false);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*手指在屏幕上滑动,页面跟随手指移动*/
document.addEventListener("touchmove",function(e){
   e.preventDefault();
   var touch = e.touches[0];
   var deltaX = touch.pageX – startX;
   var deltaY = touch.pageY – startY;
   //如果X方向上的位移大于Y方向,则认为是左右滑动
   if (Math.abs(deltaX) > Math.abs(deltaY)){
       moveLength = deltaX;
       var translate = initialPos + deltaX; //当前需要移动到的位置
       //如果translate>0 或
       if (translate = maxWidth){
           //移动页面
           this.transform.call(viewport,translate);
           isMove = true;
       }
       direction = deltaX>0?"right":"left"; //判断手指滑动的方向
   }
}.bind(this),false);

ontouchend:手指离开屏幕时,计算屏幕最终停留在哪一页。首先计算手指在屏幕上的停留时间deltaT,如果deltaT

(1)如果是快速滑动,则让当前页面完整的停留在屏幕中央(需要计算当前页面还有多少需要滑动)

(2)如果是慢速滑动,还需要判断手指在屏幕上滑动的距离,如果滑动的距离没有超过屏幕宽度50%,则要回退到上一页,相反则要停留在当前页面

/*手指离开屏幕时,计算最终需要停留在哪一页*/
document.addEventListener(“touchend”,function(e){ e.preventDefault();
var translate = 0; //计算手指在屏幕上停留的时间 var deltaT = new
Date().getTime() – startT; if (isMove){ //发生了左右滑动
//使用动画过渡让页面滑动到最终的位置 viewport.style.webkitTransition =
“0.3s ease -webkit-transform”; if(deltaT
//如果停留时间小于300ms,则认为是快速滑动,无论滑动距离是多少,都停留到下一页
translate = direction == ‘left’?
currentPosition-(pageWidth+moveLength):currentPosition+pageWidth-moveLength;
//如果最终位置超过边界位置,则停留在边界位置 translate = translate >
0 ? 0 : translate; //左边界 translate = translate //右边界 }else {
//如果滑动距离小于屏幕的50%,则退回到上一页 if
(Math.abs(moveLength)/pageWidth moveLength; }else{
//如果滑动距离大于屏幕的50%,则滑动到下一页 translate = direction ==
‘left’?
currentPosition-(pageWidth+moveLength):currentPosition+pageWidth-moveLength;
translate = translate > 0 ? 0 : translate; translate = translate
maxWidth : translate; } } //执行滑动,让页面完整的显示到屏幕上
this.transform.call(viewport,translate); } }.bind(this),false);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/*手指离开屏幕时,计算最终需要停留在哪一页*/
document.addEventListener("touchend",function(e){
   e.preventDefault();
   var translate = 0;
   //计算手指在屏幕上停留的时间
   var deltaT = new Date().getTime() – startT;
   if (isMove){ //发生了左右滑动
        //使用动画过渡让页面滑动到最终的位置
        viewport.style.webkitTransition = "0.3s ease -webkit-transform";
        if(deltaT //如果停留时间小于300ms,则认为是快速滑动,无论滑动距离是多少,都停留到下一页
            translate = direction == ‘left’?
            currentPosition-(pageWidth+moveLength):currentPosition+pageWidth-moveLength;
            //如果最终位置超过边界位置,则停留在边界位置
            translate = translate > 0 ? 0 : translate; //左边界
            translate = translate //右边界
        }else {
            //如果滑动距离小于屏幕的50%,则退回到上一页
            if (Math.abs(moveLength)/pageWidth moveLength;
            }else{
                //如果滑动距离大于屏幕的50%,则滑动到下一页
                translate = direction == ‘left’?
                currentPosition-(pageWidth+moveLength):currentPosition+pageWidth-moveLength;
                translate = translate > 0 ? 0 : translate;
                translate = translate  maxWidth : translate;
            }
        }
        //执行滑动,让页面完整的显示到屏幕上
        this.transform.call(viewport,translate);
    }
}.bind(this),false);

除此之外,还要计算当前页面是第几页,并设置当前页码

//计算当前的页码 pageNow = Math.round(Math.abs(translate) / pageWidth) +
1; setTimeout(function(){
//设置页码,DOM操作需要放到子线程中,否则会出现卡顿 this.setPageNow();
}.bind(this),100);

1
2
3
4
5
6
7
//计算当前的页码
pageNow = Math.round(Math.abs(translate) / pageWidth) + 1;
 
setTimeout(function(){
    //设置页码,DOM操作需要放到子线程中,否则会出现卡顿
    this.setPageNow();
}.bind(this),100);

基本的思路就这些,当然在实际操作过程中还有一些细节需要注意,这里就不详细说了,都在代码里能体现出来,源代码已传至Git:https://github.com/git-onepixel/guesture,
有兴趣的同学欢迎一起讨论,(由于时间原因,本示例没有加入history路由),你也可以点击或扫描下面二维码来查看示例效果:

图片 2

 

3 赞 24 收藏 2
评论

图片 3

三看 SVG Web 动效

2016/11/30 · HTML5 · 1
评论 ·
SVG

原文出处:
凹凸实验室   

图片 4

CSS3 动效玩腻了吗?没关系的,我们还有 SVG。

Welikesmall
是一个互联网品牌宣传代理,这是我见过的最喜欢使用 SVG
做动效的网页设计团队。事实上,越来越多的网页动效达人选择在 SVG
的疆土上开辟动效的土壤,即便 SMIL 寿将终寝,事实上这反而将 SVG
动效推向了一个新的世界:CSS3 Animation + SVG。

图片 5

(SMIL is dead! Long live SMIL! A Guide to Alternatives to SMIL
Features)

还记得我在久远的《以电影之眼看 CSS3
动画》中说道:“CSS3
动画简直拥有了整个世界!”那么带上 SVG 的 CSS3
动画则已突破天际向着宇宙级的可能性前进(感觉给自己挖了一个无比巨大的坑,网页动画界可不敢再出新技术了[扶额])。

CSS 与 SVG 的打通无疑将 html 代码的可读性又推上一个台阶,我们可以通过
CSS 控制 SVG
图形的尺寸、填色、边框色、过渡、移动变幻等相当实用的各种属性,除此之外,将图形分解的动画在这种条件下也变得相当简单。

Performance.now()

高分辨率时间API提供了一个名为now()的函数,它返回一个DOMHighResTimeStamp对象,这是一个浮点数值,以毫秒级别(精确到千分之一毫秒)显示当前时间。单独这个数值并不会为你的分析带来多少价值,但是两个这样的数值的差值,就可以精确描述过去了多少时间。

这个函数除了比内置的Date对象更加精确以外,它还是“单调”的,简单说,这意味着它不会受操作系统(例如,你笔记本上的操作系统)周期性修改系统时间影响。更简单的说,定义两个Date实例,计算它们的差值,并不代表过去了多少时间。

“单调性”的数学定义是“(一个函数或者数值)以从不减少或者从不增加的方式改变”。

我们可以从另外一种途径来解释它,即想象使用它来在一年中让时钟向前或者向后改变。例如,当你所在国家的时钟都同意略过一个小时,以便最大化利用白天的时间。如果你在时钟修改之前创建了一个Date实例,然后在修改之后创建了另外一个,那么查看这两个实例的差值,看上去可能像“1小时零3秒又123毫秒”。而使用两个performance.now()实例,差值会是“3秒又123毫秒456789之一毫秒”。

在这一节中,我不会涉及这个API的过多细节。如果你想学习更多相关知识或查看更多如何使用它的示例,我建议你阅读这篇文章:Discovering
the High Resolution Time
API。

既然你知道高分辨率时间API是什么以及如何使用它,那么让我们继续深入看一下它有哪些潜在的缺点。但是在此之前,我们定义一个名为makeHash()的函数,在这篇文章剩余的部分,我们会使用它。

JavaScript

function makeHash(source) {  var hash = 0;  if (source.length === 0)
return hash;  for (var i = 0; i < source.length; i++) {    var char =
source.charCodeAt(i);    hash = ((hash<<5)-hash)+char;    hash =
hash & hash; // Convert to 32bit integer  }  return hash; }

1
2
3
4
5
6
7
8
9
10
function makeHash(source) {
 var hash = 0;
 if (source.length === 0) return hash;
 for (var i = 0; i < source.length; i++) {
   var char = source.charCodeAt(i);
   hash = ((hash<<5)-hash)+char;
   hash = hash & hash; // Convert to 32bit integer
 }
 return hash;
}

我们可以通过下面的代码来衡量这个函数的执行效率:

JavaScript

var t0 = performance.now(); var result = makeHash(‘Peter’); var t1 =
performance.now(); console.log(‘Took’, (t1 – t0).toFixed(4),
‘milliseconds to generate:’, result);

1
2
3
4
var t0 = performance.now();
var result = makeHash(‘Peter’);
var t1 = performance.now();
console.log(‘Took’, (t1 – t0).toFixed(4), ‘milliseconds to generate:’, result);

如果你在浏览器中运行这些代码,你应该看到类似下面的输出:

JavaScript

Took 0.2730 milliseconds to generate: 77005292

1
Took 0.2730 milliseconds to generate: 77005292

这段代码的在线演示如下所示:

记住这个示例后,让我们开始下面的讨论。

索引

本文将讲到三个动效例子:

  • 箭头描线动效
  • 播放按钮滤镜动效
  • 虚线描线动效

动效来源:WLS-Adobe

即将聊到的 SVG 标签:

  • <path>
  • <g>
  • <symbol>
  • <defs>
  • <use>
  • <clipPath>
  • <mask>

以及属性:

  • viewBox
  • preserveAspectRatio
  • fill
  • stroke
  • stroke-dasharray
  • stroke-dashoffset
  • d
  • clip-path
  • mask

缺陷1 – 意外衡量不重要的事情

在上面的示例中,你可以注意到,我们在两次调用performance.now()中间只调用了makeHash()函数,然后将它的值赋给result变量。这给我们提供了函数的执行时间,而没有其他的干扰。我们也可以按照下面的方式来衡量代码的效率:

JavaScript

var t0 = performance.now(); console.log(makeHash(‘Peter’));  // bad
idea! var t1 = performance.now(); console.log(‘Took’, (t1 –
t0).toFixed(4), ‘milliseconds’);

1
2
3
4
var t0 = performance.now();
console.log(makeHash(‘Peter’));  // bad idea!
var t1 = performance.now();
console.log(‘Took’, (t1 – t0).toFixed(4), ‘milliseconds’);

这个代码片段的在线演示如下所示:

但是在这种情况下,我们将会测量调用makeHash(‘Peter’)函数花费的时间,以及将结果发送并打印到控制台上花费的时间。我们不知道这两个操作中每个操作具体花费多少时间,
只知道总的时间。而且,发送和打印输出的操作所花费的时间会依赖于所用的浏览器,甚至依赖于当时的上下文。

或许你已经完美的意识到console.log方式是不可以预测的。但是执行多个函数同样是错误的,即使每个函数都不会触发I/O操作。例如:

JavaScript

var t0 = performance.now(); var name = ‘Peter’; var result =
makeHash(name.toLowerCase()).toString(); var t1 = performance.now();
console.log(‘Took’, (t1 – t0).toFixed(4), ‘milliseconds to generate:’,
result);

1
2
3
4
5
var t0 = performance.now();
var name = ‘Peter’;
var result = makeHash(name.toLowerCase()).toString();
var t1 = performance.now();
console.log(‘Took’, (t1 – t0).toFixed(4), ‘milliseconds to generate:’, result);

同样,我们不会知道执行时间是怎么分布的。它会是赋值操作、调用toLowerCase()函数或者toString()函数吗?

从一个简单的例子说起

图片 6

要做出这样的效果,第一步是将图形画出来。徒手敲代码这种事还是留给图形工具来做,但是,为了更好地控制与制作动效,咱至少要做到读懂
SVG 代码。

SVG 的基本格式是使用 <svg> 标签对代码进行包裹,可直接将代码段插入 html
中,也可以保存成 svg 文件之后使用 imgobject 进行引用。

XHTML

<svg width=”100%” height=”100%”> <!– SVG markup here. –>
</svg>

1
2
3
<svg width="100%" height="100%">
<!– SVG markup here. –>
</svg>

由于交互动效所需,这里仅介绍直接使用 svg 标签的情况。

XHTML

<svg width=”90″ height=”13″ viewBox=”0 0 89.4 12.4″> <line
x1=”0″ y1=”6.2″ x2=”59.6″ y2=”6.2″></line> <line x1=”54.7″
y1=”0.7″ x2=”60.5″ y2=”6.5″></line> <line x1=”54.7″
y1=”11.7″ x2=”60.5″ y2=”5.8″></line> </svg>

1
2
3
4
5
<svg width="90" height="13" viewBox="0 0 89.4 12.4">
<line x1="0" y1="6.2" x2="59.6" y2="6.2"></line>
<line x1="54.7" y1="0.7" x2="60.5" y2="6.5"></line>
<line x1="54.7" y1="11.7" x2="60.5" y2="5.8"></line>
</svg>

这是箭头的代码段,使用了最简单的线条进行绘制。可以看到其中包裹了许多坐标样的属性值。有坐标就意味着有坐标系。

SVG
的坐标系存在三个概念:视窗、视窗坐标系、用户坐标系。视窗坐标系与用户坐标系属于
SVG 的两种坐标系统,默认情况下这两个坐标系的点是一一对应的。与 web
其他坐标系相同,原点位于视窗的左上角,x 轴水平向右,y 轴垂直向下。

图片 7

(图片来源:MDN-SVG
Tutorial-Positions)

SVG 的位置、大小与文档流中的块级元素相同,都可由 CSS 进行控制。

视窗即为在页面中 SVG 设定的尺寸可见部分,默认情况下 SVG 超出隐藏。

SVG 能通过 viewBox 属性就完成图形的位移与缩放。

viewBox属性值的格式为(x0,y0,u_width,u_height),每个值之间用逗号或者空格隔开,它们共同确定了视窗显示的区域:视窗左上角坐标设为(x0,y0)、视窗的宽设为
u_width,高为 u_height;这个变换对整个视窗都起作用。

下图展示了当 viewBox 尺寸与 SVG 尺寸相同、放大一倍、缩小一倍时的表现:

图片 8

图片 9

图片 10

一句话总结,就是用户坐标系需要以某种方式铺满整个视窗。默认的方式是以最短边为准铺满,也就是类似
background-size 中的 cover 值。通过 preserveAspectRatio
属性你可以控制用户坐标系的展开方式与位置,完美满足你的各种需求。

preserveAspectRatio
是一個以對齊為主,然後再選擇要自動填滿還是咖掉的屬性。——引用来源《SVG
研究之路 (23) – 理解 viewport 與
viewbox》

属性的语法如下:preserveAspectRatio="[defer] <align> [<meetOrSlice>]"

注意3个参数之间需要使用空格隔开。

defer:可选参数,只对 image 元素有效,如果 image 元素中
preserveAspectRatio 属性的值以 defer 开头,则意味着 image
元素使用引用图片的缩放比例,如果被引用的图片没有缩放比例,则忽略
defer。所有其他的元素都忽略这个字符串。

meetOrSlice:可选参数,可以去下列值:

  • meet – 默认值,统一缩放图形,让图形全部显示在 viewport 中。
  • slice – 统一缩放图形,让图形充满 viewport,超出的部分被剪裁掉。

——引用来源《突袭 HTML5 之 SVG 2D 入门6 –
坐标与变换》

align:必选参数。由两个名词组成。

這兩個名詞分別代表 viewbox 與 viewport 的 x 方向對齊模式,以及 y
方向的對齊模式,換句話說,可以想成:「水平置中 +
垂直靠上對齊」的這種感覺,不過在這個 align
的表現手法倒是很抽象,可以用下方的表格看出端倪:

图片 11

也因此我們要做一個「水平置中 + 垂直靠上對齊」的 viewbox
設定,就必須寫成:xMidYMin,做一個「水平靠右對齊 + 垂直靠下對齊」的
viewbox
設定,就必須寫成:xMaxYMax,不過這裡有個細節請特別注意,「Y」是大寫呀!真是不知道為什麼會這樣設計,我想或許跟命名規則有關吧!

——引用来源《SVG 研究之路 (23) – 理解 viewport 與
viewbox》

下图诠释了各种填充的效果:

图片 12

(图片来源:7 Coordinate Systems, Transformations and
Units)

在这一层面处理好图形的展示之后,剩下的所有变换,无论是 translate、rotate
还是 opacity,我们都可以全权交给 CSS
来处理,并且可以将图形细化到形状或者路径的层面进行变换。

然而实际情况是,刚才的那段代码,放进codepen之后是什么也看不见的,原因就在于这个路径的绘制既没有填充颜色也没有描边。

缺陷 #2 – 只衡量一次

另外一个常见的错误是只衡量一次,然后汇总花费的时间,并以此得出结论。很可能执行不同的次数会得出完全不同的结果。执行时间依赖于很多因素:

  • 编辑器热身的时间(例如,将代码编译成字节码的时间)
  • 主线程可能正忙于其它一些我们没有意识到的事情
  • 你的电脑的CPU可能正忙于一些会拖慢浏览器速度的事情

持续改进的方法是重复执行函数,就像这样:

JavaScript

var t0 = performance.now(); for (var i = 0; i < 10; i++) {
 makeHash(‘Peter’); } var t1 = performance.now(); console.log(‘Took’,
((t1 – t0) / 10).toFixed(4), ‘milliseconds to generate’);

1
2
3
4
5
6
var t0 = performance.now();
for (var i = 0; i < 10; i++) {
 makeHash(‘Peter’);
}
var t1 = performance.now();
console.log(‘Took’, ((t1 – t0) / 10).toFixed(4), ‘milliseconds to generate’);

这个示例的在线演示如下所示:

这种方法的风险在于我们的浏览器的JavaScript引擎可能会使用一些优化措施,这意味着当我们第二次调用函数时,如果输入时相同的,那么JavaScript引擎可能会记住了第一次调用的输出,然后简单的返回这个输出。为了解决这个问题,你可以使用很多不同的输入字符串,而不用重复的使用相同的输入(例如‘Peter’)。显然,使用不同的输入进行测试带来的问题就是我们衡量的函数会花费不同的时间。或许其中一些输入会花费比其它输入更长的执行时间。

填充——fill

fill 属性用于给形状填充颜色。

CSS

svg line { fill: #000; /* 填充黑色 */ }

1
2
3
svg line {
fill: #000; /* 填充黑色 */
}

填充色的透明度通过 fill-opacity 设置。

fill-rule 用于设置填充方式,算法较为抽象,除了 inherit
这个取值,还可取以下两种值:

nonzero:这个值采用的算法是:从需要判定的点向任意方向发射线,然后计算图形与线段交点的处的走向;计算结果从0开始,每有一个交点处的线段是从左到右的,就加1;每有一个交点处的线段是从右到左的,就减1;这样计算完所有交点后,如果这个计算的结果不等于0,则该点在图形内,需要填充;如果该值等于0,则在图形外,不需要填充。看下面的示例:

图片 13

evenodd:这个值采用的算法是:从需要判定的点向任意方向发射线,然后计算图形与线段交点的个数,个数为奇数则改点在图形内,需要填充;个数为偶数则点在图形外,不需要填充。看下图的示例:

图片 14

——引用来源《突袭 HTML5 之 SVG 2D 入门4 –
笔画与填充》

然而我们发现,我们的箭头即使填充了颜色,还是什么也看不见,问题就出在我们绘制的时候使用了没有面积的
line 标签。这个时候,就需要出动描边了。

缺陷 #3 – 太依赖平均值

在上一节中,我们学习到的一个很好的实践是重复执行一些操作,理想情况下使用不同的输入。然而,我们要记住使用不同的输入带来的问题,即某些输入的执行时间可能会花费所有其它输入的执行时间都长。这样让我们退一步来使用相同的输入。假设我们发送同样的输入十次,每次都打印花费了多长时间。我们会得到像这样的输出:

JavaScript

Took 0.2730 milliseconds to generate: 77005292 Took 0.0234 milliseconds
to generate: 77005292 Took 0.0200 milliseconds to generate: 77005292
Took 0.0281 milliseconds to generate: 77005292 Took 0.0162 milliseconds
to generate: 77005292 Took 0.0245 milliseconds to generate: 77005292
Took 0.0677 milliseconds to generate: 77005292 Took 0.0289 milliseconds
to generate: 77005292 Took 0.0240 milliseconds to generate: 77005292
Took 0.0311 milliseconds to generate: 77005292

1
2
3
4
5
6
7
8
9
10
Took 0.2730 milliseconds to generate: 77005292
Took 0.0234 milliseconds to generate: 77005292
Took 0.0200 milliseconds to generate: 77005292
Took 0.0281 milliseconds to generate: 77005292
Took 0.0162 milliseconds to generate: 77005292
Took 0.0245 milliseconds to generate: 77005292
Took 0.0677 milliseconds to generate: 77005292
Took 0.0289 milliseconds to generate: 77005292
Took 0.0240 milliseconds to generate: 77005292
Took 0.0311 milliseconds to generate: 77005292

请注意第一次时间和其它九次的时间完全不一样。这很可能是因为浏览器中的JavaScript引擎使用了优化措施,需要一些热身时间。我们基本上没有办法避免这种情况,但是会有一些好的补救措施来阻止我们得出一些错误的结论。

一种方式是去计算后面9次的平均时间。另外一种更加使用的方式是收集所有的结果,然后计算“中位数”。基本上,它会将所有的结果排列起来,对结果进行排序,然后取中间的一个值。这是performance.now()函数如此有用的地方,因为无论你做什么,你都可以得到一个数值。

让我们再试一次,这次我们使用中位数函数:

JavaScript

var numbers = []; for (var i=0; i < 10; i++) {  var t0 =
performance.now();  makeHash(‘Peter’);  var t1 = performance.now();
 numbers.push(t1 – t0); } function median(sequence) {  sequence.sort();
 // note that direction doesn’t matter  return
sequence[Math.ceil(sequence.length / 2)]; } console.log(‘Median time’,
median(numbers).toFixed(4), ‘milliseconds’);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var numbers = [];
for (var i=0; i < 10; i++) {
 var t0 = performance.now();
 makeHash(‘Peter’);
 var t1 = performance.now();
 numbers.push(t1 – t0);
}
 
function median(sequence) {
 sequence.sort();  // note that direction doesn’t matter
 return sequence[Math.ceil(sequence.length / 2)];
}
 
console.log(‘Median time’, median(numbers).toFixed(4), ‘milliseconds’);

描边——stroke

这个 stroke 可得大书特书,因为光是这个 stroke
就能搞定80%的描线动效。

直接通过 stroke 设置描边色,我们就能立刻看到刚才的箭头了。通过
stroke-width 则可以对描边的粗细进行修改。

CSS

svg line { stroke: #000; stroke-width: 1px; }

1
2
3
4
svg line {
stroke: #000;
stroke-width: 1px;
}

图片 15

缺陷 #4 – 以可预测的方式比较函数

我们已经理解衡量一些函数很多次并取平均值总会是一个好主意。而且,上面的示例告诉我们使用中位数要比平均值更好。

在实际中,衡量函数执行时间的一个很好的用处是来了解在几个函数中,哪个更快。假设我们有两个函数,它们的输入参数类型一致,输出结果相同,但是它们的内部实现机制不一样。

例如,我们希望有一个函数,当特定的字符串在一个字符串数组中存在时,函数返回true或者false,但这个函数在比较字符串时不关心大小写。换句话说,我们不能直接使用Array.prototype.indexOf方法,因为这个方法是大小写敏感的。下面是这个函数的一个实现:

JavaScript

function isIn(haystack, needle) {  var found = false;
 haystack.forEach(function(element) {    if (element.toLowerCase() ===
needle.toLowerCase()) {      found = true;    }  });  return found; }
console.log(isIn([‘a’,’b’,’c’], ‘B’));  // true
console.log(isIn([‘a’,’b’,’c’], ‘d’));  // false

1
2
3
4
5
6
7
8
9
10
11
12
function isIn(haystack, needle) {
 var found = false;
 haystack.forEach(function(element) {
   if (element.toLowerCase() === needle.toLowerCase()) {
     found = true;
   }
 });
 return found;
}
 
console.log(isIn([‘a’,’b’,’c’], ‘B’));  // true
console.log(isIn([‘a’,’b’,’c’], ‘d’));  // false

我们可以立刻发现这个方法有改进的地方,因为haystack.forEach循环总会遍历所有的元素,即使我们可以很快找到一个匹配的元素。现在让我们使用for循环来编写一个更好的版本。

JavaScript

function isIn(haystack, needle) {  for (var i = 0, len =
haystack.length; i < len; i++) {    if (haystack[i].toLowerCase()
=== needle.toLowerCase()) {      return true;    }  }  return false; }
console.log(isIn([‘a’,’b’,’c’], ‘B’));  // true
console.log(isIn([‘a’,’b’,’c’], ‘d’));  // false

1
2
3
4
5
6
7
8
9
10
11
function isIn(haystack, needle) {
 for (var i = 0, len = haystack.length; i < len; i++) {
   if (haystack[i].toLowerCase() === needle.toLowerCase()) {
     return true;
   }
 }
 return false;
}
 
console.log(isIn([‘a’,’b’,’c’], ‘B’));  // true
console.log(isIn([‘a’,’b’,’c’], ‘d’));  // false

现在我们来看哪个函数更快一些。我们可以分别运行每个函数10次,然后收集所有的测量结果:

JavaScript

function isIn1(haystack, needle) {  var found = false;
 haystack.forEach(function(element) {    if (element.toLowerCase() ===
needle.toLowerCase()) {      found = true;    }  });  return found; }
function isIn2(haystack, needle) {  for (var i = 0, len =
haystack.length; i < len; i++) {    if (haystack[i].toLowerCase()
=== needle.toLowerCase()) {      return true;    }  }  return false; }
console.log(isIn1([‘a’,’b’,’c’], ‘B’));  // true
console.log(isIn1([‘a’,’b’,’c’], ‘d’));  // false
console.log(isIn2([‘a’,’b’,’c’], ‘B’));  // true
console.log(isIn2([‘a’,’b’,’c’], ‘d’));  // false function
median(sequence) {  sequence.sort();  // note that direction doesn’t
matter  return sequence[Math.ceil(sequence.length / 2)]; } function
measureFunction(func) {  var letters =
‘a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z’.split(‘,’);  var
numbers = [];  for (var i = 0; i < letters.length; i++) {    var t0
= performance.now();    func(letters, letters[i]);    var t1 =
performance.now();    numbers.push(t1 – t0);  }  console.log(func.name,
‘took’, median(numbers).toFixed(4)); } measureFunction(isIn1);
measureFunction(isIn2);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
function isIn1(haystack, needle) {
 var found = false;
 haystack.forEach(function(element) {
   if (element.toLowerCase() === needle.toLowerCase()) {
     found = true;
   }
 });
 return found;
}
 
function isIn2(haystack, needle) {
 for (var i = 0, len = haystack.length; i < len; i++) {
   if (haystack[i].toLowerCase() === needle.toLowerCase()) {
     return true;
   }
 }
 return false;
}
 
console.log(isIn1([‘a’,’b’,’c’], ‘B’));  // true
console.log(isIn1([‘a’,’b’,’c’], ‘d’));  // false
console.log(isIn2([‘a’,’b’,’c’], ‘B’));  // true
console.log(isIn2([‘a’,’b’,’c’], ‘d’));  // false
 
function median(sequence) {
 sequence.sort();  // note that direction doesn’t matter
 return sequence[Math.ceil(sequence.length / 2)];
}
 
function measureFunction(func) {
 var letters = ‘a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z’.split(‘,’);
 var numbers = [];
 for (var i = 0; i < letters.length; i++) {
   var t0 = performance.now();
   func(letters, letters[i]);
   var t1 = performance.now();
   numbers.push(t1 – t0);
 }
 console.log(func.name, ‘took’, median(numbers).toFixed(4));
}
 
measureFunction(isIn1);
measureFunction(isIn2);

我们运行上面的代码, 可以得出如下的输出:

JavaScript

true false true false isIn1 took 0.0050 isIn2 took 0.0150

1
2
3
4
5
6
true
false
true
false
isIn1 took 0.0050
isIn2 took 0.0150

这个示例的在线演示如下所示:

到底发生了什么?第一个函数的速度要快3倍!那不是我们假设的情况。

其实假设很简单,但是有些微妙。第一个函数使用了haystack.forEach方法,浏览器的JavaScript引擎会为它提供一些底层的优化,但是当我们使用数据索引技术时,JavaScript引擎没有提供对应的优化。这告诉我们:在真正测试之前,你永远不会知道。

线的虚实:stroke-dasharray

(敲黑板)王牌属性出现辣!
这个属性的属性值是1到 n 个数字,多个数字由逗号隔开,CSS
中的定义则由空格分开,每个数字定义了实线段的长度,分别是按照绘制、不绘制这个顺序循环下去。

下面是设置了1个、2个、3个数字时虚线的描绘情况对比:

图片 16

发表评论

电子邮件地址不会被公开。 必填项已用*标注

标签:, ,
网站地图xml地图