Päätöksenteko

Tietokoneen supertaidot: päätöksenteko

Olemme oppineet tulostamaan ja lukemaan syötettä käyttäjältä. Olemme lisäksi oppineet käyttämään muuttujia sekä hyödyntämään muuttujia laskennassa. Osaat jo tehdä ohjelman, joka esimerkiksi kysyy käyttäjältä kahta lukua ja laskee niiden summan. Tällaisen ohjelman voi toteuttaa esimerkiksi seuraavalla tavalla.

Mikäli ohjelmaan syöttää luvut 40 ja 2, on tulostus seuraava.

Syötä ensimmäinen luku.
40
Syötä toinen luku.
2
Lukujen 40 ja 2 summa on 42.

Ohjelmoinnissa esiintyvien ongelmien ratkaisut ovat harvoin täysin lineaarisia. Esimerkiksi perintöveroa laskettaessa veroprosenttiin vaikuttaa perittävä määrä sekä perijän ja perittävän suhde. Verkossa olevaan lomakkeeseen kirjoitettu sähköpostiosoite hyväksytään tyypillisesti vain mikäli osoitteessa on sähköpostiin kuuluvat tyypilliset osat kuten @-merkki. Niinkin luonnolliseen asiaan kuin verkossa tai kaupassa maksamiseen kuuluu myös vaihtoehtoista toimintaa -- entä jos tilillä ei olekaan maksuun tarvittavaa määrää rahaa?

Tutustutaan seuraavaksi vaihtoehtoisen toiminnan toteuttamiseen.

Vaihtoehtoinen toiminta ja ehtolause

Ehtolause (conditional statement) mahdollistaa vaihtoehtoisen toiminnallisuuden toteuttamisen ohjelmaan. Ehtolauseen avulla luodaan toiminnallisuutta, joka suoritetaan vain mikäli ehtolauseen "ehdon" vertailussa käytettävä lauseke evaluoituu todeksi. Tällainen ehto voi olla vaikkapa kahden luvun yhtäsuuruuden tarkastelu tai jossain merkkijonossa olevan tietyn merkin olemassaolon tarkastelu.

Ehtolause mahdollistaa vaihtoehtoisen ohjelman suorituspolun. Kun ohjelman suoritus saapuu ehtolauseeseen, suoritus haarautuu ehtolauseen yhteydessä olevan ehdon perusteella. Mikäli ehto evaluoituu todeksi, suoritetaan ehtolauseeseen määritelty koodi, jonka jälkeen ohjelman suoritus jatkuu ehtolausetta seuraavasta koodista. Muulloin, eli mikäli ehto evaluoituu epätodeksi, suoritus siirtyy suoraan ehtolausetta seuraavaan koodiin.

Alla on kuvattuna ehtolausetta käyttävä ohjelma. Ohjelmassa tarkastellaan kahden luvun yhtäsuuruutta. Mikäli luvut ovat samat, ohjelma tulostaa viestin Luvut olivat samat!. Lopuksi ohjelma tulostaa viestin Loppu!.

Luku 0 ei ole sama kuin luku 10, joten ohjelma ei tulosta viestiä Luvut olivat samat!. Ohjelman tulostus on seuraava.

Loppu!

Muuta yllä olevaa ohjelmaa siten, että muuttujien eka ja toka luvut ovat samat. Huomaat tällöin, että ohjelman tulostus muuttuu seuraavanlaiseksi.

Luvut olivat samat!
Loppu!

Muutama sana lähdekoodin muotoilusta

Lähdekoodin muotoilulla ja muotoiluun kuuluvalla sisennyksellä voi vaikuttaa merkittävästi lähdekoodin luettavuuteen. Alla olevat kaksi ohjelmaa tekevät täysin saman asian. Kumpaa on mielestäsi helpompi lukea?

main()

{
  var eka = 42;
    var toka = 42; if (eka == toka) {
print('Luvut olivat samat!');}
print('Loppu!');}

main() {
  var eka = 42;
  var toka = 42;

  if (eka == toka) {
    print('Luvut olivat samat!');
  }

  print('Loppu!');
}

Meidän mielestämme jälkimmäinen on ymmärrettävämpi. Tässä on muutamia ohjeita, joita materiaalissa käytetään:

• Kullakin rivillä on korkeintaan yksi lause.
• Samaan asiaan liittyvät lauseet voidaan peräkkäisille riveille, mutta eri asioita tekevät lauseet erotetaan ylimääräisellä rivinvaihdolla. Esimerkiksi yllä muuttujien esittelyn jälkeen on ylimääräinen rivinvaihto ennen ehtolausetta.
• Lohkossa oleva lähdekoodi sisennetään kahdella välilyönnillä. Mikäli lohkon sisällä on toinen lohko kuten yllä, sisennys riippuu suoraan lohkojen määrästä -- kukin lohko lisää sisennystä kahdella merkillä.

Harjoittele näiden ohjeiden noudattamista.

Totuusarvo ja ehtolauseen evaluaatio

Ehtolauseen lauseke (eli ehtolauseen suluissa oleva vertailu) evaluoidaan ohjelman suorituksen aikana, ja evaluaation tuloksena on aina joko totta (true) tai epätotta (false). Ohjelmointikielissä on totuusarvon esittämiseen tarkoitettu muuttujatyyppi. Tarkastellaan sen toimintaa seuraavaksi. Totuusarvomuuttuja esitellään samalla tavalla kuin mikä tahansa muu muuttuja. Se voi saada arvokseeni joko arvon totta (eli true) tai epätotta (eli false). Alla olevassa esimerkissä luodaan kaksi totuusarvomuuttujaa, joiden arvot tulostetaan.

main() {
  var totta = true;
  var epatotta = false;

  print('$totta ei ole $epatotta');
}

true ei ole false

Ehtolauseen lauseke saa arvonaan lopulta (eli evaluaation jälkeen) totuusarvon, joka on joko totta tai epätotta. Alla olevassa esimerkissä luodaan totuusarvon sisältävä muuttuja totta, joka asetetaan ehtolauseen lausekkeeseen. Kun ohjelma käsittelee ehtolauseen, se vaihtaa muuttujan totta paikalle muuttujan totta arvon (eli tässä true). Koska lausekkeen arvo on totta, ehtolauseen lohkossa oleva lähdekoodi suoritetaan.

main() {
  var totta = true;

  if (totta) {
    print('Tottahan se oli.');
  }
}

Tottahan se oli.

Mikäli ehtolauseen lausekkeessa käytettävän totuusarvomuuttujan arvo on epätotta, ohjelman suoritus ei mene ehtolauseen lohkoon. Tämä nähdään alla olevasta ohjelmasta.

main() {
  var totta = false;

  if (totta) {
    print('Tottahan se oli.');
  }

  print('Ehtolauseen lohkossa olevaa koodia ei suoritettu?');
}

Ehtolauseen lohkossa olevaa koodia ei suoritettu?

Totuusarvomuuttujan arvo voidaan asettaa myös evaluaation kautta. Alla olevassa esimerkissä totuusarvomuuttujan totta arvoksi asetetaan lausekkeen 10 == 10 evaluaation tulos. Koska 10 on 10, evaluoituu lauseke todeksi (true), jolloin muuttujan totta arvoksi tulee true. Kun ohjelman suoritus siirtyy ehtolauseeseen, ehtolauseen lausekkeeseen asetetun totta-muuttujan paikalle vaihdetaan muuttujan arvo (eli totta). Koska lauseke on totta, ohjelma siirtyy suorittamaan ehtolauseen lohkossa olevaa lähdekoodia.

main() {
  var totta = (10 == 10);

  if (totta) {
    print('10 on yhtäsuuri kuin 10');
  }
}

10 on yhtäsuuri kuin 10

Edellä olevassa esimerkissä totuusarvomuuttujan arvon asettamiseen liittyvässä lausekkeessa 10 == 10 oli lukuja. Luvut voidaan vaihtaa muuttujiksi ja ohjelman toiminta pysyy käytännössä samana. Alla olevassa esimerkissä lauseke on muutettu muotoon eka == toka, missä eka ja toka ovat muuttujia, joiden kummankin arvo on 10. Kun lauseke eka == toka evaluoidaan, ensin muuttujien nimien paikalle vaihdetaan niiden arvot. Tämä johtaa siihen, että lauseke on muodossa 10 == 10, joka lopulta evaluoituu todeksi true.

main() {
  var eka = 10;
  var toka = 10;
  var totta = (eka == toka);

  if (totta) {
    print('10 on yhtäsuuri kuin 10');
  }
}

10 on yhtäsuuri kuin 10

Huomaamme, että totuusarvomuuttujaa ei oikeastaan tässä tarvitse. Voimme vaihtaa ehtolauseelle annettavan totuusarvomuuttujan edellisessä esimerkissä käytetyksi lausekkeeksi. Alla olevassa esimerkissä ehtolauseen lauseke evaluoidaan todeksi, sillä muuttujat eka ja toka sisältävät samat arvot.

main() {
  var eka = 10;
  var toka = 10;

  if (eka == toka) {
    print('10 on yhtäsuuri kuin 10');
  }
}

10 on yhtäsuuri kuin 10

Voit kokeilla yllä esiteltyjä esimerkkejä alla olevassa ohjelmointiympäristössä.

Ehtolauseen rakenne ja käsittely

Tarkastellaan ehtolausetta tarkemmin. Ehtolauseessa käytetään (1) if-avainsanaa ehtolauseen aloittamiseen, (2) if-avainsanaa seuraavaa sulkuja konkreettisen ehdon (lauseke) määrittelyyn, ja (3) lähdekoodia, joka suoritetaan mikäli ehtolauseessa olevan vertailun lopputulos on totta (eli lauseke evaluoituu todeksi). Suoritettava koodi asetetaan ehtolauseen sulkujen jälkeen tulevaan lohkoon eli aaltosuluilla rajattuun alueeseen.

Tarkastellaan edellistä esimerkkiä hieman tarkemmin.

main() {
  var eka = 42;
  var toka = 42;

  if (eka == toka) {
    print('Luvut olivat samat!');
  }

  print('Loppu!');
}

Ehtolauseen lauseke eka == toka evaluoidaan samalla tavalla kuin muut lausekkeet. Ensin muuttujien paikalle vaihdetaan muuttujien arvot. Tämän jälkeen lauseke on muotoa 42 == 42. Kaksi yhtäsuuruusmerkkiä on vertailuoperaattori, jonka tulos on totta mikäli vasemmalla ja oikealla puolella olevat arvot ovat samat, muulloin epätotta. Tässä tapauksessa arvot ovat samat, joten arvoksi tulee true eli totta. Kun ehtolauseen lauseke on evaluoitu, ohjelman suoritus siirtyy ehtolauseen yhteyteen määriteltyyn lohkoon mikäli evaluaation tulos on totta, muulloin siirrytään ehtolausetta seuraavaan lauseeseen.

Alla olevassa esimerkissä luvun lukeminen käyttäjältä on yhdistetty ehtolauseen käyttöön. Ohjelma kysyy ensin käyttäjältä lukua. Tämän jälkeen ohjelma vertailee käyttäjän syöttämää lukua lukuun 0. Mikäli käyttäjän syöttämä luku on 0, ohjelma tulostaa viestin Kiitos!. Ohjelman lopussa ohjelma tulostaa viestin Loppu!.

Kun ohjelmassa on kysytty käyttäjältä lukua, seuraava suoritettava lause on ehtolause. Mikäli käyttäjä syöttää luvun 0, ehtolauseen lauseke luku == 0 muuntuu muotoon 0 == 0. Tämä evaluoituu todeksi, jolloin ohjelman suoritus siirtyy ehtolauseen lohkoon. Ehtolauseen lohkossa on viestin Kiitos! tulostava tulostuslause. Kun ehtolauseen lohkossa olevat lauseet on suoritettu, ohjelman suoritus siirtyy ehtolausetta lohkon jälkeiseen lauseeseen. Tässä lause on viestin Loppu! tulostava tulostuslause. Lopulta ohjelman suoritus päättyy.

Syötä luku.
0
Kiitos!
Loppu!

Mikäli käyttäjä syöttää luvun 1, ehtolauseen lauseke luku == 0 muuntuu muotoon 1 == 0. Tämä evaluoituu epätodeksi, jolloin ohjelman suoritus siirtyy suoraan ehtolausetta seuraavaan lauseeseen ja ehtolauseen yhteyteen määritellyssä lohkossa olevia lauseita ei suoriteta.

Syötä luku.
1
Loppu!

Erilaiset vertailuoperaatiot

Edeltävissä ehtolauseen käyttöön johdattelevissa esimerkeissä ja tehtävissä vertailtiin lukujen yhtäsuuruutta. Ehtolauseilla voidaan tehdä myös muunlaisia vertailuja. Vertailut määritellään vertailuoperaattoreiden (relational operators) avulla.

Vertailuoperaattoreita on useita, ja niiden avulla voidaan yhtäsuuruuden lisäksi vertailla esimerkiksi järjestystä. Alla olevassa taulukossa on listattuna oleellisimmat vertailuoperaattorit.

Hyödyntämällä pienempi tai yhtäsuuri kuin -vertailuoperaattoria <= voimme tehdä esimerkiksi ohjelman, joka tarkastaa että käyttäjän syöttämä luku on pienempi tai yhtä suuri kuin jokin raja, esimerkiksi 1000. Alla oleva ohjelma tulostaa viestin Kiitos! mikäli käyttäjä syöttää luvun, joka on pienempi tai yhtäsuuri kuin 1000.

Vastaavasti, ohjelman, joka tulostaa Kiitos! mikäli käyttäjä syöttää luvun, joka on suurempi kuin 10 voi toteuttaa seuraavasti.

Merkkijonot ja vertailuoperaattorit

Merkkijonojen vertailussa vertailuoperaattoreista toimii vain yhtäsuuruuden ja erisuuruuden vertailu. Esimerkiksi pienempi kuin -vertailuoperaatio ei merkkijonojen yhteydessä toimi.

Alla olevassa esimerkissä on ohjelma, missä käyttäjää pyydetään kirjoittamaan salasana. Mikäli käyttäjä kirjoittaa merkkijonon salasana, ohjelma kehuu käyttäjää hyvästä työstä.

Alla on muutama mahdollinen tulostusesimerkki yllä olevasta ohjelmasta.

Kirjoita salasana.
salasana
Hyvin meni!
Loppu!

Kirjoita salasana.
enpäs!
Loppu!

Huomaa, että merkkijonot ja luvut käsitellään erityyppisinä muuttujina. Alla olevassa esimerkissä käyttäjältä luetaan luku, jota verrataan merkkijonoon. Vaikka käyttäjä syöttää luvun 10, ohjelma ei tulosta viestiä Täysi kymppi!.

import 'dart:io';

main() {
  print('Kirjoita luku.');
  var luku = int.parse(stdin.readLineSync()!);

  if (luku == '10') {
    print('Täysi kymppi!');
  }

  print('Loppu!');
}

Kirjoita luku.
10
Loppu!

Muuttujat ja lohkot

Tarkastellaan seuraavaksi miten muuttujat toimivat yhdessä lohkojen kanssa. Lohkoilla tarkoitetaan aaltosuluilla rajattua aluetta. Tähän mennessä olemme käyttäneet lohkoja sekä ohjelman aloituspisteen määrittelevän main()-funktion yhteydessä että vaihtoehtoisen toiminnan määrittelyyn käytetyn ehtolauseen yhteydessä.

Alla olevassa esimerkissä on kaksi lohkoa: (1) main()-funktion määrittelyä seuraava lohko sekä tämän sisällä oleva (2) ehtolauseeseen kuuluva lohko.

import 'dart:io';

main() {
  print('Tulostus main()-funktion lohkossa.');

  var luku = 0;

  if (luku == 0) {
    print('Tulostus ehtolauseen lohkossa.');
    print('MUTTA! Myös main()-funktion lohkossa.');
  }
}

Muuttujien ja lohkojen yhteistoimintaan liittyy yksi sääntö: muuttuja on olemassa vain lohkossa, jossa muuttuja on määritelty, sekä sen lohkon sisällä olevissa lohkoissa. Toisin sanoen, muuttuja ei ole olemassa sen lohkon ulkopuolella, jossa muuttuja on määritelty. Käytännössä tämä näkyy siten, että seuraavan ohjelman suorittaminen epäonnistuu, sillä ehtolauseessa määriteltyä muuttujaa ika ei ole olemassa ehtolauseen jälkeen.

main() {
  print('Tulostus main()-funktion lohkossa.');

  var luku = 0;

  if (luku == 0) {
    print('Tulostus ehtolauseen lohkossa.');
    print('MUTTA! Myös main()-funktion lohkossa.');

    var ika = 42;
  }

  print('Ikä on $ika.');
}

Kun yritämme suorittaa yllä olevaa ohjelmaa ohjelmointiympäristössä, näemme virheen Undefined name 'ika' - line 13. Virhe tarkoittaa että muuttujaa ika ei ole määritelty (ja muuttujaa yritetään käyttää rivillä 13).

Mikäli haluamme käyttää muuttujaa ehtolauseen ulkopuolella, tulee se myös määritellä ehtolauseen ulkopuolella ennen sen käyttöä. Ylläolevan ohjelman tapauksessa muuttujan ika voi määritellä esimerkiksi heti muuttujan luku määrittelyn jälkeen. Muuttujaan ika asetetaan arvo 42 vain mikäli muuttujan luku arvo on 0. Huomaa alla, että ehtolauseessa olevan muuttujan ika edellä ei ole avainsanaa var -- tämä johtuu siitä, että muuttuja on esitelty jo aiemmin.

main() {
  print('Tulostus main()-funktion lohkossa.');

  var luku = 0;
  var ika = 0;

  if (luku == 0) {
    print('Tulostus ehtolauseen lohkossa.');
    print('MUTTA! Myös main()-funktion lohkossa.');

    ika = 42;
  }

  print('Ikä on $ika.');
}

Nyt ohjelma toimii. Ohjelman tulostus on seuraavanlainen.

Tulostus main()-funktion lohkossa.
Tulostus ehtolauseen lohkossa.
MUTTA! Myös main()-funktion lohkossa.
Ikä on 42.

Edeltävä esimerkki kuvaa käytännössä miten muuttujan arvoa voi muuttaa tilanteessa, missä jokin vertailu on totta. Tarkastellaan tätä vielä toisen esimerkin kautta. Luodaan ohjelma, joka kysyy käyttäjältä laskujen lopputuloksia. Ohjelma pitää kirjaa myös oikein menneistä vastauksista.

Tervetuloa laskuvisaan!
Paljonko on 427?
294
Paljonko on 3-(-1)?
2
Paljonko on 2+124?
56
Kiitos vastauksista!
Oikein meni 1 / 3

Ehtolause ja muulloin (else)

Edelliset esimerkit ovat rajautuneet toiminnallisuuteen, joka suoritetaan kun ehtolauseen lauseke evaluoituu todeksi. Joskus ohjelmiin halutaan toiminnallisuutta, joka suoritetaan silloin, kun ehtolauseen lauseke ei ole totta. Tähän käytetään ehtolauseen if yhteydessä käytettävää else-komentoa.

Ehtolauseen suorituspolku määräytyy ehtolauseen ehdon lausekkeen evaluaatiosta. Mikäli lauseke on totta, päädytään if-haaran lähdekoodiin. Mikäli lauseke on epätotta, päädytään else-haaran lähdekoodiin (mikäli sellainen on määritelty). Haarautumisen jälkeen ohjelman suoritus palaa ehtolausetta seuraavaan lähdekoodiin.

Alla olevassa esimerkissä käyttäjää pyydetään kirjoittamaan luku 0. Jos käyttäjä kirjoittaa luvun 0, käyttäjälle tulostetaan viesti Kiitos!. Muulloin käyttäjälle kirjoitetaan viesti Lueppa ohjeet!.

Syötä luku 0.
1
Lueppa ohjeet!
Loppu!

Syötä luku 0.
0
Kiitos!
Loppu!

Komento else tulee komentoon if liittyvän aaltosuluilla rajatun lohkon jälkeen. Komennolle else määritellään oma lohko, jossa oleva lähdekoodi suoritetaan mikäli else-komentoa edeltävän if-lauseen lauseke evaluoituu epätodeksi. Toisin kuin if-komennolle, else-komennolle ei siis kuulu lauseketta, vaan siihen liittyvä lohko suoritetaan mikäli edeltävä if-komennon lauseke on epätotta.

Tarkastellaan tätä vielä aiemmin toteuttamamme laskuvisan kannalta. Aiemmassa laskuvisan versiossa käyttäjä ei saanut palautetta vastauksen yhteydessä. Lisätään palautteen antaminen kunkin vastauksen yhteyteen -- mikäli käyttäjä vastaa kysymykseen oikein, käyttäjälle tulostetaan viesti Oikein meni!, muulloin käyttäjälle tulostetaan viesti Väärin meni!.

Tervetuloa laskuvisaan!
Paljonko on 427?
294
Oikein meni!
Paljonko on 3-(-1)?
2
Väärin meni!
Paljonko on 2+124?
56
Väärin meni!
Kiitos vastauksista!
Oikein meni 1 / 3

Ehtolauseiden ketjuttaminen

Ehtolauseita voi halutessaan asettaa peräkkäin siten, että ohjelmaan muodostuu vertailuista koostuva ketju jos -- muulloin jos.

Yllä kuvattuna kahdesta vertailusta koostuva ehtolause. Tässä, mikäli ensimmäinen lauseke evaluoituu epätodeksi, päädytään ehtolauseen toiseen osaan. Vaikka yllä olevassa esimerkissä kuvataan vain kaksi vertailua, voi ehtolauseita kuitenkin ketjuttaa käytännössä rajattoman määrän.

Tarkastellaan tätä konkreettisen esimerkin avulla. Alla olevassa esimerkissä on ohjelma, joka tulostaa eri viestin luvuille -1, 0, ja 1.

Syötä luku 0.
1
Melkein onnistui!
Loppu!

Syötä luku.
-1
Huti!
Loppu!

Syötä luku.
2
Loppu!

Useista vertailuista koostuva ketju toteutetaan lisäämällä if-komentoa seuraavan aaltosuluilla rajatun lohkon jälkeen tulevalle else-komennolle if-komento, jolle määritellään sulkuihin ehto. Tätä seuraa aaltosuluilla rajattu lohko, joka sisältää ohjelmakoodin, joka suoritetaan mikäli else-komentoa seuraavan if-komentoon liittyvä ehto on totta. Kuten edellä olevasta esimerkistä huomataan, näitä else if-komentoja voi olla useita.

Useista vertailusta koostuvaan ketjuun voi asettaa loppuun else-komennon, jonka avulla määritellään ohjelmakoodi, joka suoritetaan mikäli yksikään vertailuista ei ole totta.

Syötä luku 0.
2
Kokeilepa uudestaan!
Loppu!

Kun ehtolauseita ketjutetaan, ketjussa olevista ehtolauseiden lohkoista suoritetaan vain ensimmäinen, johon liittyvä vertailu on totta. Mikäli käyttäjä syöttää alla olevassa esimerkissä luvun 3, ei ohjelman suoritus käy koskaan else if tai else-komennoissa.

Syötä luku.
42
Luku 42!
Loppu!

Voimme havaita vastaavan tilanteen myös seuraavassa esimerkissä.

Syötä luku.
1
Positiivinen luku!
Loppu!

Syötä luku.
10000
Positiivinen luku!
Loppu!

Loogiset operaatiot

Vertailuoperaatioita voi halutessaan yhdistää loogisten operaatioiden (logical operators) eli ja, tai, ja ei-käskyjen avulla. Yhdistämällä vertailuoperaatioita loogisten operaatioiden avulla voidaan kirjoittaa esimerkiksi lauseke, joissa verrataan onko jokin annettu luku pienempi kuin jokin toinen luku ja suurempi kuin jokin toinen luku. Alla olevassa esimerkissä tarkastellaan onko käyttäjän syöttämä luku välillä [0, 10], eli suurempi tai yhtäsuuri kuin 0 ja pienempi tai yhtäsuuri kuin 10.

Syötä luku.
3
Syötetty luku oli välillä [0, 10]!
Loppu!

Syötä luku.
11
Loppu!

Loogisia operaatioita on kolme: (1) ja, (2) tai, ja (3) ei.

Ja-operaatiota && käytetään kahden tai useamman vertailun yhdistämiseen siten, että ehtolause on totta jos ja vain jos kaikki yhdistetyt vertailut ovat totta. Alla olevassa esimerkissä tarkastellaan, että luku on välillä [-100, 100] ja että luku ei ole 0.

if (luku >= -100 && luku <= 100 && luku != 0) {
  print('Luku on välillä [-100, 100] ja luku ei ole 0.');
}

Tai-operaatiota || käytetään kahden tai useamman vertailun yhdistämiseen siten, että ehtolause on totta mikäli yksikin yhdistetyistä vertailuista on totta. Alla olevassa esimerkissä tarkastellaan, että luku on yksi, kymmenen, tai sata.

if (luku == 1 || luku == 10 || luku == 100) {
  print('Luku on 1, 10 tai 100.');
}

Ei-operaatiota ! käytetään vertailujen tuloksen kääntämiseen siten, että tosi muuttuu epätodeksi ja toisaalta epätosi muuttuu todeksi. Ei-operaatiota käytettäessä käännettävä yhdistelmä asetetaan sulkujen sisään, jonka eteen asetetaan !-merkki.

if (!(luku == 1 || luku == 10 || luku == 100)) {
  print('Luku ei ole 1, 10 tai 100.');
}

Alla on yhteenveto loogisista operaatioista.

Samassa lausekkeessa voi käyttää myös eri loogisia operaatioita. Alla olevassa esimerkissä tarkastellaan onko luku 0 tai luku välillä [10, 100].

if (luku == 0 || (luku >= 10 && luku <= 100)) {
    print('Luku on 0 tai luku on välillä [10, 100].');
}

Loogisista operaattoreista koostuvan lausekkeen (esim. luku == 0 || luku == 1 || luku == 2) evaluointi tapahtuu oletuksena vasemmalta oikealle mikäli operaattorit ovat samoja. Eri operaattoreista koostuvan lausekkeen evaluointi tapahtuu operaattoreihin liittyvässä tärkeysjärjestyksessä -- ja-operaatiot suoritetaan ennen tai-operaatioita. Näiden järjestys kuvataan tarkemmin Dart-kielen dokumentaatiossa. Yksinkertainen nyrkkisääntö suoritusjärjestykseen vaikuttamiseen on sulkujen käyttäminen. Sulkujen sisällä olevat operaattorit evaluoidaan ennen sulkujen ulkopuolella olevaa koodia. Näin on tehty myös yllä. Yllä olevassa esimerkissä vertailu luku >= 10 && luku <= 100 tehdään ensin, jonka jälkeen vertailun tulos tuodaan osaksi vertailua luku == 0 || tulos.

Tarkastellaan lausekkeen luku == 0 || (luku >= 10 && luku <= 100) evaluaatiota vielä konkreettisen esimerkin avulla. Oletetaan, että käyttäjä syöttää luvun 11, joka asetetaan muuttujaan luku. Evaluaatio tapahtuu seuraavia askeleita noudattaen.

• Kun muuttujassa luku on arvo 11, lauseke muuntuu muotoon 11 == 0 || (11 >= 10 && 11 <= 100)
• Tarkastellaan ensin suluissa olevaa lausekkeen osaa 11 >= 10 && 11 <= 100.
  • Osa 11 >= 10 evaluoituu todeksi, sillä 11 on suurempi tai yhtäsuuri kuin 10. Nyt suluissa oleva lauseke on true && 11 <= 100.
  • Osa 11 <= 100 evaluoituu myös todeksi, sillä 11 on pienempi tai yhtäsuuri kuin sata.
  • Nyt suluissa oleva lauseke on true && true, joka evaluoituu todeksi, sillä kummatkin puolet ovat totta. Lopputulos on true.
• Evaluoitavana on vielä 11 == 0 || true.
• Yksitoista ei ole nolla, joten lauseke 11 == 0 evaluoituu epätodeksi false.
• Jäljelle jäävä lauseke false || true evaluoituu todeksi, sillä looginen operaatio tai on totta mikäli kumpi tahansa (tai kummatkin) lausekkeen puolista ovat totta.

Tee oma kokeilusi yllä olevalla esimerkillä, ja kokeile miten sulkujen poisjättäminen vaikuttaa ohjelman suoritukseen.

Sisäkkäiset ehtolauseet

Ehtolauseen lohkoon voi kirjoittaa mitä tahansa lähdekoodia, myös toisen ehtolauseen. Alla olevassa esimerkissä on kuvattuna loogisilla operaatioilla toteutettu ehtolause, missä tarkastellaan, onko muuttujan luku arvo välillä [0, 10].

if (luku >= 0 && luku <= 10) {
  print('Syötetty luku oli välillä [0, 10]!');
}

Saman voi toteuttaa myös sisäkkäisillä ehtolauseilla seuraavalla tavalla. Alla olevassa esimerkissä ulomman ehtolauseen lohkossa oleva koodi suoritetaan mikäli lauseke luku >= 0 evaluoituu todeksi. Tätä seuraa lohkossa olevan koodin suoritus. Sisemmän ehtolauseen lohko suoritetaan mikäli lauseke luku <= 10 evaluoituu todeksi -- yhdessä nämä kaksi lauseketta tekevät saman kuin edellä nähty loogisilla operaatioilla yhdistetty lauseke luku >= 0 && luku <= 10.

if (luku >= 0) {
  if (luku <= 10) {
    print('Syötetty luku oli välillä [0, 10]!');
  }
}

Ehtolauseen lohkossa on toinen ehtolause. Mikäli ulomman ehtolauseen lauseke evaluoituu todeksi, ohjelman suoritus siirtyy ehtolauseen lohkoon, mikä sisältää toisen ehtolauseen. Mikäli ehtolause taas evaluoituu epätodeksi, siirrytään ehtolausetta seuraavaan lähdekoodiin.

Sisäkkäisiä ehtolauseita voi käyttää useampaan osaan haarautuvan logiikan toteuttamiseen. Esimerkiksi osaan linnanmäen laitteista pääsee vain mikäli käyttäjä on vähintään 120 senttiä pitkä ja vähintään 7 vuotta vanha. Ohjelman, joka kysyy ikää vain mikäli käyttäjä on tarpeeksi pitkä voi toteuttaa sisäkkäisten ehtolauseiden avulla seuraavalla tavalla.

Kuinka pitkä olet?
117
Pituusraja on 120 senttiä.

Kuinka pitkä olet?
142
Kuinka vanha olet?
10
Tervetuloa laitteeseen!