运用 Console 来学习、调节和测量检验JavaScrip分分

作者:分分快三计划

三、怎样支配函数的调用次数

也足以经过闭包来调节函数的实践次数

function someFunction() {
    console.log(1);
}

function otherFunction() {
    console.log(2);
}


function setFunCallMaxTimes(fun, times, nextFun) {
    return function() {
        if (times-- > 0) {
            // 执行函数
            return fun.apply(this, arguments);
        } else if (nextFun && typeof nextFun === 'function') {
            // 执行下一个函数
            return nextFun.apply(this, arguments);
        }
    };
}

var fun = setFunCallMaxTimes(someFunction, 3, otherFunction);

fun(); // 1
fun(); // 1
fun(); // 1
fun(); // 2
fun(); // 2

 

 

Python装饰器(decorator)定义与用法详解,pythondecorator

正文实例陈诉了Python装饰器(decorator)定义与用法。分享给大家供我们参照他事他说加以考察,具体如下:

什么样是装饰器(decorator)

简单来说的话,能够把装饰器驾驭为贰个封装函数的函数,它日常将盛传的函数恐怕是类做确定的管理,重返修改未来的对象.所以,大家可以在不更动原函数的基本功上,在执行原函数前后实施别的代码.相比常用的地方有日记插入,事务管理等.

装饰器

最简便易行的函数,重返八个数的和

def calc_add(a, b):
 return a   b
calc_add(1, 2)

而是未来又有新的要求,总计求和操作耗费时间,很简短,求和前赢得一下时光,求和后再拿走三次,求差就可以

import datetime
def calc_add(a, b):
 start_time = datetime.datetime.now()
 result = a   b
 end_tiem = datetime.datetime.now()
 print "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
 return result
calc_add(1, 2)

现在呢,函数calc_diff(a, b),总结a-b,也想总计减法操作的小时差,很好办,把这段代码复制过去.但是假使大家未来想编的是三个数学函数库,各类函数都想总结其实施耗费时间,总不可能三个贰个复制代码,想个更加好的办法.

咱俩精通,在Python中等学校函授数也是被视为对象的,能够当做参数字传送递,那么一旦把总括耗费时间的单独为贰个单独的函数calc_spend_time(),然后把须要总结耗费时间的函数比如calc_add的引用传递给它,在calc_spend_time中调用calc_add,那样有着的须求总括耗费时间的函数都休想修改本身的代码了.

def calc_spend_time(func, *args, **kargs):
 start_time = datetime.datetime.now()
 result = func(*args, **kargs)
 end_tiem = datetime.datetime.now()
 print "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
def calc_add(a, b):
 return a   b
calc_spend_time(calc_add, 1, 1)
# calc_spend_time(calc_add, a=1, b=2)

看起来也不错,担当总结的函数不用更换,只需调用的时候作为参数传给总括时间差的函数.但就是这,调用的时候格局变了,不再是clac(1, 2),而是calc_spend_time(clac_add, 1, 2),万一calc_add大面积被调用,那么还得一处一处找,然后修改回复,依然很麻烦.要是想不修改代码,就得使clac()calc_spend_time(clac)效用同样,那么能够在calc_spend_time()里把传播的clac包装一下,然后回到包装后的新的函数,再把再次来到的包装好的函数赋给clac,那么calc()的功能就和上例calc_spend_time(calc())职能同样.

import datetime
def calc_spend_time(func):
 def new_func(a, b):
  start_time = datetime.datetime.now()
  result = func(a, b)
  end_tiem = datetime.datetime.now()
  print "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
 return new_func
def calc_add(a, b):
 return a   b
calc_add = calc_spend_time(calc_add)
calc_add(1, 2)

语法糖

地方的例证就是装饰器的定义,包装函数的函数.事实上上边的例子仍是能够更简短

import datetime
def calc_spend_time(func):
 def new_func(a, b):
  start_time = datetime.datetime.now()
  result = func(a, b)
  end_tiem = datetime.datetime.now()
  print "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
 return new_func
@calc_spend_time
def calc_add(a, b):
 return a   b
calc_add(1, 2)

@calc_spend_time就是语法糖,它的原形正是:calc_add = calc_spend_time(calc_add)

无参数的函数装饰器

import datetime
def calc_spend_time(func):
 def new_func(*args, **kargs):
  start_time = datetime.datetime.now()
  result = func(*args, **kargs)
  end_tiem = datetime.datetime.now()
  print "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
 return new_func
@calc_spend_time
def calc_add(a, b):
 return a   b
@calc_spend_time
def calc_diff(a, b):
 return a - b
calc_add(a=1, b=2)
calc_diff(1, 2)

注:

*args:把具有的参数按出现顺序打包成list
**kargs:把持有的key=value格局的参数打包成三个dict

带参数的函数装饰器

借使大家必要领会函数的一部分特别信息,比方函数作者,能够因此给装饰器函数扩张参数来完成.

import datetime
def calc_spend_time(author):
 def first_deco(func):
  def new_func(*args, **kargs):
   start_time = datetime.datetime.now()
   result = func(*args, **kargs)
   end_tiem = datetime.datetime.now()
   print author, "result:", result, "used:", (end_tiem - start_time).microseconds, "μs"
  return new_func
 return first_deco
@calc_spend_time('author_1')
def calc_add(a, b):
 return a   b
@calc_spend_time('author_2')
def calc_diff(a, b):
 return a - b
calc_add(a=1, b=2)
calc_diff(1, 2)

Python内置装饰器

Python内置的装饰器有多个:staticmethodclassmethodproperty

staticmethod:把类中的方法定义为静态方法,使用staticmethod装饰的方式能够使用类也许类的实例对象来调用,无需传入self

class Human(object):
 """docstring for Human"""
 def __init__(self):
  super(Human, self).__init__()
 @staticmethod
 def say(message):
  if not message:
   message = 'hello'
  print 'I say %s' % message
 def speak(self, message):
  self.say(message)
Human.say(None)
human = Human()
human.speak('hi')

输出:

I say hello
I say hi

classmethod:把类中的方法定义为类措施,使用classmethod装饰的方式能够使用类只怕类的实例对象来调用,并将该class对象隐式的作为第三个参数字传送入

class Human(object):
 """docstring for Human"""
 def __init__(self):
  super(Human, self).__init__()
  self.message = '111'
 def say(message):
  if not message:
   message = 'hello'
  print 'I say %s' % message
 @classmethod
 def speak(cls, message):
  if not message:
   message = 'hello'
  cls.say(message)
human = Human()
human.speak('hi')

输出同上例

property:把办法成为属性

class Human(object):
 """docstring for Human"""
 def __init__(self, value):
  super(Human, self).__init__()
  self._age = value
 @property
 def age(self):
  return self._age
human = Human(20)
print human.age

越来越多关于Python相关内容可查看本站专项论题:《Python数据结构与算法教程》、《Python Socket编制程序能力总括》、《Python函数使用技巧总括》、《Python字符串操作技术汇总》及《Python入门与进级杰出教程》

期望本文所述对大家Python程序设计有着扶持。

本文实例叙述了Python装饰器(decorator)定义与用法。分享给大家供大家仿效,具体如下: 什...

 

(部分相比较鸡肋的办法没有列出来,用粗蓝标出来的是常用的措施)

一、总括函数施行次数

例行的主意能够动用 console.log 输出来肉眼总计有多少个出口

而是在Chrome中放到了三个 console.count 方法,能够总结一个字符串输出的次数。大家得以接纳那么些来直接地总括函数的推行次数

function someFunction() {
    console.count('some 已经执行');
}

function otherFunction() {
    console.count('other 已经执行');
}

someFunction(); // some 已经执行: 1
someFunction(); // some 已经执行: 2
otherFunction(); // other 已经执行: 1

console.count(); // default: 1
console.count(); // default: 2

不带参数则为 default 值,不然将会输出该字符串的实践次数,观测起来依旧挺方便的

 

理之当然,除了输出次数之外,还想获得多个从头到尾的次数值,能够用装饰器将函数包装一下,内部选择对象存款和储蓄调用次数就能够

var getFunCallTimes = (function() {

    // 装饰器,在当前函数执行前先执行另一个函数
    function decoratorBefore(fn, beforeFn) {
        return function() {
            var ret = beforeFn.apply(this, arguments);

            // 在前一个函数中判断,不需要执行当前函数
            if (ret !== false) {
                fn.apply(this, arguments);
            }
        };
    }

    // 执行次数
    var funTimes = {};

    // 给fun添加装饰器,fun执行前将进行计数累加
    return function(fun, funName) {
        // 存储的key值
        funName = funName || fun;

        // 不重复绑定,有则返回
        if (funTimes[funName]) {
            return funTimes[funName];
        }

        // 绑定
        funTimes[funName] = decoratorBefore(fun, function() {
            // 计数累加
            funTimes[funName].callTimes  ;

            console.log('count', funTimes[funName].callTimes);
        });

        // 定义函数的值为计数值(初始化)
        funTimes[funName].callTimes = 0;

        return funTimes[funName];
    }
})();

function someFunction() {

}

function otherFunction() {

}


someFunction = getFunCallTimes(someFunction, 'someFunction');

someFunction(); // count 1
someFunction(); // count 2
someFunction(); // count 3
someFunction(); // count 4

console.log(someFunction.callTimes); // 4



otherFunction = getFunCallTimes(otherFunction);
otherFunction(); // count 1
console.log(otherFunction.callTimes); // 1

otherFunction(); // count 2
console.log(otherFunction.callTimes); // 2

 

再有一点点小的实物,举例能够由此 %c 调整输出文字的体制

1. 计算函数推行次数

总结:
  Console 是帮助大家学习和调治将养 JS的 1 个十二分好工具,假设你从前没用过,哪未来就起来用它呢。

 

  你会发觉它能帮你省相当多耗时的。

3. 怎么着支配函数的调用次数

 

2. 总计函数推行时间

一  什么是 Console
Console 是用于展示 JS和 DOM 对象音信的独立窗口。何况向 JS 中注入1个 console 对象,使用该对象
可以输出音讯到 Console 窗口中。别的张开Console后,ALT F1的话,会弹出火速键一览,也是相比灵通的。

4. 什么样支配函数的举行时间

 

二、总结函数实施时间

Chrome中存放了 console.time 和 console.timeEnd 来照应总括时间

console.time();

for (var i = 0; i < 100000;   i) {

}

console.timeEnd(); // default: 1.77197265625ms

不传播参数的话,将以default输出皮秒值

咱俩得以打包一下,传入函数名称,类似上面的做法,使用装饰器在函数推行前后开展处理

var getFunExecTime = (function() {

    // 装饰器,在当前函数执行前先执行另一个函数
    function decoratorBefore(fn, beforeFn) {
        return function() {
            var ret = beforeFn.apply(this, arguments);

            // 在前一个函数中判断,不需要执行当前函数
            if (ret !== false) {
                fn.apply(this, arguments);
            }
        };
    }

    // 装饰器,在当前函数执行后执行另一个函数
    function decoratorAfter(fn, afterFn) {
        return function() {
            fn.apply(this, arguments);
            afterFn.apply(this, arguments);
        };
    }

    // 执行次数
    var funTimes = {};

    // 给fun添加装饰器,fun执行前后计时
    return function(fun, funName) {
        return decoratorAfter(decoratorBefore(fun, function() {
            // 执行前
            console.time(funName);
        }), function() {
            // 执行后
            console.timeEnd(funName);
        });
    }
})();

那正是说调用的时候,就无需理会怎么着计时了

function someFunction() {
    for (var i = 0; i < 100000;   i) {

    }
}


function otherFunction() {
    for (var i = 0; i < 10000000;   i) {

    }
}

someFunction = getFunExecTime(someFunction, 'someFunction');
someFunction(); // someFunction: 1.616943359375ms

otherFunction = getFunExecTime(otherFunction, 'otherFunction');
otherFunction(); // otherFunction: 18.157958984375ms

 

Chrome的Console API究竟不是正式的,除了选取它之外,还是能够挑选日期插件 Date 中的 getTime now 相关办法

而是使用Date对象来计量耗费时间并半间不界,推荐使用标准的 performance.now

var start = performance.now();

console.time();

for (var i = 0; i < 10000000;   i) {

}

var end = performance.now();

console.timeEnd(); // default: 23.598876953125ms

console.log(end - start); // 23.600000015459955

能够看看,它们是离开十分的小的

行使类似的章程,将它包裹起来以便有扶持调用

var getFunExecTime = (function() {

    // 装饰器,在当前函数执行前先执行另一个函数
    function decoratorBefore(fn, beforeFn) {
        return function() {
            var ret = beforeFn.apply(this, arguments);

            // 在前一个函数中判断,不需要执行当前函数
            if (ret !== false) {
                fn.apply(this, arguments);
            }
        };
    }

    // 装饰器,在当前函数执行后执行另一个函数
    function decoratorAfter(fn, afterFn) {
        return function() {
            fn.apply(this, arguments);
            afterFn.apply(this, arguments);
        };
    }

    // 执行次数
    var funTimes = {};

    // 给fun添加装饰器,fun执行前后计时
    return function(fun, funName) {
        funName = funName || fun;

        if (funTimes[funName]) {
            return funTimes[funName];
        }

        // 绑定
        funTimes[funName] = decoratorAfter(decoratorBefore(fun, function() {
            // 执行前
            funTimes[funName].timestampStart = performance.now();
        }), function() {
            // 执行后
            funTimes[funName].timestampEnd = performance.now();

            // 将执行耗时存入
            funTimes[funName].valueOf = function() {
                return this.timestampEnd - this.timestampStart;
            };
        });

        return funTimes[funName];
    }
})();

function someFunction() {
    for (var i = 0; i < 100000;   i) {

    }
}


function otherFunction() {
    for (var i = 0; i < 10000000;   i) {

    }
}

// 包装
someFunction = getFunExecTime(someFunction);
// 执行
someFunction();
// 获取耗时,可直接使用函数的 valueOf
console.log( someFunction); // 2.0999999847263098

otherFunction = getFunExecTime(otherFunction, 'otherFunction');
otherFunction(); 
console.log( otherFunction); // 21.00000000745058

 

log 方法第二个参数协理类似 C 语言 printf 字符串替换方式,Log 帮助上面三种替换方式:

四、如何决定函数的实行时间

因为JS是单线程的,调整函数的执行时间相对来讲挺麻烦

透过 async await yield 等异步性格,或然还能源办公室成的

在React 16中的 Fiber 机制,在某种意义上是能调节函数的举办机会,得空再去会见它是怎么落到实处的吗

那组方法用于打开浏览器的分析器,用于分析那组函数之间的 js 执市场价格况,
注:firebuglite 不扶助 profile 作用,Chrome 帮忙profile,但解析的内容不详。

假设想总计JS中的函数试行次数最多的是哪位,实施时间最长的是哪些,该如何是好啊?

十  console.group(object[, object, ...]), groupCollapsed, groupEnd
那 3 个函数用于把 log 等出口的音讯进行分组,方便阅读查看。

六  console.assert(expression[, object, ...]) 

 
二  什么浏览器帮忙 Console
不知凡多少人大概都清楚 Chrome 和 FireFox(FireBug)中都帮助Console。而别的浏览器都支
持糟糕。比方 IE8 自带的开辟工具即使援助Console,但职能相比较平淡,展现对象的时候都以体现
[Object,Object],何况无法点击查阅对象里面的质量。IE6、IE7 纵然能够安装 Developer Toolbar,但也
不扶助 console。Safari、Opera 都扶持 Console,但运用上都尚未 FireBug和 Chrome 的方便。
  将来firebug推出了 firebuglite工具,能够让具备浏览器都支持Console功用,何况动用上和FireBug
大致同样。详见 http://getfirebug.com/firebuglite
 
三  为啥不直接行使 alert 或自身写的 log
应用 alert 不是一模一样能够呈现音讯,调节和测量检验程序吗?alert 弹出窗口会中断程序,
要是要在循环中呈现音讯,手点击关闭窗口都累死。并且 alert 呈现对象恒久呈现为[object ]。
  自身写的 log 即使能够显得一些 object 音信,但众多作用支撑都尚未 console 好,看完前面 console
的介绍就驾驭了。  

把 html 元素的html 代码打字与印刷出来,等同于log.
 
  console.trace()
trace 方法能够查阅当前函数的调用饭店消息,即眼下函数是什么样调用的,e.g:

分分快三计划 1

十三  console.count([title])
count 方法用于总括当前代码被实践过多少次,title 参数能够在次数前边输出额外的标题以扶助阅读。e.g:  

分分快三计划 2

 

十四 console.table(data)
table 方法把data 对象用表格的法门呈现出来,那在展现数组或许格式同样的JSON 对象的时候极度管用。
注:table 只扶植 FireBug,并且是在 firebug1.6 版本后才有。

  • %s  替代字符串
  • %d  替代整数
  • %f  替代浮点值
  • %o  代替 Object

 

 

assert 方法类似于单元测验中的断言,当 expression 说明式为 false 的时候,输出前面包车型地铁信息,e.g:
 注:assert 方法在 firebuglite 不支持,Chrome 和 FireBug 支持
 
七  console.clear()
该形式清空 console 中的全数消息 (Chrome中不协理)  

八  console.dirxml(node) 

五  console.debug,info,warn,error
这 4 种艺术与 log 方法运用同样,只是展现的Logo和文字颜色差异.

四  Console.log(object[, object, ...])
Console.log 是最简便易行输出新闻到 console 窗口的措施,扶助多个参数,该方法会把
那几个参数组合在联合签名显示,e.g:

分分快三计划 3

十二  console.profile(name)/console.profileEnd() 

groupCollapsed 方法与 group 方法一样,只是彰显的分组私下认可是折叠的.
 
 十一  console.time(name)/console.timeEnd(name)
大家经常索要测量检验 js 函数的实施时间,可能大家和谐写代码在第1 条语句和
末段 1 条语句取当明日子相减。那组函数实际就落到实处了那样的成效,time(name)依照name 创制 1 个新
的放大计时器。timeEnd(name)甘休给定name 的机械漏刻,并呈现时间。


分分快三计划 4

e.g:

分分快三计划 5


本文由分分快三计划发布,转载请注明来源

关键词: log JS 调试 Javascirpt Console