设置背景透明度：
1.
WindowManager.LayoutParams lp = myDialog.getWindow().getAttributes();
lp.dimAmount = 0.7f
2. <style name="NoTitleDialog" parent="@android:style/Theme.Dialog">
<item name="android:windowNoTitle">true</item>
<item name="android:windowBackground">@drawable/white_corner</item>
<item name="android:backgroundDimEnabled">true</item>
<item name="android:backgroundDimAmount">0.9</item>
</style>

1.安装apk程序

Intent intent=new Intent();
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.setAction(Intent.ACTION_VIEW);
intent.setDataAndType(Uri.fromFile(new File(”此处写apk路径”),"application/vnd.android.package-archive");
context.startActivity(intent);

2.卸载程序

Intent intent=new Intent(Intent.ACTION_DELETE,Uri.parse("package:"+此处为要卸载的程序的包名));
context.startActivity(intent);

PackageManager pm=getPackageManager();

Intent intent=new Intent();

intent=pm.getLaunchIntentForPackage("此处写要打开的程序的包名");
startActivity(intent);

IntentService
@Override
public void onStart(Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);
}

startService(intent) 后执行onStart,通过mServiceHandler向HandlerThread的MessageQueue发送一条消息。然后HandlerThread中获取到后调用mServiceHandler.的handlerMessage进行处理，执行onHandleIntent,然后执行stopSelf(msg.arg1)，stopSelf通过msg.arg1判断是否需要结束service

package com.asfman.test;

import android.app.IntentService;
import android.content.Intent;
import android.util.Log;

public class TestService extends IntentService {
private boolean isRunning;
public TestService() {
super("TestService");
Log.i("info", "TestService");
}

@Override
protected void onHandleIntent(Intent intent) {
Log.i("info", "onHandleIntent");
// TODO Auto-generated method stub
for (long i = 0; i <= 5; i++) {
Log.i("info", " " + i);
try {
Thread.sleep(700);
} catch (InterruptedException e) {
}
}
if(isRunning) isRunning = false;
// stopSelf(-1);
startService(intent);
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.i("info", "onStartCommand:" + startId);
Log.i("info", "isRunning:" + isRunning);
if(isRunning) {
return -1;
} else {
isRunning = true;
}

return super.onStartCommand(intent, flags, startId);
}

@Override
public void onDestroy() {
Log.i("info", "onDestroy");
super.onDestroy();
isRunning = false;
}

@Override
public void onCreate() {
Log.i("info", "onCreate");
super.onCreate();
}

}

may be"先打开终端命令如下：

sodu /etc/init.d/apparmor

sudo ifconfig eth0 down

sudo ifconfig eth0 up

这样有线网终于能上去了，在新立得里apparmor,安装最新版本2.3.1,

sudo gedit /etc/NetManager/nm-system-settings.conf

在弹出的窗口中把＝fales更改成=true，这里要提示一下，安装apparmor时千万要勾选apparmor.docs,不然，哼哼，不相信的自己试试。

还没完，不信你拔了网线，还不能无线上网。

这时我怎么想也想不通了，允许无线上网前面那个勾也勾上了，无线网络列表里也有无线信号，但就是连不上不去，怎么回事？

我点网络标识，在下拉单里－VPN连接－配置VPN，对比了无线和有线的设置，终于在IPv6设置里找到不同之处，有线网我在“方法”选项里选忽略，无线我却选“自动”，把自动改成忽略，拔掉网线，无线网标识转了两转，终于连上了。"

执行顺序
root@asfman:/home/asfman/workspace# adb logcat -s info:d
I/info (16212): Application start
I/info (16212): First Activity =======onCreate()========
I/info (16212): First Activity =======onStart()========
I/info (16212): First Activity =======onResume()========

second activity start
I/info (16212): First Activity =======onPause()========
I/info (16212): Second Activity =======onCreate()========
I/info (16212): Second Activity =======onStart()========
I/info (16212): Second Activity =======onResume()========
I/info (16212): First Activity =======onStop()========

click back button:
I/info (16212): Second Activity =======onPause()========
I/info (16212): First Activity =======onRestart()========
I/info (16212): First Activity =======onStart()========
I/info (16212): First Activity =======onResume()========
I/info (16212): Second Activity =======onStop()========
I/info (16212): Second Activity =======onDestroy()========

package com.asfman;

import android.app.Application;
import android.util.Log;

public class Application_Entry extends Application {

@Override
public void onCreate() {
// TODO Auto-generated method stub
super.onCreate();
Log.i("info", "Application start");
}

@Override
public void onTerminate() {
// TODO Auto-generated method stub
super.onTerminate();
Log.i("info", "Application terminate");
}

}

I/info ( 378): Application start

I/info ( 324): First Activity =======onCreate()========
I/info ( 324): First Activity =======onStart()========
I/info ( 324): First Activity =======onResume()========
I/ActivityManager( 60): Starting activity: Intent { cmp=com.asfman/.Second }
I/info ( 324): First Activity =======onPause()========
I/info ( 324): Second Activity =======onCreate()========
I/info ( 324): Second Activity =======onStart()========
I/info ( 324): Second Activity =======onResume()========
I/ActivityManager( 60): Displayed activity com.asfman/.Second: 394 ms (total 394 ms)
I/info ( 324): First Activity =======onStop()========

rimpath JavaScript 是不个轻量级的，基于JavaScript的，跨浏览器，采用APL/GPL开放源代码协议的，可以让你轻松进行基于模板编程方式的纯JS引擎。

它有如下的特点：
1、采用标准的JavaScript编写，支持跨浏览器
2、模板语法类似于：FreeMarker，Velocity,Smarty
3、采用简易的语言来描述大段的字串以及Dom/DHTML操作
4、可以很方便的解析XML文件格式的数据到指定模板。

采 用该引擎，可以让它来完全处理View方面的事情，服务端Module直接输出Data就可以。让你的MVC模式连成一体，而且由于View由浏览器来处 理，大大减少了服务器的负担，用来构建Ajax技术的网络信息系统应用是一个非常好的选择。下面将通过翻译该站的文章来给大家介绍这个JST引擎的使用。

网站地址：

http://trimpath.com/project/wiki/JavaScriptTemplates

如果大家等不及看我翻译或者不满意翻译质量，请看上面网站的原文。

hred 2005-11-21 17:18
JST十分钟简介

JST API
JST Markup Syntax
JST Standard Modifiers
JST Downloads
JST Community Wiki
JST Browser Compatibility
JST Online Demo

1、API
首先到下载页面下载 template.js
然后在你的JSP/ASP/PHP等文件中引用
CODE:


[Copy to clipboard]

当你引用了template.js文件之后，脚本将创建一个名叫“trimpath”的物件给你使用。

TrimPath Object
这个物件是一个全局的单一变量，也是所有trimpath组件的访问入口，除了它自身，我们尝试建立一个清晰的命名空间给您使用。

下面是 Trimpath 定义的方法：

TrimPath.parseDOMTemplate ( elementId, optionalDocument )

得到页面中ID为elementId的Dom组件的InnerHTML，并将其解析成一个模板，这个方法返回一个templateObject对象（下面将详细描述），解析出错时将抛出一个异常，下面是这个方法的参数：
elementId DOM组件，其innerhtml将用来做模板
optionalDocument 一个可选参数，在使用iframe，frameset或者默认多文档时会有用
通常用来做模板的DOM元素是一个隐藏的
[Copy to clipboard]

TrimPath.processDOMTemplate ( elementId, contextObject, optionalFlags, optionalDocument )
一 个辅助函数，里面调用了TrimPath.parseDOMTemplate() 和 then the process() 方法以获得templateObject。输出的是templateObject.process() 中返回的对象。解析出错时将抛出一个错误。下面是这个方法的参数：

elementId 包含模板内容的DOM元素ID
contextObject 参考templateObject.process()
optionalFlags 参考templateObject.process()
optionalDocument 参考TrimPath.parseDOMTemplate

TrimPath.parseTemplate ( templateContentStr, optionalTemplateName )
解析模板方法，将一个字符串做为模板解析并返回一个templateObject
参数表：

templateContentStr 符合JST语法的字符串，例如: “Hello ${firstName} ${lastName}”
optionalTemplateName 一个可选的字符串用来指定模板名称，辅助查错。

The templateObject
TrimPath.parseTemplate() 和 TrimPath.parseDOMTemplate()的成功运行将产生一个 templateObject 它只有一个主方法

templateObject.process ( contextObject, optionalFlags )

这个方法将模板和数据结合在一起，可以重复调用，如果没有重新解析，templateObjects的缓存和重用将获得最好的系统性能。这个函数的返回值是一个经过“渲染”过的模板的字符串。

参数contextObject 必须是一个对象，并将成为模板的一个访问域，比如一个模板是：${a}，那么contextObject.a必须是可以访问到的。同样${a.b.c}, contextObject.a.b.c也是可以访问到的。
注 意：contextObject 可以是javascript中的任意对象，包含字符串, 数字, 日期, 对象和函数。所以${groupCalender(new Date())} 可以这样来调用contextObject.groupCalender(new Date())。当然，你必须自己编程实现groupCalender() 这个函数。

参数optionalFlags 可以是空值，也可以是一个下面列表描述的对象：
throwExceptions 默认是false,当true的时候，process() 方法将重新抛出异常，当false的时候，任何异常将停止解析模板，并在方法返回值包含一个出错信息。
keepWhitespace 默认是falsel，当值为true时，模板的空白将保留。当为false时，空白（换行、空格、TAB）将被截取。

String.prototype.process() 方法

String.prototype.process ( contextObject, optionalFlags )
做为一个便捷的方式为string对象加入一个process（）的方法，让它来执行解析模板的动作。参数跟process()一样。

CODE:

var result = “hello ${firstName}”.process(data)
// …is equivalent to…
var result = TrimPath.parseTemplate(“hello ${firstName}”).process(data);
[Copy to clipboard]

添加自定义标识符

如果要采用自定义标识符，你必须把他们放在_MODIFERS 这个对象中，这些标识符集将被添加到contextObject 对象中，然后最终传给process()解析。每一个自定义标识符必须是一个函数并且至少有一个字符串参数输入和一个字符串输出。
例子：
CODE:

var myModifiers = {
hello : function(str, greeting) {
if (greeting == null)
greeting = “Hello”;
return greeting + “, ” + str;
},
zeroSuffix : function(str, totalLength) {
return (str + “000000000000000″).substring(0, totalLength);
}
};
var myData = {
firstName : “John”,
getCurrentPoints : function() { /* Do something here… */ return 12; }
}

myData._MODIFIERS = myModifiers;

“${firstName}”.process(myData) == “John”
“${firstName|hello}”.process(myData) == “Hello, John”
“${firstName|hello:”Buenos Dias”}”.process(myData) == “Buenos Dias, John”
“${firstName|hello:”Buenos Dias”|capitalize}”.process(myData) == “BUENOS DIAS, JOHN”

“${getCurrentPoints()}”.process(myData) == “12″
“${getCurrentPoints()|zeroSuffix:4}”.process(myData) == “1200″
[Copy to clipboard]

顺其自然 2005-11-22 12:11
东东不错，可惜没时间研究

hred 2005-12-01 16:02
JST 的语法和语句

语法

${expr}
${expr|modifier}
${expr|modifier1|modifier2|…|modifierN}
${expr|modifier1:argExpr1_1}
${expr|modifier1:argExpr1_1,argExpr1_2,…,argExpr1_N}
${expr|modifier1:argExpr1_1,argExpr1_2|…|modifierN:argExprN_1,argExprN_2,…,argExprN_M}

表达式可以是除了“}”之外的任何合法的javascript字符串
标识符看起来像这种结构：modifierName[:argExpr1[,argExpr2[,argExprN]]]

一个带参数的表达式例子
${customer.firstName}
${customer.firstName|capitalize}
${customer.firstName|default:”no name”|capitalize}
${article.getCreationDate()|default:new Date()|toCalenderControl:”YYYY.MM.DD”,true,”Creation Date”}
${(lastQuarter.calcRevenue() – fixedCosts) / 1000000}

一个表达式也可以像下面一样通过添加“％”字符来标识，这个可以避免在你的表达式中出现“}”时出错的情况。

比如：
Visit our ${% emitLink(‘Solutions and Products’,
{ color: ‘red’, blink: false }) %} page.

The extra spaces are actually not ne
cessary, like…
${%customer.firstName%}
${%customer.firstName|capitalize%}

语句
JST语句就像是javascript语句一样，也有if/else/for/function这些句子

分支控制语句

{if testExpr}
{elseif testExpr}
{else}
{/if}

上述testExpr 是一个合法的javascript判定式

例子

{if customer != null && customer.balance > 1000}
We love you!
{/if}

{if user.karma > 100}
Welcome to the Black Sun.
{elseif user.isHero}
Sir, yes sir! Welcome!
{if user.lastName == “Yen”}
Fancy some apple pie, sir?
{/if}
{/if}

Login

*JST引擎还包含一个辅助函数defined(str)，这个可以测试一个变量是否已经被定义。

比如这段代码判断管理员发送了消息给你

{if defined(‘adminMessage’)}
System Administrator Important NOTICE: ${adminMessage}
{/if}

循环语句

{for varName in listExpr}
{/for}

{for varName in listExpr}
…main body of the loop…
{forelse}
…body when listExpr is null or listExpr.length is 0…
{/for}

*varName 必须是一个javascript的合法变量名
*listExpr 可以是一个数组，对象或者为空，而且只能被赋值一次
例子

Two variables are bound in the main body of the loop:
__LIST__varName – holds the result of evaluating listExpr.
varName_index – this is the key or counter used during iteration.

Examples:
{for x in customer.getRecentOrders()}
${x_index} : ${x.orderNumber}

{forelse}
You have no recent orders.
{/for}

Converted pseudo-code for the above…
var __LIST__x = customer.getRecentOrders();
if (__LIST__x != null && __LIST__x.length > 0) {
for (var x_index in __LIST__x) {
var x = __LIST__x[x_index];
${x_index} : {$x.orderNumber}

}
} else {
You have no recent orders.
}

定义变量

{var varName}
{var varName = varInitExpr}
*varName必须是一个合法的javascript变量名
*varInitExpr必须是一个没有包含”}”的字符串

例子：

{var temp = crypto.generateRandomPrime(4096)}
Your prime is ${temp}.

宏定义
{macro macroName(arg1, arg2, …argN)}
…body of the macro…
{/macro}

*宏类似于一个javascript函数，不同点在于宏的主体是另外一个包含了诸如控制语句、循环语句的JST模板

*宏的名称必须是一个合法javascript变量名
*宏的返回值是一个字符创
*使用宏可以采用这种语法 ：${macroName()}
一个使用宏的例子

{macro htmlList(list, optionalListType)}
{var listType = optionalListType != null ? optionalListType : “ul”}
<${listType}>
{for item in list}
${item}
{/for}

{/macro}

Using the macro…
${htmlList([ 1, 2, 3])}
${htmlList([ "Purple State", "Blue State", "Red State" ], “ol”)}
{var saved = htmlList([ 100, 200, 300 ])}
${saved} and ${saved}

运行上述语句将出现
*1
*2
*3
这样的列表。只需将数据列表赋值给htmlList这个宏，就会帮你把数据通过

方式列出来，聪明的你很快就会把它改成 等应用了。
从宏的访问域来说，默认情况下它是每个模板私有的，但是如果你想定义一个宏库的话，那么也许你需要在process()之前先定义可以导出宏：contextObject['exported'] ={};
下面是例子：
{macro userName(user)}
{if user.aliasName != null && user.aliasName.length > 0}
${user.aliasName}
{else}
${user.login}
{/if}
{/macro}
${exported.userName = userName |eat}
另外，你也可以设置 contextObject['exported'] = contextObject;它也可以正常的工作。



CDATA 文本区段

{cdata}
…text emitted without JST processing…
{/cdata}

{cdata EOF}
…text emitted without JST processing…
EOF

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>Vertical Middle</title>
<style>
.itm{border:2px solid #ccc;width:160px;height:160px;text-align:center;}
.blank{width:0;height:160px;}
.itm img{vertical-align:middle;}
</style>
</head>

<body>
<div class="itm">
<img src="http://cn.yimg.com/i/comn/blank.gif" class="blank" />
<a href=""><img src="http://cn.yimg.com/bookmark/yisou/mp3/m060616.jpg"/></a>
</div>
</body>
</html>
http://listenpro.googlepages.com/demo_vertical_css.html

类 {
width: 100%; height: 100%; background: url(PNG地址) no-repeat left top; {你的其他代码}
_filter: progid:DXImageTransform.Microsoft.AlphaImageLoader(enabled=true, sizingMethod=scale, src="PNG地址");
_background: none;
}

NetUtil，不在html中嵌入js，而在swf中直接调用简单js语句的相关实用方法。
在ie7、firefox3中测试通过。

注：使用时请确保在ie中用object标签嵌入swf并赋予唯一id属性，而firefox中只需用embed标签嵌入该swf即可

另：getSwfUrl代码未实现，请各位高手给出相关实现建议

NetUtil源码如下：


package cn.asarea.utils
{
/**
*Author: ATHER Shu 2008.9.26
* NetUtil类: 一些直接调用浏览器简单js的实用类
* 功能：
* 1.显示swf所在页面也就是浏览器地址栏地址 getPageUrl
* 2.显示swf所在地址(未实现，求高手指点) getSwfUrl
* 3.直接弹出浏览器提示 explorerAlert
* 4.获取swf所在页面的编码方式 getpageEncoding
* 5.获取浏览器类型 getBrowserType
* 6.直接运行js代码 eval
* http://www.asarea.cn
* ATHER Shu(AS)
*/
import flash.external.ExternalInterface;
import flash.net.URLRequest;
import flash.net.navigateToURL;

public class NetUtil
{
//获取当前页面url
public static function getPageUrl():String
{
//在ie中如果没有用object classid或者没有赋id属性，而直接用embed，该方法会失效！
var pageurl:String = ExternalInterface.call("eval", "window.location.href");
if(pageurl == null)
pageurl = "none";//"not in a page or js called fail";
return pageurl;
}
//获取swf文件所在url
public static function getSwfUrl():String
{
//要用displayobject的loaderinfo而无法全局访问！
return "get it later";
}
//通过js弹出浏览器提示alert
public static function explorerAlert(msg:String):void
{
navigateToURL(new URLRequest("javascript:alert('"+msg+"')"), "_self");
}
//获取swf所在页面编码方式
public static function getpageEncoding():String
{
//IE下用:document.charset
//Firefox下用:document.characterSet
var pageencoding:String = ExternalInterface.call("eval", "document.charset");
if(pageencoding == null)
pageencoding = ExternalInterface.call("eval", "document.characterSet");
//
if(pageencoding == null)
pageencoding = "NONE";//can't get the page encoding
return pageencoding.toUpperCase();
}
//获取浏览器类型
public static function getBrowserType():String
{
//var browsertype:String = ExternalInterface.call("eval", "navigator.appName");
var browsertype:String = ExternalInterface.call("eval", "navigator.userAgent");
return (browsertype ? browsertype:"NONE");
}
//直接运行js语句，eval
public static function eval(code:String):Object
{
var rtn:Object = ExternalInterface.call("eval", code);
return rtn;
}
}
}


使用代码：


import cn.asarea.utils.NetUtil;
btna.addEventListener(MouseEvent.CLICK, onclick);
btnb.addEventListener(MouseEvent.CLICK, onclick);
btnc.addEventListener(MouseEvent.CLICK, onclick);
btnd.addEventListener(MouseEvent.CLICK, onclick);
function onclick(evt:MouseEvent):void
{
if (evt.target == btna)
NetUtil.explorerAlert("欢迎访问www.asarea.cn");
else if (evt.target == btnb)
NetUtil.explorerAlert(NetUtil.getPageUrl());
else if (evt.target == btnc)
NetUtil.explorerAlert(NetUtil.getpageEncoding());
else
NetUtil.explorerAlert(NetUtil.getBrowserType());
}

<input type="button" onclick="addText('---')" value="click" />
<textarea id="t" rows="5" cols="15">testtest</textarea>
<script type="text/javascript">
<!--
function addText(txt) {
obj = document.getElementById("t");
selection = document.selection;
obj.focus();
if (typeof obj.selectionStart != "undefined") {
var s = obj.selectionStart;
obj.value = obj.value.substr(0, obj.selectionStart) + txt + obj.value.substr(obj.selectionEnd);
obj.selectionEnd = s + txt.length;
} else if (selection && selection.createRange) {
var sel = selection.createRange();
sel.text = txt;
} else {
obj.value += txt;
}
}

//-->
</script>

function test(){
var selection;
if (window.getSelection) {
selection = ''+window.getSelection();
} else if (document.selection) {
selection = document.selection.createRange().text;
}
return(selection);
}

slide Toggle
function Observer(doJob, bindType){
this.eventType = bindType || "click";
this.doJob = doJob;
this.list = [];
}
Observer.prototype = {
bind: function(obj){
var o = this;
$(obj)[this.eventType](function(){
o.carry(this);
return false;
});
},
carry: function(obj){
if(obj == this.list[0]) return;
this.list.unshift(obj);
this.doJob && this.doJob();
if(this.length > 2) this.length = 2;
}
}
void function initSlide(){
var o = new Observer(function(){
var cur = this.list[0], old = this.list[1];
cur && $(cur).next().slideToggle();
old && $(old).next().slideToggle();
});
$("a").each(function(i){
o.bind(this);
});
o.list[0] = $("a")[0];
o.doJob();
}();

《悟透JavaScript》之 甘露模型一
引子


编程世界里只存在两种基本元素，一个是数据，一个是代码。编程世界就是在数据和代码千丝万缕的纠缠中呈现出无限的生机和活力。

数据天生就是文静的，总想保持自己固有的本色；而代码却天生活泼，总想改变这个世界。

你看，数据代码间的关系与物质能量间的关系有着惊人的相似。数据也是有惯性的，如果没有代码来施加外力，她总保持自己原来的状态。而代码就象能量，他存在的唯一目的，就是要努力改变数据原来的状态。在代码改变数据的同时，也会因为数据的抗拒而反过来影响或改变代码原有的趋势。甚至在某些情况下，数据可以转变为代码，而代码却又有可能被转变为数据，或许还存在一个类似E=MC2形式的数码转换方程呢。然而，就是在数据和代码间这种即矛盾又统一的运转中，总能体现出计算机世界的规律，这些规律正是我们编写的程序逻辑。

不过，由于不同程序员有着不同的世界观，这些数据和代码看起来也就不尽相同。于是，不同世界观的程序员们运用各自的方法论，推动着编程世界的进化和发展。

众所周知，当今最流行的编程思想莫过于面向对象编程的思想。为什么面向对象的思想能迅速风靡编程世界呢？因为面向对象的思想首次把数据和代码结合成统一体，并以一个简单的对象概念呈现给编程者。这一下子就将原来那些杂乱的算法与子程序，以及纠缠不清的复杂数据结构，划分成清晰而有序的对象结构，从而理清了数据与代码在我们心中那团乱麻般的结。我们又可以有一个更清晰的思维，在另一个思想高度上去探索更加浩瀚的编程世界了。

在五祖弘忍讲授完《对象真经》之后的一天，他对众弟子们说：“经已讲完，想必尔等应该有所感悟，请各自写个偈子来看”。大弟子神秀是被大家公认为悟性最高的师兄，他的偈子写道：“身是对象树，心如类般明。朝朝勤拂拭，莫让惹尘埃！”。此偈一出，立即引起师兄弟们的轰动，大家都说写得太好了。只有火头僧慧能看后，轻轻地叹了口气，又随手在墙上写道：“对象本无根，类型亦无形。本来无一物，何处惹尘埃？”。然后摇了摇头，扬长而去。大家看了慧能的偈子都说：“写的什么乱七八糟的啊，看不懂”。师父弘忍看了神秀的诗偈也点头称赞，再看慧能的诗偈之后默然摇头。就在当天夜里，弘忍却悄悄把慧能叫到自己的禅房，将珍藏多年的软件真经传授于他，然后让他趁着月色连夜逃走...

后来，慧能果然不负师父厚望，在南方开创了禅宗另一个广阔的天空。而慧能当年带走的软件真经中就有一本是《JavaScript真经》！

回归简单

要理解JavaScript，你得首先放下对象和类的概念，回到数据和代码的本原。前面说过，编程世界只有数据和代码两种基本元素，而这两种元素又有着纠缠不清的关系。JavaScript就是把数据和代码都简化到最原始的程度。

JavaScript中的数据很简洁的。简单数据只有 undefined, null, boolean, number和string这五种，而复杂数据只有一种，即object。这就好比中国古典的朴素唯物思想，把世界最基本的元素归为金木水火土，其他复杂的物质都是由这五种基本元素组成。

JavaScript中的代码只体现为一种形式，就是function。

注意：以上单词都是小写的，不要和Number, String, Object, Function等JavaScript内置函数混淆了。要知道，JavaScript语言是区分大小写的呀!

任何一个JavaScript的标识、常量、变量和参数都只是unfined, null, bool, number, string, object 和 function类型中的一种，也就typeof返回值表明的类型。除此之外没有其他类型了。

先说说简单数据类型吧。

undefined: 代表一切未知的事物，啥都没有，无法想象，代码也就更无法去处理了。
注意：typeof(undefined) 返回也是 undefined。
可以将undefined赋值给任何变量或属性，但并不意味了清除了该变量，反而会因此多了一个属性。

null: 有那么一个概念，但没有东西。无中似有，有中还无。虽难以想象，但已经可以用代码来处理了。
注意：typeof(null)返回object，但null并非object，具有null值的变量也并非object。

boolean: 是就是，非就非，没有疑义。对就对，错就错，绝对明确。既能被代码处理，也可以控制代码的流程。

number: 线性的事物，大小和次序分明，多而不乱。便于代码进行批量处理，也控制代码的迭代和循环等。
注意：typeof(NaN)和typeof(Infinity)都返回number 。
NaN参与任何数值计算的结构都是NaN，而且 NaN != NaN 。
Infinity / Infinity = NaN 。

string: 面向人类的理性事物，而不是机器信号。人机信息沟通，代码据此理解人的意图等等，都靠它了。

简单类型都不是对象，JavaScript没有将对象化的能力赋予这些简单类型。直接被赋予简单类型常量值的标识符、变量和参数都不是一个对象。

所谓“对象化”，就是可以将数据和代码组织成复杂结构的能力。JavaScript中只有object类型和function类型提供了对象化的能力。

没有类

object就是对象的类型。在JavaScript中不管多么复杂的数据和代码，都可以组织成object形式的对象。

但JavaScript却没有 “类”的概念！

对于许多面向对象的程序员来说，这恐怕是JavaScript中最难以理解的地方。是啊，几乎任何讲面向对象的书中，第一个要讲的就是“类”的概念，这可是面向对象的支柱。这突然没有了“类”，我们就象一下子没了精神支柱，感到六神无主。看来，要放下对象和类，达到“对象本无根，类型亦无形”的境界确实是件不容易的事情啊。

这样，我们先来看一段JavaScript程序：
var life = {};
for(life.age = 1; life.age <= 3; life.age++)
{
switch(life.age)
{
case 1: life.body = "卵细胞";
life.say = function(){alert(this.age+this.body)};
break;
case 2: life.tail = "尾巴";
life.gill = "腮";
life.body = "蝌蚪";
life.say = function(){alert(this.age+this.body+"-"+this.tail+","+this.gill)};
break;
case 3: delete life.tail;
delete life.gill;
life.legs = "四条腿";
life.lung = "肺";
life.body = "青蛙";
life.say = function(){alert(this.age+this.body+"-"+this.legs+","+this.lung)};
break;
};
life.say();
};
这段JavaScript程序一开始产生了一个生命对象life，life诞生时只是一个光溜溜的对象，没有任何属性和方法。在第一次生命过程中，它有了一个身体属性body，并有了一个say方法，看起来是一个“卵细胞”。在第二次生命过程中，它又长出了“尾巴”和“腮”，有了tail和gill属性，显然它是一个“蝌蚪”。在第三次生命过程中，它的tail和gill属性消失了，但又长出了“四条腿”和“肺”，有了legs和lung属性，从而最终变成了“青蛙”。如果，你的想像力丰富的话，或许还能让它变成英俊的“王子”，娶个美丽的“公主”什么的。不过，在看完这段程序之后，请你思考一个问题：

我们一定需要类吗？

还记得儿时那个“小蝌蚪找妈妈”的童话吗？也许就在昨天晚，你的孩子刚好是在这个美丽的童话中进入梦乡的吧。可爱的小蝌蚪也就是在其自身类型不断演化过程中，逐渐变成了和妈妈一样的“类”，从而找到了自己的妈妈。这个童话故事中蕴含的编程哲理就是：对象的“类”是从无到有，又不断演化，最终又消失于无形之中的...

“类”，的确可以帮助我们理解复杂的现实世界，这纷乱的现实世界也的确需要进行分类。但如果我们的思想被“类”束缚住了，“类”也就变成了“累”。想象一下，如果一个生命对象开始的时就被规定了固定的“类”，那么它还能演化吗？蝌蚪还能变成青蛙吗？还可以给孩子们讲小蝌蚪找妈妈的故事吗？

所以，JavaScript中没有“类”，类已化于无形，与对象融为一体。正是由于放下了“类”这个概念，JavaScript的对象才有了其他编程语言所没有的活力。

如果，此时你的内心深处开始有所感悟，那么你已经逐渐开始理解JavaScript的禅机了。

函数的魔力

接下来，我们再讨论一下JavaScript函数的魔力吧。

JavaScript的代码就只有function一种形式，function就是函数的类型。也许其他编程语言还有procedure或 method等代码概念，但在JavaScript里只有function一种形式。当我们写下一个函数的时候，只不过是建立了一个function类型的实体而已。请看下面的程序：
function myfunc()
{
alert("hello");
};

alert(typeof(myfunc));
这个代码运行之后可以看到typeof(myfunc)返回的是function。以上的函数写法我们称之为“定义式”的，如果我们将其改写成下面的“变量式”的，就更容易理解了：
var myfunc = function ()
{
alert("hello");
};

alert(typeof(myfunc));
这里明确定义了一个变量myfunc，它的初始值被赋予了一个function的实体。因此，typeof(myfunc)返回的也是function。其实，这两种函数的写法是等价的，除了一点细微差别，其内部实现完全相同。也就是说，我们写的这些JavaScript函数只是一个命了名的变量而已，其变量类型即为function，变量的值就是我们编写的函数代码体。

聪明的你或许立即会进一步的追问：既然函数只是变量，那么变量就可以被随意赋值并用到任意地方啰？

我们来看看下面的代码：
var myfunc = function ()
{
alert("hello");
};
myfunc(); //第一次调用myfunc，输出hello

myfunc = function ()
{
alert("yeah");
};
myfunc(); //第二次调用myfunc，将输出yeah
这个程序运行的结果告诉我们：答案是肯定的！在第一次调用函数之后，函数变量又被赋予了新的函数代码体，使得第二次调用该函数时，出现了不同的输出。

好了，我们又来把上面的代码改成第一种定义式的函数形式：
function myfunc ()
{
alert("hello");
};
myfunc(); //这里调用myfunc，输出yeah而不是hello

function myfunc ()
{
alert("yeah");
};
myfunc(); //这里调用myfunc，当然输出yeah
按理说，两个签名完全相同的函数，在其他编程语言中应该是非法的。但在JavaScript中，这没错。不过，程序运行之后却发现一个奇怪的现象：两次调用都只是最后那个函数里输出的值！显然第一个函数没有起到任何作用。这又是为什么呢？

原来，JavaScript执行引擎并非一行一行地分析和执行程序，而是一段一段地分析执行的。而且，在同一段程序的分析执行中，定义式的函数语句会被提取出来优先执行。函数定义执行完之后，才会按顺序执行其他语句代码。也就是说，在第一次调用myfunc之前，第一个函数语句定义的代码逻辑，已被第二个函数定义语句覆盖了。所以，两次都调用都是执行最后一个函数逻辑了。

如果把这个JavaScript代码分成两段，例如将它们写在一个html中，并用<script/>标签将其分成这样的两块：
<script>
function myfunc ()
{
alert("hello");
};
myfunc(); //这里调用myfunc，输出hello
</script>

<script>
function myfunc ()
{
alert("yeah");
};
myfunc(); //这里调用myfunc，输出yeah
</script>
这时，输出才是各自按顺序来的，也证明了JavaScript的确是一段段地执行的。

一段代码中的定义式函数语句会优先执行，这似乎有点象静态语言的编译概念。所以，这一特征也被有些人称为：JavaScript的“预编译”。

大多数情况下，我们也没有必要去纠缠这些细节问题。只要你记住一点：JavaScript里的代码也是一种数据，同样可以被任意赋值和修改的，而它的值就是代码的逻辑。只是，与一般数据不同的是，函数是可以被调用执行的。

不过，如果JavaScript函数仅仅只有这点道行的话，这与C++的函数指针，DELPHI的方法指针，C#的委托相比，又有啥稀奇嘛！然而，JavaScript函数的神奇之处还体现在另外两个方面：一是函数function类型本身也具有对象化的能力，二是函数function与对象 object超然的结合能力。

奇妙的对象

先来说说函数的对象化能力。

任何一个函数都可以为其动态地添加或去除属性，这些属性可以是简单类型，可以是对象，也可以是其他函数。也就是说，函数具有对象的全部特征，你完全可以把函数当对象来用。其实，函数就是对象，只不过比一般的对象多了一个括号“()”操作符，这个操作符用来执行函数的逻辑。即，函数本身还可以被调用，一般对象却不可以被调用，除此之外完全相同。请看下面的代码：
function Sing()
{
with(arguments.callee)
alert(author + "：" + poem);
};
Sing.author = "李白";
Sing.poem = "汉家秦地月，流影照明妃。一上玉关道，天涯去不归";
Sing();
Sing.author = "李战";
Sing.poem = "日出汉家天，月落阴山前。女儿琵琶怨，已唱三千年";
Sing();
在这段代码中，Sing函数被定义后，又给Sing函数动态地增加了author和poem属性。将author和poem属性设为不同的作者和诗句，在调用Sing()时就能显示出不同的结果。这个示例用一种诗情画意的方式，让我们理解了JavaScript函数就是对象的本质，也感受到了JavaScript语言的优美。

好了，以上的讲述，我们应该算理解了function类型的东西都是和object类型一样的东西，这种东西被我们称为“对象”。我们的确可以这样去看待这些“对象”，因为它们既有“属性”也有“方法”嘛。但下面的代码又会让我们产生新的疑惑：
var anObject = {}; //一个对象
anObject.aProperty = "Property of object"; //对象的一个属性
anObject.aMethod = function(){alert("Method of object")}; //对象的一个方法
//主要看下面：
alert(anObject["aProperty"]); //可以将对象当数组以属性名作为下标来访问属性
anObject["aMethod"](); //可以将对象当数组以方法名作为下标来调用方法
for( var s in anObject) //遍历对象的所有属性和方法进行迭代化处理
alert(s + " is a " + typeof(anObject[s]));
同样对于function类型的对象也是一样：
var aFunction = function() {}; //一个函数
aFunction.aProperty = "Property of function"; //函数的一个属性
aFunction.aMethod = function(){alert("Method of function")}; //函数的一个方法
//主要看下面：
alert(aFunction["aProperty"]); //可以将函数当数组以属性名作为下标来访问属性
aFunction["aMethod"](); //可以将函数当数组以方法名作为下标来调用方法
for( var s in aFunction) //遍历函数的所有属性和方法进行迭代化处理
alert(s + " is a " + typeof(aFunction[s]));
是的，对象和函数可以象数组一样，用属性名或方法名作为下标来访问并处理。那么，它到底应该算是数组呢，还是算对象？

我们知道，数组应该算是线性数据结构，线性数据结构一般有一定的规律，适合进行统一的批量迭代操作等，有点像波。而对象是离散数据结构，适合描述分散的和个性化的东西，有点像粒子。因此，我们也可以这样问：JavaScript里的对象到底是波还是粒子？

如果存在对象量子论，那么答案一定是：波粒二象性！

因此，JavaScript里的函数和对象既有对象的特征也有数组的特征。这里的数组被称为“字典”，一种可以任意伸缩的名称值对儿的集合。其实， object和function的内部实现就是一个字典结构，但这种字典结构却通过严谨而精巧的语法表现出了丰富的外观。正如量子力学在一些地方用粒子来解释和处理问题，而在另一些地方却用波来解释和处理问题。你也可以在需要的时候，自由选择用对象还是数组来解释和处理问题。只要善于把握JavaScript的这些奇妙特性，就可以编写出很多简洁而强大的代码来。

放下对象

我们再来看看function与object的超然结合吧。

在面向对象的编程世界里，数据与代码的有机结合就构成了对象的概念。自从有了对象，编程世界就被划分成两部分，一个是对象内的世界，一个是对象外的世界。对象天生具有自私的一面，外面的世界未经允许是不可访问对象内部的。对象也有大方的一面，它对外提供属性和方法，也为他人服务。不过，在这里我们要谈到一个有趣的问题，就是“对象的自我意识”。

什么？没听错吧？对象有自我意识？

可能对许多程序员来说，这的确是第一次听说。不过，请君看看C++、C#和Java的this，DELPHI的self，还有VB的me，或许你会恍然大悟！当然，也可能只是说句“不过如此”而已。

然而，就在对象将世界划分为内外两部分的同时，对象的“自我”也就随之产生。“自我意识”是生命的最基本特征！正是由于对象这种强大的生命力，才使得编程世界充满无限的生机和活力。

但对象的“自我意识”在带给我们快乐的同时也带来了痛苦和烦恼。我们给对象赋予了太多欲望，总希望它们能做更多的事情。然而，对象的自私使得它们互相争抢系统资源，对象的自负让对象变得复杂和臃肿，对象的自欺也往往带来挥之不去的错误和异常。我们为什么会有这么多的痛苦和烦恼呢？

为此，有一个人，在对象树下，整整想了九九八十一天，终于悟出了生命的痛苦来自于欲望，但究其欲望的根源是来自于自我意识。于是他放下了“自我”，在对象树下成了佛，从此他开始普度众生，传播真经。他的名字就叫释迦摩尼，而《JavaScript真经》正是他所传经书中的一本。

JavaScript中也有this，但这个this却与C++、C#或Java等语言的this不同。一般编程语言的this就是对象自己，而 JavaScript的this却并不一定！this可能是我，也可能是你，可能是他，反正是我中有你，你中有我，这就不能用原来的那个“自我”来理解 JavaScript这个this的含义了。为此，我们必须首先放下原来对象的那个“自我”。

我们来看下面的代码：
function WhoAmI() //定义一个函数WhoAmI
{
alert("I'm " + this.name + " of " + typeof(this));
};

WhoAmI(); //此时是this当前这段代码的全局对象，在浏览器中就是window对象，其name属性为空字符串。输出：I'm of object

var BillGates = {name: "Bill Gates"};
BillGates.WhoAmI = WhoAmI; //将函数WhoAmI作为BillGates的方法。
BillGates.WhoAmI(); //此时的this是BillGates。输出：I'm Bill Gates of object

var SteveJobs = {name: "Steve Jobs"};
SteveJobs.WhoAmI = WhoAmI; //将函数WhoAmI作为SteveJobs的方法。
SteveJobs.WhoAmI(); //此时的this是SteveJobs。输出：I'm Steve Jobs of object

WhoAmI.call(BillGates); //直接将BillGates作为this，调用WhoAmI。输出：I'm Bill Gates of object
WhoAmI.call(SteveJobs); //直接将SteveJobs作为this，调用WhoAmI。输出：I'm Steve Jobs of object

BillGates.WhoAmI.call(SteveJobs); //将SteveJobs作为this，却调用BillGates的WhoAmI方法。输出：I'm Steve Jobs of object
SteveJobs.WhoAmI.call(BillGates); //将BillGates作为this，却调用SteveJobs的WhoAmI方法。输出：I'm Bill Gates of object

WhoAmI.WhoAmI = WhoAmI; //将WhoAmI函数设置为自身的方法。
WhoAmI.name = "WhoAmI";
WhoAmI.WhoAmI(); //此时的this是WhoAmI函数自己。输出：I'm WhoAmI of function

({name: "nobody", WhoAmI: WhoAmI}).WhoAmI(); //临时创建一个匿名对象并设置属性后调用WhoAmI方法。输出：I'm nobody of object
从上面的代码可以看出，同一个函数可以从不同的角度来调用，this并不一定是函数本身所属的对象。this只是在任意对象和function元素结合时的一个概念，是种结合比起一般对象语言的默认结合更加灵活，显得更加超然和洒脱。

在JavaScript函数中，你只能把this看成当前要服务的“这个”对象。this是一个特殊的内置参数，根据this参数，您可以访问到“这个”对象的属性和方法，但却不能给this参数赋值。在一般对象语言中，方法体代码中的this可以省略的，成员默认都首先是“自己”的。但JavaScript却不同，由于不存在“自我”，当访问“这个”对象时，this不可省略！

JavaScript提供了传递this参数的多种形式和手段，其中，象BillGates.WhoAmI()和SteveJobs.WhoAmI()这种形式，是传递this参数最正规的形式，此时的this就是函数所属的对象本身。而大多数情况下，我们也几乎很少去采用那些借花仙佛的调用形式。但只我们要明白JavaScript的这个“自我”与其他编程语言的“自我”是不同的，这是一个放下了的“自我”，这就是JavaScript特有的世界观。

对象素描

已经说了许多了许多话题了，但有一个很基本的问题我们忘了讨论，那就是：怎样建立对象？

在前面的示例中，我们已经涉及到了对象的建立了。我们使用了一种被称为JavaScript Object Notation(缩写JSON)的形式，翻译为中文就是“JavaScript对象表示法”。

JSON为创建对象提供了非常简单的方法。例如，
创建一个没有任何属性的对象：
var o = {};
创建一个对象并设置属性及初始值：
var person = {name: "Angel", age: 18, married: false};
创建一个对象并设置属性和方法：
var speaker = {text: "Hello World", say: function(){alert(this.text)}};
创建一个更复杂的对象，嵌套其他对象和对象数组等：
var company =
{
name: "Microsoft",
product: "softwares",
chairman: {name: "Bill Gates", age: 53, Married: true},
employees: [{name: "Angel", age: 26, Married: false}, {name: "Hanson", age: 32, Marred: true}],
readme: function() {document.write(this.name + " product " + this.product);}
};
JSON的形式就是用大括“{}”号包括起来的项目列表，每一个项目间并用逗号“,”分隔，而项目就是用冒号“:”分隔的属性名和属性值。这是典型的字典表示形式，也再次表明了 JavaScript里的对象就是字典结构。不管多么复杂的对象，都可以被一句JSON代码来创建并赋值。

其实，JSON就是JavaScript对象最好的序列化形式，它比XML更简洁也更省空间。对象可以作为一个JSON形式的字符串，在网络间自由传递和交换信息。而当需要将这个JSON字符串变成一个JavaScript对象时，只需要使用eval函数这个强大的数码转换引擎，就立即能得到一个JavaScript内存对象。正是由于JSON的这种简单朴素的天生丽质，才使得她在AJAX舞台上成为璀璨夺目的明星。

JavaScript就是这样，把面向对象那些看似复杂的东西，用及其简洁的形式表达出来。卸下对象浮华的浓妆，还对象一个眉目清晰！

构造对象

好了，接下我们来讨论一下对象的另一种创建方法。

除JSON外，在JavaScript中我们可以使用new操作符结合一个函数的形式来创建对象。例如：
function MyFunc() {}; //定义一个空函数
var anObj = new MyFunc(); //使用new操作符，借助MyFun函数，就创建了一个对象
JavaScript的这种创建对象的方式可真有意思，如何去理解这种写法呢？

其实，可以把上面的代码改写成这种等价形式：
function MyFunc(){};
var anObj = {}; //创建一个对象
MyFunc.call(anObj); //将anObj对象作为this指针调用MyFunc函数
我们就可以这样理解，JavaScript先用new操作符创建了一个对象，紧接着就将这个对象作为this参数调用了后面的函数。其实，JavaScript内部就是这么做的，而且任何函数都可以被这样调用！但从 “anObj = new MyFunc()” 这种形式，我们又看到一个熟悉的身影，C++和C#不就是这样创建对象的吗？原来，条条大路通灵山，殊途同归啊！

君看到此处也许会想，我们为什么不可以把这个MyFunc当作构造函数呢？恭喜你，答对了！JavaScript也是这么想的！请看下面的代码：
1 function Person(name) //带参数的构造函数
2 {
3 this.name = name; //将参数值赋给给this对象的属性
4 this.SayHello = function() {alert("Hello, I'm " + this.name);}; //给this对象定义一个SayHello方法。
5 };
6
7 function Employee(name, salary) //子构造函数
8 {
9 Person.call(this, name); //将this传给父构造函数
10 this.salary = salary; //设置一个this的salary属性
11 this.ShowMeTheMoney = function() {alert(this.name + " $" + this.salary);}; //添加ShowMeTheMoney方法。
12 };
13
14 var BillGates = new Person("Bill Gates"); //用Person构造函数创建BillGates对象
15 var SteveJobs = new Employee("Steve Jobs", 1234); //用Empolyee构造函数创建SteveJobs对象
16
17 BillGates.SayHello(); //显示：I'm Bill Gates
18 SteveJobs.SayHello(); //显示：I'm Steve Jobs
19 SteveJobs.ShowMeTheMoney(); //显示：Steve Jobs $1234
20
21 alert(BillGates.constructor == Person); //显示：true
22 alert(SteveJobs.constructor == Employee); //显示：true
23
24 alert(BillGates.SayHello == SteveJobs.SayHello); //显示：false
这段代码表明，函数不但可以当作构造函数，而且还可以带参数，还可以为对象添加成员和方法。其中的第9行，Employee构造函数又将自己接收的this作为参数调用Person构造函数，这就是相当于调用基类的构造函数。第21、22行还表明这样一个意思：BillGates是由Person构造的，而SteveJobs是由Employee构造的。对象内置的constructor属性还指明了构造对象所用的具体函数！

其实，如果你愿意把函数当作“类”的话，她就是“类”，因为她本来就有“类”的那些特征。难道不是吗？她生出的儿子各个都有相同的特征，而且构造函数也与类同名嘛！

但要注意的是，用构造函数操作this对象创建出来的每一个对象，不但具有各自的成员数据，而且还具有各自的方法数据。换句话说，方法的代码体(体现函数逻辑的数据)在每一个对象中都存在一个副本。尽管每一个代码副本的逻辑是相同的，但对象们确实是各自保存了一份代码体。上例中的最后一句说明了这一实事，这也解释了JavaScript中的函数就是对象的概念。

同一类的对象各自有一份方法代码显然是一种浪费。在传统的对象语言中，方法函数并不象JavaScript那样是个对象概念。即使也有象函数指针、方法指针或委托那样的变化形式，但其实质也是对同一份代码的引用。一般的对象语言很难遇到这种情况。

不过，JavaScript语言有大的灵活性。我们可以先定义一份唯一的方法函数体，并在构造this对象时使用这唯一的函数对象作为其方法，就能共享方法逻辑。例如：
function SayHello() //先定义一份SayHello函数代码
{
alert("Hello, I'm " + this.name);
};

function Person(name) //带参数的构造函数
{
this.name = name; //将参数值赋给给this对象的属性
this.SayHello = SayHello; //给this对象SayHello方法赋值为前面那份SayHello代码。
};

var BillGates = new Person("Bill Gates"); //创建BillGates对象
var SteveJobs = new Person("Steve Jobs"); //创建SteveJobs对象

alert(BillGates.SayHello == SteveJobs.SayHello); //显示：true
其中，最后一行的输出结果表明两个对象确实共享了一个函数对象。虽然，这段程序达到了共享了一份方法代码的目的，但却不怎么优雅。因为，定义SayHello方法时反映不出其与Person类的关系。“优雅”这个词用来形容代码，也不知道是谁先提出来的。不过，这个词反映了程序员已经从追求代码的正确、高效、可靠和易读等基础上，向着追求代码的美观感觉和艺术境界的层次发展，程序人生又多了些浪漫色彩。

显然，JavaScript早想到了这一问题，她的设计者们为此提供了一个有趣的prototype概念。

初看原型

prototype源自法语，软件界的标准翻译为“原型”，代表事物的初始形态，也含有模型和样板的意义。JavaScript中的prototype概念恰如其分地反映了这个词的内含，我们不能将其理解为C++的prototype那种预先声明的概念。

JavaScript的所有function类型的对象都有一个prototype属性。这个prototype属性本身又是一个object类型的对象，因此我们也可以给这个prototype对象添加任意的属性和方法。既然prototype是对象的“原型”，那么由该函数构造出来的对象应该都会具有这个“原型”的特性。事实上，在构造函数的prototype上定义的所有属性和方法，都是可以通过其构造的对象直接访问和调用的。也可以这么说，prototype提供了一群同类对象共享属性和方法的机制。

我们先来看看下面的代码：
function Person(name)
{
this.name = name; //设置对象属性，每个对象各自一份属性数据
};

Person.prototype.SayHello = function() //给Person函数的prototype添加SayHello方法。
{
alert("Hello, I'm " + this.name);
}

var BillGates = new Person("Bill Gates"); //创建BillGates对象
var SteveJobs = new Person("Steve Jobs"); //创建SteveJobs对象

BillGates.SayHello(); //通过BillGates对象直接调用到SayHello方法
SteveJobs.SayHello(); //通过SteveJobs对象直接调用到SayHello方法

alert(BillGates.SayHello == SteveJobs.SayHello); //因为两个对象是共享prototype的SayHello，所以显示：true
程序运行的结果表明，构造函数的prototype上定义的方法确实可以通过对象直接调用到，而且代码是共享的。显然，把方法设置到prototype的写法显得优雅多了，尽管调用形式没有变，但逻辑上却体现了方法与类的关系，相对前面的写法，更容易理解和组织代码。

那么，对于多层次类型的构造函数情况又如何呢？

我们再来看下面的代码：
1 function Person(name) //基类构造函数
2 {
3 this.name = name;
4 };
5
6 Person.prototype.SayHello = function() //给基类构造函数的prototype添加方法
7 {
8 alert("Hello, I'm " + this.name);
9 };
10
11 function Employee(name, salary) //子类构造函数
12 {
13 Person.call(this, name); //调用基类构造函数
14 this.salary = salary;
15 };
16
17 Employee.prototype = new Person(); //建一个基类的对象作为子类原型的原型，这里很有意思
18
19 Employee.prototype.ShowMeTheMoney = function() //给子类添构造函数的prototype添加方法
20 {
21 alert(this.name + " $" + this.salary);
22 };
23
24 var BillGates = new Person("Bill Gates"); //创建基类Person的BillGates对象
25 var SteveJobs = new Employee("Steve Jobs", 1234); //创建子类Employee的SteveJobs对象
26
27 BillGates.SayHello(); //通过对象直接调用到prototype的方法
28 SteveJobs.SayHello(); //通过子类对象直接调用基类prototype的方法，关注！
29 SteveJobs.ShowMeTheMoney(); //通过子类对象直接调用子类prototype的方法
30
31 alert(BillGates.SayHello == SteveJobs.SayHello); //显示：true，表明prototype的方法是共享的
这段代码的第17行，构造了一个基类的对象，并将其设为子类构造函数的prototype，这是很有意思的。这样做的目的就是为了第28行，通过子类对象也可以直接调用基类prototype的方法。为什么可以这样呢？

原来，在JavaScript中，prototype不但能让对象共享自己财富，而且prototype还有寻根问祖的天性，从而使得先辈们的遗产可以代代相传。当从一个对象那里读取属性或调用方法时，如果该对象自身不存在这样的属性或方法，就会去自己关联的prototype对象那里寻找；如果prototype没有，又会去prototype自己关联的前辈prototype那里寻找，直到找到或追溯过程结束为止。

在JavaScript内部，对象的属性和方法追溯机制是通过所谓的prototype链来实现的。当用new操作符构造对象时，也会同时将构造函数的prototype对象指派给新创建的对象，成为该对象内置的原型对象。对象内置的原型对象应该是对外不可见的，尽管有些浏览器(如Firefox)可以让我们访问这个内置原型对象，但并不建议这样做。内置的原型对象本身也是对象，也有自己关联的原型对象，这样就形成了所谓的原型链。

在原型链的最末端，就是Object构造函数prototype属性指向的那一个原型对象。这个原型对象是所有对象的最老祖先，这个老祖宗实现了诸如toString等所有对象天生就该具有的方法。其他内置构造函数，如Function, Boolean, String, Date和RegExp等的prototype都是从这个老祖宗传承下来的，但他们各自又定义了自身的属性和方法，从而他们的子孙就表现出各自宗族的那些特征。

这不就是“继承”吗？是的，这就是“继承”，是JavaScript特有的“原型继承”。

“原型继承”是慈祥而又严厉的。原形对象将自己的属性和方法无私地贡献给孩子们使用，也并不强迫孩子们必须遵从，允许一些顽皮孩子按自己的兴趣和爱好独立行事。从这点上看，原型对象是一位慈祥的母亲。然而，任何一个孩子虽然可以我行我素，但却不能动原型对象既有的财产，因为那可能会影响到其他孩子的利益。从这一点上看，原型对象又象一位严厉的父亲。我们来看看下面的代码就可以理解这个意思了：
function Person(name)
{
this.name = name;
};

Person.prototype.company = "Microsoft"; //原型的属性

Person.prototype.SayHello = function() //原型的方法
{
alert("Hello, I'm " + this.name + " of " + this.company);
};

var BillGates = new Person("Bill Gates");
BillGates.SayHello(); //由于继承了原型的东西，规规矩矩输出：Hello, I'm Bill Gates

var SteveJobs = new Person("Steve Jobs");
SteveJobs.company = "Apple"; //设置自己的company属性，掩盖了原型的company属性
SteveJobs.SayHello = function() //实现了自己的SayHello方法，掩盖了原型的SayHello方法
{
alert("Hi, " + this.name + " like " + this.company + ", ha ha ha ");
};

SteveJobs.SayHello(); //都是自己覆盖的属性和方法，输出：Hi, Steve Jobs like Apple, ha ha ha

BillGates.SayHello(); //SteveJobs的覆盖没有影响原型对象，BillGates还是按老样子输出
对象可以掩盖原型对象的那些属性和方法，一个构造函数原型对象也可以掩盖上层构造函数原型对象既有的属性和方法。这种掩盖其实只是在对象自己身上创建了新的属性和方法，只不过这些属性和方法与原型对象的那些同名而已。JavaScript就是用这简单的掩盖机制实现了对象的“多态”性，与静态对象语言的虚函数和重载(override)概念不谋而合。

然而，比静态对象语言更神奇的是，我们可以随时给原型对象动态添加新的属性和方法，从而动态地扩展基类的功能特性。这在静态对象语言中是很难想象的。我们来看下面的代码：
function Person(name)
{
this.name = name;
};

Person.prototype.SayHello = function() //建立对象前定义的方法
{
alert("Hello, I'm " + this.name);
};

var BillGates = new Person("Bill Gates"); //建立对象

BillGates.SayHello();

Person.prototype.Retire = function() //建立对象后再动态扩展原型的方法
{
alert("Poor " + this.name + ", bye bye!");
};

BillGates.Retire(); //动态扩展的方法即可被先前建立的对象立即调用
阿弥佗佛，原型继承竟然可以玩出有这样的法术！

原型扩展

想必君的悟性极高，可能你会这样想：如果在JavaScript内置的那些如Object和Function等函数的prototype上添加些新的方法和属性，是不是就能扩展JavaScript的功能呢？

那么，恭喜你，你得到了！

在AJAX技术迅猛发展的今天，许多成功的AJAX项目的JavaScript运行库都大量扩展了内置函数的prototype功能。比如微软的ASP.NET AJAX，就给这些内置函数及其prototype添加了大量的新特性，从而增强了JavaScript的功能。

我们来看一段摘自MicrosoftAjax.debug.js中的代码：

String.prototype.trim = function String$trim() {
if (arguments.length !== 0) throw Error.parameterCount();
return this.replace(/^\s+|\s+$/g, '');
}
这段代码就是给内置String函数的prototype扩展了一个trim方法，于是所有的String类对象都有了trim方法了。有了这个扩展，今后要去除字符串两段的空白，就不用再分别处理了，因为任何字符串都有了这个扩展功能，只要调用即可，真的很方便。

当然，几乎很少有人去给Object的prototype添加方法，因为那会影响到所有的对象，除非在你的架构中这种方法的确是所有对象都需要的。

前两年，微软在设计AJAX类库的初期，用了一种被称为“闭包”(closure)的技术来模拟“类”。其大致模型如下：
function Person(firstName, lastName, age)
{
//私有变量：
var _firstName = firstName;
var _lastName = lastName;

//公共变量:
this.age = age;

//方法：
this.getName = function()
{
return(firstName + " " + lastName);
};
this.SayHello = function()
{
alert("Hello, I'm " + firstName + " " + lastName);
};
};

var BillGates = new Person("Bill", "Gates", 53);
var SteveJobs = new Person("Steve", "Jobs", 53);

BillGates.SayHello();
SteveJobs.SayHello();
alert(BillGates.getName() + " " + BillGates.age);
alert(BillGates.firstName); //这里不能访问到私有变量
很显然，这种模型的类描述特别象C#语言的描述形式，在一个构造函数里依次定义了私有成员、公共属性和可用的方法，显得非常优雅嘛。特别是“闭包”机制可以模拟对私有成员的保护机制，做得非常漂亮。

所谓的“闭包”，就是在构造函数体内定义另外的函数作为目标对象的方法函数，而这个对象的方法函数反过来引用外层外层函数体中的临时变量。这使得只要目标对象在生存期内始终能保持其方法，就能间接保持原构造函数体当时用到的临时变量值。尽管最开始的构造函数调用已经结束，临时变量的名称也都消失了，但在目标对象的方法内却始终能引用到该变量的值，而且该值只能通这种方法来访问。即使再次调用相同的构造函数，但只会生成新对象和方法，新的临时变量只是对应新的值，和上次那次调用的是各自独立的。的确很巧妙！

但是前面我们说过，给每一个对象设置一份方法是一种很大的浪费。还有，“闭包”这种间接保持变量值的机制，往往会给JavaSript的垃圾回收器制造难题。特别是遇到对象间复杂的循环引用时，垃圾回收的判断逻辑非常复杂。无独有偶，IE浏览器早期版本确实存在JavaSript垃圾回收方面的内存泄漏问题。再加上“闭包”模型在性能测试方面的表现不佳，微软最终放弃了“闭包”模型，而改用“原型”模型。正所谓“有得必有失”嘛。

原型模型需要一个构造函数来定义对象的成员，而方法却依附在该构造函数的原型上。大致写法如下：
//定义构造函数
function Person(name)
{
this.name = name; //在构造函数中定义成员
};

//方法定义到构造函数的prototype上
Person.prototype.SayHello = function()
{
alert("Hello, I'm " + this.name);
};

//子类构造函数
function Employee(name, salary)
{
Person.call(this, name); //调用上层构造函数
this.salary = salary; //扩展的成员
};

//子类构造函数首先需要用上层构造函数来建立prototype对象，实现继承的概念
Employee.prototype = new Person() //只需要其prototype的方法，此对象的成员没有任何意义！

//子类方法也定义到构造函数之上
Employee.prototype.ShowMeTheMoney = function()
{
alert(this.name + " $" + this.salary);
};

var BillGates = new Person("Bill Gates");
BillGates.SayHello();

var SteveJobs = new Employee("Steve Jobs", 1234);
SteveJobs.SayHello();
SteveJobs.ShowMeTheMoney();
原型类模型虽然不能模拟真正的私有变量，而且也要分两部分来定义类，显得不怎么“优雅”。不过，对象间的方法是共享的，不会遇到垃圾回收问题，而且性能优于“闭包”模型。正所谓“有失必有得”嘛。

在原型模型中，为了实现类继承，必须首先将子类构造函数的prototype设置为一个父类的对象实例。创建这个父类对象实例的目的就是为了构成原型链，以起到共享上层原型方法作用。但创建这个实例对象时，上层构造函数也会给它设置对象成员，这些对象成员对于继承来说是没有意义的。虽然，我们也没有给构造函数传递参数，但确实创建了若干没有用的成员，尽管其值是undefined，这也是一种浪费啊。

唉！世界上没有完美的事情啊！

原型真谛

正当我们感概万分时，天空中一道红光闪过，祥云中出现了观音菩萨。只见她手持玉净瓶，轻拂翠柳枝，洒下几滴甘露，顿时让JavaScript又添新的灵气。

观音洒下的甘露在JavaScript的世界里凝结成块，成为了一种称为“语法甘露”的东西。这种语法甘露可以让我们编写的代码看起来更象对象语言。

要想知道这“语法甘露”为何物，就请君侧耳细听。

在理解这些语法甘露之前，我们需要重新再回顾一下JavaScript构造对象的过程。

我们已经知道，用 var anObject = new aFunction() 形式创建对象的过程实际上可以分为三步：第一步是建立一个新对象；第二步将该对象内置的原型对象设置为构造函数prototype引用的那个原型对象；第三步就是将该对象作为this参数调用构造函数，完成成员设置等初始化工作。对象建立之后，对象上的任何访问和操作都只与对象自身及其原型链上的那串对象有关，与构造函数再扯不上关系了。换句话说，构造函数只是在创建对象时起到介绍原型对象和初始化对象两个作用。

那么，我们能否自己定义一个对象来当作原型，并在这个原型上描述类，然后将这个原型设置给新创建的对象，将其当作对象的类呢？我们又能否将这个原型中的一个方法当作构造函数，去初始化新建的对象呢？例如，我们定义这样一个原型对象：

var Person = //定义一个对象来作为原型类
{
Create: function(name, age) //这个当构造函数
{
this.name = name;
this.age = age;
},
SayHello: function() //定义方法
{
alert("Hello, I'm " + this.name);
},
HowOld: function() //定义方法
{
alert(this.name + " is " + this.age + " years old.");
}
};
这个JSON形式的写法多么象一个C#的类啊！既有构造函数，又有各种方法。如果可以用某种形式来创建对象，并将对象的内置的原型设置为上面这个“类”对象，不就相当于创建该类的对象了吗？

但遗憾的是，我们几乎不能访问到对象内置的原型属性！尽管有些浏览器可以访问到对象的内置原型，但这样做的话就只能限定了用户必须使用那种浏览器。这也几乎不可行。

那么，我们可不可以通过一个函数对象来做媒介，利用该函数对象的prototype属性来中转这个原型，并用new操作符传递给新建的对象呢？

其实，象这样的代码就可以实现这一目标：

function anyfunc(){}; //定义一个函数躯壳
anyfunc.prototype = Person; //将原型对象放到中转站prototype
var BillGates = new anyfunc(); //新建对象的内置原型将是我们期望的原型对象
不过，这个anyfunc函数只是一个躯壳，在使用过这个躯壳之后它就成了多余的东西了，而且这和直接使用构造函数来创建对象也没啥不同，有点不爽。

可是，如果我们将这些代码写成一个通用函数，而那个函数躯壳也就成了函数内的函数，这个内部函数不就可以在外层函数退出作用域后自动消亡吗？而且，我们可以将原型对象作为通用函数的参数，让通用函数返回创建的对象。我们需要的就是下面这个形式：

function New(aClass, aParams) //通用创建函数
{
function new_() //定义临时的中转函数壳
{
aClass.Create.apply(this, aParams); //调用原型中定义的的构造函数，中转构造逻辑及构造参数
};
new_.prototype = aClass; //准备中转原型对象
return new new_(); //返回建立最终建立的对象
};

var Person = //定义的类
{
Create: function(name, age)
{
this.name = name;
this.age = age;
},
SayHello: function()
{
alert("Hello, I'm " + this.name);
},
HowOld: function()
{
alert(this.name + " is " + this.age + " years old.");
}
};

var BillGates = New(Person, ["Bill Gates", 53]); //调用通用函数创建对象，并以数组形式传递构造参数
BillGates.SayHello();
BillGates.HowOld();

alert(BillGates.constructor == Object); //输出：true
这里的通用函数New()就是一个“语法甘露”！这个语法甘露不但中转了原型对象，还中转了构造函数逻辑及构造参数。

有趣的是，每次创建完对象退出New函数作用域时，临时的new_函数对象会被自动释放。由于new_的prototype属性被设置为新的原型对象，其原来的原型对象和new_之间就已解开了引用链，临时函数及其原来的原型对象都会被正确回收了。上面代码的最后一句证明，新创建的对象的constructor属性返回的是Object函数。其实新建的对象自己及其原型里没有constructor属性，那返回的只是最顶层原型对象的构造函数，即Object。

有了New这个语法甘露，类的定义就很像C#那些静态对象语言的形式了，这样的代码显得多么文静而优雅啊！

当然，这个代码仅仅展示了“语法甘露”的概念。我们还需要多一些的语法甘露，才能实现用简洁而优雅的代码书写类层次及其继承关系。好了，我们再来看一个更丰富的示例吧：

//语法甘露：
var object = //定义小写的object基本类，用于实现最基础的方法等
{
isA: function(aType) //一个判断类与类之间以及对象与类之间关系的基础方法
{
var self = this;
while(self)
{
if (self == aType)
return true;
self = self.Type;
};
return false;
}
};

function Class(aBaseClass, aClassDefine) //创建类的函数，用于声明类及继承关系
{
function class_() //创建类的临时函数壳
{
this.Type = aBaseClass; //我们给每一个类约定一个Type属性，引用其继承的类
for(var member in aClassDefine)
this[member] = aClassDefine[member]; //复制类的全部定义到当前创建的类
};
class_.prototype = aBaseClass;
return new class_();
};

function New(aClass, aParams) //创建对象的函数，用于任意类的对象创建
{
function new_() //创建对象的临时函数壳
{
this.Type = aClass; //我们也给每一个对象约定一个Type属性，据此可以访问到对象所属的类
if (aClass.Create)
aClass.Create.apply(this, aParams); //我们约定所有类的构造函数都叫Create，这和DELPHI比较相似
};
new_.prototype = aClass;
return new new_();
};

//语法甘露的应用效果：
var Person = Class(object, //派生至object基本类
{
Create: function(name, age)
{
this.name = name;
this.age = age;
},
SayHello: function()
{
alert("Hello, I'm " + this.name + ", " + this.age + " years old.");
}
});

var Employee = Class(Person, //派生至Person类，是不是和一般对象语言很相似？
{
Create: function(name, age, salary)
{
Person.Create.call(this, name, age); //调用基类的构造函数
this.salary = salary;
},
ShowMeTheMoney: function()
{
alert(this.name + " $" + this.salary);
}
});

var BillGates = New(Person, ["Bill Gates", 53]);
var SteveJobs = New(Employee, ["Steve Jobs", 53, 1234]);
BillGates.SayHello();
SteveJobs.SayHello();
SteveJobs.ShowMeTheMoney();

var LittleBill = New(BillGates.Type, ["Little Bill", 6]); //根据BillGate的类型创建LittleBill
LittleBill.SayHello();

alert(BillGates.isA(Person)); //true
alert(BillGates.isA(Employee)); //false
alert(SteveJobs.isA(Person)); //true
alert(Person.isA(Employee)); //false
alert(Employee.isA(Person)); //true
“语法甘露”不用太多，只要那么一点点，就能改观整个代码的易读性和流畅性，从而让代码显得更优雅。有了这些语法甘露，JavaScript就很像一般对象语言了，写起代码了感觉也就爽多了！

令人高兴的是，受这些甘露滋养的JavaScript程序效率会更高。因为其原型对象里既没有了毫无用处的那些对象级的成员，而且还不存在constructor属性体，少了与构造函数间的牵连，但依旧保持了方法的共享性。这让JavaScript在追溯原型链和搜索属性及方法时，少费许多工夫啊。

我们就把这种形式称为“甘露模型”吧！其实，这种“甘露模型”的原型用法才是符合prototype概念的本意，才是的JavaScript原型的真谛！

想必微软那些设计AJAX架构的工程师看到这个甘露模型时，肯定后悔没有早点把AJAX部门从美国搬到咱中国的观音庙来，错过了观音菩萨的点化。当然，我们也只能是在代码的示例中，把Bill Gates当作对象玩玩，真要让他放弃上帝转而皈依我佛肯定是不容易的，机缘未到啊！如果哪天你在微软新出的AJAX类库中看到这种甘露模型，那才是真正的缘分！

编程的快乐

在软件工业迅猛发展的今天，各式各样的编程语言层出不穷，新语言的诞生，旧语言的演化，似乎已经让我们眼花缭乱。为了适应面向对象编程的潮流，JavaScript语言也在向完全面向对象的方向发展，新的JavaScript标准已经从语义上扩展了许多面向对象的新元素。与此相反的是，许多静态的对象语言也在向JavaScript的那种简洁而幽雅的方向发展。例如，新版本的C#语言就吸收了JSON那样的简洁表示法，以及一些其他形式的JavaScript特性。

我们应该看到，随着RIA(强互联应用)的发展和普及，AJAX技术也将逐渐淡出江湖，JavaScript也将最终消失或演化成其他形式的语言。但不管编程语言如何发展和演化，编程世界永远都会在“数据”与“代码”这千丝万缕的纠缠中保持着无限的生机。只要我们能看透这一点，我们就能很容易地学习和理解软件世界的各种新事物。不管是已熟悉的过程式编程，还是正在发展的函数式编程，以及未来量子纠缠态的大规模并行式编程，我们都有足够的法力来化解一切复杂的难题。

佛最后淡淡地说：只要我们放下那些表面的“类”，放下那些对象的“自我”，就能达到一种“对象本无根，类型亦无形”的境界，从而将自我融入到整个宇宙的生命轮循环中。我们将没有自我，也没有自私的欲望，你就是我，我就是你，你中有我，我中有你。这时，我们再看这生机勃勃的编程世界时，我们的内心将自然生起无限的慈爱之心，这种慈爱之心不是虚伪而是真诚的。关爱他人就是关爱自己，就是关爱这世界中的一切。那么，我们的心是永远快乐的，我们的程序是永远快乐的，我们的类是永远快乐的，我们的对象也是永远快乐的。这就是编程的极乐！

说到这里，在座的比丘都犹如醍醐灌顶，心中豁然开朗。看看左边这位早已喜不自禁，再看看右边那位也是心花怒放。

蓦然回首时，唯见君拈花微笑...

用一个单独的文件创建一个 JAR 文件 jar cf jar-file input-file...
用一个目录创建一个 JAR 文件 jar cf jar-file dir-name
创建一个未压缩的 JAR 文件 jar cf0 jar-file dir-name
更新一个 JAR 文件 jar uf jar-file input-file...
查看一个 JAR 文件的内容 jar tf jar-file
提取一个 JAR 文件的内容 jar xf jar-file
从一个 JAR 文件中提取特定的文件 jar xf jar-file archived-file...
运行一个打包为可执行 JAR 文件的应用程序 java -jar app.jar

常常在网上看到有人询问：如何把 java 程序编译成 .exe 文件。通常回答只有两种，一种是制作一个可执行的 JAR 文件包，然后就可以像.chm 文档一样双击运行了；而另一种是使用 JET 来进行 编译。但是 JET 是要用钱买的，而且据说 JET 也不是能把所有的 Java 程序都编译成执行文件，性能也要打些折扣。所以，使用制作可执行 JAR 文件包的方法就是最佳选择了，何况它还能保持 Java 的跨平台特性。

下面就来看看什么是 JAR 文件包吧：

1. JAR 文件包

JAR 文件就是 Java Archive File，顾名思意，它的应用是与 Java 息息相关的，是 Java 的一种文档格式。 JAR 文件非常类似 ZIP 文件——准确的说，它就是 ZIP 文件，所以叫它文件包。JAR 文件与 ZIP 文件唯一的区别就是在 JAR 文件的内容中，包含了一个 META-INF/MANIFEST.MF 文件，这个文件是在生成 JAR 文件的时候自动创建的。举个例子，如果我们具有如下目录结构的一些文件：

　　==

　　`-- test

　　　 `-- Test.class

把它压缩成 ZIP 文件 test.zip，则这个 ZIP 文件的内部目录结构为：

　　test.zip

　　`-- test

　　　 `-- Test.class

如果我们使用 JDK 的 jar 命令把它打成 JAR 文件包 test.jar，则这个 JAR 文件的内部目录结构为：

　　test.jar

　　|-- META-INF

　　|　 `-- MANIFEST.MF

　　`-- test

　　　　`--Test.class

2. 创建可执行的 JAR 文件包

制作一个可执行的 JAR 文件包来发布你的程序是 JAR 文件包最典型的用法。

Java 程序是由若干个 .class 文件组成的。这些 .class 文件必须根据它们所属的包不同而分级分目录存放；运行前需要把所有用到的包的根目录指定给 CLASSPATH 环境变量或者 java 命令的 -cp 参数；运行时还要到控制台下去使用 java 命令来运行，如果需要直接双击运行必须写 Windows 的批处理文件 (.bat) 或者 Linux 的 Shell 程序。因此，许多人说，Java 是一种方便开发者苦了用户的程序设计语言。

其实不然，如果开发者能够制作一个可执行的 JAR 文件包交给用户，那么用户使用起来就方便了。在 Windows 下安装 JRE (Java Runtime Environment) 的时候，安装文件会将 .jar 文件映射给 javaw.exe 打开。那么，对于一个可执行的 JAR 文件包，用户只需要双击它就可以运行程序了，和阅读 .chm 文档一样方便 (.chm 文档默认是由 hh.exe 打开的)。那么，现在的关键，就是如何来创建这个可执行的 JAR 文件包。

创建可执行的 JAR 文件包，需要使用带 cvfm 参数的 jar 命令，同样以上述 test 目录为例，命令如下：

jar cvfm test.jar manifest.mf test

这里 test.jar 和 manifest.mf 两个文件，分别是对应的参数 f 和 m，其重头戏在 manifest.mf。因为要创建可执行的 JAR 文件包，光靠指定一个 manifest.mf 文件是不够的，因为 MANIFEST 是 JAR 文件包的特征，可执行的 JAR 文件包和不可执行的 JAR 文件包都包含 MANIFEST。关键在于可执行 JAR 文件包的 MANIFEST，其内容包含了 Main-Class 一项。这在 MANIFEST 中书写格式如下：

Main-Class: 可执行主类全名(包含包名)

例如，假设上例中的 Test.class 是属于 test 包的，而且是可执行的类 (定义了 public static void main(String[]) 方法)，那么这个 manifest.mf 可以编辑如下：

Main-Class: test.Test <回车>;

这个 manifest.mf 可以放在任何位置，也可以是其它的文件名，只需要有 Main-Class: test.Test 一行，且该行以一个回车符结束即可。创建了 manifest.mf 文件之后，我们的目录结构变为：

　　==

　　|-- test

　　|　 `-- Test.class

　　`-- manifest.mf

这时候，需要到 test 目录的上级目录中去使用 jar 命令来创建 JAR 文件包。也就是在目录树中使用“==”表示的那个目录中，使用如下命令：

jar cvfm test.jar manifest.mf test

之后在“==”目录中创建了 test.jar，这个 test.jar 就是执行的 JAR 文件包。运行时只需要使用 java -jar test.jar 命令即可。

需要注意的是，创建的 JAR 文件包中需要包含完整的、与 Java 程序的包结构对应的目录结构，就像上例一样。而 Main- Class 指定的类，也必须是完整的、包含包路径的类名，如上例的 test.Test；而且在没有打成 JAR 文件包之前可以使用 java <类名>; 来运行这个类，即在上例中 java test.Test 是可以正确运行的 (当然要在 CLASSPATH 正确的情况下)。

3. jar 命令详解

jar 是随 JDK 安装的，在 JDK 安装目录下的 bin 目录中，Windows 下文件名为 jar.exe，Linux 下文件名为 jar。它的运行需要用到 JDK 安装目录下 lib 目录中的 tools.jar 文件。不过我们除了安装 JDK 什么也不需要做，因为 SUN 已经帮我们做好了。我们甚至不需要将 tools.jar 放到 CLASSPATH 中。

使用不带任何的 jar 命令我们可以看到 jar 命令的用法如下：

jar {ctxu}[vfm0M] [jar-文件] [manifest-文件] [-C 目录] 文件名 ...

其中 {ctxu} 是 jar 命令的子命令，每次 jar 命令只能包含 ctxu 中的一个，它们分别表示：

-c　创建新的 JAR 文件包

-t　列出 JAR 文件包的内容列表

-x　展开 JAR 文件包的指定文件或者所有文件

-u　更新已存在的 JAR 文件包 (添加文件到 JAR 文件包中)

[vfm0M] 中的选项可以任选，也可以不选，它们是 jar 命令的选项参数

-v　生成详细报告并打印到标准输出

-f　指定 JAR 文件名，通常这个参数是必须的

-m　指定需要包含的 MANIFEST 清单文件

-0　只存储，不压缩，这样产生的 JAR 文件包会比不用该参数产生的体积大，但速度更快

-M　不产生所有项的清单（MANIFEST〕文件，此参数会忽略 -m 参数

[jar-文件] 即需要生成、查看、更新或者解开的 JAR 文件包，它是 -f 参数的附属参数

[manifest-文件] 即 MANIFEST 清单文件，它是 -m 参数的附属参数

[-C 目录] 表示转到指定目录下去执行这个 jar 命令的操作。它相当于先使用 cd 命令转该目录下再执行不带 -C 参数的 jar 命令，它只能在创建和更新 JAR 文件包的时候可用。　　

文件名 ... 指定一个文件/目录列表，这些文件/目录就是要添加到 JAR 文件包中的文件/目录。如果指定了目录，那么 jar 命令打包的时候会自动把该目录中的所有文件和子目录打入包中。

下面举一些例子来说明 jar 命令的用法：

1) jar cf test.jar test

该命令没有执行过程的显示，执行结果是在当前目录生成了 test.jar 文件。如果当前目录已经存在 test.jar，那么该文件将被覆盖。

2) jar cvf test.jar test

该命令与上例中的结果相同，但是由于 v 参数的作用，显示出了打包过程，如下：

标明清单(manifest)

增加：test/(读入= 0) (写出= 0)(存储了 0%)

增加：test/Test.class(读入= 7) (写出= 6)(压缩了 14%)

3) jar cvfM test.jar test

该命令与 2) 结果类似，但在生成的 test.jar 中没有包含 META-INF/MANIFEST 文件，打包过程的信息也略有差别：

增加：test/(读入= 0) (写出= 0)(存储了 0%)

增加：test/Test.class(读入= 7) (写出= 6)(压缩了 14%)

4) jar cvfm test.jar manifest.mf test

运行结果与 2) 相似，显示信息也相同，只是生成 JAR 包中的 META-INF/MANIFEST 内容不同，是包含了 manifest.mf 的内容

5) jar tf test.jar

在 test.jar 已经存在的情况下，可以查看 test.jar 中的内容，如对于 2) 和 3) 生成的 test.jar 分别应该此命令，结果如下；

对于 2)

META-INF/

META-INF/MANIFEST.MF

test/

test/Test.class

对于 3)

test/

test/Test.class

6) jar tvf test.jar

除显示 5) 中显示的内容外，还包括包内文件的详细信息，如：

0 Wed Jun 19 15:39:06 GMT 2002 META-INF/

86 Wed Jun 19 15:39:06 GMT 2002 META-INF/MANIFEST.MF

0 Wed Jun 19 15:33:04 GMT 2002 test/

7 Wed Jun 19 15:33:04 GMT 2002 test/Test.class

7) jar xf test.jar

解开 test.jar 到当前目录，不显示任何信息，对于 2) 生成的 test.jar，解开后的目录结构如下：

　　==

　　|-- META-INF

　　|　 `-- MANIFEST

　　`-- test

　　　　`--Test.class

8) jar xvf test.jar

运行结果与 7) 相同，对于解压过程有详细信息显示，如：

创建：META-INF/

展开：META-INF/MANIFEST.MF

创建：test/

展开：test/Test.class

9) jar uf test.jar manifest.mf

在 test.jar 中添加了文件 manifest.mf，此使用 jar tf 来查看 test.jar 可以发现 test.jar 中比原来多了一个 manifest。这里顺便提一下，如果使用 -m 参数并指定 manifest.mf 文件，那么 manifest.mf 是作为清单文件 MANIFEST 来使用的，它的内容会被添加到 MANIFEST 中；但是，如果作为一般文件添加到 JAR 文件包中，它跟一般文件无异。

10) jar uvf test.jar manifest.mf

与 9) 结果相同，同时有详细信息显示，如：

增加：manifest.mf(读入= 17) (写出= 19)(压缩了 -11%)

4. 关于 JAR 文件包的一些技巧

1) 使用 unzip 来解压 JAR 文件

在介绍 JAR 文件的时候就已经说过了，JAR 文件实际上就是 ZIP 文件，所以可以使用常见的一些解压 ZIP 文件的工具来解压 JAR 文件，如 Windows 下的 WinZip、WinRAR 等和 Linux 下的 unzip 等。使用 WinZip 和 WinRAR 等来解压是因为它们解压比较直观，方便。而使用 unzip，则是因为它解压时可以使用 -d 参数指定目标目录。

在解压一个 JAR 文件的时候是不能使用 jar 的 -C 参数来指定解压的目标的，因为 -C 参数只在创建或者更新包的时候可用。那么需要将文件解压到某个指定目录下的时候就需要先将这具 JAR 文件拷贝到目标目录下，再进行解压，比较麻烦。如果使用 unzip，就不需要这么麻烦了，只需要指定一个 -d 参数即可。如：

unzip test.jar -d dest/

2) 使用 WinZip 或者 WinRAR 等工具创建 JAR 文件

上面提到 JAR 文件就是包含了 META-INF/MANIFEST 的 ZIP 文件，所以，只需要使用 WinZip、WinRAR 等工具创建所需要 ZIP 压缩包，再往这个 ZIP 压缩包中添加一个包含 MANIFEST 文件的 META-INF 目录即可。对于使用 jar 命令的 -m 参数指定清单文件的情况，只需要将这个 MANIFEST 按需要修改即可。

3) 使用 jar 命令创建 ZIP 文件

有些 Linux 下提供了 unzip 命令，但没有 zip 命令，所以需要可以对 ZIP 文件进行解压，即不能创建 ZIP 文件。如要创建一个 ZIP 文件，使用带 -M 参数的 jar 命令即可，因为 -M 参数表示制作 JAR 包的时候不添加 MANIFEST 清单，那么只需要在指定目标 JAR 文件的地方将 .jar 扩展名改为 .zip 扩展名，创建的就是一个不折不扣的 ZIP 文件了，如将上一节的第 3) 个例子略作改动：

jar cvfM test.zip test

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title></title>
<script src="jquery-1.2.6.js" type="text/javascript"></script>
<style type="text/css">
#openwin{width: 300px; font-size: 12px; border: 1px solid rgb(112, 156, 210);}
.hd{background: #709cd2; padding: 5px 2px; color: #fff; border: 1px solid #fff;}
h2{ margin: 0; padding: 0; font-size: 14px;}
.closewin{float: right; width: 18px; background: url(dialogclose.gif) left center; height: 17px;}
p{margin: 0; padding: 5px 6px; text-indent: 2em;}
</style>
<script type="text/javascript">
<!--
$.fn.extend({
drag: function(parent, limit, sFunc, mFunc, eFunc){//limit range, start handler, moving handler, end handler
return this.each(function(){
var _this = parent ? this.parentNode : this;
if($.browser.msie) {
this.onselectstart = function(){return false};
if($(_this).css("backgroundColor") == "transparent")_this.style.background = "#fff";
}
if($.browser.mozilla) this.style.MozUserSelect = 'none';
this.style.cursor = "move";
$(this).mousedown(function(e){
sFunc && sFunc.call(_this);
var offset = $(_this).offset();
var screenX = e.screenX, screenY = e.screenY, w = _this.offsetWidth, h = _this.offsetHeight;
$(document).mousemove(function(e2){
if($.browser.msie && e.which != 1) return ($(document).unbind(), eFunc.call(_this));
var curLeft = offset.left + e2.screenX - screenX, curTop = offset.top + e2.screenY - screenY;
if(!limit) limit = {minX: -20000, maxX: 20000, minY: -20000, maxY : 20000};
curLeft = curLeft < limit.minX ? limit.minX : ((curLeft + w) > limit.maxX ? (limit.maxX - w) : curLeft);
curTop = curTop < limit.minY ? limit.minY : ((curTop + h) > limit.maxY ? (limit.maxY - h) : curTop);
$(_this).css({position: "absolute", left: curLeft, top: curTop});
if($.browser.msie && _this.tagName == "IMG") e2.preventDefault();
mFunc && mFunc.call(_this);
});
$(document).mouseup(function(){
$(document).unbind();
eFunc && eFunc.call(_this);
});
if(this.tagName == "IMG") e.preventDefault();
});
});
}
});
$(function(){
$(".hd").drag(true);
});
//-->
</script>
</head>
<body>

<div id="openwin">
<div class="hd">
<div class="closewin"></div>
<h2>窗口名字</h2>
</div>
<div id="bd">
<p>福建炼厂PP装置现产拉丝T30S，今日挂牌价普降1500元/吨。最新拉丝T30S挂牌价7500元/吨，膜料T36F挂牌价7500元/吨。厂家销售正常。</p>
</div>
</div>
<img align="absmiddle" src="dialogclose.gif" />
</body>
</html>

<button onclick="AddText(123)">add</button>
<textarea id="test" rows="10" cols="100"></textarea>
<script type="text/javascript">
<!--
function AddText(txt) {
obj = document.getElementById("test");
selection = document.selection;
obj.focus();
if (typeof obj.selectionStart != "undefined") {
var opn = obj.selectionStart + 0;
obj.value = obj.value.substr(0, obj.selectionStart) + txt + obj.value.substr(obj.selectionEnd);
} else if (selection && selection.createRange) {
var sel = selection.createRange();
sel.text = txt;
sel.moveStart("character", -txt.length);
} else {
obj.value += txt;
}
}
//-->
</script>

Example:



<#macro do_twice>
1. <#nested>
2. <#nested>
</#macro>
<@do_twice>something</@do_twice>




Output:



1. something
2. something





The nested directive can create loop variables for the nested content. For example:



<#macro do_thrice>
<#nested 1>
<#nested 2>
<#nested 3>
</#macro>
<@do_thrice ; x>
${x} Anything.
</@do_thrice>




This will print:



1 Anything.
2 Anything.
3 Anything.





A more complex example:



<#macro repeat count>
<#list 1..count as x>
<#nested x, x/2, x==count>
</#list>
</#macro>
<@repeat count=4 ; c, halfc, last>
${c}. ${halfc}<#if last> Last!</#if>
</@repeat>




The output will be:



1. 0.5
2. 1
3. 1.5
4. 2 Last!

<div onmouseover="eval(str);" onmouseout="eval(str2);" id="ddd" style="border: 1px solid green; position: absolute; left: 100px; top: 10px; width: 100px; height: 30px; background: yellow;">

</div>
<script type="text/javascript">
<!--
var o = document.getElementById("ddd");
var str ='Move({\
obj: o,\
Begin: { top : o.offsetTop, left : o.offsetLeft, width : o.offsetWidth, height : o.offsetHeight},\
End: { top : o.offsetTop, left : o.offsetLeft, width : 300 ,height : 200}\
})';
var old = {width: o.offsetWidth, height: o.offsetHeight};
var str2 ='Move({\
obj: o,\
Begin: { top : o.offsetTop, left : o.offsetLeft, width : o.offsetWidth, height : o.offsetHeight},\
End: { top : o.offsetTop, left : o.offsetLeft, width : old.width ,height : old.height}\
})';
function Move(o) {
if(o.obj.t) clearTimeout(o.obj.t);
var goon = false;
var Time = o.Time || 10;
for (var i in o.End) {
var step = 0, neg = false;
var temp = o.End[i] - o.Begin[i];
if (temp == 0) continue;
if (temp < 0) {
neg = true;
temp = -temp;
}
step = temp < 4 ? 1 : temp >> 2;
if (step == 0){
o.obj.style[i] = o.End[i] + "px";
continue;
}
if (neg) step = -step;
o.obj.style[i] = (o.Begin[i] += step) + "px";
goon = true;
}
if (!goon) {
o.obj.t = null;
o.obj = null;
o = null;
return;
}
o.obj.t = setTimeout(function() {
Move(o);
}, Time)
}
//-->
</script>

/*
* FileName:
* Author: Asfman
* Date:
* Contact: http://jsframework.cn
* parameter:
* Need js:
*/
function StayPosition(speed)
{
this.objs = [];
this.speed = speed || 0.1;
this.timer = this.round = this.obj = this.end = null;
if(StayPosition.initialize !== true){
function correct(func, obj){
return function(){
func.call(obj);
}
}
StayPosition.prototype.start = function(){
this.timer = setInterval(correct(this.run, this), 33);
}
StayPosition.prototype.stop = function(){
clearInterval(this.timer);
}
StayPosition.prototype.capitalize = function(prop){return prop.replace(/^[a-z]/, function(a){return a.toUpperCase();})}
StayPosition.prototype.add = function(dom, prop){
var offset = prop ? "offset" + this.capitalize(prop) : "offsetTop";
var scroll = prop ? "scroll" + this.capitalize(prop) : "scrollTop";
prop = prop ? prop : this.offset.slice(6).toLowerCase();
this.objs.push({"dom": dom, "prop": {"size": dom[offset], "name": prop, "offset": offset, "scroll": scroll}});
}
StayPosition.prototype.run = function(){
for(var i = 0, l = this.objs.length; i < l; i++){
this.obj = this.objs[i];
this.end = (document.documentElement[this.obj.prop.scroll] || document.body[this.obj.prop.scroll]) + this.obj.prop.size;
if(this.end != this.obj.dom[this.obj.prop.offset]){
this.round = this.end - this.obj.dom[this.obj.prop.offset] > 0 ? Math.ceil : Math.floor;
this.obj.dom.style[this.obj.prop.name] = this.obj.dom[this.obj.prop.offset] + this.round((this.end - this.obj.dom[this.obj.prop.offset]) * this.speed) + "px";
}
}
}
}
StayPosition.initialize = true;
}

globalStorage

这个也是html5中提出来，在浏览器关闭以后，使用globalStorage存储的信息仍能够保留下来，并且存储容量比IE的userdata大得多，一个域下面是5120k。和sessionStorage一样，域中任何一个页面存储的信息都能被所有的页面共享。
作用域

globalStorage['z.baidu.com'] 所有z.baidu.com下面的页面都可以使用这块空间
globalStorage['baidu.com'] 所有baidu.com下面的页面都可以使用这块空间
globalStorage['com']：所有com域名都可以 共享的使用这一块空间
globalStorage[''] ：所有页面都可以使用的空间

现在Firefox只支持当前域下的globalStorage存储， 如果使用公用域会导致一个这样一个类似的错误“Security error” code: “1000”。
过期时间

按照HTML5的描述，globalStorage只在安全问题或者当用户要求时才会过期，浏览器应该避免删除那些正在被脚本访问的数据，并且userdata应该是用户可写的。

因此我们的脚本要能够控制过期时间，可以在globalStorage的某个区域存储过期时间，在load的时候判断是否过期，可以在一定程度上解决过期时间的问题。

存储时，同时存储过期时间
Save = function(content, expires, attribute, fileName){
var date = new Date();
date.setSeconds(date.getSeconds() + expires);
globalStorage[domain][fileName + "__expires"] = date.getTime();
}
Load时判断是否过期，过期则删除：
Load = function(attribute, fileName){
var date = new Date();
if(parseInt(globalStorage[domain][fileName + "__expires"]) < parseInt(date.getTime()) ){
d.Remove(attribute, fileName);
d.Remove(attribute, fileName + “__expires”);
}
return globalStorage[domain][fileName + attribute];
}
一个客

<div id="wrapper">
<div id="nav">

<h1><img src="http://images.china-pub.com/ebook35001-40000/39954/zcover.jpg" width="144" height="200" alt="JavaScript王者归来" /></h1>


<ul>
<li><a href="#synopsis">内容简介</a></li>
<li><a href="#about">关于作者</a></li>
<li><a href="#catalog">目录</a></li>
<li><a href="#foreword">前言</a></li>

<li><a href="#comment">网友评论</a></li>
<li><a href="#read">样章试读</a></li>
<li><a href="#buy">在线购买</a></li>
<li><a href="#download">例子下载</a></li>
<li><a href="#correction">勘误表</a></li>
</ul>

</div>
<ul id="book">
<pre></pre>
</ul>
</div>

第二次:修饰符

2.1 访问控制
封装将数据和处理数据的代码连接起来。同时，封装也提供了另外一个重要属性：访问控制。通过封装你可以控制程序的某个部分可以访问类的成员，防止对象的滥用，从而保护对象中数据的完整性。对于所有的面向对象的语言，比如C++，访问控制都是一个很重要的方面。由于Java语言使用了包的概念，使它的访问控制相对来说更复杂一些。我们把控制访问控制权限的修饰符主要分为两类，类和它的方法及变量，下面我们分别简单介绍。

-类的访问控制

->; Default：当类不使用任何访问控制修饰符时，即采用的默认的访问控制权限。它允许同一个包内的类访问，而对于它所在包以外的类则不能访问。

->; Public：允许任何包中的任何类访问，对Java里面的所有类开放。

-方法和变量的访问控制

->; Public：所有类均可以访问。

->; Private：只能被它所在的类中的成员访问，使该定义的成员对外在的类不可见。

->; Protected：可以被同一个包的类访问，另外其所有子类也可以访问。

->; Default：当成员不使用任何访问控制修饰符时，即采用默认的访问控制权限。它和Protected类似，唯一的区别在于子类访问权限，它仅允许同一个包的子类访问，而其他包中的子类则不可以访问。

2.2 其他修饰符
除了访问控制修饰符，Java还有其他繁多的修饰符来声明类、方法和变量，下面分别针对所修饰的对象来简单介绍一下主要的修饰符。

-类修饰符

->; final：用来指定该类不能被其他类扩展，从而阻止继承。

->; abstract：表示该类是不允许被实例化的类，也就是说该类需要被扩展继承。被这样声明的类也称为抽象类。

显而易见，final和abstract不能同时使用。

-方法修饰符

->; abstract：被声明的方法称为抽象方法，不含任何代码，需要其继承的子类的相应方法覆盖重载。这里需要注意的是被声明有abstract方法的类必须被声明为abstract。

->; final：声明的方法不允许被覆盖重载。

->; static：声明的方法被成为类方法，不依赖于任何的对象，不需要实例化对象即可直接使用类名来调用该方法。注意的是在该方法体内不可访问实例变量。

->; 变量修饰符

->; static：被声明为static的变量实际可以看作就是全局变量，同样不需要实例化对象即可直接使用类名来引用之。

->; final：被声明的变量的内容不可以被修改，实际可以被看作是一个常量，类似于C或者C++中的const。

2.3 缺省构造函数
我们都知道当对象被实例化的时候，构造函数总是被调用。如果我们在定义类的时候不指定一个构造函数，Java会自行创建一个不带参数的缺省构造函数。而如果我们定义有了一个构造函数，则Java不会再创建缺省构造函数。

更值得注意的是，如果子类的超类不含有不带参数的构造函数，那么子类在使用缺省构造函数就会出错，Java不会为子类创建不带参数的缺省构造函数。因此，我们在使用缺省构造函数的时候要比较小心。我们可以看如下的例子：


class Fruit {

public Fruit ( String color ) {

System.out.print ( “color = ” + color ) ;

}

}

class Apple extends Fruit {

public static void main ( String [ ] args ) {

Apple m = new Apple () ;

}

}
运行结果出错：

Fruit.java:6: No constructor matching Fruit ( ) found in class Fruit .

Class Apple extends Fruit {

1 error

2.4 合法的返回类型
由于在方法调用的时候，方法返回的类型有可能与实际声明的类型不同，因此我们需要关心什么样的返回类型才是合法的。实际上，系统采用了隐式的类型转换来处理类型的返回。以下几种情况的是合法的：

->; 如果声明的是浮点类型，那么可返回整型类型。

->; 如果声明的是整型类型，那么只要返回的整型类型范围小于或等于声明的类型，返回合法。

->; 如果声明的是对象类型，那么只要返回的是该对象类型，或者是其子类的对象类型，合法。

ie6能识别_ ie7 ff不行

<job>
<script>
var oConn = new ActiveXObject("Adodb.Connection");
oConn.Open("Provider=Microsoft.Jet.Oledb.4.0; Data Source=customer2.mdb");
oConn.Execute("create table asfman(id counter IDENTITY PRIMARY KEY, name varchar(10))");
WSH.Echo("OK");
oConn.Close();
oConn=null;
</script>
</job>

<job>
<script>
var oCat=new ActiveXObject('adox.catalog');
var oTbl=new ActiveXObject('adox.table');
oCat.Create("Provider=Microsoft.Jet.Oledb.4.0;Data Source=create.mdb");
with(oTbl){
Name='Customers'; // table name
ParentCatalog=oCat;
Columns.Append('id', 3); // integer
Columns('id').Properties('AutoIncrement')=true;
Columns.Append('area', 202, 150); // memo
Columns.Append('company', 202, 250); // memo
Columns.Append('type', 202, 150); // memo
}
oCat.Tables.Append(oTbl);
WSH.Echo("OK");
oTbl=null;
oCat=null;
</script>
</job>

注：IE都能识别*;标准浏览器(如FF)不能识别*；
IE6能识别*，但不能识别 !important,
IE7能识别*，也能识别!important;
FF不能识别*，但能识别!important;

Array.prototype.push=function()
{
var l=arguments.length;
for(var i=0;i<l;i++)
{
this[this.length++]=arguments[i];
}
}

function setArray(obj, elems)
{
obj.length = 0;
Array.prototype.push.apply(obj, elems);
return obj;
}

EditPlus是一套功能非常强大的文字编辑器，拥有无限制的Undo/Redo（撤销）、英文拼字检查、自动换行、列数标记、搜寻取代、同时编辑多文 件、全屏幕浏览功能。而它还有一个好用的功能，就是它有监视剪贴簿的功能，能够同步于剪贴簿自动将文字贴进EditPlus的编辑窗口中，让你省去做贴上 的步骤。另外它也是一个好用的程序代码编辑器，除了支持HTML, CSS, PHP, ASP, Perl, C/C++, Java, JavaScript, VBScript的代码高亮外，还内建完整的HTML和CSS指令功能，对于习惯用记事本编辑网页的朋友，它可帮你节省一半以上的网页制作时间，若你有安 装IE 3.0以上版本，它还会结合IE浏览器于EditPlus窗口中，让你可以直接预览编辑好的网页(若没安装IE，也可指定浏览器路径)。
它有以下几项突出的优点：
1. 启动速度快。这几乎是最令人欣赏的一项特性 ，我知道 UltraEdit 是一个功能极其丰富而且强大的编辑器，但它的启动速度太慢了，我没理由为打开一个寥寥数行的文本文件等上好几秒。

2. 界面简洁。这也是非常令人欣赏的特性，www.x-force.cn也许某些比较 Geek 的用户会对庞杂而丰满的程序主菜单仰慕不已，但我并不愿意为了一些并不常用的功能牺牲眼前电脑屏幕上更多的空间，正相反，我喜欢“Keep it simple, stupid”的界面设计，能用，够用就好。

3. 完善的代码高亮。最近一直使用的是 EmEditor 6.0，但在编写 Perl 脚本时，我发现 EmEditor 的语法高亮有一定问题，它甚至不能正确识别 =comment ... =cut 这样的 Perl 注释语句。而在 EditPlus 下，这种注释被支持得非常好。还有就是在EmEditor下，经常出现多个双引号高亮错误的情况，还以为自己写错代码了……

4. 代码折叠功能。 这个功能在 EditPlus 版之前似乎没有提供，但现在已经有了，而且效果不错，至少比 EmEditor 的强很多。从我迷上玩博客以后，常常为分析 HTML/CSS 模版代码感到疲惫，因为必须把网页元素间的内在结构搞清楚才能有效地控制它们的显示效果。我以前的一篇文章曾经提到 用 Notepad++ 内置的代码折叠功能分析网页源码，不过说实话那个开源软件的确有很多需要改进的地方，尤其是中文支持方面远不如 EditPlus，EmEditor 这类商业软件。

5. 多文档编辑界面。 这是个比较细节的特性，在 EmEditor 中，如果把最后一篇活动文档关闭，则主程序也会随之关闭，这给我带来了一些不便。尤其是当我希望创建新的空白文档时，我不得不在开始菜单中重新启动编辑 器。而在 EditPlus 中，只要不点击最右上角的关闭按钮，编辑器始终是打开状态，我个人认为这样更方便一些。除此之外，在界面外观设计上 EditPlus 也有很多过人之处，我不能很好地将这种独特的属性描述出来，但我可以做一个比喻，如果把各种文本编辑器都看作一个美女的话，EditPlus 就属于那种苗条纤巧，落落大方的类型，相比之下 EmEditor 则略显富态，而 UltraEdit 简直就是肥婆了。
EditPlus 使用技巧集萃

【1】正则表达式应用——替换指定内容到行尾
原始文本如下面两行
abc aaaaa
123 abc 444

希望每次遇到“abc”，则替换“abc”以及其后到行尾的内容为“abc efg”
即上面的文本最终替换为：
abc efg
123 abc efg

解决：
① 在替换对话框，查找内容里输入“abc.*”
② 同时勾选“正则表达式”复选框，然后点击“全部替换”按钮
其中，符号的含义如下：
“.” ＝匹配任意字符
“*” ＝匹配0次或更多

注意：其实就是正则表达式替换，这里只是把一些曾经提出的问题加以整理，单纯从正则表达式本身来说，就可以引申出成千上万种特例。

【2】正则表达式应用——数字替换 （Microshaoft@CCF,jiuk2k@CCF）
希望把
asdadas123asdasdas456asdasdasd789asdasd
替换为:
asdadas[123]asdasdas[456]asdasdasd[789]asdasd

在替换对话框里面，勾选“正则表达式”复选框；
在查找内容里面输入“[0-9][0-9][0-9]”，不含引号
“替换为:”里面输入“[\0\1\2]”，不含引号
范围为你所操作的范围，然后选择替换即可。

实际上这也是正则表达式的使用特例，“[0-9]”表示匹配0～9之间的任何特例，同样“[a-z]”就表示匹配a～z之间的任何特例
上面重复使用了“[0-9]”，表示连续出现的三个数字
“\0”代表第一个“[0-9]”对应的原型，“\1”代表第二个“[0-9]”对应的原型，依此类推
“[”、“]”为单纯的字符，表示添加“[”或“]”，如果输入“其它\0\1\2其它”，则替换结果为：

asdadas其它123其它asdasdas其它456其它asdasdasd其它789其它asdasd

功能增强（by jiuk2k@CCF）：
如果将查找内容“[0-9][0-9][0-9]”改为“[0-9]*[0-9]”，对应1 或 123 或 12345 或 ...
大家根据需要定制

相关内容还有很多，可以自己参考正则表达式的语法仔细研究一下

【3】正则表达式应用——删除每一行行尾的指定字符
因为这几个字符在行中也是出现的,所以肯定不能用简单的替换实现
比如
12345 1265345
2345
需要删除每行末尾的“345”
这个也算正则表达式的用法，其实仔细看正则表达式应该比较简单，不过既然有这个问题提出，说明对正则表达式还得有个认识过程，解决方法如下
解决：
在替换对话框中，启用“正则表达式”复选框
在查找内容里面输入“345$”
这里“$”表示从行尾匹配

如果从行首匹配，可以用“^”来实现，不过 EditPlus 有另一个功能可以很简单的删除行首的字符串
a. 选择要操作的行
b. 编辑－格式－删除行注释
c. 在弹出对话框里面输入要清除的行首字符，确定

【4】正则表达式应用——替换带有半角括号的多行
几百个网页中都有下面一段代码：
<script LANGUAGE="JavaScript1.1">
<!--
htmlAdWH('93163607', '728', '90');
//-->
</SCRIPT>
我想把它们都去掉，可是找了很多search & replace的软件，都是只能对“一行”进行操作。

EditPlus 打开几百个网页文件还是比较顺畅的，所以完全可以胜任这个工作。
具体解决方法，在 Editplus 中使用正则表达式，由于“(”、“)”被用做预设表达式（或者可以称作子表达式）的标志，所以查找
“<script LANGUAGE="JavaScript1.1">\n<!--\nhtmlAdWH('93163607', '728', '90'.);\n//-->\n</SCRIPT>\n”
时会提示查找不到，所以也就无法进行替换了，这时可以把“(”、“)”使用任意字符标记替代，即半角句号：“.”。替换内容为
<script LANGUAGE="JavaScript1.1">\n<!--\nhtmlAdWH.'93163607', '728', '90'.;\n//-->\n</SCRIPT>\n
在替换对话框启用“正则表达式”选项，这时就可以完成替换了

补充：（lucida@DRL）
对( ) 这样的特殊符号，应该用\( \)来表示，这也是很标准的regexp语法，可以写为
<script LANGUAGE="JavaScript1.1">\n<!--\nhtmlAdWH\('93163607', '728', '90'\);\n//-->\n</SCRIPT>\n

【5】正则表达式应用——删除空行
启动EditPlus，打开待处理的文本类型文件。
①、选择“查找”菜单的“替换”命令，弹出文本替换对话框。选中“正则表达式”复选框，表明我们要在查找、替换中使用正则表达式。然后，选中“替换范围”中的“当前文件”，表明对当前文件操作。
②、单击“查找内容”组合框右侧的按钮，出现下拉菜单。
③、下面的操作添加正则表达式，该表达式代表待查找的空行。（技巧提示：空行仅包括空格符、制表符、回车符，且必须以这三个符号之一作为一行的开头，并且以回车符结尾，查找空行的关键是构造代表空行的正则表达式）。
直接在"查找"中输入正则表达式“^[ \t]*\n”，注意\t前有空格符。
（1）选择“从行首开始匹配”，“查找内容”组合框中出现字符“^”，表示待查找字符串必须出现在文本中一行的行首。
（2）选择“字符在范围中”，那么在“^”后会增加一对括号“[]”，当前插入点在括号中。括号在正则表达式中表示，文本中的字符匹配括号中任意一个字符即符合查找条件。
（3）按一下空格键，添加空格符。空格符是空行的一个组成成分。
（4）选择“制表符”，添加代表制表符的“\t”。
（5）移动光标，将当前插入点移到“]”之后，然后选择“匹配 0 次或更多”，该操作会添加星号字符“*”。星号表示，其前面的括号“[]”内的空格符或制表符，在一行中出现0个或多个。
（6）选择“换行符”，插入“\n”，表示回车符。
④、“替换为”组合框保持空，表示删除查找到的内容。单击“替换”按钮逐个行删除空行，或单击“全部替换”按钮删除全部空行（注意：EditPlus有时存在“全部替换”不能一次性完全删除空行的问题，可能是程序BUG，需要多按几次按钮）。

【6】软件技巧——键盘记录的注意事项
EditPlus 的键盘记录有些类似于 UltraEdit 的宏操作，不过功能相对单一，录制的文件可编辑性较差。
由于基本无法编辑录制的文件，所以录制的时候为了避免录制失败，推荐纯粹使用键盘操作，以下是比较关键的几个键盘组合：
Ctrl+F ＝ 调出查找对话框
Ctrl+H ＝ 调出替换对话框
Alt+F4 ＝ 关闭作用，比如，关闭查找对话框、关闭替换对话框，等等
其它键盘快捷键在“帮助－快捷键列表”里面可以很容易的查找到，这里就不细说了。

【7】软件技巧——关闭文档标签的便捷方法
右键单击文档标签工具条，弹出菜单中选择“标签选项”，选中“用鼠标中间的按钮关闭”，这里包括鼠标的滚轮。

【8】软件技巧——如何去掉 EditPlus 保存文本文件时的添加后缀提示？
如果你使用 EditPlus 进行文本编辑，那么每次创建文本文件，编辑后保存时，尽管文件类型下拉列表中显示的是文本文件， EditPlus 还是询问你是否添加".txt"后缀，是不是很烦？
解决方法:
① 在程序目录建立一个空的文件“template.txt”
② “工具－参数设置－模板”里面，单击“添加”按钮添加模板，“菜单文本”这里输入“Text”，浏览“template.txt”，之后确定即可
③ “文件－新建－text”，就可以建立一个空的文本文件，保存时，这个文件自动带有扩展名".txt"，也就避免了令人头疼的确认
④ 模板设置文件名称为“template.ini”，如果和主程序同一路径，可以使用相对路径
罗嗦了点，不过管用
要自动创建带有某种后缀的文件，方法同上。

【9】软件技巧——提示找不到语法文件 *.stx 的解决办法
原因多为设置的语法文件不存在或者是路径设置不对。这是因为 EditPlus 的语法是设置文件采用的是绝对路径，而在你设置了语法文件之后，再把程序复制到其它目录，因而导致 EditPlus 无法找到该语法文件。
解决办法：
在主程序目录里，找到 Setting.ini 这是 EditPlus 存放语法的文件
查找后缀为“.stx”、“acp”的文本内容，或者查找带有驱动器符号的行，比如
Syntax file=C:\Program Files\EditPlus 2\cpp.stx
那么，就把”C:\Program Files\EditPlus 2\“替换成你当前软件的路径。
其它提示找不到文件的解决方法同上

【10】软件技巧——设置editplus支持其它文字，如韩文
在editplus里打开文件，出来打开文件对话框；然后点击“转换器”后面的那个省略号，会出来自定义转换器对话框；在右边选择你需要的编码方式，添加到左边，然后点确定；最后在下拉框中选择需要的编码方式，然后打开文件即可。

【11】软件技巧——FTP 上传的设置
“文件->远程操作->FTP 上传”在“设置”选项卡中设置好参数（“子目录”前面应该加“/”如“/web/”），点击“确定”回到“FTP 上传”选项卡，然后点击“上传”即可；“批量上传”的设置类似。

【12】软件技巧——如何禁用备份文件功能？
在“参数选择”的文件选项页，禁用“'保存时自动创建备份文件”选项

【13】软件技巧——添加语法文件、自动完成文件、以及剪辑库文件
要添加 *.STX（语法文件）或 *.ACP（自动完成文件）：
1. 选择“参数选择→语法”
2. 单击“添加”按钮，命名，在“扩展名”部分输入对应扩展名（不带“.”）
3. 浏览/输入 STX（语法文件部分） 以及 ACP（自动完成文件部分）。
添加剪辑库文件（*.CTL）
复制相应 *.CTL 文件到软件安装目录，重新启动 EditPlus ，则系统自动识别。

作者主页有很多语法自动完成文件下载，地址
http://editplus.com/files.html">http://editplus.com/files.html

【14】工具集成——编译器集成例子（Java、Borland C++、Visual C++、Inno Setup、nsis）
在“工具→参数选择→用户工具”选项页设置，设置步骤
① 设置组名称，这里也可以不设置
② 单击“添加工具→应用程序”按钮并进行如下设置
③ 各种类似"$(FilePath)"的参数可以在文本框右侧的箭头下拉菜单中获取，具体含义如下
参数 描述
$(FilePath) 文件路径（文件全名，含目录和文件名）
$(FileDir) 文件目录（不带文件名）
$(FileName) 文件名（不带目录）
$(FileNameNoExt) 不带扩展名的文件名（不带目录）
$(FileExt) 扩展名（当前文件）
$(ProjectName) 工程名称（当前工程名）
$(CurLine) 当前行号（光标位置处的行号）
$(CurCol) 当前列号（光标位置处的列号）
$(CurSel) 当前文本（插入当前选定文本）
$(CurWord) 当前单词（插入当前单词）
$(WindowList) 显示当前窗口列表并选择特定文件


例子 1. Java 编译器

菜单文本：Java 编译器
命令：c:\java\bin\javac.exe
参数："$(FilePath)"
初始目录：$(FileDir)
捕获输出：开启

要运行已编译的 Java 类文件，你可以进行如下设置：
菜单文本：Java
命令：c:\java\bin\java.exe
参数：$(FileNameNoExt)
初始目录：$(FileDir)
“命令”部分应当替换为实际的 Java 解释器的路径。

例子 2. Borland C++

菜单文本：Borland C
命令：c:\bc\bin\bcc32.exe
参数：-Ic:\bc\include -Lc:\bc\lib -n$(FileDir) $(FilePath)
初始目录：c:\bc\bin
捕获输出：开启

例子 3. Visual C++

菜单文本：Visual C++
命令：c:\msdev\vc98\bin\cl.exe
参数："$(FilePath)"
初始目录：$(FileDir)
捕获输出：开启

例子 4. Inno Setup
菜单文本：编译 Inno
命令：C:\Program Files\Inno Setup 4\Compil32.exe”
参数：/cc $(FileName)
初始目录：$(FileDir)
捕获输出：开启

例子 5. nsis
菜单文本：编译 nsis
命令：C:\NSIS\makensis.exe
参数：$(FileName)
初始目录：$(FileDir)
捕获输出：开启

例子 6. C#
菜单文本：编译 C#
命令：C:\WINDOWS\Microsoft.NET\Framework\v1.0.3705\csc.exe
参数：$(FileName)
初始目录：$(FileDir)
捕获输出：开启

在上面设置中，在命令部分，必须使用系统中各自编译器的绝对路径。

设置完毕后，你可以在“工具”菜单运行对应工具了，运行结果会显示在底部的输出窗口，你也可以通过快捷键(Ctrl + 0-9) 运行，或者是通过“用户工具栏”的快捷按钮运行。

要运行已编译的 *.exe 文件，你可以进行如下设置（此时可执行文件需要和编译文件同名）：
菜单文本：Run
命令：$(FileNameNoExt)
参数：
初始目录：$(FileDir)

【15】工具集成—— 让Editplus调试PHP程序
1:打开Editplus，选择"工具->配置用户工具..."菜单。
2: 在弹出的窗口中选择"添加工具->应用程序",给新程序起一个好记的名字，比如这里我们用"Debug PHP",在"菜单文本"中输入"Debug PHP"。点击"命令行"右边的按钮,找到你的php.exe所在的路径，例如这里是"c:\php\php.exe"。再点击"参数"右边的下拉按钮选 择"文件路径",最后再把"捕获输出"前面的复选框选上。
3:现在测试一下，新建一个php文件，按快捷键Ctrl+1可以激活刚才我们设置的工 具(如果你设置了多个工具,快捷键可能会有所不同),现在你可以看到它已经能正常工作了。但是还有一点不太理想:如果你的PHP程序出错,在输出窗口会提 示你第几行出错 ,单击这一行提示,Editplus老是提示你找不到某某文件，是否新建。接下下我们要修正这个功能。
4:打开刚才用户工具设置 窗口，找到刚才设置的"Debug PHP"工具。点击"捕获输出"复选框旁边的"输出模式"按钮,会弹出一个定义输出模式的窗体，把"使用默认输出模式"前面的复选框去掉, 在"正则表达式"这一项的文本框中输入" ^.+ in (.+) line ([0-9]+) "(不包括引号),细心的朋友可能会发现，这里使用的也正则表达式的语法。然后，在下面的"文件名"下拉菜单中选择"预设表达式 1"，即上边正则表达式中的第一个参数,"行"下拉菜单项选择"预设表达式 2"，"列"下拉项保持为空。然后保存设置。
5:好了，现在再来试一下吧，双击出错的行数，Editplus就会自动激活出错文件，并把光标定位到出错行,是不是特别方便呢?!
现在,Editplus经过我们的"改造",已经可以即时的调试PHP文件了，虽然还不是"可视化"界面的，但对于一些平常的小程序来查错还是非常好用的。Editplus真是不款不可多得的好工具，如果你有什么使用技巧，不要忘了大家一起分享哦。^O^

如果不能切换错误行号，请尝试作如下修改： （by aukw@CCF）
1.php.ini 中html_errors = Off打开
//如果你不打开，3.中的表达式要修改
2.参数改成：-q -f "$(FilePath)"
//不加"符号的话文件名有空格的文件调试失败。。
//-q不输出html头信息，你去掉也行，不过调试时候你一般用不到那些header信息
3." ^.+ in (.+) line ([0-9]+) " 改成 "^.+ in (.+) on line ([0-9]+)$"
//如果还是不行，请注意调试结果，自己修改表达式来取出文件名和行号

【16】工具集成——打造 PHP 调试环境(二)
1: 把剪辑库定位在 PHP4 Functions 上就可以在编辑时, 利用[插入]->[匹配剪辑]命令,就可以自动完成末输入完整的 PHP 函数(或直接按 F2 键)
2: 类似上面,在选择部分文字后,同样可以自动完成。(同 F2)
3: 在[参数选择]->[设置和语法]->PHP->自动完成, 选择目录下的 php.acp 文件,你可以定制自己的自动完成方式.
4: 想要即时预览文件,可在[参数选择]->[工具]->WEB 服务器中添加本地目录，(注意不要加 http:// , 应是一个有效的站点)。
如: 主机->localhost/php | 根目录->D:\php
主机->localhost/asp |www.x-force.cn根目录->D:\asp
主机->localhost/cgi | 根目录->D:\cgi
完成设置后只要脚本文件位于这些目录下(子目录也没问题), 就能够正确解释.
5: 各种语法和模板文件可以在 http://editplus.com/files.html">http://editplus.com/files.html 获得，可根据需要选用和编辑。
6: Ctrl+F11 可显示当前文件中的函数列表.
7: 添加各种用户工具.如:
启动MYSQL服务器管理工具->C:\mysql\bin\winmysqladmin.exe
启动Apache服务器->C:\Apache\bin\Apache.exe -k start
启动Apache服务器->C:\Apache\bin\Apache.exe -k stop (shutdown)
8: DBG 附带有一个 prof_results.php 文件,可剖析 PHP 程序的性能.
虽不是真正的调试器,但已经够了.
OK! 经过改造后,是不是有点象一个 IDE 什么?还差点,没有即时帮助...看我的,再来:
9: 把 php_manual_en.chm (最好是扩展帮助手册)加入到用户工具中, 当遇到需要参考的关键字时, 把光标定位其上, 按下快捷键 Ctrl+1, 看到了吗.
在输入时有想不起来的函数名时, 先按照第 1 条的方法调出函数, 然后...怎么样?

以上有的是对于调试工具的设置，由于此类工具比较多，大家设置时参考以上的基本就差不多了，所以就不过多的列举了。

【17】在 WINPE 中集成 EDITPLUS
可以基于目前的bartpe做得WINPE中，菜单使用nu2menu制作

默认位置为 \programs\editplus\
默认系统位置为光盘的 i386 目录

i386/system32 的 autorun.bat 中添加外壳集成（系统右键）
regedit /s %SystemDrive%\programs\editplus\REG.REG
regsvr32 /s \programs\editplus\EPPSHELL.DLL
（reg.reg保存了epp的工具栏信息，当然注册用户也可以放置注册信息）

复制editplus安装包里面的文件到programs\editplus\，注意，如果有setting.ini，删掉该文件，在nu2menu里面加入以下句子（可以根据需要安排位于特定菜单条目下）
<MITEM TYPE="ITEM" DISABLED="@Not(@FileExists(@GetProgramDrive()\Programs\EditPlus\editplus.exe))" CMD="RUN"
FUNC="@GetProgramDrive()\Programs\EditPlus\editplus.exe">EditPlus 文本编辑</MITEM>

【18】支持带UTF-8标记/不带UTF-8标记的文件 Lei@DRL提出并测试
这里Byte order Mark翻译为标记/文件头/标签

参数选择－文件－里面设置“支持不带有UTF-8文件头的UTF－8文件”，我这里翻译标签为UTF-8文件头，如果复选该项，应该是保存为不带标签的Utf-8，如果不复选，应该是保存成带有BOM的UTF-8。
这样就可以打开带签名的UTF-8文件，并且可以正常编辑，但是又不能打开不带签名的了，想要打开不带签名的还需要改回来...不过虽然有点麻烦，但是总算能用了

javascript:var r=0;document.onmouseover = function(){var s = event.srcElement;if(s.tagName.toUpperCase()=="IMG"){var

t=setInterval(function(){s.style.filter="progid:DXImageTransform.Microsoft.Matrix(SizingMethod='auto

expand',M11="+Math.cos(r)+",M12="+Math.sin(r)+",M21=-"+Math.sin(r)+",M22="+Math.cos(r)

+")";r+=0.1},100);s.onmouseout=function(){r=0;clearInterval(t);s.style.filter='',s.onmouseout=null};}};void(0);

<script>
Array.prototype.slice = function(s,e)
{
var ret = [];
if(!s) s = 0;
if(e > this.length || !e) e = this.length;
if(e < 0) e = this.length + e;
if(s < 0) s = this.length + s;
if(s > e){
var temp = s;
s = e;
e = s;
}
for(var i = 0, l = this.length; i < l; i++)
{
if(s <= i && e > i)
ret.push(this[i]);
}
return ret;
}
function test()
{
alert(Array.prototype.slice.apply(arguments));
}
var arr = [1,2,3,4];
alert(arr.slice(-2));
test("just"," a "," guess");
</script>

Javascript的垃圾回收机制
在Javascript中，如果一个对象不再被引用，那么这个对象就会被GC回收。如果两个对象互相引用，而不再被第3者所引用，那么这两个互相引用的对象也会被回收。因为函数a被b引用，b又被a外的c引用，这就是为什么函数a执行后不会被回收的原因。

可能只要没有对local variables的引用，就会释放内存。
所以按winter的方法可以解决泄露吧

<script>
function test(s,e){
var temp=[];
if(e>this.length|| !e)e = this.length;
if(e<0) e = this.length + e;
if(s<0) s = this.length + s;
if(s>e) {
var stemp = e;
s = e;
e = stemp;
}
for(var i=0;i<this.length;i++)
{
if(s<=i && e>=i|| s<0)
temp.push(this[i]);
}
return temp;
}
var a="abcd";
alert(test.call(a,0));
</script>

note:
在写一些html标签时需要<![CDATA[]]>包含起来，否者会出错

<%@Language=Javascript CodePage=65001%>
<%
Response.CodePage=65001;
Response.Charset="UTF-8";
%>

<(\S*?)[^>]*>.*?</\1>|<.*? />

asfman.getPosition = function(o)
{
var rObj={left:0,top:0},iBorderLeft,iBorderTop;
while(o!==document.body)
{

iBorderLeft = parseInt(asfman.getCurrentStyle(o.offsetParent,"borderLeftWidth"),10);
iBorderTop = parseInt(asfman.getCurrentStyle(o.offsetParent,"borderTopWidth"),10);
iBorderLeft = iBorderLeft ? iBorderLeft : 0;
iBorderTop = iBorderTop ? iBorderTop :0;
rObj.left+=o.offsetLeft+iBorderLeft;
rObj.top+=o.offsetTop+iBorderTop;
o=o.offsetParent;
}
return rObj;
}
asfman.flyTo = function(ops,ope,obj,speed)
{
var sX = ops.left;
var sY = ops.top;
var eX = ope.left;
var eY = ope.top;
speed = speed ? speed :20;
var r = 1;
function fly()
{
var iTimer = setInterval(function(){
if(r>20)
{
clearInterval(iTimer);
return true;
}
obj.style.left = (eX - sX)*r/20 + sX + "px";
obj.style.top = (eY- sY)*r/20 + sY + "px";
r++;
},speed);
}
return fly();
}

var isIE=(navigator.appName=="Microsoft Internet Explorer");
var asfman={};

//initialize
(function(){
var scriptNode = document.getElementsByTagName("script")[document.getElementsByTagName("script").length-1];
asfman.createDate = "2007-06-15";
asfman.lastEditDate ="2007-09-29";
asfman.author = "asfman";
asfman.path = scriptNode.src.replace(/[^\/]+$/i,"");
asfman.fileList = {};
$import("base");
if (scriptNode.getAttribute("import"))
{
$import(scriptNode.getAttribute("import"));
}
scriptNode = null;
})();

//construct main funciton
function $import(filePath)
{
var re=/[^|]+/g;
var re2;
var l,r,m,path1,path2;
while(re.test(filePath))
{
path1=RegExp.lastMatch;
if(/\((.+?)\)/.test(path1))
{
l=RegExp.leftContext;
m=RegExp.lastParen;
r=RegExp.rightContext;
path1=m.replace(/[^+]+/g,l+"$&"+r);
}
re2=/[^+]+/g;
while(re2.test(path1))
{
path2=RegExp.lastMatch;
if(!(/\.js$/.test(path2)))
{
path2 = asfman.path + path2.replace(/\./g,"/") + ".js";
}
else
{
path2=asfman.path + path2.replace(/\.(?!js$)/g,"/");
}
if(!asfman.fileList[path2])
{
document.write('<script src="'+path2+'" language="javascript"><\/script>');
asfman.fileList[path2] = true;
}
}
}
}

$import("function.(dom+createXmlhttp+json+cookie+calendar+$load+date+swfobject)|class.HighLightClass|prototype.String.(trim+urlEncode)|css.(createCss+skin)|debug");

一些常用SQL语句的总结 竖项变横项
http://blog.csdn.net/gsong/archive/2007/06/14/1652148.aspx

SQL必知必会（第3版）
http://book.csdn.net/bookfiles/394/