Select Page
/* First class citizen – what does this mean?  In javascript,
functions can be passed into other functions
functions can be stored in variables
*/

// Let’s talk about putting functions into variables

/* 
Method 1:
function doctorize(firstName) {
    return `Dr. ${firstName}`;
}

Anon Function
Anonymous function is a function without a name. This is not valid javascript
function (firstname) {
    return `Dr. ${name}`;
}

Function Expression:
const doctorize = function (firstname) {
    return `Dr. ${name}`;
}

Hoisting:  Javascript “hoists” all functions to the very top of the file, so even if you call
a function before it is defined, it will still run.  This is not the case though if you define
a variable as a function – that variable is not available until it is defined.
Arrow Functions
Consise, shorter functions, one liner
Don’t have their own scope
They are anonymous functions. Always have to declare it and stick into a variable
This is the normal way to do a function:
function incheToCM(inches) {
    const cm = inches * 2.54;
    return cm;
}

One way to make the code a little smaller:
function inchtoCM(inches) {
    return inches * 2.54;
}

Now, let’s make it an anonymous function, in preparation for making it an arrow function:
const inchToCM = function(inches) {
    return inches * 2.54;
}

Now convert to arrow function:
const inchToCM = (inches) =>  inches * 2.54;
*/
const inchToCM = (inches=>  inches * 2.54;

/*
function add(a, b = 3) {
    const total = a + b;
    return total;
}
*/
// let’s convert the add function to an arrow function
const add = (ab = 3=> a + b;
/*Returning an Object
function makeABaby(first, last) {
    const baby = {
        name: `${first} ${last}`,
        age: 0
    }
    return baby;
}

Now how would we return this as an object?
*/
//The below is not as good as above, despite being smaller. It’s not as easily readable. So don’t
//always use an arrow function.
const makeABaby = (firstlast=> ({ name: `${first} ${last}`age: 0 })

// IIFE – Immediately Invoked Function Expression
//You can wrap an anonymous function in paretheses
(function() {
    console.log(‘Running anonymouse function’);
    return ‘This is cool’;
})();  // Note that when invoking this at the end of the function, it immediately runs. 
//Methods!!!!!
// Method is a function that lives inside of an object

const Mike = {
    name: ‘Mike Coleman’
    age: 100,
    favpizza: ‘LaRosas’,
    greeting: function() {
        console.log(`Hello, ${Mike.name}`);
        console.log(`You are ${Mike.age} years old.`);
        return `You are ${Mike.age} years old.`;
    }
}

// Short Hand Method for the function inside the object (method)
// greeting() {
//    console.log(`Hello, ${Mike.name}`);
//    return `You are ${Mike.age} years old.`;

//Callback Function – just telling browser to be a dear, and do something when something happens
//When someone clicks this, run this
const button = document.querySelector(‘.clickMe’);
button.addEventListener(‘click’,Mike.greeting)

//Timer callback
setTimeout(Mike.greeting3000);  //3000 is 3 seconds