05 - Föreläsning - Grundläggande programmering (1DV021)

class: center, middle, lnu-background-yellow

### Grundläggande programmering (1DV021)
        # Föreläsning 5

---

class: lnu-background-cc

### Upphovsrätt för detta verk

Detta verk är framtaget av Mats Loock i anslutning till kursen Grundläggande programmering (1DV021) vid Linnéuniversitetet.

Allt innehåll i detta verk förutom fotografier, ikoner, bild på kurslitteraturen samt Linnéuniversitetets logotyp och symbol,
        är licensierad under en <a rel="license" href="http://creativecommons.org/licenses/by/4.0/">
            <img alt="Creative Commons-licens" style="border-width:0;vertical-align:middle" src="https://i.creativecommons.org/l/by/4.0/80x15.png" />
            Creative Commons Erkännande 4.0 Internationell Licens
        </a>.
        #### Du får använda detta verk så här
        - kopiera hela eller delar av innehållet
        - sprida hela eller delar av innehållet
        - visa hela eller delar av innehållet offentligt och digitalt
        - konvertera innehållet till annat format
        - du får även göra om innehållet

Om du förändrar innehållet så ta inte med fotografier, ikoner, bild på kurslitteraturen samt Linnéuniversitetets logotyp och symbol i din nya version!

Vid all användning måste du ange källan: ”Linnéuniversitetet – Grundläggande programmering (1DV021)” och
        en länk till https://coursepress.lnu.se/kurs/grundlaggande-programmering och till Creative Common-licensen här ovan.

---

# Hur hantrera flera värden genom en variabel eller ett returvärde?
        ## Problem

- En variabel kan bara tilldelas ett värde.
            - Vilka alternativ finns det om "flera" värden ska kunna tilldelas en variabel?
        - En funktion kan bara returnera ett värde.
            - Vilka alternativ finns det om "flera" värden ska returneras?

## Lösning

Oavsett om det är "flera" värden som ska tilldelas en variabel eller om en funktion ska returnera "flera" värden är lösningen __EN__ referens till en __array__ eller ett __objekt__, där arrayen eller objektet kan __innehålla flera värden__.

---
    
        # Vad är ett objekt?

- Objekt är ett referensvärde, en instans av en referenstyp, som t.ex. `Object`.
        - Du kan samla namngivna värden i objekt. Namn/värde-paren kallas egenskaper.
        - Egenskaperna ett objekt har kan vara olika typer.
        - En, eller flera, referensvariabler kan referera till ett och samma objekt.

```
        let person = {
          firstName: 'Ellen',
          lastName: 'Nu',
          age: 7,
          eyeColor: 'yellow'
        }
        
        let anotherRef = person // båda variablerna refererar till samma objekt
        ```

---

# Så skapar du ett Object-objekt

- Objektliteral - rekommenderat sätt

```
         // Ett tomt objekt
        let person = {}

// Ett objekt med tre egenskaper
        let car = {
          make: 'Volvo',
          color: 'blue',
          year: 2010
        }
        ```

- Med nyckelordet new - ___inte rekommenderat!___

```
        // Ett tomt objekt
        let person = new Object()

// Ett objekt med tre egenskaper
        let car = new Object()
        car.make = 'Volvo'
        car.color = 'blue'
        car.year = 2010
        ```

---
        
        # Så kan du också skapa ett Object-objekt

- `Object.create(proto[, propertiesObject])` ger dig mer kontroll över ett objekts egenskaper.

```
        // Tomma objekt
        let person = {}

let anotherPerson = Object.create(Object.prototype)
        ```

```
        // Objekt med egenskaper
        let car = {
            make: 'Volvo',
            color: 'blue',
            year: 2010
        }

let anotherCar = Object.create(Object.prototype, {
          make: {
            value: 'Volvo',
            writable: true,
            enumerable: true,
            configurable: true
          },
          color: {
            value: 'blue',
            writable: true,
            enumerable: true,
            configurable: true
          },
          year: {
            value: 2010,
            writable: true,
            enumerable: true,
            configurable: true
          }
        })
        ```

---

# Två olika sätt att att komma åt egenskapers värden

- Punktnotationen är det föredragna sättet.
        - Hakparenteser används oftast tillsammans med en variabel innehållande egenskapens namn.

```
        let car = {
          make: 'Volvo',
          color: 'blue',
          year: 2010
        }

console.log(car.year) // OUTPUT:  2010

// Lägg till en ny egenskap till objektet.
        car.model = 'V70' // { make: 'Volvo', color: 'blue', year: 2010, model: 'V70' }

let property = 'model'
        console.log(car[property]) // OUTPUT:  'V70'
        ```

---

# Egenskaper i ett objekt

- Iterera genom ett objekts samtliga egenskaper (inklusive dess prototyper) med [`for...in`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...in).

```
        let car = {
          make: 'Volvo',
          color: 'blue',
          year: 2010
        }

for (let propertyName in car) {
          console.log(propertyName + ': ' + car[propertyName])
        }

// OUTPUT: make: Volvo
        // OUTPUT: color: blue
        // OUTPUT: year: 2010
        ```

---

# Nycklarna till värdena

- Iterera igenom ett objekts egna egenskaper med hjälp av egenskapen [`keys`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys), som är en array innehållande objektets egna egenskaper.

```
        let car = {
          make: 'Volvo',
          color: 'blue',
          year: 2010
        }

let keys = Object.keys(car) // [ 'make', 'color', 'year' ]

keys.forEach(function (key) {
          console.log(key + ': ' + car[key])
        })

// OUTPUT: make: Volvo
        // OUTPUT: color: blue
        // OUTPUT: year: 2010
        ```

---

# Om fel inträffar kasta ett undantag!

- Kastas ett undantag avbryts all exekvering av en aktuella funktionen ([`throw`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw)).
        - Exekveringen fortsätter i det först förekommande `catch`-blocket; saknas det avslutas programmet.

```
        const foo = function (arr) {

// Kasta ett undantag om arr inte refererar till en array.
          if (!Array.isArray(arr)) {
            throw new TypeError(`arr doesn't refer to an array.`)
          }

// Gör något med arrayen...
        }

foo('Jag är inte en array!')  // Anropet leder till att programmet avslutas!
        ```

---

# Hantera undantag

- Undantag kan fångas och hanteras ([`try...catch`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/try...catch)).

```
        let car = {
          make: 'Volvo',
          color: 'blue',
          year: 2010
        }

let bar = function (obj) {
          if (!obj.hasOwnProperty('make') ||
            !obj.hasOwnProperty('model')) {
            throw new Error('Objektet saknar relevanta egenskap(er).')
          }

// Gör något med objektets egenskaper make och model...
        }

try {
          bar(car)
        } catch (e) {
          console.error(e.message) // OUTPUT: Objektet saknar relevanta egenskap(er).
        }
        ```
        ---