sekunden zu datum algorythmus

[Thomas J.S.]

hallo allerseits,

im perl ist es möglich das datum im form von sekunden zu speichern und dies dann doch wieder als normales datum auszugeben;
was ich wissen möchte wie im perl eben diese "zurückrechnung" erfolgt. also ich möchte den algorythmus kennen mit dem perl aus den sekunden das datum zurückrechnet.

grüße
thomas

[Klaus Mock]

Hallo Thomas,

im perl ist es möglich das datum im form von sekunden zu speichern und dies dann doch wieder als normales datum auszugeben;

Ich hoffe, Du meinst die Geschichte mit 'time', 'gmtime' bzw. 'localtime'.

was ich wissen möchte wie im perl eben diese "zurückrechnung" erfolgt.

Perl verwendet AFAIK die entsprechenden Funktionen aus den C-Bibliotheken des Compilers, mit dem es übersetzt wurde.

also ich möchte den algorythmus kennen mit dem perl aus den sekunden das datum zurückrechnet.

Wenn Du den Source zum GCC bzw zu dessen libc ansiehst, dann wirst Du sicherlich fündig. (Zumindest soweit es deren Implementation betriff)

Grüße
  Klaus

[RoRo]

moin,

im perl ist es möglich das datum im form von sekunden zu speichern und dies dann doch wieder als normales datum auszugeben;
was ich wissen möchte wie im perl eben diese "zurückrechnung" erfolgt. also ich möchte den algorythmus kennen mit dem perl aus den sekunden das datum zurückrechnet.

@z = localtime("sekunden seit beginn der epoche"); # 1.1.1970
$z[4] += 1; # hier steht der Monat
$z[5] += 1900; # hier steht das Jahr

print "$z[3].$z[4].$z[5]\n";

Thats all :)

Rolf

siehe auch perldoc- time, localtime, gmtime und guck hier auch mal rein:
http://i-netlab.de/perlmod/ctdoc.htm

[Vedat Yetkin]

Hallo Thomas,

was ich wissen möchte wie im perl eben diese "zurückrechnung" erfolgt. also ich möchte den algorythmus kennen mit dem perl aus den sekunden das datum zurückrechnet.

Geht es Dir darum, welchen Algorithmus PERL selbst dazu verwendet, oder möchtest Du einfach einen Algorithmus, der das auch kann?

Bei letzterem kann ich Dir aushelfen, hab grad mal eins geschrieben...
Ich denke, Du wirst damit klar kommen ... ansonsten einfach fragen.

Grüße, Vedat

#!/usr/bin/perl

sj ($jahr) gibt zurück, ob ein Jahr ein Schaltjahr ist

Gibt 1 für ja und 0 für nein zurück.

sub sj {
  my $j = shift;
  my $sj = 0;
  if (($j % 4)==0) {$sj++} #Schaltjahr
  if (($j % 100)==0) {$sj--} #kein Schaltjahr, wenn durch 100 teilbar
  if (($j % 1000)==0) {$sj++} # aber wenn auch durch 1000 teilbar, dann doch Schaltjahr
  return $sj;
}

sub tim ($monat, $jahr);

Gibt zurück, wieviele Tage der aktuelle Monat hat.

sub tim {
  my $m = shift;
  my $j=shift;
  my @tage = (0,31,28,31,30,31,30,31,31,30,31,30,31);
  $tim=$tage[$m];
  if ($m==2) { $tim += sj($j); }
  return $tim;
}

my ($jahr, $monat, $tag) = (1970,1,1); # Das Ganze beginnt bei 1.1.1970, 0:00 Uhr
my $t=time;  # hier steht das Datum im Sekundenformat ...
my $zaehler=0; # hier zählen wir die Sekunden soweit hoch, bis wir das obige Datum erreicht haben

Erst mal die Jahre hochzählen ...

while ($zaehler<$t) {
$zaehler +=(365 * 24 * 60 * 60);
$zaehler += (sj ($jahr) * 24 * 60 * 60);
$jahr++;
}
$jahr--;  #der Algorithmus oben schiesst um ein Jahr über :-)
$zaehler -=(365 * 24 * 60 * 60);
$zaehler -= (sj ($jahr) * 24 * 60 * 60);

Das Gleiche mit dem Monat...

while ($zaehler<$t) {
$zaehler +=(tim($monat,$jahr) * 24 * 60 * 60);
$monat++;
}
$monat--;
$zaehler -=(tim($monat,$jahr) * 24 * 60 * 60);

Jetzt noch die Tage

while ($zaehler<$t) {
$zaehler +=(24 * 60 * 60);
$tag++;
}
$tag--;

Wenn Du lustig bist, kannst Du noch die Stunden und Minuten auf diese Weise hochzählen....

#Schnell mal kucken, was der gerechnet hat ...
print "$tag.$monat.$jahr";

... also bei mir hat er richtig gerechnet *g*

exit(0);

[RoRo]

Hi Vedat,

sj ($jahr) gibt zurück, ob ein Jahr ein Schaltjahr ist

Gibt 1 für ja und 0 für nein zurück.

sub sj {
  my $j = shift;
  my $sj = 0;
  if (($j % 4)==0) {$sj++} #Schaltjahr
  if (($j % 100)==0) {$sj--} #kein Schaltjahr, wenn durch 100 teilbar
  if (($j % 1000)==0) {$sj++} # aber wenn auch durch 1000 teilbar, dann doch Schaltjahr
  return $sj;
}

Deine Formel rechnet falsch.
Richtig wäre:

Schaltjahr

sub is_leapyear{
 my $year = shift;
 my $v = 0;
 if(!$year)  { return "-1" }
 if($year%4==0)   { $v = 1 }
 if($year%100==0) { $v = 0 }
 if($year%400==0) { $v = 1 }
 return $v;
}

Rolf

[Vedat Yetkin]

Hallo Rolf,

Deine Formel rechnet falsch.

Ja, tatsächlich.
Also, bevor Du die Art mit Hoch und Runterzählen bemängelst, die Art fand ich in einer anderen Routine praktischer, weil es da darum ging, wieviele Tage der Februar hat. Ginge auch mit einer einfachen Zuweisung ... na, vielleicht wollte ich auch nur den Code unlesbarer machen *g*

[...]

if(!$year)  { return "-1" }

Sinnvoll ... wenn man die Routine universell einsetzen will. Aber man muß so oder so wissen, was die Routine macht. Denn: der Rückgabewert -1 bringt mein Hauptprogramm ziemlich durcheinander :-)
Und wer wissen will, ob ein Jahr ein Schaltjahr ist, sollte dann schon sagen, um welches Jahr es geht :-)

if($year%4==0)   { $v = 1 }
if($year%100==0) { $v = 0 }
if($year%400==0) { $v = 1 }

Ooops, genau da ist mein Fehler ... 400, nicht 1000 ... hast recht... ich erinnere mich wieder *g*

Danke,

Tschüss, Vedat

[RoRo]

Hi Vedat,

if($year%4==0)   { $v = 1 }
if($year%100==0) { $v = 0 }
if($year%400==0) { $v = 1 }

Ooops, genau da ist mein Fehler ... 400, nicht 1000 ... hast

ach was, nimm doch einfach mein Modul http://i-netlab.de/perlmod/ctdoc.htm *g

Btw., find ich gut wie Du die Tage eines Monats berechnest, in Kalender.pm mach ichs fast genauso http://i-netlab.de/cgi-bin/show_script.cgi?ct

... und hier noch was zum basteln
=cut
#!/usr/bin/perl
use Kalender;

for(1899..2001){
 print "Der 1.1. des Jahres $_ ist ein ";
 if(is_leapyear($_)){
  print weekday(1,1,$_)," (Schaltjahr)\n";
 }
 else{
  print weekday(1,1,$_)," \n";
 }
}
=cut

Viele Grüße aus Baden, Rolf (roro)

[n.d. parker]

Moin Rolf,

sub is_leapyear{
my $year = shift;
my $v = 0;
if(!$year)  { return "-1" }
if($year%4==0)   { $v = 1 }
if($year%100==0) { $v = 0 }
if($year%400==0) { $v = 1 }
return $v;
}

eleganter (perliger) waere imho:

sub is_leapyear ($) {
  my $year = shift;

not $year % 4
  and ( $year % 100 or not $year % 400 );
}

(gibt obendrein wirkliche boolean-werte (im Perl-Sinne) zurueck, '0' ist nicht immer == 'false').

Viele Gruesse,

n.d.p.

[n.d. parker]

Mahlzeit,

sub is_leapyear ($) {
  my $year = shift;

not $year % 4
  and ( $year % 100 or not $year % 400 );
}
(gibt obendrein wirkliche boolean-werte (im Perl-Sinne) zurueck

und vieeel huebscher ist natuerlich die folgende Version ;-))

#!/usr/bin/perl -w
use strict;

sub is_leapyear ($) {
  my $year = shift;

not (
    $year % 4   or not
    $year % 100 and
    $year % 400
  );
}

$="\n";
print "$_ => ", is_leapyear($_) for (qw(
  1900
  1903
  1904
  2000
));

bye

--
n.d.p.

[Vedat Yetkin]

... und ich wage zu widersprechen.

Hi nd,

eleganter (perliger) waere imho:

sub is_leapyear ($) {
  my $year = shift;

not $year % 4
  and ( $year % 100 or not $year % 400 );
}

Sieht wirklich eleganter aus, wie soll ich armer Schlucker denn da noch durchblicken, ohne 200 Seiten Perldocs durchgelesen zu haben?

(gibt obendrein wirkliche boolean-werte (im Perl-Sinne) zurueck, '0' ist nicht immer == 'false').

Nun ja, in meinem Skript sind keine Booleans erwünscht *g*
Es kommt doch darauf an, was man mit dem Ergebnis machen möchte. Ich lasse mir halt 0 und 1 zurückgeben, um mit diesen Werten weiterrechnen zu können und um auf eine If - Abfrage verzichten zu können.
Ist halt mein Stil, aber der ändert sich in letzter Zeit immer mehr...

Grüße, Vedat

[n.d. parker]

Moin Vedat,

... und ich wage zu widersprechen.

*lol*

eleganter (perliger) waere imho:

[...]

Sieht wirklich eleganter aus, wie soll ich armer Schlucker denn da noch durchblicken, ohne 200 Seiten Perldocs durchgelesen zu haben?

so schlimm finde ich das eigentlich gar nicht ;) [1]

(gibt obendrein wirkliche boolean-werte (im Perl-Sinne) zurueck, '0' ist nicht immer == 'false').
Nun ja, in meinem Skript sind keine Booleans erwünscht *g*

hmm, 'is_*'-Funktionen implizieren bei mir immer boolean-Werte.

Es kommt doch darauf an, was man mit dem Ergebnis machen möchte.
Ich lasse mir halt 0 und 1 zurückgeben, [...]

genaugenommen wuerde ich dir jetzt folgende Variante vorschlagen (*g*):

sub is_leapyear ($) {
  my $year = shift;

not (
    $year % 4   or not
    $year % 100 and
    $year % 400
  );
}
sub sj ($) {
  is_leapyear(shift) ? 1 : 0;
}

Viele Gruesse,

n.d.p.

[1] siehe auch http://www.atomic-eggs.com/selfspezial/scbboard/841.html ...

P.S.: Was ist eigentlich ein "leapy-ear"? ;-)

[Vedat Yetkin]

Hi,

Ooops, mein Algorithmus berücksichtigt nicht, daß auch negative Datumsangaben in Sekunden erlaubt sind für Daten vor 1.1.1970 ...

aber das Prinzip sollte klar sein, oder?
Müsste man halt eine Fallabfrage vorher machen.

cu, Vedat

[Thomas J.S.]

Hallo Vedat,

Geht es Dir darum, welchen Algorithmus PERL selbst dazu verwendet, oder möchtest Du einfach einen Algorithmus, der das auch kann?

egal. da ich nur wusste das perl das kann fragte ich halt danach. ;-)

Ich denke, Du wirst damit klar kommen ...

oh, wohl kaum. ich kann gar kein perl ;-)
ich habe damit etwas anderes vor, deshalb möchte ich wissen wie das geht.

beispiel:
991950865  muss 07.06.2001, 23:54  zurückgeben.
wenn ich nur 991950865 (also ich habe die sekunden und möchte daraus die zeit ausrechnen) zur verfgügung habe, wie geht hier dein algorythmus vor?
--
sub sj {
  my $j = shift;
  my $sj = 0;
  if (($j % 4)==0) {$sj++} #Schaltjahr
  if (($j % 100)==0) {$sj--} #kein Schaltjahr, wenn durch 100 teilbar
  if (($j % 400)==0) {$sj++} # aber wenn auch durch 400 teilbar, dann doch Schaltjahr
  return $sj;
}

ich verstehe nicht was shift hier tut. ich habe nachgelesen was die funktion 'shift' macht, aber denn sinn verstehe ich hier nicht.

my ($jahr, $monat, $tag) = (1970,1,1); # Das Ganze beginnt bei 1.1.1970, 0:00 Uhr
my $t=time;  # hier steht das Datum im Sekundenformat ...

da würde jetzt also 991950865 stehen

my $zaehler=0; # hier zählen wir die Sekunden soweit hoch, bis wir das obige Datum erreicht haben

Erst mal die Jahre hochzählen ...

while ($zaehler<$t) {

ok, also das geht von 0 bis 991950864 (da 991950865 schon == wäre)

$zaehler +=(365 * 24 * 60 * 60);

also 991950864 + 31536000 macht 1023306864 (aber warum hier um eine sekunde weniger und um jahr hochzählen?)

$zaehler += (sj ($jahr) * 24 * 60 * 60);

das heisst also:
1023306864 + (und komme da nicht weiter: hier kommt das 'shift' von oben ins spiel nur wie? und was ist das ergebniss?

ich mache hier stop da ich ja nicht weiterrechnen kann. ;-)

grüße
thomas

[Vedat Yetkin]

Hallo Thomas,

Okay, ich hatte Perl-Kenntnisse vorausgesetzt. Dann probieren wir´s halt mal so...

beispiel:
991950865  muss 07.06.2001, 23:54  zurückgeben.
wenn ich nur 991950865 (also ich habe die sekunden und möchte daraus die zeit ausrechnen) zur verfgügung habe, wie geht hier dein algorythmus vor?

Den Algorithmus erkläre ich nachher in Worten... also prosaisch...

ich verstehe nicht was shift hier tut. ich habe nachgelesen was die funktion 'shift' macht, aber denn sinn verstehe ich hier nicht.

Mit sub beginnen Unterprogramme. So wie bei (Visual) Basic. Wenn ich in Basic stehen hab:
SUB Unterprogramm (a$, b$)

....
END SUB

dann kann ich dieses Unterprogramm aufrufem mit meinetwegen Unterprogramm ("hallo", "welt")

Die Variable a$ hat dann den Wert "hallo" und b$ den Wert "welt".
Bei Perl ist es anders. Bei Perl muß man die übergegebenen Werte an die Variable weitergeben ... genau das macht Shift ...

Um den Algorithmus zu erklären eigentlich unerheblich.

--------
Zum Algorithmus selbst:
Das Schema ist altbekannt, erinnert mich an die Grundschulübung, Geldbeträge mit so wenigen Münzen wie möglich zusammenzustellen.
6,23 DM wären also 1 x 5 DM, 1x 1 DM, 2 x 10 Pf, 1 x 2 Pf und 1 x 1 Pf ...

Wir haben also die Zahl 991950865.
Wir fangen mit bei 1.1.1970 an und zählen die Jahre hoch... (für jedes Jahr 365 * 24 * 60 * 60 bzw. bei Schaltjahren 366 * 24 * 60 * 60)
bis kein Jahr mehr "reinpasst".
Danach zählen wir die Monate hoch, bis keine mehr reinpassen ... und dann die Tage ...

Stunden und Minuten hab ich weggelassen, aber das Spielchen kann man da schön weitertreiben...
und was nach den Minuten übrig bleibt, sind die Sekunden.

Wie gesagt, localtime unterstützt aber auch negative Zahlen, die werden in meinem Algorithmus nicht unterstützt ...

Im Prinzip ist er also für den Mülleimer *g*

Ciao, Vedat

[Thomas J.S.]

Hallo Vedat,

Okay, ich hatte Perl-Kenntnisse vorausgesetzt.

was soll ich dazu sagen? ;-)
ich will nicht programmieren (auch wenn ich das in mancher hinsicht doch tue), sonst mach ich dann plözlich nichts anders als das.

ich verstehe nicht was shift hier tut. ich habe nachgelesen was die funktion 'shift' macht, aber denn sinn verstehe ich hier nicht.

Mit sub beginnen Unterprogramme.

ja, das ist mir klar.

Bei Perl muß man die übergegebenen Werte an die Variable weitergeben ... genau das macht Shift ...

aber shift nicht doch den ersten wert aus einer liste ung gibt ihn dan zurück ... nur welche liste haben wir hier?

Zum Algorithmus selbst:

Wir haben also die Zahl 991950865.
Wir fangen mit bei 1.1.1970 an und zählen die Jahre hoch... (für jedes Jahr 365 * 24 * 60 * 60 bzw. bei Schaltjahren 366 * 24 * 60 * 60)
bis kein Jahr mehr "reinpasst".

da muss du aber schon vorher wissen, welche bzw. wieviele schaltjahre es gab zwsichen 1970 und 'unserem' zeitpunkt, aber woher weisst du das?

----

Erst mal die Jahre hochzählen ...

while ($zaehler<$t) {
#was passiert hier:
$zaehler +=(365 * 24 * 60 * 60);

#hier ruft du dein sub 'sj' aus auf, aber was macht 1970 also ($jahr)? oder ist es einfach 1970x24x60x60 und die zahl dieser multiplikation jagst du durch 'sj' ?
$zaehler += (sj ($jahr) * 24 * 60 * 60);
$jahr++;
}
$jahr--;  #der Algorithmus oben schiesst um ein Jahr über :-)
$zaehler -=(365 * 24 * 60 * 60);
$zaehler -= (sj ($jahr) * 24 * 60 * 60);
----

wo genau passiert das, das hochzählen, das wäre für mich eher eine division als addition (+=) also: $time % (365 * 24 * 60 * 60)
oder bin ich jetzt sehr auf dem holzweg?

Grüße
Thomas

Das Gleiche mit dem Monat...

while ($zaehler<$t) {
$zaehler +=(tim($monat,$jahr) * 24 * 60 * 60);
$monat++;
}
$monat--;
$zaehler -=(tim($monat,$jahr) * 24 * 60 * 60);

Jetzt noch die Tage

while ($zaehler<$t) {
$zaehler +=(24 * 60 * 60);
$tag++;
}
$tag--;

Wenn Du lustig bist, kannst Du noch die Stunden und Minuten auf diese Weise hochzählen....

#Schnell mal kucken, was der gerechnet hat ...
print "$tag.$monat.$jahr";

... also bei mir hat er richtig gerechnet *g*

exit(0);

Danach zählen wir die Monate hoch, bis keine mehr reinpassen ... und dann die Tage ...

Stunden und Minuten hab ich weggelassen, aber das Spielchen kann man da schön weitertreiben...
und was nach den Minuten übrig bleibt, sind die Sekunden.

Wie gesagt, localtime unterstützt aber auch negative Zahlen, die werden in meinem Algorithmus nicht unterstützt ...

Im Prinzip ist er also für den Mülleimer *g*

Ciao, Vedat

[Thomas J.S.]

Hallo Vedat,

Okay, ich hatte Perl-Kenntnisse vorausgesetzt.

was soll ich dazu sagen? ;-)
ich will nicht programmieren (auch wenn ich das in mancher hinsicht doch tue), sonst mach ich dann plözlich nichts anders als das.

Mit sub beginnen Unterprogramme.

ja, das ist mir klar.

Bei Perl muß man die übergegebenen Werte an die Variable weitergeben ... genau das macht Shift ...

aber shift nimmt doch den ersten wert aus einer liste und gibt ihn dan zurück ... nur welche liste haben wir hier?

Zum Algorithmus selbst:

Wir haben also die Zahl 991950865.
Wir fangen mit bei 1.1.1970 an und zählen die Jahre hoch... (für jedes Jahr 365 * 24 * 60 * 60 bzw. bei Schaltjahren 366 * 24 * 60 * 60)
bis kein Jahr mehr "reinpasst".

da muss du aber schon vorher wissen, welche bzw. wieviele schaltjahre es gab zwsichen 1970 und 'unserem' zeitpunkt, aber woher weisst du das?

----

Erst mal die Jahre hochzählen ...

while ($zaehler<$t) {
#was passiert hier:
$zaehler +=(365 * 24 * 60 * 60);

#hier ruft du dein sub 'sj' aus auf, aber was macht 1970 also ($jahr)? oder ist es einfach 1970x24x60x60 und die zahl dieser multiplikation jagst du durch 'sj' ?
$zaehler += (sj ($jahr) * 24 * 60 * 60);
$jahr++;
}
$jahr--;  #der Algorithmus oben schiesst um ein Jahr über :-)
$zaehler -=(365 * 24 * 60 * 60);
$zaehler -= (sj ($jahr) * 24 * 60 * 60);
----

wo genau passiert das, das hochzählen. das wäre für mich eher eine division als addition statt += also: $time % (365 * 24 * 60 * 60)
oder bin ich jetzt sehr auf dem holzweg?

Grüße
Thomas

[Vedat Yetkin]

Hallo Thomas,

ich schreibe Dir morgen eine Mail (oder heute ... je nach dem, wie genau man´s nimmt ... auf jeden Fall werde ich vorher geschlafen haben).

Da kann ich auch auf jede einzelne Zeile im Skript eingehen.

Und wenn ich es vergesse, kannst Du mich nochmal fragen.

Ciao, Vedat

[Bernhard Peissl]

Grüssi olle mitanaunda!

Sorry wenn ich mir hier einschalte, aber von deinem Code Yedat halte ich mich eh fern, keine Sorge, den darfst du erklären ;-) nur kurz zum shift:

was soll ich dazu sagen? ;-)
ich will nicht programmieren (auch wenn ich das in mancher hinsicht doch tue), sonst mach ich dann plözlich nichts anders als das.

hmmm mysteriös, mysteriös :-?

Bei Perl muß man die übergegebenen Werte an die Variable weitergeben ... genau das macht Shift ...

aber shift nicht doch den ersten wert aus einer liste ung gibt ihn dan zurück ... nur welche liste haben wir hier?

Die Parameter die an eine Funktion übergeben werden kann man innerhalb der Funktion abfragen, sie werden nämlich in der Variable '@_' gespeichert. Das ist ein Feld, und an jeder Stelle steht ein Parameter mit der die Funktion aufgerufen wurde. Beispielsweise:

Wenn du bei einem Aufruf der Funktion 'func' zwei Werte übergibst ('string1' und 'string2') dann kannst du folgendermassen in der Funktion abfragen was übergeben wurde:

Aufruf: func('string1','string2')
Abfrage:
sub func {
    ($param1, $param2) = @_;
    print $param1."-".$param2;
}

Somit sind deine Übergabeparameter aus dem Feld in zwei Variablen aufgeteilt worden. Wenn du mehr Parameter übergeben willst, musst du das Feld (@_) eben auf mehrere Variablen "aufteilen".

Und shift, macht im Grunde nix anders als von diesem Feld (@_) immer das oberste Element abzufragen und an eine Variable zurückzugeben:

Das heisst also die Zeile
($param1, $param2) = @_;

macht dasselbe wie die zwei:
$param1 = shift;
$param2 = shift;

Es wird immer von oben weggenommen und (an eine Variable) zurückgegeben, ähnlich wie auch bei einem Kartenstoss. Du hebst immer nur eine Karte ab, und das immer von oben, an die unterste Karte (zuletzt übergebenen Parameter) kommst du nur ran, wenn du alle Karten w.o. abgehoben hast.

Wenn ein Stapel nun nur aus einer Karte besteht? Nun ja, dann nimmt er halt nur diese eine ;-) Und wenn an eine Funktion nur ein Parameter übergeben wird, dann hat das Feld @_ eben nur einen Eintrag, der dann mir shift stinknormal abgefragt wird. Da er immer das oberste nimmt ist die anzahl der Elemente fast wurscht, es müssen nur >= 1 Elemente in der Liste sein!

Der Aufruf aus Yedats script: sj($jahr) sollte dir nun etwas klarer sein ;-) ==> @_=($jahr)  ==> $j=shift;

So, ich hoffe ich hab dich nicht noch mehr verwirrt ;-)

lg bernhard

[Vedat Yetkin]

Hallo Pernarnd,

So, ich hoffe ich hab dich nicht noch mehr verwirrt ;-)

Nur unwesentlich, jetzt weiß keiner mehr, wie ich heisse *g*

Ciao, Vedat

[Bernhard Peissl]

Grüssi Yedat,

So, ich hoffe ich hab dich nicht noch mehr verwirrt ;-)
Nur unwesentlich, jetzt weiß keiner mehr, wie ich heisse *g*

??? *verwirrt* ???

Dein Name ist zwar eher den etwas exotischeren zuzuordnen ;-) aber ich hoffe ich hab mich nirgends peinlicherweise vertippt!

lg bernhard

[Vedat Yetkin]

Hallo Bernhard,

Grüssi Yedat,

Dein Name ist zwar eher den etwas exotischeren zuzuordnen ;-) aber ich hoffe ich hab mich nirgends peinlicherweise vertippt!

lol

ich heisse mit Vornamen trotzdem Vedat und nicht Yedat ... finde ich insofern lustig, weil ein Lehrer mich gerne mit Vetkin angesprochen hatte ... so, jetzt ist die Verwirrung komplett, freut mich, alle Klarheiten beseitigt zu haben.

Ciao Vedat

[Bernhard Peissl]

Hallo Vedat :o)

ich heisse mit Vornamen trotzdem Vedat und nicht Yedat ... finde ich insofern lustig, weil ein Lehrer mich gerne mit Vetkin angesprochen hatte

Sorry, da hab ich anscheinend zu schnell gelesen - solche Sachen schiebe ich immer gern auf Kollegen Murphy ;-) Aber ich habs vermerkt, wird nicht wieder passieren!

... so, jetzt ist die Verwirrung komplett, freut mich, alle Klarheiten beseitigt zu haben.

Nein - <?m=131021&t=25049> *fg* Hallo Wer, Wie? - _jetzt_ ist die Verwirrung komplett ;-)

Alle "Klarheiten" beseitigt? *g*

lg Bernhard

[Thomas J.S.]

hallo bernhard,

danke für die erklärung.
es ist etwas klarer geworden.

ich bin zugegeben etwas leicht belustigt, welche richtung meine frage nimmt, denn perl wollte ich nicht unbedingt lernen ;-)

das mit shift kam nur weil ich nicht nachvollzihen konnte wie der script rechnet.
und darum geht mir, deshalb habe ich ja auch gleich einen sekundenwert genommen, ich möchte wissen - so schritt für schritt - wie der script von sekunden auf das 'richtige' datum kommt. also etwas mathe ;-)

grüße
thomas

[Florian]

Hallo

ich habe ein ähnliches Problem:

Da auch der aktuelle Thread auf fast jede andere Programmiersprache anwendbar ist wäre ich dankbar wenn ein allgemeiner Algorithmus rauskäme, da ich noch nicht weiß, wie ich ihn implementieren werde

Wie kann man aus einem Datum die aktuelle Kalenderwoche rausbekommen???

Es ist wieder wie mit dem Schaltjahr, da gibt es irgendeine Bedingung wann z.B. die 1. KW beginnt aber wo steht so was ???

[RoRo]

Hallo

Wie kann man aus einem Datum die aktuelle Kalenderwoche rausbekommen???

moin,

use Kalender;
$woche = cal_week(11,6,2001);

das Modul findest Du auf meiner HP; Rolf

http://i-netlab.de/perlmod/ctdoc.htm