DIV+CSS网页布局常用的方法与技巧

CSS布局常用的方法

　　float:none|left|right
　　取值：
　　none:默认值。对象不飘浮
　　left:文本流向对象的右边
　　right:文本流向对象的左边

　　它是怎样工作的，看个一行两列的例子

　　xhtml代码:
　　Example Source Code

　　<div id="wrap">
　　<div id="column1">这里是第一列</div>
　　<div id="column2">这里是第二列</div>
　　<div class="clear"></div> /*这是违背web标准意图的，只是想说明在它下面的元素需要清除浮动*/
　　</div>

　　CSS代码:
　　Example Source Code

　　#wrap{width:100;height:auto;}
　　#column1{float:left;width:40;}
　　#column2{float:right;width:60;}
　　.clear{clear:both;}

　　position:static|absolute|fixed|relative

　　取值：
　　static:�默认值。无特殊定位，对象遵循HTML定位规则
　　absolute:�将对象从文档流中拖出，使用left，right，top，bottom等属性相对于其最接近的一个最有定位设置的父对象进行绝对定位。如果不存在这样的父对象，则依据body对象。而其层叠通过z-index属性定义
　　fixed:�未支持。对象定位遵从绝对(absolute)方式。但是要遵守一些规范
　　relative:�对象不可层叠，但将依据left，right，top，bottom等属性在正常文档流中偏移位置

　　它来实现一行两列的例子

　　xhtml代码:
　　Example Source Code

　　<div id="wrap">
　　<div id="column1">这里是第一列</div>
　　<div id="column2">这里是第二列</div>
　　</div>

　　CSS代码:
　　Example Source Code [www.52css.com]
　　#wrap{position:relative;/*相对定位*/width:770px;}
　　#column1{position:absolute;top:0;left:0;width:300px;}
　　#column2{position:absolute;top:0;right:0;width:470px;}

　　他们的区别在哪？

　　显然，float是相对定位的，会随着浏览器的大小和分辨率的变化而改变，而position就不行了，所以一般情况下还是float布局！

CSS常用布局实例

　　单行一列
　　Example Source Code

　　body{margin:0px;padding:0px;text-align:center;}
　　#content{margin-left:auto;margin-right:auto;width:400px;}

　　两行一列
　　Example Source Code

　　body{margin:0px;padding:0px;text-align:center;}
　　#content-top{margin-left:auto;margin-right:auto;width:400px;}
　　#content-end{margin-left:auto;margin-right:auto;width:400px;}

　　三行一列
　　Example Source Code

　　body{margin:0px;padding:0px;text-align:center;}
　　#content-top{margin-left:auto;margin-right:auto;width:400px;width:370px;}
　　#content-mid{margin-left:auto;margin-right:auto;width:400px;}
　　#content-end{margin-left:auto;margin-right:auto;width:400px;}

　　单行两列
　　Example Source Code

　　#bodycenter{width:700px;margin-right:auto;margin-left:auto;overflow:auto;}
　　#bodycenter#dv1{float:left;width:280px;}
　　#bodycenter#dv2{float:right;width:420px;}

　　两行两列
　　Example Source Code

　　#header{width:700px;margin-right:auto;margin-left:auto;overflow:auto;}
　　#bodycenter{width:700px;margin-right:auto;margin-left:auto;overflow:auto;}
　　#bodycenter#dv1{float:left;width:280px;}
　　#bodycenter#dv2{float:right;width:420px;}

　　三行两列
　　Example Source Code

　　#header{width:700px;margin-right:auto;margin-left:auto;}
　　#bodycenter{width:700px;margin-right:auto;margin-left:auto;}
　　#bodycenter#dv1{float:left;width:280px;}
　　#bodycenter#dv2{float:right;width:420px;}
　　#footer{width:700px;margin-right:auto;margin-left:auto;overflow:auto;clear:both;}

　　单行三列
　　绝对定位
　　Example Source Code

　　#left{position:absolute;top:0px;left:0px;width:120px;}
　　#middle{margin:0px190px0px190px;}
　　#right{position:absolute;top:0px;right:0px;width:120px;}

　　float定位一
　　xhtml代码:
　　Example Source Code

　　<div id="wrap">
　　<div id="column">
　　<div id="column1">这里是第一列</div>
　　<div id="column2">这里是第二列</div>
　　<div class="clear"></div>/*用法web标准不建议，但是记住下面元素需要清除浮动*/
　　</div>
　　<divid="column3">这里是第三列</div>
　　<divclass="clear"></div>/*用法web标准不建议，但是记住下面元素需要清除浮动*/
　　</div>


　　CSS代码:
　　Example Source Code

　　#wrap{width:100;height:auto;}
　　#column{float:left;width:60;}
　　#column1{float:left;width:30;}
　　#column2{float:right;width:30;}
　　#column3{float:right;width:40;}
　　.clear{clear:both;}

　　float定位二

　　xhtml代码：
　　Example Source Code

　　<div id="center"class="column">
　　<h1>Thisisthemaincontent.</h1>
　　</div>
　　<div id="left"class="column">
　　<h2>Thisistheleftsidebar.</h2>
　　</div>
　　<div id="right"class="column">
　　<h2>Thisistherightsidebar.</h2>
　　</div>

　　CSS代码：
　　Example Source Code

　　body{
　　margin:0;
　　padding-left:200px;/*LCfullwidth*/
　　padding-right:190px;/*RCfullwidth CCpadding*/
　　min-width:200px;/*LCfullwidth CCpadding*/
　　}
　　.column{
　　position:relative;
　　float:left;
　　}
　　#center{
　　width:100;
　　}
　　#left{
　　width:200px;/*LCwidth*/
　　right:200px;/*LCfullwidth*/
　　margin-left:-100;
　　}
　　#right{
　　width:190px;/*RCwidth*/
　　margin-right:-100;
　　}
--
道不远人，人自远。

设计时如何把握网页布局

设计时如何把握网页布局

最开始，网页呈现在你面前的时侯，它就好像一张白纸， 它需要你任意挥洒你的设计才思。在开始的时侯，你需要明白，虽然你能控制一切你所能控制的东西，但假如你知道什么是一种约定俗成的标准或者说大多数访问者 的浏览习惯，那么你可以在此基础上加上自己的东西。你当然也可以创造出自己的设计方案，但如果你是初学者，那么最好明白网页布局的基本概念。

1.页面尺寸

由于页面尺寸和显示器大小及分辨率有关系，网页的局限性就在于你无法突破显示器的范围，而且 因为浏览器也将占去不少空间，留下给你的页面范围变得越来越小。一般分辨率在800x600的情况下，页面的显示尺寸为：780x428个象素；分辨率在 640x480的情况下，页面的显示尺寸为:620X311个象素；分辨率在1024X768的情况下，页面的显示尺寸为：1007x600。从以上数据 可以看出，分辨率越高页面尺寸越大。

浏览器的工具栏也是影响页面尺寸的原因。一般目前的浏览器的工具栏都可以取消或者增加，那么当你显示全部的工具栏时，和关闭全部工具栏时，页面的尺寸是不一样的。

在网页设计过程中，向下拖动页面是惟一给网页增加更多内容(尺寸)的方法。但我想提醒大家除非你能肯定站点的内容能吸引大家拖动，否则不要让访问者拖动页面超过三屏。如果需要在同一页面显示超过三屏的内容，那么你最好能在上面做上页面内部连接，方便访问者浏览。

2.整体造型

什么是造型，造型就是创造出来的物体形象。这里是指页面的整体形象，这种形象应该是一个整体，图形与文本的接合应该是层叠有序。虽然，显示器和浏览器都是矩形，但对于页面的造型，你可以充分运用自然界中的其它形状以及它们的组合：矩形，圆形，三角形，菱形等。

对于不同的形状，它们所代表的意义是不同的。比如矩形代表着正式，规则，你注意到很多ICP 和政府网页都是以矩形为整体造型；圆形带表着柔和，团结，温暖，安全等，许多时尚站点喜欢以圆形为页面整体造型；三角形代表着力量，权威，牢固，侵略等， 许多大型的商业站点为显示它的权威性常以三角形为页面整体造型；菱形代表着平衡，协调，公平，一些交友站点常运用菱形作为页面整体造型。虽然不同形状带表 着不同意义，但目前的网页制作多数是接合多个图形加以设计，在这其中某种图形的构图比例可能占的多一些。

3.页头

页头又可称之为页眉，页眉的作用是定义页面的主题。比如一个站点的名字多数都显示在页眉里。这样，访问者能很快知道这个站点是什么内容。页头是整个页面设计的关键，它将牵涉到下面的更多设计和整个页面的协调性。页头常放置站点名字的图片和公司标志以及旗帜广告。

4.文本

文本在页面中出现都数以行或者块(段落)出现，它们的摆放位置决定者整个页面布局的可视性。在过去因为页面制作技术的局限，文本放置的位置的灵活性非常小，而随着DHTML的兴起，文本已经可以按照自己的要求放置到页面的任何位置。

5.页脚

页脚和页头相呼应。页头是放置站点主题的地方，而页脚是放置制作者或者公司信息的地方。你能看到，许多制作信息都是放置在页脚的。

6.图片

图片和文本是网页的两大构成元素，却一不可。如何处理好图片和文本的位置成了整个页面布局的关键。而你的布局思维也将体现在这里。

7.多媒体

除了文本和图片，还有声音，动画，视频等等其它媒体。虽然它们不是经常能被利用到，但随着动态网页的兴起，它们在网页布局上也将变得更重要。

--
道不远人，人自远。

centos 感觉不错～

晚上刻碟安装了centos5.3，用起来感觉真的不错哈！哈哈~ 输入法有点弱。其他的开发环境的配置暂时没去动他，我想不会太难的！明天去买书学习学习下！对自己投资吧！

--
道不远人，人自远。

几种主流语言的泛型比较

几种主流语言的泛型比较
    第一种支持泛型的语言是ADA(一种Pascal语言的后代,差不多是军方的专用语言).而把泛型发扬光大的的是C++(主要是借助泛型实现的模板).
    作为一种提高代码重用的技术,泛型被越来越多的语言所支持.
    java,C#,Delphi都开始先后支持了泛型技术.我就在这里比较和评论一下C++,java,C#,Delphi几种泛型技术的特点.
   
                  实现时机 是否会生成参考类    效率       约束                     兼容性           泛型运行时信息            
    C++            编译时         会              高       基本算没有                  好               基本算没有
                                                     
    Java           编译时         不会            高       有                               好                 很弱
   
   
    C#             运行时         不会           一般     有                              一般                强
   
   
    Delphi         编译时         会              高       有                                好                  强
   
先从实现的时机和是否生成参考类来说.
C++主要是通过源代码替换机制来实现泛型的.也就是说C++的泛型和宏差不多. 也就是说会为每个泛型实例生成参考类.
Java主要是通过编译器把泛型类全部变成object来实现的.而泛型类的方法是编译通过打包等技术进行类型转换的.例如List<T>实际上永远都是List<object>,不会生成新的参考类.
C#则主要是通过在虚拟机中加入泛型技术来达到对泛型的支持的.List<T>在虚拟机中只是List<T>.不会生成参考类. 只有在JIT编译的时候才会生成参考类的机器代码.当然T的类型不一样具体在虚拟机中的实现也不一样.当T是值类型的时候会生成参考类.但我们这里主要讨 论大部分情况,.NET中多数情况下用引用类型的时候多得多.
Delphi在编译角度讲则更像C++,是通过代码替换机制生成参考类来实现泛型的.但Delphi的类型限制更严格.没有指定类型的约束的时候是不允许使用特定的方法或者操作符等的.具体在后面的约束中讲.  

效率方面
C++的效率就高一些.编译期间生成原生代码效率和正常手写代码一样高.
java的效率也比较高.生成的代码和手写代码几乎也是一样的.但打包拆包的类型转换会影响一点效率.
C#编译速度就快一些.但执行的时候要JIT编译器来处理泛型.会在一定程度上影响执行效率.
Delphi和C++相似.效率也是很高的.  

约束
C++的模板约束能力比较差.相当于没有.主要是通过代码替换.替换后的代码能便通过就通过了.通不过就报编译错误.不过未来的C++0X标准加入了模板约束.
Java通过编译器保证泛型的约束.
C#通过运行时检查来保证约束.
Delphi通过编译器来保证泛型约束.

兼容性.
C++没有虚拟机,原生代码基本不存在兼容性问题.
java是通过编译器把所有类型都换成object.虚拟机都不用改,和旧的虚拟机完全兼容.兼容性非常好.
C#因为是要虚拟机支持的,所以再旧的.NET Frame虚拟机上不能执行新的泛型代码.
Delphi和C++类似,都是原生代码.所以基本不存在兼容问题.

泛型运行时信息.
C++本身运行时信息就弱的可怜.加之泛型利用代码替换的技术实现,所以基本不具有泛型技术的运行时信息.
Java虽然通过把所有的类型都替换成object实现了良好的兼容性,也有泛型的约束,但是却带来了无法获取运行时信息的难题.因为在Java虚拟机看来都是object,没有分别.
C#虽然通过虚拟机技术支持泛型带来兼容性不好的问题.但是运行时信息却及其强.
Delphi虽然实现技术和C++类似,因为有泛型约束,并且不是象java那样靠虚拟机执行无法区分object.所以Delphi的泛型对运行时信息一点都没有影响.

--
道不远人，人自远。

OpenCms 启动指导

OpenCms 启动指导

1. 启动MySQL 服务进程。
2. tomcat/bin/找到startup.bat, 双击该命令启动Tomcat 服务。
3. 手工启动Apache 服务(如果您安装了IIS之类的)。
4. 访问URL：http://localhost，进入默认站点的首页。
5. 访问URL：http://localhost/system/login/，进入工作区的登录页面。
6. 在登录页面输入用户名Admin 和密码admin（密码第一个字符小写），进入工作区。

--
道不远人，人自远。

集成Apache、Tomcat 和OpenCms 的意义

1) OpenCms 的所有静态资源（如图片或二进制文件）将有Apache 管理并对外提供服务，提
高了站点的整体性能。

2) OpenCms 中的动态资源将由Tomcat 管理，使Tomcat 从处理静态资源中解放出来。

3)可以去掉地址中的两个opencms 部分。

--
道不远人，人自远。

正则表达式语言元素(9)

下表列出了用于修改正则表达式的子表达式。

构造	定义
(? imnsx - imnsx )	对诸如不区分大小写这样的选项进行设置或禁用以使其在模式中间打开或关闭。有关特定选项的信息，请参见正则表达式选项。在封闭组结束之前，选项更改将一直有效。请参见有关分组构造(?imnsx-imnsx: ) 的信息，它是一个更为巧妙的形式。
(?# )	插入到正则表达式内部的内联注释。该注释在第一个右括号字符处终止。
# [至行尾]	X 模式注释。该注释以非转义的 # 开头，并继续到行的结尾。（请注意，必须激活 x 选项或 RegexOptions.IgnorePatternWhitespace 枚举选项才能识别此类注释。）

--
道不远人，人自远。

正则表达式语言元素(8)

替换构造

下表列出了用于修改正则表达式以允许进行二者之一/或匹配的特殊字符。

替换构造	定义
|	与以 |（竖线）字符分隔的术语中的任何一项匹配；例如， cat|dog|tiger。使用最左侧的成功匹配。
(?( 表达式 )yes|no)	如果表达式在此位置匹配，则与"yes"部分匹配；否则，与"no"部分匹配。"no"部分可省略。表达式可以是任何有效的子表达式，但它将变为零宽度断言，因此该语法等效于 (?(?=expression)yes|no)。请注意，如果表达式是命名组的名称或捕获组编号，则替换构造将解释为捕获测试（在本表的下一行对此进行了描述）。若要避免在这些情况下产生混淆，则可以显式拼出内部 (?=expression)。
(?( name )yes|no)	如果命名捕获字符串有匹配，则与"yes"部分匹配；否则，与"no"部分匹配。"no"部分可省略。如果给定的名称不与此表达式中使用的捕获组的名称或编号对应，则替换构造将解释为表达式测试（在本表的上一行进行了描述）。

--
道不远人，人自远。

正则表达式语言元素(7)

下表列出了用于将后向引用修饰符添加到正则表达式中的可选参数。

后向引用构造	定义
\ 数字	后向引用。例如，(\w)\1 查找双写的单词字符。
\k<name>	命名后向引用。例如，(?<char>\w)\k<char> 查找双写的单词字符。表达式 (?<43>\w)\43 执行同样的操作。可以使用单引号替代尖括号，例如 \k'char'。

请注意八进制转义代码和使用相同表示法的 \number 后向引用之间的多义性。有关正则表达式引擎如何解析多义性的详细信息，请参见反向引用。

--
道不远人，人自远。

正则表达式语言元素(6)

分组构造描述了正则表达式的子表达式，通常用于捕获输入字符串的子字符串。下表描述了正则表达式分组构造。

分组构造	说明
( 子表达式 )	捕获匹配的子表达式（或非捕获组；有关更多信息，请参见正则表达式选项中的 ExplicitCapture 选项）。使用 () 的捕获基于左括号按顺序从 1 开始自动编号。捕获元素编号为零的第一个捕获是由整个正则表达式模式匹配的文本。
(?< name > 子表达式)	将匹配的子表达式捕获到一个组名称或编号名称中。用于 name 的字符串不得包含任何标点符号，并且不能以数字开头。可以使用单引号替代尖括号，例如 (?'name')。
(?< name1 - name2 > 子表达式)	（平衡组定义。）删除先前定义的 name2 组的定义，并在 name1 组中存储先前定义的 name2 组和当前组之间的间隔。如果未定义 name2 组，则匹配将回溯。由于删除 name2 的最后一个定义会显示 name2 的先前定义，因此该构造允许将 name2 组的捕获堆栈用作计数器，用于跟踪嵌套构造（如括号）。在此构造中，name1 是可选的。可以使用单引号替代尖括号，例如 (?'name1-name2')。 有关更多信息，请参见本主题中的示例。
(?: 子表达式)	（非捕获组。）不捕获由子表达式匹配的子字符串。
(?imnsx-imnsx: 子表达式)	应用或禁用子表达式中指定的选项。例如，(?i-s: ) 将打开不区分大小写并禁用单行模式。有关更多信息，请参见正则表达式选项。
(?= 子表达式)	（零宽度正预测先行断言。）仅当子表达式在此位置的右侧匹配时才继续匹配。例如，\w+(?=\d) 与后跟数字的单词匹配，而不与该数字匹配。此构造不会回溯。
(?! 子表达式)	（零宽度负预测先行断言。）仅当子表达式不在此位置的右侧匹配时才继续匹配。例如，\b(?!un)\w+\b 与不以 un 开头的单词匹配。
(?<= 子表达式)	（零宽度正回顾后发断言。）仅当子表达式在此位置的左侧匹配时才继续匹配。例如，(?<=19)99 与跟在 19 后面的 99 的实例匹配。此构造不会回溯。
(?<! 子表达式)	（零宽度负回顾后发断言。）仅当子表达式不在此位置的左侧匹配时才继续匹配。
(?> 子表达式)	（非回溯子表达式（也称为"贪婪"子表达式）。）该子表达式仅完全匹配一次，然后就不会逐段参与回溯了。（也就是说，该子表达式仅与可由该子表达式单独匹配的字符串匹配。） 默认情况下，如果匹配未成功，回溯会搜索其他可能的匹配。如果已知无法成功回溯，可以使用非回溯子表达式避免不必要的搜索，从而提高性能。

命名捕获基于左括号按从左到右的顺序依次编号（与非命名捕获类似），但在对所有非命名捕获进行计数之后才开始对命名捕获编号。例如，模式 ((?<One>abc)/d+)?(?<Two>xyz)(.*) 按编号和名称产生下列捕获组。（编号为 0 的第一个捕获总是指整个模式）。

编号	名称	模式
0	0（默认名称）	((?<One>abc)/d+)?(?<Two>xyz)(.*)
1	1（默认名称）	((?<One>abc)/d+)
2	2（默认名称）	(.*)
3	1	(?<One>abc)
4	2	(?<Two>xyz)

平衡组定义示例

---

下 面的代码示例演示使用平衡组定义匹配输入字符串中的左右尖括号 (<>)。在该示例中，像使用堆栈那样使用 Open 组和 Close 组的捕获集合来跟踪尖括号配对：将所捕获的各左尖括号放入 Open 组的捕获集合中；将所捕获的各右尖括号放入 Close 组的捕获集合中；平衡组定义确保每个左尖括号均有一个匹配的右尖括号。

Visual Basic

复制代码

' This code example demonstrates using the balancing group definition feature of 
  ' regular expressions to match balanced left angle bracket (<) and right angle 
' bracket (>) characters in a string. 

Imports System
  Imports System.Text.RegularExpressions

Class Sample
    Public Shared Sub Main() 
  '
'    The following expression matches all balanced left and right angle brackets(<>). 
'    The expression:
  '    1)   Matches and discards zero or more non-angle bracket characters.
'    2)   Matches zero or more of:
'    2a)  One or more of:
  '    2a1) A group named "Open" that matches a left angle bracket, followed by zero 
'         or more non-angle bracket characters. 
  '         "Open" essentially counts the number of left angle brackets.
'    2b) One or more of:
  '    2b1) A balancing group named "Close" that matches a right angle bracket, 
'         followed by zero or more non-angle bracket characters. 
  '         "Close" essentially counts the number of right angle brackets.
'    3)   If the "Open" group contains an unaccounted for left angle bracket, the 
  '        entire regular expression fails.
'
        Dim pattern As String = "^[^<>]*" & _
                                  "(" + "((?'Open'<)[^<>]*)+" & _
                                "((?'Close-Open'>)[^<>]*)+" + ")*" & _
                                  "(?(Open)(?!))$"
        Dim input As String = "<abc><mno<xyz>>"
  '
        Dim m As Match = Regex.Match(input, pattern)
        If m.Success = True Then
              Console.WriteLine("Input: ""{0}"" " & vbCrLf & "Match: ""{1}""", _
                                 input, m)
        Else
            Console.WriteLine("Match failed.")
        End If
      End Sub 'Main
End Class 'Sample 
  
'This code example produces the following results:
'
'Input: "<abc><mno<xyz>>"
  'Match: "<abc><mno<xyz>>"
'

C#

复制代码

// This code example demonstrates using the balancing group definition feature of 
  // regular expressions to match balanced left angle bracket (<) and right angle 
// bracket (>) characters in a string. 

using System;
  using System.Text.RegularExpressions;

class Sample 
{
    public static void Main() 
      {
/*
    The following expression matches all balanced left and right angle brackets(<>). 
    The expression:
    1)   Matches and discards zero or more non-angle bracket characters.
      2)   Matches zero or more of:
    2a)  One or more of:
    2a1) A group named "Open" that matches a left angle bracket, followed by zero 
           or more non-angle bracket characters. 
         "Open" essentially counts the number of left angle brackets.
    2b) One or more of:
      2b1) A balancing group named "Close" that matches a right angle bracket, 
         followed by zero or more non-angle bracket characters. 
           "Close" essentially counts the number of right angle brackets.
    3)   If the "Open" group contains an unaccounted for left angle bracket, the 
          entire regular expression fails.
*/
    string pattern = "^[^<>]*" +
                     "(" + 
                         "((?'Open'<)[^<>]*)+" +
                       "((?'Close-Open'>)[^<>]*)+" +
                       ")*" +
                     "(?(Open)(?!))$";
      string input = "<abc><mno<xyz>>";
//
    Match m = Regex.Match(input, pattern);
      if (m.Success == true)
        Console.WriteLine("Input: \"{0}\" \nMatch: \"{1}\"", input, m);
      else
        Console.WriteLine("Match failed.");
    }
}

/*
  This code example produces the following results:

Input: "<abc><mno<xyz>>"
Match: "<abc><mno<xyz>>"
  
*/

--
道不远人，人自远。

正则表达式语言元素(5)

限定符将可选数量的数据添加到正则表达式。限定符表达式应用于紧挨着它前面的字符、组或字符类。.NET Framework 正则表达式支持最小匹配 (lazy) 限定符。

下表描述了影响匹配的元字符。数量 n 和 m 是整数常数。

限定符	说明
*	指定零个或更多个匹配；例如 \w* 或 (abc)*。等效于 {0,}。
+	指定一个或多个匹配；例如 \w+ 或 (abc)+。等效于 {1,}。
?	指定零个或一个匹配；例如 \w? 或 (abc)?。等效于 {0,1}。
{ n }	指定恰好 n 个匹配；例如 (pizza){2}。
{ n ,}	指定至少 n 个匹配；例如 (abc){2,}。
{ n , m }	指定至少 n 个但不多于 m 个匹配。
*?	指定尽可能少地使用重复的第一个匹配（等效于 lazy *）。
+?	指定尽可能少地使用重复但至少使用一次（等效于 lazy +）。
??	指定使用零次重复（如有可能）或一次重复 (lazy ?)。
{ n }?	等效于 {n} (lazy {n})。
{ n ,}?	指定尽可能少地使用重复但至少使用 n 次 (lazy {n,})。
{ n , m }?	指定介于 n 次和 m 次之间、尽可能少地使用重复 (lazy {n,m})。

--
道不远人，人自远。

正则表达式语言元素(4)

原子零宽度断言

下表中描述的元字符不会使引擎在字符串中前进或使用字符。它们只是根据字符串中的当前位置使匹配成功或失败。例如，^ 指定当前位置在行或字符串的开头。因此，正则表达式 ^FTP 只会返回那些在行的开头出现的字符串"FTP"的匹配项。

断言	说明
^	指定匹配必须出现在字符串的开头或行的开头。有关更多信息，请参见正则表达式选项中的 Multiline 选项。
$	指定匹配必须出现在以下位置：字符串结尾、字符串结尾处的 \n 之前或行的结尾。有关更多信息，请参见正则表达式选项中的 Multiline 选项。
\A	指定匹配必须出现在字符串的开头（忽略 Multiline 选项）。
\Z	指定匹配必须出现在字符串的结尾或字符串结尾处的 \n 之前（忽略 Multiline 选项）。
\z	指定匹配必须出现在字符串的结尾（忽略 Multiline 选项）。
\G	指定匹配必须出现在上一个匹配结束的地方。与 Match.NextMatch() 一起使用时，此断言确保所有匹配都是连续的。
\b	指定匹配必须出现在 \w（字母数字）和 \W（非字母数字）字符之间的边界上。匹配必须出现在单词边界上（即出现在由任何非字母数字字符分隔的单词中第一个或最后一个字符上）。匹配也可以出现在字符串结尾处的单词边界上。
\B	指定匹配不得出现在 \b 边界上。

--
道不远人，人自远。

正则表达式语言元素(3)

可以使用影响匹配行为的选项修改正则表达式模式。可以通过下列两种基本方法之一设置正则表达式选项：可以在 Regex (pattern, options) 构造函数中的 options 参数中指定，其中 options 是 RegexOptions 枚举值的按位"或"组合；也可以使用内联 (?imnsx-imnsx:) 分组构造或 (?imnsx-imnsx) 其他构造在正则表达式模式内设置它们。

在内联选项构造中，一个选项或一组选项前面的减号 (-) 用于关闭这些选项。例如，内联构造 (?ix-ms) 将打开 IgnoreCase 和 IgnorePatternWhiteSpace 选项而关闭 Multiline 和 Singleline 选项。默认情况下，关闭所有正则表达式选项。

下表列出了 RegexOptions 枚举的成员以及等效的内联选项字符。请注意，选项 RightToLeft 和 Compiled 只适用于表达式整体而不允许内联。（它们只能在 Regex 构造函数的 options 参数中指定。）选项 None 和 ECMAScript 不允许内联。

RegexOption 成员	内联字符	说明
None	N/A	指定不设置任何选项。
IgnoreCase	i	指定不区分大小写的匹配。
Multiline	m	指定多行模式。更改 ^ 和 $ 的含义，以使它们分别与任何行的开头和结尾匹配，而不只是与整个字符串的开头和结尾匹配。
ExplicitCapture	n	指定唯一有效的捕获是显式命名或编号的 (?<name>…) 形式的组。这允许圆括号充当非捕获组，从而避免了由 (?:…) 导致的语法上的笨拙。
Compiled	N/A	指定正则表达式将被编译为程序集。生成该正则表达式的 Microsoft 中间语言 (MSIL) 代码；以较长的启动时间为代价，得到更快的执行速度。
Singleline	s	指定单行模式。更改句点字符 (.) 的含义，以使它与每个字符（而不是除 \n 之外的所有字符）匹配。
IgnorePatternWhitespace	x	指定从模式中排除非转义空白并启用数字符号 (#) 后面的注释。（有关转义空白字符的列表，请参见字符转义。）请注意，空白永远不会从字符类中消除。
RightToLeft	N/A	指 定搜索是从右向左而不是从左向右进行的。具有此选项的正则表达式将移动到起始位置的左边而不是右边。（因此，起始位置应指定为字符串的结尾而不是开头。） 为了避免构造具有无限循环的正则表达式的可能性，此选项不能在中流指定。但是，(?<) 回顾后发构造提供了可用作子表达式的类似替代物。 RightToLeft 只更改搜索方向。它不会反转所搜索的子字符串。预测先行和回顾后发断言不改变：预测先行向右搜索；回顾后发向左搜索。
ECMAScript	N/A	指定已为表达式启用了符合 ECMAScript 的行为。此选项仅可与 IgnoreCase 和 Multiline 标志一起使用。将 ECMAScript 同任何其他标志一起使用将导致异常。
CultureInvariant	N/A	指定忽略语言中的区域性差异。有关更多信息，请参见在 RegularExpressions 命名空间中执行不区分区域性的操作。

--
道不远人，人自远。

正则表达式语言元素(2)

只在替换模式中允许替换。对于正则表达式中的类似功能，使用后向引用（如 \1）。有关后向引用的详细信息，请参见反向引用和后向引用构造。

字符转义和替换是在替换模式中识别的唯一的特殊构造。下面几部分描述的所有语法构造只允许出现在正则表达式中；替换模式中不识别它们。例如，替换模式 a*${txt}b 会插入字符串"a*"，该字符串后跟按 txt 捕获组匹配的子字符串，该子字符串后跟字符串"b"（如果有）。在替换模式中，* 字符不会识别为元字符。与此类似，在正则表达式匹配模式中不识别 $ 模式。在正则表达式中，$ 指定字符串的结尾。

下表显示如何定义命名并编号的替换模式。

字符	说明
$ 数字	替换按组号 number（十进制）匹配的最后一个子字符串。
${ name }	替换由 (?<name> ) 组匹配的最后一个子字符串。
$$	替换单个"$"字符。
$&	替换完全匹配本身的一个副本。
$`	替换匹配前的输入字符串的所有文本。
$'	替换匹配后的输入字符串的所有文本。
$+	替换最后捕获的组。
$_	替换整个输入字符串。

--
道不远人，人自远。

正则表达式语言元素(1)

.NET Framework SDK 提供了大量的正则表达式工具，使您能够高效地创建、比较和修改字符串，以及迅速地分析大量文本和数据以搜索、移除和替换文本模式。

大多数重要的正则表达式语言运算符都是非转义的单个字符。转义符 \（单个反斜杠）通知正则表达式分析器反斜杠后面的字符不是运算符。例如，分析器将星号 (*) 视为重复限定符，而将后跟星号的反斜杠 (\*) 视为 Unicode 字符 002A。

下表中列出的字符转义在正则表达式和替换模式中都会被识别。

转义符	说明
一般字符	除 .$ ^ { [ ( | ) * + ? \ 外，其他字符与自身匹配。
\a	与响铃（警报）\u0007 匹配。
\b	如果在 [] 字符类中，则与退格符 \u0008 匹配；如果不是这种情况，请参见本表后面的“注意”部分。
\t	与 Tab 符 \u0009 匹配。
\r	与回车符 \u000D 匹配。
\v	与垂直 Tab 符 \u000B 匹配。
\f	与换页符 \u000C 匹配。
\n	与换行符 \u000A 匹配。
\e	与 Esc 符 \u001B 匹配。
\040	将 ASCII 字符匹配为八进制数（最多三位）；如果没有前导零的数字只有一位数或者与捕获组号相对应，则该数字为后向引用。（有关更多信息，请参见反向引用。）例如，字符 \040 表示空格。
\x20	使用十六进制表示形式（恰好两位）与 ASCII 字符匹配。
\cC	与 ASCII 控制字符匹配；例如，\cC 为 Ctrl-C。
\u0020	使用十六进制表示形式（恰好四位）与 Unicode 字符匹配。 注意 .NET Framework 不支持用于指定 Unicode 的 Perl 5 字符转义。Perl 5 字符转义的格式是 \x{####…}，其中“####…”是十六进制数字的序列。应改为使用本行中描述的 .NET Framework 字符转义。
\	在后面带有不识别为转义符的字符时，与该字符匹配。例如，\* 与 \x2A 相同。

注意
转义字符 \b 是一个特例。在正则表达式中，\b 表示单词边界（在 \w 和 \W 之间），不过，在 [] 字符类中，\b 表示退格符。在替换模式中，\b 始终表示退格符。

--
道不远人，人自远。

代码生成工具CodeSmith与SmartCode学习

   近段时间学习了代码生成工具，一是CodeSmith，二是SmartCode。
总的来说个人比较倾向于SmartCode，因为其是开源的，并且附带了很多的可以直接使用的模板，也有视频演示视频。学习起来非常的轻松！而CodeSmith是商业的，虽然有破解的，但是就是用不太习惯，codeSmith是基于asp.net的语法编写template的，习惯了codebind模式后，现在直接写<%%>感觉不是太习惯。SmartCode直接采用lib的方式编写模板，使用的时候添加assembly就可以了，对习惯了编写后台的人比较适合点。
  使用代码生成器可以提高效率，一般是对这套代码模式非常清楚又不想重复的做体力活，那么他们是你的选择。同时呢，你可以看他们的模板特别是smartcode的，可以学习到一些设计的思想哈。这些都算是经验的总结吧！

--
道不远人，人自远。

必须勤奋些

最近把hibernate文档又看了一遍，果然比第一次看的时候理解更深些，还看了教程，总算有个入门吧，暂时告一段落吧！
想看看web service 和 spring 相关的东西。加油！
现在白天搞 .net ，晚上搞 java 。 有点不连续。 自己得抓紧，得勤奋些，不聪明的人只能这样了。
坚持，坚持，保持耐心，拥有希望！

Hibernate简要笔记

1.
mysql engine:innoDb 支持事务， 其他的有些不支持事务，在Hibernate中默认事务是不开启的和jdbc

相反，所以如果数据不支持引擎，对hibernate来说插入数据都是有效的。

2.
save 与 persist。 没开事务的时候 persist不会插入（insert）数据。

3.
update，没记录时会抛异常

4.
transient:数据库里没相应记录与之对应，new出来的，没id值
persistent:数据库里有相应记录与之对应，并与session关联，有id值
detached:数据库里没相应记录与之对应，但是没有session与之关联，有id值

看图。

5.
hibernate查询的方式：

1）HQL

2）Criteria

6.
java实体类或属性名与数据库关键字冲突问题。
1）改表名
2）表名加反引号 ` , 字段名
3）表名加 [] 括起来 ， 我自己摸索出来的。

7.
hql 命名参数， 把 name=？ 代替 为 name=:name  ,这样不需要 依赖于顺序了

8.
many to one: 基于对象建模，对象

one to many: set<对象> 使用泛型，配置的 one-to-many中需要配置class属性

one to one :foreign,constrained约束

many to many: 转成 2个 one to many的，连接表。性能问题。

component: 组件

9.
集合：PersitentSet。

10.
cascade ：用来说明当对主对象进行某种操作是否对其关联的从对象也做类似的操作
        none、all、save-update、delete、lock、refresh、evict、replicate、
        persist、merge、delete-orphan。一般不在 many to many，mang ot one中设置级联
    ，在one ot one 和 one to many 中设置。
       级联一般配置在 set list 等 中。
        在one的一端！！！
inverse ：表示是是否放弃维护关联关系。one to many 维护关联关系就是更新外键，
        many to many 维护关联关系就是在中间表（关联表）增减记录

           在父对象的一端或者one的一端放弃 维护关联关系（true）。关系由多的一段维护。
           对象模型关联的设置。
           可以提升性能。

           在list 和 array中不能出现 invers属性。有序的集合必须维护关系。
           多的一端不能设置inverse属性。

11.
继承映射。三种策略，或者四种。

1）一张表一个继承树，效率高，增加子类需修改表结构，子表字段不能非空字段
    subclass。子类
    discriminator。鉴别器。
2）每个类一张表，一个父表，多个字表。
    joined - subclass 。table。 key 外键。
3) 1)2)混合使用，join
4）每个类都有一张独立表。

    union - subclass。
12.懒加载， 提高性能
1）
load 方法。 懒加载。 lazy，load。

asm，cglib，不能是final的 ，如果是的话，lazy 失效。

Hibrenate.initialize（Class claaz）；
2）one to one ，lazy（主对象不会出现，从对象出现）
   a。lazy！=false，
   b。constrained = true // 从对象
   c。fetch = select
分多次查询，即在需要的时候查询，fetch如果为join的话，lazy就失效了。
访问的时候就查询。

相关的属性什么时候查询。

3）one to many ，many to mangy ， lazy
  a。lazy！=false
  b。fetch = select

4）many to one。lazy 缺省是lazy的
  a。lazy！=false
  b。fetch = select

5）懒加载对象都是代理对象，getId，getClass不会触发懒加载，Initialize（proxy）方法

13.
Cache分析。。
1）session里有cache，session不关闭，2次同一个get。session生命周期比较短，起缓存作用比较小
   save update load CreateQuery(不行)， 清理，clear（全部） evict（一条）。
   一级缓存没有限制。大数据量很容易内存溢出。
2）sessionFactory里也有，二级缓存，配置文件配置。

   cache.use_second_level_cache ： true.
   cache.provider: class(HashTable,OSCache,Ehcache，TreeCache，SwarmCache)
   OsCache 配置文件。
 
  每一个类需要缓存的设置：
  cfg中： class cache， usage：read only ，  read write， nonstrict-read-write，

transactional。
  hbm中：Cache。命中率，session。clear（）清除一级缓存

3）打开统计信息：
   generate_staticstics : true.

   或得统计信息：SessionFactory。getStastics（）返回的是Statistics类里面有不少描述信息；

   清理   evict()
 
  CreateQuery ：难以利用缓存。命中率低。

14.
分布式缓存，集群。，读取快，更新慢。

OScache支持。

中央缓存。更新快，读取慢，memcache

数据缓存的条件。
a。读取的次数大于修改的次数。
b。数据量不能太大
c。对数据有独享的控制权
d。可以容忍出现无效的数据


15.
事务相关。

JDBC事务一个数据库，JTA事务-分布式事务-跨数据库，JTA容器。

JNDI：类似注册表。

事务边界：事务开始，事务提交，事务回滚。

16.
opensessionInView
    页面渲染的时候，session能够打开
    Servlet Filter 里使用Session， getLocalSession
ThreadLocal 局部线程变量

要从SessionFactory中获得GetCucrrentSession的话需要配置
current_Session_context_class。否则会异常。
值为thread（ThreadLocal）或者jta（jta事务管理器）。


17.
乐观锁：hibernate用version和timestamp控制实现
悲观锁：数据库实现

18.
Session是非线程安全的。周期短，尽量晚的获取，尽量早的释放。他代表一个数据库连接。
SessionFactory是线程安全的。一个数据库对应一个SessionFactory，周期长。


19.
flush:一级缓存和数据库同步


20.

HQL:
查询多个对象，返回的是对象。要返回多个列，返回Object[]。


根据ID查询时，get、load查询和CreateQuery（不能利用缓存）的差别：性能～～


21.

N+1查询：iterator。
懒加载：fetch-》join，利用缓存。



detachedCriteria：离线查询，动态SQL。

22.
监听器。
拦截器与事件：Interceptor接口。

实现接口，
cfg，里配置even

推荐用 监听器。

23.
(1)使用sql，不用hql。
Query createSQLQuery(String).操作的是表，跟平时操作sql一样。

返回的是对象。

(2)使用Query节点，属性 name(可以放在class里面也可以放在外面，在里面的时候需要加上包的全路径

名)，，即命名查询。把hql，放到hbm。xml文件里统一管理。
类似ibatis。

Query getNamedQuery(String name);

(3)
sql-query节点。里面使用的是sql。

24.
保存Domain对象，可以用Map代替。将对象转为xml。


25.
Best practice。

不适合的场景：
1）OLAP，一查询为主，相反适合OLTP
2）关系模型设计不合理的，
3）数据量巨大，性能要求苛刻。

1）细粒度设计持久类 component
2）id
3）每个持久类一个映射文件
4）映射文件作为资源加载
5）自然组件，覆盖hascode，equal
6）考虑把查询串发在hbm。xml配置文件里。
7）少用？多用变量名
8）不要自己管理jdbc 连接。
9）考虑使用自定义类型，UserType
10）性能瓶颈使用硬编码的jdbc实现
11）session flush 成本比较高，尽量不手动管理。交给hibernate
12）在三层架构中使用托管对象 detached object
13）在2层结构中，考虑使用长 持久上下文
14）不要把异常看成可恢复的，catch 回滚是，必须throw出来，让上层调用者知道。
15）对于关联有限考虑lazy fetching。
16）避免open session in view 的问题。
17）考虑把hibernate 代码从业务逻辑代码中抽象出来。
18）不要使用怪异的连接映射
19）偏爱双向关联。单项管理更难查询？？？

--自助者天助之--

--
道不远人，人自远。

人体24小时状态热图

时间 身体状况 适宜的活动
1∶00 人体进入浅睡眠阶段，易醒，对痛觉特别敏感。 睡眠休息
2∶00 体内大部分器官处于一天中工作最慢的时刻。而肝脏却在紧张地工作，为人体排毒。
3∶00 全身处于休息状态，肌肉完全放松。
4∶00 血压最低，人体脑部供血最少。所以，此时老年人容易发生心脑血管意外。
5∶00 经历了一定时间的睡眠，人体得到了充分休息。此时起床，显得精神饱满。 起床（如果可以）
6∶00 血压开始升高，心跳也逐渐加快。 起床、锻炼、日计划
7∶00 体温开始上升，人体免疫力最强。 创造性的工作
8∶00 皮肤有毒物质排除殆尽，性激素含量最高。
9∶00 皮肤痛觉降低。此时是就医注射的好时机。 完成工作任务
10∶00 精力充沛，最适宜工作。
11∶00 精力最旺盛，人体不易感觉疲劳。
12∶00 经历了一个上午的工作，人体需要休息。 整理、总结
13∶00 此时胃液分泌最多，胃肠加紧工作，适宜进餐，人体稍感疲乏，需要短时间的休息。 午餐
14∶00 人体应激能力下降，全身反应迟钝。 午睡
15∶00 体温最高，工作能力开始恢复。 执行工作任务
16∶00 血糖升高，脸部最红。
17∶00 工作效率最高，肺部呼吸运动最活跃，适宜进行体育锻炼 体育锻炼
18∶00 人体痛觉再度降低。 休息
19∶00 血压略有升高。此时，人们情绪最不稳定。 晚餐
20∶00 记忆力最强，大脑反应异常迅速。 阅读、学习
21∶00 脑神经反应活跃，适宜学习和记忆。 个人爱好
22∶00 呼吸开始减慢，体温逐渐下降。
23∶00 机体功能处于休息状态，一天的疲劳开始缓解。 整理、总结，睡眠休息
24∶00 进入睡眠状态，充分恢复体能。 睡眠休息

外语！外语！

　　外语！外语！我要重试学习的激情！今天又受打击了！５５５～～～


　　计划！计划！一定要执行！


　　耐心！耐心！保持信心！

　　
　　继续奋斗！继续找！

Invist-.net O/R mapper - code generator（.net o/r 映射 代码生成器）

无意间在http://visualstudiogallery.com上看到了Vs 2008的一个插件 - Invist - http://www.invist.net/。
上有详细介绍和文档说明。首先下了软件，然后看了视频演示。再打开vs2008，操作了一遍感觉很爽哦～ 不到一瞬间，数据访问层最垃圾的事情基本都解决了哈！ cool！！！ 明天再仔细研究下，看看是否可以用与企业开发中，看看性能如何！！！

mark！