Come scorrere le date usando Bash?

Ho un tale script bash:

array=( '2015-01-01', '2015-01-02' )

for i in "${array[@]}"
do
    python /home/user/executeJobs.py {i} &> /home/user/${i}.log
done

Ora voglio scorrere un intervallo di date, ad esempio 2015-01-01 fino al 2015-01-31.

Come ottenere in Bash?

Aggiornamento :

Bello da avere: nessun lavoro dovrebbe essere avviato prima del completamento di un'esecuzione precedente. In questo caso, quando executeJobs.py è completato, il prompt di bash $tornerà.

ad es. potrei incorporare wait%1nel mio ciclo?

Utilizzando la data GNU:

d=2015-01-01
while [ "$d" != 2015-02-20 ]; do 
  echo $d
  d=$(date -I -d "$d + 1 day")

  # mac option for d decl (the +1d is equivalent to + 1 day)
  # d=$(date -j -v +1d -f "%Y-%m-%d" "2020-12-12" +%Y-%m-%d)
done

Si noti che poiché utilizza il confronto tra stringhe, è necessaria la notazione ISO 8601 completa delle date limite (non rimuovere gli zeri iniziali). Per verificare la presenza di dati di input validi e costringerli a un modulo valido, se possibile, puoi utilizzare dateanche:

# slightly malformed input data
input_start=2015-1-1
input_end=2015-2-23

# After this, startdate and enddate will be valid ISO 8601 dates,
# or the script will have aborted when it encountered unparseable data
# such as input_end=abcd
startdate=$(date -I -d "$input_start") || exit -1
enddate=$(date -I -d "$input_end")     || exit -1

d="$startdate"
while [ "$d" != "$enddate" ]; do 
  echo $d
  d=$(date -I -d "$d + 1 day")
done

Un'ultima aggiunta : per verificare che $startdatesia prima $enddate, se prevedi solo date comprese tra gli anni 1000 e 9999, puoi semplicemente utilizzare il confronto tra stringhe in questo modo:

while [[ "$d" < "$enddate" ]]; do

Per essere al sicuro oltre l'anno 10000, quando il confronto lessicografico si interrompe, usa

while [ "$(date -d "$d" +%Y%m%d)" -lt "$(date -d "$enddate" +%Y%m%d)" ]; do

L'espressione si $(date -d "$d" +%Y%m%d)converte $din una forma numerica, cioè 2015-02-23diventa 20150223, e l'idea è che le date in questa forma possano essere confrontate numericamente.

Espansione del tutore :

for i in 2015-01-{01..31} …

Di Più:

for i in 2015-02-{01..28} 2015-{04,06,09,11}-{01..30} 2015-{01,03,05,07,08,10,12}-{01..31} …

Prova:

$ echo 2015-02-{01..28} 2015-{04,06,09,11}-{01..30} 2015-{01,03,05,07,08,10,12}-{01..31} | wc -w
 365

Compatto / annidato:

$ echo 2015-{02-{01..28},{04,06,09,11}-{01..30},{01,03,05,07,08,10,12}-{01..31}} | wc -w
 365

Ordinato, se è importante:

$ x=( $(printf '%s\n' 2015-{02-{01..28},{04,06,09,11}-{01..30},{01,03,05,07,08,10,12}-{01..31}} | sort) )
$ echo "${#x[@]}"
365

Dal momento che non è ordinato, puoi semplicemente aggiungere anni bisestili:

$ echo {2015..2030}-{02-{01..28},{04,06,09,11}-{01..30},{01,03,05,07,08,10,12}-{01..31}} {2016..2028..4}-02-29 | wc -w
5844

start='2019-01-01'
end='2019-02-01'

start=$(date -d $start +%Y%m%d)
end=$(date -d $end +%Y%m%d)

while [[ $start -le $end ]]
do
        echo $start
        start=$(date -d"$start + 1 day" +"%Y%m%d")

done

Ho avuto lo stesso problema e ho provato alcune delle risposte sopra, forse sono ok, ma nessuna di queste risposte ha risolto quello che stavo cercando di fare, usando macOS.

Stavo cercando di ripetere le date in passato, e quanto segue è ciò che ha funzionato per me:

#!/bin/bash

# Get the machine date
newDate=$(date '+%m-%d-%y')

# Set a counter variable
counter=1 

# Increase the counter to get back in time
while [ "$newDate" != 06-01-18 ]; do
  echo $newDate
  newDate=$(date -v -${counter}d '+%m-%d-%y')
  counter=$((counter + 1))
done

Spero che sia d'aiuto.

Se si desidera eseguire il ciclo dalla data di input a qualsiasi intervallo di seguito può essere utilizzato, verrà anche stampato l'output nel formato aaaaMMgg ...

#!/bin/bash
in=2018-01-15
while [ "$in" != 2018-01-25 ]; do
  in=$(date -I -d "$in + 1 day")
  x=$(date -d "$in" +%Y%m%d)
  echo $x
done

Avevo bisogno di scorrere le date su AIX, BSD, Linux, OS X e Solaris. Il datecomando è uno dei comandi meno portabili e più miserabili da utilizzare sulle piattaforme che ho incontrato. Ho trovato più facile scrivere un my_datecomando che funzionasse ovunque.

Il programma C seguente prende una data di inizio e aggiunge o sottrae giorni da essa. Se non viene fornita alcuna data, aggiunge o sottrae giorni dalla data corrente.

Il my_datecomando ti consente di eseguire le seguenti operazioni ovunque:

start="2015-01-01"
stop="2015-01-31"

echo "Iterating dates from ${start} to ${stop}."

while [[ "${start}" != "${stop}" ]]
do
    python /home/user/executeJobs.py {i} &> "/home/user/${start}.log"
    start=$(my_date -s "${start}" -n +1)
done

E il codice C:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>

int show_help();

int main(int argc, char* argv[])
{
    int eol = 0, help = 0, n_days = 0;
    int ret = EXIT_FAILURE;

    time_t startDate = time(NULL);
    const time_t ONE_DAY = 24 * 60 * 60;

    for (int i=0; i<argc; i++)
    {
        if (strcmp(argv[i], "-l") == 0)
        {
            eol = 1;
        }
        else if (strcmp(argv[i], "-n") == 0)
        {
            if (++i == argc)
            {
                show_help();
                ret = EXIT_FAILURE;
                goto finish;
            }

            n_days = strtoll(argv[i], NULL, 0);
        }
        else if (strcmp(argv[i], "-s") == 0)
        {
            if (++i == argc)
            {
                show_help();
                ret = EXIT_FAILURE;
                goto finish;
            }

            struct tm dateTime;
            memset (&dateTime, 0x00, sizeof(dateTime));

            const char* start = argv[i];
            const char* end = strptime (start, "%Y-%m-%d", &dateTime);

            /* Ensure all characters are consumed */
            if (end - start != 10)
            {
                show_help();
                ret = EXIT_FAILURE;
                goto finish;
            }

            startDate = mktime (&dateTime);
        }
    }

    if (help == 1)
    {
        show_help();
        ret = EXIT_SUCCESS;
        goto finish;
    }

    char buff[32];
    const time_t next = startDate + ONE_DAY * n_days;
    strftime(buff, sizeof(buff), "%Y-%m-%d", localtime(&next));

    /* Paydirt */
    if (eol)
        fprintf(stdout, "%s\n", buff);
    else
        fprintf(stdout, "%s", buff);

    ret = EXIT_SUCCESS;

finish:

    return ret;
}

int show_help()
{
    fprintf(stderr, "Usage:\n");
    fprintf(stderr, "  my_date [-s date] [-n [+|-]days] [-l]\n");
    fprintf(stderr, "    -s date: optional, starting date in YYYY-MM-DD format\n");
    fprintf(stderr, "    -n days: optional, number of days to add or subtract\n");
    fprintf(stderr, "    -l: optional, add new-line to output\n");
    fprintf(stderr, "\n");
    fprintf(stderr, "  If no options are supplied, then today is printed.\n");
    fprintf(stderr, "\n");
    return 0;
}

Bash è meglio scritto sfruttando le pipe (|). Ciò dovrebbe comportare un'elaborazione efficiente della memoria e simultanea (più veloce). Vorrei scrivere quanto segue:

seq 0 100 | xargs printf "20 Aug 2020 - %sdays\n" \
  | xargs -d '\n' -l date -d

Quanto segue stamperà la data 20 aug 2020e stamperà le date dei 100 giorni precedenti.

Questo oneliner può essere trasformato in un'utilità.

#!/usr/bin/env bash

# date-range template <template>

template="${1:--%sdays}"

export LANG;

xargs printf "$template\n" | xargs -d '\n' -l date -d

Per impostazione predefinita, scegliamo di iterare negli ultimi 1 giorno alla volta.

$ seq 10 | date-range
Mon Mar  2 17:42:43 CET 2020
Sun Mar  1 17:42:43 CET 2020
Sat Feb 29 17:42:43 CET 2020
Fri Feb 28 17:42:43 CET 2020
Thu Feb 27 17:42:43 CET 2020
Wed Feb 26 17:42:43 CET 2020
Tue Feb 25 17:42:43 CET 2020
Mon Feb 24 17:42:43 CET 2020
Sun Feb 23 17:42:43 CET 2020
Sat Feb 22 17:42:43 CET 2020

Supponiamo di voler generare date fino a una certa data. Non sappiamo ancora quante iterazioni abbiamo bisogno per arrivarci. Diciamo che Tom è nato il 1 gennaio 2001. Vogliamo generare ogni data fino a una certa. Possiamo ottenere ciò utilizzando sed.

seq 0 $((2**63-1)) | date-range | sed '/.. Jan 2001 /q'

Il $((2**63-1))trucco viene utilizzato per creare un numero intero grande.

Una volta che sed esce, uscirà anche dall'utilità di intervallo di date.

Si può anche iterare utilizzando un intervallo di 3 mesi:

$ seq 0 3 12 | date-range '+%smonths'
Tue Mar  3 18:17:17 CET 2020
Wed Jun  3 19:17:17 CEST 2020
Thu Sep  3 19:17:17 CEST 2020
Thu Dec  3 18:17:17 CET 2020
Wed Mar  3 18:17:17 CET 2021

Se sei bloccato con la data busybox , ho trovato che lavorare con i timestamp è l'approccio più affidabile:

STARTDATE="2019-12-30"
ENDDATE="2020-01-04"

start=$(date -d $STARTDATE +%s)
end=$(date -d $ENDDATE +%s)

d="$start"
while [[ $d -le $end ]]
do
    date -d @$d +%Y-%m-%d

    d=$(( $d + 86400 ))
done

Questo produrrà:

2019-12-30
2019-12-31
2020-01-01
2020-01-02
2020-01-03
2020-01-04

Il timestamp Unix non include i secondi intercalari, quindi 1 giorno equivale sempre esattamente a 86400 secondi.