Pourquoi Javascript getYear () renvoie 108?

Pourquoi ce javascript renvoie 108 au lieu de 2008? il obtient le jour et le mois corrects mais pas l'année?

myDate = new Date();
year = myDate.getYear();

année = 108?

C'est une histoire de l'an 2000 , seules les années depuis 1900 sont comptées.

Il y a maintenant des problèmes de compatibilité potentiels qui getYear()ont été déconseillés en faveur de getFullYear()- de quirksmode :

Pour rendre la question encore plus complexe, date.getYear () est obsolète de nos jours et vous devriez utiliser date.getFullYear (), qui, à son tour, n'est pas prise en charge par les anciens navigateurs. Si cela fonctionne, cependant, il devrait toujours donner l'année complète, c'est-à-dire. 2000 au lieu de 100.

Votre navigateur donne les années suivantes avec ces deux méthodes:

* The year according to getYear(): 108
* The year according to getFullYear(): 2008

Il existe également des différences d'implémentation entre Internet Explorer et Firefox, car l'implémentation d'IE a getYear()été modifiée pour se comporter comme getFullYear()- d' IBM :

Selon la spécification ECMAScript, getYear renvoie l'année moins 1900, initialement censée renvoyer "98" pour 1998. getYear était obsolète dans ECMAScript Version 3 et remplacé par getFullYear ().

Internet Explorer a modifié getYear () pour qu'il fonctionne comme getFullYear () et le rende conforme à l'an 2000, tandis que Mozilla a conservé le comportement standard.

Étant donné que getFullYear ne fonctionne pas dans les navigateurs plus anciens, vous pouvez utiliser quelque chose comme ceci:

Date.prototype.getRealYear = function() 
{ 
    if(this.getFullYear)
        return this.getFullYear();
    else
        return this.getYear() + 1900; 
};

Le prototype Javascript peut être utilisé pour étendre des objets existants, tout comme les méthodes d'extension C #. Maintenant, nous pouvons simplement faire ceci;

var myDate = new Date();
myDate.getRealYear();
// Outputs 2008

Consultez les documents. Ce n'est pas un problème pour l'an 2000 - c'est un manque de problème pour l'an 2000! Cette décision a été prise à l'origine en C et a été copiée en Perl, apparemment en JavaScript, et probablement dans plusieurs autres langages. Il y a bien longtemps, il était apparemment toujours souhaitable d'utiliser des années à deux chiffres, mais remarquablement, celui qui a conçu cette interface avait suffisamment de prévoyance pour se rendre compte qu'il devait réfléchir à ce qui se passerait en 2000 et au-delà, donc au lieu de simplement fournir les deux derniers chiffres, ils ont fourni le nombre d'années depuis 1900. Vous pourriez utiliser les deux chiffres, si vous étiez pressé ou vouliez prendre des risques. Ou si vous souhaitez que votre programme continue de fonctionner, vous pouvez ajouter 100 au résultat et utiliser des années à quatre chiffres à part entière.

Je me souviens de la première fois que j'ai manipulé des dates en Perl. Curieusement, j'ai lu la documentation . Apparemment, ce n'est pas une chose courante. Un an ou deux plus tard, j'ai été appelé au bureau le 31 décembre 1999 pour corriger un bogue qui avait été découvert à la dernière minute possible dans un code Perl contractuel, des choses avec lesquelles je n'avais jamais rien à voir. C'était exactement ce problème: l'appel de date standard renvoyait des années depuis 1900, et les programmeurs l'ont traité comme une année à deux chiffres. (Ils ont supposé qu'ils obtiendraient "00" en 2000.) En tant que jeune programmeur inexpérimenté, j'ai été stupéfait de constater que nous avions payé tellement plus cher pour un travail "professionnel", et ces gens n'avaient même pas pris la peine de lire le Documentation. Ce fut le début de nombreuses années de désillusion; maintenant je suis vieux et cynique. :)

En 2000, la conférence annuelle YAPC Perl a été appelée "YAPC 19100" en l'honneur de ce non-bogue souvent rapporté.

De nos jours, dans le monde Perl du moins, il est plus logique d'utiliser un module standard pour la gestion des dates, un module qui utilise de vraies années à quatre chiffres. Je ne sais pas ce qui pourrait être disponible pour JavaScript.

Il doit renvoyer le nombre d'années depuis l'année 1900.

utiliser date.getFullYear().

Ceci est (comme indiqué à juste titre ailleurs) est une chose de l'an 2000. Netscape (écrit avant 2000) renvoyé à l'origine, par exemple 98depuis getYear(). Plutôt que d'y retourner 00, il est revenu 100pour l'année 2000. Ensuite, d'autres navigateurs sont venus et l'ont fait différemment, et tout le monde était mécontent car l'incompatibilité régnait.

Navigateurs plus récents pris getFullYearen charge comme méthode standard pour renvoyer l'année complète.

Cette question est si ancienne qu'elle me fait pleurer de nostalgie pour les jours dotcom!

C'est vrai, Date.getYear () renvoie le nombre d'années depuis 1900, tout comme l'heure locale () de Perl. On se demande pourquoi un langage conçu dans les années 1990 ne rendrait pas compte du chiffre d'affaires du siècle, mais que puis-je dire? Vous deviez être là. Cela avait en quelque sorte un sens à l'époque (comme pets.com).

Avant 2000, on aurait pu être tenté de corriger ce bogue en ajoutant "19" au résultat de getYear () résultant en le "bug de l'année 19100" . D'autres ont déjà suffisamment répondu à cette question (ajoutez 1900 au résultat de getDate ()).

Peut-être que le livre que vous lisez sur JavaScript est un peu vieux?

Merci pour l'explosion du passé!

Vous devez, comme indiqué, ne jamais utiliser getYear(), mais plutôt utiliser getFullYear().

L'histoire n'est cependant pas aussi simple que "les implémentations d'IE GetYear()comme getFullYear(). Opera et IE traitent ces jours-ci getYear()comme cela getYear()était initialement spécifié pour les dates antérieures à 2000, mais le traiteront comme getFullYear()pour les dates postérieures à 2000, tandis que Webkit et Firefox s'en tiennent à l'ancien comportement.

Cela génère 99 dans tous les navigateurs:

javascript:alert(new Date(917823600000).getYear());

Cela génère 108 dans FF / WebKit et 2008 dans Opera / IE:

javascript:alert(new Date().getYear());

C'est idiot. Il date des jours antérieurs à l'an 2000 et renvoie maintenant simplement le nombre d'années depuis 1900 pour des raisons d'héritage. Utilisez getFullYear () pour obtenir l'année réelle.

J'utilise date.getUTCFullYear(); travailler sans problèmes.

Le nombre que vous obtenez est le nombre d'années depuis 1900. Ne me demandez pas pourquoi.

Comme d' autres l' ont dit, il renvoie le nombre d'années écoulées depuis 1900. La raison pour laquelle il fait c'est que lorsque JavaScript a été inventé au milieu des années 90, que le comportement était à la fois pratique et compatible avec les API de date-heure dans d' autres langues. En particulier C. Et, bien sûr, une fois l'API établie, ils ne pouvaient pas la modifier pour des raisons de rétrocompatibilité.

BTW, différents navigateurs peuvent renvoyer des résultats différents, il est donc préférable d'ignorer complètement cette fonction et d'utiliser toujours getFullYear ().

var date_object = nouvelle date (); var année = date_object.getYear (); if (année <2000) {année = année + 1900; } // vous obtiendrez l'année complète ....

il retourne une année à 4 chiffres - 1900, ce qui était peut-être cool il y a plus de 9 ans, mais est assez retardée maintenant. Java.util.Date de Java le fait également.