Sistema Operatiu Linux

Unitat: Programació del Shell

1- Creació de nous comandaments
2 - Paràmetres en els comandaments
3 - Utilitzar la sortida de programes com a paràmetres del nostre programa
4 - Variables de l'entorn

• Quan tenim una sèrie de comandaments que utilitzem sovint es convenient agrupar los sota un nom apropiat de forma que obtenim un nou comandament.
• Per exemple, si sovint volem contar els usuaris que estan connectats escriurem:

• Per crear un nou comandament equivalent primer de tot crearem un fitxer de text anomenat cu (de Contar Usuaris) que contingui l'ordre anterior:

• Observeu que les cometes són obligatòries. Què obtindríem si no les posem? En el fitxer cu quedaria el nombre d'usuaris connectats en comptes de l'ordre de comptar usuaris.
• Recordem ara que el shell és un programa que s'està executant, i el seu nom és bash (shell per defecte). Com és un programa, es pot executar i redireccionar la seva entrada.
• Per exemple, podem executar el shell redireccionant la seva entrada (que per defecte és el teclat) per tal de que sigui el fitxer cu:

El resultat serà el mateix que si haguéssim teclejat who | wc -l des del terminal.

• D'altre banda el shell admet paràmetres, igual que ho fan molts comandaments. Si escrivim:

obtindrem el mateix resultat, doncs bash pren la seva entrada d'un fitxer si se'l passa com a paràmetre.
• Per executar un fitxer de text que conté comandaments, com ara cu, tenim un altre alternativa que és convertir-lo en executable:

• Un fitxer executable que conté comandaments del shell s'anomena fitxer d'script del shell o abreviada ment script. Aleshores el podrem executar directament:

• Tal com ho tenim ara cu funcionarà només si està situat en el directori de l'usuari i si aquest directori està en la variable d'entorn PATH. Per fer que funcioni de forma general podem moure'l al nostre directori privat bin i després afegir el camí a la variable PATH:

• Els usuaris d'un script l'executen de la mateixa forma que els altres comandaments i per tant no tenen forma de saber que només conté una simple instrucció, en comptes de ser un complicat programa escrit en 'C'.
• La forma en que el shell executa un script és creant un nou procés de shell (un subshell) exactament igual que si escrivim $bash cu
• Per tant bash cu no és el mateix que bash < cu, malgrat el resultat sí ho sigui. En el segon cas no es crea cap subshell.

• La majoria de comandaments dels shell admeten paràmetres i opcions. Es interessant que els comandaments que nosaltres creem tinguin també aquesta possibilitat.
• Per exemple volem crear un comandament anomenat fx per fer que un fitxer sigui executable, de forma que sigui equivalent escriure:

a escriure:

• Necessitem un fitxer de text que contingui l'ordre chmod. Ja sabem com fer-ho això. El que no sabem és com indicar a fx quin serà el nom del fitxer que farem executable, doncs aquest serà diferent cada cop que executem fx.
• Quan shell executa un fitxer de comandaments, cada ocurrència de $1 es reemplaça per el primer paràmetre, cada ocurrència de $2 es reemplaça per el segon paràmetre, i així successivament fins el paràmetre $9.
• Per tant escriurem en el fitxer fx el text chmod +x $1. Veiem el següent exemple:

• Hi tenim també casos en que el nombre de paràmetres és variable, és a dir que de vegades no donarem cap paràmetre en utilitzar el comandament i d'altres en donarem un o més d'un. Per aquests casos tenim l'abreviatura $* que significa "tots els paràmetres". Podríem definir aleshores el comandament fx així:

• Exemple: definim el comandament cl per comptar les lineas d'un  o més d'un fitxer:

• La primera sentencia crea una línia de comentari en el fitxer cl, identificada per el prefix #. En la segona línia afegim (símbol >>) la instrucció de comptar líneas. En la tercera donem drets d'execució al fitxer cl i en l'ùltima el provem comptant les líneas de tots els fitxer del nostre directori bin. També funcionarà el següent exemple en el qual no usem cap paràmetre:

En aquest cas comptarà quants fitxers hi han en el directori /home/usuari/bin, doncs ls mostra els fitxers que hi han, els quals es prenen com a entrada del programa cl, el qual compta el nombre de lineas del fitxer d'entrada, és a dir, el nombre de fitxers que proporciona ls.

• El símbol $0 està reservat per el propi nom del programa en execució. Per exemple si afegim la següent línia al fitxer cl:

i l'executem, veurem que surt al final del nombre de lineas del fitxer la frase:

• També podem passar paràmetres que no siguin noms de fitxers. Per exemple considerem el fitxer agenda:

• Podem usar grep per buscar en ell.  Creem un comandament busca que cerca qualsevol nombre de textos en aquest fitxer i provem-lo:

• Ens trobem un problema a l'executar $ busca 'Pere Pages'  i es que s'interpreta com si haguéssim escrit $ grep Pere Pages /home/usuari/agenda  que està malament doncs pren Pages com un nom de fitxer. Això és així degut a l'espai en blanc que conté la cadena que busquem. Hauríem de passar tota la cadena 'Pere Pages'  com un únic paràmetre per a grep. La solució serà modificar el comandament busca:

• Ara el $* serà reemplaçat per els paràmetres com abans, però aquests es passaran a grep com un únic paràmetre malgrat tinguin espais en blanc.

PRÀCTICA: Creació de comandaments i pas de paràmetres
 

• La sortida de qualsevol programa pot utilitzar-se en un comandament tancant el programa amb cometes invertides (l'accent obert català: ` `).
• Exemple:

• Les cometes invertides poden anar també incloses dintre de les cometes dobles:

• Un altre exemple: volem enviar un mail a una llista d'usuaris els noms dels quals estan en un fitxer de text anomenat llista. El text del mail està en un altre fitxer anomenat carta. Podem fer-ho de la següent forma:

cat mostra el contingut del fitxer llista, és a dir la llista de noms, que es converteixen en paràmetres per a mail gràcies a l'ús de les cometes ``. Es com si haguéssim escrit:

• En efecte, quan el shell interpreta la sortida en cometes inverses com a paràmetres tracta als salts de línia com a separadors de paraules.

PRÀCTICA: La sortida de programes com a paràmetres

• El shell proporciona el manteniment del que s'anomena variables de l'entorn
• Són cadenes de caràcters que representen valors que defineixen l'entorn de treball
• Hi han variables d'entorn predefinides del sistema i pròpies de l'usuari
• Podem modificar els valors de qualsevol d'elles (en algunes cal tenir prou privilegis)
• Existeixen moltes variables predefinides que depenen de cada sistema
• Les variables s'indiquen de la següent forma (sense espais):

• El nom de la variable pot ser qualsevol cadena de caràcters que no comenci per un número ni contingui el caràcter $ ni espais en blanc.
• El valor pot ser qualsevol cadena, incloent espais. Si conté espais cal tancar la cadena entre cometes dobles ("")
• Exemples:

• Assigna la cadena "prova variables" a la variable MIVAR. Normalment posem el nom de les variables d'entorn en majúscules per distinguir-les dels noms de fitxers i comandaments.
• Podem veure el contingut de la variable amb:

• Mostrarà el contingut de la variable MIVAR. És obligatori col·locar el signe $ davant del nom.
• Més exemples:

• Aquesta seqüència fa que assigni una ordre a una variable. Després s'executa invocant el nom de la variable. Podem utilitzar-ho per abreviar ordres llargues i d'ús freqüent.

export
 

• Cada variable es defineix en el Shell actiu. Si canviem de Shell (per exemple creant un subshell) la variable deixa d'existir. Podem provar-ho amb la variable XYZ:

$sh                                            arranca un subshell
$echo $XYZ                               no mostra res
 

• En aquesta seqüència creem un subshell (sh) i cridem a la variable XYZ que ara estarà buida. Per tornar a l'anterior shell:

• Per poder disposar de la variable en tots els shells, cal exportar-la:

• Aquest exemple d'exportació només és vàlid si es fa des del shell principal. No podem exportar des d'un subshell al seu superior (proveu-ho).

• Mostra la llista completa de les variables d'entorn actualment definides.Algunes variables bàsiques són: PATH, LOGNAME, etc.

set

• Permet també veure les variables d'entorn fins i tot algunes que no apareixen amb env perquè són utilitzades per el propi shell. Per exemple la variable PS1 que representa el "prompt".

• Farà aparèixer el prompt Linux:

• El Shell interpreta una cadena de caràcters que contingui espais en blanc com múltiples arguments. Per exemple:

• Donarà error perquè interpreta dos arguments: prova queda assignat a la variable d'entorn i el segon l'intenta executar com si sigues un comandament.
• Això ho sol ventem acotant la cadena entre cometes dobles:

• No obstant les variables d'entorn contingudes dintre de les cadenes acotades també són interpretades per el shell. Per exemple:

• Resultat: El meu nom d'usuari és a0alumne

• Si volem que el shell no interpreti la variable cal acotar la cadena amb cometes simples:

• Si volem afegir més camins de cerca a la variable PATH:

• Per combinar el contingut d'una variable amb constants:

• Resultat: holas, mostra el contingut de la variable seguida de la constant. Es diferent que fer:

que mostraria el valor de la variable VARs, si existeix.
 
• Podem avaluar el valor d'una variable i prendre una decisió segons el valor:

• Si la variable BUSTIA existeix mostrarà el seu valor. En cas contrari mostra valor2 sense assignar res a la variable.

• Si la variable BUSTIA existeix mostrarà el seu valor. En cas contrari mostra valor2 i aquest valor s'assignarà  a la variable.

• Serveix per esborrar el valor d'una variable:

• Equivalentment podem fer:

Pràctica 10: Variables del shell

Utilitzar variables dintre de fitxers script: pas per valor i per referència

• Hem vist que el valor d'una variable no es passa automàticament als subshells. Això implica que un comandament creat per nosaltres no podrà canviar el valor d'una variable doncs els fitxers scripts són executats per un subshell.
• Exemple:

• Quan passem variables de l'entorn a un fitxer script ho podem fer de dues formes:
1. Passar només el valor de la variable, però sense que l'script pugui modificar la variable. Diem que el pas de la variable es fa per valor.
2. Donar a l'script l'accés complert sobre la variable. Diem que passem la variable per referència.
• Quan exportem (amb export variable) les variables que l'script necessita estem fent un pas de variables per valor. Exemple:

• El shell proporciona el comandament ' . ' (un punt) que força l'execució de l'script en el propi shell en comptes de pasar-ho a un subshell. Això equival a donar a l'script l'accés total sobre la variable (pas per referència). Exemple:

• Quan utilitzem el punt per executar un script el que realment succeeix es que l'entrada estàndard del shell (el teclat) es redirecciona temporalment per prendre-la del fitxer script. Realment l'script no s'està executant, i per tant no necessita tenir permisos d'execució.
• Hi ha un altre forma de passar només el valor d'una variable del shell a un script (pas per valor) a banda d'usar export que es asignar-li el valor en la mateixa línia en la que cridem a l'script. Per exemple:

• Utilitzarem l'execució amb el punt quan volem modificar permanentment el valor d'una variable i utilitzarem les assignacions en la mateixa línia que l'script o bé l'exportació quan les modificacions siguin temporals (només tenen efecte dins de l'script).

PRÀCTICA: Ús de variables en fitxers script