Fonctions Date/heure
Utiliser les fonctions suivantes pour analyser, formater et manipuler la date, l'heure, et les valeurs date/heure partout dans FME où les expressions sont supportées.
Liens |
---|
Sauf si le contraire est indiqué, les arguments temporels (date, heure, date-heure) doivent être au Formats standards FME d'heure et de date ou ISO 8601.
Pour le support arithmétique, voir aussi DateTimeCalculator dans l'aide des Transformers de FME Workbench.
Note Les espaces dans les fonctions date/heure sont automatiquement coupées en début et fin de chaîne.
Lorsqu'un argument temporel est traité, si l'année, le mois, le jour, les heures, les minutes et/ou les secondes sont en dehors de la plage prise en charge, l'argument est rejeté et le résultat est défini comme nul. @DateTimeParse est la seule fonction date/heure qui dispose d'un argument facultatif pour réparer les parties qui dépassent les plages prises en charge (sauf pour les années). Par exemple, @DateTimeParse(20161332,%Y%m%d,repair) réparera la date d'entrée en 20170201.
Conseil Utiliser @DateTimeParse pour réparer les intervalles de secondes et autres valeurs temporelles contenant des parties qui dépassent des plages telles que les valeur de date/heure générées par des capteurs ou autres dispositifs mécaniques.
Fonctions Date/heure
Fonction | Description | Exemples |
---|---|---|
@DateTimeAdd() |
DateHeure + Intervalle = Date heure |
@DateTimeAdd(20170102, P1M) = 20170202 @DateTimeAdd(20170102, -P1M) = 20161202 |
@DateTimeCast() |
Change le type source en un type destination, si la conversion est enregistrée. Un troisième argument optionnel spécifie le type de changement de format de l'opération. Voir @DateTimeCast pour plus de détails. |
@DateTimeCast(20170102123000-08, time) = 123000-08:00 @DateTimeCast(20170132, date) = null @DateTimeCast(20170001, date) = null @DateTimeCast(20180821, time, exact_match) = null @DateTimeCast(120000+08:00, time_offset, strict_offset) = 120000+08:00 @DateTimeCast(120000, time_offset, strict_offset) = null |
@DateTimeCreate() |
Crée une chaîne de date/heure sans fuseau horaire ni décalage UTC. |
@DateTimeCreate(2017,1,2,12,30,0,-08) = 20170102123000-08:00 |
@DateTimeDiff() |
Datetime – Datetime = Intervalle |
@DateTimeDiff(20170201,20170101) = P1M @DateTimeDiff(20170202, 20170201, seconds) = 86400 |
@DateTimeFormat() |
Formatte les chaînes date/heure FME pour qu'elles puissent être exploitées par des Writers ou Transformers. |
@DateTimeFormat(20170102,%B %d %Y) = January 02 2017 |
@DateTimeIntervalCreate() |
Crée des chaînes Intervalles sousla norme ISO 8601 de format de durée. |
@DateTimeIntervalCreate(1,0,0,0,0,0) = P1Y |
@DateTimeIntervalNegate() |
Ignorer les Intervalles |
@DateTimeIntervalNegate(P1Y) = -P1Y |
@DateTimeNow() |
Crée des valeurs d'horodatage en heure locale, local sans fuseau ou en heure UTC. |
@DateTimeNow() = 20170203170000.1234567 @DateTimeNow(localUnzoned) = 20170203170000.1234567 @DateTimeNow(local) = 20170203170000.1234567-08:00 @DateTimeNow(utc) = 20170204010000.1234567+00:00 |
@DateTimeParse() |
Analyse arbitraire de chaînes contenant des informations date/heure dans des chaînes au format FME. Peut être utilisé pour la validation et la réparation. Peut analyser les secondes intercalaires en reportant la seconde supplémentaire de manière à ce que toutes les parties soient dans la plage. |
@DateTimeParse(January 2 2017, %B %d %Y) = 20170102 @DateTimeParse(20170229,%Y%m%d,repair) = 20170301 |
@DateTimeRound() |
Arrondit une chaîne de date à un intervalle donné. |
@DateTimeRound(20170203170000.1234567, down, seconds, 1) = 20170203170000 @DateTimeRound(20170203170000.1234567, up, seconds, 5) = 20170203170005 |
@TimeZoneGet |
Récupère le décalage UTC de valeurs date-heure zonées. |
@TimeZoneGet(083000-08) = -08:00 |
@TimeZoneRemove |
Supprime le décalage UTC de valeurs date-heure zonées. |
@TimeZoneRemove(083000-08) = 083000 |
@TimeZoneSet |
Définit un fuseau horaire (décalage UTC) en date-heure non-zonée ou convertit une date-heure zonée en un autre fuseau horaire. |
@TimeZoneSet(083000-01:00, -08:00) = 013000-08:00 @TimeZoneSet(083000, -08:00) = 083000-08:00 @TimeZoneSet(083000-01:00, local) = 013000-08:00 @TimeZoneSet(083000-01:00, utc) = 093000+00:00 |
Description détaillées des fonctions Date/Heure
Fonctions de construction Dat/heure
@DateTimeCast
Change une valeur temporelle dans le type temporel spécifié.
Retour
Une chaîne de date, heure ou date/heure dans le Formats standards FME d'heure et de date si la valeur en entrée est correctement, sinon nulle.
Syntaxe
@DateTimeCast(<datetime>,<targetType>[,<castType>])
Arguments
<datetime>
Une date, une heure ou une chaîne de dateheure en Formats standards FME d'heure et de date ou au format de date et d'heure ISO 8601. Lorsqu'un élément d'heure est manquant, minuit (000000) est supposé.
<targetType>
Sensible à la casse, peut être une date, une heure ou une dateheure. Les autres valeurs sont rejetées, avec le résultat défini sur null. Si <castType est strict_offset ou exact_match, <targetType> peut aussi etre time_offset ou datetime_offset.
<castType>
Peut être preserve_offset, strict_offset, ou exact_match.
- preserve_offset : si <datetime> inclut un décalage, il est préservé dans la sortie.
- strict_offset : Si <datetime> n'a pas de décalage (les décalages n'ont pas de valeur par défaut) et que <targetType> est time_offset ou datetime_offset, null est retourné. Si <targetType> est time ou datetime, tout décalage est abandonné.
- exact_match : Agit comme un validateur. Si <datetime> ne correspond pas exactement à <targetType>, null est retourné.
Exemples
@DateTimeCast(20170101,datetime) = 20170101000000
@DateTimeCast(20170101000000,date) = 20170101
@DateTimeCast(000000,date) = null
@DateTimeCast(20180821, time, exact_match) = null
@DateTimeCast(120000+08:00, time_offset, strict_offset) = 120000+08:00
@DateTimeCast(120000, time_offset, strict_offset) = null
@DateTimeCreate
Crée une chaîne date_heure.
Retour
Une chaîne de dateheure au format FME, contenant un décalage UTC si un décalage non vide est fourni. Si un argument d'entrée est invalide, null est retourné.
Syntaxe
@DateTimeCreate(<year>,<month>,<day>,<hours>,<minutes>,<seconds>,<offset>)
Arguments
Note Les valeurs décimales sont arrondies en entier.
<year>
Entier entre 1 et 9999.
<month>
Entier entre 1 et 12.
<day>
Entier entre 1 et 31 .
<hours>
Entier entre 0 et 23.
<minutes>
Entier entre 0 et 59.
<seconds>
Valeur décimale comprise entre 0 et 59.999999999.
<offset>
Chaîne de la forme +/-hh, +/-hhmm, ou +/-hh:mm. Peut également être la chaîne vide, "" , pour indiquer une heure non zonée.
Exemples
@DateTimeCreate(2017,1,2,0,0,0,"") = 20170102000000
@DateTimeCreate(2017,0,1,0,0,0) = null
Conseil Pour créer une date ou une heure, utiliser soit @DateTimeCas ou contruire la date ou l'heure sans utiliser de fonction date/heure (par exemple, en tapant "20170101").
@DateTimeIntervalCreate
Créer un intervalle représentant une période telle que 1 mois, 1 année, 1 jour et ainsi de suite.
Retour
Une chaîne de caractères au format de durée ISO 8601, sauf que les années, mois, jours, heures et minutes fractionnaires ne sont pas supportés. Si un argument d'entrée est invalide, null est renvoyé.
Syntaxe
@DateTimeIntervalCreate(<years>,<months>,<days>,<hours>,<minutes>,<seconds>[,<sign>])
Arguments
Note Les valeurs flottantes avec décimales fournies comme arguments entiers sont arrondies en entiers. Les valeurs d'entrée doivent être soit toutes non-négatives, soit toutes non-positives. Les entrées à signes mixtes seront rejetées et le résultat sera défini comme nul.
<years>
Entier.
<months>
Entier.
<days>
Entier.
<hours>
Entier.
<minutes>
Entier.
<seconds>
Entier.
<sign>
Valeur de chaîne de caractères facultative. Peut être l'une des valeurs suivantes :
- Non spécifié : l'intervalle est positif.
- +: l'intervalle est positif.
−
: L'intervalle est un intervalle négatif. Par exemple, P1M signifie un mois à partir d'une certaine date, et -P1M signifie un mois négatif à partir d'une certaine date.- Autres valeurs : l'arguement est rejeté et le résultat est null.
Exemples
@DateTimeIntervalCreate(1,2,0,0,0,0.123) = P1Y2MT0.123S
@DateTimeIntervalCreate(1,0,-1,0,0,0) = null
@DateTimeIntervalCreate(0,0,1,0,0,0,-) = -P1D
Conseil Il est souvent plus facile de construire des chaînes d'intervalles sans utiliser @DateTimeIntervalCreate() . Exemples :
- P1Y - une années à partir d'une date
- P@Value(days)D - utilise les valeur de 'jour' de l'attribut comme valeur d'intervalle.
@DateTimeNow
Génère la date en cours en respectant la précision horaire.
Retour
Une chaîne de dateheure dans Formats standards FME d'heure et de date avec le type de décalage spécifié. Si le type de décalage n'est pas valide, null est retourné.
Syntaxe
@DateTimeNow([<offsetType>])
Arguments
<offsetType>
Les chaînes optionnelles sont insensibles à la casse et peuvent être :
- Non spécifiées : Identique à localUnzoned. (local sans fuseau).
- localUnzoned : Génère l'heure locale mais aucun fuseau n'est appliqué.
local
: génère l'heure locale, avec le décalage UTC local ajouté. Par exemple, l'heure normale du Pacifique a un décalage UTC de -08:00.utc
: génère l'heure UTC avec un décalage +0:00.- Autres valeurs : l'arguement est rejeté et le résultat est null.
Exemples
@DateTimeNow() = 20170202162035.1574322
@DateTimeNow(localUnzoned) = 20170202162035.1574322
@DateTimeNow(local) = 20170202162035.1574322-08:00
@DateTimeNow(utc)
= 20170203002035.1574322+00:00
Fonctions arithmétiques Date/heure
@DateTimeAdd
Ajoute un intervalle, ou une période de temps, à une dateheure. Pour soustraire d'une dateheure, transforme en négatif <intervalle>. Par exemple, <intervalle> = P1M ajoute un mois à <datetime>. <intervalle> = -P1M soustrait un mois à <datetime>.
Retour
Une chaîne de dateheure dans Formats standards FME d'heure et de date qui a le même type temporel que l'entrée <datetime>, où les dates d'entrée sont automatiquement appelées en dateheures en ajoutant minuit si <interval> contient une composante de temps. Si l'un des arguments n'est pas valide, ou si <interval> contient des parties qui ne sont pas trouvées dans l'argument <datetime>, null est retourné.
Syntaxe
@DateTimeAdd(<datetime>,<interval>)
Arguments
<datetime>
Une chaîne date, heure ou date-heure Formats standards FME d'heure et de date ou ISO 86061.
<interval>
Une chaîne au format durée ISO 8601, sauf les années, mois, jours, heures et minutes fractionnés non supportés.
Exemples
@DateTimeAdd(20170102,P1M) = 20170202
@DateTimeAdd(20160229,P1Y) = 20170228
@DateTimeAdd(20160229,-P1Y) = 20150228
@DateTimeAdd(000000,PT1H) = 010000
@DateTimeAdd(20170102,PT1H) = 20170102010000
@DateTimeAdd(000000,P1DT1H) = null
Note La fonction adhère aux invariants suivants tant que les arguments en entrées sont valides :
- EndTime – StartTime = Interval iff
- StartTime + Interval = EndTime
Bien que cet invariant semble simple, il donne des réponses uniques à des calculs ambigus comme 20170228 – 20160229 ou 20160229 + P1Y.
Note L'intervalle est au format de durée ISO 8601. Les unités plus grandes sont ajoutées avant les unités plus petites, car l'ordre est important. Par exemple, 30 mars + P1M + P1D = 1er mai, mais 30 mars + P1D + P1M = 30 avril. La façon correcte d'interpréter + P1M1D est donc d'ajouter d'abord un mois, puis un jour.
@DateTimeDiff
<endDatetime> - <startDatetime> = intervalle. Les valeurs de début et de fin doivent avoir le même type temporel, sinon le résultat est nul. La seule exception est que les dates sont autocastés en dateheure en ajoutant minuit si l'autre argument est une dateheure. Cette fonction prend en charge plusieurs types d'intervalles.
Retour
Une valeur d'intervalle dont le type est défini par <intervalType>. Si l'un des arguments d'entrée est invalide, ou si les valeurs de début et de fin ne sont pas du même type temporel (par exemple, date - datetime), null est renvoyé.
Syntaxe
@DateTimeDiff(<endDatetime>,<startDatetime>[,<intervalType>])
Arguments
<endDatetime>
Une chaîne de date, d'heure ou de dateheure au format Formats standards FME d'heure et de date ou date et heure ISO 8601. <endDatetime> doit être compatible avec <startDatetime>. Voir Matrice de compatibilité de type pour <endDatetime> et <startDatetime> ci-dessous.
<startDatetime>
Une chaîne de date, d'heure ou de dateheure au format Formats standards FME d'heure et de date ou date et heure ISO 8601. <startDatetime> doit être compatible avec <endDatetime>. Voir Matrice de compatibilité de type pour <endDatetime> et <startDatetime> ci-dessous.
<intervalType>
Can be one of the following string values, case-insensitive:
-
Non-spécifié : sort l'intervalle au format de durée ISO 8601.
- Intervalle : Sort l'intervalle au format de durée ISO 8601.
- Années: Sort l'intervalle en tant qu'année fractionnée ou une année égale 12 mois.
- Mois : produit l'intervalle sous forme de mois fractionnés. Entre une paire de valeurs temporelles de début et de fin, il y a X mois complets. Le reste qui n'est pas un mois complet est constitué d'un nombre de jours, d'heures, de minutes et de secondes. Le reste est d'abord converti en jours fractionnés. Ensuite, les jours fractionnaires sont divisés par le nombre de jours d'un mois de transition. Le mois de croisement précède le reste et garantit que le reste n'est jamais supérieur à un mois, lorsqu'il est exprimé sous forme de fraction de mois. Enfin, le reste sous forme de fraction de mois est ajouté aux X mois complets, ce qui donne les mois fractionnés.
- Semaines : Sort l'intervalle en tant que semaines fractionnées où une semaine contient 7 jours.
- Jours: Sort l'intervalle en tant que jours fractionnés où une journée est composée de 24 heures.
- Heures: Sort l'intervalle en tant qu'heures fractionnées où une heure contient 60 minutes.
- Minutes: Sort l'intervalle en tant que minutes fractionnées où une minute contient 60 secondes.
- Secondes: Sort l'intervalle en tant que secondes fractionnées.
-
Autres valeurs : l'arguement est rejeté et le résultat est null.
Note La fonction adhère aux invariants suivants tant que les arguments date-heure en entrée sont valides :
- EndTime – StartTime = Interval iff
- StartTime + Interval = EndTime
Bien que cet invariant semble simple, il donne des réponses uniques à des calculs ambigus comme 20170228 – 20160229 ou 20160229 + P1Y.
Note Pour réutiliser des années, mois, jours, heures ou minutes fractionnés dans un Transformer DateTimeCalculator ou une fonction @DateTimeAdd(), arrondissez ou tronquez au préalable la valeur fractionnée en entier.
Conseil Les années, mois, jours, heures, minutes ou secondes fractionnées en tant que type d'intervalle de sortie peuvent être utile pour des comparaison ou du reporting.
Conseil Il est difficile de comprendre et de travailler avec des intervalles négatifs. Dans la mesure du possible, évitez les intervalles négatifs en veillant à ce que les dates de début soient antérieures aux dates de fin.
Matrice de compatibilité de type pour <endDatetime> et <startDatetime>
|
Date | Heure | Heure avec décalage | Date-Heure | Date-Heure avec décalage |
---|---|---|---|---|---|
Date |
Oui |
Non |
Non |
Oui |
Non |
Heure |
Non |
Oui |
Non |
Non |
Non |
Heure avec décalage |
Non |
Non |
Oui |
Non |
Non |
Date-Heure |
Oui |
Non |
Non |
Oui |
Non |
Date-Heure avec décalage |
Non |
Non |
Non |
Non |
Oui |
Les types end/start incompatibles résultent en un rejet de l'entité.
Exemples
@DateTimeDiff(20170407, 20170101) = P3M6D
@DateTimeDiff(20170407, 20170101, months) = 3.2000000000000002
@DateTimeDiff(20170407, 20170101, days) = 96
@DateTimeDiff(20170102010000, 20170102) = PT1H
@DateTimeDiff(20170102, 20170131020304-08:00) = null
@DateTimeIntervalNegate
Négativise les chaînes d'intervalles. Cette fonction peut être utilisée pour transformer @DateTimeAdd() en une fonction de soustraction.
Retour
Si l'entrée <intervalle> est invalide, null est retourné. Sinon, l'entrée <intervalle> avec son signe inversé. Cela signifie soit l'ajout d'un caractère "-", soit la suppression de ce caractère.
Syntaxe
@DateTimeIntervalNegate(<interval>)
Arguments
<interval>
Une chaîne au format durée ISO 8601, sauf les années, mois, jours, heures et minutes fractionnés non supportés.
Exemples
@DateTimeIntervalNegate(-P1M1D) = P1M1D
@DateTimeIntervalNegate(P1M1Y) = null
Note Un intervalle annulé peut ne pas contenir le même nombre de jours que l'intervalle original. Par exemple, P1M à partir d'aujourd'hui peut représenter 31 jours, et -P1M peut représenter 30 jours. Dans la mesure du possible, utilisez des intervalles positifs, qui sont plus faciles à utiliser.
@DateTimeRound
Retour
Une chaîne de date au Formats standards FME d'heure et de date. Si la date d'entrée n'est pas valide, null est renvoyé.
Syntaxe
@DateTimeRound(<datetime>,<round_type>,<unit>,<interval>)
Arguments
<datetime>
Une chaîne de caractères date, heure ou date-heure au Formats standards FME d'heure et de date ou date et heure au format ISO 8601.
<round_type>
Sens de l'arrondi :
- Up : Arrondit à l'intervalle supérieure de la valeur <unit> spécifiée.
- Down : Arrondit à l'intervalle le plus proche de la valeur <unit> spécifiée.
- Nearest : Arrondit à l'intervalle le plus proche de la valeur <unit> spécifiée.
<unit>
L'unité d'arrondi du temps. Les valeurs valides sont :
- Jours
- hours
- minutes
- seconds
<interval>
L'intervalle d'arrondi pour l'unité <unit> spécifiée. Cette valeur doit être un nombre entier qui se divise uniformément par la valeur maximale de l'unité de temps sélectionnée. Par exemple, une valeur d'intervalle de 5 est valable pour les minutes car elle se divise également en 60.
Note Si <unit> est days jours, seul un intervalle de 1 est pris en charge.
Exemples
@DateTimeRound(20170203170000.1234567,down,seconds,1) = 20170203170000
@DateTimeRound(20170203170000.1234567,up,seconds,5) = 20170203170005
@DateTimeRound(20170203170000.1234567,nearest,hours,5) = 20170203150000
Fonctions Date/Time Timezone
@TimeZoneGet
Récupère le décalage UTC d'une date-heure zonées.
Retour
Le décalage UTC de la dateheure d'entrée si elle est zonée, et null sinon. Si l'entrée n'est pas une valeur de dateheure FME, null est retourné. Le décalage UTC retourné est converti dans le type de retour spécifié.
Syntaxe
@TimeZoneGet(<datetime>[,<returnType>])
Arguments
<datetime>
Une chaîne de caractères date, heure ou date-heure au Formats standards FME d'heure et de date ou date et heure au format ISO 8601.
<returnType>
Facultatif. S'applique uniquement si la dateheure de saisie est zonée. Doit être l'une des valeurs suivantes, insensible à la casse, ou l'entrée est rejetée :
- Non-spécifié : identique à utcOffset.
- utcOffset: Retourne le décalage UTC sous la forme (+|-)hh:mm.
- minutes: Retourne le décalage UTC en tant que minutes.
- seconds: Retourne le décalage UTC en tant que secondes.
Exemples
@TimeZoneGet(083000-08) = -08:00
@TimeZoneGet(083000+08) = +08:00
@TimeZoneGet(083000-01:30, minutes) = -90
@TimeZoneGet(083000+01:30, minutes) = 90
@TimeZoneGet(083000-01:30, seconds) = -5400
@TimeZoneGet(083000) = null
@TimeZoneRemove
Supprime un décalage UTC d'une date-heure.
Retour
Si la date-heure en entrée est zonée, retourne la date-time en entrée avec le décalage UTC supprimé.
Si la date-heure en entrée est zonée, retourne la date-time inchangée.
Si l'entrée n'est pas une valeur date-heure ISO ou FME, un null est retourné.
Syntaxe
@TimeZoneRemove(<datetime>)
Arguments
<datetime>
Une chaîne de caractères date, heure ou date-heure au Formats standards FME d'heure et de date ou date et heure au format ISO 8601.
Exemples
@TimeZoneRemove(083000-08) = 083000
@TimeZoneRemove(083000) = 083000
@TimeZoneRemove(08:30) = null
@TimeZoneSet
Convertit/Définit le décalage UTC de l'entrée date-time.
Retour
Si la date-heure en entrée est zonée, retourne la date-time avec le décalage UTC convertit en un décalage UTC spécifié.
Si la date-heure en entrée est non-zonée, retourne la date-time en entrée avec le décalage UTC spécifié attaché.
Si un argument en entrée est invalide, null est retourné.
Syntaxe
@TimeZoneSet(<datetime>, <timeZone>[, <mode>])
Arguments
<datetime>
Une chaîne de caractères date, heure ou date-heure au Formats standards FME d'heure et de date ou date et heure au format ISO 8601.
<timeZone>
Peut être l'une des valeurs suivantes, insensibles à la casse :
- local : Le décalage UTC du fuseau horaire local qui était en vigueur au moment de la valeur de dateheure. En mode convert, cela convertit une valeur dateheure avec décalage en heure locale équivalente, en respectant les règles de l'heure d'été. En mode réinitialisation, tout décalage existant est ignoré, et la dateheure est associée à un décalage UTC applicable à l'heure locale. ( Le mode réinitialisation échoue s'il n'y a pas d'heure locale associée en raison d'une heure sautée lorsque l'heure d'été prend effet, ou pendant une heure répétée ambiguë lorsque l'heure standard prend effet).
- utc: Le décalage UTC +00:00.
- Un décalage UTC sous la forme (+|-)hh:mm.
<mode>
Doit être l'une valeurs suivantes, insensibles à la casse, ou l'entrée est rejetée :
- Non-spécifié : identique à auto.
- auto: Définit le fuseau horaire si l'entrée est non-zonée et convertit le fuseau horaire si l'entrée est zonée.
- reset: Supprime tout décalage UTC puis définit le définit selon la cible <timeZone>.
- convert : L'entrée non zonée est rejetée. L'entrée zonée est convertie du décalage UTC source vers la cible <timeZone>.
Exemples
@TimeZoneSet(083000, -08:00) = 083000-08:00
@TimeZoneSet(083000, -08:00, convert) = null
@TimeZoneSet(083000-01:00, -08:00) = 013000-08:00
@TimeZoneSet(083000-01:00, local) = null
@TimeZoneSet(083000-01:00, utc) = 093000+00:00
@TimeZoneSet(083000-01:00, -08:00, reset) = 083000-08:00
Fonctions Date/Time Parse/Format
@DateTimeParse
Analyse les chaînes contenant des informations de dateheure à partir d'une source arbitraire, et produit des chaînes de date, heure et dateheure au format Formats standards FME d'heure et de date ou ISO 8601. La chaîne de format est sensible à la casse, sauf indication contraire. La fonction parse parcourt la chaîne d'entrée et la compare à la chaîne de format.
Retour
Date, heure ou chaîne de dateheure en Formats standards FME d'heure et de date, selon les indicateurs de format. Si la chaîne de caractères d'entrée correspond entièrement à la chaîne de caractères d'entrée avant que la chaîne de caractères de format ne soit entièrement appliquée, le résultat est défini comme nul. Toutefois, la chaîne de format peut correspondre au début d'une chaîne d'entrée. Par exemple, @DateTimeParse(2017-01-02 03:04:05,%Y-%m-%d) = 20170102. Si la chaîne de format n'a pas permis d'analyser les informations temporelles, ou si l'un des indicateurs d'analyse n'a pas permis de récupérer les informations temporelles attendues, le résultat est défini comme nul.
Syntaxe
@DateTimeParse(<string>,<format>[,<mode>])
Arguments
<string>
Chaîne d'entrée arbitraire contenant des informations temporelles. La chaîne d'entrée est coupée des espaces de début et de fin. L'information temporelle doit satisfaire aux exigences suivantes, sinon elle est rejetée et le résultat est défini comme nul :
- Année, mois et jour sont fournis ensemble, dans n'importe quel ordre, à travers une combinaison de paramètres de formats comme %Y-%m-%d.
- Si les heures sont renseignées par des chaînes de format %H ou %I, mais pas les minutes ou les secondes, ces dernières se voient attribuer la valeur par défaut 00. Cela permet d'analyser les entrées sous la forme 12AM ou 3PM.
- Similairement, si les heures et minutes sont peuplées mais pas les secondes, la seconde partie se voit assigner une valeur par défaut de 00.
<format>
Chaîne de format contenant les drapeaux de format pris en charge, les caractères réguliers et les caractères spéciaux. La chaîne de format est débarrassée des espaces avant et arrière. Les chaînes de format vides et les indicateurs de format non pris en charge entraînent la mise à zéro du résultat.
La priorité des indicateurs d'analyse, de la plus haute à la plus basse, est la suivante : %s ou %Es, %z, %j, tous les autres indicateurs. Lorsque les autres indicateurs se chevauchent - par exemple, si %B et %m sont tous deux spécifiés - alors celui qui est spécifié en dernier prévaut.
<mode>
Valeur de chaîne facultative. Peut être l'une des valeurs suivantes, insensible à la casse :
- Non-spécifié : les parties temporelles en entrée doivent respecter les plages documentées.
- repair (insensible à la casse) : caractères dépassant seront rejetés (par exemple, le mois 0) mais les parties en dépassement (autres que les années) seront réparées de manière à ce que toutes les parties soient ramenées dans la plage (par exemple, le mois 13 entraînera l'incrémentation de l'année par 1, et le mois sera mis à 1). %I n'est pas couvert par ce mode, car il est ambigu de savoir comment 13:00AM doit être réparé - comme 13:00 (traiter AM comme un élément étranger), ou 01:00 (l'heure après 12AM) ?
- Autres valeurs : l'arguement est rejeté et le résultat est null.
Note Si <string> ou <format> contient une virgule (,), il est nécessaire de mettre l'argument contenant la virgule entre guillemets (""). Sans les guillemets, la virgule agit comme un séparateur d'arguments.
Conseil La fonction @DateTimeParse() peut être utilisée pour valider des chaînes temporelles, y compris celles au format FME. Si elle produit une sortie nulle, et que la chaîne de format est vérifiée comme étant correcte, alors la chaîne temporelle d'entrée est invalide. De plus, si en définissant <mode> sur repair, une sortie nulle se transforme en une valeur temporelle en Formats standards FME d'heure et de date, alors la chaîne d'entrée contenait des parties de débordement (invalides) mais a été réparée.
- Exemple : @DateTimeParse(20170229, %Y%m%d) = null. L'entrée n'est pas valide.
- Exemple : @DateTimeParse(20170229, %Y%m%d,repair) = 20170301. L'entrée est réparée.
Exemples
@DateTimeFormat
Formate les chaînes de date, d'heure et de dateheure FME ou ISO dans un format personnalisé, pour être utilisées par les Writers et les Transformers. La chaîne de format est sensible à la casse.
Retour
Une chaîne formatée, si les arguments d'entrée sont valides. Si l'un ou l'autre des arguments n'est pas valide (par exemple, la chaîne de format contient des drapeaux non supportés étant donné le type temporel de la dateheure d'entrée), cette fonction renvoie null.
Syntaxe
@DateTimeFormat(<datetime>,<format>)
Arguments
<datetime>
Date, heure ou chaîne de dateheure en Formats standards FME d'heure et de date ou au format date et heure ISO 8601. Les dates saisies seront converties automatiquement en dateheure en ajoutant minuit si la chaîne de format produit des éléments d'heure.
<format>
Chaîne de format contenant les indicateurs de format et les caractères réguliers pris en charge. La chaîne de format est débarrassée des espaces avant et arrière. Les chaînes de format vides et les indicateurs de format non pris en charge entraînent la mise à zéro du résultat. Certains indicateurs de format pris en charge sont rejetés pour certains types de temporaires d'entrée, ce qui entraîne l'attribution de la valeur null au résultat. Plus précisément :
- Si l'entrée est une date ou date-heure, rejette :
- Si l'entrée est une heure ou une heure avec décalage, rejette :
- Si l'entrée est une heure, en dehors des paramètres précédents, rejette :
- Si l'entrée est une date-heure avec décalage, rejette :
%s %z %Ez
%s %Es %Y %y %m %N %b %B %u %U %w %W %d %e %j %a %A
%z %Ez
%Es
Note Si <format> contient une virgule (,) à l'intérieur, il est nécessaire de mettre l'argument contenant la virgule entre guillemets (""). Sans les guillemets, la virgule agit comme un séparateur d'arguments.
Exemples
Paramètres et Exemples de Chaîne de Formatage
Méthode |
Paramètres |
Signification |
@DateTimeParse |
@DateTimeFormat |
||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Année |
%Y |
Année à quatre chiffres, comprise entre 0001 et 9999. |
@DateTimeParse(2017-01-02, %Y-%m-%d) = 20170102 |
@DateTimeFormat(20170102, %Y-%m-%d) = 2017-01-02 |
||||||||||||||||||
%y#### |
Année à deux chiffres où #### est la plus grande année (quatre chiffres) à considérer. Par exemple, si %y2059 est spécifié, les années à deux chiffre 00-59 sont lues comme 2000-2059, tandis que 60-99 sont lues comme 1960-1999. |
@DateTimeParse(17-01-02, %y2020-%m-%d) = 20170102 @DateTimeParse(17-01-02, %y2010-%m-%d) = 19170102 @DateTimeParse(17-01-02, %y2017-%m-%d) = 20170102 |
Non-supporté. |
|||||||||||||||||||
%y |
Année à deux chiffres. |
Non-supporté. |
@DateTimeFormat(20170102, %y-%m-%d) = 17-01-02 |
|||||||||||||||||||
Mois |
%m |
Mois à deux chiffres, compris entre 01 et 12. |
Mois à un chiffre acceptés si séparés par des délimiteurs. @DateTimeParse(2017-1-2, %Y-%m-%d) = 20170102 |
@DateTimeFormat(20170102, %Y-%m-%d) = 2017-01-02 |
||||||||||||||||||
%N |
Same as %m except as noted. |
@DateTimeParse(1/2/2017,%N/%e/%Y) = 20170102 |
Identique à %m, sauf les zéros en premiers supprimés. @DateTimeFormat(20170102,%N/%e/%Y) = 1/2/2017 |
|||||||||||||||||||
%b |
Mois de l'année abrégé, trois lettres, en anglais. |
@DateTimeParse(Jan 2 2017,%b %d %Y) = 20170102 |
@DateTimeFormat(20170102, %b %d %Y) = Jan 02 2017 |
|||||||||||||||||||
%B |
|
@DateTimeParse(January 2 2017,%B %d %Y) = 20170102 |
@DateTimeFormat(20170102, %B %d %Y) = January 02 2017 |
|||||||||||||||||||
Semaine |
%a |
Jours de la semaine, abrégés en 3 lettres. |
Non supporté. Envisagez l'analyse syntaxique en utilisant *. |
@DateTimeFormat(20170102, %a %b %d %Y) = Mon Jan 02 2017 |
||||||||||||||||||
%A |
Nom complet des jours de la semaine. |
Non supporté. Envisagez l'analyse syntaxique en utilisant *. |
@DateTimeFormat(20170102, %A %B %d %Y) = Monday January 02 2017 |
|||||||||||||||||||
%u |
Jour de la semaine en un seul chiffre, compris entre 1 et 7 (Lundi étant 1). |
Non-supporté. |
@DateTimeFormat(20170102, %u) = 1 |
|||||||||||||||||||
%U |
Semaine de l'année en deux chiffres, compris entre 00 et 53, commençant avec le premier dimanche en tant que premier jour de l'année 1. |
Non-supporté. |
@DateTimeFormat(20160102, %U) = 00 @DateTimeFormat(20160103, %U) = 01 @DateTimeFormat(20171231, %U) = 53 |
|||||||||||||||||||
%w |
Jour de la semaine en un seul chiffre compris entre 0 et 6 (Dimanche étant 0). |
Non-supporté. |
@DateTimeFormat(20170101, %w) = 0 |
|||||||||||||||||||
%W |
Semaine de l'année en deux chiffres, compris entre 00 et 53, commençant avec le premier lundi de la semaine 1. |
Non-supporté. |
@DateTimeFormat(20160103, %W) = 00 @DateTimeFormat(20160104, %W) = 01 @DateTimeFormat(20181231, %W) = 53 |
|||||||||||||||||||
Jour |
%d |
Jour du mois en deux chiffres, compris entre 01 et le dernier jour du mois. |
Jour en un chiffre accepté si séparé par des délimiteurs. @DateTimeParse(2017-1-2, %Y-%m-%d) = 20170102 |
@DateTimeFormat(20170102, %Y-%m-%d) = 2017-01-02 |
||||||||||||||||||
%e |
Identique à %d sauf si exception notée. |
@DateTimeParse(1/2/2017,%N/%e/%Y) = 20170102 |
Identique à %d à l'exception des zéros en amont supprimés. @DateTimeFormat(20170102,%N/%e/%Y) = 1/2/2017 |
|||||||||||||||||||
%j |
Jour de l'année en trois chiffres, compris entre 001 et 365 (année non-bissextile) ou 366 (année bissextile). |
Jours de l'année à 1 et 2 chiffres acceptés. @DateTimeParse(20171,%Y%j) = 20170101 |
@DateTimeFormat(20170101,%Y-%j) = 2017-001 @DateTimeFormat(20161231,%Y-%j) = 2016-366 |
|||||||||||||||||||
Heures |
%H |
Heures en deux chiffres, compris entre 00 et 23. |
Heures à un chiffre acceptées si séparées par des délimiteurs. @DateTimeParse(8:30, %H:%M) = 083000 |
@DateTimeFormat(083000, %H:%M:%S) = 08:30:00 |
||||||||||||||||||
%k |
Identique à %H sauf si exception notée. |
@DateTimeParse(8:30, %k:%M) = 083000 |
Identique à %H à l'exception des zéros en amont supprimés. @DateTimeFormat(083000, %k:%M%p) = 8:30AM |
|||||||||||||||||||
%I (i) |
Horloge à 12 heures, compris de 0 à 12. |
Heures à un chiffre acceptées si séparées par des délimiteurs. @DateTimeParse(8:30PM, %I:%M%p) = 203000 |
@DateTimeFormat(203000, %I:%M %p) = 08:30PM |
|||||||||||||||||||
%l (L) |
Identique à %l sauf si exception notée. |
@DateTimeParse(8:30PM, %l:%M%p) = 203000 |
Identique à %l à l'exception des zéros en amont supprimés. @DateTimeFormat(203000, %l:%M%p) = 8:30PM |
|||||||||||||||||||
%p |
AM/PM |
AM/PM acceptés, insensibles à la casse. @DateTimeParse(12:30am, %I:%M%p) = 003000 |
@DateTimeFormat(083000, %I:%M %p) = 08:30 AM |
|||||||||||||||||||
Minutes |
%M |
Minutes à deux chiffres, compris entre 00 et 59. |
Minutes à un chiffre acceptées si séparées par des délimiteurs. @DateTimeParse(8:30, %H:%M) = 083000 |
@DateTimeFormat(083000, %H:%M:%S) = 08:30:00 |
||||||||||||||||||
Secondes |
%S |
Secondes à deux chiffres, avec une plage de 00 à 59. Les fractions de seconde sont prises en charge jusqu'à une résolution de l'ordre de la nanoseconde. |
Secondes à un chiffre acceptées si séparées par délimiteurs. @DateTimeParse(8:30:01.234, %H:%M:%S) = 083001.234 |
@DateTimeFormat(083059.123, %H:%M:%S) = 08:30:59.123 |
||||||||||||||||||
%s |
Secondes depuis l'heure de l'Epoch Unix (1970-01-01 00:00:00+00:00). Les fractions de secondes sont supportées jusqu'à une résolution de l'ordre de la nanoseconde. La chaîne de formatage est rejetée si %z et %s sont tous deux présents. |
Accepte le temps d'epoch. Donne une dateheure UTC. La partie secondes doit comporter au moins un seul chiffre. Par exemple, "0,1" est considéré comme une valeur valide pour %s, mais ".1" ne l'est pas. @DateTimeParse(1.234, %s) = 19700101000001.234+00:00 @DateTimeParse(1.234-08:00, %s%z) = null |
Accepte une dateheure zonée. Produit une heure epoch. @DateTimeFormat( 19700101000001.234+00:00, %s) = 1.234 @DateTimeFormat( 19700101000001.234, %s) = null @DateTimeFormat( 19700101000001.234+00:00, %s%z) = null |
|||||||||||||||||||
%Es |
Identique à %s, sauf que ce paramètre supporte les dates et date-heures non-zonées. La chaîne de formatage est rejetée si %z et %Es sont tous deux présents. |
Accepte l'heure epoch. Produit une dateheure UTC, mais sans le décalage UTC. La sortie n'est donc pas zonée. @DateTimeParse(1.234, %Es) = 19700101000001.234 @DateTimeParse(1.234, %Es%z) = null |
Accepte une date ou une dateheure non zonée et la traite comme une heure UTC. Donne une heure epoch. @DateTimeFormat( 19700101000001.234, %Es) = 1.234 @DateTimeFormat(19700102, %Es) = 86400 @DateTimeFormat( 19700101000001.234+00:00, %Es) = null @DateTimeFormat(19700101000001.234, %Es%z) = null |
|||||||||||||||||||
Fuseau horaire |
%z |
Décalage UTC sous la forme +/-hh:mm, sauf si exception notée. |
Décalage UTC sous la forme +/-hh, +/-hhmm, ou +/-hh:mm, ou Z for heure Zulu qui est +00:00. @DateTimeParse(8:30-08,%H:%M%z) = 083000-08:00 |
@DateTimeFormat(000000-08:00,%T%z) = 00:00:00-08:00 |
||||||||||||||||||
%Ez |
Identique à %z sauf si exception notée. |
@DateTimeParse(03:04:05Z,%H:%M:%S%Ez) = 030405+00:00 |
Identique à %Ez, sauf que +00:00 sort en tant que Z pour heure Zulu. @DateTimeFormat(030405+00:00,%T%Ez)=03:04:05Z |
|||||||||||||||||||
Raccourcis |
%T |
Egal à %H:%M:%S |
@DateTimeParse(03:04:05,%T) = 030405 |
@DateTimeFormat(000000,%T) = 00:00:00 |
||||||||||||||||||
FME |
Auto-parse l'entrée qui est au Formats standards FME d'heure et de date et répare les parties dépassant si l'argument réparation est défini. Spécifiquement, @DateTimeParse() recherche les correspondances suivantes :
Peut être combiné avec le paramètre ISO séparé avec le caractère | (barre verticale). Pour rendre ce raccourci moins ambigu depuis une chaîne de texte avec le même contenu, quand FME et ISO sont spécifiés, il ne doit y avoir aucun autre paramètre présent. |
@DateTimeParse(030460-0800, FME, repair) = 030500-08:00 @DateTimeParse(030460-0800, FME|ISO, repair) = 030500-08:00 |
@DateTimeFormat(083000-08, FME) = 083000-08:00 @DateTimeFormat(20170229, FME) = null |
|||||||||||||||||||
ISO |
Auto-parse/formate l'entrée en format date-heure ISO. Spécifiquement, @DateTimeParse() recherche les correspondances suivantes :
Pour rendre ce raccourci moins ambigu depuis une chaîne de texte avec le même contenu, quand ISO est spécifié, il ne doit y avoir aucun autre paramètre présent. |
@DateTimeParse(2017-01-02, FME | ISO) = 20170102 @DateTimeParse(03:04:60,ISO,repair) = 030500 |
@DateTimeFormat(20170102, ISO) = 2017-01-02 @DateTimeFormat(20170102030405-08,ISO) = 2017-01-02T03:04:05-08:00 |
|||||||||||||||||||
Métacaractère |
* |
Un simple mot qui correspond à une séquence de caractères délimités par des espaces blancs ou le début/la fin d'une chaîne, ou le caractère suivant immédiatement le caractère * suivant. Par exemple, "Lundi" peut être interpréter soit "*" ou "*,". Les caractères suivants sont des caractères spéciaux qui peuvent suivre le * :
|
@DateTimeParse("On Monday, January 23 2017","* * %B %d %Y") = 20170123 @DateTimeParse("On Monday, January 23 2017","* *, %B %d %Y") = 20170123 |
Non-supporté. |
||||||||||||||||||
? |
Un caractère unique. |
@DateTimeParse(January 23rd 2017,%B %d?? %Y) = 20170123 @DateTimeParse(LC80460262015110LGN00, LC???????%Y%jLGN??) = 20150420 |
Non-supporté. |
|||||||||||||||||||
$ |
Fin de la chaîne d'entrée. Utilisé pour s'assurer que l'entrée correspond entièrement à la chaîne de format. Les chaînes en entrée sont automatiquement tronquées d'espaces de début et de fin. |
@DateTimeParse(2017-01-02, %Y-%m-%d$) = 20170102 @DateTimeParse(2017-01-02 and then, %Y-%m-%d$) = null |
Non-supporté. |
|||||||||||||||||||
Caractères spéciaux |
%% |
Le caractère %. |
@DateTimeParse(2017%01%05,%Y%%%m%%%d) = 20170105 |
@DateTimeFormat(020304,%T %%) = 02:03:04 % |
||||||||||||||||||
%* |
Le caractère *. |
@DateTimeParse(*** 2017-01-05,%*%*%* %Y-%m-%d) = 20170105 |
Non-supporté. |
|||||||||||||||||||
%? |
Le caractère ? |
@DateTimeParse(On Jan 2 2017?,* %b %d %Y%?) = 20170102 |
Non-supporté. |
|||||||||||||||||||
%$ |
Le caractère $ |
@DateTimeParse(2017$01$02,%Y%$%m%$%d) = 20170102 |
Non-supporté. |
|||||||||||||||||||
Caractère régulier |
Tout |
Tout caractère qui n'est pas un joker ou un caractère spécial tel que documenté ci-dessus est considéré comme un caractère ordinaire. La sensibilité à la casse est respectée. |
@DateTimeParse(On Jan 23 2017, On %b %d %Y) = 20170123 @DateTimeParse(On Jan 23 2017, on %b %d %Y) = null |
@DateTimeFormat(20170102,On %B %d %Y) = On January 02 2017 |
Voir aussi