A function defined as follows:

let myFunc = () => {
console.log("Hello World")
}

A parameter are the variables defined in the function declaration.

function addThree(parameter1, parameter2, parameter3) {
return parameter1 + parameter2 + parameter3
}

An argument passes variables or values to a function in the function call

function addThree(parameter1, parameter2, parameter3) {
return parameter1 + parameter2 + parameter3;
}

let argument1 = 3;
let argument2 = 5;
let argument3 = 9;

addThree(argument1, argument2, argument3);  //returns 17

Returns NaN - because 1 + undefined is not a number.

1. initial expression: for (let i = 0; ... ) {}
2. condition: for (let i = 0; i < array.length; ... ) {}
3. loopEnd expression: for (let i = 0; i < array.length; i++)

Comments are used in code to further define what the code is doing. They are NOT to be executed.

1 and 3. #1 is for multiple lines of comments. The last '*/' will close the comment area. // may also be a comment, but you must use it at the beginning of each comment line.

Yes!

No! This will return a syntax error because it is trying to evaluate "it". '//' must be used before each line on a comment. To comment out multiple lines of code use the pair: '/* */'

Use console.log() to print out variable values.

1. Use string concatenation: console.log("myVar Value: " + myVar)
2. Use interpolation: console.log(`myVar Value: ${myVar}`)
3. Also string concatenation, using "," console.log("myVar Value1: ", myVar, " and adding 1 is: ", myVar + 1)

Yes, but it may not do what you intended. If, for instance, you have two variables a=1 and b=2, and you run the code above it will not add a and b. Instead, it will concatenate the two characters 'a' and 'b' into another string of 'ab'.

Yes, but again, it may not give you what you intended. Here JavaScript sees a letter and a number. It will attempt to convert the number to a letter, then concatenate. The result will be '1b'

A float or an integer. It can be negative, or positive.

The result will be 1020. Because you took a string, used the concatenate operator and added x and y. To get the result of 30, you would use:

let x = 10;
let y = 20;
console.log("The result is: ", x + y)  ... or
console.log(`The result is: ${x + y}`);

REPLS: Read, Evaluate, Print Loops. Invoking node at the command line will provide a REPL.

Numbers

Yes!

Variables cannot begin with Numbers, and "-" is never allowed, nor is "#" ever allowed.

Variables can be any alpha/numeric value, $, or _; and cannot begin with a number

1. let 1Number = 0;
2. let -Number = 0;
3. let #Number = 0;

False

Variables may only begin with underscore (_), dollar sign($), or alphabetic characters

my#Variable: # is neither alphabetic, numeric, nor $ nor _

1Variable: Although numeric, the variable cannot begin with a number

"bootcamp".length ==> 8

'bootcamp'[3] ==> 't'

'bootcamp'[0] = 'b'

Index is a zero based number. Length counts starting at 1.

Overrunning the length of the array or string. 'bootcamp'.length = 8, but 'bootcamp'[8] is undefined

Use the indexOf method: 'bootcamp'.indexOf('t') => 3;

Use the '+' operator: 'Hello' + 'World' = 'HelloWorld'

+, -, *, /, %

• ! = not
• && = and
• || = or

1. multiplication, division : left to right
2. addition, subtraction : left to right

NOT equal to

The expression on the left must be true AND the expression on the right must be true; otherwise the answer is false.

The expression on the left must be true, and if it is not, the expression on the right is evaluated to see if it is true. If neither are true, the expression is evaluated to false. Otherwise the expression is evaluated to true.

Only the expression that is required to determine the outcome is evaluated, starting from left to right. For instance, if true && false, both the left 'true' and the right 'false' must be evaluated. However, if 'false' && 'false' then only the left needs to be evaluated, because only one expression must be false for an '&&' operation to evaluate to false.

In the case of ||, if the left expression is true, the expression evaluates to true. So the right expression is never evaluated. If the left expression evaluates to false, then the right must be evaluated to determine if the statement evaluates to false.

DeMorgan's law refers to the associativity of && and || expressions. Given a grouped expression, how would you break it apart into individual expressions.

• !(A || B) === !A && !B
• !(A && B) === !A || !B

My memory aid is: "NOT of AND is OR, and NOT of OR is AND"

'a' < 'b' = true

"Apple" < "apple" = true

'A' > 'a'

1 > 2 = false

PEMDAS: Parentheses, Exponents, Multiplication and Division (from left to right), Addition and Subtraction (from left to right)

==: Used for comparing two variables, but it ignores the datatype of the variable

===: Used for comparing two variables, but this operator also checks the datatype when comparing.

5 == "5" => true Because == does not compare the datatype.

5 === "5" //false Because === evaluates the datatype as well. The number 5 is not equal to the string '5'.

    while (condition) {
        ... code to be executed here
    }

    for (let i = 0; i < 5; i++) {
        ... do something
    }

An iteration is each pass through the loop, or each time the loop executes.

index>

    function forLoopDoubler (array) {
        let i = 0;
        while (i < array.length) {
            array[i] = array[i] * 2;
            i++;
        }
        return array;
    }

Use the .length method: myArray.length

Arrays are always defined with square brackets: let myArray = ['a', 'b', 'c']

3

Either use indexOf, or because 9 is the last element in the array you can use array.length-1;

myArray.indexOf(9)

myArray[myArray.length - 1]

numbersAndLetters.indexOf(17) ==> 2

Notice that because 17 is a number, it is stored in the array index of 3. It is NOT stored as index of 3 AND 4. Similarly with 'cat', stored at index 3. This element is a string. Arrays can store different data types, and each data type gets its own index.

Arrays are 0-based -- meaning the first element is ALWAYS 0.

Using length as an index. Because arrays are zero based, the last index of the array would be length-1, NOT length! myArray.length

1, 2, 34, 5, 6 : Javascript tries to convert your array into a string. :-(

console.log([1, 2, 3].concat([4, 5, 6])); // => [1, 2, 3, 4, 5, 6]

The number 4 is not included in the array. So the indexOf method would return -1

Use the .concat method: arrayOne.concat(arrayTwo)

myArray.pop() will return the last element of the array. Further, it will remove the last element from the array.

myArray.shift(): This will both remove the first element from the array, and return that element to the caller.

If you want to add the element to the end of the array, use .push(<element>): myArray.push('newElement')

Use the unshift method: myArray.unshift('newFirstElement')

Array.map()

    let myArray = [ 1, 2, 3, 4 ]

    myArray.map( (elt) => {
        return elt * 2
    });

    //returns:  [2, 4, 6, 8 ]
    //does NOT mutate original array.

Array.filter

    let myArray = [ 1, 4, 7, 6, 12, 9]

    myArray.filter( (elt) => {
        if (elt % 2 === 0) return elt;
    });

    //returns [4, 6, 12]

accumulator.

If accumulator does not have an initial value set, then accumulator is set to the first element of the array

    let nums = [3, 7, 5, 9];

    let sum = nums.reduce ( (accum, el) => {
        return accum + el;
    });

    //sum is now 24.

    let sum = nums.reduce ( (accum, el) => return accum + el, 100);

    Array.reduce( fn(), accum);

accum = 3; elt = 7;

This would be the 2nd argument to the reduce function:

    let nums = [3, 7, 5, 9]

    let sum = nums.reduce(function(accum, el) {
        return accum + el;
    }, 100);

    let nums = [3, 7, 5, 9]

    let product = nums.reduce( (accum, elt) => {
        return accum * el;
    });

    // returns

Because you're doubling each number, you'll need to double the first number. This requires that the accumulator doubles the number - but the accumulator will not automatically do this. So you'll need to pass in an initial value for the accumulator so that it doesn't use the first element of the array as the initial value.

    let nums = [3, 7, 5, 9];

    let doubleProduct = nums.reduce( (accum, el) => {
        return accum * 2 * el
    }, 1);

Now on the first pass accumulator will be set to 1, and each element will be doubled before being multiplied -- including the first element. Remember: If there is no initial value given for the accumulator, the initial value will be set to the first value in the array, and the second element in the array will be used in the first iteration of the reducer's function.

The accumulator.

    let nums = [3, 7, 5, 9, 2]

    let max = nums.reduce( (accum, el) => {
        if (el > accum) {
            return el;
        } else {
            return accum
        }});

    let nums = [1, 2, 3]
    let newArray = []

    for (let i = 0, i < nums.length; i++) {
        newArray.push(2 * nums[i]);
    }

or ...

    let nums = [1, 2, 3];

    let newArray = nums.forEach( (elt, index) => {
        return elt[i] * 2
    }

When you write code to avoid throwing exceptions. eg:

    if (value !== undefined) {}
    if (value !== null) {}

The function that is passed into Array#forEach may accept the current element, index, and array

The Array#reduce method accepts a function as it's first argument and a value to be used as the initial accumulator as an optional second argument.

The function that is passed into Array#filter should return boolean.

The function that is passed should accept the current accumulator and current element as its arguments.

The Array#filter method accepts a function as an argument and returns a new array containing elements of the original array that result in `true` when passed into the function.

The Array#map method accepts a function as an argument returns a new array containing the results of calling that function on each element of the original array.

Array#shift

The String#split method accepts a "separator" string as an argument and returns an array containing the resulting substrings when the string is cut along instances of the "separator".

For example:

    let sentence = "follow the yellow brick road";
    let words = sentence.split(" ");
    console.log(words); // [ 'follow', 'the', 'yellow', 'brick', 'road' ]

Array#pop

Both methods accept a start index and end index representing the range of indices to be sliced as a new array or string. The start index is inclusive, while the end index is exclusive.

"Mutability" refers to an object's ability to undergo changed. Mutable objects can be modified, while immutable objects cannot be changed after they are created.

The Array#join method accepts a "separator" string as an argument and returns a string where elements of the array are concatenated together with the "separator" between each element.

For example:

let words = ["run", "around", "the", "block"];
console.log(words.join("_")); // 'run_around_the_block'

Arrays are mutable.

Numbers, strings, and booleans are all immutable. Don't confuse mutability with the variable types: var, let and const. When you define a variable with let, then yes. You can change the value of the variable. Similarly with var. However, when you change the value of the variable the variable is re-created in a different location in memory. This makes the data types shown immutable. Arrays, on the other hand, you can change the contents of the array without changing where the array points in memory. The variable containing the array will never change its memory address.

The Array#unshift method accepts one or more values as arguments and will add those values to the front of the array, mutating the array. The method returns the new length of the array.

let array = ['a', 'b', 'c', 'd' ]
let arrayLength = array.unshift('e', 'd', 'f', 'g')

arrayLength  //=> 8
array  //=> :
            [
            'e', 'd', 'f',
            'g', 'a', 'b',
            'c', 'd'
            ]

The Array#push method accepts one or more values as arguments and adds those values as new elements to the end of the array, mutating the array. The method will return the new length of the array.

let array = [1, 2, 3, 4]
array.push(6, 7, 8, 9, 10)  //=> 9
array      // => :
                [
                1, 2, 3,  4, 6,
                7, 8, 9, 10
                ]

Array#splice has two required arguments: a target index and a number of elements to remove

Array#splice can additionally accept any number of additional arguments representing values to be inserted

array  // => :
            [
            1, 2, 3,  4, 6,
            7, 8, 9, 10
            ]
array.splice(-1)  //=> [ 10 ]  -- removes 10 from the arrray and returns it as an array
array    // =>  array now does not have 10 in it
                [
                1, 2, 3, 4,
                6, 7, 8, 9
                ]
array.splice(4, 1) // returns [ 6 ] from the array, while removing it from the array
[ 6 ]
array  // Array no longer has 6 in it
            [
            1, 2, 3, 4,
            7, 8, 9
            ]
array.splice(0, 1, 'a', 'b', 'c')  //removes 1 from the array and returns [ 1 ], then adds 'a', 'b', 'c', in its place
array  // contents of the array has removed 1, and in its place put 'a', 'b', 'c'
        [
        'a', 'b', 'c', 2, 3,
        4,   7,   8,   9
        ]

['a', 'b', 'f'] : Array#splice mutates the input array, removing 3 elements starting at index 2.

A mutuble object can be changed. An immutable object cannot be changed.

Arrays are mutable. Booleans, Numbers, and Strings are immutable.

['a', 'b', 'c', 'd', 'e'] : Array#slice does not mutate the input array, so arr is unchanged.

A primitive (primitive value, primitive data type) is data that is not an object, and has no methods.

Six: string, number, bigint, boolean, undefined and symbol.

We haven't learned about symbols yet.

Null means "the ABSENCE of data". Any data type can be set to null.

Use the built in "typeof" operator

    console.log(typeof null); // 'object'
    console.log(typeof 'c'); // 'string'
    console.log(typeof 1); // 'number'
    console.log(typeof true); // 'boolean'

    let a;
    console.log(typeof a); //'undefined'

A first-class object is something that can be stored in a variable.

Yes! You can store a function in a variable and pass it to another function

Use a try/catch block

try, catch, finally

Provides a mechanism to evalute statements and throw errors if the statements do not conform.

    try {
        if (array.length === 0) {
            do something ...
        }
    }

You use a catch block to gracefully process the error, rather than allowing your code to break and throw an exception to the user.

    try {
        if (array.length === 0) {
            ... do something
        }
    } catch (e) {
        if (e === instanceOf ReferenceError) {
            console.log("array is not defined");
        } else {
            console.log("error:  ", e)
        }
    }

Function Expression Syntax

throw Error('this error');

throw new Error('this error');

The finally block runs whether or not an error occurs. It always runs.

    function sumArray(array) {
        let sum = 0;

        try {
            for (let i = 0; i < array.length; i += 1) {
                sum += array[i];
            }
        } catch (e) {
            console.log(e);
            return null;
        } finally {
            console.log("This wil aways print.");
        }
        return sum;
    }