Villkorssatser
När man programmerar använder man sig ofta av villkorssatser för att styra programflödet. Med hjälp av en villkorssats kan man styra hur programflödet ska uppföra sig då ett visst villkor är uppfyllt.
if-satser
Den vanligaste villkorssatsen är if-satsen. Man har då en sektion med kod som enbart utförs då villkoret är sant, till exempel;
if (villkor)
{
<kodblocket utförs endast om villkor är sant>
}
<Här fortsätter koden sen>
Eller för att skriva det på vanlig svenska; Om villkor är sant gör det här…
Om villkor inte är sant, fortsätter programmet att köra koden som finns efter ”}”-tecknet.
Man kan även begära att något annat ska utföras i de fall som villkoret inte är sant. Då gör man så här;
if ( villkor)
{
<utförs endast om villkor är sant>
} else {
<utförs endast om villkor är falskt>
}
Med den programkoden säger man; om villkor är sant gör det som står i första blocket, i annat fall gör det som står i else-blocket.
Om man vill kan man lägga if-satser inuti andra if-satser. Det kallas nästlade eller inkapslade if:ar. Sådana kan man använda om man vill att programmet ska kolla om flera saker är sanna. Men som ni kommer att se i nästa sektion, går det ibland att lösa dylika situationer på ett mer effektivt sätt. Ett exempel på nästlade if-satser:
if ( villkor)
{
if ( villkor2)
{
<utförs endast om både villkor och villkor2 är sanna>
}
}
Att jobba med sanningsvärden
Man brukar tala om sanningsvärden när man jobbar med villkor. Ett sanningsvärde är antingen true eller false, dvs sant eller falskt. När ett villkor är sant säger man att villkoret är uppfyllt. Ibland kan man även säga uttryck istället för villkor.
Några exempel på sanningsvärden:
C#-villkor Resultat 1 == 1 True 1 == 2 False “alfa” == “alfa” True “alfa” == “beta” False
Lägg märke till att för jämförelse använder man sig i JavaScript av ”==”, dvs två likamed-tecken. Ett likamed-tecken ger tilldelning, medan två ger jämförelse. Tilldelning ändrar innehållet i variabeln, medan jämförelse returnerar true eller false utan att ändra något innehåll.
(I den här sektionen kommer vi bara att använda if-satser i exemplen. Men alla sanningsvärden skulle fungera lika bra (eller dåligt) i t.ex. while-loopar.)
Om man vill kan man göra if-satser som alltid utförs:
if ( true ) { <utförs alltid> }
Det är iofs rätt meningslöst att göra så (vi kommer dock att se att det finns tillfällen då liknande konstruktioner är användbara, men det blir först när vi kommer till while). Ännu meningslösare, men likväl möjligt, är att göra en if-sats som aldrig körs (genom att använda sig av sanningsvärdet false).
I villkor använder man sig ofta av matematiska jämförelseoperatorer. Några vanliga villkor/jämförelseoperatorer:
C#-villkor Typ av jämförelse a == b Är a och b lika? a != b Är a skiljd ifrån b? a < b Är a mindre än b? a > b Är a större än b? a <= b Är a mindre än eller lika b?
I C# betyder ”!” icke, eller ”not”, så man utläser alltså ”!=” som icke lika med. Kombinera sanningsvärden Man kan sätta samman mer komplexa villkor med hjälp av; ”&&” som betyder ”och” samt ”||” som betyder ”eller”. Genom att använda dessa instruktioner kan man foga samman flera sanningsuttryck till ett. Man kan jämföra med hur man använder sig av + och – när man räknar med vanliga tal, skillnaden är att vi nu ”räknar” med sanningsvärden.
Det finns till och med en speciell gren av matematik som specialiserar sig på räkning med sanningsvärden-/uttryck, det kallas Boolesk algebra.
Och-villkor; &&
När man använder sig av && måste bägge villkoren vara uppfyllda för att hela och-villkoret ska bli sant.
if ( villkor1 && villkor2 ) { <utförs endast om både villkor1 och villkor2 är sanna> }
Det innebär att följande gäller för och-villkoret:
Villkor Resultat false && false false true && false false false && true false true && true true
Eller-villkor; || När man använder eller-varianten, ||, räcker det med att ett av villkoren är uppfyllt (bägge villkoren kan vara sanna, men det räcker med att ett är det).
if ( villkor1 || villkor2 ) { <utförs endast om något, eller båda, av villkor1 och villkor2 är sant> }
Det innebär att följande gäller för eller-villkoret:
Villkor Resultat false && false false true && false true false && true true true && true true Icke-villkor; ! Icke-operatorn förändrar ett sanningsvärde till dess motsats. Dvs, true blir false och vice versa.
Villkor Resultat !false true !true false
I vissa fall kan det vara snyggare och enklare att skriva ett uttryck på ett visst sätt och sedan lägga ett ”!” framför allt för att på så vis omvandla det till sin motsats. Man kan alltid skriva om och-vilkor till eller-vilkor med hjälp av icke-operatorn och vice versa. Sanningsvärden och funktioner Vissa programfunktioner returnerar true eller false och kan därför direkt användas som sanningsvärden/villkor i if-satser. Det är speciellt användbart för jämförelsefunktioner för strängvariabler och liknande.
Som vi nämnt, så har C# en speciell variabeltyp som enbart är till för sanningsvärden. Den heter bool och kan enbart anta värdena true eller false. Ibland kan det vara praktiskt att spara undan returvärdet från en funktion i en bool-variabel.
Man t.ex. använder ofta bool-variabler i while-satser. Ett litet exempel;
bool running; running = true;
while (running) <massa kod> if ( tangent == ”q”) {
running = false;
} }
Exemplet ovan kommer alltså att köras i en loop, ända tills användaren trycker på tangenten ”q”. Då blir running satt till false och while-loopen avslutas.
När man programmerar är det alltid viktigt att försöka bryta ned varje programuppgift i så små deluppgifter som möjligt. Därför är det ofta bra att skapa små jämförelsefunktioner som returnera true eller false. Till exempel om man vill kolla om ett tal är ett jämt tal, kan man skapa en liknande funktion;
bool isEven ( int tal ) { if( tal % 2 == 0 ) { return true;
} else {
return false;
}
}
Inte det mest optimala sättet att skapa en dylik funktion, men det är relativt läsbart. Här skapar vi en ny metod, som heter isEven. I och med att vi definierat metoden kan vi använda den på andra ställen i vår kod, precis som om den vore en del av programmeringsspråket. På så vis kan vi alltså utvidga språket och specialanpassa det för det vi vill göra. Ett bättre och koncisare sätt att skriva ovanstående funktion skulle vara det här:
bool isEven ( int tal ) { return tal % 2 == 0; }
Nu när man definierat funktionen, finns den att tillgå och man kan använda sig av den i programmets if-satser;
if ( isEven( nånVariabel ) ) { <utförs endast om nånVariabel är ett jämt tal > }
Man skulle även kunna skriva ”isEven( a ) == true”, men det behövs inte eftersom ju funktionen alltid returnerar true eller false. Man undviker oftast att lägga till onödig kod, det skapar bara mer chanser att något blir fel eller att koden blir mer svårläst.
Om man skulle vilja testa om något är udda, d.v.s. motsatsen till jämt, kan man göra så här;
if ( isEven( nånVariabel ) == false ) { <utförs endast om nånVariabel är ett udda tal> }
Ett annat, vanligare, sätt att kontrollera om något är falskt är;
if ( !isEven( nånVariabel ) ) { <utförs endast om nånVariabel är ett udda tal> }
Som du kanske minns så betyder ”!”-tecknet ”inte” i C#. Användandet av ”not” kommer ifrån Boolesk algebra. ”!”-tecknet gör om det efterföljande uttrycket till dess motsats. Det betyder att !true blir false och !false blir true.
Självklart kan man använda ”&&” och ”||” tillsammans med funktioner som returnerar sanningsvärden. Till exempel:
if ( isEven(nånVariabel ) && nånVariabel > 10 ) { <utförs endast om nånVariabel är ett jämt tal som är större än 10 > }
Om man har många ”&&” och/eller ”||” i rad, kan det bli lite svårläst. Det kan även vara svårt att avgöra i vilken prioritetsordning uttrycken ska utföras. Det kan man oftast lösa genom att gruppera uttrycken inom parenteser (precis som i vanlig matematik när man vill styra vilka beräkningsdelar som ska ske före andra). T.ex.;
if ( isEven( a ) && a > 10 ) || ( !isEven( a ) && ( a < 9 && a > 2 ) ) { <utförs när nåt av följande uppfylls;
”a är ett jämt tal som är större än 10” eller ”a är ett udda tal som är större än 2 och mindre än 9” >
}