new Function
创建的函数,是全局执行上下文function test() {
var i = 0;
return function () {
var j = 0;
++i, ++j;
console.log(i * j);
}
}
var f1 = test();
f2 = test();//独立
f1();//1
f1();//2 因为闭包,所以引用变量一直存在
f2();//1 函数作用域的独立性
频繁操作后,只获取最后
t.oninput = debounce(fn, 1000)
function debounce(fn, delay) {
let time;//闭包变量,一直存在
return function(){
//频繁操作,频繁清空计时器
clearTimeout(time);
time=setTimeout(() => {
//...执行代码
}, delay);
}
}
频繁操作,有规律的获取(开锁,关锁)
function throttle(fn,wait){
let time;
return ()=>{
if(!time){
timer = setTimeout(()=>{//关锁
//...执行代码
timer = null;//开锁
},delay);
}
}
}
function throttle(fn,wait){
let old=0;
return ()=>{
let now=new Date().valueOf();
if(now-old>wait){
//...执行代码
old=now;
}
}
}
递归必须有一个跳出条件
每一层递归如果需要进行累计操作,需要return一个值,不然就会undefined
函数作用域:
可以使用尾递归进行优化
递归其实是个回溯的过程,从返回的位置往回执行
//优化前
function dg(n){
if(n===1)return 1;
return n*dg(n-1)
}
dg(5)
//优化后 O(1)
function dg(n,total){
if(n===1)return total;
return dg(n-1,n*total) //将结果携带
}
dg(5,1)
this是动态的,谁调用this就指向谁
多层调用取决于最近的
没有明确调用者,则为全局调用
箭头函数,this指向外层的this(静态指向)
立即执行函数,this指向全局
let obj1={
name:'obj1_name',
print:function(){
return()=>console.log(this.name)
}
}
let obj2={name:'obj2_name'}
obj1.print()() //obj1_name
obj1.print().call(obj2) //obj1_name
obj1.print.call(obj2)() //obj2_name
.call(this,参数); //性能更好
.apply(this,[参数]);
.bind(this,参数)(); //bind会返回新函数
arguments
是类数组,可迭代对象用于接受函数参数,只能放在末尾,并返回一个数组(arguments是类数组)
function fn(a,...args){
console.log(a,args);//1 [2, 3, 4, 5]
}
fn(1,2,3,4,5)
也可以用于解构赋值
let [a,...args]=[1,2,3,4,5]
console.log(a,args);//1 [2, 3, 4, 5]
fn(...arr)
[...arr]
[...arr,...arr1]
[...arguments]
展开对象{...obj}
具有iterator接口的对象也可以展开
var m = new Map();
m.set(1,1)
m.set(2,2)
var arr = [...m] // [[1,1],[2,2]]
对象合并{...obj,...obj1}
属性覆盖{...obj,"name":"bob"}
var [one, two, three] = [1,2,3];
var [a=5, b=7] = [1];
[a, b] = [b, a];
var [a, , b] = f()
rest
参数:var [a, ...b] = [1, 2, 3]
var {a, b} = {a: 1, b: 2}
var {a: A, b: B} = {a: 1, b: 2}
var {a = 10, b = 20} = {a: 1};
满足以下一种情况:
比如:setTImeout,Promise
function(a,b,c){}
//柯里化
function(a){
return function(b){
return function(c){
return a+b+c
}
}
}
调用该函数,内部会实例化对象并返回