who wants to be a javascriptaire
1.0.0
Manera divertida de aprender JavaScript para sus entrevistas de codificación/codificación web. Todas las preguntas se responden aquí en texto y también tienen un video en nuestro canal de YouTube. Haga clic en el
¡No dude en comunicarse con nosotros en nuestras plataformas sociales! ?
Discordia || Instagram || Twitter || Tiktok || Blog || Facebook
Apoyo
Por favor, estrella este proyecto y compártelo con otros para mostrar tu apoyo. ¡Sígueme ❤️ para obtener actualizaciones sobre proyectos y tutoriales futuros!
Conceptos básicos del idioma - Matrices - Fecha y hora - JavaScript orientado a objetos - Módulos - Varios
console . log ( new Date ( 2023 , 1 , 31 ) )Tue Jan 31 2024Tue Jan 31 2023Fri Mar 03 2023ErrorEn JavaScript, mientras se construye fechas que usan objetos de fecha, los meses se basan 0. Lo que significa que 0 es para enero y el 1 es para febrero.
Entonces, en este caso, estamos pidiendo a JavaScript que establezca una fecha del 31 de febrero que no existe.
Pero en lugar de lanzar un error, JavaScript lo desborde al próximo mes, que es marzo.
Y desde febrero de 2023 tiene solo 28 días, el código se desbordará por 3 días, lo que hace que el resultado sea el 3 de marzo de 2023.
var username = 'kirandash'
var username = 'bgwebagency'
console . log ( username )bgwebagencykirandashReferenceErrorSyntaxError Podemos declarar la misma variable varias veces usando la palabra clave var . Y la variable mantendrá el valor que se asignó al final.
Pero no podemos declarar la misma variable varias veces usando let o const
const user = {
username : 'kirandash' ,
updateUsername : newName => {
this . username = newName
} ,
}
user . updateUsername ( 'bgwebagency' )
console . log ( user . username )bgwebagencyReferenceErrorkirandashundefined Porque la función updateUsername no funciona correctamente y no puede actualizar el username del user .
La función updateUsername en object de usuario es una función de flecha y no está vinculado al objeto user .
Por lo tanto, this palabra clave dentro de la función UpdateUsername no se refiere al objeto user , sino que se refiere al alcance global.
Para solucionar este problema, debemos cambiar la función de flecha a una función normal.
const len1 = 'kiran' . length
const len2 = '?' . length
console . log ( len1 , len2 )5, 25, 15, undefined5, SyntaxErrorEn JavaScript, la propiedad de longitud de cadena devuelve el número de bytes y no el número de caracteres como esperamos.
Un emoji es un personaje unicode que está codificado en dos bytes. Por lo tanto, la respuesta es 2 para esta pregunta.
La longitud de la cadena para kiran devuelve 5 porque en una cadena cada carácter es 1 byte.
console . log ( undefined == null , undefined === null )true, truetrue, falsefalse, falsefalse, truePrimero permítanme explicar la diferencia entre un operador igual igual y estricto.
El operador igual solo verifica si ambos valores son iguales. El estricto operador igual verifica si tanto el valor como el tipo son iguales.
Entonces, en este código, la primera declaración undefined == null devuelve true ya que tanto undefined como null tienen el mismo valor que está vacío.
Pero la segunda declaración undefined === null devuelve false . Dado que typeof undefined está undefined , mientras que typeof null es un object .
Es posible que se pregunte por qué typeof null es un object cuando null es básicamente un tipo de datos primitivo. Básicamente, esto es un error en JavaScript desde el principio.
Ahora, un consejo más para usted: cuando desea establecer un valor vacío para una variable, use null en lugar de undefined . Dado que undefined se usa principalmente para verificar si una variable no tiene valor asignado.
function getFruits ( x , ... multi , y ) {
console . log ( x , y , multi ) ;
}
getFruits ( "?" , "?" , "?" , "?" , "?" )? ? ["?", "?", "?"]SyntaxErrorLos operadores de descanso se agregaron como parte de la función ES6.
Se necesitan todos los argumentos pasados a una función y lo pone en una matriz.
Si se pasan múltiples argumentos a una función, entonces el operador REST debe llegar al final. Es por eso que este fragmento de código arrojará un error.
Para solucionar este problema, mueva el operador REST al final y luego debería funcionar.
let x = Number . NEGATIVE_INFINITY
let y = Number . POSITIVE_INFINITY
let z = x + y
console . log ( z )0undefinedNaNTypeErrorNegativo_infinity y position_infinity son propiedades del objeto número en JavaScript que representa el concepto matemático de infinito negativo e infinito positivo.
Cuando agrega número.
Agregar un valor infinito positivo a un valor infinito negativo no da como resultado un valor numérico significativo.
Entonces, en este caso, Z será Nan.
Tenga en cuenta que el código no lanzará un TipoError, ya que JavaScript puede realizar la operación de adición entre el número.
console . log ( 'BG Web Agency' === NaN , isNaN ( 'BG Web Agency' ) )true, truefalse, truetrue, falsefalse, false Usando === NaN para verificar si un valor es un número no funcionará.
En JavaScript, NaN (no un número) es un valor especial que representa un número no válido.
NAN no es igual a nada, incluido sí mismo, por lo que la expresión "BG Web Agency" === NaN siempre devolverá false .
Para verificar si un valor es un número en JavaScript, puede usar la función isNaN() . Esta función devuelve true si el argumento se le pasa es NaN , o si no se puede convertir a un número.
console . log ( isFinite ( Infinity ) , isNaN ( Infinity ) )false, falsefalse, truetrue, falsefalse, false La función isFinite() se usa para determinar si un valor dado es un número finito.
Devuelve falso si el valor es Nan, Infinity o -infinity, y verdadero si el valor es un número finito.
Entonces, en este ejemplo, isFinite(Infinity) devolverá falso porque el infinito no es un número finito.
Por otro lado, la función ISNAN () se usa para determinar si un valor dado no es un número (NAN).
Devuelve verdadero si el valor es nan y falso si el valor es un número o cualquier otro tipo de datos.
Entonces, en este ejemplo, isNaN(Infinity) también devolverá falso porque el infinito no es Nan.
Por lo tanto, use siempre la función isFinite en lugar de la función isNaN cuando desea validar si un número es finito
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 función getName Arrow usa this palabra clave para referirse a la propiedad de nombre del objeto, pero debido a que las funciones de flecha tienen un léxico this enlace, el valor de this palabra clave dentro de la función de flecha será el objeto global que es window en un navegador o global en node.js.
Dado que no hay propiedad de nombre en el objeto global , la función regresa undefined .
La función getAge utiliza una expresión de función regular y se refiere correctamente a la propiedad de edad del objeto user utilizando this palabra clave.
Pero cuando se asigna getAge a la variable getAge , pierde la referencia al objeto user , por lo que cuando la función se llama usando getAge() , esto se referirá al objeto global nuevamente, y dado que no hay propiedad de edad en el objeto global, la función devuelve indefinida.
for ( var i = 0 ; i < 3 ; i ++ ) {
setTimeout ( function ( ) {
console . log ( i )
} , 0 )
}Un cierre es una función que retiene el acceso a variables en su alcance externo, incluso después de que la función exterior ha regresado.
En este ejemplo, la respuesta es B, porque la función SetTimeOut es asíncrona y no se ejecuta de inmediato.
Para cuando se ejecuta la función de devolución de llamada pasada a SetTimout, el bucle ya se ha completado y la variable I tiene un valor de 3.
Por lo tanto, cada llamada a consola.log (i) dentro de la función de devolución de llamada imprimirá 3.
Para resolver este problema e imprimir 0, 1, 2, podemos usar una IFE (expresión de la función invocada inmediatamente) para crear un nuevo alcance para cada iteración del bucle.
Esto crea una nueva variable j dentro de cada iife, con su propia copia del valor actual de I en esa iteración del bucle.
Cuando se ejecuta la función de devolución de llamada pasada a SetTimeOut, tiene acceso a la variable J en su cierre, que tiene el valor esperado de 0, 1 o 2 para cada iteración del bucle.
function add ( x ) {
return function ( y ) {
if ( y !== undefined ) {
x += y
return arguments . callee
} else {
return x
}
}
}
console . log ( add ( 1 ) ( 2 ) ( 3 ) ( ) )La respuesta correcta es A. El código define una función ADD que toma un solo argumento X y devuelve otra función que toma un solo argumento y.
Esta función interna verifica si Y está definido. Si se define, agrega Y a X y devuelve una referencia a sí misma usando la propiedad Arguments.callee, que permite que la función se llame recursivamente con el siguiente argumento.
Si Y no está definido, devuelve el valor actual de x.
Luego, el código llama a agregar (1) (2) (3) (). Esta primera llama agregar (1) con 1 como argumento, que devuelve una función que toma un solo argumento y.
Luego, llama a esta función con 2 como argumento, que agrega 2 a 1 y devuelve una referencia a la función.
Finalmente, llama a esta función con 3 como argumento, que agrega 3 a 3 y devuelve una referencia a la función.
Como no se pasa ningún argumento en la última llamada, devuelve el valor actual de X, que es 6.
Este código demuestra un ejemplo más complejo de curry en JavaScript, donde la función curry devuelve una referencia a sí misma, lo que permite que se llame recursivamente con el siguiente argumento.
function multiply ( x ) {
return function ( y ) {
return x * y
}
}
const double = multiply ( 2 )
console . log ( double ( 5 ) )La respuesta correcta es B. El código define una función de multiplicación que toma un solo argumento x y devuelve otra función que toma un solo argumento y. Esta función interna multiplica X e Y y devuelve el resultado.
Luego, el código crea una nueva función doble llamando a Multiply con 2 como argumento. La función doble ahora es una función curry que puede llamarse con un solo argumento para duplicar su valor.
Finalmente, el código llama el doble con 5 como argumento, lo que resulta en que se registren 10 a la consola.
Este código demuestra el concepto de curry en JavaScript, donde una función devuelve otra función que se puede aplicar parcialmente con algunos argumentos.
¿Cuál de las siguientes afirmaciones es verdadera sobre el método next() de un iterador en JavaScript?
La respuesta correcta es A.
En JavaScript, un iterable es un objeto que define una secuencia y puede iterarse sobre un bucle.
Un iterador es un objeto que sabe cómo acceder a los elementos de uno iterable a la vez.
Un objeto iterable tiene un método con la clave Symbol.iterator , que devuelve un objeto Iterator.
El objeto Iterator tiene un método next() , que devuelve un objeto con dos propiedades: value , que es el siguiente elemento en la secuencia, y done , que es un booleano que indica si el iterador ha alcanzado el final de la secuencia.
Los iterables se usan comúnmente en muchas aplicaciones en tiempo real mientras se trabaja con grandes conjuntos de datos, o mientras implementan estructuras de datos personalizadas
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 )¿Qué sale del fragmento de código anterior?
La respuesta correcta es D.
La función counter es una función generadora que crea un bucle infinito que produce valores incrementados de i .
La variable gen se establece en la función del generador, y cada llamada a gen.next() devuelve un objeto con la propiedad de valor establecida en el siguiente valor.
Las declaraciones console.log luego impriman los valores devueltos por gen.next() .
Una función del generador es un tipo especial de función que puede usarse para controlar la iteración en una secuencia de valores.
A diferencia de las funciones tradicionales, las funciones del generador le permiten hacer una pausa y reanudar su ejecución, y producir múltiples valores con el tiempo.
¿Cuál de los siguientes escenarios podría causar una fuga de memoria en JavaScript?
Las referencias circulares ocurren cuando dos o más objetos se hacen referencia entre sí, creando un bucle que evita que los objetos sean recolectados de basura.
Esto puede causar una fuga de memoria si los objetos ya no son necesarios pero no pueden liberarse debido a la referencia circular.
Las opciones A, C y D no generalmente causan fugas de memoria en JavaScript.
La recolección de basura es el proceso de liberar automáticamente la memoria que ya no está siendo utilizada por un programa.
En JavaScript, el algoritmo de marca y barrido se usa comúnmente para la recolección de basura.
Este algoritmo funciona primero marcando todos los objetos en la memoria a los que todavía están siendo referenciados por el programa, luego barriendo y liberando cualquier memoria que no esté marcada como en uso.
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 ( ) )
} ) ( )¿Qué sale del fragmento de código anterior?
Cuando se ejecuta el código, se llama a la función Main (), que es una función Async que usa la esperanza para obtener datos de la función getData() .
Una vez que se recuperan los datos, la instrucción console.log(data) registra "datos recuperados con éxito" a la consola.
Después de eso, la declaración throw new Error("Something went wrong") arroja un error.
El bloque catch captura el error y los registros "Caught an error: Something went wrong" en la consola y luego devuelve la cadena "Error occurred" .
Finalmente, el bloque finalmente se ejecuta y los registros "Finally block executed." a la consola y luego devuelve la cadena "Finally block value" .
Cuando se llama a la función main() , devuelve una promesa porque es una función async. Dado que el bloque finally también devuelve un valor, ese valor será el valor final resuelto de la promesa.
Por lo tanto, cuando console.log(main()) se llama, "Finally block executed." y "Finally block value" se registrará a la consola.
Pruebe, atrapa y finalmente son palabras clave utilizadas en JavaScript para manejar los errores de tiempo de ejecución.
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 ) ;¿Qué sale del fragmento de código anterior?
Porque la declaración break no es válida dentro de la función de devolución de llamada pasada a forEach .
forEach no admite la terminación temprana utilizando la declaración break . Por lo tanto, se arroja un error: "Uncaught SyntaxError: Illegal break statement".
En caso de para el bucle, se permite la instrucción break .
Para solucionar el problema, elimine la declaración break de foreach y debería funcionar.
En general, for of se recomienda for in forEach
let arr = [ 1 , 2 , 3 , 4 ]
let result = arr . push ( 5 )
console . log ( 'result: ' , result , 'arr: ' , arr )¿Qué sale del fragmento de código anterior?
El método array.push() en JavaScript agrega uno o más elementos al final de una matriz y devuelve la nueva longitud de la matriz.
En el código dado, arr es una matriz con los valores [1, 2, 3, 4] . El método push() se llama con el argumento 5, que agrega 5 al final de la matriz arr .
El método push() devuelve la nueva longitud de la matriz después de la adición de los elementos (s). En este caso, la nueva longitud de ARR será 5 porque se agrega 5 al final de la matriz.
let arr = [ 3 , 5 , 7 , 9 ]
let result = arr . unshift ( 1 , 2 )
console . log ( 'result: ' , result , 'arr: ' , arr )¿Qué sale del fragmento de código anterior?
El método array.unshift() en JavaScript agrega uno o más elementos al comienzo de una matriz y devuelve la nueva longitud de la matriz.
En el código dado, arr es una matriz con los valores [3, 5, 7, 9] . El método unshift() se llama con los argumentos 1 y 2, que agrega 1 y 2 al comienzo de la matriz arr .
El método unshift() devuelve la nueva longitud de la matriz después de la adición de los elementos (s). En este caso, la nueva longitud de arr será 6 porque 1 y 2 se agregarán al comienzo de la matriz, cambiando los elementos existentes a la derecha.
const myArray = [ 1 , 2 , 3 , 4 , 5 ]
const poppedValue = myArray . pop ( )
console . log ( poppedValue )¿Qué sale del fragmento de código anterior?
El método Array.pop() en JavaScript elimina el último elemento de una matriz y devuelve ese elemento.
En este caso, myArray es una matriz con elementos [1, 2, 3, 4, 5] , y se llama a myArray.pop() , que elimina el elemento 5 de la matriz y lo devuelve.
const arr = [ 10 , 20 , 30 , 40 , 50 ]
const removedElement = arr . shift ( )
console . log ( 'removedElement: ' , removedElement , 'arr: ' , arr )¿Qué sale del fragmento de código anterior?
El método Array.shift() elimina el primer elemento de la matriz arr , que es 10 , y lo devuelve. La matriz arr resultante será [20, 30, 40, 50] .
Por lo tanto, la opción A es la respuesta correcta, ya que refleja el valor correcto de removedElement y se llama al estado actualizado de arr después de Array.shift() . La opción B es incorrecta, ya que establece que removedElement será 50, lo cual no es cierto. La opción C también es incorrecta, ya que afirma que arr permanece sin cambios, lo que no es preciso. La opción D es ligeramente confusa, ya que establece que Array.shift() devuelve la matriz, lo cual no es cierto.
let arr = [ 1 , 2 , 3 , 4 , 5 ]
let removed = arr . splice ( 1 , 2 , 'a' , 'b' )
console . log ( 'removed:' , removed , 'arr: ' , arr )¿Qué sale del fragmento de código anterior?
El método Array.splice() se utiliza para modificar una matriz agregando, eliminando o reemplazando elementos.
En este caso, el fragmento de código usa arr.splice(1, 2, 'a', 'b') , que comienza desde el índice 1 (eliminando 2 elementos) e inserta los elementos a y b en su lugar. Los elementos que se eliminan (es decir, 2 y 3) se devuelven y se asignan a la variable eliminada. Después de la ejecución, se eliminará [2, 3] y arr será [1, 'a', 'b', 4, 5] . La opción C es incorrecta ya que incluye los elementos insertados en la matriz eliminada, que no es precisa. La opción D también es incorrecta, ya que menciona los elementos incorrectos que se eliminan de la matriz.
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 )¿Qué sale del fragmento de código anterior?
El método Array.indexOf() busca el índice de la primera aparición del valor especificado en las frutas de matriz. En este caso, "naranja" se encuentra en el índice 2, por lo que index será 2.
El método Array.lastIndexOf() busca el índice de la última aparición del valor especificado en las frutas de matriz. En este caso, "Apple" aparece dos veces en la matriz y su última ocurrencia está en el índice 4, por lo que lastIndex será 4.
Por otro lado, el método Array.includes() verifica si el valor especificado "uva" existe en las frutas de matriz, y dado que "uva" está presente en la matriz, result será cierto.
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 ,
)¿Qué sale del fragmento de código anterior?
El método Array.filter() devuelve una matriz que contiene todos los elementos para los cuales la función pasada a ella devuelve verdadera. En este caso, la función isDivisibleBy7 devuelve verdadero para cualquier número que sea divisible por 7. En la matriz nums , 7 y 28 son divisibles por 7, por lo que nums.filter(isDivisibleBy7) devuelve [28, 7].
El método Array.find() devuelve el primer elemento en la matriz para el cual la función pasada a ella devuelve verdadero. En este caso, la función pasada a ella devuelve verdadero para cualquier número menor de 10. Hay múltiples números en nums que son menos de 10, pero dado que Array.find() solo devuelve el primero para el cual es verdadero, nums.find((num) => num < 10) devuelve 7.
El método Array.findIndex() es similar al método Array.find() , pero devuelve el índice del primer elemento en la matriz para la cual la función pasada a ella devuelve verdadero, en lugar del elemento en sí. En este caso, la función pasada a ella devuelve verdadera para 28, ya que el 28/2 == 14. 28 está en los nums de matriz y está en el índice 0, por lo que nums.find((num) => num / 2 == 14) devuelve 0.
const numbers = [ 1 , 2 , 3 , 4 , 5 ]
const doubledNumbers = numbers . map ( num => num * 2 )
console . log ( doubledNumbers )¿Qué sale del fragmento de código anterior?
El método Array.map() en JavaScript crea una nueva matriz aplicando una función proporcionada a cada elemento de la matriz original.
En este caso, la función proporcionada num => num * 2 multiplica cada número en la matriz de números por 2, lo que resulta en una nueva matriz [2, 4, 6, 8, 10] .
const numbers = [ 1 , 2 , 3 , 4 , 5 ]
const sum = numbers . reduce ( ( acc , val ) => acc + val )
console . log ( sum )¿Qué sale del fragmento de código anterior?
Array.reduce() toma una matriz y "la reduce" a un solo valor aplicando repetidamente una función a cada elemento y realizando un seguimiento del resultado acumulado. Se usa comúnmente para tareas como sumar una matriz de números, encontrar el valor máximo o concatenar una matriz de cadenas en una sola cadena.
En este caso, el método Rede () toma una función de devolución de llamada que se ejecuta para cada elemento de la matriz. La función de devolución de llamada toma dos parámetros, acc y val , que representan el acumulador y el valor actual de la matriz, respectivamente.
Dentro de la función de devolución de llamada, el valor actual de la matriz se agrega al acumulador y se devuelve el resultado. El método reduce() actualiza el valor del acumulador con cada iteración hasta que se haya iterado sobre todos los elementos de la matriz.
Finalmente, el método reduce() devuelve el valor final del acumulador, que es la suma de todos los números en la matriz, que es 15.
const arr = [ 1 , 2 , 3 , 4 ]
const result = arr . reduceRight ( ( acc , curr ) => acc + curr )
console . log ( result )¿Qué sale del fragmento de código anterior?
El método reduceRight() es similar al método reduce() , excepto que comienza a reducir la matriz desde el elemento más a la derecha al elemento más a la izquierda. El método reduceRight() aplica una función contra un acumulador y cada valor de la matriz (de derecha a izquierda) para reducirlo a un solo valor.
En el fragmento de código dado, la matriz arr contiene los valores [1, 2, 3, 4] . El método reduceRight() se llama en esta matriz con una función de devolución de llamada que agrega el acumulador acc con el elemento actual curr .
En la primera iteración, el valor curr será 4 , y el valor ACC estará undefined , ya que no se proporciona ningún valor inicial. Por lo tanto, el resultado de la primera iteración será 4 .
En la segunda iteración, el valor curr será 3 , y el valor acc será el resultado de la iteración anterior, que es 4 . Por lo tanto, el resultado de la segunda iteración será 7 .
En la tercera iteración, el valor curr será 2 , y el valor acc será el resultado de la iteración anterior, que es 7 . Por lo tanto, el resultado de la tercera iteración será 9 .
En la cuarta y última iteración, el valor curr será 1 , y el valor acc será el resultado de la iteración anterior, que es 9 . Por lo tanto, el resultado de la cuarta iteración será 10 .
Por lo tanto, la salida final del código será 10 . Por lo tanto, la opción correcta es A.
const arr = [ 'Centauri' , 3.14159 , 'canine' , 11235 , undefined ]
const result = arr . sort ( )
console . log ( result )¿Qué sale del fragmento de código anterior?
Por defecto, el método sort() clasifica elementos por carácter, por lo que 11235 viene antes de 3.14159 porque 1 viene antes de 3.
Las palabras y las letras se clasifican alfabéticamente mediante código ASCII, por lo que "Centauri" que comienza con una clasificación de C (código ASCII 67) en mayúscula antes de "canino" que comienza con una minúscula C (código ASCII 99).
Los elementos indefinidos siempre se clasifican hasta el final de una matriz.
Por lo tanto, la salida final del código será [11235, 3.14159, 'Centauri', 'canino', indefinido] que es la opción D.
let numbers = [ 1 , 2 , 3 , undefined , 6 , 7 , 8 , 9 ]
let [ a , , b , c = 2 , ... rest ] = numbers
console . log ( a , b , c , rest )¿Qué sale del fragmento de código anterior?
Con la destrucción de la matriz, es posible desempacar ciertos valores de una matriz en variables individuales. Los valores que creamos en el lado izquierdo ( a, b, c, rest ) corresponden a los valores y el orden de la matriz que asignamos en el lado derecho ( numbers ).
La variable a corresponde al primer elemento de la matriz, que es 1 .
Como no especificamos una variable para el siguiente valor 2 , el valor no se tiene en cuenta en la evaluación y se omite.
La variable b corresponde al tercer elemento de la matriz, que es 3 .
Es posible establecer valores predeterminados para las variables si el elemento en la matriz está undefined . Dado que el cuarto elemento en la matriz undefined está definido, la variable c tiene el valor predeterminado 2 .
Con el operador de propagación ( ... ) podemos asignar los valores restantes de la matriz a una variable. Dado que los valores [ 6, 7, 8, 9 ] son los valores restantes de la matriz, se asignan al rest variable.
Por lo tanto, el resultado final es: 1 3 2 [ 6, 7, 8, 9 ] , que es la opción 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 )¿Qué sale del fragmento de código anterior?
new Date() devolverá la fecha y hora actuales seguidas de las dos fechas especificadas en el formato "A yyyy-MM-DDTHH: MM: SS.SSZ", donde "Z" representa el desplazamiento de la zona horaria de UTC.
YYYY-MM-DDTHH:mm:ss.sssZ es un formato utilizado para representar fechas y tiempos en el estándar ISO 8601. Consiste en los siguientes componentes:
YYYY : año de cuatro dígitos (0000 a 9999), o como un año ampliado con + o - seguido de seis dígitos. El signo se requiere durante años ampliados. -000000 se nota explícitamente como un año válido.MM : Mes de dos dígitos (01 = enero, 02 = febrero, etc.). El valor predeterminado es 01.DD : Día del mes de dos dígitos (01 a 31)T : un separador que indica el inicio del componente de tiempoHH : Hora de dos dígitos del día en formato las 24 horas (00 a 23). Como caso especial, se permite las 24:00:00 y se interpreta como la medianoche al comienzo del día siguiente. Predeterminado a 00.mm : minuto de dos dígitos de la hora (00 a 59). Predeterminado a 00.ss : segundo de dos dígitos del minuto (00 a 59). Predeterminado a 00..sss : componente de milisegundos (000 a 999). El valor predeterminado a 000.Z : Un sufijo que indica que el tiempo está en UTC (tiempo universal coordinado), sin compensación. Puede ser el carácter literal Z (que indica UTC), o + o, seguido de HH: mm, el desplazamiento en horas y minutos de 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 ( ) ,
)¿Qué sale del fragmento de código anterior?
El código proporcionado crea un objeto de fecha inicializado con la fecha y hora del "15 de marzo de 1975 23:15:30".
Luego, modifica las actas y la fecha UTC del objeto FECHA utilizando los métodos setMinutes() y setUTCDate() , respectivamente.
Finalmente, registra los valores actualizados de minutos, año y fecha UTC usando console.log() .
Después de modificar las actas a 10 usando setMinutes(10) , el método getMinutes() devuelve el valor actualizado de 10.
Después de modificar la fecha de UTC a 5 usando setUTCDate(5) , el método getUTCDate() devuelve el valor actualizado de 5.
El método getFullYear() devuelve el año sin cambios, que es 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' )¿Qué sale del fragmento de código anterior?
El código calcula la diferencia en los días entre la fecha "2023-5-1" y la próxima fecha de elección de EE. UU. "2024-11-5". Utiliza el objeto Date para crear dos fechas: date1 representa el 1 de mayo de 2023 y next_us_election representa el 5 de noviembre de 2024.
El método getTime() se usa para obtener el valor de tiempo en milisegundos para cada fecha. Al restar el valor de tiempo de date1 de next_us_election , obtenemos la diferencia de tiempo en milisegundos.
Para convertir la diferencia horaria de milisegundos a días, la dividimos por el número de milisegundos en un día (1000 _ 3600 _ 24). El resultado se almacena en la difference_in_days variable_in_days.
Finalmente, la función parseInt() se usa para convertir el valor de diferencia_in_days en un entero, y el resultado se registra en la consola junto con la cadena "Días". La salida será "554 días".
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 ( )¿Qué sale del fragmento de código anterior?
El código define a una person literal de objetos con propiedades como name , age , hobbies y address , y un método sayHello .
Las declaraciones console.log() imprimen el valor de name , el segundo elemento de la matriz de hobbies (que es "viajar") y el valor de la propiedad city en el objeto address (que es "Nueva York").
Finalmente, el método sayHello se llama al objeto person usando notación de puntos, que genera la cadena "Hola, mi nombre es John" a la consola.
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 )¿Qué sale del fragmento de código anterior?
El código define un User de la función de constructor que crea objetos user con una propiedad username y un método de updateUsername . Dos objetos user , user1 y user2 , se crean con los nombres de usuario iniciales 'Kirandash' y 'BGWeBagency' respectivamente.
El método updateUsername se llama a los objetos user1 y user2 para actualizar sus nombres de usuario. El nombre de usuario de user1 se actualiza a 'Kirandash-Website', y el nombre de usuario de user2 se actualiza a 'BGWeBagency-App'.
Finalmente, el código registra la concatenación de user1.username y user2.username , lo que da como resultado la salida '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' )¿Qué sale del fragmento de código anterior?
La función call se usa para invocar la función greet con el objeto person como el contexto (el valor de this ) y 'John' como el argumento.
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?
Opciones:
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 ?
Opciones:
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 )
