Základní syntaxe ================ Synaxe v základu Céčková: příkazy oddělené středníkem, bloky ve složených závorkách. Mezery se obvykle ignorují, ale občas významné: f(1, 2, 3); <-- zavolání funkce 'f' se třemi parametry f (1, 2, 3); <-- zavolání funkce 'f' s jedním parametrem -- seznamem (1,2,3) f\ (1,2,3); <-- escapovaná mezera (unspace) -- opět tři parametry @pole\ [42]; <-- před závorkou indexující pole nesmí být mezera @pole[ 42 ]; <-- ale tady může Komentáře: # řádkový komentář #`{{ víceřádkový komentář (používat opatrně, ale hodí se k zakomentování kusu kódu) za mřížkou je zpětný apostrof lze použít i jiný pár oddělovačů, viz quoting constructs (4. týden) }} Identifikátory: písmena, číslice (obojí dle nějaké unicodové definice) *pomlčky*, apostrofy (ne na začátku/konci, za nimi písmeno) nesmí začínat číslem příklady: don't-panic, číslo42, __ANSWER neplatné: x', --force, 42answers, číslo-42 opět pozor na mezery: $x-y <-- proměnná s pomlčkou v názvu $x - y <-- od proměnné $x odečteme návratovou hodnotu funkce y $x-$y <-- rozdíl $x a $y, protože název nemůže končit pomlčkou $x-4 <-- od hodnoty $x odečteme 4 holý identifikátor obvykle znamená volání funkce bez parametrů Literály ======== Celá čísla: 1024 1_048_576 <-- podtržítka pro přehlednost (lze napsat kamkoli) 0xBeeF <-- šestnáctkový literál 0o755 <-- osmičkový literál (0755 je syntax error) 0b101010 <-- binární literál :17<1g> <-- číslo 33 zapsané v sedmnáctkové soustavě Racionální čísla (uložená přesně, typ Rat): 4.2 1.0 <-- nelze "1." 0.1 <-- nelze ".1" Floaty (vždy obsahují 'e', typ Num): 6.62e-34 <-- Planckova konstanta 6.022e23 <-- Avogadrova konstanta Stringy: 'hello world' <-- bez interpolace, jediné escapy: \', \\ "Hello, $name!\n" <-- s interpolací proměnných a obvyklými backslash escapy "1+1 = {1+1}" <-- interpolace obecných výrazů Proměnné ======== ## Sigily ## Název proměnné = sigil + identifikátor Sigil je speciální znak určující (částečně) typ obsahu proměnné. $ sklalár (může obsahovat cokoli) @ pole (nebo něco, co se chová jako pole) % hash - slovník (nebo něco, co se chová jako hash) & subrutiny: func <-- návratová hodnota zavolání 'func' bez parametrů &func <-- odkaz na funkci 'func' (lze předat jako parametr jiné funkci atd.) např. @pole.map(&sin) Sigil je nedílnou součástí názvu: $x a @x jsou dvě nezávislé proměnné. Na rozdíl od Perlu 5 se sigil nemění při indexování: Perl 6 Perl 5 Celé pole @pole @pole První prvek @pole[0] $pole[0] Mezi sigilem a názvem může být sekundární sigil (twigil): $.attr <-- atribut aktuálního objektu $*IN <-- dynamická proměnná (v první aproximaci: něco jako globální proměnná) $^a <-- automaticky deklarovaný parametr $?LINE <-- proměnná kompilátoru ## Deklarace proměnných ## Proměnné musí při prvním použití (nebo před ním) deklarovány. Deklarátor my: vytvoří lexikálně lokální proměnnou (platí v aktuálním bloku a všech vnořených, od místa deklarace do konce) my $x; <-- deklarace proměnné $x (obsahuje nedefinovanou hodnotu Any) my $x = 42; <-- deklarace a inicializace my ($x,$y); <-- deklarace dvou proměnných (my $x, $y) = (1, 2); <-- deklarace se může nacházet kdekoli uvnitř výrazu Deklarace s typovým omezením: my Int $x; <-- celé číslo nebo celočíselný undef my Int:D $x; <-- celé číslo, musí mít definovanou hodnotu Další deklarátory (lze psát místo 'my'): our $x; <-- globální proměnná daného modulu (viditelná zvenku) state $x; <-- proměnná, která si zachová hodnotu napříč opakovanými vstupy do bloku (např. více iterací for cycklu, více zavolání funkce) Výpis prvků pole s indexy: for (@pole) { print (state $i)++, $_; } Další manipulace s proměnnými: temp $x = 42; <-- dočasně změní hodnotu proměnné, na konci bloku vrátí původní (jako "local" v Perlu 5) Anonymní proměnné: $, @, ... každý výskyt vytvoří novou proměnnou ($a, $, $) = my-func; <-- zahození nepotřebných hodnot (funkce vrací tříprvkový seznam) jsou automaticky state: for (@pole) { say $++, $_; } <-- vypíše prvky pole s indexy Základní operátory ================== aritmetické: +, -, *, % běžné aritmetické / vrací racionální číslo, bez ohledu na typ operandů div celočíselné dělení %% operátor dělitelnosti ($x %% 2 je True, pokud je $x sudé) konverzní (unární): + na číslo (+@pole dá délku pole) ~ na string @ na pole (či něco podobného) % na hash (či něco podobného) ? na boolean (moc často nejsou potřeba, většina operátorů a funkcí autokonvertuje své operandy, např.: "1"+"1" je 2) porovnávací: == < > <= >= ≤ ≥ číselné porovnání (operandy převedeny na čísla) <=> třístavové číselné porovnání (vrací Less, Same, nebo More) používá se při třídění eq lt gt le ge stringové (lexikografické) porovnání leg třístavové stringové porovnání === identita objektů before after obecné porovnání dvou objektů, i různých typů (třeba pokud chceme binárně hledat v heterogenním poli) další: min, max ano, to jsou binární operátory, obvykle použité v konstrukcích: [max] @pole <-- maximum z pole (redukční metaoperátor) $m min= $x; <-- udržování průběžného minima logické: &&, ||, // zkrácené vyhodnocování && vrátí první nepravivý operand (nebo poslední operand) 4 && 0 && 5 vrátí 0 4 && 5 && 6 vrátí 6 || vrátí první pravdivý operand (nebo poslední operand) 0 || 4 || 5 vrátí 4 0 || False || "" vrátí "" // se chová jako ||, ale používá definovanost místo pravdivosti Any // 0 // 4 == 0 používá se pro doplnění defaultu pro "nevyplněné" hodnoty: ($x // "default") $x //= "default" Řídicí konstrukce ================= Základní podmínka (složené závorky povinné) if $x == 0 { say "nula" } Elsif/else: if $x == 0 { say "nula" } elsif $x == 1 { say "jedna" } elsif $x == 2 { say "dva" } else { say "do tolika počítat neumím" } Negovaná podmínka: unless $x==0 { say "nenulové"; } Podmínka za příkazem: say "nula" if $x==0; Podmínka na (ne)definovanost: with ($x) { say "x = $_"; # blok se provede, pokud je $x definované, a nastaví ho jako topic } die without $filename; # skončí chybou, pokud nebyl určen název souboru While cyklus (syntaxe jako if): while ($x != 0) { ... } While cyklus s negovanou podmínkou: until ($x == 0) { ... } Řízení smyček: next <-- skok na další iteraci (jako 'continue' v jiných jazycích) last <-- ukončení cyklu (jako 'break' v jiných jazycích) Nekonečná smyčka: loop { say "A už tam budem?"; } Céčkový for (málokdy užitečný): loop (my $i = 0; $i < 42; $i++) { say $i; } # hezčí zápis: for 0..^42 -> $i { say $i; } # .say for ^42; Volání funkcí ============= Poziční parametry: my-func; <-- volání bez parametrů (1 + my-func) <-- volání bez parametrů uvnitř výrazu my-func 1, 2, 3; <-- volání bez závorek (3 parametry) my-func(1,2,3); <-- volání se závorkami (3 parametry), užitečné uvnitř výrazů my-func (1,2,3); <-- jeden parametr -- seznam (1,2,3) $obj.my-meth: 1, 2, 3; <-- volání metody bez závorek potřebuje dvojtečku $obj.my-meth(1,2,3); <-- volání metody s parametry v závorkách (1 + $obj.my-meth) <-- volání metody bez parametrů, i uvnitř výrazu Pojmenované parametry: process in => 'input.txt', out => 'output.txt'; <-- dva pojmenované parametry Příslovce (jiný zápis pojmenovaných parametrů): Příslovce Význam --------- ------ :force force => True :!verbose verbose => False :$filename filename => $filename :level(9) level => 9 :10lines lines => 10 # jen pro celá