JS Reserved Words

Question 1

What is ‘this’?

Answer 1

refers to an object:

In an object method, this refers to the object.
In an object’s prototype chain, this refers to the object.
In a function, in strict mode, this is undefined.
In an event, this refers to the element that received the event.

Alone, this refers to the global object.
In a function, this refers to the global object.

methods like call(), apply(), and bind() can refer this to any object.

Question 2

What are the JavaScript primitive data types?

Answer 2

7 primitives:

string, number, boolean, null, undefined, symbol, bigint

Question 3

break;

Answer 3

the break statement ends the current loop, switch, or labeled block.

Question 4

continue;

Answer 4

the continue statement ends the current iteration of a loop.

i.e. if we are on the 9th iteration and hit a continue statement, we’ll skip to the 10th iteration.

Question 5

return;

Answer 5

the return statement ends function/method execution and specifies a value to be returned to the caller.

Question 6

switch case

Answer 6

the two keywords needed to assemble a switch statement.

switch(input) {
  case 'a': 
    //run some code
    break;
  default: 
    alert('no code ran');
    break;
}

Question 7

if (true)

else…

Answer 7

the if keyword defines a conditional expression

the else keyword defines a block of code if not true

Question 8

for ()

Answer 8

creates a loop that will iterate ‘for’ a defined amount of iterations

Question 9

while (true)

Answer 9

creates a loop that will iterate for an undefined amount of iterations.

Question 10

do {
  //some code
}  while (true);

Answer 10

a do while expression will execute code exactly once before considering the while expression

Question 11

true

false

Answer 11

reserved keywords for boolean values

Question 12

typeof foobar

Answer 12

returns a string indicating the type of foobar

[ undefined, object, boolean, number, bigint, string, symbol, function, ]

note: null is a type of object

Question 13

foo instanceof bar

Answer 13

the instance of operator tests if the prototype property of a constructor appears in the prototype chain of an object.

returns true||false

Question 14

delete

Answer 14

the delete operator removes a property from an object.

delete object.property;

Question 15

in

Answer 15

the in operator returns true if the specified property exists in the object’s prototype chain

‘propertyName’ in object;

if (‘propertyName’ in object === false) //do this code;

Question 16

const

Answer 16

const foo = ‘bar’

Constants are block-scoped. The value of a constant can’t be changed through reassignment (i.e. by using the assignment operator), and it can’t be redeclared.

However, if a constant is an object or array its properties or items can be updated or removed.

Question 17

let

Answer 17

The let declaration declares a block-scoped local variable, optionally initializing it to a value.

Question 18

var

Answer 18

The var statement declares a function-scoped or globally-scoped variable, optionally initializing it to a value.

Question 19

Which is preferrable to use ‘let’ or ‘var’

Answer 19

The vast majority of the time, ‘let’ is preferable to use for variable containers.

Question 20

import

Answer 20

The static import declaration is used to import read-only live bindings which are exported by another module.

The imported bindings are called ‘live bindings’ as they are updated by the module that exported the binding, and cannot be modified by the importing module.

In order to use the import declaration in a source file, the file must be interpreted by the runtime as a module. In HTML, this is done by adding type=”module” to the tag.
Modules are automatically interpreted in strict mode.

import declarations can only be present in modules, and only at the top-level (i.e. not inside blocks, functions, etc.).

Question 21

What are the four forms of import declarations?

Answer 21

Named import: 
  import { export1, export2 } from "module-name";
Default import: 
  import defaultExport from "module-name";
Namespace import: 
  import * as name from "module-name";
Side effect import: 
  import "module-name";

Question 22

export

Answer 22

The export declaration is used to export values from a JavaScript module.

Question 23

export default

Answer 23

The export default syntax allows any expression.

As a special case, functions and classes are exported as declarations, not expressions, and these declarations can be anonymous.

This means functions will be hoisted.

Question 24

async

Answer 24

async function (parameter) { 
  const result = await expression;
  return result; 
}

An async function is a function declared with the async keyword, and the await keyword is permitted within it.

The async and await keywords enable asynchronous, promise-based behavior to be written in a cleaner style, avoiding the need to explicitly configure promise chains.

Question 25

await

Answer 25

The await expression causes async function execution to pause until a Promise is settled (that is, fulfilled or rejected). AND to resume execution of the async function after fulfillment. When resumed, the value of the await expression is that of the fulfilled Promise. If the Promise is rejected, the await expression throws the rejected value. It can only be used inside an async function within regular JavaScript code. However, it can be used on its own with JavaScript modules.

Question 26

null

Answer 26

The value null represents the intentional absence of any object value. It is one of JavaScript's primitive values and is treated as falsy for boolean operations.

Question 27

class Name {}

Answer 27

The class declaration creates a new class with a given name using prototype-based inheritance. ``` class name { constructor() } ```

Question 28

static

Answer 28

The static keyword defines a static method or property for a class, or a class static initialization block. Neither static methods nor static properties can be called on instances of the class. Instead, they're called on the class itself. ``` class Name { static value; constructor() static function(){} } ```

Question 29

extends

Answer 29

The extends keyword is used in class declarations or class expressions to create a class that is a child of another class.

Question 30

constructor()

Answer 30

The constructor method is a special method of a class for creating and initializing an object instance of that class.

Question 31

super

Answer 31

The super keyword is used to access properties on an object literal or class's [[Prototype]], or invoke a superclass's constructor.

Question 32

try, catch, finally

Answer 32

The try...catch statement is comprised of a try block and either a catch block, a finally block, or both. The code in the try block is executed first, and if it throws an exception, the code in the catch block will be executed. The code in the finally block will always be executed before control flow exits the entire construct.

Question 33

throw

Answer 33

The throw statement throws a user-defined exception. Execution of the current function will stop (the statements after throw won't be executed), and control will be passed to the first catch block in the call stack. If no catch block exists among caller functions, the program will terminate.

Question 34

for await...of

Answer 34

The for await...of statement creates a loop iterating over async iterable objects as well as on sync iterables, including: built-in String, Array, Array-like objects (e.g., arguments or NodeList), TypedArray, Map, Set, and user-defined async/sync iterables. This statement can only be used inside an async function. async function* foo() { yield 1; yield 2; } ``` (async function() { for await (const num of foo()) { console.log(num); break; // closes iterator, triggers return } })(); ```

Question 35

for. .. in | for. .. of

Answer 35

***less performant that .forEach() and standard for() The for...in statement iterates over all enumerable properties of an object that are keyed by strings (ignoring ones keyed by Symbols), including inherited enumerable properties. The for...of statement creates a loop iterating over iterable objects, including: built-in String, Array, array-like objects (e.g., arguments or NodeList), TypedArray, Map, Set, and user-defined iterables. It invokes a custom iteration hook with statements to be executed for the value of each distinct property of the object.