JS函数

语法

function 函数名([形参列表]){
执行代码
}
函数名([实参列表])

函数定义

• 函数声明
  var x=add(2,3);
  function add(number1,number2){
  var sum=number1+number2;
  return sum;
  }

• 函数表达式
  将匿名函数赋值给变量
  var add= function(number1,number2){
  var sum=number1+number2;
  return sum;
  }
  var x=add(2,3);
  var y=add(2);//实参数量小于形参
  var y=add(2，3，4);//实参数量多于形参

• 对象实例化（构造函数）
  var add=new Function("i","j",return(i+j));

区别
函数声明的方式定义函数可以在声明前调用，而函数表达式和实例化必须在定义函数后调用
实例化的函数定义方法无法识别父函数的变量
(function(){
var i=10;
var add = new Function("j","console.log(i+j);debugger;")
add(1);})()

2.利用argument进行函数计算
function add(){
var sum =0,parameter;
for(i=0；i<=arguments.length; i++){
parameter = arguments[i];
sum = sum + parameter;
}
return sum;
}
3.参数为原始类型，值传递
function increment(number){
number = number +1;
return number;
}
var a=1;
var x=increment(a);2
a;//1,只传递值，原始值不改变

• 参数为对象类型，引用传递
  function increment(person）{
  person.age=person.age+1;
  return person;
  }
  var jerry={name:"jerry",age：9}；
  var x=increment(jerry);
  x;
  jerry;//{name:"jerry",age：10}原始值被改变

作用域

• 变量起作用的范围

  
  

若内部没有相应的作用对象，则会作用到外部

• 作为对象属性
  var point{
  x:1,
  y:1,
  move:function(stepX,stepY){
  this.x+=stepX;this即指函数作用的对象
  this.y+=stepY;
  }

  point.move(2,1);
  

构造函数

• 构造函数
  function Point(x,y){
  this.x=x;
  this.y=y;
  this.move=function(stepX,stepY){
  this.x+=stepX;
  this.y+=stepY;
  }
  var point1=new Point(1,1);//{x:1,y:1,move:function(stepX,stepY){}}
  var point2=new Point(1,2);

• 原型 设置共用的方法函数

function Point(x,y){

    this.x=x;
    this.y=y;
  }
  Point.prototype.move=function(stepX,stepY){
     this.x+=stepX;
     this.y+=stepY;
  }
  var point=new point(1,1);
  point.move(2,1);//x:3,y:2

 function Car(type,color){

    this.type=type;
    this.color=color;
    this.status="stop";
    this.light="off";
  }
  //在原型函数的基础上创建新的方法
  Car.prototype.start=function(){
    this.status="start";
    this.light="on";
    console.log(this.type+"is"+this.status);
  }
 Car.prototype.stop=function(){
    this.status="stop";
    this.light="off";
  }
  var audi=new Car("audi","sliver");
  var benzi=new Car("benzi","black");
  audi.start;//调用方法
  benzi.stop;
  audi.status;//访问属性
  audi.light="off";

• 构造函数与普通函数的区别
  1.本质上没有区别
  2.构造函数通常会有this指定实例属性，原型对象上通常有一些公共方法
  3.构造函数命名通常首字母大写

函数调用(this)

调用模式

• 构造函数调用模式

• 方法调用模式
  audi.start

• 函数调用模式
  函数调用没有指明特定对象时function()，this指向全局变量即window
  内部方法的子函数无法调用到this
  var myNumber ={
  value:1,
  double: function(){
  var that = this;
  var helper = function(){
  that.value=add(that.value,that.value);
  }
  helper();
  }

• apply(call)调用模式
  借用其他函数的方法Function.prototype.apply()
  function Point(x,y){
  this.x= x;
  this.y= y;
  }
  Point.prototype.move=function(x,y){
  this.x+=x;
  this.y+=y;
  }
  var p = new Point(0,0);
  p.move(2,2);
  var circle={x=1,y=1,r=1};
  Point.prototype.apply(circle,[2,1]);//x=3,y=2,z=1

   // Function.prototype.bind()
  var circlemove=Point.prototype.bind(circle,2,1);//绑定函数不直接执行
  setTimeout(circlemove,1000);//延迟执行函数
  

函数调用参数

• Array-like
  arguments[index]
  arguments[length]
• arguments.callee

递归

  function factorial(i){
      if(i==0){
          return 1;}//递归函数的退出条件
     return i*factorial(i-1);//调用函数本身
  }

闭包

• 属性隐藏，对象封装
  在函数内部含有子函数，子函数调用了父函数的变量

  
  

• 记忆函数(不懂）
  var factorial=(function(){
  var count=0;
  var fac= function(i){
  count++;
  if(i==0){
  console.log("调用次数"+count);
  return 1;}//递归函数的退出条件
  return i*factorial(i-1);//调用函数本身
  }
  return fac
  })()

  for (var i=0;i<=10;i++){
     console.log(factorial(i));//调用函数
  }
  

First-class function

• 函数柯里化curry
  将接受多个参数的函数转为接受单一参数的函数，返回的的函数可以接受后续参数
• 回调