JS 函数

函数

定义函数

方式一：

绝对值函数

function abs(x){
    if(x>=0){
        return x;
    }
    else{
        -x
    }
    
}

一旦执行return 代表函数结束 返回结果！

如果没有执行return,函数执行完也会返回结果 结果就是 undefined

方式二：

var abs=function(x){
    if(x>=){
       return x;
     }
    else{
        return -x;
    }
}

function(x){…} 这个是一个匿名内部类 但是可以把结果赋值给avs ，通过abs 就可以调用函数。

方式一和方式二 等价

调用函数

abs(10)
abs(-10)

参数问题： javascript 可以传任意个参数，也可以不传参数

参数进来是否存在的问题?

假设不纯在参数 如何规避

var abs= function(x){
    //手动抛出异常来判读
    if(typeof x != 'number'){
       throw  'not  a number'
       
    }
    
    if(x>=0){
        return x;
    }
    else{
        return-x;
    }
      
}

arguments 是js免费赠送的关键字；

代表 传递进来的所有参数 ，是一个数组！

var abs= function(x){
    
    console.log("x=>"+x);
    
    for(var i=0;arguments.length;i++){
        console.log(arguments[i])
    }
    
    
    if(x>=0){
        return x;
    }
    else{
        return-x;
    }
      
}

问题： arguments 包含所有的参数 ，我们有时候想使用多余的参数来进行附加操作。 需要排除已有参数

rest

以前

if(arguments.length>2){
    for(var i=2;i<arguments.length;i++)
        ......
}

ES6 引入新特性 ，获取除了已定义的参数之外的所有参数

function aaa(a,b,c,...rest){
    console.log("a=>"+a)
    console.log("b=>"+b)
    console.log(rest);
}

rest 参数只能写在最后面， 必须用… 标识。

变量作用域

在javascript 中 var 定义变量实际是有作用域的。

假设在函数中声明，则在函数体外不饿可以使用 （闭包）

function qj(){
    var x=1;
    x=x+1;
}

x=x+2;

Uncaught referenceError: is not defined

如果两个函数使用了相同的变量名，只要在函数内部，就不冲突

function qj(){
    var x=1;
    x=x+1;
    
}


function qj2(){
    var x='A'
    x=x+1;
}

内部函数可以访问外部函数的成员，反之则不行

function qj(){
  var x=1; 
    
    function qj2(){
        var x=x+1;
    }
    
    var z=y+1;
    
}

内部函数变量和外部函数的变量 重名

function qj(){
    var x=1;
    
    function qj2(){
        var x='A';
        console.log('inner'+x);
       
    }
    
    console.log('outer'+x); 
    qj2()   
}

qj()

输出

outex
innerxx

假设js中，函数查找变量从自身函数开始。 由内 向外 查找，假设外部存这个同名的函数变量，则内部函数会屏蔽外部函数的变量。

var x= 'x'+y;
console.lgo(x);
var y='y''

结果 ： x undefined

说明: js 执行引擎，自动提升了y的声明，但是不会提升变量y1的赋值；

function qj2(){
    var y;
    var x="x"+y;
    console.log(x);
    
    y='y';
    
}

这个是在Js建立之初就存在的特性。养成规范；所有定义都放在函数头部，不要乱放，便于代码维护；

function qj2(){
    var x=1;
    y=x+1;
    z,i,a;
}

全局函数

x=1;
function f(){
    console.log(x);
}
f();
console.log(x)

全局对象 window

var x='xxx';
alter(x)
alter(window.x);  //默认所有的全局变量，都会自动绑定在window对象下

alert()这个函数本身也是 window 变量

js实际上只有一个全局作用域，任何变量（函数也可以视为变量）假设没有在函数作用范围内找到，就会向外查找，如果在

全局作用域都没有找到，那么会报错 RefrenceError

规范

由于我们所有的全局变量都会绑定到我们的window上，如果不同的js文件，都使用了相同的全局变量， 冲突–> 如何能够减少冲突？

//唯一全局变量
var aaaa={}；

//定义全局变量
 
aaaa.name="xxxx"；
aaaa.add= function(a.b){
    return a+b;
}

把自己的代码全部放到自己定义的唯一空间名字中，减少全局变量冲突！

局部作用域

function aaa(){
    for(var i;i>=100;i++){
        console.log(i);
    }
    console.lgo(i+1);    //有问题 i出了这个作用域也可以使用
}

ES6 通过let 关键字 解决了局部作用域冲突问题

function aaa(){
    for(let i;i>=100;i++){
        console.log(i);
    }
    console.lgo(i+1);    //有问题 i出了这个作用域也可以使用
}

常量 const

在ES6 之间 定义常量 的规则是 变量全部大写 但是还能修改值

var PI =3.14;
console.log(PI)
PI=123;
console.log(PI);

在ES6 引入了常量关键字 const