[Développement] Classe Date

j'en ai eu marre de voir plein de gens poster sur le forum pour des problemes de traitements des dates en PHP (notamment à cause des problemes de compatibilités entre les dates anciennes et les timestamp Unix, ou à cause des formats de dates sous MySQL, etc...)

j'ai donc decidé de developper une classe DateHeure (qui sera ensuite à la disposition de chacun dans la partie code source) qui permettra de resoudre tous ces petits tracas. pour l'instant elle fait :

- construction à partir de 6 nombres (si pas de valeurs, je constuis a partir de la date du jour)
- construction à partir d'un timestamp MySQL
- creation d'un timesstamp MySQL
- formattage pour affichage

et je compte realiser sous peu :
- constuction a partir d'un timestamp Unix
- creation d'un timestamp Unix
- addition, soustraction de dates

voilà, si vous avez des idées de methodes qui vous sembleraient utiles, n'hesitez pas à m'en faire part, je noterai toute suggestion, mais le developpement ne sera pas instantané... [edit]si vous trouvez que c'est tout nul, que ça sert ç rien et que je perds mon temps, vous pouvez me le dire aussi [/edit]

de vos suggestions
++

tres bonne idee les fuseaux horaires (et meme peut-etre une gestion de l'heure d'été ?).

pour le problemes des bases de données, pour l'instant je me suis attaqué à MySQL, il faudra que je me renseigne des differents formats de dates proposés sur les autres SGBD, afin de generaliser un peu tout ça...

n'hesitez pas ;-)

Personnellement, j'ai fait une fonction hier soir qui permet de transformer une DATETIME MySQL (YYYY-MM-JJ HH:MM:SS) en date formatée ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Jeudi 25 Novembre 2004 à 14h15

Je la posterais demain (car au boulo...) .

pour ta contribution ;-), et en effet, j'oubliais de preciser :

si vous avez deja developpé une petite fonction qui fait un petit truc specifique sur les dates, n'hesitez pas à me la fournir.

ça permettra de faire une mise en commun des talents et de m'epargner du travail ... bien sur le nom de chacun des auteurs apparaitra dans le package final ;-)

voilà en fait je pense que ça va plutôt se transformer en projet de developpement en commun (j'aimerais bien m'occuper de la mise en commun, l'integration des methodes dans la classe finale)

le topic vient donc d'etre mis en post-it (merci Blade ;-)), chacun pourra maintenant y apporter sa petite contribution, sans risque de le voir couler dans les profondeurs du classement ;-)

Envoyé par Kioob

Simple question : y a pas déjà ça dans Pear ?

apparemment y a bien un truc de gestion des dates, mais ça m'etonnerait qu'elle te genere automatiquement des dates de n'importe quel format de n'importe quel SGBD, ça m'etonnerait qu'elle propose l'affichage des dates en français (on pourrait meme le faire en plusieurs langues), etc...

moi ce que je propose c'est vraiment un gros truc, effectivement aussi solide qu'une classe Pear, qui resolve d'un coup tous les problemes de dates PHP. et pour ça j'ai besoin de tout le monde ;-)

le but est aussi d'etre evolutif, ainsi des fonctionnalités pourront se rajouter dans l'avenir...

C'est vrai que vous avez un serieux "concurent" http://pear.php.net/package/Date
En principe les packages pear sont des usines a gaz, ca serait presque leur défaut.

Je salue toutefois l'idée, et puis y'a toujours de nouvelles choses a apporter.

Jai vu que le package pear ne se base pas sur le timestamp pour les calculs, et ca c'est tres important : on n'est pas limité de 1970 a 2038, ca peut donc etre utilisé de facon generique (idée a prendre).

Envoyé par doof

Jai vu que le package pear ne se base pas sur le timestamp pour les calculs, et ca c'est tres important : on n'est pas limité de 1970 a 2038, ca peut donc etre utilisé de facon generique (idée a prendre).

t'inquiete pas, ma classe n'est absolument pas basée là-dessus, car c'est justement le probleme de la gestion des dates dans PHP : dès qu'on veut sortir de cet intervalle, c'est la galère... en gros la structure de ma classe ressemble fortement à celle de la classe Pear:ate (que je ne connaissais pas avant aujourd'hui, juré ;-), et qui est en effet une usine à gaz, avec beaucoup de choses inutiles...)

Ok, tu fais donc les calculs directement basés sur le calendrier grégorien ? Peux-tu gerer des dates inferieures au 9 Decembre 1582 basées sur le calendrier Julien ?

Je dis ca parce-que je viens de me renseigner et je constate avec effarement que la période du 10 decembre 1582 au 19 décembre n'a jammais existé , ce qui ne simplifie pas du tout les calculs pour les dates anterieures (du moins en france, pour les autres pays c'est d'autres dates pour encore plus compliquer l'affaire).

En gros, sur quoi te bases-tu ?

je me base sur le calendrier grégorien, truc normal quoi...

je n'avais pas songé aux calculs juliens, et je n'ai donc pas encore testé la periode que tu indiques...

Envoyé par loufoque

Si on utilise un système non windows, le timestamp est valide jusqu'en 1900.. ça devrait suffire non ?

ben justement non, que fais-tu des applications web qui doivent traiter des données concernant des dates anterieures ?
c'est justement une des raisons de vivre de ce projet ;-)

Alors ma fonction ne vous servira pas à grand chose :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//Fonction qui transforme une date de type '2004-02-01 13:30:00' en 'Dimanche 1 Février 2004 à 13h30'
function format_dateFR($mysql_date_time)
{
	//On sépare la date du temps
	$date_time = explode(" ",$mysql_date_time);
	//On sépare les éléments de la date
	$date = explode("-",$date_time[0]);
	//On sépare les éléments du temps
	$time = explode(":",$date_time[1]);
 
	//Tableau avec les jours de la semaine
	$jours = array("Dimanche","Lundi","Mardi","Mercredi","Jeudi","Vendredi","Samedi");
	//Tableau avec les mois de l'année
	$mois = array("Janvier","Février","Mars","Avril","Mai","Juin","Juillet","Août","Septembre","Octobre","Novembre","Décembre");
 
	//On formate la date
	$timestamp = mktime (0, 0, 0, $date[1], $date[2], $date[0]);
 
	return 	$jours[date("w",$timestamp)] 	//Le jour en lettre			- Dimanche
			. " " . 
			date("j",$timestamp) 			//Le jour en chiffre(s)		- 1
			. " " . 
			$mois[date("m",$timestamp)-1] 	//Le mois en lettre			- Février
			. " " . 
			$date[0] 						//L'année					- 2004
			. " à " . 
			$time[0] 						//L'heure					- 13
			. "h" . 
			$time[1];						//Les minutes				- 30
}

Bon, ben je me suis amusé a faire une petite serie de fonctions pour gerer les dates sans utiliser le timestamp (sauf pour avoir la date actuelle bien sur, je vois pas d'autres moyen). Je me suis basé sur le jour Julien qui est aux jours ce que le timestamp est aux secondes. C'est un comptage des jours depuis le 1er janvier -4712. Un jour étant repéré par son numero de jour Julien + Le nombre de secondes écoulées, il devient vraiment aisé de faire toute sorte de calculs dessus. J'ecris ce texte par exemple au 2453337eme jour julien, 69693eme seconde.

Une date est representée par un tableau généré par __getDate() et qui ressemble beaucoup au tableau de getdate() de php.

Les fonctions dependant donc toutes les unes des autres, je suis obligé de mettre tout le lot, désolé pour la longueur (les noms des fonctions ont aussi des noms à ralonge, je savais pas quoi mettre, j'ai donc choisit des noms explicites si possible) .

Bon, c'est un 1er jet, y'a pas de controle d'erreur et beaucoups sont à ameliorer !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
/******************************************************************************************************
*Retourne le nom d'un mois sous forme littérale dans une langue choisie
*Utilise la langue locale du serveur si $lang = FALSE (configurable avec setlocale())
*Si $lang est une chaine, tente de retourner le mois dans cette langue ('fr_FR.ISO8859-1' pour francais)
*Ou alors, on peut directement passer un tableau contenant les noms des mois
*$name = mounthWord(3, 'fr_FR.ISO8859-1');
*@param int $mounth
*@param mixed $lang
*@return string
**/
function mounthWord($mounth, $lang = FALSE)
{
	if (is_array($lang)) return $lang[$mounth-1];
	else {
		if (is_string($lang)) setlocale(LC_TIME, $lang);
		$dMounth = ucfirst(strftime("%B", 947890800 + 2629744 * ($mounth-1)));
		if (is_string($lang)) setlocale(LC_TIME, '');
		return $dMounth;
	}
}
 
 
/******************************************************************************************************
*Retourne le nom d'un jour sous forme littérale dans une langue choisie
*marche à l'identique de mounthWord()
*@param int $day
*@param mixed $lang
*@return string
**/
function dayWord($day, $lang = FALSE)
{
	if (is_array($lang)) return $lang[$day];
	else {
		if (is_string($lang)) setlocale(LC_TIME, $lang);
		$dDay = ucfirst(strftime("%A", 946810800 + 86400 * $day));
		if (is_string($lang)) setlocale(LC_TIME, '');
		return $dDay;
	}
}
 
 
/******************************************************************************************************
*Retourne le nombre de jours dans le mois, fevrier varie suivant l'année bissextile
*@param int $year
*@param int $mounth
*@return int
**/
function getNbDayOfMounth($year, $mounth)
{
	$tbMounth = array (31, (!isBissextile($year)) ? 28 : 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
	return $tbMounth[$mounth-1];
}
 
 
/******************************************************************************************************
*Verifie si une année est bissextile
*@param int $year
*@return boolean
**/
function isBissextile($year)
{
	if ($year % 4 > 0) return FALSE;
	elseif ($year % 100 > 0) return TRUE;
	elseif ($year % 400 > 0) return FALSE;
	else return TRUE;
}
 
 
/******************************************************************************************************
*Retourne le jour de la semaine selon un jour Julien
*@param int $year
*@param int $mounth
*@param int $day
*@return int
**/
function getDayOfWeek($julian)
{
	return ($julian + 1.5) % 7;
}
 
 
/******************************************************************************************************
*Retourne le numero de la semaine d'un jour de l'année
*@param int $day
*@return int
**/
function getWeekNumber($julian)
{
	$d4 = ($julian + 31741 - ($julian % 7)) % 146097 % 36524 % 1461;
	$l = floor($d4 / 1460);
	$d1 = (($d4 - $l) % 365) + $l;
	$nb = floor($d1 / 7) + 1;
	return $nb;
}
 
 
/******************************************************************************************************
*Retourne le quantieme d'une date
*$dayNb = getDayOfYear(2004, 11, 26);
*@param int $year
*@param int $mounth
*@param int $day
*@return int
.**/
function getDayOfYear($year, $mounth, $day)
{
	if (isBissextile($year)) {
		$n = floor(275 * $mounth / 9) - floor(($mounth + 9) / 12) + $day - 30;
	} else {
		$n = floor(275 * $mounth / 9) - 2 * floor(($mounth + 9) / 12) + $day - 30;
	}
	return $n;
}
 
 
/******************************************************************************************************
*Retourne le jour Julien à partir du lundi 1 janvier -4712 à 12 h
*$julDay = getJulianDay(2004, 11, 26);
*@param int $year
*@param int $mounth
*@param int $day
*@return int
**/
function getJulianDay($year, $mounth, $day)
{
	$hours = 12;
	$ggg = 1;
	/* Decalage Gregorien
	if( $year < 1582 ) $ggg = 0;
	if( $year <= 1582 && $mounth < 10 ) $ggg = 0;
	if( $year <= 1582 && $mounth == 10 && $day < 5 ) $ggg = 0;
	*/
	$jd = -1 * floor(7*(floor(($mounth + 9) / 12)+ $year) / 4);
	$s = 1;
	if (($mounth - 9) < 0) $s = -1;
	$a = abs($mounth - 9);
	$j1 = floor($year + $s * floor($a / 7));
	$j1 = -1 * floor((floor($j1 / 100) + 1) * 3 / 4);
	$jd = $jd + floor(275 * $mounth / 9) + $day + ($ggg * $j1);
	$jd = floor($jd + 1721027 + 2 * $ggg + 367 * $year - 0.5);
	$jd = $jd + ($hours / 24);
	if ($jd < 0) $jd = 0;
 
	return round($jd);
}
 
 
/******************************************************************************************************
*Convertit un jour julien en date année/mois/jours
*@param int $julian
*@return array
**/
function julianToDate($julian)
{
	$a = $julian + 32044;
	$b = floor((4 * $a + 3) / 146097);
	$c = $a - floor(($b * 146097) / 4);
	/* Calendrier Julien
	$b = 0;
	$c = $julian + 32082;
	*/
	$d = floor((4 * $c + 3) / 1461);
	$e = $c - floor((1461 * $d) / 4);
	$m = floor((5 * $e + 2) / 153);
	$tbDate['day'] = $e - floor((153 * $m + 2) / 5) + 1;
	$tbDate['mounth'] = $m + 3 - 12 * floor($m / 10);
	$tbDate['year'] = $b * 100 + $d - 4800 + floor($m / 10);
 
	return $tbDate;
}
 
 
/******************************************************************************************************
*Retourne un tableau contenant toutes les infos d'une date à partir d'un jour julien
*$julDay = getDateFromJulian(2453336);
*@param int $julian
*@param mixed $lang optionel
*@return array
**/
function getDateFromJulian($julian, $lang = FALSE)
{
	$tbDate = julianToDate($julian);
	return __getDate($tbDate['year'], $tbDate['mounth'], $tbDate['day'], 0, 0, 0, $lang);
}
 
 
/******************************************************************************************************
*Retrourne le nombre de secondes selon un temps jours/heures/minutes/secondes
*@param int $day
*@param int $hour
*@param int $minute
*@param int $seconds
*@return int
**/
function getSecondsFromTime ($seconds = 0, $minute = 0, $hour = 0, $day = 0)
{
	return (86400 * $day) + (3600 * $hour) + (60 * $minute) + $seconds;
}
 
 
/******************************************************************************************************
*Retourne un tableau jours/heures/minutes/secondes à partir d'un nombre de secondes
*@param int $sec
*@return array
**/
function getTimeFromSeconds($sec)
{
	$tbTime['sec'] = $sec % 60;
	$tbTime['min'] = floor($sec / 60) % 60;
	$tbTime['hou'] = floor($sec / 3600) % 24;
	$tbTime['day'] = floor($sec / 86400);
	return $tbTime;
}
 
 
/******************************************************************************************************
*Verifie strictement la validité d'une date annes/mois/jour
*@param int $year
*@param int $mounth
*@param int $day
*@return boolean
**/
function isValidDate($year, $mounth, $day)
{
	$julian = getJulianDay($year, $mounth, $day);
	$verif = julianToDate($julian);
	if ($year == $verif['year'] && $mounth == $verif['mounth'] && $day == $verif['day']) return TRUE;
	else return FALSE;
}
 
 
/******************************************************************************************************
*Renvoie un tableau contenant toutes les infos d'une date
*fonction generique pour retourner la structure d'une date
*accepte des valeurs négatives et des dates invalides, recalcule la date et l'heure dans ce cas.
*$date = __getDate($year, $mounth, $day, $hour, $minute, $seconds)
*@param int $year
*@param int $mounth
*@param int $day
*@param int $hour optionel
*@param int $minute optionel
*@param int $seconde optionel
*@param mixed $lang optionel
*@return array
**/
function __getDate($year, $mounth, $day, $hour = 0, $minute = 0, $seconds = 0, $lang = FALSE)
{
	$now = getdate(time());
 
	// Recalcul des heures
	$time = getSecondsFromTime($seconds, $minute, $hour);
	if ($time >= 86400) { // aditionne le temps a une date
		$tbTime = getTimeFromSeconds($time);
		$day = $day + $tbTime['day'];
		$ntime = getSecondsFromTime($tbTime['sec'], $tbTime['min'], $tbTime['hou']);
		$tbTime = getTimeFromSeconds($ntime);
	}
	elseif ($time < 0) { // soustrait le temps a une date
		$tbTime = getTimeFromSeconds(abs($time));
		if ($time % 86400 != 0) $r =1;
		$day = $day - ($tbTime['day'] + $r );
		$ntime = getSecondsFromTime($tbTime['sec'], $tbTime['min'], $tbTime['hou']);
		$tbTime = getTimeFromSeconds(86400 - $ntime);
	}
	else { // remet en forme le temps
		$ntime = getSecondsFromTime($seconds, $minute, $hour);
		$tbTime = getTimeFromSeconds($ntime);
	}
	$hour = $tbDate['hour'] = $tbTime['hou'];
	$minute = $tbDate['minute'] = $tbTime['min'];
	$seconds = $tbDate['seconds'] = $tbTime['sec'];
 
	// Recalcul de la date
	if ($mounth <=0 || $mounth > 12) { // cas particulier des mois
		$mounth = $mounth - 1;
		$mm = $mounth % 12;
		if($mm < 0) $mm = 12 - abs($mm);
		$year = $year + floor($mounth / 12);
		$mounth = $mm + 1;
	}
	$tbDate['julian'] = getJulianDay($year, $mounth, $day);
	$verif = julianToDate($tbDate['julian']);
	$day = $tbDate['day'] = $verif['day'];
	$mounth = $tbDate['mounth'] = $verif['mounth'];
	$year = $tbDate['year'] = $verif['year'];
 
	// suite du tableau
	$tbDate['yearDay'] = getDayOfYear($year, $mounth, $day);
	$tbDate['weekDay'] = getDayOfWeek($tbDate['julian']);
	$tbDate['strDay'] =  dayWord($tbDate['weekDay'], $lang);
	$tbDate['strMounth'] = mounthWord($mounth, $lang);
	$tbDate['Bissextile'] = isBissextile($year) ? 1 : 0;
	$tbDate['weekNb'] = getWeekNumber($tbDate['julian']);
	$tbDate['Dseconds'] = getSecondsFromTime ($seconds, $minute, $hour);
	$tbDate['timestamp'] = mktime($hour, $minute, $seconds, $mounth, $day, $year);
	$tbDate['NbDaysM'] = getNbDayOfMounth($year, $mounth);
 
	// position de la date par rapport au temps actuel
	$tbDate['PosDateD'] = getPosDate(0, array('julian' => $tbDate['julian'], 'Dseconds' => $tbDate['Dseconds']));
	$tbDate['PosDateS'] = getPosDate(1, array('julian' => $tbDate['julian'], 'Dseconds' => $tbDate['Dseconds']));
	$diff = getDiffDate($tbDate, array(
				'julian' => getJulianDay($now['year'], $now['mon'], $now['mday']),
				'Dseconds' => getSecondsFromTime($now['seconds'], $now['minutes'], $now['hours'])));
	$tbDate['diffday'] = $diff['day'];
	$tbDate['diffhou'] = $diff['hou'];
	$tbDate['diffmin'] = $diff['min'];
	$tbDate['diffsec'] = $diff['sec'];
	$tbDate['difftsec'] = $diff['tsec'];
 
	return $tbDate;
}
 
 
/******************************************************************************************************
*Retourne la difference entre 2 dates
*@param array $date1
*@param array $date2
*@return array
**/
function getDiffDate($date1, $date2)
{
	$test = getPosDate(1, $date1, $date2);
	if ($test == -1) {
		$small = $date1;
		$great = $date2;
	} else {
		$small = $date2;
		$great = $date1;
	}
	$diff['day'] = $great['julian'] - $small['julian'];
	$diff['tsec'] = $great['Dseconds'] - $small['Dseconds'];
	if ($diff['tsec'] < 0) {
		$diff['day'] = $diff['day'] -1;
		$diff['tsec'] = 86400 - abs($diff['tsec']);
	}
	$time = getTimeFromSeconds($diff['tsec']);
	$diff['hou'] = $time['hou'];
	$diff['min'] = $time['min'];
	$diff['sec'] = $time['sec'];
 
	return $diff;
}
 
 
/******************************************************************************************************
*Retourne la "position" de la date par rapport a une autre,
*c'est a dire si c'est une date passée (-1), presente (0) ou future (1)
*si aucune date est passée en 3eme argument, la comparaison se fait par rapport au temps actuel
*@param int $prec precision 0 = au jour pres et 1 = à la seconde pres
*@param array $date
*@param array $comp
*@return int
**/
function getPosDate($prec, $date, $comp = FALSE)
{
	if ($comp == FALSE) {
		$Gdate = getdate(time());
		$comp['julian'] = getJulianDay($Gdate['year'], $Gdate['mon'], $Gdate['mday']);
		$comp['Dseconds'] = getSecondsFromTime($Gdate['seconds'], $Gdate['minutes'], $Gdate['hours']);
	}
	if ($date['julian'] < $comp['julian']) return -1;
	if ($date['julian'] > $comp['julian']) return 1;
	if ($date['julian'] == $comp['julian']) {
		if ($prec == 0) return 0;
		else {
			if ($date['Dseconds'] < $comp['Dseconds']) return -1;
			if ($date['Dseconds'] > $comp['Dseconds']) return 1;
			if ($date['Dseconds'] == $comp['Dseconds']) return 0;
		}
	}
}
 
 
/******************************************************************************************************
*Renvoie un tableau contenant toutes les infos d'une date en utilisant __getdate()
*Utilise un modele simple pour determiner le format d'entrée
*$date = getDateFromPattern('10-05-2004 10:25:15', 'DD-MM-YYYY HH:MN:SS');
*la syntaxe du modele (sensible à la casse) :
*Jour : DD
*Mois : MM
*Année : YYYY (incompatible si 2 chiffres)
*Heure : HH
*Minute : MN (!!! ne pas confondre avec mois MM !!!)
*Secondes : SS
*@param string $date
*@param string $pattern
*@param mixed $lang optionel
*@return array
**/
function getDateFromPattern($date, $pattern, $lang = FALSE)
{
	if (strpos($pattern, 'DD') !== FALSE) $day = substr($date, strpos($pattern, 'DD'), 2);
	else return FALSE;
	if (strpos($pattern, 'MM') !== FALSE) $mounth = substr($date, strpos($pattern, 'MM'), 2);
	else return FALSE;
	if (strpos($pattern, 'YYYY') !== FALSE) $year = substr($date, strpos($pattern, 'YYYY'), 4);
	else return FALSE;
	if (strpos($pattern, 'HH') == TRUE ) $hour = substr($date, strpos($pattern, 'HH'), 2);
	else $hour = 0;
	if (strpos($pattern, 'MN') == TRUE) $minute = substr($date, strpos($pattern, 'MN'), 2);
	else $minute = 0;
	if (strpos($pattern, 'SS') == TRUE) $seconds = substr($date, strpos($pattern, 'SS'), 2);
	else $seconds = 0;
 
	return __getDate($year, $mounth, $day, $hour, $minute, $seconds, $lang);
}
 
 
/******************************************************************************************************
*Renvoie un tableau contenant toutes les infos d'une date suivant le timestamp en utilisant __getdate()
*$date = getDateFromTimestamp('1101481054');
*@param int $timestamp
*@param mixed $lang optionel
*@return array
**/
function getDateFromTimeStamp($timestamp, $lang = FALSE)
{
	$date = getdate($timestamp);
	return __getDate($date['year'], $date['mon'], $date['mday'], $date['hours'], $date['minutes'], $date['seconds'], $lang);
}
 
 
/******************************************************************************************************
*Retourne un tableau contenant tous les jours Julien d'un semaine donnée
*@param int $year
*@param int $week
**return array
**/
function getWeek($year, $week)
{
	$day = getJulianDay($year, 1, 1) + 7 * ($week - 1);
	$iday = getDateFromJulian($day);
	$offset = $day - $iday['weekDay'] + 1;
	for ($i = $offset; $i <= $offset + 6; $i++) {
		$tbWeek[] = $i;
	}
	return $tbWeek;
}
 
 
/******************************************************************************************************
*Retourne un tableau contenant tous les jours Julien d'un mois donné
*@param int $year
*@param int $mounth
**return array
**/
function getMounth($year, $mounth)
{
	$day = getJulianDay($year, $mounth, 1);
	$nb = getNbDayOfMounth($year, $mounth);
	for ($i = $day; $i <= $day + $nb - 1 ; $i++) {
		$tbMounth[] = $i;
	}
	return $tbMounth;
}
 
 
/******************************************************************************************************
*Retourne une date formatée à partir d'un tableau structuré de date de __getDate()
*Utilise la date courante par défaut
*Version basique; beaucoups d'options à rajouter
*@param string $pattern
*@param array $date
*@return string
**/
function strDate($pattern, $date = FALSE)
{
	if ($date == FALSE) $date = getDateFromTimeStamp(time());
	$in = array (
		'/%l%/',
		'/%j%/',
		'/%M%/',
		'/%n%/',
		'/%G%/',
		'/%i%/',
		'/%s%/',
		'/%W%/',
		'/%z%/',
		'/%ju%/',
		'/%se%/',
		'/%Y%/',
		'/%y%/e',
		'/%w%/',
		'/%U%/',
		'/%D%/e',
		'/%dd%/',
		'/%dh%/',
		'/%dm%/',
		'/%ds%/',
		'/%dts%/'
	);
	$out = array (
		$date['strDay'],
		$date['day'],
		$date['strMounth'],
		$date['mounth'],
		$date['hour'],
		$date['minute'],
		$date['seconds'],
		$date['weekNb'],
		$date['yearDay'],
		$date['julian'],
		$date['Dseconds'],
		$date['year'],
		"substr(".$date['year'].", 2, 2)",
		$date['weekDay'],
		$date['timestamp'],
		"substr(".$date['strDay'].", 0, 3)",
		$date['diffday'],
		$date['diffhou'],
		$date['diffmin'],
		$date['diffsec'],
		$date['difftsec']
	);
 
	return preg_replace($in, $out, $pattern);
}

Voilà, dans la foulée, je met un exemple (a essayer) qui montre de quoi elles sont capables pour le moment :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
setlocale(LC_TIME, 'fr_FR.ISO8859-1'); // <= les dates en francais
 
// Jour d'aujourd'huis formaté
echo strDate('Nous sommes le %l% %j% %M% %Y%, <br>il est %G% heures %i% minutes et %s% secondes<br>semaine %W%, %z%eme jour de l\'année, %w%eme jour de la semaine<br>jour Julien no %ju%, %se%eme seconde du jour, le timestamp est : %U%<br><br>');
 
// Transformation pattern vers un autre
$datetime = '2004-11-26 22:10:14';
echo "La date \"$datetime\" réordonnée donne : ";
echo strDate('%l% %j% %M% %Y% à %G%h%i%', getDateFromPattern($datetime, 'YYYY-MM-DD HH:MN:SS'));
 
// Vieille date avec calculs dessus
echo strDate('<br><br>Nikola Tesla est né le %l% %j% %M% %Y% au %ju%eme jour Julien<br>En considerant qu\'il soit né a minuit,<br>%dd% jours %dh% heures %dm% minutes et %ds% secondes se sont écoulées depuis<br><br>', getDateFromPattern('10/07/1856', 'DD/MM/YYYY'));
 
// Recuperation d'une semaine sous forme de tableau
echo '2004 - semaine 49 :';
$week = getWeek(2004, 49);
echo '<table border="0" bgcolor="#EFEFEF">';
foreach ($week as $julian) {
	echo strDate("<tr><td>$julian</td><td>%D%</td><td><b>%j%</b></td><td>%M%<td>%z%</td></td></tr>", getDateFromJulian($julian));
}
echo '</table>';

Torvalds, il se pourait que tu ai déjà fait tout ca, en attendant, j'espere que ca pourrat donner quelques idées

wow !!! impressionnant !!! doof pour ta contribution !!!

en effet certaines choses sont deja faites
mais comme je suis justement en train de me pencher sur le calcul du numero du jour, ton systeme de calendrier julien va m'etre tres utile ;-)
si ça ne te derange pas, je vais juste changer les noms des variables pour que tout soit en français ;-)

encore pour le temps et l'energie depensés ;-)

ps : ta fonction getWeekNumber() doit etre foireuse, car ton code est le meme que le mien, et par exemple pour le lundi 27/12/2004, ça renvoie 52 alors qu'on sera en semaine 53... je ne sais pas encore comment je vais resoudre ça, mais ça doit etre faisable ;-)

Je me suis posé la question pour recuperer le no de semaine justement. C'est pas la fonction qui est foireuse en elle meme, c'est que je ne sais pas quelle reference prendre dans le cas d'une semaine a cheval sur 2 années. Si l'année commence 1 dimanche, considere-t-on ce dimanche comme la semaine 1 sinon, a partir de quel jour ?

Donc c'est corrigeable -a condition- de savoir exactement (officiellement disont) dans quel cas on commence le comptage de semaine (ce que je ne sais pas du tout) !!

Oops, j'avais mal compris le probleme. En effet, il y a un décalage par rapport au jours ou commence l'année avec ce systeme, donc ceil(($day) / 7) changerat de semaine à chaque fois ce jour.

Il faudrait donc faire ceil(($day+$decalage_avec_le_dimanche) / 7)

Le probleme est que dans ma fonction, je calculais par rapport au numero du jour de l'année et que donc c'est pas possible de connaitre directement le decalage a partir de ce chiffre.

Encore une fois, le jour julien est là pour resoudre le probleme apparement : http://www.auduteau.net/calendar/cal5.shtml ( j'ai déjà pris des formules sur ce site ).

Je ferais une nouvelle version basée sur le jour julien demain

[edit] => corriged, en se basant sur le jour julien !! [/edit]

Je viens de réediter, j'ai supprimé la fonction dateToWord() pour la remplacer par 2 fonctions distinctes mounthWord() et dayWord() qui utilisent la configuration locale pour afficher les noms de jours et de mois. Comme ca, pour faire du multilingue, ca devient easy. Si le serveur ne connait pas une langue, on peut utiliser ses propres tableaux à la place. Toutes les autres fonctions en profitent bien sur.

J'ai aussi arrangé __getDate() qui accepte maintenant des dates negatives, ou erronées (ex : 33/12/2004) dans ce cas, la date est recalculée à la volée, ce qui lui donne une grande souplesse, comme pour mktime() de php. Ca permet aussi de gerer tres facilement les décalages horaire.

voilà voilà.