面向对象
基于原型的面向对象
基于原型的面向对象方式中,对象(object)则是依靠构造器(constructor)利用原型(prototype)构造出来的.
function F(argument) { //自定义函数
}
alert(F.prototype); //对象 F.prototype --> 内存地址 --> 存储一个对象
//构造函数对象:函数构造器 创建函数对象
var obj = new Function(var1,var2,...,functionBody());
//var1,var2 functionBody() 自定义函数
- 注意:构造器构造的对象,效率低,var1,var2 顺序在functionBody中不能变
- 对象 --> 函数对象,普通对象 new Function创建的都是函数对象
闭包
- 用途:读取函数内部变量 让i变量的值保留在内存中
- 优缺点:封装性强 可以访问局部变量 内存占用浪费,容易引起内存泄漏
function a(){
var i = 0;
function b(){
alert(++i);
}
return b;
}
var c = a();
c(); //1
声明对象
第一种 字面式
var obj = {
var obj = {
name : 'greentea',
age : 23,
do : function(){
console.log('do...');
}
}
第二种
var obj = new Object();
obj.name = 'greentea';
obj.age = 23;
第三种 构造函数
function test(a,b,...){
this.name = wang;
this.do = function(){
//...
}
}
var obj = new test(a,b,...)
工厂模式创建对象
工厂模式创建对象不需要new,并且要返回一个对象,而构造函数创建对象需要new一个对象,还要将this返回
function createObject(name,age){
var obj = new Object();
obj.name = name;
obj.age = age;
obj.run = function(){
return this.name + this.age;
}
return obj;
}
var box1 = createObject('zhangsan',21);
var box2 = createObject('lisi',18);
原型模式创建对象
function test(){
}
test.prototype.play = 'lol';
test.prototype.do = 'papa';
test.prototype.eat = function(){
console.log('mm');
}
var obj = new test();
构造加原型
function test(){
this.color = 'red';
}
test.prototype.play = 'lol';
test.prototype.do = 'papa';
test.prototype.eat = function(){
console.log(this.color);
}
var obj = new test();
对象的遍历
var person = {};
person.name = 'zs';
person.age = 23;
for(var i in person){ //i是属性或方法名称
alert(ren[i]); //取得属性值或方法体
}
封装
function demo(){
var n = 1; //局部变量,外部不能直接访问
function test(){
return n++;
}
return test;
}
alert(demo()()); //2
原型链继承
原型:是利用
prototype添加属性和方法
原型链:JS在创建对象(不论是普通对象还是函数对象)的时候,都有一个叫做__proto__的内置属性,用于指向创建他的函数对象的原型对象prototype
原型链的概念实现原型继承
function Person(name,age){
this.name = name;
this.age = age;
}
Person.prototype.sayHello = function(){
alert('属性name值' + this.name);
}
function Student(){
this.style = 'play';
}
Student.prototype = new Person('lisi',18);
Student.prototype.grade = 3;
Student.prototype.test = function(){
alert(this.grade);
}
构造函数继承
在子类内部构造父类的对象实现继承
function Parents(name){
this.name = name;
this.say = function(){
alert('父亲的名字:'+this.name);
}
}
function Child(name,age){
this.pObj = Parents;
this.pObj(name);
this.age = age;
this.sayC = function(){
alert('child:' + this.name + '---' + 'age:' + this.age);
}
}
var p = new Parents('zhangsan');
p.say();
var c = new Child('lisi',20);
c.sayC();
call和apply的用法
call:调用一个对象的方法,以另一个对象替换当前对象
apply:应用某一对象的一个方法,用另一个对象替换当前对象
obj.call(function(){},var1,var2,var3...)
obj.apply(function(){},[var1,var2,var3...])
function person(name,age,len){
this.name = name;
this.age = age;
this.len = len;
this.say = function(){
alert(this.name + ":" + this.age + ":" + this.len);
}
}
//call继承
function student(name,age){
person.call(this,name,age);
}
//apply继承
function teacher(name,age,len){
person.apply(this,[name,age,len]);
}
var per = new person('zhangsan',25,170);
per.say();
var stu = new student('lisi',18);
stu.say(); //lisi 18 undefined
delete
- 只能删除属性,不能删除方法
- 删除不了变量
- 不能删除原型链中的属性和变量
callee
调用本函数,如果没有条件约束,将陷入死循环
var sum = function(){
if(n<=1){
return 1;
}else{
return n+arguments.callee(n-1); //在函数内部调用本函数
}
}
