Att jobba med sanningsvärden
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:
| JavaScript-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.
Faktum är att man i JavaScript ofta använder sig av "===", dvs trippla likamed-tecken. Denna typ av jämförelse kollar både att innehållet är av samma typ och att innehållet är lika. Eftersom JavaScript försöker omvandla saker så de blir av samma datatyp, kan detta vara mycket användbart då man vill undvika att jämföra äpplen med päron. Här är ett exempel på skillnaden mellan de båda jämförelseoperatorerna.
| JavaScript-villkor | Resultat |
|---|---|
| "1" == 1 | True |
| "1" === 1 | False |
Skillnaden på de två jämförelserna i ovanstående exempel är att "1" är en sträng, det vill säga det tecknet som motsvarar en 1:a, snarare än det tal som har värdet ett. Med ==, kommer JavaScript att omvandla höger- och vänsterled till samma datatyp innan jämförelsen. Den översätter alltså tecknet till ett tal och jämför det med talet och då blir ju bägge sidor lika. Däremot kommer === inte att göra någon typomvandlig. Det gör att JavaScript direkt kan se att sakerna inte är lika. Strängen "1" tillhör inte samma datatyp som siffran 1 och därmed kan inte innehållet heller vara lika.
(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).
Jämförelseoperationer
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 och b inte lika?
|
a < b
|
Är a mindre än b?
|
a > b
|
Är a större än b?
|
a <= b
|
Är a mindre än eller lika med b?
|
a >= b
|
Är a strörre än eller lika med b?
|
I JavaScript 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 i matematiken, 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.
De variabler som innehåller sanningsvärden, dvs true eller false kallas för bool eller booleska. 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;
var 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;
function isEven ( 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 funktion, 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:
function isEven ( 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 JavaScript. 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” >
}