Lexikalisk struktur ⚠️

JavaScript gör skillnad på små och stora bokstäver, nyckelordet while måste skrivas exakt så och inte WHILE. Variablerna avar och aVar är två skilda variabler.

JS bryr sig inte om blanka tecken som mellanslag och tabb. Du kan använda dem som du vill för att formatera ditt program. När du kör ett program “live” kan du ta bort alla tomma tecken, det är så som “minifiering” fungerar när det förminskar ett JavaScript för att snabba upp laddningshastighet av en sida, allt för att ge användaren en bättre upplevelse.

Kommentarer är samma som i PHP och C++. // för en-rads kommentarer och /* */ för kommentarer som spänner över flera rader. Det finns också stöd för DocBlock kommentarer /** */ och då i samverkan med externa verktyg för automatgenererande dokumentation.

Literaler

När du skriver in ett värde i JavaScript är det en “literal” som kan tolkas som ett värde och en typ.

Följande visar hur literaler kan tolkas.

42 // Talet 42
4.2 // Talet 4.2
("hello world") // En sträng med text
("hej") // En sträng till
true // Ett boolskt värde
false // Ett annat boolskt värde
null // Ett null värde
undefined // Ett odefinierat värde
/javascript/ // Ett reguljärt uttryck
{ x: 1, y: 2 }[(1, 2, "three")] // Ett objekt med två properties // En array med tre värden

Pröva att skriva in någon av literalerna för att se hur JavaScript tolkar dem.

Identifierare

En identifierare är en sträng som används för att namnge en variabel eller funktion. Reglerna för identifierare liknar andra programmeringsspråk.

En identifierare börjar med en bokstav a-z, A-Z, understreck _ eller dollartecken $ och följs därefter av bokstav a-z, A-Z, understreck _, dollartecken $ eller siffror 0-9.

Följande är giltiga identifierare:

myVar
moped
$
_
M64
i

Pröva att skriva in en identifierare och tilldela den ett värde av en literal.

let myValue = "fortytwo"

myValue

Reserverade ord

Det finns ett antal reserverade ord i JavaScript, dessa kan vara bra att ha lite koll på, kika på dem innan du går vidare. Du kan inte använda reserverade ord som namn på variabler.

Vilka ord som är reserverade kan skifta mellan olika versioner av JavaScript, du gör bäst i att undvika dem, oavsett vilken version du använder.

Nu ser vi hur JavaScript upplever typerna för de olika literalerna. De två sifforna är number och flera av literalerna upplevdes som object.

Låt oss fortsätta studera grunderna så att vi får bättre grepp om typerna som JavaScript erbjuder.

Värden och Datatyper

Primitiva värden

JavaScript har ett antal primitiva värden.

Boolska variabler som true och false.
Numeriska värden som 42 och 4.2.
Strängar som "mumin" och 'mumin'.
Icke-värden i form av null och undefined.

De är primitiver, enkla värden.

Objekt

De literaler som representerar ett icke-primitivt värde representeras som ett objekt.

Alla nedan har samma värde för typeof(), alla är "object".

[] array literal.
{} objekt literal.
/./ ett reguljärt uttryck.

En funktion har också en upplevd typ i form av "function".

> typeof(function(){})
'function'

I samtliga fall så är dessa icke-primitiva värden en instans av Object, det ursprungliga objektet i en hierarki av JavaScript objekt.

[] instanceof Object
[] instanceof Array
true

/./ instanceof Object
/./ instanceof RegExp
true

> a = {}
{}
> a instanceof Object
true

> a = function(){}
[Function]
> a instanceof Object
true
> a instanceof Function
true

Det finns alltså en objekthierarki dit ett värde hör, baserat på dess typ.

Objektbaserade datatyper

I JavaScript finns ett antal objektbaserade datatyper. Följande lista ger en översikt. Dessa inbyggda objekt innehåller inbyggda funktioner som kan användas för att jobba med värden av respektive typ.

Namn	Syfte
`Number`	Siffror, tal, nummer
`String`	Strängar och tecken
`Boolean`	Boolska värden, `sant` eller `falskt`
`Object`	Moderobjektet, samt en osorterad lista av `key:value`
`Array`	En sorterad lista av numrerade värde
`Function`	Funktioner som exekverbar kod
`RegExp`	Reguljära uttryck

Varje datatyp är representerad som ett objekt med medlemsvariabler och metoder. Dessa används när man jobbar med värden som är av en viss typ. Objektets medlemmar och metoder avgör vad man kan göra med ett värde som är av en viss typ.

Till exempel kan du ta reda på längden av en sträng på följande sätt.

> "Mumintrollet".length
12
> "Mumintrollet".charAt(1)
'u'

Det som sker är att strängliteralen omvandlas automatiskt till ett String-object och dess property length avläses och metoden String.charAt() anropas.

På det viset kan man säga att även primitiverna har en koppling till ett objekt som i sin tur bestämmer vad man kan göra med värdet.

En strängliteral blir alltså till ett String-objekt vilket är kopplat till objektet Object. De metoder och properties som finns i Object och i String kan användas.

Se detta exempel som använder en metod som finns i Object.

> a = 42
42
> a.toString()
'42'

Detta är grunden i hur värden och datatyper byggs upp och vilka metoder som finns tillgängliga.

Fler objekttyper utan literaler

Låt oss titta på två andra objekttyper inte har en egen literal.

Namn	Syfte
`Date`	Datum och datumhantering
`Error`	Felhantering för syntax och fel under körning

Dessa objekt skapar man med operatorn new så här.

// Date
> a = new Date()
Mon Nov 07 2016 18:05:33 GMT+0100 (CET)
> a instanceof Object
true
> a instanceof Date
true
> typeof(a)
'object'

// Error
> e = new Error()
[Error]
> e instanceof Object
true
> e instanceof Error
true
> typeof(e)
'object'

Här skapar vi alltså en instans av objektet och får därmed tillgång till de metoder som objektet implementerar.

Sammanfattningsvis om typer och värden

Det är number, string, boolean som är primitiver och resten är specialiserade objekttyper. Typerna Number, String, Boolean, Function, Array, Date och RegExp är en variant, en specialisering, av typen Object.

Funktionen typeof() svarar med en upplevd typ i form av en sträng.

Uttrycket instanceof testar om ett objekt/värde/variabel är av en viss Objekt.

Samtliga objekttyper är något som kallas globala objekt, de innehåller metoder och properties som kan användas för att jobba med dem och de värden de representerar.

Till dessa tillkommer undefined och null.

Namn	Syfte
`undefined`	En variabel som inte givits ett värde har värdet undefined som är en egen typ.
`null`	Null är avsaknaden av ett värde, men ändå ett medvetet värde som blivit tilldelat till en variabel. Det är en egen typ.

En variabel som ännu inte blivit tilldelad ett värde sägs ha värdet undefined. En funktion som inte returnerar något sägs returnera undefined. Ett odefinierat värde, helt enkelt.

Man kan tilldela en variabel ett värde null som kan sägas innebära avsaknaden av värde. Vill man undvika undefined kan man explicit tilldela en variabel null. Internt representeras null av ett objekt, iallafall enligt funktionen typeof() och det kan kännas lite udda, men det är inget som bör störa oss.

Vi tar och kikar lite djupare in i var och en av dessa, samtidigt som vi gör lite övningar. Då fortsätter vi.

Variabler utan värde, `undefined`

En variabel som inte har tilldelats ett värde får automatiskt värdet undefined. Det är ett odefinerat värde.

let i

if (i === undefined) {
  // Yep, this is true for i
}

if (typeof i === "undefined") {
  // Yep, this is true for i
}

Ett icke-värde, `null`

Javascript skiljer på null som är ett icke-värde och undefined som är ett odefinierat värde. Man använder null för att ge en variabel värdet null, med mening. När värdet undefined dyker upp så innebär det oftast att man inte initierat en variabel med ett värde.

let i
let j = null

if (i === j) {
  // Nope, not the same type, they are not equal.
}

if (i == j) {
  // Yep, both evaluates to false so they are equal.
}

if (j === null) {
  // Yep, j is null for sure.
}