Prüfung:: Reporter:: Dattel:: Format-Perl-Baugruppe enthält formating Subroutinen der Dattel.

SYNOPSE

Gebrauch Prüfung:: Reporter:: Dattel:: Format;

@lt = localtime (Zeit);

Druck time2str ($template, Zeit);
Druck strftime ($template, @lt);

Druck time2str ($template, Zeit, $zone);
Druck strftime ($template, @lt, $zone);

Druck ctime (Zeit);
Druck asctime (@lt);

Druck ctime (Zeit, $zone);
Druck asctime (@lt, $zone);

Diese Baugruppe stellt Programme zu den Formatdatteln in ASCII-Zeichenketten zur Verfügung. Sie entsprechen dem c-Bibliotheksprogramme strftime und dem ctime.

time2str (SCHABLONE, ZEIT [, ZONE])

time2str konvertiert ZEIT in eine ASCII-Zeichenkette using die Umwandlungsangabe, die in der SCHABLONE gegeben wird. ZONE, wenn sie gegeben wird, spezifiziert die Zone, die der Ausgang benötigt wird, um innen zu sein, ZONE führt zu Ihrer aktuellen Zone.

strftime (SCHABLONE, ZEIT [, ZONE])

strftime ist time2str ähnlich, mit der Ausnahme daß wird die Zeit als Reihe, wie die Reihe vergangen, die durch localtime zurückgebracht wird.

ctime (ZEIT [, ZONE])

ctime ruft time2str mit den gegebenen Argumenten using die Umwandlungsangabe „%a %b %e %T %Yn“

asctime (ZEIT [, ZONE])

asctime ruft time2str mit den gegebenen Argumenten using die Umwandlungsangabe „%a %b %e %T %Yn“

Dattel:: Manip ist Programme einer Dattelhandhabung.

SYNOPSE

Gebrauch Dattel:: Manip;

$version = DateManipVersion;

$date = ParseDate (@args);
$date = ParseDate ($string);
$date = ParseDate ($string);

@date = UnixDate ($date, @format);
$date = UnixDate ($date, @format);

$delta = ParseDateDelta (@args);
$delta = ParseDateDelta ($string);
$delta = ParseDateDelta ($string);

@str = Delta_Format ($delta, $dec, @format);
$str = Delta_Format ($delta, $dec, @format);

$recur = ParseRecur ($string, $base, $date0, $date1, $flags);
@dates = ParseRecur ($string, $base, $date0, $date1, $flags);

$flag = Date_Cmp ($date1, $date2);

$d = DateCalc ($d1, $d2 [, $errref] [, $del]);

$date = Date_SetTime ($date, $hr, $min, $sec);
$date = Date_SetTime ($date, $time);

$date = Date_SetDateField ($date, $field, $val [, $nocheck]);

$date = Date_GetPrev ($date, $dow, $today, $hr, $min, $sec);
$date = Date_GetPrev ($date, $dow, $today, $time);

$date = Date_GetNext ($date, $dow, $today, $hr, $min, $sec);
$date = Date_GetNext ($date, $dow, $today, $time);

$name = Date_IsHoliday ($date);

$listref = Events_List ($date);
$listref = Events_List ($date0, $date1);

$date = Date_ConvTZ ($date);
$date = Date_ConvTZ ($date, $from);
$date = Date_ConvTZ ($date, "", $to);
$date = Date_ConvTZ ($date, $from, $to);

$flag = Date_IsWorkDay ($date [, $flag]);

$date = Date_NextWorkDay ($date, $off [, $time]);

$date = Date_PrevWorkDay ($date, $off [, $time]);

$date = Date_NearestWorkDay ($date [, $tomorrowfirst]);

&Date_Init ();
&Date_Init („VAR=VAL“, „VAR=VAL“,…);
@list = Date_Init ();
@list = Date_Init („VAR=VAL“, „VAR=VAL“,…);

Die oben genannten Programme aller Check, zum zu überprüfen, ob Date_Init gerufen. Wenn es nicht gewesen, rufen sie es automatisch. Infolgedessen gibt es normalerweise keine Notwendigkeit, Date_Init ausdrücklich zu rufen, es sei denn Sie einige der Configvariablen ändern möchten (unten beschrieben). Sie tun auch die Fehlerprüfung auf dem Input.

Die Programme, die nachstehend aufgeführt, bestimmt Haupt- für internen Gebrauch bis zu anderer Dattel:: Manip Programme. Sie tun wenig oder keine Fehlerprüfung und nicht ausdrücklich rufen Date_Init. Jene Funktionen alle erfolgt in der Hauptdattel:: Manip Programme oben.

Weil sie beträchtlich schneller als sind, datieren die vollen:: Manip Programme, sind sie für Gebrauch mit einigen Einsprüchen erhältlich. Da wenig oder keine Fehlerprüfung erfolgt, ist es die Verantwortlichkeit des Programmierers, zu garantieren, dass gültige Daten (UND gültige Datteln) ihnen überschritten. Das Überschreiten der unzulässigen Daten (wie ein nicht numerischer Monat) oder der unzulässigen Datteln (31. Februar) ausfällt auf unvorhersehbare Arten sz (vielleicht zurückgehende falsche Resultate). Vor der Anwendung dieser Programme auch da Date_Init nicht durch diese gerufen, muß es vom Programmierer ausdrücklich gerufen werden.

In den folgenden Programmen kann $y als Jahr mit 2 oder 4 Digits (es konvertiert in ein Jahr mit 4 Digits, das auf dem variablen unten beschriebenen YYtoYYYY basiert) eingeführt werden entweder. Monat und Tag sollten in allen Fällen numerisch sein. Die meisten (wenn nicht alle) der Informationen unten können von UnixDate erhalten werden, das wirklich die Methode ist, die, ich erhalten zu werden beabsichtigte sie, aber es gibt Gründe, diese zu verwenden (diese sind beträchtlich schneller).

$day = Date_DayOfWeek ($m, $d, $y);
$secs = Date_SecsSince1970 ($m, $d, $y, $h, $mn, $s);
$secs = Date_SecsSince1970GMT ($m, $d, $y, $h, $mn, $s);
$days = Date_DaysSince1BC ($m, $d, $y);
$day = Date_DayOfYear ($m, $d, $y);
($y, $m, $d, $h, $mn, $s) = Date_NthDayOfYear ($y, $n);
$days = Date_DaysInYear ($y);
$days = Date_DaysInMonth ($m, $y);
$wkno = Date_WeekOfYear ($m, $d, $y, $first);
$flag = Date_LeapYear ($y);
$day = Date_DaySuffix ($d);
$tz = Date_TimeZone ();

Dattel:: Formatierer-Perl-Baugruppe ist Nachricht einer einfachen Dattel- und Zeitformatierung.

SYNOPSE

Gebrauch Dattel:: Formatierer;

# eine Dattel erstellen:: Formatierernachricht mit dem Tagesdatum und der Zeit.
mein $date = Dattel:: Formatter->now ();

# ein Formatiererprogramm für diese Nachricht erstellen
# Formatierer Mini-sprachenunterlagen unten sehen
$date->createDateFormatter („(hh): (mm): (SS) (mm)/(DD)/(YYYY) ");

$date drucken; # Druckdattel in diesem Format - > 12:56: 03 4/12/2004

# den Formatierer für Gebrauch mit anderen Nachrichten erhalten
mein $formatter = $date->getDateFormatter ();

# einen Abstand der Zeit erstellen
mein $interval = Dattel:: Formatter->createTimeInterval (Jahre => 1, Tag=> 2, protokolliert => 15);

# Wiederverwendung das formater von oben
$interval->setDateFormatter ($formatter);

Druck $interval; # Druckdattel in diesem Format - > 12:56: 03 4/12/2004

# Gebrauch überbelastete Bediener
mein $future_date = $date + $interval;

# Sortierung die Datteln (wieder mit dem Überlastungsbediener)
meine @sorted_dates = Sortierung {$a <=> $b} ($date, $interval, $future_date);

Diese Baugruppe liefert eine schnelle und sehr flexible in den Formatierungsdatteln und -zeiten verwendet zu werden Mini-sprache. Zwecks die nützlich zwar bilden lassen, mußten wir eine völlig arbeitende Dattel- u. Zeitnachricht. Diese Nachricht schaut und riecht ganz wie das Java und die Javascript-Dattelnachricht auf Zweck. Wir überbelasteten auch einige Bediener, um Dattelzusatz und -abzug sowie Vergleiche zu erlauben.

Dattel:: Bekehrter:: French_Rev kann von/nach französischem revolutionärem Kalender konvertieren.

SYNOPSE

Gebrauch Dattel:: Bekehrter:: French_Rev;
Konvertieren von gregorianischem (oder von anderem) in Revolutionär
$date=new Dattel:: Bekehrter:: Gregorianisch (1799, 11, 9);
Bekehrter Dattel:: Bekehrter:: French_Rev $date;
Druck $date->date_string, „N“;
Druck $date->date_string ($format), „N“;
Konvertieren von revolutionärem in gregorianisches (oder anderes)
$date=new Dattel:: Bekehrter:: French_Rev (8, 2, 18);
Bekehrter Dattel:: Bekehrter:: Gregorianisches $date;
Druck $date->date_string, „N“;

Dattel:: Hijri ist eine Perl-Extension, zum der islamischen (hijri) und gregorianischen Datteln zu konvertieren.

SYNOPSE

Gebrauch Dattel:: Hijri;

# Bekehrter gregorianisch zur hijri Dattel
mein ($hd, $hm, $hy) = g2h ($gd, $gm, $gy);

# Bekehrter hijri zur gregorianischen Dattel
mein ($gd, $gm, $gy) = h2g ($hd, $hm, $hy);

Diese einfache Baugruppe konvertiert gregorianische Datteln zu islamischem (hijri) und umgekehrt.
Die Datteln müssen als Reihe gegeben werden, die den Tag, den Monat und das Jahr enthält und zurückbringen die entsprechende Dattel als Liste mit den gleichen Elementen eichen.

Kategorie:: Dattel ist eine Perl-Baugruppe, die einen einfachen Datteltypen für Perl zur Verfügung stellt.

Sie können neue Kategorie erstellen:: Nachrichten mit einem Erbauer von den verschiedenen Skalarformaten datieren, refs und Durcheinander refs kleiden, und dann können Sie ihn durch das builtin leicht manipulieren „+“ und“ - „Bediener (z.B., $date=date ([2001.03.15]) +3Y 1s). Relative Datteltypen auch erhältlich.

Was in diesem Auslösen neu ist:

· Dieses Auslösen hinzufügt „ampm“ und „meridiam“ Methoden.

TK:: Dattel ist ein Dattel/Zeit Widget für perl/Tk.

SYNOPSE

Gebrauch TK:: Dattel;
$date_widget = $top->Date->pack;
$date_widget->get („%x %X“);

TK:: Dattel implementiert einen Dattel/Zeit Widget. Es gibt drei Möglichkeiten, eine Dattel einzugeben:
Using die Tastatur, zum der Digits und der Tabulatortaste oder der Mäusenadelanzeige einzugeben, um Fokus zwischen Bereiche zu verschieben.

Anwendung auf und ab Cursortasten zur Stufensprung/zum Dekrement die Dattel (nur mit eingebauter TK:: NumEntryPlain Widget).

Das Auswählen auf und ab Pfeiltasten erhöht oder verringert den Wert des aktiven Bereichs (nur mit eingebauter TK:: FireButton Widget).

Das Dattel-/Zeit-Format

Anders als Java hat Perl nicht eine Dattel-/Zeitnachricht. Jedoch ist es möglich, die Unix-Zeit (Sekunden seit Epoche, die 1. Januar 1970 ist), als Abwechslung zu verwenden. Dieses ist begrenzt, da auf der meisten Architektur, die gültige Reichweite zwischen dem 14. Dezember 1901 und dem 19. Januar 2038 ist. Für andere Datteln ist es möglich, eine Durcheinanderdarstellung zu verwenden:

{o => Jahr,
m => Monat,
d => Tag,
H => Stunde,
M => Protokoll,
S => an zweiter Stelle}

Die Abkürzungen derivated von den Formatzeichen von strftime. Notiert, dass Jahr das volle Jahr (1998 anstelle von 98) ist und Monat ist die reale Monatszahl, im Vergleich mit dem Ausgang von localtime (), wo der Monat durch einen subtrahiert.

In diesem Dokument verwiesen die erste Methode als unixtime und die zweite Methode als datehash.

STANDARDoptionen

TK:: Datieren sinkt vom Feld und übernimmt alle seine Optionen.

- Orient

Spezifizierte Lagebestimmung der Stufensprung- und Dekrementtasten. Mag vertikal (Zahlungseinstellung) oder horizontal sein.

Zeit:: Format ist eine Perl-Baugruppe für bedienungsfreundliche Dattel-/Zeitformatierung.

SYNOPSE

Gebrauch Zeit:: Format qw (%time %strftime %manip);

$time {$format}
$time {$format, $unixtime}

Druck „ist heute $time {yyyy/mm/dd} N“;
Druck „war gestern $time {yyyy/mm/dd, time-24*60*60} N“;
„die Zeit drucken ist $time {hh: mm: SS} N“;
„eine andere Zeit drucken ist $time {H: mm morgens TZ, $another_time} N“;
Druck „Zeitstempel: $time {yyyymmdd.hhmmss.mmm} N“;
%time nimmt auch Dattel: an: Manip Zeichenketten und Datum-Zeit-Nachrichten:
$dm = Dattel:: Manip:: ParseDate (letzten Montag);
Druck „war letzten Montag $time {Monat d, yyyy, $dm}“;
$dt = DateTime->new (….);
Druck „Heres eine andere Dattel: $time {m/d/yy, $dt}“;
Es nimmt auch die meisten Zeichenketten der Dattel ISO-8601/der Zeit an:
$t = 2005/10/31 T17: 11: 09; # Datteltrennzeichen: /oder - oder.
$t = 2005-10-31 17.11.09; # zwischen Trennzeichen: T oder _ oder Platz
$t = 20051031_171109; # Zeittrennzeichen: : oder.
$t = 20051031171109; # können Trennzeichen ausgelassen werden
$t = 2005/10/31; # ist Dattel-nur okay
$t = 17:11: 09; # ist Zeit-nur okay
# aber nicht:
$t = 20051031; # Dattel-nur ohne Trennzeichen
$t = 171109; # Zeit-nur ohne Trennzeichen
#…, weil die wie Epochezeitzahlen aussehen.
%strftime arbeitet wie POSIXs strftime, wenn Sie jene %-formats mögen.
$strftime {$format}
$strftime {$format, $unixtime}
$strftime {$format, $sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst}

Druck „POSIXish: $strftime {%A, %B %d, %Y, 0.0.0.12.11.95.2} N“;
Druck „POSIXish: $strftime {%A, %B %d, %Y, 1054866251} N“;
Druck „POSIXish: $strftime {%A, %B %d, %Y} N“; # aktuelle Uhrzeit
%manip arbeitet wie Dattel:: Manips UnixDate Funktion.
$manip {$format};
$manip {$format, $when};

Druck „Dattel:: Manip: $manip {%m/%d/%Y} N“; # aktuelle Uhrzeit
Druck „Dattel:: Manip: $manip {%m/%d/%Y, letzten Dienstag} N“;
Diese können als unabhängige Funktionen auch verwendet werden:
Gebrauch Zeit:: Format qw (time_format time_strftime time_manip);

Druck „ist heute“, time_format (yyyy/mm/dd, $some_time), „N“;
Druck „POSIXish: “, time_strftime (%A %B %d, %Y, $some_time), „N“;
Druck „Dattel:: Manip: “, time_manip (%m/%d/%Y, $some_time), „N“;

Diese Baugruppe erstellt globale Pseudovariablen, die Formatdatteln und -zeiten, entsprechend Formatierungscodes Sie ihnen in den Zeichenketten führen.

Die %time Formatierungscodes sind konzipiert, um einfach zu sein, sich zu erinnern und zu verwenden, und gerade bis zu Zeichen den Ausgangzeitwert aufzunehmen, wann immer möglich. Z.B. ist der Vierzahlenjahrcode, die Dreizeichen Monatsabkürzung ist „Montag“ „yyyy“.

Die nette Sache über Haben von a variabel-wie Schnittstelle anstelle von den Funktionsaufrufen ist, dass die Werte innerhalb der Zeichenketten verwendet werden können (sowie außerhalb der Zeichenketten in den gewöhnlichen Ausdrücken). Datteln werden häufig innerhalb der Zeichenketten (Bordbuchmeldungen, Ausgang, Datensätze, usw.) verwendet, also, die Fähigkeit ist zu haben, sie zu interpolieren direkt handlich.

Perl erlaubt willkürliche Ausdrücke innerhalb der lockigen Klammern eines Durcheinanders, selbst wenn dieses Durcheinander in eine Zeichenkette interpoliert wird. Dieses erlaubt Ihnen, Berechnung schnell zu tun bei der Formatisierung von Zeiten und dem Einstecken sie in Zeichenketten. Das Beispiel „gestern“ oben sehen.

Die Formatzeichenketten sind mit Programmierern im Verstand konzipiert. Was benötigen Sie sehr häufig? 4-stelliges Jahr, Monat, Tag, 24 gründete Stunde, Protokoll, zweites -- normalerweise mit führenden null. Diese sechs sind die einfachsten in der Zeit zu verwenden und sich zu erinnern Formate:: Format: yyyy, mm, DD, hh, mm, SS. Varianten auf diesen Formaten folgen einer einfachen und gleichbleibenden Formel. Diese Baugruppe ist für jeder, das vom Versuchen, sich strftime (3) s an obskure Codes zu erinnern träge ist, oder von $t [4] ++ endlos schreiben; $t [5] +=1900 als Sie formatieren manuell Zeiten oder Datteln.

Notiert, dass mm (und in Verbindung stehende Codes) für Monate und Protokoll verwendet werden. Dieses ist ein Merkmal. %time löst die Mehrdeutigkeit, indem es andere nahe gelegene Formatierungscodes prüft. Wenn sein im Rahmen eines Jahres oder eines Tages, „Monat“ angenommen wird. Wenn im Rahmen einer Stunde oder einer Sekunde, „Protokoll“ angenommen wird.

Die Formatzeichenketten werden nicht bedeutet, um jede überhaupt empfangene Dattel-/Zeitnotwendigkeit umzugeben. Aber wie oft benötigen Sie den Tag des Jahres (strftimes %j) oder die Wochenzahl (strftimes %W)?

Für Fähigkeiten, die %time nicht voraussetzt, stellt %strftime eine Schnittstelle zum POSIXs strftime zur Verfügung, und %manip stellt eine Schnittstelle zur Dattel: zur Verfügung: Manip Baugruppee UnixDate Funktion.

Wenn die Deckfensterbaugruppe Zeit:: Format_XS ist auch, Zeit: eingebaut: Format spürt auf und verwendet es. Dieses ergibt eine beträchtliche Drehzahlzunahme für %time und time_format.

PHP-Dattel-Picker-Kategorienbibliothek legt automatisch den erforderlichen HTML-und Javascriptcode fest, der ein pop-up Fenster scheinen läßt, den Benutzer herr5uhren von wählen zu lassen ein Kalender. Die ausgewählte Dattel wird zu einer benutzerspezifischen Steuerung von der rufenden Seite überschritten.

Jeder Aspekt ist kundengerecht, indem er eine Schablone und eine in Verbindung stehende CSS-Datei ändert. Das Format, in dem die Dattel zurückgebracht wird, die Zahlungseinstellungdattel und der Zeitraum und der erste Tag der Woche können ausgewählt werden.

Vielen Dank Johan van Ieperen für das Senden Achim in die holländische Übersetzung für die PHP-Kategorie und für den wertvollen Kommentar, den er für bildete das Verbessern von Brauchbarkeit, von Deutschland für das Finden der Marke, die oben den Kalender auf bestimmten Situationen schrauben und auch zu Wassilios Meletiadis für das Senden in die deutsche Übersetzung für diese PHP-Kategorie danken würde.

Weitere Vorschläge, kommentiert und Anträge welcommed. Identifikation auch schätzen wirklich, wenn Sie mich Links zu den Webseiten schicken konnten, in denen Sie die Kategorie verwenden, also ich sie als Hinweis geben und mehr Leute überzeugen kann, ihn zu verwenden. Danke!

Was in diesem Auslösen neu ist:

· Die ausgewählte Dattel und die Zeit wurden nicht konserviert, wenn der Monat oder das Jahr geändert wurden.
· Using jedes mögliches Dattelformat anders als die Zahlungseinstellung würde alle Datteln veranlassen, überall abgeschalten zu werden.
· Ein potenzielles Problem mit selectableYearsRange und selectableTimesRange war örtlich festgelegt.
· Die Ursache des Problems war die Tatsache, dass Funktion der PHPs Dattel () eine Zeichenkette zurückbringt und folglich Dattel („O“) das Tagesdatum als Zeichenkette eher als eine ganze Zahl zurückbringen würde, die den Kalender unbrauchbar bildete.

Datum/Uhrzeit:: Format:: Seite ist eine Perl-Baugruppe, zum zu analysieren und Format PostgreSQL Datteln und Zeiten.

SYNOPSE

Gebrauch Datum/Uhrzeit:: Format:: Seite;

mein $dt = Datum/Uhrzeit:: Format:: Pg->parse_datetime (23:12 2003-01-16: 01);

# 2003-01-16T23: 12: 01+0200
Datum/Uhrzeit:: Format:: Pg->format_datetime ($dt);

Diese Baugruppe versteht die Formate, die von PostgreSQL für seine DATTEL-, ZEIT-, ZEITSTEMPEL- und ABSTAND-Daten Typen verwendet werden. Sie kann verwendet werden, um diese Formate zu analysieren, um Datum-Zeit-- oder Datum/Uhrzeit zu erstellen:: Dauernachrichten und sie können ein Datum-Zeit-- oder Datum/Uhrzeit nehmen:: Dauernachricht und produzieren eine Zeichenkette, die sie in einem Format darstellt, das von PostgreSQL angenommen wird.

ERBAUER

Die folgenden Methoden können angewendet werden, um Datum/Uhrzeit zu erstellen:: Format:: Seitennachrichten.
neu (Namens=> Wert,…)

Erstellt ein neues Datum/Uhrzeit:: Format:: Seitenfall. Dieses wird im Allgemeinen nicht für einfache Arbeitsweisen benötigt. Wenn Sie eine andere Satzgliederungsart von der Zahlungseinstellung verwenden möchten dann, ist sie bequemer, eine Nachricht zu erstellen.

mein $parser = Datum/Uhrzeit:: Format:: Pg->new ()
mein $copy = $parser->new (europäisches => 1);

Diese Methode nimmt die folgenden Optionen an:

europäisch

Wenn Europäer auf ungleich Null eingestellt wird, werden Datteln angenommen, um im europäischen dd/mm/yyyy Format zu sein. Die Zahlungseinstellung ist, Format US-mm/dd/yyyy anzunehmen (weil dieses die Zahlungseinstellung für PostgreSQL ist).

Diese Option hat nur einen Effekt, wenn PostgreSQL auf Ausgangdatteln im PostgreSQL (nur DATTEL) und IN DEN SQL-(DATTEL und ZEITSTEMPEL) Arten eingestellt wird.
Notiert, dass Sie diese Option nicht einstellen müssen, wenn der PostgreSQL Server eingestellt worden ist, um das ISO-Format zu verwenden, das die Zahlungseinstellung ist.

server_tz

Diese Option kann auf ein Datum/Uhrzeit eingestellt werden:: TimeZonenachricht oder eine Zeichenkette, die einen Zeitzonennamen enthält.

Dieser Wert muß auf den gleichen Wert eingestellt werden, den die PostgreSQL Server-Zeitzone, zwecks ZEITSTEMPEL MIT TIMEZONE zu analysieren im PostgreSQL, im SQL und in den deutschen Formaten richtig bewertet.

Notiert, dass Sie diese Option nicht einstellen müssen, wenn der PostgreSQL Server eingestellt worden ist, um das ISO-Format zu verwenden, das die Zahlungseinstellung ist.

klonen ()

Diese Methode wird für die zur Verfügung gestellt, die es vorziehen, über eine Methode ausdrücklich zu klonen, die Klon genannt wird ().

mein $clone = $original->clone ();

Wenn Sie gerufen werden, wie eine Kategorienmethode, die sie stirbt.

Dattel:: ICal ist eine Perl-Extension für ICalendar Dattelnachrichten.

SYNOPSE

Gebrauch Dattel:: ICal;

$ical = Dattel:: ICal->new (ical => 19971024T120000);
$ical = Dattel:: ICal->new (Epoche => Zeit);
$ical = Dattel:: ICal->new (Jahr => 1964,
Monat => 10, Tag=> 16, Stunde => 16,
minimales => 12, sek => 47);

$hour = $ical->hour;
$year = $ical->year;

$ical_string = $ical->ical;
$epoch_time = $ical->epoch;

$ical2 = $ical + $duration;
(Wo $duration entweder eine Dauerzeichenkette, wie P2W3DT7H9M oder eine Dattel: ist: ICal:: Nachricht der Dauer (qv).
$ical += P6DT12H;

$duration = $ical1 - $ical2;
$ical3 = $ical1 - $duration;

Dattel-Pcalc ist eine Perl-Baugruppe und ist eine direkte Übersetzung ausgezeichneten Dattel der Steffen-Beyers:: Calc-Baugruppe, zum von Perl nur anstelle von einer Kombination von Perl und von C. zu verwenden.

Dieses Paket besteht aus einer Perl-Baugruppe für alle Arten Terminberechnungen, die auf dem Gregorianischen Kalender basieren (der heute verwendet in allen westlichen Ländern), dadurch eseinwilligt eseinwilligt mit allen relevanten Normen und Standards: ISO/R 2015-1971, LÄRM 1355 und in gewissem Grade ISO 8601 (wo anwendbar).

Java-Dattel-Picker ist eine Suite der Dattelteile für Schwingen, in hohem Grade geschätzt durch Java-Entwickler für seinen Reichtum der Merkmale, der Flexibililtät und der gut in Handarbeit gemachten API. Java-Dattel-Pickerprojekt enthält einen editable Dattelpicker, einen Dattel-/Zeitbereich, einen mehrfachen Monatskalender und ein Monatsteil.

Sind hier einige Hauptmerkmale „des Java-Dattel-Pickers“:

· Lots Merkmale, zum irgendeiner Dattel/Zeiteintragungssituation zu handhaben
· Vorsichtige und well-crafted API, zum der Entwicklung Ihrer Anwendung zu beschleunigen
· Microsoft-wie der Kalender, zum des gleichen Gefühls für Benutzer beim Bewegen zu halten auf Java-Anwendungen
· Mäuse- und Tastaturträger, zum von Datum-Zeit-Informationen intuitiv einzubringen
· Ausführliches Tutorium und Beispiele, zum die die meisten aus der API heraus zu erhalten
· Quellencodezugriff, zum der Lebensdauer Ihrer Anwendung sicherzustellen
· Arbeiten mit J2SE 1.3 oder höheres auf Windows, Mac, Linux und allem Java aktivierten Plattformen
· Abgabe geben Verteilung frei

Schwingen gefällig

Die Teile können für jede mögliche Sprache und Region beschränkt werden
Gebrauchsfertiger JTable Dattelzellenherausgeber also -c$sie müssen ein nicht schreiben
Tastaturträger für maximale Produktivität
Träger (Metall, Windows, Motiv, Aqua und Zoll) schauen und glauben

Flexible API

Dattelbaumuster, zum der bearbeiteten Dattel zu steuern
Syntaxanalyse datieren, um Abkürzungdatteln wie „gestern“ oder „heute zu analysieren + 3“
Renderer datieren, um Kalendertage anzustreichen, wie Sie brauchen
Auswahlbaumuster datieren, um alles über die selected/-able Datteln zu steuern
Delegierte des Zolls UI, zum fein einzustellen oder sogar reimplement das UI, wie Sie mögen

Dattel-Auswahl

Auswahltyp mögen einzelnen, einzelnen Abstand oder mehrfache Abstände
Woche und Tag des Wochenauswahlträgers
Ungültiger Dattelträger, zum der maximalen Dattel Flexibilität eingeben zu lassen
Datteln auf einen Abstand wie 1. Januar 2002 einschränken - 7. April 2003
Datteln mit Richtlinien einschränken, wie „Wochenendendatteln nicht ausgewählt werden können“, oder „Feiertage nicht ausgewählt werden können“
Einzelne Datteln wie 3. Januar 2005 einschränken

Datum-Zeit-bearbeiten

Der strukturierte dieser Herausgeber erzwingt Benutzer, syntaktisch gültige Datteln using jedes mögliches Dattelformat zu schreiben
Textträger, zum der Datteln als einfacher Text, ohne Begrenzungen zu erreichen
Abkürzungdattelträger also -c$sie können Abkürzungzeichenketten wie „heute“, „Weihnachten“ schreiben oder „morgen“, um eine Dattel zu spezifizieren
Gültigkeitserklärung datieren, um Benutzer vom Machen von Fehlern zu halten
Bereichzugriff datieren, um volle Kontrolle in einer bearbeiteten Dattel zu haben

Konfiguration eintragen

Mehrfacher Monatskalender, zum eines Vierteljahres oder des vollständigen Jahres anzusehen
Steuerrasterfeldfarbe und -sicht
Die Kalendertage anstreichen, wie Sie mit Dattel renderers mögen
Kundenspezifische Schrifttypen und Farben, zum einer intuitiven Schnittstelle zu erstellen
Wochenzahlen und -tage zeigen oder verstecken

Was in diesem Auslösen neu ist:

· Dieses Auslösen addiert Träger für den JBuilders dbSwing verbindlichen Rahmen der Daten.
· Es verbessert den Dattelherausgeber, um Monatsnamen zu unterstützen.
· JDatePicker wird schneller erstellt (vergleichbar mit JComboBox).
· Der JDatePicker Kalender kann using eine Popup- Nachricht jetzt konfiguriert werden.
· Die JDatePicker Kategorie hat wenige Methoden (verringert von 29 bis 7).
· Es gibt andere Verbesserungen und bugfixes.

Datum/Uhrzeit:: Format:: Erbauer ist eine Perl-Baugruppe, zum der Datum-Zeit-Syntaxanalysenkategorien und -nachrichten zu erstellen.

SYNOPSE

Paket Datum/Uhrzeit:: Format:: Schriftsatz;
unser $VERSION = 0.07;
Gebrauch Datum/Uhrzeit:: Format:: Erbauer
(
Syntaxanalysen => {
parse_datetime => [
{
regex => qr/^ (d {4}) (DD) (DD) (DD) (DD) (DD,) $,
Params => [qw (Jahrmonatstagesstundenprotokoll an zweiter Stelle)],
},
{
regex => qr/^ (d {4}) (DD) (DD) $,
Params => [qw (Jahrmonatstag)],
},
],
}
);

Datum/Uhrzeit:: Format:: Erbauer erstellt Datum-Zeit-Syntaxanalysen. Viele reihen Formate der Datteln auf und Zeiten sind einfach und erfordern gerade einen grundlegenden regulären Ausdruck, die relevante Information zu extrahieren. Erbauer liefert eine einfache Methode, dies ohne Schreibenspakete des strukturellen Codes zu tun.

Erbauer liefert einige Methoden, denen die meisten youll nie benötigt, oder mindestens braucht selten. Theyre stellte mehr für das Freilegen der Baugruppeninnereien allen möglichen Unterklassen oder für zur Verfügung, wenn Sie etwas tun müssen etwas über, was hinaus ich erwartete.

Dattel:: Ist eine Extension Perl-OO für das Handhaben der Datteln der römischen Art römisch.

SYNOPSE

Gebrauch Dattel:: Römisch;

$caesar_death = Dattel:: Roman->new (römische => Identifikation 3 702);

Druck $caesar_death->ical (), „N“; #prints -520315

Diese Baugruppe definiert eine Kategorie für das Handhaben der römischen Datteln, wie von Julius Caesar in 45 BC definiert.

Dattel-Rechner ist eine Dattelrechneranwendung, die in pyqt geschrieben. Sie können Tage zu einer Dattel hinzufügen oder subtrahieren, oder die Zahl Tagen zwischen zwei Datteln berechnen.

Sie können auch beschließen, Ihre Berechnungen using nur Arbeitstage laufen zu lassen und/oder einschließlich des Anfangs/der Enddaten zu berechnen. Es gibt ein komplettes GUI für Einstellungsfeiertagsdatteln.

Feiertage können örtlich festgelegte jährliche Datteln, variable Datteln sein, wie „der 1. Montag im Juni“ oder „der engste Montag zum 22. Februar“. Dieses Hilfsprogramm könnte für Leute, die sein müssen, kritische Stichtage der Zeit zu berechnen, wie Rechtsanwälte nützlich sein.

Dattel-Rechneranwendung ist auch als superkaramba Thema erhältlich. Sie können beide vom Downloadlink zentralladen.

Datum/Uhrzeit:: Format:: Ist eine Perl-Baugruppe mit römischer Tagesnumerierung für Datum-Zeit-Nachrichten römisch.

SYNOPSE

Gebrauch Datum/Uhrzeit:: Format:: Römisch;

mein $formatter = Datum/Uhrzeit:: Format:: Roman->new (
Muster => %d %f %b %y);

mein $dt = DateTime->new (Jahr => 2003, Monat => 5, Tag=> 28);

$formatter->format_datetime ($dt);
# Kal Juni 2003 5

Diese Baugruppe formatiert Datteln in der römischen Art.

Die Römer ausdrückten ihre Datteln in Beziehung zu drei reparierten Datteln pro Monat en. Z.B.: das Ides von März war das 15. dieses Monats; 14. März genannt „2 Ides“, 13. März gerufen „3 Ides“, etc. Die Tage zur Hälfte zweite des Monats benannt nach dem ersten Tag des nächsten Monats, das „Kalends“; z.B. 16. März genannt „17 Kalends von April“.

METHODEN

neu (Muster => $string)

Erstellt eine neue Formatierernachricht. Das wahlweiseformatierungsmuster definiert das Format des Ausgangs von format_datetime (). Wenn kein Formatierungsmuster gegeben, verwendet eine angemessene Zahlungseinstellung.

format_datetime ($datetime)

Retruns die formatierte Zeichenkette. Diese Methode kann ersucht werden um einer Formatierernachricht (erstellt durch neues ())oder sie kann als Kategorienmethode gerufen werden. Im letzten Fall verwendet das Zahlungseinstellungmuster.

MUSTER-SPEZIFIKATIONSELEMENTE

Die folgenden Spezifikationselemente erlaubt in den Formatzeichenketten, die zur neuen gegeben () Methode:

%b

Der abgekürzte Monatsname.

%B

Der volle Monatsname.

%d

Der Tag des Monats als dezimale Zahl (einschließlich 1 für die örtlich festgelegten Tage).

%D

Der Tag des Monats, geschrieben als Zahl plus den entsprechenden örtlich festgelegten Tag.

%f

Das örtlich festgelegte Tagesteil der Dattel.

%m

Der Monat als dezimale Zahl (Reichweite 1 bis 12).

%y

Das Jahr als dezimale Zahl.

Wenn ein Spezifikationselement von O oder von O vorangegangen, geschrieben Zahlen in die Versalien- und kleingeschriebenen römischen Ziffern, beziehungsweise.

Das %f Spezifikationselement akzeptiert ein zusätzliches Argument von 1 Digit und spezifiziert die Länge des Ausgangs:

%0f: abgekürzter Name (z.B. „Kal“)
%1f: vollständiger Name (z.B. „Kalends“)
%2f: Einzeichen Abkürzung (z.B. „K“)

Datum/Uhrzeit:: Format:: Erbauer:: Tutorium ist eine schnelle Kategorie auf der Anwendung des Erbauers.

ERSTELLEN EINER KATEGORIE

Wie die meisten Leute, die Baugruppee schreiben, wissen, beginnen Sie ein Paket mit einer Paketanmeldung und einigen Hinweisen über Baugruppenversion:

Paket Datum/Uhrzeit:: Format:: ICal;
unser $VERSION = 0.04;

Nach diesem rufen Sie Erbauer mit etwas Optionen. Es gibt nur einige (später einzeln aufgeführt). Im Augenblick waren an den Syntaxanalysen nur interessiert.

Gebrauch Datum/Uhrzeit:: Format:: Erbauer
(
Syntaxanalysen => {
…
}
);

Die Syntaxanalysenoption nimmt einen Hinweis auf einem Durcheinander der Methodennamen und -bedingungen:

Syntaxanalysen => {
parse_datetime =>…,
parse_datetime_with_timezone =>…,
…
}

Erbauer erstellt Methoden in Ihrer Kategorie, jede Methode, die eine Syntaxanalyse ist, die den gegebenen Bedingungen folgt. Es empfohlen stark, dass eine Methode parse_datetime genannt, sei es eine Erbauer erstellte Methode oder die von Ihren Selbst.

Zusätzlich zum Erstellen irgendwelche der Syntaxanalysenmethoden erstellt es auch eine neue () Methode, die instantiate (oder Klon) Nachrichten dieser Kategorie kann. Dieses Verhalten kann mit der Erbaueroption geändert werden, aber wir brauchen nicht, das noch zu wissen.

Jeder Wert, der einem Methodennamen in der Syntaxanalysenliste entspricht, ist entweder eine einzelne Bedingung oder eine Liste von Bedingungen. Wohler Anfang mit dem einfachen Fall.

parse_briefdate => {
Params => [qw (Jahrmonatstag)],
regex => qr/^ (dddd) (DD) (DD) $,
},

Dieses ergibt eine Methode, die parse_briefdate benannt, das Zeichenketten in der Form 20040716 nimmt und die Datum-Zeit-Nachrichten zurückbringt, die diese Dattel darstellen. Ein Benutzer der Kategorie konnte schreiben:

Gebrauch Datum/Uhrzeit:: Format:: ICal;
mein $date = „19790716“;
mein $dt = Datum/Uhrzeit:: Format:: ICal->parse_briefdate ($date);
„meinen Geburtsmonat drucken ist“, $dt->month_name, „N“;

Das regex angewendet bis die Inputzeichenkette und wenn es abgleicht, dann $1, $2 2,… abgebildet zu den Params 2, die DateTime->new gegeben und übergeben (). Im Wesentlichen:

mein $rv = DateTime->new (Jahr => $1, Monat => $2, Tag=> $3);

Es gibt schwierigere Sachen man kann innerhalb einer einzelnen Bedingung, aber des wohlen Deckels später tun die.

Häufig wünschen youll eine Methode in der Lage sein, eine Zeichenkette zu nehmen und laufen lassen sie gegen mehrfache Syntaxanalysenbedingungen. Es sein sehr irritierend, wenn der Benutzer ausarbeiten mußte, welches Format die Datum-Zeit-Zeichenkette innen und dann war, die Methode am angebrachtesten war.

So läßt Erbauer Sie mehrfache Bedingungen spezifizieren:

parse_datetime => [
{
Params => [qw (Jahrmonatstagesstundenprotokoll an zweiter Stelle)],
regex => qr/^ (dddd) (DD) (DD) T (DD) (DD) (DD) $,
},
{
Params => [qw (Jahrmonatstagesstundenprotokoll)],
regex => qr/^ (dddd) (DD) (DD) T (DD) (DD) $,
},
{
Params => [qw (Jahrmonats-Tagesstunde)],
regex => qr/^ (dddd) (DD) (DD) T (DD) $,
},
{
Params => [qw (Jahrmonatstag)],
regex => qr/^ (dddd) (DD) (DD) $,
},
],

Sein ein arrayref von Bedingungen. Eine Syntaxanalyse erstellt, die jede dieser Bedingungen sequentiell versucht, in der Ordnung, die Sie spezifizierten.

Datum/Uhrzeit:: Cron:: Ist eine Perl-Baugruppe einfach, die eine cron Eingabe und einen Check gegen aktuelle Uhrzeit analysieren kann.

SYNOPSE

Gebrauch Datum/Uhrzeit:: Cron:: Einfach;

$c = Datum/Uhrzeit:: Cron:: Simple->new ($cron);

$boolean = $c->validate_time;

$c->new_cron ($cron);

Diese Baugruppe ist eine schnelle und schmutzige Methode, festzustellen, wenn ein cron Zeitformat während des Tagesdatums und der Zeit gültig ist.

Eine cron Eingabe richtet dem nac cron Format vom crontab (5).

Die validate_time Funktion verwendet das Tagesdatum und die Zeit für Vergleich, aber annehmen auch eine gültige Datum-Zeit-Nachricht als Parameter.

BEISPIEL

Gebrauch Datum/Uhrzeit:: Cron:: Einfach;

$c = Datum/Uhrzeit:: Cron:: Simple->new (0-59/2 10.12 * * 5);

wenn ($c->validate_time) {…}

$c->new_cron (* * 1 * 0);

wenn ($c->validate_time) {…}

Datum/Uhrzeit:: Format:: Excel ist eine Perl-Baugruppe, die zwischen Datum-/Uhrzeit und Excel-Datteln konvertieren kann.

SYNOPSE

Gebrauch Datum/Uhrzeit:: Format:: Excel;

# von Excel über Kategorienmethode:

mein $datetime = Datum/Uhrzeit:: Format:: Excel->parse_datetime (37680);
Druck $datetime->ymd (.); # 2003.02.28

# oder über eine Nachricht

mein $excel = Datum/Uhrzeit:: Format:: Excel->new ();
Druck $excel->parse_datetime (25569) - >ymd; # 1970-01-01

# zurück zu Excel-Zahl:

Datum/Uhrzeit verwenden;
mein $dt = DateTime->new (Jahr => 1979, Monat => 7, Tag=> 16);
mein $daynum = Datum/Uhrzeit:: Format:: Excel->format_datetime ($dt);
Druck $daynum; # 29052

# oder über eine Nachricht
mein $other_daynum = $excel->format_datetime ($dt);
Druck $other_daynum; # 29052

Excel verwendet ein anderes System für seine Datteln als die meisten Unix-Programme. Diese Baugruppe erlaubt Ihnen, zwischen einigen der Excel-rohen Formate und Datum-Zeit-Nachrichten zu konvertieren, die über irgendwelche des anderen Datum/Uhrzeit dann weiter konvertiert werden können:: Format:: * Baugruppee oder gerade mit DateTimes Methoden.

Wenn Sie geschehen, Datteln zwischen dem 1. Januar 1900 zu beschäftigen und dem 1. März 1900 bitte die Mitteilungen auf Epochen las.

Wenn das youre, das tatsächliche Kalkulationstabellendateien, Sie handhaben wünscht Kalkulationstabelle finden kann:: WriteExcel und Kalkulationstabelle:: ParseExcel des Gebrauches.