HashMap原理、源码、实践

HashMap是一种十分常用的数据结构，作为一个应用开发人员，对其原理、实现的加深理解有助于更高效地进行数据存取。本文所用的jdk版本为1.5。 

使用HashMap 

《Effective JAVA》中认为，99%的情况下，当你覆盖了equals方法后，请务必覆盖hashCode方法。默认情况下，这两者会采用Object的“原生”实现方式，即： 

Java代码  收藏代码
  1. protected native int hashCode();  
  2. public boolean equals(Object obj) {  
  3.     return (this == obj);  
  4. }  


hashCode方法的定义用到了native关键字，表示它是由C或C++采用较为底层的方式来实现的，你可以认为它返回了该对象的内存地址；而缺省equals则认为，只有当两者引用同一个对象时，才认为它们是相等的。如果你只是覆盖了equals()而没有重新定义hashCode()，在读取HashMap的时候，除非你使用一个与你保存时引用完全相同的对象作为key值，否则你将得不到该key所对应的值。 

另一方面，你应该尽量避免使用“可变”的类作为HashMap的键。如果你将一个对象作为键值并保存在HashMap中，之后又改变了其状态，那么HashMap就会产生混乱，你所保存的值可能丢失（尽管遍历集合可能可以找到）。可参考http://www.ibm.com/developerworks/cn/java/j-jtp02183/ 

HashMap存取机制 

Hashmap实际上是一个数组和链表的结合体，利用数组来模拟一个个桶（类似于Bucket Sort）以快速存取不同hashCode的key，对于相同hashCode的不同key，再调用其equals方法从List中提取出和key所相对应的value。 

JAVA中hashMap的初始化主要是为initialCapacity和loadFactor这两个属性赋值。前者表示hashMap中用来区分不同hash值的key空间长度，后者是指定了当hashMap中的元素超过多少的时候，开始自动扩容，。默认情况下initialCapacity为16，loadFactor为0.75，它表示一开始hashMap可以存放16个不同的hashCode，当填充到第12个的时候，hashMap会自动将其key空间的长度扩容到32，以此类推；这点可以从源码中看出来： 

Java代码  收藏代码
  1. void addEntry(int hash, K key, V value, int bucketIndex) {  
  2.     Entry e = table[bucketIndex];  
  3.         table[bucketIndex] = new Entry(hash, key, value, e);  
  4.         if (size++ >= threshold)  
  5.             resize(2 * table.length);  
  6. }  


而每当hashMap扩容后，内部的每个元素存放的位置都会发生变化（因为元素的最终位置是其hashCode对key空间长度取模而得），因此resize方法中又会调用transfer函数，用来重新分配内部的元素；这个过程成为rehash，是十分消耗性能的，因此在可预知元素的个数的情况下，一般应该避免使用缺省的initialCapacity，而是通过构造函数为其指定一个值。例如我们可能会想要将数据库查询所得1000条记录以某个特定字段（比如ID）为key缓存在hashMap中，为了提高效率、避免rehash，可以直接指定initialCapacity为2048。 

另一个值得注意的地方是，hashMap其key空间的长度一定为2的N次方，这一点可以从一下源码中看出来： 

Java代码  收藏代码
  1. int capacity = 1;  
  2. while (capacity < initialCapacity)   
  3.     capacity <<= 1;  


即使我们在构造函数中指定的initialCapacity不是2的平方数，capacity还是会被赋值为2的N次方。 

为什么Sun Microsystem的工程师要将hashMap key空间的长度设为2的N次方呢？这里参考R.W.Floyed给出的衡量散列思想的三个标准： 


    一个好的hash算法的计算应该是非常快的
    一个好的hash算法应该是冲突极小化
    如果存在冲突,应该是冲突均匀化 


为了将各元素的hashCode保存至长度为Length的key数组中，一般采用取模的方式，即index = hashCode % Length。不可避免的，存在多个不同对象的hashCode被安排在同一位置，这就是我们平时所谓的“冲突”。如果仅仅是考虑元素均匀化与冲突极小化，似乎应该将Length取为素数（尽管没有明显的理论来支持这一点，但数学家们通过大量的实践得出结论，对素数取模的产生结果的无关性要大于其它数字）。为此，Craig Larman and Rhett Guthrie《Java Performence》中对此也大加抨击。为了弄清楚这个问题，Bruce Eckel（Thinking in JAVA的作者）专程采访了java.util.hashMap的作者Joshua Bloch，并将他采用这种设计的原因放到了网上（http://www.roseindia.net/javatutorials/javahashmap.shtml） 。 

上述设计的原因在于，取模运算在包括JAVA在内的大多数语言中的效率都十分低下，而当除数为2的N次方时，取模运算将退化为最简单的位运算，其效率明显提升（按照Bruce Eckel给出的数据，大约可以提升5～8倍） 。看看JDK中是如何实现的： 

Java代码  收藏代码
  1. static int indexFor(int h, int length) {  
  2.     return h & (length-1);  
  3. }  


当key空间长度为2的N次方时，计算hashCode为h的元素的索引可以用简单的与操作来代替笨拙的取模操作！假设某个对象的hashCode为35（二进制为100011），而hashMap采用默认的initialCapacity（16），那么indexFor计算所得结果将会是100011 & 1111 = 11，即十进制的3，是不是恰好是35 Mod 16。 

上面的方法有一个问题，就是它的计算结果仅有对象hashCode的低位决定，而高位被统统屏蔽了；以上面为例，19（10011）、35（100011）、67（1000011）等就具有相同的结果。针对这个问题， Joshua Bloch采用了“防御性编程”的解决方法，在使用各对象的hashCode之前对其进行二次Hash，参看JDK中的源码： 

Java代码  收藏代码
  1. static int hash(Object x) {  
  2.         int h = x.hashCode();  
  3.         h += ~(h << 9);  
  4.         h ^=  (h >>> 14);  
  5.         h +=  (h << 4);  
  6.         h ^=  (h >>> 10);  
  7.         return h;  
  8.     }  


采用这种旋转Hash函数的主要目的是让原有hashCode的高位信息也能被充分利用，且兼顾计算效率以及数据统计的特性，其具体的原理已超出了本文的领域。 

加快Hash效率的另一个有效途径是编写良好的自定义对象的HashCode，String的实现采用了如下的计算方法： 

Java代码  收藏代码
  1. for (int i = 0; i < len; i++) {  
  2. h = 31*h + val[off++];  
  3. }  
  4. hash = h;  


这种方法HashCode的计算方法可能最早出现在Brian W. Kernighan和Dennis M. Ritchie的《The C Programming Language》中，被认为是性价比最高的算法（又被称为times33算法，因为C中乘数常量为33，JAVA中改为31），实际上，包括List在内的大多数的对象都是用这种方法计算Hash值。 

另一种比较特殊的hash算法称为布隆过滤器，它以牺牲细微精度为代价，换来存储空间的大量节俭，常用于诸如判断用户名重复、是否在黑名单上等等，可以参考李开复的数学之美系列第13篇（http://googlechinablog.com/2006/08/blog-post.html） 

Fail-Fast机制 

众所周知，HashMap不是线程安全的集合类。但在某些容错能力较好的应用中，如果你不想仅仅因为1%的可能性而去承受hashTable的同步开销，则可以考虑利用一下HashMap的Fail-Fast机制，其具体实现如下： 

Java代码  收藏代码
  1. Entry nextEntry() {   
  2. if (modCount != expectedModCount)  
  3.     throw new ConcurrentModificationException();  
  4.                      ……  
  5. }  


其中modCount为HashMap的一个实例变量，并且被声明为volatile，表示任何线程都可以看到该变量被其它线程修改的结果（根据JVM内存模型的优化，每一个线程都会存一份自己的工作内存，此工作内存的内容与本地内存并非时时刻刻都同步，因此可能会出现线程间的修改不可见的问题） 。使用Iterator开始迭代时，会将modCount的赋值给expectedModCount，在迭代过程中，通过每次比较两者是否相等来判断HashMap是否在内部或被其它线程修改。HashMap的大多数修改方法都会改变ModCount，参考下面的源码： 
Java代码  收藏代码
  1. public V put(K key, V value) {  
  2.     K k = maskNull(key);  
  3.         int hash = hash(k);  
  4.         int i = indexFor(hash, table.length);  
  5.         for (Entry e = table[i]; e != null; e = e.next) {  
  6.             if (e.hash == hash && eq(k, e.key)) {  
  7.                 V oldValue = e.value;  
  8.                 e.value = value;  
  9.                 e.recordAccess(this);  
  10.                 return oldValue;  
  11.             }  
  12.         }  
  13.         modCount++;  
  14.         addEntry(hash, k, value, i);  
  15.         return null;  
  16.     }  


以put方法为例，每次往HashMap中添加元素都会导致modCount自增。其它诸如remove、clear方法也都包含类似的操作。 
从上面可以看出，HashMap所采用的Fail-Fast机制本质上是一种乐观锁机制，通过检查状态——没有问题则忽略——有问题则抛出异常的方式，来避免线程同步的开销，下面给出一个在单线程环境下发生Fast-Fail的例子： 

Java代码  收藏代码
  1. class Test {    
  2.     public static void main(String[] args) {               
  3.         java.util.HashMap map=new java.util.HashMap();    
  4.        map.put(new Object(), "a");    
  5.        map.put(new Object(), "b");    
  6.        java.util.Iterator it=map.keySet().iterator();    
  7.        while(it.hasNext()){    
  8.            it.next();    
  9.            map.put("", "");         
  10.         System.out.println(map.size());    
  11.     }    
  12. }  


运行上面的代码会抛出java.util.ConcurrentModificationException，因为在迭代过程中修改了HashMap内部的元素导致modCount自增。若将上面代码中 map.put(new Object(), "b") 这句注释掉，程序会顺利通过，因为此时HashMap中只包含一个元素，经过一次迭代后已到了尾部，所以不会出现问题，也就没有抛出异常的必要了。 
在通常并发环境下，还是建议采用同步机制。这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作，以防止意外的非同步访问。 

LinkedHashMap 

遍历HashMap所得到的数据是杂乱无章的，这在某些情况下客户需要特定遍历顺序时是十分有用的。比如，这种数据结构很适合构建 LRU 缓存。调用 put 或 get 方法将会访问相应的条目（假定调用完成后它还存在）。putAll 方法以指定映射的条目集合迭代器提供的键-值映射关系的顺序，为指定映射的每个映射关系生成一个条目访问。Sun提供的J2SE说明文档特别规定任何其他方法均不生成条目访问，尤其，collection 集合类的操作不会影响底层映射的迭代顺序。 

LinkedHashMap的实现与 HashMap 的不同之处在于，前者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序通常就是集合中元素的插入顺序。该类定义了header、before与after三个属性来表示该集合类的头与前后“指针”，其具体用法类似于数据结构中的双链表，以删除某个元素为例： 

Java代码  收藏代码
  1. private void remove() {  
  2.        before.after = after;  
  3.        after.before = before;  
  4. }  


实际上就是改变前后指针所指向的元素。 

显然，由于增加了维护链接列表的开支，其性能要比 HashMap 稍逊一筹，不过有一点例外：LinkedHashMap的迭代所需时间与其的所包含的元素成比例；而HashMap 迭代时间很可能开支较大，因为它所需要的时间与其容量（分配给Key空间的长度）成比例。一言以蔽之，随机存取用HashMap，顺序存取或是遍历用LinkedHashMap。 

LinkedHashMap还重写了removeEldestEntry方法以实现自动清除过期数据的功能，这在HashMap中是无法实现的，因为后者其内部的元素是无序的。默认情况下，LinkedHashMap中的removeEldestEntry的作用被关闭，其具体实现如下： 

Java代码  收藏代码
  1. protected boolean removeEldestEntry(Map.Entry eldest) {  
  2.     return false;  
  3. }  


可以使用如下的代码覆盖removeEldestEntry： 

Java代码  收藏代码
  1. private static final int MAX_ENTRIES = 100;  
  2.   
  3. protected boolean removeEldestEntry(Map.Entry eldest) {  
  4.     return size() > MAX_ENTRIES;  
  5. }  


它表示，刚开始，LinkedHashMap中的元素不断增长；当它内部的元素超过MAX_ENTRIES（100）后，每当有新的元素被插入时，都会自动删除双链表中最前端（最旧）的元素，从而保持LinkedHashMap的长度稳定。 

缺省情况下，LinkedHashMap采取的更新策略是类似于队列的FIFO，如果你想实现更复杂的更新逻辑比如LRU（最近最少使用） 等，可以在构造函数中指定其accessOrder为true，因为的访问元素的方法（get）内部会调用一个“钩子”，即recordAccess，其具体实现如下： 

Java代码  收藏代码
  1. void recordAccess(HashMap m) {  
  2.     LinkedHashMap lm = (LinkedHashMap)m;  
  3.     if (lm.accessOrder) {  
  4.         lm.modCount++;  
  5.         remove();  
  6.         addBefore(lm.header);  
  7.     }  
  8. }  


上述代码主要实现了这样的功能：如果accessOrder被设置为true，则每次访问元素时，都将该元素移至headr的前面，即链表的尾部。将removeEldestEntry与accessOrder一起使用，就可以实现最基本的内存缓存，具体代码可参考http://bluepopopo.iteye.com/blog/180236。 

WeakHashMap 

99%的JAVA教材教导我们不要去干预JVM的垃圾回收机制，但JAVA中确实存在着与其密切相关的四种引用：强引用、软引用、弱引用以及幻象引用。 

JAVA中默认的HashMap采用的是采用类似于强引用的强键来管理的，这意味着即使作为key的对象已经不存在了（指没有任何一个引用指向它），也仍然会保留在HashMap中，在某些情况下（例如内存缓存）中，这些过期的条目可能会造成内存泄漏等问题。 

WeakHashMap采用的策略是，只要作为key的对象已经不存在了（超出生命周期），就不会阻止垃圾收集器清空此条目，即使当前机器的内存并不紧张。不过，由于GC是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象，除非你显示地调用它，可以参考下面的例子： 

Java代码  收藏代码
  1. public static void main(String[] args) {  
  2.     Mapmap = new WeakHashMap();  
  3.     map.put(new String("Alibaba"), "alibaba");  
  4.     while (map.containsKey("Alibaba")) {  
  5.         try {  
  6.             Thread.sleep(500);  
  7.          } catch (InterruptedException ignored) {  
  8.          }  
  9.          System.out.println("Checking for empty");  
  10.          System.gc();  
  11.     }  


上述代码输出一次Checking for empty就退出了主线程，意味着GC在最近的一次垃圾回收周期中清除了new String(“Alibaba”),同时WeakHashMap也做出了及时的反应，将该键对应的条目删除了。如果将map的类型改为HashMap的话，由于其内部采用的是强引用机制，因此即使GC被显示调用，map中的条目依然存在，程序会不断地打出Checking for empty字样。另外，在使用WeakHashMap的情况下，若是将 

Java代码  收藏代码
  1. map.put(new String("Alibaba"), "alibaba");   


改为 

Java代码  收藏代码
  1. map.put("Alibaba", "alibaba");   


程序还是会不断输出Checking for empty。这与前面我们分析的WeakHashMap的弱引用机制并不矛盾，因为JVM为了减小重复创建和维护多个相同String的开销，其内部采用了蝇量模式（《JAVA与模式》），此时的“Alibaba”是存放在常量池而非堆中的，因此即使没有对象指向“Alibaba”，它也不会被GC回收。弱引用特别适合以下对象：占用大量内存，但通过垃圾回收功能回收以后很容易重新创建。 

介于HashMap和WeakHashMap之中的是SoftHashMap，它所采用的软引用的策略指的是，垃圾收集器并不像其收集弱可及的对象一样尽量地收集软可及的对象，相反，它只在真正 “需要” 内存时才收集软可及的对象。软引用对于垃圾收集器来说是一种“睁一只眼，闭一只眼”方式，即 “只要内存不太紧张，我就会保留该对象。但是如果内存变得真正紧张了，我就会去收集并处理这个对象。” 就这一点看，它其实要比WeakHashMap更适合于实现缓存机制。遗憾的是，JAVA中并没有实现相关的SoftHashMap类（Apache和Google提供了第三方的实现），但它却是提供了两个十分重要的类java.lang.ref.SoftReference以及ReferenceQueue，可以在对象应用状态发生改变是得到通知，可以参考com.alibaba.common.collection.SofthashMap中processQueue方法的实现: 

Java代码  收藏代码
  1. private ReferenceQueue queue = new ReferenceQueue();  
  2. ValueCell vc;  
  3. Map hash = new HashMap(initialCapacity, loadFactor);  
  4. ……  
  5. while ((vc = (ValueCell) queue.poll()) != null) {  
  6. if (vc.isValid()) {  
  7.           hash.remove(vc.key);  
  8.            } else {  
  9.              valueCell.dropped--;  
  10.            }  
  11. }  
  12. }  


processQueue方法会在几乎所有SoftHashMap的方法中被调用到，JVM会通过ReferenceQueue的poll方法通知该对象已经过期并且当前的内存现状需要将它释放，此时我们就可以将其从hashMap中剔除。事实上，默认情况下，Alibaba的MemoryCache所使用的就是SoftHashMap。 
Read More

terminal & console

终端（Terminal）
终端是用户和计算机进行实时交互的接口设备。终端一般由显示器、键盘和终端控制器组成，有的还带有鼠标。显示器和键盘与终端控制器相连，终端控制器通过通用端口（如串口）和计算机主机相连。用户通过终端和计算机交流。一台UNIX主机可以连多个终端。终端分为两类：字符终端和图形终端。

仿真终端 在某计算机上运行某一特定程序，把计算机当作另一台计算机的终端使用。目前仿真终端与UNIX主机的连接方式主要有网络连接和串口连接。


控制台（Console）
这是一种特殊的终端，由显示器、键盘（和鼠标）组成，分别连到主机的专用接口（监视器接口、键盘接口、鼠标接口）上。一般一台主机只能接一个控制台，控制台可以完成普通终端不能完成的工作：非常重要的信息（如严重的错误信息），只能在控制台上显示，有些特殊的任务（如执行修复工作）也只能在控制台上完成。除了实现以上特殊功能外，控制台还可以象其它终端那样工作。 -->
Read More

shallow and retained sizes


Shallow size of an object is the amount of memory allocated to store the object itself, not taking into account the referenced objects. Shallow size of a regular (non-array) object depends on the number and types of its fields. Shallow size of an array depends on the array length and the type of its elements (objects, primitive types). Shallow size of a set of objects represents the sum of shallow sizes of all objects in the set.
Retained size of an object is its shallow size plus the shallow sizes of the objects that are accessible, directly or indirectly, only from this object. In other words, the retained size represents the amount of memory that will be freed by the garbage collector when this object is collected.
To better understand the notion of the retained size, let us look at the following examples:
In order to measure the retained sizes, all objects in memory are treated as nodes of a graph where its edges represent references from objects to objects. There are also special nodes - GC root objects, which will not be collected by Garbage Collector at the time of measuring (read more about GC roots).
The pictures below show the same set of objects, but with varying internal references.
Figure 1:
Figure 2:
Let us consider obj1.
As you can see, in both pictures we have highlighted all of the objects that are directly or indirectly accessed only by obj1. If you look at Figure 1, you will see thatobj3 is not highlighted, because it is also referenced by a GC root object. On Figure 2, however, it is already included into the retained set, unlike obj5, which is still referenced by GC root.
Thus, the retained size of obj1 will represent the following respective values:
  • For Figure 1: the sum of shallow sizes of obj1, obj2 and obj4
  • For Figure 2: the sum of shallow sizes of obj1, obj2, obj3 and obj4
Looking at obj2, however, we see that its retained size in the above cases will be:
  • For Figure 1: the sum of shallow sizes of obj2 and obj4
  • For Figure 2: the sum of shallow sizes of obj2, obj3 and obj4
In general, retained size is an integral measure, which helps to understand the structure (clustering) of memory and the dependencies between object subgraphs, as well as find potential roots of those subgraphs.
Read More

你可能不知道的Shell


Shell也叫做命令行界面，它是*nix操作系统下用户和计算机的交互界面。Shell这个词是指操作系统中提供访问内核服务的程序。

这篇文章向大家介绍Shell一些非广为人知、但却实用有趣的知识，权当品尝shell主食后的甜点吧。

科普

先科普几个你可能不知道的事实：

Shell几乎是和Unix操作系统一起诞生，第一个Unix Shell是肯·汤普逊（Ken Thompson）以Multics上的Shell为模范在1971年改写而成，并命名Thompson sh。即便是后来流行的bash（shell的一种变体），它的年龄实际上比当前流行的所有的Linux kernel都大，可谓在Linux系统上是先有Shell再有Kernel。
当前绝大部分*nix和MacOS操作系统里的默认的Shell都是bash，bash由Brian Fox在1987年创造，全称Bourne Again shell ( bash)。
你或许听说除了bash之外，还有Bourne shell ( sh)，Korn shell ( ksh)，C shell （包括 csh and tcsh），但是你知道这个星球上一共存在着大约50多种不同的shell么？想了解他们，请参考 http://www.freebsd.org/ports/shells.html。
每个月tiobe上都会给一个编程语言的排名，来显示各种语言的流行度。排名指数综合了全球范围内使用该语言的工程师人数、教学的课程数和第三方供应商数。截止至2012年11月份，tiobe公布的编程语言排行榜里，bash的指数是0.56%排名22位。如果算上它旗下的awk 0.21%和tcl 0.146%，大概就能排到14名。注意这里还不包括bash的同源的兄弟姐妹csh、ksh等，算上它们，shell家族有望接近前十。值得一提的是一直以来shell的排名就很稳定，不像某些“暴发户”语言，比如objective-c，这些语言的流行完全是因为当前Apple系的崛起，但这种热潮极有可能来得快去得更快。




全球最大的源代码仓库Github里，shell相关的项目数占到了8%，跻身前5和Java相当，可见在实战工程里，shell可谓宝刀不老。图片来源，参见这里


一些强大的命令

再分享一些可能你不知道的shell用法和脚本，简单&强大！

在阅读以下部分前，强烈建议读者打开一个shell实验，这些都不是shell教科书里的大路货哦：）

!$
!$是一个特殊的环境变量，它代表了上一个命令的最后一个字符串。如：你可能会这样：
$mkdir mydir
$mv mydir yourdir
$cd yourdir
可以改成：
$mkdir mydir
$mv !$ yourdir
$cd !$
sudo !!
以root的身份执行上一条命令 。
场景举例：比如Ubuntu里用apt-get安装软件包的时候是需要root身份的，我们经常会忘记在apt-get前加sudo。每次不得不加上sudo再重新键入这行命令，这时可以很方便的用sudo !!完事。
（陈皓注：在shell下，有时候你会输入很长的命令，你可以使用!xxx来重复最近的一次命令，比如，你以前输入过，vi /where/the/file/is, 下次你可以使用 !vi 重得上次最近一次的vi命令。）
cd –
回到上一次的目录 。
场景举例：当前目录为/home/a，用cd ../b切换到/home/b。这时可以通过反复执行cd –命令在/home/a和/home/b之间来回方便的切换。
（陈皓注：cd ~ 是回到自己的Home目录，cd ~user，是进入某个用户的Home目录）
‘ALT+.’ or ‘ .’
热建alt+. 或 esc+. 可以把上次命令行的参数给重复出来。
^old^new
替换前一条命令里的部分字符串。
场景：echo "wanderful"，其实是想输出echo "wonderful"。只需要^a^o就行了，对很长的命令的错误拼写有很大的帮助。（陈皓注：也可以使用 !!:gs/old/new）
du -s * | sort -n | tail
列出当前目录里最大的10个文件。
:w !sudo tee %
在vi中保存一个只有root可以写的文件
date -d@1234567890
时间截转时间
> file.txt
创建一个空文件，比touch短。
mtr coolshell.cn
mtr命令比traceroute要好。
在命令行前加空格，该命令不会进入history里。
echo “ls -l” | at midnight
在某个时间运行某个命令。
curl -u user:pass -d status=”Tweeting from the shell” http://twitter.com/statuses/update.xml
命令行的方式更新twitter。
curl -u username –silent “https://mail.google.com/mail/feed/atom” | perl -ne ‘print “\t” if //; print “$2\n” if /<(title|name)>(.*)<\/\1>/;’
检查你的gmail未读邮件
ps aux | sort -nk +4 | tail
列出头十个最耗内存的进程
man ascii
显示ascii码表。
场景：忘记ascii码表的时候还需要google么?尤其在天朝网络如此“顺畅”的情况下，就更麻烦在GWF多应用一次规则了，直接用本地的man ascii吧。
ctrl-x e
快速启动你的默认编辑器（由变量$EDITOR设置）。
netstat –tlnp
列出本机进程监听的端口号。（陈皓注：netstat -anop 可以显示侦听在这个端口号的进程）
tail -f /path/to/file.log | sed '/^Finished: SUCCESS$/ q'
当file.log里出现Finished: SUCCESS时候就退出tail，这个命令用于实时监控并过滤log是否出现了某条记录。
ssh user@server bash < /path/to/local/script.sh
在远程机器上运行一段脚本。这条命令最大的好处就是不用把脚本拷到远程机器上。
ssh user@host cat /path/to/remotefile | diff /path/to/localfile -
比较一个远程文件和一个本地文件
net rpc shutdown -I ipAddressOfWindowsPC -U username%password
远程关闭一台Windows的机器
screen -d -m -S some_name ping my_router
后台运行一段不终止的程序，并可以随时查看它的状态。-d -m参数启动“分离”模式，-S指定了一个session的标识。可以通过-R命令来重新“挂载”一个标识的session。更多细节请参考screen用法 man screen。
wget --random-wait -r -p -e robots=off -U mozilla http://www.example.com
下载整个www.example.com网站。（注：别太过分，大部分网站都有防爬功能了：））
curl ifconfig.me
当你的机器在内网的时候，可以通过这个命令查看外网的IP。
convert input.png -gravity NorthWest -background transparent -extent 720×200  output.png
改一下图片的大小尺寸
lsof –i
实时查看本机网络服务的活动状态。
vim scp://username@host//path/to/somefile
vim一个远程文件
python -m SimpleHTTPServer
一句话实现一个HTTP服务，把当前目录设为HTTP服务目录，可以通过http://localhost:8000访问 这也许是这个星球上最简单的HTTP服务器的实现了。
history | awk '{CMD[$2]++;count++;} END { for (a in CMD )print CMD[a] " " CMD[a]/count*100 "% " a }' | grep -v "./" | column -c3 -s " " -t | sort -nr | nl | head -n10
(陈皓注：有点复杂了，history|awk ‘{print $2}’|awk ‘BEGIN {FS=”|”} {print $1}’|sort|uniq -c|sort -rn|head -10)
这行脚本能输出你最常用的十条命令，由此甚至可以洞察你是一个什么类型的程序员。
tr -c “[:digit:]” ” ” < /dev/urandom | dd cbs=$COLUMNS conv=unblock | GREP_COLOR=”1;32″ grep –color “[^ ]“
想看看Marix的屏幕效果吗？（不是很像，但也很Cool!）
看不懂行代码？没关系，系统的学习一下*nix shell脚本吧，力荐《Linux命令行与Shell脚本编程大全》。

最后还是那句Shell的至理名言：(陈皓注：下面的那个马克杯很不错啊，404null.com挺有意思的)
Read More

ps -elL | awk '$2 == "D"'

ps -elL | awk '$2 == "D"'
Read More

如何将函数的实际参数转化为真正的数组？


函数的arguments在JavaScript里只是一个类似数组的对象，和NodeList类似，拥有length属性，但没有push、pop和shift等数组中的方法，并不是真正意义上的数组，值得庆幸的是，我们可以通过数组的slice方法将arguments对象转换成真正的数组：



上述两种方式虽然实现的目的相同，但是两者在性能上有一些细微的差异。测试结果表明，在arguments.length较小的时候，方式2在性能上稍占优势，但是当arguments.length较大的时候，方式1就略胜一筹。

除此之外，还有第三种最传统最老土的方法：


在具体的应用中，还需结合实际情况，灵活选择最合适的方式，下边的实例展示了转换前后的差异。
Read More

Javascript 绝句


像诗一样的 Javascript 代码。

1. 取整同时转成数值型：

'10.567890'|0
//结果: 10
'10.567890'^0
//结果: 10
-2.23456789|0
//结果: -2
~~-2.23456789
//结果: -2
2. 日期转数值：

var d = +new Date(); //1295698416792
3. 类数组对象转数组：

var arr = [].slice.call(arguments)
4. 漂亮的随机码：

Math.random().toString(16).substring(2); //14位
Math.random().toString(36).substring(2); //11位
5. 合并数组：

var a = [1,2,3];
var b = [4,5,6];
Array.prototype.push.apply(a, b);
uneval(a); //[1,2,3,4,5,6]
6. 用0补全位数：

function prefixInteger(num, length) {
return (num / Math.pow(10, length)).toFixed(length).substr(2);
}
7. 交换值：

a= [b, b=a][0];
8. 将一个数组插入另一个数组的指定位置：

var a = [1,2,3,7,8,9];
var b = [4,5,6];
var insertIndex = 3;
a.splice.apply(a, Array.concat(insertIndex, 0, b));
// a: 1,2,3,4,5,6,7,8,9
9. 删除数组元素：

var a = [1,2,3,4,5];
a.splice(3,1);
10. 快速取数组最大和最小值

Math.max.apply(Math, [1,2,3]) //3
Math.min.apply(Math, [1,2,3]) //1
(出自http://ejohn.org/blog/fast-javascript-maxmin/)

11. 条件判断：

var a = b && 1;
//相当于
if (b) {
a = 1;
} else {
a = b;
}

var a = b || 1;
//相当于
if (b) {
a = b;
} else {
a = 1;
}
12. 判断IE（两种方法）:

var ie = /*@cc_on !@*/false;
var ie = !-[1,];
原文地址：http://bai.lu/RVT1X
Read More

How to Check Filesystem Block Size on Linux?

How to Check Filesystem Block Size on Linux?
Example 1:
# tune2fs -l /dev/sda1 | grep -i ‘block size’
Block size: 4096
Example 2:
# dumpe2fs -h /dev/sda1 |grep “Block size:”
Block size: 4096
Example 3:
# blockdev –getbsz /dev/sda1
4096
Example 4:
# echo “abc” >test.txt
# du -h test.txt
4.0K test
Read More
Subscribe to: Posts (Atom)