JavaScript基础之函数详解

    // 方式1：字符串封装代码创建函数
    var fun = new Function("console.log('hello 我是第一个函数');");
    console.log(fun);
    // 函数在被调用时执行
    fun()
    // 方式2：函数声明
    function fun2() {
      console.log(fun2)
    }
    fun2()
    // 方式3：函数表达式
    var fun3 = function () {
      console.log("我是匿名函数的封装的代码")
    };
    console.log(fun3)
    fun3();

    function mianji(r){
      return 3.14 * r * r;
    }
    function fun(a) {
      console.log("a = " + a)
    }
    fun(mianji(10))
    fun(mianji)

    function fun4(){
      function fun5(){
        alert("我是fun5")
      }
      return fun5;
    }
    a = fun4();
    console.log(a)   //输出fun5函数体
    a()   //输出"我是fun5"
    fun4()()   //输出"我是fun5"

    function Person(name, age, gender) {
      this.name = name;
      this.age = age;
      this.gender = gender;
      this.sayName = function () {
        alert(this.name)
      };
    }
    var per = new Person("张三", 15, "男")
    var per2 = new Person("李四", 16, "女")
    var per3 = new Person("王五", 17, "男")
    console.log(per)

    (function(){
      alert("我是一个匿名函数")
    })
    // 函数定义完，立即被调用，称为立即执行函数

	 // 1.call方法
	 var o = {
	     name:"张美丽"
	 }
	 function fn(a,b) {
	     console.log(this);
	     console.log(a + b);
	   }
	 fn(1,3) //此时的this指向的是window 运行结果：3
	 fn.call(o,1,2) //此时的this指向的是对象o  运行结果：输出对象o和3
	 // 2.apply方法
	 var o = {
	     name:'andy'
	 }
	 function fn1(a,b) { 
	     console.log(this);
	     console.log(a + b)
	  }
	  fn()  //此时的this指向的是window 运行结果：3
	  fn.apply(o,[1,2])  //此时的this指向的对象o，运行结果：输出对象o和3
	 //  3.bind方法
	 var o = {
	     name:'andy'
	 }
	 function fn1(a,b) { 
	     console.log(this);
	     console.log(a + b)
	  }
	  var f = fn.bind(o,1,2)  //此处的f是bind返回的新函数
	  f()  //调用新函数  this指向的是对象o

	// 1.父构造函数
	function Father(uname) {
	  // this 指向父构造函数的对象实例
	  this.uname = uname;
	}
	// 2.子构造函数
	function Son(uname, age) {
	  // this指向子构造函数的对象实例
	  // 3.使用call方式实现子继承父的属性
	  Father.call(this.uname);
	  this.age = age;
	}
	var son = new Son('王帅帅', 18);  
	console.log(son);    // Son {age:18} 

// 1.父构造函数
function Father(uname, age) {
  // this 指向父构造函数的对象实例
  this.uname = uname;
  this.age = age;
}
Father.prototype.money = function() {
  console.log(100000);
 };
 // 2.子构造函数 
  function Son(uname, age, score) {
      // this 指向子构造函数的对象实例
      Father.call(this, uname, age);
      this.score = score;
  }
// Son.prototype = Father.prototype;  这样直接赋值会有问题,如果修改了子原型对象,父原型对象也会跟着一起变化
  Son.prototype = new Father();
  // 如果利用对象的形式修改了原型对象,别忘了利用constructor 指回原来的构造函数
  Son.prototype.constructor = Son;
  // 这个是子构造函数专门的方法
  Son.prototype.exam = function() {
    console.log('孩子要考试');
  }
var son = new Son('王帅哥',18,100);
console.log(son);  //存在一个Father原型对象，在Father里面有age,uname,exam;money在fahter外层的原型对象里面。

// 父类
function Shape() {
  this.x = 0;
  this.y = 0;
}
// 子类
function Rectangle() {
  Shape.call(this); // 调用父类的构造函数
}
// 将父类的原型对象，作为子类原型的原型对象。子类续承父类
Rectangle.prototype = Object.create(Shape.prototype);
// 设置子类原型的构造函数
Rectangle.prototype.constructor = Rectangle;
var r = new Rectangle();
r instanceof Rectangle;	// true
r instanceof Shape;		// true