Tutorial de aprendizaje de scripts de Shell (1)

Enterprise 2023-10-01 02:05:13 views: null

aprendizaje de scripts de shell

1. ¿Qué es Shell?

1. descripción general del caparazón

Shell es una interfaz de línea de comandos (CLI) en un sistema operativo de computadora que permite a los usuarios interactuar con el sistema operativo y realizar diversas tareas y operaciones. Shell también es un lenguaje de programación de scripts que permite a los usuarios escribir scripts para automatizar tareas y ejecutar una serie de comandos.

En los sistemas operativos Linux y Unix, Shell 是用户与操作系统内核之间的中间层acepta comandos ingresados ​​por el usuario y los pasa al kernel para su ejecución. Los usuarios pueden ingresar comandos a través del teclado y luego el Shell procesa 解释和执行esos comandos. Shell también es responsable del procesamiento, 输入和输出、环境变量、文件操作etc.

Algunos Shell comunes incluyen Bash (Bourne-Again Shell), Zsh (Z Shell), Fish (Friendly Interactive Shell), etc. Cada Shell tiene sus propias características y funciones. Bash es el shell predeterminado más común en Linux y macOS

Los principales usos de Shell incluyen:

  • Ejecutar comandos y programas: los usuarios pueden ingresar comandos en Shell para ejecutar programas, administrar archivos, ver el estado del sistema, etc.
  • Programación de scripts: los usuarios pueden escribir scripts de Shell para combinar una serie de comandos y operaciones para lograr tareas automatizadas.
  • Canalizaciones y redirección: el shell permite a los usuarios canalizar la salida de comandos a otros comandos, así como redirigir la entrada y salida a archivos o dispositivos.
  • Gestión de variables de entorno: Shell permite a los usuarios configurar y gestionar variables de entorno, que afectan el entorno de ejecución de los usuarios y programas.
  • Control de procesos: Shell admite declaraciones condicionales, bucles y ramas, lo que permite a los usuarios escribir una lógica de script compleja.

2. Clasificación de conchas

La programación de Shell, al igual que la programación de JavaScript y PHP, requiere un editor de texto que pueda escribir código y un intérprete de script que pueda interpretarlo y ejecutarlo. Hay
muchos tipos de Shell en Linux, y los más comunes son:

  • Bourne Shell (/usr/bin/sh o /bin/sh)
  • Bourne otra vez Shell（/bin/bash）
  • C Shell（/usr/bin/csh）
  • K Shell（/usr/bin/ksh）
  • Shell para raíz (/sbin/sh)

Este tutorial se centra en Bash, también conocido como Bourne Again Shell. Debido a que es fácil de usar y gratuito, Bash se usa ampliamente en el trabajo diario. Al mismo tiempo, Bash también es el Shell predeterminado para la mayoría de los sistemas Linux.

En general, la gente no distingue entre Bourne Shell y Bourne Again Shell, por lo que#!/bin/sh同样也可以改为 #!/bin/bash

#! 告诉系统其后路径所指定的程序即是解释此脚本文件的 Shell 程序

3. El primer script de shell

# 1. vim helloworld.sh 是打开一个文本编辑器（Vim）并创建或打开名为 "helloworld.sh" 的文件的命令
vim helloworld.sh

# 2. echo "hello, world!" 是一个 Shell 命令。作用是在终端上打印 "hello, world!"
echo "hello,world!"

# 3. 用于为一个文件赋予可执行权限 
chmod +x helloworld.sh

# 4. 运行这个脚本的命令
./helloworld.sh
  • El efecto de ejecución es el siguiente:
    Insertar descripción de la imagen aquí

4. Ejecución de múltiples comandos

Múltiples ejecutores de comandos efecto Formato
; Se ejecutan varios comandos secuencialmente sin ninguna conexión lógica entre los comandos. comando 1; comando 2
&& Cuando el comando 1 se ejecuta correctamente (el código de estado de salida es 0), se ejecutará el comando 2; de lo contrario, el comando 2 no se ejecutará. Comando 1 && Comando 2
|| El comando 2 solo se ejecutará cuando el comando 1 se ejecute incorrectamente (el código de estado de salida no es 0); de lo contrario, el comando 2 no se ejecutará. Comando 1 || Comando 2

Ejemplo de ejecución de múltiples comandos:

  1. El punto y coma (;) se utiliza para ejecutar varios comandos secuencialmente y no existe una conexión lógica entre los comandos:

    $ command1 ; command2 ; command3

    Ejemplo:

    $ ls ; echo "Hello" ; date

    El comando anterior ejecutará lsel comando (enumera el contenido del directorio actual), echoel comando (imprime "Hola") y dateel comando (muestra la fecha y hora actuales).

  2. El operador lógico AND (&&) se utiliza para ejecutar el siguiente comando solo si el comando anterior se ejecutó correctamente:

    $ command1 && command2

    Ejemplo:

    $ rm file.txt && echo "File deleted successfully"

    El comando anterior primero intenta eliminar file.txtel archivo y, si la eliminación se realiza correctamente, ejecute echoel comando para mostrar "Archivo eliminado correctamente". Si la eliminación del archivo falla (el comando 1 se ejecutó incorrectamente), echoel comando no se ejecutará.

  3. El operador lógico OR (||) se utiliza para ejecutar el siguiente comando solo si el comando anterior se ejecutó incorrectamente:

    $ command1 || command2

    Ejemplo:

    $ find /tmp -name "file.txt" || echo "File not found"

    El comando anterior primero intenta /tmpencontrar un archivo llamado "file.txt" en el directorio. Si se encuentra el archivo (el comando 1 se ejecutó correctamente), echoel comando no se ejecutará. Si no se encuentra el archivo (el comando 1 se ejecutó incorrectamente), echoel comando se ejecuta para mostrar "Archivo no encontrado".

2. Variables del caparazón

3.1 Reglas de nomenclatura para variables

En los scripts de shell, las variables son elementos clave que se utilizan para almacenar y manipular datos. La denominación adecuada de las variables es clave para escribir scripts claros, legibles y sólidos. Las siguientes son las reglas de nomenclatura para las variables de Shell:

  1. Los nombres de las variables pueden contener:

    • Letras (mayúsculas o minúsculas): de la a a la z o de la A a la Z.
    • Números: del 0 al 9 (pero los nombres de las variables no pueden comenzar con números).
    • Subrayado _.

  2. Los nombres de las variables deben comenzar con una letra o un guión bajo. No se permite comenzar con un número.

  3. Los nombres de las variables distinguen entre mayúsculas y minúsculas, por lo que $myVary $myvarson dos variables diferentes.

  4. Evite el uso de palabras clave reservadas de Shell (por ejemplo, if, while, for, etc.) como nombres de variables.

  5. Se recomienda utilizar nombres de variables descriptivos y significativos para mejorar la legibilidad del script.

  6. Estilos de nombres comunes:

    • Camel Case: la primera palabra comienza con una letra minúscula y la primera letra de las palabras siguientes está en mayúscula.
      Por ejemplo: myVariableName, thisIsCamelCase.

    • Nomenclatura de guión bajo (caso serpiente): todas las letras están en minúsculas y las palabras están _separadas por guiones bajos.
      Por ejemplo: my_variable_name, this_is_snake_case.

Ejemplo:

A continuación se muestran algunos ejemplos que demuestran diferentes reglas de nomenclatura de variables:

# 驼峰命名法示例
myVariableName="Hello, World!"
thisIsCamelCase="这是一个驼峰命名"
anotherCamelCaseVariable="这是另个驼峰命名"

# 下划线命名法示例
my_variable_name="Hello, World!"
this_is_snake_case="这是下划线命名"
another_snake_case_variable="这是另一个下划线命名"

Las reglas correctas de nomenclatura de variables son una de las bases de la programación de scripts de shell, ya que ayudan a escribir código mantenible y legible, reduciendo errores y mejorando la calidad del código.

3.2 Símbolos especiales para variables

  1. $ : El signo de dólar se utiliza para referirse al valor de una variable.
    Ejemplo:

    myVar="Hello"
echo $myVar   # 输出：Hello

    Insertar descripción de la imagen aquí

  2. * : Comodín de asterisco, utilizado para hacer coincidir cero o más caracteres.
    Ejemplo:

    ls *.txt   # 列出所有以 ".txt" 结尾的文件

    Insertar descripción de la imagen aquí

  3. ? : comodín de signo de interrogación, utilizado para hacer coincidir cualquier carácter.
    Ejemplo:

    ls file?.txt   # 列出类似 "file1.txt"、"fileA.txt" 的文件

    Insertar descripción de la imagen aquí

  4. [ ] : Los corchetes se utilizan para definir el juego de caracteres y pueden coincidir con cualquier carácter entre corchetes.
    Ejemplo:

    ls [aeiou]*   # 列出以元音字母开头的文件

    Insertar descripción de la imagen aquí

  5. { } : las llaves se utilizan para crear secuencias de comandos o expandir cadenas.
    Ejemplo:

    echo {
      
      A,B,C}   # 输出：A B C

    Insertar descripción de la imagen aquí

  6. | : La barra vertical se utiliza para pasar la salida de un comando a otro comando, formando una tubería.
    Ejemplo:

    cat file.txt | grep "pattern"   # 在文件中搜索模式

    Insertar descripción de la imagen aquí

  7. ; : El punto y coma se utiliza para separar varios comandos, lo que permite ejecutar varios comandos en una línea.
    Ejemplo:

    command1; command2   # 依次执行两个命令

    Insertar descripción de la imagen aquí

  8. && : Operador lógico AND, utilizado para ejecutar dos comandos y ejecutar el segundo comando solo después de que el primer comando tenga éxito.
    Ejemplo:

    make && make install   # 如果 make 成功，则执行 make install

  9. || : Operador lógico OR utilizado para ejecutar dos comandos y ejecutar el segundo comando solo si el primero falla.
    Ejemplo:

    command1 || echo "command1 failed"   # 如果 command1 失败，则输出提示

  10. \> : El símbolo mayor que se utiliza para redirigir la salida de un comando a un archivo.
    Ejemplo:

    echo "Hello, World!" > output.txt   # 将文本写入文件

Insertar descripción de la imagen aquí

  1. >> : El símbolo doble mayor que se utiliza para agregar la salida de un comando a un archivo.
    Ejemplo:
echo "More text" >> output.txt   # 追加文本到文件

Insertar descripción de la imagen aquí

  1. < : El símbolo menor que se utiliza para redirigir el contenido de un archivo como entrada a un comando.
    Ejemplo:
command < input.txt   # 使用文件内容作为输入执行命令
  1. ` : Las comillas invertidas se utilizan para ejecutar el comando y generarlo como una cadena.
    Ejemplo:
currentDate=`date`   # 获取当前日期并存储为字符串

3.3 Variables definidas por el usuario

Las variables las definen los escritores de scripts de Shell y se utilizan para almacenar resultados intermedios de tareas o cálculos específicos. El alcance es el proceso o script de Shell actual.

1. Definir variables:

En los scripts de shell, puede utilizar el signo igual (=) para definir variables. 变量名不应该包含空格，并且通常使用大写字母, para distinguirlas de las variables de entorno del sistema.

myVar="Hello, World"

2. Asignar variables:

Para asignar un valor a una variable, simplemente use el signo igual (=) para la operación de asignación.

myVar="New Value"

3. Utilice variables:

Para utilizar el valor de una variable, preceda la variable con un signo de dólar ($).

echo $myVar

4. Concatenación de cadenas:

Las variables se pueden concatenar con cadenas.

greeting="Hello"
name="John"
echo "$greeting, $name!"

Ejemplo:

[root@localhost shell]# NAME="cxk"
[root@localhost shell]# DOING="play-basketball"
[root@localhost shell]# echo $NAME $DOING
cxk play-basketball
[root@localhost shell]# echo "$NAME,$DOING！！！"
cxk,play-basketball！！！

5. Exportar variables:

Si desea exportar una variable al entorno del shell actual para que otros procesos secundarios también puedan acceder a ella, puede usar exportel comando.

export myVar="Exported Value"

6. Variables de solo lectura:

Una variable se puede convertir en de solo lectura para evitar que se modifique su valor.

readonly myVar="This variable is read-only"

Ejemplo:

[root@localhost shell]# var='cxk'
[root@localhost shell]# echo $var
cxk
[root@localhost shell]# var='rap'
[root@localhost shell]# echo $var
rap
[root@localhost shell]# readonly var='ikun'
[root@localhost shell]# echo $var
ikun
[root@localhost shell]# var='cxk'
-bash: var: 只读变量

7. Eliminar variables:

Las variables se pueden eliminar usando unsetel comando.

unset myVar

Ejemplo:

[root@localhost shell]# setVar='temp'
[root@localhost shell]# echo $setVar
temp
[root@localhost shell]# unset setVar
[root@localhost shell]# echo $setVar

8. Mejores prácticas:

  • Utilice nombres de variables significativos para mejorar la legibilidad del código.
  • Utilice comillas dobles para citar variables para manejar cadenas que contengan espacios o caracteres especiales.
  • Evite el uso de letras mayúsculas para definir variables que no sean de entorno para evitar conflictos con las variables de entorno del sistema.
  • Antes de utilizar una variable, compruebe si está definida para evitar errores inesperados.
  • Úselo readonlypara evitar que las variables que no deben cambiarse se modifiquen accidentalmente.
  • Úselo exportpara que la variable esté disponible en el proceso hijo.
  • Agregue comentarios para explicar el propósito de las variables para mejorar la capacidad de mantenimiento del código.

3.4 Variables ambientales

1. ¿Qué son las variables de entorno?

Las variables de entorno son pares clave-valor almacenados en el nivel del sistema operativo y se utilizan para almacenar información de configuración, rutas, preferencias del usuario, etc. Las variables de entorno del Shell son muy importantes para controlar y configurar el comportamiento del sistema.

2. Verifique las variables de entorno:

Utilice echoel comando y el signo de dólar ($) para ver el valor de una variable de entorno específica
. Por ejemplo, genere la ruta del directorio de inicio del usuario actual:

echo $HOME

Insertar descripción de la imagen aquí

3. Establecer variables de entorno:

Para configurar variables de entorno, puede utilizar exportel comando:

export MY_VARIABLE="Hello"

Esto creará una MY_VARIABLEvariable de entorno denominada y establecerá su valor en "Hola". Tenga en cuenta que esta variable está disponible dentro de la sesión de shell actual.

4. Variables de entorno persistentes:

Para hacer que una variable de entorno sea persistente, generalmente la agrega al archivo de configuración del shell, como .bashrco .bash_profile(para el shell Bash). De esta manera, la variable se establece automáticamente cada vez que se inicia una nueva sesión de shell.

5. Ver todas las variables de entorno:

Para ver todas las variables de entorno definidas, puede utilizar envel comando:

env

O use printenvel comando:

printenv

6. Eliminar variables de entorno:

Para eliminar variables de entorno, puede utilizar unsetel comando:

unset MY_VARIABLE

7. Utilice variables de entorno:

Las variables de entorno son muy útiles en los scripts y se pueden usar para almacenar información de configuración o rutas, por ejemplo:

# 使用环境变量
echo "home路径的环境变量地址: $HOME"

8. Variables de entorno predefinidas del sistema:

El sistema operativo y Shell predefinen algunas variables de entorno, como PATH, HOME, USERetc., que se pueden utilizar para acceder a la información o configuración del sistema.

9. Importar variables de entorno:

Importar variables de entorno significa cargar variables de entorno desde un archivo o fuente externo en la sesión de shell actual para que estén disponibles en la sesión actual. Normalmente se utiliza para garantizar que las variables de entorno requeridas estén definidas antes de cargar información de configuración desde un archivo, configurar variables de entorno o ejecutar otros scripts.

En el shell, hay varias formas de importar variables de entorno:

  • Usar sourcecomando o .(punto): estos dos comandos se usan para ejecutar los comandos en el archivo especificado y aplicar los resultados a la sesión de shell actual. Normalmente se utiliza para cargar archivos de variables de entorno, como .env.

    source .env
# 或者
. .env

    ¿Dónde .envestá el archivo que contiene las definiciones de variables de entorno? Después de ejecutar estos comandos, .envlas variables de entorno definidas en el archivo entrarán en vigor en la sesión de shell actual.

  • Usando exportel comando: si desea importar variables de entorno a la sesión de shell actual y hacerlas disponibles en procesos secundarios, puede usar exportel comando:

    export MY_VARIABLE="Hello"

    Esto creará una variable de entorno nombrada en la sesión de shell actual MY_VARIABLEy la hará disponible en la sesión actual y sus procesos secundarios.

  • Pasar ~/.bashrco ~/.bash_profile: si desea que las variables de entorno se importen automáticamente cada vez que inicie una nueva sesión de Bash Shell, puede agregarlas al archivo .bashrco .bash_profileen el directorio de inicio del usuario. De esta manera, las variables de entorno se configurarán automáticamente cada vez que inicie sesión.

    Por ejemplo, puede .bashrcagregar la siguiente línea al archivo para importar variables de entorno:

    source /path/to/myenvfile

10. Mejores prácticas:

  • Utilice nombres de variables significativos para mejorar la legibilidad del código.
  • Evite sobrescribir las variables de entorno predefinidas del sistema para evitar problemas innecesarios.
  • Cuando se requiera información confidencial (como contraseñas), evite almacenarla en variables de entorno, ya que las variables de entorno generalmente no son una forma segura de almacenarlas.

3.5 Variables de parámetros posicionales

  • Estas variables se utilizan para obtener argumentos de línea de comando en scripts de shell.
  • $0Indica el nombre del script, $1indica el primer parámetro, $2indica el segundo parámetro, etc.
  • Ejemplo:
    script.sh arg1 arg2
# 在脚本内部可以使用 $0、$1、$2 获取参数
    Insertar descripción de la imagen aquí

3.6 Variables predefinidas

  • El Shell proporciona algunas variables predefinidas especiales para obtener información sobre el Shell y el sistema.
  • Por ejemplo, $HOMErepresenta el directorio de inicio del usuario actual y $PWDrepresenta el directorio de trabajo actual.
  • Ejemplo:
    echo "当前用户的主目录是 $HOME"

3.7 Aceptar entrada del teclado

  • Estas variables se utilizan para aceptar la entrada del teclado por parte del usuario.
  • Por ejemplo, readun comando se utiliza para almacenar la entrada del usuario en una variable específica.
  • Ejemplo:
    echo "请输入您的姓名："
read userName
echo "您输入的姓名是：$userName"
    Insertar descripción de la imagen aquí

3. Operador de concha

La siguiente es la sintaxis y ejemplos de operadores comunes en scripts de shell.

Tipo de operador operador Ejemplo de sintaxis Ejemplo
operadores aritméticos suma result=$((a + b)) 5 + 2El resultado es7
Sustracción result=$((a - b)) 5 - 2El resultado es3
multiplicación result=$((a * b)) 5 * 2El resultado es10
división result=$((a / b)) 10 / 3El resultado es3
tomar el resto result=$((a % b)) 15 % 7El resultado es1
Operadores relacionales igual [ "$a" -eq "$b" ] 5 -eq 5es verdad
no igual a [ "$a" -ne "$b" ] 5 -ne 2es verdad
más que el [ "$a" -gt "$b" ] 5 -gt 2es verdad
menos que [ "$a" -lt "$b" ] 5 -lt 10es verdad
mayor o igual a [ "$a" -ge "$b" ] 5 -ge 5es verdad
Menos que o igual a [ "$a" -le "$b" ] 5 -le 10es verdad
Operadores logicos Y operación [ "$a" -gt 0 ] && [ "$a" -lt 10 ] 5 > 0y 5 < 10es verdad
O operación [ "$a" -eq 0 ] || [ "$a" -eq 10 ] 5 = 0o 5 = 10es falso
NO operación ! [ "$a" -eq 5 ] 5 = 5Es falso
operador de asignación Asignación x=10 xigual10
asignación aditiva x=$((x + 5)) x5Después de la suma xes igual15
asignación sustractiva y=$((y - 5)) ymenos igual 5ay15
Operadores de bits Bit a bit Y result=$((a & b)) 5 & 3El resultado es1
O bit a bit result=$((a | b)) 5 | 3El resultado es7
XOR bit a bit result=$((a ^ b)) 5 ^ 3El resultado es6
negación bit a bit result=$((~a)) ~5El resultado es-6
Shift izquierdo result=$((a << 2)) 5 << 2El resultado es20
Giro a la derecha result=$((a >> 1)) 5 >> 1El resultado es2

3.1 Operadores aritméticos

Nota: En Shell, si desea realizar la operación de suma de variables ay b, debe utilizar una sintaxis específica para lograrlo. El shell no interpreta la escritura directa $a+$bcomo una operación de suma porque lo trata como un comando no encontrado.

Para realizar operaciones de suma, puede utilizar exprcomandos o $((...))expresiones. A continuación se muestran ejemplos de ambos métodos:

  • Método 1: usar exprel comando

    a=1
b=2
result=$(expr $a + $b)
echo "a + b = $result"

  • Método 2: usar $((...))expresiones

    a=1
b=2
result=$((a + b))
echo "a + b = $result"

Se utiliza para realizar operaciones matemáticas. Los operadores aritméticos admitidos son +, -, *, /, %.

# 语法：result=$((expression))

a=5
b=2

# 加法
result=$((a + b))  # 结果是7

# 减法
result=$((a - b))  # 结果是3

# 乘法
result=$((a * b))  # 结果是10

# 除法
result=$((a / b))  # 结果是2

# 取余
result=$((a % b))  # 结果是1

3.2 Operadores relacionales

Se utiliza para comparar la relación entre dos valores. Los operadores relacionales admitidos son -eq, -ne, -gt, -lt, -ge, -le.

# 语法：[ expression ]
# 注意：方括号内的空格是必需的！

a=5
b=10

# 相等
if [ "$a" -eq "$b" ]; then
    echo "$a 等于 $b"
else
    echo "$a 不等于 $b"
fi

# 不等于
if [ "$a" -ne "$b" ]; then
    echo "$a 不等于 $b"
else
    echo "$a 等于 $b"
fi

# 大于
if [ "$a" -gt "$b" ]; then
    echo "$a 大于 $b"
else
    echo "$a 不大于 $b"
fi

# 小于
if [ "$a" -lt "$b" ]; then
    echo "$a 小于 $b"
else
    echo "$a 不小于 $b"
fi

# 大于等于
if [ "$a" -ge "$b" ]; then
    echo "$a 大于等于 $b"
else
    echo "$a 小于 $b"
fi

# 小于等于
if [ "$a" -le "$b" ]; then
    echo "$a 小于等于 $b"
else
    echo "$a 大于 $b"
fi

3.3 Operadores lógicos

Se utiliza para realizar operaciones lógicas. Los operadores lógicos admitidos son &&(Y lógico), ||(O lógico), !(NO lógico).

# 语法：command1 && command2
# command2 仅在 command1 返回真（退出状态码为0）时执行

# 与运算
if [ "$a" -gt 0 ] && [ "$a" -lt 10 ]; then
    echo "$a 大于0并且小于10"
else
    echo "$a 不满足条件"
fi

# 或运算
if [ "$a" -eq 0 ] || [ "$a" -eq 10 ]; then
    echo "$a 等于0或等于10"
else
    echo "$a 不满足条件"
fi

# 非运算
if ! [ "$a" -eq 5 ]; then
    echo "$a 不等于5"
else
    echo "$a 等于5"
fi

3.4 Operador de asignación

Se utiliza para asignar valores a variables. Los operadores de asignación admitidos son =``+=, -=, *=, /=, %=.

# 语法：variable operator expression

x=10
y=20

# 赋值
x=5
y=10

# 加法并赋值
x=$((x + 5))  # x 现在等于10

# 减法并赋值
y=$((y - 5))  # y 现在等于15

Operadores de 3,5 bits

Se utiliza para realizar operaciones de bits. Los operadores de bits admitidos son &(Y bit a bit), |(OR bit a bit), ^(OR exclusivo bit a bit), ( ~negación bit a bit), <<(desplazamiento a la izquierda), >>(desplazamiento a la derecha).

# 语法：result=$((expression))

a=5
b=3

# 按位与
result=$((a & b))  # 结果是1

# 按位或
result=$((a | b))  # 结果是7

# 按位异或
result=$((a ^ b))  # 结果是6

# 按位取反
result=$((~a))     # 结果是-6

# 左移
result=$((a << 2))  # 结果是20

# 右移
result=$((a >> 1))  # 结果是2

4. Control de procesos

Las estructuras de control de procesos en los scripts de Shell incluyen declaraciones condicionales (declaraciones if), declaraciones de bucle (bucle for, bucle while), declaraciones de caso, etc. A continuación se detallan la sintaxis y los ejemplos de uso para cada estructura de control de flujo:

4.1 Declaración condicional: declaración if

  • ifLas declaraciones se utilizan para ejecutar diferentes comandos en condiciones específicas. La sintaxis es la siguiente:

    if [ condition ]; then
    # 条件为真时执行的命令
else
    # 条件为假时执行的命令
fi

  • Ejemplo:

    #!/bin/bash

x=10

if [ $x -eq 10 ]; then
    echo "x 等于 10"
else
    echo "x 不等于 10"
fi

4.2 Declaración de bucle: bucle for

  • forLos bucles se utilizan para ejecutar una serie de comandos sobre los elementos de una lista. La sintaxis es la siguiente:

    for variable in list; do
    # 在每次迭代中执行的命令
done

  • Ejemplo:

    #!/bin/bash

fruits=("apple" "banana" "cherry")

for fruit in "${fruits[@]}"; do
    echo "水果：$fruit"
done

4.3 Declaración de bucle: bucle while

  • whileSe utiliza un bucle para ejecutar una secuencia de comandos cuando una condición es verdadera hasta que la condición es falsa. La sintaxis es la siguiente:

    while [ condition ]; do
    # 当条件为真时执行的命令
done

  • Ejemplo:

    #!/bin/bash

count=1

while [ $count -le 5 ]; do
    echo "循环次数：$count"
    ((count++))
done

4.4 declaración de caso

  • caseLas declaraciones se utilizan para ejecutar diferentes comandos según diferentes condiciones. La sintaxis es la siguiente:

    case expression in
    pattern1)
        # 匹配 pattern1 时执行的命令
        ;;
    pattern2)
        # 匹配 pattern2 时执行的命令
        ;;
    *)
        # 默认情况下执行的命令
        ;;
esac

  • Ejemplo:

    #!/bin/bash

fruit="apple"

case $fruit in
    "apple")
        echo "这是苹果"
        ;;
    "banana")
        echo "这是香蕉"
        ;;
    *)
        echo "这不是苹果或香蕉"
        ;;
esac

4.5 Controlar el flujo: interrumpir y continuar

  • breakSe utiliza para salir del bucle.

  • continueSe utiliza para omitir el resto del ciclo actual y continuar con la siguiente iteración.

  • Ejemplo:

    #!/bin/bash

for i in {
      
      1..5}; do
    if [ $i -eq 3 ]; then
        continue
    fi
    echo "循环次数：$i"
    if [ $i -eq 4 ]; then
        break
    fi
done

5. Función

Las funciones de Shell son herramientas poderosas que permiten encapsular un conjunto de comandos y lógica en una unidad reutilizable para realizar una tarea o cálculo específico. En este artículo, profundizaremos en la sintaxis detallada de las funciones de Shell y proporcionaremos múltiples ejemplos prácticos para comprenderlas y utilizarlas mejor.

5.1 Definición de la función Shell

Las funciones de Shell pueden usar dos formas de sintaxis diferentes: usando functionpalabras clave y usando forma compacta.

5.1.1 definición de función de palabra clave de función

function function_name {
    
    
    # 函数体，包括命令和逻辑
    # 可以接受参数
    # 可以使用局部变量
    # 可以返回一个值
}

5.1.2 Definición de función de forma compacta

function_name() {
    
    
    # 函数体
}

5.2 Llamada a función

Una vez que se define una función, se puede llamar donde sea necesario en el script. Al llamar a una función, simplemente use su nombre seguido de los argumentos requeridos.

gramática:

function_name argument1 argument2

Ejemplo de llamada de función simple

# 定义一个函数，用于打印欢迎消息
welcome() {
    
    
    echo "欢迎来到Shell函数示例！"
}

# 调用函数
welcome

5.3 Parámetros de función

Las funciones pueden aceptar parámetros, lo que las hace más versátiles y flexibles. Dentro de la función, puede utilizar variables $1como, etc. para hacer referencia a los parámetros pasados ​​a la función $2. $3Estas variables representan el primer parámetro, el segundo parámetro, el tercer parámetro, etc.

Veamos un ejemplo de una función que acepta parámetros:

# 定义一个函数，接受两个参数并打印它们
print_arguments() {
    
    
    echo "第一个参数: $1"
    echo "第二个参数: $2"
}

# 调用函数，并传递两个参数
print_arguments "Hello" "World"

print(){
echo "你的名字：$1"
echo "你的爱好：$2"
}
print "蔡徐坤" "打篮球"

Insertar descripción de la imagen aquí

5.4 Valor de retorno de la función

Las funciones de Shell pueden devolver un valor, lo que permite a la función realizar cálculos y pasar los resultados al programa principal. Para devolver un valor, puede usar returnuna declaración y luego usarla en el programa principal $?para obtener el valor de retorno.

Ejemplo de función que calcula la suma de dos números y devuelve el resultado:

# 定义一个函数，计算两个数字之和并返回结果
add_numbers() {
    
    
    local sum=$(( $1 + $2 ))
    return $sum
}

# 调用函数，并获取返回值
add_numbers 5 7
result=$?
echo "5 + 7 的和是：$result"

5.5 Variables locales

En las funciones de Shell, puede utilizar localpalabras clave para crear variables locales. Las variables locales solo son visibles dentro de la función y no afectan a las variables en el ámbito global. Esto es muy útil porque permite usar variables dentro de una función sin preocuparse por conflictos con otras partes del código.

Ejemplo de función de variables locales:

# 定义一个函数，演示局部变量
my_function() {
    
    
    local local_variable="局部变量"
    echo "在函数内部：$local_variable"
}

local_variable="全局变量"
my_function
echo "在函数外部：$local_variable"

fun(){
    
    

echo "全局变量值:$var"
local var="局部变量"
echo "局部变量赋值后:$var"
}
var="全局变量"
fun

Insertar descripción de la imagen aquí

5.6 Ejemplos prácticos

5.6.1 Calcular factoriales

Calcula el factorial de un número dado. El factorial es el producto de un número entero positivo y el producto de todos los números enteros positivos desde 1 hasta ese número entero.

# 定义一个函数，计算给定数字的阶乘
calculate_factorial() {
    
    
    local number=$1
    local result=1

    if [ $number -lt 0 ]; then
        echo "输入必须是非负整数。"
        return 1
    fi

    for (( i=1; i<=number; i++ )); do
        result=$((result * i))
    done

    echo "$number 的阶乘是：$result"
    return 0
}

# 调用函数，计算阶乘
calculate_factorial 5
calculate_factorial 0
calculate_factorial -3

5.6.2 Buscar archivos

Encuentra un archivo específico en el sistema de archivos y devuelve la ruta al archivo

# 定义一个函数，查找文件并返回路径
find_file() {
    
    
    # 接受两个参数：文件名和搜索目录
    local file_name=$1
    local search_dir=$2

    # 检查是否提供了有效的文件名和搜索目录
    if [ -z "$file_name" ] || [ -z "$search_dir" ]; then
        echo "请输入文件名和搜索目录。"
        return 1  # 返回错误代码1表示参数不足或无效
    fi

    # 使用`find`命令在指定目录中查找文件
    local result=$(find "$search_dir" -name "$file_name")

    # 检查是否找到文件
    if [ -z "$result" ]; then
        echo "未找到文件 '$file_name'。"
        return 1  # 返回错误代码1表示未找到文件
    else
        echo "文件 '$file_name' 的路径是：$result"
        return 0  # 返回成功代码0表示找到文件
    fi
}

# 调用函数，查找文件
find_file "example.txt" "/path/to/search"   # 查找存在的文件
find_file "missing.txt" "/path/to/search"   # 查找不存在的文件
find_file "" "/path/to/search"              # 无效的参数：文件名为空

6. Comandos de interceptación, reemplazo y procesamiento de personajes.

6.1 Procesamiento de caracteres comunes

6.1.1 Longitud de la cuerda

gramática:

${
    
    #string}

Ejemplo:

string="Hello, World!"
length=${
    
    #string}
echo "字符串的长度为：$length"  # 输出 "字符串的长度为：13"

6.1.2 Interceptar subcadenas

gramática:

${string:起始位置:长度}

Ejemplo:

string="Hello, World!"
substring="${string:0:5}"  # 从位置0开始截取5个字符
echo "$substring"  # 输出 "Hello"

6.1.3 Eliminar prefijo

gramática:

${string#前缀}

Ejemplo:

string="/path/to/file.txt"
without_prefix="${string#/path/}"  # 删除前缀 "/path/"
echo "$without_prefix"  # 输出 "to/file.txt"

6.1.4 Eliminar sufijo

gramática:

${string%后缀}

Ejemplo:

string="/path/to/file.txt"
without_suffix="${string%.txt}"  # 删除后缀 ".txt"
echo "$without_suffix"  # 输出 "/path/to/file"

6.1.5 Convertir a minúsculas

gramática:

${string,,}

Ejemplo:

string="Hello, World!"
lowercase="${string,,}"  # 转换为小写
echo "小写: $lowercase"  # 输出 "小写: hello, world!"

6.1.6 Convertir a mayúsculas

gramática:

${string^^}

Ejemplo:

string="Hello, World!"
uppercase="${string^^}"  # 转换为大写
echo "大写: $uppercase"  # 输出 "大写: HELLO, WORLD!"

6.1.7 Reemplazo de cadena (primera coincidencia)

gramática:

${string/要替换的子串/替换为的字符串}

Ejemplo:

string="姓名：name,age:20,height:159cm,艺名：name"
replaced="${string/name/cxk}"  # 替换第一个 "name" 为 "cxk"
echo "$replaced"  # 输出 "姓名：cxk,age:20,height:159cm,艺名：name"

Insertar descripción de la imagen aquí

6.1.8 Reemplazo de cadenas (coincidir con todas)

gramática:

${string//要替换的子串/替换为的字符串}

Ejemplo:

string="姓名：name,age:20,height:159cm,艺名：name"
replaced="${string//name/cxk}"  # 替换所有的 "apples" 为 "bananas"
echo "$replaced"  # 输出 "I love bananas, bananas are great!"

Insertar descripción de la imagen aquí

6.1.9 Extraer coincidencia de subcadenas

gramática:

[[ $string =~ 正则表达式 ]]
匹配结果：${
    
    BASH_REMATCH[n]}

Ejemplo:

string="我的邮箱 [email protected]"
# 使用正则表达式来匹配字符串中的邮箱地址，并将匹配结果存储在`BASH_REMATCH`数组中，然后提取出匹配的邮箱地
if [[ $string =~ [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{
    
    2,4} ]]; then
    email="${
     
     BASH_REMATCH[0]}"
    echo "匹配到的邮箱地址是：$email"
fi

Insertar descripción de la imagen aquí

6.2 Expresiones regulares y comodines

6.2.1 La diferencia entre expresiones regulares y comodines

  1. Expresiones regulares :

    • Las expresiones regulares son una herramienta poderosa 模式匹配para hacer coincidir cadenas de texto según patrones. Es una coincidencia de inclusión, por lo que puede coincidir en cualquier parte de la cadena.
    • En Linux, comandos como grep, etc. suelen admitir expresiones regulares awk. sedPuede utilizar expresiones regulares para buscar, reemplazar, filtrar texto y más.
    • La rica sintaxis de las expresiones regulares le permite realizar operaciones de texto avanzadas como capturar, agrupar, repetir coincidencias, etc.

    Ejemplo:

    • Úselo greppara buscar todas las filas que contienen números:grep '[0-9]' file.txt

  2. Comodín :

    • Los comodines se utilizan para hacer coincidir los nombres de los archivos. Es una coincidencia exacta que solo coincide con nombres de archivos que coinciden con un patrón específico, independientemente del contenido del archivo.
    • En Linux, comandos como ls, findetc. cpnormalmente admiten comodines. Los caracteres comodín se utilizan para buscar o manipular archivos, no el texto dentro de los archivos.
    • Los caracteres comodín incluyen *(coincidir con cero o más caracteres), ?(coincidir con un carácter), [...](coincidir con un rango de caracteres), etc.

    Ejemplo:

    • Úselo para lsenumerar todos .txtlos archivos que terminan con:ls *.txt

Resumir:

  • Las expresiones regulares se utilizan para el procesamiento de texto y admiten operaciones y coincidencias más avanzadas.
  • Los comodines se utilizan para hacer coincidir nombres de archivos y son una herramienta básica de selección de archivos.

6.2.2 Expresiones regulares de uso común

Patrón de expresión regular describir Ejemplo de uso
^pattern Coincide con patternlíneas que comienzan con . grep '^Error' file.txtHaga coincidir líneas que comiencen con "Error".
pattern$ Coincide con patternlíneas que terminan en. grep 'end$' file.txtCoincide con líneas que terminan en "end".
. Coincide con cualquier carácter excepto nueva línea. grep 'a.b' file.txtCoincide con "aab", "axb", etc.
* Coincide con cero o más instancias del carácter o subexpresión anterior. grep 'go*gle' file.txtCoincide con "ggle", "google", "google", etc.
+ Coincide con una o más instancias del carácter o subexpresión anterior. grep 'go+gle' file.txtCoincide con "google", "google", etc., pero no con "ggle".
? Coincide con cero o una instancia del carácter o subexpresión anterior. grep 'colou?r' file.txtCoincide con "color" y "color".
[abc] Coincide con cualquier carácter del conjunto de caracteres. grep '[aeiou]' file.txtCoincide con líneas que contienen vocales.
[0-9] Coincide con cualquier número. grep '[0-9]' file.txtCoincide con líneas que contienen números.
[^abc] Coincide con cualquier carácter que no esté en el conjunto de caracteres. grep '[^0-9]' file.txtCoincide con líneas que no contienen números.
\d Coincide con cualquier carácter numérico, equivalente a [0-9]. grep '\d' file.txtCoincide con líneas que contienen números.
\D Coincide con cualquier carácter no numérico, equivalente a [^0-9]. grep '\D' file.txtCoincide con líneas que no contienen números.
\w Coincide con cualquier carácter de una sola palabra (letra, número o guión bajo), equivalente a [a-zA-Z0-9_]. grep '\w' file.txtCoincide con líneas que contienen caracteres de palabras.
\W Coincide con cualquier carácter que no sea una palabra, equivalente a [^a-zA-Z0-9_]. grep '\W' file.txtCoincide con líneas que no contienen caracteres de palabras.
\s Coincide con cualquier carácter de espacio en blanco (espacio, tabulación, nueva línea, etc.). grep '\s' file.txtCoincide con líneas que contienen espacios en blanco.
\S Coincide con cualquier carácter que no sea un espacio en blanco. grep '\S' file.txtCoincide con líneas que no contienen espacios en blanco.
(pattern) Cree un grupo de captura que capture texto coincidente. grep 'a\(bc\)*d' file.txtCoincide con "ad", "abcd", "abcbcd", etc.
` ` Operador lógico OR, coincide con cualquiera de los dos patrones.
.* Coincide con cero o más caracteres arbitrarios, normalmente una línea completa de texto. grep '.*pattern.*' file.txtCoincide con líneas que contienen "patrón".

6.3 Comandos de interceptación, reemplazo y procesamiento de personajes

6.3.1 comando de corte

cut命令用于从文本行中剪切或提取字段。默认情况下，cut使用制表符（Tab）作为字段分隔符，但可以通过-d选项指定其他分隔符。它通常用于提取或删除文本文件中的特定列。

基本用法：

cut [OPTIONS] [FILE]

  • 剪切文件中的第2列：

    cut -f2 input.txt

    Insertar descripción de la imagen aquí

  • 使用逗号作为分隔符剪切第1和第3列：

    cut -d',' -f1,3 input.csv

    Insertar descripción de la imagen aquí

  • 以特定字符作为字段分隔符，剪切第1列：

    cut -d',' -f1 /etc/passwd

    Insertar descripción de la imagen aquí

  • 剪切每行的前5个字符：

    cut -c1-5 input.txt

    Insertar descripción de la imagen aquí

6.3.2 awk命令

awk是一个强大的文本处理工具，它可以执行复杂的文本处理操作，包括文本提取、计算、条件筛选等。awk将文本分割成字段，并允许对字段进行操作。它的灵活性使其成为处理结构化文本数据的理想工具。

基本用法：

awk 'pattern { action }' [FILE]

  • 显示文件的第2列和第3列：

    awk '{print $2, $3}' input.txt

    Insertar descripción de la imagen aquí

  • 计算文件中所有数字的总和：

    awk '{ sum += $1 } END { print sum }' input.txt

    Insertar descripción de la imagen aquí

  • 使用逗号作为分隔符，打印第1列和第3列：

    awk -F',' '{print $1, $3}' input.csv

    Insertar descripción de la imagen aquí

  • 打印包含特定模式的行：

        awk '/pattern/ {print}' input.txt

    Insertar descripción de la imagen aquí

6.3.3 sed命令

sed（流编辑器）用于对文本进行基本的编辑和转换，如替换、删除、插入和替换。sed可以通过正则表达式来匹配和操作文本，通常在管道中与其他命令一起使用。

基本用法：

sed [OPTIONS] 's/pattern/replacement/' [FILE]

  • 替换文本文件中的所有"old"为"new"：

    sed 's/old/new/g' input.txt

    Insertar descripción de la imagen aquí

  • 删除包含特定字符串的行：

    sed '/pattern/d' input.txt

    Insertar descripción de la imagen aquí

  • 在每行的开头插入文本：

    sed 's/^/Prefix /' input.txt

    Insertar descripción de la imagen aquí

  • 将文件中的所有字母转换为大写：

    sed 's/[a-z]/\U&/g' input.txt

    Insertar descripción de la imagen aquí

6.4 sort、uniq、wc 命令

sort、uniq和wc是在Linux和Unix系统上常用的命令，用于排序、去重和统计文本数据。

6.4.1 sort命令

sort命令用于对文本文件的行进行排序。默认情况下，它按照字典顺序对文本行进行排序，但可以使用不同的选项来进行数字排序、逆序排序等。

基本用法：

sort [OPTIONS] [FILE]

  • 对文件进行排序并将结果输出到标准输出：

    sort input.txt

    Insertar descripción de la imagen aquí

  • 对文件进行数字排序（例如，按数值大小而不是字典顺序）：

    sort -n input.txt

    Insertar descripción de la imagen aquí

  • 对文件进行逆序排序：

    sort -r input.txt

    Insertar descripción de la imagen aquí

6.4.2 uniq命令

uniq命令用于从已排序的文本数据中去重重复的行。它通常与sort命令结合使用，以确保重复行相邻。

基本用法：

uniq [OPTIONS] [FILE]

  • 从文件中去重重复的行：

    sort input.txt | uniq

    Insertar descripción de la imagen aquí

  • 显示去重后的行以及它们重复的次数：

    sort input.txt | uniq -c

    Insertar descripción de la imagen aquí

6.4.3 wc命令

wc命令用于统计文本文件的行数、字数和字符数。

基本用法：

wc [OPTIONS] [FILE]

  • 统计文件的行数、单词数和字符数：

    wc input.txt

    Insertar descripción de la imagen aquí

  • 仅统计行数：

    wc -l input.txt

    Insertar descripción de la imagen aquí

  • 仅统计单词数：

    wc -w input.txt

    Insertar descripción de la imagen aquí

  • 仅统计字符数：

    wc -c input.txt

    Insertar descripción de la imagen aquí

6.5 管道（Pipeline）

管道（Pipeline）是在Unix和类Unix操作系统中广泛使用的强大工具，它允许将一个命令的输出直接传递给另一个命令，以便进行复杂的数据处理和筛选。

管道（Pipeline）语法：

command1 | command2
  • command1：第一个命令的输出将被传递给第二个命令。
  • command2：接收来自command1的输入并进行处理的第二个命令。

6.6 grep命令

grep命令用于在文本中搜索匹配指定模式的行

grep命令语法：

grep [选项] 模式 [文件...]
  • 选项：可以是一些可选的标志，用于控制搜索的行为。
  • 模式：要搜索的文本模式或正则表达式。
  • 文件：要在其中搜索模式的一个或多个文件。如果省略文件参数，则grep将从标准输入中读取数据。
  1. 搜索文件中包含特定字符串的行：
grep "search_term" filename.txt
  1. 搜索多个文件中包含特定字符串的行：
grep "search_term" file1.txt file2.txt
  1. 搜索目录中所有文件包含特定字符串的行：
grep "search_term" /path/to/directory/*
  1. 搜索多个文件并显示匹配行的行号：
grep -n "search_term" file1.txt file2.txt
  1. 忽略大小写进行搜索：
grep -i "search_term" filename.txt
  1. 使用正则表达式进行高级搜索（例如，查找以"abc"开头的行）：
grep "^abc" filename.txt
  1. 逆向搜索，即只显示不匹配模式的行：
grep -v "search_term" filename.txt
  1. 递归搜索目录中的文件：
grep -r "search_term" /path/to/directory/
  1. 搜索匹配模式的行并统计匹配的次数：
grep -c "search_term" filename.txt

7. 输入输出重定向

7.1 Linux标准输入

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

7.2 输入重定向

类型 符号（语法） 功能
标准输入 命令 < 文件1 命令将文件1的内容作为标准输入设备
标识符限定输入 命令 << 标识符 命令将标准输入中读入内容，直到遇到“标识符”分隔符为止
输入输出重定向 命令 < 文件1 > 文件2 命令将文件1的内容作为标准输入，将文件2作为标准输出。

7.3 输出重定向

类型 符号 作用
Redirección de salida estándar (anulación) Comando > Archivo En modo de sobrescritura, envíe el contenido de salida correcto del comando al archivo o dispositivo especificado
Redirección de salida estándar (añadir) Comando>>Archivo En el modo de agregar, envíe el contenido de salida correcto del comando al archivo o dispositivo especificado
Redirección de salida de error estándar (anulación) Comando de error 2> Archivo Envía la salida de error del comando al archivo o dispositivo especificado en modo de sobrescritura
Redirección de salida de error estándar (añadir) Comando de error 2 >> archivo En el modo de agregar, envíe la salida de error del comando al archivo o dispositivo especificado
Guarde tanto stdout como stderr (sobrescribir) Comando>Archivo2>&1 En modo superposición, guarde la salida correcta y la de error en el mismo archivo
Guarde tanto la salida estándar como la salida de error estándar (adjuntar) Comando>>Archivo2>&1 En el modo de agregar, guarde tanto la salida correcta como la salida de error en el mismo archivo
Guarde tanto stdout como stderr (sobrescribir) Comando&>Archivo En modo superposición, guarde la salida correcta y la de error en el mismo archivo
Guarde tanto la salida estándar como la salida de error estándar (adjuntar) Comando &>> Archivo En el modo de agregar, guarde tanto la salida correcta como la salida de error en el mismo archivo
Guarde la salida correcta y la salida de error por separado Comando > Archivo 1 2 > Archivo 2 Guarde la salida correcta en el archivo 1 y la salida de error en el archivo 2

7.4 /dev/nulo

Si desea ejecutar un comando sin mostrar el resultado en la pantalla, puede /dev/nulldescartar el resultado por completo redirigiéndolo a un archivo.

Ejemplo:

command > /dev/null

Este comando redirige la salida estándar del comando a /dev/nullun archivo, descartando la salida por completo.

Supongo que te gusta

Origin blog.csdn.net/qq_29864051/article/details/132650005
Recomendado
Clasificación
Diario
Más
2024-06-02(0)
2024-06-01(2)
2024-05-31(0)
2024-05-30(0)
2024-05-29(1)
2024-05-28(0)
2024-05-27(1)
2024-05-26(1)
2024-05-25(0)
2024-05-24(13)

Code World

© 2018 codetd.com