1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 使用stat查看某个文件inode
stat  _config.yml
  File: '_config.yml'
  Size: 2522            Blocks: 8          IO Block: 4096   regular file
Device: fd02h/64770d    Inode: 52354       Links: 1
Access: (0664/-rw-rw-r--)  Uid: ( 1000/ zhang)   Gid: ( 1000/ zhang)
Access: 2019-04-22 09:39:28.735991059 +0800
Modify: 2018-07-07 15:37:50.000000000 +0800
Change: 2018-12-11 07:38:26.287109004 +0800
 Birth: -

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 查看inode
df -i
Filesystem                 Inodes  IUsed     IFree IUse% Mounted on
overlay                  26214400 597690  25616710    3% /
tmpfs                      485005     17    484988    1% /dev
tmpfs                      485005     16    484989    1% /sys/fs/cgroup
/dev/mapper/centos-home 215418880 297955 215120925    1% /home/test
/dev/mapper/centos-root  26214400 597690  25616710    3% /etc/hosts
shm                        485005      1    485004    1% /dev/shm
tmpfs                      485005      1    485004    1% /proc/acpi
tmpfs                      485005      1    485004    1% /proc/scsi
tmpfs                      485005      1    485004    1% /sys/firmware

1
2
3
4
5
6
7
8
9

vim /root/.vimrc


"这是注释"
set nu
set ruler
set bg=dark
syntax on
set hlsearch

1
2
3
4

#iconv -f 源编码 -t 新编码 filename [-o newfile]
#-o，转换到新文件

iconf -f big4 -t utf8 old.big5 -o new.utf8

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

vim

:set magic
:set nomagic


magic (\m)：除了 $ . * ^ 之外的元字符都需要转义，也就是反斜杠(\)
/\m.*    #查找任意字符串

nomagic (\M)：除了`$ ^`之外的元字符都需要转义
/\M.*    #查找特定字符串.*

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

vim 1.txt


# \s，空格
# 删除每行开通的空格
:%s/^\s*//g


# 去掉开头的行号
11, 20s/^[0-9]\{2\}//g



# 查找
/[0-9]\{3,5\}


# 查找多个
/aaa\|bbb\|ccc
#替换多个
:%s/aaa\|bbb/HAHAHAHA/g

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

sudo yum install -y vim git

# 下载Vundle
git clone https://github.com/VundleVim/Vundle.vim.git ~/.vim/bundle/Vundle.vim

# 配置vundle
vim ~/.vimrc

#加入以下内容
set nocompatible              " required
filetype off                  " required
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()
Plugin 'gmarik/Vundle.vim'
call vundle#end()            " required
filetype plugin indent on    " required

" 设置包括vundle和初始化相关的runtime path
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()
" 另一种选择, 指定一个vundle安装插件的路径
"call vundle#begin('~/some/path/here')

" 让vundle管理插件版本,必须
Plugin 'VundleVim/Vundle.vim'

" 以下范例用来支持不同格式的插件安装.
" 请将安装插件的命令放在vundle#begin和vundle#end之间.
" Github上的插件
" 格式为 Plugin '用户名/插件仓库名'
Plugin 'tpope/vim-fugitive'
" 来自 http://vim-scripts.org/vim/scripts.html 的插件
" Plugin '插件名称' 实际上是 Plugin 'vim-scripts/插件仓库名' 只是此处的用户名可以省略
Plugin 'L9'
" 由Git支持但不再github上的插件仓库 Plugin 'git clone 后面的地址'
Plugin 'git://git.wincent.com/command-t.git'
" 本地的Git仓库(例如自己的插件) Plugin 'file:///+本地插件仓库绝对路径'
Plugin 'file:///home/gmarik/path/to/plugin'
" 插件在仓库的子目录中.
" 正确指定路径用以设置runtimepath. 以下范例插件在sparkup/vim目录下
Plugin 'rstacruz/sparkup', {'rtp': 'vim/'}
" 安装L9，如果已经安装过这个插件，可利用以下格式避免命名冲突
Plugin 'ascenator/L9', {'name': 'newL9'}

" 你的所有插件需要在下面这行之前
call vundle#end()            " 必须
filetype plugin indent on    " 必须 加载vim自带和插件相应的语法和文件类型相关脚本
" 忽视插件改变缩进,可以使用以下替代:
"filetype plugin on
"
" 简要帮助文档
" :PluginList       - 列出所有已配置的插件
" :PluginInstall    - 安装插件,追加 `!` 用以更新或使用 :PluginUpdate
" :PluginSearch foo - 搜索 foo ; 追加 `!` 清除本地缓存
" :PluginClean      - 清除未使用插件,需要确认; 追加 `!` 自动批准移除未使用插件
"
" 查阅 :h vundle 获取更多细节和wiki以及FAQ
" 将你自己对非插件片段放在这行之后


# 安装插件
# vim中
:PluginInstall

# bash
vim _PluginInstall +qall



# 查找插件
# vim
:PluginSearch
# 要从vimscripts网站刷新本地的列表
:PluginSearch!


# 查看已安装插件
# vim
:PluginList


# 更新插件
# vim
:PluginUpdate

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

# 下载安装
curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim


# 配置
vim ~/.vimrc
# 以 call plug#begin(PLUGIN_DIRECTORY) 开始，并以 call plug#end() 结束
# 栗子
" Specify a directory for plugins
" - For Neovim: ~/.local/share/nvim/plugged
" - Avoid using standard Vim directory names like 'plugin'
call plug#begin('~/.vim/plugged')

" Make sure you use single quotes

" Shorthand notation; fetches https://github.com/junegunn/vim-easy-align
Plug 'junegunn/vim-easy-align'

" Any valid git URL is allowed
Plug 'https://github.com/junegunn/vim-github-dashboard.git'

" Multiple Plug commands can be written in a single line using | separators
Plug 'SirVer/ultisnips' | Plug 'honza/vim-snippets'

" On-demand loading
Plug 'scrooloose/nerdtree', { 'on':  'NERDTreeToggle' }
Plug 'tpope/vim-fireplace', { 'for': 'clojure' }

" Using a non-master branch
Plug 'rdnetto/YCM-Generator', { 'branch': 'stable' }

" Using a tagged release; wildcard allowed (requires git 1.9.2 or above)
Plug 'fatih/vim-go', { 'tag': '*' }

" Plugin options
Plug 'nsf/gocode', { 'tag': 'v.20150303', 'rtp': 'vim' }

" Plugin outside ~/.vim/plugged with post-update hook
Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }

" Unmanaged plugin (manually installed and updated)
Plug '~/my-prototype-plugin'

" Initialize plugin system
call plug#end()



# 重载.vimrc以使用vim
source ~/.vimrc
# vim
:PlugInstall
:PlugUpdate
:PlugClean


# 升级plug
# vim
:PlugUpgrade

1
2
3
4

import ipdb

xxx
ipdb.set_strace()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

python3 -m ipdb xxx.py
ipdb>

ipdb> help

Documented commands (type help <topic>):
========================================
EOF    cl         disable  interact  next    psource  rv         unt
a      clear      display  j         p       q        s          until
alias  commands   down     jump      pdef    quit     source     up
args   condition  enable   l         pdoc    r        step       w
b      cont       exit     list      pfile   restart  tbreak     whatis
break  continue   h        ll        pinfo   return   u          where
bt     d          help     longlist  pinfo2  retval   unalias
c      debug      ignore   n         pp      run      undisplay

Miscellaneous help topics:
==========================
exec  pdb

1
2
3
4
5
6
7
8
9

python3 -m ipdb xxx.py
# 在第3行设置断点
ipdb> b 3

# 执行到断点处
ipdb> c

# 查看2-7行代码
ipdb> l 2,7

1
2
3
4

U-XXXXXXXX

#每个 X 都是一个十六进制的数字
#因此，它的数值从U-00000000到U-FFFFFFFF

1
2
3
4
5
6
7

type ls


type -t ls
#file，外部命令
#alias，别名
#builtin，內建命令

1
2
3
4
5
6
7

#HOME，用户主目录
#SHELL，当前环境使用的shell
#HISTSIZE，历史命令
#PATH，执行文件查找路径
#LANG，语系
#$PS1，命令提示符
#PS2，第二行提示符

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

\d		#可显示出『星期 月 日』的日期格式，如："Mon Feb 2"

\H		#完整的主机名

\h		#仅取主机名在第一个小数点之前的名字

\t		#显示时间，24小时格式的『HH:MM:SS』

\T		#显示时间，为12小时格式的『HH:MM:SS』

\A		#显示时间，为24小时格式的『HH:MM』

\@		#显示时间，为12小时格式的『am/pm』

\u		#目前使用者的账号名称，如『root』

\v		#BASH的版本信息

\w		#完整工作路径名，由根目录写起的目录名称。但家目录会以 ~ 取代

\W		#利用basename函数取得工作目录名称，所以仅会列出最后一个目录名。

\#		#下达的第几个命令

\$		#提示字符，root时，提示字符为#；否则就是$

1

test -e /root/test.txt && echo 'Exist' || 'Not exist'

1
2
3

# 示例
/root/test.sh opt1 opt2 opt3
	$0	$1	$2	$3

1
2
3

if [ confition ]; then
    xxx
fi

1
2
3
4
5

if [ condition ]; then
	xxx;
else
	xxx;
fi

1
2
3
4
5
6
7

if [ confition1 ]; then
	xxx;
elif [ condition2 ]; then
	xxx;
else
	xxx;
fi

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

case $变量名 in
"$var1")
	xxx
    ;;
"$var2")
	xxx
    ;;
*)
	xxx
    ;;
esac



####栗子
#/etc/init.d/network

case "$1" in
start)
	xxx
	;;
stop)
	xxx
    ;;
restart)
	xxx
    ;;
status)
	xxx
    ;;
esac

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

vim func.sh



function fname () {

}


####栗子
function Zhang() {
	echo $1 $2
}

Zhang "$1" "$2"



#执行
sh func.sh aaa bbb

1
2
3
4

while [ condition1 ]
do
	xxx
done

1
2
3
4

until [ condition ]
do
	xxx
done

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

for i in con1 con2 con3 ...
do
	xxx
done


####栗子
for i in 192.168.1.{1,2,3}
do
	ping -c 1 $i
done

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

for ((初始值;限制值；步长))
do
	xxx
done


####栗子
for ((i=0;i<10;i++))
do
	echo $i
done

1
2
3
4
5
6
7
8
9

sh [-nvx] xxx.sh


#-v 运行脚本前，先将脚本内容输入到屏幕
#-n 仅查询语法问题
#-x 边显示边执行

当然也可以把这几个调试参数写到shellbang中
#!/bin/bash -x

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#bash(Bourne Again Shell)，shell环境使得用户能与操作系统的内核进行交互操作

#!/bin/bash
#date
#description

cmd1; cmd2
cmd3


#sh /path/xx.sh
#Bash还有一个历史记录文件 ~/.bash_history

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#终端作为交互式工具，用户可以通过它与shell环境进行交互

echo '$var'
echo $var
echo -e "1\t2\t3"
echo -e '\e[1;31m Red color \e[0m'    #彩色


echo {1..10}		#输出1到10
echo {A..H}		#for i in {a..z}


cat << EOF
11
22
33
EOF


# \转义字符
printf "%-5s %-10s $-4.2f\n" 001 Zhang 56.789
#格式替代符%s %d %c %f, -左对齐

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#Bash中，每一个变量默认值值都是字符串形式
#环境变量和自定义变量

echo $SHELL
echo $UID


var=value	#这是赋值
#var = value这是相等操作
echo $var
echo ${var}
echo ${#var}	#字符数


#export用来设置环境变量，此后，任何shell中的程序都会继承环境变量
ZHANG=Gentleman
export ZHANG


PATH="$PATH:/home/zhang/bin"
export $PATH

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#let, expr, bc, [], (())
#要注意默认是字符串类型哦

n1=1;n2=2
let sum=n1+n2
let n1++;let n2-=1

sum=$[ n1 + n2 ]
sum2=$(( sum + 3 ))

sum=`expr 3 + 4`


#浮点计算 bc
echo "8 * 1.1" | bc


#设置小数点精度
echo "scale=2; 3/8" | bc


#进制转换
num=100
echo "obase=2; $num" | bc

num=1100100
echo "obase=10; ibase=2; $num" | bc


#平方和平方根
echo "sqrt(100)" | bc
echo "10^2" | bc

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#最常用的文件描述符是 stdin(0), stdout(1), stderr(2); 通过内容过滤将输出重定向到文件

echo "This is a sample text 1" > temp.txt	#覆盖
echo "This is sample text 2" >> temp.txt	#追加

ls + >stdout.txt 2>stderr.txt
cmd 2>&1 /dev/null  == com &> /dev/null		#null设备也被称为黑洞


#当一个command发生错误并退回时，它会返回一个非0的状态码
echo $?


#tee命令，一方面可将数据重定向到文件，另一方面还可提供一份重定向数据的副本作为后续命令的stdin
#tee默认覆盖文件，-a选项追加
cat temp.txt | tee tee.txt | cat -n

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#数组借助索引将多个独立的数据存储为一个集合
#普通数组只能使用整数作为数组索引，而关联数组可以使用字符串作为数组索引
#还可将数组定义成一组索引-值(index-value)


arr=(1 two 3 four 5)
echo ${arr[0]}
arr[0]=One


index=3
echo ${arr[$index]		#arr[3]
echo ${arr[*]}
echo ${#arr[*]}		#arr-length


#关联数组可用任意文本作为数组索引
declare -A ass_arr
ass_arr=([index1]=val1 [index2]=val2 ...)	#内嵌索引-值
ass_arr[index3]=val3	#独立索引-值
echo ${!ass_arr[*]}		#列出数组索引

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#alias作用是暂时的，关闭终端后别名就失效；
#为使别名一直保持，可将其写入 ~/.bashrc，因为每一个新的shell都会执行~/.bashrc中的命令
#新设置的别名将取代已有别名


alias vi=vim;
unalias vi
echo "alias ll='ls -l --color=auto'" >> ~/.bashrc


#\对别名命令进行转义，执行原本的命令。避免攻击者利用别名将某些特权命令替换成别有用心的命令
\vi test.sh

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#很多应用程序需要以不同的格式打印日期，设置日期和时间，以及根据日期和时间执行操作;
#延时通常用于在程序执行过程中提供一段等待时间;
#在Unix-like系统中，日期被存储为一个整数，其大小为世界标准时间1970年1月1日0时0分0秒起所流逝的秒数；
#这种计时方式被称之为 纪元时或Unix时间；
#通过纪元时间，可知道两个日期之间相隔了多少秒
#编写以循环方式运行的监视脚本时，设置时间间隔是必不可少的

date +%s

#!/bin/bash
start=$(date +%s)
commands
sleep 1
end=$(date +%s)
diff=$((end - start))
echo "$diff seconds"


#显示指定时间
date +%F -d -1days
date +%H -d -3hours



#将标准时间转换为原子时间
date -d '2018-02-07 14:05:53' +%s
1517983553

#将原子时间转换为标准时间
date --date='@1517983553'
Wed Feb  7 14:05:53 CST 2018

1
2
3
4
5

#调试功能能在出现一些异常情况时生成运行信息

#!/bin/bash -xv
sh -x
sh -n

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

function fname()
{
statements
}


fname()
{
echo $1, $2		#访问第参数1和参数2,$n第n个参数
echo "$@"		#以列表的形式一次性打印所有参数
echo "$*"		#类似于$@，但参数被作为单个实体
return 0		#f返回值
}
fname 1 22 333	#返回上面定义的变量


#递归函数，能够调用自身，不断地生成新的进程，最终会造成xx
#导出函数，使用export导出，这样函数作用域就可以扩展到子进程
export -f fname
#读取命令返回值
echo $?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#输入通常是stdin，输出stderr或stdout,这些命令称为 过滤器(filter)。我们使用 管道(pipe) 来连接每一个过滤器
cmd1 | cmd2 | cmd3


#子shell，子shell生成独立的进程，不会对当前shell有任何影响，所做改变仅限于子shell内
zhang=$(ls | cat -n)


#反引用
zhang=`ls | cat -n`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#read是一个重要的从标准输入中读取文本的命令
#可以使用read以交互的形式来读取用户的输入

read -n 5 zhang		#读取字符数
echo $zhang

read -s passwd		#不回显
echo $passwd

read -t 5 zhang		#超时时间
echo $zhang

read -p zhang		#显示提示信息
echo $zhang

read -d ":" zhang		#定界符结束输入
123：
echo $zhang

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#内部字段分隔符(Internal Field Separator, IFS)是shell中的一个重要概念
#IFS的默认值为空白字符(换行符、制表符、空格)
awk -F: '{print $1,$3}' /etc/passwd		#IFS=":"

#对一些列值进行迭代，循环非常有用
for i in {1..10}
do
cmd
done

while condition
do
cmd
done

until condition
do
cmd
done

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

#程序中的流程控制是由比较和测试语句来处理的
if condition1 || condition2
then
	cmd1
elif condition3 && condition4
then
	cmd2
else
	cmd3
fi


#算术比较
if [ $num -ge 10 -a $num -lt 20 ]

-eq
-gt
-ge
-lt
-le
-a
-o


#文件系统相关
if [ -f $file1 -o -x $file2]

-x
-w
-r
-f
-d
-e
-b		#block
-l


#字符串比较
[[ $str1 = $str2]]

=		#=号旁有空格--是比较关系；=号旁没空格，是赋值语句
!=
>
<
-z		#空字符
-n		#非空字符


#使用test命令来执行条件检测
if [ $num -eq 0 ]  -- if test $num -eq 0

1
2
3
4
5
6
7
8

#cat命令通常用于读取、显示或拼接文件内容，不过它所具备的能力远不止此
#cat(concatenate, 拼接)
cat file1 file2 ···
echo "Ahaha" | cat - file1 file2		#-指stdin文本文件名

cat -s file3  -- cat file3 | tr -s '\n'		#压缩空白行
cat -T test.py		#将制表符显示为 ^I, 避免制表符和连续空格误用, 产生错误缩进
cat -n file4		#显示行号

1
2
3
4
5
6
7
8
9

#-t,将时间数据输出到标准错误； -a,追加输出
script -t 2> timing.log -a output.session		#两个文件随意取名, 如不将错误重定向会显示在屏幕上导致很乱
输入命令
cmd2
···
exit		#退出录制


scriptreplay -t timing.log output.session		#播放

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

#基于文件名及正则表达式搜索
find /home/zhang		#列出/home/zhang目录及其子目录线所有文件和文件夹
find /home/zhang -name "*.txt"
find . -name "*.sh" -o -iname "zhang*"		#匹配多个
find /home/zhang -path "201710*"		#-path将文件路径作为一个整体进行匹配
find . -regex	".*\(\.txt|\.[0-9]+\)$"		#匹配以.txt或数字结尾的文件



#使用-maxdepth, -mindepth参数，来限制find的遍历深度
#-type, 根据文件类型搜索。 f(普通文件)，d(目录)，b(块设备)，l(符号链接)，s(套接字)等
find /home -maxdepth 1 -type f(d)		#参数顺序也会影响find的查找效率



#根据文件类型搜索
find /dev -type b		#查看/dev及其子目录下设备文件
find / -maxdepth 1 -type l		#查找/下链接文件



#根据文件时间进行搜索
#Unix/Linux文件系统中的每一个文件都有三种时间戳(timestamp),-表示小于，+表示大于
#Unix中并没有所谓的 "创建时间" 的概念
#访问时间(-atime,以天为单位； -amin,以分钟为单位):用户最近一次访问文件时间；
#修改时间(-mtime,以天为单位； -mmin,以分钟为单位):文件最后一次修改时间；
#变化时间(-ctime,以天为单位； -cmin,以分钟为单位):文件元数据(如权限，所有权)最后一次变化时间；
find /home/zhang -type f -mtime 7		#7天前被修改的普通文件
find /home/zhang -type f -amin -10		#搜索10分钟内被修改的普通文件
find . -type f -newer file1.txt		#找出比file1.txt新的文件



#基于文件大小的搜索
#b(块，512字节), c(字节), w(字，2字节), k(千字节), M(兆字节), G(吉字节)
find . -type -f -size +100k



#删除匹配的文件
find . -type f -name "*.swp" -delete



#基于文件权限和所有权的匹配
find . -type f -perm 644
find /var/apache -type f -name "*.php" -perm 644		#搜索基于权限的文件
find /var -maxdepth 2 -type f -user zhang		#搜索基于用户的文件



#执行命令或动作
#find命令可以借助-exec与其他命令进行结合
#{}是一个特殊字符串，将替换为相应文件名
find . -type f -perm 764 -user zhang -exec chmod 644 {} \;		#将所属用户zhang，权限764的文件权限修改为644
find . -type f -mmin +30 -name "*.txt" -exec cp {} {}.old \;		#复制最近30内修改的名字为.txt的文件



#-exec结合多个命令
#我们无法在-exec参数中直接使用多个命令，不过我们可以把多个命令写到一个shellscript中，然后执行
-exec ./test.sh {} \;
find . -type f -name "*.sh" -mmin -10 -exec sh {} \;



#让find跳过特定目录
-prune



#利用find搭配tar打包
#查找7天内的文件并打包
#建议使用绝对路径，管道无效，所有要定向到文件
find /dir/path/zhang -type -f -mmtime -7 > /dir/path/zhang/zhang.list && tar -T /dir/path/zhang/zhang.list -czvf /dir/path/zhang123.tar.gz
#检查是否正确
tar -tf /dir/path/zhang123.tar.gz

#不能使用find -exec tar，这样打包以后只有最后一个文件

1
2
3
4
5

stat 1.txt

#Access:
#Modify:
#Change:

1
2
3
4

#-a     change only the access time
#-m     change only the modification time
#-d     instead of current time
#-t     instead of current time

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#xargs能够处理stdin并将其转换为特定命令的命令行参数
#也可以将单行或多行输入文本转换成其他格式(如多行变单行)
cmd | xargs


#将多行输入转换为单行输出
echo -e "1\n2\n3" | xargs	#将换行符替换为空格
#将单行输入转换成多行输出
echo "1 2 3" | xargs -n 1	#每行一个参数
echo "hahaZhahaZhahaZhaha" | xargs -n 2 -d Z	#-d指定分隔符


#读取stdin，将格式化参数传递给命令
cat test.txt | xargs -n 1 ./zhang.sh	#zhang.sh arg1; zhang.sh arg2... 每次提供一个参数
cat test.txt | xargs -n X ./zhang.sh	#X为参数个数，一次提供全部参数


#指定替换字符串
cat test.txt | xargs -I {} ./zhang.sh {}


#结合find使用xargs
find . -type f -name "*.txt" -print0 | xargs -0 ls	#-print0无换行输出, -0将\0作为输入界定符


#统计某文件行数
find /path -type f -name "*.c" -print0 | xargs -0 wc -l


#结合stdin，运用while和子shell
cat file.txt | while read arg; do cat $arg; done == cat file.txt | xargs - {} cat {}
cmd0 | (cmd1; cmd2; cmd3) | cmd4	#子shell

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#tr命令经常用来编写优美的单行命令
#tr可对来自stdin的字符 进行替换、删除以及压缩


echo "AH WONDERFUL" | tr 'A-Z' 'a-z'	#转换大小写
echo "AH WONDERFUL" | tr 'A-Z' 'a-b' --> ab bbbbbbbbb
#tr [option] set1 set2
#如果两个字符集长度不相等，那么set2会不断重复其最后一个字符，直到长度与set1相同


echo 12345 | tr '0-9' '9876543210'	#数字加密
echo 87654 | tr '9876543210' '0-9'	#数字解密


echo 'He is a cool boy, and she is a beautiful girl' | tr 'A-Za-z' 'NOPQRSRUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm'	#加密
echo 'Ur vf n pbby obl, naq fur' | tr 'NOPQRSRUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm' 'A-Za-z'	#解密

cat 1.txt | tr '\t' ' '	#将制表符转换为空格


#删除字符
echo "Hello 530 World" | tr -d '0-9'	#-d删除，删除数字
Hello  World
echo "Hello 520 World" | tr -d -c '0-9'	#-c补集
 520


#压缩字符，将连续的重复字符压缩为单个字符
echo "GNU's    not   Unix" | tr -s ' '	#-s压缩，压缩空格
GNU's not Unix


echo -e "1\n2\n3\n4\n5" > sum.txt
cat sum.txt | echo $[ $(tr '\n' '+') 0 ] -- echo $[1+2+3+4+5+0]


#tr字符类
\a	终端鸣响
\b	退格
\f	换页
\n	换行
\r	回车
\t	水平制表符
\v	垂直制表符
string1-stringN	#从字符1到字符N升序过程中的所有字符
[字符*次数]
[:alnum:]	#所有字母和数字
[:alpha:]	#所有字母
[:digit:]	#所有数字
[:lower:]	#所有小写字母
[:upper:]	#所有大写字母
[:graph:]	#所有可打印字符，不含空格
[:print:]	#所有可打印字符，包含空格
[:blank:]	#所有水平排列的空白字符
[:cntrl:]	#所有控制字符
[:punct:]	#所有标点字符
[:space:]	#所有空白字符
[:xdigit:]	#所有十六进制数
[=字符]	#指定字符

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#校验和(checksum)程序从文件中生成校验和密钥，然后利用校验和密钥核实文件的完整性
#校验和对于编写备份脚本或系统维护脚本非常重要，因为它们都会涉及通过网络传输文件
#通过使用校验和核实，我们就可以识别那些在网络传输过程中出现损坏的文件，并重传，从而确保数据完整性
#校验和对于核实数据完整性非常有用
#广泛使用的校验和技术有：md5sum, sha1sum


#对单个文件进行校验
md5sum sum.txt > sum.md5
#302c28003d487124d97c242de94da856  sum.txt
md5sum -c sum.md5	#-c检查
#sum.txt: 确定


#对目录进行校验
#对目录计算校验和意味着我们需要对目录中的所有文件以递归的方式进行计算
yum install -y md5deep
md5deep -r ./dir > dir.md5	#recursive递归
md5sum -c dir.md5


#可以将测试dir下某个文件更改一下，校验的时候会报错

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#sort - 对文本文件进行行排序
#uniq - 删除排序文件中的重复行


echo -e "333\n1" > 1.txt; echo -e "22\n22" > 2.txt
sort 1.txt 2.txt -o ./sorted.txt
#1
#22
#22
#333
cat sortec.txt | uniq
#1
#22
#333


sort -n	#按数字进行排序
sort -r	#逆向排序
sort -M	#按月份排序
sort -C	#检查是否排序
sort -b	#忽略空白


#依据键或列进行排序
sort -k 2 data.txt	#依据第二列来排序


#uniq要么使用管道，要么使用排过序的文件作文输入
uniq -u sorted.txt	#只显示唯一的行(即没有重复出现的行)
uniq -d sorted.txt	#只显示重复的行
uniq -s 2 -w 2 sorted.txt	#-s忽略前2个字符，-w指定用于比较的最大字符数

1
2
3
4
5
6

#在编写shell脚本时，我们经常需要存储临时文件。最适合存储临时数据的位置是 /tmp
#/tmp目录中的内容会在系统重启后被清空

filename=$RANDOM	#RANDOM返回一个随机数
filename2=$$	#当前shell的PID
filename3=$((date +%F))	#通过日期命令

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#某些情况下，需要把文件分割成多个更小的片段
dd if=/dev/zero bs=100k count=1 of=./data.file	#生成一个大小100k内容全是0的文件
split -b 20k data.file	#-d指定分割大小
#data.file xaa xab xac xad xae,这五个文件都为20k
#我测试了一下，几个文件加起来数据没变，几个文件总行数没变
#单位有 k, m, G, c(byte), w(word)
#-d以数字为后缀， -a指定后缀长度


split data.file -b 20k -d -a 2 spt	#增加前缀名'spt'
#data.file  spt00  spt01  spt02  spt03  spt04


split -l 10 data.file	#-l按行数来分割文件
#split只能根据大小或行数分割文件


#csplit可以根据文件本身特点进行分割
-f	#指定分割后文件前缀
-n	#指定分割后文件后缀数字个数
-b	#指定后缀格式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#借助%操作符将名称从 “名称.扩展名” 格式中提取出来


file="zhang.txt"
name1=${file%.*}	#删除位于%右侧的通配符(.*)所匹配的字符串，通配符从右向左进行匹配
#zhang
#*号通配符，.号
#%属于非贪婪匹配(non-greedy),它会匹配通配符最短结果
#%%属于贪婪匹配(greedy)，它会匹配符号条件的最长字符串



name2=${file#*.}	#删除位于#右侧的通配符(*.)所匹配的字符串，通配符从左向右进行匹配
#txt
# #属于非贪婪匹配
# ##属于贪婪匹配


#栗子
URL=“www.google.com”
echo ${URL%.*}	#非贪婪匹配，移除最右边.及其后面内容
www.google
echo ${URL%%.*}	#贪婪匹配
www
echo ${URL#*.}	#非贪婪匹配，移除最左边.及其前面内容
google.com
echo ${URL##*.}	#贪婪匹配
com

1
2
3
4
5
6

#Linux大多数发行版都含有一份词典文件，另外还有一个被称为aspell的拼写检查命令
#words --> /usr/share/dict/linux.words

grep "^good" /usr/share/dict/linux.words

aspell

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#写一个读取交互式输入脚本
vi jiaohu.sh

#!/bin/bash
read -p "Input a number:" num
read -p "Input name:" name
echo "You have enterd number:$num, name:$name"

echo -e "1\nzhang" | ./jiaohu.sh
You have entered number:1, name:hello


#or
echo -e "1\nzhang" > input.txt
./jiaohu.sh < input.txt


#交互式输入自动化
#用expect实现自动化
yum install -y expect
vim auto_expect.sh


#!/bin/expect
spawn ./jiaohu.sh	#spawn指定需要自动化哪一个命令
expect "Input a number:"	#expect提供需要等待的消息
send "1\n"		#send是要发送的消息
expect "Input name:"
send "zhang"
expect eof	#expect eof指明命令交互结束

./auto_expect.sh

1
2
3
4
5

#dd命令会克隆给定的输入内容，然后将一模一样的副本写到输出
#如果不指定if，dd会从stdin中读取输入；如果不指定of，dd会输出到stdout
#/dev/zero是一个字符设备，它会不断返回0值字节(\0)

dd if=/dev/zero of=junk.data bs=1M count=1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#comm命令用于两个文件之间的比较
#交集(intersection),差集(set difference), 求差
#comm必须使用排过序的文件作为输入


echo -e "1\n2\n3" > A.txt && echo -e "3\n2\n3" > B.txt
sort -n A.txt -o A.txt && sort -n B.txt -o B.txt
comm A.txt B.txt
#输出第一列为A独有，第二列为B独有，第三列为交集


comm A.txt B.txt -1 -2
#-1从输出中删除第一列，-2删除第二列，-3删除第三列

1
2
3
4

#重复文件指的是那些虽然名字不同但内容却一模一样的文件

ls -lS	#以文件大小排序，识别大小相等的文件
md5sum	#接下来计算这些文件的校验和

1

mkdir -p /home/zhang/1/22/333 2>/dev/null

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#用户(user)，用户组(group)，其他用户(other)

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


#用户还有一个称为setuid(S)的特殊权限，它出现在用户的x位置
#setuid权限允许用户以其拥有者的权限来执行可执行文件，即便这个文件是由其他用户运行的
-rwSrw-r--



#组也拥有一个setgid(S)权限，它出现在组的x位置
#它允许以同该目录拥有者所在组相同的有效组权限来运行可执行文件
-rwxrwSr--



#目录有一个特殊权限，叫做粘滞位(sticky bit)(T或t)，出现在其他用户的x位置
#当一个目录设置了粘滞位，只有创建该目录的用户才能删除目录中的文件,即便group和other有w权限
-rwxr--rwT



chmod u=rwx g=rw o=r file1
chmod u+x g-w file2
chmod 744 file3


chmod a+x . -R	#以递归方式设置权限
chown user.group . -R	#以递归方式设置所有权


chmod a+t dir1	#设置粘滞位


chmod +s fiel4
chown root.root file4
chmod +s file4
./file4	#每次file4都是以root运行

#setuid的使用不是无限制的，它只能应用在Linux ELF格式二进制，而不能用于脚本文件。

1
2
3
4
5
6

#不可修改(immutable),是保护文件不被修改的安全手段之一。
#一旦文件被设置为不可修改，任何用户(包括root)都不能修改，除非将其不可修改属性移除

chattr	#修改文件在Linux第二扩展文件系统(E2fs)上的特有属性
chattr +i file1	#这样就无法删除file1
chattr -i file1

1
2
3
4
5
6
7
8
9

#touch命令可用来生成空白文件，如果文件存在，则可以用它修改文件的时间戳

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


touch -a/-m	#更改文件访问/修改时间
touch -d "Thu Oct 31 14:20:13 CST 2017" file1	#指定特定时间戳

1
2
3
4
5
6
7

#符号链接(软链接)只不过是指向其他文件的指针

ln -s /usr/bin /bin
ls -l / | grep "^l"
find / -maxdepth 1 -type l

readlink /bin	#找出链接目标

1
2
3
4

#在Unix/Linux系统中，文件类型并不是由文件扩展名决定的

file /etc/passwd
file -b /etc/passwd

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#环回文件系统是指那些在文件中而非物理设备中创建的文件系统

dd if=/dev/zero of=loopback.file bs=1G count=1
mkfs.ext4 loopback.file
mount -o loop loopback.file /mnt/loopback	#-o loop来挂载环回文件
df -h
umount /mnt/loopback


#将ISO文件作为环回文件挂载
mount -o loop linux.iso /mnt/iso

1
2
3
4
5
6
7
8

#可引导光盘自身具备引导能力，也可以运行操作系统或其他软件。不可引导光盘则做不到这些。

cat /dev/cdrom  > /dev/sdc	#sdc指U盘
dd if=/dev/cdrom of=/dev/sdc	#将ISO写入usb存储设备
mkisofs -V "Label" -o /dev/sdc /dev/cdrom


cdrecord -v dev=/dev/cdrom image.iso

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#补丁文件(patch file)
#diff命令可以生成差异文件

diff -u file1 file2	#一体化形式输出
diff -u file1 file2 > diff.patch
patch -p1 file1 < diff.patch	#得到file2
patch -p1 file2 < diff.patch	#得到file1
patch -R file1 < diff.patch; patch -R file2 < diff.patch	#还原


#diff也能够以递归的形式作用于目录，它对目录中所有内容生成差异输出
diff -Naur dir1 dir2
#-N将所有确实文件视为空文件， -a将所有文件视为文本文件
#-u生成一体化输出， -r遍历目录下所有文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

echo -e '1\n1\n1\n1' > /tmp/1.txt
echo -e '1\n1\n0\n1' > /tmp/2.txt


#比较
diff -u 1.txt 2.txt
--- 1.txt       2018-12-14 16:08:36.457495835 +0800
+++ 2.txt       2018-12-14 16:08:37.574495820 +0800
@@ -1,4 +1,4 @@
 1
 1
-1
+0
 1


#解释
--- 1.txt       2018-12-14 16:08:36.457495835 +0800
+++ 2.txt       2018-12-14 16:08:37.574495820 +0800
#第一部分，是文件的基本信息
#---表示变动前的文件
#+++表示变动后的文件


@@ -1,4 +1,4 @@
#第二部分，变动的位置用两个@作为起首和结束。
#-号表示第一个文件(1.txt), 1表示第一行，4表示连续四行。也就是第一个文件从第一行开始连续四行
#+号表示第二个文件(2.txt), 1表示第一行，4表示连续四行。


 1
 1
-1
+0
 1
#第三部分表示变动的具体内容
#除了有变动的那些行以外，也是上下文各显示3行。它将两个文件的上下文合并显示在一起，所以称为合并显示
#每一行最前面的标志位，空表示无变动，减号表示第一个文件删除的行，加号表示第二个文件新增的行

1
2
3
4
5
6

head file1; tail file1	#head与tail默认打印10行
head -n 5 file1; tail -n 6 file1	#指定行数
head -n -5 file1	#打印除了最后5行外所有行
tail -n +(5+1) file1	#打印除了开始5行外所有行

tail -f /var/log/nginx/access.log	#--follow，动态关注文件

1
2
3
4

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#在命令行中使用pushd和popd快速定位，pushd和popd以栈的方式运作
#当没有鼠标时，复制粘贴就不怎么实用了
#pushd和popd可以用于在多个目录之间进行切换而无需复制并粘贴目录路径

pushd /home/user1; pushd /home/user2; pushd /home/user3	#将路径添加到栈
pushd +2	#切换到/home/user3

popd	#移除最近添加入栈的目录


cd /root; cd /home/user
cd -	#回到上次的目录
cd ..	#切换到上一级目录
cd ~	#切换到用户主目录

1
2
3
4
5
6
7

#wc(word count)，是一个统计工具

wc -l file1	#统计行数
wc -w file1	#统计单词数
wc -c file	#统计字符数
wc -L file	#打印最长行长度
wc file1	#行、单词、字符数

1
2
3
4
5
6
7
8
9

#tree命令是以图形化的树状结构打印文件和目录,在Linux发行版中默认未安装

yum install -y tree
tree /home/zhang
tree /home/zhang -P "*.sh"	#只标记出.sh文件
tree /home/zhang -I "*.sh"	#标记出除.sh文件外所有文件
tree /home/zhang -h	#显示大小

tree /home/zhang -H http://localhost -o tree.html	#以html形式输出目录树

1
2
3
4
5
6

#匹配一个ipv4地址
[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}


#匹配一个邮箱地址
[\w]+@[\w]\.com

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

grep "匹配文本/通配符" file1 file2... --color=auto	#重点标记匹配
grep -E "正则表达式" file
egrep "正则" file


grep -v	#反向匹配
grep -c	#统计匹配行数
grep -n	#打印出匹配的行号
grep -o	#唯一匹配
grep -l	"匹配" file1 file2	#返回匹配的文件名
grep -R	#递归匹配
grep -i	#忽略大小写
grep -e "匹配1" -e "匹配2"	#匹配多个样式
grep -f match.txt file1	#从match.txt文件读取匹配
grep "匹配" --include=*.{sh,txt} --exclude=*.log --exclude-dir=/home/user -r /home	#包括或排除文件
-A/-B n	#输出匹配 之后/之前 n行
-c n	#输出匹配 前后 n行



#正则匹配多个
egerep "(a|b)"

1
2
3
4
5
6
7

#制表符'\t' 是cut默认的定界符
cut -d' ' -f1 1.txt	#-d指定分隔符，-f打印第几个字段
cut -f1,2,3	#打印1,2，3列
-c字符；	-b字节；
cut -c 1-5 1.txt	#打印1-5字符
cut -c -2 1.txt	#打印前2个字符
cut -c 3-	#打印第3个字符到行尾

1
2
3
4

#单词解析可以用 关联数组,正则表达式配合sed,awk,grep等工具来完成
#关联数组中，将单词作为数组索引，单词次数作为数组值

egrep -o "\b[:alpha:]+\b"	#匹配单词

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#sed - stream editor for filtering and transforming text
#字符/在sed中最为定界符使用


#替换
#sed 's/匹配样式/替代字符串/'
sed 's/pattern/repalce/' file	#替换
sed -i 's/pattern/repalce/' file	#将替换应用于file


echo "1.txt" > 1.txt && sed 's/txt/haha' 1.txt	#在输出中用haha替换txt
sed -i 's/txt/haha/' 1.txt	#将1.txt文件中的txt用haha替换掉
#-i选项替换原文件


echo "hahaha" | sed 's/ha/HA/g'	#全部替换
echo "hahaha"	| sed 's/ha/HA/2g'	#指定位置替换，从第2处开替换全局


#移除匹配样式的行
sed '/pattern/d
sed '/^$/d'	##移除空白行


#在sed中用&标记已匹配字符串
echo "A wonderful goal" | sed 's/\w\+/[&]/g'	#\w\+匹配每一个单词


#子串匹配标记\1,\2...
echo "1st 2nd 3rd" | sed 's/\(\w\+\) \(\w\+\) \(\w\+\)/\2 \1 \3/'
2nd 1st 3rd
#将\2和\1交换次序，(),+等在sed中要转义，否则要报错


#组合多个表达式
sed 'expression1; expression2; ...
echo "aabbcc" | sed 's/a/A/; s/b/B/; s/c/C/g'
AaBbCC


#双引号 " " 内的特殊符号（如$等），可以保有原本的特性
#单引号 ' ' 内的特殊字符则仅为一般字符（纯文本）
#引用
text=hello
echo 'hello world' | sed "s/$text/HELLO/"
HELLO world

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

#awk ‘begin{print "start"} pattern {command} end{print "end"}’ file

awk '{sum += $1}; {print sum}'

#awk脚本由:begin块、end块和能使用模式(pattern)匹配的通用语句块 组成
#3个部分都是可选的
#awk也可以从stdin中读取内容

cat /etc/passwd | awk -F: '{print $1}'	#-F指定界定符


#awk中的特殊变量
#NR：记录数量(number of records)，对应于当前行号
#NF：字段数量(number of fields)，对应于当前行的字段数
#$0：执行过程中当前行的文本内容
#$1,$2...$NF：第1个/2个.../最后一个 字段的内容

echo -e "L1 1\nL2 22\nL3 333" | awk '{print NR NF $0 $1 $2}'
# NR NF $0    $1  $2 $NF=最后一个=$2
  1  2  L1 1  L1  1  1
  2  2  L2 2  L2  2  2
  3  2  L3 3  L3  3  3


#将外部变量传递给awk
#-v选项可将外部值传递给awk
#  -v var=val  --assign=var=val

var='12345'
echo | awk -v v1=$var '{print v1}'


#多个变量
var1=111; var2=222
echo | awk '{print v1,v2}' v1=$var1 v2=$var2


#变量来自文件而非标准输入
awk '{print v1,v2}' v1=$var1 v2=$var2 file


#用样式对awk进行过滤处理
awk 'NR < 3,NR==4' 1.txt	#行号<5的行
awk '/linux/' 1.txt	#匹配带有linux的行（可用re）
awk '!/linux/' 1.txt #!匹配不带linux的行


#设置定界符
awk -F: '{print $1}' /etc/passwd
awk '{FS=":"} {print $1}' /etc/passwd
awk '{FS=":"; print $1}' /etc/passwd


#从awk中读取命令输出，用getline读取行
echo | awk '{"grep root /etc/passwd" | getlin out; print out}'
root❌0:0:root:/root:/bin/bash


#在awk中使用循环
awk '{for(i=1;i<4;i++) {print $i}}' 2.txt	#输出第1,2,3列



#使用awk删除某列
awk -F' '    '{$1=null;$2=null;print}' ./file

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#迭代文件中的每一行
echo -e "1\n22\n333" | while read line;do echo $line;done
grep "bash" /etc/passwd | while read line;do echo $line;done
#1
#22
#333


#迭代一行中的每一个单词
echo "1 22 333" | while read line;do for word in $line;do echo $word;done;done
#1
#22
#333


#迭代一个单词中的每一个字符
echo "abc" | while read line;
do
	for word in $line;
	do
    	for((i=0;i<${#word};i++));
		do
        	echo ${word:i:1};
		done;
	done;
done

#写成一行
echo "abc" | while read line; do for word in $line; do for((i=0;i<${#word};i++)); do echo ${word:i:1}; done; done; done
#a
#b
#c
#${#word}返回变量word的长度

1
2
3
4
5
6
7
8

#paste - merge(整合) lines of files
echo -e  "1\n2\n3" > 1.txt && echo -e "Line1\nLine2\nLine3" > 2.txt
paste 1.txt 2.txt
1	Line1
2	Line2
3	Line3
#默认定界符是制表符，用-d指定
paste 1.txt 2.txt -d','

1
2

awk -F':' '{print $1,$3}' file1
cut -d':' -f 1,3 file1

1
2
3
4
5
6

awk 'NR==1,NR==10' /etc/passwd
awk 'NR==1,NR==10' /etc/passwd | awk -F":" '{print $1,$NF}' #打印特定行内的特定列

awk '/start_pattern/, /end_pattern/' file	#打印start到end之间的内容,可使用re
awk '/root/, /zhang/' /etc/passwd	#打印root到zhang之间内容
awk '/^ro.?t'/, /bash$/' /etc/pass

1
2
3

#tac - 反转显示文件中的行，行内的内容无法用tac反向排列
tac 1.txt
awk '{lifo[NR]=$0; lno=NR} END{ for(;lno>-1;lno--) {print lifo[lno]};}' 1.txt

1
2
3
4
5
6
7
8
9

#egrep


#匹配一个邮箱地址
egrep -o '[a-zA-Z0-9.]+@[0-9a-zA-Z.]+\.[a-zA-Z]{2,4}' emails.txt


#匹配一个URL地址
egrep -o "http://[a-zA-Z0-9.]+\.[a-zA-Z]{2,3}" urls.txt

1
2
3

grep "zhang" /etc/passwd -A 5	#Ater
grep "zhang" /etc/passwd -B 5	#Before
grep "zhang" /etc/passwd -C 5	#前后五行都打印

1

sed 's/[^.]*handsome boy[^.]*\.//g' file.txt	#句子以.结束

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#替换变量内容中的部分文字
var="One two three"
echo ${var/t/T}	#只替换了一个
#One Two three


#指定字符串起始位置和长度
#${变量:开始部分:长度}
${vari:start:length}
echo {var:0:2}	#On
echo {var:1:6}	#ne two


#起始字符的索引是0,将最后一个字符索引记为-1
echo ${var:(-1)}	#e
echo ${var3}	#ree

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#Wget - The non-interactive(非交互式) network downloader

wget URL1 URL2...
wget http://xxx.com/nginx-1.12.0.tag.gz
wget https://xxx/a.rpm http://xxxx/bb.rpm


#指定文件名，指定信息输出(wget默认是stdout)
wget http://mirrors.aliyun.com/repo/Centos-7.repo -O aliyun.repo -o ./wget.log
wget URL -t 5	#-t，重试次数


#下载限速
wget --limit-rate=10m URL	#下载限速
wget -Q 100m URL	#指定下载配额


#端点续传
#wget进行的下载在完成前被中断，从断点开始下载
wget -c URL


#用cURL下载
#cURL是一个比wget更强大的高级命令工具
#和wget不同，curl并不将下载数据写入文件，而是写入stdout，因此必须重定向到文件


#复制或镜像整个网站
#wget有一个选项可以使其像爬虫一样以递归方式手机网页上所有URL链接，并逐个下载
#这样一来就可以下载一个网站的所有页面
wget --mirror URL
#-m(--mirror) -N -r -l inf --no-remove-listing 的缩写形式。
或 wget -r -N -l DEPTH URL
#-r递归下载，-l指定递归深度，-N(timestamp)只获取比本地时间新的文件


#访问需要认证的HTTP或FTP页面
wget --user "username" --password "pass" URL
#如未在命令行内输入密码，则会由网页提示手动输入

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#links - lynx-like alternative character mode WWW browser

#在命令行中浏览一个网页
links www.baidu.com


#以ASCII形式下载网页
links --dump URL > URL.txt


#打开本地html文件
links 1.html

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

#curl - transfer a URL
#cURL通常将下载文件输出到stdout，将进度信息输出到stderr
#要想避免显示进度信息，可使用--silent
#curl可用来下载、发送各种HTTP请求、指定HTTP头部等操作

curl URL --silent	#输出到stdout


#-O写入文件，文件名从URL中解析
curl http://www.baidu.com/index.html -O --silent	#创建index.html


#-o将数据写入指定文件
curl URL -o baidu.html --progress	#--progress显示进度条
links baidu.html


#端点续传
#和wget不同，cURL包含更高级的下载恢复特性，能够从特定的文件偏移处继续下载
#curl可以通过指定一个偏移量来下载部分文件
手动：curl URL/file -C offset	#偏移量以Byte为单位的整数
自动：curl -C -URL	#自动续传


#用cURL设置参照页字符串, --referer
#参照页(referer)是位于HTTP头部中的一个字符串，用来标识用户从哪个页面到达当前页面的
#如果用户点击网页A中某个链接，转到了网页B。那么网页B头部的referer会包含网页A的URL
curl --referer Referer_URL target_URL
curl --referer http://www.baidu.com http://jianshu.com


#用cURL设置cookie, --cookie
#可以用curl来存储HTTP操作过程中使用到的cookie
#cookie用key=value形式，指定多个用 分号 分隔
curl URL --cookie "user=AAA;name=bbb"
curl URL --cookie-jar cookie.txt	#将cookie另存为


#用cURL设置用户代理字符串, --user-agent
#如果不指定代理，一些需要用户代理的网页就无法显示
curl URL --user-agent(-A) "Mozilla"


#用-H "头部信息"传递多个头部信息
curl -
H "Host:www.haha.com" -H "Accept-language: en" URL

#限定cURL可占用的带宽
curl URL --limit-rate 10m


#指定最大下载量
curl URL --max-filesize 大小(Bytes)


#用cURL进行认证，-u username:password指定用户名和密码
curl -u user:pass URL
curl -u user URL	#手动输入密码


#只打印响应头部信息(无数据部分), -I
curl -I URL

1
2

curl -u user http://mail.163.com
#手动输入密码

1
2
3
4
5
6
7

curl -s URL | grep -o "<img src=[^>]*>" | sed 's/<img src=//g; s/>//g' > img.list
#匹配图片的URL，可能还需要细化修改
#不同的URL可能有不同的规则，根据实际情况取出img的URL


#下载图片
wget $URL 或 curl -s -O $URL

1
2
3
4
5
6
7
8
9

lynx -traversal URL #会将URL中所有链接生成到reject.dat文件中
sort -u reject.dat | while read link
do
	output=`curl -I $link -s | grep "HTTP/.*OK"`
    if [[ -z $output ]]
    then
    	echo $link
    fi
done < links.txt

1
2
3

curl URL --silent -o `date +%F`.html	#第一次
curl URL --silent -o `date +%F`.html	#第二次
diff -u 第一次 第二次

1
2
3
4

curl URL -d “postarg=AABBCC” #-d,http post data
curl URL -d "post1=key1&post2=key2&post3..."	#指定多个数据

wget URL -post-data "post1=key1"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

#归档文件，-c(create file)
tar -cf 1.tar [sources]	#-f(specify filename)指定文件名


#文件名必须紧跟在-f之后
tar -cvf txt.tar *.txt	#-v(verbose)详细信息


#向已归档文件中添加文件，-r
tar -rvf txt.tar *.html


#列出归档文件中的内容，-t
tar -tf txt.tar	#列出归档内容
tar -tvf txt.tar	#列出内容详细信息


#从归档文件中提取文件或文件夹，-x(exact)
tar -xf txt.tar	#默认提取到当前目录
#-C指定提取目录
tar -xvf txt.tar -C /dir/path
#只提取归档中特定文件
tar -xf txt.tar 1.txt 1.html -C /tmp	#只会提取1.txt和1.html文件


#在tar中使用stdin和stdout
tar -cvf - *.text | tar -xvf - -C /tmp


#拼接两个归档文件，-A
tar -Af txt.tar html.tar
tar -tvf txt.tat	#验证是否成功


#添加选项，可以将指定的任意文件加入到归档文件中。如果同名文件已存在，不会覆盖源文件，那么结果就是归档中包含了多个同名文件
#通过检查时间戳来更新对党文件中的内容，-u
#只有比归档文件中同名文件 更新(newer) 才添加
tar -uvf html.tar 1.html


#比较归档文件与文件系统中的内容，-d
tar -df txt.tar 1.txt 2.txt


#从归档文件中删除文件，--delete
tar -f txt.tar --delete 1.txt 2.txt


#从归档文件中排除部分文件,--exclude
tar -cf all.tar ./* --exclude="*.html"	#排除.html文件
tar -cvf txt.tar *.txt --exclude="1.txt"


#打印总字节数,--totals
tar -cf all.txt ./* --totals


#压缩tar归档文件，指定不同压缩格式

#-z,	.tar.gz
#-j,	.tar.bz2
#--lzma,	.tar.lzma,
#.tar.lzo
tar -czvf txt.tar.gzip *.txt
tar -xzvf txt.tar -C /dir/path


#tar后删除原文件
tar -czvf txt.tar.gz ./txt --remove-files

1
2
3
4
5
6
7
8

touch file{1..4}

echo file1 file2 file3 file4 | cpio -ov file.cpio
#-o指定输出，-v打印归档文件列表


#-i指定输入，-t列出归档中文件
cpio -it < file.cpio

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

gzip file	#file.gz，会覆盖原文件
gunzip file.gz	#file，也会删除原文件


#列出压缩文件的属性信息，-l
gzip -l file.gz


#指定gzip的压缩级别，--fast或--best
--fast	最低压缩比，最快速度完成
--best	最高压缩比，最慢速度完成


#将gzip与归档文件结合，-z
tar -czvf txt.tar.gzip ./*.txt
#-a指定从文件扩展名自动判断压缩格式
tar -cavf txt.tar.gzip ./*.txt


#tar只能从命令行中接收有限个文件，要解决这个问题，可以写一个循环并添加-r选项


#解压缩，-x
tar -xzvf txt.tar.gzip
tar -xavf txt.tar.gzip -C /dir/path

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

bzip2 file	#file.bz2,同理会覆盖原文件
bzip2 file -k	#保留原文件
bunzip2 file.bz2	#解压缩
bunzip file.bz2 -k


#从stdin读入并写到stdout
cat file | bzip2 -c > file.bz2


#将bzip2与归档文件结合，-j
tar -cvjf 1.tar.bz2 ./1.*
tar -cavf 1.tar.bz2 ./1.*	#-a根据文件扩展名自动判断压缩格式
tar -xjvf 1.tar.bz2
tar -xavf 1.tar.bz2 -C /tmp


#压缩比
#从1级(速度最快，压缩率最低)到9级
bzip -9 -k file


#对成千上万的文件进行归档，需要借助 循环和-r选项

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

lzma file	#file.lzma,同样也会删除原文件
lzma file -k 	#保留原文件
unlzma file.lzma

#从stdin读入并写入stdout
cat file | lzma -C > file.lzma

#与tar相结合,--lzma
tar -cvf 1.tar.lzma ./1.* --lzma
tar -cavf 1.tat.lzma ./1.*	#自动判断
tar -xvf 1.tar.lzma --lzma
tar -xavf 1.tar.lzma -C /tmp

#压缩率
#从1级到9级(压缩级别最高，速度最慢)

#对成千上万的文件，需要使用循环和-r选项

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

zip file.zip file
unzip file.zip
#与lzma,gzip,bzip2相比，zip完成后不会删除原文件


#对目录和文件进行递归操作,-r
zip -r dir.zip /root/test ./file


#向归档文件中增加内容，-u
zip dir.zip -u newfile


#从压缩文件中删除内容，-d
zip -d dir.zip file


#列出归档文件中内容
unzip -l dir.zip

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

yum install squashfs-tools -y

#创建squashfs文件
mksquashfs source compressfile.squashfs

mksquashfs /etc etc.squashfs
#/etc(67M) --> etc.suqashfs(18M)


#要挂载squashfs文件，利用环回形式进行挂载
mkdir /mnt/squash
mount -o loop etc.squashfs /mnt/squash
#此处挂载使用etc.squashfs文件系统
#如果直接查看etc.squashfs，就是一个普通文件，但是挂载以后所有文件都出现了
umount /mnt/squash


#在创建squashfs文件时排除指定文件，-e
mksquashfs /etc etc.squashfs -e /etc/passwd /etc/shadow /etc/*.txt
#在挂载之后就没有相关文件了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

ccrypt 1.txt	#会要求输入口令(encryption key)
#之后会生成1.txt.cpt覆盖原文件


#更改key,-x
ccrypt -x 1.txt.cpt	#输入old key和new key


#解密，-d(--decrypt)
ccrypt -d 1.txt.cpt	#输入key解密

1
2
3
4
5

#加密，-c(--symmetric)对称加密
gpg -c file	#会要求输入口令(Passphrase)，生成file.gpg

#解密
gpg file.gpg

1
2
3
4
5
6

#将文件编码为base64格式
base64 file > outputfile
cat file | base64 > outputfile

#解码,-d
base64 -d outputfile > file

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

echo "1.txt" > 1.txt
md5sum 1.txt	#生成密钥到stdout
#39061daa34ca3de20df03a88c52530ea  1.txt


sha1sum file	#生成密钥到stdout
#659fcbc505db207c03b5c4c0b6981d63286abe21  1.txt


#查看/etc/shadow中密码的散列值
awk 'NR==1' /etc/shadow | awk -F: '{print $2}'	#root密码散列
#$6$BxpV48gPsjuq6.pF$wE7pUDwtOI.v64kd5folG68yUt2UAQDTUGgKa5Iz69GaupEoRAdCeerP8nRKXo48c4azutUCGhnDgzd1qe8YX0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#/etc/passwd里面的密码散列类型就是salted散列


#查看root密码对应的散列值
head -1 /etc/shadow
root:$6$ZlHRCZG2iRwQUXAu$RAEDH97nPdZB2RK20npua6Qf6jB7osatoC99ow3LtPQ6aORdLISYC7/4iTYU162emkQLt4ZafdgjyAeoSB7IU0::0:99999:7:::


#openssl - OpenSSL command line tool

#shadow密码是使用openssl生成
#将SALT_STRING替换为随机字符串，同时将pass替换成你想测试的密码
openssl -1 -salt SALT_STRING passwd

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#-a进行归档，-v详细信息
rsync -av source destination
rsync -av /etc /tmp


#异地cp
rsync -av source username@host:PATH
rsync -av username@host:PATH destination
#rsync借助于ssh，可以使用ssh无秘钥认证
rsync -av /etc [email protected]:~

#-z, --compress  compress file data during the transfer
rsync -avz [email protected]:/etc /tmp


#注意，路径格式
rsync /etc /tmp	#整个/etc目录
rsync /etc/ /tmp	#/etc目录下所有内容


#显示进度，--progress
rsync -avz --progress /etc /tmp


#排除部分文件，--exclude
rsync -avz /etc /tmp --exclude=/etc/nginx --exclude "*.txt"


#更新rsync时，删除不存在的文件，--delete
#默认情况下，rsync并不会在目的端删除源端已不存在的文件
rsync -avz /etc [email protected]:~ --delete


#定期调度
crontab -e
0 */10 * * * rsync -avz /etc user@host:PATH


#实时同步，inotifywait+rsync
yum install inotify-tools -y

#-m(monitor),-r(recursive),-q(--quiet)静默模式，-e(event)

vi inotify_rsync.sh
inotifywait -mrq -e creat,delete,modify,move --exclude "^.*\.filepart$" /etc | while read file
do
rsync -az --exclude=".*" --exclude="*.swp" --exclude=".filepart" --delete /etc /tmp > /dev/null 2>$1
done

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

mkdir /home/zhang/gittest
cd /home/zhang/gittest



#在源主机中添加用户信息
git config --global user.name "username"	#设置用户名
git config --global user.email "[email protected]"	#设置邮箱


#创建一个空的Git版本库或初始化一个老版本
git init


#记录变更到版本库
git commit


#添加远程git目录并同步备份
git remote add origin user@host:/home/zhang/gittest


#为git跟踪(git tracking)添加或删除文件
#add,添加内容至索引
git add *
#git add *.txt; git add *.ph	#添加部分文件


#删除不需要跟踪的文件和文件夹
#rm,从工作去和索引删除文件
git rm file
#git rm *.txt


#检查点或创建备份点(check point)
git commit -m "Commit Message"


#push,更新远程
git push


#用Git恢复数据
#log,显示提交日志
git log


#返回之前某个版本或状态
git checkout xxxxxxxx(Commit ID)


#clone,克隆一个版本库到本地
git clone URL
git clone user@host:PATH