function replaceIt(string) { // 3.1 Replaces the word 'this' with the word 'that'.

return string.replace("this", "that"); //

}

function capitalizeIt(string) { // 3.2 Capitalizes all the words in the string.

return string.toUpperCase(); //

}

function printIt(string) { // 3.3 Prints the string to console.

return console.log(string) //

}

function repAndCap(string) { // 2 ... we pass the string to repAndCap and executes

return printIt(capitalizeIt(replaceIt(string))); // in order by first running replaceIt, then capitalizing

} // it by running capitalizeIt, then finally printing it.

console.log(repAndCap("this is a test")) // 1 When repAndRap is called with the argument

// "this is a test"....

*/

// FUNCTION KEYWORD NAME CALL SIGNATURE (W/PARAMETER)

// \ | /

function myFunction(str) {

return str; //- MAIN BLOCK of function

}

console.log(myFunction("Hello!")); //- CALL (W/ARGUMENT)

function interest(principal, rate, years) { // note here that no default parameters are given, only inputs.

return principal * rate / 100 * years;

}

console.log(`default parameter example before default:`);

console.log(interest(10000, 3.5, 5)); //-> 1750

function interest2(principal, rate, years) {

}

console.log(`default parameter example with default variable:`);

console.log(interest2(10000)); //-> 1750

function interest3(principal, rate = 3.5, years = 5) { // note here default parameters are INSIDE the call signature.

return principal * rate / 100 * years;

}

console.log(`default parameter example with default variable in call signature:`);

console.log(interest3(10000)); //-> 1750

function addDeclaration(num1, num2) {

return num1 + num2;

}

console.log(`function declaration example:`)

console.log(addDeclaration(2,2)) //-> 4

*/

// function expression:

let addExpression = function(num1, num2) {

return num1 + num2;

}; // note the semi-colon that terminates the variable.

console.log(`function expression example:`)

console.log(addExpression(3,3)); //-> 6

//function expression called through another variable:

let variableWithAddExpression = addExpression;

console.log(`function expression called via another variable:`);

variableWithAddExpression();

// ES6 Fat Arrow Function:

// -- when you read this, you would say 'goes to...' for fat arrow.

const addFatArrow = (num1, num2) => num1 + num2;

console.log(addFatArrow(4,4)) // 8

*/

function multiplyIt(num1, num2) { // function

return num1 * num2;

}

console.log(`multiply it result`);

console.log(multiplyIt(2, 3)); //=>6 // invocation (note that console.log is just so that the example prints to console)

*/

function addItUp(num1, num2) { // plus is passed two parameters, a and b.

}

console.log(`results of Return as function example below`);

addItUp(2, 3); // now we INVOKE the function and PASS the parameters we want. We have two slots, so two numbers.

//-> 5

// 6

// { '0': 2, '1': 3 }

*/

let info = {

firstName : 'John', // a name/value pair

lastName : 'Smith',

occupation : 'soldier'

}

console.log(`result of normal function test:`)

console.log(info.firstName); //-> John ()

*/

let report = {

status: 'Awesome', // property called status with a value called Awesome. NOTE COMMA!

plus: function(a,b) { // this is an anonymous function assigned to an element. It is called with the 'plus' identifier

}

}

console.log(`results of function in object example:`)

report.plus(2,3); //-> { status: 'Awesome', plus: [Function: plus] }

// 5

// { '0': 2, '1': 3 }

// Awesome

*/

*/

let talk = function() {

console.log(this.loud);

}

let talkOutLoud = {normal: "whisper", loud: "yell"}

talk.call(talkOutLoud); //-> yell

// we invoke the function call...

// use the .call method...

// pass-in the talkOutLoud

// console.log runs this(i.e. talk) dot loud(from talkOutLoud)

// Another way to do the same thing above is like this:

let talk2 = function(what) {

console.log(what);

}

let talkOutLoud2 = {normal: "whisper", loud: "yell"}

talk2.call(talkOutLoud2, talkOutLoud2.normal); //-> whisper

// normal is being passed into the what variable in the function.

// which is then passed into the console.log.

*/ let talk3 = function(what) {

console.log(what);

}

let talkOutLoud3 = {normal: "whisper", loud: "yell"}

talk3.apply(talkOutLoud3, ['roar']); //-> roar

// instead of normal (previous), we pass in an array with 'roar'.

// we change call to apply...

// roar is passed to the what variable and the console.log.

let addSomething = function() {

}

console.log(addSomething(4,4,4)); //-> 12 // because we use `arguments`, we can pass in as many

console.log(addSomething(5,5,5,5,5,5,5,5)); //-> 40 // arguments as we want.

function addSomething2() {

}

console.log(`example with arguments object:`)

console.log(addSomething2(1,2,3,4,5,10)); //-> 25

let addTheThing = function(a,b) {

return a + b; // the job of the return function here is to return the result of a + b.

}

console.log(addTheThing(4,5)) //-> 9

let cat = function() {

console.log('meow')

}

console.log(cat());

let cat2 = function() {

console.log('meow meow')

}();

let addTheCats = function(message) { // Second, the string is passed (via message) to the function.

console.log(message); // Third, the string finally is passed to the console.log statement.

}("Good evening, I am a cat"); // First, a string is passed.

(function(message) {

console.log(message)

})("I am an anonymous function");

let myLibraryDemo = (function() {

let myBook = "Moby Dick";

})(); //->

let myLibrary = (function() {

return { // Here we return an object.

book: function() { // Then, we have an element with the name 'book' and a method (i.e. function).

console.log('Pride and Prejudice')

}

}

})();

myLibrary.book(); //-> Moby Dick // call function with name space (i.e. myLibrary) and method (i.e. book).

/*

let myLibrary2 = (function() {

return {

bookCollection: function() {

console.log(arguments[0].book); // Capture the argument as arguments[0] (i.e. the 0th argument)

}

}

})();

myLibrary2.bookCollection({ book: 'Jane Eyre'}); //-> Jabe Eyre

*/

let myLibrary3 = (function() {

return {

bookCollection: function() {

}

}

})();

myLibrary3.bookCollection(); //-> nothing // because no arguments are given, you will get 'nothing'.

myLibrary3.bookCollection({ book: 'Persuasion'}); //-> Persuasion // because we now have a key value pair.

let myLibrary4 = (function() {

let DEFAULT = {

book: 'Northanger Abbey' // 2. this is good if you need to modify your defaults in one place.

}

return {

bookCollection: function() {

}

}

})();

myLibrary4.bookCollection();

let cars = (function() {

let DEFAULT = {

car: 'Ferrari',

speed: 'normal'

}

return {

carCollection: function() {

}, // 1. add another item to our object (i.e. run).

run: function() {

}

}

})();

cars.carCollection(); //-> Ferrari

cars.run(); //-> speed...normal

cars.run( { speed: 'fast'}); //-> speed...fast

let cars2 = (function() {

let DEFAULT = {

car: 'Ferrari',

speed: 'normal'

}

return {

carCollection: function() {

},

run: function() {

}

}

})();

cars2.carCollection({ car: 'Porsche'}).run({ speed: 'Super Fast'});

// classic was of getting the sum with rest operator

function sum1(...args) {

}

console.log(sum1(1,2,3,4,5,10));

// more modern way of getting the sum with rest operator

function sum2(...args) {

return args.reduce((a, b) => a + b);

}

console.log(sum2(1,2,3,4,5,10));

// more complex example

function sum3(discount, ...prices) {

const total = prices.reduce((a,b) => a + b);

return total * (1 - discount); // if dicount is .01 subtracted from 1 is 0.9 multiplied by total will...

} // ...return final price after discount.

console.log(sum3(0.1, 20, 30)); // 0.1 is the discount, 20 and 30 are the prices.

//-> 45

let xS = function() {