Linux Shell 脚本攻略笔记

Mon, Jul 15, 2019

Linux Shell 脚本攻略笔记[速查]

[toc]

Linux Shell 脚本攻略的笔记，markdown 编写，可以速查(ctrl+f)

资源[](#资源)

shell script[](#shell-script)

#!/bin/bash
# do something

run shell script[](#run-shell-script)

sh script.sh

or

chmod a+x script.sh
./script.sh
# 会读取首行的解释器, 执行

cmd

cmd1; cmd2

or

cmd1
cmd2

echo[](#echo)

echo 的功能正如其名，就是基于标准输出打印一段文本

echo "welcome to bash"
echo welcome to bash

使用不带引号的 echo 时，无法显示分号

使用单引号 echo 时，bash 不会对单引号中变量求值 ‘\$var’

echo 中转义换行符

默认情况，echo 将换行标志追加到文本尾部，可以忽略结尾换行符

echo -n 'test\n'

对字符串进行转义

echo -e '1\t2\t3'

打印彩色输出

文字颜色码
    重置0
    黑色30
    红色31
    绿色32
    黄色33
    蓝色34
    洋红35
    青色36
    白色37

echo -e "\e[1;31m This is red test \e[0m"

背景颜色码
    重置0
    黑色40
    红色41
    绿色42
    黄色43
    蓝色44
    洋红45
    青色46
    白色47

echo -e "\e[1;42m Green Background \e[0m"

printf[](#printf)

可以格式化字符串, 使用参数同 c 中 printf 一样

printf "hello world"

默认不会加换行符, 需要手动添加

printf "%-5s %-10s %-4.2f\n" 3 Jeff 77.564

3    Jeff      77.56

环境变量和变量[](#环境变量和变量)

bash 中，每个变量的值都是字符串，无论你给变量赋值时是否使用引号，值都会以字符串的形式存储

环境变量

查看所有与此终端进程相关的环境变量

env

查看某个进程的环境变量

cat /proc/$PID/environ

变量赋值

var=value
var='the value'
var="the $PARAM"

echo $var
echo ${var}

var = value非变量赋值是相等操作

环境变量

未在当前进程中定义，而是从父进程中继承而来的变量
export 设置环境变量,之后,从当前shell 执行的任何程序都会继承这个变量

export PYTHONPATH=$PYTHONPATH:/home/ken/workspace

常用的环境变量

PATH 查找可执行文件路径, 通常定义在/etc/environment or /ect/profile or ~/.bashrc
修改:        export PATH=$PATH:/new/path/
HOME
PWD
USER
UID
SHELL

获取字符串长度

length=${#var}

识别当前 shell 版本

echo $SHELL
    /bin/bash
echo $0
    bash

检查是否为超级用户 or 普通用户

root的UID=0

if [ $UID -ne 0 ]
then
    echo "not root user"
else
    echo "root"
fi

修改 bash 的提示字符

设置PS1变量
\u用户名
\h主机名
\w当前工作目录

pgrep[](#pgrep)

获取某个进程名对应进程 id

pgrep gedit

shell 数学运算[](#shell数学运算)

整数运算

let

no1=4
no2=5
let result=no1+no2

let no1++
let no2--
let no1+=7
let no2-=7

expr(少用)

result=`expr 3 + 4`
result=$(expr $no1 + 5)

其他方法

result=$[ no1 + no2 ]
result=$[ $no + 5 ]

result=$(( no1 + 5 ))

浮点数

echo "4 * 0.56" | bc
设定精度
echo "scale=2;3/8" | bc
进制转换
echo "obase=2;100" | bc
平方
echo "10^10" | bc
平方根
echo "sqrt(100)" | bc

命令状态[](#命令状态)

当命令成功完成, 返回 0

发生错误并退回, 返回非 0

可以从$?中获取 cmd; echo $?

文件描述符和重定向[](#文件描述符和重定向)

文件描述符: 与文件输入/输出相关联的整数, 用来跟踪已打开的文件

0 stdin  标砖输入
1 stdout 标准输出
2 stderr 标准错误

重定向到文件

清空文件写入新内容
echo "test" > temp.txt
追加
echo "test" >> temp.txt

>等价于1>
>>等价于 1>>

输出分离或合并

分离
cmd 2>stderr.txt  1>stdout.txt

合并
cmd > output.txt 2>&1
or
cmd &> output.txt

扔到垃圾桶

/dev/null 特殊设备文件, 接收到的任何数据都会被丢弃(位桶/黑洞)

只有标准错误
cmd 2 > /dev/null

标准输出和标准错误
cmd >/dev/null 2>&1

同时输出到终端和文件

cmd | tee file1

tee默认覆盖，可以-a选项追加
cmd | tee -a file1

将 stdin 作为命令参数

cmd1 | cmd2 | cmd3 -

将文件重定向到命令

cmd < file

自定义文件描述符

使用文件描述符3打开并读取文件
exec 3<input.txt
cat <&3

使用文件描述符4进行写入
exec 4>output.txt
echo newline >&4

cat[](#cat)

cat, concatenate(拼接)

“cat”代表了连结（Concatenation），连接两个或者更多文本文件或者以标准输出形式打印文件的内容

一般格式

cat file1 file2 file3

从管道中读取
OUTPUT_FROM_SOME_CMDS | cat

echo "test" | cat - file1

压缩空白行, 多个连续空行变成单个

cat -s  file

配合 tr 移除空白行

cat file | tr -s '\n' #连续多个\n -> \n

加行号

cat -n file

显示制表符等

cat -T file

cat f > t
注意：“>>”和“>”调用了追加符号。它们用来追加到文件里，而不是显示在标准输出上。
“>”符号会删除已存在的文件，然后创建一个新的文件。
所以因为安全的原因，建议使用“>>”，它会写入到文件中，而不是覆盖或者删除。

输入多行文字(CTRL + d 退出)

cat > test.txt

数组和关联数组[](#数组和关联数组)

普通数组，整数作为数组索引, 借助索引将多个独立的数据存储为一个集合(list)

关联数组，可以使用字符串作为索引(map)

数组

定义

array_var=(1 2 3 4 5)

or
array_var[0]="test1"
array_var[3]="test3"

读取

echo ${array_var[0]}

以清单形式打印

echo ${array_var[*]}
echo ${array_var[@]}

长度

echo ${#array_var[*]}

获取索引列表

echo ${!array_var[*]}

关联数组

declare -A ass_array

内嵌索引-值
ass_array=([index1]=value1 [index2]=value2)

独立
ass_array[index3]=value3

echo ${ass_array[index1]}

alias[](#alias)

alias 是一个系统自建的 shell 命令，允许你为名字比较长的或者经常使用的命令指定别名。

alias new_command='command seq'
unalias new_command

使用原生命令
\new_command

date[](#date)

“date”命令使用标准的输出打印当前的日期和时间，也可以深入设置

读取日期

date

时间戳

date +%s

日期转换为时间戳

date --date "Thu Nov 18 08:07:21 IST 2010" +%s

日期格式化

星期  %a  Sat
      %A  Saturday
月    %b  Nov
      %B  November
日    %d  31
固定日期格式mm/dd/yy     %D
年    %y  10
      %Y  2010
小时  %I/%H    08
分钟  %M  33
秒    %S  10
纳秒  %N  696308515
Unix纪元时  %s

格式化

date "+%Y %B %d"

date +%Y-%m-%d
输出： 2011-07-28
date +"%Y-%m-%d %H:%M:%S"

设置日期和时间

date -s "格式化日期字符串"

date -s "21 June 2009 11:01:22"

延时

sleep number_of_seconds

两天后及两天前

date -d '2 days' +%Y%m%d
date -d '2 days ago' +%Y%m%d

某一天的几天前

TODAY=`date +%Y%m%d`
DAY_1_AGO=`date -d "$TODAY 1 days ago" +%Y%m%d`

时间戳日期转换

date -d @1193144433
date -d @1193144433 "+%Y-%m-%d %T"

反向:
date -d "2007-10-23 15:00:23" "+%s"

赋值给变量

DATE=$(date +%Y%m%d)
DATE=`date +%Y%m%d`

调试脚本[](#调试脚本)

打印出所执行的每一行命令

bash -x script.sh
sh -x script.sh

在脚本中设置开关

set -x 在执行时显示参数和命令
set +x 关闭调试
set -v 当命令进行读取时显示输入
set +v 禁止打印输入

直接修改脚本

#!/bin/bash -xv

函数和参数[](#函数和参数)

定义函数

function fname()
{
    statements;
}
or
fname()
{
    statements;
}

调用

fname;
传参
fname arg1 arg2;

接收参数

$1第一个参数
$2第二个参数
$n第n个参数

"$@"被扩展成 "$1" "$2" "$3"
"$*"扩展成"$1c$2c$3", 其中c是IFS第一个字符

"$@"使用最多, $*将所有的参数当做单个字符串

bash 支持递归

导出函数,可以作用到子进程中

export -f fname

函数及命令返回值

cmd;
echo $?

退出状态，成功退出，状态为0，否则，非0

cmd
if [ $? -eq 0 ]
then
    echo "success"
else
    echo "fail"
fi

管道[](#管道)

前一个命令的输出作为后一个命令的输入

$cmd1 | cmd2 | cmd3

读取命令输出[](#读取命令输出)

子shell  subshell
cmd_output=$(COMMANDS)
or
反引用
cmd_output=`COMMANDS`

子 shell 本身是独立进程, 不会对当前 shell 有任何影响

pwd;
(cd /bin; ls)
pwd #同上一个pwd

保留空格和换行符

out=$(cat text.txt)
echo $out  #丢失所有换行符

out="$(cat text.txt)"
echo $out  #保留

cat a
1
2
3
echo $(cat a)
1 2 3
echo "$(cat a)"
1
2
3

read[](#read)

read, 用于从键盘或标准输入中读取文本

读取 n 个字符存入变量

read -n number_of_chars variable_name

不回显的方式读取密码

read -s var

显示提示信息

read -p "Enter input:" var

限时输入

read -t  timeout var

设置界定符

read -d delim_char var
read -d ":" var
hello:

字段分隔符和迭代器[](#字段分隔符和迭代器)

内部字段分隔符，Internal Field Separator, IFS

IFS 默认为空白字符（换行符，制表符，空格）

data="name,sex,rollno"
oldIFS=$IFS
IFS=,
for item in $data
do
        echo $item
done

IFS=$oldIFS

循环[](#循环)

for 循环

echo {1..50}

for i in {a..z}; do actions; done;

or

for((i=0;i<10;i++))
{
    commands;
}

while 循环

while condition
do
    commands;
done

until 循环

until condition
do
    commands;
done

比较和测试[](#比较和测试)

if 条件

if condition;
then
    commands;
elif condition;
then
    commands;
else
    commands;
fi

逻辑运算符进行简化, 短路运算更简洁

[ condition ] && action;
[ condition ] || action;

算术比较

-gt 大于
-lt 小于
-ge 大于等于
-le 小于等于
-ne 不等于
-eq 等于

注意[]和操作数之间的空格
[ $var -eq 0 ]

and
[ $var -ne 0 -a $var2 -ge 2 ]
or
[ $var -ne 0 -o $var2 -ge 2 ]

文件测试

[ -f $file_var ] 正常文件路径或文件名
[ -x $var ] 可执行
-d 目录
-e 存在
-c 字符设备文件
-b 块设备文件
-w 可写
-r 可读
-L 符号链接

字符串比较

[[ $str1 = $str2 ]]
[[ $str1 == $str2 ]]

[[ $str1 != $str2 ]] 不等

[[ $str1 > $str2 ]]
[[ $str1 < $str2 ]]

[[ -z $str1 ]]  空
[[ -n $str1 ]]  非空

if [[ -n $str1 ]] && [[ -z $str2 ]]
then
    commands;
fi

find[](#find)

搜索指定目录下的文件，从开始于父目录，然后搜索子目录

基本

find base_path

# 打印文件和目录列表
find . -print  #默认\n分割文件名

文件名

find path -name "*.txt" -print
          -iname  忽略大小写

多个条件 or
find . \( -name "*.txt" -o -name "*.py" \)

文件路径

通配符
find /home/users -path "*slynux*" -print

正则
find . -regex ".*\(\.py\|\.sh\)$"
       -iregex 忽略大小写

否定参数

find . ! -name "*.txt" -print

根据文件类型

find . -type d -print
f 普通文件
l 符号链接
d 目录
c 字符设备
b 块设备
s 套接字
p Fifo

设定目录深度

find . -maxdepth 1 -type f -print
find . -mindepth 2 -type f -print

根据文件时间搜索

计量单位 天
-atime 最近一次访问时间
-mtime 最后一次被修改时间
-ctime 文件元数据，最近一次修改时间

find . -type f -atime -7 -print #最近七天内被访问的
find . -type f -atime 7 -print  #恰好在七天前
                      +7 -print #超过七天

计量单位 分钟
-amin 访问时间
-mmin 修改时间
-cmin 变化时间

find . -type f -amin +7 -print #访问时间超过7分钟的

find . -type f -newer file.txt -print  #用于比较时间戳的参考文件，比参考文件更新的文件

基于文件大小的搜索

find . -type f -size +2k
+ 大于  -小于   无符号，恰好等于

b 块
c 字节
w 字（2字节）
k 千字节
M 兆字节
G 吉字节

删除匹配的文件

find . -type f -name "*.swp" -delete
#注意：-delete位置一定是最后

文件权限及所有权

find . -type f -perm 644 -print

find . -type f -user slynux -print

执行命令或动作(最强大的命令)

find . -type f -user root -exec chown slynux {} \;
find . -type f -exec cp {} OLD \;
find . -iname "abc.txt" -exec md5sum {} \;

{} 江北替换成对应文件名
exec无法结合多个命令，可以将多个命令放入脚本，调用之

跳过指定目录

find . \( -name ".git" -prune \) -name '*.txt'

xargs[](#xargs)

将标准输入数据转化成命令行参数

将 stdin 接收到的数据重新格式化，再将其作为参数传给其他命令

多行输入转化成单行输出

cat  example.txt | xargs  #空格替换掉\n

切成多行，每行 n 个参数

cat examplet.txt | xargs -n 3

可以指定分隔符

echo "aaaXbbbXccc" | xargs -d 'X'

将参数传递给脚本(类似循环)

cat args.txt | xargs -n 1 ./cecho.sh

./cecho.sh -p arg1 1
需要变更
cat args.txt | xargs -I {} ./cecho.sh -p {} 1

find 与 xargs 组合

find . -type f -name "*.txt" -print | xargs rm -rf

其他

cat file | ( while read arg; do cat $arg; done )
cat file | xargs -I {} cat {}

tr[](#tr)

tr 可以对来自标准输入的字符进行替换，删除以及压缩(translate, 可以将一组字符变成另一组字符)

tr 只能通过 stdin，无法通过其他命令行进行接收参数

格式

tr [options] source-char-set replace-char-set

选项

-c 取source-char-set补集，通常与-d/-s配合
-d 删除字source-char-set中的所列的字符
-s 浓缩重复字符，连续多个变成一个

字符替换

cat /proc/12501/environ | tr '\0' '\n'

大小写替换

echo  "HELLO" | tr 'A-Z' 'a-z'
cat text | tr '\t' ' '

删除字符

echo "hello 123 world 456"| tr -d '0-9'
hello  world

字符集补集

echo "hello 1 char 2" | tr -d -c '0-9'  #删除非0-9
12

压缩字符

连续的重复字符

echo "GNU is    not UNix" | tr -s ' '

字符类

alnum 字母和数字
alpha 字母
cntrl 控制字符
digit 数字
graph 图形字符
lower 小写字母
print 可打印字符
punct 标点符号
space 空白字符
upper 大写字母
xdigit 十六进制字符

tr '[:lower:]' '[:upper:]'

md5sum[](#md5sum)

32 个字符的十六进制串

md5sum filename
md5sum filename1 filename2

sha1sum[](#sha1sum)

40 个字符十六进制串

sha1sum file

需安装 md5deep 软件包

md5deep/sha1deep
md5deep -rl dirname
         r递归，l相对路径

sort[](#sort)

语法

sort [options] [file(s)]

-c 检查是否已排序
-u 丢弃所有具有相同键值的记录

-b 忽略开头空白
-d 字典序
-g 一般数值，以浮点数类型比较字段，仅支持gnu
-i 忽略无法打印的字符

-k 定义排序键值字段
-n 以整数类型比较字段
-r 倒转
-o 输出到指定文件

排序

sort file1 > file1.sorted
sort -o file1.sored file1

按数字, 要明确

sort -n file1

逆序

sort -r file

测试一个文件是否已经被排过序

sort -C file
if [ $? -eq 0 ]; then
    echo ssss
fi

合并两个排过序的文件，并不需要对合并后的文件进行再排序

sort -m sorted1 sorted2

根据键或者列排序(按照哪一个列)

sort -k 1 data

限定特定范围内一组字符

key=char4-char8
sort -k 2,3 data

sort -k2.4,5.6 file
第二个字段的第四个字符开始比较，直到第五个字段的第六个字符

忽略前导空白及字典序排序

sort -bd unsorted.txt

去重

sort a.txt | uniq
sort -u a.txt

uniq[](#uniq)

用法

uniq file

只显示未重复的记录

uniq -u file

找出重复的行

uniq -d file
-s 可指定跳过前N个字符
-w 指定用于比较的最大字符数

统计各行出现的次数

uniq -c file

p57

tempfile[](#tempfile)

只有在基于 Debian 的发布版才有(Ubuntu/Debian)

temp_file=$(tempfile)
等同
temp_file="/tmp/file-$RANDOM"

#$$为进程id
temp_file="/tmp/var.$$"

split[](#split)

按大小分割文件, 单位 k(KB), M, G, c(byte), w(word)

split -b 10k data.file

-d 数字后缀，-a 后缀长度

split -b 10k data.file -d -a 4

分割后指定文件名前缀

split -b 10k data.file file_prefix

设置后缀格式，可以用这个
split -b 10k data.file -d -a 4 file_prefix

根据行数分割

spilt -l 10 data
可以用这个
split -l 10000  table_ods_orc_1e.csv  -d -a 3 split_file

其扩展是 csplit，可根据文件特性切分，关注

bash 变量匹配切分[](#bash变量匹配切分)

sample.jpg

file_jpg="sample.jpg"

从右向左匹配
${file_jpg%.*}
#sample

从左向右匹配
${file_jpg#.*}
#jpg

% # 属于非贪婪
%% ## 属于贪婪

贪婪非贪婪

var=hack.fun.book.txt
${var%.*} #hack.fun.book
${var%%.*} #hack

${var#.*} #fun.book.txt
${var##.*} #txt

expect[](#expect)

实现自动化

spawn ./ineractive.sh
expect "Enter the number"
send "1\n"
expect "Enter name:"
send "hello\n"
expect eof

spawn指定需要自动化的命令
expect提供需要等待的消息
send发送消息
expect eof指明命令交互结束

dd[](#dd)

生成任意大小的文件

# 创建一个1M大小的文件junk.data
bs=2M count=2 则文件大小4M

dd if=/dev/zero of=junk.data bs=1M count=1
   输入文件     输出文件     块大小   复制块数

块大小单位
字节(1B) c
字(2B)   w
块(512B)   b
千字节(1024B) k
兆字节(1024KB) M
吉字节(1024MB) G

comm[](#comm)

两个文件之间比较，输出三列

onleA \t onlyB \t bothAB

comm A B -1 -2 #删除第一第二列
-3 删除第三列

可以得到A^B  A-B B-A

mkdir[](#mkdir)

“mkdir”(Make directory)命令在命名路径下创建新的目录。然而如果目录已经存在了，那么它就会返回一个错误信息”不能创建文件夹，文件夹已经存在了”(“cannot create folder, folder already exists”)

mkdir dirpath

mkdir -p dirpath1/dirpath2

#一次多个目录
mkdir -p /home/user/{test,test1,test2}

注意：目录只能在用户拥有写权限的目录下才能创建

ls[](#ls)

ls 命令是列出目录内容(List Directory Contents)的意思。运行它就是列出文件夹里的内容，可能是文件也可能是文件夹

ls 文件的内容关系

- 普通文件
d 目录
c 字符设备
b 块设备
l 符号链接
s 套接字
p 管道

文件权限序列
rwx
rwS  setuid(S)，特殊权限, 出现在x的位置, 允许用户以其拥有者的权限来执行文件, 即使这个可执行文件是由其他用户运行的

目录
r,允许读取目录中文件和子目录列表
w,允许在目录中创建或删除文件或目录
x,指明是否可以访问目录中的文件和子目录
rwt/rwT 粘滞位，只有创建该目录的用户才能删除目录中的文件，即使用户组和其他用户也有写权限，典型例子/tmp, 写保护

查看目录

ls -d */
ls -F | grep "/$"
ls -l | grep "^d"
find . -type d -maxdepth 1 -print

其他

ls -l    命令已详情模式(long listing fashion)列出文件夹的内容
ls -a    命令会列出文件夹里的所有内容，包括以”.”开头的隐藏文件

chmod[](#chmod)

设置文件权限

“chmod”命令就是改变文件的模式位。chmod 会根据要求的模式来改变每个所给的文件，文件夹，脚本等等的文件模式（权限）。

设置权限

user group others all
u    g     o      a

chmod u=rwx g=rw o=r filename

chmod u+x filename
chomd a+x filename #所有

chmod a-x filename

chmod 764 filename

#设置粘滞位
chmod a+t dirname

#递归改变

chmod 777 . -R

注意：对于系统管理员和用户来说，这个命令是最有用的命令之一了。在多用户环境或者服务器上，对于某个用户，如果设置了文件不可访问，那么这个命令就可以解决，如果设置了错误的权限，那么也就提供了为授权的访问。

chown[](#chown)

每个文件都属于一个用户组和一个用户“chown”命令用来改变文件的所有权，所以仅仅用来管理和提供文件的用户和用户组授权。

改变所有权

chown user.group filename

递归

chown -R user.group .

每次都以其他用户身份执行(允许其他用户以文件所有者的身份来执行)

chomod +s executable_file

chown root.root executable_file
chmod +s executable_file
./executable_file

chattr[](#chattr)

创建不可修改文件

chattr +i file

一旦被设置为不可修改, 任何用户包括超级用户都不能删除该文件, 除非其不可修改的属性被移除

chattr -i file

touch[](#touch)

“touch”命令代表了将文件的访问和修改时间更新为当前时间。

touch 命令只会在文件不存在的时候才会创建它(空白文件)。如果文件已经存在了，它会更新时间戳，但是并不会改变文件的内容。

空白文件

touch filename

for name {1..100}.txt
do
    touch $name
done

修改文件访问时间

touch -a "Fri Jun 25 20:50:14 IST 1999" filename
touch -m #修改文件内容的修改时间

修改文件或目录的时间戳(YYMMDDhhmm)

touch -t 0712250000 file

注意：touch 可以用来在用户拥有写权限的目录下创建不存在的文件。

ln[](#ln)

建立软连接

ln -s target symbolic_link_name

如果目的路径已经存在，而没有指定 -f 标志，ln 命令不会创建新的链接，而是向标准错误写一条诊断消息并继续链接剩下的 SourceFiles。

-f 促使 ln 命令替换掉任何已经存在的目的路径

readlink[](#readlink)

读取链接对应真是路径

readlink web

 readlink ~/.vim
 /Users/ken/github/k-vim

file[](#file)

通过查看文件内容来找出特定类型的文件

打印文件类型信息

file filename

打印不包含文件名在内

file -b filename

e.g.

file /etc/passwd
/etc/passwd: ASCII English text

file -b /etc/passwd
ASCII English text

读文件[](#读文件)

while read line;
do
    something
done < filename

diff[](#diff)

生成文件差异

非一体化

diff version1.txt version2.txt

一体化, 可读性更好

diff -u version.txt

使用 patch 将命令应用于任意一个文件

diff -u version1.txt version2.txt > version.patch
patch -p1 version1.txt < version.patch

递归作用于目录

diff -Naur directory1 directory2

-N 所有缺失的文件作为空文件
-a 所有文件视为文本文件
-u 一体化输出
-r 递归遍历

head[](#head)

前 10 行打印

head file

前 n 行

head -n 4 file

扣除最后 N 行之外的所有行

head -n -5 file

tail[](#tail)

最后 10 行

tail file

打印最后五行

tail -n 5 file
tail -5 file

扣除前 n 行

tail -n +(N+1)

实时动态打印

tail -f growing_file

当某个给定进程结束后, tail 随之终结

tail -f file --PID $PID

pushd/popd[](#pushd-popd)

将当前路径压入栈

pushd

压入某个路径

pushd /home/ken

查看当前路径列表

dirs

切换到某一个

#dirs从左到右编号 0 -
pushd +3

移除最近压入栈的路径并切换到下一个目录

popd

cd[](#cd)

经常使用的“cd”命令代表了改变目录。它在终端中改变工作目录来执行，复制，移动，读，写等等操作

切换到上一目录

cd -

会到 HOME 目录

cd
cd ~

会到上一级目录

cd ..

wc[](#wc)

Word Count

统计行数

wc -l file

统计单词数

wc -w file

统计字符数

wc -c file

统计所有

wc file

统计最长行的长度

wc file -L

tree[](#tree)

以图形化的树状结构打印文件和目录的结构，需要自行安装

tree ~/unixfile

重点标记出匹配某种样式的文件

tree PATH -P "*.sh"

只标记符合样式之外的文件

tree path -I PATTERN

同时打印文件和目录大小

tree -h

grep[](#grep)

文本搜索工具, 支持正则表达式和通配符

‘grep‘命令搜索指定文件中包含给定字符串或者单词的行

基本用法

grep "match_pattern" file1 file2

使用颜色重点标记

grep word filename --color=auto

扩展型使用正则

grep -E "[a-z]+"
egrep "[a-z]+"

只输出匹配到的文本部分

grep -o word filename

除匹配行外的所有行

grep -v word filename

统计匹配行数

grep -c 'text' filename

打印出包含匹配字符串的行数

grep linux -n filename

打印样式匹配所位于的字符或字节的偏移

echo "gnu is not unix" | grep -b -o "not"

搜索多个文件，找出匹配文本位于哪个文件中

grep -l linux file1 file2
取反
grep -L

递归搜索目录

grep -R "text" dir

忽略大小写

grep -i "hello" filename

匹配多个样式

grep -e "pattern1" -e "pattern2" file

运行匹配脚本

grep -f pattern_file source_file

pattern_file:
hello
cool

在搜索中包含、排除文件

grep --include *.{c,cpp} word file

排除

grep --exclude "Readme" filename
--exclude-dir

静默输出，用于判断(不会产生任何输出)

grep -q word file
if [ $? -eq 0 ]

打印匹配行之前，之后的行

grep -A 3 之后3行
grep -B 3 之前
grep -C 3 前后

使用行缓冲

在使用tail -f命令时是可以及时看到文件的变化的，但是如果再加上一个grep命令，可能看到的就不那么及时了，
因为grep命令在buffer写不满时就不输出，可以通过选项  --line-buffered 来搞定，如：

tail -f file.txt | grep something  --line-buffered

cut[](#cut)

语法

cut -c list [ file ... ]
cut -f list [ -d delim ] [ file ...]

-c list 以字符为主，作剪切操作
-f list 以字段为主，作剪切操作

提取字段或列

#第一列
cut -f1 filenam

#第二三列
cut -f2,3 filename

提取补集

cut -f1 --complement filename

指定字段分隔符

cut -d ";" -f2 filename
cut -d : -f 1,5 /etc/passwd

指定字符

-b 字节
-c 字符
-f 字段

cut -c1-5 filename
N-
N-M
-M

ls -l | cut -c 1-10

指定输出分隔符

cut -c1-3,6-9 --output-delimiter ","

join[](#join)

语法

join [options] file1 file2

选项
-1 field1
-2 field2
-o file.field
-t separator

例子

join file1 file2

sed[](#sed)

sed(Stream editor)流编辑器, 可以配合正则使用, 进行替换等

sed 替换语法

sed 's/pattern/replace_string/' file

将结果直接运用于源文件

-i 用于, 直接修改源文件

替换第一个
sed -i 's/pattern/replace_string/' file

替换第二个
sed -i 's/pattern/replace_string/2' file

替换所有
sed -i 's/pattern/replace_string/g' file

从第N处开始替换
sed -i 's/pattern/replcae_string/2g' file

移除空白行

sed '/^$/d' file

已匹配字符串标记

引用匹配到的
sed 's/\w\+/[&]/g' filename

组合多个表达式

sed 'exp1' | sed 'exp2'
等价
sed 'exp1;exp2'

使用引用

sed "s/$text/HELLO/"

子串匹配标记(后向引用，最多 9 个)

sed 's/\([a-z]\+\)' \([A-Z\]\+\)/\2 \1/' filename

保存到文件

sed 's/pattern/replacement/' -i outfile

使用其他分隔符

sed 's#/home/#/tmp/#'

awk[](#awk)

基本结构

awk -F '-' 'BEGIN{statements} {statements} END{statements}' file
表达式中单引号可以换成双引号
BEGIN -> 每一行，执行statements, 执行END

打印某一列

awk -F '-' '{print $0}' file #全部
awk -F '-' '{print $2}' file #第二列

print 拼接字符

awk '{var="v1"; var1="v2"; print var1"-"var2;}'

特殊变量

NR nuber of records, 记录数
NF number of fields, 字段数
$0 当前行文本
$1 第一字段
$2 第二字段
$NF 最后一个字段

FILENAME 当前输入文件的名称
FNR 当前输入文件记录数
FS 字段分隔字符
OFS 输出字段分隔符，默认" "
ORS 输出记录分隔符，默认"\n"

统计行数

awk 'END{print NF}'

将外部变量值传递给 awk

awk -v VARIABLE=$VAR '{ print VARIABLE }'
awk '{print v1, v2}' v1=$var1 v2=$var2

读取行

seq 5 | awk '{ getline var; print var}'

进行行过滤

awk 'NR<5' #行号小于5
awk 'NR==1,NR==4' #行号在1到5之间
awk '/linux/' #包含样式linux
awk '!/linux/' #不包含
awk '$1 ~/jones/' #第一个字段包含jones

tail file
awk 'NR <= 10' file

设定分隔符

awk -F: '{ print $NF }' file

设定输出分隔符

awk -F: -v "OFS=-" '{print $1,$2}' /etc/passwd

打印空行

awk 'NF>0 {print $0}'
or
awk 'NF>0' #未指定action默认打印

print 和 printf

awk -F: '{print "User", $1, "is really", $5}' /etc/passwd
awk -F: '{printf "User %s is really %s\n", $1, $5}' /etc/passwd

awk 中使用循环

for(i=0;i<10;i++) { print $i; }

for(i in array) { print array[i] }

内建函数

length(str)
index(str,search_str)
split(str,array,delimiter) 用界定符生成一个字符串列表
substr(string, start, end) #子串
sub(regex, replacement_str, str) #正则替换首个匹配位置
gsub(regex, replacement_str, string) #最后一个匹配位置
match(string, regex) #检查是否能够匹配字符串
tolower(string) #转小写
toupper(string) #转大写

写成脚本文件

BEGIN {}
pattern1 {action1}
pattern2 {action2}
END {}

文件迭代[](#文件迭代)

读文件行

while read line;
do
    echo $line;
done < file.txt

迭代每个单词

for word in $line;
do
    echo $word;
done

迭代每一个字符

for((i=0;i<${#word};i++))
do
    echo ${word:i:1} ;
done

paste[](#paste)

按列合并文件

paste file1 file2 file3

指定分隔符

paste file1 file2 -d ','

tac[](#tac)

逆序打印

tac file1 file2

rev[](#rev)

接收一个文件或 stdin 作为输入, 逆序打印每一行内容

echo "abc" | rev

wget[](#wget)

Wget 是用于非交互式（例如后台）下载文件的免费工具.支持 HTTP, HTTPS, FTP 协议和 HTTP 代理(选项多, 用法灵活)

一个用于文件下载的命令行工具

wget URL1 URL2

指定保存文件名

wget URL -O local.txt

指定日志，默认达到 stdout

wget URL -O local.txt -o log.txt

指定重复尝试次数

wget -t 5 URL

下载限速

wget --limit-rate 20k url

指定限额

wget -Q 100m url

断点续传

wget -c URL

$ wget -c -t 100 -T 120 http://www.linux.com/xxxx.data

当文件特别大或者网络特别慢的时候，往往一个文件还没有下载完，连接就已经被切断，此时就需要断点续传。
wget的断点续传是自动的。
-c 选项的作用为断点续传。
-t 参数表示重试次数(例如重试100次，-t 100，如果设成-t 0，表示无穷次重试，直到连接成功)
-T 参数表示超时等待时间，例如-T 120，表示等待120秒连接不上就算超时

复制或镜像整个网站

wget --mirror exampledomain.com
wget -r -N -l DEPTH URL
     递归，允许对文件使用时间戳，层级
$ wget -r -np -nd http://www.linux.com/packs/

-np 的作用是不遍历父目录
-nd 表示不在本机重新创建目录结构

访问需要认证的 HTTP/FTP

wget --user username --password pass URL

post 请求

wget url -post-data "name=value" -O output.html

批量下载

wget -i downloads.txt #将文件地址写入一个文件

用 wget 命令执行 ftp 下载

wget -m ftp://username:password@hostname

curl[](#curl)

基本用法

curl url > index.html

不显示进度信息

curl URL --slient

将内容写入文件，而非标准输出

curl URL --slient -O

写入指定文件

curl URL --slient -o filename

显示进度条

curl url -o index.html --progress

断点续传

curl -C - URL

设置参照页字符串

curl --referer Referer_URL target_URL
跳转到target_URL,其头部referer为Referer_URL

设置 cookie

curl url --cookie "user=slynux;pass=hack"
另存为一个文件

curl URL --cookie-jar cookie_file

设置用户代理

curl URL --user-agent "Mozilla/5.0"
头部信息
curl -H "Host: www.slynux.org" -H "Accept-language: en" url

限定下载带宽

curl url --limit-rate 20k

指定最大下载量(可下载的最大文件大小)

curl url --max-filesize bytes
超出限制的话，返回非0

进行认证

curl -u user:pass url

只打印头部信息,不下载远程文件

curl -I url
curl -head url

发送 post 请求

curl URL -d "va1=1&va2=2"
         --data

lynx[](#lynx)

将网页以 ascii 字符形式下载

lynx -dump URL > webpage_as_text.txt

打印出网站的文本板块而非 html

lynx -dump url

生成信息文件

lynx -traversal url

tar[](#tar)

“tar”命令是磁带归档(Tape Archive)，对创建一些文件的的归档和它们的解压很有用。

将多个文件和文件夹保存成单个文件, 同时还能保留所有的文件属性

对文件进行归档

-c create file,创建文件
-f specify filename,指定文件名

tar -cf output.tar file1 file2 file3
tar -cf output.tar *.txt

tar -cvf output.tar *.txt

向归档中追加文件

tar -rvf original.tar new_file
-r,追加

查看过程中更多信息

tar -tvvf archive.tar
-v/-vv, verbose

提取文件或文件夹

-x, exact
tar -xf archive.tar

-C,指定文件
tar -xf archive.tar -C /path/to/extraction_directory


tar -xvf archive.tar

提取指定文件

tar -xvf file.tar file1 file4

拼接两个归档文件

tar -Af file1.tar file2.tar
#file2合并到file1中

只有在文件内容修改时间更新(newer),才进行添加

tar -uvvf archive.tar filea

比较归档文件与文件系统中的内容

tar -df archive.tar filename1 filename2

从归档文件中删除文件

tar -f archive.tar --delete file1 file2

提取到某个目录

 tar zxvf package.tar.gz -C new_dir

压缩归档文件

gzip/gunzip -> .gz
f.tar.gz   -z
tar -czvf
tar -xzvf

bzip/bunzip -> .bz2
f.tar.bz2  -j

f.tar.lzma --lzma
f.tar.lzo

从归档中排除部分文件

tar -cf arch.tar * --exclude "*.txt"
cat list
   filea
   fileb
tar -cf arch.tar * -X list

排除版本控制文件

tar --exclude-vcs -czvvf source.tar.gz files

打印总字节数

tar -cf arc.tar * --exclude "*.txt" --totals

cpio[](#cpio)

使用频率不高

归档，保留文件属性（权限、所有权等）

echo file1 file2 | cpio -ov > archive.cpio
-o 指定输出
-v 打印归档文件列表

列出 cpio 中的文件内容

cpio -it < archive.cpio
-i指定输入
-t列出归档文件中的内容

gzip[](#gzip)

压缩，会删除源文件

gzip filename
#got filename.gz

解压

gunzip filename.gz

列出文件属性信息

gzip -l text.gz

stdin 读入文件并写出到 stdout

cat file | gzip -c > file.gz

压缩归档文件

tar -czvvf archive.tar.gz [files]
or
tar -cvvf archive.tar.gz [files]
gzip archive.tar

指定压缩率

1-9,1最低，但速度最快
gzip -9 test.img

zcat[](#zcat)

无需解压缩，直接从.gz 中提取内容

zcat test.gz

bzip[](#bzip)

更大的压缩率

bzip2 filename

解压缩

bunzip2 filename.bz2

stdin 到 stdout

cat file > bzip2 -c > file.tar.bz2

压缩归档

tar -cjvvf archive.tar.bz2 [files]
or
tar -cvvf archive.tar [files]
bzip2 archive.tar

保留输入文件

bunzip2 test.bz2 -k

压缩率

bzip2 -9 test.img

lzma[](#lzma)

比 gzip/bzip2 更好的压缩率

压缩

lzma filename

解压

unlzma filename.lzma

stdin 到 stdout

cat file | lzma -c > file.lzma

创建归档

tar -cavvf archive.tar.lzma [files]
    -xavf

保留输入文件

lzma test.bz2 -k

压缩率

lzma -9 test.img

zip[](#zip)

压缩

zip archive_name.zip [source files/dirs]

对目录和文件进行递归操作

zip -r archive.zip folder1 file2

base64[](#base64)

编码

base64 filename > outfile
cat file | base64 > outfile

解码

base64 -d file > outfile

md5sum[](#md5sum-1)

“md5sum”就是计算和检验 MD5 信息签名。 md5 checksum(通常叫做哈希)使用匹配或者验证文件的文件的完整性，因为文件可能因为传输错误，磁盘错误或者无恶意的干扰等原因而发生改变。

单向散列

md5sum file
sha1sum file

rsync[](#rsync)

可以对位于不同位置的文件和目录进行备份, 借助差异计算和压缩技术实现最小化数据传输量

要确保远端安装了 openssh

rsync -av source_path dest_path
-a 进行归档  -v打印细节
路径可以使本地，也可以是远端路径

e.g.
rsync -av /home/test /home/backups/ #复制到backups目录下
rsync -av /home/test /home/backups  #创建backups目录, 复制

备份到远程服务器

rsync -av source_path user@host:PATH
可以反向

改善传输速度

rsync -avz source destination

排除文件

rsync -avz source dest --exclude "*.txt"
                       --exclude-from FILEPATH
FILEPATH:
*.bak

更新备份时，删除不存在的文件

rsync -avz source dest --delete

git[](#git)

初始化目录

git init

配置用户信息

git config --global user.name "wklken"
git config --global user.email "wklken@yeah.net"

加到远端

git remote add origin user@remotehost:/home/backup/backup.git
git push origin master

添加

git add *

删除

git rm *.py

标记一个检查点

git commit -m "Commit message"

查看日志

git log

回滚到某个版本

git checkout hashid [ filename ]

克隆

git clone url

dd[](#dd-1)

Dtat Definiton, 要注意参数顺序, 错误的参数会损毁所有数据

可以用来转换和复制文件，大多数时间是用来复制 iso 文件(或任何其它文件)到一个 usb 设备(或任何其它地方)中去，所以可以用来制作 USB 启动器

语法说明

dd if=SOURCE of=TARGET bs=BLOCK_SIZE count=COUNT
if/of  输入/输出文件或设备路径
bs块大小
count 限制复制到目标的字节数

dd if=/dev/zero of=/dev/sda1

#制作iso 从cdrom设备读取所有数据, 创建iso文件
dd if=/dev/cdrom of=cdrom.iso

备份恢复

dd if=/dev/sda1 of=x.img

dd if=x.img of=/dev/sda1

mount[](#mount)

mount 是一个很重要的命令，用来挂载不能自动挂载的文件系统。你需要 root 权限挂载设备。在插入你的文件系统后，

mount --bind /source /destination

首先运行”lsblk”命令，识别出你的设备，然后把分配的设备名记下来。
root@tecmint:~# lsblk
创建一个任何名字的目录，但是最好和引用相关。

root@tecmint:~# su
Password:
root@tecmint:~# cd /dev
root@tecmint:~# mkdir usb
现在将“sdb1”文件系统挂载到“usb”目录.
root@tecmint:~# mount /dev/sdb1 /dev/usb

挂载镜像

mount -o loop file.img /mnt/mount_point

##网络相关

ifconfig[](#ifconfig)

显示网络接口、子网掩码等详细信息

ifconfig
/sbin/ifconfig

打印某个特定网络接口

ifconfig iface_name

e.g.
ifconfig en1

HWaddr     MAC地址
inet addr  ip地址
Bcast      广播地址
Mask       子网掩码

设置网络接口 ip

ifconfig wlan0 192.168.0.80

dns

cat /etc/resolv.conf

host google.com #Dns查找

nslookup google.com #更详细信息

修改 dns/host

echo nameserver IP_ADDRESS >> /etc/resolv.conf

echo ip domain >> /etc/hosts

ping

ping www.baidu.com

路由信息

显示路由表
route

以数字形式显示地址
route -n

设置默认网关

route add default gw 192.168.0.1 wlan0

trace_route, 显示分组途径的所有网关的地址

traceroute google.com

ping[](#ping)

基本

ping ADDRESS  #主机名，域名或ip

PING 命令可以得到 RTT(Round Trip Time), 分组从源到目的主机的往返时间, 单位 ms

限制发送分组数

ping ADDRESS -c COUNT

ping

fping[](#fping)

同时 ping 一组 ip, 而且响应非常快

fping -a ip1 ip2 -g
fping -a 192.160.1/24 -g
fping -a < ip.list

-a, 所有活动主机的ip
-g, 从IP/mask生成的ip地址范围

进行 dns 查询

fping -a -d 2 > /dev/null  < ip.list

lftp[](#lftp)

基本用法

lftp username@ftphost
cd dir
lcd改变本地主机目录
mkdir 创建目录
get/put 下载上传
quit退出

scp[](#scp)

scp 是 secure copy 的缩写, scp 是 linux 系统下基于 ssh 登陆进行安全的远程文件拷贝命令。

linux 的 scp 命令可以在 linux 服务器之间复制文件和目录.

拷贝文件

scp filename user@remotehost:/home/pat
ip或主机名均可

scp SOURCE DESTINATION

递归复制

scp -r dir1 user@remotehost:/home/backup

提高拷贝速度

scp  -c arcfour -r -P20755 dir/ 192.168.2.*:/**/**/data/
-c arcfour 这个算法没有加校验不保证完整性，注意慎用，内网1000M带宽，默认算法速度只能达到30M/s，用arcfour这个算法速度可以达到50-80M/s

SSH[](#ssh)

连接远程

ssh username@remote_host

ssh -p port username@remote_host

执行命令

ssh username@remote_host 'cmd1; cmd2' > stdout.txt 2>errors.txt

压缩功能

ssh -C user@hostname 'cmds'

打通 ssh

1.创建SSH密钥
  ssh-keygen -t rsa
  公钥, ~/.ssh/id_rsa.pub
2.登陆远端服务器, 将公钥写入 ~/.ssh/authorized_keys

lsof[](#lsof)

列出系统中开放端口及运行在端口上的服务

lsof -i

配合 grep, 获取需要的信息

netstat[](#netstat)

查看开放端口和服务

netstat -tnp

##磁盘和系统

du[](#du)

du = disk usage

估计文件的空间占用。逐层统计文件（例如以递归方式）并输出摘要。

查看占用磁盘空间

du FILENAME1 FILENAME2

查看目录

du -a dir

以 KB,MB 或块为单位展示

du -h FILENAME1

显示总计情况

du -c FILENAME1

只显示合计

du -s FILENAME1

以特定单位打印

du -b/-k/-m/-B FILES

排除部分文件

du --exclude "*.txt" DIR
   --exclude-from EXCLUDE.txt DIR

指定最深层级

du --max-depth 2 DIR

指定目录最大的 10 个文件

du -ak S_DIR | sort -nrk 1 | head

df[](#df)

df = disk free

报告系统的磁盘使用情况。在跟踪磁盘使用情况方面对于普通用户和系统管理员都很有用。 ‘df‘ 通过检查目录大小工作，但这一数值仅当文件关闭时才得到更新。

查看磁盘可用空间

df
df -h

time[](#time)

计算命令执行时间

time COMMAND

real 挂钟时间, 从开始执行到结束的时间
user 进程花费在用户模式中的cpu时间, 真正用于执行进程所花得时间
sys  进程花费在内核模式中的cpu时间

写入文件

time -o output.txt COMMAND
time -a output.txt COMMAND #追加

格式化输出

time -f "Time: %U"  -a -o timing.log uname
real %e
user %U
sys %S

who[](#who)

获取当前用户登陆信息

who / w

当前登陆主机的用户列表

users

uptime[](#uptime)

查看系统已经通电运行多长时间了

uptime
#也可以看到负载

last[](#last)

显示上次用户登录信息- 前一次启动会话信息

last

获取单个用户

last USER

watch[](#watch)

在终端中以固定间隔监视命令输出

#default 2s
watch ls

# 5s
watch -n 5 ls

颜色标示

watch -d 'COMMAND'

进程和线程[](#进程和线程)

ps[](#ps)

ps 命令给出正在运行的某个进程的状态，每个进程有特定的 id 成为 PID。

ps 命令主要查看系统中进程的状态

USER              PID  %CPU %MEM      VSZ    RSS   TT  STAT STARTED      TIME COMMAND
USER表示启动进程用户
PID表示进程标志号

%CPU表示运行该进程占用CPU的时间与该进程总的运行时间的比例
%MEM表示该进程占用内存和总内存的比例。

VSZ表示占用的虚拟内存大小，以KB为单位。
RSS为进程占用的物理内存值，以KB为单位。

TTY表示该进程建立时所对应的终端，"?"表示该进程不占用终端。
STAT表示进程的运行状态，包括以下几种代码：
    D，不可中断的睡眠；
    R，就绪（在可运行队列中）；
    S，睡眠；
    T，被跟踪或停止；
    Z，终止（僵死）的进程，Z不存在，但暂时无法消除；
    W，没有足够的内存分页可分配；<高优先序的进程；
    N，低优先序的进程；
    L，有内存分页分配并锁在内存体内（实时系统或I/O）。

START为进程开始时间。
TIME为执行的时间。
COMMAND是对应的命令名。

查看进程信息

#当前终端
ps

PID TTY TIME CMD
PID  进程ID
TTY  终端
TIME 进程启动后过去的时间
CMD  进程对应的命令

显示更多信息

#当前终端
ps -f

查看所有进程

ps aux
ps -ef

查看某个用户的所有进程

ps U ken

命令格式

ps [OTHER OPTIONS] -o par1,par2,par3
ps -eo comm,pcpu | head
pmem 内存使用率，comm可执行文件名,user启动进程的用户,etime启动后度过的时间

设置升序降序

ps -eo comm,pcpu --sort -pcpu | head
+升序，-降序

找出给定命令名对应进程 ID

ps -C COMMAND_NAME
ps -C bash -o pid=

进程线程相关

ps -eLf --sort -nlwp | head

查看子进程树

ps axwef

注意：当你要知道有哪些进程在运行或者需要知道想杀死的进程 PID 时 ps 命令很管用。你可以把它与‘grep‘合用来查询指定的输出结果，例如：

# ps -A | grep -i ssh

pgrep[](#pgrep-1)

pgrep 只需要命令名的一部分, ps 需要准确的全名

基本用法

pgrep bash

指定进程的用户

pgrep -u root,slynux COMMAND

返回匹配进程数

pgrep -c COMANND

top[](#top)

查看占用 cpu 最多的进程列表

top

kill[](#kill)

kill 是用来杀死已经无关紧要或者没有响应的进程,杀死一个进程需要知道进程的 PID

列出可用信号

kill -l

终止一个进程

kill PROCESS_ID_LIST

强杀进程

kill -9 PROCESS_ID

杀死一组命令

killall process_name
killall -9 process_name

指定用户
killall -u USERNAME process_name

pkill[](#pkill)

杀，接受进程名

pkill process_name
pkill -s SIGNAL process_name

which[](#which)

查找 PATH 下某个命令位置

which ls

whereis[](#whereis)

whereis 的作用是用来定位命令的二进制文件\资源\或者帮助页.举例来说,获得 ls 和 kill 命令的二进制文件/资源以及帮助页:

whereis ls
whereis kill

类似 which，多了命令手册位置，源代码位置

注意:当需要知道二进制文件保存位置时有用.

file[](#file-1)

确定文件类型

whatis[](#whatis)

对命令的简短描述

hostname[](#hostname)

当前主机名

uname[](#uname)

主机名
uname -n

#内核版本，硬件架构等
uname -a

#内核发行版本
uname -r

主机类型(32位/64位)
uname -m

cpu相关信息
cat /proc/cpuinfo

内存信息
cat /proc/meminfo

例子

#uname -a
Linux tecmint 3.8.0-19-generic #30-Ubuntu SMP Wed May 1 16:36:13 UTC 2013 i686 i686 i686 GNU/Linux

1. “Linux“: 机器的内核名
2. “tecmint“: 机器的分支名
3. “3.8.0-19-generic“: 内核发布版本
4. “#30-Ubuntu SMP“: 内核版本
5. “i686“: 处理器架构
6. “GNU/Linux“: 操作系统名

crontab[](#crontab)

格式

* * * * * cmd
分钟(0-59)，小时(0-23)，天(1-31)，月份(1-12)，工作日(0-6)

A,B  A and B
*/C  every C

查看

crontab -l
crontab -l -u slynux

编辑

crontab -e

移除

crontab -r
crontab -u slynux -r

可以在 crontab 中加入环境变量

getopts[](#getopts)

命令行参数处理

while getopts :f:vql opt
do
    case $opt in
    f)  file=$OPTARG
        ;;
    v)  verbose=true
        ;;
    ....

history[](#history)

“history”命令就是历史记录。它显示了在终端中所执行过的所有命令的历史

history

注意：按住“CTRL + R”就可以搜索已经执行过的命令，它可以你写命令时自动补全

sudo[](#sudo)

“sudo”(super user do)命令允许授权用户执行超级用户或者其它用户的命令。通过在 sudoers 列表的安全策略来指定。

注意：sudo 允许用户借用超级用户的权限，然而”su”命令实际上是允许用户以超级用户登录。所以 sudo 比 su 更安全。并不建议使用 sudo 或者 su 来处理日常用途，因为它可能导致严重的错误如果你意外的做错了事，这就是为什么在 linux 社区流行一句话：

“To err is human, but to really foul up everything, you need root password.” “人非圣贤孰能无过，但是拥有 root 密码就真的万劫不复了。”

cal[](#cal)

“cal”（Calender），它用来显示当前月份或者未来或者过去任何年份中的月份

cal
cal 02 1835

cp[](#cp)

“copy”就是复制。它会从一个地方复制一个文件到另外一个地方

cp file1 file2
cp -r dir1 dir2

快速备份一个文件：

cp some_file_name{,.bkp}

注意： cp，在 shell 脚本中是最常用的一个命令，而且它可以使用通配符（在前面一块中有所描述），来定制所需的文件的复制。

mv[](#mv)

“mv”命令将一个地方的文件移动到另外一个地方去。

pwd[](#pwd)

“pwd”（print working directory），在终端中显示当前工作目录的全路径。

注意：这个命令并不会在脚本中经常使用，但是对于新手，当从连接到 nux 很久后在终端中迷失了路径，这绝对是救命稻草。

free[](#free)

free -m
             total       used       free     shared    buffers     cached
Mem:          7982       6811       1171          0        350       5114
-/+ buffers/cache:       1346       6636
Swap:        16935         11      16924

显示剩余内存

free -m | grep cache | awk '/[0-9]/{ print $4" MB" }'

在这里例子中,应用程序只使用了 1346MB 内存,还有 6636MB 空闲内存可以使用.

一些简单的计算方法：

物理已用内存 = 实际已用内存 - 缓冲 - 缓存 = 6811M - 350M - 5114M

物理空闲内存 = 总物理内存 - 实际已用内存 + 缓冲 + 缓存

应用程序可用空闲内存 = 总物理内存 - 实际已用内存

应用程序已用内存 = 实际已用内存 - 缓冲 - 缓存

原始解释：转至互联网： Linux 的基本原则是没有资源应该被浪费.因此核心会使用尽可能多的 RAM,来缓存来自本地和远程的文件系统的信息.系统做读写操作的时候,会将与当前运行的进程相关的数据尽量存储在 RAM 里.系统报告的缓存是缓冲和页缓存两者之和.缓存并不是在进程结束的时候被回收(你可能很快会启动另外一个进程,需要同样的数据),而是随需回收–比如,当你启动一个需要大量内存的进程时,Linux 核心会从内存中回收缓存,将得到的内存分配给新的进程.

有些区域,比如匿名内存映射(mmps)和共享内存区域,它们被报告为缓存,但不是被核心直接释放.一般的缓存不映射到进程的地址空间,仅仅是简单的核心映射,而这些特别的缓存映射到所有挂接到它们上面的进程.

eval[](#eval)

eval "ls -l"

basename[](#basename)

获取路径中文件部分

basename resolv.conf #resolv.conf
basename /etc/resolv.conf # resolv.conf

cmp[](#cmp)

比较两个任意类型的文件并将结果输出至标准输出。如果两个文件相同， ‘cmp‘默认返回 0；如果不同，将显示不同的字节数和第一处不同的位置。

cmp file1 file2
diff file1 file2

rm[](#rm)

‘rm’ 标准移除命令。 rm 可以用来删除文件和目录

rm file1
rm -r dir1  #递归删除空目录

强删

rm -rf fileordir

警告: ”rm -rf” 命令是一个破坏性的命令,假如你不小心删除一个错误的目录。一旦你使用’rm -rf’ 删除一个目录,在目录中所有的文件包括目录本身会被永久的删除,所以使用这个命令要非常小心。

service[](#service)

‘service‘命令控制服务的启动、停止和重启，它让你能够不重启整个系统就可以让配置生效以开启、停止或者重启某个服务。

注意：要想使用 service 命令，进程的脚本必须放在‘/etc/init.d‘，并且路径必须在指定的位置。如果要运行“service apache2 start”实际上实在执行“service /etc/init.d/apache2 start”.

man[](#man)

‘man‘是系统帮助页。Man 提供命令所有选项及用法的在线文档。几乎所有的命令都有它们的帮助页

man thecommand

注意：系统帮助页是为了命令的使用和学习而设计的。

passwd[](#passwd)

这是一个很重要的命令，在终端中用来改变自己密码很有用。显然的，因为安全的原因，你需要知道当前的密码。

gcc[](#gcc)

gcc 是 Linux 环境下 C 语言的内建编译器。下面是一个简单的 C 程序，在桌面上保存为 Hello.c （记住必须要有‘.c‘扩展名

gcc Hello.c
./a.out
gcc -o Hello Hello.c
./Hello

注意: 编译 C 程序时，输出会自动保存到一个名为“a.out”的新文件，因此每次编译 C 程序 “a.out”都会被修改。因此编译期间最好定义输出文件名.，这样就不会有覆盖输出文件的风险了。

g++[](#g)

g++是 C++的内建编译器

g++ Add.cpp
./a.out
g++ -o Add Add.cpp
./Add

java[](#java)

Java 是世界上使用最广泛的编程语言之一. 它也被认为是高效, 安全和可靠的编程语言. 现在大多数基于网络的服务都使用 Java 实现.

javac tecmint.java
java tecmint

注意: 几乎所有的 Linux 发行版都带有 gcc 编译器, 大多数发行版都内建了 g++ 和 java 编译器, 有些也可能没有. 你可以用 apt 或 yum 安装需要的包.

关于/dev/null[](#关于-dev-null)

特别有用的特殊文件，位桶，传送到此文件的数据都会被系统丢弃。

语言及乱码[](# 语言及乱码)

查看变量值

echo $LANG   未设置任何LC_XXX时使用的默认值
echo $LC_ALL 覆盖所有LC_XXX变量，总控开关

好的做法是，避免为任何 LC_XXX 变量赋值，使用 LC_ALL 和 LANG 来控制

避免乱码：从编辑器到语言，再到系统，统一编码为 UTF-8

shell 的版本[](# shell的版本)

bash --version

查看进程所属目录[](# 查看进程所属目录)

查看nginx的PID，以常用的80端口为例：

[root@xiaoyuer scripts]# netstat -lntup|grep 80
tcp        0      0 0.0.0.0:80                  0.0.0.0:*                   LISTEN      13309/nginx
 
#可以知道nginx进程是13309

通过相应的进程ID(比如：13309）查询当前运行的nginx路径：

[root@xiaoyuer scripts]# ll /proc/13309/exe
lrwxrwxrwx 1 root root 0 Jan  4 17:02 /proc/13309/exe -> /data/nginx/sbin/nginx

获取到nginx的执行路径后，使用-t参数即可获取该进程对应的配置文件路径，如：

/usr/local/nginx/sbin/nginx -t
nginx: the configuration file /usr/local/nginx/conf/nginx.conf syntax is ok
nginx: configuration file /usr/local/nginx/conf/nginx.conf test is successful

其实所有的启动命令都是类似　

Linux Shell 脚本攻略笔记

Linux Shell 脚本攻略笔记[速查]

资源[](#资源)

shell script[](#shell-script)

run shell script[](#run-shell-script)

echo[](#echo)

printf[](#printf)

环境变量和变量[](#环境变量和变量)

pgrep[](#pgrep)

shell 数学运算[](#shell数学运算)

命令状态[](#命令状态)

文件描述符和重定向[](#文件描述符和重定向)

cat[](#cat)

数组和关联数组[](#数组和关联数组)

alias[](#alias)

date[](#date)

调试脚本[](#调试脚本)

函数和参数[](#函数和参数)

管道[](#管道)

读取命令输出[](#读取命令输出)

read[](#read)

字段分隔符和迭代器[](#字段分隔符和迭代器)

循环[](#循环)

比较和测试[](#比较和测试)

find[](#find)

xargs[](#xargs)

tr[](#tr)

md5sum[](#md5sum)

sha1sum[](#sha1sum)

对目录进行校验[](#对目录进行校验)

sort[](#sort)

uniq[](#uniq)

tempfile[](#tempfile)

split[](#split)

bash 变量匹配切分[](#bash变量匹配切分)

expect[](#expect)

dd[](#dd)

comm[](#comm)

mkdir[](#mkdir)

ls[](#ls)

chmod[](#chmod)

chown[](#chown)

chattr[](#chattr)

touch[](#touch)

ln[](#ln)

readlink[](#readlink)

file[](#file)

读文件[](#读文件)

diff[](#diff)

head[](#head)

tail[](#tail)

pushd/popd[](#pushd-popd)

cd[](#cd)

wc[](#wc)

tree[](#tree)

grep[](#grep)

cut[](#cut)

join[](#join)

sed[](#sed)

awk[](#awk)

文件迭代[](#文件迭代)

paste[](#paste)

tac[](#tac)

rev[](#rev)

wget[](#wget)

curl[](#curl)

lynx[](#lynx)

tar[](#tar)

cpio[](#cpio)

gzip[](#gzip)

zcat[](#zcat)

bzip[](#bzip)

lzma[](#lzma)

zip[](#zip)

base64[](#base64)

md5sum[](#md5sum-1)

rsync[](#rsync)

git[](#git)

dd[](#dd-1)

mount[](#mount)