Exam Specific Questions

Question 1

How is a variable’s scope determine?

Answer 1

A variable’s scope determines where it is available in a program. The location where you declare a variable determines its scope.

You can declare a variable with global scope or local scope.

Question 2

How is a block scope defined?

Answer 2

A block is a set of statements and expressions between a set of curtly braces { }. 
E.g. if statements, for and while loops
Note: Object literals and class definitions are not blocks 

Let and const variables have block scope, which means if declared within a block, they are only accessible within that block.

Question 3

What is an undeclared variable? What is a notable feature of undeclared variables?

Answer 3

An undeclared variable is a variable not declared with let, const, or var.

E.g. variable = 123

Undeclared variables have global scope and ignore function/block scope entirely.

Question 4

What are the 3 broad rules of variable scope?

Answer 4

1. A variable declared outside of a block is accessible inside the block.
2. Inner scope variables cannot be accessed in outer scope.
3. Inner scope variables will overshadow outer scope variables. i.e. once the inner scope has the same name as an outer scope variable, the outer variable will not be accessible inside the scope.

Question 5

What are the 2 rules specific to function scope?

Answer 5

1. Peer function scopes do not conflict.
   i. e. Two different functions can have the same variable names within its scope
2. Nested functions have their own variable scope.
   Same levels apply where the innermost function can access outer scopes, but outer scopes cannot access inner function scopes.

Question 6

What are the two types of values all JavaScript data types can be categorized into?

Answer 6

Every value in JavaScript is either a primitive value or an object.

Question 7

What are the 7 primitive data types?

Answer 7

String, Boolean, Number, Null, Undefined

Symbol and BigInt were introduced in ES6 but are less commonly used.

Question 8

What is the difference between null and undefined?

Answer 8

Both represent an absence in value, but null is an intention absence usually assigned by design.

Question 9

What is the key feature of primitive data types?

Answer 9

Primitive data types are also known as atomic or indivisible data types since they are immutable.

They can only be reassigned if declared using let or var, but not changed.

Any operation performed on a primitive value will return a new primitive value.

Question 10

What is the difference between a non-mutating and a mutating operation?

Answer 10

A non-mutating operation preserves the previous value of the data passed in.

A mutating operation will change the previous value of the data passed in.

Primitive data type methods are non-mutating since primitive values are immutable.

Mutation is a concern for certain array and object methods since passed in arrays/objects have the chance of being mutated. i.e. sort, push, pop

Question 11

What are some common string methods? What are their return values?

Answer 11

.includes => true/false
.concat => new string
.split => new array
.trim => new string
.toUpperCase / .toLowerCase => new string
.charAt => character located at index
.charCodeAt => UTF-16 code of character at index
.repeat => new string
.endsWith / .startsWith => true/false

Question 12

What are some common array methods? What are their return values?

Answer 12

.forEach => undefined
.map => new array
.filter => new array of elements that satisfy callback
.find => first element in the array that satisfy callback
.sort => original array, mutated
.includes => true / false
.reduce => single accumulated output value

Question 13

What are considered objects? What is the key feature of objects?

Answer 13

Objects include:
Simple objects
Arrays
Date objects
Functions

Objects are mutable, you can change part of an object.

Question 14

How do you access keys and values in an object as an array?

Answer 14

Object.keys() and Object.values() methods allow you to access keys and values as separate arrays.

Object.entries() will return a nested array of key/value pairs.

Question 15

What is an object’s inheritance?

Answer 15

A child object can inherit properties from another parent object.

Object.create() is a simple way to create a new object that inherits from an existing object.

Question 16

How do you iterate over an object’s keys and values? How do you exclude iterating over inherited properties?

Answer 16

You can loop over an object’s keys and values with a for/in loop. A regular for/in loop with iterate over all inherited properties as well.

To limit iteration to an object’s own properties, use the hasOwnProperty() method (which will return true if not inherited)

Question 17

How do you merge the properties of two different objects?

Answer 17

Object.assign() method allows you to merge two or more objects. It allows you to combine key-value pairs into a single object.

NOTE: Object.assign will mutate the target object (first argument passed in). To create a new object and avoid mutation, use an empty object as the first argument.

Question 18

What are sparse arrays?

Answer 18

Arrays may have gaps where there are missing elements aka elements that have never been assigned a value.

Accessing these gap elements by index will return undefined, but NOTE this does not mean the value is undefined. It is not set at all.

E.g. The following is either called a 3-element array whose values are missing OR an empty array with a length of 3:

> let array = [ ];
array.length = 3;
console.log(array) // => [ <3 empty items> ]

Question 19

Why are arrays considered objects?

Answer 19

Arrays are also objects, but with indexes (non-negative integer) as their property key.

It is possible for an array to have properties whose name is not a non-negative integer.

E.g. 
> let array = [1, 2];
> array[-1] = 3;
> array['foo'] = 'boo';
> console.log(array)    // => [1, 2, '-1': 3, foo: 'boo']

Question 20

Explain the difference between a pass by reference and a pass by value? Which strategy does JavaScript utilize?

Answer 20

‘Pass by reference’ and ‘Pass by value’ are both strategies that describe the affect of function arguments.

Pass by value describes a variable that is passed in as a function argument and the function can’t do anything that mutates the variable. This is the case for JavaScript’s primitive data types.

Pass by reference describes a variable being passed in as a function argument and the function call can affect the original data value. This is the case for arrays and objects, which have the chance of being mutated by certain methods (e.g. pop, push, shift)

Question 21

When are variables considered pointers aka references? What happens when variables that are pointers are reassigned?

Answer 21

JavaScript uses pointers for non-primitive values like arrays and objects.

Non-primitive values are stored in a region of memory (aka heap) that is pointed or referred to when the data retrieved.

Therefore when a variable is assigned the value of another variable that is an array or object, the value is pointing to the same region in memory. Mutating one variable will also mutate the other.

However, reassigning one of the variables will not mutate the other. Reassignment will cause the reassigned variable to point to a different region in memory.

It is important to note that reassigning a single element or property in an array or object WILL mutate all variables referencing the same data in memory.

Question 22

What is the key difference between returning a value and printing/displaying it?

Answer 22

Console.log is a method that tells JavaScript to print/display something to the console. In node, that is your screen. In the browser, that is your developer tool.

The return value for console.log, however, will always be undefined because the expression evaluates to nothing.

A return value is the evaluated value of an expression. Expressions are anything JS can evaluate to value, even if it is undefined or null.

Question 23

What are the 6 falsy values? What are truthy values?

Answer 23

The 6 falsy values are:
False
0 (zero)
NaN
"" (empty string)
undefined
null

Everything that is not a falsy value, is a truthy value.

Question 24

What is the correct method to describe a truthy or falsy value?

Answer 24

When discussing a truthy/falsy expression, it is recommended to use terms such as “evaluates to true” or “is truthy” instead of “is true” or “equals to true”.

Question 25

What is the difference between a variable declaration and a variable assignment?

Answer 25

A variable declaration is a STATEMENT that asks JavaScript to reserve space for a variable with a particular name.

An assignment is when a variable (or identifier) is initialized with a value using the ‘=’ assignment operator.

Note: Variable declarations have a return value of undefined, even if there is also an assignment. A pure assignment without a declaration, will have a return value of the value on the right hand side of the ‘=’ operator.

Question 26

What are the comparison operators? What are their return values?

Answer 26

Comparison operators include:

> , =, <=, ==, ===, !=, !==

All comparison operators have a boolean return value.

Question 27

What is the difference between a strictly equal ‘===’ and a loosely equal ‘==’ operator?

Answer 27

A strictly equal operator returns true when both operands have the same value AND data type.

A loosely equal operator returns true when both operands have the same value, but not necessarily the same data type.

Question 28

What will NaN === NaN return?

Answer 28

NaN === NaN OR
NaN == NaN

will always return false

Question 29

What are the three logical operators?

Answer 29

&& (AND), | | (OR), ! (NOT)

&& returns true when both operands are true.

! will negate the operand and return the opposite boolean value

| returns true when one of the two operands is true.

Question 30

How do logical operators short circuit?

Answer 30

Using the && operator, if the first operand is false then expression will terminate and the second operand will not run.

Using the | | operator, if the first operand is true, then the expression will terminate and the second operand will not run.

Note: The return value of the two logical operators (&&, | |) is always the value of the operand evaluated last.

Question 31

What is the order of operator precedence?

Answer 31

1. Comparison: <=, , >=
2. Equality: ===, ==, !==, !=
3. Logical AND &&
4. Logical OR | |

Question 32

What is the difference between implicit and explicit coercion?

Answer 32

Implicit coercion describes JavaScript’s default process of changing one of two data types to match when performing an operation involving two different data types.

Explicit coercion is a programmer’s intentional alteration of a data type using Javascript’s built-in functions.

You should always rely on explicit coercion when working with different data types!

Question 33

What data types do JavaScript implicitly coerce when using template literals?

Answer 33

Inside template literals, JS coerces all expressions wrapped in ${ } to string values.

Question 34

What happens when you use the == loosely equal operator to compare a string and a number?

Answer 34

When using the == operator to compare a string and a number, JavaScript will implicitly coerce the string into the number.

string == number
string becomes a number. If it is not a numeric value, the value will be NaN

Question 35

What happens when you use the == loosely equal operator to compare a string OR number with a boolean?

Answer 35

string/number == boolean
JavaScript will implicitly coerce the boolean value into its number value.
true = 1, false = 0

e.g.
‘1’ == true // => true because true is coerced to 1

Question 36

What will be the return value when comparing ‘null’ and ‘undefined’ with a == loosely equal operator? What about with a === strictly equal operator?

Answer 36

null == undefined // => true, coerced to zeros

nul === undefined // => false

Question 37

What will be the return value when comparing an empty array with an empty string with a loosely equal operator? What about zero or an empty object?

Answer 37

[] == “” // => true, both coerced to numbers (zeros)
[] == 0 // => true, empty array coerced to number (zero)
[4] == 4 // => true, array with single element coerced to number

”” == 0 // => true, empty string coerced to number (zero)

[] == {} // => false, two objects (even empties) are never equal unless pointing to the same point in memory

Question 38

When using the + operator and ONE of the operands is a string, what will happen to the other operand?

Answer 38

When using the + operator, if one of the operands is a string then the other operand will be implicitly coerced by JS into a string.

E.g.
> ‘number’ + 1 // = > ‘number 1’
> “” + [1, 2, 3] // => ‘1,2,3’
> “” + {} // = > ‘[object Object]’

Question 39

When using the + operator, what will happen when the operands are primitive data types other than strings and undefined (either numbers, booleans, or nulls)?

What if undefined is one of the operands?

Answer 39

When using the + operator with numbers, booleans, and nulls, both operands will be converted to numbers and added together.

E.g.
> true + false // => 1 + 0 = 1
> 7 + null // => 7+ 0 = 7

Undefined with the + will always return NaN
> undefined + null // => NaN
> undefined + 8 // => NaN

Question 40

When using the + operator, what will happen when one of the operands is an object?

Answer 40

Both operands will be converted into a string and concatenated together.

The object (empty or filled) becomes the string ‘[object Object]’.

E.g.
> {foo: 1} + 8 // => ‘[object Object]8’
> {foo: 1} + undefined // => ‘[object Object]undefined’

Question 41

What happens when you use relational operators (e.g. >, =, <=) to compare two different data types?

Answer 41

All non-numbers (strings, boolean, null, undefined) will be converted to numbers.
Note: Undefined’s number form is NaN.

E.g.
> true > null // => true since 1 > 0
> 123 > ‘a’ // => false since 123 is not greater than NaN
> 123 > undefined // => false since 123 is not greater than NaN

Question 42

What happens when you use relational operators (e.g. >, =, <=) to compare two strings?

Answer 42

When both operands are strings, they are compared in lexicographic (abc) order.

e.g. ‘b’ > ‘a’

Question 43

What are some ways to explicitly convert non-number data types (e.g. strings, arrays) to numbers?

Answer 43

Number() method will convert numeric strings, booleans, null, single digit arrays to their numeric value.
Non-numeric strings, undefined, empty objects, filled arrays will return NaN.
Empty strings, empty arrays, whitespace strings, and false will return 0 (zero).

parseInt() method functions similarly to Number(). The key difference is that it will convert a string to a number as long as it begins with a digit. (e.g. ‘12oz’)

The unary + operator will also change a value to a number and works exactly the same as Number().

Question 44

What are some ways to explicitly convert non-string data types to strings?

Answer 44

toString() or String() will both convert to string.

String() will also convert undefined and null to strings whereas toString() will have result in an error.

Question 45

What is the difference between a function definition and function invocation?

Answer 45

Function definition includes a function’s parameters and the code within the function body. A function definition will not run/execute until it is invoked.

Function invocation (aka calling the function) is writing the function name and passing in argument(s) within a set of parentheses. Upon invocation, the function will execute the code within the function body with the passed in arguments as its parameters.

Question 46

What are function declarations? What is the syntax?

Answer 46

Function declaration is a way of writing functions using the ‘function’ key word, curly braces, and an explicit return statement. If there is no return statement, the function will return undefined.

Question 47

What are function expressions? What is the syntax?

Answer 47

Function expressions are function definitions saved in a variable (let, const, var).

E.g. let greetPeople = function () {
       console.log('Good morning');
        };

NOTE: Wrapping a function declaration in a set of parentheses will create a function expression.

Question 48

Are functions returned from a higher order function considered a function declaration or function expression?

Answer 48

Functions returns from a higher order function are considered function expressions.

E.g. greeter function below is a function expression 
 > function makeGreeter(name) {
 >   return function greeter() {
 >        console.log(`Hello ${name}`);
 >   }
 > }

Question 49

What is the key feature difference between function declarations and function expressions?

Answer 49

Function declarations can be invoked BEFORE it is declared in the code because they are hoisted to the top when the program is executed.

Function expressions cannot be invoked before it appears in a program. Calling a function expression before it is written in the program will result in an error.

Question 50

What is an arrow function? What is the syntax?

Answer 50

Arrow functions are function expressions that do not use the function keyword.

The return statement and curly braces can be omitted if the function body contains only ONE expression.

If there are multiple lines/expressions in the function body, then return statement and curly braces are needed.

Parentheses can be omitted if there is only one argument.

Question 51

What is the implicit return value for functions?

Answer 51

By default, a function’s return value is undefined.

When a return statement is used within the function definition, that specific value will be returned to the location where it was called/invoked.

Question 52

Describe higher-order functions in JavaScript.

Answer 52

Higher-order functions are functions that take functions as an argument or return a function.

It doesn’t have to have function definitions within their body to be considered higher-order.

It can return any function, including a function that is another higher-order function.

Question 53

What are considered first-class values in JavaScript?

Answer 53

First-class values are values that can be passed to functions as arguments or returned by those functions.

All JS functions are first-class functions i.e. all functions can be passed around as values.

Functions passed to other functions are often called callbacks.

It doesn’t have to accept another function as an argument or return a function to be considered first-class.

There is no limit to the number of functions that can be passed as arguments to a first-class function.

Question 54

Describe the 6 possible function side effects.

Answer 54

1. It changes the value of a variable defined in the outer scope.
2. It changes the state or content of an array or object that is assigned to a variable in the outer scope.
3. It changes the state or content of an array or object passed to the function as an argument.
4. It uses a variable from the outer scope that is not a constant.
5. It reads or writes output from any source
   e. g. using readline-sync to define a variable, console logging
6. It calls another function that has a side effect

Question 55

What are the 3 characteristics of pure functions?

Answer 55

1. Always return a value that is dependent on its arguments
2. Have no side effects
3. Given the same arguments, the function always return the same value.