Voorwaardelijke logica leren met vertakkings- en lusinstructies
In deze zelfstudie leert u hoe u code schrijft waarmee variabelen en het uitvoeringspad voor wijzigingen worden onderzocht op basis van deze variabelen. Met behulp van uw browser schrijft u interactief C# en bekijkt u de resultaten van het samenstellen en uitvoeren van uw code. Deze zelfstudie bevat een reeks lessen waarin vertakkings- en lusconstructies in C# worden verkend. In deze lessen krijgt u uitleg over de basisprincipes van de computertaal C#.
Tip
Als u een codefragment in de focusmodus wilt plakken, moet u de sneltoets (Ctrl + v of cmd + v) gebruiken.
Besluiten nemen met behulp van de if-instructie
Voer de volgende code uit in het interactieve venster. Selecteer de knop Focusmodus invoeren. Typ vervolgens het volgende codeblok in het interactieve venster en selecteer Uitvoeren:
int a = 5;
int b = 6;
if (a + b > 10)
Console.WriteLine("The answer is greater than 10.");
Als u dit uitvoert in uw omgeving, moet u in plaats daarvan de instructies voor de lokale versie volgen.
Wijzig de declaratie van b zodanig dat de som lager is dan 10:
int b = 3;
Selecteer opnieuw de knop Uitvoeren . Omdat het antwoord lager is dan 10, wordt er niets afgedrukt. De door u geteste voorwaarde is onwaar. U hebt geen uitvoerbare code, omdat u enkel een van de mogelijke vertakkingen voor een if-instructie hebt geschreven: de vertakking Waar.
Tip
Bij de verkenning van C# (of elke andere programmeertaal) zult u fouten maken bij het schrijven van code. Het compileerprogramma vindt deze fouten en meldt deze aan u. Wanneer de uitvoer foutberichten bevat, dient u zorgvuldig de voorbeeldcode en de code in het interactieve venster na te kijken om te zien wat u moet herstellen. Deze oefening helpt u om inzicht te krijgen in de structuur van C#-code.
Het eerste voorbeeld toont de kracht van if en booleaanse typen. Een booleaanse waarde is een variabele die één of twee waarden kan hebben: true of false. C# definieert een speciaal type, bool voor booleaanse variabelen. Met de instructie if controleert u de waarde van een bool. Wanneer de waarde true is, wordt de instructie die op de if volgt, uitgevoerd. Anders wordt het overgeslagen.
Dit proces voor het controleren van voorwaarden en het uitvoeren van instructies op basis van deze voorwaarden is krachtig. Laten we nog meer verkennen.
Ervoor zorgen dat ‘if’ en ‘else’ in combinatie werken
Als u verschillende code in de vertakkingen Waar en Onwaar wilt uitvoeren, maakt u een else-vertakking die wordt uitgevoerd wanneer de voorwaarde onwaar is. Probeer dit:
int a = 5;
int b = 3;
if (a + b > 10)
Console.WriteLine("The answer is greater than 10");
else
Console.WriteLine("The answer is not greater than 10");
De instructie die volgt op het sleutelwoord else, wordt alleen uitgevoerd wanneer de geteste voorwaarde false is. Door de combinatie van if en else met booleaanse voorwaarden wordt u al het vermogen geboden dat u nodig hebt.
Belangrijk
De inspringing onder instructie if en else is voor menselijke lezers.
De C#-taal behandelt inspringing of witruimte niet als belangrijk.
De instructie die volgt op het sleutelwoord if of else wordt uitgevoerd op basis van de voorwaarde. Alle voorbeelden in deze zelfstudie volgen een veelvoorkomende procedure om regels te laten inspringen op basis van de controlestroom van instructies.
Omdat inspringing niet significant is, moet u deze gebruiken { en } aangeven wanneer u wilt dat meer dan één instructie deel uitmaakt van het blok dat voorwaardelijk wordt uitgevoerd. C#-programmeurs gebruiken die accolades doorgaans voor alle if- en else-componenten. Het volgende voorbeeld is hetzelfde als wat u hebt gemaakt. Probeer het
int a = 5;
int b = 3;
if (a + b > 10)
{
Console.WriteLine("The answer is greater than 10");
}
else
{
Console.WriteLine("The answer is not greater than 10");
}
Tip
In de rest van deze zelfstudie bevatten de codevoorbeelden allemaal de accolades, gevolgd door geaccepteerde procedures.
U kunt meer gecompliceerde voorwaarden testen:
int a = 5;
int b = 3;
int c = 4;
if ((a + b + c > 10) && (a == b))
{
Console.WriteLine("The answer is greater than 10");
Console.WriteLine("And the first number is equal to the second");
}
else
{
Console.WriteLine("The answer is not greater than 10");
Console.WriteLine("Or the first number is not equal to the second");
}
Het == symbool test op gelijkheid. Door == onderscheid te maken tussen de gelijkheidstest en toewijzing, die u in a = 5hebt gezien.
De && staat voor and. Dat wil zeggen dat beide voorwaarden waar moeten zijn om de instructie in de vertakking Waar uit te voeren. Deze voorbeelden geven tevens weer dat er meerdere instructies in een vertakking kunnen voorkomen, mits u deze omsluit met { en }.
U kunt ook gebruiken || om 'or' weer te geven:
int a = 5;
int b = 3;
int c = 4;
if ((a + b + c > 10) || (a == b))
{
Console.WriteLine("The answer is greater than 10");
Console.WriteLine("Or the first number is equal to the second");
}
else
{
Console.WriteLine("The answer is not greater than 10");
Console.WriteLine("And the first number is not equal to the second");
}
Wijzig de waarden van a, ben c schakel tussen && en || om te verkennen. U krijgt meer inzicht in hoe de && en || operators werken.
Lussen gebruiken om bewerkingen te herhalen
Een ander belangrijk concept voor het maken van grotere programma’s is lussen. U kunt lussen gebruiken om instructies te herhalen die u meer dan eens wilt laten uitvoeren. Probeer deze code in het interactieve venster:
int counter = 0;
while (counter < 10)
{
Console.WriteLine($"Hello World! The counter is {counter}");
counter++;
}
Met de instructie while wordt een voorwaarde gecontroleerd en de instructie uitgevoerd conform de while. Hiermee wordt de controle van de voorwaarde en de uitvoering van die instructies herhaald tot de voorwaarde onwaar is.
Dit voorbeeld bevat nog een andere nieuwe operator. De ++ na de variabele counter is de verhogingsoperator. Hiermee wordt de waarde van de teller met 1 verhoogd en wordt die waarde in de tellervariabele opgeslagen.
Belangrijk
Controleer of de lusvoorwaarde while inderdaad naar onwaar wordt geschakeld wanneer u de code uitvoert. Als dat niet het geval is, hebt u een oneindige lus gemaakt, zodat uw programma nooit wordt voltooid. Dit zullen we niet demonstreren, aangezien er dan een time-out optreedt in de engine waarop uw code wordt uitgevoerd, waardoor u geen uitvoer van uw programma te zien krijgt.
Met de lus while wordt de voorwaarde getest voordat de code conform de while wordt uitgevoerd. Met de lus do ... while wordt eerst de code uitgevoerd en daarna de voorwaarde uitgevoerd. Het ziet er als volgt uit:
int counter = 0;
do
{
Console.WriteLine($"Hello World! The counter is {counter}");
counter++;
} while (counter < 10);
Deze lus do en de vorige lus while werken op gelijke wijze.
Laten we doorgaan met één laatste lusinstructie.
Werken met de lus ‘for’
Een andere bekende lusinstructie die u in C#-code tegenkomt, is de lus for. Probeer deze code in het interactieve venster:
for (int counter = 0; counter < 10; counter++)
{
Console.WriteLine($"Hello World! The counter is {counter}");
}
Deze doet hetzelfde als lus while en lus do die u al hebt gebruikt. De instructie for bevat drie delen die de werking ervan regelen.
Het eerste deel is de ‘for’-initialisatiefunctie: int counter = 0; declareert dat counter de lusvariabele is en stelt de bijbehorende beginwaarde in op 0.
Het middelste deel is de ‘for’-voorwaarde: counter < 10 declareert dat deze lus for wordt uitgevoerd zolang de waarde van de teller lager is dan 10.
Het laatste deel is de ‘for’-iterator: counter++ geeft op hoe de lusvariabele moet worden aangepast wanneer het blok conform de instructie for wordt uitgevoerd. Hier wordt opgegeven dat counter steeds met 1 moet worden verhoogd als het blok wordt uitgevoerd.
Hiermee kunt u zelf experimenteren. Probeer elk van de volgende opties:
- Wijzig het initialisatieprogramma, zodat bij een andere waarde wordt gestart.
- Wijzig de voorwaarde, zodat bij een andere waarde wordt gestopt.
Als u klaar bent, gaan we verder met het zelf schrijven van code, om toe te passen wat u hebt geleerd.
Er is nog een andere lusinstructie die niet wordt behandeld in deze zelfstudie: de foreach instructie. De foreach instructie herhaalt de instructie voor elk item in een reeks items. Het wordt meestal gebruikt met verzamelingen, dus deze wordt behandeld in de volgende zelfstudie.
Geneste lussen gemaakt
Een while, doof for lus kan in een andere lus worden genest om een matrix te maken met behulp van de combinatie van elk item in de buitenste lus met elk item in de binnenste lus. Laten we dat doen om een set alfanumerieke paren te maken die rijen en kolommen vertegenwoordigen.
Met één for lus kunnen de rijen worden gegenereerd:
for (int row = 1; row < 11; row++)
{
Console.WriteLine($"The row is {row}");
}
Een andere lus kan de kolommen genereren:
for (char column = 'a'; column < 'k'; column++)
{
Console.WriteLine($"The column is {column}");
}
U kunt één lus in de andere nesten om paren te vormen:
for (int row = 1; row < 11; row++)
{
for (char column = 'a'; column < 'k'; column++)
{
Console.WriteLine($"The cell is ({row}, {column})");
}
}
U kunt zien dat de buitenste lus eenmaal wordt verhoogd voor elke volledige uitvoering van de binnenste lus. Draai de rij- en kolom genest om en bekijk de wijzigingen voor uzelf.
Vertakkingen en lussen combineren
Nu u de instructie if en de lusconstructies in de computertaal C# hebt gezien, kijken we of u C#-code kunt schrijven om de som van de gehele getallen 1 tot en met 20 te vinden die deelbaar zijn door 3. Hier volgen een paar hints:
- De
%-operator biedt u het resterende deel van de divisiebewerking. - De instructie
ifbiedt u de voorwaarde om te zien of een getal deel moet uitmaken van de som. - De lus
forkan u helpen bij het herhalen van een reeks stappen voor alle getallen 1 tot en met 20.
Probeer het zelf eens. Controleer daarna wat u hebt gemaakt. Om u een hint te geven: het antwoord moet 63 zijn.
Uitdaging voltooien
Kreeg u ook deze uitkomst?
int sum = 0;
for (int number = 1; number < 21; number++)
{
if (number % 3 == 0)
{
sum = sum + number;
}
}
Console.WriteLine($"The sum is {sum}");
Gefeliciteerd
U hebt de interactieve zelfstudie 'vertakkingen en lussen' voltooid. U kunt de koppeling voor de lijstverzameling hieronder selecteren om de volgende interactieve zelfstudie te starten of u kunt de .NET-site bezoeken om de .NET SDK te downloaden, een project op uw computer te maken en coderen te behouden. In de sectie Volgende stappen gaat u terug naar deze zelfstudies.
Meer informatie over deze concepten vindt u in deze artikelen:
Is er een probleem met deze sectie? Als dit het geval is, kunt u ons feedback geven zodat we deze sectie kunnen verbeteren.
