who wants to be a javascriptaire
1.0.0
Unterhaltsame Möglichkeit, JavaScript für Ihre Frontend-/Web -Codierungsinterviews zu lernen. Alle Fragen werden hier im Text beantwortet und haben auch ein Video auf unserem YouTube -Kanal. Klicken Sie auf die
Fühlen Sie sich frei, uns auf unseren sozialen Plattformen zu erreichen! ?
Zwietracht || Instagram || Twitter || Tiktok || Blog || Facebook
Unterstützung
Bitte spielen Sie dieses Projekt mit anderen und teilen Sie es mit anderen, um Ihre Unterstützung zu zeigen. Folgen Sie mir, um Updates zu zukünftigen Projekten und Tutorials zu erhalten!
Sprachgrundlagen - Arrays - Datum und Uhrzeit - objektorientierte JavaScript - Module - Verschiedenes
console . log ( new Date ( 2023 , 1 , 31 ) )Tue Jan 31 2024Tue Jan 31 2023Fri Mar 03 2023ErrorIn JavaScript sind die Monate von Datum Objekten mit 0 basiert. Was bedeutet, dass 0 für Januar und 1 für Februar ist.
In diesem Fall bitten wir JavaScript, ein Datum vom 31. Februar 2023 festzulegen, der nicht existiert.
Aber anstatt Fehler zu werfen, überflutet JavaScript es auf den nächsten Monat, der März ist.
Und seit Februar im Jahr 2023 nur 28 Tage, wird der Code um 3 Tage überlaufen, was das Ergebnis am 3. März 2023 beträgt.
var username = 'kirandash'
var username = 'bgwebagency'
console . log ( username )bgwebagencykirandashReferenceErrorSyntaxError Wir können dieselbe Variable mithilfe des var -Schlüsselworts mehrfach deklarieren. Und die Variable hält den Wert, den sie am Ende zugewiesen hat.
Wir können jedoch nicht mehrmals dieselbe Variable mit let oder const deklarieren
const user = {
username : 'kirandash' ,
updateUsername : newName => {
this . username = newName
} ,
}
user . updateUsername ( 'bgwebagency' )
console . log ( user . username )bgwebagencyReferenceErrorkirandashundefined Da die Funktion updateUsername nicht ordnungsgemäß funktioniert und den username des user nicht aktualisiert.
Die Funktion updateUsername im object ist eine Pfeilfunktion und ist nicht an das user gebunden.
Das this Schlüsselwort in der Funktion updateUnername bezieht sich also nicht auf das user , sondern bezieht sich auf den globalen Bereich.
Um dieses Problem zu beheben, sollten wir die Pfeilfunktion in eine normale Funktion ändern.
const len1 = 'kiran' . length
const len2 = '?' . length
console . log ( len1 , len2 )5, 25, 15, undefined5, SyntaxErrorIn JavaScript gibt die Eigenschaft der String Länge die Anzahl der Bytes zurück und nicht die Anzahl der Zeichen, wie wir es erwarten.
Ein Emoji ist ein Unicode -Zeichen, das in zwei Bytes codiert ist. Daher ist die Antwort 2 für diese Frage.
Die Saitenlänge für kiran gibt 5 zurück, da in einer Zeichenfolge jedes Zeichen 1 Byte ist.
console . log ( undefined == null , undefined === null )true, truetrue, falsefalse, falsefalse, trueLassen Sie mich zunächst den Unterschied zwischen gleichem und strengen gleichberechtigten Operator erklären.
Der gleiche Bediener prüft nur, ob beide Werte gleich sind. Der strenge gleiche Operator prüft, ob sowohl Wert als auch Typ gleich sind.
In diesem Code gibt die erste Anweisung undefined == null true zurück, da undefined und null den gleichen Wert haben, der leer ist.
Aber die zweite Anweisung undefined === null gibt false zurück. Da typeof undefined undefined ist, ist typeof null ein object .
Sie fragen sich vielleicht, warum typeof null ein object ist, wenn null im Grunde ein primitiver Datentyp ist. Dies ist im Grunde genommen ein Fehler im JavaScript von Anfang an.
Jetzt noch ein Tipp für Sie: Wenn Sie einen leeren Wert für eine Variable festlegen möchten, verwenden Sie null anstelle von undefined . Da undefined hauptsächlich verwendet wird, um zu prüfen, ob eine Variable keinen Wert zugewiesen hat.
function getFruits ( x , ... multi , y ) {
console . log ( x , y , multi ) ;
}
getFruits ( "?" , "?" , "?" , "?" , "?" )? ? ["?", "?", "?"]SyntaxErrorRastoperatoren wurden als Teil der ES6 -Funktion hinzugefügt.
Es dauert alle Argumente, die an eine Funktion übergeben wurden, und stellt sie in ein Array.
Wenn mehrere Argumente an eine Funktion übergeben werden, muss der Restoperator am Ende kommen. Deshalb macht dieser Code -Snippet einen Fehler.
Um dieses Problem zu beheben, verschieben Sie den Restbetreiber am Ende und dann sollte es funktionieren.
let x = Number . NEGATIVE_INFINITY
let y = Number . POSITIVE_INFINITY
let z = x + y
console . log ( z )0undefinedNaNTypeErrorNegative_infinity und positiv_infinity sind Eigenschaften des Zahlenobjekts im JavaScript, das das mathematische Konzept der negativen Unendlichkeit und der positiven Unendlichkeit darstellt.
Wenn Sie number addieren.
Das Hinzufügen eines positiven unendlichen Wertes zu einem negativen unendlichen Wert führt nicht zu einem sinnvollen numerischen Wert.
In diesem Fall wird Z nan sein.
Beachten Sie, dass der Code kein Typeerror wirft, da JavaScript den Additionsvorgang zwischen number.negative_infinity und number.Positiv_infinity ausführen kann.
console . log ( 'BG Web Agency' === NaN , isNaN ( 'BG Web Agency' ) )true, truefalse, truetrue, falsefalse, false Verwenden Sie === NaN um zu überprüfen, ob ein Wert eine Zahl ist, funktioniert nicht.
In JavaScript ist NaN (nicht eine Zahl) ein besonderer Wert, der eine ungültige Zahl darstellt.
Nan ist nichts gleich, einschließlich sich selbst, daher wird der Ausdruck "BG Web Agency" === NaN immer false zurückgegeben.
Um zu überprüfen, ob ein Wert eine Zahl in JavaScript ist, können Sie die Funktion isNaN() verwenden. Diese Funktion gibt true zurück, wenn das an sie übergebene Argument NaN ist oder wenn es nicht in eine Zahl konvertiert werden kann.
console . log ( isFinite ( Infinity ) , isNaN ( Infinity ) )false, falsefalse, truetrue, falsefalse, false Die Funktion isFinite() wird verwendet, um festzustellen, ob ein bestimmter Wert eine endliche Zahl ist.
Es gibt False zurück, wenn der Wert Nan, Infinity oder -Infinity ist, und wahr, wenn der Wert eine endliche Zahl ist.
In diesem Beispiel wird isFinite(Infinity) falsch zurückkehren, da Unendlichkeit keine endliche Zahl ist.
Andererseits wird die Funktion isnan () verwendet, um festzustellen, ob ein gegebener Wert keine Zahl (NAN) ist.
Es gibt true zurück, wenn der Wert NAN ist, und falsch, wenn der Wert eine Zahl oder einen anderen Datentyp ist.
In diesem Beispiel wird isNaN(Infinity) auch falsch zurückkehren, da Unendlichkeit nicht NAN ist.
Verwenden Sie daher immer isFinite -Funktion anstelle isNaN -Funktion, wenn Sie validieren möchten, wenn eine Zahl endlich ist
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 ( ) ) Die Funktion getName Arrow verwendet this Schlüsselwort, um auf die Namenseigenschaft des Objekts zu verweisen. Da Pfeilfunktionen jedoch eine lexikalische this Bindung haben, ist der Wert this Schlüsselworts in der Pfeilfunktion das globale Objekt, das in einem Browser oder global in window
Da das global Objekt keine Namenseigenschaft gibt, kehrt die Funktion undefined zurück.
Die getAge -Funktion verwendet einen regulären Funktionsausdruck und bezieht sich korrekt auf die Alterseigenschaft des user mit this Schlüsselwort.
Wenn getAge der getAge -Variablen jedoch zugewiesen wird, verliert es den Verweis auf das user . Wenn die Funktion unter Verwendung getAge() aufgerufen wird, bezieht sich dies erneut auf das globale Objekt, und da es keine Alterseigenschaft für das globale Objekt gibt, gibt die Funktion undefiniert zurück.
for ( var i = 0 ; i < 3 ; i ++ ) {
setTimeout ( function ( ) {
console . log ( i )
} , 0 )
}Ein Verschluss ist eine Funktion, die den Zugriff auf Variablen in seinem äußeren Bereich behält, selbst nachdem die äußere Funktion zurückgegeben wurde.
In diesem Beispiel lautet die Antwort B, da die SetTimeout -Funktion asynchron ist und nicht sofort ausgeführt wird.
Bis die an SetTimeOut übergebene Rückruffunktion ausgeführt wird, hat die Schleife bereits abgeschlossen und die I -Variable hat einen Wert von 3.
Daher druckt jeder Anruf bei Console.log (i) in der Rückruffunktion 3.
Um dieses Problem zu lösen und 0, 1, 2 zu drucken, können wir ein IIF (sofort aufgerufene Funktionsausdruck) verwenden, um für jede Iteration der Schleife einen neuen Bereich zu erstellen.
Dies schafft eine neue Variable j in jedem IIFE, mit seiner eigenen Kopie des aktuellen Wertes von I, wenn die Iteration der Schleife ist.
Wenn die an setTimeout übergebene Rückruffunktion ausgeführt wird, hat sie Zugriff auf die J -Variable in ihrer Schließung, die für jede Iteration der Schleife den erwarteten Wert von 0, 1 oder 2 hat.
function add ( x ) {
return function ( y ) {
if ( y !== undefined ) {
x += y
return arguments . callee
} else {
return x
}
}
}
console . log ( add ( 1 ) ( 2 ) ( 3 ) ( ) )Die richtige Antwort ist A. Der Code definiert eine Add -Funktion, die ein einzelnes Argument X annimmt und eine andere Funktion zurückgibt, die ein einzelnes Argument y aufnimmt.
Diese innere Funktion prüft, ob y definiert ist. Wenn es definiert ist, fügt es y zu x hinzu und gibt einen Verweis auf sich selbst mit der Eigenschaft von Arguments.Callee zurück, mit der die Funktion mit dem nächsten Argument rekursiv aufgerufen werden kann.
Wenn y nicht definiert ist, gibt es den aktuellen Wert von x zurück.
Anschließend addieren Sie (1) (2) (3) (). Diese ersten Aufrufe fügen (1) mit 1 als Argument hinzu, das eine Funktion zurückgibt, die ein einziges Argument y nimmt.
Dann nennt es diese Funktion mit 2 als Argument, das 2 zu 1 hinzufügt und einen Verweis auf die Funktion zurückgibt.
Schließlich nennt es diese Funktion mit 3 als Argument, das 3 zu 3 hinzufügt und einen Verweis auf die Funktion zurückgibt.
Da im letzten Anruf kein Argument weitergegeben wird, gibt es den aktuellen Wert von x zurück, der 6 ist.
Dieser Code zeigt ein komplexeres Beispiel für das Currying in JavaScript, bei dem die Curry -Funktion eine Referenz auf sich selbst zurückgibt, sodass sie mit dem nächsten Argument rekursiv bezeichnet werden kann.
function multiply ( x ) {
return function ( y ) {
return x * y
}
}
const double = multiply ( 2 )
console . log ( double ( 5 ) )Die richtige Antwort lautet B. Der Code definiert eine Multiplikationsfunktion, die ein einzelnes Argument X annimmt und eine andere Funktion zurückgibt, die ein einzelnes Argument y nimmt. Diese innere Funktion multipliziert X und Y und gibt das Ergebnis zurück.
Anschließend erstellt der Code eine neue Funktion doppelt, indem es Multiply mit 2 als Argument aufruft. Die doppelte Funktion ist jetzt eine Curry -Funktion, die mit einem einzigen Argument aufgerufen werden kann, um ihren Wert zu verdoppeln.
Schließlich ruft der Code mit 5 als Argument auf, was dazu führt, dass 10 bei der Konsole protokolliert werden.
Dieser Code demonstriert das Konzept der Currying in JavaScript, wobei eine Funktion eine andere Funktion zurückgibt, die teilweise mit einigen Argumenten angewendet werden kann.
Welche der folgenden Aussagen gilt für die next() Methode eines Iterators in JavaScript?
Die richtige Antwort ist A.
In JavaScript ist ein iterable ein Objekt, das eine Sequenz definiert und über eine Schleife iteriert werden kann.
Ein Iterator ist ein Objekt, das weiß, wie man auf die Elemente eines iterablen einzelnen zugreift.
Ein iterierbares Objekt hat eine Methode mit dem Schlüsselsymbol Symbol.iterator , das ein Iteratorobjekt zurückgibt.
Das Iteratorobjekt hat eine next() -Methode, die ein Objekt mit zwei Eigenschaften zurückgibt: value , das das nächste Element in der Sequenz ist und ein Boolescher done , der angibt, ob der Iterator das Ende der Sequenz erreicht hat.
Iterables werden häufig in vielen Echtzeitanwendungen verwendet, während sie mit großen Datensätzen arbeiten oder benutzerdefinierte Datenstrukturen implementieren
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 )Was gibt der obige Code -Snippet aus?
Die richtige Antwort ist D.
Die counter ist eine Generatorfunktion, die eine unendliche Schleife erstellt, die die Inkrementierung von Werten von i ergibt.
Die gen -Variable wird auf die Generatorfunktion eingestellt, und jeder Aufruf an gen.next() gibt ein Objekt mit der Werteigenschaft zurück, die auf den nächsten Wert wurde.
Die console.log -Anweisungen drucken dann die von gen.next() zurückgegebenen Werte.
Eine Generatorfunktion ist eine spezielle Funktionstyp, mit der die Iteration über eine Sequenz von Werten gesteuert werden kann.
Im Gegensatz zu herkömmlichen Funktionen ermöglichen es Ihnen Generatorfunktionen, deren Ausführung innehalten und wieder aufzunehmen und im Laufe der Zeit mehrere Werte zu ergeben.
Welche der folgenden Szenarien könnte möglicherweise ein Speicherleck in JavaScript verursachen?
Zirkuläre Referenzen treten auf, wenn sich zwei oder mehr Objekte aufeinander verweisen und eine Schleife erstellen, die verhindert, dass die Objekte Müll gesammelt werden.
Dies kann ein Speicherleck verursachen, wenn die Objekte nicht mehr benötigt werden, aber aufgrund der kreisförmigen Referenz nicht befreit werden können.
Die Optionen A, C und D verursachen normalerweise keine Speicherlecks in JavaScript.
Die Müllsammlung ist der Prozess der automatischen Freigabe des Speichers, der nicht mehr von einem Programm verwendet wird.
In JavaScript wird der Mark- und Sweep -Algorithmus üblicherweise für die Müllsammlung verwendet.
Dieser Algorithmus funktioniert, indem er zuerst alle Objekte im Speicher markiert, auf die immer noch vom Programm verwiesen wird, und dann einen Speicher, der nicht wie in Gebrauch markiert ist, durchflutet und befreien wird.
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 ( ) )
} ) ( )Was gibt der obige Code -Snippet aus?
Wenn der Code ausgeführt wird, wird die Funktion main () aufgerufen, eine asynchronisierte Funktion, die erwartet, um Daten aus der Funktion getData() abzurufen.
Sobald die Daten abgerufen sind, log das console.log(data) "Daten erfolgreich abgerufen" an die Konsole.
Danach wirft der throw new Error("Something went wrong") einen Fehler aus.
Der catch -Block erfasst den Fehler und protokolliert "Caught an error: Something went wrong" in die Konsole und dann den String "Error occurred" zurückgegeben.
Schließlich wird der endgültige Block ausgeführt und protokolliert "Finally block executed." an die Konsole und gibt dann die Zeichenfolge "Finally block value" zurück.
Wenn die Funktion main() aufgerufen wird, gibt sie ein Versprechen zurück, da es sich um eine asynchronisierte Funktion handelt. Da der finally Block auch einen Wert zurückgibt, ist dieser Wert der endgültige gelehrte Wert des Versprechens.
Daher, wenn console.log(main()) genannt wird, "Finally block executed." und "Finally block value" wird an der Konsole angemeldet.
Versuchen Sie, fangen und schließlich Keywords, die in JavaScript verwendet werden, um Laufzeitfehler zu verarbeiten.
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 ) ;Was gibt der obige Code -Snippet aus?
Weil break -Anweisung in der Rückruffunktion, die an forEach übergeben wurde, nicht gültig ist.
forEach unterstützt keine frühzeitige Kündigung mithilfe der break -Anweisung. Daher wird ein Fehler geworfen: "Uncaught SyntaxError: Illegal break statement".
Im Falle einer Schleife ist die break -Erklärung zulässig.
Um das Problem zu beheben, entfernen Sie die break -Anweisung von foreach und es sollte funktionieren.
Im Allgemeinen wird for of for in oder forEach empfohlen
let arr = [ 1 , 2 , 3 , 4 ]
let result = arr . push ( 5 )
console . log ( 'result: ' , result , 'arr: ' , arr )Was gibt der obige Code -Snippet aus?
Die array.push() -Methode in JavaScript fügt ein oder mehrere Elemente am Ende eines Arrays hinzu und gibt die neue Länge des Arrays zurück.
In dem angegebenen Code ist arr ein Array mit den Werten [1, 2, 3, 4] . Die push() -Methode wird mit dem Argument 5 aufgerufen, das 5 zum Ende des arr hinzufügt.
Die push() -Methode gibt die neue Länge des Arrays nach Zugabe des Elements zurück. In diesem Fall beträgt die neue Länge von ARR 5, da 5 am Ende des Arrays hinzugefügt wird.
let arr = [ 3 , 5 , 7 , 9 ]
let result = arr . unshift ( 1 , 2 )
console . log ( 'result: ' , result , 'arr: ' , arr )Was gibt der obige Code -Snippet aus?
Die array.unshift() -Methode in JavaScript fügt dem Beginn eines Arrays ein oder mehrere Elemente hinzu und gibt die neue Länge des Arrays zurück.
Im angegebenen Code ist arr ein Array mit den Werten [3, 5, 7, 9] . Die unshift() -Methode wird mit den Argumenten 1 und 2 aufgerufen, die zum Beginn des arr -Arrays 1 und 2 hinzugefügt werden.
Die unshift() -Methode gibt die neue Länge des Arrays nach Zugabe des Elements zurück. In diesem Fall beträgt die neue Länge von arr 6, da 1 und 2 zum Beginn des Arrays hinzugefügt werden und die vorhandenen Elemente nach rechts verschoben werden.
const myArray = [ 1 , 2 , 3 , 4 , 5 ]
const poppedValue = myArray . pop ( )
console . log ( poppedValue )Was gibt der obige Code -Snippet aus?
Die Array.pop() -Methode in JavaScript entfernt das letzte Element aus einem Array und gibt dieses Element zurück.
In diesem Fall ist myArray ein Array mit Elementen [1, 2, 3, 4, 5] , und myArray.pop() wird aufgerufen, das das Element 5 aus dem Array entfernt und zurückgibt.
const arr = [ 10 , 20 , 30 , 40 , 50 ]
const removedElement = arr . shift ( )
console . log ( 'removedElement: ' , removedElement , 'arr: ' , arr )Was gibt der obige Code -Snippet aus?
Die Array.shift() -Methode entfernt das erste Element aus dem arr -Array, das 10 ist, und gibt es zurück. Das resultierende arr -Array ist dann [20, 30, 40, 50] .
Option A ist also die richtige Antwort, da sie den korrekten Wert von removedElement und der aktualisierte Status von arr nach Array.shift() widerspiegelt. Option B ist falsch, da es feststellt, dass removedElement 50 beträgt, was nicht wahr ist. Option C ist auch falsch, da die arr unverändert bleibt, was nicht korrekt ist. Option D ist leicht verwirrend, da Array.shift() das Array zurückgibt, was nicht wahr ist.
let arr = [ 1 , 2 , 3 , 4 , 5 ]
let removed = arr . splice ( 1 , 2 , 'a' , 'b' )
console . log ( 'removed:' , removed , 'arr: ' , arr )Was gibt der obige Code -Snippet aus?
Die Methode Array.splice() wird verwendet, um ein Array durch Hinzufügen, Entfernen oder Austausch von Elementen zu ändern.
In diesem Fall verwendet das Code -Snippet arr.splice(1, 2, 'a', 'b') , das aus dem Index 1 (Entfernen von 2 Elementen) beginnt und die Elemente a und b an ihrer Stelle einfügt. Die Elemente, die entfernt werden (dh 2 und 3), werden zurückgegeben und der Variablen zugeordnet. Nach der Ausführung ist die Entfernung [2, 3] und arr wird [1, 'a', 'b', 4, 5] sein. Option C ist falsch, da es die eingefügten Elemente im entfernten Array enthält, was nicht genau ist. Option D ist auch falsch, da sie die falschen Elemente erwähnt, die aus dem Array entfernt werden.
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 )Was gibt der obige Code -Snippet aus?
Das Array.indexOf() -Methode sucht nach dem Index des ersten Auftretens des angegebenen Wertes in den Array -Früchten. In diesem Fall befindet sich "Orange" unter Index 2, sodass index 2 sein wird.
Die Methode Array.lastIndexOf() sucht nach dem Index des letzten Auftretens des angegebenen Wertes in den Array -Früchten. In diesem Fall erscheint "Apple" im Array zweimal und sein letztes Ereignis liegt bei Index 4, sodass lastIndex 4 sein wird.
Andererseits prüft das Array.includes() result
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 ,
)Was gibt der obige Code -Snippet aus?
Die Methode Array.filter() gibt ein Array zurück, das alle Elemente enthält, für die die an sie übergebene Funktion true zurückgibt. In diesem Fall gibt die Funktion isDivisibleBy7 true für eine beliebige Zahl zurück, die durch 7 teilbar ist. In der nums -Array sind 7 und 28 durch 7 teilbar, also kehrt nums.filter(isDivisibleBy7) zurück [28, 7].
Die Methode Array.find() gibt das erste Element in dem Array zurück, für das die an sie übergebene Funktion true zurückgibt. In diesem Fall gibt die an sie übergebene Funktion für eine beliebige Zahl von weniger als 10 zurück. Es gibt mehrere Zahlen in nums , die weniger als 10 sind, aber da Array.find() nur die erste zurückgibt, für die sie wahr ist, gibt nums.find((num) => num < 10) 7 zurück.
Die Array.findIndex() -Methode ähnelt der Array.find() -Methode, gibt jedoch den Index des ersten Elements in dem Array zurück, für das die an sie übergebene Funktion wahr ist, und nicht das Element selbst. In diesem Fall gibt die an sie übergebene Funktion für 28 die TRUE zurück, da der 28/2 == 14. 28 in den Array nums liegt und in Index 0 liegt, also nums.find((num) => num / 2 == 14) gibt 0 zurück.
const numbers = [ 1 , 2 , 3 , 4 , 5 ]
const doubledNumbers = numbers . map ( num => num * 2 )
console . log ( doubledNumbers )Was gibt der obige Code -Snippet aus?
Die Array.map() -Methode in JavaScript erstellt ein neues Array, indem eine bereitgestellte Funktion auf jedes Element des ursprünglichen Arrays angewendet wird.
In diesem Fall multipliziert die bereitgestellte Funktion num => num * 2 jede Zahl im Nummernarray mit 2, was zu einem neuen Array führt [2, 4, 6, 8, 10] .
const numbers = [ 1 , 2 , 3 , 4 , 5 ]
const sum = numbers . reduce ( ( acc , val ) => acc + val )
console . log ( sum )Was gibt der obige Code -Snippet aus?
Array.reduce() nimmt ein Array auf und "reduziert" es auf einen einzelnen Wert, indem Sie wiederholt eine Funktion auf jedes Element anwenden und das akkumulierte Ergebnis verfolgen. Es wird üblicherweise für Aufgaben verwendet, z. B. für die Summierung einer Reihe von Zahlen, das Finden des Maximalwerts oder die Verkettung einer Reihe von Zeichenfolgen in eine einzelne Zeichenfolge.
In diesem Fall nimmt die Methode record () eine Rückruffunktion an, die für jedes Element des Arrays ausgeführt wird. Die Rückruffunktion enthält zwei Parameter, acc und val , die den Akkumulator bzw. den aktuellen Wert des Arrays darstellen.
In der Rückruffunktion wird der aktuelle Wert des Arrays dem Akkumulator hinzugefügt und das Ergebnis zurückgegeben. Die Methode reduce() aktualisiert den Wert des Akkumulators mit jeder Iteration, bis er über alle Elemente des Arrays iteriert wurde.
Schließlich gibt die reduce() -Methode den Endwert des Akkumulators zurück, der die Summe aller Zahlen im Array ist, dh 15.
const arr = [ 1 , 2 , 3 , 4 ]
const result = arr . reduceRight ( ( acc , curr ) => acc + curr )
console . log ( result )Was gibt der obige Code -Snippet aus?
Die reduceRight() -Methode ähnelt der reduce() -Methode, außer dass es beginnt, das Array vom rechts bis zum linken Element aus dem linken Element zu reduzieren. Die reduceRight() -Methode wendet eine Funktion gegen einen Akkumulator und jeden Wert des Arrays (von rechts nach links) an, um sie auf einen einzelnen Wert zu reduzieren.
Im angegebenen Code -Snippet enthält das arr -Array die Werte [1, 2, 3, 4] . Die reduceRight() -Methode wird auf diesem Array mit einer Rückruffunktion aufgerufen, die den Akkumulator acc mit dem aktuellen Element curr fügt.
In der ersten Iteration beträgt der curr -Wert 4 und der ACC -Wert wird undefined , da kein Anfangswert bereitgestellt wird. Daher wird das Ergebnis der ersten Iteration 4 sein.
In der zweiten Iteration beträgt der curr -Wert 3 und der acc -Wert ist das Ergebnis der vorherigen Iteration, die 4 ist. Daher wird das Ergebnis der zweiten Iteration 7 sein.
In der dritten Iteration beträgt der curr -Wert 2 und der acc -Wert wird das Ergebnis der vorherigen Iteration sein, die 7 ist. Daher wird das Ergebnis der dritten Iteration 9 sein.
In der vierten und endgültigen Iteration beträgt der curr -Wert 1 und der acc -Wert wird das Ergebnis der vorherigen Iteration sein, die 9 beträgt. Daher beträgt das Ergebnis der vierten Iteration 10 .
Daher beträgt die endgültige Ausgabe des Codes 10 . Daher ist die richtige Option A. A.
const arr = [ 'Centauri' , 3.14159 , 'canine' , 11235 , undefined ]
const result = arr . sort ( )
console . log ( result )Was gibt der obige Code -Snippet aus?
Standardmäßig die sort() -Methode sortiert Elemente nach Charakter, so dass 11235 vor 3.14159 kommt, da 1 vor 3 kommt.
Wörter und Buchstaben werden alphabetisch von ASCII -Code sortiert, also "Centauri", das mit einem Großbuchstaben C (ASCII -Code 67) beginnt, vor "Eckzahn", der mit einem Kleinbuchstaben C (ASCII -Code 99) beginnt.
Undefinierte Elemente sortieren immer bis zum Ende eines Arrays.
Somit ist die endgültige Ausgabe des Codes [11235, 3.14159, 'Centauri', 'Canine', undefined], was Option D. ist.
let numbers = [ 1 , 2 , 3 , undefined , 6 , 7 , 8 , 9 ]
let [ a , , b , c = 2 , ... rest ] = numbers
console . log ( a , b , c , rest )Was gibt der obige Code -Snippet aus?
Bei Array Destructuring ist es möglich, bestimmte Werte von einem Array in einzelne Variablen auszupacken. Die Werte, die wir auf der linken Seite erstellt haben ( a, b, c, rest ), entsprechen den Werten und der Reihenfolge des Arrays, die wir auf der rechten Seite zugewiesen haben ( numbers ).
Die Variable a entspricht dem ersten Element des Arrays, das 1 ist.
Da wir keine Variable für den nächsten Wert 2 angegeben haben, wird der Wert in der Bewertung nicht berücksichtigt und übersprungen.
Die Variable b entspricht dem dritten Element des Arrays, das 3 ist.
Es ist möglich, Standardwerte für die Variablen festzulegen, wenn das Element im Array undefined ist. Da das vierte Element im Array undefined ist, hat die Variable c den Standardwert 2 .
Mit dem Spread Operator ( ... ) können wir die verbleibenden Werte des Arrays einer Variablen zuweisen. Da die Werte [ 6, 7, 8, 9 ] die verbleibenden Werte des Arrays sind, werden sie der variablen rest zugeordnet.
Daher ist das Endergebnis: 1 3 2 [ 6, 7, 8, 9 ] , das ist 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 )Was gibt der obige Code -Snippet aus?
Das new Date() gibt das aktuelle Datum und die aktuelle Uhrzeit zurück, gefolgt von den beiden angegebenen Daten im Format "yyyy-mm-ddthh: mm: ss.sssz", wobei "z" den UTC-Zeitzonenversatz darstellt.
YYYY-MM-DDTHH:mm:ss.sssZ ist ein Format, das zur Darstellung von Daten und Zeiten im ISO 8601-Standard verwendet wird. Es besteht aus den folgenden Komponenten:
YYYY : Vierstelliges Jahr (0000 bis 9999) oder als erweitertes Jahr mit + oder - gefolgt von sechs Ziffern. Das Zeichen ist für erweiterte Jahre erforderlich. -000000 wird ausdrücklich als gültiges Jahr nicht zugelassen.MM : Zweistelliger Monat (01 = Januar, 02 = Februar und so weiter). Es ist standardmäßig 01.DD : Zweistelliger Tag des Monats (01 bis 31)T : Ein Trennzeichen, das den Beginn der Zeitkomponente angibtHH : Zweistellige Stunde des Tages im 24-Stunden-Format (00 bis 23). Als Sonderfall ist 24:00:00 Uhr erlaubt und wird zu Beginn des nächsten Tages als Mitternacht interpretiert. Standardmäßig 00.mm : zweistellige Minute der Stunde (00 bis 59). Standardmäßig 00.ss : Zwei-stellige Sekunde der Minute (00 bis 59). Standardmäßig 00..sss : Millisekundenkomponente (000 bis 999). Standardmäßig auf 000.Z : Ein Suffix, das angibt, dass die Zeit in UTC (koordinierte universelle Zeit) ohne Versatz ist. Es kann entweder das buchstäbliche Zeichen Z (an, das UTC anzeigt) oder + oder - gefolgt von HH: MM, den Offset in Stunden und Minuten von UTC von UTC sein. 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 ( ) ,
)Was gibt der obige Code -Snippet aus?
Der bereitgestellte Code erstellt ein Datumsobjekt, das mit dem Datum und der Uhrzeit von "15. März 1975 23:15:30" initialisiert wurde.
Anschließend modifiziert es das Protokoll- und UTC -Datum des Datumsobjekts mit den Methoden setMinutes() bzw. setUTCDate() .
Schließlich protokolliert es die aktualisierten Werte von Protokoll-, Jahr und UTC -Datum mit console.log() .
Nach der Änderung der Minuten auf 10 mit setMinutes(10) gibt die getMinutes() -Methode den aktualisierten Wert von 10 zurück.
Nach der Änderung des UTC -Datums auf 5 unter Verwendung von setUTCDate(5) gibt die Methode getUTCDate() den aktualisierten Wert von 5 zurück.
Die Methode getFullYear() gibt das unveränderte Jahr, das 1975 ist, zurück.
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' )Was gibt der obige Code -Snippet aus?
Der Code berechnet die Differenz in den Tagen zwischen dem Datum "2023-5-1" und dem nächsten US-Wahldatum "2024-11-5". Es verwendet das Date , um zwei Daten zu erstellen: date1 repräsentiert 1. Mai 2023, und next_us_election repräsentiert den 5. November 2024.
Die getTime() -Methode wird verwendet, um den Zeitwert in Millisekunden für jedes Datum zu erhalten. Durch Subtrahieren des Zeitwerts von date1 von next_us_election erhalten wir den Zeitunterschied in Millisekunden.
Um den Zeitunterschied von Millisekunden in Tage umzuwandeln, teilen wir ihn an einem Tag durch die Anzahl der Millisekunden (1000 _ 3600 _ 24). Das Ergebnis wird in den variablen difference_in_days gespeichert.
Schließlich wird die parseInt() -Funktion verwendet, um den Wert differenz_in_days in eine Ganzzahl umzuwandeln, und das Ergebnis wird zusammen mit der String "Days" an der Konsole protokolliert. Die Ausgabe beträgt "554 Tage".
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 ( )Was gibt der obige Code -Snippet aus?
Der Code definiert eine person mit Eigenschaften wie name , age , hobbies und address sowie eine Methode sayHello .
Die console.log() -Anweisungen drucken den Wert des name , das zweite Element des hobbies -Arrays (das "Reisen") und den Wert des Stadteigentums im address (das "New York") und den Wert des city ) drucken.
Schließlich wird die Methode sayHello unter Verwendung einer Punktnotation auf das person aufgerufen, das die Zeichenfolge "Hallo, mein Name ist John" zur Konsole ausgibt.
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 )Was gibt der obige Code -Snippet aus?
Der Code definiert einen User , der user mit einer username -Eigenschaft und einer updateUsername -Methode erstellt. Zwei user , user1 und user2 , werden mit den ersten Benutzernamen 'Kirandash' bzw. 'BGWebagent' erstellt.
Die updateUsername -Methode wird sowohl auf user1 als auch user2 -Objekte aufgerufen, um ihre Benutzernamen zu aktualisieren. Der Benutzername von user1 wird auf "Kirandash-Website" aktualisiert, und der Benutzername von user2 wird auf "BGWEBAGECY-APP" aktualisiert.
Schließlich protokolliert der Code die Verkettung von user1.username und user2.username , was dazu führt, dass die Ausgabe 'Kirandash-Websit BGWebagenty-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' )Was gibt der obige Code -Snippet aus?
Die call wird verwendet, um die greet -Funktion mit dem person als Kontext (den Wert this ) und 'John' als Argument aufzurufen.
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 )
