# Design Pattern

var App = App || {};
App.Parent = function () {};
App.Child = function () {};

App.container = 1;
App.module = {
    module_1: {
        data: {a: 1, b: 2}
    },
    module_2: {}
};

function Parent() {}
function Child() {}

var some_var = 1;

var module1 = {};

module.data = {a : 1, b : 2};

var module2 = {}

define(['a', 'b', 'c'], function (a, b, c) {
    /* statement */
});

(function (root, factory) {
  if (typeof define === 'function' && define.amd) {
    // AMD. Register as an anonymous module.
    define(['b'], factory);
  } else if (typeof module === 'object' && module.exports) {
    // Node. Does not work with strict CommonJS, but
    // only CommonJS-like environments that support module.exports,
    // like Node.
    module.exports = factory(require('b'));
  } else {
    // Browser globals (root is window)
    root.returnExports = factory(root.b);
  }
}(this, function (b) {
  //use b in some fashion.

  // Just return a value to define the module export.
  // This example returns an object, but the module
  // can return a function as the exported value.
  return {};
}));

(function () {
    // private 변수들과 함수들을 선언

    return {
        // public 변수들과 함수들을 선언
    };
}());

var HTMLChanger = (function() {
    var contents = 'contents';

    var changeHTML = function () {
        var element = document.getElementById('attribute-to-change');
        element.innerHTML = contents;
    }

    return {
        callChangeHTML: function () {
            changeHTML();
            console.log(contents);
        }
    };
}());

HTMLChanger.callChangeHTML();         // 'contents'
console.log(HTMLChanger.contents);    // undefined

var module = (function () {
    // 1. Module Scope 내에서 사용할 변수 작성
    var scopeVal = {},
        utilMethod,
        manipulateDOM,
        eventHandler,
        initModule;

    // 2. Utility Method 작성
    utilMethod = function () {
        /* 실행 코드 */
    };

    // 3. DOM 조작 메소드 작성
    manipulateDOM = function () {
        /* 실행 코드 */
    }

    // 4. Event Handler 작성
    eventHandler = function () {
        /* 실행 코드 */
    }

    // 5. Public Method 작성
    return {
        init: initMethod
    };
}());

function volume(l, w, h) {
    return l * w * h;
}

function curry(fn) {
    var arity = fn.length;

    return (function resolver() {
        var memory = Array.prototype.slice.call(arguments);

        return function () {
            var local = memory.slice();

            Array.prototype.push.apply(local, arguments);

            var next = (local.length >= arity? fn : resolver);

            return next.apply(null, local);
        };
    }());
}

var curried = curry(volume),
    length = curried(2),
    lengthAndWidth = length(3);

console.log(lengthAndWidth(4));

var _curried = curry(volume);
console.log(_curried(2)(3)(4));

var count = 0;

var fibonacci = function (n) {
    count++;
    return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
}

for (var i = 0; i <= 10; i++) {
    console.log(i + ' = ' + fibonacci(i));
}

console.log('count = ', count);

var fibonacci = function () {
    var memo = [0, 1];
    var count = 0;
    var fib = function (n) {
        count++;

        var result = meno[n];

        if (typeof result !== 'number') {
            result = fib(n - 1) + fib(n - 2);
            memo[n] = result;
        }
        return result;
    };
    return fib;
}

for (var i = 0; i <= 10; i++) {
    console.log(i, ' = ', fibonacci(i));
}

console.log('count : ', count);

var factorial = (function () {
    var save = {};
    var fact = function (number) {
        if (number > 0) {
            var saved = save[number - 1] || fact(number - 1);
            var result = number * saved;
            save[number] = result;
            console.log(saved, result);
            return result;
        } else {
            return 1;
        }
    }
    return fact;
}());

factorial(7);