grep [^a-k]pple

从系统词典中选择所有以“c”开头且以“o”结尾的单词
grep '\'
找出一个文件中或者输出中找到包含*的行
grep '\*'
显示所有包含每个字符串至少有20个连续字母的单词的行
grep [a-Z]\{20,\}

sort - 排序

语法：

sort [-fbMnrtuk] [file or stdin]

参数说明：

• -f ：忽略大小写的差异，例如 A 与 a 视为编码相同；
• -b ：忽略最前面的空格符部分；
• -M ：以月份的名字来排序，例如 JAN, DEC 等等的排序方法；
• -n ：使用『纯数字』进行排序(默认是以文字型态来排序的)；
• -r ：反向排序；
• -u ：就是 uniq ，相同的数据中，仅出现一行代表；
• -t ：分隔符，默认是用 [tab] 键来分隔；
• -k ：以哪个区间 (field) 来进行排序

默认是以第一个字符升序排序:

# cat /etc/passwd | sort adm:x:3:4:adm:/var/adm:/sbin/nologinavahi-autoipd:x:100:156:avahi-autoipd:/var/lib/avahi-autoipd:/sbin/nologinavahi:x:70:70:Avahi daemon:/:/sbin/nologinbin:x:1:1:bin:/bin:/sbin/nologin......

以第3列排序：

[root@www ~]# cat /etc/passwd | sort -t ':' -k 3root:x:0:0:root:/root:/bin/bashuucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologinoperator:x:11:0:operator:/root:/sbin/nologinbin:x:1:1:bin:/bin:/sbin/nologingames:x:12:100:games:/usr/games:/sbin/nologin

使用数字排序：

cat /etc/passwd | sort -t ':' -k 3nroot:x:0:0:root:/root:/bin/bashdaemon:x:1:1:daemon:/usr/sbin:/bin/shbin:x:2:2:bin:/bin:/bin/sh

倒序排序：

cat /etc/passwd | sort -t ':' -k 3nrnobody:x:65534:65534:nobody:/nonexistent:/bin/shntp:x:106:113::/home/ntp:/bin/falsemessagebus:x:105:109::/var/run/dbus:/bin/falsesshd:x:104:65534::/var/run/sshd:/usr/sbin/nologin或者cat /etc/passwd | sort -t ':' -k 3 -nr

先以第六个域的第2个字符到第4个字符进行正向排序，再基于第一个域进行反向排序：

cat /etc/passwd |  sort -t ':' -k 6.2,6.4 -k 1r      sync:x:4:65534:sync:/bin:/bin/syncproxy:x:13:13:proxy:/bin:/bin/shbin:x:2:2:bin:/bin:/bin/shsys:x:3:3:sys:/dev:/bin/sh

查看/etc/passwd有多少个shell:

方法对/etc/passwd的第七个域排序并去重，然后统计行数：

[root@VM_0_9_centos ~]# cat /etc/passwd |  sort -t':' -k 7 -uroot:x:0:0:root:/root:/bin/bashsyslog:x:996:994::/home/syslog:/bin/falsesync:x:5:0:sync:/sbin:/bin/synchalt:x:7:0:halt:/sbin:/sbin/haltbin:x:1:1:bin:/bin:/sbin/nologinshutdown:x:6:0:shutdown:/sbin:/sbin/shutdown[root@VM_0_9_centos ~]# cat /etc/passwd |  sort -t':' -k 7 -u|wc -l6

uniq - 去重

选项与参数：-i   ：忽略大小写字符的不同；-c  ：进行计数-u  ：只显示唯一的行

该命令用于排完序之后，对排序结果进行去重

python@xxx:~$ last | cut -d ' ' -f 1  | sort | uniqhahapythonrebootwtmppython@xxx:~$ last | cut -d ' ' -f 1  | sort | uniq -c      12 haha     22 python      7 reboot      1 wtmp

排序文件，默认是去重：

#cat words | sort |uniqfriendhelloworld

排序之后删除了重复行，同时在行首位置输出该行重复的次数：

#sort testfile | uniq -c1 friend3 hello2 world

仅显示存在重复的行，并在行首显示该行重复的次数：

#sort testfile | uniq -dc3 hello2 world

仅显示不重复的行：

sort testfile | uniq -ufriend

tee - 同时输出多个文件

从标准输入设备读取数据，将其内容输出到标准输出设备，同时保存成文件。

一般情况下用重定向实现，需要同时输出多个文件时可以使用该命令。

参数：

• -a或–append 　附加到既有文件的后面，而非覆盖它．

将输出同时保存到多个文件中，同时将输出内容显示到控制台：

python@xxx:~/test$ echo "hello world"|tee f1 f2 hello worldpython@xxx:~/test$ cat f1hello worldpython@xxx:~/test$ echo "hello world"|tee f1 f2 -ahello worldpython@xxx:~/test$ cat f1hello worldhello world

tr - 替换指定的字符

不指定参数时，即表示替换指定的字符为另一个字符，支持指定的字符集合。

参数说明：

• -d, --delete：删除指定的字符
• -s, --squeeze-repeats：缩减连续重复的字符成指定的单个字符

字符集合的范围：

• \NNN 八进制值的字符 NNN (1 to 3 为八进制值的字符)
• \ 反斜杠
• \a Ctrl-G 铃声
• \b Ctrl-H 退格符
• \f Ctrl-L 走行换页
• \n Ctrl-J 新行
• \r Ctrl-M 回车
• \t Ctrl-I tab键
• \v Ctrl-X 水平制表符
• CHAR1-CHAR2 ：字符范围从 CHAR1 到 CHAR2 的指定，范围的指定以 ASCII 码的次序为基础，只能由小到大，不能由大到小。
• [CHAR*] ：这是 SET2 专用的设定，功能是重复指定的字符到与 SET1 相同长度为止
• [CHAR*REPEAT] ：这也是 SET2 专用的设定，功能是重复指定的字符到设定的 REPEAT 次数为止(REPEAT 的数字采 8 进位制计算，以 0 为开始)
• [:alnum:] ：所有字母字符与数字
• [:alpha:] ：所有字母字符
• [:blank:] ：所有水平空格
• [:cntrl:] ：所有控制字符
• [:digit:] ：所有数字
• [:graph:] ：所有可打印的字符(不包含空格符)
• [:lower:] ：所有小写字母
• [:print:] ：所有可打印的字符(包含空格符)
• [:punct:] ：所有标点字符
• [:space:] ：所有水平与垂直空格符
• [:upper:] ：所有大写字母
• [:xdigit:] ：所有 16 进位制的数字
• [=CHAR=] ：所有符合指定的字符(等号里的 CHAR，代表你可自订的字符)

将文件testfile中的小写字母全部转换成大写字母：

cat testfile |tr a-z A-Z 或cat testfile |tr [:lower:] [:upper:] 

缩减连续重复的字符成指定的单个字符：

python@xxx:~/test$ cat tdddddddsssssddeeeeeeeeeeaaaaaaaaaaaaaavvvvvvvvvvvvvvpython@xxx:~/test$ cat t|tr -s 'se'dddddddsddeaaaaaaaaaaaaaavvvvvvvvvvvvvvpython@xxx:~/test$ cat t|tr -s 'sdeav'dsdeav

删除指定的字符：

python@xxx:~/test$ cat t|tr -d 'dv'ssssseeeeeeeeeeaaaaaaaaaaaaaa

join - 文件按行连接

将两个文件中指定栏位相同的行连接起来。即按照两个文件中共同拥有的某一列，将对应的行拼接成一行。

注意：在使用join之前所处理的文件要事先经过排序。

$ cat testfile_1Hello 95 #例如，本例中第一列为姓名，第二列为数额  Linux 85  test 30  cmd@hdd-desktop:~$ cat testfile_2Hello 2005 #例如，本例中第一列为姓名，第二列为年份  Linux 2009  test 2006 

使用join命令，将两个文件连接：

$ join testfile_1 testfile_2 #连接testfile_1、testfile_2中的内容  Hello 95 2005 #连接后显示的内容  Linux 85 2009  test 30 2006 

两个文件互换，输出结果的变化：

$ join testfile_2 testfile_1 #改变文件顺序连接两个文件  Hello 2005 95 #连接后显示的内容  Linux 2009 85  test 2006 30 

参数：

• -a 除了显示原来的输出内容之外，还显示指令文件中没有相同栏位的行。
• -e 若[文件1]与[文件2]中找不到指定的栏位，则在输出中填入选项中的字符串。
• -i或–igore-case 比较栏位内容时，忽略大小写的差异。
• -o 按照指定的格式来显示结果。
• -t 使用栏位的分隔字符。
• -v 跟-a相同，但是只显示文件中没有相同栏位的行。
• -1 连接[文件1]指定的栏位。
• -2 连接[文件2]指定的栏位。

paste-将多个文件对应行链接在一起

paste 指令会把每个文件以列对列的方式，一列列地加以合并。

语法：

paste [-s][-d ][文件...]

参数：

• -d或–delimiters= 　用指定的间隔字符取代跳格字符。
• -s或–serial 　串列进行而非平行处理。
• [文件…] 指定操作的文件路径

使用paste指令将文件"file"、“testfile”、"testfile1"进行合并，输入如下命令：

$ cat file    #file文件的内容  xiongdan 200  lihaihui 233  lymlrl 231  $ cat testfile#testfile文件的内容  liangyuanm  ss  $ cat testfile1      #testfile1文件的内容  huanggai 56  zhixi 73 $ paste file testfile testfile1xiongdan 200    liangyuanm ss   huanggai 56lihaihui 233     zhixi 73lymlrl 231$ paste -d ':' file testfile testfile1xiongdan 200:liangyuanm ss:huanggai 56lihaihui 233::zhixi 73lymlrl 231::

参数"-s"可以将一个文件中的多行数据合并为一行进行显示：

$ paste -s file      #合并指定文件的多行数据xiongdan 200 lihaihui 233 lymlrl 231 

如果将文件位置改为-，表示接收标准输入：

$ cat file |paste testfile1 -huanggai 56     xiongdan 200zhixi 73 lihaihui 233 lymlrl 231

split - 文件切割

split命令用于将一个文件分割成数个。

该指令将大文件分割成较小的文件，在默认情况下将按照每1000行切割成一个小文件。

语法：

split [-bl] file prefix-b: 以大小切割-l：以行数切割prefix：切割后文件的前缀

参数说明：

• - : 指定每多少行切成一个小文件
• -b : 指定每多少字节切成一个小文件
• -C : 与参数"-b"相似，但是在切 割时将尽量维持每行的完整性
• [输出文件名] : 设置切割后文件的前置文件名， split会自动在前置文件名后再加上编号

使用指令"split"将文件"README"每6行切割成一个文件，输入如下命令：

$ split -6 README#将README文件每六行分割成一个文件 $ ls    #执行ls指令  #获得当前目录结构README xaa xad xag xab xae xah xac xaf xai

以上命令执行后，指令"split"会将原来的大文件"README"切割成多个以"x"开头的小文件。而在这些小文件中，每个文件都只有6行内容。

以大小切割：

$ ls -lh disease.dmp-rwxr-xr-x 1 root root 122M Jul  4  2013 disease.dmp$ split -b 50m disease.dmp disease.dmp$ ls -lh disease.dmp*-rwxr-xr-x 1 root root 122M Jul  4  2013 disease.dmp-rw-r--r-- 1 root root  50M Jan  9 16:10 disease.dmpaa-rw-r--r-- 1 root root  50M Jan  9 16:10 disease.dmpab-rw-r--r-- 1 root root  22M Jan  9 16:10 disease.dmpac

xargs - 参数代换

不是所有的命令都支持管道，如ls，对于不支持管道的命令，可以通过xargs让其有管道命令的效果，如下所示：

# find /sbin -perm +7000 | xargs ls -l-rwsr-x--- 1 root ecryptfs 19896 Feb 23  2012 /sbin/mount.ecryptfs_private-rwsr-xr-x 1 root root     75496 Jan  9  2013 /sbin/mount.nfs-rwsr-xr-x 1 root root     75504 Jan  9  2013 /sbin/mount.nfs4-rwxr-sr-x 1 root root      8544 Feb 22  2012 /sbin/netreport-rwsr-xr-x 1 root root     14112 Nov  2  2010 /sbin/pam_timestamp_check-rwsr-xr-x 1 root root     75504 Jan  9  2013 /sbin/umount.nfs-rwsr-xr-x 1 root root     75504 Jan  9  2013 /sbin/umount.nfs4-rwsr-xr-x 1 root root     19768 Nov  2  2010 /sbin/unix_chkpwd

如果没有xargs，ls -l的结果将不是前面find的标准输出，因为ls不支持管道命令。

xargs 用作替换工具，读取输入数据重新格式化后输出。

定义一个测试文件，内有多行文本数据：

# cat test.txta b c d e f gh i j k l m no p qr s tu v w x y z

多行输入单行输出：

# cat test.txt | xargsa b c d e f g h i j k l m n o p q r s t u v w x y z

-n 选项多行输出：

# cat test.txt | xargs -n3a b cd e fg h ij k lm n op q rs t uv w xy z

-d 选项可以自定义一个定界符：

# echo "nameXnameXnameXname" | xargs -dXname name name name

结合 -n 选项使用：

# echo "nameXnameXnameXname" | xargs -dX -n2name namename name

读取 stdin，将格式化后的参数传递给命令:

# cat sk.sh#!/bin/bash#sk.sh命令内容，打印出所有参数。echo $*# cat arg.txtaaabbbccc# cat arg.txt | xargs -I {} ./sk.sh -p {} -l-p aaa -l-p bbb -l-p ccc -l

选项-I指定一个替换字符串 {}，这个字符串在 xargs 扩展时会被替换掉。

复制所有图片文件到 /data/images 目录下：

ls *.jpg | xargs -n1 -I {} cp {} /data/images

选项-n 后面加次数，表示命令在执行的时候一次用的argument的个数，默认是用所有的。

xargs 结合 find 使用

用 rm 删除太多的文件时候，可能得到一个错误信息：/bin/rm Argument list too long. 用 xargs 去避免这个问题：

find . -type f -name "*.log" -print0 | xargs -0 rm -f

xargs -0 将 \0 作为定界符。

统计一个源代码目录中所有 php 文件的行数：

find . -type f -name "*.php" -print0 | xargs -0 wc -l

查找所有的 jpg 文件，并且压缩它们：

find . -type f -name "*.jpg" -print | xargs tar -czvf images.tar.gz

批量下载：

# cat url-list.txt | xargs wget -c

wget的-c选项表示断点续传。

linux命令练习

常用命令

1.进入到用户根目录cd ~ 或 cd2.查看当前所在目录pwd3.进入到hadoop用户根目录cd ~hadoop4.返回到原来目录cd -5.返回到上一级目录cd ..6.查看hadoop用户根目录下的所有文件ls -la7.在根目录下创建一个hadoop的文件夹mkdir /hadoop8.在/hadoop目录下创建src和WebRoot两个文件夹分别创建：mkdir /hadoop/src  mkdir /hadoop/WebRoot同时创建：mkdir /hadoop/{src,WebRoot}进入到/hadoop目录，在该目录下创建.classpath和README文件分别创建：touch .classpath  touch README同时创建：touch {.classpath,README}查看/hadoop目录下面的所有文件ls -la在/hadoop目录下面创建一个test.txt文件,同时写入内容"this is test"echo "this is test" > test.txt查看一下test.txt的内容cat test.txtmore test.txtless test.txt向README文件追加写入"please read me first"echo "please read me first" >> README将test.txt的内容追加到README文件中cat test.txt >> README拷贝/hadoop目录下的所有文件到/hadoop-bakcp -r /hadoop /hadoop-bak进入到/hadoop-bak目录，将test.txt移动到src目录下，并修改文件名为Student.javamv test.txt src/Student.java在src目录下创建一个struts.xml> struts.xml删除所有的xml类型的文件rm -rf *.xml删除/hadoop-bak目录和下面的所有文件rm -rf /hadoop-bak返回到/hadoop目录，查看一下README文件有多单词，多少个少行wc -w READMEwc -l README返回到根目录，将/hadoop目录先打包，再用gzip压缩分步完成：tar -cvf hadoop.tar hadoop  gzip hadoop.tar一步完成：tar -zcvf hadoop.tar.gz hadoop  将其解压缩，再取消打包分步完成：gzip -d hadoop.tar.gz 或 gunzip hadoop.tar.gz一步完成：tar -zxvf hadoop.tar.gz将/hadoop目录先打包，同时用bzip2压缩，并保存到/tmp目录下tar -jcvf /tmp/hadoop.tar.bz2 hadoop将/tmp/hadoop.tar.bz2解压到/usr目录下面tar -jxvf hadoop.tar.bz2 -C /usr/

系统命令

1.查看主机名hostname2.修改主机名(重启后无效)hostname hadoop3.修改主机名(重启后永久生效)vi /ect/sysconfig/network4.修改IP(重启后无效)ifconfig eth0 192.168.12.225.修改IP(重启后永久生效)vi /etc/sysconfig/network-scripts/ifcfg-eth06.查看系统信息uname -auname -r7.查看ID命令id -uid -g8.日期datedate +%Y-%m-%ddate +%Tdate +%Y-%m-%d" "%T9.日历cal 201210.查看文件信息file filename11.挂载硬盘mountumount加载windows共享mount -t cifs //192.168.1.100/tools /mnt12.查看文件大小du -hdu -ah13.查看分区df -h14.sshssh hadoop@192.168.1.115.关机shutdown -h now /init 0shutdown -r now /reboot

用户和组

添加一个tom用户，设置它属于users组，并添加注释信息分步完成：useradd tom   usermod -g users tom      usermod -c "hr tom" tom一步完成：useradd -g users -c "hr tom" tom设置tom用户的密码passwd tom修改tom用户的登陆名为tomcatusermod -l tomcat tom将tomcat添加到sys和root组中usermod -G sys,root tomcat查看tomcat的组信息groups tomcat添加一个jerry用户并设置密码useradd jerrypasswd jerry添加一个交america的组groupadd america将jerry添加到america组中usermod -g america jerry将tomcat用户从root组和sys组删除gpasswd -d tomcat rootgpasswd -d tomcat sys将america组名修改为amgroupmod -n am america

权限

创建a.txt和b.txt文件，将他们设为其拥有者和所在组可写入，但其他以外的人则不可写入:chmod ug+w,o-w a.txt b.txt创建c.txt文件所有人都可以写和执行chmod a=wx c.txt 或chmod 666 c.txt将/hadoop目录下的所有文件与子目录皆设为任何人可读取chmod -R a+r /hadoop将/hadoop目录下的所有文件与子目录的拥有者设为root，用户拥有组为userschown -R root:users /hadoop将当前目录下的所有文件与子目录的用户皆设为hadoop，组设为userschown -R hadoop:users *

帮助文档

1.内部命令：echo查看内部命令帮助：help echo 或者 man echo2.外部命令：ls查看外部命令帮助：ls --help 或者 man ls 或者 info ls3.man文档的类型(1~9)man 7 manman 5 passwd4.快捷键：ctrl + c：停止进程ctrl + l：清屏ctrl + r：搜索历史命令ctrl + q：退出5.善于用tab键

文件相关命令

1.进入到用户根目录cd ~ 或者 cdcd ~hadoop回到原来路径cd -2.查看文件详情stat a.txt3.移动mv a.txt /ect/改名mv b.txt a.txt移动并改名mv a.txt ../b.txt4拷贝并改名cp a.txt /etc/b.txt5.vi撤销修改ctrl + u (undo)恢复ctrl + r (redo)6.名令设置别名(重启后无效)alias ll="ls -l"取消unalias ll7.如果想让别名重启后仍然有效需要修改vi ~/.bashrc8.添加用户useradd hadooppasswd hadoop9创建多个文件touch a.txt b.txttouch /home/{a.txt,b.txt}10.将一个文件的内容复制到里另一个文件中cat a.txt > b.txt追加内容cat a.txt >> b.txt 11.将a.txt 与b.txt设为其拥有者和其所属同一个组者可写入，但其他以外的人则不可写入:chmod ug+w,o-w a.txt b.txtchmod a=wx c.txt12.将当前目录下的所有文件与子目录皆设为任何人可读取:chmod -R a+r *13.将a.txt的用户拥有者设为users,组的拥有者设为jessie:chown users:jessie a.txt14.将当前目录下的所有文件与子目录的用户的使用者为lamport,组拥有者皆设为users，chown -R lamport:users *15.将所有的java语言程式拷贝至finished子目录中:cp *.java finished16.将目前目录及其子目录下所有扩展名是java的文件列出来。find -name "*.java"查找当前目录下扩展名是java 的文件find -name *.java17.删除当前目录下扩展名是java的文件rm -f *.java

VIM

ia/Ao/Or + ?替换0:文件当前行的开头$:文件当前行的末尾G:文件的最后一行开头1 + G到第一行 9 + G到第九行 = :9dd:删除一行3dd：删除3行yy:复制一行3yy:复制3行p:粘贴u:undoctrl + r:redo"a剪切板a"b剪切板b"ap粘贴剪切板a的内容每次进入vi就有行号vi ~/.vimrcset nu:w a.txt另存为:w >> a.txt内容追加到a.txt:e!恢复到最初状态:1,$s/hadoop/root/g 将第一行到追后一行的hadoop替换为root:1,$s/hadoop/root/c 将第一行到追后一行的hadoop替换为root(有提示)

查找

1.查找可执行的命令：which ls2.查找可执行的命令和帮助的位置：whereis ls3.查找文件(需要更新库:updatedb)locate hadoop.txt4.从某个文件夹开始查找find / -name "hadooop*"find / -name "hadooop*" -ls5.查找并删除find / -name "hadooop*" -ok rm {} \;find / -name "hadooop*" -exec rm {} \;6.查找用户为hadoop的文件find /usr -user hadoop -ls7.查找用户为hadoop并且(-a)拥有组为root的文件find /usr -user hadoop -a -group root -ls8.查找用户为hadoop或者(-o)拥有组为root并且是文件夹类型的文件find /usr -user hadoop -o -group root -a -type d9.查找权限为777的文件find / -perm -777 -type d -ls10.显示命令历史history11.grepgrep hadoop /etc/password

打包与压缩

1.gzip压缩gzip a.txt2.解压gunzip a.txt.gzgzip -d a.txt.gz3.bzip2压缩bzip2 a4.解压bunzip2 a.bz2bzip2 -d a.bz25.将当前目录的文件打包tar -cvf bak.tar .将/etc/password追加文件到bak.tar中(r)tar -rvf bak.tar /etc/password6.解压tar -xvf bak.tar7.打包并压缩gziptar -zcvf a.tar.gz8.解压缩tar -zxvf a.tar.gz解压到/usr/下tar -zxvf a.tar.gz -C /usr9.查看压缩包内容tar -ztvf a.tar.gzzip/unzip10.打包并压缩成bz2tar -jcvf a.tar.bz211.解压bz2tar -jxvf a.tar.bz2

正则表达式

规则：.  : 任意一个字符a* : 任意多个a(零个或多个a)a? : 零个或一个aa+ : 一个或多个a.* : 任意多个任意字符\. : 转义.\ ：以h开头，p结尾的一个单词o\{2\} : o重复两次grep '^i.\{18\}n$' /usr/share/dict/words查找不是以#开头的行grep -v '^#' a.txt | grep -v '^$' 以h或r开头的grep '^[hr]' /etc/passwd不是以h和r开头的grep '^[^hr]' /etc/passwd不是以h到r开头的grep '^[^h-r]' /etc/passwd

输入输出重定向

1.新建一个文件touch a.txt> b.txt2.错误重定向:2>find /etc -name zhaoxing.txt 2> error.txt3.将正确或错误的信息都输入到log.txt中find /etc -name passwd > /tmp/log.txt 2>&1 find /etc -name passwd &> /tmp/log.txt4.追加>>5.将小写转为大写（输入重定向）tr "a-z" "A-Z"  log.txt < ccc> ddd> EXI7.查看/etc下的文件有多少个？ls -l /etc/ | grep '^d' | wc -l8.查看/etc下的文件有多少个，并将文件详情输入到result.txt中ls -l /etc/ | grep '^d' | tee result.txt | wc -l

进程控制

1.查看用户最近登录情况lastlastlog2.查看硬盘使用情况df3.查看文件大小du4.查看内存使用情况free5.查看文件系统/proc6.查看日志ls /var/log/7.查看系统报错日志tail /var/log/messages8.查看进程top9.结束进程kill 1234kill -9 4333

其他命令

远程文件复制：scp

scp 命令用于 Linux 之间复制文件和目录，scp是 secure copy 的缩写是linux系统下基于ssh登陆进行安全的远程文件拷贝命令。

scp 是加密的，rcp 是不加密的，scp 是 rcp 的加强版。

使用scp命令要确保使用的用户具有可读取远程服务器相应文件的权限，否则scp命令是无法起作用的。

从本地复制到远程命令格式：

复制文件scp local_file remote_username@remote_ip:remote_folder 或者 scp local_file remote_username@remote_ip:remote_file 或者 scp local_file remote_ip:remote_folder 或者 scp local_file remote_ip:remote_file复制文件夹scp -r local_folder remote_username@remote_ip:remote_folder 或者 scp -r local_folder remote_ip:remote_folder 

实例：

scp /home/space/music/1.mp3 root@xiaoxiaoming.xyz:/home/root/others/music scp /home/space/music/1.mp3 root@xiaoxiaoming.xyz:/home/root/others/music/001.mp3 scp /home/space/music/1.mp3 xiaoxiaoming.xyz:/home/root/others/music scp /home/space/music/1.mp3 xiaoxiaoming.xyz:/home/root/others/music/001.mp3scp -r /home/space/music/ root@xiaoxiaoming.xyz:/home/root/others/ scp -r /home/space/music/ xiaoxiaoming.xyz:/home/root/others/ 

从远程复制到本地：

scp root@xiaoxiaoming.xyz:/home/root/others/music /home/space/music/1.mp3 scp -r xiaoxiaoming.xyz:/home/root/others/ /home/space/music/

-P 参数来设置命令的端口号：

#scp 命令使用端口号 4588scp -P 4588 remote@xiaoxiaoming.xyz:/usr/local/sin.sh /home/administrator

locate查找

locate命令会去保存文档和目录名称的数据库内，查找文件或目录。

一般情况我们只需要输入locate your_file_name 即可查找指定文件。

参数：

• -d或–database= 配置locate指令使用的数据库。locate指令预设的数据库位于/var/lib/mlocate目录里，文档名为mlocate.db。

查找passwd文件，输入以下命令：

locate passwd

locate与find的区别: find 是去硬盘找，locate 只在/var/lib/slocate资料库中找。

locate的速度比find快，它并不是真的查找，而是查数据库，一般文件数据库在/var/lib/mlocate/mlocate.db中，所以locate的查找并不是实时的，而是以数据库的更新为准，一般是系统自己维护，也可以手工升级数据库 ，命令为：

updatedb

which命令

which查找$PATH中设置命令及安装文件目录所在位置

python@ubuntu:/var/lib/mlocate$ which locate/usr/bin/locate

echo

常见用法：

python@ubuntu:~$ echo -e "hello\t\t world！"  解析转义字符hello     world！python@ubuntu:~$ echo -E "hello\t\t world！"  不解析转义字符hello\t\t world！python@ubuntu:~$ echo $a  输出环境变量b

设置或显示环境变量：export

在 shell 中执行程序时，shell 会提供一组环境变量。export 可新增，修改或删除环境变量，供后续执行的程序使用。export 的效力仅限于该次登陆操作。

export [-fnp][变量名称]=[变量设置值]

参数说明：

• -f 　代表[变量名称]中为函数名称。
• -n 　删除指定的变量。变量实际上并未删除，只是不会输出到后续指令的执行环境中。
• -p 　列出所有的shell赋予程序的环境变量。

# export MYENV=7 //定义环境变量并赋值# export -p //列出当前的环境变量

修改主机名&ip地址

显示主机名：hostname

临时修改：hostname xxx

永久修改

对于Ubuntu 系统

vim /etc/hostname

对于centos系统

vim /etc/sysconfig/network

在此配置文件中添加一条HOSTNAME=node1

针对centos7系统，可以使用如下命令

hostnamectl set-hostname xxx

一般需要重开shell甚至重启操作系统才能生效。

修改IP地址

ifconfig eth0 192.168.12.22(重启后无效)

vim /etc/sysconfig/network-scripts/ifcfg-eth0

mount挂载

mount 挂载外部存储设备到文件系统中

mkdir /mnt/cdrom 创建一个目录，用来挂载mount -t iso9660 -o ro /dev/cdrom /mnt/cdrom/     

将设备/dev/cdrom挂载到 挂载点 ： /mnt/cdrom中

umount /mnt/cdrom

ssh免密登陆

假如 A 要登陆 B
在A上操作：
首先生成密钥对

ssh-keygen (提示时，直接回车即可)

再将A自己的公钥拷贝并追加到B的授权列表文件authorized_keys中

ssh-copy-id B

批量添加用户

与用户账号有关的系统文件

完成用户管理的工作本质都是对有关的系统文件进行修改，这些系统文件包括/etc/passwd, /etc/shadow, /etc/group等。

/etc/passwd记录用户的基本属性

它的内容类似下面的例子：

＃ cat /etc/passwdroot:x:0:0:Superuser:/:daemon:x:1:1:System daemons:/etc:bin:x:2:2:Owner of system commands:/bin:sys:x:3:3:Owner of system files:/usr/sys:adm:x:4:4:System accounting:/usr/adm:uucp:x:5:5:UUCP administrator:/usr/lib/uucp:auth:x:7:21:Authentication administrator:/tcb/files/auth:cron:x:9:16:Cron daemon:/usr/spool/cron:listen:x:37:4:Network daemon:/usr/net/nls:lp:x:71:18:Printer administrator:/usr/spool/lp:sam:x:200:50:Sam san:/home/sam:/bin/sh

/etc/passwd中一行记录对应着一个用户，每行记录又被冒号(:)分隔为7个字段，其格式和具体含义如下：

用户名:口令:用户标识号:组标识号:注释性描述:主目录:登录Shell

用户名：

通常长度不超过8个字符，由大小写字母和/或数字组成，不能有冒号(😃。登录名中不能有冒号(😃，因为冒号在这里是分隔符。

为了兼容起见，登录名中最好不要包含点字符(.)，并且不使用连字符(-)和加号(+)打头。

口令：

本身存放用户口令的加密串，但现在许多Linux 系统都使用了shadow技术，把真正的加密后的用户口令字存放到/etc/shadow文件中，而/etc/passwd文件的口令字段中只存放一个特殊的字符，例如“x”或者“*”。

用户标识号：

是一个整数，系统内部用它来标识用户。一般情况下它与用户名是一一对应的，如果几个用户名对应的用户标识号是一样的，系统内部将把它们视为同一个用户，但是它们可以有不同的口令、不同的主目录以及不同的登录Shell等。

通常用户标识号的取值范围是0～65 535。0是超级用户root的标识号，1～99由系统保留，作为管理账号，普通用户的标识号从100开始。

组标识号：

记录用户所属的用户组，对应着/etc/group文件中的一条记录。

注释性描述：

一段任意编写的注释，创建账户时可以通过useradd -c 用户名的-c参数指定。

主目录：

用户的起始工作目录，用户在登录到系统之后所处的目录。

登录Shell：

用户登录后，要启动一个进程，负责将用户的操作传给内核，这个进程是用户登录到系统后运行的命令解释器或某个特定的程序，即Shell。

Shell是用户与Linux系统之间的接口。Linux的Shell有许多种，每种都有不同的特点。常用的有sh(Bourne Shell), csh(C Shell), ksh(Korn Shell), tcsh(TENEX/TOPS-20 type C Shell), bash(Bourne Again Shell)等。

可以通过usermod的-s参数为用户指定某个Shell。如果useradd不通过-s参数指定shell，那么系统使用bash为默认的登录Shell，即这个字段的值为/bin/bash。

为用户的登录指定特定的Shell可以限制用户只能运行指定的应用程序，在该应用程序运行结束后，用户就自动退出了系统。不过大部分Linux系统要求只有在系统中登记过的shell才能出现在这个字段中。

伪用户（pseudo users）

这些用户的登陆shell为/usr/sbin/nologin，即不能登录。它们的存在主要是方便系统管理，满足相应的系统进程对文件属主的要求。

常见的伪用户如下所示：

bin 拥有可执行的用户命令文件 sys 拥有系统文件 adm 拥有帐户文件 uucp UUCP使用 lp lp或lpd子系统使用 nobody NFS使用

还有许多标准的伪用户，例如：audit, cron, mail, usenet等，它们也都各自为相关的进程和文件所需要。

/etc/shadow

对安全性要求较高的Linux系统都把/etc/passwd文件中的口令字段保存在/etc/shadow文件中，超级用户才拥有该文件读权限。

/etc/shadow中的记录行与/etc/passwd中的一一对应，它由pwconv命令根据/etc/passwd中的数据自动产生

字段是：

登录名:加密口令:最后一次修改时间:最小时间间隔:最大时间间隔:警告时间:不活动时间:失效时间:标志

1. "登录名"是与/etc/passwd文件中的登录名相一致的用户账号
2. "口令"字段存放的是加密后的用户口令字，长度为13个字符。如果为空，则对应用户没有口令，登录时不需要口令；如果含有不属于集合 { ./0-9A-Za-z }中的字符，则对应的用户不能登录。
3. "最后一次修改时间"表示的是从某个时刻起，到用户最后一次修改口令时的天数。大部分linux系统的时间起点是1970年1月1日。
4. "最小时间间隔"指的是两次修改口令之间所需的最小天数。
5. "最大时间间隔"指的是口令保持有效的最大天数。
6. "警告时间"字段表示的是从系统开始警告用户到用户密码正式失效之间的天数。
7. "不活动时间"表示的是用户没有登录活动但账号仍能保持有效的最大天数。
8. "失效时间"字段给出的是一个绝对的天数，如果使用了这个字段，那么就给出相应账号的生存期。期满后，该账号就不再是一个合法的账号，也就不能再用来登录了。

下面是/etc/shadow的一个例子：

＃ cat /etc/shadowroot:Dnakfw28zf38w:8764:0:168:7:::daemon:*::0:0::::bin:*::0:0::::sys:*::0:0::::adm:*::0:0::::uucp:*::0:0::::nuucp:*::0:0::::auth:*::0:0::::cron:*::0:0::::listen:*::0:0::::lp:*::0:0::::sam:EkdiSECLWPdSa:9740:0:0::::

/etc/group记录用户组信息

每个用户都属于某个用户组；一个组中可以有多个用户，一个用户也可以属于不同的组。

当一个用户同时是多个组中的成员时，在/etc/passwd文件中记录的是用户所属的主组，也就是登录时所属的默认组，而其他组称为附加组。

用户要访问属于附加组的文件时，必须首先使用newgrp命令使自己成为所要访问的组中的成员。

用户组的所有信息都存放在/etc/group文件中，字段有：

组名:口令:组标识号:组内用户列表

1. "组名"是用户组的名称，由字母或数字构成。与/etc/passwd中的登录名一样，组名不应重复。
2. "口令"字段存放的是用户组加密后的口令字。一般Linux 系统的用户组都没有口令，即这个字段一般为空，或者是*。
3. "组标识号"与用户标识号类似，也是一个整数，被系统内部用来标识组。
4. "组内用户列表"是属于这个组的所有用户的列表，不同用户之间用逗号(,)分隔。这个用户组可能是用户的主组，也可能是附加组。

/etc/group文件的一个例子如下：

root::0:rootbin::2:root,binsys::3:root,uucpadm::4:root,admdaemon::5:root,daemonlp::7:root,lpusers::20:root,sam

实操

先编辑一个文本用户文件

每一列按照/etc/passwd密码文件的格式书写，要注意每个用户的用户名、UID、宿主目录都不可以相同，其中密码栏可以留做空白或输入x号。一个范例文件user.txt内容如下：

user001::601:100:user:/home/user001:/bin/bashuser002::602:100:user:/home/user002:/bin/bashuser003::603:100:user:/home/user003:/bin/bashuser004::604:100:user:/home/user004:/bin/bashuser005::605:100:user:/home/user005:/bin/bashuser006::606:100:user:/home/user006:/bin/bash

执行/usr/sbin/newusers命令

需要root权限：

# newusers < user.txt

可以执行命令 vipw 或 vi /etc/passwd 检查 /etc/passwd 文件是否已经出现这些用户的数据，并且用户的宿主目录是否已经创建。

取消 shadow password 功能

将 /etc/shadow 产生的 shadow 密码解码，然后回写到 /etc/passwd 中，并将/etc/shadow的shadow密码栏删掉。这是为了方便下一步的密码转换工作，即先取消 shadow password 功能。

执行/usr/sbin/pwunconv命令:

# pwunconv

编辑每个用户的密码对照文件

格式为：

用户名:密码

实例文件 passwd.txt 内容如下：

user001:123456user002:123456user003:123456user004:123456user005:123456user006:123456

执行 /usr/sbin/chpasswd命令

需要root权限：

创建用户密码，chpasswd 会将经过 /usr/bin/passwd 命令编码过的密码写入 /etc/passwd 的密码栏。

# chpasswd < passwd.txt

将密码编码为 shadow password

执行命令 /usr/sbin/pwconv 将密码编码为 shadow password，并将结果写入 /etc/shadow。

# pwconv

这样就完成了大量用户的创建了，之后您可以到/home下检查这些用户宿主目录的权限设置是否都正确，并登录验证用户密码是否正确。

完整步骤

先准备好用户文件user和密码文件passwd

然后运行：

newusers < userpwunconvchpasswd < passwdpwconv

crontab的使用

crontab命令是cron table的简写，它是cron的配置文件，也可以叫它作业列表。

相关配置文件如下：

• /var/spool/cron/ 目录下存放的是每个用户包括root的crontab任务，每个任务以创建者的名字命名
• /etc/crontab 这个文件负责调度各种管理和维护任务。
• /etc/cron.d/ 这个目录用来存放任何要执行的crontab文件或脚本。
• 还可以把脚本放在/etc/cron.hourly、/etc/cron.daily、/etc/cron.weekly、/etc/cron.monthly目录中，让它每小时/天/星期、月执行一次。

命令格式：

crontab [ -u user ] { -l | -r | -e }//省略用户表表示操作当前用户的crontab    -e      (编辑工作表)    -l      (列出工作表里的命令)    -r      (删除工作表)

crontab -e进入当前用户的工作表编辑，是常见的vim界面。每行是一条命令。

crontab的命令构成为 时间+动作，其时间有分、时、日、月、周五种，操作符有

• ***** 取值范围内的所有数字
• / 每过多少个数字
• - 从X到Z
• **，**散列数字

基本格式 :

f1f2f3f4f5command分时日月周命令 第1列表示分钟0～59 每分钟用*或者 */1表示 第2列表示小时0～23（0表示0点） 第3列表示日期1～31 第4列表示月份1～12 第5列标识号星期0～6（0表示星期天） 第6列要运行的命令

• 其中 f1 是表示分钟，f2 表示小时，f3 表示一个月份中的第几日，f4 表示月份，f5 表示一个星期中的第几天。command表示要执行的命令。
• 当 f1 为 * 时表示每分钟都要执行 program，f2 为 * 时表示每小时都要执行程序，以此类推
• 当 f1 为 a-b 时表示从第 a 分钟到第 b 分钟这段时间内要执行，f2 为 a-b 时表示从第 a 到第 b 小时都要执行，以此类推
• 当 f1 为 */n 时表示每 n 分钟个时间间隔执行一次，f2 为 */n 表示每 n 小时个时间间隔执行一次，以此类推
• 当 f1 为 a, b, c,… 时表示第 a, b, c,… 分钟要执行，f2 为 a, b, c,… 时表示第 a, b, c…个小时要执行，以此类推

在 12 月内, 每天的早上 6 点到 12 点，每隔 3 个小时 0 分钟执行一次 /usr/bin/backup

0 6-12/3 * 12 * /usr/bin/backup

周一到周五每天下午 5:00 寄一封信给 alex@domain.name

0 17 * * 1-5 mail -s "hi" alex@domain.name < /tmp/maildata

每月每天的午夜 0 点 20 分, 2 点 20 分, 4 点 20 分…执行 echo “haha”

20 0-23/2 * * * echo "haha"

示例1：

45 4 1,10,22 * * /etc/init.d/smb restart 每月1、10、22日的4 : 45重启smb10 1 * * 6,0 /etc/init.d/smb restart  每周六、周日的1 : 10重启smb0,30 18-23 * * * /etc/init.d/smb restart  每天18 : 00至23 : 00之间每隔30分钟重启smb0 23 * * 6 /etc/init.d/smb restart  每星期六的晚上11 : 00 pm重启smb* */1 * * * /etc/init.d/smb restart  每一小时重启smb* 23-7/1 * * * /etc/init.d/smb restart  晚上11点到早上7点之间，每隔一小时重启smb

示例2：

0 */2 * * * /sbin/service httpd restart  每两个小时重启一次apache 50 7 * * * /sbin/service sshd start  每天7：50开启ssh服务 50 22 * * * /sbin/service sshd stop  每天22：50关闭ssh服务 0 0 1,15 * * fsck /home  每月1号和15号检查/home 磁盘 1 * * * * /home/bruce/backup  每小时的第一分执行 /home/bruce/backup这个文件 00 03 * * 1-5 find /home "*.xxx" -mtime +4 -exec rm {} \;  每周一至周五3点钟，在目录/home中，查找文件名为*.xxx的文件，并删除4天前的文件。30 6 */10 * * ls  每月的1、11、21、31日是的6：30执行一次ls命令

环境变量问题：

有时创建了一个crontab，但是这个任务却无法自动执行，而手动执行这个任务却没有问题，这种情况一般是由于在crontab文件中没有配置环境变量引起的。

所以注意如下3点：

1）脚本中涉及文件路径时写全局路径；

2）脚本执行要用到java或其他环境变量时，通过source命令引入环境变量，如：

cat start_cbp.sh#!/bin/shsource /etc/profileexport RUN_CONF=/home/d139/conf/platform/cbp/cbp_jboss.conf/usr/local/jboss-4.0.5/bin/run.sh -c mev &

3）当手动执行脚本OK，但是crontab死活不执行时，可以尝试在crontab中直接引入环境变量解决问题。如：

0 * * * * . /etc/profile;/bin/sh /var/www/java/audit_no_count/bin/restart_audit.sh

特殊权限

linux共12位权限，除了9位基础权限还有3个特殊权限。

三种特殊的权限

SetUID(suid)

命令功能： **临时使用命令的属主权限执行该命令。**即如果文件有suid权限时，那么普通用户去执行该文件时，会以该文件的所属用户的身份去执行。

SetUID（简写suid）：会在属主权限位的执行权限上写个s。 如果该属主权限位上有执行权限，则会在属主权限位的执行权限上写个s（小写）； 如果该属主权限位上没有执行权限，则会在属主权限位的执行权限上写个S（大写）。

suid数字权限是4000,设置方法：

方式1：[root@centos7 ~]# chmod u+s filename方式2：[root@centos7 ~]# chmod 4755 filename

查看passwd命令的权限

`[root@localhost ftl]``# ll /usr/bin/passwd ` `问题： ``passwd``文件的属组是root,表示只有root用户可以访问的文件，为什么普通用户依然可以使用该命令更改自己的密码？``答案：当普通用户[omd]使用``passwd``命令的时候，系统看到``passwd``命令文件的属性有大写s后，表示这个命令的属主权限被omd用户获得,也就是omd用户获得文件``/etc/shadow``的root的rwx权限`

由于passwd具有s权限，普通用户使用该命令的时候，就会以该命令的属主身份root执行该命令，于是能够顺利修改普通用户不具备修改权限的/etc/shadow文件。

希望普通用户user1可以删除某个自己没有权限删除的文件的操作方法：

• sudo给user1授权rm权限
• rm设置suid
• 修改被删除文件上级目录的权限

SetUID（简称suid）总结：

1. 让普通用户对可执行的二进制文件，临时拥有二进制文件的属主权限；
2. 如果设置的二进制文件没有执行权限，那么suid的权限显示就是S（大写字母S）；
3. 特殊权限suid仅对二进制可执行程序有效，其他文件或目录则无效。
4. suid极其危险，如果给vim或者rm命令设置了setUID，那么任何文件都能编辑或者删除了，相当于有root权限了。

setGID（sgid）

**命令功能：**使用sgid可以使得多个用户之间共享一个目录的所有文件变得简单。当某个目录设置了sgid后，在该目录中新建的文件不在是创建该文件的默认所属组。

如果该属组权限位上有执行权限，则会在属组主权限位的执行权限上写个s（小写字母）； 如果该属组权限位上没有执行权限，则会在属组主权限位的执行权限上写个S（大写字母S）。

write命令的权限：

[root@VM_0_9_centos ~]# ll /bin/write -rwxr-sr-x 1 root tty 19544 Aug  9 11:10 /bin/write

sgid数字权限是2000，设置方法：

方式1：[root@VM_0_9_centos ~]# chmod 2755 test/方式2：[root@VM_0_9_centos ~]# chmod g+s test/[root@VM_0_9_centos ~]# ll -d test/drwxr-sr-x 2 root root 4096 Nov 22 21:02 test/

在设置SetGID的文件夹创建文件的属组是父目录的属组：

[root@VM_0_9_centos ~]# cd test/[root@VM_0_9_centos test]# su aaa[aaa@VM_0_9_centos test]$ touch bbb[aaa@VM_0_9_centos test]$ ll-rw-rw-r-- 1 aaa  root 0 Nov 22 21:14 bbb

sticky(sbit)粘滞位

**命令功能：**粘滞位，只对目录有效，对某目录设置粘滞位后，普通用户就算有w权限也只能删除该目录下自己建立的文件，而不能删除其他用户建立的文件。

如果该其他用户权限位上有执行权限，则会在其他用户权限位的执行权限上写个t（小写）； 如果该其它用户权限位上没有执行权限，则会在其他用户权限位的执行权限上写个T（大写）。

系统中存在的/tmp目录是经典的粘滞位目录，谁都有写权限，因此安全成问题，常常是木马第一手跳板。

[aaa@VM_0_9_centos ~]$ ll -d /tmp/ drwxrwxrwt. 9 root root 4096 Nov 22 21:15 /tmp/

sbit数字权限是1000，设置方法：

方法1：[root@VM_0_9_centos ~]# chmod 1755 test/方法2：[root@VM_0_9_centos ~]# chmod o+t test/ 查看权限：[root@VM_0_9_centos ~]# ll -d test/    drwxr-xr-t 2 root root 4096 Nov 22 21:15 test/

chattr权限

chattr概述：凌驾于r、w、x、suid、sgid之上的权限。

lsattr：查看特殊权限

[root@VM_0_9_centos ~]# lsattr /etc/passwd-------------e-- /etc/passwd

chattr：设置特殊权限

防止系统中某个关键文件被修改：

[root@VM_0_9_centos ~]# chattr +i /etc/fstab[root@VM_0_9_centos ~]# lsattr /etc/fstab   ----i--------e-- /etc/fstab

让某个文件只能往里面追加内容，不能删除，一些日志文件适用于这种操作：

[root@VM_0_9_centos ~]# chattr +a user_act.log[root@VM_0_9_centos ~]# lsattr user_act.log -----a-------e-- user_act.log

掩码umask

umask的作用

umask值用于设置用户在创建文件时的默认权限，当我们在系统中创建目录或文件时，目录或文件所具有的默认权限就是由umask值决定的。

对于root用户，系统默认的umask值是0022；对于普通用户，系统默认的umask值是0002。执行umask命令可以查看当前用户的umask值。

[root@VM_0_9_centos ~]# umask0022

umask是如何改变新文件的权限

umask值一共有4组数字，其中第1组数字用于定义特殊权限，一般不予考虑，与一般权限有关的是后3组数字。

默认情况下，对于目录，用户所能拥有的最大权限是777；对于文件，用户所能拥有的最大权限是目录的最大权限去掉执行权限，即666。因为x执行权限对于目录是必须的，没有执行权限就无法进入目录，而对于文件则不必默认赋予x执行权限。

对于root用户，他的umask值是022。当root用户创建目录时，默认的权限就是用最大权限777去掉相应位置的umask值权限，即对于所有者不必去掉任何权限，对于所属组要去掉w权限，对于其他用户也要去掉w权限，所以目录的默认权限就是755；当root用户创建文件时，默认的权限则是用最大权限666去掉相应位置的umask值，即文件的默认权限是644。

通过umask命令可以修改umask值，比如将umask值设为0077。

[root@VM_0_9_centos ~]# umask 0077[root@VM_0_9_centos ~]# umask0077

永久修改umask

umask命令只能临时修改umask值，系统重启之后umask将还原成默认值。如果要永久修改umask值，可修改/etc/bashrc或/etc/profile文件。

例如要将默认umask值设置为027，那么可以在文件中增加一行umask 027。

linux软件安装

Ubuntu软件安装与卸载

更新Ubuntu软件下载地址

开源软件镜像站 ：https://mirrors.tuna.tsinghua.edu.cn/help/ubuntu/

Ubuntu 的软件源配置文件是 /etc/apt/sources.list。将系统自带的该文件做个备份，将该文件替换为下面内容，即可使用 TUNA 的软件源镜像。

ubuntu版本: 16.04 LTS

# 默认注释了源码镜像以提高 apt update 速度，如有需要可自行取消注释deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial main restricted universe multiverse# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial main restricted universe multiversedeb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-updates main restricted universe multiverse# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-updates main restricted universe multiversedeb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-backports main restricted universe multiverse# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-backports main restricted universe multiversedeb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-security main restricted universe multiverse# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-security main restricted universe multiverse# 预发布软件源，不建议启用# deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-proposed main restricted universe multiverse# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-proposed main restricted universe multiverse

然后

sudo cp /etc/apt/sources.list /etc/apt/sources.list.backup

再sudo vim /etc/apt/sources.list修改为以上内容

Ubuntu软件操作的相关命令

sudo apt-get update  更新源sudo apt-get install package 安装包sudo apt-get remove package 删除包sudo apt-cache search package 搜索软件包sudo apt-cache show package  获取包的相关信息，如说明、大小、版本等sudo apt-get install package --reinstall   重新安装包sudo apt-get -f install   修复安装sudo apt-get remove package --purge 删除包，包括配置文件等sudo apt-get build-dep package 安装相关的编译环境sudo apt-get upgrade 更新已安装的包sudo apt-get dist-upgrade 升级系统sudo apt-cache depends package 了解使用该包依赖那些包sudo apt-cache rdepends package 查看该包被哪些包依赖sudo apt-get source package  下载该包的源代码sudo apt-get clean && sudo apt-get autoclean 清理无用的包sudo apt-get check 检查是否有损坏的依赖

yum安装命令

yum（ Yellow dog Updater, Modified）是一个在Fedora和RedHat以及SUSE中的Shell前端软件包管理器。

基於RPM包管理，能够从指定的服务器自动下载RPM包并且安装，可以自动处理依赖性关系，并且一次安装所有依赖的软体包，无须繁琐地一次次下载、安装。

yum提供了查找、安装、删除某一个、一组甚至全部软件包的命令，而且命令简洁而又好记。

更新国内yum源

网易（163）yum源是国内最好的yum源之一 ，无论是速度还是软件版本，都非常的不错。

将yum源设置为163 yum，可以提升软件包安装和更新的速度，同时避免一些常见软件版本无法找到。

首先备份/etc/yum.repos.d/CentOS-Base.repo

mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup

下载对应版本 repo 文件, 放入 /etc/yum.repos.d/

• CentOS5 ：http://mirrors.163.com/.help/CentOS5-Base-163.repo
• CentOS6 ：http://mirrors.163.com/.help/CentOS6-Base-163.repo
• CentOS7 ：http://mirrors.163.com/.help/CentOS7-Base-163.repo

wget http://mirrors.163.com/.help/CentOS7-Base-163.repomv CentOS7-Base-163.repo /etc/yum.repos.d/CentOS-Base.repo

运行以下命令生成缓存

yum clean allyum makecache

除了网易之外，国内还有其他不错的 yum 源，比如中科大和搜狐。

中科大的 yum 源，安装方法查看：https://lug.ustc.edu.cn/wiki/mirrors/help/centos

sohu 的 yum 源安装方法查看: http://mirrors.sohu.com/help/centos.html

yum常用命令

yum 语法：

yum [options] [command] [package ...]

选项：

• **options：**可选，选项包括-h（帮助），-y（当安装过程提示选择全部为"yes"），-q（不显示安装的过程）等等。
• **command：**要进行的操作。
• **package：**操作的对象。

实例：

• 列出所有可更新的软件清单命令：yum check-update
• 更新所有软件命令：yum update
• 仅安装指定的软件命令：yum install
• 仅更新指定的软件命令：yum update
• 显示包信息：yum info
• 列出所有可安裝的软件清单命令：yum list
• 删除软件包命令：yum remove
• 查找软件包 命令：yum search
• 清除缓存命令:
  • yum clean packages: 清除缓存目录下的软件包
  • yum clean headers: 清除缓存目录下的 headers
  • yum clean oldheaders: 清除缓存目录下旧的 headers
  • yum clean, yum clean all (= yum clean packages; yum clean oldheaders) :清除缓存目录下的软件包及旧的headers

yum在线安装MySQL5.7

Step1: 检测系统是否自带安装mysql

yum list installed | grep mysql

Step2: 删除系统自带的mysql及其依赖

yum -y remove mysql-libs.x86_64

Step3: 给CentOS添加rpm源，并且选择较新的源

wget dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpmyum localinstall mysql-community-release-el7-5.noarch.rpmyum repolist all | grep mysqlyum-config-manager --disable mysql55-communityyum-config-manager --disable mysql56-communityyum-config-manager --enable mysql57-community-dmryum repolist enabled | grep mysql

Step4:安装mysql 服务器

yum install mysql-community-server

Step5: 启动mysql

service mysqld start

grep “password” /var/log/mysqld.log(查看临时密码)

SET PASSWORD = PASSWORD('your new password');ALTER USER 'root'@'localhost' PASSWORD EXPIRE NEVER;flush privileges;

默认的要求必须的设置格式：
包含数字、小写或大写字母以及特殊字符

默认的要求必须的设置格式：
包含数字、小写或大写字母以及特殊字符

如果不想复杂，可以使用以下方式

set global validate_password_policy=0;set global validate_password_length=1;

Step6: 查看mysql是否自启动,并且设置开启自启动

# chkconfig --list | grep mysqld# chkconfig mysqld on

Step7: mysql安全设置

mysql_secure_installation

rpm

RPM是Red Hat公司随Redhat Linux推出了一个软件包管理器，通过它能够更加轻松容易地实现软件的安装。

常见用法：

• rpm -ivh 安装软件
• rpm -e 卸载安装
• rpm -qi 显示软件安装信息
• rpm -qa | grep xxx 查询软件是否安装（包括相关依赖）
• rpm -Uvh 升级一个rpm

具体参数详解：
-i, --install 安装包
-v, --verbose 列出更多详细信息，安装进度
-h, --hash 安装时列出hash标记 (与 -v连用)
-e, --erase 卸载安装包
-U, --upgrade=+ 升级包
–replacepkge 无论软件包是否已被安装，都强行安装软件包
–test 安装测试，并不实际安装
–nodeps 忽略软件包的依赖关系强行安装
–force 忽略软件包及文件的冲突
-q,–query:
-a, --all 查询/校验所有的安装包
-p, --package 查询/校验一个安装文件
-l, --list 列出安装文件
-d, --docfiles 列出所有文档文件
-f, --file 查询/校验安装包中所包含的文件

安装软件：

# rpm -hvi dejagnu-1.4.2-10.noarch.rpm 警告：dejagnu-1.4.2-10.noarch.rpm: V3 DSA 签名：NOKEY, key ID db42a60e准备...    ########################################### [100%]

显示软件安装信息：

# rpm -qi dejagnu-1.4.2-10.noarch.rpm【第1次更新 教程、类似命令关联】

Linux的基本配置

1.修改主机名

vi /etc/sysconfig/networkNETWORKING=yesHOSTNAME=hadoop1

2.修改ip地址

vi /etc/sysconfig/network-scripts/ifcfg-eth0DEVICE=eth0TYPE=EthernetONBOOT=yesBOOTPROTO=staticIPADDR=192.168.100.101NETMASK=255.255.255.0service network restart

3.修改ip地址和主机名的映射关系

vi /etc/hosts127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4::1  localhost localhost.localdomain localhost6 localhost6.localdomain6192.168.100.101 hadoop1

4.关闭iptables并设置其开机启动/不启动

service iptables stopchkconfig iptables onchkconfig iptables off

安装JDK

1.上传jdk-7u45-linux-x64.tar.gz到Linux上2.解压jdk到/usr/local目录tar -zxvf jdk-7u45-linux-x64.tar.gz -C /usr/local/3.设置环境变量，在/etc/profile文件最后追加相关内容(技巧r:!pwd)vi /etc/profileexport JAVA_HOME=/usr/local/jdk1.7.0_45export PATH=$PATH:$JAVA_HOME/bin4.刷新环境变量source /etc/profile5.测试java命令是否可用java -version

制作本地YUM源

上传CentOS-6.7-x86_64-bin-DVD1.iso到服务器

将CentOS-6.7-x86_64-bin-DVD1.iso镜像挂载到某个目录:

mkdir /var/isomount -o loop CentOS-6.7-x86_64-bin-DVD1.iso /var/iso

安装并启动Apache服务器：

yum install -y httpdservice httpd start

使用浏览器访问http://192.168.100.101（如果访问不通，检查防火墙是否开启了80端口或关闭防火墙）

将YUM源配置到httpd中：

cp -r /var/iso/ /var/www/html/CentOS-6.7umount /var/iso

在浏览器中访问http://192.168.100.101/CentOS-6.7/

配置使用YUM源：

备份原有的YUM源的配置文件

cd /etc/yum.repos.d/rename .repo .repo.bak *

修改YUM源配置文件

vi CentOS-Local.repo[base]name=CentOS-Localbaseurl=http://192.168.100.101/CentOS-6.7gpgcheck=1enabled=1   #很重要，1才启用gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-6

重建yum缓存

#清除yum缓存文件，重新新建yum clean all && yum makecache#列出可用的YUM源yum repolist

rpm包生成yum源目录

如果已经下载好了rpm包，可以自行制作一个yum源（yum仓库）。将下载的rpm包上传到centos服务器上（比如/data/rpm目录下），然后进入存放rpm包的目录，执行以下命令：

# cd /data/rpm# createrepo .

这样，rpm包存放的目录就可以作为yum源目录使用。
如果提示找不到createrepo命令，可以使用yum install createrepo安装该程序。

Shell编程

这里说的Shell 脚本（shell script），是在Linux 环境下运行的脚本程序

Shell 编程跟 JavaScript、php 编程一样，只要有一个能编写代码的文本编辑器和一个能解释执行的脚本解释器就可以了。

Linux 的 Shell 种类众多，常见的有：

• Bourne Shell（/usr/bin/sh或/bin/sh）
• Bourne Again Shell（/bin/bash）
• C Shell（/usr/bin/csh）
• K Shell（/usr/bin/ksh）
• Shell for Root（/sbin/sh）
• ……

Bash是大多数Linux 系统默认的 Shell，本文也仅关注Bash Shell。

在一般情况下，并不区分 Bourne Shell 和 Bourne Again Shell，所以，像 #!/bin/sh，它同样也可以改为 #!/bin/bash。

#! 告诉系统其后路径所指定的程序即是解释此脚本文件的 Shell 程序。

入门

运行Shell脚本

编写shell脚本：

vi test.sh#!/bin/bashecho "Hello World !"

#! 是一个约定的标记，它告诉系统这个脚本需要什么解释器来执行，即使用哪一种 Shell。

echo 命令用于向窗口输出文本。

运行 Shell 脚本有两种方法：

1、作为可执行程序

chmod +x ./test.sh  #使脚本具有执行权限./test.sh  #执行脚本

默认情况下，一定要写成 ./test.sh，而不是 test.sh，运行其它二进制的程序也一样。

除非将当前目录.加入到PATH环境变量中，配置方法：

sudo vi /etc/profile加入一行export PATH=$PATH:.保存之后，执行source /etc/profile

2、作为解释器参数

直接运行解释器，其参数就是 shell 脚本的文件名：

/bin/sh test.sh

这种方式运行的脚本，不需要在第一行指定解释器信息，写了也没用。

编写一个快捷创建shell脚本的命令

#!/bin/bashif test -z $1;then  newfile="./script_`date +%m%d_%s`"else  newfile=$1fiecho $newfileif  ! grep "^#!" $newfile &>/dev/null; thencat >> $newfile << EOF#!/bin/bash# Author:# Date & Time: `date +"%F %T"`#Description:EOFfivim +5 $newfilechmod +x $newfile

将以上内容编写好之后保存为shell文件，然后执行

chmod u+x shellsudo mv shell /usr/bin/

echo命令

Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式：

echo string

显示普通字符串:

echo "It is a test"

这里的双引号完全可以省略，以下命令与上面实例效果一致：

echo It is a test

显示转义字符:

echo "\"It is a test\""

结果将是:

"It is a test"

同样，双引号也可以省略

read 命令从标准输入中读取一行,并把输入行的每个字段的值指定给 shell 变量

#!/bin/shread name echo "$name It is a test"

以上代码保存为 test.sh，name 接收标准输入的变量，结果将是:

[root@www ~]# sh test.shOK#标准输入OK It is a test #输出

显示换行

echo -e "OK! \n" # -e 开启转义echo "It is a test"

输出结果：

OK!It is a test

显示不换行

#!/bin/shecho -e "OK! \c" # -e 开启转义 \c 不换行echo "It is a test"

输出结果：

OK! It is a test

printf 命令

printf 命令的语法：

printf  format-string  [arguments...]

参数说明：

• format-string: 为格式控制字符串
• arguments: 为参数列表。

实例如下：

#!/bin/bash printf "%-10s %-8s %-4s\n" 姓名 性别 体重kg  printf "%-10s %-8s %-4.2f\n" 郭靖 男 66.1234 printf "%-10s %-8s %-4.2f\n" 杨过 男 48.6543 printf "%-10s %-8s %-4.2f\n" 郭芙 女 47.9876 

执行脚本，输出结果如下所示：

姓名     性别   体重kg郭靖     男      66.12杨过     男      48.65郭芙     女      47.99

• %s %c %d %f都是格式替代符
• %-10s 指一个宽度为10个字符（-表示左对齐，没有则表示右对齐），任何字符都会被显示在10个字符宽的字符内，如果不足则自动以空格填充，超过也会将内容全部显示出来。
• %-4.2f 指格式化为小数，其中.2指保留2位小数。

printf的转义序列：

例子：

Shell 注释

以 # 开头的行就是注释，会被解释器忽略：

#--------------------------------------------# 这是一个注释# author：菜鸟教程# site：www.taobao.com# slogan：学的不仅是技术，更是梦想！#--------------------------------------------##### 用户配置区 开始 ######## 这里可以添加脚本描述信息# ###### 用户配置区 结束  #####

多行注释还可以使用以下格式：

:<<EOF注释内容...注释内容...注释内容...EOF

EOF 也可以使用其他符号:

:<<'注释内容...注释内容...注释内容...':<<!注释内容...注释内容...注释内容...!

Shell变量

定义变量

your_name="taobao.com"

变量名的命名须遵循如下规则：

• 命名只能使用英文字母，数字和下划线，首个字符不能以数字开头。
• 中间不能有空格，可以使用下划线（_）。
• 不能使用标点符号。
• 不能使用bash里的关键字（可用help命令查看保留关键字）。

使用变量

在变量名前面加美元符号即可，如：

your_name="qinjx"echo $your_nameecho ${your_name}

加花括号可以帮助解释器识别变量的边界，比如：

for skill in Ada Coffe Action Java; do    echo "I am good at ${skill}Script"done

只读变量

使用 readonly 命令可以将变量定义为只读变量，只读变量的值不能被改变。

下面的例子尝试更改只读变量，结果报错：

python@ubuntu:~/shell$ myUrl="http://www.google.com"python@ubuntu:~/shell$ readonly myUrlpython@ubuntu:~/shell$ myUrl="http://www.baidu.com"-bash: myUrl: 只读变量

删除变量

使用 unset 命令可以删除变量，但不能删除只读变量：

#!/bin/shmyUrl="http://www.baidu.com"unset myUrlecho $myUrl

变量类型

运行shell时，会同时存在三种变量：

• 1) 局部变量 局部变量在脚本或命令中定义，仅在当前shell实例中有效，其他shell启动的程序不能访问局部变量。
• 2) 环境变量 所有的程序，包括shell启动的程序，都能访问环境变量，有些程序需要环境变量来保证其正常运行。必要的时候shell脚本也可以定义环境变量。
• 3) shell变量 shell变量是由shell程序设置的特殊变量。shell变量中有一部分是环境变量，有一部分是局部变量，这些变量保证了shell的正常运行

Shell 函数

shell中函数的定义格式如下：

[ function ] funname [()]{    action;    [return int;]}

说明：

• 1、可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。
• 2、参数返回，可以显示加：return 返回，如果不加，将以最后一条命令运行结果，作为返回值。 return后跟数值n(0-255)

示例：

#!/bin/bashfunWithReturn(){    echo "这个函数会对输入的两个数字进行相加运算..."    echo "输入第一个数字: "    read aNum    echo "输入第二个数字: "    read anotherNum    echo "两个数字分别为 $aNum 和 $anotherNum !"    return $(($aNum+$anotherNum))}funWithReturnecho "输入的两个数字之和为 $? !"

输出，类似下面：

这个函数会对输入的两个数字进行相加运算...输入第一个数字: 1输入第二个数字: 2两个数字分别为 1 和 2 !输入的两个数字之和为 3 !

函数返回值在调用该函数后通过 $? 来获得。

注意：所有函数在使用前必须定义。这意味着必须将函数放在脚本开始部分，直至shell解释器首次发现它时，才可以使用。调用函数仅使用其函数名即可。

在Shell中，调用函数时可以向其传递参数。在函数体内部，通过 $n 的形式来获取参数的值，例如，$1表示第一个参数，$2表示第二个参数…

带参数的函数示例：

#!/bin/bashfunWithParam(){    echo "第一个参数为 $1 !"    echo "第二个参数为 $2 !"    echo "第十个参数为 $10 !"    echo "第十个参数为 ${10} !"    echo "第十一个参数为 ${11} !"    echo "参数总数有 $# 个!"    echo "作为一个字符串输出所有参数 $* !"}funWithParam 1 2 3 4 5 6 7 8 9 34 73

输出结果：

第一个参数为 1 !第二个参数为 2 !第十个参数为 10 !第十个参数为 34 !第十一个参数为 73 !参数总数有 11 个!作为一个字符串输出所有参数 1 2 3 4 5 6 7 8 9 34 73 !

当n>=10时，需要使用${n}来获取参数。

另外，还有几个特殊字符用来处理参数：

文件包含

Shell 文件包含的语法格式如下：

. filename   # 注意点号(.)和文件名中间有一空格或source filename

实例

创建两个 shell 脚本文件。

test1.sh 代码如下：

#!/bin/bashurl="http://www.baidu.com"

test2.sh 代码如下：

#!/bin/bash#使用 . 号来引用test1.sh 文件. ./test1.sh# 或者使用以下包含文件代码# source ./test1.shecho "url地址：$url"

接下来，我们为 test2.sh 添加可执行权限并执行：

$ chmod +x test2.sh $ ./test2.sh url地址：http://www.baidu.com

**注：**被包含的文件 test1.sh 不需要可执行权限。

shell数据类型

字符串

字符串可以用单引号，也可以用双引号，也可以不用引号。

单引号：

str='this is a string'

单引号字符串的限制：

• 单引号里的任何字符都会原样输出，单引号字符串中的变量是无效的；
• 单引号字串中不能出现单独一个的单引号（对单引号使用转义符后也不行），但可成对出现，作为字符串拼接使用。

双引号：

your_name='taobao'str="Hello, I know you are \"$your_name\"! \n"echo -e $str

输出结果为：

Hello, I know you are "taobao"! 

双引号的优点：

• 双引号里可以有变量
• 双引号里可以出现转义字符

拼接字符串：

your_name="taobao"# 使用双引号拼接greeting="hello, "$your_name" !"greeting_1="hello, ${your_name} !"echo $greeting  $greeting_1# 使用单引号拼接greeting_2='hello, '$your_name' !'greeting_3='hello, ${your_name} !'echo $greeting_2  $greeting_3

输出结果为：

hello, taobao ! hello, taobao !hello, taobao ! hello, ${your_name} !

获取字符串长度${#s}

string="abcd"echo ${#string} #输出 4

截取字符串${s:n1:n2}

以下实例从字符串第 2 个字符开始截取 4 个字符：

string="taobao is a great site"echo ${string:1:4} # 输出 unoo

查找字符出现的位置expr index

查找字符 i 或 o 的位置(哪个字母先出现就计算哪个)：

string="taobao is a great site"echo `expr index "$string" io`  # 输出 3

注意： 以上脚本中 ` 是反引号，而不是单引号 '。

数组

bash支持一维数组（不支持多维数组），并且没有限定数组的大小。

数组元素的下标由 0 开始编号。

定义数组

在 Shell 中，用括号来表示数组，数组元素用"空格"符号分割开。定义数组的一般形式为：

array_name=(value0 value1 value2 value3)

或者

array_name=(value0value1value2value3)

或单独定义数组的各个分量：

array_name[0]=value0array_name[1]=value1array_name[n]=valuen

可以不使用连续的下标，而且下标的范围没有限制。

读取数组

读取数组元素值的一般格式是：

valuen=${array_name[n]}

例子：

#!/bin/bashmy_array=(A B "C" D)echo "第一个元素为: ${my_array[0]}"echo "第二个元素为: ${my_array[1]}"echo "第三个元素为: ${my_array[2]}"echo "第四个元素为: ${my_array[3]}"

执行脚本，输出结果如下所示：

$ chmod +x test.sh $ ./test.sh第一个元素为: A第二个元素为: B第三个元素为: C第四个元素为: D

使用 @或* 符号可以获取数组中的所有元素，例如：

echo ${array_name[@]}

例子：

#!/bin/bashmy_array[0]=Amy_array[1]=Bmy_array[2]=Cmy_array[3]=Decho "数组的元素为: ${my_array[*]}"echo "数组的元素为: ${my_array[@]}"

执行脚本，输出结果如下所示：

$ chmod +x test.sh $ ./test.sh数组的元素为: A B C D数组的元素为: A B C D

获取数组的长度

获取数组长度的方法与获取字符串长度的方法相同，例如：

# 取得数组元素的个数length=${#array_name[@]}# 或者length=${#array_name[*]}# 取得数组单个元素的长度lengthn=${#array_name[n]}

例子：

#!/bin/bashmy_array[0]=Amy_array[1]=Bmy_array[2]=Cmy_array[3]=Decho "数组元素个数为: ${#my_array[*]}"echo "数组元素个数为: ${#my_array[@]}"

执行脚本，输出结果如下所示：

$ chmod +x test.sh $ ./test.sh数组元素个数为: 4数组元素个数为: 4

Shell传递参数

执行 Shell 脚本时，向脚本传递参数，脚本内获取参数的格式为：$n。

n 代表一个数字，1 为执行脚本的第一个参数，2 为执行脚本的第二个参数，以此类推……

$0 为执行的文件名

test.sh文件内容如下：

vi test.sh#!/bin/bashecho "Shell 传递参数实例！";echo "执行的文件名：$0";echo "第一个参数为：$1";echo "第二个参数为：$2";echo "第三个参数为：$3";

运行结果：

python@ubuntu:~/test$ sh test.sh 1 2 3Shell 传递参数实例！执行的文件名：test.sh第一个参数为：1第二个参数为：2第三个参数为：3

参数获取：

#!/bin/bashecho "参数个数为：$#";echo "$*传递的参数作为一个字符串显示：$*";echo "$@传递的参数作为一个字符串显示：$@";echo "脚本运行的当前进程ID号：$$";echo "后台运行的最后一个进程的ID号：$!";echo "$?"

执行脚本，输出结果如下所示：

python@ubuntu:~/test$ ./test.sh 1 2 3参数个数为：31 2 3传递的参数作为一个字符串显示：1 2 31 2 3传递的参数作为一个字符串显示：1 2 3脚本运行的当前进程ID号：5059后台运行的最后一个进程的ID号：0

$*与$@的区别：

• 只有在双引号中体现出来。假设在脚本运行时写了三个参数 1、2、3，，则$* 等价于 “1 2 3”（传递了一个参数），而$@等价于 “1” “2” “3”（传递了三个参数）。

#!/bin/bashecho "-- \"\$*\" 演示 ---"for i in "$*"; do    echo $idoneecho "-- \"\$@\" 演示 ---"for i in "$@"; do    echo $idoneecho "-- \$* 演示 ---"for i in $*; do    echo $idoneecho "-- \$@ 演示 ---"for i in $@; do    echo $idone

执行脚本，输出结果如下所示：

python@ubuntu:~/test$ sh test 1 2 3-- "$*" 演示 ---1 2 3-- "$@" 演示 ---123-- $* 演示 ---123-- $@ 演示 ---123

Shell基本运算符

Shell 和其他编程语言一样，支持多种运算符，包括：

• 算数运算符
• 关系运算符
• 布尔运算符
• 字符串运算符
• 文件测试运算符

原生bash不支持简单的数学运算，但是可以通过其他命令来实现，例如 awk 和 expr，expr 最常用。

expr 是一款表达式计算工具，使用它能完成表达式的求值操作。

#!/bin/bashval=`expr 2 + 2`echo "两数之和为 : $val"

执行脚本，输出结果如下所示：

两数之和为 : 4

两点注意：

• 表达式和运算符之间要有空格，例如 2+2 是不对的，必须写成 2 + 2。
• 完整的表达式要被 ` ` 包含，这个字符是反引号在 Esc 键下边。

算术运算符

下表列出了常用的算术运算符，假定变量 a 为 10，变量 b 为 20：

算术运算符实例如下：

#!/bin/basha=10b=20val=`expr $a + $b`echo "a + b : $val"val=`expr $a - $b`echo "a - b : $val"val=`expr $a \* $b`echo "a * b : $val"val=`expr $b / $a`echo "b / a : $val"val=`expr $b % $a`echo "b % a : $val"if [ $a == $b ]then   echo "a 等于 b"fiif [ $a != $b ]then   echo "a 不等于 b"fi

执行脚本，输出结果如下所示：

a + b : 30a - b : -10a * b : 200b / a : 2b % a : 0a 不等于 b

注意：

• 乘号(*)前边必须加反斜杠\才能实现乘法运算；
• if…then…fi 是条件语句，后续将会讲解。
• 在 MAC 中 shell 的 expr 语法是：$((表达式))，此处表达式中的 “*” 不需要转义符号 \ 。

let varName=算术表达式varName=$[算术表达式]varName=$((算术表达式))

关系运算符

关系运算符只支持数字，不支持字符串，除非字符串的值是数字。

下表列出了常用的关系运算符，假定变量 a 为 10，变量 b 为 20：

关系运算符实例如下：

#!/bin/basha=10b=20if [ $a -eq $b ]then   echo "$a -eq $b : a 等于 b"else   echo "$a -eq $b: a 不等于 b"fiif [ $a -ne $b ]then   echo "$a -ne $b: a 不等于 b"else   echo "$a -ne $b : a 等于 b"fiif [ $a -gt $b ]then   echo "$a -gt $b: a 大于 b"else   echo "$a -gt $b: a 不大于 b"fiif [ $a -lt $b ]then   echo "$a -lt $b: a 小于 b"else   echo "$a -lt $b: a 不小于 b"fiif [ $a -ge $b ]then   echo "$a -ge $b: a 大于或等于 b"else   echo "$a -ge $b: a 小于 b"fiif [ $a -le $b ]then   echo "$a -le $b: a 小于或等于 b"else   echo "$a -le $b: a 大于 b"fi

执行脚本，输出结果如下所示：

10 -eq 20: a 不等于 b10 -ne 20: a 不等于 b10 -gt 20: a 不大于 b10 -lt 20: a 小于 b10 -ge 20: a 小于 b10 -le 20: a 小于或等于 b

布尔运算符

下表列出了常用的布尔运算符，假定变量 a 为 10，变量 b 为 20：

布尔运算符实例如下：

#!/bin/basha=10b=20if [ $a != $b ]then   echo "$a != $b : a 不等于 b"else   echo "$a == $b: a 等于 b"fiif [ $a -lt 100 -a $b -gt 15 ]then   echo "$a 小于 100 且 $b 大于 15 : 返回 true"else   echo "$a 小于 100 且 $b 大于 15 : 返回 false"fiif [ $a -lt 100 -o $b -gt 100 ]then   echo "$a 小于 100 或 $b 大于 100 : 返回 true"else   echo "$a 小于 100 或 $b 大于 100 : 返回 false"fiif [ $a -lt 5 -o $b -gt 100 ]then   echo "$a 小于 5 或 $b 大于 100 : 返回 true"else   echo "$a 小于 5 或 $b 大于 100 : 返回 false"fi

执行脚本，输出结果如下所示：

10 != 20 : a 不等于 b10 小于 100 且 20 大于 15 : 返回 true10 小于 100 或 20 大于 100 : 返回 true10 小于 5 或 20 大于 100 : 返回 false

逻辑运算符

以下介绍 Shell 的逻辑运算符，假定变量 a 为 10，变量 b 为 20:

逻辑运算符实例如下：

#!/bin/basha=10b=20if [[ $a -lt 100 && $b -gt 100 ]]then   echo "返回 true"else   echo "返回 false"fiif [[ $a -lt 100 || $b -gt 100 ]]then   echo "返回 true"else   echo "返回 false"fi

执行脚本，输出结果如下所示：

返回 false返回 true

字符串运算符

下表列出了常用的字符串运算符，假定变量 a 为 “abc”，变量 b 为 “efg”：

字符串运算符实例如下：

#!/bin/basha="abc"b="efg"if [ $a = $b ]then   echo "$a = $b : a 等于 b"else   echo "$a = $b: a 不等于 b"fiif [ $a != $b ]then   echo "$a != $b : a 不等于 b"else   echo "$a != $b: a 等于 b"fiif [ -z $a ]then   echo "-z $a : 字符串长度为 0"else   echo "-z $a : 字符串长度不为 0"fiif [ -n "$a" ]then   echo "-n $a : 字符串长度不为 0"else   echo "-n $a : 字符串长度为 0"fiif [ $a ]then   echo "$a : 字符串不为空"else   echo "$a : 字符串为空"fi

执行脚本，输出结果如下所示：

abc = efg: a 不等于 babc != efg : a 不等于 b-z abc : 字符串长度不为 0-n abc : 字符串长度不为 0abc : 字符串不为空

文件测试运算符

文件测试运算符用于检测 Unix 文件的各种属性。

属性检测描述如下：

其他检查符：

• -S: 判断某文件是否 socket。
• -L: 检测文件是否存在并且是一个符号链接。

变量 file 表示文件 /var/www/runoob/test.sh，它的大小为 100 字节，具有 rwx 权限。下面的代码，将检测该文件的各种属性：

#!/bin/bashfile="/var/www/runoob/test.sh"if [ -r $file ]then   echo "文件可读"else   echo "文件不可读"fiif [ -w $file ]then   echo "文件可写"else   echo "文件不可写"fiif [ -x $file ]then   echo "文件可执行"else   echo "文件不可执行"fiif [ -f $file ]then   echo "文件为普通文件"else   echo "文件为特殊文件"fiif [ -d $file ]then   echo "文件是个目录"else   echo "文件不是个目录"fiif [ -s $file ]then   echo "文件不为空"else   echo "文件为空"fiif [ -e $file ]then   echo "文件存在"else   echo "文件不存在"fi

执行脚本，输出结果如下所示：

文件可读文件可写文件可执行文件为普通文件文件不是个目录文件不为空文件存在

test命令

Shell中的 test 命令用于检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试。

数值测试

实例演示：

num1=100num2=100if test $[num1] -eq $[num2]then    echo '两个数相等！'else    echo '两个数不相等！'fi

输出结果：

两个数相等！

代码中的 [] 执行基本的算数运算，如：

#!/bin/basha=5b=6result=$[a+b] # 注意等号两边不能有空格echo "result 为： $result"

结果为:

result 为： 11

字符串测试

实例演示：

num1="ru1noob"num2="runoob"if test $num1 = $num2then    echo '两个字符串相等!'else    echo '两个字符串不相等!'fi

输出结果：

两个字符串不相等!

文件测试

实例演示：

cd /binif test -e ./bashthen    echo '文件已存在!'else    echo '文件不存在!'fi

输出结果：

文件已存在!

另外，Shell还提供了与( -a )、或( -o )、非( ! )三个逻辑操作符用于将测试条件连接起来，其优先级为："!“最高，”-a"次之，"-o"最低。例如：

cd /binif test -e ./notFile -o -e ./bashthen    echo '至少有一个文件存在!'else    echo '两个文件都不存在'fi

输出结果：

至少有一个文件存在!

Shell 流程控制

if else判断语句

if 语句语法格式：

if conditionthen    command1     command2    ...    commandN fi

写成一行（适用于终端命令提示符）：

if [ $(ps -ef | grep -c "ssh") -gt 1 ]; then echo "true"; fi

if else 语法格式：

if conditionthen    command1     command2    ...    commandNelse    commandfi

if else-if else 语法格式：

if condition1then    command1elif condition2 then     command2else    commandNfi

以下实例判断两个变量是否相等：

a=10b=20if [ $a == $b ]then   echo "a 等于 b"elif [ $a -gt $b ]then   echo "a 大于 b"elif [ $a -lt $b ]then   echo "a 小于 b"else   echo "没有符合的条件"fi

输出结果：

a 小于 b

if else语句经常与test命令结合使用，如下所示：

num1=$[2*3]num2=$[1+5]if test $[num1] -eq $[num2]then    echo '两个数字相等!'else    echo '两个数字不相等!'fi

输出结果：

两个数字相等!

for循环

for循环一般格式为：

for var in item1 item2 ... itemNdo    command1    command2    ...    commandNdone

写成一行：

for var in item1 item2 ... itemN; do command1; command2… done;

例如，顺序输出当前列表中的数字：

for loop in 1 2 3 4 5do    echo "The value is: $loop"done

输出结果：

The value is: 1The value is: 2The value is: 3The value is: 4The value is: 5

顺序输出字符串中的字符：

for str in 'This is a string'do    echo $strdone

输出结果：

This is a string

while循环

while循环格式为：

while conditiondo    commanddone

示例：

#!/bin/bashint=1while(( $int<=5 ))do    echo $int    let "int++"done

运行脚本，输出：

12345

while循环可用于读取键盘信息。下面的例子中，输入信息被设置为变量FILM，按Ctrl-D结束循环。

echo '按下  退出'echo -n '输入你最喜欢的网站名: 'while read FILMdo    echo "是的！$FILM 是一个好网站"done

运行脚本，输出类似下面：

按下  退出输入你最喜欢的网站名:淘宝是的！淘宝 是一个好网站

无限循环

无限循环语法格式：

while :do    commanddone

或者

while truedo    commanddone

或者

for (( ; ; ))

until 循环

until 循环执行一系列命令直至条件为 true 时停止。

until 循环与 while 循环在处理方式上刚好相反。

一般 while 循环优于 until 循环，但在某些时候—也只是极少数情况下，until 循环更加有用。

until 语法格式:

until conditiondo    commanddone

condition 一般为条件表达式，如果返回值为 false，则继续执行循环体内的语句，否则跳出循环。

以下实例我们使用 until 命令来输出 0 ~ 9 的数字：

#!/bin/basha=0until [ ! $a -lt 10 ]do   echo $a   a=`expr $a + 1`done

运行结果：

输出结果为：

0123456789

case

Shell case语句为多选择语句。可以用case语句匹配一个值与一个模式，如果匹配成功，执行相匹配的命令。case语句格式如下：

case 值 in模式1)    command1    command2    ...    commandN    ;;模式2）    command1    command2    ...    commandN    ;;esac

下面的脚本提示输入1到4，与每一种模式进行匹配：

echo '输入 1 到 4 之间的数字:'echo '你输入的数字为:'read aNumcase $aNum in    1)  echo '你选择了 1'    ;;    2)  echo '你选择了 2'    ;;    3)  echo '你选择了 3'    ;;    4)  echo '你选择了 4'    ;;    *)  echo '你没有输入 1 到 4 之间的数字'    ;;esac

输入不同的内容，会有不同的结果，例如：

输入 1 到 4 之间的数字:你输入的数字为:3你选择了 3

跳出循环

在循环过程中，有时候需要在未达到循环结束条件时强制跳出循环，Shell使用两个命令来实现该功能：break和continue。

break命令允许跳出所有循环（终止执行后面的所有循环）。

下面的例子中，脚本进入死循环直至用户输入数字大于5。要跳出这个循环，返回到shell提示符下，需要使用break命令。

#!/bin/bashwhile :do    echo -n "输入 1 到 5 之间的数字:"    read aNum    case $aNum in 1|2|3|4|5) echo "你输入的数字为 $aNum!" ;; *) echo "你输入的数字不是 1 到 5 之间的! 游戏结束"     break ;;    esacdone

执行以上代码，输出结果为：

输入 1 到 5 之间的数字:3你输入的数字为 3!输入 1 到 5 之间的数字:7你输入的数字不是 1 到 5 之间的! 游戏结束

continue命令与break命令类似，只有一点差别，它不会跳出所有循环，仅仅跳出当前循环。

Shell输入/输出重定向

重定向命令列表如下：

需要注意的是文件描述符 0 通常是标准输入（STDIN），1 是标准输出（STDOUT），2 是标准错误输出（STDERR）。

输出重定向

重定向一般通过在命令间插入特定的符号来实现。特别的，这些符号的语法如下所示:

command1 > file1

上面这个命令执行command1然后将输出的内容存入file1。

注意任何file1内的已经存在的内容将被新内容替代。如果要将新内容添加在文件末尾，请使用>>操作符。

输出重定向会覆盖文件内容：

$ echo "www.baidu.com" > users$ cat userswww.baidu.com$

如果不希望文件内容被覆盖，可以使用 >> 追加到文件末尾，例如：

$ echo "www.baidu.com" >> users$ cat userswww.baidu.comwww.baidu.com$

输入重定向

和输出重定向一样，Unix 命令也可以从文件获取输入，语法为：

command1 < file1

这样，本来需要从键盘获取输入的命令会转移到文件读取内容。

注意：输出重定向是大于号(>)，输入重定向是小于号(<)。

统计 users 文件的行数,执行以下命令：

python@ubuntu:~/test$ wc -l test 4 test

也可以将输入重定向到 users 文件：

python@ubuntu:~/test$ wc -l <test4

注意：上面两个例子的结果不同：第一个例子，会输出文件名；第二个不会，因为它仅仅知道从标准输入读取内容。

同时替换输入和输出，执行command1，从文件infile读取内容，然后将输出写入到outfile中:

command1  outfile

重定向深入讲解

一般情况下，每个 Unix/Linux 命令运行时都会打开三个文件：

• 标准输入文件(stdin)：stdin的文件描述符为0，Unix程序默认从stdin读取数据。
• 标准输出文件(stdout)：stdout 的文件描述符为1，Unix程序默认向stdout输出数据。
• 标准错误文件(stderr)：stderr的文件描述符为2，Unix程序会向stderr流中写入错误信息。

默认情况下，command > file 将 stdout 重定向到 file，command < file 将stdin 重定向到 file。

如果希望 stderr 重定向到 file，可以这样写：

$ command 2 > file

如果希望 stderr 追加到 file 文件末尾，可以这样写：

$ command 2 >> file

2 表示标准错误文件(stderr)。

如果希望将 stdout 和 stderr 合并后重定向到 file，可以这样写：

$ command > file 2>&1或者$ command >> file 2>&1

如果希望对 stdin 和 stdout 都重定向，可以这样写：

$ command file2

command 命令将 stdin 重定向到 file1，将 stdout 重定向到 file2。

Here Document

Here Document 是 Shell 中的一种特殊的重定向方式，用来将输入重定向到一个交互式 Shell 脚本或程序。

它的基本的形式如下：

command << delimiter    documentdelimiter

它的作用是将两个 delimiter 之间的内容(document) 作为输入传递给 command。

注意：结尾的delimiter 一定要顶格写，前面不能有任何字符，后面也不能有任何字符，包括空格和 tab 缩进。

在命令行中通过 wc -l 命令计算 Here Document 的行数：

$ wc -l << EOF    欢迎来到    菜鸟教程    www.runoob.comEOF3   # 输出结果为 3 行$

/dev/null 文件

如果希望执行某个命令，但又不希望在屏幕上显示输出结果，那么可以将输出重定向到 /dev/null：

$ command > /dev/null

/dev/null 是一个特殊的文件，写入到它的内容都会被丢弃；如果尝试从该文件读取内容，那么什么也读不到。但是 /dev/null 文件非常有用，将命令的输出重定向到它，会起到"禁止输出"的效果。

如果希望屏蔽 stdout 和 stderr，可以这样写：

$ command > /dev/null 2>&1

0 是标准输入（STDIN），1 是标准输出（STDOUT），2 是标准错误输出（STDERR）。

实例

杨辉三角：

#!/bin/bashif (test -z $1) ;then  read -p "Input high Int Lines:" high else  high=$1 fi if (test -z $2) ;then  space=4else  space=$2fiprintspace(){  #空位填充  for((z=1;z<=$1;z++));do    echo -n " "  done}a[0]=1     for((i=0;i0;j--));do     ((a[$j]+=a[$j-1]))   done  printspace $((($high-$i)*$space/2))  for ((j=0;j<=$i;j++));do    num=$(($space-${#a[$j]}))    printspace $(($num/2))    echo -n ${a[$j]}    printspace $(($num-$num/2))  done  echo ""done

sum()&max():

#!/bin/bashecho "shell的函数返回值只能为0~255的整数，高位自动丢弃"sum(){ sum=0 for i in $@ do  if test $i -ne $1;then   echo -n "+"  fi  echo -n "$i"  sum=$(($sum+$i)) done echo "=$sum" return $(($sum))}sum $@echo "‘sum()’函数返回值："$?max(){ max=0 for i in $@;do  if test $i -ge $max;then    max=$i  fi done echo "参数最大值：$max" return $(($max))}max $@echo "‘max()’函数返回值："$?

99乘法表：

#!/bin/bashfor i in {1..9};do for((j=1;j<=i;j++));do  echo -en "$i*$j=$(($i*$j))\t" done echo ""donefor a in {1..9};do    for b in {0..9};do for c in {0..9};do     number1=$((a*100+b*10+c))     number2=$((a**3+b**3+c**3))     if test $number1 -eq $number2; then  echo "Found number $number1"     fi done    donedone

文本编辑命令

cut命令

选项与参数：-d  ：后面接分隔字符。与 -f 一起使用；-f  ：依据 -d 的分隔字符将一段信息分割成为数段，用 -f 取出第几段的意思；-c  ：以字符 (characters) 的单位取出固定字符区间；

cut以行为单位，根据分隔符把行分成若干列，这样就可以指定选取哪些列了。

cut -d '分隔字符' -f 选取的列数echo $PATH|cut -d ':' -f 2  --选取第2列echo $PATH|cut -d ':' -f 3,5  --选取第3列和第5列echo $PATH|cut -d ':' -f 3-5  --选取第3列到第5列echo $PATH|cut -d ':' -f 3-   --选取第3列到最后1列echo $PATH|cut -d ':' -f 1-3,5--选取第1到第3列还有第5列

只显示/etc/passwd的用户和shell：

#cat /etc/passwd | cut -d ':' -f 1,7 root:/bin/bashdaemon:/bin/shbin:/bin/sh

sed命令

sed 可依照脚本的指令来处理、编辑文本文件。

Sed 主要用来自动编辑一个或多个文件、简化对文件的反复操作、编写转换程序等。

语法:

sed [-e][-f][文本文件]

参数说明：

• -e 以指定的script来处理输入的文本文件。
• -f以指定的script文件来处理输入的文本文件。
• -n仅显示script处理后的结果，一般跟p动作搭配使用。
• -i使用处理后的结果修改文件。

动作说明：

• a：在指定行后面插入内容
• i：在指定行前面插入内容
• d：删除指定行
• c ：替换指定行
• p ：打印指定行的数据，通常需要跟-n选项搭配使用
• s ：替换指定字符，兼容vim的替换语法，例如 1,20s/old/new/g

元字符集

sed支持一般的正则表达式，下面是支持的正则语法：
^行的开始 如：/^sed/匹配所有以sed开头的行。
$行的结束 如：/sed$/匹配所有以sed结尾的行。
.匹配一个非换行符的任意字符 如：/s.d/匹配s后接一个任意字符，然后是d。
*匹配零或多个字符 如：/*sed/匹配所有模板是一个或多个空格后紧跟sed的行。
[]匹配一个指定范围内的字符，如/[Ss]ed/匹配sed和Sed。
[^]匹配一个不在指定范围内的字符，如：/[^A-RT-Z]ed/匹配不包含A-R和T-Z的一个字母开头，紧跟ed的行。
\(..\)保存匹配的字符，如s/(love)able/\1rs，loveable被替换成lovers。
&保存搜索字符用来替换其他字符，如s/love/**&**/，love这成**love**。
\<单词的开始，如:/<love/匹配包含以love开头的单词的行。
\>单词的结束，如/love>/匹配包含以love结尾的单词的行。
x\+重复字符x，至少1次，如：/o\+/匹配至少有1个o的行。
x\{m\}重复字符x，m次，如：/o\{5\}/匹配包含5个o的行。
x\{m,\}重复字符x,至少m次，如：/o\{5,\}/匹配至少有5个o的行。
x\{m,n\}重复字符x，至少m次，不多于n次，如：/o\{5,10\}/匹配5-10个o的行。

a|i:在指定行位置添加行

python@xxx:~/test$ cat testfile LINUX!   Linux is a free unix-type opterating system.   This is a linux testfile!   Linux test python@xxx:~/test$ sed -e 2a\newline testfile  LINUX!   Linux is a free unix-type opterating system.  newline This is a linux testfile!   Linux test  

默认情况下-e参数可以省略：

python@xxx:~/test$ cat testfile|sed '2a\newline' LINUX!   Linux is a free unix-type opterating system.  newline This is a linux testfile!   Linux test python@xxx:~/test$ sed '2a newline' testfile LINUX!   Linux is a free unix-type opterating system.  newline This is a linux testfile!   Linux test 

中的内容最好用单引号括起来，如果脚本内容不存在空白字符也可以省略单引号。

在第二行之前添加一行：

python@xxx:~/test$ sed '2i newline' testfile  LINUX!  newline Linux is a free unix-type opterating system.   This is a linux testfile!   Linux test 

最后一行加入 # This is a test:

python@xxx:~/test$ sed '$a # This is a test' testfile  LINUX!   Linux is a free unix-type opterating system.   This is a linux testfile!   Linux test # This is a test

同时添加多行：

python@xxx:~/test$ cat testfile|sed '2a\newline1\> newline2' LINUX!   Linux is a free unix-type opterating system.  newline1newline2 This is a linux testfile!   Linux test 

d:删除指定行

将 /etc/passwd 的内容列出行号，并将第 2~5 行删除！

[root@www ~]# nl /etc/passwd | sed '2,5d'1 root:x:0:0:root:/root:/bin/bash6 sync:x:5:0:sync:/sbin:/bin/sync7 shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown.....(后面省略).....

只删除第2行：

nl /etc/passwd | sed '2d' 

删除第3到最后一行：

nl /etc/passwd | sed '3,$d' 

删除/etc/passwd所有包含/usr/sbin/nologin的行，其他行输出：

python@xxx:~/test$ nl /etc/passwd | sed  '/\/usr\/sbin\/nologin/d'1  root:x:0:0:root:/root:/bin/bash5  sync:x:4:65534:sync:/bin:/bin/sync19  systemd-timesync:x:100:102:systemd Time Synchronization,,,:/run/systemd:/bin/false20  systemd-network:x:101:103:systemd Network Management,,,:/run/systemd/netif:/bin/false....下面忽略

c:替换指定行

将第2-5行的内容替换成为『No 2-5 number』：

python@xxx:~/test$ nl /etc/passwd | sed '2,5c No 2-5 number'1  root:x:0:0:root:/root:/bin/bashNo 2-5 number6  games:x:5:60:games:/usr/games:/usr/sbin/nologin.....(后面省略).....

p:仅显示指定行

不加-n选项时，除了输出匹配行，还同时会输出所有行，所以需要加-n选项。

仅列出 /etc/passwd 文件内的第 5-7 行：

python@xxx:~/test$ nl /etc/passwd | sed -n '5,7p'5  sync:x:4:65534:sync:/bin:/bin/sync6  games:x:5:60:games:/usr/games:/usr/sbin/nologin7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin

搜索 /etc/passwd有root关键字的行：

python@xxx:~/test$ cat /etc/passwd | sed -n '/root/p'  root:x:0:0:root:/root:/bin/bashpython@xxx:~/test$ sed -n '/root/p' /etc/passwd      root:x:0:0:root:/root:/bin/bash

打印/etc/passwd有以root和bin开头之间的行：

python@xxx:~/test$ cat /etc/passwd | sed -n '/^root/,/^bin/p'root:x:0:0:root:/root:/bin/bashdaemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologinbin:x:2:2:bin:/bin:/usr/sbin/nologin

打印从第五行开始到第一个包含以/var/mail开始的行之间的所有行：

python@xxx:~/test$ nl /etc/passwd | sed -n '5,\/var\/mail/p' 5  sync:x:4:65534:sync:/bin:/bin/sync     6  games:x:5:60:games:/usr/games:/usr/sbin/nologin     7  man:x:6:12:man:/var/cache/man:/usr/sbin/nologin     8  lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin     9  mail:x:8:8:mail:/var/mail:/usr/sbin/nologin

s:字符串替换

语法：

sed 's/要被取代的字串/新的字串/g'

不论什么字符，紧跟着s命令的都被认为是新的分隔符.

sed 's#10#100#g'表示把所有10替换成100，“#”在这里是分隔符，代替了默认的“/”分隔符。

提取本机所有的ip地址：

[root@VM_0_9_centos ~]# ifconfig | grep 'inet ' inet 172.16.0.9  netmask 255.255.240.0  broadcast 172.16.15.255 inet 127.0.0.1  netmask 255.0.0.0[root@VM_0_9_centos ~]# ifconfig | grep 'inet '|sed 's/^[^0-9]*\([0-9\.]*\).*$/\1/g'172.16.0.9127.0.0.1

对于以root和bin开头之间的行，每行的末尾添加sed test：

python@xxx:~/test$ cat /etc/passwd | sed '/^root/,/^bin/s/$/--sed test/'  root:x:0:0:root:/root:/bin/bash--sed testdaemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin--sed testbin:x:2:2:bin:/bin:/usr/sbin/nologin--sed testsys:x:3:3:sys:/dev:/usr/sbin/nologin

y:单字符替换

跟s一样也用于替换，不过s替换的是整体，y替换的是每一字母对应的单个字母

把data中的第一行至第三行中的a替换成A，b替换成B，c替换成C：

sed '1,3y/abc/ABC/' data 

示例：

python@ubuntu:~/test$ echo "123" | sed 'y/13/34/' 324python@ubuntu:~/test$ echo "axxbxxcxx" | sed 'y/abc/123/'1xx2xx3xx

hHgG模式空间&保持空间

h命令是将当前模式空间中内容覆盖至保持空间，H命令是将当前模式空间中的内容追加至保持空间

g命令是将当前保持空间中内容覆盖至模式空间，G命令是将当前保持空间中的内容追加至模式空间

模拟tac命令：

python@ubuntu:~/test$ cat log.txt 2 this is a test3 Are you like awkThis's a test10 There are orange,apple,mongopython@ubuntu:~/test$ cat log.txt |sed '1!G;h;$!d'10 There are orange,apple,mongoThis's a test3 Are you like awk2 this is a test

1!G第1行不 执行“G”命令，从第2行开始执行。

$!d，最后一行不删除（保留最后1行）

下图P表示模式空间，H代表保持空间：

递增序列：

python@ubuntu:~/test$ seq 3123python@ubuntu:~/test$ seq 3|sed 'H;g'112123

多次指定-e选项进行多点编辑

删除/etc/passwd第三行到末尾的数据，并把bash替换为blueshell：

nl /etc/passwd | sed -e '3,$d' -e 's/bash/blueshell/'1  root:x:0:0:root:/root:/bin/blueshell2  daemon:x:1:1:daemon:/usr/sbin:/bin/sh

删除一个文件以#开头的行和空行：

python@xxx:~/test$ nl abc -ba     1     2  b     3  a     4     5  # aaaa     6     7  ddd     8     9  # sss    10  eeee    11python@xxx:~/test$ sed -e '/^#/d' -e '/^$/d' abcbadddeeee

也可以通过;实现

python@ubuntu:~/test$ nl /etc/passwd | sed '3,$d;s/bash/blueshell/'     1  root:x:0:0:root:/root:/bin/blueshell     2  daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologinpython@ubuntu:~/test$ sed '/^#/d;/^$/d' abcbadddeeee

选项-i直接修改文件内容

默认情况下sed命令仅仅只是将处理结果显示在控制台，加-i选项则会修改文件内容。

将 regular_express.txt 内每一行结尾若为 . 则换成 !

[root@www ~]# cat regular_express.txt taobao.google.taobao.facebook.zhihu-weibo-[root@www ~]# sed -i 's/\.$/\!/g' regular_express.txt[root@www ~]# cat regular_express.txt taobao!google!taobao!facebook!zhihu-weibo-

awk命令

AWK是一种处理文本文件的语言，是一个强大的文本分析工具。

之所以叫AWK是因为其取了三位创始人 Alfred Aho，Peter Weinberger, 和 Brian Kernighan 的 Family Name 的首字符。

语法：

awk [选项参数] 'script' var=value file(s)或awk [选项参数] -f scriptfile var=value file(s)

选项参数说明：

• -F fs or --field-separator fs
  指定输入文件折分隔符，fs是一个字符串或者是一个正则表达式，如-F:。
• -v var=value or --asign var=value
  赋值一个用户定义变量。
• -f scripfile or --file scriptfile
  从脚本文件中读取awk命令。

基本用法

awk '{[pattern] action}' file

每行按空格或TAB分割，输出文本中的1、4列：

python@ubuntu:~/test$ cat log.txt 2 this is a test3 Are you like awkThis's a test10 There are orange,apple,mongopython@ubuntu:~/test$ awk '{print $1,$4}' log.txt2 a3 likeThis's 10 orange,apple,mongo

格式化输出：

python@ubuntu:~/test$ awk '{printf "%-8s %-10s\n",$1,$4}' log.txt2 a  3 like      This's      

-F指定分割字符

awk -F  #-F相当于内置变量FS, 指定分割字符

使用:分割,取/etc/passwd文件每个用户对应shell：

python@ubuntu:~/test$ awk -F: '{print $1,$7}'  /etc/passwd root /bin/bashdaemon /usr/sbin/nologinbin /usr/sbin/nologinsys /usr/sbin/nologinsync /bin/sync# 或者使用内建变量python@ubuntu:~/test$ awk 'BEGIN{FS=":"} {print $1,$7}'  /etc/passwd  root /bin/bashdaemon /usr/sbin/nologinbin /usr/sbin/nologin

同时使用:和/l两个分隔符分割/etc/passwd文件

python@ubuntu:~/test$ awk -F '[:\/]' '{print $1,$7}'  /etc/passwd      root rootdaemon usrbin bin

-v设置变量

awk -v  # 设置变量

例子：

python@ubuntu:~/test$ cat log.txt 2 this is a test3 Are you like awkThis's a test10 There are orange,apple,mongopython@ubuntu:~/test$ awk -va=1 '{print $1,$1+a}' log.txt2 33 4This's 110 11python@ubuntu:~/test$ awk -va=1 -vb=s '{print $1,$1+a,$1b}' log.txt2 3 2s3 4 3sThis's 1 This'ss10 11 10s

-f指定awk脚本

awk -f {awk脚本} {文件名}

脚本模块：

• BEGIN{ 这里面放的是执行前的语句 }
• END {这里面放的是处理完所有的行后要执行的语句 }
• {这里面放的是处理每一行时要执行的语句}

假设有这么一个文件（学生成绩表）：

$ cat score.txtMarry   2143 78 84 77Jack    2321 66 78 45Tom     2122 48 77 71Mike    2537 87 97 95Bob     2415 40 57 62

awk脚本如下：

$ cat cal.awk#!/bin/awk -f#运行前BEGIN {    math = 0    english = 0    computer = 0     printf "NAME    NO.   MATH  ENGLISH  COMPUTER   TOTAL\n"    printf "---------------------------------------------\n"}#运行中{    math+=$3    english+=$4    computer+=$5    printf "%-6s %-6s %4d %8d %8d %8d\n", $1,$2,$3,$4,$5,$3+$4+$5}#运行后END {    printf "---------------------------------------------\n"    printf "  TOTAL:%10d %8d %8d \n", math, english, computer    printf "AVERAGE:%10.2f %8.2f %8.2f\n", math/NR, english/NR, computer/NR}

我们来看一下执行结果：

$ awk -f cal.awk score.txtNAME    NO.   MATH  ENGLISH  COMPUTER   TOTAL---------------------------------------------Marry  2143     788477      239Jack   2321     667845      189Tom    2122     487771      196Mike   2537     879795      279Bob    2415     405762      159---------------------------------------------  TOTAL:319      393      350AVERAGE:     63.80    78.60    70.00

AWK工作原理

AWK 工作流程可分为三个部分：

• 读输入文件之前执行的代码段（由BEGIN关键字标识）。
• 主循环执行输入文件的代码段。
• 读输入文件之后的代码段（由END关键字标识）。

命令结构:

awk 'BEGIN{ commands } pattern{ commands } END{ commands }'

下面的流程图描述出了 AWK 的工作流程：

• 1、通过关键字 BEGIN 执行 BEGIN 块的内容，即 BEGIN 后花括号 {} 的内容。
• 2、完成 BEGIN 块的执行，开始执行body块。
• 3、读入有 \n 换行符分割的记录。
• 4、将记录按指定的域分隔符划分域，填充域，$0 则表示所有域(即一行内容)，$1\ast \ast 表示第一个域，\ast \ast$n 表示第 n 个域。
• 5、依次执行各 BODY 块，pattern 部分匹配该行内容成功后，才会执行 awk-commands 的内容。
• 6、循环读取并执行各行直到文件结束，完成body块执行。
• 7、开始 END 块执行，END 块可以输出最终结果。

运算符

过滤第一列大于2的行

$ awk '$1>2' log.txt    #命令3 Are you like awkThis's a test10 There are orange,apple,mongo

过滤第一列等于2的行

$ awk '$1==2 {print $1,$3}' log.txt    #命令#输出2 is

过滤第一列大于2并且第二列等于’Are’的行

$ awk '$1>2 && $2=="Are" {print $1,$2,$3}' log.txt    #命令#输出3 Are you

内建变量

格式化变量说明：

• %s 输出字符串
• %i 输出整数
• %f 输出浮点数

%-5s 格式为左对齐且宽度为5的字符串代替（-表示左对齐），不使用则是又对齐。
%-4.2f 格式为左对齐宽度为4，保留两位小数。

python@ubuntu:~/test$ awk 'BEGIN{printf "%4s %4s %4s %4s %4s %4s %4s %4s %4s\n","FILENAME","ARGC","FNR","FS","NF","NR","OFS","ORS","RS";printf "---------------------------------------------\n"} {printf "%4s %4s %4s %4s %4s %4s %4s %4s %4s\n",FILENAME,ARGC,FNR,FS,NF,NR,OFS,ORS,RS}'  log.txtFILENAME ARGC  FNR   FS   NF   NR  OFS  ORS   RS---------------------------------------------log.txt    2    1  5    1  log.txt    2    2  5    2  log.txt    2    3  3    3   log.txt    2    4  4    4  python@ubuntu:~/test$ awk -F: 'BEGIN{printf "%4s %4s %4s %4s %4s %4s %4s %4s %4s\n","FILENAME","ARGC","FNR","FS","NF","NR","OFS","ORS","RS";printf "---------------------------------------------\n"} {printf "%4s %4s %4s %4s %4s %4s %4s %4s %4s\n",FILENAME,ARGC,FNR,FS,NF,NR,OFS,ORS,RS}'  log.txtFILENAME ARGC  FNR   FS   NF   NR  OFS  ORS   RS---------------------------------------------log.txt    2    1    :    1    1  log.txt    2    2    :    1    2  log.txt    2    3    :    1    3  log.txt    2    4    :    1    4    

输出顺序号 NR, 匹配文本行号

python@ubuntu:~/test$ awk '{print NR,FNR,$1,$2,$3}' log.txt1 1 2 this is2 2 3 Are you3 3 This's a test4 4 10 There are

指定输出分割符

python@ubuntu:~/test$ cat log.txt 2 this is a test3 Are you like awkThis's a test10 There are orange,apple,mongopython@ubuntu:~/test$ awk '{print $1,$2,$5}' OFS=" $ "  log.txt2 $ this $ test3 $ Are $ awkThis's $ a $ 10 $ There $ 

忽略大小写

$ awk 'BEGIN{IGNORECASE=1} /this/' log.txt---------------------------------------------2 this is a testThis's a test

正则字符串匹配

~ 表示模式开始。// 中是模式。

输出第二列包含 “th”，并打印第二列与第四列：

python@ubuntu:~/test$ awk '$2 ~ /th/ {print $2,$4}' log.txtthis a

输出包含"re"的行：

python@ubuntu:~/test$ awk '/re/' log.txt3 Are you like awk10 There are orange,apple,mongo

!表示取反

输出第二列不包含 “th”，并打印第二列与第四列：

python@ubuntu:~/test$ awk '$2 !~ /th/ {print $2,$4}' log.txtAre likea There orange,apple,mongo

输出不包含"re"的行：

python@ubuntu:~/test$ awk '!/re/' log.txt2 this is a testThis's a test

一些实例

计算文件大小

$ ls -l *.txt | awk '{sum+=$6} END {print sum}'--------------------------------------------------666581

从文件中找出长度大于80的行

awk 'length>80' log.txt

打印九九乘法表

seq 9 | sed 'H;g' | awk -v RS='' '{for(i=1;i<=NF;i++)printf("%dx%d=%d%s", i, NR, i*NR, i==NR?"\n":"\t")}'

访问日志分析

日志格式

python@ubuntu:~/test$ head access.log -n142.236.10.75 "changtou.xiaoxiaoming.xyz" [14/Oct/2019:12:47:18 +0800] "GET /logo/8@3x.png HTTP/1.1" 200 26053 "https://changtou.xiaoxiaoming.xyz/" "Mozilla/5.0 (Linux; U; Android 8.1.0; zh-CN; EML-AL00 Build/HUAWEIEML-AL00) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/57.0.2987.108 baidu.sogo.uc.UCBrowser/11.9.4.974 UWS/2.13.1.48 Mobile Safari/537.36 AliApp(DingTalk/4.5.11) com.alibaba.android.rimet/10487439 Channel/227200 language/zh-CN" "42.236.10.75" rt="0.000" uct="-" uht="-" urt="-"

示例：

1.数据清洗awk '($6 ~ /.html/) && ($8 ~ /200/)  {print $0}' access.log > clean.log2.统计PVpython@ubuntu:~/test$ awk '{print $0}'  clean.log | wc -l700python@ubuntu:~/test$ cut -d ' ' -f 1 clean.log|wc -l    7003:UVpython@ubuntu:~/test$ awk '{print $1}'  clean.log |sort|uniq| wc -l155python@ubuntu:~/test$ cut -d ' ' -f 1 clean.log|sort|uniq| wc -l1554:获取每天访问网站最多的前10名用户awk '{print $1}' clean.log|sort|uniq -c|sort -k 1nr|head或cut -d ' ' -f 1 clean.log|sort|uniq -c|sort -k 1nr|head

awk编程

条件语句IF&ELSE

IF 条件语句语法格式如下：

if (condition)    action

也可以使用花括号来执行一组操作：

if (condition){    action-1    action-1    .    .    action-n}

判断数字是奇数还是偶数：

python@ubuntu:~/test$ awk 'BEGIN {num = 10; if (num % 2 == 0) printf "%d 是偶数\n", num }'10 是偶数

IF - ELSE 条件语句语法格式如下：

if (condition)    action-1else    action-2

在条件语句 condition 为 true 时只需 action-1，否则执行 action-2。

python@ubuntu:~/test$ awk 'BEGIN {>     num = 11; >     if (num % 2 == 0) printf "%d 是偶数\n", num; >     else printf "%d 是奇数\n", num > }'11 是奇数python@ubuntu:~/test$ awk 'BEGIN {num = 11; if (num % 2 == 0) printf "%d 是偶数\n", num; else printf "%d 是奇数\n", num }'11 是奇数

可以创建多个 IF - ELSE 格式的判断语句来实现多个条件的判断：

$ awk 'BEGIN {a=30;if (a==10)  print "a = 10";else if (a == 20)  print "a = 20";else if (a == 30)  print "a = 30";}'

输出结果：

python@ubuntu:~/test$ awk 'BEGIN {> a=30;> if (a==10)>   print "a = 10";> else if (a == 20)>   print "a = 20";> else if (a == 30)>   print "a = 30";> }'a = 30

循环语句For&While

For 循环的语法如下：

for (initialisation; condition; increment/decrement)    action

下面的例子使用 For 循环输出数字 1 至 5：

python@ubuntu:~/test$ awk 'BEGIN { for (i = 1; i <= 5; ++i) print i }'12345

While 循环的语法如下：

while (condition)    action

下面是使用 While 循环输出数字 1 到 5 的例子：

python@ubuntu:~/test$ awk 'BEGIN {i = 1; while (i < 6) { print i; ++i } }'12345

在下面的示例子中，当计算的和大于 50 的时候使用 break 结束循环：

$ awk 'BEGIN {   sum = 0; for (i = 0; i  50) break; else print "Sum =", sum    } }'

输出结果为：

python@ubuntu:~/test$ awk 'BEGIN {>    sum = 0; for (i = 0; i sum += i; if (sum > 50) break; else print "Sum =", sum >    } > }'Sum = 0Sum = 1Sum = 3Sum = 6Sum = 10Sum = 15Sum = 21Sum = 28Sum = 36Sum = 45

Continue 语句用于在循环体内部结束本次循环，从而直接进入下一次循环迭代。

下面的例子输出 1 到 20 之间的偶数：

python@ubuntu:~/test$ awk 'BEGIN {for (i = 1; i <= 20; ++i) {if (i % 2 == 0) print i ; else continue} }'2468101214161820

Exit 用于结束脚本程序的执行。

该函数接受一个整数作为参数表示 AWK 进程结束状态。 如果没有提供该参数，其默认状态为 0。

下面例子中当和大于 50 时结束 AWK 程序。

$ awk 'BEGIN {   sum = 0; for (i = 0; i  50) exit(10); else print "Sum =", sum    } }'

输出结果为：

python@ubuntu:~/test$ awk 'BEGIN {>    sum = 0; for (i = 0; i sum += i; if (sum > 50) exit(10); else print "Sum =", sum >    } > }'Sum = 0Sum = 1Sum = 3Sum = 6Sum = 10Sum = 15Sum = 21Sum = 28Sum = 36Sum = 45python@ubuntu:~/test$ echo $?10

awk数组

AWK的数组底层数据结构是散列表，索引可以是数字或字符串。

数组使用的语法格式：

array_name[index]=value

创建数组并访问数组元素：

$ awk 'BEGIN {sites["taobao"]="www.taobao.com";sites["google"]="www.google.com"print sites["taobao"] "\n" sites["google"]}'

删除数组元素语法格式：

delete array_name[index]

下面的例子中，数组中的 google 元素被删除（删除命令没有输出）：

$ awk 'BEGIN {sites["taobao"]="www.taobao.com";sites["google"]="www.google.com"delete sites["google"];print sites["google"]}'

AWK 本身不支持多维数组，不过我们可以很容易地使用一维数组模拟实现多维数组。

如下示例为一个 3x3 的三维数组：

100 200 300400 500 600700 800 900

以上实例中，array[0][0] 存储 100，array[0][1] 存储 200 ，依次类推。为了在 array[0][0] 处存储 100, 可以使用字符串0,0 作为索引： array[“0,0”] = 100。

下面是模拟二维数组的例子：

$ awk 'BEGIN {array["0,0"] = 100;array["0,1"] = 200;array["0,2"] = 300;array["1,0"] = 400;array["1,1"] = 500;array["1,2"] = 600;# 输出数组元素print "array[0,0] = " array["0,0"];print "array[0,1] = " array["0,1"];print "array[0,2] = " array["0,2"];print "array[1,0] = " array["1,0"];print "array[1,1] = " array["1,1"];print "array[1,2] = " array["1,2"];}'

执行上面的命令可以得到如下结果：

array[0,0] = 100array[0,1] = 200array[0,2] = 300array[1,0] = 400array[1,1] = 500array[1,2] = 600

在数组上可以执行很多操作，比如，使用 asort 完成数组元素的排序，或者使用 asorti 实现数组索引的排序等等。

AWK 用户自定义函数

自定义函数的语法格式为：

function function_name(argument1, argument2, ...){    function body}

以下实例实现了两个简单函数，它们分别返回两个数值中的最小值和最大值。

文件 functions.awk 代码如下：

# 返回最小值function find_min(num1, num2){  if (num1  num2)    return num1  return num2}# 主函数function main(num1, num2){  # 查找最小值  result = find_min(10, 20)  print "Minimum =", result  # 查找最大值  result = find_max(10, 20)  print "Maximum =", result}# 脚本从这里开始执行BEGIN {  main(10, 20)}

执行 functions.awk 文件，可以得到如下的结果：

$ awk -f functions.awk Minimum = 10Maximum = 20

AWK 内置函数

AWK 内置函数主要有以下几种：

• 算数函数
• 字符串函数
• 时间函数
• 位操作函数
• 其它函数

算数函数

字符串函数

**注：**Ere 部分可以是正则表达式。

1、gsub、sub 使用

$ awk 'BEGIN{info="this is a test2012test!";gsub(/[0-9]+/,"||",info);print info}'this is a test||test!

2、查找字符串（index 使用）

使用了三元运算符: 表达式 ? 动作1 : 动作2

$ awk 'BEGIN{info="this is a test2012test!";print index(info,"11111")?"ok":"no found";}'no found$ awk 'BEGIN{info="this is a test2012test!";print index(info,"is")?"ok":"no found";}'ok$ awk 'BEGIN{info="this is a test2012test!";print index(info,"test")?"ok":"no found";}'ok

3、正则表达式匹配查找(match 使用）

$ awk 'BEGIN{info="this is a test2012test!";print match(info,/[0-9]+/)?"ok":"no found";}'ok

4、截取字符串(substr使用）

从第 4 个 字符开始，截取 10 个长度字符串。

$ awk 'BEGIN{info="this is a test2012test!";print substr(info,4,10);}'s is a tes

5、字符串分割（split使用）

$ awk 'BEGIN{info="this is a test";split(info,tA," ");print length(tA);for(k in tA){print k,tA[k];}}'42 is3 a4 test1 this

分割 info，将 info 字符串使用空格切分为动态数组 tA。注意 awk for …in 循环，是一个无序的循环。 并不是从数组下标 1…n ，因此使用时候需要特别注意。

时间函数

strftime 日期和时间格式说明符:

位操作函数

其他函数

vim全套笔记

VIM快速复习

什么是 vim？

Vim是从 vi 发展出来的一个文本编辑器。代码补完、编译及错误跳转等方便编程的功能特别丰富，在程序员中被广泛使用。vim 的官方网站 (http://www.vim.org)

vim 键盘图：

基本上vi可以分为三种状态：

• 命令模式（command mode)
• 插入模式（Insert mode)
• 底行模式（last line mode)

按:冒号即可进入last line mode

:set nu 列出行号:set nonu取消行号:#7 跳到文件中的第7行/keyword 查找字符  按n向下?keyword 查找字符  按N向下:n1,n2/word1/word2/gc  替换指定范围单词，c表示提示:w 保存文件:w filename 以指定的文件名另存:n1,n2 w [filename]将 n1 到 n2行另存:r [filename]读入另一个文件加到光标所在行后面:! ls /home  在vi当中察看ls输出信息！:q离开vi:wq 和 :ZZ 和 :x 保存并退出vi!强制执行:% s/^/#/g 来在全部内容的行首添加 # 号注释:1,10 s/^/#/g 在1~10 行首添加 # 号注释  

从command mode进入Insert mode

按i在当前位置编辑
按a在当前位置的下一个字符编辑
按o插入新行，从行首开始编辑
按R(Replace mode)：R会一直取代光标所在的文字，直到按下 ESC为止；(常用)

按ESC键退回command mode

h←j↓k↑l→前面加数字移动指定的行数或字符数
1、翻页bu上下整页，ud上下半页

ctrl+b：上移一页。ctrl+f：下移一页。ctrl+u：上移半页。ctrl+d：下移半页。

2、行定位

7gg或7G：定位第7行首字符。(可能只在Vim中有效)G：移动到文章的最后。7H:当前屏幕的第7行行首M：当前屏幕中间行的行首7L:当前屏幕的倒数第7行行首

3、当前行定位

$：移动到光标所在行的“行尾”。0或^：移动到光标所在行的“行首”w：光标跳到下个单词的开头e：光标跳到下个单词的字尾b：光标回到上个单词的开头

4、编辑

x：剪切当前字符7x：剪切从当前位置起7个字符大写的X，表示从前面一个字符开始往前计算dd：剪切光标所在行。7dd：从光标所在行开始剪切7行d7G删除光标所在到第7行的所有数据yw：复制当前单词7yw：复制从当前位置起7个单词yy：复制当前行6yy：从当前行起向下复制6行y7G复制游标所在列到第7列的所有数据p：粘贴u：撤销ctrl+r：取消撤销cw：删除当前单词(从光标位置开始计算)，并进入插入模式c7w：删除7个单词并进入插入模式

多行编辑，vim支持，vi不支持

按ctrl+V进入块模式，上下键选中快，按大写G选择到末尾，上下左右键移动选择位置
按大写I进去编辑模式，输入要插入的字符，编辑完成按ESC退出
选中要替换的字符后，按c键全部会删除，然后输入要插入的字符，编辑完成按ESC退出
选中要替删除的字符后，按delete键，则会全部删除

按shift+V可进入行模式，对指定行操作

vim练习

1、创建目录/tmp/test，将/etc/man.config复制到该目录下

# mkdir -p /tmp/test# cp /etc/man.config /tmp/test/# cd /tmp/test/

2、用vim编辑man.config文件：

vim man.config

3、设置显示行号； 移动到第58行，向右移动40个字符，查看双引号内的是什么目录；

：set nu58G 或58gg 40-> 或40空格 目录为：/dir/bin/foo 

4、移动到第一行，并向下查找“bzip2”这个字符串，它在第几行；

移动到最后一行，并向上查找该字符串；gg 或1G/bzip 137行 ?bzip2

5、将50行到100行之间的man更改为MAN，并且 逐个挑选 是否需要修改；

若在挑选过程中一直按y，结果会在最后一行出现改变了几个man?:50,100s/man/MAN/gc 25次替换

6、修改完后，突然反悔了，要全部复原，有哪些方法？

一直按u键或者:q!强制不保存退出后，再重新打开该文件

7、复制65到73这9行的内容（含有MANPATH_MAP），并且粘贴到最后一行之后；

65gg或65G到该行后，9yy,G 移动到最后一行，p粘贴

8、21行到42行之间开头为#符号的批注数据不要了，如何删除；

21G到该行 22dd

9、将这个文件另存为man.test.config的文件

:w man.test.config

10、到第27行，并且删除15个字符，结果出现的第一个字符是什么？

27gg 后15x

11、在第一行新增一行，在该行内输入“I am a student ”

gg到第一行 O输入即可 说明：o是在当前行之后插入一行，O是在当前行之前插入一行

12、保存并退出

:wq

vi/vim的三种模式

vi/vim主要分为三种模式，分别是命令模式（Command mode），输入模式（Insert mode）和底线命令模式（Last line mode）。

这三种模式的作用分别是：

命令模式

用户刚刚启动 vi/vim，便进入了命令模式。 任何时候，不管用户处于何种模式，只要按一下ESC键，即可使Vi进入命令模式；

此状态下敲击键盘动作会被Vim识别为命令，输入: 可切换到底线命令模式，以在最底一行输入命令。

若想要编辑文本：启动Vim，进入了命令模式，按下i，切换到输入模式。

输入模式

在命令模式下输入插入命令i、附加命令a 、打开命令o、修改命令c、取代命令r或替换命令s都可以进入文本输入模式。在该模式下，用户输入的任何字符都被Vi当做文件内容保存起来，并将其显示在屏幕上。在文本输入过程中，若想回到命令模式下，按键ESC即可。

底行模式

在命令模式下按下:（英文冒号）就进入了底行命令模式。

底线命令模式可以输入单个或多个字符的命令，可用的命令非常多。

在底线命令模式中，基本的命令有（已经省略了冒号）：

• q 退出程序
• w 保存文件

按ESC键可随时退出底线命令模式。

vim基础操作

进入输入模式(Insert mode)

• i: 插入光标前一个字符

• I: 插入行首

• a: 插入光标后一个字符

• A: 插入行未

• o: 向下新开一行,插入行首

• O: 向上新开一行,插入行首

在进入输入模式后， vi 画面的左下角处会出现『–INSERT–』的字样

进入替换模式(Replace mode)

• r : 只会取代光标所在的那一个字符一次
• R: 会一直取代光标所在的文字，直到按下ESC为止

在进入输入模式后， vi 画面的左下角处会出现『–REPLACE–』的字样

命令模式下常用命令

移动光标

删除操作

撤销&复原&重复

复制&粘贴

合成行

• J: 将光标所在行与下一行的数据结合成同一行

搜索

替换

底行命令模式的常用操作

示例：

将当前路径插入到光标的下一行:r!pwd

可视模式

v 进入字符可视化模式： 文本选择是以字符为单位的。
V 进入行可视化模式： 文本选择是以行为单位的。
Ctrl+v 进入块可视化模式 ： 选择一个矩形内的文本。

可视模式下可进行如下操作：

可视模式下，选中的区域是由两个端点来界定的（一个在左上角，一个在右下角），在默认情况下只可以控制右下角的端点，而使用o按键则可以在左上角和右下角之间切换控制端点。

Linux系统启动过程

Linux系统的启动过程可以分为5个阶段：

• 内核的引导。
• 运行 init。
• 系统初始化。
• 建立终端 。
• 用户登录系统。

加载内核

当计算机打开电源后，首先是BIOS开机自检，按照BIOS中设置的启动设备（通常是硬盘）来启动。

操作系统接管硬件以后，首先读入 /boot 目录下的内核文件。

启动初始化进程init

内核文件加载以后，就开始运行第一个程序 /sbin/init，它的作用是初始化系统环境。

init程序首先是需要读取配置文件/etc/inittab。

CentOS 各版本init配置文件的位置：

• SysV: init, CentOS 5之前, 配置文件： /etc/inittab。
• Upstart: init,CentOS 6, 配置文件： /etc/inittab, /etc/init/*.conf。
• Systemd： systemd, CentOS 7,配置文件： /usr/lib/systemd/system、 /etc/systemd/system。

由于init是第一个运行的程序，它的进程编号（pid）就是1。其他所有进程都从它衍生，都是它的子进程。

确定运行级别

许多程序需要开机启动。它们在Windows叫做"服务"（service），在Linux就叫做"守护进程"（daemon）。

init进程的一大任务，就是去运行这些开机启动的程序。

但是，不同的场合需要启动不同的程序，比如用作服务器时，需要启动Apache，用作桌面就不需要。

Linux允许为不同的场合，分配不同的开机启动程序，这就叫做"运行级别"（runlevel）。也就是说，启动时根据"运行级别"，确定要运行哪些程序。

Linux系统有7个运行级别(runlevel)：

• 运行级别0：系统停机状态，系统默认运行级别不能设为0，否则不能正常启动
• 运行级别1：单用户工作状态，root权限，用于系统维护，禁止远程登陆
• 运行级别2：多用户状态(没有NFS)
• 运行级别3：完全的多用户状态(有NFS)，登陆后进入控制台命令行模式
• 运行级别4：系统未使用，保留
• 运行级别5：X11控制台，登陆后进入图形GUI模式
• 运行级别6：系统正常关闭并重启，默认运行级别不能设为6，否则不能正常启动

可以使用运行级别执行关机或重启：

init 0关机init 6重启

加载开机启动程序

在init的配置文件中有这么一行： si::sysinit:/etc/rc.d/rc.sysinit它调用执行了/etc/rc.d/rc.sysinit，而rc.sysinit是一个bash shell的脚本，它主要是完成一些系统初始化的工作，rc.sysinit是每一个运行级别都要首先运行的重要脚本。

它主要完成的工作有：激活交换分区，检查磁盘，加载硬件模块以及其它一些需要优先执行任务。

l5:5:wait:/etc/rc.d/rc 5

这一行表示以5为参数运行/etc/rc.d/rc，/etc/rc.d/rc是一个Shell脚本，它接受5作为参数，去执行/etc/rc.d/rc5.d/目录下的所有的rc启动脚本，/etc/rc.d/rc5.d/目录中的这些启动脚本实际上都是一些连接文件，而不是真正的rc启动脚本，真正的rc启动脚本实际上都是放在/etc/rc.d/init.d/目录下。

而这些rc启动脚本有着类似的用法，它们一般能接受start、stop、restart、status等参数。

/etc/rc.d/rc5.d/中的rc启动脚本通常是K或S开头的连接文件，对于以 S 开头的启动脚本，将以start参数来运行。

而如果发现存在相应的脚本也存在K打头的连接，而且已经处于运行态了(以/var/lock/subsys/下的文件作为标志)，则将首先以stop为参数停止这些已经启动了的守护进程，然后再重新运行。

这样做是为了保证是当init改变运行级别时，所有相关的守护进程都将重启。

至于在每个运行级中将运行哪些守护进程，用户可以通过chkconfig或setup中的"System Services"来自行设定。

用户登录

一般来说，用户的登录方式有三种：

• （1）命令行登录
• （2）ssh登录
• （3）图形界面登录

对于运行级别为5的图形方式用户来说，他们的登录是通过一个图形化的登录界面。登录成功后可以直接进入 KDE、Gnome 等窗口管理器。

而本文主要讲的还是文本方式登录的情况：当我们看到mingetty的登录界面时，我们就可以输入用户名和密码来登录系统了。

Linux 的账号验证程序是login，login会接收mingetty传来的用户名作为用户名参数。

然后login会对用户名进行分析：如果用户名不是root，且存在 /etc/nologin 文件，login 将输出 nologin 文件的内容，然后退出。

这通常用来系统维护时防止非root用户登录。只有/etc/securetty中登记了的终端才允许 root 用户登录，如果不存在这个文件，则root用户可以在任何终端上登录。

/etc/usertty文件用于对用户作出附加访问限制，如果不存在这个文件，则没有其他限制。

图形模式与文字模式的切换方式

Linux预设提供了六个命令窗口终端机让我们来登录。

默认我们登录的就是第一个窗口，也就是tty1，这个六个窗口分别为tty1,tty2 … tty6，你可以按下Ctrl + Alt + F1 ~ F6 来切换它们。

如果你安装了图形界面，默认情况下是进入图形界面的，此时你就可以按Ctrl + Alt + F1 ~ F6来进入其中一个命令窗口界面。

当你进入命令窗口界面后再返回图形界面只要按下Ctrl + Alt + F7 就回来了。

如果你用的vmware 虚拟机，命令窗口切换的快捷键为 Alt + Space + F1~F6. 如果你在图形界面下请按Alt + Shift + Ctrl + F1~F6 切换至命令窗口。

login shell

shell，简单说就是命令行界面，让用户可以直接与操作系统对话。用户登录时打开的shell，就叫做login shell。

（1）命令行登录：首先读入 /etc/profile，这是对所有用户都有效的配置；然后依次寻找下面三个文件，这是针对当前用户的配置。

~/.bash_profile~/.bash_login~/.profile

需要注意的是，这三个文件只要有一个存在，就不再读入后面的文件了。比如，要是 ~/.bash_profile 存在，就不会再读入后面两个文件了。

（2）ssh登录：与第一种情况完全相同。

（3）图形界面登录：只加载 /etc/profile 和 _{/.profile。也就是说，}/.bash_profile 不管有没有，都不会运行。

Linux关机

sync 将数据由内存同步到硬盘中。shutdown 关机指令，你可以man shutdown 来看一下帮助文档。例如你可以运行如下命令关机：shutdown –h 10 'This server will shutdown after 10 mins' 计算机将在10分钟后关机，并且显示信息在登陆用户的当前屏幕中。shutdown –h now 立马关机shutdown –h 20:25 系统会在今天20:25关机shutdown –h +10 十分钟后关机shutdown –r now 系统立马重启shutdown –r +10 系统十分钟后重启reboot 就是重启，等同于 shutdown –r nowhalt 关闭系统，等同于shutdown –h now 和 poweroff

最后总结一下，不管是重启系统还是关闭系统，首先要运行sync命令，把内存中的数据写到磁盘中。

关机的命令有 shutdown –h now halt poweroff 和 init 0 , 重启系统的命令有 shutdown –r now reboot init 6。

计算机启动的流程

boot是bootstrap（鞋带）的缩写，它来自一句谚语：

“pull oneself up by one’s bootstraps”

字面意思是"拽着鞋带把自己拉起来"，这当然是不可能的事情。最早的时候，工程师们用它来比喻，计算机启动是一个很矛盾的过程：必须先运行程序，然后计算机才能启动，但是计算机不启动就无法运行程序！

早期真的是这样，必须想尽各种办法，把一小段程序装进内存，然后计算机才能正常运行。所以，工程师们把这个过程叫做"拉鞋带"，久而久之就简称为boot了。

计算机的整个启动过程分成四个阶段。

第一阶段：BIOS

上个世纪70年代初，“只读内存”（read-only memory，缩写为ROM）发明，开机程序被刷入ROM芯片，计算机通电后，第一件事就是读取它。

BIOS全称是Basic Input/Output System，即基本输入输出系统，即下图芯片里的程序。

硬件自检

BIOS程序首先检查，计算机硬件能否满足运行的基本条件，这叫做"硬件自检"（Power-On Self-Test），缩写为POST。

如果硬件出现问题，主板会发出不同含义的蜂鸣，启动中止。如果没有问题，屏幕就会显示出CPU、内存、硬盘等信息。

启动顺序

硬件自检完成后，BIOS把控制权转交给下一阶段的启动程序。

下一阶段的启动程序根据BIOS设置项Boot Sequence（启动顺序）决定，排在前面的设备就是优先转交控制权的设备。

第二阶段： 主引加粗样式导记录

BIOS按照"启动顺序"，把控制权转交给排在第一位的储存设备。

这时，计算机读取该设备的第一个扇区，也就是读取最前面的512个字节。如果这512个字节的最后两个字节是0x55和0xAA，表明这个设备可以用于启动；如果不是，表明设备不能用于启动，控制权于是被转交给"启动顺序"中的下一个设备。

这最前面的512个字节，就叫做"主引导记录"（Master boot record，缩写为MBR）。

主引导记录组成

主引导记录由三个部分组成：

（1） 第1-446字节：调用操作系统的机器码。

（2） 第447-510字节：分区表（Partition table），共64字节。

（3） 第511-512字节：主引导记录签名（0x55和0xAA）。

其中，第二部分"分区表"的作用，是将硬盘分成若干个区。

分区表

硬盘分区有很多好处。每个分区可以安装不同的操作系统，"主引导记录"因此必须知道将控制权转交给哪个区。

分区表的长度只有64个字节，里面又分成四项，每项16个字节。所以，一个硬盘最多只能分四个一级分区，又叫做"主分区"。

每个主分区的16个字节，由6个部分组成：

（1） 第1个字节：如果为0x80，就表示该主分区是激活分区，控制权要转交给这个分区。四个主分区里面只能有一个是激活的。

（2） 第2-4个字节：主分区第一个扇区的物理位置（柱面、磁头、扇区号等等）。

（3） 第5个字节：主分区类型。

（4） 第6-8个字节：主分区最后一个扇区的物理位置。

（5） 第9-12字节：该主分区第一个扇区的逻辑地址。

（6） 第13-16字节：主分区的扇区总数。

最后的四个字节（“主分区的扇区总数”），决定了这个主分区的长度。也就是说，一个主分区的扇区总数最多不超过2的32次方。

如果每个扇区为512个字节，就意味着单个分区最大不超过2TB。再考虑到扇区的逻辑地址也是32位，所以单个硬盘可利用的空间最大也不超过2TB。如果想使用更大的硬盘，只有2个方法：一是提高每个扇区的字节数，二是增加扇区总数。

第三阶段：硬盘启动

这时，计算机的控制权就要转交给硬盘的某个分区了，这里又分成三种情况。

情况A：卷引导记录

上一节提到，四个主分区里面，只有一个是激活的。计算机会读取激活分区的第一个扇区，叫做"卷引导记录"（Volume boot record，缩写为VBR）。

"卷引导记录"的主要作用是，告诉计算机，操作系统在这个分区里的位置。然后，计算机就会加载操作系统了。

情况B：扩展分区和逻辑分区

随着硬盘越来越大，四个主分区已经不够了，需要更多的分区。但是，分区表只有四项，因此规定有且仅有一个区可以被定义成"扩展分区"（Extended partition）。

所谓"扩展分区"，就是指这个区里面又分成多个区。这种分区里面的分区，就叫做"逻辑分区"（logical partition）。

计算机先读取扩展分区的第一个扇区，叫做"扩展引导记录"（Extended boot record，缩写为EBR）。它里面也包含一张64字节的分区表，但是最多只有两项（也就是两个逻辑分区）。

计算机接着读取第二个逻辑分区的第一个扇区，再从里面的分区表中找到第三个逻辑分区的位置，以此类推，直到某个逻辑分区的分区表只包含它自身为止（即只有一个分区项）。因此，扩展分区可以包含无数个逻辑分区。

但是，似乎很少通过这种方式启动操作系统。如果操作系统确实安装在扩展分区，一般采用下一种方式启动。

情况C：启动管理器

在这种情况下，计算机读取"主引导记录"前面446字节的机器码之后，不再把控制权转交给某一个分区，而是运行事先安装的"启动管理器"（boot loader），由用户选择启动哪一个操作系统。

Linux环境中的启动管理器例如Grub。

第四阶段：操作系统

控制权转交给操作系统后，操作系统的内核首先被载入内存。

以Linux系统为例，先载入/boot目录下面的kernel。内核加载成功后，第一个运行的程序是/sbin/init。它根据配置文件（Debian系统是/etc/initab）产生init进程。这是Linux启动后的第一个进程，pid进程编号为1，其他进程都是它的后代。

然后，init线程加载系统的各个模块，比如窗口程序和网络程序，直至执行/bin/login程序，跳出登录界面，等待用户输入用户名和密码。

至此，全部启动过程完成。

单用户模式修改Centos系统root密码

步骤如下：

重启linux系统

3 秒之内要按一下回车，出现如下界面

按向下方向键移动到第二行，按"e"进入编辑模式

在 第二行最后边输入 single，用空格与前面内容隔开

回车

最后按"b"启动，启动后就进入了单用户模式了

进入到单用户模式后，就可以使用passwd命令任意更改root密码了：

救援模式修改Ubuntu系统root密码

重启，按住shift键，出现如下界面，选中如下选项

按回车键进入如下界面，然后选中最新的recovery mode选项

按e进入如下界面，找到图中红色框的recovery nomodeset并将其删掉，再在这一行的后面输入

quiet splash rw init=/bin/bash

接着按F10或者Ctrl+x 后出现如下界面，在命令行内输入passwd后进行修改密码即可

修改完之后重启系统。

虚拟机

三种网络模式

桥接

在网络网卡上安装了一个桥接协议，让这块网卡处于混杂模式，可以同时连接多个网络的做法。

桥接下，类似于把物理主机虚拟为一个交换机，所有桥接设置的虚拟机连接到这个交换机的一个接口上，物理主机也同样查在这个交换机当中，所以所有桥接下网卡与网卡都是交换模式的，相互可以访问而不干扰。

Host-only（仅与主机通信）

虚拟机使用VMnet1网卡与主机单独组网,主机对于虚拟机相当于路由器

NAT

虚拟机使用VMnet8网卡与主机单独组网,主机对于虚拟机相当于路由器，VMnet8网卡通过NAT地址转换协议与物理机网卡通信

常见问题

修改静态地址后发现无法ping外网

需要设置网关route add default gw 192.168.33.1添加nameservervi /etc/resolv.confnameserver 192.168.33.1

虚拟机克隆后eth0消失

直接修改  /etc/sysconfig/network-script/ifcfg-eth0删掉UUID  HWADDR配置静态地址然后：rm -rf 　/etc/udev/rules.d/70-persistent-net.rules然后 reboot