Expressions & Operators

Question 1

What are two special values that denote the absence of a meaningful value?

Answer 1

null & undefined

Question 2

What’s the difference between null and undefined?

Answer 2

Undefined typically means a variable has been declared but not defined.

Null is an empty or non-existent value. Null must be assigned.

Question 3

What’s the special behavior of the || logical operator when the left hand side is not a boolean?

Answer 3

When the left hand side is not boolean, it will convert it to a boolean to decide which side to take.

expr1 || expr2 : if expr1 can be converted to true, returns expr1. It can be used to fallback to a default value.

const car = {};
const color = car.color || 'green';

Question 4

What’s the special behavior of the && logical operator when the left hand side is not a boolean?

Answer 4

When the left hand side is not boolean, it will convert it to a boolean to decide which side to take.

expr1 && expr2 : if expr1 can be converted to true, returns expr2. Can be used to check if object is defined (or truthy) before using it.

const car = { color: 'green' };
const color = car && car.color;

Question 5

Describe equality comparison for primitives like strings and numbers

Answer 5

Primitives like string and numbers are compared by their value.

Question 6

Describe equality comparison for objects like arrays, dates, and plain objects.

Answer 6

Objects like arrays, dates, and plain objects are compared by their reference, which checks to see if the objects refer to the same location in memory.

Question 7

What does it mean to compare by reference?

Answer 7

Checks to see if the objects refer to the same location in memory.

Question 8

What is this type of syntax called?

const [red, yellow, green] = foo;

Answer 8

Array destructuring

Question 9

What is the purpose of array destructuring?

Answer 9

Makes it possible to unpack values from arrays into distinct variables.

const foo = ['one', 'two', 'three'];
const [red, yellow, green] = foo;
console.log(red); // 'one'

Question 10

How can you swap two variables in one expression?

Answer 10

You can use array destructuring:

let a = 1;
let b = 2;
[a, b] = [b, a];
console.log(a); // 2
console.log(b); // 1

Question 11

What is this type of syntax called?

const a = { b: 7, c: true };
const {b, c} = a;

Answer 11

Object desctructuring

Question 12

When unpacking a variable with object destructuring, how do you also assign it to a variable with a different name?

Answer 12

const a = { b: 7, c: true };
const {b: newName, c: anotherNew } = a;
console.log(newName); // 7

Question 13

What is the nullish coalescing operator?

Answer 13

The nullish coalescing operator is a logical operator that returns its right-hand side operand when its left-hand side operand is null or undefined, and otherwise returns its left-hand side operand.

const foo = null ?? 'default';
console.log(foo); // default

Question 14

What’s the name of the operator that returns its right-hand side operand when its left-hand side operand is null or undefined, and otherwise returns its left-hand side operand.

Answer 14

Nullish coalescing operator

Question 15

Which operator allows an expression to be expanded into multiple items?

Answer 15

The spread operator, which is three dots.

const foo = ['b', 'c'];
const bar = ['a', ...foo, 'd'];
// ["a", "b", "c", "d"]

Question 16

Using the spread operator, what two places can you expand an iterable expression into? (Iterable expression being like an array or a string.)

Answer 16

1) Arguments for function calls

function foo(x, y, z) { }
const args = [1, 2, 3];
foo(...args);
// instead of foo.apply(null, args)

2) Elements for array literal

const foo = ['b', 'c'];
const bar = ['a', ...foo, 'd'];
// ["a", "b", "c", "d"]

Question 17

Using the spread operator, where can you expand an object?

Answer 17

You can expand an object into key-value pairs for object literals.

const obj1 = { foo: 'bar', x: 42 };
const clonedObj = { ...obj1 };
// Object { foo: "bar", x: 42 }

Question 18

How do you remove a property from an object?

Answer 18

The delete operator.

const employee = {
	firstname: “John”,
	lastname; “Doe”
};
console.log(employee.firstname);
// “John”
delete employee.firstname;
console.log(employee.firstname);
// undefined

Question 19

What does the delete operator do?

Answer 19

Removes a property from an object.

const employee = {
	firstname: “John”,
	lastname; “Doe”
};
console.log(employee.firstname);
// “John”
delete employee.firstname;
console.log(employee.firstname);
// undefined

Question 20

What does the ‘in’ operator do?

Answer 20

The ‘in’ operator returns true if the specified property is in the specified object or its prototype chain.

const car = {
	make: ‘Honda’,
	model: ‘Accord’
};
console.log(‘make’ in car);
// true
delete car.make;
console.log(‘make’ in car);
// false

Question 21

How do you check if a property is in an object?

Answer 21

The ‘in’ operator returns true if the specified property is in the specified object or its prototype chain.

const car = {
	make: ‘Honda’,
	model: ‘Accord’
};
console.log(‘make’ in car);
// true
delete car.make;
console.log(‘make’ in car);
// false

Question 22

What does the instanceof operator do?

Answer 22

The instanceof operator tests whether the prototype property of a constructor appears anywhere in the prototype chain of an object.

function Car(make, model) {
  this.make = make;
  this.model = model;
}
const myCar = new Car('Honda', 'Accord');
const a = myCar instanceof Car; // true
const b= myCar instanceof Object; //true

Question 23

What happens when the new operator executes?

const foo = new Foo(1, 2, 3);

Answer 23

When the code ‘new Foo(…)’ executes, the following things happen:

1) A new object is created, inheriting from the Foo.prototype.
2) The constructor function Foo is called with the specified arguments, and with ‘this’ bound to the newly created object.
3) The object returned by the constructor function becomes the result of the whole ‘new’ expression. If the constructor function doesn’t explicitly return an object, the object created in Step 1 is used instead. Normally constructors don’t return a value.

Question 24

What does the typeof operator return?

Answer 24

The typeof operator returns a string indicating the type of the operand.

console. log(typeof 42); // “number”
console. log(typeof ‘foo’); // “string”
console. log(typeof true); // “boolean”

Question 25

What is logged here?

const str = new String('foo');
console.log(typeof str);

Answer 25

It logs “object” because all constructor functions will be typeof “object” (except for Function constructors).

Question 26

What is the result of this?

typeof null

Answer 26

“object”

Question 27

What is the result of this?

typeof undefined

Answer 27

“undefined”

Question 28

Here are two ways to check if x has a value. What is the difference between them?

if (x !== undefined && x !== null) {
…
}

if (x) {
…
}

Answer 28

if (x !== undefined && x !== null) {
  // x is not undefined nor null
  // x could be false, 0, NaN, or ‘’
}

if (x) { // truthy
  // x is not undefined, null, 0, NaN, or ‘’
}

Question 29

Here are two ways to check if x is undefined or null. What is the difference between them?

if (x === undefined || x === null) {
…
}

if (!x) { // falsy
…
}

Answer 29

if (x === undefined || x === null) {
  // x is either undefined or null
  // x is not false, 0, NaN, or ‘’
}

if (!x) { // falsy
  // x is undefined, null, false, 0, NaN, or ‘’
}

Question 30

What is a falsy value?

Answer 30

A falsy value is a value that is considered false when encountered in a Boolean context.

Question 31

Give six examples of falsy values.

Answer 31

• false
• 0
• ’’ or “” or ``
• null
• undefined
• NaN

Question 32

What are the data types?

Answer 32

Primitives:
String, Number, Boolean, Null, Undefined, BigInt, Symbol

Non-primitive: Object