函数基础内容

函数概述

函数用function修饰的一个代码块，这个代码块一般是抽取对应的功能代码形成对应的复用。在一定程度上减少代码冗余。函数的核心的思想 封装，封装完让别人去调用。

函数的分类

• 系统函数 属于系统的函数（属于global对象的函数的 alert() console.log() isNaN()...）

• 内置函数 属于对应的内置对象的函数 （Math.Pow()...)

• 自定义的函数 自己定义的函数（自己封装抽取的代码）

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

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

//匿名的 不具备复用 声明就需要调用
/*function(参数,...){
                对应的代码
        }*/
// 自执行函数
(function(){
    console.log('hello')
})()

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

function 函数名(形参，形参...){
    函数体(代码)
}
//声明 具名函数(第一种)
//function sayHello(){
    console.log('hello')
}
sayHello()

//传递函数
function sayHello1(name,age){//形参是形容的参数
    console.log('hello'+name+age)
}
sayHello1('李四') //传进的是实参 根据你要的参数个数来传递对应的参数个数
//调用
//sayHi() //报错
//console.log(sayHi); undefined
//具名函数的变种声明
var sayHi = function(){
    console.log('hi')
}
sayHi()

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

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

参数的传递

//传递参数
//计算两数之和 在函数声明的时候他传递的参数是形参（变量名）(随便写 建议语义化)
function sum(a,b){
    console.log(a+b);
}
//调出执行 传递的参数是实参 一定由对应的值
sum(1,2)
//new Function的方式传递参数
var sum1 = new Function('a','b','alert(a+b)')
sum(1,2)

javascript的程序预编译过程

• 优先编译function

• 优先编译变量（不会进行赋值操作的）

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

练习

传入两个数 打印他们之间最大的

function max(number1,number2){
    if(typeof nubmber1!="number" || typeof number2!="number"){
        //console.error('输入出错');
        //抛出新错误
        trow new Error('输入出错')//当程序报错 底下的所有内容将不会再执行
    }
    //比对最大值
    var maxValue = number1>number2?number1:number2
    console.log(maxValue)
}
max(1,2)//打印2

计算传入的数值是否是回文数值 是打印是回文 不是打印不是回文

//计算传入的数值是否是回文数值 是打印是回文 不是打印不是回文
//传入一个数值
function isPalindrome(number1){
    if(tpyeof number1 !='number'){
        //抛出新的错误
        throw new Error('输入出错')//当程序报错 底下的所有内容将不会再执行
    }
    var x =number1
    if(number1 == 0){
        console.log('当前是回文');
    }else if{
        console.log('当前不是回文');
    }
    var reverse = 0
    //进行反转操作
    while(x>0){
        reverse = reverse * 10 + x%10
        x = parseInt(x/10)
    }
    //进行判断
    if(number1 == reverse){
        console.log('当前是回文');
    }else{
        console.log('当前不是回文');
    }
}
isPalindrome(11011)

return关键词

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

function 方法名(形参1,形参2,...){
    相关操作
    return 数据
}

示例

计算两个数的和 将这个和返回

//return 后面的内容是不会执行的
function sum(n1,n2){
    console.log('之前执行的')
    return n1 + n2
    console.log('之后执行的')
}
var result = sum(1,2)
console.log(result)

//当你没有return关键词 他也会返回对应的数据 他的返回是在程序执行完以后 返回的值undefined
function fn(){
    console.log('程序执行');
    return;没有指定对应的数据 相当于没有return 相当于将return关键词放在最后面
    console.log('结束')
}
console.log(fn());

return的特点

1、他会结束对应的函数，在本身这个函数内容 执行了return后面的内容将不会再执行了

2、我们一般在程序结束的结尾返回对应的数据

3、也可以利用对应的return的特性帮助我们来对应的函数

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

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

• return关键词知识结束当前的函数

• 抛出错误世界树整个程序

函数的对应的运行过程

gc回收机制 垃圾回收机制（垃圾回收机制 不能强制执行的 对应的运行机制）

gc的两大回收机制

引用计数法（针对与引用数据类型的 有变量指向当前引用就给他+1 当这个变量不再指向它就-1 到0就回收了）

标记清除法（针对于值类型 有用yes没有用no 当你是no的时候就回收）

执行机制

• 函数是在对应的方法执行栈上执行的

• 打开代码空间拿出里面的代码进行执行

• 当你执行完以后对应的gc就会把这个内容从执行栈上移走 对应的代码空间就会还原

arguments

概述：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

示例

传入任意的数值来取出它的和

function sum(){
    //获取所有的参数 数值
    var result = 0
    //遍历arguments里面所有的数值
    for（var i = 0;i<arguments.length;i++){
        result +=arguments[i]
    }
    return result
}
console.log(sum(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 b = 60
var c = 50
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 = 处理函数

简单示例

<div id='content'>点击</div>
<input type="text" id="myInput"> <button id="btn">点击按钮获取input显示的值</button>
<script>
    //获取对应的div 根据id获取
    var content = document.getElementById('content')
    //给对应的div添加事件 由事件触发的函数被称为事件驱动
    content.onclick = function(){
        alert('hello')
    }
    //1.获取按钮
    var btn = document.getElementById('btn')
    //2.给按钮添加点击事件
    function hello(){
        //3.在点击事件执行的函数里面获取对应的input内容
        //3.1 获取input
        var myInput = document.getElementById('myInput')
        //3.2再获取里面的内容 value属性 获取input的显示内容 也可以进行设置
        console.log(myInput.value);
    }
    btn.onclick = hello
</script>

递归

递归属于一个对应的算法 所有的算法都是套路，递归能做所有循环能做的事

递归的三大要素（O(logn)）

• 找规律

• 找初始值 没有规律的已知条件

• 自己调自己

示例

问第100位置的值是什么2 4 6 8 10 12 14...当前值 = 上一个值 + 2

function fn(n){
    if(n == 1){ //没有规律的
        return 2
    }else{//有规律的 自己调自己
        return fn(n-1) + 2
    }
}
console.log(fn(100))

练习

1-100的所有偶数和

//2 6 12 20 30  2 + 4  6 + 6 上一个 + 位数*2
function fn1(){
    if(n==1){
        return 2
    }else{
        return fn1(n-1)+n*2
    }
}
console.log(fn1(50));

求对应的阶乘5的阶乘 1 2 6 24

function fn(n){
    if(n==1){
        return 1
    }else{
        return fn(n-1)*n
    }
}
fn(5)

1 2 4 7 11 16 问第10位

function fn(n){
    if(n==1){
        return 1
    }else{
        return fn(n-1)+n-1
    }
}
fn(10)

1 2 3 5 8 13 问第10位

function fn(n){
    if(n==1){
        return 1
    }else if(n==2){
        return 2
    }else{
        return fn(n-2) +fn(n-1)
    }
}
fn(10)