Voorbeelden van JavaScript-flashcards uit onze app

Download onze app uit de App Store of Google Play om meer gratis flitskaarten te krijgen of abonneer u voor toegang tot alle flitskaarten.

Wat is lexicale scope in JavaScript?

Lexicale scope in JavaScript is een principe waarbij het zichtbaarheidsbereik van een variabele wordt bepaald door de locatie in de code. Dit betekent dat variabelen toegankelijk zijn binnen het blok waarin ze zijn gedefinieerd, evenals in eventuele geneste blokken. Dit maakt het creëren van closures en controle over variabele toegang mogelijk. Voorbeeld van het gebruik van lexicale scope in JavaScript-code:

function outerFunction() {
  let outerVariable = `Ik ben buiten!`;

  function innerFunction() {
    console.log(outerVariable); // Heeft toegang tot 'outerVariable'
  }

  innerFunction();
}
outerFunction(); // Toont `Ik ben buiten!`

Lexicale scope stelt een innerlijke functie in staat om variabelen te bereiken die zijn gedefinieerd in een uiterlijke functie, zelfs nadat de uiterlijke functie is voltooid. Dit is een sleutelelement in het creëren van closures in JavaScript, wat zorgt voor flexibeler beheer van de status in applicaties.

Wat is hoisting?

Tilting is een mechanisme in JavaScript-talen waarbij variabelen en functies naar de bovenkant van hun bereik worden verplaatst voordat de code wordt uitgevoerd. In de praktijk betekent dit dat we functies of variabelen kunnen gebruiken voordat ze daadwerkelijk zijn gedeclareerd.

Het moet echter worden opgemerkt dat tilting iets anders werkt voor variabelen en functies.

Voor variabelen gedeclareerd met var sleutelwoorden, wordt alleen de declaratie getild, niet de initialisatie. Variabelen geïnitialiseerd vóór de declaratie worden teruggegeven als ongedefinieerd.

Een voorbeeld van tilting-code voor variabelen:

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

Voor functies verplaatst de kanteling zowel de declaratie als de definitie van de functie naar de top, wat het gebruik van de functie mogelijk maakt voordat deze is gedeclareerd.

Een voorbeeld van tilting-code voor functies:

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

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

Tilting vindt niet plaats voor variabelen gedeclareerd met let en const.

Wat is een pijlfunctie en wat zijn de voordelen?

Een pijlfunctie, ook bekend als pijlfunctie, is een type functie geïntroduceerd in ECMAScript 6 (ES6). Ze worden pijlfuncties genoemd omdat ze een speciale syntaxis gebruiken met een pijl ( => ) om de functie te definiëren.

Ter vergelijking, een traditionele functie ziet er misschien zo uit:

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

De equivalent als pijlfunctie is:

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

Het belangrijkste voordeel van een pijlfunctie is dat het zijn eigen uitvoeringscontext (binding aan this) niet creëert, wat vaak een bron van fouten is in JavaScript. In pijlfuncties wordt this geërfd van de omringende context. Een ander voordeel is de bondigheid van de syntaxis, vooral nuttig wanneer functies worden gebruikt als argumenten voor andere functies, bijv. in hogere-orde functies.

Aan de andere kant, vanwege het ontbreken van zijn eigen this, zijn pijlfuncties niet geschikt voor het definiëren van constructor (creatieve) objecten of voor het maken van methoden in prototype-objecten.

Wat is een Promise-object en hoe kan het worden gebruikt?

Het Promise-object in JavaScript wordt gebruikt om asynchrone operaties te beheren. Een Promise vertegenwoordigt een waarde die mogelijk niet beschikbaar is op het moment dat de Promise is gemaakt, maar mogelijk in de toekomst beschikbaar is, of helemaal nooit.

Een Promise-object kan in een van de drie staten verkeren:
1. In afwachting - de operatie is nog aan de gang, nog niet voltooid, hetzij succesvol, hetzij met fouten.
2. Voldaan - operatie succesvol voltooid, Promise heeft een waarde geretourneerd.
3. Afgewezen - operatie voltooid met een fout, Promise retourneerde de reden voor de fout.

Een Promise die is nagekomen of afgewezen, wordt beschouwd als "voldaan" en de staat ervan verandert nooit.

Een Promise-object aanmaken:

const promise = new Promise((resolve, reject) => {
  const success = true;
  if (success) {
    resolve('Operatie geslaagd.');
  } else {
    reject('Operatie mislukt.');
  }
});

Het gebruik van een Promise-object:

promise
  .then(result => {
    console.log(result); // Zal afdrukken: 'Operatie geslaagd.'
  })
  .catch(error => {
    console.log(error);
  });

De .then() methode wordt uitgevoerd wanneer de Promise is nagekomen, en .catch() wanneer het is afgewezen. In beide gevallen wordt het resultaat van de operatie of de reden voor de afwijzing van de belofte als een argument doorgegeven.

Wat is een callback?

Een callback, ook wel een callback-functie genoemd, is een functie die wordt doorgegeven als een argument aan een andere functie en vervolgens wordt uitgevoerd (teruggeroepen) na de voltooiing van die functie. Callback-functies worden veel gebruikt in JavaScript, vooral bij asynchrone bewerkingen zoals AJAX-verzoeken of event handling.

Callback-functies ontvangen meestal de resultaten van een bepaalde operatie als argumenten, zodat ze kunnen worden gebruikt voor het verwerken of analyseren van die resultaten.

Het gebruik van zo'n functie in de praktijk kan er als volgt uitzien:

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

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

In dit geval ontvangt de functie `executeAfterTimeout` een `callback`-functie als parameter, die wordt uitgevoerd nadat een opgegeven hoeveelheid tijd is verstreken. Callback-functies zijn uitermate nuttig voor het beheren van asynchrone controleflow in JavaScript.

Wat is de nullish coalescing operator en hoe werkt het?

De Nullish Coalescing Operator (??) is een logische operator die de rechterkant van de operatie retourneert wanneer de linkerkant null of niet gedefinieerd is. Met andere woorden, wanneer een variabele leeg is, geeft de nullish coalescing operator de gedefinieerde waarde als resultaat terug.

De basisnotatie is:

let waarde = null ?? 'standaardwaarde';

In dit geval, omdat de linkerkant (waarde) null is, is het resultaat 'standaardwaarde'. Daarnaast verschilt deze operator van de OF-operator (||), omdat de OF-functie de rechterkant retourneert wanneer de linkerkant onwaar is (false, 0, '', null, undefined, NaN), terwijl de nullish coalescing operator alleen de rechterkant retourneert wanneer de linkerkant null of niet gedefinieerd is.

Voorbeeld met OF:

let waarde1 = 0 || 'standaard';
console.log(waarde1); // output: 'standaard' omdat 0 een valse waarde is

Voorbeeld met nullish coalescing:

let waarde2 = 0 ?? 'standaard';
console.log(waarde2); // output: 0 want 0 is noch null noch ongedefinieerd

Dus, in tegenstelling tot OF, behandelt de nullish coalescing operator 0, '' en NaN niet als "lege" waarden.

Wat is Symbol en wanneer moet het worden gebruikt?

Een symbool in JavaScript is een unieke en onveranderlijke gegevenstype dat vaak wordt gebruikt om unieke eigenschappen van objecten te identificeren.

Je kunt een symbool maken door de Symbol() constructor aan te roepen, die elke keer dat deze wordt aangeroepen een uniek symbool maakt. Zelfs als we de Symbol() constructor met hetzelfde argument aanroepen, zal elk gemaakt symbool anders zijn.

const symbool1 = Symbol('mijnSymbool');
const symbool2 = Symbol('mijnSymbool');
console.log(symbool1 === symbool2); // geeft false terug

Symbool wordt vaak gebruikt om (unieke) eigenschappen van objecten te definiëren, vooral wanneer we willen dat deze eigenschap verborgen of privé is. Het dekt ook eigenschappen die niet worden overwogen bij het itereren over objecten met behulp van for...in of for...of en worden niet geretourneerd door de Object.keys() methode. Bovendien zorgt symbolen dat "pseudo" privé-eigenschappen aanmaken mogelijk is.

let obj = {};
let privéEigenschap = Symbol('privé');

obj[privéEigenschap] = 'Dit is privé';

console.log(obj[privéEigenschap]); // 'Dit is privé'
console.log(Object.keys(obj)); // []

Er is geen definitieve regel over wanneer je Symbool moet gebruiken. Ze worden meestal gebruikt als we een unieke eigenschap aan een object willen maken die niet gemakkelijk gezien of gewijzigd kan worden, of we willen methoden definiëren die het gedrag van objecten op een laag niveau beïnvloeden.

Wat zijn WeakMap en WeakSet?

WeakMap en WeakSet zijn speciale versies van JavaScript Map en Set objecten die de automatische geheugen vrijgave door de Garbage Collector niet verhinderen.

WeakMap is een verzameling van sleutel-waarde paren waarbij de sleutels objecten moeten zijn en de waarden alles kunnen zijn. Het belangrijkste verschil tussen Map en WeakMap is dat de sleutels in WeakMap "zwak" worden vastgehouden, wat betekent dat als er geen andere referenties naar het sleutelobject zijn, het zal worden opgeruimd door de garbage collector en zijn invoer in WeakMap automatisch wordt verwijderd.

Hier is een voorbeeld van het gebruik van WeakMap:

let john = { naam: "John" };

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

john = null; // overschrijf de referentie

// john is uit het geheugen verwijderd!

WeakSet is vergelijkbaar met wat WeakMap is naar Map. Het is een set van objecten, maar het verhindert de garbage-collection niet als het object nergens anders zichtbaar is. Het mist typische Set methodes zoals `size` en `clear`, en de `add` methode accepteert alleen objecten.

Voorbeeld van het gebruik van WeakSet:

let john = { naam: "John" };

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

john = null; // overschrijf de referentie

// john is uit het geheugen verwijderd!

Beide, WeakMap en WeakSet, worden voornamelijk gebruikt in situaties waarin we extra informatie over objecten willen opslaan die verwijderd moeten worden wanneer het object zelf wordt verwijderd.

JavaScript Flashcards