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.

Exempel på sanningsvärden

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 när man utför en jämförelse i JavaScript så använder man 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.

JavaScript har några egenheter. Eftersom JavaScript automatiskt omvandlar datatyper så kan man jämföra på följande vis:

JavaScript-villkor	Resultat
1 == "1"	True

===

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 samt att innehållet är lika.

Vid vanlig jämförelse försöker JavaScript att omvandla variablernas innehåll så att de blir av samma datatyp. Vilket i många fall kan vara bra. Men det kan uppstå situationer där man jämför äpplen med päron och får resultat som är helt tokiga.

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.)

Enbart true eller false

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.

T.ex. använder man ofta bool-variabler i while-satser. Ett litet exempel;

let 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 snyggare och koncisare sätt att skriva ovanstående funktion skulle vara det här:

function isEven ( tal )
{
  return tal % 2 == 0;
}

Eftersom vi ska returnera ett sanningsvärde och bara gör en enda test, kan vi ju lika gärna returnera resultatvärdet ifrån testet. if:arna i första varianten tillförde ju inget mer än att de antingen returnerade true eller false. Vilket ju är de värden vi får ut direkt ifrån vårt test och vi kan därför optimera bort if:arna. Detta funkar inte i alla fall, men i vissa fall kan det ge en kortare och snyggare lösning.

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

Styra prioritetsordning med "()"

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

Nästa aktivitet

Loopar och slingor