Cvičení – sestavení kódu pomocí metod

10 min

Metody jsou užitečné k uspořádání kódu, opakovanému využití kódu a k efektivnímu řešení problémů. Můžete si představit metodu jako černou skříňku, která přebírá vstup, provádí pojmenovanou úlohu a vrací výstup. Pomocí tohoto předpokladu můžete rychle strukturovat programy tak, že pojmete své úkoly jako metody a pak vyplníte logiku po identifikaci všech potřebných úkolů.

Pokud používáte prostý jazyk k popisu kroků v kódu bez přísného dodržování pravidel syntaxe, používáte "pseudokód". Kombinování metod a pseudokódu je skvělý způsob, jak rychle pracovat prostřednictvím jakékoli náročné programovací úlohy.

Použití metod ke strukturování kódu

Předpokládejme, že jste kandidátem v programovacím pohovoru. Dotazovač chce, abyste napsali program, který zkontroluje, jestli je adresa IPv4 platná nebo neplatná. Máte následující pravidla:

Platná adresa IPv4 se skládá ze čtyř čísel oddělených tečkami.
Každé číslo nesmí obsahovat úvodní nuly.
Každé číslo musí být v rozsahu od 0 do 255.

Příklady platných IP adres jsou 1.1.1.1 a 255.255.255.255.

Adresa IPv4 je zadaná jako řetězec. Můžete předpokládat, že se skládá jenom z číslic a teček (v řetězci nejsou žádná písmena).

Jak byste k tomuto úkolu přistupovali?

Poznámka:

I když nejste obeznámeni s IP adresami, nemějte obavy! Kód v tomto cvičení můžete přesto dokončit pomocí kroků.

Rozdělení problému

V tomto úkolu identifikujete kroky potřebné k vyřešení problému. Při bližším pohledu na pravidla si můžete uvědomit, že k určení, jestli je adresa IPv4 platná, trvá pouze tři kroky.

V editoru Visual Studio Code odstraňte veškerý existující kód z předchozích cvičení.
Do editoru zadejte následující pseudokód:
```
/*
if ipAddress consists of 4 numbers
and
if each ipAddress number has no leading zeroes
and
if each ipAddress number is in range 0 - 255

then ipAddress is valid

else ipAddress is invalid
*/
```
Pseudokód je skvělý způsob, jak začít řešit jakýkoli problém. Pomocí tohoto bloku komentáře překlenujete mezeru mezi pravidly výzvy a kódem programu a objasníte hlavní úlohy, které váš kód provede. Pseudokód nemusí být funkční nebo dodržovat pravidla syntaxe, ale mělo by to být jasné vysvětlení toho, co bude kód dělat. Teď to pojďme převést na skutečný kód!
Zadejte nový prázdný řádek kódu a do editoru zadejte následující kód:
```
if (ValidateLength() && ValidateZeroes() && ValidateRange()) 
{
    Console.WriteLine($"ip is a valid IPv4 address");
} 
else 
{
    Console.WriteLine($"ip is an invalid IPv4 address");
}
```
V tomto kroku transformujete if příkazy z pseudokódu na volatelné metody a vypíšete výsledky. Nedělejte si starosti s definováním metod; Můžete předpokládat, že každá metoda provádí úlohu, kterou její název popisuje. Chyby kompilace opravíte a brzy vytvoříte logiku metody, ale prozatím se zaměříte na celkový přehled. Když začnete pracovat na novém programu, zaměření na celkový návrh vám pomůže udržet si přehled a vyvíjet aplikace rychleji.
Zadejte nový prázdný řádek kódu pod existujícím kódem a do Editoru zadejte následující kód:
```
void ValidateLength() {}
void ValidateZeroes() {}
void ValidateRange() {}
```
Všimněte si, že použití zástupných metod vám umožnilo rychle přistupovat k problému a strukturovat kód pro vývoj řešení. Teď, když máte strukturovaný plán, můžete pokračovat v řešení problému vyplněním části kódu po kusu.

Vývoj řešení

Teď, když máte všechny zástupné metody potřebné k vyřešení problému, můžete se začít soustředit na podrobnosti vašeho řešení. Mějte na paměti, že vstupní formát IPv4 adresy bude řetězec skládající se z číslic oddělených tečkami. Pojďme začít!

Na začátku programu vytvořte proměnné pro uložení vstupních a ověřovacích stavů:

string ipv4Input = "107.31.1.5";
bool validLength = false;
bool validZeroes = false;
bool validRange = false;

Aktualizujte kód řešení tak, aby používal ověřovací proměnné následujícím způsobem:

ValidateLength(); 
ValidateZeroes(); 
ValidateRange();

if (validLength && validZeroes && validRange) 
{
    Console.WriteLine($"ip is a valid IPv4 address");
} 
else
{
    Console.WriteLine($"ip is an invalid IPv4 address");
}

Aktualizujte metodu ValidateLength následujícím způsobem:
```
void ValidateLength() 
{
    string[] address = ipv4Input.Split(".");
    validLength = address.Length == 4;
};
```
První pravidlo uvádí, že adresa IPv4 musí mít čtyři čísla. V tomto kódu tedy použijete string.Split k oddělení číslic a kontrole, že jsou čtyři z nich.
Aktualizujte metodu ValidateZeroes následujícím způsobem:
```
void ValidateZeroes() 
{
    string[] address = ipv4Input.Split(".");

    foreach (string number in address) 
    {
        if (number.Length > 1 && number.StartsWith("0")) 
        {
            validZeroes = false;
        }
    }

    validZeroes = true;
}
```
Chvíli zvažte, jak se pravidlo překládá na kód.

Druhé pravidlo uvádí, že čísla v adrese IPv4 nesmí obsahovat úvodní nuly. Metoda tedy musí zkontrolovat počáteční nuly při přijetí 0 jako platné číslo. Pokud mají všechna čísla platné nuly, validZeroes měla by být rovna truea false jinak. V tomto kódu tedy zkontrolujete, že každé číslo s více než jednou číslicí nezačíná nulou.

Pokud se podíváte pozorně, všimnete si, že validZeroes je nastavená na true po foreach dokončení smyčky. Chcete ale nastavit validZeroestrue pouze v případě, že se nenašly žádné počáteční nuly. Tuto chybu můžete opravit nastavením validZeroes = true před spuštěním smyčky foreach . Tuto chybu ale můžete opravit také pomocí příkazu return .
Aktualizujte kód následujícím kódem:
```
foreach (string number in address) 
{
    if (number.Length > 1 && number.StartsWith("0")) 
    {
        validZeroes = false;
        return;
    }
}
```
Návratový příkaz ukončí provádění metody a vrátí řízení volajícímu metody. return Přidání příkazu po validZeroes = false ukončení metody po nalezení první neplatné nuly. Pokud se nenajde žádná neplatná nula, metoda se ukončí po nastavení validZeroes na truehodnotu . Pojďme přejít k další metodě.
Aktualizujte metodu ValidateRange následujícím způsobem:
```
void ValidateRange() 
{
    string[] address = ipv4Input.Split(".");

    foreach (string number in address) 
    {
        int value = int.Parse(number);
        if (value < 0 || value > 255) 
        {
            validRange = false;
            return;
        }
    }
    validRange = true;
}
```
Třetí pravidlo uvádí, že každé číslo v adrese IPv4 musí být v rozsahu od 0 do 255. V tomto kódu tedy zkontrolujete, jestli je každé číslo menší než 255, a pokud ne, ukončete provádění po nastavení validRange na falsehodnotu . Vzhledem k tomu, že vstupní řetězec obsahuje jenom číslice a tečky, nemusíte kontrolovat záporná čísla.

Může však existovat případ, kdy mezi tečkami nejsou přítomny žádné číslice. Například 255...255. V takovém případě string.Split(".") by se vrátily prázdné položky, což by způsobilo int.Parse selhání. Můžete tomu zabránit zadáním StringSplitOptions.
Aktualizujte kód následujícím způsobem:
```
string[] address = ipv4Input.Split(".", StringSplitOptions.RemoveEmptyEntries);
```
Při použití StringSplitOptions.RemoveEmptyEntries vynechání prázdných položek z address pole a zabránění pokusům o parsování prázdných řetězců.

Dokončení řešení

Teď, když máte všechny metody dokončené k ověření IP adresy, je čas se vrátit k původnímu řešení. V tomto úkolu přidáte další vstupní hodnoty a připravíte se na testování kódu.

Vyhledejte následující kód, který jste napsali dříve v programu:
```
string ipv4Input = "107.31.1.5";
```
Následujícím způsobem aktualizujte kód:
```
string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
```
Při vývoji řešení je důležité otestovat kód s různými vstupními případy. V tomto kódu zadáte slušný rozsah testovacích hodnot. Teď, když jste aktualizovali testovací vstup, budete muset aktualizovat kód tak, aby používal nové hodnoty. Vzhledem k tomu, že hodnoty jsou v poli, budete muset aktualizovat kód tak, aby každý z nich testovat pomocí smyčky.
Aktualizujte kód následujícím způsobem:
```
foreach (string ip in ipv4Input) 
{
    ValidateLength(); 
    ValidateZeroes(); 
    ValidateRange();

    if (validLength && validZeroes && validRange) 
    {
        Console.WriteLine($"{ip} is a valid IPv4 address");
    } 
    else 
    {
        Console.WriteLine($"{ip} is an invalid IPv4 address");
    }
}
```
Nakonec je potřeba opravit vstupní data, která každá metoda používá, protože jste aktualizovali ipv4Input z řetězce na pole. Vzhledem k tomu, že každá metoda používá string.Split, můžete deklarovat proměnnou pro uložení výsledku string.Split a jeho použití v každé metodě.

Přidejte proměnnou pro uložení aktuální adresy IPv4, na kterou bude každá metoda odkazovat:

string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
string[] address;
bool validLength = false;
bool validZeroes = false;
bool validRange = false;

Inicializace address pomocí string.Split následujícího postupu:

foreach (string ip in ipv4Input) 
{
    address = ip.Split(".", StringSplitOptions.RemoveEmptyEntries);

Odeberte odkazy z string.Split každé metody ověřování, aby místo toho používaly globální address proměnnou. Příklad:
```
void ValidateLength() 
{
    validLength = address.Length == 4;
};
```

Kontrola práce

V této úloze spustíte aplikaci z integrovaného terminálu a ověříte, že váš kód funguje správně. Pojďme na to.

Porovnejte kód s následujícím kódem, abyste měli jistotu, že je správný:

string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
string[] address;
bool validLength = false;
bool validZeroes = false;
bool validRange = false;

foreach (string ip in ipv4Input) 
{
    address = ip.Split(".", StringSplitOptions.RemoveEmptyEntries);

    ValidateLength(); 
    ValidateZeroes(); 
    ValidateRange();

    if (validLength && validZeroes && validRange) 
    {
        Console.WriteLine($"{ip} is a valid IPv4 address");
    } 
    else 
    {
        Console.WriteLine($"{ip} is an invalid IPv4 address");
    }
}

void ValidateLength() 
{
    validLength = address.Length == 4;
};

void ValidateZeroes() 
{
    foreach (string number in address) 
    {
        if (number.Length > 1 && number.StartsWith("0")) 
        {
            validZeroes = false;
            return;
        }
    }

    validZeroes = true;
}

void ValidateRange() 
{
    foreach (string number in address) 
    {
        int value = int.Parse(number);
        if (value < 0 || value > 255) 
        {
            validRange = false;
            return;
        }
    }
    validRange = true;
}

Uložte práci pomocí ctrl + S nebo pomocí nabídky Soubor editoru Visual Studio Code.
V případě potřeby otevřete integrovaný panel terminálu editoru Visual Studio Code.

Na panelu PRŮZKUMNÍK otevřete terminál v umístění složky TestProject, klikněte pravým tlačítkem myši na TestProject a pak vyberte Otevřít v integrovaném terminálu.
Na příkazovém řádku terminálu zadejte příkaz dotnet run.
Ověřte, že váš kód vytvoří následující výstup:
```
107.31.1.5 is a valid IPv4 address
255.0.0.255 is a valid IPv4 address
555..0.555 is an invalid IPv4 address
255...255 is an invalid IPv4 address
```
Pokud váš kód zobrazuje různé výsledky, budete muset zkontrolovat kód, abyste našli chybu a aktualizovali ji. Spusťte kód znovu, abyste zjistili, jestli jste problém vyřešili. Pokračujte v aktualizaci a spouštění kódu, dokud váš kód nevygeneruje očekávané výsledky.

Rekapitulace

Tady je, co jste se zatím naučili o používání metod:

Metody lze použít k rychlé struktuře aplikací.
Klíčové return slovo lze použít k ukončení provádění metody.
Každý krok problému lze často přeložit do vlastní metody.
Použití metod k řešení malých problémů při sestavování řešení

Váš názor

Byla tato stránka užitečná?