body
{ }{
    font-size: 12px;
    margin: 0px;
    padding: 0px;
    height: 100%;
        width: 100%;
    overflow: auto;
    text-align: center;
    display: block;
}
/**//*---body我是作为最顶层容器的---所以它具备了我需要的所有东西，实现的效果是居中，我加上了display: block;虽然这个是一个默认属性，但是我们不能保证所有浏览器都是默认，（如果是所有浏览器都默认的，我自己写个浏览器的默认为none的给你耍）*/
#body_Div
{ }{
    margin: 0px auto;
    padding: 0px;
    text-align: left;
    width: 1003px;
    height:100%;
    overflow:auto;
}
/**//*这个是核心层，多有的元素基本都是在这个层里的，这个层也具备了我想要的属性，text-align: left; 因为在上层我把文本对齐成为居中，所以这个层我要把它还原为左对齐margin: 0px auto; 一般IE的CSS编写者不会有这个auto值的，在IE会自动，但是在FF如果少了auto你将会发现FF里你的核心部分不是居中的。所以要做到通用，我们就必须要加上auto值，IE也支持auto值*/

第二：浮动对象，都拥有独立的父DIV；关于这点。。有意见的人可能不少，持有的观点就是，“你这样做只会令DIV过分的多，过于复杂”，其实，我也不想这样做，但是- -！IE对于浮动对象的{margin，padding}存在BUG所以为了减少一切可能的出错，我唯有多花费一点代码，说实在的我只是想它更健康。这个父DIV主要作用其实就是令到内部浮动对象更可控制，这个父DIV就是一个单纯的容器DIV

第三：所有的浮动都需要闭合；这个有经验的人都知道。。用完浮动你肯定需要把它闭合掉的，不闭合，可能不同浏览器在解析的时候会把你的浮动变成向下默认，（可以这样解析：就是元素内部的子元素都默认具有浮动属性）

第四：一个行向浮动如果超过3个那么请使用UL来实现浮动

第五：灵活使用类选择，我个人的做法是，所有的id选择器都是用于布局的，类选择器都是用于呈现效果的，这样做的好处就是，当你想要的效果出现问题的时候，更快速地找到错误。这个是我有意识的把“架构”和“内容”分离。

.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;%CATALINA_HOME%\lib\servlet-api.jar;
.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;D:\apache-tomcat-6.0.18\lib\servlet-api.jar

修改文件：C:\jakarta-tomcat-5.0.28\conf\server.xml

插入位置：

<Host name="localhost" debug="0" appBase="webapps"
unpackWARs="true" autoDeploy="true"
xmlValidation="false" xmlNamespaceAware="false">
     <Context path="/myapp"  docBase="C:/jakarta-tomcat-5.0.28/webapps/myapp"  debug="0" reloadable="true"/>

参考URL

http://hi.baidu.com/net_plz/blog/item/966ee6dc25f908a5cc116635.html

http://blog.163.com/jianhuren2005@126/blog/static/1715817120071015115620650/

流行的 JavaScript 库不胜枚举，jQuery, MooTools, Prototype, Dojo, YUI。这些 JavaScript 库功能丰富，加上它们的插件，几乎能胜任任何工作，然而这是有代价的，这些库往往导致你的网页尺寸臃肿。在某些场合，如果你只想完成特定的工作，可以使用一些功能更专一的轻量库，本文介绍了40个非常出色的轻量级 JavaScript 库。

这是本文的第一部分，第二部分请参阅40 个轻量级 JavaScript 库（下）。

1. 表单相关

wForms
一个低调的开源项目，简化了绝大多数常用 JavaScript 表单功能，包含可以直接使用的表单验证功能，另外，还包含强大的表单同步以及表单条件判断功能。

Validanguage
又一个低调的 JavaScript 表单验证框架。它拥有集成逻辑，一些设置可以针对全局，单个表单或单个对象。提供两个API，集成 AJAX 支持，缓存，以及回调函数。它提供类似 HTML 的 API 语句，以及面向对象的 JavaScript API 。

LiveValidation
一个轻量的表单验证库。除了传统的验证功能，还提供实时验证，可以一边输入一遍验证。Ruby on Rails 用户可能会发现这个库非常好用，因为他们的命名规则和参数十分近似。该库既有独立版本，又有一个 Prototype 版本。

yav
一个强大，灵活，可扩展的表单验证库。支持各种场合，从简单的如日期，电子邮件地址以及整数的验证，到复杂的，如正则表达式。内置 AJAX 支持，输出的错误消息可以定位到对象级。

qForms
处理表单的整套方案。功能包括各种验证规则，防止多次发布的机制，以及锁定或解锁制定输入框。

formreform
不基于 table 的多栏设计向来是一个挑战。这个微型库将传统的表单变成漂亮的多栏形式。

2. 动画相关

$fx()
一个用来让 HTML 对象运动的轻量库。你可以在一个时间轴上改变任何 CSS 属性，对于复杂动画，你可以将各种效果结合起来，将对象分组，让它们并行运动。

JSTweener
一个生成中间帧的 JavaScript 库，它的 API 类似著名的中间帧引擎 Tweener。你可以指定动画时间，定义切换效果以及时延。在几乎任何点都可以触动事件。

Facebook Animation
一个强大的，用来创建可定制的，基于 CSS 的动画。在 Facebook 动画中，几行代码就可以改善 UI。语法和 FBJS （用于 Facebook 的库）一样。

FX
一个语法类似 YUI 的轻量 JavaScript 库，可以为几乎任何 CSS 属性创建中间帧。支持颜色和滚动动画，为对象设置 to 和 from 值就可以了。

3. 视觉与图形效果

JS charts
支持柱状图，圆饼图以及简单的曲线图。直接将这个库插入网页，然后从 XML 文件或 JavaScript 数组变量调用数据。PNG 格式，兼容所有主要浏览器。

Canvas 3D JS Library (C3DL)
C3DL 使 3D 程序的编写变得简单。提供一套数学，场景与 3D 对象类，可以直接在浏览器中开发 3D 内容，不需要很深的 3D 知识。

Processing.js
这是 Processing 语言在 JavaScript 的移植。2D输出功能丰富。提供了绘图，色彩处理，字体，对象等处理函数。

Rapha?l
一个让人惊叹的 JavaScript 库，可以在 Web 上实现矢量图。使用 SVG, VML 创建的图形可以被更改或绑定事件。功能极其丰富，包括旋转，动画，缩放等。

ImageFX
该 JavaScript 库为图片添加效果，如虚化，锐化，浮雕，加亮等。ImageFX 使用画布对象实现这些效果，兼容所有主流浏览器。这个库非常容易使用，只要将 .js 库文件插入网页，调用那些函数即可。

Pixastic
Pixastic 使用 HTML5 画布对象，允许对原始像素进行操作。效果包括去饱和度，灰度级，反转，亮度，对比度调整，色调，饱和度调整，以及浮雕，虚化等效果。因为用到了 HTML 5 的画布对象，因此还无法兼容所有浏览器。

Reflection.js
一个很低调的 JavaScript 自动实现倒影效果。倒影的高度，透明度可以调整。支持所有主流浏览器，文件尺寸小于5K。

4. 数据库

Taffy DB
一个 JavaScript 库，可以看作浏览器中的 SQL Server，或高级数组管理器。在使用了 AJAX 的程序中，可以用作数据库层，可以创建，读取，编辑，删除数据，使用循环，排序以及高级查询。

ActiveRecord.js
这个库支持 Google Gears 以及 Chrome，Aptana Jaxer, Adobe AIR 以及任何支持 HTML 5 SQL 细则的平台（目前有 Webkit 以及 iPhone）。可以自动创建表，验证和同步数据。

http://www.comsharp.com/GetKnowledge/zh-CN/TeamBlogTimothyPage_K742.aspx

流行的 JavaScript 库不胜枚举，jQuery, MooTools, Prototype, Dojo, YUI。这些 JavaScript 库功能丰富，加上它们的插件，几乎能胜任任何工作，然而这是有代价的，这些库往往导致你的网页尺寸臃肿。在某些场合，如果你只想完成特定的工作，可以使用一些功能更专一的轻量库，本文介绍了40个非常出色的轻量级 JavaScript 库。

这是本文的第二部分，第一部分参见40 个轻量级 JavaScript 库 （上）。

5. 字符串与数学函数

Date.js
和日期打交道不是件容易事，有很多格式要处理。Datejs 可以很好地处理简单或复杂的日期函数。可以将日期解析出诸如“Next thursday”，“+2 years”一类的格式，也支持所有日期形式，如 2009.01.08, 12/6/2001。

Sylvester
一个处理矢量和点阵的数学 JavaScript 库，包含多维矢量和点阵建模类，以及在3D空间的一些模型。

Pretty Date
一个很出色的 JavaScript 库，用一种很漂亮，很友好的方式显示日期，如下图所示。

XRegExp
JavaScript 中的 RegExp 对象已经支持正则表达式，XRegExp 增加了更多未来浏览器可能包含的功能（ECMAScript 4 - ES4）。该库对 RegExp 对象进行缓存，重用并增加了众多新功能。

JavaScript URL Library
一个用来处理 URL 的 JavaScript 库，可以对 URL 中的任意部分进行处理。

6. Fonts

typeface.js
这个库可以让你在网页中使用任意字体，但和 sIFR 以及 FLIR 这些基于 Flash 的方案不一样，typeface.js 100% 基于 JavaScript，只需将你的字体文件上传到一个基于 Web 的生成器那里，再将生成的 JavaScript 文件下载回来包含到网页中即可。

Cufón
和 typeface.js 很相像，Cufón 也可以让你在网页中使用任意字体，同样，它也是使用一个生成器，将字体转换成 VML，将生成的 .js 文件包含到网页即可。

7. 调试与记录

Blackbird
人们经常使用 Alert() 调试 JavaScript 程序，Blackbird 提供了一个漂亮的控制台记录，查看，过滤程序的运行。

NitobiBug
基于浏览器的跨浏览器 javaScript 对象记录与检查工具。

Firebug Lite
目前最好的 JavaScript 调试工具非 Firebug 莫属，然而该工具只支持 FireFox，将 Firebug Lite .js 文件插入你的网页，就可以在所有浏览器都实现 FireBug 功能。

8. 其它

swfobject
这是一个最受欢迎的对 Flash 对象进行引用的方法。可以生成标准 swf 引用代码，并探测用户播放器版本。如果用户版本不支持，会显示备用内容。

sorttable 与 dragtable
不管你喜欢与否，table 仍然是最好的表现数据的方式，但可以更好地利用。sorttable 可以让表格数据排序，只需在 table 上加一个 class="sortable" 标志，还可以排除指定的栏。dragtable 让表格的栏可以拖动，在表格上加上 class="dragable" 标志即可，这两个类可以结合起来使用，只需加上 class="sortable dragtable" 即可。

DD_roundies 与 DD_belatedPNG
DD_roundies 可以不依赖图片实现圆角功能，只面向 IE， 通过 VML 实现，其它浏览器会被略过，因为那些浏览器本身支持 CSS 圆角。

DD_belatedPNG 是为了解决 IE6 对 PNG 支持不好问题而开发的，不管 PNG 图片用于 src 还是 background-image，DD_belatedPNG 都能提供修补。

Custom JavaScript Dialog Boxes
一个只有 4.5K 的轻量 JavaScript 库，可以创建用户定制对话框，可显示4种类型的消息框，alerts, warnings, prompts, success。可以设定消息框标题，内容，以及过多长时间显示。

GameJS
GameJS 是微软的 XNA 游戏框架在 JavaScript 上的移植，使用 canvas 对象作为输出设备。JavaScript 不是最佳游戏平台，但对那些帧率较低的游戏也没有问题。

Shortcuts.js
从 Google Reader 和 Gmail 开始，Web 程序中的快捷键开始流行起来。Shorcuts.js 让快捷键的处理变得简单。

Mapstraction
有不少地图提供商都提供不同 API，如果你要更换提供商，比如从 Google Maps 到 MapQuest，需要更新代码，Mapstraction 提供了常用地图提供商的 API，只需该一行代码就能完成转换。

Amberjack
一个只有 4K 的微型 JavaScript 库，可以为你的网站添加漂亮的教程功能，一个模式窗口会以教程的形式显示任意内容，教程中的步骤可以通过手工编码实现或在线自动生成。可以使用主题或 CSS 控制内容的格式。

JsLoad
JsLoad 可以从 Google server 远程加载各种 JavaScript 库，可以自动加载各种版本的支撑库。

　　Google的PageRank根据网站的外部链接和内部链接的数量和质量俩衡量网站的价值。PageRank背后的概念是，每个到页面的链接都是对该页面的一次投票，被链接的越多，就意味着被其他网站投票越多。这个就是所谓的“链接流行度”——衡量多少人愿意将他们的网站和你的网站挂钩。PageRank这个概念引自学术中一篇论文的被引述的频度——即被别人引述的次数越多，一般判断这篇论文的权威性就越高。

　　Google有一套自动化方法来计算这些投票。Google的PageRank分值从0到10；PageRank为10表示最佳，但非常少见，类似里氏震级（Richter scale），PageRank级别也不是线性的，而是按照一种指数刻度。这是一种奇特的数学术语，意思是PageRank4不是比PageRank3好一级——而可能会好6到7倍。因此，一个PageRank5的网页和PageRank8的网页之间的差距会比你可能认为的要大的多。

　　PageRank较高的页面的排名往往要比PageRank较低的页面高，而这导致了人们对链接的着魔。在整个SEO社区，人们忙于争夺、交换甚至销售链接，它是过去几年来人们关注的焦点，以至于Google修改了他的系统，并开始放弃某些类型的链接。比如，被人们广泛接受的一条规定，来自缺乏内容的“link farm”（链接工厂）网站的链接将不会提供页面的PageRank，从PageRank较高的页面得到链接但是内容不相关（比如说某个流行的漫画书网站链接到一个叉车规范页面），也不会提供页面的PageRank。Google选择降低了PageRank对更新频率，以便不鼓励人们不断的对其进行监测。

　　Google PageRank一般一年更新四次，所以刚上线的新网站不可能获得PR值。你的网站很可能在相当长的时间里面看不到PR值的变化，特别是一些新的网站。PR值暂时没有，这不是什么不好的事情，耐心等待就好了。

　　为您的网站获取外部链接是一件好事，但是无视其他SEO领域的工作而进行急迫的链接建设就是浪费时间，要时刻保持一个整体思路并记住以下几点：

　　·Google的排名算法并不是完全基于外部链接的

　　·高PageRank并不能保证Google高排名

　　·PageRank值更新的比较慢，今天看到的PageRank值可能是三个月前的值

　　因此我们不鼓励刻意的去追求PageRank，因为决定排名的因素可以有上百种。尽管如此，PageRank还是一个用来了解Google对您的网站页面如何评价的相当好的指示，建议网站设计者要充分认识PageRank在Google判断网站质量中的重要作用，从设计前的考虑到后期网站更新都要给予PageRank足够的分析，很好的利用。我们要将PageRank看作是一种业余爱好而不是一种信仰。

　　---------------------------------------------------------------------------------------------------------------------

　　通过对由超过 50,000 万个变量和 20 亿个词汇组成的方程进行计算，PageRank 能够对网页的重要性做出客观的评价。PageRank 并不计算直接链接的数量，而是将从网页 A 指向网页 B 的链接解释为由网页 A 对网页 B 所投的一票。这样，PageRank 会根据网页 B 所收到的投票数量来评估该页的重要性。

　　此外，PageRank 还会评估每个投票网页的重要性，因为某些网页的投票被认为具有较高的价值，这样，它所链接的网页就能获得较高的价值。重要网页获得的 PageRank（网页排名）较高，从而显示在搜索结果的顶部。Google 技术使用网上反馈的综合信息来确定某个网页的重要性。搜索结果没有人工干预或操纵，这也是为什么 Google 会成为一个广受用户信赖、不受付费排名影响且公正客观的信息来源。

　　－－－－－－－－－－－－－－－

　　其实简单说就是民主表决。打个比方，假如我们要找李开复博士，有一百个人举手说自己是李开复。那么谁是真的呢？也许有好几个真的，但即使如此谁又是大家真正想找的呢？:-) 如果大家都说在 Google 公司的那个是真的，那么他就是真的。

　　在互联网上，如果一个网页被很多其它网页所链接，说明它受到普遍的承认和信赖，那么它的排名就高。这就是 Page Rank 的核心思想。 当然 Google 的 Page Rank 算法实际上要复杂得多。比如说，对来自不同网页的链接对待不同，本身网页排名高的链接更可靠，于是给这些链接予较大的权重。Page Rank 考虑了这个因素，可是现在问题又来了，计算搜索结果的网页排名过程中需要用到网页本身的排名，这不成了先有鸡还是先有蛋的问题了吗？

　　Google 的两个创始人拉里·佩奇（Larry Page ）和谢尔盖·布林 (Sergey Brin) 把这个问题变成了一个二维矩阵相乘的问题，并且用迭代的方法解决了这个问题。他们先假定所有网页的排名是相同的，并且根据这个初始值，算出各个网页的第一次迭代排名，然后再根据第一次迭代排名算出第二次的排名。他们两人从理论上证明了不论初始值如何选取，这种算法都保证了网页排名的估计值能收敛到他们的真实值。值得一提的事，这种算法是完全没有任何人工干预的。

　　理论问题解决了，又遇到实际问题。因为互联网上网页的数量是巨大的，上面提到的二维矩阵从理论上讲有网页数目平方之多个元素。如果我们假定有十亿个网页，那么这个矩阵就有一百亿亿个元素。这样大的矩阵相乘，计算量是非常大的。拉里和谢尔盖两人利用稀疏矩阵计算的技巧，大大的简化了计算量，并实现了这个网页排名算法。今天 Google 的工程师把这个算法移植到并行的计算机中，进一步缩短了计算时间，使网页更新的周期比以前短了许多。

　　我来 Google 后，拉里 (Larry) 在和我们几个新员工座谈时，讲起他当年和谢尔盖(Sergey) 是怎么想到网页排名算法的。他说："当时我们觉得整个互联网就像一张大的图 （Graph)，每个网站就像一个节点，而每个网页的链接就像一个弧。我想，互联网可以用一个图或者矩阵描述，我也许可以用这个发现做个博士论文。" 他和谢尔盖就这样发明了 Page Rank 的算法。

　　网页排名的高明之处在于它把整个互联网当作了一个整体对待。它无意识中符合了系统论的观点。相比之下，以前的信息检索大多把每一个网页当作独立的个体对待，很多人当初只注意了网页内容和查询语句的相关性，忽略了网页之间的关系。

　　今天，Google 搜索引擎比最初复杂、完善了许多。但是网页排名在 Google 所有算法中依然是至关重要的。在学术界, 这个算法被公认为是文献检索中最大的贡献之一，并且被很多大学引入了信息检索课程 (Information Retrieval) 的教程。

　　如何提高你网页的 PR 值？

　　什么是PR值呢? PR值全称为PageRank，PR是英文Pagerank 的缩写形式，Pagerank取自Google的创始人LarryPage，它是Google排名运算法则（排名公式）的一部分，Pagerank是Google对网页重要性的评估，是Google用来衡量一个网站的好坏的唯一标准。PageRank(网页级别)是Google用于评测一个网页“重要性”的一种方法。在揉合了诸如Title标识和Keywords标识等所有其它因素之后，Google通过PageRank来调整结果，使那些更具“重要性”的网页在搜索结果中另网站排名获得提升，从而提高搜索结果的相关性和质量。 PR值的级别从1到10级，10级为满分。PR值越高说明该网页越受欢迎。Google把自己的网站的PR值定到10，这说明Google这个网站是非常受欢迎的，也可以说这个网站非常重要。Google大受青睐的另一个原因就是它的网站索引速度。向Google提交你的网站直到为Google收录，一般只需两个星期。如果你的网站已经为Google收录，那么通常Google会每月一次遍历和更新(重新索引)你的网站信息。不过对于那些PR值(Pagerank)较高的网站，Google索引周期会相应的短一些。一个PR值为1的网站表明这个网站不太具有流行度，而PR值为7到10则表明这个网站非常受欢迎。PR值最高为10，一般PR值达到4，就算是一个不错的网站了。那么PR值都受那些因素影响呢？下面我们一起来看看。

　　第一：网站外部链接的数量和质量

　　在计算网站排名时，Pagerank会将网站的外部链接数考虑进去。并不能说一个网站的外部链接数越多其PR值就越高，如果这样的话，一个网站尽可能获得最多的外部链接就OK了，有这种想法是错误的。Google对一个网站上的外部链接数的重视程度并不意味着你因此可以不求策略地与任何网站建立连接。这是因为Google并不是简单地由计算网站的外部链接数来决定其等级。Google的Pagerank系统不单考虑一个网站的外部链接质量，也会考虑其数量。这个问题看来很有复杂。首先让我们来解释一下什么是阻尼因数(damping factor)。阻尼因素就是当你投票或链接到另外一个站点时所获得的实际PR分值。阻尼因数一般是0.85。当然比起你网站的实际PR值，它就显得微不足道了。

　　现在让我们来看看这个PR分值的计算公式：PR(A)=(1-d)+d(PR(t1)/C(t1)+...+PR(tn)/C(tn)) 公式解释：其中PR(A)表示的是从一个外部链接站点t1上，依据Pagerank?系统给你的网站所增加的PR分值；PR(t1)表示该外部链接网站本身的PR分值；C(t1)则表示该外部链接站点所拥有的外部链接数量。大家要谨记：一个网站的投票权值只有该网站PR分值的0.85，

　　那么，是不是说对一个网站而言，它所拥有的较高网站质量和较高PR分值的外部链接数量越多就越好呢？错，因为－Google的Pagerank系统不单考虑一个网站的外部链接质量，也会考虑其数量.比方说，对一个有一定PR值的网站X来说，如果你的网站Y是它的唯一一个外部链接，那么Google就相信网站X将你的网站Y视做它最好的一个外部链接，从而会给你的网站Y更多的分值。可是，如果网站X上已经有49个外部链接，那么Google就相信网站X只是将你的网站视做它第50个好的网站。因而你的外部链接站点上的外部链接数越多，你所能够得到的PR分值反而会越低，它们呈反比关系。

　　说它对是因为－一般情况下，一个PR分值大于等于6的外部链接站点，可显著提升你的PR分值。但如果这个外部链接站点已经有100个其它的外部链接时，那你能够得到的PR分值就几乎为零了。同样，如果一个外部链接站点的PR值仅为2，但你却是它的唯一一个外部链接，那么你所获得的PR值要远远大于那个PR值为6，外部链接数为100的网站。

　　而且这个0.85的权值平均分配给其链接的每个外部网站。

　　第二：Google在你的网站抓取的页面数

　　Google在你的网站抓取的页面数，数目越多，Pagerank值越高。但通常Google并不会主动抓取你的网站的所有页面，尤其是网址里带有“?”的动态链接，Google不主动，那就要我们主动了，最笨的办法是把网站所有的页面都提交给Google，但我想没有谁真会这么做，但页面不多的话可以试试。更好的办法是制作一个静态Html页面，通常被称作“网站地图”或“网站导航”，它里面包含你要添加的所有网址，然后把这个静态页面提交给Google。

　　第三：网站被世界三大知名网站 DMOZ，Yahoo和Looksmart 收录

　　众所周知，Google的Pagerank系统对那些门户网络目录如DMOZ，Yahoo和Looksmart尤为器重。特别是对DMOZ。一个网站上的DMOZ链接对Google的Pagerank?来说，就好像一块金子一样珍贵。如果你的网站为ODP收录，则可有效提升你的页面等级。向ODP提交你的站点并为它收录，其实并不是一件难事，只是要多花点时间而已。只要确保你的网站提供了良好的内容，然后在ODP合适的目录下点击"增加站点"，按照提示一步步来就OK了。至少要保证你的索引页(INDEX PAGE)被收录进去。所以，如果你的网站内容涉及完全不同的几块内容，你可以把每个内容的网页分别向ODP提交－不过请记住"欲速则不达"。等到Google对其目录更新后，你就能看到你的PR值会有什么变化了。如果你的网站为Yahoo和Looksmart所收录，那么你的PR值会得到显著提升。如果你的网站是非商业性质的或几乎完全是非商业性质的内容，那么你可以通过zeall.com使你的网站为著名的网络目录Looksmart所收录。Looksmart也是从Zeal网络目录获得非商业搜索列表。

　　Google PR值的更新周期是多长时间？

　　一般情况下PR值更新的周期是2.5～3个月！最近一次PR更新是2008年1月中旬。

　　PageRank相关算法总结：

　　1.PageRank

　　基本思想：如果网页T存在一个指向网页A的连接，则表明T的所有者认为A比较重要，从而把T的一部分重要性得分赋予A。这个重要性得分值为：PR（T）/C(T)

　　其中PR（T）为T的PageRank值，C(T)为T的出链数，则A的PageRank值为一系列类似于T的页面重要性得分值的累加。

　　优点：是一个与查询无关的静态算法，所有网页的PageRank值通过离线计算获得；有效减少在线查询时的计算量，极大降低了查询响应时间。

　　不足：人们的查询具有主题特征，PageRank忽略了主题相关性，导致结果的相关性和主题性降低；另外，PageRank有很严重的对新网页的歧视。

　　2.Topic-Sensitive PageRank（主题敏感的PageRank）

　　基本思想：针对PageRank对主题的忽略而提出。核心思想：通过离线计算出一个PageRank向量集合，该集合中的每一个向量与某一主题相关，即计算某个页面关于不同主题的得分。主要分为两个阶段：主题相关的PageRank向量集合的计算和在线查询时主题的确定。

　　优点：根据用户的查询请求和相关上下文判断用户查询相关的主题（用户的兴趣）返回查询结果准确性高。

　　不足：没有利用主题的相关性来提高链接得分的准确性。

　　3.Hilltop

　　基本思想：与PageRank的不同之处：仅考虑专家页面的链接。主要包括两个步骤：专家页面搜索和目标页面排序。

　　优点：相关性强，结果准确。

　　不足：专家页面的搜索和确定对算法起关键作用，专家页面的质量决定了算法的准确性，而专家页面的质量和公平性难以保证；忽略了大量非专家页面的影响，不能反应整个Internet的民意；当没有足够的专家页面存在时，返回空，所以Hilltop适合对于查询排序进行求精。

　　那么影响google PageRank的因素有哪些呢?

　　1 与pr高的网站做链接:

　　2 内容质量高的网站链接

　　3加入搜索引擎分类目录

　　4 加入免费开源目录

　　5 你的链接出现在流量大、知名度高、频繁更新的重要网站上

　　6google对DPF格式的文件比较看重。

　　7安装Google工具条

　　8域名和tilte标题出现关键词与meta标签等

　　9反向连接数量和反向连接的等级

　　10Google抓取您网站的页面数量

　　11导出链接数量

　　PageRank科学排名遏止关键字垃圾

　　目前，五花八门的网站为争夺网上排名采用恶意点击和输入关键字垃圾的手段来吸引网民的眼球，无论对于互联网企业还是互联网用户，这都不是一个好现象。

　　为了解决这样的问题，Google 创始人之一拉里.佩奇（Larry Page）发明了一种算法PageRank，是由搜索引擎根据网页之间相互的超链接进行计算的网页排名。它经常和搜索引擎优化有关。PageRank 系统目前被Google 用来体现网页的相关性和重要性，以便科学排名，遏止关键字垃圾。

　　PageRank这个概念引自一篇学术论文的被媒体转载的频度，一般被转载的次数越多，这篇论文的权威性就越高，价值也就越高。PageRank是1998年在斯坦福大学问世的，2001

　　年9 月被授予美国专利。如今它在 Google 所有算法中依然是至关重要的。在学术界, 这个算法被公认为是文献检索中最大的贡献之一，并且被很多大学引入了信息检索课程(Information Retrieval) 的教程。

　　PageRank 通过对由超过 5 亿个变量和 20 亿个词汇组成的方程进行计算，能科学公正地标识网页的等级或重要性。PR级别为1到10，PR值越高说明该网页越重要。例如：一个PR 值为1 的网站表明这个网站不太具有流行度，而PR 值为7到10则表明这个网站极其重要。PageRank级别不是一般的算术级数，而是按照一种几何级数来划分的。PageRank3 不是比PageRank2 好一级，而可能会好到数倍。

　　PageRank根据网站的外部链接和内部链接的数量和质量来衡量网站的价值。PageRank的概念是，每个到页面的链接都是对该页面的一次投票，被链接得越多，就意味着被其他网站投票越多。Google 有一套自动化方法来计算这些投票，但Google 的排名算法不完全基于外部链接。PageRank 对来自不同网页的链接会区别对待，来自网页本身排名高的链接更受青睐，给这些链接有较大的权重。

　　同时，Google 不只是看一个网站的投票数量，或者这个网站的外部链接数量。它会对那些投票的网站进行分析。如果这些网站的PR 值比较高，则其投票的网站可从中受益。因此，Google 的技术专家提醒人们，在建设网站的外部链接时，应尽可能瞄准那些PR 值高且外部链接数又少的网站。这样的外部链接站点越多，你的PR 值就会越高，从而使得你的Google 排名得到显著提升。

　　PageRank的另一作用是对关键字垃圾起到巨大的遏制作用。眼下，一些垃圾网站为了提高点击率，用一些与站点内容无关的关键字垃圾壮声威，比如用明星的名字、用公共突

　　发事件称谓等。这些网页的目的或是为了骗取广告点击，或是为了传播病毒。还有一些无赖式的博客评论也从中搅局，在网上招摇过市，骗取网民的注意力，这也被网络技术人员

　　视为垃圾。

　　PageRank目前使用一种基于信任和名誉的算法帮助遏止关键字垃圾，它忽视这些关键字垃圾的存在，以网页相互链接评级别论高低。Google 排名之所以大受追捧，是由于它并非

　　只使用关键字或代理搜索技术， 而是将自身建立在高级的网页级别技术基础之上。 别的搜索引擎提供给搜索者的是多种渠道值为 8 的网站信息得来的一个粗略的搜索结果，而Google 提供给它的搜索者的则是它自己产生的高度精确的搜索结果。这就是为什么网站管理员会千方百计去提高自己网站在Google 的排名了。

　　PageRank一般一年更新四次，所以刚上线的新网站不可能获得PR 值。不过PR 值暂时没有，并不是什么不好的事情，耐心等待就能得到Google 的青睐。

一、深度优先搜索 
    深度优先搜索就是在搜索树的每一层始终先只扩展一个子节点，不断地向纵深前进直到不能再前进（到达叶子节点或受到深度限制）时，才从当前节点返回到上一级节点，沿另一方向又继续前进。这种方法的搜索树是从树根开始一枝一枝逐渐形成的。

      深度优先搜索亦称为纵向搜索。由于一个有解的问题树可能含有无穷分枝，深度优先搜索如果误入无穷分枝（即深度无限），则不可能找到目标节点。所以，深度优先搜索策略是不完备的。另外，应用此策略得到的解不一定是最佳解（最短路径）。

二、    重排九宫问题游戏
在一个3乘3的九宫中有1-8的8个数及一个空格随机摆放在其中的格子里。如下面左图所示。现在要求实现这样的问题：将该九宫调整为如下图右图所示的形式。调整规则是：每次只能将与空格（上，下或左，右）相临的一个数字平移到空格中。试编程实现。

| 2 | 8  | 3 |                 | 1 | 2 | 3 |
-
| 1 |     | 4 |                 | 8 |    | 4 |

| 7 | 6  | 5 |                 | 7 | 6 | 5 |

深度优先搜索的路径示意图：

三、广度优先搜索

     在深度优先搜索算法中，是深度越大的结点越先得到扩展。如果在搜索中把算法改为按结点的层次进行搜索，本层的结点没有搜索处理完时，不能对下层结点进行处理，即深度越小的结点越先得到扩展，也就是说先产生的结点先得以扩展处理，这种搜索算法称为广度优先搜索法。

广度优先搜索路径示意图：

四、航班问题（来自《The Art of Java》)
    一位顾客要预定一张从New York到Los Angeles的航班机票，下面是航班线路，请你为顾客找一种购票方案。

下面是用深度优先搜索求解的程序:

// Find connections using a depth-first search.
import java.util.*;
import java.io.*;
// Flight information.
class FlightInfo {
  String from;
  String to;
  int distance;
  boolean skip; // used in backtracking
  FlightInfo(String f, String t, int d) {
    from = f;
    to = t;
    distance = d;
    skip = false;
  }
}
class Depth {
  final int MAX = 100;
  // This array holds the flight information.
  FlightInfo flights[] = new FlightInfo[MAX];
  int numFlights = 0; // number of entries in flight array
  Stack btStack = new Stack(); // backtrack stack
  public static void main(String args[])
  {
   
    String to, from;
    Depth ob = new Depth();
    BufferedReader br = new
      BufferedReader(new InputStreamReader(System.in));
 
    ob.setup(); 
    try {
      System.out.print("From? ");
      from = br.readLine();
      System.out.print("To? ");
      to = br.readLine();
      ob.isflight(from, to);
      if(ob.btStack.size() != 0)
        ob.route(to);
    } catch (IOException exc) {
      System.out.println("Error on input.");
    }
  }
 
  // Initialize the flight database.
  void setup()
  {
    addFlight("New York", "Chicago", 900);
    addFlight("Chicago", "Denver", 1000);
    addFlight("New York", "Toronto", 500);
    addFlight("New York", "Denver", 1800);
    addFlight("Toronto", "Calgary", 1700);
    addFlight("Toronto", "Los Angeles", 2500);
    addFlight("Toronto", "Chicago", 500);
    addFlight("Denver", "Urbana", 1000);
    addFlight("Denver", "Houston", 1000);
    addFlight("Houston", "Los Angeles", 1500);
    addFlight("Denver", "Los Angeles", 1000);
  }
 
  // Put flights into the database.
  void addFlight(String from, String to, int dist)
  {
 
    if(numFlights < MAX) {
      flights[numFlights] =
        new FlightInfo(from, to, dist);
      numFlights++;
    }
    else System.out.println("Flight database full.\n");
  }
  // Show the route and total distance.
  void route(String to)
  {
    Stack rev = new Stack();
    int dist = 0;
    FlightInfo f;
    int num = btStack.size();
    // Reverse the stack to display route.
    for(int i=0; i < num; i++)
      rev.push(btStack.pop());
    for(int i=0; i < num; i++) {
      f = (FlightInfo) rev.pop();
      System.out.print(f.from + " to ");
      dist += f.distance;
    }
    System.out.println(to);
    System.out.println("Distance is " + dist);
  }
  /* If there is a flight between from and to,
     return the distance of flight;
     otherwise, return 0. */
  int match(String from, String to)
  {
    for(int i=numFlights-1; i > -1; i--) {
      if(flights[i].from.equals(from) &&
         flights[i].to.equals(to) &&
         !flights[i].skip)
      {
        flights[i].skip = true; // prevent reuse
        return flights[i].distance;
      }
    }
    return 0; // not found
  }
 
  // Given from, find any connection.
  FlightInfo find(String from)
  {
    for(int i=0; i < numFlights; i++) {
      if(flights[i].from.equals(from) &&
         !flights[i].skip)
      {
        FlightInfo f = new FlightInfo(flights[i].from,
                             flights[i].to,
                             flights[i].distance);
        flights[i].skip = true; // prevent reuse
        return f;
      }
    }
    return null;
  }
 
  // Determine if there is a route between from and to.
  void isflight(String from, String to)
  {
    int dist;
    FlightInfo f;
    // See if at destination.
    dist = match(from, to);
    if(dist != 0) {
      btStack.push(new FlightInfo(from, to, dist));
      return;
    }
    // Try another connection.
    f = find(from);
    if(f != null) {
      btStack.push(new FlightInfo(from, to, f.distance));
      isflight(f.to, to);
    }
    else if(btStack.size() > 0) {
      // Backtrack and try another connection.
      f = (FlightInfo) btStack.pop();
      isflight(f.from, f.to);
    }
  }
} 
 

解释：isflight()方法用递归方法进行深度优先搜索，它先调用match()方法检查航班的数据库，判断在from和to之间有没有航班可达。如果有，则获取目标信息，并将该线路压入栈中，然后返回（找到一个方案）。否则，就调用find()方法查找from与任意其它城市之间的线路，如果找到一条就返回描述该线路的FlightInfo对象，否则返回null。如果存在这样的一条线路，那么就把该线路保存在f中，并将当前航班信息压到栈的顶部，然后递归调用isflight()方法 ,此时保存在f.to中的城市成为新的出发城市.否则就进行回退,弹出栈顶的第一个节点,然后递归调用isflight()方法。该过程将一直持续到找到目标为止。

程序运行结果：

C:\java>java Depth
From? New York
To? Los Angeles
New York to Chicago to Denver to Los Angeles
Distance is 2900

C:\java>

      深度优先搜索能够找到一个解，同时，对于上面这个特定问题，深度优先搜索没有经过回退，一次就找到了一个解；但如果数据的组织方式不同，寻找解时就有可能进行多次回退。因此这个例子的输出并不具有普遍性。而且，在搜索一个很长，但是其中并没有解的分支的时候，深度优先搜索的性能将会很差，在这种情况下，深度优先搜索不仅在搜索这条路径时浪费时间，而且还在向目标的回退中浪费时间。

再看对这个例子使用广度优先搜索的程序：

// Find connections using a breadth-first search.
import java.util.*;
import java.io.*;
// Flight information.
class FlightInfo {
  String from;
  String to;
  int distance;
  boolean skip; // used in backtracking
  FlightInfo(String f, String t, int d) {
    from = f;
    to = t;
    distance = d;
    skip = false;
  }
}
class Breadth {
  final int MAX = 100;
  // This array holds the flight information.
  FlightInfo flights[] = new FlightInfo[MAX];
  int numFlights = 0; // number of entries in flight array
  Stack btStack = new Stack(); // backtrack stack
  public static void main(String args[])
  {
    String to, from;
    Breadth ob = new Breadth();
    BufferedReader br = new
      BufferedReader(new InputStreamReader(System.in));
 
    ob.setup(); 
    try {
      System.out.print("From? ");
      from = br.readLine();
      System.out.print("To? ");
      to = br.readLine();
      ob.isflight(from, to);
      if(ob.btStack.size() != 0)
        ob.route(to);
    } catch (IOException exc) {
      System.out.println("Error on input.");
    }
  }
 
  // Initialize the flight database.
  void setup()
  {
    addFlight("New York", "Chicago", 900);
    addFlight("Chicago", "Denver", 1000);
    addFlight("New York", "Toronto", 500);
    addFlight("New York", "Denver", 1800);
    addFlight("Toronto", "Calgary", 1700);
    addFlight("Toronto", "Los Angeles", 2500);
    addFlight("Toronto", "Chicago", 500);
    addFlight("Denver", "Urbana", 1000);
    addFlight("Denver", "Houston", 1000);
    addFlight("Houston", "Los Angeles", 1500);
    addFlight("Denver", "Los Angeles", 1000);
  }
 
  // Put flights into the database.
  void addFlight(String from, String to, int dist)
  { 
    if(numFlights < MAX) {
      flights[numFlights] =
        new FlightInfo(from, to, dist);
      numFlights++;
    }
    else System.out.println("Flight database full.\n");
  }
  // Show the route and total distance.
  void route(String to)
  {
    Stack rev = new Stack();
    int dist = 0;
    FlightInfo f;
    int num = btStack.size();
    // Reverse the stack to display route.
    for(int i=0; i < num; i++)
      rev.push(btStack.pop());
    for(int i=0; i < num; i++) {
      f = (FlightInfo) rev.pop();
      System.out.print(f.from + " to ");
      dist += f.distance;
    }
    System.out.println(to);
    System.out.println("Distance is " + dist);
  }
  /* If there is a flight between from and to,
     return the distance of flight;
     otherwise, return 0. */
  int match(String from, String to)
  {
    for(int i=numFlights-1; i > -1; i--) {
      if(flights[i].from.equals(from) &&
         flights[i].to.equals(to) &&
         !flights[i].skip)
      {
        flights[i].skip = true; // prevent reuse
        return flights[i].distance;
      }
    }
    return 0; // not found
  }
 
  // Given from, find any connection.
  FlightInfo find(String from)
  {
    for(int i=0; i < numFlights; i++) {
      if(flights[i].from.equals(from) &&
         !flights[i].skip)
      {
        FlightInfo f = new FlightInfo(flights[i].from,
                             flights[i].to,
                             flights[i].distance);
        flights[i].skip = true; // prevent reuse
        return f;
      }
    }
    return null;
  }
 
  /* Determine if there is a route between from and to
     using breadth-first search. */
  void isflight(String from, String to)
  {
    int dist, dist2;
    FlightInfo f;
    // This stack is needed by the breadth-first search.
    Stack resetStck = new Stack();
    // See if at destination.
    dist = match(from, to);
    if(dist != 0) {
      btStack.push(new FlightInfo(from, to, dist));
      return;
    }
    /* Following is the first part of the breadth-first
       modification.  It checks all connecting flights
       from a specified node. */
    while((f = find(from)) != null) {
      resetStck.push(f);
      if((dist = match(f.to, to)) != 0) {
        resetStck.push(f.to);
        btStack.push(new FlightInfo(from, f.to, f.distance));
        btStack.push(new FlightInfo(f.to, to, dist));
        return;
      }
    }
    /* The following code resets the skip fields set by
       preceding while loop. This is also part of the
       breadth-first modifiction. */
    int i = resetStck.size();
    for(; i!=0; i--)
      resetSkip((FlightInfo) resetStck.pop());
    // Try another connection.
    f = find(from);
    if(f != null) {
      btStack.push(new FlightInfo(from, to, f.distance));
      isflight(f.to, to);
    }
    else if(btStack.size() > 0) {
      // Backtrack and try another connection.
      f = (FlightInfo) btStack.pop();
      isflight(f.from, f.to);
    }
  }
  // Reset skip field of specified flight.
  void resetSkip(FlightInfo f) {
    for(int i=0; i< numFlights; i++)
      if(flights[i].from.equals(f.from) &&
         flights[i].to.equals(f.to))
           flights[i].skip = false;
  }
}

程序运行结果：

C:\java>java Breadth
From? New York
To? Los Angeles
New York to Toronto to Los Angeles
Distance is 3000

C:\java>

它找到了一个合理的解，但这不具有一般性。因为找到的第一条路径取决于信息的物理组织形式。

如果目标在搜索空间中隐藏得不是太深，那么广度优先搜索的性能会很好。

Larbin只是一个爬虫，也就是说larbin只抓取网页，至于如何parse的事情则由用户自己完成。另外，如何存储到数据库以及建立索引的事情 larbin也不提供。

latbin最初的设计也是依据设计简单但是高度可配置性的原则，因此我们可以看到，一个简单的larbin的爬虫可以每天获取５００万的网页，实在是非常高效。

2] Larbin的性能特征
高效是我对 larbin 的评价。
今年四月份的时候我对larbin的性能做过一个测试，luliang.dhs.org是我自己常用的服务器，CPU 为1G，内存512，其它的性能一般，因为是三年前购置的。

我将我自己的网页 六翼作为入口，运行larbin进行５层内的url的抓取。

当时纪录的一些数据：
Internet IO: 500-700k/per second （我想大约我的网络下载的瓶颈了吧）
CPU top: 5%-15%
disk consume: 1M/s ，基本上一个小时爬 3个G 的网页。差不多20万的页面
url 解析: 200万－300万每小时

3] larbin 的作用
很多人初见 larbin 不知道从哪里下手，那么我来简单介绍一下 larbin 的功能和实际应用。
1. larbin 获取单个、确定网站的所有联结，甚至可以镜像一个网站。
2. larbin建立 url 列表群，例如针对所有的网页进行 url retrive后，进行xml的联结的获取。或者是 mp3 。
3. larbin 定制后可以作为搜索引擎的信息的来源（例如可以将抓取下来的网页每2000一组存放在一系列的目录结构里面）。

总归，larbin应当是一个被广大搜索引擎爱好者应当引起注意的一个产品，虽然其功能逐渐被 Nutch 所接受和替代，但是其在爬虫上的优美设计的确值得称道。

　　下面我们来看一段代码，了解一下cookie究竟是怎样建立的：
　　
　　<HTML>
　　<HEAD>
　　<TITLE>Set a cookie based on a form</TITLE>
　　<SCRIPT LANGUAGE="java script" TYPE="TEXT/java script">
　　<!-- Hide script from older browsers
　　
　　expireDate = new Date
　　expireDate.setMonth(expireDate.getMonth()+6)
　　
　　userName = ""
　　if (documents .cookie != "") {
　　userName = documents .cookie.split("=")[1]
　　}
　　
　　function setCookie() {
　　userName = document.myform.nameField.value
　　documents .cookie = "userName="+userName+";expires=" + expireDate.toGMTString()
　　}
　　
　　// End hiding script -->
　　</SCRIPT>
　　</HEAD>
　　<BODY BGCOLOR="WHITE" onLoad="document.myform.nameField.value = userName">
　　<form NAME="myform">
　　<H1>Enter your name:<INPUT TYPE="TEXT" NAME="nameField" onBlur="setCookie()"></H1>
　　</form>
　　</BODY>
　　</HTML>
　　这是一锻简单的建立cookie的脚本。
　　
　　1，<SCRIPT LANGUAGE="java script" TYPE="TEXT/java script">
　　
　　脚本开始的标记，由此一句告诉浏览器以下将是java script.
　　
　　2,<!-- Hide script from older browsers
　　
　　为了防止浏览器不能识别脚本，而让浏览器误以为是HTML注释而忽略它。
　　
　　3，expireDate = new Date
　　
　　获取当前日期，并存入变量expireDate中。
　　
　　4，expireDate.setMonth(expireDate.getMonth()+6)
　　
　　获取当前月份值，将其加6后设置为expireDate的月份总值部分。这意味着本cookie的有效期为6个月。
　　
　　5，if (documents .cookie != "")
　　
　　如果document的值不为空，相当于检查用户硬盘上是否已经有了cookie。
　　
　　6，userName = documents .cookie.split("=")[1]
　　
　　此处用到了split("=")函数，它的功能是把cookie记录分割为数组，cookie的名为cookie[0],值为cookie[1],以此累推。所以此处documents .cookie.split("=")[1]返回的值是此cookie的值。在此句中将值赋给了变量username。
　　
　　7，function setCookie()
　　
　　设置名为setCookie的函数。
　　
　　8，documents .cookie = "userName="+userName+";expires=" + expireDate.toGMTString()
　　
　　此句是将设置好的cookie写入用户硬盘。expireDate.toGMTString()把expireDate中的值转换为文本字符串，这样才能写入cookie中。
　　
　　9，onLoad="document.myform.nameField.value = userName"
　　
　　当页面载入时，把username的值写入文本框(如果有的话)。
　　
　　10，onBlur="setCookie()"
　　
　　当用户离开文本框时，onBlur调用函数setCookie。
　　
　　结合上面的注释，读那段代码相信不成问题吧!既然我们可以建立cookie，那么读取也不是什么难事，请接着往下看!

　　二、读取和显示cookie
　　
　　一般来说，cookie的作者并不希望cookie被显示出来，这是当然的!天知道里面写了些什么!？然而这也是我们想要读出它的原因!~~~:D
　　
　　<HTML>
　　<HEAD>
　　<TITLE>Cookie Check</TITLE>
　　</HEAD>
　　<BODY BGCOLOR="WHITE">
　　<H2>
　　<SCRIPT LANGUAGE="java script" TYPE="TEXT/java script">
　　<!-- Hide script from older browsers
　　
　　if (documents .cookie == "") {
　　document.write("There are no cookies here")
　　}
　　else {
　　thisCookie = documents .cookie.split("; ")
　　
　　for (i=0; i<thisCookie.length; i++) {
　　document.write("Cookie name is ’"+thisCookie.split("=")[0])
　　document.write("’, and the value is ’"+thisCookie.split("=")[1]+"’<BR>")
　　}
　　}
　　
　　// End hiding script -->
　　</SCRIPT>
　　</H2>
　　</BODY>
　　</HTML>
　　
　　以上的便是一段读取cookie的名字和值的脚本。上文中解释过的语句在此不多赘述，且看有什么新的语法：
　　
　　1，thisCookie = documents .cookie.split("; ")[注意：并非前文中出现过的split("=")。
　　
　　split("; ")可以产生数组的结果，本句中，由documents .cookie.split("; ")来获取cookie的值，并将这个数组赋值缎带变量：thisCookie。
　　
　　2，for (i=0; i<thisCookie.length; i++)
　　
　　设置计算器变量i的值为0，如果其值小于thisCookie.length(thisCookie中值的个数)，将i的值加1。
　　
　　3，document.write("Cookie name is ’"+thisCookie.split("=")[0])
　　
　　此句中thisCookie.split("=")[0]较难理解，上面的脚本中，thiscookie已经被赋值为一个数组的值，那么thisCookie是指数组中第i个值，也就是第i个cookie，而由上文可知split("=")[0]是指cookie的名字。

　　这样thisCookie.split("=")[0]便是第i的cookie中cookie的名字!
　　
　　4,document.write("’, and the value is ’"+thisCookie.split("=")[1]
　　
　　跟3极为相似，即是第i个cookie中 cookie的值。
　　
　　到此，我们已经熟悉了如何建立cookie以及它的读取。这些也正是cookie欺骗也需要的主要技术!

　　三、cookie欺骗的实现
　　
　　要做到cookie欺骗，最重要的是理解目标cookie中的储值情况，并设法改变它。由上面的学习我们知道，基于cookie的格式所限，一般来说，只有在Cookie.split("=")[0]和Cookie.split("=")[1]中的值对我们才是有用的。也就是说只需改变这两处或是处的值即可达到我们的目的。

　　而在实际操作中，还得先解决另一个问题。由于受浏览器的内部cookie机制所限，每个cookie只能被它的原服务器所访问!可我们总不能跑到人家服务器上操作吧!这里就需要一个小技巧了。

　　在上面我们提到过cookie的格式，最后两项中分别是它的url路径和域名。不难想到，服务器对cookie的识别靠的就是这个!

　　而在平时，我们要浏览一个网站时，输入的url便是它的域名，需要经过域名管理系统dns将其转化为IP地址后进行连接的。这其中就有一个空当。如果能在dns上做手脚，把目标域名的IP地址对应到其它站点上，我们便可以非法访问目标站点的cookie了!

　　做到这一点并不难，当然我不并不是要去操纵dns，而且那也是不可能的事情。在win9下的安装目录下，有一 名为hosts.sam的文件，以文本方式打开后会看到这样的格式：

　　127.0.0.1 lockhost #注释

　　利用它，我们便可以实现域名解析的本地化!而且其优先权高于网络中的dns!

　　具体使用时，只需将IP和域名依上面的格式添加，并另存为hosts即可!(注意：此文件无后赘名，并非hosts.sam 文件本身!)
　　
　　到此，cookie欺骗所需的所以知识已经齐备。下面以一个“假”的例子，演示一下如何进入实战.(不便给出真实地址，以免引起犯罪!~~~:P)
　　假设目标站点是 www.xxx.com
　　www.self.com是自己的站点。(可以用来存放欺骗目标所需的文件，用来读取和修改对方的cookie.)

　　首先ping出www.self.com的IP地址：

　　ping www.self.com
　　
　　Reply from 12.34.56.78: bytes=32 time=20ms TTL=244
　　
　　然后修改hosts.sam文件如下：
　　
　　12.34.56.78 www.xxx.com
　　并保存为hosts。
　　
　　将用来读取cookie的页面传至www.self.com(脚本如二所示)。
　　此时连上www.xxx.com。由于我们已经对hosts动过手脚，这时来到的并不是www.xxx.com，而是www.self.com

　　www.xxx.com设在本地的cookie便可被读出!~~:D

　　然后根据具体情况修改一的脚本，用同样的方法，向此cookie中写入数据。修改完毕后，删掉hosts文件，再重新进入www.xxx.com，此时已经大功告成，可享受你的hack成果了!~~~:)
　　
　　编后

　　cookie欺骗是一种发现较早，且较难使用的hack手法，除了java script 可以控制以外，asp等也可以用来对其进进设置。所以在此声明，未必能对所有站点有较。但技术真实，无须置疑!
　　
　　补充：在win2000中hosts文件的建立与win98不同，需要c:\winnt\system32\drivers\etc文件夹中创建!

iedevtoolbar下载地址如下:

本地（较老版本）：http://files.cnblogs.com/JustinYoung/iedevtoolbar.rar

官方（最新版本）：http://www.microsoft.com/downloads/details.aspx?FamilyID=e59c3964-672d-4511-bb3e-2d5e1db91038&DisplayLang=en

第二个是httpwatchpro,这个工具主要功能是监视http的数据,但是它也能让你看到相关网页或者样式表文件的内容.

httpwatchpro下载下载地址如下:

大小限制，分卷压缩。

http://files.cnblogs.com/JustinYoung/httpwatchpro-v4.1.part1.rar

http://files.cnblogs.com/JustinYoung/httpwatchpro-v4.1.part2.rar

这两个软件都很简单,只有简单的几个英文单词,所以也没有必要用汉化版.估计也没有人会去做汉化版.但是真是这些简单小巧的软件让我们的工作效率有了很大的提高.工欲善其事,必先善其器.

KeyWord：web开发工具,web开发小软件,网页开发工具,网页开发小软件,iedevtoolbar下载,iedevtoolbar教程,iedevtoolbar使用,iedevtoolbar帮助,httpwatch下载,httpwatch教程,httpwatch帮助,httpwatch使用,httpwatchpro下载,httpwatchpro教程,httpwatchpro帮助

网站最重要的东西是什么？
——内容？SEO（搜索引擎优化）？UE（用户体验）？都不对！是速度！
内容再丰富的网站，如果慢到无法访问也是毫无意义的； SEO做的再好的网站，如果搜索蜘蛛抓不到也是白搭(页面效率和搜索蜘蛛之间的关系，需要进一步的确认，此为和上篇保持统一)； UE设计的再人性化的网站，如果用户连看都看不到也是空谈。

所以网页的效率绝对是最值得关注的方面。虽然我们在 《如何提高网页的效率（上篇）——提高网页效率的14条准则》提到了如何提高网页效率的14条准则，但是如何知道我们现在的网页的效率到底如何？到底处于怎样一个级别？又有哪些方面做的不够好，需要改进呢？也许，你会说，问一下用户不就知道了吗？但是相比感性比例占据太大的用户感受而言，理性的工具和数据更具有说服力。本篇就将向你介绍一款评测网页效率的工具——YSlow（why slow，这个名字起的太好了）。

yslow

YSlow是由Yahoo开发者团队发布的一款基于Firebug的插件。而Firebug 又是一款基于FireFox的插件。所以说YSlow是一款基于FireFox插件的插件。虽然有点绕，但是最终说明的问题是：

·                          很遗憾，微软的IE系列浏览器不能使用YSlow。

·                          YSlow只能使用在FireFox浏览器上。

·                          如果要想使用YSlow，那么你必须先安装FireFox。

·                          如果要想使用YSlow，那么你就要安装FireFox上的Firebug插件。

这看上去好像有点令人沮丧，但是事实上它并不像想象中的那么麻烦，只要按照下面的步骤你将能很快的使用YSlow：

1.            到http://www.mozilla.net.cn/firefox/ 下载最新版的FireFox，并安装它。当然如果你已经安装了FireFox可以跳过此步。

2.            到https://addons.mozilla.org/en-US/firefox/addon/1843/ 下载最新版的Firebug，并安装它。当然如果你已经安装了Firebug可以跳过此步。

3.            到https://addons.mozilla.org/en-US/firefox/addon/5369/ 下载最新版的YSlow，并安装它。当然如果你已经安装了YSlow可以跳过此步。

图2：在菜单中先打开Firebug插件

这时候打开FireFox，你将在【工具】菜单中看到【firebug】（如图2）。打开firebug，然后在firebug中点击YSlow菜单，便看进入YSlow的主界面（如图3）。

图3：在菜单中先打开Firebug插件(点击小图查看完整大图)

点击【Performace】菜单

YSlow便开始分析此页的效率，并从13个最影响网页效率的方面给出评估（如图4）。

图4：YSlow给出的本页面效率评估

可以看出来，YSlow评估的依据就是我们在 《如何提高网页的效率（上篇）——提高网页效率的14条准则》中提到的前面13条。前面蓝色的字母表示这一条准则的得分。A最高。点击右面的三角形可以得到更多的信息和建议，有些信息里面还有“放大镜” 图标，点击也将展示更为详细的信息和建议。（如图5所示）

图5：YSlow可以给出每条准则的详细评估信息和建议

点击【Stats】菜单

这个视图会告诉你页面的总体统计信息。包括页面大小、css样式表大小、脚本文件大小、总体图片大小、flash文件大小和css中用到的图片文件大小。还会告诉你，哪些东西被缓存了，缓存了多少等等。

图6：【Stats】视图信息

点击【Components】菜单

这个视图是一个页面所有部件的信息列表。从中我们可以得知每个部件的各种详细信息。如：类型、URL、Expires数据、状态、大小、读取时间、ETag信息等等。通过对这个列表的分析，我们就可以知道到底是什么东西最耗费我们的资源，从而有针对性的进行优化。

图7：【Components】视图信息，点击“放大镜”图标我们可以知道更详细的信息（点击小图查看完整大图）

点击【Tools】菜单

【Tools】菜单包含4个子菜单，就是4个实用工具。【JSLine】工具会生成JSLine报表，报表是对本网页中JS脚本的分析报告，包含错误和建议。【ALL JS】工具，将生成本页面所有脚本代码便于阅读和打印的报表页面。【ALL CSS】工具，将生成本页面所有CSS样式表代码便于阅读和打印的报表页面。【Printable View】将【Performance】和【Stats】视图中的信息生成一份更适合阅读和打印的报表页面。

图8：【Tools】菜单，包含了4个子菜单

点击【Help】菜单

【Help】主要是些常用的帮助途径的入口。从这里你可以很方面的访问YSlow的官方网络和博客。如果你还对YSlow的使用有什么疑惑的话，那么在这里你将获得满意的解答。

图8：【Help】菜单是些常用的帮助入口