Teoria de Bash

0. Índex

1. Coses que se li passen a la majoria de la gent
2. Estructura d'un script
3. Imprimir a la pantalla
4. Llegir l'INPUT de l'usuari
5. Càlculs en Bash
6. Condicions
7. bucles
8. Funcions
9. Getops

1. Coses que se li passen a la majoria de la gent

/ Bin / bash o / bin / sh

Una de les primeres coses que fa la màquina a l'executar el nostre script és mirar amb quina shell ha de fer. En la majoria dels sistemes linux actuals / bin / sh és un enllaç a / Bin / bash, Però no sempre és així, per exemple en les distribucions que utilitzen BusyBox Porten Sh i normalment també porten xoc, Però si s'utilitza / bin / sh, No s'executarà amb Bash. Per això recomano utilitzar sempre / Bin / bash.

Unicode vs ASCII

Us heu preguntat per què no podeu utilitzar «» o «ñ» en els vostres scripts? O utilitzar accents? Pot arribar a ser bastant molest en scripts interactius. Això és perquè la codificació per defecte de Bash és ASCII, o el que és el mateix, el set de caràcters de l'anglès. Per canviar només hem de indicar-li al nostre script que volem utilitzar Unicode. Per això cal afegir una línia just després de l'intèrpret d'ordres:

# - * - ENCODING: UTF-8 - * -

Ull, és important que aquesta línia estigui a el principi de l'script.

Fer el script executable

És curiós la quantitat de gent que executa els scripts amb «$ Bash script.sh»En lloc de«$ ./script.sh»A la fi i al el cap és per a això que hem definit un intèrpret d'ordres.

Per afegir permisos d'execució cal executar:

suo + x script.sh

BIN = "carpeta on tinguem els scripts" PATH = "$ BIN $ PATH"

2. Estructura d'un script

1. Capçalera
2. Definició de variables globals
3. Ajuda
4. Funcions
5. Cos principal

La capçalera és on s'indica quin shell volem utilitzar i la codificació. L'avantatge de les funcions és reutilitzar codi que es repeteix escrivint una sola vegada i fer més fàcil l'enteniment de l'script, per codi que supera les 100 línies és molt útil.

Per poder utilitzar funcions, aquestes han d'estar definides amb abans de el cos principal del nostre script. I si volem utilitzar variables a nivell global de tot el nostre script, tant en el cos principal com a les funcions, hem de definir-les a el principi de tot, just després de la capçalera.

Finalment, és de bona pràctica escriure una funció d'ajuda per quan el nostre script s'executi malament o amb mals paràmetres. Òbviament, és aquests casos volem sortir de l'script immediatament, sense llegir les funcions. Per això podem utilitzar:

function help () {echo "" "El nostre text d'ajuda bé formatat." "" exit if [[-z $ 1 || $ 1 == "-h" || $ 1 == "--help"]]; then help fi

Si afegim «exit» a la funció d'ajuda, sortirem de l'script cada vegada que executem ajuda, per exemple després de missatges d'errors, etc. Ens estalviem un parell de línies de codi.

La condició indica mostrar ajuda en pantalla i sortir si s'executa l'script sense paràmetres o si s'indica -h / -help. Si us fixeu aquest és el comportament estàndard de la majoria de programes linux.

3. Imprimeix a pantalla

Ha 2 comandaments principals per imprimir en pantalla en bash: «trobo»i«imprimirf«. Els dos són igual de ràpids i els dos formen part de bash. La principal diferència per a un principiant és que trobo afegeix un salt de línia a al final, mentre que «imprimirf»No ho fa.

Trobo està molt bé i és el que fa servir la majoria de la gent, però quan es llegeixen l'INPUT de l'usuari, o quan es volen imprimir variables tretes d'arxius mitjançant processat de text, poden passar coses rares. Normalment es solucionen fàcilment, tan fàcil com canviar les dobles cometes a simples o viceversa, o treure les referències a variables fora de les cometes. «ressò»Fa coses rares també depenent de com s'ha compilat, si utilitzem sempre Ubuntu o sempre Fedora, no ens afecta, però si canviem de distribució si.

Per això utilitzo «imprimirf«, Que no em dóna mals de cap ia més es comporta més com el«imprimirf»De C o el«imprimir»De Python, això és molt important si algun dia voleu portar el vostre script a un altre llenguatge de programació.

4. Llegir l'INPUT de l'usuari

Tot el que escrivim després de el nom del nostre script i abans de donar-li a la tecla de retorn queda automàticament guardat en unes variables especials. Aquestes variables són de tipus $ X on la X és un nombre.

«$0»Indica el nom del nostre script i des de«$1»Fins a l'infinit són variables tot el que hem escrit després. Per exemple:

cat << EOF >> test.sh #! / bin / bash # - * - ENCODING: UTF-8 - * - printf "\ $ 0 = $ 0 \ n" printf "\ $ 1 = $ 1 \ n" printf "\ $ 2 = $ 2 \ n "EOF chmod + x script.sh ./script.sh meu fitxer.txt

Creem un script de prova, ho fem executable i l'executem amb 2 paràmetres. Obtenim la sortida en pantalla de:

$ 0 = ./script.sh $ 1 = la meva $ 2 = fitxer.txt

Utilitzant cometes podríem haver passat «el meu fitxer.txt" a "$ 1».

També podem llegir l'INPUT d'un usuari amb la comanda «read», indicant directament la variable on vulguem guardar el paràmetre. Per exemple:

printf "Com et dius? \ n" read NOM printf "Hola, $ NOM. \ n"

5. Càlculs en Bash

Per això podem utilitzar «expressar«, Sempre que no necessitem fer cáclculos complexos. Cal destacar dues coses, la primera és que «expressar»Només admet nombres enters, la segona és que la divisió retorna el resultat sencer, per veure la resta podem utilitzar«%".

Normalment voldrem assignar el resultat d'expr a una variable. Això ho podrem fer de dues formes:

Var2 = `expr $ VAR1 / 10` var2 = $ (expr $ VAR1 / 100)

També es pot obviar «expressar»Utilitzant doble parèntesi:

Var2 = $ (($ VAR1 / 100))

6. condicions

S'ha escrit ja d'una manera molt extensa sobre «if","else","elif»I les condicions. Podeu llegir sobre això a:

• Programant en Bash: part 1
• Bash: condicions if, then, else
• Comprovar si un arxiu o carpeta existeix o no i mes amb un cicle if
• Programant en Bash: part 2

Només vull destacar la diferència entre l'ús de simples claudàtors, «[]«, I dobles claudàtors,«[[]]«, Per a la condicions. Amb dobles claudàtors podem utilitzar condicions addicionals:

• «&&»Per i
• «||»Per o

Per utilitzar «&&»i«||»Amb simples claudàtors caldria separar cada part entre claudàtors separats. L'exemple utilitzat per la part de l'script que mira si cal executar ajuda quedaria:

if [-z "$ 1"] || [ "$ 1" == "-h"] || [ "$ 1" == "--help"]]; then help fi

També ens evita el haver d'escriure els noms de variables dins de cometes per prevenir errors. Per exemple:

if [$ 1 = 1]; then printf "El paràmetre és igual a 1."; fi if [ "$ 1" = 1]; then printf "El paràmetre és igual a 1."; fi if [[$ 1 = 1]]; then printf "El paràmetre és igual a 1."; fi

Si s'executa script.sh sense cap paràmetre, el primer cas donaria un error:

bash: [: =: s'esperava un operador unari

Del que no s'ha parlat és de «cas«, Que s'utilitza per simplificar«if«. Comencem pel principi, quan no tenim cap «if»S'executarà tot el codi. Si afegim una condició «if»Tindrem dos casos, un en què s'executa el bloc de codi que està dins de l'«if»I l'altre cas on no s'executa aquest bloc.

Si afegim un «else«, També tindrem dues casos, però aquests dos casos són diferents als anteriors. Perquè ara hi haurà dos blocs de codi condicionals, A i B, i un bloc C, que és la resta de el programa. S'executarà A o B, i C. En el cas anterior era A i C o només C.

Per evitar escriure condicions «if / else»Dins«else»I simplificar la lectura d'el codi, es va crear«elif«. Quan tenim moltes condicions que depenen de l'anterior, per exemple rang de nombres o de l'tipus:

VAR1 = $ 1 if [[$ VAR1 = 1]]; then printf "1 \ n" elif [[$ VAR1 = 2]]; then printf "2 \ n" elif [[$ VAR1 = 3]]; then printf "3 \ n" else printf "cap \ n" fi

En el cas de l'últim «elif»Es llegiran moltes condicions. Amb casi s'agilitza aquest procés:

VAR1 = $ 1 casi $ VAR in 1) printf "1 \ n" ;; 2) printf "2 \ n" ;; 3 | 4) printf "3 o 4, depèn \ n" ;; *) Printf "cap \ n" ;; esac

Es llegirà una variable, en aquest cas VAR1, i es mirarà si equival a algun dels casos, si no, s'executarà el cas per defecte «*». Els dobles punt i coma equivalen a «trencar«, Li indiquen a«cas»Que ha d'acabar.

7. Bucles

Són molt pocs els bucles a saber-se en qualsevol llenguatge de programació. En Bash són «mentre","fins»i«for«. S'ha escrit ja al blog sobre aquests:

• Programant en Bash: part 1
• Programant en Bash: part2

Hi ha dos tipus de bucles «for«, Els que són de l'tipus«$ For VAR in loquesea»I el que són de l'tipus C«$ For ((I = 0; I <= 10; I ++))«. El segon tipus de bucles «for»Són molt útils, té 3 parts en l'inici de l'bucle:

• Declaració i iniciació de variables (En aquest cas una variable auxiliar «I = 0»).
• Condició d'execució (fins que I sigui menor o igual que 10).
• Increment de la variable auxiliar

Al meu entendre és el bucle més potent de tots. Un exemple, que imprimeix tots els números des del 0 fins al 10, ambdós inclosos:

#! / Bin / bash for ((I = 0; I <= 10; I ++)); do printf "$ I \ n" done

8. Funcions

Hi ha algunes coses que Bash no ens permet fer, o si? En un primer cop d'ull, les funcions de bash impedeixen fer 3 coses: declarar variables locals en les funcions, passar-li paràmetres a les funcions i retornar paràmetres. Tot té solució.

No fer res per l'estil de:

#! / Bin / bash VAR = 1 printc "$ VAR \ n" function hola () {VAR = 2 printf "$ VAR \ n"} hola printf "$ VAR \ n"

Això imprimeix en pantalla 1, 2 i 2.

Per declarar variables locals hi afegir «local»Quan es declara:

#! / Bin / bash VAR = 1 printf "$ VAR1 \ n" function foo () {local VAR1 = 2 printf "$ VAR1 \ n"} printf "$ VAR1 \ n" foo printf "$ VAR1 \ n"

Això imprimeix en pantalla 1, 1, 2, 1.

Com se li passen paràmetres a una funció?

#! / Bin / bash # - * - ENCODING: UTF-8 - * - function hola () {printf "Hola $ 1 \ n"}

printf «Com et dius? \ n»
read VAR1
hola $ VAR1

Com es tornen paràmetres?

#! / Bin / bash # - * - ENCODING: UTF-8 - * - function hola () {printf "Hola holita"} printf "Com et dius? \ N" read VAR1 VAR1 = $ (hola) # AQUI ESTÀ printf "$ VAR1 $ var2 \ n"

Com veieu això té dues pegues, només es pot tornar un paràmetre, que pot ser un vector 😀, i si es vol tornar un paràmetre, ja no es pot imprimir en pantalla des d'aquesta funció.

9. Getops

Una de les últimes coses de Bash que cal conèixer per crear scripts complexos és «getops«. Serveix per passar opcions a l'script sense importar l'ordre. L'única pega és que només afecta opcions curtes:

#! / Bin / bash # - * - ENCODING: UTF-8 - * - VARC = 0 function help () {printf "Missatge d'ajuda \ n" exit} if [[-z $ 1]]; then help fi while getopts: ha: b: c OPT; do casi $ OPT in h) help ;; :) help ;; a) VARA = $ OPTARG ;; b) VARB = $ OPTARG ;; c) VARC = 1 ;; \?) Help ;; esac done # Bloc principal de l'script que # fa coses amb VARA, VARB i VARC

«Getopts»Llegeix les opcions una a una, per això es necessita d'un bucle.

Hi ha 2 tipus d'opcions que es poden passar usant «getopts":

• Els paràmetres anomenats flags, en aquest cas -co -h. S'especifiquen amb la lletra que vulguem utilitzar. Són com a variables booleanes, «veritable»(Estan) o«false»(No hi són).
• Paràmetres amb arguments associats, -a Cualquiercosa, -b Cualquiercosa. S'especifiquen amb la lletra que vulguem amb dos punts a continuació. L'argument és guardat en OPTARG (aquest nom és inalterable).

Què fa aquest script?

Mostra el missatge d'ajuda quan no es passa cap opció, quan es passa el paràmetre «-h», quan es passa un paràmetre no vàlid (per exemple «-x», això ho fa «\?») O quan es passa un paràmetre vàlid sense argument ( «:»). En la resta dels casos guarda la presència de «-c» com un 1 en VARC, i els valors passats amb «-a» i «-b» a VARA i VARB.