opening hours
4.1.1
Con spatie/opening-hours crea un objeto que describe el horario de apertura de una empresa, que puede consultar para saber si open o closed en días o fechas específicas, o utilizar para presentar los horarios por día.
spatie/opening-hours se puede usar directamente en Carbon gracias a cmixin/business-time para que pueda beneficiarse de las funciones de horario de apertura directamente en sus objetos de fecha mejorados.
Se crea un conjunto de horarios de apertura pasando un horario regular y una lista de excepciones.
// 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" ;
}El objeto se puede consultar para un día de la semana, lo que devolverá un resultado basado en el cronograma habitual:
// Open on Mondays:
$ openingHours -> isOpenOn ( ' monday ' ); // true
// Closed on Sundays:
$ openingHours -> isOpenOn ( ' sunday ' ); // falseTambién se puede consultar por una fecha y hora concreta:
// 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 ' ); // falseTambién puede devolver matrices de horarios de apertura para una semana o un día:
// 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 ();En la construcción, puede establecer una bandera para los tiempos de desbordamiento a lo largo de los días. Por ejemplo, para una discoteca que abre hasta las 3 de la madrugada los viernes y sábados:
$ openingHours = Spatie OpeningHours OpeningHours:: create ([
' overflow ' => true ,
' friday ' => [ ' 20:00-03:00 ' ],
' saturday ' => [ ' 20:00-03:00 ' ],
], null );Esto permite que la API consulte los datos del día anterior para verificar si el horario de apertura está abierto dentro de su rango de tiempo.
Puede agregar datos en definiciones y luego recuperarlos:
$ 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 eveningEn el ejemplo anterior, los datos son cadenas pero pueden tener cualquier tipo de valor. De modo que puede incrustar varias propiedades en una matriz.
Para mayor comodidad de la estructura, la pareja datos-horas puede ser una matriz totalmente asociativa, por lo que el ejemplo anterior es estrictamente equivalente al siguiente:
$ 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 ' ,
],
],
]); Puede utilizar el separador to especificar varios días a la vez, para la semana o para excepciones:
$ 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 ' ,
],
],
]);La última herramienta de estructura es el filtro, le permite pasar cierres (o referencias de métodos/funciones invocables) que toman una fecha como parámetro y devuelven la configuración para la fecha dada.
$ 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 se encuentra un elemento invocable en la propiedad "exceptions" , se agregará automáticamente a los filtros para que pueda mezclar filtros y excepciones en la matriz de excepciones . El primer filtro que devuelva un valor no nulo tendrá prioridad sobre los siguientes filtros y la matriz de filtros tiene prioridad sobre los filtros dentro de la matriz de excepciones .
Advertencia: activaremos todos los filtros para cada fecha de la que necesitemos recuperar el horario de apertura y no podemos predicar ni almacenar en caché el resultado (puede ser una función aleatoria), por lo que debe tener cuidado con los filtros, demasiados filtros o procesos largos dentro de los filtros. puede tener un impacto significativo en el rendimiento.
También puede devolver el siguiente DateTime de apertura o cierre de un DateTime determinado.
// 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:00Lea la sección de uso para conocer la API completa.
Spatie es una agencia de diseño web con sede en Amberes, Bélgica. Encontrará una descripción general de todos nuestros proyectos de código abierto en nuestro sitio web.
Invertimos muchos recursos en la creación de los mejores paquetes de código abierto. Puedes apoyarnos comprando uno de nuestros productos pagos.
Apreciamos mucho que nos envíe una postal desde su ciudad natal, mencionando cuál de nuestros paquetes está utilizando. Encontrarás nuestra dirección en nuestra página de contacto. Publicamos todas las postales recibidas en nuestro muro virtual de postales.
Puede instalar el paquete a través del compositor:
composer require spatie/opening-hours El paquete solo debe usarse a través de la clase OpeningHours . También se utilizan tres clases de objetos de valor: Time , que representa un solo tiempo, TimeRange , que representa un período con un inicio y un final, y openingHoursForDay , que representa un conjunto de TimeRange que no se pueden superponer.
SpatieOpeningHoursOpeningHoursOpeningHours::create(array $data, $timezone = null, $toutputTimezone = null): SpatieOpeningHoursOpeningHoursMétodo de fábrica estática para llenar el conjunto de horarios de apertura.
$ openingHours = OpeningHours:: create ([
' monday ' => [ ' 09:00-12:00 ' , ' 13:00-18:00 ' ],
// ...
]); Si no se especifica ninguna zona horaria, OpeningHours simplemente asumirá que siempre pasa objetos DateTime que ya tienen la zona horaria que coincide con su horario.
Si pasa $timezone como segundo argumento o mediante la clave de matriz 'timezone' (puede ser un objeto DateTimeZone o una string ), las fechas pasadas se convertirán a esta zona horaria al comienzo de cada método, entonces si el método devuelve un objeto de fecha (como nextOpen , nextClose , previousOpen , previousClose , currentOpenRangeStart o currentOpenRangeEnd ), luego se vuelve a convertir a la zona horaria original antes de la salida para que el objeto puede reflejar un momento en la hora local del usuario, mientras que OpeningHours puede permanecer en su propia zona horaria comercial.
Alternativamente, también puede especificar la zona horaria de entrada y salida (usando el segundo y tercer argumento) o usando una matriz:
$ 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 Por motivos de seguridad, la creación del objeto OpeningHours con rangos superpuestos generará una excepción a menos que pase explícitamente 'overflow' => true, en la definición de matriz de horario de apertura. También puedes fusionarlos explícitamente.
$ 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 );No todos los días son obligatorios, si falta algún día se fijará como cerrado.
OpeningHours::fill(array $data): SpatieOpeningHoursOpeningHours Lo mismo que create , pero no estático.
$ openingHours = ( new OpeningHours )-> fill ([
' monday ' => [ ' 09:00-12:00 ' , ' 13:00-18:00 ' ],
// ...
]);OpeningHours::forWeek(): SpatieOpeningHoursOpeningHoursForDay[] Devuelve una serie de objetos OpeningHoursForDay para una semana normal.
$ openingHours -> forWeek ();OpeningHours::forWeekCombined(): array Devuelve una serie de días. La clave de matriz es el primer día con el mismo horario, los valores de la matriz son días que tienen el mismo horario laboral y el mismo objeto OpeningHoursForDay .
$ openingHours -> forWeekCombined ();OpeningHours::forWeekConsecutiveDays(): array Devuelve una serie de días concatenados, días adyacentes con las mismas horas. La clave de matriz es el primer día con el mismo horario, los valores de la matriz son días que tienen el mismo horario laboral y el mismo objeto OpeningHoursForDay .
Advertencia : se consideran días consecutivos de lunes a domingo sin bucle (el lunes no es consecutivo al domingo) sin importar el orden de los días en los datos iniciales.
$ openingHours -> forWeekConsecutiveDays ();OpeningHours::forDay(string $day): SpatieOpeningHoursOpeningHoursForDay Devuelve un objeto OpeningHoursForDay para un día normal. Un día es una cadena en minúsculas del nombre del día en inglés.
$ openingHours -> forDay ( ' monday ' );OpeningHours::forDate(DateTimeInterface $dateTime): SpatieOpeningHoursOpeningHoursForDay Devuelve un objeto OpeningHoursForDay para una fecha específica. Busca una excepción ese día y, en caso contrario, devuelve el horario de apertura según el horario habitual.
$ openingHours -> forDate ( new DateTime ( ' 2016-12-25 ' ));OpeningHours::exceptions(): SpatieOpeningHoursOpeningHoursForDay[] Devuelve una matriz de todos los objetos OpeningHoursForDay para excepciones, codificados por una cadena de fecha Ymd .
$ openingHours -> exceptions ();OpeningHours::isOpenOn(string $day): boolComprueba si el negocio está abierto (contiene al menos 1 rango de horario de atención) en un día del horario habitual.
$ openingHours -> isOpenOn ( ' saturday ' );Si la cadena proporcionada es una fecha, verificará si está abierta (contiene al menos 1 rango de horas de apertura) considerando tanto el horario del día normal como las posibles excepciones.
$ openingHours -> isOpenOn ( ' 2020-09-03 ' );
$ openingHours -> isOpenOn ( ' 09-03 ' ); // If year is omitted, current year is used instead OpeningHours::isClosedOn(string $day): boolComprueba si el negocio está cerrado en un día del horario habitual.
$ openingHours -> isClosedOn ( ' sunday ' );OpeningHours::isOpenAt(DateTimeInterface $dateTime): boolComprueba si el negocio está abierto en un día concreto, a una hora concreta.
$ openingHours -> isOpenAt ( new DateTime ( ' 2016-26-09 20:00 ' ));OpeningHours::isClosedAt(DateTimeInterface $dateTime): boolComprueba si el negocio está cerrado en un día concreto, a una hora determinada.
$ openingHours -> isClosedAt ( new DateTime ( ' 2016-26-09 20:00 ' ));OpeningHours::isOpen(): boolComprueba si el negocio está abierto en este momento.
$ openingHours -> isOpen ();OpeningHours::isClosed(): boolComprueba si el negocio está cerrado en este momento.
$ openingHours -> isClosed ();OpeningHours::isAlwaysOpen(): boolComprueba si el negocio está abierto 24 horas al día, 7 días a la semana, no tiene excepciones ni filtros.
if ( $ openingHours -> isAlwaysOpen ()) {
echo ' This business is open all day long every day. ' ;
}OpeningHours::isAlwaysClosed(): boolComprueba si el negocio nunca está abierto, no tiene excepciones ni filtros.
OpeningHours acepta matrices o listas vacías con todos los días de la semana vacíos sin prejuicios.
Si no es un estado válido en su dominio, debe usar este método para generar una excepción o mostrar un error.
if ( $ openingHours -> isAlwaysClosed ()) {
throw new RuntimeException ( ' Opening hours missing ' );
}OpeningHours::nextOpenOpeningHours::nextOpen(
?DateTimeInterface $ dateTime = null ,
?DateTimeInterface $ searchUntil = null ,
?DateTimeInterface $ cap = null ,
) : DateTimeInterface` Devuelve el siguiente DateTime abierto desde el DateTime dado ( $dateTime o desde ahora si este parámetro es nulo o se omite).
Si se pasa un objeto DateTimeImmutable , se devuelve un objeto DateTimeImmutable .
Establezca $searchUntil en una fecha para generar una excepción si no se puede encontrar una hora de apertura antes de este momento.
Establezca $cap en una fecha de modo que, si no se puede encontrar una hora de apertura antes de este momento, se devuelva $cap .
$ openingHours -> nextOpen ( new DateTime ( ' 2016-12-24 11:00:00 ' ));OpeningHours::nextCloseOpeningHours::nextClose(
?DateTimeInterface $ dateTime = null ,
?DateTimeInterface $ searchUntil = null ,
?DateTimeInterface $ cap = null ,
) : DateTimeInterface` Devuelve el próximo cierre DateTime desde el DateTime dado ( $dateTime o desde ahora si este parámetro es nulo o se omite).
Si se pasa un objeto DateTimeImmutable , se devuelve un objeto DateTimeImmutable .
Establezca $searchUntil en una fecha para generar una excepción si no se puede encontrar una hora de cierre antes de este momento.
Establezca $cap en una fecha de modo que, si no se puede encontrar una hora de cierre antes de este momento, se devuelva $cap .
Si la programación siempre está abierta o siempre cerrada, no hay ningún cambio de estado que encontrar y, por lo tanto, nextOpen (pero también previousOpen , nextClose y previousClose ) arrojará un MaximumLimitExceeded Puede detectarlo y reaccionar en consecuencia o puede usar los métodos isAlwaysOpen / isAlwaysClosed para anticipar tal caso.
$ openingHours -> nextClose ( new DateTime ( ' 2016-12-24 11:00:00 ' ));OpeningHours::previousOpenOpeningHours::previousOpen(
?DateTimeInterface $ dateTime = null ,
?DateTimeInterface $ searchUntil = null ,
?DateTimeInterface $ cap = null ,
) : DateTimeInterface` Devuelve DateTime abierto anterior desde el DateTime dado ( $dateTime o desde ahora si este parámetro es nulo o se omite).
Si se pasa un objeto DateTimeImmutable , se devuelve un objeto DateTimeImmutable .
Establezca $searchUntil en una fecha para generar una excepción si no se puede encontrar una hora de apertura después de este momento.
Establezca $cap en una fecha de modo que, si no se puede encontrar una hora de apertura después de este momento, se devuelva $cap .
$ openingHours -> previousOpen ( new DateTime ( ' 2016-12-24 11:00:00 ' ));OpeningHours::previousCloseOpeningHours::previousClose(
?DateTimeInterface $ dateTime = null ,
?DateTimeInterface $ searchUntil = null ,
?DateTimeInterface $ cap = null ,
) : DateTimeInterface` Devuelve DateTime de cierre anterior desde la DateTime dada ( $dateTime o desde ahora si este parámetro es nulo o se omite).
Si se pasa un objeto DateTimeImmutable , se devuelve un objeto DateTimeImmutable .
Establezca $searchUntil en una fecha para generar una excepción si no se puede encontrar una hora de cierre después de este momento.
Establezca $cap en una fecha de modo que, si no se puede encontrar una hora de cierre después de este momento, se devuelva $cap .
$ openingHours -> nextClose ( new DateTime ( ' 2016-12-24 11:00:00 ' ));OpeningHours::diffInOpenHours(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatDevuelve la cantidad de tiempo abierto (número de horas como número flotante) entre 2 fechas/horas.
$ openingHours -> diffInOpenHours ( new DateTime ( ' 2016-12-24 11:00:00 ' ), new DateTime ( ' 2016-12-24 16:34:25 ' ));OpeningHours::diffInOpenMinutes(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatDevuelve la cantidad de tiempo abierto (número de minutos como número flotante) entre 2 fechas/horas.
OpeningHours::diffInOpenSeconds(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatDevuelve la cantidad de tiempo abierto (número de segundos como número flotante) entre 2 fechas/horas.
OpeningHours::diffInClosedHours(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatDevuelve la cantidad de tiempo cerrado (número de horas como número flotante) entre 2 fechas/horas.
$ openingHours -> diffInClosedHours ( new DateTime ( ' 2016-12-24 11:00:00 ' ), new DateTime ( ' 2016-12-24 16:34:25 ' ));OpeningHours::diffInClosedMinutes(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatDevuelve la cantidad de tiempo cerrado (número de minutos como número flotante) entre 2 fechas/horas.
OpeningHours::diffInClosedSeconds(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatDevuelve la cantidad de tiempo cerrado (número de segundos como número flotante) entre 2 fechas/horas.
OpeningHours::currentOpenRange(DateTimeInterface $dateTime) : false | TimeRange Devuelve una instancia de SpatieOpeningHoursTimeRange del rango abierto actual si el negocio está abierto, falso si el negocio está cerrado.
$ 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 " ;
} Los métodos start() y end() devuelven instancias SpatieOpeningHoursTime . Las instancias Time creadas a partir de una fecha se pueden formatear con información de fecha. Esto es útil para rangos que superan la medianoche:
$ 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 Devuelve una instancia DateTime de la fecha y hora desde que el negocio está abierto si el negocio está abierto, false si el negocio está cerrado.
Nota: la fecha puede ser el día anterior si utiliza rangos nocturnos.
$ 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 Devuelve una instancia DateTime de la fecha y hora hasta que el negocio estará abierto si el negocio está abierto, false si el negocio está cerrado.
Nota: la fecha puede ser el día siguiente si utiliza rangos nocturnos.
$ 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étodo de fábrica estático para llenar el conjunto con una matriz https://schema.org/OpeningHoursSpecification o una cadena JSON.
dayOfWeek admite una variedad de nombres de días (con sabor a Google) o una variedad de URL de días (especificación oficial 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) : arrayDevuelve una especificación de horas de apertura como una matriz.
$ 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 Esta clase está pensada como de solo lectura. Implementa ArrayAccess , Countable e IteratorAggregate para que puedas procesar la lista de TimeRange en forma de matriz.
SpatieOpeningHoursTimeRange Objeto de valor que describe un período con una hora de inicio y de finalización. Se puede convertir a una cadena en formato H:iH:i .
SpatieOpeningHoursTime Objeto de valor que describe un solo tiempo. Se puede convertir a una cadena en formato H:i .
Puedes convertir el formato OpenStreetMap al objeto OpeningHours usando osm-opening-hours (gracias a mgrundkoetter)
Consulte CHANGELOG para obtener más información sobre los cambios recientes.
composer test Consulte CONTRIBUCIÓN para obtener más detalles.
Si encuentra un error relacionado con la seguridad, envíe un correo electrónico a [email protected] en lugar de utilizar el rastreador de problemas.
Eres libre de utilizar este paquete, pero si llega a tu entorno de producción, te agradeceremos mucho que nos envíes una postal desde tu ciudad natal, mencionando cuál de nuestros paquetes estás utilizando.
Nuestra dirección es: Spatie, Kruikstraat 22, 2018 Amberes, Bélgica.
Publicamos todas las postales recibidas en el sitio web de nuestra empresa.
La Licencia MIT (MIT). Consulte el archivo de licencia para obtener más información.
