向东博客 专注WEB应用 构架之美 --- 构架之美，在于尽态极妍 | 应用之美，在于药到病除|赢在IT，Playin' with IT,Focus on Killer Application,Marketing Meets Technology.

背景：可能电脑是办工环境，你现在在外面用手机连接上linux上的ssh，又想这个时候关掉在PC登录连接上的ssh，怎么办？
  Linux系统root用户可强制踢制其它登录用户，首先以root登录以便查看全部的在线用户信息，可用 w 或者 who 命令查看用户所在的终端。
　　强制踢人命令格式：pkill -kill -t pts
　　解释：
　　pkill -kill -t 　踢人命令
　　tty　所踢用户的TTY
　　如上踢出tty1用户的命令为： pkill -kill -t pts/4
　　用户已经被强制踢掉了

实践如下：
1）谁还在用ssh连接到本linux上？
[root@iZ25dcp92ckZ ~]# w
17:52:38 up 118 days,  1:38,  5 users,  load average: 2.01, 2.02, 2.05
USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
root     pts/0    202.108.16.80    09:36    2:45m  1:36   0.34s -bash
root     pts/1    202.108.16.80    09:36    2:45m  0.19s  0.19s -bash
root     pts/3    202.108.16.80    09:36    2:45m  0.26s  0.26s -bash
root     pts/9    202.108.16.80    09:40    3:48m  0.11s  0.11s -bash

2）根据1作pkill操作，自己的ssh连接得留下：
[root@iZ25dcp92ckZ ~]# pkill -kill -t pts/0
[root@iZ25dcp92ckZ ~]# pkill -kill -t pts/1
[root@iZ25dcp92ckZ ~]# pkill -kill -t pts/3
[root@iZ25dcp92ckZ ~]# pkill -kill -t pts/9

3）确认已经把pc的ssh连接杀死并Ok了：
[root@iZ25dcp92ckZ ~]# w
17:53:21 up 118 days,  1:39,  1 user,  load average: 1.44, 1.89, 2.00
USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
root     pts/10   117.136.0.88     17:32    1.00s  0.05s  0.00s w
[root@iZ25dcp92ckZ ~]#


Freebsd一样的： last
root       pts/12   111.199.58.196         Wed Oct 11 22:40   still logged in
root       pts/11   111.199.58.196         Wed Oct 11 22:38   still logged in
root       pts/10   111.199.58.196         Wed Oct 11 22:34   still logged in
root       pts/9    111.199.58.196         Wed Oct 11 22:29   still logged in
root       pts/8    111.199.58.196         Wed Oct 11 22:28   still logged in
root       pts/7    111.199.58.196         Wed Oct 11 22:16   still logged in
root       pts/1    111.199.58.196         Wed Oct 11 22:16   still logged in
root       pts/6    111.199.58.196         Wed Oct 11 22:06   still logged in
root       pts/0    111.199.58.196         Wed Oct 11 22:05   still logged in
root       pts/5    111.199.58.196         Wed Oct 11 21:48   still logged in
root       pts/4    111.199.58.196         Wed Oct 11 21:04   still logged in
root       pts/3    111.199.58.196         Wed Oct 11 21:03   still logged in
root       pts/2    111.199.58.196         Wed Oct 11 20:57   still logged in

踢掉命令：
pkill -kill -t pts/12
pkill -kill -t pts/11
pkill -kill -t pts/10
pkill -kill -t pts/9
pkill -kill -t pts/8
pkill -kill -t pts/7
pkill -kill -t pts/1
pkill -kill -t pts/6
pkill -kill -t pts/0
pkill -kill -t pts/5
pkill -kill -t pts/4
pkill -kill -t pts/3
pkill -kill -t pts/2

背景：在写代码程序里写文件时不小心出现了一个带横线的文件，如下：
[root@iZ25dcp92ckZ temp]# ls
-000                                      84b1052c-ebc5-11e4-bf9b-b9856d949d58-002.mp4
[root@iZ25dcp92ckZ temp]# ll -i
总用量 58140
1211764 -rw-r--r-- 1 48 root        0 10月 23 17:14 -000
1187168 -rw-r--r-- 1 48 root 11904973 10月 23 17:14 84b1052c-ebc5-11e4-bf9b-b9856d949d58-002.mp4
干掉它：
find . -inum 1211764 -exec rm {} \;
————————————————————————————————————————————
linux下怎样删除以横线开关的文件:
一些客户用FTP上传了一些以横线开关的文件,然后需要删除或改名时都不能操作.所以很苦恼.
在删除时报以下错误:

以下是解决方法:
1.首先以ll -i 查看下文件的inode值.

2.有以下命令删除或改名此类文件:
find 命令
　　使用 UNIX find 命令，您可以完成使用 ls 命令所开始的工作。对于要进行操作的文件，您已经知道了它们的索引编号，那么就可以开始进行相应的操作了！
　　要删除看似无名的文件，您只需要使用 find 和 -inum 开关对索引编号和文件进行定位。然后，在找到该文件之后，使用 find 和 -exec 开关删除该文件：
　　
# find . -inum 393228 -exec rm {} \;
　　要对该文件进行重命名或删除，可以使用 mv 或 rm：
删除文件:



# find . -inum 393228 -exec mv {} passwd.txt \;
重命名文件:



问题解决.

来自：http://blog.chinaunix.net/uid-23683795-id-2391090.html

最近找到一篇很好的文章将linux多线程函数pthread_cond_wait，是我茅塞顿开，豁然开朗，决定转载过来，以便经常复习记忆。

条件变量的结构为pthread_cond_t，函数pthread_cond_init（）被用来初始化一个条件变量。它的原型为：
extern int pthread_cond_init __P ((pthread_cond_t *__cond,__const pthread_condattr_t *__cond_attr));
其中cond是一个指向结构pthread_cond_t的指针，cond_attr是一个指向结构pthread_condattr_t的指针。结构 pthread_condattr_t是条件变量的属性结构，和互斥锁一样我们可以用它来设置条件变量是进程内可用还是进程间可用，默认值是 PTHREAD_ PROCESS_PRIVATE，即此条件变量被同一进程内的各个线程使用。注意初始化条件变量只有未被使用时才能重新初始化或被释放。释放一个条件变量的函数为pthread_cond_destroy（pthread_cond_t cond）。　
也可以静态的初始化条件变量
pthread_cond_t my_condition = PTHREAD_COND_INITIALIZER;
函数pthread_cond_wait（）使线程阻塞在一个条件变量上。它的函数原型为：
extern int pthread_cond_wait __P ((pthread_cond_t *__cond,pthread_mutex_t *__mutex));
调用这个函数时,线程解开mutex指向的锁并被条件变量cond阻塞。线程可以被函数pthread_cond_signal和函数 pthread_cond_broadcast唤醒线程被唤醒后，它将重新检查判断条件是否满足，如果还不满足，一般说来线程应该仍阻塞在这里，被等待被下一次唤醒。这个过程一般用while语句实现。
通过下面的程序来理解:
__________________华丽的CODE分割线_________________________
pthreadCondWait.c
#include <stdio.h> #include <stdlib.h> #include <pthread.h>   #include <unistd.h> pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; /*初始化互斥锁*/ pthread_cond_t cond = PTHREAD_COND_INITIALIZER;  //初始化条件变量 void *thread1(void *); void *thread2(void *); int i=1; int main(void) {         pthread_t t_a;         pthread_t t_b;         pthread_create(&t_a,NULL,thread1,(void *)NULL);/*创建进程t_a*/         pthread_create(&t_b,NULL,thread2,(void *)NULL); /*创建进程t_b*/         pthread_join(t_b, NULL);/*等待进程t_b结束*/         pthread_mutex_destroy(&mutex);         pthread_cond_destroy(&cond);          exit(0); } void *thread1(void *junk) {         for(i=1;i<=9;i++)         {              pthread_mutex_lock(&mutex);//              if(i%3==0)                  pthread_cond_signal(&cond);/*条件改变，发送信号，通知t_b进程*/               else                         printf("thead1:%d\n",i);               pthread_mutex_unlock(&mutex);//*解锁互斥量*/               printf("Up Unlock Mutex\n");                     sleep(1);         } } void *thread2(void *junk) {         while(i<9)         {               pthread_mutex_lock(&mutex);             if(i%3!=0)                    pthread_cond_wait(&cond,&mutex);/*等待*/             printf("thread2:%d\n",i);             pthread_mutex_unlock(&mutex);             printf("Down Ulock Mutex\n");             sleep(1);                 } }

___________________至关重要的绚烂的结果分割线_________________
[root@iZ25dcp92ckZ testdemo]# vi pthreadCondWait.c          
[root@iZ25dcp92ckZ testdemo]# gcc pthreadCondWait.c -lpthread -o pthreadCondWaitStudy
[root@iZ25dcp92ckZ testdemo]# ./pthreadCondWaitStudy
thead1:1
Up Unlock Mutex
thead1:2
Up Unlock Mutex
Up Unlock Mutex
thread2:3
Down Ulock Mutex
thread2:3
Down Ulock Mutex
thead1:4
Up Unlock Mutex
thead1:5
Up Unlock Mutex
Up Unlock Mutex
thread2:6
Down Ulock Mutex
thread2:6
Down Ulock Mutex
thead1:7
Up Unlock Mutex
thead1:8
Up Unlock Mutex
Up Unlock Mutex
thread2:9
Down Ulock Mutex

_________________HOW IT WORKS________

i不是三的倍数的时候.
thread2条件变量阻塞,释放Mutex
thread1加锁,打印thread1:i,释放锁,打印"Up Unlock Mutex"
i为3的倍数的时候,
thread1,加锁,条件变量通知,唤醒条件变量阻塞线程,打印"Up Unlock Mutex"
thread2,被唤醒,加锁,打印"thread2:i",释放锁,打印"Down Ulock Mutex"

    所以说函数pthread_cond_wait()调用时,不仅对条件变量起作用,还对互斥锁有作用!

++++++++++++++++唯美的好书推荐线++++++++++++
"Beiginning Linux Programming" by Neil Matthrew & Richard Stones
You can choose the English version or Chinese version, but I recommend the English one. Maybe it' easier to understand what the authers say than the Chinese one ,  even if you're Chinese.

原文地址：http://blogold.chinaunix.net/u1/53448/showart_431857.html

背景：这个linux用户登录进行相关环境变量的设置和下面这些全局和用户之前的关系，值得大致有一个理解，特别是环境变量，有一些程序运行的环镜参数息息相关，还有类似如对secureCRT标签的设置（为什么就登录失效没有触发呢，直接运行又OK等问题有疑惑，排查问题困难），/etc/bashrc /etc/sysconfig/bash-prompt-xterm 里设置secureCRT标签，怎么登录就没有变呢，而是直接运行source /etc/bashrc即可生效（运行source XXX之前，先运行bash，即：1）bash 2）source XXX）：/etc/bashrc  里面包含/etc/sysconfig/bash-prompt-xterm 文件就能设置了呢，/etc/bashrc: 为每一个运行bash shell的用户执行此文件.当bash shell被打开时,该文件被读取。此中必然有蹊跷，设置secureCRT 的标签见：http://jackxiang.com/post/6773/ ，是阿里云给修改了这个：/etc/bashrc 里加入新变量：if [ -z "$PROMPT_COMMAND" ]; then ，它不为空，没有运行这个/etc/sysconfig/bash-prompt-xterm 文件,解决办法就是：PROMPT_COMMAND="";强制清空得了，重新运行source  /etc/bashrc就Ok了 。

执行顺序如下：
/etc/bashrc ==>（PROMPT_COMMAND=/etc/sysconfig/bash-prompt-xterm）=》 /etc/profile/etc/profile.d/ [2.for i in /etc/profile.d/*.sh ; do]  ==>.bash_profile =（包含:. ~/.bashrc）=. ~/.bashrc。（首先启动 /etc/profile 文件，然后再启动用户目录下的 ~/.bash_profile），摘自：http://blog.51cto.com/xoyabc/1658135

/etc/profile:此文件为系统的每个用户设置环境信息,当用户第一次登录时,该文件被执行.
并从/etc/profile.d目录的配置文件中搜集shell的设置.

/etc/bashrc:为每一个运行bash shell的用户执行此文件.当bash shell被打开时,该文件被读取.

~/.bash_profile:每个用户都可使用该文件输入专用于自己使用的shell信息,当用户登录时,该
文件仅仅执行一次!默认情况下,他设置一些环境变量,执行用户的.bashrc文件.

~/.bashrc:该文件包含专用于你的bash shell的bash信息,当登录时以及每次打开新的shell时,该
该文件被读取.

~/.bash_logout:当每次退出系统(退出bash shell)时,执行该文件.

另外,/etc/profile中设定的变量(全局)的可以作用于任何用户,而~/.bashrc等中设定的变量(局部)只能继承/etc/profile中的变量,他们是"父子"关系.

~/.bash_profile 是交互式、login 方式进入 bash 运行的

~/.bashrc 是交互式 non-login 方式进入 bash 运行的

通常二者设置大致相同，所以通常前者会调用后者。



bash的几个初始化文件 - [Ubuntu]



（1）/etc/profile
全局（公有）配置，不管是哪个用户，登录时都会读取该文件。

（2）/ect/bashrc
Ubuntu没有此文件，与之对应的是/ect/bash.bashrc
它也是全局（公有）的
bash执行时，不管是何种方式，都会读取此文件。

（3）~/.profile
若bash是以login方式执行时，读取~/.bash_profile，若它不存在，则读取~/.bash_login，若前两者不存在，读取~/.profile。
另外，图形模式登录时，此文件将被读取，即使存在~/.bash_profile和~/.bash_login。

（4）~/.bash_login
若bash是以login方式执行时，读取~/.bash_profile，若它不存在，则读取~/.bash_login，若前两者不存在，读取~/.profile。

（5）~/.bash_profile
Unbutu默认没有此文件，可新建。
只有bash是以login形式执行时，才会读取此文件。通常该配置文件还会配置成去读取~/.bashrc。

（6）~/.bashrc
当bash是以non-login形式执行时，读取此文件。若是以login形式执行，则不会读取此文件。

（7）~/.bash_logout
注销时，且是longin形式，此文件才会读取。也就是说，在文本模式注销时，此文件会被读取，图形模式注销时，此文件不会被读取。

下面是在本机的几个例子：
1. 图形模式登录时，顺序读取：/etc/profile和~/.profile
2. 图形模式登录后，打开终端时，顺序读取：/etc/bash.bashrc和~/.bashrc
3. 文本模式登录时，顺序读取：/etc/bash.bashrc，/etc/profile和~/.bash_profile
4. 从其它用户su到该用户，则分两种情况：
    （1）如果带-l参数（或-参数，--login参数），如：su -l username，则bash是lonin的，它将顺序读取以下配置文件：/etc/bash.bashrc，/etc/profile和~/.bash_profile。
    （2）如果没有带-l参数，则bash是non-login的，它将顺序读取：/etc/bash.bashrc和~/.bashrc
5. 注销时，或退出su登录的用户，如果是longin方式，那么bash会读取：~/.bash_logout
6. 执行自定义的shell文件时，若使用“bash -l a.sh”的方式，则bash会读取行：/etc/profile和~/.bash_profile，若使用其它方式，如：bash a.sh， ./a.sh，sh a.sh（这个不属于bash shell），则不会读取上面的任何文件。
7. 上面的例子凡是读取到~/.bash_profile的，若该文件不存在，则读取~/.bash_login，若前两者不存在，读取~/.profile。







linux中profile与bashrc的区别
Ubuntu 的相关目录下
/ect/ /root /home/myuser
profile .profile .profile
bash.bashrc .bashrc .bashrc
profile.d

Fedora的相关目录
/ect/ /root /home/myuser
profile 　　　　 profile
bashrc 　　.bashrc bashrc
profile.d 　　　　　　　　　　　　　　　　　　　　profile.d

说明：myuser　是你添加创建的用户
在网上找了半天也不能包括所有的，所以只能比较个大概。



bashrc与profile的区别

要搞清bashrc与profile的区别，首先要弄明白什么是交互式shell和非交互式shell，什么是login shell 和non-login shell。

交互式模式就是shell等待你的输入，并且执行你提交的命令。这种模式被称作交互式是因为shell与用户进行交互。这种模式也是大多数用户非常熟悉的：登录、执行一些命令、签退。当你签退后，shell也终止了。 shell也可以运行在另外一种模式：非交互式模式。在这种模式下，shell不与你进行交互，而是读取存放在文件中的命令,并且执行它们。当它读到文件的结尾，shell也就终止了。

bashrc与profile都用于保存用户的环境信息，bashrc用于交互式non-loginshell，而profile用于交互式log


来自：http://blog.renren.com/share/224354794/8635033605
========================登录Linux时/etc/profile、~/.bash_profile等几个文件的执行过程  ========================
关于登录linux时，/etc/profile、~/.bash_profile等几个文件的执行过程。 在登录Linux时要执行文件的过程如下： 在刚登录Linux时，首先启动 /etc/profile 文件，然后再启动用户目录下的 ~/.bash_profile、 ~/.bash_login或 ~/.profile文件中的其中一个，执行的顺序为：~/.bash_profile、 ~/.bash_login、 ~/.profile。如果 ~/.bash_profile文件存在的话，一般还会执行 ~
关于登录linux时，/etc/profile、~/.bash_profile等几个文件的执行过程。

在登录Linux时要执行文件的过程如下：

在刚登录Linux时，首先启动 /etc/profile 文件，然后再启动用户目录下的 ~/.bash_profile、 ~/.bash_login或 ~/.profile文件中的其中一个，执行的顺序为：~/.bash_profile、 ~/.bash_login、 ~/.profile。如果 ~/.bash_profile文件存在的话，一般还会执行 ~/.bashrc文件。因为在 ~/.bash_profile文件中一般会有下面的代码：

if [ -f ~/.bashrc ] ; then

. ./bashrc

fi

~/.bashrc中，一般还会有以下代码：

if [ -f /etc/bashrc ] ; then

. /bashrc

fi

所以，~/.bashrc会调用 /etc/bashrc文件。最后，在退出shell时，还会执行 ~/.bash_logout文件。

执行顺序为：/etc/profile -> (~/.bash_profile | ~/.bash_login | ~/.profile) -> ~/.bashrc -> /etc/bashrc -> ~/.bash_logout

关于各个文件的作用域，在网上找到了以下说明：

（1）/etc/profile： 此文件为系统的每个用户设置环境信息,当用户第一次登录时,该文件被执行. 并从/etc/profile.d目录的配置文件中搜集shell的设置。

（2）/etc/bashrc: 为每一个运行bash shell的用户执行此文件.当bash shell被打开时,该文件被读取。

（3）~/.bash_profile: 每个用户都可使用该文件输入专用于自己使用的shell信息,当用户登录时,该文件仅仅执行一次!默认情况下,他设置一些环境变量,执行用户的.bashrc文件。

（4）~/.bashrc: 该文件包含专用于你的bash shell的bash信息,当登录时以及每次打开新的shell时,该该文件被读取。

（5）~/.bash_logout:当每次退出系统(退出bash shell)时,执行该文件. 另外,/etc/profile中设定的变量(全局)的可以作用于任何用户,而~/.bashrc等中设定的变量(局部)只能继承 /etc/profile中的变量,他们是"父子"关系。

（6）~/.bash_profile 是交互式、login 方式进入 bash 运行的~/.bashrc 是交互式 non-login 方式进入 bash 运行的通常二者设置大致相同，所以通常前者会调用后者。

在这里开始书写日记、心情 …

来自：http://blog.163.com/jianweicheng@126/blog/static/356732022008228559399/

if (xxx) {     int i; }
里，如果xxx为true，后面的{}才被执行。{后，栈里为i开了4字节的单元（如果是32位机的话）。遇}时，这四个字节被弹出。






来自：http://www.kuqin.com/article/23candcplusplus/937677.html

[root@iZ25dcp92ckZ /]# find / -size +200M -exec du -h {} \;
1.1G    /swapfile


————————————————————————————————————
一、查看系统当前的分区情况：

>free -m
二、创建用于交换分区的文件:

>dd if=/dev/zero of=/whatever/swap bs=block_size （10M）count=number_of_block(3000)

三、设置交换分区文件:
>mkswap  /export/swap/swapfile

四、立即启用交换分区文件:
>swapon /whateever/swap

五、若要想使开机时自启用，则需修改文件/etc/fstab中的swap行：

/whatever/swap swap swap defaults 0 0

————————————————————————————————————
如何在红帽 企业版Linux系统中添加swap文件？
解决方法:
1. 确定swap文件的大小，单位为M。将该值乘以1024得到块大小。例如，64MB的swap文件的块大小是65536。

2. 在root提示符下，键入下面的命令，其中count大小等于所要求的块大小：

dd if=/dev/zero f=/swapfile bs=1024 count=65536
3. 建立swap文件：

mkswap /swapfile
4. 要立即打开swap文件而不是在启动时自动开启：

swapon /swapfile
5. 要想在启动时开启，需要在/etc/fstab中添加如下内容：

/swapfile    swap    swap   defaults 0 0
当下一次系统启动时，新的swap文件就打开了。

6. 在添加新的swap文件并开启后，检查cat /proc/swaps 或者free命令的输出来查看swap是否已打开。

7.删除SWAP分区
swapoff /swapfile    修改/etc/fstab文件  rm -rf /swapfile


1 block ＝ 512字节

来自：http://my.oschina.net/jccpp/blog/142980

来自：http://www.linuxidc.com/Linux/2013-03/81890.htm

删除SWAP：
swapon -s
swapoff /dev/dm-1
swapoff:/dev/dm-1: swapoff failed: Cannot allocate memory
kill -9 1503  #java killed
swapoff /dev/dm-1
free -m

背景：如果获取一个二进制文件大小，可能用stat命令，也可能c函数ftell去转一圈，知道大小。
//把文件的位置指针移到文件尾
fseek(fp,OL,SEEK_END);
//获取文件长度;
length=ftell(fp);
printf("该文件的长度为%1d字节\n",length);

#include <stdio.h> long GetFileSize(char *filename) {    long siz = 0;    FILE *fp = fopen(filename, "rb");    if (fp){           fseek(fp, 0, SEEK_END);           siz = ftell(fp);           fclose(fp);     }     return siz; } int main(){     long size;     char *fileName="./tianxia2.mp4";     size = GetFileSize(fileName);     printf("binary file %s size=%ld\n",fileName,size);     return 1;                                                                                                                                                                                         }

[root@iZ25dcp92ckZ multepoolserver]# ./getbinfilesize
binary file ./tianxia2.mp4 size=11827505

背景：关于Linux的流概念，比如在调试C代码时，出错了，或是想捕获输出的错误到同一个文件，这些都要用到流知识，输入，输出，错误分别是：0，1，2，于是有了 >2 >2&1,该文章都有详细解答讲解，写的非常好,写的非常好，难得的好干货,拨云见雾………我已经无力吐槽。
如：
[root@iZ25dcp92ckZ multepoolserver]# cat aaa.txt
cat: aaa.txt: 没有那个文件或目录
[root@iZ25dcp92ckZ multepoolserver]# cat aaa.txt > notexist.txt 2>&1
[root@iZ25dcp92ckZ multepoolserver]# cat notexist.txt
cat: aaa.txt: 没有那个文件或目录
————————————————————————————————————
./multepoolser > echoOut.txt
./tianxia > appleOut.txt 2>&1  

————————————————————————————————————————————————————————
内容简介

1、第三部分第二课：流、管道、重定向，三管齐下

2、第三部分第三课预告：监视系统活动，滴水不漏

流、管道、重定向，三管齐下

这一课我们来学一些非常有用的内容，而且相当有意思，而且内容很多，而且有可能颠覆你的三《观》（毕竟三管齐下，不颠覆三观也难）。

今天的标题中的三个名称，听上去就怪怪的。什么流，管道，重定向，都啥玩意啊。不过希望学完这课，大家能够有拨云见雾的感觉。

到目前为止，我们已经学习了不少Linux的命令了，也已经比较熟悉命令行的用法了。其最基本用法是这样的：

在终端输入命令（比如输入ls命令）。

命令的运行结果显示在终端中。

但是我们还不知道的是：其实我们可以重定向命令的运行结果。

重定向，是什么意思呢？简单来说，就是我们可以把本来要显示在终端的命令结果，输送到别的地方：

到文件中或者作为其他命令的输入（命令的链接，或者叫命令管道）。

把两个命令连起来使用，一个命令的输出作为另一个命令的输入，这就构成了管道。

管道的英语是pipeline。你可以想象一个个水管，连接起来。这一个水管流出来的水（输出），如果接上另一个水管，水是不是就流入另一个水管，成为另一个水管的输入了？

当然了，在计算机科学中，流（英语是stream）的含义是比较难理解的，也比较丰富，不同的情况下含义也不太一样。如果把它比作水流可能不完全。

知乎上就有一篇帖子，大家可以看看：

《如何理解编程语言中「流」（stream）的概念？》

http://www.zhihu.com/question/27996269

我们常可以看到这样的字样：位元流，字节流，资料流，视频流，音频流，流媒体，流算法，流处理，数据流挖掘，等等。

在维*基百科中，流的简单定义是这样的，供大家参考：

《In computer science, a stream is a sequence of data elements made available over time. A stream can be thought of as items on a conveyor belt being processed one at a time rather than in large batches.》

以上这段英语翻译过来大致意思是（有点难翻译...翻得不好不要拍我）：

《在计算机科学中，流是时间上可用的一系列数据元素。我们可以把流比喻成传送带上的物件，每个时间点传输一个，而不是多个打包传输。》

（翻得连我自己都快吐了...如果要扔我鸡蛋请再多扔几个面团过来，这样我可以做鸡蛋灌饼）

前面说了，我们会学习如何把命令的输出结果重定向到其他地方：

哪里：文件或者另一个命令的输入。

如何实现：通过在命令间插入特定的符号（这些符号可以被称为《重定向流》符号）。下面我们会学到，有好几种符号。

可以用下图来做一个小结：

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

可以看到，命令的输出可以有三个去向：

终端

文件

其他命令的输入

到目前为止，我们只用过第一种形式：把命令的输出结果显示在终端。

我们岂能就此罢休呢对吧，肯定要乘胜追击啊。一不做二不休啊。

重定向流从Unix时代就已经是很重要的概念了，后来Linux出现，重定向流的原理依旧沿用。

重定向流将会改变我们看待终端命令行的方式，所以这课很重要。

借着这一课，我们将把我们的命令行的造诣提升到另一个层级。如果之前是命令行的小学，那么这一课学完就基本可以初中毕业了。

你也许看到过一些Linux高手输入命令，经常会输入一大串，然后回车。这一大串命令中很可能就用到了我们今天学的流，管道和重定向。

>和>>：重定向到文件

我们先从最简单的开始。最简单的操作就是把命令的输出结果重定向到文件中，就不会在终端显示命令运行结果了。

准备工作：再谈cut命令

在开始学习>和>>这两个符号的用法之前，我们需要创建一些文件。

在创建文件之前，我们来谈谈cut命令的进阶用法。cut是英语《剪切》的意思，用于从文件中剪切出来一部分内容。

上一课《【Linux探索之旅】第三部分第一课：数据处理，慢条斯理》中我们学习了cut命令，但没有深入讲解，只讲了比较基本的用法（-c参数：根据字符数来剪切）。

我们再来学习一下cut命令的其他参数。

cut命令进阶：根据分隔符来剪切

我们来看一种特殊的文件形式：CSV格式。

CSV是Comma Separated Values的缩写，翻成中文是《逗号分隔值》。

以下摘自百度百科：

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

《逗号分隔值（Comma-Separated Values，CSV，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）。纯文本意味着该文件是一个字符序列，不含必须像二进制数字那样被解读的数据。CSV文件由任意数目的记录组成，记录间以某种换行符分隔；每条记录由字段组成，字段间的分隔符是其它字符或字符串，最常见的是逗号或制表符。通常，所有记录都有完全相同的字段序列。》

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

CSV文件的后缀名是.csv，通常可以被Excel等软件打开，打开之后会把分隔符隔开的各个数值填充到表格里。

我们来构建一个CSV文件。因为我们要用逗号作为分隔符，来学习cut命令的进阶使用：根据分隔符来剪切。

假设我们有一个人数不多的班级，作为老师我们需要统计新近一次考试的成绩。我们为此制作了一个表格，并按照顺序把数据写入表格。

我们的CSV文件的内容可以如下，我们用Nano这样的文本编辑器来编写这个CSV文件，并且取名：notes.csv （note是英语《成绩》的意思）。

Mack,95 / 100,很不错

Matthew,30 / 100,跟平时一样水

Louise,70 / 100,有进步

Luke,54 / 100,接近平均分了

John,68 / 100,不错，但还可以更好

Samuel,100 / 100,总是那么完美

David,40 / 100,退步挺大呀

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

如上图所示，我们的notes.csv文件中每一行由三部分组成，每部分由一个逗号分隔：

学生名字

成绩（满分是100分）

评语

现在假如我们要从notes.csv文件中提取名字那一列，怎么办呢？我们不能用cut命令的-c参数啊，毕竟每个名字的字符数不相等。

聪明如你应该想到了。是的，我们看到文件中每一行的每一部分是用分隔符来隔开的，所以我们可以这样做：

需要用到两个参数：

-d参数：d是delimiter的缩写，是《分隔符》的意思。用于指定用什么分隔符（比如逗号，分号，双引号等等）。

-f参数：f是field的缩写，是《区域》的意思。表示剪切下用分隔符分隔的哪一块或哪几块区域。

我们的notes.csv文件是用逗号来分隔三个部分的，我们要剪切下来的是名字那一列，也就是第一部分。因此我们可以这样使用：

cut -d , -f 1 notes.csv

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

怎么样，很不错吧。我们通过cut命令的两个参数就实现了从notes.csv文件中剪切下第一部分（名字）的想法。

那如果我们只想剪切下评语部分呢？评语是第三部分：

cut -d , -f 3 notes.csv

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

那如果我们要第一和第三部分呢？可以这样：

cut -d , -f 1,3 notes.csv

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

同样地，我们可以用 cut -d , -f 2- notes.csv 来剪切第二部分直到最后的内容：

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

好了，现在准备工作做好了，我们可以来学习重定向流符号了。

>：重定向到新的文件

我们知道虽然我们刚才用cut命令从notes.csv文件中剪切出来一些部分，但原始的notes.csv文件是不变的。

我们现在想要将剪切出来的部分储存到一个文件中，而不是像之前那样显示在终端里。

（为了方便演示，我们在家目录下新建一个redirect目录，redirect是英语《重定向》的意思。将之前的notes.csv文件放到这个目录下，再用cd redirect命令定位到这个目录）

我们需要用到>这个神奇的符号，如果你是美式键盘，那么可以在句号那个键找到这个符号，在句号的上面。所以要输入这个符号，可以用Shift加上句号那个键。做网络前端开发的程序员应该对这个符号不陌生，因为HTML语言里到处是<>这对符号。

这个符号可以将命令的输出结果重定向到你自己选择的文件中。例如：

cut -d , -f 1 notes.csv > students.txt

student是英语《学生》的意思。如果你运行上述命令，那么终端不会有任何显示。因为我们将cut命令的运行结果（剪切了名字那一列）重定向到students.txt文件中了。

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

可以看到，我们用cat命令打印了student.txt文件的内容，正是cut -d , -f 1 notes.csv 这句命令的运行结果。

我们用ls命令查看redirect目录下的文件，发现多了一个students.txt文件。

怎么样，>这个符号很有用吧。不过使用时要小心，因为>符号会把输出重定向到文件中，如果此文件不存在，则新建一个文件；如果此文件已经存在，那就会把文件内容覆盖掉（清除原有内容，然后写入文件），而且是不会征求用户确认的。

有时候，我们既不想将命令的输出显示在终端，又不想将其储存到文件中，怎么办呢？

Linux中有一个俗称《黑洞》的文件，就是 /dev/null

null是英语《无，空》的意思。

/dev/null 文件是特殊文件，不是一个目录。此文件具有唯一的属性：它总是空的。它能使发送到/dev/null 的任何数据作废，就好像这些数据掉进了无底的黑洞一般。

因此，假如我们不需要在终端显示刚才那个cut命令的结果，也不想存储到文件里，那么可以这么做：

cut -d , -f 1 notes.csv > /dev/null

>>: 重定向到文件末尾

我们已经知道，单独一个>符号可以实现重定向到新的文件（覆盖文件内容），那么两个连在一起的>符号有什么作用呢？

>>的作用与>是类似的，不过它不会像>那么危险（如果文件已经存在，>符号会覆盖文件内容），而是将重定向的内容写入到文件末尾，起到追加的作用。如果文件不存在，也会被创建。

我们就来实践一下：

cut -d , -f 1 notes.csv >> students.txt

因为我们上一个例子中已经用>符号来重定向名字那列的内容到students.txt文件中了，所以上面的命令会追加同样内容到students.txt的末尾。

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

我们用cat命令打印了students.txt文件的内容，可以看到有两遍notes.csv中名字列的内容。

>>符号在很多情况下非常有用，比如你人不在电脑前，而你又想让终端为你记录程序运行的结果，就可以在一个日志文件的末尾一直写入。例如：

command >> results.log

小结

我们方才学习了两个重定向流符号：

>：重定向到文件中。如果文件已存在，则覆盖文件内容；文件不存在，则创建文件。

>>：重定向到文件末尾。文件不存在，则创建文件。

可以用下图演示两个符号的原理：

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

2>，2>>，2>&1：重定向错误输出

怎么样，流的重定向是不是很有趣？那么我们继续学习其他的重定向流符号。

我们首先来学点新知识。

stdin，stdout，stderr：标准输入，标准输出，标准错误输出

这三个又是什么东东？这一课新东西果然多。

一般学编程，到某个阶段，总应该会碰到这三位仁兄的。所以既然逃不了，不如勇敢来面对。

对于我们的终端命令行，我们从键盘向终端输入数据，这是标准输入，也就是stdin。

终端接收键盘输入的命令，会产生两种输出：

标准输出：stdout。指终端输出的所有信息（不包括错误信息）。

标准错误输出：stderr。指终端输出的错误信息。

第一个stdout就是我们到目前为止看到的那些Linux命令的正常运行结果，比如在终端中运行ls命令，我们以前也看到了它列出当前目录下所有文件。

那什么是标准错误输出呢？其实我们以前也看到过，只是见得不多而已。

我们用一个例子来说明。

假设，我们运行cat notes.csv命令，想要显示notes.csv文件的内容。将会有两种结果：

如果一切顺利（notes.csv文件存在于当前目录，而且我们有权限这么做），那么终端就会显示其内容。这是标准输出。

如果出错（比如notes.csv文件不存在），那么终端就会显示错误信息。这是标准错误输出。

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

如上图所示，我们在redirect这个目录中运行cat notes.csv时，因为文件存在，而且我们有权限对其执行cat命令，所以打印出了文件内容。这就是标准输出。

接着，我们用cd .. 命令定位到了上一级目录，也就是用户的家目录，在这个目录中我们并没有创建notes.csv文件，所以cat notes.csv命令自然就输出了错误信息：No such file or directory，翻译过来就是《不存在此文件或目录》。这就是标准错误输出。

默认情况下，标准输出和标准错误输出都会显示在终端，这也是为什么我们之前对它们的区别并没有那么在意的原因，因为长得挺像的，都在终端输出。

我们可以用下图来演示：

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

这三个你也可以把它们看作流：

stdin：标准输入流。standard input的缩写。标准输入是指输入至程序的数据（通常是文件）。程序要求以读(read)操作来传输数据。并非所有程序都要求输入。如dir或ls程序运行时不用任何输入。 除非重定向，输入是预期由键盘获取的。 标准输入的文件描述符为 0 （零）；在POSIX <unistd.h> 的定义是 STDIN_FILENO；相对应的 <stdio.h> 变数为 FILE* stdin ；类似地， <iostream> 变数为 std::cin 。

stdout：标准输出流。standard output的缩写。标准输出是指程序写输出数据的流。程序要求数据传输使用写的运算。并非所有程序都要求输出。如mv或ren程序在成功完成时是没有输出的。 除非重导向，输出是预期显示在终端上的。 标准输出的文件描述符为 1 （一）。POSIX <unistd.h> 定义是 STDOUT_FILENO；相对应的 <stdio.h> 变数为 FILE* stdout ；类似地， <iostream> 变数为 std::cout 。

stderr：标准错误输出流。standard error的缩写。标准错误输出是另一个输出流，用于输出错误消息或诊断。它独立于标准输出，且标准输出和标准错误输出可以分别被重定向。标准错误输出的文件描述符为 2 （二）；POSIX <unistd.h> 定义为 STDERR_FILENO；相对的 <stdio.h> 变数 FILE* stderr。C++ <iostream> 的变数为： std::cerr。

文件描述符  名字  解释
0  stdin  标准输入
1  stdout  标准输出
2  stderr  标准错误输出
那什么是文件描述符呢？

文件描述符的英语是File Descriptor，简称fd。

文件描述符是计算机科学中的一个术语，要完全讲清楚可能要用单独的一课。我们就不深究了。

文件描述符是一个用于表述指向文件的引用的抽象化概念。这定义本身也有点抽象。我们不需要太深入了解。大致只需要知道：

《文件描述符在形式上是一个非负整数。实际上，它是一个索引值，指向操作系统内核为每一个进程所维护的该进程打开文件的记录表。当程序打开一个现有文件或者创建一个新文件时，内核向进程返回一个文件描述符》。

文件描述符通常是Unix，Linux等系统的概念。在Windows中，也有类似的概念，但是Windows中称为《句柄》，就是handle。

好了，重新回到我们的话题。刚才我们已经学习了用>和>>两个符号可以将输出重定向到文件中，那么我们在出错的情况下是不是也可以用>和>>将标准错误输出也重定向到文件中呢？我们来试试：

cat not_exist_file.csv > results.txt

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

如上图所示，因为 not_exist_file.csv 这个文件不存在（正如其名），所以产生了错误信息。但是这个错误信息却并没有如我们所愿的写入到results.txt文件中，而是仍旧在终端输出了。这是为什么呢？不是说好的>符号用于重定向输出到文件的吗？

其实，>和>>符号只是将标准输出重定向到文件。并不能将标准错误输出重定向到文件。

那么我们要重定向标准错误输出，该怎么办呢？

我们就要用到 2> 这个符号，是的，就是在>这个符号左边紧挨着写一个2。

为什么是2呢？记得上面说的吗？标准错误输出的文件描述符是2，所以这里的2表示标准错误输出。如果没有2，单独的>符号就是重定向标准输出（文件描述符为1）。

我们补充一下刚才的命令：

cat not_exist_file.csv > results.txt 2> errors.log

这个命令里有两个重定向：

> results.txt：将标准输出重定向到results.txt文件中。

2> errors.log：将标准错误输出重定向到errors.log文件中。

也就是说，假如 not_exist_file.csv这个文件确实存在，将其内容写入results.txt文件中；假如文件不存在，将错误信息写入errors.log文件中。

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

如上图所示，我们运行了cat not_exist_file.csv > results.txt 2> errors.log这个命令，因为not_exist_file.csv这个文件不存在，所以results.txt文件是空的；errors.log文件的内容是错误信息。

类似地，2>>符号用于将标准错误输出重定向到文件末尾。

合并输出

上面我们学习了如何将标准输出和标准错误输出分别重定向到不同文件。但是有的时候，我们比较任性，我们就想把标准输出和标准错误输出都重定向到同一个地方。怎么做呢？

须要使用 2>&1 这个组合符号。

看着怪怪的对吧？由四个字符组成。这个符号的作用是：将标准错误输出重定向到与标准输出相同的地方。

我们用实例演示一下：

cat not_exist_file.csv > results.txt 2>&1

上面的命令的作用是：将cat not_exist_file.csv这个命令的所有输出（标准输出和标准错误输出）都重定向到results.txt文件中。

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

如上图所示，运行cat not_exist_file.csv > results.txt 2>&1命令之后，因为not_exist_file.csv这个文件不存在，但又因为加了2>&1这个符号，所以标准输出（为空）和标准错误输出（cat: not_exist_file.csv: No such file or directory）都重定向到results.txt文件中了。

然后大家是否觉得要将标准输出和标准错误输出都重定向到文件末尾，应该是这样写：2>>&1 呢？

其实不然，这样是不对的。我们还是保持2>&1这个组合不变，只改变前面的符号就行了。例如：

cat not_exist_file.csv >> results.txt 2>&1

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

可以看到，又追加了一条错误信息到results.txt文件中。

小结

2>：将标准错误输出重定向到文件。如果文件已经存在，则覆盖文件内容；如果不存在，则创建文件。

2>>：将标准错误输出重定向到文件末尾。如果文件不存在，则创建文件。

2>&1：将标准输出和标准错误输出都重定向到一个地方。

用下图来演示：

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

上图中，我故意没有加>>和2>>，不然这图就太复杂了。其实>和>>，2>和2>>的区别就是前者覆盖文件内容，后者追加内容到文件。

<，<<：从文件或键盘读取

到目前为止，这一课我们只讲了如何重定向命令的输出，也就是决定命令输出的信息的去向。那么接着我们可以做一点相反的事情：决定命令的输入来自哪里。

当然了，上面也说了，不是所有的命令都有输入，也不是所有的命令都有输出。

到目前为止，我们的命令的输入都来自于后面接的参数，这些参数有些是文件名，有些是目录名，等等。

但我们其实可以使命令的输入来自于文件或者键盘输入。如下图所示：

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

<：从文件中读取

看到这个<符号，是不是想到了之前的>符号呢？

是的，这对孪生兄弟，原理类似但是功能正相反。<符号用于指定命令的输入。

我们用一个简单的例子来演示：

cat < notes.csv

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

如上图所示，cat < notes.csv的运行结果和cat notes.csv （不用重定向流符号）一模一样，都是在终端打印notes.csv的内容，那我们为什么需要<符号呢？

事实上，虽然cat < notes.csv的运行结果和cat notes.csv一样，但是原理却不一样：

cat notes.csv ：这种情况下，cat命令接受的输入是notes.csv这个文件名，那么它要先打开notes.csv文件，然后打印出文件内容。

cat < notes.csv ：这种情况下，cat命令接受的输入直接是notes.csv这个文件的内容，cat命令只负责将其内容打印。而打开文件，将文件内容传递给cat命令的工作则交给shell程序（也就是控制终端的程序）来完成。

所以，虽然结果看似一样，但是中间的过程确实不一样的。

<<：从键盘读取

<<符号的作用是将键盘的输入重定向为某个命令的输入，很多情况下都很有用。

我们用实例来说明：

sort -n << END

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

如上图所示，输入这条命令之后，回车，终端就进入了键盘输入模式，看到那个>符号和其后闪动的光标了么？

就是让你输入数据的。

我们知道sort -n的作用是按照从小到大进行排列。那么我们就输入一些数值吧（每输一个数值，用回车键来换行，接着输入下一个数值，输入END来结束输入，END被称为结束字符串。当然了，你可以用其他字符串，比如haha，nihao，不一定要用END）：

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

可以看到，sort -n命令将我们输入的一串数值进行了由小到大的排序。

我们再试试其他命令与<<符号的配合，这次我们用wc命令吧，wc命令用于统计字符等，如果配合-m参数就是统计字符数。

wc -m << END

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

可以看到，《How many characters are there in this sentence ?》这句话中有49个字符。

这句话翻成中文就是《这句话中有多少个字符？》

小结

<：将命令的输入重定向为文件内容。

<<：将命令的输入重定向为键盘输入，以逐行输入的模式（回车键换行）。所有输入的行都将在输入结束字符串（例如上面例子中的END）之后发送给命令。

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

当然了，我们也可以将之前学习的输出重定向符号和这一节的输入重定向符号结合使用：

sort -n << END > numbers_sorted.txt 2>&1

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

如上图所见，以上命令将sort -n命令对数值排序的结果都输入到numbers_sorted.txt文件中，如果有错误信息也输入。

|：管道

好了，终于来到本课的最后一节了。

是不是有点累呢？如果是的话，可以去烤一只烤鸭。为什么小编不像以前一样说烤鸡了呢？是因为最近有一对好友夫妇在法国Aix en Provence开了一家烤鸭店，他们的公众号发了几张诱人的烤鸭照片，看得小编直流哈喇子。但是吃不到啊，小编住在Nice附近，离Aix en Provence有近3个小时火车的路程。唉，以后去吧~

好了，不扯烤鸭了，言归正传。

这一节要学的符号，将会成为你以后Linux生涯中最常用的符号之一，使用率绝对高过这一课学的其他符号。

这个符号就是所谓的《管道符号》：|

是的，就是美式键盘上位于反斜杠那个键的那个符号，要输入这个符号，需要使用Shift + \

|符号既然被称为《管道符》，那么其作用就是《建立命令管道》咯。

是的，还记得本课开篇的时候我们提到的那个比喻吗？一个命令的输出可以作为另一个命令的输入，就好像将两根水管接起来一样，前一根水管流出来的水就会流入后一根水管了。

管道也算是重定向流的一种。

原理

将两个命令连成管道，这是什么意思呢？简单的说就是将一个命令的输出作为另一个命令的输入，如下图所示：

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

大致来说：命令1的输出立即会变成命令2的输入。使用这个原理，我们可以用|符号连接无穷多个命令，构成很长的命令管道。

管道符绝对使Linux命令的威力增加N倍。之前我们也说了，Linux中的命令（很多都是从Unix时代承袭下来的），每一个的功能虽然有限，但是却在它们自己的岗位上尽忠职守，工作做得棒棒哒。所以单独一条Linux命令可能功能有限，但是一旦《铁索连环》，那可是会结合各个命令的功能，其强大不难想见。

实践

我们用几个实例来学习管道吧。

按学生名字排序

你应该还记得我们的notes.csv文件，其中有三部分，用逗号隔开的，第一部分是学生名字，第二部分是成绩，第三部分是评语。

之前我们用cut -d , -f 1 notes.csv 命令来剪切了名字那一列。如果你还记得我们前一课学的sort命令，它是用于排序文件内容。

那么为什么不把这两个命令用管道符连接起来呢？我们可以用sort命令对cut命令提取到的名字列进行排序：

cut -d , -f 1 notes.csv | sort

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

如上图所见，我们用sort命令对名字列按照首字母的字典顺序进行了排序。

怎么样，管道是不是很有意思？

如果我们将上面的命令再扩充一下，配合之前学习的输出重定向符号，就变成了这样：

cut -d , -f 1 notes.csv | sort > sorted_names.txt

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

可以看到，我们将sort命令排序的结果重定向到sorted_names.txt文件中了。

根据大小排序目录

之前我们学过，du命令可以深入遍历当前目录下每个子目录，把所有文件的大小都做一个统计。

我们可以用cd命令来回到我们的家目录。然后运行du命令。

问题是：du命令要运行挺久的，因为小编家目录下文件很多。

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

单独用du命令的缺点我们也有目共睹了，一是可能要运行很久（如果文件很多），二是显示结果没有排序，杂乱无章。

但如果我们这样做就会清爽很多：

du | sort -nr | head

还记得head命令的用法么？如果不用-n参数指定显示行数，那么head会默认显示前10行。

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

所以以上命令的作用是：

du 深入遍历当前目录下每个子目录，把所有文件的大小都做一个统计

sort -nr sort命令的-n参数是按以数值来排序（此处是文件大小）排序，默认是小的在前；-r参数是倒序排列，有了-r参数，-n参数就变成大的数值在前了

head 列出前十个最大的数值（这里是文件大小）

列出包含关键字的文件

还记得我们的好朋友grep命令吗？之前的课中有学过，这个命令很强大，可以在文件中查找关键字，并且显示关键字所在的行。但有时，我们会觉得grep显示的信息太冗长了。每一行不仅有文件名，还有关键字出现的那一行文本，等等。

我们可以运行以下命令试试：

sudo grep log -Ir /var/log | cut -d : -f 1 | sort | uniq

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

这个命令做了什么呢？让我们一步步来分解：

sudo grep log -Ir /var/log ：遍历/var/log这个目录及其子目录，列出所有包含log这个关键字的行。-I参数用于排除二进制文件。-r参数用于递归遍历。sudo命令是为了以root身份查找系统文件夹/var/log。

cut -d : -f 1 从命令1的输出结果中只剪切出文件名那一列（由冒号分隔的第一个区域）。

sort 将文件名的列以首字母的字典顺序进行排序。

uniq : 去掉重复的文件名。

小结

小结很简单，因为管道符的基本作用比较简单，就是将一个命令的输出重定向为另一个命令的输入。如下图所示：

Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下

记住这个基本原理就好了。

好了，终于这一课结束了。是不是有点晕，如果觉得还没怎么掌握，那需要再读一遍本课程，参考一些课外读物，自己在终端上多练习。尽情发挥你的想象力，来创造出各种命令的组合吧。

总结

Linux命令的结果（标准输出），我们不一定要显示在终端里，也可以将其存放在一个文件里，只需要在命令后加上 > 符号，然后接文件名就可以了。例如 ls > file_list.txt 就会把ls命令的结果（当前目录所有文件的列表）存放到file_list.txt文件中，不在终端显示了。

>> 符号可以追加内容。>符号会把文件内容清空，再写入。如果文件已经存在，那么>>符号会在文件末尾追加写入内容。

2>和2>>符号用于重定向标准错误输出到文件中。2>&1符号用于将标准错误输出和标准输出重定向到相同地方。

<符号重定向命令的输入为文件内容，<<符号重定向命令的输入为键盘输入。

管道符号|可以将命令连接起来，好像一个个对接的管道一样，前一个命令的输出成为后一个命令的输入。

第三部分第三课预告

今天的课就到这里，一起加油吧！

下一课我们学习：监视系统活动，滴水不漏

新朋友请关注「程序员联盟」微信搜公众号 ProgrammerLeague

程序员联盟官网：

coderunity点com

程序员联盟论坛：

coderunity点com/bbs/

小编微信号： frogoscar

小编邮箱： enmingx@gmail.com


【Linux探索之旅第三部分第二课：流、管道、重定向，三管齐下】
http://toutiao.com/a6193788933316428033/?iid=3041659310&app=news_article&tt_from=android_share&utm_medium=toutiao_android&utm_campaign=client_share

背景：想要做一个高性能的框架也好，其实还是站在内核上面跳舞，为此，其对内核的设置很重要，就以swoole来讲，其queque是基于epoll，进程间通讯用到内核的que，当然要设置它 了，再就是消息队列这块的通讯，是不是也得设置，这块还有高并发的句柄这块，也需要设置为更大。这块linux下的epoll和freebsd的kqueque都要设置一下，否则，用不上内核的能力也就问题大了，swoole的nginx配置到swoole的通讯用unix socket dgram，也需要配置，你可能说这个框架性能不行了，其实性能是一个综合体，不是一个框架就能说明的。

当使用消息队列作为进程间通信方式时，需要调整此内核参数

kernel.msgmnb = 4203520，消息队列的最大字节数
kernel.msgmni = 64，最多允许创建多少个消息队列
kernel.msgmax = 8192，消息队列单条数据最大的长度

————————————————————————————
ulimit设置

ulimit -n 要调整为100000甚至更大。 命令行下执行 ulimit -n 100000即可修改。如果不能修改，需要设置 /etc/security/limits.conf，加入

* soft nofile 262140
* hard nofile 262140
root soft nofile 262140
root hard nofile 262140
* soft core unlimited
* hard core unlimited
root soft core unlimited
root hard core unlimited
内核设置

net.unix.max_dgram_qlen = 100

swoole使用unix socket dgram来做进程间通信，如果请求量很大，需要调整此参数。系统默认为10，可以设置为100或者更大。
或者增加worker进程的数量，减少单个worker进程分配的请求量。

net.core.wmem_max

修改此参数增加socket缓存区的内存大小

net.ipv4.tcp_mem  =   379008       505344  758016
net.ipv4.tcp_wmem = 4096        16384   4194304
net.ipv4.tcp_rmem = 4096          87380   4194304
net.core.wmem_default = 8388608
net.core.rmem_default = 8388608
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_tw_reuse

是否socket reuse，此函数的作用是Server重启时可以快速重新使用监听的端口。如果没有设置此参数，会导致server重启时发生端口未及时释放而启动失败

net.ipv4.tcp_tw_recycle

使用socket快速回收，短连接Server需要开启此参数

消息队列设置

当使用消息队列作为进程间通信方式时，需要调整此内核参数

kernel.msgmnb = 4203520，消息队列的最大字节数
kernel.msgmni = 64，最多允许创建多少个消息队列
kernel.msgmax = 8192，消息队列单条数据最大的长度

开启CoreDump

设置内核参数

kernel.core_pattern = /data/core_files/core-%e-%p-%t
通过ulimit -c命令查看当前coredump文件的限制

ulimit -c
如果为0，需要修改/etc/security/limits.conf，进行limit设置。

开启core-dump后，一旦程序发生异常，会将进程导出到文件。对于调查程序问题有很大的帮助
其他重要配置

net.ipv4.tcp_syncookies=1
net.ipv4.tcp_max_syn_backlog=81920
net.ipv4.tcp_synack_retries=3
net.ipv4.tcp_syn_retries=3
net.ipv4.tcp_fin_timeout = 30
net.ipv4.tcp_keepalive_time = 300
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.ip_local_port_range = 20000 65000
net.ipv4.tcp_max_tw_buckets = 200000
net.ipv4.route.max_size = 5242880
查看配置是否生效

如：修改net.unix.max_dgram_qlen = 100后，通过

cat /proc/sys/net/unix/max_dgram_qlen
如果修改成功，这里是新设置的值。

摘自：http://wiki.swoole.com/wiki/page/11.html
本地socket--SOCK_DGRAM方式：http://blog.csdn.net/shanzhizi/article/details/16883601

背景：我是一个同事，操作一些命令后出现这个问题，经过chmod 755 / 问题得到解决。
chmod 755 /

客户一个oracle突然当机了，由于业务启动，客户下意识的重启了服务器，系统是起来了，准备切换到oracle用户下启动数据库，可以怎么都无法su切换，真是火上浇油呀，描述如下：
在root用户下，su到一个普通用户oracle，得到如下错误:

[root@localhost ~]# su -  oracle
su: warning: cannot change directory to /home/oracle: Permission denied
su: /bin/bash: Permission denied

而oracle用户也无法通过直接登录，出现同样错误。

这是一个非常奇怪的问题，到底是什么导致的呢？思路如下：
1，程序执行权限问题
2，程序依赖的共享库权限问题
3，目录权限问题
4，根空间问题。

检查/bin/bash，权限正确，检查/home/oracle权限正确，检查/lib/ld-***.so，权限也正确。

继续调试，检查/etc/passwd，将oracle的home设置为/tmp，把/tmp设置为777，这个权限应该是最宽松的。

而su出现同样的错误。

也就是oracle用户无法访问777权限的/tmp。

问题到底出现在哪里呢？

最后
通过star命令，看到了问题根本，
[root@localhost ~]#stat  /
输出如下：因为你ls是看不到的。
  File: “/”
  Size: 1024            Blocks: 2          IO Block: 1024   目录
Device: 803h/2051d      Inode: 2           Links: 22
Access: (0666/drw-rw-rw-)  Uid: (    0/    root)   Gid: (    0/    root)
Access: 2007-12-01 22:28:48.000000000 +0800
Modify: 2007-12-01 22:28:34.000000000 +0800
Change: 2007-12-01 23:17:35.000000000 +0800

问题出来了，这里的权限是错误的，X权限的丢失造成的。

[root@localhost ~]#chmod 755 /


修改后,问题消失。

产生上述问题的方法：
第一种，chmod 666 /，可以导致。

或者，
第二种，chmod 700 /lib/ld-xxxx.so，也可以导致su失败。

有兴趣可以自己试一下。

/ 权限的丢失对于各种运行在自己用户身份上的daemon也存在同样的影响。
原文链接： http://www.ixdba.net/a/mz/2010/0421/14.html

背景：c语言把整数写入文件，并读出，C语言写整数到文件用啥函数？ 我看 fwrite 是写char*的。这个在调试队列时可以用上，有时入队出队不一致时，通过入队写了多少行出队写了多少行就知道到底队列程序在数据量大时有没有问题。

#include<stdio.h> #include<string.h> main(){         int count = 0;         FILE *f = fopen("./test.txt","wb+");         if(f){                 fprintf(f,"%d",888);                 printf("%s","ok");         }         rewind(f);         fscanf(f,"%d",&count);         count = count +9;         printf("%d",count);         fclose(f); }


摘自：http://blog.163.com/song_0803/blog/static/4609759720112231158527/

入队写文件：
FILE *f = fopen("./ququein.txt","wb+"); if(f){     fprintf(f,"%d",888); } fclose(f);

出队写文件：
FILE *f = fopen("./ququeout.txt","wb+"); if(f){                                       fprintf(f,"%d",888); } fclose(f);

#include<stdio.h> #include<string.h> main(){     FILE *f = fopen("./ququein.txt","wb+");     if(f){         fprintf(f,"%d",888);     }     fclose(f);     /*     FILE *f = fopen("./ququeout.txt","wb+");     if(f){         fprintf(f,"%d",888);     }     fclose(f);     */                                                                                                                                                                                               }


整个换行到里面去，否则全是888不太好用vim 打开直接set nu看多少行：
#include<stdio.h> #include<string.h> main(){     FILE *f = fopen("./ququein.txt","a+");     if(f){         fprintf(f,"%d",888);         char *enter="\n";         fwrite(enter,1,strlen(enter),f);     }     fclose(f);     /*     FILE *f = fopen("./ququeout.txt","wb+");     if(f){         fprintf(f,"%d",888);     }     fclose(f);     */ }

w+以纯文本方式读写，而wb+是以二进制方式进行读写。

mode说明：
w 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
w+ 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。
wb 只写方式打开或新建一个二进制文件，只允许写数据。
wb+ 读写方式打开或建立一个二进制文件，允许读和写。
r 打开只读文件，该文件必须存在，否则报错。
r+ 打开可读写的文件，该文件必须存在，否则报错。
rb+ 读写方式打开一个二进制文件，只允许读写数据。
a 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。（EOF符保留）
a+ 以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。 （原来的EOF符不保留）
ab+ 读写打开一个二进制文件，允许读或在文件末追加数据。
加入b 字符用来告诉函数库打开的文件为二进制文件，而非纯文字文件。

每天做得最多的就是用VIM打开文件、保存文件。使用VIM编辑文件时我习惯用'x'命令在保存并退出。而我的一个同事习惯用'wq'命令保存并退出，有一次他问我用'x'和'wq'有什么区别吗？我当时答不出来。

今天我在用'x'命令保存退出时发现了一个有趣的地方，保存退出后有时会显示 "filename" 1L, 10C 已写入  这么一行，有时又不显示。多试了几次才发现在没有修改文件时用'x'命令保存退出时不会显示 "filename" 1L, 10C 已写入 ，文件的修改时间也不会发生变化。有修改时则会显示这一行，而且文件的修改时间也会随之更新。接着我又使用'wq'命令保存退出时终于发现了点问题：不管我是否修改了文件内容，用'wq'命令保存退出时都会显示 "filename" 1L, 10C 已写入 ，并更新文件的修改时间。呵呵原来"x"与"wq"的的真正区别在这里：

wq   强制性写入文件并退出。即使文件没有被修改也强制写入，并更新文件的修改时间。
x    写入文件并退出。仅当文件被修改时才写入，并更新文件修改时间，否则不会更新文件修改时间。


From:http://blog.chinaunix.net/uid-12115233-id-3268894.html

用C语言实现一个循环队列并不难。关键点在于对队列 "空" 和 "满" 状态的判断。

正如《C和指针》中所描写的，有两种方法来实现对队列空和满状态的判断。

在数组中空一个元素不填，起始时, 置tail为0, front为1, 这样一来, 实现要浪费queue buffer中两个元素空间：
队列空:  (tail+1) % queue_size == front
队列满:  (tail+2) % queue_size == front
定义一个变量来记录队列中元素的个数, 判断队列的空和满直接看变量的值即可


本文中使用的是第2种:
#include <stdio.h>      #define QUEUE_SIZE          5   #define QUEUE_TYPE          int      static int queue_cnt = 0;   static int queue_front = 0;   static int queue_tail = 0;      static QUEUE_TYPE queue_buf[QUEUE_SIZE];      int is_empty()   {       return queue_cnt == 0;   }      int is_full()   {       return queue_cnt == QUEUE_SIZE;   }      int insert(QUEUE_TYPE e)   {       if (is_full()) {           printf("queue is full!!!\n");           return 0;       }       queue_buf[queue_tail] = e;       queue_tail = (queue_tail + 1) % QUEUE_SIZE;       queue_cnt++;          return 1;   }      int delete()   {       if (is_empty()) {           printf("queue is empty!!!\n");           return 0;       }       queue_front = (queue_front + 1) % QUEUE_SIZE;       queue_cnt--;       return 1;   }      int main()   {       insert(3);       insert(3);       insert(3);       insert(3);       insert(3);       delete();       insert(3);       insert(3);       return 0;   }  

来自：http://blog.csdn.net/huangkangying/article/details/44066729

在 .vimrc里添加：

fun! ShowFuncName()   let lnum = line(".")   let col = col(".")   echohl ModeMsg   echo getline(search("^[^ \t#/]\\{2}.*[^:]\s*$", 'bW'))   echohl None   call search("\\%" . lnum . "l" . "\\%" . col . "c") endfun map f :call ShowFuncName() <CR>
按一下 f 键就能显示函数名字。

来自：http://blog.csdn.net/caspiansea/article/details/42570311


vim里一个函数很长（几百行），光标在函数中间的某个位置，怎么快速跳到函数头？
[]
是跳到函数头。[ 是 p 右侧那个键。
正常模式
跳到头
[[
跳到尾
][
跳到下一个函数
]]
调到上一个函数
[]
调到上一层大括号
[{


ctrl + o 回到光标回到上次位置：
ESC下面那个按两下也可以实现


命令模式下跳转到某行：
比如开始在第n行,然后用mG后,跳到了m行,

背景：尽管登录vps会发邮件，但是会偶出现，登录了又发了一邮件，于是想此时看到底有多少个终端在登录态，还是阿里的alikid触发，还是真有黑客，怎么办，w查看，w tux。
LINUX是个多用户系统，一旦连接到网络中，它可以同时为多个登录用户提供服务。系统管理员可以随时了解系统中有那些用户，用户都在进行什么操作。
查看用户的操作
系统管理员若想知道某一时刻用户的行为，只需要输入命令w即可，在SHELL终端中输入如下命令：
tux@tux-desktop:~$ w
21:13:14 up 7:08, 2 users, load average: 0.22, 0.32, 0.20
USER     TTY      FROM              LOGIN@   IDLE   JCPU   PCPU WHAT
tux      tty7     :0               14:05     ?    37:55   0.33s x-session-manag
tux      pts/1    :0.0             21:13    0.00s 0.13s 0.00s w

可以看到执行W命令及显示结果。
命令信息含义
上述显示的信息分别表示如下：
第一行显示系统的汇总信息，字段分别表示系统当前时间、系统运行时间、登陆哟内用户总数及系统平均负载信息。对于上述势力中的几个显示数据意义为：
21:13:14 表示执行W的时间是在晚上9点13分。
7:08 表示系统运行7小时8分。
2 users 表示当前系统登陆用户总数为2。
load average与后面的数字一起表示系统在过去1，5，10分钟内的负载程度，数值越小，系统负载越轻。
从第二行开始构成一个表格，共有8个栏目，分别显示各个用户正在做的事情及该用户所占用的系统资料。
USER：显示登陆用户帐号名。用户重复登陆，该帐号也会重复出现。
TTY：用户登陆所用的终端。
FROM：显示用户在何处登陆系统。
LOGIN@：是LOGIN AT的意思，表示登陆进入系统的时间。
IDLE：用户空闲时间，从用户上一次任务结束后，开会记时。
JCPU：一终端代号来区分，表示在摸段时间内，所有与该终端相关的进程任务所耗费的CPU时间。
PCPU：指WHAT域的任务执行后耗费的CPU时间。
WHAT：表示当前执行的任务。

查看某用户
当登陆系统用户很多的时候，可以在W后面加上某个用户名，则会查看该用户执行任务的情况。
tux@tux-desktop:~$ w tux
21:19:01 up 7:14, 2 users, load average: 0.25, 0.21, 0.18
USER     TTY      FROM              LOGIN@   IDLE   JCPU   PCPU WHAT
tux      tty7     :0               14:05     ?    38:05   0.33s x-session-manag
tux      pts/1    :0.0             21:13    0.00s 0.13s 0.00s w tux

默认情况下，系统会显示上述所有的信息，如果只关心某一方面，可以只使用相关的选项。

linux svn工作空间锁定无法更新的解决方法（Working copy ‘.’ locked）
背景：有人在linux上直接修改文件（可能是debug），但没有提交成功。产生这种情况大多是因为上次svn更新命令执行失败且被自动锁定了。
于是会出现如下情况：
[root@localhost justwinit_devel]# /usr/bin/svn  update --username xiangdong --password xiangdong
svn: Working copy '.' locked
svn: run 'svn cleanup' to remove locks (type 'svn help cleanup' for details)
怎么办？

两步解决：
步骤1：
写个脚本批量清,cleanuplocked.sh：
#!/bin/sh
for lk in `find /data/htdocs/justwinit_devel -name "lock"`
do
`rm $lk`
done
exit


步骤二：运行命令svn cleanup：
[root@localhost justwinit_devel]# svn cleanup
[root@localhost justwinit_devel]# /usr/bin/svn  update --username xiangdong --password xiangdong

-----------------------------------------------------------------------
ATTENTION!  Your password for authentication realm:

   <http://svn.jackxiang.com:80> Authorization Realm

can only be stored to disk unencrypted!  You are advised to configure
your system so that Subversion can store passwords encrypted, if
possible.  See the documentation for details.

You can avoid future appearances of this warning by setting the value
of the 'store-plaintext-passwords' option to either 'yes' or 'no' in
'/root/.subversion/servers'.
-----------------------------------------------------------------------
Store password unencrypted (yes/no)? yes
At revision 2736.


参考：http://www.xuebuyuan.com/1112787.html

背景：vim打开代码时候发现空格显示后发现行尾有一堆空格...得删除，在vim配置下可以高亮这些空格，看到后方便删除掉。
让vim显示行尾的空格的配置办法，在/etc/vimrc文件添加如下两行 ：
highlight WhitespaceEOL ctermbg=red guibg=red
match WhitespaceEOL /\s\+$/
match WhitespaceEOL /\t\+/           #匹配tab实践从Windows上传Tab字符上去是OK的。
摘自：http://www.codeweblog.com/%E8%AE%A9vim%E6%98%BE%E7%A4%BA%E7%A9%BA%E6%A0%BC-%E5%8F%8Atab%E5%AD%97%E7%AC%A6-vim-%E5%A4%9A%E8%A1%8C%E6%B3%A8%E9%87%8A/

方法一：vi 删除行尾空格以替换解决掉删除行尾空格，实践OK如下：
行末：$
行首：^
空格：\s

行末空格：\s\+$
行首空格：^\+\s

删除行尾空格：
:%s/\s\+$//

:%s/\s\+$//g   #也成，别少个$就成，否则所有空格全给去了。
http://blog.itpub.net/22661144/viewspace-1433706/

方法二：用插件实现，实践OK，共两步
（1）安装插件到指定目录：
cd /tmp
git clone https://github.com/dongweiming/vary.vim  
mkdir -p /root/.vim/plugin
cd /root/.vim/plugin
mv /tmp/vary.vim/plugin/vary.vim /root/.vim/plugin/
ls /root/.vim/plugin/vary.vim
备注：特别注意，直接wget是不行的，wget https://github.com/dongweiming/vary.vim/blob/master/plugin/vary.vim,这个是网页，不全是源码，要么点上面的RAW，否则得git clone,里面的doc里的内容没有啥实际的功能性用处，不放也行，并不影响使用。
（2）让插件在vim 里配置并生效：
vim /root/.vimrc
set tabstop=4 let g:auto_striptrail = "htm,html,txt,xml,css,c,cpp,conf,cnf,php,vimrc,bash_profile,bashrc,sh,h,cpp,c,spec,ini,cfg,lua,xlsx,ltf,md,ltf,repo,jmx,js,python,ruby,csp" let g:auto_striptab = "htm,html,txt,xml,css,c,cpp,conf,cnf,php,vimrc,bash_profile,bashrc,sh,h,cpp,c,spec,ini,cfg,lua,xlsx,ltf,md,ltf,repo,jmx,js,python,ruby,csp" autocmd BufReadPost * :call StripTrailingWhite() autocmd BufReadPost * :call RetabIndents()        
实践发现Txt文件不行，不能替换，PHP可以，再就是在/root/.vimrc里包含就直接包含：
if filereadable(expand("~/.vimrc.bundles"))                                                                              
  source ~/.vimrc.bundles
endif

#cat /root/.vimrc.bundles
filetype off   set rtp+=~/.vim/bundle/vundle/ call vundle#rc() " Define bundles via Github repos " Bundle 'christoomey/vim-run-interactive' Bundle 'croaky/vim-colors-github' Bundle 'danro/rename.vim' Bundle 'majutsushi/tagbar' Bundle 'kchmck/vim-coffee-script' Bundle 'kien/ctrlp.vim' Bundle 'pbrisbin/vim-mkdir' Bundle 'scrooloose/syntastic' Bundle 'slim-template/vim-slim' Bundle 'thoughtbot/vim-rspec' Bundle 'tpope/vim-bundler' Bundle 'tpope/vim-endwise' Bundle 'tpope/vim-fugitive' Bundle 'tpope/vim-rails' Bundle 'tpope/vim-surround' Bundle 'vim-ruby/vim-ruby' Bundle 'vim-scripts/ctags.vim' Bundle 'vim-scripts/matchit.zip' Bundle 'vim-scripts/tComment' Bundle 'mattn/emmet-vim' Bundle 'scrooloose/nerdtree' Bundle 'Lokaltog/vim-powerline' Bundle 'godlygeek/tabular' Bundle 'msanders/snipmate.vim' Bundle 'jelera/vim-javascript-syntax' Bundle 'altercation/vim-colors-solarized' Bundle 'othree/html5.vim' Bundle 'xsbeats/vim-blade' Bundle 'Raimondi/delimitMate' Bundle 'groenewege/vim-less' Bundle 'Lokaltog/vim-easymotion' Bundle 'tomasr/molokai' Bundle 'klen/python-mode' Bundle 'dongweiming/vary.vim'

直接修改插件：
vi /root/.vim/bundle/vary.vim/plugin/vary.vim

VIM调试/root/.vimrc的脚本方法：
vim -D /tmp/jackX.txt

最后两行介绍,在/root/.vimrc下面加两行实现后，实践发现，打开时就自动去行尾空格,在写入前有行尾空格也给自动去了写入：
autocmd BufReadPost * :call StripTrailingWhite()
autocmd BufReadPost * :call RetabIndents()
表示打开文件之前就修改，把修改后的结果呈现给你
成功实践来自网址：http://www.tuicool.com/articles/aQfqUv


三、实践OK之Editplus删除行尾空格:
Editplus的替换查找：　\s+$
[V]正则表达式
全部替换


四、RegexBuddy调试之多行尾测试之Whole file改为Line by line：
Match：
\s+$

Test:
psql \  
   --host=127.0.0.1 \  
   --port=5432 \  
   --username kong \  
   --password \  
   --dbname=kongdb

发现只被替换了kongdb后面的空格，怎么办？
在Test下面一行有一个：Whole file改为Line by line即可按多行，也就能看到上面这个六行的行尾给变黄了，也就是被标记成行尾空格了。


四、sublime去行尾空格：
\s+$

（1）具体步骤：
CTRL+H打开replace功能，勾选上左侧的regular expression，并填写
find what栏 : \s+$
replace with栏 : （这行留空）
接着点replace all即可

（2）配置法去行尾空格：
点击菜单栏上的“Preferences”，找到“Setting-Default”，搜索“trim_trailing_white_space_on_save："trim_trailing_white_space_on_save": true,