JavaScript语法-----函数

一:初识函数

1.1:初识函数

函数用于封装完成一段特定的代码

相当于一条或多条语句组成的代码块包裹起来

用户在使用时，只需要关心参数和返回值，就能完成特定的功能，而不用了解具体的实现

1.2:内置函数

console.log(isNaN("number"));//true
console.log(parseInt('15.99'));//15

1.3:自定义函数

提高代码的复用性，降低程序维护的难度

函数格式
 function name(params){

}
function指这是一个函数语句
name是函数名
params是函数参数
{}内放函数的具体功能

1.3.1:无参函数

function demo(){
 console.log("我是一个函数");
        }
使用函数
demo()//"我是一个函数"
demo()//"我是一个函数"

1.3.2:有参函数

function sum(a,b){
console.log(a+b);
        }
使用函数
sum(1,2)//3
sum(8888,9999)//18887

1.4:函数的返回值

//函数的返回值是指函数在调用后获得的数据
//在定义函数时，可以为函数指定一个返回值，函数的返回值可以是任意类型的数据
//在JS中使用return语句得到返回值并退出函数
{return 表达式}

1.5:获取函数调用时传递所有实参

function num3 (a,b){
console.log(a,b);
       }
num3(1,2)//1,2
num3(1,2,3,4,5)//1,2
num3(1)//1,undefined

1.6:扩展运算符

function num1(...nums) {
console.log(nums);
       }
num1(1,2,3,4,5)//[1,2,3,4,5]
num1(1,2,3)//[1,2,3]

1.7:arguments对象

在开发时，如果不确定形参的个数，可以不设置形参
在函数体中直接通过arguments对象获取函数调用时传递的实参
function num2(){
console.log(arguments);
console.log(argumengts.length);
 }
num2(1,2,3,4,5)
num2(1,2,3)

二:函数内外变量的作用域

2.1:变量

2.1.1:全局变量

全局变量:在函数体外声明的变量或者在函数体内省略var关键字声明的变量
var a=10;
function demo(){
console.log(a);//a为全局变量，在函数体内可以被访问
        }
demo()
console.log(a);//a为全局变量，在函数体外可以被访问

2.1.2:局部变量

局部变量:在函数体内利用var关键字声明的变量
function demo1(){
var b=10;//b是var关键字声明的变量，为局部变量

c=20;//c是省略var关键字声明的变量，为全局变量
        }
demo1()//10
console.log(b);//b is notdefined
console.log(c);//可以在函数外访问到全局变量c

2.1.3:块级变量

//在es6标准中，新增的let关键字声明的变量为块级变量
//一个花括号{}为一个块级
if(true){
let sex='男';//let声明的变量sex为块级变量
console.log(sex);///块级变量sex可以在{}内部被访问
        }
//console.log(sex);块级变量sex不可以在{}外部被访问

2.2:JS三种作用域

全局作用域:被全局变量所拥有:在{}外声明的变量
局部作用域:被局部变量所拥有:在函数内定义的变量
块级作用域:被块级变量所拥有:在分支语句或者循环大括号中定义的变量

2.2.1:let和var声明变量的区别

let声明的全局变量
不允许在变量初始化前被访问
console.log(test);//Connot access 'test' before initialization
console.log(demo2);//undefined 可以访问到全局变量demo 但是demo目前没有赋值 为undefined
var demo2=7
let test = 10
function fun(){
console.log(demo);
        }
fun()

2.3:变量提升

console.log(d);Connot access 'test' before initialization
let d= 20;

通过var声明的变量，在申明并赋值语句之前就可以被访问到
console.log(f);//undefined
var f=20;

因为变量提升，所以67-68行代码执行效果其实是71-73行
var f;
console.log(f);
var f=20;

三:函数进阶

3.1:函数表达式

函数表达式是指将函数值赋给变量的表达式

//封装一个sum函数，在函数内可以求得变量num1和变量num2的和
var fn = function sum(num1,num2){
//在函数内部封装了一个打印语句
//调用此函数，就会打印执行语句
console.log(num1+num2);
       }
fn(10,20)

3.2:匿名函数

// 当用var 声明后可以直接删除变量名
var fn = function (num1,num2){
console.log(num1+num2);
       }
fn(10,20)

3.3:箭头函数

//删除function关键字
//在参数和函数体中间放上=>
var fn2 =(num1,num2)=>{
console.log(num1+num2);
 }
fn2(10,20)

//当函数体只有一句话时，可以省略大括号
var fn2 =(num1,num2) => console.log(num1+num2);
fn2(10,20)//30

//当函数只有一句代码，并且函数的执行结果就是函数的返回值,可以省略函数的大括号和return关键字
var fn1=(num1,num2)=>num1+num2;
console.log(fn1(1,2));//3

//当参数只有一个时，可以省略函数外部的小括号
var fn4 = num3=> num3+num3;
console.log(fn4(8));

3.4:回调函数        

//函数fn作为参数传递给函数cal
然后在函数cal中调用fn
此时fn就是回调函数
function cal(num1,num2,fn){
return fn(num1,num2)
}

console.log(cal(10,20,function(a,b){
return a+b;
         }));//30

console.log(cal(10,20,function(a,b){
return a*b;
}));//200

console.log(cal (10,3,function(c,d){
return c%d
}));

3.4.1回调函数的用处

在cal函数中设置了回调函数后
可以根据调用时传递的不同的函数参数(相加函数，相乘函数)
去实现不同的功能
实现了函数的定制化

四:定时器函数

4.1:setInterval关键字

//setInterval()
//Interval:间隔，间隙
//"时间间隔"一到，代码就会执行一次
setInterval(function,time)
setInterval(function(){
console.log("该上课了");
},1000)

4.2:setTimeout关键字

//setTimeout()
//用来指某个函数或某段代码在多少毫秒以后执行
setTimeout(function,time)
setTimeout(function(){
console.log("要抢票了");
 },30)

4.3:特别注意

//定时器属于异步代码
//setTimeout指定的代码，必须等同步代码执行完毕后执行
console.log(1);
setTimeout(function(){
console.log(2);
},50)
console.log(3);
//1
//3
//2

五:函数嵌套与作用域链

//函数变量访问规则:就近原则
//当在一个作用域中访问变量时，首先看当前作用域有没有声明
//如果有则访问，没有则往上级作用域查找
//直到达到顶端作用域没有时，则回报错

var i=10;
function fn(){
var i=20;
function fn1(){
function fn2(){
console.log(i);
}
fn2()
}
fn1()
}
fn()

六:闭包函数

6.1闭包的概念

闭包(close):闭包是一种代码形式，内部函数访问外部函数的局部变量
//举例：js函数a中有有一个函数b，函数b访问了函数a里面定义的局部变量，此时就产生了闭包
//     变脸所在的函数就是闭包函数，在这里，a就是闭包函数

//外部函数
function outer(){
//外部函数定义的局部变量
let n=10;
//内部函数
function inner(){
//内部函数要访问外部函数定义的局部变量
console.log(n);
}
inner()
 }
outer()

6.2:闭包的作用

闭包的作用：解决变量污染问题，让变量被保护起来
       
function fn(){
let count=0;
setInterval(function(){
console.log(count++);
        },1000)
    }
    fn()
//在这段代码中变量count是一个很常用的变量名
//为了避免和其他位置的代码冲突，可以使用一个函数将上面的代码包裹起来

七:递归函数

//递归函数是一个函数间接或直接地调用自身
function getSum2(n){
//当n=1时;
if(n==1){
return 1;
}
//当前数字+比自己小1的数字
return n+getSum2(n-1)
}
console.log(getSum2(6));