100 questions théoriques sur JavaScript

Bonne journée, mes amis!



Voici une liste des 100 principales questions de base sur JavaScript de ce référentiel avec des réponses courtes et des liens vers le tutoriel JavaScript moderne (JSR) d'Ilya Kantor et MDN.



Cette liste, ainsi que plus de 300 questions pratiques, sont disponibles dans mon application .



L'application met en œuvre un mécanisme de mémorisation de la question étudiée, et fournit également un travail en mode hors ligne.



Je m'excuse pour les éventuelles erreurs et erreurs typographiques. Toute forme de rétroaction est appréciée.



Édition du 14.09.2019



Voir la suite ici .

1. Comment créer un objet?

Il y a plusieurs moyens de le faire. Certains d'entre eux sont:

Object literal:

const object = {}

Constructeur d'objets (non recommandé):

const object = new Object()

Méthode Object.create ()

Lors de l'utilisation de cette méthode, un objet lui est passé comme argument, qui deviendra le prototype du nouvel objet.

//     -  
const object = Object.create(null)

Fonction constructeur Nous créons une fonction constructeur et utilisons l'opérateur "new" pour créer une instance de cette fonction - un objet:

function Person (name) {
    const object = {}
    object.name = name
    object.age = 30
    return object
}
const user = new Person('')

Classe:

class Person {
    constructor(name) {
        this.name = name
    }
}

const user = new Person('')

JSR

MDN

2. Que sont les prototypes?

Les prototypes sont utilisés pour créer de nouveaux objets basés sur ceux existants. Cette technique est appelée héritage prototypique. Le prototype d'une instance d'objet est accessible via Object.getPrototypeOf (objet) ou la propriété __proto__ (propriété cachée interne [[Prototype]]).







JSR

MDN

3. Quelle est la différence entre call (), apply () et bind ()?

La différence entre ces méthodes est plus facile à expliquer avec des exemples.

La méthode call () appelle une fonction avec la valeur spécifiée et les arguments séparés par des virgules.

const employee1 = { firstName: '', lastName: '' }
const employee2 = { firstName: '', lastName: '' }

function invite (greet1, greet2) {
    console.log(\`${greet1}, ${this.firstName} ${this.lastName}. ${greet2}\`)
}

invite.call(employee1, '', ' ?') // ,  .  ?
invite.call(employee2, '', ' ?') // ,  .  ?

La méthode apply () appelle une fonction avec la valeur et les arguments de tableau spécifiés.

const employee1 = { firstName: '', lastName: '' }
const employee2 = { firstName: '', lastName: '' }

function invite (greet1, greet2) {
    console.log(\`${greet1}, ${this.firstName} ${this.lastName}. ${greet2}\`)
}

invite.apply(employee1, ['', ' ?']) // ,  .  ?
invite.apply(employee2, ['', ' ?']) // ,  .  ?

La méthode bind () renvoie une nouvelle fonction avec la valeur spécifiée et vous permet de lui passer un tableau ou n'importe quel nombre d'arguments séparés par des virgules.

const employee1 = { firstName: '', lastName: '' }
const employee2 = { firstName: '', lastName: '' }

function invite (greet1, greet2) {
    console.log(\`${greet1}, ${this.firstName} ${this.lastName}. ${greet2}\`)
}

const inviteEmployee1 = invite.bind(employee1)
const inviteEmployee2 = invite.bind(employee2)
inviteEmployee1('', ' ?') // ,  .  ?
inviteEmployee2('', ' ?') // ,  .  ?

Ainsi, les méthodes call () et apply () appellent la fonction après qu'elle a été liée à un objet. La différence entre les deux réside dans la manière dont les arguments sont transmis. Cette différence est facile à retenir avec les premières lettres des méthodes: call est une virgule (virgule, c), apply est un tableau (array, a). La méthode bind () renvoie une nouvelle fonction liée à l'objet spécifié.



JSR - Appeler / Appliquer

JSR - Lier

MDN - Appeler

MDN - Appliquer

MDN - Lier

4. Qu'est-ce que JSON et quelles sont ses méthodes?

JSON est un format de données textuelles basé sur la syntaxe d'objet JavaScript inventée par Douglas Crockford. Il est utilisé pour transférer des données sur le réseau et porte généralement l'extension .json et le type MIME application / json.

Analyse: convertit une chaîne JSON en objet.

JSON.parse(text)

Stringification: convertit un objet en chaîne JSON pour la transmission sur le réseau.

JSON.stringify(object)

JSR

MDN

5. Que fait la méthode Array.slice ()?

La méthode slice () renvoie les éléments de tableau sélectionnés sous la forme d'un nouveau tableau. Il renvoie les éléments commençant à l'index spécifié dans le premier argument et se terminant par, mais non compris, l'index spécifié dans le deuxième argument facultatif. Si le deuxième argument est absent, tous les éléments commençant à l'index spécifié dans le premier argument seront récupérés.

const arrayIntegers = [1, 2, 3, 4, 5]
const arrayIntegers1 = arrayIntegers.slice(0, 2) // [1, 2]
const arrayIntegers2 = arrayIntegers.slice(2, 3) // [3]
const arrayIntegers3 = arrayIntegers.slice(4) // [5]

Notez que cette méthode ne modifie pas le tableau d'origine, mais n'en renvoie qu'un sous-ensemble en tant que nouveau tableau.



JSR

MDN

6. Que fait la méthode Array.splice ()?

La méthode splice () est utilisée pour ajouter ou supprimer des éléments vers ou depuis un tableau. Le premier argument spécifie la position de départ pour ajouter ou supprimer des éléments, le second argument facultatif spécifie le nombre d'éléments à supprimer. Chaque argument suivant (troisième, etc.) est ajouté au tableau:

let arrayOriginal1 = [1, 2, 3, 4, 5]
let arrayOriginal2 = [1, 2, 3, 4, 5]
let arrayOriginal3 = [1, 2, 3, 4, 5]

let array1 = arrayOriginal1.splice(0, 2) //  [1, 2];   = [3, 4, 5]
let array2 = arrayOriginal2.slice(3) //  [4, 5];   = [1, 2, 3]
let array3 = arrayOriginal3.slice(3, 1, 'a', 'b', 'c') //  [4];   = [1, 2, 3, 'a', 'b', 'c']

Notez que la méthode splice () modifie le tableau d'origine et renvoie un tableau des éléments extraits.



JSR

MDN

7. Quelle est la différence entre slice () et splice ()?

Les principales différences sont les suivantes:



JSR

MDN - Slice

MDN - Épissure

8. Comment les objets et les cartes se comparent-ils?

Les objets sont similaires aux mappes en ce sens qu'ils vous permettent tous deux de définir des clés sur des valeurs, de récupérer des valeurs, de supprimer des clés et de déterminer si une valeur est présente par clé. Pour cette raison, les objets étaient utilisés comme cartes. Cependant, il existe certaines différences entre eux qui rendent l'utilisation de cartes plus préférable dans certains cas.

• Les clés d'objet ne peuvent être que des chaînes et des symboles, et les clés de carte peuvent être n'importe quelle valeur, y compris des fonctions et des objets
• Les clés de mappage sont ordonnées, mais les clés d'objet ne le sont pas. Ainsi, lors de l'itération, les clés de la carte sont renvoyées dans l'ordre dans lequel elles ont été ajoutées
• Vous pouvez obtenir la taille de la carte à l'aide de la propriété size et le nombre de propriétés d'objet est défini manuellement
• Une carte est une entité itérable, et pour itérer sur un objet, vous devez d'abord obtenir ses clés d'une manière ou d'une autre, puis les parcourir
• Lorsque vous utilisez un objet comme carte, n'oubliez pas que tout objet a un prototype, de sorte que les propres clés de la carte peuvent se chevaucher avec des clés définies par l'utilisateur. Par conséquent, Object.create (null) doit être utilisé pour créer un objet de carte, mais cette méthode est désormais rarement utilisée.
• L'objet est inférieur à la carte en termes de performances lorsqu'il s'agit d'ajouter / supprimer rapidement des clés

JSR

MDN

9. Quelle est la différence entre les opérateurs "==" et "==="?

JavaScript fournit deux façons de comparer les valeurs: strict (===,! ==) et abstrait (== ,! ==). Dans une comparaison stricte, les valeurs sont comparées telles quelles, et dans une comparaison laxiste, si nécessaire, une conversion implicite (transtypage) des types de valeur est effectuée. Les opérateurs stricts utilisent les règles suivantes pour comparer différents types de valeurs:

• Deux chaînes sont strictement égales lorsqu'elles ont le même jeu de caractères, la même longueur et les mêmes caractères aux mêmes positions
• Deux nombres sont strictement égaux si leurs valeurs sont égales. Il existe deux cas particuliers:
  
  
  
  
  • NaN ne vaut rien, y compris NaN
  • Les zéros positifs et négatifs sont égaux l'un à l'autre
  
  
  
• Les valeurs booléennes sont strictement égales lorsque les deux sont vraies ou fausses, c'est-à-dire vrai ou faux
• Deux objets sont strictement égaux s'ils font référence au même objet (emplacement mémoire)
• null === undefined renvoie false et null == undefined renvoie true

Quelques exemples:

0 == false // true
0 === false // false
1 == "1" // true
1 === "1" // false
null == undefined // true
null === undefined // false
'0' == false // true
'0' === false // false
[] == [] // 
[] === [] // false,      
{} == {} // 
{} === {} // false,      

JSR

MDN

10. Que sont les fonctions lambda ou fléchées?

Les fonctions fléchées sont une manière abrégée d'écrire des expressions fonctionnelles. Ils n'ont pas leurs propres objectifs, arguments, super et nouveau. Ces fonctions constituent une bonne alternative aux fonctions qui n'ont pas de méthode, mais ne peuvent pas être utilisées comme constructeurs.

function regularSum (x, y) {
    return x + y
}

const arrowSum = (x, y) => x + y

JSR

MDN

11. Pourquoi les fonctions sont-elles appelées objets de première classe?

En JavaScript, les fonctions sont des objets de première classe. Cela signifie que les fonctions peuvent être utilisées comme des variables régulières.

Par exemple, une fonction peut être transmise en tant qu'argument à une autre fonction, renvoyée en tant que valeur d'une autre fonction et affectée à une variable. L'exemple suivant affecte une fonction à un gestionnaire:

const handler = () => console.log(' -   ')
document.addEventListener('click', handler)

JSR

MDN

12. Qu'est-ce qu'une fonction de premier ordre?

Une fonction de premier ordre est une fonction qui ne prend pas une autre fonction comme argument et ne retourne pas une fonction comme valeur:

const firstOrder = () => console.log(' -   ')

JSR

MDN

13. Qu'est-ce qu'une fonction d'ordre supérieur?

Une fonction d'ordre supérieur est une fonction qui prend une autre fonction comme argument, ou renvoie une autre fonction comme valeur:

const firstOrderFun = () => console.log(' -   ')
const higherOrder = returnFirstOrderFun => returnFirstOrderFun()
higherOrder(firstOrderFunc)

JSR

MDN

14. Qu'est-ce qu'une fonction unaire?

Une fonction unaire (fonction monade) est une fonction qui ne prend qu'un seul argument:

const unaryFun = a => console.log(a + 10) //  10        

JSR

MDN

15. Qu'est-ce que le curry?

Le curry est le processus de conversion d'une fonction avec plusieurs paramètres en plusieurs fonctions avec un seul paramètre. Ce processus porte le nom du mathématicien Haskell Curry. Le curry transforme une fonction n-aire en plusieurs fonctions unaires (réduit l'arité de la fonction):

const sum = (a, b, c) => a + b + c
const currySum = a => b => c => a + b + c

currySum(1) //  : b => c => 1 + b + c
currySum(1)(2) //  : c => 3 + c
currySum(1)(2)(3) //   6

Le curry est utilisé pour activer la réutilisation du code (application de fonction partielle) et pour composer des fonctions.



JSR

16. Qu'est-ce qu'une fonction pure?

Une fonction pure est une fonction dont la valeur de retour dépend uniquement des arguments passés, sans effets secondaires. En termes simples, si vous appelez une fonction n fois avec n arguments et que la fonction renvoie toujours la même valeur, alors elle est propre:

//  
let numberArray = []
const impureAddNumber = number => numberArray.push(number)
// 
const pureAddNumber = number => argNumberArray => argNumberArray.concat([number])

console.log(impureAddNumber(1)) // 1
console.log(numberArray) // [1]
console.log(pureAddNumber(2)(numberArray)) // [1, 2]
console.log(numberArray) // [1]

Dans l'exemple ci-dessus, impureAddNumber n'est pas une fonction pure car la méthode push () renvoie la nouvelle longueur du tableau, qui est indépendante de l'argument passé. La deuxième fonction est pure car la méthode concat () concatène les deux tableaux sans effets secondaires et renvoie un nouveau tableau. Les fonctions pures sont essentielles pour les tests unitaires et n'ont pas besoin d'injection de dépendances. L'absence d'effets secondaires améliore la fiabilité de l'application en raison des connexions plus faibles entre ses éléments. L'une des incarnations de ce principe est le concept d'immuabilité, introduit dans ES6, qui préfère const à let.



JSR

MDN

17. À quoi sert le mot-clé "let"?

Le mot clé let déclare une variable locale à portée de bloc. La portée d'une telle variable est limitée par le bloc, l'opérateur ou l'expression dans lequel elle est utilisée. Les variables déclarées avec le mot-clé "var" ont une portée globale ou fonctionnelle dans laquelle elles sont définies:

let counter = 1
if (counter === 1) {
    let counter = 2
    console.log(counter) // 2
}
console.log(counter) // 1 ( counter,   ,   )

JSR

MDN

18. Quelle est la différence entre let et var?

Les principales différences sont les suivantes:



Quelques exemples:

function userDetails(username) {
    if (username) {
        console.log(salary)
        console.log(age)
        let age = 30
        var salary = 10000
    }
    console.log(salary) // 10000 (  )
    console.log(age) // SyntaxError: "age" is not defined (  )
}

JSR

MDN - laissez

MDN - var

19. Pourquoi le mot «laisser» a-t-il été choisi comme mot-clé?

Let est un opérateur mathématique utilisé par les premiers langages de programmation tels que Scheme et Basic. De nos jours, let est utilisé par un grand nombre de langages de programmation, ce mot est donc l'alternative la plus proche de l'abréviation "var" (variable).



JSR

MDN

20. Comment remplacer une variable dans un bloc de commutation?

Si vous essayez de remplacer une variable déclarée avec le mot clé "let" dans un bloc de commutation, vous obtiendrez une erreur:

let counter = 1
switch(x) {
    case 0:
        let name
        break
    case 1:
        let name // SyntaxError
        break
}

Pour résoudre ce problème, vous devez créer un nouveau bloc à l'intérieur du cas - une nouvelle portée lexicale:

let counter = 1
switch(x) {
    case 0: {
        let name
        break
    }
    case 1: {
        let name
        break
    }
}

JSR

MDN

21. Qu'est-ce qu'une zone morte temporaire?

Si vous tentez d'accéder aux variables déclarées avec le mot clé "let" ou "const" (mais pas "var") avant qu'elles ne soient définies (c'est-à-dire avant qu'elles ne reçoivent une valeur dans la portée actuelle), une exception ReferenceError sera levée (erreur de référence ). En d'autres termes, le fuseau horaire est le temps entre la création du contexte (scope) d'une variable et sa définition:

function someMethod () {
    console.log(counter1) // undefined
    console.log(counter2) // ReferenceError
    var counter1 = 1
    const counter2 = 2
}

MDN

22. Qu'est-ce qu'une expression de fonction immédiatement invoquée (IIFE)?

IIFE est une fonction qui est appelée immédiatement après la définition. La syntaxe d'une telle fonction peut ressembler à ceci (l'une des options, la plus courante):

(function () {
    // 
})()

// ,      
(() => {
    // 
})()

La principale raison d'utiliser l'IIFE est de garder les variables privées, car les variables déclarées à l'intérieur de l'IIFE ne sont pas accessibles depuis l'environnement extérieur:

(function () {
    var message = 'IIFE'
    console.log(message)
})()
console.log(message) // SyntaxError: "message" is not defined

JSR

MDN

23. Quels sont les avantages de l'utilisation des modules?

Entre autres, on peut citer:

• Améliorer la lisibilité et faciliter la maintenance du code
• Code réutilisable
• Maintenir propre l'espace de noms global

JSR

MDN

24. Qu'est-ce que la mémorisation ou la mémorisation?

La mémorisation est un moyen d'améliorer les performances d'une fonction en stockant les résultats précédemment reçus de cette fonction dans le cache. Chaque fois que la fonction est appelée, l'argument qui lui est passé devient l'index du cache. Si les données se trouvent dans le cache, elles sont renvoyées sans réexécuter la fonction. Sinon, la fonction est exécutée et le résultat est écrit dans le cache:

const memoAdd = () => {
    let cache = {}
    return value => {
        if (value in cache) {
            console.log('   ')
            return cache[value] //   , cache.value        ,     JavaScript     .    
        } else {
            console.log(' ')
            let result = value + 20
            cache[value] = result
            return result
        }
    }
}
//    memoAdd
const add = memoAdd()
console.log(add(20)) //   40
console.log(add(20)) //     40

25. Qu'est-ce que le levage?

Le levage est le processus qui consiste à déplacer des variables et des expressions de fonction au début de leur portée avant d'exécuter du code. Rappelez-vous: seules les variables et expressions elles-mêmes sont hissées, pas leur initialisation (c'est-à-dire que la déclaration de variable est hissée, pas l'affectation d'une valeur à celle-ci):

console.log(message) // undefined
var message = '!'

Pour l'interpréteur, ce code ressemble à ceci:

var message
console.log(message)
message = '!'

JSR

MDN

26. Qu'est-ce qu'une classe?

Les classes introduites dans ES6 sont le sucre syntaxique (wrapper, abstraction ou add-on) pour l'héritage de prototype (pour le prototype de fonction de constructeur). Exemple de fonction constructeur:

function Bike(model, color) {
    this.model = model
    this.color = color
}

Bike.prototype.getDetails = function () {
    return ' ' + this.model + '   ' + this.color + ' .'
}

Même exemple en utilisant la classe:

class Bike {
    constructor (color, model) {
        this.color = color
        this.model = model
    }

    getDetails () {
        return \` ${this.model}   ${this.color} .\`
    }
}

JSR

MDN

27. Qu'est-ce qu'une fermeture?

Une fermeture est une combinaison d'une fonction et de son environnement lexical. En termes simples, une fermeture se produit lorsqu'une fonction interne a accès aux variables déclarées dans une fonction externe. Une fermeture a une chaîne de trois portées:

• Propre portée
• Portée de la fonction externe
• Portée mondiale

const welcome = name => {
    const greet = message => {
        console.log(\`${message}, ${name}!\`)
    }
    return greet
}

const fun = welcome('')
fun('') // , !

JSR

MDN

28. Qu'est-ce qu'un module?

Les modules sont de petits morceaux de code indépendant et réutilisable qui sous-tendent de nombreux modèles de conception. La plupart des modules sont exportés sous forme d'objets, de fonctions ou de constructeurs.



JSR

MDN

29. Qu'est-ce que la portée?

La portée définit la disponibilité des variables, des fonctions et des objets à différents endroits du code lors de son exécution. En d'autres termes, la portée est la visibilité des variables et d'autres ressources dans le contexte actuel d'exécution de code.



MDN

30. Qu'est-ce qu'un technicien de service?

Un service worker est un script qui s'exécute indépendamment de la page Web sur laquelle il s'exécute et des actions de l'utilisateur. En fait, le service worker agit comme un serveur proxy entre l'application et le navigateur. Les principales capacités des techniciens de service sont les suivantes: s'assurer que l'application est hors ligne, synchroniser périodiquement en arrière-plan, notifications push, intercepter et traiter les requêtes réseau et gérer par programme le cache.



MDN

31. Comment interagissez-vous avec le modèle d'objet de document (DOM) à l'aide de techniciens de service?

Les techniciens de service n'ont pas d'accès direct au DOM. Cependant, ils peuvent interagir avec la page via l'interface postMessage, et la page peut modifier le DOM.



MDN - ServiceWorker

MDN - postMessage

32. Comment réutiliser les informations lors du redémarrage d'un service worker?

L'un des problèmes avec les techniciens de service est qu'ils arrêtent de s'exécuter lorsqu'ils ne sont pas utilisés et redémarrent en cas de besoin. Cela vous empêche d'ajouter globalement des gestionnaires d'événements d'extraction et de message. Pour réutiliser les informations, il est nécessaire de s'assurer que les agents de service interagissent avec une base de données indexée (IndexedDB) ou un stockage local (stockage local).



MDN

33. Qu'est-ce qu'une base de données indexée (IndexedDB)?

IndexedDB est une API de bas niveau pour stocker de grandes quantités de données structurées, y compris des fichiers et des objets blob, côté client. Cette interface utilise des index pour améliorer la vitesse de récupération des données.



JSR

MDN

34. Qu'est-ce que le stockage Web?

Le stockage Web est une interface qui vous permet de stocker des données sous forme de paires clé / valeur localement, c'est-à-dire dans le navigateur de l'utilisateur, d'une manière plus pratique que l'utilisation de cookies. Le stockage Web fournit deux mécanismes de stockage:

• Stockage local (stockage local) - stocke les données de l'utilisateur actuel pendant une durée illimitée
• Stockage de session - stocke les données tout au long de la session en cours, c'est-à-dire lors de la fermeture de l'onglet du navigateur, les données seront perdues

JSR

MDN

35. Qu'est-ce que postMessage?

postMessage est un moyen de communiquer entre différentes sources d'un objet window (par exemple, une page et la popup qu'elle génère (une fenêtre pop-up) ou une page et un iframe incorporé). En règle générale, les scripts d'une page n'ont pas accès à une autre page si cette page suit l'origine commune ou la politique de source unique (source - protocole, hôte et port).



MDN - postMessage

36. Que sont les cookies?

Un cookie est un petit morceau de données qui est stocké sur l'ordinateur d'un utilisateur pour une utilisation ultérieure par un navigateur. Les cookies sont stockés sous forme de paires clé / valeur:

document.cookie = 'username='

JSR

MDN

37. Pourquoi avons-nous besoin de cookies?

Les cookies sont utilisés pour enregistrer des informations sur l'utilisateur (il n'est pas recommandé de les utiliser pour stocker des informations confidentielles). Habituellement, ce processus se compose de deux étapes:

• Lors de la première visite de la page, le profil de l'utilisateur est enregistré dans un cookie
• En revisitant la page, le profil utilisateur est récupéré à partir du cookie

JSR

MDN

38. Quelles sont les capacités des cookies?

Par défaut, les cookies sont supprimés lorsque le navigateur est fermé, mais cela peut être modifié en définissant l'expiration en UTC:

document.cookie = 'username=; expires=Sat, 5 Sep 2020 12:00:00 UTC'

Par défaut, les cookies appartiennent à la page actuelle, mais cela peut également être modifié en définissant le chemin:

document.cookie = 'username=; path=/services'

JSR

MDN

39. Comment supprimer les cookies?

Vous pouvez supprimer les cookies en définissant le temps écoulé comme durée de vie. Dans ce cas, vous n'avez pas besoin de définir une valeur de cookie:

document.cookie = 'username=; expires=Sat, 05 Jun 2020 00:00:00 UTC; path=/;'

Veuillez noter que dans ce cas, il est nécessaire de déterminer le chemin pour supprimer le cookie correct. Certains navigateurs ne vous permettent pas de supprimer les cookies sans spécifier ce paramètre.



JSR

MDN

40. Quelle est la différence entre les cookies, le stockage local et le stockage de session?

Les principales différences sont les suivantes:



JSR - Cookies

MDN - Cookie

JSR - LocalStorage, SessionStotage

MDN - Stockage Web

41. Quelle est la principale différence entre le stockage local et le stockage de session?

Le stockage local est identique au stockage de session, sauf que dans le premier, les données sont enregistrées même lorsque vous fermez et redémarrez le navigateur, et dans le second, les données sont supprimées à la fin de la session (fermeture de l'onglet du navigateur).



JSR

MDN

42. Comment accéder au stockage Web?

L'objet window fournit des objets WindowLocalStorage et WindowSessionStorage qui ont respectivement les propriétés localStorage et sessionStorage. Ces propriétés créent une instance d'un objet Storage, avec laquelle vous pouvez écrire, récupérer et supprimer des données pour un domaine et un type de stockage spécifiques (session ou local):

//  
localStorage.setItem('data', document.querySelector('.data').value)
//  
localStorage.getItem('data')

JSR

MDN

43. Quelles méthodes le stockage de session fournit-il?

Le stockage de session fournit des méthodes pour lire, écrire et supprimer des données:

//  
sessionStorage.setItem('key', 'value')

//  
const data = sessionStorage.getItem('key')

//   
sessionStorage.removeItem('key')

//   
sessionStorage.clear()

JSR

MDN

44. Quel événement se produit lors de l'utilisation du stockage Web?

Lorsque le stockage change dans le contexte d'un autre document, l'événement de stockage est déclenché:

window.onstorage = function () {}

Un exemple de gestion de cet événement:

window.onstorage = event => {
    console.log(\`${event.key}  .
     : ${event.oldValue}.
     : ${event.newValue}.\`)
}

Cet événement vous permet de mettre en place une sorte de chat.



JSR

MDN

45. À quoi sert le stockage Web?

Le stockage Web est plus sécurisé et peut stocker plus de données que les cookies sans affecter les performances. De plus, aucune donnée n'est envoyée au serveur (dans le cas des cookies, les données sont incluses dans les en-têtes de requête et de réponse à chaque fois que le client accède au serveur). Par conséquent, cette manière de stocker les données est préférable aux cookies.



JSR

MDN

46. ​​Comment déterminer si un navigateur prend en charge le stockage Web?

Avant d'utiliser le stockage Web, il est recommandé de vérifier la prise en charge du navigateur pour cette interface:

if (typeof(Storage) !== 'undefined') {
    // 
} else {
    // -  
}

// 
if ('Storage' in window) {
    console.log('ok')
} else {
    console.warn(' ok')
}

Selon CanIUse , la prise en charge du stockage Web est de 98% aujourd'hui.



JSR

MDN

47. Comment déterminer si un navigateur prend en charge les techniciens de service?

Avant d'utiliser les techniciens de service, il est recommandé de vérifier la prise en charge du navigateur pour cette interface:

if (typeof(Worker) !== undefined) {
    // 
} else {
    // -  
}
// 
if ('Worker' in window) {
    console.log('ok')
} else {
    console.warn(' ok')
}

Selon CanIUse , le soutien aux travailleurs des services est de 94% aujourd'hui.



MDN

48. Donnez un exemple de web worker

Pour utiliser l'outil de travail Web, vous devez effectuer les opérations suivantes.

Créez un fichier pour le worker, par exemple get-current-time.js:

const getCurrentTime = () => {
    let time = new Date().toLocaleTimeString()
    postMessage(time)
    setTimeout(() => getCurrentTime(), 1000)
}

getCurrentTime()

La méthode postMessage () est utilisée pour envoyer des messages à la page.

Créez un objet de travail:

const worker = new Worker('get-current-time.js')

Après cela, nous traitons la réception des messages du travailleur:

<output></output>
<button></button>

worker
    .addEventListener('message', event => document.querySelector('output')
    .textContent = event.data)

Le worker continuera à traiter l'événement de message même après que le script externe a terminé son travail, il doit donc être arrêté de force:

document.querySelector('button')
    .addEventListener('click', () => worker.terminate())

Si vous définissez le worker sur indéfini, vous pouvez le réutiliser:

worker = undefined

MDN

49. Quelles sont les limites des web workers pour travailler avec le DOM

Les web workers étant créés dans un fichier séparé, ils n'ont pas accès aux objets suivants:

• fenêtre
• Document
• Objet parent - l'objet qui a démarré le travailleur

MDN

50. Qu'est-ce qu'une promesse?

Une promesse (communication) est un objet qui est soit exécuté avec une certaine valeur, soit rejeté avec une erreur. Les promesses sont résolues après un certain laps de temps ou après un certain événement. Une promesse peut avoir l'un des trois états suivants: en attente, honorée et rejetée.

Syntaxe de la promesse:

const promise = new Promise((resolve, reject) => {
    // 
})

// ,   ,    
const promise = Promise.resolve(value)
promise.then(value => {
    // 
})

Un exemple d'utilisation d'une promesse:

const promise = new Promise(resolve => {
    const timer = setTimeout(() => {
        resolve('  !')
        clearTimeout(timer)
    }, 5000);
}, reject => {
    reject('-   ')
})

promise
    .then(value => console.log(value))
    .catch(error => console.error(error))
    .finally(() => console.log(' ')) //     "  !"  5    " "

Algorithme de résolution de promesse:







JSR

MDN

51. Pourquoi des promesses sont-elles nécessaires?

Les promesses sont utilisées pour travailler avec du code asynchrone. Ils sont une alternative aux fonctions de rappel, évitant le soi-disant «enfer de rappel», rendant le code plus propre et plus lisible.



JSR

MDN

52. Nommez trois états possibles d'une promesse

Les promesses ont trois états:

• En attente: l'étape avant le démarrage de l'opération
• Réalisé: opération terminée avec succès
• Rejeté: l'opération a échoué. L'exception est levée

JSR

MDN

53. Qu'est-ce qu'une fonction de rappel?

Un rappel est une fonction qui est passée à une autre fonction en tant qu'argument. Cette fonction (interne) est appelée dans le parent (externe) pour effectuer une opération lorsqu'un événement spécifique se produit. Regardons un exemple simple:

function callback(name) {
    alert(\`, ${name}!\`)
}

function outer(cb) {
    const name = prompt(',   ')
    cb(name)
}
outer(callback)

Dans cet exemple, la fonction externe demande le nom de l'utilisateur et le stocke dans la variable de nom. Cette fonction passe ensuite le nom à la fonction de rappel, qui génère un message d'accueil avec le nom de l'utilisateur.



JSR

MDN

54. Pourquoi des rappels sont-ils nécessaires?

Les rappels sont nécessaires car JavaScript est un langage piloté par les événements. Cela signifie que, par exemple, au lieu d'attendre une réponse à une demande ou qu'un événement particulier soit traité, JavaScript continue de répondre à d'autres événements. Prenons un exemple dans lequel une fonction accède à l'interface et l'autre imprime un message sur la console:

function first () {
    //    API
    setTimeout(() => console.log('  '), 1000)
}

function second () {
    console.log('  ')
}

first()
second()
//    "  ",  "  "

Comme vous pouvez le voir, JavaScript n'attend pas la fin de la première fonction, mais continue d'exécuter le code. Par conséquent, les rappels sont utilisés pour simuler l'asynchronie, empêchant le blocage du thread principal du programme.



JSR

MDN

55. Qu'est-ce que l'enfer du rappel?

L'enfer de rappel est un anti-modèle où plusieurs fonctions de rappel sont imbriquées les unes dans les autres pour implémenter une logique asynchrone. Cette structure de code est difficile à comprendre et à maintenir. Cela pourrait ressembler à ceci:

function first () {
    return function second () {
        return function third () {
            return function fourth () {
                //  ..
            }
        }
    }
}

Cette approche du codage est considérée comme une mauvaise pratique, sauf en cas de currying, d'application partielle ou de composition de fonctions.



JSR

MDN

56. Que sont les événements envoyés par le serveur (SSE)?

Les événements envoyés par le serveur sont une technologie de notification push qui permet aux navigateurs de recevoir des données mises à jour du serveur via une connexion HTTP sans envoyer de requête. C'est l'un des moyens de communication entre le client et le serveur, lorsque les messages ne sont envoyés que par le serveur. Cette technologie est utilisée pour mettre à jour Facebook / Twitter, les prix en magasin, les fils d'actualité, etc.



JSR

MDN

57. Comment recevoir les messages (notifications ou événements) envoyés par le serveur?

L'objet EventSource est utilisé pour cela:

if('EventSource' in window) {
    const source = new EventSource('sse.js')
    source.addEventListener('message', event => document.querySelector('output')
        .textContent = event.data)
}

JSR

MDN

58. Comment puis-je vérifier la prise en charge du navigateur pour SSE?

Ceci est fait comme ceci:

if (typeof EventSource !== 'undefined') {
    // 
} else {
    // SSE  
}

// 
('EventSource' in window)
    ? console.log('ok')
    : console.warn('! ok')

Selon CanIUse, 95% des navigateurs sont actuellement pris en charge par SSE.



JSR

MDN

59. Quels événements se produisent lorsque vous travaillez avec SSE?

Voici une liste de ces événements:



JSR

MDN

60. Quelles sont les règles de base pour travailler avec des promesses?

Les règles de base pour travailler avec des promesses sont les suivantes:

• Une promesse est un objet contenant une méthode then () intégrée ou standard
• L'étape de l'attente d'une promesse se termine généralement par une étape de sa réalisation ou de son rejet
• Le statut d'une promesse remplie ou rejetée ne doit pas changer une fois qu'elle a été résolue
• Après avoir résolu une promesse, sa valeur ne devrait pas non plus changer.

JSR

MDN

61. Qu'est-ce qu'un rappel dans un rappel?

Vous pouvez imbriquer les rappels les uns dans les autres afin d'effectuer certaines opérations de manière séquentielle:

loadScript('/script1.js', script => {
    console.log(\` ${script} \`)

    loadScript('/script2.js', script => {
        console.log(\` ${script} \`)

        loadScript('/script3.js', script => {
            console.log(\` ${script} \`)
        })
    })
})

JSR

MDN

62. Qu'est-ce qu'une chaîne de promesses?

L'exécution séquentielle de plusieurs tâches asynchrones à l'aide de promesses est appelée une chaîne de promesses. Prenons un exemple:

new Promise((resolve, reject) => {
    const id = setTimeout(() => {
        resolve(1)
        clearTimeout(id)
    }, 1000)
}).then(result => {
    console.log(result) // 1
    return result * 2
}).then(result2 => {
    console.log(result2) // 2
    return result2 * 3
}).then(result3 => {
    console.log(result3) // 6
}).catch(error => console.error(error))

Algorithme d'exécution:

• La première promesse se résout avec une valeur de 1
• Après cela, la première méthode then () imprime cette valeur sur la console et la renvoie multipliée par 2
• Le second then () imprime le résultat du premier then () sur la console (2) et renvoie le résultat multiplié par 3
• Le dernier then () imprime le résultat du second then () sur la console (6)
• Le bloc catch est utilisé pour gérer les erreurs

JSR

MDN

63. Qu'est-ce que Promise.all ()?

Promise.all () est une promesse qui prend un tableau d'autres promesses comme argument et renvoie les résultats des promesses tenues ou une erreur si l'une est rejetée. Syntaxe:

Promise.all([Promise1, Promise2, Promise3])
    .then(results => console.log(results))
    .catch(error => console.error(error))

N'oubliez pas que l'ordre dans lequel les résultats sont déclenchés dépend de l'ordre des promesses dans le tableau.



JSR

MDN

64. Qu'est-ce que Promise.race ()?

Promise.race () retourne le résultat de la première promesse remplie ou rejetée passée sous forme de tableau de promesses:

const promise1 = new Promise((resolve, reject) => setTimeout(resolve, 500, ''))

const promise2 = new Promise((resolve, reject) => setTimeout(resolve, 100, ''))

Promise.race([promise1, promise2]).then(value => console.log(value)) // ""

JSR

MDN

65. Qu'est-ce qu'un régime strict?

Pour activer le mode strict, utilisez l'instruction 'use strict' (ou 'use strict') au début de tout le code ou d'une fonction individuelle. Le mode strict a été introduit dans ES5. Dans ce mode, certaines actions sont interdites et davantage d'exceptions sont levées.



JSR

MDN

66. Pourquoi avez-vous besoin d'un régime strict?

Le mode strict vous permet d'écrire du code plus sécurisé en empêchant de nombreuses erreurs de se produire. Par exemple, il interdit la création accidentelle de variables globales (sans le mot-clé, variable = valeur), l'affectation d'une valeur à une propriété en lecture seule, une propriété qui ne peut être obtenue qu'avec un getter, une propriété inexistante et une variable ou un objet inexistant. En mode non strict, aucune exception n'est levée dans tous ces cas.



JSR

MDN

67. Comment activer la sécurité stricte?

Le mode strict est activé par l'instruction 'use strict' (ou 'use strict') au début d'un code ou d'une fonction. Habituellement, cette instruction est indiquée au tout début du script, c'est-à-dire dans l'espace de noms global:

'use strict'
x = 3.14 // ReferenceError: "x" is not defined

Si 'use strict' est spécifié dans une fonction, alors le mode strict s'applique uniquement à cette fonction:

x = 3.14 //   
f() // ReferenceError: "y" is not defined

function f () {
    'use strict'
    y = 3.14
}

JSR

MDN

68. À quoi sert la double négation?

La double négation (!!) convertit la valeur en booléen. Si la valeur est false, alors false est renvoyé, sinon - true:

const x = 1
console.log(x) // 1
console.log(!!x) // true
const y = ''
console.log(y) // ''
console.log(!!str) // false

Remarque:!!! N'est pas un opérateur séparé, mais deux opérateurs! ..



MDN

JSR

69. À quoi sert l'opérateur de suppression?

Cet opérateur permet de supprimer les propriétés des objets et les valeurs de ces propriétés:

'use strict'
const user = {
    name: '',
    age: 30
}

delete user.age

console.log(user) // { name: "" }

delete user // SyntaxError: Delete of an unqualified identifier in strict mode

Notez qu'en mode non strict, une tentative de suppression d'un objet échouera silencieusement.

Puisqu'un tableau est également un objet, l'application de la suppression à un élément du tableau supprimera sa valeur et y écrira un l'index de l'élément supprimé du tableau sera conservé et la longueur du tableau ne changera pas.



JSR

MDN

70. A quoi sert le type d'opérateur?

Cet opérateur permet de définir le type d'une variable ou d'une expression:

typeof 1 // number
typeof [] // object
typeof '' // string
typeof (1 + 2) // number

typeof null // object
typeof NaN // number

JSR

MDN

71. Qu'est-ce qui n'est pas défini?

undefined est la valeur standard non définie (mais non manquante) (valeur par défaut) d'une variable à laquelle aucune valeur n'a été attribuée, ainsi qu'une variable non déclarée. C'est l'un des types de données primitifs:

let name
console.log(typeof name) // undefined
console.log(typeof age) // undefined

Cette valeur peut être affectée à une variable explicitement:

user = undefined

JSR

MDN

72. Qu'est-ce qui est nul?

null est une valeur qui représente l'absence d'une valeur, définie explicitement. C'est l'un des types de données primitifs. En utilisant null, vous pouvez supprimer la valeur d'une variable:

const user = null
console.log(typeof user) // object

JSR

MDN

73. Quelle est la différence entre null et undefined?

Les principales différences sont les suivantes:



JSR - JSR non défini

- null

MDN - MDN non défini

- nul

74. Qu'est-ce que eval?

La fonction eval () évalue la chaîne qui lui est passée. Une chaîne peut être une expression, une variable, un ou plusieurs opérateurs:

console.log(eval('1 + 2')) // 3

//   
const curryCalc = x => operator => y =>
    new Promise((resolve, reject) =>
        resolve(eval(\`x${operator}y\`))
    ).then(
        result => console.log(result),
        error => console.error(' !')
    )

curryCalc(1)('+')(2) // 3
curryCalc(4)('-')(3) // 1
curryCalc(5)('x')(6) //  !

Utilisation non recommandée.



JSR

MDN

75. Comment accéder à l'historique du navigateur?

Les informations sur l'historique des mouvements entre les pages du navigateur contiennent la propriété historique de l'objet window. Pour aller à la page précédente ou suivante, utilisez les méthodes back (), next () ou go ():

const goBack = () => {
    history.back()
    // 
    history.go(-1)
}

const goForward = () => history.forward()

MDN

76. Quels types de données existent en JavaScript?

Il existe 8 types principaux en JavaScript:

• nombre pour tout nombre: entier ou virgule flottante, les valeurs entières sont limitées à ± 2 ⁵³
• bigint pour les entiers de longueur arbitraire
• string pour les chaînes. Une chaîne peut contenir un ou plusieurs caractères, il n'y a pas de type de caractère distinct
• booléen pour vrai / faux
• null pour les valeurs inconnues - un type distinct avec une seule valeur nulle
• non défini pour les valeurs non attribuées - un type distinct ayant une valeur non définie
• objet pour des structures de données plus complexes
• symbole pour les identifiants uniques

JSR

MDN

77. Que fait isNaN ()?

La fonction isNaN () convertit la valeur en nombre et vérifie si elle est NaN.

isNaN('hello') // true
isNaN(100) // false

Une version plus robuste de cette fonctionnalité est la méthode Number.isNaN () introduite dans ES6.



JSR

MDN

78. Quelle est la différence entre les variables non déclarées et non définies?

Les principales différences sont les suivantes:



JSR

MDN

79. Que sont les variables globales?

Dans le navigateur, les fonctions globales et les variables déclarées avec le mot-clé "var", ou sans le mot-clé (en mode lax), deviennent des propriétés de l'objet global window (ne fonctionne pas dans les modules). Ces variables sont accessibles de n'importe où dans le programme. Il n'est pas recommandé d'utiliser des variables globales. Si vous avez besoin de créer une variable globale, il est préférable de le faire explicitement:

window.currentUser = {
    name: ''
}

// 
globalThis.currentUser = {
    name: ''
}

console.log(currentUser.name) // 

JSR

80. Quels problèmes pose la création de variables globales?

La création de variables globales pollue l'espace de noms global, ce qui peut provoquer des conflits entre les noms de variables. Cela rend également plus difficile le débogage et le test de votre code.



JSR

81. Qu'est-ce que NaN?

La propriété globale NaN est une valeur Not-a-Number. Plus précisément, NaN indique que la valeur est incorrecte, mais toujours un nombre. Par conséquent, typeof NaN renvoie nombre.

parseInt('bla') // NaN
Math.sqrt(-1) // NaN

MDN

82. Que fait isFinite ()?

La fonction globale isFinite () convertit l'argument en nombre et renvoie true s'il s'agit d'un nombre ordinaire (fini), c'est-à-dire pas NaN, Infinity (infini positif), -Infinity (infini négatif). Sinon, false est renvoyé.

isFinite(Infinity) // false
isFinite(-Infinity) // false
isFinite(NaN) // false

isFinite(100) // true

Il existe également une méthode Number.isFinite () qui, contrairement à isFinite (), ne convertit pas l'argument en nombre avant la vérification.



MDN

JSR

83. Qu'est-ce que le flux / propagation d'événements?

Le flux des événements (propagation des événements) est l'ordre dans lequel l'événement se produit sur la page. Lorsque vous cliquez sur un élément imbriqué dans d'autres éléments, avant que l'événement n'atteigne l'élément cible, il passera séquentiellement par tous ses ancêtres, à partir de l'objet de fenêtre global. Il y a trois étapes de propagation d'événements:

• De haut en bas - étape de capture ou de plongée
• Stade cible
• De bas en haut - l'étape de l'ascension ou de la montée (à ne pas confondre avec les variables de montée - levage)

JSR

84. Qu'est-ce que l'événement bouillonnant?

Le bullage est l'étape de propagation d'un événement, lorsque l'événement est d'abord enregistré sur l'élément cible, puis en remontant la chaîne depuis les ancêtres de cet élément jusqu'à l'élément le plus haut (extérieur) - l'objet de fenêtre global.



JSR

85. Qu'est-ce que l'immersion ou la capture d'événements?

L'immersion est l'étape au cours de laquelle un événement est déclenché, lorsqu'il s'inscrit pour la première fois sur l'élément le plus haut (extérieur) (l'objet de fenêtre global), puis descend dans la chaîne des ancêtres jusqu'à l'élément cible.



JSR

86. Comment soumettre un formulaire pour traitement?

Cela peut se faire de différentes façons:

function submitForm() {
    document.forms[0].submit()
}

form.onsubmit = function(event) {
    event.preventDefault()
    // 
}

form.addEventListener('submit', event => {
    event.preventDefault()
    // 
})

Tout bouton sur un formulaire est soumis par défaut, c'est-à-dire sert à soumettre un formulaire.



JSR

MDN

87. Comment puis-je obtenir des informations sur le système d'exploitation?

Ces informations sont contenues dans l'objet navigateur global. Certaines de ces informations peuvent être obtenues via sa propriété de plateforme:

console.log(navigator.platform)

MDN

88. Quelle est la différence entre les événements DOMContentLoaded et load?

L'événement DOMContentLoaded est déclenché lorsque le document HTML d'origine a été entièrement chargé et analysé sans attendre le chargement complet des feuilles de style, des images ou des cadres. L'événement de chargement se déclenche après le chargement complet de la page, y compris les ressources supplémentaires.



JSR

MDN - DOMContentLoaded

MDN - charge

89. Quelle est la différence entre les objets natifs, hôte (appartenant à l'exécution du code) et personnalisés?

Les objets natifs font partie du langage et sont définis dans la spécification ECMAScript. Ces objets sont, par exemple, Number, String, Function, Object, Math, RegExp, Date, etc. Les objets hôtes sont fournis par le navigateur ou un autre moteur d'exécution tel que Node.js. Ces objets sont, par exemple, window, document (DOM), XMLHttpRequest, Web API (pile d'appels, file d'attente de tâches), etc. Les objets utilisateur sont tous les objets créés dans le code, par exemple un objet contenant des informations sur l'utilisateur:

const user = {
    name: '',
    age: 30
}

JSR

MDN

90. Quels outils sont utilisés pour reporter le code?

Ces moyens sont:

• Outils de développement intégrés au navigateur tels que Chrome DevTools
• Expression du débogueur
• Bon vieux console.log ()

JSR

MDN - débogueur

MDN - Console

91. Quels sont les avantages et les inconvénients des promesses par rapport aux rappels?

Avantages:

• Évitez l'enfer des rappels
• Vous permet d'exécuter du code asynchrone de manière séquentielle en utilisant then ()
• Autoriser le code asynchrone à s'exécuter en parallèle à l'aide de Promise.all ()
• Résout de nombreux problèmes de rappel (appel trop tard ou trop tôt, plusieurs appels au lieu d'un, masquage d'erreur)

désavantages

• Le code devient plus difficile à écrire
• Pour prendre en charge les navigateurs plus anciens, un polyfill est nécessaire (il n'y a presque plus de navigateurs de ce type aujourd'hui)

JSR - Promesses

JSR - Rappels

MDN - Promise

MDN - Rappel

92. Quelle est la différence entre un attribut et une propriété d'élément?

Lorsque le navigateur charge la page, il analyse le HTML et génère des objets DOM à partir de celui-ci. Pour les nœuds d'élément, la plupart des attributs HTML standard deviennent automatiquement les propriétés des objets DOM. Ceux. l'attribut d'un élément est spécifié dans le balisage et sa propriété dans le DOM. Par exemple, pour une balise body avec un attribut id = "page", l'objet DOM aura une propriété body.id = "page".

<input type="text" value=" !">
//     : type  value

const input = document.querySelector('input')
//  
console.log(input.getAttribute('value'))
//  
console.log(input.value)

//   
input.setAttribute('value', ' !')
//   
input.value = ' !'

Notez que la spécification ECMAScript définit également des attributs pour les propriétés d'objet - [[Value]], [[Writable]], [[Enumerable]] et [[Configurable]].



JSR

93. Qu'est-ce qu'une politique de même origine (SOP)?

La politique d'origine partagée (même source) bloque l'accès aux données d'une autre source. La source est une combinaison de protocole, d'hôte et de port. Par défaut, le partage de ressources cross-origin (CORS) est interdit, c'est-à-dire les données sont fournies uniquement en réponse à une demande de la même source dans laquelle elles se trouvent. Ce comportement peut être modifié à l'aide d'en-têtes HTTP spéciaux.



JSR

MDN - SOP

MDN - CORS

94. Que fait le vide 0?

L'opérateur void évalue l'expression passée et renvoie undefined. Habituellement, lorsque nous cliquons sur un lien, le navigateur charge une nouvelle page ou recharge la page actuelle. Vous pouvez éviter cela en utilisant l'expression "void (0)":

<a href="javascript:void(0)" onclick="alert('!')">  !
</a>

Les recharges de page peuvent également être évitées avec un simple stub:

<a href="#"> </a>
//     "#"   URL   

MDN

95. JavaScript est-il un langage de programmation compilé ou interprété?

JavaScript lui-même est un langage de programmation interprété. Le moteur analyse le code, interprète chaque ligne et l'exécute. Cependant, les navigateurs modernes utilisent une technologie appelée juste à temps (compilation JIT) où le code est compilé (optimisé) avant d'être exécuté. Cela augmente le temps de préparation pour l'exécution du code, mais accélère considérablement l'exécution elle-même. Par exemple, V8, le moteur utilisé dans Chrome et Node.js, utilise l'interpréteur Ignition pour analyser le code et le compilateur TurboFan pour optimiser le code.



JSR

MDN

96. JavaScript est-il sensible à la casse?

Oui, JavaScript est sensible à la casse. Par conséquent, les mots-clés, les noms de variables, les fonctions et les objets doivent être identiques lors de leur utilisation. Par exemple, const somename et const someName sont des variables différentes, typeof (1) est un nombre et typeOf 1 est ReferenceError: typeOf n'est pas défini.



JSR

MDN

97. Java et JavaScript sont-ils liés?

Non, ce sont deux langages de programmation différents. Cependant, ils appartiennent tous deux à des langages orientés objet et, comme beaucoup d'autres langages, utilisent une syntaxe similaire (if, else, for, switch, break, continue, etc.). Fondamentalement, Java to JavaScript est un stratagème marketing.



JSR

MDN

98. Qu'est-ce qu'un événement?

Un événement est une réaction du navigateur à une action spécifique. Cette action peut être une action de l'utilisateur, par exemple, cliquer sur un bouton ou saisir du texte, charger une page, recevoir une réponse à une demande, etc. (Les actions qui déclenchent des événements ne sont pas nécessairement spécifiques à l'utilisateur). Les événements sont enregistrés pour un traitement ultérieur.

button.onclick = () => alert('!')

input.addEventListener('change', function() {
    p.textContent = this.value
})

window.onload = () => console.log('  ')

MDN

JSR

99. Qui a inventé JavaScript?

JavaScript a été créé par Brendan Eich pendant son séjour chez Netscape Communications. Le langage s'appelait à l'origine Mocha, puis il a été renommé LiveScript et était destiné à la fois à la programmation côté client et à la programmation côté serveur (où il devrait être appelé LiveWire).



JSR

MDN