JavaScript Flashcards
1
Q
What are JavaScript’s primitive data types?
A
Boolean, BigInt, Null, Number, String, Symbol, Undefined
2
Q
What does the Number data type include?
A
All real numbers (positive and negative integers and floating point numbers, +/-Infinity)
3
Q
What is a string?
A
Strings are a list of characters in a specific sequence surrounded by single or double quotes.
4
Q
What is a Boolean?
A
Primitive data type which has the values of true or false.
5
Q
What does a value of null represent?
A
Represents the intentional absence of a value.
6
Q
The value of undefined represents…?
A
Represents the absence of a value and is used to convey the value does not exist.
7
Q
What is an Object?
A
Collection of related data as key : value pairs.
8
Q
Which values evaluate as falsy?
A
0, -0, 0n (BigInt zero) empty strings, null, undefined, NaN, false
9
Q
What is an object property?
A
A property is a member of an object that associates a key with a value.
10
Q
What is a method?
A
A method is a function which is associated with an object’s property.
11
Q
What do comparison operators return?
A
A Boolean value of true/false
<, >, <=, >=, ==, ===, !=, !==
12
Q
Three ways to define a function in JavaScript:
A
Function declaration.
Function expression.
Arrow function (also known as arrow function expressions)
13
Q
Key difference between a function declaration and function expression?
A
Function expressions are not hoisted and cannot be called before they appear in a program.
14
Q
What is an anonymous function?
A
A function with no name property.
15
Q
When would you use a do/while statement?
A
When you want the code block to execute at least 1 time.
16
Q
Functions that always return a true or false value are referred to as…
A
Predicates
17
Q
What is function composition?
A
Passing a function call as an argument to another function.
18
Q
[].includes()
A
An array prototype method that determines if a value passed as an argument is an element of the calling array and returns true or false as appropriate.
19
Q
[].slice()
A
An array prototype method which returns a portion of an array into a new array object selected from index start up to but not including index end. If no index end argument is given, the method will automatically slice to the final element of the array.
20
Q
.splice()
A
Changes the contents of an array by removing or replacing existing elements and/or adding new elements. Returns an array of the deleted elements. Argument format is:
splice(startIndex, deleteCount, item1, item2, itemN)
21
Q
.push()
A
Adds one or more elements to the end of an array and returns the new length of the array.
22
Q
.pop()
A
Removes the last element from the array and returns the removed element.
23
Q
.join()
A
Creates and returns a new string by concatenating all of the elements in the array. If no separator argument is passed the elements will be comma separated with no spaces between elements.
24
Q
[].concat()
A
Merges two or more arrays and returns a new array.
```[1, 2].concat([3])
~~~
\\ returns a new array [1, 2, 3]
25
```.shift()```
Removes and returns the first element from an array
26
```.unshift()```
Adds one or more elements to the beginning of an array and returns the new length of the array.
27
```.reverse()```
Reverses the order of elements in an array and returns a reference to the same array. This method is destructive and mutates the original array.
28
```.flat()```
Array prototype method that returns a new array with the sub-array elements concatenated into the new array, to the specified depth.
29
```.sort()```
Sorts the elements of an array in place and returns the reference to the same array, now sorted. The default sort behavior is to sort the array in ascending order, converting the array elements into strings, then comparing them.
30
```.reduce()```
What is it used for?
What is the structure of implementing the following Array method?
This array method is used to effectively reduce the contents of an array to a single value.
The reduce method takes two arguments:
1) a callback function with two parameters, the first parameter represents the accumulator value and the second parameter represents the current value of the iteration. The return value of the callback function is used as the accumulator in the next invocation of the callback.
2) initial value for the accumulator.
```[].reduce((accumulator, element) => accumulator + element, \*initial value for accumulator variable*\)```
31
```Array.isArray()```
Determines whether a passed value is an array and returns a Boolean value as appropriate.
32
```Array.from()```
Creates and returns a new array from an iterable. Can be passed a function expression that performs an action on each element of the iterable as a second argument to get behavior similar to .map()
```Array.from('fox')
```\\\ returns ['f', 'o', 'x']
```console.log(Array.from([1, 2, 3], x => x + x));
```// Expected output: Array [2, 4, 6]
33
```Object.keys()```
Returns an array of an object’s own enumerable property names
34
```{}.hasOwnProperty(’propertyString’)```
Determines whether an object has the specified property as its own property (as opposed to inheriting it) and returns an appropriate Boolean value.
35
How can you iterate through all of an object's properties?
Use a for/in loop
```for (let prop in obj) {
// iterates through all object properties even those of an object's prototype
}```
36
```Object.values()```
Returns an array of an object’s own property values
```Object.values({a : 1, b : 2}); // [1, 2]```
37
```Object.create()```
Returns a new object that will inherit from an existing Object which is passed as the method argument.
38
```Object.assign()```
Copies all of a source object’s own properties into a target object and returns the modified target object.
```const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };```
```const returnedTarget = Object.assign(target, source);```
```console.log(target);
// Expected output: Object { a: 1, b: 4, c: 5 }```
```console.log(returnedTarget === target);
// Expected output: true```
39
```Object.freeze()```
Prevents an object from being changed and returns the same object that was passed as an argument.
40
```Object.is()```
returns a Boolean value indicating whether two arguments are the same value.
41
What do logical operators return?
logical operators return the last evaluated value.
```|| &&```
42
```.endsWith()```
String prototype method which determines if the calling string ends with the characters in the specified string argument and returns an appropriate Boolean value.
43
```.charAt()```
What if no passed argument? What if argument is out of bounds?
String prototype method that returns a new string with the character located at the index passed as an argument. If no passed argument, default of index 0 is used. If argument is out of bounds, returns an empty string.
44
```.substring()```
String prototype method that returns part of the calling string from the start index up to but not including the end index, or to the end of the string if no end index supplied.
45
```.split()```
String prototype method which splits a string at a specified pattern and returns an array of substrings.
46
```''.includes()```
How many arguments?
String prototype method which determines if a provided substring can be found in the calling string and returns an appropriate Boolean value. Takes an optional second argument that specifies which index in the string to start looking for the substring.
47
```.match()```
Retrieves the result of matching a string against a regular expression and returns and array whose contents depend on the presence or absence of the global flag.
```const paragraph = 'The quick brown fox jumps over the lazy dog. It barked.';```
```const regex = /[A-Z]/g; //regex object```
```const found = paragraph.match(regex);```
```console.log(found);```
```// Expected output: Array ["T", "I"]```
48
```''.indexOf()```
String prototype method that returns the index of the first occurrence of the provided substring.
49
```.replace()```
String prototype method that returns a new string with one, some, or all matches of an argument replaced by the replacement argument. The behavior of this method is flexible depending on the arguments passed. For instance you can pass a Regexp object for the matching pattern and a string as a replacement argument or even a function which is invoked for every match and its return value used as the replacement text.
50
```.padStart()```
String prototype method returns a new string that is padded with another string as many times is needed to reach the desired length. The first argument is the length of string desired and the second argument is the string that will be used to pad the string to the desired length.
51
```Math.random()```
Generates a random number >= 0 and less than 1
52
```Math.floor()```
Returns a rounded down integer.
53
```parseInt()```
Parses a string and returns an integer
54
```parseFloat()```
Parses a string and returns a floating point number.
55
```.toFixed()```
Formats a number to the desired number of digits after the decimal point and returns a string representing the number. If no digit argument provided, method has a default value of zero digits.
56
What does it mean for a variable name to be idiomatic?
Variable names that are idiomatic are accurate, descriptive, understandable to the reader. Their name conveys an accurate meaning to the reader.
57
What would make a variable name illegal?
1) Cannot start with a digit
2) Cannot contain whitespace
3) Cannot contain any special characters
4) Cannot be identical to JavaScript's reserved keywords
58
What are the three primary variable naming conventions?
1) camelCase - used for variable and function names
2) PascalCase - reserved for naming Constructor functions
3) SCREEMING_SNAKE_CASE - used for naming constants that represent unchanging configuration values in the program.
59
When do implicit type coercions occur?
When a non-strict operation of two of more values with differing data types occurs.
60
What happens when number values are compared with string values using the ```==``` (loose equality) operator?
Anytime a number and string are compared with ```==``` the string is coerced to a number.
61
What happens when a Boolean value is compared to any other data type which performs a 'loose' comparison?
Boolean values are always coerced to numbers!
62
Anytime an object is compared to a primitive value the object is coerced to a ... and then compared. How does the coercion behavior for empty array **[]** objects and empty objects **{}** differ?
Primitive. Empty array's are coerced to the primitive value of zero whereas empty objects are coerced to a string value of '[object Object]'
63
Anytime one of the operands of the binary **+** operator is a string…
The other operand will be coerced to a string and the values will be concatenated.
64
Any combination of these data types used with the binary **+** operator will result in what behavior? (List the data types!)
Any combination of Booleans, Null, Number, Undefined will result in the values being coerced to numbers and added together.
65
What happens if one of the operands of the binary ***+*** operator is an object?
Both operands are coerced to strings and concatenated.
66
When using relational operators, when will JavaScript compare values lexicographically?
When both values are strings. Otherwise, JavaScript converts both operands to numbers before comparing them.
67
You should not use the _____ or ____ explicit type coercions in template literals.
String() or .toString()
68
What does a for/of loop do? What is the structure?
A for/of loop iterates over the elements of an array.
```for (let value of array) { }```
69
What are variables? What do they store?
Variables are names for a specific area in memory. This memory location will either contain a primitive value or a pointer to something that cannot be easily stored in the default space allotted for each variable.
70
What are valid variables in JavaScript?
Variables declared with `let` or `var`.
Constants declared with `const`.
Function names and parameters.
Class names.
Properties of the global object.
71
What does the term 'identifier' refer to? What are appropriate to refer to as identifiers?
The term identifier is a broad term used to refer to variables, but also includes object property names.
72
A variable's scope determines...
Where the program can access that variable by name.
73
What are some advantages to using a for loop?
Two main advantages.
1) Looping logic is all within the `for ()`statement and therefore easy to see at a glance.
2) For loops typically declare a variable for the looping logic, which is **scoped to the for statement**. An increment variable in a while loop is **scoped outside the while statement**. Using locally scoped variables can help to make code cleaner and better organized.
74
What is `break`?
A JavaScript keyword that terminates the execution of the nearest loop.
75
What is `continue`?
A JavaScript keyword that forces the JavaScript engine to skip to the next iteration of the loop.
76
What is `console.log()`?
A method for writing information/data to the console.
77
What is `readline-sync`? What is the `.question` method?
`readline-sync` is a simplified version of the `readline` node library that allows JavaScript programs to read input from the command line. The `.question` method allows for text to be displayed in the command line and for the user to provide input that the program can consume.
78
What is `require`?
A node function used to import modules, JSON, and local files.
79
What data type are functions? What are the implications of this?
Functions aren’t just code, they are objects! As such they can be passed to other functions, returned from functions, and assigned to variables and properties.
80
What is the difference between `say;` and `say();` ?
`say;` is a variable whose value is a reference to a function object. `say();` is a function invocation which causes the JavaScript engine to temporarily 'jump' into the say function body and execute its code.
81
When can you omit a return statement but still return a value?
This is possible within an arrow function if the body of the function contains only one expression that is not surrounded by curly braces.
82
Function definition
is the entirety of a function. In the case of a function declaration the definition includes everything from the `function` keyword to the closing curly brace.
83
Function invocation
A noun which describes the code written to invoke a function. Ex `say()` is a function invocation that enables the program to invoke the say function object when executed.
84
What is an argument?
Primitive values or objects which are passed to a function.
85
What is a parameter?
Declarations for the local variables used within a function to access its arguments.
86
What are the two kinds of scope in JavaScript?
Global and Local scope
87
Where are global variables accessible in a program?
Anywhere.
88
What are the two forms of local scope?
block scope and function scope.
89
Functions and blocks represent a sort of ... scope. Whereas the global scope represents an ... scope.
inner, outer
90
Five function scope rules
1. Variables declared in the outer scope are accessible in the inner scope.
2. Variable declared in the inner scope are not accessible in the outer scope.
3. Peer scopes do not conflict
4. Inner scoped variables shadow outer scoped variables.
5. Nested functions have their own scope.
91
What is a block?
A related set of statements and expressions between a pair of opening and closing curly braces.
92
How do you return values from a function?
With the `return` statement.
93
What is output? Provide an example.
Output is how your computer or application presents the results to something other than itself. A common example of output is using `console.log()` to to display data to the console.
94
What are return values?
Return values are results from functions or methods that are being presented to and used within the program.
95
What does pass-by-value mean?
When a variable assigned to a primitive value is passed as an argument to a function, the function cannot reassign that variable.
96
What does pass-by-reference mean?
When a variable that is assigned to an Object is passed as an argument to a function, the function can mutate the original object.
97
What is a destructive function or method? Bonus: Is reassignment destructive?
Functions or methods that mutate their arguments. Bonus: reassignment is not destructive!
98
Are return values from functions pass-by-value or pass-by-reference?
The same rules apply to function return values as do function arguments.
99
Does variable assignment pass-by-value or pass by reference?
Trick question! The terms pass-by-value and pass-by-reference are only used to describe how values are passed to and returned from functions.
100
What is the purpose of the call stack?
The call stack allows JavaScript to keep track of which function is executing and where execution should resume when the function returns.
101
In relationship to the call stack, what is the main function? What other names does it go by?
The main function represents the global portion of the program and is also referred to as the stack frame.
102
What happens to the call stack when a function returns?
When a function returns it is then 'popped' off the call stack and the program uses the next stack frame to determine where execution will resume from.
103
What is an expression?
An expression is anything that JavaScript can evaluate to a value.
104
What is a statement?
Code that demands a task.
105
What is exception handling?
A process of managing errors in a predictable and reliable way.
106
When are error objects created?
When the JavaScript interpreter cannot continue executing a program.
107
When will JavaScript raise a `ReferenceError`?
Represents an error when a variable that doesn't exist (or hasn't yet been initialized) in the current scope is referenced.
108
When will JavaScript raise a `TypeError`?
Represents an error when an operation could not be performed, typically (but not exclusively) when a value is not of the expected type.
109
When will JavaScript raise a `SyntaxError`? What is unique about these errors?
Represents an error when trying to interpret syntactically invalid code. `SyntaxError` is unique in that they typically occur at compilation time, not runtime.
110
When will a `catch` block run? What happens after?
A `catch` block will run when, within a `try/catch` statement, the program raises an error (throws an exception). After the `catch` block runs, the program will resume running with the code that follows the entire `try/catch` statement.
111
What is a guard clause? When should they be implemented?
A guard clause is code that guarantees data meets certain preconditions before it gets used. Guard clauses are best used when a function can't trust that its arguments are valid.
112
Some basic steps for detecting edge cases are...
Examine the assumptions inherent in your code. Can your program violate your assumptions? What happens when they are? These examples are your edge cases.
113
`Math.pow()`
Returns the value of a base raised to a power.
114
How can you get a random number between a specified minimum and maximum value?
`(Math.random() * (maxVal - minVal)) + minVal`
The resulting number can equal minVal but not maxVal (will always be bound to one less than the maxVal value).
115
Variable scoping rules...
Describes how and where a language finds previously declared variables.
116
Can you create variables without using a JavaScript declaration keyword? What happens if you do this?
Yes, but if done in code assume it's an accident. Undeclared variables have global scope.
117
What is short-circuit evaluation?
A mechanism which terminates the evaluation of an expression as soon as the minimum requirements for evaluating that expression has been met.
118
What are JavaScript's reference types?
Arrays, Objects, and Functions are all reference types (they are all objects)
119
Are return values from functions pass-by-value or pass-by-reference?
The same rules apply to function return values as to function arguments. If the return value is a reference type it will be pass-by-reference, if the return value is a primitive it will be pass-by-value.
120
Function side effects
Accesses a non-local variable and either reassigns it or mutates an Object referenced by the non-local variable.
Reads to or writes from an outside resource like the console, a database, files, or the browser.
Function throws an exception or calls a function which throws an exception.
121
```''.slice()```
String prototype method which returns a substring from the calling String. Takes two arguments, the first argument is the start index and the second argument is the end index, not inclusive.
122
What happens if you omit the second argument when using the string method ```'string'.slice(2)```? What if no arguments are passed?
The method will return a substring with all characters from the start index to the end of the string. If no arguments are passed a copy of the calling string is returned.
123
The String methods ```String.prototype.slice()``` and ```String.prototype.substring()``` are very similar. How do they differ? Which one should you use?
They differ in two ways:
1) When the start index is greater than the end index, `substring` will swap the arguments while `slice` will return an empty string.
2) When either argument is negative, `substring` treats them as `0` and returns a copy of the calling string, while, `slice` works from the end of the string.
124
What is an array?
Arrays are lists of elements that are ordered by index, where each element can be any value.
125
What happens here? Why?
```let obj = { fruit: 'apple', vegetable: 'carrot', fruit: 'pear' }```
`obj` is initialized to the Object `{ fruit: 'pear', vegetable: 'carrot' }` Because object keys/properties must be unique, the first value associated with the `fruit` property is overwritten by the second `fruit` property value `'pear'`.
126
What happens if you attempt to access an out of bounds index on a String or Array with bracket notation?
Attempting to access either negative or positive out of bounds indices will return `undefined`.
127
What happens if you use an invalid key when attempting to access a property of an object?
It will return `undefined`.
128
What are the primary keys of an Array? What else is a valid key of an Array?
The Array's index values. If the Array non-element properties, those properties are valid keys.
129
Are 'empty slots' in an Array included in the Array's length property? What about non-element properties to the array?
Empty slots are included in the length property, however non-element properties are not! Non-element properties are key/value pairs that do not use integer indexes.
130
What will the following code snippets return?
```'this is a string'.split();```
```'abcdef'.split('');```
```'apple,orange,mango'.split(',');```
1) ['this is a string']
2) ['a','b','c','d','e','f']
3) ['apple', 'orange', 'mango']
131
How can you convert an Object to an Array?
```Object.entries(object)``` will return an Array with the key/value pairs of the passed Object as nested arrays.
132
What is logged to the console? What is the takeaway from the following code?
```let string = 'bob';
string[0] = 'B';
console.log(string);```
string element reassignment, even though it's syntactically permitted, doesn't affect the string.
133
`String.prototype.trim()`
Returns a new string with whitespace removed from the beginning and end of the calling string.
134
`String.prototype.trimStart()`
Returns a new string with whitespace removed from the beginning of the calling string.
135
`String.prototype.trimEnd()`
Returns a new string with whitespace removed from the end of the calling string.
136
What does `''.charAt()` return when passed an out of bounds index?
`''` an empty string.
137
```String.prototype.charCodeAt()```
Bonus: what if you don't pass an argument?
Returns the unicode code point or character code of the character at the index passed as an argument.
Bonus: the method returns the character code at index 0.
138
What is a Unicode code point?
The number that represents a given character at the machine level.
139
```String.fromCharCode()```
returns the character represented by the character code value.
140
```String.prototype.repeat()```
returns a new string which contains the specified number of copies of the string on which it was called, concatenated together
141
What is the following an example of?
``` let keyValue = [ 'key', 'value']```
``` let [ key, value ] = keyValue```
How many variables are in this snipppet? what are their values?
This is an example of ***array destructuring assignment***. Array destructuring assignment allows us to assign elements of the array to multiple variables by wrapping the variable names in brackets. There are 3 variables.
```key // 'key'```
```value // 'value'```
142
```.forEach()```
`forEach` is an iterative array method that executes a provided callback function once for every element in the calling array and always returns `undefined`. `forEach` will always invoke the callback function for every element in the calling array unless an error is thrown. The callback function takes up to three arguments: `element`, `index`, `array`. It’s typically used to execute side effects at the end of a method chain.
143
```.filter()```
`filter` is an iterative array method that executes a provided callback function once for every element in the calling array and returns a new array containing the values for which the callback function returns a truthy value. The callback function can take up to three arguments: `element`, `index`, `array`.
144
```.map()```
`map` is an iterative array method that returns a new array populated with the return values of the provided callback function and contains the same number of elements as the calling array. The callback function takes up to three arguments: `element`, `index`, `array`.
145
```.fill()```
Array prototype method that mutates its caller by replacing elements in an array. The first argument is the replacement value, second argument is the start index, third argument is the up to but not including end index.
146
```.some()```
Array prototype method that executes a callback function for every element in an array. If at least one return value from the callback is truthy, return boolean true. Otherwise return false.
147
```.every()```
Array prototype method that executes a callback function for every element in an array. If every callback return value is truthy, return true. Otherwise return false.
148
```.find()```
Return the first element from the calling array that returns truthy for the provided callback function. Returns `undefined` if no elements return truthy.
149
```.findIndex()```
Returns the index of the 1st element that returns truthy from the provided callback function. Returns -1 if no truthy value returned from callback.
150
How can you easily determine if the value `NaN` is in an array?
Use the .includes() array method.
151
Fun fact: Most built-in array methods _________ non-element properties and ______.
ignore, empty slots
152
Useful lexicographic ordering rules:
- All uppercase letters come before lowercase letters
- Digits (0-9) and most punctuation come before letters
- Several punctuation characters between the uppercase and lowercase letters.
153
`.sort()` can take an optional callback function with two parameters `a, b`, which represent elements from the calling array being compared. The return values of the callback dictate how the elements are sorted. What are these rules?
Bonus: Expression for ordering in ascending order? Descending order?
return value > 0 `b` before `a`
return value < 0 `a` before `b`
return value === 0 no change
154
Modern way for creating a shallow copy of an array?
Spread syntax.
155
What is a shallow copy?
A shallow copy contains a ***shared reference*** to the original variable. Changes on shallow copies are reflected on origin object.
156
How can you create a deep copy? What's the catch?
Deep copies can be created by serializing an object to text using `let serializedObj = JSON.stringify(obj)` and then using `JSON.parse(serializedObj)` to create a new object. The catch is this method will only work on simple objects and nested arrays.
157
If you attempt to _______ a frozen object it will fail _____. If you attempt to use a ______ method on a frozen object it will _______.
reassign, fail silently
mutating, throw a TypeError
158
Determine if an object has been frozen...
`Object.isFrozen(obj)`
159
```Object.fromEntries()```
Object static method which transforms an array of nested array key/value pairs into an object. The input array should be formatted the same as the ```Object.entries()```return value.
160
What does it mean that arrays in JavaScript are sparse?
The number of elements in an array isn't necessarily the same as its length: there can be gaps in the array (empty slots).
161
What is a higher-order function?
A function which accepts functions as parameters and/or returns a function.
162
Why would a `for/in` loop and `Object.keys()` produce different results for iterating over Object properties?
A `for/in` loop iterates over an object's prototype properties as well as the object's own properties. The `Object.keys()` static method returns an array of an objects own properties.
163
How are sparse arrays created?
1) Increase the size of the length property of the array without adding any values to it.
164
How does `Array.prototype.sort()` handle `undefined` values in an array?
They are always placed at the end of the array no matter what the other values are.
