Newsgroup: it.comp.lang.javascript
Titolo: [?] Settimana dell'anno

Ho scoperto or ora che non esiste (o quantomeno non trovo) come sapere la
settimana dell'anno...
non esiste nulla, vero (tipo il datepart("ww",now()) di vbs)? Esiste il
giorno della settimana ma non la settimana dell'anno...
Curiosità, se mi confermate che non esiste mi scriverò la funzione
Grazie

 Curiosità, se mi confermate che non esiste mi scriverò la funzione
Da parte mia ti confermo. A meno che qualcuno non mi smentisca. :)
--------------------------------
Inviato via 
http://usenet.libero.it

Scritta...ma non esiste uno standard???
Il primo giorno della settimana è domenica o Lunedì a seconda dei
linguaggi...e fin qui è accettabile
Il bello è come considerare p.e. il 31/12/2002: per sql server e vbs è
settimana 53, per outlook è settimana 1!
nella function considero sempre 53 (viene usata normalmente per statistiche
per settimana, direi che l'anno 2002 è l'anno 2002, non metà 2002 e metà
2003...)
Riccà, può servire per userscripts?
function giornosett(doggi,firstday) {
 //firstday:default 0 => Domenica ... 6 => Sabato
 //doggi => default oggi
 if(String(doggi)=='undefined') doggi=new Date();
 //azzero orario, per sicurezza
 doggi=new Date(doggi.getFullYear(),doggi.getMonth(),doggi.getDate(),0,0,0);
if((String(firstday)=='undefined')||(Number(firstday)<0)||(Number(firstday)>
6)) firstday=0;
 //cerco il primo firstday dell'anno
 var d=new Date(doggi.getFullYear(),0,1,0,0,0);
 while(d.getDay()!=Number(firstday)) d=new
Date(doggi.getFullYear(),0,d.getDate()+1,0,0,0);
 //differenza in giorni tra le 2 date
 var conta=Math.round((doggi.getTime()-d.getTime())/(1000*60*60*24));
 //divido per 7 e aggiungo 1 per la prima settimana, + 1 se a) resto diverso
da 0 oppure il giorno della settimana è lo stesso e b) la data fornita è
posteriore al primo firstday dell'anno
 var
ris=1+parseInt(conta/7)+((((conta%7!=0)||(doggi.getDay()==d.getDay()))&&(dog
gi.getTime()>=d.getTime()))?1:0);
 return ris;
}

 Riccà, può servire per userscripts?
Urca.. tutto questo robo per capire in che settimana dell'anno siamo..??
Continuero' a vivere bene senza, credo.. ^_^" (ma non si puo' ottimizzare?)


 Continuero' a vivere bene senza, credo.. ^_^" (ma non si puo'
ottimizzare?)
Boh...io ho trovato questa strada, se esiste un calcolo più semplice per
capirlo...secondo me esiste, solo che non mi è venuto in mente altro...
Si può ottimizzare raggruppando qualche calcolo, ho tenuto separate le righe
per scrivere un commento e un codice leggibile per postarlo al newsgroup

 per scrivere un commento e un codice leggibile per postarlo al newsgroup
Certo capisco.. Cmq ho dato un occhiata al codice. A prima vista ci sono
quantomeno le dichiarazioni delle var che possono essere ottimizzate, al di
la' del calcolo.
Poi mi chiedevo: Mi spieghi questa storia delle 53 settimane? Non ci sono 52
settimane in un anno? il 31/12/2002 non e' la 52esima settimana? (Neanche da
dire che e' un anno bisestile no?)


no, la settimana 52 termina il 29 dicembre quest'anno; come consideri il
30-31? outlook lo considera come prima settimana del 2003, con sql server
datepart restituisce 53...
365/7=52,14 <= c'è sempre 1-2 giorni che ballano...

 365/7=52,14 <= c'è sempre 1-2 giorni che ballano...
1-2 giorni? 0.14*7 da' 0.98, neanche un giorno per poco.
(oddio.. ora mi fai venire in dubbio. Stamani non mi sento molto ferrato in
aritmetica..)


 aritmetica..)
hai ragione, ma devi sommare i giorni che perdi con la prima settimana

 hai ragione, ma devi sommare i giorni che perdi con la prima settimana
Okay, ma a quel punto hai un risultato diverso a prescindere, non hai 52,14
da cui dedurre che ci sono 1-2 gg che ballano. :)
(evviva, oggi non sono ancora fuso in matematica.. :D )


  d=new Date(doggi.getFullYear(),0,d.getDate()+1,0,0,0);
Mi sembra di capire che stai spostando la data alla prima domenica o al
primo lunedě dell'anno.
Io uso un altro procedimento che mi sembra piů efficiente. Se ti interessa
te lo spiego.
Maurizio.

 te lo spiego.
Certo, se c'è qualcosa di meglio ben venga

 365/7=52,14 <= c'è sempre 1-2 giorni che ballano...
E questo ammesso che il primo giorno dell'anno sia lunedì. Anche se l'anno
avesse 364 giorni, la prima settimana potrebbe essere di pochi giorni, ad
esempio 3; i rimanenti 4 giorni darebbero luogo ad una settimana
supplementare.
Maurizio.

 (evviva, oggi non sono ancora fuso in matematica.. :D )
Non ti preoccupare, succede regolarmente a tutti :-)
52 settimane per 7 giorni sono 364 giorni. Il 365esimo, o 366esimo se l'anno
è bisestile, come lo consideri? Non è l'inizio di una nuova settimana?
Maurizio.

 è bisestile, come lo consideri? Non è l'inizio di una nuova settimana?
Si, infatti, e su questo non ci piove. :)
La questione vergeva se tale settimana la dovevi considerare la 53esima o la
1° settimana dell'anno successivo.
Logicamente parlando, la soluzione e' la seconda e non la prima.
A livello di codice, invece, conviene ottenere come risultato 53.


 Certo, se c'č qualcosa di meglio ben venga
La spiegazione č un po' lunga solo perché sono prolisso :-)
Per prima cosa calcolo i giorni che fanno parte della prima settimana
dell'anno. Per ora non ci preoccupiamo se la settimana inizia di domenica o
di lunedě.
La funzione getDay() riporta il giorno della settimana con un numero che
chiamiamo n: 0 il primo giiorno, 1 il secondo... Quindi (se si considera che
la settimana inizi di domenica):
    primogiorno = new Date(anno, 0, 1);
    n = primogiorno.getDay();
il numero di giorni che compone la prima settimana č dato semplicemente da
7 - n.
Se vogliamo che la settimana inizi dal lunedě il calcolo č abbastanza
semplice:
    n = (n + 6) % 7
In questo modo 0 = lunedě, 1 = martedě...
Cosě la precedente formula diventa:
    n = (primogiorno.getDate() + 6) % 7;
Il numero di giorni della prima settimana č:
    m = 7 - n = 7 - (primogiorno.getDate() + 6) % 7;
oppure, piů in generale:
    m = 7 - (primogiorno.getDate() + firstday) % 7;
con firstday = 0 (se la settimana inizia di domenica) oppure 6.
Sistemata la prima settimana, calcolo i giorni rimanenti, cioč i giorni fra
la data attuale (doggi) e il primo giorno dell'anno (effettivi, compreso il
primo giorno dell'anno) e vi tolgo i giorni della prima settimana.
    conta = Math.round((doggi - primogiorno) / 7) + 1 - m;
Infine:
    ris = 1 + Math.floor(conta / 7) + (conta % 7 != 0 ? 1 : 0);
L'1 iniziale si riferisce alla prima settimana giŕ calcolata. Mi sembra (ho
fatto solo verifiche sommarie) che non bisogna fare ulteriori controlli se
la doggi capita nella prima settimana dell'anno. In questo caso il
Math.floor riporta -1 e il risultato dovrebbe essere ugualmente corretto.
In conclusione, il codice dovrebbe essere, piů o meno, a parte i controlli
supplementari sui parametri passati (e mie sviste sempre possibili):
    doggi = new Date(doggi.getFullYear(), doggi.getMonth(),
doggi.getDate());
    primogiorno = new Date(doggi.getFullYear(), 0, 1);
    conta = Math.round((doggi - primogiorno) / 7)  - 6 +
(primogiorno.getDate() + firstday) % 7;
    ris = 1 + Math.floor(conta / 7) + (conta % 7 != 0 ? 1 : 0);
A proposito del Math.round che tu hai messo per calcolare i giorni: questo
risolve in modo semplice il problema dell'ora legale.
Maurizio.

Non ho tempo purtroppo di verificarla ma c'è qualcosa che non va
Se chiamo la function sotto con
<b ody onload='alert(giornosett2(new Date(2002,11,31),0))' >
mi restituisce un numeraccio...secondo me è la doggi-primogiorno che è
sbagliata, fa una differenza in millisecondi forse?
function giornosett2(doggi,firstday) {
 doggi = new Date(doggi.getFullYear(), doggi.getMonth(),doggi.getDate());
 primogiorno = new Date(doggi.getFullYear(), 0, 1);
 conta = Math.round((doggi - primogiorno) / 7)  - 6 + (primogiorno.getDate()
+ firstday) % 7;
 ris = 1 + Math.floor(conta / 7) + (conta % 7 != 0 ? 1 : 0);
 return ris;

 Logicamente parlando, la soluzione e' la seconda e non la prima.
Sì, ma cosa ti dà fastidio? Che in un anno ci siano 53 settimane o che una
settimana possa considerarsi contemporaneamente come ultima e come prima?
Anche se la settimana a cavallo fra due anni viene vista come prima
dell'anno successivo, le 53 settimane ci sarebbero ugualmente, ogni 5 o 6
anni. Ad esempio, se il primo giorno dell'anno capita di sabato o domenica,
il giorno 2 o il 3 già ci troveremo nella seconda settimana. I 364 giorni
mancanti danno luogo ad altre 52 settimane.
A questo punto non mi preoccupa più che tutti gli anni ci possa essere
(sempre) la 53esima o anche la 54esima (raramente) settimana.
Per il resto forse è solo questione di gusti personali.
A proposito dell'inizio della settimana (di domenica o di lunedì): in UK,
come in tutti i paesi anglosassoni, la settimana iniziava di domenica; però
un dubbio ce l'ho: con l'adesione all'Europa gli inglesi hanno dovuto
accettare, con una legge, tutte le convenzioni europee: il metro, il
chilogrammo. Che lo facciano veramente è un altro discorso, ma in questo
anche noi non siamo di esempio. Vi risulta che abbiano accettato anche la
convenzione sulle date?
Maurizio.

 in millisecondi forse?
Hai ragione perfettamente. Avevo scritto il codice senza nemmeno
verificarlo. Bisogna dividere per il solito numero 86400000.
Più tardi, o appena trovo il tempo, verifico meglio quello che ho scritto e
riposto il codice funzionante.
Maurizio.

esisteva uno standard "ufficiale" a cui attenersi
credo che l' iso abbia detto qualcosa al riguardo
la settimana si attribuisce valutando il giovedi'
se questo cade nell'anno nuovo tutta la settimana compete a questo
il contrario altrimenti
e se non sbaglio per l'iso la settimana parte dal lunedi

 sbagliata, fa una differenza in millisecondi forse?
Ho verificato e vi era anche un altro errore: avevo scritto getDate invece
di getDay. Comunque questo è il codice corretto:
    function giornosett2(doggi, firstday) {
        doggi = new Date(doggi.getFullYear(), doggi.getMonth(),
doggi.getDate());
        primogiorno = new Date(doggi.getFullYear(), 0, 1);
        conta = Math.round((doggi - primogiorno) / 86400000)  - 6 +
(primogiorno.getDay() + firstday) % 7;
        ris = 1 + Math.floor(conta / 7) + (conta % 7 != 0 ? 1 : 0);
        return ris;
    }
Maurizio.

:-O
interessante, questa me la segno...
resto però nella divisione 53-1 per evitare pacchi mostruosi con le query
multianno
Grazie



brw, iso ammette la 53
ho trovato in fretta questo
http://www.cl.cam.ac.uk/~mgk25/iso-time.html
ciao

 settimana possa considerarsi contemporaneamente come ultima e come prima?
Niente mi da' fastidio, cercavo solo di capire la problematica e di definire
una logica dietro. :)
