金沙国际官网_金沙国际平台登录

因为这个金沙国际官网_金沙国际平台登录网站与很多的大型澳门赌场都有合作,金沙国际官网_金沙国际平台登录尽职尽责,高效执行,保持好奇心,不断学习,追求卓越,点击进入金沙国际官网_金沙国际平台登录马上体验吧,所以现在也正式地开始了营业。

您的位置:金沙国际官网 > web前端 > 响应式增强设计,什么是函数组合

响应式增强设计,什么是函数组合

发布时间:2019-11-03 01:48编辑:web前端浏览(83)

    HTML imports 入门

    2015/02/10 · HTML5 · HTML, imports

    本文由 伯乐在线 - XfLoops 翻译,周进林 校稿。未经许可,禁止转载!
    英文出处:webcomponents.org。欢迎加入翻译组。

    Template、Shadow DOM及Custom Elements 让你创建UI组件比以前更容易了。但是像HTML、CSS、JavaScript这样的资源仍然需要一个个地去加载,这是很没效率的。

    删除重复依赖也并不简单。例如,现在加载jQuery UI或Bootstrap就需要为JavaScript、CSS及Web Fonts添加单独的标签。如果你的Web 组件应用了多重的依赖,那事情就变得更为复杂。

    HTML 导入让你以一个合并的HTML文件来加载这些资源。

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

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

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

    图片 1

    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 评论

    图片 2

    响应式增强设计

    2015/03/18 · CSS, HTML5, JavaScript · 响应式, 设计

    本文由 伯乐在线 - fzr 翻译,黄利民 校稿。未经许可,禁止转载!
    英文出处:24ways.org。欢迎加入翻译组。

    24ways 在这10年中已经逐渐变得强大了。在因特网历史中这已是一个永远不可磨灭的了。回想一下在那段时间里我们见证所有变化:Ajax的兴起,移动设备的激增,前端开发工具不可预知的前景。

    工具和技术来来往往,兴起衰落,但在过去的十年中有一件事于我而言是一直没有变化的:渐进式增强。

    渐进式增强不是一门技术。它更像是一种思考方式。渐进式增强鼓励你去思考网页所提供的基本意义,而不是去想一个已完成网页如何展示的细小问题。所以渐进式增强允许你以更抽象的方式思考核心功能,而不是纠结于网页在不错的宽屏设备上的理想状态。

    一旦你已经确定要添加的核心功能是什么–向购物栏中添加一件商品,发布一条消息,分享一张图片–然后你可以以一种最简单的方式实现该功能。那通常也意味着要从优秀的老式的HTML入手。你所需要的通常只是链接和表格。然后,只要你已经使得该核心功能基本工作,你就可以开始对更多现代浏览器加强功能以逐步提供更好的用户体验。

    以这种方式工作的好处不仅仅是你的网页可以在旧式浏览器中工作(尽管只是基本能运行)。它还能保证如果在现在的浏览器中出现的小毛病不至于酿成大祸。

    人们对渐进式增强存在一个误解,认为渐进式增强就是花时间解决旧式浏览器,然而事实却相反。将基本功能投入使用并不会花费太久。而且一旦你已经完成这部分工作,你就可以随心所欲地去测试最新最好的浏览器技术,脑中的意识是即使它们现在还不能被普遍支持,也没有问题,因为你已经把最可靠的东西投入使用了。

    看待Web发展的关键在于意识到不会有最终的接口—可能会有很多只有轻微差别但会依赖于任意时刻任意用户的属性和容量的接口。网站不需要在每一个浏览器中都一模一样。

    真正理解了这个就是一个极大地进步。你可以把时间花费在为更多浏览器提供最好体验的同时保证能在任何建立工作的地方实现核心功能,而不是努力使你的网站在差异巨大的浏览器中一模一样。

    允许我以一个简单的例子来表述:导航。

    第一步:核心功能

    假设我们现在有一个关于圣诞节12天欢庆的简单网站,一天一个页面。这个核心功能也相当清晰了:

    1、了解其中任意一天。
    2、从一天到另一天浏览。

    第一个功能可以通过将文本用头条,段落以及所有常用的HTML结构化标签组装起来实现。第二个则通过一系列的超链接实现。
    那么现在导航列表最适合放在哪里呢?个人而言,我是一个跳转到页脚导航模式的粉丝。这个模式先放网页内容,其次才是导航。页面顶部有一个带有href属性的连接指向导航的标签。

    XHTML

    <a class="control" href="#menu">Menu</a> ... <nav id="menu" role="navigation">... <a class="control" href="#top">Dismiss</a></nav>

    1
    2
    3
    4
    5
    <a class="control" href="#menu">Menu</a>
    ...
     
    <nav id="menu" role="navigation">...
    <a class="control" href="#top">Dismiss</a></nav>

    查看页脚超链导航模式的演示。

    由于只有超链接,这个模式也只是在网络初兴时期能在每一个浏览器上工作。Web浏览器要做的只是展示超链接(正如名字所示)。

    第二步:增强型布局

    在小屏幕设备上,比如移动电话,页脚链接模式是一个相当简洁的解决办法。一旦有更多的屏幕空间可使用时,就可以使用CSS将导航重新定位在内容之上。我可以设置position属性为absolute,使用弹性布局盒,或者设置display属性为table。

    CSS

    @media all and (min-width: 35em) { .control { display: none; } body { display: table; } [role="navigation"] { display: table-caption; columns: 6 15em; } }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    @media all and (min-width: 35em) {
      .control {
        display: none;
      }
      body {
        display: table;
      }
      [role="navigation"] {
        display: table-caption;
        columns: 6 15em;
      }
    }

    查看宽屏样式的演示。

    第三步:增强!

    没错。现在我已经可以为所有人提供核心功能了,而且对宽屏也有相当不错的响应风格设计。到这里我可以停下脚步了,但渐进式增强的实际优点却是我还没有做到的。从这儿开始,我可以疯狂地为现代浏览器添加各种奇特的优化效果,而不用担心不能为旧式浏览器提供退路—退路已经准备好了。

    实际上我想为小屏幕的设备提供一个漂亮的屏外画布。下面是我的规划:

    1、 将导航放置在主内容下面。
    2、 监听伪类为.control的链接是否被点击并拦截其反应。
    3、 当这些链接被点击后,为主体body切换赋予伪类.active。
    4、 如果伪类.active存在,将内容滑出以显示导航。

    下面是定位内容和导航的CSS代码:

    CSS

    @media all and (max-width: 35em) { [role="main"] { transition: all .25s; width: 100%; position: absolute; z-index: 2; top: 0; right: 0; } [role="navigation"] { width: 75%; position: absolute; z-index: 1; top: 0; right: 0; } .active [role="main"] { transform: translateX(-75%); } }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    @media all and (max-width: 35em) {
      [role="main"] {
        transition: all .25s;
        width: 100%;
        position: absolute;
        z-index: 2;
        top: 0;
        right: 0;
      }
      [role="navigation"] {
        width: 75%;
        position: absolute;
        z-index: 1;
        top: 0;
        right: 0;
      }
      .active [role="main"] {
        transform: translateX(-75%);
      }
    }

    在我的JavaScript代码中,我将会监听伪类.control链接上的任何点击事件,然后据此为主体body切换赋予伪类.active。

    JavaScript

    (function (win, doc) { 'use strict'; var linkclass = 'control', activeclass = 'active', toggleClassName = function (element, toggleClass) { var reg = new RegExp('(s|^)' + toggleClass + '(s|$)'); if (!element.className.match(reg)) { element.className += ' ' + toggleClass; } else { element.className = element.className.replace(reg, ''); } }, navListener = function (ev) { ev = ev || win.event; var target = ev.target || ev.srcElement; if (target.className.indexOf(linkclass) !== -1) { ev.preventDefault(); toggleClassName(doc.body, activeclass); } }; doc.addEventListener('click', navListener, false); }(this, this.document));

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    (function (win, doc) {
      'use strict';
      var linkclass = 'control',
        activeclass = 'active',
        toggleClassName = function (element, toggleClass) {
          var reg = new RegExp('(s|^)' + toggleClass + '(s|$)');
          if (!element.className.match(reg)) {
            element.className += ' ' + toggleClass;
          } else {
            element.className = element.className.replace(reg, '');
          }
        },
        navListener = function (ev) {
          ev = ev || win.event;
          var target = ev.target || ev.srcElement;
          if (target.className.indexOf(linkclass) !== -1) {
            ev.preventDefault();
            toggleClassName(doc.body, activeclass);
          }
        };
      doc.addEventListener('click', navListener, false);
    }(this, this.document));

    我已经准备就绪了,是吗?哪有那么快!

    使用HTML导入

    为加载一个HTML文件,你需要增加一个link标签,其rel属性为import,herf属性是HTML文件的路径。例如,如果你想把component.html加载到index.html:

    index.html

    XHTML

    <link rel="import" href="component.html" >

    1
    <link rel="import" href="component.html" >

    你可以往HTML导入文件(译者注:本文将“ the imported HTML”译为“HTML导入文件”,将“the original HTML”译为“HTML主文件”。例如,index.html是HTML主文件,component.html是HTML导入文件。)添加任何的资源,包括脚本、样式表及字体,就跟往普通的HTML添加资源一样。

    component.html

    XHTML

    <link rel="stylesheet" href="css/style.css"> <script src="js/script.js"></script>

    1
    2
    <link rel="stylesheet" href="css/style.css">
    <script src="js/script.js"></script>

    doctype、html、 head、 body这些标签是不需要的。HTML 导入会立即加载要导入的文档,解析文档中的资源,如果有脚本的话也会立即执行它们。

    标准符合测试

    我假设在我的代码中已经实现addEventListener函数。这并不是一个安全的假设。因为JavaScript不像HTML或CSS那样具有容错性。如果你使用了一个浏览器不能识别的HTML元素或属性,或是使用了一个浏览器不能理解的CSS选择器,属性或是值,那都不是大问题。浏览器会忽略掉它不能识别的东西:既不会抛出错误也不会停止解析文件。

    JavaScript就不同了。如果你的JavaScript代码有错误,又或者使用了一个浏览器不能辨识的JavaScript函数或属性,浏览器会抛出错误,而且会停止解析文件。这就是为什么JavaScript中特征在使用之前必须要测试。这也说明将核心功能依赖于JavaScript是非常不安全的。

    就我而言,我需要测试addEventListener函数的存在性:

    JavaScript

    (function (win, doc) { if (!win.addEventListener) { return; } ... var enhanceclass = 'cutsthemustard'; doc.documentElement.className += ' ' + enhanceclass; }(this, this.document));

    1
    2
    3
    4
    5
    6
    7
    8
    (function (win, doc) {
      if (!win.addEventListener) {
        return;
      }
      ...
      var enhanceclass = 'cutsthemustard';
      doc.documentElement.className += ' ' + enhanceclass;
    }(this, this.document));

    BBC的大牛们称这种特征测试为标准符合测试。如果一个浏览器通过了该测试,它就达到了标准,所以它就获得了增强性能。如果一个浏览器没能达到标准,它就没有增强的性能。这也不算什么坏事,记住,网站不需要在每个浏览器中都表现的一样。

    我希望确保我的离线画布样式只能应用于符合标准的浏览器。我会使用JavaScript为文档添加一个伪类.cutsthemustard:

    JavaScript

    (function (win, doc) { if (!win.addEventListener) { return; } ... var enhanceclass = 'cutsthemustard'; doc.documentElement.className += ' ' + enhanceclass; }(this, this.document));

    1
    2
    3
    4
    5
    6
    7
    8
    (function (win, doc) {
      if (!win.addEventListener) {
        return;
      }
      ...
      var enhanceclass = 'cutsthemustard';
      doc.documentElement.className += ' ' + enhanceclass;
    }(this, this.document));

    现在我可以使用已存在的类名来调整我的CSS:

    CSS

    @media all and (max-width: 35em) { .cutsthemustard [role="main"] { transition: all .25s; width: 100%; position: absolute; z-index: 2; top: 0; right: 0; } .cutsthemustard [role="navigation"] { width: 75%; position: absolute; z-index: 1; top: 0; right: 0; } .cutsthemustard .active [role="main"] { transform: translateX(-75%); } }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    @media all and (max-width: 35em) {
      .cutsthemustard [role="main"] {
        transition: all .25s;
        width: 100%;
        position: absolute;
        z-index: 2;
        top: 0;
        right: 0;
      }
      .cutsthemustard [role="navigation"] {
        width: 75%;
        position: absolute;
        z-index: 1;
        top: 0;
        right: 0;
      }
      .cutsthemustard .active [role="main"] {
        transform: translateX(-75%);
      }
    }

    查看符合标准的增强型离线画布导航演示。记住,这只适用于小屏幕,所以你可能会需要将浏览器窗口压扁。

    执行顺序

    浏览器解析HTML文档的方式是线性的,这就是说HTML顶部的script会比底部先执行。并且,浏览器通常会等到JavaScript代码执行完毕后,才会接着解析后面的代码。

    为了不让script 妨碍HTML的渲染,你可以在标签中添加async或defer属性(或者你也可以将script 标签放到页面的底部)。defer 属性会延迟脚本的执行,直到全部页面解析完毕。async 属性让浏览器异步地执行脚本,从而不会妨碍HTML的渲染。那么,HTML 导入是怎样工作的呢?

    HTML导入文件中的脚本就跟含有defer属性一样。例如在下面的示例中,index.html会先执行script1.js和script2.js ,然后再执行script3.js。

    index.html

    XHTML

    <link rel="import" href="component.html"> // 1. <title>Import Example</title> <script src="script3.js"></script> // 4.

    1
    2
    3
    <link rel="import" href="component.html"> // 1.
    <title>Import Example</title>
    <script src="script3.js"></script>        // 4.

    component.html

    XHTML

    <script src="js/script1.js"></script> // 2. <script src="js/script2.js"></script> // 3.

    1
    2
    <script src="js/script1.js"></script>     // 2.
    <script src="js/script2.js"></script>     // 3.

    1.在index.html 中加载component.html并等待执行

    2.执行component.html中的script1.js

    3.执行完script1.js后执行component.html中的script2.js

    4.执行完 script2.js继而执行index.html中的script3.js

    注意,如果给link[rel=”import”]添加async属性,HTML导入会把它当做含有async属性的脚本来对待。它不会等待HTML导入文件的执行和加载,这意味着HTML 导入不会妨碍HTML主文件的渲染。这也给提升网站性能带来了可能,除非有其他的脚本依赖于HTML导入文件的执行。

    增强所有!

    这仅仅是一个相对比较简单的例子,但它阐明了渐进式增强背后的思想:只要你已经为所有人提供了核心功能,就可以随意为现代浏览器增加最流行的增强性能。

    渐进式增强并不意味着你必须为所有人都提供一模一样的功能—恰恰相反。这也是为什么需要尽早确定你的核心功能是什么,而且确保这个核心功能可以被大多数基本技术提供实现。在这个点的基础上,你可以随意添加更多的不属于关键任务的特征。你可以在能支持更多特征的浏览器上相应的添加更多的属性,比如CSS的动画效果,JavaScript的定位功能以及HTML中新的输入框类型。

    正如我所说的,渐进式增强不是一门技术。它是一种思考方式。如果你已经开始使用这种思考方式,你就已经准备好了面对接下来的十年了。

    赞 1 收藏 评论

    跨域导入

    从根本上说,HTML导入是不能从其他的域名导入资源的。

    比如,你不能从向  导入HTML 文件。为了绕过这个限制,可以使用CORS(跨域资源共享)。想了解CORS,请看这篇文章。

    关于作者:fzr

    图片 3

    微博:@fzr-fzr) 个人主页 · 我的文章 · 26

    图片 4

    本文由金沙国际官网发布于web前端,转载请注明出处:响应式增强设计,什么是函数组合

    关键词: