如何将表单的所有元素转换为JavaScript对象？

我想有一些方法从我的表单中自动构建一个JavaScript对象，而不必遍历每个元素 . 我不想要 $('#formid').serialize(); 返回的字符串，也不想要 $('#formid').serializeArray(); 返回的 Map

30 回答

5

我自己将一个表单编码为多维JavaScript对象，以便在生产环境中使用它 . 结果是https://github.com/serbanghita/formToObject.js .

回复于 2024-04-29T09:18:38+08:00

此函数应处理多维数组以及具有相同名称的多个元素 .

到目前为止，我已经使用它几年了：

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;
};

回复于 2024-04-29T09:18:38+08:00

1
简洁是最好的 . 我使用了一个简单的字符串替换为正则表达式，到目前为止它们就像一个魅力 . 我不是正则表达专家，但我敢打赌，你甚至可以填充非常复杂的对象 .
```
var values = $(this).serialize(),
attributes = {};

values.replace(/([^&]+)=([^&]*)/g, function (match, name, value) {
    attributes[name] = value;
});
```
回复于 2024-04-29T09:18:38+08:00
1574
我发现所选解决方案存在问题 .

当使用具有基于数组的名称的表单时，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;
            }
        });
```
请注意：这也可以在表单submit（）之外工作，因此如果您的代码的其余部分发生错误，如果您放置在“保存更改”的链接按钮上，表单将不会提交 .

另请注意，此函数永远不应用于验证表单，仅用于收集要发送到服务器端进行验证的数据 . 使用这种弱和批量分配的代码会导致XSS等 .
回复于 2024-04-29T09:18:38+08:00

我更喜欢这种方法，因为：您不必迭代2个集合，如果需要，您可以获取除“name”和“value”之外的其他内容，并且可以在将值存储在对象中之前清理它们的值（如果您有默认值，您不希望存储，例如） .

$.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"));

仅在Firefox中测试过 .

回复于 2024-04-29T09:18:38+08:00

Tobias Cohen解决方案的固定版本 . 这个正确处理像 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;
};

还有CoffeeScript版本，方便您编码：

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

回复于 2024-04-29T09:18:38+08:00

使用lodash#set

let serialized = [
  { key: 'data[model][id]', value: 1 },
  { key: 'data[model][name]', value: 'product' },
  { key: 'sid', value: 'dh0un1hr4d' }
];

serialized.reduce(function(res, item) {
  _.set(res, item.key, item.value);
  return res;
}, {});

// returns
{
  "data": {
    "model": {
      "id": 1,
      "name": "product"
    }
  },
  "sid": "dh0un1hr4d"
}

回复于 2024-04-29T09:18:38+08:00

260
我发现这个问题的最简单和最准确的方法是使用bbq plugin或者这个one（大小约为0.5K字节） .

it also works with multi dimensional arrays.
```
$.fn.serializeObject = function()
{
	return $.deparam(this.serialize());
};
```
回复于 2024-04-29T09:18:38+08:00

你可以这样做：

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

见JSON .

回复于 2024-04-29T09:18:38+08:00

出了什么问题：

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

回复于 2024-04-29T09:18:38+08:00

Turn anything into an object (not unit tested)

<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 } }

回复于 2024-04-29T09:18:38+08:00

由于XSS攻击以及可能还有很多其他问题，我不会在现场网站上使用它，但这里有一个简单的例子说明你可以做什么：

$("#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;
});

回复于 2024-04-29T09:18:38+08:00

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;
}

注意与实际输入同名的隐藏字段，因为它们将被覆盖 .

回复于 2024-04-29T09:18:38+08:00

要获得快速，现代的解决方案，请使用JSONify jQuery插件 . 下面的示例是从GitHub自述文件中逐字记录的 . 所有这些都归功于该插件的作者Kushal Pandya .

鉴于：

<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":"joe@example.com","password":"mypass"}

如果你想用这个JSON对象做一个jQuery POST：

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

回复于 2024-04-29T09:18:38+08:00

将表单转换为JSON LIKE A BOSS

当前来源是GitHub和bower .

$ 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();

巫术（JavaScript）

(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);

回复于 2024-04-29T09:18:38+08:00

52

所有这些答案对我来说都是如此 . 为简单起见，有一些话要说 . 只要你的所有表单输入都有name属性设置，这应该只是jim dandy .

$（'form.myform'） . submit（function（）{
var $ this = $（this）
，viewArr = $ this.serializeArray（）
，view = {};

for（var i in viewArr）{
view [viewArr [i] .name] = viewArr [i] .value;
}

//在这里查看视图对象（例如JSON.stringify？）
}）;

回复于 2024-04-29T09:18:38+08:00
3
单行（除了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请求）
回复于 2024-04-29T09:18:38+08:00
6
如果您使用Underscore.js，您可以使用相对简洁的：
```
_.object(_.map($('#myform').serializeArray(), _.values))
```
回复于 2024-04-29T09:18:38+08:00

从一些older回答：

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

回复于 2024-04-29T09:18:38+08:00

2
我喜欢samuels版本，但我相信它有一个小错误 . 通常JSON发送为

{“coreSKU”：“PCGUYJS”，“name_de”：“不管”，......

不是

[{“coreSKU”：“PCGUYJS”}，{“name_de”：“what”}，...

所以IMO的功能应该读：
```
App.toJson = function( selector ) {
    var o = {};
    $.map( $( selector ), function( n,i )
    {
        o[n.name] = $(n).val();
    });     
    return o;
}
```
并将其包装在数据数组中（通常也是如此），最后将其作为astring App.stringify发送（{data：App.toJson（'#cropform：input'）}）

对于stringify，请查看精简版本的Question 3593046，在json2.js处查看每个可能性的版本 . 这应该涵盖所有:)
回复于 2024-04-29T09:18:38+08:00
11
好吧，我知道这已经有了一个高度赞成的答案，但最近又有了另一个similar question was asked，我也被引导到了这个问题 . 我也想提供我的解决方案，因为它提供了优于已接受解决方案的优势：您可以包含已禁用的表单元素（这有时很重要，具体取决于您的UI功能）

以下是other SO question的答案：

最初，我们使用jQuery的 serializeArray() 方法，但不包括禁用的表单元素 . 我们经常会将"sync'd"的表单元素禁用到页面上的其他源，但我们仍然需要将数据包含在序列化对象中 . 所以 serializeArray() 已经出局了 . 我们使用 :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 .
回复于 2024-04-29T09:18:38+08:00
11
使用maček's solution，我修改它以使用ASP.NET MVC在同一表单上处理其嵌套/复杂对象的方式 . 您所要做的就是将验证件修改为：
```
"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" />
```
回复于 2024-04-29T09:18:38+08:00

没有检查每个元素就没有办法做到这一点 . 您真正想知道的是"has someone else already written a method that converts a form to a JSON object?"以下内容应该有效 - 请注意，它只会为您提供通过POST返回的表单元素（必须具有名称） . 这是 not tested .

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;
}

回复于 2024-04-29T09:18:38+08:00

所有的给定答案有一些问题是......

如果输入名称像 name[key] 那样的数组，但它会像这样生成

name:{
   key : value
 }

For Example : 如果我有这样的形式 .

<form>
        <input name="name" value="value" >
        <input name="name1[key1]" value="value1" >
        <input name="name2[key2]" value="value2" >
        <input name="name3[key3]" value="value3" >
    </form>

然后它将使用所有给定的答案生成这样的对象 .

Object {
    name : 'value',
    name1[key1] : 'value1',
    name2[key2] : 'value2',
    name3[key3] : 'value3', 
}

但它必须生成如下所示，任何人都希望如下所示 .

Object {
    name : 'value',
    name1 : {
        key1 : 'value1'
    },
    name2 : {
        key2 : 'value2'
    },
    name3 : {
        key2 : 'value2'
    }
}

然后在js代码下面试试这个 .

(function($){
    $.fn.getForm2obj = function(){
        var _ = {},_t=this;
        this.c = function(k,v){ eval("c = typeof "+k+";"); if(c == 'undefined') _t.b(k,v);}
        this.b = function(k,v,a = 0){ if(a) eval(k+".push("+v+");"); else eval(k+"="+v+";"); };
        $.map(this.serializeArray(),function(n){
            if(n.name.indexOf('[') > -1 ){
                var keys = n.name.match(/[a-zA-Z0-9_]+|(?=\[\])/g),le = Object.keys(keys).length,tmp = '_';
                $.map(keys,function(key,i){
                    if(key == ''){
                        eval("ale = Object.keys("+tmp+").length;");
                        if(!ale) _t.b(tmp,'[]');
                        if(le == (i+1)) _t.b(tmp,"'"+n['value']+"'",1);
                        else _t.b(tmp += "["+ale+"]",'{}');
                    }else{
                        _t.c(tmp += "['"+key+"']",'{}');
                        if(le == (i+1)) _t.b(tmp,"'"+n['value']+"'");
                    }
                });
            }else _t.b("_['"+n['name']+"']","'"+n['value']+"'");
        });
        return _;
    }
})(jQuery);
console.log($('form').getForm2obj());

<!DOCTYPE html><html><head>
    <script src="https://code.jquery.com/jquery-3.2.1.min.js"></script>
    <title>Convert form data to JavaScript object with jQuery</title>
</head>
<body>
    <form>
        <input name="name" value="value" >
        <input name="name1[key1]" value="value1" >
        <input name="name2[key2]" value="value2" >
        <input name="name3[key3]" value="value3" >
        <input type="checkbox" name="name4[]" value="1" checked="checked">
        <input type="checkbox" name="name4[]" value="2">
        <input type="checkbox" name="name4[]" value="3">
    </form>
</body></html>

回复于 2024-04-29T09:18:38+08:00

100

另一个答案

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

回复于 2024-04-29T09:18:38+08:00

使用：

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"}

回复于 2024-04-29T09:18:38+08:00

2
我最近遇到了同样的问题，并推出了this .toJSON jQuery plugin，它将表单转换为具有相同结构的JSON对象 . 这对于动态生成的表单尤其有用，您希望让用户在特定位置添加更多字段 .

关键是你可能真的想要构建一个表单，以便它本身就有一个结构，所以假设你想创建一个表单，用户在城里插入他最喜欢的地方：你可以想象这个表单代表一个 <places>...</places> XML元素用户喜欢的地方列表，因此列出 <place>...</place> 元素，每个元素包含例如 <name>...</name> 元素， <type>...</type> 元素，然后是 <activity>...</activity> 元素列表，以表示您可以在这样的地方执行的活动 . 所以你的XML结构是这样的：
```
<places>

    <place>

        <name>Home</name>
        <type>dwelling</type>

        <activity>sleep</activity>
        <activity>eat</activity>
        <activity>watch TV</activity>

    </place>

    <place>...</place>

    <place>...</place>

</places>
```
如果有一个JSON对象可以代表这个确切的结构，那将是多么酷，所以你将能够：
- 将此对象存储在任何类似CouchDB的数据库中
- 从$ _POST []服务器端读取它并检索正确嵌套的数组，然后可以进行语义操作
- 使用一些服务器端脚本将其转换为格式良好的XML文件（即使您不知道其先验的确切结构）
- 只是以某种方式使用它，因为它在任何Node.js类似的服务器脚本中
好的，现在我们需要考虑一个表单如何表示XML文件 .

当然 <form> 标签是 root ，但是我们有 <place> 元素，它是一个容器而不是数据元素本身，所以我们不能使用输入标签 .

这是 <fieldset> 标签派上用场的地方！我们将使用 <fieldset> 标记来表示表单/ XML表示中的所有容器元素，因此得到如下结果：
```
<form name="places">

    <fieldset name="place">

        <input type="text" name="name"/>
        <select name="type">
            <option value="dwelling">Dwelling</option>
            <option value="restoration">Restoration</option>
            <option value="sport">Sport</option>
            <option value="administrative">Administrative</option>
        </select>

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

    </fieldset>

</form>
```
正如你在这种形式中看到的那样，我们打破了唯一名称的规则，但这没关系，因为它们将被转换为元素数组，因此它们只能通过数组中的索引来引用 .

此时你可以看到表单里面没有 name="array[]" 这样的名字，一切都很漂亮，简单和语义 .

现在我们想要这个表格要转换为JSON对象，如下所示：
```
{'places':{

    'place':[

        {

            'name': 'Home',
            'type': 'dwelling',

            'activity':[

                 'sleep',
                 'eat',
                 'watch TV'

            ]

        },

        {...},

        {...}

    ]

}}
```
为此，我开发了this jQuery plugin here，有人在this Code Review thread帮助优化，看起来像这样：
```
$.fn.toJSO = function () {
    var obj = {},
        $kids = $(this).children('[name]');
    if (!$kids.length) {
        return $(this).val();
    }
    $kids.each(function () {
        var $el = $(this),
            name = $el.attr('name');
        if ($el.siblings("[name=" + name + "]").length) {
            if (!/radio|checkbox/i.test($el.attr('type')) || $el.prop('checked')) {
                obj[name] = obj[name] || [];
                obj[name].push($el.toJSO());
            }
        } else {
            obj[name] = $el.toJSO();
        }
    });
    return obj;
};
```
我还让this one blog post解释了这一点 .

这会将表单中的所有内容转换为JSON（甚至是收音机和复选框），您将要做的就是调用
```
$.post('script.php',('form').toJSO(), ...);
```
我知道有很多方法可以将表单转换为JSON对象，并确保 .serialize() 和 .serializeArray() 在大多数情况下工作得很好并且主要用于使用，但我认为将表单编写为具有有意义名称的XML结构并将其转换为完整的想法进入一个结构良好的JSON对象是值得尝试的，如果您需要检索动态生成的表单数据，那么您可以添加同名输入标记而无需担心这一事实非常有用 .

我希望这可以帮助别人！
回复于 2024-04-29T09:18:38+08:00

我发现托比亚斯科恩的代码存在问题（我没有足够的意见直接评论它），否则这对我有用 . 如果您有两个具有相同名称的选项，两者都带有值=“”，则原始代码将生成“name”：“”而不是“name”：[“”，“”]

我认为这可以通过在第一个if条件中添加“|| o [this.name] ==''”来解决：

$.fn.serializeObject = function()
{
    var o = {};
    var a = this.serializeArray();
    $.each(a, function() {
        if (o[this.name] || 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;
};

回复于 2024-04-29T09:18:38+08:00

417

有一个插件可以为jQuery，jquery.serializeJSON做到这一点 . 我现在已成功地在一些项目中使用它 . 它就像一个魅力 .

回复于 2024-04-29T09:18:38+08:00
3
我喜欢使用 Array.prototype.reduce 因为's a one-liner, and it doesn' t依赖于Underscore.js之类：
```
$('#formid').serializeArray()
    .reduce(function(a, x) { a[x.name] = x.value; return a; }, {});
```
这与使用 Array.prototype.map 的答案类似，但您不需要使用其他对象变量来混淆范围 . 一站式购物 .

IMPORTANT NOTE ：具有重复 name 属性的输入的表单是有效的HTML，实际上是一种常见方法 . 在这种情况下，使用此线程中的任何答案都是不合适的（因为对象键必须是唯一的） .
回复于 2024-04-29T09:18:38+08:00

使用jQuery将表单数据转换为JavaScript对象

30 回答

将表单转换为JSON LIKE A BOSS

现在不推荐使用以下代码 .

用法

巫术（JavaScript）

相关问题