函数

概述：函数是用function修饰一个代码块，这个代码块一般是抽取对应的功能代码形成对应的复用。在一定程度减少代码冗余。
函数的核心思想：封装（封装完可以被调用）

函数分类：

• 系统函数（属于系统的函数）
• 内置函数（属于对应的内置对象的函数）
• 自定义函数（自己定义的函数）

函数的创建（自定义的函数创建）：

1、匿名创建（没有定义名字，不具备复用价值）

//自执行代码
(function(){
    console.log('hello')
})()

2、具名函数（有名字的函数，具备复用价值）

function fn(){
    console,log('hello world');
}
fn()
//第二种写法
var a = function(){
    console.log('你好');
}
a()

3、函数对象创建（使用new关键词）

//函数对象创建方式 里面的参数是字符串
var fn = new Function('alert("123")')
fn()

函数的参数传递：

//传递参数
//计算两数之和，再函数声明的时候他传递的参数是形参(变量名)
function sum(a,b){
    console.log(a+b);
}
//调用执行，传递的参数是实参 一定有对应的值
sum(1,2)

//第二种写法 new Function的方式传递参数
var sum1 = new Function('a','b','alert+(a+b)')
sum1(1,2)

JavaScript的程序预编译过程：

概述：预编译过程属于编译之前做的事情 。

• 优先编译function
• 优先编译变量(不会进行赋值操作)

console.log(a); //undefined
// a() //报错 a 不是一个函数 预编译不会编译赋值操作
//调用 方法名(实际的参数)
fn()
//具名函数
/* function 函数名(参数,...){
执行的代码
} */
    function fn(){
        console.log('hello world');
}
//具名函数的第二种写法
var a = function(){
    console.log('你好');
}
//调用
a()
//在JavaScript中程序运行有个预编译过程
//他会先去加载对应的方法 function修饰的方法 加载对应的变量 var修饰的变量(并不会优先编译
赋值)

return关键词：

概述：return意思为返回，它是用于对应的函数中返回对应的数据的一个关键词，当你的数据返回了那么当前这个函数就没有意义了，所以当前这个函数在return后面的代码就不会再执行了。

fuction 方法名（形参1，形参2，....）{
    相关操作
    return 数据
}

注意：

• 当你没有return关键词，它也会返回对应的数据，它的返回是在程序执行完以后，返回的值为undefined。
• 没有指定对应的数据，相当没有return，相当于将return关键词放在最后面

return关键词的特点：

1. 它会结束对应的函数，在本身这个函数的函数内容执行了return，那return后面的内容将不会再执行了。
2. 我们一般在程序的结尾返回对应的数据。
3. 也可以利用对应的retrun的特性帮助我们来对应的函数。

function sum(number1,number2){
    //如果当前传递的数不是数值 那么就结束这个函数
    if(typeof number1 != 'number' || typeof number2 != 'number'){
        return
    }
        return number1+number2
}

return 关键词 和 抛出错误（throw new Error()）的区别：

• return 关键词只是结束当前的函数
• 抛出错误是结束整个程序

函数的对应的运行过程：

gc回收机制：

概述：垃圾回收机制，不能强制执行的，拥有对应的运行机制。

gc的两大回收机制：

• 引用计数法 （针对于引用数据类型的，有变量指向当前引用就给他+1，当这个变量不再指向它就-1，到0就回收了）
• 标记清除法 （针对于值类型有用yes，没有用 no，当你是no的时候就回收）

执行机制：

• 函数是在对应的方法执行栈上执行的
• 打开代码空间拿出里面的代码进行执行
• 当你执行完以后对应的gc就会把这个内容从执行栈上移走，对应的代码空间就会还原

arguments：

概述：arguments是函数的里面的所有参数的集合，它是一个伪数组（具备数组特性，有下标，有length（长度））

function fn() {
//所有的函数都具备arguments arguments特殊的值里面包含所有的参数
console.log(arguments)
//获取arguments里面的参数的第一个 arguments[下标] 来获取对应的下标的值
console.log(arguments[0]);
//查询当前arguments的长度 arguments.length
console.log(arguments.length);
}
//对应的下标从0开始 0表示第一个 最大值 对应的长度-1 length 当前的个数-1
fn(1, 2, 3, 4, 5)

注意：使用arguments来获取对应的值的时候，我们一般不写形参。

arguments使用的相关：

• arguments通过[下标]，来返回对应的元素
• arguments的length属性表示传入参数的个数

作用域及作用域链：

概述：一个变量的作用范围称为作用域，在全局声明的变量就是全局作用域，在函数内声明的变量它的作用域就是局部作用域（仅在当前函数内可用，函数作用域）

var a = 10 //全局变量 全局作用域
function fn(){
var a = 20 //局部变量 局部作用域
console.log(a) //20
}
console.log(a) //10

作用域链：

概述：作用范围内容变量的查找，它是链式查找，从局部到全局。

//查找变量的过程 从局部到全局
var a = 10 //全局变量
var c = 50
var b = 60
function fn(){
    // console.log(a); //undefined
    console.log(a); //10
    // var a = 20; //局部
    a = 20; //全局的
    console.log(b);//60
    console.log(c);//undefined
var c = b = 100;
    // console.log(a); //20
    // console.log(a); //20
  (function(){
    // console.log(a); //undefined
    console.log(a); //20
    // var a = 30 //局部
    console.log(b);//100
    console.log(c);//undefined
var c = b = 200
    a = 30 //全局的
    // console.log(a); //30
    // console.log(a); //30
})()
}
    console.log(a); //10
    fn()
    console.log(a); //30
    console.log(b);//200
    console.log(c);//50

函数的嵌套：

概述：函数是可以互相嵌套的。

function fn(){
    function fn1(){
        console.log('hello')
        //fn(3) //报错
    }
    function fn2(){
        console.log('hello')
        function fn3(){
        console.log('hello')
    }
 }
    fn1()
    console.log('world')
}
fn() //hello world

注意：在函数内部可以定义函数和调用的函数，函数内部不能调用优先级比自己要低的。

事件驱动（利用对应的事件来调用对应的函数）：

简单的一个dom操作：

获取对应的dom元素

var 变量 = document.getElementById('对应的标签的id属性')

给对应的变量添加点击事件：

变量名.onclick = 处理函数

递归：

概述：递归属于一个对应的算法 所有的算法都是套路。递归能做所有循环能做的事情。

递归的三大要素 (O(logn))：

• 找规律
• 找初始值（没有规律的已知条件）
• 自己调用自己