// 篮球基类
var Basketball = function() {
    this.intro = '篮球盛行于美国';
};
Basketball.prototype = {
    getMember: function() {
        console.log('每个队伍需要5名队员');
    },
    getBallSize: function() {
        console.log('篮球很大');
    }
};
// 足球基类
var Football = function() {
    this.intro = '足球盛行于美国';
};
Football.prototype = {
    getMember: function() {
        console.log('每个队伍需要11名队员');
    },
    getBallSize: function() {
        console.log('篮球很大');
    }
};
// 运动工厂
var SportsFactory = function(name) {
    switch(name) {
        case 'NBA': 
            return new Basketball();
        case 'wordCup': 
            return new Football();
    }
};

// 工厂类
var Factory = function(type, content) {
    if(this instanceof Factory) {
        var s = new this[type](content);
        return s;
    } else {
        // 防止使用者不知道这是一个类，忘了加new操作符创建，导致全局变量污染
        return new Factory(type, content);
    }
};
Factory.prototype = {
    Java: function(content) {
        // ...
    },
    JavaScript: function(content) {
        // ...
    },
    php: function(content) {
        // ...
    }
};

// 抽象工厂方法
var VehicleFactory = function(subType, superType) {
    // 判断抽象工厂中是否有该抽象类
    if(typeof VehicleFactory[superType] === 'function') {
        // 缓存类
        function F() {};
        // 继承父类属性和方法
        F.prototype = new VehicleFactory[superType]();
        // 将子类构造函数指向子类
        subType.constructor = subType;
        // 子类原型继承父类
        subType.prototype = new F();
    } else {
        // 不存在该抽象类抛出错误
        throw new Error('未创建该抽象类');
    }
};
// 小汽车抽象类
VehicleFactory.Car = function() {
    this.type = 'car';
};
VehicleFactory.Car.prototype = {
    getPrice: function() {
        return new Error('抽象方法不能调用')
    }
};
// 公交车抽象类
VehicleFactory.Bus = function() {
    this.type = 'bus';
};
VehicleFactory.Bus.prototype = {
    getPrice: function() {
        return new Error('抽象方法不能调用');
    }
};

// 创建一位人类
var Human = function(param) {
    // 技能
    this.skill = param && param.skill || '保密';
    // 兴趣爱好
    this.hobby = param && param.hobby || '保密';
};
// 类人原型方法
Human.prototype = {
    getSkill: function() {
        return this.skill;
    },
    getHobby: function() {
        return this.hobby;
    }
};
// 实例化姓名类
var Named = function(name) {
    var that = this;
    // 构造器，解析姓名的姓与名
    (function(name, that) {
        that.wholeName = name;
        if(name.indexOf(' ') > -1) {
            that.FirstName = name.slice(0, name.indexOf(' '));
            that.FirstName = name.slice(name.indexOf(' '));
        }
    })(name, that);
};
// 实例化职位类
var Work = function(work) {
    var that = this;
    // 构造器，通过传入的职位特征来设置相应职位及描述
    (function(work, that) {
        switch(work) {
            case 'code':
                that.work = '工程师';
                break;
            case 'UI':
            case 'UE':
                that.work = '设计师';
                break;
            case 'teach':
                that.work = '教师';
                break;
            default:
                that.work = work;
        }
    })(work, that);
};
// 更换期望的职位
Work.prototype.changeWork = function(work) {
    this.work = work;
};

// 应聘者创建类
var Person = function(name, work) {
    // 创建应聘者缓存对象
    var _person = new Human();
    // 创建应聘者姓名解析对象
    _person.name = new Named(name);
    // 创建应聘者期望职位
    _person.work = new Work(work);
    // 返回创建的应聘者对象
    return _person;
}

// 原型对象复制方法
function prototypeExtend() {
    var F = function() {},
        args = arguments,
        i = 0,
        len = args.length;
    for (; i < len; i++) {
        // 遍历每个模板对象中的属性
        for(var j in args[i]) {
            F.prototype[j] = args[i][j];
        }
    }
    // 返回缓存类实例
    return new F();
}

var penguin = prototypeExtend({
    speed: 20,
    swim: function() {
        console.log('游泳速度' + this.speed);
    },
    run: function() {
        console.log('奔跑速度' + this.speed);
    }
})

var A = {
    Util: {
        util_method1: function() {},
        util_method2: function() {}
    },
    Tool: {
        tool_method1: function() {},
        tool_method2: function() {}
    },
    Ajax: {
        ajax_method1: function() {},
        ajax_method2: function() {}
    }
    ...
}

A.Util.util_method1();
A.Tool.tool_method2();

// 外观模式实现
function addEvent(dom, type, fn) {
    // 对于支持DOM2级事件处理程序的浏览器
    if(dom.addEventListener) {
        dom.addEventListener(type, fn, false);
    // 对于不支持addEventListener但支持attachEvent的浏览器
    } else if(dom.attachEvent) {
        dom.attachEvent('on' + type, fn);
    } else {
        dom['on' + type] = fn;
    }
}

function doSomeThing(name, title, age, color, size, prize){}

/**
 * obj.name: name
 * obj.title: title
 * obj.age: age
 * obj.color: color
 * obj.size: size
 * obj.prize: prize
***/
function doSomeThing(obj){}

function doSomeThing(obj) {
    var _adapter = {
        name: '雨夜清荷',
        title: '设计模式',
        age: 24,
        color: 'pink',
        size: 100,
        prize: 50
    };
    for(var i in _adapter) {
        _adapter[i] = obj[i] || _adapter[i];
    }
}

// 装饰者
var decorator = function(input, fn) {
    // 获取事件源
    var input = document.getElementById(input);
    // 若事件源已经绑定事件
    if(typeof input.onclick === 'function') {
        // 缓存事件源原有回调函数
        var oldClickFn = input.onclick;
        // 为事件源定义新的事件
        input.onclick = function() {
            // 事件源原有回调函数
            oldClickFn();
            // 执行事件源新增回调函数
            fn();
        }
    } else {
        input.onclick = fn;
    }
}

function changeColor(dom, color, bg) {
    // 设置元素的字体颜色
    dom.style.color = color;
    // 设置元素的背景颜色
    dom.style.background = bg;
}

var spans = document.getElementsByTagName('span');
spans[0].onmouseover = function() {
    changeColor(this, 'red', '#ddd');
}

var Flyweight = function() {
    // 已创建的元素
    var created = [];
    // 创建一个新闻包装容器
    function create() {
        var dom = document.createElement('div');
        // 将容器插入新闻列表容器中
        document.getElementById('container').appendChild(dom);
        // 缓存新创建的元素
        created.push(dom);
        // 返回创建的新元素
        return dom;
    }
    return {
        // 获取创建新闻元素方法
        getDiv: function() {
            // 如果已创建的元素小于当前页元素总个数(5个)，则创建
            if(created.length < 5) {
                return created();
            } else {
                // 获取第一个元素，并插入去后面
                var div = created.shift();
                created.push(div);
                return div;
            }
        }
    }
}

var paper = 0,
    num = 5,
    len = article.length;
// 添加五条新闻
for(var i = 0; i < 5; i++) {
    if(article[i])
        // 通过享元类获取创建的元素并写入新闻内容
        Flyweight.getDiv().innerHTML = article[i];
}

// 下一页按钮绑定事件
document.getElementById('next_page').onclick = function() {
    // 如果新闻内容不足5条则返回
    if(article.length < 5) {
        return;
    }
    var n = ++paper * num % len,  // 获取当前页的第一条新闻索引
        j = 0;
    // 插入5条新闻
    for(; j < 5; j++) {
        // 如果存在n+j条则插入
        if(article[n + j]) {
            Flyweight.getDiv().innerHTML = article[n + j];
        // 否则插入起始位置第n+j-len条
        } else if(article[n + j - len]) {
            Flyweight.getDiv().innerHTML = article[n + j - len];
        } else {
            Flyweight.getDiv().innerHTML = "";
        }
    }
}

// 格式化字符串方法
function formateString(str, data) {
    return str.replace(/\{#(\w+)#\}/g, function(match, key) {
        return typeof data[key] === undefined ? '': data[key]
    });
}
// 基础导航
var Nav = function(data) {
    // 基础导航样式模板
    this.item = '<a href="{#href#}" title="{#title#}">{#name#}</a>';
    // 创建字符串
    this.html = '';
    // 格式化数据
    for(var i = 0, len = data.length; i < len; i++) {
        this.html += formateString(this.item, data[i]);
    }
    // 返回字符串数据
    return this.html;
}

var NumNav = function(data) {
    // 消息提醒信息组件模板
    var tpl = '<b>{#num#}</b>';
    // 装饰数据
    for(var i = data.length - 1; i >= 0; i--) {
        data[i].name += data[i].name + formateString(tpl, data[i]);
    }
    // 继承基础导航类
    return Nav.call(this, data);
}

var Observer = (function() {
    // 防止消息队列暴露而被篡改，故将消息容器作为静态私有变量保存
    var __messages = {};
    return {
        // 注册信息接口
        regist: function() {},
        // 发布信息接口
        fire: function() {},
        // 移除信息接口
        remove: function() {}
    }
})();

// 投票结果状态对象
var ResultState = function() {
    // 判断结果保存在内部状态中
    var States = {
        // 每种状态作为一种独立方法保存
        state0: function() {
            console.log('这是第一种情况')：
        },
        state1: function() {
            console.log('这是第二种情况')：
        },
        state2: function() {
            console.log('这是第三种情况')：
        },
        state3: function() {
            console.log('这是第四种情况')：
        }
    }
    // 获取某种状态并执行对应方法
    function show(result) {
        States['state' + result] && States['state' + result]();
    }
    return {
        // 返回调用状态方法接口
        show: show
    }
}();

ResultState.show(3);

// 价格策略对象
var PriceStrategy = function() {
    // 内部算法对象
    var strategy = {
        // 100返30
        return30: function(price) {},
        // 100返50
        return50: function(price) {},
        // 9折
        percent90: function(price) {},
        // 8折
        percent80: function(price) {},
        // 5折
        percent50: function(price) {},
    }
    // 策略算法调用接口
    return function(algorithm, price) {
        return strategy[algorithm] && strategy[algorithm](price);
    }
}();

// 模块实现模块
var viewCommand = (function() {
    var tpl = {
        // 展示图片结构模块
        product: [
            '<div>',.....,'</div>'
        ].join(''),
        // 展示标题结构模块
        title: [
        '<div>',.....,'</div>'
        ].join(''),
    },
    // 格式化字符串缓存字符串
    html = '';
    // 格式化字符串
    function formateString(str, obj) {}
    // 方法集合
    var Action = {
        // 创建方法
        create: function(data, view) {
            // 解析数据
            if(data.length) {
                // 遍历
                for(var i = 0, len = data.length; i < len; i++) {
                    html += formateString(tpl[view], data[i]);
                }
            } else {
                html += formateString(tpl[view], data);
            }
        },
        // 展示方法
        display: function(container, data, vuew) {
            // 如果传入数据
            if(data) {
                // 根据给的数据创建视图
                this.create(data, view);
            }
            // 展示模块
            document.getElementById(container).innerHTML = html;
            // 展示后清空缓存字符串
            html = '';
        }
    }
    // 命令接口
    return function excute(msg) {
        // 解析命令，如果msg.param不是数组则将其转化为数组
        msg.param = Object.prototype.toString.call(msg.param) === "[object Array]" ? msg.param : [msg.param];
        // Action内部调用的方法引用this，此处保证作用域this执行传入Action
        Action[msg.command].apply(Action, msg.param)
    }
})();

var productData = [
    {
        src: 'command/02.jpg',
        text: '绽放的桃花'
    },
    {
        src: 'command/03.jpg',
        text: '阳光下的温馨'
    }
],
// 模块标题数据
titleData = {
    title: '夏日里的一片温馨',
    tips: '暖暖的温情带给人们家的感觉'
}
// 调用命令对象
viewCommand({
    command: 'display',
    param: ['title', titleData, 'title']
});
viewCommand({
    command: 'create',
    param: ['product', productData, 'product']
});

var bindEvent = function(dom, type, fn) {
    if(dom.addEventListener) {
        dom.addEventListener(type, fn, false);
    } else if(dom.attachEvent) {
        dom.attachEvent('on' + type, fn);
    } else {
        dom['on' + type] = fn;
    }
}
var demo = document.getElementById('demo');
bindEvent(demo, 'click', function() {
    this.style.background = 'red';
});

function bindIEEvent(dom, type, fn, data) {
    var data = data || {};
    dom.attachEvent('on' + type, function(e){
        fn.call(dom, e, data);
    });
};

// 中介者对象
var Mediator = function() {
    // 消息对象
    var _msg = {};
    return {
        // 订阅消息方法，type:消息名称 action:消息回调函数
        register: function(type, action) {
            // 如果消息存在
            if(_msg[type])
                // 存入回调函数
                _msg[type].push(action);
            else {
                // 不存在则建立消息容器
                _msg[type] = [];
                _msg[type].push(action);
            }
        },
        // 发布消息方法
        send: function(type) {
            // 如果该消息已经被订阅
            if(_msg[type]) {
                // 遍历已存储的消息回调函数
                for(var i = 0, len = _msg[type].length; i < len; i++) {
                    // 执行回调函数
                    _msg[type][i] && _msg[type][i]();
                }
            }
        }
    }
}();

// Page备忘录类
var Page = function() {
    // 信息缓存对象
    var cache = {};
    return function(page, fn) {
        // 判断该页数据是否在缓存中
        if(cache[page]) {
            // 显示该页内容
            showPage(page, cache[page]);
            // 执行成功回调函数
            fn && fn();
        } else {
            // 否则异步请求
            $.post('./data/getNewsData.php', {
                page: page
            }, function(res) {
                // 成功返回
                if(res.errNo == 0) {
                    showPage(page, res.data);
                    cache[page] = res.data;
                    fn && fn();
                } else {
                    // 处理异常
                }
            })
        }
    }
}

var Iterator = function(items, container) {
    // 获取父元素
    var container = container && document.getElementById(container) || document,
    // 获取元素
        items = container.getElementsByTagName(items),
    // 获取元素长度
        length = items.length,
    // 当前索引值
        index = 0;
    // 缓存原生数组splice方法
    var splice = [].splice;
    return {
        // 获取第一个元素
        first: function() {},
        // 获取最后一个元素
        second: function() {},
        // 获取前一个元素
        pre: function() {},
        // 获取后一个元素
        next: function() {},
        // 获取某一个元素
        get: function(num) {},
        // 对每一个元素执行某一个方法
        dealEach: function(fn) {},
        // 对某一个元素执行某一个方法
        dealItem: function(num, fn) {},
        // 排他方式处理某一个元素
        exclusive: function() {}
    }
}