दिलचस्प पोस्ट
मैं कैसे easy_install vcvarsall.bat को इंगित कर सकता हूँ? MySQL में पैसे के मूल्यों को स्टोर करने के लिए सर्वश्रेष्ठ डेटा प्रकार क्या जावास्क्रिप्ट का यह उद्देश्य नए तरीके से बनाई गई वस्तु को संदर्भित करता है एंड्रॉइड मैप एपीआई वी 2 में मार्कर कैसे एनीमेट करें? एंड्रॉइड ==> मेमोरी विश्लेषण ==> एक्लिप्स स्मृति विश्लेषक? आर में अपॉस्ट्रॉप्स को छोड़कर सभी विराम चिह्न निकालें क्या एनएसएएलओएर्ब्रिब्रील लोड्स को हाँ पर सेट करते समय एप स्टोर को अस्वीकार कर दिया जाता है? सफारी से ऐप या ऐप स्टोर लाँच करना? फ़ील्ड द्वारा PHP क्रमबद्ध सरणी? एमआईपीएस लिंक सूची मठ अभिव्यक्ति पार्स बाल तत्व पाठ सहित बिना सेलेनियम वेबड्राइवर (पायथन एपीआई के माध्यम से) के एक तत्व का टेक्स्ट कैसे प्राप्त करें? पीआईएल का प्रयोग करके पिक्सेल की आरजीबी प्राप्त करें JSON वस्तु इंटरनेट एक्सप्लोरर 8 में अनिर्धारित है आईओएस में परिपत्र प्रगति बार

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

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

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

वेब के समाधान से एकत्रित समाधान "JQuery के साथ जावास्क्रिप्ट ऑब्जेक्ट के रूप में फॉर्म डेटा कन्वर्ट करें"

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

छिपे हुए क्षेत्रों के लिए देखें जो कि वास्तविक निविष्टियों के समान नाम रखते हैं, क्योंकि उन्हें अधिलेखित किया जाएगा।

एक बॉस की तरह JSON के रूप में रूपांतरित करें


वर्तमान स्रोत GitHub और कगार पर है

$ कगार स्थापित 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); 

क्या गलत है:

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

टोबीस कोहेन के समाधान का एक निश्चित संस्करण यह एक सही तरह से झूठी मूल्यों को संभालता है जैसे 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 

मुझे 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 हैं, और वास्तव में एक सामान्य दृष्टिकोण है इस धागे में दिए गए किसी भी उत्तर का उपयोग उस मामले में अनुचित होगा (चूंकि ऑब्जेक्ट की कुंजी अद्वितीय होना चाहिए)

ये सभी उत्तर शीर्ष पर मेरे लिए इतना लग रहा था सादगी के लिए कहा जाने वाला कुछ है जब तक आपके सभी फॉर्म इनप्लॉम्स में नाम विशेषता सेट हो, यह सिर्फ जैम डंडी का काम करना चाहिए।

 $('form.myform').submit(function () { var $this = $(this) , viewArr = $this.serializeArray() , view = {}; for (var i in viewArr) { view[viewArr[i].name] = viewArr[i].value; } //Do stuff with view object here (eg JSON.stringify?) }); 

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

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

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

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

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

यहाँ अन्य SO प्रश्न से मेरा जवाब है:

प्रारंभ में, हम jQuery के serializeArray() विधि का उपयोग कर रहे थे, लेकिन इसमें ऐसे फॉर्म तत्व शामिल नहीं हैं जो अक्षम हैं। हम अक्सर पृष्ठ पर अन्य स्रोतों के "सिंक्रैटेड" फ़ॉर्म तत्वों को अक्षम कर देंगे, लेकिन हमें अब भी हमारे सीरिजलाइज्ड ऑब्जेक्ट में डेटा शामिल करना होगा। तो 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 आईडीरीज़ के रूप में संरचित किया गया था, इसलिए हमने इसे उपयोग किया था: (मैं इसे यहां उपलब्ध कराने के मामले में यह उपयोगी है)

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

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

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

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

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

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

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

चौड़ाई सभी को देखते हुए वहाँ कुछ समस्या है …

यदि name[key] तरह सरणी के रूप में इनपुट नाम है, लेकिन यह इस तरह उत्पन्न होगा

  name:{ key : value } 

उदाहरण के लिए: यदि मेरे पास इस तरह का फ़ॉर्म है I

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

फिर इसे जेएस कोड से नीचे की कोशिश करें।

 function getFormData2Object(form){ var un_array = form.serializeArray(); var _array = {}; $.map(un_array, function(n, i){ if(n.name.indexOf('[') > -1 ){ var array = n.name.match(/\[(.*?)\]/); var key = n.name.replace(array[1],"").replace('[',"").replace(']',""); if(!_array[key]){ _array[key] = {}; } _array[key][array[1]] = n['value']; }else{ _array[n['name']] = n['value']; } }); return _array; } getFormData2Object($('form')) 

सरलता यहाँ सबसे अच्छा है। मैंने एक नियमित स्ट्रिंग का इस्तेमाल नियमित अभिव्यक्ति के साथ किया है, और उन्होंने इस प्रकार एक आकर्षण की तरह काम किया है। मैं एक नियमित अभिव्यक्ति विशेषज्ञ नहीं हूँ, लेकिन मुझे यकीन है कि आप बहुत जटिल ऑब्जेक्ट्स भी आबाद कर सकते हैं।

 var values = $(this).serialize(), attributes = {}; values.replace(/([^&]+)=([^&]*)/g, function (match, name, value) { attributes[name] = value; }); 

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

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

कुछ पुराने उत्तर से:

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

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

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

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

मुझे टोबीस कोहेन कोड के साथ एक समस्या मिली (मेरे पास इस पर सीधे टिप्पणी करने के लिए पर्याप्त अंक नहीं हैं), जो अन्यथा मेरे लिए काम करता है यदि आपके पास एक ही नाम के साथ दो विकल्प हैं, दोनों मूल्य = "" के साथ, मूल कोड "नाम" उत्पन्न करेगा: "" के बजाय "" ":" "[", ""]]

मुझे लगता है कि यह "" [ओ [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; }; 

यदि आप अजैक्स के माध्यम से यह फ़ॉर्म सबमिट करने के लिए JSON में सभी फ़ॉर्म फ़ील्ड कन्वर्ट करने की कोशिश कर रहे हैं तो ये एक ऐसा jQuery फॉर्म प्लगइन है जो ऐसा करता है।

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

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

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

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

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

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

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

  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 , आदि हो जाएगा

मैं हाल ही में एक ही समस्या थी और इस के साथ बाहर आया .to JSON jQuery प्लगइन जो एक ही संरचना के साथ एक JSON ऑब्जेक्ट में एक प्रपत्र धर्मान्तरित। यह गतिशील रूप से उत्पन्न रूपों के लिए भी उपयोगी है, जहां आप अपने उपयोगकर्ता को विशिष्ट स्थानों में और अधिक फ़ील्ड जोड़ना चाहते हैं।

बात यह है कि आप वास्तव में एक फार्म का निर्माण करना चाहते हैं ताकि इसकी एक संरचना हो, तो हम कहते हैं कि आप एक ऐसा फॉर्म बनाना चाहते हैं जहां उपयोगकर्ता शहर में अपने पसंदीदा स्थान सम्मिलित करता है: आप इस फॉर्म को <places>...</places> प्रतिनिधित्व के लिए कल्पना कर सकते हैं <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 ऑब्जेक्ट के साथ कितना शांत होगा, जो इस सटीक संरचना का प्रतिनिधित्व करेगा, ताकि आप या तो सक्षम हो सकें:

  • इस ऑब्जेक्ट को स्टोर करें क्योंकि यह किसी भी काउचडी -जैसे डेटाबेस में है
  • इसे अपने $ _POST [] सर्वर साइड से पढ़ें और एक सही ढंग से नेस्टेड ऐरे को फिर से खोलें, जिससे आप अर्थपूर्ण ढंग से हेरफेर कर सकते हैं
  • कुछ सर्वर-साइड स्क्रिप्ट का उपयोग करके इसे एक अच्छी तरह से बनाई गई XML फ़ाइल में परिवर्तित करें (भले ही आपको इसकी सटीक संरचना ए- प्राथमिकता नहीं पता हो)
  • किसी भी तरह इसे उपयोग करें क्योंकि यह किसी भी Node.js- समान सर्वर स्क्रिप्ट में है

ठीक है, तो अब हमें यह सोचने की ज़रूरत है कि कोई फॉर्म XML फ़ाइल का प्रतिनिधित्व कैसे कर सकता है।

बेशक <form> टैग root , लेकिन फिर हमारे पास वह <place> है जो एक कंटेनर है और एक डेटा तत्व नहीं है, इसलिए हम इसके लिए इनपुट टैग का उपयोग नहीं कर सकते।

यह वह जगह है जहां <fieldset> टैग काम में आता है! हम अपने फार्म / एक्सएमएल प्रस्तुति में सभी कंटेनर तत्वों का प्रतिनिधित्व करने के लिए <fieldset> टैग का उपयोग करेंगे और इसलिए इस तरह से परिणाम प्राप्त करना होगा:

 <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[]" नहीं है name="array[]" और सब कुछ सुंदर, सरल और अर्थपूर्ण है

Now we want this form to be converted into a JSON object which will look like this:

 {'places':{ 'place':[ { 'name': 'Home', 'type': 'dwelling', 'activity':[ 'sleep', 'eat', 'watch TV' ] }, {...}, {...} ] }} 

To do this I have developed this jQuery plugin here which someone helped optimizing in this Code Review thread and looks like this:

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

I also made this one blog post to explain this more.

This converts everything in a form to JSON (even radio and check boxes) and all you'll have left to do is call

 $.post('script.php',('form').toJSO(), ...); 

I know there's plenty of ways to convert forms into JSON objects and sure .serialize() and .serializeArray() work great in most cases and are mostly intended to be used, but I think this whole idea of writing a form as an XML structure with meaningful names and converting it into a well-formed JSON object is worth the try, also the fact you can add same-name input tags without worrying is very useful if you need to retrive dynamically generated forms data.

I hope this helps someone!

One-liner (no dependencies other than jQuery), uses fixed object binding for function passsed to map method.

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

What it does?

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

suitable for progressive web apps (one can easily support both regular form submit action as well as ajax requests)

I prefer this approach because: you don't have to iterate over 2 collections, you can get at things other than "name" and "value" if you need to, and you can sanitize your values before you store them in the object (if you have default values that you don't wish to store, for example).

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

Use like so:

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

Only tested in Firefox.

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.

Given:

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

Running:

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

Produces:

 {"name":"Joe User","email":"joe@example.com","password":"mypass"} 

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

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

I coded a form to a multidimensional JavaScript object myself to use it in production. The result is https://github.com/serbanghita/formToObject.js .

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

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 🙂

If you are sending a form with JSON you must remove [] in sending the string. You can do that with the jQuery function serializeObject():

 var frm = $(document.myform); var data = JSON.stringify(frm.serializeObject()); $.fn.serializeObject = function() { var o = {}; //var a = this.serializeArray(); $(this).find('input[type="hidden"], input[type="text"], input[type="password"], input[type="checkbox"]:checked, input[type="radio"]:checked, select').each(function() { if ($(this).attr('type') == 'hidden') { //If checkbox is checked do not take the hidden field var $parent = $(this).parent(); var $chb = $parent.find('input[type="checkbox"][name="' + this.name.replace(/\[/g, '\[').replace(/\]/g, '\]') + '"]'); if ($chb != null) { if ($chb.prop('checked')) return; } } if (this.name === null || this.name === undefined || this.name === '') return; var elemValue = null; if ($(this).is('select')) elemValue = $(this).find('option:selected').val(); else elemValue = this.value; if (o[this.name] !== undefined) { if (!o[this.name].push) { o[this.name] = [o[this.name]]; } o[this.name].push(elemValue || ''); } else { o[this.name] = elemValue || ''; } }); return o; }