Hallo,
ich möchte eine Datumsfolge für eine einstellbare Tagesanzahl
ab einem beliebigen Datum erzeugen.
Ich habe mir die PEAR::Calendar - Klassen dazu schon angeschaut,die
bringen aber immer nur die Sequenzen an der Jahres/Monats/Wochen-Grenze.
Ich brauche aber z.B. die nächsten 30 Tage ab dem 25.12.2004. Also mit
Monats und Jahreswechsel.
Kann mich jemand in die richtige Richtung verlinken?
Danke.
Jens
Post removed (X-No-Archive: yes)
Jens Puruckherr schrieb:
> Ich brauche aber z.B. die nächsten 30 Tage ab dem 25.12.2004. Also mit
> Monats und Jahreswechsel.
>
> Kann mich jemand in die richtige Richtung verlinken?
Könnte man z.B. so machen:
|
| $ausgangsdatum = '2004-12-25';
| $anzahl = 30;
| $ergebnis = array();
|
| for ($i = 1; $i <= $anzahl; $i++) {
| $ergebnis[$i] = date('Y-m-d', strtotime("{$ausgangsdatum} +{$i} day"));
| }
|
| print_r($ergebnis);
| ?>
Ausserhalb von einem Unix-Timestamp könnte man auch den Julian Day Count
hochzähen. Siehe Calendar-Extension.
Gruß
Carsten
Prima, funktioniert. Ich habe wieder mal zu kompliziert gedacht.
Was ist der Unterschied zwischen
> | $ergebnis[$i] = date('Y-m-d', strtotime("{$ausgangsdatum} +{$i} day"));
und
$ergebnis[$i] = date('Y-m-d', strtotime("$ausgangsdatum + $i day"));
Weil bei mir beides funktioniert.
Jens
:wq
Jens Puruckherr schrieb:
> Prima, funktioniert. Ich habe wieder mal zu kompliziert gedacht.
> Was ist der Unterschied zwischen
>
>> | $ergebnis[$i] = date('Y-m-d', strtotime("{$ausgangsdatum} +{$i} day"));
>
> und
>
> $ergebnis[$i] = date('Y-m-d', strtotime("$ausgangsdatum + $i day"));
>
Die { sowie } (geschweifte Klammer). Die sagen dem Parser, dass es sich
innerhalb des Strings auf jeden Fall um Variablen handelt. Man könnte
auch folgendes schreiben (was ich persönlich bevorzuge, um dem PHP
Parser nicht auch noch das Parsen eines Strings aufzubürden):
$ergebnis[$i] = date('Y-m-d', strtotime($ausgangsdatum." + ".$i." day"));
Ciao,
Tobias
Ulrich Gehauf wrote:
Hallo,
> Am Tue, 15 Aug 2006 12:45:25 +0200 schrieb Jens Puruckherr:
>=20
>> Ich brauche aber z.B. die nächsten 30 Tage ab dem 25.12.2004. Also=
mit
>> Monats und Jahreswechsel.
>=20
> Datum umwandeln in Unix-Timestamp (strtotime/mktime),
>=20
> 30*24*60*60 dazuzählen (wahlweise auch in Einzelschritten über Sc=
hleife)
Das direkte Rechnen mit Sekunden funktioniert in den meisten Fällen =
durch
die Sommerzeit aber nicht in allen. Besser
=20
echo strtotime("+1 day"), "\n";
echo strtotime("+1 week"), "\n";
echo strtotime("+1 week 2 days 4 hours 2 seconds"),
benutzen, das berücksichtigt auch die Sommerzeit.
tschuess
[|8:)
Jens Puruckherr schrieb:
> > $ergebnis[$i] = date('Y-m-d', strtotime("{$ausgangsdatum} +{$i} day"));
>
> und
>
> $ergebnis[$i] = date('Y-m-d', strtotime("$ausgangsdatum + $i day"));
>
> Weil bei mir beides funktioniert.
In diesem Fall gibt's keinen funktionalen Unterschied und ist einfach
Angewohnheit. Genau kannst du das hier nachlesen:
http://de.php.net/manual/en/language.types.string.php#langua ge.types.string.parsing
Die Lösung von Tobias hatte ich auch erst im Kopf. Aber ich dachte so
erkennst du besser was in strtotime() gemacht wird...
Gruß
Carsten
Jens Puruckherr schrieb:
> Was ist der Unterschied zwischen
>
>> | $ergebnis[$i] = date('Y-m-d', strtotime("{$ausgangsdatum} +{$i} day"));
>
> und
>
> $ergebnis[$i] = date('Y-m-d', strtotime("$ausgangsdatum + $i day"));
Im Ersten sind mehr geschwungene Klammern.
Grüße, Matthias (sinnvolle Antworten wurden ja schon gegeben)
Tobias Kutzler schrieb:
>>> | $ergebnis[$i] =3D date('Y-m-d', strtotime("{$ausgangsdatum} +{$i} d=
ay"));
>>=20
> Man könnte=20
> auch folgendes schreiben (was ich persönlich bevorzuge, um dem PHP=20
> Parser nicht auch noch das Parsen eines Strings aufzubürden):
>=20
> $ergebnis[$i] =3D date('Y-m-d', strtotime($ausgangsdatum." + ".$i." day=
"));
Du meinst wirklich, der zweifache Aufruf der String-Concatenation ist
schneller als das Interpolieren? Zumal du doppelte Anführungszeichen
benutzt, womit du den Interpolator auch noch zweimal aufrufst.
Aber das ist letztlich akademisch; der Unterschied liegt -- wenn
überhaupt -- im Millisekundenbereich.
MfG
Niels
--=20
| http://www.kolleg.de =B7 Das Portal der Kollegs in Deutschland |
| http://www.bsds.de =B7 BSDS Braczek Software- und DatenSysteme |
| Webdesign =B7 Webhosting =B7 e-Commerce =B7 Joomla! Content Management =
|
------------------------------------------------------------ ------
Am Tue, 15 Aug 2006 17:29:04 +0200 schrieb Niels Braczek:
> Tobias Kutzler schrieb:
>> $ergebnis[$i] = date('Y-m-d', strtotime($ausgangsdatum." + ".$i." day"));
>
> Du meinst wirklich, der zweifache Aufruf der String-Concatenation ist
> schneller als das Interpolieren? Zumal du doppelte Anführungszeichen
> benutzt, womit du den Interpolator auch noch zweimal aufrufst.
> Aber das ist letztlich akademisch; der Unterschied liegt -- wenn
> überhaupt -- im Millisekundenbereich.
Seit dem ich hier mitlese (also in den letzten 3 bis 4 Monaten) hat mal
irgendwer einen Benchmark mit genau diesen Dingen gemacht. Wenn ich mich
recht entsinne ist die hier beschriebene Möglichkeit tatsächlich die
langsamste gewesen, eben aufgrund des doppelten Overheads zum
anschmeisen der Parser Routine und anschliessender Rückgabe.
Am schnellsten war wimre das Konstrukt der Machart $ausgangsdatum.' +
'.$i.' day', meine Vermutung dazu ist, weil einfach der Parser weiß,
wann ist Variabel und wann String. Und ich meine der
Geschwindigkeitsfaktor war schon erheblich. Letzt genannte Variante war
glaube ich etwa 5 bis 6 mal schneller.
Ich wünschte ich wüsste wer den Test damals gemacht hatte... Oder
zumindest das Topic, dann könnte man suchen, aber so :-(
--
Link zur PHP-FAQ http://www.php-faq.de
Norbert Melzer schrieb:
> Seit dem ich hier mitlese (also in den letzten 3 bis 4 Monaten) hat mal
> irgendwer einen Benchmark mit genau diesen Dingen gemacht. Wenn ich mich
> recht entsinne ist die hier beschriebene Möglichkeit tatsächlich die
> langsamste gewesen, eben aufgrund des doppelten Overheads zum
> anschmeisen der Parser Routine und anschliessender Rückgabe.
>
> Am schnellsten war wimre das Konstrukt der Machart $ausgangsdatum.' +
> '.$i.' day', meine Vermutung dazu ist, weil einfach der Parser weiß,
> wann ist Variabel und wann String. Und ich meine der
> Geschwindigkeitsfaktor war schon erheblich. Letzt genannte Variante war
> glaube ich etwa 5 bis 6 mal schneller.
>
> Ich wünschte ich wüsste wer den Test damals gemacht hatte... Oder
> zumindest das Topic, dann könnte man suchen, aber so :-(
Du könntest das von Niels Braczek meinen?
Re: Stringvergleich - Optimierung
Gruß
Carsten
Norbert Melzer schrieb:
> Ich wünschte ich wüsste wer den Test damals gemacht hatte... Oder
> zumindest das Topic, dann könnte man suchen, aber so :-(
Das war ich, zuletzt in news:e9lbvv$1kc$02$1@news.t-online.com. Da ging
es um echo, aber auch in Verbindung mit Interpolation und
Stringverbindung. Man sieht dort auch, dass der Unterschied zwischen den
Varianten ungefähr eine 100.000stel Sekunde beträgt. Lesbarkeit muss
also Vorrang haben vor Performanz.
Und hier fällt für mich der .-Operator schon raus.
Ich finde
"{$ausgangsdatum} +{$i} day"
wesentlich einfacher zu lesen als
$ausgangsdatum." + ".$i." day"
YMMV.
MfG
Niels
--=20
| http://www.kolleg.de =B7 Das Portal der Kollegs in Deutschland |
| http://www.bsds.de =B7 BSDS Braczek Software- und DatenSysteme |
| Webdesign =B7 Webhosting =B7 e-Commerce =B7 Joomla! Content Management =
|
------------------------------------------------------------ ------