opening hours
4.1.1
Avec spatie/opening-hours vous créez un objet qui décrit les heures d'ouverture d'une entreprise, que vous pouvez interroger pour savoir si open ou closed à des jours ou à des dates spécifiques, ou utiliser pour présenter les heures par jour.
spatie/opening-hours peut être utilisé directement sur Carbon grâce à cmixin/business-time afin que vous puissiez bénéficier des fonctionnalités d'heures d'ouverture directement sur vos objets date améliorés.
Un ensemble d'horaires d'ouverture est créé en transmettant un horaire régulier et une liste d'exceptions.
// Add the use at the top of each file where you want to use the OpeningHours class:
use Spatie OpeningHours OpeningHours ;
$ openingHours = OpeningHours:: create ([
' monday ' => [ ' 09:00-12:00 ' , ' 13:00-18:00 ' ],
' tuesday ' => [ ' 09:00-12:00 ' , ' 13:00-18:00 ' ],
' wednesday ' => [ ' 09:00-12:00 ' ],
' thursday ' => [ ' 09:00-12:00 ' , ' 13:00-18:00 ' ],
' friday ' => [ ' 09:00-12:00 ' , ' 13:00-20:00 ' ],
' saturday ' => [ ' 09:00-12:00 ' , ' 13:00-16:00 ' ],
' sunday ' => [],
' exceptions ' => [
' 2016-11-11 ' => [ ' 09:00-12:00 ' ],
' 2016-12-25 ' => [],
' 01-01 ' => [], // Recurring on each 1st of January
' 12-25 ' => [ ' 09:00-12:00 ' ], // Recurring on each 25th of December
],
]);
// This will allow you to display things like:
$ now = new DateTime ( ' now ' );
$ range = $ openingHours -> currentOpenRange ( $ now );
if ( $ range ) {
echo " It's open since " . $ range -> start (). "n" ;
echo " It will close at " . $ range -> end (). "n" ;
} else {
echo " It's closed since " . $ openingHours -> previousClose ( $ now )-> format ( ' l H:i ' ). "n" ;
echo " It will re-open at " . $ openingHours -> nextOpen ( $ now )-> format ( ' l H:i ' ). "n" ;
}L'objet peut être interrogé pour un jour de la semaine, ce qui renverra un résultat basé sur l'horaire régulier :
// Open on Mondays:
$ openingHours -> isOpenOn ( ' monday ' ); // true
// Closed on Sundays:
$ openingHours -> isOpenOn ( ' sunday ' ); // falseIl peut également être interrogé pour une date et une heure spécifiques :
// Closed because it's after hours:
$ openingHours -> isOpenAt ( new DateTime ( ' 2016-09-26 19:00:00 ' )); // false
// Closed because Christmas was set as an exception
$ openingHours -> isOpenOn ( ' 2016-12-25 ' ); // falseIl peut également renvoyer des tableaux d'heures d'ouverture pour une semaine ou une journée :
// OpeningHoursForDay object for the regular schedule
$ openingHours -> forDay ( ' monday ' );
// OpeningHoursForDay[] for the regular schedule, keyed by day name
$ openingHours -> forWeek ();
// Array of day with same schedule for the regular schedule, keyed by day name, days combined by working hours
$ openingHours -> forWeekCombined ();
// OpeningHoursForDay object for a specific day
$ openingHours -> forDate ( new DateTime ( ' 2016-12-25 ' ));
// OpeningHoursForDay[] of all exceptions, keyed by date
$ openingHours -> exceptions ();Lors de la construction, vous pouvez définir un indicateur pour les délais de débordement sur plusieurs jours. Par exemple, pour une discothèque ouverte jusqu'à 3h du matin le vendredi et le samedi :
$ openingHours = Spatie OpeningHours OpeningHours:: create ([
' overflow ' => true ,
' friday ' => [ ' 20:00-03:00 ' ],
' saturday ' => [ ' 20:00-03:00 ' ],
], null );Cela permet à l'API d'approfondir les données de la veille pour vérifier si les heures d'ouverture sont ouvertes à partir de sa plage horaire.
Vous pouvez ajouter des données dans les définitions puis les récupérer :
$ openingHours = OpeningHours:: create ([
' monday ' => [
' data ' => ' Typical Monday ' ,
' 09:00-12:00 ' ,
' 13:00-18:00 ' ,
],
' tuesday ' => [
' 09:00-12:00 ' ,
' 13:00-18:00 ' ,
[
' 19:00-21:00 ' ,
' data ' => ' Extra on Tuesday evening ' ,
],
],
' exceptions ' => [
' 2016-12-25 ' => [
' data ' => ' Closed for Christmas ' ,
],
],
]);
echo $ openingHours -> forDay ( ' monday ' )-> data ; // Typical Monday
echo $ openingHours -> forDate ( new DateTime ( ' 2016-12-25 ' ))-> data ; // Closed for Christmas
echo $ openingHours -> forDay ( ' tuesday ' )[ 2 ]-> data ; // Extra on Tuesday eveningDans l'exemple ci-dessus, les données sont des chaînes mais il peut s'agir de n'importe quel type de valeur. Vous pouvez donc intégrer plusieurs propriétés dans un tableau.
Pour des raisons de commodité de structure, le couple données-heures peut être un tableau entièrement associatif, donc l'exemple ci-dessus est strictement équivalent au suivant :
$ openingHours = OpeningHours:: create ([
' monday ' => [
' hours ' => [
' 09:00-12:00 ' ,
' 13:00-18:00 ' ,
],
' data ' => ' Typical Monday ' ,
],
' tuesday ' => [
[ ' hours ' => ' 09:00-12:00 ' ],
[ ' hours ' => ' 13:00-18:00 ' ],
[ ' hours ' => ' 19:00-21:00 ' , ' data ' => ' Extra on Tuesday evening ' ],
],
// Open by night from Wednesday 22h to Thursday 7h:
' wednesday ' => [ ' 22:00-24:00 ' ], // use the special "24:00" to reach midnight included
' thursday ' => [ ' 00:00-07:00 ' ],
' exceptions ' => [
' 2016-12-25 ' => [
' hours ' => [],
' data ' => ' Closed for Christmas ' ,
],
],
]); Vous pouvez utiliser le séparateur to spécifier plusieurs jours à la fois, pour la semaine ou pour des exceptions :
$ openingHours = OpeningHours:: create ([
' monday to friday ' => [ ' 09:00-19:00 ' ],
' saturday to sunday ' => [],
' exceptions ' => [
// Every year
' 12-24 to 12-26 ' => [
' hours ' => [],
' data ' => ' Holidays ' ,
],
// Only happening in 2024
' 2024-06-25 to 2024-07-01 ' => [
' hours ' => [],
' data ' => ' Closed for works ' ,
],
],
]);Le dernier outil de structure est le filtre, il vous permet de passer des fermetures (ou une référence de fonction/méthode appelable) qui prennent une date comme paramètre et renvoie les paramètres pour la date donnée.
$ openingHours = OpeningHours:: create ([
' monday ' => [
' 09:00-12:00 ' ,
],
' filters ' => [
function ( $ date ) {
$ year = intval ( $ date -> format ( ' Y ' ));
$ easterMonday = new DateTimeImmutable ( ' 2018-03-21 + ' .( easter_days ( $ year ) + 1 ). ' days ' );
if ( $ date -> format ( ' m-d ' ) === $ easterMonday -> format ( ' m-d ' )) {
return []; // Closed on Easter Monday
// Any valid exception-array can be returned here (range of hours, with or without data)
}
// Else the filter does not apply to the given date
},
],
]); Si un appelable est trouvé dans la propriété "exceptions" , il sera automatiquement ajouté aux filtres afin que vous puissiez mélanger les filtres et les exceptions dans le tableau des exceptions . Le premier filtre qui renvoie une valeur non nulle aura la priorité sur les filtres suivants et le tableau de filtres aura la priorité sur les filtres à l'intérieur du tableau d'exceptions .
Attention : nous effectuerons une boucle sur tous les filtres pour chaque date à partir de laquelle nous devons récupérer les heures d'ouverture et ne pouvons ni prédire ni mettre en cache le résultat (cela peut être une fonction aléatoire), vous devez donc être prudent avec les filtres, trop de filtres ou un long processus à l'intérieur des filtres. peut avoir un impact significatif sur les performances.
Il peut également renvoyer le prochain DateTime d'ouverture ou de fermeture à partir d'un DateTime donné.
// The next open datetime is tomorrow morning, because we’re closed on 25th of December.
$ nextOpen = $ openingHours -> nextOpen ( new DateTime ( ' 2016-12-25 10:00:00 ' )); // 2016-12-26 09:00:00
// The next open datetime is this afternoon, after the lunch break.
$ nextOpen = $ openingHours -> nextOpen ( new DateTime ( ' 2016-12-24 11:00:00 ' )); // 2016-12-24 13:00:00
// The next close datetime is at noon.
$ nextClose = $ openingHours -> nextClose ( new DateTime ( ' 2016-12-24 10:00:00 ' )); // 2016-12-24 12:00:00
// The next close datetime is tomorrow at noon, because we’re closed on 25th of December.
$ nextClose = $ openingHours -> nextClose ( new DateTime ( ' 2016-12-25 15:00:00 ' )); // 2016-12-26 12:00:00Lisez la section d'utilisation pour l'API complète.
Spatie est une agence de webdesign basée à Anvers, en Belgique. Vous trouverez un aperçu de tous nos projets open source sur notre site Internet.
Nous investissons beaucoup de ressources dans la création des meilleurs packages open source de leur catégorie. Vous pouvez nous soutenir en achetant l'un de nos produits payants.
Nous apprécions grandement que vous nous envoyiez une carte postale de votre ville natale, mentionnant le(s) forfait(s) que vous utilisez. Vous trouverez notre adresse sur notre page contact. Nous publions toutes les cartes postales reçues sur notre mur virtuel de cartes postales.
Vous pouvez installer le package via composer :
composer require spatie/opening-hours Le package ne doit être utilisé que via la classe OpeningHours . Il existe également trois classes d'objets de valeur utilisées partout, Time , qui représente une heure unique, TimeRange , qui représente une période avec un début et une fin, et openingHoursForDay , qui représente un ensemble de TimeRange qui ne peuvent pas se chevaucher.
SpatieOpeningHoursOpeningHoursOpeningHours::create(array $data, $timezone = null, $toutputTimezone = null): SpatieOpeningHoursOpeningHoursMéthode d'usine statique pour remplir l'ensemble des heures d'ouverture.
$ openingHours = OpeningHours:: create ([
' monday ' => [ ' 09:00-12:00 ' , ' 13:00-18:00 ' ],
// ...
]); Si aucun fuseau horaire n'est spécifié, OpeningHours supposera simplement que vous transmettez toujours les objets DateTime dont le fuseau horaire correspond déjà à votre emploi du temps.
Si vous transmettez un $timezone comme deuxième argument ou via la clé de tableau 'timezone' (il peut s'agir soit d'un objet DateTimeZone , soit d'une string ), alors les dates transmises seront converties dans ce fuseau horaire au début de chaque méthode, puis si la méthode renvoie un objet date (tel que nextOpen , nextClose , previousOpen , previousClose , currentOpenRangeStart ou currentOpenRangeEnd ), puis il est reconverti dans le fuseau horaire d'origine avant la sortie afin que l'objet puisse refléter un moment dans l'heure locale de l'utilisateur tandis que OpeningHours peut rester dans son propre fuseau horaire professionnel.
Alternativement, vous pouvez également spécifier le fuseau horaire d'entrée et de sortie (en utilisant le deuxième et le troisième argument) ou en utilisant un tableau :
$ openingHours = OpeningHours:: create ([
' monday ' => [ ' 09:00-12:00 ' , ' 13:00-18:00 ' ],
' timezone ' => [
' input ' => ' America/New_York ' ,
' output ' => ' Europe/Oslo ' ,
],
]);OpeningHours::mergeOverlappingRanges(array $schedule) : array Pour des raisons de sécurité, la création d'un objet OpeningHours avec des plages qui se chevauchent lèvera une exception à moins que vous ne transmettiez explicitement 'overflow' => true, dans la définition du tableau des heures d'ouverture. Vous pouvez également les fusionner explicitement.
$ ranges = [
' monday ' => [ ' 08:00-11:00 ' , ' 10:00-12:00 ' ],
];
$ mergedRanges = OpeningHours:: mergeOverlappingRanges ( $ ranges ); // Monday becomes ['08:00-12:00']
OpeningHours:: create ( $ mergedRanges );
// Or use the following shortcut to create from ranges that possibly overlap:
OpeningHours:: createAndMergeOverlappingRanges ( $ ranges );Tous les jours ne sont pas obligatoires, si un jour manque, il sera déclaré fermé.
OpeningHours::fill(array $data): SpatieOpeningHoursOpeningHours Identique à create , mais non statique.
$ openingHours = ( new OpeningHours )-> fill ([
' monday ' => [ ' 09:00-12:00 ' , ' 13:00-18:00 ' ],
// ...
]);OpeningHours::forWeek(): SpatieOpeningHoursOpeningHoursForDay[] Renvoie un tableau d’objets OpeningHoursForDay pour une semaine normale.
$ openingHours -> forWeek ();OpeningHours::forWeekCombined(): array Renvoie un tableau de jours. La clé du tableau est le premier jour avec les mêmes heures, les valeurs du tableau sont les jours qui ont les mêmes heures de travail et l'objet OpeningHoursForDay .
$ openingHours -> forWeekCombined ();OpeningHours::forWeekConsecutiveDays(): array Renvoie un tableau de jours concaténés, de jours adjacents avec les mêmes heures. La clé du tableau est le premier jour avec les mêmes heures, les valeurs du tableau sont les jours qui ont les mêmes heures de travail et l'objet OpeningHoursForDay .
Attention : les jours consécutifs sont considérés du lundi au dimanche sans bouclage (le lundi n'est pas consécutif au dimanche) quel que soit l'ordre des jours dans les données initiales.
$ openingHours -> forWeekConsecutiveDays ();OpeningHours::forDay(string $day): SpatieOpeningHoursOpeningHoursForDay Renvoie un objet OpeningHoursForDay pour une journée normale. Un jour est une chaîne minuscule du nom du jour en anglais.
$ openingHours -> forDay ( ' monday ' );OpeningHours::forDate(DateTimeInterface $dateTime): SpatieOpeningHoursOpeningHoursForDay Renvoie un objet OpeningHoursForDay pour une date spécifique. Il recherche une exception ce jour-là, sinon il renvoie les heures d'ouverture en fonction de l'horaire régulier.
$ openingHours -> forDate ( new DateTime ( ' 2016-12-25 ' ));OpeningHours::exceptions(): SpatieOpeningHoursOpeningHoursForDay[] Renvoie un tableau de tous les objets OpeningHoursForDay pour les exceptions, saisis par une chaîne de date Ymd .
$ openingHours -> exceptions ();OpeningHours::isOpenOn(string $day): boolVérifie si l'entreprise est ouverte (contient au moins une plage d'heures d'ouverture) un jour de l'horaire régulier.
$ openingHours -> isOpenOn ( ' saturday ' );Si la chaîne donnée est une date, elle vérifiera si elle est ouverte (contient au moins une plage d'heures d'ouverture) en tenant compte à la fois de l'horaire normal et des exceptions possibles.
$ openingHours -> isOpenOn ( ' 2020-09-03 ' );
$ openingHours -> isOpenOn ( ' 09-03 ' ); // If year is omitted, current year is used instead OpeningHours::isClosedOn(string $day): boolVérifie si l'entreprise est fermée un jour de l'horaire régulier.
$ openingHours -> isClosedOn ( ' sunday ' );OpeningHours::isOpenAt(DateTimeInterface $dateTime): boolVérifie si l'entreprise est ouverte un jour spécifique, à une heure précise.
$ openingHours -> isOpenAt ( new DateTime ( ' 2016-26-09 20:00 ' ));OpeningHours::isClosedAt(DateTimeInterface $dateTime): boolVérifie si l'entreprise est fermée un jour précis, à une heure précise.
$ openingHours -> isClosedAt ( new DateTime ( ' 2016-26-09 20:00 ' ));OpeningHours::isOpen(): boolVérifie si l'entreprise est ouverte en ce moment.
$ openingHours -> isOpen ();OpeningHours::isClosed(): boolVérifie si l'entreprise est fermée en ce moment.
$ openingHours -> isClosed ();OpeningHours::isAlwaysOpen(): boolVérifie si l'entreprise est ouverte 24h/24 et 7j/7, sans exceptions ni filtres.
if ( $ openingHours -> isAlwaysOpen ()) {
echo ' This business is open all day long every day. ' ;
}OpeningHours::isAlwaysClosed(): boolVérifie si l'entreprise n'est jamais ouverte, n'a aucune exception et aucun filtre.
OpeningHours accepte un tableau ou une liste vide avec chaque jour de la semaine vide, sans préjugés.
S'il ne s'agit pas d'un état valide dans votre domaine, vous devez utiliser cette méthode pour lever une exception ou afficher une erreur.
if ( $ openingHours -> isAlwaysClosed ()) {
throw new RuntimeException ( ' Opening hours missing ' );
}OpeningHours::nextOpenOpeningHours::nextOpen(
?DateTimeInterface $ dateTime = null ,
?DateTimeInterface $ searchUntil = null ,
?DateTimeInterface $ cap = null ,
) : DateTimeInterface` Renvoie le prochain DateTime ouvert à partir du DateTime donné ( $dateTime ou à partir de maintenant si ce paramètre est nul ou omis).
Si un objet DateTimeImmutable est passé, un objet DateTimeImmutable est renvoyé.
Définissez $searchUntil sur une date pour lever une exception si aucune heure d'ouverture ne peut être trouvée avant ce moment.
Définissez $cap sur une date, donc si aucune heure d'ouverture ne peut être trouvée avant ce moment, $cap est renvoyé.
$ openingHours -> nextOpen ( new DateTime ( ' 2016-12-24 11:00:00 ' ));OpeningHours::nextCloseOpeningHours::nextClose(
?DateTimeInterface $ dateTime = null ,
?DateTimeInterface $ searchUntil = null ,
?DateTimeInterface $ cap = null ,
) : DateTimeInterface` Renvoie DateTime de fermeture suivant à partir du DateTime donné ( $dateTime ou à partir de maintenant si ce paramètre est nul ou omis).
Si un objet DateTimeImmutable est passé, un objet DateTimeImmutable est renvoyé.
Définissez $searchUntil sur une date pour lever une exception si aucune heure de fermeture ne peut être trouvée avant ce moment.
Définissez $cap sur une date, donc si aucune heure de fermeture ne peut être trouvée avant ce moment, $cap est renvoyé.
Si le planning est toujours ouvert ou toujours fermé, il n'y a aucun changement d'état à trouver et donc nextOpen (mais aussi previousOpen , nextClose et previousClose ) lancera un MaximumLimitExceeded Vous pouvez l'attraper et réagir en conséquence ou vous pouvez utiliser les méthodes isAlwaysOpen / isAlwaysClosed pour anticiper tel cas.
$ openingHours -> nextClose ( new DateTime ( ' 2016-12-24 11:00:00 ' ));OpeningHours::previousOpenOpeningHours::previousOpen(
?DateTimeInterface $ dateTime = null ,
?DateTimeInterface $ searchUntil = null ,
?DateTimeInterface $ cap = null ,
) : DateTimeInterface` Renvoie DateTime ouvert précédent à partir du DateTime donné ( $dateTime ou à partir de maintenant si ce paramètre est nul ou omis).
Si un objet DateTimeImmutable est passé, un objet DateTimeImmutable est renvoyé.
Définissez $searchUntil sur une date pour lever une exception si aucune heure d'ouverture ne peut être trouvée après ce moment.
Définissez $cap sur une date, donc si aucune heure d'ouverture ne peut être trouvée après ce moment, $cap est renvoyé.
$ openingHours -> previousOpen ( new DateTime ( ' 2016-12-24 11:00:00 ' ));OpeningHours::previousCloseOpeningHours::previousClose(
?DateTimeInterface $ dateTime = null ,
?DateTimeInterface $ searchUntil = null ,
?DateTimeInterface $ cap = null ,
) : DateTimeInterface` Renvoie DateTime de fermeture précédent à partir du DateTime donné ( $dateTime ou à partir de maintenant si ce paramètre est nul ou omis).
Si un objet DateTimeImmutable est passé, un objet DateTimeImmutable est renvoyé.
Définissez $searchUntil sur une date pour lever une exception si aucune heure de fermeture ne peut être trouvée après ce moment.
Définissez $cap sur une date, donc si aucune heure de fermeture ne peut être trouvée après ce moment, $cap est renvoyé.
$ openingHours -> nextClose ( new DateTime ( ' 2016-12-24 11:00:00 ' ));OpeningHours::diffInOpenHours(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatRenvoie la durée d'ouverture (nombre d'heures sous forme de nombre flottant) entre 2 dates/heures.
$ openingHours -> diffInOpenHours ( new DateTime ( ' 2016-12-24 11:00:00 ' ), new DateTime ( ' 2016-12-24 16:34:25 ' ));OpeningHours::diffInOpenMinutes(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatRenvoie la durée d'ouverture (nombre de minutes sous forme de nombre flottant) entre 2 dates/heures.
OpeningHours::diffInOpenSeconds(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatRenvoie la durée d'ouverture (nombre de secondes sous forme de nombre flottant) entre 2 dates/heures.
OpeningHours::diffInClosedHours(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatRenvoie la durée de fermeture (nombre d'heures sous forme de nombre flottant) entre 2 dates/heures.
$ openingHours -> diffInClosedHours ( new DateTime ( ' 2016-12-24 11:00:00 ' ), new DateTime ( ' 2016-12-24 16:34:25 ' ));OpeningHours::diffInClosedMinutes(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatRenvoie la durée de fermeture (nombre de minutes sous forme de nombre flottant) entre 2 dates/heures.
OpeningHours::diffInClosedSeconds(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatRenvoie la durée de fermeture (nombre de secondes sous forme de nombre flottant) entre 2 dates/heures.
OpeningHours::currentOpenRange(DateTimeInterface $dateTime) : false | TimeRange Renvoie une instance SpatieOpeningHoursTimeRange de la plage ouverte actuelle si l'entreprise est ouverte, false si l'entreprise est fermée.
$ range = $ openingHours -> currentOpenRange ( new DateTime ( ' 2016-12-24 11:00:00 ' ));
if ( $ range ) {
echo " It's open since " . $ range -> start (). "n" ;
echo " It will close at " . $ range -> end (). "n" ;
} else {
echo " It's closed " ;
} Les méthodes start() et end() renvoient les instances SpatieOpeningHoursTime . Les instances Time créées à partir d'une date peuvent être formatées avec des informations de date. Ceci est utile pour les plages dépassant minuit :
$ period = $ openingHours -> currentOpenRange ( new DateTime ( ' 2016-12-24 11:00:00 ' ));
if ( $ period ) {
echo " It's open since " . $ period -> start ()-> format ( ' D Gh ' ). "n" ;
echo " It will close at " . $ period -> end ()-> format ( ' D Gh ' ). "n" ;
} else {
echo " It's closed " ;
}OpeningHours::currentOpenRangeStart(DateTimeInterface $dateTime) : false | DateTime Renvoie une instance DateTime de la date et de l'heure depuis lesquelles l'entreprise est ouverte si l'entreprise est ouverte, false si l'entreprise est fermée.
Remarque : la date peut être la veille si vous utilisez des plages de nuit.
$ date = $ openingHours -> currentOpenRangeStart ( new DateTime ( ' 2016-12-24 11:00:00 ' ));
if ( $ date ) {
echo " It's open since " . $ date -> format ( ' H:i ' );
} else {
echo " It's closed " ;
}OpeningHours::currentOpenRangeEnd(DateTimeInterface $dateTime) : false | DateTime Renvoie une instance DateTime de la date et de l'heure jusqu'à laquelle l'entreprise sera ouverte si l'entreprise est ouverte, false si l'entreprise est fermée.
Remarque : la date peut être le lendemain si vous utilisez les plages de nuit.
$ date = $ openingHours -> currentOpenRangeEnd ( new DateTime ( ' 2016-12-24 11:00:00 ' ));
if ( $ date ) {
echo " It will close at " . $ date -> format ( ' H:i ' );
} else {
echo " It's closed " ;
}OpeningHours::createFromStructuredData(array|string $data, $timezone = null, $outputTimezone = null): SpatieOpeningHoursOpeningHoursMéthode de fabrique statique pour remplir l'ensemble avec un tableau https://schema.org/OpeningHoursSpecification ou une chaîne JSON.
dayOfWeek prend en charge un tableau de noms de jours (à saveur Google) ou un tableau d'URL de jours (spécification officielle de schema.org).
$ openingHours = OpeningHours:: createFromStructuredData ( ' [
{
"@type": "OpeningHoursSpecification",
"opens": "08:00",
"closes": "12:00",
"dayOfWeek": [
"https://schema.org/Monday",
"https://schema.org/Tuesday",
"https://schema.org/Wednesday",
"https://schema.org/Thursday",
"https://schema.org/Friday"
]
},
{
"@type": "OpeningHoursSpecification",
"opens": "14:00",
"closes": "18:00",
"dayOfWeek": [
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday"
]
},
{
"@type": "OpeningHoursSpecification",
"opens": "00:00",
"closes": "00:00",
"validFrom": "2023-12-25",
"validThrough": "2023-12-25"
}
] ' );OpeningHours::asStructuredData(strinf $format = 'H:i', string|DateTimeZone $timezone) : arrayRenvoie une OpeningHoursSpecification sous forme de tableau.
$ openingHours -> asStructuredData ();
$ openingHours -> asStructuredData ( ' H:i:s ' ); // Customize time format, could be 'h:i a', 'G:i', etc.
$ openingHours -> asStructuredData ( ' H:iP ' , ' -05:00 ' ); // Add a timezone
// Timezone can be numeric or string like "America/Toronto" or a DateTimeZone instance
// But be careful, the time is arbitrary applied on 1970-01-01, so it does not handle daylight
// saving time, meaning Europe/Paris is always +01:00 even in summer time.SpatieOpeningHoursOpeningHoursForDay Cette classe est conçue en lecture seule. Il implémente ArrayAccess , Countable et IteratorAggregate afin que vous puissiez traiter la liste des TimeRange de manière semblable à un tableau.
SpatieOpeningHoursTimeRange Objet de valeur décrivant une période avec une heure de début et une heure de fin. Peut être converti en chaîne au format H:iH:i .
SpatieOpeningHoursTime Objet de valeur décrivant une seule fois. Peut être converti en chaîne au format H:i .
Vous pouvez convertir le format OpenStreetMap en objet OpeningHours en utilisant osm-opening-hours (merci à mgrundkoetter)
Veuillez consulter CHANGELOG pour plus d'informations sur ce qui a changé récemment.
composer test Veuillez consulter CONTRIBUER pour plus de détails.
Si vous avez trouvé un bug concernant la sécurité, veuillez envoyer un mail à [email protected] au lieu d'utiliser le suivi des problèmes.
Vous êtes libre d'utiliser ce package, mais s'il parvient à votre environnement de production, nous apprécions grandement que vous nous envoyiez une carte postale de votre ville natale, mentionnant lequel de nos packages vous utilisez.
Notre adresse est : Spatie, Kruikstraat 22, 2018 Anvers, Belgique.
Nous publions toutes les cartes postales reçues sur le site Internet de notre entreprise.
La licence MIT (MIT). Veuillez consulter le fichier de licence pour plus d'informations.
