json - JQuery के साथ फॉर्म डेटा को जावास्क्रिप्ट ऑब्जेक्ट में कनवर्ट करें




serialization (25)

मैं अपने फॉर्म के सभी तत्वों को जावास्क्रिप्ट ऑब्जेक्ट में कैसे परिवर्तित करूं?

मैं प्रत्येक तत्व पर लूप किए बिना, मेरे रूप से जावास्क्रिप्ट ऑब्जेक्ट को स्वचालित रूप से बनाने का कोई तरीका चाहता हूं। मैं एक स्ट्रिंग नहीं चाहता, जैसा कि $('#formid').serialize(); द्वारा लौटाया गया है $('#formid').serialize(); , और न ही मैं चाहता हूं कि नक्शा $('#formid').serializeArray(); द्वारा लौटाया $('#formid').serializeArray();


Answers

I wouldn't use this on a live site due to XSS attacks and probably plenty of other issues, but here's a quick example of what you could do:

$("#myform").submit(function(){
    var arr = $(this).serializeArray();
    var json = "";
    jQuery.each(arr, function(){
        jQuery.each(this, function(i, val){
            if (i=="name") {
                json += '"' + val + '":';
            } else if (i=="value") {
                json += '"' + val.replace(/"/g, '\\"') + '",';
            }
        });
    });
    json = "{" + json.substring(0, json.length - 1) + "}";
    // do something with json
    return false;
});

टोबीस कोहेन के समाधान का एक निश्चित संस्करण। यह सही ढंग से 0 और '' जैसे गलत मूल्यों को संभालता है।

jQuery.fn.serializeObject = function() {
  var arrayData, objectData;
  arrayData = this.serializeArray();
  objectData = {};

  $.each(arrayData, function() {
    var value;

    if (this.value != null) {
      value = this.value;
    } else {
      value = '';
    }

    if (objectData[this.name] != null) {
      if (!objectData[this.name].push) {
        objectData[this.name] = [objectData[this.name]];
      }

      objectData[this.name].push(value);
    } else {
      objectData[this.name] = value;
    }
  });

  return objectData;
};

और आपके कोडिंग सुविधा के लिए एक कॉफीस्क्रिप्ट संस्करण:

jQuery.fn.serializeObject = ->
  arrayData = @serializeArray()
  objectData = {}

  $.each arrayData, ->
    if @value?
      value = @value
    else
      value = ''

    if objectData[@name]?
      unless objectData[@name].push
        objectData[@name] = [objectData[@name]]

      objectData[@name].push value
    else
      objectData[@name] = value

  return objectData

I like samuels version, but I believe it has a small error. Normally JSON is sent as

{"coreSKU":"PCGUYJS","name_de":"whatever",...

NOT as

[{"coreSKU":"PCGUYJS"},{"name_de":"whatever"},...

so the function IMO should read:

App.toJson = function( selector ) {
    var o = {};
    $.map( $( selector ), function( n,i )
    {
        o[n.name] = $(n).val();
    });     
    return o;
}

and to wrap it in data array (as commonly expected, too), and finally send it as astring App.stringify( {data:App.toJson( '#cropform :input' )} )

For the stringify look at Question 3593046 for the lean version, at json2.js for the every-eventuality-covered version. That should cover it all :)


प्रत्येक तत्व की जांच किए बिना ऐसा करने का कोई तरीका नहीं है। आप वास्तव में क्या जानना चाहते हैं "क्या किसी और ने पहले से ही एक विधि लिखी है जो एक फॉर्म को JSON ऑब्जेक्ट में परिवर्तित करता है?" निम्नलिखित की तरह कुछ काम करना चाहिए - ध्यान दें कि यह केवल आपको फॉर्म तत्व देगा जो एक पोस्ट के माध्यम से वापस किया जाएगा (एक नाम होना चाहिए)। यह परीक्षण नहीं किया जाता है

function formToJSON( selector )
{
     var form = {};
     $(selector).find(':input[name]:enabled').each( function() {
         var self = $(this);
         var name = self.attr('name');
         if (form[name]) {
            form[name] = form[name] + ',' + self.val();
         }
         else {
            form[name] = self.val();
         }
     });

     return form;
}

JQuery के लिए ऐसा करने के लिए एक प्लगइन है, github.com/marioizquierdo/jquery.serializeJSON । मैंने इसे कुछ परियोजनाओं पर सफलतापूर्वक उपयोग किया है। यह एक सम्मोहन की तरह काम करता है।


तुम यह केर सकते हो:

var frm = $(document.myform);
var data = JSON.stringify(frm.serializeArray());

JSON देखें।


उपयोग:

function form_to_json (selector) {
  var ary = $(selector).serializeArray();
  var obj = {};
  for (var a = 0; a < ary.length; a++) obj[ary[a].name] = ary[a].value;
  return obj;
}

आउटपुट:

{"myfield": "myfield value", "passwordfield": "mypasswordvalue"}

ठीक है, मुझे पता है कि यह पहले से ही एक बहुत ही उग्र उत्तर है, लेकिन हाल ही में एक और समान सवाल पूछा गया था , और मुझे इस प्रश्न के लिए भी निर्देशित किया गया था। मैं अपना समाधान भी पेश करना चाहता हूं, क्योंकि यह स्वीकार्य समाधान पर एक लाभ प्रदान करता है: आप अक्षम फॉर्म तत्वों को शामिल कर सकते हैं (जो कि कभी-कभी महत्वपूर्ण होता है, यह निर्भर करता है कि आपका यूआई कैसे काम करता है)

अन्य SO प्रश्न से मेरा जवाब यहां दिया गया है:

प्रारंभ में, हम jQuery की serializeArray() विधि का उपयोग कर रहे थे, लेकिन इसमें अक्षम तत्व शामिल नहीं हैं। हम प्रायः फॉर्म तत्वों को अक्षम कर देंगे जो पृष्ठ पर अन्य स्रोतों के लिए "सिंक'd" हैं, लेकिन हमें अभी भी हमारे क्रमबद्ध ऑब्जेक्ट में डेटा शामिल करने की आवश्यकता है। तो serializeArray() बाहर है। हमने एक :input कंटेनर में सभी इनपुट तत्व (सक्षम और अक्षम दोनों) प्राप्त करने के लिए :input चयनकर्ता का उपयोग किया, और फिर हमारी ऑब्जेक्ट बनाने के लिए $.map()

var inputs = $("#container :input");
var obj = $.map(inputs, function(n, i)
{
    var o = {};
    o[n.name] = $(n).val();
    return o;
});
console.log(obj);

ध्यान दें कि इसके लिए काम करने के लिए, आपके प्रत्येक इनपुट को name विशेषता की आवश्यकता होगी, जो परिणामस्वरूप ऑब्जेक्ट की संपत्ति का नाम होगा।

वास्तव में हम जो भी इस्तेमाल करते हैं उससे थोड़ा संशोधित होता है। हमें एक ऑब्जेक्ट बनाने की आवश्यकता थी जिसे .NET IDictionary के रूप में संरचित किया गया था, इसलिए हमने इसका उपयोग किया: (यदि यह उपयोगी है तो मैं इसे यहां प्रदान करता हूं)

var obj = $.map(inputs, function(n, i)
{
    return { Key: n.name, Value: $(n).val() };
});
console.log(obj);

मुझे इन दोनों समाधानों को पसंद है, क्योंकि वे $.map() फ़ंक्शन का सरल उपयोग करते हैं, और आपके चयनकर्ता पर पूर्ण नियंत्रण होता है (इसलिए, आप अपने परिणामी ऑब्जेक्ट में कौन से तत्वों को समाप्त करते हैं)। इसके अलावा, कोई अतिरिक्त प्लगइन की आवश्यकता है। सादा पुराना jQuery।


एक-लाइनर (jQuery के अलावा कोई निर्भरता नहीं), map विधि में भेजे गए फ़ंक्शन के लिए निश्चित ऑब्जेक्ट बाइंडिंग का उपयोग करता है।

$('form').serializeArray().map(function(x){this[x.name] = x.value; return this;}.bind({}))[0]

यह क्या करता है?

"id=2&value=1&comment=ok" => Object { id: "2", value: "1", comment: "ok" }

प्रगतिशील वेब ऐप्स के लिए उपयुक्त (कोई आसानी से दोनों नियमित रूप से कार्रवाई के साथ-साथ AJAX अनुरोध सबमिट करने का समर्थन कर सकता है)


क्या गलत है:

var data = {};
$(".form-selector").serializeArray().map(function(x){data[x.name] = x.value;}); 

कुछ older उत्तर से:

$('form input,select').toArray().reduce(function(m,e){m[e.name] = $(e).val(); return m;},{})

किसी ऑब्जेक्ट में कुछ भी चालू करें (इकाई परीक्षण नहीं)

<script type="text/javascript">
string = {};

string.repeat = function(string, count)
{
    return new Array(count+1).join(string);
}

string.count = function(string)
{
    var count = 0;

    for (var i=1; i<arguments.length; i++)
    {
        var results = string.match(new RegExp(arguments[i], 'g'));
        count += results ? results.length : 0;
    }

    return count;
}

array = {};

array.merge = function(arr1, arr2)
{
    for (var i in arr2)
    {
        if (arr1[i] && typeof arr1[i] == 'object' && typeof arr2[i] == 'object')
            arr1[i] = array.merge(arr1[i], arr2[i]);
        else
            arr1[i] = arr2[i]
    }

    return arr1;
}

array.print = function(obj)
{
    var arr = [];
    $.each(obj, function(key, val) {
        var next = key + ": ";
        next += $.isPlainObject(val) ? array.print(val) : val;
        arr.push( next );
      });

    return "{ " +  arr.join(", ") + " }";
}

node = {};

node.objectify = function(node, params)
{
    if (!params)
        params = {};

    if (!params.selector)
        params.selector = "*";

    if (!params.key)
        params.key = "name";

    if (!params.value)
        params.value = "value";

    var o = {};
    var indexes = {};

    $(node).find(params.selector+"["+params.key+"]").each(function()
    {
        var name = $(this).attr(params.key),
            value = $(this).attr(params.value);

        var obj = $.parseJSON("{"+name.replace(/([^\[]*)/, function()
        {
            return '"'+arguments[1]+'"';
        }).replace(/\[(.*?)\]/gi, function()
        {
            if (arguments[1].length == 0)
            {
                var index = arguments[3].substring(0, arguments[2]);
                indexes[index] = indexes[index] !== undefined ? indexes[index]+1 : 0;

                return ':{"'+indexes[index]+'"';
            }
            else
                return ':{"'+escape(arguments[1])+'"';
        })+':"'+value.replace(/[\\"]/gi, function()
        {
            return "\\"+arguments[0]; 
        })+'"'+string.repeat('}', string.count(name, ']'))+"}");

        o = array.merge(o, obj);
    });

    return o;
}
</script>

परीक्षण का आउटपुट:

$(document).ready(function()
{
    console.log(array.print(node.objectify($("form"), {})));
    console.log(array.print(node.objectify($("form"), {selector: "select"})));
});

पर

<form>
    <input name='input[a]' type='text' value='text'/>
    <select name='input[b]'>
        <option>select</option>
    </select>

    <input name='otherinput[c][a]' value='a'/>
    <input name='otherinput[c][]' value='b'/>
    <input name='otherinput[d][b]' value='c'/>
    <input name='otherinput[c][]' value='d'/>

    <input type='hidden' name='anotherinput' value='hidden'/>
    <input type='hidden' name='anotherinput' value='1'/>

    <input type='submit' value='submit'/>
</form>

निकलेगा:

{ input: { a: text, b: select }, otherinput: { c: { a: a, 0: b, 1: d }, d: { b: c } }, anotherinput: 1 }
{ input: { b: select } }


serializeArray पहले से ही यह करता है। आपको बस अपने आवश्यक प्रारूप में डेटा मालिश करने की आवश्यकता है:

function objectifyForm(formArray) {//serialize data function

  var returnArray = {};
  for (var i = 0; i < formArray.length; i++){
    returnArray[formArray[i]['name']] = formArray[i]['value'];
  }
  return returnArray;
}

छिपे हुए फ़ील्ड के लिए देखें, जिनके पास वास्तविक इनपुट के समान नाम है क्योंकि वे ओवरराइट हो जाएंगे।


इस समस्या के लिए मैंने पाया सबसे सरल और सबसे सटीक तरीका बीबीक्यू प्लगइन या यह one (जो लगभग 0.5 के बाइट आकार है) का उपयोग करना था।

यह बहु आयामी सरणी के साथ भी काम करता है।

$.fn.serializeObject = function()
{
	return $.deparam(this.serialize());
};


For a quick, modern solution, use the JSONify jQuery plugin. The example below is taken verbatim from the GitHub README. All credit to Kushal Pandya, author of the plugin.

दिया हुआ:

<form id="myform">
    <label>Name:</label>
    <input type="text" name="name"/>
    <label>Email</label>
    <input type="text" name="email"/>
    <label>Password</label>
    <input type="password" name="password"/>
</form>

चल रहा है:

$('#myform').jsonify();

पैदा करता है:

{"name":"Joe User","email":"[email protected]","password":"mypass"}

If you want to do a jQuery POST with this JSON object:

$('#mybutton').click(function() {
    $.post('/api/user', JSON.stringify($('#myform').jsonify()));
}

इस फ़ंक्शन को समान नाम वाले एकाधिक तत्वों के साथ बहुआयामी सरणी को संभालना चाहिए।

मैं इसे अब तक कुछ वर्षों से उपयोग कर रहा हूं:

jQuery.fn.serializeJSON=function() {
  var json = {};
  jQuery.map(jQuery(this).serializeArray(), function(n, i) {
    var _ = n.name.indexOf('[');
    if (_ > -1) {
      var o = json;
      _name = n.name.replace(/\]/gi, '').split('[');
      for (var i=0, len=_name.length; i<len; i++) {
        if (i == len-1) {
          if (o[_name[i]]) {
            if (typeof o[_name[i]] == 'string') {
              o[_name[i]] = [o[_name[i]]];
            }
            o[_name[i]].push(n.value);
          }
          else o[_name[i]] = n.value || '';
        }
        else o = o[_name[i]] = o[_name[i]] || {};
      }
    }
    else {
      if (json[n.name] !== undefined) {
        if (!json[n.name].push) {
          json[n.name] = [json[n.name]];
        }
        json[n.name].push(n.value || '');
      }
      else json[n.name] = n.value || '';      
    }
  });
  return json;
};

Another answer

document.addEventListener("DOMContentLoaded", function() {
  setInterval(function() {
    var form = document.getElementById('form') || document.querySelector('form[name="userprofile"]');
    var json = Array.from(new FormData(form)).map(function(e,i) {this[e[0]]=e[1]; return this;}.bind({}))[0];
    
    console.log(json)
    document.querySelector('#asJSON').value = JSON.stringify(json);
  }, 1000);
})
<form name="userprofile" id="form">
  <p>Name <input type="text" name="firstname" value="John"/></p>
  <p>Family name <input name="lastname" value="Smith"/></p>
  <p>Work <input name="employment[name]" value="inc, Inc."/></p>
  <p>Works since <input name="employment[since]" value="2017" /></p>
  <p>Photo <input type="file" /></p>
  <p>Send <input type="submit" /></p>
</form>

JSON: <textarea id="asJSON"></textarea>

FormData: https://developer.mozilla.org/en-US/docs/Web/API/FormData


मुझे Array.prototype.reduce का उपयोग करना Array.prototype.reduce क्योंकि यह एक लाइनर है, और यह Underscore.js या इस तरह पर निर्भर नहीं है:

$('#formid').serializeArray()
    .reduce(function(a, x) { a[x.name] = x.value; return a; }, {});

यह Array.prototype.map का उपयोग कर उत्तर के समान है, लेकिन आपको अतिरिक्त ऑब्जेक्ट चर के साथ अपने दायरे को अव्यवस्थित करने की आवश्यकता नहीं है। एक स्थान पर खरीदारी।

महत्वपूर्ण नोट : डुप्लिकेट name विशेषता वाले इनपुट वाले फॉर्म मान्य HTML हैं, और वास्तव में एक आम दृष्टिकोण है। इस थ्रेड में किसी भी उत्तर का उपयोग उस मामले में अनुचित होगा (क्योंकि ऑब्जेक्ट कुंजी अद्वितीय होनी चाहिए)।


यदि आप Underscore.js का उपयोग कर रहे हैं तो आप अपेक्षाकृत संक्षिप्त उपयोग कर सकते हैं:

_.object(_.map($('#myform').serializeArray(), _.values))

फॉर्म को जेएसओएन की तरह एक बॉस में कनवर्ट करें

वर्तमान स्रोत GitHub और बोवर पर है।

$ bower jquery-serialize-object स्थापित करें

निम्नलिखित कोड अब बहिष्कृत है

निम्नलिखित कोड इनपुट नामों के सभी प्रकार के साथ काम कर सकते हैं; और जैसे ही आप उम्मीद करेंगे उन्हें संभालें।

उदाहरण के लिए:

<!-- all of these will work! -->
<input name="honey[badger]" value="a">
<input name="wombat[]" value="b">
<input name="hello[panda][]" value="c">
<input name="animals[0][name]" value="d">
<input name="animals[0][breed]" value="e">
<input name="crazy[1][][wonky]" value="f">
<input name="dream[as][vividly][as][you][can]" value="g">
// output
{
  "honey":{
    "badger":"a"
  },
  "wombat":["b"],
  "hello":{
    "panda":["c"]
  },
  "animals":[
    {
      "name":"d",
      "breed":"e"
    }
  ],
  "crazy":[
    null,
    [
      {"wonky":"f"}
    ]
  ],
  "dream":{
    "as":{
      "vividly":{
        "as":{
          "you":{
            "can":"g"
          }
        }
      }
    }
  }
}

प्रयोग

$('#my-form').serializeObject();

जादूगर (जावास्क्रिप्ट)

(function($){
    $.fn.serializeObject = function(){

        var self = this,
            json = {},
            push_counters = {},
            patterns = {
                "validate": /^[a-zA-Z][a-zA-Z0-9_]*(?:\[(?:\d*|[a-zA-Z0-9_]+)\])*$/,
                "key":      /[a-zA-Z0-9_]+|(?=\[\])/g,
                "push":     /^$/,
                "fixed":    /^\d+$/,
                "named":    /^[a-zA-Z0-9_]+$/
            };


        this.build = function(base, key, value){
            base[key] = value;
            return base;
        };

        this.push_counter = function(key){
            if(push_counters[key] === undefined){
                push_counters[key] = 0;
            }
            return push_counters[key]++;
        };

        $.each($(this).serializeArray(), function(){

            // skip invalid keys
            if(!patterns.validate.test(this.name)){
                return;
            }

            var k,
                keys = this.name.match(patterns.key),
                merge = this.value,
                reverse_key = this.name;

            while((k = keys.pop()) !== undefined){

                // adjust reverse_key
                reverse_key = reverse_key.replace(new RegExp("\\[" + k + "\\]$"), '');

                // push
                if(k.match(patterns.push)){
                    merge = self.build([], self.push_counter(reverse_key), merge);
                }

                // fixed
                else if(k.match(patterns.fixed)){
                    merge = self.build([], k, merge);
                }

                // named
                else if(k.match(patterns.named)){
                    merge = self.build({}, k, merge);
                }
            }

            json = $.extend(true, json, merge);
        });

        return json;
    };
})(jQuery);

मास्क के समाधान का उपयोग करके, मैंने इसे एएसपी.नेट एमवीसी के समान तरीके से अपने नेस्टेड / जटिल वस्तुओं को संभालने के तरीके के साथ काम करने के लिए संशोधित किया। आपको बस इतना करना है कि इस पर वैध टुकड़ा संशोधित करें:

"validate": /^[a-zA-Z][a-zA-Z0-9_]*((?:\[(?:\d*|[a-zA-Z0-9_]+)\])*(?:\.)[a-zA-Z][a-zA-Z0-9_]*)*$/,

यह मिलान करेगा और उसके बाद नामों के साथ सही ढंग से तत्वों को मानचित्र करेगा:

<input type="text" name="zooName" />

तथा

<input type="text" name="zooAnimals[0].name" />

मुझे चयनित समाधान के साथ एक समस्या मिली।

सरणी आधारित नाम वाले रूपों का उपयोग करते समय jQuery serializeArray () फ़ंक्शन वास्तव में मर जाता है।

मेरे पास एक PHP ढांचा है जो सरणी-आधारित फ़ील्ड नामों का उपयोग करता है ताकि एक ही फॉर्म को एकाधिक दृश्यों में एक ही पृष्ठ पर कई बार रखा जा सके। विरोधाभासी रूप मॉडल के बिना एक ही पृष्ठ पर दोनों को जोड़ने, संपादित करने और हटाने के लिए यह आसान हो सकता है।

चूंकि मैं इस पूर्ण आधार कार्यक्षमता को लेने के बिना फॉर्मों को क्रमबद्ध करना चाहता था, इसलिए मैंने अपना खुद का seralizeArray () लिखने का फैसला किया:

        var $vals = {};

        $("#video_edit_form input").each(function(i){
            var name = $(this).attr("name").replace(/editSingleForm\[/i, '');

            name = name.replace(/\]/i, '');

            switch($(this).attr("type")){
                case "text":
                    $vals[name] = $(this).val();
                    break;
                case "checkbox":
                    if($(this).attr("checked")){
                        $vals[name] = $(this).val();
                    }
                    break;
                case "radio":
                    if($(this).attr("checked")){
                        $vals[name] = $(this).val();
                    }
                    break;
                default:
                    break;
            }
        });

कृपया ध्यान दें: यह फॉर्म सबमिट () के बाहर भी काम करता है, इसलिए यदि आपके शेष कोड में कोई त्रुटि उत्पन्न होती है तो फॉर्म सबमिट नहीं होगा यदि आप "परिवर्तन सहेजें" कहकर लिंक बटन पर रहते हैं।

यह भी ध्यान रखें कि सत्यापन के लिए सर्वर-साइड को भेजने के लिए डेटा एकत्र करने के लिए केवल इस फ़ॉर्म को फ़ॉर्म को सत्यापित करने के लिए इस फ़ंक्शन का उपयोग नहीं किया जाना चाहिए। ऐसे कमजोर और बड़े पैमाने पर असाइन किए गए कोड का उपयोग करने से XSS , इत्यादि का कारण बन जाएगा।


मैं इस दृष्टिकोण को पसंद करता हूं क्योंकि: आपको 2 संग्रहों को फिर से शुरू करने की आवश्यकता नहीं है, यदि आपको आवश्यकता हो तो आप "नाम" और "मूल्य" के अलावा अन्य चीज़ों पर जा सकते हैं, और आप ऑब्जेक्ट में उन्हें स्टोर करने से पहले अपने मूल्यों को स्वच्छ कर सकते हैं ( यदि आपके पास डिफ़ॉल्ट मान हैं जिन्हें आप स्टोर नहीं करना चाहते हैं, उदाहरण के लिए)।

$.formObject = function($o) {
    var o = {},
        real_value = function($field) {
            var val = $field.val() || "";

            // additional cleaning here, if needed

            return val;
        };

    if (typeof o != "object") {
        $o = $(o);
    }

    $(":input[name]", $o).each(function(i, field) {
        var $field = $(field),
            name = $field.attr("name"),
            value = real_value($field);

        if (o[name]) {
            if (!$.isArray(o[name])) {
                o[name] = [o[name]];
            }

            o[name].push(value);
        }

        else {
            o[name] = value;
        }
    });

    return o;
}

इस तरह प्रयोग करें:

var obj = $.formObject($("#someForm"));

केवल फ़ायरफ़ॉक्स में परीक्षण किया गया।


एक बात यह है कि उपरोक्त समाधानों को ध्यान में नहीं रखा जाता है यदि आपके पास इनपुट की एक सरणी है लेकिन केवल एक मूल्य प्रदान किया गया था।

उदाहरण के लिए, यदि बैक एंड लोगों की एक सरणी की अपेक्षा करता है, लेकिन इस विशेष मामले में, आप केवल एक व्यक्ति से निपट रहे हैं। फिर कर रहे हैं:

<input type="hidden" name="People" value="Joe" />

फिर पिछले समाधानों के साथ, यह सिर्फ कुछ ऐसा करने के लिए मैप करेगा:

{
    "People" : "Joe"
}

लेकिन यह वास्तव में मानचित्र करना चाहिए

{
    "People" : [ "Joe" ]
}

इसे ठीक करने के लिए, इनपुट इस तरह दिखना चाहिए:

<input type="hidden" name="People[]" value="Joe" />

और आप निम्न फ़ंक्शन का उपयोग करेंगे (अन्य समाधानों के आधार पर, लेकिन थोड़ा बढ़ाया गया है)

$.fn.serializeObject = function() {
var o = {};
var a = this.serializeArray();
$.each(a, function() {
    if (this.name.substr(-2) == "[]"){
        this.name = this.name.substr(0, this.name.length - 2);
        o[this.name] = [];
    }

    if (o[this.name]) {
        if (!o[this.name].push) {
            o[this.name] = [o[this.name]];
        }
        o[this.name].push(this.value || '');
    } else {
        o[this.name] = this.value || '';
    }
});
return o;
};




jquery json serialization