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

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

您的位置:金沙国际官网 > web前端 > 浅谈javascript函数节流,深入理解

浅谈javascript函数节流,深入理解

发布时间:2019-11-03 17:41编辑:web前端浏览(141)

    10 个打造 React.js App 的最佳 UI 框架

    2017/05/26 · 基础技术 · React, UI

    原文出处: Vladimir Metnew   译文出处:IT程序狮   

    图片 1

    10 个打造 React.js App 的最佳 UI 框架

    在本文中,我们将分享一些助你打造 React.js App 最佳的 UI 框架。它们具备你所需要的基本 React 组件,以及易用的 API,同时,在外观和体验上也非常棒。Have Fun !


    浅谈javascript函数节流

    2016/03/14 · JavaScript · 函数

    原文出处: 涂根华   

    什么是函数节流?

         函数节流简单的来说就是不想让该函数在很短的时间内连续被调用,比如我们最常见的是窗口缩放的时候,经常会执行一些其他的操作函数,比如发一个ajax请求等等事情,那么这时候窗口缩放的时候,有可能连续发多个请求,这并不是我们想要的,或者是说我们常见的鼠标移入移出tab切换效果,有时候连续且移动的很快的时候,会有闪烁的效果,这时候我们就可以使用函数节流来操作。大家都知道,DOM的操作会很消耗或影响性能的,如果是说在窗口缩放的时候,为元素绑定大量的dom操作的话,会引发大量的连续计算,比如在IE下,过多的DOM操作会影响浏览器性能,甚至严重的情况下,会引起浏览器崩溃的发生。这个时候我们就可以使用函数节流来优化代码了~

    函数节流的基本原理:

         使用一个定时器,先延时该函数的执行,比如使用setTomeout()这个函数延迟一段时间后执行函数,如果在该时间段内还触发了其他事件,我们可以使用清除方法 clearTimeout()来清除该定时器,再setTimeout()一个新的定时器延迟一会儿执行。

    我们先来看一个简单的window.resize的demo例子,比如我先定义一个全局变量count=0;当我触发一次window.resize的时候,该全局变量count++; 我们来看看在控制台中打印出count的效果;JS代码如下:

    var count = 0; window.onresize = function(){ count++; console.log(count); }

    1
    2
    3
    4
    5
    var count = 0;
    window.onresize = function(){
        count++;
        console.log(count);
    }

    执行截图效果如下:

    图片 2

    如上resize的代码,简单的缩放一次就打印出多次,这并不是我们想要的效果,这是简单的测试,那如果我们换成ajax请求的话,那么就会缩放一次窗口会连续触发多次ajax请求,下面我们试着使用函数节流的操作试试一下;

    函数节流的第一种方案封装如下:

    function throttleFunc(method,context){ clearTimeout(method.tId); method.tId = setTimeout(function(){ method.call(context); },100); }

    1
    2
    3
    4
    5
    6
    function throttleFunc(method,context){
         clearTimeout(method.tId);
         method.tId = setTimeout(function(){
             method.call(context);
         },100);
    }

    我们再来封装一下窗口缩放的demo

    var count = 0; function myFunc() { count++; console.log(count); } window.onresize = function(){ throttleFunc(myFunc); } function throttleFunc(method,context){ clearTimeout(method.tId); method.tId = setTimeout(function(){ method.call(context); },100); }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    var count = 0;
    function myFunc() {
       count++;
       console.log(count);
    }
    window.onresize = function(){
        throttleFunc(myFunc);
    }
    function throttleFunc(method,context){
         clearTimeout(method.tId);
         method.tId = setTimeout(function(){
             method.call(context);
         },100);
    }

    如上代码,我们再来看看效果,窗口缩放和放大效果会看到,只执行了一次;打印了一次。

    上面的代码使用一个定时器每隔100毫秒执行一次;

    我们也可以使用闭包的方法对上面的函数进行再封装一下;

    函数节流的第二种封装方法如下:

    function throttle(fn, delay){ var timer = null; return function(){ var context = this, args = arguments; clearTimeout(timer); timer = setTimeout(function(){ fn.apply(context, args); }, delay); }; };

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    function throttle(fn, delay){
         var timer = null;
         return function(){
             var context = this,
                 args = arguments;
             clearTimeout(timer);
             timer = setTimeout(function(){
                 fn.apply(context, args);
             }, delay);
         };
    };

    上面第二种方案是使用闭包的方式形成一个私有的作用域来存放定时器timer,第二种方案的timer是通过传参数的形式引入的。

    调用demo代码如下:

    var count = 0; function myFunc() { count++; console.log(count); } var func = throttle(myFunc,100); window.onresize = function(){ func(); } function throttle(fn, delay){ var timer = null; return function(){ var context = this, args = arguments; clearTimeout(timer); timer = setTimeout(function(){ fn.apply(context, args); }, delay); }; };

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    var count = 0;
    function myFunc() {
        count++;
        console.log(count);
    }
    var func = throttle(myFunc,100);
    window.onresize = function(){
       func();
    }        
    function throttle(fn, delay){
         var timer = null;
         return function(){
             var context = this,
                 args = arguments;
             clearTimeout(timer);
             timer = setTimeout(function(){
                 fn.apply(context, args);
             }, delay);
         };
    };

    函数节流的基本思想是:就是想让一个函数不要执行的太频繁,减少一些过快的来节流函数,比如当我们改变窗口缩放的时候,浏览器的间隔有可能是16ms,这是浏览器自带的时间间隔,我们无法改变,而我们通过节流的方式可以试着改变一下这个间隔,尽量稍微延长下这个调用时间,因此我们可以封装如下函数:

    函数节流的第三种封装方法

    function throttle3(fn,delay,runDelay){ var timer = null; var t_start; return function(){ var context = this, args = arguments, t_cur = new Date(); timer & clearTimeout(timer); if(!t_start) { t_start = t_cur; } if(t_cur - t_start >= runDelay) { fn.apply(context,args); t_start = t_cur; }else { timer = setTimeout(function(){ fn.apply(context,args); },delay); } } }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    function throttle3(fn,delay,runDelay){
          var timer = null;
          var t_start;
          return function(){
             var context = this,
                 args = arguments,
                 t_cur = new Date();
             timer & clearTimeout(timer);
             if(!t_start) {
                 t_start = t_cur;
             }
             if(t_cur - t_start >= runDelay) {
                  fn.apply(context,args);
                  t_start = t_cur;
             }else {
                  timer = setTimeout(function(){
                      fn.apply(context,args);
                   },delay);
             }
        }
    }

    调用demo如下:

    var count = 0; function myFunc() { count++; console.log(count); } var func = throttle3(myFunc,50,100); window.onresize = function(){ func();} function throttle3(fn,delay,runDelay){ var timer = null; var t_start; return function(){ var context = this, args = arguments, t_cur = new Date(); timer & clearTimeout(timer); if(!t_start) { t_start = t_cur; } if(t_cur - t_start >= runDelay) { fn.apply(context,args); t_start = t_cur; }else { timer = setTimeout(function(){ fn.apply(context,args); },delay); } } }

    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
    var count = 0;
    function myFunc() {
       count++;
       console.log(count);
    }
    var func = throttle3(myFunc,50,100);
    window.onresize = function(){
       func();}
    function throttle3(fn,delay,runDelay){
          var timer = null;
          var t_start;
          return function(){
              var context = this,
                  args = arguments,
                  t_cur = new Date();
              timer & clearTimeout(timer);
              if(!t_start) {
                  t_start = t_cur;
              }
              if(t_cur - t_start >= runDelay) {
                    fn.apply(context,args);
                    t_start = t_cur;
              }else {
                    timer = setTimeout(function(){
                         fn.apply(context,args);
                    },delay);
              }
          }
    }

    上面的第三个函数是封装后的函数,有三个参数,我们可以自己设置触发事件的时间间隔,则意味着,如上代码50ms连续调用函数,后一个调用会把前一个调用的等待处理掉,但每隔100ms会至少执行一次,具体使用哪一种方式只要看自己的权衡,但是我个人觉得第二种封装函数的方式够我们使用的,当然据说第三种方式性能更好~

    1 赞 3 收藏 评论

    图片 3

    深入理解 JSON

    2017/03/29 · JavaScript · 2 评论 · JSON

    原文出处: Apriltail   

    我们先来看一个JS中常见的JS对象序列化成JSON字符串的问题,请问,以下JS对象通过JSON.stringify后的字符串是怎样的?先不要急着复制粘贴到控制台,先自己打开一个代码编辑器或者纸,写写看,写完再去仔细对比你的控制台输出,如果有误记得看完全文并评论,哈哈。

    JavaScript

    var friend={ firstName: 'Good', 'lastName': 'Man', 'address': undefined, 'phone': ["1234567",undefined], 'fullName': function(){ return this.firstName + ' ' + this.lastName; } }; JSON.stringify(friend);//这一行返回什么呢?

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    var friend={  
        firstName: 'Good',
        'lastName': 'Man',
        'address': undefined,
        'phone': ["1234567",undefined],
        'fullName': function(){
            return this.firstName + ' ' + this.lastName;
        }
    };
     
    JSON.stringify(friend);//这一行返回什么呢?

    第二个问题,如果我想在最终JSON字符串将这个’friend’的姓名全部变成大写字母,也就是把”Good”变成”GOOD”,把”Man”变成”MAN”,那么可以怎么做?

    基于以上两个问题,我们再追本溯源问一下,JSON究竟是什么东西?为什么JSON就是易于数据交换?JSON和JS对象的区别?JS中JSON.parseJSON.stringify和不常见的toJSON,这几个函数的参数和处理细节到底是怎样的?

    欢迎进入本次“深挖JSON之旅”,下文将从以下几个方面去理解JSON:

    • 首先是对“JSON是一种轻量的数据交换格式”的理解;
    • 然后来看经常被混为一谈的JSON和JS对象的区别;
    • 最后我们再来看JS中这几个JSON相关函数具体的执行细节。

    希望全文能让如之前的我一样对JSON一知半解的亲能说清楚JSON是什么,也能熟练运用JSON,不看控制台就知道JS对象序列化成JSON字符串后输出是啥。

    1. Material-UI

    图片 4

    基于谷歌 Material Design 设计规范的 React 组件

    此外,它还是 React 的第一个 UI 套件。Material-UI具备你所需要的所有组件(甚至更多),以及可配置性极高的预定义调色板和``,帮助你为应用程序定制相应的颜色主题。

    由于 Material-UI 过去的版本中存在一些性能问题,就我个人而言,不是很满意。但自3.0 版本发布后的反馈来看,它在性能方面已有所改善。

    项目地址:【传送门】

    一、JSON是一种格式,基于文本,优于轻量,用于交换数据

    如果没有去过JSON的官方介绍可以去一下这里,官方介绍第一、二段已经很清楚地表述了JSON是什么,我将JSON是什么提炼成以下几个方面:

    2. React Desktop

    图片 5

    专为 MacOS Sierra 和 Windows 10 提供的 React UI 组件

    关于Electron 框架,我相信你已经有所了解。如果你对跨平台桌面应用程序 UI 组件也感兴趣的话,那么React-Desktop绝对是你的“菜”。你可以使用它轻松获取用于 Mac OS 和 Windows 10 系统上相应的 UI 组件。

    项目地址:【传送门】

    1. 一种数据格式

    什么是格式?就是规范你的数据要怎么表示,举个栗子,有个人叫“二百六”,身高“160cm”,体重“60kg”,现在你要将这个人的这些信息传给别人或者别的什么东西,你有很多种选择:

    • 姓名“二百六”,身高“160cm”,体重“60kg”
    • name="二百六"&height="160cm"&weight="60kg"
    • 二百六16060
    • {"name":"二百六","height":160,"weight":60}
    • … …

    以上所有选择,传递的数据是一样的,但是你可以看到形式是可以各式各样的,这就是各种不同格式化后的数据,JSON是其中一种表示方式。

    3. Semantic-UI-React

    图片 6

    由 Semantic-UI 官方出品的 React UI 组件

    就个人而言,我认为它是最好用的 React UI 框架。它是由官方基于Semantic-UI打造的 React 组件,它几乎涵盖了 Semantic-UI 上的所有组件,而且它还有一个易用的 Declarative API,以及用于 React 组件的 shorthand props,同时它能够做到 jQuery-free。

    另外,我做了一个使用 React-Semantic-UI,Webpack 构建项目的新手示例,你也可以来看看。

    项目地址:【传送门】

    2. 基于文本的数据格式

    JSON是基于文本的数据格式,相对于基于二进制的数据,所以JSON在传递的时候是传递符合JSON这种格式(至于JSON的格式是什么我们第二部分再说)的字符串,我们常会称为“JSON字符串”。

    4. Ant-design

    图片 7

    一套企业级 UI 设计语言和基于 React 实现的 Web 组件库的体验解决方案

    引用官方文档介绍:

    • 用于 Web 应用程序的企业级 UI 设计语言。
    • 一套开箱即用的高品质 React 组件。
    • 由 TypeScript 构建,并具备完整定义类型。
    • 基于 npm + webpack + dva 前端开发工作流。

    它支持浏览器、服务器端渲染和 Electron 环境,并具备丰富的组件,你还可以通过Create-react-app 来学习。来看看Ant-design demo吧!

    项目地址:【传送门】

    3. 轻量级的数据格式

    在JSON之前,有一个数据格式叫xml,现在还是广泛在用,但是JSON更加轻量,如xml需要用到很多标签,像上面的例子中,你可以明显看到xml格式的数据中标签本身占据了很多空间,而JSON比较轻量,即相同数据,以JSON的格式占据的带宽更小,这在有大量数据请求和传递的情况下是有明显优势的。

    5. Blueprint

    图片 8

    引用自官方文档:

    “它将为拥有复杂、数据密集的 Web 界面的桌面应用程序进行全面优化。如果你注重移动端的交互体验,并且正寻找移动优先的 UI 套件的话,它可能不适合你。”

    Blueprint 是由 TypeScript 构建,并具备良好的使用文档。它包含了丰富(30+)的 React 基础组件,从按钮到表单控件、工具提示均有涉及。此外,它的每个组件都包含了 CSS 样式。并且,你还可以使用 Sass 和 Less 变量、优雅的调色板和两种尺寸的 300+ UI 图标等工具,来打造一款专属于你的组件和应用程序。

    项目地址:【传送门】

    4. 被广泛地用于数据交换

    轻量已经是一个用于数据交换的优势了,但更重要的JSON是易于阅读、编写和机器解析的,即这个JSON对人和机器都是友好的,而且又轻,独立于语言(因为是基于文本的),所以JSON被广泛用于数据交换。

    以前端JS进行ajax的POST请求为例,后端PHP处理请求为例:

    1. 前端构造一个JS对象,用于包装要传递的数据,然后将JS对象转化为JSON字符串,再发送请求到后端;
    2. 后端PHP接收到这个JSON字符串,将JSON字符串转化为PHP对象,然后处理请求。

    可以看到,相同的数据在这里有3种不同的表现形式,分别是前端的JS对象、传输的JSON字符串、后端的PHP对象,JS对象和PHP对象明显不是一个东西,但是由于大家用的都是JSON来传递数据,大家都能理解这种数据格式,都能把JSON这种数据格式很容易地转化为自己能理解的数据结构,这就方便啦,在其他各种语言环境中交换数据都是如此。

    6. React-Bootstrap

    图片 9

    用 React 构建的 Bootstrap 3 组件

    引用自官方文档:

    React-Bootstrap是一个可重用的前端组件库。通过使用 Facebook 的 React.js 框架来获得 Twitter Bootstrap 的外观与体验,以及更清晰的代码。

    简而言之,它是知名的 Bootstrap 组件的 React 实现。

    项目地址:【传送门】

    二、JSON和JS对象之间的“八卦”

    很多时候都听到“JSON是JS的一个子集”这句话,而且这句话我曾经也一直这么认为,每个符合JSON格式的字符串你解析成js都是可以的,直到后来发现了一个奇奇怪怪的东西…

    本文由金沙国际官网发布于web前端,转载请注明出处:浅谈javascript函数节流,深入理解

    关键词:

上一篇:没有了

下一篇:没有了