Express不能正常安装，会出现没有相应的现象

Advance 安装中组件依赖关系选择和版本选择都会出错，反复手动选择安装，运行出现一些错误：R6034 等等，特别是Mapserver的安装

解决方法：

在一台Windows XP下安装OSGeo4W的全部需要的组件，然后复制到Win2003下，注意两个系统下的目录位置要相同

在2003下Reintstall一下Apache

完成…

后续关于MapServer的配置

安装的MapServer Itasca Demo Application存在一些问题，需要修改配置

1. D:\OSGeo\apps\mapserv-demo 下的 IMAGEPATH ，"\"和“/"问题，否则有临时文件读写错误

2.所有涉及的template文件需要增加一行”<!– MapServer Template –>“放在文件第一行，否则有模板错误提示

3.D:\OSGeo\apache\conf下httpd.conf,<Directory "d:\OSGeo/tmp/ms_tmp/"> 红色部分补上，否则看不到图

如果你准备在JavaScript中写类，那么你必需对关键字 this 的使用有深刻的理解：

这是JavaScript手册中对 this的简单解释：

this:指当前对象。

对于 JScript 的客户版本，如果在其他所有对象的上下文之外使用 this，则它指的是 window 对象。

在全局环境下的 this

通常我们认为，Javascript 不在任何函数，不在任何类中，直接书写运行的代码的环境，称为直接运行环境，或者全局环境。实际上这个环境并不是一个真正意义上全局环境,

运行下面的代码：

dump(this,'Global This');

我们可以得到输出结果：

可以看到，在这个环境下，this 等于 浏览器的原生对象 window ,它是原生类 Window 的实例。

事实上，当我们在浏览器中运行JavaScript代码时，windows 是所有代码的根节点，所有的代码都是存储并挂接于这个节点的，当然多窗口的环境下会有多个window对象。

function Car(){

}
dump(Car);
dump(window.Car);

输出结果：

■ function function Car() {  …

■ function function Car() { …

可以看到 Car 和 window.Car 是完全相同的东西

在类中使用 this

现在我们来看看当使用类的时候，this会发生什么样的变化。下面是一段典型的类定义代码，我们来逐步分析：

function Car(color,doors){
    //用构造模式定义属性
    this.color = color;
    this.doors = doors;
    this.dispThis = function(){
    	dump(this,'this');
    };
    dump(this,'this');
}

//原型方法
Car.prototype.dispThis2 = function(){
	dump(this,'this');
};

//静态方法
Car.dispThis3 = function(){
	dump(this,'this');
};

aCar = new Car('red',4);
aCar.dispThis();
aCar.dispThis2();
Car.dispThis3();
Car('red',4);

输出结果：

■ this: object – [object Object]                                                       //构造函数 new Car()

– color ■ string red

– doors ■ number 4

– dispThis ■ function function () { dump(this, "this"); }…

– dispThis2 ■ function function () { dump(this, "this"); }…

■ this: object – [object Object]                                                        //构造方法 aCar.dispThis();

– color ■ string red

– doors ■ number 4

– dispThis ■ function function () { dump(this, "this"); }…

– dispThis2 ■ function function () { dump(this, "this"); }…

■ this: object – [object Object]                                                       //原型方法 aCar.dispThis2()

– color ■ string red

– doors ■ number 4

– dispThis ■ function function () { dump(this, "this"); }…

– dispThis2 ■ function function () { dump(this, "this"); }…

 

■ this: function function Car(color, doors) { this.co…               //静态方法 Car.dispThis3()

■ this: object – [object Window]                                                   //直接运行构造函数 Car()

[The window Object]

可以看到在构造函数、构造方法、原型方法中的都可以获取到this对象，它们指向同一个实例对象aCar，该对象由 new Car() 语句生成。

在Car的静态方法 Car.dispThis4（其实就是Car的一个直接的function属性）中，this 就是Car 本身，

当不使用new 关键字，而直接运行类的构造函数Car（其实现在它就是一个普通函数）时，在函数内部 this 就是当前运行环境的window对象

注意：比较一下 aCar.dispThis() 和 静态方法 Car.dispThis3() 输出结果就可以发现：Car 和 Car 生成的对象是2个完全不同的概念；Car是一个函数对象，继承与原生的 Function ；而Car的实例aCar则是一个单纯的对象，它继承与JavaScript原生的 Object

比较一下：

通过这个表格特别是1、2、3行，我们可以清晰的得到一个规律：this 其实就等于调用代码时的调用的节点，即：aCar. 和 Car. 。这个调用节点也就是参考文档中所提到的上下文环境。

那么如何解释4、5的结果呢？

new Car();使用了一个特殊关键字 new ，这个关键字的作用就是生成一个新的对象，并赋值给 this 。所以 this = aCar

Car();没有通过任何节点调用，实际上通过了默认节点window 来调用，通过上一节我们也可以看出 Car 实际上就是 window.Car 。所以 this = window

总结和结论：

JavaScript中所有的东西都是对象，包括数字、字符、函数以及对象的属性，函数总是存在（挂接）于某个对象中（默认存在于window对象），并通过某个对象调用的。在函数中总是有一个可用的的 this 变量，脚本引擎对 this 的解析是动态的，运行时的；它指向函数被调用时所挂接的对象。

我们可以通过一系列函数对象来进一步明晰这个过程，这些函数对象我们有时也称之为类的静态方法，实际上类的静态方法本身也是一个类，也是一个对象，明白了这一点，你就可以深刻理解Javascript的对象机制了。

function Car(){
	this.name = 'car';
	e(this);
};

Car.Wheel = function(){
	this.name = 'wheel';
	e(this);

};

Car.Wheel.Size = function(){
	this.name = 'wheel.size';
	e(this);
}

Car();
Car.Wheel();
Car.Wheel.Size();

输出结果

■ object – [object Window]

■ function function Car() { this.name = "car"; …

■ function function () { this.name = "wheel"; …

当 this 遇到事件

当我们在事件函数中使用到 this 时，this 有时会很不听话，经常会取值为意料之外的对象。先来看一段示例代码：

我们定义一个类的方法函数 Car.prototype.show();

function Car(){
	this.name = 'Class Car';
}

Car.prototype.show = function(){
	echo('On Car.show');
	dump(this,'this');
};

aCar = new Car;

然后使用两个按钮的分别用两种方式触发 aCar.show;

<input id="btn1" type="button" value="Press Me call car.show"/>
<input id="btn2" type="button" value="Press Me call car.show #2"/>

<script type='text/javascript'>
   document.getElementById("btn1").onclick = aCar.show;
   document.getElementById("btn2").onclick = function(){aCar.show();}
</script>

输出结果

//btn1 click

■ this: object – [object HTMLInputElement]

– tagName ■ string INPUT

– value ■ string Press Me call car.show

– id ■ string btn1

– className ■ string

…….

//btn2 click

■ this: object – [object Object]

– name ■ string Class Car

– show ■ function function () { echo("On Car.show"); …

我们看到btn1的click事件中 this 的输出结果是 Input元素，

btn2的Click事件中，this 的输出结果是 aCar。

为什么会出现这一结果呢？

造成不同的主要原因是事件的绑定方式的不同，我们来看看事件的绑定过程：

btn1使用 document.getElementById("btn1").onclick = aCar.show  这条语句进行了事件绑定。
我们把 btn1.click 指向（引用）了 aCar.show，当事件触发时 btn1.click 被调用（回调），也就是调用了 aCar.show  的代码；看起来一切正常，唯一需要注意的是： aCar.show  的内部代码不是以节点名称 aCar 来调用的，而是以节点 btn1 来调用的，也就是说此时 show()  的运行时节点是 btn1，那么 this 也就成为了 btn1。

btn2 使用 document.getElementById("btn1").onclick = function(){aCar.show();} 。
和btn1唯一的区别就是它使用了一个匿名函数把 aCar.show();包裹起来了。就是这样简单一个包裹引起根本性的变化，当事件触发时 btn1.click 被调用（回调），运行代码并不直接是 aCar.show ，而是通过匿名函数又再次调用 aCar.show ；此时调用的节点是 aCar ,所以 this = aCar 。

有些文章用事件函数的复制和引用来解释btn1和btn2结果的不同，这种解释实际是错误的，流于表象的，虽然很多文章还做了很多图来解释… JavaScript 的所有赋值语句都应该理解为引用，这又是另外一个话题，不扯远了…

我们来进一步比较不同事件函数绑定方式所带来的 this 的变化：

function Car(){
	this.name = 'Class Car';
}

Car.prototype.show = function(){
	dump(this,'this');
};

aCar = new Car;

element.onclick = aCar.show;                       // this = element
element.addEventListener('click',aCar.show, false) // this = element

element.onclick = function () {aCar.show();}      // this = aCare
lement.attachEvent('onclick',aCar.show)           // this = aCare
<element onclick="aCar.show();">                  // this = aCare

element.onclick = function () {this.style.color = '#cc0000';}     //this = element
<element onclick="this.style.color = '#cc0000';">                 //this = element

总结：this 指向函数被调用时所挂接的对象。当事件函数被调用时，this 总是等于事件所在的节点，因此我们应该使用匿名函数作为事件函数，并在匿名函数中二次调用可能需要的其它函数。以此来避免可能的 this 混乱。

现在我们来看一段示范代码，这是一段典型的既能获取函数本身所在节点，又能获取触发对象的代码模式

function Car(){
	this.name = 'Class Car';
}

Car.prototype.doSomethin = function(obj){
  dump(this,'this');  //this = aCar
  dump(obj,'obj');    //obj = element
};

aCar = new Car();

<element onclick="aCar.doSomething(this)">                //方法1
element.onclick = function() {aCar.doSomething(this)}     //方法2

在类中进行事件绑定操作

当我们在类代码中进行事件绑定操作时，对this的使用会遇到新的困难，我们知道所有的事件函数中 this 都必然等于事件函数所在的对象（即上例中的btn1)，那么我们如何在一个类中书写一段匿名事件函数，并在匿名事件函数中调用当前类的对象呢？

看代码：

<input id="btn1" type="button" value="Press Me call car.show"/>

<script type='text/javascript'><!--

function Car(){
	this.name = 'Class Car';
}
Car.prototype.showThis = function(obj){
	dump(this,'this');
	dump(obj,'obj');
};
Car.prototype.bind = function(){
	document.getElementById("btn1").onclick = function(){ this.showThis(this); };
};

aCar = new Car;
aCar.bind();

--></script>

如果你看到这里对 this 已经有了深刻的理解，那么就会发现这段代码实际使用的话会出错的，问题就出在这一行代码：

document.getElementById("btn1").onclick = function(){this.showThis(this);};

这行代码的本身是在aCar.bind中运行，然后这行代码又写了一个匿名函数：function(){this.showThis(this);} 。匿名函数中我们希望调用当前对象 aCar 的方法 showThis ,同时又想把事件触发对象btn1 传递给 showThis。我们用了2个 this ，这里的 this 到底应该等于什么呢？两个 this 都应该等于 btn1 ,因为这个匿名函数将会以节点 btn1.click 来运行的。this.showThis 将会无法调用到我们希望的目标 aCar.showThis ；

那么如何改写这段代码，来正确的调用aCar.showThis 呢？似乎目前只有这个方法，使用一个临时变量来传递 this ：

var _this = this;

document.getElementById("btn1").onclick = function(obj){_this.showThis(obj);};

其实这样代码看起来有点让人难以理解，如果想更深入的解释这段代码，就需要进一步解释JavaScript的编译和解释运行机制，我对此也没有深入的研究，但是可以推测出的原因是：JavaScript的脚本引擎对变量的编译和解释是根据代码书写环境（书写节点）来进行的，而对this 似乎总是根据运行环境（运行节点）来赋值的。

回调函数和 this 使用的总结

关于 this 的使用似乎很让人头晕，特别是当 this 和事件和类混在一起使用的时候，如果你需要一个简单的方法来处理这个，我们可以归纳出几条规则

1. 事件处理函数又可以称为回调函数(CallBack Function)，回调函数不仅仅用于界面事件（Click,Moueover等等）的处理，很多异步处理需要大量的回调函数。
2. 总是使用匿名函数作为回调函数，并在匿名函数中再调用其它命名函数，使用 event = function(){ somefunction(); }  的方式，不要使用 event = somefunction 的方式
3. 命名并传递默认参数，同时也可以把回调函数中的 this 传递给其它被调用函数。如：event = function(params){ somefunction(this,params); }
4. 如果在类中书写匿名回调函数，并且需要在函数中调用当前类的当前对象，使用一个临时变量来引用 function(){_this.showThis();};

最后来看看常见的Jquery的事件绑定方式：

<input id="btn1" type="button" value="Press Me call car.show"/>
<input id="btn2" type="button" value="Press Me call car.show #2"/>

<script type='text/javascript'><!--

function Car(){
	this.name = 'Class Car';
}
Car.prototype.show = function(){
	echo('On Car.show');
	dump(this,'this');
};
aCar = new Car;

$("#btn1").click(function(){aCar.show()});  //通过匿名函数2次调用 this = aCar
$("#btn2").click(aCar.show);                // this = btn2

--></script>

输出结果

On Car.show //这个是引用方式 this = aCar

■ this: object – [object Object]

– name ■ string Class Car

– show ■ function function () { echo("On Car.show"); …

On Car.show //这个是复制方式 this = btn2

■ this: object – [object HTMLInputElement] 

– tagName ■ string INPUT

– value ■ string Press Me call car.show #2

– id ■ string btn2

– className ■ string

…….

这里的Node,HTMLElement,HTMLAnchorElement其实就是HTML元素对象的类声明，我们可以通过修改这些类的原型来修改所有相关的HTML元素特性。

但是，HTMLElement和Node在IE中是虽然存在的，但是IE屏蔽了它，我们是无法访问到它的。

所有的Node实例有个标准属性 nodeType,有时它可以帮助我们判断一个NODE的属性

nodeType values chart 列表

比如判断一个对象是否为 HTMLElement的实例：

Oobj instanceof HTMLElement;         //这行代码在IE中会报错的
Oobj .nodeType == Node.ELEMENT_NODE; //这行代码在IE中会报错的
Oobj .nodeType == 1;                 //Node.ELEMENT_NODE=1 在IE中只能直接使用数字

//一段完整判断函数
function isElement(Oobj ){
    return !!(Oobj && Oobj.nodeType == 1);
} 

参考：

DOM对象参考手册 http://www.navioo.com/DOMReference/HTML/reference/api/htmldom2.index.php

这个站关于JavaScript的参考资料很好，很强大 http://www.navioo.com

JavaScript中所有的东西都是对象，包括函数、字符、数字等等等。但是JavaScript没有Class这个概念。

JavaScript使用Function来模拟类，任何一个function都有一个对应的prototype对象来存储和扩展这个function的定义，也就是说原型对象是关联于函数的

我们计划使用new关键字来调用并生成新对象的函数，我们称为“构造函数”

一个基本的函数分析

function Car(){
	color = 'red';
};

echo(Car);
echo(Car.constructor);
echo(Car.prototype);
echo(Car.prototype.constructor);

输出结果

function Car() { color = "red"; }

function Function() { [native code] }

[object Object]

function Car() { color = "red"; }

1. Car本身是一个函数
2. 它的constructor是原生对象（Native Function）
3. 在函数Car定义解析的同时，会系统生成一个对象 Car.prototype，它将会是所有由Car生成(new)的实例对象的原型对象，注意它是对象，这不同于常见的Class概念。默认的原型对象没有任何属性
4. Car的原型对象的Constructor就是Car自己，这也说明了原型对象是在函数定义的同时产生的。

原型对象

函数的原型对象是在脚本引擎解析每个函数代码时自动生成的，而不是执行时才生成

//function Car 是显式定义的，Car.prototype已经在代码解析时自动生成了，此时可以访问
echo(Car.prototype);
function Car(){};

//function Plan 是赋值定义的，Plan.prototype没有自动生成了，此时不能访问
echo(Plan.prototype);
Plan = function(){};
//现在才可以访问
echo(Plan.prototype); 

原型对象实际的工作方式是一种链式查找，脚本运行时，脚本引擎首先在当前实例对象中查找指定的属性，如果有就直接使用，如果没有就到原型对象中找，如果原型对象也没有，就到原型对象的原型对象中查找，这是一个递归的查找链。所有的JavaScript对象的查找链最终都会归结到原生函数Object的原型对象中去。

function Car(){
	this.color = 'red';
};

Car.prototype.color = 'blue';
Car.prototype.doors = 4;
Object.prototype.wheels = 4;

aCar = new Car;
echo(aCar.color);
echo(aCar.doors);
echo(aCar.wheels);

输出结果：

red  //注意：这里构造函数中定义的属性color覆盖了原型中的color定义

4 //从原型中查找到了doors

4 //从根原型中查找到了wheels

实例对象的原型对象关系链是有脚本引擎内部维护的，我们不能操作和修改它，但是可以通过定义和修改构造函数的prototype属性来影响的以后生成(new)的实例对象的原型对象，而JavaScript的继承关系正是通过这一方式来模拟的。

类的继承

JavaScript所有原生函数(Function,Array..)的Prototype对象指针是只读的，不能修改。你可以改变原型的内容，但不能改变原型对象本身。

而非原生函数的的原型对象是可以修改，如果把一个函数（A）的原型定义(prototype)指向另一个函数函数（B）的实例，这样可以就模拟出A继承B的效果

其实际效果是：把B的原型对象插入到了A的实例对象的原型链中去：

new A > A.prototype > B.prototype > …. > Object.prototype

//这样的代码是不能执行的
Array.prototype = new String('');

function Car(){}
function RaceCar(){}
//RaceCar 现在继承了 Car 的定义
RaceCar.prototype = new Car;

考虑到修改函数原型对象时可能会造成修改前的原型定义丢失，所有应该仅可能早的指定原型对象。

同时你也许需要修改新原型对象的constructor，使其指向当前构造函数，典型的继承关系处理代码如下：

function Car(){
	Car.prototype.color = 'blue';
	this.doors = 4;
}

function RaceCar(){
	RaceCar.prototype.color = 'red';
	this.doors = 2;
}
RaceCar.prototype = new Car; //RaceCar 现在继承了 Car 的定义
RaceCar.prototype.constructor = RaceCar;  //修改constructor

aCar = new RaceCar();

Car.prototype.wheels = 4;

echo(aCar.color);
echo(aCar.wheels);

输出结果为：

red

4

11

建模结构图

我们使用一段代码及其对应的建模结构图来进一步说明JavaScript的继承处理方式：

代码：

function A(){

}

B.prototype = new A;
B.prototype.constructor = B;

function B(){

}

结构图：

参考：http://mckoss.com/jscript/object.htm

直接生成对象实例，并操作实例

//定义
var aCar = new Object();
aCar.color = "red";
aCar.doors = 4;
aCar.showColor = function() {}
//调用
aCar.showColor();

工厂模式

其实就把上面的代码用过函数封装一下

//定义
function createCar(color,doors){
  var aCar = new Object();
  aCar.color = color;
  aCar.doors = doors;
  aCar.showColor = function() {alert(this.color);};
  return aCar;
}
//调用
bCar = createCar('red',4);
bCar.showColor();

混合工厂模式

函数名直接用类名，然后用了关键字new，其实这样写仅仅是好看一些，和上面的工厂方法没有本质区别。

//定义
function car(color,doors){
  var aCar = new Object();
  aCar.color = color;
  aCar.doors = doors;
  aCar.showColor = function() {alert(this.color);};
  return aCar;
}
//调用
bCar = new car('red',4);
bCar.showColor();

构造模式

//定义
function car(color,doors){
  this.color = color;
  this.doors = doors;
  this.showColor = function() {alert(this.color);};
}
//调用
bCar = new car('red',4);
bCar.showColor();

和上面相比，少了2句：var aCar = new Object() 和 return aCar 。实际上关键字 new 默认执行了一个操作：this = new Object() ，而this会作为构造函数的默认返回值。

原型模式

//定义
function car(){}
car.prototype.color = 'red';
car.prototype.doors = 4;
car.prototype.showColor = function() {alert(this.color);};

//调用
bCar = new car();
bCar.showColor();

动态原型模式

定义并判断类的静态属性_initialized，在构造函数内部动态定义修改类原型。

/定义
function car(color,doors) {
    this.color = color;
    this.doors = doors;
    if (typeof car._initialized == "undefined") {
        car.prototype.showColor = function() {
            alert(this.color);
        };
    }
    car._initialized = true;
}
//调用
aCar = new car('red',4);
aCar.showColor();

总结：

这些是JavaScript类定义的几种基本模式，实际每种模式下定义出的属性和类都是有区别的，经典模式和工厂模式因为不符合OOP的语法习惯，基本没有人用了。我们通常使用构造模式和原型模式的混合定义类

目前最流行的也是最实用的类定义结构如下：

//用构造模式定义类的构造器和属性
function car(color,doors){
	//用构造模式定义属性
	this.color = color;
	this.doors = doors;
}

//用原型模式定义方法
car.prototype.showColor = function(){
	alert(this.color);
};

//这是静态属性
car.type = 'vehicle';

aCar = new car('red',4);
aCar.showColor();

1.使用构造模式定义类的构造函数和非函数属性

2.使用原型模式定义类的函数属性（方法）

3.可以通过ClassName.name的方式定义静态属性

4.函数（方法）在本质上也是一种属性，有关各种属性定义方式的区别可以参看后面的参考章节。

参看章节：

http://blog.csdn.net/avon520/archive/2009/01/17/3819751.aspx

Javascript类- 几种属性的定义方式及区别

Javascript类-构造方法和原型方法的区别

构 造方法 和构造属性一样，它是分别存储于每个实例之中的，相互之间是完全独立。

原型方法 和原型属性一样，他是存储于原型中的，每个实例中存储的实际上一 个指向原型的指针。

所有对原型方法的修改会影响到所有实例，而构造方法实际上只能通过实例来访问和修改，也只会影响到相应的实例。

先写结论：方法通常应该使用原型模式定义，并且在必要时通过原型来动态重定义，避免使用构造模式定义方法。

看看示例代码吧： 我们首先构造一个简单的类car,定义2个方法，分别是构造方式定义的constructFunction 和 原型方式定义的 prototypeFunction

function echo(str){document.write('<div>'+str+'<div>');}

function car(){
   this.constructFunction = function(){
       echo('This is constructFunction');
   };
}

car.prototype.prototypeFunction = function(){
    echo('This is prototypeFunction');
};

aCar = new car();
bCar = new car();

aCar.constructFunction();
aCar.prototypeFunction();
bCar.constructFunction();
bCar.prototypeFunction();

输出结果：

This is constructFunction

This is prototypeFunction

This is constructFunction

This is prototypeFunction

原型方法可以随时动态定义和修改，修改的方法当然是通过类的原型访问，通过重新定义原型方法可以影响到类的所有实例：

aCar = new car();
bCar = new car();

car.prototype.prototypeFunction = function(){
	echo('This a new prototypeFunction');
};

aCar.prototypeFunction();
bCar.prototypeFunction();

可以看到，即使在实例已经创建以后，对原型的修改也可以反映到影响到所有实例上来。

构造方法是无法通过原型来访问的，只能通过实例访问，也只能通过实例来重定义。下面代码尝试修改实例：aCar的方法constructFunction

aCar = new car();
bCar = new car();
cCar = new car();

// car.constructFunction() 尝试通过类或者类的原型访问构造定义的方法是无效的，会报错
// car.prototype..constructFunction() 尝试通过类或者类的原型访问构造定义的方法是无效的，会报错

aCar.constructFunction = function(){
    echo('This a new constructFunction');
}

aCar.constructFunction();
bCar.constructFunction();
cCar.constructFunction();

输出结果：

This a new constructFunction

This is constructFunction

This is constructFunction

对实例aCar的构造方法和影响到了aCar而没有影响到其它实例

事实上，原型方法也是可以通过实例直接修改的，如果直接修改实例的原型方法会出现什么情况呢？

本 段开头已经指出：“每个实例中原形方法存储的实际上一个指向原型的指针”，如果你尝试修改实例的原型方法，就改变这个指针，使其指向新定义的方法函数；而 原型中的方法定义并没有受到影响。同时，指针既然转向，那么该实例的这个原型方法也就脱离了原型的定义，而成为一个独立方法。 通过下面的代码可以清晰的明白这种过程：

aCar = new car();
bCar = new car();
cCar = new car();

//修改aCar的原型方法 prototypeFunction
aCar.prototypeFunction = function(){
    echo('This a new prototypeFunction');
}
//检查修改结果
aCar.prototypeFunction();
bCar.prototypeFunction();
cCar.prototypeFunction();

//修改原型方法 prototypeFunction ，就会发现奥妙之处了
car.prototype.prototypeFunction = function(){
    echo('This a new prototypeFunction modified by prototype');
}
//检查修改结果
aCar.prototypeFunction();
bCar.prototypeFunction();
cCar.prototypeFunction();

注意:直接修改实例的原型方法虽然是可行的,但是会带来代码上的混淆和混乱,要尽可能避免使用这种方式.

先看代码，这段代码中出现了类定义中可能使用到5种属性或者变量

function car(param1,param2){
    //构造变量
    var varProperty = 'This is a var Perperty';
    //构造属性
    this.constructProperty = 'This is a construct Property'
}

//原形属性
car.prototype.prototypeProperty = 'This is a prototype property';

//静态属性
car.staticProperty = 'This is a static property';

构造变量 使用VAR声明和定义，它的作用域仅限于构造方法内部，包括在构造器内部定义的所有方法（构造方法）。直接通过变量名访问：varProperty。有些文章也把叫做私有属性，从作用域上看，它是私有的，但它不是属性，类的原型是无法访问它的。

构造参数 就是上述代码中的 param1,param2,它与构造变量有相同的作用域和方法方式

function car(param1,param2){
    //构造变量
    var varProperty = 'This is a var Perperty';

    echo(varProperty);
    echo(param1);

    this.someMethod = function(){
        echo(varProperty);
        echo(param1);
     };
}

构造属性 构造属性在类的构造器中通过this.定义，它是公开的(public)，可以通过类的实例(this.)直接访问和修改它

原型属性 在类的原型中定义，它也是公开，具有和构造属性相同的作用域，它不仅可以通过实例访问，也可以随时通过原型来访问（(ClassName.propertype.)

它和构造属性是有区别的：原型属性可以通过原型直接访问，它存储于类的原型中的，各个实例是通过指针共享访问它。具体下面单独分析

function car(){

    //构造属性
    this.constructProperty = 'This is a construct Property'

    this.someMethod = function(){
        echo(this.constructProperty); //这样可以
        echo(this.ptototypeProperty); //这一可以
     };
}

//原形属性
car.prototype.prototypeProperty = 'This is a prototype property';

echo(car.constructProperty);  //这样是不能访问构造属性的
echo(car.ptototypeProperty);  //这样是不能访问原型属性的

//必须通过实例来访问
aCar = new car();
echo(aCar.constructProperty);  //这样可以
echo(aCar.ptototypeProperty);  //这样可以

echo(car.prototypeProperty)    //原型属性可以通过原型直接访问

静态属性 直接通过ClassName.的方式定义，它具有和常规OOP语言中的静态属性类似的特性，但注意，它只能通过ClassName访问，不能通过实例访问，在类的中也不能通过this访问

function car(param1,param2){
    echo(this.staticProperty);//这样是不能访问到静态属性的。
    echo(car.staticProperty);//这样可以访问到静态属性的。
}

//静态属性
car.staticProperty = 'This is a static property';

aCar = new car();
echo(aCar.staticPerperty); //这样是不能访问到静态属性的。
echo(car.staticProperty); //这样可以访问到静态属性的。

构造属性和原型属性的区别：

上面已经说了构造属性和原型属性的定义方式，和访问方法，它们的主要区别在于：原型属性可以通过原型直接访问，它存储于类的原型中的，各个实例是通过指针共享访问它。也就是说对于每个构造属性，每个实例都有一个自己存储副本；而对于每个原形属性，每个实例实际上是共享同一个存储副本，实例中存储的仅仅是一个指向原型属性的指针。

看代码吧：

function car(){
    //构造属性
    this.constructProperty = new Array ('tom','jerry');
}

//原形属性
car.prototype.prototypeProperty = new Array ('tom','jerry');

aCar = new car();
bCar = new car();
cCar = new car();

//修改aCar的构造属性
aCar.constructProperty.push('Emeric');
echo(aCar.constructProperty);
echo(bCar.constructProperty);
echo(bCar.constructProperty);

//修改aCar的原型属性
aCar.prototypeProperty.push('Emeric');
echo(aCar.prototypeProperty);
echo(bCar.prototypeProperty);
echo(bCar.prototypeProperty);

输出结果：

//改变aCar的构造属性，仅仅影响到的aCar单一实例

tom,jerry,Emeric

tom,jerry

tom,jerry

//改变aCar的原型属性，影响到了所有实例

tom,jerry,Emeric

tom,jerry,Emeric

tom,jerry,Emeric

这里我们为什么在示例代码中使用数组，而没有使用其它简单变量呢？来看另一段代码：这段代码的和上面的唯一区别是使用了字符串作为属性，

function car(){
    //构造属性
    this.constructProperty = 'This is a construct Property'
}

//原形属性
car.prototype.prototypeProperty = 'This is a prototype property';

aCar = new car();
bCar = new car();
cCar = new car();

aCar.constructProperty = 'New string';
echo(aCar.constructProperty);
echo(bCar.constructProperty);
echo(bCar.constructProperty);

aCar.prototypeProperty = 'New string';
echo(aCar.prototypeProperty);
echo(bCar.prototypeProperty);
echo(bCar.prototypeProperty);

输出结果如下，对aCar的两种属性的修改都没有影响到其它实例，正如上面所说，javascript在实例中使用指针来指向原型属性，当使用 aCar.prototypeProperty = 'New string' 进行直接赋值时，javascript进行的操作是修改实例的指针（aCar.prototypeProperty ），使其指向新的存储副本 'New string' ，这一过程往往会掩盖了原型属性的共享特性。

New string

This is a construct Property

This is a construct Property

New string

This is a prototype property

This is a prototype property

再看一段补充代码，这是接着上面的代码运行的，我们通过原型来直接修改了原型属性：

car.prototype.prototypeProperty = 'Another New String!';
echo(aCar.prototypeProperty);
echo(bCar.prototypeProperty);
echo(bCar.prototypeProperty);

输出结果如下，会发现，这一修改仅仅影响到了bCar和cCar。

原因其实就是因为上面 aCar.prototypeProperty = 'New string' 的，它改变了 aCar.prototypeProperty 的指向，而不再指向 原型，因而他也就脱离了原型的控制。

New string

Another New String!

Another New String!

由于原型属性的共享特性和可能发生的实例指针脱离原型的现象，我们应该仅仅对需要共享的属性使用原型定义，一般的属性应该尽量使用构造来定义；在修改原型属性时应该尽可能通过原型(car.prototype.)来访问修改，而不要通过实例(aCar.)来修改；。以此来避免可能发生的属性混乱问题。

软件：Debian Lenny 5.0 + ISPCP 1.0.2 stable

工具：apache 里的AB

声名：这是在一个非标准环境下的测试，测试结果不具有普遍可比性，仅供参考

eAccelerator的对比测试结果

测试应用网站：3个

• A 一个简单的模拟PHPINFO类页面，提取系统信息，显示，单文件程序
• B 一个自己开发的CMS系统
• C WordPress BLOG，加载了一些常见插件

测试方式：使用 ab -t 60 -c 5 参数测试，每阶段2次测试取评价值，分2个阶段

• P1 没有安装eAcceleratr
• P2  安装了eAccelerator

分析：

依照CMS应用为典型WEB应用需要环境，可以看到eAccelerator提高效率高达100%，综合环境变化情况，至少我们可以期望有50%的提高，从A和B成绩对比来看，过于简单的脚本和过于复杂的脚本环境下，eAccelerator表现就不是很突出，当然，这也木桶原理的表现。

从A/B的对比成绩，我们还可以看出，eAccelerator因为可以缓存脚本编译结果，由此带来的CPU占用率的降低是很明显的。

eAccelerator环境下的压力测试：

测试应用网站：

• A 一个简单的模拟PHPINFO类页面，提取系统信息，显示，单文件程序
• B 一个自己开发的CMS系统
• C WordPress BLOG，加载了一些常见插件
• D 一个最简单的静态HTML文件，仅显示几个字符，主要测试APACHE的静态响应能力

测试方法：使用 ab -t 30 -c X 参数测试，每阶段2次测试取平均值

X分别取 1 / 2 /5 /15 /60 分段测试，根据具体应用，某些分段没有测试意义，跳过了

A INFO 页面压力分段测试成绩

B CMS页面压力分段测试成绩

C WordPress页面压力分段测试成绩

D 简单静态HTML页面

分析：

1. 此测试环境典型WEB应用的最佳并发连接支持大约在每秒十个左右（低不低？）
2. WordPress确实是个巨无霸
3. 针对A的测试结果，我们可以认为，系统响应瓶颈应该在IO部分
4. 针对 B / C 的测试结果，我们可以认为系统响应的瓶颈在CPU
5. 本来想进一步提高静态页面测试压力的，可是ab在我的Windows Server环境下总是有问题
   先是报这个错，后来换个AB版本解决了
   apr_pollset_create failed: Invalid argument (22)      
   又开始报这个错。。。郁闷
   apr_socket_recv: 您的主机中的软件放弃了一个已建立的连接。   (730053)

 BTW：我一开始的测试结果很低，后来发现问题出在我的测试客户端需要通过一条RouterOS路由器访问服务器，而且还要NAT转换一下，严重影响了测试结果，我把当时使用RouterOS路由时的测试结果也贴上来吧，仅供娱乐：

近期看到ISPCP正式版已经发布好久了,就决定升级.升级路线是首先 升级Debian 到 Lenny (5.0),然后再升级ISPCP

A 升级Linux

升级的方法很简单

1) (可选的) 检查你的更新源列表（sources.list)

apt-spy -d stable -t 5 update #是用Stable或者Lenny现阶段效果应该是一样的

有些指南让你加上国家和地区参数，时间没有必要，事实上我们访问最快的源往往都在国外。

你也可以手动去更新 /etc/apt/sources.list

2) 更新系统

aptitude update && aptitude upgrade

这一步可能需要反复运行几次，如果有软件版本冲突提示，你需要运行 aptitude 手动选择冲突解决方案

一直运行到aptitude update && aptitude upgrade提示没有需要更新软件包了，系统升级完成

3)可能遇到的问题

我遇到问题是：Mysql升级到5.2以后不能自动启动了，检查 /etc/log/daemon.log发现一个提示

/etc/init.d/mysql[2130]: ERROR: Using expire_logs_days without log_bin crashes the server. See README.Debian.gz

修改 /etc/mysql/my.cnf 解决问题

#log_bin = /var/log/mysql/mysql-bin.log #这一行本来是被注释掉的

expire_logs_days = 10

完成上述步骤后服务器及ISPCP应该仍然可以正常工作，检查处理完可能存在的问题后，准备升级ISPCP

B) 更新 ISPCP到 1.0.2

安装ISCP官方说明逐步操作

http://www.isp-control.net/documentation/doku.php?id=start:upgrade:rc

几点说明：

1）更新/ect/apt/sourcs.list

直接使用上述apt-spy获取的sources.list,按如下格式添加 contrib 和 non-free 参数

deb http://ftp.tw.debian.org/debian/ lenny main contrib non-free

deb http://security.debian.org/ lenny/updates main contrib non-free

deb-src http://ftp.tw.debian.org/debian/ lenny main contrib non-free

2) 如果你已经采取了其他系统备份措施，官方说明中的第6步（BACKUPS）是可以跳过的

3) 第9步：【 cp -Rv /tmp/ispcp/var/* /var/ 】，你可能会遇到一个无法覆盖的提示： /var/www/ispcp/daemon/ispcp_daemon Text in busy，你可以忽略，或者先停止ispcp_daemon【/etc/init.d/ispcp_daemon stop】

4）如果你在perl ispcp-update 过程中遇到需要输入密码的步骤，如果恰好你又选择了 【auto generated 】，恩，慢慢等吧，不是死机了，就是慢。

5）如果你安装官方步骤升级完遇到服务器报”500 Server Error”错误

出现这个错误的可能原因很多，首先你需要检查你的Apache，FastCGI，PHP是否使用了非官方集成的插件，比如eAccelerator等。500错误一般出现在FastCGI和PHP引擎。

我的情况是eAccelerator版本过期，因为PHP升级了，所以需要重新编译eAccelerator

有关eAccelerator的安装和配置参阅 http://isp-control.net/documentation/doku.php?id=howto:eaccelerator

6）学会追踪分析各类日志文件是解决各类问题的最好方法，比如上述500问题，如果不是通过日志分析，想找到问题根源实在是太难。而且ISPCP默认没有启用PHP的错误日志文件记录，我还是手动修改PHP.ini，启用PHP日志后才追踪发现问题的根源的。

/var/log/* 大部分系统LOG文件都是放在这里的

7) ISPCP的配置和日志文件结构

/etc
     /apach2
             /apache2.conf           #apache 主配置文件
             /conf.d/*               #附加配置文件
             /mods-*/*               #附加MOD配置文件
             /sites-*/*              #站点配置文件
             /ispcp                  #ISPCP各客户站点配置，这个目录实际上链接到了 /sites-*/* 目录下了
     /php5
             /cgi/php.ini            #php 主配置文件
             /cli/phpini             #php 的 cli 配置文件
             /conf.d/*               #PHP 附加配置文件
     /ispcp
             /ispcp.conf             #ispcp 主配置文件
             /apache/*               #apache 相关的配置文件模板
             /fcgi/*                 #php    相关的配置文件模板和脚本模板
             /*other                 #应该是其他一些相关配置的模板
/var/www
     /fcgi                           #各客户站点的PHP配置文件及FastCGI的PHP启动脚本
             /domain.com             #一个站点
                /php5/php.ini        #PHP 的站点配置文件
                /php5-fcgi-starter   #启动PHP 的FASTCGI脚本
     /ispcp                          #ispcp的运行文件
             /gui                    #管理站点文件
     /virtual/domain.com             #各个客户站点主目录
             /htdocs                 #网站根目录
             /errors                 #错误提示的相关文件HTML
             /cgi-bin                #脚本目录
             /backups                #备份文件，自动/手动
             /logs                   #这个不用说了吧，默认的这里放的是Apache的LOG文件
             /phptmp                 #脚本临时文件，默认的Session文件放这里的
/var/log
     /kern.log                       #系统核心
     /daemon.log                     #系统服务
     /mysql.err
     /mysql.log
     /mysql/*                        #Mysql想关的LOG
     /apache2/*                      #Apache的LOG（Combined,error,traf,suexec等到）还有各个站点，
                                     #这里的LOG和/var/www/virtual//domain.com/log 是什么关系我还没搞清楚

8) 关于修改ISPCP配置模板文件以后如何刷新各站点，请参阅：

http://www.isp-control.net/documentation/doku.php?id=howto:ispcp:regenerate_config

关于PHP的站点配置文件刷新，官方说明有误刷新前你必须删除原有的站点配置文件，才会刷新，另外master站点不会刷新的。

ISPCP的各处PHP配置文件加载顺序为
1 /etc/php5/cgi/php.ini
2 /var/www/fcgi/domain.com/php5/php.ini
3 /etc/php5/conf.d/*

下面的配置会覆盖上面的配置，所以你可以把共性的配置定义放到conf.d目录下，专门建立一个文件放置。而把需要每个站点单独配置的特别是设计路径的配置项放到parts/php.ini中，然后刷新生效。

下面是我的对配置文件的修改

;添加到 /etc/ispcp/fcgi/parts/php5/php.ini 结尾
[Append per site]
eaccelerator.cache_dir = "{WWW_DIR}/{DMN_NAME}/phptmp"
error_log               = {WWW_DIR}/{DMN_NAME}/logs/php-error.log

;添加到 /etc/php5/conf.d/my.ini

disable_functions = show_source, system, shell_exec, passthru, exec, phpinfo, shell, symlink, popen, proc_open

file_uploads		= On

upload_max_filesize	= 20M
post_max_size		= 30M

;memory_limit		= 128M

max_input_time		= 300
;max_execution_time	= 30 

error_reporting      =  E_ALL & ~E_NOTICE | E_WARNING | E_STRTCT
log_errors             = On
display_errors	= Off

下面是我写的一个自动刷新ISPCP PHP配置文件的脚本

#!/bin/sh
/etc/init.d/ispcp_daemon stop

echo 'Enter the password of root for mysql'
mysql -u root -p < ispcp-reset-site-status.sql

echo 'Wating........'
rm -r ispcp-conf-backups
mkdir -p ispcp-conf-backups
mv /var/www/fcgi/*.* ispcp-conf-backups

/var/www/ispcp/engine/ispcp-rqst-mngr
/etc/init.d/ispcp_daemon start

/etc/init.d/apache2 restart

配套的SQL文件，务必保存成文件名：ispcp-reset-site-status.sql，并放到和上面脚本相同的目录下

USE ispcp;
UPDATE `domain` SET `domain_status` = 'change' WHERE `domain_status` = 'ok';
UPDATE `subdomain` SET `subdomain_status` = 'change' WHERE `subdomain_status` = 'ok';
UPDATE `domain_aliasses` SET `alias_status` = 'change' WHERE `alias_status` = 'ok';

1.指定新目标数据库的编码为 utf8_unicode_ci ,需要你的Mysql版本为4.1+，通过 数据库->操作 来操作

2.导入数据备份文件

3.修改wp-config.php 文件，增加一行： define(‘DB_CHARSET’,'utf8′);

OK，完成！

顺便提一下，低版本数据库导入高版本数据库时，先根据源数据编码指定好新的目标数据库默认编码（通过 数据库->操作 来操作），可以解决大部分数据升级到乱码问题。