• Linux中_Ubuntu上_使用命令总结整理_02

    文章目录

    目录：

    1、操作系统操作
    1、Linux 基础
    2、系统信息
    3、系统负载 – top
    4、程序开机自启动服务配置
    5、重定向_管道_流
    6、终端其他命令

    2、文件与目录操作
    1、文件和目录
    2、文件搜索
    3、查看文件内容
    4、文本处理
    5、文件的特殊属性-权限 - 使用 “+” 设置权限，使用 “-” 用于取消
    6、字符设置和文件格式转换
    7、打包和压缩，解压文件

    3、文件系统操作
    1、挂载一个文件系统
    2、文件系统分析
    3、初始化一个文件系统
    4、SWAP文件系统

    4、备份和光盘
    1、备份
    2、光盘

    5、OS包管理器，软件仓库
    1、RPM 包 - （Fedora, Redhat及类似系统）
    2、YUM 软件包升级器 - （Fedora, RedHat及类似系统）
    3、DEB 包 (Debian, Ubuntu 以及类似系统)
    4、APT 软件工具 (Debian, Ubuntu 以及类似系统)

    6、进程管理
    1、查看进程
    2、进程状态
    3、前台进程 & 后台进程
    4、守护进程
    5、持续监控Linux命令的执行情况
    6、僵尸进程

    7、登录与注销，关机 (系统的关机、重启以及登出 )

    8、用户和用户群组相关的命令

    9、磁盘空间

    10、网络 -（以太网和WIFI无线）操作

    11、编译安装软件

    12、JPS工具

    13、crontab 定时任务调度器

    14、vim 编辑器专题

    15、Shell编程相关

    16、bash常用命令

    17、Linux 快捷方式

    18、获取帮助

    1、操作系统操作

    1、Linux 基础

        1、操作系统
        操作系统 Operating System 简称 OS ，是软件的一部分，它是硬件基础上的第一层软件，是硬件和其它软件沟通的桥梁。

        操作系统会控制其他程序运行，管理系统资源，提供最基本的计算功能，如管理及配置内存、决定系统资源供需的优先次序等，同时还提供一些基本的服务程序。


    2、什么是 Linux
        1、Linux 系统内核与 Linux 发行套件的区别
            Linux 系统内核指的是由 Linus Torvalds 负责维护，提供硬件抽象层、硬盘及文件系统控制及多任务功能的系统核心程序。

            Linux 发行套件系统是我们常说的 Linux 操作系统，也即是由 Linux 内核与各种常用软件的集合产品。

            总结：真正的 Linux 指的是系统内核，而我们常说的 Linux 指的是“发行版完整的包含一些基础软件的操作系统”。

        
        2、Linux 对比 Windows
            稳定且有效率；

            免费（或少许费用）；

            漏洞少且快速修补；

            多任务多用户；

            更加安全的用户与文件权限策略；

            适合小内核程序的嵌入系统；

            相对不耗资源。

        
        3、Linux 系统种类
            红帽企业版 Linux ：RHEL 是全世界内使用最广泛的 Linux 系统。它具有极强的性能与稳定性，是众多生成环境中使用的（收费的）系统。

            Fedora ：由红帽公司发布的桌面版系统套件，用户可以免费体验到最新的技术或工具，这些技术或工具在成熟后会被加入到 RHEL 系统中，因此 Fedora 也成为 RHEL 系统的试验版本。

            CentOS ：通过把 RHEL 系统重新编译并发布给用户免费使用的 Linux 系统，具有广泛的使用人群。

            Deepin ：中国发行，对优秀的开源成品进行集成和配置。

            Debian ：稳定性、安全性强，提供了免费的基础支持，在国外拥有很高的认可度和使用率。

            Ubuntu ：是一款派生自 Debian 的操作系统，对新款硬件具有极强的兼容能力。Ubuntu 与 Fedora 都是极其出色的 Linux 桌面系统，而且 Ubuntu 也可用于服务器领域。

        
        4、终端连接阿里云服务器

            通过执行 ssh root@121.42.11.34 命令，然后输入服务器连接密码就可以顺利登陆远程服务器。从现在开始我们就可以在本地电脑操作远程服务器。

            这个黑色的面板就是终端也就是 Shell （命令行环境）。

            ssh root@xxx    这是一条命令，必须要在 Shell 中才能执行。

        
        5、Shell
            1、Shell 这个单词的原意是“外壳”，跟 kernel（内核）相对应，比喻内核外面的一层，即用户跟内核交互的对话界面。

                Shell 是一个程序，提供一个与用户对话的环境。这个环境只有一个命令提示符，让用户从键盘输入命令，所以又称为命令行环境（ command line interface ，简写为 CLI ）。Shell 接收到用户输入的命令，将命令送入操作系统执行，并将结果返回给用户。

                Shell 是一个命令解释器，解释用户输入的命令。它支持变量、条件判断、循环操作等语法，所以用户可以用 Shell 命令写出各种小程序，又称为 Shell 脚本。这些脚本都通过Shell 的解释执行，而不通过编译。

                Shell 是一个工具箱，提供了各种小工具，供用户方便地使用操作系统的功能。

            2、Shell 的种类
                Shell 有很多种，只要能给用户提供命令行环境的程序，都可以看作是 Shell 。

                历史上，主要的 Shell 有下面这些：

                    Bourne Shell（sh）

                    Bourne Again shell（bash）

                    C Shell（csh）

                    TENEX C Shell（tcsh）

                    Korn shell（ksh）

                    Z Shell（zsh）

                    Friendly Interactive Shell（fish）

                
                其中 Bash 是目前最常用的 Shell 。MacOS 中的默认 Shell 就是 Bash 。

                通过执行 echo $SHELL 命令可以查看到当前正在使用的 Shell 。
                还可以通过 cat /etc/shells 查看当前系统安装的所有 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
    • 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
    • 85
    • 86
    • 87

    2、系统信息

        arch                    显示机器的处理器架构
    
    dmidecode -q            显示硬件系统部件 - (SMBIOS / DMI) 
    
    uname -m                显示机器的处理器架构
    uname -r                显示正在使用的内核版本
    
    lspci -tv               罗列出所有的 PCI 设备  
    lsusb -tv               显示 USB 设备
    
    hdparm -i /dev/hda      罗列一个磁盘的架构特性 
    hdparm -tT /dev/sda     在磁盘上执行测试性读取操作
    
    cat /proc/cpuinfo       显示CPU info的信息 
    cat /proc/interrupts    显示中断 
    cat /proc/meminfo       校验内存使用 
    cat /proc/swaps         显示哪些swap被使用 
    cat /proc/version       显示内核的版本 
    cat /proc/net/dev       显示网络适配器及统计 
    cat /proc/mounts        显示已加载的文件系统
      
    hostname                查看当前主机名
    
    who                     登录在本机的用户与来源
                                -H或--heading 　显示各栏位的标题信息列。
    
    w                       登录在本机的用户及其运行的程序
                                -s 　使用简洁格式列表，不显示用户登入时间，终端机阶段作业和程序所耗费的CPU时间。
                                -h 　不显示各栏位的标题信息列。
                                
    write                   给当前联机的用户发消息
    
    wall                    给所有登录再本机的用户发消息
    
    ctime=`date +%Y-%m-%dT%k:%M:%S`         格式化时间，如2018-01-13T11:09:19， 注意%k 与 %H的区别，前者返回9，后者返回09.
    YESTERDAY=`date +%Y-%m-%d -d "-1 days"` 获取昨日日期
    
    clock -w                将时间修改保存到 BIOS
    
    users                   显示当前登录系统地用户
    
    date [参数]… [+格式] |  显示或设定系统的日期与时间
                                        【date常用参数】
                    -u 使用格林尼治时间
                    -r 最后一次修改文件的时间
                    -s 设置时间
                                        【date常用格式】:
                    %a 星期几的简称，例如一、二、三
                    %A 星期几的全名，例如星期一、星期二
                    %H 小时(以00-23来表示)。
                    %M 分钟(以00-59来表示)。
                    %P AM或PM。
                    %D 日期(含年月日)
                    %U 该年中的周数。
                    %T 显示时间格式，24小时制(hh:mm:ss)
                    %x 显示日期的格式(mm/dd/yy)
                    %y 年的最后两个数字
                    %Y 年(如2007、2008)
                    %r 时间(hh:mm:ss 上午或下午)
    date -s “2015-10-17 01:01:01″                       //时间设定
    date +%Y%m%d                                //显示前天年月日
    date +%Y%m%d --date="+1 day/month/year"     //显示前一天/月/年的日期
    date +%Y%m%d --date="-1 day/month/year"     //显示后一天/月/年的日期
    date -d '2 weeks'                           2周后的日期
    date                                        显示系统日期和时间（+%y 年  +%m 月  +%d日） 
    date 041217002007.00                        设置日期和时间-月日时分年.秒 
    
    cal [参数] 月份] [年份] |                 查看日历
                                        【cal常用参数】:
                    -1 显示当月的月历
                    -3 显示前、当、后一个月的日历
                    -m 显示星期一为一个星期的第一天
                    -s (默认)星期天为第一天
                    -j 显示当月是一年中的第几天的日历
                    -y 显示当前年份的日历
    cal                                     //显示当前日期  cal -y 
    cal 2007                                显示2007年的日历表

    netstat -rn         查询网关地址(如将centos服务器网络获取类型由dhcp切换为static时,需要获取到ip及网关信息进行固化配置时会用到,如本地ip为10.34.0.123,则通过如下命令查询到网关为第一个3.254):

        netstat -rn
        
        Kernel IP routing table
        Destination     Gateway         Genmask         Flags   MSS Window  irtt Iface
        0.0.0.0         10.34.3.254     0.0.0.0         UG        0 0          0 enp3g0
        10.34.0.0       0.0.0.0         255.255.252.0   U         0 0          0 enp3g0
        192.168.1.0     0.0.0.0         255.255.255.0   U         0 0          0 virbr0
        CentOS / RedHat 系列,查看操作系统信息(如果没有lsb_release命令, 使用"yum install redhat-lsb"安装):

        [root@server-test online]# lsb_release -a
        LSB Version:	:core-4.1-amd64:core-4.1-noarch
        Distributor ID:	CentOS
        Description:	CentOS Linux release 7.5.1804 (Core) 
        Release:	7.5.1804
        Codename:	Core
    
    last [选项] [<用户名>...] [...]     显示上次登录用户的列表。
                                        【last常用参数】:
                    -<数字>              显示行数
                    -a, --hostlast       最后一列显示主机名
                    -d, --dns            将 IP 号转换回主机名
                    -F, --file <文件>    用指定文件代替 /var/log/wtmp
                    -F, --fulltimes      打印完整的登录和注销时间和日期
                    -i, --ip             以数字和点的形式显示 IP 号
                    -n, --limit <数字>   要显示的行数
                    -R, --nohostname     不显示主机名字段
                    -s, --since <时间>   显示从指定时间起的行
                    -t, --until <时间>   显示到指定时间为止的行
                    -p, --present <时间> 显示在指定时间谁在场(present)
                    -w, --fullnames      显示完整的用户名和域名
                    -x, --system         显示系统关机项和运行级别更改
                     --time-format <格式>    以指定<格式>显示时间戳：
                                               notime|short|full|iso

                    -h, --help           display this help
                    -V, --version        display version

    lastlog [选项]        查看每个用户最后的登陆时间
                                        【lastlog常用参数】:
                    -b, --before DAYS             仅打印早于 DAYS 的最近登录记录
                    -C, --clear                   清除一个用户的最近登录记录(须配合 -u 使用)
                    -h, --help                    显示此帮助信息并推出
                    -R, --root CHROOT_DIR         chroot 到的目录
                    -S, --set                     设置最近登录记录为当前时间(须配合 -u 使用)
                    -t, --time DAYS               仅打印晚于 DAYS 的最近登录记录
                    -u, --user LOGIN              打印 LOGIN 用户的最近登录记录
    
    finger [选项] [使用者] [用户@主机] |     查看用户信息
                                        【finger常用参数】:
                     -s 显示用户的注册名、实际姓名、终端名称、写状态、停滞时间、登录时间等信息
                     -l 除了用-s选项显示的信息外，还显示用户主目录、登录shell、邮件状态等信息，以及用户主目录下的.plan、.project和.forward文件的内容。
                     -p 除了不显示.plan文件和.project文件以外，与-l选项相同

    • 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
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132

    3、系统负载 – top

        top [参数] |      获取进程的动态列表。显示当前系统正在执行的进程的相关信息，包括进程ID、内存占用率、CPU占用率等  

        展示的这些进程是按照使用处理器 %CPU 的使用率来排序的。
        
        
    top -d 20 -p 1303                   将进程号1303的系统负载，每隔20秒刷新一次。英文状态下，按住c键，将展示进行的详细环境信息

    top -d 20 -n 3 -b > test.txt        每隔20秒，一共执行3次， 将统计结果导入到test.txt文件中。           

    top -b -n 1         top命令显示不全，添加-w参数，-b为 批处理模式，-n为刷新的次数，
    
    top -b -n 1 -w 512  发现信息显示不全，最后man top，加一个参数w后，完全显示
    
    
    top -c -bw 500      如果需要显示完整的COMMAND命令，使用top -c参数，查看完整进程名， 按500个字符长度查看（这样基本可以查看到完整的命令）


    参数列表，官方解释： 

    1. 命令行选项
           top的命令行语法包括：

             -hv|-bcHiOSs -d secs -n max -u|U user -p pid -o fld -w [cols]

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

    典型的强制开关(‘-’)甚至空格都是完全可选的。
    【top常用参数】
    -h | -v :帮助/版本 显示库版本和使用提示，然后退出。

                       -b  :批处理模式操作。    以批处理模式启动top，这对于将输出从top发送到其他程序或文件非常有用。在这种模式下，top将不接受输入并运行，直到您使用命令行选项‘-n’设置的迭代限制或直到终止。

                   -c  :命令行/程序名切换。  从顶部开始，最后记住的‘c’状态颠倒。因此，如果top显示的是命令行，那么该字段将显示程序名称，反之亦然。有关更多信息，请参阅`c‘交互命令。

                   -d  :延迟时间间隔：-d ss.t(十分之一秒)。  指定屏幕更新之间的延迟，并覆盖个人配置文件或启动默认设置中的相应值。稍后，可以使用‘d’或‘s’交互命令更改此设置。

                        支持小数秒，但不允许使用负数。但是，在所有情况下，如果top在安全模式下运行，则禁止进行此类更改，但超级用户除外(除非使用了%s命令行选项)。有关以下内容的更多信息。
                        安全模式请参阅主题6a。系统配置文件。

                   -H  :线程模式操作。         指示TOP显示单独的线程。如果没有此命令行选项，则会显示每个进程中所有线程的总和。稍后，可以使用‘H’交互命令来更改这一点。

                   -i  :空闲进程切换          从顶部开始，最后记住的' i'状态颠倒。当此开关关闭时，自上次更新以来未使用任何CPU的任务将不会显示。有关此切换的其他信息，请参阅主题4c。任务区域命令，大小。

                   -n  :迭代次数限制为:-n number       指定top在结束前应产生的最大迭代数或帧数。

                   -o  :将排序字段重写为：-o fieldname   指定将在其上排序任务的字段的名称，与配置文件中反映的内容无关。您可以在字段名称前加上“+”或“-”，以覆盖排序方向。前导“+”将强制排序高到低，而“-”将确保从低到高的排序。
                        
                        此选项主要用于支持自动/脚本化批处理模式操作。

                   -O  :输出字段名称          此选项充当上述-o选项的帮助形式。它将导致top在单独的行上打印每个可用的字段名，然后退出。此类名称需经过nls翻译。

                   -p  :监控PID模式为：-pN1-pN2。。。或-pN1、N2、N3。。。

                        仅监视具有指定进程ID的进程。此选项最多可以放弃20次，或者您可以提供一个逗号分隔的列表，最多包含20个pid。允许将两种方法混合使用。

                        pid值为零将被视为顶级程序运行时的进程id。

                        这只是一个命令行选项，如果您希望返回正常操作，则无需退出并重新启动top，只需发出以下任何交互式命令：“=”、“u”或“u”。

                        “p”、“u”和“u”命令行选项互斥。

                   -s  :安全模式操作，以强制的安全模式启动top，即使是root。通过系统配置文件可以更好地控制该模式（请参见主题6）。文件）。

                   -S  :累计时间切换。
    从顶部开始，最后记住的“S”状态颠倒。当累计时间模式打开时，列出每个进程及其死子进程已使用的CPU时间。有关这方面的其他信息，请参阅‘S’交互命令。模式。

                   -u | -U  :用户筛选模式为：-u|-U编号或名称。    仅显示用户ID或用户名与给定ID或用户名匹配的进程。‘-u’选项匹配有效用户，而‘-U’选项匹配任何用户(实际、有效、已保存或文件系统)。

                        前缀加感叹号(‘！’)。设置为用户id或名称指示top仅显示用户与提供的进程不匹配的进程。

                        ‘p’、‘u’和‘U’命令行选项相互排斥。

                   -w  :输出宽度覆盖为：-w[number]

    • 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

    在批处理模式中，当在没有参数的情况下使用时，top将使用COLUMNS=和LINES=环境变量（如果设置）格式化输出。否则，宽度将固定为最大512列。使用参数，可以减小或增大输出宽度（最多512），但行数被认为是无限的。

                    在正常显示模式下，当在没有参数的情况下使用时，如果设置了COLUMNS=和LINES=环境变量，top将尝试格式化输出。使用参数时，输出宽度只能减小，不能增大。无论是使用环境变量还是带-w的参数，如果不是在批处理模式下，都不能超过实际的端子尺寸。

                注意：如果不使用此命令行选项，输出宽度始终基于调用top的终端，无论是否处于批处理模式。

    • 1
    • 2
    • 3

    4、程序开机自启动服务配置

        Centos系统服务器脚本目录位置：/usr/lib/systemd/

    其内部有系统（system）和用户（user）2个文件夹，如需要开机不登录即要求能执行的程序，在系统服务（system）里，即/usr/lib/systemd/system；

    而如果需要用户登录之后才可以运行的程序，在用户服务（user）里，即/usr/lib/systemd/user。

    这里以nginx服务开启自启为例：

    [Unit]    
    Description=Nginx restart on Reboot
    After=network.target    
         
    [Service]    
    Type=forking    
    User=nginx
    Group=nginx
    ExecStart=/etc/init.d/nginx start    
    ExecReload=/etc/init.d/nginx restart    
    ExecStop=/etc/init.d/nginx  stop    
    PrivateTmp=true    

    [Install]    
    WantedBy=multi-user.target   
    
    参数说明：
        Description:描述服务
        After:描述本服务的上游依赖关系，即上游启动完毕后，才可以启动本服务
        [Service]服务运行参数的设置
        Type=forking是后台运行的形式
        User 服务启动用户
        Group 服务启动用户组
        ExecStart 为服务的具体运行命令
        ExecReload 为重启命令
        ExecStop 为停止命令
        PrivateTmp=True 表示给服务分配独立的临时空间
    
    注意：
        [Service]的启动、重启、停止命令全部要求使用绝对路径
        [Install]服务安装的相关设置，可设置为多用户
        一般文件以644权限进行保存,如下：

        [root@nn2 system]# ll frp.service 
        -rw-r--r-- 1 root root 266 Oct 29 11:50 frp.service

    设置开机自启动命令：systemctl  enable  nginx.service

    >> 如果查看systemctl启动服务的log信息?
        Service启动之后, 如果想查询其详细日志信息, 可以使用类似 tail 的命令, 使用 journalctl -f 可以来实时追踪日志. 

    使用journalctl可以查看使用systemctl启动的service，常用参数有两种, 如下:

        ①. 显示多个混合在一起的systemctl 服务日志, 一般刚启动完一个service时查看比较方便
            journalctl -f
        
        ②. 只查看某一个具体的service服务的日志

            journalctl -u 服务名

            如:
            2021-11-10 10:06:37 nn1 systemd: Started Bigdata KafkaManager.
            2021-11-10 10:06:37 nn1 kafka-manager: This application is already running (Or delete /opt/software/kafka-manager-1.3.3.23/RUNNING_PID file).

        ③. 通过 "系统日志" 来进行查询

            tail -100f /var/log/message

            2021-11-10 10:06:37 nn1 systemd: Started Bigdata KafkaManager.
            2021-11-10 10:06:37 nn1 kafka-manager: This application is already running (Or delete /opt/software/kafka-manager-1.3.3.23/RUNNING_PID 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
    • 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

    5、重定向_管道_流

        1、在 Linux 中一个命令的去向可以有3个地方：终端、文件、作为另外一个命令的入参。
        命令一般都是通过键盘输入，然后输出到终端、文件等地方，它的标准用语是 stdin 、 stdout 以及 stderr 。

        标准输入 stdin ，终端接收键盘输入的命令，会产生两种输出；
        标准输出 stdout ，终端输出的信息（不包含错误信息）；
        标准错误输出 stderr ，终端输出的错误信息。


    2、重定向
        把本来要显示在终端的命令结果，输送到别的地方（到文件中或者作为其他命令的输入）。
        当我们 cat 一个文件时，会把文件内容打印到屏幕上，这个是标准输出；

        1、输出重定向 >
            > 表示重定向到新的文件。
                                【注意】使用 > 要注意，如果输出的文件不存在它会新建一个，如果输出的文件已经存在，则会覆盖。因此执行这个操作要非常小心，以免覆盖其它重要文件。
            当使用了 > res.txt 时，则不会打印到屏幕，会把标准输出写入文件 res.txt 文件中；
            


        2、输出重定向 >>
            表示重定向到文件末尾，因此它不会像 > 命令这么危险，它是追加到文件的末尾（当然如果文件不存在，也会被创建）。


        3、输出重定向 2>
            2> 表示会把标准错误输出重定向到文件中。
            
            2> errors.log 当发生错误时会写入 errors.log 文件中。


        4、输出重定向 2>>
            2>> 表示会把标准错误输出（追加到文件末尾）同 >> 相似。

        5、输出重定向 2>&1
            2>&1 表示标准输出和标准错误输出都重定向到一个地方。
            cat not_exist_file.csv > res.txt 2>&1  # 覆盖输出
            
        6、输出重定向 >> xxx.log 2>&1
            2>&1 表示标准输出和标准错误输出都覆盖写重定向到一个地方。
            cat not_exist_file.csv >> res.txt 2>&1 # 追加输出

        目前为止，我们接触的命令的输入都来自命令的参数，其实命令的输入还可以来自文件或者键盘的输入。



        7、输入重定向 <
            < 符号用于指定命令的输入。
            
            cat < name.csv  # 指定命令的输入为 name.csv
            
            虽然它的运行结果与 cat name.csv 一样，但是它们的原理却完全不同：
                cat name.csv 表示 cat 命令接收的输入是 notes.csv 文件名，那么要先打开这个文件，然后打印出文件内容。
                cat < name.csv 表示 cat 命令接收的输入直接是 notes.csv 这个文件的内容， cat命令只负责将其内容打印，打开文件并将文件内容传递给 cat 命令的工作则交给终端完成。

        8、输入重定向 <<
            将键盘的输入重定向为某个命令的输入。

            sort -n << END      # 输入这个命令之后，按下回车，终端就进入键盘输入模式，其中END为结束命令字符（这个可以自定义）
            wc -m << END        # 统计输入的单词
    
    
    3、管道 |
        把两个命令连起来使用，一个命令的输出作为另外一个命令的输入，英文是 pipeline ，可以想象一个个水管连接起来，管道算是重定向流的一种。

        举几个实际用法案例：
        
            cut -d , -f 1 name.csv | sort > sorted_name.txt     # 第一步获取到的 name 列表，通过管道符再进行排序，最后输出到sorted_name.txt
            
            du | sort -nr | head        # du 表示列举目录大小信息,# sort 进行排序,-n 表示按数字排序，-r 表示倒序,# head 前10行文件
            
            grep log -Ir /var/log | cut -d : -f 1 | sort | uniq     # grep log -Ir /var/log 表示在log文件夹下搜索 /var/log 文本，-r 表示递归，-I 用于排除二进制文件,# cut -d : -f 1 表示通过冒号进行剪切，获取剪切的第一部分,# sort 进行排序# uniq 进行去重
            


    4、流
        流并非一个命令，在计算机科学中，流 stream 的含义是比较难理解的，记住一点即可：流就是读一点数据, 处理一点点数据。其中数据一般就是二进制格式。 上面提及的重定向或管道，就是把数据当做流去运转的。

    • 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

    6、终端其他命令

        clear               //清除屏幕信息
    
    lpq                 查看在打印队列中等待的作业
    
    lpr                 打印,把指定的文件发送到打印队列中。
    lpr foo.txt         打印 foo.txt 文件
    lprm                取消打印队列中的作业
    lprm 作业号码       取消打印队列中的作业
    
    history （10）                                //显示历史指令-默认1000行
    
    alias l=’ls’                //定义命令别名
    unalias l                   //删除别名
    alias                       //列出别名
    
    typeset [-aAfFgilnrtux] [-p] 名称[=值] ...     设置变量的值和属性。`declare'  的等价形式。
    
    vmstat |        对操作系统的虚拟内存、进程、CPU活动进行监控  
    
    echo xx             //显示文本  x=0  echo $x . echo -e \$x . echo $(pwd)
                                        【echo常用参数】:
                    -n  输出后不换行
                    -e  遇到转义字符特殊处理          
                     
                    eg:               
                        echo "he\nhe"   
                        显示he\nhe
                             
                        echo -e "he\nhe"    
                        显示he(换行了)
                            he
                                
                                
    

    set                         设置/取消，显示环境变量和普通变量
                                        【set常用参数】:
                    -a  标记修改的或者创建的变量为导出。
                    -b  立即通告任务终结。
                    -e  如果一个命令以非零状态退出，则立即退出。
                    -f  禁用文件名生成(模式匹配)。
                    -h  当查询命令时记住它们的位置
                    -k  所有的赋值参数被放在命令的环境中，而不仅仅是
                      命令名称之前的参数。
                    -m  启用任务控制。
                    -n  读取命令但不执行
                    -o 选项名
    
    unset           删除一个环境变量,取消设定 shell 变量和函数的值和属性。对每一个 NAME 名称，删除对应的变量或函数。
                                        【unset常用参数】:
                    -f	将每个 NAME 视为函数
                    -v	将每个 NAME 视为变量
                    -n	将每个 NAME 视为名称引用，只取消其本身而非其指向的变量
                    不带选项时，unset 首先尝试取消设定一个变量，如果失败，再尝试取消设定一个函数。


    env             显示环境变量,在环境中设置每个给定变量<名称>的值为给定<值>，并运行给定<命令>。
                                        【env常用参数】:
                    -i, --ignore-environment  以空环境启动
                    -0, --null           以 NUL 空字符而非换行符结束每一输出行
                    -u,  --unset=名称     从当前环境中移除一个变量
                    -C, --chdir=目录     将工作目录变更为指定目录
               
                
    export          把普通变量变成环境变量,为 shell 变量设定导出属性。标记每个 NAME 名称为自动导出到后续命令执行的环境。如果提供了 VALUE,则导出前将 VALUE 作为赋值。
                                        【export常用参数】:
                    -f	指 shell 函数
                    -n	删除每个 NAME 名称的导出属性
                    -p	显示所有导出的变量和函数的列表

    read        从标准输入读取一行并将其分为不同的域。
                                        【read常用参数】:
                    -a array	将词语赋值给 ARRAY 数组变量的序列下标成员，从零开始
                    -d delim	持续读取直到读入 DELIM 变量中的第一个字符，而不是换行符
                    -e	使用 Readline 获取行
                    -i text	使用 TEXT 文本作为 Readline 的初始文字
                    -n nchars	读取 nchars 个字符之后返回，而不是等到读取换行符。
                        但是分隔符仍然有效，如果遇到分隔符之前读取了不足 nchars 个字符。
                    -N nchars	在准确读取了 nchars 个字符之后返回，除非遇到文件结束符或者读超时，
                        任何的分隔符都被忽略
                    -p prompt	在尝试读取之前输出 PROMPT 提示符并且不带
                        换行符
                    -r	不允许反斜杠转义任何字符
                    -s	不回显终端的任何输入
                    -t timeout	如果在 TIMEOUT 秒内没有读取一个完整的行则超时并且返回失败。
                        TMOUT 变量的值是默认的超时时间。TIMEOUT 可以是小数。
                        如果 TIMEOUT 是 0，那么仅当在指定的文件描述符上输入有效的时候，
                        read 才返回成功；否则它将立刻返回而不尝试读取任何数据。
                        如果超过了超时时间，则返回状态码大于 128
                    -u fd	从文件描述符 FD 中读取，而不是标准输入


    declare [-aAfFgilnrtux] [-p] [名称[=值] ...]       设定变量值和属性。声明变量并且赋予它们属性。如果没有给定名称，则显示所有变量的属性和值。
                                        【declare常用参数】:
                    -f	限制动作或显示为仅函数名称和定义
                    -F	限制仅显示函数名称 (以及调试时显示行号和源文件名)
                    -g	当用于 shell 函数内时创建全局变量; 否则忽略
                    -p	显示每个 NAME 变量的属性和值

                    设定属性的选项：
                    -a	使 NAME 成为下标数组 (如果支持)
                    -A	使 NAME 成为关联数组 (如果支持)
                    -i	使 NAME 带有 `integer' (整数)属性
                    -l	将 NAME 在赋值时转为小写
                    -n	使 NAME 成为指向一个以其值为名称的变量的引用
                    -r	将 NAME 变为只读
                    -t	使 NAME 带有 `trace' (追踪)属性
                    -u	将每个 NAME 在赋值时转为大写
                    -x	将 NAME 导出                  
                                                                   
                                   
                                   
    ulimit      限制使用者的某些系统资源,修改 shell 资源限制。在允许此类控制的系统上，提供对于 shell 及其创建的进程所可用的资源的控制。
                                        【ulimit常用参数】:
                    -S	使用软 (`soft') 资源限制
                    -H	使用硬 (`hard') 资源限制
                    -a	所有当前限制都被报告
                    -b	套接字缓存尺寸
                    -c	创建的核文件的最大尺寸
                    -d	一个进程的数据区的最大尺寸
                    -e	最高的调度优先级 (`nice')
                    -f	有 shell 及其子进程可以写的最大文件尺寸,(一般可能设定为 2GB)单位为 Kbytes 
                    -i	最多的可以挂起的信号数
                    -k	分配给此进程的最大 kqueue 数量
                    -l	一个进程可以锁定的最大内存尺寸
                    -m	最大的内存进驻尺寸
                    -n	最多的打开的文件描述符个数
                    -p	管道缓冲区尺寸
                    -q	POSIX 信息队列的最大字节数
                    -r	实时调度的最大优先级
                    -s	最大栈尺寸
                    -t	最大的CPU时间，以秒为单位
                    -u	最大用户进程数
                    -v	虚拟内存尺寸
                    -x	最大的文件锁数量
                    -P	最大伪终端数量
                    -T	最大线程数量

                    并非所有选项在所有系统上可用。
                            
    ulimit -f 1024      限制使用者仅能建立 1MBytes 以下的容量的档案     
         
         
    free [参数] |         显示Linux系统中空闲的、已用的物理内存及swap内存,及被内核使用的buffer     
                                        【free常用参数】:
                    -b, --bytes         以字节显示输出
                    -k   --kilo         使用千字节显示输出
                    -m  --mega          使用兆字节显示输出
                    -g  --giga          使用吉字节显示输出
                    -t  --tera          使用太字节显示输出
                    -h  --human         显示人类可读的输出
                    -w, --wide          宽版输出
         
    
    iostat [参数] [时间t] [次数n]|        对系统的磁盘操作活动进行监视,汇报磁盘活动统计情况，同时也会汇报出CPU使用情况,(每隔t时间刷新一次，最多刷新n次)
                                        【iostat常用参数】:
                    -p[磁盘] 显示磁盘和分区的情况
                
                
    at [参数] [时间] | 在一个指定的时间执行一个指定任务，只能执行一次
                                        【at常用参数】:
                     HH:MM[am|pm] + number [minutes|hours|days|weeks] 强制在某年某月某日的某时刻进行该项任务
                     at q 查看系统未执行的任务
                     atrm n 删除编号为n的任务
                     at -c n 显示编号为n的任务的内容

    • 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
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165

    2、文件与目录操作

    1、文件和目录

        file -b myfile      显示目录或文件的详细信息，判断文件类型
    
    pwd                 显示当前所在工作路径
        
        [root@iZm5e8dsxce9ufaic7hi3uZ ~]# pwd
        /root
            命令解析：
                root：表示用户名；
                iZm5e8dsxce9ufaic7hi3uZ：表示主机名；
                ~：表示目前所在目录为家目录，其中 root 用户的家目录是 /root 普通用户的家目录在 /home 下；
                #：指示你所具有的权限（ root 用户为 # ，普通用户为 $ ）。
    
    
    iconv -l            列出已知的编码
    
    stat [选项]... 文件...      显示文件/文件系统的状态，详细信息显示
    stat myfile         显示文件的状态信息  
                                        【stat常用参数】
                    必选参数对长短选项同时适用。
                      -L, --dereference     显示符号链接
                      -f, --file-system     显示文件系统状态而非文件状态
                      -c  --format=FORMAT   按照指定格式输出；
                                                
                          --printf=FORMAT   类似于--format，但解释反斜杠转义，
                                                并且不输出强制的尾随换行符；
                                                如果要换行，请在FORMAT中包含。
                                                
                      -t, --terse           简洁模式，只显示摘要信息
                          --help		    显示此帮助信息并退出
                          --version		    显示版本信息并退出

                    
                    文件的有效格式序列（不带--file system）：

                        %a   八进制表示的访问权限（注意“#”和“0”printf标志）
                        %A   人类可读形式的访问权限
                        %b   分配的块数（参见%b）
                        %B   由%b报告的每个块的字节大小
                        %C   SELinux安全上下文字符串
                        %d   设备编号（十进制）
                        %D   设备编号（十六进制）
                        %f   原始模式（十六进制）
                        %F   文件类型
                        %g   所有者的组ID
                        %G   组所有者名称
                        %h   硬链接数
                        %i   索引节点号
                        %m   挂载点
                        %n   文件名
                        %N   带符号链接时取消引用的引用文件名
                        %o   最佳I/o传输大小提示
                        %s   总大小（字节）
                        %t   主要设备类型（十六进制），用于字符/块设备特殊文件
                        %T   次要设备类型（十六进制），用于字符/块设备特殊文件
                        %u   所有者的用户ID
                        %U   所有者的用户名
                        %w   文件出生时间，可读；-如果未知
                        %W   文件生成时间，从大纪元开始的秒数；0（如果未知）
                        %x   上次访问时间，人类可读
                        %X   上次访问时间，自大纪元以来的秒数
                        %y   上次数据修改的y时间，人类可读
                        %Y   次数据修改的Y时间，自大纪元以来的秒数
                        %z   上次状态更改的时间，人类可读
                        %Z   上次状态更改的时间，自大纪元以来的秒数

                    文件系统的有效格式序列：

                        %a   非超级用户可用的空闲块
                        %b   文件系统中的总数据块
                        %c   文件系统中的文件节点总数
                        %d   文件系统中的d个空闲文件节点
                        %f   文件系统中的f个可用块
                        %i   文件系统ID（十六进制）
                        %l   文件名的最大长度
                        %n   文件名
                        %s   块大小（用于更快的传输）
                        %S   基本块大小（用于块计数）
                        %t   文件系统类型（十六进制）
                        %T   人类可读形式的T文件系统类型


                    --terse 和下列<格式>等效：:
                        %n %s %b %f %u %g %D %i %h %t %T %X %Y %Z %W %o %C
                    --terse --file-system 与下列<格式>等效：
                        %n %i %l %t %s %S %b %f %a %c %d

                    注意：您的shell 可能内置了自己的stat 程序版本，它会覆盖这里所提及的相应
                    版本。请查阅您的shell 文档获知它所支持的选项。

    which ls            查看命令的可执行文件所在路径。
                        Linux 下，每一条命令其实都对应一个可执行程序，在终端中输入命令，按回车的时候，就是执行了对应的那个程序， which 命令本身对应的程序也存在于 Linux 中。总的来说一个命令就是一个可执行程序。
                        
    cd [-L|[-P [-e]] [-@]] [目录]     改变 shell 工作目录。
    cd              是英语 change directory 的缩写，表示切换工作目录。
    cd              不添加任何参数，也是回到个人的家目录     
    cd ~user1       进入个人的主目录 
    cd -            返回上次所在的目录     
    cd ~            跳转到家目录
    cd ..           返回上一级目录 
    cd ../..        返回上两级目录
    cd /            跳转到根目录
    cd ./home       跳转到当前目录的home目录下
    cd /home/lion   跳转到根目录下的home目录下的lion目录
                    [注意] 输入cd /ho + 单次 tab 键会自动补全路径 + 两次 tab 键会列出所有可能的目录列表。
    
    
    ls [选项] [目录名 |      列出相关目录下的所有目录和文件
                                        【ls常用参数】:
                    -a 列出包括.a开头的隐藏文件的所有文件
                    -A 通-a，但不列出 "." 和 ".."
                    -c 根据ctime排序显示
                    -l 列出文件的详细信息
                    -f 列举的文件显示文件类型
                    -h 适合人类阅读的
                    -t 根据文件修改时间排序，按文件最近一次修改时间排序
                    -r 逆向，从后向前地列举目录中内容
                    -R 递归，该选项递归地列举当前目录下所有子目录内的内容
                    -s 大小，按文件大小排序
                    -i 显示文件的 inode （ inode 是文件内容的标识）
                    ---color[=WHEN] 用色彩辨别文件类型 WHEN 可以是 'never'、'always'或'auto'其中之一.
                        白色：表示普通文件
                        蓝色：表示目录
                        绿色：表示可执行文件
                        红色：表示压缩文件
                        浅蓝色：链接文件
                        红色闪烁：表示链接的文件有问题
                        黄色：表示设备文件
                        灰色：表示其它文件 
    ls -F           查看目录中的文件 
    ls -l           显示文件和目录的详细资料,查看文件最后被编辑时间
    ls -lu myfile   查看文件最后被访问时间
    ls -a           显示所有文件和目录包括隐藏的隐藏文件
    ls -i           显示文件索引节点号
    ls -m           以逗号分隔
    ls *[0-9]*      显示包含数字的文件名和目录名
    
    
    tree            显示文件和目录由根目录开始的树形结构.
                        sudo apt-get install tree 
    tree -l         以树状图列出目录内容
    tree -a         所有
    tree -i         不以阶梯状
    tree -s         列出文件或目录大小
    tree -t         按更改时间
    
    touch [选项] 文件 | 创建空文件或更新文件时间
                                        【touch常用参数】:
                    -a 只修改存取时间
                    -m 值修改变动时间
                    -r 使用指定文件的时间属性而非当前时间，eg:touch -r a b ,使b的时间和a相同
                    -t 使用给定 [[CC]YY]MMDDhhmm[.ss] 的时间戳而非当前时间 ，-t time [[CC]YY]MMDDhhmm[.SS],C:年前两位
                        eg:touch -t 201211142234.50 log.log
               
    touch myfile    创建文件
    touch -t 0712250000 file1   修改一个文件或目录的时间戳 - (YYMMDDhhmm)
    touch -at 01011212 myfile   修改文件最后被访问时间
    touch -t YYMMDDhhmm file1   修改一个文件或目录的时间戳
    
    
    mkdir [选项] 目录… |        创建新目录
                                        【mkdir常用参数】:
                    -p 递归创建目录，若父目录不存在则依次创建
                    -m 自定义创建目录的权限 eg:mkdir -m 777 hehe
                    -v 显示创建目录的详细信息
                    
    mkdir dir1                  创建一个叫做 'dir1' 的目录' 
    mkdir dir1 dir2             同时创建两个目录 
    mkdir -p /tmp/dir1/dir2     创建一个目录树，-p 递归的创建目录结构
    
    rm [选项] 一个或多个文件或目录 |    删除文件 或 目录
    rm -f file1         删除一个叫做 'file1' 的文件' 
    rmdir dir1          删除一个叫做 'dir1' 的目录' 
    rm -rf dir1         删除一个叫做 'dir1' 的目录并同时删除其内容 
    rm -rf dir1 dir2    同时删除两个目录及它们的内容 
    rm new_file         删除 new_file 文件
    rm f1 f2 f3         同时删除 f1 f2 f3 3个文件
                                        【rm常用参数】
                    -i 向用户确认是否删除；
                    -f 忽略不存在的文件强制删除，不给出提示；
                    -r 递归删除文件夹，著名的删除操作 rm -rf 。
                    -v 详细显示进行步骤
    
    rmdir               删除指定的空目录
                                        【rmdir 常用参数】
                     -v 显示执行过程
                     -p 若自父母删除后父目录为空则一并删除
                    
    mv [选项] 源文件或目录 目录或多个源文件 |       移动或重命名文件
                                        【mv常用参数】：
                    -b  覆盖前做备份
                    -f  如存在不询问而强制覆盖
                    -i  如存在则询问是否覆盖
                    -n  不覆盖已存在文件
                    -S, 替换常用的备份文件后缀
                    -t, 将所有<源文件>移动至指定的<目录>中，目录参数在前，文件参数在后
                    -T, 将参数中所有<目标文件>部分视为普通文件
                    -u  较新才覆盖
                    -v, 对正在发生的操作给出解释
                    -Z, 将目标文件的 SELinux 安全上下文设置为默认类型

                    eg:    
                        mv a /tmp/ 将文件a移动到 /tmp目录下
                        mv a b 将a命名为b
                        mv /home/zenghao test1.txt test2.txt test3.txt
                        
    mv file one         将 file 文件移动到 one 目录下
    mv new_folder one   将 new_folder 文件夹移动到one目录下
    mv *.txt folder     把当前目录下所有 txt 文件移动到 folder 目录下
    mv file new_file    将file 文件重命名为 new_file
    
    cp [选项] 源文件或目录 目录或多个源文件 | 将源文件复制至目标文件，或将多个源文件复制至目标目录。
                                        【cp常用参数】：
                    -r -R 递归复制该目录及其子目录内容
                    -p  连同档案属性一起复制过去
                    -f  不询问而强制复制
                    -s  生成快捷方式
                    -a  将档案的所有特性都一起复制
                    -i 互动：如果文件将覆盖目标中的文件，他会提示确认
                    -v 详细：显示文件的复制进度
    cp file file_copy   复制一个文件，file 是目标文件，file_copy 是拷贝出来的文件
    cp dir/* .          复制一个目录下的所有文件到当前工作目录 */
    cp -a /tmp/dir1 .   复制一个目录到当前工作目录 
    cp -a dir1 dir2     复制一个目录 
    cp -r dir1 dir2     复制一个目录及子目录 
    cp file one             把 file 文件拷贝到 one 目录下，并且文件名依然为 file
    cp file one/file_copy   把 file 文件拷贝到 one 目录下，文件名为file_copy
    cp *.txt folder         把当前目录下所有 txt 文件拷贝到 folder 目录下
     
    scp [参数] [原路径] [目标路径] | 在Linux服务器之间复制文件和目录
                                        【scp常用参数】：
                    -v  详细显示输出的具体情况
                    -r  递归复制整个目录
    复制文件：
    scp： 它是 Secure Copy 的缩写，表示安全拷贝。scp 可以使我们通过网络，把文件从一台电脑拷贝到另一台电脑。
        scp 是基于 ssh 的原理来运作的， ssh 会在两台通过网络连接的电脑之间创建一条安全通信的管道， scp 就利用这条管道安全地拷贝文件。

        scp source_file destination_file                # source_file 表示源文件，destination_file 表示目标文件
            其中 source_file 和 destination_file 都可以这样表示：user@ip:file_name ， user 是登录名， ip 是域名或 ip 地址。file_name 是文件路径。
        
        scp local_file remote_username@remote_ip:remote_folder  复制本地文件到远程，指定了用户名，命令执行后需要输入用户密码，仅指定了远程的目录，文件名字不变
        scp local_file remote_username@remote_ip:remote_file    复制本地文件到远程，指定了用户名，命令执行后需要输入用户密码，指定了文件名
        scp local_file remote_ip:remote_folder      复制本地文件到远程，没有指定用户名，命令执行后需要输入用户名和密码，仅指定了远程的目录，文件名字不变，
        scp local_file remote_ip:remote_file        复制本地文件到远程，没有指定用户名，命令执行后需要输入用户名和密码，指定了文件名 

    复制目录：  
        scp -r local_folder remote_username@remote_ip:remote_folder     复制本地目录到远程，指定了用户名，命令执行后需要输入用户密码；
        scp -r local_folder remote_ip:remote_folder                     复制本地目录到远程，没有指定用户名，命令执行后需要输入用户名和密码；
                              
        scp /home/daisy/full.tar.gz root@172.19.2.75:/home/root                 从 本地 复制到 远程    
        scp root@/172.19.2.75:/home/root/full.tar.gz /home/daisy/full.tar.gz    从 远程 复制到 本地                                                 
    
    
    
    ln [参数] [源文件或目录] [目标文件或目录] |        英文 Link 的缩写，表示创建链接。某一个文件在另外一个位置建立一个同步的链接。                
    ln -s file1 lnk1    创建一个指向文件或目录的软链接 
    ln file1 lnk1       创建一个指向文件或目录的物理硬链接
                                        【ln常用参数】   
                    -s 建立软连接
                    -v 显示详细的处理过程
                    
                    学习创建链接之前，首先要理解链接是什么，我们先来看看 Linux 的文件是如何存储的：
                        Linux 文件的存储方式分为3个部分，文件名、文件内容以及权限，其中文件名的列表是存储在硬盘的其它地方和文件内容是分开存放的，每个文件名通过 inode 标识绑定到文件内容。

                Linux 下有两种链接类型：硬链接和软链接。

                    硬链接：
                        使链接的两个文件共享同样文件内容，就是同样的 inode ，一旦文件1和文件2之间有了硬链接，那么修改任何一个文件，修改的都是同一块内容，它的缺点是，只能创建指向文件的硬链接，不能创建指向目录的（其实也可以，但比较复杂）而软链接都可以，因此软链接使用更加广泛。
                        ln file1 file2      创建 file2 为 file1 的硬链接
                    
                        如果我们用 rm file1 来删除 file1 ，对 file2 没有什么影响，对于硬链接来说，删除任意一方的文件，共同指向的文件内容并不会从硬盘上删除。只有同时删除了 file1 与file2 后，它们共同指向的文件内容才会消失。

                    软链接：
                        软链接就类似 windows 下快捷方式。
                        ln -s file1 file2       表示file2 指向 file1 
                            其实 file2 只是 file1 的一个快捷方式，它指向的是 file1 ，所以显示的是 file1 的内容，但其实 file2 的 inode 与 file1 并不相同。如果我们删除了 file2 的话， file1是不会受影响的，但如果删除 file1 的话， file2 就会变成死链接，因为指向的文件不见了。
            

    du                  列举目录大小信息。
    du -hs test         以适合人类阅读的单位显示 test 文件夹的总大小。
                                        【du常用参数】
                    -h 适合人类阅读的；
                    -a 同时列举出目录下文件的大小信息；
                    -s 只显示总计大小，不显示具体信息。

    
    rename          用字符串替换的方式批量改变文件名.
                    版本区分方法: rename --version
                        如果返回结果中包含 util-linux , 说明是 C 语言版本, 反之是 Perl 版本。
                    # Perl版本
                        rename [ -h|-m|-V ] [ -v ] [ -0 ] [ -n ] [ -f ] [ -d ] [ -e|-E perlexpr]*|perlexpr [ files ]
                        Perl语言版本格式：rename ‘s/原字符串/新字符串/’ 文件名          
                    # C语言版本
                        rename [选项] 表达式 替换的字符 文件...
                        C语言版本格式：rename 原字符串 新字符串 文件名
            
                                        【rename常用参数】
                    # Perl版本
                        -v, --verbose  详细：打印成功重命名的文件的打印名称。
                        -0, --null 从STDIN读取时，请使用\0作为记录分隔符
                        -n, --nono 不执行任何操作：打印要重命名的文件名，但不重命名。
                        -f, --force 覆盖：允许覆盖现有文件
                        --path, --fullpath 重命名完整路径：包括任何目录组件。默认
                        -d, --filename, --nopath, --nofullpath 不重命名目录：仅重命名路径的文件名部分
                        -h, --help 帮助：打印提要和选项。
                        -m, --man 手册: 打印手册页.
                        -V, --version 版本: 显示版本号.
                        -e  表达: 作用于文件名的代码. 可以重复来构建代码（比如“perl-e”）。如果没有-e，则第一个参数用作代码。
                        -E      语句：对文件名执行操作的代码，如-e，但终止于 ';'.
                    # C语言版本
                        -v, --verbose 提供视觉反馈，其中重命名了哪些文件（如果有的话）
                        -V, --version 显示版本信息并退出。
                        -s, --symlink 在符号链接目标上执行重命名
                        -h, --help 显示帮助文本并退出

                rename 命令存在两个版本用法上有所区别：
                    1、C语言版本, 支持通配符：
                        [常用通配符说明]
                        ?    表示一个任意字符
                        *    表示一个或一串任意字符
                        [charset]    可替代charset集中的任意单个字符

                    2、Perl版本, 支持正则表达式：
                        [常用正则表达式符号说明]
                        ^    匹配输入的开始位置
                        $    匹配输入的结尾
                        .    匹配除换行符外的任意字符
                        +    匹配前一个字符一次或多次 例如，"zo+"可以匹配"zoo",但不匹配"z"
                        [a-z]    表示某个范围内的字符，例如，"[a-z]"匹配"a"与"z"之间的任何一个小写字母字符。
                        [^m-z]    否定的字符区间。与不在指定区间内的字符匹配。
    使用例子：
        Perl 版本
    
            字母的替换rename "s/AA/aa/" * //把文件名中的AA替换成aa
            修改文件的后缀rename "s//.html//.php/" * //把.html 后缀的改成 .php后缀
            批量添加文件后缀rename "s/$//.txt/" * //把所有的文件名都以txt结尾
            批量删除文件名rename "s//.txt//" * //把所有以.txt结尾的文件名的.txt删掉


            1、修改文件的后缀：    
                将 1.txt 2.txt 重命名为 1.log 2.log

                $ rename -v "s/txt/log/g" 1.txt 2.txt
                1.txt renamed as 1.log
                2.txt renamed as 2.log


            2、批量添加文件后缀：

                rename "s//.html//.php/" *     # 把.html 后缀的改成 .php后缀

                rename "s/$//.txt/" *  # 把所有的文件名都以txt结尾

            3、批量删除文件名
                
                rename "s//.txt//" *   # 把所有以.txt结尾的文件名的.txt删掉

            4、批量更改目录下所有文件的后缀名。

                rename 's/\.csv/\.txt/' *

                现在我当前目录R1下有60个后缀是txt的文件，我想把所有的txt文件都修改为后缀为csv，如果一个一个的修改，很耗费时间，效率低，只要执行这个命令，一下就搞定。

            5、批量把目录下所有文件名包含大写部分修改为小写。

                rename 'y/A-Z/a-z/' *（反着写就是小写变大写）

                我当前目录下的文件名大写小写都有，执行该命令后文件名全部是小写，实际执行图：



            6、删除目前下所有文件的后缀名

                rename 's/.csv//' *或者rename 's/\.bak$//' *.bak

                我当前目录下的文件都是csv后缀，执行该命令后所有文件都没有后缀名。


            7、给所有文件添加后缀名。

                rename 's/$/\.txt/'  *


            8、统一在所有文件名前添加某个字符串

                rename 's/^/googluck/' *

                这里我想把当前目录下的文件的文件名前都添加goodluck，执行该命令后，所有文件名的前面都加山了goodluck。
       
            9、给所有文件替换任意amsr-vector-fs-为01_amsr-vector-fs-字符串：
                
                rename -v "s/amsr-vector-fs-/01_amsr-vector-fs-/" amsr-vector-fs-* 
       
        C 语言版本
            例子：将文件名中的“test”批量替换为“TEST”
            # rename test TEST test_*.log

            # ls
            # TEST_10.log  TEST_1.log  TEST_2.log  TEST_3.log  TEST_4.log  TEST_5.log  TEST_6.log  TEST_7.log  TEST_8.log  TEST_9.log


            1、将 1.txt 2.txt 重命名为 1.log 2.log

                $ rename -v txt log 1.txt 2.txt
                `1.txt' -> `1.log'
                `2.txt' -> `2.log'

            
            2、将当前目录下.htm批量改成.html
                > rename .htm .html *.htm

                文件夹中有这些文件foo1, …, foo9, foo10, …, foo278

            3、把foo1到foo9的文件重命名为foo01到foo09
                > rename foo foo0 foo?

            4、foo01到foo99的所有文件都被重命名为foo001到foo099
                > rename foo foo0 foo??

            5、从foo0200到foo0278的所有文件都被重命名为foo200到foo278，文件名中的foo0被替换为foo。
                > rename foo0 foo foo0[2]*                     

    • 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
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314
    • 315
    • 316
    • 317
    • 318
    • 319
    • 320
    • 321
    • 322
    • 323
    • 324
    • 325
    • 326
    • 327
    • 328
    • 329
    • 330
    • 331
    • 332
    • 333
    • 334
    • 335
    • 336
    • 337
    • 338
    • 339
    • 340
    • 341
    • 342
    • 343
    • 344
    • 345
    • 346
    • 347
    • 348
    • 349
    • 350
    • 351
    • 352
    • 353
    • 354
    • 355
    • 356
    • 357
    • 358
    • 359
    • 360
    • 361
    • 362
    • 363
    • 364
    • 365
    • 366
    • 367
    • 368
    • 369
    • 370
    • 371
    • 372
    • 373
    • 374
    • 375
    • 376
    • 377
    • 378
    • 379
    • 380
    • 381
    • 382
    • 383
    • 384
    • 385
    • 386
    • 387
    • 388
    • 389
    • 390
    • 391
    • 392
    • 393
    • 394
    • 395
    • 396
    • 397
    • 398
    • 399
    • 400
    • 401
    • 402
    • 403
    • 404
    • 405
    • 406
    • 407
    • 408
    • 409
    • 410
    • 411
    • 412
    • 413
    • 414
    • 415
    • 416
    • 417
    • 418
    • 419
    • 420

    2、文件搜索

        find        用于查找文件，它会去遍历你的实际硬盘进行查找，而且它允许我们对每个找到的文件进行后续操作，功能非常强大。

    find <何处> <何物> <做什么>    
        何处：指定在哪个目录查找，此目录的所有子目录也会被查找。
        何物：查找什么，可以根据文件的名字来查找，也可以根据其大小来查找，还可以根据其最近访问时间来查找。
        做什么：找到文件后，可以进行后续处理，如果不指定这个参数， find 命令只会显示找到的文件。

    find [PATH] [option] [action] | 在文件树种查找文件，并作出相应的处理
                                        【find常用参数】
                    1. 与时间有关的选项：共有 -atime, -ctime 与 -mtime 和-amin,-cmin与-mmin.
                        以 -mtime 说明:    
                            -mtime n ：n 为数字，意义为在 n 天之前的『一天之内』被更动过内容的档案;
                            -mtime +n ：列出在 n 天之前(不含 n 天本身)被更动过内容的档案档名；    
                            -mtime -n ：列出在 n 天之内(含 n 天本身)被更动过内容的档案档名。    
                            -newer file ：file 为一个存在的档案，列出比 file 还要新的档案档名
            
                    2. 与使用者或组名有关的参数：     
                         -uid n ：n 为数字，这个数字是用户的账号 ID，亦即 UID     
                         -gid n ：n 为数字，这个数字是组名的 ID，亦即 GID 
                         -user name ：name 为使用者账号名称！例如 dmtsai  
                         -group name：name 为组名，例如 users ；     
                         -nouser ：寻找档案的拥有者不存在 /etc/passwd 的人！    
                         -nogroup ：寻找档案的拥有群组不存在于 /etc/group 的档案！
     
                    3. 与档案权限及名称有关的参数：   
                         -name filename：搜寻文件名为 filename 的档案（可使用通配符）   
                         -size [+-]SIZE：搜寻比 SIZE 还要大(+)或小(-)的档案。这个 SIZE 的规格有：
                            c: 代表 byte        
                            k: 代表 1024bytes。所以，要找比 50KB还要大的档案，就是『 -size +50k
                            -type TYPE ：搜寻档案的类型为 TYPE 的，类型主要有：
                                 一般正规档案 (f) 
                                 装置档案 (b, c)       
                                 目录 (d)        
                                 连结档 (l)        
                                 socket (s)
                                 FIFO (p)  
                        -perm mode ：搜寻档案权限『刚好等于』 mode的档案，这个mode为类似chmod的属性值，举例来说，-rwsr-xr-x 的属性为 4755！
                        -perm -mode ：搜寻档案权限『必须要全部囊括 mode 的权限』的档案，举例来说：
           
                            我们要搜寻-rwxr--r-- 亦即 0744 的档案，使用：
                            -perm -0744，
                                当一个档案的权限为 -rwsr-xr-x ，亦即 4755 时，也会被列出来，因为 -rwsr-xr-x 的属性已经囊括了 -rwxr--r-- 的属性了。
                        
                        -perm +mode ：搜寻档案权限『包含任一 mode 的权限』的档案，举例来说，我们搜寻-rwxr-xr-x ，亦即 -perm +755 时，但一个文件属性为 -rw-------也会被列出来，因为他有 -rw.... 的属性存在！
            
     
                    4. 额外可进行的动作：    
                        -exec command ：command 为其他指令，-exec 后面可再接额外的指令来处理搜寻到的结果。    
                        -print ：将结果打印到屏幕上，这个动作是预设动作！    
             
                        eg:       
                            find / -perm +7000 -exec ls -l {} \; ,额外指令以-exec开头，以\;结尾{}代替前面找到的内容 | xargs 
                        
                        -i  默认的前面输出用{}代替 
                
                            eg:         
                                find . -name "*.log" | xargs -i mv {} test4
            
    根据文件名查找：
        find -name "file.txt"       当前目录以及子目录下通过名称查找文件
        find . -name "syslog"       当前目录以及子目录下通过名称查找文件
        find / -name "syslog"       从 '/' 进入整个系统根目录下查找syslog
        find /var/log -name "syslog"    在指定的目录/var/log下查找syslog文件
        find /var/log -name "syslog*"   查找syslog1、syslog2 ... 等文件，通配符表示所有
        find /var/log -name "*syslog*"  查找包含syslog的文件 
            [注意] find 命令只会查找完全符合 “何物” 字符串的文件，而 locate 会查找所有包含关键字的文件。

    根据文件大小查找：
        find /var -size +10M        /var 目录下查找文件大小超过 10M 的文件
        find /var -size -50k        /var 目录下查找文件大小小于 50k 的文件
        find /var -size +1G         /var 目录下查找文件大小查过 1G 的文件
        find /var -size 1M          /var 目录下查找文件大小等于 1M 的文件
    
    根据文件最近访问时间查找：
        find -name "*.txt" -atime -7    近 7天内访问过的.txt结尾的文件
    仅查找目录或文件：
        find . -name "file" -type f     只查找当前目录下的file文件find . -name "file" -type d  --> 只查找当前目录下的file目录
    
    操作查找结果：
        find -name "*.txt" -printf "%p - %u\n"      找出所有后缀为txt的文件，并按照 %p - %u\n 格式打印，其中%p=文件名，%u=文件所有者
        find -name "*.jpg" -delete                  删除当前目录以及子目录下所有.jpg为后缀的文件，不会有删除提示，因此要慎用。
        find -name "*.c" -exec chmod 600 {} \;      对每个.c结尾的文件，都进行 -exec 参数指定的操作，{} 会被查找到的文件替代，\; 是必须的结尾
        find -name "*.c" -ok chmod 600 {} \;        和上面的功能一直，会多一个确认提示
                            
    
    find / -user user1                  搜索属于用户 'user1' 的文件和目录 
    find /home/user1 -name \*.bin       在目录 '/ home/user1' 中搜索带有'.bin' 结尾的文件 
    find /usr/bin -type f -atime +100   搜索在过去100天内未被使用过的执行文件 
    find /usr/bin -type f -mtime -10    搜索在10天内被创建或者修改过的文件 
    find / -name \*.rpm -exec chmod 755 '{}' \;     搜索以 '.rpm' 结尾的文件并定义其权限 
    find /tmp -name \*.hprof -exec rm -f {} \;      批量删除java堆栈.hprof文件
    find / -xdev -name \*.rpm                       搜索以 '.rpm' 结尾的文件，忽略光驱、捷盘等可移动设备 
    
    find . -type f | xargs grep -rn 'my_test_calendar' | cut -d : -f 1 | uniq           查询hive_sh目录下，包含搜索关键字'my_test_calendar'的文本出现的文件及关键字所在的行，将文件(文件路径+文件名) 字段提取出来，并做滤重处理。


    案例二、查找所有出现指定文本的文件并滤重（进阶版）
    #### # 脚本说明
    #### 遍历 hive_tables.txt 文件中的所有表（如 hive_table_1）,查找其在指定目录/data/program/hive_sh/下的文件中，是否使用到。如果查到重复出现该文本的文件，做滤重处理。 
    #### -----------------------------------------------
        #!/bin/bash

        while read tbl
        do
         
        echo ------------------Handle table: $tbl--------------
        find /data/program/hive_sh/ -type f | xargs grep -rn $tbl | cut -d : -f 1 | uniq > ./output/${tbl}_result.txt

        done < hive_tables.txt
    
    
    locate              搜索包含关键字的所有文件和目录。后接需要查找的文件名，也可以用正则表达式。
    yum -y install mlocate      安装 locate
    
    updatedb                    更新数据库
    
    locate \*.ps            寻找以 '.ps' 结尾的文件 - 先运行 'updatedb' 命令 -r 使用正规运算式做寻找的条件.
    
         [注意] locate 命令会去文件数据库中查找命令，而不是全磁盘查找，因此刚创建的文件并不会更新到数据库中，所以无法被查找到，可以执行 updatedb 命令去更新数据库.
    
    whereis [-bmsu] [BMS 目录名 -f ] 文件名|      定位可执行文件、源代码文件、帮助文件在文件系统中的位置
                                        【whereis常用参数】
                    -b 定位可执行文件。
                    -m 定位帮助文件。
                    -s 定位源代码文件。
                    -u 搜索默认路径下除可执行文件、源代码文件、帮助文件以外的其它文件。
                    -B 指定搜索可执行文件的路径。
                    -M 指定搜索帮助文件的路径。
                    -S 指定搜索源代码文件的路径。
                        
    whereis halt            显示一个二进制文件、源码或man的位置 
    
    which 可执行文件名称     显示一个二进制文件或可执行文件的位置完整路径，在PATH变量指定的路径中查看系统命令是否存在及其位置。
    
    
    grep        全局搜索一个正则表达式，并且打印到屏幕。简单来说就是，在文件中查找关键字，并显示关键字所在行。
    grep text file      在file文件中搜索test文本或字符内容，# text代表要搜索的文本，file代表供搜索的文件
    
   
    

    grep （-c）'a' myfile            在文件中查找指定内容 (显示行号)
    grep Aug /var/log/messages      在文件 '/var/log/messages'中查找关键词"Aug" 
    grep ^Aug /var/log/messages     在文件 '/var/log/messages'中查找以"Aug"开始的词汇 
    grep [0-9] /var/log/messages    选择 '/var/log/messages' 文件中所有包含数字的行 
    grep Aug -R /var/log/*          在目录 '/var/log' 及随后的目录中搜索字符串"Aug"*/
    grep -E 'string_1|string_2' /var/log/test.log   在日志中同时查询包含 string_1或包含string_2的记录

    grep    显示匹配行的上下行内容专题：

    grep -A2 2 test.txt             返回匹配行和匹配行的后两行

    grep -B2 2 test.txt             返回匹配行和匹配行的前两行

    grep -C2 2 text.txt 或者 grep -A2 -B2 2 test.txt  返回匹配行和匹配行的前后两行
    grep -E path /etc/profile       完全匹配 path
    grep -E ^path /etc/profile      匹配 path 开头的字符串
    grep -E [Pp]ath /etc/profile    匹配path或Path
    
                                        【grep常用参数】
                    -A -B -C 后面跟阿拉伯数字
                    -A 返回匹配后和它后面的n行,(After，之后)。
                    -B 返回匹配行和它前面的n行,(Before，之前)。
                    -C 返回匹配行和它前后各n行，通-A和-B联用,(Context，上下文即前后)。
                    -i 忽略大小写， grep -i path /etc/profile
                    -n 显示行号，grep -n path /etc/profile
                    -v 只显示搜索文本不在的那些行，grep -v path /etc/profile
                    -r 递归查找，grep -r hello /etc
    
    redis-cli -h 111.111.111.111 -p 7001 -c -a ${PASSWORD} --raw hgetall 2022-03-24_ORDER_STAT | grep -E "^[[:digit:]]{1,4}_已下单" -A1        匹配redis中, field 中包含以1到4位数字开头,以"_已下单"结尾的字符, 并将其 value 值带出来(-A1)

    grep -Hnr docker *              在本层或子文件夹里递归查找包含指定字符“docker”的文件，并显示文件名+行号，如果精确匹配文本，加o参数。参数含义：（H：每次匹配时将文件名打印出来；n：打印字符串所在的行号；r：递归查找；o：精确匹配到单词，多一个字符都不行）
    grep -rn "query_string" *  Linux目录下全局查找所有文件中是否包含指定字符串（-r：递归；-n：显示行号;-c:显示计数）

    rgrep           Linux 中还有一个命令，作用相当于 grep -r  递归查找

    
    ldconfig            用于在默认搜寻目录 /lib 和 /usr/lib 以及动态库配置文件 /etc/ld.so.conf 内所列的目录下，搜索出可共享的动态链接库（格式如 lib*.so*），进而创建出动态链接器（ld.so 或 ld-linux.so）所需的缓存文件。缓存文件默认为 /etc/ld.so.cache，此文件保存已排好序的动态链接库名字列表。为了让动态链接库为系统所共享，需运行动态链接库的管理命令 ldconfig 更新动态链接库的缓存文件。
    
                                        【ldconfig常用参数】
                    1、 -v或--verbose:用此选项时,ldconfig将显示正在扫描的目录及搜索到的动态链接库,还有它所创建的连接的名字.

                    2、-n :用此选项时,ldconfig仅扫描命令行指定的目录,不扫描默认目录(/lib,/usr/lib),也不扫描配置文件/etc/ld.so.conf所列的目录.

                    3、-N :此选项指示ldconfig不重建缓存文件(/etc/ld.so.cache).若未用-X选项,ldconfig照常更新文件的连接.

                    4、-X : 此选项指示ldconfig不更新文件的连接.若未用-N选项,则缓存文件正常更新.

                    5、-f CONF : 此选项指定动态链接库的配置文件为CONF,系统默认为/etc/ld.so.conf.

                    6、-C CACHE :此选项指定生成的缓存文件为CACHE,系统默认的是/etc/ld.so.cache,此文件存放已排好序的可共享的动态链接库的列表.

                    7、-r ROOT :此选项改变应用程序的根目录为ROOT(是调用chroot函数实现的).选择此项时,系统默认的配置文件/etc/ld.so.conf,实际对应的为ROOT/etc/ld.so.conf.如用-r/usr/zzz时,打开配置文件/etc/ld.so.conf时,实际打开的是/usr/zzz/etc/ld.so.conf文件.用此选项,可以大大增加动态链接库管理的灵活性.

                    8、-l :通常情况下,ldconfig搜索动态链接库时将自动建立动态链接库的连接.选择此项时,将进入专家模式,需要手工设置连接.一般用户不用此项.

                    9、-p或--print-cache :此选项指示ldconfig打印出当前缓存文件所保存的所有共享库的名字.

                    10、-c FORMAT 或--format=FORMAT :此选项用于指定缓存文件所使用的格式,共有三种:ld(老格式),new(新格式)和compat(兼容格式,此为默认格式).

                    11、-V : 此选项打印出ldconfig的版本信息,而后退出.

                    12、- 或 --help 或--usage : 这三个选项作用相同,都是让ldconfig打印出其帮助信息,而后退出.、

    • 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
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203

    3、查看文件内容

        cat [选项] [文件]..| 一次显示整个文件或从键盘创建一个文件或将几个文件合并成一个文件
    cat             浏览和创建文件，一次性显示文件所有内容，更适合查看小的文件。
    cat > myfile    创建文件并编辑内容（ctrl+D结束编辑）
    cat -n myfile   查看文件并标示文件的行数
    cat file1       从第一个字节开始正向查看文件的内容 
    cat file1 file2 同时显示文件1和2的内容
    cat file1 file2 > mfile     将文件file1和文件file2合并后存入文件mfile
       
    cat file1 file2 ... | command <> file1_in.txt_or_file1_out.txt      使用PIPE、STDIN和STDOUT进行文本操作的通用语法
    cat file1 | command ( sed, grep, awk, grep, etc...) > result.txt    合并一个文件的详细说明文本，并将简介写入一个新文件中 
    cat file1 | command( sed, grep, awk, grep, etc...) >> result.txt    合并一个文件的详细说明文本，并将简介写入一个已有的文件中 

    cat example.txt | awk 'NR%2==1'     删除example.txt文件中的所有偶数行
                                        【cat常用参数】
                    -n 显示行号。
                    -E 在结束行提示$
                        
    head [参数]… [文件]… |  显示每个指定文件的开头到标准输出，默认开头10行
    head (-10) myfile       指定显示文件前若干行（默认前10）
    head -2 file1           查看一个文件的前两行
    head -v file1           显示文件file1的内容，并给出文件标题名
    head cloud-init.log -n 2    查看一个文件的前两行，-n 指定行数 
                如果指定了多于一个文件，在每块输出之前附加文件名称作为头部。
                                        【head常用参数】
                    -c, --bytes=[-]K    显示每个文件的前 K 字节内容；
                                        如果数字前附加“-”字符，则除了每个文件的
                                        最后 K 字节数据外显示其余全部内容.
                    -n, --lines=[-]K    显示每个文件的前 K 行内容而非前 10 行内容；
                                        如果数字前附加“-”字符，则除了每个文件的
                                        最后 K 行数据外显示其余全部内容
                    -q, --quiet, --silent	不显示包含给定文件名的文件头
                    -v, --verbose		    总是显示包含给定文件名的文件头
                    -z, --zero-terminated   以 NUL 字符而非换行符作为行尾分隔符
                      --help		    显示此帮助信息并退出
                      --version		    显示版本信息并退出
    
    tail [必要参数] [选择参数] [文件] |   显示每个指定文件结尾10 行并输出至标准输出
    tail        显示每个指定文件的最后 10 行并输出至标准输出。
                若指定了多于一个文件，程序会在每段输出的开始添加相应文件名作为头。           
    tail (-10) myfile   指定显示文件后若干行（默认后10） 
    tail -2 file1       查看一个文件的最后两行 
    tail -f /var/log/messages   实时查看被添加到一个文件中的内容 
    tail -c 10 file1            查看文件的最后10个字符 
    tail cloud-init.log         显示文件的最后10行
    tail cloud-init.log -n 2    显示文件的最后指定行数。
                                        【tail常用参数】
                    -c, --bytes=[+]NUM       输出最后 NUM 字节；或者使用 -c +NUM 以输出每个文件第 NUM 个字节之后的全部内容
                    -n          输出最后NUM行，而不是最后10行；
                                或使用-n+NUM以NUM行开始输出内容
                    -f          会每过1秒检查下文件是否有更新内容，也可以用 -s 参数指定间隔时间 tail -f -s 4 xxx.log
                    -q, --quiet, --silent    不输出给出文件名的头
                        --retry              即使目标文件不可访问依然重复试图打开
                    -s, --sleep-interval=N   使用-f，在迭代之间休眠大约N秒（默认值为1.0）；在inotify和--pid=P的情况下，至少每N秒检查一次进程P
                    -v, --verbose            始终输出提供文件名的标头
                    -z, --zero-terminated    以 NUL 字符而非换行符作为行尾分隔符
                      --help		        显示此帮助信息并退出
                      --version		        显示版本信息并退出
    
    less |          可前后移动地逐屏查看文章内容，在查看前不会加载整个文件
    less            分页显示文件内容，更适合查看大的文件。类似于 'more' 命令，但是它允许在文件中和正向操作一样的反向操作
                                        【less常用参数】
                     -m 显示类似于more命令的百分比
                     -N 显示行号
                     / 字符串：向下搜索“字符串”的功能
                     ? 字符串：向上搜索“字符串”的功能
                     n 重复前一个搜索(与 / 或 ? 有关)
                     N 反向重复前一个搜索(与 / 或 ? 有关)
                     b 向后翻一页
                     d 向后翻半页
    less myfile                 分页自由显示文件（Page Down / Page Up）
    
    tac [选项]... [文件]...     将每个指定文件按行倒置并写到标准输出。
    tac file1       从最后一行开始反向显示查看一个文件的内容

    more |          按页查看文章内容，从前向后读取文件，因此在启动时就加载整个文件（按Space空格翻页）
                                        【more常用参数】
                    +n 从第n行开始显示
                    -n 每次查看n行数据 
                    +/String 搜寻String字符串位置，从其前两行开始查看
                    -c 清屏再显示
                    -p 换页时清屏
                    -d 提示使用者，在画面下方显示[Press space to continue, q to quit.]，如果使用者按错键，则会显示[Press h for instructions.]而不是哔声
                    -l 取消遇见特殊字元^L(送纸字元)时会暂停的功能
                    -f 计算行数时，以实际上的行数，而非自动换行过后的行数(有些单行字数太长的会被扩展为两行或两行以上)
                    -p 不以卷动的方式显示每一页，而是先清除萤幕后再显示内容
                    -c 跟-p相似，不同的是先显示内容再清除其他旧资料
                    -s 当遇到有连续两行以上的空白行，就代换为一行的空白行
                    -u 不显示下引号(根据环境变数TERM指定的terminal而有所不同)
                    fileNames 欲显示内容的档案，可为复数个数

                    
    more myfile     分页往后显示文件
    
    
    nl [选项]… [文件]… |    将指定的各个<文件>添加行号标注后写到标准输出。
                                        【nl常用参数】
                     -b 使用指定样式编号文件的正文行目
                         -b a 不论是否有空行，都列出行号(类似 cat -n)
                         -b t 空行则不列行号(默认)
                    -n 根据FORMAT插入行号,有ln rn rz三个参数:
                        ln     左对齐，空格不用 0 填充
                        rn     右对齐，空格不用 0 填充
                        rz     右对齐，空格用 0 填充


    ldd 可执行文件/lib共享库名       看可执行文件或lib共享库的所有链接库

    • 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
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106

    4、文本处理

        chmod [u/g/o/a][+/-/=][r/w/x] myfile    更改文件权限
                    u-user,g-group,o-others,a-all  .   +-添加,--删除,=-重置   .
                    r-read读（4），w-write写（2），x-execute执行（1）
    
    sort            linux下的排序工具，对文件的行进行排序。
                                        【sort常用参数】:
                    -o <输出文件>   将排序后的结果存入指定的文件。
                　　-r　　降序排列，以相反的顺序来排序。
                　　-R    随机排序
                　　-u　　去重
                　　-n　　以数字大小排序(默认是首字母排序)默认是把数字识别成字符串的，因此 138 会排在 25 前面，如果添加了 -n 数字排序的话，则 25 会在 138 前面。
                　　-t <分隔字符> 指定排序时所用的栏位分隔字符。这里我们指定'|'为分隔符。
                　　-k　　选择以哪个区间进行排序。指定分隔后的第几位进行排序 这里我们指定第2位          
    sort myfile                 对文件内容进行排序
    sort -r myfile              逆序
    sort file1 file2            排序两个文件的内容 
    sort file1 file2 | uniq     取出两个文件的并集(去除重复行，重复的行只保留一份，) 
    sort file1 file2 | uniq -u  删除交集，留下其他的行，查找非重复行 
    sort file1 file2 | uniq -d  取出两个文件的交集(查找重复行，只留下同时存在于两个文件中的文件) 

    sort target_file | uniq -c          统计每一个文件出现的次数 

    
    sort -run -k 2 -t '|' report.txt    将report.txt文件里的一些方法的执行时间，要求按执行时间降序排列.
         1 void com.dustpan.zeus.core.service.MergeService.startService(int)|2
         2 void com.dustpan.zeus.core.service.InitShopDateService.startService(int)|1
         3 boolean com.dustpan.zeus.core.service.MergeService.executeGePrintSyncTask()|475
     
    ps auxw | head -1;
    ps auxw|sort -rn -k4|head -5  查找内存耗用top3的app  
   
    
    
    diff [参数] [文件1或目录1] [文件2或目录2] |     比较单个文件或者目录内容
                                        【diff常用参数】
                    -b 　不检查空格字符的不同。
                    -B 　不检查空白行。
                    -i 不检查大小写
                    -q 仅显示差异而不显示详细信息
    diff a b > parch.log                比较两个文件的不同并产生补丁
    diff myfile01 myfile02              对不同文件进行比较
    diff3 myfile01 myfile02 myfile03    比较三个文件
    sdiff myfile01 myfile02             合并不同文件
    vimdiff myfile01 myfile02              对不同文件进行比较
    
    cmp myfile01 myfile02       逐字节比较两个文件       
    comm myfile01 myfile02      逐行比较已排序的文件文件1 和文件2。
    comm -1 file1 file2         比较两个文件的内容只删除 'file1' 所包含的内容 
    comm -2 file1 file2         比较两个文件的内容只删除 'file2' 所包含的内容 
    comm -3 file1 file2         比较两个文件的内容只删除两个文件共有的部分 
    
    cut -b(-c)(-d) 2(3) myfile  对文件内容进行剪切
                                        【cut常用参数】
                    -b ：以字节为单位进行分割。这些字节位置将忽略多字节字符边界，除非也指定了 -n 标志。
                    -c ：以字符为单位进行分割。
                    -d ：自定义分隔符，默认为制表符。（比如逗号、分号、双引号等等）  
                    -f ：与-d一起使用，指定显示用分隔符分割的哪一块或哪几块区域。
    cut -d , name.txt 用 , 都好作为分割符号
    cut -f 1,2,3 name.txt   显示第1，2，3列数据字符
    cut -c 2-4 name.txt         # 剪切每一行第二到第四个字符           
    head -n 5 /etc/passwd | cut -d : -f 1,3-5       使用cut提取文本字符串,按“:”分割，提取/etc/passwd中第1,3,4,5列数据，按原分隔符":"进行拼接。

    paste                       合并文件，需确保合并的两文件行数相同
                                        【paste常用参数】
                    -d 指定不同于空格或tab键的域分隔符
                    -s 按行合并，单独一个文件为一行
    paste myfile02 myfile01     对文件内容进行粘贴 02-）01
    paste file1 file2           合并两个文件或两栏的内容 
    paste -d '+' file1 file2    合并两个文件或两栏的内容，中间用"+"区分
    
    sed                         对数据行进行替换、删除、新增、选取等操作
                                        【sed常用参数】
                    a   新增，在新的下一行出现
                    c   取代，
                    d   删除
                    i   插入，在新的上一行出现
                    
    sed '1,2c Hi' ab        取代 n1,n2 之间的行 eg:      
    sed 's/stringa1/stringa2/g' example.txt     将example.txt文件中的 "string1" 替换成 "string2" (如果不加-i参数,则在内存中替换; 添加-i参数,则在文件中直接替换)
    sed '/^$/d' example.txt             从example.txt文件中删除所有空白行 
    sed '/ *#/d; /^$/d' example.txt     从example.txt文件中删除所有注释和空白行 
    echo 'esempio' | tr '[:lower:]' '[:upper:]'     合并上下单元格内容 
    sed -e '1d' result.txt              从文件example.txt 中排除第一行 
    sed -n '/stringa1/p'                查看只包含词汇 "string1"的行 
    sed -e 's/ *$//' example.txt        删除每一行最后的空白字符 
    sed -e 's/stringa1//g' example.txt  从文档中只删除词汇 "string1" 并保留剩余全部 
    sed -n '1,5p;5q' example.txt        查看从第一行到第5行内容 
    sed -n '5p;5q' example.txt          查看第5行 
    sed -e 's/00*/0/g' example.txt      用单个零替换多个零 
    sed -i '3i helloword' test.txt   在test.txt文件的第三行插入‘helloword’字符串
        "sed按指定字符串删除"专题：

            1、用sed删除匹配到字符串的行：
                语法：sed-i'/关键字符/d'文件名
                举例1：匹配"\etc\install.sh"
                set -i '/\/etc\/install.sh/d' 1.txt
                说明：
                    / 搜索
                    匹配\/etc\/install.sh，就是“/etc/install.sh”
                    -i 表示操作在源文件上生效.否则操作内存中数据,并不写入文件中.
                    在分号内的/d表示删除匹配的行。
             
            2、举例2：
                删除以a开头的行
                sed -i '/^a.*/d' tmp.txt
                ^a表示开头是a, .*表示后跟任意字符串

            3、Example-1:  使用sed进行文本批量替换

                #!/bin/bash

                ddl_file_path=/c/Users/user/Downloads/sqoop_data/hive_2_mysql


                ls $ddl_file_path | while read f;
                do
                echo "--------->"$ddl_file_path/$f

                ## Template
                #sed -i 's///g' $ddl_file_path/$f
                #sed -i "s///g" $ddl_file_path/$f

                sed -i 's/111.111.111.111:3306/222.222.222.222:3307/g' $ddl_file_path/$f
                sed -i "s/'password_1'/'password_2'/g" $ddl_file_path/$f

                done

                # echo -e "=========>\n\t Files contains keyword "/WARN:" in path $ddl_file_path are deleted!!!"
                #!/bin/bash

                set -x

                ## Template
                #sed -i 's///g' $ddl_file_path/$f
                #sed -i "s///g" $ddl_file_path/$f


            4、## Func 1 - 实现在所有文件的第四行、第五行插入指定文本

                ddl_file_path=/e/迅雷下载/user_data_after

                ls $ddl_file_path | while read f;
                do    
                    # 如果文件不是文件夹类型，才允许插入操作
                    if [ ! -d $f ];then
                        echo "--------->"$ddl_file_path/$f

                        sed -i '4i retries=10' $ddl_file_path/$f
                        sed -i '5i retry.backoff=3' $ddl_file_path/$f
                    fi
                done


            5、## Func 2 - 如果文件夹不存在，则创建；反之提示文件已存在

                if [ ! -d "beijing" ];then
                    mkdir beijing
                else
                    echo "File already exists"
                fi
            
            6、文件类型的参数判别大全：

                shell脚本判断文件类型

                shell判断文件,目录是否存在或者具有权限 
            
                #!/bin/sh 

                myPath="/var/log/httpd/" 
                myFile="/var/log/httpd/access.log" 

                # 这里的-x 参数判断$myPath是否存在并且是否具有可执行权限 
                if [ ! -x "$myPath"]; then 
                mkdir "$myPath" 
                 fi 
                 
                 # 这里的-d 参数判断$myPath是否存在 
                 if [ ! -d "$myPath"]; then 
                 mkdir "$myPath" 
                 fi 
                 
                 # 这里的-f参数判断$myFile是否存在 
                 if [ ! -f "$myFile" ]; then 
                 touch "$myFile" 
                 fi 
                 
                 # 其他参数还有-n,-n是判断一个变量是否是否有值 
                 if [ ! -n "$myVar" ]; then 
                 echo "$myVar is empty" 
                 exit 0 
                 fi 
                 
                 # 两个变量判断是否相等 
                 if [ "$var1" = "$var2" ]; then 
                 echo '$var1 eq $var2' 
                 else 
                 echo '$var1 not eq $var2' 
                 fi 

                文件的判别逻辑大全：
                --------------------------------------------------------------------
                -a 文件存在. 
                -b 文件存在，并且是块特殊文件
                -c 文件存在，并且是一个字符专用文件
                -d 文件存在，并且是一个目录。
                -e 文件存在（与-a相同）。
                -f 文件存在，并且是常规文件。
                -g 文件存在并设置了其setgid（2）位。
                -G 文件存在，并且具有与此进程相同的组ID。
                -k 文件存在并设置了粘性位。
                -L 文件存在，并且是一个符号链接。
                -n 字符串长度不为零。
                -o 已启用命名选项。
                -O 文件存在，并且由该进程的用户ID拥有。
                -p 文件存在，并且是先进先出（FIFO）特殊文件或命名管道。
                -r 文件存在，当前进程可以读取。
                -s 文件存在且大小大于零。
                -S 文件存在并且是套接字。 
                -t 文件描述符号文件是打开的，并且与终端设备相关联。
                -u 文件存在并设置了其setuid（2）位。 
                -w 文件存在，并且可由当前进程写入。 
                -x 文件存在，可由当前进程执行。
                -z 字符串长度为零。

                注意-s 和 -f 参数的区别

    awk [选项] '脚本命令' 文件名             逐行扫描文件（从第 1 行到最后一行），寻找含有目标文本的行，如果匹配成功，则会在该行上执行用户想要的操作；反之，则不对行做任何处理。
                                        【awk常用参数】
                    -F fs	指定以 fs 作为输入行的分隔符，awk 命令默认分隔符为空格或制表符。
                    -f file	    从脚本文件中读取 awk 脚本指令，以取代直接在命令行中输入指令。
                    -v var=val	在执行处理过程之前，设置一个变量 var，并给其设备初始值为 val。
                    {} 要执行的脚本内容
            
    cat /etc/passwd |awk -F ':' '{print $1"\t"$7}'
    echo a b c | awk '{print $1}'       查看一行第一栏 
    echo a b c | awk '{print $1,$3}'    查看一行的第一和第三栏 
    
    echo 'hElloWorld' | tr '[:lower:]' '[:upper:]'  找出所有的小写字母并全部替换为大写字母 

    wc （-参数） myfile         对文件内容进行统计 （c-字符数,w-单词数,l-行数），并将统计结果显示输出
                                        【wc常用参数】:
                    -l filename 报告行数
                    -c filename 报告字节数
                    -m filename 报告字符数
                    -w filename 报告单词数
    wc name.txt                 # 统计name.txt 内容
        13 13 91 name.txt
        结果解析：
            第一个13，表示行数；
            第二个13，表示单词数；
            第三个91，表示字节数
            
    uniq myfile                 检查文件中的重复内容,从INPUT（或标准输入）过滤相邻匹配线，写入OUTPUT（或标准输出）。
                                        【uniq常用参数】:
                    -c 统计重复行数
                    -d 只显示重复的行数
            
    uniq -c name.txt                统计name.txt重复行数
    uniq -d name.txt                只显示name.txt重复的行数
    uniq name.txt                   # 去除name.txt重复的行数，并打印到屏幕上
    uniq name.txt uniq_name.txt     # 把去除重复后的文件保存为 uniq_name.txt,【注意】它只能去除连续重复的行数。


    
    综合案例:
        本机tcp各种状态数统计

        netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'
        CLOSE_WAIT 2
        ESTABLISHED 276
        SYN_SENT 2
        TIME_WAIT 63270


        awk 'BEGIN {
           sum = 0; for (i = 0; i < 20; ++i) {
              sum += i; if (sum > 50) exit(10); else print "Sum =", sum 
           } 
        }'
    
    
    
    file(选项)(参数)                探测给定文件的类型。file命令对文件的检查分为文件系统、魔法幻数检查和语言检查3个过程。
                                    文件：要确定类型的文件列表，多个文件之间使用空格分开，可以使用shell通配符匹配多个文件。
                                        【file常用参数】:
                    -b：列出辨识结果时，不显示文件名称；
                    -c：详细显示指令执行过程，便于排错或分析程序执行的情形；
                    -f<名称文件>：指定名称文件，其内容有一个或多个文件名称时，让file依序辨识这些文件，格式为每列一个文件名称；
                    -L：直接显示符号连接所指向的文件类别；
                    -m<魔法数字文件>：指定魔法数字文件；
                    -v：显示版本信息；
                    -z：尝试去解读压缩文件的内容。

        file -b install.log     显示文件类型
        
        file -L file            查看软链接对应文件的文件类型

  
    readelf <选项> elf-文件     于查看ELF格式的文件信息， 常见的文件如在Linux上的可执行文件，动态库(*.so)或者静态库(*.a) 等包含ELF格式的文件。
                                也可以用man命令窥其全貌。它用来显示一个或者多个elf格式的目标文件的信息，可以通过它的选项来控制显示哪些信息。
                                 参数：
                                    elf-file(s)就表示那些被检查的文件。可以支持32位，64位的elf格式文件，也支持包含elf文件的文档
                                        【readelf常用参数】:                       
                    -a ：--all 显示全部信息,等价于 -h -l -S -s -r -d -V -A -I

                    -h ：--file-header 显示elf文件开始的文件头信息. 

                    -l ：--program-headers  ；--segments 显示程序头（段头）信息(如果有的话)。 

                    -S ：--section-headers  ；--sections 显示节头信息(如果有的话)。 

                    -g ：--section-groups 显示节组信息(如果有的话)。

                    -t ：--section-details 显示节的详细信息(-S的)。 

                    -s ：--syms  ；--symbols 显示符号表段中的项（如果有的话）。 

                    -e ：--headers 显示全部头信息，等价于: -h -l -S 

                    -n ：--notes 显示note段（内核注释）的信息。 

                    -r ：--relocs 显示可重定位段的信息。 

                    -u ：--unwind 显示unwind段信息。当前只支持IA64 ELF的unwind段信息。 

                    -d ：--dynamic 显示动态段的信息。 

                    -V ：--version-info 显示版本段的信息。 

                    -A ：--arch-specific 显示CPU构架信息。 

                    -D ：--use-dynamic 使用动态段中的符号表显示符号，而不是使用符号段。 

                    -x  ：--hex-dump= 以16进制方式显示指定段内内容。number指定段表中段的索引,或字符串指定文件中的段名。 

                    -w[liaprmfFsoR]或者

                    -debugdump[=line,=info,=abbrev,=pubnames,=aranges,
                    =macro,=frames,=frames-interp,=str,=loc,=Ranges] 显示调试段中指定的内容。 

                    -I ：--histogram 显示符号的时候，显示bucket list长度的柱状图。 

                    -v ：--version 显示readelf的版本信息。 

                    -H ：--help 显示readelf所支持的命令行选项。 

                    -W ：--wide 宽行输出。
    
    readelf -h test.debug       用readelf命令读取一下文件信息

    • 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
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314
    • 315
    • 316
    • 317
    • 318
    • 319
    • 320
    • 321
    • 322
    • 323
    • 324
    • 325
    • 326
    • 327
    • 328
    • 329
    • 330
    • 331
    • 332
    • 333
    • 334
    • 335
    • 336
    • 337
    • 338
    • 339
    • 340
    • 341
    • 342
    • 343
    • 344
    • 345
    • 346
    • 347
    • 348
    • 349
    • 350

    5、文件的特殊属性-权限 - 使用 “+” 设置权限，使用 “-” 用于取消

        1、修改权限的确简单，但是理解其深层次的意义才是更加重要的。下面我们来系统的学习Linux 的文件权限。

        [root@lion ~]# ls -l

        drwxr-xr-x 5 root root 4096 Apr 13  2020 climblrwxrwxrwx 1 root root    7 Jan 14 06:41 hello2.c -> hello.c-rw-r--r-- 1 root root  149 Jan 13 06:14 hello.c

        其中 drwxr-xr-x 表示文件或目录的权限。让我们一起来解读它具体代表什么？

        d ：表示目录，就是说这是一个目录，普通文件是 - ，链接是 l 。
        r ：read 表示文件可读。
        w ：write 表示文件可写，一般有写的权限，就有删除的权限。
        x ：execute 表示文件可执行。
        - ：表示没有相应权限。


    2、权限的整体是按用户来划分的：

        现在再来理解这句权限 drwxr-xr-x 的意思：

        它是一个文件夹；

        它的所有者具有：读、写、执行权限；

        它的群组用户具有：读、执行的权限，没有写的权限；

        它的其它用户具有：读、执行的权限，没有写的权限。


    3、现在理解了权限，我们使用 chmod 来尝试修改权限。chmod 它不需要是 root 用户才能运行的，只要你是此文件所有者，就可以用 chmod 来修改文件的访问权限。

        1、数字分配权限：
            权限	数字
            r	4
            w	2
            x	1
            因此要改变权限，只要做一些简单的加法就行：
        
        例如：
            chmod 640 hello.c   # 分析6 = 4 + 2 + 0 表示所有者具有 rw 权限
                                      4 = 4 + 0 + 0 表示群组用户具有 r 权限
                                      0 = 0 + 0 + 0 表示其它用户没有权限
                                      对应文字权限为：-rw-r-----
        
        2、用字母来分配权限：
            u ：user 的缩写，用户的意思，表示所有者。
            g ：group 的缩写，群组的意思，表示群组用户。
            o ：other 的缩写，其它的意思，表示其它用户。
            a ：all 的缩写，所有的意思，表示所有用户。
            + ：加号，表示添加权限。
            - ：减号，表示去除权限。
            = ：等于号，表示分配权限。
        
        例如：
            chmod u+rx file         # 文件file的所有者增加读和运行的权限
            chmod g+r file          # 文件file的群组用户增加读的权限
            chmod o-r file          # 文件file的其它用户移除读的权限
            chmod g+r o-r file      # 文件file的群组用户增加读的权限，其它用户移除读的权限
            chmod go-r file         # 文件file的群组和其他用户移除读的权限
            chmod +x file           # 文件file的所有用户增加运行的权限
            chmod u=rwx,g=r,o=- file    # 文件file的所有者分配读写和执行的权限，群组其它用户分配读的权限，其他用户没有任何权限



    ls -lh                          显示权限 
    ls /tmp | pr -T5 -W$COLUMNS     将终端划分成5栏显示 
    
    chmod                       修改访问权限。
    chmod 740 file.txt          修改访问权限
                                        【chmod常用参数】
                    -R 可以递归地修改文件访问权限，例如 chmod -R 777 /home/lion
    
    chmod ugo+rwx directory1        设置目录的所有人(u)、群组(g)以及其他人(o)以读（r ）、写(w)和执行(x)的权限 
    chmod go-rwx directory1     删除群组(g)与其他人(o)对目录的读写执行权限 
    chmod u+s /bin/file1        设置一个二进制文件的 SUID 位 - 运行该文件的用户也被赋予和所有者同样的权限 
    chmod u-s /bin/file1        禁用一个二进制文件的 SUID位 
    chmod g+s /home/public      设置一个目录的SGID 位 - 类似SUID ，不过这是针对目录的 
    chmod g-s /home/public      禁用一个目录的 SGID 位 
    chmod o+t /home/public      设置一个文件的 STIKY 位 - 只允许合法所有人删除文件 
    chmod o-t /home/public      禁用一个目录的 STIKY 位
    
    
    chown user1 file1           改变一个文件的所有人属性 
    chown -R user1 directory1   改变一个目录的所有人属性并同时改变改目录下所有文件的属性 
    chown user1:group1 file1    改变一个文件的所有人和群组属性 
    
    chattr +a file1             只允许以追加方式读写文件 
    chattr +c file1             允许这个文件能被内核自动压缩/解压 
    chattr +d file1             在进行文件系统备份时，dump程序将忽略这个文件 
    chattr +i file1             设置成不可变的文件，不能被删除、修改、重命名或者链接 
    chattr +s file1             允许一个文件被安全地删除 
    chattr +S file1             一旦应用程序对这个文件执行了写操作，使系统立刻把修改的结果写到磁盘 
    chattr +u file1             若文件被删除，系统会允许你在以后恢复这个被删除的文件 

    sudo                        以特定用户的权限执行特定命令
                                     -l 列出当前用户可执行的命令
                                     -u username    #uid 以指定用户执行命令
     
    lsattr                      显示特殊的属性 
    
    chgrp group1 file1          改变文件的群组 
    
    find / -perm -u+s           罗列一个系统中所有使用了SUID控制的文件

    • 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
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102

    6、字符设置和文件格式转换

        dos2unix filedos.txt fileunix.txt 将一个文本文件的格式从MSDOS转换成UNIX 

    unix2dos fileunix.txt filedos.txt 将一个文本文件的格式从UNIX转换成MSDOS 

    recode ..HTML < page.txt > page.html 将一个文本文件转换成html 

    recode -l | more 显示所有允许的转换格式 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    7、打包和压缩，解压文件

        我们常常使用 tar 将多个文件归档为一个总的文件，称为 archive 。然后用 gzip 或 bzip2 命令将 archive 压缩为更小的文件。
      
    gzip / gunzip   "压缩/解压"归档，默认用 gzip 命令，压缩后的文件后缀名为 .tar.gz 。
    zip/unzip   “压缩/解压” zip 文件（ zip 压缩文件一般来自 windows 操作系统）。
    tar 归档+压缩，可以用 tar 命令同时完成归档和压缩的操作，就是给 tar 命令多加一个选项参数，使之完成归档操作后，还是调用 gzip 或 bzip2 命令来完成压缩操作。
    
    打包：是将多个文件变成一个总的文件，它的学名叫存档、归档。

    压缩：是将一个大文件（通常指归档）压缩变成一个小文件。
        
        
    1、压缩,解压
    
        zip myfile.zip myfile       //压缩，创建一个zip格式的压缩包 
        zip -d myfile.zip myfile    //添加
        zip -m myfile.zip myfile    //删除    
        zip -r file1.zip file1 file2 dir1 将几个文件和目录同时压缩成一个zip格式的压缩包 
        zip -r sort.zip sort/ # 将sort文件夹压缩为 sort.zip，其中-r表示递归
        
        unzip file1.zip             解压一个 .zip 格式压缩包
        unzip -o myfile.zip         //解压（覆盖）
        unzip -n myfile.zip         //解压（不覆盖）
        unzip -l archive.zip        # 不解开 .zip 文件，只看其中内容
        zipinfo myfile.zip          //列出压缩文件信息


        bzip2 file1             压缩一个叫做 'file1' 的文件
        bunzip2 file1.bz2       解压一个叫做 'file1.bz2'的文件 
    
    
        gzip file1              压缩一个叫做 'file1'的文件
        gzip archive.tar        # 压缩 
        gzip -9 file1           最大程度压缩  
        gunzip file1.gz         解压一个叫做 'file1.gz'的文件 
        gunzip archive.tar.gz   # 解压


        
    2、打包和解包 
        rar a file1.rar test_file           创建一个叫做 'file1.rar' 的包 
        rar a file1.rar file1 file2 dir1    同时压缩 'file1', 'file2' 以及目录 'dir1' 
        rar x file1.rar         解压rar包 
        unrar x file1.rar       解压rar包，如果无unrar命令，参考：Linux CentOS 7.0 下 rar unrar的安装 
                
                
        tar -cvf archive.tar file1 创建一个非压缩的 tarball 
        tar -cvf archive.tar file1 file2 dir1 创建一个包含了 'file1', 'file2' 以及 'dir1'的档案文件 
        tar -tf archive.tar             显示一个包中的内容 
        tar -xvf archive.tar            释放一个包 
        tar -xvf archive.tar -C /tmp    将压缩包释放到 /tmp目录下 
        tar -cvfj archive.tar.bz2 dir1  创建一个bzip2格式的压缩包 
        tar -jxvf archive.tar.bz2       解压一个bzip2格式的压缩包 
        tar -zcvf archive.tar.gz dir1   创建一个gzip格式的压缩包 
        tar -zxvf archive.tar.gz        解压一个gzip格式的压缩包
        tar -zcvf archive.tar.gz archive/   # 将archive文件夹归档并压缩
        tar -zxvf archive.tar.gz            # 将archive.tar.gz归档压缩文件解压

        zcat、zless、zmore：正常使用 cat less more 可以查看文件内容，但是压缩文件的内容是不能使用这些命令进行查看的，而要使用 zcat、zless、zmore 进行查看。

            zcat archive.tar.gz
    
    
    
    
    3、命令介绍：
        2、.gzip [-cdtv#] 檔名 | 压缩、解压缩，源文件都不再存在
                                        【gzip常用参数】
                     -d 进行解压缩
                     -c 将压缩的数据输出到屏幕上
                     -v :显示原档案/压缩文件案的压缩比等信息
                     -# 最快，但压缩比最差，
                     =9 最慢，但压缩比最好
                
        3、gunzip | 解压缩

        4、bzip2 | 压缩、解压缩
                                        【bzip2常用参数】
                     -d :解压
                     -z :压缩
                     -k :保留源文件
                     -c ：将压缩的过程产生的数据输出到屏幕上!
                     -v ：可以显示出原档案/压缩文件案的压缩比等信息;
                     -# ：与 gzip 同样的，都是在计算压缩比的参数
                     -9 最佳
                     -1 最快!
                
        5、.bzcat 读取数据而无需解压
        
        6、.tar [主选项+辅选项] 将文件或者目录 | 多个目录或档案打包、压缩成一个 tar 归档。
                                        【tar常用参数】：
                    -cvf 表示 create（创建）+ verbose（细节）+ file（文件），创建归档文件并显示操作细节；
                    -tf 显示归档里的内容，并不解开归档；
                    -rvf 追加文件到归档， tar -rvf archive.tar file.txt ；
                    -xvf 解开归档， tar -xvf archive.tar 
                
                主选项：
                    -c  建立打包档案，可搭配 -v 来察看过程中被打包的档名(filename)
                    -t  察看打包档案的内容含有哪些档名，重点在察看『档名』就是了;
                    -x  解打包或解压缩的功能，可以搭配 -C (大写) 在特定目录解开

                 辅选项：   
                     -j  透过 bzip2 的支持进行压缩/解压缩：此时档名最好为 *.tar.bz2
                     -z  透过 gzip 的支持进行压缩/解压缩：此时档名最好为 *.tar.gz
                     -v  在压缩/解压缩的过程中，将正在处理的文件名显示出来！  
                     -f filename -f 后面要立刻接要被处理的档名！
                     -C 目录   这个选项用在解压缩，若要在特定目录解压缩，可以使用这个选项。  
                 --exclude FILE：在压缩打包过程中忽略某文件 eg: tar --exclude /home/zenghao -zcvf myfile.tar.gz /home/* /etc
                 -p  保留备份数据的原本权限与属性，常用于备份(-c)重要的配置文件*/
                 -P(大写）  保留绝对路径，亦即允许备份数据中含有根目录存在之意；


             eg: 
                 压 缩：tar -jcvf filename.tar.bz2 要被压缩的档案或目录名称  
                 查 询：tar -jtvf filename.tar.bz2  
                 解压缩：tar -jxvf filename.tar.bz2 -C 欲解压缩的目录
     
                tar -cvf sort.tar sort/                     # 将sort文件夹归档为sort.tar
                tar -cvf archive.tar file1 file2 file3      # 将 file1 file2 file3 归档为archive.tar

    • 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
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118

    3、文件系统操作

    1、挂载一个文件系统

        mount [-t vfstype] [-o options] device dir      挂载硬盘
                                        【mount常用参数】
                    (无) 不加任何参数，直接输入命令可以显示已挂载的文件系统和目录
                    -a 挂上/etc/fstab下的全部文件系统
                    -t 制定所挂上来的文件系统的名称，所有系统支持的文件系统，这个信息可以在/proc/filesystems这个文件里看到
                    -n 挂上文件系统，但是不把文件系统的数据写入/etc/mtlab这个文件
                    -w 将文件系统设为可读写
                    -r 挂上来的文件系统设为只读
                    -ro 采用只读方式挂接设备
                    -rw 采用读写方式挂接设备
        
                eg:
                    mount /home/mydisk.iso /tmp/mnt 通过mnt访问mydisk内的内容
    
    
    mount /dev/hda2 /mnt/hda2       挂载一个叫做hda2的盘 - 确定目录 '/ mnt/hda2' 已经存在  
    mount /dev/fd0 /mnt/floppy      挂载一个软盘 
    mount /dev/cdrom /mnt/cdrom     挂载一个cdrom或dvdrom 
    mount /dev/hdc /mnt/cdrecorder  挂载一个cdrw或dvdrom 
    mount /dev/hdb /mnt/cdrecorder  挂载一个cdrw或dvdrom 
    mount -o loop file.iso /mnt/cdrom   挂载一个文件或ISO镜像文件 
    mount -t vfat /dev/hda5 /mnt/hda5   挂载一个Windows FAT32文件系统 
    mount /dev/sda1 /mnt/usbdisk        挂载一个usb 捷盘或闪存设备 
    mount -t smbfs -o username=user,password=pass //WinClient/share /mnt/share      挂载一个windows网络共享 
    
    umount 取消挂载
    umount /dev/hda2                卸载一个叫做hda2的盘 - 先从挂载点 '/ mnt/hda2' 退出 
    umount -n /mnt/hda2             运行卸载操作而不写入 /etc/mtab 文件- 当文件为只读或当磁盘写满时非常有用 
    user -km /mnt/hda2             当设备繁忙时强制卸载

    • 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

    2、文件系统分析

        badblocks -v /dev/hda1      检查磁盘hda1上的坏磁块 
    
    fsck (-选项) 分区名称       检查和修复Linux文件系统,看是否有坏轨或数据流失的现象。
                                        【fsck常用参数】
                    -a 自动修复文件系统，不询问任何问题，比较危险

                    -A 依照/etc/fstab配置文件的内容，检查该文件内所列全部文件系统。若没有附加参数"-P”，则会先检查/目录的文件系统，而不会同时检查所有文件系统

                    -R 采取互动方式，在修复时询问问题，让用户确认并决定处理方式

                    -S 依次检查作业而不是同时执行。当依次指定多个文件系统且采用互动的方式进行检查时，请使用此参数以便顺序执行，否则fsck可能会同时询问数个问题，让人不知所措

                    -V 显示命令执行的过程

                    -T 指定要检查的文件系统的类型

                    -N 不是真正执行指令，仅列出实际执行时会进行的动作


    fsck /dev/hda1              修复/检查hda1磁盘上linux文件系统的完整性 

    fsck.ext2 /dev/hda1         修复/检查hda1磁盘上ext2文件系统的完整性 

    e2fsck /dev/hda1            修复/检查hda1磁盘上ext2文件系统的完整性 

    e2fsck -j /dev/hda1         修复/检查hda1磁盘上ext3文件系统的完整性 

    fsck.ext3 /dev/hda1         修复/检查hda1磁盘上ext3文件系统的完整性 

    fsck.vfat /dev/hda1         修复/检查hda1磁盘上fat文件系统的完整性 

    fsck.msdos /dev/hda1        修复/检查hda1磁盘上dos文件系统的完整性 

    dosfsck /dev/hda1           修复/检查hda1磁盘上dos文件系统的完整性 

    • 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

    3、初始化一个文件系统

        mkfs /dev/hda1          在hda1分区创建一个文件系统 

    mke2fs /dev/hda1        在hda1分区创建一个linux ext2的文件系统 

    mke2fs -j /dev/hda1     在hda1分区创建一个linux ext3(日志型)的文件系统 

    mkfs -t vfat 32 -F /dev/hda1    创建一个 FAT32 文件系统 

    fdformat -n /dev/fd0    格式化一个软盘 

    mkswap /dev/hda3        创建一个swap文件系统 

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

    4、SWAP文件系统

        mkswap /dev/hda3 创建一个swap文件系统 

    swapon /dev/hda3 启用一个新的swap文件系统 

    swapon /dev/hda2 /dev/hdb3 启用两个swap分区 

    • 1
    • 2
    • 3
    • 4
    • 5

    4、备份和光盘

    1、备份

        dump -0aj -f /tmp/home0.bak /home   制作一个 '/home' 目录的完整备份 
    dump -1aj -f /tmp/home0.bak /home   制作一个 '/home' 目录的交互式备份 
    restore -if /tmp/home0.bak          还原一个交互式备份 
    rsync -rogpav --delete /home /tmp   同步两边的目录 
    rsync -rogpav -e ssh --delete /home ip_address:/tmp             通过SSH通道rsync 
    rsync -az -e ssh --delete ip_addr:/home/public /home/local      通过ssh和压缩将一个远程目录同步到本地目录 
    rsync -az -e ssh --delete /home/local ip_addr:/home/public      通过ssh和压缩将本地目录同步到远程目录 
    dd bs=1M if=/dev/hda | gzip | ssh user@ip_addr 'dd of=hda.gz'   通过ssh在远程主机上执行一次备份本地磁盘的操作 
    dd if=/dev/sda of=/tmp/file1        备份磁盘内容到一个文件 
    tar -Puf backup.tar /home/user      执行一次对 '/home/user' 目录的交互式备份操作 
    ( cd /tmp/local/ && tar c . ) | ssh -C user@ip_addr 'cd /home/share/ && tar x -p'       通过ssh在远程目录中复制一个目录内容 
    ( tar c /home ) | ssh -C user@ip_addr 'cd /home/backup-home && tar x -p'        通过ssh在远程目录中复制一个本地目录 
    tar cf - . | (cd /tmp/backup ; tar xf - )       本地将一个目录复制到另一个地方，保留原有权限及链接 
    find /home/user1 -name '*.txt' | xargs cp -av --target-directory=/home/backup/ --parents        从一个目录查找并复制所有以 '.txt' 结尾的文件到另一个目录 
    find /var/log -name '*.log' | tar cv --files-from=- | bzip2 > log.tar.bz2       查找所有以 '.log' 结尾的文件并做成一个bzip包 
    dd if=/dev/hda of=/dev/fd0 bs=512 count=1       做一个将 MBR (Master Boot Record)内容复制到软盘的动作 
    dd if=/dev/fd0 of=/dev/hda bs=512 count=1       从已经保存到软盘的备份中恢复MBR内容 

 
        
    1、SCP命令： 
        scp： 它是 Secure Copy 的缩写，表示安全拷贝。scp 可以使我们通过网络，把文件从一台电脑拷贝到另一台电脑。
        scp 是基于 ssh 的原理来运作的， ssh 会在两台通过网络连接的电脑之间创建一条安全通信的管道， scp 就利用这条管道安全地拷贝文件。

        scp source_file destination_file                # source_file 表示源文件，destination_file 表示目标文件
            其中 source_file 和 destination_file 都可以这样表示：user@ip:file_name ， user 是登录名， ip 是域名或 ip 地址。file_name 是文件路径。


        scp file.txt root@192.168.1.5:/root             # 表示把我的电脑中当前文件夹下的 file.txt 文件拷贝到远程电脑
        scp root@192.168.1.5:/root/file.txt file.txt    # 表示把远程电脑上的 file.txt 文件拷贝到本机
        
    
    
    2、rsync 命令：
        rsync 命令主要用于远程同步文件。它可以同步两个目录，不管它们是否处于同一台电脑。它应该是最常用于“增量备份”的命令了。它就是智能版的 scp 命令。

        
        yum install rsync       软件安装
    
        基础用法：
            rsync -arv Images/ backups/                     # 将Images 目录下的所有文件备份到 backups 目录下
            rsync -arv Images/ root@192.x.x.x:backups/      # 将Images 目录下的所有文件同步到服务器的backups目录下
        
                                        【rsync常用参数】
                    -a 保留文件的所有信息，包括权限，修改日期等；
                    -r 递归调用，表示子目录的所有文件也都包括；
                    -v 冗余模式，输出详细操作信息。

        默认地， rsync 在同步时并不会删除目标目录的文件，例如你在源目录中删除一个文件，但是用 rsync 同步时，它并不会删除同步目录中的相同文件。如果向删除也可以这么做：rsync -arv --delete Images/ backups/ 。

    • 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

    2、光盘

        cdrecord -v gracetime=2 dev=/dev/cdrom -eject blank=fast -force         清空一个可复写的光盘内容 
    mkisofs /dev/cdrom > cd.iso             在磁盘上创建一个光盘的iso镜像文件 
    mkisofs /dev/cdrom | gzip > cd_iso.gz   在磁盘上创建一个压缩了的光盘iso镜像文件 
    mkisofs -J -allow-leading-dots -R -V "Label CD" -iso-level 4 -o ./cd.iso data_cd        创建一个目录的iso镜像文件 
    cdrecord -v dev=/dev/cdrom cd.iso       刻录一个ISO镜像文件 
    gzip -dc cd_iso.gz | cdrecord dev=/dev/cdrom - 刻录一个压缩了的ISO镜像文件 
    mount -o loop cd.iso /mnt/iso           挂载一个ISO镜像文件 
    cd-paranoia -B                          从一个CD光盘转录音轨到 wav 文件中 
    cd-paranoia -- "-3"                     从一个CD光盘转录音轨到 wav 文件中（参数-3） 
    cdrecord --scanbus                      扫描总线以识别scsi通道 
    dd if=/dev/hdc | md5sum                 校验一个设备的md5sum编码，例如一张 CD 

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

    5、OS包管理器，软件仓库

    1、Linux 下软件是以包的形式存在，一个软件包其实就是软件的所有文件的压缩包，是二进制的形式，包含了安装软件的所有指令。Red Hat 家族的软件包后缀名一般为 .rpm ，Debian 家族的软件包后缀是 .deb 。
Linux 的包都存在一个仓库，叫做软件仓库，它可以使用 yum 来管理软件包， yum 是 CentOS 中默认的包管理工具，适用于 Red Hat 一族。可以理解成 Node.js 的 npm 。

2、切换 CentOS 软件源：
    有时候 CentOS 默认的 yum 源不一定是国内镜像，导致 yum 在线安装及更新速度不是很理想。这时候需要将 yum 源设置为国内镜像站点。国内主要开源的镜像站点是网易和阿里云，清华园源，兰州大学源，中科院，华为源等。

    1、首先备份系统自带 yum 源配置文件：
        mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup


    2、下载阿里云的 yum 源配置文件到 /etc/yum.repos.d/CentOS7
        wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
    
    3、生成缓存
        yum makecache

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

    1、RPM 包 - （Fedora, Redhat及类似系统）

        rpm -ivh package.rpm            安装一个rpm包 
    rpm -ivh --nodeps package.rpm   安装一个rpm包而忽略依赖关系警告 
    rpm -U package.rpm              更新一个rpm包但不改变其配置文件 
    rpm -F package.rpm              更新一个确定已经安装的rpm包 
    rpm -e [--nodeps] package_name.rpm  删除一个rpm包[--nodeps表示忽略依赖关系] 
    rpm -e --nodeps `rpm -qa | grep clickhouse`     批量删除所有 ClickHouse 已安装的 rpm 包,并忽略彼此间的依赖关系
    rpm -qa                         显示系统中所有已经安装的rpm包 
    rpm -qa | grep httpd            显示所有名称中包含 "httpd" 字样的rpm包 
    rpm -qi package_name            获取一个已安装包的特殊信息 
    rpm -qg "System Environment/Daemons"            显示一个组件的rpm包 
    rpm -ql package_name            显示一个已经安装的rpm包提供的文件列表 
    rpm -qc package_name            显示一个已经安装的rpm包提供的配置文件列表 
    rpm -q package_name --whatrequires              显示与一个rpm包存在依赖关系的列表 
    rpm -q package_name --whatprovides              显示一个rpm包所占的体积 
    rpm -q package_name --scripts   显示在安装/删除期间所执行的脚本l 
    rpm -q package_name --changelog 显示一个rpm包的修改历史 
    rpm -qf /etc/httpd/conf/httpd.conf              确认所给的文件由哪个rpm包所提供 
    rpm -qp package.rpm -l          显示由一个尚未安装的rpm包提供的文件列表 
    rpm --import /media/cdrom/RPM-GPG-KEY           导入公钥数字证书 
    rpm --checksig package.rpm      确认一个rpm包的完整性 
    rpm -qa gpg-pubkey              确认已安装的所有rpm包的完整性 
    rpm -V package_name             检查文件尺寸、 许可、类型、所有者、群组、MD5检查以及最后修改时间 
    rpm -Va                         检查系统中所有已安装的rpm包- 小心使用 
    rpm -Vp package.rpm             确认一个rpm包还未安装 
    rpm2cpio package.rpm | cpio --extract --make-directories *bin*          从一个rpm包运行可执行文件 
    rpm -ivh /usr/src/redhat/RPMS/`arch`/package.rpm                        从一个rpm源码安装一个构建好的包 
    rpmbuild --rebuild package_name.src.rpm         从一个rpm源码构建一个 rpm 包

    • 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

    2、YUM 软件包升级器 - （Fedora, RedHat及类似系统）

        yum update | yum upgrade        更新软件包    
    yum install package_name        下载并安装一个rpm包 (如: yum -y install zip unzip)
    yum localinstall package_name.rpm   将安装一个rpm包，使用你自己的软件仓库为你解决所有依赖关系 
    yum update package_name.rpm     更新当前系统中所有安装的rpm包 
    yum update package_name         更新一个rpm包 
    yum remove package_name         删除一个rpm包 
    yum list | grep tmux            列出所有可安裝的软件清单命令
    yum search package_name         在rpm仓库中搜寻软件包 
    yum clean packages              清理rpm缓存删除下载的包 
    yum clean headers               删除所有头文件 
    yum clean all                   删除所有缓存的包和头文件 

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

    3、DEB 包 (Debian, Ubuntu 以及类似系统)

        dpkg -i package.deb             安装/更新一个 deb 包 
    dpkg -r package_name            从系统删除一个 deb 包 
    dpkg -l                         显示系统中所有已经安装的 deb 包 
    dpkg -l | grep httpd            显示所有名称中包含 "httpd" 字样的deb包 
    dpkg -s package_name            获得已经安装在系统中一个特殊包的信息 
    dpkg -L package_name            显示系统中已经安装的一个deb包所提供的文件列表 
    dpkg --contents package.deb     显示尚未安装的一个包所提供的文件列表 
    dpkg -S /bin/ping               确认所给的文件由哪个deb包提供 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    4、APT 软件工具 (Debian, Ubuntu 以及类似系统)

        apt-get install package_name    安装/更新一个 deb 包 
    apt-cdrom install package_name  从光盘安装/更新一个 deb 包 
    apt-get update                  升级列表中的软件包 
    apt-get upgrade                 升级所有已安装的软件 
    apt-get remove package_name     从系统删除一个deb包 
    apt-get check                   确认依赖的软件仓库正确 
    apt-get clean                   从下载的软件包中清理缓存 
    apt-cache search searched-package   返回包含所要搜索字符串的软件包名称 
     


wget [参数] [URL地址] |     直接从网络上下载文件。可以使我们直接从终端控制台下载文件，只需要给出文件的HTTP或FTP地址。
wget 非常稳定，如果是由于网络原因下载失败， wget 会不断尝试，直到整个文件下载完毕。
                                        【wget常用参数】
                    -o FILE 把记录写到FILE文件中。 
                    -c 继续中断的下载。
                
wget -O a.txt URL                   把下载记录写到FILE文件中
wget --limit-rate=300k URL          限速下载

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

    6、进程管理

    1、查看进程

        在 Windows 中通过 Ctrl + Alt + Delete 快捷键查看软件进程。

    1、w 命令：
        显示当前在线用户情况,帮助我们快速了解系统中目前有哪些用户登录着，以及他们在干什么。

        [root@lion ~]# w 06:31:53 up 25 days,  9:53,  1 user,  load average: 0.00, 0.01, 0.05

    USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
    root     pts/0    118.31.243.53    05:56    1.00s  0.02s  0.00s 
    
        w 06:31:53：表示当前时间
        up 25 days, 9:53：表示系统已经正常运行了“25天9小时53分钟”
        1 user：表示一个用户
        load average: 0.00, 0.01, 0.05：表示系统的负载，3个值分别表示“1分钟的平均负载”，“5分钟的平均负载”，“15分钟的平均负载” 
        
        USER：表示登录的用于 
        TTY：登录的终端名称为pts/0 
        FROM：连接到服务器的ip地址 
        LOGIN@：登录时间 
        IDLE：用户有多久没有活跃了 
        JCPU：该终端所有相关的进程使用的 CPU 时间，每当进程结束就停止计时，开始新的进程则会重新计时 
        PCPU：表示 CPU 执行当前程序所消耗的时间，当前进程就是在 WHAT 列里显示的程序 
        WHAT：表示当下用户正运行的程序是什么，这里我运行的是 w



    2、ps 命令：
        用于显示当前系统中的进程， ps 命令显示的进程列表不会随时间而更新，是静态的，是运行 ps 命令那个时刻的状态或者说是一个进程快照。

        基础语法
            ps  PID TTY          TIME CMD 1793 pts/0    00:00:00 bash 4756 pts/0    00:00:00 ps  
            
            PID：进程号，每个进程都有唯一的进程号 
            TTY：进程运行所在的终端 
            TIME：进程运行时间 
            CMD：产生这个进程的程序名，如果在进程列表中看到有好几行都是同样的程序名，那么就是同样的程序产生了不止一个进程。

                                        【ps常用参数】
                    -ef 列出所有进程;
                    -efH 以乔木状列举出所有进程;
                    -aux 显示所有包含其他使用者的行程
                    ps -aux | less  通过 CPU 和内存使用来过滤进程 
                    -aux --sort -pcpu 按 CPU 使用降序排列， 
                    -aux --sort -pmem 表示按内存使用降序排列;
                    -axjf 以树形结构显示进程， ps -axjf 它和 pstree 效果类似。       
                    -s 基本选项：
                     -A, -e               所有进程
                     -a                   除会话引导符外，所有都使用tty
                      a                   所有都使用tty，包括其他用户
                     -d                   除会话负责人外
                     -N, --deselect       取消选择
                      r                   仅运行进程
                      T                   该终端上的所有进程
                      x                   不控制ttys的进程 
                      
                    
                    -l 按列表选择:
                     -C <命令>            命令名称
                     -G, --Group     真实的组id或组名
                     -g, --group   会话或有效组名
                     -p, p, --pid    进程编号
                            --ppid   父进程编号
                     -q, q, --quick-pid 
                                          进程id(快速模式)
                     -s, --sid   会话id
                     -t, t, --tty    终端
                     -u, U, --user   有效的用户id或名称
                     -U, --User      真实用户编号或名称

                      选择选项也将其作为参数:
                        逗号分隔的列表。'-u root,nobody' 或
                        空白分隔的列表。'-p 123 4567'     
                      
                      
                    -o 输出格式：
                        -F                   超满的
                        -f                   完整格式，包含命令行
                        f, --forest         ascii 字符艺术显示的进程树
                        -H                   显示流程层次结构
                        -j                   作业的格式
                        j                   BSD 任务控制格式
                        -l                   长格式
                        l                   BSD 长格式
                        -M, Z                添加安全数据（用于 SELinux）
                        -O           预加载默认列
                        O           作为-O，具有BSD特性
                        -o, o, --format <格式>
                                          用户定义的格式
                        s                   信号格式
                        u                   面向用户的格式
                        v                   虚拟内存格式
                        X                   寄存器格式
                        -y                  不显示标志，显示RSS和地址(与-l一起使用)
                         --context        显示安全上下文（用于 SELinux）
                         --headers        重复标题行，每页一个
                         --no-headers     根本不打印页眉
                         --cols, --columns, --width 
                                          设置屏幕宽度
                         --rows, --lines 
                                          设置屏幕高度   
                     
                     
                    -t Show threads:
                        H                   就像它们是进程一样
                        -L                   可能有LWP和NLWP列
                        -m, m                后处理
                        -T                   可能与SPID列
                         
                         
                    -m Miscellaneous options:
                        -c                   使用-l选项显示调度类
                        c                   显示真正的命令名
                        e                   命令后显示环境
                        k,    --sort        指定排序顺序为: [+|-]key[,[+|-]key[,...]]
                        L                   显示格式说明符
                        n                   显示数字uid和wchan
                        S,    --cumulative  包括一些死子进程数据
                        -y                   不显示标志，只显示rss（仅使用-l）
                        -V, V, --version     显示版本信息并退出
                        -w, w                不限制输出宽度

                            --help 
                                          显示帮助信息并退出



    3、top
        top [参数] |      获取进程的动态列表。显示当前系统正在执行的进程的相关信息，包括进程ID、内存占用率、CPU占用率等  

        top - 07:20:07 up 25 days, 10:41, 1 user, load average: 0.30, 0.10, 0.07 相当 w命令的第一行的信息。
        
        展示的这些进程是按照使用处理器 %CPU 的使用率来排序的。
        
        
    4、fuser命令：
        fuser：无效的选项 --help
        fuser 显示哪些进程使用指定的文件、端口或文件系统。
        用法：fuser [-fIMuvw] [-a|-s] [-4|-6] [-c|-m|-n 命名空间]
                    [-k [-i] [-信号]] 名字...
              fuser -l
              fuser -V

                        【fuser常用参数】：
            -a,--all              也显示未使用的文件
            -i,--interactive      杀死程序前询问 (未指定 -k 选项时被忽略)
            -I,--inode            总是使用 inode 来比较文件
            -k,--kill             杀死访问指定文件的进程
            -l,--list-signals     列出可用的信号名
            -m,--mount            显示所有使用指定文件系统或块设备的进程
            -M,--ismountpoint     只在 <名字> 为挂载点时完成要求
            -n,--namespace 空间   在指定命名空间中查找 (file、udp 或 tcp)
            -s,--silent           不输出信息
            -信号                 发送指定的 "信号" 而不是 SIGKILL
            -u,--user             显示用户 ID
            -v,--verbose          输出更多信息
            -w,--writeonly        只杀死有权写入的进程
            -V,--version          显示版本信息
            -4,--ipv4             仅查找 IPv4 套接字
            -6,--ipv6             仅查找 IPv6 套接字
            -                     重置选项

            udp/tcp 名字格式: [本地端口][,[远程主机][,[远程端口]]]

    
    
    
    
    
    
    5、kill 命令杀死进程：
        kill [-s 信号声明 | -n 信号编号 | -信号声明] 进程号 | 任务声明 ... 或 kill -l [信号声明]                向一个任务发送一个信号。
        
        向以 PID 进程号或者 JOBSPEC 任务声明指定的进程发送一个以
        SIGSPEC 信号声明或 SIGNUM 信号编号命名的信号。如果没有指定
        SIGSPEC 或 SIGNUM，那么假定发送 SIGTERM 信号。

        kill -1：HUP 终端断线

        kill -2：INT 中断（同 Ctrl + C）
         
        kill -3：QUIT 退出（同 Ctrl + \）
         
        kill -9：KILL 强制终止
         
        kill -15：TERM 终止
         
        kill -18：CONT 继续（与STOP相反， fg/bg命令）
         
        kill -19：STOP 暂停（同 Ctrl + Z）
        
        pid>0，信号sig发送给进程号=pid的进程
        pid=0，信号sig被发送给调用者进程所在组中的每一个进程
        pid=-1，信号sig将被发送调用者进程有权限发送的每一个进程，除了1号进程之外
        pid<-1，信号将发送给进程组=-pid中的每一个进程
        
        
                                        【kill常用参数】
                    -l 列出所有可用的信号名称，如果参数后跟 `-l'则被假设为信号编号，而相应的信号名称会被列出。
                    -p 印出pid并不发送信号
                    -n sig	    SIG 是信号编号
                    -s signal   SIG 是信号名称，其中可用的讯号有 HUP (1), KILL (9), TERM (15), 分别代表著重跑, 砍掉, 结束
        kill                        结束一个进程， kill + PID 。
        kill 956                    # 结束进程号为956的进程
        kill 956 957                # 结束多个进程
        kill -9 7291                # 强制结束进程
        pkill -kill -t pts/??       杀掉指定名字的进程，如上述的pts/5
        killall Jincheng            杀死匹配与指定<进程号>具有相同命名空间的进程
        
        
        杀死进程实例：
            1、根据进程PID号杀死进程：
                1、根据进程号（PID）杀死进程：第二列显示的就是进程号

                    kill 命令杀死指定进程PID的进程

                        kill PID
                
                2、强制杀死进程。（有些进程可能杀不死，就加个-9参数，强制将其杀死）

                    kill -9 PID
                
                3、杀死多个进程，在命令 kill -9 后面跟多个进程的PID号即可。（进程号之间以空格隔开）

                    kill -9 PID1 PID2 PID3 ...



            2、强制杀死某个端口号下的所有进程。
                示例：杀死tcp端口8080下的所有进程

                sudo fuser -k -n tcp 8080  
                
                fuser用于通过文件或端口号识别进程。
                
                
                
            3、杀死某个命令下的所有进程
                
                1、实例1：使用 killall 命令杀死所有python3 执行的程序： 
                    killall [参数] [进程名] 

                    killall 命令用于杀死指定名字的进程（kill processes by name）

                        sudo killall python3
                
                注意：一般情况下，不会采用该方法去批量杀死进程，因为此方法可能会造成误杀。

                2、实例2：使用 pkill 命令杀死所有python3执行的程序： 
                    pkill [参数] [进程名] 

                    pkill 命令与 killall 命令相同，同样用于杀死指定名字的进程（kill processes by name）

                    sudo pkill python3
                    
                
                    
            4、杀死进程名中含有xxx字段的所有进程
                1、实例：杀死进程名中含 ‘AI_server’ 字段的所有进程(不推荐)

                    ps -def | grep 'AI_server' | cut -c 9-15 | xargs kill -9
                
                    已经成功杀死了所有进程名中包含‘AI_srever’字段的所有进程
                
                    命令详解：
                        1、 ps -ef |grep 'AI_server' 
                            这个命令会查出所有进程名字中含有‘AI_server’字段的进程。
                            
                        2、cut 9-15 
                            从输出结果的每行字符串中截取第9-15个字符， 刚好就是我们所需的进程号。
                        3、xargs kill -9 
                            命令 xargs 是将前面提取到的所有的进程号，作为参数传给命令 kill -9 ， 这样我们就能杀死所有的进程。（ xargs kill -9 中的 xargs 命令是用来把前面命令的输出结果(PID)作为 kill -9 命令的参数，并执行该令）
                        
                        
                        
                2、方法进阶，优化方法杀死进程名中含 ‘AI_server’ 字段的所有进程：
                    
                    ps -ef | grep LOCAL=NO | grep -v grep | cut -c 9-15 | xargs kill -9

                    注意：（参照方法三中的批量杀死进程的执行结果）使用 ps -ef | grep xxx 命令根据进程名中的字段查找进程ID的时候，同时会包含含有关键字《grep》的进程。
                    
                    解决办法： 
                        1、 ps -ef |grep 'LOCAL=NO' 
                                这个命令会查出所有进程名字中含有‘LOCAL=NO’字段的进程。
                        2、grep -v grep 是在列出的进程中去除含有关键字 grep 的进程。
                        3、cut 9-15 
                                从输出结果的每行字符串中截取第9-15个字符， 刚好就是我们所需的进程号。
                        4、xargs kill -9 
                            命令 xargs 是将前面提取到的所有的进程号，作为参数传给命令 kill -9 ， 这样我们就能杀死所有的进程。（ xargs kill -9 中的 xargs 命令是用来把前面命令的输出结果(PID)作为 kill -9 命令的参数，并执行该令）



                3、执行打印出来的这些命令，杀死进程名中包含 aaa 字段的进程。
                
                    ps -ef|grep 'aaa' |grep -v grep|awk  '{print "kill -9 " $2}' |sh
                    
                    命令详解：
                        1、ps -ef|grep 'aaa' 这个命令会查出所有进程名字中含有‘aaa’字段的进程。
                        2、命令 grep -v grep 是过滤掉 grep 命令本身的进程；

                        3、awk  '{print "kill -9 " $2}' 命令会列出所有要杀死的进程，并将之打印在了屏幕上。
                      
                        4、命令 ps -ef | grep aaa | grep -v grep|awk '{print "kill -9 "$2}'  列出了所有要杀死的进程，并将之打印在了屏幕上。
                            $2 表示第2列,即进程号PID；。
                        
                        5、 |sh ，表示执行打印出来的这些命令，进而达到杀死进程名中包含‘aaa’字段的进程。
                
              
                
                4、杀死进程名中包含 check_os.sh 字段的进程，并排除 grep 自身的进程，和 打印所有符合条件的进程PID，再将结果传给 kill -9 执行。
                    
                    ps -ef|grep 'check_os.sh' | grep -v grep | awk '{print $2}' | xargs kill -9
                    1、ps -ef|grep 'check_os.sh' 这个命令会查出所有进程名字中含有‘check_os.sh’字段的进程。
                    2、grep -v grep 是过滤掉 grep 命令本身的进程；
                    
                    3、awk '{print $2}' 表示输出所有进程的第二列的进程PID。
                        $2 表示第2列,即进程号PID；。
                    4、xargs kill -9 
                            命令 xargs 是将前面提取到的所有的进程号，作为参数传给命令 kill -9 ， 这样我们就能杀死所有的进程。（ xargs kill -9 中的 xargs 命令是用来把前面命令的输出结果(PID)作为 kill -9 命令的参数，并执行该令）    
            
            
            
                5、杀死进程名中包含 tomcat 字段的进程，将需要杀死的进程号赋值给变量，再使用命令 kill -9 杀死他们

                    pidlist=`ps -ef |grep tomcat |grep -v grep|awk '{print $2}'`

                    kill -9 $pidlist 
                    
                        1、pidlist= 将需要杀死的进程号赋值给变量 pidlist
                        
                        2、ps -ef|grep 'tomcat' 这个命令会查出所有进程名字中含有‘tomcat’字段的进程。
                        3、命令 grep -v grep 是过滤掉 grep 命令本身的进程；

                        4、awk '{print $2}' 表示输出所有进程的第二列的进程PID。
                            $2 表示第2列,即进程号PID；。
                        
                        5、kill -9 $pidlist  使用命令 kill -9 杀死变量 pidlist 中的进程号。
                        
            
            注意：有的root进程给命令加sudo提权限是杀不掉进程的，需要切换到root用户再用命令杀进程。

    • 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
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314
    • 315
    • 316
    • 317
    • 318
    • 319
    • 320
    • 321
    • 322
    • 323
    • 324
    • 325
    • 326
    • 327
    • 328
    • 329
    • 330
    • 331
    • 332
    • 333
    • 334
    • 335
    • 336
    • 337
    • 338
    • 339

    2、进程状态：

        主要是切换进程的状态。我们先了解下 Linux 下进程的五种状态：

    状态码 R ：表示正在运行的状态；

    状态码 S ：表示中断（休眠中，受阻，当某个条件形成后或接受到信号时，则脱离该状态）；

    状态码 D ：表示不可中断（进程不响应系统异步信号，即使用kill命令也不能使其中断）；

    状态码 Z ：表示僵死（进程已终止，但进程描述符依然存在，直到父进程调用 wait4()系统函数后将进程释放）；

    状态码 T ：表示停止（进程收到 SIGSTOP 、 SIGSTP 、 SIGTIN 、 SIGTOU 等停止信号后停止运行）。

    
    taskset -pc 35986           查看进程所运行的核

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

    3、前台进程 & 后台进程

        1、前台进程：默认情况下，用户创建的进程都是前台进程，前台进程从键盘读取数据，并把处理结果输出到显示器。例如运行 top 命令，这就是一个一直运行的前台进程。

    2、后台进程：后台进程的优点是不必等待程序运行结束，就可以输入其它命令。在需要执行的命令后面添加& 符号，就表示启动一个后台进程。
        
        &：启动后台进程，它的缺点是后台进程与终端相关联，一旦关闭终端，进程就自动结束了。

    3、cp name.csv name-copy.csv &     在后台运行
    
    4、nohup 命令：
        使进程不受挂断（关闭终端等动作）的影响。
        nohup cp name.csv name-copy.csv     
        nohup                               命令也可以和 & 结合使用。
        nohup cp name.csv name-copy.csv &   
    
    5、bg 命令：
        使一个“后台暂停运行”的进程，状态改为“后台运行”。
        bg %1           # 不加任何参数的情况下，bg命令会默认作用于最近的一个后台进程，如果添加参数则会作用于指定标号的进程
    
    
    6、实际案例1：

        1. 执行 grep -r "log" / > grep_log 2>&1   命令启动一个前台进程，并且忘记添加 & 符号。
        2. ctrl + z 使进程状态转为后台暂停。
        3. 执行 bg 将命令转为后台运行。
        
        
    7、实际案例2：

        前端开发时我们经常会执行 yarn start 启动项目，
        此时我们执行 ctrl + z 先使其暂停，
        然后执行 bg 使其转为后台运行，这样当前终端就空闲出来可以干其它事情了，
        如果想要唤醒它就使用 fg 命令即可（后面会讲）。
        
        
    8、jobs 命令：
        显示当前终端后台进程状态。

        [root@lion ~]# jobs[1]+  Stopped                 top[2]-  Running                 grep --color=auto -r "log" / > grep_log 2>&1 &
    
    
    9、fg 命令：
        fg 使进程转为前台运行，用法和 bg 命令类似。

        我们可以使程序在后台运行，成为后台进程，这样在当前终端中我们就可以做其他事情了，而不必等待此进程运行结束。

    • 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

    4、守护进程

        1、一个运行起来的程序被称为进程。在 Linux 中有些进程是特殊的，它不与任何进程关联，不论用户的身份如何，都在后台运行，这些进程的父进程是 PID 为1的进程， PID 为1的进程只在系统关闭时才会被销毁。它们会在后台一直运行等待分配工作。我们将这类进程称之为守护进程 daemon 。
    守护进程的名字通常会在最后有一个 d ，表示 daemon 守护的意思，例如 systemd、httpd 。
    
    2、systemd 进程：
        systemd 是一个 Linux 系统基础组件的集合，提供了一个系统和服务管理器，运行为 PID 1 并负责启动其它程序。

        [root@lion ~]# ps -auxUSER       
        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMANDroot               1  0.0  0.2  51648  3852 ?        Ss   Feb01   1:50 /usr/lib/systemd/systemd --switched-root --system --deserialize 22

        通过命令也可以看到 PID 为1的进程就是 systemd 的系统进程。

    3、systemd 常用命令（它是一组命令的集合）：

        systemctl start nginx       # 启动服务
        systemctl stop nginx        # 停止服务
        systemctl restart nginx     # 重启服务
        systemctl status nginx      # 查看服务状态
        systemctl reload nginx      # 重载配置文件(不停止服务的情况)
        systemctl enable nginx      # 开机自动启动服务
        systemctl disable nginx     # 开机不自动启动服务
        systemctl is-enabled nginx  # 查看服务是否开机自动启动
        systemctl list-unit-files --type=service    # 查看各个级别下服务的启动和禁用情况

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

    5、持续监控Linux命令的执行情况

        Linux和windows相比，很多管控都需要用命令来操作。windows以直观的可视化的方式操作，特别适合在桌面端PC上操作执行相应的软件。
    而Linux命令行方式的操作，特别是在服务器端编程、管理、运维方面，更加简单、短小、精悍。短短一行组合命令，即可完成在windows需要各种加工、整合的复杂高效的功能操作
    
    
    watch [参数] [命令] |  重复执行某一命令以观察变化
                                        【watch常用参数】:
                    -b, --beep             如果命令以非零返回值退出的话则发出哔声
                    -c, --color            解释ANSI颜色和样式序列
                    -d, --differences[=]
                                         突出显示更新之间的更改,高亮显示动态变化
                    -e, --errexit          如果命令具有非零出口，则退出
                    -g, --chgexit          命令输出更改时退出
                    -n, --interval   更新之间等待的秒数,默认为2s刷新一次，通过-n 参数更新刷新频次；
                    -p, --precise          尝试以精确的间隔运行命令
                    -t, --no-title         关闭头部显示
                    -x, --exec             将命令传给 exec 而非“sh -c”

                    -h, --help     显示此帮助然后离开
                    -v, --version  output version information and exit

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

    6、僵尸进程：

        僵尸进程：在 Linux 系统中，一个进程结束了,但是他的父进程没有等待(调用wait / waitpid)他,那么他将变成一个僵尸进程。当用ps命令观察进程的执行状态时,看到这些进程的状态栏为defunct是一个早已死亡的进程，但在进程表(processs table)中仍占了一个位置(slot)。
        
    1、查看系统中是否存在defunct进程：
        ps -ef | grep defunct
        
        
    2、 查看僵尸进程的ID及其父进程ID:
    
        1、查看所有僵尸进程的ID及其父进程ID:
            ps -ef | grep defunct | more

        2、查看某个僵尸进程的父进程ID
            ps -ef | grep defunct_process_pid #得到defunct进程的父进程ID
             
            
            UID PID PPID C STIME TTY TIME CMD   条目：
            UID：用户ID
            PID：进程ID
            PPID：父进程ID
                
        3、找到僵尸进程的父进程然后kill -9 杀死：
            需要确定僵尸进程的相关信息，比如父进程ppid、僵尸进程的pid以及命令行等信息。
            ps -e -o stat,ppid,pid,cmd | egrep '^[Zz]'
            
            说明：

                ps：ps命令用于获取当前系统的进程信息.

                -e：参数用于列出所有的进程

                -o：参数用于设定输出格式，这里只输出进程的stat(状态信息)、ppid(父进程pid)、pid（当前进程的pid)，cmd(即进程的可执行文件。

                egrep：是linux下的正则表达式工具

                '^[Zz]'：这是正则表达式，表示第一个字符的位置，[Zz]，表示z或者大写的Z字母，即表示第一个字符为Z或者z开头的进程数据，只所以这样是因为僵尸进程的状态信息以Z或者z字母开头。

          
                
    3、杀死僵尸进程：
        1、重启服务器：
            sudo reboot
            
        2、通过结束父进程从而结束僵尸进程杀死父进程：

            kill -9 PPID  
                     
        3、很多时候遇到僵尸进程我们不能结束父进程，比如父进程是init进程，那一旦结束父进程，整个系统就挂掉了，这时候则可以考虑挂起子进程，这相当于“曲线救国”。一个进程一旦挂起就相当于“什么都不做了”。可以通过执行如下命令来挂起进程。
                
            kill -hup 2563   

    • 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

    7、登录与注销，关机 (系统的关机、重启以及登出 )

    login               //登录或切换用户
logout              //注销用户（命令行）,退出登录shell  
exit                (shell-退出控制台)

shutdown –(选项)      关机/重启
                                        【shutdown常用参数】:
                    -k 不是真正的关机，只是发出警告命令
                    -r 关机后重启（这个用的最多）
                    -t 在规定的时间内关机
            
shutdown -h hours:minutes &     按预定时间关闭系统 
shutdown -h 10      //10分钟后自动关机
shutdown -c         取消按预定时间关闭系统 
shutdown -r now     重启
shutdown -r 10      //十分钟后自动重启

reboot              //关机，关闭系统，需要 root 身份。只有输入，不加任何参数，系统会以最快的速度关机，且不将内存或缓冲区里的东西写回硬盘。
                                        【reboot常用参数】:
                    -d 不把记录写到/var/log/wtmp档案里(-n这个参数包含了-d)
                    -f 强迫重开机，不呼叫shutdown这个指令
                    -n 在重开机前不做将记忆体资料写回硬盘
                    -w 并不会真的重开机，只是把记录写到/var/log/wtmp档案里
            
halt(root用户)      //关闭所有进程后自动关机，需要 root 身份。
poweroff            //关闭所有进程后自动关机，直接运行即可关机，不需要 root 身份。

init 6              //重启 （0-关机，1-单用户，2-多用户，3-完全多用户，4-图形化，5-安全模式，6-重启）
init 0              关闭系统
telinit 0           关闭系统

    • 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

    8、用户和用户群组相关的命令

    1、用户：

        Linux 是一个多用户的操作系统。在 Linux 中，理论上来说，我们可以创建无数个用户，但是这些用户是被划分到不同的群组里面的，有一个用户，名叫 root ，是一个很特殊的用户，它是超级用户，拥有最高权限。
    自己创建的用户是有限权限的用户，这样大大提高了 Linux 系统的安全性，有效防止误操作或是病毒攻击，但是我们执行的某些命令需要更高权限时可以使用 sudo 命令。
    
    
    sudo date           当然查看日期是不需要sudo的这里只是演示，sudo 完之后一般还需要输入用户密码
    
    adduser 和 useradd 在Ubuntu中都可以用来创建用户：
    
    adduser 与 useradd 区别：
        adduser 与 useradd 指令为同一指令（经由符号连结 symbolic link）：
        
        1、useradd是一个linux命令，它提供了很多参数在用户使用的时候根据自己的需要进行设置；
        1、adduser是一个perl 脚本，在使用的时候会出现类似人机交互的界面，系统将会提示输入创建用户所需的各种信息，只要跟着系统的提示就能完成用户的创建，这个命令比起useradd来说比较简单。
        
        2、useradd user1 用户名后面如果不添加其他任何选项，创建出来的用户将是默认的“三无”用户，且该用户无法登陆。这属于使用 useradd 创建用户没有做完。useradd创建用户的过程，用户名，密码和主目录三个过程是分开进行的。
            无家目录。
            无密码。
            无系统Shell。
        2、adduser user1 命令可以不带任何参数使用，并在完成后自动创建主目录。adduser 命令倾向于一种人际对话的过程，它会提示操作者按照步骤设置，前两步当然就是输入密码和再次确认密码，而useradd是没有人机对话过程的；
        
        3、Linux中通常会使用useradd。
        3、而Ubuntu中通常使用adduser。
        
        
        
    adduser 添加用户:
        sudo adduser lilei          //创建一个用户newuser，并交互式的设置密码(会自动同名组，创建/home/test/，从etc/skel/复制文件，并设定密码和相关初始身份信息)(推荐方式)，新增使用者帐号或更新预设的使用者资料。
        
        
    useradd 添加用户：
        //useradd 创建用户的过程，用户名，密码和主目录三个过程是分开进行的。
        1、sudo useradd newuser        //创建一个用户newuser，需要手动创建 /home
        
        2、passwd newuser              //需要为用户newuser设置密码
        
        3、useradd -d /home/newuser newuser    //为用户newuser设置主目录

        
        示例：
            useradd -c "Name Surname " -g admin -d /home/user1 -s /bin/bash user1   //创建一个属于 "admin" 用户组的用户 user1 
        
        用法：useradd [选项] 登录
                          useradd -D
                          useradd -D [选项]
        
        useradd [-u UID] [-g 初始群组] [-G 次要群组] [-c 说明栏] [-d 家目录绝对路径] [-s shell] 使用者账号名 |          新增用户
                            
                                            【useradd常用参数】:
                          --badnames                不检查坏名字
                      -b, --base-dir BASE_DIR	    新账户的主目录的基目录
                          --btrfs-subvolume-home    use BTRFS subvolume for home directory
                      -c, --comment COMMENT         新账户的 GECOS 字段
                      -d, --home-dir HOME_DIR       新账户的主目录
                      -D, --defaults		        显示或更改默认的 useradd 配置
                      -e, --expiredate EXPIRE_DATE  新账户的过期日期,格式为『YYYY-MM-DD』
                      -f, --inactive INACTIVE       新账户的密码不活动期
                      -g, --gid GROUP		新账户主组的名称或 ID
                      -G, --groups GROUPS	新账户的附加组列表
                      -h, --help            显示此帮助信息并推出
                      -k, --skel SKEL_DIR	使用此目录作为骨架目录
                      -K, --key KEY=VALUE   不使用 /etc/login.defs 中的默认值
                      -l, --no-log-init	    不要将此用户添加到最近登录和登录失败数据库
                      -m, --create-home	    创建用户的主目录(一般账号默认值)
                      -M, --no-create-home  不创建用户的主目录(系统账号默认值)
                      -N, --no-user-group	不创建同名的组
                      -o, --non-unique		允许使用重复的 UID 创建用户
                      -p, --password PASSWORD		加密后的新账户密码
                      -r, --system                  创建一个系统账户,这个账号的 UID 会有限制
                      -R, --root CHROOT_DIR         chroot 到的目录
                      -P, --prefix PREFIX_DIR       prefix directory where are located the /etc/* files     */
                      -s, --shell SHELL		新账户的登录 shell
                      -u, --uid UID			新账户的用户 ID
                      -U, --user-group		创建与用户同名的组
                      -Z, --selinux-user SEUSER		为 SELinux 用户映射使用指定 SEUSER
                          --extrausers              Use the extra users database
        
        
        
        
        
    
    设置sudo权限，为用户添加sudo权限，可以使用修改sudoers和adduser两种方法，推荐使用第二种：
        
        1、etc/sudoers文件就是与sudo组有关的文件，在里面添加一行

            newuser ALL=(ALL) ALL
        
        
        2、第二种是使用adduser命令，直接一行：

            adduser newuser sudo
    


    
    passwd              修改密码，需要 root 用户权限
                                        【passwd常用参数】:
                    -l 使密码失效
                    -u 与-l相对，用户解锁
                    -S 列出登陆用户passwd文件内的相关参数
                    -n 后面接天数，shadow 的第 4 字段，多久不可修改密码天数
                    -x 后面接天数，shadow 的第 5 字段，多久内必须要更动密码
                    -w 后面接天数，shadow 的第 6 字段，密码过期前的警告天数
                    -i 后面接『日期』，shadow 的第 7 字段，密码失效日期
                    使用管道刘设置密码：echo "zeng" | passwd --stdin zenghao
                      
    passwd user1            修改一个用户的密码 (只允许root执行)
    
    userdel             删除用户，需要 root 用户权限，删除用户账号在系统文件/etc/passwd，/etc/group，/etc/shadow等文件下的信息，要想删除主目录即用户的家目录需要使用-r参数。
                                        【userdel常用参数】:
                    -r 用户文件一并删除  
                              
    userdel lion        只会删除用户名，不会从/home中删除对应文件夹
    userdel lion -r     会同时删除/home下的对应文件夹
    
    chage [-ldEImMW] 账号名 |      修改用户密码的相关属性
                                        【chage常用参数】:
                     -l 列出该账号的详细密码参数;
                     -d 后面接日期，修改 shadow 第三字段(最近一次更改密码的日期)，格式YYYY-MM-DD
                     -E 后面接日期，修改 shadow 第八字段(账号失效日)，格式 YYYY-MM-DD
                     -I 后面接天数，修改 shadow 第七字段(密码失效日期)
                     -m 后面接天数，修改 shadow 第四字段(密码最短保留天数)
                     -M 后面接天数，修改 shadow 第五字段(密码多久需要进行变更)
                     -W 后面接天数，修改 shadow 第六字段(密码过期前警告日期)
    
    usermod [-cdegGlsuLU] username |    修改用户的相关属性
                                        【usermod常用参数】:
                     -a -G 会让你离开原先的群组，如果你不想这样做的话，就得再添加 -a 参数，意味着append 追加的意思。
                     -c 后面接账号的说明，即 /etc/passwd 第五栏的说明栏，可以加入一些账号的说明。
                     -d 后面接账号的家目录，即修改 /etc/passwd 的第六栏;
                     -e 后面接日期，格式是 YYYY-MM-DD 也就是在 /etc/shadow 内的第八个字段数据啦!
                     -f 后面接天数为 shadow 的第七字段。
                     -g 修改用户所在的群组，例如 usermod -g friends lion修改 lion 用户的群组为 friends 。
                     -G 一次性让用户添加多个群组，例如 usermod -G friends,foo,bar lion 。
                     -l 后面接账号名称。对用户重命名。需要注意的是 /home 中的用户家目录的名字不会改变，需要手动修改。 /etc/passwd 的第一栏!
                     -s 后面接 Shell 的实际档案，例如 /bin/bash 或 /bin/csh 等等。
                     -u 后面接 UID 数字啦!即 /etc/passwd 第三栏的资料;
                     -L 冻结密码
                     -U 解冻密码

    chfn [选项] [登录]      修改个人信息
                                        【chfn常用参数】:
                    -f, --full-name FULL_NAME     更改用户的全名
                    -h, --home-phone HOME_PHONE   更改用户的家庭电话号码
                    -o, --other OTHER_INFO        更改用户的其它 GECOS 信息
                    -r, --room ROOM_NUMBER        更改用户的房间号
                    -R, --root CHROOT_DIR         chroot 到的目录
                    -u, --help                    显示此帮助信息并推出
                    -w, --work-phone WORK_PHONE   更改用户的办公室电话号码
                      --extrausers              Use the extra users database
  
  
    su [参数] user |        切换用户，需要 root 用户权限
                                        【su常用参数】:
                    -l 切换时连同环境变量、工作目录一起改变
                    -c command 执行command变回原来的使用者
    sudo su                 切换为root用户（exit 命令或 CTRL + D 快捷键都可以使普通用户切换为 root 用户）
    su lion                 切换为普通用户
    su                      切换为root用户
      
    users               显示当前登录系统地用户
    
    id [username] |     查看用户相关的id信息，还可以用来判断用户是否存在
    
    whoami [选项]...     显示当前用户名，显示与当前的有效用户ID 相关联的用户名。与id -un 相同。
                                        【whoami常用参数】:
                    --help		显示此帮助信息并退出
                    --version		显示版本信息并退出

    • 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
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168

    2、群组的管理

        Linux 中每个用户都属于一个特定的群组，如果你不设置用户的群组，默认会创建一个和它的用户名一样的群组，并且把用户划归到这个群组。

    groupadd [-g gid] 组名 |      创建群组，用法和 useradd 类似。
                                        【groupmod常用参数】:
                    -g 设定添加组的特定组id
                            
    groupadd friends                创建一个新用户组 
    
    groupdel [groupname]            删除一个已存在的群组
    groupdel foo                    删除foo群组
    
    groups              查看用户所在群组，查看登陆用户支持的群组， 第一个输出的群组为有效群组
    groups lion         查看 lion 用户所在的群组
    
    groupmod [-g gid] [-n group_name] 群组名 |     修改组信息
                                        【groupmod常用参数】:
                    -g 修改既有的 GID 数字
                    -n 修改既有的组名
     
    gpasswd |           群组管理员功能

        root管理员动作：   
            -gpasswd groupname          设定密码 
            -gpasswd [-A user1,...] [-M user3,...] groupname  移交主控权，账号加入群组
                -A  将 groupname 的主控权交由后面的使用者管理(该群组的管理员)
                -M  将某些账号加入这个群组当中
            -gpasswd [-r] groupname     删除密码 
                -r  将 groupname 的密码移除

        群组管理员动作：
            - gpasswd [-ad] user groupname 用户加入/删除群组 
            -a  将某位使用者加入到 groupname 这个群组当中   
            -d  将某位使用者移除出 groupname 这个群组当中
                       
    groupmod -n new_group_name old_group_name      重命名一个用户组 
     
    chage -E 2005-12-31 user1       设置用户口令的失效期限 
    pwck                    检查 '/etc/passwd' 的文件格式和语法修正以及存在的用户 
    grpck                   检查 '/etc/passwd' 的文件格式和语法修正以及存在的群组 
    newgrp group_name       切换有效群组，登陆进一个新的群组以改变新创建文件的预设群组 

    chgrp                   用于修改文件的群组。

    chgrp bar file.txt      file.txt文件的群组修改为bar
    
    chown                   改变文件的所有者，需要 root 身份才能运行。
    chown lion file.txt     把其它用户创建的file.txt转让给lion用户
    chown lion:bar file.txt 把file.txt的用户改为lion，群组改为bar
                                        【chown常用参数】
                    -R 递归设置子目录和子文件， chown -R lion:lion /home/frank 把 frank 文件夹的用户和群组都改为 lion 。

    
    
    案例 1：
        #### 1-创建用户、2-追加附加组、3-删除附加组
        
        # 1
            useradd san_zhang -m
            passwd san_zhang san_zhang@163.com

        # 从管道输出中修改密码(如果非root且可以转为root，请使用sudo)
            echo san_zhang@163.com | sudo passwd --stdin san_zhang
        #-----------------------------------------------------

        
        # 2
            usermod -aG hdfs san_zhang (将san_zhang追加到附加组hdfs中(可以添加多个附加组，多个组之间用空格隔开，如"hdfs,yarn,spark")，其默认在san_zhang中)
        
            此时查看其所在的用户组，可以发现其所属组为san_zhang，附加组为hdfs，如下：
                id san_zhang
                uid=1001(san_zhang) gid=1001(san_zhang) groups=1001(san_zhang),992(hdfs)

            引申：
            如果上一步顺序写错，误将hdfs追加到san_zhang用户组中，如使用了如下错误的命令：
                usermod -aG san_zhang hdfs
            则此时查看hdfs所属组，就会发现其也在san_zhang组下了
            id hdfs
            uid=995(hdfs) gid=992(hdfs) groups=992(hdfs),994(hadoop),1001(san_zhang)

            这时再查看san_zhang组，就会看到误加入的hdfs用户了
                groups san_zhang
                san_zhang : san_zhang hdfs
        #-----------------------------------------------------
        
        
        # 3
            gpasswd -d hdfs san_zhang (从san_zhang组中删除误加入的hdfs用户)
            执行后的日志：Removing user hdfs from group san_zhang
        #-----------------------------------------------------
    
    
    
    案例 2：

        统计某个分组下有哪些用户

        [root@cdh01 ~]# grep hdfs /etc/group
        hdfs:x:993:

        [root@cdh01 ~]# awk -F : '{print $1,$4}' /etc/passwd | grep '993'
        hdfs 993

    • 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
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101

    9、磁盘空间

    df [选项] [文件] |      显示指定磁盘文件的可用空间,如果没有文件名被指定，则所有当前被挂载的文件系统的可用空间将被显示.
                                        【df常用参数】:
                    -a 显示全部文件系统
                    -h 文件大小友好显示（例如：1023M）
                    -B, --block-size=大小  使用指定字节数的块。例如，'-BM' 将以1,048,576 字节为单位显示大小。参见 SIZE 格式。
                    -H, --si        以 1000 为基底显示大小（例如，1.1G）
                    -i, --inodes	列出I-nodes的使用量
                    -k  把各分区的大小和挂上来的文件分区的大小用k表示
                    -l, --local		只显示本机的文件系统
                      --no-sync		取得使用量数据前不进行同步动作(默认)
                      --output[=域列表]      使用给定域列表定义的输出格式，
                                               或者在缺省情况下输出所有域。
                    -P, --portability     使用 POSIX 兼容的输出格式
                      --sync            取得使用量数据前先调用同步（sync）动作
                      --total           省略所有对可用空间无显著影响的项并生成总计值
                    -t, 列出某一文件系统的所有分区磁盘空间使用量
                    -T, 列出每个分区所属文件系统的名称
                    -x, 列出不是某一文件系统的所有分区磁盘空间使用量，和-t选项相反
                    -v                    （忽略）
                      --help		显示此帮助信息并退出
                      --version		显示版本信息并退出
                    
df -h                   显示已经挂载的分区列表 

du [选项] [文件] |      计算每个文件的磁盘用量，目录则取总用量。
                                        【du常用参数】:
                    -a 显示全部目录及其次目录下的每个文件所占的磁盘空间
                    -b 显示目录和文件的大小，以B为单位
                    -c 最后再加上一个总计
                    x 只计算属于同一文件系统的文件
                    -h 方便阅读的方式
                    -s 只显示总和的大小

                    
ls -lSr |more           以尺寸大小排列文件和目录 
du -sh dir1             估算目录 'dir1' 已经使用的磁盘空间' 
du -sk * | sort -rn     以容量大小为依据依次显示文件和目录的大小 
rpm -q -a --qf '%10{SIZE}t%{NAME}n' | sort -k1,1n       以大小为依据依次显示已安装的rpm包所使用的空间 (fedora, redhat类系统) 
dpkg-query -W -f='${Installed-Size;10}t${Package}n' | sort -k1,1n       以大小为依据显示已安装的deb包所使用的空间 (ubuntu, debian类系统) 

hdfs dfs -du /dw/default | sort -rn | head -n 10 | awk '{printf("%.2f\t\t%.2f\t\t%s\t\n",$1/1024/1024/1024,"\t"$2/1024/1024/1024,"\t"$3)}'          查询hdfs文件系统中表文件大小，按从大到小的顺序排列(取前10列)，单位GB

    • 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

    10、网络 -（以太网和WIFI无线）操作

    ifconfig [网络设备] [参数] |  查看和配置网络设备，查看 ip 网络相关信息，如果命令不存在的话， 执行命令 yum install net-tools 安装。
ifconfig eth0               显示一个以太网卡的配置 
ifconfig eth0 192.168.1.1 netmask 255.255.255.0     控制IP地址 
ifconfig eth0 promisc       设置 'eth0' 成混杂模式以嗅探数据包 (sniffing) 
    参数解析：
        eth0 ：对应有线连接（对应你的有线网卡），就是用网线来连接的上网。
        eth ：是 Ethernet 的缩写，表示“以太网”。有些电脑可能同时有好几条网线连着，例如服务器，那么除了eht0 ，你还会看到 eth1 、 eth2 等。
        lo ：表示本地回环（ Local Loopback 的缩写，对应一个虚拟网卡）可以看到它的 ip 地址是 127.0.0.1 。每台电脑都应该有这个接口，因为它对应着“连向自己的链接”。这也是被称之为“本地回环”的原因。所有经由这个接口发送的东西都会回到你自己的电脑。看起来好像并没有什么用，但有时为了某些缘故，我们需要连接自己。例如用来测试一个网络程序，但又不想让局域网或外网的用户查看，只能在此台主机上运行和查看所有的网络接口。例如在我们启动一个前端工程时，在浏览器输入 127.0.0.1:3000 启动项目就能查看到自己的 web 网站，并且它只有你能看到。

        wlan0 ：表示无线局域网（上面案例并未展示）。
        host：ip 地址和主机名的互相转换。

ifup eth0                   启用一个 'eth0' 网络设备 
ifdown eth0                 禁用一个 'eth0' 网络设备 

dhclient eth0               以dhcp模式启用 'eth0' 

route [-nNvee] [-FC] [] 显示和操作核心路由表
                                        【route常用参数】:
                    -v, --verbose            显示详细信息
                    -n, --numeric            不解析名称
                    -e, --extend             显示更多信息
                    -F, --fib                显示转发信息库(默认)。
                    -C, --cache              显示路由缓存而不是FIB
            
route -n show routing table 
route add -net 0/0 gw IP_Gateway            配置默认网关
route add -net 192.168.0.0 netmask 255.255.0.0 gw 192.168.1.1 configure static 
route to reach network '192.168.0.0/16'    配置静态路由以到达网络
route del 0/0 gw IP_gateway                 删除静态路由
echo "1" > /proc/sys/net/ipv4/ip_forward    激活ip路由

hostname                    显示系统的主机名
host www.example.com        查找主机名以将名称解析为ip地址，反之亦然

nslookup www.example.com    查找主机名以将名称解析为ip地址和viceversa

ip link show                显示所有接口的链接状态 

mii-tool eth0               显示“eth0”的链接状态

ethtool eth0                显示网卡“eth0”的统计信息 

设置网口子ip：
    sudo ifconfig 网口名称:1 192.168.7.2 up
    sudo ifconfig eno1:1 192.168.7.2 up

netstat (-选项)             显示与IP、TCP、UDP和ICMP协议相关的统计数据，了解Linux系统的网络情况。假设没有指定任何参数给netstat命令，则效果和指定-F参数相同。
                                        【netstat常用参数】
                    a 显示所有连线中的Socket
                    F 显示FIB
                    a 全部列出，包括正在等待的程序
                    c 持续列出网络状态
                    i 显示网络界面信息
                    n 使用网络ip地址代替名称
                    o 显示计时器
                    r 显示网络路径表
                    t 显示TCP协议的连接情形
                    u 显示UDP协议的连接情形
                    v 显示版本信息
                    w 显示RAW传输协议的连接情形

netstat -tup                显示所有活动的网络连接及其PID
netstat -tupl               显示系统上侦听的所有网络服务及其PID

telnet [参数] [主机] |      用于远程登录，采用明文传送报文，安全性不好

tcpdump tcp port 80         显示所有HTTP流量

iwlist scan                 显示无线网络
iwconfig eth1               显示无线网卡的配置 

whois www.example.com       查找whois数据库

ping [参数] [主机名或IP地址] |      测试与目标主机的连通性
                                        【ping常用参数】:
                    c 次数，设置完成要求回应的次数。ping命令会反复发出信息，直到达到设定的次数为止
                    D 使用Socket的SO_DEBUG功能
                    F 大量而且快速地送网络封包给一台机器，看它的回应。一般不到几秒钟，送出去的封包就会超过两千个。
                    I 秒数，指定收发信息的间隔时间，单位为s，预置位1s。与参数f不兼容
                    S bytes，设置数据包的大小。预设置为56B，加上8B ICMP头文件，共64B
                    R 忽略网关，直接将数据保送到远程主机上。如果该主机并非局域网的一份子，就会传回错误信息。
                    Q 不显示命令的执行过程，只显示结果
                    V 详细显示命令的执行过程，包括非回应信息和其它信息
                    T 存活数值，设置存活数值TTL的大小。TTL是IP协议包中的一个值，它告诉网络，数据包在网络中的时间是否太长而应被丢弃。

ping –c 5 –i 10 –s 504 –t 64 des.blood.net          检测des.bllod.net主机网络功能是否正常，送出去要去信息需完成5次回应，每次间隔10s，数据包的大小为512B


ftp                         用来传输文件，非常重要。如果在网络上看到一个很重要的文件，就可以用这个命令把那个文件传到自己的机器上来。
    注意：用户必须有相应的存取权限，否则不能从远程系统中获得文件或向远程系统中传输文件。为了使用ftp来传输文件，用户必须知道远程计算机上的合法用户名和口令。
                                        【ftp常用参数】:  
                    -D 详细显示命令的执行过程，便于排错和分析程序的执行情况
                    -I 关闭互动模式，不询问任何问题
                    -G 关闭本地主机文件名称支持特殊字符的扩充特征
                    -N 不适用自动登录。FTP在启动时，会尝试自动登录远端系统，它会从用户的转述目录中读取.netrc文件的内容，以便自行登录。若该文件不存在，FTP会放弃自动登录，并询问用户的账号名称
                    -V 显示命令的执行过程
ftp ftp.dark.com            用ftp登录ftp.dark.com主机

bye                         结束连线并结束程序，在ftp模式下，输入bye即可中断目前的连线作业，并结束ftp的执行，没有选项。


telnet          主要功能是进行远程登录。该命令允许用户在使用telnet协议的远程计算机之间进行通信，用户可以通过网络在远程计算机上登录，就像登录到本地机上执行命令一样。为了通过telnet登录计算机，必须知道远程计算机上的合法用户名和口令。telnet只为普通终端提供终端仿真，而不支持X Window等图形环境。
                一旦telnet成功连接到远程系统上，就显示登录信息，并提示用户输入用户名和口令。如果用户名和口令正确，就能成功登录并在远程系统上工作。用户结束了远程会话后，一定要确保使用logout命令退出远程系统。然后telnet报告远程会话被关闭，并返回到用户本地机的shell提示符下。
                
telnet 主机名或IP           标准用法格式。
telnet 140.114.63.12       登录IP地址为140.114.63.12的计算机

   
rlogin          也是用来远程登录的。它的英文含义是remote login。该命令与telnet命令很相似，允许用户启动远程系统上的交互命令会话。
rlogin (-选项) host       标准用法。
                                        【rlogin常用参数】
                    8 允许输入8位字符数据
                    e 为rlogin会话设置转义字符，默认的转义字符是“~”，用户可以指定一个文字字符或一个/nnn形式的八进制数。
                    E 停止任何转义字符。当与-8选项一起使用时，它提供一个完全透明的链接
                    l 用户名称，指定要登入远端主机的用户名称
                    L 使用litout模式进行远端登入操作
            
rlogin –l inin 140.114.125.24       登入140.114.125.24的计算机


ssh 连接远程服务器：
    1、通过非对称加密以及对称加密的方式（同 HTTPS 安全连接原理相似）连接到远端服务器。
        ssh 用户@ip:port1、ssh root@172.20.10.1:22     # 端口号可以省略不写，默认是22端口
    
    2、输入连接密码后就可以操作远端服务器了。
    
    3、配置 ssh：
        config 文件可以配置 ssh ，方便批量管理多个 ssh 连接。

        配置文件分为以下几种：

            全局 ssh 服务端的配置：/etc/ssh/sshd_config ；

            全局 ssh 客户端的配置：/etc/ssh/ssh_config（很少修改）；

            当前用户 ssh 客户端的配置：~/.ssh/config 。

                        【服务端 config 文件的常用配置参数】

                服务端 config 参数	        作用
                Port	                sshd 服务端口号（默认是22）
                PermitRootLogin	        是否允许以 root 用户身份登录（默认是可以）
                PasswordAuthentication	是否允许密码验证登录（默认是可以）
                PubkeyAuthentication	是否允许公钥验证登录（默认是可以）
                PermitEmptyPasswords	是否允许空密码登录（不安全，默认不可以）
                
                [注意] 修改完服务端配置文件需要重启服务 systemctl restart sshd


                        【客户端 config 文件的常用配置参数】

                客户端 config 参数	    作用
                Host	                别名
                HostName	            远程主机名（或 IP 地址）
                Port	                连接到远程主机的端口
                User	                用户名


                        【配置当前用户的 config文件】

                # 创建config      vim ~/.ssh/config
                # 填写一下内容
                Host lion           # 别名 HostName   
                172.x.x.x           # ip 地址  
                Port 22             # 端口  
                User root           # 用户

                这样配置完成后，下次登录时，可以这样登录 ssh lion 会自动识别为 root 用户。

                [注意] 这段配置不是在服务器上，而是你自己的机器上，它仅仅是设置了一个别名。

    
    4、免密登录：
        1、ssh 登录分两种，一种是基于口令（账号密码），另外一种是基于密钥的方式。

            基于口令，就是每次登录输入账号和密码，显然这样做是比较麻烦的，今天主要学习如何基于密钥实现免密登录。

        2、基于密钥验证原理：
            客户机生成密钥对（公钥和私钥），把公钥上传到服务器，每次登录会与服务器的公钥进行比较，这种验证登录的方法更加安全，也被称为“公钥验证登录”。

            
            具体实现步骤：
                1、在客户机中生成密钥对（公钥和私钥） 
                
                    ssh-keygen      （默认使用 RSA 非对称加密算法）

                    运行完 ssh-keygen 会在 ~/.ssh/ 目录下，生成两个文件：
                        id_rsa.pub ：公钥
                        id_rsa ：私钥

                2、把客户机的公钥传送到服务

                    执行 ssh-copy-id root@172.x.x.x
                                                    （ssh-copy-id 它会把客户机的公钥追加到服务器 ~/.ssh/authorized_keys 的文件中）。

                    
                    执行完成后，运行 ssh root@172.x.x.x 就可以实现免密登录服务器了。

            配合上面设置好的别名，直接执行 ssh lion 就可以登录，是不是非常方便。

    • 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
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200

    11、编译安装软件 :

    之前我们学会了使用 yum 命令进行软件安装，如果碰到 yum 仓库中没有的软件，我们就需要会更高级的软件安装"源码编译安装"。

    • 1

    1、编译安装

        简单来说，编译就是将程序的源代码转换成可执行文件的过程。大多数 Linux 的程序都是开放源码的，可以编译成适合我们的电脑和操纵系统属性的可执行文件。

    基本步骤如下：

        下载源代码

        解压压缩包

        配置

        编译

        安装

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

    2、实际案例

        1、下载
        我们来编译安装 htop 软件，首先在它的官网下载源码：bintray.com/htop/source…[1]

        下载好的源码在本机电脑上使用如下命令同步到服务器上：
            scp 文件名 用户名@服务器ip:目标路径
            scp ~/Desktop/htop-3.0.0.tar.gz root@121.42.11.34:.
    
        也可以使用 wegt 进行下载：
            wegt+下载地址wegt https://bintray.com/htop/source/download_file?file_path=htop-3.0.0.tar.gz
    
    
    2、解压文件
        tar -zxvf htop-3.0.0.tar.gz     # 解压
        cd htop-3.0.0                   # 进入目录
    
    3、配置
        执行 ./configure ，它会分析你的电脑去确认编译所需的工具是否都已经安装了。

    4、编译
        执行 make 命令

    5、安装
        执行 make install 命令，安装完成后执行 ls /usr/local/bin/ 查看是否有 htop 命令。如果有就可以执行 htop 命令查看系统进程了。

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

    12、JPS工具

    JPS(Java Virtual Machine Process Status Tool)是JDK 1.5提供的一个显示当前所有java进程pid的命令，简单实用，非常适合在linux/unix平台上简单察看当前java进程的一些简单情况。

我想很多人都是用过unix系统里的ps命令，这个命令主要是用来显示当前系统的进程情况，有哪些进程，及其 id。 jps 也是一样，它的作用是显示当前系统的java进程情况，及其id号。我们可以通过它来查看我们到底启动了几个java进程（因为每一个java程序都会独占一个java虚拟机实例），和他们的进程号（为下面几个程序做准备），并可通过opt来查看这些进程的详细启动参数。

 使用方法：在当前命令行下打 jps(需要JAVA_HOME，没有的话，到改程序的目录下打) 。

jps存放在JAVA_HOME/bin/jps，使用时为了方便请将JAVA_HOME/bin/加入到Path.

    $> jps
    23991 Jps
    23789 BossMain
    23651 Resin

                                        【jps常用参数】

                    -q 只显示pid，不显示class名称,jar文件名和传递给main 方法的参数：
                        $>  jps -q
                        28680
                        23789
                        23651

                    -m 输出传递给main 方法的参数，在嵌入式jvm上可能是null：
                        $> jps -m
                        28715 Jps -m
                        23789 BossMain
                        23651 Resin -socketwait 32768 -stdout /data/aoxj/resin/log/stdout.log -stderr /data/aoxj/resin/log/stderr.log

                    -l 输出应用程序main class的完整package名 或者 应用程序的jar文件完整路径名：
                        $> jps -l
                        28729 sun.tools.jps.Jps
                        23789 com.asiainfo.aimc.bossbi.BossMain
                        23651 com.caucho.server.resin.Resin

                    
                    -v 输出传递给JVM的参数

                        $> jps -v
                        23789 BossMain
                        28802 Jps -Denv.class.path=/data/aoxj/bossbi/twsecurity/java/trustwork140.jar:/data/aoxj/bossbi/twsecurity/java/:/data/aoxj/bossbi/twsecurity/java/twcmcc.jar:/data/aoxj/jdk15/lib/rt.jar:/data/aoxj/jd

                        k15/lib/tools.jar -Dapplication.home=/data/aoxj/jdk15 -Xms8m
                        23651 Resin -Xss1m -Dresin.home=/data/aoxj/resin -Dserver.root=/data/aoxj/resin -Djava.util.logging.manager=com.caucho.log.LogManagerImpl - Djavax.management.builder.initial=com.caucho.jmx.MBeanServerBuilderImpl

        
sudo jps看到的进程数量最全：

jps 192.168.0.77
    列出远程服务器192.168.0.77机器所有的jvm实例，采用rmi协议，默认连接端口为1099（前提是远程服务器提供jstatd服务）

注：jps命令有个地方很不好，似乎只能显示当前用户的java进程，要显示其他用户的还是只能用unix/linux的ps命令。

详细情况请参考sun官方文档。
    http://java.sun.com/j2se/1.7.0/docs/tooldocs/share/jps.html

GO TOP INDEX ^ 
Microsoft Windows networks (SAMBA) 
nbtscan ip_addr netbios name resolution 
nmblookup -A ip_addr netbios name resolution 
smbclient -L ip_addr/hostname show remote shares of a windows host 
smbget -Rr smb://ip_addr/share like wget can download files from a host windows via smb 
mount -t smbfs -o username=user,password=pass //WinClient/share /mnt/share mount a windows network share

-b file            若文件存在且是一个块特殊文件，则为真
-c file            若文件存在且是一个字符特殊文件，则为真
-d file            若文件存在且是一个目录，则为真
-e file            若文件存在，则为真
-f file            若文件存在且是一个规则文件，则为真
-g file            若文件存在且设置了SGID位的值，则为真
-h file            若文件存在且为一个符合链接，则为真
-k file            若文件存在且设置了"sticky"位的值
-p file            若文件存在且为一已命名管道，则为真
-r file            若文件存在且可读，则为真
-s file            若文件存在且其大小大于零，则为真
-u file            若文件存在且设置了SUID位，则为真
-w file            若文件存在且可写，则为真
-x file            若文件存在且可执行，则为真
-o file            若文件存在且被有效用户ID所拥有，则为真

-z string          若string长度为0，则为真
-n string          若string长度不为0，则为真
string1 = string2  若两个字符串相等，则为真
string1 != string2 若两个字符串不相等，则为真

int1 -eq int2      若int1等于int2，则为真
int1 -ne int2      若int1不等于int2，则为真
int1 -lt int2      若int1小于int2，则为真
int1 -le int2      若int1小于等于int2，则为真
int1 -gt int2      若int1大于int2，则为真
int1 -ge int2      若int1大于等于int2，则为真

!expr              若expr为假则复合表达式为真。expr可以是任何有效的测试表达式
expr1 -a expr2     若expr1和expr2都为真则整式为真
expr1 -o expr2     若expr1和expr2有一个为真则整式为真

特殊变量

$0                 正在被执行命令的名字。对于shell脚本而言，这是被激活命令的路径
$n                 该变量与脚本被激活时所带的参数相对应。n是正整数，与参数位置相对应($1,$2…)
$#                 提供脚本的参数号
$*                 所有这些参数都被双引号引住。若一个脚本接收两个参数，$*等于$1$2
$@                 所有这些参数都分别被双引号引住。若一个脚本接收到两个参数，$@等价于$1$2
$?                 前一个命令执行后的退出状态, 常用于判断上一个命令的执行结果, 以辅助判断下游分支逻辑的执行
$$                 当前shell的进程号。对于shell脚本，这是其正在执行时的进程ID
$!                 前一个后台命令的进程号

    • 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
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104

    13、crontab 定时任务调度器:

    1、①、语法
    Linux下的任务调度分为两类：系统任务调度和用户任务调度。
                                        【crontab常用参数】    
                    file 载入crontab
                    -e 编辑某个用户的crontab文件内容
                    -l 显示某个用户的crontab文件内容
                    -r 删除某个用户的crontab文件
        
2、Linux系统任务是由 cron (crond) 这个系统服务来控制的，这个系统服务是默认启动的。用户自己设置的计划任务则使用crontab 命令。在CentOS系统中：

    cat /etc/crontab

    SHELL=/bin/bash
    PATH=/sbin:/bin:/usr/sbin:/usr/bin
    MAILTO=root
    HOME=/
    # For details see man 4 crontabs
    # Example of job definition:
    # .---------------- minute (0 - 59)
    # | .------------- hour (0 - 23)
    # | | .---------- day of month (1 - 31)
    # | | | .------- month (1 - 12) OR jan,feb,mar,apr ...
    # | | | | .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat
    # | | | | |
    # * * * * * user-name command to be executed

    前四行是用来配置crond任务运行的环境变量:
                    》第一行SHELL变量指定了系统要使用哪个shell，这里是bash；
                    》第二行PATH变量指定了系统执行命令的路径；
                    》第三行MAILTO变量指定了crond的任务执行信息将通过电子邮件发送给root用户，如果MAILTO变量的值为空，则表示不发送任务执行信息给用户；
                    》第四行的HOME变量指定了在执行命令或者脚本时使用的主目录。

3、用户定期要执行的工作，比如用户数据备份、定时邮件提醒等。用户可以使用 crontab 工具来定制自己的计划任务。所有用户定义的crontab 文件都被保存在 /var/spool/cron目录中。其文件名与用户名一致。


4、用户所建立的crontab文件中，每一行都代表一项任务，每行的每个字段代表一项设置，它的格式共分为六个字段：
        》前五段是时间设定段；
        》第六段是要执行的命令段

    crontab表达式 格式如下：
    minute hour day month week command

    crontab用法与实例crontab用法与实例

5、在以上各个字段中，还可以使用以下特殊字符：

    "*"代表所有的取值范围内的数字，如月份字段为*，则表示1到12个月；
    "/"代表每一定时间间隔的意思，如分钟字段为*/10，表示每10分钟执行1次。
    "-"代表从某个区间范围，是闭区间。如“2-5”表示“2,3,4,5”，小时字段中0-23/2表示在0~23点范围内每2个小时执行一次。
    ","分散的数字（不一定连续），如1,2,3,4,7,9。
    注：由于各个地方每周第一天不一样，因此Sunday=0（第一天）或Sunday=7（最后1天）。


6、case: 每隔2分钟,删除指定目录下,创建时间超过10个小时的文件

    */2 * * * * /bin/sh -c "find /tmp/hadoop-hdfs/mapred/local -cmin +600 -type d -exec rm -rf {} \;" >> /var/lib/hadoop-hdfs/auto_remove_mr_output.out

    • 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

    14、vim 编辑器专题

    1、Vim 是什么？

        Vim 是从 vi 发展出来的一个文本编辑器。其代码补全、编译及错误跳转等方便编程的功能特别丰富，在程序员中被广泛使用。和 Emacs 并列成为类 Unix 系统用户最喜欢的编辑器。

    • 1

    2、Vim 常用模式：

        交互模式

    插入模式

    命令模式

    可视模式


    1、交互模式
        也称为正常模式，这是 Vim 的默认模式，每次运行 Vim 程序的时候，就会进入这个模式。

        例如执行 vim name.txt 则会进入交互模式。

        交互模式特征：
            在这个模式下，你不能输入文本；
            它可以让我们在文本间移动，删除一行文本，复制黏贴文本，跳转到指定行，撤销操作，等等。

    
    2、插入模式
        这个模式是我们熟悉的文本编辑器的模式，就是可以输入任何你想输入的内容。进入这个模式有几种方法，最常用的方法是按字母键 i （ i、I、a、A、o、O 都可以进入插入模式，只是所处的位置不同），退出这种模式，只需要按下 Esc 键。

        i, I 进入输入模式 Insert mode ：i 为“从目前光标所在处输入”， I 为“在目前所在行的第一个非空格符处开始输入”；

        a, A 进入输入模式 Insert mode ：a 为“从目前光标所在的下一个字符处开始输入”，A 为“从光标所在行的最后一个字符处开始输入”；

        o, O 进入输入模式 Insert mode ：o 为“在目前光标所在的下一行处输入新的一行”；O 为在目前光标所在处的上一行输入新的一行。


    3、命令模式
        命令模式也称为底线命令模式，这个模式下可以运行一些命令例如“退出”，“保存”，等动作。
        也可以用这个模式来激活一些 Vim 配置，例如语法高亮，显示行号，等。甚至还可以发送一些命令给终端命令行，例如 ls、cp 。

        为了进入命令模式，首先要进入交互模式：再按下冒号键。
        
        从插入模式切换为命令行模式：按「ESC」键。
        
            :w filename 将文章以指定的文件名保存起来  
            :wq 保存并退出 
            :q! 不保存而强制退出

    • 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

    3、基本操作

        1、打开 Vim
        在终端命令行中输入 vim 回车后 Vim 就会被运行起来，也可以用 Vim 来打开一个文件，只需要在 vim 后面再加文件名。如 vim file.name ，如果文件不存在，那么会被创建。

    2、插入
        进入文件之后，此时处于交互模式，可以通过输入 i 进入插入模式。

    3、移动
        在 Vim 的交互模式下，我们可以在文本中移动光标。

        h 向左移动一个字符
        j 向下移动一个字符
        k 向上移动一个字符
        l 向右移动一个字符
        
        按「ctrl」+「b」：屏幕往 "后" 移动一页。
        按「ctrl」+「f」：屏幕往 "前" 移动一页。
        按「ctrl」+「u」：屏幕往 "后" 移动半页。
        按「ctrl」+「d」：屏幕往 "前" 移动半页。
    　　
    　　按数字「 0 」：移到文章的开头。
    　　按「G」：移动到文章的最后。
    　　按「$」：移动到光标所在行的 "行尾" 。
    　　按「^」：移动到光标所在行的 "行首"
    　　按「w」：光标跳到下个字的开头
    　　按「e」：光标跳到下个字的字尾
    　　按「b」：光标回到上个字的开头
    　　按「#l」：光标移到该行的第#个位置，如：5l,56l。
    　　
        当然也可以使用四个方向键进行移动，效果是一样的。



    4、跳至行首和行末
        行首：在交互模式下，为了将光标定位到一行的开始位置，只需要按下数字键 0 即可，键盘上的 Home 键也有相同效果。

        行末：在交互模式下，为了将光标定位到一行的末尾，只需要按下美元符号键 $ 即可，键盘上的 End 键也有相同效果。

    5、按单词移动
        在交互模式下，按字母键 w 可以一个单词一个单词的移动。

    6、退出文件
        在交互模式下，按下冒号键 : 进入命令模式，再按下 q 键，就可以退出了。

        如果在退出之前又修改了文件，就直接想用 :q 退出 Vim ，那么 Vim 会显示一个红字标明错误信息。此时我们有两个选择：

            保存并退出 :wq 或 :x ；

            不保存且强制退出 :q! 。

    • 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

    4、标准操作：

        1、删除字符
        1、在交互模式下，将光标定位到一个你想要删除的字符上，按下字母键 x 你会发现这个字符被删除了。
                                「x」：每按一次，删除光标所在位置的 "后面" 一个字符。
                                「X」：大写的X，每按一次，删除光标所在位置的 "前面" 一个字符。
     　　
        2、也可以一次性删除多个字符，只需要在按 x 键之前输入数字即可。
                                「#x」：例如，「6x」表示删除光标所在位置的 "后面" 6 个字符。
                                「#X」：例如，「20X」表示删除光标所在位置的 "前面" 20 个字符。
                                
        3、删除（剪切）单词，行
            删除一行：连按两次 d 来删除光标所在的那一行。
                                「dd」：删除光标所在行。
                    
            删除多行：例如先输入数字 2 ，再按下 dd ，就会删除从光标所在行开始的两行。
                                「#dd」：从光标所在行开始删除#行

            删除一个单词：将光标置于一个单词的首字母处，然后按下 dw 。

            删除多个单词：例如先按数字键 2 再按 dw 就可以删除两个单词了。

        4、从光标所在位置删除至行首：d0 。

            从光标所在位置删除至行末：d$ 。


    2、复制单词，行
        复制行：按两次 y 会把光标所在行复制到内存中，和 dd 类似， dd 用于“剪切”光标所在行。
                            「yy」：复制光标所在行到缓冲区。
                            「#yy」：例如，「6yy」表示拷贝从光标所在的该行 "往下数" 6 行文字。

        复制单词：yw 会复制一个单词。
                            「yw」：将光标所在之处到字尾的字符复制到缓冲区中。
                            「#yw」：复制#个字到缓冲区
        
        复制到行末：y$ 是复制从光标所在处到行末的所有字符。

        复制到行首：y0 是复制光标所在处到行首的所有字符。

        
        粘贴
            如果之前用 dd 或者 yy 剪切复制过来的，可以使用 p 来粘贴。同样也可以使用 数字+p来表示复制多次。
                            「p」：将缓冲区内的字符贴到光标所在位置。注意：所有与 "y" 有关的复制命令都必须与 "p" 配合才能完成复制与粘贴功能。


    3、替换一个字符
        在交互模式下，将光标置于想要替换的字符上。按下 r 键，接着输入你要替换的字符即可。
                        「r」：替换光标所在处的字符。
     　　「R」：替换光标所到之处的字符，直到按下「ESC」键为止。

    4、撤销操作
        如果要撤销最近的修改，只需要按下 u 键，如果想要撤销最近四次修改，可以按下4，再按下 u 。
                        「u」：如果您误执行一个命令，可以马上按下「u」，回到上一个操作。按多次 "u" 可以执行多次回复。

    5、重做
        取消撤销，也就是重做之前的修改使用 ctrl + r 。
        
    6、更改
                    「cw」：更改光标所在处的字到字尾处
                    「c#w」：例如，「c3w」表示更改 3 个字

    7、跳转到指定行
        Vim 编辑的文件中，每一行都有一个行号，行号从1开始，逐一递增。
        
        跳转到指定行：数字+gg ，例如 7gg ，表示跳转到第7行。

        要跳转到最后一行，按下 G 。

        要跳转到第一行，按下 gg 。
        
                    「  ctrl」+「g」列出光标所在行的行号。
       
                    「#G」：例如，「15G」，表示移动光标至文章的第 15 行行首。
        
        
    8、行号默认是不显示，如果需要它显示的话，可以进入命令模式，然后输入 set nu ，如果要隐藏行号的话，使用 set nonu 。

    • 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

    5、高级操作

        1、查找
        处于交互模式下，按下 / 键，那么就进入查找模式，输入你要查找的字符串，然后按下回车。光标就会跳转到文件中下一个查找到的匹配处。如果字符串不存在，那么会显示 "pattern not found" 。

        n 跳转到下一个匹配项；

        N 跳转到上一个匹配项。

        [注意] 用斜杠来进行的查找是从当前光标处开始向文件尾搜索，如果你要从当前光标处开始，向文件头搜索则使用 ? ，当然也可以先按下 gg 跳转到第一行在进行全文搜索。

    2、查找并替换
        替换光标所在行第一个匹配的字符串：
            # 语法:s/旧字符串/新字符串
            # 实例:s/one/two

        替换光标所在行所有旧字符串为新字符串：
            # 语法:s/旧字符串/新字符串/g

        替换第几行到第几行中所有字符串：
            # 语法:n,m s/旧字符串/新字符串/g
            # 实例:2,4 s/one/two/g

        最常用的就是全文替换了：
            # 语法:%s/旧字符串/新字符串/g
    
    3、合并文件
        可以用冒号 +r ( :r ) 实现在光标处插入一个文件的内容。

        :r filename     # 可以用Tab键来自动补全另外一个文件的路径

    4、分屏
        Vim 有一个特别便捷的功能那就是分屏，可以同时打开好几个文件，分屏之后，屏幕每一块被称为一个 viewport ，表示“视口”。

        横向分屏 :sp 文件名

        垂直分屏 :vsp 文件名

        分屏模式下的快捷键：
            Ctrl + w 再加 Ctrl + w ，表示从一个 viewport 移动光标到另外一个 viewport ；
            Ctrl + w 再加 “方向键”，就可以移动到这个方向所处的下一个视口了；

            Ctrl + w 再加 + 号，表示扩大当前视口；

            Ctrl + w 再加 - 号，表示缩小当前视口；

            Ctrl + w 再加 = 号，表示平均当前视口；

            Ctrl + w 再加 r 键，会反向调换视口位置；

            Ctrl + w 再加 q 键，会关闭当前视口；

            Ctrl + w 再加 o 键，会关闭除当前视口以外的所有视口；

    5、运行外部命令 :!
        在 Vim 中可以运行一些终端命令，只要先输入 :! ，然后接命令名称。

        例如：
            :!ls        # 在Vim中打开的文件所在的目录运行ls命令

    6、可视模式
        前面只讲了 Vim 的三种模式，其实还有一种模式叫做可视模式。

        1、进入它的三种方式（都是从交互模式开始）：
            v 字符可视模式，进入后配合方向键选中字符后，然后再按 d 键可以删除选中。

            V 行可视模式，进入后光标所在行默认被选中，然后再按 d 键可以删除所在行。

            Ctrl + v 块可视模式，它是可视模式最有用的功能了，配合 d 和 I 键可以实现删除选中的内容和插入内容。

        2、同时选中多行，并在选中行头部插入内容的具体操作步骤：

            1. ctrl + v 进入块可视模式
            2. 使用方向键进行选中（上下左右）假设选中5行
            3. 输入 I 键进行多行同时插入操作
            4. 插入完成后连续按两下 esc 键，实现多行同时插入相同字符

        3、进入可视模式之后的操作键：

            d 键，表示删除选中；

            I 键，表示在选中之前插入；

            u 键，表示选中变为小写；

            U 键，表示选中变为大写；

    • 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

    6、Vim 配置

        选项参数
    在 Vim 被启动后，可以运行一些指令来激活一些选项参数，但是这些选项参数的配置在退出Vim 时会被忘记，例如前面讲解的激活行号。如果希望所在的配置是永久性的，那么需要在家目录（ cd ~ ）创建一个 Vim 的配置文件 .vimrc 。

        .vimrc
        set number "        显示行号
        syntax on "         激活语法高亮
        set showcmd "       实时看到输入的命令
        set ignorecase "    搜索时不区分大小写
        set mouse=a "       激活鼠标，用鼠标选中时相当于进入可视模式

    
    Vim 配置非常丰富，我们可以通过个性化配置把 Vim 打造成属于自己的 IDE 等等。在 github 上也可以搜索到一些强大的 Vim 配置文件。









①、大小写转换
    gu或者gU
    
    形象一点的解释就是小u意味着转为小写；大U意味着转为大写.

    剩下的就是对这两个命令的限定（限定操作的行，字母，单词）等等

    1、整篇文章大写转化为小写
      打开文件后，无须进入命令行模式。键入:ggguG
      解释一下：ggguG分作三段gg gu G
                gg=光标到文件第一个字符
                gu=把选定范围全部小写
                G=到文件结束

    2、整篇文章小写转化为大写
        打开文件后，无须进入命令行模式。键入:gggUG

        解释一下：gggUG分作三段gg gU G
        gg=光标到文件第一个字符
        gU=把选定范围全部大写
        G=到文件结束
        
    3、只转化某个单词
        guw 、gue
        gUw、gUe
        
        这样，光标后面的单词便会进行大小写转换
        想转换5个单词的命令如下：
        gu5w、gu5e
        gU5w、gU5e
        
    4、转换几行的大小写
        将光标定位到想转换的行上，键入：1gU 从光标所在行 往下一行都进行小写到大写的转换
        10gU，则进行11行小写到大写的转换
        以此类推，就出现其他的大小写转换命令
        gU0        ：从光标所在位置到行首，都变为大写
        gU$        ：从光标所在位置到行尾，都变为大写
        gUG        ：从光标所在位置到文章最后一个字符，都变为大写
        gU1G      ：从光标所在位置到文章第一个字符，都变为大写




②、字符串处理专题
    总结:

        掐头(删左侧: 
            ①#:删左侧;
            ②##:贪婪删左侧)
        
        去尾(删右侧: 
            ①%:删右边;
            ②%%:贪婪删右侧)

    1、linux shell 字符串操作详解 （长度，读取，替换，截取，连接，对比，删除，位置 ）
        1.Linux shell 截取字符变量的前8位

            实现方法有如下几种：


            expr substr “$a” 1 8
            echo $a|awk ‘{print substr(,1,8)}’
            echo $a|cut -c1-8
            echo $
            expr $a : ‘\(.\\).*’
            echo $a|dd bs=1 count=8 2>/dev/null
             

        2.按指定的字符串截取

            (1)第一种方法:

                从左向右截取最后一个string后的字符串
                ${varible##*string}
                从左向右截取第一个string后的字符串
                ${varible#*string}
                从右向左截取最后一个string后的字符串
                ${varible%%string*}
                从右向左截取第一个string后的字符串
                ${varible%string*}
                “*”只是一个通配符可以不要

                请看下面的例子：


                $ MYVAR=foodforthought.jpg
                $ echo ${MYVAR##*fo}
                rthought.jpg
                $ echo ${MYVAR#*fo}
                odforthought.jpg

            (2)第二种方法：

                ${varible:n1:n2}:截取变量varible从n1开始的n2个字符，组成一个子字符串。可以根据特定字符偏移和长度，使用另一种形式的变量扩展，来选择特定子字符串。试着在 bash 中输入以下行：


                $ EXCLAIM=cowabunga
                $ echo ${EXCLAIM:0:3}
                cow
                $ echo ${EXCLAIM:3:7}
                abunga

                这种形式的字符串截断非常简便，只需用冒号分开来指定起始字符和子字符串长度。


        3.按照指定要求分割：

            比如获取后缀名

            ls -al | cut -d “.” -f2
            小结：shell对应字符串的处理方法很多，根据需求灵活选择。

             

            在做shell批处理程序时候，经常会涉及到字符串相关操作。有很多命令语句，如：awk,sed都可以做字符串各种操作。 其实shell内置一系列操作符号，可以达到类似效果，大家知道，使用内部操作符会省略启动外部程序等时间，因此速度会非常的快。

             

            一、判断读取字符串值

                表达式                     含义
                ${var}	        变量var的值, 与$var相同
                 	 
                ${var-DEFAULT}	如果var没有被声明, 那么就以$DEFAULT作为其值 *
                ${var:-DEFAULT}	如果var没有被声明, 或者其值为空, 那么就以$DEFAULT作为其值 *
                 	 
                ${var=DEFAULT}	如果var没有被声明, 那么就以$DEFAULT作为其值 *
                ${var:=DEFAULT}	如果var没有被声明, 或者其值为空, 那么就以$DEFAULT作为其值 *
                 	 
                ${var+OTHER}	如果var声明了, 那么其值就是$OTHER, 否则就为null字符串
                ${var:+OTHER}	如果var被设置了, 那么其值就是$OTHER, 否则就为null字符串
                 	 
                ${var?ERR_MSG}	如果var没被声明, 那么就打印$ERR_MSG *
                ${var:?ERR_MSG}	如果var没被设置, 那么就打印$ERR_MSG *
                 	 
                ${!varprefix*}	匹配之前所有以varprefix开头进行声明的变量
                ${!varprefix@}	匹配之前所有以varprefix开头进行声明的变量
                
                加入了“*”  不是意思是： 当然, 如果变量var已经被设置的话, 那么其值就是$var.

             

             

            二、字符串操作（长度，读取，替换）

                表达式                     含义
                ${#string}	                $string的长度
                 	 
                ${string:position}	        在$string中, 从位置$position开始提取子串
                ${string:position:length}	在$string中, 从位置$position开始提取长度为$length的子串
                 	 
                ${string#substring}	从变量$string的开头, 删除最短匹配$substring的子串
                ${string##substring}	从变量$string的开头, 删除最长匹配$substring的子串
                ${string%substring}	从变量$string的结尾, 删除最短匹配$substring的子串
                ${string%%substring}	从变量$string的结尾, 删除最长匹配$substring的子串
                 	 
                ${string/substring/replacement}	使用$replacement, 来代替第一个匹配的$substring
                ${string//substring/replacement}	使用$replacement, 代替所有匹配的$substring
                ${string/#substring/replacement}	如果$string的前缀匹配$substring, 那么就用$replacement来代替匹配到的$substring
                ${string/%substring/replacement}	如果$string的后缀匹配$substring, 那么就用$replacement来代替匹配到的$substring
                 	 
                
                说明："* $substring”可以是一个正则表达式.

             

             实例：

             

            读取：

                $ echo ${abc-'ok'}  
                ok  
                $ echo $abc  
                $ echo ${abc='ok'}  
                ok  
                $ echo $abc  
                ok  
                  
                #如果abc 没有声明“=" 还会给abc赋值。  
                $ var1=11;var2=12;var3=  
                $ echo ${!v@}             
                var1 var2 var3  
                $ echo ${!v*}  
                var1 var2 var3  
                  
                #${!varprefix*}与${!varprefix@}相似，可以通过变量名前缀字符，搜索已经定义的变量,无论是否为空值。  
             

            1，取得字符串长度

                string=abc12342341          //等号二边不要有空格  
                echo ${#string}             //结果11  
                expr length $string         //结果11  
                expr "$string" : ".*"       //结果11 分号二边要有空格,这里的:根match的用法差不多  
             
             2，字符串所在位置

                expr index $string '123'    //结果4 字符串对应的下标是从1开始的   
                 
                str="abc"  
                expr index $str "a"  # 1  
                expr index $str "b"  # 2  
                expr index $str "x"  # 0  
                expr index $str ""   # 0   
                 

                这个方法让我想起来了js的indexOf，各种语言对字符串的操作方法大方向都差不多，如果有语言基础的话，学习shell会很快的。

                 

            3，从字符串开头到子串的最大长度

                expr match $string 'abc.*3' //结果9    
                 
                个人觉得这个函数的用处不大，为什么要从开头开始呢。

         

        4，字符串截取

            echo ${string:4}      //2342341  从第4位开始截取后面所有字符串    
            echo ${string:3:3}    //123      从第3位开始截取后面3位    
            echo ${string:3:6}    //123423   从第3位开始截取后面6位    
            echo ${string: -4}    //2341  ：右边有空格   截取后4位    
            echo ${string:(-4)}   //2341  同上    
            expr substr $string 3 3   //123  从第3位开始截取后面3位    
             

            str="abcdef"  
            expr substr "$str" 1 3  # 从第一个位置开始取3个字符， abc  
            expr substr "$str" 2 5  # 从第二个位置开始取5个字符， bcdef   
            expr substr "$str" 4 5  # 从第四个位置开始取5个字符， def  
              
            echo ${str:2}           # 从第二个位置开始提取字符串， bcdef  
            echo ${str:2:3}         # 从第二个位置开始提取3个字符, bcd  
            echo ${str:(-6):5}        # 从倒数第二个位置向左提取字符串, abcde  
            echo ${str:(-4):3}      # 从倒数第二个位置向左提取6个字符, cde  
             

            上面的方法让我想起了，php的substr函数，后面截取的规则是一样的。

         

        5，匹配显示内容

            //例3中也有match和这里的match不同，上面显示的是匹配字符的长度，而下面的是匹配的内容    
            expr match $string '\([a-c]*[0-9]*\)'  //abc12342341    
            expr $string : '\([a-c]*[0-9]\)'       //abc1    
            expr $string : '.*\([0-9][0-9][0-9]\)' //341 显示括号中匹配的内容    
             

            这里括号的用法，是不是根其他的括号用法有相似之处呢，

             

        6，截取不匹配的内容

            echo ${string#a*3}     //42341  从$string左边开始，去掉最短匹配子串    
            echo ${string#c*3}     //abc12342341  这样什么也没有匹配到    
            echo ${string#*c1*3}   //42341  从$string左边开始，去掉最短匹配子串    
            echo ${string##a*3}    //41     从$string左边开始，去掉最长匹配子串    
            echo ${string%3*1}     //abc12342  从$string右边开始，去掉最短匹配子串    
            echo ${string%%3*1}    //abc12     从$string右边开始，去掉最长匹配子串    
             
            str="abbc,def,ghi,abcjkl"  
            echo ${str#a*c}     # 输出,def,ghi,abcjkl  一个井号(#) 表示从左边截取掉最短的匹配 (这里把abbc字串去掉）  
            echo ${str##a*c}    # 输出jkl，             两个井号(##) 表示从左边截取掉最长的匹配 (这里把abbc,def,ghi,abc字串去掉)  
            echo ${str#"a*c"}   # 输出abbc,def,ghi,abcjkl 因为str中没有"a*c"子串  
            echo ${str##"a*c"}  # 输出abbc,def,ghi,abcjkl 同理  
            echo ${str#*a*c*}   # 空  
            echo ${str##*a*c*}  # 空  
            echo ${str#d*f)     # 输出abbc,def,ghi,abcjkl,   
            echo ${str#*d*f}    # 输出,ghi,abcjkl     
              
            echo ${str%a*l}     # abbc,def,ghi  一个百分号(%)表示从右边截取最短的匹配   
            echo ${str%%b*l}    # a             两个百分号表示(%%)表示从右边截取最长的匹配  
            echo ${str%a*c}     # abbc,def,ghi,abcjkl    
             
            这里要注意，必须从字符串的第一个字符开始，或者从最后一个开始，可以这样记忆, 井号（#）通常用于表示一个数字，它是放在前面的；百分号（%）卸载数字的后面; 或者这样记忆，在键盘布局中，井号(#)总是位于百分号（%）的左边(即前面)  。

         

        7，匹配并且替换

            echo ${string/23/bb}   //abc1bb42341  替换一次    
            echo ${string//23/bb}  //abc1bb4bb41  双斜杠替换所有匹配    
            echo ${string/#abc/bb} //bb12342341   #以什么开头来匹配，根php中的^有点像    
            echo ${string/%41/bb}  //abc123423bb  %以什么结尾来匹配，根php中的$有点像   
             

            str="apple, tree, apple tree"  
            echo ${str/apple/APPLE}   # 替换第一次出现的apple  
            echo ${str//apple/APPLE}  # 替换所有apple  
              
            echo ${str/#apple/APPLE}  # 如果字符串str以apple开头，则用APPLE替换它  
            echo ${str/%apple/APPLE}  # 如果字符串str以apple结尾，则用APPLE替换它  
             
            $ test='c:/windows/boot.ini'  
            $ echo ${test/\//\\}  
            c:\windows/boot.ini  
            $ echo ${test//\//\\}  
            c:\windows\boot.ini  
              
            #${变量/查找/替换值} 一个“/”表示替换第一个，”//”表示替换所有,当查找中出现了：”/”请加转义符”\/”表示。  
             
        8. 比较

            [[ "a.txt" == a* ]]        # 逻辑真 (pattern matching)  
            [[ "a.txt" =~ .*\.txt ]]   # 逻辑真 (regex matching)  
            [[ "abc" == "abc" ]]       # 逻辑真 (string comparision)   
            [[ "11" < "2" ]]           # 逻辑真 (string comparision), 按ascii值比较  
         
        9. 连接

            s1="hello"  
            s2="world"  
            echo ${s1}${s2}   # 当然这样写 $s1$s2 也行，但最好加上大括号  
         
        10. 字符串删除
            $ test='c:/windows/boot.ini'  
            $ echo ${test#/}  
            c:/windows/boot.ini  
            $ echo ${test#*/}  
            windows/boot.ini  
            $ echo ${test##*/}  
            boot.ini  
              
            $ echo ${test%/*} 
            c:/windows 
            $ echo ${test%%/*} 
             
            #${变量名#substring正则表达式}从字符串开头开始配备substring,删除匹配上的表达式。 */
            #${变量名%substring正则表达式}从字符串结尾开始配备substring,删除匹配上的表达式。 
            #注意：${test##*/},${test%/*} 分别是得到文件名，或者目录地址最简单方法。 



    2、Linux Bash Shell字符串截取
        #!/bin/bash
            #定义变量赋值时等号两边不能有空格，否则会报命令不存在  

        # 运行shell脚本两种方式
            # 1、作为解释参数 /bin/sh test.sh ;  
            2、作为可执行文件 chmod +x ./test.sh blog_url='http://www.cnblogs.com/Bighua/p/7535900.html'
        
        
        # 1、 #号截取，从左往右删除从0开始到第一个匹配条件('//')部分，保留剩下部分
            echo ${blog_url#*//}
            
            #运行结果*/ 如下  www.cnblogs.com/Bighua/p/7535900.html

        
        #2、  ##号截取，从左往右删除从0开始到最后一个匹配条件('/')部分，保留剩下部分
            echo ${blog_url##*/}
            #运行结果如下  7535900.html

        
        #3、 %号截取，从右往左删除从#blog_url开始到第一个匹配条件('/')部分，保留剩下部分
            echo ${blog_url%/*}
            # 运行结果如下*/ http://www.cnblogs.com/Bighua/p

        #4、 %%号截取，从右往左删除从#blog_url开始到最后一个匹配条件('/')部分,保留剩下部分
            echo ${blog_url%%/*}
            # 运行结果如下*/ http:

        #5、从左边第几个开始截取几个字符
            echo ${blog_url:0:7}
            # 运行结果如下 http://

        #6、从左边第几个字符开始到结束
            echo ${blog_url:7}
            # 运行结果如下 www.cnblogs.com/Bighua/p/7535900.html

        #7、从右边起数第几个字符为起点，从左往右截取几个字符
            echo ${blog_url:0-7:2}
            # 运行结果如下 00

        #8、从右起第几个字符开始为起点，一直到结尾
            echo ${blog_url:0-4}
            # 运行结果 html 



    3、Shell 截取字符串
        shell中截取字符串的方法很多

            ${var#*/}
            ${var##*/}
            ${var%/*}
            ${var%%/*}
            ${var:start:len}
            ${var:start}
            ${var:0-start:len}
            ${var:0-start}


        下面用几个例子展示一下*/：

            1) 获得字符串的长度
                语法：
                    ${#var}
             
                示例代码：

                    str="http://www.fengbohello.xin3e.com/blog/shell-truncating-string"
                    echo "string : [${str}]"

                    length=${#str}
                    echo "length : [${length}]"
             

                执行结果：

                    string : [http://www.fengbohello.xin3e.com/blog/shell-truncating-string]
                    length : [61]
             

            2) 使用 # 和 ## 获取尾部子字符串
                2.1) # 最小限度从前面截取word
                    语法：
                        ${parameter#word}  


                    示例代码：

                        str="http://www.fengbohello.xin3e.com/blog/shell-truncating-string"
                        echo "string : [${str}]"

                        #分割符为'/'
                        substr=${str#*/}
                        echo "substr : [${substr}]"

                    执行结果：

                        string : [http://www.fengbohello.xin3e.com/blog/shell-truncating-string]
                        substr : [/www.fengbohello.xin3e.com/blog/shell-truncating-string]


                2.2) ## 最大限度从前面截取word
                    语法：
                        ${parameter##word}
                     

                    示例代码：
                        str="http://www.fengbohello.xin3e.com/blog/shell-truncating-string"
                        echo "string : [${str}]"

                        #分割符为'/'
                        substr=${str##*/}
                        echo "substr : [${substr}]"
                     

                    执行结果：

                        string : [http://www.fengbohello.xin3e.com/blog/shell-truncating-string]
                        substr : [shell-truncating-string]
                         

            3) 使用 % 和 %% 获取头部子字符串
                3.1) % 最小限度从后面截取word
                    语法：
                        ${parameter%word} 
                 
                    示例代码：
                        str="http://www.fengbohello.xin3e.com/blog/shell-truncating-string"
                        echo "string : [${str}]"

                        substr=${str%/*}
                        echo "substr : [${substr}]"
                 
                    执行结果*/：
                        string : [http://www.fengbohello.xin3e.com/blog/shell-truncating-string]
                        substr : [http://www.fengbohello.xin3e.com/blog]
                 

                3.2) %% 最大限度从后面截取word
                    语法：
                        ${parameter%%word}
                 

                    示例代码：
                        str="http://www.fengbohello.xin3e.com/blog/shell-truncating-string"
                        echo "string : [${str}]"

                        substr=${str%%/*}
                        echo "substr : [${substr}]"
                 
                    执行结果*/：

                        string : [http://www.fengbohello.xin3e.com/blog/shell-truncating-string]
                        substr : [http:]
                 

            
            4)使用 ${var:} 模式获取子字符串
                4.1) 指定从左边第几个字符开始以及子串中字符的个数
                    语法：
                        ${var:start:len}
                     
                    示例代码：
                        str="http://www.fengbohello.xin3e.com/blog/shell-truncating-string"
                        echo "string : [${str}]"

                        #其中的 0 表示左边第一个字符开始，7 表示子字符的总个数。
                        substr=${str:0:7}
                        echo "substr : [${substr}]"

                    执行结果：

                        string : [http://www.fengbohello.xin3e.com/blog/shell-truncating-string]
                        substr : [http://]
                     

                4.2) 从左边第几个字符开始一直到结束
                    语法：
                        ${var:7}
                     
                    示例代码：
                        str="http://www.fengbohello.xin3e.com/blog/shell-truncating-string"
                        echo "string : [${str}]"

                        #其中的 7 表示左边第8个字符开始
                        substr=${str:7}
                        echo "substr : [${substr}]"
                
                    执行结果：

                        string : [http://www.fengbohello.xin3e.com/blog/shell-truncating-string]
                        substr : [www.fengbohello.xin3e.com/blog/shell-truncating-string]
                     

                4.3) 从右边第几个字符开始以及字符的个数
                    语法：
                        ${var:0-start:len}
                     
                    示例代码：

                        str="http://www.fengbohello.xin3e.com/blog/shell-truncating-string"
                        echo "string : [${str}]"

                        #其中的 0-23 表示右边算起第23个字符开始，5 表示字符的个数
                        substr=${str:0-23:5}
                        echo "substr : [${substr}]"
              
                     

                    执行结果：

                        string : [http://www.fengbohello.xin3e.com/blog/shell-truncating-string]
                        substr : [shell]
                     

                4.4) 从右边第几个字符开始一直到结束
                    语法：
                        ${var:0-start}
                     

                    示例代码：
                        str="http://www.fengbohello.xin3e.com/blog/shell-truncating-string"
                        echo "string : [${str}]"

                        #其中的 0-6 表示右边算起第6个字符开始
                        substr=${str:0-6}
                        echo "substr : [${substr}]"
                        
                    执行结果：
                        string : [http://www.fengbohello.xin3e.com/blog/shell-truncating-string]
                        substr : [string]
                        
                        
                        
                        
    4、shell脚本字符串截取的8种方法
        假设有变量 var=http://www.aaa.com/123.htm.

        1. # 号截取，删除左边字符，保留右边字符。

            echo ${var#*//}
         
            其中 var 是变量名，# 号是运算符，*// 表示从左边开始删除第一个 // 号及左边的所有字符.
            即删除 http://
            结果是 ：www.aaa.com/123.htm


        2. ## 号截取，删除左边字符，保留右边字符。

            echo ${var##*/}
         
            ##*/ 表示从左边开始删除最后（最右边）一个 / 号及左边的所有字符
            即删除 http://www.aaa.com/
            结果是 123.htm


        3. %号截取，删除右边字符，保留左边字符

            echo ${var%/*}
         

            %/* 表示从右边开始*/，删除第一个 / 号及右边的字符
            结果是：http://www.aaa.com


        4. %% 号截取，删除右边字符，保留左边字符

            echo ${var%%/*}
             
             %%/* 表示从右边开始，删除最后（最左边）一个 / 号及右边的字符
            结果是*/：http:


        5. 从左边第几个字符开始，及字符的个数

            echo ${var:0:5}
             

            其中的 0 表示左边第一个字符开始，5 表示字符的总个数。
            结果是：http:


        6. 从左边第几个字符开始，一直到结束。

            echo ${var:7}
         
            其中的 7 表示左边第8个字符开始，一直到结束。
            结果是 ：www.aaa.com/123.htm


        7. 从右边第几个字符开始，及字符的个数

            echo ${var:0-7:3}
         
            其中的 0-7 表示右边算起第七个字符开始，3 表示字符的个数。
            结果是：123


        8. 从右边第几个字符开始，一直到结束。

            echo ${var:0-7}
         
            表示从右边第七个字符开始，一直到结束。
            结果是：123.htm

            注：（左边的第一个字符是用 0 表示，右边的第一个字符用 0-1 表示）



    5. Linux-shell脚本字符串截取
        字符截取

            测试字符串
                var=1234567890abcedef1203


            1、使用#截取0以后的内容
                
                echo ${var#*0}
                
                结果：abcedef1203
                #表示操作符，*0表示从左往右找到第一个0，截取0之后的所有字符


                echo ${var##*0}

                结果：3
                #表示操作符，*0表示从右往左找到第一个0，截取0之后的所有字符


            2、使用%截取

                echo ${var%0*}
                
                结果：1234567890abcedef12
                %表示操作符，0*表示从右往左找到第一个0，截取0之前的所有字符


                echo ${var%%0*}

                结果：123456789
                %表示操作符，0*表示从左往右找到第一个0，截取0之前的所有字符



            3、根据索引来截取

                echo ${var:0:7}

                结果：1234567
                其中的 0 表示左边第一个字符开始，7 表示字符的总个数。



                echo ${var:7:5}

                结果：890ab
                其中的 7 表示左往右第七个字符开始，5 表示字符的个数。


                echo ${var:0-7:5}

                结果：def12
                其中的 0-7 表示右往左第七个字符开始，5 表示字符的个数。


                echo ${var:0-7}

                结果：def1203
                如果不加字符个数就截取剩下的所有字符




        总结
            shell用来处理字符串还是不习惯，但是不难！
            
            
            
            
            
    6. linux中shell变量$#,$@,$0,$1,$2的含义解释/Shell中的${}、##和%%使用范例/export
        linux中shell变量$#,$@,$0,$1,$2的含义解释: 
            变量说明: 
                $$ 
                Shell本身的PID（ProcessID） 
                
                $! 
                Shell最后运行的后台Process的PID 
                
                $? 
                最后运行的命令的结束代码（返回值） 
                
                $- 
                使用Set命令设定的Flag一览 
                
                $* 
                所有参数列表。如"$*"用「"」括起来的情况、以"$1 $2 … $n"的形式输出所有参数。 
                $@ 
                所有参数列表。如"$@"用「"」括起来的情况、以"$1" "$2" … "$n" 的形式输出所有参数。 
                $# 
                添加到Shell的参数个数 
                
                $0 
                Shell本身的文件名 
                
                $1～$n 
                添加到Shell的各参数值。$1是第1参数、$2是第2参数…。 

            -----------------------------------------------------------------


        介绍下Shell中的${}、##和%%使用范例，本文给出了不同情况下得到的结果。
            假设定义了一个变量为：
            
            代码如下:
                file=/dir1/dir2/dir3/my.file.txt

                可以用${ }分别替换得到不同的值：
                    ${file#*/}：删掉第一个 / 及其左边的字符串：dir1/dir2/dir3/my.file.txt
                    ${file##*/}：删掉最后一个 /  及其左边的字符串：my.file.txt
                    ${file#*.}：删掉第一个 .搜索  及其左边的字符串：file.txt
                    ${file##*.}：删掉最后一个 .  及其左边的字符串：txt
                    ${file%/*}：删掉最后一个  /  及其右边的字符串：/dir1/dir2/dir3
                    ${file%%/*}：删掉第一个 /  及其右边的字符串：(空值)
                    ${file%.*}：删掉最后一个  .  及其右边的字符串：/dir1/dir2/dir3/my.file
                    ${file%%.*}：删掉第一个  .   及其右边的字符串：/dir1/dir2/dir3/my

                */记忆的方法为：
                    # 是 去掉左边（键盘上#在 $ 的左边）
                    %是去掉右边（键盘上% 在$ 的右边）
                    单一符号是最小匹配；两个符号是最大匹配
                    ${file:0:5}：提取最左边的 5 个字节：/dir1
                    ${file:5:5}：提取第 5 个字节右边的连续5个字节：/dir2

                也可以对变量值里的字符串作替换：
                    ${file/dir/path}：将第一个dir 替换为path：/path1/dir2/dir3/my.file.txt
                    ${file//dir/path}：将全部dir 替换为 path：/path1/path2/path3/my.file.txt

                
            //------------------------------------------------------------------------------------------------------

        1、执行脚本时是在一个子shell环境运行的，脚本执行完后该子shell自动退出；

        2、一个shell中的系统环境变量怎样才会被复制到子shell中（用export定义的变量）；

        3、一个shell中的系统环境变量只对该shell或者它的子shell有效，该shell结束时变量消失（并不能返回到父shell中）。

        4、不用export定义的变量只对该shell有效，对子shell是无效的。


            －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

                    －d ：判断制定的是否为目录
                    －z：判断制定的变量是否存在值
                    －f：判断制定的是否为文件
                    －L:判断制定的是否为符号链接
                    －r：判断制定的是否可读
                    －s:判断存在的对象长度是否为0
                    －w:判断制定的是否可写
                    －x：判断存在的对象是否可以执行
        ！：测试条件的否定符号
                    
        这些文件操作很多时候给脚本编程带来方便，尤其是用在if条件语句中
    
    
    
    7.Shell 命令中的特殊替换、模式匹配替换、字符串提取和替换
        形式	                    说明
        ${var}	            变量本来的值
        
        ${var:-word}	    如果变量 var 为空或已被删除(unset)，那么返回 word，但不改变 var 的值。
        
        ${var:=word}	    如果变量 var 为空或已被删除(unset)，那么返回 word，并将 var 的值设置为 word。
        ${var:?message}	    如果变量 var 为空或已被删除(unset)，那么将消息 message 送到标准错误输出，可以用来检测变量 var 是否可以被正常赋值。
                            若此替换出现在Shell脚本中，那么脚本将停止运行。
                            
        ${var:+word}	    如果变量 var 被定义，那么返回 word，但不改变 var 的值。


        特殊替换——${var:-string},${var:+string},${var:=string},${var:?string}
          ①${var:-string}和${var:=string}：若变量var为空，则用在命令行中用string来替换${var:-string}，否则变量var不为空时，则用变量var的值来替换${var:-string}；不同之处是${var:=string}常用于判断var是否赋值，没有的话则给var赋上一个默认值。

          ② ${var:+string}：替换规则和上面的相反，即只有当var不是空的时候才替换成string，若var为空时则不替换或者说是替换成变量 var的值，即空值。(因为变量var此时为空，所以这两种说法是等价的) 

          ③${var:?string}：替换规则为：若变量var不为空，则用变量var的值来替换${var:?string}；若变量var为空，则把string输出到标准错误中，并从脚本中退出。我们可利用此特性来检查是否设置了变量的值。

            注意：在上面这五种替换结构中string不一定是常值的，可用另外一个变量的值或是一种命令的输出。



        模式匹配替换——${var%pattern},${var%%pattern},${var#pattern},${var##pattern}
            # 是去掉左边(在键盘上#在$之左边)；% 是去掉右边(在键盘上%在$之右边)；#和%中的单一符号是最小匹配，两个相同符号是最大匹配。

            第一种模式：${variable%pattern}。shell在variable中查找，看它是否一给的模式pattern结尾，如果是，把variable去掉右边最短的匹配模式

             第二种模式： ${variable%%pattern}，这种模式时，shell在variable中查找，看它是否一给的模式pattern结尾，如果是，把variable中去掉右边最长的匹配模式

            第三种模式：${variable#pattern} 这种模式时，shell在variable中查找，看它是否一给的模式pattern开始，如果是，把variable中去掉左边最短的匹配模式

            第四种模式： ${variable##pattern} 这种模式时，shell在variable中查找，看它是否一给的模式pattern结尾，如果是，把variable中去掉左边最长的匹配模式

            
            这四种模式中都不会改变variable的值，其中，只有在pattern中使用了*匹配符号时，%和%%，#和##才有区别。结构中的pattern支持通配符，*表示零个或多个任意字符，?表示仅与一个任意字符匹配，[...]表示匹配中括号里面的字符，[!...]表示不匹配中括号里面的字符。

                [plain]  view plain  copy

                # var=testcase      
                # echo $var      
                testcase      
                # echo ${var%s*e}     
                testca      
                # echo $var      
                testcase     
                # echo ${var%%s*e}     
                te    
                # echo ${var#?e}      
                stcase    
                # echo ${var##?e}      
                stcase    
                # echo ${var##*e}      
                    
                # echo ${var##*s}      
                e      
                # echo ${var##test}      
                case     



        字符串提取和替换—— ${var:num},${var:num1:num2},${var/pattern/pattern},${var//pattern/pattern}
            第一种模式：${var:num}，shell在var中提取第num个字符到末尾的所有字符。若num为正数，从左边0处开始；若num为负数，从右边开始提取字串，但必须使用在冒号后面加空格或一个数字或整个num加上括号，如${var: -2}、${var:1-3}或${var:(-2)}。         

            第二种模式：${var:num1:num2}，num1是位置，num2是长度。表示从$var字符串的第$num1个位置开始提取长度为$num2的子串。不能为负数。

            第三种模式：${var/pattern/pattern}表示将var字符串的第一个匹配的pattern替换为另一个pattern。

            第四种模式：${var//pattern/pattern}表示将var字符串中的所有能匹配的pattern替换为另一个pattern。

                [plain]  view plain  copy

                [root@centos ~]# var=/home/centos    
                [root@centos ~]# echo $var    
                /home/centos    
                [root@centos ~]# echo ${var:5}    
                /centos    
                [root@centos ~]# echo ${var: -6}    
                centos    
                [root@centos ~]# echo ${var:(-6)}    
                centos    
                [root@centos ~]# echo ${var:1:4}    
                home    
                [root@centos ~]# echo ${var/o/h}    
                /hhme/centos    
                [root@centos ~]# echo ${var//o/h}    
                /hhme/cenths    

            对{}和()而言,  括号中 的重定向符只影响该条命令， 而 括号外 的重定向符影响到括号中的所有命令。




    8.shell变量里的字符替换
        b=${a/123/321};将${a}里的第一个123替换为321
        b=${a//123/321};将${a}里的所有123替换为321

        shell调试:
            sh -x aaa.sh


        from:
            http://bbs.chinaunix.net/viewthread.php?tid=218853&extra=&page=7#pid1628522


        shell十三问:
            不過，假如你只看到 ${ } 只能用來界定變量名稱的話，那你就實在太小看 bash 了﹗
            有興趣的話，你可先參考一下 cu 本版的精華文章：
            http://www.chinaunix.net/forum/viewtopic.php?t=201843

            
            為了完整起見，我這裡再用一些例子加以說明 ${ } 的一些特異功能：
                假設我們定義了一個變量為：
                file=/dir1/dir2/dir3/my.file.txt

                我們可以用 ${ } 分別替換獲得不同的值：
                    ${file#*/}：拿掉第一條 / 及其左邊的字串：dir1/dir2/dir3/my.file.txt
                    ${file##*/}：拿掉最後一條 / 及其左邊的字串：my.file.txt
                    ${file#*.}：拿掉第一個 . 及其左邊的字串：file.txt
                    ${file##*.}：拿掉最後一個 . 及其左邊的字串：txt
                    ${file%/*}：拿掉最後條 / 及其右邊的字串：/dir1/dir2/dir3
                    ${file%%/*}：拿掉第一條 / 及其右邊的字串：(空值)
                    ${file%.*}：拿掉最後一個 . 及其右邊的字串：/dir1/dir2/dir3/my.file
                    ${file%%.*}：拿掉第一個 . 及其右邊的字串：/dir1/dir2/dir3/my
                
                
                */記憶的方法為：
                    # 是去掉左邊(在鑑盤上 # 在 $ 之左邊)
                    % 是去掉右邊(在鑑盤上 % 在 $ 之右邊)
                    單一符號是最小匹配﹔兩個符號是最大匹配。

                    ${file:0:5}：提取最左邊的 5 個字節：/dir1
                    ${file:5:5}：提取第 5 個字節右邊的連續 5 個字節：/dir2

                
                我們也可以對變量值裡的字串作替換：
                    ${file/dir/path}：將第一個 dir 提換為 path：/path1/dir2/dir3/my.file.txt
                    ${file//dir/path}：將全部 dir 提換為 path：/path1/path2/path3/my.file.txt

                
                利用 ${ } 還可針對不同的變數狀態賦值(沒設定、空值、非空值)：
                    ${file-my.file.txt} ：假如 $file 沒有設定，則使用 my.file.txt 作傳回值。(空值及非空值時不作處理)
                    ${file:-my.file.txt} ：假如 $file 沒有設定或為空值，則使用 my.file.txt 作傳回值。 (非空值時不作處理)
                    ${file+my.file.txt} ：假如 $file 設為空值或非空值，均使用 my.file.txt 作傳回值。(沒設定時不作處理)
                    ${file:+my.file.txt} ：若 $file 為非空值，則使用 my.file.txt 作傳回值。 (沒設定及空值時不作處理)
                    ${file=my.file.txt} ：若 $file 沒設定，則使用 my.file.txt 作傳回值，同時將 $file 賦值為 my.file.txt 。 (空值及非空值時不作處理)
                    ${file:=my.file.txt} ：若 $file 沒設定或為空值，則使用 my.file.txt 作傳回值，同時將 $file 賦值為 my.file.txt 。 (非空值時不作處理)
                    ${file?my.file.txt} ：若 $file 沒設定，則將 my.file.txt 輸出至 STDERR。 (空值及非空值時不作處理)
                    ${file:?my.file.txt} ：若 $file 沒設定或為空值，則將 my.file.txt 輸出至 STDERR。 (非空值時不作處理)

                
                tips:
                    以上的理解在於, 你一定要分清楚 unset 與 null 及 non-null 這三種賦值狀態.
                    一般而言, : 與 null 有關, 若不帶 : 的話, null 不受影響, 若帶 : 則連 null 也受影響.


                還有哦，${#var} 可計算出變量值的長度：
                    ${#file} 可得到 27 ，因為 /dir1/dir2/dir3/my.file.txt 剛好是 27 個字節...
       
                给我老师的人工智能教程打call！http://blog.csdn.net/jiangjunshow





③、vi中文本操作
    vi/vim 中在每行行首或行尾插入指定字符串

    行首 :%s/^/your_word/
    行尾 :%s/$/your_word/

    
    1、按键操作：

        注释(列模式方式)：ctrl+v 进入列编辑模式,向下或向上移动光标,把需要注释的行的开头标记起来,然后按大写的I,再插入注释符,比如”#”,再按Esc,就会全部注释了。

        删除：先按v,进入visual模式,横向选中列的个数(如”#”注释符号,需要选中两列),再按Esc,再按ctrl+v 进入列编辑模式,向下或向上移动光标,选中注释部分,然后按d, 就会删除注释符号（#）。

        PS：当然不一定是shell的注释符”#”，也可以是”//”，或者其他任意的字符；vim才不知道什么是注释符呢，都是字符而已。



        案例:

            vim 列编辑模式
            使用替换命令：
           
            替换命令语法：
                :[addr]s/源字符串/目标字符串/[option]

            全局替换：
                :%s/源字符串/目标字符串/g
                
                参数说明：

                    [addr]——表示检索范围，省略时表示当前行。
                    "%"：表示整个文件，同"1,$"；
                    ".,$"：从当前行到文件尾；
                    s：表示替换操作
                    [option]：表示操作类型
                    g：全局替换
                    c：表示进行确认
                    p：表示替换结果逐行显示（Ctrl+L恢复屏幕）
                    省略option：默认仅对每行第一个匹配串进行替换
                    如果在源字符串和目标字符串中有特殊字符，需要使用“\”转义

                举例：
                    在全部内容的行首添加//号注释
                        :% s/^/\/\//g

                    在2~50行首添加//号注释
                        :2,50 s/^/\/\//g

                    在2~50行首删除//号
                        :2,50 s/^\/\///g

            
            全局替换（全文替换、全部替换）：
                :%s/原字符/希望替换的字符/g


④、vim基础操作
    在命令模式下：

    1、跳到指定行，如5
        :5

    2、跳到最后一行
        G（shift + g）

    3、跳到行首
        gg

    4、转到第N行，如第7行
        7G

    5、删除所有内容
        A).使用shift+g转到最后一行

        B).命令模式下输入:1,.d

    
        引申：深处第3行到最后一行

            A).使用shift+g转到最后一行

            B).命令模式下输入:3,.d

    6、删除光标所在字符
        x

    7、删除光标所在前面的字符（大写X）
        X

    8、删除到下一个单词开头
        dw

    9、删除到本单词末尾
        de

    10、删除到本单词末尾包括标点在内
        dE

    11、删除到前一个单词
        db

    12、删除到前一个单词包括标点在内
        dB

    13、删除一整行
        dd

    14、删除光标位置到本行结尾
        ud$

    15、删除光标位置到本行开头
        d0

        在vim中 ，“.”当前行 ，“1,.”表示从第一行到当前行 ，“d”删除，3dd代表删除三行。

    16、vim 统计单词匹配数量  
        :%s/hello world/&/gn 
        上句统计hello world 在全文出现的次数

        如果要统计从50行到100行，出现的次数，则使用： 
            :50,100s/hello world//gn



⑤、shell脚本中的注释(单行注释/多行注释)
    1、单行注释
    "#" 置于行首位置

    2、多行注释
        A) 方式一
            :<
    • 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
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314
    • 315
    • 316
    • 317
    • 318
    • 319
    • 320
    • 321
    • 322
    • 323
    • 324
    • 325
    • 326
    • 327
    • 328
    • 329
    • 330
    • 331
    • 332
    • 333
    • 334
    • 335
    • 336
    • 337
    • 338
    • 339
    • 340
    • 341
    • 342
    • 343
    • 344
    • 345
    • 346
    • 347
    • 348
    • 349
    • 350
    • 351
    • 352
    • 353
    • 354
    • 355
    • 356
    • 357
    • 358
    • 359
    • 360
    • 361
    • 362
    • 363
    • 364
    • 365
    • 366
    • 367
    • 368
    • 369
    • 370
    • 371
    • 372
    • 373
    • 374
    • 375
    • 376
    • 377
    • 378
    • 379
    • 380
    • 381
    • 382
    • 383
    • 384
    • 385
    • 386
    • 387
    • 388
    • 389
    • 390
    • 391
    • 392
    • 393
    • 394
    • 395
    • 396
    • 397
    • 398
    • 399
    • 400
    • 401
    • 402
    • 403
    • 404
    • 405
    • 406
    • 407
    • 408
    • 409
    • 410
    • 411
    • 412
    • 413
    • 414
    • 415
    • 416
    • 417
    • 418
    • 419
    • 420
    • 421
    • 422
    • 423
    • 424
    • 425
    • 426
    • 427
    • 428
    • 429
    • 430
    • 431
    • 432
    • 433
    • 434
    • 435
    • 436
    • 437
    • 438
    • 439
    • 440
    • 441
    • 442
    • 443
    • 444
    • 445
    • 446
    • 447
    • 448
    • 449
    • 450
    • 451
    • 452
    • 453
    • 454
    • 455
    • 456
    • 457
    • 458
    • 459
    • 460
    • 461
    • 462
    • 463
    • 464
    • 465
    • 466
    • 467
    • 468
    • 469
    • 470
    • 471
    • 472
    • 473
    • 474
    • 475
    • 476
    • 477
    • 478
    • 479
    • 480
    • 481
    • 482
    • 483
    • 484
    • 485
    • 486
    • 487
    • 488
    • 489
    • 490
    • 491
    • 492
    • 493
    • 494
    • 495
    • 496
    • 497
    • 498
    • 499
    • 500
    • 501
    • 502
    • 503
    • 504
    • 505
    • 506
    • 507
    • 508
    • 509
    • 510
    • 511
    • 512
    • 513
    • 514
    • 515
    • 516
    • 517
    • 518
    • 519
    • 520
    • 521
    • 522
    • 523
    • 524
    • 525
    • 526
    • 527
    • 528
    • 529
    • 530
    • 531
    • 532
    • 533
    • 534
    • 535
    • 536
    • 537
    • 538
    • 539
    • 540
    • 541
    • 542
    • 543
    • 544
    • 545
    • 546
    • 547
    • 548
    • 549
    • 550
    • 551
    • 552
    • 553
    • 554
    • 555
    • 556
    • 557
    • 558
    • 559
    • 560
    • 561
    • 562
    • 563
    • 564
    • 565
    • 566
    • 567
    • 568
    • 569
    • 570
    • 571
    • 572
    • 573
    • 574
    • 575
    • 576
    • 577
    • 578
    • 579
    • 580
    • 581
    • 582
    • 583
    • 584
    • 585
    • 586
    • 587
    • 588
    • 589
    • 590
    • 591
    • 592
    • 593
    • 594
    • 595
    • 596
    • 597
    • 598
    • 599
    • 600
    • 601
    • 602
    • 603
    • 604
    • 605
    • 606
    • 607
    • 608
    • 609
    • 610
    • 611
    • 612
    • 613
    • 614
    • 615
    • 616
    • 617
    • 618
    • 619
    • 620
    • 621
    • 622
    • 623
    • 624
    • 625
    • 626
    • 627
    • 628
    • 629
    • 630
    • 631
    • 632
    • 633
    • 634
    • 635
    • 636
    • 637
    • 638
    • 639
    • 640
    • 641
    • 642
    • 643
    • 644
    • 645
    • 646
    • 647
    • 648
    • 649
    • 650
    • 651
    • 652
    • 653
    • 654
    • 655
    • 656
    • 657
    • 658
    • 659
    • 660
    • 661
    • 662
    • 663
    • 664
    • 665
    • 666
    • 667
    • 668
    • 669
    • 670
    • 671
    • 672
    • 673
    • 674
    • 675
    • 676
    • 677
    • 678
    • 679
    • 680
    • 681
    • 682
    • 683
    • 684
    • 685
    • 686
    • 687
    • 688
    • 689
    • 690
    • 691
    • 692
    • 693
    • 694
    • 695
    • 696
    • 697
    • 698
    • 699
    • 700
    • 701
    • 702
    • 703
    • 704
    • 705
    • 706
    • 707
    • 708
    • 709
    • 710
    • 711
    • 712
    • 713
    • 714
    • 715
    • 716
    • 717
    • 718
    • 719
    • 720
    • 721
    • 722
    • 723
    • 724
    • 725
    • 726
    • 727
    • 728
    • 729
    • 730
    • 731
    • 732
    • 733
    • 734
    • 735
    • 736
    • 737
    • 738
    • 739
    • 740
    • 741
    • 742
    • 743
    • 744
    • 745
    • 746
    • 747
    • 748
    • 749
    • 750
    • 751
    • 752
    • 753
    • 754
    • 755
    • 756
    • 757
    • 758
    • 759
    • 760
    • 761
    • 762
    • 763
    • 764
    • 765
    • 766
    • 767
    • 768
    • 769
    • 770
    • 771
    • 772
    • 773
    • 774
    • 775
    • 776
    • 777
    • 778
    • 779
    • 780
    • 781
    • 782
    • 783
    • 784
    • 785
    • 786
    • 787
    • 788
    • 789
    • 790
    • 791
    • 792
    • 793
    • 794
    • 795
    • 796
    • 797
    • 798
    • 799
    • 800
    • 801
    • 802
    • 803
    • 804
    • 805
    • 806
    • 807
    • 808
    • 809
    • 810
    • 811
    • 812
    • 813
    • 814
    • 815
    • 816
    • 817
    • 818
    • 819
    • 820
    • 821
    • 822
    • 823
    • 824
    • 825
    • 826
    • 827
    • 828
    • 829
    • 830
    • 831
    • 832
    • 833
    • 834
    • 835
    • 836
    • 837
    • 838
    • 839
    • 840
    • 841
    • 842
    • 843
    • 844
    • 845
    • 846
    • 847
    • 848
    • 849
    • 850
    • 851
    • 852
    • 853
    • 854
    • 855
    • 856
    • 857
    • 858
    • 859
    • 860
    • 861
    • 862
    • 863
    • 864
    • 865
    • 866
    • 867
    • 868
    • 869
    • 870
    • 871
    • 872
    • 873
    • 874
    • 875
    • 876
    • 877
    • 878
    • 879
    • 880
    • 881
    • 882
    • 883
    • 884
    • 885
    • 886
    • 887
    • 888
    • 889
    • 890
    • 891
    • 892
    • 893
    • 894
    • 895
    • 896
    • 897
    • 898
    • 899
    • 900
    • 901
    • 902
    • 903
    • 904
    • 905
    • 906
    • 907
    • 908
    • 909
    • 910
    • 911
    • 912
    • 913
    • 914
    • 915
    • 916
    • 917
    • 918
    • 919
    • 920
    • 921
    • 922
    • 923
    • 924
    • 925
    • 926
    • 927
    • 928
    • 929
    • 930
    • 931
    • 932
    • 933
    • 934
    • 935
    • 936
    • 937
    • 938
    • 939
    • 940
    • 941
    • 942
    • 943
    • 944
    • 945
    • 946
    • 947
    • 948
    • 949
    • 950
    • 951
    • 952
    • 953
    • 954
    • 955
    • 956
    • 957
    • 958
    • 959
    • 960
    • 961
    • 962
    • 963
    • 964
    • 965
    • 966
    • 967
    • 968
    • 969
    • 970
    • 971
    • 972
    • 973
    • 974
    • 975
    • 976
    • 977
    • 978
    • 979
    • 980
    • 981
    • 982
    • 983
    • 984
    • 985
    • 986
    • 987
    • 988
    • 989
    • 990
    • 991
    • 992
    • 993
    • 994
    • 995
    • 996
    • 997
    • 998
    • 999
    • 1000
    • 1001
    • 1002
    • 1003
    • 1004
    • 1005
    • 1006
    • 1007
    • 1008
    • 1009
    • 1010
    • 1011
    • 1012
    • 1013
    • 1014
    • 1015
    • 1016
    • 1017
    • 1018
    • 1019
    • 1020
    • 1021
    • 1022
    • 1023
    • 1024
    • 1025
    • 1026
    • 1027
    • 1028
    • 1029
    • 1030
    • 1031
    • 1032
    • 1033
    • 1034
    • 1035
    • 1036
    • 1037
    • 1038
    • 1039
    • 1040
    • 1041
    • 1042
    • 1043
    • 1044
    • 1045
    • 1046
    • 1047
    • 1048
    • 1049
    • 1050
    • 1051
    • 1052
    • 1053
    • 1054
    • 1055
    • 1056
    • 1057
    • 1058
    • 1059
    • 1060
    • 1061
    • 1062
    • 1063
    • 1064
    • 1065
    • 1066
    • 1067
    • 1068
    • 1069
    • 1070
    • 1071
    • 1072
    • 1073
    • 1074
    • 1075
    • 1076
    • 1077
    • 1078
    • 1079
    • 1080
    • 1081
    • 1082
    • 1083
    • 1084
    • 1085
    • 1086
    • 1087
    • 1088
    • 1089
    • 1090
    • 1091
    • 1092
    • 1093
    • 1094
    • 1095
    • 1096
    • 1097
    • 1098
    • 1099
    • 1100
    • 1101
    • 1102
    • 1103
    • 1104
    • 1105
    • 1106
    • 1107
    • 1108
    • 1109
    • 1110
    • 1111
    • 1112
    • 1113
    • 1114
    • 1115
    • 1116
    • 1117
    • 1118
    • 1119
    • 1120
    • 1121
    • 1122
    • 1123
    • 1124
    • 1125
    • 1126
    • 1127
    • 1128
    • 1129
    • 1130
    • 1131
    • 1132
    • 1133
    • 1134
    • 1135
    • 1136
    • 1137

    15、Shell编程相关

    ①、内置变量

        1、declare
        declare声明变量的使用，总结如下：
        declare [+/-][选项] 变量名
        选项：
           -：给变量添加类型属性
           +：取消变量的类型属性
          -a：将变量声明为数组型，-A将声明一个关联数组，俗称字典。  关联知识：Shell 数组与关联数组详解及实例代码（https://www.jb51.net/article/103915.htm）
          -i：将变量声明为整型
          -x：将变量声明为环境变量
          -r：将变量声明为只读变量
          -p：查看变量的被声明的类型

        declare -i 说明：

        和 (())、let、$[] 不同，declare -i的功能非常有限，仅支持最基本的数学运算（加减乘除和取余），不支持逻辑运算（比较运算、与运算、或运算、非运算），所以在实际开发中很少使用。

            declare -i m n ret
            m=10
            n=30

            ret=$m+$n
            echo $ret

            ret=$n/$m
            echo $ret
    
        declare的作用域，只在函数内，出来后就失效了，如下：

            #!/bin/bash

            foo()
            {
            declare FOO="bar"
            }

            bar()
            {
            foo
            echo $FOO
            }

            bar

    • 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

    ②、数据结构

        1、数组
        Linux shell中数组的使用(https://www.cnblogs.com/Joke-Shi/p/5705856.html?login=from_csdn)

        1、数组有两种数据类型：

            A). 一是数值类型;

            B). 二是字符串类型.

        虽然shell本身是弱类型的，但也可以这么区分。

        2、数值类型的数组：一对括号表示数组，数组中元素之间使用“空格”来隔开。

            举个列子: 
                arr_number=(1 2 3 4 5);

        3、字符串类型数组：同样，使用一对括号表示数组，其中数组中的元素使用双引号或者单引号包含，同样使用“空格”来隔开。

                arr_string=("abc" "edf" "sss"); 或者 arr_string=('abc' 'edf' 'sss');

            #!/bin/bash
            arr_number=(1 2 3 4 5)

            # ①、获取数组长度
            # 语法： ${#ARRAY_NAME[@|*]}
            echo 'arr_number length ='${#arr_number[@]}
            echo 'arr_number length ='${#arr_number[*]}

            # ②、根据下标访问数组元素（注意：下标与java语法类似，从0开始）
            # 2nd key's value
            echo "2nd key's value ="${arr_number[1]}

            # ③、分片访问
            echo ${arr_number[@]:0:6}

            # ④、模式替换
            echo ${arr_number[@]/3/33}

            # ⑤、数组的遍历
            for e in ${arr_number[@]}
            do
                    echo $e
            done

            # ⑥、综合案例
            # 编注：数组默认分割符为空格，如果数组元素中本身包含空格，也会被截断，这里通过改变IFS（系统字段分割# 符默认为空格）为换行，达到分割数组的目的。
            greet=('hello world' "hi,john")
            OLD_IFS=$IFS
            IFS='\n'
            for e in ${greet[@]}
            do
                    echo $e
            done
            IFS=$OLD_IFS
   
   
                        》①、批量删除日志：
            for i in in {1..10}; do rm -f hadoop-cmf-hive-HIVEMETASTORE-nn1.testhdp.com.log.out.$i;done

                        》②、批量将日志置空：
            for i in in {1..10}; do cat /dev/null > hadoop-cmf-yarn-NODEMANAGER-dn8.hadoop.com.log.out.$i;done




    2、字典dict 或 Map
        1). 声明字典类型：
            declare -A dic

            这里一定要-A来声明，-a只能用来声明数组类型。

        2). 字典赋初值
            dic=([key1]="value1" [key2]="value2" [key3]="value3")

        3). 字典动态赋值
            dic['key']=value

        4). 打印指定key的value
            echo ${dic['key']}

        5). 打印所有key值
            echo ${!dic[*]}

        6). 打印所有value
            echo ${dic[*]}

        7). 遍历key值
            for key in $(echo ${!dic[*]})
            do
                echo "$key : ${dic[$key]}"
            done
        
        8). 综合案例

            #! /bin/sh
            #输入格式为一行一个单词

            declare -A dict
            dict=([k1]="v1" [k2]="v2")
            echo ${dict["k1"]}
            echo ${!dict[*]}
            echo ${dict[*]}

            for key in ${!dict[*]}
            do
                    echo "$key : ${dict[$key]}"
            done
            set -x
            aa="null"
            bb=
            cc=''

            #    -z 字符串为"null".就是长度为0.
            #
            #    -n 字符串不为"null"
            #
            #     注意:
            #
            #     使用-n在[]结构中测试必须要用""把变量引起来.使用一个未被""的字符串来使用! -z
            #
            #     或者就是未用""引用的字符串本身,放到[]结构中。虽然一般情况下可
            #
            #     以工作,但这是不安全的.习惯于使用""来测试字符串是一种好习惯.
            if [ -n "$cc" ];then
                    echo "aa is not null"
            fi
            set +x


            #定义字典类型变量
            declare -A dict

            #从标准输入读取
            while read word
            do
                #若key为word的变量不存在，则为未定义，即第一次遇到此word，则将此word加入字典并设置其value为1。，否则自增value值
                if [ ! -n dict[${word}] ];then
                    dict[${word}]=1
                else
                    ((dict[${word}]++))
                fi
            done
            #打印统计结果
            echo -e "word\t\tcount"
            for key in $(echo ${!dict[*]})
            do
                echo -e "$key\t\t${dict[$key]}"
            done
    
    
        综合案例二: shell的map简单的添加、查找、删除、遍历(https://blog.csdn.net/weixin_42651205/article/details/83624574?login=from_csdn)





    3、管道输出中执行下一条指令
        ps -ef | grep 'new-consumer' | awk '{print $2}' |xargs kill -9       #删除kafka consumer进程

        ps -ef|grep java|grep -v grep|awk '{print $2}'|xargs kill -9          #删除java进程   

        find /opt/flume-custom/ -name *.conf|xargs grep -re "127.0.0.1:9092" #查找到的文件中查找指定字符串

        find /opt/ -type f -name '*.log' |xargs grep 'db.hostname'

        cat ~/.ssh/id_rsa.pub | ssh my_admin@111.111.111.111 "cat - >> ~/.ssh/authorized_keys"

        kill -9 $(ps -ef|grep "sh\ *start_new.sh\ *main"|grep -v grep|awk '{print $2}') #\ *表任意多空格

        kill -9 `ps -ef|grep data-integration|awk '{print $2}'`

        ls|while read f;do zip -r ${f}.zip $f;done  #压缩所有ls出来的文件夹

        ls|grep 'hadoop-cmf-yarn-RESOURCEMANAGER-nn1.hadoop.com.log.out.[0-9]\{1,\}'|while read f;do cat /dev/null > $f;done #将所有RESOURCEMANAGER日志文件内容置为空，文件尾缀为1个以上从0到9的数字，如1、2、9、12均能匹配查找到,在nn1上磁盘（/var/log/{hadoop-hdfs,hadoop-yarn}）上日志一般都比较大

        # 查找10日前创建的文件，并情况其内容
        find . -type f -name '*oozie-instrumentation.log.*' -atime +10 | while read f;do cat /dev/null > $f;done

        #查看所有用户的crontab任务，其中"-I {}"参数，可以使用-i来等量实现
        cat /etc/passwd | cut -f 1 -d : |xargs -I {} crontab -l -u {}
        cat /etc/passwd | cut -f 1 -d : |xargs -i crontab -l -u {}

        # 查询当前目录下所有文件(含目录下文件)中包含关键字(sku)的文件路径, 滤重, 并过滤掉路径中含指定字符(000)
        grep -rn 'sku' * | awk -F ':' '{print $1}' | uniq | grep -v 000
    
    
    
        传送门：Shell基础知识》xargs详解(https://www.cnblogs.com/liaojiafa/p/11537636.html?login=from_csdn)

    
    
        读取文件每一行，并循环做处理：

        ①、while read line
            do
                   …
            done < file

        ②、cat file  | ${BIZ_LOGICAL}

        综合实例：

            ssh   127.0.0.1 <$line; done

            ls lib/* |while read line;do jar -tf $line|grep LogAnalysis; echo $line;done

            #hdfs文件大小统计排序*/

            hdfs dfs -du ${HDFS_PATH} | sort -rn | head -n 10 | awk '{printf("%.2f\t\t%.2f\t\t%s\t\n",$1/1024/1024/1024,"\t"$2/1024/1024/1024,"\t"$3)}'

            #获取所有java程序的进程号

            ps -ef | while read line ; do if [[ $line =~ "java" ]] ;then echo $line |  awk -F ' ' '{print $2}' ; fi ;done

            //循环所有文件，并添加header
            #!/bin/bash
            ls OrderDetail_sysdate_* |while read file;do
            sed -i "1i\\$(cat header.csv)" $file
            done

    
        
        综合案例：

            清理日志文件夹中的日志文件，将其置为黑洞文件内容（即情况该文件）。

                #!/bin/bash

                #先遍历本文件夹里文件夹
                dir_list=`ls`

                #对查询到的文件夹执行清空其内文件的操作
                for dir in $dir_list;do
                    echo $dir
                    ls $dir/* | while read line;do echo $line; cat /dev/null > $line; done
                done
    
    
            for i in `seq 1 $(cat /proc/cpuinfo |grep "physical id" |wc -l)`; do dd if=/dev/zero of=/dev/null & done

            pkill -9 dd





    5、break 与 contine区别*/
        如下代码所示：

        不带参数 N：	
            break 	    循环只能退出最内层的循环；
            continue 	只能去掉本次循环的剩余代码；
    
        带参数 N：	
            break N	    可以退出N层循环；
            continue N 	将会把N层循环剩余代码都去掉，单循环次数不变；
    
    
        #!/bin/bash

        for i in a b c d
        do
            echo -n $i

            for j in `seq 10`
            do
                if test $j -eq 5;then
                    #break
                   # continue
                    #break 2
                    continue 2
                fi
                echo -n $j
            done

            #换行
            echo 
        done

        ##########################################
        ###
        ### Program result:
        ###
        ##########################################
        #
        #>>>>>>>>>>>>>> 1. break >>>>>>>>>>>>>>>>>
        # a1234
        # b1234
        # c1234
        # d1234

        #>>>>>>>>>>>>>> 2. continue >>>>>>>>>>>>>>>>>
        # a1234678910
        # b1234678910
        # c1234678910
        # d1234678910

        #>>>>>>>>>>>>>> 3. "break 2","break 3" has same effect >>>>>>>>>>>>>>>>>
        # a1234

        #>>>>>>>>>>>>>> 4. "continue 2" >>>>>>>>>>>>>>>>>
        # a1234
        # b1234
        # c1234
        # d1234
        
        
        
        
    6、大文件拆分处理
        文件拆分：

        split -d -a 8 -l 10000 PayOrderDetail.csv PayOrderDetail_sysdate_.csv

        用法：

            Usage: split [OPTION]... [INPUT [PREFIX]]
            Output fixed-size pieces of INPUT to PREFIXaa, PREFIXab, ...; default
            size is 1000 lines, and default PREFIX is 'x'.  With no INPUT, or when INPUT
            is -, read standard input.

            Mandatory arguments to long options are mandatory for short options too.
              -a, --suffix-length=N   generate suffixes of length N (default 2)
                  --additional-suffix=SUFFIX  append an additional SUFFIX to file names
              -b, --bytes=SIZE        put SIZE bytes per output file
              -C, --line-bytes=SIZE   put at most SIZE bytes of lines per output file
              -d, --numeric-suffixes[=FROM]  use numeric suffixes instead of alphabetic;
                                               FROM changes the start value (default 0)
              -e, --elide-empty-files  do not generate empty output files with '-n'
                  --filter=COMMAND    write to shell COMMAND; file name is $FILE
              -l, --lines=NUMBER      put NUMBER lines per output file
              -n, --number=CHUNKS     generate CHUNKS output files; see explanation below
              -u, --unbuffered        immediately copy input to output with '-n r/...'
                  --verbose           print a diagnostic just before each
                                        output file is opened
                  --help     display this help and exit
                  --version  output version information and exit

            SIZE is an integer and optional unit (example: 10M is 10*1024*1024).  Units
            are K, M, G, T, P, E, Z, Y (powers of 1024) or KB, MB, ... (powers of 1000).

            CHUNKS may be:
            N       split into N files based on size of input
            K/N     output Kth of N to stdout
            l/N     split into N files without splitting lines
            l/K/N   output Kth of N to stdout without splitting lines
            r/N     like 'l' but use round robin distribution
            r/K/N   likewise but only output Kth of N to stdout

            GNU coreutils online help: 
            For complete documentation, run: info coreutils 'split invocation'

        详细案例，详见：split命令_Linux split命令：切割（拆分）文件






    7、awk
        #批量删除hdfs下ods层下所有数据

        hdfs dfs -lsr /user/hive/warehouse/ods|awk '{print "hdfs dfs -rm -R" $8}'





    8、实现脚本中切换用户并执行该用户相关的命令操作
        假如当前用户为root账户，希望切换到其他用户下执行相关的操作，如有以下业务场景：

        想以yarn用户身份，取删除yarn运行相关的早期用处不大的日志。

    
        方式①、

            #!/bin/bash
            su - yarn < /dev/null 2>&1 &
    
        
        注意：

        该命令的执行权限是临时的，只在本条语句起作用。即在COMMAND命令行内部，是以$USER身份执行命令；执行结束后，回到初始状态用户，这里为root。 

        案例：

            ## 01-Handle logic of clean HDFS NAMENODE & DATANODE & audit logs.
            ########################################################
            su - hdfs -c '
                    HDFS_PATH=/var/log/hadoop-hdfs;
                    ls $HDFS_PATH | grep "hadoop-cmf-hdfs-NAMENODE-nn1.hadoop.com.log.out.[0-9]\{1,\}$" | while read f;     do `cat /dev/null > $HDFS_PATH/$f`; done   ;
                    ls $HDFS_PATH | grep "hadoop-cmf-hdfs-DATANODE-nn1.hadoop.com.log.out.[0-9]\{1,\}$" | while read f;     do `cat /dev/null > $HDFS_PATH/$f`; done   ;
                    ls $HDFS_PATH | grep "hdfs-audit.log.[0-9]\{1,\}$" | while read f;                                      do `cat /dev/null > $HDFS_PATH/$f`; done
            '
    
        注意：

            ① ls这段语句在命令行下执行没任何问题，提取到“su - hdfs -c”中时，`cat /dev/null > $HDFS_PATH/$f`这段必须要包裹上``符号，才能正常执行。

            ② -c 参数中，可以执行多行命令，但是需要几个条件：A). 所用命令使用''包裹，每一行命令间，使用"；"来进行分隔。


        补充su的用法：

            [root@cdh-nn1 ~]# su --help

            Usage:
             su [options] [-] [USER [arg]...]

            Change the effective user id and group id to that of USER.
            A mere - implies -l.   If USER not given, assume root.

            Options:
             -m, -p, --preserve-environment  do not reset environment variables
             -g, --group              specify the primary group
             -G, --supp-group         specify a supplemental group

             -, -l, --login                  make the shell a login shell
             -c, --command          pass a single command to the shell with -c
             --session-command      pass a single command to the shell with -c
                                             and do not create a new session
             -f, --fast                      pass -f to the shell (for csh or tcsh)
             -s, --shell              run shell if /etc/shells allows it

             -h, --help     display this help and exit
             -V, --version  output version information and exit

            For more details see su(1).
    
    
    
        su 和 “su - ${USER}”的区别：

            ①、su只是切换用户。
            ②、su - 切换用户并切换shell环境。

            ③、su another
            pwd后为/home/current

            ④、su - another
            pwd后为/home/another

    
    
    9、awk实现查找奇数行、偶数行：
        seq 20 > test.txt
        [root@server1 tmp]# awk 'NR%2 != 0' test.txt
        [root@server1 tmp]# awk 'NR%2 == 0' test.txt



    10、IFS专题
        IFS, 全称 内部字段分隔符(Internal Field Separator, IFS) , 作用是在Linux中定义一个定界符，默认是空格。

        如果字符串中的分隔符,默认不是空格,而是逗号(如csv文件), 则可以考虑临时替换IFS为逗号,处理完文本处理任务后, 再将默认的修改回来.

        如果脚本实现, 按","提取表名list:

        batch_upsert_table_process.sh

            #!/bin/bash

            include_tables="activity_info,activity_rule,activity_sku,base_category1,base_category2,base_category3,base_province,base_region,base_trademark,coupon_info,coupon_range,coupon_use,financial_sku_cost,sku_info,spu_info,user_info"

            function get_element_by_split_comma(){
                ifs_old=$IFS
                IFS=","

                for tbl in $(echo "${include_tables}");do
                    echo 'Now is handle table >>>>>>>>>>>>>>>>>>>>> '$tbl
                    /data/maxwell/bin/maxwell-bootstrap --database gmall --table $tbl --config /data/maxwell/tf_custom_config/gmall_rtdw_test.properties
                done

                #Recovery IFS to default
                IFS=$ifs_old
            }

            get_element_by_split_comma

    • 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
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314
    • 315
    • 316
    • 317
    • 318
    • 319
    • 320
    • 321
    • 322
    • 323
    • 324
    • 325
    • 326
    • 327
    • 328
    • 329
    • 330
    • 331
    • 332
    • 333
    • 334
    • 335
    • 336
    • 337
    • 338
    • 339
    • 340
    • 341
    • 342
    • 343
    • 344
    • 345
    • 346
    • 347
    • 348
    • 349
    • 350
    • 351
    • 352
    • 353
    • 354
    • 355
    • 356
    • 357
    • 358
    • 359
    • 360
    • 361
    • 362
    • 363
    • 364
    • 365
    • 366
    • 367
    • 368
    • 369
    • 370
    • 371
    • 372
    • 373
    • 374
    • 375
    • 376
    • 377
    • 378
    • 379
    • 380
    • 381
    • 382
    • 383
    • 384
    • 385
    • 386
    • 387
    • 388
    • 389
    • 390
    • 391
    • 392
    • 393
    • 394
    • 395
    • 396
    • 397
    • 398
    • 399
    • 400
    • 401
    • 402
    • 403
    • 404
    • 405
    • 406
    • 407
    • 408
    • 409
    • 410
    • 411
    • 412
    • 413
    • 414
    • 415
    • 416
    • 417
    • 418
    • 419
    • 420
    • 421
    • 422
    • 423
    • 424
    • 425
    • 426
    • 427
    • 428
    • 429
    • 430
    • 431
    • 432
    • 433
    • 434
    • 435
    • 436
    • 437
    • 438
    • 439
    • 440
    • 441
    • 442
    • 443
    • 444
    • 445
    • 446
    • 447
    • 448
    • 449
    • 450
    • 451
    • 452
    • 453
    • 454
    • 455
    • 456
    • 457
    • 458
    • 459
    • 460
    • 461
    • 462
    • 463
    • 464
    • 465
    • 466
    • 467
    • 468
    • 469
    • 470
    • 471
    • 472
    • 473
    • 474
    • 475
    • 476
    • 477
    • 478
    • 479
    • 480
    • 481
    • 482
    • 483
    • 484
    • 485
    • 486
    • 487
    • 488
    • 489
    • 490
    • 491
    • 492
    • 493
    • 494
    • 495
    • 496
    • 497
    • 498
    • 499
    • 500
    • 501
    • 502
    • 503
    • 504
    • 505
    • 506
    • 507
    • 508
    • 509
    • 510
    • 511
    • 512
    • 513

    ③、echo在shell中控制颜色&闪烁显示

        1、在shell中显示色彩
        语法格式：

        echo -e "\033[颜色1:颜色2m 要展示的文字 \033[0m"

                                        【echo常用参数】

    -----------------------------------------------------------------------------------------------------------------------

                    -e选项：表示允许反斜杠（对字符）转义。
                    
                    \033[颜色1；颜色2m：称为转义序列，它本身是一个整体，中间不要有空格。
                    \033[：转义序列的开始。其中\033代表Esc符号，也可以使用\E或\e来代替。
                    颜色1和颜色2：表示字体的前景色或背景色，至于颜色1和颜色2哪一个表示前景色，哪一个表示背景色，由其设定的数值来决定，前景色和背景色的数值空间是不同的。
                    m：转义序列的终止标志。
                    \033[0m：表示将颜色恢复回原来的配色。
                     我们可以用一张原理图来理解：

    -----------------------------------------------------------------------------------------------------------------------

    图示说明：



    颜色码：

    • 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

    ④、数据类型转化

        1、字符串转化为数字
        案例1: 将日期中以0开头的数字字符串转换为数字

        比如今日为2022-03-25, 如果想获取月份, 可以使用 echo $(date +%m) 或 echo `date +%m`, 将获取到字符串"03", 但我们想要去掉开头0的3, 翻遍date的api都没有找到.

        这时候可以考虑使用数学运算将原字符串 与 一个数字0相加, 变相通过数学计算获取到整形的计算结果.

        [hdfs@hadoop test]$ echo $(expr $(date +%m) + 0)
        3

        [hdfs@hadoop test]$ echo `expr $(date +%m) + 0`
        3

        [hdfs@hadoop test]$ hive --hivevar year=$(date +%Y) --hivevar month=`expr $(date +%m) + 0` -f /data/program/test_hive.hql
    
    
        test_hive.hql中则可以使用上述动态传参的值:

        ALTER TABLE ads.my_partition_table_test DROP IF EXISTS PARTITION(year=${hivevar:year}, month=${hivevar:month});

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

    ⑤、登录shell 与 非登录shell区别

        登录shell：使用linux账户登录后执行的shell
        Linux系统各个功能模块：
            /etc/profile
            ~/.bash_profile
            ~/.bashrc--->/etc/bashrc--->/etc/profile.d/*.sh
        注意：*/如果把环境变量只放到 /etc/profile 中，非登陆模式会获取不到环境变量。
            
    非登录shell：不经登录，直接使用shell，如ssh 远程连接到主机后执行的shell
        Linux系统各个功能模块：
            ~/.bashrc--->/etc/bashrc--->/etc/profile.d/*.sh

    */注意：

        如果将环境变量配置信息，配置在/etc/profile中，对于非登录shell，则获取不到。
        而对于/etc/profile.d/*.sh，则对于2种shell，都可以访问到*/。

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

    16、bash常用命令

    Ctrl + c        强制终止当前命令
Ctrl + l        清屏
Ctrl + a        光标移动到命令行首
Ctrl + e        光标移动到命令行尾
Ctrl + u        从光标所在位置删除到行首
Ctrl + z        把命令放在后台
Ctrl + r        在历史命令中搜索

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    17、Linux 快捷方式

    在开始学习 Linux 命令之前，有这么一些快捷方式，是必须要提前掌握的，它将贯穿整个 Linux 使用生涯。

通过上下方向键 ↑ ↓ 来调取过往执行过的 Linux 命令；

命令或参数仅需输入前几位就可以用 Tab 键补全；

Ctrl + R ：用于查找使用过的命令（history 命令用于列出之前使用过的所有命令，然后输入 ! 命令加上编号( !2 )就可以直接执行该历史命令）；

Ctrl + L：清除屏幕并将当前行移到页面顶部；

Ctrl + C：中止当前正在执行的命令；

Ctrl + U：从光标位置剪切到行首；

Ctrl + K：从光标位置剪切到行尾；

Ctrl + W：剪切光标左侧的一个单词；

Ctrl + Y：粘贴 Ctrl + U | K | Y 剪切的命令；

Ctrl + A：光标跳到命令行的开头；

Ctrl + E：光标跳到命令行的结尾；

Ctrl + D：关闭 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

    18、获取帮助

    man 手册种类：
    可执行程序或 Shell 命令；
    系统调用（ Linux 内核提供的函数）；
    库调用（程序库中的函数）；
    文件（例如 /etc/passwd ）；
    特殊文件（通常在 /dev 下）；
    游戏；
    杂项（ man(7) ，groff(7) ）；
    系统管理命令（通常只能被 root 用户使用）；
    内核子程序。

man + 数字 + 命令           输入 man + 数字 + 命令/函数，可以查到相关的命令和函数，若不加数字， man 默认从数字较小的手册中寻找相关命令和函数

man 3 rand                  表示在手册的第三部分查找 rand 函数
man ls                      查找 ls 用法手册

man 手册核心区域解析：(以 man pwd 为例)
    NAME            # 命令名称和简单描述     
        pwd -- return working directory name
    
    SYNOPSIS        # 使用此命令的所有方法     
        pwd [-L | -P]
        
    DESCRIPTION     # 包括所有参数以及用法     The pwd utility writes the absolute pathname of the current working directory to the standard output.     
        Some shells may provide a builtin pwd command which is similar or identical to this utility.  Consult the builtin(1) manual page.     
        The options are as follows:     
        -L      Display the logical current working directory.     
        -P      Display the physical current working directory (all symbolic links resolved).     
        
        If no options are specified, the -L option is assumed.SEE ALSO # 扩展阅读相关命令     
        builtin(1), cd(1), csh(1), sh(1), getcwd(3)
        
        help

    man 命令像新华词典一样可以查询到命令或函数的详细信息，但其实我们还有更加快捷的方式去查询， command --help 或 command -h ，它没有 man 命令显示的那么详细，但是它更加易于阅读。
    
man ls                  //获取帮助
man -k ls               //不清楚完整名字
command --help          显示更加易于阅读的命令帮助介绍
command -h              显示更加易于阅读的命令帮助介绍
whatis ls               //获取帮助
help cd  / cd –help     //获取帮助 -d(简短描述) -s(用法简介)
info who                //获取帮助

    • 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
  • 相关阅读:
    SpringCloud Config 分布式服务配置
    HDRP shader 获取深度值（方便地）
    【对软件项目的一些理解】多维团队分工合作模式
    （附源码）ssm人力资源管理系统 毕业设计 271621
    环形缓冲RingBuffer和无锁
    vue路由传参刷新丢失
    亚马逊云科技通过生成式AI，帮助清华RIOS加速计算和分析的处理效率
    训练神经网络跑了好几天,训练神经网络需要多久
    Linux常用命令字典篇
    从零开始的图像语义分割：FCN快速复现教程（Pytorch+CityScapes数据集）
  • 原文地址：https://blog.csdn.net/qq_44681788/article/details/130898980