Bash kullanarak tarihler arasında nasıl geçiş yapılır?

Böyle bir bash betiğim var:

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

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

Şimdi, örneğin 2015-01-01 ile 2015-01-31 arasındaki bir tarih aralığı arasında döngü yapmak istiyorum.

Bash'de nasıl başarılır?

Güncelleme :

Güzel-olması: Önceki bir çalıştırma tamamlanmadan önce hiçbir iş başlatılmamalıdır. Bu durumda, executeJobs.py tamamlandığında bash istemi $geri dönecektir.

örneğin kendi döngüme dahil edebilir miyim wait%1?

GNU tarihini kullanma:

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

Bunun dize karşılaştırması kullandığından, kenar tarihlerinin tam ISO 8601 gösterimini gerektirdiğini unutmayın (baştaki sıfırları kaldırmayın). Geçerli giriş verilerini kontrol etmek ve mümkünse geçerli bir forma zorlamak için şunları da kullanabilirsiniz date:

# 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

Son bir ekleme : Daha $startdateönce olduğunu kontrol etmek için , $enddateyalnızca 1000 ile 9999 yılları arasında tarihler bekliyorsanız, aşağıdaki gibi dize karşılaştırmasını kullanabilirsiniz:

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

Sözlükbilimsel karşılaştırmanın bozulduğu 10000 yılından sonra çok güvenli tarafta olmak için şunu kullanın:

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

İfade $(date -d "$d" +%Y%m%d)dönüştürür $dyani sayısal formuna dönüşmesi, 2015-02-23olur 20150223, ve fikri bu formda tarihleri sayısal karşılaştırılabilir olmasıdır.

Brace genişlemesi :

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

Daha:

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

Kanıt:

$ 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

Kompakt / iç içe:

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

Önemliyse sipariş edildi:

$ 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

Sırasız olduğundan, artık yılların üstesinden gelebilirsiniz:

$ 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

Aynı sorunu yaşadım ve yukarıdaki cevaplardan bazılarını denedim, belki tamamlar, ancak bu cevapların hiçbiri macOS kullanarak yapmaya çalıştığım şeyle sabitlenmedi.

Geçmişteki tarihleri ​​yinelemeye çalışıyordum ve şu benim için işe yaradı:

#!/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

Umarım yardımcı olur.

Giriş tarihinden aşağıdaki herhangi bir aralığa döngü yapmak istenirse kullanılabilir, ayrıca çıktı yyyyMMdd formatında yazdırılır ...

#!/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

AIX, BSD'ler, Linux, OS X ve Solaris'te tarihler arasında geçiş yapmam gerekiyordu. dateKomut ben karşılaştım platformlarındaki kullanımına az taşınabilir ve en sefil komutları biridir. Her my_dateyerde çalışan bir komut yazmayı daha kolay buldum .

Aşağıdaki C programı bir başlangıç ​​tarihi alır ve ondan günler ekler veya çıkarır. Tarih belirtilmezse, geçerli tarihe gün ekler veya çıkarır.

my_dateKomut her yerde aşağıdakileri yapabilirsiniz:

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

Ve C kodu:

#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, en iyi borulardan (|) yararlanılarak yazılır. Bu, bellek verimli ve eşzamanlı (daha hızlı) işleme ile sonuçlanmalıdır. Ben şunu yazardım:

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

Aşağıdakiler 20 aug 2020, 100 günün tarihini ve ondan önceki 100 günün tarihlerini yazdıracaktır.

Bu oneliner bir yardımcı program haline getirilebilir.

#!/usr/bin/env bash

# date-range template <template>

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

export LANG;

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

Varsayılan olarak her seferinde son 1 güne yineleme yapmayı seçiyoruz.

$ 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

Diyelim ki belirli bir tarihe kadar tarihler oluşturmak istiyoruz. Oraya ulaşmak için henüz kaç tane yinelemeye ihtiyacımız olduğunu bilmiyoruz. Diyelim ki Tom 1 Ocak 2001'de doğdu. Her tarihi belirli bir tarihe kadar oluşturmak istiyoruz. Bunu sed kullanarak başarabiliriz.

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

$((2**63-1))Hüner büyük tamsayı oluşturmak için kullanılır.

Sed çıktıktan sonra, tarih aralığı yardımcı programından da çıkacaktır.

3 aylık bir aralık kullanarak da yineleme yapılabilir:

$ 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

Meşgul kutusu tarihiyle sıkışıp kaldıysanız , zaman damgalarıyla çalışmanın en güvenilir yaklaşım olduğunu gördüm:

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

Bu çıktı:

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

Unix zaman damgası artık saniye içermez, bu nedenle 1 gün her zaman tam olarak 86400 saniyeye eşittir.