party-bid 三种数据结构思维总结

简介：针对party-bid活动采取不同的结构实现对数据的存储和获取。总而言之，对每一种结构，存储时

的方式与获取的方式是不一样的。区别不同的结构，了解他们的不同之处，理解他们各自的优缺点。

第一种结构：

activities = [                         
    {              
        name: "first activity",
        sign_ups:[],
        bids:[]
    }] 
sign_ups: [
            {
                name:"张三",
                phone:"13600000000"
            }]
bids:[
      {
         name:"竞价1",
         biddings : [
                    {
                        name: "张三",
                        phone:"13600000000",
                        price: "12"

    }] 

解析：这种方式的结构比较清晰，一个活动包含活动名，报名人信息，竞价人信息。直接存储到一个大
的activities中，那要取活动的报名人信息的话，就要通过活动名找到对应的报名，同样，要找竞价
的话，也要通过活动名才能找到对应的竞价信息。

所以，活动的存储和创建活动就可以这样实现：

function Activity(activity_name) {
    this.name = activity_name;
    this.sign_ups = [];
    this.bids = [];
}

Activity.prototype.create = function () {
    var activities = JSON.parse(localStorage.activities);
    activities.unshift(this);
    localStorage.activities = JSON.stringify(activities);
}

如果要得到报名信息的话，可以这样获得：

Message.judge_sign_up_repeat = function (sms_json) {
    var activities = JSON.parse(localStorage.activities);
    var activity = _.find(activities, function (num) {
        return num.name == Activity.get_current_activity();
    })
    var sign_up_repeat = _.some(activity.sign_ups, function (list) {
        return list.phone == Message.save_phone(sms_json);
    })
    return sign_up_repeat;
}

如果要得到竞价信息的话，可以这样获得：

Message.check_bid_phone_repeat = function (sms_json) {
    var activities = JSON.parse(localStorage.activities);
    var current_activity = _.find(activities, function (list) {
        return list.name == Activity.get_current_activity();
    })
    var current_bid = _.find(current_activity.bids, function (num) {
        return num.name == Activity.get_current_bid();
    })
    var bid_phone_repeat = _.some(current_bid.biddings, function (bid) {
        return bid.phone == Message.save_phone(sms_json)
    })
    return bid_phone_repeat;
}

总结：这种结构比较清晰和容易理解，但有点麻烦和啰嗦。

第二种结构：

activities = {
    "0":{
        name: "first activity",
        sign_ups:[],
        bids:[],
        biddings:{}
    }]
sign_ups: [
            {
                name:"张三",
                phone:"13600000000"
            }]
bids:["竞价1","竞价2"]

biddings:{
            "竞价1":[
                {
                    phone:"13600000000",
                    price: "12"

                },
                {
                    phone:"15600000000",
                    price: "10"
                }
            ]
        }

解析：这种方式的结构也比较清晰和直接，一个对象包含多个小对象，为每一个活动都添加了一个ID数组（初始值为[]，作为活动的属性），
通过ID就可以找到对应的活动，一个活动包含活动名，报名人信息，竞价名，竞价人的详细信息。直接存储到一个大的activities中，
那要取活动的报名人信息的话，就要通过将ID(当前活动)作为索引就能找到对应的报名，同样，要找竞价的话，也要通过ID（当前活动）到达竞价，
然后通过将竞价名（当前竞价）作为索引才能找到对应的竞价信息。

所以，活动的存储和创建活动就可以这样实现：

function Activity(activity_name){
    this.name = activity_name;
    this.sign_ups = [];
    this.bids = [];
    this.biddings = {}
}

Activity.prototype.create = function(){
    var activities_json = JSON.parse(localStorage.activities);  //得到一个大对象
    var activity_ids = JSON.parse(localStorage.activity_ids);
    var counter = activity_ids.length;    //counter == 0
    activities_json[counter] = (this);    //这里的counter作为活动的属性
    localStorage.setItem('activities',JSON.stringify(activities_json));
    localStorage.setItem('counter',JSON.stringify(counter));
    activity_ids[counter] = localStorage.getItem('counter');    //activity_ids[counter] == 0;
    localStorage.setItem('activity_ids',JSON.stringify(activity_ids));
    localStorage.current_activity = '0';
    localStorage.activity_id_generator = '3';
}

如果要得到报名信息的话，可以这样获得：

Message.judge_sign_up_repeat = function (sms_json) {
    var activities = JSON.parse(localStorage.activities);
    var current_activity = Activity.get_current_activity()
    var sign_up_repeat = _.some(activities[current_activity].sign_ups, function (list) {
        return list.phone == Message.save_phone(sms_json)
    })
    return sign_up_repeat;
}

如果要得到竞价信息的话，可以这样获得：

Message.judge_bid_phone_repeat = function (sms_json) {
    var activities = JSON.parse(localStorage.activities);
    var current_activity = Activity.get_current_activity();
    var current_bid = Activity.get_current_bid();
    var bid_phone_repeat=_.some(activities[current_activity].biddings[current_bid],function(num){
        return num.phone == Message.save_phone(sms_json);
    })
    return bid_phone_repeat;
}

总结：这种结构比较清新和直接，比第一种要麻利点，能够快速得到报名信息和竞价信息。

第三种结构：

activities = [
    {
        id:"0",
        name: "first activity"  
    }]

sign_ups = [
    {
        name:"张三",
        phone:"13600000000",
        activity_id:"0"
    }]

bids = [
    {
        name: "竞价1",
        activity_id:"0",
        biddings:[
            {
                phone:"13600000000",
                price: "9"

            },
            {
                phone:"15600000000",
                price: "10"
            }
        ]
    }]

解析：这种方式的结构非常清晰直接，一个数组包含多个对象，为每一个活动都添加了一个ID数组（初始值为[]），通过ID就可以找到活动，
一个活动包含活动名，ID。一个报名包含报名信息，活动ID。一个竞价包含活动ID，竞价信息。存储的时候不再是直接存储到一个大
的activities中，在这里，而是分别存储活动，报名，竞价。那要取活动的报名人信息的话，直接通过acyivity_id属性就能很
容易的找到当前活动，想要得到报名信息，竞价信息就自然比较容易了。

所以，活动的存储和创建活动就可以这样实现：

function Activity(activity_name) {
    this.name = activity_name;
    this.id = Activity.id();
}

Activity.id = function () {
    var activities_json = JSON.parse(localStorage.activities);
    var counter = activities_json.length;
    localStorage.setItem('counter', JSON.stringify(counter));
    return localStorage.getItem('counter');
}

Activity.prototype.create = function () {
    var activities_json = JSON.parse(localStorage.activities);   //得到一个数组
    activities_json.unshift(this);
    localStorage.setItem('activities', JSON.stringify(activities_json));
    localStorage.current_activity = '0';
    localStorage.activity_id_generator = '3';
}

如果要得到报名信息的话，可以这样获得：

Message.judge_sign_up_repeat = function (sms_json) {
    var sign_ups = JSON.parse(localStorage.sign_ups);
    var activity = _.find(sign_ups, function (num) {
        return num.activity_id == Activity.get_current_activity();
    })
    var sign_up_repeat = _.some(activity, function (value, key) {
        return key == 'phone' ? value == Message.save_phone(sms_json) : ''
    })
    return sign_up_repeat;
}

如果要得到竞价信息的话，可以这样获得：

Message.judge_bid_phone_repeat = function (sms_json) {
    var bids = JSON.parse(localStorage.bids);
    var current_bids = _.find(bids, function (num) {
        return (num.activity_id == Activity.get_current_activity() && num.name == Activity.get_current_bid())
    })
    var bid_repeat = _.some(current_bids.biddings, function (list) {
        return list.phone == Message.save_phone(sms_json)
    })
    return bid_repeat;
}

总结：这种存储结构相对来说，比第二种更直接，直接通过acyivity_id属性就能很容易的找到当前活动，
想要得到报名信息，竞价信息就自然比较容易了。

通过对这三种数据结构的了解，我个人比较偏向于第三种结构，或许每个人的想法不一样，如果是你，
你会选择哪一种呢？