01-shell基础概述

为什么学shell编程

python

golang

c c++

javascript java

一、为什么要学Shell编程

系统管理自动化
- 在Unix和Linux系统中，系统管理员需要执行大量重复性的任务，如文件管理（创建、删除、移动、复制文件和目录）、用户管理（添加、删除用户，修改用户权限）、软件安装和更新等。通过Shell编程，可以将这些任务编写成脚本，实现自动化操作。例如，在一个有上百台服务器的机房中，需要更新软件包。如果手动在每台服务器上执行更新命令，将是非常耗时的。使用Shell脚本可以同时在多台服务器上自动执行更新操作，大大提高工作效率。
任务调度
- 可以结合系统的任务调度工具（如Linux中的cron），让Shell脚本在指定的时间自动运行。比如，每天凌晨自动备份重要的数据文件，或者定期清理系统日志，确保系统的日志文件不会占用过多的磁盘空间。
数据处理和文本处理能力强
- Shell提供了强大的文本处理工具，如grep（用于在文本文件中查找特定的字符串模式）、sed（用于对文本进行编辑，如替换、删除特定行等操作）和awk（用于处理文本数据，如提取特定列的数据）。这些工具在处理大量的日志文件、配置文件等文本数据时非常有用。例如，从一个大型的服务器日志文件中提取出特定IP地址访问的记录，用于分析网络安全情况。
与系统底层紧密结合
- Shell脚本可以直接调用系统命令和工具，能够方便地获取系统资源信息（如CPU使用率、内存使用情况、磁盘空间等）。这对于监控系统性能、优化系统资源配置等操作非常有帮助。比如，编写一个Shell脚本，当服务器的磁盘空间使用率超过一定阈值（如90%）时，发送警报邮件给管理员。
跨平台适用性（在Unix/Linux家族）
- Shell脚本在Unix和Linux的各种发行版中具有较好的兼容性。一旦学会了Shell编程，基本可以在不同的Unix/Linux系统上运行相同的脚本，只需要做一些小的调整，如路径和软件包名称的差异等。这对于在多种服务器环境或者开发环境中工作的人来说非常方便。

二、什么是Shell编程

定义
- Shell是一个命令行解释器，它接收用户输入的命令并将其传递给操作系统内核去执行。Shell编程就是利用Shell所提供的语法和命令来编写脚本（script），这些脚本是一系列的命令集合，按照一定的逻辑顺序组合在一起，用于完成特定的任务。
- 例如，一个简单的Shell脚本可能是用来备份一个目录下的所有文件到另一个目录。脚本中会包含创建备份目录（如果不存在）、复制文件等命令。
常见的Shell类型
- Bash（Bourne - Again Shell）：这是目前大多数Linux系统默认的Shell。它是对原始Bourne Shell（sh）的增强版本，具有丰富的功能，如命令补全、历史命令记录、作业控制等。它的语法灵活，支持变量定义、条件判断、循环结构等编程特性，适用于各种复杂的脚本编写。
- sh（Bourne Shell）：这是Unix系统中最早出现的Shell之一。它的语法比较简洁，许多Shell脚本的基本语法都源于sh。虽然现在Bash更为常用，但sh仍然在一些简单的脚本或者需要考虑兼容性的场景下使用。
- csh（C - Shell）：它的语法类似于C语言，对熟悉C语言的用户比较友好。它提供了一些特色功能，如命令别名、作业控制等，但在脚本编程方面，Bash更为流行，不过csh在一些特定的学术和科研环境中仍然有使用。
- ksh（Korn Shell）：它结合了Bourne Shell和C - Shell的一些优点，具有强大的编程功能，如高级的变量处理、更好的数学运算支持等。它在一些企业级的Unix系统中使用。
Shell脚本的基本结构
- 开头部分（Shebang）：通常脚本的第一行是#!/bin/bash（如果是Bash脚本）或者#!/bin/sh等，这被称为Shebang。它告诉系统这个脚本应该使用哪种Shell来解释执行。
- 命令部分：这是脚本的主体部分，包含一系列的Shell命令，这些命令可以是系统命令（如ls、cp、mv等），也可以是Shell内置的命令（如echo用于输出信息、read用于读取用户输入等）。这些命令按照编写的顺序依次执行。
- 逻辑控制部分（可选）：包括条件判断（如if - then - else语句）和循环结构（如for循环、while循环）。用于根据不同的情况执行不同的命令，或者重复执行某些命令。例如，通过条件判断来检查文件是否存在，如果存在则执行备份操作，否则输出错误信息；通过循环来遍历一个目录下的所有文件并进行处理。

三、怎么学Shell编程

基础环境搭建
- 首先，需要有一个可以运行Shell的操作系统环境，如Linux或Unix系统。如果是初学者，建议使用Linux的一些用户友好型发行版，如Ubuntu或CentOS。可以通过安装虚拟机软件（如VirtualBox），在虚拟机中安装Linux操作系统来进行学习。
- 打开终端（Terminal）应用程序，这是与Shell交互的接口。在终端中可以输入Shell命令并查看执行结果。
学习基本命令
- 从最基本的命令开始学习，如ls（列出目录内容）、cd（改变目录）、pwd（显示当前目录）、cp（复制文件）、mv（移动文件）、rm（删除文件）等。了解这些命令的参数和用法，可以通过阅读命令的帮助文档（如man ls可以查看ls命令的详细手册）来深入学习。
- 练习组合使用这些命令来完成简单的任务，如创建一个目录，在目录中创建一些文件，然后将这些文件复制到另一个目录中。
学习变量和输入输出
- 掌握Shell中变量的定义和使用方法。变量可以用来存储数据，如文件名、目录名、用户输入等。例如，name="John"定义了一个名为name的变量，其值为John。
- 学会使用echo命令输出变量的值或者固定的文本信息。同时，学习read命令来接收用户输入并存储到变量中，这样可以让脚本与用户进行交互。
学习脚本结构和逻辑控制
- 了解脚本的开头部分（Shebang）的作用，学会编写简单的脚本文件。可以使用文本编辑器（如vi、vim或nano）来创建和编辑脚本文件。
- 学习条件判断语句（if - then - else）的语法和用法。例如，判断一个文件是否存在，如果存在则输出“文件存在”，否则输出“文件不存在”。
- 掌握循环结构（for循环和while循环）。例如，使用for循环来遍历一个目录下的所有文件并打印文件名，或者使用while循环来不断接收用户输入直到满足某个条件。
深入学习和实践
- 学习更高级的Shell特性，如函数的定义和使用。函数可以将一段代码封装起来，方便重复调用，提高脚本的模块化程度。
- 研究如何在Shell脚本中调用外部程序，以及如何处理外部程序的输出和错误。
- 通过实际的项目来练习Shell编程，如编写一个系统监控脚本，用于监控服务器的CPU使用率、内存使用情况、磁盘空间等，并在指标异常时发出警报；或者编写一个自动化部署脚本，用于将应用程序部署到服务器上。
- 参考优秀的Shell脚本示例，在网上有许多开源的Shell脚本可以供学习和参考，如在GitHub等代码托管平台上搜索Shell脚本项目，学习他人的代码结构、编程思路和技巧。

第一章：什么是编程语言

1.0 编程的目的

计算机的发明，是为了用机器取代/解放人力，而编程的目的则是将人类的思想流程按照某种能够被计算机识别的表达方式传递给计算机，从而达到让计算机能够像人脑/电脑一样自动执行的效果。

自动化任务
- 提高效率：在软件开发、系统管理、数据处理等众多领域，存在大量重复性的任务。以软件测试为例，每次更新软件版本后，都需要对软件的各项功能进行测试。通过编写测试脚本进行自动化测试，可以大大减少人工操作的时间和精力。比如，使用自动化测试框架（如Selenium用于Web应用测试），能够模拟用户在浏览器中的各种操作，如点击按钮、填写表单等，并且可以在短时间内对软件进行多次测试，每次更新软件后自动运行测试脚本，快速发现潜在问题。
- 减少错误：人类在执行重复性任务时容易出现疲劳和失误。而编程实现的自动化任务可以按照预设的规则精确地执行。例如，在财务数据处理中，每个月需要从不同部门收集数据并进行汇总、计算和报表生成。通过编写程序，可以确保每次数据处理的步骤和计算方法都是一致的，避免了人工计算可能出现的错误，如数据录入错误、计算失误等。
解决问题
- 复杂问题求解：许多实际问题非常复杂，手工计算或操作几乎无法解决。例如，在气象预报中，需要处理海量的气象数据，包括温度、湿度、气压、风速等多个变量在不同时间和空间的观测值。通过编写复杂的数值天气预报模型程序，利用高性能计算机进行计算，可以对大气运动进行模拟，从而预测天气变化。这些模型涉及大量的数学方程和物理原理，编程能够将这些复杂的计算过程实现，帮助气象学家做出更准确的天气预报。
- 优化资源分配：在物流和供应链管理领域，需要合理安排货物的运输、仓储等环节，以最小化成本并满足客户需求。通过编写算法和程序，可以根据货物的数量、目的地、运输工具的容量和成本等诸多因素，优化运输路线和仓储分配方案。例如，通过遗传算法等优化算法编程实现，找到最佳的车辆配送路线，提高物流效率，降低运输成本。
创新和创造
- 开发新软件和应用：编程是软件开发的核心手段。从移动应用到桌面软件，从企业级软件到游戏开发，程序员通过编写代码将创意变为现实。例如，开发一款全新的社交媒体应用，需要编写代码来实现用户注册、登录、发布动态、好友互动等功能。通过使用编程语言（如Python结合Django框架用于后端开发，JavaScript结合React框架用于前端开发）构建整个软件系统，为用户提供全新的社交体验。
- 构建智能系统：随着人工智能和机器学习的发展，编程被用于构建智能系统。例如，通过编写代码来训练神经网络模型，用于图像识别、语音识别、自然语言处理等领域。以图像识别为例，程序员使用深度学习框架（如TensorFlow或PyTorch）编写代码，收集和标注图像数据，训练模型识别图像中的物体、人物等内容，从而应用于安防监控、自动驾驶等众多领域。
数据处理和分析
- 数据挖掘和知识发现：在大数据时代，企业和研究机构拥有海量的数据。编程可以用于从这些数据中挖掘有价值的信息。例如，电商企业通过分析用户的购买行为数据（包括购买的商品、购买时间、购买频率等），编写数据挖掘程序，利用关联规则挖掘算法（如Apriori算法）发现用户购买商品之间的关联。如发现购买了婴儿奶粉的用户有很大概率会购买婴儿尿布，从而可以进行精准的商品推荐，提高销售额。
- 数据可视化：将数据以直观的方式呈现出来有助于更好地理解数据。通过编程可以使用数据可视化库（如Python中的Matplotlib和Seaborn）将复杂的数据转换为图表（如柱状图、折线图、饼图等）。例如，在金融领域，通过编写程序将股票市场的数据可视化，展示股票价格的走势、成交量等信息，帮助投资者更好地分析市场动态。

编程语言(programming language)，是用来定义计算机程序的形式语言。

它是一种被标准化的交流技巧，用来向计算机发出指令。
一种计算机语言让程序员能够准确地定义计算机所需要使用的数据，并精确地定义在不同情况下所应当采取的行动。

小时候我们跟着父母学说话，通过长时间的熏陶，以及自我学习，我们在不知不觉中学会了说话，也能够理解他人说话的意思；

就好比（以前没钱吃肯德基、现在没钱吃肯德基）这句话我们随着被社会毒打后，也理解其含义。


我们可以通过固定的语法格式，让他人为我们做事：
1. 张三，你去帮我打盆水，给本大爷洗洗脚。

张三可能会帮你去打水，也可能打一盆水，倒在你头上。。。


而计算机，我们也可以通过语言让它为我们做事，并且计算机会对你言听计从，完成你的任务，除非你的”语言“出了问题，让计算机理解错了（写了一堆bug）

因此这就是编程语言，每一种语言都有固定的语法格式，只有学习后才会使用。（英语，法语，汉语，不都是这样么）

bash 
python /golang 高级运维工程师

js
database SQL语言
配置文件，json, yaml,

1.0 什么是编程

一、编程的定义

编程，也称为程序设计，是使用一种特定的编程语言，来编写计算机能够理解和执行的指令序列（程序）的过程。

计算机本身只能理解由0和1组成的二进制代码，而编程语言是一种人类可以理解和编写的工具，通过编译器或解释器将其转换为计算机能够执行的机器语言。

例如，当你想要计算机计算两个数字的和，你可以使用编程语言（如Python）编写这样的指令：

a = 3
b = 5
c = a + b
print(c)

在这个简单的例子中，定义了两个变量a和b，分别赋值为3和5，然后将它们的和赋值给变量c，最后通过print函数将结果打印出来。这个指令序列就是一个小程序，当通过Python解释器运行时，计算机就能按照这些指令计算并输出结果（8）。

二、编程语言的分类

机器语言
- 这是计算机能够直接理解和执行的语言，由0和1组成的二进制代码。它与计算机硬件紧密相关，不同的计算机硬件架构（如英特尔架构和ARM架构）有不同的机器语言。例如，一个简单的机器语言指令可能是“00000001”代表加载数据，“00000010”代表加法运算等。由于机器语言非常难以理解和编写，除了在非常底层的开发（如操作系统内核开发的某些部分）或对硬件进行编程（如嵌入式系统编程的某些情况）外，很少直接使用。
汇编语言
- 汇编语言是一种低级编程语言，它使用助记符来代替机器语言中的二进制指令。例如，在汇编语言中，“MOV”可能代表数据移动指令，“ADD”代表加法指令。虽然它比机器语言更容易理解，但仍然与硬件紧密相关，需要对计算机的硬件结构（如寄存器、内存地址等）有深入的了解。汇编语言常用于对性能要求极高的系统开发，如操作系统内核、驱动程序开发，或者在对硬件资源严格控制的嵌入式系统中使用。
高级编程语言
- 面向过程语言：如C语言，它强调程序的执行流程，通过函数来组织代码。在C语言中，你可以编写一系列的函数来完成特定的任务。例如，下面是一个简单的C语言程序，用于计算两个数的和：
```
#include <stdio.h>
int main() {
  int a = 3;
  int b = 5;
  int c = a + b;
  printf("%d", c);
  return 0;
}
```
- 面向对象语言：如Java、C++和Python（它同时支持面向过程和面向对象编程）。面向对象语言以对象为核心，将数据和操作数据的方法封装在一起。以Java为例，定义一个简单的“Person”类：
```
class Person {
  private String name;
  private int age;
  public Person(String name, int age) {
      this.name = name;
      this.age = age;
  }
  public String getName() {
      return name;
  }
  public int getAge() {
      return age;
  }
}
```
  这个类包含了人的姓名和年龄两个属性，以及获取姓名和年龄的方法。通过创建“Person”对象，可以对人的相关信息进行操作。
- 脚本语言：如JavaScript、Python（也可用于脚本编写）和Ruby。脚本语言通常不需要经过编译过程（有些也可以编译），而是通过解释器直接执行。它们常用于自动化任务、网页开发（JavaScript用于浏览器端脚本）和系统管理等领域。例如，JavaScript可以用于在网页中实现动态效果，如验证用户输入的表单数据、实现网页的交互功能等。

三、编程的基本步骤

问题分析
- 在开始编程之前，需要明确要解决的问题。这包括确定问题的需求、输入和输出。例如，如果要编写一个程序来计算学生的平均成绩，需要明确输入是学生的各科成绩，输出是平均成绩。并且要考虑特殊情况，如成绩的合法性（成绩是否在合理的范围内）等。
设计算法
- 算法是解决问题的步骤和方法。可以用自然语言、流程图或伪代码来描述算法。以计算平均成绩为例，算法可以是：先将各科成绩相加，然后除以科目数量。用伪代码表示如下：
```
输入各科成绩（成绩列表）
计算成绩总和
计算科目数量
平均成绩 = 成绩总和 / 科目数量
输出平均成绩
```

选择编程语言并编码

根据问题的性质和要求选择合适的编程语言。如果是开发一个网站的前端交互部分，可能选择JavaScript；如果是进行系统级的开发，可能选择C或C++。然后按照设计好的算法，使用所选编程语言的语法和规则进行编码。

语言价值，市场薪资价值
语言热度，招聘热度 
C语言，花好久才能完成一点点小功能，成就感很低
学习兴趣，对语言热情很高，不吃饭也得学，一定能学成（挣钱）
不要听别人说啥好啥坏。
字节有C开发大佬，10W
学bash？python？golang，3万？？刺激。
完成任务时效性，老板开发一个功能，java,c去写，1个月？老板直接让你滚蛋。
python,golang,1周完成，nice。。👍

测试和调试
- 编写好的程序需要进行测试，以检查是否能够正确地解决问题。在测试过程中，可能会发现程序中的错误（称为bug）。通过调试工具和技术，如设置断点、查看变量的值等，来定位和修复错误。例如，在计算平均成绩的程序中，如果发现输出的平均成绩总是错误的，可能通过调试来检查成绩总和或科目数量的计算是否正确。
维护和更新
- 程序在使用过程中可能需要根据新的需求或发现的问题进行维护和更新。例如，随着教育改革，成绩的计算方式可能发生变化，或者需要添加新的功能，如同时计算班级的最高和最低成绩等，这就需要对程序进行修改和完善。

编程就是你想让计算机自动帮你做一些事，节省你的时间，提高你的效率；

编程就是你将自己的想法，思路，以某个编程语言特有的语法风格，写出来，产出的就是一堆文本，就像是写了一堆作文。

注：代码文件，在没运行的时候，就是一些普通文本，只有通过特定语言的运行环境，才有了意义。

1.1 编译型语言

程序在执行之前需要一个专门的编译过程，把程序编译成为机器语言文件，运行时不需要重新翻译，直接使用编译的结果就行了。

程序执行效率高，依赖编译器，跨平台性差些。如C、C++。

定义
- 编译型语言是一种编程语言类型。使用编译型语言编写的程序代码，需要通过一个专门的程序（编译器）将其全部翻译成机器语言（计算机能够直接理解和执行的二进制代码）后，才能运行。这个翻译过程是在程序运行之前完成的，就好像是把一本用外语写的书全部翻译成母语，之后阅读翻译好的内容就可以了。
- 例如，C语言和C++语言就是典型的编译型语言。当你编写了一个C语言程序（源文件通常以.c为扩展名）后，需要使用C编译器（如GCC - GNU Compiler Collection）对这个源文件进行编译。编译器会对源文件进行词法分析、语法分析、语义分析等一系列复杂的操作，将其转换为目标机器（例如x86架构的计算机）能够理解的机器语言文件（通常是二进制文件，在Linux下可能是.out扩展名）。
编译过程
- 词法分析：编译器首先会把源程序代码当作一个字符流，将其分解为一个个单词（也称为词法单元）。例如，对于代码“int num = 10;”，编译器会将其分解为“int”（关键字，表示整数类型）、“num”（标识符，变量名）、“=”（赋值运算符）、“10”（常量）和“;”（语句结束符）这些词法单元。这就好比阅读一本书时，先把句子拆分成一个个单词来理解它们的基本含义。
- 语法分析：在词法分析的基础上，编译器会检查这些单词组合成的语句是否符合该语言的语法规则。例如，在C语言中，语句必须按照一定的结构来写，像“if (condition) { statement; }”这样的条件语句结构是固定的。如果写成“if condition { statement; }”（缺少括号）就违反了语法规则，编译器就会报错。语法分析器会构建出一个语法树来表示程序的语法结构，这个语法树就像一棵倒置的树，根节点代表整个程序，子节点代表各个语句和表达式等。
- 语义分析：确定程序在语义上是否正确。这包括检查变量是否在使用前被声明、类型是否匹配等。例如，在C语言中，不能将一个整数变量直接赋值给一个字符变量而不进行类型转换。如果出现这种情况，语义分析阶段就会发现错误。语义分析还会处理一些更复杂的语义问题，比如函数调用的参数是否正确、作用域问题等。
- 代码生成和优化：在经过前面的分析后，编译器会根据目标机器的指令集生成相应的机器语言代码。同时，编译器还会对生成的代码进行优化。例如，它可能会把一些重复计算的表达式简化，或者调整代码的顺序来提高执行效率。例如，如果程序中有一个循环，编译器可能会尝试将一些不随循环变化的计算提到循环外面，以减少计算次数。
优点
- 执行效率高：由于编译型语言的程序在运行前已经被翻译成了机器语言，计算机可以直接执行，不需要像解释型语言那样在运行时逐行翻译和执行。所以，在性能要求较高的场景下，编译型语言表现出色。例如，在开发操作系统、大型游戏引擎或者对实时性要求很高的工业控制系统中，C和C++等编译型语言被广泛使用。以一个3D游戏引擎为例，它需要快速处理大量的图形渲染计算和物理模拟计算。使用编译型语言编写的游戏引擎部分，能够以较高的速度处理这些复杂的计算，从而提供流畅的游戏体验。
- 代码安全性相对较高：编译型语言在编译过程中会进行严格的语法和语义检查，一些明显的错误（如语法错误、类型不匹配等）能够在编译阶段被发现并纠正。而且，编译后的二进制文件通常难以被直接修改（与文本形式的源程序相比），这在一定程度上提高了代码的安全性。例如，在开发金融软件时，编译型语言可以确保程序的稳定性和安全性，减少因为代码被恶意篡改而带来的风险。
缺点
- 开发周期可能较长：因为需要经过编译过程，而且编译过程如果出现错误（尤其是语法和语义错误），需要回到源程序进行修改，然后重新编译。这个反复编译 - 修改的过程可能会比较耗时。特别是对于大型项目，编译时间可能会很长。例如，一个大型的C++项目，可能包含数千个源文件，每次修改一个小部分后，重新编译整个项目可能需要花费几分钟甚至几十分钟。
- 跨平台性相对复杂：编译型语言生成的机器语言代码是与特定的机器架构和操作系统相关的。要想在不同的平台（如从Windows平台移植到Linux平台，或者从x86架构移植到ARM架构）上运行，通常需要重新编译代码，并且可能需要针对不同的平台进行一些代码调整。例如，在不同的操作系统中，系统调用（如文件操作、进程管理等）的方式和接口可能不同，这就需要在移植程序时对这些部分进行修改。

演示go语言，进行代码编译，运行

1.安装golang编译器
[root@web-8 ~]#yum install epel-release golang -y

2.编写golang代码
[root@web-8 /hello-linux]#cat hello-world.go 
package main

import "fmt"

func main() {
    fmt.Println("于超老师带你学Linux~~~www.yuchaoit.cn")
}


[root@web-8 /hello-linux]#


3.编译代码，生成二进制命令

[root@web-8 /hello-linux]#go build hello-world.go 
[root@web-8 /hello-linux]#ll
total 1732
-rwxr-xr-x 1 root root 1766214 May 25 16:57 hello-world
-rw-r--r-- 1 root root     110 May 25 16:57 hello-world.go
[root@web-8 /hello-linux]#file hello-world.go 
hello-world.go: C source, UTF-8 Unicode text
[root@web-8 /hello-linux]#
[root@web-8 /hello-linux]#file hello-world
hello-world: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped


4. 运行代码
[root@web-8 /hello-linux]#./hello-world 
于超老师带你学Linux~~~www.yuchaoit.cn



5. [可选] 加入到PATH变量中
[root@web-8 /hello-linux]#mv hello-world /usr/local/bin/
[root@web-8 /hello-linux]#
[root@web-8 /hello-linux]#
[root@web-8 /hello-linux]#hello-world 
于超老师带你学Linux~~~www.yuchaoit.cn

1.2 图解编译代码

1.3 解释型语言

程序不需要编译，程序在运行时由解释器翻译成机器语言，每执行一次都要翻译一次。

因此效率比较低，这个效率是针对cpu而言的，你们普通的人类就别琢磨语言的性能了；

每一个语言都很强大。

定义
- 解释型语言是一种编程语言类型。它的程序代码不需要像编译型语言那样预先编译成机器语言，而是在运行时由解释器逐行翻译并执行。
- 这就好比有一个翻译官，在你阅读用外语写的句子时，他逐句为你翻译，让你能够理解句子的意思并做出相应的动作。
- 例如，Python和JavaScript就是典型的解释型语言。以Python为例，当你运行一个Python脚本（.py文件）时，Python解释器会读取脚本文件中的代码，从第一行开始逐行进行分析、翻译并执行。如果代码中有错误，解释器会在执行到错误行时停止，并显示相应的错误信息。
执行过程
- 解释器会首先对程序代码进行词法分析和语法分析，就像编译型语言的编译器一样。它会把代码分解为一个个单词（词法单元），并检查这些单词组成的语句是否符合语言的语法规则。例如，在Python中，对于代码“a = 10 + 'abc'”，解释器在词法分析阶段会识别出“a”是一个变量名，“=”是赋值运算符，“10”是一个整数，“+”是加法运算符，“'abc'”是一个字符串。在语法分析阶段，它会发现将一个整数和一个字符串相加是不符合Python语法规则的，于是会报错。
- 与编译型语言不同的是，解释型语言在完成语法分析后，不会生成机器语言文件。而是直接根据语法分析的结果，逐行将代码翻译成中间代码（有些解释型语言有这个过程）或者直接执行相应的操作。以JavaScript在浏览器中的执行过程为例，当浏览器加载包含JavaScript代码的网页时，JavaScript解释器（通常是浏览器内置的）会读取代码，对于每一行可执行的代码（如变量赋值、函数调用等），它会将其转换为浏览器能够理解的操作，如操作DOM（文档对象模型）来更新网页内容、发送网络请求等。
优点
- 开发效率高：由于不需要编译过程，开发人员可以快速地编写和测试代码。在编写代码时，能够立即看到代码的执行结果，方便快速调试和修改。例如，在使用Python进行数据分析时，数据科学家可以快速地编写脚本，尝试不同的数据处理方法。如果发现某一行代码的结果不符合预期，他们可以立即修改这行代码，然后重新运行脚本，而不需要像编译型语言那样等待编译完成。这种快速的开发 - 测试循环使得解释型语言在一些快速迭代的项目中非常受欢迎，如Web开发中的一些小型脚本、数据分析的探索性阶段等。
- 跨平台性好：解释型语言的代码本身不依赖于特定的机器语言，只要有相应的解释器，就可以在不同的平台上运行。例如，Python代码可以在Windows、Linux、Mac等多种操作系统上运行，只要在这些系统上安装了Python解释器即可。这使得解释型语言在开发跨平台应用时具有很大的优势。例如，一个用JavaScript编写的网页应用，只要浏览器支持JavaScript解释器（几乎所有现代浏览器都支持），就可以在各种设备（如桌面电脑、平板电脑、智能手机）上正常运行。
缺点
- 执行效率相对较低：因为解释型语言是逐行翻译和执行的，每次执行代码都需要进行翻译操作，所以在性能方面通常不如编译型语言。在处理大规模数据或者对性能要求极高的场景下，可能会出现运行速度慢的问题。例如，在一个需要处理大量图形数据的3D游戏中，如果使用解释型语言来处理核心的图形渲染算法，可能会因为翻译和执行的延迟导致游戏画面卡顿。不过，随着计算机硬件性能的不断提升和解释器优化技术的发展，这个差距在某些情况下正在逐渐缩小。
- 代码安全性较低（相对）：解释型语言的代码通常以文本形式存在，并且在运行时动态翻译和执行。这使得代码更容易被查看和修改。如果代码在一个不安全的环境中运行（如在用户可以随意访问代码的服务器上），就有可能被恶意篡改。而且，由于解释型语言的灵活性，一些潜在的安全漏洞（如代码注入攻击）可能更容易出现。例如，在一个Web应用中，如果没有对用户输入的JavaScript代码进行严格的过滤，就有可能被攻击者注入恶意脚本，从而导致安全问题。

比如Python/JavaScript/ Perl /ruby/Shell等都是解释型语言。

python脚本

# 安装python3解释器，编写代码，运行代码
[root@web-8 /hello-linux]#yum install python3 python3-devel -y

[root@web-8 /hello-linux]#cat hello-python.py 
print("www.yuchaoit.cn 于超老师带你学linux")


解释运行
[root@web-8 /hello-linux]#python3 hello-python.py 
www.yuchaoit.cn 于超老师带你学linux

bash脚本

[root@web-8 /hello-linux]#cat hello-bash.sh 
echo "于超老师带你学linux ~~~  www.yuchaoit.cn"
[root@web-8 /hello-linux]#
[root@web-8 /hello-linux]#bash hello-bash.sh 
于超老师带你学linux ~~~  www.yuchaoit.cn

1.4 编译、解释语言区别

编译型

二进制执行速度快
依赖平台架构
保护源代码
底层工具开发，操作系统，超大型应用，高并发型应用，都是编译型语言开发。

解释型

跨平台性能好
执行过程较慢（相对计算机而言，其实人类感受不到的。。）而且你块那几秒对你有啥用？
源码暴露在外，不安全
适合开发各种脚本，完成自动化工作
对速度要求不是太高的应用开发，如网站开发。
执行方式
- 编译型语言：
  - 编译型语言在执行之前，需要通过编译器将全部源代码一次性翻译为目标机器（如特定的CPU架构和操作系统）能够理解的机器语言。这个过程是在程序运行之前独立完成的，就像把一本外语书全部翻译成本地语言后再阅读。例如，用C++编写的程序，使用编译器（如GCC）将其源文件（.cpp）编译成二进制文件（.exe或其他可执行格式）后，计算机就可以直接运行这个二进制文件，而不需要再去处理原始的源代码。
- 解释型语言：
  - 解释型语言的代码是在运行时逐行翻译并执行的。解释器就像一个实时翻译官，在程序运行过程中，逐行读取源代码，将其翻译为机器可以执行的指令并立即执行。例如，Python程序在运行时，Python解释器会从代码的第一行开始，边翻译边执行。如果代码很长，解释器会持续这个过程，直到程序结束或者遇到错误。
执行效率
- 编译型语言：
  - 通常具有较高的执行效率。因为在编译过程中，编译器可以对代码进行深度优化，例如调整代码的执行顺序、减少冗余计算、合理分配内存等。而且编译后的机器语言可以直接被计算机的CPU执行，不需要额外的翻译步骤。在对性能要求较高的场景，如操作系统开发、大型游戏制作、高性能计算等领域，编译型语言（如C、C++）是首选。例如，游戏引擎的核心渲染部分使用C++编写并编译，能够高效地处理大量图形数据，提供流畅的游戏画面。
- 解释型语言：
  - 执行效率相对较低。由于解释型语言是逐行翻译和执行，每次执行代码都要进行翻译操作，这会带来一定的性能开销。特别是在处理大量数据或者复杂算法时，这种开销可能会导致程序运行速度明显变慢。不过，对于一些对性能要求不是极高的场景，如简单的脚本任务、网页交互（JavaScript）、快速的数据处理探索（Python）等，解释型语言的效率是可以接受的。而且，随着硬件性能的提升和解释器优化技术的发展，这种效率差距在某些情况下正在缩小。
开发效率
- 编译型语言：
  - 开发周期可能相对较长。因为编译型语言在开发过程中，如果代码出现语法或语义错误，需要重新回到源代码进行修改，然后再次编译整个程序。对于大型项目，编译过程可能会很复杂且耗时。例如，一个包含众多源文件的C++项目，每次修改一点代码后可能需要重新编译整个项目，这个过程可能需要花费几分钟甚至更长时间。
- 解释型语言：
  - 开发效率通常较高。由于不需要编译步骤，程序员可以快速地编写和测试代码。在编写代码时，能够立即看到代码的执行结果，方便对代码进行调试和修改。例如，在Python开发环境中，修改一行代码后可以马上运行程序来查看效果。这种快速的开发 - 测试循环使得解释型语言在快速迭代的项目中很受欢迎，如Web开发中的小型脚本、数据分析的初步探索阶段等。
跨平台性
- 编译型语言：
  - 跨平台相对复杂。因为编译型语言生成的机器语言代码是与特定的机器架构和操作系统相关的。要在不同的平台上运行，通常需要重新编译代码，并且可能需要针对不同平台的特性（如系统调用、内存管理等）进行代码调整。例如，一个C语言程序在Windows平台编译成的可执行文件，不能直接在Linux平台运行，需要重新在Linux平台编译，并且可能要修改一些与平台相关的代码部分，如文件路径表示方法等。
- 解释型语言：
  - 跨平台性较好。只要目标平台上有相应的解释器，解释型语言的代码就可以运行。代码本身不依赖于特定的机器语言，它的跨平台性主要依赖于解释器的兼容性。例如，Python代码只要在Windows、Linux和Mac等平台上安装了Python解释器，就可以正常运行，而且代码基本不需要做太多修改。
代码安全性
- 编译型语言：
  - 代码安全性相对较高。编译过程中会进行严格的语法和语义检查，能够发现并纠正一些明显的错误。编译后的二进制文件通常难以被直接修改（相比于文本形式的源代码）。例如，在金融系统等对安全性要求较高的软件中，使用编译型语言可以在一定程度上减少代码被篡改的风险。不过，这并不意味着编译型语言就绝对安全，仍然可能存在安全漏洞，如缓冲区溢出等。
- 解释型语言：
  - 代码安全性相对较低。解释型语言的代码通常以文本形式存在，并且在运行时动态翻译和执行，这使得代码更容易被查看和修改。而且，由于其灵活性，一些潜在的安全漏洞（如代码注入攻击）可能更容易出现。例如，在Web应用中，如果没有对用户输入的JavaScript代码进行严格的过滤，就可能会被注入恶意脚本，导致安全问题。

2.什么是shell

在Linux早起，还没有出现图形化，超哥和其他系统管理员都只能坐在电脑前，输入shell命令，查看控制台的文本输出。

在大多数Linux发行版里，例如centos，可以简单的用组合键来访问Linux控制台，也就是ctrl+F1~F7。

现在更多的使用xshell这样的控制终端，来连接管理我们的Linux机器。

以centos为例，默认的shell都是GNU bash shell，支持一些特性，例如

man手册
tab补全
shell指令
定义
- Shell（壳）是一种用户与操作系统内核之间的接口程序。它接收用户输入的命令，并将这些命令传递给操作系统内核去执行，然后把内核执行的结果返回给用户。可以把Shell想象成一个翻译官，它在用户和操作系统内核这两个“角色”之间进行沟通，让用户能够通过输入各种命令来控制系统的操作。
- 例如，在Linux系统中，当用户在终端输入“ls -l”命令时，Shell会接收这个命令，分析它的语法和语义，然后将其传递给操作系统内核。内核会执行相应的文件系统操作，获取当前目录下文件的详细信息，再将这些信息返回给Shell，最后Shell将结果显示在终端上，用户就可以看到文件的详细列表了。
功能特点 bash
- 命令执行：这是Shell最基本的功能。用户可以通过Shell输入各种系统命令来完成不同的任务，如文件管理（创建、删除、移动、复制文件和目录）、进程管理（启动、停止、查看进程）、系统设置（修改系统参数、安装软件等）。例如，在Unix系统中，“cp file1 file2”命令可以通过Shell执行，用于将“file1”文件复制为“file2”。
- 脚本编程：Shell支持脚本编程。用户可以将一系列的命令组合成一个脚本文件，通过Shell来执行这个脚本，从而实现自动化的任务流程。例如，编写一个备份文件的脚本，其中包含创建备份目录、复制文件到备份目录等一系列命令，每次需要备份文件时，只需运行这个脚本即可，而不用手动逐个输入命令。
- 环境变量设置：Shell可以设置和管理环境变量。环境变量是存储在系统中的一些变量，它们包含了系统和用户相关的各种信息，如路径（PATH变量，用于指定系统在哪些目录中查找可执行文件）、当前用户（USER变量）、当前语言环境（LANG变量）等。通过修改环境变量，用户可以改变系统的一些行为。例如，将一个新的软件安装目录添加到PATH变量中，这样就可以在任何目录下直接执行该软件的可执行文件。
- 输入输出重定向和管道操作：Shell提供了强大的输入输出重定向和管道功能。输入输出重定向可以改变命令的输入来源和输出去向。例如，“>”符号可以将一个命令的输出重定向到一个文件中，如“ls -l > filelist.txt”会将当前目录下文件的详细列表输出到“filelist.txt”文件中。管道操作（“|”）可以将一个命令的输出作为另一个命令的输入，用于组合多个命令来完成更复杂的任务。例如，“ps -ef | grep httpd”可以先获取系统中所有进程的信息（通过“ps -ef”），然后筛选出包含“httpd”关键字的进程信息（通过“grep httpd”）。
常见的Shell类型
- Bash（Bourne - Again Shell）：这是目前大多数Linux系统默认的Shell。它是对原始Bourne Shell（sh）的增强版本，具有丰富的功能，如命令补全、历史命令记录、作业控制等。它的语法灵活，支持变量定义、条件判断、循环结构等编程特性，适用于各种复杂的脚本编写。例如，在Bash中，用户可以使用“$(command)”语法来获取一个命令的输出并作为变量的值，这在脚本编程中非常有用。
- sh（Bourne Shell）：这是Unix系统中最早出现的Shell之一。它的语法比较简洁，许多Shell脚本的基本语法都源于sh。虽然现在Bash更为常用，但sh仍然在一些简单的脚本或者需要考虑兼容性的场景下使用。例如，一些早期的Unix脚本可能是基于sh编写的，在维护这些脚本时，可能需要使用sh来确保正确执行。
- csh（C - Shell）：它的语法类似于C语言，对熟悉C语言的用户比较友好。它提供了一些特色功能，如命令别名、作业控制等，但在脚本编程方面，Bash更为流行，不过csh在一些特定的学术和科研环境中仍然有使用。例如，在一些科学计算软件的交互环境中，用户可能更习惯使用csh的语法风格。
- ksh（Korn Shell）：它结合了Bourne Shell和C - Shell的一些优点，具有强大的编程功能，如高级的变量处理、更好的数学运算支持等。它在一些企业级的Unix系统中使用。例如，在一些大型企业的服务器管理中，ksh可能用于编写复杂的系统管理脚本。

GNU bash shell是在系统普通用户登陆时，作为普通程序运行，这个规则是/etc/passwd中指定的条目

[pyyu01@web-8 ~]$grep 'pyyu01' /etc/passwd
pyyu01:x:1003:1003::/home/pyyu01:/bin/bash

bash会在用户登录时候自动启动，如果是虚拟控制台终端登录，`命令行界面（英語：Command-Line Interface，缩写：CLI）提示符会自动出现，此时可以输入shell命令。

或者是通过图形化桌面登录Linux系统，你就需要启动GNOME这样的图形化终端仿真器来访问shell CLI。

2.1 shell作用

命令解释与执行
- 用户操作接口：Shell为用户提供了一个直接与操作系统交互的命令行界面。用户可以通过在Shell中输入命令来让操作系统执行各种任务。例如，在Linux系统中，用户想要查看当前目录下的文件列表，就可以在Shell（如Bash）中输入“ls”命令。Shell会将这个命令传递给操作系统内核，内核执行相应的文件系统操作，然后将文件列表信息返回给Shell，最终显示在终端上。
- 支持多种命令类型：它可以执行系统自带的命令，包括文件和目录操作命令（如“cp”用于复制文件、“mkdir”用于创建目录）、进程管理命令（如“ps”用于查看进程、“kill”用于终止进程）、网络相关命令（如“ping”用于测试网络连接、“ifconfig”用于查看和配置网络接口）等。同时，还可以执行用户自定义的脚本和可执行程序。比如，用户编写了一个名为“my_script.sh”的Shell脚本，通过在Shell中输入“./my_script.sh”就可以执行这个脚本。
系统管理与自动化
- 批量任务处理：系统管理员可以利用Shell编写脚本，将多个命令组合在一起，实现自动化的系统管理任务。例如，在一个服务器集群中，需要定期备份重要的数据文件。管理员可以编写一个Shell脚本，其中包含连接到各个服务器、打包指定的数据文件、将备份文件传输到备份存储设备等一系列命令。然后通过设置定时任务（如在Linux中使用cron），让这个脚本在指定的时间自动运行，大大提高了工作效率。
- 软件安装与配置管理：在安装和配置软件时，Shell也发挥着重要作用。许多软件的安装过程可以通过在Shell中运行安装脚本或者一系列命令来完成。例如，在Linux系统中安装“Apache”服务器软件，可能需要在Shell中输入一系列的配置和安装命令，如“sudo apt - get install apache2”（在基于Debian的系统中）。而且，在软件安装后，还可以通过Shell脚本对软件的配置文件进行修改和管理，以满足不同的需求。
- 系统监控与维护：Shell可以用于监控系统的状态，如CPU使用率、内存使用情况、磁盘空间等。通过编写Shell脚本，结合系统提供的命令（如“top”用于查看系统资源使用情况、“df”用于查看磁盘空间），可以实时收集这些信息，并在系统出现异常情况（如磁盘空间不足、CPU长时间高负载）时采取相应的措施，如发送警报邮件给管理员。
文本处理与数据过滤
- 文本处理工具集成：Shell集成了许多强大的文本处理工具，如“grep”、“sed”和“awk”。“grep”用于在文本文件或命令输出中查找包含特定模式的行。例如，在一个大型的系统日志文件中，使用“grep 'error' logfile.txt”可以快速找到包含“error”字样的行，帮助管理员定位系统故障。“sed”主要用于对文本进行编辑操作，如替换文本中的某些字符或字符串。例如，“sed's/old_text/new_text/g' file.txt”可以将“file.txt”文件中的所有“old_text”替换为“new_text”。“awk”则用于对文本进行更复杂的处理，如提取特定列的数据。例如，从一个以空格分隔的文件中提取第二列的数据，可以使用“awk '{print $2}' file.txt”。
- 数据过滤与转换：可以利用Shell的管道（“|”）和重定向（“>”和“<”）功能，对数据进行过滤和转换。例如，通过管道将一个命令的输出作为另一个命令的输入，“ps -ef | grep httpd”可以获取所有进程信息，并从中筛选出与“httpd”相关的进程信息。通过重定向，可以将命令的输出保存到文件中，或者从文件中读取数据作为命令的输入，方便数据的进一步处理和分析。
环境变量管理
- 环境变量设置：Shell可以用于设置和修改环境变量。环境变量是存储在系统中的一些变量，它们包含了系统和用户相关的各种信息，如路径（PATH变量，用于指定系统在哪些目录中查找可执行文件）、当前用户（USER变量）、当前语言环境（LANG变量）等。例如，用户可以通过在Shell中输入“export PATH = $PATH:/new/directory”来将一个新的目录添加到可执行文件的搜索路径中，这样在这个目录下的可执行文件就可以在命令行中直接运行了。
- 环境变量传递与继承：当启动一个新的进程或执行一个脚本时，Shell会将当前的环境变量传递给新的进程或脚本。这使得不同的程序可以共享系统的环境信息，并且可以根据环境变量的值来调整自己的行为。例如，一个Java程序可能会根据“JAVA_HOME”环境变量来确定Java运行时环境的安装位置，从而正确地启动和运行。

shell的作用是

解释执行用户输入的命令或程序等
用户输入一条命令，shell就解释一条
键盘输入命令，Linux给与响应的方式，称之为交互式

shell是一块包裹着系统核心的壳，处于操作系统的最外层，与用户直接对话，把用户的输入，解释给操作系统，然后处理操作系统的输出结果，输出到屏幕给与用户看到结果。

从我们登录Linux，输入账号密码到进入Linux交互式界面，所有的操作，都是交给shell解释并执行

我们想要获取计算机的数据，不可能每次都编写程序，编译后，再运行，再得到我们想要的，例如你想找到一个文件，可以先写一段C语言的代码，然后调用系统函数，通过gcc编译后，运行程序才能找到文件。。。

因此有大牛开发出了shell解释器，能够让我们方便的使用Linux，例如只要敲下ls -lh这样的字符串，shell解释器就会针对这句话翻译，解释成ls -l -h 然后执行，通过终端输出结果，无论是图形化或是命令行界面。

即使我们用的图形化，点点点的动作，区别也只是

命令行操作，shell解释执行后，输出结果到黑屏命令行界面
图形化操作，shell接受点击动作，输出图案数据

文本源代码 > 解释器 > 机器码

就好比如下的过程

2.2 shell和运维

系统部署与初始化
- 操作系统安装自动化：在大规模服务器部署场景中，运维人员可以利用Shell脚本自动化操作系统的安装过程。通过预先编写包含分区、格式化、软件包选择等安装步骤的脚本，结合自动化安装工具（如PXE网络安装），可以同时在多台服务器上快速完成操作系统的安装，节省大量时间和人力。例如，在数据中心构建新的服务器集群时，使用Shell脚本可以确保每台服务器都按照相同的标准配置进行操作系统安装。
- 软件安装与配置：Shell对于软件的安装和配置管理至关重要。运维人员可以使用Shell命令来安装各种软件包。在Linux系统中，像“yum install”（基于RPM的系统）或“apt - get install”（基于Debian的系统）等命令可以通过Shell执行，用于安装服务器软件（如Web服务器、数据库服务器等）。而且，在软件安装后，通过Shell脚本可以对软件的配置文件进行批量修改，确保软件在不同服务器上具有一致的配置。例如，对于Apache服务器，运维人员可以编写Shell脚本修改“httpd.conf”配置文件，设置虚拟主机、端口等参数。
系统监控与故障排查
- 资源监控脚本：运维人员可以编写Shell脚本，结合系统命令（如“top”、“vmstat”、“df”等）来监控服务器的资源使用情况。例如，编写一个脚本定期检查CPU使用率、内存使用率和磁盘空间，当资源使用率超过一定阈值时，通过邮件或其他通知方式（如短信网关）提醒运维人员。这样可以及时发现服务器性能问题，如内存泄漏、磁盘空间不足等。
- 故障排查工具：Shell提供了丰富的工具用于故障排查。当服务器出现故障时，运维人员可以使用“grep”在日志文件中查找特定的错误信息，使用“netstat”检查网络连接状态，使用“ps -ef”查看进程状态等。例如，如果Web服务器出现故障，运维人员可以通过在Shell中运行“grep 'error' /var/log/httpd/error.log”来查找日志中的错误信息，从而快速定位故障原因，如配置错误、模块加载失败等。
系统维护与更新
- 系统更新自动化：定期更新操作系统和软件包是保持系统安全和稳定的重要措施。运维人员可以使用Shell脚本自动化更新过程。在Linux系统中，可以编写脚本通过“yum - y update”（基于RPM的系统）或“apt - get update && apt - get upgrade”（基于Debian的系统）来自动更新系统软件包。同时，还可以在脚本中加入备份重要数据、检查更新是否成功等步骤，以确保更新过程的安全性和可靠性。
- 日志管理与清理：服务器会产生大量的日志文件，这些文件如果不及时清理，可能会占用大量磁盘空间。运维人员可以使用Shell编写日志管理脚本，定期清理过期的日志文件，或者对日志文件进行压缩备份。例如，使用“find”命令结合Shell脚本找到超过一定时间的日志文件，然后使用“rm”命令删除或“tar”命令进行压缩备份。
自动化运维流程与任务调度
- 任务调度：在Linux系统中，“cron”是一个常用的任务调度工具，它可以通过Shell脚本实现自动化的任务调度。运维人员可以将需要定期执行的任务（如备份、系统检查、数据同步等）编写成Shell脚本，然后通过“cron”设置任务的执行时间和频率。例如，设置一个每天凌晨2点执行数据备份的任务，通过在“cron”表中添加相应的Shell脚本执行命令即可。
- 自动化运维流程：通过将多个Shell脚本组合在一起，运维人员可以构建复杂的自动化运维流程。例如，从服务器性能监控、故障发现、自动修复（在一定程度上）到通知运维人员的完整流程都可以通过Shell脚本实现。这样可以提高运维效率，减少人为错误，尤其是在处理大量服务器和复杂系统时，自动化运维流程能够发挥巨大的作用。

shell脚本语言很适合处理纯文本类型数据，且Linux的哲学思想就是一切皆文件，如日志、配置文件、文本、网页文件，大多数都是纯文本类型的，因此shell可以方便的进行文本处理，好比强大的Linux三剑客（grep、sed、awk）

shell脚本就是把一堆linux命令和数据文件，配置文件，静态资源，mysql操作，的集合，放在一起去执行；
shell脚本可以包括N个变量、循环、条件判断、函数等；

特定的格式 + 特定的语法 + 系统命令 + 文件数据 = 脚本

shell可以解决运维什么问题？

1.系统初始化脚本，如ssh配置、yum源、防火墙、ntp、基础软件安装，这一系列的步骤，写成脚本。

2. 定时备份数据，shell脚本 + crontab，每天夜里12点备份数据库。

3. nginx日志切割脚本。

4. 服务管理脚本，如nginx，mysql启停脚本。

5. 如代码上线脚本，将开发写好的代码，发布交给nginx。

6. 如自己开发一个跳板机脚本等。

简单说就是你的运维工作日常，可以用脚本完成自动化，提升效率，节省时间，多点时间和妹子聊天不香吗。

3.学习shell必备的工具

1. 熟练的vim
2. 熟练掌握linux命令
3. 熟练掌握正则，三剑客

4.学习shell的正确姿势

1. 知道自己要做什么，你准备给三台机器部署好nginx？
2. 拿到需要别立即去写shell脚本，先把命令写好，然后转化为脚本。部署流程，需要的命令
3. 先看懂老师的脚本，然后模仿，模仿久了，你就会自己写了。

总之
多思考
多练习
多总结

5.如何学好shell编程

如何学好shell脚本编程？

1.充分利用好课上时间，一定要主动思考，别等答案
2.充分理解知识点的语法，概念
3.先模仿老师的脚本开发，看懂语法
4.消化吸收老师的脚本思路后，自己模仿，改造
5.有思路后，按照自己的意愿，开发脚本

6. 送给小白的话

无论你以后学shell，还是python，学编程语言的套路都是一样的；

你学过英语吧？
1. 学单词-------shell的关键字
2. 学语法规则--------shell的语法要求
3. 写作文--------用shell写的脚本文件

到这你估计有点眉目了，但是为什么还有的人觉得学shell很难呢？

1.在于超老师带python、linux的学员时，总会发现有同学学不会，或者说代码写不出来，他也会问我，说超哥，，为什么上课我听着那么明白，自己写，感觉就呆住了，不知道咋开始啊。

2. 于超老师：“这不废话么？人家在那敲代码，一个需求用三种shell脚本思路实现，你天天搁那玩游戏，看电视剧，能学明白还有天理吗？”

3. 我就说你当初学英语，学汉语吧！你不会去琢磨，用哪个字，还是哪个说法，才能表达出你的意思。

你是随口就叭叭叭说了一堆优雅的中国话，对把？
为什么你代码写不出来，因为你没有烂熟于心。。。。你写代码，发现，关键字没记住，语法是啥来着？以及我到底怎么表达才是合适的！也就是你的代码逻辑如何写，你是不熟练的！
这就跟你去思考，我是用胳膊走路，还是腿走路，这不还是因为你路走少了么。

所以，狠下心来，你没有狠下心，早上5点到夜里3点的学代码，写代码，重点是写代码。

不断的写，就像当年郭靖学降龙十八掌，洪七公让他对着树打两巴掌，这傻大个打了1000掌，为啥？说难听点，大家都是屌丝，你要没有郭靖这意志力，就别想着咸鱼翻身，做武林顶级高手了。


结尾，于超老师送给你，也送给自己一句话，学无止境，成功没有捷径，想爬得更高，没有上万行代码的洗礼，没有一千个日夜的拼命学习，想翻身？不存在的。

第二章：shell光速入门

1.shell书写规则

1. shell脚本要做到见名知意，正式的脚本，别瞎写a.sh  b.sh 容易被打。。

2. 虽然脚本是文本类型，但是建议以.sh结尾。vim也能提供颜色支持。

3. 给脚本加上注释（英文最好，中文写在你的笔记里），包括了脚本的创建时间，作者，作用等信息；

4. 创建好可以管理你脚本的目录。

5. 创建统一管理脚本的目录，别乱放，回头找不到。

脚本示例

#!/bin/bash     #! 这个符号在计算机中读作shebang，表示指定用什么解释器运行脚本
# Author: www.yuchaoit.cn  877348180@qq.com
# Create Time:  2025/01/17
# Script Description: this is my first shell script.

2.vim插件模板

打开vim配置文件

vim ~/.vimrc

代码

syntax on
set nocompatible
"set number
"filetype on
"set history=1000
"set background=dark
""set autoindent
"set smartindent
"set tabstop=4
"set shiftwidth=4
"set showmatch
"set guioptions-=T
"set ruler
"set nohls
"set incsearch
""set fileencodings=utf-8

if &term=="xterm"
    set t_Co=8
    set t_Sb=^[[4%dm
    set t_Sf=^[[3%dm
endif

function AddFileInformation_php()
      let infor = "<?php\n"
      \." ***************************************************************************\n"
      \." * \n"
      \." * Copyright (c) 2014 \n"
      \." *  \n"
      \." **************************************************************************/ \n"
      \." \n"
      \." \n"
      \." \n"
      \."/** \n"
      \." * @file:".expand("%")." \n"
      \." * @author your name(www.yuchaoit.cn) \n"
      \." * @date ".strftime("%Y-%m-%d %H:%M")." \n"
      \." * @version 1.0  \n"
      \." **/ \n"
      \." \n"
      \." \n"
      \." \n"
      \." \n"
      \." \n"
      \." \n"
      \."?>"
      silent  put! =infor
endfunction
autocmd BufNewFile *.php call AddFileInformation_php()

function AddFileInformation_sh()
      let infor = "#!/bin/bash\n"
      \."\n"
      \."# ***************************************************************************\n"
      \."# * \n"
      \."# * @file:".expand("%")." \n"
      \."# * @author:www.yuchaoit.cn \n"
      \."# * @date:".strftime("%Y-%m-%d %H:%M")." \n"
      \."# * @version 1.0  \n"
      \."# * @description: Shell script \n"
      \."# * @Copyright (c)  all right reserved \n"
      \."#* \n"
      \."#**************************************************************************/ \n"
      \."\n"
      \."\n"
      \."\n"
      \."\n"
      \."exit 0"
      silent  put! =infor
endfunction
autocmd BufNewFile *.sh call AddFileInformation_sh()

function AddFileInformation_py()
      let infor = "#!/usr/bin/env python\n"
      \."# -*- coding: utf-8 -*-\n"
      \."# ************************************************************************ \n"
      \."# * \n"
      \."# * @file:".expand("%")." \n"
      \."# * @author:www.yuchaoit.cn \n"
      \."# * @date:".strftime("%Y-%m-%d %H:%M")." \n"
      \."# * @version 1.0  \n"
      \."# * @description: Python Script \n"
      \."# * @Copyright (c)  all right reserved \n"
      \."# * \n"
      \."#************************************************************************* \n"
      \."\n"
      \."import os,sys"
      \."\n"
      \."print u'''中文'''\n"
      \."\n"
      \."exit()"
      silent  put! =infor
endfunction
autocmd BufNewFile *.py call AddFileInformation_py()

这个插件，可以自动识别php、python、sh后缀的脚本，提供vim插件。

2.1 测试插件，编写shell

3.第一个shell脚本

[root@web-8 /all-sh]#cat first.sh 
#!/bin/bash

# ***************************************************************************
# * 
# * @file:first.sh 
# * @author:www.yuchaoit.cn 
# * @date:2022-05-25 19:50 
# * @version 1.0  
# * @description: Shell script 
# * @Copyright (c)  all right reserved 
#* 
#**************************************************************************/ 

echo "welcome my linux course. www.yuchaoit.cn"


exit 0



执行脚本
[root@web-8 /all-sh]#bash first.sh 
welcome my linux course. www.yuchaoit.cn

4.执行shell方式

4.1 执行命令不同

[root@yuchao-tx-server ~/p3-shell]#echo 'echo www.yuchaoit.cn' > t1.sh
[root@yuchao-tx-server ~/p3-shell]#
[root@yuchao-tx-server ~/p3-shell]#
[root@yuchao-tx-server ~/p3-shell]#chmod u+x t1.sh
[root@yuchao-tx-server ~/p3-shell]#
[root@yuchao-tx-server ~/p3-shell]#./t1.sh
www.yuchaoit.cn
[root@yuchao-tx-server ~/p3-shell]#bash t1.sh
www.yuchaoit.cn
[root@yuchao-tx-server ~/p3-shell]#source t1.sh
www.yuchaoit.cn

# 当用.执行，和source执行，和用bash执行的区别是什么？
# 如果./t1.sh 这种执行，会调用bash解释器，开辟子shell去执行，会读取 #!/bin/bash
# 包括 bash t1.sh   和 sh t1.sh 都一样！

# 特殊，当用  . 或者source命令执行时，不会单独开辟子shell，是在当前bash下执行！

Shebang（读作 "she-bang"）

最常见的名称，来源于 “sharp”（#）和 “bang”（!）的组合。
用于表示脚本文件的解释器路径。

在Shell脚本编程中，常见的执行方式有直接执行脚本文件、使用 sh 或 bash 命令执行、在当前 shell 环境中使用点号（.）或 source 命令执行。以下是它们的详细区别总结：

执行方式	命令格式	运行环境	脚本权限要求	变量作用域	用途场景	示例
直接执行脚本文件	`./script.sh` 需先 `chmod +x script.sh`	在一个新的子 shell 进程中执行	需要可执行权限	脚本内定义的变量仅在子 shell 内有效，不影响外部环境	独立的脚本执行，适用于大多数常规脚本任务	假设脚本 `test.sh` 内容为 `#!/bin/bash <br> echo "Hello from script" <br> var=10 <br> echo "Variable value: $var"`，先`chmod +x test.sh`，然后`./test.sh`执行
使用`sh`或`bash`命令执行	`sh script.sh` `bash script.sh`	在新的子 shell 进程中执行，`sh`可能会以POSIX兼容模式运行，`bash`以Bash特性运行	不需要脚本有可执行权限	脚本内定义的变量仅在子 shell 内有效，不影响外部环境	调试脚本，或在不同的 shell 环境（如POSIX兼容的`sh`）中运行脚本	`bash test.sh`，即使`test.sh`没有可执行权限也能运行
使用点号（`.`）或`source`命令执行	`. script.sh` `source script.sh`	在当前 shell 环境中执行	不需要脚本有可执行权限	脚本内定义或修改的变量,会影响当前 shell 环境	用于加载配置文件，使配置立即生效；或在当前环境中执行函数定义脚本，以便后续调用函数	假设`config.sh`脚本内容为`export PATH=$PATH:/new/path <br> export SOME_VAR=value`，执行`. config.sh`后，`PATH`和`SOME_VAR`变量会在当前 shell 环境生效

这些执行方式各有特点，根据具体的需求和场景选择合适的执行方式，有助于更有效地管理和运行 Shell 脚本。

4.2 首行是否指定解释器shebang

1.不指定 #!/usr/bin/env 解释器 ，导致./file  直接运行以bash去执行
[root@yuchao-tx-server ~/p3-shell]#cat p1.py
print("www.yuchaoit.cn")
[root@yuchao-tx-server ~/p3-shell]#
[root@yuchao-tx-server ~/p3-shell]#
[root@yuchao-tx-server ~/p3-shell]#chmod u+x p1.py
[root@yuchao-tx-server ~/p3-shell]#
[root@yuchao-tx-server ~/p3-shell]#./p1.py
./p1.py:行1: 未预期的符号 `"www.yuchaoit.cn"' 附近有语法错误
./p1.py:行1: `print("www.yuchaoit.cn")'



2. 不同的脚本必须指定解释器，才能正确运行

[root@yuchao-tx-server ~/p3-shell]#cat p1.py
#!/usr/bin/env python3
print("www.yuchaoit.cn")
[root@yuchao-tx-server ~/p3-shell]#
[root@yuchao-tx-server ~/p3-shell]#
[root@yuchao-tx-server ~/p3-shell]#./p1.py
www.yuchaoit.cn


# ubuntu下，注意默认只有python3了
[root@www.yuchaoit.cn all_bash_file]$cat haha.py
#!/usr/bin/python3
print("我是python程序，我被执行了..")

4.3 强制用解释器去执行脚本

[root@yuchao-tx-server ~/p3-shell]#python3 p1.py
www.yuchaoit.cn

[root@yuchao-tx-server ~/p3-shell]#bash t1.sh
www.yuchaoit.cn

4.4 shell和python和运维

Shell

shell脚本的优势在于，最贴切linux底层，直接使用linux原生命令，效率很高，适合处理偏向操作系统底层的脚本。

对于一些常见的系统脚本，用shell去开发会更简单，更快速，例如一键部署nginx集群，系统内核参数优化，服务启动脚本，日志分析解析三剑客的提取脚本等。

虽然其他语言，如python也能实现这个效果，但是考虑到学习成本，开发效率，以及如果通过python管理操作系统的模块去写脚本，这个python语言对操作系统的效率，远不如linux命令来的强大。

因此对于基本的系统维护需求，用shell脚本会更符合易用、快速、高效的原则。


python能实现的，shell实现不了，反之，python都行！

python

python是最近几年运维自动化非常流行的语言，随着运维人员开发能力的提升，以及运维对编程的需求加大，像知乎网、豆瓣网、国外的INS网都是python开发的，虽说后来有更新。

因此python很适合web开发，实现网站的后端功能，这个是shell完成不了的，shell仅仅是维护linux系统的脚本语言。

python除了可以开发网站的web服务，以及运维的开源工具，如ansible，saltstack，openstack虚拟化平台，都是python开发而来。

因此运维的第二语言以python为主，适合开发更复杂，更强大的运维软件，运维系统，而不是简单的运维脚本了。

5. 调试shell执行

例如给你准备如下一个测试登录的脚本。

通过set -x 和 set +x 设定一个范围，会显示对应的代码，以及执行结果。

[root@yuchao-tx-server ~/p3-shell]#cat login.sh
#!/usr/bin/env bash
# set -x 用于在运行结果之前，先输出对应的命令，用于精准调试shell脚本逻辑
#set -x

# 用户输入交互
read -p "请输入账号："  username
read -p "请输入密码："  pwd
# set +x 表示关闭这个x调试功能
#set +x

# 账号密码验证逻辑
if [[ "${username}" == "yuchao" && "${pwd}" == "www.yuchaoit.cn" ]];then
    echo "尊贵的SVIP，欢迎您登录！"
else
    echo "什么玩意？账号密码错误！！"
fi

# 执行脚本
[root@yuchao-tx-server ~/p3-shell]#bash login.sh
+ read -p 请输入账号： username
请输入账号：pyyu
+ read -p 请输入密码： pwd
请输入密码：www.yuchaoit.cn
+ set +x
尊贵的SVIP，欢迎您登录！


# 错误登录
[root@yuchao-tx-server ~/p3-shell]#bash login.sh
+ read -p 请输入账号： username
请输入账号：123
+ read -p 请输入密码： pwd
请输入密码：123
+ set +x
什么玩意？请你先注册！

加上脚本的详细执行过程，通过 bash -vx参数显示详细过程。

[root@yuchao-tx-server ~/p3-shell]#bash -vx login.sh
#!/usr/bin/env bash
# set -x 用于在运行结果之前，先输出对应的命令，用于精准调试shell脚本逻辑
set -x
+ set -x

# 用户输入交互
read -p "请输入账号："  username
+ read -p 请输入账号： username
请输入账号：pyyu
read -p "请输入密码："  pwd
+ read -p 请输入密码： pwd
请输入密码：www.yuchaoit.cn
# set +x 表示关闭这个x调试功能
set +x
+ set +x

# 账号密码验证逻辑
if [[ "${username}" == "pyyu" && "${pwd}" == "www.yuchaoit.cn" ]];then
    echo "尊贵的SVIP，欢迎您登录！"
else
    echo "什么玩意？请你先注册！"
fi
尊贵的SVIP，欢迎您登录！

去掉set -x 和set +x ，这个作为了解，一般不用。

并且模拟代码写错了，例如忘记了结尾的fi。

[root@yuchao-tx-server ~/p3-shell]#cat login.sh
#!/usr/bin/env bash
# 用户输入交互
read -p "请输入账号："  username
read -p "请输入密码："  pwd

# 账号密码验证逻辑
if [[ "${username}" == "pyyu" && "${pwd}" == "www.yuchaoit.cn" ]];then
    echo "尊贵的SVIP，欢迎您登录！"
else
    echo "什么玩意？请你先注册！"
[root@yuchao-tx-server ~/p3-shell]#

执行，错误结果如下

[root@yuchao-tx-server ~/p3-shell]#bash login.sh
请输入账号：qweqwe
请输入密码：qwe
login.sh:行11: 语法错误: 未预期的文件结尾

显示详细过程

[root@yuchao-tx-server ~/p3-shell]#bash -vx  login.sh
#!/usr/bin/env bash
# 用户输入交互
read -p "请输入账号："  username
+ read -p 请输入账号： username
请输入账号：qwe
read -p "请输入密码："  pwd
+ read -p 请输入密码： pwd
请输入密码：qwe

# 账号密码验证逻辑
if [[ "${username}" == "pyyu" && "${pwd}" == "www.yuchaoit.cn" ]];then
    echo "尊贵的SVIP，欢迎您登录！"
else
    echo "什么玩意？请你先注册！"
login.sh:行11: 语法错误: 未预期的文件结尾

修复Bug，结尾加上fi，再执行，且显示代码详细加载的过程，用于调试代码。


[root@yuchao-tx-server ~/p3-shell]#bash -vx login.sh
#!/usr/bin/env bash
# 用户输入交互
read -p "请输入账号："  username
+ read -p 请输入账号： username
请输入账号：pyyu
read -p "请输入密码："  pwd
+ read -p 请输入密码： pwd
请输入密码：www.yuchaoit.cn

# 账号密码验证逻辑
if [[ "${username}" == "pyyu" && "${pwd}" == "www.yuchaoit.cn" ]];then
    echo "尊贵的SVIP，欢迎您登录！"
else
    echo "什么玩意？请你先注册！"
fi
+ [[ pyyu == \p\y\y\u ]]
+ [[ www.yuchaoit.cn == \w\w\w\.\y\u\c\h\a\o\i\t\.\c\n ]]
+ echo 尊贵的SVIP，欢迎您登录！
尊贵的SVIP，欢迎您登录！

6. 代码编写细节语法（重点）

1.成对儿出现的符号，一次性写好，别遗漏。

如下符号，一次性，首尾都给写好。

例如大括号{}
中括号[]
小括号()
单引号' '
双引号" "
反引号` `

2.shell语法要求括号内必须有空格。

中括号[ ]两端需要留有空格，不然会报错
书写时即可留出空格然后书写内容。
如果不知道大括号{}，中括号[]，小括号()，到底哪种括号需要两端留空格，可以在书写这些括号的时候两端都保留空格来进行书写，这样可以有效避免因空格导致的各种错误。

例如上述代码案例的 中括号。
[[ 语法要求前后都预留一个空格 ]]

if [[ "${username}" == "pyyu" && "${pwd}" == "www.yuchaoit.cn" ]];then

流程控制语句，习惯性，先写好流程，再添加内容。

例1：if语句格式一次书写完成

if 条件语句
then
条件成立后执行的代码
fi



例2：for循环格式一次书写完成

 for条件内容
 do
 条件成立后执行的代码
 done


 提示：while、until、case等语句也是一样

 意思就是告诉大家，可以先吧语法框架写好，防止自己忘了，导致低级的语法错误。

4.虽然shell无要求，但是建议你写缩进，清晰代码的层次关系。

总结

编程目的
编译型语言、解释性语言
解释性语言的python和shell
什么是shell
shell和运维的联系
学会shell的正确姿势
shell登录脚本光速入门。
执行shell脚本的不同方式，细节。
调试shell的技巧。
写shell脚本的细节。

01-Shell基础概述