Programming Methodologies in JavaScript

const elf = {
    name: 'Orwell',
    weapon: 'bow',
    attack() {
        return 'attack with ' + elf.weapon
    }
}

const elf2 = {
    name: 'Sam',
    weapon: 'Sword',
    attack() {
        return 'attack with ' + elf.weapon
    }
}

// Factory function - build elf objects
function createElf(name, weapon) {
    return {
        name: name,
        weapon: weapon,
        attack() {
            return 'attack with ' + weapon
        }
    }
}

const peter = createElf('Peter', 'Stones');
console.log(peter.attack()); // RESULT: "attack with Stones"

const sam = createElf('Sam', 'Fire');
console.log(sam.attack()); // RESULT: "attack with Fire"

// Factory function - build elf objects
const elfFunctionsStore = {
    attack() {
        return 'attack with ' + this.weapon
    }
}

function createElf(name, weapon) {
    // Set up the prototype chain
    let newElf = Object.create(elfFunctionsStore);
    newElf.name = name;
    newElf.weapon = weapon;
    return newElf;
}

const peter = createElf('Peter', 'Stones');
console.log(peter.attack()); // RESULT: "attack with Stones"

const sam = createElf('Sam', 'Fire');
console.log(sam.attack()); // RESULT: "attack with Fire"

// ES6 Class
class Elf {
    constructor(name, weapon) {
        this.name = name;
        this.weapon = weapon;
    }
    attack() {
        return 'attack with ' + this.weapon
    }
}

const peter = new Elf('Peter', 'Stones');
console.log(peter.attack()); // RESULT: "attack with Stones"

const sam = new Elf('Sam', 'Fire');
console.log(sam.attack()); // RESULT: "attack with Fire"

// ES6 Class
class Elf {
    constructor(name, weapon) {
        this.name = name;
        this.weapon = weapon;
    }
    attack() {
        return 'attack with ' + this.weapon
    }
}

const peter = new Elf('Peter', 'Stones');
console.log(peter.attack()); // RESULT: "attack with Stones"

const sam = new Elf('Sam', 'Fire');
console.log(sam.attack()); // RESULT: "attack with Fire"

// Check for instanceOf
console.log('Is Peter and instance of Elf?', peter instanceof Elf);
console.log('Is Sam and instance of Elf?', sam instanceof Elf);

// Set the super-class
class Character {
    constructor(name, weapon) {
        this.name = name;
        this.weapon = weapon;
    }
    attack() {
        return 'attack with ' + this.weapon
    }
}

// Extend the super-class
class Elf extends Character {
    constructor(name, weapon, type) {
        super(name, weapon, type);

        // Add properties unique to this sub-class, but also unique variations for each instance of this sub-class
        this.type = type
    }
}

class Ogre extends Character {
    constructor(name, weapon, color) {
        super(name, weapon);

        // Add properties unique to this sub-class, but also unique variations for each instance of this sub-class
        this.color = color;
    }

    // Add functions unique to this sub-class and shared by all in the sub-class
    makeFort() {
        return 'The strongest fort in the world has been made'
    }
}

const peter = new Elf('Peter', 'Stones', 'Wood Elf');
console.log(peter.name); // RESULT: "Peter"
console.log(peter.type); // RESULT: "Wood Elf"
console.log(peter.attack()); // RESULT: "attack with Stones"

const sam = new Elf('Sam', 'Fire', 'House Elf');
console.log(sam.name); // RESULT: "Sam"
console.log(sam.type); // RESULT: "House Elf"
console.log(sam.attack()); // RESULT: "attack with Fire"

const shrek = new Ogre('Shrek', 'club', 'green');
console.log(shrek.name); // RESULT: "Shrek"
console.log(shrek.attack()); // RESULT: "attack with club"
console.log(shrek.makeFort()); // RESULT: "The strongest fort in the world has been made"

// Check for instanceOf
console.log('Is Peter an instance of Elf?', peter instanceof Elf); // RESULT: true
console.log('Is Sam and instance of Elf?', sam instanceof Elf); // RESULT: true

console.log('Is Shrek an instance of Elf?', shrek instanceof Elf); // RESULT: false
console.log('Is Shrek an instance of Character?', shrek instanceof Character); // RESULT: true
console.log('Is Shrek an instance of Ogre?', shrek instanceof Ogre); // RESULT: true

// Under the hood, JS is just creating prototype chains
console.log('Is Ogre a prototype of Shrek? ', Ogre.prototype.isPrototypeOf(shrek));
console.log('Is Character a prototype of Ogre? ', Character.prototype.isPrototypeOf(Ogre.prototype));

// These are NOT Pure function as each will alter the array every time it is called, and the order of calling these makes a difference.
const array = [1, 2, 3];

function mutateArray(arr) {
    arr.pop();
}

function mutateArray2(arr) {
    arr.push()
}

// Rewritten as Pure functions
const array = [1, 2, 3];

function removeLastItem(arr) {
    const newArray = [].concat(arr);
    newArray.pop();
    return newArray
}

function addToArray(arr) {
    const newArray = [].concat(arr);
    newArray.push(1)
    return newArray
}

console.log(removeLastItem(array)); // RESULT: [ 1, 2 ]
console.log(addToArray(array)); // RESULT: [ 1, 2, 3, 1 ]
console.log(array); // RESULT: [ 1, 2, 3] (has not been altered)

// Another example of a Pure function
function multiplyBy2(arr) {
    return arr.map(item = & gt; item * 2)
}

console.log(multiplyBy2(array)); // RESULT: [ 2, 4, 6 ]
console.log(array); // RESULT: [ 1, 2, 3] (has not been altered)

// Not Idempotent
function notIdempotent(num) {
    Math.random(num)
}

notIdempotent(5) // RESULT: (This returns a different number every time, because the function is not idempotent)

// An idempotent function that is not Pure becasue it interacts outside its environment
function antIdempotentOne(num) {
    console.log(num);
}

antIdempotentOne(5) // RESULT: 5

// An example of being able to call itself repeatedly and still output the the same as if not calling itself
Math.abs(Math.abs(Math.abs(-50)));

// Setup the user
const user = {
    name: 'Kim',
    active: true,
    cart: [],
    purchases: []
}

// The history1 variable will store user each step to keep a record
const history1 = [];

// Setup compose functionality
const compose = (f, g) = & gt;
(...args) = & gt;
f(g(...args))

// Use compose to set up the assembly line
const purchaseItem = (...fns) = & gt;
fns.reduce(compose);

// Fill the assembly line
purchaseItem(
    emptyUserCart,
    buyItem,
    applyTaxToItems,
    addItemToCart
)(user, {
    name: 'laptop',
    price: 50
});

// Record the initial user data,
// update the cart and then return a copy
// of the user object with the updated info
function addItemToCart(user, item) {
    history1.push(user)
    const updatedCart = user.cart.concat(item)
    return Object.assign({}, user, {
        cart: updatedCart
    });
}

// Record the initial user data and
// then return the cart with the updated amount
function applyTaxToItems(user) {
    history1.push(user)
    const {
        cart
    } = user;
    const taxRate = 1.3;
    const updatedCart = cart.map(item = & gt; {
        return {
            name: item.name,
            price: item.price * taxRate
        }
    })
    return Object.assign({}, user, {
        cart: updatedCart
    });
}

// Record the initial user data and
// then return a copy of the object with the item added to the cart
function buyItem(user) {
    history1.push(user)
    const itemsInCart = user.cart;
    return Object.assign({}, user, {
        purchases: itemsInCart
    });
}

// Record the initial user data and
// then return an empty copy of the object.
function emptyUserCart(user) {
    history1.push(user)
    return Object.assign({}, user, {
        cart: []
    });
}