Objects, Functions, Classes - 25%

Question 1

Create an obj

Answer 1

Object literal:
const obj = { a: “b” };

Object constructor:
const obj = new Object( )

Question 2

delete operator

Answer 2

Use to delete a key/value pair from an obj:
delete myObj.key;

Question 3

keys w/space

Answer 3

use quotation
ex: { “my key”: 2 }

Question 4

existence of a property in an obj

Answer 4

Can use “in” operator to test for existence of a property:
“nonExist” in myObj // false

Reading a non-existent property returns undefined (not null):
myObj.nonExist === undefined

Question 5

Obj Iteration

Answer 5

for (key in object) { }

Question 6

Object property order

Answer 6

Properties that have keys that can be converted to Integers are sorted, the rest are in creation order

Question 7

Object Inheritance

Answer 7

All objects inherit from at least 1 other obj
The object being inherited from is called the prototype,
and the inherited properties can be found in the prototype object of the constructor
You can add a property to all objects created through a certain constructor using the prototype property:
Car.prototype.color = ‘red’;

Question 8

“this” for obj

Answer 8

Can use w/in a method to refer to the current object.
In a Class, cannot access “this” from w/in a nested fn, unless using arrow fn nested once (skips closest encompassing layer)

Question 9

getters and setters

Answer 9

Within object initializers, they are prefixed with the keywords get or set.
When the getter is called, a fn is run and a value is returned.
When a setter is called, a parameter is accepted and a fn runs

const myObj = {
a: 7,
get b() {
return this.a + 1;
},
set c(x) {
this.a = x / 2;
},
};
console.log(myObj.a); // 7
console.log(myObj.b); // 8
myObj.c = 50; // Calls the set c(x) method
console.log(myObj.a); // 25

Question 10

Comparing objs

Answer 10

Can’t be done with equality operator - 2 objs aren’t equal even if same keys/values.
For simple objs, can use JSON.stringify for comparison, but if key/vals aren’t in same order, it won’t work.

Question 11

JS Class

Answer 11

A type of fn used to create mult objs w/the same properties and methods.
Also used to implement OOP concepts in JS, such as inheritance, encapsulation, and polymorphism.

It was introduced in (ES6) as a new syntax over the existing prototype-based inheritance.
They provide a more intuitive and clear syntax to create objects and deal with inheritance.

Question 12

constructor

Answer 12

Creates a new object,
Binds ‘this’ to the new object,
Runs the code in the constructor,
Returns the new object.
Ex:
class Person {
constructor(name) {
this.name = name;
}
}
const gal = new Person(“Court”);
^ this calls the constructor fn

declaring it is optional, all will have a constructor fn built in.

Question 13

Class Inheritance

Answer 13

Use “extends” keyword to declare a subclass, and inherit the properties and methods of the parent class.
Uses super( ) in the constructor method to pass the parent properties up, then can add its unique initialization.

Question 14

Encapsulation

Answer 14

If a property or fn is declared using #, it is private and can only be reached from inside that Class.

Question 15

Modules

Answer 15

Ways of splitting JS programs into separate units that can be imported when needed. Node.js has this ability and some JS libraries / frameworks use them.

Question 16

Module usage

Answer 16

The <script type="module"> attribute is used to denote when a module is being pointed to.

Can export props and fns by adding to end of file:
export { name, fn1, fn2 };
or exporting each individually. Can’t use * w/export.

Use import statement - import { name, fn1, fn2 } from “./modules/square.js”;
The path - starting w/dot means starting at the current location.

Can use “as” in the import to change their reference keyword.

Question 17

Types of Scope

Answer 17

Global scope: The default scope for all code running in script mode.
Module scope: The scope for code running in module mode.
Function scope: The scope created with a function.
Block scope: The scope created with a pair of curly braces (a block) - this is for let and const, not var

Question 18

Execution flow

Answer 18

Top-down.
JS first checks for function and variable declarations and then executes the code. This concept is known as hoisting.

Ex - var
console.log(myVar); // This will output: undefined
var myVar = 5;
console.log(myVar); // This will output: 5

Ex - let (const is the same)
console.log(myLet); // ReferenceError: myLet is not defined
let myLet = 5;
console.log(myLet); // 5

Question 19

continue (in a loop)

Answer 19

The continue statement skips an iteration if a certain condition returns true.

Question 20

decorators

Answer 20

A wrapper fn that wraps an existing fn and extends its behavior Can be used to extend bx of objects without affecting other objects of the same class.
When it is a Class decorator, should receive only 1 arg.

Question 21

closure fn

Answer 21

A fn that has access to the parent scope, even after the parent function has closed. This means that a fn defined in the scope of another fn will continue to have access to variables in its parent fn and global scope, even after the parent fn has finished executing.

Question 22

privileged fn

Answer 22

A public fn that has access to private fns or variables. In other words, it is a method which is accessible in the public scope but has access to private data or methods.

Privileged methods are usually created by declaring them with the ‘this’ keyword inside the constructor.

Question 23

property descriptors

Answer 23

writable - boolean, can use to make readonly.

An obj that allows you to define or modify the attributes of existing properties on an obj. Attributes:

1. Value: The value associated with the property. Can be any valid JavaScript value (number, object, function, etc).
2. Writable: A Boolean indicating whether the value of the property can be changed.
3. Enumerable: A Boolean indicating whether the property can be enumerated.
4. Configurable: A Boolean indicating whether the property can be changed and deleted from the object.
5. Get: A function which serves as a getter for the property, or undefined if there is no getter. The function’s return value will be used as the value of the property.
6. Set: A function which serves as a setter for the property, or undefined if there is no setter. The function will receive as its only argument the new value being assigned to the property.

These descriptors can be accessed using methods like Object.getOwnPropertyDescriptor() and can be defined or modified using methods like Object.defineProperty() and Object.defineProperties().

Question 24

Object.entries

Answer 24

Returns an array containing all of the [key, value] pairs of a given object’s own enumerable string properties.
Object.fromEntries() - reverse of Object.entries:
Returns a new object from an iterable of [key, value] pairs.

Question 25

Object.values

Answer 25

Returns an array containing the values that correspond to all of a given object’s own enumerable string properties.

Question 26

Object.preventExtensions

Answer 26

Prevents obj from being extended.
Object.isExtensible gives boolean.

Question 27

Object.seal

Answer 27

Prevents other code from deleting properties of an object.
Object.isSealed gives boolean

Question 28

Object.freeze

Answer 28

Freezes an object. Other code cannot delete or change its properties.
Object.isFrozen gives boolean.

Question 29

Object.getOwn….

Answer 29

Object.getOwnPropertyDescriptor()
Returns a property descriptor for a named property on an object.

Object.getOwnPropertyDescriptors()
Returns an object containing all own property descriptors for an object.

Object.getOwnPropertyNames()
Returns an array containing the names of all of the given object’s own enumerable and non-enumerable properties.

Object.getOwnPropertySymbols()
Returns an array of all symbol properties found directly upon a given object.

Question 30

Object.assign

Answer 30

Copies the values of all enumerable own properties from one or more source objects to a target object.
ex:
Object.assign(target, obj)
- can have mult objs that will combine into the target obj

Question 31

Object.create

Answer 31

pass in a prototype obj to create a new one
Object.create(protoObj)

Question 32

higher-order fn

Answer 32

A fn that can take one or more fns as args, or can return a fn as its result. This is possible because in JS, fns are first-class citizens, meaning they can be assigned to variables, stored in data structures, passed as arguments to other functions, or returned as values from other functions. Higher-order functions are a key component of functional programming in JavaScript. Examples of higher-order functions include map(), filter(), and reduce().

Question 33

iterator v generator

Answer 33

Iterator:
An obj that provides a next() method which returns the next item in the sequence. This method returns an obj w/2 properties: done and value. The done property is a boolean that is true if the sequence is finished, and false otherwise. The value property is the current item in the sequence.

Generator:
A fn that can stop midway and then continue from where it left off. Generators simplify the task of writing iterators. They produce a sequence of results instead of a single value. Each call to the generator fn returns the next value in the sequence.

Comparison:
- Iterators allow you to customise the iteration logic whereas generators handle the iteration logic for you.
- Iterators require you to implement the next() method whereas generators automatically have a next() method.
- Generators use the yield keyword to yield the sequence of values, iterators do not have such a feature.
- Generators can also use the return statement to specify the final value of the sequence.
- Iterators can be infinite, generators cannot be infinite because they should have an end to the sequence.
- With a generator, you can use a loop to iterate through the values, whereas with an iterator, you have to manually call the next method until done is true.
- Generators can be easier to write and read when the logic to produce the sequence of values is complex.

Question 34

using .prototype to add a fn to a class

Answer 34

Changes to the prototype won’t affect existing instances of the object, only future instances. So if you add a new method to the prototype after creating an instance, that instance won’t have access to the new method.

Question 35

arguments obj of a fn

Answer 35

• an array-like collection of vals
• contains all the vals passed to the fn
• only avail for non-arrow fns
• the argument keyword can be used to access, for ex:
  argument[0] will be 1st arg passed.

Question 36

recursive fn

Answer 36

A fn that calls itself until it reaches a specified condition, known as the base case.
Useful in various scenarios, such as traversing tree-like data structures (like the DOM in web browsers or JSON objects), performing depth-first searches, solving complex mathematical calculations like factorials or Fibonacci sequences, and more. They can make code more readable and easier to understand, but they can also lead to high memory usage and stack overflow errors if not implemented carefully.

Question 37

static methods in a class

Answer 37

Static methods cannot be called through a class instance.

A static method in JS is a method that belongs to a class rather than an instance of the class. This means that you can call the method on the class itself, rather than on an object created from the class.

The main difference between a static method and a regular method (also known as instance method) is that the static method doesn’t know anything about the class state. It can’t modify the object state as it is not bound to any instance of the class.