\

Aqui temos um livro livre e completo sobre Shell

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

Você está aqui: TWikiBar > TWikiBarChiacchiere004
Controles: EDITAR ANEXAR MAIS MAIS ALTERACOES IMPRIMIR - Última Atualização: [21 Feb 2013 - V.3]

Chiacchiere da Bar Parte IV

     - Allora, hai provato a fare l'esercizio che ti ho chiesto per riordinare le idee?

     - Certo che l'ho fatto! Quando si parla di programmazione, senza allenamento non si impara. Mi avevi chiesto di fare un piccolo script per sapere se un determinato utente, da passare come parametro, è loggato (arghh!) oppure non lo è. Ho fatto così:

$ cat loggato #!/bin/bash # Cercare se un utente è loggato oppure non lo è if who | grep $1 then echo $1 è loggato else echo $1 non è loggato, niente da fare fi

     - Calma, calma! Vedo che hai voglia di darti da fare, ma prima ordiniamo le solite birrette e poi penseremo alla Shell. Chico, portaci due birre alla spina, una senza schiuma!

     - Adesso che ci siamo bagnati l'ugola vediamo di dare un'occhiata all'esecuzione del tuo script:

$ loggato jneves jneves pts/0 Oct 18 12:02 (10.2.4.144) jneves è loggato

In effetti funziona. Ho passato il mio login come parametro e il programma ha risposto che ero loggato, tuttavia ha restituito una riga che non ho chiesto. Questa riga è l'output del comando who e, per evitare che ciò accada, è sufficiente spedirla nel buco nero cioè, come adesso sai, in /dev/null. Vediamo come:

$ cat loggato #!/bin/bash # Cercare se un utente è loggato (versione 2) if who | grep $1 > /dev/null then echo $1 è loggato else echo $1 non è loggato, niente da fare fi

Proviamo se funziona:

$ loggato jneves jneves è loggato $ loggato chico chico non è loggato, niente da fare

Penguin con un piatto di attenzione Ah, adesso funziona! Ricordati sempre questo suggerimento: la maggior parte dei comandi ha uno standard output e uno standard error (grep, test, del quale parleremo dopo, e pochi altri sono le uniche eccezioni) e bisogna stare attenti a redirezionarli nel buco nero quando serve.

Bene, adesso cambiamo argomento: l'ultima volta che ci siamo visti qui al Bar ti stavo mostrando i comandi condizionali e, quando ormai avevamo la gola secca per il tanto parlare di if, mi hai chiesto come si testano le condizioni. Vediamolo ora.

Il Comando test

Tutti sono abituati a usare if per testare condizioni ed esse sono sempre maggiore di, minore di, maggiore o uguale a, minore o uguale a, uguale a e diverso da. Bene, per testare condizioni nella Shell si usa il comando test, solo che è molto più potente di quanto siamo soliti credere. Per prima cosa, ti mostrerò le principali opzioni (ce ne sono molte altre) per testare i file:

Opzioni del Comando test per i file
  file1 -ot file2     file 1 è più vecchio di file2  
  Opzione     Vero se:  
  -e file     file esiste  
  -s file     file esiste e la sua grandezza è maggiore di zero  
  -f file     file esiste ed è un file regolare  
  -d file     file esiste ed è una directory  
  -r file     file esiste e possiede i diritti di lettura  
  -w file     file esiste e possiede i diritti di scrittura  
  -x file     file esiste e possiede i diritti di esecuzione  
  file1 -nt file2     file 1 è più recente di file2  

Adesso da' un'occhiata alle principali opzioni per testare stringhe di caratteri:

Opzioni del comando test per le stringhe di caratteri
  c1 = c2    Le stringhe c1 e c2 sono identiche 
  Opzione     Vero se:  
  -z stringa    Grandezza di stringa uguale a zero 
  -n stringa    Grandezza di stringa maggiore di zero 
  stringa    =stringa= ha una grandezza superiore a zero 

Pensi che non ce ne siano altre? Errore! Eccoti quelle alle quali sei più abituato, ossia le famose comparazioni tra valori numerici. Osserva la tabella:

Opzioni del comando test per i numeri
  n1 -le n2     n1 è minore o uguale a n2     minore o uguale a  
  Opzione     Vero se:     Significato  
  n1 -eq n2     n1 e n2 sono uguali     uguale a  
  n1 -ne n2     n1 e n2 non sono uguali     diverso da  
  n1 -gt n2     n1 è maggiore di n2     maggiore di  
  n1 -ge n2     n1 è maggiore o uguale a n2     maggiore o uguale a  
  n1 -lt n2     n1 è minore di n2     minore di  

Inoltre, a queste opzioni si aggiungono anche i seguenti strumenti:

Operatori
  -o     O logico  
  Operatore     Scopo  
  Parentesi ( )     Raggruppare  
  Punto esclamativo !     Negare  
  -a     E logico  

Però! Come vedi ce n'è per tutti i gusti e, come ti ho detto all'inizio, il nostro if è molto più potente di quello degli altri. Vediamo qualche esempio di come funziona: per prima cosa testeremo l'esistenza di una directory:

Esempi:

    if  test -d lmb
    then
        cd lmb
    else
        mkdir lmb
        cd lmb
    fi

Nell'esempio ho eseguito un test sull'esistenza della directory lmb: nel caso in cui non esista (else), la creiamo. Adesso criticherai di certo la logica dell'esempio dicendo che lo script non è ottimizzato. Lo so, ma volevo che tu lo capissi così com'è per utilizzare il punto esclamativo (!) come negazione di test. Osserva:

    if  test ! -d lmb
    then
        mkdir lmb
    fi
    cd lmb

In questo modo la directory lmb è creata solo se non esiste e tale negazione è dovuta al punto esclamativo (!) che precede l'opzione -d. Alla fine dell'esecuzione di questo frammento di script il programma si ritroverà sicuramente nella directory lmb.

Vediamo due esempi per capire la differenza nella comparazione tra numeri e fra stringhe.

    str1=1
    str2=01
    if  test $str1 = $str2
    then
        echo Le variabili sono uguali.
    else
        echo Le variabili sono diverse.
    fi

Eseguendo questo frammento di programma otteniamo:

     Le variabili sono diverse.

Adesso apportiamo qualche modifica affinché la comparazione avvenga tra numeri:

    str1=1
    str2=01
    if  test $str1 -eq $str2
    then
        echo Le variabili son uguali.
    else
        echo Le variabili sono diverse.
    fi

E mandiamolo in esecuzione:

     Le variabili sono uguali.

Come hai potuto vedere, le due esecuzioni hanno prodotto risultati diversi perché la stringa 01 è diversa dalla stringa 1, tuttavia la situazione cambia quando le variabili sono testate numericamente, poiché il numero 1 è uguale al numero 01.

Esempi:

Per capire l'uso dei connettori -o (O) e -a (E), osserva l'esempio “animale” direttamente nel prompt (mi scuseranno gli zoologi ma non so niente di regno, phylum, classe, ordine, famiglia, genere e specie, per cui l'uso che faccio di famiglia e genere è molto probabilmente errato):

$ Famiglia=felini $ Genere=gatto $ if test $Famiglia = canidi -a $Genere = lupo -o $Famiglia = felini -a $Genere = leone > then > echo Attenzione > else > echo Puoi accarezzarlo > fi Puoi accarezzarlo

In questo esempio, se l'animale appartiene alla famiglia dei canidi E (-a) al genere lupo, O (-o) appartiene alla famiglia dei felini E (-a) al genere leone, ci sarà dato un avvertimento, altrimenti il messaggio ci dirà che possiamo accarezzarlo.

Pinguim com placa de dica (em inglês) Il simbolo di maggiore (>) all'inizio delle righe all'interno di if è un prompt di continuazione (definito nella variabile $PS2) e quando la Shell si accorge che un comando continuerà nella riga successiva, lo posizionerà automaticamente fino a quando il comando non sarà chiuso.

Modifichiamo l'esempio e vediamo se funziona ancora:

$ Famiglia=felini $ Genere=gatto $ if test $Famiglia = felini -o $Famiglia = canidi -a $Genere = giaguaro -o $Genere = lupo > then > echo Attenzione > else > echo Puoi accarezzarlo > fi Attenzione

Ovviamente l'operazione ha generato un errore perché l'opzione -a ha la precedenza sull'opzione -o, per cui la prima a essere verificata è l'espressione:

     $Famiglia = canidi -a $Genere = giaguaro

la quale, essendo falsa, produce:

     $Famiglia = felini -o FALSO -o $Genere = lupo

Quindi:

     VERO -o FALSO -o FALSO

Poiché tutti i connettori sono -o e affinché una serie di espressioni connesse tra loro per mezzo di diversi O logici sia vera è sufficiente che lo sia una di esse, l'espressione finale ha come risultato VERO e then è stato eseguito in forma errata. Per farlo funzionare di nuovo digitiamo:

$ if test \($Famiglia = felini -o $Famiglia = canidi\) -a \($Genere = giaguaro -o $Genere = lupo\) > then > echo Attenzione > else > echo Puoi accarezzarlo > fi Puoi accarezzarlo

In questo modo, grazie all'uso delle parentesi, abbiamo raggruppato le espressioni con il connettore -o e reso prioritarie le loro esecuzioni ottenendo come risultato:

     VERO -a FALSO

Affinché il risultato di due espressioni legate dal connettore -a sia VERO è necessario che siano entrambe vere, evento che non si verifica nell'esempio precedente. In tal modo il risultato finale è FALSO quindi else è eseguito correttamente.

Se volessimo scegliere un CD contenente le tracce di 2 artisti diversi, siamo tentati a utilizzare un if con il connettore -a, ma è sempre bene ricordare che bash ci mette a disposizione molti strumenti, e potremmo ottenere lo stesso risultato molto più semplicemente con un unico comando grep. Ecco come:

$ grep Artista1 canzoni | grep Artista2

Allo stesso modo, per scegliere i CD nei quali siano presenti Artista1 e Artista2, non è necessario utilizzare un if con il connettore -o. egrep (o, ancora meglio, grep -E) fa esattamente al caso nostro. Vediamo:

$ egrep (Artista1|Artista2) canzoni

Oppure (almeno in questo caso specifico) anche il semplice comando grep avrebbe risolto il problema:

$ grep Artista[12] canzoni

Nel comando egrep precedente è stata utilizzata un'espressione regolare nella quale la barra verticale (|) funziona come un O logico e le parentesi sono utilizzate per delimitare l'estensione di questo O. Nel comando grep del secondo esempio la parola Artista deve essere seguita da uno dei valori della lista racchiusa tra parentesi quadre ([ ]), cioè 1 o 2.

     - D'accordo, capisco che il comando if della Shell è molto più potente degli altri, ma detto tra noi il costrutto if test ... è molto strano e poco leggibile.

     - Hai ragione, non piace neanche a me e credo che non piaccia a nessuno. Penso che sia per questo che la Shell incorpora un'altra sintassi in sostituzione del comando test.

Esempi:

Prendiamo l'esempio fatto in precedenza per cambiare directory:

    if  test ! -d lmb
    then
        mkdir lmb
    fi
    cd lmb

Utilizzando la nuova sintassi lo trasformiamo in questo:

    if  [ ! -d lmb ]
    then
        mkdir lmb
    fi
    cd lmb

In poche parole, il comando test può essere sostituito con una coppia di parentesi quadre ([ ]), separate dagli argomenti tramite due spazi: in questo modo sarà più facile da leggere poiché il comando if avrà una sintassi simile a quella di altri linguaggi. Da qui in avanti il comando test sarà utilizzato in questa forma.

Cara, mi si è ristretto il Comando Condizionale

Se pensi che sia finita qui, ti sbagli di grosso. Osserva la seguente tabella di verità:

Valori Booleani E O
 FALSO-FALSO   FALSO   FALSO 
 VERO-VERO   VERO   VERO 
 VERO-FALSO   FALSO   VERO 
 FALSO-VERO   FALSO   VERO 

Ricapitolando, quando il connettore è E e la prima condizione è vera, il risultato finale può essere VERO o FALSO in base alla seconda condizione, mentre con il connettore O se la prima condizione è vera il risultato sarà sempre VERO mentre se la prima è falsa il risultato dipenderà dalla seconda condizione.

I programmatori che hanno sviluppato l'interprete sono persone in gamba e cercano sempre di ottimizzare gli algoritmi. Infatti, nel caso del connettore E, la seconda condizione non sarà verificata se la prima è falsa, poiché il risultato sarà sempre FALSO. Con O la seconda condizione sarà controllata soltanto se la prima è falsa.

In base a quanto detto sopra, essi hanno creato una forma breve per condurre un test. Il connettore E è indicato con && mentre per O si usa ||. Per vederne il funzionamento li utilizzeremo come test nel nostro vecchio esempio per cambiare directory:

    if  [ ! -d lmb ]
    then
        mkdir lmb
    fi
    cd lmb

Il programma potrebbe essere riscritto in questo modo:

    [ ! -d lmb ] && mkdir lmb
    cd lmb

Oppure, togliendo la negazione (!):

    [ -d lmb ] || mkdir lmb
    cd lmb

Nel primo caso, se il primo comando (il test rappresentato dalle parentesi quadre) ha successo, cioè se la directory lmb non esiste, sarà eseguito il mkdir poiché la prima condizione era vera e il connettore era E.

Nell'esempio seguente, testiamo se la directory lmb esiste (nell'esempio precedente abbiamo testato la non esistenza) e, nel caso in cui il risultato sia vero, mkdir non sarà eseguito perché il connettore era O. Proviamo così:

     cd lmb || mkdir lmb

In questo caso, se cd non avesse successo, si genererebbe la directory lmb ma il cd per entrare in essa non sarebbe eseguito. Per eseguire più di un comando in questa forma è necessario raggruppare i comandi tramite l'uso di parentesi graffe ({ }). Vediamo come:

    cd lmb ||
        {
        mkdir lmb
        cd lmb
        }

Non va ancora bene perché se la directory non esiste il comando cd restituirà il relativo messaggio di errore. Quindi digitiamo:

    cd lmb 2> /dev/null ||
        {
        mkdir lmb
        cd lmb
        }

Come puoi vedere, il comando if ci ha permesso di eseguire un cd sicuro in modi diversi. È bene ricordare che con la parola sicuro intendo il fatto che, alla fine dell'esecuzione, ti troverai all'interno di lmb sempre che tu abbia i permessi per entrare in lmb e per creare una directory in ../lmb, che ci sia spazio sul disco, ...

E sotto con test

Però! Pensi che sia davvero finita? Ti sbagli amico mio! Il comando test ha ancora una forma ed è ottima perché ti permette di usare dei modelli per la comparazione. Questi modelli seguono le norme della Generazione dei Nomi dei File (File Name Generation) che sono vagamente somiglianti alle Espressioni Regolari ma che non devono essere confuse con queste. La differenza nella sintassi del test che abbiamo appena visto è che in quest'ultimo caso si utilizzano due coppie di parentesi quadre nel modo seguente:

[[ espressione ]]

Dove espressione è una di quelle presenti nella tabella che segue:

Espressioni Condizionali per Modelli
  espr1 ¦¦ espr2     "O" logico, vero se espr1 oppure espr2 è vera  
  Espressione     Risultato  
  stringa == modello
  stringa1 = modello  
  Vero se stringa1 coincide con modello  
  stringa1 != modello     Vero se stringa1 non coincide con modello.  
  stringa1 < stringa1     Vero se stringa1 precede stringa1 in ordine alfabetico.  
  stringa1 > stringa1     Vero se stringa1 segue stringa1 in ordine alfabetico  
  espr1 && espr2     "E" logico, vero se espr1 e espr2 sono entrambe vere  

$ echo $H 13 $ [[ $H == [0-9] || $H == 1[0-2] ]] || echo Ora non valida Ora non valida $H=12 $ [[ $H == [0-9] || $H == 1[0-2] ]] || echo Ora non valida $

Nell'esempio, testiamo se il contenuto della variabile $H è compreso tra zero e nove ([0-9]) oppure (||) tra dieci e dodici (1[0-2]) e se non lo è otteniamo un messaggio di errore.

Esempi:

Per sapere se una variabile ha lunghezza pari a uno e un solo carattere digita:

$ var=a $ [[ $var == ? ]] && echo var è di un carattere var è di un carattere $ var=aa $ [[ $var == ? ]] && echo var è di un carattere $

Come puoi facilmente immaginare, l'uso di modelli per la comparazione aumenta notevolmente la potenza del comando test. All'inizio della nostra chiacchierata, prima dell'ultima birra, abbiamo detto che il comando if dell'interprete Shell è più potente dei suoi corrispondenti in altri linguaggi. Adesso che conosciamo tutte le sue funzioni, dimmi: sei d'accordo con questa affermazione?

Caso coincide con case

Vediamo un esempio didattico: a seconda del valore della variabile $opz , lo script dovrà eseguire una delle seguenti opzioni: inclusione, esclusione, modifica o fine. Vediamo questo frammento di script:

    if  [ $opz -eq 1 ]
    then
        inclusione
    elif [ $opz -eq 2 ]
    then
        esclusione
    elif [ $opz -eq 3 ]
    then
        modifica
    elif [ $opz -eq 4 ]
    then
        exit
    else
        echo Digita un'opzione tra 1 e 4
    fi

Nell'esempio hai potuto vedere l'uso di elif con un else if: questa è la sintassi corretta e accettata ma possiamo fare di meglio utilizzando il comando case, che ha questa sintassi:

    case $var in
        modello1) cmd1
                 cmd2
                 cmdn ;;
        modello2) cmd1
                 cmd2
                 cmdn ;;
        modellon) cmd1
                 cmd2
                 cmdn ;;
    esac

La variabile $var è confrontata con i modelli modello1, ..., modellon e, se uno di essi coincide con essa, viene eseguito il corrispondente blocco di comandi cmd1, ..., cmdn finché non si incontra un doppio punto-e-virgola (;;): a questo punto il flusso del programma ripartirà dall'istruzione posta subito dopo esac.

Nella creazione di modelli sono accettano i seguenti caratteri:

Caratteri Per La Creazione di Modelli
¦   OU logico  
  Carattere     Significato  
*   Qualsiasi carattere presente zero o più volte  
?   Qualsiasi carattere presente una sola volta  
[...]   Lista di caratteri  

Per farti vedere quanto è più elegante, ripetiamo l'esempio di prima utilizzando case al posto di if ... elif ... else ... fi.

    case $opz in
        1) inclusione ;;
        2) esclusione ;;
        3) modifica ;;
        4) exit ;;
        *) echo Digita un'opzione tra 1 e 4
    esac

Come avrai capito, ho usato l'asterisco come ultima opzione, cioè se l'asterisco corrisponde a qualsiasi carattere, allora esso corrisponderà a qualsiasi carattere non compreso nell'intervallo tra 1 a 4. Un'altra cosa da notare è che prima di esac il doppio punto-e-virgola non è necessario.

Esempi:

Adesso proviamo a buttare giù uno script più radicale. Esso ti darà il buon giorno, la buona sera o la buona notte a seconda dell'ora in cui è eseguito, ma prima da' un'occhiata a questi comandi:

$ date Tue Nov 9 19:37:30 BRST 2004 $ date +%H 19

Il comando date mostra la data completa del sistema, ma ci sono diverse opzioni di mascheramento. In questo comando la formattazione inizia con un segno più (+) e i caratteri di formattazione seguono il segno di percentuale (%), così che %H è l'ora di sistema. Detto questo, vediamo un esempio:

$ cat benvenuto.sh #!/bin/bash # Programma beneducato che # dà il buongiorno, la buonasera o # la buonanotte in base all'ora Ora=$(date +%H) case $Ora in 0? | 1[01]) echo Buon Giorno ;; 1[2-7] ) echo Buona Sera ;; * ) echo Buona Notte ;; esac exit

Ci sono andato giù pesante, vero? Vediamo i passaggi caso per caso (o forse case per case? smile )

0? | 1[01] - Significa zero seguito da un carattere qualsiasi (?), oppure (|) uno seguito da zero o uno ([01]), cioè 01, 02, ... 09, 10 e 11;

1[2-7]     - Significa uno seguito da un carattere compreso tra due e sette, cioè 12, 13, ... 17;

*          - Significa tutto ciò che non coincide con nessuno dei modelli precedenti.

Bash 4.0 ha introdotto due nuove funzionalità per il comando case. A partire da questa versione ci sono altri due terminatori di blocco oltre a ;; e sono:

;;& - Quando un blocco di comandi è chiuso con questo terminatore il programma non uscirà da case, ma testerà i modelli che seguono;

;& - In questo caso, sarà eseguito il blocco seguente senza testarne il modello.

Esempi:

Supponiamo che nel tuo programma possano verificarsi 4 tipi di errore e che tu voglia indicare ognuno di essi con una potenza di 2, cioè 1, 2, 4 e 8, in modo che la somma degli errori generi un numero unico che li rappresenti tutti (è così che si formano i numeri binari). In questo modo, se si verificano errori di tipo 1 e 4, al programma sarà passato 5 (4+1), se gli errori sono 1, 4 e 8, sarà passato 13 (8+4+1). Osserva la tabella seguente:

Som- Errori
ma 8 4 2 1
0   -     -     -     -  
15   X     X     X     X  
14   X     X     X     -  
13   X     X     -     X  
12   X     X     -     -  
11   X     -     X     X  
10   X     -     X     -  
9   X     -     -     -  
8   X     -     -     -  
7   -     X     X     X  
6   -     X     X     -  
5   -     X     -     X  
4   -     X     -     -  
3   -     -     X     X  
2   -     -     X     -  
1   -     -     -     X  

$ cat case.sh #!/bin/bash # Riceve un codice formato dalla somma di 4 tipi di #+ errore e restituisce i relativi messaggi. Così, #+ se otteniamo errori tipo 4 e 2, lo script riceverà 6. #+ Se gli errori sono 1 e 2, otterremo 3. In definitiva, #+ i codici di errore seguono una formazione binaria.

Bin=$(bc <<< "obase=2; $1") # Trasforma in binario Zeri=0000 Len=${#Bin} # Prende la grandezza di $Bin Bin=${Zeri:$Len}$Bin # Riempie con zeri a sinistra # Potremmo fare quanto fatto in precedenza #+ con un comando printf, come vedremo nel capitolo 6 case $Bin in 1[01][01][01]) echo Errore tipo 8;;& [01]1[01][01]) echo Errore tipo 4;;& [01][01]1[01]) echo Errore tipo 2;;& [01][01][01]1) echo Errore tipo 1;;& 0000) echo Non ci sono errori;;& *) echo Binario finale: $Bin esac

Osserva che tutte le opzioni saranno testate per sapere quali sono i bit accesi (zero=spento, uno=acceso). Alla fine lo script genera un numero binario affinché lo si possa comparare con il risultato. Facciamo una prova:

$ case.sh 5 Errore tipo 4 Errore tipo 1 Binario finale: 0101 $ case.sh 13 Errore tipo 8 Errore tipo 4 Errore tipo 1 Binario generato: 1101

Osserva anche questo frammento di codice adattato da quello presente in http://tldp.org/LDP/abs/html/bashver4.html

case "$1" in
    [[:print:]] )  echo $1 è un carattere stampabile;;&
    # Il terminatore ;;& testerà il modello seguente
    [[:alnum:]] )  echo $1 è un carattere alfanumerico;;&
    [[:alpha:]] )  echo $1 è un carattere alfabetico   ;;&
    [[:lower:]] )  echo $1 è una lettera minuscola    ;;&
    [[:digit:]] )  echo $1 è un carattere numerico  ;&
    # Il terminatore ;& eseguirà il prossimo blocco...
    %%%@@@@@    )  echo "************************"  ;;
#   ^^^^^^^^  ... anche con un modello strano.
esac

L'esecuzione dello script inserendo il carattere 3 sarà:

3 è un carattere stampabile 
3 è un carattere alfanumerico 
3 è un carattere numerico
********************************

Inserendo m:

m è un carattere stampabile 
m è un carattere alfanumerico 
m è un carattere alfabetico
m è una lettera minuscola

Inserendo / otteniamo:

/  è un carattere stampabile

     - Accidenti, finora ho parlato tanto e bevuto poco. Adesso ti assegno un esercizio da fare a casa, mi darai la risposta la prossima volta che ci vediamo qui al bar, d'accordo?

     - D'accordo, ma prima è meglio che tu dia qualche informazione a chi segue questo corso riguardo al modo in cui ti possono conttatare per eventuali critiche, per scambiare qualche battuta, per invitarti a bere una birra, a tenere un corso o una conferenza e anche per parlare male dei politici.

     - Facile, la mia e-mail è julio.neves@gmail.com, ma non cercare di imbrogliarmi, non mi scordo certo di darti i compiti a casa. Lo script da fare dovrà ricevere come parametro il nome di un file, salverà questo file con il nome originale seguito da una tilde (~) e lo passerà a vi (il miglior editor di testo conosciuto) affinché possa essere modificato. Lo scopo è quello di conservare una copia valida aggiornata del file nel caso in cui qualcuno apporti variazioni non dovute. Ovviamente dovrai fare i controlli opportuni, come verificare che sia inserito un parametro, che il file esista e ogni altra cosa che pensi debba stare nello script. Capito tutto?

     - Sì, sì...

     - Chico! Portami un'altra birretta senza schiuma, il mio amico qui comincia a capirci qualcosa! smile


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.