PERL ---Úvod--- Perl byl vytvořen pro zpracování textových dat. Programy v něm jsou krátké a srozumitelné. Vyznačuje se tím, že je možné jednu věc udělat více způsoby - připomíná lidský jazyk. Interpretovaný jazyk ---Stavba jazyka--- výraz - po vyhodnocení má určitou hodnotu příkazy - výrazy ukončené středníkem - mají taky hodnotu, můžou být v bloku {příkaz1; příkaz2; komentáře - #koment nebo více řádků přes =for comment... =cut identifikátory objektů - case-sensitive, druhy objektů: a) proměnná - obsahuje hodnotu jednoduchou nebo násobnou b) funkce - podprogramy c) ovladače souborů, formáty, typegloby Objekty se nemusí nikde deklarovat ani inicializovat. Existuje spousta implicitních proměnných a funkcí. ---Datové typy--- --Různé-- Ovladače souborů Formáty Typeglob - záznamy z tabulky symbolů - různé typy objektů se stejným jménem: jmeno - @jmeno, %jmeno,&jmeno... --Proměnné-- Identifikátor proměnné začíná dle druhu různým znakem: a) skalár - $jmeno - jedna hodnota (řetězec, číslo, odkaz) b) pole - @jmeno - seznam skalárů (dané pořadí prvků) c) hash - %jmeno - asociativní pole (náhodné pořadí prvků) - "klíč"=>"hodnota" Logické hodnoty - pravidla pravdivosti: a) pravda - $x = 1; $x = defined; b) nepravda - $x = 0; $x = undef; Při práci s proměnnými je důležitý kontext - skalární nebo seznamový. Všude je předávání odkazem - původní hodnota se mění. Když dám v bloku před jméno my, tak je hodnota taková jenom v tom bloku. Implicitní: $_ - prvek v seznamu, @_ - seznam argumentů funkce ze STDIN -Řetězcespeciální znaky - \n - konec řádku modifikátory - \u - převede následující znak na velké písmeno zápis - 'neco' nebo q//... bez vkládání, "jmenuji se $jmeno" nebo qq//... s vkládím proměných spojení: 'neco'.'dalsi'; -Polevytvoření: @pole = (1,3,'neco',8) nebo @pole = gw(1 3 neco 8) sekvence: @cisla = (1.. 10) přístup k prvkům: $pole[0] # 1; $pole[-1] # 8; počet prvků: $pocet = @pole nebo scalar @pole; $x = (2,8,1,6) # vypíše 6 $#pole - hodnota posledního indexu pole práce s více prvky zároveň: @pole[5..7] = (5, 6, 7); výběr více prvků: @jine = @pole[1,3]; funkce pro práci s poli: - push(@pole,'neco'): přidat prvek na konec; pop(@pole): smazat poslední prvek - unshift: přidat prvek na začátek; shift: smazat první prvek; - splice: nahradit prvky - split: řetězec na pole; join - pole na řetězec; - delete $array[index] : smazat prvek na určitém místě - splice(@pole, $i, 1) : smazat prvek a změnit indexy procházení polem:
foreach $prvek (@pole) { # zpracuj $prvek nebo for my $i (0.. $#x) { print "$i: $pole[$i]\n"; -Hashevytvoření: %hash = ('1' => 'červená', '2' => 'modrá', '3' => 'zelená'); nebo (1,'červená',2,'modrá') přístup k prvkům: $moje = $hash{1 převod pole na hash: %hash = @pole; přidat prvek: $hash{5 = 'fialová'; Funkce pro práci s hashi: - each(%hash): načte první pár hodnot do seznamu a přesune ukazatel na další while(($key,$value) = each(%hash)) { print "$key - $value \n"; - delete($hash{key): smazat prvek - keys(%hash): seznam všech klíčů foreach $key (keys %hash) { print "$key - $hash{$key\n"; - values(%hash): seznam všech hodnot - exists($hash{key): jestli tam je tento klíč ---Operátory--- Jsou to v podstatě funkce pracující s operandy, mají však zvláštní způsob zápisu a různou prioritu. Takže to znamená, že funkce jsou zvláštní případ operátoru. Není potřeba psát zbytečně závorky. Termy jsou proměnné, uvozovkové (a podobné) operátory, operátor <>, výrazy v kulatých závorkách a funkce s parametry v závorkách (seznamové i unární operátory). - inkrementace: $x = 1; print ++$x; # nejprve zvýší hodnotu $x na 2, vytiskne 2 print $x++; # vytiskne 2 a pak zvýší hodnotu $x na 3 - umocňování: 2**4; # dvě na čtvrtou (výsledek 16) - unární:!... logická negace výrazu; -... mínus u čísla - matematické: / + % a další jako např. cos x - testování souborů: -w 'neco.txt'; # vrátí jedna pokud je možné do souboru zapisovat - relační, rovnost: různé pro čísla a řetězce (např. <... lt) - logické: a) vysoká priorita: && - AND, - OR : open(file,'dat.txt') die "nelze otevrit soubor"; b) nízká priorita: and, or, not, xor : open FILE, "$soubor" or die "Nelze otevřít soubor."; - operátor rozsahu: 1..10; 'a'..'z'; - podmínkový operátor: $max = $a > $b? $a : $b; # do proměnné $max se uloží větší z čísel $a a $b $a > $b? $text = "a je vetsi nez b" : $text = "b je vetsi nez a"; - operátor přiřazení: l-hodnota OPERÁTOR= hodnota; např. $x += 5... $x = $x + 5 - operátor čárka:, je synonymum pro => skalární kontext - vyhodnotí výraz na pravé straně a vrátí jeho hodnotu seznamový kontext - oddělovač prvků seznamu ---Příkazy--- Jednoduché příkazy: např. chomp($x = <>)... načíst vstup od uživatele a oříznout jej -Modifikátoryzkrácený zápis příkazů na jeden řádek if, unless: $podil = $x / $y if $x!= 0; Složené příkazy se skládají z klíčových slov, výrazů a bloků. - if (VÝRAZ) BLOK else BLOK
- while (VÝRAZ) BLOK continue BLOK - for (my $i = 1; $i <= 10; $i++) BLOK - foreach PROMĚNNÁ (SEZNAM) BLOK implicitní proměnná $_ v rámci cyklu: @cisla = (1..10); foreach (@cisla) { $_ = $_**2; - řízení cyklů: návěští, last, next - holé bloky: cykly,které se provedou právě jednou - switch nejlépe takto: $a=3; $b = 3; BLOK: { if ($a > $b) {print "a"; last BLOK if ($b > $a) {print "b"; last BLOK print "rovna se"; ---Podprogramy--- Existují předdefinované (vestavěné), je možnost definovat vlastní funkce. Jméno funkce začíná s & pro např. pro vytvoření odkazu. - definice nové funkce: sub jmenofunkce { příkazy - volání funkce: jmenofunkce arg1, arg2; --Argumenty-- Tvoří jeden seznam, který je uvnitř funkce přístupný přes pole @_ -> jednotlivé argumenty přes $_[index] Pouze reálné(předávání odkazem) - pokud to nechci, přiřadit to do lokálního pole: -> my @args = @_ -Příklad- # definice funkce sub soucet { my $s = 0; foreach (@_) { $s += $_; return $s; # volání funkce print soucet 1,3,8; -Pojmenování argumentů pomocí hashesub vydel { my %args = @_; return $args{-nahore/$args{-dole; print vydel(-nahore => 12, -dole => 6); -Předávání neskalárárních argumentů- Když vložím pole hodnot, tak se to pole ztratí: @a = (1, 2, 3); @b = (4, 5, 6); @c = (@a,@b) # pole ma 6 prvku Musím to vložit jako odkaz: @c = (\@a,\@b); # pole ma 2 prvky Přístup k prvkům v určitém poli: $prvek = $c[1][2]; --Volání funkce-- Použití jména funkce ve výrazu. Argumenty se nemusí dávat do závorky.
Funkce se nemusí volat s použitím počátečního &. Při použití tohoto symbolu: - nebere se v úvahu případný prototyp - argumenty funkce musejí být uzavřeny v závorkách, bez argumentů: pole @_ --Prototypy-- Prototypem lze při definici funkci říct, kolik argumentů funkce očekává a jakého typu mají být. Interpretr to potom při překladu programu kontroluje. typy: $,@,%,& \ jako odkaz a * pro ovladač sub mojefunkce($$) {... # definice mojefunkce 2,$x; # volání mojefunkce 5; # neplatné volání --Uzávěry-- divný :) --Konstantní funkce-- Někdy je v okamžiku překladu funkce jasné, jaká bude návratová hodnota funkce. Potom Perl všechny výskyty volání funkce nahradí touto hodnotou. Jsou to konstanty. Lze zapsat taky pomocí pragmatu use constant: use constant DEBUG => 0; sub PI () { 3.141592654 # definice print "PI je ".PI; # výpis, nebo také: "PI je @{[PI]" nebo "PI je ${\PI" ===Odkazy=== Pevný odkaz (reference)je hodnota, která obsahuje konkrétní adresu v paměti, kde se nachází odkazovaná hodnota. Získání hodnoty z odkazu se nazývá dereference. ==Vytváření pevných odkazů== =Operátor obrácené lomítko= $x = 123; # nastavení hodnoty proměnné $rx = \$x; # vytvoření odkazu na proměnnou =Konstruktory= a) anonymní pole: $array_reference = [1, 'a', 'xxxxx']; b) anynomyní hash: $dny_ref = { 'Pondělí' => 1, 'Úterý' => 2 ; c) anonymní podprogram: $code_reference = sub { print "Ahoj." ; d) $object = new Class; ==Používání pevných odkazů== proměnná: TypJmeno odkaz: $JmenoOdkazu přístup: Typ$JmenoOdkazu nebo Typ{$JmenoOdkazu nebo $JmenoOdkazu->[0] =Příklady= $cislo = $$rx; # promenna obsahuje 123 @pole = (1,2,3); $rp = \@pole; $prvni = $$rp[0] nebo ${$rp[0] nebo $rp->[0]; # promenna obsahuje 1 Platí pravidlo, že mezi hranatými a složenými závorkami a mezi dvojící složených závorek není třeba psát symbol ->. $pole[0]->[1]->[3]... $pole[0][1][3] ==Pseudohashe== $pseudohash = [{a => 1, b => 2, c => 3, 'xx', 'yy', 'zz']; print $pseudohash->{a; # ma vypsat yy ale nefunguje
==Symbolické odkazy== $jmeno = 'aaa'; $$jmeno = 10; # do proměnné $aaa se nastavi hodnota 10 print $aaa nebo ${aaa ===Složitější datové struktury=== ==Záznamy== Pomocí hashe nebo pole. ==Vícerozměrná pole== Seznamy mohou obsahovat jenom skalární hodnoty - musím použít odkazy. @a = (1,2); @b = (3,4); @pole = (\@a, \@b); print ${$pole[1][0]; print $pole[1]->[0]; # vypise 3 @pole1 = @{$pole[0]; # ziskame prvni pole print $pole1[1]; # vypise 2 =Dynamické vytváření= while (<>) { chomp; @radek = split /\s+/; push @matice, [@radek]; # konstuktor anonymního pole # nebo pouze push @matice, [split /\s+/]; ==Hashe polí== %hry = ( 'ps3' => ['metal gear solid 4', 'god of war 3'], 'xbox360' => ['gears of war 2', 'forza 3'] ); @ps3hry = @{$hry{ps3; print "${ps3hry[1]\n"; # vypise god print $hry{ps3[0]; # vypise metal print ${$hry{ps3[0] # taky metal ==Pole hashů, hashe hashů== podobne jako nahore ===Některé věstavěné funkce=== je jich hodně :) caller - vrací pole: package, soubor, radek chop $value - odstraní poslední znak a vrátí ho chomp $value - odstraní znak konce řádku crypt($heslo, $sul) - vrati hash hodnotu grep VYRAZ, SEZNAM - vypis hodnot ze seznamu podle určité podmínky ===Formáty=== Slouží k vytváření hezkých výstupů. Formát se uplatní při volání funkce write, která pro formátování výstupu použije aktuálně vybraný formát. Pro definici formátu se používá funkce format. ===Regulární výrazy=== Regulární výraz je vzorem, který popisuje obsah řetězce.
Tento vzor se s řetězcem porovnává a výsledkem porovnání je pravdivá hodnota v případě, že řetězec vzoru odpovídá, v opačném případě je výsledkem hodnota nepravdivá. Kvantifikátory se chovají tzv. hladově - pohltí tak velkou část řetězce, jak je to jenom možné. - dá se to změnit použitím? po kvantifikátoru:.*? ==Zápis== reg výraz vyhledání: /vzor/ reg výraz nahrazení: s/vzor/nahrada /vzor/g... pole s obsahem () nebo pole $&( všechny nalezené podřetězce) /vzor/... pole s obsahem () (tzn. ($1, $2,..., $+)) nebo (1) Použijeme-li modifikátor g, neprovádí se prohledávání řetězce vždy od začátku, ale od pozice, kde skončilo poslední úspěšné prohledávání. Při neúspěšném prohledávání se ukazatel posune zpět na začátek řetězce (pokud nepoužijeme modifikátor c). ==Použití== # základní $x = '2 zdar 4'; $a = $x =~ /\d/; # vypíše 1 - nalezeno @a = $x =~ /\d/; # vypíše 1 - nalezeno @b = $x =~ /(\d)/; # vypíše 2 - obsah první závorky () @c = $x =~ /\d/g; # vypíše 24 - nalezené podřetězce @d = $x =~ /(\d)/g; # vypíše 24 - to stejné print @d; # vypíše možnost @d # nahrazení $text = 'neco'; $text =~ s/[a-z]/2/g; print $text; # vypíše 2222 # vyhledání $text = 'neco'; $text =~ /ec/; print $&; # vypíše ec - nalezený řetězec # nahrazení 2 $html = '<B>text</B> jiný text <B>zase jiný text</b>'; $html =~ /<B>(.*?)<\/B>/; # do proměnné $1 se uloží 'text' print $+; # vypíše text - poslední obsah závorky # vyhledání 2 $x = '1 2 3'; while ($x =~ /\d/g) { print "nalezeno $&\n"; # vypíše nalezeno 1 nalezeno 2 nalezeno 3 ==Návratová hodnota== 1) skalární kontext: 1 (úspěch), "" (neúspěch) 2) seznamový kontext: neúspěch: prázdný seznam úspěch: a) bez /g - pole s obsahem () (tzn. ($1, $2,..., $+)) nebo (1) b) s /g - pole s obsahem () nebo pole $& (seznam všech nalezených podřetězců) # data $x = '1 2 3 4'; # vyhodnocení v seznamovém kontextu @x = $x =~ /(\d) (\d)/; # @x obsahuje (1, 2) @x = $x =~ /(\d) (\d)/g; # @x obsahuje (1, 2, 3, 4) # jiné vyhodnocení v seznamovém kontextu print $x =~ /(\d) (\d)/; # vytiskne '12' # vyhodnocení ve skalárním kontextu
$a = $x =~ /\d \d/; print $a; # vypíše 1 ===Práce se soubory=== Používají se ovladače. Funkce pro ovladače. ==Použití== # základní - přečíst všechny řádky $ok = open FILE, "data.txt"; # otevřít soubor pro čtení print $ok; # vypíše 1 pokud úspěšné while(<file>) { # číst ze souboru po řádcích print "$.: $_"; # vypsat číslo řádku a obsah řádku # další příklady open FILE, "data.txt"; $radek = <FILE>; # obsahuje první řádek @radky = <FILE>; # obsahuje všechny řádky v seznamu print $radky[1]; # vypsat druhý řádek print <FILE>; # vypsat soubor jako seznam - včetně znaků pro konec řádku # standardní ovladače $cislo = <>; # ovladač - je standardní vstup - klávesnice print $cislo*10; # vypíše zadané číslo # různé funkce open FILE, "data.txt"; seek FILE, 3, 0; # posunout se za třetí znak v prvním řádku souboru $radek = <FILE>; print $radek; # vypíše první řádek od 4. znaku # zápis open FILE, "> data2.txt"; # otevřít soubor pro přepis; >> pro zápis na konec souboru print FILE "zdar\n"; # zapsat do souboru text a znak pro konec řádku print FILE "chlape"; # zapsat pouze text print FILE ", jak se mas?"; # ověření otevření souboru open FILE, "data.txt" or die "Nelze otevřít soubor."; # čeština v souboru - jiná funkce open open(my $fh, "<:encoding(utf-8)", "filename") die "can't open file: $!"; ===Perl a čeština=== Tj. kódování UTF-8 - Zadat do windows terminálu: chcp 65001 - Ve skriptu neco.pl musí být na začátku toto: use utf8; use open qw( :encoding(utf-8) :std ); # stdin, stdout, stderr používají utf-8 # nebo toto: binmode(stdout, ":encoding(utf-8)"); ===Moduly=== zobrazit instalované moduly: instmodsh