Självstudie: C#- `if` instruktioner och -loopar – villkorsstyrd logik

I den här handledningen lär du dig att skriva C#-kod som går igenom variabler och ändrar programflödet baserat på dessa variabler. Du skriver C#-kod och ser resultatet av att kompilera och köra den. Handledningen innehåller en serie lektioner som utforskar förgrenings- och slingsatser i C#. De här lektionerna lär dig grunderna i C#-språket.

I den här handledningen kommer du att:

Starta ett GitHub Codespace med en C#-utvecklingsmiljö.
Utforska if och else satser.
Använd loopar för att upprepa åtgärder.
Arbeta med kapslade loopar.
Kombinera grenar och loopar.

Förutsättningar

Du måste ha något av följande alternativ:

Ett GitHub-konto för att använda GitHub Codespaces. Om du inte redan har ett konto kan du skapa ett kostnadsfritt konto på GitHub.com.
En dator med följande verktyg installerade:
- .NET 10 SDK.
- Visual Studio Code.
- C# DevKit.

Använd if-satser

Om du vill starta ett GitHub Codespace med utbildningsmiljön, öppnar du ett webbläsarfönster till utbildningscodespacens lagringsplats. Välj den gröna kodknappen och fliken Codespaces . Välj + sedan tecknet för att skapa ett nytt Codespace med den här miljön. Om du har slutfört andra självstudier i den här serien kan du öppna det kodområdet i stället för att skapa ett nytt.

När kodområdet läses in skapar du en ny fil i mappen tutorials med namnet branches-loops.cs.
Öppna den nya filen.

Skriv eller kopiera följande kod till branches-loops.cs:

int a = 5;
int b = 6;
if (a + b > 10)
    Console.WriteLine("The answer is greater than 10.");

Prova den här koden genom att skriva följande kommando i den integrerade terminalen:
```
cd tutorials
dotnet branches-loops.cs
```
Du bör se meddelandet "Svaret är större än 10." skrivs ut till konsolen.
Ändra deklarationen för b så att summan är mindre än 10:
```
int b = 3;
```
Skriv dotnet branches-loops.cs igen i terminalfönstret.

Eftersom svaret är mindre än 10 skrivs ingenting ut. Det villkoret du testar är falskt. Du har ingen kod att köra eftersom du bara skrev en av de möjliga grenarna för en if-instruktion: den sanna grenen.

Tips

När du utforskar C# (eller något programmeringsspråk) kan du göra misstag när du skriver kod. Kompilatorn hittar och rapporterar felen. Titta närmare på felutdata och koden som genererade felet. Du kan också be Copilot att hitta skillnader eller upptäcka eventuella misstag. Kompilatorfelet kan vanligtvis hjälpa dig att hitta problemet.

Det första exemplet visar kraften hos if och booleska typer. Ett booleskt värde är en variabel som kan ha ett av två värden: true eller false. C# definierar en särskild typ för bool booleska variabler. Instruktionen if kontrollerar värdet på bool. När värdet är truekörs instruktionen efter if. Annars hoppas den över. Den här processen med att kontrollera villkor och köra instruktioner baserat på dessa villkor är kraftfull. Nu ska vi utforska mer.

Få if- och else-satser att fungera tillsammans

Om du vill köra annan kod i både sanna och falska grenar skapar du en else gren som körs när villkoret är falskt. Prova en else gren.

Lägg till de två sista raderna i följande kodfragment (du bör redan ha de fyra första):
```
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");
```
Instruktionen som följer nyckelordet else körs endast när villkoret som testas är false. Att kombinera if och else med booleska villkor ger all kraft du behöver för att hantera både ett true och ett false villkor.

Viktig

Indraget under if- och else-satser är för mänskliga läsare. C#-språket behandlar inte indrag eller blanksteg som betydande. Instruktionen efter nyckelordet if eller else körs baserat på villkoret. Alla exempel i den här självstudien följer en vanlig metod för att indenta rader baserat på kontrollflödet i instruktionerna.

Eftersom indragning inte är signifikant måste du använda { och } för att ange när du vill att fler än en instruktion ska ingå i blocket som exekveras villkorligt. C#-programmerare använder vanligtvis dessa klammerparenteser på alla if- och else-satser.
Följande exempel är detsamma som det du skapade i föregående exempel, med tillägget av { och }. Ändra koden så att den matchar följande kod:
```
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");
}
```
Tips

I resten av den här självstudien innehåller alla kodexempel klammerparenteser, enligt vedertagna metoder.
Du kan testa mer komplicerade villkor. Lägg till följande kod efter den kod som du har skrivit hittills:
```
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");
}
```
Symbolen == testar för likhet. Om du använder == skiljer du testet för likhet från tilldelningen, som du såg i a = 5.

&& representerar "och". Det innebär att båda villkoren måste vara sanna för att kunna utföra satsen i den sanna delen. De här exempel visar också att du kan ha flera instruktioner i varje villkorsgren, förutsatt att de inkapslas i { och }.
Du kan också använda || för att representera "eller". Lägg till följande kod efter det du har skrivit hittills:
```
if ((a + b + c > 10) || (a == b))
```
Ändra värdena för a, boch c och växla mellan && och || att utforska. Du får mer förståelse för hur operatorerna && och || fungerar.

Du har slutfört det första steget. Innan du börjar nästa avsnitt ska vi flytta den aktuella koden till en separat metod. Det gör det enklare att börja arbeta med ett nytt exempel. Placera den befintliga koden i en metod som heter ExploreIf(). Anropa det från början av programmet. När du har slutfört ändringarna bör koden se ut som följande kod:

ExploreIf();

void ExploreIf()
{
    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");
    }

    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 greater than the second");
    }
    else
    {
        Console.WriteLine("The answer is not greater than 10");
        Console.WriteLine("Or the first number is not greater than the second");
    }

    if ((a + b + c > 10) || (a > b))
    {
        Console.WriteLine("The answer is greater than 10");
        Console.WriteLine("Or the first number is greater than the second");
    }
    else
    {
        Console.WriteLine("The answer is not greater than 10");
        Console.WriteLine("And the first number is not greater than the second");
    }
}

Kommentera ut anropet till ExploreIf(). Det gör utdata mindre röriga när du arbetar i det här avsnittet:
```
//ExploreIf();
```

Det // startar en kommentar i C#. Kommentarer är all text som du vill behålla i källkoden, men som inte körs som kod. Kompilatorn genererar ingen körbar kod från kommentarer.

Använda loopar för att upprepa åtgärder

Ett annat viktigt begrepp för att skapa större program är loopar. Använd loopar för att upprepa instruktioner som du vill köra mer än en gång.

Lägg till den här koden efter anropet till ExploreIf:
```
int counter = 0;
while (counter < 10)
{
    Console.WriteLine($"Hello World! The counter is {counter}");
    counter++;
}
```
while-instruktionen kontrollerar ett villkor och kör instruktionen som följer efter while. Den kontrollerar villkoret upprepade gånger och kör de här instruktionerna tills villkoret är falskt.

Det finns en ytterligare ny operator i det här exemplet. ++ efter variabeln counter är ökningsoperatören . Den lägger till 1 i värdet counter för och lagrar det värdet i variabeln counter .

Viktig

Kontrollera att loopvillkoret while ändras till false när du kör koden. Annars skapar du en oändlig loop där programmet aldrig slutar. Det beteendet visas inte i det här exemplet eftersom du måste tvinga programmet att avslutas genom att använda CTRL-C eller på annat sätt.

while-loopen testar villkoret innan koden körs efter while.
Loopen do ... while kör koden först och kontrollerar sedan villkoret. Do while-loopen visas i följande kod:
```
int counter = 0;
do
{
    Console.WriteLine($"Hello World! The counter is {counter}");
    counter++;
} while (counter < 10);
```
Den här do loopen och den tidigare while loopen ger samma utdata.

Nu går vi vidare till en sista loop-instruktion.

Arbeta med for-loopen

En annan vanlig loop-instruktion som du ser i C#-kod är for-loopen.

Prova den här koden:
```
for (int counter = 0; counter < 10; counter++)
{
    Console.WriteLine($"Hello World! The counter is {counter}");
}
```
Den föregående for-loopen utför samma arbete som den while-loopen och den do-loop som du redan använde. Instruktionen for har tre delar som styr hur den fungerar:
- Den första delen är för initieraren: int counter = 0; deklarerar att counter är loopvariabeln och anger dess ursprungliga värde till 0.
- Den mellersta delen är for-villkoret: counter < 10 deklarerar att den här for loopen fortsätter att köras så länge värdet counter för är mindre än 10.
- Den sista delen är för iteratorn: counter++ anger hur du ändrar loopvariabeln efter att ha kört blocket efter for-instruktionen. Här anger den att counter ökar med 1 varje gång blocket körs.
Experimentera med dessa villkor själv. Prova var och en av följande ändringar:
- Ändra initieraren så att den börjar med ett annat värde.
- Ändra villkoret så att det slutar med ett annat värde.

När du är klar går du vidare till nästa avsnitt för att skriva lite kod själv och använda det du har lärt dig.

Det finns en annan loop-sats som inte behandlas i den här självstudien: satsen foreach. Instruktionen foreach upprepar sin instruktion för varje objekt i en sekvens med objekt. Du använder det oftast med samlingar. Den tas upp i nästa självstudie.

Skapade kapslade loopar

Du kan kapsla en while, doeller for -loop i en annan loop för att skapa en matris genom att kombinera varje objekt i den yttre loopen med varje objekt i den inre loopen. Nu ska vi skapa en uppsättning alfanumeriska par som representerar rader och kolumner.

Lägg till följande for loop som genererar raderna:

for (int row = 1; row < 11; row++)
{
    Console.WriteLine($"The row is {row}");
}

Lägg till ytterligare en loop för att generera kolumnerna:

for (char column = 'a'; column < 'k'; column++)
{
    Console.WriteLine($"The column is {column}");
}

Kapsla slutligen kolumnernas loop inuti raderna för att bilda par:
```
for (int row = 1; row < 11; row++)
{
    for (char column = 'a'; column < 'k'; column++)
    {
        Console.WriteLine($"The cell is ({row}, {column})");
    }
}
```
Den yttre slingan ökar en gång för varje fullständig körning av den inre slingan. Vänd på rad- och kolumnordningen och se ändringarna själv. När du är klar placerar du koden från det här avsnittet i en metod med namnet ExploreLoops().

Kombinera grenar och loopar

Nu när du har använt -instruktionen if och loopkonstruktionerna på C#-språket kan du se om du kan skriva C#-kod för att hitta summan av alla heltal 1 till 20 som är delbara med 3. Här följer några tips:

Operatorn % ger dig resten av en divisionsåtgärd.
Med if-instruktionen får du reda på villkoret om ett tal ska vara en del av summan.
Den for-loopen kan hjälpa dig att upprepa en serie steg för alla tal 1 till och med 20.

Prova själv. Kontrollera sedan hur du gjorde. Som ett tips bör du få 63 som svar.

Kom du på något som liknar det här?

int sum = 0;
for (int number = 1; number < 21; number++)
{
    if (number % 3 == 0)
    {
        sum = sum + number;
    }
}
Console.WriteLine($"The sum is {sum}");

Du har slutfört handledningen "grenar och loopar". Du kan lära dig mer om dessa begrepp i dessa artiklar:

Rensa resurser

GitHub tar automatiskt bort ditt Codespace efter 30 dagars inaktivitet. Om du planerar att utforska fler självstudier i den här serien, kan du låta ditt Codespace vara provisionerat. Om du är redo att besöka .NET-webbplatsen för att ladda ned .NET SDK kan du ta bort ditt Codespace. Om du vill ta bort ditt Codespace öppnar du ett webbläsarfönster och navigerar till dina Codespaces. Du bör se en lista över dina kodområden i fönstret. Välj de tre punkterna (...) i inmatningen för lär-självstudions kodutrymme och välj ta bort.

Nästa steg

Lär dig mer om samlingar

Feedback

Var den här sidan till hjälp?

Last updated on 2025-12-11