Skip to content

Latest commit

 

History

History
1311 lines (880 loc) · 32.1 KB

README_pt_BR.md

File metadata and controls

1311 lines (880 loc) · 32.1 KB

Lista de questões (avançadas) sobre JavaScript

Posto questões de múltipla escolha sobre JavaScript no meu Instagram, as quais também posto aqui!

Do básico ao avançado: Teste quão bem você conhece o JavaScript, refresque um pouco do seu conhecimento, ou se prepare para uma entrevista! 💪 🚀 Eu atualizo esse repositório semanalmente com novas questões.

As respostas estão em seções recolhidas abaixo das questões, basta clicar nelas para expandir. Boa sorte ❤️


1. Qual é a saída?
function sayHi() {
  console.log(name);
  console.log(age);
  var name = "Lydia";
  let age = 21;
}

sayHi();
  • A: Lydia e undefined
  • B: Lydia e ReferenceError
  • C: ReferenceError e 21
  • D: undefined e ReferenceError
Resposta

Resposta: D

Dentro da função, nós primeiro declaramos a variável name usando a palavra-chave var. Isso significa que a variavel é elevada(hoisted) (O espaço na memória é separado durante a fase de criação) com o valor padrão undefined, até que chegue na linha onde definimos a variável. Ainda não definimos a variável na linha onde tentamos usar colocar no log o valor da variável name, portanto ela ainda tem o valor undefined.

Variáveis com a palavra-chave let (e const) são elevadas, mas diferente de var, não são inicializadas. Elas não acessíveis antes da linha em que as declaramos (ou inicializamos). Esse é um conceito chamado de "temporal dead zone". Quando tentamos acessar essas variáveis antes de serem declaradas, o JavaScript lança um ReferenceError


2. Qual é a saída?
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 1);
}

for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 1);
}
  • A: 0 1 2 e 0 1 2
  • B: 0 1 2 e 3 3 3
  • C: 3 3 3 e 0 1 2
Resposta

Resposta: C

Por causa da fila de eventos em JavaScript, a callback de setTimeout é chamada depois do laço ter sido executado. Já que a variável i no primeiro laço foi declarada usando a palavra-chave var, seu valor era global. Durante o laço, incrementamos o valor de i por 1 em cada repetição, usando o operador unário ++. Quando a callback de setTimeout foi chamada, i valia 3.

No segundo laço, a variável i foi declarada usando a palavra-chave let: Variáveis declaradas com let (e const) só são acessíveis nos escopos de seus blocos (um bloco é qualquer código entre { }). Durante cada repetição do laço, i vai ter um novo valor, e cada valor tem seu escopo dentro do laço.


3. Qual é a saída?
const shape = {
  radius: 10,
  diameter() {
    return this.radius * 2;
  },
  perimeter: () => 2 * Math.PI * this.radius
};

shape.diameter();
shape.perimeter();
  • A: 20 e 62.83185307179586
  • B: 20 e NaN
  • C: 20 e 63
  • D: NaN e 63
Resposta

Resposta: B

Perceba que o valor de diameter é uma função normal, enquanto que o valor de perimeter é uma arrow function.

Com arrow functions, a palavra-chave this faz referência ao escopo atual em que está inserida, diferente de funções normais! Isso significa que quando nós chamamos perimeter, ela não faz referência ao objeto shape, mas ao seu escopo atual (por exemplo, window).

Não há radius fora de shape, então retorna undefined.


4. Qual é a saída?
+true;
!"Lydia";
  • A: 1 and false
  • B: false and NaN
  • C: false and false
Resposta

Resposta: A

O operador unário + tenta converter um operando para um número. true é 1, e false é 0.

A string 'Lydia' tem valor truthy*. O que estamos realmente perguntando é "Esse valor truthy é falsy?". Isso retorna false.

*Nota do tradutor: truthy é um termo único ao JavaScript que denota valores que podem ser convertidos em um booleano True. Sua contraparte é falsy, que são valores que podem ser convertidos em um booleano false. Para fins de consistência, mantenho os termos originais.


5. Qual é a alternativa correta?
const bird = {
  size: "small"
};

const mouse = {
  name: "Mickey",
  small: true
};
  • A: mouse.bird.size não é válido
  • B: mouse[bird.size] não é válido
  • C: mouse[bird["size"]] não é válido
  • D: Todos são válidos
Resposta

Resposta: A

No JavaScript, todas chaves dos objetos são strings (a não ser que sejam um símbolo). Ainda que não possamos digitá-las como strings, elas são sempre convertidas para string sob o capô.

JavaScript interpreta afirmações. Quando usamos a notação de colchetes, ele vê o colchete de abertura [ e continua lendo até encontrar o colchete que o fecha ]. Só então vai avaliar e rodar as afirmações.

mouse[bird.size]: Primeiro avalia bird.size, que é "small". mouse["small"] retorna true

Por outro lado, com a notação de ponto ., isso não acontece. mouse não tem uma chave chamada bird, o que significa que mouse.bird é undefined. Então, pedimos pelo size usando a notação de ponto: mouse.bird.size. Uma vez que mouse.bird é undefined, estamos realmente pedindo undefined.size. Isso não é válido, e irá gerar um erro similar a Cannot read property "size" of undefined.


6. Qual é a saída?
let c = { greeting: "Hey!" };
let d;

d = c;
c.greeting = "Hello";
console.log(d.greeting);
  • A: Hello
  • B: Hey
  • C: undefined
  • D: ReferenceError
  • E: TypeError
Resposta

Resposta: A

Em JavaScript, todos objetos interagem por referência quando os colocamos um igual ao outro.

Primeiro, a variável c guarda o valor de um objeto. Depois, declaramos d com a mesma referencia que c tem para o objeto.

Quando você muda um objeto, você muda todos eles.


7. Qual é a saída?
let a = 3;
let b = new Number(3);
let c = 3;

console.log(a == b);
console.log(a === b);
console.log(b === c);
  • A: true false true
  • B: false false true
  • C: true false false
  • D: false true true
Resposta

Resposta: C

new Number() é uma funcção construtura padrão do JavaScript. Ainda que parece com um número, não é realmente um número: Tem um monte de funções extras e é um objeto.

Quando usamos o operador ==, só conferimos se ambas tem o mesmo valor. Ambas tem o valor de 3, então retorna true.

Contudo, quando usamos o operador ===, ambos valor e tipo tem de ser o mesmo. E não são: new Number() não é um número, é um objeto. Ambos retornam false.


8. Qual é a saída?
class Chameleon {
  static colorChange(newColor) {
    this.newColor = newColor;
    return this.newColor;
  }

  constructor({ newColor = "green" } = {}) {
    this.newColor = newColor;
  }
}

const freddie = new Chameleon({ newColor: "purple" });
freddie.colorChange("orange");
  • A: orange
  • B: purple
  • C: green
  • D: TypeError
Resposta

Resposta: D

A função colorChange é estática. Métodos estáticos são designados para viver somente nos construtores em que são criados, e filhos não herdam esses métodos. Já que freddie é filho de Chameleon, a função não é herdada, e não está disponível para freddie: Um erro TypeError é gerado.


9. Qual é a saída?
let greeting;
greetign = {}; // Erro de digitação!
console.log(greetign);
  • A: {}
  • B: ReferenceError: greetign is not defined
  • C: undefined
Resposta

Resposta: A

Cria o log do objeto, pois criamos um objeto vazio no objeto global! Quando erramos a digitação de greeting como greetign, o interpretador do JavaScript viu isso como global.greetign = {} (ou window.greetign = {} em um navegador).

Para evitar esse comportamento, podemos usar "use strict". Isso garante que você tenha declarado uma variável antes de poder inicializá-la com algum valor.


10. O que acontece quando fazemos isso?
function bark() {
  console.log("Woof!");
}

bark.animal = "dog";
  • A: Nada, isso é ok!
  • B: SyntaxError. Não se pode adicionar propriedades em uma função dessa maneira.
  • C: undefined
  • D: ReferenceError
Resposta

Resposta: A

Isso é possível em JavaScript, pois funções são objetos! (Tudo menos tipos primitivos são objetos)

Uma função é um tipo especial de objeto. O código que você escreve não é a verdadeira função. A função é um objeto com propriedades. E essa propriedade é invocável.


11. Qual é a saída?
function Person(firstName, lastName) {
  this.firstName = firstName;
  this.lastName = lastName;
}

const member = new Person("Lydia", "Hallie");
Person.getFullName = function() {
  return `${this.firstName} ${this.lastName}`;
};

console.log(member.getFullName());
  • A: TypeError
  • B: SyntaxError
  • C: Lydia Hallie
  • D: undefined undefined
Resposta

Resposta: A

Você não pode adicionar propriedades para um construtor igual aos objetos normais. Se você quer adicionar uma funcionalidade para todos objetos ao mesmo tempo, você deve usar o prototype.

Então nesse caso

Person.prototype.getFullName = function() {
  return `${this.firstName} ${this.lastName}`;
};

faria member.getFullName() funcionar. Por quê isso é beneficial? Digamos que tivéssemos esse método no próprio construtor. Talvez nem toda instância de Person precisasse desse método. Isso gastaria muita memória, uma vez que cada instância teria esse propriedade e teria seu espaço alocado. Ao invés disso, se adicionarmos somente ao protótipo, alocamos somente um único espaço na memória, e todas instâncias de Person ainda tem acesso ao método.


12. Qual é a saída?
function Person(firstName, lastName) {
  this.firstName = firstName;
  this.lastName = lastName;
}

const lydia = new Person("Lydia", "Hallie");
const sarah = Person("Sarah", "Smith");

console.log(lydia);
console.log(sarah);
  • A: Person {firstName: "Lydia", lastName: "Hallie"} e undefined
  • B: Person {firstName: "Lydia", lastName: "Hallie"} e Person {firstName: "Sarah", lastName: "Smith"}
  • C: Person {firstName: "Lydia", lastName: "Hallie"} e {}
  • D:Person {firstName: "Lydia", lastName: "Hallie"} e ReferenceError
Resposta

Resposta: A

Na sarah, não usamos a palavra-chave new. Quando usamos new, se refere ao novo objeto vazio que criamos. Contudo, se não usarmos new, nos referimos ao objeto global!

Afirmamos que this.firstName vale "Sarah" e this.lastName vale "Smith". O que realmente fizemos foi definir global.firstName = 'Sarah' e global.lastName = 'Smith'. A sarah ainda é undefined.


13. Quais são as três fases na propagação de eventos?
  • A: Target > Capturing > Bubbling
  • B: Bubbling > Target > Capturing
  • C: Target > Bubbling > Capturing
  • D: Capturing > Target > Bubbling
Resposta

Resposta: D

Durate a fase do capturing, o evento percorre os elementos pais até chegar no elemento algo. Isso alcança o elemento target, e o bubbling começa.

*Nota do tradutor: bubbling descreve uma forma específica de propagação de eventos. Em tradução livre é "borbulhar", que indica como os eventos "sobem" a cadeia onde estão aninhados, mas prefiro por manter o original, visto que é o nome dessa forma de propagação.


14. Todos objetos tem protótipos.
  • A: Verdadeiro
  • B: Falso
Resposta

Resposta: B

Todos objetos tem protótipos, exceto pelo base object. O base object tem acesso à alguns métodos e propriedades, como .toString. É o motivo de podermos usar métodos já embutidos no JavaScript! Todos métodos desse tipo já estão embutidos no protótipo. Apesar do JavaScript não encontrar algum método diretamente no seu objeto, ele percorre a cadeia de protótipos até encontrar no base, o que torna acessível para todo objeto.


15. Qual é a saída?
function sum(a, b) {
  return a + b;
}

sum(1, "2");
  • A: NaN
  • B: TypeError
  • C: "12"
  • D: 3
Resposta

Resposta: C

JavaScript é uma linguagem dinamicamente tipada: Não especificamos quais tipos nossas variáveis são. Valores pode ser automaticamente convertidos em outro tipo sem você saber, o que é chamado de coerção implicita de tipo. Coerção é converter de um tipo em outro.

Nesse exemplo, JavaScript converte o número 1 em uma string, para que a função faça sentido e retorne um valor. Durante a adição de um tipo numérico (1) e uma string ('2'), o número é tratado como uma string. Podemos concatenar strings como "Hello" + "World", então o que está acontecendo aqui é "1" + "2" que retorna "12".


16. Qual é a saída?
let number = 0;
console.log(number++);
console.log(++number);
console.log(number);
  • A: 1 1 2
  • B: 1 2 2
  • C: 0 2 2
  • D: 0 1 2
Resposta

Resposta: C

O operador unário no sufixo ++:

  1. Retorna o valor (retorna o valor 0)
  2. Incrementa o valor (numero agora é 1)

O operador unário prefixo ++:

  1. Incrementa o valor (numero agora é 2)
  2. Retorna o valor (Retorna o valor 2)

Isso retorna 0 2 2.


17. Qual é a saída?
function getPersonInfo(one, two, three) {
  console.log(one);
  console.log(two);
  console.log(three);
}

const person = "Lydia";
const age = 21;

getPersonInfo`${person} is ${age} years old`;
  • A: "Lydia" 21 ["", " is ", " years old"]
  • B: ["", " is ", " years old"] "Lydia" 21
  • C: "Lydia" ["", " is ", " years old"] 21
Resposta

Resposta: B

Se usamos template literals marcadas, ou tagged template literals, o valor do primeiro argumento é sempre um array com a string, separada pelos tagged template liberals. Os argumentos restantes recebem os valores das expressões passadas!


18. Qual é a saída?
function checkAge(data) {
  if (data === { age: 18 }) {
    console.log("You are an adult!");
  } else if (data == { age: 18 }) {
    console.log("You are still an adult.");
  } else {
    console.log(`Hmm.. You don't have an age I guess`);
  }
}

checkAge({ age: 18 });
  • A: You are an adult!
  • B: You are still an adult.
  • C: Hmm.. You don't have an age I guess
Resposta

Resposta: C

Quando testamos igualdade, primitivos são comparados por seus valores, enquanto objetos são comparados por suas referências. O JavaScript confere se os objetos tem a referência para o mesmo local na memória.

Os dois objetos que estamos comparando não são assim: O objeto que passamos como parâmetro faz referência a uma posição na memória diferente daquela que o objeto que usamos para conferir a igualdade.

É por isso que ambos { age: 18 } === { age: 18 } E { age: 18 } == { age: 18 } retornam false.


19. Qual é a saída?
function getAge(...args) {
  console.log(typeof args);
}

getAge(21);
  • A: "number"
  • B: "array"
  • C: "object"
  • D: "NaN"
Resposta

Resposta: C

O operador spread (...args.) retorna um array com os argumentos. Um array é um objeto, então typeof args retorna "object"


20. Qual é a saída?
function getAge() {
  "use strict";
  age = 21;
  console.log(age);
}

getAge();
  • A: 21
  • B: undefined
  • C: ReferenceError
  • D: TypeError
Resposta

Resposta: C

Com "use strict", você pode ter certeza que não declarou variáveis globais. Nunca declaramos a variável age, e já que usamos "use strict", ira gerar um erro de referência. Se não tivéssemos usado "use strict", teria funcionado, uma vez que a propriedade age teria sido adicionada ao objeto global.


21. Qual o valor de sum?
const sum = eval("10*10+5");
  • A: 105
  • B: "105"
  • C: TypeError
  • D: "10*10+5"
Resposta

Resposta: A

eval executa o código mesmo se passado como string. Se é uma expressão, como nesse caso, ele cálcula a expressão. A expressão é 10 * 10 + 5. Isso retorna o número 105.


22. Por quanto tempo cool_secret é acessível?
sessionStorage.setItem("cool_secret", 123);
  • A: Sempre, o dado não é perdido.
  • B: Quando o usuário fechar a guia.
  • C: Quando o usuário fechar o navegador inteiro.
  • D: Quando o usuário desligar o computador.
Resposta

Resposta: B

Dados guardados em sessionStorage são removidos depois de fechar a guia.

Se usássemos localStorage, o dado seria guardado para sempre, exceto se localStorage.clear() fosse chamado.


23. Qual é a saída?
var num = 8;
var num = 10;

console.log(num);
  • A: 8
  • B: 10
  • C: SyntaxError
  • D: ReferenceError
Resposta

Resposta: B

Coma a palavra-chave var, você pode declarar várias variáveis com o mesmo nome. A variável vai guardar o último valor.

Você não pode fazer isso com let ou const uma vez que eles conferem o bloco de escopo em que estão inseridos.


24. Qual é a saída?
const obj = { 1: "a", 2: "b", 3: "c" };
const set = new Set([1, 2, 3, 4, 5]);

obj.hasOwnProperty("1");
obj.hasOwnProperty(1);
set.has("1");
set.has(1);
  • A: false true false true
  • B: false true true true
  • C: true true false true
  • D: true true true true
Resposta

Resposta: C

Todas as chaves de objetos (exceto símbolos) são strings debaixo do capô, mesmo que você não digite como uma string. É por isso que obj.hasOwnProperty('1') também retorna true.

Não funciona assim para Set. Não tem um '1' no nosso set: set.has('1') retorna false. Temos o tipo número 1, então set.has(1) retorna true.


25. Qual é a saída?
const obj = { a: "one", b: "two", a: "three" };
console.log(obj);
  • A: { a: "one", b: "two" }
  • B: { b: "two", a: "three" }
  • C: { a: "three", b: "two" }
  • D: SyntaxError
Resposta

Resposta: C

Se temos duas chaves com o mesmo nome, a última irá substituir a primeira. Ainda vai estar na primeira posição, mas com o último valor específicado.


26. O contexto global de execução do JavaScrit cria duas coisas para você: O objeto global, e a palavra-chave this.
  • A: Verdadeiro
  • B: Falso
  • C: Depende
Resposta

Resposta: A

O contexto base de execução é o contexto global: É aquilo que está acessível em qualquer lugar do código.


27. Qual é a saída?
for (let i = 1; i < 5; i++) {
  if (i === 3) continue;
  console.log(i);
}
  • A: 1 2
  • B: 1 2 3
  • C: 1 2 4
  • D: 1 3 4
Resposta

Resposta: C

A palavra-chave continue pula uma iteração se a condição retorna true.


28. Qual é a saída?
String.prototype.giveLydiaPizza = () => {
  return "Just give Lydia pizza already!";
};

const name = "Lydia";

name.giveLydiaPizza();
  • A: "Just give Lydia pizza already!"
  • B: TypeError: not a function
  • C: SyntaxError
  • D: undefined
Resposta

Resposta: A

String é um construtor embutido, no qual podemos adicionar propriedades. Nesse caso adicionamos um método ao seu protótipo. Tipos primitivos string são automaticamente convertidos em um objeto string, gerado pelo construtor String. Assim, todas as strings (que são objetos string) tem acesso ao método.


29. Qual é a saída?
const a = {};
const b = { key: "b" };
const c = { key: "c" };

a[b] = 123;
a[c] = 456;

console.log(a[b]);
  • A: 123
  • B: 456
  • C: undefined
  • D: ReferenceError
Resposta

Resposta: B

Chaves de objeto são automaticamente convertidas em strings. Estamos tentando usar um objeto como chave do objeto a, com o valor de 123.

Contudo, quando transformamos um objeto em string, ele vira um "[Object object]". Então, o que estamos afirmando é a["Object object"] = 123. Após, tentamos a mesma coisa. c é outro objeto que (implicitamente) convertemos para string. Então, temos a["Object object"] = 456.

Então, fazemos o log de a[b], o que na verdade é a["Object object"]. Acabmos de definir esse valor, como 456, e é isso que ele retorna.


30. Qual é a saída?
const foo = () => console.log("First");
const bar = () => setTimeout(() => console.log("Second"));
const baz = () => console.log("Third");

bar();
foo();
baz();
  • A: First Second Third
  • B: First Third Second
  • C: Second First Third
  • D: Second Third First
Resposta

Resposta: B

Temos a função setTimeout e a invocamos por primeiro. Ainda assim, apareceu no log por último.

Isso acontece pois nos navegadores, não temos apenas o nosso mecanismo de execução (runtime engine), temos também algo chamado WebAPI. A WebAPI nos da coisas como a setTimeout e o DOM.

Depois que a função de retorno (callback) é enviada para a WebAPI, a função setTimeout (mas não seu retorno ou callback) são enviadas para fora do stack.

Agora, foo é chamada, e "First" é adicionado ao log.

foo é evniada para fora do stack, e baz é chamada. "Third" é adicionado ao log.

A WebAPI não pode simplesmente adicionar coisas ao stack sempre que ficam prontas. Ao invés, disso, todo retorno que fica pronto é enviado para algo chamado queue.

É aqui que um laço de evento começa a ocorrer. Um laço de evento confere o stack e o queue. Se o stack está livre, pega a primeira coisa que estiver na queue e coloca no stack.

bar é chamada, "Second" é adicionado ao log, e é enviado para fora do stack.


31. qual é o event.target quando clicamos no botão?
<div onclick="console.log('first div')">
  <div onclick="console.log('second div')">
    <button onclick="console.log('button')">
      Click!
    </button>
  </div>
</div>
  • A: A div mais externa
  • B: A div mais interna
  • C: button
  • D: Um array dos elementos aninhandos.
Resposta

Resposta: C

O elemento mais interno no aninhamento que causou o evento é o alvo do evento. Você pode parar o bubbling com event.stopPropagation.


32. Quando você clica no parágrafo, O que é adicionado ao log?
<div onclick="console.log('div')">
  <p onclick="console.log('p')">
    Click here!
  </p>
</div>
  • A: p div
  • B: div p
  • C: p
  • D: div
Resposta

Resposta: A

Se clicarmos em p, veremos dois itens adicionaos ao log: p e div. Durante a propagação de eventos, existem 3 fases: capturar, adquirir o target, e o bubbling. Por padrão, manipuladores de eventos são executados junto a fase de bubbling (a não ser que você marque useCapture como true). Percorre do elemento aninhando mais interno, propagando para fora.


33. Qual é a saída?
const person = { name: "Lydia" };

function sayHi(age) {
  console.log(`${this.name} is ${age}`);
}

sayHi.call(person, 21);
sayHi.bind(person, 21);
  • A: undefined is 21 Lydia is 21
  • B: function function
  • C: Lydia is 21 Lydia is 21
  • D: Lydia is 21 function
Resposta

Resposta: D

Com ambos, podemos passar o objeto que queremos que o this faça referência. Contudo, .call é executado imediatamente!

.bind. retorna uma cópia da função, mas com seu contexto vinculado à cópia. E não é executado imediatamente.


34. Qual é a saída?
function sayHi() {
  return (() => 0)();
}

typeof sayHi();
  • A: "object"
  • B: "number"
  • C: "function"
  • D: "undefined"
Resposta

Resposta: B

A função sayHi retorna o valor retornado pela arrow function pois ela é uma IIFE (Immediately Invoked Function Expression ou Expressão de Função Invocada Imediatamente). Essa IIFE retornou 0, que é do tipo "number".

Para saber mais: Só existem 7 tipos já definidos: null, undefined, boolean, number, string, object, e symbol. "function" não é um tipo, uma vez que funções são objetos, elas são do tipo "object".


35. Qual desses tem valor falsy?
0;
new Number(0);
("");
(" ");
new Boolean(false);
undefined;
  • A: 0, '', undefined
  • B: 0, new Number(0), '', new Boolean(false), undefined
  • C: 0, '', new Boolean(false), undefined
  • D: Todos são falsy
Resposta

Resposta: A

Existem somente seis valores falsy:

  • undefined
  • null
  • NaN
  • 0
  • '' (string vazia)
  • false

Funções construtoras, como new Number e new Boolean são truthy.


36. Qual é a sáida?
console.log(typeof typeof 1);
  • A: "number"
  • B: "string"
  • C: "object"
  • D: "undefined"
Resposta

Resposta: B

typeof 1 retorna "number". typeof "number" retorna "string"


37. Qual é a saída?
const numbers = [1, 2, 3];
numbers[10] = 11;
console.log(numbers);
  • A: [1, 2, 3, 7 x null, 11]
  • B: [1, 2, 3, 11]
  • C: [1, 2, 3, 7 x empty, 11]
  • D: SyntaxError
Answer

Answer: C

When you set a value to an element in an array that exceeds the length of the array, JavaScript creates something called "empty slots". These actually have the value of undefined, but you will see something like:

[1, 2, 3, 7 x empty, 11]

depending on where you run it (it's different for every browser, node, etc.)


38. Qual é a saída?
(() => {
  let x, y;
  try {
    throw new Error();
  } catch (x) {
    (x = 1), (y = 2);
    console.log(x);
  }
  console.log(x);
  console.log(y);
})();
  • A: 1 undefined 2
  • B: undefined undefined undefined
  • C: 1 1 2
  • D: 1 undefined undefined
Resposta

Resposta: A

O bloco do catch recebe o argumento x. Esse não é o mesmo x da variável de quando estamos passando os argumentos. A variável x é de escopo do seu bloco.

Depois, definimos essa variável, dentro do seu bloco, para valor 1, e definimos o valor de y, que pertence a um bloco maior. Agora, nos adicionamos ao log o valor de x, que dentro desse bloco tem valor 1.

Fora do bloco do catch. x ainda é undefined, e y ainda é 2. Quando tentamos usar console.log(x) fora do bloco do catch, isso retorna undefined, e y retorna 2.


39. Tudo em JavaScript ou é um...
  • A: primitivo ou um objeto
  • B: função ou um object
  • C: Pegadinha! Somente objetos
  • D: número ou um objeto
Resposta

Resposta: A

JavaScript tem somente tipos primitivos e objetos.

Tipos primitivos são boolean, null, undefined, bigint, number, string, e symbol.

O que diferencia um primitivo de um objeto é que primitivos não métodos ou propriedades. Contudo, se você está atento vai lembrar que 'foo'.toUpperCase() retorna 'FOO' e não resulta em um TypeError. Isso acontece pois quando você tenta acessar uma propriedade ou método em um primitivo como, por exemplo, uma string, JavaScript vai transformar esse primitivo em objeto usando um wrapper, nesse caso o String, e discarta o wrapper imediatamente após executar o método ou propriedade. Todos os primitivos, com exceção de null e undefined exibem esse comportamento.


40. Qual é a saída?
[[0, 1], [2, 3]].reduce(
  (acc, cur) => {
    return acc.concat(cur);
  },
  [1, 2]
);
  • A: [0, 1, 2, 3, 1, 2]
  • B: [6, 1, 2]
  • C: [1, 2, 0, 1, 2, 3]
  • D: [1, 2, 6]
Resposta

Resposta: C

[1, 2] é nosso valor inicial. É o valor que começamos, e portanto o valor do primeiro acc. Durante a primeira iteração, acc é [1,2], e cur é [0, 1]. Nós concatemos ambos, o que resulta em [1, 2, 0, 1].

Então, [1, 2, 0, 1] é acc e [2, 3] é o cur. Concatenamos novamente, e chegamos em [1, 2, 0, 1, 2, 3].


41. Qual é a saída?
!!null;
!!"";
!!1;
  • A: false true false
  • B: false false true
  • C: false true true
  • D: true true false
Resposta

Resposta: B

null é falsy. !null retorna true. !true retorna false.

"" é falsy. !"" retorna true. !true retorna false.

1 é truthy. !1 retorna false. !false retorna true.


42. O que o método setInterval retorna no navegador?
setInterval(() => console.log("Hi"), 1000);
  • A: um id único
  • B: a quantidade de millisegundos especificada
  • C: a função passada
  • D: undefined
Resposta

Resposta: A

Retorna um id único. Esse id pode ser usado para limpar o intervalo com a função clearInterval().


43. Qual é o retorno?
[..."Lydia"];
  • A: ["L", "y", "d", "i", "a"]
  • B: ["Lydia"]
  • C: [[], "Lydia"]
  • D: [["L", "y", "d", "i", "a"]]
Resposta

Resposta: A

Strings são iteráveis. O operador do spread ... mapeia todo caractére de um iterável para um elemento.