继上一篇 对象、for in、

对象回顾

//对象的第一种创建方式，通过对象直接量创建
var obj = {
    name : "胖胖",
    age : 18,
    sex : "男",
    fin : function(){
        alert("胖胖在讲课");
    },
    clothing : {
        color : "red",
        height : "100px",
        width : "100px"
    }
};
alert(obj.name);  //访问对象属性
alert(obj["name"]); //访问的第二种方式

alert( obj.fin );
obj.fin();

alert( obj.clothing.color );


//修改属性
obj.age = 19;
alert(obj.age);


//删除属性
delete obj.age;
alert(obj.age);

for in

// for in 的使用 用作遍历对象的属性
var obj = {
    name : "小明",
    age : 18,
    sex : "男"
};

for(var i in obj){
    // alert(i);//拿到的是对象的属性
    alert( obj[i] );
}

var arr = [1,22,4,7];
for(var i in arr){
    // alert(i);//打印的是数组的下标
    alert(arr[i]);
}


// with的使用
var obj = {
   name : "小明",
   age : 18,
   sex : "男"
};


with(obj){
   var n = name;
   var a = age;
   var s = sex;
}
alert(n);
alert(a);
alert(s);

类与对象

类：“类”这个词是抽象的，不是具体的某一个；比如狗，指的就是狗这一类动物，是所有的狗，不是某一只具体的狗
对象：对象是类的实例，是具体的。比如小明家的狗，这个对象指的就是具体的狗，是小明家的那一只

数组是类
var arr1 = new Array(); //arr是一个数组对象

instanceof作用

// instanceof作用：用来判断一个对象是不是某一个类的实例
//需求：怎么判断obj 是不是一个数组
var obj = new Array();
// alert(typeof obj);//打印的是object


alert(obj instanceof Array);  //打印true 说明obj是Array的一个实例
alert(obj instanceof Date);   //打印false 说明obj不是Date的一个实例

this

//this指向的是当前引用的那个对象
var obj = {
    name : "胖胖",
    age : 18,
    sex : "男",
    eat : function(){
         alert(this);        //打印object
         alert(this.name);   //打印胖胖   this指的就是obj
         alert("胖胖在吃饭");
    },
    clothing : {
        name : "衣服",
        fin : function(){
             alert(this);        //打印object
             alert(this.name);   //打印衣服  this指的就是obj.clothing
        }
    }
}

对象的第二种创建方法

//对象的第二种创建方式，可以通过new操作符来创建
var obj = new Object();
var arr = new Array();
var date = new Date();


var obj = new Object();
obj.name = "胖胖";
obj.age = 18;
obj.sex = "男";
obj.eat = function(){
    alert("胖胖在吃饭");
};
obj.eat();


var obj2 = new Object();
obj2.name = "小明";
obj2.age = 19;
obj2.sex = "男";
obj2.eat = function(){
    alert("小明运动");
};
obj2.eat();

//这种创建方式的缺点：想要创建一个相似的对象，就会产生大量代码

工厂模式

//工厂模式：可以解决第二种创建对象的缺点;

function dog(name,age,sex){   //dog是不是相当一个类
    var obj = new Object();
    obj.name = name;
    obj.age = age;
    obj.sex = sex;
    return obj;
}

var obj1 = dog("小黑",3,"男");
// alert(obj1.sex);
var obj2 = dog("小红",2,"女");
// alert(obj2.name)

//alert(obj1 instanceof dog);   //打印false  不能说明obj1是dog类的一个实例
//缺点：不能识别创建的对象是哪个类的实例

构造函数

//函数也可以是构造函数(或者是类)
//如果函数要当成构造函数来使用的话，就把第一个字符大写，区分普通的函数
function Dog(name,age,sex){  //也可以说这里是一个Dog类

    this.name = name;   //这里的this指的是谁，答：指的就是当前new的对象
    this.age = age;
    this.sex = sex;
}


var obj = new Dog("小黑",18,"男");
// alert(obj.name);
// alert(obj instanceof dog);  //打印true 说是obj 是 Dog类的一个实例

var obj1 = new Dog("小花",17,"女");

prototype

//prototype原型  相当于java中的static 静态的 公共的
function Dog(name,age,sex){

    this.name = name;
    this.age = age;
    this.sex = sex;
}

Dog.prototype.eat = function(){  //给Dog原型上添加一个eat方法，这样的话new一个对象都会具有这个方法
    alert("吃东西");
};

var dog1 = new Dog("小花",3,"女");
var dog2 = new Dog("小黑",3,"男");
dog1.eat();
dog2.eat();

给数组添加一个去重的方法

Array.prototype.removeRepetition = function(){

    var arr = [];
    for(var i = 0; i < this.length; i++){

        if( this.indexOf( this[i]) == i ){
            arr.push(this[i]);
        }
    }

    this.length = 0;   //this指的就是arr1   这里把arr1这个数组清空
    for(var j = 0; j < arr.length; j++){
        this[j] = arr[j];
    }
};
var arr1 = [11,11,11,23];
arr1.removeRepetition();
alert(arr1);