1 Linux系统的简介

Linux学习
Linux >
1 Linux系统的简介

Linux系统的简介

0.UNIX和Linux的发展史

1.Linux在各领域的发展

2.常见的Linux发行版本

3.初学者应该选择的版本

4.我们该怎么学习Linux

5.工作中我们需要的技能

Copyright ? 2022. 布衣King-小志.


1.0 UNIX和Linux的发展史

Linux学习
Linux > 1 Linux系统的简介 >
1.0 UNIX和Linux的发展史

一、UNIX的发展史

（1） 1965年，美国麻省理工学院（MIT）通用电气公司（GE）及AT&T的贝尔实验室联合开发Multics工程计划，其目标是开发一种交互式的具有多道程序处理能力的分时操作系统，但因Multics追求的目标过于庞大复杂，项目进度远远落后于计划，最后贝尔实验室宣布退出。
（2） 1969年，美国贝尔实验室的肯?汤普森在DEC PDP-7机器上开发出了UNIX系统。
（3） 1971年，肯?汤普森的同事丹尼斯?里奇发明了C语言；1973年，UNIX系统的绝大部分源代码用C语言重写，这位提高UNIX系统的可移植性打下基础。

UNIX版本
1） Open Solaris
在UNIX的各发行版中，Open Solaris是唯一一个由商业版转为开放源代码的个例。
2） Oracle Solaris
在UNIX商业版中，Solaris是一个非常优秀的操作系统。
3） IBM AIX
AIX(Advanced Interactivee Xecutive)是IBM公司所有的UNIX操作系统。AIX源自于System V Release 3，运行在IBM公司的Power PC硬件架构之上。
4） HP-UX
HP-UX(Hewlett Packard UNIX，HPUX)是美国惠普公司在System v的基础上开发的UNIX操作系统。
5） UNIX V6
1975年发表的UNIX V6版是比较成熟的版本，贝尔实验室免费向美国各大学提供该版本，并开始广泛地配备于各大学的PDP-11系列计算机上。1977年，UNIX首次移植到非PDP类型的计算机上。
6） BSD UNIX
除了贝尔实验室外，另一个使用比较广泛的UNIX版本是美国加州大学贝克利分校开发的BSD UNIX，该版本大量安装在SUN工作站上。1993年推出了4.4BSD版本。BSD是网络的主要平台，对DARPA的TCP/IP提供了支持，其中的网络文件系统(NFS)提供了与很多计算机机种的连接，NFS及AT&T开发的远程文件共享(RFS)使UNIX系统在网络支持方面保持领先地位。
7） Solaris
Solaris曾是使用最广泛、最成功的商业UNIX实现版本。Sun公司的操作系统最初叫做Sun OS，主要基于BSD UNIX版本。

二、Linux的发展史

Linux 内核最初只是由芬兰人林纳斯?托瓦兹（Linus Torvalds）在赫尔辛基大学上学时出于个人爱好而编写的在1991年首次发布。1992年3月，内核1.0版本的推出，标志着Linux第一个正式的版本的诞生。

它主要受到Minix和Unix思想的启发，是一个基于POSIX的多用户、多任务、支持多线程和多CPU的操作系统。
伴随着互联网的发展，Linux得到了来自全世界软件爱好者、组织、公司的支持。它除了在服务器方面保持着强劲的发展势头以外，在个人电脑、嵌入式系统上都有着长足的进步。使用者不仅可以直观地获取该操作系统的实现机制，而且可以根据自身的需要来修改完善Linux，使其最大化地适应用户的需要。
Linux不仅系统性能稳定，而且是开源软件。其核心防火墙组件性能高效、配置简单，保证了系统的安全。在很多企业网络中，为了追求速度和安全，Linux不仅仅是被网络运维人员当作服务器使用，甚至当作网络防火墙，这是Linux的一大亮点。
Linux是一款免费的操作系统，这意味着任何的时间和需要的地点它都要比其他操作系统更容易安装。不用担心购买网站授权并受到数字版权管理的制约，这对所有类型的组装机器以及服务器配置的测试变得更加直接。
Linux让开展各种实际有用且具有创造性的事情成为可能。例如，你可以在一个U盘上装载LINUX的自生系统引导映像，启动一台硬盘已经崩溃的计算机，之后查找并解决该问题。或者，因为LINUX是一个真正的多用户操作系统，它具有非常好的私密性和稳定性，整个团队可以同时从本地或远程登录进行工作。
Linux的构建采用了一些与UNIX操作系统相同的技术，并带有大多数与深度成熟的UNIX操作系统相一致的工具。这极大地增加了稳定性和安全性。LINUX的发行版还提供了复杂的软件包管理系统，可以可靠地安装和维护每一个在线资源库中成千上万的免费软件应用。
Linux不仅是免费的，更是开源的，这意味着任何人都可以获得其代码并根据自己的需求进行修改。事实上，已经孵化出专属LINUX各发行版的巨大生态系统。一个发行版是一个定制的软件包，它将LINUX内核以及用户计算机LINUX运行版的安装工具一起发布。它能运行主要的Unix工具软件、应用程序和网络协议。它支持32位和64位硬件。 Linux继承了Unix以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统。
Linux 的八大特点
 目前银行业务主要使用的操作系统是UNIX和Linux系统。这主要是由银行业务和UNIX和Linux系统的特点所致。
Linux系统是银行计算机中最常用的操作系统之一，同时也包含了Unix全部的功能和特性，银行及金融机构选择Linux系统的最主要原因是 Linux出色的稳定性和高速性，Linux可每天24小时、每年365天不间断地连续可靠工作，数年工作而无需重启，与经常死机的Windows相比，这一优点尤为突出，也正是金融业所需要的运行系统。
Linux的八大主要特点：
（1）开放性 是指系统遵循世界标准规范，特别是遵循开放系统互连（OSI）国际标准。凡遵循国际标准所开发的硬件和软件，都能彼此兼容，可方便地实现互连。同时免费，源代码开发也是被应用的重要条件之一。
（2）多用户、交互式的分时操作系统
不同的用户分别在不同的终端上，进行交互式操作，就好像各自独占主机一样。每个用户对自己的资源（例如：文件、设备）有特定的权限，互不影响。
（3）多任务
现代计算机的最主要的一个特点是同时执行多个程序，而且各个程序的运行互相独立。Linux系统调度每一个进程平等地访问微处理器。由于CPU的处理速度非常快，其结果是，启动的应用程序看起来好像在并行运行。事实上，从处理器执行一个应用程序中的一组指令到Linux调度微处理器再次运行这个程序之间只有很短的时间延迟，用户感觉不出来的。
（4）良好的用户界面
Linux向用户提供了两种界面：用户界面和系统调用。Linux的传统用户界面是基于文本的命令行界面，即shell，它既可以联机使用，又可存在文件上脱机使用。shell有很强的程序设计能力，用户可方便地用它编制程序，从而为用户扩充系统功能提供了更高级的手段。可编程Shell是指将多条命令组合在一起，形成一个Shell程序，这个程序可以单独运行，也可以与其他程序同时运行。
系统调用内核提供的、功能十分强大的一系列的函数，用户可以在编程时直接使用Linux内核中系统提供的系统调用命令。系统通过这个界面为用户程序提供低级别、高效率的服务。Linux还为用户提供了图形用户界面。它利用鼠标、菜单、窗口、滚动条等设施，给用户呈现一个直观、易操作、交互性强的友好的图形化界面。
（5）设备独立性
操作系统把所有外部设备统一当作成文件来看待，只要安装它们的驱动程序，任何用户都可以像使用文件一样，操纵、使用这些设备，而不必知道它们的具体存在形式。当需要增加新设备时、系统管理员就在内核中增加必要的连接。这种连接（也称作设备驱动程序）保证每次调用设备提供服务时，内核以相同的方式来处理它们。当新的及更好的外设被开发并交付给用户时，操作允许在这些设备连接到内核后，就能不受限制地立即访问它们。设备独立性的关键在于内核的适应能力。其他操作系统只允许一定数量或一定种类的外部设备连接。而设备独立性的操作系统能够容纳任意种类及任意数量的设备，因为每一个设备都是通过其与内核的专用连接独立进行访问。
Linux是具有设备独立性的操作系统，它的内核具有高度适应能力，随着更多的程序员加入Linux编程，会有更多硬件设备加入到各种Linux内核和发行版本中。另外，由于用户可以免费得到Linux的内核源代码，因此，用户可以修改内核源代码，以便适应新增加的外部设备。
（6）丰富的网络功能
完善的内置网络是Linux一大特点。 Linux在通信和网络功能方面优于其他操作系统。其他操作系统没有如此紧密地和内核结合在一起的连接网络的能力，也没有内置这些联网特性的灵活性。而Linux为用户提供了完善的、强大的网络功能。
1． 支持Internet是其网络功能之一。Linux免费提供了大量支持Internet的软件，Internet是在Unix领域中建立并繁荣起来的，在这方面使用Linux是相当方便的，用户能用Linux与世界上的其他人通过Internet网络进行通信。
2． 文件传输是其网络功能之二。用户能通过一些Linux命令完成内部信息或文件的传输。
3． Linux不仅允许进行文件和程序的传输，它还为系统管理员和技术人员提供了访问其他系统的窗口。通过这种远程访问的功能，一位技术人员能够有效地为多个系统服务，即使那些系统位于相距很远的地方。
（7）可靠的系统安全
Linux采取了许多安全技术措施，包括对读、写控制、带保护的子系统、审计跟踪、核心授权等，这为网络多用户环境中的用户提供了必要的安全保障。
（8）良好的可移植性
Linux可移植性是指将操作系统从一个平台转移到另一个平台使它仍然能按其自身的方式运行的能力。Linux是一种可移植的操作系统，能够在从微型计算机到大型计算机的任何环境中和任何平台上运行。可移植性为运行Linux的不同计算机平台与其他任何机器进行准确而有效的通信提供了手段，不需要另外增加特殊的和昂贵的通信接口。


1.1 Linux在各领域的发展

Linux学习
Linux > 1 Linux系统的简介 >
1.1 Linux在各领域的发展

Linux在各领域发展的现状和趋势

1. Linux与开源软件
Linux是一种自由和开放源代码的类UNIX操作系统，该操作系统的内核由李纳斯.托瓦兹在1991年首次发布，之后，再加上用户空间的应用程序，就成为Linux操作系统。严格上讲，Linux只是操作系统内核本身，但通常采用“Linux内核”来表达该意思。而Linux则常用来指基于Linux内核的完整操作系统，它包括GUI组件（图形用户界面）和许多其他实用工具。
GNU通用公共许可协议，是一个广泛使用的自由软件许可协议条款。最初由理查德?斯托曼为GNU计划而撰写，GPL给出了计算机程序自由软件的定义，任何基于GPL软件开发衍生的产品在发布时必须采用GPL许可验证方式，且必须公开源代码。
Linux是自由软件和开放源代码软件发展中最著名的例子。只有遵循GNU GPL，任何个人和机构都可以自由地使用Linux的所有底层源代码，也可以自由地修改和再发布。随着Linux操作系统飞速发展，在Linux上各种集成的开源软件和实用工具也得到了应用和普及，因此，Linux也成为开源软件的代名词。

开源软件简介
 开源软件和免费软件的区别
开源软件是指在软件发行的时候，附上软件的源代码，并授权允许用户更改/自由再散布/衍生著作，开源并不抵制商业收费。
免费软件就是免费提供给用户使用的软件，但是其免费的时候，通常都会有其他的限制，比如其源码不一定会公开，而且使用者也并没有使用、复制、研究、修改和再散布的权利.
Linux常用的开源软件

开源软件 | 作用 | 开源软件 | 作用
Apache | web服务器 | Nginx | web服务器
MySQL | 数据库(SQLsever Oracle) | PHP | 脚本语言
Samba | Linux和windows之间的内网文件服务器 | MongoDB | NoSQL数据库
Ruby | 脚本语言 | Python | 脚本语言
Sphinx | 中文分词 |  |

开源软件使用的自由，绝大多数开源软件免费，研究的自由，可以获得软件源代码，散布及改良的自由，可以自由传播、改良甚至销售
2. Linux在服务器领域的发展
 随着开源软件在世界范围内影响力日益增强，Linux服务器操作系统在整个服务器操作系统市场格局中占据了越来越多的市场份额，已经形成了大规模市场应用的局面，并且保持着快速的增长率，尤其在政府、金融、农业、交通、电信等国家关键领域。此外，考虑到Linux的快速成长性以及国家相关政策的扶持力度，Linux服务器产品一定能够冲击更大的服务器市场。
据权威部门统计，目前Linux在服务器领域已经占据75%的市场份额。同时，Linux在服务器市场的迅速崛起，已经引起全球IT产业的高度关注，并以强劲的势头成为服务器操作系统领域中的中坚力量。
3. Linux在桌面领域的发展
近年来，特别在国内市场，Linux桌面操作系统的发展趋势非常迅猛。国内如中标麒麟Linux、红旗Linux、深度Linux等系统软件厂商推出的Linux桌面操作系统，目前已经在政府、企业、OEM等领域得到了广泛应用。另外，SUSE、Ubuntu也相继推出了基于Linux的桌面系统，特别是Ubuntu Linux，已经积累了大量的社区用户。但是，从系统的整体功能、性能来看，Linux桌面系统与Windows系列相比还有一定差距，主要表现在系统易用性、系统管理、软硬件兼容性、软件的丰富程度等方面。
4. Linux在移动嵌入式领域的发展
Linux的低成本、强大的定制功能以及良好的可移植性，使Linux在嵌入式系统方面得到了广泛应用，目前Linux已广泛应用于手机、平板电脑、路由器、电视和电子游戏机等领域。在移动设备上广泛使用的Android操作系统就是创建在Linux内核之上的。目前，Android操作系统的全球市场份额已达84.6%。
此外，思科公司在网络防火墙和路由器中也使用了定制的Linux，阿里云也开发了一套基于Linux的操作系统“YunOS”，可用于智能手机、平板电脑和网络电视；常见的数字视频录像机、舞台灯光控制系统等都在逐渐采用定制版本的Linux来实现，而这一切均归功于Linux与开源的力量。
5. Linux在云计算/大数据领域的发展
互联网产业的迅猛发展，促使云计算、大数据产业的形成并快速发展，云计算、大数据作为一个基于开源软件的平台，Linux占据了核心优势。据Linux基金会的研究，86%的企业已经使用Linux操作系统进行云计算、大数据平台的构建。目前，Linux以开始取代UNIX成为最受青睐的云计算、大数据平台操作系统。


1.2 常见的Linux发行版本

Linux学习
Linux > 1 Linux系统的简介 >
1.2 常见的Linux发行版本

常见的Linux发现版本

我们往往会被Linux众多版本搞得一头雾水，从技术上来说，李纳斯.托瓦兹开发的Linux只是一个内核。内核指的是一个提供设备驱动、文件系统、进程管理、网络通信等功能的系统软件，但一个内核并不是一套完整的操作系统，它只是操作系统的核心。一些组织或厂商将Linux内核和各种软件和文档包装起来，并提供系统安装界面和系统配置、设定与管理工具，就构成了Linux的发行版本。
Linux的发行版本大体分为两类：一类是商业公司维护的发行版本，另一类是社区组织维护的发行版本。前者以著名的Red Hat为代表，后者以Debian为代表。

1. Red Hat Linux

Red Hat Linux 是Red Hat最早发行的个人版本的Linux，其1.0版本于1994年11月3日发行。虽然其历史不及其他Linux发行版本悠久，但比起很多的Linux发行套件，Red Hat的历史要悠久得多。自从Red Hat 9.0版本发布后，Red Hat公司就不再开发桌面版的Linux发行套件，Red Hat Linux停止了开发，而将全部力量集中在服务器版本的开发上，也就是Red Hat Enterprise Linux版。2004年4月30日，Red Hat公司正式停止对Red Hat 9.0版本的支援，这标志着Red Hat Linux的正式完结。原本的桌面版Red Hat Linux发行套件与来自开源社区的Fedora进行合并，成为Fedora Core发行版本。

目前Red Hat分为两个系列：由Red Hat公司提供收费技术支持和更新的Red Hat Enterprise Linux，以及由社区开发的免费的Fedora Core。

Red Hat 官方网站： http://www.redhat.com

2. Fedora Core

Fedora Core(FC)被Red Hat公司定位为新技术的测试平台，许多新技术都会在FC中检验。如果这些新技术稳定，Red Hat公司则会考虑加入到Red Hat Enterprise Linux中。

Fedora Core 1 发布于2003年年末，而FC的定位便是桌面用户。FC提供了最新的软件包，同时它的版本更新周期也非常短，仅有6个月。由于版本更新频繁，性能和稳定性得不到保证，因此一般在服务器上不推荐采用Fedora Core。

对于用户而言，Fedora是一套功能完备、更新迅速的免费操作系统，因此，个人领域的应用，例如开发、体验新功能等，可选择此发行版本。

3. Red Hat Enterprise Linux

Red Hat Enterprise Linux（RHEL，Red Hat的企业版Linux）。Red Hat现在主要做服务器版的Linux开发，在版本上注重性能和稳定性,以及对硬件的支持.由于企业版操作系统的开发周期较长，注重性能、稳定性和服务端软件支持，因此版本更新相对较缓慢。

RHEL 的版本基于Fedora。大约发布六个新版本的Fedora后就会有一个新版本的RHEL发布，因此，RHEL大约3年发布一个新版本。目前最新版本是2015年3月6日发布的RHEL7.1。

4. CentOS

CentOS 全名为“社区企业操作系统”（Community Enterprise Operating System），它由来自于RHEL依照开发源代码规定发布的源代码编译而成，由于RHEL是商业产品，因此必须讲个Red Hat的所有Logo改成自己的CentOS标识，这就产生了CentOS操作系统。两者的不同在于，CentOS并不包含封闭源代码软件。因此，CentOS不但可以自由使用，而且能享受CentOS提供的长期免费升级和更新服务。这是CentOS的一个很大的优势。

CentOS 从RHEL的源代码包来构建，它的版本号有两部分：主要版本和次要版本，主要版本和次要版本号分别对应于RHEL的主要版本与更新包。例如，CentOS 6.5构建在RHEL6.0更新的第5版上。但是从RHEL7.0版本以后，CentOS版本命名格式又稍有变化：主要版本任然对应于RHEL的主要版本，次要版本以RHEL更新包发布日期为准。例如，RHEL7.1对应的CentOS版本为CentOS 7.1.1503，这表示RHEL7.1版本是2015年3月发布的。

在2014年CentOS宣布与Red Hat合作，但CentOS将会在新的委员会下继续运作，并不受RHEL的影响。这个策略表明CentOS后续发展将由Red Hat作为强有力的支持。

CentOS 官方网站： http://www.centos.org

5. SUSELinux

SUSE 是德国最著名的Linux发行版，也享有很高的声誉，不过命运相当坎坷。2003年11月4日，Novell公司对外宣布收购SUSE。2004年1月，该收购顺利完成，Novell同时将SUSE正式命名为SUSE Linux。Novell公司收购SUSE，加速了SUSE Linux的发展，将免费SUSE Linux改为openSUSE社区项目。但在2010年，Attachmate公司收购了Novell公司，在被收购后，SUSE Linux发展受阻。而就在3年后，SUSE再次易主，2014年9月，Attachmate公司被上市公司Micro Focus收购，但幸运的是，SUSE官方宣布开源作为SUSE的发展之本，仍将继续贡献开源，SUSE仍将全力支持openSUSE。

虽然SUSE多次易主，但并不影响它的专业性。据不完全统计，SUSE Linux现在欧洲Linux市场中占有将近80%的份额，大部分关键应用都是建立在SUSE Linux下的。而由于SUSE多次易主，再加上SUSE在中国的营销模式问题，现在SUSE在中国的Linux市场份额并不大，但是这些并不影响SUSE Linux高可靠性与稳定性的事实。随着SUSE的发展，相信SUSE Linux在中国的应用会越来越多。

SUSE官方网站： https://www.suse.com
OpenSUSE官方网站： http://www.opensuse.org

6. Ubuntu Linux

Ubuntu（中文谐音为“友帮拓”、“优般图”、“乌班图”）是一个以桌面应用为主的Linux操作系统，基于Debian GNU/Linux，Ubuntu旨在为一般用户提供一个由自由软件构建而成的最新的同时又相当稳定的操作系统。Ubuntu具有庞大的社区力量，用户可以方便地从社区获得帮助。

Ubuntu官方网站： http://www.ubuntu.com

7. 发行版本总结

上面主要介绍了几种最常见的Linux发行版本，其实Linux的发行版本还有很多，比较常见的还有Debian GNU/Linux、Mandriva、Gentoo、Slackware、Knoppix、MEPIS和Xandros，以及国产的红旗Linux、深度Linux和中标麒麟Linux等，其实纵观LINUX的各个发行版，Linux发行版本无非是朝着这两个方面发展，一是服务器市场，二是桌面市场。

以Ubuntu Linux为代表的Linux发行版本走的是桌面市场路线，虽然它们给用户带来很多惊喜，更新也很快，但是由于桌面市场有Windows这样强劲的对手，因此Linux桌面市场的发展不容乐观。目前Ubuntu Linux也开始向企业级服务器市场发力。

以Red Hat系列版本为代表的Linux发行版现在主要面向企业级Linux的服务器市场，重点开发Linux的企业版本，其他的发行版（例如，国产红旗Linux、中标麒麟Linux等）都重点投入在了Linux服务器市场。Linux两大发布厂商现在都走了Linux服务器市场的路线，可见Linux作为企业级服务器有着巨大的发展前途。据权威部门统计，Linux在服务器市场的占有率每年都在持续上升。


1.3 初学者应该选择的版本

Linux学习
Linux > 1 Linux系统的简介 >
1.3 初学者应该选择的版本

初学者入门应该选择哪种版本的Linux

1.初学者入门首选——CentOS系列
? CentOS现在拥有庞大的网络用户群体，学习遇到问题，在网络上可以较容易地搜索到解决方法
? CentOS系列版本可以轻松获得。
? CentOS应用范围广，具有典型性和代表性。
2.桌面平台首选——Ubuntu Linux
 Linux桌面市场，Ubuntu Linux几乎占据了桌面Linux的半壁江山，Ubuntu Linux主打Linux桌面之最，界面美观，简洁而不失华丽。如果想在Linux下进行娱乐休闲，Ubuntu Linux绝对是首选。
3.企业级应用首选——RHEL/CentOS系列
 企业应用追求的是可靠性和稳定性，这就要求构建企业级应用的系统平台具有高可靠性和高稳定性。
RHEL与CentOS两个Linux发行版本，并没有太大差别，所不同的是，RHEL属于商业Linux发行版本，如果要使用RHEL版本，则需要购买商业授权和咨询服务，Red Hat公司提供系统的技术支持并提供系统的免费升级。而CentOS属于非商业发行版，可以从网上免费下载。


1.4 我们该怎么学习Linux

Linux学习
Linux > 1 Linux系统的简介 >
1.4 我们该怎么学习Linux

我们该怎么学习Linux系统

开始Linux的学习之后，请不要用Windows的工作方式来思考问题，因为它们之间确实有很大的不同，比如，它们之间的内存管理机制、进程运行机制等都有很大的不同。
1. 一定要习惯命令行方式
 Linux是由命令行组成的操作系统，精髓在命令行，无论图形界面发展到什么水平，命令行方式的操作永远是不会变的。Linux命令有许多强大的功能：从简单的磁盘操作、文件存取，到复杂的多媒体图像和流媒体文件的制作，都离不开命令行。虽然Linux也有桌面系统，但是X-Window也只是运行在命令行模式下的一个应用程序。
因此，可以说命令是学习Linux系统的基础，在很大程度上，学习Linux就是学习命令，很多Linux高手其实都是精通命令的人。
也许对于刚刚从Windows系统转向Linux系统的初学者来说，立刻进入枯燥的命令学习实在太难，但是一旦学会就会爱不释手，因为它的功能实在是太强大了。
2. 理论结合实践
 有很多初学者都会遇到这么一个问题，自己对系统的每个命令都很熟悉，但是在系统出现故障的时候，就无从下手了，甚至不知道在什么时候用什么命令去检查系统，这是很多Linux新手最无奈的事情了。归根到底，就是学习的理论知识没有很好地与系统实际操作相结合。
很多Linux知识，例如每个命令的参数含义，看起来也很容易理解，但是一旦组合起来使用，并不那么容易，没有多次的动手练习，其中的技巧是无法完全掌握的。
人类大脑不像计算机的硬盘，除非硬盘坏掉或者硬盘格式化，否则存储的资料将永远记忆在硬盘中，而且时刻可以调用。而在人类记忆的曲线中，必须要不断地重复练习才会将一件事情记得比较牢。学习Linux也一样，如果无法坚持学习，就会学了后面的，忘了前面的。还有些Linux初学者也学了很多Linux知识，但是由于长期不用，导致学过的东西在很短的时间内又忘记了，久而久之，失去了学习的信心。
可见，要培养自己的实战技能，只有勤于动手，肯于实践，这也是学好Linux的根本。
3. 学会使用Linux联机帮助
各个Linux发行版本的技术支持时间都比较短，这对于Linux初学者来说往往是不够的。其实，当安装了完整的Linux系统后，其中已经包含了一个强大的帮助，只是可能你还没有发现它，或者还没有掌握使用它的技巧。例如，如果对于tar命令的使用不是很熟悉，那么只要在命令行输入“man tar”，就会得到tar的详细说明和用法。
主流的Linux发行版本都自带了非常详细的帮助文档，包括使用说明和FAQ，从系统安装到系统的维护，再到系统安全，针对不同层次用户的详尽文档。仔细阅读文档后，60%的问题都可以在这里得到解决。
4. 学会独立思考问题，独立解决问题
遇到问题，首先想到的应该是如何自己去解决这个问题，解决方式有很多。比如，看书、查资料、上网搜索和浏览技术论坛等，通过这几种方式，90%的问题都能得到解决。
独立思考并解决问题，不但锻炼了自己独立解决问题的能力，而且在技术上能得到快速提高。如果通过以上方式实在解决不了，可以向人询问，得到答案后要思考为何这么做，然后做笔记记录解决过程。最忌讳的方式只要遇到问题，就去问人，虽然这样可能会很快解决问题，但是长久下去，遇到问题就会依赖别人，技术上也不会进步。
5. 学习专业英语
如果想深入学习Linux，一定要尝试查看英文文档。因为，技术性的东西写得最好、最全面的文档都是英文版的，最先发布的高新技术也都是用英语写的。即便是非英语国家的人发布技术文档，也都首先翻译成英语在国际学术期刊和网络上发表。安装一个新的软件时先看Readme文档，再看Install文档，然后看FAQ文档，最后才动手安装，这样遇到问题就知道原因了。因此，学习一点专业英语是很有必要的。

6. Linux学习路线图


1.5 工作中我们需要的技能

Linux学习
Linux > 1 Linux系统的简介 >
1.5 工作中我们需要的技能

工作中我们需要的技能

1. 用户的管理及权限管理

2.赋权操作：用户赋予权限、文件赋予权限

3.文件编辑：vi命令

4.文件上传及下载：FTP命令

5.执行脚本：shell脚本的编写及执行

6.文件查找

7.进程管理

8.任务调度

9. 网络状态监控

10.常规命令掌握


2 Linux系统基本结构

Linux学习
Linux >
2 Linux系统基本结构

Linux系统基本结构

1. Linux系统控制台的使用

2. Linux文件系统结构介绍

3.Linux系统核心组件介绍

4.Linux系统运行机制介绍


2.1 Linux系统控制台的使用

Linux学习
Linux > 2 Linux系统基本结构 >
2.1 Linux系统控制台的使用

Linux系统控制台的使用

Linux系统由桌面控制台和字符控制台 组成，桌面系统其实就是我们安装软件包时的X-Window视窗，而X-Window的实质是在命令行下运行的一个应用程序。字符控制台式Linux系统的核心，大部分操作都是在字符界面下完成的。
默认Linux下有6个字符控制台，每个控制台可以独立作业，互不影响，这真正体现了Linux系统的“多用户、多任务”的特性。在图形界面下要切换到字符界面时，只需要按Ctrl+Alt+F1~F6组合键中的任何一个，即可进入字符界面。相反，如果要从字符界面切换到X-Window下，可以在字符界面的命令行中输入“startx”或者按Ctrl+Alt+F7组合键即可 。
Linux下图形界面的发展还不是很完善，与Window相比，功能上还有很多欠缺，因而在操作上有很大限制，很多复杂的操作无法在图形界面下完成，所以养成在字符界面下工作的习惯是非常必要的。
Linux系统的默认管理员用户是root ，与windows的管理用户Administrator类似，root用户可以操作系统的任何文件和设备，拥有最高权限。输入登录的用户名root，然后输入对应的密码，即可登录Linux系统。


2.2 Linux文件系统结构介绍

Linux学习
Linux > 2 Linux系统基本结构 >
2.2 Linux文件系统结构介绍

Linux文件系统结构介绍

目录结构

l / ：Linux 系统的根目录。

l /root ：该目录为系统管理员目录,如果用户是以超级用户的身份登录的，这个就是超级用户的主目录，设置成较高安全等级

l /bin ：存放系统预装的可执行程序，或用户一般使用程序，这里存放的可执行文件可以在系统的任何目录下执行。如ls，mv，rm等常用执行文件，有时内容与/usr/bin一样（使用链接文件）

l /dev：dev 是设备（device）的英文缩写，这个目录对所有的用户都十分重要，因为在这个目录中包含了所有Linux系统中使用的外部设备，Linux中的设备也是以文件的形式存在的，但是这里并不是放的外部设备的驱动程序

l /home ：用户的主目录，如果建立一个用户，用户名是“jl”,那么在/home目录下就有一个对应的/home/jl路径，用来存放用户的主目录，也叫作用户的根目录，用户登录以后，默认打开自己的根目录。

l /lib ：lib是库（library）英文缩写。这个目录是用来存放系统动态连接共享库的，其作用类似于 Windows 里的 DLL 文件，几乎所有的应用程序都会用到这个目录下的共享库

l /mnt ：这个目录在一般情况下也是空的，系统提供该目录是为了让用户临时挂载别的文件系统，我们可以将光驱挂载在 /mnt/ 上，然后进入该目录就可以查看光驱里的内容。

l /proc ：可以在这个目录下获取系统信息，这些信息是在内存中，由系统自己产生的。

l /run ：是一个临时文件系统，存储系统启动以来的信息。当系统重启时，这个目录下的文件应该被删掉或清除。如果你的系统上有 /var/run 目录，应该让它指向 run。

l /srv ：存放服务启动后需要提取的数据（不用服务器就是空）

l /tmp ：用来存放不同程序执行时产生的临时文件。

l /var：系统中的可变文档的存放位置，这个目录存放在不断扩充的东西，我们习惯将那些经常被修改的文件存放在该目录下，比如运行的各种日志文件、未读邮件等。

l /boot ：在这个目录存放启动Linux时使用的一些核心文件，包括一些连接文件机镜像文件，都是系统启动时要用到的程序。在使用grub或lilo引导linux的时候，会用到这里的一些信息

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

l /etc ：etc这个目录是linux系统中最重要的目录之一。在这个目录下存放了系统管理时要用到的各种配置文件和子目录。我们要用到的网络配置文件，文件系统，x系统配置文件，设备配置信息，设置用户信息等都在这个目录下

/etc/rc.d：这个路径主要在记录一些开关机过程中的 scripts 档案， scripts 有点像是DOS 下的批次档（.bat檔名）

/etc/rc.d/init.d：所以服务预设的启动 scripts 都是放在这里的，例如要启动与关闭iptables 可以：

/etc/rc.d/init.d/iptables start

/etc/rc.d/init.d/iptables stop

/etc/X11：这是与 X windows 有关的设定文件所在的目录，如XF86Config-4

l /media：类windows的其他设备，例如U盘、光驱等等，识别后linux会把设备放到这个目录下。

l /opt：存放 Linux 中额外安装的软件。比如安装的 MySQL 数据库就可以放到这个目录下，该目录默认为空。

l /sbin：只有系统管理员能使用的程序和指令

l /sys： 这是linux2.6内核的一个很大的变化。该目录下安装了2.6内核中新出现的一个文件系统 sysfs 。sysfs文件系统集成了下面3种文件系统的信息：针对进程信息的proc文件系统、针对设备的devfs文件系统以及针对伪终端的devpts文件系统。该文件系统是内核设备树的一个直观反映。当一个内核对象被创建的时候，对应的文件和目录也在内核对象子系统中

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

l /usr ：Linux 的系统资源目录，里面存放的是一些系统可执行文件或者系统的一些文件库。这是linux系统中占用硬盘空间最大的目录，相当于windows下的program files目录

/usr/bin：放置可执行程序，这个目录的档案与 /bin 几乎是相同的

/usr/sbin：放置管理者使用程序，与 /sbin 类似的功能

/usr/include：一些套件的头文件，以源代码形式安装程序时通常会用到

/usr/lib：许多程序与子程序所需的函数库

/usr/local：软件升级后常用的安装目录，可执行文件通常放在

/usr/local/bin

/usr/share/doc：系统说明文档

/usr/share/man：man工具文档放在路径

/usr/src：编译系统时，源代码存放的位置

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

l /lost+found：系统产生异常错误时，会将一些遗失的片段放在该目录下


2.3 Linux系统核心组件介绍

Linux学习
Linux > 2 Linux系统基本结构 >
2.3 Linux系统核心组件介绍

Linux系统核心组件介绍

指挥Linux系统稳定有序运行的核心是Linux内核，这个内核相当于Linux的“大脑”，Linux操作系统就是在Linux内核上发展壮大起来的，我们平时所说的Linux系统的高可靠和高稳定性都是针对内核来讲的。因此，内核的组成和构架就成为每个Linux爱好者共同关心的问题。

Linux内核的官方网站是https://www.kernel.org/，从20世纪90年代初由Linux发布第一版开始，经过开源社区和Linux爱好者十几年的共同努力，现在已经发展到了最新的4.1内核。它已经从Linux作为学习Intel 386架构的一个项目发展成一个完全可以商用的成熟操作系统。目前基于Linux的服务器应用、移动应用已经遍布在生活的各个角落。

Linux是一款开源操作系统，这就给了我们一个非常难得的机会去学习一个成熟的、商用的操作系统是如何实现的。一个完整的Linux内核一般由5个部分组成，它们分别是内存管理、进程管理、进程间通信、虚拟文件系统和网络接口。

1. 内存管理

内存管理主要完成的是如何合理有效地管理整个系统的物理内存，同时快速响应内核各个子系统对内存分配的请求。Linux内存管理支持虚拟内存，即在系统上运行的所有程序占用的内存总量可以大于实际物理内存，而多余出的这部分内存就是通过磁盘申请得到的，平时系统只把当前运行的程序块保留在内存中，其他程序块则保留在磁盘中。在内存紧缺时，内存管理负责在磁盘和内存间交换程序块。

2. 进程管理

进程管理主要控制系统进程对CPU的访问，当需要某个进程运行时，由进程调度器根据基于优先级的调度算法启动新的进程，Linux支持多任务运行。那么如何在单个CPU上支持多任务呢？这个工作就是由进程调度管理来完成的。在系统运行时，每个进程都会分得一定的时间片，然后进程调度器根据时间片的不同，选择每个进程依次运行。例如，当某个进程的时间片用完后，调度器会选择一个新的进程继续运行。由于切换的时间和频率都非常快，因此用户感觉是多个程序在同时运行。而实际上，CPU在同一时间内只有一个进程在运行，这一切都是进程调度管理的结果。

3. 进程间通信

进程间通信主要用于控制不同进程之间在用户空间的同步、数据共享和交换。由于不同的用户进程拥有不同的进程空间，因此进程间的通信要借助于内核的中转来实现。一般情况下，当一个进程等待硬件操作完成时，它会被挂起。当硬件操作完成后，进程被恢复执行，而协调这个过程的就是进程间的通信机制。

4. 虚拟文件系统

Linux内核中的虚拟文件系统用一个通用的文件模型表示各种不同的文件系统，这个文件模型屏蔽了很多具体文件系统的差异，使Linux内核支持很多不同的文件系统。虚拟文件系统可以分为逻辑文件系统和设备驱动程序。逻辑文件系统指Linux所支持的文件系统，如ext2、ext3、ext4、xfs和fat等；设备驱动程序指为每一种硬件控制器所编写的设备驱动程序模块。

5. 网络接口

网络接口提供了对各种网络标准的实现和各种网络硬件的支持。网络接口一般分为网络协议和网络设备驱动程序。网络协议部分负责实现每一种可能的网络传输协议。网络设备驱动程序则主要负责与硬件设备进行通信，每一种可能的网络硬件都有相应的设备驱动程序。


2.4 Linux系统运行机制介绍

Linux学习
Linux > 2 Linux系统基本结构 >
2.4 Linux系统运行机制介绍

Linux系统运行机制介绍

Linux运行机制，主要包括初始化init系统、系统的运行级别、系统的关闭方法等。

1. Linux初始化init系统
Linux操作系统的启动首先从BIOS开始，接下来Linux引导程序将内核映像记载到内存，进行内核初始化，内核初始化的最后一步就是启动PID为1的init进程。这个进程是系统的第一个进程，它负责产生其他所有用户进程。
仅仅将内核运行起来是毫无用途的，因此就需要一个系统能够定义、管理和控制init进程的行为，并负责组织和运行许多独立的或相关的初始化工作，从而让系统进入一个用户设定的运行模式中，这个系统就是init系统。
大多数Linux发行版的init系统是和System V相兼容的，因此称为sysvinit。这是最早也是最流行的init系统。在RHEL7.x/CentOS7.x发行版之前的系统都采用sysvinit，sysvinit概念简单清晰，主要依赖于Shell脚本，但它一次一个串行地启动进程，这导致了它的最大弱点：启动太慢。虽然在服务器上这个缺点不算什么，但是当Linux被应用到移动终端设备上时，这个缺点就变成了大问题。为了能更快地启动系统，开发者对sysvinit进行了不断的改进，先后出现了upstart和systemd这两个主要的新一代init系统，以Ubuntu为代表的Linux发行版就采用的是upstart方式，而在RHEL7.x/CentOS7.x版本中，已经默认开始采用systemd来管理系统。Upstart出现很早，而systemd出现较晚，但发展更快，大有取代upstart的趋势。

2. runlevel到target的改变

Windows系统有安全运行模式和正常运行模式，这是两个不同的运行级别。同样，Linux也有系统运行级别，并且Linux系统的运行级别更加灵活，更加多样化。

Sysvinit用术语“runlevel”来定义系统运行级别。在RHEL 7.x/CentOS 7.x版本之前的系统中，通常有7种运行级别，这些运行级别均在/etc/inittab文件中指定，sysvinit程序通过检查/etc/inittab文件中是否包含有“initdefault”项来启动一个默认的运行级别。

每个Linux发行版对运行级别的定义都不太一样。但0/1/6三个级别获得了共识：

l 0表示关机模式

l 1表示单用户模式，单用户模式下只有系统管理员可以登录

l 6表示重启模式，也就是关闭所有运行的进程，然后重新启动系统。

另外4个运行级别，RHEL/CentOS发行版定义的含义如下：

l 2表示多用户模式，不支持文件共享，例如不支持NFS服务。这种模式不常用。

l 3表示完全的多用户模式，支持NFS服务，这是最常用的用户模式，默认登录到系统的字符界面。

l 4表示基本不用的用户模式，可以实现某些特定的登录请求。

l 5表示完全多用户模式，默认登录到X-Window系统，也就是登录到Linux图形界面。

这些运行级别和Linux中init程序相互对应。例如，执行“init 1”命令系统就进入单用户模式，执行“int6”命令系统将重新启动。

在RHEL 7.x/CentOS 7.x版本中，由于采用了systemd管理体系，因此以前运行级别（runlevel）的概念被新的运行目标（target）所取代，target的命名类似于“multi-user.target”这种形式，比如原来的运行级别3（runlevel3）对应于新的多用户目标“multi-user.target”，运行级别5（runlevel5）就对应于“graphical.target”。因为systemd机制中不再使用runlevel的概念，所以/etc/inittab也不再被系统使用。

在新的systemd管理体系里，默认的target（相当于以前的默认运行级别）通过软链接来实现。

例如，要查看系统的默认target，可以执行

由此可知，现在系统的默认 target为“graphical.target”，相当于“runlevel5”，如果要修改默认 target为“multi-user.target”，可以先删除存在的软链接，然后重新建立软链接指向到“multi-user.target”即可

要查看运行级别与target的对应关系，可以执行“ll /lib/systemd/system/runlevel*.target”命令

从图中可知，有5中target模式。其中，poweroff.target对应runlevel0，表示关机模式；rescue.target对应runlevel1，表示单用户模式或救援模式；multi-user.target对应runlevel2/runlevel3/runlevel4，表示多用户模式；graphical.target对应runlevel5，表示图形界面多用户模式，reboot.target对应runlevel6，表示重启系统模式。

3. 系统关机过程

在Linux系统下一些常用的关机/重启命令有shutdown/halt/reboot以及init，他们都可以达到重启系统的目的，但每个命令的内部工作过程不同。

1. shutdown命令

Shutdown命令是安全地将系统关机，在系统关机前使用shutdown命令，系统管理员会通知所有登录的用户系统将要关闭，并且login指令会被冻结，即新的用户不能再登录。直接关机或是延时一段时间关机都是可以的，也可以进行重启。

有些初学者会使用直接关闭电源的方法来关闭Linux，这是非常危险的，因为Linux与Windows不同，在Linux后台运行很多进程，这些进程控制这Linux对系统的各种操作，如果强制关机，可能会造成进程的混乱以至于丢失数据。如果在系统工作负荷很高的情况下突然断电，不仅会丢失数据，甚至还会损坏硬件设备。

Shutdown命令是用shell编写的程序，必须由超级用户才能执行。Shutdown执行的工作是送信号给init程序，要求它改变运行级别来实现。Runlevel0被用来停机，runlevel6用来重启系统。而runlevel1则是用来使系统计入执行系统管理任务状态，如果没有给出 –h 或-r标志时这是shutdown命令的默认工作状态。如果想要了解停机或重新开机过程中做了哪些动作，可以在/etc/inittab里看到关于这些runlevel的信息。

命令语法：shutdown [-arkhncfF(参数名称)] [-t sec(秒数)] time [warning-message(警告信息)]

各参数的含义：

-a 使用 /etc/shutdown.allow 来验证身份。

-t sec 通知 init(8) 在转换到其它运行级别前，发送警告 (warning) 信号后延时 (sec) 秒数后再发送关闭 (kill) 信号。

-k 并非真正关机，只向所有人显示警告信息。

-r 重启。

-h 停机。

-n 不调佣init程序关机，而是有shutdown自己进行（一般关机程序有shutdown调用init来实现关机动作的），使用此参数将加快关机速度，但是不建议用户使用此种关机方式

-f 重启时跳过磁盘检测。

-F 重启时强制磁盘检测。

-c 取消前一个shutdown命令。例如，当执行一个如“shutdown –h 15:30”的命令时，只要按Ctrl+C组合键就可以中断关机的命令；而执行如“shutdown –h 15:30&”的命令时，就将shutdown 转到后台运行了，此时就需要使用“shutdown -c”将前一个shutdown命令取消

time 关机时间。

warning-message 发送给所有用户的消息。

范例：关机命令

Shutdown –r now --重新启动系统

Shutdown –h now --立即关机

Shutdown +15 --15分钟后关机

Shutdown +5 "System will shutdown after 5 minutes" --设定5分钟后关机，并发警告信息

2. halt命令

halt是最简单的关机命令，相当于“shutdown -h”组合。halt执行时，会杀死应用进程，执行sync系统调用，文件系统写操作完成后就会停止内核。

Halt --直接输入进行关机

3. reboot命令

Reboot命令用来重启系统，用法比较简单，在终端命令行以root用户执行该命令即可进行系统重启。

Reboot命令常用参数如下：

-n 在重启之前不执行磁盘刷新

-w 做一次重启模拟，并不会真的重新启动

-d 不把记录写到 /var/log/wtmp 档案里（ -n 参数包含了 -d）

-f 强制重开机

-i 在重开机之前先把所有网络相关的装置停止

reboot --直接输入进行重启

4. init命令

init程序主要用于系统不同运行级之间的切换，切换的工作是立即完成的。例如，init 0就是将系统运行级别切换到0，也就是关机；init6命令用于将系统运行级别切换到6，也就是重启系统。


3 Linux常用命令

Linux学习
Linux >
3 Linux常用命令

Linux常用命令

1.文件处理命令

2.权限管理命令

3.文件搜索命令

4.帮助命令

5.用户管理命令

6.压缩解压命令

7.网络命令

8.关机命令


3.0 预备知识

Linux学习
Linux > 3 Linux常用命令 >
3.0 预备知识

预备知识

1.Linux的登录

我们来看看图中的每行所表示的是什么意思

第一行显示的是Linux发行商和所发布的版本
第二行显示的是该版本的Linux所使用的Linux内核，表示内核版本是3.10.0，其中3是主版本号，10是次要版本号，如果这个为偶数的话，就是一个稳定版本，所以在以后选择Linux的时候，一定要注意这个参数。最后的0为修订次数。
第三行显示的是我们这台电脑的名字，这里的193就是我们这台电脑的名称。
明白以上的一些参数之后，我们就可以登录了，首先在第三行的“193 login：”后面输入用户名，这里我们输入root，然后按ENTER，接着要求输入用户密码，输入密码后，如果密码正确，则会出现如下画面：

现在我们看看下面两行
Last login: 这行表示我们这个用户的上次登录的时间和位置
[root@192~]#这行的root:表示登录的用户是root用户
@：相当于at
192:表示所登录的服务器，一般为服务器名称
~：表示目前位于/root目录下
#：表示root的提示符号，普通用户为$


3.1 命令格式

Linux学习
Linux > 3 Linux常用命令 >
3.1 命令格式

命令格式：命令 [-选项] [参数]

例如： ls -la /etc

说明：

  • 个别命令使用不遵循此格式
  • 当有多个选项时，可以写在一起
  • 简化选项与完整选项

-a 等于 --all (完整选项用 -- 调用)


3.2.1 显示目录命令 ls

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 >
3.2.1 显示目录命令 ls

命令名称 ：ls

命令英文原意：list

命令路径： /bin/ls

执行权限：所有用户

功能描述：显示目录文件

-a 显示所有文件，包括隐藏文件(以 . 开始的文件就是隐藏文件)

-d 查看目录属性（针对目录）

-l 显示详细信息（long 长格式）

-h 人性化显示文件大小

-i (id编号，唯一标识)

范例：

这样屏幕上就立刻显示当前目录下的所有文件及自目录。注意你可能发现“Desktop”显示的颜色是蓝颜色，这里提示大家一下：

白色的文件：一般的文件

蓝色的文件：目录

绿色的文件：可执行文件

这种方法可以最直观的方法来识别文件类型。

查看详细信息：ls -l 或 ll [查看文件具体讲解，跳转到3.3]

查看所有隐藏文件及目录：ls -a

查看所有隐藏文件及目录的详细信息：ls -al

查看其他目录的信息：ls /

查看其他目录的详细信息：ls -l /


3.2.2 目录处理命令

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 >
3.2.2 目录处理命令

目录处理命令

mkdir | 创建新目录 mkdir -p
cd | 切换目录
pwd | 显示当前目录
rmdir | 删除空目录
cp | 复制文件或目录，更改名字 cp -r -p
mv | 剪切文件，改名
rm | 删除文件或目录 rm 删除文件 rm -r 删除目录


目录处理命令 mkdir

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 > 3.2.2 目录处理命令 >
目录处理命令 mkdir

目录处理命令 mkdir

命令名称：mkdir
命令英文原意：make directories
命令路径：/bin/mkdir
执行权限：所有用户
语法：mkdir -p [目录名]
功能描述：创建新目录
-p 递归创建（可以同时创建多个目录）

范例：

创建目录：[root@192 ~]# mkdir myfile

直接在本目录创建lianxi的目录：

[root@localhost ~]# mkdir lianxi

通过绝对路径在lianxi的目录中，同时创建cesi1和cesi2的目录：

[root@localhost ~]# mkdir /root/lianxi/cesi1 /root/lianxi/cesi2

注意：不要把目录弄的乱七八糟，应该有规划的创建。


目录处理命令 cd

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 > 3.2.2 目录处理命令 >
目录处理命令 cd

目录处理命令 cd

命令名称：cd
命令英文原意： change directory
命令路径：shell 内置命令
执行权限：所有用户
语法：cd [目录]
功能描述：切换目录
范例：

上面目录下面有两个奇怪的家伙，一个是 . 一个是 .. 其实这又要讲到路径的知识，路径的表示方法有两种：

A ：绝对路径：就是表示出目标文件或子目录的目录树结构。

这个目录的绝对路径表示方法为/root/lianxi，在lianxi 目录中还有其他两个目录cesi1和cesi2

这两个的绝对路径为/root/lianxi/cesi1和/root/lianxi/cesi2

B ：相对路径：就是相对于当前工作目录的路径来表示位置。相对路径中有两个符号，就是 .. .

..表示当前当前工作目录的上一层目录。如当前我们处在lianxi目录中，我们作如下操作：

. 表示当前的工作目录。如果当前我们处在lianxi目录中，那么 . 就表示当前的工作目录lianxi

切换目录

命令补全：cd c+[tab键] --->cd cesi1自动补全


目录处理命令 pwd

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 > 3.2.2 目录处理命令 >
目录处理命令 pwd

目录处理命令 pwd

命令名称：pwd
命令英文原意：print working directory
命令路径：/bin/pwd
执行权限：所有用户
语法：pwd
功能描述：显示当前目录

范例：

直接输入：pwd 显示绝对路径


目录处理命令 rmdir

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 > 3.2.2 目录处理命令 >
目录处理命令 rmdir

目录处理命令 rmdir

命令名称： rmdir
命令英文原意：remove empty directories
命令路径：/bin/rmdir
执行权限：所有用户
语法：rmdir [目录]
功能描述：删除空目录

范例：

[root@localhost cesi1]# rmdir /root/lianxi/cesi2 # 去除空目录
[root@localhost cesi1]# cd .. #返回上一层目录
[root@localhost lianxi]# ls #显示目录
cesi1


目录处理命令 cp

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 > 3.2.2 目录处理命令 >
目录处理命令 cp

目录处理命令：cp

命令名称： cp
命令英文原意：cope
命令路径：/bin/cp
执行权限：所有用户
语法： cp -rp [原文件或目录] [目标文件或目录]
-r 复制目录
-p 保留文件属性功能描
功能描述：复制文件或目录，更改名字
范例：

[root@localhost ~]# cp ps.txt /root/lianxi/cesi1 #把ps.txt文件复制到cesi1目录下
[root@localhost ~]# cd /root/lianxi/cesi1 #切换目录到cesi1目录
[root@localhost cesi1]# ls #显示目录中的文件
ps.txt

[root@localhost lianxi]# cp cesi1 cesi2 #将目录cesi1复制到目录cesi2中
cp: 略过目录"cesi1"
[root@localhost lianxi]# cd cesi2
[root@localhost cesi2]# ll
总用量 0

发现没有按照我们的意愿复制目录

现在就需要 -r 选项：复制目录

[root@localhost lianxi]# cp -r cesi1 cesi2 #将目录cesi1复制到目录cesi2中
[root@localhost lianxi]# cd cesi2
[root@localhost cesi2]# ls
cesi1
[root@localhost cesi2]# cd cesi1 #把我们刚才复制的文件也一同复制到了cesi2中
[root@localhost cesi1]# ls
ps.txt
[root@localhost cesi1]# cp ps.txt ps_bak.txt #复制并且重新命名
[root@localhost cesi1]# ls
ps_bak.txt ps.txt

保留文件属性 ，在Linux中文件的时间显示的是最后修改时间

[root@localhost cesi1]# ls -l
总用量 32
-rw-r--r--. 1 root root 14931 12月 2 13:33 ps_bak.txt
-rw-r--r--. 1 root root 14931 12月 2 12:43 ps.txt

我们在复制的时候如果不想要时间修改使用参数 -p

[root@localhost cesi1]# cp -p ps.txt ps_bak2
[root@localhost cesi1]# ls -l
总用量 48
-rw-r--r--. 1 root root 14931 12月 2 12:43 ps_bak2
-rw-r--r--. 1 root root 14931 12月 2 13:33 ps_bak.txt
-rw-r--r--. 1 root root 14931 12月 2 12:43 ps.txt

注意：可以同时复制多个文件，只要有目标文件就可以
大小写严格区分


目录处理命令 mv

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 > 3.2.2 目录处理命令 >
目录处理命令 mv

目录处理命令 mv

命令名称： mv
命令英文原意： move
命令路径：/bin/mv
执行权限：所有用户
语法：mv [原文件或目录] [目标目录]
功能描述：剪切文件、改名

范例：

[root@localhost cesi1]# mv ps_bak.txt /root/lianxi #移动ps_bak.txt文件到/root/lianxi目录下
[root@localhost cesi1]# cd /root/lianxi #切换目录
[root@localhost lianxi]# ls
cesi1 cesi2 ps_bak.txt


目录处理命令 rm

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 > 3.2.2 目录处理命令 >
目录处理命令 rm

目录处理命令 rm

命令名称：rm
命令英文原意：remove
命令路径：/bin/rm
执行权限：所有用户
语法： rm -rf [文件或目录]
-r 删除目录
-f 强制执行（不希望有询问）
功能描述：删除文件

范例：

[root@localhost cesi1]# ls
ps_bak2 ps.txt
[root@localhost cesi1]# rm ps_bak2 #删除文件ps_bak2
rm：是否删除普通文件 "ps_bak2"？y #系统询问是否删除，y同意，n不同意
[root@localhost cesi1]# ls
ps.txt

如果不希望系统询问使用 -f 选项

[root@localhost cesi1]# rm -f ps.txt #强制删除ps.txt文件
[root@localhost cesi1]# ls

删除目录，使用 -r 选项

[root@localhost cesi2]# rm -f cesi1 #强制删除cesi1目录
rm: 无法删除"cesi1": 是一个目录
[root@localhost cesi2]# rm -rf cesi1 #强制删除cesi1目录
[root@localhost cesi2]# ls

注意：谨慎操作、没有回收站可言、删除之前先备份


3.2.3 文件处理命令

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 >
3.2.3 文件处理命令

文件处理命令

touch | 创建空文件
cat | 显示文件内容
tac | 显示文件内容（反向列示）
more | 分页显示文件内容
less | 分页显示文件内容（可向上翻页，可以搜索）
head | 显示文件前面几行
tail | 显示文件后面几行


文件处理命令 touch

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 > 3.2.3 文件处理命令 >
文件处理命令 touch

文件处理命令 touch

命令名称：touch
命令英文原意：
命令路径：/bin/touch
执行权限：所有用户
语法：touch [文件名]
功能描述：创建空文件
范例：

[root@localhost lianxi]# touch program #在本目录下创建文件program
[root@localhost lianxi]# ls
cesi1 cesi2 program ps_bak.txt

[root@localhost lianxi]# touch /root/lianxi/cesi1/program_bak #指明路径创建program_bak
[root@localhost lianxi]# cd cesi1 #切换到cesi1目录中
[root@localhost cesi1]# ls
program_bak ps.txt

创建带空格的文件：

[root@localhost cesi1]# touch program file #同时创建两个文件program file
[root@localhost cesi1]# ls
file program program_bak ps.txt
[root@localhost cesi1]# touch "program file" #创建带空格的文件
[root@localhost cesi1]# ls
file program program_bak program file ps.txt

注意：在Linux中尽量不要创建带空格的文件


文件处理命令 cat

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 > 3.2.3 文件处理命令 >
文件处理命令 cat

文件处理命令 cat

命令名称： cat
命令英文原意：
命令路径：/bin/cat
执行权限：所有用户
语法：cat [文件名]
功能描述：显示文件内容
-n显示行号
范例：

[root@localhost cesi1]# cat /etc/issue #查看issue文件内容
\S
Kernel \r on an \m

[root@localhost cesi1]# cat -n /etc/issue #查看文件显示行号
1 \S
2 Kernel \r on an \m
3
[root@localhost cesi1]# cat -n /etc/services #长文件显示

注意：cat不适合显示长文件


文件处理命令 tac

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 > 3.2.3 文件处理命令 >
文件处理命令 tac

文件处理命令 tac

命令名称： tac
命令英文原意：
命令路径：/usr/bin/tac
执行权限：所有用户
语法：tac [文件名]
功能描述：显示文件内容（反向列示）--倒的显示
范例：

[root@localhost cesi1]# tac /etc/issue #显示文件，反向显示

Kernel \r on an \m
\S
[root@localhost cesi1]# tac -n /etc/issue #tac没有-n显示行号，错误的
tac：无效选项 -- n


文件处理命令 more

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 > 3.2.3 文件处理命令 >
文件处理命令 more

文件处理命令 more

命令名称： more
命令英文原意：
命令路径：/bin/more
执行权限： 所有用户
语法： more [文件名]
功能描述： 分页显示文件内容
范例：

[root@localhost cesi1]# more /ect/services

操作事项：
空格或 f 翻页
Enter 换行
q/Q 退出

[root@localhost cesi1]# more -100 /etc/services #从100行开始看起

[root@localhost cesi1]# more -1000d /etc/services #从1000行开始看起，显示帮助


文件处理命令 less

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 > 3.2.3 文件处理命令 >
文件处理命令 less

文件处理命令 less

命令名称： less
命令英文原意：
命令路径： /usr/bin/less
执行权限：所有用户
语法： less [文件名]
功能描述：分页显示文件内容（可向上翻页，可以搜索）
范例：

[root@localhost cesi1]# less /etc/services #查看文件

操作事项：
空格或 f 翻页
Enter 换行
q/Q 退出
page up 向上翻页
page on 向下翻页
箭头 (上) 逐行往上

可以进行搜索：/ 表示搜索， 例如：/servic n表示（next）继续往下找


文件处理命令 head

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 > 3.2.3 文件处理命令 >
文件处理命令 head

文件处理命令 head

命令名称： head
命令英文原意：
命令路径：/usr/bin/head
执行权限：所有用户
语法：head [文件名]
功能描述：显示文件前面几行
-n 指定行数

范例：

[root@localhost cesi1]# head -n 20 /etc/services #显示开头20行的内容
# /etc/services:
# $Id: services,v 1.55 2013/04/14 ovasik Exp $
#
# Network services, Internet style
# IANA services version: last updated 2013-04-10
#
# Note that it is presently the policy of IANA to assign a single well-known
# port number for both TCP and UDP; hence, most entries here have two entries
# even if the protocol doesn't support UDP operations.
# Updated from RFC 1700, ``Assigned Numbers'' (October 1994). Not all ports
# are included, only the more common ones.
#
# The latest IANA port assignments can be gotten from
# http://www.iana.org/assignments/port-numbers
# The Well Known Ports are those from 0 through 1023.
# The Registered Ports are those from 1024 through 49151
# The Dynamic and/or Private Ports are those from 49152 through 65535
#
# Each line describes one service, and is of the form:
#

[root@localhost cesi1]# head /etc/services #默认的是前10行，主要用在查看脚本文件
# /etc/services:
# $Id: services,v 1.55 2013/04/14 ovasik Exp $
#
# Network services, Internet style
# IANA services version: last updated 2013-04-10
#
# Note that it is presently the policy of IANA to assign a single well-known
# port number for both TCP and UDP; hence, most entries here have two entries
# even if the protocol doesn't support UDP operations.
# Updated from RFC 1700, ``Assigned Numbers'' (October 1994). Not all ports


文件处理命令 tail

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 > 3.2.3 文件处理命令 >
文件处理命令 tail

文件处理命令 tail

命令名称： tail
命令英文原意：
命令路径：/usr/bin/tail
执行权限：所有用户
语法：tail [文件名]
功能描述：显示文件后面几行
-n指定行数
-f 动态显示文件末尾内容

范例：

[root@localhost cesi1]# tail -n 19 /etc/services #显示services文件末尾19行内容
nimcontroller 48000/udp # Nimbus Controller
nimspooler 48001/tcp # Nimbus Spooler
nimspooler 48001/udp # Nimbus Spooler
nimhub 48002/tcp # Nimbus Hub
nimhub 48002/udp # Nimbus Hub
nimgtw 48003/tcp # Nimbus Gateway
nimgtw 48003/udp # Nimbus Gateway
nimbusdb 48004/tcp # NimbusDB Connector
nimbusdbctrl 48005/tcp # NimbusDB Control
3gpp-cbsp 48049/tcp # 3GPP Cell Broadcast Service Protocol
isnetserv 48128/tcp # Image Systems Network Services
isnetserv 48128/udp # Image Systems Network Services
blp5 48129/tcp # Bloomberg locator
blp5 48129/udp # Bloomberg locator
com-bardac-dw 48556/tcp # com-bardac-dw
com-bardac-dw 48556/udp # com-bardac-dw
iqobject 48619/tcp # iqobject
iqobject 48619/udp # iqobject
matahari 49000/tcp # Matahari Broker

[root@localhost cesi1]# tail /etc/services #默认显示10行
3gpp-cbsp 48049/tcp # 3GPP Cell Broadcast Service Protocol
isnetserv 48128/tcp # Image Systems Network Services
isnetserv 48128/udp # Image Systems Network Services
blp5 48129/tcp # Bloomberg locator
blp5 48129/udp # Bloomberg locator
com-bardac-dw 48556/tcp # com-bardac-dw
com-bardac-dw 48556/udp # com-bardac-dw
iqobject 48619/tcp # iqobject
iqobject 48619/udp # iqobject
matahari 49000/tcp # Matahari Broker

[root@localhost cesi1]# tail -f /var/log/messages #-f 动态显示，更新后可以看到数据变化，CTRL+C退出
Dec 3 13:56:08 localhost NetworkManager[861]: <info> [1638510968.9557] dhcp4 (ens33): domain name 'localdomain'
Dec 3 13:56:08 localhost NetworkManager[861]: <info> [1638510968.9557] dhcp4 (ens33): state changed bound -> bound
Dec 3 13:56:08 localhost dbus[709]: [system] Activating via systemd: service name='org.freedesktop.nm_dispatcher' unit='dbus-org.freedesktop.nm-dispatcher.service'
Dec 3 13:56:08 localhost systemd: Starting Network Manager Script Dispatcher Service...
Dec 3 13:56:08 localhost dhclient[1182]: bound to 192.168.47.134 -- renewal in 742 seconds.
Dec 3 13:56:08 localhost dbus[709]: [system] Successfully activated service 'org.freedesktop.nm_dispatcher'
Dec 3 13:56:08 localhost systemd: Started Network Manager Script Dispatcher Service.
Dec 3 13:56:08 localhost nm-dispatcher: req:1 'dhcp4-change' [ens33]: new request (4 scripts)
Dec 3 13:56:08 localhost nm-dispatcher: req:1 'dhcp4-change' [ens33]: start running ordered scripts...
Dec 3 13:57:00 localhost kernel: hrtimer: interrupt took 4393777 ns


3.2.4 链接命令 ln

Linux学习
Linux > 3 Linux常用命令 > 3.2 文件处理命令 >
3.2.4 链接命令 ln

链接命令 ln

命令名称：ln
命令英文原意： link
命令路径：/bin/ln
执行权限：所有用户
语法： ln -s[原文件] [目标文件] 创建软链接
ln [原文件] [目标文件] 创建硬链接
功能描述：生成链接文件
范例：

[root@localhost cesi1]# ln -s /etc/issue /root/lianxi/issue.soft #创建软链接issue.soft

[root@localhost lianxi]# ln /etc/issue /root/lianxi/issue.hard #创建硬链接issue.hard文件

软链接特征：类似windows快捷方式（使用的比较多）

lrwxrwxrwx. 1 root root 10 12月 3 14:46 issue.soft -> /etc/issue

1.软链接的权限都是rwx(方便管理)

2.文件较小，只是符号链接

3.issue.soft -> /etc/issue 箭头指向源文件

硬链接特征：可以同时更新

1.类似拷贝命令 cp -p + 同步更新

[root@localhost lianxi]# echo " www.csdn.net " >> /etc/issue #在文件后面加上 www.csdn.net
[root@localhost lianxi]# cat issue.hard #查看硬链接文件，看到数据同步更新
\S
Kernel \r on an \m

www.csdn.net
2.通过i节点识别 一个i节点映射多个文件

[root@localhost lianxi]# ls -i issue.hard #查看硬链接的 i 节点
33555492 issue.hard
[root@localhost lianxi]# cd /etc
[root@localhost etc]# ls -i issue #查看原文件的 i 节点
33555492 issue

3.不能跨分区

4.不能针对目录使用

注意：软链接删除原文件，对软链接有影响

硬链接删除原文件，对硬链接没有影响


3.3 权限管理命令

Linux学习
Linux > 3 Linux常用命令 >
3.3 权限管理命令

权限管理命令 chmod chown chgrp umask

权限管理解析：

在Linux中我们可以使用 ll 或者 ls -l 命令来显示一个文件的属性以及文件所属的用户和组

文件类型：

当为 d 则是目录
当为 - 则是文件；
若是 l 则表示为链接文档(link file)；
若是 b 则表示为装置文件里面的可供储存的接口设备(可随机存取装置)；
若是 c 则表示为装置文件里面的串行端口设备，例如键盘、鼠标(一次性读取装置)。

从左至右用 0-9 这些数字来表示

l 第 0 位确定文件类型

l 第 1-3 位确定属主（该文件的所有者）拥有该文件的权限

l 第4-6位确定属组（所有者的同组用户）拥有该文件的权限

l 第7-9位确定其他用户拥有该文件的权限

文件目录权限总结：

代表字符 | 权限 | 数字代表 | 对文件的含义 | 对目录的含义
r | 读权限 | 4 | 可以查看文件的内容 | 可以列出目录中的内容
w | 写权限 | 2 | 可以修改文件内容 | 可以在目录中创建、删除文件
x | 执行权限 | 1 | 可以执行文件 | 可以进入目录

使用数字进行权限转换

rwx rw- r-- 764

532 r-x -wx -w-

文件file中对应的权限

r: cat/more/head/tail/less

w: vim

x: script command

目录directory中对应的权限

r: ls

w: touch/mkdir/rmdir/rm

x: cd


3.3.1 权限管理命令 chmod

Linux学习
Linux > 3 Linux常用命令 > 3.3 权限管理命令 >
3.3.1 权限管理命令 chmod

权限管理命令 chmod

命令名称： chmod
命令英文原意：change the permissions mode of a file
命令路径： /bin/chmod
执行权限：所有用户
语法： chmod [{ugoa}{+-=}{rwx}] [文件或目录]
[mode=421] [文件或目录]
-R 递归修改
功能描述：改变文件或目录权限 所有者和root可以该文件权限
范例：

在Linux中我们可以使用 ll 或者 ls -l 命令来显示一个文件的属性以及文件所属的用户和组

语法： chmod [{ugoa}{+-=}{rwx}] [文件或目录]
 [mode=421] [文件或目录]
 -R 递归修改
参数代表含义：

u: 所有者-->谁创建了该文件

g: 所属组-->

o: 其他人-->

a: 所有权限-->

范例一：增加program中所有者的执行权限

[root@localhost lianxi]# chmod u+x program #增加program所有者执行权限

范例二：增加所属组写权限，去掉其他人读权限

[root@localhost lianxi]# chmod g+w,o-r program #增加所属组写权限，去掉其他人读权限

范例三：通常情况下我们都会用数字表示权限

r:4 w:2 e:1

rwxr----- 对应数字权限 740

[root@localhost lianxi]# chmod 760 ps_bak.txt #修改ps_bak文件的权限为rwxrw----

范例四：使用递归修改，修改目录cesi1及其目录下文件为所有用户具有全部权限

[root@localhost lianxi]# chmod -R 777 cesi1 #修改目录cesi1及其目录下文件为所有用户具有全部权限


3.3.2 其他权限管理命令 chown

Linux学习
Linux > 3 Linux常用命令 > 3.3 权限管理命令 >
3.3.2 其他权限管理命令 chown

其他权限管理命令 chown

命令名称： chown
命令英文原意：change file own ership
命令路径： /bin/chown
执行权限：所有权限
语法： chown [用户] [文件或目录]
功能描述：改变文件或目录的所有者 只有root用户可以
范例：

[root@localhost lianxi]# useradd cesi #创建用户cesi

[root@localhost lianxi]# useradd cesi #创建用户cesi


3.3.3 其他权限管理命令 chgrp

Linux学习
Linux > 3 Linux常用命令 > 3.3 权限管理命令 >
3.3.3 其他权限管理命令 chgrp

其他权限管理命令 chgrp

命令名称：chgrp
命令英文原意：change file group ownership
命令路径：/bin/chgrp
执行权限：所有用户
语法：chgrp [用户组] [文件或目录]
功能描述：改变文件或目录的所属组
范例：

[root@localhost lianxi]# groupadd cesi #添加用户组

[root@localhost lianxi]# chgrp cesi program #修改program文件的用户组

一个用户可以有多个组，缺省组只能有一个，创建文件或目录都是默认的缺省组


3.3.4 其他权限管理命令 umask

Linux学习
Linux > 3 Linux常用命令 > 3.3 权限管理命令 >
3.3.4 其他权限管理命令 umask

其他权限管理命令 umask

命令名称：umask
命令英文原意：the user file creation mask
命令路径：shell内置命令
执行权限：所有用户
语法： umask [-S]
-S 以rwx形式显示新建文件缺省权限
功能描述：显示、设置文件的缺省权限
范例：

[root@localhost lianxi]# umask
0022 #第一个0：特殊权限 022：三种用户的权限 ---w--w--

777的权限 rwxrwxrwx 缺省后是rwxr-xr-x 权限是755（目录）

文件默认是没有x的权限 缺省后是rw-r--r-- 权限是644（文件）

[root@localhost lianxi]# umask -S
u=rwx,g=rx,o=rx

Linux定义缺省创建的文件下不能具有可执行权限


3.4 文件搜索命令

Linux学习
Linux > 3 Linux常用命令 >
3.4 文件搜索命令

文件搜索命令

find | 文件搜索
locate | 在文件资料库中查找文件
which | 搜索命令所在目录及别名信息
whereis | 搜索命令所在目录及帮助文档路径
grep | 在文件内容中搜索子串匹配的行并输出


3.4.1 文件搜索命令 find

Linux学习
Linux > 3 Linux常用命令 > 3.4 文件搜索命令 >
3.4.1 文件搜索命令 find

文件搜索命令 find

命令名称： find
命令英文原意： find
命令路径：/bin/find
执行权限：所有用户
语法：find [搜索范围] [匹配条件]
功能描述：文件搜索
需要了解知识：

  • 搜索会大量占用系统资源
  • Linux以数据块为最小存储单位：1数据块=512字节=0.5KB 100MB=102400KB= 204800数据块
  • 搜索的范围尽量越小越好，越精确越好，这样可以节约Linux的系统资源
  • 在find中用到的通配符 *：可以匹配任意字符 ？：可以匹配单个字符

范例：

范例1：-name -iname （ * ?） 的用法

[root@localhost /]# find /etc -name init #在目录/etc中查找文件init

使用通配符（* ？）进行查找文件

[root@localhost /]# find /etc -name *init* #查找包含init的文件

[root@localhost /]# find /etc -name init??? #查找init后面有3个字符的文件

使用 -iname 不区分大小写

[root@localhost /]# find /etc -iname init* #查找init*文件不区分大小写

范例2：-size +n：大于 -n：小于 =n 等于 n表示数据块 < /FONT >

[root@localhost /]# find / -size +204800 #在根目录下查找大于100MB的文件

范例3：-user：根据用户查询 -group：根据所属组查询

[root@localhost /]# find /home -user cesi #在根目录下查找所有者为cesi的文件

[root@localhost /]# find /home -user cesi -name cesi #在根目录下查找所有者为cesi文件名字为cesi的文件
/home/cesi

范例4：-cmin：按分钟查询 (+表示超过多长时间 -表示多长时间之内)
[root@localhost /]# find /home -user cesi -name cesi #在根目录下查找所有者为cesi文件名字为cesi的文件
/home/cesi

-amin 访问时间 access 什么时候被浏览过

[root@localhost /]# find /root -amin -30 #查找/root文件下30分钟内被浏览过的文件

[root@localhost /]# find /root -atime -10 #十小时内存取的文件或目录

-cmin 文件属性change 修改文件属性的时间

[root@localhost /]# find /root -cmin -10 # 十分钟内更改过的文件或目录

[root@localhost /]# find /root -ctime +10 # 十小时前更改过的文件或目录

-mmin 文件内容modify 增加删除修改文件内容的时间

范例5：-a：两个条件同时满足（常用） -o：两个条件满足任意一个即可

[root@localhost /]# find / -size +163840 -a -size -204800 #在根目录/下查找大于80MB小于100MB的文件

范例6：

[root@localhost /]# find /root -name lianxi -exec ls -l {} \; #在/root下查找lianxi文件或目录并显示其详细信息

-exec：对搜索结果执行操作 -ok：询问确认信息

{} \; ：固定格式 {}：结果集 \：转译符 ；：结速

-type：根据文件类型查找 f：文件 d：目录 l：软链接文件

-inum 根据 i 节点查找

[root@localhost /]# find /etc -name init* -a -type d #查找init*开头的目录（配合使用）

[root@localhost /]# find /etc -name init* -a -type f -exec ls -l {} \; #查找init*开头的文件并显示现象信息

[root@localhost /]# find /etc -name init* -a -type f -ok ls -l {} \; #查找init*开头的文件并显示现象信息，需要询问

通过 i 节点查找：[root@localhost /]# find / -inum 3786018 -exec ls -l {} \; #通过节点查找

总结：find -name -iname * ? -size + - -user -group

-amin -cmin -mmin

-type f d l -inum -a -o

-exec / -ok

{} \;


3.4.2 其他搜索命令 locate

Linux学习
Linux > 3 Linux常用命令 > 3.4 文件搜索命令 >
3.4.2 其他搜索命令 locate

文件搜索命令 locate

命令名称： locate
命令英文原意： locate
命令路径：/usr/bin/locate
执行权限：所有用户
语法：locate 文件名
功能描述：在文件资料库中查找文件

原理：建立文件资料库，定期更新，所以查找速度更快

范例：

[root@localhost /]# locate inittab #查找文件inittab

[root@localhost /]# locate locate #查找它自己

/var/lib/mlocate/mlocate.db #资料库的数据文件，需要定时更新

[root@localhost lianxi]# touch /root/lianxi cesilocate
[root@localhost lianxi]# locate cesilocate #查找不到数据
[root@localhost lianxi]# find /root/lianxi -name cesilocate #使用find可以找到
/root/lianxi/cesilocate

updatedb 更新文件资料库（升级文件资料库）

[root@localhost lianxi]# updatedb #升级文件资料库
[root@localhost lianxi]# locate cesilocate
/root/lianxi/cesilocate

注意：在临时目录/tmp中的内容无法使用 locate 找到
[root@localhost lianxi]# touch /tmp/cesilocate_tmp #创建临时文件cesilocate_tmp
[root@localhost tmp]# find / -name cesilocate_tmp #使用find可以查到数据
/tmp/cesilocate_tmp
[root@localhost tmp]# updatedb #升级文件资料库
[root@localhost tmp]# locate cesilocate_tmp #使用locate 找不到文件

locate使用的时候区分大小写 -i 选项忽略大小写

[root@localhost lianxi]# touch /root/lianxi/Cesilocate
[root@localhost lianxi]# ls
cesi1 cesi2 cesilocate Cesilocate find issue.hard issue.soft program ps_bak.txt
[root@localhost lianxi]# updatedb
[root@localhost lianxi]# locate cesilocate
/root/lianxi/cesilocate
[root@localhost lianxi]# locate -i cesilocate
/root/lianxi/Cesilocate
/root/lianxi/cesilocate


3.4.3 其他搜索命令 which

Linux学习
Linux > 3 Linux常用命令 > 3.4 文件搜索命令 >
3.4.3 其他搜索命令 which

文件搜索名 which

命令名称：which
命令英文原意：which
命令路径：/usr/bin/which
执行权限：所有用户
语法：which 命令
功能描述：搜索命令所在目录及别名信息

需要了解知识：( /bin或/usr/bin/) 所有用户使用的命令 (/sbin或/usr/sbin) 只有root用户才能使用

[root@localhost lianxi]# which ls #查看ls目录的路径
alias ls='ls --color=auto'
/usr/bin/ls
[root@localhost lianxi]# which cp #查看cp目录的路径
alias cp='cp -i'
/usr/bin/cp


3.4.4 其他搜索命令 whereis

Linux学习
Linux > 3 Linux常用命令 > 3.4 文件搜索命令 >
3.4.4 其他搜索命令 whereis

文件搜索命令 whereis

命令名称：whereis
命令英文原意：whereis
命令路径：/usr/bin/whereis
执行权限：所有用户
语法：whereis [命令名称]
功能描述：搜索命令所在目录及帮助文档路径
范例：

[root@localhost lianxi]# whereis ls
ls: /usr/bin/ls /usr/share/man/man1/ls.1.gz /usr/share/man/man1p/ls.1p.gz
[root@localhost lianxi]# whereis cp
cp: /usr/bin/cp /usr/share/man/man1/cp.1.gz /usr/share/man/man1p/cp.1p.gz


3.4.5 其他搜索命令 grep

Linux学习
Linux > 3 Linux常用命令 > 3.4 文件搜索命令 >
3.4.5 其他搜索命令 grep

文件内容中搜索命令 grep

命令名称：grep
命令英文原意：grep
命令路径：/bin/grep
执行权限：所有用户
语法： grep -iv [指定字串] [文件]
功能描述：在文件中搜索字符串匹配的行并输出

范例：

[root@localhost sbin]# grep -i sum ./sum.sh #查找sum.sh脚本中sum的内容

-i 不区分大小写

-v 排除指定字串，反向查找

-n 输出行号

--color=auto 搜索出的关键字用颜色显示

[root@localhost sbin]# grep -v sum ./sum.sh #查找sum.sh脚本中除了sum的内容

[root@localhost sbin]# grep -i ^# ./sum.sh #查找首行为#号的内容

[root@localhost sbin]# grep -iv ^# ./sum.sh #查找首行不为#号的内容


3.5 帮助命令

Linux学习
Linux > 3 Linux常用命令 >
3.5 帮助命令

帮助命令

man 命令或配置文件 命令 NAME 作用 选项

配置文件 NAME 存放信息 文件格式

whatis 命令

apropos 配置文件

命令 --help

info

date man date 参数格式

help


3.5.1 帮助命令 man

Linux学习
Linux > 3 Linux常用命令 > 3.5 帮助命令 >
3.5.1 帮助命令 man

帮助命令 man [info]

命令名称：man
命令英文原意：manual 手册
命令路径：/usr/bin/man
执行权限：所有用户
语法：man [命令或配置文件]
功能描述：获取帮助信息
范例：

范例1：查看命令的帮助信息

[root@localhost sbin]# man ls #查看ls命令的帮助信息

键盘输入 / -l #可以找关于-l相关选项的内容，按键盘 n 查找下一个

范例2：查看配置文件的帮助信息 使用man查看配置文件时，不要增加绝对路径，直接写配置文件名称就可以

[root@localhost sbin]# man services #查看配置文件services的帮助信息

范例3：查看一个特殊的 passwd

[root@localhost sbin]# whereis passwd
passwd: /usr/bin/passwd /etc/passwd /usr/share/man/man1/passwd.1.gz /usr/share/man/man5/passwd.5.gz

说明：passwd中有两个帮助文档passwd.1.gz和passwd.5.gz ，其中 1：命令的帮助 5：配置文件的帮助

查看配置文件的帮助 ：[root@localhost sbin]# man 5 passwd #查看配置文件的帮助文档

范例4：查看修改时间

[root@localhost sbin]# date #查看时间，发现时间不对
2021年 12月 09日 星期四 11:32:06 CST

使用man date 查看格式如下

[root@localhost sbin]# date 120811582021
2021年 12月 08日 星期三 11:58:00 CST


3.5.2 帮助命令 help

Linux学习
Linux > 3 Linux常用命令 > 3.5 帮助命令 >
3.5.2 帮助命令 help

帮助命令 help

命令名称：help
命令路径：shell内置命令
执行权限：所有用户
语法：help 命令
功能描述：获得shell内置命令的帮助信息

需要了解的知识：

  • shell是命令解释器
  • shell内置命令，没有路径 例如cd umask 使用 which 查不到路径，只能使用help查看帮助

范例：

[root@localhost sbin]# help umask #查看umask的帮助信息

[root@localhost sbin]# help if


3.5.3 实用的其他帮助命令

Linux学习
Linux > 3 Linux常用命令 > 3.5 帮助命令 >
3.5.3 实用的其他帮助命令

实用的其他帮助命令 whatis apropos --help

范例：

范例1：whatis

[root@localhost sbin]# whatis ls #可直接读取这个命令的信息
ls (1) - 列目录内容
ls (1p) - list directory contents
[root@localhost sbin]# whatis ifconfig
ifconfig (8) - 配置网络接口

范例2：apropos

[root@localhost sbin]# apropos services #查看配置文件简短信息
services (5) - (未知的主题)
chkconfig (8) - updates and queries runlevel information for system services
db_replicate (1) - Provide replication services
dbus-update-activation-environment (1) - update environment used for D-Bus session services
endservent (3p) - network services database functions
fingerprint-auth (5) - Common configuration file for PAMified services
fingerprint-auth-ac (5) - Common configuration files for PAMified services written by authconfig(8)
getservbyname (3p) - network services database functions
getservbyport (3p) - network services database functions
getservent (3p) - network services database functions
nfs.systemd (7) - managing NFS services through systemd.
pam_listfile (8) - deny or allow services based on an arbitrary file
password-auth (5) - Common configuration file for PAMified services
password-auth-ac (5) - Common configuration files for PAMified services written by authconfig(8)
postlogin (5) - Common configuration file for PAMified services
postlogin-ac (5) - Common configuration files for PAMified services written by authconfig(8)
probe::stap.cache_add_nss (3stap) - Add NSS (Network Security Services) information to cache
rtas (2) - Allows userspace to call RTAS (Run Time Abstraction Services)
setservent (3p) - network services database functions
sg_ses (8) - access a SCSI Enclosure Services (SES) device
smartcard-auth (5) - Common configuration file for PAMified services
smartcard-auth-ac (5) - Common configuration files for PAMified services written by authconfig(8)
sssd (8) - System Security Services Daemon
system-auth (5) - Common configuration file for PAMified services
system-auth-ac (5) - Common configuration files for PAMified services written by authconfig(8)
tcpd (8) - access control facility for internet services

[root@localhost sbin]# apropos inittab
inittab (5) - 与 sysv 兼容的 init 进程使用的初始化文件格式

范例3：--help

[root@localhost sbin]# touch --help
用法：touch [选项]... 文件...
Update the access and modification times of each FILE to the current time.

A FILE argument that does not exist is created empty, unless -c or -h
is supplied.

A FILE argument string of - is handled specially and causes touch to
change the times of the file associated with standard output.

Mandatory arguments to long options are mandatory for short options too.
-a 只更改访问时间
-c, --no-create 不创建任何文件
-d, --date=字符串 使用指定字符串表示时间而非当前时间
-f (忽略)
-h, --no-dereference 会影响符号链接本身，而非符号链接所指示的目的地
(当系统支持更改符号链接的所有者时，此选项才有用)
-m 只更改修改时间
-r, --reference=FILE use this file's times instead of current time
-t STAMP use [[CC]YY]MMDDhhmm[.ss] instead of current time
--time=WORD change the specified time:
WORD is access, atime, or use: equivalent to -a
WORD is modify or mtime: equivalent to -m
--help 显示此帮助信息并退出
--version 显示版本信息并退出

请注意，-d 和-t 选项可接受不同的时间/日期格式。

GNU coreutils online help: < http://www.gnu.org/software/coreutils/ >
请向< http://translationproject.org/team/zh_CN.html > 报告touch 的翻译错误
要获取完整文档，请运行：info coreutils 'touch invocation'


3.6 用户管理命令

Linux学习
Linux > 3 Linux常用命令 >
3.6 用户管理命令

用户管理命令 useradd

命令名称：useradd
命令路径：/usr/sbin/useradd
执行权限：root
语法：useradd 用户名
功能描述：添加新用户 用户名不要弄的太复杂
范例：

[root@localhost lianxi]# useradd yangmi

#添加yangmi的用户，只是给了它一个家目录，想要登录需要一个验证密码

用户管理命令 passwd

命令名称：passwd
命令路径：/usr/bin/passwd
执行权限：所有用户
语法：passwd 用户名
功能描述：设置用户密码

范例：

[root@localhost lianxi]# passwd yangmi #超级用户可以随意改
更改用户 yangmi 的密码 。
新的 密码：
无效的密码： 密码包含用户名在某些地方
重新输入新的 密码：
passwd：所有的身份验证令牌已经成功更新。

注意：普通用户只能修改自己的密码，且必须符合复杂度的要求。密码规则：最少8位，大小写字母，数字符合组合

用户管理命令 who

命令名称：who
命令路径：/usr/bin/who
执行权限：所有用户
语法：who
功能描述：查看当前登录用户信息

范例：

[root@localhost lianxi]# who
root pts/1 2021-12-07 14:14 (192.168.47.1)

解释：登录用户名 终端终端 tty本地终端 / pts远程终端 登录时间 IP地址

用户管理命令 w

命令名称： w
命令路径：/usr/bin/w
执行权限：所有用户
语法：w
功能描述： 查看登录用户详细信息

范例：

[root@localhost lianxi]# w
[root@localhost lianxi]# uptime
16:43:08 up 2 days, 23:50, 1 user, load average: 0.00, 0.01, 0.05


3.7 压缩解压命令

Linux学习
Linux > 3 Linux常用命令 >
3.7 压缩解压命令

压缩命令

.gz gzip gunzip(gzip -d)
.tar tar -cf(打包) -xf(解开包)
.tar.gz tar -zcf -zxf
.zip zip -r unzip
.bz2 bzip2 bunzip2
.tar.bz2 tar -cjf -xjf


3.7.1 压缩解压命令 gzip gunzip

Linux学习
Linux > 3 Linux常用命令 > 3.7 压缩解压命令 >
3.7.1 压缩解压命令 gzip gunzip

压缩解压命令 gzip gunzip

命令名称：gzip
命令英文原意：GUNzip
命令路径：/bin/gzip
执行权限：所有用户
语法：gzip [文件]
功能描述：压缩文件
压缩后的格式： .gz
命令名称：gunzip
命令英文原意：GUNunzip
命令路径：/bin/gunzip
执行权限：所有用户
语法：gzip [压缩文件]
功能描述：解压缩.gz的压缩文件
范例：

[root@localhost lianxi]# cp /etc/services /root/lianxi/yasuo #复制services文件，更名为yasuo

压缩比是5倍多

注意：gzip 只能压缩文件，压缩后不保留原文件，不能压缩目录

[root@localhost lianxi]# gunzip yasuo.gz #解压yasuo.gz文件


3.7.2 压缩解压命令 tar

Linux学习
Linux > 3 Linux常用命令 > 3.7 压缩解压命令 >
3.7.2 压缩解压命令 tar

压缩解压命令 tar

命令名称：tar
命令路径：/bin/tar
执行权限：所有用户
语法：tar 选项[-zcf] [压缩后文件名] [目录]
-c 打包
-v 显示详细信息
-f 指定文件名（必须加）
-z 打包同压缩
功能描述：打包目录 名字是为了方便区分，一般加.tar
压缩后文件格式： .tar.gz
命令名称：tar
tar命令解压缩语法：
-x 解包
-v 显示详细信息
-f 指定解压文件
-z 解压缩

范例：

[root@localhost lianxi]# tar -cvf cesi1.tar cesi1 cesi2 #打包cesi1 cesi2目录

[root@localhost lianxi]# gzip cesi1.tar #压缩cesi1.tar

.tar.gz压缩格式是互联网最常见的压缩格式

[root@localhost lianxi]# tar -zcf cesi1.tar.gz cesi1 #打包压缩cesi1目录为cesi1.tar.gz

[root@localhost lianxi]# tar -zxvf cesi1.tar.gz #解压解包 cesi1.tar.gz


3.7.3 压缩解压命令 zip unzip

Linux学习
Linux > 3 Linux常用命令 > 3.7 压缩解压命令 >
3.7.3 压缩解压命令 zip unzip

压缩解压命令 zip unzip

命令名称：zip
命令路径：/usr/bin/zip
执行权限：所有用户
语法：zip 选项[-r] [压缩后文件名] [文件或目录]
-r 压缩目录
功能描述：压缩文件或目录
压缩后文件格式： .zip
优点：Linux和windows都支持的压缩格式，且压缩后保留原格式
命令名称：unzip
命令路径：/usr/bin/unzip
执行权限：所有用户
语法：unzip [压缩文件]
功能描述：解压 .zip 的压缩文件
范例：

[root@localhost lianxi]# zip yasuo.zip yasuo

[root@localhost lianxi]# unzip yasuo.zip #解压yasuo.zip


3.7.4 压缩解压命令 bzip2 bunzip2

Linux学习
Linux > 3 Linux常用命令 > 3.7 压缩解压命令 >
3.7.4 压缩解压命令 bzip2 bunzip2

压缩解压命令 bzip2 bunzip2

命令名称：bzip2
命令路径：/usr/bin/bzip2
执行权限：所有用户
语法：bzip2 选项[-k] [文件]
-k产生压缩文件后保留原文件
功能描述：压缩文件
压缩后文件格式： .bz2
命令名称：bunzip2
命令路径：/usr/bin/bunzip2
执行权限：所有用户
语法：bunzip2 [-k][压缩文件]
-k 解压缩后保留原文件
功能描述：解压 .zip 的压缩文件

范例：

[root@localhost lianxi]# bzip2 -k yasuo #使用bzip2 压缩文件yasuo

[root@localhost lianxi]# tar -cjf yasuo.tar.bz2 yasuo #使用tar 用选项-j 替代 bzip2命令

[root@localhost lianxi]# bunzip2 -k yasuo.bz2 #使用bunzip2解压yasuo.bz2文件

[root@localhost lianxi]# tar -xjf yasuo.tar.bz2


3.8 网络命令

Linux学习
Linux > 3 Linux常用命令 >
3.8 网络命令

网络命令

write | 给用户发信息，以Ctrl+D保存结束 （用户必须是在线用户）
wall | 发广播信息（在线用户）
ping | 测试网络连通性
ifconfig | 查看和设置网卡信息
mail | 查看发送电子邮件（在不在线都可以）
netstat | 显示网络相关信息，查询网络状态
last lastlog | 列出目前与过去登入系统的用户信息 看计算机所有用户查询信息
traceroute | 显示数据包到主机访问的路径/跟踪路由
setup | 配置网络 redhat自带的


3.8.1 网络命令 write

Linux学习
Linux > 3 Linux常用命令 > 3.8 网络命令 >
3.8.1 网络命令 write

网络命令 write

命令名称：write
命令路径：/usr/bin/write
执行权限：所有用户
语法：write [用户名]
功能描述：给用户发信息，以Ctrl+D保存结束 （用户必须是在线用户）
历史最古老的即时通信
范例：

查询在线用户可以用who或 w

使用write时，输错删除用Ctrl+backspace 键


3.8.2 网络命令 wall

Linux学习
Linux > 3 Linux常用命令 > 3.8 网络命令 >
3.8.2 网络命令 wall

网络命令 wall

命令名称：wall
命令英文原意：write all
命令路径：/usr/bin/wall
执行权限：所有用户
语法：wall [message]
功能描述：发广播信息（在线用户）

范例：


3.8.3 网络命令 ping

Linux学习
Linux > 3 Linux常用命令 > 3.8 网络命令 >
3.8.3 网络命令 ping

网络命令 ping

命令名称：ping
命令路径：/bin/ping
执行权限：所有用户
语法：ping 选项 ip地址
-c 指定发送次数
功能描述：测试网络连通性

范例：

[root@localhost lianxi]# ping 192.168.2.156 #测试到主机的连通性，按Ctrl+C后结束测试
PING 192.168.2.156 (192.168.2.156) 56(84) bytes of data.
64 bytes from 192.168.2.156: icmp_seq=1 ttl=128 time=0.600 ms
64 bytes from 192.168.2.156: icmp_seq=2 ttl=128 time=0.697 ms
64 bytes from 192.168.2.156: icmp_seq=3 ttl=128 time=0.567 ms
64 bytes from 192.168.2.156: icmp_seq=4 ttl=128 time=0.566 ms
64 bytes from 192.168.2.156: icmp_seq=5 ttl=128 time=0.664 ms
64 bytes from 192.168.2.156: icmp_seq=6 ttl=128 time=0.492 ms
64 bytes from 192.168.2.156: icmp_seq=7 ttl=128 time=0.412 ms

[root@localhost lianxi]# ping -c 3 192.168.2.156 #测试3次网络
PING 192.168.2.156 (192.168.2.156) 56(84) bytes of data.
64 bytes from 192.168.2.156: icmp_seq=1 ttl=128 time=1.01 ms
64 bytes from 192.168.2.156: icmp_seq=2 ttl=128 time=0.490 ms
64 bytes from 192.168.2.156: icmp_seq=3 ttl=128 time=0.515 ms

--- 192.168.2.156 ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2002ms
rtt min/avg/max/mdev = 0.490/0.672/1.013/0.242 ms

注意：重点查看丢包率就可以了，丢包率高证明网络不好


3.8.4 网络命令 ifconfig

Linux学习
Linux > 3 Linux常用命令 > 3.8 网络命令 >
3.8.4 网络命令 ifconfig

网络命令 ifconfig

命令名称：ifconfig
命令英文原意：interface configure
命令路径：/sbin/ifconfig
执行权限：root
语法：ifconfig 网卡名称 IP地址
功能描述：查看和设置网卡信息

范例：

[root@localhost lianxi]# ifconfig #查看网卡信息

[root@localhost lianxi]# ifconfig eth0 192.168.8.250 #临时加IP地址


3.8.5 网络命令 mail

Linux学习
Linux > 3 Linux常用命令 > 3.8 网络命令 >
3.8.5 网络命令 mail

网络命令 mail

命令名称：mail
命令路径：/bin/mail
执行权限：所有用户
语法：mail [用户名]
功能描述：查看发送电子邮件（在不在线都可以）

范例：

注意：系统给root发的邮件非常重要，务必要重视！

Held 2 messages in /var/spool/mail/root
您在 /var/spool/mail/root 中有邮件


3.8.6 网络命令 netstat

Linux学习
Linux > 3 Linux常用命令 > 3.8 网络命令 >
3.8.6 网络命令 netstat

网络命令 netstat

命令名称：netstat
命令路径：/bin/netstat
执行权限：所有用户
语法：netstat [选项]
功能描述：显示网络相关信息，查询网络状态
选项：
-t: TCP协议 通过3次握手后连通
-u: UDP协议 不握手直接发送信息
-l: 监听
-r: 路由
-n: 显示IP地址和端口号

范例：

[root@localhost lianxi]# netstat -tlun #查看本机监听的端口

[root@localhost lianxi]# netstat -an #查看本机所有的网络连接

[root@localhost lianxi]# netstat -rn #查看本机路由器


3.8.7 网络命令 last lastlog

Linux学习
Linux > 3 Linux常用命令 > 3.8 网络命令 >
3.8.7 网络命令 last lastlog

网络命令 last lastlog

命令名称：last
命令路径：/usr/bin/last
执行权限：所有用户
语法：last
功能描述：列出目前与过去登入系统的用户信息
命令名称：lastlog
执行权限：所有用户
语法：lastlog
功能描述：看计算机所有用户查询信息

范例：

[root@localhost lianxi]# cat /etc/passwd | grep yangmi #查看yangmi用户的uid
yangmi:x:1003:1004::/home/yangmi:/bin/bash
[root@localhost lianxi]# lastlog -u 1003
用户名 端口 来自 最后登陆时间
yangmi pts/0 192.168.47.1 五 12月 10 11:30:34 +0800 2021


3.8.8 网络命令 traceroute

Linux学习
Linux > 3 Linux常用命令 > 3.8 网络命令 >
3.8.8 网络命令 traceroute

网络命令 traceroute

命令名称：traceroute
命令路径：/bin/traceroute
执行权限：所有用户
语法：traceroute
功能描述：显示数据包到主机访问的路径/跟踪路由

范例：

[root@localhost lianxi]# traceroute www.lampbrother.net
traceroute to www.lampbrother.net (60.221.23.2), 30 hops max, 60 byte packets
1 gateway (192.168.47.2) 0.108 ms 0.062 ms 0.157 ms
2 * * *


3.8.9 网络命令 setup

Linux学习
Linux > 3 Linux常用命令 > 3.8 网络命令 >
3.8.9 网络命令 setup

网络命令 setup

命令名称：setup
命令路径：/usr/bin/setup
执行权限: root
语法：setup
功能描述：配置网络 redhat自带的

范例：


3.9 关机重启命令

Linux学习
Linux > 3 Linux常用命令 >
3.9 关机重启命令

关机重启命令

关机

  • shutdown -h
  • halt
  • poweroff
  • init 0

重启

  • shutdown -r
  • reboot
  • init 6

退出登录

  • logout


3.9.1 关机重启命令 shutdown

Linux学习
Linux > 3 Linux常用命令 > 3.9 关机重启命令 >
3.9.1 关机重启命令 shutdown

关机重启命令 shutdown

[root@localhost lianxi]# shutdown [选项] 时间
选项：
-c:取消前一个关机命令
-h:关机
-r:重启
个人推荐大家就用这个就可以了！

范例：

[root@localhost lianxi]# shutdown -h now #表示现在关机

[root@localhost lianxi]# shutdown -h 20:00 #表示晚上8点关机

[root@localhost lianxi]# shutdown -r 20:00 #表示晚上8点重启

[root@localhost lianxi]# shutdown -c #表示取消关机命令

[root@localhost lianxi]# shutdown +5 "System will shutdown after 5 minutes"

#设定5分钟后关机，并发警告信息给登录用户

注意：

  1. Linux系统关机重启必须慎重，因为服务器访问人数多，如果硬盘在高速运转的时候容易损坏
  2. 关机之前先要把服务断开，然后再重启


3.9.2 其他关机命令

Linux学习
Linux > 3 Linux常用命令 > 3.9 关机重启命令 >
3.9.2 其他关机命令

其他关机命令

[root@localhost lianxi]# halt #直接关机
[root@localhost lianxi]# poweroff #相当于直接断电
[root@localhost lianxi]# init 0 #修改运行级别为关机


3.9.3 其他重启命令

Linux学习
Linux > 3 Linux常用命令 > 3.9 关机重启命令 >
3.9.3 其他重启命令

其他重启命令

[root@localhost lianxi]# reboot #重启
[root@localhost lianxi]# init 6 #修改运行级别为重启
系统运行级别
0 关机 (不能设为默认运行级别)
1 单用户 （安全模式：启动最小服务，用来做修复，没有图形界面）
2 不完全多用户，不含NFS(网络)服务，没有图形界面 NFS简单的文件共享服务（不建议用，安全风险）
3 完全多用户（完全命令行）
4 未分配
5 图形界面（X11 X代表Linux图形环境）
6 重启（不能设为默认运行级别）

[root@localhost lianxi]# cat /etc/inittab #查看进程的配置文件

id:3:initdefault: #修改系统默认运行级别

[root@localhost lianxi]# runlevel #查看系统运行级别
N 5
[root@localhost lianxi]# init 3 #切换运行级别
[root@localhost lianxi]# runlevel
5 3


3.9.4 退出登录命令 logout

Linux学习
Linux > 3 Linux常用命令 > 3.9 关机重启命令 >
3.9.4 退出登录命令 logout

退出登录命令 logout

注意：当我们不用系统的时候，最好是退出登录，类似于Windows的锁定


3.10 挂载命令

Linux学习
Linux > 3 Linux常用命令 >
3.10 挂载命令

挂载命令 mount umount

命令名称：mount
命令路径：/bin/mount
执行权限: 所有用户
语法：mount [-t 文件系统] 设备文件名 挂载点
功能描述：挂载命令，手动连接外设

范例：

挂载之前，先确认挂载的设备

mkdir /mnt/cdrom #创建挂载点

mount -t iso9660 /dev/sr0 /mnt/cdrom #挂载文件

-t iso9660可以忽略不写

umount /dev/sr0 #卸载

范例：

[root@192 ~]# mkdir /mnt/cdrom #创建挂载目录
[root@192 dev]# mount /dev/sr0 /mnt/cdrom #挂载iso
mount: /dev/sr0 写保护，将以只读方式挂载


4 文本编辑器 Vi/Vim

Linux学习
Linux >
4 文本编辑器 Vi/Vim

文本编辑器 Vi/Vim

Vi编辑器是所有UNIX及Linux系统下标准的文本编辑器，对UNIX及Linux系统的任何版本，vi编辑器是完全相同的。Vim是vi的升级版本，增加了一些功能，对vi命令是完全兼容的。在一些基础命令上两者应该是一样的。
Vim是一个功能强大的全屏幕文本编辑器，Vim编辑器提供了丰富的编辑功能。这个编辑器十分简陋，对于初学者很不友好。但是在Linux中vi编辑器作用非常大，以后尤其我们在配置各种服务器时修改配置文件时十分有用。

它的作用是建立、编辑、显示文本文件 。Vim没有菜单，只有命令。

Vim编辑器有三种工作模式，在有的资料中名字不相同，但是并不影响
Vim编辑器三种模式：命令模式（command mode）、插入模式（Insert mode）/[输入模式]、底线命令模式（last line mode）/[编辑模式 ]。掌握这三种模式十分重要。

命令模式

用户刚刚启动 vi/vim，便进入了命令模式。
此状态下敲击键盘动作会被Vim识别为命令，而非输入字符。比如我们此时按下i，并不会输入一个字符，i被当作了一个命令。
以下是常用的几个命令：
i 切换到输入模式，以输入字符。
x 删除当前光标所在处的字符。
: 切换到底行命令模式，在最底下一行输入命令。
若想要编辑文本：启动Vim，进入了命令模式，按下i，切换到输入模式。
命令模式只有一些最基本的命令，因此仍要依靠底线命令模式输入更多命令。

set number --显示行号 [set nu]

输入模式

在命令模式下按下i就进入了输入模式。
在输入模式中，可以使用以下按键：
字符按键以及Shift组合，输入字符
ENTER，回车键，换行
BACK SPACE，退格键，删除光标前一个字符
DEL，删除键，删除光标后一个字符
方向键，在文本中移动光标
HOME/END，移动光标到行首/行尾
Page Up/Page Down，上/下翻页
Insert，切换光标为输入/替换模式，光标将变成竖线/下划线
ESC，退出输入模式，切换到命令模式

底线模式/编辑模式

在命令模式下按下:（英文冒号）就进入了底线命令模式。
底线命令模式可以输入单个或多个字符的命令，可用的命令非常多。
在底线命令模式中，基本的命令有（已经省略了冒号）：
q 退出程序
w 保存文件
按ESC键可随时退出底线命令模式。


4.1 VIM常用操作

Linux学习
Linux > 4 文本编辑器 Vi/Vim >
4.1 VIM常用操作

Vim常用操作

插入命令

命令 | 作用
a | 在光标所在字符后插入
A | 在光标所在行尾插入
i | 在光标所在字符前插入
I | 在光标所在行行首插入
o | 在光标下插入新行
O | 在光标上插入新行

定位命令

命令 | 作用
：set nu | 设置行号
：set nonu | 取消行号
gg G | 到第一行 到最后一行
nG | 到第n行
：n | 到第n行
$ | 移至行尾
0 | 移至行首

删除命令

命令 | 作用
x | 删除光标所在处字符
nx | 删除光标所在处后n个字符
dd | 删除光标所在行，ndd删除n行
dG | 删除光标所在行到文件末尾内容
D | 删除光标所在处到行尾内容
：n1,n2d | 删除指定范围的行

复制和剪切命令

命令 | 作用
yy | 复制当前行
nyy | 复制当前行以下n行
dd | 剪切当前行
ndd | 剪切当前行以下n行
p、P | 粘贴在当前光标所在行下或行上

替换和取消命令

命令 | 作用
r | 取代光标所在处字符
R | 从光标所在处开始替换字符，按Esc结束
u | 取消上一步操作

搜索和搜索替换命令

命令 | 作用
/string | 搜索指定字符串 搜索时忽略大小写 :set ic 、set noic
n | 搜索指定字符串的下一个出现位置
:%s/old/new/g | 全文替换指定字符串
:n1,n2s/old/new/g | 在一定范围内替换指定字符串

:替换范围
%s 全文替换
起始行，终止行s /要替换的字符串/替换的新的字符串/g(g不询问，c询问操作)

保存和退出命令

命令 | 作用
:w | 保存修改
:w new_filename | 另存为指定文件
:wq | 保存修改并退出
ZZ | 快捷键，保存修改并退出或shift+zz
:q! | 不保存修改退出
:wq! | 强行保存修改并退出（文件所有者及root可使用）


4.2 VIM使用技巧

Linux学习
Linux > 4 文本编辑器 Vi/Vim >
4.2 VIM使用技巧

Vim使用技巧

导入命令执行结果 ：r !命令

：r 文件名 可以导入文件中的内容到光标位置

：r !date 把时间插入到vim中

定义快捷键 ：map 快捷键 触发命令

范例： map ^P I#<ESC> #表示定义的是P这个快捷键 I-->跳到行首并进入插入模式 插入# +<ESC>进入命令模式

使用的时候按Ctrl+p

删除快捷方式 map ^B 0x 建立快捷方式Ctrl+b 用0跳到行首，用x删除光标内容

插入邮箱地址 map ^H ijdsoft_li@163.com <ESC> 使用快捷方式Ctrl+h插入邮箱，完成后退回命令模式

连续行注释

：n1,n2s/^/#/g ^表示行首 替换命令的使用 g不需要确认

1,4s/^/#/g 把第1行到第4行行首用#替换，不需要确认

：n1,n2s/^#//g 1,4s/^#//g 去掉行首的#号

：n1,n2s/^\/\//g 行首加//注释

替换

：ab mymail jdsoft_li@163.com mymail+回车，就会变成邮箱地址

注意：我们可以在家目录中创建配置文件，方便使用， vi /root/.vimrc 只能编辑命令


5 Shell基础

Linux学习
Linux >
5 Shell基础

Shell的简介

Shell的本意是“壳”的意思，其实已经很形象地说明了shell在Linux系统中的作用。Shell就是围绕在Linux内核之外的一个“壳”程序，用户在操作系统上完成的所有任务都是通过shell与Linux系统内核的交互来实现的 。

所以也可以认为Shell是用户和Linux操作系统之间的接口。Linux中有多种shell，其中缺省使用的是bash 。
Shell最重要的功能是命令解释，从这种意义上说，Shell是一个命令解释器。Linux系统中的所有可执行文件都可以作为Shell命令来执行。Linux系统上可执行文件的分类见下表。

下图描述了Shell是如何完成命令解释的：

命令解释过程

当用户提交了一个命令后，Shell首先判断它是否为内置命令，如果是就通过Shell内部的解释器将其解释为系统功能调用并转交给内核执行；若是外部命令或实用程序就试图在硬盘中查找该命令并将其调入内存，再将其解释为系统功能调用并转交给内核执行。

在查找该命令时分为两种情况：

1. 用户给出了命令的路径，Shell就沿着用户给出的路径进行查找，若找到则调入内存，若没找到则输出提示信息。

2. 用户没有给出命令的路径，Shell就在环境变量PATH所制定的路径中依次进行查找，若找到则调入内存，若没找到则输出提示信息。

注释：

1. 内置命令是包含在Shell自身当中的，在编写Shell的时候就已经包含在内了，当用户登录系统后就会在内存中运行一个Shell，由其自身负责解释内置命令。一些基本的命令如cd、exit等都是内置命令。查看内置命令的使用方法可以用 help 命令。

2. 外部命令是存在于文件系统某个目录下的具体的可执行程序，如文件拷贝命令cp，就是在/bin目录下的一个可执行文件。查看外部命令的使用方法可以用 man 或 info 命令。外部命令也可以是某些商业或自由软件，如mozilla等。

此外，Shell还具有如下的一些功能：

通配符

命令补全、别名机制、命令历史

重定向

管道

命令替换

Shell编程语言

Shell的主要版本

注释：

1.shell：
简单来说就是一个"工具"，它是一个命令行解释器，把用户输入的命令传输到内核去执行。

2.bash
我们要知道，shell不止有一种，它的种类众多，而最常见的就是bash，全称为borne again shell，linux默认就是bash

3.terminal
这是一个用户终端，用来启动bash（或者说shell，因为linux默认是bash）环境，这也可以说算是一个“工具”，对比一下，terminal这个工具活跃在为用户服务的前端，而shell这个工具活跃在为用户服务的后端。

4.xshell
xshell: 是一个强大的安全终端模拟软件，支持SSH1, SSH2, 以及Microsoft Windows 平台的TELNET 协议，可以在Windows界面下用来访问远端不同系统下的服务器，从而比较好的达到远程控制终端的目的。 xshell 连接到远程服务端，需要 主机ip地址，端口号，用户名 密码

当用户登录系统后，如果登录字符界面，将出现shell命令提示符。“#”表示登录的用户是系统超级用户，“$”表示登录到系统的是普通用户 。
最后，shell还是强大的解释行程序设计语言，它定义了各种选项和变量，几乎支持高级程序语言的所有结构，如变量、函数、表达式和循环等。利用shell可以编写shell脚本程序，类似于Windows/DOS下的批处理文件，但是shell功能更加完善，更加强大。
归纳：

Shell是一个命令行解释器，它为用户提供了一个向Linux内核发送请求以便运行程序的界面系统级程序，用户可以用Shell来启动、挂起、停止甚至是编写一些程序。

Shell还是一个功能相当强大的编程语言，易编写，易调试，灵活性较强。Shell是解释执行的脚本语言，在Shell中可以直接调用Linux系统命令。

Bash是作为用户的基本Shell（默认）。


5.1 命令echo

Linux学习
Linux > 5 Shell基础 >
5.1 命令echo

命令的学习

1.echo输出命令

[root@localhost ~]# echo [选项] [输出内容]
选项：
-e： 支持反斜线控制的字符转换

注意：echo 中间有空格需要加双引号，没有的话可以直接写，！在Linux中有特殊作用，如果非要加使用单引号

[root@localhost ~]# echo 123456
123456
[root@localhost ~]# echo "hello world"
hello world
[root@localhost ~]# echo "hello world!"
-bash: !": event not found
[root@localhost ~]# echo 'hello world!'
hello world!

控制字符 | 作用
\\ | 输出\本身
\a | 输出警告音
\b | 退格键，也就是向左删除键
\c | 取消输出行末的换行符。和“-n”选项一致
\e | ESCAPE键
\f | 换页符
\n | 换行符
\r | 回车键
\t | 制表符，也就是tab键
\v | 垂直制表符
\0nnn | 按照八进制ASCII码表输出字符。其中0为数字0，nnn为三位八进制数
\xhh | 按照十六进制ASCII码表输出字符。其中hh是两位十六进制数

[root@localhost ~]# echo -e "ab\bc" #删除左侧字符
ac
[root@localhost ~]# echo -e "a\tb\tc\nd\te\tf" #制表符与换行符
a b c
d e f
[root@localhost ~]# echo -e "\x61\t\x62\t\x63\n\x64\t\x65\t\x66" #安装十六进制ASCII码也可以同样输出
a b c
d e f
[root@localhost ~]# echo -e "\e[1;31m abcd\e[0m" #输出颜色，\e[1表示开始颜色输出，\e[0m表示结束颜色输出
abcd

#30m=黑色，31m=红色，32m=绿色，33m=黄色

#34m=蓝色，35m=洋色，36m=青色，37m=白色


5.2 命令date

Linux学习
Linux > 5 Shell基础 >
5.2 命令date

命令 date

上面有使用date命令，这个命令在shell脚本中使用很频繁，最常见的几个用法如下：
date +%Y ：表示以四位数字格式打印年份
date +%y ：表示以两位数字格式打印年份
date +%m ：表示月份
date +%d ：表示日期
date +%H ：表示小时
date +%M ：表示分钟
date +%S ：表示秒
date +%w ：表示星期，0~6，0表示星期天

参数说明
-d datestr : 显示 datestr 中所设定的时间 (非系统时间)–help : 显示辅助讯息
-s datestr : 将系统时间设为 datestr 中所设定的时间
-u : 显示目前的格林威治时间
–version : 显示版本编号
范例：有时，在脚本中会用到一天前的日期：

一小时前：

一分钟前：


5.3 脚本执行方式

Linux学习
Linux > 5 Shell基础 >
5.3 脚本执行方式

脚本执行方式

1.创建第一个脚本

2.脚本执行

（1）赋予执行权限，之间运行

  • [root@localhost sh]# chmod 755 hello.sh #赋予执行权限
  • ./hello.sh

（2）通过Bash调用执行脚本

  • bash hello.sh

[root@localhost sh]# cat h.sh
#!/bin/Bash #不是注释，是一个标志，标称写的内容为Bash，Shell脚本
#The first program #一定要写完整的注释
#Author:lixiaozhi #一定要有良好的注释

echo -e "Hello World!"
echo -e '\e[1;31m Hello World!\e[0m'

执行报错
[root@localhost sh]# ./h.sh
-bash: ./h.sh: /bin/Bash: 坏的解释器: 没有那个文件或目录
[root@localhost sh]# cat -A h.sh
#!/bin/Bash #M-dM-8M-^MM-fM-^XM-/M-fM-3M-(M-iM-^GM-^JM-oM-< M-^LM-fM-^XM-/M-dM-8M-^@M-dM-8M-*M-fM - M-^GM-eM-?M-^WM-oM-<M-^LM-fM- M-^GM-gM-'M-0M-eM-^FM-^YM-gM-^ZM-^DM-eM-^FM-^EM-eM-.M-9M-dM-8M-:BashM-oM-<M-^LShellM-hM-^DM-^ZM-fM-^\M-,$
#The first program #M-dM-8M-^@M-eM-.M-^ZM-hM-&M-^AM-eM-^FM-^YM-eM-.M-^LM-fM-^UM-4M-gM-^ZM-^DM-fM-3M-(M-iM-^GM-^J$
#Author:lixiaozhi #M-dM-8M-^@M-eM-.M-^ZM-hM-&M-^AM-fM-^\M-^IM-hM-^IM-/M-eM-%M-=M-gM-^ZM-^DM-fM-3M-(M-iM-^GM-^J$
$
echo -e "Hello World!"$
echo -e '\e[1;31m Hello World!\e[0m'$

注意：在Linux中回车符是$，window 是^表示，所以Linux中不认它。

解决方案：转换一下即可

[root@localhost sh]# yum -y install dos2unix.x86_64 #使用yum安装转换软件

[root@localhost sh]# dos2unix square.sh #这个是俄罗斯方块.sh
dos2unix: converting file square.sh to Unix format ...

下面来编写一个脚本：

Shell脚本通常都以.sh作为后缀名，不是说不加.sh的脚本不能运行，只是大家的习惯，这样也方便辨识。
上面，第一行以 #!/bin/bash 开头，表示该文件使用的是bash语法，不设置该行也可以执行，但不符合规范。#表示注释，后面跟一些该脚本的相关注释内容，以及作者、创建日期或版本等。注释可以省略，但不建议省略，因为我们的记忆力有限，没有注释我们自己都不知自己写的脚本是用来干什么的、是什么时候写的。建议从一开始就要养成写脚本的良好习惯，方便自己也方便他人。

下面来执行上面的脚本：

另外一种执行方式：

使用上面方法来执行shell脚本的前提是脚本本身又执行权限，所以需要给脚本加一个x权限。
另外，使用sh脚本命令执行脚本时，可以加 –x 选项来查看脚本的执行过程：


5.4 Bash的基本功能（上）

Linux学习
Linux > 5 Shell基础 >
5.4 Bash的基本功能（上）

Bash基本功能

1.历史命令与命令补全

[root@localhost ~]#history [选项] [历史命令保存文件]
选项：
-c: 清空历史命令
-w: 把缓存中的历史命令写入历史命令保存文件
~/.bash_history #历史命令保存器

历史命令默认会保存1000条可以在环境变量配置文件/etc/profile中进行修改

历史命令的调用

  • 使用上、下箭头调用以前的历史命令
  • 使用“!n”重复执行第n条历史命令
  • 使用“!!”重复执行上一条命令
  • 使用“!字串”重复执行最后一条以该字串开头的命令

命令与文件补全

在Bash中，命令与文件补全是非常方便与常用的功能，我们只要在输入命令或文件时，按“Tab”键就会自动进行补全
[root@localhost ~]# if <按TAB键>
if ifcfg ifconfig ifdown ifenslave ifnames ifrename ifup
[root@localhost ~]# if
可以从上面看到，用户输入“if”后按tab键，即可显示以“if”为前缀的所有命令和文件。如果需要的是ifconfig命令，那么只须再次输入“co”，然后按TAB键，shell就能补全命令。
如果我们要进入一个很深的目录中，并且每个目录的名字又很长，此时利用bash的自动补全功能，就再好不过了

2.命令别名与常用快捷键

[root@localhost ~]#alias 别名='原命令' #设定命令别名
[root@localhost ~]#alias #查询命令别名

[root@localhost sh]# alias vi='vim'
[root@localhost
sh]# alias
alias cp='cp -i'
alias
egrep='egrep --color=auto'
alias fgrep='fgrep --color=auto'
alias
grep='grep --color=auto'
alias l.='ls -d .* --color=auto'
alias ll='ls -l
--color=auto'
alias ls='ls --color=auto'
alias mv='mv -i'
alias rm='rm
-i'
alias vi='vim'
alias which='alias | /usr/bin/which --tty-only --read-alias
--show-dot --show-tilde'< /FONT>

命令执行时顺序

  1. 第一顺位执行用绝对路径或相对路径执行的命令
  2. 第二顺位执行别名
  3. 第三顺位执行Bash的内部命令
  4. 第四顺位执行按照$PATH环境变量定义的目录查找顺序找到的第一个命令

让别名永久有效

[root@localhost ~]#vi /root/.bashrc

删除别名

[root@localhost ~]#unalias 别名

Bash常用快捷键

快捷键 | 作用
ctrl+A | 把光标移动到命令行开头。如果我们输入的命令过长，想要把光标移动到命令行开头时使用
ctrl+E | 把光标移动到命令行结尾
ctrl+C | 强制终止当前的命令
ctrl+L | 清屏，相当于clear命令
ctrl+U | 删除或剪切关标之前的命令。输入了一行很长的命令，不用使用退格键一个一个字符删除，使用这个快捷键会更加方便
ctrl+K | 删除或剪切关标之后的内容
ctrl+Y | 粘贴ctrl+U或ctrl+K剪切的内容
ctrl+R | 在历史命令中搜索，按下ctrl+R之后，就会出现搜索界面，只要输入搜索内容，就会从历史命令中搜索
ctrl+D | 退出当前终端
ctrl+Z | 暂停，并放入后台。
ctrl+S | 暂停屏幕输出
ctrl+Q | 恢复屏幕输出

3.Shell的重定向
1.标准输入输出

设备 | 设备文件名 | 文件描述符 | 类型
键盘 | /dev/stdin | 0 | 标准输入
显示器 | /dev/sdtout | 1 | 标准输出
显示器 | /dev/sdterr | 2 | 标准错误输出

所谓的重定向，就是不使用系统默认的标准输入/输出，而是重新指定，因此重定向分为输入重定向、输出重定向和错误输出重定向要实现重定向就需要了解重定向操作符，shell就是根据重定向操作符来决定重定向操作的。
（1） 输入重定向（实际工作中用的不多，主要是打补丁会用到）
[root@localhost ~]#wc [选项] [文件名]
选项：
-c 统计字节数
-w 统计单词数
-l 统计行数

输入重定向用于改变命令的输入源，利用输入重定向，就可以将一个文件的内容作为命令的输入，而不从键盘输入。（CTRL+D）

用于输入重定向的操作符有“<”和“<<”。例如：

这里用wc命令统计输入给它的文件/etc/inittab的函数、单词数和字符数。
还有一种输入重定向操作符“<<”。这种重定向告诉shell，当前命令的标准输入为来自命令行中一对分隔号之间的内容。例如(用的更少)：

上面的命令将一对分隔号aa之间的内容作为wc命令的输入。分隔号可以是任意字符。Shell将在第一个分隔号后开始读取内容，直到出现另一个分隔号读取结束，然后将内容送给wc命令处理。
（2） 输出重定向

类型 | 符号 | 作用
标准输出重定向 | 命令 >文件 命令 >>文件 | 以覆盖的方式，把命令的正确输出输出到指定的文件或设备当中 以追加的方式，把命令的正确输出输出到指定的文件或设备当中
标准错误输出重定向 | 错误命令 2>文件 错误命令 2>>文件 | 以覆盖的方式，把命令的错误输出输出到指定的文件或设备当中 以追加的方式，把命令的错误输出输出到指定的文件或设备当中
输出重定向不是将命令的输出结果在屏幕上输出，而是输出到一个指定文件中。
例如：

这条命令将ps -ef输出的系统运行进程信息全部输入到了ps.txt文件，而不是输出到屏幕，可以用more命令查看ps.txt文件中系统运行的进程信息。

其中，more命令用于查看文件的内容，上面的命令是将file1/file2/file3的内容全部输出到file文件中，类似于文件内容的合并。
如果在“>”后面指定的文件不存在，shell就会自动重建一个；如果文件存在，那么这个文件原有的内容将被覆盖；如果不想覆盖存在的文件，可以使用“>>”操作符。例如

这条命令 w将/etc目录及其子目录下的所有文件信息追加到/root/install.log文件的后面，/root/install.log文件原来的内容仍然存在。

实际工作中，正确输出和错误输出同时保存

命令 > 文件 2>&1 | 以覆盖的方式，把正确输出和错误输出都保存到同一个文件当中
命令 >> 文件 2>&1 | 以追加的方式，把正确输出和错误输出都保存到同一个文件当中
命令 &>文件 | 以覆盖的方式，把正确输出和错误输出都保存到同一个文件当中
命令 &>>文件 | 以追加的方式，把正确输出和错误输出都保存到同一个文件当中
命令 >>文件1 2>>文件2 | 把正确的输出追加到文件1中，把错误的输出追加到文件2中

[root@localhost ~]# ls &>/dev/null #不保存任何错误，执行就行


5.5 Bash的基本功能（下）

Linux学习
Linux > 5 Shell基础 >
5.5 Bash的基本功能（下）

bash的基本功能

1.多命令顺序执行

多命令执行符 | 格式 | 作用
; | 命令1;命令2 | 多个命令顺序执行，命令之间没有任何逻辑联系
&& | 命令1&&命令2 | 逻辑与 当命令1正确执行，则命令2才会执行 当命令1执行不正确，则命令2不会执行
|| | 命令1 || 命令2 | 逻辑或 当命令1执行不正确，则命令2才会执行 当命令1执行正确，则命令2不会执行

dd命令是Linux磁盘复制或数据复制，能复制特殊命令，特殊文件，也能复制分区，甚至整个硬盘，可以当做磁盘对拷对待

[root@localhost ~]#dd if=输入文件 of=输出文件 bs=字节数 count=个数
选项：
if=输入文件 指定源文件或源设备
of=输出文件 指定目标文件或目标设备
bs=字节数 指定一次输入/输出多少字节，即把这些字节看做一个数据块
count=个数 指定输入/输出多少个数据块

[root@localhost ~]# date;dd if=/dev/zero of=/root/testfile bs=1k count=100000;date #创建100mb文件需要多长时间
2021年 12月 24日 星期五 20:26:21 CST
记录了100000+0 的读入
记录了100000+0 的写出
102400000字节(102 MB)已复制，1.32417 秒，77.3 MB/秒
2021年 12月 24日 星期五 20:26:22 CST

[root@localhost ~]# ls && echo yes #第一条命令可以执行，输出yes
anaconda-ks.cfg file install.log ps.txt sogou 公共 视频 文档 音乐
error.txt initial-setup-ks.cfg lianxi sh testfile 模板 图片 下载 桌面
yes
[root@localhost ~]# ls gdafa && echo yes #第一条命令出现错误，就不会输出
ls: 无法访问gdafa: 没有那个文件或目录

我们有些命令需要执行第1个才能执行第2个，执行第2个后才能执行第3个

[root@localhost ~]# ls || echo no #当执行第一条命令，就不会输出
anaconda-ks.cfg file install.log ps.txt sogou 公共 视频 文档 音乐
error.txt initial-setup-ks.cfg lianxi sh testfile 模板 图片 下载 桌面

[root@localhost ~]# ls /lianxi && echo yes || echo no #当ls执行报错，第2个命令不执行，执行no
ls: 无法访问/lianxi: 没有那个文件或目录
no
[root@localhost ~]# ls ./lianxi && echo yes || echo no #当ls执行第2个命令，不执行no
cesi1 cesi2 Cesilocate issue.hard program yasuo yasuo.tar.bz2
cesi1.tar.gz cesilocate find issue.soft ps_bak.txt yasuo.bz2 yasuo.zip
yes

2. Shell的管道

[root@localhost ~]#命令1 | 命令2 #命令1的正确输出作为命令2的操作对象

管道可以把很多命令连接起来，可以把第1个命令的输出当作第2个命令的输入，第2个命令的输出当作第3个命令的输入，依次类推。因此，管道的作用就是把一个命令的输出当作下一个命令的输入，而不经过任何中间文件。
通过管道符 “|” 可以建立管道连接，例如：
[root@localhost ~]# ls -al /etc/* |more
这条命令表示将/etc目录以及子目录下的所有文件分屏显示。
[root@localhost ~]# ps -ef| grep httpd|wc -l
这个命令用户查看系统中正在运行的httpd进程，并统计httpd的进程数。

[root@localhost ~]# grep "root" /etc/passwd #显示在passwd文件中包含root的行
root:x:0:0:root:/root:/bin/bash
operator:x:11:0:operator:/root:/sbin/nologin

3. Shell的通配符（匹配文件名）

通配符 | 作用
？ | 匹配一个任意字符
* | 匹配0个或任意多个任意字符，也就是可以匹配任何内容
[ ] | 匹配中括号中任意一个字符。例如[abc]代表一定匹配一个字符，或者是a,或者是b,或者是c
[-] | 匹配中括号中任意一个字符，-代表一个范围。例如：[a-z]代表匹配一个小写字母
[^] | 逻辑非，表示匹配不是中括号内的一个字符。例如：[^0-9]代表匹配一个不是数字的字符

Bash中常用的通配符有 “*” “？” “[]”。
（1）“*”——匹配任意一个或多个字符
例如：[root@localhost ~]# ls *.txt
这条命令列出当前目录中所有以“.txt”结尾的文件（除去以“.”开头的文件）。
例如：[root@localhost ~]# cp doc/* /opt
这条命令表示将doc目录下的所有文件（除去以“.”开头的文件）复制到/opt目录下。
例如：[root@localhost ~]# ls -al /etc/*/*.conf
这条命令列出/etc目录的子目录下所有以“.conf”结尾的文件。在/etc目录下以“.conf”结尾的文件不会列出
（2）“？”——匹配任意单一字符
例如：[root@localhost ~]# ls ab?.txt
这条命令列出当前目录下以ab开头，随后一个字母是任意字符，接着以“.txt”结尾的文件。
例如：[root@localhost ~]# ls ab??.txt
这条命令列出当前目录下以ab开头，随后两个字母是任意字符，接着以“.txt”结尾的文件。
（3）“[]”——匹配任何包含在方括号内的单子符
例如：[root@localhost ~]# ls /dev/sda[12345]
/dev/sda1 /dev/sda2 /dev/sda3 /dev/sda4 /dev/sda5
上面的命令列出了在/dev目录下以sda开头，第4个字符是1/2/3/4/5的所有文件。
例如：[root@localhost ~]# ls /dev/sda[1-5]
在方括号“1-5”给出了匹配的范围，与上面一条命令完全等效。
（4）通配符的组合使用
在Linux下，通配符也可以组合使用
例如：[root@localhost ~]# ls [0-9]?.conf
这条命令列出当前目录下以数字开头，随后一个是任意字符，接着以“.conf”结尾的所有文件。
例如：[root@localhost ~]# ls [xyz]*.txt
这条命令列出当前目录下以x/y/z开头，最后以“.txt”结尾的文件。

4. Shell中其他特殊符号
符号 | 作用
'' | 单引号。在单引号中所有的特殊符号，如“$”和“·”（反引号）都没有特殊含义
"" | 双引号。在双引号中特殊字符都没有特殊含义，但是“$”、“·”和“\”是例外，拥有“调用变量的值”、“引用命令”和“转义符” 的特殊含义
·· | 反引号。反引号括起来的内容是系统命令，在Bash中回先执行它。和$()作用一样，不过推荐使用$(),因为反引号容易看错
$() | 和反引号作用一样，用来引用系统命令
# | 在Shell脚本中，#开头的行代表注释
$ | 用于调用变量的值，如需要调用变量name的值时，需要用$name的方式得到变量的值
\ | 转义符，跟在\之后的特殊符号将失去特殊含义，变成普通字符。如\$将输出“$”符号，而不当作是变量引用

（1） 转义字符 “ \ ”
如果将“\”放到特殊字符前面，shell就会忽略这些特殊字符的原有含义，把它们当作普通字符对待，例如：
[root@localhost ~]# ls
[root@localhost ~]# mv abc\?\* abc
[root@localhost ~]# mv C\:\\backup backup
上面是将abc?*重名名为abc，将C:\backup重命名为backup。因为文件名中包含特殊字符，所以都使用了转义字符“\”。
（2） 单引号 “ ' ”
如果将字符串放到一对单引号之间，那么字符串中所有字符的特殊含义将被忽略，例如：
[root@localhost ~]# mv C\:\\backup backup
[root@localhost ~]# mv 'C:\backup' backup
上面两条命令完全等效。
（3） 双引号 “ "" ”
双引号的引用与单引号基本相同，包含在双引号内的大部分特殊字符可以当作普通字符处理，但是仍有一些特殊字符即使用双引号括起来，也仍然保留自己的特殊含义，比如“$”、“\”，“’”。
[root@localhost ~]# str="The \$SHELL Current shell is $SHELL"
[root@localhost ~]# str1="\$$SHELL"
[root@localhost ~]# echo $str
The $SHELL Current shell is /bin/bash
[root@localhost ~]# echo $str1
$/bin/bash
从上面的输出可以看出，“$”和“\”在双引号内仍然保留了特殊含义。
[root@localhost ~]# str="This hostname is 'hostname'"
[root@localhost ~]# echo $str
This hostname is 'hostname'
上面的输出中，字符“’”在双引号中也保留了自己的特殊含义。

[root@localhost ~]# name=lxz
[root@localhost ~]# echo $name
lxz
[root@localhost ~]# echo '$name'
$name
[root@localhost ~]# echo "$name"
lxz

[root@localhost ~]# echo $(date)
2021年 12月 24日 星期五 22:08:23 CST

5. Shell元字符

在Shell中有一些具有特殊的意义字符，称为 Shell元字符（shell metacharacters）。若不以特殊方式指明，Shell并不会把它们当做普通文字符使用。
下表简单介绍了常用的Shell元字符的意义：


5.6 Bash的变量

Linux学习
Linux > 5 Shell基础 >
5.6 Bash的变量

Bash变量

1.什么是变量

变量是计算机内存的单元，其中存放的值可以改变。当Shell脚本需要保存一些信息时，如一个文件名或是一个数字，就把它存放在一个变量中。每个变量有一个名字，所以很容易应用它。使用变量可以保存有用信息，使系统获知用户相关设置，变量也可以用于保存暂时信息。

2.变量设置规则

  • 变量名称可以由字母、数字和下划线组成，但是不能以数字开头。如果变量名是“2name”则是错误的。
  • 在Bash中，变量的默认类型都是字符串型，如果要进行数值运算，则必须指定变量类型为数值型。
  • 变量用等号连接值，等号左右两侧不能有空格。
  • 变量的值如果有空格，需要使用单引号或双引号包括。
  • 在变量的值中，可以使用“\”转义符。
  • 如果需要增加变量的值，那么可以进行变量值的叠加。不过变量需要用双引号包含“$变量名”或用${变量名}包含。
  • 如果是把命令的结果作为变量值赋予变量，则需要使用反引号或$()包含命令。
  • 环境变量名建议大写，便于区分。

3.变量分类

  • 用户自定义变量（最常用的）
  • 环境变量：这种变量中主要保存的是和系统操作环境相关的数据
  • 位置参数变量：这种变量主要是用来向脚本当中传递参数或数据的，变量名不能自定义，变量作用是固定的
  • 预定义变量：是Bash中已经定义好的变量，变量名不能自定义，变量作用也是固定的。

4.用户自定义变量（本地变量）

变量定义：[root@localhost ~]# name="lixiaozhi" #变量定义，有空格用双引号或单引号括起来

变量叠加

[root@localhost ~]# aa=123
[root@localhost ~]# aa="$aa"456
[root@localhost ~]# aa=${aa}789< /FONT>

[root@localhost ~]# echo $aa
123456789

变量调用

在脚本中应用变量时需要加上符号$。
[root@localhost ~]# echo $name #调用变量

变量查看

[root@localhost ~]# set #查看系统的所有变量
[root@localhost ~]# set | grep "name"

变量删除

[root@localhost ~]# unset #删除变量

5.环境变量

1）环境变量是什么

用户自定义变量旨在当前的Shell中生效，而环境变量会在当前Shell和这个Shell的所有子Shell当中生效。如果把环境变量写入相应的配置文件，那么这个环境变量就会在所有Shell中生效。

2）设置环境变量

export 变量名=变量值 #申明变量
env #专门查询环境变量
unset 变量名 #删除变量

有一个概念需要了解父shell和子shell
[root@localhost ~]# bash #进入一个子shell
[root@localhost ~]# pstree #查看树形结构进程
[root@localhost ~]# exit #退出子shell

[root@localhost ~]# echo $name
lixiaozhi
[root@localhost ~]# export age=18
[root@localhost ~]# bash
[root@localhost ~]# echo $age
18

3）系统常见环境变量
PATH：系统查找命令的路径
[root@localhost ~]# echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin
[root@localhost sh]# cp ./hello.sh /root/bin
[root@localhost ~]# hello.sh
Hello World!

PAHT="$PATH":/root/sh #PATH变量叠加

[root@localhost ~]# PATH="$PATH":/root/sh
[root@localhost ~]# hello.sh
Hello World!
[root@localhost ~]# echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/root/sh

4）PS1:定义系统提示符的变量

\d：显示日期，格式为“星期 月 日”
\h：显示简写主机名。如默认主机名“localhost”
\t：显示24小时制时间，格式为“HH:MM:SS”
\T：显示12小时制时间，格式为“HH:MM:SS”
\A：显示24小时制时间，格式为“HH:MM”
\u：显示当前用户名
\w：显示当前所在目录的完整名称
\W：显示当前所在目录的最后一个目录
\#：执行的第几个命令
\$：提示符。如果是root用户会显示提示符为“#”，如果是普通用户会显示提示符为“$”

[root@localhost ~]# echo $PS1
[\u@\h \W]\$
[root@localhost ~]# PS1='[\u@\t\w]\$ '
[root@10:56:03~]# cd /usr/local/src
[root@10:56:49/usr/local/src]# PS1='[\u@\@ \h \#\W]\$ '
[root@10:57 上午 localhost 31src]# PS1='[\u@\h \W]\$ '
[root@localhost src]#
临时的修改，重启或者重新登录就修改回去了

6.位置参数变量

位置参数变量 | 作用
$n | n为数字，$0代表命令本身，$1-$9代表第一到第九个参数，十以上的参数需要用大括号包含，如${10}
$* | 这个变量代表命令行中所有的参数，$*把所有的参数看成一个整体
$@ | 这个变量也代表命令行中所有的参数，不过$@把每个参数区分对待
$# | 这个变量代表命令行中所有参数的个数

[root@192 ~]# cd sh
[root@192 sh]# ls
hello.sh h.sh square.sh
[root@192 sh]# vi canshu.sh

#!/bin/bash
echo $0
echo $1
echo $2
echo $3
[root@192 sh]# chmod +x canshu.sh #修改脚本增加执行权限
[root@192 sh]# canshu.sh
/root/sh/canshu.sh

[root@192 sh]# canshu.sh 123 123 456
/root/sh/canshu.sh
123
123
456

范例1（求和）：
#!/bin/bash
#author:lixiaozhi
num1=$1
num2=$2
sum=$(($num1+$num2))
#变量sum的和是num1加num2
echo $sum
#打印变量sum的值
另一种写法
#!/bin/bash
sum=$(($1+$2))
echo "sum is :$sum"
[root@192 sh]# ./sum.sh 33 45
78

范例2：
#!/bin/bash
echo "A total of $# parameters" #使用$#代表所有参数的个数
echo "The parameter is: $*" #使用$*代表所有的参数
echo "The parameter is: $@" #使用$@也代表所有参数

[root@192 sh]# vi canshu1.sh
#!/bin/bash

echo $#
echo $*
echo $@

[root@192 sh]# canshu1.sh
-bash: /root/sh/canshu1.sh: 权限不够
[root@192 sh]# chmod 755 canshu1.sh
[root@192 sh]# canshu1.sh
0
[root@192 sh]# canshu1.sh 11 22 33 44 55 66
6
11 22 33 44 55 66
11 22 33 44 55 66

范例3:$*与$@的区别
[root@192 sh]# vi canshu2.sh
[root@192 sh]# chmod 755 canshu2.sh
[root@192 sh]# canshu2.sh 1 2 3 4
The parameters is : 1 2 3 4
The parameter1 is:1
The parameter2 is:2
The parameter3 is:3
The parameter4 is:4
[root@192 sh]# cat canshu2.sh
#!/bin/bash
for i in "$*"
#$*中的所有参数看成是一个整体，所以这个for循环只会循环一次
do
echo "The parameters is : $i"
done
x=1
for y in "$@"
#$@中的每个参数都看成是独立的，所以"$@"中有几个参数，就会循环几次
do
echo "The parameter$x is:$y"
x=$(($x+1))
done

7.预定义变量

预定义变量 | 作用
$? | 最后一次执行的命令的返回状态。如果这个变量的值为0，证明上一个命令正确执行；如果这个变量的值为非0（具体哪个数，由命令自己来决定），则证明上一个命令执行不正确。
$$ | 当前进程的进程号（PID）
$! | 后台运行的最后一个进程的进程号（PID）

[root@192 sh]# ls 123
ls: 无法访问123: 没有那个文件或目录
[root@192 sh]# echo $?
2

范例：
[root@192 sh]# vi variable.sh
[root@192 sh]# chmod 755 variable.sh
[root@192 sh]# variable.sh
The current process is 62038
The last one Daemon process is 62039
[root@192 sh]# /root/sh/hello.sh

#!/bin/bash
#Author byking

echo "The current process is $$"
#输出当前进程的PID
#这个PID就是variable.sh这个脚本执行时，生成的进程的PID

find /root -name hello.sh &
#使用find命令在root目录下查找hello.sh文件
#符号&的意思是把命令放入后台执行
echo "The last one Daemon process is $!"

8.接收键盘输入

[root@localhost ~]# read [选项] [变量名]
选项：
-p "提示信息"：在等待read输入时，输出提示信息，read命令会一直等待用户输入，使用此选项可以指定等待时间
-n 秒数： read命令只接受指定的字符数，就会执行
-s： 隐藏输入的数据，适用于机密信息的输入

#!/bin/bash
# Author:布衣king
read -t 30 -p "Please input your name:" name
echo "Name is $name"

read -s -t 30 -p "Please enter your age:" age
#年龄是隐私，所以我们用“-s”选项隐藏输入
echo -e "\n"
echo "Age is $age"

read -n 1 -t 30 -p "Please select your gender[M/F]:" sex
#使用“-n 1”选项只接收一个输入字符就会执行（都不用输入回车）
echo -e "\n"
echo "Sex is $sex"


5.6.1 数值运算与运算符

Linux学习
Linux > 5 Shell基础 > 5.6 Bash的变量 >
5.6.1 数值运算与运算符

数值运算与运算符

数值运算

[root@192 sh]# aa=11
[root@192 sh]# bb=22
[root@192 sh]# cc=$aa+$bb
[root@192 sh]# echo $cc
11+22

变量默认数据类型是字符串

1.declare声明变量类型
[root@localhost ~]# declare [+/-][选项] 变量名
选项：
-： 给变量奢姿那个类型属性
+： 取消变量的类型属性
-i: 将变量声明为整数型（integer）\
-x： 将变量声明为环境变量
-p： 显示指定变量的被声明的类型
[root@192 sh]# declare -p aa
declare -- aa="11"
[root@192 sh]# export aa
[root@192 sh]# declare -p aa
declare -x aa="11"< /FONT>

2.数值运算——方法1

[root@192 sh]# aa=11
[root@192 sh]# bb=22
#给变量aa和bb赋值
[root@192 sh]# declare -i cc=$aa+$bb
[root@192 sh]# declare -p cc
declare -i cc="33"< /FONT>

3.方法2：expr或let数值运算工具

[root@192 sh]# aa=11
[root@192 sh]# bb=22
#给变量aa和bb赋值
[root@192 sh]# dd= $(expr $aa+ $bb) #dd的值是aa和bb的和。注意“+”号左右两侧必须有空格< /FONT>

[root@192 sh]# dd=$(expr $aa + $bb) #加空格后的结果
[root@192 sh]# echo $dd
33
[root@192 sh]# dd=$(expr $aa+$bb) #没有加空格的结果
[root@192 sh]# echo $dd
11+22

4.方法3："$((运算式))"或“$[运算式]”

[root@192 sh]# aa=11
[root@192 sh]# bb=22
[root@192 sh]# ff=$(($aa+$bb))
[root@192 sh]# gg=$[$aa+$bb]
[root@192 sh]# echo $ff $gg
33 33< /P>

运算符（数值越大优先级越高）

优先级 | 运算符 | 说明
13 | -，+ | 单目负、单目正
12 | !，~ | 逻辑非、按位取反或补码
11 | *，/，% | 乘、除、取模
10 | +，- | 加，减
9 | <<,>> | 按位左移，按位右移
8 | <=,>=,<,> | 小于或等于，大于或等于，小于，大于
7 | ==,!= | 等于、不等于
6 | & | 按位与
5 | ^ | 按位异或
4 | | | 按位或
3 | && | 逻辑与
2 | || | 逻辑或
1 | =，+=，-=，*=，/=,%=,&=,^=,|=,<<=,>>= | 赋值、运算且赋值

[root@localhost ~]#aa=$(((11+3)*3/2))
#虽然乘和除的优先级高于加，但是通过小括号可以调整运算优先级
[root@localhost ~]#bb=$((14%3)) #14不能被3整除，余数是2
[root@localhost ~]#cc=$((1&&0))
#逻辑与运算只有想与的两边都是1，与的结果才是1，否则与的结果是0


5.6.2 变量测试与内容替换

Linux学习
Linux > 5 Shell基础 > 5.6 Bash的变量 >
5.6.2 变量测试与内容替换

变量测试与内容替换

系统默认的测试方法，能看懂就可以了

变量置换方式 | 变量y没有设置 | 变量y为空值 | 变量y设置值
x=${y-新值}< /FONT> | x=新值 | x为空 | x=$y
x=${y:-新值} | x=新值 | x=新值 | x=$y
x=${y+新值} | x为空 | x=新值 | x=新值
x=${y:+新值} | x为空 | x为空 | x=新值
x=${y=新值} | x=新值 y=新值 | x为空 y值不变 | x=$y y值不变
x=${y:=新值} | x=新值 y=新值 | x=新值 y=新值 | x=$y y值不变
x=${y?新值} | 新值输出到标准错误输出（屏幕） | x为空 | x=$y
x=${y:?新值} | 新值输出到标准错误输出 | 新值输出到标准错误输出 | x=$y

范例：


5.7 环境变量配置文件

Linux学习
Linux > 5 Shell基础 >
5.7 环境变量配置文件

环境变量配置文件

一、环境变量配置文件简介

1. source命令

[root@localhost ~]# source 配置文件
或
[root@localhost ~]# . 配置文件
作用：使配置的环境变量即时生效

2.环境变量配置文件简介

环境变量配置文件中主要是定义对系统的操作环境生效的系统默认环境变量，比如PATH（环境变量）/HISTSIZE（历史命令）/PSI（提示符）/HOSTNAME（系统名）等默认环境变量

环境变量有哪些：

/etc/profile
/etc/profile.d/*.sh
~/.bash_profile
~/.bashrc
/etc/bashrc

在etc中对所有用户都生效，~只对家目录生效

二、环境变量配置文件作用

1.配置文件的优先级

2./etc/profile的作用

USER变量：
LOGNAME变量：
MAIL变量：
PATH变量：
HOSTNAME变量：
HISTSIZE变量：
umask：

注意：写在后面的环境变量会覆盖前面的变量，除非使用变量叠加

三、其他配置文件和登录信息

1.注销时生效的环境变量配置文件

~/.bash_logout #可以把命令写到这个文件中，系统在注销的时候就会执行这些命令

2.其他配置文件

~/.bash_history #历史命令，排错使用

3.Shell登录信息

本地终端欢迎信息：/etc/issue

转义符 | 作用
\d | 显示当前系统日期
\s | 显示操作系统名称
\l | 显示登录的终端号，这个比较常用
\m | 显示硬件体系结构，如i386，i686等
\n | 显示主机名
\o | 显示域名
\r | 显示内核版本
\t | 显示当前系统时间
\u | 显示当前登录用户的序列号

远程终端欢迎信息：/etc/issue.net(不认上面的转义符)

转义符在/etc/issue.net文件中不能使用

是否显示此欢迎信息，由ssh的配置文件/etc/ssh/sshd_config决定，加入“Banner /etc/issue.net”行才能显示（记得重启ssh服务）

重启服务：service sshd restart #重启sshd服务

登陆后欢迎信息：/etc/motd

不管是本地登陆，还是远程登陆，都可以显示此欢迎信息


6 Shell编程

Linux学习
Linux >
6 Shell编程

Linux系统Shell编程

Shell脚本并不能作为正式的编程语言，因为它是在Linux的shell中运行的，所以称为shell脚本。事实上，shell脚本就是一些命令的集合。
假如完成某个需求需要一口气输入10条命令，对于简单的命令，我们可以直接在shell窗口中输入，但如果是比较长且复杂的命令，一次一次敲就会显得很麻烦。我们可以把这10条命令都记录到一个文档中，然后去调用文档中的命令，这样就能一步操作完成，以后再遇到这个需求的时候也只需要调用这个文档就行了，这个文档就是shell脚本，只是这个文档有它特殊的格式。
Shell脚本能帮我们很方便地管理服务器，我们可以指定一个任务计划，定时去执行某个shell脚本以满足需求。在正式编写shell脚本之前，建议将所有自定义脚本放到/user/local/sbin/目录下，意思可以更好地管理文档，二是方便后面的维护。


6.1 Shell编程

Linux学习
Linux > 6 Shell编程 >
6.1 Shell编程

Shell编程

1.正则表达式

2.字符截取命令

3.字符处理命令

4.条件判断

5.流程控制


6.1.1 正则表达式

Linux学习
Linux > 6 Shell编程 > 6.1 Shell编程 >
6.1.1 正则表达式

正则表达式基础

1.正则表达式与通配符

正则表达式用来在文件中匹配符合条件的字符串，正则是包含匹配。grep、awk、sed等命令支持正则表达式。

通配符用来匹配符合条件的文件名，通配符是完全匹配。ls、find、cp这些命令不支持正则表达式，所以只能使用shell自己的通配符来进行匹配（* / ? / [ ]）。

2.基础正则表达式

元字符 | 作用
* | 前一个字符匹配0次或任意多次
. | 匹配除了换行符外任意一个字符
^ | 匹配行首。例如：^hello会匹配以hello开头的行
$ | 匹配行尾。例如：hello$会匹配以hello结尾的行
[ ] | 匹配中括号中指定的任意一个字符，只匹配一个字符。例如：[aoeiu]匹配任意一个元音字母，[0-9]匹配任意一位数字，[a-z][0-9]匹配小写字和一位数字构成的两位字符
[^] | 匹配除中括号的字符以外的任意一个字符。例如：[^0-]
\ | 转义符。用于取消将特殊符号的含义取消
\{n\} | 表示其前面的字符恰好出现几次。例如：[0-9]\{4\}匹配4位数字，[1][3-8][0-9]\{9\}匹配手机号码
\{n,\} | 表示其前面的字符出现不小于n次。例如：[0-9]\{2,\}表示两位以上的数字
\{n,m\} | 表示其前面的字符至少出现n次，最多出现m次。例如：[a-z]\{6,8\}匹配6到8位的小写字母

测试用的文本：test_rule.txt

Mr. Li Ming said:
he was the honest man in Lampbrother.
123despise him.

But since Mr. shen Chao came,
he never saaaid those words.
5555nice!

because,actuaaaally,
Mr. Shen Chao is the most honest man!
Later,Mr. Li ming soid his hot body.

范例：

1."*"前一个字符匹配0次或任意多次

1）[root@localhost lianxi]# grep "a*" test_rule.txt #匹配所有内容，包括空白行

2）[root@localhost lianxi]# grep "aa*" test_rule.txt #匹配至少包含有一个a的行

3）[root@localhost lianxi]# grep "aaa*" test_rule.txt #匹配最少包含两个连续a的字符串

4）[root@localhost lianxi]# grep "aaaaa*" test_rule.txt #匹配最少包含四个连续a的字符串

2.“."匹配除了换行符外任意一个字符

1）[root@localhost lianxi]# grep "s..d" test_rule.txt #"s..d"会匹配在s和d这两个字母之间一定 有两个字符的单词

2）[root@localhost lianxi]# grep "s.*d" test_rule.txt #匹配在s和d字母之间的任意字符

3）[root@localhost lianxi]# grep ".*" test_rule.txt #匹配所有内容

3.“^”匹配行首，"$"匹配行尾

1）[root@localhost lianxi]# grep "^M" test_rule.txt #匹配以大写M开头的行

2）[root@localhost lianxi]# grep "n$" test_rule.txt #匹配以小写n结尾的行
3）[root@localhost lianxi]# grep "^$" test_rule.txt #匹配空白行

4."[ ]"匹配中括号中指定的任意一个字符，只匹配一个字符

1）[root@localhost lianxi]# grep "s[ao]id" test_rule.txt #匹配s和i字母中，要不是a,要不是o

2）[root@localhost lianxi]# grep "[0-9]" test_rule.txt #匹配任意一个数字

3）[root@localhost lianxi]# grep "^[a-z]" test_rule.txt #匹配用小写字母开头的行

5.“[^]"匹配除中括号的字符以外的任意一个字符

1）[root@localhost lianxi]# grep "^[^a-z]" test_rule.txt #匹配不用小写字母开头的行

2）[root@localhost lianxi]# grep "^[^a-z A-Z]" test_rule.txt #匹配不用字母开头的行

6.“\”转义符

[root@localhost lianxi]# grep "\.$" test_rule.txt #匹配使用“.”结尾的行

7.“\{n\}”表示其前面的字符恰好出现几次

1）[root@localhost lianxi]# grep "a\{3\}" test_rule.txt #匹配a字母连续出现三次的字符串

2）[root@localhost lianxi]# grep "[0-9]\{3\}" test_rule.txt #匹配包含连续的三个数字的字符串

8.“\{n,\}”表示其前面的字符出现不小于n次

[root@localhost lianxi]# grep "^[0-9]\{3,\}[a-z]" test_rule.txt #匹配最少用连续3个数字开头的行

9.“\{n,m\}”匹配其前面的字符至少出现n次，最多出现m次

[root@localhost lianxi]# grep "sa\{1,3\}i" test_rule.txt


6.1.2 字符截取命令

Linux学习
Linux > 6 Shell编程 > 6.1 Shell编程 >
6.1.2 字符截取命令

字符截取命令

1.cut字段提取命令

[root@localhost~]# cut [选项] 文件名
选项：
-f 列号： 提取第几列
-d分隔符： 按照指定分隔符分割列

范例：
[root@localhost~]# vi student.txt
ID Name PHP LINUX MYSQL AVERAGE
1 liming 82 95 86 87.66
2 sc 74 96 87 85.66
3 gao 99 83 93 91.66
[root@localhost~]# cut -f 2 student.txt
[root@localhost~]# cut -f 2,4 student.txt
[root@localhost~]# cut -d ":" -f 1,3 /etc/passwd
[root@localhost~]# cat /etc/passwd | grep /bin/bash | grep -v root | cut -d ":" -f 1

cut命令的局限(不是制表符，是空格符，无法分辨)

[root@localhost~]# df -h | grep "sda5" #查看分区使用状况
[root@localhost~]# df -h | cut -d " " -f 1,3 #查看分区使用状况

2.printf命令（awk中使用）

printf '输出类型输出格式' 输出内容
输出类型：
%ns： 输出字符串。n是数字指代输出几个字符
%ni： 输出整数。n是数字指代输出几个数字
%m.nf： 输出浮点数。m和n是数字，指代输出的整数位数和小数位数。如%8.2f代表共输出8位数，其中2位是小数，6位是整数
输出格式：
\a： 输出警告声音
\b： 输出退格键，也就是Backspace键
\f： 清除屏幕
\n： 换行
\r： 回车，也就是Enter键
\t： 水平输出退格键，也就是Tab键
\v： 垂直输出退格键，也就是Tab键

范例：

[root@localhost~]# printf %s 1 2 3 4 5 6
[root@localhost~]# printf %s %s %s 1 2 3 4 5 6
[root@localhost~]# printf '%s %s %s' 1 2 3 4 5 6
[root@localhost~]# printf '%s %s %s\n' 1 2 3 4 5 6
[root@localhost~]#cat student.txt | printf '%s' #没有结果输出
[root@localhost~]#prinf '%s' $(cat student.txt) #正确输出,变量赋值输出
[root@localhost~]#prinf '%s\t %s\t %s\t %s\t %s\t %s\n' $(cat student.txt) #调整格式输出

在awk命令的输出中支持print和printf命令

  • print：print会在每个输出之后自动加入一个换行符（Linux默认没有print命令）
  • printf：printf是标准格式输出命令，并不会自动加入换行符，如果需要换行，需要手工加入换行符

3.awk命令（比cut强大，awk是复杂的命令，可以经常编程，流程控制等）

# awk '条件1{动作1} 条件2{动作2}...' 文件名
条件 （Pattern）：
一般使用关系表达式作为条件
x>10 判断变量x是否大于10
x>=10 大于等于10
x<=10 小于等于10
动作 （Action）：
格式化输出
流程控制语句

注意：awk先读入第一行在开始处理

范例：
[root@localhost~]# awk '{printf $2 "\t" $6 "\n"}' student.txt #不做任何条件执行动作，显示第2和6列
[root@localhost~]# df -h | awk '{print $1 "\t" $3 "\t" $5}' #可以识别空格
[root@localhost~]# df -h | grep sda5 | awk '{print $5}'| cut -d "%" -f 1 #提取使用了多少空间

BEGIN

[root@localhost~]# awk 'BEGIN {printf "This is a transcript \n"} {printf $2 "\t" $6 "\n"}' student.txt
#BEGIN是条件,开始之前

END

[root@localhost~]# awk 'END {printf "This END \n"} {printf $2 "\t" $6 "\n"}' student.txt

FS内置变量

[root@localhost~]# awk '{FS=":"}' {printf $1 "\t" $3 "\n"} /etc/passwd
[root@localhost~]# awk 'BEGIN{FS=":"}' {printf $1 "\t" $3 "\n"} /etc/passwd
[root@localhost~]# cat /etc/passwd | grep "/bin/bash" | awk 'BEGIN { FS=":"} {printf $1 "\t" $3 "\n"}'

关系运算符

[root@localhost~]# cat student.txt | grep -v Name | awk '$6>=87 {printf $2 "\n"}'

4.sed命令

sed是一种几乎包括在所有UNIX平台（包括Linux）的轻量级流编辑器。sed主要是用来将数据进行选取、替换、删除、新增的命令。

[root@localhost~]# sed [选项] '[动作]' 文件名
选项：
-n: 一般sed命令会把所有数据都输出到屏幕，如果加入此选项，则只会把经过sed命令处理的行输出到屏幕。
-e: 允许对输入数据应用多条sed命令编辑
-i: 用sed的修改结果直接修改读取数据的文件，而不是由屏幕输出
动作：
a\： 追加，在当前行后添加一行或多行。添加多行时，除最后一行外，每行末尾需要用"\"代表数据未完结。
c\： 行替换，用c后面的字符串替换原数据行，替换多行时，除最后一行外，每行末尾需用"\"代表数据未完结。
i\： 插入，在当期行前插入一行或多行。插入多行时，除最后一行外，每行末尾需要用"\"代表数据未完结。
d： 删除，删除指定的行。
p： 打印，输出指定的行。
s： 字串替换，用一个字符串替换另外一个字符串。格式位"行范围s/旧字串/新字串/g"(和vim中的替换格式类似)。

范例：sed输出都不影响文件本身，只是影响屏幕输出

行数据操作：
[root@localhost~]# sed '2p' student.txt #查看文件的第2行
[root@localhost~]# sed -n '2p' student.txt #查看文件的第2行
[root@localhost~]# sed '2,4d' student.txt #删除第二行到第四行的数据，但不修改文件本身
[root@localhost~]# df -h | sed -n '2p'
[root@localhost~]# sed '2a hello' student.txt #在第二行后追加hello
[root@localhost~]# sed '2i hello \ world' student.txt #在第二行前插入两行数据
[root@localhost~]# sed '2c No such person' student.txt #数据替换

字符串替换：
[root@localhost~]# sed 's/旧字串/新字串/g' 文件名
[root@localhost~]# sed '3s/74/99/g' student.txt #在第三行中，把74换成99
[root@localhost~]# sed -i '3s/74/99/g' student.txt #sed操作的数据直接写入文件
[root@localhost~]# sed ie 's/Liming//g；s/Gao//g' student.txt #同时把Liming和Gao替换为空


6.1.3 字符处理命令

Linux学习
Linux > 6 Shell编程 > 6.1 Shell编程 >
6.1.3 字符处理命令

字符处理命令

1.排序命令sort

[root@localhost ~]#sort [选项] 文件名
选项：
-f： 忽略大小写
-n： 以数值型进行排序，默认使用字符串型排序
-r： 反向排序
-t： 指定分隔符，默认分隔符是制表符
-k n[,m] 按照指定的字段范围排序。从第n字段开始，m字段结束（默认到行尾）

[root@localhost ~]#sort /etc/passwd #排序用户信息文件
[root@localhost ~]#sort -r /etc/passwd #反向排序
[root@localhost ~]#sort -t ":" -k 3,3 /etc/passwd #指定分隔符是“:”，用第三字段开头，第三字段结尾排序，就是只用第三字段排序。
[root@localhost ~]#sort -n -t ";" -k 3,3 /etc/passwd

2.统计命令wc

[root@localhost ~]#wc [选项] 文件名
选项：
-l: 只统计行数
-w: 只统计单词数
-m: 只统计字符数

[root@localhost ~]# wc /etc/passwd
 43 87 2262 /etc/passwd


6.1.4 条件判断

Linux学习
Linux > 6 Shell编程 > 6.1 Shell编程 >
6.1.4 条件判断

条件判断

1.安装文件类型进行判断

测试选项 | 作用
-b文件 | 判断该文件是否存在，并且是否为块设备文件（是块设备文件为真）
-c文件 | 判断该文件是否存在，并且是否为字符设备文件（是字符设备文件为真）
-d文件 | 判断该文件是否存在，并且是否为目录文件（是目录为真）
-e文件 | 判断该文件是否存在（存在为真）
-f文件 | 判断该文件是否存在，并且是否为普通文件（是普通文件为真）
-L文件 | 判断该文件是否存在，并且是否为符号链接文件（是符号链接文件为真）
-p文件 | 判断该文件是否存在，并且是否为管道文件（是管道文件为真）
-s文件 | 判断该文件是否存在，并且是否为非空（非空为真）
-s文件 | 判断该文件是否存在，并且是否为套接字文件（是套接字文件为真）

两种判断格式（给程序看的）

[root@localhost ~]# test -e /root/install.log

[root@localhost ~]# [ -e /root/lianxi/test_rule.txt ] #前面和后面一定要有空格
[root@localhost ~]# echo $? #$?查看上一条命令是否正确，返回值是0代表正确，非0代表错误
0
[root@localhost ~]# [ -d /root ]&& echo "yes"||echo "no" #命令执行顺序||
yes

2.按照文件权限进行判断

测试选项 | 作用
-r 文件 | 判断该文件是否存在，并且是否该文件拥有读权限（有读权限为真）
-w 文件 | 判断该文件是否存在，并且是否该文件拥有写权限（有写权限为真）
-x 文件 | 判断该文件是否存在，并且是否该文件拥有执行权限（有执行权限为真）
-u 文件 | 判断该文件是否存在，并且是否该文件拥有SUID权限（有SUID权限为真）
-g 文件 | 判断该文件是否存在，并且是否该文件拥有SGID权限（有SGID权限为真）
-k 文件 | 判断该文件是否存在，并且是否该文件拥有SBit权限（有SBit权限为真）

[root@localhost ~]# [ -w /root/lianxi/test_rule.txt ]&& echo "yes"||echo "no"
[root@localhost ~]# [ -w /root/lianxi/test_rule.txt ]&& echo yes||echo no
yes

3.两个文件之间进行比较

测试选项 | 作用
文件1 -nt 文件2 | 判断文件1的修改时间是否比文件2的新（如果新则为真）
文件1 -ot 文件2 | 判断文件1的修改时间是否比文件2的旧（如果旧则为真）
文件1 -ef 文件2 | 判断文件1是否和文件2的inode号一致，可以理解为两个文件是否为同一个文件，这个判断用于判断硬链接是很好的方法

4.两个整数之间比较（针对程序脚本的）

测试选项 | 作用
整数1 -eq 整数2 | 判断整数1是否和整数2相等（相等为真）
整数1 -ne 整数2 | 判断整数1是否和整数2不相等（不相等为真）
整数1 -gt 整数2 | 判断整数1是否大于整数2（大于为真）
整数1 -lt 整数2 | 判断整数1是否小于整数2（小于为真）
整数1 -ge 整数2 | 判断整数1是否大于等于整数2（大于等于为真）
整数1 -le 整数2 | 判断整数1是否小于等于整数2（小于等于为真）

[root@localhost ~]# [ 23 -gt 22 ]&& echo yes ||echo no #判断整数23大于整数22
yes
[root@localhost ~]# [ 23 -ge 22 ]&& echo yes ||echo no #判断23是否大于等于22
[root@localhost ~]# [ 23 -le 22 ]&& echo yes ||echo no #判断23是否小于等于22

5.字符串的判断（常用的）

测试选项 | 作用
-z 字符串 | 判断字符串是否为空（为空返回真）
-n 字符串 | 判断字符串是否为非空（非空返回真）
字串1==字串2 | 判断字符串1是否和字符串2相等（相等返回真）
字串1！=字串2 | 判断字符串1是否和字符串2不相等（不相等返回真）

[root@localhost ~]# name=sc #给name变量赋值
[root@localhost ~]# [ -z "$name" ]&& echo "yes"||echo "no" #判断name是否为空，因为不为空，所以返回no(写程序用的上)

[root@localhost ~]# aa=11
[root@localhost ~]# bb=22
[root@localhost ~]# [ "$aa" == "$bb" ]&& echo "yes" ||echo "no" #判断两个变量的值是否相等，明显不相等，所以返回no
no

6.多重条件判断

测试选项 | 作用
判断1 -a 判断2 | 逻辑与，判断1和判断2都成立，最终的结果为真
判断1 -o 判断2 | 逻辑或，判断1和判断2有一个成立，最终的结果就为真
！判断 | 逻辑非，使原始的判断式取反

[root@localhost ~]# aa=11
[root@localhost ~]# [ -n "$aa" -a "$aa" -gt 23 ]&& echo yes ||echo no
no
#判断变量aa是否有值，同时判断变量aa的是否大于23
#因为变量aa的值不大于23，所以虽然第一个判断值为真，返回的结果也是假


6.1.5 流程控制

Linux学习
Linux > 6 Shell编程 > 6.1 Shell编程 >
6.1.5 流程控制

流程控制

1.if语句

2.case语句

3.for循环

4.while循环和until循环


if语句

Linux学习
Linux > 6 Shell编程 > 6.1 Shell编程 > 6.1.5 流程控制 >
if语句

if语句

1.单分支if条件语句

if [条件判断式] ；then
程序
fi
或者
if [条件判断式]
then
程序
fi

单分支条件语句需要注意几个点

  • if语句使用fi结尾，和一般语言使用大括号结尾不同
  • [条件判断式]就是使用test命令判断，所以中括号和条件判断式之间必须有空格
  • then后面跟符合条件之后执行的程序，可以放在[ ]之后，用“;”分割。也可以换行写入，就不需要“;”了

范例1：判断分区使用率

#!/bin/bash #标称我下面写的都式shell语言
#统计根分区使用率
#Author:xiaozhi

rate=$(df -h | grep "/dev/sda3" | awk '{print $5}' | cut -d "%" -f1) #关键
#把根分区使用率作为变量值赋予变量rate

if [$rate -ge 80]
then
echo "Warning! /dev/sda3 is full!!"
fi

此程序的写法：

df -h | grep "/dev/sda3" | awk '{print $5}' | cut -d "%" -f1 #这写命令可以执行就可以作为变量使用

2.双分支if条件语句

if [条件判断式]
then
条件成立时，执行的程序
else
条件不成立时，执行的另一个程序
fi

范例2：备份mysql数据库

#! /bin/bash
#备份mysql数据库
#Author:

ntpdate asia.pool.ntp.org &>/dev/null
#同步系统时间
date=$(date +%y%m%d)
#把当前系统时间按照“年月日”格式赋予变量date
size=$(du -sh /var/lib/mysql)
#统计mysql数据库的大小，并把大小赋予size变量

if [ -d /tmp/dbbak]
then
echo "Date :$date!" > /tmp/dbbak/dbinfo.txt
echo "Date size :$size" >> /tmp/dbbak/dbinfo.txt
cd /tmp/dbbak
tar -zcf mysql-lib-$date.tar.gz /var/lib/mysql dbinfo.txt &>dev/null #/var/lib/mysql目录可以直接换一个做测试
rm -rf /tmp/dbbak/dbinfo.txt
else
mkdir /tmp/dbbak
echo "Date :$date!" > /tmp/dbbak/dbinfo.txt
echo "Date size :$size" >> /tmp/dbbak/dbinfo.txt
cd /tmp/dbbak
tar -zcf mysql-lib-$date.tar.gz /var/lib/mysql dbinfo.txt &>dev/null
rm -rf /tmp/dbbak/dbinfo.txt
fi

范例3:判断apache是否启动

#! /bin/bash
#判断apache是否启动
#Author:

port=$(nmap -sT 192.168.1.156 | grep tcp | grep http | awk '{print $2}')
#使用nmap命令扫描服务器，并截取apache服务的状态，赋予变量port
if ["$port"=="port"]
then
echo "$(date) httpd is ok!" >>/tmp /autostart-acc.log
else
/etc/rc.d/init.d/httpd start &>/dev/null
echo "$(date) restart httpd !!" >>/tmp/autostart-err.log
fi

3.多分支if条件语句

if [条件判断式1]
then
当条件判断式1成立时，执行程序1
elif [条件判断式2]
then
但条件判断式2成立时，执行程序2
...省略更多条件...
else
当所有条件都不成立时，最后执行此程序
fi

范例3：判断用户输入的是什么文件

#!/bin/bash
#判断用户输入的是什么文件
#Author:

read -p "Please input a filename: " file
#接收键盘的输入，并赋予变量file

if [ -z "$file"]
#判断file变量是否为空
then
echo "Error ,pleae input a filename"
exit 1
elif [ ! -e "$file"]
#判断file的值是否存在
then
echo "Your input is not a file!"
exit 2
elif [ -f "$file"]
#判断file的值是否为普通文件
then
echo "$file is a regulare file!"
elif [ -d "$file"]
#判断file的值是否为目录文件
then
echo "$file is a directory!"
else
echo "$file is an other file! "
fi


case语句

Linux学习
Linux > 6 Shell编程 > 6.1 Shell编程 > 6.1.5 流程控制 >
case语句

case语句

多分支case条件语句（判断）

  • case语句和if...elif...else语句一样都是多分支条件语句，不过和if多分支条件语句不同的是，case语句只能判断一种条件关系，而if语句可以判断多种条件关系。

case $变量名 in
"值1"）
如果变量的值等于值1，则执行程序1
；；
"值2")
如果变量的值等于值2，则执行程序2
；；
...省略其他分支...
*)
如果变量的值都不是以上的值，则执行此程序
；；
esac

范例：

范例1：判断用户输入

#!/bin/bash
#判断用户输入
#AuThor：
read -p "Please choose yes/no" -t 30 cho
case $cho in
"yes")
echo "YOUR choose is yes!"
;;
"no")
echo "YOUR choose is no!"
;;
*)
echo "Your choose is error!"
;;
esac

范例2：

#!/bin/bash
#输入123选择机票
#AuThor：

echo 'you want to shanghai,plseas input "1"'
echo 'you want to guangzhou,plseas input "2"'
echo 'you want to chengdu,plseas input "3"'

read -t 30 -p "Please input your chooise: "cho
case $cho in
"1")
echo "上海的机票"
;;
"2")
echo "广州的机票!"
;;
"3")
echo "成都的机票！"
;;
"*")
echo "错误，输入1、2、3"
esac


for循环

Linux学习
Linux > 6 Shell编程 > 6.1 Shell编程 > 6.1.5 流程控制 >
for循环

for循环

语法一
for 变量 in 值1 值2 值3...
do
程序
done

范例1：打印时间
#!/bin/bash
#打印时间
#AuThor：
for time in morning noon afternoon evening
do
echo "This time is $time!"
done

范例2：
#!/bin/bash
#循环1到6
#AuThor：
for i in 1 2 3 4 5 6 #可以用变量替代
do
echo $i
done

范例3：
#!/bin/bash
#批量解压缩脚本
#AuThor：
cd /lamp
ls *.tar.gz>ls.log
for i in $(cat ls.log)
do
tar -zxf $i &>/dev/null
done
rm -rf /lamp/ls.log

语法二 适用是否知道循环
for ((初始值;循环控制条件;变量变化))
do
程序
done

范例4：
#!/bin/bash
#从1加到100
#AuThor：

s=0
for ((i=1; i<=100; i=i+1))
do
s= $(($s+$i)) #只有用双小括号数值才能运算
done
echo "The sum of 1+2+3...+100 is :$s"

范例：批量添加用户

#!/bin/bash
#批量添加指定数量的用户
#AuThor：

read -p "Please input user name: " -t 30 name
read -p "Please input the number of users: " -t 30 num
read -p "Please input the password of users: " -t 30 pass
if[ ! -z "$name" -a ! -z "$num" -a ! -z "$pass"]
then
y=$(echo $num | sed's/^[0-9]*$'//g)
if[ -z "$y"]
then
for((i=1;i<=$num;i=i+1))
do
/usr/sbin/useradd $name$i &>/dev/null
echo $pass | /usr/bin/passwd --stdin $name$i &>/dev/null #| passwd --stdin "$name$i"另一种写法
done
fi
fi


while循环与until循环

Linux学习
Linux > 6 Shell编程 > 6.1 Shell编程 > 6.1.5 流程控制 >
while循环与until循环

while循环与until循环

1.while循环

while循环是不定循环，也称作条件循环。只要条件判断式成立，循环就会一直继续，直到条件判断式不成立，循环才会停止。这就是和for的固定循环不太一样了。

while [ 条件判断式 ]
do
程序
done

范例1：从1 加到 100
#!/bin/bash
#从1加到100
#AuThor：

i=1
s=0
while [$i -le 100]
#如果变量i的值小于等于100，则执行循环
do
s=$(($s+$i))
i=$(($i+1))
done
echo "The sum is : "$s"

2.until循环

until循环，和while循环相反，until循环时只要条件判断式不成立则进行循环，并执行循环程序。一旦循环条件成立，则终止循环。

until [ 条件判断式 ]
do
程序
done

范例1：从1 加到 100
#!/bin/bash
#从1加到100
#AuThor：

i=1
s=0
until [$i -gt 100]
#循环直到变量i的值大于100 就停止循环
do
s=$(($s+$i))
i=$(($i+1))
done
echo "The sum is : "$s"


6.2 编程案例分析

Linux学习
Linux > 6 Shell编程 >
6.2 编程案例分析
New Topic (Press Shift-Enter to insert a line break. Press Enter to add a paragraph return.)


6.2.1 Shell脚本中的变量

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 >
6.2.1 Shell脚本中的变量

Shell脚本中的变量

Shell脚本中的变量可以是一个数值、一个命令或者一个路径。定义变量的格式为：
变量名=变量的值
在脚本中应用变量时需要加上符号$。
下面编写一个与变量有关的脚本：


数字运算

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 > 6.2.1 Shell脚本中的变量 >
数字运算

数字运算

在脚本中进行数字运算，也会用到变量。
下面再定义一个脚本：


和用户交互

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 > 6.2.1 Shell脚本中的变量 >
和用户交互

用户交互

自定义一个脚本

Read命令用于和用户交互，它把用户输入的字符串作为变量值

加上 –x选项查看执行过程：


Shell脚本预设变量

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 > 6.2.1 Shell脚本中的变量 >
Shell脚本预设变量

Shell脚本预设变量

实际上，shell脚本在执行时，后面可以跟一个或者多个参数。
下面自定义一个脚本

option.sh 5 15 #5和15就是预设变量$1和$2
$1表示脚本的第一个参数，$2表示脚本的第二个参数，以此类推。
一个脚本的预设变量数量是没有限制的，另外还有$0，它表示脚本本身的名字。


6.2.2 Shell脚本中的逻辑判断

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 >
6.2.2 Shell脚本中的逻辑判断

Shell脚本中的逻辑判断

1. 不带else

2. 带有else

3. 带有elif

4. 和文档相关的判断

5. case逻辑判断


不带else

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 > 6.2.2 Shell脚本中的逻辑判断 >
不带else

1. 不带else

具体格式：

下面自定义一个脚本：

输入90，没有设置else条件，所以没有结果


带有else

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 > 6.2.2 Shell脚本中的逻辑判断 >
带有else

2. 带有else
具体格式如下：

下面我们修改if1脚本：

执行上面脚本：


带有elif

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 > 6.2.2 Shell脚本中的逻辑判断 >
带有elif

3. 带有elif
具体格式：

下面自定义一个脚本：

执行上面脚本：

判断数值大小除了可以使用(( ))的形式外，还可以使用[]，但不能使用>、<、=这样的符号了，要使用-lt(小于)、-gt(大于)、-le(小于或等于)、-ge(大于或等于)、-eq(等于)、-ne(不等于)。< /FONT>

< /P>

< /FONT>


和文档相关的判断

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 > 6.2.2 Shell脚本中的逻辑判断 >
和文档相关的判断

4. 和文档相关的判断
Shell脚本中if还经常用于判断文档的属性，比如判断是普通文件还是目录，判断文件是否可读、写、执行权限等。

If 常用的选项有以下几个：

-e ：判断文件或目录是否存在
-d ：判断是不是目录以及是否存在
-f ：判断是不是普通文件以及是否存在
-r ：判断是否有读权限
-w ：判断是否有写权限
-x ：判断是否有执行权限

具体格式：

示例如下：

/home/是目录而非文件，所以在判断它是否为文件时并不会显示ok。


case逻辑判断

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 > 6.2.2 Shell脚本中的逻辑判断 >
case逻辑判断

5. case逻辑判断
在shell脚本中，除了使用if来判断逻辑外，还可以使用case.
具体格式：
下面的结构中，不限制value的个数，*代表其它任意值。

下面自定义一个脚本：

脚本中的$a的值为1或0，执行结果如下：

case脚本常用于编写系统服务的启动脚本。


6.2.3 Shell脚本中的循环

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 >
6.2.3 Shell脚本中的循环

shell脚本算是一门简易的编程语言了，脚本中的循环也是不能缺少的。常用的循环有for循环和while循环。

1. for 循环
for循环结构是在日常运维工作中使用很频繁的循环结构。
具体格式：

下面自定义一个脚本

上面，循环的条件是引用系统命令的执行结果seq 1 5，但必须用反引号括起来。
查看执行结果:

对于反括号的用法:

另外循环的条件还可以是一组字符或者数字（用一个或多个空格隔开），也可以是一条命令的执行结果。
示例如下：

2. while循环
日常运维工作中，也会经常用while循环来编写死循环的脚本，用于监控某项服务。
具体格式:

下面自定义一个脚本:

(注意空格)
查看执行结果:

另外，可以用一个冒号:代替循环条件，这样就可以做到死循环。


6.2.4 Shell脚本中的函数

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 >
6.2.4 Shell脚本中的函数

Shell脚本中的函数

Shell脚本中的函数就是先把一段代码整理到一个小单元中，并给这个小单元命名，当用到这段代码时，直接调用这个小单元的名字即可。
下面自定义一个脚本

查看执行结果:

上面func.sh中的sum()为自定义的函数。
在shell脚本中函数的格式如下：

需要注意的是，在shell脚本中，被调用的函数一定要写在最前面，不能出现在中间或最后。因为函数是要被调用的，如果还没有出现就被调用，那当然会出错。


6.2.5 Shell脚本中的中断和继续

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 >
6.2.5 Shell脚本中的中断和继续

Shell脚本中的中断和继续

在shell脚本循环的过程中，我们难免会遇到一些特殊需求，比如当循环到某个地方时需要做一些事情，这时候很有可能需要退出循环，或者跳过本次循环。
1. break
break用在循环中，不管是for或者while都可以。在脚本中使用它，表示退出本层循环。之所以说层，是因为有时我们会用到嵌套循环，大循环里面还有小循环，而break仅仅是退出那一层循环，它的上层循环不受影响。
下面自定义一个脚本

执行结果：

上面脚本中，当i=3时，会跳出循环，后面的4和5不再执行，但上层的循环仍在继续。
2. continue
continue也是使用在循环中的，但和break不同，当在shell脚本中遇到continue时，结束的不是整个循环，而是本次循环（不退出本层循环，只是结束这一次循环）。
自定义一个脚本：

查看执行结果：

当i=3时，因为有continue，结束本次循环，continue后面的语句不再执行，但是后面的循环不受影响。
3. exit
还有一个和break、continue类似的用法，就是exit，它作用的范围更大，直接退出整个shell脚本。
直接修改continue.sh

执行结果：

这个结果和continue相比，明显exit在i=3时，就直接退出了整个脚本。


6.2.6 Shell脚本文件分析

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 >
6.2.6 Shell脚本文件分析

Shell脚本文件分析

1.乘法口诀表

#!/bin/bash
for i in `seq 1 9`
do
for j in `seq 1 $i`
do
k=$[$i*$j]
##-n选项，不换行，-e使用制表符
echo -ne "$j""X""$i=$k\t"
done
echo
done

2.获取随机数

#!/bin/bash
##RANDOM随机函数，100取余就可以获得1-100的随机整数
n=$[$RANDOM%100]
while :
do
read -p "请输入一个1-100间的整数：" n1
n2=`echo $n1|sed 's/[0-9]//g'`
if [ ! -z $n2 ]
then
echo "你输入的不是1-100的整数！"
continue
fi
if [ $n1 -gt 100 ] || [ $n1 == 0 ]
then
echo "请输入1-100的整数！"
continue
fi
if [ $n1 == $n ]
then
echo "你猜对了！"
break
elif [ $n1 -gt $n ]
then
echo "你输入的数字太大了！"
continue
else
echo "你输入的数字太小了！"
continue
fi
done

3.计算1-100的和

#!/bin/bash
for i in `seq 1 100`
do
j=$[$j+$i]
done
echo $j

4.批量建立用户

#!/bin/bash
#批量建立用户user_00,user_01,...user_100并且所有用户同属于users组；
for i in `seq 0 1 100`
do
if [ $i -lt 10 ]
then
useradd -g 100 user_0$i
elif [ $i == 100 ]
then
useradd -g 100 user_100
else
useradd -g 100 user_$i
fi
done

5.输入整数

#!/bin/bash
#编写shell脚本，要求输入一个正整数，然后计算出从1到输入数字的和，要求如果输入的数字小于1，则重新输入，直到输入正确的数字为止；
while :
do
read -p "请输入一个正整数： " n
if echo $n |grep -q '[^0-9]'
then
echo "你没有输入一个正整数！"
continue
fi
if [ $n -lt 1 ]
then
echo "你没有输入大于1的数！"
continue
fi
for i in `seq 1 $n`
do
j=$[$j+$i]
done
echo $j
exit
done

6.移动目录

#!/bin/bash
#编写shell脚本，把/root/目录下的所有目录（只需要一级）拷贝到/tmp/目录下；
cd /root/
for file in `ls`
do
if [ -d $file ]
then
mkdir /tmp/$file
else
continue
fi
done


6.2.7 Shell脚本文件上传下载

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 >
6.2.7 Shell脚本文件上传下载

shell脚本实现ftp上传下载文件功能


6.2.8 批量上传FTP服务器

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 >
6.2.8 批量上传FTP服务器

Linux实现批量上传FTP服务器的shell脚本

#!/bin/bash
#Linux实现批量上传FTP服务器的shell脚本
HOST=XXX.XXX.X.XXX # ftp 服务器IP
FTP_USERNAME=myftp # 登录ftp服务器用户名
FTP_PASSWD=XXXXXX # 登录ftp服务器密码
Backup_Period=`expr 1 \* 1` # 延时 24h （1天）
H=h
Delay=$Backup_Period$H
SourceDir=/home/backup/audio #待备份的文件目录
LogDir=/home/backup/ #备份脚本日志记录

#创建日志
function LogFile {
sudo touch $LogDir/log/`date +"%Y-%m-%d"`.log
Logfile=$LogDir/log/`date +"%Y-%m-%d"`.log
sudo chmod 666 $Logfile

}

#筛选待备份的文件
#根据文件时间戳与当前日期差值
#默认备份间隔为1天
function Backup_Func(){
cd $SourceDir
for file in `ls`
do
UNIX_TIME_FILE=`date +%s -r $file`
TODAY_TIME=`date +%s`

Interval_Time=$(expr $TODAY_TIME - $UNIX_TIME_FILE)
Hour_distance=$(expr ${Interval_Time} / 3600)
if [ "$Hour_distance" -lt "$1" ]
then
Bak_File="$Bak_File $file"

fi
done

}

###### main funciton ######

## 创建备份脚本记录日志
LogFile

## 循环备份，间隔为 1 天
while true
do
echo "-----------------------------------" >>$Logfile
LOG_TIME=`date +"%Y-%m-%d %H:%M:%S"`
Bak_File=""

Backup_Func $Backup_Period ##执行筛选待备份文件函数
echo "'$LOG_TIME' $Bak_File will be backup !" >>$Logfile

## 开启登录FTP 服务
echo "'$LOG_TIME' Start FTP servers !" >>$Logfile
ftp -ivn $HOST << EOF
user $FTP_USERNAME $FTP_PASSWD
lcd $SourceDir
cd /home/ftp/opendir
mput $Bak_File
bye
EOF
echo "'$LOG_TIME' End FTP servers !" >>$Logfile
echo "'$LOG_TIME' Backup $Bak_File succeed !" >>$Logfile
echo "-----------------------------------" >>$Logfile
## 退出 FTP服务器，文件上传成功

sleep $Delay
done
exit 0


6.2.9 俄罗斯方块

Linux学习
Linux > 6 Shell编程 > 6.2 编程案例分析 >
6.2.9 俄罗斯方块
#!/bin/bash

# Tetris Game
# 10.21.2003 xhchen<[email]xhchen@winbond.com.tw[/email]>

#APP declaration
APP_NAME="${0##*[\\/]}"
APP_VERSION="1.0"

#颜色定义
cRed=1
cGreen=2
cYellow=3
cBlue=4
cFuchsia=5
cCyan=6
cWhite=7
colorTable=($cRed $cGreen $cYellow $cBlue $cFuchsia $cCyan $cWhite)

#位置和大小
iLeft=3
iTop=2
((iTrayLeft = iLeft + 2))
((iTrayTop = iTop + 1))
((iTrayWidth = 10))
((iTrayHeight = 15))

#颜色设置
cBorder=$cGreen
cScore=$cFuchsia
cScoreValue=$cCyan

#控制信号
#改游戏使用两个进程，一个用于接收输入，一个用于游戏流程和显示界面;
#当前者接收到上下左右等按键时，通过向后者发送signal的方式通知后者。
sigRotate=25
sigLeft=26
sigRight=27
sigDown=28
sigAllDown=29
sigExit=30

#七中不同的方块的定义
#通过旋转，每种方块的显示的样式可能有几种
box0=(0 0 0 1 1 0 1 1)
box1=(0 2 1 2 2 2 3 2 1 0 1 1 1 2 1 3)
box2=(0 0 0 1 1 1 1 2 0 1 1 0 1 1 2 0)
box3=(0 1 0 2 1 0 1 1 0 0 1 0 1 1 2 1)
box4=(0 1 0 2 1 1 2 1 1 0 1 1 1 2 2 2 0 1 1 1 2 0 2 1 0 0 1 0 1 1 1 2)
box5=(0 1 1 1 2 1 2 2 1 0 1 1 1 2 2 0 0 0 0 1 1 1 2 1 0 2 1 0 1 1 1 2)
box6=(0 1 1 1 1 2 2 1 1 0 1 1 1 2 2 1 0 1 1 0 1 1 2 1 0 1 1 0 1 1 1 2)
#所有其中方块的定义都放到box变量中
box=(${box0[@]} ${box1[@]} ${box2[@]} ${box3[@]} ${box4[@]} ${box5[@]} ${box6[@]})
#各种方块旋转后可能的样式数目
countBox=(1 2 2 2 4 4 4)
#各种方块再box数组中的偏移
offsetBox=(0 1 3 5 7 11 15)

#每提高一个速度级需要积累的分数
iScoreEachLevel=50 #be greater than 7

#运行时数据
sig=0 #接收到的signal
iScore=0 #总分
iLevel=0 #速度级
boxNew=() #新下落的方块的位置定义
cBoxNew=0 #新下落的方块的颜色
iBoxNewType=0 #新下落的方块的种类
iBoxNewRotate=0 #新下落的方块的旋转角度
boxCur=() #当前方块的位置定义
cBoxCur=0 #当前方块的颜色
iBoxCurType=0 #当前方块的种类
iBoxCurRotate=0 #当前方块的旋转角度
boxCurX=-1 #当前方块的x坐标位置
boxCurY=-1 #当前方块的y坐标位置
iMap=() #背景方块图表

#初始化所有背景方块为-1, 表示没有方块
for ((i = 0; i < iTrayHeight * iTrayWidth; i++)); do iMap[$i]=-1; done

#接收输入的进程的主函数
function RunAsKeyReceiver()
{
local pidDisplayer key aKey sig cESC sTTY

pidDisplayer=$1
aKey=(0 0 0)

cESC=`echo -ne "\033"`
cSpace=`echo -ne "\040"`

#保存终端属性。在read -s读取终端键时，终端的属性会被暂时改变。
#如果在read -s时程序被不幸杀掉，可能会导致终端混乱，
#需要在程序退出时恢复终端属性。
sTTY=`stty -g`

#捕捉退出信号
trap "MyExit;" INT TERM
trap "MyExitNoSub;" $sigExit

#隐藏光标
echo -ne "\033[?25l"

while :
do
#读取输入。注-s不回显，-n读到一个字符立即返回
read -s -n 1 key

aKey[0]=${aKey[1]}
aKey[1]=${aKey[2]}
aKey[2]=$key
sig=0

#判断输入了何种键
if [[ $key == $cESC && ${aKey[1]} == $cESC ]]
then
#ESC键
MyExit
elif [[ ${aKey[0]} == $cESC && ${aKey[1]} == "[" ]]
then
if [[ $key == "A" ]]; then sig=$sigRotate #<向上键>
elif [[ $key == "B" ]]; then sig=$sigDown #<向下键>
elif [[ $key == "D" ]]; then sig=$sigLeft #<向左键>
elif [[ $key == "C" ]]; then sig=$sigRight #<向右键>
fi
elif [[ $key == "W" || $key == "w" ]]; then sig=$sigRotate #W, w
elif [[ $key == "S" || $key == "s" ]]; then sig=$sigDown #S, s
elif [[ $key == "A" || $key == "a" ]]; then sig=$sigLeft #A, a
elif [[ $key == "D" || $key == "d" ]]; then sig=$sigRight #D, d
elif [[ "[$key]" == "[]" ]]; then sig=$sigAllDown #空格键
elif [[ $key == "Q" || $key == "q" ]] #Q, q
then
MyExit
fi

if [[ $sig != 0 ]]
then
#向另一进程发送消息
kill -$sig $pidDisplayer
fi
done
}

#退出前的恢复
function MyExitNoSub()
{
local y

#恢复终端属性
stty $sTTY
((y = iTop + iTrayHeight + 4))

#显示光标
echo -e "\033[?25h\033[${y};0H"
exit
}

function MyExit()
{
#通知显示进程需要退出
kill -$sigExit $pidDisplayer

MyExitNoSub
}

#处理显示和游戏流程的主函数
function RunAsDisplayer()
{
local sigThis
InitDraw

#挂载各种信号的处理函数
trap "sig=$sigRotate;" $sigRotate
trap "sig=$sigLeft;" $sigLeft
trap "sig=$sigRight;" $sigRight
trap "sig=$sigDown;" $sigDown
trap "sig=$sigAllDown;" $sigAllDown
trap "ShowExit;" $sigExit

while :
do
#根据当前的速度级iLevel不同，设定相应的循环的次数
for ((i = 0; i < 21 - iLevel; i++))
do
sleep 0.02
sigThis=$sig
sig=0

#根据sig变量判断是否接受到相应的信号
if ((sigThis == sigRotate)); then BoxRotate; #旋转
elif ((sigThis == sigLeft)); then BoxLeft; #左移一列
elif ((sigThis == sigRight)); then BoxRight; #右移一列
elif ((sigThis == sigDown)); then BoxDown; #下落一行
elif ((sigThis == sigAllDown)); then BoxAllDown; #下落到底
fi
done
#kill -$sigDown $$
BoxDown #下落一行
done
}

#BoxMove(y, x), 测试是否可以把移动中的方块移到(x, y)的位置, 返回0则可以, 1不可以
function BoxMove()
{
local j i x y xTest yTest
yTest=$1
xTest=$2
for ((j = 0; j < 8; j += 2))
do
((i = j + 1))
((y = ${boxCur[$j]} + yTest))
((x = ${boxCur[$i]} + xTest))
if (( y < 0 || y >= iTrayHeight || x < 0 || x >= iTrayWidth))
then
#撞到墙壁了
return 1
fi
if ((${iMap[y * iTrayWidth + x]} != -1 ))
then
#撞到其他已经存在的方块了
return 1
fi
done
return 0;
}

#将当前移动中的方块放到背景方块中去,
#并计算新的分数和速度级。(即一次方块落到底部)
function Box2Map()
{
local j i x y xp yp line

#将当前移动中的方块放到背景方块中去
for ((j = 0; j < 8; j += 2))
do
((i = j + 1))
((y = ${boxCur[$j]} + boxCurY))
((x = ${boxCur[$i]} + boxCurX))
((i = y * iTrayWidth + x))
iMap[$i]=$cBoxCur
done

#消去可被消去的行
line=0
for ((j = 0; j < iTrayWidth * iTrayHeight; j += iTrayWidth))
do
for ((i = j + iTrayWidth - 1; i >= j; i--))
do
if ((${iMap[$i]} == -1)); then break; fi
done
if ((i >= j)); then continue; fi

((line++))
for ((i = j - 1; i >= 0; i--))
do
((x = i + iTrayWidth))
iMap[$x]=${iMap[$i]}
done
for ((i = 0; i < iTrayWidth; i++))
do
iMap[$i]=-1
done
done

if ((line == 0)); then return; fi

#根据消去的行数line计算分数和速度级
((x = iLeft + iTrayWidth * 2 + 7))
((y = iTop + 11))
((iScore += line * 2 - 1))
#显示新的分数
echo -ne "\033[1m\033[3${cScoreValue}m\033[${y};${x}H${iScore} "
if ((iScore % iScoreEachLevel < line * 2 - 1))
then
if ((iLevel < 20))
then
((iLevel++))
((y = iTop + 14))
#显示新的速度级
echo -ne "\033[3${cScoreValue}m\033[${y};${x}H${iLevel} "
fi
fi
echo -ne "\033[0m"

#重新显示背景方块
for ((y = 0; y < iTrayHeight; y++))
do
((yp = y + iTrayTop + 1))
((xp = iTrayLeft + 1))
((i = y * iTrayWidth))
echo -ne "\033[${yp};${xp}H"
for ((x = 0; x < iTrayWidth; x++))
do
((j = i + x))
if ((${iMap[$j]} == -1))
then
echo -ne " "
else
echo -ne "\033[1m\033[7m\033[3${iMap[$j]}m\033[4${iMap[$j]}m[]\033[0m"
fi
done
done
}

#下落一行
function BoxDown()
{
local y s
((y = boxCurY + 1)) #新的y坐标
if BoxMove $y $boxCurX #测试是否可以下落一行
then
s="`DrawCurBox 0`" #将旧的方块抹去
((boxCurY = y))
s="$s`DrawCurBox 1`" #显示新的下落后方块
echo -ne $s
else
#走到这儿, 如果不能下落了
Box2Map #将当前移动中的方块贴到背景方块中
RandomBox #产生新的方块
fi
}

#左移一列
function BoxLeft()
{
local x s
((x = boxCurX - 1))
if BoxMove $boxCurY $x
then
s=`DrawCurBox 0`
((boxCurX = x))
s=$s`DrawCurBox 1`
echo -ne $s
fi
}

#右移一列
function BoxRight()
{
local x s
((x = boxCurX + 1))
if BoxMove $boxCurY $x
then
s=`DrawCurBox 0`
((boxCurX = x))
s=$s`DrawCurBox 1`
echo -ne $s
fi
}

#下落到底
function BoxAllDown()
{
local k j i x y iDown s
iDown=$iTrayHeight

#计算一共需要下落多少行
for ((j = 0; j < 8; j += 2))
do
((i = j + 1))
((y = ${boxCur[$j]} + boxCurY))
((x = ${boxCur[$i]} + boxCurX))
for ((k = y + 1; k < iTrayHeight; k++))
do
((i = k * iTrayWidth + x))
if (( ${iMap[$i]} != -1)); then break; fi
done
((k -= y + 1))
if (( $iDown > $k )); then iDown=$k; fi
done

s=`DrawCurBox 0` #将旧的方块抹去
((boxCurY += iDown))
s=$s`DrawCurBox 1` #显示新的下落后的方块
echo -ne $s
Box2Map #将当前移动中的方块贴到背景方块中
RandomBox #产生新的方块
}

#旋转方块
function BoxRotate()
{
local iCount iTestRotate boxTest j i s
iCount=${countBox[$iBoxCurType]} #当前的方块经旋转可以产生的样式的数目

#计算旋转后的新的样式
((iTestRotate = iBoxCurRotate + 1))
if ((iTestRotate >= iCount))
then
((iTestRotate = 0))
fi

#更新到新的样式, 保存老的样式(但不显示)
for ((j = 0, i = (${offsetBox[$iBoxCurType]} + $iTestRotate) * 8; j < 8; j++, i++))
do
boxTest[$j]=${boxCur[$j]}
boxCur[$j]=${box[$i]}
done

if BoxMove $boxCurY $boxCurX #测试旋转后是否有空间放的下
then
#抹去旧的方块
for ((j = 0; j < 8; j++))
do
boxCur[$j]=${boxTest[$j]}
done
s=`DrawCurBox 0`

#画上新的方块
for ((j = 0, i = (${offsetBox[$iBoxCurType]} + $iTestRotate) * 8; j < 8; j++, i++))
do
boxCur[$j]=${box[$i]}
done
s=$s`DrawCurBox 1`
echo -ne $s
iBoxCurRotate=$iTestRotate
else
#不能旋转，还是继续使用老的样式
for ((j = 0; j < 8; j++))
do
boxCur[$j]=${boxTest[$j]}
done
fi
}

#DrawCurBox(bDraw), 绘制当前移动中的方块, bDraw为1, 画上, bDraw为0, 抹去方块。
function DrawCurBox()
{
local i j t bDraw sBox s
bDraw=$1

s=""
if (( bDraw == 0 ))
then
sBox="\040\040"
else
sBox="[]"
s=$s"\033[1m\033[7m\033[3${cBoxCur}m\033[4${cBoxCur}m"
fi

for ((j = 0; j < 8; j += 2))
do
((i = iTrayTop + 1 + ${boxCur[$j]} + boxCurY))
((t = iTrayLeft + 1 + 2 * (boxCurX + ${boxCur[$j + 1]})))
#\033[y;xH, 光标到(x, y)处
s=$s"\033[${i};${t}H${sBox}"
done
s=$s"\033[0m"
echo -n $s
}

#更新新的方块
function RandomBox()
{
local i j t

#更新当前移动的方块
iBoxCurType=${iBoxNewType}
iBoxCurRotate=${iBoxNewRotate}
cBoxCur=${cBoxNew}
for ((j = 0; j < ${#boxNew[@]}; j++))
do
boxCur[$j]=${boxNew[$j]}
done

#显示当前移动的方块
if (( ${#boxCur[@]} == 8 ))
then
#计算当前方块该从顶端哪一行"冒"出来
for ((j = 0, t = 4; j < 8; j += 2))
do
if ((${boxCur[$j]} < t)); then t=${boxCur[$j]}; fi
done
((boxCurY = -t))
for ((j = 1, i = -4, t = 20; j < 8; j += 2))
do
if ((${boxCur[$j]} > i)); then i=${boxCur[$j]}; fi
if ((${boxCur[$j]} < t)); then t=${boxCur[$j]}; fi
done
((boxCurX = (iTrayWidth - 1 - i - t) / 2))

#显示当前移动的方块
echo -ne `DrawCurBox 1`

#如果方块一出来就没处放，Game over!
if ! BoxMove $boxCurY $boxCurX
then
kill -$sigExit ${PPID}
ShowExit
fi
fi

#清除右边预显示的方块
for ((j = 0; j < 4; j++))
do
((i = iTop + 1 + j))
((t = iLeft + 2 * iTrayWidth + 7))
echo -ne "\033[${i};${t}H "
done

#随机产生新的方块
((iBoxNewType = RANDOM % ${#offsetBox[@]}))
((iBoxNewRotate = RANDOM % ${countBox[$iBoxNewType]}))
for ((j = 0, i = (${offsetBox[$iBoxNewType]} + $iBoxNewRotate) * 8; j < 8; j++, i++))
do
boxNew[$j]=${box[$i]};
done

((cBoxNew = ${colorTable[RANDOM % ${#colorTable[@]}]}))

#显示右边预显示的方块
echo -ne "\033[1m\033[7m\033[3${cBoxNew}m\033[4${cBoxNew}m"
for ((j = 0; j < 8; j += 2))
do
((i = iTop + 1 + ${boxNew[$j]}))
((t = iLeft + 2 * iTrayWidth + 7 + 2 * ${boxNew[$j + 1]}))
echo -ne "\033[${i};${t}H[]"
done
echo -ne "\033[0m"
}

#初始绘制
function InitDraw()
{
clear
RandomBox #随机产生方块，这时右边预显示窗口中有方快了
RandomBox #再随机产生方块，右边预显示窗口中的方块被更新，原先的方块将开始下落
local i t1 t2 t3

#显示边框
echo -ne "\033[1m"
echo -ne "\033[3${cBorder}m\033[4${cBorder}m"

((t2 = iLeft + 1))
((t3 = iLeft + iTrayWidth * 2 + 3))
for ((i = 0; i < iTrayHeight; i++))
do
((t1 = i + iTop + 2))
echo -ne "\033[${t1};${t2}H||"
echo -ne "\033[${t1};${t3}H||"
done

((t2 = iTop + iTrayHeight + 2))
for ((i = 0; i < iTrayWidth + 2; i++))
do
((t1 = i * 2 + iLeft + 1))
echo -ne "\033[${iTrayTop};${t1}H=="
echo -ne "\033[${t2};${t1}H=="
done
echo -ne "\033[0m"

#显示"Score"和"Level"字样
echo -ne "\033[1m"
((t1 = iLeft + iTrayWidth * 2 + 7))
((t2 = iTop + 10))
echo -ne "\033[3${cScore}m\033[${t2};${t1}HScore"
((t2 = iTop + 11))
echo -ne "\033[3${cScoreValue}m\033[${t2};${t1}H${iScore}"
((t2 = iTop + 13))
echo -ne "\033[3${cScore}m\033[${t2};${t1}HLevel"
((t2 = iTop + 14))
echo -ne "\033[3${cScoreValue}m\033[${t2};${t1}H${iLevel}"
echo -ne "\033[0m"
}

#退出时显示GameOVer!
function ShowExit()
{
local y
((y = iTrayHeight + iTrayTop + 3))
echo -e "\033[${y};0HGameOver!\033[0m"
exit
}

#显示用法.
function Usage
{
cat << EOF
Usage: $APP_NAME
Start tetris game.

-h, --help display this help and exit
--version output version information and exit
EOF
}

#游戏主程序在这儿开始.
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
Usage
elif [[ "$1" == "--version" ]]; then
echo "$APP_NAME $APP_VERSION"
elif [[ "$1" == "--show" ]]; then
#当发现具有参数--show时，运行显示函数
RunAsDisplayer
else
bash $0 --show& #以参数--show将本程序再运行一遍
RunAsKeyReceiver $! #以上一行产生的进程的进程号作为参数
fi


7 用户和用户组管理

Linux学习
Linux >
7 用户和用户组管理

Linux用户和用户组管理

Linux系统是一个多用户多任务的分时操作系统，任何一个要使用系统资源的用户，都必须首先向系统管理员申请一个账号，然后以这个账号的身份进入系统。
用户的账号一方面可以帮助系统管理员对使用系统的用户进行跟踪，并控制他们对系统资源的访问；另一方面也可以帮助用户组织文件，并为用户提供安全性保护。
每个用户账号都拥有一个唯一的用户名和各自的口令。
用户在登录时键入正确的用户名和口令后，就能够进入系统和自己的主目录。
实现用户账号的管理，要完成的工作主要有如下几个方面：
? 1.用户账号的添加、删除与修改。
? 2.用户口令的管理。
? 3.用户组的管理。


7.1 Linux系统用户管理

Linux学习
Linux > 7 用户和用户组管理 >
7.1 Linux系统用户管理

Linux系统用户管理

1.添加新用户 useradd

useradd [选项] [用户名]
选项:
-c comment 指定一段注释性描述。
-d 目录 指定用户主目录，如果此目录不存在，则同时使用-m选项，可以创建主目录。
-g 用户组 指定用户所属的用户组。
-G 用户组，用户组 指定用户所属的附加组。
-s Shell文件 指定用户的登录Shell。
-u 用户号 指定用户的用户号，如果同时有-o选项，则可以重复使用其他用户的标识号。

用户名:指定新账号的登录名。

实例1
[root@localhost ~]# useradd –d /home/sam -m sam
此命令创建了一个用户sam，其中-d和-m选项用来为登录名sam产生一个主目录 /home/sam（/home为默认的用户主目录所在的父目录）。

实例2
[root@localhost ~]# useradd -s /bin/sh -g group –G adm,root gem
此命令新建了一个用户gem，该用户的登录Shell是 /bin/sh，它属于group用户组，同时又属于adm和root用户组，其中group用户组是其主组。
这里可能新建组：[root@localhost ~]#groupadd group及groupadd adm 增加用户账号就是在/etc/passwd文件中为新用户增加一条记录，同时更新其他系统文件如/etc/shadow, /etc/group等。

Linux提供了集成的系统管理工具userconf，它可以用来对用户账号进行统一管理。

2.删除帐号
如果一个用户的账号不再使用，可以从系统中删除。删除用户账号就是要将/etc/passwd等系统文件中的该用户记录删除，必要时还删除用户的主目录。
删除一个已有的用户账号使用userdel命令，其格式如下：
userdel [选项] [用户名]
常用的选项是 -r，它的作用是把用户的主目录一起删除。
例如：
[root@localhost ~]# userdel -r sam
此命令删除用户sam在系统文件中（主要是/etc/passwd, /etc/shadow, /etc/group等）的记录，同时删除用户的主目录。

3. 修改帐号
修改用户账号就是根据实际情况更改用户的有关属性，如用户号、主目录、用户组、登录Shell等。
修改已有用户的信息使用usermod命令，其格式如下：
usermod [选项] [用户名]
常用的选项包括-c, -d, -m, -g, -G, -s, -u以及-o等，这些选项的意义与useradd命令中的选项一样，可以为用户指定新的资源值。另外，有些系统可以使用选项：-l 新用户名
这个选项指定一个新的账号，即将原来的用户名改为新的用户名。
例如：
[root@localhost ~]# usermod -s /bin/ksh -d /home/z –g developer sam
此命令将用户sam的登录Shell修改为ksh，主目录改为/home/z，用户组改为developer。

4. 用户口令的管理
用户管理的一项重要内容是用户口令的管理。用户账号刚创建时没有口令，但是被系统锁定，无法使用，必须为其指定口令后才可以使用，即使是指定空口令。
指定和修改用户口令的Shell命令是passwd。超级用户可以为自己和其他用户指定口令，普通用户只能用它修改自己的口令。

命令的格式为：
passwd [选项] [用户名]
选项：
-l 锁定口令，即禁用账号。
-u 口令解锁。
-d 使账号无口令。
-f 强迫用户下次登录时修改口令。
如果默认用户名，则修改当前用户的口令。
例如
假设当前用户是sam，则下面的命令修改该用户自己的口令：
[root@localhost ~]$ passwd
Old password:******
New password:*******
Re-enter new password:*******
如果是超级用户，可以用下列形式指定任何用户的口令：
[root@localhost ~]# passwd sam
New password:*******
Re-enter new password:*******
普通用户修改自己的口令时，passwd命令会先询问原口令，验证后再要求用户输入两遍新口令，如果两次输入的口令一致，则将这个口令指定给用户；而超级用户为用户指定口令时，就不需要知道原口令。

为了系统安全起见，用户应该选择比较复杂的口令，例如最好使用8位长的口令，口令中包含有大写、小写字母和数字，并且应该与姓名、生日等不相同。

为用户指定空口令时，执行下列形式的命令：
[root@localhost ~]# passwd -d sam
此命令将用户 sam 的口令删除，这样用户 sam 下一次登录时，系统就不再允许该用户登录了 。
passwd 命令还可以用 -l(lock) 选项锁定某一用户 ，使其不能登录，例如：
[root@localhost ~]# passwd -l sam


7.2 Linux系统用户组的管理

Linux学习
Linux > 7 用户和用户组管理 >
7.2 Linux系统用户组的管理

Linux系统用户组的管理

每个用户都有一个用户组，系统可以对一个用户组中的所有用户进行集中管理。不同Linux 系统对用户组的规定有所不同，如Linux下的用户属于与它同名的用户组，这个用户组在创建用户时同时创建。
用户组的管理涉及用户组的添加、删除和修改。组的增加、删除和修改实际上就是对/etc/group文件的更新。
1. 增加一个新的用户组使用groupadd命令。
其格式如下：
groupadd [选项] [用户组]
选项：
-g GID 指定新用户组的组标识号（GID）。
-o 一般与-g选项同时使用，表示新用户组的GID可以与系统已有用户组的GID相同。

范例1：
[root@localhost ~]# groupadd group1
此命令向系统中增加了一个新组group1，新组的组标识号是在当前已有的最大组标识号的基础上加1。
范例2：
[root@localhost ~]# groupadd -g 101 group2
此命令向系统中增加了一个新组group2，同时指定新组的组标识号是101。

2. 删除一个已有的用户组，使用groupdel命令
其格式如下：
groupdel [用户组]
范例：
[root@localhost ~]# groupdel group1
此命令从系统中删除组group1。

3. 修改用户组的属性使用groupmod命令。
其语法如下：
groupmod [选项] [用户组]
选项：
-g GID 为用户组指定新的组标识号。
-o 与-g选项同时使用，用户组的新GID可以与系统已有用户组的GID相同。
-n新用户组 将用户组的名字改为新名字
范例1：
[root@localhost ~]# groupmod -g 102 group2
此命令将组group2的组标识号修改为102。
范例2：
[root@localhost ~]# groupmod –g 10000 -n group3 group2
此命令将组group2的标识号改为10000，组名修改为group3。

4. 切换用户组
一个用户同时属于多个用户组，那么用户可以在用户组之间切换，以便具有其他用户组的权限。用户可以在登录后，使用命令newgrp切换到其他用户组，这个命令的参数就是目的用户组。例如：
[root@localhost ~]$ newgrp root
这条命令将当前用户切换到root用户组，前提条件是root用户组确实是该用户的主组或附加组。类似于用户账号的管理，用户组的管理也可以通过集成的系统管理工具来完成。


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

Linux学习
Linux > 7 用户和用户组管理 >
7.3 与用户账号有关的系统文件

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

完成用户管理的工作有许多种方法，但是每一种方法实际上都是对有关的系统文件进行修改。
与用户和用户组相关的信息都存放在一些系统文件中，这些文件包括/etc/passwd, /etc/shadow, /etc/group等。
下面分别介绍这些文件的内容。
1、/etc/passwd文件是用户管理工作涉及的最重要的一个文件。
Linux系统中的每个用户都在/etc/passwd文件中有一个对应的记录行，它记录了这个用户的一些基本属性。
这个文件对所有用户都是可读的。它的内容类似下面的例子：
[root@localhost ~]＃ cat /etc/passwd
root:x:0:0:Superuser:/:
daemon:x:1:1:System daemons:/etc:
bin:x:2:2:Owner of system commands:/bin:
sys:x:3:3:Owner of system files:/usr/sys:
adm:x:4:4:System accounting:/usr/adm:
uucp:x:5:5:UUCP administrator:/usr/lib/uucp:
auth:x:7:21:Authentication administrator:/tcb/files/auth:
cron:x:9:16:Cron daemon:/usr/spool/cron:
listen:x:37:4:Network daemon:/usr/net/nls:
lp:x:71:18:Printer administrator:/usr/spool/lp:
sam:x:200:50:Sam san:/home/sam:/bin/sh
从上面的例子我们可以看到，/etc/passwd中一行记录对应着一个用户，每行记录又被冒号(:)分隔为7个字段，其格式和具体含义如下：
用户名:口令:用户标识号:组标识号:注释性描述:主目录:登录Shell
1）"用户名"是代表用户账号的字符串。
通常长度不超过8个字符，并且由大小写字母和/或数字组成。登录名中不能有冒号(:)，因为冒号在这里是分隔符。
为了兼容起见，登录名中最好不要包含点字符(.)，并且不使用连字符(-)和加号(+)打头。
2）“口令”一些系统中，存放着加密后的用户口令字。
虽然这个字段存放的只是用户口令的加密串，不是明文，但是由于/etc/passwd文件对所有用户都可读，所以这仍是一个安全隐患。因此，现在许多Linux 系统（如SVR4）都使用了shadow技术，把真正的加密后的用户口令字存放到/etc/shadow文件中，而在/etc/passwd文件的口令字段中只存放一个特殊的字符，例如“x”或者“*”。
3）“用户标识号”是一个整数，系统内部用它来标识用户。
一般情况下它与用户名是一一对应的。如果几个用户名对应的用户标识号是一样的，系统内部将把它们视为同一个用户，但是它们可以有不同的口令、不同的主目录以及不同的登录Shell等。
通常用户标识号的取值范围是0～65 535。0是超级用户root的标识号，1～99由系统保留，作为管理账号，普通用户的标识号从100开始。在Linux系统中，这个界限是500。
4）“组标识号”字段记录的是用户所属的用户组。
它对应着/etc/group文件中的一条记录。
5)“注释性描述”字段记录着用户的一些个人情况。
例如用户的真实姓名、电话、地址等，这个字段并没有什么实际的用途。在不同的Linux 系统中，这个字段的格式并没有统一。在许多Linux系统中，这个字段存放的是一段任意的注释性描述文字，用做finger命令的输出。
6)“主目录”，也就是用户的起始工作目录。
它是用户在登录到系统之后所处的目录。在大多数系统中，各用户的主目录都被组织在同一个特定的目录下，而用户主目录的名称就是该用户的登录名。各用户对自己的主目录有读、写、执行（搜索）权限，其他用户对此目录的访问权限则根据具体情况设置。
7)用户登录后，要启动一个进程，负责将用户的操作传给内核，这个进程是用户登录到系统后运行的命令解释器或某个特定的程序，即Shell。
Shell是用户与Linux系统之间的接口。Linux的Shell有许多种，每种都有不同的特点。常用的有sh(Bourne Shell), csh(C Shell), ksh(Korn Shell), tcsh(TENEX/TOPS-20 type C Shell), bash(Bourne Again Shell)等。
系统管理员可以根据系统情况和用户习惯为用户指定某个Shell。如果不指定Shell，那么系统使用sh为默认的登录Shell，即这个字段的值为/bin/sh。
用户的登录Shell也可以指定为某个特定的程序（此程序不是一个命令解释器）。
利用这一特点，我们可以限制用户只能运行指定的应用程序，在该应用程序运行结束后，用户就自动退出了系统。有些Linux 系统要求只有那些在系统中登记了的程序才能出现在这个字段中。
8)系统中有一类用户称为伪用户（pseudo users）。
这些用户在/etc/passwd文件中也占有一条记录，但是不能登录，因为它们的登录Shell为空。它们的存在主要是方便系统管理，满足相应的系统进程对文件属主的要求。
常见的伪用户如下所示：
伪用户含 义
bin 拥有可执行的用户命令文件
sys 拥有系统文件
adm 拥有帐户文件
uucp UUCP使用
lp lp或lpd子系统使用
nobody NFS使用

拥有帐户文件

1、除了上面列出的伪用户外，还有许多标准的伪用户，例如：audit, cron, mail, usenet等，它们也都各自为相关的进程和文件所需要。
由于/etc/passwd文件是所有用户都可读的，如果用户的密码太简单或规律比较明显的话，一台普通的计算机就能够很容易地将它破解，因此对安全性要求较高的Linux系统都把加密后的口令字分离出来，单独存放在一个文件中，这个文件是/etc/shadow文件。 有超级用户才拥有该文件读权限，这就保证了用户密码的安全性。
2、/etc/shadow中的记录行与/etc/passwd中的一一对应，它由pwconv命令根据/etc/passwd中的数据自动产生
它的文件格式与/etc/passwd类似，由若干个字段组成，字段之间用":"隔开。这些字段是：
登录名:加密口令:最后一次修改时间:最小时间间隔:最大时间间隔:警告时间:不活动时间:失效时间:标志
?"登录名"是与/etc/passwd文件中的登录名相一致的用户账号
?"口令"字段存放的是加密后的用户口令字，长度为13个字符。如果为空，则对应用户没有口令，登录时不需要口令；如果含有不属于集合 { ./0-9A-Za-z }中的字符，则对应的用户不能登录。
?"最后一次修改时间"表示的是从某个时刻起，到用户最后一次修改口令时的天数。时间起点对不同的系统可能不一样。例如在SCO Linux 中，这个时间起点是1970年1月1日。
?"最小时间间隔"指的是两次修改口令之间所需的最小天数。
?"最大时间间隔"指的是口令保持有效的最大天数。
?"警告时间"字段表示的是从系统开始警告用户到用户密码正式失效之间的天数。
?"不活动时间"表示的是用户没有登录活动但账号仍能保持有效的最大天数。
?"失效时间"字段给出的是一个绝对的天数，如果使用了这个字段，那么就给出相应账号的生存期。期满后，该账号就不再是一个合法的账号，也就不能再用来登录了。
下面是/etc/shadow的一个例子：
[root@localhost ~]＃ cat /etc/shadow
root:Dnakfw28zf38w:8764:0:168:7:::
daemon:*::0:0::::
bin:*::0:0::::
sys:*::0:0::::
adm:*::0:0::::
uucp:*::0:0::::
nuucp:*::0:0::::
auth:*::0:0::::
cron:*::0:0::::
listen:*::0:0::::
lp:*::0:0::::
sam:EkdiSECLWPdSa:9740:0:0::::
3、用户组的所有信息都存放在/etc/group文件中。
将用户分组是Linux 系统中对用户进行管理及控制访问权限的一种手段。
每个用户都属于某个用户组；一个组中可以有多个用户，一个用户也可以属于不同的组。
当一个用户同时是多个组中的成员时，在/etc/passwd文件中记录的是用户所属的主组，也就是登录时所属的默认组，而其他组称为附加组。
用户要访问属于附加组的文件时，必须首先使用newgrp命令使自己成为所要访问的组中的成员。
用户组的所有信息都存放在/etc/group文件中。此文件的格式也类似于/etc/passwd文件，由冒号(:)隔开若干个字段，这些字段有：
组名:口令:组标识号:组内用户列表
?"组名"是用户组的名称，由字母或数字构成。与/etc/passwd中的登录名一样，组名不应重复。
?"口令"字段存放的是用户组加密后的口令字。一般Linux 系统的用户组都没有口令，即这个字段一般为空，或者是*。
?"组标识号"与用户标识号类似，也是一个整数，被系统内部用来标识组。
?"组内用户列表"是属于这个组的所有用户的列表/b]，不同用户之间用逗号(,)分隔。这个用户组可能是用户的主组，也可能是附加组。
/etc/group文件的一个例子如下：
root::0:root
bin::2:root,bin
sys::3:root,uucp
adm::4:root,adm
daemon::5:root,daemon
lp::7:root,lp
users::20:root,sam


7.4 批量添加用户

Linux学习
Linux > 7 用户和用户组管理 >
7.4 批量添加用户

添加批量用户

添加和删除用户对每位Linux系统管理员都是轻而易举的事，比较棘手的是如果要添加几十个、上百个甚至上千个用户时，我们不太可能还使用useradd一个一个地添加，必然要找一种简便的创建大量用户的方法。Linux系统提供了创建大量用户的工具，可以让您立即创建大量用户，方法如下：
（1）先编辑一个文本用户文件。
每一列按照/etc/passwd密码文件的格式书写，要注意每个用户的用户名、UID、宿主目录都不可以相同，其中密码栏可以留做空白或输入x号。一个范例文件user.txt内容如下：
user001::600:100:user:/home/user001:/bin/bash
user002::601:100:user:/home/user002:/bin/bash
user003::602:100:user:/home/user003:/bin/bash
user004::603:100:user:/home/user004:/bin/bash
user005::604:100:user:/home/user005:/bin/bash
user006::605:100:user:/home/user006:/bin/bash
（2）以root身份执行命令 /usr/sbin/newusers，从刚创建的用户文件user.txt中导入数据，创建用户：
[root@localhost ~]# newusers < user.txt
然后可以执行命令 vipw 或 vi /etc/passwd 检查 /etc/passwd 文件是否已经出现这些用户的数据，并且用户的宿主目录是否已经创建。
（3）执行命令/usr/sbin/pwunconv。
将 /etc/shadow 产生的 shadow 密码解码，然后回写到 /etc/passwd 中，并将/etc/shadow的shadow密码栏删掉。这是为了方便下一步的密码转换工作，即先取消 shadow password 功能。
[root@localhost ~]# pwunconv
（4）编辑每个用户的密码对照文件。
格式为：
用户名:密码
实例文件 passwd.txt 内容如下：
user001:123456
user002:123456
user003:123456
user004:123456
user005:123456
user006:123456
（5）以 root 身份执行命令 /usr/sbin/chpasswd。
创建用户密码，chpasswd 会将经过 /usr/bin/passwd 命令编码过的密码写入 /etc/passwd 的密码栏。
[root@localhost ~]# chpasswd < passwd.txt
（6）确定密码经编码写入/etc/passwd的密码栏后。
执行命令 /usr/sbin/pwconv 将密码编码为 shadow password，并将结果写入 /etc/shadow。
[root@localhost ~]# pwconv
这样就完成了大量用户的创建了，之后您可以到/home下检查这些用户宿主目录的权限设置是否都正确，并登录验证用户密码是否正确。


8.Linux软件包管理

Linux学习
Linux >
8.Linux软件包管理

Linux软件包管理

1.软件包管理简介

2.RPM包管理 -rpm命令管理

3.RPM包管理 -yum在线管理

4.源码包管理

5.脚本安装包与软件包选择


8.1 软件包管理简介

Linux学习
Linux > 8.Linux软件包管理 >
8.1 软件包管理简介

软件包管理简介

1.软件包分类

源码包 ：脚本安装包

（c语言的源代码，方便阅读，系统安装的慢，安装需要转义为二进制，安装过程与windows差不 多）

二进制包 ：RPM包、系统默认包

（经过编译的二进制包，加快安装速度，简化安装操作，不方便阅读）

2.源码包

源码包的优点是：

  • 开源，如果有足够的能力，可以修改源代码
  • 可以自由选择所需的功能
  • 软件是编译安装，所以更加适合自己的系统，更加稳定也效率更高
  • 卸载方便

源码包的缺点：

  • 安装过程步骤较多，尤其安装较大的软件集合时（如LAMP环境搭建），容易出现拼写错误
  • 编译过程时间较长，安装比二进制安装时间长
  • 因为是编译安装，安装过程中一旦报错新手很难解决

3.RPM包

二进制包的优点：

  • 包管理系统简单，只通过几个命令就可以实现包的安装、升级、查询和卸载
  • 安装速度比源码包安装快的多

二进制包缺点：

  • 经过编译，不再可以看到源代码
  • 功能选择不如源码包灵活
  • 依赖性（a--->b--->c）


8.2 RPM包管理 -rpm命令管理

Linux学习
Linux > 8.Linux软件包管理 >
8.2 RPM包管理 -rpm命令管理

RPM包管理 -rpm命令管理

1.RPM包命名原则

httpd-2.2.15-15.3l6.centos.1.i686.rpm（包名是httpd,包全名是httpd-2.2.15-15.3l6.centos.1.i686.rpm）

httpd 软件包名

2.2.15 软件版本

15 软件发布的次数

el6.centos 适合的Linux平台

i686 适合的硬件平台

rpm rpm包扩展名

2.RPM包依赖性

  • 树形依赖：a-->b-->c（最典型的依赖）
  • 环形依赖：a-->b-->c-->a
  • 模块依赖：模块依赖查询网站：www.rpmfind.net

范例：

[root@192 ~]# mkdir /mnt/cdrom #创建挂载目录
[root@192 dev]# mount /dev/sr0 /mnt/cdrom #挂载iso
mount: /dev/sr0 写保护，将以只读方式挂载

3.包全名与包名

  • 包全名：操作的包是没有安装的软件包时，使用包全名。而且要注意路径（安装）
  • 包名：操作已经安装的软件包时，使用包名。是搜索/var/lib/rpm/中的数据库（执行、卸载）

4.RPM安装

rpm -ivh 包全名
选项：
-i（install） 安装
-v（verbose） 显示详细信息
-h（hash） 显示进度
--nodeps 不检测依赖性

[root@192 Packages]# rpm -ivh httpd- #按tab键就会列出与httpd相关的安装包
httpd-2.4.6-95.el7.centos.x86_64.rpm httpd-manual-2.4.6-95.el7.centos.noarch.rpm
httpd-devel-2.4.6-95.el7.centos.x86_64.rpm httpd-tools-2.4.6-95.el7.centos.x86_64.rpm

[root@192 Packages]# rpm -ivh httpd-2.4.6-95.el7.centos.x86_64.rpm #安装httpd
错误：依赖检测失败：
/etc/mime.types 被 httpd-2.4.6-95.el7.centos.x86_64 需要
httpd-tools = 2.4.6-95.el7.centos 被 httpd-2.4.6-95.el7.centos.x86_64 需要
[root@192 Packages]# rpm -ivh httpd-tools-2.4.6-95.el7.centos.x86_64.rpm
准备中... ################################# [100%]
正在升级/安装...
1:httpd-tools-2.4.6-95.el7.centos ################################# [100%]

我们主要看第2个100%

[root@192 Packages]# rpm -ivh httpd-2.4.6-95.el7.centos.x86_64.rpm
错误：依赖检测失败：
/etc/mime.types 被 httpd-2.4.6-95.el7.centos.x86_64 需要
[root@192 Packages]# yum deplist httpd #检查依赖性
已加载插件：fastestmirror, langpacks
Loading mirror speeds from cached hostfile
* base: mirrors.huaweicloud.com
* extras: mirrors.aliyun.com
* updates: mirrors.aliyun.com
软件包：httpd.x86_64 2.4.6-97.el7.centos.2
依赖：/bin/sh
provider: bash.x86_64 4.2.46-35.el7_9
依赖：/etc/mime.types
provider: mailcap.noarch 2.1.41-2.el7
依赖：/usr/sbin/groupadd
provider: shadow-utils.x86_64 2:4.6-5.el7
依赖：/usr/sbin/useradd
provider: shadow-utils.x86_64 2:4.6-5.el7
依赖：httpd-tools = 2.4.6-97.el7.centos.2
[root@192 Packages]# rpm -ivh mailcap-2.1.41-2.el7.noarch.rpm
准备中... ################################# [100%]
正在升级/安装...
1:mailcap-2.1.41-2.el7 ################################# [100%]
[root@192 Packages]# rpm -ivh httpd-
httpd-2.4.6-95.el7.centos.x86_64.rpm httpd-manual-2.4.6-95.el7.centos.noarch.rpm
httpd-devel-2.4.6-95.el7.centos.x86_64.rpm httpd-tools-2.4.6-95.el7.centos.x86_64.rpm
[root@192 Packages]# rpm -ivh httpd-2.4.6-95.el7.centos.x86_64.rpm
准备中... ################################# [100%]
正在升级/安装...
1:httpd-2.4.6-95.el7.centos ################################# [100%]

我在安装htppd升级包的时候奔溃了，依赖的包太多了!需要用到yum在处理依赖性的方法

5.RPM包升级

rpm -Uvh 包全名
选项：
-U（upgrade） 升级

6.卸载

rpm -e 包名
选项：
-e（erase） 卸载
--nodeps 不检测依赖性

[root@192 Packages]# rpm -e httpd
错误：依赖检测失败：
httpd = 2.4.6-95.el7.centos 被 (已安裝) httpd-manual-2.4.6-95.el7.centos.noarch 需要

[root@192 Packages]# rpm -e httpd-manual
[root@192 Packages]# rpm -e httpd


8.3 RPM包管理-其他内容

Linux学习
Linux > 8.Linux软件包管理 >
8.3 RPM包管理-其他内容

1.查询是否安装

[root@192 /]# rpm -q 包名 #查询包是否安装
选项：
-q 查询（query）
[root@192 /]# rpm -qa #查询所有已经安装的RPM包
选项：
-a 所有（all）

[root@192 /]# rpm -qa | grep httpd
httpd-tools-2.4.6-95.el7.centos.x86_64

2.查询软件包详细信息

[root@192 /]# rpm -qi 包名
选项：
-i 查询软件信息（information）
-p 查询未安装包信息（package）[包全名]

3.查询包中文件安装位置

[root@192 /]# rpm -ql 包名
选项：
-l 列表（list）
-p 查询未安装包信息（package）

4.查询系统文件属于哪个RPM包

[root@192 /]# rpm -qf 系统文件名
选项：
-f 查询系统文件属于哪个软件包（file）

5.查询软件包的依赖性

[root@192 /]# rpm -qR 包名
选项：
-R 查询软件包的依赖性（requires）
-p 查询未安装包信息（package）

6.RPM包检验（查看被修改的文件）

[root@192 /]# rpm -V 已安装的包名
选项：
-V 校验指定RPM包中的文件（verify）

验证内容中的8个信息的具体内容如下：

  • S 文件大小是否改变
  • M 文件的类型或文件的权限（rwx）是否被改变
  • 5 文件MD5校验和是否改变（可以看成文件内容是否改变）
  • D 设备中，从代码是否改变
  • L 文件路径是否改变
  • U 文件的属主（所有者）是否改变
  • G 文件的属组是否改变
  • T 文件的修改时间是否改变

文件类型

  • c 配置文件（config file）
  • d 普通文档（documentation）
  • g "鬼"文件（ghost file）,很少见，就是该文件不应该被这个RPM包包含
  • l 授权文件（license file）
  • r 描述文件（read me）

7.RPM包中文件提取 （文件修复用的）

[root@192 /]# rpm2cpio 包全名 |[\（表示换行）] cpio -idv.文件绝对路径
rpm2cpio #将rpm包转换为cpio格式的命令
cpio #是一个标准工具，它用于创建软件档案文件和从档案文件中提取文件

[root@192 /]# cpio 选项 <[文件|设备]
选项：
-i: copy-in模式，还原
-d: 还原时自动新建目录
-v: 显示还原过程

范例：测试文件修改功能

[root@192 ~]# rpm -qf /bin/ls #查询ls命令属于哪个软件包
coreutils-8.22-24.el7_9.2.x86_64
[root@192 ~]# mv /bin/ls /tmp/ #造成ls命令误删除假象
[root@192 ~]# ls
bash: ls: 未找到命令...
相似命令是： 'lz'
[root@192 ~]# rpm2cpio /mnt/cdrom/Packages/coreutils-8.22-24.el7.x86_64.rpm |cpio -idv ./bin/ls #提取RP包中ls命令到当前目录的/bin/ls下
28603 块
[root@192 ~]# cp /root/bin/ls /bin/ #把ls命令复制会/bin/目录，修复文件丢失


8.4 RPM包管理 -yum在线管理

Linux学习
Linux > 8.Linux软件包管理 >
8.4 RPM包管理 -yum在线管理

RPM包管理 -yum在线管理

用来解决依赖性，自动安装

1.IP地址配置和网络yum源

[root@192 ~]# ifconfig eth0 192.168.1.156 #临时生效一旦重启，就会失效 ，想要永久修改，查看3.8命令

[root@192 ~]# ping www.sina.com.cn
PING ww1.sinaimg.cn.w.alikunlun.com (124.165.216.217) 56(84) bytes of data.
64 bytes from 217.216.165.124.adsl-pool.sx.cn (124.165.216.217): icmp_seq=1 ttl=57 time=6.73 ms
64 bytes from 217.216.165.124.adsl-pool.sx.cn (124.165.216.217): icmp_seq=2 ttl=57 time=7.03 ms
64 bytes from 217.216.165.124.adsl-pool.sx.cn (124.165.216.217): icmp_seq=3 ttl= 57 time=6.94 ms< /FONT>

网络yum源（linux的官方网络）

[root@192 ~]# cd /etc/yum.repos.d/ #yum源保存在CentOS-Base.repo
[root@192 yum.repos.d]# ls
CentOS-Base.repo CentOS-Debuginfo.repo CentOS-Media.repo CentOS-Vault.repo
CentOS-CR.repo CentOS-fasttrack.repo CentOS-Sources.repo CentOS-x86_64-kernel.repo
[root@192 yum.repos.d]# vim /etc/yum.repos.d/CentOS-Base.repo #查看yum文件

  • [base] 容器名称，一定要放在[]中
  • name 容器说明，可以自己随便写
  • mirrorlist 镜像站点，这个可以注释掉
  • baseurl 我们的yum源服务器的地址。默认是CentOS官方的yum源服务器，是可以使用的，如果你觉的慢可以改成你喜欢的yum源地址
  • enabled 此容器是否生效，如果不写或写成enable=1都是生效，写成enable=0就是不生效
  • gpgcheck 如果是1是指RPM的数字证书生效，如果是0则不生效
  • gpgkey 数字证书的公钥文件保存位置。不用修改

2.yum命令

2.1 查询

[root@192 yum.repos.d]# yum list #查询所有可用软件包列表

[root@192 yum.repos.d]# yum search 关键字（包名） #搜索服务器上所有和关键字相关的包

2.2 安装

[root@192 yum.repos.d]# yum -y install 包名
选项：
install 安装
-y 自动回答yes

[root@192 yum.repos.d]# yum -y install httpd #安装apache服务
已加载插件：fastestmirror, langpacks
Loading mirror speeds from cached hostfile
* base: mirrors.huaweicloud.com
* extras: mirrors.aliyun.com
* updates: mirrors.aliyun.com
base | 3.6 kB 00:00:00
extras | 2.9 kB 00:00:00
updates | 2.9 kB 00:00:00
正在解决依赖关系
--> 正在检查事务
---> 软件包 httpd.x86_64.0.2.4.6-97.el7.centos.2 将被 安装
--> 正在处理依赖关系 httpd-tools = 2.4.6-97.el7.centos.2，它被软件包 httpd-2.4.6-97.el7.centos.2.x86_64 需要
--> 正在检查事务
---> 软件包 httpd-tools.x86_64.0.2.4.6-95.el7.centos 将被 升级
---> 软件包 httpd-tools.x86_64.0.2.4.6-97.el7.centos.2 将被 更新
--> 解决依赖关系完成

依赖关系解决

==========================================================================================================================================
Package 架构 版本 源 大小
==========================================================================================================================================
正在安装:
httpd x86_64 2.4.6-97.el7.centos.2 updates 2.7 M
为依赖而更新:
httpd-tools x86_64 2.4.6-97.el7.centos.2 updates 94 k

事务概要
==========================================================================================================================================
安装 1 软件包
升级 ( 1 依赖软件包)

总下载量：2.8 M
Downloading packages:
No Presto metadata available for updates
(1/2): httpd-tools-2.4.6-97.el7.centos.2.x86_64.rpm | 94 kB 00:00:00
(2/2): httpd-2.4.6-97.el7.centos.2.x86_64.rpm | 2.7 MB 00:00:00
------------------------------------------------------------------------------------------------------------------------------------------
总计 3.6 MB/s | 2.8 MB 00:00:00
Running transaction check
Running transaction test
Transaction test succeeded
Running transaction
警告：RPM 数据库已被非 yum 程序修改。
正在更新 : httpd-tools-2.4.6-97.el7.centos.2.x86_64 1/3
正在安装 : httpd-2.4.6-97.el7.centos.2.x86_64 2/3
清理 : httpd-tools-2.4.6-95.el7.centos.x86_64 3/3
验证中 : httpd-2.4.6-97.el7.centos.2.x86_64 1/3
验证中 : httpd-tools-2.4.6-97.el7.centos.2.x86_64 2/3
验证中 : httpd-tools-2.4.6-95.el7.centos.x86_64 3/3

已安装:
httpd.x86_64 0:2.4.6-97.el7.centos.2

作为依赖被升级:
httpd-tools.x86_64 0:2.4.6-97.el7.centos.2

完毕！

[root@192 yum.repos.d]# yum -y install gcc #c语言的编辑器

2.3 升级

[root@192 yum.repos.d]# yum -y update 包名
选项：
update 升级
-y 自动回答yes

2.4 卸载（尽量不用）

[root@192 yum.repos.d]# yum -y remove 包名
选项：
remove 卸载
-y 自动回答yes

强调服务器安装原理：安装最小化安装不安装多余软件，使用什么软件安装什么软件，尽量不卸载，尤其是yum卸载，尽量不用

3.YUM软件组管理命令

[root@192 yum.repos.d]# yum grouplist #列出所以可用的软件组列表
已加载插件：fastestmirror, langpacks
没有安装组信息文件
Maybe run: yum groups mark convert (see man yum)
Loading mirror speeds from cached hostfile
* base: mirrors.huaweicloud.com
* extras: mirrors.aliyun.com
* updates: mirrors.aliyun.com
可用的环境分组：
最小安装
基础设施服务器
计算节点
文件及打印服务器
基本网页服务器
虚拟化主机
带 GUI 的服务器
GNOME 桌面
KDE Plasma Workspaces
开发及生成工作站
可用组：
传统 UNIX 兼容性
兼容性程序库
图形管理工具
安全性工具
开发工具
控制台互联网工具
智能卡支持
科学记数法支持
系统管理
系统管理工具
完成

[root@192 yum.repos.d]#yum groupinstall 软件组名 #安装指定软件组，组名可以由grouplist查询出来（安装英文）

[root@192 yum.repos.d]#yum groupremove 软件组名 #卸载指定软件组

3.光盘yum源搭建步骤

3.1 挂载光盘

[root@192 ~]# mount /dev/cdrom /mnt/cdrom/ #挂载光盘

3.2 让网络yum源文件失效

[root@192 ~]# cd /etc/yum.repos.d/
[root@192 yum.repos.d]# ls
CentOS-Base.repo CentOS-Debuginfo.repo CentOS-Media.repo CentOS-Vault.repo
CentOS-CR.repo CentOS-fasttrack.repo CentOS-Sources.repo CentOS-x86_64-kernel.repo
[root@192 yum.repos.d]# mv CentOS-Basc.repo CentOS-Base.repo.bak #改名字就会失效

3.2 修改光盘yum源文件

[root@192 yum.repos.d]# vim CentOS-Media.repo

[c7-media]
name=CentOS-$releasever - Media
baseurl=file:///mnt/cdrom/
#地址为你自己的光盘挂载地址
# file:///media/cdrom/
# file:///media/cdrecorder/
#注释这两个不存在的地址
gpgcheck=1
enabled=1 #把enable=0改为enable=1,让这个yum源配置文件生效
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-7


8.5 源码包管理

Linux学习
Linux > 8.Linux软件包管理 >
8.5 源码包管理

源码包管理

源码包和RPM包的区别

1.区别

  • 安装之前的区别：概念上的区别
  • 安装之后的区别：安装位置不同

2.RPM包安装位置

是安装在默认位置中：RPM包默认安装路径

/etc/ | 配置文件安装目录
/usr/bin/ | 可执行的命令安装目录
/usr/lib/ | 程序所使用的函数库保存位置
/usr/share/doc/ | 基本的软件使用手册保存位置
usr/share/man | 帮助文件保存位置

[root@my-think ~]# rpm -q httpd #查询httpd的安装包
httpd-2.4.6-97.el7.centos.2.x86_64
[root@my-think ~]# rpm -ql httpd #查询httpd的安装路径
/etc/httpd
/etc/httpd/conf
/etc/httpd/conf.d
/etc/httpd/conf.d/README
/etc/httpd/conf.d/autoindex.conf
/etc/httpd/conf.d/userdir.conf
/etc/httpd/conf.d/welcome.conf
/etc/httpd/conf.modules.d ...

3.源码包安装位置

安装在指定位置当中，一般是 /usr/local/软件名/ #Linux专门准备的位置

4.安装位置不同带来的影响

RPM包安装的服务可以使用系统服务管理命令（service）来管理，例如RPM包安装的apache的启动方法是：

[root@my-think init.d]# service httpd start #只有在redhat系列中才能用service,也可以使用绝对路径启动
Redirecting to /bin/systemctl start httpd.service

开放防火墙端口80

[root@my-think bin]# firewall-cmd --zone=public --add-port=80/tcp --permanent
success
[root@my-think bin]# firewall-cmd --reload
success

使用网页进行访问网络地址：192.168.1.8

默认放网页的地方：/var/www/html

可以在html文件夹中创建index.html测试网页

源码包安装的服务则不能被服务管理命令管理，因为没有安装到默认路径中。所以只能用绝对路径进行服务的管理，如：

/usr/local/apache2/bin/apachectl start

源码包安装过程

北京理工大学开源软件镜像服务 http://mirror.bit.edu.cn/web/

1.安装准备

安装C语言编译器

下载源码包：http://mirror.bit.edu.cn/cn/apache/httpd

2.安装注意事项

  • 源代码保存位置：/usr/local/src/
  • 软件安装位置：/usr/local/
  • 如何确定安装过程报错：
  • ---> 安装过程停止
  • ---> 并出现error、warning或no的提示

3.源码包安装过程

  • 下载源码包 ：使用ftp进行传输
  • 解压缩下载的源码包 ：tar -zxvf httpd-2.4.51.tar.gz #解压
  • [root@my-think src]# du -sh httpd-2.4.51 #查看文件多大
    48M httpd-2.4.51
  • 进入解压缩目录（不能省略）

其中有两个说明是重要的，一个是安装说明：INSTALL 一个是使用说明：README

INSTALL 安装步骤列出来了
$ ./configure --prefix=PREFIX 软件配置与检查< /FONT>

  • 定义需要的功能选项
  • 检测系统环境是否符合安装要求
  • 把定义好的功能选项和检查系统环境的信息都写入Makefile文件，用于后续的编辑

[root@my-think httpd-2.4.51]# ./configure --prefix=/usr/local/apache2 #定义绝对路径的位置< /FONT>

configure:
checking for APR-util... no
configure: error: APR-util not found. Please read the documentation. #报错了，不管理，自己百度去

$ make #编译 如果报错，只要清空已经编译的内容就行了 make clean #清空临时文件，这个时候在local目录中是没有apache2目录的
$ make install # 编译安装
$ PREFIX/bin/apachectl start #启动方法

4.源码包的卸载

不需要卸载命令，直接删除安装目录即可。不会遗留任何垃圾文件


8.6. 脚本安装包

Linux学习
Linux > 8.Linux软件包管理 >
8.6. 脚本安装包

脚本安装包

1.脚本安装包（硬件驱动）

  • 脚本安装包并不是独立的软件包类型，常见安装的是源码包
  • 是人为把安装过程写成了自动安装的脚本，只要执行脚本，定义简单的参数，就可以完成安装
  • 非常类似于Windows下软件的安装方式

2.Webmin的作用

Webmin是一个基于Web的Linux系统管理界面。您就可以通过图形化的方式设置用户账号、Apache、DNS、文件共享等服务。

3.Webmin安装过程

  • 下载软件： http://sourceforge.net/projects/webadmin/files/webmin/
  • 解压缩，并进入解压缩目录
  • 执行安装脚本

[root@my-think webmin-1.610]# ./setup.sh #直接执行.sh脚本就可以了

在网页中打开地址 http://192.168.1.8:10000

修改防火墙端口

[root@my-think webmin-1.610]# firewall-cmd --zone=public --add-port=10000/tcp --permanent
success
[root@my-think webmin-1.610]# firewall-cmd --reload
success


9 Linux常用传输工具

Linux学习
Linux >
9 Linux常用传输工具

Linux常用传输工具

1.ftp服务传输

2.tftp

3.sftp

4.scp

一般我们只要用ftp客户端工具就可以实现传输

我常用的是xftp，还有其他的工具ssh secure file transfer工具等


9.1 ftp传输

Linux学习
Linux > 9 Linux常用传输工具 >
9.1 ftp传输

ftp

FTP(File Transfer Protocol,文件传输协议) 是TCP/IP协议组中的协议之一。FTP协议包括两个组成部分，其一为FTP服务，其二为FTP客户端。其中FTP服务器用来存储文件，用户可以使用FTP客户端通过FTP协议访问位于FTP服务器上的资源。在开发网站的时候，通常利用FTP协议把网页或程序传到Web服务器上。此外，由于FTP传输效率非常高，在网络上传输大的文件时，一般也采用该协议。

默认情况下FTP协议使用TCP端口中的20和21这两个端口，其中20用于传输数据，21用于传输控制信息。但是，是否使用20作为传输数据的端口与FTP使用的传输模式有关，如果采用主动模式，那么数据传输端口就是20；如果采用被动模式，则具体最终使用哪个端口要服务器端和客户端协商决定。

在配置ftp需要修改配置

1.网络，需要使用桥接模式，保证内网和外网相连接，因为本地地址是192.168.1.6，我们需要设置Linux网络地址

修改网络地址：ifconfig eth0 192.168.1.8

2.安装ftp

Ubuntu安装ftp服务器

apt-get install vsftpd

Redhat安装ftp服务器

rpm - ivh vsftpd-1.1.3-8.i386.rpm

[root@192 ~]# yum -y install vsftpd #云端下载安装服务

3.配置服务器

[root@192 ~]# ls /etc/vsftpd
ftpusers user_list vsftpd.conf vsftpd_conf_migrate.sh

vim /etc/vsftpd.conf(Ubuntu) 或者 vim /etc/vsftpd/vsftpd.conf

4.关闭防火墙（有的用iptables,有的用firewall）

[root@192 ~]# service iptables stop #关闭防火墙

下面命令让防火墙对20和21端口开放 --permanent为永久开放(CentOS中的)

[root@192 ~]# firewall-cmd --zone=public --add-port=20/tcp --permanent
success
[root@192 ~]# firewall-cmd --zone=public --add-port=21/tcp --permanent
success

[root@192 ~]# firewall-cmd --reload #重新载入
success
[root@192 ~]# firewall-cmd --zone=public --query-port=20/tcp #查看端口
yes
[root@192 ~]# firewall-cmd --zone=public --remove-port=20/tcp --permanent #删除例外端口

5.启动ftp服务器

/etc/init.d/vsftpd restart 或者 service vsftpd restart

6.正式测试ftp的用法

在windows的DOS系统输入dir，然后进行切换到cd desktop

在cmd中输入ftp IP地址登录到linux，一般不用root用户

使用命令ls查看该用户下内容，cd进行切换

使用get获取文件，使用put进行上传

7.安装ftp客户端

8.ftp的Shell脚本编辑

ftp -n -v << EOF
open $HOST $PORT
user $USER $PASS
mkdir $EXECUTE_YEAR
cd $EXECUTE_YEAR
mkdir $EXECUTE_DAY
bye
EOF

-n :一般在启动ftp时，ftp会试着进行自动登录，本选项可以关掉这个功能。

-v：显示详细信息，本选项使得ftp显示远端服务器的所有响应，并在数据传输完成后显示传输数据的统计信息。

-i：进行多个文件传输时关掉交互式的确认信息。

ftp -v -n 81.0.33.2<<EOF
user dwftp s6dw6ck
#进入标志文件目录取标志文件
cd /vol/dwftp/dwftp/flg
get done_fxq_$d2.flg done_fxq_$d2.flg
bye
EOF

9.退出ftp 使用bye命令


9.2 tftp

Linux学习
Linux > 9 Linux常用传输工具 >
9.2 tftp

tftp

TFTP是一个传输文件的简单协议，它基于UDP协议而实现，但是我们也不能确定有些TFTP协议是基于其它传输协议完成的。此协议设计的时候是进行小文件传输的。因此它不具备通常的FTP的许多功能，它只能从文件服务器上获得或写入文件，不能列出目录，不进行认证，它传输8位数据。传输中有三种模式：netascii，这是8位的ASCII码形式，另一种是octet，这是8位源数据类型；最后一种mail已经不再支持，它将返回的数据直接返回给用户而不是保存为文件。


9.3 sftp

Linux学习
Linux > 9 Linux常用传输工具 >
9.3 sftp

sftp

sftp是Secure File Transfer Protocol的缩写，安全文件传送协议。可以为传输文件提供一种安全的网络的加密方法。sftp与ftp有着几乎一样的语法和功能。SFTP为SSH的其中一部分，是一种传输档案至Blogger伺服器的安全方式。其实在SSH软件包中，已经包含了一个叫作SFTP（Secure File Transfer Protocol）安全文件信息传输子系统，SFTP本身没有单独的守护进程，它必须使用sshd守护进程（端口号默认是22）来完成相应的连接和答复操作，所以从某种意义上来说，SFTP并不像一个服务器程序，而更像是一个客户端程序。SFTP同样是使用加密传输认证信息和传输的数据，所以，使用SFTP是非常安全的。但是，由于传输方式使用了加密/解密技术，所以传输效率比普通的FTP要低得多，如果你对网络安全性要求更高时，可以使用SFTP代替FTP。


9.4 scp

Linux学习
Linux > 9 Linux常用传输工具 >
9.4 scp

scp

scp是secure copy的缩写，scp是Linux系统下基于ssh登陆进行安全的远程文件拷贝命令，主要用于Linux服务器之间复制文件和目录。scp使用ssh安全协议传输数据，具有和ssh一样的验证机制，从而可以实现安全的远程拷贝文件


10 Linux系统磁盘管理

Linux学习
Linux >
10 Linux系统磁盘管理

Linux系统磁盘管理

Linux 磁盘管理好坏直接关系到整个系统的性能问题。
Linux 磁盘管理常用三个命令为 df、du 和 fdisk。
? df（英文全称：disk full）：列出文件系统的整体磁盘使用量
? du（英文全称：disk used）：检查磁盘空间使用量
? fdisk：用于磁盘分区


10.1 查看磁盘使用情况 df

Linux学习
Linux > 10 Linux系统磁盘管理 >
10.1 查看磁盘使用情况 df

查看磁盘使用情况 df

df命令参数功能：检查文件系统的磁盘空间占用情况。可以利用该命令来获取硬盘被占用了多少空间，目前还剩下多少空间等信息。
语法：
df [-ahikHTm] [目录或文件名]
选项与参数：
-a ：列出所有的文件系统，包括系统特有的 /proc 等文件系统；
-k ：以 KBytes 的容量显示各文件系统；
-m ：以 MBytes 的容量显示各文件系统；
-h ：以人们较易阅读的 GBytes, MBytes, KBytes 等格式自行显示；
-H ：以 M=1000K 取代 M=1024K 的进位方式；
-T ：显示文件系统类型, 连同该 partition 的 filesystem 名称 (例如 ext3) 也列出；
-i ：不用硬盘容量，而以 inode 的数量来显示

范例 1：将系统内所有的文件系统列出来
[root@www ~]# df
Filesystem 1K-blocks Used Available Use% Mounted on
/dev/hdc2 9920624 3823112 5585444 41% /
/dev/hdc3 4956316 141376 4559108 4% /home
/dev/hdc1 101086 11126 84741 12% /boot
tmpfs 371332 0 371332 0% /dev/shm

在 Linux 底下如果 df 没有加任何选项，那么默认会将系统内所有的 (不含特殊内存内的文件系统与 swap) 都以 1 Kbytes 的容量来列出来！

范例 2：将容量结果以易读的容量格式显示出来
[root@www ~]# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/hdc2 9.5G 3.7G 5.4G 41% /
/dev/hdc3 4.8G 139M 4.4G 4% /home
/dev/hdc1 99M 11M 83M 12% /boot
tmpfs 363M 0 363M 0% /dev/shm

范例 3：将系统内的所有特殊文件格式及名称都列出来
[root@www ~]# df -aT
Filesystem Type 1K-blocks Used Available Use% Mounted on
/dev/hdc2 ext3 9920624 3823112 5585444 41% /
proc proc 0 0 0 - /proc
sysfs sysfs 0 0 0 - /sys
devpts devpts 0 0 0 - /dev/pts
/dev/hdc3 ext3 4956316 141376 4559108 4% /home
/dev/hdc1 ext3 101086 11126 84741 12% /boot
tmpfs tmpfs 371332 0 371332 0% /dev/shm
none binfmt_misc 0 0 0 - /proc/sys/fs/binfmt_misc
sunrpc rpc_pipefs 0 0 0 - /var/lib/nfs/rpc_pipefs

范例 4：将 /etc 底下的可用的磁盘容量以易读的容量格式显示
[root@www ~]# df -h /etc
Filesystem Size Used Avail Use% Mounted on
/dev/hdc2 9.5G 3.7G 5.4G 41% /


10.2 检查磁盘空间使用量 du

Linux学习
Linux > 10 Linux系统磁盘管理 >
10.2 检查磁盘空间使用量 du

检查磁盘空间使用量 du

Linux du 命令也是查看使用空间的，但是与 df 命令不同的是 Linux du 命令是对文件和目录磁盘使用的空间的查看，还是和df命令有一些区别的，这里介绍 Linux du 命令。
语法：
du [-ahskm] 文件或目录名称
选项与参数：
-a ：列出所有的文件与目录容量，因为默认仅统计目录底下的文件量而已。
-h ：以人们较易读的容量格式 (G/M) 显示；
-s ：列出总量而已，而不列出每个各别的目录占用容量；
-S ：不包括子目录下的总计，与 -s 有点差别。
-k ：以 KBytes 列出容量显示；
-m ：以 MBytes 列出容量显示；

范例 1：只列出当前目录下的所有文件夹容量（包括隐藏文件夹）:
[root@www ~]# du
8 ./test4 <==每个目录都会列出来
8 ./test2
....中间省略....
12 ./.gconfd <==包括隐藏文件的目录
220 . <==这个目录(.)所占用的总量
直接输入 du 没有加任何选项时，则 du 会分析当前所在目录里的子目录所占用的硬盘空间。

范例 2：将文件的容量也列出来
[root@www ~]# du -a
12 ./install.log.syslog <==有文件的列表了
8 ./.bash_logout
8 ./test4
8 ./test2
....中间省略....
12 ./.gconfd
220 .

范例 3：检查根目录底下每个目录所占用的容量
[root@www ~]# du -sm /*
7 /bin
6 /boot
.....中间省略....
0 /proc
.....中间省略....
1 /tmp
3859 /usr <==系统初期最大就是他了啦！
77 /var
通配符 * 来代表每个目录。
与 df 不一样的是，du 这个命令其实会直接到文件系统内去搜寻所有的文件数据。


10.3 磁盘分区 fdisk

Linux学习
Linux > 10 Linux系统磁盘管理 >
10.3 磁盘分区 fdisk

磁盘分区 fdisk

fdisk 是 Linux 的磁盘分区表操作工具。
语法：
fdisk [-l] 装置名称
选项与参数：
-l ：输出后面接的装置所有的分区内容。若仅有 fdisk -l 时， 则系统将会把整个系统内能够搜寻到的装置的分区均列出来。

实例 1：列出所有分区信息
[root@AY120919111755c246621 tmp]# fdisk -l

Disk /dev/xvda: 21.5 GB, 21474836480 bytes
255 heads, 63 sectors/track, 2610 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00000000

Device Boot Start End Blocks Id System
/dev/xvda1 * 1 2550 20480000 83 Linux
/dev/xvda2 2550 2611 490496 82 Linux swap / Solaris

Disk /dev/xvdb: 21.5 GB, 21474836480 bytes
255 heads, 63 sectors/track, 2610 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x56f40944

Device Boot Start End Blocks Id System
/dev/xvdb2 1 2610 20964793+ 83 Linux

范例 2：找出你系统中的根目录所在磁盘，并查阅该硬盘内的相关信息
[root@www ~]# df / <==注意：重点在找出磁盘文件名而已
Filesystem 1K-blocks Used Available Use% Mounted on
/dev/hdc2 9920624 3823168 5585388 41% /

[root@www ~]# fdisk /dev/hdc <==仔细看，不要加上数字喔！
The number of cylinders for this disk is set to 5005.
There is nothing wrong with that, but this is larger than 1024,
and could in certain setups cause problems with:
1) software that runs at boot time (e.g., old versions of LILO)
2) booting and partitioning software from other OSs
(e.g., DOS FDISK, OS/2 FDISK)

Command (m for help): <==等待你的输入！
输入 m 后，就会看到底下这些命令介绍

Command (m for help): m <== 输入 m 后，就会看到底下这些命令介绍
Command action
a toggle a bootable flag
b edit bsd disklabel
c toggle the dos compatibility flag
d delete a partition <==删除一个partition
l list known partition types
m print this menu
n add a new partition <==新增一个partition
o create a new empty DOS partition table
p print the partition table <==在屏幕上显示分割表
q quit without saving changes <==不储存离开fdisk程序
s create a new empty Sun disklabel
t change a partition's system id
u change display/entry units
v verify the partition table
w write table to disk and exit <==将刚刚的动作写入分割表
x extra functionality (experts only)

离开 fdisk 时按下 q，那么所有的动作都不会生效！相反的， 按下w就是动作生效的意思。
Command (m for help): p <== 这里可以输出目前磁盘的状态< /FONT>

Disk /dev/hdc: 41.1 GB, 41174138880 bytes <==这个磁盘的文件名与容量
255 heads, 63 sectors/track, 5005 cylinders <==磁头、扇区与磁柱大小
Units = cylinders of 16065 * 512 = 8225280 bytes <= = 每个磁柱的大小 < /FONT>

Device Boot Start End Blocks Id System
/dev/hdc1 * 1 13 104391 83 Linux
/dev/hdc2 14 1288 10241437+ 83 Linux
/dev/hdc3 1289 1925 5116702+ 83 Linux
/dev/hdc4 1926 5005 24740100 5 Extended
/dev/hdc5 1926 2052 1020096 82 Linux swap / Solaris
# 装置文件名 启动区否 开始磁柱 结束磁柱 1K大小容量 磁盘分区槽内的系统

Command (m for help): q
想要不储存离开吗？按下 q 就对了！不要随便按 w 啊！
使用 p 可以列出目前这颗磁盘的分割表信息，这个信息的上半部在显示整体磁盘的状态。


10.4 磁盘格式化

Linux学习
Linux > 10 Linux系统磁盘管理 >
10.4 磁盘格式化

磁盘格式化

磁盘分割完毕后自然就是要进行文件系统的格式化，格式化的命令非常的简单，使用 mkfs（make filesystem） 命令。
语法：
mkfs [-t 文件系统格式] 装置文件名
选项与参数：
-t ：可以接文件系统格式，例如 ext3, ext2, vfat 等(系统有支持才会生效)

范例 1查看 mkfs 支持的文件格式
[root@www ~]# mkfs[tab][tab]
mkfs mkfs.cramfs mkfs.ext2 mkfs.ext3 mkfs.msdos mkfs.vfat
按下两个[tab]，会发现 mkfs 支持的文件格式如上所示。
范例 2：将分区 /dev/hdc6（可指定你自己的分区） 格式化为 ext3 文件系统：
[root@www ~]# mkfs -t ext3 /dev/hdc6
mke2fs 1.39 (29-May-2006)
Filesystem label= <==这里指的是分割槽的名称(label)
OS type: Linux
Block size=4096 (log=2) <==block 的大小配置为 4K
Fragment size=4096 (log=2)
251392 inodes, 502023 blocks <==由此配置决定的inode/block数量
25101 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=515899392
16 block groups
32768 blocks per group, 32768 fragments per group
15712 inodes per group
Superblock backups stored on blocks:
32768, 98304, 163840, 229376, 294912

Writing inode tables: done
Creating journal (8192 blocks): done <==有日志记录
Writing superblocks and filesystem accounting information: done

This filesystem will be automatically checked every 34 mounts or
180 days, whichever comes first. Use tune2fs -c or -i to override.
# 这样就创建起来我们所需要的 Ext3 文件系统了！简单明了！


10.5 磁盘检验

Linux学习
Linux > 10 Linux系统磁盘管理 >
10.5 磁盘检验

磁盘检验

fsck（file system check）用来检查和维护不一致的文件系统。
若系统掉电或磁盘发生问题，可利用fsck命令对文件系统进行检查。
语法：
fsck [-t 文件系统] [-ACay] 装置名称
选项与参数：
-t : 给定档案系统的型式，若在 /etc/fstab 中已有定义或 kernel 本身已支援的则不需加上此参数
-s : 依序一个一个地执行 fsck 的指令来检查
-A : 对/etc/fstab 中所有列出来的 分区（partition）做检查
-C : 显示完整的检查进度
-d : 打印出 e2fsck 的 debug 结果
-p : 同时有 -A 条件时，同时有多个 fsck 的检查一起执行
-R : 同时有 -A 条件时，省略 / 不检查
-V : 详细显示模式
-a : 如果检查有错则自动修复
-r : 如果检查有错则由使用者回答是否修复
-y : 选项指定检测每个文件是自动输入yes，在不确定那些是不正常的时候，可以执行 # fsck -y 全部检查修复。

范例 1：查看系统有多少文件系统支持的 fsck 命令：
[root@www ~]# fsck[tab][tab]
fsck fsck.cramfs fsck.ext2 fsck.ext3 fsck.msdos fsck.vfat
范例 2：强制检测 /dev/hdc6 分区:
[root@www ~]# fsck -C -f -t ext3 /dev/hdc6
fsck 1.39 (29-May-2006)
e2fsck 1.39 (29-May-2006)
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information
vbird_logical: 11/251968 files (9.1% non-contiguous), 36926/1004046 blocks
如果没有加上 -f 的选项，则由于这个文件系统不曾出现问题，检查的经过非常快速！若加上 -f 强制检查，才会一项一项的显示过程。


10.6 磁盘挂载和卸载

Linux学习
Linux > 10 Linux系统磁盘管理 >
10.6 磁盘挂载和卸载

磁盘挂载和卸载

Linux 的磁盘挂载使用 mount 命令，卸载使用 umount 命令。
磁盘挂载语法：
mount [-t 文件系统] [-L Label名] [-o 额外选项] [-n] 装置文件名 挂载点

范例 1：用默认的方式，将刚刚创建的 /dev/hdc6 挂载到 /mnt/hdc6 上面！
[root@www ~]# mkdir /mnt/hdc6
[root@www ~]# mount /dev/hdc6 /mnt/hdc6
[root@www ~]# df
Filesystem 1K-blocks Used Available Use% Mounted on
.....中间省略.....
/dev/hdc6 1976312 42072 1833836 3% /mnt/hdc6

磁盘卸载命令 umount 语法：
umount [-fn] 装置文件名或挂载点
选项与参数：
-f ：强制卸除！可用在类似网络文件系统 (NFS) 无法读取到的情况下；
-n ：不升级 /etc/mtab 情况下卸除。

范例：卸载/dev/hdc6
[root@www ~]# umount /dev/hdc6


11 Linux系统管理

Linux学习
Linux >
11 Linux系统管理

Linux系统管理

1.进程管理

2.工作管理

3.系统资源查看

4.系统定时任务

5.日志管理

6.启动管理

7.备份与恢复


11.1 进程管理

Linux学习
Linux > 11 Linux系统管理 >
11.1 进程管理

进程管理

1.进程简介

进程是正在执行的一个程序或命令，每一个进程都是一个运行的实体，都有自己的地址空间，并占用一定的系统资源。

2.进程管理的作用

  • 判断服务器健康状态
  • 查看系统中所有进程
  • 杀死进程


11.1.1 进程查看

Linux学习
Linux > 11 Linux系统管理 > 11.1 进程管理 >
11.1.1 进程查看

进程查看

1.查看系统中所有进程

[root@localhost ~]# ps aux #查看系统中所有进程，使用BSD操作系统格式【使用UNIX系统格式】

[root@localhost ~]# ps -le #查看系统中所有进程，使用Linux标准命令格式

进程中的含义：

  • USER：该进程是由哪个用户产生的；
  • PID：进程的ID号
  • %CPU：该进程占用CPU资源的百分比，占用越高，进程越耗费资源
  • %MEM：该进程占用物理内存的百分比，占用越高，进程越耗费资源
  • VSZ：该进程占用虚拟内存的大小，单位KB；
  • RSS：该进程占用实际物理内存的大小，单位KB
  • TTY：该进程是在哪个终端中运行的。其中tty1-tty7代表本地控制台终端，tty1-tty6是本地的字符界面终端，tty7是图形终端。pts/0-256代表虚拟终端。
  • STAT：进程状态。常见的状态有： R：运行、S：睡眠、T：停止状态、s：包含子进程、+：位于后台(常见的几种)
  • START：该进程的启动时间
  • TIME：该进程占用CPU的运算时间，注意不是系统时间
  • COMMAND：产生此进程的命令名

2.查看系统健康状态

[root@localhost ~]# top [选项]

选项：（shift +m/p）
-d 秒数：指定top命令每隔几秒更新。默认是3秒
在top命令的交互模式当中可以执行的命令：
？或h： 显示交互模式的帮助
P： 以CPU使用率排序，默认就是此项
M： 以内存的使用率排序
N： 以PID排序
q: 退出top

默认是%CPU排序

第一行信息为任务队列信息

内容 | 说明
12:26:46 | 系统当前时间
up 1 day,13:32 | 系统的运行时间，本机已经运行1天13小时32分钟
2 user | 当前登录了两个用户
load average: 0.00,0.00,0.00 | 系统在之前1分钟，5分钟，15分钟的平均负载。一般认为小于1时，负载较小。如果大于1，系统已经超出负荷。

第二行为进程信息

内容 | 说明
Tasks: 95 total | 系统中的进程总数
1 running | 正在运行的进程数
94 sleeping | 睡眠的进程
0 stopped | 正在停止的进程
0 zombie | 僵尸进程。如果不是0，需要手工检查僵尸进程（服务正在停，但是没有停到，等一下再查看还有没有）

第三行为CPU信息

内容 | 说明
Cpu(s)： 0.1%us | 用户模式占用的CPU百分比
0.1%sy | 系统模式占用的CPU百分比
0.0%ni | 改变过优先级的用户进程占用的CPU百分比
99.7%id | 空闲CPU的CPU百分比
0.1%wa | 等待输入/输出的进程的占用CPU百分比
0.1%hi | 硬中断请求服务占用的CPU百分比
0.1%si | 软中断请求服务占用的CPU百分比
0.0%st | st（Steal time）虚拟时间百分比。就是当有虚拟机时，虚拟CPU等待实际CPU的时间百分比

第四行为物理内存信息

内容 | 说明
Mem： 625344k total | 物理内存的总量，单位KB
571504k used | 已经使用的物理内存数量
53840k free | 空闲的物理内存数量，我们使用的是虚拟机，总共值分配了628MB内存，所以只有53MB的空闲内存
65800k buffers | 作为缓冲的内存数量

第五行为交换分区（swap）信息

内容 | 说明
Swap： 524280k total | 交换分区（虚拟内存）的总大小
0k used | 已经使用的交互分区的大小
524280k free | 空闲交互分区的大小
409280k cached | 作为缓存的交互分区的大小

3.查看进程树

[root@localhost ~]# pstree [选项]
选项：
-p：显示进程的PID
-u：显示进程的所属用户


11.1.2 终止进程

Linux学习
Linux > 11 Linux系统管理 > 11.1 进程管理 >
11.1.2 终止进程

终止进程

1.kill命令

[root@localhost ~]# kill -l
#查看可用的进程信号

常用的信号

信号代号 | 信号名称 | 说明
1 | SIGHUP | 该信号让进程立即关闭，然后重新读取配置文件之后重启
2 | SIGINT | 程序终止信号，用于终止前台进程。相当于输出ctrl+c快捷键
8 | SIGFPE | 在发生致命的算术运算错误时发出。不仅包括浮点运算错误，还包括溢出及除数为0等其他所有的算术的错误
9 | SIGKILL | 用来立即结束程序的运行。本信号不能被阻塞、处理和忽略。一般用于强制终止进程
14 | SIGALRM | 时钟定时信号，计算的是实际的时间或时钟时间。alarm函数使用该信号
15 | SIGTERM | 正常结束进程的信号，kill命令的默认信号。有时如果进程以及发生问题，这个信号是无法正常终止进程的，我们才会尝试SIGKILL信号，也就是信号9
18 | SIGCONT | 该信号可以让暂停的进程恢复执行，本信号不能被阻断
19 | SIGSTOP | 该信号可以暂停前台进程，相当于输入ctrl+z快捷键。本信号不能被阻隔

范例：不认识不要随便杀

[root@localhost ~]# kill -1 22354 #重启进程
[root@localhost ~]# kill -9 22368 #强制杀死进程

[root@localhost ~]# pstree -p | grep httpd #查找httpd(apache)的服务进程树

2.killall命令

[root@localhost ~]# killall [选项][信号]进程名
#按照进程名杀死进程
选项：
-i： 交互式，询问是否要杀死某个进程
-I： 忽略进程名的大小写

[root@localhost ~]# killall -9 httpd #杀死所有Apache的进程

3.pkill命令

[root@localhost ~]# pkill [选项][信号]进程名
#按照进程名终止进程
选项：
-t 终端号：按照终端号踢出用户

[root@localhost ~]# w
#使用w命令查询本机已经登录的用户

[root@localhost ~]# pkill -t -9 pts/0
#强制杀死从pts/0虚拟终端登录的进程


11.2 工作管理

Linux学习
Linux > 11 Linux系统管理 >
11.2 工作管理

工作管理

1.把进程放入后台

[root@localhost ~]# tar -zcf etc.tar.gz /etc &

符号 & 表示把执行命令放到后台中继续执行

[root@localhost ~]# top
#在top命令执行的过程中，按下ctrl+z快捷键，在后台中暂停运行

ctrl+c 强制终止，ctrl+z 放入后台暂停运行

2.查看后台的工作

[root@localhost ~]# job [-l]
选项：
-l:显示工作的PID
注：“+”号代表最近一个放入后台的工作，也是工作恢复时，默认恢复的工作。“-”代表倒数第二个放入后台的工作

[root@localhost ~]# jobs
[1]+ 已停止 top #1表示工作号
[root@localhost ~]# jobs -l
[1]+ 59685 停止 (信号) top

[root@localhost ~]# jobs
[1]- 已停止 top
[2]+ 已停止 top

3.将后台暂停的工作恢复到前台执行

[root@localhost ~]# fg %工作号
参数：
%工作号:%号可以省略，但是注意工作号和PID的区别

4.把后台暂停的工作恢复到后台执行

[root@localhost ~]# bg %工作号

注：后台恢复执行的命令，是不能和前台有交互的，否则不能恢复到后台执行


11.3 系统资源管理

Linux学习
Linux > 11 Linux系统管理 >
11.3 系统资源管理

系统资源查看

1.vmstat命令监控系统资源

[root@localhost ~]# vmstat [刷新延时 刷新次数]

范例：

[root@localhost ~]# vmstat 1 3 #相当于把top命令ps结合使用了

2.dmesg开机时内核检测信息

[root@localhost ~]# dmesg

[root@localhost ~]# dmesg | grep CPU

3.free命令查看内存使用状态

[root@localhost ~]# free [-b|-k|-m|-g]
选项：
-b： 以字节为单位显示
-k： 以KB为单位显示，默认就是以KB为单位显示
-m： 以MB为单位显示
-g： 以GB为单位显示

[root@localhost ~]# free -m

缓存和缓冲的区别

简单来说缓存（cache）是用来加速数据从硬盘中“读取”的，而缓冲（buffer）是用来加速数据“写入”硬盘的

4.查看CPU信息

[root@localhost ~]# cat /proc/cpuinfo

5.uptime命令

[root@localhost ~]# uptime

#显示系统的启动时间和平均负载，也就是top命令的第一行。w命令也可以看到这个数据。

16:10:40 up 3 days, 15:47, 3 users, load average: 0.00, 0.01, 0.05

6.查看系统与内核相关信息

[root@localhost ~]# uname [选项]
选项：
-a： 查看系统所有相关信息
-r： 查看内核版本
-s： 查看内核名称

[root@localhost ~]# uname -a
Linux localhost.localdomain 3.10.0-1160.25.1.el7.x86_64 #1 SMP Wed Apr 28 21:49:45 UTC 2021 x86_64 x86_64 x86_64 GNU/Linux
[root@localhost ~]# uname -r
3.10.0-1160.25.1.el7.x86_64
[root@localhost ~]# uname -s
Linux

判断当前系统的位数 [root@localhost ~]# file /bin/ls

7.列出进程打开或使用的文件信息

[root@localhost ~]# lsof [选项] #列出进程调用或打开的文件信息
选项：
-c 字符串： 只列出以字符串开头的进程打开的文件
-u 用户名： 只列出某个用户的进程打开的文件
-p pid: 列出某个PID进程打开的文件

[root@localhost ~]# lsof -p 59534 查看进程59534的文件信息
[root@localhost ~]# lsof -c init 查看字符串init的进程信息


11.4 系统定时任务

Linux学习
Linux > 11 Linux系统管理 >
11.4 系统定时任务

系统定时任务

在指定的时间执行指定的命令

1. crond服务管理与访问控制

[root@localhost ~]# service crond restart #crond 服务启动命令

[root@localhost ~]# chkconfig crond on
注意：正在将请求转发到“systemctl enable crond.service”。

[root@localhost ~]# ps aux | grep crond #保证进程中有crond服务就可以
root 61285 0.1 0.1 126388 1688 ? Ss 18:23 0:00 /usr/sbin/crond -n
root 61405 0.0 0.0 112824 984 pts/0 R+ 18:30 0:00 grep --color=auto crond

2. 用户的crontab设置

[root@localhost ~]# crontab [选项]
选项：
-e： 编辑crontab定时任务
-l： 查询crontab任务
-r： 删除当前用户所有的crontab任务

[root@localhost ~]# crontab -e #进入crontab编辑界面。会打开vim编辑你的工作
* * * * * 执行的任务

项目 | 含义 | 范围
第一个“*” | 一小时当中的第几分钟 | 0-59
第二个 “*” | 一天当中的第几小时 | 0-23
第三个 “*” | 一个月当中的第几天 | 1-31
第四个 “*” | 一年当中的第几月 | 1-12
第五个 “*” | 一周当中的星期几 | 0-7（0和7都代表星期日）

特殊符号 | 含义
* | 代表任何时间。比如第一个“*”就代表一小时中每分钟都执行一次的意思
， | 代表不连续的时间。比如“0 8,12,16 * * *命令“，代表在每天的8点0分，12点0分，16点0分都执行一次
- | 代表连续的时间范围。比如“0 5 * * 1-6命令”，代表在周一到周六的凌晨5点0分执行命令
*/n | 代表每隔多久执行一次。比如“*/10 * * * *命令”，代表每隔10分钟就执行一遍命令

举例

时间 | 含义
45 22 * * * 命令 | 在22点45分执行命令
0 17 * * 1 命令 | 每周1的17点0分执行命令
0 5 1,15 * * 命令 | 每月1号和15号的凌晨5点0分执行命令
40 4 * * 1-5 命令 | 每周一到周五的凌晨4点40分执行一次命令
*/10 4 * * * 命令 | 每天的凌晨4点，每隔10分钟执行一次命令
0 0 1,15 * 1 命令 | 每月1号和15号，每周一的0点0分都会执行命令。注意：星期几和几号最好不要同时出现，因为他们定义的都是天。非常容易让管理员混乱。

*/5 * * * * /bin/echo "11" >>/tmp/test

[root@localhost ~]# date
2021年 12月 15日 星期三 19:07:02 CST
[root@localhost ~]# crontab -l
* * * * * /bin/echo "11" >>/tmp/test
[root@localhost ~]# cat /tmp/test
11
或者写成：* * * * * echo 111 >> /tmp/test

5 5 * * 2 /sbin/shutdown -r now

0 5 1,10,15 * * /root/sh/autobak.sh

[root@localhost ~]# crontab -r #删除定时任务
[root@localhost ~]# crontab -l
no crontab for root