javascript中领悟到的重要三点

1.封装

2.继承

3.多态

1.1 封装（单例模式）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var obj = {
  name: 'qinqiang',
  age:'25',
  method:function(){
    var objName = this.name;
    return objName;
  },
  ale:function(){
    var that = this;
    function sum(num1,num2){
      this.num = that.age;
      return num1+this.num+num2;
    }
    console.log(sum(1,2));
  }
}

单例模式有不污染全局变量和节约window栈内存的优点

1.2 封装（工厂模式）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function self (name,age,sex){
  var person ={};
  person.name = name;
  person.age = age;
  person.sex = sex;
  if(sex=="man"){
    person.job="coder"
  }
  if(sex=="women"){
    person.job="beautiful"
  }
  return person
}
var people = self ("qinqiang",27,"man")
console.log(people.job)

1.2 封装（构造函数模式）

1
2
3
4
5
6
7
8
9
function person (){
  this.eat = "food";
  this.sleep="night";
  this.say=function(){
    console.log("I can say chinise")
  }
}
var p = new person();
p.say()

2.1继承 (原型继承）

我理解的是把被继承者的构造函数赋值给继承者的prototype，需要给继承者的prototype手动添加constructor属性

1
2
3
4
5
6
7
8
9
10
11
12
13
function A(){

};
function B(){

};
B.prototype.work = function(){
  console.log('I can work');
};
A.prototype = new B();
A.prototype.constructor = A;
var a = new A()
console.log(a.work)

2.1继承 (call/apply 继承）

1
2
3
4
5
6
7
8
9
10
11
12
function A(){
  this.name = 'qq'
  this.age = '25'
  this.say = function(){
    console.log("i can say")
  }
}
function B(){
  A.call(this)
}
var b = new B()
console.log(b)

3.多态

javascript中没有严格的多态，因为JS中没有重载，相同名字的函数不能同时存在，后定义的重名函数会覆盖先定义的函数（即使两个形参不相同）,但是可以用一个通用方法来模拟面向对象语言的多态

1
2
3
4
5
6
7
8
9
10
11
12
13
function simpoly(){
  if(arguments.length ===1){
    return function(){
      console.log(1);
    }
  }
  if(arguments.length ===2){
    return function (){
      console.log(2);
    }
  }
}
simpoly(1,2)()