JavaScript Fundamentals

Question 1

Can you overwrite variable declarations without an error using var?

Answer 1

Yes;
var camper = 'James';
var camper = 'David';
console.log(camper);
// logs 'David'

Question 2

What are the six falsy values?

Answer 2

undefined, null, NaN, 0, “” (empty string), and false

Question 3

Will these return true or false?

1) false == “”
2) NaN == undefined
3) 0 == null
4) null == undefined
5) NaN == NaN
6) 0 == “”

Answer 3

1) false == “”, true
2) NaN == undefined, false
3) 0 == null, false
4) null == undefined, true
5) NaN == NaN, false (NaN is not equivalent to anything, not even itself!)
6) 0 == “”, true

If can use Object.is(NaN, NaN) to see if it is equal (will return true)

Question 4

What are the 7 primitive data types of JavaScript?

Answer 4

undefined
Boolean
Number
String
BigInt
Symbol
Null

Question 5

Why is Math.max() smaller than Math.min()?

Answer 5

If no arguments are given, Math.min() returns infinity and Math.max() returns -infinity . This is simply part of the specification for the max() and min() methods, but there is good logic behind the choice.

Question 6

What are the differences between var, let, and const?

Answer 6

Const can't be reassigned (although does allow for variable mutation... just can't re-assign the variable itself). Const also can't be declared without a value... will have syntax error
All declarations (function, var, let, const and class) are hoisted in JavaScript, while the var declarations are initialized with undefined, but let and const declarations remain uninitialized.
During compile time, JavaScript only stores function and variable declarations in the memory, not their assignments (value). 
They will only get initialized when their lexical binding (assignment) is evaluated during runtime by the JavaScript engine. 
Var is function scoped while let and const are block scoped (scoped within things like if statements and for loops

Question 7

What are things not allowed in ‘use strict’

Answer 7

Strict mode changes previously accepted “bad syntax” into real errors.

• Using a variable, without declaring it, is not allowed like x=5
• Mistyping a variable name creates a new global variable. In strict mode, this will throw an error, making it impossible to accidentally create a global variable.
• assigning values to non-writable properties
• deleting a variable or function
• duplicating parameters
• The this keyword refers to the object that called the function. If the object is not specified, functions in strict mode will return undefined and functions in normal mode will return the global object (window):

Question 8

What happens if you assign a variable without a keyword?

Answer 8

If not using strict mode, it will be assigned to the window. So x = 1 will be window.x = 1

Question 9

What is a ReferenceError and name common examples.

Answer 9

A ReferenceError indicates that an invalid reference value has been detected.
A JavaScript program is trying to read a variable that does not exist:
dog
dog = 2 (need use strict)
Or there are unexpected assignments (such as using = when you should use ==

Question 10

What is a SyntaxError and name some examples.

Answer 10

• A function statement without name
• Missing comma after an object property definition
• Trying to use a reserved identifier like delete or class
• Missing ) or } or ; or ,

Question 11

What is a type error and name some examples.

Answer 11

A TypeError happens when a value has a type that’s different than the one expected

• Mistyping a method… blank is not a function
• Unexpected undefined and null types

Question 12

What does this return?

alert(“1” + 2 + 2);

Answer 12

“122”

Here, the first operand is a string, the compiler treats the other two operands as strings too. The 2 gets concatenated to ‘1’, so it’s like ‘1’ + 2 = “12” and “12” + 2 = “122”.

Question 13

What does this return?

alert(2 + 2+ “1”);

Answer 13

“41”

Here, operators work one after another. The first + sums two numbers, so it returns 4, then the next + adds the string 1 to it, so it’s like 4 + ‘1’ = ‘41’.

Question 14

let counter = 1
let a = ++counter;
****************
let counter = 1
let a = counter++;

What is the value of a in each situation and why?

Answer 14

In the first scenario, ‘a’ returns 2 because the prefix form returns the new variable.

In the second scenario, ‘a’ returns 1 because the postfix form returns the old variable (prior to increment/decrement).

Note that if the result of increment/decrement is not used, there is no difference in which form to use:
let counter = 0;
counter++;
++counter;
alert( counter ); // 2, the lines above did the same

Question 15

What is the result of these two expressions?
null + 1 = ?
undefined + 1 = ?

Answer 15

null + 1 = 0
null becomes 0 after the numeric conversion

undefined + 1 = NaN
undefined becomes NaN after the numeric conversion

Question 16

What is the result of the following expressions?

console. log(“2” > 1);
console. log(“01” == 1);

Answer 16

Both are true because when comparing values of different types, JavaScript converts the values to numbers

Question 17

What does this do?

console.log(!!”non-empty string”)

Answer 17

Returns true. A double NOT !! is sometimes used for converting a value to a boolean type
Same as:
console.log(Boolean(“non-empty string”)); //true

Question 18

What will this result be?

console.log(null || 2 && 3 || 4)

Answer 18

The precedence of AND && is higher than ||, so it executes first.

&& returns the first falsy value or the last value if no falsy is found.

The result of 2 && 3 = 3, so the expression becomes:
null || 3 || 4
Now the result is the first truthy value: 3

Question 19

When would you want to use “do…while” over “while”?

Answer 19

This form of syntax should only be used when you want the body of the loop to execute at least once regardless of the condition being truthy. Usually, the “while” is preferred

Question 20

What is the nullish coalescing operator ?? and how is it differ from the OR || operator?

Answer 20

|| returns the first truthy value.
?? returns the first defined value.

We use ?? when we want to use default value only when the variable is null/undefined (instead of false, 0, “”). That is, when the value is really unknown/not set.

Question 21

What are rest and spread parameters?

Answer 21

• When … is at the end of function parameters, it’s “rest parameters” and gathers the rest of the list of arguments into an array.
• When … occurs in a function call or alike, it’s called a “spread syntax” and expands an array into a list

Question 22

What is optional chaining?

Answer 22

The optional chaining ?. is a safe way to access nested object properties, even if an intermediate property doesn’t exist.

The ?. checks the left part for null/undefined and allows the evaluation to proceed if it’s not so. If not it returns undefined. This allows to safely access nested properties.

The syntax has 3 forms:
obj?.prop – returns obj.prop if obj exists, otherwise undefined.
obj?.[prop] – returns obj[prop] if obj exists, otherwise undefined.
obj.method?.() – calls obj.method() if obj.method exists, otherwise returns undefined.

Question 23

What is a programming paradigm?

Answer 23

A strategy for designing and implementing your code. A philosophy, style, or general approach to writing code.

Question 24

What type of language is JavaScript?

Answer 24

JavaScript (JS) is a lightweight, interpreted, or just-in-time compiled programming language with first-class functions. JavaScript is a prototype-based, multi-paradigm, single-threaded, dynamic language, supporting object-oriented, imperative, and declarative (e.g. functional programming) styles.

As a multi-paradigm language, JavaScript supports event-driven, functional, and imperative programming styles. It has application programming interfaces (APIs) for working with text, dates, regular expressions, standard data structures, and the Document Object Model (DOM).

Question 25

What does this return?

console. log( ‘01’ == 1 );
console. log( true == 1 )

Answer 25

True. When comparing values of different types, JavaScript converts the values to numbers.
True. For boolean values, true becomes 1.

Question 26

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

Answer 26

Operands of different types are converted to numbers by the equality operator ==.

A strict equality operator === checks the equality without type conversion.

Question 27

a()

function a() {
console.log('hi')
}

function a() {
console.log('bye')
}

Answer 27

‘bye’

With variables, they’re partially hoisted so we have undefined to that variable.

However….

during the hoisting phase, we fully hoist function declarations!

Question 28

What logs?

var favoriteFood = “grapes”;

var foodThoughts = function () {
     console.log(favoriteFood);
     var favoriteFood = "sushi"
     console.log(favoriteFood);
}

foodThoughts()

Answer 28

undefined
sushi

Hoisting on every execution context. Every time we run a function, a new execution context get created and we have to go through the creation phase and execution phase again.

favoriteFood gets hoisted within the foodThoughts function, so when the first console.log happens, favoriteFood within that function is initialized but undefined.

If we remove the var from the function and simply had favoriteFood = “sushi”, then the first console.log would be grapes.

Question 29

What will be the output of the code below?
var z = 1, y = z = typeof y;
console.log(y);

Answer 29

The output would be undefined. associativity of the assignment operator is Right to Left, so typeof y will evaluate first , which is undefined. It will be assigned to z, and then y would be assigned the value of z and then z would be assigned the value 1.