$"...", @"...", .Length, .ToUpper(), .ToLower(), .Trim(), .Substring(), .Contains(), .Replace(), .Split(), string.Join()seber meč a odpovídá vlastními hláškamiList<string> z minulých dvou hodin" Seber MEČ " bude fungovat stejně jako "seber meč".@"..." se dá nakreslit drak, aniž by se program zbláznil ze zpětných lomítek.Tenhle blok je jen pro vás — dětem ho nepromítejte.
| Fáze | Co se děje | Čas |
|---|---|---|
| Rozjezd | Ukážete, proč hra nerozumí příkazu Seber Meč |
10 min |
| Výklad | Bloky Text je řada znaků až Doslovný text | 35 min |
| Ukázky | Demo 1–5, demo 5 spojuje všechny tři poslední hodiny | 25 min |
| Cvičení | Děti pracují samy, vy obcházíte | 55 min |
| Závěr | Kdo chce, pustí svou mluvící hru před třídou | 5 min |
Jedna věta: text není jen to, co vypíšeš — je to materiál, který se dá řezat, lepit a měnit.
Druhá myšlenka, která dnes musí zaznít nahlas: řetězec se nikdy nemění.
Replace, Trim, ToUpper — žádná z těch metod původní text neupraví.
Všechny vrátí nový text. Kdo si to neuvědomí, bude celou hodinu psát
jmeno.ToUpper(); na samostatný řádek a divit se, že se nic neděje.
Tuhle chybu uvidíte ve třídě desetkrát. Nebojujte s ní, využijte ji: je to nejlepší možný úvod do rozdílu mezi příkazem a výrazem.
StringBuilder. Je to správný nástroj na skládání tisíců řetězců,
ale dnes by jen zamlžil myšlenku. += bohatě stačí."🐉".Length je 2, je fascinující — a naprosto
matoucí. Držte se písmen. Detaily máte v technickém pozadí níž.{cislo:F2}. Zaokrouhlování necháme
na hodinu o číslech. Dnes jde o text.$. Console.WriteLine("Máš {zlato} zlata"); vypíše
doslova {zlato}. Klasika, kterou uvidí i na svém prvním pohovoru.Substring(0, 5) na kratším textu. Program spadne.
Druhé číslo je délka, ne koncová pozice — tohle si musí osahat."Meč" == "meč" je false.
Odtud vede přímá cesta k ToLower() v každém příkazu hry.Než řeknete cokoli o řetězcích, promítněte tenhle kousek z minulé hodiny:
string prikaz = "Seber Meč";
if (prikaz == "seber meč")
{
Console.WriteLine("Sebral jsi meč.");
}
else
{
Console.WriteLine("Tomu nerozumím.");
}
Hra nerozumí. Přitom hráč napsal úplně rozumnou věc.
Zeptejte se: „co je špatně — hráč, nebo program?" Někdo řekne, že hráč má psát malými písmeny. To je přesně ten okamžik, kdy můžete říct: „dobrý program se přizpůsobí člověku, ne naopak."
A jako druhý nářez přidejte mezeru navíc: "seber meč ". Taky nefunguje.
Dneska obojí spravíme dvěma metodami.
Řetězec (string) je řada znaků za sebou — skoro jako seznam z minulé hodiny.
Poznáváš to? Je to skoro stejné jako u seznamu:
| Seznam | Řetězec |
|---|---|
batoh.Count |
jmeno.Length |
batoh[0] |
jmeno[0] |
poslední batoh[batoh.Count - 1] |
poslední jmeno[jmeno.Length - 1] |
Jediný rozdíl: seznam má Count, řetězec má Length. Proč zrovna tak,
to je historie — prostě si to zapamatuj.
Znaky se počítají od nuly, stejně jako přihrádky v batohu.
Tohle jsou dvě metody, které spraví rozjezdový problém.
.Trim() odstraní mezery na začátku a na konci..ToLower() udělá ze všeho malá písmena. .ToUpper() naopak velká.prikaz.Trim().ToLower() udělá obojí.Hranaté závorky ve výpisu jsou trik — díky nim je vidět, kde text končí.
Důležité: prikaz se nezměnil! Metody vrátily nový text.
Proto si ho ukládáme do proměnné uklizeny.
Od téhle chvíle používej prikaz.Trim().ToLower() v každé hře.
Hráči ti poděkují.
Tohle je nejdůležitější věta hodiny, tak ji čti pomalu.
První hlaska.ToUpper(); vyrobí velký text — a zahodí ho.
Nikam jsme ho neuložili.
Druhý řádek výsledek uloží zpátky do hlaska, a proto se změna projeví.
Platí to pro všechny metody řetězců: Trim, ToLower, Replace,
Substring. Žádná z nich původní text nemění, všechny vrací nový.
Zapamatovací pomůcka: text je vytesaný do kamene. Můžeš vytesat nový, starý ale nepřepíšeš.
Substring vrátí část textu. Bere dvě čísla: odkud a jak dlouhý kousek.
index: 0 1 2 3 4 5 6 7 8 9
D r a k o b i j e c
Substring(0, 4) = od nuly čtyři znaky → DrakSubstring(4) = od čtyřky do konce → obijecKdybys chtěl Substring(0, 50) u desetiznakového jména, program spadne —
nemůžeš uříznout víc, než kolik je.
Dvě metody, se kterými se z jedné šablony dá vyrobit sto různých hlášek.
.Replace("co", "čím") vymění všechny výskyty..Contains("draka") odpoví true / false — hodí se do if..StartsWith(...) a .EndsWith(...) se ptají na začátek a konec.Všimni si, že výsledek Replace zase ukládáme zpátky do proměnné.
Bez toho by se nestalo nic.
Šablona s velkými zástupnými slovy (JMENO, ZBRAN) je starý trik
z opravdových her. Jeden text, tisíc hlášek.
Když hráč napíše seber meč, hra potřebuje dvě věci zvlášť: co dělat a s čím.
.Split(' ') rozseká text v místech, kde je mezera, a vrátí řadu slov.
Ta řada se chová skoro jako seznam z minulé hodiny:
foreachem,slova[0],.Length (jako u textu), ne .Count.Pozor: kdyby hráč napsal jen seber, slova[1] neexistuje a program spadne.
Proto se před sáhnutím vyplatí zeptat na slova.Length.
Split text rozřeže. string.Join ho zase slepí — a nejlíp funguje
se seznamem z minulé hodiny.
string.Join(oddělovač, seznam) udělá z pěti položek jednu hezkou větu.
Všimni si, že se píše jinak než ostatní metody: není za tečkou
za jménem seznamu, ale začíná slovem string. Je to nástroj,
který patří celému typu, ne jednomu konkrétnímu textu.
Bez Join bys musel psát cyklus a řešit, kam dát čárku a kam ne.
Tohle je jeden řádek.
Někdy chceš text přesně tak, jak je napsaný — i s lomítky a odřádkováním. Od toho je zavináč před uvozovkami.
V obyčejném řetězci má \ zvláštní význam (\n = nový řádek),
takže cesta k souboru by se musela psát "C:\\hry\\...".
Zavináč @ říká: „ber to doslova". Žádné \n, žádné triky —
co je napsané, to se vypíše.
Navíc smí být na víc řádků, což je přesně to, co potřebuješ na ASCII obrázek draka.
Jediná past: uvozovky uvnitř se píšou zdvojeně ("").
Pár věcí, které dětem neříkáte, ale vy je vědět chcete.
Řetězce jsou neměnné (immutable). string je referenční typ, ale chová se
jako hodnota: každá „úprava" alokuje nový objekt na haldě. Proto
retezec += x v cyklu o tisíci opakováních vyrobí tisíc objektů —
a proto existuje StringBuilder. Dětem to dnes neříkejte, ale vy vězte,
že jejich denik += ... z hodiny o smyčkách je na malé texty naprosto v pořádku.
Interpolace není lepení. $"Máš {zlato} zlata" kompilátor přeloží na
string.Format nebo (od C# 10) na DefaultInterpolatedStringHandler,
což je rychlejší než ruční +. Pro děti je podstatné jen to, že je to čitelnější.
Length počítá UTF-16 jednotky, ne „písmena". "🐉".Length je 2,
protože emoji je surrogate pair. Proto v hodině nikde neřežeme Substringem
text s emoji — jen obyčejná písmena. Když se někdo zeptá, řekněte pravdu:
„počítač si text ukládá po kouscích a některé znaky jsou ze dvou kousků."
Diakritika a ToLower(). Funguje i na Č, Ř, Š. Co ale nefunguje
intuitivně, je porovnávání s == u znaků složených z písmene a diakritického
znaménka (Unicode normalizace). V praxi se s tím na klávesnici nesetkají.
Split(' ') vrací string[]. Pole, ne List<T>. Záměrně to nerozmazáváme —
dětem stačí, že se to chová „skoro jako seznam", jen s .Length.
Kdo se zeptá, tomu řekněte, že pole má pevnou velikost a seznam umí růst.
Interpolace a zarovnání udělají z několika proměnných úřední dokument.
Co u toho říct: {jmeno,-22} znamená „zarovnej doleva na 22 znaků".
Právě díky tomu rámeček nikdy nerozhodí. Zkuste před třídou zadat delší jméno —
ať vidí, kde je hranice.
Opravdové hry nemají napsanou každou větu. Mají šablony.
Co u toho říct: zeptejte se, co by se muselo přepsat, kdyby se změnilo slovo „máchne" na „sekne". Odpověď: jediný řádek — šablona. Přesně kvůli tomu se to takhle dělá.
Split promění větu na slova a program s nimi může pracovat jednotlivě.
Co u toho říct: hledání nejdelšího slova je úplně stejný algoritmus
jako hledání nejsilnějšího zásahu z minulé hodiny. Jen se porovnává
.Length místo čísla. Nechte je tu podobnost najít.
@"..." umí víc řádků, takže se do něj vejde celý obrázek.
Co u toho říct: zkuste smazat zavináč a spustit. Kompilátor se rozčílí,
protože obyčejný řetězec nesmí přes víc řádků. Je to nejrychlejší způsob,
jak ukázat, k čemu @ je.
Finále: herní smyčka z hodiny o smyčkách, seznam z hodiny o inventáři a dnešní rozbor textu dohromady.
Console.ReadLine() — jeden řádek na jedno čtení.Co u toho říct: všimněte si prvního vstupního řádku — " Seber MEČ ".
Díky Trim().ToLower() hra rozumí. Smažte ty dvě metody, spusťte znovu
a ukažte, jak se hra rozbije. Tohle je celá hodina v jedné ukázce.
Chyby, na které u textu narazí úplně každý.
string jmeno = "Kaja";
jmeno.ToUpper();
Console.WriteLine(jmeno);
Console.WriteLine(jmeno.Substring(0, 10));
Dvě chyby v jednom kousku:
jmeno.ToUpper(); nic nezmění — výsledek nikam neuložíme.
Vypíše se Kaja.Substring(0, 10) u čtyřznakového jména shodí program.
Nemůžeš uříznout deset písmen ze čtyř.Správně: jmeno = jmeno.ToUpper(); a jmeno.Substring(0, 3).
| Hláška / projev | Co se stalo | Jak to spravit |
|---|---|---|
Vypíše se {zlato} místo čísla |
Chybí $ před uvozovkami |
$"Máš {zlato} zlata" |
| Nic se nezměnilo | Výsledek metody se nikam neuložil | text = text.ToUpper(); |
ArgumentOutOfRangeException |
Substring chce víc znaků, než text má |
Druhé číslo je délka, ne konec |
IndexOutOfRangeException |
slova[1] po Split, ale slovo bylo jen jedno |
Nejdřív ověř slova.Length |
CS1009: Unrecognized escape sequence |
Zpětné lomítko v obyčejném řetězci | Použij @"C:\cesta" |
CS1010: Newline in constant |
Text přes víc řádků bez @ |
Před uvozovky dej @ |
| Podmínka nikdy neplatí | Velká a malá písmena | Porovnávej prikaz.Trim().ToLower() |
Chybu s neuloženým výsledkem předveďte na projektoru a nechte třídu hádat,
co se vypíše. Skoro všichni řeknou velká písmena. Když se ukáže Kaja,
je to nejsilnější moment hodiny.
Pak napište jmeno = jmeno.ToUpper(); a spusťte znovu. Rozdíl jednoho
znaku = je pro ně zapamatovatelnější než jakákoli definice neměnnosti.
// TODO.
Když nevíš, klikni na 💡 Poradit u příslušného bodu zadání —
v dílně se ti kód posune o jeden krok dál. Nejdřív to ale zkus sám.
Tvoje zadání:
Každý hrdina potřebuje vizitku. Ta tvoje se poskládá sama z několika proměnných.
- Vytvoř proměnné
jmeno,povolani,urovena vypiš je jednou větou💡 Poradit
Dva texty (string) a jedno číslo (int).
Výpis přes interpolaci:Console.WriteLine($"{jmeno} je {povolani} na úrovni {uroven}.");— nezapomeň na$.- Vypiš jméno velkými písmeny a spočítej jeho délku
💡 Poradit
jmeno.ToUpper()vrátí nový text,jmeno.Lengthje počet znaků.
Obojí se dá dát rovnou do interpolace:$"{jmeno.ToUpper()} ({jmeno.Length} znaků)".- Vyrob zkratku ze tří prvních písmen jména
💡 Poradit
string zkratka = jmeno.Substring(0, 3).ToUpper();.
První číslo je start, druhé je délka kousku.- Vypiš vizitku do rámečku se zarovnanými sloupci
💡 Poradit
Zarovnání se píše do interpolace za čárku:$"| {jmeno,-20} |"zarovná doleva na 20 znaků.
Rámeček složíš znew string('─', 24).- Přidej heslo hrdiny psané velkými písmeny s vykřičníkem
💡 Poradit
Text hesla si dej do proměnné a vypišConsole.WriteLine($"⚔️ {heslo.ToUpper()}!");.
Kdo chce, přidá kolem hesla čáru znew string('=', 36).
| Úroveň | Co má zvládnout |
|---|---|
| Minimum | Body 1–2: vizitka se vypíše a jméno umí velká písmena |
| Rozšíření | Body 3–4 se zkratkou a zarovnaným rámečkem |
| Výzva | Udělat zkratku, která zvládne i jméno kratší než tři znaky (pomocí Math.Min) |
Očekávaný výsledek: úhledná vizitka se zarovnanými sloupci, zkratkou a bojovým heslem.
Kde se zaseknou:
$. Vypíše se {jmeno} doslova. První a nejčastější chyba.
Ať si zvyknou psát $ dřív než uvozovky.jmeno.ToUpper(); na samostatném řádku. Nic se nestane. Vraťte se
k bloku Řetězec se nikdy nemění.{jmeno,-20} jako spolehlivější.$"{"Jméno:",-12}" vypadá divoce,
ale je to legální. Kdo se v tom ztrácí, ať si text dá do proměnné.Kdo je hotový dřív: zkratka, která nespadne u krátkého jména:
jmeno.Substring(0, Math.Min(3, jmeno.Length)).
Otázka na závěr cvičení: „Co znamená mínus v {jmeno,-20}?"
Zarovnání doleva. Bez mínusu se zarovnává doprava.
Tvoje zadání:
U brány do čarodějovy věže se musí říct heslo. Strážný je ale slušný — velká písmena ani mezery navíc mu nevadí.
- Vytvoř
zadano = " TAJNE Heslo "aspravne = "tajne heslo"a vypiš je v hranatých závorkách💡 Poradit
Hranaté závorky napiš přímo do textu:Console.WriteLine($"[{zadano}]");.
Díky nim je vidět, kde text opravdu začíná a končí.- Uklid zadané heslo do proměnné
uklizene💡 Poradit
string uklizene = zadano.Trim().ToLower();.
Výsledek musíš uložit — samotnézadano.Trim();nic neudělá.- Porovnej uklizené heslo se správným a rozhodni, jestli strážný pustí dál
💡 Poradit
if (uklizene == spravne) { ... } else { ... }.
Do obou větví dej hlášku — třeba „🚪 Brána se otevírá." a „🛑 Strážný se ani nehne.".- Vypiš délku hesla a napiš, jestli je dost dlouhé (aspoň 8 znaků)
💡 Poradit
Délka jeuklizene.Length.
Podmínka:if (uklizene.Length >= 8) { ... }.- Zjisti, jestli heslo obsahuje mezeru a jestli začíná slovem
tajne💡 Poradit
uklizene.Contains(" ")vrátítruenebofalse.
Na začátek se ptáuklizene.StartsWith("tajne").
| Úroveň | Co má zvládnout |
|---|---|
| Minimum | Body 1–3: heslo s mezerami a velkými písmeny projde |
| Rozšíření | Body 4–5 s kontrolou délky a rozborem hesla |
| Výzva | Vypsat heslo zamaskované hvězdičkami pomocí new string('*', uklizene.Length) |
Očekávaný výsledek: program, který pustí dovnitř i přes mezery navíc a velká písmena — a umí o hesle něco říct.
Kde se zaseknou:
zadano.Trim(); bez uložení. Nejčastější chyba celé hodiny.
Heslo se neuklidí a strážný nepustí. Vraťte se k bloku o neměnnosti.Trim() a zapomene ToLower().
Nechte je vypisovat mezikrok v hranatých závorkách, hned to uvidí.= místo ==. Kompilátor to odmítne. Dobrá připomínka:
jedno rovnítko přiřazuje, dvě porovnávají.zadano.Length je o čtyři větší
kvůli mezerám. Zeptejte se, které číslo je „to správné".Kdo je hotový dřív: hvězdičkové maskování a kontrola, jestli heslo
obsahuje číslici (uklizene.Contains("7")).
Otázka na závěr cvičení: „Proč strážný pustí i toho, kdo píše velkými písmeny?" Protože program porovnává až uklizenou verzi — a to je vstřícnost k člověku.
Tvoje zadání:
Jedna šablona, spousta hlášek. Přesně tak to dělají opravdové hry.
- Vytvoř šablonu se zástupnými slovy
JMENOaCIL💡 Poradit
Třeba:string sablona = "JMENO sesílá ohnivou kouli na CIL!";.
Zástupná slova piš velkými písmeny, ať jsou v textu vidět.- Nahraď
JMENOjménem hrdiny a výsledek si ulož💡 Poradit
string hlaska = sablona.Replace("JMENO", "Elora");.
Bez uložení do proměnné se nic nezmění!- Nahraď
CILa hlášku vypiš💡 Poradit
hlaska = hlaska.Replace("CIL", "starého draka");— všimni si, že výsledek ukládáš zpátky dohlaska.- Vyrob z téže šablony druhou hlášku pro jiného hrdinu
💡 Poradit
Použij znovusablona— ta se nezměnila, protožeReplacevrací nový text.
Ulož ji do jiné proměnné, třebahlaska2.- Zkontroluj, jestli hláška obsahuje slovo
drak, a udělej „cenzuru"💡 Poradit
if (hlaska.Contains("drak")) { ... }.
Cenzura je jen dalšíReplace:hlaska.Replace("ohnivou kouli", "🔥🔥🔥").
| Úroveň | Co má zvládnout |
|---|---|
| Minimum | Body 1–3: z šablony vznikne jedna hotová hláška |
| Rozšíření | Body 4–5: druhá hláška a kontrola obsahu |
| Výzva | Vyrobit tři hlášky a všechny uložit do List<string>, pak je vypsat foreachem |
Očekávaný výsledek: z jedné šablony vzniknou dvě různé hlášky a původní šablona zůstane nedotčená.
Kde se zaseknou:
sablona.Replace(...) bez uložení. Opakování z minulého cvičení,
ale tady je následek vidět nejlíp: hláška zůstane se slovem JMENO.sablona = sablona.Replace("JMENO", "Elora");
a pak se diví, že druhá hláška už nemá co nahradit. Skvělá chyba —
nechte ji vzniknout a pak se ptejte proč."Jmeno" vs. "JMENO". Nic se nenahradí
a nic se nestane. Připomeňte, že text musí sedět přesně.Replace("na", "do") přepíše i "ohnivou"…
Nechte je zkusit, je to zábavná katastrofa.Kdo je hotový dřív: tři hlášky uložené do List<string> a vypsané
foreachem — spojení dnešní a minulé hodiny.
Otázka na závěr cvičení: „Proč se šablona po Replace nezměnila?"
Protože řetězce se nemění. Replace vrací nový text.
Tvoje zadání:
Hra dostane větu a musí si s ní poradit — rozebrat ji, upravit a složit zpátky.
- Vytvoř větu a rozřež ji na slova
💡 Poradit
Třebastring veta = "elora sekla draka do ocasu";.
Rozřezání:string[] slova = veta.Split(' ');, počet jeslova.Length.- Vypiš každé slovo na vlastní řádek i s jeho délkou
💡 Poradit
foreach (string slovo in slova) { ... }a uvnitř$"{slovo} ({slovo.Length})".
Číslování přidej počítadlem nad cyklem.- Uprav první slovo tak, aby začínalo velkým písmenem
💡 Poradit
slova[0].Substring(0, 1).ToUpper() + slova[0].Substring(1).
První kousek je jedno písmeno, druhý je zbytek od indexu 1 do konce.- Slož větu zpátky dohromady a přidej vykřičník
💡 Poradit
string.Join(" ", slova)slepí slova zpátky mezerou.
Když před tím přepíšešslova[0], projeví se to i ve složené větě.- Najdi nejdelší slovo ve větě
💡 Poradit
Stejný algoritmus jako hledání nejsilnějšího zásahu:string nejdelsi = "";nad cyklem a uvnitřif (slovo.Length > nejdelsi.Length) { nejdelsi = slovo; }.
| Úroveň | Co má zvládnout |
|---|---|
| Minimum | Body 1–2: věta se rozdělí a slova se vypíšou |
| Rozšíření | Body 3–4 s velkým počátečním písmenem a složením zpátky |
| Výzva | Vypsat větu pozpátku (slova otočit přes List<string> a Reverse()) |
Očekávaný výsledek: rozebraná věta, opravené velké písmeno na začátku a věta složená zpátky i s vykřičníkem.
Kde se zaseknou:
Substring(1, 1) místo Substring(1). Dostanou jedno písmeno místo
celého zbytku. Vraťte se k obrázku s indexy.slovo uvnitř foreach. Proměnná cyklu je jen kopie —
přiřazení do ní nic nezmění (a kompilátor to navíc zakáže).
Proto měníme slova[0] mimo cyklus.nejdelsi začíná na null. Pak nejdelsi.Length spadne.
Prázdný text "" má délku 0 a funguje.string.Join("", slova) slepí slova
bez mezer. Není to chyba, ale ať vědí, co dělají.Kdo je hotový dřív: věta pozpátku — List<string> l = new List<string>();,
naplnit foreachem, l.Reverse() a string.Join(" ", l).
Otázka na závěr cvičení: „Proč měníme slova[0] a ne slovo v cyklu?"
Protože slovo je jen kopie jedné položky, ne ta položka samotná.
Tvoje zadání:
Velké finále. Hra bude rozumět větám jako
Seber MEČ— i s mezerami navíc.
- Nad smyčkou vytvoř seznam
batoha vypiš uvítání v@"..."💡 Poradit
List<string> batoh = new List<string>();a text přes víc řádků dostring uvitani = @"...";.
Do uvítání napiš i nabídku příkazů.- Přidej smyčku, která vstup uklidí přes
Trim()aToLower()💡 Poradit
Nejdřívstring vstup = Console.ReadLine();, pak pojistkaif (vstup == null) { break; }a teprve potomstring prikaz = vstup.Trim().ToLower();.
Na"konec"udělejbreak.- Příkaz
batohvypíše obsah jednou větou pomocístring.Join💡 Poradit
Console.WriteLine($"🎒 Neseš: {string.Join(", ", batoh)}");.
Když je batoh prázdný, napiš to slovy —batoh.Count == 0.- Rozřež příkaz na slova a vytáhni sloveso a předmět
💡 Poradit
string[] slova = prikaz.Split(' ');.
Nejdřív ověřif (slova.Length < 2) { ... continue; }, jinak program na jednoslovném příkazu spadne.- Podle slovesa
sebernebozahoďuprav batoh a pod smyčkou vypiš souhrn💡 Poradit
if (sloveso == "seber") { batoh.Add(predmet); }a uzahoďnejdřívbatoh.Contains(predmet).
Souhrn patří až pod uzavírací}smyčky.
| Úroveň | Co má zvládnout |
|---|---|
| Minimum | Body 1–3: smyčka běží a batoh vypíše obsah jednou větou |
| Rozšíření | Body 4–5: hra rozumí dvouslovným příkazům |
| Výzva | Přidat příkaz prozkoumej, hlášku s velkým počátečním písmenem předmětu a počítadlo nepochopených příkazů |
Console.ReadLine() — jeden řádek na jedno čtení.Očekávaný výsledek: hra, která rozumí Seber MEČ stejně dobře
jako seber meč. První vstupní řádek v okénku je schválně „ušpiněný".
Kde se zaseknou:
Trim().ToLower() bez uložení. Hra pak nerozumí ničemu. Klasika dneška.slova[1] bez kontroly. Jakmile hráč napíše jediné slovo, program spadne.
Kontrola slova.Length < 2 musí být před sáhnutím.continue. Po výpisu batohu program pokračuje na Split
a zbytečně hlásí, že nerozumí. continue znamená „tohle kolo je hotové".null až za Trim(). vstup.Trim() na null spadne.
Nejdřív if (vstup == null) break;, teprve pak úklid.Kdo je hotový dřív: příkaz prozkoumej <místo>, hláška s velkým
počátečním písmenem předmětu (predmet.Substring(0, 1).ToUpper() + predmet.Substring(1))
a počítadlo nepochopených příkazů.
Otázka na závěr cvičení: „Které dva řádky dělají hru vstřícnou k hráči?"
vstup.Trim().ToLower() a kontrola počtu slov.
Console.ReadLine() — jeden řádek na jedno čtení.Zadání: Napiš program, který z jedné věty udělá zápis do kroniky.
zapis.Split a .Length).Substring).Replace.string.Join.Co musí program umět:
| Požadavek | Popis |
|---|---|
| Interpolace | Všechny výpisy přes $"..." |
| Rozbor textu | Split, .Length, Substring |
| Šablona | Aspoň dvě různé hlášky z jednoho Replace vzoru |
| Složení | string.Join na konci |
| Doslovný text | Aspoň jeden @"..." — třeba hlavička kroniky |
Bonus (nepovinně): spočítej, kolik slov v zápisu je delších než pět písmen, a nejdelší z nich vypiš velkými písmeny.
Úkol je schválně poskládaný z těch metod, které dnes používali nejvíc:
Split, Substring, Replace, Join. Nic nového se učit nemusí.
Při opravě sledujte jednu jedinou věc: jestli výsledky metod ukládají.
Kdo odevzdá zapis.ToUpper(); na samostatném řádku, ten dnešní hlavní
myšlenku ještě nemá — a stojí za to mu to říct osobně.
Nejčastější pád programu: Substring(0, 3) na krátkém textu. Když se to
někomu stane, je to dobrý začátek příští hodiny: „jak se program zeptá,
jestli to vůbec může udělat?"
Až budeš chtít vědět víc, tady jsou původní zdroje. Jsou anglicky, ale kód v nich je stejný jako ten tvůj.
| Téma | Odkaz |
|---|---|
Typ string |
learn.microsoft.com — string |
Interpolace $"..." |
learn.microsoft.com — string interpolation |
Doslovné řetězce @"..." |
learn.microsoft.com — verbatim strings |
Substring |
learn.microsoft.com — String.Substring |
Split |
learn.microsoft.com — String.Split |
string.Join |
learn.microsoft.com — String.Join |
Trim, ToUpper, ToLower |
learn.microsoft.com — String.Trim |
Replace a Contains |
learn.microsoft.com — String.Replace |
Dneska se tvoje hra naučila mluvit a poslouchat. Rozumí tomu, co hráč napíše, i když to napíše po svém — a odpovídá větami, které si sama složí.
| Dovednost | Kde se ti bude hodit |
|---|---|
$"..." a zarovnání |
Každý hezký výpis, tabulka, faktura, vysvědčení |
Trim() a ToLower() |
Přihlašovací formuláře, vyhledávání, chatboti |
Split() a string.Join() |
Zpracování dat, CSV tabulky, příkazová řádka |
Replace() a šablony |
Hromadné e-maily, titulky, hlášky ve hrách |
Kde to potkáš v životě: když do vyhledávače napíšeš Praha
a on stejně najde Prahu, děje se přesně to, co jsi dnes napsal —
Trim() a ToLower(). Každý formulář na internetu tohle dělá.
A Split? Ten běží pokaždé, když program čte tabulku, adresu nebo
zprávu. Rozřezat text na kousky je jedna z nejčastějších věcí,
které programátor dělá.
Příště: hrdina i drak mají pořád jen hromadu samostatných proměnných.
Příště se naučíme slovníky (Dictionary<string, int>) — a jedna
příšera konečně půjde popsat jedním údajem se jménem, životy i odměnou.