php - los - el tiempo en san josé, california

¿Es el tiempo actual entre dos tiempos dados?

Question

Estoy tratando de calcular si la hora actual está dentro del horario de apertura de un restaurante .

Esta pregunta se ha planteado mucho en Stackoverflow, pero no he encontrado una que pueda explicar los problemas que tengo. Además, sería bueno ver la idea de una mejor manera de hacer esto.

Actualmente se interrumpe si el día está cerrado (domingo en este ejemplo) o si es 1 am el "sábado" (técnicamente, 1 am domingo por la mañana). Tengo la sensación de que tendré que cambiar la forma en que se almacenan los datos para explicar después de la medianoche, pero estoy tratando de trabajar con lo que tengo por ahora. Es un problema, porque la mayoría de los restaurantes enumeran sus horarios de apertura para un día determinado de 5:00 a 2:00, no de 5:00 a 12:00, de 12:00 a 2:00.

De todos modos, esto es lo que tengo. Por favor, dime una mejor manera de hacerlo.

Tengo tiempos almacenados así:

$times = array(
    ''opening_hours_mon'' => ''9am - 8pm'',
    ''opening_hours_tue'' => ''9am - 2am'',
    ''opening_hours_wed'' => ''8:30am - 2am'',
    ''opening_hours_thu'' => ''5:30pm - 2am'',
    ''opening_hours_fri'' => ''8:30am - 11am'',
    ''opening_hours_sat'' => ''9am - 3pm, 5pm - 2am'',
    ''opening_hours_sun'' => ''closed''
);

Este es el código que estoy usando ahora:

// Get the right key for today
$status = ''open'';
$now = (int) current_time( ''timestamp'' );
$day = strtolower( date(''D'', $now) );
$string = ''opening_hours_''.$day;

$times = $meta[$string][0]; // This should be a stirng like ''6:00am - 2:00am'' or even ''6:00am - 11:00am, 1:00pm to 11:00pm''.

// Does it contain a ''-'', if not assume it''s closed.
$pos = strpos($times, ''-'');
if ($pos === false) {       
    $status = ''closed'';
} else {

    // Maybe a day has multiple opening times?
    $seating_times = explode('','', $times);
    foreach( $seating_times as $time ) {

        $chunks = explode(''-'', $time);
        $open_time = strtotime($chunks[0]);
        $close_time = strtotime($chunks[1]);

        // Calculate if now is between range of open and closed
        if(($open_time <= $now) && ($now <= $close_time)) {
            $status = ''open'';
            break;
        } else {
            $status = ''closed'';             
        }

    }

}

NOTA: current_time (''timestamp'', 0) es una función de WordPress .

Answer 1

Aquí está mi solución orientada a objetos, basada en el uso de la clase PHP DateTime (disponible desde la versión 5.2):

<?php 

class Restaurant {
    private $cw;
    private $times = array();
    private $openings = array();

    public function __construct(array $times) {
        $this->times = $times;
        $this->setTimes(date("w") ? "this" : "last");
        //print_r($this->openings);       // Debug
    }

    public function setTimes($cw) {
        $this->cw = $cw;
        foreach ($this->times as $key => $val) {
            $t = array();
            $buf = strtok($val, '' -,'');
            for ($n = 0; $buf !== FALSE; $n++) {
                try {
                    $d = new DateTime($buf);
                    $d->setTimestamp(strtotime(substr($key, -3)." {$this->cw} week {$buf}"));
                    if ($n && ($d < $t[$n-1])) {
                        $d->add(new DateInterval(''P1D''));
                    }
                    $t[] = $d;
                } catch (Exception $e) {
                    break;
                }
                $buf = strtok('' -,'');
            }
            if ($n % 2) {
                throw new Exception("Invalid opening time: {$val}");
            } else {
                $this->openings[substr($key, -3)] = $t;
            }
        }
    }

    public function isOpen() {
        $cw = date("w") ? "this" : "last";
        if ($cw != $this->cw) {
            $this->setTimes($cw);
        }
        $d = new DateTime(''now'');
        foreach ($this->openings as $wd => $t) {
            $n = count($t);
            for ($i = 0; $i < $n; $i += 2) {
                if (($d >= $t[$i]) && ($d <= $t[$i+1])) {
                    return(TRUE);
                }
            }
        }
        return(FALSE);
    }
}

$times = array(
    ''opening_hours_mon'' => ''9am - 8pm'',
    ''opening_hours_tue'' => ''9am - 2am'',
    ''opening_hours_wed'' => ''8:30am - 2am'',
    ''opening_hours_thu'' => ''9am - 3pm'',
    ''opening_hours_fri'' => ''8:30am - 11am'',
    ''opening_hours_sat'' => ''9am - 3pm, 5pm - 2am'',
    ''opening_hours_sun'' => ''closed''
);

try {
    $r = new Restaurant($times);
    $status = $r->isOpen() ? ''open'' : ''closed'';
    echo "status=".$status.PHP_EOL;
} catch (Exception $e) {
    echo $e->getMessage().PHP_EOL;
}

?>

Como puede ver, el constructor construye un formulario interno (la matriz de openings de objetos DateTime), que luego se usa con una comparación simple en el método isOpen para verificar si, en el momento de la llamada, el restaurante está abierto o cerrado.

También notará que he usado el método DateTime:add para calcular la fecha de mañana, en lugar de agregar 86400 (24 * 60 * 60) a la fecha y hora actual, para evitar problemas con los turnos de DST .
Prueba de concepto:

<?php

ini_set("date.timezone", "Europe/Rome");
echo "date.timezone = ".ini_get("date.timezone").PHP_EOL;

$d1 = strtotime("2013-10-27 00:00:00");
$d2 = strtotime("2013-10-28 00:00:00");
// Expected: 86400, Result: 90000
echo "Test #1: ".($d2 - $d1).PHP_EOL;
// Expected: 2013-10-28 00:00:00, Result: 2013-10-27 23:00:00
echo "Test #2: ".date("Y-m-d H:i:s", $d1 + 86400).PHP_EOL;

$d1 = strtotime("2014-03-30 00:00:00");
$d2 = strtotime("2014-03-31 00:00:00");
// Expected: 86400, Result: 82800
echo "Test #3: ".($d2 - $d1).PHP_EOL;
// Expected: 2014-03-30 00:00:00, Result: 2014-03-29 23:00:00
echo "Test #4: ".date("Y-m-d H:i:s", $d2 - 86400).PHP_EOL;

?>

Lo que da los siguientes resultados:

date.timezone = Europe/Rome
Test #1: 90000
Test #2: 2013-10-27 23:00:00
Test #3: 82800
Test #4: 2014-03-29 23:00:00

Por lo tanto, parece que un día no siempre tiene 86400 segundos; al menos no dos veces al año ...

Answer 2

Aquí está mi solución:

DATOS DE ENTRADA:

$meta = array(
   ''opening_hours_mon'' => ''9am - 8pm'',
   ''opening_hours_tue'' => ''9am - 2am'',
   ''opening_hours_wed'' => ''8:30am - 2am'',
   ''opening_hours_thu'' => ''9am - 3pm'',
   ''opening_hours_fri'' => ''8:30am - 11am'',
   ''opening_hours_sat'' => ''9am - 3pm, 5pm - 2am'',
   ''opening_hours_sun'' => ''closed''

);

current_time (''timestamp'') (como dicho autor) analog of time() en WordPress
Y solución:

    $now = (int) current_time( ''timestamp'' );
    $day = strtolower(date(''D'', $now));
    $yesterday = strtolower(date(''D'', strtotime(''-1 day'')));
    $days = array(
        ''yesterday'' => $meta[''opening_hours_''.$yesterday],
        ''today'' => $meta[''opening_hours_''.$day],
    );
    $status = false;
    foreach($days as $when=>$times)
    {
        $parts = explode('','',$times);
        foreach($parts as $p)
        {
            if($p == ''closed'')
                break;
            else{
                list($b,$e) = explode(''-'',$p);
                $b = strtotime("$when $b");
                $e = strtotime("$when $e");
                if($b > $e)
                    $e += strtotime("$when $e +1 day");;
                if($b <= $now && $now <= $e)
                {
                    $status =true;
                    break;
                }
            }
        }
    }

PARA LAS PRUEBAS:
Puedes cambiar las primeras 3 líneas a las siguientes:

$now = (int) strtotime(''today 3:00am'');
$day = strtolower(date(''D'', $now));
$yesterday = strtolower(date(''D'', strtotime(''yesterday 3:00am'')));

Answer 3

Aquí hay otra solución sin necesidad de reformatear sus datos.

$times = array(
    ''opening_hours_mon'' => ''9am - 8pm'',
    ''opening_hours_tue'' => ''9am - 2am'',
    ''opening_hours_wed'' => ''8:30am - 2am'',
    ''opening_hours_thu'' => ''5:30pm - 2am'',
    ''opening_hours_fri'' => ''8:30am - 11am'',
    ''opening_hours_sat'' => ''9am - 3pm, 5pm - 2am'',
    ''opening_hours_sun'' => ''closed''
);

function compileHours($times, $timestamp) {
    $times = $times[''opening_hours_''.strtolower(date(''D'',$timestamp))];
    if(!strpos($times, ''-'')) return array();
    $hours = explode(",", $times);
    $hours = array_map(''explode'', array_pad(array(),count($hours),''-''), $hours);
    $hours = array_map(''array_map'', array_pad(array(),count($hours),''strtotime''), $hours, array_pad(array(),count($hours),array_pad(array(),2,$timestamp)));
    end($hours);
    if ($hours[key($hours)][0] > $hours[key($hours)][1]) $hours[key($hours)][1] = strtotime(''+1 day'', $hours[key($hours)][1]);
    return $hours;
}

function isOpen($now, $times) {
    $open = 0; // time until closing in seconds or 0 if closed
    // merge opening hours of today and the day before
    $hours = array_merge(compileHours($times, strtotime(''yesterday'',$now)),compileHours($times, $now)); 

    foreach ($hours as $h) {
        if ($now >= $h[0] and $now < $h[1]) {
            $open = $h[1] - $now;
            return $open;
        } 
    }
    return $open;
}

$now = strtotime(''7:59pm'');
$open = isOpen($now, $times);

if ($open == 0) {
    echo "Is closed";
} else {
    echo "Is open. Will close in ".ceil($open/60)." minutes";
}

?>

Hice varias pruebas y parece funcionar como se esperaba, tomando todos los aspectos en los que podía pensar. Déjame saber si encuentras un problema con este. Sé que el enfoque parece un poco desagradable pero quería usar solo funciones simples (bueno, excepto la parte difícil con array_map ) y mantenerlo lo más corto posible.

Answer 4

He hecho algo similar en el pasado, pero adopté un enfoque totalmente diferente. Guardé mis horas de apertura en una mesa separada.

CREATE TABLE `Openinghours`
(
    `OpeninghoursID` int, // serial
    `RestaurantID` int, // foreign key
    `Dayofweek` int, // day of week : 0 (for Sunday) through 6 (for Saturday)
    `Opentime` int, // time of day when restaurant opens (in seconds)
    `Closetime` int // time of day when restaurant closes (in seconds)
);

Si un restaurante tiene más de un período de apertura por día, solo puede agregar 2 registros (o más identificación necesaria). Lo bueno de usar esta tabla es que simplemente puede consultar para ver qué restaurantes están abiertos.

$day = date(''w'');
$now = time()-strtotime("00:00");
$query = "Select `RestaurantID` from `Openinghours` where `Dayofweek` = ".$day." and `Opentime` <= ".$now." and `Closetime` > ".$now;

Otra de las ventajas de usar un sistema de este tipo es que puede adaptar su consulta para obtener diferentes resultados, como por ejemplo: qué restaurantes están abiertos ahora y permanecen abiertos por al menos otra hora (no tiene sentido ir a un restaurante unos minutos antes de cerrar)

$day = date(''w'');
$now = time()-strtotime("00:00");
$query = "Select `RestaurantID` from `Openinghours` where `Dayofweek` = ".$day." and `Opentime` <= ".$now." and `Closetime` > ".($now+3600);

Por supuesto, necesita reformatear sus datos actuales, pero trae buenas características.

Answer 5

Matrices de tiempos de semanas

$times = array(
    ''opening_hours_mon'' => ''9am - 8pm'',
    ''opening_hours_tue'' => ''9am - 2am'',
    ''opening_hours_wed'' => ''8:30am - 2am'',
    ''opening_hours_thu'' => ''9am - 3pm'',
    ''opening_hours_fri'' => ''8:30am - 11am'',
    ''opening_hours_sat'' => ''9am - 3pm, 5pm - 2am'',
    ''opening_hours_sun'' => ''closed''
);

Ejemplo de uso:

ini_set( "date.timezone", "Pacific/Auckland" ); // Make sure correct timezone is set

echo ( isOpen( $times ) ? ''Open'' : ''Closed'' );    

echo ( isOpen( $times ,"10am" ) ? ''Open'' : ''Closed'' );

Definición de la función:

/*
 *  First parameter : Weeks timings as array
 *  Second parameter : Time to check as string
 *  Return value : boolean
 */
function isOpen( $times ,$timeToCheck = ''now'' )
{
    $timeToCheckAsUnixTimestamp = strtotime( $timeToCheck );

    $yesterdayTimes = $todayTimes = '''';
    //  Find yesterday''s times and today''s times
    foreach( $times as $day => $timeRange )
    {
        $yesterdayTimes = ( stripos( $day ,date( "D" ,time() - 60 * 60 * 24 ) ) !== false ? $timeRange : $yesterdayTimes );
        $todayTimes = ( stripos( $day ,date( "D" ) ) !== false ? $timeRange : $todayTimes );
    }
    //  Handle closed
    if( strcasecmp( $todayTimes ,''closed'' ) == 0 ) return false;
    if( strcasecmp( $yesterdayTimes ,''closed'' ) == 0 ) $yesterdayTimes = ''12am - 12am'';
    //  Process and check with yesterday''s timings
    foreach( explode( '','' ,$yesterdayTimes ) as $timeRanges )
    {
        list( $from ,$to ) = explode( ''-'' ,$timeRanges );
        list( $fromAsUnixTimestamp ,$toAsUnixTimestamp ) = array( strtotime( $from .'' previous day'' ) ,strtotime( $to .'' previous day''  ) );
        $toAsUnixTimestamp = ( $toAsUnixTimestamp < $fromAsUnixTimestamp ? strtotime( $to ) : $toAsUnixTimestamp );
        if( $fromAsUnixTimestamp <= $timeToCheckAsUnixTimestamp and $timeToCheckAsUnixTimestamp <= $toAsUnixTimestamp ) return true;
    }
    //  Process and check with today''s timings
    foreach( explode( '','' ,$todayTimes ) as $timeRanges )
    {
        list( $from ,$to ) = explode( ''-'' ,$timeRanges );
        list( $fromAsUnixTimestamp ,$toAsUnixTimestamp ) = array( strtotime( $from ) ,strtotime( $to ) );
        $toAsUnixTimestamp = ( $toAsUnixTimestamp < $fromAsUnixTimestamp ? strtotime( $to .'' next day'' ) : $toAsUnixTimestamp );
        if( $fromAsUnixTimestamp <= $timeToCheckAsUnixTimestamp and $timeToCheckAsUnixTimestamp <= $toAsUnixTimestamp ) return true;
    }
    return false;
}

Answer 6

Pase su matriz como argumento a esta función y obtendrá verdadero para abierto y falso para cerrado en el momento actual. Es una función sencilla y directa. Acabo de consultar los horarios de apertura de hoy y, si es necesario, de ayer, sin hacer innecesarios recorridos durante todos los días de la semana. Tal vez podría mejorarse un poco, pero funciona y no es complicado.

function isOpen($times) {
    $times = array_values($times); //we will use numeric indexes
    $now = new DateTime();
    $day = $now->format(''N''); 
    $day--; //days are counted 1 to 7 so we decrement it to match indexes
    $period = $times[$day];
    if($period!=''closed'') {
        $opening = explode(''-'', $period);
        $open = new DateTime($opening[0]);
        $close = new DateTime($opening[1]);
        if($close<$open) {
            //it means today we close after midnight, it is tomorrow
            $close->add(new DateInterval(''P1D''));
        }
        if($open<$now && $now<$close) {
            //we are open
            return true;
        }
    }
    if($period==''closed'' || $now<$open) {
        //now we check if we still open since yesterday
        $day = $day==0 ? 6 : $day-1;
        $period = $times[$day];
        if($period==''closed'') return false;
        $opening = explode('' - '', $period);
        $open = new DateTime($opening[0]);
        $close = new DateTime($opening[1]);
        if($close<$open) {
        //it means yesterday we closed after midnight
            if($now<$close) {
                //we are before closing time
                return true;
            }
        }
    }
    return false;
}

Answer 7

Probablemente este no sea el más eficiente, pero debería funcionar bien para su problema:

$times = array(
    ''opening_hours_mon'' => ''9am - 8pm'',
    ''opening_hours_tue'' => ''9am - 2am'',
    ''opening_hours_wed'' => ''8:30am - 2am'',
    ''opening_hours_thu'' => ''9am - 3pm'',
    ''opening_hours_fri'' => ''8:30am - 11am'',
    ''opening_hours_sat'' => ''9am - 3pm, 5pm - 2am'',
    ''opening_hours_sun'' => ''closed''
);

var_dump(is_open($times, strtotime(''sun 1am''))); // true

Aquí está la primera función, simple en diseño; utiliza una cuadrícula de horarios de apertura y cierre y determina si el tiempo dado coincide con alguno de los rangos:

function is_open($times, $now)
{
    $today = strtotime(''today'', $now);

    $grid = get_time_grid($times);
    $today_name = strtolower(date(''D'', $today));
    $today_seconds = $now - $today;

    foreach ($grid[$today_name] as $range) {
        if ($today_seconds >= $range[0] && $today_seconds < $range[1]) {
            return true;
        }
    }

    return false;
}

Esta función construye la cuadrícula real; si un final de rango viene antes de su inicio correspondiente, creará dos rangos, uno para cada día que se está extendiendo.

function get_time_grid($times)
{
    static $next_day = array(
        ''mon'' => ''tue'', ''tue'' => ''wed'', ''wed'' => ''thu'',
        ''thu'' => ''fri'', ''fri'' => ''sat'', ''sat'' => ''sun'',
        ''sun'' => ''mon''
    );
    static $time_r = ''(/d{1,2}(?::/d{2})?(?:am|pm))'';

    $today = strtotime(''today'');
    $grid = [];

    foreach ($times as $key => $schedule) {
        $day_name = substr($key, -3);
        // match all time ranges, skips "closed"
        preg_match_all("/$time_r - $time_r/", $schedule, $slots, PREG_SET_ORDER);
        foreach ($slots as $slot) {
            $from = strtotime($slot[1], $today) - $today;
            $to = strtotime($slot[2], $today) - $today;

            if ($to < $from) { // spans two days
                $grid[$day_name][] = [$from, 86400];
                $grid[$next_day[$day_name]][] = [0, $to];
            } else { // normal range
                $grid[$day_name][] = [$from, $to];
            }
        }
    }

    return $grid;
}

Solo hay algunos comentarios en el código, pero espero que puedan seguir lo que se está haciendo. Déjame saber si necesitas alguna aclaración.

Answer 8

Si usa una base de datos para esto, no usó datetime para esto.

Muestra:

sunday 14:28, saturday 1:28

Puede dividir estas dos partes y compararlas, en tiempo de cadena (parte 2). Puedes usar strtotime para convertir el tiempo de la cadena en una marca de tiempo y compararla.

Muestra:

$date = "sunday 14:28"; 
echo $stamp = strtotime($date);

Salida:

1360492200

Me gusta este código:

$Time="sunday  14:28 , saturday 1:28";
$tA=explode(",",$Time);
$start=strtotime($tA[0]);
$end=strtotime($tA[1]);
$now=time();
if($now>$start and $now<$end){
   echo "is open";
}else{
   echo "is close";
}

Pero tienes un problema con actualizarlos puedes hacer esto.

Answer 9

Supongamos que, en lugar de una matriz de este tipo, teníamos otra con el siguiente tipo de entradas:

Array ( [from] => 1382335200 [to] => 1382374800 )

Los valores from y to son marcas de tiempo, calculadas proyectando la información de su matriz a la semana actual (en ejecución) .

Luego, para verificar si el restaurante estaba abierto en este momento, tendríamos que hacer algo tan simple como:

$slots=..... /* calculate time slots array */
$status=''closed'';
$rightnow=time();
foreach($slots as $slot)
  if($rightnow<=$slot[''to''])
    {
    if($rightnow>=$slot[''from'']) $status=''open'';
    break;
    }
echo "The restaurant is <strong>$status</strong> right now<br>";

Dado un día de la semana, en forma de mon , tue , wed , etc. y dos cadenas que definen un rango de tiempo, por ejemplo, de 8:30am y 3:15pm , la siguiente función devolverá el intervalo de tiempo correspondiente, como se describió anteriormente:

function get_time_slot($weekday,$fromtime,$totime)
  {
  $from_ts=strtotime("this week $weekday $fromtime");
  $to_ts=strtotime("this week $weekday $totime");
  if($to_ts<$from_ts)
    {
    $to_ts=strtotime("this week $weekday +1 day $totime");
    if($to_ts>strtotime("next week midnight")) 
      $to_ts=strtotime("this week mon $totime");
    }
  return array(''from''=>$from_ts,''to''=>$to_ts);
  }

strtotime() puede hacer milagros, ¿eh? Tenga en cuenta que, si el final del intervalo de tiempo resulta ser anterior al inicio, suponemos que se refiere al día siguiente y lo volvemos a calcular como tal.

EDITAR: Al principio, ingenuamente pensé que lo corregiría agregando los segundos de un día. Eso no fue exactamente exacto, ya que manipular una marca de tiempo no conserva la información de horario de verano. Entonces, si un intervalo de tiempo incluyera un turno de día (medianoche) y también un turno de horario de verano , daría resultados inexactos por hora. Usar strtotime() nuevamente, con el mismo argumento más un día, lo pondría en orden.

yaEDIT: Se corrigió otro error (con suerte el último): cuando un restaurante está abierto los domingos hasta después de la medianoche, $to_time debería terminar hasta el lunes de esta semana, a la misma hora. ¡Uf!

Ahora, para transformar tu matriz, deberías hacer:

$slots=array();
foreach($times as $key=>$entry)
  {
  list(,,$dow)=explode(''_'',$key);
  foreach(explode('','',$entry) as $d)
    {
    $arr=explode(''-'',$d);
    if(count($arr)==2) $slots[]=get_time_slot($dow,$arr[0],$arr[1]);
    }
  }

Aquí hay un pequeño phpfiddle para demostrar esto .

EDITAR : Motivado por la discusión de "concisión" en otra respuesta, pensé en dar mi versión "compacta". Usando la misma lógica exacta , se reduce a lo siguiente:

$status=''closed'';
$rightnow=time();
foreach($times as $key=>$entry)
  {
  list(,,$dow)=explode(''_'',$key);
  foreach(explode('','',$entry) as $d)
    if(count($arr=explode(''-'',$d))==2)
      {
      $from_ts=strtotime("this week $dow {$arr[0]}");
      $to_ts=strtotime("this week $dow {$arr[1]}");
      if($to_ts<$from_ts) $to_ts=strtotime("this week $dow +1 day {$arr[1]}");
        {
        $to_ts=strtotime("this week $dow +1 day {$arr[1]}");
        if($to_ts>strtotime("next week midnight")) 
          $to_ts=strtotime("this week mon {$arr[1]}");
        }
      if($rightnow<=$to_ts)
        {
        if($rightnow>=$from_ts) $status=''open'';
        break 2; // break both loops
        }
      }
  }
echo "<hr>The restaurant is <strong>$status</strong> right now<br>";

Sin embargo, yo mismo prefiero la versión original. Además de los beneficios obvios de tener una función, la matriz $slots podría muy bien ser almacenada en caché y reutilizada, haciendo que los cálculos relevantes sean mucho más fáciles que analizar los datos originales nuevamente.

Answer 10

Tal vez no estoy entendiendo esto completamente, pero atravesando un ciclo básico, quizás esto podría funcionar:

if( ($date(''D'') == "3" ) )
{
    $open = "8";
    $close = "17";
    $now = time();

    if( ($now > $open) and ($now < $close) )
    {
        echo "open";
    }
    else
    {
        echo "closed";
    }
}

Quizás no sea la mejor manera de evitarlo, ya que esto no incluiría los días festivos, y requiere algunas declaraciones condicionales, pero creo que podría funcionar. Bueno, no es óptimo, pero siempre funcionó para mí.

Answer 11

Solución sin cambio de hora en formato almacenado

<?php
    $times = array(
        ''opening_hours_mon'' => ''9am - 8pm'',
        ''opening_hours_tue'' => ''5pm - 2am'',
        ''opening_hours_wed'' => ''8:30am - 2am'',
        ''opening_hours_thu'' => ''9am - 3pm'',
        ''opening_hours_fri'' => ''8:30am - 11am'',
        ''opening_hours_sat'' => ''9am - 3pm, 5pm - 2am'',
        ''opening_hours_sun'' => ''closed''
    );

    //$time_go = ''13:00'';
    $time_go = date(''H:i'');

    //$day_go = 1; //monday
    $day_go = (date(''N'') - 1);

    if(Are_they_open($time_go, $day_go, $times)){
        echo ''jep'';
    }
    else{
        echo ''nope'';
    }

    function Are_they_open($time_go, $day_go, $times){
        // the magic
        $times = array_values($times);
        $day_go = explode('','', $times[$day_go]);
        $time_go = hh_mm_toSeconds($time_go);

        foreach($day_go as $time){

            if((!$time) || ($time == ''closed'')){
                return false;
            }

            $time = explode('' - '', $time);
            $time_open = hh_mm_toSeconds(date(''H:i'', strtotime($time[0])));
            $time_close = hh_mm_toSeconds(date(''H:i'', strtotime($time[1])));

            if(($time_go > $time_open) && ($time_go < $time_close)){
                return true;
            }
            elseif (($time_open > $time_close) || ($time_go > $time_open)){
                return true;
            }

        }

        return false;
    }

    function hh_mm_toSeconds($str_time){
        sscanf($str_time, "%d:%d", $hours, $minutes);
        return ($hours * 3600) + ($minutes * 60);
    }
?>

Solución donde se cambia el formato de hora.

$times = array(
    1 => array(
        array(''07:00'', ''17:00'')
    ),
    2 => array(
        array(''07:00'', ''14:30''),
        array(''15:00'', ''20:00'')
    ),
    3 => array(
        array(''07:00'', ''17:00'')
    ),
    4 => false, //closed
    5 => array(
        array(''07:00'', ''17:00''),
        array(''20:00'', ''24:00'')
    ),
    6 => array(
        array(''00:00'', ''03:00''),
        array(''07:00'', ''17:00''),
        array(''20:00'', ''24:00'')
    ),
    7 => array(
        array(''00:00'', ''03:00'')
    ),
);