Perché Javascript getYear () restituisce 108?

Perché questo javascript restituisce 108 invece del 2008? ottiene il giorno e il mese corretti ma non l'anno?

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

anno = 108?

È una cosa del 2000 , vengono contati solo gli anni dal 1900.

Ci sono potenziali problemi di compatibilità ora che getYear()sono stati deprecati a favore di getFullYear()- da quirksmode :

Per rendere la questione ancora più complessa, date.getYear () è deprecato al giorno d'oggi e dovresti usare date.getFullYear (), che, a sua volta, non è supportato dai browser meno recenti. Se funziona, tuttavia, dovrebbe sempre dare l'intero anno, cioè. 2000 invece di 100.

Il tuo browser fornisce i seguenti anni con questi due metodi:

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

Ci sono anche differenze di implementazione tra Internet Explorer e Firefox, poiché l'implementazione di IE è getYear()stata modificata per comportarsi come getFullYear()- da IBM :

Secondo la specifica ECMAScript, getYear restituisce l'anno meno 1900, originariamente pensato per restituire "98" per il 1998. getYear è stato deprecato in ECMAScript Versione 3 e sostituito con getFullYear ().

Internet Explorer ha cambiato getYear () per funzionare come getFullYear () e renderlo conforme a Y2k, mentre Mozilla ha mantenuto il comportamento standard.

Poiché getFullYear non funziona nei browser meno recenti, puoi utilizzare qualcosa di simile:

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

Il prototipo Javascript può essere utilizzato per estendere oggetti esistenti, proprio come i metodi di estensione C #. Ora, possiamo solo fare questo;

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

Controlla i documenti. Non è un problema di Y2K: è una mancanza di un problema di Y2K! Questa decisione è stata presa originariamente in C ed è stata copiata in Perl, apparentemente JavaScript e probabilmente in molti altri linguaggi. Molto tempo fa apparentemente era ancora desiderabile usare anni a due cifre, ma sorprendentemente chiunque avesse progettato quell'interfaccia aveva abbastanza premeditazione per rendersi conto che dovevano pensare a cosa sarebbe successo nel 2000 e oltre, quindi invece di fornire solo gli ultimi due cifre, fornivano il numero di anni dal 1900. Potresti usare le due cifre, se eri di fretta o volevi essere rischioso. Oppure, se desideri che il tuo programma continui a funzionare, puoi aggiungere 100 al risultato e utilizzare anni a quattro cifre a tutti gli effetti.

Ricordo la prima volta che ho manipolato la data in Perl. Stranamente ho letto i documenti . Apparentemente questa non è una cosa comune. Uno o due anni dopo fui chiamato in ufficio il 31 dicembre 1999 per correggere un bug che era stato scoperto all'ultimo minuto possibile in un codice Perl a contratto, cose con cui non avevo mai avuto nulla a che fare. Era esattamente questo il problema: la chiamata di data standard restituiva anni dal 1900 ei programmatori lo consideravano come un anno a due cifre. (Presumevano che avrebbero ottenuto "00" nel 2000.) Essendo un giovane programmatore inesperto, mi ha sconvolto il fatto che avessimo pagato così tanto extra per un lavoro "professionale", e quelle persone non si erano nemmeno preoccupate di leggere il documentazione. Era l'inizio di molti anni di disillusione; adesso sono vecchio e cinico. :)

Nel 2000, la conferenza annuale YAPC Perl è stata denominata "YAPC 19100" in onore di questo non bug segnalato spesso.

Al giorno d'oggi, almeno nel mondo Perl, ha più senso usare un modulo standard per la gestione della data, uno che utilizza anni reali a quattro cifre. Non sono sicuro di cosa potrebbe essere disponibile per JavaScript.

Deve restituire il numero di anni dall'anno 1900.

utilizzare date.getFullYear().

Questa è (come correttamente sottolineato altrove) una cosa da anno 2000. Netscape (scritto prima del 2000) restituito originariamente, ad esempio 98da getYear(). Piuttosto che tornare a 00, è invece tornato 100per l'anno 2000. Poi sono arrivati ​​altri browser e lo hanno fatto in modo diverso, e tutti erano scontenti quando regnava l'incompatibilità.

Browser successivi supportati getFullYearcome metodo standard per restituire l'anno completo.

Questa domanda è così vecchia che mi fa piangere di nostalgia per i giorni delle dotcom!

Esatto, Date.getYear () restituisce il numero di anni dal 1900, proprio come localtime () di Perl. Viene da chiedersi perché un linguaggio progettato negli anni '90 non avrebbe tenuto conto del giro di secoli, ma cosa posso dire? Dovevi essere lì. All'epoca aveva un senso (come ha fatto Pets.com).

Prima del 2000, si poteva essere tentati di correggere questo bug aggiungendo "19" al risultato di getYear () risultando nel "bug dell'anno 19100" . Altri hanno già risposto sufficientemente a questa domanda (aggiungi 1900 al risultato di getDate ()).

Forse il libro che stai leggendo su JavaScript è un po 'vecchio?

Grazie per il tuffo nel passato!

Come sottolineato, non dovresti mai usare getYear(), ma invece usaregetFullYear() .

La storia, tuttavia, non è semplice come "IE implementa GetYear()come getFullYear(). Opera e IE in questi giorni trattano getYear()come getYear()originariamente specificato per le date precedenti al 2000, ma lo tratteranno comegetFullYear() per le date dopo il 2000, mentre webkit e Firefox mantengono il vecchio comportamento

Questo restituisce 99 in tutti i browser:

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

Questo produce 108 in FF / WebKit e 2008 in Opera / IE:

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

È stupido. Essa risale al pre-Y2K giorni , e ora solo restituisce il numero di anni a partire dal 1900 per motivi di eredità. Usa getFullYear () per ottenere l'anno effettivo.

Sto usando date.getUTCFullYear(); lavorare senza problemi.

Il numero che ottieni è il numero di anni dal 1900. Non chiedermi perché ..

Come altri hanno detto, restituisce il numero di anni a partire dal 1900. Il motivo per cui lo fa che è che quando è stato inventato JavaScript metà degli anni '90, che il comportamento era sia conveniente e coerente con le API data-ora in altre lingue. In particolare C. E, naturalmente, una volta stabilita l'API, non è stato possibile modificarla per motivi di compatibilità con le versioni precedenti.

A proposito, browser diversi potrebbero restituire risultati diversi, quindi è meglio saltare del tutto questa funzione e utilizzare sempre getFullYear ().

var date_object = new Date (); var year = date_object.getYear (); se (anno <2000) {anno = anno + 1900; } // avrai l'intero anno ....

sta restituendo un anno a 4 cifre: 1900, che potrebbe essere stato bello più di 9 anni fa, ma ora è piuttosto ritardato. Java.util.Date di Java fa anche questo.