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

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 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 Noeud, 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.

What are the data types in JavaScript?

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

• Numéro
• Chaîne
• Boolean
• Indéfini
• Null
• BigInt
• Symbole
• Objet

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

What are the built-in methods in 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. Numéro
   • àFixe
   • versChaîne
   • ...
2. Chaîne
   • en minuscules
   • commence avec
   • graphiqueÀ
   • ...
3. tableau
   • une fonction 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.

How to create an array in 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 carré supports[]. 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 Array constructeur. 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.

How to create an object in 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 Object constructeur. 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.

How do you debug JavaScript code?

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. Journal

Nous pouvons utiliser le console.log déclarations à 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é.

How to add JavaScript code in an HTML file?

Nous pouvons ajouter le fichier HTML JavaScript en utilisant le script étiqueter. 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>

What are 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.

How to read a 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.

How to create and delete a 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, le one clé de cookie 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 gardez la même date Jan 31 2023 même après le Jan 31 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.

What are the different JavaScript frameworks?

Il ya beaucoup de Frameworks JavaScript là-bas. React, Vue, Angular, etc., pour le développement de l'interface utilisateur. Express, Koa, Nest, etc., pour le développement côté serveur. SuivantJS, 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.

Closures in 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.

Hoisting in 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 il ne l'initialisera qu'à la ligne numéro 3.

Changez le var à let or const comme suit, et 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

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

Currying in 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));

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

Difference between document and window

Les window est l'objet le plus haut dans le 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 window objet sans window.

Les document est la partie de window chose. 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.

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

Difference between client-side and server-side

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.

Difference between innerHTML and innerText

Tant le innerHTML , 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>';

Ajouter un élément avec l'id title à votre 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 du span étiqueter. Alors le innerHTML prendra la chaîne HTML et la restituera en HTML normal.

Les innerText de l'autre côté prendra une chaîne normale et la rendra telle quelle. Il ne rendra aucun code HTML comme innerHTML. Changer la innerHTML à 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.

Difference between let and var

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

Les let est un bloc de portée et var est à portée de 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 en 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 accéder au a variable à l'extérieur du bloc également. 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 il en dehors de la fonction car il est à portée de fonction.

On peut redéclarer les variables en utilisant var mot clé mais nous ne pouvons pas redéclarer les variables en utilisant let mot-clé. 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 renverra 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.

Difference between session storage and local storage

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 sessionStorage , localStorage objets respectivement.

What is NaN in JavaScript?

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

What is Lexical scoping?

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.

What is passed by value and passed by reference?

Les passer par la valeur , passer 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 du a n'est pas modifié même si nous l'avons modifié à l'intérieur de 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 du arr est modifié lorsque nous le modifions à l'intérieur de 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.

What is memoization?

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.

What is the rest parameter?

Les paramètre de repos 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 les paramètre de repos utilisant l' opérateur de repos.

function sample(a, b, ...rest) {
  console.log("Rest parameter", rest);
}

sample(1, 2, 3, 4, 5);

Les reste paramètre 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.

What is object destructuring?

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);

What is array destructuring?

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);

What are event capturing and event bubbling?

Evènement capture , événement bouillonnant sont deux façons de propager des é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énement : 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 le cas où 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.

What are the Promises in JavaScript?

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

A 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 déroulé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 chaînage si nécessaire. Les données précédemment renvoyées seront acceptées dans le prochain then rappeler.

Explain the different types of scope in JavaScript

Il existe deux types de portée en JavaScript. Les portée mondiale , 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 périmètres locaux pour var , let, const respectivement.

What are self-invoking functions?

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.

What are arrow functions?

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 pas les leurs this contraignant. Le this le mot-clé à 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

What are callbacks?

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 passé comme un rappel au sampleL’ finished La fonction 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.,

What are the different types of errors?

Vérifions quelques erreurs dans JavaScript.

Erreur de référence: cette erreur se produira si la variable à laquelle nous accédons est disponible.

Erreur-type: JavaScript lancera 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.

Erreur de syntaxe: 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.

What are the different scopes of variables in JavaScript?

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

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

What are escape characters in 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 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..,

What are BOM and DOM?

Modèle d'objet de navigateur (BOM) : tous les navigateurs ont une nomenclature représentant la fenêtre actuelle du navigateur. Il contient notre objet window le plus haut qui est utilisé pour manipuler la fenêtre du navigateur.

Modèle d'objet de document (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.

What is a screen object?

Les écran objet 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 largeur, la taille, orientation, profondeur de pixel, 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 fréquemment posées Entretien Java questions et réponses.

Bon apprentissage 🙂