\

Aqui temos um livro livre e completo sobre Shell

Os sedentos do "saber livre" são muito benvindos.

Você está aqui: TWikiBar > BatePapos > TWikiBarChiacchiere009
Controles: EDITAR ANEXAR MAIS MAIS ALTERACOES IMPRIMIR - Última Atualização: [28 Feb 2013 - V.2]

Chiacchiere da Bar Parte IX



     - Va bene, so già che vuoi una birra prima di iniziare, ma ho tanta voglia di mostrarti ciò che ho fatto che chiedo subito il primo giro e poi ti faccio vedere.

     - Chico, due birre. La sua senza schiuma così non resta cattivo odore in quei baffoni...

     - Mentre aspettiamo che la birra arrivi lascia che ti rammenti che mi hai chiesto di riscrivere il programma listartista ,con la formattazione dello schermo in loop, in modo tale che esso termini quando riceve <ENTER> al posto del nome dell'artista. Eventuali messaggi di errore e domande devono essere visualizzati nella terzultima riga dello schermo utilizzando le routine inviamsg.funz e domanda.funz che abbiamo appena sviluppato.

     - Per prima cosa ho dato una bella sforbiciata a inviamsg.funz e a domanda.funz:

$ cat inviamsg.funz # La funzione riceve soltanto un parametro # con il messaggio che si vuole mostrare, # per non obbligare il programmatore a passare # il messaggio tra virgolette useremo $* (tutti # i parametri, ricordi?) e non $1. Msg="$*" LungMsg=${#Msg} Colonne=$(((TotColonne - LungMsg) / 2)) # Centra msg nella riga tput cup $RigaMesg $Colonne echo "$Msg" read -n1 tput cup $RigaMesg $Col; tput el # Cancella msg dallo schermo%

$ cat domanda.funz # La funzione riceve 3 parametri nel seguente ordine: # $1 – Messaggio da mostrare sullo schermo # $2 – Valore da accettare come risposta di default # $3 – L'altro valore accettato # Supponendo che $1=Accetti?, $2=s e $3=n, la riga # sottostante inserirà in Msg il valore "Accetta? (S/n)" Msg="$1 (`echo $2 | tr a-z A-Z`/`echo $3 | tr A-Z a-z`)" LungMsg=${#Msg} Colonne=$(((TotColonne - LungMsg) / 2)) # Centra msg nella riga tput cup $RigaMesg $Colonne echo "$Msg" tput cup $RigaMesg $((Colonne + RigaMsg + 1)) read -n1 SN [ ! $SN ] && SN=$2 # Se vuota inserisce il valore di default in SN echo $SN | tr A-Z a-z # L'output di SN sarà in minuscolo tput cup $RigaMesg $Col; tput el # Cancella msg dallo schermo%

     - Ed ecco il pezzo forte:

$ cat elencartista3 #!/bin/bash # Dato un artista, mostra le sue canzoni # versione 3

RigaMesg=$((`tput lines` - 3)) # Riga in cui compariranno i messaggi per l'operatore TotCols=$(tput cols) # Numero di colonne a schermo per centrare i messaggi

clear echo " +----------------------------------------------------+  | Elenca Tutte le Canzoni di un Determinato Artista |  | ----- ----- -- ------- -- -- ----------- ------- |  | |  | Inserisci l'Artista: | +----------------------------------------------------+" while true do tput cup 5 51; tput ech 31 # ech=Erase chars (31 caratteri per non cancellare la barra verticale) read Nome if [ ! "$Nome" ] # $Nome è vuota? then . domanda.funz "Vuoi interrompere?" s n [ $SN = n ] && continue break fi

fgrep -iq "^$Nome~" canzoni || # fgrep non interpreta ^ come espressione regolare { . inviamsg.funz "Non ci sono canzoni di questo artista" continue }

tput cup 7 29; echo '| |' RigaAttuale=8 IFS=" :" for ArtCanz in $(cut -f2 -d^ canzoni) # Escludi nome dell'album do if echo "$ArtCanz" | grep -iq "^$Nome~" then tput cup $RigaAttuale 29 echo -n '| ' echo $ArtCanz | cut -f2 -d~ tput cup $RigaAttuale 82 echo '|' let RigaAttuale++ if [ $ RigaAttuale? -eq $RigaMesg ] then . inviamsg.funz "Premi un tasto per continuare..." tput cup 7 0; tput ed # Cancella lo schermo a partire dalla riga 7 tput cup 7 29; echo '| |' RigaAttuale=8 fi fi done tput cup $ RigaAttuale? 29; echo '| |' tput cup $((++RigaAttuale)) 29 read -n1 -p "+-----------Premi un tasto per una nuova ricerca------------+" tput cup 7 0; tput ed # Cancella lo schermo a partire dalla riga 7 done

     - Caspita, oggi sei pieno di entusiasmo! Mi piace come hai risolto il problema e come hai strutturato il programma. È stato un po' laborioso ma la presentazione è ottima e hai sfruttato bene le opzioni di tput. Mettiamolo alla prova con un álbum di Emerson, Lake & Palmer che ho già inserito:

             +----------------------------------------------------+
             |  Elenca Tutte le Canzoni di un Determinato Artista |
             |  ----- ----- -- ------- -- -- ----------- -------  |
             |                                                    |
             |  Inserisci l'Artista: Emerson, Lake & Palmer       |
             +----------------------------------------------------+
             |                                                    |
             |  Jerusalem                                         |
             |  Toccata                                           |
             |  Still ... You Turn Me On                          |
             |  Benny The Bouncer                                 |
             |  Karn Evil 9                                       |
             |                                                    |
             +--------Premi un tasto per una nuova ricerca--------+

Zuppa di lettere

    - Fatto! Adesso sai tutto sulla lettura, ma riguardo alla scrittura sei ancora ai primi passi. So che adesso mi chiederai:
    - Non è forse con il comando echo e i redirezionamenti che si scrive?

In effetti, con questi comandi puoi scrivere il 90% di ciò che devi, tuttavia, se hai bisogno di scrivere qualcosa di formattato ti daranno filo da torcere. Per formattare l'output vedremo un'istruzione molto interessante, printf, la cui sintassi è la seguente:

   printf formato [argomento...]

In cui:
formato è una stringa di caratteri che contiene 3 tipi di oggetti: 1. caratteri semplici; 1. caratteri di specifica del formato; 1. sequenza di escape standard del linguaggio C.
Argomento è la stringa da stampare sotto il controllo di formato.

Ognuno dei caratteri utilizzati per la specifica di formato è preceduto dal carattere % seguito dalla specifica di formato in base alla tabella sottostante:

Tabella dei Caratteri di Formattazione di printf
%  Stampa un %. Non c'è conversione  
  Lettera     L'espressione sarà stampata come:
c  Semplice carattere  
d  Numero in base decimale  
e  Notazione scientifica esponenziale  
f  Numero con punto decimale (float)  
g Il più piccolo tra i formati %e e %f eliminando gli zeri non significativi
o  Numero in base ottale  
s  Stringa di caratteri  
x  Numero in base esadecimale  

Le sequenze di escape standard del linguaggio C sono sempre precedute da una barra inversa (\) e quelle riconosciute dal comando printf sono:

Sequenze di Escape di printf
t   Avanza fino al successivo segno di tabulazione  
  Seqüência     Efeito  
a   Emette un bip  
b   Arretra di una posizione (backspace)  
f   Salta alla successiva pagina logica (form feed)  
n   Salta all'inizio della riga successiva (line feed)  
r   Torna all'inizio della riga corrente (carriage return)  

E non finisce certo qui! Ci sarebbe molto altro da dire riguardo a questa istruzione, ma poiché ci sono un sacco di particolari e quindi sarebbe noioso da spiegare e, peggio ancora, da leggere o studiare, visto che non voglio annoiare nessuno, passiamo direttamente agli esempi e ai commenti.

$ printf "%c" "1 caracter" 1$ Sbagliato! Ha elencato soltanto un carattere e non è andato a capo alla fine $ printf "%c\n" "1 caracter" 1 È andato a capo ma non ha mostrato l'intera stringa $ printf "%c caractere\n" 1 1 caractere Questa è la forma corretta, %c ha ricevuto il carattere 1 $ a=2 $ printf "%c caracteres\n" $a 2 caracteres %c ha ricevuto il valore della variabile $a $ printf "%10c caracteres\n" $a          2 caracteres $ printf "%10c\n" $a caracteres          2 c

Nota bene che negli ultimi due esempi, per via di %c, è stato mostrato un solo carattere per ogni stringa. Il 10 davanti a c non significa dieci caratteri. Un eventuale numero dopo il segno di percentuale (%) indica la lunghezza che avrà la stringa dopo l'esecuzione del comando.

Guarda questi esempi:

$ printf "%d\n" 32 32 $ printf "%10d\n" 32 32 Riempie con spazi a sinistra anziché con zeri $ printf "%04d\n" 32 0032 04 dopo % indica 4 quattro cifre con zeri a sinistra $ printf "%e\n" $(echo "scale=2 ; 100/6" | bc) 1.666000e+01 Il default di %e è 6 cifre decimali $ printf "%.2e\n" `echo "scale=2 ; 100/6" | bc` 1.67e+01 Il .2 indica due cifre decimali $ printf "%f\n" 32.3 32.300000 Il default di %f è 6 cifre decimali $ printf "%.2f\n" 32.3 32.30 Il .2 indica due cifre decimali $ printf "%.3f\n" `echo "scale=2 ; 100/6" | bc` 33.330 bc ha restituito 2 cifre decimali, printf ha inserito uno 0 a destra $ printf "%o\n" 10 12 Conversione di 10 in base ottale $ printf "%03o\n" 27 033 Così la conversione sembra più “ottale”, vero? $ printf "%s\n" Peteleca Peteleca $ printf "%15s\n" Peteleca Peteleca Peteleca con 15 caratteri riempiti con spazi $ printf "%-15sNeves\n" Peteleca Peteleca Neves Il segno meno (-) ha riempito a destra con spazi $ printf "%.3s\n" Peteleca Pet 3 tronca dopo i primi 3 caratteri $ printf "%10.3sa\n" Peteleca Peta Pet con 10 caratteri concatenato con a (dopo la s) $ printf "ESEMPIO %x\n" 61888 ESEMPIO f1c0 Trasformazione in base esadecimale ma l'uno e lo zero non rendono bene $ printf "ESEMPIO %X\n" 61888 ESEMPIO F1C0 Così funziona meglio (nota la X maiuscola) $ printf "%X %XL%X\n" 49354 192 10 C0CA C0LA

L'ultimo esempio non è marketing ed è molto completo, per cui lo commento passo per passo: 1. Il primo %X converte 49354 in base esadecimale producendo come risultato C0CA (da leggere "ci", "zero", "ci" e "a"); 1. Segue uno spazio a sua volta seguito da %XL. %X converte o 192 producendo come risultato C0 che insieme a L produce C0L; 1. Infine, l'ultimo %X trasforma 10 in A.

Come potete notare, l'istruzione printf è piuttosto completa e complessa (fortunatamente echo risolve quasi ogni problema).

Penso di aver fatto la scelta giusta quando ho deciso di spiegare printf tramite degli esempi poiché non avrei saputo come enumerare altrimenti tutte quelle regolette senza rendere barbosa e pesante la lettura.

Principali Variabili della Shell

La Bash contiene diverse variabili che servono a dare informazioni sull'ambiente o a modificarlo. Ce ne sono davvero tante e non intendo mostrarle tutte, ma c'è una piccola parte di esse che può esserti d'aiuto per elaborare degli script. Vediamo le più importanti:

Principali variabili della Bash
TMOUT Se ha un valore superiore a zero, quel valore sarà quello di timeout del comando read. Nel prompt, quel valore è interpretato come il tempo di attesa per un'azione prima di terminare la sessione. Se, per esempio, la variabile contiene il valore 30, la Shell darà logout dopo 30 secondi dall'ultima azione nel prompt.
      Variabile Contenuto
CDPATH Contiene i percorsi da esplorare per localizzare la directory specificata. Nonostante questa variabile sia poco conosciuta, il suo utilizzo deve essere incentivato perché permette di risparmiare un sacco di lavoro, specialmente in installazioni con una struttura di directory su molti livelli.
HISTSIZE Limita il numero di istruzioni contenuto nel file dello storico dei comandi (normalmente .bash_history ma in realtà è ciò che è archiviato nella variabile $HISTFILE). Il suo valore di default è 500.  
HOSTNAME Il nome dell'attuale host (che può essere ottenuto anche con il comando uname -n).
LANG Utilizzata per determinare la lingua parlata nel paese (più in dettaglio una categoria di locale).
LINENO Il numero della riga dello script o della funzione in esecuzione: il suo utilizzo principale è notificare i messaggi di errore assieme alle variabili $0 (nome del programma) e $FUNCNAME (nome della funzione in esecuzione)
LOGNAME Immagazzina il nome di login dell'utente.
MAILCHECK Specifica, in secondi, a frequenza con la quale la Shell verificherà la presenza di email nei file indicati dalle variabili $MAILPATH o $MAIL. Il tempo standard è 60 secondi. Una volta trascorso questo lasso di tempo la Shell eseguirà questa verifica prima di mostrare il successivo prompt primario (definito in $PS1). Se la variabile non è valorizzata o ha un valore inferiore o uguale a zero la verifica di eventuali nuove email non sarà eseguita.
PATH Percorsi da esplorare per localizzare il file specificato. Poiché ogni script è un file, se utilizzi la directory corrente (.) nella tua variabile $PATH, non hai bisogno di usare ./scrp per eseguire scrp. Basta lanciare scrp. Così si fanno le cose qui al Bar.
PIPESTATUS È una variabile di tipo vettoriale (array) che contiene un elenco di valori di codici di ritorno dell'ultima pipeline eseguita, cioè un array che include ogni $? di ogni istruzione dell'ultima pipeline.
PROMPT_COMMAND Se questa variabile riceve un'istruzione, ogni volta che premi <ENTER> nel prompt principale ($PS1), questo comando sarà eseguito. È utile quando è necessario ripetere spesso una certa istruzione.
PS1 È il prompt principale. Nelle "Chiacchiere da Bar" utilizziamo i suoi valori di default: $ per l'utente semplice e # per root, ma è frequente che sia personalizzato. Una curiosità: esiste addirittura un concorso per chi personalizza $PS1 nel modo più creativo. (clique para dar uma googlada)
PS2 Chiamato anche prompt di continuazione, è quel simbolo di maggiore (>) che appare dopo aver premuto <ENTER> senza che il comando sia stato terminato.
PWD Contiene il percorso completo ($PATH) della directory corrente. Ha lo stesso effetto del comando pwd.
RANDOM Ogni volta che si accede a questa variabile essa restituisce un numero intero casuale compreso tra 0 e 32767.
REPLY Utilizza questa variabile per recuperare l'ultimo campo letto se a esso non è associata alcuna variabile.
SECONDS Questa variabile indica da quanti secondi è attiva la Shell corrente. Usala soltanto per salvare un utente da quella cosa che chiamano sistema operativo ma che ha bisogno di boot freqenti. smile

* CDPATH

$ echo $CDPATH .:..:~:/usr/local $ pwd /home/jneves/LM $ cd bin $ pwd /usr/local/bin

Poiché /usr/local era nella mia variabile $CDPATH e la directory bin non era presente in alcuna delle directory superiori (., .. e ~), cd è stato eseguito su /usr/local/bin

* LANG

$ date Thu Apr 14 11:54:13 BRT 2005 $ LANG=pt_BR date Qui Abr 14 11:55:14 BRT 2005

Avendo attribuito alla variabile LANG il valore pt_BR (portoghese del Brasile), la data è stata indicata secondo la norma brasiliana. È interessante osservare che non è stato utilizzato il punto-e-virgola (;) per separare l'attribuzione del valore di LANG dal comando date.

* PIPESTATUS

$ who jneves pts/0 Apr 11 16:26 (10.2.4.144) jneves pts/1 Apr 12 12:04 (10.2.4.144) $ who | grep ^botelho $ echo ${PIPESTATUS[*]} 0 1

In questo esempio si vede che l'utente botelho non era "loggato", quindi è eseguita una pipeline che lo cerca. Si utilizza la notazione [*] in un array per elencare tutti i suoi elemento: in tal modo possiamo vedere che la prima istruzione (who) ha avuto buon esito (codice di ritorno 0), mentre la successiva (grep) ha fallito (codice di ritorno 1).

* RANDOM

Per generare in maniera casuale un numero intero compreso tra 0 e 100 scriviamo:

$ echo $((RANDOM%101)) 73

In poche parole, prendiamo il resto della divisione per 101 del numero casuale generato, poiché il resto della divisione per 101 di un numero qualsiasi è compreso tra 1 e 100.

* REPLY

$ read -p "Digita S oppure N: " Digita S oppure N: N $ echo $REPLY N

Ricordo ancora il tempo in cui la memoria era un bene prezioso che costava moooooolto caro. Per questo, dovendo prendere una S o una N, di solito non alloco uno spazio speciale, quindi prendo ciò che è stato immesso nella variabile $REPLY.

Espansione dei parametri

Bene, la maggior parte di ciò che abbiamo visto finora sono comandi esterni alla Shell. Essi risolvono grossi problemi, facilitano la visualizzazione, la manutenzione e semplificazione del codice, ma non sono efficienti quanto i comandi interni (built-in). Se il nostro problema è di efficienza, dobbiamo scegliere i comandi interni e, a partire da desso, ti mostrerò alcune tecniche per una bella scossa al tuo programma.

Nella tabella e negli esempi che seguiranno vedremo una serie di strutture chiamate espansione (o sostituzione) di parametri (Parameter Expansion), le quali sostituiscono istruzioni come cut, o expr, o tr, o sed e rendono più rapida l'esecuzione dei programmi.

Espansione di parametri
  ${stringa,,}   Trasforma tutte le lettere di stringa in minuscola (a partire dalla bash 4.0)
  Espressione   Risultato atteso
  ${var:-default}   Se var non ha valore, il risultato dell'espressione è default
  ${#stringa}   Lunghezza di $stringa
  ${stringa:posizione}   Estrae una sottostringa di $stringa a partire da posizione. L'origine è zero
  ${stringa:posizione:lunghezza}   Estrae una sottostringa di $stringa a partire da posizione di lunghezza pari a lunghezza. L'origine è zero
  ${stringa#espr}   Elimina il segmento più corto di $stringa a sinistra nell'espressione espr
  ${stringa##espr}   Elimina il segmento più lungo di $stringa a sinistra nell'espressione espr
  ${stringa%espr}   Elimina il segmento più corto di $stringa a destra nell'espressione espr
  ${stringa%%espr}   Elimina il segmento più lungo di $stringa a destra nellespressione espr
  ${stringa/sottostringa1/sottostringa2}   Sostituisce la prima occorrenza di sottostringa1 con sottostringa2 all'interno di $stringa
  ${stringa//sottostringa1/sottostringa2}   Sostituisce tutte le occorrenze di sottostringa1 con sottostringa2 all'interno di $stringa
  ${stringa/#sottostringa1/sottostringa2}   Se sottostringa1 coincide con l'inizio di $stringa, allora è sostituito con sottostringa2
  ${stringa/%sottostringa1/sottostringa2}   Se sottostringa1 coincide con la fine di $stringa, allora è sostituito con sottostringa2
  ${stringa^}   Trasforma la prima lettera di stringa in maiuscola (a partire dalla bash 4.0)
  ${stringa^^}   Trasforma tutte le lettere di stringa in maiuscolo (a partire dalla bash 4.0)
  ${stringa,}   Trasforma la prima lettera di stringa in minuscola (a partire dalla bash 4.0)

* Se in una domanda S è proposto come default e il valore dell'uscita è assegnato alla variabile $SN, una volta letto quel valore possiamo procedere così:

   SN=${SN:-S}

In tal modo, se l'utente da ha semplicemente digitato <ENTER> per confermare di aver accettato il valore di default, dopo aver eseguito questa istruzione, la variabile avrà valore S, altrimenti avrà il valore digitato.

* Per conoscere la lunghezza di una stringa:

$ stringa=0123 $ echo ${#stringa} 4

* Per estrarre il contenuto di una stringa a partire dalla posizione uno scriviamo:

$ stringa=abcdef $ echo ${stringa:1} bcdef

Osserva che si inizia a contare da zero e non da uno.

* Nella stessa variabile $stringa dell'esempio precedente, per estrarre 3 caratteri a partire dalla 2ª posizione:

$ echo ${stringa:2:3} cde

Osserva che si inizia ancora a contare da zero e non da uno.

* Possiamo anche estrarre dalla fine verso l'inizio:

$ TimeBom=Flamengo $ echo ${TimeBom: -5} mengo $ echo ${TimeBom:(-5)} mengo

Lo spazio o le parentesi sono necessarie affinché il segno meno (-) sia separato dai due-punti (:): se ciò accadesse, otterremmo l'espansione, vista in precedenza, che sostituisce una variabile vuota o nulla con un valore di default, cioè la famosa ${var:-default}.

* Per eliminare ogni elemento a sinistra della prima occorrenza di una stringa scrivi:

$ stringa="Chiacchiere da Bar" $ echo ${stringa#*' '} da Bar $ echo "Conversazione "${stringa#*' '} Conversazione da Bar

In questo esempio è stato eliminato tutto ciò che, a sinistra, coincide con il segmento più breve dell'espressione *' ', cioè tutto fino al primo spazio.

Questi esempi potrebbero essere scritti senza proteggere lo spazio dall'interpretazione della Shell (ma preferisco proteggerlo per rendere il codice più facilmente leggibile). Osserva:

$ echo ${stringa#* } da Bar $ echo "Conversazione "${stringa#* } Conversazione da Bar

Osserva che nella costruzione di espr è permesso l'uso di metacaratteri.

* Utilizzando lo stesso valore della variabile $stringa, osserva come faremmo per ottenere soltanto Bar:

$ echo ${stringa##*' '} Bar $ echo "Andiamo a farci una birra al "${stringa##*' '} Andiamo a farci una birra al Bar

Stavolta abbiamo eliminato il segmento più lungo a sinistra dall'espressione espr. L'uso dei metacaratteri è consentito proprio come nell'esempio precedente.

Un esempio più utile: affinché non compaia il percorso (path) completo del programma (che, come sappiamo, è contenuto nella variabile $0) in un eventuale messaggio di errore, all'inizio scrivi quanto segue:

   echo Uso: ${0##*/} testo del messaggio di errore

In questo esempio sarà eliminato, a sinistra, ogni carattere presente fino all'ultima barra (/) del percorso (path): in tal modo resterà soltanto il nome del programma.

* L'uso del simbolo di percentuale (%) è speculare a quello del cancelletto (#). Vediamone un esempio:

$ echo $stringa Chiacchiere da Bar $ echo ${stringa%' '*} Chiacchiere da $ echo ${stringa%%' '*} Bar

* Per scambiare la prima occorrenza di una sottostringa con un'altra all'interno di una stringa:

$ echo $stringa Chiacchiere da Bar $ echo ${stringa/da/al} Chiacchiere al Bar $ echo ${stringa/da /} Chiacchiere Bar

Presta molta attenzione quando usi i metacaratteri, sono piuttosto dispettosi! I loro effetti si estenderanno al loro intero raggio d'azione. Osserva l'esempio che segue: l'intenzione è quella di sostituire Diceria da Bar con Chiacchiere da Bar:

$ stringa=”Diceria da Bar” $ echo $stringa Diceria da Bar $ echo ${stringa/*a/Chiacchiere} Chiacchierer

L'idea era di tagliare tutto fino alla prima a, tuttavia è stato cambiato tutto fino all'ultima a. Il problema può essere risolto in vari modi. Osserva:

$ echo ${stringa/*ia/Chiacchiere} Chiacchiere da Bar $ echo ${stringa/???????/Chiacchiere} Chiacchiere da Bar

* Sostituire tutte le occorrenze di una sottostringa con un'altra. Quando scriviamo:

$ echo ${stringa//a/e} Chiecchiere de Ber

sostituiamo tutte le a con e. Osserva il seguente script che toglie gli spazi dai nomi dei file.

$ cat TogliSpazi.sh #!/bin/bash # Rinomina i file con spazi #+ nel nome sostituendoli con tratti bassi(_). Errore=0 for File in *' '* do [ -f ${File// /_} ] && { echo $File non è stato rinominato Errore=1 continue } mv "$File" "${File// /_}" done 2> /dev/null # Nel caso in cui non esista file con spazi restituisce errore exit $Errore

* Sostituzione di una sottostringa all'inizio o alla fine di una variabile. Per una sostituzione all'inizio scriveremo:

$ echo $Uccellino voglio voglio $ echo "Come dicono al sud - "${Uccellino/#voglio/no} Come dicono al sud - non voglio

Per una sostituzione alla fine scriveremo:

$ echo "Come dicono nel nordest - "${Uccellino/%voglio/no} Come dicono nel nordest - voglio no

Queste espansioni sono state introdotte a partire dalla Bash 4.0 e modificano il formato delle lettere del testo da espandere. Quando usiamo il circonflesso (^), l'espansione è fatta da minuscolo a maiuscolo e quando usiamo la virgola (,) l'espansione è fatta da maiuscolo a minuscolo.

$ Nome="botelho" $ echo ${Nome^} Botelho $ echo ${Nome^^} BOTELHO $ Nome="botelho carvalho" $ echo ${Nome^} Botelho carvalho

Un frammento di script che può facilitarti la vita:

read -p "Vuoi continuare (s/n)? "
[[ ${REPLY^} == N ]] && exit

In tal modo possiamo evitare di controllare se la risposta data è N (maiuscolo) o n (minuscolo).

In rWindows, oltre ai virus e all'instabilità, sono frequenti anche nomi di file con spazi e quasi tutti in maiuscole. Abbiamo appena visto un esempio di come sostituire lo spazio con un tratto basso (_): nel prossimo vedremo come come trasformare i nomi in minuscolo (se ricevi molti file da quel coso è meglio creare uno script fondendo i due).

$ cat cambiaformato.sh #!/bin/bash # Se il nome del file contiene almeno una #+ lettera maiuscola, la trasforma in minuscola

for File in *[A-Z]* # File con almeno una minuscola do if [ -f "${File,,}" ] # Il file con tutte lettere minuscole esiste già? then echo ${File,,} esiste già else mv "$File" "${File,,}" fi done

     - Adesso basta, oggi le nostre chiacchiere sono state noiose perché c'erano un sacco di cose da memorizzare, ma l'essenziale è che tu abbia capito il nocciolo del discorso e, quando ti sarà necessario, consulta i tovaglioli sui quali ho scritto questi suggerimenti e tienili da parte perché non si sa mai. Tornando a bomba: è l'ora di farci un'altra birra e guardare la partita del Flamengo. Per la prossima volta ti do un compitino facile facile: prendi la routine domanda.funz (quella di cui abbiamo parlato all'inizio delle nostre chiacchiere di oggi) e ottimizzale affinché la variabile $SN riceva il valore di default tramite l'espansione di parametri come abbiamo visto.

     - Chico, non dimenticare di riempirmi il bicchiere. Texto a ser mostrado para chamar atenção

-- AlbertoTaddei - 27 Feb 2013


Licença Creative Commons - Atribuição e Não Comercial (CC) 2017 Pelos Frequentadores do Bar do Júlio Neves.
Todo o conteúdo desta página pode ser utilizado segundo os termos da Creative Commons License: Atribuição-UsoNãoComercial-PermanênciaDaLicença.