Perl: espressioni e operazioni. A2.3.4.18 AND logico, OR e OR esclusivo

espressioni in PERL, come in altri linguaggi di programmazione, sono combinazioni di variabili, costanti e operazioni che danno risultati significativi. Questo risultato può essere un array scalare, array o associativo.

Tutte le operazioni PERL sono suddivise in:

Le operazioni di I/O sono descritte nell'articolo " Perl: descrittori di file", operazioni con espressioni regolari — "Perl: espressioni regolari", sezione" Operazioni con espressioni regolari ".

Operazioni di confronto

Operazioni di confronto confrontare i due operandi e restituire 1 o 0 a seconda del risultato di tale confronto. PERL contiene due set di operatori di confronto: per confrontare numeri e per confrontare stringhe. Le operazioni del primo gruppo convertono prima gli operandi in numeri e poi li confrontano. Le operazioni del secondo gruppo convertono gli operandi in stringhe e li confrontano in ordine lessicografico... Se viene specificata la direttiva use locale, il confronto viene effettuato in base alla locale.

Prossimo esempio

$ a = 299;
$ b = 30;
se ($ a< $b)
{
print "Il numero $ a è minore del numero $ b \ n";
}
if ($ a lt $ b)
{
print "La riga $ a è minore della riga $ b \ n";
}

stamperà il messaggio: la riga 299 è inferiore alla riga 30.

Operazioni logiche

PERL contiene due set operazioni logiche , che sono identici nel risultato, ma hanno priorità diverse. Notare che i risultati delle operazioni AND e OR differiscono da quelli di altri linguaggi di programmazione.

Le operazioni and, or, xor e not hanno la priorità più bassa tra tutte le operazioni PERL. Ciò consente loro di essere utilizzati sul lato destro delle istruzioni senza parentesi aggiuntive, ad esempio:

Apri HANDLE, "file.dat" o die "Errore: $! \ N";

Utilizzando l'operazione || in questo esempio richiederà le parentesi:

Apri (HANDLE, "file.dat") || die "Errore: $! \ n";

Operazioni bit a bit

Operazioni bit a bit si applicano agli operandi rappresentati come numeri binari(cioè come stringhe di bit) e restituiscono un valore che indica il risultato dell'operazione.

Le operazioni di spostamento si applicano solo agli operandi numerici, ma il resto operazioni sui bit si applicano sia ai numeri che alle stringhe. Se uno degli operandi di un'operazione bit per bit è un numero, entrambi gli operandi vengono convertiti in numeri interi. Se entrambi gli operandi sono stringhe, vengono convertiti in stringhe della stessa lunghezza e l'operazione viene eseguita su ciascun bit delle stringhe risultanti. Questo ci consente di applicare operazioni bit per bit a operandi di qualsiasi lunghezza. In questo caso, l'operazione | e ^ riempie la stringa più corta a destra con zero bit e l'operazione & tronca la stringa più lunga alla dimensione di quella più corta. Possiamo indicare esplicitamente il tipo di operazione utilizzando le virgolette per le stringhe o 0+ per i numeri. Esempi:

Stampa 1.9 | 2; # 3 (operando mobile ridotto a intero)
stampa 150 | "105"; # 255 (0x96 | 0x69 è uguale a 0xFF)
stampa "150" | "105"; # "155" (in ASCII)
$ un = 150;
$b = "105";
stampa 0 + $ a | 0 + $ b; #operandi numerici
stampa "$ a" | "$ b"; # operandi stringa

Le operazioni bit per bit sono influenzate dalle direttive di controllo aritmetico. Per impostazione predefinita, gli interi sono considerati senza segno, quindi l'operazione di spostamento a destra riempie i bit più significativi del risultato con zeri e l'operazione ~ 0 restituisce l'intero positivo più grande. La direttiva use integer fa sì che gli interi vengano interpretati come numeri con segno. Pertanto, nella sua area di azione, l'operazione dello spostamento a destra riempie i bit più significativi del risultato con il bit di segno del numero e l'operazione ~ 0 restituisce il numero -1.

operazioni unarie

Più unario

Più unario(+) restituisce il suo operando. L'unico uso significativo di questa operazione è separare il nome di una funzione dai suoi argomenti tra parentesi. Considera questo esempio:

Stampa (10 + 20) / 10;

Contrariamente alle aspettative, questo operatore non stampa il numero 3, ma il numero 30. Il fatto è che le parentesi intorno agli argomenti della funzione hanno la priorità più alta in PERL, ovvero l'operazione di stampa (10 + 20) viene eseguita prima del divisione per 10. Il risultato desiderato si ottiene inserendo un più unario davanti alle parentesi, che ne abbassa la precedenza:

Stampa + (10 + 20) / 10;

meno unario

meno unario(-) inverte il segno di un operando numerico. Se l'operando è una stringa, viene restituito il seguente risultato:

• se la stringa inizia con un carattere "+" o "-", di conseguenza questo carattere viene sostituito con il carattere opposto;
• in caso contrario, viene restituita la concatenazione del carattere "-" e la stringa originale.

In particolare, le costruzioni -word e "-word" sono equivalenti.

Creazione di collegamenti

Incremento e diminuzione

Le operazioni ++ e - sono chiamate rispettivamente operazioni incremento e decremento... Un incremento aumenta il valore di una variabile numerica di 1. Se viene utilizzato come prefisso (++ a), restituisce il valore dell'operando dopo averlo aumentato di 1. Se viene utilizzato come suffisso (a ++ ), quindi restituisce il valore dell'operando prima di aumentarlo di 1. Se l'operando di incremento è una variabile stringa che corrisponde al modello / ^ ** $ /, la stringa viene incrementata carattere per carattere, con un'interruzione. Esempi:

Stampa ++ ($ x = "99"); # "cento"
stampa ++ ($ x = "a0"); # "a1"
print++ ($ x = "Az"); # "Ba"
stampa ++ ($ x = "zz"); # "aaa"

Il decremento si applica solo alle variabili numeriche e diminuisce il valore della variabile di 1. Se questa operazione viene utilizzata come prefisso (--a), restituisce il valore dell'operando dopo averlo decrementato di 1. Se viene utilizzata come suffisso (a--), quindi restituisce il valore operando prima di decrementarlo di 1. Esempi:

Stampa - ($ x = 99); # 98
print (($ x = 99) -); # 99
print - ($ x = "a0"); # -uno

Operazioni unarie denominate

Operazioni additive

Ci sono due operazioni aggiuntive sui numeri (addizione e sottrazione) e uno sulle stringhe (concatenazione).

Stampa "1" + "2"; # 3
stampa "1". "2"; # "12"

Operazioni moltiplicative

Ce ne sono quattro operazioni moltiplicative su numeri (moltiplicazione, divisione, modulo ed elevamento a potenza) e uno su stringhe (ripetizione).

Stampa "-" x 80; # stampa la linea meno
@one = (1) x 5; # @ones = (1, 1, 1, 1, 1)
@ones = (2) x @ones; # @ones = (2, 2, 2, 2, 2)

Operazioni di assegnazione

Operazioni di assegnazione assegnare all'operando di sinistra il risultato dell'operazione, che è determinato dall'operando di destra e dall'operazione stessa. L'operazione di assegnazione di base è a = b, che significa: assegnare il valore dell'operando b alla variabile a. Tutte le altre assegnazioni sono abbreviazioni per altre assegnazioni sovrapposte, come mostrato nella tabella seguente.

Un operatore di assegnazione restituisce il suo operando di sinistra e quindi può essere utilizzato sul lato sinistro dell'operatore di assegnazione successivo. ad esempio

($ un + = 2) * = 3;

equivalente a

$ un + = 2;
$ un * = 3;

L'assegnazione di un elenco a un elenco restituisce un elenco di variabili a cui sono stati assegnati valori. L'assegnazione di un elenco a uno scalare restituisce il numero di elementi in questo elenco.

q-operazioni

Nella maggior parte dei linguaggi di programmazione, le virgolette vengono utilizzate per formare costanti stringa. Tuttavia, in PERL sono operazioni che forniscono l'interpolazione delle stringhe e la corrispondenza dei modelli. Chiameremo tali operazioni q-operazioni(a partire dal parola inglese citazione, cioè una virgoletta). PERL contiene due serie di operazioni q, elencate nella tabella seguente.

Qui, invece delle parentesi (), puoi usare qualsiasi carattere che non sia una lettera, un numero o uno spazio o delimitatori accoppiati: (),, (),<>... Esempi di utilizzo dei costrutti q per creare costanti stringa sono stati forniti in pagina 6.2.3.2; per usarli nelle espressioni regolari, vedere pagina 6.4.6 .

Altre operazioni

Reindirizzamento

operazione reindirizzamento sembra:

Operazioni di collegamento

La maggior parte delle operazioni con le espressioni regolari funziona con la variabile speciale $ _. Per la corrispondenza del modello linee arbitrarie sono utilizzati operazioni di collegamento che assomigliano a:

A = ~ ba! ~ B

dove a è qualsiasi espressione stringa e b è un modello per la corrispondenza, la sostituzione o la traslitterazione. L'operazione = ~ restituisce vero se la corrispondenza, la sostituzione o la traslitterazione ha avuto successo, falso in caso contrario. L'operazione! ~ restituisce la negazione logica del risultato = ~. Per esempi di utilizzo di queste operazioni, vedere pagina 6.4.6 .

Impostazione dell'intervallo

operazione impostazione dell'intervallo sembra:

In realtà sono due operazioni diverse a seconda del contesto. Nel contesto di una lista, questa operazione restituisce una lista di valori (a a + 1… b). Per le stringhe, l'intervallo viene visualizzato utilizzando incremento, Per esempio:

Per ogni (1..10)
{
# loop 10 volte
}
@a = @a [$ # a-4 .. $ # a]; # taglia gli ultimi cinque elementi
@a = ("abc" .. "abe"); # @a = ("abc", "abd", "abe")

In un contesto scalare, questa operazione si comporta come un trigger a due stati che restituisce vero o falso. Ciascuna delle operazioni .. mantiene il proprio stato. È falso finché il suo operando sinistro è falso. Una volta che l'operando di sinistra è vero, questa operazione è vera finché l'operando di destra è falso. Dopo che l'operando di destra diventa vero, questa operazione restituisce nuovamente false.

Il risultato non diventa falso fino alla successiva chiamata a questa operazione. L'operazione .. può controllare l'operando di destra e diventare falsa per la stessa valutazione, quando diventa vera, ma una volta ritorna vera. Se vogliamo che non valuti l'operando giusto fino alla prossima chiamata ad esso, allora dobbiamo usare il modulo

Altrimenti, le operazioni .. e ... sono identiche. L'operando di destra non viene valutato mentre l'operazione è falsa e l'operando di sinistra non viene valutato mentre l'operazione è vera. Il valore restituito da questa operazione è riga vuota false e numeri interi consecutivi a partire da 1 true. Il numero progressivo viene reimpostato per il nuovo intervallo. A ultimo numero l'intervallo viene aggiunto con la stringa "E0". Se uno degli operandi è costante, viene implicitamente confrontato con la variabile speciale $. (contenente il numero linea corrente file corrente). Si apre il seguente esempio dato file e ne stampa le righe da una a cinque.

Apri HANDLE, "filename.ext";
mentre ( )
{
stampa se (1..5);
}

Operazione condizionale

Operazione condizionaleÈ un'operazione ternaria che assomiglia a:

Test? valore1: valore2

dove test, valore1 e valore2 sono espressioni. Se test è vero, l'operazione restituisce valore1, altrimenti restituisce valore2. Esempio:

Printf "Ho% d amico% s. \ N", $ n, ($ n == 1)? "g": (($ n< 5) ? "га" : "зей");

Questa operazione può essere utilizzata sul lato sinistro di un'operazione di assegnazione se sia valore1 che valore2 sono variabili, ad esempio:

($ test? $ a: $ b) = $ c;

Operazione virgola

Operazione virgola fa sì che i valori di due espressioni vengano valutati in sequenza e restituisce la seconda di esse. Sembra:

Espr1, espr2

dove espr1 ed espr2 sono espressioni qualsiasi. Negli elenchi, una virgola funge da separatore per gli elementi dell'elenco.

PERL contiene un sinonimo per questa operazione della forma

Espr1 => espr2

Questo modulo è comunemente usato per gli elementi accoppiati di un elenco, ad esempio, durante l'inizializzazione di array associativi. Inoltre, se l'operando sinistro dell'operatore => è una parola, allora viene interpretato come una stringa (vedi. pagina 6.2.7)

L'ordine delle operazioni

Quando si valutano le espressioni, PERL tiene conto priorità delle operazioni: Le operazioni con priorità più alta vengono eseguite per prime. Per modificare l'ordine delle operazioni, utilizzare parentesi: l'espressione racchiusa in essi ha la precedenza più alta. La tabella seguente elenca tutte le operazioni PERL in ordine di priorità decrescente; le operazioni che si trovano nella stessa riga della tabella hanno uguale priorità e vengono eseguite o da sinistra a destra o da destra a sinistra, come indicato nella tabella.

Ci sono diversi modi per confrontare gli oggetti in Perl. Puoi verificare l'uguaglianza dei valori usando l'operatore infisso ===. Per gli oggetti immutabili (i cui valori non possono essere modificati, letterali. Ad esempio, il letterale 7 sarà sempre 7) questo confronto comune i valori. Ad esempio "ciao" === "ciao" è sempre vero perché entrambe le stringhe sono invariate e hanno lo stesso significato.

Per gli oggetti mutabili, === confronta la loro identità. === restituisce vero se i suoi argomenti sono alias dello stesso oggetto. Oppure, due oggetti sono identici se sono lo stesso oggetto. Anche se sia @a che @b contengono gli stessi valori se i loro contenitori sono oggetti diversi, avranno identità diverse e non saranno gli stessi quando si confrontano ===:

Il mio @a = 1, 2, 3; mio @b = 1, 2, 3; dire @a === @a; # 1 say @a === @b; # 0 # usa l'identità qui say 3 === 3; # 1 say "a" === "a"; # 1 mio $ a = "a"; dire $ un === "un"; # uno

L'operatore eqv restituisce True se due oggetti sono dello stesso tipo e struttura. Quindi per @a e @b nell'esempio, @a eqv @b è vero perché @a e @b contengono gli stessi valori. D'altra parte "2" eqv 2 restituirà False, poiché l'argomento a sinistra è una stringa e l'argomento a destra è un numero, e quindi sono di tipi diversi.

Proprio come == converte i suoi argomenti in numeri, l'operatore eq infix confronta l'uguaglianza delle stringhe, convertendo gli argomenti in stringhe se necessario.

If $ saluto eq "ciao" (dire "benvenuto";)

Altri operatori confrontano le stringhe lessicograficamente.

In realtà una forma più conveniente per! ==, che a sua volta è una concatenazione del metaoperatore! e l'operatore infisso ==. La stessa spiegazione vale per ne ed!Eq.

Gli operatori di confronto a tre vie ricevono due operandi e restituiscono Ordine :: Aumenta se l'operando è minore a sinistra, Ordine :: Uguale se sono uguali, Ordine :: Diminuisce se l'operando a destra è minore (Ordine :: Aumenta, Order :: Same e Order: : Decrease sono enumerazioni; vedi). Per i confronti numerici, utilizzare l'operatore<=>, e per gli archi è leg (dall'inglese l esser, e qual, greater). L'operatore infisso cmp è anche un operatore di confronto che restituisce tre risultati di confronto. La sua particolarità è che dipende dal tipo di argomenti: i numeri vengono confrontati come<=>, stringhe come leg e (ad esempio) coppie confrontando prima le chiavi e poi i valori (se le chiavi sono uguali).

dì 10<=>5; # +1 diciamo 10 gamba 5; # perché "1" lt "5" say "ab" leg "a"; # +1, confronto lessicografico

L'ordinamento è un'applicazione tipica degli operatori di confronto a tre vie citati. Il metodo di ordinamento negli elenchi riceve un blocco o una funzione che confronta i suoi due argomenti e restituisce valori negativi se inferiori a 0 - se gli argomenti sono uguali e maggiori di 0 se il primo argomento è maggiore del secondo. Questi risultati vengono quindi utilizzati nell'ordinamento per formare il risultato.

dì ~ .ordinare; # output: Dire astratto concreto ~ .sort: -> $ a, $ b (uc ($ a) leg uc ($ b)); # output: abstract Concrete

L'ordinamento predefinito fa distinzione tra maiuscole e minuscole, ad es. i caratteri maiuscoli sono "maggiori di" caratteri minuscoli. L'esempio utilizza l'ordinamento senza distinzione tra maiuscole e minuscole.

I diversi operatori di confronto trasmettono i loro argomenti a tipi specifici prima di confrontarli. Ciò è utile quando è richiesto un confronto specifico ma i tipi dei parametri sono sconosciuti. Perl 6 fornisce un operatore speciale che consente i confronti Fai la cosa giusta usando l'operatore di confronto intelligente ~~.

If $ pints-drunk ~~ 8 (dici "Vai a casa," ne hai avuto abbastanza! ";) Se $ country ~~" Sweden "(dici" Polpette con mirtilli rossi e alce di patate, per favore. ") A meno che $ dimensioni del gruppo ~~ 2..4 (dire "Devi avere tra 2 e 4 persone per prenotare questo tour.";)

L'operatore smart match decide sempre quale tipo di confronto eseguire in base al tipo di valore sul lato destro. Negli esempi precedenti, questi confronti erano rispettivamente numerici, di stringhe e di intervalli. Questo capitolo ha dimostrato il funzionamento degli operatori di confronto: numeri - == e stringhe eq. Tuttavia, non esiste un operatore per confrontare gli intervalli. Questo fa parte della funzione di corrispondenza "intelligente": tipi più complessi consentono di realizzare idee insolite combinando confronti con altri.

La corrispondenza intelligente funziona chiamando il metodo ACCEPTS sull'operando di destra e passando l'operando a sinistra come argomento. L'espressione $ risposta ~~ 42 si riduce a chiamare 42.ACCEPTS ($ risposta). Queste informazioni saranno utili durante la lettura dei capitoli successivi su classi e metodi. Anche tu scriverai cose che possono fare una mappatura intelligente implementando il metodo ACCEPTS per farlo "funzionare come dovrebbe".

Per confrontare i dati scalari o i valori delle variabili scalari, Perl offre un insieme di operazioni binarie che calcolano relazioni di uguaglianza, maggiore di, maggiore o uguale a, ecc. tra i loro operandi, quindi questo gruppo di operazioni è anche chiamato operazioni di relazione . Perl utilizza diverse operazioni per confrontare dati numerici e dati stringa. Tutti loro sono presentati in tabella. 4.1.

Tabella 4.1. Operazioni di relazione

Il risultato delle operazioni di relazione (ad eccezione dell'ultimo confronto) è True, valore 1 o False, stringa vuota "".

Commento
Un valore vero nelle operazioni aritmetiche viene interpretato come il numero 1 e nelle operazioni sulle stringhe come la stringa "1". Il valore false nelle operazioni aritmetiche viene interpretato come il numero 0 e nelle stringhe come la stringa vuota "".

Operazioni di relazione numerica

Le operazioni relazionali numeriche vengono applicate ai dati numerici, in cui uno o entrambi gli operandi possono essere specificati come una stringa contenente un numero decimale valido. Se nelle operazioni relazionali numeriche uno qualsiasi degli operandi viene specificato come una stringa il cui contenuto non rappresenta un numero decimale valido, si presume che il suo valore sia uguale a e viene visualizzato un avviso sull'uso errato dell'operando in un operatore relazionale numerico (se la modalità di visualizzazione degli avvisi dell'interprete Perl è abilitata). Il significato delle operazioni di relazione per dati numerici corrisponde alle consuete operazioni matematiche per confrontare i numeri (esempio 4.7).

123> 89; # Risultato: 1 (vero)

123 < 89; # Результат: "" (ложь)

123 <= 89; # Результат: "" (ложь)

89 <= 89; # Результат: 1 (истина)

23> = 89; # Risultato: "" (falso)

23 <=>89; # Risultato: -1 (l'operando destro è maggiore di quello sinistro)

89 <=>23; # Risultato: 1 (l'operando destro è maggiore di quello sinistro)

L'uso di operazioni di confronto numerico non è difficile, tuttavia, quando si confrontano per l'uguaglianza di numeri decimali in virgola mobile, gli effetti di arrotondamento possono apparire associati a un numero limitato di cifre significative nella mantissa di rappresentare numeri reali in un computer e portare a "errati ", dal punto di vista dell'utente, il funzionamento delle operazioni di confronto ... L'Esempio 4.8 illustra una situazione simile.

#! peri -w
$z = 0,7;

$ zz = 10 + 0,7-10; # La variabile $ zz contiene il numero 0.7

# Stampa la stringa "z è uguale a zz" se i valori di $ z e $ zz sono uguali print "z è uguale a zz \ ​​​​n" if ($ z == $ zz);

Quando proviamo a eseguire l'Esempio 4.8, siamo sorpresi di scoprire che il nostro programma non stamperà nulla. Che cosa c'é? La risposta sta nell'operatore per il calcolo del valore della variabile $ zz. Quando si eseguono operazioni aritmetiche, a causa di errori di arrotondamento, si ottiene il valore 0,699999999999999 (è possibile inserire un'istruzione di stampa per la variabile $ zz e assicurarsi di ciò), sebbene sia vicino a 0,7, ma non esattamente uguale ad esso. Pertanto, l'operazione di confronto ha funzionato correttamente!

Consigli
Non utilizzare l'operazione di confronto per l'uguaglianza dei numeri reali, il suo risultato potrebbe non essere quello previsto dal punto di vista matematico. Se è necessario verificare l'uguaglianza di due numeri reali, allora è meglio confrontare il valore assoluto della loro differenza con un numero molto piccolo (a seconda della precisione richiesta):

addominali ($ a- $ b)<= 0.00000001; # Проверка равенства

Operazioni sulle stringhe di relazione

Il confronto dei dati delle stringhe si basa sul loro ordinamento secondo la tabella ASCII, ovvero il carattere con il codice ASCII inferiore precede il carattere con il codice superiore. Il confronto delle stringhe viene eseguito carattere per carattere da sinistra a destra. Ciò significa che se i primi caratteri delle stringhe sono uguali, vengono confrontati i secondi e, se sono uguali, vengono confrontati i terzi, ecc. Inoltre, se le stringhe sono di lunghezza diversa, il numero di caratteri con il codice o che manca per l'uguaglianza viene aggiunto alla fine della stringa più corta. Va notato che, a differenza di altri linguaggi di programmazione, gli spazi bianchi che seguono le stringhe di Perl sono significativi quando si confrontano le stringhe. L'Esempio 4.9 mostra i confronti di stringhe per illustrare queste regole.

Prestiamo attenzione alle ultime due operazioni per confrontare le stringhe letterali. I contenuti dei loro operandi possono essere convertiti in numeri validi, e quindi operazioni relazionali numeriche simili sono applicabili a loro. Tuttavia, il loro risultato sarà significativamente diverso dal risultato dell'esecuzione di operazioni sulle relazioni tra stringhe. Quando si utilizza l'operazione< в предпоследнем выражении результат будет Ложь, а если в последнем выражении применить операцию ==, то результат будет Истина. Об этом всегда следует помнить, так как Perl автоматически преобразует символьные данные в числовые там, где это необходимо.

In questa parte parleremo di istruzioni condizionali e cicli.

Operatori condizionali

Come sempre, partiamo subito dagli esempi.

$ a = spostamento;
se ($ a> 10) (
stampa "a> 10 \ n ";
}

I programmatori in linguaggi simili al C dovrebbero avere una familiarità dolorosa con questa costruzione, quindi non c'è niente di speciale da commentare. Lasciami solo dire che, a differenza del C, qui non puoi omettere le parentesi graffe. Più precisamente, c'è un modo, ma ne parleremo più avanti. I costrutti if-else e if-else-if-... in Perl hanno questo aspetto:

$ a = spostamento;
se ($ a> 10) (
stampa "a> 10 \ n ";
) altro (
stampa "a<= 10\ n ";
}

se ($ a> 0) (
# fare qualcosa
) elsif ($ a == 0) (
# fare qualcosa
) altro (
# Fai qualcos'altro
}

In generale, tutto è come ci aspettiamo con un'eccezione. Non c'è "else if" in Perl - dovresti usare elsif e solo quello invece. Elsif può essere ripetuto più volte, altrimenti è facoltativo, le parentesi graffe non possono essere omesse.

A differenza di altri linguaggi di programmazione, Perl fornisce anche un'istruzione less. I seguenti due pezzi di codice fanno la stessa cosa:

a meno che ($ a == 0) (
# "... a meno che a non sia zero"
...
}

if ($ un! = 0) (
# lo stesso
# ...
}

A meno che non possa essere usato insieme a elsif e else, ma non c'è "elsunless" in Perl.

Perl ha la capacità di ridurre la quantità di codice se, se una condizione è soddisfatta, è necessario eseguire solo una riga di codice. I seguenti esempi fanno la stessa cosa:

se ($ a> $ b) (
uscita 1;
}

a meno che ($ b == $ c) (
uscita 2;
}

# se la condizione è vera, termina lo script con il codice 1
uscita 1 if ($ a> $ b);
# se b == c, continua l'esecuzione dello script
uscita 2 a meno che ($ b == $ c);

In questo caso, le parentesi nell'ultimo esempio possono essere omesse:

# se la condizione è vera, termina lo script con il codice 1
uscita 1 se $ a> $ b;

Se scrivi in ​​Java / PHP o in un altro linguaggio simile al C, questa costruzione sarà molto probabilmente insolita per te, ma in pratica è davvero conveniente. In russo, di solito diciamo anche "completa il programma se..." e non "se...allora...".

Proprio come C/C++ e PHP, Perl ha operatore ternario ?:... Funziona in modo simile alla costruzione if-else, solo all'interno di espressioni:

se ($ a> $ b) (
$ a = $ a / $ b;
) altro (
$ a = $ b / $ a;
}

# codice simile che utilizza l'operatore del punto interrogativo
# una riga di codice invece di cinque
$ a = $ a> $ b? $ a / $ b: $ b / $ a;

Vorrei anche spendere due parole sugli operatori di confronto. Operatori di confronto nel linguaggio Perl sono divisi in due gruppi: confronto di numeri e confronto di stringhe.

Ricorda, gli scalari in Perl possono essere interpretati sia come stringhe che come numeri. Ad esempio, 123 è maggiore di 45, ma la stringa "123" è minore della stringa "45". È qui che ci sono voluti diversi gruppi di operatori di confronto. Il confronto delle stringhe di Perl viene eseguito allo stesso modo di altri linguaggi di programmazione moderni, quindi spero che non ci siano domande.

For, fore, while / fino a, do..while / fino a cicli

Il ciclo for è molto familiare a tutti i programmatori:

# stampa la stringa "0 1 2 3 4"
per ($ i = 0; $ i< 5 ; $i ++ ) {
stampa "$ i";
}

Tra parentesi, separato da punto e virgola:

1. Codice eseguito prima dell'inizio del ciclo.
2. Condizione controllata prima dell'inizio(e non alla fine, come molti pensano) di ogni iterazione. Se è falso, il ciclo termina.
3. Codice eseguito dopo ogni iterazione.

Come nel caso degli operatori condizionali, non puoi omettere le parentesi graffe nei cicli (c'è anche una notazione speciale per questo - vedi sotto).

Il ciclo foreach dovrebbe essere familiare ai programmatori PHP:

@arr = (0, 1, 2, 3, 4);
# stampa la stringa "0 1 2 3 4"
foreach $ i (@arr) (
stampa "$ i";
}

Il corpo del ciclo foreach viene eseguito per ogni elemento nell'array specificato tra parentesi. Una caratteristica importante di foreach è nella variabile $ i non copiato un elemento dell'array @arr come molti pensano. La variabile $ i nel corpo del ciclo è l'elemento dell'array stesso... Pertanto, il codice seguente incrementa di uno il valore di ciascun elemento dell'array @arr:

$ i = 19880508;
foreach $ i (@arr) (
$i++;
}
# $ i è ancora 19880508

Anche foreach può essere utilizzato per lavorare con gli hash:

% cancelletto = (
aaa => 1,
bbb => 2,
) ;
# la funzione keys restituisce un array contenente tutte le chiavi nell'hash
foreach $ k (keys% hash) (
print "$ k => $ hash ($ k) \ n ";
}

In Perl per il ciclo ogni ha una forma breve:

# se hai dimenticato cosa fa l'operatore qw,
# torna alla prima parte della "programmazione di base Perl"
per $ i (qw / 1 2 3 /) (
stampa "$ i";
}

Cioè, in effetti, ovunque, invece di foreach, puoi semplicemente scrivere per. Perl non confonderà tale notazione con un ciclo for reale, perché in quest'ultimo è necessario scrivere punti e virgola e così via.

Mentre, i cicli fino e do funzionano allo stesso modo di C ++ o Pascal / Delphi:

# stampa "1 2 3 4 5" in quattro modi diversi

$ io = 0;
mentre ($ i< 5 ) { # mentre $ i è inferiore a cinque
stampa ++ $ i. "";
}
stampa " \ n "; # nuova linea

$ io = 0;
fino a ($ io == 5) ( # finché $ i è uguale a cinque
stampa ++ $ i. "";
}
stampa " \ n ";

$ io = 0;
fare (
stampa ++ $ i. "";
) mentre ($ i< 5 ) ; # spunta alla fine del ciclo
stampa " \ n ";

$ io = 0;
fare (
stampa ++ $ i. "";
) fino a ($ i == 5);
stampa " \ n ";

Simile alle istruzioni if ​​e less, esiste una notazione abbreviata per i cicli:

$ io = 0;
stampa ++ $ i. "" mentre ($ i< 5 ) ;
stampa " \ n ";

$ io = 0;
stampa ++ $ i. "" fino a ($ i == 5);
stampa " \ n ";

stampa "$ _" per (qw / 1 2 3 4 5 /); # puoi anche foreach (qw / 1 2 3 4 5 /);
stampa " \ n ";

Notare l'ultimo ciclo foreach. Ricordiamo che questa è una scorciatoia per foreach, non un ciclo for, giusto? Quest'ultimo, tra l'altro, non ha una voce breve. Quindi, il nome della variabile non è stato specificato qui, con l'aiuto del quale faremo riferimento agli elementi dell'array. Non può essere utilizzato nella stenografia foreach. In questo caso, viene utilizzata una variabile speciale - $ _. Anche il seguente esempio funziona abbastanza:

per (qw / 1 2 3 4 /) (
stampa "$ _";
}

A proposito, può essere riscritto come segue.

E abbiamo imparato come i numeri e le stringhe vengono convertiti tra loro al volo. Abbiamo anche avuto un assaggio di espressione condizionale Se ma non ho ancora capito come confrontare i due scalari. A proposito ci sarà un discorso in questa parte.

Se abbiamo due variabili $ x e $ y, possiamo confrontarle? 1, 1.0 e 1.00 sono uguali? Che ne dici di "1.00"? Che è più "pippo" o "bar"?

Due insiemi di operatori di confronto

Perl ha due serie di operatori di confronto. Come per gli operatori binari di addizione (+), concatenazione (.) e ripetizione (x) che abbiamo già studiato, anche qui l'operatore determina come si comportano gli operandi e come vengono confrontati.

Questi due gruppi di operatori sono:

Valore stringa numerico == eq è uguale! = Ne non è uguale< lt меньше >gt di più<= le меньше или равно >= ge è maggiore o uguale

Gli operatori a sinistra confronta valori numerici, e sulla destra (nella colonna centrale) confronta i valori in base alla tabella ASCII o alle impostazioni internazionali correnti.

Diamo un'occhiata ad alcuni esempi:

Usa rigoroso; utilizzare gli avvisi; usa 5.010; if (12.0 == 12) (dire "VERO";) else (dire "FALSO";)

In questo caso più semplice, Perl stamperà VERO perché l'operatore == confronta due numeri, quindi a Perl non interessa se sono scritti come numeri interi o in virgola mobile.

Nel prossimo confronto, la situazione è un po' più interessante.

"12.0" == 12

questa espressione è vera anche perché l'operatore "a ==" di Perl converte una stringa in un numero.

2 < 3 истинно, так как < сравнивает два числа. 2 lt 3 также истинно, ведь 2 находистя перед 3 в Tabella ASCII... 12> 3 è ovviamente vero. 12 gt 3 tornerà FALSO

Questo può sembrare inaspettato a prima vista, ma se ci pensate, Perl confronta le stringhe carattere per carattere. Quindi confronta "1" e "3" e poiché sono diversi e "1" viene prima di "3" nella tabella ASCII, a questo punto Perl decide che la stringa 12 è inferiore alla stringa 3.

Devi sempre essere sicuro di confrontare il valore esattamente come ti serve!

"foo" == "bar" sarà vero

Verrà inoltre visualizzato un avviso se (!) Gli avvisi sono abilitati con gli avvisi di utilizzo. La ragione di ciò è che stiamo usando due stringhe come numeri nel confronto numerico ==. Come menzionato nella sezione precedente, Perl guarda una stringa da sinistra e la converte nel numero che trova lì. Poiché entrambe le stringhe iniziano con lettere, verranno convertite in 0. 0 == 0, quindi l'espressione è vera.

Dall'altro lato:

"pippo" eq "bar" è falso

Quindi devi sempre assicurarti di confrontare il valore esattamente come dovrebbe!

Lo stesso sarà quando si confronta

"foo" == "" sarà vero

"pippo" eq "" sarà falso

I risultati in questa tabella potrebbero tornare utili:

12.0 == 12 VERO "12.0" == 12 VERO "12.0" eq 12 FALSO 2< 3 ИСТИНА 2 lt 3 ИСТИНА 12 >3 VERO 12 gt 3 FALSO! (attenzione, potrebbe non essere ovvio a prima vista) "foo" == "" VERO! (Emette un avviso se viene utilizzato il pragma "warnings") "foo" eq "" FALSE "foo" == "bar" TRUE! (Emette un avviso se viene utilizzato il pragma "warnings") "foo" eq "bar" FALSE

E infine, un esempio in cui puoi cadere in una trappola ricevendo alcuni dati dall'utente e tagliando con cura il feed di linea alla fine, controlla se la linea è vuota.

Usa rigoroso; utilizzare gli avvisi; usa 5.010; stampa "input:"; il mio $ nome = ; chomp $ nome; if ($ nome == "") (# sbagliato! usa eq qui invece di ==! pronuncia "VERO";) else (dici "FALSO";)

Se eseguiamo questo script e digitiamo "abc", otteniamo una risposta TRUE, perché perl ha deciso che "abc" è uguale a una stringa vuota.