再往下纯属个人观点，喜欢看的看，不喜欢看的闪，我说的不是真理，看了照做起反作用的别找我，谁的大脑都有自己过滤的功能。

两个人在一起，可能会有争吵分歧，但更多的是要宽容，理解，信任。人生苦短，两个人生的交集共同走过的时间更短，把二人世界的每一天都过得温馨，幸福吧！

•实实在在的理解和信任，建立在充分了解对方的基础之上。
可能有人会说，不信任对方，怎么交往？对，最初的信任，是盲目的信任，因为你必须信任，但是这时当问你在某件事情上为什么信任对方？大多是说不出的。随着了解的深入，你会知道对方在某件事情上做出什么处理，就可以说出来你是为什么信任对方的。理解也是这个道理。

•争吵的目的不是解气，而是解决问题。
•争吵时可以表达自己的不快，但是分手等话千万不要说。

争吵常常伴随着冲动，冲动又会口不择言，比如，”过不下去就tm离”等等，我认为，两个人的争吵是正常的，但是争吵的目的往往不是争出谁对谁错，更不是动不动就以”离”相逼，最终目的是解决问题才对。我跟她说过，吵架可以，但是不能提分手。

不管在何种状态何种情况下，说分手，离婚，代表着对这段感情已经放弃了，这是一个可怕的事情，可能你说出的是气话，但是在对方听来很刺耳，很痛心，并且，ta认为，你想放弃了，这个念头儿ta会一直记得。而往往说出这样儿的话，都是由于争吵产生的不理智而引起的。

•家，是可以放松，但绝对不是让你放肆的地方。
每个人在工作中都会遇到不愉快，不顺利，但是这绝对不是你在家发脾气的理由儿。回到家，你可以好好儿休息，也可以和ta说说工作上的事情，让ta知道你的状态，看看能否给你一些建议等等。所以我认为，家，是可以放松，但绝对不是让你随意放肆的地方。
两个人组成了家并不容易，你发一通儿脾气，有可能对方还不知道是怎么回事儿，那就会觉得委屈。当然，因为ta爱你，也理解你，有可能会忍让，但是，一而再，再而三的这样儿，试问，谁能受的了你？
这是一个神奇的问题，发脾气的一方会想，我外边儿受了那么大的气，回家还不让我发泄一下儿？！
而另外一方呢？你外边儿不顺心了有本事外边儿发脾气去啊，别在这儿玩儿窝里横，你凭什么在我这儿发脾气？我招你惹你了？
所以矛盾很尖锐，其实想想看，ta发脾气了，你可以容忍一下儿，等事后再给ta讲道理。因为，家，是ta最后的避风港了。
但是ta也要想想，你不能总是这样用你的坏脾气来在糟蹋这个家，要不就连最后的避风港都没有了，不是么？
最主要的，还是取决于发脾气的那个人，如果那个人不发脾气，至少这个问题就不是问题。
两个人的爱，并不像父母给你的爱一样。父母的爱那是真的无私的，你即使跟他们发脾气，他们也一样爱着你。
而两个人的爱是相互的，所以才会出现付出与回报(这个话题也很有的说)，这时再想想，你这么糟蹋着家，糟蹋着ta因为爱你而容忍你的脾气，会没有问题么？

•ta除了是你的爱人，还是你的朋友，老师，知己。
两个人在家庭中总是处于不同的角色。ta们互为爱人，朋友，老师，知己等等。
每个人都有长处和短处，取长补短，在一个家中也不例外。两个人除了谈情说爱之外，也要思想上的交流与沟通才好，坐在一起聊聊天儿，让对方更了解自己，这是一种不错的方法。

•缘分只能让两个人相识，别走不到一起就说是”有缘无分”，缘分招谁惹谁了？

家中的ta，也是要你去珍惜的，两个人走到一起不容易，缘分让彼此认识了，缘分的任务也就完成了，两个人至于下来如何发展，就看如何用心的营造好这个家了吧。

Over……

一种是家的成员论，这种观点认为家不在于它的大小，位置，奢侈抑或贫穷等外在形式方面的因素，在于家中的成员是否相亲相爱，携手生活。
这个观点应该也是大多数人认同并执行的，就像两个人相识，相亲，相爱，结婚并携手人生路。

另外一种是家的形式论，这种是某一方先把家（的形式）建立好（比如买好房子，买好床，做好装修等），然后找一个人来填补成员的空缺。

前者，属于两人共同创造了一个家，然后一起享受创造的结果。
这种观点在乎的是我和谁，对方一个怎么样的人来共同进行创造，组成这个家。我和对方关心的都是对方的这个人，而对于我们能组成一个什么形式(样子)的家，是次要的(当然，也不能这个家的形式太惨了，惨的没法儿过日子了，那就是贫贱夫妻百事衰了)。

后者，是一方先进行了创造，然后找进来一个人填补另外一方空缺的位置，一人创造，共同享受。一个创造者，一个享受者，在对方的心里的地位和水平是不一样的。我娶(嫁)你，是因为我的家缺少了一个女(男)人，你是来填补这个空缺的，仅此而已。
家我创造好了，你进来就行了，我在乎的是这个位置上有个人，但这个人是谁，我不会过于关心。
包办婚姻，搓花儿打蜜傍款套现，也会有些这种意味儿吧。

我个人和两位朋友，和大多数儿人还是认同家的成员论，爱情乃至婚姻在大多大多数儿情况下不是随便找个人来填个位置就能幸福的，我也不能例外。（很幸运，去年年底找到了我的她，并且现在我们很好，未来我也有信心我们会更好。）

现在我的观点是，家，最重要的在于它的成员，但是形式也是必要的。成员是家的基本要素，而形式则是促进家的成员和谐幸福的因素。

再贫两句题外话，当然了，现在还有另外一种情况，就是婚外情，那就出现了小三儿，不管男女，都是小三儿，别光把小三儿的称号扣给女人，这不公平，在以前小三儿也被称为奸夫淫妇，我自认为在这方面儿算非常洁身自好，所以可以有资格说一句自己的观点，”小三儿们，SB们。”这是题外话，在这里不多说，以后有兴趣可以单独好好儿想想这种现象写一篇文章出来。

闲话了一大堆，最后祝看了此文的朋友们有了主儿的合合美美，没有主儿的想找个主儿的快点儿实现，没有主儿的也不想找个主儿的那更得谢谢您花了这么长时间看了篇可能暂时对您没用的文章了，不过也祝您一个人活的精彩。

这是一篇受密码保护的文章。您需要提供访问密码：

密码：

先来说明我的结论：
1. “不给别人留疑问”不仅局限于邮件，可以渗透到咱们工作、生活中，都适用。
2. “自省”是一种工作、生活的习惯。“自省”分为主动和被动两方面。

再来看我的思考：
“不给别人留疑问”：
这个话题刚开始的讲解是使用邮件，来说明一份邮件要做什么，为什么做，后续工作如何完成等等。
如果做到邮件内容的简洁，明了，让收件人一看就是知道什么事情，该怎么做。

除了邮件之外，再从技术角度拿天天都开发的代码来说。
咱们写代码的目的除了效率，实现功能外，也需要给别人看，
如果咱们的代码的注释都写的很好，那么别人在看自己写的代码的时候，就不用来问自己，为什么这么写？这段代码干什么用的？
这个如果做到了，就是不给别人留疑问。

可以自己再来开拓思路，会发现很多地方都可以做到“不给别人留疑问”，不局限于工作，包括生活。

比如很常见的场景，
A：你要喝什么？
B：我要喝可乐。
A：你喝什么可乐？
B：我喝可口可乐。

如果第一次B直接回答我要喝可口可乐，那么就不会有第二次对话，就是“不给别人留疑问”。

============================

再来说说“自省”:
在“自省”的基础上，我理解为主动的“自省”与被动的“自省”。
被动的就是指出现问题之后，咱们先来从自身考虑，是被动的。
主动的就是指在没有问题出现，每天或者每周都来回顾、思考一下自己的工作、生活，有没有需要改进的。

这么来不是很恰当的总结下，
被动的“自省”是指亡羊补牢，为时未晚，
主动的“自省”是指防患于未然。

优劣自然显现，当然主动的要比被动的更积极了。

周五请了一天假，本来想在家好好复习，一看需要复习，需要背的东西太多了，结果耗过去了，周六也是，faint……

反思了一下，有如下几点做的不好：
1. 没有统计复习的难度，导致在复习的时候，发现复习的量和复习的点都很多，结果头很大；

2. 在头很大的情况下，没有进行分析，分析主要复习哪些容易拿分儿，拿分儿多，哪些是次要复习的，导致每次复习都从头开始，这就好像抱着本儿英文单词书，从字母A开始背单词，背两天放下了，再拿起来，还是从新开始从A开始背；

3. 复习的时候并不专心，开心，QQ，微博，邮件等发个信息，回个信息看似耗费不了多长时间，其实不然，从一个开心的转贴能看10多个转贴，时间就是这么一点点耗费的，我粗略统计了下，这两天因为这个原因耗费了我至少10个小时的时间，多么可观；

4. 懒惰，时间观念不强，总是想着还有时间，结果就还有不到6个小时的时间了。

———————————————
针对于上面的反思，可以采用如下方法来改进：

1. 不管是工作，还是复习功课亦或是做其他事情，都要先在开始前进行分析，计划，制定可行的目标和时间点，这样心里才有底；

2. 做事情要分清主次，虽然在GTD管理里面提到如果做一件事情小于两分钟，就要立即做完，但是在自觉性较低的情况下，哪怕一分钟，不重要，就不做，先把不能分清主次的问题给纠正过来；

3. 做好时间管理，并且提高对时间管理的思想认识，在规定的时间里就必须要完成计划好的事情；

4. 给自己完成事情创造好的环境，例如，复习的时候，就是不开电脑，那么就不会在聊天这些方面耗费时间了；或者看书，就带着本书去个咖啡屋看一下午，除了看书不能干别的事情，自己只好看书，从客观环境来帮助自己完成事情；

———————————————
画个小图： 要做事情 —–> 先分析事情 —–> 分析后制定好计划时间点和目标 —–> 给自己创造环境，严格遵是时间来完成既定的目标 —–> 每次都进行总结，看看还有什么需要改进，在下次更进一步。

———————————————
最终的结论是：在思想上放松了，导致行动计划放慢安排的不合理，最终的结果就是放弃或者是失败。

总结于此，与朋友们共勉。

点根烟，喝杯咖啡，努力的看最后6个小时的书。虽然如此，还是希望今天考试一切顺利！

同时，我认为：技术，源于生活，应用于生活。

举个例子：程序中，在service层有个异常，不知道应该如何处理，那么最终就会抛出异常给上层（Action层）处理；这个在工作中，如果你没有办法决定一个事情应该如何处理，那么就需要交给（求助于）上级领导来处理。
所以说，技术的思维不应该只局限于处理技术问题，还可以处理工作、生活中的问题。将技术所能产生的效益最大化。

————————-下面是英文原文和对应的中文翻译————————-

其中我认为：
我们必须记住，打地基比砌墙更需要坚实，长期目标脱离了扎实的短期目标的实现是不能实现的。
短期目标的实现是以以前完成的目标为前提的。
这两句比较重要，打地基好比技术的基础，比如java基础，砌墙就像一些建立在基础之上的类似于应用框架等等，只有基础打的扎实了，砌墙才能更有效率。

There are three kinds of goals: shirt-term, medium-range and long long-term goals.

Short-term goals are those that usually deal with current activities which we can apply on a daily basis.
Such goals can be achieved in a week or less, or two weeks, or possibly, months.
It should be remembered that just as building is no stronger than its foundation, long-term goals cannot amount to very munch without the achievement of solid short-term goals.
Upon completing our short-term goals, we should date the occasion and then add new short-term goals that will build on those that have been completed.

The intermediate goals build on the foundation of the short-term goals. They might deal with just one term of school or the entire school year, or they could even extend for several years.
Any time you move a step at a time, you should never allow yourself to become discouraged or overwhelmed.
As you complete each step, you will enforce the belief in your ability to grow and succeed.
And as your list of completion dates grow, your motivation and desire will increase.

Long-term goals may be related to our dreams of the future. They might cover five years or more. Life is not a static thing.
We should never allow a long-term goal to limit us or our course of action.

目标有三种：短期目标，中期目标和长期目标。

短期目标是根据每日制定的为了处理当前事物的目标。短期目标可以以少于一个星期，一个星期，两个星期，或者可能的话一个月来完成。
我们必须记住，打地基比砌墙更需要坚实，长期目标脱离了扎实的短期目标的实现是不能实现的。

短期目标的实现是以以前完成的目标为前提的。

中期目标是在短期目标的基础上指定的。可以以一个学期或整个学年为周期指定，或者延长至几年。每次你根据目标前进了一步，都不要让自己感到没有信心或者压力重重。当你完成了一个目标，你都会增加成功的信心。并且当你完成目标的日期越来越近，你的动力和希望都会增加。

长期目标可以和我们未来的梦想相关联。可以是五年或五年以上的目标。生活不是一成不变的。我们不能让长期目标制约了我们或我们的行为。

一种是 var a = new Number(0),这种是返回一个Number的对象

第二种 var a= Number(0),这种是返回一个单纯的数字0

下面是在firefox下控制台输出的两种不同的实例化方法。

>>> console.log(new Number(0));
0 {}

>>> console.log(Number(0));
0

这个知识点可以参考： http://www.w3school.com.cn/js/jsref_obj_number.asp (JavaScript Number 对象参考手册)

但是需要注意的是：如果 new Number(“xxxx”)，传入一个字符串，将返回NaN，NaN的意义是“Not a Number”，代表不是一个数字，

判断的方法不能单纯的用 “xxxx”==NaN 来判断，因为NaN本身和NaN也不相等，

>>> NaN==NaN
false

如何判断一个变量是否是NaN，需要用到isNaN(var)这个方法，例如：

>>> isNaN(Number(“xxx”))
true

>>> isNaN(Number(“134″))
false

>>> isNaN(Number(134))
false

>>> isNaN(NaN)
true

一个小数，例如1.7777777，或者1.3333333，不管后面的位数是多少，只保留到小数点后第二位，但是不是四舍五入，1.7777777处理后就是1.77，1.3333333处理后就是1.33

这个就要用到BigDecimal#setScale的方法了。

具体看如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import java.math.BigDecimal;
import java.math.RoundingMode;
 
public class ScaleTest {
 
	public static void main(String[] args) {
 
		double a = 1.66728D;
		double b = 1.33333D;
		double c = 1.00000D;
 
		BigDecimal aa = new BigDecimal(a);
		BigDecimal bb = new BigDecimal(b);
		BigDecimal cc = new BigDecimal(c);
		System.out.println(aa.setScale(2, BigDecimal.ROUND_UP));
		System.out.println(aa.setScale(2, BigDecimal.ROUND_DOWN));
		System.out.println(bb.setScale(2, BigDecimal.ROUND_UP));
		System.out.println(bb.setScale(2, BigDecimal.ROUND_DOWN));
		System.out.println(cc.setScale(2, BigDecimal.ROUND_UP));
		System.out.println(cc.setScale(2, BigDecimal.ROUND_DOWN));
		System.out.println("-------------------------------------");
		System.out.println(aa.setScale(2, RoundingMode.UP));
		System.out.println(aa.setScale(2, RoundingMode.DOWN));
		System.out.println(bb.setScale(2, RoundingMode.UP));
		System.out.println(bb.setScale(2, RoundingMode.DOWN));
		System.out.println(cc.setScale(2, RoundingMode.UP));
		System.out.println(cc.setScale(2, RoundingMode.DOWN));
	}
}

输出结果如下：
1.67
1.66
1.34
1.33
1.00
1.00
————————————-
1.67
1.66
1.34
1.33
1.00
1.00

上面仅仅是根据我的需要举了BigDecimal.ROUND_UP和BigDecimal.ROUND_DOWN的例子，下面就用个表格来分析下。

ROUND_UP ROUND_DOWN
1.66728D 1.67 1.66
1.33333D 1.34 1.33
1.00000D 1.00 1.00

也就是说，ROUND_DOWN，是一个舍位取值的概念，我保留了两位小数，我不管你后面的小数值如何，也不会四舍五入，就硬生生的给阶段，相当于什么呢，就是我从小数点后面开始取两位，两位后面的都不要了，相当于一个截取字符串的操作。

而ROUND_UP那，很宽容，很大方，我不管你第三位的小数是多少，我都给你加一最小单位（比如保留两位小数，最小单位是0.01，保留三位小数，最小单位就是0.001），当然了，你保留到最后一位的数字如果是0的话，那么就不加了。

而这两个作用在咱们实际当中什么情况下不能使用四舍五入，需要用这两个呢？

用个应用题举例子吧，

一个篮子可以装10个苹果，现在有82个苹果，需要几个篮子来装？
9个，对，这是咱们的什么结果，不正是ROUND_UP的么（只不过这道题是取小数点后0位，也就是取整的区别而已），也就很好解释为什么最小单位是0不需要再加一个最小单位了，如果我只有80个苹果，8个篮子正好装下，就不需要第九个了。

那么什么时候儿需要使用ROUND_DOWN呢，再来看下面一个例子，
每个加油站相距8公里，一公里需要耗一个油，我现在车里还有90个油，请问，我最晚在第几个加油站必须得加油了？
11个，第十一个，就是在车使用88个油到达第11个加油站后需要加油，因为我还剩2个由已经撑不到第12个加油站了。这种情况，ROUND_DOWN就派上用场了。

其实，BigDecimal不光有ROUND_UP，ROUND_DOWN，还有其他的很多值，比如：ROUND_CEILING、ROUND_HALF_DOWN等等，具体的效果可以自己实验下。

这里给出篇文章地址供参考：
http://stephen830.javaeye.com/blog/260776 JAVA对double或者float的浮点数精度计算控制方法

原文如下：
JAVA对double或者float的浮点数精度计算控制方法
文章分类:Java编程关键字: java double或者float的浮点数精度
★★★ 本篇为原创，需要引用转载的朋友请注明：《 http://stephen830.javaeye.com/blog/260776 》 谢谢支持！★★★本篇介绍了在JAVA中如何对double或者float的浮点数进行精度计算，在JAVA中提供了多种参数来实现精度的不同控制方式。具体例子如下：
Java代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

import java.math.BigDecimal;   
 
/**  
 * 与小数位精度(四舍五入等)相关的一些常用工具方法.  
 *   
 * float/double的精度取值方式分为以下几种: <br>  
 * java.math.BigDecimal.ROUND_UP <br>  
 * java.math.BigDecimal.ROUND_DOWN <br>  
 * java.math.BigDecimal.ROUND_CEILING <br>  
 * java.math.BigDecimal.ROUND_FLOOR <br>  
 * java.math.BigDecimal.ROUND_HALF_UP<br>  
 * java.math.BigDecimal.ROUND_HALF_DOWN <br>  
 * java.math.BigDecimal.ROUND_HALF_EVEN <br>  
 *   
 * @author stephen  
 * @version 1.0.0  
 */  
public final class RoundTool {   
 
    /**  
     * 对double数据进行取精度.  
     * <p>  
     * For example: <br>  
     * double value = 100.345678; <br>  
     * double ret = round(value,4,BigDecimal.ROUND_HALF_UP); <br>  
     * ret为100.3457 <br>  
     *   
     * @param value  
     *            double数据.  
     * @param scale  
     *            精度位数(保留的小数位数).  
     * @param roundingMode  
     *            精度取值方式.  
     * @return 精度计算后的数据.  
     */  
    public static double round(double value, int scale, int roundingMode) {   
        BigDecimal bd = new BigDecimal(value);   
        bd = bd.setScale(scale, roundingMode);   
        double d = bd.doubleValue();   
        bd = null;   
        return d;   
    }   
 
    /**  
     * 测试用的main方法.  
     *   
     * @param argc  
     *            运行参数.  
     */  
    public static void main(String[] argc) {   
        //下面都以保留2位小数为例   
 
        //ROUND_UP   
        //只要第2位后面存在大于0的小数，则第2位就+1   
        System.out.println(round(12.3401,2,BigDecimal.ROUND_UP));//12.35   
        System.out.println(round(-12.3401,2,BigDecimal.ROUND_UP));//-12.35   
        //ROUND_DOWN   
        //与ROUND_UP相反   
        //直接舍弃第2位后面的所有小数   
        System.out.println(round(12.349,2,BigDecimal.ROUND_DOWN));//12.34   
        System.out.println(round(-12.349,2,BigDecimal.ROUND_DOWN));//-12.34   
        //ROUND_CEILING   
        //如果数字>0 则和ROUND_UP作用一样   
        //如果数字<0 则和ROUND_DOWN作用一样   
        System.out.println(round(12.3401,2,BigDecimal.ROUND_CEILING));//12.35   
        System.out.println(round(-12.349,2,BigDecimal.ROUND_CEILING));//-12.34   
        //ROUND_FLOOR   
        //如果数字>0 则和ROUND_DOWN作用一样   
        //如果数字<0 则和ROUND_UP作用一样   
        System.out.println(round(12.349,2,BigDecimal.ROUND_FLOOR));//12.34   
        System.out.println(round(-12.3401,2,BigDecimal.ROUND_FLOOR));//-12.35   
        //ROUND_HALF_UP [这种方法最常用]   
        //如果第3位数字>=5,则第2位数字+1   
        //备注:只看第3位数字的值,不会考虑第3位之后的小数的   
        System.out.println(round(12.345,2,BigDecimal.ROUND_HALF_UP));//12.35   
        System.out.println(round(12.3449,2,BigDecimal.ROUND_HALF_UP));//12.34   
        System.out.println(round(-12.345,2,BigDecimal.ROUND_HALF_UP));//-12.35   
        System.out.println(round(-12.3449,2,BigDecimal.ROUND_HALF_UP));//-12.34   
        //ROUND_HALF_DOWN   
        //如果第3位数字>=5,则做ROUND_UP   
        //如果第3位数字<5,则做ROUND_DOWN   
        System.out.println(round(12.345,2,BigDecimal.ROUND_HALF_DOWN));//12.35   
        System.out.println(round(12.3449,2,BigDecimal.ROUND_HALF_DOWN));//12.34   
        System.out.println(round(-12.345,2,BigDecimal.ROUND_HALF_DOWN));//-12.35   
        System.out.println(round(-12.3449,2,BigDecimal.ROUND_HALF_DOWN));//-12.34   
        //ROUND_HALF_EVEN   
        //如果第3位是偶数,则做ROUND_HALF_DOWN   
        //如果第3位是奇数,则做ROUND_HALF_UP   
        System.out.println(round(12.346,2,BigDecimal.ROUND_HALF_EVEN));//12.35   
        System.out.println(round(12.345,2,BigDecimal.ROUND_HALF_EVEN));//12.35   
    }   
}

这篇文章算说的比较详细的了，供参考。

document.getElementById(‘xxx’).innerHTML 适用于 IE和Firefox浏览器

document.getElementById(‘xxx’).innerText 只适用于IE浏览器

其次：
对于同一个对象，二者返回的内容不一样：
innerHTML 返回的是这个对象内部所有的代码，包括html与非html代码
而innerText只返回这个内部的非html代码。

看个例子：

源代码如下：

页面效果如下：

点击innerHTML的效果：

点击innerText的效果：

============首先先白活一下儿有可能是众所周知的概念，各位可以忽略此段直接到下一个无敌的分割线============
之前在使用linux系统时，经常会用到创建链接的操作，所谓链接，就是创建一个符号，将这个符号指向一个文件或者目录，
个人理解，也可以说是这个符号是指向文件或者目录的一个指针。

软链接也叫符号链接，关于这两种链接的区别，将在最后说明。

我在linux经常使用软链接，主要用途下面举个例子：

比如在编译apache之后，会产生如下目录，/usr/local/apache2.0/
这时的启动apache的命令就是：
/usr/local/apache2.0/bin/apachectl start

接下来，我要将apache2.0升级到apache2.2，
那么我的启动apache2.2的命令就是：
/usr/local/apache2.2/bin/apachectl start

现在，我要将系统中所有用到/usr/local/apache2.0/bin/apachectl start的地方（例如启动脚本，crontab等）
都换成/usr/local/apache2.2/bin/apachectl start

很累，万一想从2.2版本，切换回2.0版本，还要再都改一遍。

我的方法是创建一个软链接，在最开始编译好apache2.0时，创建软链接命令如下：

ln -s /usr/local/apache2.0/ /usr/local/apache2

这样，apache2就是apache2.0的一个软链接了，
现在，我的/usr/local/目录下除了apache2.0还有了apache2.2，
那么我只要取消原来的apache2软链接：
unlink /usr/local/apache2 【这里需要特别注意的是，apache2最后不要加”/”】
再重新创建软链接：
ln -s /usr/local/apache2.2/ /usr/local/apache2

这样，我其他地方启动apache的脚本统一写成：
/usr/local/apache2/bin/apachectl start

通过切换软链接的方式，来启动不同版本的apache，方便又省事儿，而且，如果从2.0切换至2.2之后，发现有问题，还可以通过这种方式快速的切换回2.0版本。

好了，贫了这么半天，来说说windows下如何创建链接吧，
今天发现电脑的E盘只剩下200多M了，一看自己的eclipse的workspace占用了6个多G，于是乎，有了转移workspace目录的想法，C盘还有10多个G，就放在C盘吧。

============windows自带的命令行下如何创建硬链接============

先来一句话说明windows创建硬链接的方法：
命令行中执行：
fsutil hardlink create <新文件名> <现有文件名>
例如：
fsutil hardlink create e:\target.txt e:\source.txt

则在E盘根目录创建了名为”target.txt”的，指向E盘根目录的source.txt的硬链接，需要说明的是：
硬链接文件有两个限制(Unix/Linux 和 Windows 也都如此)
(1) 不允许给目录创建硬链接；
(2) 只有在同一文件系统中的文件之间才能创建链接。

在windows下，创建硬链接还必须是在同一个卷(分区)下。

很显然，这个并不能符合我转移workspace的需求，于是乎～～～～～～
为了转移workspace后，不影响现在eclipse的使用，决定采用软链接的方式。
============windows如何创建软链接============

上网上搜索了资料，得知可以使用如下三种方法来实现，Junction，GNU utilities for Win32，Total Commander
（这三个软件在下面的”本文软件网址”中，都附有链接，可以到其网站上去下载）

下面分别说说这三种的不同用法以及主要区别，

情景：workspace转移后在c:\workspace，要求访问e:\workspace等于访问c:\workspace，

首先，Junction，
命令如下：
junction -s e:\workspace c:\workspace
加-s的意思是对子目录执行递归操作，
命令行会显示：
Created: e:\workspace
Targetted at: c:\workspace
好了，现在华丽的访问e:\workspace吧，已经跟c:\workspace一模一样了，
而且，我向e:\workspace加入了200M的文件，并没有占用E盘的空间，而是占用C盘的空间。

好，现在来删除e:\workspace软链接，使用如下命令：
junction -d e:\workspace
命令行会显示：Deleted e:\workspace.
这时的e:\workspace已经没有了，c:\workspace还完好无缺。

满足要求！

【网上有人提到过：
需要注意的是，Explorer 对待 symbolic link 有一个很奇怪的行为。
那就是，在 Explorer 里一个 symbolic link 跟被它 link 的目录没有区别，
删除这个 symbolic link 将会删除被 link 的目录下的所有文件！
】

但是我在vista系统下测试，删除了e:\workspace，c:\workspace仍然好好的存在。

————————————————–

再来看看GNU utilities for Win32
先下载，下载后，是个zip压缩包，解压缩后，会看到如下的一个目录结构：
UnxUtils\usr\local\wbin
这里面的N多命令，其中的ln.exe就是咱们要使用的来，
【PS：UnxUtils\bin这个目录下有个sh.exe，我一运行就报错，不用去管它，感觉这个就是个加载器，运行后会加载到它的shell环境中，
我把UnxUtils\usr\local\wbin设置在了系统的环境变量中，也可以和方便的在cmd中直接使用每个命令。】

像在linux下一样，在cmd中执行
ln -s c:\workspace e:\workspace
命令行提示：
ln: symbolic links are not supported on this system

阿门，不支持，放弃～～～正如网上所说，这个工具包的ln只能创建硬链接。
虽然ln不支持，但是这个软件包的其他命令还是很不错滴，例如grep，可以很方便的搜索windows文件了，要比windows的垃圾搜索好很多。

————————————————–

来看看Total Commander吧，
下载下来是个安装包，最新的版本已经内置了中文，安装时可以选择中文，并且可以不安装其他的语言，以节省空间。

下载，安装，并没有发现可以做软链接的功能，忽略。
但是这个作为资源管理器的替代者倒是很强大，又发现了个很好滴工具。

————————————————–

总结：在windows下创建软链接，使用junction。

============本文软件网址============

http://technet.microsoft.com/zh-cn/sysinternals/bb896768.aspx

Windows Sysinternals > 下载 > File and Disk Utilities > Junction v1.04

http://unxutils.sourceforge.net/

GNU utilities for Win32

http://www.ghisler.com/

Total Commander

============本文windows命令部分参考============

http://www.buaaer.com/bbs/viewthread.php?tid=3183

硬链结和符号链接的区别

http://answers.google.com/answers/threadview?id=341355

Q: how to create a symbolic link under Win2K, WinXP, and above?

http://rainux.org/ntfs-hard-linksymbolic-link

NTFS 下的硬链接(hard link)与符号链接(symbolic link)

============附：硬链结和符号链接的区别============

硬连接记录的是目标的 inode,符号连接记录的是目标的 path。
软连接就像是快捷方式,而硬连接就像是备份!符号连接可以做跨分区的 link；而 硬连接由于 inode 的缘故，只能在本分区中做 link.所以,符号连接的使用频率要高的多。

存在两种不同类型的链接，软链接和硬链接。修改其中一个，硬连接指向的是节点(inode),而软连接指向的是路径(path)

软链接文件

　　软链接又叫符号链接，这个文件包含了另一个文件的路径名。可以是任意文件或目录，可以链接不同文件系统的文件。和win下的快捷方式差不多。链接文件甚至可以链接不存在的文件，这就产生一般称之为”断链”的问题(或曰“现象”)，链接文件甚至可以循环链接自己。类似于编程语言中的递归。

命令格式：
代码:
ln [-s] source_path target_path

硬链接文件

　　info ln 命令告诉您，硬链接是已存在文件的另一个名字，硬连接的命令是

代码:
ln -d existfile newfile

引用:
硬链接文件有两个限制

　　1、不允许给目录创建硬链接；
　　2、只有在同一文件系统中的文件之间才能创建链接。

　　对硬链接文件进行读写和删除操作时候，结果和软链接相同。但如果我们删除硬链接文件的源文件，硬链接文件仍然存在，而且保留了愿有的内容。这时，系统就“忘记”了它曾经是硬链接文件。而把他当成一个普通文件。修改其中一个，与其连接的文件同时被修改

代码:
$umask 022
$ cp /etc/httpd/conf/httpd.conf /usr/sam

原来前面做的试验，改变了系统默认的umask值，现在改回来为022,
举个httpd.conf文件做例 子

代码:
$ ln httpd.conf httpd1.conf
$ ln -s httpd.conf httpd2.conf

第一条为硬链接，第二条为软链接

代码:
$ ls -li

代码:
总用量 80
1077669 -rw-r–r– 2 sam adm 34890 10月 31 00:57 httpd1.conf
1077668 lrwxrwxrwx 1 sam adm 10 10月 31 00:58 httpd2.conf ->; httpd.conf
1077669 -rw-r–r– 2 sam adm 34890 10月 31 00:57 httpd.conf

可以看到，使用ls -li，软连接只产生了10字节的快捷而已，硬连接却实实在在的的拷贝。最前面的inode硬链接和源文件是一样的，而软链接不一样，具体看一下回复

对http1.conf进行编辑，可以发现httpd.conf也发生了一样的变化

代码:
$ rm httpd.conf

现在删除链接的源文件，来比较不同之处

代码:
$ ls -l
总用量 44
drw-r–r– 2 sam adm 4096 10月 30 20:14 file6
-rw-r–r– 1 sam adm 34890 10月 31 00:57 httpd1.conf
lrwxrwxrwx 1 sam adm 10 10月 31 00:58 httpd2.conf ->; httpd.conf

我的结论就是:硬链结只有全部被删除的时候，文件才无法访问，但是软链接，只要他的源文件消失了，这个文件就无法访问了。软链接就是记录了文件路径的一种特殊文件。