Questions et réponses d'entrevue JavaScript fréquemment posées

Publié: 2023-01-13

Avoir JavaScript dans votre portefeuille augmente les chances d'obtenir un rôle de développeur de logiciels. Cela dit, examinons les questions d'entretien JavaScript fréquemment posées.

JavaScript est l'un des langages les plus utilisés dans le développement Web. Il est utilisé pour développer presque n'importe quel type d'application maintenant.

Avant de passer aux questions de l'entretien, voyons les avantages d'apprendre JavaScript.

Javascript

JavaScript est un langage de programmation léger, interprété ou compilé juste à temps. C'est l'un des langages de base du World Wide Web. Vous connaissez les deux autres langages de base de www. Vous feriez mieux de les chercher si vous ne le faites pas.

JavaScript est principalement créé pour le Web. Mais ce n'est pas seulement pour le web maintenant. Avec l'aide d'environnements comme Node, Deno , etc., nous pouvons l'exécuter sur presque toutes les plateformes.

Voyons quelques avantages de celui-ci.

Avantages de JavaScript

  1. Facile à démarrer. Vous pouvez l'apprendre même sans aucune connaissance en codage.
  2. Grande communauté autour d'elle. Vous obtiendrez toute l'aide que vous voulez si vous êtes coincé n'importe où.
  3. Il existe de nombreuses bibliothèques/frameworks construits à l'aide de JavaScript, ce qui permet de développer des applications plus rapidement.
  4. Nous pouvons développer des applications frontend, backend, android, iOS, etc., avec JavaScript. Nous pouvons créer presque n'importe quel type d'application avec. Mais, il est plus robuste dans le développement Web.

Quels sont les types de données en JavaScript ?

Les types de données sont utilisés pour stocker différents types de données. Les types de données diffèrent d'un langage de programmation à l'autre. En JavaScript, nous avons 8 types de données. Voyons-les un par un.

  • Nombre
  • Chaîne
  • booléen
  • Indéfini
  • Nul
  • BigInt
  • Symbole
  • Chose

Tous les types de données sauf Object sont appelés valeurs primitives. Et ils sont immuables.

Quelles sont les méthodes intégrées dans JavaScript ?

Les méthodes intégrées dans JavaScript sont différentes pour chaque type de données. Nous pouvons accéder à ces méthodes intégrées en utilisant le type de données respectif. Voyons quelques méthodes intégrées pour différents types de données et structures de données.

  1. Nombre
    • versFixe
    • toString
    • …
  2. Chaîne
    • toLowerCase
    • commence avec
    • chartAt
    • …
  3. Déployer
    • filtre
    • carte
    • pour chaque
    • …

Il existe de nombreuses méthodes intégrées pour chaque type de données. Vous pouvez vérifier les références de toutes les méthodes intégrées de différents types de données et structures de données.

Comment créer un tableau en JavaScript ?

Les tableaux sont l'une des structures de données de base en JavaScript. Les tableaux peuvent contenir n'importe quel type de données car JavaScript est dynamique. Voyons comment créer des tableaux en JavaScript.

Nous pouvons créer un tableau en utilisant des crochets [] . Il est simple et rapide de créer des objets

 // Empty array const arr = []; // Array with some random values const randomArr = [1, "One", true]; console.log(arr, randomArr);

Nous pouvons créer un tableau en utilisant le constructeur Array . Les gens utilisent rarement le constructeur pour créer des tableaux dans des projets généraux.

 // Empty array const arr = new Array(); // Array with some random values const randomArr = new Array(1, "One", true); console.log(arr, randomArr);

Les tableaux JavaScript sont modifiables, c'est-à-dire que nous pouvons les modifier à notre guise après les avoir créés.

Comment créer un objet en JavaScript ?

Outre le tableau, l'objet est une autre structure de données de base en JavaScript. Les objets utilisent stocker les paires clé-valeur. La clé doit être une valeur immuable, alors que la valeur peut être n'importe quoi. Voyons comment créer des objets en JavaScript.

Nous pouvons créer des objets en utilisant des accolades {} . Il est simple et rapide de créer des objets.

 // Empty object const object = {}; // Object with some random values const randomObject = { 1: 2, one: "Two", true: false }; console.log(object, randomObject);

Nous pouvons créer des objets en utilisant le constructeur d' Object . Les gens l'utilisent rarement dans des projets généraux.

 // Empty object const object = new Object(); // Object with some random values const randomObject = new Object(); randomObject[1] = 2; randomObject["one"] = "Two"; randomObject[true] = false; console.log(object, randomObject);

Les objets JavaScript sont modifiables, c'est-à-dire que nous pouvons les modifier après la création, comme vous le voyez dans le 2ème exemple.

Comment déboguer le code JavaScript ?

Le débogage du code n'est pas simple. Et c'est différent d'un langage de programmation à l'autre, d'un projet à l'autre, etc.; Voyons les choses courantes utilisées pour déboguer JavaScript.

#1. Enregistrement

Nous pouvons utiliser les instructions console.log à plusieurs endroits dans notre code pour identifier le bogue. Le code arrêtera d'exécuter les lignes de code suivantes lorsqu'il y a un bogue dans la ligne précédente.

La journalisation est l'une des anciennes méthodes de débogage, qui est assez efficace pour les petits projets. C'est une technique de débogage courante pour tout langage de programmation.

#2. Outils de développement

JavaScript est principalement utilisé pour développer des applications Web. Ainsi, presque tous les navigateurs disposent désormais d'outils de développement qui aident à déboguer le code JavaScript.

L'une des méthodes de débogage les plus utilisées consiste à définir des points d'arrêt dans les outils de développement. Les points d'arrêt arrêtent l'exécution de JavaScript et donnent toutes les informations sur l'exécution en ce moment.

Nous pouvons définir plusieurs points d'arrêt autour de l'endroit où nous obtenons des erreurs et voir ce qui en est la cause. C'est le moyen le plus efficace de déboguer les applications Web JavaScript.

#3. IDE

Nous pouvons utiliser les IDE pour déboguer JavaScript. VS Code prend en charge le débogage avec des points d'arrêt. La fonctionnalité de débogage peut différer en fonction de l'IDE que vous utilisez. Mais la plupart des IDE auront cette fonctionnalité.

Comment ajouter du code JavaScript dans un fichier HTML ?

Nous pouvons ajouter le fichier HTML JavaScript en utilisant la balise script . Vous pouvez vérifier l'exemple ci-dessous.

 <!DOCTYPE html> <html lang="en"> <head> <title>Geekflare</title> </head> <body> <h1>Geekflare</h1> <script> // JavaScript code goes here console.log("This is JavaScript code"); </script> </body> </html>

Que sont les cookies ?

Les cookies sont des paires clé-valeur utilisées pour stocker de petites informations. L'information peut être n'importe quoi. Nous pouvons définir le délai d'expiration des cookies, qui seront supprimés après leur délai d'expiration. Ceux-ci sont largement utilisés pour stocker les informations des utilisateurs.

Les cookies ne seront pas effacés même si nous actualisons la page jusqu'à ce que nous les supprimions ou qu'ils expirent. Vous pouvez vérifier les cookies de n'importe quelle application Web/page Web dans n'importe quel navigateur en ouvrant les outils de développement.

Comment lire un cookie ?

Nous pouvons lire le cookie en JavaScript en utilisant document.cookie . Il renverra tous les cookies que nous avons créés.

 console.log("All cookies", document.cookie);

Il renverra une chaîne vide s'il n'y a pas de cookies.

Comment créer et supprimer un cookie ?

Nous pouvons créer les cookies en définissant la paire clé-valeur sur document.cookie . Voyons un exemple.

 document.cookie = "one=One;";

Dans la syntaxe ci-dessus, la clé de cookie one et One est sa valeur. Nous pouvons ajouter plus d'attributs au cookie comme le domaine, le chemin, l'expiration, etc. ; chacun d'eux doit être séparé par un point- virgule (;) . Tous les attributs sont facultatifs.

Voyons un exemple avec des attributs.

 document.cookie = "one=One;expires=Jan 31 2023;path=/;";

Dans le code ci-dessus, nous avons ajouté une date d'expiration et un chemin d'accès au cookie. Si la date d'expiration n'est pas fournie, le cookie sera supprimé après la session. Le chemin par défaut sera le chemin du fichier. Le format de la date d'expiration doit être en GMT.

Voyons comment créer plusieurs cookies.

 document.cookie = "one=One;expires=Jan 31 2023;path=/;"; document.cookie = "two=Two;expires=Jan 31 2023;path=/;"; document.cookie = "three=Three;expires=Jan 31 2023;path=/;";

Les cookies ne seront pas écrasés si la clé ou le chemin est différent lors de la configuration de plusieurs cookies. Si la clé et le chemin sont identiques, il écrasera le cookie précédent. Consultez l'exemple ci-dessous, qui écrasera le cookie défini précédemment.

 document.cookie = "one=One;expires=Jan 31 2023;path=/;"; document.cookie = "one=Two;path=/;";

Nous avons supprimé la date d'expiration du cookie et modifié la valeur.

Utilisez la date d'expiration à une date future lorsque vous testez le code pour qu'il fonctionne correctement. Si vous conservez la même date le 31 janvier 2023 même après le 31 janvier 2023 , les cookies ne seront pas créés.

Nous avons vu comment créer et mettre à jour les cookies. Voyons comment supprimer les cookies.

La suppression des cookies est facile. Changez simplement la date d'expiration du cookie en n'importe quelle date passée. Vérifiez l'exemple ci-dessous.

 // Creating cookies document.cookie = "one=One;expires=Jan 31 2023;path=/;"; document.cookie = "two=Two;expires=Jan 31 2023;path=/;"; document.cookie = "three=Three;expires=Jan 31 2023;path=/;"; // Deleting the last cookie document.cookie = "three=Three;expires=Jan 1 2023;path=/;";

Vous ne trouverez pas le dernier cookie dans les cookies car il est supprimé dans la dernière ligne du code. C'est tout pour le tutoriel min cookies.

Quels sont les différents frameworks JavaScript ?

Il existe de nombreux frameworks JavaScript. React, Vue, Angular, etc., pour le développement de l'interface utilisateur. Express, Koa, Nest, etc., pour le développement côté serveur. NextJS, Gatsby, etc., pour la génération de sites statiques. React Native, Ionic, etc., pour le développement d'applications mobiles. Nous avons mentionné certains des frameworks JavaScript ici. Vous pouvez trouver d'autres frameworks qui prendront beaucoup de temps à explorer. Explorez quand vous en avez besoin.

Fermetures en JavaScript

Une fermeture est une fonction regroupée avec sa portée lexicale et son environnement lexical parent. Avec les fermetures, nous pouvons accéder aux données de portée externe. Les fermetures sont formées lorsque les fonctions sont créées.

 function outer() { const a = 1; function inner() { // We can access all the data from the outer function scope here // The data will be available even if we execute this function outside the outer function // as inners' closure formed while creating it console.log("Accessing a inside inner", a); } return inner; } const innerFn = outer(); innerFn();

Les fermetures sont largement utilisées dans les applications JavaScript. Vous les avez peut-être déjà utilisés sans vous rendre compte qu'il s'agit de fermetures. Il y a beaucoup plus que cela à apprendre sur les fermetures. Assurez-vous d'avoir complètement appris ce concept.

Lever en JavaScript

Le levage est un processus en JavaScript où la déclaration des variables, des fonctions et des classes se déplace vers le haut de la portée avant d'exécuter le code.

 // Accessing `name` before declaring console.log(name); // Declaring and initializing the `name` var name = "Geekflare";

Si vous exécutez le code ci-dessus, vous ne verrez aucune erreur. Mais dans la plupart des langues, vous obtiendrez l'erreur. La sortie sera undefined car le levage ne fait que déplacer les déclarations vers le haut et ne l'initialisera qu'à la ligne numéro 3.

Modifiez la var en let ou const comme suit, puis réexécutez le code.

 // Accessing `name` before declaring console.log(name); // Declaring and initializing the `name` const name = "Geekflare";

Maintenant, vous obtiendrez l'erreur de référence indiquant que nous ne pouvons pas accéder à la variable avant de l'initialiser.

 ReferenceError: Cannot access 'name' before initialization

Donc, ici, let et const sont introduits dans ES6, qui ne sont pas accessibles avant d'être initialisés, comme le suggère l'erreur. En effet, les variables déclarées avec let ou const seront dans la zone morte temporelle (TDZ) jusqu'à ce que la ligne soit initialisée. Nous ne pouvons pas accéder aux variables de TDZ.

Curry en JavaScript

Currying est une technique pour convertir des fonctions avec de nombreux paramètres en moins de paramètres avec plusieurs callables. Avec lui, nous pouvons convertir une fonction callable add(a, b, c, d) en add(a)(b)(c)(d) callable. Voyons un exemple de la façon de le faire.

 function getCurryCallback(callback) { return function (a) { return function (b) { return function (c) { return function (d) { return callback(a, b, c, d); }; }; }; }; } function add(a, b, c, d) { return a + b + c + d; } const curriedAdd = getCurryCallback(add); // Calling the curriedAdd console.log(curriedAdd(1)(2)(3)(4));

Nous pouvons généraliser la fonction getCurryCallback qui sera utilisée pour différentes fonctions à convertir en curry callables. Vous pouvez vous référer à JavaScript Info pour plus de détails à ce sujet.

Différence entre document et fenêtre

La window est l'objet le plus haut du navigateur. Il contient toutes les informations sur la fenêtre du navigateur, comme l'historique, l'emplacement, le navigateur, etc. ; il est globalement disponible en JavaScript. Nous pouvons l'utiliser directement dans notre code sans aucune importation. Nous pouvons accéder aux propriétés et aux méthodes de l'objet window sans window.

Le document est la partie de l'objet window . Tout le code HTML chargé sur la page Web est converti en objet document. L'objet document fait référence à l'élément spécial HTMLDocument, qui aura des propriétés et des méthodes différentes comme tous les éléments HTML.

La window l'objet représente la fenêtre du navigateur et le document représente le document HTML chargé dans cette fenêtre du navigateur.

Différence entre côté client et côté serveur

Le côté client fait référence à l'utilisateur final utilisant l'application. Le côté serveur fait référence au serveur Web sur lequel l'application est déployée.

Dans la terminologie frontale, nous pouvons dire navigateur sur les ordinateurs des utilisateurs en tant que côté client et services cloud en tant que côté serveur.

Différence entre innerHTML et innerText

innerHTML et innerText sont les propriétés des éléments HTML. Nous pouvons modifier le contenu d'un élément HTML en utilisant ces propriétés.

Nous pouvons attribuer la chaîne HTML à innerHTML une propriété rendue comme du HTML normal. Vérifiez l'exemple ci-dessous.

 const titleEl = document.getElementById("title"); titleEl.innerHTML = '<span style="color:orange;">Geekflare</span>';

Ajoutez un élément avec le title de l'identifiant à votre code HTML et ajoutez le script ci-dessus au fichier JavaScript. Exécutez le code et voyez la sortie. Vous serez Geekflare en couleur orange. Et si vous inspectez l'élément, il sera à l'intérieur de la balise span . Ainsi, innerHTML prendra la chaîne HTML et la restituera en HTML normal.

Le innerText de l'autre côté prendra une chaîne normale et la restituera telle quelle. Il ne restituera aucun code HTML comme innerHTML . Remplacez innerHTML par innerText dans le code ci-dessus et vérifiez la sortie.

 const titleEl = document.getElementById("title"); titleEl.innerText = '<span style="color:orange;">Geekflare</span>';

Maintenant, vous verrez la chaîne exacte que nous avons fournie sur la page Web.

Différence entre let et var

Les mots clés let et var sont utilisés pour créer des variables en JavaScript. Le mot-clé let est introduit dans ES6.

Le let est de portée bloc et var est de portée fonction.

 { let a = 2; console.log("Inside block", a); } console.log("Outside block", a);

Exécutez le code ci-dessus. Vous obtiendrez une erreur sur la dernière ligne car nous ne pouvons pas accéder à let a dehors du bloc car il est limité au bloc. Maintenant, changez-le en var et exécutez-le à nouveau.

 { var a = 2; console.log("Inside block", a); } console.log("Outside block", a);

Vous n'obtiendrez aucune erreur car nous pouvons également accéder à a variable en dehors du bloc. Maintenant, remplaçons le bloc par une fonction.

 function sample() { var a = 2; console.log("Inside function", a); } sample(); console.log("Outside function", a);

Vous obtiendrez une erreur de référence si vous exécutez le code ci-dessus car nous ne pouvons pas accéder à var a it en dehors de la fonction car il est limité à la fonction.

Nous pouvons redéclarer les variables en utilisant le mot-clé var mais nous ne pouvons pas redéclarer les variables en utilisant le mot-clé let . Voyons un exemple.

 var a = "Geekflare"; var a = "Chandan"; console.log(a);
 let a = "Geekflare"; let a = "Chandan"; console.log(a);

Le premier morceau de code ne générera aucune erreur et la valeur est a sera remplacée par la dernière valeur attribuée. Le 2ème morceau de code générera une erreur car nous ne pouvons pas redéclarer les variables en utilisant let .

Différence entre le stockage de session et le stockage local

Le stockage de session et le stockage local sont utilisés pour stocker des informations sur les ordinateurs des utilisateurs accessibles sans Internet. Nous pouvons stocker les paires clé-valeur à la fois dans le stockage de session et dans le stockage local. La clé et la valeur seront converties en chaînes si vous fournissez un autre type de données ou une autre structure de données.

Le stockage de session sera effacé après la fin de la session (lorsque le navigateur est fermé). Le stockage de l'emplacement ne sera pas effacé tant que nous ne l'aurons pas effacé.

Nous pouvons accéder, mettre à jour et supprimer le stockage de session et le stockage de localisation avec les objets sessionStorage et localStorage respectivement.

Qu'est-ce que NaN en JavaScript ?

Le NaN est abrégé en Not-a-Number . Cela signifie que quelque chose n'est pas un nombre légal/valide en JavaScript. Il y a des cas où nous obtiendrons NaN en sortie comme 0/0 , undefined * 2 , 1 + undefined , null * undefined etc.,

Qu'est-ce que la portée lexicale ?

La portée lexicale fait référence à l'accès aux variables à partir de la portée de ses parents. Disons que nous avons une fonction avec deux fonctions internes. La fonction la plus interne peut accéder aux variables de portée de ses deux fonctions parentes. De même, la fonction de 2ème niveau peut accéder à la portée de la fonction la plus externe. Voyons cela dans un exemple.

 function outermost() { let a = 1; console.log(a); function middle() { let b = 2; // `a` are accessible here console.log(a, b); function innermost() { let c = 3; // both `a` and `b` are accessible here console.log(a, b, c); } innermost(); } middle(); } outermost();

JavaScript utilise une chaîne de portée pour trouver la variable lorsque nous y accédons quelque part dans le code. Tout d'abord, il vérifiera la variable dans la portée actuelle, puis la portée parente jusqu'à la portée globale.

Qu'est-ce qui est passé par valeur et passé par référence ?

Le passage par valeur et le passage par référence sont deux façons de passer les arguments à une fonction en JavaScript.

Passer par valeur : il crée une copie des données d'origine et la transmet à la fonction. Ainsi, lorsque nous apportons des modifications à la fonction, cela n'affectera pas les données d'origine. Vérifiez l'exemple ci-dessous.

 function sample(a) { // changing the value of `a` a = 5; console.log("Inside function", a); } let a = 3; sample(a); console.log("Outside function", a);

Vous verrez que la valeur d'origine de a n'est pas modifiée même si nous l'avons modifiée dans la fonction.

Passer par référence : il passe la référence des données à la fonction. Ainsi, lorsque nous apportons des modifications à la fonction, cela modifie également les données d'origine.

 function sample(arr) { // adding a new value to the array arr.push(3); console.log("Inside function", arr); } let arr = [1, 2]; sample(arr); console.log("Outside function", arr);

Vous verrez que la valeur d'origine de arr est modifiée lorsque nous la modifions dans la fonction.

Remarque : tous les types de données primitifs sont passés par valeur et les non primitifs sont passés par référence.

Qu'est-ce que la mémorisation ?

La mémorisation est une technique qui stocke les valeurs calculées dans des caches et les utilise lorsque nous en avons à nouveau besoin sans les recalculer. Cela accélérera l'exécution du code si le calcul est très lourd. Il y a un compromis de stockage qui n'est pas un gros problème par rapport au temps.

 const memo = {}; function add(a, b) { const key = `${a}-${b}`; // checking whether we computed the value already or not if (memo[key]) { console.log("Not computing again"); return memo[key]; } // adding the newly computed value to cache // here cache is a simple global object memo[key] = a + b; return memo[key]; } console.log(add(1, 2)); console.log(add(2, 3)); console.log(add(1, 2));

C'est un exemple simple qui démontre la mémorisation. Ici, ajouter deux nombres n'est pas un calcul lourd et difficile. C'est juste pour la démo.

Quel est le paramètre de repos ?

Le paramètre rest est utilisé pour collecter tous les paramètres restants dans une fonction. Disons que nous avons une fonction qui accepte un minimum de 2 arguments et peut accepter n'importe quel nombre de paramètres au maximum. Comme nous n'avons pas le nombre maximum d'arguments, nous pouvons collecter les 2 premiers paramètres avec des variables normales et tous les autres avec le paramètre rest en utilisant l' opérateur rest .

 function sample(a, b, ...rest) { console.log("Rest parameter", rest); } sample(1, 2, 3, 4, 5);

Le paramètre rest sera un tableau des trois derniers arguments dans l'exemple ci-dessus. Avec cela, nous pouvons avoir n'importe quel nombre de paramètres pour une fonction.

Une fonction ne peut avoir qu'un seul paramètre de repos. Et le paramètre de repos doit être le dernier dans l'ordre des paramètres.

Qu'est-ce que la déstructuration d'objet ?

La déstructuration d'objet est utilisée pour accéder aux variables de l'objet et les affecter à des variables portant les mêmes noms que les clés d'objet. Voyons un exemple.

 const object = { a: 1, b: 2, c: 3 }; // Object destructuring const { a, b, c } = object; // Now, a, b, c will be used as normal variables console.log(a, b, c);

Nous pouvons changer les variables des variables déstructurées dans la même ligne comme suit.

 const object = { a: 1, b: 2, c: 3 }; // Changing the names of `a` and `b` const { a: changedA, b: changedB, c } = object; // Now, changedA, changedB, c will be used as normal variables console.log(changedA, changedB, c);

Qu'est-ce que la déstructuration de tableau ?

La déstructuration d'un tableau permet d'accéder aux variables du tableau et de les affecter à des variables. Voyons un exemple.

 const array = [1, 2, 3]; // Array destructuring // It's based on the index of the array const [a, b, c] = array; // Now, we can use a, b, c as normal variables console.log(a, b, c);

Qu'est-ce que la capture d'événements et le bouillonnement d'événements ?

La capture d'événements et le bouillonnement d'événements sont deux moyens de propagation d'événements dans HTML DOM. Disons qu'il y a deux éléments HTML, l'un dans l'autre. Et un événement se produit sur l'élément intérieur. Désormais, le mode de propagation des événements décidera de l'ordre d'exécution de ces événements.

Bulle d'événements : il exécute d'abord le gestionnaire d'événements sur l'élément, puis son élément, puis il remonte jusqu'à l'élément le plus haut. C'est le comportement par défaut de tous les événements.

Capture d' événement : nous devons spécifier dans l'événement que nous devons utiliser ce type de propagation d'événement. Nous pouvons le spécifier lors de l'ajout de l'écouteur d'événement. Les événements s'exécuteront dans l'ordre suivant si la capture d'événements est activée.

  1. Les événements commencent à s'exécuter à partir de l'élément le plus haut jusqu'à ce que l'élément cible se termine.
  2. L'événement sur l'élément cible sera exécuté à nouveau.
  3. La propagation de l'événement bouillonnant se produira à nouveau jusqu'à ce que l'élément le plus haut soit en place.

Nous pouvons arrêter la propagation de l'événement en appelant event.stopPropogation une méthode dans le gestionnaire d'événements.

Quelles sont les Promesses en JavaScript ?

L'objet Promise est utilisé pour les opérations asynchrones qui se termineront à l'avenir par un état de réussite ou d'échec.

Une Promise peut être dans l'un des états suivants.

  1. pending – lorsque l'opération est toujours en cours.
  2. fulfilled - lorsque l'opération s'est terminée avec succès. Nous aurons des résultats (le cas échéant) dans l'état de réussite.
  3. rejected – lorsque l'opération se termine par un échec. Nous aurons la raison (l'erreur) pour laquelle cela a échoué.

Voyons deux exemples de cas de réussite et d'échec.

 // Promise which will complete successfully const successPromise = new Promise((resolve, reject) => { setTimeout(() => { resolve({ message: "Completed successfully" }); }, 300); }); successPromise .then((data) => { console.log(data); }) .catch((error) => { console.log(error); }); // Promise which will complete with failure state const failurePromise = new Promise((resolve, reject) => { setTimeout(() => { reject(new Error("Failing the promise for testing")); }, 300); }); failurePromise .then((data) => { console.log(data); }) .catch((error) => { console.log(error); });

Vous pouvez en avoir plusieurs then enchaîner si nécessaire. Les données précédemment renvoyées seront acceptées then du prochain rappel.

Expliquer les différents types de portée en JavaScript

Il existe deux types de portée en JavaScript. La portée globale et la portée locale .

Vous avez peut-être également entendu parler de la portée de la fonction et de la portée du bloc. Ce sont des étendues locales pour var et let , const respectivement.

Que sont les fonctions d'appel automatique ?

Les fonctions auto-invoquantes sont des fonctions sans nom qui seront exécutées immédiatement après la création. Voyons quelques exemples.

 // Without any parameters (function sayHello() { console.log("Hello, World!"); })(); // With parameters (function add(a, b) { console.log("Sum", a + b); })(1, 2);

Nous pouvons même passer les arguments aux fonctions auto-invoquantes comme vous l'avez vu dans l'exemple.

Que sont les fonctions fléchées ?

La fonction fléchée est un sucre syntaxique par rapport à la fonction normale avec quelques modifications. Ils se comportent comme des fonctions normales dans les cas d'utilisation généraux. Les fonctions fléchées sont utiles lorsque nous devons avoir des rappels. Voyons sa syntaxe.

 // arrow functions will return by default if it doesn't have any brackets let add = (a, b) => a + b; console.log(add(1, 2));

Il existe quelques différences entre les fonctions fléchées et les fonctions normales.

  • Les fonctions fléchées n'ont this leur propre liaison. Le mot clé this à l'intérieur de la fonction de flèche fait référence à sa portée parent this .
  • Les fonctions fléchées ne peuvent pas être utilisées comme fonctions constructeur

Que sont les rappels ?

Un rappel est une fonction transmise à une autre fonction appelée à l'intérieur de cette fonction. L'utilisation de rappels est une chose courante en JavaScript. Voyons un exemple.

 function sample(a, b, callback) { const result = a + b; callback(result); } function finished(result) { console.log("Finished with", result); } sample(1, 2, finished);

La fonction finished est transmise en tant que rappel à l' sample . La fonction finished est invoquée avec le résultat après avoir effectué une action. Vous verrez l'utilisation des rappels principalement dans les opérations asynchrones comme les promesses, setTimeout, etc.,

Quels sont les différents types d'erreurs ?

Vérifions quelques erreurs dans JavaScript.

ReferenceError : cette erreur se produira si la variable à laquelle nous accédons est disponible.

TypeError : JavaScript génère cette erreur si l'erreur ne correspond pas à d'autres types d'erreurs. Cela se produira également lorsque nous essaierons d'effectuer une action qui n'est pas compatible avec les données.

SyntaxError : cette erreur se produira si la syntaxe JavaScript n'est pas correcte.

Il existe également d'autres types d'erreurs. Mais ce sont les types d'erreurs courants en JavaScript.

Quelles sont les différentes portées des variables en JavaScript ?

Il existe deux portées de variables en JavaScript. Les variables déclarées à l'aide du mot-clé var auront une portée de fonction et les variables déclarées avec let et const auront la portée de bloc .

Reportez-vous à la 17e question pour plus de détails sur la portée de ces variables.

Que sont les caractères d'échappement en JavaScript ?

La barre oblique inverse est le caractère d'échappement en JavaScript. Il est utilisé pour imprimer certains caractères spéciaux que nous ne pouvons pas imprimer en général. Disons que nous voulons imprimer une apostrophe (') à l'intérieur d'une chaîne, ce que nous ne pouvons pas faire normalement car la chaîne se terminera à la deuxième apostrophe. Dans ce cas, nous utiliserons le caractère d'échappement pour éviter de terminer la chaîne à ce point.

 const message = 'Hi, I\'m Geekflare'; console.log(message);

Nous pouvons obtenir la sortie ci-dessus sans utiliser de caractère d'échappement en remplaçant les apostrophes simples extérieures par des apostrophes doubles. Mais ce n'est qu'un exemple d'utilisation d'un caractère d'échappement. Il y a d'autres caractères pour lesquels nous avons définitivement besoin d'un caractère d'échappement comme \n , \t , \\ etc.,

Qu'est-ce que la nomenclature et le DOM ?

Browser Object Model (BOM) : tous les navigateurs ont un BOM représentant la fenêtre de navigateur actuelle. Il contient notre objet window le plus haut qui est utilisé pour manipuler la fenêtre du navigateur.

Document Object Model (DOM) : les navigateurs créent le DOM lorsque le HTML est chargé dans l'arborescence. Nous pouvons manipuler les éléments HTML à l'aide de l'API DOM.

Qu'est-ce qu'un objet écran ?

L'objet écran est l'une des propriétés de l'objet fenêtre global. Il contient différentes propriétés de l'écran sur lequel la fenêtre actuelle du navigateur est rendue. Certaines des propriétés sont width , height , orientation , pixelDepth , etc.

Conclusion

Il peut y avoir des questions de suivi pour toutes les questions ci-dessus. Donc, vous devez préparer les concepts autour de toutes les questions ci-dessus.

Vous pouvez également explorer certaines questions et réponses d'entretien Java fréquemment posées.

Bon apprentissage