Array ( [0] => 15482948 [id] => 15482948 [1] => cswiki [site] => cswiki [2] => Tcl [uri] => Tcl [3] => [img] => [4] => [day_avg] => [5] => [day_diff] => [6] => [day_last] => [7] => [day_prev_last] => [8] => [oai] => [9] => [is_good] => [10] => [object_type] => [11] => 1 [has_content] => 1 [12] => Tcl (Tool Command Language) je velmi přívětivý a flexibilní skriptovací jazyk, který byl navržen tak, aby usnadnil vývoj aplikací a automatizaci různých úloh. Jeho hlavním cílem je poskytnout nástroje, které umožňují programátorům i netechnickým uživatelům vytvářet a manipulovat s daty efektivně a intuitivně. Tcl je známý svou jednoduchou syntaxí, která usnadňuje učení a používání jazyka. Uživatelé mohou rychle začít psát skripty a vytvářet funkce, což přispívá k rychlému vývoji aplikací. Díky své flexibilitě a rozšiřitelnosti se Tcl často používá v různých oblastech, jako jsou testování, automatizace, a GUI (grafické uživatelské rozhraní). Jazyk také podporuje různé typy dat a struktury, což uživatelům umožňuje pracovat s komplexními datovými modely. Komunita kolem Tcl je aktivní a přátelská, což znamená, že je snadné najít zdroje nebo pomoc při řešení problémů. Využití Tcl v kombinaci s jeho robustními knihovnami usnadňuje integraci s jinými technologiemi a platformami. Celkově lze říci, že Tcl je skvělým nástrojem pro ty, kdo chtějí efektivně zvládat různé úkoly, a to jak ve světe profesionálního vývoje, tak ve vzdělávání. Jeho přístupnost a síla z něj činí optimální volbu pro mnoho programátorů a nadšenců do technologií. [oai_cs_optimisticky] => Tcl (Tool Command Language) je velmi přívětivý a flexibilní skriptovací jazyk, který byl navržen tak, aby usnadnil vývoj aplikací a automatizaci různých úloh. Jeho hlavním cílem je poskytnout nástroje, které umožňují programátorům i netechnickým uživatelům vytvářet a manipulovat s daty efektivně a intuitivně. Tcl je známý svou jednoduchou syntaxí, která usnadňuje učení a používání jazyka. Uživatelé mohou rychle začít psát skripty a vytvářet funkce, což přispívá k rychlému vývoji aplikací. Díky své flexibilitě a rozšiřitelnosti se Tcl často používá v různých oblastech, jako jsou testování, automatizace, a GUI (grafické uživatelské rozhraní). Jazyk také podporuje různé typy dat a struktury, což uživatelům umožňuje pracovat s komplexními datovými modely. Komunita kolem Tcl je aktivní a přátelská, což znamená, že je snadné najít zdroje nebo pomoc při řešení problémů. Využití Tcl v kombinaci s jeho robustními knihovnami usnadňuje integraci s jinými technologiemi a platformami. Celkově lze říci, že Tcl je skvělým nástrojem pro ty, kdo chtějí efektivně zvládat různé úkoly, a to jak ve světe profesionálního vývoje, tak ve vzdělávání. Jeho přístupnost a síla z něj činí optimální volbu pro mnoho programátorů a nadšenců do technologií. ) Array ( [0] => {{Infobox - programovací jazyk [1] => | název = Tcl [2] => | logo = Tcl.svg [3] => | popisek loga = Tcl logo [4] => | paradigma = [[Programovací paradigma#Multiparadigmatické programovací jazyky|Multiparadigmatický]]: [[Imperativní programování|imperativní]], [[Strukturované programování|strukturovaný]], procedurální, [[Funkcionální programování|funkcionální]], [[Objektově orientované programování|objektově orientovaný]], řízený událostmi [5] => | vznik = 1988 [6] => | autor = [[John Ousterhout]] [7] => | vývojář = [[John Ousterhout]], Tcl Core Team [8] => | poslední verze = [https://sourceforge.net/projects/tcl/files/Tcl/8.6.12/ 8.6.12] [9] => | datum poslední verze = 31. října 2021 [10] => | poslední testovací verze = [https://sourceforge.net/projects/tcl/files/Tcl/9.0a3/tcl-release-notes-9.0a3.txt/view 9.0a3] [11] => | datum poslední testovací verze = 23. června 2021 [12] => | typování = [[Typový systém#Dynamická typová kontrola|dynamická]] [13] => | implementace = [https://www.activestate.com/activetcl ActiveTcl], [https://www.androwish.org Androwish] [14] => | dialekty = [http://jim.tcl.tk Jim] [15] => | ovlivněno = [[Awk]], [[Lisp]] [16] => | ovlivnil = [[PHP]],{{Citace elektronické monografie | příjmení = Lerdorf | jméno = Rasmus | titul = PHP on Hormones – history of PHP presentation by Rasmus Lerdorf given at the MySQL Conference in Santa Clara, California | datum = 2007-04-26 | accessdate=2009-12-11 | vydavatel = The Conversations Network | url=http://itc.conversationsnetwork.org/shows/detail3298.html }} [[Tea (programovací jazyk)|Tea]], [[Windows PowerShell|PowerShell]]{{Citace elektronického periodika |titul=Windows PowerShell : PowerShell and WPF: WTF |url=http://blogs.msdn.com/powershell/archive/2008/05/25/powershell-and-wpf-wtf.aspx |datum přístupu=2016-06-15 |url archivu=https://web.archive.org/web/20081225093003/http://blogs.msdn.com/powershell/archive/2008/05/25/powershell-and-wpf-wtf.aspx |datum archivace=2008-12-25 |nedostupné=ano }} [17] => | operační systém = [18] => | licence = [http://www.tcl.tk/software/tcltk/license.html Stylu BSD] [19] => | web = [http://www.tcl.tk www.tcl.tk] [20] => }} [21] => '''Tcl''' (vyslovuje se „tý-sý-el“ nebo „tykl“, název je zkratkou z '''Tool Command Language''') je jednoduchý, ale účinný [[programovací jazyk|skriptovací jazyk]], který v roce [[1988]] vytvořil [[John Ousterhout]]. Přes nezvyklou [[syntax]]i je Tcl snadno zvládnutelný a díky nízkým nárokům na [[hardware]] je oblíbený především pro [[testování softwaru]], programování [[vestavěný systém|vestavěných systémů]] a [[prototypování]]. V roce 1991 byl doplněn grafickým [[Tk (framework)|frameworkem Tk]] a výsledný systém nazývaný [[Tcl/Tk]] se stal až do nástupu [[Qt (knihovna)|Qt]] a [[GTK+]] jedním z nejoblíbenějších nástrojů pro vytváření [[grafické uživatelské rozhraní|grafických uživatelských rozhraní]]. [[Tk (framework)|Framework Tk]] je dostupný v různých skriptovacích ([[Perl]], [[Python]], [[Ruby]]) i kompilovaných jazycích ([[C++]], [[Ada (programovací jazyk)|Ada]]). Logo jazyka v podobě pírka vychází z anglické slovní hříčky, neboť výslovnost názvu ''tykl'' je stejná jako u slova tickle = lechtat, šimrat. Pírko (brk) má navíc význam coby tradiční nástroj dávných písařů (prvních skriptérů). [22] => [23] => == Vlastnosti == [24] => Základní vlastnosti: [25] => [26] => * [[Imperativní programování|imperativní a procedurální]] jazyk – program je tvořen posloupností příkazů [27] => * rozšiřitelnost – uživatelem definované [[Podprogram|procedury]] se chovají jako vestavěné příkazy z [[Knihovna (programování)|knihovny]] jazyka; lze definovat i příkazy sloužící jako [[Řídicí struktura|řídicí struktury]], Tcl lze rozšiřovat pomocí funkcí v jazyce [[C (programovací jazyk)|C]], [[C plus plus|C++]] a [[Java (programovací jazyk)|Java]] [28] => * extrémně jednoduchá syntaxe – všechny příkazy (i řídicí struktury) mají jednotnou strukturu v [[Polská notace|prefixové notaci]] (výrazy ale používají obvyklou infixovou notaci) [29] => * příkazy mohou mít proměnný počet parametrů [30] => * všechny příkazy mohou být dynamicky předefinovány nebo přetíženy [31] => * všechny datové typy i text programu jsou reprezentovány pomocí [[textový řetězec|textových řetězců]], výsledky funkcí lze vkládat přímo do textu programu; [[zdrojový kód|text programu]] se dá vytvářet za běhu [32] => * proměnné mají implicitně [[Lokální proměnná|oblast platnosti lokální]] ve funkci, v níž jsou použity; příkazy uplevel a upvar umožňují přístup k proměnným z předchozích procedur v řetězci jejich volání; příkaz global umožňuje rozšířit oblast platnosti na celý zdrojový soubor [33] => * podpora [[Jmenný prostor|jmenných prostorů]] [34] => * podpora [[Modulární programování|modulárního programování]] [35] => * existují [[Objektově orientované programování|objektově orientovaná rozšíření]] [36] => * všechny příkazy definované přímo jazykem Tcl generují při nesprávném použití chybová hlášení [37] => * [[interpret (software)|interpretovaný jazyk]] používající bytecode [38] => * plná podpora [[Unicode]] 3.1 od roku 1999 [39] => * [[Portace softwaru|přenositelnost]] – samotný jazyk, i mnoho knihoven (včetně [[Tcl/Tk|Tk]]) jsou nezávislé na platformě ([[Microsoft Windows|Windows]], [[Unix]], [[Linux]], [[Mac OS|Mac]], [[Android (operační systém)|Android]]) [40] => * [[Událostmi řízená architektura|událostmi řízené rozhraní]] pro [[soket]]y a [[soubor]]y; lze používat časové a uživatelem definované události [41] => * úzká integrace s knihovnou [[grafické uživatelské rozhraní|grafického uživatelského rozhraní]] [[Tk (framework)|Tk]] [42] => * obtížná práce se [[Spojový seznam|spojovými strukturami]] [43] => [44] => == Spuštění Tcl == [45] => Základní [[Interpret (software)|interpret]] jazyka Tcl – tclsh – lze spustit bez [[Parametr funkce|parametrů]] a s Tcl pracovat [[interaktivní zpracování|interaktivně]]: [46] => [47] => tclsh [48] => % expr 22/7 [49] => 3 [50] => % expr 22/7. [51] => 3.142857142857143 [52] => % expr 4*atan(1) [53] => 3.141592653589793 [54] => % string length "nejneobhospodařovatelnějšími" [55] => 28 [56] => % exit [57] => [58] => Znak procento (%) je [[Prompt|nápověda]], kterou vypisuje [[interpret (software)|interpret]] Tcl, a která je uváděna pouze u ukázek [[Interaktivita|interaktivní práce]]. Příkaz expr je nutné v Tcl používat pro vyhodnocování [[matematický výraz|matematických výrazů]]. Lomítko je operátor dělení; pro dělení celých čísel se používá [[Celé číslo|celočíselné]] [[dělení se zbytkem]], použitím desetinné tečky u jednoho z operandů se vynutí [[Reálné číslo|reálné dělení]]. Hvězdička je operátor násobení; pro ukončení interpretu lze použít příkaz exit nebo [[Textový soubor#Znak konec souboru|znak konce souboru]], kterým je v [[Microsoft Windows]] a v [[MS-DOS]]u klávesová kombinace Ctrl-Z, v [[Unix]]u Ctrl+D. Aby bylo možné editovat příkazy pomocí [[Kurzorová šipka|kurzorových kláves]], musí být nainstalován balíček tclreadline{{Citace elektronické monografie | url = https://sourceforge.net/projects/tclreadline/ | titul = tclreadline; GNU readline for interactive tcl shells | datum přístupu = 2017-05-09}}; i bez něj lze příkazem history vypsat seznam zadaných příkazů a zvolený příkaz znovu vyvolat zadáním vykřičníku a čísla příkazu. [59] => [60] => Druhý interpret – wish – je určený pro programy používající [[grafické uživatelské rozhraní]]: [61] => [62] => 
    [63] => wish
    [64] => % wm title . "Hlavní okno"
    [65] => % wm minsize . 320 200
    [66] => % label .l -text "Nápis v hlavním okně"
    [67] => .l
    [68] => % pack .l -padx 40 -pady 20
    [69] => % toplevel .w2 
    [70] => .w2
    [71] => % wm title .w2 "Druhé okno"
    [72] => % label .w2.l -text "Nápis v druhém okně"
    [73] => .w2.l
    [74] => % pack .w2.l -padx 10 -pady 10
    [75] => %
    [76] =>
[77] => [78] => – spuštěním wish se otevře hlavní okno okno aplikace; příkazy začínající wm slouží pro komunikaci se [[Správce oken|správcem oken]]: wm title změní text v záhlaví okna a wm minsize předepíše jeho minimální velikost (šířka 320 [[pixel]]ů a výška 200 [[pixel]]ů); příkaz label připraví nápis, který se provedením příkazu pack zobrazí uvnitř okna; příkaz toplevel vytvoří druhé okno, kterému se dalšími příkazy také změní text v záhlaví a ve kterém se vypíše další text; parametry začínající tečkou jsou obdobou [[Cesta (informatika)|cest]] používaných pro navigaci ve stromové struktuře [[Adresář (informatika)|adresářů]] na disku: samotná tečka označuje hlavní okno, .l je prvek pojmenovaný l ve hlavním okně, .w2 je druhé okno a .w2.l je prvek ve druhém okně (na konkrétních jménech l a w2 nezáleží). Příkazy vytvářející grafické prvky, jako label a toplevel, vracejí jméno prvku, které lze uložit do proměnných a používat v dalších příkazech. [79] => [80] => Obvyklejší přístup je ale spouštění předem připravených programů neboli [[Skript (programování)|skriptů]]: [81] => [82] => tclsh program.tcl parametr parametr ... [83] => [84] => Parametry skriptu jsou dostupné jako [[#Práce se seznamy|seznam]] v proměnné argv; počet parametrů lze tedy zjistit pomocí llength $argv. Další možností je čtení proměnné argc z globálního [[Jmenný prostor|jmenného prostoru]], tedy $::argc. Jméno spuštěného skriptu je v proměnné argv0. [85] => [86] => Souborům s programy v jazyce Tcl se obvykle dává [[Přípona souboru|přípona]] .tcl. Aby v Unixu bylo možné pouštět Tcl skripty pouze zadáním jejich jména, je potřeba dát souboru se skriptem [[Přístupová práva v Unixu|právo execute]] a na jeho začátek přidat první čtyři řádky z následující ukázky: [87] => [88] => [89] => #!/bin/sh [90] => # -*- tcl -*- [91] => # The next line is executed by /bin/sh, but not tcl \ [92] => exec tclsh "$0" ${1+"$@"} [93] => [94] => puts "Hello, world!" [95] => [96] => [97] => První řádek díky konstrukci [[Shebang (Unix)|Shebang]] zajistí, že se skript začne interpretovat [[Unixový shell|programem /bin/sh]]; provedením příkazu exec se spustí tclsh, který začne číst soubor se skriptem zase od začátku, ale řádek s příkazem exec považuje za pokračování komentáře z předchozího řádku díky jeho zakončení obráceným lomítkem. [98] => [99] => == Syntaxe a základní sémantika == [100] => Program (skript) v Tcl je tvořen posloupností příkazů. Každý příkaz začíná jménem příkazu, za kterým mohou následovat argumenty (parametry) oddělované od sebe navzájem i od jména příkazu vždy alespoň jednou mezerou nebo [[tabulátor]]em. Příkaz je ukončen koncem řádku nebo středníkem. Jména příkazů v Tcl nejsou vyhrazená slova, ani nemají v jazyce žádné zvláštní postavení; jsou to obyčejné, nijak neprivilegované, funkce v knihovně. Příkazy mohou mít proměnný počet argumentů. [101] => [102] => příkaz argument1 argument2 ... argumentN [103] => [104] => Pokud argumenty obsahují [[bílý znak|bílé znaky]], musí být uzavřeny ve dvojitých uvozovkách nebo ve složených závorkách – pak může být argument i víceřádkový; pokud ale chcete odřádkovat mezi argumenty, je nutné bezprostředně před odřádkování napsat zpětné lomítko. [105] => [106] => === Symboly se zvláštním významem === [107] => * $ – vrací hodnotu proměnné, jejíž jméno je uvedeno za znakem dolar [108] => * [] – závorky včetně obsahu nahradí výstupem Tcl příkazu, který je v závorkách uzavřen [109] => * "" – obsah uvozovek považuje za jediný argument, přitom vyhodnocuje vnořené konstrukce s $, [] a \ [110] => * {} – obsah závorek považuje za jediný argument, ale na rozdíl od uvozovek nevyhodnocuje konstrukce se speciální znaky uvnitř [111] => * \ – ruší zvláštní význam následujícího znaku nebo vytváří řídicí znak nebo znak se zadaným kódem [112] => * # – uvozuje komentář, který končí s koncem řádku; lze použít pouze v místě, kde může začínat příkaz [113] => [114] => Apostrofy nemají v Tcl žádný zvláštní význam. Kulaté závorky se používají pro přístup k prvkům asociativních polí a pro vyjádření priority v aritmetických výrazech. [115] => [116] => === Příkaz puts === [117] => Příkaz puts vypíše zadaný řetězec (který musí tvořit jedno slovo, proto je vhodné jej vždy uzavírat do uvozovek) následovaný znakem konce řádku, implicitně na standardní výstup (kanál stdout): [118] => [119] => [120] => puts "Hello, world!" [121] => [122] => [123] => Pokud puts nemá po vypsání řetězce odřádkovat, je potřeba před řetězcem použít volbu -nonewline: [124] => [125] => [126] => puts -nonewline "Hodnota proměnné i: " [127] => puts $i [128] => [129] => [130] => Před vypisovaným řetězcem lze uvést jméno výstupního kanálu (nebo proměnnou, která se odkazuje na soubor): [131] => [132] => [133] => puts stderr "Chyba!" [134] => [135] => [136] => === Proměnné a příkaz set === [137] => Pro přiřazení hodnoty do proměnné slouží příkaz set; pro získání obsahu proměnné je nutné před její jméno napsat znak dolar: [138] => [139] => % set x 5 [140] => 5 [141] => % puts "Hodnota proměnné x je $x." [142] => Hodnota proměnné x je 5. [143] => [144] => Pokud je příkaz set zadán v příkazovém řádku tclsh (tj. při interaktivním provádění), vypisuje se přiřazovaná hodnota; při provádění programu ne. [145] => [146] => Přiřazení hodnoty výrazu do proměnné není tak jednoduché; je potřeba použít příkaz expr a hranaté závorky pro dosazení výsledku příkazu do jiného příkazu: [147] => [148] => % set stupnu_Fahrenheita 451 [149] => 451 [150] => % set stupnu_Celsia [expr {($stupnu_Fahrenheita-32)/1.8}] [151] => 232.77777777777777 [152] => [153] => Před otevírací hranatou i složenou závorkou musí být mezera; první odděluje parametry příkazu set, druhá jméno příkazu expr od parametru. [154] => [155] => Aby se odlišilo jméno proměnné od okolního textu, lze jej uzavřít do složených závorek ${jmeno}: [156] => [157] => % set a 2 [158] => 2 [159] => % set b 3 [160] => 3 [161] => % puts "${a}x$b=[expr {$a*$b}]" [162] => 2x3=6 [163] => [164] => Tcl není staticky typovaný jazyk: každá proměnná může obsahovat hodnotu libovolného typu – např. celé číslo, reálné číslo, řetězec, seznam, jméno příkazu nebo slovník; hodnoty se převádějí na jiné typy podle potřeby automaticky (s omezeními danými syntaxí). Hodnoty jsou ale vždy konstantní ({{Vjazyce2|en|''immutable''}}); operace, které vypadají, že mění hodnoty, ve skutečnosti pouze vrací jinou hodnotu. [165] => [166] => === Asociativní pole === [167] => [[Asociativní pole]] je složená [[datová struktura]], ve které se pro přístup k jednotlivým položkám používá klíč, kterým může být libovolný [[textový řetězec]]. S prvky asociativních polí se pracuje stejně jako s jednoduchými proměnnými: [168] => [169] => [170] => set hlavni_mesta(ČR) "Praha" [171] => set hlavni_mesta(Slovensko) "Bratislava" [172] => set hlavni_mesta(Polsko) "Varšava" [173] => set hlavni_mesta(Německo) "Berlín" [174] => set hlavni_mesta(Rakousko) "Vídeň" [175] => [176] => set stat Slovensko [177] => puts "Hlavní městem státu $stat je $hlavni_mesta($stat)." [178] => [179] => [180] => Asociativní pole lze také vytvořit pomocí příkazu array set: [181] => [182] => [183] => array set hlavni_mesta { [184] => "ČR" "Praha" [185] => "Slovensko" "Bratislava" [186] => "Polsko" "Varšava" [187] => "Německo" "Berlín" [188] => "Rakousko" "Vídeň" [189] => } [190] => [191] => set stat Slovensko [192] => puts "Hlavní městem státu $stat je $hlavni_mesta($stat)." [193] => [194] => [195] => Oba skripty vypíšou: [196] => [197] => Hlavní městem státu Slovensko je Bratislava. [198] => [199] => Přítomnost prvku v poli lze testovat příkazem [200] => [201] => [202] => info exists hlavni_mesta(Antarktis) [203] => [204] => [205] => který vrací jedničku, pokud existuje zadaný prvek v zadaném poli; jinak vrací nulu. [206] => [207] => Asociativní pole (jako celek) nelze vypisovat příkazem puts; lze použít příkaz parray ze standardní knihovny: [208] => [209] => 
    [210] => % puts $hlavni_mesta
    [211] => can't read "hlavni_mesta": variable is array
    [212] => % parray hlavni_mesta
    [213] => hlavni_mesta(Německo)   = Berlín
    [214] => hlavni_mesta(Polsko)    = Varšava
    [215] => hlavni_mesta(Rakousko)  = Vídeň
    [216] => hlavni_mesta(Slovensko) = Bratislava
    [217] => hlavni_mesta(ČR)        = Praha
    [218] =>
[219] => [220] => Asociativní pole nelze předávat jako parametry procedur nebo je vracet jako návratové hodnoty funkcí; je možné použít příkazy array set a array get, které provádějí převod mezi asociativním polem a seznamem: [221] => [222] => 
    [223] => % array get hlavni_mesta
    [224] => Německo Berlín Polsko Varšava Slovensko Bratislava ČR Praha Rakousko Vídeň
    [225] =>
[226] => [227] => == Operátory seskupení == [228] => Před provedením každého příkazu Tcl provede vyhodnocení proměnných a vnořených příkazů (tzv. substituce nebo expanze). Substituci lze řídit pomocí operátorů seskupení. Jazyk Tcl má 3 operátory seskupení: [229] => [230] => * Uvozovky "" [231] => * Složené závorky {} [232] => * Hranaté závorky [] [233] => [234] => Operátory seskupení propůjčují jazyku Tcl nezaměnitelný charakter, jsou však zároveň i příčinou, proč se mu mnoho programátorů vyhýbá. [235] => [236] => === Uvozovky === [237] => Uvozovky se chovají stejně jako v mnoha jiných skriptovacích jazycích: vytvářejí řetězec z posloupnosti slov a zároveň nezabraňují expanzi proměnných ani vyhodnocování příkazů zapsaných v hranatých závorkách. Pokud se mají do řetězce vložit uvozovky, je nutné před nimi napsat obrácené lomítko; obrácené lomítko také ruší význam dolaru jako prostředku pro expanzi hodnoty proměnné: [238] => [239] => [240] => puts "Prvek $i pole \$arr má hodnotu \"$arr($i)\"." [241] => [242] => [243] => Pokud je v proměnné i hodnota 8, a prvek pole $arr s indexem 8 (indexem může být i řetězec) obsahuje řetězec "osmička", vypíše se [244] => [245] => Prvek 8 pole $arr má hodnotu "osmička". [246] => [247] => V uvozovkách mají některé posloupnosti začínající znakem obrácené lomítko význam řídicích nebo jiných znaků: [248] => [249] => {| class="wikitable" [250] => |- [251] => ! Posloupnost !! Význam [252] => |- [253] => | \n || Znak nový řádek (line feed) [254] => |- [255] => | \r || Znak návrat vozíku (carriage return) [256] => |- [257] => | \t || Znak tabelátor (tab) [258] => |- [259] => | \v || Znak vertikální tabelátor (vertical tab) [260] => |- [261] => | \a || Znak zvonek (bell) [262] => |- [263] => | \b || Znak backspace [264] => |- [265] => | \0nn || Znak se zadaným kódem (v osmičkové soustavě) [266] => |- [267] => | \uHHHH || [[Unicode]] znak U+HHHH [268] => |- [269] => | \xHH || Znak se zadaným kódem (v šestnáctkové soustavě) [270] => |} [271] => [272] => === Hranaté závorky === [273] => Do hranatých závorek lze zapsat libovolný příkaz Tcl včetně parametrů; příkaz v hranatých závorkách se provede před provedením příkazu, ve kterém je použit, a hranaté závorky se nahradí výstupem, který vyprodukuje. V následujícím příkladu je použit příkaz clock seconds, který vrací počet sekund od 1. 1. 1970 a příkaz clock format, který tento údaj zformátuje podle parametru uvedeného za volbou -format:{{Sfn|scripting/syntax|loc=Kapitola: A Little Example}} [274] => [275] => [276] => puts "Od 1. ledna 1970 uplynulo [clock seconds] sekund;" [277] => puts "Je rok [clock format [clock seconds] -format "%Y"]." [278] => [279] => [280] => vypíše [281] => [282] => Od 1. ledna 1970 uplynulo 1366380049 sekund; [283] => Je rok 2013. [284] => [285] => Jak je vidět, hranaté závorky a uvozovky lze vnořovat. [286] => [287] => Nejčastější příkaz, který se píše do hranatých závorek, je příkaz expr, který vyhodnocuje aritmetické výrazy: [288] => [289] => [290] => set vyraz "1+2+3+4+5+6+7+8+9+10" [291] => set vysledek [expr $vyraz] [292] => puts "Součet $vyraz je $vysledek." [293] => [294] => [295] => Vypíše [296] => [297] => Součet 1+2+3+4+5+6+7+8+9+10 je 55. [298] => [299] => Substituce pomocí hranatých závorek umožňuje použít výsledek jednoho příkazu jako argument dalšího příkazu. Pokud se má vyvolat příkaz jako funkce, která vrací hodnotu, musí se vždy uzavřít do hranatých závorek. [300] => [301] => Tcl nepotřebuje operátor pro [[Zřetězení|spojení řetězců]], protože stačí jenom zapsat proměnné nebo příkazy v hranatých závorkách za sebe. Na rozdíl od [[Bourne shell|unixových interpretů příkazů]] vyhodnocuje Tcl každý řetězec pouze jednou (pokud skript přímo nepředepisuje opakované vyhodnocení), což trochu komplikuje interaktivní použití, ale zprůhledňuje chování ve skriptech (např. mezery ve jméně souboru nepůsobí potíže známé z unixových shellů). [302] => [303] => === Složené závorky === [304] => Složené závorky se chovají jako apostrofy v [[Unixový shell|unixových interpretech příkazů]] a některých skriptovacích jazycích – jejich obsah se bere jako jedno slovo a nijak se neexpanduje (jen se ignoruje konec řádku, před kterým je zpětné lomítko). Složené závorky se mohou používat pro zápis řetězců, které se mají interpretovat přesně tak, jak jsou zapsány, v Tcl však mají mnohem širší použití – pro zápis [[#Práce se seznamy|seznamů]] a [[Řídicí struktura|řídicích struktur]]. Cyklus s testem na začátku se v Tcl zapisuje jako příkaz while, za kterým následují dvě slova – první je podmínka, druhé je tělo cyklu. Tcl nevyžaduje žádné závorky, do kterých by se podmínka a tělo cyklu uzavíralo, ale nejsnazší způsob, jak podmínku i tělo cyklu zapsat jako jedno slovo, je uzavřít je do složených závorek. Díky tomu se zápis while cyklu v Tcl podobá zápisu v [[C (programovací jazyk)|jazyce C]]. Podobným způsobem se zapisuje definice funkce (první parametr za slovem proc je jméno procedury nebo funkce, druhý seznam parametrů, třetí tělo funkce), podmíněný příkaz (první parametr za slovem if je podmínka, druhým seznam příkazů, které se mají provést, je-li podmínka splněna, pak mohou následovat části elseif a else). [305] => [306] => Do složených závorek se také uzavírají matematické výrazy vyhodnocované příkazem expr. [307] => [308] => Pokud by se v příkazu puts použitém v části „[[#Uvozovky|Uvozovky]]“ nahradily vnější uvozovky složenými závorkami: [309] => [310] => [311] => puts {Prvek $i pole \$arr má hodnotu \"$arr($i)\".} [312] => [313] => [314] => výsledný výstup by vypadal značně odlišně; pravděpodobně úplně jinak, než bylo zamýšleno: [315] => [316] => Prvek $i pole \$arr má hodnotu \"$arr($i)\". [317] => [318] => Pokud jsou složené závorky vnořeny do jiných složených závorek, hranatých závorek nebo uvozovek, chovají se jako normální znak: [319] => [320] => [321] => puts "Prvek {$i} pole \$arr má hodnotu {$arr($i)}." [322] => [323] => [324] => vypíše [325] => [326] => Prvek {8} pole $arr má hodnotu {osmička}. [327] => [328] => Do složených závorek se uzavírají výrazy v příkazu expr, aby se zabránilo dvojí expanzi jména proměnných: [329] => [330] => [331] => set i 10 [332] => set d "\$i" [333] => puts [expr 2*$d] [334] => [335] => [336] => == Řídicí struktury == [337] => V Tcl jsou dostupné obvyklé [[Řídicí struktura|řídicí struktury]]: [338] => [339] => * if elseif else – [[podmíněný příkaz]] [340] => * switch – vícecestné větvení [341] => * while – cyklus s testem na začátku [342] => * for – cyklus s řídicí proměnnou [343] => * foreach – cyklus přes prvky seznamu [344] => [345] => Díky vynalézavému použití složených závorek je zápis řídicích struktur podobný jako v [[C (programovací jazyk)|jazyce C]]; v Tcl se však do složených závorek píšou nejen příkazy, ale i podmínky. Interpretu Tcl je skutečnosti jedno, jaké operátory seskupení se použijí (a jestli vůbec nějaké). Vyžaduje pouze, aby slova uvozující jednotlivé konstrukce měly správný počet argumentů/parametrů. Například v příkazu cyklu while musí být za jménem příkazu dva argumenty: první je podmínka, druhý tělo cyklu. A nejjednodušším způsobem, jak sdělit Tcl, že určitý text má považovat za jeden parametr, je uzavřít jej do složených závorek. Protože parametry musí být odděleny aspoň jednou mezerou, musí být vně složených závorek (tj. před { a za }) vždy aspoň jeden bílý znak (mezera nebo tabelátor). Otevírací závorka těla cyklu musí být na stejném řádku jako podmínka (nebo musí být předchozí řádek zakončen [[Zpětné lomítko|zpětným lomítkem]]). [346] => [347] => === Podmíněný příkaz === [348] => Následující program ukazuje syntaxi podmíněného příkazu v Tcl; část else je nepovinná, příkaz může mít libovolný počet částí elseif: [349] => [350] => [351] => if {$i > 0} { [352] => puts "$i je kladné číslo" [353] => } elseif {$i == 0} { [354] => puts "$i je nula" [355] => } else { [356] => puts "$i je záporné číslo" [357] => } [358] => [359] => [360] => === While cyklus === [361] => Následující ukázka použití while příkazu počítá [[Ludolfovo číslo]] \pi podle vzorce [362] => [363] => :\pi = \operatorname{arctg}\frac{1}{2} + \operatorname{arctg}\frac{1}{3} [364] => [365] => kde funkce [[arkus tangens]] se počítá pomocí [[Taylorův vzorec|Taylorova vzorce]] [366] => [367] => :\operatorname{arctg} x = x-\frac{x^3}{3}+\frac{x^5}{5}-\frac{x^7}{7}+\frac{x^9}{9}-\ldots (pro x<1) [368] => [369] => [370] => set platnych_mist 12 [371] => set epsilon "1e-$platnych_mist" [372] => set znam 1.0 [373] => set moc2 [expr {1.0/2.0}] [374] => set moc3 [expr {1.0/3.0}] [375] => set n 1 [376] => set clen [expr {$moc2+$moc3}] [377] => set suma $clen [378] => while {abs($clen)>$epsilon} { [379] => incr n 2 [380] => set znam [expr {-$znam}] [381] => set moc2 [expr {$moc2/4.0}] [382] => set moc3 [expr {$moc3/9.0}] [383] => set clen [expr {$znam/$n*($moc2+$moc3)}] [384] => set suma [expr {$suma+$clen}] [385] => } [386] => puts "Ludolfovo číslo: [format "%.${platnych_mist}G" [expr {4.0*$suma}]]" [387] => [388] => [389] => Příkaz incr zvětší hodnotu proměnné, která je jeho prvním parametrem, o hodnotu zadanou druhým parametrem (nebo o 1, pokud druhý parametr chybí). [390] => [391] => Pro ukončení provádění cyklu lze použít příkaz break. [392] => [393] => === For cyklus === [394] => V případě for cyklu se do vlastních složených závorek dává každý ze tří výrazů, které se v jazyce C píšou do kulatých závorek a oddělují středníky: [395] => [396] => [397] => for {set i 1} {$i <= 10} {incr i} { [398] => puts "$i" [399] => } [400] => [401] => [402] => Pro ukončení provádění cyklu lze použít příkaz break, pro zahájení dalšího průchodu cyklem příkaz continue. V Tcl existuje i příkaz cyklu přes všechny prvky seznamu foreach, který je popsán u [[#Práce se seznamy|seznamů]]. [403] => [404] => == Definice funkcí == [405] => Funkce se v Tcl definují příkazem proc, za kterým následují dvojí složené závorky; první obsahují seznam parametrů (oddělených mezerami), druhé tělo funkce. Pokud má funkce vracet návratovou hodnotu, lze použít příkaz return (jinak vrací výsledek posledního provedeného příkazu). Naprogramovat výpočet faktoriálu [[rekurze|rekurzivně]] sice není ideální, ale je to možné i v Tcl. Všimněte si, že Tcl umožňuje, aby jméno funkce byl vykřičník: [406] => [407] => [408] => proc ! {n} { [409] => if {$n <= 1} { [410] => set res 1 [411] => } else { [412] => set res [expr {$n * [ ! [expr {$n - 1}] ]} ] [413] => } [414] => return $res [415] => } [416] => [417] => for {set n 1} {$n <= 20} {incr n} { [418] => puts "$n! = [! $n]" [419] => } [420] => [421] => [422] => Vhodnější výpočet faktoriálu bez [[rekurze]] by mohl vypadat takto: [423] => [424] => [425] => proc ! {n} { [426] => set res 1 [427] => for {set k 2} {$k <= $n} {incr k} { [428] => set res [expr {$res*$k}] [429] => } [430] => return $res [431] => } [432] => [433] => for {set n 1} {$n <= 20} {incr n} { [434] => puts "$n! = [! $n]" [435] => } [436] => [437] => [438] => Uživatelem definované funkce se volají stejně jako ostatní příkazy – parametry se píšou za jméno funkce a od jména funkce i sebe navzájem se oddělují mezerami nebo bílými znaky. Proto při volání funkce faktoriál není možné psát (jako v matematice) vykřičník za výraz, z něhož se má faktoriál počítat. [439] => [440] => Většina příkazů jazyka Tcl jsou funkce s proměnným počtem parametrů. To platí i o příkazech ve standardní knihovně. Příkaz proc (konstruktor pro vytváření procedur/funkcí) umožňuje definovat implicitní hodnoty pro argumenty, které nebudou použity ve volání procedury, a parametr obsahující všechny argumenty, což umožňuje zpracování proměnného počtu argumentů ve funkcích. [441] => [442] => === Přístup k globálním proměnným === [443] => [444] => Proměnné použité mimo funkci nejsou uvnitř funkce viditelné. Pro jejich zpřístupnění lze uvnitř funkce použít příkaz [445] => [446] => global ''proměnná'' [447] => [448] => === Modifikace parametrů funkce === [449] => [450] => Pokud mají být změny hodnot některého z parametrů funkce viditelné i po opuštění funkce, je nutné použít [[Parametr funkce#Způsoby předávání parametru|předávání parametrů odkazem]]. V tcl lze použít následující konstrukci: [451] => [452] => [453] => # Funkce vrátí kód bytu (0-255) z pozice idx v řetězci buffer a zvětší idx o 1 [454] => # Je-li idx >= než délka bufferu, vrátí -1 a idx nezmění [455] => proc get_first_octet {buffer idx} { [456] => # na parametr idx se budeme odkazovat pomocí $pos [457] => upvar 1 $idx pos [458] => if {$pos < [string length $buffer]} { [459] => binary scan [string index $buffer $pos] c octet [460] => incr pos [461] => return [expr {$octet & 0xFF}] [462] => } else { [463] => return -1 [464] => } [465] => } [466] => [467] => [468] => Při volání funkce se na místě parametru předávaného odkazem píše pouze jméno proměnné bez znaku dolar: [469] => [470] => [471] => set retezec "Abcd" [472] => set i 0 [473] => set kod [get_first_octet $retezec i] [474] => [475] => [476] => === Implicitní parametry funkce === [477] => [478] => Místo posledního nebo několika posledních parametrů v definici funkce mohou být použity dvojice {jméno hodnota}. Ve volání funkce pak mohou tyto parametry chybět. Při vstupu do funkce se jim přiřadí hodnoty uvedené v seznamu parametrů. [479] => [480] => === Funkce s proměnným počtem parametrů === [481] => [482] => Pokud se poslední parametr v definici funkce jmenuje args, je možné tuto funkci vyvolat s větším počtem parametrů, než je uvedeno v definici. Parametr args pak bude obsahovat seznam všech zbývajících parametrů, který lze zpracovávat funkcemi uvedenými v části [[#Práce se seznamy|Práce se seznamy]]. [483] => [484] => === Funkce vracející více hodnot === [485] => [486] => Pokud má funkce vracet více hodnot, lze je vrátit v podobě seznamu, který lze zkonstruovat funkcí list: [487] => [488] => [489] => return [list "Error" "Soubor $filename nelze číst"] [490] => [491] => [492] => Vrácenou hodnotu lze zpracovávat pomocí funkcí uvedených v části [[#Práce se seznamy|Práce se seznamy]]. [493] => [494] => === Funkce s klíčovými parametry === [495] => [496] => Někdy je potřeba definovat funkce, které pracují s velkým počtem parametrů, ale při konkrétním vyvolání se jich používá jenom několik málo, přičemž uvnitř funkce se za ostatní dosadí vhodné implicitní hodnoty. Pokud lze setřídit parametry od nejpoužívanějších po nejméně používané, může se volání funkcí zkrátit použitím implicitních parametrů. Jinak je lepší rezignovat na přístup, že význam parametru je dán jeho pořadím (poziční parametry), a použít klíčové parametry, kdy se seznam parametrů zadává ve tvaru seznamu dvojic ''jméno1 hodnota1 jméno2 hodnota2 ...''. Aby se snadno odlišila jména parametrů od hodnot, používají se často jména začínající znakem minus, podobně jako [[Příkazový řádek#Formát příkazu|přepínače (volby) v příkazovém řádku]]. Pro zpracování klíčových parametrů lze v Tcl použít následující postup:{{Citace elektronické monografie [497] => | url = https://stackoverflow.com/questions/31110082/how-to-create-tcl-proc-with-hyphen-flag-arguments [498] => | titul = How to create tcl proc with hyphen flag arguments [499] => | jméno = Dinesh [500] => | vydavatel = stackoverflow [501] => | datum = 2015-06-29 [502] => | datum přístupu = 2018-01-24}} [503] => [504] => [505] => proc moje_funkce {args} { [506] => if {[catch {array set moje_parametry $args} msg]} { [507] => return $msg [508] => } [509] => # Parametry jsou nyní dostupné jako moje_parametry(jméno) [510] => parray moje_parametry [511] => } [512] => [513] => moje_funkce -pocet 3 -retezec "abc" [514] => [515] => [516] => Funkce parray z knihovny Tcllib vypíše přehledně prvky pole: [517] => [518] => 
    [519] => moje_parametry(-pocet)   = 3
    [520] => moje_parametry(-retezec) = abc
    [521] =>
[522] => [523] => == Různé příkazy a funkce == [524] => [525] => Seznam dostupných příkazů (včetně uživatelem nadefinovaných funkcí) lze vypsat příkazem: [526] => [527] => [528] => join [lsort [info commands]] "\n" [529] => [530] => [531] => Přestože v Tcl je každá funkce zároveň příkazem a naopak příkaz často vrací nějakou hodnotu – například příkazy incr a append vracejí novou hodnotu použité proměnné – v následujícím textu jsou rozlišovány funkce (které budou v programu použity v hranatých závorkách) od celých příkazů. [532] => [533] => === Práce se seznamy === [534] => [535] => Seznam je v tcl libovolný řetězec, v němž jsou jednotlivé prvky odděleny mezerami. Pokud prvky seznamu obsahují mezery, Tcl je uzavírá do složených závorek. Pomocí složených závorek lze velmi jednoduše vytvářet víceúrovňové konstantní seznamy, např. [536] => [537] => [538] => set slovnicek { [539] => {{učit} {teach taught taught}} [540] => {{učit se} {learn {learnt learned} {learnt learned}}} [541] => } [542] => [543] => [544] => Pro vytváření seznamů obsahujících hodnoty proměnných a výrazů lze použít příkaz list nebo subst. [545] => [546] => Jednotlivé prvky lze vybírat pomocí funkce lindex. [547] => [548] => * list [ ''hodnota'' ... ] – funkce vrací seznam tvořený zadanými prvky; oproti předchozímu příkladu mohou jednotlivé argumenty obsahovat proměnné nebo být tvořeny výrazy [549] => * llength ''seznam'' – funkce vrací počet prvků v seznamu – llength "abc 2 xyz" vrací 3; není-li ''seznam'' korektním seznamem, skončí chybou unmatched open brace in list [550] => * lindex ''seznam'' ''číslo_prvku'' – funkce vrací zadaný prvek seznamu (prvky se číslují od 0) – lindex {a b c} 2 vrací c; prvek lze kromě čísla zadat i řetězcem end (konec řetězce) nebo ve tvaru ''číslo+číslo'', ''číslo-číslo'', end''+číslo'' nebo end''-číslo'' (zápis pozice nesmí obsahovat mezery); není-li ''seznam'' korektním seznamem, skončí chybou [551] => * lset ''proměnná'' ''index'' ''hodnota'' – příkaz nastaví prvek ''seznamu'' se zadaným ''indexem'' na zadanou ''hodnotu'' [552] => * lreplace ''seznam'' ''n1'' ''n2'' [ ''hodnota'' ... ] – funkce vrátí seznam, který vznikne ze zadaného ''seznamu'' nahrazením prvků ''n1'' až ''n2'' zadanými ''hodnotami'' (počet vypouštěných a vkládaných prvků nemusí souhlasit) [553] => * linsert ''seznam'' ''index'' [ ''hodnota'' ... ] – funkce vrátí seznam, do kterého jsou před pozici ''index'' vloženy zadané ''hodnoty'' [554] => * lappend ''proměnná'' [ ''hodnota'' ... ] – příkaz připojí zadané ''hodnoty'' na konec seznamu v zadané ''proměnné'' (a vrátí výsledný seznam); neobsahuje-li ''proměnná'' korektní seznam, skončí chybou [555] => * lsearch [ -''volby'' ... ] ''seznam'' ''vzorek'' – funkce vrátí index prvního prvku ''seznamu'', který vyhovuje zadanému ''vzorku''; s volbou -regexp je vzorek považován za [[regulární výraz]], s volbou -glob za [[žolíkový výraz]], s volbou -exact se provádí přesné porovnání (implicitně řetězců, je-li uvedena navíc volba -integer, pak celých čísel, s volbou -real čísel s pohyblivou řádovou čárkou); není-li ''vzorek'' v ''seznamu'', vrátí -1; není-li ''seznam'' korektním seznamem, skončí chybou [556] => * split ''řetězec'' ''oddělovač'' – funkce vrátí seznam tvořený ''řetězcem'' rozděleným na části v místech ''oddělovačů''; je-li ''oddělovač'' prázdný, vrátí ''řetězec'' rozdělený na jednotlivé znaky [557] => * join ''seznam'' ''oddělovač'' – funkce spojí prvky ''seznamu'' pomocí ''oddělovačů'' a vrátí jako jeden řetězec [558] => * foreach { ''seznam jmen proměnných'' } ''seznam'' { ''příkazy'' } – příkaz realizující cyklus přes celý ''seznam''; při každém průchodu zpracuje tolik položek ''seznamu'', kolik proměnných je v ''seznam jmen proměnných'' a přiřadí je zadaným proměnným; ''příkazy'' se provádí opakovaně, dokud se nevyčerpají všechny prvky seznamu; pokud se v posledním průchodu nedostává hodnot pro všechny proměnné, naplní zbytek proměnných prázdnými řetězci; v těle cyklu lze používat příkazy break a continue. [559] => [560] => Někdy se používá trik pro uložení několika prvních hodnot seznamu do proměnných pomocí příkazu foreach, jehož tělo je tvořeno příkazem break: například uložení pro uložení prvního prvku seznamu do proměnné var1 a třetího prvku do var3 (druhý prvek, o který nestojíme, se uloží do proměnné -) lze použít příkaz: [561] => [562] => [563] => foreach {var1 - var3} seznam break [564] => [565] => [566] => === Práce s řetězci === [567] => [568] => * string length ''řetězec'' – funkce vrací délku řetězce; u binárních řetězců vrací délku v [[Bajt|bytech]], u znakových ve znacích [569] => * string bytelength ''řetězec'' – funkce vrací počet [[Bajt|bytů]] použitých pro reprezentaci zadaného řetězce v paměti; pro binární řetězce vrací nesmyslné hodnoty; tato funkce je pravděpodobně pro programování v Tcl zcela nepoužitelná{{Citace elektronické monografie | url = http://wiki.tcl.tk/8455 | titul = string bytelength | jméno = Donal | příjmení = Fellows | vydavatel = wiki.tcl.tk}} [570] => * string index ''řetězec'' ''pozice'' – funkce vrací znak na dané pozici řetězce (číslováno od 0); pozici lze kromě čísla zadat i řetězcem end (konec řetězce) nebo ve tvaru ''číslo+číslo'', ''číslo-číslo'', end''+číslo'' nebo end''-číslo'' (zápis pozice nesmí obsahovat mezery) [571] => * string range ''řetězec'' ''from'' ''to'' – funkce vrací podřetězec od pozice ''from'' do pozice ''to'' včetně (číslováno od 0); ''from'' i ''to'' lze zadat stejně jako pozici ve string index [572] => * string first ''vzorek'' ''řetězec'' [ ''start'' ] – funkce vrací pozici prvního výskytu řetězce ''vzorek'' v zadaném ''řetězci'' od pozice ''start'' (číslováno od 0); při neúspěchu vrátí -1 [573] => * append ''proměnná'' ''seznam'' – příkaz spojí všechny prvky seznamu do jednoho řetězce (nic mezi ně nevkládá) a ten připojí na konec obsahu proměnné [574] => * string map ''mapa'' ''řetězec'' – funkce vrátí řetězec vzniklý z posledního parametru nahrazením podřetězců podle mapy; mapa je seznam dvojic podřetězec náhrada; nahrazuje vždy první nalezený podřetězec, nikoli nejdelší [575] => * string reverse ''řetězec'' – funkce vrací zadaný řetězec pozpátku [576] => * string repeat ''řetězec'' ''počet'' – funkce vrací řetězec vzniklý zadaným počtem opakování zadaného řetězce [577] => * string compare [ -nocase ] [ -length ''n'' ] ''řetězec1'' ''řetězec2'' – porovná řetězce a vrátí -1 (''řetězec1'' je před ''řetězec2''), 0 (řetězce jsou stejné) nebo 1 [578] => * od verze Tcl 8.4 lze používat pro porovnávání řetězců infixové operátory eq (je rovno) a ne (není rovno) [579] => [580] => === Regulární výrazy === [581] => [582] => * regexp [ ''volby'' ] ''reg_výraz'' ''řetězec'' [ ''proměnná'' ... ] – funkce vrátí jedničku, pokud zadaný ''řetězec'' vyhovuje [[regulární výraz|regulárnímu výrazu]] ''reg_výraz''; pokud jsou uvedeny proměnné, uloží se do první podřetězec, na který byl napasován celý [[regulární výraz]], do dalších podřetězce, které byly napasovány na podvýrazy zapsané v ''reg_výraz'' v kulatých závorkách; volby mohou být [583] => ** -nocase – nerozlišují se velká a malá písmena; [584] => ** -start ''pozice'' – shoda se hledá až od zadané pozice [585] => ** -indices – do proměnných se neukládají podřetězce ale dvojice čísel, udávající počáteční a koncovou pozici v řetězci; podřetězec lze získat pomocí string range ''řetězec'' [lindex $pos 0] [lindex $pos 1], kde pos je jméno proměnné, do které byla uložena dvojice pozic, která nás zajímá; pro Tcl od verze 8.5 lze použít string range ''řetězec'' {*}$pos; prefix {*} zajistí, že jednotlivá slova z proměnné $pos budou považována za samostatné parametry příkazu string range [586] => * regsub [''volby''] ''reg_výraz'' ''řetězec'' ''náhrada'' ''výsledek'' – funkce vrátí počet úspěšných nahrazení podřetězců vyhovujících ''reg_výraz'' v zadaném ''řetězci'' výrazem ''náhrada''; do parametru ''výsledek'' uloží výsledek nahrazování; nejpoužívanější volbou je -all, která znamená, že se mají nahrazovat všechny nalezené výskyty, jinak se provede náhrada pouze prvního výskytu [587] => [588] => === Práce se soubory === [589] => [590] => * open ''jméno'' – funkce otevře nebo vytvoří soubor a vrátí manipulátor souboru [591] => * close ''manipulátor'' – funkce zavře soubor [592] => * puts [''manipulátor''] ''řetězec'' – příkaz zapíše zadaný řetězec do souboru [593] => * gets ''manipulátor'' [''proměnná''] – funkce načte jeden řádek ze souboru a uloží ho do zadané proměnné, vrátí počet přečtených bytů nebo -1 na konci souboru; není-li uvedeno jméno proměnné vrací načtený řádek – v tomto případě je nutné testovat konec souboru pomocí funkce eof! [594] => * read ''manipulátor'' [''délka''] – funkce načte blok zadané délky ze souboru [595] => * fconfigure [''manipulátor''] ''parametry'' – příkaz nastaví režim práce se souborem (např. nebufferovaný, bez čekání, binární bez konverzí [[Kódování znaků|kódování]] a [[Nový řádek|konců řádků]]) [596] => [597] => === Konverze dat === [598] => [599] => * format ''formát'' ''hodnota'' [ ... ] – funkce vrací řetězec ''formát'' vyplněný v místech formátovacích direktiv zadanými hodnotami – jako funkce [[sprintf]] v [[C (programovací jazyk)|jazyce C]] [600] => * scan ''řetězec'' ''formát'' [''proměnná'' [ ... ]] – funkce načítá z ''řetězce'' hodnoty zadané ''formátem'' a plní jimi ''proměnné'' jako funkce [[sscanf]] v [[C (programovací jazyk)|jazyce C]]; vrací počet naplněných proměnných [601] => * binary format ''formát'' ''řetězec'' – funkce vrací řetězec vzniklý interpretací zadaného řetězce zadaným formátem; binary format B* 0100000101000010 vrací AB, protože 01000001 je [[Dvojková soustava|binární zápis]] kódu písmene A a 01000010 [[Dvojková soustava|binární zápis]] kódu písmene B [602] => * binary scan ''vstup'' ''formát'' ''výstup'' – příkaz uloží do proměnné ''$výstup'' hodnotu vzniklou interpretací ''vstupu'' zadaným ''formátem'' – binary scan $line B* bitstring uloží do $bitstring [[Dvojková soustava|binární zápis]] obsahu proměnné $line; binary scan ABC12 H* output; puts $output vypíše reprezentaci znaků v [[Šestnáctková soustava|šestnáctkové soustavě]] 4142433132 [603] => * encoding convertto ''výstupní_kódování'' ''vstup'' – funkce vrací ''vstup'' zkonvertovaný do zadaného kódování [604] => * encoding convertfrom ''vstupní_kódování'' ''vstup'' – funkce vrací ''vstup'' zkonvertovaný ze zadaného kódování – pro konverzi z [[UTF-16]] do [[UTF-8]] je nutné použít [encoding convertto utf-8 [encoding convertfrom unicode $vstup]] [605] => [606] => === Jmenné prostory === [607] => [608] => Mechanismus jmenných prostorů vytváří stromovou strukturu, v jejichž různých uzlech jsou identifikátory proměnných a funkcí (příkazů). To umožňuje používat v jednom programu více knihoven současně bez problémů s konflikty ve jménech funkcí a proměnných. Výběr jmenného prostoru identifikátoru se provádí pomocí kvalifikovaných jmen tvaru ::prostor::podprostor::atd::identifikátor, přičemž kvalifikované jméno pro identifikátory v základním (kořenovém) jmenném prostoru je ::identifikátor. [609] => [610] => Pro práci se jmennými prostory slouží příkaz namespace, jehož první parametr udává, jaká operace se jmennými prostory se má provést. Pro vytvoření nebo opětovný vstup do jmenného prostoru slouží příkaz namespace eval jméno_prostoru kód, kde kód je libovolná posloupnost příkazů v Tcl. Všechny proměnné a funkce, které budou v rámci příkazu namespace eval jméno_prostoru definovány bez uvedení kvalifikovaného jména, budou patřit do příslušného jmenného prostoru. Při použití nekvalifikovaného jména se identifikátor nejdříve vyhledává v aktuálním jmenném prostoru; není-li v něm nalezen, postup dalšího vyhledávání závisí na tom, o jaký identifikátor se jedná; zatímco proměnné se hledají ještě v kořenovém jmenném prostoru, příkazy se hledají postupně ve všech nadřízených jmenných prostorech aktuálního prostoru. Hierarchické jmenné prostory se vytvářejí vnořenými příkazy namespace eval. [611] => [612] => === Rozšiřitelnost === [613] => [614] => V Tcl lze každou funkci chápat jako rozšíření jazyka – příkaz info commands začne vracet, že příkaz příslušného jména existuje. Tímto způsobem lze do starší verze Tcl doimplementovat příkaz, který je dostupný v novějších verzích. Dostupnost příkazu lze testovat pomocí info commands jméno_příkazu nebo namespace which jméno_příkazu. [615] => [616] => === Zpracování výjimek === [617] => [618] => Pro ošetření [[Výjimka (programování)|chyb (výjimek)]] při provádění programu poskytuje Tcl příkaz catch. Konstrukce [619] => [620] => [621] => catch {skript} jméno_proměnné [622] => [623] => [624] => se chová podobně jako [625] => [626] => [627] => set jméno_proměnné [skript] [628] => [629] => [630] => ale při úspěšném provedení příkazu nebo příkazů v části skript vrací hodnotu 0. V případě, že při provádění skriptu dojde k jakékoli chybě, přiřadí se do zadané proměnné text chyby a příkaz catch vrátí hodnotu 1. Další možnosti využití příkazu catch jsou popsány v dokumentaci. [631] => [632] => Následující funkce otestuje, zda lze otevřít spojení na [[soket]] na zadané [[IP adresa|IP adrese]] a [[Síťový port|siťovém portu]]: [633] => [634] => [635] => proc check_socket {{ip "127.0.0.1"} {port 23}} { [636] => if { [catch {socket $ip $port} fid ] } { [637] => puts "Chyba: spojení na $ip:$port nelze otevřít" [638] => } else { [639] => puts "OK: spojení na $ip:$port se podařilo otevřít" [640] => close $fid [641] => } [642] => } [643] => [644] => check_socket {*}$argv [645] => [646] => [647] => == Odkazy == [648] => [649] => === Reference === [650] => [651] => [652] => === Literatura === [653] => * {{Citace elektronické monografie [654] => | url = http://www.tcl.tk/scripting/syntax.tml [655] => | titul = An Introduction to Tcl Syntax [656] => | ref = scripting/syntax [657] => | lang = en [658] => | datum přístupu = 2022-11-01 [659] => }} [660] => [661] => === Související články === [662] => [663] => * [[Tk (framework)]] [664] => * [[Tcl/Tk]] [665] => [666] => === Externí odkazy === [667] => * {{Commonscat}} [668] => ;{{en}} [669] => * [http://wiki.tcl.tk/ Tcl/Tk Wiki] [670] => * [http://www.tcl.tk/ Tcl/Tk Home Page] [671] => * [http://www.tcl.tk/scripting/primer.html Úvod do Tcl] [672] => * {{Wikiknihy|kniha=en:Tcl Programming}} – rozsáhlý text s ukázkami kompletních programů [673] => ;{{cs}} [674] => * [http://www.root.cz/serialy/programovaci-jazyk-tcl/ Seriál o Tcl/Tk na Root.cz] [675] => * [http://www.root.cz/serialy/tcl-zaklady/ Seriál TCL základy na Root.cz] [676] => * [http://www.ucw.cz/~hubicka/skolicky/skolicka11.html Hubičkova školička] [677] => {{Programovací jazyky}} [678] => {{Aplikační frameworky}} [679] => {{Autoritní data}} [680] => {{Portály|Internet}} [681] => [682] => [[Kategorie:Rodina jazyků Tcl| ]] [683] => [[Kategorie:Skriptovací jazyky]] [684] => [[Kategorie:Objektově orientované programovací jazyky]] [] => )
good wiki

Tcl

Tcl (vyslovuje se „tý-sý-el“ nebo „tykl“, název je zkratkou z Tool Command Language) je jednoduchý, ale účinný skriptovací jazyk, který v roce 1988 vytvořil John Ousterhout. Přes nezvyklou syntaxi je Tcl snadno zvládnutelný a díky nízkým nárokům na hardware je oblíbený především pro testování softwaru, programování vestavěných systémů a prototypování.

More about us

About

Jeho hlavním cílem je poskytnout nástroje, které umožňují programátorům i netechnickým uživatelům vytvářet a manipulovat s daty efektivně a intuitivně. Tcl je známý svou jednoduchou syntaxí, která usnadňuje učení a používání jazyka. Uživatelé mohou rychle začít psát skripty a vytvářet funkce, což přispívá k rychlému vývoji aplikací. Díky své flexibilitě a rozšiřitelnosti se Tcl často používá v různých oblastech, jako jsou testování, automatizace, a GUI (grafické uživatelské rozhraní). Jazyk také podporuje různé typy dat a struktury, což uživatelům umožňuje pracovat s komplexními datovými modely. Komunita kolem Tcl je aktivní a přátelská, což znamená, že je snadné najít zdroje nebo pomoc při řešení problémů. Využití Tcl v kombinaci s jeho robustními knihovnami usnadňuje integraci s jinými technologiemi a platformami. Celkově lze říci, že Tcl je skvělým nástrojem pro ty, kdo chtějí efektivně zvládat různé úkoly, a to jak ve světe profesionálního vývoje, tak ve vzdělávání. Jeho přístupnost a síla z něj činí optimální volbu pro mnoho programátorů a nadšenců do technologií.

Expert Team

Vivamus eget neque lacus. Pellentesque egauris ex.

Award winning agency

Lorem ipsum, dolor sit amet consectetur elitorceat .

10 Year Exp.

Pellen tesque eget, mauris lorem iupsum neque lacus.

You might be interested in

,'#Práce se seznamy','C (programovací jazyk)','Tk (framework)','regulární výraz','grafické uživatelské rozhraní','Řídicí struktura','Dvojková soustava','Tcl/Tk','John Ousterhout','pixel','Objektově orientované programování','Unixový shell'

Pixel

Tcl/Tk