who wants to be a javascriptaire
1.0.0
Maneira divertida de aprender JavaScript para suas entrevistas de codificação de front -end/web. Todas as perguntas são respondidas aqui no texto e também têm um vídeo em nosso canal do YouTube. Clique no
Sinta -se à vontade para entrar em contato conosco em nossas plataformas sociais! ?
Discord || Instagram || Twitter || Tiktok || Blog || Facebook
Apoiar
Por favor sustde este projeto e compartilhe -o com outras pessoas para mostrar seu apoio. Siga -me ❤️ Para atualizações sobre projetos e tutoriais futuros!
Basics de idioma - Matriz - Data e hora - JavaScript orientado a objeto - Módulos - Diversos
console . log ( new Date ( 2023 , 1 , 31 ) )Tue Jan 31 2024Tue Jan 31 2023Fri Mar 03 2023ErrorNo JavaScript, enquanto a construção de datas usando objetos de data são baseados em 0. O que significa que 0 é para janeiro e 1 é para fevereiro.
Portanto, neste caso, estamos pedindo ao JavaScript para definir uma data de 2023, 31 de fevereiro, que não existe.
Mas, em vez de lançar erros, o JavaScript o transbordará para o próximo mês, que é março.
E desde fevereiro de 2023 tem apenas 28 dias, o código transbordará em 3 dias, tornando o resultado em 3 de março de 2023.
var username = 'kirandash'
var username = 'bgwebagency'
console . log ( username )bgwebagencykirandashReferenceErrorSyntaxError Podemos declarar a mesma variável várias vezes usando a palavra -chave var . E a variável manterá o valor que foi atribuído no final.
Mas não podemos declarar a mesma variável várias vezes usando let ou const
const user = {
username : 'kirandash' ,
updateUsername : newName => {
this . username = newName
} ,
}
user . updateUsername ( 'bgwebagency' )
console . log ( user . username )bgwebagencyReferenceErrorkirandashundefined Como a função updateUsername não está funcionando corretamente e não está atualizando o username do user .
A função updateUsername no object do usuário é uma função de seta e não está vinculada ao objeto user .
Portanto, a função this Keyword Inside UpdateUserName não se refere ao objeto user , mas refere -se ao escopo global.
Para corrigir esse problema, devemos alterar a função de seta para uma função normal.
const len1 = 'kiran' . length
const len2 = '?' . length
console . log ( len1 , len2 )5, 25, 15, undefined5, SyntaxErrorNo JavaScript, a propriedade Comprimento da String retorna o número de bytes e não o número de caracteres como esperamos.
Um emoji é um caractere unicode que é codificado em dois bytes. Portanto, a resposta é 2 para esta pergunta.
O comprimento da corda para kiran retorna 5 porque em uma corda cada caractere é 1 byte.
console . log ( undefined == null , undefined === null )true, truetrue, falsefalse, falsefalse, truePrimeiro, deixe -me explicar a diferença entre operador igual e estrito.
O operador igual apenas verifica se os dois valores são iguais. O rigoroso operador igual verifica se o valor e o tipo são iguais.
Portanto, neste código, a primeira instrução undefined == null retorna true pois ambos undefined e null têm o mesmo valor que está vazio.
Mas a segunda declaração undefined === null retorna false . Como typeof undefined é undefined , enquanto typeof null é um object .
Você pode estar se perguntando, por que typeof null é um object quando null é basicamente um tipo de dados primitivo. Isso basicamente é um erro em JavaScript desde o início.
Agora, mais uma dica para você: quando você deseja definir um valor vazio para uma variável, use null em vez de undefined . Como undefined é usado principalmente para verificar se uma variável não tem valor atribuído a ele.
function getFruits ( x , ... multi , y ) {
console . log ( x , y , multi ) ;
}
getFruits ( "?" , "?" , "?" , "?" , "?" )? ? ["?", "?", "?"]SyntaxErrorOs operadores de repouso foram adicionados como parte do recurso ES6.
São necessários todos os argumentos passados para uma função e a coloca em uma matriz.
Se vários argumentos forem passados para uma função, o operador de restos deverá chegar no final. É por isso que esse snippet de código lançará um erro.
Para corrigir esse problema, mova o operador restante para o final e então ele deve funcionar.
let x = Number . NEGATIVE_INFINITY
let y = Number . POSITIVE_INFINITY
let z = x + y
console . log ( z )0undefinedNaNTypeErrorNegativo_infinity e positivo_infinity são propriedades do objeto numérico no JavaScript que representa o conceito matemático de infinidade negativa e infinidade positiva.
Quando você adiciona número.negative_infinity e número.positive_infinity, o resultado é NAN.
Adicionar um valor infinito positivo a um valor infinito negativo não resulta em um valor numérico significativo.
Então, neste caso, Z será NAN.
Observe que o código não jogará um TypeError, pois o JavaScript é capaz de executar a operação de adição entre o número.negative_infinity e o número.positive_infinity.
console . log ( 'BG Web Agency' === NaN , isNaN ( 'BG Web Agency' ) )true, truefalse, truetrue, falsefalse, false Usando === NaN para verificar se um valor é um número não funcionará.
No JavaScript, NaN (não um número) é um valor especial que representa um número inválido.
A NAN não é igual a nada, incluindo a si mesma, então a expressão "BG Web Agency" === NaN sempre retornará false .
Para verificar se um valor é um número no JavaScript, você pode usar a função isNaN() . Esta função retorna true se o argumento passou para ela for NaN , ou se não puder ser convertido em um número.
console . log ( isFinite ( Infinity ) , isNaN ( Infinity ) )false, falsefalse, truetrue, falsefalse, false A função isFinite() é usada para determinar se um determinado valor é um número finito.
Ele retorna false se o valor for nan, infinito ou -infinity, e verdadeiro se o valor for um número finito.
Portanto, neste exemplo, isFinite(Infinity) retornará falso porque o infinito não é um número finito.
Por outro lado, a função isnan () é usada para determinar se um determinado valor não é um número (NAN).
Ele retorna true se o valor for nan e false se o valor for um número ou qualquer outro tipo de dados.
Portanto, neste exemplo, isNaN(Infinity) também retornará falso porque o infinito não é NAN.
Portanto, sempre use a função isFinite em vez da função isNaN quando você deseja validar se um número for 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 ( ) ) A função getName Arrow usa this palavra -chave para se referir à propriedade Nome do objeto, mas como as funções de seta têm this ligação lexical, o valor this palavra -chave dentro da função de seta será o objeto global que é window em um navegador, ou global em Node.js.
Como não há propriedade de nome no objeto global , a função retorna undefined .
A função getAge usa uma expressão de função regular e refere -se corretamente à propriedade etária do objeto user usando this palavra -chave.
Mas quando getAge é atribuído à variável getAge , ele perde a referência ao objeto user ; portanto, quando a função é chamada usando getAge() , isso se referirá ao objeto global novamente e, como não há propriedade de idade no objeto global, a função retorna indefinida.
for ( var i = 0 ; i < 3 ; i ++ ) {
setTimeout ( function ( ) {
console . log ( i )
} , 0 )
}Um fechamento é uma função que mantém o acesso a variáveis em seu escopo externo, mesmo após o retorno da função externa.
Neste exemplo, a resposta é B, porque a função Settimeout é assíncrona e não é executada imediatamente.
Quando a função de retorno de chamada passada para o setTimeout é executada, o loop já foi concluído e a variável I tem um valor de 3.
Portanto, cada chamada para console.log (i) dentro da função de retorno de chamada imprimirá 3.
Para resolver esse problema e imprimir 0, 1, 2, podemos usar um IIFE (expressão de função imediatamente invocada) para criar um novo escopo para cada iteração do loop.
Isso cria uma nova variável j dentro de cada iife, com sua própria cópia do valor atual de I nessa iteração do loop.
Quando a função de retorno de chamada passada para o setTimeout é executada, ela tem acesso à variável J em seu fechamento, que possui o valor esperado de 0, 1 ou 2 para cada iteração do loop.
function add ( x ) {
return function ( y ) {
if ( y !== undefined ) {
x += y
return arguments . callee
} else {
return x
}
}
}
console . log ( add ( 1 ) ( 2 ) ( 3 ) ( ) )A resposta correta é A. O código define uma função Adicionar que pega um único argumento x e retorna outra função que leva um único argumento y.
Esta função interna verifica se y é definido. Se for definido, adiciona y a x e retorna uma referência a si mesma usando os argumentos.
Se Y não estiver definido, ele retornará o valor atual de x.
Em seguida, as chamadas de código add (1) (2) (3) (). Isso primeiro chama Add (1) com 1 como seu argumento, que retorna uma função que leva um único argumento y.
Em seguida, ele chama essa função com 2 como seu argumento, que adiciona 2 a 1 e retorna uma referência à função.
Finalmente, ele chama essa função com 3 como seu argumento, que adiciona 3 a 3 e retorna uma referência à função.
Como nenhum argumento é passado na última chamada, ele retorna o valor atual de x, que é 6.
Este código demonstra um exemplo mais complexo de currying em JavaScript, onde a função curry retorna uma referência a si mesma, permitindo que seja chamada recursivamente com o próximo argumento.
function multiply ( x ) {
return function ( y ) {
return x * y
}
}
const double = multiply ( 2 )
console . log ( double ( 5 ) )A resposta correta é B. O código define uma função de multiplicação que leva um único argumento x e retorna outra função que leva um único argumento y. Esta função interna multiplica x e y e retorna o resultado.
Em seguida, o código cria uma nova função dupla chamando multiplicar com 2 como seu argumento. A função dupla agora é uma função ao curry que pode ser chamada com um único argumento para dobrar seu valor.
Finalmente, o código chama o dobro com 5 como argumento, o que resulta em 10 sendo registrados no console.
Este código demonstra o conceito de currying em JavaScript, onde uma função retorna outra função que pode ser aplicada parcialmente com alguns argumentos.
Qual das seguintes afirmações é verdadeira sobre o método next() de um iterador em JavaScript?
A resposta correta é A.
No JavaScript, um iterável é um objeto que define uma sequência e pode ser iterado com o uso de um loop.
Um iterador é um objeto que sabe como acessar os elementos de um iterável de cada vez.
Um objeto iterável possui um método com o Symbol.iterator da chave.iterator, que retorna um objeto iterador.
O objeto iterador possui um método next() , que retorna um objeto com duas propriedades: value , que é o próximo elemento na sequência, e done , que é um booleano indicando se o iterador atingiu o final da sequência.
Os iteráveis são comumente usados em muitos aplicativos em tempo real enquanto trabalham com grandes conjuntos de dados ou enquanto implementam estruturas de dados 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 )O que o snippet de código acima sai?
A resposta correta é D.
A função counter é uma função de gerador que cria um loop infinito que gera valores incrementadores de i .
A variável gen é definida como a função do gerador e cada chamada para gen.next() retorna um objeto com a propriedade Value definida para o próximo valor rendido.
As instruções console.log imprimem os valores retornados por gen.next() .
Uma função do gerador é um tipo especial de função que pode ser usado para controlar a iteração em uma sequência de valores.
Diferentemente das funções tradicionais, as funções do gerador permitem uma pausa e retomar a execução deles e produzir vários valores ao longo do tempo.
Qual dos seguintes cenários poderia potencialmente causar um vazamento de memória em JavaScript?
As referências circulares ocorrem quando dois ou mais objetos se referenciam, criando um loop que impede que os objetos sejam coletados de lixo.
Isso pode causar um vazamento de memória se os objetos não forem mais necessários, mas não puderem ser libertados devido à referência circular.
As opções A, C e D normalmente não causam vazamentos de memória em JavaScript.
A coleta de lixo é o processo de liberação automaticamente de memória que não está mais sendo usada por um programa.
Em JavaScript, o algoritmo de marca e varredura é comumente usado para coleta de lixo.
Esse algoritmo funciona primeiro marcando todos os objetos na memória que ainda estão sendo referenciados pelo programa, depois varrendo e liberando qualquer memória que não esteja marcada como em 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 ( ) )
} ) ( )O que o snippet de código acima sai?
Quando o código é executado, a função principal () é chamada, que é uma função assíncrona que usa aguarda para obter dados da função getData() .
Depois que os dados são recuperados, a instrução console.log(data) registra "dados recuperados com sucesso" para o console.
Depois disso, a declaração throw new Error("Something went wrong") lança um erro.
O bloco catch pega o erro e registra "Caught an error: Something went wrong" para o console e depois retorna a string "Error occurred" .
Finalmente, o bloco finalmente é executado e os logs "Finally block executed." para o console e, em seguida, retorna a string "Finally block value" .
Quando a função main() é chamada, ela retorna uma promessa porque é uma função assíncrona. Como o bloco finally também retorna um valor, esse valor será o valor final resolvido da promessa.
Portanto, quando console.log(main()) é chamado: "Finally block executed." e "Finally block value" será registrado no console.
Tente, capturar e, finalmente, as palavras -chave usadas no JavaScript para lidar com erros de tempo de execução.
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 ) ;O que o snippet de código acima sai?
Porque a declaração break não é válida dentro da função de retorno de chamada passada para forEach .
forEach não suporta o término precoce usando a instrução break . Portanto, um erro é lançado: "Uncaught SyntaxError: Illegal break statement".
No caso do loop, a declaração break é permitida.
Para corrigir o problema, remova a declaração break do foreach e ele deve funcionar.
Em geral, for of forEach for in
let arr = [ 1 , 2 , 3 , 4 ]
let result = arr . push ( 5 )
console . log ( 'result: ' , result , 'arr: ' , arr )O que o snippet de código acima sai?
O método array.push() em JavaScript adiciona um ou mais elementos ao final de uma matriz e retorna o novo comprimento da matriz.
No código fornecido, arr é uma matriz com os valores [1, 2, 3, 4] . O método push() é chamado com o argumento 5, que adiciona 5 ao final da matriz arr .
O método push() retorna o novo comprimento da matriz após a adição do (s) elemento (s). Nesse caso, o novo comprimento do ARR será 5 porque 5 é adicionado ao final da matriz.
let arr = [ 3 , 5 , 7 , 9 ]
let result = arr . unshift ( 1 , 2 )
console . log ( 'result: ' , result , 'arr: ' , arr )O que o snippet de código acima sai?
O método array.unshift() em JavaScript adiciona um ou mais elementos ao início de uma matriz e retorna o novo comprimento da matriz.
No código fornecido, arr é uma matriz com os valores [3, 5, 7, 9] . O método unshift() é chamado com os argumentos 1 e 2, que adiciona 1 e 2 ao início da matriz arr .
O método unshift() retorna o novo comprimento da matriz após a adição do (s) elemento (s). Nesse caso, o novo comprimento do arr será 6 porque 1 e 2 são adicionados ao início da matriz, mudando os elementos existentes para a direita.
const myArray = [ 1 , 2 , 3 , 4 , 5 ]
const poppedValue = myArray . pop ( )
console . log ( poppedValue )O que o snippet de código acima sai?
O método Array.pop() em JavaScript remove o último elemento de uma matriz e retorna esse elemento.
Nesse caso, myArray é uma matriz com elementos [1, 2, 3, 4, 5] , e myArray.pop() é chamado, que remove o elemento 5 da matriz e o retorna.
const arr = [ 10 , 20 , 30 , 40 , 50 ]
const removedElement = arr . shift ( )
console . log ( 'removedElement: ' , removedElement , 'arr: ' , arr )O que o snippet de código acima sai?
O método Array.shift() remove o primeiro elemento da matriz arr , que é 10 , e o retorna. A matriz arr resultante será então [20, 30, 40, 50] .
Portanto, a opção A é a resposta correta, pois reflete o valor correto do removedElement e o estado atualizado do arr após Array.shift() é chamado. A opção B está incorreta, pois afirma que o removedElement será 50, o que não é verdadeiro. A opção C também está incorreta, pois afirma que arr permanece inalterado, o que não é preciso. A opção D é um pouco confusa, pois afirma que Array.shift() retorna a matriz, o que não é verdadeiro.
let arr = [ 1 , 2 , 3 , 4 , 5 ]
let removed = arr . splice ( 1 , 2 , 'a' , 'b' )
console . log ( 'removed:' , removed , 'arr: ' , arr )O que o snippet de código acima sai?
O método Array.splice() é usado para modificar uma matriz adicionando, removendo ou substituindo elementos.
Nesse caso, o snippet de código usa arr.splice(1, 2, 'a', 'b') , que começa no índice 1 (removendo 2 elementos) e insere os elementos a e b em seu lugar. Os elementos que são removidos (isto é, 2 e 3) são devolvidos e atribuídos à variável removida. Após a execução, removido será [2, 3] e arr será [1, 'a', 'b', 4, 5] . A opção C está incorreta, pois inclui os elementos inseridos na matriz removida, o que não é preciso. A opção D também está incorreta, pois menciona os elementos incorretos que são removidos da 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 )O que o snippet de código acima sai?
O método Array.indexOf() procura o índice da primeira ocorrência do valor especificado nos frutos da matriz. Nesse caso, "Orange" é encontrado no índice 2, então index será 2.
O método Array.lastIndexOf() procura o índice da última ocorrência do valor especificado nos frutos da matriz. Nesse caso, "Apple" aparece duas vezes na matriz e sua última ocorrência está no índice 4, então lastIndex será 4.
Por outro lado, o método Array.includes() verifica se o valor especificado "uva" existe nos frutos da matriz e, como "uva" está presente na matriz, result será verdadeiro.
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 ,
)O que o snippet de código acima sai?
O método Array.filter() retorna uma matriz que contém todos os elementos para os quais a função passada para ele retorna true. Nesse caso, a função isDivisibleBy7 retorna verdadeira para qualquer número divisível por 7. Na matriz nums , 7 e 28 são divisíveis por 7, portanto nums.filter(isDivisibleBy7) [28, 7].
O método Array.find() retorna o primeiro elemento na matriz para a qual a função passada para ele retorna true. Nesse caso, a função passada retorna true para qualquer número menor que 10. Existem vários números em nums inferiores a 10, mas desde Array.find() apenas retorna o primeiro para o qual é verdadeiro, nums.find((num) => num < 10) retorna 7.
O método Array.findIndex() é semelhante ao método Array.find() , mas retorna o índice do primeiro elemento na matriz para a qual a função passada para ela retorna verdadeira, e não o próprio elemento. Nesse caso, a função passada retorna true para 28, pois o 28/2 == 14. 28 está nos nums da matriz e está no índice 0, então nums.find((num) => num / 2 == 14) retorna 0.
const numbers = [ 1 , 2 , 3 , 4 , 5 ]
const doubledNumbers = numbers . map ( num => num * 2 )
console . log ( doubledNumbers )O que o snippet de código acima sai?
O método Array.map() em JavaScript cria uma nova matriz aplicando uma função fornecida a cada elemento da matriz original.
Nesse caso, a função fornecida num => num * 2 multiplica cada número na matriz de números por 2, resultando em uma nova matriz [2, 4, 6, 8, 10] .
const numbers = [ 1 , 2 , 3 , 4 , 5 ]
const sum = numbers . reduce ( ( acc , val ) => acc + val )
console . log ( sum )O que o snippet de código acima sai?
Array.reduce() pega uma matriz e a "reduz" a um único valor aplicando repetidamente uma função a cada elemento e acompanhando o resultado acumulado. É comumente usado para tarefas como resumir uma matriz de números, encontrar o valor máximo ou concatenar uma matriz de strings em uma única string.
Nesse caso, o método Reduce () leva uma função de retorno de chamada que é executada para cada elemento da matriz. A função de retorno de chamada leva dois parâmetros, acc e val , que representam o acumulador e o valor atual da matriz, respectivamente.
Dentro da função de retorno de chamada, o valor atual da matriz é adicionado ao acumulador e o resultado é retornado. O método reduce() atualiza o valor do acumulador a cada iteração até que ele tenha iterado em todos os elementos da matriz.
Finalmente, o método reduce() retorna o valor final do acumulador, que é a soma de todos os números da matriz, ou seja, 15.
const arr = [ 1 , 2 , 3 , 4 ]
const result = arr . reduceRight ( ( acc , curr ) => acc + curr )
console . log ( result )O que o snippet de código acima sai?
O método reduceRight() é semelhante ao método reduce() , exceto que começa a reduzir a matriz do elemento mais à direita para o elemento mais à esquerda. O método reduceRight() aplica uma função contra um acumulador e cada valor da matriz (da direita para a esquerda) para reduzi-lo a um único valor.
No snippet de código fornecido, a matriz arr contém os valores [1, 2, 3, 4] . O método reduceRight() é chamado nesta matriz com uma função de retorno de chamada que adiciona o accumulador acc ao elemento atual curr .
Na primeira iteração, o valor curr será 4 e o valor do ACC será undefined , pois nenhum valor inicial é fornecido. Portanto, o resultado da primeira iteração será 4 .
Na segunda iteração, o valor curr será 3 e o valor acc será o resultado da iteração anterior, que é 4 . Portanto, o resultado da segunda iteração será 7 .
Na terceira iteração, o valor curr será 2 e o valor acc será o resultado da iteração anterior, que é 7 . Portanto, o resultado da terceira iteração será 9 .
Na quarta e última iteração, o valor curr será 1 e o valor acc será o resultado da iteração anterior, que é 9 . Portanto, o resultado da quarta iteração será 10 .
Portanto, a saída final do código será 10 . Portanto, a opção correta é A.
const arr = [ 'Centauri' , 3.14159 , 'canine' , 11235 , undefined ]
const result = arr . sort ( )
console . log ( result )O que o snippet de código acima sai?
Por padrão, o método sort() classifica os elementos do caractere, então 11235 vem antes de 3.14159 porque 1 vem antes de 3.
Palavras e letras são classificadas em ordem alfabética pelo código ASCII SO "Centauri", que começa com uma espécie de maiúsculas C (código ASCII 67) antes de "canino", que começa com um C (código ASCII 99).
Elementos indefinidos sempre classificam o final de uma matriz.
Assim, a saída final do código será [11235, 3.14159, 'Centauri', 'canino', indefinido], que é a opção D.
let numbers = [ 1 , 2 , 3 , undefined , 6 , 7 , 8 , 9 ]
let [ a , , b , c = 2 , ... rest ] = numbers
console . log ( a , b , c , rest )O que o snippet de código acima sai?
Com a destruição da matriz, é possível descompactar certos valores de uma matriz em variáveis individuais. Os valores que criamos no lado esquerdo ( a, b, c, rest ) correspondem aos valores e à ordem da matriz que atribuímos no lado direito ( numbers ).
A variável a corresponde ao primeiro elemento da matriz, que é 1 .
Como não especificamos uma variável para o próximo valor 2 , o valor não é levado em consideração na avaliação e é ignorado.
A variável b corresponde ao terceiro elemento da matriz, que é 3 .
É possível definir valores padrão para as variáveis se o elemento na matriz for undefined . Como o quarto elemento na matriz é undefined , a variável c possui o valor padrão 2 .
Com o operador de spread ( ... ), podemos atribuir os valores restantes da matriz a uma variável. Como os valores [ 6, 7, 8, 9 ] são os valores restantes da matriz, eles são atribuídos ao rest variável.
Portanto, o resultado final é: 1 3 2 [ 6, 7, 8, 9 ] , que é a opção 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 )O que o snippet de código acima sai?
new Date() retornará a data e hora atuais seguidas pelas duas datas especificadas no formato "AAAA-MM-DDTHH: MM: SS.SSSZ", onde "Z" representa o deslocamento do fuso horário da UTC.
YYYY-MM-DDTHH:mm:ss.sssZ é um formato usado para representar datas e horários no padrão ISO 8601. Consiste nos seguintes componentes:
YYYY : ano de quatro dígitos (0000 a 9999), ou como um ano expandido com + ou - seguido de seis dígitos. O sinal é necessário para anos expandidos. -000000 é explicitamente não permitido como um ano válido.MM : mês de dois dígitos (01 = janeiro, 02 = fevereiro e assim por diante). Padrão para 01.DD : Dia de dois dígitos do mês (01 a 31)T : um separador indicando o início do componente de tempoHH : Hora do dia de dois dígitos em formato 24 horas (00 a 23). Como um caso especial, 24:00:00 é permitido e é interpretado como meia -noite no início do dia seguinte. Padrões para 00.mm : Minuto de dois dígitos da hora (00 a 59). Padrões para 00.ss : Segundo de dois dígitos do minuto (00 a 59). Padrões para 00..sss : componente de milissegundos (000 a 999). Padrões para 000.Z : Um sufixo indicando que o tempo está no UTC (tempo universal coordenado), sem deslocamento. Pode ser o caractere literal Z (indicando UTC) ou + ou - seguido por HH: MM, o deslocamento em horas e minutos do 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 ( ) ,
)O que o snippet de código acima sai?
O código fornecido cria um objeto de data inicializado com a data e a hora de "15 de março de 1975 23:15:30".
Em seguida, ele modifica a data de atas e UTC do objeto Data usando os métodos setMinutes() e setUTCDate() , respectivamente.
Por fim, ele registra os valores atualizados de minutos, ano e data da UTC usando console.log() .
Depois de modificar a ata para 10 usando setMinutes(10) , o método getMinutes() retorna o valor atualizado de 10.
Depois de modificar a data do UTC para 5 usando setUTCDate(5) , o método getUTCDate() retorna o valor atualizado de 5.
O método getFullYear() retorna o ano inalterado, que é 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' )O que o snippet de código acima sai?
O código calcula a diferença nos dias entre a data "2023-5-1" e a próxima data eleitoral dos EUA "2024-11-5". Ele usa o objeto Date para criar duas datas: date1 representa 1 de maio de 2023 e next_us_election representa 5 de novembro de 2024.
O método getTime() é usado para obter o valor do tempo em milissegundos para cada data. Ao subtrair o valor de tempo da date1 da next_us_election , obtemos a diferença de horário em milissegundos.
Para converter a diferença de tempo de milissegundos para dias, dividimos -o pelo número de milissegundos em um dia (1000 _ 3600 _ 24). O resultado é armazenado na variável difference_in_days .
Finalmente, a função parseInt() é usada para converter o valor diferencial_in_days em um número inteiro e o resultado é registrado no console junto com a string "dias". A saída será "554 dias".
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 ( )O que o snippet de código acima sai?
O código define um objeto person com propriedades como name , age , hobbies e address , e um método sayHello .
As instruções console.log() imprimem o valor do name , o segundo elemento da matriz hobbies (que é "viajar") e o valor da propriedade city no objeto address (que é "Nova York").
Finalmente, o método sayHello é chamado ao objeto person usando notação de pontos, que gera a string "Hello, meu nome é John" para o 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 )O que o snippet de código acima sai?
O código define um User da função do construtor que cria objetos user com uma propriedade username e um método updateUsername . Dois objetos user , user1 e user2 , são criados com os nomes de usuário iniciais 'Kirandash' e 'BGWebagency', respectivamente.
O método updateUsername é chamado nos objetos user1 e user2 para atualizar seus nomes de usuário. O nome de usuário do user1 é atualizado para 'Kirandash-Website' e o nome de usuário do user2 é atualizado para 'BGWEBABENCE-APP'.
Finalmente, o código registra a concatenação de user1.username e user2.username , que resulta na saída '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' )O que o snippet de código acima sai?
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 )
