• Linux Shell脚本攻略笔记[速查]
  • 资源
  • shell script
  • run shell script
  • echo
  • printf
  • 环境变量和变量
  • pgrep
  • shell数学运算
  • 命令状态
  • 文件描述符和重定向
  • cat
  • 数组和关联数组
  • alias
  • date
  • 调试脚本
  • 函数和参数
  • 管道
  • 读取命令输出
  • read
  • 字段分隔符和迭代器
  • 循环
  • 比较和测试
  • find
  • xargs
  • tr
  • md5sum
  • sha1sum
  • 对目录进行校验
  • sort
  • uniq
  • tempfile
  • split
  • bash变量匹配切分
  • expect
  • dd
  • comm
  • mkdir
  • ls
  • chmod
  • chown
  • chattr
  • touch
  • ln
  • readlink
  • file
  • 读文件
  • diff
  • head
  • tail
  • pushd/popd
  • cd
  • wc
  • tree
  • grep
  • cut
  • join
  • sed
  • awk
  • 文件迭代
  • paste
  • tac
  • rev
  • wget
  • curl
  • lynx
  • tar
  • cpio
  • gzip
  • zcat
  • bzip
  • lzma
  • zip
  • base64
  • md5sum
  • rsync
  • git
  • dd
  • mount
  • 网络相关
    • ifconfig
    • ping
    • fping
    • lftp
    • scp
    • SSH
    • lsof
    • netstat
  • 磁盘和系统
    • du
    • df
    • time
    • who
    • uptime
    • last
    • watch
  • 进程和线程
    • ps
    • pgrep
    • top
    • kill
    • pkill
    • which
    • whereis
    • file
    • whatis
    • hostname
    • uname
    • crontab
    • getopts
    • history
    • sudo
    • cal
    • cp
    • mv
    • pwd
    • free
    • eval
    • basename
    • cmp
    • rm
    • service
    • man
    • passwd
    • gcc
    • g++
    • java
    • 关于/dev/null
    • 语言及乱码
    • shell的版本

#!/bin/bash

# do something

sh script.sh

or

chmod a+x script.sh

./script.sh

# 会读取首行的解释器, 执行

cmd1; cmd2

or

cmd1

cmd2

echo "welcome to bash"

echo welcome to bash

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 "hello world"

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

3    Jeff      77.56

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}

echo $SHELL

    /bin/bash

echo $0

    bash

root的UID=0

if [ $UID -ne 0 ]

then

    echo "not root user"

else

    echo "root"

fi

设置PS1变量

\u用户名

\h主机名

\w当前工作目录

pgrep gedit

no1=4

no2=5

let result=no1+no2

let no1++

let no2--

let no1+=7

let no2-=7

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 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

cmd1 | cmd2 | cmd3 -

cmd < file

使用文件描述符3打开并读取文件

exec 3<input.txt

cat <&3

使用文件描述符4进行写入

exec 4>output.txt

echo newline >&4

cat file1 file2 file3

从管道中读取

OUTPUT_FROM_SOME_CMDS | cat

echo "test" | cat - file1

cat -s  file

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

cat -n file

cat -T file

cat f > t

注意：“>>”和“>”调用了追加符号。它们用来追加到文件里，而不是显示在标准输出上。

“>”符号会删除已存在的文件，然后创建一个新的文件。

所以因为安全的原因，建议使用“>>”，它会写入到文件中，而不是覆盖或者删除。

cat > test.txt

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 new_command='command seq'

unalias new_command

使用原生命令

\new_command

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第一个字符

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

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`

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 -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:

data="name,sex,rollno"

oldIFS=$IFS

IFS=,

for item in $data

do

        echo $item

done

IFS=$oldIFS

echo {1..50}

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

or

for((i=0;i<10;i++))

{

    commands;

}

while condition

do

    commands;

done

until condition

do

    commands;

done

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 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'

cat  example.txt | xargs  #空格替换掉\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 . -type f -name "*.txt" -print | xargs rm -rf

cat file | ( while read arg; do cat $arg; done )

cat file | xargs -I {} cat {}

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 filename

md5sum filename1 filename2

sha1sum file

md5deep/sha1deep

md5deep -rl dirname

         r递归，l相对路径

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 file

uniq -u file

uniq -d file

-s 可指定跳过前N个字符

-w 指定用于比较的最大字符数

uniq -c file

temp_file=$(tempfile)

等同

temp_file="/tmp/file-$RANDOM"

#$$为进程id

temp_file="/tmp/var.$$"

split -b 10k data.file

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

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

spawn ./ineractive.sh

expect "Enter the number"

send "1\n"

expect "Enter name:"

send "hello\n"

expect eof

spawn指定需要自动化的命令

expect提供需要等待的消息

send发送消息

expect eof指明命令交互结束

# 创建一个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

onleA \t onlyB \t bothAB

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

-3 删除第三列

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

mkdir dirpath

mkdir -p dirpath1/dirpath2

#一次多个目录

mkdir -p /home/user/{test,test1,test2}

- 普通文件

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    命令会列出文件夹里的所有内容，包括以”.”开头的隐藏文件

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 user.group filename

chown -R user.group .

chomod +s executable_file

chown root.root executable_file

chmod +s executable_file

./executable_file

chattr +i file

chattr -i file

touch filename

for name {1..100}.txt

do

    touch $name

done

touch -a "Fri Jun 25 20:50:14 IST 1999" filename

touch -m #修改文件内容的修改时间

touch -t 0712250000 file

ln -s target symbolic_link_name

readlink web

 readlink ~/.vim

 /Users/ken/github/k-vim

file filename

file -b filename

file /etc/passwd

/etc/passwd: ASCII English text

file -b /etc/passwd

ASCII English text

while read line;

do

    something

done < filename

diff version1.txt version2.txt

diff -u version.txt

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

patch -p1 version1.txt < version.patch

diff -Naur directory1 directory2

-N 所有缺失的文件作为空文件

-a 所有文件视为文本文件

-u 一体化输出

-r 递归遍历

head file

head -n 4 file

head -n -5 file

tail file

tail -n 5 file

tail -5 file

tail -n +(N+1)

tail -f growing_file

tail -f file --PID $PID

pushd

pushd /home/ken

dirs

#dirs从左到右编号 0 -

pushd +3

popd

cd -

cd

cd ~

cd ..

wc -l file

wc -w file

wc -c file

wc file

wc file -L

tree ~/unixfile

tree PATH -P "*.sh"

tree path -I PATTERN

tree -h

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 -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 [options] file1 file2

选项

-1 field1

-2 field2

-o file.field

-t separator

join file1 file2

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/"

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

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

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

awk -F '-' 'BEGIN{statements} {statements} END{statements}' file

表达式中单引号可以换成双引号

BEGIN -> 每一行，执行statements, 执行END

awk -F '-' '{print $0}' file #全部

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

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 -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默认打印

awk -F: '{print "User", $1, "is really", $5}' /etc/passwd

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

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 file1 file2 file3

paste file1 file2 -d ','

tac file1 file2

echo "abc" | rev

wget URL1 URL2

wget URL -O local.txt

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 表示不在本机重新创建目录结构

wget --user username --password pass URL

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

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

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

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

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

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

         --data

lynx -dump URL > webpage_as_text.txt

lynx -dump url

lynx -traversal url

-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中

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

echo file1 file2 | cpio -ov > archive.cpio

-o 指定输出

-v 打印归档文件列表

cpio -it < archive.cpio

-i指定输入

-t列出归档文件中的内容

gzip filename

#got filename.gz

gunzip filename.gz

gzip -l text.gz

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 test.gz

bzip2 filename

bunzip2 filename.bz2

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 filename

unlzma filename.lzma

cat file | lzma -c > file.lzma

tar -cavvf archive.tar.lzma [files]

    -xavf

lzma test.bz2 -k

lzma -9 test.img

zip archive_name.zip [source files/dirs]

zip -r archive.zip folder1 file2

base64 filename > outfile

cat file | base64 > outfile

base64 -d file > outfile

md5sum file

sha1sum file

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 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 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 --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

/sbin/ifconfig

ifconfig iface_name

e.g.

ifconfig en1

HWaddr     MAC地址

inet addr  ip地址

Bcast      广播地址

Mask       子网掩码

ifconfig wlan0 192.168.0.80

cat /etc/resolv.conf

host google.com #Dns查找

nslookup google.com #更详细信息

echo nameserver IP_ADDRESS >> /etc/resolv.conf

echo ip domain >> /etc/hosts

ping www.baidu.com

显示路由表

route

以数字形式显示地址

route -n

route add default gw 192.168.0.1 wlan0

traceroute google.com

ping ADDRESS  #主机名，域名或ip

ping ADDRESS -c COUNT

ping

fping -a ip1 ip2 -g

fping -a 192.160.1/24 -g

fping -a < ip.list

-a, 所有活动主机的ip

-g, 从IP/mask生成的ip地址范围

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

lftp username@ftphost

cd dir

lcd改变本地主机目录

mkdir 创建目录

get/put 下载上传

quit退出

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 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'

1.创建SSH密钥

  ssh-keygen -t rsa

  公钥, ~/.ssh/id_rsa.pub

2.登陆远端服务器, 将公钥写入 ~/.ssh/authorized_keys

lsof -i

netstat -tnp

du FILENAME1 FILENAME2

du -a dir

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

du -ak S_DIR | sort -nrk 1 | head

df

df -h

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 / w

users

uptime

#也可以看到负载

last

last USER

#default 2s

watch ls

# 5s

watch -n 5 ls

watch -d 'COMMAND'

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

+升序，-降序

ps -C COMMAND_NAME

ps -C bash -o pid=

ps -eLf --sort -nlwp | head

ps axwef

# ps -A | grep -i ssh

pgrep bash

pgrep -u root,slynux COMMAND

pgrep -c COMANND

top

kill -l

kill PROCESS_ID_LIST

kill -9 PROCESS_ID

killall process_name

killall -9 process_name

指定用户

killall -u USERNAME process_name

pkill process_name

pkill -s SIGNAL process_name

which ls

whereis ls

whereis kill

主机名

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“: 操作系统名

* * * * * 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

while getopts :f:vql opt

do

    case $opt in

    f)  file=$OPTARG

        ;;

    v)  verbose=true

        ;;

    ....

history

cal

cal 02 1835

cp file1 file2

cp -r dir1 dir2

cp some_file_name{,.bkp}

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" }'

eval "ls -l"

basename resolv.conf #resolv.conf

basename /etc/resolv.conf # resolv.conf

cmp file1 file2

diff file1 file2

rm file1

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

rm -rf fileordir

man thecommand

gcc Hello.c

./a.out

gcc -o Hello Hello.c

./Hello

g++ Add.cpp

./a.out

g++ -o Add Add.cpp

./Add

javac tecmint.java

java tecmint

echo $LANG   未设置任何LC_XXX时使用的默认值

echo $LC_ALL 覆盖所有LC_XXX变量，总控开关