js-函数-function

大家好, 我叫 方可申

函数声明和表达式

a() //函数提升, 所以没问题
fn() // 变量没提升, 报错.
function a() {} 未写return 则默认是 undefined // 函数会提升到顶部, 意思是
const fn = function() {}
fn?.() 相当于 (f !== null && f !== undefined) ? f() : undefined

箭头函数

1. 它继承环境中的this
2. 不能用来new 也就是做构造函数

(x, y) =>  x + y // 省略了 {} 和return
() => ({name: x}) 返回对象的话,用()包一下,不然会被识别为函数体的花括号.
const strict = (function(){ return !this })() // 判断是不是严格模式
对象函数叫方法?
方法 + this 是面向对象编程的核心...

---

尾调优化 函数柯里化 防抖 节流

局部作用域,全局,块级,其中局部又叫函数作用域;

函数执行时所在的作用域，是定义时的作用域，而不是调用时所在的作用域。闭包利用的就是函数的作用域原理

function foo() {
  var x = 1;
  function bar() {
    console.log(x);
  }
  return bar;
}

var x = 2;
var f = foo().toString();

eval(f) // undefined

函j数传参的值如果是引用的,改变会变,如果是原始值,则不影响

var obj = [1, 2, 3];

function f(o) {
  o = [2, 3, 4];
}
f(obj);

obj // [1, 2, 3]

arguments 这个对象只有在函数体内部，才可以使用。伪数组, 有length, 有索引, 但是不能用数组的方法.

Array.prototype.slice.call(arguments); //

2. 函数才有return, 终止函数(放在for循环,可以终止循环)

3. 变量和函数提升, 函数同名后面覆盖前面的

alert(a);//function a(){alert(3);}
var a=1;
alert(a);//1
function a(){alert(2);}
alert(a);//1
var a=3;
alert(a);//3
function a(){alert(3);}
alert(a);//3

1. 等号设置默认值

function fuc(para=123) {
  return para
}
fuc(456) /// 不传的话,就是默认值123

5.匿名函数写成箭头函数

5.1.var f = v => v

var f = function(v) {
    return v;
}
 返回对象要加()
简化回调函数

[1,2,3].map(x => x*x) 

1. 概念
   作用域: 内层可以访问外层,外层不能访问内层.
   闭包: 即能够读取其他函数内部变量的函数。

立即执行函数

没有命名函数, 避免污染全局变量; 1. 封装私有属性和私有方法.2.一个是可以读取函数内部的变量，另一个就是让这些变量始终保持在内存中，即闭包可以使得它诞生环境一直存在。

  function getNumber() {
    var n = 999;
    return function getN(){
      console.log(n++)
    }
  }
  var f = getNumber();
  f(); //999
  f(); //1000

2. 应用场景

2.1 setTimeout()的传参

    let a = 123;
    let foo = function (a) {
        return function () {
            console.log(a);
        }
    }
    setTimeout(foo(a), 100)

2.2 封装变量

   var counter = (function(){
        var privateCounter = 0; //私有变量
        function change(val){
            privateCounter += val;
        }
        return {
            increment:function(){   //三个闭包共享一个词法环境
                change(1);
            },
            decrement:function(){
                change(-1);
            },
            value:function(){
                return privateCounter;
            }
        };
    })();
原文链接：https://blog.csdn.net/qq_21132509/java/article/details/80694517

bind实现柯里化(bind的实现机制就是柯里化)

柯里化的优点：参数复用，提前确认和延时运行

function add() {
    // 第一次执行时，定义一个数组专门用来存储所有的参数
    var _args = Array.prototype.slice.call(arguments);

    // 在内部声明一个函数，利用闭包的特性保存_args并收集所有的参数值
    var _adder = function() {
        _args.push(...arguments);
        return _adder;
    };

    // 利用toString隐式转换的特性，当最后执行时隐式转换，并计算最终的值返回
    _adder.toString = function () {
        return _args.reduce(function (a, b) {
            return a + b;
        });
    }
    return _adder;
}

var a = add(1)(2)(3)                // f 6 ?
var b = add(1, 2, 3)(4)             // 10
var c = add(1)(2)(3)(4)(5)          // 15
var d = add(2, 6)(1)                // 9

console.log(a, b, c, d)