openwares.net

Java EE Kepler Service Release 1版自带的EGIT仍然不支持符号链接，将符号连接视为脏文件，用.gitignore忽略掉符号链接都没用，只能从EGIT team->advanced里将符号连接设置为”Assume Anchanged”。

vim支持文本折叠,将多行文本折叠到一行显示，并提供折叠起来的多行文本的预览。通过折叠，可以更容易明白整个文档的结构。
一个折叠就相当于文档中的一个小节。

Tomcat支持多虚拟主机，每个虚拟主机又可以有多个虚拟目录,应用程序可以部署到虚拟目录，也可以直接部署到虚拟主机的根目录

添加虚拟主机

[xml]

主机的基本目录为/path/to/webapps，默认情况下,该目录下的ROOT目录为主机根虚拟目录，其他命名目录为相应名字的虚拟目录。
也就是说，访问http://openwares.net/会访问到/path/to/webapps/ROOT目录，而访问http://openwares.net/foo
则会访问到/path/to/webapps/foo目录。

如果是部署war文件，则ROOT.war对应根虚拟目录/，而foo.war则对应/foo虚拟目录

部署应用程序到根虚拟目录

最简单的办法就是，直接将应用程序部署到虚拟主机appBase目录下的ROOT目录，如果是部署war包则将其命名为ROOT.war放到appBase目录下

还有一个方法是为应用程序在虚拟主机内添加一个Context,有两个选择：

• 直接修改server.xml配置文件
  在虚拟主机配置下面添加Context
  [xml]
  
  \[/xml\] path留空，则表示根虚拟路径/映射到/path/to/webapps目录。如果path="/foo",则/foo虚拟路径映射到/path/to/webapps
• 在Catalina/主机名/目录下添加Context配置文件
  Catalina/openwares.net/ROOT.xml
  [xml]
  [/xml]

注意xml配置文件的命名，ROOT.xml表示配置的虚拟路径为根虚拟路径，配置文件里面的path和上面一样要置空。
如果配置访问应用程序的虚拟路径为/foo,则配置文件名为foo.xml
Catalina/openwares.net/foo.xml
[xml]


[/xml]

第二种方法更好一些

注意：使用context配置根虚拟路径时，host的docBase一定不要与Context的docBase指向同一个目录，host默认的ROOT Context优先级比较高，会使用户设置的ROOT Context失效。

默认情况下，使用new运算符创建的对象是从函数构造器(constructor)的原型对象(constructor.prototype)继承属性的，新对象不会继承函数构造器(constructor)自身的属性。
[javascript]
(function(){
function Func(){
this.a=”a”
}

Func.b=”b”
Func.prototype.c=”c”;

var obj=new Func();
console.log(obj.a); //a
console.log(obj.b); //undefined
console.log(obj.c); //c

console.log(obj.proto); //F{c: “c”}
console.log(obj.prototype); //undefined
})();
[/javascript]

可以看到obj有本地属性a,没有属性b，还有继承自constructor.prototype的属性c。

那么要让obj继承函数构造器(constructor)的属性也十分简单
[javascript]
function Func(){
this.a=”a”
}

Func.b=”b”
Func.prototype.c=”c”;
Func.prototype=Func;

var obj=new Func();
console.log(obj.a); //a
console.log(obj.b); //b
console.log(obj.c); //undefined

console.log(obj.proto); //function Func(){this.a=”a”}
console.log(obj.prototype); //function Func(){this.a=”a”}
})();
[/javascript]

只要将函数构造器(constructor)的原型对象(constructor.prototype)指定为其自身即可。

===
[erq]

函数声明
命名函数声明
[javascript]
// 函数声明会被提升，所以可以提前调用
// 这里只是普通的函数调用,此时this指向Window对象,会为Window对象添加属性b
// result的值和类型依赖于Func()函数的返回值,没有return语句默认返回undefined
var result = Func(); //Window{…}
console.log(result); //undefined
console.log(typeof result); //undefined

// 函数声明
function Func(){
//局域临时变量，函数执行完即被丢弃，无论是作为普通函数还是构造器调用
var a = “a”;

// 无论是普通函数调用还是作为函数构造器
// this指向哪个对象，则为那个对象添加属性b,
// 如果作为构造器调用，this指向新创建的对象
this.b = “b”;

// 因为没有使用var声明c,所以c属于全局变量，无论什么时候函数被调用，都会为全局对象添加属性c
c=”c”;

console.log(this);
}

//用户自定义函数的构造器为Function(),所以Func函数的原型链(proto)指向Function.prototype
console.log(Func); //function Func(){//临时变量…}
console.log(typeof Func); //function
console.log(Func.proto); //function Empty(){}
console.log(Func.proto===Function.prototype); //true
console.log(Func.prototype); //Func{}
console.log(Func.prototype.constructor); //function Func(){//临时变量…}
console.log(Func.prototype.proto===Object.prototype); //true

// 当对函数施加new运算符时,函数才叫做构造器,new运算符的结果总是一个对象
// 函数自身返回对象的优先级高，new运算符新构造对象的优先级低。
// new运算符无论如何都会执行构造器函数,如果函数也返回一个对象的话,new运算符新构造的对象会被丢弃。
var obj = new Func(); //Func{b: “b”}
console.log(obj); // Func{b: “b”}
console.log(typeof obj); // object
console.log(obj.proto); // Func{}
console.log(obj.proto===Func.prototype); // true
console.log(obj.prototype); //undefined

// 这里只是为Func换了个别名func而已,func和Func都引用同一个命名函数对象Func()
// 二者是同一个东西，排名不分先后
var func = Func;
console.log(func); //function Func(){//临时变量…}
console.log(typeof func); //function
console.log(func.proto); //function Empty(){}
console.log(func.prototype); //Func{}
[/javascript]

匿名函数声明
匿名函数不立即执行是没有什么用处的，因为声明之后根本无法引用它，但仍然可以这样声明
[javascript]
//匿名函数
console.log(function(){var a=”a”;this.b=”b”;console.log(this);}) //function (){var a=”a”…}
//直接执行,第一次是console.log(this)输出,为Window{…}
// 第二次输出为函数返回值输出undefined
console.log((function(){var a=”a”;this.b=”b”;console.log(this);})()) //Window{…}; undefined
//当作函数构造器执行,第一次是构造函数输出，console.log(this)
//第二次是返回的新对象的输出,都是Onject{b: “b”}
console.log(new function(){var a=”a”;this.b=”b”;console.log(this);}) //Object{b: “b”}; Object{b: “b”}
console.log(function(){var a=”a”;this.b=”b”;console.log(this);}.proto) //function Empty(){}
// 匿名函数的匿名原型对象
console.log(function(){var a=”a”;this.b=”b”;console.log(this);}.prototype) //Object{}
console.log(function(){var a=”a”;this.b=”b”;console.log(this);}.prototype==Object.prototype) //false
console.log(function(){var a=”a”;this.b=”b”;console.log(this);}.prototype.proto===Object.prototype) //true
[/javascript]
函数表达式

命名函数表达式

[javascript]
// 函数表达式中的Func名字只在函数内部可见，不会进入外部名字空间
//var result1 = Func(); //Func is not defined

// 函数表达式不会被提升，所以不能提前调用
//var result2 = func(); //func is not a function
console.log(func); //undefined

// 函数表达式,func和Func都指向同一个命名函数对象Func()
// 二者是同一个东西，但是Func名字只在函数内部可见
var func = function Func(){
//临时变量，函数执行完即被丢弃，无论是作为普通函数还是构造器调用
var a = “a”;

// 无论是普通函数调用还是作为函数构造器
// this指向哪个对象，则为那个对象添加属性b,
this.b = “b”;
console.log(this);
}

// 函数表达式不会被提升，所以只能在函数定义之后调用
// 普通函数调用,this指向Window对象
var result3 = func(); //Window{…}

//用户自定义函数的构造器为Function(),所以func函数的原型链(proto)指向Function.prototype
console.log(func); //function Func(){//临时变量…}
console.log(typeof func); //function
console.log(func.proto); //function Empty(){}
console.log(func.proto===Function.prototype); //true
console.log(func.prototype); //Func{}
console.log(func.prototype.proto===Object.prototype); //true

// 当对函数施加new运算符时,函数才叫做构造器,new运算符的结果总是一个对象
// 函数自身返回对象的优先级高，new运算符新构造对象的优先级低。
// new运算符无论如何都会执行构造器函数,如果函数也返回一个对象的话,new运算符新构造的对象会被丢弃。
var obj = new func(); //Func{b: “b”}
console.log(obj); // Func{b: “b”}
console.log(typeof obj); // object
console.log(obj.proto); // Func{}
console.log(obj.proto===func.prototype); // true
console.log(obj.prototype); //undefined
[/javascript]

匿名函数表达式

匿名函数表达式和命名函数表达式的唯一区别是，其prototype属性对象是个匿名对象，而命名函数表达式的prototype属性对象为一个具名对象，比如上个例子中的Func()

[javascript]
// 函数表达式不会被提升，所以不能提前调用
//var result2 = func(); //func is not a function
console.log(func); //undefined

// 函数表达式,引擎为其分配了一个不具名的对象作为其原型对象(prototype属性指向的对象)
// 其本质上与上个示例中的具名对象Func()是一样的,原型链的上层都是Object
// func指向一个匿名函数对象function(){//临时变量…}
var func = function(){
//临时变量，函数执行完即被丢弃，无论是作为普通函数还是构造器调用
var a = “a”;

// 无论是普通函数调用还是作为函数构造器
// this指向哪个对象，则为那个对象添加属性b,
this.b = “b”;
console.log(this);
}

// 函数表达式不会被提升，所以只能在函数定义之后调用
// 普通函数调用,this指向Window对象
var result3 = func(); //Window{…}

//用户自定义函数的构造器为Function(),所以func函数的原型链(proto)指向Function.prototype
console.log(func); //function(){//临时变量…}
console.log(typeof func); //function
console.log(func.proto); //function Empty(){}
console.log(func.proto===Function.prototype); //true
//func.prototype是一个不具名的对象,其与上个例子中的具名对象Func()是一样的东西
//其原型链的上一个对象都是Object.prototype
console.log(func.prototype.constructor); // function(){//临时变量…}
console.log(func.prototype); // Object{}
console.log(Object.prototype); // Object{}
//不要被输出迷惑了,这个不具名对象与Object.prototype是不同的对象
console.log(func.prototype==Object.prototype); // false
//这个不具名对象原型自Object
console.log(func.prototype.proto===Object.prototype); // true

// 当对函数施加new运算符时,函数才叫做构造器,new运算符的结果总是一个对象
// 函数自身返回对象的优先级高，new运算符新构造对象的优先级低。
// new运算符无论如何都会执行构造器函数,如果函数也返回一个对象的话,new运算符新构造的对象会被丢弃。
var obj = new func(); //func{b: “b”}
console.log(obj); // func{b: “b”}
console.log(typeof obj); // object
console.log(obj.proto); // Object{}
console.log(obj.proto===func.prototype); // true
console.log(obj.prototype); //undefined
[/javascript]

函数构造器

当对函数施加new运算符时，函数才叫做构造器(constrcutor)，否则就是普通的函数调用。普通的函数调用中，函数返回的对象直接返回给调用者。

但是当使用new操作符作为构造器调用时，new操作符会构造一个函数构造器(constrcutor)原型对象(constructor.prototype)类型的空对象(是object，不是function)，新对象的__proto__属性指向函数构造器的原型(constructor.prototype),从而新对象从函数构造器原型(constructor.prototype)继承属性。
新对象的constructor属性值被赋予原型对象的constructor值(prototype.constructor)，也就是函数构造器(constrcutor)自身。new运算符使用新对象作为this调用函数构造器(constrcutor)。

返不返回新对象还要视函数的返回值而定。如果函数自身使用return语句明确的返回一个object或function,则直接返回函数的返回值，新
创建的对象被丢弃。否则会返回新创建的对象。

无论返不返回新创建的对象函数构造器(constrcutor)都会被调用。无论如何构造器(使用new操作符)都会返回一个对象，而不是基本类型。

new操作符创建的新对象只可能是object，不会是其他类型，不会是function。

new操作符新创建的对象未添加其他属性之前，所有的本地属性都来自于构造函数中使用this添加的属性。

不同的函数构造器(constrcutor)创建不同的对象。

到底new运算符做了什么事情，参见MDN文章new。

===
[erq]

undefiend

javascript定义了一个全局变量undefined，它的值是undefined，它的值的类型也是undefined。 但是这个undefined全局变量不是一个常量，也不是一个关键字，而且可以被用户定义的名字覆盖。
[javascript]
console.log(undefined); //undefined
console.log(typeof undefined); //undefined
var undefined=”test”;
console.log(undefined); //test
console.log(typeof undefined); //string
[/javascript]
为了防止undefined全局变量被无意覆盖，一个常用的技巧是使用一个传递到函数的额外形式参数。 在调用时故意不为其提供实际参数,从而这个参数不会获取任何值,成为undefined。比如jquery就是这样玩的：

[javascript]
(function( window, undefined ) {
…
})( window );
[/javascript]
这样，在匿名函数内部，可以保证undefined就是undefined不是任何其他值。
其实质是定义了一个匿名函数局部作用域变量undefined,其值为undefined。

null

null不是变量，是一个预定义的对象，其值为null

[javascript]
console.log(null); //null
console.log(typeof null); //object
console.log(null == undefined) //true
console.log(null === undefined) //false

console.log(null.toString()); //Uncaught TypeError: Cannot call method ‘toString’ of null
var null=”test” //Uncaught SyntaxError: Unexpected token null
[/javascript]

不能重定义null的名字，null虽然被认为是对象，但其没有任何方法。null对象可以作为原型继承链的终点。

null与undefiend的值相等，但二者的类型不同。
===
[erq]

JavaScript 中局部变量只可能通过两种方式声明，一个是作为函数参数，另一个是通过 var 关键字声明。

python特别是3真是个好东西。

发自 WordPress for Android

platform模块提供了底层系统平台的相关信息

系统架构

32位还是64位
[python]

import platform
platform.architecture()
(‘64bit’, ‘ELF’) # python 3.3.2+ 64 bits on debian jessie 64 bits
(‘32bit’, ‘WindowsPE’) # python 3.3.2 32 bits on windows 8.1 64 bits
(‘64bit’, ‘WindowsPE’) # python 3.3.2 64 bits on wndows 8.1 64 bits
(‘64bit’, ‘’) # python 3.4.1 64 bits on mac os x 10.9.4
[/python]
ELF和WindowsPE是可执行文件格式

操作系统
linux,mac还是windows
[python]

platform.system()
‘Linux’ # python 3.3.2+ 64 bits on debian jessie 64 bits
‘Windows’ # python 3.3.2 32 bits on windows 8.1 64 bits
‘Windows’ # python 3.3.2 64 bits on windows 8.1 64 bits
‘Darwin’ # python 3.4.1 64 bits on mac os x 10.9.4
[/python]

系统版本
[python]

platform.version()
‘#1 SMP Debian 3.10.11-1 (2013-09-10)’ # python 3.3.2+ 64 bits on debian jessie 64 bits
‘6.2.9200’ # python 3.3.2 32 bits on windows 8.1 64 bits
‘6.2.9200’ # python 3.3.2 64 bits on windows 8.1 64 bits
‘Darwin Kernel Version 13.3.0: Tue Jun 3 21:27:35 PDT 2014; root:xnu-2422.110.17~1/RELEASE_X86_64’ # python 3.4.1 64 bits on mac os x 10.9.4
[/python]

CPU平台
[python]

platform.machine()
‘x86_64’ # python 3.3.2+ 64 bits on debian jessie 64 bits
‘AMD64’ # python 3.3.2 32 bits on windows 8.1 64 bits
‘AMD64’ # python 3.3.2 64 bits on windows 8.1 64 bits
‘x86_64’ # python 3.4.1 64 bits on mac os x 10.9.4
[/python]

linux发行版
[python]

platform.dist()
(‘debian’, ‘jessie/sid’, ‘’) # python 3.3.2+ 64 bits on debian jessie 64 bits
[/python]

节点名
也就是机器名
[python]

platform.node()
‘work’ # python 3.3.2+ 64 bits on debian jessie 64 bits
‘work-xxx’ # python 3.3.2 32 bits on windows 8.1 64 bits
[/python]

系统信息
[python]

platform.uname()
uname_result(system=’Linux’, node=’work’, release=’3.10-3-amd64’, version=’#1 SMP Debian 3.10.11-1 (2013-09-10)’, machine=’x86_64’, processor=’’) # python 3.3.2+ 64 bits on debian jessie 64 bits

uname_result(system=’Windows’, node=’work-xxx’, release=’8’, version=’6.2.9200’, machine=’AMD64’, processor=’Intel64 Family 6 Model 58 Stepping 9,
GenuineIntel’) # python 3.3.2 32 bits on windows 8.1 64 bits

uname_result(system=’Darwin’, node=’mba’, release=’13.3.0’, version=’Darwin Kernel Version 13.3.0: Tue Jun 3 21:27:35 PDT 2014; root:xnu-2422.110.17~1/RELEASE_X86_64’, machine=’x86_64’, processor=’i386’) # python 3.4.1 64 bits on mac os x 10.9.4
[/python]

python版本
[python]

platform.python_verison()
‘3.3.2+’ # python 3.3.2+ 64 bits on debian jessie 64 bits
‘3.3.3’ # python 3.3.2 32 bits on windows 8.1 64 bits
[/python]

===
[erq]

RT