Adv Conc- Modules, Exceptions, Garbage Collection, Side effects/Pure Functions Flashcards
What are the benefits of using modules? (3 things)
If a program is contained entirely in one file, even just 100 lines of code can take time to understand fully. Splitting the program up is easier to understand each component.
Working on a program as a team is easier with multiple files.
You have to put in more work to encapsulate and make private data properly.
Import a module managed by npm
const readline = require(‘readline-sync’);
let choice = readline.question(“Do you want to run this program? (y/n)”);
CommonJS modules are compatile with browsers
t or f
Browsers don’t natively support CommonJS modules, but you can use a transpiler like Babel to transpile code that uses CommonJS modules into a format that can be used by browsers.
Export and import a module
module.exports = anObject
let pear = require(“./CodeTester1”);
// it needs the path
hat happens if you have multiple exports?
let apple = {
a: 1,
}
let orange = {
a: 2,
}
module.exports = apple;
module.exports = orange;
let pear = require(“./CodeTester1”);
console.log(pear.a);
The last module.export to get processed is processed
export a module (for use in a compatible browser) (2 ways)
export let variable = primitive or object
or
export {variable}
import a module (for use in a compatible browser)
import { variableNameFromOtherFile } from “./filePathAndName.ext”
import multiple modules in one line (for use in a compatible browser)
import { variableName1, variableName2 } from “./filePathAndName.ext”
Import a module and change the variable name (for use in a compatible browser)
import { variableName1 as newVar1, variableName2 } from “./filePathAndName.ext”
Import all modules (for use in a compatible browser) and access them
File1.js
export function foo() {
console.log(1);
}
File2.js
import * as FooModule from “./File1”;
FooModule.foo(); // 1
What is this called?
File1.js
export function foo() {
console.log(1);
}
File2.js
import * as FooModule from “./File1”;
FooModule.foo(); // 1
Namespace import.
While using Namespace imports is possible, it is more common and preferred to use Named imports for importing specific declarations.
How many default exports are allowed per file
1
Do default export and import (for use in a compatible browser
bar.js
function bar() {
console.log(2);
}
export default bar;
otherfile.js
import bar from “./bar”;
bar(); // 2
Do default export and import and changed the name (for use in a compatible browser
bar.js
function bar() {
console.log(2);
}
export default bar;
otherfile.js
import renamedBar from “./bar”;
renamedBar(); // 2
Do default export and import and changed the name
Also import a non default module
(for use in a compatible browser)
utils.js
export function foo() {
console.log(1);
}
function bar() {
console.log(2);
}
export default bar;
otherfile.js
import renamedBar, { foo } from “./utils.js”;
foo(); // 1
renamedBar(); // 2
import and export are usually only compatible in browser.
Do it in node and make it compatible (2 ways)
change the file names to .mjs
Alternatively, a more preferred method is to add “type”: “module” to the package.json file. This enables ES6 modules and the files can retain the .js extension.
//package.json
{
“name”: “index”,
“version”: “1.0.0”,
“description”: “”,
“main”: “index.js”,
“type”: “module”,
“scripts”: {
“test”: “echo "Error: no test specified" && exit 1”
},
“keywords”: [],
“author”: “”,
“license”: “ISC”
}
Create a custom error
throw new Error(“Divide by zero!”);
Catch and error and do a block
try {
} catch(errorObject) {
}
With a try catch statement, have it only do something if the error is of a certain kind
function divideOneBy(divisor) {
try {
let result = div(1, divisor);
console.log(result);
} catch (error) {
if (error instanceof DivideByZeroError) {
console.log(${error.message} ignored);
}
}
}
divideOneBy(1); // 1
divideOneBy(0); // Divide by zero! ignored
With a try catch statement, have it only do something if the error is of a certain kind
If it’s another kind, let that error throw
function divideOneBy(divisor) {
try {
let result = div(1, divisor);
console.log(result);
} catch (error) {
if (error instanceof DivideByZeroError) {
console.log(${error.message} ignored);
} else {
throw error;
}
}
}
divideOneBy(1); // 1
divideOneBy(0); // Divide by zero! ignored
What Happens When A Program Throws An Exception (3 things)
- js goes back to look for a try block to see if it contains the code. Looks back at all the blocks, if none are try blocks, throws the error
- if it finds a try block, it exits the try block (without executing anymore code) and executes the catch block
- If the catch block re-throws the exception, it again resumes as before, looking for another try block.
What happens with this:
try {
console.log(1);
a = b;
console.log(2);
} catch(error) {
console.log(3);
}
1
3
YOu should use exceptions for flow control
“if this throws an error, then do this other code”
t or f
F
What’s the idea of “ask forgiveness” in error throwing
– Computer programming pioneer Admiral Grace Hopper
Exceptions are sometimes likened to the “ask forgiveness” approach to error handling. Rather than asking whether we can do something, we just go ahead and try it. If an exception does occur, then we have to ask forgiveness – handle the exception or just accept the cost of an error.
In contrast to the “ask forgiveness” approach, the “get permission” approach involves determining beforehand whether something is going to work. For instance, if we expect a user to input a number, we can test whether they really did enter a number before we try to use it as a number. This is often harder to do than allowing an exception to be raised, but once permission is granted, we know things will work.
In general, an exception handler in a catch block should do as little as possible. But you can… (5 things)
Ignore the exception.
Return an error value (e.g., undefined, null) to the calling function.
Set a flag that the program can test after the handler finishes running.
Log a simple error message
Throw another exception with an explicit throw statement. (but you can explicitly set another exception. Just don’t do anything like try to read a file that might now be there)
What makes a function have side effects? (5 things)
It reassigns any non-local variable.
It mutates the value of any object referenced by a non-local variable.
It reads from or writes to any data entity (files, network connections, etc.) that is non-local to your program.
It raises an exception.
It calls another function that has any side effects that are not confined to the current function. For instance, if you call a function that mutates an argument, but that argument is local to the calling function, then it isn’t a side effect. (See the example with sort later in this assignment.)
we will often talk about side effects as a general characteristic of some functions. If the function can have side effects when used as intended, then we say the function itself has side effects. In practice, functions that have side effects have them regardless of what arguments are passed in.
What makes a function not used as intended? (3 things)
If a required argument is omitted, the function isn’t being used as intended.
If you pass an array to a function that expects a number, the function isn’t being used as intended.
If you call a function before you’ve done any required preparations (such as opening a connection to a remote server), the function isn’t being used as intended.
Does this have side effects?
function sortCopy(arrayOfNumbers) {
arrayOfNumbers = arrayOfNumbers.slice(); // creates a copy of an array
arrayOfNumbers.sort((a, b) => a - b);
return arrayOfNumbers;
}
no
// sort has local side effects
do either of these have side effects?
[1, 2, 3].map(number => 2 * number);
[1, 2, 3].map(number => {
console.log(number);
return 2 * number;
});
[1, 2, 3].map(number => 2 * number);
[1, 2, 3].map(number => {
console.log(number);
return 2 * number;
});
Does this have side effects?
function divideBy(numerator, denominator) {
try {
if (denominator === 0) {
throw new Error(“Divide by zero!”); // side effect: raises an exception
}
} catch (error) {
return undefined;
}
return numerator / denominator;
}
No, the error was handled
Does this have side effects?
function divideBy(numerator, denominator) {
try {
if (denominator === 0) {
throw new Error(“Divide by zero!”); // side effect: raises an exception
}
} catch (error) {
console.log(error.message);
return undefined;
}
return numerator / denominator;
}
yes, the catch block has a side effect
Does Math.random have side effects?
Math.random() has a side effect (it changes the state of the random number generator).
What makes a pure function? (2 things)
Have no side effects.
Given the same set of arguments, the function always returns the same value during the function’s lifetime. This rule implies that the return value of a pure function depends solely on its arguments.
The consistent return value is possibly the most important feature of pure functions. The fact that the return value is dependent solely on the arguments implies that nothing else in the program can influence the function during the function’s lifetime.
What s a functions lifetime?
A function’s lifetime begins when the function is created. It ends when the function is destroyed.
Whats the benefit of pure functions?
A big benefit of pure functions is that the consistent return value and lack of side effects make them easy to test. Since they are effectively isolated from the rest of the program, you don’t have to worry about what happens elsewhere. Nothing outside of the function can have any effect on it. Nothing in the function can have any impact on the rest of the program. This is very convenient and helpful when testing.
Update one object’s properties with the properties of another.
Exampel:
let obj1 = {
a: 1,
b: 2,
c: 3,
}
let obj2 = {
b: 1312,
}
we want b of obj1 to be 1312
Object.assign(obj1, obj2)
Remove an object property
delete obj1.property
Syntax for:
exporting/ importing in browser for regular variable,
at declaration,
or default,
default at declaration
multiple imports/exports and change name
multiple imports/exports and default and change name
export {apple}
import {apple} from ‘’
export let apple
import {apple} import {apple}
export default apple
import apple (or change name)
export default apple =
import apple (or change name)
export {apple, orange}
import {apple, orange}
export {pear, apple}
import {apple as orange, pear as fruit} from ‘./jstest2.js’;
let apple = 123;
let purple = ‘a’;
export default pear;
export {apple};
import purple, {apple} from “./jstest2.js”; (the default has to go first)
