Ćwiczenie — kompilowanie kodu za pomocą metod

10 min

Metody są przydatne do organizowania kodu, ponownego tworzenia kodu i efektywnego rozwiązywania problemów. Możesz myśleć o metodzie takiej jak skrzynka, która pobiera dane wejściowe, wykonuje nazwane zadanie i zwraca dane wyjściowe. Dzięki temu założeń można szybko strukturę programów po prostu nazewnictwa zadań jako metod, a następnie wypełnić logikę po zidentyfikowaniu wszystkich niezbędnych zadań.

Jeśli używasz zwykłego języka do opisywania kroków w kodzie, bez ścisłego przestrzegania reguł składni, używasz "pseudo-kodu". Łączenie metod i pseudo-kodu to doskonały sposób na szybkie włączenie wszelkich trudnych zadań programistycznych.

Używanie metod do tworzenia struktury kodu

Załóżmy, że jesteś kandydatem w wywiadzie programistycznym. Osoba przeprowadzająca wywiad chce napisać program sprawdzający, czy adres IPv4 jest prawidłowy, czy nieprawidłowy. Otrzymujesz następujące reguły:

Prawidłowy adres IPv4 składa się z czterech liczb rozdzielonych kropkami
Każda liczba nie może zawierać zer wiodących
Każda liczba musi należeć do zakresu od 0 do 255

1.1.1.1 i 255.255.255.255 to przykłady prawidłowych adresów IP.

Adres IPv4 jest udostępniany jako ciąg. Można założyć, że składa się tylko z cyfr i kropek (w podanym ciągu nie ma liter).

Jak podejść do tego zadania?

Uwaga

Nawet jeśli nie znasz adresów IP, nie martw się! Nadal możesz ukończyć kod w tym ćwiczeniu, wykonując kroki.

Podział problemu

W tym zadaniu zidentyfikujesz kroki potrzebne do rozwiązania problemu. Jeśli przyjrzysz się bliżej regułom, może się okazać, że wystarczy wykonać trzy kroki, aby określić, czy adres IPv4 jest prawidłowy.

W edytorze programu Visual Studio Code usuń dowolny istniejący kod z poprzednich ćwiczeń.
Wprowadź następujący pseudo-kod w edytorze:
```
/*
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
*/
```
Pseudo-kod to świetny sposób na rozpoczęcie rozwiązywania wszelkich problemów. Korzystając z tego bloku komentarzy, należy wypełnić lukę między regułami monitów a kodem programu, wyjaśniając główne zadania, które wykona kod. Pseudo-kod nie musi być funkcjonalny ani stosować się do reguł składni, jednak powinno to być jasne wyjaśnienie tego, co zrobi kod. Teraz przekształcimy to w prawdziwy kod!
Wprowadź nowy pusty wiersz kodu, a następnie wpisz następujący kod w edytorze:
```
if (ValidateLength() && ValidateZeroes() && ValidateRange()) 
{
    Console.WriteLine($"ip is a valid IPv4 address");
} 
else 
{
    Console.WriteLine($"ip is an invalid IPv4 address");
}
```
W tym kroku przekształcisz if instrukcje z pseudo-kodu w metody wywoływane i wyprowadzasz wyniki. Nie martw się jeszcze o definiowanie metod; Można założyć, że każda metoda wykonuje zadanie, w którym opisano jego nazwę. Naprawisz błędy kompilacji i wkrótce utworzysz logikę metody, ale skupisz się na dużym obrazie. Po rozpoczęciu pracy nad nowym programem skupienie się na ogólnym projekcie pomaga w szybszym organizowaniu i opracowywaniu aplikacji.
Wprowadź nowy pusty wiersz kodu poniżej istniejącego kodu, a następnie wpisz następujący kod w edytorze:
```
void ValidateLength() {}
void ValidateZeroes() {}
void ValidateRange() {}
```
Zwróć uwagę, że użycie metod symboli zastępczych umożliwiło szybkie podejście do problemu i struktury kodu w celu opracowania rozwiązania. Teraz, gdy masz plan ustrukturyzowany, możesz kontynuować rozwiązywanie problemu, wypełniając fragment kodu po kawałku.

Opracowywanie rozwiązania

Teraz, gdy masz wszystkie metody zastępcze potrzebne do rozwiązania problemu, możesz zacząć skupiać się na szczegółach rozwiązania. Należy pamiętać, że format wejściowy adresu IPv4 będzie ciągiem składającym się z cyfr rozdzielonych kropkami. Zacznijmy!

Na początku programu utwórz zmienne do przechowywania stanu danych wejściowych i stanu weryfikacji:

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

Zaktualizuj kod rozwiązania, aby użyć zmiennych walidacji w następujący sposób:

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

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

Zaktualizuj metodę ValidateLength w następujący sposób:
```
void ValidateLength() 
{
    string[] address = ipv4Input.Split(".");
    validLength = address.Length == 4;
};
```
Pierwsza reguła wskazuje, że adres IPv4 musi mieć cztery liczby. Dlatego w tym kodzie użyjesz string.Split metody , aby oddzielić cyfry i sprawdzić, czy istnieją cztery z nich.
Zaktualizuj metodę ValidateZeroes w następujący sposób:
```
void ValidateZeroes() 
{
    string[] address = ipv4Input.Split(".");

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

    validZeroes = true;
}
```
Pośmiń chwilę, aby zastanowić się, jak reguła tłumaczy się na kod.

Druga reguła stwierdza, że liczby w adresie IPv4 nie mogą zawierać zer wiodących. Dlatego metoda musi sprawdzać liczby zer wiodących podczas akceptowania 0 jako prawidłowa liczba. Jeśli wszystkie liczby mają prawidłowe zera, validZeroes powinny być równe true, i false w przeciwnym razie. Dlatego w tym kodzie sprawdzasz, czy każda liczba z więcej niż jedną cyfrą nie zaczyna się od zera.

Jeśli przyjrzysz się bliżej, zauważysz, że validZeroes jest ustawiona na wartość true po zakończeniu foreach pętli. Jednak chcesz ustawić wartość validZeroestrue tylko wtedy, gdy nie znaleziono zer wiodących. Tę usterkę można poprawić, ustawiając ustawienie validZeroes = true przed uruchomieniem foreach pętli. Można jednak również poprawić tę usterkę przy użyciu instrukcji return .
Zaktualizuj kod do następujących elementów:
```
foreach (string number in address) 
{
    if (number.Length > 1 && number.StartsWith("0")) 
    {
        validZeroes = false;
        return;
    }
}
```
Instrukcja return kończy wykonywanie metody i zwraca kontrolkę do obiektu wywołującego metodę. return Dodanie instrukcji po zakończeniu metody po validZeroes = false znalezieniu pierwszego nieprawidłowego zera. Jeśli nie znaleziono nieprawidłowego zera, metoda zakończy się po ustawieniu validZeroes wartości .true Przejdźmy do następnej metody.
Zaktualizuj metodę ValidateRange w następujący sposób:
```
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;
}
```
Trzecia reguła określa, że każda liczba w adresie IPv4 musi należeć do zakresu od 0 do 255. Dlatego w tym kodzie sprawdzasz, czy każda liczba jest mniejsza niż 255, a jeśli nie, zakończ wykonywanie po ustawieniu wartości validRangefalse. Ponieważ ciąg wejściowy zawiera tylko cyfry i kropki, nie musisz sprawdzać pod kątem liczb ujemnych.

Może jednak wystąpić przypadek, w którym nie ma żadnych cyfr między kropkami. Na przykład "255...255". W takim przypadku string.Split(".") zwraca puste wpisy, co powoduje int.Parse niepowodzenie. Można temu zapobiec, określając wartość StringSplitOptions.
Zaktualizuj kod w następujący sposób:
```
string[] address = ipv4Input.Split(".", StringSplitOptions.RemoveEmptyEntries);
```
Użycie StringSplitOptions.RemoveEmptyEntries pomija pustych wpisów z address tablicy i uniemożliwia analizowanie pustych ciągów.

Ukończ rozwiązanie

Teraz, gdy wszystkie metody zostały ukończone w celu zweryfikowania adresu IP, nadszedł czas na ponowne sprawdzenie początkowego rozwiązania. W tym zadaniu dodasz więcej wartości wejściowych i przygotujesz się do przetestowania kodu.

Znajdź następujący kod napisany wcześniej w programie:
```
string ipv4Input = "107.31.1.5";
```
Zaktualizuj kod w następujący sposób:
```
string[] ipv4Input = {"107.31.1.5", "255.0.0.255", "555..0.555", "255...255"};
```
Podczas tworzenia rozwiązania ważne jest przetestowanie kodu przy użyciu różnych przypadków wejściowych. W tym kodzie podajesz przyzwoity zakres wartości testowych. Po zaktualizowaniu danych wejściowych testu należy zaktualizować kod, aby używał nowych wartości. Ponieważ wartości znajdują się w tablicy, należy zaktualizować kod, aby przetestować każdy z nich przy użyciu pętli.
Zaktualizuj kod w następujący sposób:
```
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");
    }
}
```
Na koniec należy naprawić dane wejściowe, których używa każda metoda, ponieważ została zaktualizowana ipv4Input z ciągu do tablicy. Ponieważ każda metoda używa string.Splitmetody , można zadeklarować zmienną do przechowywania wyników string.Split i użyć jej w każdej metodzie.

Dodaj zmienną do przechowywania bieżącego adresu IPv4, do którego odwołuje się każda metoda:

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;

Zainicjuj address przy użyciu string.Split następującego polecenia:

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

Usuń odwołania do string.Split z każdej z metod walidacji, aby zamiast tego używały zmiennej globalnej address . Na przykład:
```
void ValidateLength() 
{
    validLength = address.Length == 4;
};
```

Sprawdź swoją pracę

W tym zadaniu uruchomisz aplikację ze zintegrowanego terminalu i sprawdzisz, czy kod działa poprawnie. Zaczynajmy.

Porównaj kod z następującymi elementami, aby upewnić się, że jest on poprawny:

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;
}

Zapisz swoją pracę przy użyciu Ctrl + S lub za pomocą menu Plik programu Visual Studio Code.
W razie potrzeby otwórz panel zintegrowany terminal programu Visual Studio Code.

W panelu EKSPLORATOR, aby otworzyć terminal w lokalizacji folderu TestProject, kliknij prawym przyciskiem myszy pozycję TestProject, a następnie wybierz polecenie Otwórz w zintegrowanym terminalu.
W wierszu polecenia terminalu wprowadź polecenie dotnet run
Sprawdź, czy kod generuje następujące dane wyjściowe:
```
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
```
Jeśli kod wyświetla różne wyniki, musisz przejrzeć kod, aby znaleźć błąd i wprowadzić aktualizacje. Uruchom ponownie kod, aby sprawdzić, czy problem został rozwiązany. Kontynuuj aktualizowanie i uruchamianie kodu, dopóki kod nie generuje oczekiwanych wyników.

Podsumowanie

Poniżej przedstawiono informacje na temat używania metod do tej pory:

Metody mogą służyć do szybkiego tworzenia struktury aplikacji
Słowo return kluczowe może służyć do zakończenia wykonywania metody
Każdy krok problemu często można przetłumaczyć na własną metodę
Używanie metod do rozwiązywania małych problemów w celu utworzenia rozwiązania

Opinia

Czy ta strona była pomocna?