who wants to be a javascriptaire
1.0.0
Façon amusante d'apprendre JavaScript pour vos interviews Frontend / Web Coding. Toutes les questions sont répondues ici dans le texte et ont également une vidéo sur notre chaîne YouTube. Cliquez sur
N'hésitez pas à nous joindre sur nos plateformes sociales! ?
Discorde || Instagram || Twitter || Tiktok || Blog || Facebook
Soutien
S'il vous plaît, jouez à ce projet et partagez-le avec les autres pour montrer votre soutien. Suivez-moi ❤️ pour les mises à jour sur les futurs projets et tutoriels!
Bases linguistiques - Arrays - Date et heure - JavaScript orienté objet - Modules - Divers
console . log ( new Date ( 2023 , 1 , 31 ) )Tue Jan 31 2024Tue Jan 31 2023Fri Mar 03 2023ErrorEn JavaScript, alors que la construction de dates à l'aide des mois d'objets date est basée à 0. Ce qui signifie que 0 est pour janvier et 1er pour février.
Ainsi, dans ce cas, nous demandons à JavaScript de fixer une date du 2023 le 31 février qui n'existe pas.
Mais au lieu de lancer une erreur, JavaScript le débordera au mois prochain qui est mars.
Et depuis février 2023, n'a que 28 jours, le code débordera de 3 jours, ce qui est le 3 mars 2023.
var username = 'kirandash'
var username = 'bgwebagency'
console . log ( username )bgwebagencykirandashReferenceErrorSyntaxError Nous pouvons déclarer la même variable plusieurs fois en utilisant le mot-clé var . Et la variable conservera la valeur qui lui a été attribuée à la fin.
Mais nous ne pouvons pas déclarer la même variable plusieurs fois en utilisant let ou const ou const
const user = {
username : 'kirandash' ,
updateUsername : newName => {
this . username = newName
} ,
}
user . updateUsername ( 'bgwebagency' )
console . log ( user . username )bgwebagencyReferenceErrorkirandashundefined Parce que la fonction updateUsername ne fonctionne pas correctement et ne parvient pas à mettre à jour le username de l' user .
La fonction updateUsername dans object utilisateur est une fonction flèche et n'est pas liée à l'objet user .
Ainsi, le this clé dans la fonction UpdateUserName ne fait pas référence à l'objet user , mais fait référence à la portée globale.
Pour résoudre ce problème, nous devons changer la fonction flèche en une fonction normale.
const len1 = 'kiran' . length
const len2 = '?' . length
console . log ( len1 , len2 )5, 25, 15, undefined5, SyntaxErrorDans JavaScript, la propriété de longueur de chaîne renvoie le nombre d'octets et non le nombre de caractères comme nous l'attendons.
Un emoji est un caractère Unicode qui est codé en deux octets. Par conséquent, la réponse est 2 pour cette question.
La longueur de chaîne pour kiran renvoie 5 car dans une chaîne, chaque caractère est de 1 octet.
console . log ( undefined == null , undefined === null )true, truetrue, falsefalse, falsefalse, truePermettez-moi d'abord d'expliquer la différence entre un opérateur égal et strict égal.
L'opérateur égal ne vérifie que si les deux valeurs sont égales. L'opérateur strict égal vérifie si la valeur et le type sont égaux.
Ainsi, dans ce code, la première instruction undefined == null renvoie true car les undefined et null ont la même valeur qui est vide.
Mais la deuxième déclaration undefined === null renvoie false . Étant donné que typeof undefined n'est undefined , tandis que typeof null est un object .
Vous vous demandez peut-être pourquoi typeof null est un object lorsque null est essentiellement un type de données primitif. C'est essentiellement une erreur en JavaScript depuis le début.
Maintenant, un autre astuce pour vous: lorsque vous souhaitez définir une valeur vide pour une variable Use null au lieu d' undefined . Étant donné que undefined est principalement utilisé pour vérifier si une variable n'a aucune valeur qui lui est attribuée.
function getFruits ( x , ... multi , y ) {
console . log ( x , y , multi ) ;
}
getFruits ( "?" , "?" , "?" , "?" , "?" )? ? ["?", "?", "?"]SyntaxErrorLes opérateurs de repos ont été ajoutés dans le cadre de la fonction ES6.
Il faut tous les arguments transmis à une fonction et le met dans un tableau.
Si plusieurs arguments sont transmis à une fonction, l'opérateur REST doit arriver à la fin. C'est pourquoi cet extrait de code lancera une erreur.
Pour résoudre ce problème, veuillez déplacer l'opérateur de repos jusqu'à la fin, puis cela devrait fonctionner.
let x = Number . NEGATIVE_INFINITY
let y = Number . POSITIVE_INFINITY
let z = x + y
console . log ( z )0undefinedNaNTypeErrorNégatif_infinity et positif_infinity sont des propriétés de l'objet nombre en JavaScript qui représente le concept mathématique de l'infini négatif et de l'infini positif.
Lorsque vous ajoutez Number.negative_infinity et numéro.Positive_infinity, le résultat est nan.
L'ajout d'une valeur infinie positive à une valeur infinie négative n'entraîne pas une valeur numérique significative.
Donc, dans ce cas, Z sera Nan.
Notez que le code ne lancera pas de TypeError, car JavaScript est capable d'effectuer l'opération d'addition entre numéro.negative_infinity et numéro.Positive_infinity.
console . log ( 'BG Web Agency' === NaN , isNaN ( 'BG Web Agency' ) )true, truefalse, truetrue, falsefalse, false Utilisation === NaN pour vérifier si une valeur est un nombre ne fonctionnera pas.
Dans JavaScript, NaN (pas un nombre) est une valeur spéciale qui représente un nombre non valide.
Nan n'est égal à rien, y compris lui-même, donc l'expression "BG Web Agency" === NaN renverra toujours false .
Pour vérifier si une valeur est un nombre en JavaScript, vous pouvez utiliser la fonction isNaN() . Cette fonction renvoie true si l'argument qui lui est transmis est NaN , ou s'il ne peut pas être converti en nombre.
console . log ( isFinite ( Infinity ) , isNaN ( Infinity ) )false, falsefalse, truetrue, falsefalse, false La fonction isFinite() est utilisée pour déterminer si une valeur donnée est un nombre fini.
Il renvoie false si la valeur est NAN, Infinity ou -Infinity, et vrai si la valeur est un nombre fini.
Ainsi, dans cet exemple, isFinite(Infinity) reviendra faux car l'infini n'est pas un nombre fini.
D'un autre côté, la fonction isnan () est utilisée pour déterminer si une valeur donnée n'est pas un nombre (nan).
Il renvoie True si la valeur est nan et fausse si la valeur est un nombre ou tout autre type de données.
Ainsi, dans cet exemple, isNaN(Infinity) reviendra également faux parce que l'infini n'est pas NAN.
Par conséquent, utilisez toujours une fonction isFinite au lieu de la fonction isNaN lorsque vous souhaitez valider si un nombre est fini
const user = {
name : 'John' ,
age : 30 ,
getName : ( ) => {
return this . name
} ,
getAge : function ( ) {
return this . age
} ,
}
const getName = user . getName
const getAge = user . getAge
console . log ( getName ( ) )
console . log ( getAge ( ) ) La fonction getName Arrow utilise this mot-clé pour se référer à la propriété Nom de l'objet, mais parce que les fonctions this ont une liaison lexicale, la valeur de this mot-clé à l'intérieur de la fonction Arrow sera l'objet global qui est window d'un navigateur ou global dans node.js.
Puisqu'il n'y a pas de propriété de nom sur l'objet global , la fonction renvoie undefined .
La fonction getAge utilise une expression de fonction régulière et se réfère correctement à la propriété d'âge de l'objet user à l'aide this mot-clé.
Mais lorsque getAge est attribué à la variable getAge , il perd la référence à l'objet user , donc lorsque la fonction est appelée à l'aide getAge() , cela se réfère à nouveau à l'objet global, et comme il n'y a pas de propriété d'âge sur l'objet global, la fonction renvoie indéfinie.
for ( var i = 0 ; i < 3 ; i ++ ) {
setTimeout ( function ( ) {
console . log ( i )
} , 0 )
}Une fermeture est une fonction qui conserve l'accès aux variables dans sa portée extérieure, même après le retour de la fonction extérieure.
Dans cet exemple, la réponse est B, car la fonction Settimeout est asynchrone et ne s'exécute pas immédiatement.
Au moment où la fonction de rappel transmise à Settimeout est exécutée, la boucle est déjà terminée et la variable I a une valeur de 3.
Par conséquent, chaque appel à console.log (i) à l'intérieur de la fonction de rappel imprimera 3.
Pour résoudre ce problème et imprimer 0, 1, 2, nous pouvons utiliser un iife (expression de fonction immédiatement invoquée) pour créer une nouvelle portée pour chaque itération de la boucle.
Cela crée une nouvelle variable J à l'intérieur de chaque iife, avec sa propre copie de la valeur actuelle de I à cette itération de la boucle.
Lorsque la fonction de rappel transmise à Settimeout est exécutée, elle a accès à la variable J dans sa fermeture, qui a la valeur attendue de 0, 1 ou 2 pour chaque itération de la boucle.
function add ( x ) {
return function ( y ) {
if ( y !== undefined ) {
x += y
return arguments . callee
} else {
return x
}
}
}
console . log ( add ( 1 ) ( 2 ) ( 3 ) ( ) )La bonne réponse est A. Le code définit une fonction d'ajout qui prend un seul argument x et renvoie une autre fonction qui prend un seul argument y.
Cette fonction intérieure vérifie si y est défini. S'il est défini, il ajoute y à x et renvoie une référence à elle-même à l'aide de la propriété Arguments.Callee, qui permet à la fonction d'être appelée récursive avec l'argument suivant.
Si y n'est pas défini, il renvoie la valeur actuelle de x.
Ensuite, le code appelle Add (1) (2) (3) (). Cela appelle d'abord ajouter (1) avec 1 comme argument, qui renvoie une fonction qui prend un seul argument y.
Ensuite, il appelle cette fonction avec 2 comme argument, qui ajoute 2 à 1 et renvoie une référence à la fonction.
Enfin, il appelle cette fonction avec 3 comme argument, qui ajoute 3 à 3 et renvoie une référence à la fonction.
Étant donné qu'aucun argument n'est passé dans le dernier appel, il renvoie la valeur actuelle de x, qui est 6.
Ce code démontre un exemple plus complexe de curry dans JavaScript, où la fonction curry renvoie une référence à elle-même, ce qui lui permet d'être appelé récursivement avec l'argument suivant.
function multiply ( x ) {
return function ( y ) {
return x * y
}
}
const double = multiply ( 2 )
console . log ( double ( 5 ) )La bonne réponse est B. Le code définit une fonction multipliée qui prend un seul argument X et renvoie une autre fonction qui prend un seul argument y. Cette fonction intérieure multiplie x et y et renvoie le résultat.
Ensuite, le code crée une nouvelle fonction double en appelant Multiply avec 2 comme argument. La double fonction est désormais une fonction au curry qui peut être appelée avec un seul argument pour doubler sa valeur.
Enfin, le code appelle Double avec 5 comme argument, ce qui entraîne 10 connectés à la console.
Ce code démontre le concept de curry dans JavaScript, où une fonction renvoie une autre fonction qui peut être partiellement appliquée avec certains arguments.
Laquelle des affirmations suivantes est vraie à propos de la méthode next() d'un itérateur dans JavaScript?
La bonne réponse est A.
Dans JavaScript, un itérable est un objet qui définit une séquence et peut être itéré à l'aide d'une boucle.
Un itérateur est un objet qui sait accéder aux éléments d'un itérable à la fois.
Un objet itérable a une méthode avec le clés Symbol.iterator , qui renvoie un objet Iterator.
L'objet Iterator a une méthode next() , qui renvoie un objet avec deux propriétés: value , qui est le prochain élément de la séquence, et done , qui est un booléen indiquant si l'itérateur a atteint la fin de la séquence.
Les iterables sont couramment utilisés dans de nombreuses applications en temps réel tout en travaillant avec de grands ensembles de données, ou tout en implémentant des structures de données personnalisées
function * counter ( ) {
let i = 0
while ( true ) {
yield i ++
}
}
const gen = counter ( )
console . log ( gen . next ( ) . value )
console . log ( gen . next ( ) . value )
console . log ( gen . next ( ) . value )Quelle est la sortie de l'extrait de code ci-dessus?
La bonne réponse est D.
La fonction counter est une fonction de générateur qui crée une boucle infinie qui donne des valeurs incréments de i .
La variable gen est définie sur la fonction du générateur, et chaque appel à gen.next() renvoie un objet avec la propriété de valeur définie sur la valeur suivante.
Les instructions console.log impriment ensuite les valeurs renvoyées par gen.next() .
Une fonction de générateur est un type spécial de fonction qui peut être utilisé pour contrôler l'itération sur une séquence de valeurs.
Contrairement aux fonctions traditionnelles, les fonctions du générateur vous permettent de faire une pause et de reprendre leur exécution et de produire plusieurs valeurs au fil du temps.
Lequel des scénarios suivants pourrait potentiellement provoquer une fuite de mémoire en JavaScript?
Les références circulaires se produisent lorsque deux objets ou plus se référent les uns les autres, créant une boucle qui empêche les objets d'être collectés aux ordures.
Cela peut provoquer une fuite de mémoire si les objets ne sont plus nécessaires mais ne peuvent pas être libérés en raison de la référence circulaire.
Les options A, C et D ne provoquent généralement pas de fuites de mémoire en JavaScript.
La collecte des ordures est le processus de libération automatique de la mémoire qui n'est plus utilisée par un programme.
En JavaScript, l'algorithme Mark and Sweep est couramment utilisé pour la collecte des ordures.
Cet algorithme fonctionne en marquant d'abord tous les objets en mémoire qui sont toujours référencés par le programme, puis en balayant et en libérant toute mémoire qui n'est pas marquée comme utilisée.
function getData ( ) {
return new Promise ( ( resolve , reject ) => {
setTimeout ( ( ) => {
resolve ( 'Data retrieved successfully' )
} , 1000 )
} )
}
async function main ( ) {
try {
const data = await getData ( )
console . log ( data )
throw new Error ( 'Something went wrong' )
} catch ( err ) {
console . log ( 'Caught an error:' , err . message )
return 'Error occurred'
} finally {
console . log ( 'Finally block executed.' )
return 'Finally block value'
}
}
; ( async ( ) => {
console . log ( await main ( ) )
} ) ( )Quelle est la sortie de l'extrait de code ci-dessus?
Lorsque le code est exécuté, la fonction principale () est appelée, qui est une fonction asynchrone qui utilise l'attente pour obtenir des données de la fonction getData() .
Une fois les données récupérées, l'instruction console.log(data) journalise "les données récupérées avec succès" vers la console.
Après cela, l'instruction throw new Error("Something went wrong") lance une erreur.
Le bloc catch attrape l'erreur et les journaux "Caught an error: Something went wrong" à la console, puis renvoie la chaîne "Error occurred" .
Enfin, le bloc final est exécuté et les journaux "Finally block executed." vers la console, puis renvoie la chaîne "Finally block value" .
Lorsque la fonction main() est appelée, elle renvoie une promesse car il s'agit d'une fonction asynchrone. Étant donné que le bloc finally renvoie également une valeur, cette valeur sera la valeur finale résolue de la promesse.
Par conséquent, lorsque console.log(main()) est appelé "Finally block executed." et "Finally block value" sera enregistré à la console.
Essayez, capturez et enfin les mots clés utilisés dans JavaScript pour gérer les erreurs d'exécution.
const arr = [ 1 , 2 , 3 , 4 , 5 ] ;
let sum = 0 ;
for ( let num of arr ) {
sum += num ;
if ( sum >= 6 ) break ;
}
console . log ( sum ) ;
const arr2 = [ 1 , 2 , 3 , 4 , 5 ] ;
let sum2 = 0 ;
arr . forEach ( ( num ) => {
sum2 += num ;
if ( sum2 >= 6 ) break ;
} ) ;
console . log ( sum2 ) ;Quelle est la sortie de l'extrait de code ci-dessus?
Parce que l'instruction break n'est pas valide dans la fonction de rappel transmise à forEach .
forEach ne prend pas en charge la résiliation anticipée en utilisant la déclaration break . Par conséquent, une erreur est lancée: "Uncaught SyntaxError: Illegal break statement".
Dans le cas de pour de la boucle, une déclaration break est autorisée.
Pour résoudre le problème, supprimez l'instruction break de Foreach et cela devrait fonctionner.
En général, for of est recommandé for in ou forEach
let arr = [ 1 , 2 , 3 , 4 ]
let result = arr . push ( 5 )
console . log ( 'result: ' , result , 'arr: ' , arr )Quelle est la sortie de l'extrait de code ci-dessus?
La méthode array.push() dans JavaScript ajoute un ou plusieurs éléments à la fin d'un tableau et renvoie la nouvelle longueur du tableau.
Dans le code donné, arr est un tableau avec les valeurs [1, 2, 3, 4] . La méthode push() est appelée avec l'argument 5, qui ajoute 5 à la fin du tableau arr .
La méthode push() renvoie la nouvelle longueur du tableau après l'ajout de l'élément (s). Dans ce cas, la nouvelle longueur de l'ARR sera de 5 car 5 est ajouté à la fin du tableau.
let arr = [ 3 , 5 , 7 , 9 ]
let result = arr . unshift ( 1 , 2 )
console . log ( 'result: ' , result , 'arr: ' , arr )Quelle est la sortie de l'extrait de code ci-dessus?
La méthode array.unshift() dans JavaScript ajoute un ou plusieurs éléments au début d'un tableau et renvoie la nouvelle longueur du tableau.
Dans le code donné, arr est un tableau avec les valeurs [3, 5, 7, 9] . La méthode unshift() est appelée avec les arguments 1 et 2, qui ajoute 1 et 2 au début du tableau arr .
La méthode unshift() renvoie la nouvelle longueur du tableau après l'ajout de l'élément (s). Dans ce cas, la nouvelle durée de arr sera de 6 car 1 et 2 sont ajoutés au début du tableau, en déplaçant les éléments existants vers la droite.
const myArray = [ 1 , 2 , 3 , 4 , 5 ]
const poppedValue = myArray . pop ( )
console . log ( poppedValue )Quelle est la sortie de l'extrait de code ci-dessus?
La méthode Array.pop() dans JavaScript supprime le dernier élément d'un tableau et renvoie cet élément.
Dans ce cas, myArray est un tableau avec des éléments [1, 2, 3, 4, 5] , et myArray.pop() est appelé, qui supprime l'élément 5 du tableau et le renvoie.
const arr = [ 10 , 20 , 30 , 40 , 50 ]
const removedElement = arr . shift ( )
console . log ( 'removedElement: ' , removedElement , 'arr: ' , arr )Quelle est la sortie de l'extrait de code ci-dessus?
La méthode Array.shift() supprime le premier élément du tableau arr , qui est 10 , et le renvoie. Le réseau arr résultant sera alors [20, 30, 40, 50] .
Ainsi, l'option A est la bonne réponse car elle reflète la valeur correcte de removedElement et l'état mis à jour de arr après Array.shift() est appelé. L'option B est incorrecte car elle indique que removedElement sera 50, ce qui n'est pas vrai. L'option C est également incorrecte car elle indique que arr reste inchangée, ce qui n'est pas exact. L'option D est légèrement déroutante car elle indique que Array.shift() renvoie le tableau, ce qui n'est pas vrai.
let arr = [ 1 , 2 , 3 , 4 , 5 ]
let removed = arr . splice ( 1 , 2 , 'a' , 'b' )
console . log ( 'removed:' , removed , 'arr: ' , arr )Quelle est la sortie de l'extrait de code ci-dessus?
La méthode Array.splice() est utilisée pour modifier un tableau en ajoutant, en supprimant ou en remplacement des éléments.
Dans ce cas, l'extrait de code utilise arr.splice(1, 2, 'a', 'b') , qui commence à partir de l'indice 1 (en supprimant 2 éléments) et insère les éléments a et b à leur place. Les éléments supprimés (c.-à-d. 2 et 3) sont renvoyés et affectés à la variable supprimée. Après l'exécution, supprimé sera [2, 3] et arr sera [1, 'a', 'b', 4, 5] . L'option C est incorrecte car elle inclut les éléments insérés dans le tableau supprimé, qui n'est pas exact. L'option D est également incorrecte car elle mentionne les éléments incorrects qui sont supprimés du tableau.
const fruits = [ 'apple' , 'banana' , 'orange' , 'grape' , 'apple' , 'kiwi' ]
const index = fruits . indexOf ( 'orange' )
const lastIndex = fruits . lastIndexOf ( 'apple' )
const result = fruits . includes ( 'grape' )
console . log ( 'index: ' , index , 'lastIndex: ' , lastIndex , 'result: ' , result )Quelle est la sortie de l'extrait de code ci-dessus?
La méthode Array.indexOf() recherche l'index de la première occurrence de la valeur spécifiée dans les fruits du tableau. Dans ce cas, "orange" est trouvée à l'index 2, donc index sera 2.
La méthode Array.lastIndexOf() recherche l'index de la dernière occurrence de la valeur spécifiée dans les fruits du tableau. Dans ce cas, "Apple" apparaît deux fois dans le tableau et sa dernière occurrence est à l'indice 4, donc lastIndex sera 4.
D'un autre côté, la méthode Array.includes() vérifie si la valeur spécifiée "raisin" existe dans les fruits du tableau, et comme le "raisin" est présent dans le tableau, result sera vrai.
function isDivisibleBy7 ( num ) {
return num % 7 == 0
}
const nums = [ 28 , 7 , 3 , 29 , 15 , 1 , 2 , 23 ]
const filterResult = nums . filter ( isDivisibleBy7 )
const findResult = nums . find ( num => num < 10 )
const findIndexResult = nums . findIndex ( num => num / 2 == 14 )
console . log (
'filterResult:' ,
filterResult ,
'findResult:' ,
findResult ,
'findIndexResult:' ,
findIndexResult ,
)Quelle est la sortie de l'extrait de code ci-dessus?
La méthode Array.filter() renvoie un tableau contenant tous les éléments pour lesquels la fonction qui lui est transmise renvoie true. Dans ce cas, la fonction isDivisibleBy7 renvoie vrai pour tout nombre divisible par 7. Dans le tableau nums , 7 et 28 sont divisibles par 7, donc nums.filter(isDivisibleBy7) renvoie [28, 7].
La méthode Array.find() renvoie le premier élément du tableau pour lequel la fonction qui lui est transmise renvoie true. Dans ce cas, la fonction qui lui est transmise renvoie vrai pour n'importe quel nombre inférieur à 10. Il y a plusieurs nombres en nums qui sont inférieurs à 10, mais puisque Array.find() ne renvoie que le premier pour lequel il est vrai, nums.find((num) => num < 10) renvoie 7.
La méthode Array.findIndex() est similaire à la méthode Array.find() , mais renvoie l'index du premier élément du tableau pour lequel la fonction qui lui est transmise renvoie vrai, plutôt que l'élément lui-même. Dans ce cas, la fonction qui lui est transmise renvoie vrai pour 28, car le 28/2 == 14. 28 est dans le tableau nums et est à l'index 0, donc nums.find((num) => num / 2 == 14) renvoie 0.
const numbers = [ 1 , 2 , 3 , 4 , 5 ]
const doubledNumbers = numbers . map ( num => num * 2 )
console . log ( doubledNumbers )Quelle est la sortie de l'extrait de code ci-dessus?
La méthode Array.map() dans JavaScript crée un nouveau tableau en appliquant une fonction fournie à chaque élément du tableau d'origine.
Dans ce cas, la fonction fournie num => num * 2 multiplie chaque nombre dans le tableau des nombres par 2, ce qui donne un nouveau tableau [2, 4, 6, 8, 10] .
const numbers = [ 1 , 2 , 3 , 4 , 5 ]
const sum = numbers . reduce ( ( acc , val ) => acc + val )
console . log ( sum )Quelle est la sortie de l'extrait de code ci-dessus?
Array.reduce() prend un tableau et "réduit" à une seule valeur en appliquant à plusieurs reprises une fonction à chaque élément et en gardant une trace du résultat accumulé. Il est couramment utilisé pour les tâches telles que la résumé d'un tableau de nombres, la recherche de la valeur maximale ou la concaténation d'un tableau de chaînes en une seule chaîne.
Dans ce cas, la méthode Reduce () prend une fonction de rappel qui est exécutée pour chaque élément du tableau. La fonction de rappel prend deux paramètres, acc et val , qui représentent l'accumulateur et la valeur actuelle du tableau, respectivement.
À l'intérieur de la fonction de rappel, la valeur actuelle du tableau est ajoutée à l'accumulateur et le résultat est renvoyé. La méthode reduce() met à jour la valeur de l'accumulateur avec chaque itération jusqu'à ce qu'elle ait itéré sur tous les éléments du tableau.
Enfin, la méthode reduce() renvoie la valeur finale de l'accumulateur, qui est la somme de tous les nombres du tableau, soit 15.
const arr = [ 1 , 2 , 3 , 4 ]
const result = arr . reduceRight ( ( acc , curr ) => acc + curr )
console . log ( result )Quelle est la sortie de l'extrait de code ci-dessus?
La méthode reduceRight() est similaire à la méthode reduce() , sauf qu'elle commence à réduire le tableau de l'élément le plus à droite à l'élément le plus à gauche. La méthode reduceRight() applique une fonction contre un accumulateur et chaque valeur du tableau (de la droite à gauche) pour la réduire à une seule valeur.
Dans l'extrait de code donné, le tableau arr contient les valeurs [1, 2, 3, 4] . La méthode reduceRight() est appelée sur ce tableau avec une fonction de rappel qui ajoute l'accumulateur acc avec l'élément actuel curr .
Dans la première itération, la valeur curr sera 4 et la valeur ACC ne sera undefined , car aucune valeur initiale n'est fournie. Par conséquent, le résultat de la première itération sera 4 .
Dans la deuxième itération, la valeur curr sera 3 et la valeur acc sera le résultat de l'itération précédente, qui est 4 . Par conséquent, le résultat de la deuxième itération sera 7 .
Dans la troisième itération, la valeur curr sera 2 et la valeur acc sera le résultat de l'itération précédente, qui est 7 . Par conséquent, le résultat de la troisième itération sera 9 .
Dans la quatrième et dernière itération, la valeur curr sera 1 et la valeur acc sera le résultat de l'itération précédente, qui est 9 . Par conséquent, le résultat de la quatrième itération sera 10 .
Par conséquent, la sortie finale du code sera 10 . Par conséquent, la bonne option est A.
const arr = [ 'Centauri' , 3.14159 , 'canine' , 11235 , undefined ]
const result = arr . sort ( )
console . log ( result )Quelle est la sortie de l'extrait de code ci-dessus?
Par défaut, la méthode sort() Trie les éléments par caractère, donc 11235 est avant 3.14159 car 1 est avant 3.
Les mots et les lettres sont triés par ordre alphabétique par le code ASCII, donc "Centauri" qui commence par une trie en majuscules C (Code ASCII 67) avant "Canine" qui commence par un mincase C (Code ASCII 99).
Les éléments non définis trient toujours jusqu'à la fin d'un tableau.
Ainsi, la sortie finale du code sera [11235, 3.14159, «Centauri», «Canine», indéfinie] qui est l'option D.
let numbers = [ 1 , 2 , 3 , undefined , 6 , 7 , 8 , 9 ]
let [ a , , b , c = 2 , ... rest ] = numbers
console . log ( a , b , c , rest )Quelle est la sortie de l'extrait de code ci-dessus?
Avec la destruction du tableau, il est possible de déballer certaines valeurs d'un tableau en variables individuelles. Les valeurs que nous avons créées dans le côté gauche ( a, b, c, rest ) correspondent aux valeurs et à l'ordre du tableau que nous avons attribué dans le côté droit ( numbers ).
La variable a correspond au premier élément du tableau, qui est 1 .
Étant donné que nous n'avons pas spécifié de variable pour la valeur suivante 2 , la valeur n'est pas prise en compte dans l'évaluation et est ignorée.
La variable b correspond au troisième élément du tableau, qui est 3 .
Il est possible de définir des valeurs par défaut pour les variables si l'élément du tableau undefined . Étant donné que le quatrième élément du tableau undefined , la variable c a la valeur par défaut 2 .
Avec l'opérateur d'étalement ( ... ), nous pouvons attribuer les valeurs restantes du tableau à une variable. Étant donné que les valeurs [ 6, 7, 8, 9 ] sont les valeurs restantes du tableau, elles sont affectées au rest variable.
Par conséquent, le résultat final est: 1 3 2 [ 6, 7, 8, 9 ] , qui est l'option B.
const date1 = new Date ( )
const date2 = new Date ( '1995-12-17T05:10:00' )
const date3 = new Date ( '1995-10-15T08:12:15+02:00' )
console . log ( date1 , '' , date2 , '' , date3 )Quelle est la sortie de l'extrait de code ci-dessus?
new Date() renvoie la date et l'heure actuelles suivies des deux dates spécifiées au format "Yyyy-mm-ddthh: mm: ss.ssz", où "z" représente le décalage du fuseau horaire UTC.
YYYY-MM-DDTHH:mm:ss.sssZ est un format utilisé pour représenter les dates et les temps dans la norme ISO 8601. Il se compose des composants suivants:
YYYY : année à quatre chiffres (0000 à 9999), ou en tant qu'année élargie avec + ou - suivie de six chiffres. Le panneau est requis pour les années élargies. -000000 est explicitement interdite comme une année valide.MM : mois à deux chiffres (01 = janvier 02 = février, et ainsi de suite). Il est par défaut à 01.DD : Jour à deux chiffres du mois (01 à 31)T : un séparateur indiquant le début de la composante temporelleHH : heure à deux chiffres de la journée en format 24 heures sur 24 (00 à 23). Dans un cas particulier, 24h00 est autorisé et est interprété comme minuit au début du lendemain. Par défaut est 00.mm : Minute à deux chiffres de l'heure (00 à 59). Par défaut est 00.ss : seconde à deux chiffres de la minute (00 à 59). Par défaut est 00..sss : composant en millisecondes (000 à 999). Par défaut est 000.Z : Un suffixe indiquant que le temps est dans UTC (temps universel coordonné), sans décalage. Il peut s'agir du caractère littéral Z (indiquant UTC), soit + ou - suivi de HH: mm, le décalage en heures et à quelques minutes de l'UTC. const date = new Date ( 'Mart 15, 1975 23:15:30' )
date . setMinutes ( 10 )
date . setUTCDate ( 5 )
console . log (
'Minutes:' + date . getMinutes ( ) + ',' ,
'' ,
'Year:' + date . getFullYear ( ) + ',' ,
'' ,
'UTCDate:' + date . getUTCDate ( ) ,
)Quelle est la sortie de l'extrait de code ci-dessus?
Le code fourni crée un objet de date initialisé avec la date et l'heure du "15 mars 1975 23:15:30".
Ensuite, il modifie respectivement les méthodes de procès-verbal et UTC de l'objet Date à l'aide des méthodes setMinutes() et setUTCDate() .
Enfin, il enregistre les valeurs mises à jour des minutes, de l'année et de la date UTC à l'aide de console.log() .
Après avoir modifié les minutes à 10 à l'aide de setMinutes(10) , la méthode getMinutes() renvoie la valeur mise à jour de 10.
Après avoir modifié la date UTC à 5 à l'aide de setUTCDate(5) , la méthode getUTCDate() renvoie la valeur mise à jour de 5.
La méthode getFullYear() renvoie l'année inchangée, qui est en 1975.
const date1 = new Date ( '2023-5-1' )
const next_us_election = new Date ( '2024-11-5' )
const difference_in_time = next_us_election . getTime ( ) - date1 . getTime ( )
const difference_in_days = difference_in_time / ( 1000 * 3600 * 24 )
console . log ( parseInt ( difference_in_days , 10 ) + ' Days' )Quelle est la sortie de l'extrait de code ci-dessus?
Le code calcule la différence en jours entre la date "2023-5-1" et la prochaine date électorale américaine "2024-11-5". Il utilise l'objet Date pour créer deux dates: date1 représente le 1er mai 2023 et next_us_election représente le 5 novembre 2024.
La méthode getTime() est utilisée pour obtenir la valeur de temps en millisecondes pour chaque date. En soustrayant la valeur de temps de date1 de next_us_election , nous obtenons le décalage horaire en millisecondes.
Pour convertir le décalage horaire des millisecondes en jours, nous le divisons par le nombre de millisecondes en un jour (1000 _ 3600 _ 24). Le résultat est stocké dans la variable difference_in_days .
Enfin, la fonction parseInt() est utilisée pour convertir la valeur différence_in_days en un entier, et le résultat est connecté à la console avec la chaîne "jours". La sortie sera "554 jours".
let person = {
name : 'John' ,
age : 30 ,
hobbies : [ 'reading' , 'traveling' , 'cooking' ] ,
address : {
street : '123 Main St' ,
city : 'New York' ,
state : 'NY' ,
} ,
sayHello : function ( ) {
console . log ( 'Hello, my name is ' + this . name )
} ,
}
console . log ( person . name )
console . log ( person . hobbies [ 1 ] )
console . log ( person . address . city )
person . sayHello ( )Quelle est la sortie de l'extrait de code ci-dessus?
Le code définit une person littérale d'objet avec des propriétés telles que name , age , hobbies et address , et une méthode sayHello .
Les instructions console.log() impriment la valeur du name , le deuxième élément du tableau des hobbies (qui est "voyage"), et la valeur de la propriété city dans l'objet address (qui est "New York").
Enfin, la méthode sayHello est appelée sur l'objet person en utilisant la notation DOT, qui publie la chaîne "Bonjour, mon nom est John" à la console.
function User ( username ) {
this . username = username
this . updateUsername = newName => {
this . username = newName
}
}
const user1 = new User ( 'kirandash' )
const user2 = new User ( 'bgwebagency' )
user1 . updateUsername ( 'kirandash-website' )
user2 . updateUsername ( 'bgwebagency-app' )
console . log ( user1 . username , user2 . username )Quelle est la sortie de l'extrait de code ci-dessus?
Le code définit un User de la fonction constructeur qui crée des objets user avec une propriété username et une méthode updateUsername . Deux objets user , user1 et user2 , sont créés avec les noms d'utilisateur initiaux «Kirandash» et «bgwebagency» respectivement.
La méthode updateUsername est appelée sur les objets user1 et user2 pour mettre à jour ses noms d'utilisateur. Le nom d'utilisateur de user1 est mis à jour pour «Kirandash-website», et le nom d'utilisateur de user2 est mis à jour vers «BGWebagency-App».
Enfin, le code enregistre la concaténation de user1.username et user2.username , qui se traduit par la sortie «kirandash-website bgwebagency-app».
function greet ( name ) {
console . log ( `Hello, ${ name } ! Welcome to ${ this . location } .` )
}
const person = {
location : 'New York' ,
}
greet . call ( person , 'John' )
greet . apply ( person , [ 'Alex' ] )
const greetPerson = greet . bind ( person )
greetPerson ( 'Thomas' )Quelle est la sortie de l'extrait de code ci-dessus?
The call function is used to invoke the greet function with the person object as the context (the value of this ) and 'John' as the argument.
The apply function is used to invoke the greet function with the person object as the context (the value of this ) and an array ['Alex'] as the arguments.
The bind function is used to create a new function greetPerson with the person object as the bound context (the value of this ).
In summary, the code demonstrates how call , apply , and bind can be used to invoke a function with a specific context and arguments
class Animal {
constructor ( name ) {
this . name = name
}
static makeSound ( ) {
console . log ( 'Generic animal sound' )
}
sayName ( ) {
console . log ( `My name is ${ this . name } ` )
}
}
const a1 = new Animal ( 'Lion' )
const a2 = new Animal ( 'Time' )
Animal . makeSound ( )
a1 . makeSound ( )
a2 . makeSound ( )What does the above code snippet output?
The static method makeSound() is defined on the Animal class, and is accessible directly through the class itself, ie, Animal.makeSound() . This will output "Generic animal sound" to the console.
However, when we try to call makeSound() on an instance of the Animal class (a1.makeSound() and a2.makeSound()) , we get a TypeError, because static methods can only be accessed through the class itself and not through its instances.
function Animal ( name ) {
this . name = name
}
Animal . prototype . eat = function ( ) {
console . log ( this . name + ' is eating.' )
}
function Dog ( name ) {
Animal . call ( this , name )
}
Dog . prototype = Object . create ( Animal . prototype )
Dog . prototype . constructor = Dog
Dog . prototype . bark = function ( ) {
console . log ( this . name + ' is barking.' )
}
function CustomArray ( ) {
Array . call ( this )
}
CustomArray . prototype = Object . create ( Array . prototype )
CustomArray . prototype . constructor = CustomArray
CustomArray . prototype . sum = function ( ) {
return this . reduce ( ( acc , val ) => acc + val , 0 )
}
var dog = new Dog ( 'Buddy' )
dog . eat ( )
dog . bark ( )
var numbers = new CustomArray ( )
numbers . push ( 1 , 2 , 3 , 4 , 5 )
console . log ( numbers . sum ( ) )What will be the output of the following code
Explanation: In this example, we have a base class called Animal that defines a constructor and an eat() method. The subclass Dog extends the Animal class and adds its own constructor, bark() method, and a specific property breed .
Furthermore, we extend the built-in Array class using the class syntax to create a CustomArray class. The CustomArray class adds a custom method called sum() that calculates the sum of the array elements.
In the usage section, we create an instance of Dog named dog with the name "Buddy" . We can call the inherited eat() method from the Animal class, the bark() method defined in the Dog class.
Additionally, we create an instance of CustomArray called numbers and add some numbers to it. We can call the custom sum() method, which is added to the built-in Array class through subclassing.
This example showcases inheritance, subclassing, and extending a built-in class in JavaScript, illustrating how classes can be extended and customized to add additional functionality.
const person = {
name : 'John' ,
age : 30 ,
city : 'New York' ,
}
const { name , age , city } = person
console . log ( name )
console . log ( age )
console . log ( city )What will be the output of the following code
In the code above, we have an object literal called person with properties name , age , and city . We then use object destructuring to extract those properties into separate variables ( name , age , and city ). After destructuring, we can use these variables to access the corresponding values from the object.
Consider the following code snippet:
// module.mjs
export const PI = 3.14159
export function calculateArea ( radius ) {
return PI * radius * radius
}
export default function calculateCircumference ( radius ) {
return 2 * PI * radius
}
// script.mjs
import calculateCircumference , { PI , calculateArea } from './module.mjs'
console . log ( PI ) // Output: ________
console . log ( calculateArea ( 5 ) ) // Output: ________
console . log ( calculateCircumference ( 5 ) ) // Output: ________What will be the output of the console.log statements in the code above?
Options:
3.14159 , 78.53975 , 31.41593.14159 , 78.53975 , 62.83183.14159 , 78.53975 , NaN3.14159 , NaN , 62.8318 The module.js file exports three entities:
PI is a named export, exported using the export keyword.calculateArea is a named export, exported using the export keyword.calculateCircumference is the default export, exported using the export default syntax. In the main.js file, we import PI and calculateArea as named exports using the destructuring assignment syntax. We also import calculateCircumference as the default export. The import statements reference the module.js file using the relative file path ./module.js .
The outputs of the console.log statements will be:
console.log(PI) will output 3.14159 since we imported the named export PI .console.log(calculateArea(5)) will output 78.53975 since we imported the named export calculateArea and called the function with a radius of 5.console.log(calculateCircumference(5)) will output 62.8318 since we imported the default export calculateCircumference and called the function with a radius of 5. Consider the following code snippet:
// foo.js
function foo ( ) {
console . log ( `Foo` )
}
export { foo } What is the correct Syntax to import the function foo ?
Options:
import foo from "./foo"import foo as FooFunction from "./foo"import { foo } from "./foo"import { foo } from "./bar" Named exports are imported into different files with braces and must be imported with the name of the object, function or variable that was exported. In this example, a function with the name foo is exported from the file foo.js . Accordingly, the correct expression is: import { foo } from "./foo" .
In JavaScript, when importing a default export from a module, which syntax correctly assigns an alias "myAlias" to the default import?
Explanation: Both option B and C are valid syntaxes for importing a default export from a module and assigning it an alias. The difference between the two syntaxes is that option B does not use the { default as myAlias } syntax. This means that the default export will be imported under the name myAlias, rather than the name default.
Here is an example of how to use the option B syntax:{import myAlias from 'module';},This will import the default export from the module module and assign it the name myAlias. You can then use the myAlias variable to access the default export from the module module. Here is an example of how to use the option C syntax:{import { default as myAlias } from 'module';},This will import the default export from the module module and assign it the alias myAlias. You can then use the myAlias alias to access the default export from the module module.
The choice of which syntax to use is up to you. The option B syntax is simpler, but it can lead to collisions if there is already a variable named myAlias in the current scope. The option C syntax is more verbose, but it avoids collisions.
Which method is used to convert a JavaScript object to a JSON string while preserving data types like Dates and RegEx?
JSON.stringify()JSON.stringify() with a custom replacer functionJSON.toTypedString()JSON.stringify()JSON.stringify() with a custom replacer function. Explanation: The JSON.stringify() method can be used to convert a JavaScript object to a JSON string. However, by default, it will not preserve data types like Dates and RegEx . To preserve these data types, you can use a custom replacer function. The replacer function takes an object as input and returns a new object with the modified values.
The code below would show you how to use a custom replacer function to preserve data types:
function replacer ( key , value ) {
if ( typeof value === 'Date' ) {
return value . toJSON ( )
} else if ( typeof value === 'RegExp' ) {
return value . toString ( )
} else {
return value
}
}
const object = {
date : new Date ( ) ,
regex : / some regex / ,
}
const jsonString = JSON . stringify ( object , replacer )
