Comment exécuter efficacement les commandes de terminal sous Linux

Linux Terminal est un outil puissant qui vous permet d'effectuer diverses opérations système à l'aide de commandes. Les opérations sur les fichiers, la gestion des programmes et l'automatisation des services sont toutes des opérations qui peuvent être effectuées efficacement à l'aide de commandes shell.

Cependant, lorsque plusieurs opérations doivent être effectuées, exécuter les commandes une par une n'est pas efficace. Un moyen plus rapide consiste à enchaîner plusieurs commandes sur une seule ligne. Non seulement cela accélère le processus, mais cela vous fait également gagner du temps.

Explorons toutes les façons d'exécuter plusieurs commandes à la fois sous Linux.

Exécutez plusieurs commandes Linux à la fois

Linux utilise trois opérateurs pour vous aider à exécuter plusieurs commandes sur une seule ligne :

1. Opérateur point-virgule (;)

2. Opérateur logique OU (||)

3. Logique

   Opérateur ET (&&)

Tous ces opérateurs peuvent exécuter deux ou plusieurs commandes shell simultanément. Cependant, savoir quels opérateurs utiliser et quand peut vous aider à créer des commandes plus efficacement. Les sections suivantes expliquent l'objectif et la syntaxe de l'utilisation correcte de ces opérateurs :

1. Utilisez l'opérateur point-virgule (;)

L'utilisation de points-virgules pour segmenter les chaînes de commandes est la pratique la plus courante pour exécuter plusieurs commandes dans un terminal Linux. Cela est dû en partie à la manière dont l'opérateur est exécuté : il exécute toutes les commandes de la séquence, que la commande précédente ait été exécutée avec succès ou non.

Par exemple, si vous avez deux commandes : Commande A et Commande B, l'utilisation de l'opérateur point-virgule entre elles garantit que les deux commandes sont exécutées dans l'ordre, quel que soit le résultat de la première commande.

command A ; command B

Donc, si vous devez exécuter simultanément deux ou plusieurs commandes de terminal non liées afin que l'état de sortie de la première commande n'affecte pas l'exécution de cette dernière, l'opérateur point-virgule est la voie à suivre.

Exemple de cas d'utilisation : si vous souhaitez voir le nom de l'utilisateur actuel et le nom d'hôte du système, vous pouvez utiliser :

xiaoyuer@linuxmi:
~/www.linuxmi.com$ whoami ; 
hostnamexiaoyuerlinuxmi

N'oubliez pas que le shell exécute ces commandes dans l'ordre exact dans lequel vous les mentionnez. Le résultat ressemble à ceci :

2. Utilisez l'opérateur OR (||)

La définition du mot « ou » est révélatrice ici : lorsque vous exécutez deux commandes à l'aide de l'opérateur OR, vous dites au shell d'exécuter une seule des deux commandes.

Supposons que vous utilisiez l'opérateur OR avec deux commandes : Commande A et Commande B. Voici à quoi ressemble la commande concaténée en utilisant l'opérateur OR :

command A || command B

Ici, la commande B est exécutée uniquement lorsque la commande A échoue, c'est-à-dire lorsque la commande A renvoie une erreur. De même, si la commande A s’exécute avec succès, la commande B ne s’exécutera pas.

En parlant de son cas d'utilisation, lorsque vous devez exécuter deux commandes liées en même temps, vous pouvez utiliser l'opérateur OR pour que le shell n'exécute la commande suivante que si la commande précédente échoue.

Exemple de cas d'utilisation : disons que vous souhaitez créer un nouveau fichier, par exemple Document.txt, mais avant de le faire, vous devez vous assurer que le fichier n'existe pas déjà dans le répertoire actuel. Dans ce cas, vous pouvez exécuter les commandes dans l'ordre suivant :

xiaoyuer@linuxmi:~/www.linuxmi.com$ find . -name 
linuxmi.txt || touch linuxmi.txtxiaoyuer@linuxmi:~/www.linuxmi.com$

Ici, la commande find trouvera le répertoire de travail actuel du fichier linux.txt. Si le fichier est trouvé, la progression de la commande s'arrêtera et la deuxième commande ne sera pas exécutée.

En revanche, si le fichier n'est pas trouvé, la commande de droite sera exécutée et un nouveau fichier nommé linux.txt sera créé dans le répertoire de travail actuel.

3. Utilisez l'opérateur AND (&&)

Comme vous l'avez peut-être deviné, l'opérateur AND vous permet d'exécuter plusieurs commandes de manière séquentielle, c'est-à-dire qu'il n'exécute la commande suivante dans la séquence que si la commande précédente s'est exécutée avec succès.

为了更好地理解这一点，请考虑这样一个场景：您希望运行两个相关命令，以便仅当第一个命令返回有效输出时才运行第二个命令。在这种情况下，您可以使用 AND 运算符（称为 &&）将命令绑定在一起，以获得所需的结果。

示例用例：在 Linux 中，AND 运算符最常见的用例之一是创建一个新目录并立即进入该目录。这样，您就不必分别运行这两个命令来执行操作。

在本指南中，假设您要创建一个名为“linuxmi”的新目录，并立即将当前工作目录更改为该目录。这是你可以做到的：

xiaoyuer@linuxmi:~/www.linuxmi.com$ mkdir 
linuxmi && cd linuxmixiaoyuer@linuxmi:~/www.linuxmi.com/linuxmi$

在这里，mkdir 命令将在当前工作目录中创建一个名为 linuxmi 的新目录。如果成功，它将允许执行 cd 命令。

组合多个运算符以满足您的执行标准

除了在命令中单独使用运算符外，还可以对多个运算符进行分组以满足执行条件。当您想要执行满足多个条件的命令时，这会派上用场。

例如，假设您希望仅在命令 A 失败时才执行两个命令（命令 B 和命令 C）。为此，您需要使用运算符，如下面的符号所示：

command A || command B && command C

示例用例：假设您要确定当前工作目录中是否存在文件夹（名为 linuxmi），如果不存在，则创建该文件夹。

在这种情况下，您可以一起使用 OR 和 AND 运算符来有效地执行整个操作，而不是运行单独的命令来查找目录并创建新目录。

就是这样子：

find . -name linuxmi1 || echo "目录未找到" && mkdir linuxmi

在此命令中，find 要求 shell 在当前工作目录中搜索名为 Document 的文件夹。如果该目录不存在，终端会将流传输到 echo 和 mkdir 命令，这些命令分别打印指定的字符串并创建新文件夹。

使用 shell 脚本一次运行多个命令

shell 脚本是一个程序，可让您一次自动执行一系列命令。它消除了在 Linux 终端中键入多个命令的需要，并节省了时间和精力。

只需创建一个脚本，其中包含频繁运行所需的所有命令，并将其转换为可执行文件。然后，在您需要执行这些命令时运行它，它将为您完成所有操作。

首先创建一个新文件，然后键入要立即执行的命令。使用适当的名称保存文件，并在末尾添加“.sh”扩展名。

现在，打开终端并导航到保存脚本的文件夹。运行以下命令以使文件可执行：

chmod +x linuxmi.sh

完成后，下次需要再次执行这些命令时，请转到终端中包含脚本文件的文件夹并像这样执行它：

./linuxmi.sh

您可以使用它的一个应用程序是系统更新。与其在每次要更新系统时在终端中手动键入和执行 sudo apt update 和 sudo apt upgrade 命令，不如创建一个脚本来自动为您运行命令。

只需使用以下命令创建一个脚本文件，然后按照上面演示的其余步骤操作：

#!/bin/bash
sudo apt update && sudo apt upgrade -y

在 Linux 中高效运行终端命令

如您所见，在命令中使用运算符可以简化大多数命令行操作。

如果您希望通过终端在计算机上执行不同的系统操作，了解如何使用这些运算符将非常有帮助，并帮助您有效地运行 Linux 命令。

同样，如果您刚刚开始（或者不太熟悉）Linux，那么学习不同的终端命令是掌握命令行界面的又一步。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!