Exempel på JavaScript Flashcards från vår app

Ladda ner vår app från App Store eller Google Play för att få fler gratis flashcards eller prenumerera för tillgång till alla flashcards.

Vad är lexikal omfattning i JavaScript?

Lexikalisk räckvidd i JavaScript är en princip där synlighetsområdet för en variabel bestäms av dess plats i koden. Detta innebär att variabler är tillgängliga inuti blocket där de definierades, samt i alla nästlade block. Detta möjliggör skapandet av stängningar och kontroll över variabelåtkomst. Exempel på användning av lexikalisk räckvidd i JavaScript-kod:

function outerFunction() {
  let outerVariable = `I'm outside!`;

  function innerFunction() {
    console.log(outerVariable); // Har tillgång till 'outerVariable'
  }

  innerFunction();
}
outerFunction(); // Visar `I'm outside!`

Lexikalisk räckvidd tillåter en inre funktion att få åtkomst till variabler definierade i en yttre funktion, även efter att den yttre funktionen har avslutats. Detta är ett nyckelelement i skapandet av stängningar i JavaScript, vilket möjliggör mer flexibel statehantering i applikationer.

Vad är hoisting?

Hoisting är en mekanism i JavaScript-språk där variabler och funktioner flyttas till toppen av deras omfång innan koden körs. I praktiken innebär detta att vi kan använda funktioner eller variabler innan de faktiskt deklareras.

Det bör dock noteras att hoisting fungerar lite annorlunda för variabler och funktioner.

För variabler deklarerade med var nyckelord, är det endast deklarationen som hissas, inte initialiseringen. Variabler initialiserade före deklaration kommer att returneras som undefined.

Ett exempel på kod för variabler:

console.log(myVar); // undefined
var myVar = 5;
console.log(myVar); // 5

För funktioner, flyttar hoisting både deklaration och definition av funktionen till toppen, vilket gör det möjligt att använda funktionen innan den deklareras.

Ett exempel på kod för funktioner:

console.log(myFunction()); // "Hello World"

function myFunction() {
  return "Hello World";
}

Hoisting sker inte för variabler deklarerade med let och const.

Vad är en pilfunktion och vilka är dess fördelar?

En pilfunktion, även känd som pilfunktion, är en typ av funktion som introducerades i ECMAScript 6 (ES6). De kallas pilfunktioner eftersom de använder en speciell syntax med en pil ( => ) för att definiera funktionen.

Till jämförelse kan en traditionell funktion se ut så här:

function sum(a, b) {
  return a + b;
}

Dess ekvivalent som en pilfunktion är:

const sum = (a, b) => a + b;

Det främsta fördelen med en pilfunktion är att den inte skapar sin egen executionssammanhang (bindning till detta), vilket ofta är en källa till fel i JavaScript. I pilfunktioner ärvs detta från det omgivande sammanhanget. En annan fördel är syntaxens korthet, särskilt användbar när funktioner används som argument till andra funktioner, t.ex. i högre ordningsfunktioner.

Å andra sidan, på grund av bristen på sitt eget detta, är pilfunktioner inte lämpliga för att definiera konstruktor (kreativa) objekt eller för att skapa metoder i prototypobjekt.

Vad är ett Promise-objekt och hur kan det användas?

Promise-objektet i JavaScript används för att hantera asynkrona operationer. En Promise representerar ett värde som kanske inte är tillgängligt när Promise skapas, men kan vara tillgängligt i framtiden, eller aldrig alls.

Ett Promise-objekt kan vara i ett av tre tillstånd:
1. Pågående - operationen pågår fortfarande, inte klar antingen framgångsrikt eller med fel.
2. Uppfylld - operationen slutfördes framgångsrikt, Promise returnerade ett värde.
3. Rejected - operationen slutfördes med ett fel, Promise returnerade orsaken till felet.

Ett Promise som har uppfyllts eller avvisats anses vara "avgjord" och dess tillstånd ändras aldrig.

Skapa ett Promise-objekt:

const promise = new Promise((resolve, reject) => {
  const success = true;
  if (success) {
    resolve('Operationen är framgångsrik.');
  } else {
    reject('Operationen misslyckades.');
  }
});

Användning av ett Promise-objekt:

promise
  .then(result => {
    console.log(result); // Kommer att skriva ut: 'Operationen är framgångsrik.'
  })
  .catch(error => {
    console.log(error);
  });

Metoden .then() utförs när Promise är uppfylld, och .catch() när den avvisas. I båda fallen skickas resultatet av operationen eller orsaken till avvisning av Promisen som argument.

Vad är en callback?

En callback, även kallad en callback-funktion, är en funktion som passeras som ett argument till en annan funktion och sedan exekveras (kallas tillbaka) efter att den funktionen har slutförts. Callback-funktioner används vanligtvis i JavaScript, särskilt i asynkrona operationer som AJAX-förfrågningar eller händelsehantering.

Callbackfunktioner tar normalt emot resultaten från en viss operation som argument, så att de kan användas för att bearbeta eller analysera dessa resultat.

Användningen av en sådan funktion i praktiken kan se ut som följande:

function executeAfterTimeout(callback, timeout) {
  setTimeout(() => {
    console.log('Time passed!');
    callback();
  }, timeout);
}

executeAfterTimeout(() => {
  console.log('This is a callback!');
}, 2000);

I det här fallet tar funktionen `executeAfterTimeout` emot en `callback`-funktion som en parameter, som kommer att exekveras efter att en viss tidsperiod har passerat. Callbackfunktioner är extremt användbara för att hantera asynkron kontrollflöde i JavaScript.

Vad är nullish sammanfogning operatorn och hur fungerar den?

Nullish Coalescing Operatorn (??) är en logisk operator som returnerar den högra sidan av operationen när den vänstra sidan är null eller odefinierad. Med andra ord, när en variabel är tom, returnerar den nullish coalescerande operatören det definierade värdet som ett resultat.

Den grundläggande notationen är:

let value = null ?? 'default value';

I det här fallet, eftersom den vänstra sidan (value) är null, är resultatet 'standardvärde'. Dessutom skiljer sig denna operator från OR-operatören (||), eftersom OR-funktionen returnerar den högra sidan när den vänstra sidan är falsk (false, 0, '', null, odefinierat, NaN), medan den nullish coalescerande operatören bara returnerar den högra sidan när den vänstra sidan är null eller odefinierad.

Exempel med OR:

let value1 = 0 || 'default';
console.log(value1); // output: 'default' eftersom 0 är ett falskt värde

Exempel med nullisk sammanfogning:

let value2 = 0 ?? 'default';
console.log(value2); // output: 0 eftersom 0 inte är null eller odefinierat

Så, till skillnad från OR, behandlar den nulliska coalescerande operatören inte 0, '' och NaN som "tomma" värden.

Vad är Symbol och när bör den användas?

En Symbol i JavaScript är en unik och oföränderlig datatyp som ofta används för att identifiera unika egenskaper hos objekt.

Du kan skapa en Symbol genom att anropa Symbol()-konstruktorn, som skapar en unik symbol varje gång den anropas. Även om vi anropar Symbol()-konstruktorn med samma argument, kommer varje skapad symbol att vara olika.

const symbol1 = Symbol('mySymbol');
const symbol2 = Symbol('mySymbol');
console.log(symbol1 === symbol2); // returnerar false

Symbol används ofta för att definiera (unika) egenskaper hos objekt, särskilt när vi vill att denna egenskap ska vara dold eller privat. Den omfattar också egenskaper som inte beaktas vid iterering över objekt med hjälp av for...in eller for...of och inte returneras av Object.keys()-metoden. Dessutom tillåter symboler att skapa "pseudo" privata egenskaper.

let obj = {};
let privateProperty = Symbol('private');

obj[privateProperty] = 'This is private';

console.log(obj[privateProperty]); // 'This is private'
console.log(Object.keys(obj)); // []

Det finns ingen bestämd regel för när man ska använda Symbol. De används typiskt när vi vill skapa en unik egenskap på ett objekt som inte lätt kan ses eller ändras, eller vi vill definiera metoder som påverkar objektens beteende på en låg nivå.

Vad är WeakMap och WeakSet?

WeakMap och WeakSet är speciella versioner av JavaScript Map och Set-objekt som inte förhindrar automatisk minnesfrihet av Skräpsamlaren.

WeakMap är en samling av nyckel-värdepar där nycklar måste vara objekt och värden kan vara vad som helst. Den huvudsakliga skillnaden mellan Map och WeakMap är att nycklar i WeakMap hålls "svagt", vilket innebär att om det inte finns några andra referenser till nyckelobjektet, kommer det att samlas upp som skräp, och dess inmatning i WeakMap kommer automatiskt att tas bort.

Här är ett exempel på att använda WeakMap:

let john = { name: "John" };

let weakMap = new WeakMap();
weakMap.set(john, "...");

john = null; // skriv över referensen

// john tas bort från minnet!

WeakSet är liknande till vad WeakMap är till Map. Det är en uppsättning av objekt, men det förhindrar inte skräpsamling om objektet inte är synligt någon annanstans. Det saknar typiska Set-metoder som `size` och `clear`, och `add`-metoden tar endast objekt.

Exempel på att använda WeakSet:

let john = { name: "John" };

let weakSet = new WeakSet();
weakSet.add(john);

john = null; // skriv över referensen

// john tas bort från minnet!

Både WeakMap och WeakSet används främst i situationer när vi vill lagra ytterligare information om objekt som bör tas bort när objektet själv tas bort.

JavaScript Flashcards