Prototipo de paréntesis variable entre paréntesis y explicación de transferencia en shell
Tirantes y paréntesis en el caparazón
2009-07-23
http://blog.sina.com.cn/s/blog_4a2a29f00100o2os.html
Lo que quiero decir aquí son los paréntesis, la estructura de llaves y las variables con corchetes en varios shells. El uso del comando es el siguiente:
1. $ {Var}
2. $ (Cmd) También hay $ ((var)), ver 5;
3. () y {}
4. $ {Var: -string}, $ {var: + string} , $ {var: = string}, $ {var :? string}
5. $ ((exp))
6. $ (var% pattern), $ (var %% pattern), $ (var # pattern), $ ( var ## patrón)
Ahora se describe de la siguiente manera:
1. La forma original de las variables en Shell: $ {var} Cada
forma de variable común es $ var, como
$ var = prueba
$ echo $ var
prueba
Pero cuando desea mostrar el valor de la variable más caracteres aleatorios (uso AA aquí), se produce un error, de la siguiente manera:
$ echo $ varAA
$
En este momento, se debe usar la forma original de la variable: $ {var}, que es agregar una llave para limitar el alcance del nombre de la variable, de la siguiente manera
$ echo $ {var} AA
testAA
$
Con esta función, podemos fácilmente Escriba un programa para cambiar el sufijo en lotes, lo llamé mymv, el programa es el siguiente:
! / bin / bash
tail = $ 1
para el nombre de archivo en ls
do
mv $ filename $ {filename}. El programa $ tail
done
debe proporcionar un nombre de sufijo, como c, significa cambiar el archivo de programa C con el sufijo c, consulte la siguiente prueba:
$ ls
abc
$ mymv c
$ ls
ac bc cc
$
Parece que el programa se está ejecutando muy bien, pero este es un programa imperfecto, hay dos problemas a tener en cuenta:
A, no hay subdirectorio debajo del directorio, si hay un directorio, suponiendo dir, también lo hará Se cambió a dir.c, que obviamente no es lo que queremos, y el programa debería revisarse para reconocer el directorio.
B. No hay ayuda para procesar los parámetros del programa. El programa debe ser lo suficientemente amigable. Si el usuario no da un sufijo, debería ser capaz de manejarlo. Al igual que lo anterior, se agregará un punto (.) Directamente al archivo, que obviamente no es lo que queremos. Querer
Debido a que nuestro propósito es explicar $ {var}, esto es suficiente, por lo que el programa anterior no se revisará aquí.
2. Reemplazo de comando $ (cmd)
Reemplazo de comando $ (cmd) y símbolos cmd(tenga en cuenta que no se trata de comillas simples, en el teclado estadounidense, 是ESC下面的那个键)有相同之处 $ ls a b c $ echo $(ls) a b c $ echo ls`
abc
analicemos el comando echo $ (ls), para comprender qué se entiende por reemplazo de comando : El
shell escanea la línea de comando una vez y encuentra la estructura $ (cmd), y ejecuta el cmd en $ (cmd) una vez para obtener su salida estándar, y luego coloca esta salida en $ (ls en el comando original echo $ (ls) ) Posición, es decir, reemplace $ (ls), y luego ejecute el comando echo.
De la siguiente manera:
echo $ (ls) se reemplaza por echo abc
. Debe notarse aquí que la salida de error del comando en $ (cmd) no será reemplazada. , Solo se reemplaza la salida estándar:
$ var = $ (cat d) ### El archivo d no existe en el directorio actual
cat: d: no hay archivo o directorio
$ echo $ var
$ ### Obviamente, el valor de la variable var está vacío
$ ((var)), "$" más dos paréntesis es el significado del valor, los corchetes se usan como cálculos numéricos para operar;
...
línea = $ (($ línea-3));
awk -va = $ línea 'NR == a {print}' $ nombre de archivo >> network_test_result_more_7.txt;
percent_1_2 = $ (((($ total_1_2) * 100) / ($ total_check)));
3. Una serie de comandos de ejecución () y {}
() y {} se ejecutan en una serie de comandos, pero hay diferencias:
A, () es solo para volver a abrir una subshell para ejecutar una serie de comandos (mismo nombre Las variables en el proceso primario y el proceso secundario tienen espacios diferentes, que no interfieren entre sí.
B, {} Ejecutar una cadena de comandos en el shell actual (las variables con el mismo nombre comparten el mismo espacio de almacenamiento. Usando esta función, puede cambiar el shell actual Las variables en el proceso se pasan a la función)
C, () y {} ponen una serie de comandos entre paréntesis, y usan a; entre los comandos;
D, (), el último comando no puede usar un punto y coma
E, {} El último comando debe usar un punto y coma
F, debe haber un espacio
G entre el primer comando de {} y el corchete izquierdo, cada comando en () no necesita tener un espacio
H entre los corchetes , () y los corchetes en {} La redirección de un comando solo afecta al comando, pero la redirección fuera de los paréntesis afecta a todos los comandos entre paréntesis.
Veamos algunos ejemplos:
$ var = test
$ (var = notest; echo $ var) ### Variable valor var recorres, esto es eficaz en el sub-shell
recorres
var eco shell padre $ $ ### sigue siendo la mediana de prueba
Prueba de
$ {var = recorres; echo $ var;} ### Tenga en cuenta que debe haber un espacio entre el paréntesis izquierdo y
varnotest
$ echo $ var ### El valor de la variable var en el shell principal se convierte en notest
notest
$ {var1 = test1; var2 = test2; echo $ var1> a; echo $ var2;} ### La prueba de salida1 se redirige al archivo a,
test2 ### y la salida de test2 todavía se envía a la salida estándar.
Un CAT $
test1
$ {var1 = prueba1; var2 = test2; echo $ var1; echo $ var2;} comando en una salida estándar> a ### se redirige a un archivo de todos los soportes en un
$ CAT
test1
test2
siguiente es una Ejemplo de paso:
(
echo "1"
echo "2"
) | awk '{print NR, $ 0}'
4. Varias estructuras de reemplazo especiales: $ {var: -string}, $ {var: + string}, $ {var: = string}, $ {var :? String}
A, $ {var: -string} y $ {var: = string} (Para ver si la variable var está vacía, reemplace $ {var: -string} con string si está vacía, y reemplace $ {var: -string} con la variable var si no está vacía)
Si la variable var Si está vacío, use una cadena para reemplazar $ {var: -string} en la línea de comando; de lo contrario, cuando la variable var no esté vacía, reemplace $ {var: -string} con el valor de la variable var,
como:
$ echo newvar
$ echo $ {newvar: -a}
a
$ echo newvar ### El valor de la variable newvar todavía está vacío, pero en la última línea de comando, $ {newvar: -a} fue reemplazado por
$ newvar = b
$ echo $ {newvar : -a} ### Cuando el valor de la variable newvar no está vacío, $ {newvar: -b} en esta línea de comando se reemplaza por $ newvar, es decir, b
b
$
para $ {var: = string} $ {var: -string} es lo mismo, la diferencia es que si $ {var: = string} está vacío, reemplace $ {var: = string} con string y asigne string a la variable var:
$ echo newvar
$ echo $ {newvar: = a}
a
$ echo newvar ### La variable newvar se asigna a a, y $ {newvar: = a} se reemplaza por a
a
$ echo $ {newvar: = b} ## # Newvar variable no está vacío (su valor se ha asignado a a), luego $ {newvar: = b} se reemplaza por el valor de newvar (es decir, b)
a
$ echo $ newvar
a
$ {var: = string} se usa comúnmente Un uso es determinar si a una variable se le asigna un valor, y si no, asignarle un valor predeterminado.
Por ejemplo, para configurar el editor predeterminado:
código PHP:
echo. Usted usa el editor: $ {EDITOR: = / bin / vi}
B,
$ {var: + string} La regla de reemplazo de $ {var: + string} es lo opuesto a lo anterior, es decir Solo cuando var no está vacío, se reemplaza con string. Si var está vacío, no se reemplaza o reemplaza con el valor de la variable var, que es el valor nulo. (Debido a que la variable var está vacía en este momento, estas dos declaraciones son equivalentes)
$ echo $ newvar
a
$ echo $ {newvar: + b}
b
$ echo $ newvar
a
$ newvar =
$ echo $ {newvar: + b }
$
C, $ {var :? Cadena}
La regla de reemplazo es: si la variable var no está vacía, reemplace $ {var :? String} con el valor de la variable var; si la variable var está vacía, envíe la cadena al error estándar y salga del script. Podemos usar esta función para verificar si el valor de la variable está configurado.
$ newvar =
$ echo $ {newvar:? el valor de newvar no está configurado}
bash: newvar: el valor de newvar no está configurado
$ newvar = a
$ echo $ {newvar:? el valor de newvar no está configurado}
una extensión suplementaria
$
: por encima de esto En las cinco estructuras de reemplazo, la cadena no es necesariamente constante y se puede usar el valor de otra variable o la salida de un comando.
$ echo $ {var: - date}
6 de marzo 02:10:39 CST 2005
$ echo $ {var: - $ (fecha)}
6 de marzo 02:11:46 CST 2005
$ a = prueba
$ echo $ { var: - $ a}
prueba
$
5. Cálculo extendido estándar POSIX: $ ((exp))
Este cálculo es un operador que se ajusta al lenguaje C, es decir, siempre que el operador que se ajuste a C se pueda usar en $ ((exp)), incluso el operador trinocular .
Nota: Este cálculo extendido es un cálculo entero y no admite el tipo de punto flotante. Si es un juicio lógico, la expresión exp es verdadera, es 1 y falsa es 0.
$ echo $ ((3 + 2))
5
$ echo $ ((3> 2))
1
$ echo $ ((25 <3? 2: 3))
3
$ echo $ var
$ echo $ ((var = 2 + 3))
5
$ echo $ var
5
$ echo $ ((var ++))
5
$ echo $ var
6
$
Ok, el ejemplo anterior es suficiente, lo que también muestra que esta operación extendida es muy poderosa.
6. Cuatro estructuras de reemplazo de coincidencia de patrones: $ {var% pattern}, $ {var %% pattern}, $ {var # pattern}, $ {var ## pattern}
El significado de estas cuatro estructuras es: $ {var% pattern} y $ {var %% pattern} coinciden desde el extremo derecho (es decir, el final), y $ {var # pattern} y $ {var ## pattern} coinciden desde el extremo izquierdo (es decir, el principio). Entre ellos, $ {var% pattern} y $ {var # pattern} son las coincidencias más cortas, y $ {var %% pattern} y $ {var ## pattern} son las coincidencias más largas. Solo cuando se usan comodines en el patrón puede haber la coincidencia más larga y más corta, de lo contrario no hay una coincidencia más larga y más corta.
El patrón en la estructura admite comodines, lo que significa cero o más caracteres arbitrarios, significa cero o uno caracteres arbitrarios, [...] significa que coinciden los caracteres dentro de los corchetes, [! ...] significa que no coinciden dentro de los corchetes Carácter
$ var = aabbbccbbdbb
$ echo $ {var% b}
aabbbccbbdb
$ echo $ {var %% b}
aabbbccbbdb
$ echo $ {var # a}
abbbccbbdbb
$ echo $ {var ## a}
abbbccbbdbb
$ echo $ {var% b}
aabbbccbbdb
$ echo $ {var %% b}
$ echo $ {var # a }
abbbccbbdbb
$ echo ${var##a*}
$