Comment utiliser le paramètre JSON.parse Reviver pour analyser la chaîne de date

StackOverflow https://stackoverflow.com/questions/1792865

Question

Ma chaîne JSON contient un champ de date qui renvoie cette valeur: 

"2009-04-04T22:55:16.0000000-04:00"

Je suis particulièrement intéressé par l'analyse syntaxique que le compartiment date pas le temps. J'ai essayé d'utiliser une fonction de rénovateur, mais il est intéressant la fonction Reviver est jamais appelé! (Essayé sur Firefox)

Voici mon code pour y parvenir: 

var Site = {
.....
dateReviver: function(key, value) {
    var a;
    if (typeof value === 'string') {
        a = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
        if (a) {
            return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
                            +a[5], +a[6]));
        }
    }
    return value;
},
loadArticle: function(id) {
....
    proxy.getArticle(id, function(response) {
        var data = JSON.parse(response.result, Site.dateReviver);
        ....
    });
}
};

JSON.parse en loadArticle appelle jamais dateReviver.

J'investi une journée entière, mais pas de chance! Quelqu'un pourrait-il s'il vous plaît me aider?

Était-ce utile?

La solution

  1. L'expression régulière attend un "Zulu" fuseau horaire (A caractère 'Z' à la fin), tandis que la chaîne date-heure de l'échantillon montre un fuseau horaire numérique ( '-04: 00'). Le regex suivant accepte à la fois: 

    /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)(Z|([+\-])(\d{2}):(\d{2}))$/

    Si les chiffres de fuseau horaire ne sont pas nuls, vous voudrez peut-être modifier réellement la date après l'analyse syntaxique et / ou la conversion en UTC, pour respecter le fuseau horaire.

  2. Je peux voir dateReviver () être frappé. Effectuez les opérations suivantes dans un navigateur: 

    <!-- saved from url=(0014)about:internet -->
<html>
    <head>
        <script src="http://www.json.org/json2.js"></script>
        <script type="text/javascript" src="http://ajax.Microsoft.com/ajax/jQuery/jquery-1.3.2.js"></script>
        <script>
            $(function () {
                // a mock proxy to return some json to play with
                var proxy = {
                    getArticle: function(id, foo) { foo({
                        result: '["2009-04-04T22:55:16.0000000-04:00"]'
                    }); }
                };
                // the origial Site object, with the fixed regex
                var Site = {
                    dateReviver: function(key, value) {
                        var a;
                        if (typeof value === 'string') {
                            a = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)(Z|([+\-])(\d{2}):(\d{2}))$/.exec(value);
                            if (a) {
                                return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
                                                +a[5], +a[6]));
                            }
                        }
                        return value;
                    },
                    loadArticle: function(id) {
                        proxy.getArticle(id, function(response) {
                            var data = JSON.parse(response.result, Site.dateReviver);
                            // put the parsed JSON date on the page
                            $("#output").html(data[0].toString());
                        });
                    }
                };
                // try out our Site object
                Site.loadArticle();
            });
        </script>
    </head>
    <body>
        <div id="output"></div>
    </body>
</html>

    Je reçois ce qui suit dans le navigateur, ce qui indique l'analyse syntaxique réussie: 

    Sat Apr 4 15:55:16 PDT 2009

Autres conseils

En utilisant TypeSript, ma solution est la suivante: 

    export function parseWithDate(jsonString: string): any {
    var reDateDetect = /(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})/;  // startswith: 2015-04-29T22:06:55
    var resultObject = JSON.parse(jsonString,(key: any, value: any) => {
        if (typeof value == 'string' && (reDateDetect.exec(value))) {
            return new Date(value);
        }
        return value;
    });
    return resultObject;
}

Le meilleur de tous les mondes ;-) Il utilise un datereviver anonyme, qui est appelé par JSON.parse sur chaque propriété. La logique de Reviver est de vérifier si la propriété est de type chaîne de caractères et si oui, si elle ressemble à début d'une date ... Si elle est une date, puis renouvelez Date (valeur) faire l'analyse syntaxique réelle ... toutes les variations de fuseau horaire sont pris en charge de cette façon.

it helps!

Extension du paramètre convertisseurs jQuery.ajax a bien fonctionné pour moi de son défaut de: 

"text json": jQuery.parseJSON

à 

"text json": function (xmlValue) {
            var value = JSON.parse(xmlValue, Site.dateReviver);
      return value;
      }

L'utilisation de return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4], +a[5], +a[6]));

ne règle pas la date de l'information de fuseau horaire, l'-4:00 dans l'exemple.

Une alternative est de laisser Date () faire l'analyse syntaxique pour vous: 

var dateReviver = function (key, value) {
    var a;
    if (typeof value === 'string') {
        a = Date.parse(value);
        if (a) {
            return new Date(a);
        }    
    }
    return value;
}

Si le JSON avait été formaté avec JSON.stringify () il aurait été en UTC (Z). 

function dateReviver (k,v) {

    var isnum = /^\d+$/.test(v);

    // Check if number since Date.parse(number) returns valid date
    if (isnum) {
        return v;
    }

    if (Date.parse(v)) {
        return new Date(Date.parse(v));
    }
    return v;
}
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top