Top 179 JavaScript Interview Questions And Answers

Q: Test divisors of three

We'll solve this problem by first creating a loop that will print each number from low to high. Once we have the code for that written, we'll add a conditional that will check if the number is evenly divisible by 3 by using the mod operator. ```js function test_divisors(low, high) { // we'll store all numbers and strings within an array // instead of printing directly to the console var output = []; for (var i = low; i <= high; i++) { // simply store the current number in the output array output.push(i); // check if the current number is evenly divisible by 3 if (i % 3 === 0) { output.push('div3'); } } // return all numbers and strings return output; } test_divisors(2, 10); ```

Q: Sum of several arrays

We will solve this challenge by looping through the entire array, and then looping through each inner array adding up all the numbers. ```js function sum_array(arr) { // store our final answer var sum = 0; // loop through entire array for (var i = 0; i t.concat(e)).reduce((t, e) => t + e) } ```

Question 1

What is the `object` type?

Accepted Answer

The `object` type refers to a compound value where you can set properties (named locations) that each hold their own values of any type.

```js
var obj = {
	a: "hello world", // property
	b: 42,
	c: true
};

obj.a;		// "hello world", accessed with doted notation
obj.b;		// 42
obj.c;		// true

obj["a"];	// "hello world", accessed with bracket notation
obj["b"];	// 42
obj["c"];	// true
```
Bracket notation is also useful if you want to access a property/key but the name is stored in another variable, such as:
```js
var obj = {
	a: "hello world",
	b: 42
};

var b = "a";

obj[b];			// "hello world"
obj["b"];		// 42
```

Question 2

Explain equality in JavaScript

Accepted Answer

JavaScript has both strict and type–converting comparisons: 
* **Strict comparison (e.g., ===)** checks for value equality without allowing *coercion*
* **Abstract comparison (e.g. ==)** checks for value equality with *coercion* allowed

```js
var a = "42";
var b = 42;

a == b;			// true
a === b;		// false
```
Some simple equalityrules:
* If either value (aka side) in a comparison could be the `true` or `false` value, avoid `==` and use `===`.
* If either value in a comparison could be of these specific values (`0`, `""`, or `[]` -- empty array), avoid `==` and use `===`.
* In all other cases, you're safe to use `==`. Not only is it safe, but in many cases it simplifies your code in a way that improves readability.

Question 3

Simple clock angle

Accepted Answer

If the input is `15` then your program should return `90` because a `90`-degree angle is formed by the minute hand and the `12` o'clock mark on the clock. We'll solve this challenge by first calculating what angle is created by each minute passing on a clock. Once we calculate this number, we multiply it by the input to determine the final angle.

A method to solve such problems is to consider the rate of change of the angle in degrees per minute. The hour hand of a normal `12-hour` analogue clock turns `360°` in `12` hours (`720` minutes) or `0.5°` per minute. The minute hand rotates through `360°` in `60` minutes or `6°` per minute.

```js
function simpleClockAngle(num) {

// we got 6 because 360/60 = 6
  // 360 represents the full number of a degrees in a circle and
  // 60 is the number of minutes on a clock, so dividing these two numbers
  // gives us the number of degrees for one minute
  return 6 * num;

}

simpleClockAngle(15);
```

Question 4

What is `Scope` in JavaScript?

Accepted Answer

In JavaScript, each function gets its own *scope*. Scope is basically a collection of variables as well as the rules for how those variables are accessed by name. Only code inside that function can access that function's scoped variables.

A variable name has to be unique within the same scope. A scope can be nested inside another scope. If one scope is nested inside another, code inside the innermost scope can access variables from either scope.

Question 5

Explain how Bubble Sort works

Accepted Answer

**Bubble Sort** is based on the idea of repeatedly _comparing_ pairs of adjacent elements and then swapping their positions if they are in the wrong order. Bubble sort is a _stable_, _in-place_ sort algorithm.

How it works:
* In an unsorted array of `n` elements, start with the first two elements and sort them in ascending order. (Compare the element to check which one is greater).
* Compare the second and third element to check which one is greater, and sort them in ascending order.
* Compare the third and fourth element to check which one is greater, and sort them in ascending order.
* ...
* Repeat steps 1–`n` until no more swaps are required.

**Visualisation:**

![](https://camo.githubusercontent.com/383b23979d4d7f279f8fb285b36bcdd357b10a35/68747470733a2f2f75706c6f61642e77696b696d656469612e6f72672f77696b6970656469612f636f6d6d6f6e732f632f63382f427562626c652d736f72742d6578616d706c652d33303070782e676966)

Question 6

Lucky sevens

Accepted Answer

To solve this challenge we'll simply loop through the array starting at the 3rd position, and checking if the number at this index plus the two previous elements sums to 7. We continue doing this as we loop through the entire array. Once we find three elements that sum to 7, we simply return `true`. If we reach the end of the array without finding elements that sum to 7, we return `false`.

```js
function lucky_sevens(arr) {
  
  // if less than 3 elements then this challenge is not possible
  if (arr.length < 3) {
    return "not possible";
  }
  
  // because we know there are at least 3 elements we can
  // start the loop at the 3rd element in the array (i=2)
  // and check it along with the two previous elements (i-1) and (i-2)
  for (var i = 2; i < arr.length; i++) {
    if (arr[i] + arr[i-1] + arr[i-2] === 7) {
      return true; 
    }
  }
  
  // if loop is finished and no elements summed to 7
  return false;
  
}

lucky_sevens([2, 1, 5, 1, 0]);
```

Question 7

Test divisors of three

Accepted Answer

We'll solve this problem by first creating a loop that will print each number from low to high. Once we have the code for that written, we'll add a conditional that will check if the number is evenly divisible by 3 by using the mod operator.

```js
function test_divisors(low, high) {
  
  // we'll store all numbers and strings within an array
  // instead of printing directly to the console
  var output = [];
  
  for (var i = low; i <= high; i++) {
    
    // simply store the current number in the output array
    output.push(i);
    
    // check if the current number is evenly divisible by 3
    if (i % 3 === 0) { output.push('div3'); }
    
  }
  
  // return all numbers and strings
  return output;
  
}

test_divisors(2, 10);
```

Question 8

Sum of several arrays

Accepted Answer

We will solve this challenge by looping through the entire array, and then looping through each inner array adding up all the numbers. ```js function sum_array(arr) { // store our final answer var sum = 0; // loop through entire array for (var i = 0; i < arr.length; i++) { // loop through each inner array for (var j = 0; j < arr[i].length; j++) { // add this number to the current final sum sum += arr[i][j]; } } return sum; } sum_array([[3, 2], [1], [4, 12]]); ``` With `reduce`: ```js function sumArray(arr) { return arr.reduce((t, e) => t.concat(e)).reduce((t, e) => t + e) } ```

Question 9

What is `typeof` operator?

Accepted Answer

JavaScript provides a `typeof` operator that can examine a value and tell you what type it is:
```js
var a;
typeof a;				// "undefined"

a = "hello world";
typeof a;				// "string"

a = 42;
typeof a;				// "number"

a = true;
typeof a;				// "boolean"

a = null;
typeof a;				// "object" -- weird, bug

a = undefined;
typeof a;				// "undefined"

a = { b: "c" };
typeof a;				// "object"
```

Question 10

Explain arrays in JavaScript

Accepted Answer

An `array` is an object that holds values (of any type) not particularly in named properties/keys, but rather in numerically indexed positions:

```js
var arr = [
	"hello world",
	42,
	true
];

arr[0];			// "hello world"
arr[1];			// 42
arr[2];			// true
arr.length;		// 3

typeof arr;		// "object"
```

Top 179 JavaScript Interview Questions

What is the object type?

What is typeof operator?

Explain arrays in JavaScript

Explain equality in JavaScript

What is Scope in JavaScript?

What's the difference between Host objects and Native objects?

What's the difference between throw Error('msg') vs throw new Error('msg')?

Explain the same-origin policy with regards to JavaScript.

What is the difference between == and ===?

Is there anyway to force using strict mode in Node.js?

Why would you use something like the load event? Does this event have disadvantages? Do you know any alternatives, and why would you use those?

What is strict mode?

What is Callback Hell and what is the main cause of it?

What does use strict do?

Explain event bubbling and how one may prevent it

What are some of the advantages/disadvantages of writing JavaScript code in a language that compiles to JavaScript?

What language constructions do you use for iterating over object properties and array items?

Explain Values and Types in JavaScript

Explain Null and Undefined in JavaScript

Explain what is Linear (Sequential) Search and when may we use one?

Why is it, in general, a good idea to leave the global scope of a website as-is and never touch it?

What is let keyword in JavaScript?

Explain what is Binary Search

What is a Polyfill?

What is the motivation for bringing Symbol to ES6?

What's the difference between using let and var to declare a variable in ES6?

What is generator in JS?

Why is extending built-in JavaScript objects not a good idea?

What advantages are using arrow functions?

What are the advantages and disadvantages of using use strict?

When should we use generators in ES6?

How to compare two objects in JavaScript?

What will be the output of the following code?

What is a closure, and how/why would you use one?

What's a typical use case for anonymous functions?

What will be the output of the following code?

Suggest one simple way of removing duplicates from an array using ES6

What is the difference between Anonymous and Named functions?

Explain the difference between Object.freeze() vs const

Why should we use ES6 classes?

What are the differences between ES6 class and ES5 function constructors?

What is Currying?

What is the difference between document load event and document DOMContentLoaded event?

What is the difference between a shim and a polyfill?

What do you think of AMD vs CommonJS?

What is the definition of a Higher-Order Function?

What is a Jump (or Block) Search?

Explain the difference between undefined and not defined in JavaScript

What is Coercion in JavaScript?

What is IIFEs (Immediately Invoked Function Expressions)?

Explain what is Interpolation Search

What is export default in JavaScript?

When should I use Arrow Functions in ES6?

What are the benefits of using spread syntax in ES6 and how is it different from rest syntax?

Explain Function.prototype.bind.

Could you explain the difference between ES5 and ES6

Describe Closure concept in JavaScript as best as you could

What is the preferred syntax for defining enums in JavaScript?

What's the difference between .call and .apply?

What is the drawback of creating true private in JavaScript?

Explain the differences on the usage of foo between function foo() {} and var foo = function() {}

Does JavaScript have a map function to iterate over an object properties?

How would you prevent Callback Hell without using promises, async or generators?

Explain how JSONP works (and how it's not really Ajax)

Could you compare usage of Module Pattern vs Constructor/Prototype pattern?

When would you use import * as X from 'X' ?

What tools can be used to assure consistent code style?

What is the Temporal Dead Zone in ES6?

Explain Prototype Inheritance in JavaScript?

Explain what is Hoisting in Javascript

What's the difference between a variable that is: null, undefined or undeclared? How would you go about checking for any of these states?

Describe the JS module design pattern

Explain the Prototype Design Pattern

Can you give an example for destructuring an object or an array in ES6?

What does the term Transpiling stand for?

Can you describe the main difference between a .forEach loop and a .map() loop and why you would pick one versus the other?

What is the new keyword in JavaScript?

When should you NOT use arrow functions in ES6? Name three or more cases.

Check if a given string is a isomorphic

What is the `object` type?

What is `typeof` operator?

What is `Scope` in JavaScript?

What's the difference between `throw Error('msg')` vs `throw new Error('msg')`?

What is the difference between `==` and `===`?

Why would you use something like the `load` event? Does this event have disadvantages? Do you know any alternatives, and why would you use those?

What is `strict mode`?

What does `use strict` do?

Explain `Null` and `Undefined` in JavaScript

What is `let` keyword in JavaScript?

What is the motivation for bringing `Symbol` to ES6?

What's the difference between using `let` and `var` to declare a variable in ES6?

What are the advantages and disadvantages of using `use strict`?

Explain the difference between `Object.freeze()` vs `const`

What is the difference between document `load` event and document `DOMContentLoaded` event?

Explain the difference between `undefined` and not defined in JavaScript

What is `export default` in JavaScript?

Explain `Function.prototype.bind`.

What's the difference between `.call` and `.apply`?

Explain the differences on the usage of `foo` between `function foo() {}` and `var foo = function() {}`

Does JavaScript have a `map` function to iterate over an object properties?

When would you use `import * as X from 'X'` ?

What's the difference between a variable that is: `null`, `undefined` or undeclared? How would you go about checking for any of these states?

Can you describe the main difference between a `.forEach` loop and a `.map()` loop and why you would pick one versus the other?

What is the `new` keyword in JavaScript?

Explain difference between: `function Person(){}`, `var person = Person()`, and `var person = new Person()`?

In JavaScript, why is the `this` operator inconsistent?

What's the difference between ES6 `Map` and `WeakMap`?

Compare `Async/Await` and `Generators` usage to achive same functionality

What is the difference between the `await` keyword and the `yield` keyword?

Find the missing number in `O(n)` time

Return the N-th value of the Fibonacci sequence. Solve in `O(n)` time

Implement `pow(a,b)` without multiplication or division

Get the N-th Fibonacci number with `O(n)` time and `O(1)` space complexity