2016.4.18（js—对象基础学习笔记）

1.js采用了晚绑定，晚绑定即：编译器或解释程序在运行前，不知道对象的类型。使用晚绑定，无需检查对象的类型，只需检查对象是否支持特性和方法即可。早绑定是指在实例化对象之前定义它的特性和方法，这样编译器或监视程序就能提前转换机器代码，如Java和Visual Basic语言。
2.Array数组

• 定义方式
  var aColor=[“red”,”green”,”blue”]
  var aColor=new Array(“red”,”green”,”blue”)
• Array的大小可以动态的改变；
• Array对象覆盖了toString()和valueOf()方法，返回调用每项的toString方法，用逗号把它们连接在一起的字符串,toLocaleString()也类似；
• join()方法用于连接字符串的值，其中的唯一参数，即数组项之间使用的字符串
• 具有两个String类具有的方法，即concat()和slice()方法。concat()将参数附在数组的末尾，返回新的Array对象；slice()返回具有指定项的新数组，如果两个参数，返回第一个位置和第二个位置间的所有项，不包括第二个位置处的项
• Array模拟栈的数据结构 var stack=new Array; stack[0]=”red”; stack.pop();………
• shift()将删除数组中的第一个项，将其作为函数值返回；unshift()方法把一个项放在数组的第一个位置，然后将余下的项向后移动一位；
• reverse()方法颠倒数组项的顺序；sort()方法将根据数组项的值按升序排序

3.Date类
创建Date对象：var d=new Date();
- var d=new Date(0);只声明距离1970.1.1凌晨12点的毫秒数
- parse()和UTC()方法（Java中的两个静态方法）
var d=new Date(Date.parse(“May 25,2004”))//or 6/13/2004
var d=new Date(Date.UTC(2004,1,5))//月份从0-11，0表示1月

内置对象

1.Global对象
如我们之前使用的isNaN()、isFinite()、parseInt()、parseFloat()方法。看起来是独立的函数，其实都是Global对象的方法；
encodeURI()方法用于处理完整的URI，但它不对特殊字符进行编码（如冒号、前斜杠、问号和英镑号）
encodeURIComponent()用于处理URI的一个片断，对所有的非标准字符进行编码
eval()接收一个参数，即要执行的js字符串
这里要注意使用eval()要小心，在给它传递用户输入的数据时，恶意的用户可能会插入对站点或者应用程序安全性有危害的值，叫作代码注入
2.Math对象

//select from iFirstValue to iLastValue
fucntion selectFrom(int iFirstValue,int iLastValue){
    var iChoices=iLastValue-iFirstValue+1;
    return Math.floor(Math.random()*iChoices+iFirstValue);
}

4.this关键字
总是指向调用该方法的对象

定义类或者对象

var oCar=new Object();
oCar.color="red";
oCar.doors=4;
oCar.showColor=function(){
    alert(this.color);
};

• 工厂模式

//封装前面列出的创建car对象的操作
function createCar(){
    var oTempCar=new Object;
    oTempCar.color="red";
    oTempCar.doors=4;
    oTempCar.showColor=function(){
        alert(this.color);
    };
    return oTempCar;
}
var oCar1=new createCar();
var oCar2=new createCar();

//该进前面的createCar()方法，可以传递属性的值
function createCar(sColor,iDoors){
    var oTempCar=new Object;
    oTempCar.color=sColor;
    oTempCar.doors=iDoors;
    oTempCar.showColor=function(){
        alert(this.color);
    };
    return oTempCar;
}
var oCar1=new createCar("red",4);
var oCar2=new createCar("blue",3);

后来很多开发者在工厂函数外定义对象的方法(如showColor()方法)，然后通过属性指向该方法—>引出里构造函数的出现

• 构造函数

function Car(sColor,iDoors){
    this.color=sColor;
    this.doors=iDoors;
    this.showColor=function(){
        alert(this.color);
    };
}
var oCar1=new Car("red",4);
var oCar2=new Car("blue",3);

在构造函数的内部不用创建对象，而是使用this关键词，无需有返回值
前两种方法会重复生成函数，为每个对象都创建一个独立的函数版本（showColor）—>这就是原型方式的优势所在

• 原型方式
  利用了对象的prototype属性，可以看成创建新对象所依赖的原型

function Car(){
}
Car.prototype.color="red";
Car.prototype.doors=4;
Car.prototype.showColor=function(){
        alert(this.color);
    };
var oCar1=new Car();
var oCar2=new Car();

其中存在的问题：①对象创建后才能改变属性的默认值；②属性指向的是对象，而不是函数时：例如

Car.prototype.drivers=new Array("Mike","Sue");

var oCar1=new Car();
var oCar2=new Car();
oCar1.drivers.push("Matt");

alert(oCar2.driver);//outputs "Mike,Sue,Matt"

• 混合的构造函数/原型方式

function Car(sColor,iDoors){
    this.color=sColor;
    this.doors=iDoors;
}
Car.prototype.showColor=function(){
        alert(this.color);
}

• 动态原型方法

function Car(sColor,iDoors){
    this.color=sColor;
    this.doors=iDoors;

    if(typeof Car._initialized=="undefined"){
        Car.prototype.showColor=function(){
            alert(this.color);
        }
        Car._initialized=true;
    }
}

修改对象

• 创建新的方法

Number.prototype.toHexString=function(){
//其中this指向Number对象
    return this.toString(16);
}

• 重定义已有的方法

//保存原始方法的指针，因为一旦被覆盖后就被回收废弃
Function.prototype.originalToString=Function.prototype.toString;
Function.prototype.toString=function(){
    if(this.originalToString().length()>10){
        return "Function too long to display."
    }else{
        return this.orginalToString();
    }
}