Visa källa för Att jobba med sanningsvärden

Man brukar tala om sanningsvärden när man jobbar med villkor. Ett sanningsvärde är antingen <code>true</code> eller <code>false</code>, 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:
{| class="wikitable"
! JavaScript-villkor
! Resultat
|-
| 1 == 1
|True
|-
| 1 == 2
|False
|-
| “alfa” == “alfa”
|  True
|-
| “alfa” == “beta”
| False
|}

== <code>==</code> ==
Lägg märke till att när man utför en jämförelse i JavaScript så använder man av ”<code>==</code>”, 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 <code>true</code> eller <code>false</code> utan att ändra något innehåll.

==<code>===</code>==
Faktum är att man i JavaScript ofta använder sig av "<code>===</code>", 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.
{| class="wikitable"
! JavaScript-villkor
! Resultat
|-
| "1" == 1
|True
|-
| "1" === 1
|False
|}
Skillnaden på de två jämförelserna i ovanstående exempel är att <code>"1"</code> ä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 <code>==</code>, 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 <code>===</code> ''inte'' att göra någon typomvandlig. Det gör att JavaScript direkt kan se att sakerna inte är lika. Strängen <code>"1"</code> 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 <code>if</code>-satser i exemplen. Men alla sanningsvärden skulle fungera lika bra (eller dåligt) i t.ex. <code>while</code>-loopar.)

==Enbart <code>true</code> eller <code>false</code>==
Om man vill kan man göra <code>if</code>-satser som alltid utförs:

<div class="well well-cyanide-light">
<syntaxhighlight lang="JavaScript">
if ( true )
{
  <utförs alltid>
}
</syntaxhighlight>
</div><!-- end well -->

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 <code>while</code>).

Ännu meningslösare, men likväl möjligt, är att göra en <code>if</code>-sats som aldrig körs (genom att använda sig av sanningsvärdet <code>false</code>.

== Jämförelseoperationer ==
I villkor använder man sig ofta av matematiska jämförelseoperatorer. Några vanliga villkor/jämförelseoperatorer:

{| class="wikitable"
! C#-villkor
! Typ av jämförelse
|-
| <code>a == b</code>
| Är <code>a</code> och <code>b</code> lika?
|-
| <code>a != b</code>
| Är <code>a</code> och <code>b</code> inte lika?
|-
| <code>a < b</code>
| Är <code>a</code> mindre än <code>b</code>?
|-
| <code>a > b</code>
| Är <code>a</code> större än <code>b</code>?
|-
| <code>a <= b</code>
| Är <code>a</code> mindre än eller lika med <code>b</code>?
|-
| <code>a >= b</code>
| Är <code>a</code> strörre än eller lika med <code>b</code>?
|}

I JavaScript betyder ”<code>!</code>” icke, eller ”not”, så man utläser alltså ”<code>!=</code>” som icke lika med.

== Kombinera sanningsvärden ==
Man kan sätta samman mer komplexa villkor med hjälp av; ”<code>&&</code>” som betyder ”och” samt ”<code>||</code>” 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; <code>&&</code> ===
När man använder sig av <code>&&</code> måste bägge villkoren vara uppfyllda för att hela och-villkoret ska bli sant.

<div class="well well-cyanide-light">
<syntaxhighlight lang="JavaScript">
if ( villkor1 && villkor2 )
{
  <utförs endast om både villkor1 och villkor2 är sanna>
}
</syntaxhighlight>
</div>

Det innebär att följande gäller för och-villkoret:

{| class="wikitable" 
! Villkor
! Resultat
|-
| <code>false && false</code>
| <code>false</code>
|-
|<code>true && false</code>
| <code>false</code>
|-
| <code>false && true</code>
| <code>false</code>
|-
| <code>true && true</code>
| <code>true</code>
|}

=== Eller-villkor; <code>||</code> ===
När man använder eller-varianten, <code>||</code>, 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).

<div class="well well-cyanide-light">
<syntaxhighlight lang="JavaScript">
if ( villkor1 || villkor2 )
{
  <utförs endast om något, eller båda, av villkor1 och villkor2 är sant>
}
</syntaxhighlight>
</div><!-- end well -->

Det innebär att följande gäller för eller-villkoret:

{| class="wikitable"
! Villkor
! Resultat
|-
| <code>false && false</code>
| <code>false</code>
|-
| <code>true && false</code>
| <code>true</code>
|-
| <code>false && true</code>
| <code>true</code>
|-
| <code>true && true</code>
| <code>true</code>
|}

=== Icke-villkor; <code>!</code> ===
Icke-operatorn förändrar ett sanningsvärde till dess motsats. Dvs, <code>true</code> blir <code>false</code> och vice versa.

{| class="wikitable"
! Villkor
! Resultat
|-
| <code>!false</code>
| <code>true</code>
|-
| <code>!true</code>
| <code>false</code>
|}

I vissa fall kan det vara snyggare och enklare att skriva ett uttryck på ett visst sätt och sedan lägga ett ”<code>!</code>” 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 <code>true</code> eller <code>false</code> och kan därför direkt användas som sanningsvärden/villkor i <code>if</code>-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 <code>true</code> eller <code>false</code> 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 <code>while</code>-satser.  Ett litet exempel;

<div class="well well-cyanide-light">
<syntaxhighlight lang="JavaScript">
var running = true;

while (running)
  <massa kod>

  if ( tangent == ”q”)
  {
    running = false;
  }
}
</syntaxhighlight>
</div>

Exemplet ovan kommer alltså att köras i en loop, ända tills användaren trycker på tangenten ”q”. Då blir <code>running</code> satt till <code>false</code> och <code>while</code>-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 <code>true</code> eller <code>false</code>. Till exempel om man vill kolla om ett tal är ett jämt tal, kan man skapa en liknande funktion;

<div class="well well-cyanide-light">
<syntaxhighlight lang="JavaScript">
function isEven ( tal )
{
  if( tal % 2 == 0 )
  {
    return true;
  } else {
    return false;
  }
}	
</syntaxhighlight>
</div>

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 <code>isEven</code>. 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:

<div class="well well-cyanide-light">
<syntaxhighlight lang="JavaScript">
function isEven ( tal )
{
  return tal % 2 == 0;
}	
</syntaxhighlight>
</div>

Nu när man definierat funktionen, finns den att tillgå och man kan använda sig av den i programmets <code>if</code>-satser;

<div class="well well-cyanide-light">
<syntaxhighlight lang="JavaScript">
if ( isEven( nånVariabel ) )
{
  <utförs endast om nånVariabel är ett jämt tal >
}
</syntaxhighlight>
</div>

Man skulle även kunna skriva ”<code>isEven( a ) == true</code>”, men det behövs inte eftersom ju funktionen alltid returnerar <code>true</code> eller <code>false</code>. 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;

<div class="well well-cyanide-light">
<syntaxhighlight lang="JavaScript">
if ( isEven( nånVariabel ) == false )
{
    <utförs endast om nånVariabel är ett udda tal>
}
</syntaxhighlight>
</div>

Ett annat, vanligare, sätt att kontrollera om något är falskt är;

<div class="well well-cyanide-light">
<syntaxhighlight lang="JavaScript">
if ( !isEven( nånVariabel ) )
{
  <utförs endast om nånVariabel är ett udda tal>
}
</syntaxhighlight>
</div>

Som du kanske minns så betyder ”<code>!</code>”-tecknet ”inte” i JavaScript. Användandet av ”not” kommer ifrån Boolesk algebra. ”<code>!</code>”-tecknet gör om det efterföljande uttrycket till dess motsats. Det betyder att <code>!true</code> blir <code>false</code> och <code>!false</code> blir <code>true</code>.

Självklart kan man använda ”<code>&&</code>” och ”<code>||</code>” tillsammans med funktioner som returnerar sanningsvärden. Till exempel:

<div class="well well-cyanide-light">
<syntaxhighlight lang="JavaScript">
if ( isEven(nånVariabel ) && nånVariabel > 10 )
{
	<utförs endast om nånVariabel är ett jämt tal som är större än 10 >
}
</syntaxhighlight>
</div>

Om man har många ”<code>&&</code>” och/eller ”<code>||</code>” 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.;

<div class="well well-cyanide-light">
<syntaxhighlight lang="JavaScript">
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” >
}
</syntaxhighlight>
</div>

== Nästa aktivitet ==
[[Loopar och slingor]]