delphi - parseexact - Convertir una cadena a TDateTime en base a un formato arbitrario

iformatprovider datetime c#

Question

¿Hay alguna forma en Delphi 5 de convertir una cadena a un TDateTime donde pueda especificar el formato real que se usará?

Estoy trabajando en un procesador de trabajo, que acepta tareas de varias estaciones de trabajo. Las tareas tienen un rango de parámetros, algunos de los cuales son fechas, pero (desafortunadamente, y fuera de mi control) se pasan como cadenas. Como los trabajos pueden provenir de diferentes estaciones de trabajo, el formato de fecha y hora real utilizado para formatear las fechas como una cadena podría (y, por supuesto, la diferencia real).

Buscando en Google, la única solución rápida que encontré fue cambiar la variable ShortDateFormat y restaurarla a su valor original después. Dado que ShortDateFormat es una variable global, y estoy trabajando en un entorno de subprocesos, la única forma en que esto funcionaría es sincronizando cada acceso a él, lo cual es completamente inaceptable (y no se puede deshacer).

Podría copiar el código de la biblioteca de la unidad SysUtils en mis propios métodos, y modificarlos para que funcionen con un formato específico en lugar de las variables globales, pero me pregunto si hay algo más adecuado que no haya visto.

Un cordial saludo, y gracias de antemano,

Willem

ACTUALIZAR

Para decirlo de forma más sucinta:

Necesito algo como StrToDate (o StrToDateTime ), con la opción agregada de especificar el formato exacto que debería usar para convertir la cadena a un TDateTime.

Answer 1

Aquí está la función, y sus dos ayudantes, escribí para analizar una cadena usando un formato de fecha y hora exacto . Y dado que Stackoverflow también es un código-wiki: aquí está todo el código:

class function TDateTimeUtils.TryStrToDateExact(const S, DateFormat: string; PivotYear: Integer;
out Value: TDateTime): Boolean;
var
Month, Day, Year: Integer;
Tokens: TStringDynArray;
CurrentToken: string;
i, n: Integer;
Partial: string;
MaxValue: Integer;
nCurrentYear: Integer;
function GetCurrentYear: Word;
var
y, m, d: Word;
begin
DecodeDate(Now, y, m, d);
Result := y;
end;
begin
Result := False;
{
M/dd/yy
Valid pictures codes are
d Day of the month as digits without leading zeros for single-digit days.
dd Day of the month as digits with leading zeros for single-digit days.
ddd Abbreviated day of the week as specified by a LOCALE_SABBREVDAYNAME* value, for example, "Mon" in English (United States).
Windows Vista and later: If a short version of the day of the week is required, your application should use the LOCALE_SSHORTESTDAYNAME* constants.
dddd Day of the week as specified by a LOCALE_SDAYNAME* value.
M Month as digits without leading zeros for single-digit months.
MM Month as digits with leading zeros for single-digit months.
MMM Abbreviated month as specified by a LOCALE_SABBREVMONTHNAME* value, for example, "Nov" in English (United States).
MMMM Month as specified by a LOCALE_SMONTHNAME* value, for example, "November" for English (United States), and "Noviembre" for Spanish (Spain).
y Year represented only by the last digit.
yy Year represented only by the last two digits. A leading zero is added for single-digit years.
yyyy Year represented by a full four or five digits, depending on the calendar used. Thai Buddhist and Korean calendars have five-digit years. The "yyyy" pattern shows five digits for these two calendars, and four digits for all other supported calendars. Calendars that have single-digit or two-digit years, such as for the Japanese Emperor era, are represented differently. A single-digit year is represented with a leading zero, for example, "03". A two-digit year is represented with two digits, for example, "13". No additional leading zeros are displayed.
yyyyy Behaves identically to "yyyy".
g, gg Period/era string formatted as specified by the CAL_SERASTRING value.
The "g" and "gg" format pictures in a date string are ignored if there is no associated era or period string.
PivotYear
The maximum year that a 1 or 2 digit year is assumed to be.
The Microsoft de-factor standard for y2k is 2029. Any value greater
than 29 is assumed to be 1930 or higher.
e.g. 2029:
1930, ..., 2000, 2001,..., 2029
If the PivotYear is between 0 and 99, then PivotYear is assumed to be
a date range in the future. e.g. (assuming this is currently 2010):
Pivot Range
0 1911..2010 (no future years)
1 1912..2011
...
98 2009..2108
99 2010..2099 (no past years)
0 ==> no years in the future
99 ==> no years in the past
}
if Length(S) = 0 then
Exit;
if Length(DateFormat) = 0 then
Exit;
Month := -1;
Day := -1;
Year := -1;
Tokens := TDateTimeUtils.TokenizeFormat(DateFormat);
n := 1; //input string index
for i := Low(Tokens) to High(Tokens) do
begin
CurrentToken := Tokens[i];
if CurrentToken = ''MMMM'' then
begin
//Long month names, we don''t support yet (you''re free to write it)
Exit;
end
else if CurrentToken = ''MMM'' then
begin
//Short month names, we don''t support yet (you''re free to write it)
Exit;
end
else if CurrentToken = ''MM'' then
begin
//Month, with leading zero if needed
if not ReadDigitString(S, n, 2{MinDigits}, 2{MaxDigits}, 1{MinValue}, 12{MaxValue}, {var}Month) then Exit;
end
else if CurrentToken = ''M'' then
begin
//months
if not ReadDigitString(S, n, 1{MinDigits}, 2{MaxDigits}, 1{MinValue}, 12{MaxValue}, {var}Month) then Exit;
end
else if CurrentToken = ''dddd'' then
begin
Exit; //Long day names, we don''t support yet (you''re free to write it)
end
else if CurrentToken = ''ddd'' then
begin
Exit; //Short day names, we don''t support yet (you''re free to write it);
end
else if CurrentToken = ''dd'' then
begin
//If we know what month it is, and even better if we know what year it is, limit the number of valid days to that
if (Month >= 1) and (Month <= 12) then
begin
if Year > 0 then
MaxValue := MonthDays[IsLeapYear(Year), Month]
else
MaxValue := MonthDays[True, Month]; //we don''t know the year, assume it''s a leap year to be more generous
end
else
MaxValue := 31; //we don''t know the month, so assume it''s the largest
if not ReadDigitString(S, n, 2{MinDigits}, 2{MaxDigits}, 1{MinValue}, MaxValue{MaxValue}, {var}Day) then Exit;
end
else if CurrentToken = ''d'' then
begin
//days
//If we know what month it is, and even better if we know what year it is, limit the number of valid days to that
if (Month >= 1) and (Month <= 12) then
begin
if Year > 0 then
MaxValue := MonthDays[IsLeapYear(Year), Month]
else
MaxValue := MonthDays[True, Month]; //we don''t know the year, assume it''s a leap year to be more generous
end
else
MaxValue := 31; //we don''t know the month, so assume it''s the largest
if not ReadDigitString(S, n, 1{MinDigits}, 2{MaxDigits}, 1{MinValue}, MaxValue{MaxValue}, {var}Day) then Exit;
end
else if (CurrentToken = ''yyyy'') or (CurrentToken = ''yyyyy'') then
begin
//Year represented by a full four or five digits, depending on the calendar used.
{
Thai Buddhist and Korean calendars have five-digit years.
The "yyyy" pattern shows five digits for these two calendars,
and four digits for all other supported calendars.
Calendars that have single-digit or two-digit years, such as for
the Japanese Emperor era, are represented differently.
A single-digit year is represented with a leading zero, for
example, "03". A two-digit year is represented with two digits,
for example, "13". No additional leading zeros are displayed.
}
if not ReadDigitString(S, n, 4{MinDigits}, 4{MaxDigits}, 0{MinValue}, 9999{MaxValue}, {var}Year) then Exit;
end
else if CurrentToken = ''yyy'' then
begin
//i''m not sure what this would look like, so i''ll ignore it
Exit;
end
else if CurrentToken = ''yy'' then
begin
//Year represented only by the last two digits. A leading zero is added for single-digit years.
if not ReadDigitString(S, n, 2{MinDigits}, 2{MaxDigits}, 0{MinValue}, 99{MaxValue}, {var}Year) then Exit;
nCurrentYear := GetCurrentYear;
Year := (nCurrentYear div 100 * 100)+Year;
if (PivotYear < 100) and (PivotYear >= 0) then
begin
//assume pivotyear is a delta from this year, not an absolute value
PivotYear := nCurrentYear+PivotYear;
end;
//Check the pivot year value
if Year > PivotYear then
Year := Year - 100;
end
else if CurrentToken = ''y'' then
begin
//Year represented only by the last digit.
if not ReadDigitString(S, n, 1{MinDigits}, 1{MaxDigits}, 0{MinValue}, 9{MaxValue}, {var}Year) then Exit;
nCurrentYear := GetCurrentYear;
Year := (nCurrentYear div 10 * 10)+Year;
if (PivotYear < 100) and (PivotYear >= 0) then
begin
//assume pivotyear is a delta from this year, not an absolute value
PivotYear := nCurrentYear+PivotYear;
end;
//Check the pivot year value
if Year > PivotYear then
Year := Year - 100;
end
else
begin
//The input string should contains CurrentToken starting at n
Partial := Copy(S, n, Length(CurrentToken));
Inc(n, Length(CurrentToken));
if Partial <> CurrentToken then
Exit;
end;
end;
//If there''s still stuff left over in the string, then it''s not valid
if n <> Length(s)+1 then
begin
Result := False;
Exit;
end;
if Day > MonthDays[IsLeapYear(Year), Month] then
begin
Result := False;
Exit;
end;
try
Value := EncodeDate(Year, Month, Day);
except
Result := False;
Exit;
end;
Result := True;
end;
class function TDateTimeUtils.TokenizeFormat(fmt: string): TStringDynArray;
var
i: Integer;
partial: string;
function IsDateFormatPicture(ch: AnsiChar): Boolean;
begin
case ch of
''M'',''d'',''y'': Result := True;
else Result := False;
end;
end;
begin
SetLength(Result, 0);
if Length(fmt) = 0 then
Exit;
//format is only one character long? If so then that''s the tokenized entry
if Length(fmt)=1 then
begin
SetLength(Result, 1);
Result[0] := fmt;
end;
partial := fmt[1];
i := 2;
while i <= Length(fmt) do
begin
//If the characters in partial are a format picture, and the character in fmt is not the same picture code then write partial to result, and reset partial
if IsDateFormatPicture(partial[1]) then
begin
//if the current fmt character is different than the running partial picture
if (partial[1] <> fmt[i]) then
begin
//Move the current partial to the output
//and start a new partial
SetLength(Result, Length(Result)+1);
Result[High(Result)] := partial;
Partial := fmt[i];
end
else
begin
//the current fmt character is more of the same format picture in partial
//Add it to the partial
Partial := Partial + fmt[i];
end;
end
else
begin
//The running partial is not a format picture.
//If the current fmt character is a picture code, then write out the partial and start a new partial
if IsDateFormatPicture(fmt[i]) then
begin
//Move the current partial to the output
//and start a new partial
SetLength(Result, Length(Result)+1);
Result[High(Result)] := partial;
Partial := fmt[i];
end
else
begin
//The current fmt character is another non-picture code. Add it to the running partial
Partial := Partial + fmt[i];
end;
end;
Inc(i);
Continue;
end;
//If we have a running partial, then add it to the output
if partial <> '''' then
begin
SetLength(Result, Length(Result)+1);
Result[High(Result)] := partial;
end;
end;
class function TDateTimeUtils.ReadDigitString(const S: string; var Pos: Integer;
MinDigits, MaxDigits: Integer; MinValue, MaxValue: Integer;
var Number: Integer): Boolean;
var
Digits: Integer;
Value: Integer;
Partial: string;
CandidateNumber: Integer;
CandidateDigits: Integer;
begin
Result := False;
CandidateNumber := -1;
CandidateDigits := 0;
Digits := MinDigits;
while Digits <= MaxDigits do
begin
Partial := Copy(S, Pos, Digits);
if Length(Partial) < Digits then
begin
//we couldn''t get all we wanted. We''re done; use whatever we''ve gotten already
Break;
end;
//Check that it''s still a number
if not TryStrToInt(Partial, Value) then
Break;
//Check that it''s not too big - meaning that getting anymore wouldn''t work
if (Value > MaxValue) then
Break;
if (Value >= MinValue) then
begin
//Hmm, looks good. Keep it as our best possibility
CandidateNumber := Value;
CandidateDigits := Digits;
end;
Inc(Digits); //try to be greedy, grabbing even *MORE* digits
end;
if (CandidateNumber >= 0) or (CandidateDigits > 0) then
begin
Inc(Pos, CandidateDigits);
Number := CandidateNumber;
Result := True;
end;
end;

Answer 2

Creé tal rutina para la unidad de fechas de FreePascal, y debería ser fácil de transportar, si es que se necesita portar.

Código:

http://svn.freepascal.org/cgi-bin/viewvc.cgi/trunk/packages/rtl-objpas/src/inc/dateutil.inc?revision=30628&view=co

(el código es el último (enorme) procedimiento al final del archivo)

documentación:

http://www.freepascal.org/docs-html/rtl/dateutils/scandatetime.html

Tenga en cuenta que no es un inverso completo de formatdatetime y tiene algunas extensiones:

• Un inverso de FormatDateTime no es 100% inverso, simplemente porque uno puede poner, por ejemplo, tokens de tiempo dos veces en la cadena de formato, y scandatetime no sabría qué hora elegir.

• Cuerdas como hn no se pueden revertir de forma segura. Por ejemplo, 1: 2 (2 minutos después de 1) entrega 12, que se analiza como 12:00 y luego pierde caracteres para la parte "n".

  • Los caracteres finales son ignorados.
  • no es compatible con los caracteres de formato de Asia oriental, ya que solo son ventanas.
  • no hay soporte de MBCS.

• Extensiones

  • # 9 come espacios en blanco.
  • el espacio en blanco al final de un patrón es opcional.
  • ? coincide con cualquier char.
  • Cita los caracteres anteriores para que coincidan con el personaje.

(Creo que estos comentarios están un poco desactualizados en el sentido de que luego se agregó algo de apoyo asiático, pero no estoy seguro)

Answer 3

Las versiones posteriores de Delphi pueden llevar un argumento TFormatSettings adicional a las funciones de conversión de cadenas. TFormatSettings es una estructura que contiene varias variables globales de formato (ShortDateFormat, LongDateFormat, etc.). Por lo tanto, puede anular ese valor de manera segura para subprocesos e incluso para una sola llamada.

No recuerdo en qué versión de Delphi se introdujo, pero estoy bastante seguro de que fue después de Delphi 5.

Así que sí, por lo que sé, debe sincronizar cada acceso a ShortDateFormat o usar una función diferente.

Answer 4

No estoy seguro de lo que quieres. Ya no uso Delphi 5 pero estoy bastante seguro de que la función StrToDateTime existe en él. Usándolo puedes convertir una cadena a TDateTime con ajustes de formato. Luego, puede convertir dicho TDateTime a cualquier formato usando FormatDateTime, lo que le permite usar cualquier formato de fecha que desee.

Answer 5

Si quieres saber cómo se resolvió esto más adelante en Delphi, puedes echar un vistazo a la fuente de un sysutils.pas un poco más moderno (se parece a Delphi 6) aquí:

http://anygen.googlecome.com/.../SysUtils.pas

Revise las versiones sobrecargadas de StrToDateTime que toman un parámetro TFormatSettings .

function StrToDateTime(const S: string;
const FormatSettings: TFormatSettings): TDateTime; overload;

Answer 6

Utilice VarToDateTime en su lugar. Admite muchos más formatos de fecha en la cadena y los convierte automáticamente.

var
DateVal: TDateTime;
begin
DateVal := VarToDateTime(''23 Sep 2010'');
ShowMessage(DateToStr(DateVal));
end;

Veo que estás usando Delphi 5. Algunas versiones de Delphi necesitarán agregar Variantes a la cláusula de usos; La mayoría de las versiones posteriores lo agregan por ti. No recuerdo en qué categoría Delphi 5 cayó.

Answer 7

Utilice la biblioteca RegExpr ( https://github.com/masterandrey/TRegExpr )

var
RE: TRegExpr;
begin
RE := TRegExpr.Create;
try
RE.Expression := ''^(/d/d/d/d)/(/d/d)/(/d/d)T(/d/d):(/d/d):(/d/d)$'';
if RE.Exec( Value ) then
begin
try
Result := EncodeDate( StrToInt( RE.Match[1] ),
StrToInt( RE.Match[2] ),
StrToInt( RE.Match[3] ) ) +
EncodeTime( StrToInt( RE.Match[4] ),
StrToInt( RE.Match[5] ),
StrToInt( RE.Match[6] ),
0 )
except
raise EConvertError.Create( ''Invalid date-time: '' + Value )
end
end
else
raise EConvertError.Create( ''Bad format: '' + Value )
finally
RE.Free
end
end;

Answer 8

Yo iría al revés. Como yo lo veo, tienes dos opciones de las que mencionaste una.

• Ajuste el ShortDateFormat y mantenga todos los accesos sincronizados.
• Si conoce el formato de las cadenas que está recibiendo (de alguna manera, tendrá que hacerlo), simplemente haga algunos malabares de cadenas para obtener primero las cadenas en su formato actual de shortdate . Después de eso, convierta la cadena (malabarizada) a un TDateTime .

Me pregunto cómo va a determinar el formato para, por ejemplo, 04/05/2010.

program DateTimeConvert;
{$APPTYPE CONSOLE}
uses
SysUtils;
function GetPart(const part, input, format: string): string;
var
I: Integer;
begin
for I := 1 to Length(format) do
if Uppercase(format[I]) = Uppercase(part) then
Result := Result + input[I];
end;
function GetDay(const input, format: string): string;
begin
Result := GetPart(''d'', input, format);
if Length(Result) = 1 then Result := SysUtils.Format(''0%0:s'', [Result]);
end;
function GetMonth(const input, format: string): string;
begin
Result := GetPart(''m'', input, format);
if Length(Result) = 1 then Result := SysUtils.Format(''0%0:s'', [Result]);
end;
function GetYear(const input, format: string): string;
begin
Result := GetPart(''y'', input, format);
end;
function ConvertToMyLocalSettings(const input, format: string): string;
begin
Result := SysUtils.Format(''%0:s/%1:s/%2:s'', [GetDay(input, format), GetMonth(input, format), GetYear(input, format)]);
end;
begin
Writeln(ConvertToMyLocalSettings(''05/04/2010'', ''dd/mm/yyyy''));
Writeln(ConvertToMyLocalSettings(''05-04-2010'', ''dd-mm-yyyy''));
Writeln(ConvertToMyLocalSettings(''5-4-2010'', ''d-m-yyyy''));
Writeln(ConvertToMyLocalSettings(''4-5-2010'', ''m-d-yyyy''));
Writeln(ConvertToMyLocalSettings(''4-05-2010'', ''M-dd-yyyy''));
Writeln(ConvertToMyLocalSettings(''05/04/2010'', ''dd/MM/yyyy''));
Readln;
end.