Guia ràpida
ca
Aquest programa d'aprenentatge és una guia ràpida per a no programadors o inexperts. Prova de cobrir els aspectes bàsics i ho fa de manera gradual.
Aquest programa d'aprenentatge és una guia ràpida per a no programadors o inexperts. Prova de cobrir els aspectes bàsics i ho fa de manera gradual.
Provem-ho amb un exemple senzill. Aquest és un exemple habitual en tots els programes d'aprenentatge i llibres de programació, que imprimeix "Hola món!". Proveu d'executar el programa següent i hauríeu de veure'n la sortida.
say 'Hola món!'Aquí say és una funció que accepta arguments i els imprimeix a la sortida.
Proveu de corregir el codi següent per tal que imprimeixi 'Adéu':
say ''
__TEST__
like($stdout, qr/Adéu/, q/Hauria d'imprimir «Adéu»/);Sovint els programadors cometen errors que són perfectament correctes des del punt de vista de la sintaxi del llenguatge però tenen inconvenients lògics que generen errors molt difícils de detectar.
Per tal de detectar errors tipogràfics i sorpreses, Perl proporciona dos pragmes molt útils, strict i warnings. Us recomanem utilitzar-los en qualsevol tros de codi. Tots els exemples d'aquest programa d'aprenentatge inclouen implícitament aquestes dues línies, tot i que no es mostren per estalviar espai.
No us cal entendre el codi que hi ha a continuació, només cal que veieu la diferència entre utilitzar els pragmes de seguretat
use strict;
use warnings;
$x += 1;
$y .= 'cadena';
say 'ok';i no utilitzar-los
no strict;
no warnings;
$x += 1;
$y .= 'cadena';
say 'ok';Els números son enters (1, 2, 5) i de coma flotant (1.2, 1e5). No hi ha diferència real entre ells. Perl els tracta de la mateixa manera i els converteix automàticament.
Proveu a imprimir els següents números:
say 1;
say 4.4;
say 1.2e10;Com podeu veure, cada sentència acaba amb ;. Això és com un punt que utilitzem per separar frases.
Les manipulacions aritmètiques bàsiques inclouen: + (suma), - (resta), * (multiplicació), / (divisió), ** (exponent) i % (mòdul).
say 1 + (10/5) * 3Imprimiu el resultat de 5 elevat a 6.
say
__TEST__
like($code, qr/\*\*/, q/Hauríeu d'utilitzar l'operador **/);
like($stdout, qr/15625/, 'Hauria de ser 15625');Les cadenes es declaren utilitzant les cometes simples o dobles. La diferència entre elles no és important ara mateix. Al nostre exemple, el 'Hola món!' era una cadena.
say 'foo'Les cadenes es poden concatenar (enganxar) utilitzant un . com a operador.
say 'foo' . 'bar'Amb l'operador x podeu repetir les cadenes.
say 'foo' x 3;Normalment voldreu manipular les cadenes per obtenir-ne la longitud, trobar-hi un símbol o una subcadena, etc. Les funcions bàsiques de manipulació de cadenes inclouen length(), substr(), index(), rindex().
say length 'foo';
say substr 'foo', 1, 2;
say index 'foo', 'o';
say rindex 'foo', 'o';Imprimiu per pantalla la posició de la cadena 'bol' dins de la cadena 'futbol'.
say
__TEST__
like($code, qr/index/, q/Hauríeu d'utilitzar la funció index/);
like($stdout, qr/3/, q/Hauria de ser a la posició 3/);Les llistes són, bé, llistes de valors. Es declaren utilitzant parèntesis.
say (1, 2, 3, 5)Sovint podeu utilitzar intervals per estalviar una mica de tecleig:
say (1 .. 5)Això també funciona amb caràcters.
Imprimiu una llista de caràcters de la 'b' a la 'm'.
say
__TEST__
like($stdout, qr/bcdefghijklm/, q/Hauria d'imprimir «bcdefghijklm»/);Evidentment, les llistes poden contenir no només números, sinó també caràcters:
say (1, 'hola', 2, 'vosaltres')Les llistes utilitzades a dins d'altres lllistes s'aplanen:
say (1, (2, 3, 4), 5)En els llenguatges de programació l'assignació és una operació que emmagatzema un valor en algun lloc de la memòria de l'ordinador al qual es pot accedir amb el seu nom.
A Perl 5 hi ha tres tipus de dades integrats: escalars, vectors i diccionaris (o vectors associatius). Els escalars poden contenir cadenes i números. Els vectors són llistes ordenades d'escalars als quals s'accedeix amb un índex. Els diccionaris són vectors associatius no ordenats en què s'utilitzen claus per accedir als valors. Les variables que contenen escalars, vectors o diccionaris duen el prefix $, @ i % respectivament.
Les variables es declaren normalment utilitzant el mot my. Per exemple:
my $x = 1;
say $x;Assigneu a una varibe y la cadena 'Hola món!' i imprimiu-la.
my $
say
__TEST__
like($stdout, qr/Hola món!/, q/Hauria d'imprimir «Hola món!»/)Depenent del que contingui la variable (un número o una cadena) hi ha diferents operadors que podeu utilitzar.
Diguem que voleu sumar dos valors numèrics:
my $x = 1;
my $y = 2;
say $x + $y;O que voleu concatenar dues cadenes:
my $x = 'Hola';
my $y = 'vosaltres';
say $x . $ySi provéssiu d'utilitzar + a les cadenes o . als números es convertirien automàticament al tipus adequat.
my $x = 1;
my $y = '2 cops';
say $x . $y;
say $x + $y;Com podeu veure, al segon exemple la cadena '2 cops' s'ha convertit en un número, en aquest cas 2.
Concateneu i imprimiu la cadena 'Resultat=' i la suma de 42 i 13.
my $x = ;
my $y = ;
say
__TEST__
like($stdout, qr/55/, q/Hauria d'imprimir «Resultat=55»/);Els vectors poden contenir una llista d'escalars.
my @vector = (1, 2, 3);
say @vector;Les manipulacions bàsiques dels vectors inclouen obtenir un element amb l'índex (començant des del 0), obtenir el darrer índex, encuar i empilar valors.
my @vector = (1, 2, 3);
# Obté el tercer element
say $vector[2];
# Obté el darrer índex
say $#vector;
# Encua el valor 4
push @vector, 4;
say @vector;
# Desencua el darrer valor
pop @vector;
say @vector;
# Desempila el primer valor
shift @vector;
say @vector;
# Empila el valor 0
unshift @vector, 0;
say @vector;Probablement us haureu adonat que quan s'accedeix a un element d'un vector es canvia @ per $, ja que l'element del vector és un escalar, i els escalars duen el prefix $.
Donat el vector que conté la llista (1, 2, 3, 4), imprimiu el tercer element.
my @vector = ;
say
__TEST__
like($stdout, qr/3/, q/Hauria d'imprimir «3»/)Els diccionaris o vectors associatius són col·leccions no-ordenades d'escalars als que es pot accedir mitjançant una clau. Normalment la clau és una cadena de text.
my %diccionari = ('clau1', 'valor1', 'clau2', 'valor2');Enlloc d'utilitzar la coma per a separar les claus i els valors, Perl proporciona => com a operador més llegible, per exemple:
my %diccionari = (clau1 => 'valor1', clau2 => 'valor2');Com en el cas dels vectors, quan s'accedeix a una clau d'un diccionari, la variable esdevé un escalar i per això s'utilitza el símbol $ i les claus {}:
my %diccionari = (clau1 => 'valor1', clau2 => 'valor2');
say $diccionari{clau1};my %diccionari = (clau1 => 'valor1', clau2 => 'valor2');
say keys %diccionari;
say values %diccionari;El context és un concepte molt important a Perl. Hi ha dos contexts principals: escalar i de llista. El context habitualment afecta com es comporten les funcions i les variables. Això és similar al llenguatge natural.
L'ús més popular del context és aconseguir la longitud d'un vector. Normalment, quan utilitzeu un vector en context de llista, aquest retorna tots els seus elements, mentre que si ho utilitzeu en context escalar retorna la seva longitud.
my @vector = (1, 2, 3);
my @vector2 = @vector; # context de llista
say @vector2;
my $longitud = @vector; # context escalar
say $longitud;Abans d'introduir els corresponents operadors de Perl, veiem els conceptes bàsics de l'àlgebra booleana.
L'àlgebra booleana és una variant de l'àlgebra on en comptes de números hi ha els valors 0 i 1, on 1 s'anomena cert i 0 s'anomena fals.
Igual que a l'àlgebra normal hi ha operacions com +, *, etc, les operacions bàsiques a l'àlgebra booleana s'anomenen NOT, AND i OR. Com ja sabeu, a l'àlgebra booleana només tenim els valors cert i fals. Això vol dir que no només s'utilitzen a les diferents operacions, sinó que el resultat d'aquestes operacions és o bé cert o bé fals. Anem a veure-les d'una en una.
No hi ha valors cert i fals a Perl. A Perl cert és tot allò que no és fals, on fals és tot allò que converteix a 0. Per exemple: el mateix 0, '' (cadena buida) o undef.
L'operador NOT és un operador unari, el que significa que opera sobre un únic valor. A Perl, l'operador NOT és !. La taula de la veritat de NOT és:
| x | !x |
| 0 | 1 |
| 1 | 0 |
Veiem quins son els resultats d'utilitzar aquest operador sobre diferents valors. Al següent exemple sumem 0 als valors fals ja que sinó la funció say imprimiria la cadena buida.
say !0;
say !1 + 0;
say !'cadena que es converteix en 1' + 0;
say !'';L'operador AND és un operador binari, el que significa que opera sobre dos valors. A Perl, l'operador AND és &&. La taula de la veritat d'AND és:
| x | y | && |
| 0 | 0 | 0 |
| 1 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 1 | 1 |
Veiem quins son els resultats d'utilitzar aquest operador sobre diferents valors.
say 1 && 1;
say 0 && 1;
say 0 && 0;
say 'cadena' && 1;L'operador OR és un operador binari, el que significa que opera sobre dos valors. A Perl l'operador OR és ||. La taula de la veritat d'OR és:
| x | y | || |
| 0 | 0 | 0 |
| 1 | 0 | 1 |
| 0 | 1 | 1 |
| 1 | 1 | 1 |
Veiem quins son els resultats d'utilitzar aquest operador sobre diferents valors.
say 1 || 1;
say 0 || 1;
say 0 || 0;
say 'cadena' || 0;Com a l'àlgebra normal, els operadors de l'àlgebra boolean tenen la seva prioritat, on diferents operadors s'avaluen abans que altres. L'ordre d'avaluació dels operadors booleans és el següent:
! && ||NOT, AND i OR es poden combinar. També podeu utilitzar parèntesis per canviar l'ordre del flux lògic:
say (1 || 0) && 1Corregiu la següent sentència introduint parèntesis per tal que imprimeixi una cadena buida en comptes de 1.
say !1 || 1 && 1
__TEST__
is($stdout, "\n", q/Hauria de ser una cadena buida/);Els operadors de comparació també retornen valors cert i fals, però s'utilitzen amb números i cadenes. Com que Perl no distingeix entre números i cadenes, hi ha dos grups diferents d'operadors de comparació per a ells.
| == | != | < | <= | > | >= |
| eq | ne | lt | le | gt | ge |
Proveu aquest exemple:
say 1 == 1;
say 10 > 2;
say 3 <= 3;
say 'foo' ne 'bar';Les sentències condicionals us permeten canviar el flux del codi. Les sentències condicionals operen amb els valors booleans que heu après al capítol anterior i inclouen if/else/elsif i unless.
Quan el resultat d'una expressió entre parèntesis és cert, el bloc de codi envoltat de claus s'avalua:
if (1 == 1) {
say 'cert';
}
if (1 == 0) {
say 'fals';
}Si voleu fer quelcom quan l'expressió sigui falsa podeu utilitzar else:
if (0) {
say 'cert';
}
else {
say 'fals';
}Si voleu avaluar de nou l'expressió, podeu utilitzar elsif:
my $x = 1;
if ($x == 0) {
say 'x és zero';
} elsif ($x < 0) {
say 'x és menys que zero';
} else {
say 'x és més que zero';
}També hi ha una forma breu per la sentència if:
my $x = 5;
say 'cert' if $x > 0;unless és el contrari d'if, on és el valor fals el que determina si el bloc s'executa, i no el cert.
my $x = 5;
say 'cert' unless $x == 0;Això és el mateix que:
my $x = 5;
say 'cert' if !($x == 0);Com ja sabeu, a Perl els valors certs són tot allò que no és zero, així que la comparació amb 0 normalment no és necessària:
my $x = 5;
say 'cert' unless $x;Corregiu aquest codi per tal que imprimeixi 'Hola' en comptes d''Adéu' utilitzant operadors lògics i sense canviar el valor d'$x.
my $x = 0;
if ($x) {
say 'Hola';
}
else {
say 'Adéu';
}
__TEST__
like($code, qr/\$x = 0/, q/No hauríeu de canviar el valor d'$x/);
like($stdout, qr/Hola/, q/Hauria d'imprimir «Hola»/);Els bucles son blocs de codi que s'executen vàries vegades. Normalment s'utilizen per a accions repetitives, recòrrer estructures de dades, etc.
Un bucle foreach s'utilitza normalment per iterar sobre una llista o vector. Per exemple:
foreach my $element (1, 2, 3, 4, 5) {
say $element;
}Evidentment, també podeu passar-hi un vector:
my @vector = (1 .. 5);
foreach my $element (@vector) {
say $element;
}Com heu vist, creem un variable $element especial que conté cada l'element del vector en cada iteració. Tingueu present que si canvieu $element esteu canviant el valor del vector:
my @vector = (1 .. 5);
foreach my $element (@vector) {
$element *= 2;
}
foreach my $element (@vector) {
say $element;
}Imprimiu únicament els valors parells de 0 a 10:
foreach my $element (...) {
if (...) {
...
}
}
__TEST__
like($stdout, qr/0\n2\n4\n6\n8\n10/, q/Hauria d'imprimir valors parells/);while és un bucle més avançat que itera mentre una expressió és certa.
my $i = 10;
while ($i > 0) {
say $i;
$i = $i - 1;
}Quan l'expressió $i > 0 és falsa, el bucle s'atura.
Imprimiu només els valors senars de 0 a 10:
my $i = ;
while ($i ...) {
if (...) {
...
}
}
__TEST__
like($stdout, qr/1\n3\n5\n7\n9/, q/Hauria d'imprimir valors senars/);Sovint voldreu sortir d'un bucle sense esperar a que finalitzi. Per fer-ho, podeu utilitzar el mot last:
my $i = 0;
while ($i < 100) {
last if $i == 10;
say $i;
$i = $i + 1;
}Aquest bucle no iterarà 100 vegades per què el finalitzem quan $i és 10.
La variable especial més utilitzada és $_, que és una variable escalar per defecte. Per entendre millor com funciona fem un cop d'ull als exemples.
Coneixeu la funció say. Imprimeix qualsevol argument que li passeu. Però què passa quan no li passeu cap argument? Agafa les dades de la variable per defecte $_.
$_ = 'Hola';
say;És clar que normalment no necessitareu aquesta funcionalitat, però pot ser molt útil quan feu bucles, per exemple:
say for (1 .. 10);Per defecte un bucle for assigna valors a la variable $_ i say els imprimeix.
Moltes de les funcions integrades a Perl utilitzen la variable per defecte quan no se'ls passa cap argument.
Les subrutines són funcions que accepten arguments i que poden retornar el resultat. Normalment les subrutines s'utilitzen per eliminar el codi duplicat, fent-lo més clar i entenedor.
Diguem que voleu convertir 5 milles a kilòmetres. Escriuríeu alguna cosa com aquesta:
# Convertir 5 milles a kilòmetres
say 5 * 1.609344Però i si ara volguéssiu convertir 10 milles a kilòmetres o qualsevol altre número arbitrari? En aquest cas creem una subrutina que podem utilitzar després.
sub milles_a_kilometres {
my ($milles) = @_;
return $milles * 1.609344;
}
say milles_a_kilometres(5);
say milles_a_kilometres(10);
say milles_a_kilometres(42);La subrutina necessita una mica d'explicació. my ($milles) = @_ s'anomena desempaquetament d'arguments. A Perl els arguments que es passen a una subrutina van a parar al vector per defecte @_ (aquesta també és una variable especial de Perl, com la $_). També podeu utilitzar totes les funcions específiques per als vectors sobre el vector per defecte, és clar.
Escriviu i utilitzeu una subrutina que converteix kilòmetres a milles i imprimiu 4, 6, 9 kilòmetres convertits a milles (un kilòmetre són 0.621371192 milles).
sub kilometers_to_miles {
my ...
return ...
}
say kilometers_to_miles(4);
say kilometers_to_miles(6);
say kilometers_to_miles(9);
__TEST__
like($stdout, qr/2.485484768\n3.728227152\n5.592340728/,
q/Hauria d'imprimir els valors correctes/)Les expressions regulars són una part important del llenguatge Perl. És essencial conèixer-les i utilitzar-les quan es processa text. I això és en el que Perl és bo.
Breument, les expressions regulars són patrons especials que quan s'apliquen a les cadenes poden casar o no, capturar diverses subcadenes, modificar la subcadena inicial substituint-ne algunes parts, etc.
L'ús més habitual de les expressions regulars és trobar una cadena concreta dins d'una altra cadena.
my $cadena = 'Hola món!';
if ($cadena =~ m/Hola/) {
say 'He trobat Hola!';
}Aquí teniu un parell de coses noves: =~ i m// (m ve de l'anglès match). També existeix l'operador invers !~ que s'avalua a cert quan l'expressió regular no casa.
my $cadena = 'Hola món!';
if ($cadena !~ m/Adéu/) {
say 'No he trobat Adéu';
}Els conjunts de caràcters són construccions d'expressions regulars que casen amb exactament un caràcter entre molts. Podem crear conjunts de caràcters amb els operadors []. Per exemple:
my $string = 'Adéu';
if ($string =~ m/[aeiou]/) {
say 'He trobat una vocal';
}En aquest cas, el condicional és veritat perquè un dels caràcters dins de la classe de caràcters s'ha trobat a la cadena.
També podem indicar un rang en comptes d'escriure tots els caràcters que volem fer casar:
my $string = 'hola';
if ($string =~ m/[a-g]/) {
say 'He trobat una lletra entre la «a» i la «g» a la cadena';
}En aquest exemple, hem indicat [a-g] en comptes de [abcdefg]. Passa el mateix amb números ([2-5]) i lletres majúscules ([A-Z]).
Quan s'utilitzen rangs cal recordar que sempre cal indicar el rang en ordre alfabètic o numèric. Per exemple, [8-3] no funcionarà com un rang (buscarà coincidir amb els caràcters 8, - i 3).
Modifica aquesta expressió regular per detectar si hi ha cap 'x', 'y' o 'z' en la frase:
my $string = "Estem buscant les lletres x, y o z";
if ($string =~ ) {
say "He trobat una x, y o z";
}
__TEST__
like($code, qr/\[.*\]/, "Cal utilitzar l'operador []");
like($stdout, qr/He trobat una x, y o z/, "Hauria de trobar una x, y o z");Altres conjunts de caràcters s'escriuen sense els []. En comptes d'això consisteixen en una barra invertida \ i una lletra indicant un conjunt de caràcters. Per exemple, per descobrir si una cadena conté com a mínim un dígit, podem utilitzar \d:
my $string = 'El març té 31 dies';
if ($string =~ m/\d/) {
say 'He trobat un dígit!';
}Amb \d estem dient que volem trobar digits. També podem utilitzar \w (de l'anlgès, word) per trobar qualsevol caràcter que s'utilitzi en paraules (lletres, números i el subratllat _):
my $string = 'Aquesta frase té 5 paraules';
if ($string =~ m/\w/) {
say 'He trobat un caràcter de paraula';
}I si volem saber si una cadena conté espais en blanc podem utilitzar \s:
my $string = 'Espai en blanc';
if ($string =~ m/\s/) {
say 'Hi ha un espai en blanc a la cadena';
}Els espais en blanc inclouen tabulacions, espais, salts de linia i retorns de carro.
Podem utilitzar la versió en majúscules d'un conjunt de caràcters per fer coincidir el contrari. Per exemple, amb \S casem qualsevol caràcter que no és un espai o una cadena buida:
my $string = ' ';
if ($string =~ m/\S/) {
say 'Hi ha com a minim un caràcter que no és un espai en blanc';
}
else {
say 'No hi ha caràcters de tipus espai en blanc a la cadena';
}O amb \D fem coincidir qualsevol caràcter que no sigui un dígit:
my $string = '42';
if ($string =~ m/\D/) {
say 'Hi ha com a minim un caràcter que no és un dígit';
}
else {
say 'No hi ha caràcters que no siguin dígits a la cadena';
}Finalment, si volem casar qualsevol caràcter, utilitzem el punt:
my $string = 'Hola, Món!';
if ($string =~ m/./) {
say 'He trobat un caràcter';
}L'única situació en la que un punt no coincideix amb alguna cosa és quan la cadena està buida o només conté un salt de linia.
Les expressions regulars poden ser realment sofisticades. Per exemple, volem comprovar si una cadena té els caràcters a o o:
my $cadena = 'Casa';
if ($cadena =~ m/a|o/) {
say 'He trobat «a» o «o»';
}En aquest cas utilitzem el metacaràcter | per indicar que volem fer coincidir la lletra a o la lletra b. Un altre metacaràcter és +, que ens ajuda a trobar més d'una ocurrència del mateix caràcter a la cadena:
my $string = 'Perl en català';
if ($string =~ m/a+/) {
say 'He trobat com a mínim una «a»';
}De forma similar, * s'utilitza per indicar que pot haver-hi 0 o més ocurrències del caràcter:
my $string = 'Hola, Món!';
if ($string =~ m/l*/) {
say 'Pot haver una lletra «l» o més a la cadena';
}Com que retornarà cert si tampoc hi ha cap coincidència, això també funcionarà:
my $string = 'Hola, Món!';
if ($string =~ m/j*/) {
say 'Pot haver una lletra «j» o més a la cadena';
}Finalment, amb ? indiquem si el caràcter es troba una o cap vegada:
my $string = 'Hola, Món!';
if ($string =~ m/j?/) {
say 'Pot haver-hi o no una lletra «j» a la cadena';
}Aquests metacaràcters són més utils en expressions regulars una mica més complexes. Per exemple, si volem saber si un usuari ha escrit el seu nom, podem assegurar-nos que com a mínim hi hagi una lletra escrita:
my $string = 'Larry';
if ($string =~ m/[a-z]+/) {
say 'La cadena té com a mínim una lletra, pel que pot ser un nom'
}Fins ara, hem utilitzat les expressions regulars per fer coincidir caràcters amb la m al principi de l'expressió. Però un altre ús molt habitual és la substitució amb s:
my $string = 'Hola, Món!';
$string =~ s/Hola/Adéu/;
say $string;En aquest cas, primer indiquem que volem fer una substitució amb la s, després mostrem quina paraula o lletra volem canviar i finalment escrivim la paraula o lletra que l'ha de substituir.
El lema de Perl és "Hi ha més d'una manera de fer-ho". En aquest exercici, canvia la frase per tal que imprimeixi el lema:
my $string = "Hi ha només una manera de fer-ho";
$string =~
say $string;
__TEST__
like($stdout, qr/Hi ha més d'una manera de fer-ho/, "Hauria d'imprimir el lema de Perl");Els modificadors són lletres que s'escriuen al final de l'expressió regular i que influencien el resultat. Per exemple, podem utilitzar i per fer correspondències tant en majúscules com amb minúscules:
my $string = 'Hola, Món!';
if ($string =~ m/h/i) {
say 'Hi ha una «h» o una «H» a la cadena';
}Sense la i al final, no hi hauria coincidència, ja que només hauria buscat la h en minúscules. Un altre modificador molt comú és la g:
my $string = 'Perl en català!';
$string =~ s/a/A/g;
say $string;Amb la g estem indicant a l'expressió regular que sigui cobdiciosa (de l'anglès, greedy) i que substitueixi totes les ocurrències de a per A. Si no indiquem la g, el resultat és Perl en cAtalà!, ja que només substitueix la primera coincidència que troba.
Els modificadors es poden utilitzar tant en les substitucions com en les coincidències.
Les àncores són caràcters especials en expressions regulars que ens ajuden a fixar el que estem buscant al principi (^) o al final ($) de la cadena. Per exemple:
my $string = 'Hola, Món!';
if ($string =~ m/^H/) {
say 'Hi ha una «H» al principi de la cadena';
}Aixo és cert perquè estem buscant una H al principi. En canvi:
my $string = 'Hola, Món!';
if ($string =~ m/^o/) {
say 'Hi ha una «o» al principi de la cadena';
} else {
say 'No hi ha una «o» al principi de la cadena';
}Fixeu-vos com no hi ha coincidència en aquest exemple perquè, tot i que hi ha una o a la cadena, no està al principi de tot. Passa el mateix quan ancorem l'expressió regular al final de la cadena:
my $string = 'Hola, Món!';
if ($string =~ m/!$/) {
say 'Hi ha una «!» al final de la cadena';
}En aquest cas hi ha coincidència perquè l'últim caràcter de la cadena és un símbol d'exclamació.
En aquest exercici, crea una expressió regular de forma que la frase sigui certa, utilitzant conjunts de caràcters i àncores:
my $string = "Perl va néixer el 1987";
if ($string =~ ) {
say "La frase acaba amb un any";
}
like($code, qr/\$\W/, "L'expressió hauria d'utilitzar una àncora");
like($stdout, qr/La frase acaba amb un any/, "La condició hauria de ser certa");Viacheslav Tykhanovskyi, [email protected]
Alba Ferrer, [email protected]
Alba Ferrer, [email protected]
Alex Muntada, [email protected]
Hey! The above document had some coding errors, which are explained below:
- Around line 3:
-
Non-ASCII character seen before =encoding in 'ràpida'. Assuming UTF-8