js 函数

函数

定义函数

定义方式一

Function abs（s）{
if（x>=0）{
return x;}
else{
return -x;
}
}

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

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

定义方式二

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

functionn(x){…}这是一个匿名函数，当时可以把结果赋值给abs，通过abs也可以调用函数！

方式一和方式二等价！

调用参数

abs（10）//10
abs（-10）//10

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

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

假设不存在参数，如何规避？

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

arguments

arguments是一个JS免费赠送的关键字

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

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

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

rest

以前：

 function aaa(a,b){
      console.log("a=>"+a);
      console.log("b=>"+b);
      if (arguments.length>2)
          for (var i = 2; i < arguments.length; i++) {
    
          }
  }

ES6新特性,获取出了已经定义的参数之外的所有参数

现在：

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

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

变量的作用域

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

假设在函数体中声明，则在函数体外不堪言使用

function cs(){
    var x = 1;
    x=x+1;
}
  x=x+2; // x is not defined

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

function cs(){
    var x = 1;
    x=x+1;
}
  function dnf(){
      var x = 'a';
      x=x+1;
  }

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

function cs(){
    var x = 1;
    function ca(){
        var y=x+1;
    }
    var z=y+1;
}

假设，内部函数变量和外部函数的变量，重名

function cs(){
    var x = 1;
    function ca(){
        var x='a';
        console.log('inner'+x);
    }
    console.log('outer'+x);
    ca();
}

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

提升变量的作用域

function cs(){
//var x，y，... 自动为我们赋值
    var x = 'x'+y;
    console.log(x);
    var y = 'y';
}

结果：x undefined

说明：JS执行引擎，自动提升了y的声明，但不会提升y的赋值；

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

这个是在JS建立之初就存在的特性。所有的变量定义都放在定义的头部。

全局函数

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

全局对象 window

var  x = 'a';
alert(x);
alert(window.x)

默认所有的全局变量，都会自动绑定在window对象中

alert（）这个函数本身也是一个window对象

var  x = 'a';
 var old_alert = window.alert;
 old_alert(x);

 var  x = 'a';
 var old_alert = window.alert;
 old_alert(x);
window.alert = function (){

};
window.alert(123)//发现alert（）失效了
    //恢复
    window.alert = old_alert;

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

规范

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

//唯一全局变量 
var caster = {};
//定义全局变量
caster.name = 'momo';
caster.add = function (a,b){
    return a+b;
}

把自己的代码全部放入自己定义的唯一空间名字中，降低全局命名冲突的问题 jQuery =$

局部作用域 let

function a(){
    for (let i = 0; i < 100; i++) {
        console.log(i);
    }
    console.log(i);
}

常量

在ES6之前，定义常量：只有用全部大写字母命名的变量就是常量

ES6引入了常量关键字 const

const PI = '3.14';//只读变量
console.log(PI);
PI = 132;

方法

定义方法

方法就是把函数放在对象的里面，对象只有两个东西：属性和方法

var caster={
    name:'momo',
    birth:2000,
    //方法
    age:function (){
        //今年减去出生年
     var now = new Date().getFullYear();
     return now-this.birth;
    }
}
//属性
caster.name;
//方法，一定要带括号
caster.age();

this.代表什么？

function getAge(){
     //今年减去出生年
     var now = new Date().getFullYear();
     return now-this.birth;
 }
var caster={
    name:'momo',
    birth:2000,
    //方法
    age:getAge
}
caster.age();//ok
getAge()//NaN

this是无法指向的，是默认指向调用的它的对象

apply

getAge.apply(caster,[]);//this 指向了caster这个对象，参数为空

内部对象

标准对象

typeof '23'
"string"
typeof "23"
"string"
typeof 123
"number"
typeof true
"boolean"
typeof NaN
"number"
typeof []
"object"
typeof {}
"object"
typeof Math.abs
"function"
typeof undefined
"undefined"

Date

var now = new Date();
now.getFullYear();
now.getMonth();
now.getDate();
now.getHours();
now.getMinutes();
now.getSeconds();
now.getDay();//星期几  礼拜天开始
now.getTime(); // 时间戳 全世界统一 1970 1.1 0:00:00 毫秒数
console.log(new Date(1625987891477))
//VM142:1 Sun Jul 11 2021 15:18:11 GMT+0800 (中国标准时间)

//转为本地时间
now = new Date(1625987891477);
Sun Jul 11 2021 15:18:11 GMT+0800 (中国标准时间)
now.toLocaleString()
"2021/7/11下午3:18:11"

JSON

JSON是什么？

早期，所有的数据传输习惯使用XML文件！

JSON(JavaScript Object Notation, JS 对象简谱) 是一种轻量级的数据交换格式。

• 简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。

• 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

在JS中，一切皆为对象，任何js支持的类型都可以用JSON表示

格式：

• 对象都用{}
• 数组都用[]
• 所有的键值对都使用key：value

JSON字符串和js对象的转化

var user = {
    name: "caster",
    age:3,
    sex:'男'
}
// 对象转化为json字符串
 var json_user = JSON.stringify(user);
//json字符串转化为 对象   parse 解析
 var obj=JSON.parse('{"name":"caster","age":3,"sex":"男"}');

JSON和js对象的区别

var obj = {a:"hello",b:"helloworld"};
var json = '{"a":"hello","b":"helloworld"}';

Ajax

• 原生的js写法 xhr 异步请求
• Jquery封装号的方法 ${#NAME}.AJAX("")
• axios 请求