json array - Konvertieren von Formulardaten in JavaScript-Objekte mit jQuery




to object (25)

Wie konvertiere ich alle Elemente meines Formulars in ein JavaScript-Objekt?

Ich möchte eine Möglichkeit haben, automatisch ein JavaScript-Objekt aus meinem Formular zu erstellen, ohne jedes Element durchlaufen zu müssen. Ich will keine Zeichenkette, wie von $('#formid').serialize(); Ich möchte auch nicht, dass die Map von $('#formid').serializeArray();


Answers

Benutzen:

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

Ausgabe:

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


Mit der Lösung von Maček änderte ich die Funktionsweise so, dass ASP.NET MVC ihre verschachtelten / komplexen Objekte auf demselben Formular behandelt. Alles, was Sie tun müssen, ist das Validierungsstück zu ändern:

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

Dadurch werden Elemente mit Namen wie folgt zugeordnet und dann korrekt zugeordnet:

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

Und

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

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


Von einer older Antwort:

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

Die einfachste und genaueste Methode, die ich für dieses Problem gefunden habe, war die Verwendung von BBQ-Plugin oder dieses (die etwa 0,5 KB Größe ist).

Es funktioniert auch mit multidimensionalen Arrays.

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


Ein-Liner (keine anderen Abhängigkeiten als jQuery), verwendet die Bindung fester Objekte für die Funktion Pass-zu- map Methode.

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

Was es macht?

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

geeignet für progressive Web-Apps (sowohl reguläre Formular-Übermittlungsaktionen als auch Ajax-Anfragen können problemlos unterstützt werden)


All diese Antworten schienen mir übertrieben. Es gibt etwas, das der Einfachheit halber gesagt werden muss. Solange alle Ihre Formulareingaben das Namensattribut haben, sollte dies nur jim dandy funktionieren.

$('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 (e.g. JSON.stringify?)
});

Width all Given Antwort dort ein Problem, das ist ...

Wenn der Name der Eingabe array wie name[key] , wird dies jedoch wie folgt generiert

 name:{
   key : value
 }

Zum Beispiel: Wenn ich ein Formular wie dieses habe.

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

Dann wird es Objekt mit allen gegebenen Antworten erzeugen.

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

Aber es muss wie unten generiert werden, jeder möchte so wie unten kommen.

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

Dann probiere dies unter js code.

(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);
$('form').getForm2obj();

Ich hatte das gleiche Problem in letzter Zeit und kam mit diesem .toJSON jQuery Plugin heraus , das ein Formular in ein JSON Objekt mit der gleichen Struktur umwandelt. Dies ist auch besonders nützlich für dynamisch generierte Formulare, bei denen der Benutzer mehr Felder an bestimmten Stellen hinzufügen soll.

Der Punkt ist, dass Sie tatsächlich ein Formular erstellen möchten, so dass es eine Struktur selbst hat. Sagen wir, Sie möchten ein Formular erstellen, in das der Benutzer seine Lieblingsorte in der Stadt einfügt: Sie können sich dieses Formular als <places>...</places> vorstellen <places>...</places> XML-Element, das eine Liste von Orten enthält, die der Benutzer mag, also eine Liste von <place>...</place> -Elementen, von denen jedes zum Beispiel ein <name>...</name> -Element enthält, a <type>...</type> und dann eine Liste von <activity>...</activity> -Elementen, um die Aktivitäten darzustellen, die Sie an einem solchen Ort ausführen können. Ihre XML-Struktur würde also so aussehen:

<places>

    <place>

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

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

    </place>

    <place>...</place>

    <place>...</place>

</places>

Wie cool wäre es, ein JSON-Objekt zu haben, das genau diese Struktur repräsentiert, so dass Sie entweder:

  • Store this object as it is in any CouchDB -like database
  • Read it from your $_POST[] server side and retrive a correctly nested array you can then semantically manipulate
  • Use some server-side script to convert it into a well-formed XML file (even if you don't know its exact structure a-priori)
  • Just somehow use it as it is in any Node.js -like server script

OK, so now we need to think how a form can represent an XML file.

Of course the <form> tag is the root , but then we have that <place> element which is a container and not a data element itself, so we cannot use an input tag for it.

Here's where the <fieldset> tag comes in handy! We'll use <fieldset> tags to represent all container elements in our form/XML representation and so getting to a result like this:

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

As you can see in this form, we're breaking the rule of unique names, but this is OK because they'll be converted into an array of element thus they'll be referenced only by their index inside the array.

At this point you can see how there's no name="array[]" like name inside the form and everything is pretty, simple and semantic.

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!


Was ist falsch mit:

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

Einfachheit ist hier am besten. Ich habe eine einfache Zeichenfolge mit einem regulären Ausdruck ersetzt, und sie funktionierten wie ein Zauber bis jetzt. Ich bin kein Experte für reguläre Ausdrücke, aber ich wette, Sie können sogar sehr komplexe Objekte bevölkern.

var values = $(this).serialize(),
attributes = {};

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

Ich mag es, Array.prototype.reduce weil es ein Array.prototype.reduce ist und nicht auf Underscore.js oder dergleichen beruht:

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

Dies ähnelt der Antwort mit Array.prototype.map , aber Sie müssen Ihren Bereich nicht mit einer zusätzlichen Objektvariable Array.prototype.map . One-Stop-Shopping.

WICHTIGER HINWEIS : Formulare mit Eingaben, die doppelte Namensattribute aufweisen, sind gültiges HTML und tatsächlich eine allgemeine Vorgehensweise. Die Verwendung einer der Antworten in diesem Thread ist in diesem Fall nicht geeignet (da Objektschlüssel eindeutig sein müssen).



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.

Gegeben:

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

Laufen:

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

Produziert:

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

Diese Funktion sollte mehrdimensionale Arrays zusammen mit mehreren Elementen mit demselben Namen behandeln.

Ich benutze es seit ein paar Jahren:

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

Es gibt wirklich keine Möglichkeit, dies zu tun, ohne jedes der Elemente zu untersuchen. Was Sie wirklich wissen möchten, ist "Hat jemand anderes bereits eine Methode geschrieben, die ein Formular in ein JSON-Objekt konvertiert?" So etwas wie das Folgende sollte funktionieren - beachten Sie, dass es Ihnen nur die Formularelemente gibt, die über einen POST zurückgegeben werden (muss einen Namen haben). Dies wird nicht getestet .

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

Eine feste Version der Lösung von Tobias Cohen. Dieser behandelt korrekt falsche Werte wie 0 und '' .

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

Und eine CoffeeScript-Version für Ihre Codierung Komfort:

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

Wenn Sie versuchen, alle Formularfelder in JSON zu konvertieren, um dieses Formular über Ajax zu senden, hier ist ein jQuery-Formular-Plugin , das das tut.


Konvertieren von Formularen in JSON WIE EIN CHEF

Aktuelle Quelle ist GitHub und Laube.

$ bower installiere jquery-serialize-object

Der folgende Code ist jetzt veraltet .

Der folgende Code kann mit allen Arten von Eingabe-Namen arbeiten; und behandeln sie genau so, wie Sie es erwarten.

Beispielsweise:

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

Verwendung

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

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

Ich bevorzuge diesen Ansatz, weil: Sie müssen nicht über 2 Sammlungen iterieren, Sie können andere Dinge als "Name" und "Wert" bekommen, wenn Sie müssen, und Sie können Ihre Werte bereinigen, bevor Sie sie im Objekt speichern ( wenn Sie Standardwerte haben, die Sie nicht speichern möchten, zum Beispiel).

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

Verwenden Sie so:

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

Nur in Firefox getestet.


Ich habe ein Problem mit der ausgewählten Lösung gefunden.

Bei Verwendung von Formularen mit arraybasierten Namen wird die Funktion jQuery serializeArray () tatsächlich beendet.

Ich habe ein PHP-Framework, das Array-basierte Feldnamen verwendet, um zu ermöglichen, dass das gleiche Formular in mehreren Ansichten mehrmals auf dieselbe Seite gesetzt wird. Dies kann nützlich sein, wenn Sie auf derselben Seite hinzufügen, bearbeiten und löschen können, ohne dass dabei widersprüchliche Formularmodelle auftreten.

Da ich die Formulare seralisieren wollte, ohne diese absolute Basisfunktionalität ausnutzen zu müssen, entschied ich mich, mein eigenes seralizeArray () zu schreiben:

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

Bitte beachten Sie: Dies funktioniert auch außerhalb von form submit (). Wenn also ein Fehler im Rest Ihres Codes auftritt, wird das Formular nicht gesendet, wenn Sie auf eine Link-Schaltfläche "Änderungen speichern" klicken.

Beachten Sie außerdem, dass diese Funktion niemals zum Überprüfen des Formulars verwendet werden sollte, um nur die Daten zu sammeln, die zur Überprüfung an den Server gesendet werden. Die Verwendung eines solchen schwachen und massenzugewiesenen Codes verursacht XSS usw.


Ich habe ein Problem mit Tobias Cohens Code (ich habe nicht genug Punkte, um es direkt zu kommentieren) gefunden, was ansonsten für mich funktioniert. Wenn Sie zwei Auswahloptionen mit demselben Namen haben, beide mit Wert = "", erzeugt der ursprüngliche Code "name": "" anstelle von "name": ["", ""]

Ich denke, das kann durch Hinzufügen von "|| o [this.name] == ''" zur ersten if-Bedingung behoben werden:

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

Wenn Sie Underscore.js , können Sie das relativ übersichtliche verwenden:

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

Aktualisiert

Wir haben eine interne UI-Bibliothek, die sowohl mit dem integrierten ASP.NET-JSON-Format von Microsoft, wie /Date(msecs)/ , das hier ursprünglich abgefragt wurde, als auch mit dem 2014-06-22T00:00:00.0 Format, einschließlich 2014-06-22T00:00:00.0 . Außerdem müssen wir mit der Unfähigkeit von altIE fertig werden, mit nur 3 Nachkommastellen fertig zu werden .

Wir erkennen zuerst, welche Art von Datum wir verbrauchen, parsen es in ein normales JavaScript- Date Objekt und formatieren es dann.

1) Erkenne Microsoft Datumsformat

// Handling of Microsoft AJAX Dates, formatted like '/Date(01238329348239)/'
function looksLikeMSDate(s) {
    return /^\/Date\(/.test(s);
}

2) Erkenne das ISO-Datumsformat

var isoDateRegex = /^(\d\d\d\d)-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d)(\.\d\d?\d?)?([\+-]\d\d:\d\d|Z)?$/;

function looksLikeIsoDate(s) {
    return isoDateRegex.test(s);
}

3) Parse MS Datumsformat:

function parseMSDate(s) {
    // Jump forward past the /Date(, parseInt handles the rest
    return new Date(parseInt(s.substr(6)));
}

4) Parse ISO Datumsformat.

Wir können zumindest sichergehen, dass es sich um Standard-ISO-Daten oder ISO-Daten handelt, die so geändert wurden, dass sie immer drei Millisekunden haben ( siehe oben ). Daher ist der Code abhängig von der Umgebung unterschiedlich.

4a) Parse Standard-ISO-Datumsformat, bewältigen Sie die Probleme von OldIE:

function parseIsoDate(s) {
    var m = isoDateRegex.exec(s);

    // Is this UTC, offset, or undefined? Treat undefined as UTC.
    if (m.length == 7 ||                // Just the y-m-dTh:m:s, no ms, no tz offset - assume UTC
        (m.length > 7 && (
            !m[7] ||                    // Array came back length 9 with undefined for 7 and 8
            m[7].charAt(0) != '.' ||    // ms portion, no tz offset, or no ms portion, Z
            !m[8] ||                    // ms portion, no tz offset
            m[8] == 'Z'))) {            // ms portion and Z
        // JavaScript's weirdo date handling expects just the months to be 0-based, as in 0-11, not 1-12 - the rest are as you expect in dates.
        var d = new Date(Date.UTC(m[1], m[2]-1, m[3], m[4], m[5], m[6]));
    } else {
        // local
        var d = new Date(m[1], m[2]-1, m[3], m[4], m[5], m[6]);
    }

    return d;
}

4b) Parse ISO-Format mit einer festen drei Millisekunden Dezimalstellen - viel einfacher:

function parseIsoDate(s) {
    return new Date(s);
}

5) Formatiere es:

function hasTime(d) {
    return !!(d.getUTCHours() || d.getUTCMinutes() || d.getUTCSeconds());
}

function zeroFill(n) {
    if ((n + '').length == 1)
        return '0' + n;

    return n;
}

function formatDate(d) {
    if (hasTime(d)) {
        var s = (d.getMonth() + 1) + '/' + d.getDate() + '/' + d.getFullYear();
        s += ' ' + d.getHours() + ':' + zeroFill(d.getMinutes()) + ':' + zeroFill(d.getSeconds());
    } else {
        var s = (d.getMonth() + 1) + '/' + d.getDate() + '/' + d.getFullYear();
    }

    return s;
}

6) Binde alles zusammen:

function parseDate(s) {
    var d;
    if (looksLikeMSDate(s))
        d = parseMSDate(s);
    else if (looksLikeIsoDate(s))
        d = parseIsoDate(s);
    else
        return null;

    return formatDate(d);
}

Die folgende alte Antwort ist nützlich, um diese Datumsformatierung in jQuerys JSON-Parsing zu binden, so dass Sie Date-Objekte anstelle von Strings erhalten oder wenn Sie immer noch in jQuery <1.5 stecken bleiben.

Alte Antwort

Wenn Sie die Ajax-Funktion von jQuery 1.4 mit ASP.NET MVC verwenden, können Sie alle DateTime-Eigenschaften in Date-Objekte umwandeln mit:

// Once
jQuery.parseJSON = function(d) {return eval('(' + d + ')');};

$.ajax({
    ...
    dataFilter: function(d) {
        return d.replace(/"\\\/(Date\(-?\d+\))\\\/"/g, 'new $1');
    },
    ...
});

In jQuery 1.5 können Sie vermeiden, dass die parseJSON Methode global überschrieben wird, indem Sie die Option converters im Ajax-Aufruf verwenden.

http://api.jquery.com/jQuery.ajax/

Leider müssen Sie zu der älteren Eval-Route wechseln, um Daten zu erhalten, die global in-place analysiert werden. Andernfalls müssen Sie sie im Einzelfall nach der Analyse konvertieren.







jquery json serialization