js之自定义对象/URI编码

一、定义对象
1.对象初始化器方式
格式：objectName = {property1:value1, property2:value2,…, propertyN:valueN}
property是对象的属性,value则是对象的值，值可以是字符串、数字或对象三者之一
例如：

Js代码

1. var user={name:“user1”,age:18}；   
2. var user={name:“user1”,job:{salary:3000,title:programmer}  

var user={name:“user1”,age:18}；
var user={name:“user1”,job:{salary:3000,title:programmer}

以这种方式也可以初始化对象的方法，例如：

Js代码

1. var user={name:“user1”,age:18,getName:function(){return this.name;}             
2. }  

var user={name:“user1”,age:18,getName:function(){return this.name;}          
}

2.工厂函数（factory function）方式
例如：

Js代码

1. //每个对象都共享了同一个函数。   
2. function showColor(){   
3.     alert(this.color);   
4. }   
5.   
6. function createCar(sColor,iDoors){   
7.     var oTemp = new Object;//对象的属性可在对象创建后动态定义   
8.     oTemp.color = sColor;   
9.     oTemp.doors = iDoors;   
10.     oTemp.showColor = showColor;   
11.     return oTemp;   
12. }   
13.   
14. var oCar1 = createCar("red",4);   
15. var oCar2 = createCar("blue",3);  

//每个对象都共享了同一个函数。
function showColor(){
    alert(this.color);
}

function createCar(sColor,iDoors){
    var oTemp = new Object;//对象的属性可在对象创建后动态定义
    oTemp.color = sColor;
    oTemp.doors = iDoors;
    oTemp.showColor = showColor;
    return oTemp;
}

var oCar1 = createCar("red",4);
var oCar2 = createCar("blue",3);

3.构造函数方式
创建构造函数就像定义工厂函数一样容易。第一步选择类名，即构造函数的名字。根据惯例，这个名字的首字母大写，以使它与首字母通常是小写的变量名区分开。
例如：

Js代码

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

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关键字。使用new运算符调用构造函数时，在执行第一行代码前先创建一个对象，只有用this才能访问该对象。然后可以直接赋予this属性，默认情况下是构造函数的返回值（不必明确使用return运算符）。
4.原型(prototype)方式
该方式利用了对象的prototype属性，可把它看成创建新对象所依赖的原型。这里，用空构造函数来设置类名。然后所有的属性和方法都被直接赋予prototype属性。

Js代码

1. function Car(){   
2. }   
3. //使用原型方式时，不能通过给构造函数传递参数初始化属性的值，这意味必须在对象创建后才能改变属性的默认值   
4. Car.prototype.color ="red";   
5. Car.prototype.doors = 4;   
6. Car.prototype.drivers = new Array("Lucy","Lily");//对象却很少被多个实例共享的,属性drivers是指向Array对象的指针   
7. Car.prototype.showColor = function(){//函数共享不会造成任何问题   
8.    alert(this.color);   
9. }   
10. var oCar1 = new Car();   
11. var oCar2 = new Car();   
12. oCar1.drivers.push("Mike");   
13. alert(oCar1.drivers);//outputs "Lucy,Lily,Mike"   
14. alert(oCar2.drivers);//outputs "Lucy,Lily,Mike"  

function Car(){
}
//使用原型方式时，不能通过给构造函数传递参数初始化属性的值，这意味必须在对象创建后才能改变属性的默认值
Car.prototype.color ="red";
Car.prototype.doors = 4;
Car.prototype.drivers = new Array("Lucy","Lily");//对象却很少被多个实例共享的,属性drivers是指向Array对象的指针
Car.prototype.showColor = function(){//函数共享不会造成任何问题
   alert(this.color);
}
var oCar1 = new Car();
var oCar2 = new Car();
oCar1.drivers.push("Mike");
alert(oCar1.drivers);//outputs "Lucy,Lily,Mike"
alert(oCar2.drivers);//outputs "Lucy,Lily,Mike"

是否有种合理的创建对象的方法呢？答案是联合使用构造函数和原型方式。
5.混合的构造函数/原型方式
用构造函数定义对象的所有非函数属性，用原型方式定义对象的函数属性（方法）。结果所有函数都只创建一次，而每个对象都具有自己的对象属性实例。

Js代码

1. function Car(sColor,iDoors){   
2.    this.color = sColor;   
3.    this.doors = iDoors;   
4.    this.drivers = new Array("Lucy","Lily");   
5. }   
6. Car.prototype.showColor = function(){   
7.    alert(this.color);   
8. }   
9. var oCar1 = new Car("red",4);   
10. var oCar2 = new Car("blue",3);   
11. oCar1.drivers.push("Mike");   
12. alert(oCar1.drivers);//outputs "Lucy,Lily,Mike"   
13. alert(oCar2.drivers);//outputs "Lucy,Lily"  

function Car(sColor,iDoors){
   this.color = sColor;
   this.doors = iDoors;
   this.drivers = new Array("Lucy","Lily");
}
Car.prototype.showColor = function(){
   alert(this.color);
}
var oCar1 = new Car("red",4);
var oCar2 = new Car("blue",3);
oCar1.drivers.push("Mike");
alert(oCar1.drivers);//outputs "Lucy,Lily,Mike"
alert(oCar2.drivers);//outputs "Lucy,Lily"

现在就更像创建一般对象了。所有的非函数属性都在构造函数中创建，意味着又可用构造函数的参数赋予属性默认值了。因为只创建showColor()函数的一个实例，所以没有内存浪费。这种方式是ECMAScript主要采用的方式，它具有其他方式的特性，却没有它们的副作用。
6.动态原型方法
动态原型方法的基本想法与混合的构造函数/原型方式相同，即在构造函数内定义非函数属性，而函数属性则利用原型属性定义。唯一的区别是赋予对象方法的位置。

Js代码

1. function Car(sColor,iDoors){   
2.    this.color = sColor;   
3.    this.doors = iDoors;   
4.    this.drivers = new Array("Lucy","Lily");   
5.    if(typeof Car._initialized == "undefined"){   
6.    Car.prototype.showColor = function(){   
7.      alert(this.color);       
8.    }   
9.    Car._initialized = true;   
10.   }   
11. }  

function Car(sColor,iDoors){
   this.color = sColor;
   this.doors = iDoors;
   this.drivers = new Array("Lucy","Lily");
   if(typeof Car._initialized == "undefined"){
   Car.prototype.showColor = function(){
     alert(this.color);    
   }
   Car._initialized = true;
  }
}

直到检查typeof Car._initialized是否等于"undefined"之前，这个构造函数都未发生变化。这行代码是动态原型方法中最重要的部分。如果这个值未定义，构造函数将用原型方式继续定义对象的方法，然后把Car._initialized设置为true。如果这个值定义了（它的值为true时，typeof的值为Boolean），那么就不再创建该方法。简而言之，该方法使用标志（_initialized）来判断是否已给原型赋予了任何方法。该方法只创建并赋值一次。

例子：定义一个StringBuffer类

Js代码

1. function StringBuffer(){   
2.    this._strings_=new Array;   
3. }   
4. //把该参数附加到字符串数组中   
5. StringBuffer.prototype.append = function (str){   
6.    this._strings_.push(str);   
7. }   
8. //返回真正连接成的字符串   
9. StringBuffer.prototype.toString = function(){   
10.    return this._strings_.join("");   
11. }   
12. //清空   
13. StringBuffer.prototype.removeAll = function(){   
14.    this._strings_.splice(0,this._strings_.length);//this._strings_.length=0   
15. }  

function StringBuffer(){
   this._strings_=new Array;
}
//把该参数附加到字符串数组中
StringBuffer.prototype.append = function (str){
   this._strings_.push(str);
}
//返回真正连接成的字符串
StringBuffer.prototype.toString = function(){
   return this._strings_.join("");
}
//清空
StringBuffer.prototype.removeAll = function(){
   this._strings_.splice(0,this._strings_.length);//this._strings_.length=0
}

二、URI编码
    encodeURI()和encodeURIComponent()方法用于编码传递给浏览器的URI(统一资源标识符)。
    用法：

• encodeURI():处理完整的URI.
• encodeURIComponent():处理URI的一个片断。

   区别：

• encodeURI():不对URI中的特殊字符进行编码，如冒号、前斜杠、问号和英镑符号。
• encodeURIComponent():对它发现的所有非标准字符进行编码。

   如：var sUri = "http://www.wrox.com/illegal value.html#start";
   encodeURI(sUri)：http://www.wrox.com/illegal%20value.html#start
   encodeURIComponent(sUri)：starthttp%3A%2F%2Fwww.wrox.com%2Fillegal%20value.html%23start

   decodeURI()和decodeURIComponent()对应于encodeURI()和encodeURIComponent()的编码解码。
    说明：decodeURI()只对encodeURI()编码的字符解码。
    decodeURIComponent()会解码所有的encodeURIComponent()编码过的字符。