您的位置:奥门新浦京网址 > Wed前段 > H5单页面手势滑屏切换原理,什么是函数组合

H5单页面手势滑屏切换原理,什么是函数组合

发布时间:2019-12-03 06:53编辑:Wed前段浏览(54)

    管理页面的 setTimeout & setInterval

    2017/09/28 · JavaScript · setInterval, settimeout

    原文出处: 凹凸实验室   

    图片 1在管理 setTimeout & setInterval 这两个 APIs 时,笔者通常会在顶级(全局)作用域创建一个叫 timer 的对象,在它下面有两个数组成员 —— {sto, siv},用它们来分别存储需要管理的 setTimeoutID / setIntervalID。如下:

    JavaScript

    var timer = { sto: [], siv: [] };

    1
    2
    3
    4
    var timer = {
    sto: [],
    siv: []
    };

    在使用 setTimeout / setInterval 的时候,这样调用:

    JavaScript

    // 标记 setTimeoutID timer.sto.push( setTimeout(function() {console.log("3s")}, 3000); ); // 标记 setIntervalID timer.siv.push( setInterval(function() {console.log("1s")}, 1000) );

    1
    2
    3
    4
    5
    6
    7
    8
    // 标记 setTimeoutID
    timer.sto.push(
    setTimeout(function() {console.log("3s")}, 3000);
    );
    // 标记 setIntervalID
    timer.siv.push(
    setInterval(function() {console.log("1s")}, 1000)
    );

    在页面需要 clearTimeout clearInterval 的时候,这样调用:

    JavaScript

    // 批量清除 setTimeout timer.sto.forEach(function(sto) {clearTimeout(sto)}); // 批量清除 setInterval timer.siv.forEach(function(siv) {clearInterval(siv)});

    1
    2
    3
    4
    // 批量清除 setTimeout
    timer.sto.forEach(function(sto) {clearTimeout(sto)});
    // 批量清除 setInterval
    timer.siv.forEach(function(siv) {clearInterval(siv)});

    征服 JavaScript 面试:什么是函数组合

    2017/01/30 · JavaScript · 2 评论 · 函数

    原文出处: Eric Elliott   译文出处:众成翻译   

    图片 2

    Google 数据中心管道 — Jorge Jorquera — (CC-BY-NC-ND-2.0)

    “征服 JavaScript 面试”是我写的一系列文章,来帮助面试者准备他们在面试 JavaScript 中、高级职位中将可能会遇到的一些问题。这些问题我自己在面试中也经常会问。

    函数式编程正在接管 JavaScript 世界。就在几年前,只有少数 JavaScript 程序员知道函数式编程是什么。然而,在过去 3 年内,我所看到的每个大型应用程序代码库都大量用到了函数式编程理念。

    函数组合就是组合两到多个函数来生成一个新函数的过程。将函数组合在一起,就像将一连串管道扣合在一起,让数据流过一样。

    简而言之,函数 fg 的组合可以被定义为 f(g(x)),从内到外(从右到左)求值。也就是说,求值顺序是:

    1. x
    2. g
    3. f

    下面我们在代码中更近距离观察一下这个概念。假如你想把用户的全名转换为 URL Slug,给每个用户一个个人信息页面。为了实现此需求,你需要经历一连串的步骤:

    1. 将姓名根据空格分拆(split)到一个数组中
    2. 将姓名映射(map)为小写
    3. 用破折号连接(join)
    4. 编码 URI 组件

    如下是一个简单的实现:

    JavaScript

    const toSlug = input => encodeURIComponent( input.split(' ') .map(str => str.toLowerCase()) .join('-') );

    1
    2
    3
    4
    5
    const toSlug = input => encodeURIComponent(
      input.split(' ')
        .map(str => str.toLowerCase())
        .join('-')
    );

    还不赖…但是假如我告诉你可读性还可以更强一点会怎么样呢?

    假设每个操作都有一个对应的可组合的函数。上述代码就可以被写为:

    JavaScript

    const toSlug = input => encodeURIComponent( join('-')( map(toLowerCase)( split(' ')( input ) ) ) ); console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    const toSlug = input => encodeURIComponent(
      join('-')(
        map(toLowerCase)(
          split(' ')(
            input
          )
        )
      )
    );
     
    console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

    这看起来比我们的第一次尝试更难读懂,但是先忍一下,我们就要解决。

    为了实现上述代码,我们将组合几种常用的工具,比如 split()join()map()。如下是实现:

    JavaScript

    const curry = fn => (...args) => fn.bind(null, ...args); const map = curry((fn, arr) => arr.map(fn)); const join = curry((str, arr) => arr.join(str)); const toLowerCase = str => str.toLowerCase(); const split = curry((splitOn, str) => str.split(splitOn));

    1
    2
    3
    4
    5
    6
    7
    8
    9
    const curry = fn => (...args) => fn.bind(null, ...args);
     
    const map = curry((fn, arr) => arr.map(fn));
     
    const join = curry((str, arr) => arr.join(str));
     
    const toLowerCase = str => str.toLowerCase();
     
    const split = curry((splitOn, str) => str.split(splitOn));

    除了 toLowerCase() 外,所有这些函数经产品测试的版本都可以从 Lodash/fp 中得到。可以像这样导入它们:

    JavaScript

    import { curry, map, join, split } from 'lodash/fp';

    1
    import { curry, map, join, split } from 'lodash/fp';

    也可以像这样导入:

    JavaScript

    const curry = require('lodash/fp/curry'); const map = require('lodash/fp/map'); //...

    1
    2
    3
    const curry = require('lodash/fp/curry');
    const map = require('lodash/fp/map');
    //...

    这里我偷了点懒。注意这个 curry 从技术上来说,并不是一个真正的柯里化函数。真正的柯里化函数总会生成一个一元函数。这里的 curry 只是一个偏函数应用。请参考“柯里化和偏函数应用之间的区别是什么?”这篇文章。不过,这里只是为了演示用途,我们就把它当作一个真正的柯里化函数好了。

    回到我们的 toSlug() 实现,这里有一些东西真的让我很烦:

    JavaScript

    const toSlug = input => encodeURIComponent( join('-')( map(toLowerCase)( split(' ')( input ) ) ) ); console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    const toSlug = input => encodeURIComponent(
      join('-')(
        map(toLowerCase)(
          split(' ')(
            input
          )
        )
      )
    );
     
    console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

    对我来说,这里的嵌套太多了,读起来有点让人摸不着头脑。我们可以用一个会自动组合这些函数的函数来扁平化嵌套,就是说,这个函数会从一个函数得到输出,并自动将它传递给下一个函数作为输入,直到得到最终值为止。

    细想一下,好像数组中有一个函数可以做差不多的事情。这个函数就是 reduce(),它用一系列值为参数,对每个值应用一个函数,最后累加成一个结果。值本身也可以函数。但是 reduce() 是从左到右递减,为了匹配上面的组合行为,我们需要它从右到左缩减。

    好事情是刚好数组也有一个 reduceRight() 方法可以干这事:

    JavaScript

    const compose = (...fns) => x => fns.reduceRight((v, f) => f(v), x);

    1
    const compose = (...fns) => x => fns.reduceRight((v, f) => f(v), x);

    .reduce() 一样,数组的 .reduceRight() 方法带有一个 reducer 函数和一个初始值(x)为参数。我们可以用它从右到左迭代数组,将函数依次应用到每个数组元素上,最后得到累加值(v)。

    compose,我们就可以不需要嵌套来重写上面的组合:

    JavaScript

    const toSlug = compose( encodeURIComponent, join('-'), map(toLowerCase), split(' ') ); console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

    1
    2
    3
    4
    5
    6
    7
    8
    const toSlug = compose(
      encodeURIComponent,
      join('-'),
      map(toLowerCase),
      split(' ')
    );
     
    console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

    当然,lodash/fp 也提供了 compose()

    JavaScript

    import { compose } from 'lodash/fp';

    1
    import { compose } from 'lodash/fp';

    或者:

    JavaScript

    const compose = require('lodash/fp/compose');

    1
    const compose = require('lodash/fp/compose');

    当以数学形式的组合从内到外的角度来思考时,compose 是不错的。不过,如果想以从左到右的顺序的角度来思考,又该怎么办呢?

    还有另外一种形式,通常称为 pipe()。Lodash 称之为 flow():

    JavaScript

    const pipe = (...fns) => x => fns.reduce((v, f) => f(v), x); const fn1 = s => s.toLowerCase(); const fn2 = s => s.split('').reverse().join(''); const fn3 = s => s + '!' const newFunc = pipe(fn1, fn2, fn3); const result = newFunc('Time'); // emit!

    1
    2
    3
    4
    5
    6
    7
    8
    const pipe = (...fns) => x => fns.reduce((v, f) => f(v), x);
     
    const fn1 = s => s.toLowerCase();
    const fn2 = s => s.split('').reverse().join('');
    const fn3 = s => s + '!'
     
    const newFunc = pipe(fn1, fn2, fn3);
    const result = newFunc('Time'); // emit!

    可以看到,这个实现与 compose() 几乎完全一样。唯一的不同之处是,这里是用 .reduce(),而不是 .reduceRight(),即是从左到右缩减,而不是从右到左。

    下面我们来看看用 pipe() 实现的 toSlug() 函数:

    JavaScript

    const toSlug = pipe( split(' '), map(toLowerCase), join('-'), encodeURIComponent ); console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

    1
    2
    3
    4
    5
    6
    7
    8
    const toSlug = pipe(
      split(' '),
      map(toLowerCase),
      join('-'),
      encodeURIComponent
    );
     
    console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

    对于我来说,这要更容易读懂一些。

    骨灰级的函数式程序员用函数组合定义他们的整个应用程序。而我经常用它来消除临时变量。仔细看看 pipe() 版本的 toSlug(),你会发现一些特殊之处。

    在命令式编程中,在一些变量上执行转换时,在转换的每个步骤中都会找到对变量的引用。而上面的 pipe() 实现是用无点的风格写的,就是说完全找不到它要操作的参数。

    我经常将管道(pipe)用在像单元测试和 Redux 状态 reducer 这类事情上,用来消除中间变量。中间变量的存在只用来保存一个操作到下一个操作之间的临时值。

    这玩意开始听起来会比较古怪,不过随着你用它练习,会发现在函数式编程中,你是在和相当抽象、广义的函数打交道,而在这样的函数中,事物的名称没那么重要。名称只会碍事。你会开始把变量当作是多余的样板。

    就是说,我认为无点风格可能会被用过头。它可能会变得太密集,较难理解。但是如果你搞糊涂了,这里有一个小窍门…你可以利用 flow 来跟踪是怎么回事:

    JavaScript

    const trace = curry((label, x) => { console.log(`== ${ label }: ${ x }`); return x; });

    1
    2
    3
    4
    const trace = curry((label, x) => {
      console.log(`== ${ label }:  ${ x }`);
      return x;
    });

    如下是你用它来跟踪的方法:

    JavaScript

    const toSlug = pipe( trace('input'), split(' '), map(toLowerCase), trace('after map'), join('-'), encodeURIComponent ); console.log(toSlug('JS Cheerleader')); // '== input: JS Cheerleader' // '== after map: js,cheerleader' // 'js-cheerleader'

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    const toSlug = pipe(
      trace('input'),
      split(' '),
      map(toLowerCase),
      trace('after map'),
      join('-'),
      encodeURIComponent
    );
     
    console.log(toSlug('JS Cheerleader'));
    // '== input:  JS Cheerleader'
    // '== after map:  js,cheerleader'
    // 'js-cheerleader'

    trace() 只是更通用的 tap() 的一种特殊形式,它可以让你对流过管道的每个值执行一些行为。明白了么?管道(Pipe)?水龙头(Tap)?可以像下面这样编写 tap()

    JavaScript

    const tap = curry((fn, x) => { fn(x); return x; });

    1
    2
    3
    4
    const tap = curry((fn, x) => {
      fn(x);
      return x;
    });

    现在你可以看到为嘛 trace() 只是一个特殊情况下的 tap() 了:

    JavaScript

    const trace = label => { return tap(x => console.log(`== ${ label }: ${ x }`)); };

    1
    2
    3
    const trace = label => {
      return tap(x => console.log(`== ${ label }:  ${ x }`));
    };

    你应该开始对函数式编程是什么样子,以及偏函数应用柯里化如何与函数组合协作,来帮助你编写可读性更强的程序有点感觉了。

    1 赞 9 收藏 2 评论

    图片 3

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

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

    原文出处: 一像素   

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

    图片 4

    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路由),你也可以点击或扫描下面二维码来查看示例效果:

    图片 5

     

    3 赞 24 收藏 2 评论

    图片 6

    暂停 & 恢复

    近段时间,笔者发现很多业务都需要「暂停」和「恢复」setTimeout & setInterval 的功能,而仅靠原生的四个 APIs(setTimeout / setIntervale / clearTimeout / clearInterval)是不够用的。于是,笔者对 timer 进行了扩展,使它具备了「暂停」和「恢复」的功能,如下:

    JavaScript

    // 暂停所有的 setTimeout & setInterval timer.pause(); // 恢复所有的 setTimeout & setInterval timer.resume();

    1
    2
    3
    4
    // 暂停所有的 setTimeout & setInterval
    timer.pause();
    // 恢复所有的 setTimeout & setInterval
    timer.resume();

    扩展后的 timer对象下面挂载6个基础的 APIs。

    • setTimeout
    • setInterval
    • clearTimeout
    • clearInterval
    • pause
    • resume

    使用 timer.set* & timer.clear* 来代替原生的 set* & clear*。笔者把扩展后的 timer 托管在 GitHub 仓库上,有兴趣的同学可以移步:

    本文由奥门新浦京网址发布于Wed前段,转载请注明出处:H5单页面手势滑屏切换原理,什么是函数组合

    关键词: