{
  "assessmentTests": {
    "javascript_test": {
      "name": "JavaScript-test",
      "desc": "30 scenariobaserade frågor om grundläggande syntax och typkonvertering, funktioner/omfång/closures och detta, objekt/arrayer och datastrukturer, och event loop/async/prototypidiosom — ta reda på om ditt JavaScript matchar vad en arbetsgivare menar med JavaScript-kompetens.",
      "recommendation": "Din JavaScript-färdighetsprofil",
      "results": {
        "beginner": {
          "name": "Nybörjare",
          "desc": "Du kan skriva funktioner och objekt som fungerar, men frågorna du missade handlar om typkonvertering och referenssemantik snarare än syntax — == konverterar tyst typer före jämförelse, en arrayuppgift delar en referens istället för att kopiera, varför NaN aldrig är lika med sig själv. Detta handlar inte om att vara dålig på JavaScript; dessa är specifika regler som förvirrar folk som lärde sig språket genom att skriva kod som bara fungerade snarare än att förstå hur värden och referenser faktiskt beter sig. De spelar roll i arbetet eftersom var och en av dem är en plats där koden körs utan fel och ändå gör fel sak.",
          "recommendation": "Börja med tre saker, i denna ordning: varför == konverterar typer före jämförelse medan === inte gör det; varför att tilldela en array eller ett objekt till en ny variabel kopierar referensen, inte värdet; hur var lyfts och initialiseras till undefined medan let och const förblir i den döda zonen tills deras deklaration körs. MDN:s JavaScript-guide täcker alla tre med körbara exempel."
        },
        "intermediate": {
          "name": "Mellanliggande",
          "desc": "Du hanterar daglig programkod bekvämt — funktioner, arraymetoder, enkel kontrollflöde — och skulle inte bromsa ned av rutinmässig funktionsutveckling. Gapet mellan här och Avancerat är mestadels hur JavaScripts omfångs- och tidsinställningsregler interagerar: en var som fångats inuti en loops callbacks som alla läser samma slutliga värde, ett detta som tyst slutar peka på objektet när en metod lösgörs från det, en spread-kopia som ser djup ut men bara kopierar en nivå. Det här är den sortens buggar som passerar en snabb läsning och bara visas under ett specifikt runtime-tillstånd.",
          "recommendation": "Fokusera på hur omfång och detta faktiskt löses vid anropstid, inte definitionstid: varför en var-baserad for-loop skickar samma slutliga räkarvärde till varje callback medan let inte gör det; hur detta bestäms av hur en funktion anropas snarare än var den är skriven; varför en spread eller Object.assign bara kopierar den översta nivån av ett objekt. Sedan event loop, eftersom det förvirrar folk som redan förstår promises individuellt."
        },
        "advanced": {
          "name": "Avancerat",
          "desc": "Det här är nivån som de flesta jobbannonser menar med \"starkt JavaScript.\" Du läser en filter/map/reduce-kedja och kan förutsäga exakt vad den returnerar utan att mutera den ursprungliga arrayen, du vet varför en synkron console.log alltid slår en microtask som alltid slår en setTimeout, du griper Promise.all i vetskap om att den avvisas när någon promise avvisas snarare än att vänta på resten. Det som skiljer detta band från toppen är prototypen och objektmodellsidan av arbetet: hur prototypkedjan löser en ärvd metod kontra hasOwnProperty, vad ett klassens privata #fields faktiskt döljer.",
          "recommendation": "Tryck in i delen som skyddar tillståndet som annan kod också rör: hur JavaScripts prototypkedja löser metodsökningar som inte finns på själva instansen; vad ett klassens privata #fields faktiskt döljer från extern åtkomst; hur JSON.stringify behandlar undefined och funktioner olika inuti ett vanligt objekt kontra inuti en array. MDN:s material om event loop och prototypkedjan är det naturliga nästa steget för båda."
        },
        "expert": {
          "name": "Expert",
          "desc": "Du skårade högsta poäng i varje sektion — grundläggande syntax, typer och konvertering; funktioner, omfång, closures och detta; objekt, arrayer och datastrukturer; och async, event loop, prototyper och idiom. Praktiskt betyder det att du kan ta en främlings funktion och förklara varför den returnerar vad den gör, inte bara vad syntaxen säger att den borde göra — det är den svårare och mer värdefulla färdigheten. På denna nivå är språket själv sällan den begränsande faktorn; gränsen är vanligen async-kontrollflöde eller datans form under den.",
          "recommendation": "Avkastningen är nu i design och diagnos: resonera om ett race condition mellan Promise.all och Promise.race snarare än att citera deras definitioner; välja när en closure är rätt verktyg för privat tillstånd kontra när ett klassens privata fält är; läsa en microtask-vs-macrotask-ordningsbug i productionsloggar snarare än i ett quiz. Om du blir screening för en roll, beskriv en timingbug du hittade — en inaktuell closure-variabel eller ett felordnat async-callback — snarare än att namnge JavaScript-funktioner; det visar resonerandet, inte bara ordförrådet."
        }
      },
      "questions": [
        {
          "question": "console.log(x);\nvar x = 5;\nVad skrivs ut?",
          "options": [
            {
              "icon": "",
              "label": "5 — var-deklarationer körs omedelbar före all annan kod"
            },
            {
              "icon": "",
              "label": "ReferenceError: x is not defined"
            },
            {
              "icon": "",
              "label": "undefined — var-deklarationer hissas upp till toppen av sitt scope och initialiseras till undefined, men tilldelningen körs på plats, så innan det körs finns variabeln men innehåller undefined"
            },
            {
              "icon": "",
              "label": "null"
            }
          ]
        },
        {
          "question": "console.log(y);\nlet y = 5;\nVad händer?",
          "options": [
            {
              "icon": "",
              "label": "Det kastar ReferenceError: Cannot access 'y' before initialization — let hissas upp till toppen av sitt scope men stannar i den temporala dödzonen tills deklarationsraden faktiskt körs"
            },
            {
              "icon": "",
              "label": "Det skriver ut undefined, samma som var skulle göra"
            },
            {
              "icon": "",
              "label": "Det skriver ut 5"
            },
            {
              "icon": "",
              "label": "Det kastar en SyntaxError vid parsning"
            }
          ]
        },
        {
          "question": "const arr = [1, 2, 3];\narr.push(4);\nconsole.log(arr.length);\nVad skrivs ut?",
          "options": [
            {
              "icon": "",
              "label": "4 — const förhindrar endast omtilldelning av arr-bindningen själv, inte mutering av array-objektet det pekar på, så push fungerar fortfarande"
            },
            {
              "icon": "",
              "label": "Det kastar en TypeError, eftersom arr är const"
            },
            {
              "icon": "",
              "label": "3 — push är blockerad på en const array"
            },
            {
              "icon": "",
              "label": "undefined"
            }
          ]
        },
        {
          "question": "console.log('' == 0);\nconsole.log('' === 0);\nVad skrivs ut på de två raderna?",
          "options": [
            {
              "icon": "",
              "label": "true sedan true"
            },
            {
              "icon": "",
              "label": "false sedan false"
            },
            {
              "icon": "",
              "label": "true sedan false — == tvingar den tomma strängen till 0 innan jämförelse, medan === jämför typ och värde utan tvingning, och en sträng är aldrig strikt lika med ett nummer"
            },
            {
              "icon": "",
              "label": "false sedan true"
            }
          ]
        },
        {
          "question": "console.log(NaN === NaN);\nconsole.log(Number.isNaN(NaN));\nVad skrivs ut på de två raderna?",
          "options": [
            {
              "icon": "",
              "label": "true sedan true"
            },
            {
              "icon": "",
              "label": "true sedan false"
            },
            {
              "icon": "",
              "label": "false sedan false"
            },
            {
              "icon": "",
              "label": "false sedan true — NaN är det enda värdet i JavaScript som inte är lika med sig själv under ===, men Number.isNaN() detekterar det ändå korrekt"
            }
          ]
        },
        {
          "question": "console.log(typeof null);\nVad skrivs ut?",
          "options": [
            {
              "icon": "",
              "label": "\"null\""
            },
            {
              "icon": "",
              "label": "\"object\" — ett långvarigt fel i språket: typeof null returnerar \"object\" även om null är en primitiv, och det har bevarats för bakåtkompatibilitet sedan dess"
            },
            {
              "icon": "",
              "label": "\"undefined\""
            },
            {
              "icon": "",
              "label": "\"boolean\""
            }
          ]
        },
        {
          "question": "Vilket av följande är truthy när det används i ett if-villkor?",
          "options": [
            {
              "icon": "",
              "label": "0"
            },
            {
              "icon": "",
              "label": "\"\" (en tom sträng)"
            },
            {
              "icon": "",
              "label": "null"
            },
            {
              "icon": "",
              "label": "\"0\" — en icke-tom sträng är alltid truthy i JavaScript, även när dess innehål själv är strängen \"0\""
            }
          ]
        },
        {
          "question": "foo();\nfunction foo() { console.log('a'); }\nbar();\nvar bar = function() { console.log('b'); };\nVad händer?",
          "options": [
            {
              "icon": "",
              "label": "Båda samtalen skriver ut, \"a\" sedan \"b\""
            },
            {
              "icon": "",
              "label": "foo() skriver ut \"a\"; bar() kastar TypeError: bar is not a function — funktionsdeklarationer hissas upp helt med sin kropp, men ett var-tilldelat funktionsuttryck hissar endast var själv (som undefined), inte tilldelningen"
            },
            {
              "icon": "",
              "label": "Båda samtalen kastar ReferenceError"
            },
            {
              "icon": "",
              "label": "foo() kastar; bar() skriver ut \"b\""
            }
          ]
        },
        {
          "question": "function makeCounter() {\n  let count = 0;\n  return function() { count++; return count; };\n}\nconst counter = makeCounter();\nconsole.log(counter());\nconsole.log(counter());\nVad skrivs ut på de två raderna?",
          "options": [
            {
              "icon": "",
              "label": "1 sedan 1"
            },
            {
              "icon": "",
              "label": "0 sedan 1"
            },
            {
              "icon": "",
              "label": "undefined sedan undefined"
            },
            {
              "icon": "",
              "label": "1 sedan 2 — den returnerade funktionen stänger över samma count-variabel från makeCounter's scope, och den variabeln kvarstår mellan anrop istället för att återställas"
            }
          ]
        },
        {
          "question": "for (var i = 0; i < 3; i++) {\n  setTimeout(() => console.log(i), 0);\n}\nVad skrivs ut?",
          "options": [
            {
              "icon": "",
              "label": "0, 1, 2"
            },
            {
              "icon": "",
              "label": "3, 3, 3 — var är funktionsomfattat, inte blockomfattat, så alla tre callbacks stänger över samma i, som redan har avslutat loopen och är lika med 3 när någon av dem faktiskt körs"
            },
            {
              "icon": "",
              "label": "0, 0, 0"
            },
            {
              "icon": "",
              "label": "undefined, undefined, undefined"
            }
          ]
        },
        {
          "question": "for (let i = 0; i < 3; i++) {\n  setTimeout(() => console.log(i), 0);\n}\nVad skrivs ut?",
          "options": [
            {
              "icon": "",
              "label": "3, 3, 3"
            },
            {
              "icon": "",
              "label": "0, 0, 0"
            },
            {
              "icon": "",
              "label": "undefined, undefined, undefined"
            },
            {
              "icon": "",
              "label": "0, 1, 2 — let skapar en separat bindning för i i varje loopiteration, så varje callback får sin egen kopia istället för en delad variabel"
            }
          ]
        },
        {
          "question": "function greet() { return `Hi, ${this.name}`; }\nconst person = { name: 'Ana' };\nconsole.log(greet.call(person));\nVad skrivs ut?",
          "options": [
            {
              "icon": "",
              "label": "\"Hi, Ana\" — Function.prototype.call anropar funktionen med this explicit satt till sitt första argument, så this.name löses mot person"
            },
            {
              "icon": "",
              "label": "\"Hi, undefined\" — call() fungerar bara på funktioner som redan är metoder på ett objekt"
            },
            {
              "icon": "",
              "label": "Det kastar en TypeError, för greet är inte en metod på person"
            },
            {
              "icon": "",
              "label": "\"Hi, ${this.name}\" — call() utvärderar inte mallsträngsliteralen"
            }
          ]
        },
        {
          "question": "const timer = {\n  seconds: 0,\n  start: function() {\n    setInterval(() => { this.seconds++; }, 1000);\n  },\n};\nVarför föredrar folk piltfunktionen framför function() { this.seconds++ } inuti setInterval här?",
          "options": [
            {
              "icon": "",
              "label": "Piltfunktioner har ingen egen this — de fångar this lexikaliskt från den omslutande start-funktionen, som är timer (eftersom start anropades som timer.start()), så this.seconds refererar korrekt till timer.seconds på varje tick"
            },
            {
              "icon": "",
              "label": "Piltfunktioner körs snabbare än vanliga funktioner under körning"
            },
            {
              "icon": "",
              "label": "Piltfunktioner binder automatiskt this till det globala objektet, som råkar vara lika med timer"
            },
            {
              "icon": "",
              "label": "Piltfunktioner konverterar automatiskt this till en global variabel"
            }
          ]
        },
        {
          "question": "function multiply(a, b) { return a * b; }\nconst double = multiply.bind(null, 2);\nconsole.log(double(5));\nVad skrivs ut?",
          "options": [
            {
              "icon": "",
              "label": "Det kastar ett fel, för bind kräver båda argumenten från början"
            },
            {
              "icon": "",
              "label": "10 — bind returnerar en ny funktion med this och alla inledande argument förinställda; att anropa double(5) levererar det återstående argumentet b=5, så multiply(2, 5) körs"
            },
            {
              "icon": "",
              "label": "NaN"
            },
            {
              "icon": "",
              "label": "7, för bind lägger till sina argument till anropet istället för att ersätta dem"
            }
          ]
        },
        {
          "question": "function outer() {\n  let x = 10;\n  function inner() {\n    let x = 20;\n    console.log(x);\n  }\n  inner();\n  console.log(x);\n}\nouter();\nVad skrivs ut av de två console.log-anropen?",
          "options": [
            {
              "icon": "",
              "label": "20 sedan 20"
            },
            {
              "icon": "",
              "label": "20 sedan 10 — inner:s eget let x skuggar outer:s x bara inom inner:s scope; outer:s eget x rördes aldrig"
            },
            {
              "icon": "",
              "label": "10 sedan 10"
            },
            {
              "icon": "",
              "label": "Det kastar en ReferenceError, för x är deklarerad två gånger"
            }
          ]
        },
        {
          "question": "const a = [1, 2, 3];\nconst b = a;\nb.push(4);\nconsole.log(a.length);\nVad skrivs ut?",
          "options": [
            {
              "icon": "",
              "label": "3 — b är en separat kopia av a"
            },
            {
              "icon": "",
              "label": "undefined"
            },
            {
              "icon": "",
              "label": "Det kastar en TypeError, för a är const"
            },
            {
              "icon": "",
              "label": "4 — arrayer är objekt, så const b = a kopierar referensen, inte själva arrayen; att mutera b genom push muterar också samma exakta array som a pekar på"
            }
          ]
        },
        {
          "question": "const original = { name: 'Ana', tags: ['x', 'y'] };\nconst copy = { ...original };\ncopy.name = 'Bea';\ncopy.tags.push('z');\nconsole.log(original.name, original.tags.length);\nVad skrivs ut?",
          "options": [
            {
              "icon": "",
              "label": "'Ana' 2 — spread kopierar djupt varje kapslat objekt och array"
            },
            {
              "icon": "",
              "label": "'Ana' 3 — spread är bara en ytlig kopia: en primitiv egenskap som name kopieras efter värde, så att omtildela copy.name rör aldrig original, men en kapslad array som tags kopieras efter referens, så att pusha till copy.tags muterar samma exakta array som original.tags pekar på"
            },
            {
              "icon": "",
              "label": "'Bea' 3 — spread kopierar allt efter referens, så både ändringar på översta nivå och kapslade ändringar bärs tillbaka till original"
            },
            {
              "icon": "",
              "label": "'Bea' 2"
            }
          ]
        },
        {
          "question": "const { a: x = 10, b: y = 20 } = { a: 5 };\nconsole.log(x, y);\nVad skrivs ut?",
          "options": [
            {
              "icon": "",
              "label": "undefined undefined"
            },
            {
              "icon": "",
              "label": "5 undefined"
            },
            {
              "icon": "",
              "label": "10 20"
            },
            {
              "icon": "",
              "label": "5 20 — a är döpt om till x och är närvarande, så den behåller sitt värde 5; b är döpt om till y och är frånvarande, så den faller tillbaka till sin standardvärde 20"
            }
          ]
        },
        {
          "question": "const [first, ...rest] = [1, 2, 3, 4];\nconsole.log(rest);\nVad skrivs ut?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 3, 4]"
            },
            {
              "icon": "",
              "label": "[2, 3, 4] — rest samlar varje återstående element efter first in i en helt ny array"
            },
            {
              "icon": "",
              "label": "2"
            },
            {
              "icon": "",
              "label": "[1]"
            }
          ]
        },
        {
          "question": "const nums = [10, 1, 2];\nnums.sort();\nconsole.log(nums);\nVad skrivs ut?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 10] — sort sorterar alltid tal numeriskt i stigande ordning som standard"
            },
            {
              "icon": "",
              "label": "[10, 1, 2] — sort muterar inte den ursprungliga arrayen"
            },
            {
              "icon": "",
              "label": "[1, 10, 2] — Array.prototype.sort:s standardkomparator konverterar element till strängar och jämför dem lexikografiskt, så \"10\" sorteras före \"2\"; sort muterar också arrayen på plats istället för att returnera en ny"
            },
            {
              "icon": "",
              "label": "[2, 1, 10]"
            }
          ]
        },
        {
          "question": "const user = { profile: { age: 0 } };\nconsole.log(user.profile?.age ?? 'unknown');\nconsole.log(user.address?.city ?? 'unknown');\nVad skriver de två raderna ut?",
          "options": [
            {
              "icon": "",
              "label": "'unknown' then 'unknown' — ?? behandlar 0 som saknat, på samma sätt som || gör"
            },
            {
              "icon": "",
              "label": "0 then 'unknown' — ?? faller bara tillbaka på null eller undefined, inte på andra falska värden som 0, så age (0) behålls som det är; user.address är undefined, så ?. kortsluter hela kedjan till undefined och ?? tillhandahåller då 'unknown'"
            },
            {
              "icon": "",
              "label": "0 then undefined"
            },
            {
              "icon": "",
              "label": "'unknown' then 0"
            }
          ]
        },
        {
          "question": "const obj = { a: undefined, b: function(){}, c: NaN, d: [undefined, function(){}, 1] };\nconsole.log(JSON.stringify(obj));\nVad skriver detta ut?",
          "options": [
            {
              "icon": "",
              "label": "'{\"a\":null,\"b\":null,\"c\":null,\"d\":[null,null,1]}' — varje värde som inte stöds blir null överallt, i både objekt och arrayer"
            },
            {
              "icon": "",
              "label": "'{\"a\":undefined,\"b\":undefined,\"c\":NaN,\"d\":[undefined,null,1]}'"
            },
            {
              "icon": "",
              "label": "'{\"c\":null,\"d\":[null,null,1]}' — objektegenskaper vars värde är undefined eller en funktion utelämnas helt, och NaN serialiseras till null, men inuti en array blir dessa samma värden som inte stöds null istället för att tas bort, eftersom att ta bort ett arrayelement skulle flytta varje senare index"
            },
            {
              "icon": "",
              "label": "Det kastar en TypeError, eftersom NaN inte kan serialiseras till JSON"
            }
          ]
        },
        {
          "question": "console.log('1');\nsetTimeout(() => console.log('2'), 0);\nPromise.resolve().then(() => console.log('3'));\nconsole.log('4');\nI vilken ordning skrivs dessa ut?",
          "options": [
            {
              "icon": "",
              "label": "1, 2, 3, 4"
            },
            {
              "icon": "",
              "label": "1, 4, 2, 3"
            },
            {
              "icon": "",
              "label": "1, 4, 3, 2 — synkron kod körs först (så 1 och 4 skrivs ut omedelbar), sedan tömmer microtask-kön (Promise-callback:s) helt innan event-loopen går vidare till nästa makrotask, så 3 skrivs ut före setTimeout-callback:ens 2"
            },
            {
              "icon": "",
              "label": "1, 3, 4, 2"
            }
          ]
        },
        {
          "question": "async function foo() {\n  console.log('a');\n  await null;\n  console.log('b');\n}\nconsole.log('start');\nfoo();\nconsole.log('end');\nI vilken ordning skrivs dessa ut?",
          "options": [
            {
              "icon": "",
              "label": "start, a, end, b — foo() körs synkront upp till sin första await, så 'a' loggas omedelbar när foo() kallas; await pausar sedan foo och återgår kontrollen till anroparen, så 'end' loggas före den återupptagna 'b', som körs senare som en microtask"
            },
            {
              "icon": "",
              "label": "start, a, b, end"
            },
            {
              "icon": "",
              "label": "start, end, a, b"
            },
            {
              "icon": "",
              "label": "a, start, end, b"
            }
          ]
        },
        {
          "question": "Promise.all([\n  Promise.resolve(1),\n  Promise.reject('err'),\n  Promise.resolve(3),\n]).then(r => console.log('ok', r)).catch(e => console.log('fail', e));\nVad skriver detta ut?",
          "options": [
            {
              "icon": "",
              "label": "'fail err' — Promise.all avvisar så snart någon av dess inmatningslofte avvisar, ignorerar resultaten av de andra, så catch-hanteraren körs med det avvisningens skäl"
            },
            {
              "icon": "",
              "label": "'ok' [1, 3]"
            },
            {
              "icon": "",
              "label": "'ok' [1, undefined, 3]"
            },
            {
              "icon": "",
              "label": "Det kastar synkront och ingen hanterare körs någonsin"
            }
          ]
        },
        {
          "question": "const fast = new Promise(res => setTimeout(() => res('fast'), 10));\nconst slow = new Promise(res => setTimeout(() => res('slow'), 100));\nPromise.race([fast, slow]).then(v => console.log(v));\nVad skriver detta ut?",
          "options": [
            {
              "icon": "",
              "label": "'slow'"
            },
            {
              "icon": "",
              "label": "['fast', 'slow']"
            },
            {
              "icon": "",
              "label": "'fast' — Promise.race löses så snart det första av dess inmatningslofte löses, och 10ms-timern löses långt före 100ms-timern"
            },
            {
              "icon": "",
              "label": "Det kastar ett fel, eftersom race kräver exakt två löften"
            }
          ]
        },
        {
          "question": "function Animal(name) { this.name = name; }\nAnimal.prototype.speak = function() { return `${this.name} makes a sound`; };\nconst dog = new Animal('Rex');\nconsole.log(dog.speak());\nconsole.log(dog.hasOwnProperty('speak'));\nVad skriver de två raderna ut?",
          "options": [
            {
              "icon": "",
              "label": "'Rex makes a sound' then true"
            },
            {
              "icon": "",
              "label": "undefined then false"
            },
            {
              "icon": "",
              "label": "Det kastar en TypeError, eftersom dog inte har någon speak-metod av sig själv"
            },
            {
              "icon": "",
              "label": "'Rex makes a sound' then false — speak är definierad på Animal.prototype, inte på dog-instansen själv; dog hittar den genom prototypkedjan när den kallas, men hasOwnProperty kontrollerar endast instansens egna egenskaper, inte något ärvt"
            }
          ]
        },
        {
          "question": "class Counter {\n  #count = 0;\n  increment() { this.#count++; return this.#count; }\n}\nconst c = new Counter();\nconsole.log(c.increment());\nconsole.log(c.count);\nVad skriver de två raderna ut?",
          "options": [
            {
              "icon": "",
              "label": "1 then undefined — #count är ett privat klassfält, läsbar och skrivbar endast inuti klassens egna metoder; c.count (utan #) är en helt annan vanlig egenskap som aldrig ställdes in, så det är undefined"
            },
            {
              "icon": "",
              "label": "1 then 0"
            },
            {
              "icon": "",
              "label": "1 then 1"
            },
            {
              "icon": "",
              "label": "Det kastar en SyntaxError när man får tillgång till c.count"
            }
          ]
        },
        {
          "question": "const items = ['a', 'b'];\nconst label = `Items: ${items.length > 0 ? items.join(', ') : 'none'}`;\nconsole.log(label);\nVad skriver detta ut?",
          "options": [
            {
              "icon": "",
              "label": "'Items: ${items.length > 0 ? items.join(\\', \\') : \\'none\\'}'"
            },
            {
              "icon": "",
              "label": "'Items: none'"
            },
            {
              "icon": "",
              "label": "'Items: a, b' — mallsträngar utvärderar alla uttryck inuti ${...}, inklusive en fullständig ternär, och interpolerar dess resultat direkt i strängen"
            },
            {
              "icon": "",
              "label": "Det kastar en SyntaxError, eftersom ternärer inte är tillåtna inuti mallsträngar"
            }
          ]
        },
        {
          "question": "const nums = [1, 2, 3, 4, 5];\nconst result = nums.filter(n => n % 2 === 0).map(n => n * 10).reduce((sum, n) => sum + n, 0);\nconsole.log(result, nums);\nVad skriver detta ut?",
          "options": [
            {
              "icon": "",
              "label": "60 [1, 2, 3, 4, 5] — filter, map och reduce returnerar vardera en ny array eller värde utan att mutera den ursprungliga arrayen, så nums är oförändrad medan result är den slutliga reducerade summan (2 och 4, fördubblade till 20 och 40, summerade till 60)"
            },
            {
              "icon": "",
              "label": "60 [2, 4, 20, 40]"
            },
            {
              "icon": "",
              "label": "150 [1, 2, 3, 4, 5]"
            },
            {
              "icon": "",
              "label": "60 [20, 40]"
            }
          ]
        }
      ],
      "optionOrderVersion": "50fc0eba818f2d72"
    }
  }
}