datetime fecha - Obtener el primer día de la semana en PHP?



numero convertir (25)

strtotime('this week', time());

Reemplace el tiempo (). Los siguientes métodos de domingo / último lunes no funcionarán cuando el día actual sea domingo / lunes.

Dada una fecha MM-dd-yyyy formato, ¿alguien puede ayudarme a obtener el primer día de la semana?


Simplemente use la date($format, strtotime($date,' LAST SUNDAY + 1 DAY'));


Aquí estoy considerando el domingo como el primer sábado y el último día de la semana.

$m = strtotime('06-08-2012');  
$today =   date('l', $m);  
$custom_date = strtotime( date('d-m-Y', $m) );   
if ($today == 'Sunday') {  
   $week_start = date("d-m-Y", $m);  
} else {  
  $week_start = date('d-m-Y', strtotime('this week last sunday', $custom_date));  
}  

if ($today == 'Saturday') {  
  $week_end = date("d-m-Y", $m);
} else {  
  $week_end = date('d-m-Y', strtotime('this week next saturday', $custom_date));  
}
echo '<br>Start: '. $week_start;  
echo '<br>End: '. $week_end;  

Salida:

Inicio: 05-08-2012
Fin: 11-08-2012


¿Qué tal esto?

$day_of_week = date('N', strtotime($string_date));
$week_first_day = date('Y-m-d', strtotime($string_date . " - " . ($day_of_week - 1) . " days"));
$week_last_day = date('Y-m-d', strtotime($string_date . " + " . (7 - $day_of_week) . " days"));

Por lo que vale, aquí hay un desglose del comportamiento inseguro del strtotime al determinar un marco de referencia consistente:

http://gamereplays.org/reference/strtotime.php

Básicamente, solo estas cadenas le darán la misma fecha de manera confiable, independientemente del día de la semana en que se encuentre actualmente cuando las llame:

strtotime("next monday");
strtotime("this sunday");
strtotime("last sunday"); 

La versión siguiente de PHP versión 5.3 siguiente función le da un primer día de la semana de una fecha determinada (en este caso, domingo, 2013-02-03):

<?php
  function startOfWeek($aDate){
    $d=strtotime($aDate);
    return strtotime(date('Y-m-d',$d).' - '.date("w",$d).' days');
  }

  echo(date('Y-m-d',startOfWeek("2013-02-07")).'
');
?>

El siguiente código debería funcionar con cualquier fecha personalizada, solo usa el formato de fecha deseado.

$custom_date = strtotime( date('d-m-Y', strtotime('31-07-2012')) ); 
$week_start = date('d-m-Y', strtotime('this week last monday', $custom_date));
$week_end = date('d-m-Y', strtotime('this week next sunday', $custom_date));
echo '<br>Start: '. $week_start;
echo '<br>End: '. $week_end;

Probé el código con PHP 5.2.17 Resultados:

Start: 30-07-2012
End: 05-08-2012

¿Qué tal esto?

$first_day_of_week = date('m-d-Y', strtotime('Last Monday', time()));
$last_day_of_week = date('m-d-Y', strtotime('Next Sunday', time()));

He venido en contra de esta pregunta algunas veces y siempre me ha sorprendido que las funciones de fecha no lo hagan más fácil o más claro. Aquí está mi solución para PHP5 que usa la clase DateTime :

/**
 * @param DateTime $date A given date
 * @param int $firstDay 0-6, Sun-Sat respectively
 * @return DateTime
 */
function getFirstDayOfWeek(DateTime $date, $firstDay = 0) {
    $offset = 7 - $firstDay;
    $ret = clone $date;
    $ret->modify(-(($date->format('w') + $offset) % 7) . 'days');
    return $ret;
}

Es necesario clonar para evitar alterar la fecha original.


Encontré esto bastante frustrante dado que mi zona horaria es australiana y que strtotime() odia las fechas en el Reino Unido.

Si el día actual es domingo, entonces strtotime("monday this week") regresará al día siguiente.

Para superar esto:

Precaución : esto solo es válido para las fechas de Australia / Reino Unido

$startOfWeek = (date('l') == 'Monday') ? date('d/m/Y 00:00') : date('d/m/Y', strtotime("last monday 00:00"));
$endOfWeek = (date('l') == 'Sunday') ? date('d/m/Y 23:59:59') : date('d/m/Y', strtotime("sunday 23:59:59"));

Esto es lo que estoy usando para obtener el primer y el último día de la semana desde cualquier fecha . En este caso, el lunes es el primer día de la semana ...

$date = date('Y-m-d') // you can put any date you want
$nbDay = date('N', strtotime($date));
$monday = new DateTime($date);
$sunday = new DateTime($date);
$monday->modify('-'.($nbDay-1).' days');
$sunday->modify('+'.(7-$nbDay).' days');

$monday = date('d-m-Y',strtotime('last monday',strtotime('next monday',strtotime($date))));

Tienes que llegar el lunes primero y luego obtener el "último lunes" del próximo lunes. Entonces, si la fecha dada es el lunes, devolverá la misma fecha no la semana pasada el lunes.


Esta es la solución más corta y más fácil de leer que encontré:

    <?php
    $weekstart = strtotime('monday this week');
    $weekstop = strtotime('sunday this week 23:59:59');
    //echo date('d.m.Y H:i:s', $weekstart) .' - '. date('d.m.Y H:i:s', $weekstop);
    ?>

strtotime es más rápido que el new DateTime()->getTimestamp() .


Esta pregunta necesita una buena respuesta DateTime : -

function firstDayOfWeek($date)
{
    $day = DateTime::createFromFormat('m-d-Y', $date);
    $day->setISODate((int)$day->format('o'), (int)$day->format('W'), 1);
    return $day->format('m-d-Y');
}

var_dump(firstDayOfWeek('06-13-2013'));

Salida:-

string '06-10-2013' (length=10)

Esto tratará los límites de los años y los años bisiestos.


Qué pasa:

$date = "2013-03-18"; 
$searchRow = date("d.m.Y", strtotime('last monday',strtotime($date." + 1 day")));
echo "for date " .$date ." we get this monday: " ;echo $searchRow; echo '<br>';

No es la mejor manera, pero he probado y si estoy en esta semana recibo el lunes correcto, y si estoy en lunes recibiré ese lunes.


Mantenlo simple :

<?php    
$dateTime = new \DateTime('2012-05-14');
$monday = clone $dateTime->modify(('Sunday' == $dateTime->format('l')) ? 'Monday last week' : 'Monday this week');
$sunday = clone $dateTime->modify('Sunday this week');    
?>

Fuente: manual de PHP


La forma más fácil de obtener el primer día (lunes) de la semana actual es:

strtotime("next Monday") - 604800;

donde 604800 - es el recuento de segundos en 1 semana (60 * 60 * 24 * 7).

Este código llega el próximo lunes y lo reduce durante 1 semana. Este código funcionará bien en cualquier día de la semana. Incluso si hoy es lunes.


$today_day = date('D'); //Or add your own date
$start_of_week = date('Ymd');
$end_of_week = date('Ymd');

if($today_day != "Mon")
    $start_of_week = date('Ymd', strtotime("last monday"));

if($today_day != "Sun")
                    $end_of_week = date('Ymd', strtotime("next sunday"));

Prueba esto:

function week_start_date($wk_num, $yr, $first = 1, $format = 'F d, Y')
{
    $wk_ts  = strtotime('+' . $wk_num . ' weeks', strtotime($yr . '0101'));
    $mon_ts = strtotime('-' . date('w', $wk_ts) + $first . ' days', $wk_ts);
    return date($format, $mon_ts);
}

$sStartDate = week_start_date($week_number, $year);
$sEndDate   = date('F d, Y', strtotime('+6 days', strtotime($sStartDate)));

(de este hilo del foro )


Una forma inteligente de hacerlo es dejar que PHP maneje las diferencias de zona horaria y el horario de verano (DST). Déjame mostrarte cómo hacer esto.

Esta función generará todos los días de lunes a viernes, inclusive (útil para generar días laborables semanales):

class DateTimeUtilities {
    public static function getPeriodFromMondayUntilFriday($offset = 'now') {
        $now = new \DateTimeImmutable($offset, new \DateTimeZone('UTC'));
        $today = $now->setTime(0, 0, 1);

        $daysFromMonday = $today->format('N') - 1;

        $monday = $today->sub(new \DateInterval(sprintf('P%dD', $daysFromMonday)));
        $saturday = $monday->add(new \DateInterval('P5D'));

        return new \DatePeriod($monday, new \DateInterval('P1D'), $saturday);
    }
}

foreach (DateTimeUtilities::getPeriodFromMondayUntilFriday() as $day) {
    print $day->format('c');
    print PHP_EOL;
}

Esto devolverá las fechas de lunes a viernes para la semana actual. Para hacer lo mismo para una fecha arbitraria, pase una fecha como parámetro a DateTimeUtilities ::getPeriodFromMondayUntilFriday , así:

foreach (DateTimeUtilities::getPeriodFromMondayUntilFriday('2017-01-02T15:05:21+00:00') as $day) {
    print $day->format('c');
    print PHP_EOL;
}

//prints 
//2017-01-02T00:00:01+00:00
//2017-01-03T00:00:01+00:00
//2017-01-04T00:00:01+00:00
//2017-01-05T00:00:01+00:00
//2017-01-06T00:00:01+00:00

¿Solo interesado en el lunes, como preguntó el OP?

$monday = DateTimeUtilities::getPeriodFromMondayUntilFriday('2017-01-02T15:05:21+00:00')->getStartDate()->format('c');
print $monday;
// prints
//2017-01-02T00:00:01+00:00

$givenday = date("w", mktime(0, 0, 0, MM, dd, yyyy));

Esto le da el día de la semana de la fecha especificada donde 0 = domingo y 6 = sábado. A partir de ahí, puede calcular hacia atrás al día que desee.


este está preparado para hoy es lunes

function lastMonday(\DateTime $date) {

    $timestamp = $date->getTimestamp();

    $monday = ( 1 == date( 'N', $timestamp ));

    if ($monday) {
        return $timestamp;
    } else {
        return strtotime( 'last monday', $timestamp );
    }
}

si desea que obtenga la marca de tiempo en lugar de DateTime cambie las dos primeras líneas (elimine date-> getTimestamp) cámbielas a solo esto

function lastMonday($timestamp) {

y si quieres que ingrese cadena, cambia las primeras dos líneas a esta

function lastMonday($dateString) {

    $timestamp = strtotime($dateString);

<?php
/* PHP 5.3.0 */

date_default_timezone_set('America/Denver'); //Set apprpriate timezone
$start_date = strtotime('2009-12-15'); //Set start date

//Today's date if $start_date is a Sunday, otherwise date of previous Sunday
$today_or_previous_sunday = mktime(0, 0, 0, date('m', $start_date), date('d', $start_date), date('Y', $start_date)) - ((date("w", $start_date) ==0) ? 0 : (86400 * date("w", $start_date)));

//prints 12-13-2009 (month-day-year)
echo date('m-d-Y', $today_or_previous_sunday);

?>

(Nota: MM, dd y aaaa en la Pregunta no son sintaxis estándar de formato de fecha php; no puedo estar seguro de lo que significa, así que configuro $ start_date con ISO año-mes-día)


Otra forma de hacerlo ...

$year = '2014';
$month = '02';
$day = '26';

$date = DateTime::createFromFormat('Y-m-d H:i:s', $year . '-' . $month . '-' . $day . '00:00:00');
$day = date('w', $date->getTimestamp());

// 0=Sunday 6=Saturday
if($day!=0){

   $newdate = $date->getTimestamp() - $day * 86400;  //86400 seconds in a day

   // Look for DST change 
   if($old = date('I', $date->getTimestamp()) != $new = date('I', $newdate)){
       if($old == 0){
           $newdate -= 3600;  //3600 seconds in an hour
       } else {
           $newdate += 3600;
       }
   }

   $date->setTimestamp($newdate);
}

echo $date->format('D Y-m-d H:i:s');

La respuesta corta

No hay documentación "universal" a la que se adapta JavaScript; Cada navegador que tiene javascript es realmente una implementación. Sin embargo, hay un estándar que la mayoría de los navegadores modernos tienden a seguir, y ese es el estándar EMCAScript; Las cadenas estándar de ECMAScript tendrían, como mínimo, una implementación modificada de la definición ISO 8601.

Además de esto, hay un segundo estándar establecido por el IETF que los navegadores también tienden a seguir, que es la definición de las marcas de tiempo realizadas en el RFC 2822. La documentación real se puede encontrar en la lista de referencias en la parte inferior.

De esto se puede esperar una funcionalidad básica, pero lo que "debería" ser no es inherentemente lo que "es". Sin embargo, voy a profundizar un poco en esto con el procedimiento, ya que parece que solo tres personas respondieron la pregunta (Scott, goofballLogic y peller a saber), lo que, para mí, sugiere que la mayoría de las personas no saben lo que realmente sucede cuando crear un objeto de fecha.

La respuesta larga

¿Dónde está la documentación que enumera los especificadores de formato admitidos por el objeto Date ()?


Para responder a la pregunta, o normalmente buscar la respuesta a esta pregunta, debe saber que JavaScript no es un lenguaje novedoso; en realidad es una implementación de ECMAScript, y sigue los estándares de ECMAScript (pero tenga en cuenta que javascript también es anterior a esos estándares; los estándares de EMCAScript se basan en la implementación temprana de LiveScript / JavaScript). El estándar ECMAScript actual es 5.1 (2011); en el momento en que se formuló originalmente la pregunta (junio de 2009), la norma era 3 (se abandonó 4), pero 5 se publicó poco después de la publicación a fines de 2009. Esto debería plantear un problema; qué estándar puede seguir una implementación de javascript, puede no reflejar lo que realmente está implementado, porque a) es una implementación de un estándar dado, b) no todas las implementaciones de un estándar son puritanas, yc) la funcionalidad no se libera en sincronización con un nuevo estándar como d) una implementación es un trabajo constante en progreso

Esencialmente, cuando se trata de javascript, se trata de un derivado (javascript específico para el navegador) de una implementación (javascript en sí). El V8 de Google, por ejemplo, implementa ECMAScript 5.0, pero el JScript de Internet Explorer no intenta cumplir con ningún estándar de ECMAScript, sin embargo, Internet Explorer 9 se ajusta a ECMAScript 5.0.

Cuando se pasa un solo argumento a la nueva Fecha (), se convierte este prototipo de función:

new Date(value)

Cuando se pasan dos o más argumentos a la nueva Fecha (), se convierte este prototipo de función:

new Date (year, month [, date [, hours [, minutes [, seconds [, ms ] ] ] ] ] )


Ambas funciones deben parecer familiares, pero esto no responde de inmediato a su pregunta y lo que se cuantifica como un "formato de fecha" aceptable requiere una explicación adicional. Cuando pase una cadena a la nueva Fecha (), llamará al prototipo (tenga en cuenta que estoy usando la palabra prototipo de manera general; las versiones pueden ser funciones individuales o pueden ser parte de una declaración condicional en una sola función) para nueva fecha (valor) con su cadena como argumento para el parámetro "valor". Esta función primero verificará si es un número o una cadena. La documentación para esta función se puede encontrar aquí:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.3.2

De esto, podemos deducir que para obtener el formato de cadena permitido para la nueva Fecha (valor), debemos observar el método Date.parse (cadena). La documentación para este método se puede encontrar aquí:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.4.2

Y también podemos inferir que se espera que las fechas estén en un formato extendido ISO 8601 modificado, como se especifica aquí:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15

Sin embargo, podemos reconocer por experiencia que el objeto Date de javascript acepta otros formatos (forzado por la existencia de esta pregunta en primer lugar), y esto está bien porque ECMAScript permite formatos de implementación específicos. Sin embargo, eso todavía no responde a la pregunta de qué documentación está disponible en los formatos disponibles, ni qué formatos están realmente permitidos. Vamos a ver la implementación de javascript de Google, V8; tenga en cuenta que no estoy sugiriendo que este sea el "mejor" motor javascript (cómo se puede definir "mejor" o incluso "bueno") y no se puede asumir que los formatos permitidos en V8 representan todos los formatos disponibles en la actualidad, pero creo que es justo para asumir que sí siguen las expectativas modernas.

V8 de Google, date.js, DateConstructor

https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#141

Al observar la función DateConstructor, podemos deducir que necesitamos encontrar la función DateParse; sin embargo, tenga en cuenta que "año" no es el año real y es solo una referencia al parámetro "año".

V8 de Google, date.js, DateParse

https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#270

Esto llama a% DateParseString, que en realidad es una referencia de función en tiempo de ejecución para una función de C ++. Se refiere al siguiente código:

V8 de Google, runtime.cc,% DateParseString

https://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r=18400#9559

La llamada a la función que nos ocupa en esta función es para DateParser :: Parse (); ignore la lógica que rodea esas llamadas de función, estas son solo verificaciones para cumplir con el tipo de codificación (ASCII y UC16). DateParser :: Parse se define aquí:

V8 de Google, dateparser-inl.h, DateParser :: Parse

https://code.google.com/p/v8/source/browse/trunk/src/dateparser-inl.h?r=18400#36

Esta es la función que realmente define qué formatos acepta. Esencialmente, verifica el estándar EMCAScript 5.0 ISO 8601 y, si no cumple con los estándares, intentará construir la fecha basándose en formatos heredados. Algunos puntos clave basados ​​en los comentarios:

  1. Las palabras antes del primer número que son desconocidas para el analizador se ignoran.
  2. El texto entre paréntesis se ignora.
  3. Los números sin firmar seguidos de ":" se interpretan como un "componente de tiempo".
  4. Los números sin firmar seguidos de "." Se interpretan como un "componente de tiempo", y deben ir seguidos de milisegundos.
  5. Los números firmados seguidos de la hora o la hora (p. Ej., +5: 15 o +0515) se interpretan como la zona horaria.
  6. Al declarar la hora y los minutos, puede usar "hh: mm" o "hhmm".
  7. Las palabras que indican una zona horaria se interpretan como una zona horaria.
  8. Todos los demás números se interpretan como "componentes de fecha".
  9. Todas las palabras que comienzan con los primeros tres dígitos de un mes se interpretan como el mes.
  10. Puede definir minutos y horas juntos en cualquiera de los dos formatos: "hh: mm" o "hhmm".
  11. Símbolos como "+", "-" y ")" no coincidentes no se permiten después de que se haya procesado un número.
  12. Los elementos que coinciden con varios formatos (por ejemplo, 1970-01-01) se procesan como una cadena EMCAScript 5.0 ISO 8601 compatible con el estándar.

Por lo tanto, esto debería ser suficiente para darle una idea básica de qué esperar cuando se trata de pasar una cadena a un objeto Date. Puede ampliar aún más esto observando la siguiente especificación a la que Mozilla apunta en la Red de Desarrolladores de Mozilla (compatible con las marcas de tiempo IETF RFC 2822):

http://tools.ietf.org/html/rfc2822#page-14

La Red de desarrolladores de Microsoft menciona además un estándar adicional para el objeto Fecha: ECMA-402, la especificación de la API de internacionalización ECMAScript, que es complementaria al estándar ECMAScript 5.1 (y futuros). Eso se puede encontrar aquí:

http://www.ecma-international.org/ecma-402/1.0/

En cualquier caso, esto debería ayudar a resaltar que no existe una "documentación" que represente universalmente todas las implementaciones de javascript, pero todavía hay suficiente documentación disponible para comprender qué cadenas son aceptables para un objeto Date. Bastante la pregunta cargada cuando piensas en ello, ¿sí? :PAG

Referencias

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.3.2

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.4.2

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15

http://tools.ietf.org/html/rfc2822#page-14

http://www.ecma-international.org/ecma-402/1.0/

https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#141

https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#270

https://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r=18400#9559

https://code.google.com/p/v8/source/browse/trunk/src/dateparser-inl.h?r=18400#36

Recursos

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

http://msdn.microsoft.com/en-us/library/ff743760(v=vs.94).aspx





php datetime