Powtarzaj komendę Uniksa co x sekundy na zawsze

Istnieje wbudowane polecenie Unix, repeatktórego pierwszym argumentem jest liczba powtórzeń polecenia, przy czym polecenie (z dowolnymi argumentami) jest określone przez pozostałe argumenty repeat.

Na przykład,

% repeat 100 echo "I will not automate this punishment."

wyśle ​​echo podany ciąg 100 razy, a następnie zatrzyma się.

Chciałbym podobną komendę - nazwijmy ją forever- która działa podobnie, z tym wyjątkiem, że pierwszym argumentem jest liczba sekund na pauzę między powtórzeniami i powtarza się na zawsze. Na przykład,

% forever 5 echo "This will get echoed every 5 seconds forever and ever."

Pomyślałem, że zapytam, czy coś takiego istnieje, zanim to piszę. Wiem, że to jest jak 2-liniowy skrypt Perla lub Pythona, ale może jest to bardziej standardowy sposób. Jeśli nie, możesz opublikować rozwiązanie w swoim ulubionym języku skryptowym, w stylu Rosetta Stone .

PS: Być może lepszym sposobem na zrobienie tego byłoby uogólnienie repeatpolegające zarówno na powtarzaniu liczby powtórzeń (z -1 oznacza nieskończoność), jak i na liczbie sekund snu między powtórzeniami. Powyższe przykłady stałyby się wówczas:

% repeat 100 0 echo "I will not automate this punishment."
% repeat -1 5 echo "This will get echoed every 5 seconds forever."

Wypróbuj watchpolecenie.

Usage: watch [-dhntv] [--differences[=cumulative]] [--help] [--interval=<n>] 
             [--no-title] [--version] <command>`

Po to aby:

watch -n1  command

uruchomi polecenie co drugi (dobrze, technicznie, każdy sekund plus czas potrzebny na commanduruchomienie jako watch(przynajmniej procpsi busyboximplementacje) po prostu śpi jedną sekundę między dwoma ciągami command), na zawsze.

Czy chcesz przekazać polecenie execzamiast sh -c, użyj -xopcji:

watch -n1 -x command

W systemie macOS można uzyskać watchz portów Mac :

port install watch

Lub możesz go uzyskać od Homebrew :

brew install watch

Grzmotnąć

while+ sleep:

while true
do 
    echo "Hi"
    sleep 1
done

Oto to samo, co skrócona jedna linijka (z poniższych komentarzy):

while sleep 1; do echo "Hi"; done

Używa ;oddzielnych poleceń i używa sleep 1do whiletestu, ponieważ zawsze zwraca true. Możesz umieścić więcej poleceń w pętli - wystarczy je oddzielić;

Jest to tylko krótsza wersja innych while+sleepodpowiedzi, jeśli często wykonujesz tego rodzaju zadania jako codzienną rutynę, użycie tego pozwala uniknąć niepotrzebnych naciśnięć klawiszy, a jeśli wiersz poleceń zaczyna rozumieć dłużej, jest to nieco łatwiejsze. Ale ten zaczyna się od spania jako pierwszego.

Jest to na ogół przydatne, jeśli chcesz podążać za czymś, co ma wyjście w jednym wierszu, np. Obciążenie maszyny:

while sleep 1; do uptime; done

Jednym z problemów, na który natrafiły wszystkie dotychczasowe odpowiedzi, jest to, że czas wykonania polecenia może dryfować. Na przykład, jeśli wykonujesz sleep 10polecenie między, a wykonanie polecenia zajmuje 2 sekundy, będzie ono uruchamiane co 12 sekund; jeśli uruchomienie zajmuje zmienną ilość czasu, to w dłuższej perspektywie czas jego uruchomienia może być nieprzewidywalny.

To może być właśnie to, czego chcesz; jeśli tak, skorzystaj z jednego z pozostałych rozwiązań lub skorzystaj z tego, ale uprość sleeppołączenie.

W przypadku jednominutowej rozdzielczości zadania cron będą uruchamiane o określonej godzinie, niezależnie od tego, jak długo zajmuje każde polecenie. (W rzeczywistości uruchomione zostanie nowe zadanie crona, nawet jeśli poprzednie nadal działa).

Oto prosty skrypt Perla, który śpi do następnego interwału, więc na przykład w odstępie 10 sekund polecenie może zostać uruchomione o 12:34:00, 12:34:10, 12:34:20 itd., Nawet jeśli samo polecenie zajmuje kilka sekund. Jeśli polecenie działa dłużej niż intervalsekundy, następny przedział zostanie pominięty (w przeciwieństwie do crona). Przedział jest obliczany względem epoki, więc przedział 86400 sekund (1 dzień) będzie działał o północy czasu UTC.

#!/usr/bin/perl

use strict;
use warnings;

if (scalar @ARGV < 2) {
    die "Usage: $0 seconds command [args...]\n";
}

$| = 1;  # Ensure output appears

my($interval, @command) = @ARGV;

# print ">>> interval=$interval command=(@command)\n";

while (1) {
    print "sleep ", $interval - time % $interval, "\n";
    sleep $interval - time % $interval;
    system @command; # TODO: Handle errors (how?)
}

Myślę, że wszystkie dotychczasowe odpowiedzi są albo zbyt skomplikowane, albo zamiast tego odpowiedz na inne pytanie:

• „Jak kilkakrotnie uruchamiać program, tak aby między końcem programu a następnym uruchomieniem było X sekund opóźnienia” .

Prawdziwe pytanie brzmiało:

• „Jak uruchamiać program co X sekund”

Są to dwie bardzo różne rzeczy, gdy polecenie wymaga czasu na zakończenie.

Weźmy na przykład skrypt foo.sh(udawaj, że jest to program, który zajmuje kilka sekund).

#!/bin/bash
# foo.sh
echo `date +"%H:%M:%S"` >> output.txt;
sleep 2.5;
# ---

Chcesz uruchomić to co sekundę, a większość sugerowałaby watch -n1 ./foo.sh, lub while sleep 1; do ./foo.sh; done. Daje to jednak wynik:

15:21:20
15:21:23
15:21:27
15:21:30
15:21:34

Co nie jest dokładnie uruchamiane co sekundę. Nawet z -pflagą, jak man watchsugeruje strona, może to rozwiązać, wynik jest taki sam.

Łatwym sposobem na wykonanie pożądanego zadania, na które niektórzy się dotykają, jest uruchomienie polecenia w tle. Innymi słowy:

while sleep 1; do (./foo.sh &) ; done

I to wszystko.

Możesz uruchomić go co 500 ms z sleep 0.5, lub co masz.

W bash:

bash -c 'while [ 0 ]; do echo "I will not automate this punishment in absurdum."; done'

( echomożna zastąpić dowolnym poleceniem ...

Lub w perl:

perl -e 'for (;1;) {print "I will not automate this punishment in absurdum.\n"}'

Gdzie print "I will not automate this punishment in absurdum.\n"można zastąpić „dowolnym” poleceniem otoczonym backticks (`).

I na chwilę dodaj sleepinstrukcję w pętli for:

bash -c 'while [ 0 ]; do echo "I will not automate this punishment in absurdum."; sleep 1; done'

i

perl -e 'for (;1;) {print "I will not automate this punishment in absurdum.\n"; sleep 1}'

Ostatnie bash> = 4.2 pod najnowszym jądrem Linuksa, odpowiedź oparta.

Aby ograniczyć czas wykonania, nie ma widelców ! Używane są tylko wbudowane.

W tym celu używam readwbudowanej funkcji zamiast sleep. Niestety nie będzie to działać w przypadku sesji notty .

Funkcja szybkiego uderzenia „ repeat” zgodnie z żądaniem:

repeat () {
   local repeat_times=$1 repeat_delay=$2 repeat_foo repeat_sleep
   read -t .0001 repeat_foo
   if [ $? = 1 ] ;then
       repeat_sleep() { sleep $1 ;}
   else
       repeat_sleep() { read -t $1 repeat_foo; }
   fi
   shift 2
   while ((repeat_times)); do
        ((repeat_times=repeat_times>0?repeat_times-1:repeat_times))
        "${@}"
        ((repeat_times))&& ((10#${repeat_delay//.})) &&
            repeat_sleep $repeat_delay
   done
}

Mały test z podanymi ciągami:

repeat 3 0 printf "Now: %(%T)T, Hello %s.\n" -1 Guy
Now: 15:13:43, Hello Guy.
Now: 15:13:43, Hello Guy.
Now: 15:13:43, Hello Guy.

repeat -1 .5 printf "Now: %(%T)T, Hello %s.\n" -1 Guy
Now: 15:14:14, Hello Guy.
Now: 15:14:14, Hello Guy.
Now: 15:14:15, Hello Guy.
Now: 15:14:15, Hello Guy.
Now: 15:14:16, Hello Guy.
Now: 15:14:16, Hello Guy.
Now: 15:14:17, Hello Guy.
Now: 15:14:17, Hello Guy.
Now: 15:14:18, Hello Guy.
Now: 15:14:18, Hello Guy.
^C

W zależności od szczegółowości i czasu trwania przesłanego polecenia ...

W najnowszych jądrach Linuksa istnieje plik /proc/timer_listzawierający informacje o czasie w nanosekundach.

Jeśli chcesz uruchomić polecenie dokładnie raz na sekundę, Twoje polecenie musi zakończyć się w niecałą sekundę! I stamtąd musisz sleeptylko resztę bieżącej sekundy.

Jeśli opóźnienie jest ważniejsze, a twoje polecenie nie wymaga znacznego czasu, możesz:

command=(echo 'Hello world.')
delay=10
while :;do
    printf -v now "%(%s)T" -1
    read -t $(( delay-(now%delay) )) foo
    ${command[@]}
  done.

Ale jeśli Twoim celem jest uzyskanie drobniejszej ziarnistości, musisz:

Użyj informacji w nanosekundach, aby poczekać do początku sekundy ...

W tym celu napisałem małą funkcję bash:

# bash source file for nano wait-until-next-second

mapfile  </proc/timer_list _timer_list
for ((_i=0;_i<${#_timer_list[@]};_i++));do
    ((_c+=${#_timer_list[_i]}))
    [[ ${_timer_list[_i]} =~ ^now ]] && TIMER_LIST_READ=$_c
    [[ ${_timer_list[_i]} =~ offset:.*[1-9] ]] && \
        TIMER_LIST_OFFSET=${_timer_list[_i]//[a-z.: ]} && \
        break
done
unset _i _timer_list _c
readonly TIMER_LIST_OFFSET TIMER_LIST_READ
waitNextSecondHires() {
    local nsnow nsslp
    read -N$TIMER_LIST_READ nsnow </proc/timer_list
    nsnow=${nsnow%% nsecs*}
    nsnow=$((${nsnow##* }+TIMER_LIST_OFFSET))
    nsslp=$((2000000000-10#${nsnow:${#nsnow}-9}))
    read -t .${nsslp:1} foo
}

Po ich uzyskaniu możesz:

command=(echo 'Hello world.')
while :;do
    waitNextSecondHires
    ${command[@]}
  done.

uruchomić ${command[@]}bezpośrednio w wierszu poleceń, niż porównać z

command=(eval "echo 'Hello world.';sleep .3")
while :;do
    waitNextSecondHires
    ${command[@]}
  done.

to musi dać dokładnie taki sam wynik.

Wynajmuje funkcję bash „ repeat” zgodnie z żądaniem:

Możesz to źródło:

mapfile  </proc/timer_list _timer_list
for ((_i=0;_i<${#_timer_list[@]};_i++));do
    ((_c+=${#_timer_list[_i]}))
    [[ ${_timer_list[_i]} =~ ^now ]] && TIMER_LIST_READ=$_c
    [[ ${_timer_list[_i]} =~ offset:.*[1-9] ]] && \
        TIMER_LIST_OFFSET=${_timer_list[_i]//[a-z.: ]} && \
        break
done
unset _i _timer_list _c
readonly TIMER_LIST_OFFSET TIMER_LIST_READ

repeat_hires () {
    local repeat_times=$1 repeat_delay=$2 repeat_foo repeat_sleep repeat_count
    read -t .0001 repeat_foo
    if [ $? = 1 ] ;then
        repeat_sleep() { sleep $1 ;}
    else
        repeat_sleep() { read -t $1 repeat_foo; }
    fi
    shift 2
    printf -v repeat_delay "%.9f" $repeat_delay
    repeat_delay=${repeat_delay//.}
    read -N$TIMER_LIST_READ nsnow </proc/timer_list
    nsnow=${nsnow%% nsec*}
    started=${nsnow##* }
    while ((repeat_times)); do
        ((repeat_times=repeat_times>0?repeat_times-1:repeat_times))
        "${@}"
        ((repeat_times)) && ((10#$repeat_delay)) && {
            read -N$TIMER_LIST_READ nsnow </proc/timer_list
            nsnow=${nsnow%% nsec*}
            nsnow=${nsnow##* }
            (( (nsnow - started) / 10#$repeat_delay - repeat_count++ )) &&
                printf >&2 "WARNING: Command '%s' too long for %f delay.\n" \
                           "${*}" ${repeat_delay:0:${#repeat_delay}-9
                           }.${repeat_delay:${#repeat_delay}-9}
            printf -v sleep "%010d" $((
                10#$repeat_delay - ( ( nsnow - started ) % 10#$repeat_delay ) ))
            repeat_sleep ${sleep:0:${#sleep}-9}.${sleep:${#sleep}-9}
        }
    done
}

Następnie spróbuj:

time repeat_hires 21 .05 sh -c 'date +%s.%N;sleep .01'
1480867565.152022457
1480867565.201249108
1480867565.251333284
1480867565.301224905
1480867565.351236725
1480867565.400930482
1480867565.451207075
1480867565.501212329
1480867565.550927738
1480867565.601199721
1480867565.651500618
1480867565.700889792
1480867565.750963074
1480867565.800987954
1480867565.853671458
1480867565.901232296
1480867565.951171898
1480867566.000917199
1480867566.050942638
1480867566.101171249
1480867566.150913407

real    0m1.013s
user    0m0.000s
sys     0m0.016s

time repeat_hires 3 .05 sh -c 'date +%s.%N;sleep .05'
1480867635.380561067
WARNING: Command 'sh -c date +%s.%N;sleep .05' too long for 0.050000 delay.
1480867635.486503367
WARNING: Command 'sh -c date +%s.%N;sleep .05' too long for 0.050000 delay.
1480867635.582332617

real    0m0.257s
user    0m0.000s
sys     0m0.004s

Chcesz wypróbować to (Bash)?

forever ()   {
    TIMES=shift;
    SLEEP=shift;
    if [ "$TIMES" = "-1" ]; then  
        while true;
        do 
            $@
            sleep $SLEEP
        done
    else
        repeat "$TIMES" $@ 
    fi; }

Perl

#!/usr/bin/env perl
# First argument is number of seconds to sleep between repeats, remaining
# arguments give the command to repeat forever.

$sleep = shift;
$cmd = join(' ', @ARGV);

while(1) {
  system($cmd);
  sleep($sleep); 
}

Bash i niektóre z jego pokrewnych powłok mają wygodny (( ... ))zapis, w którym można oceniać wyrażenia arytmetyczne.

Tak więc, jako odpowiedź na twoje trzecie wyzwanie, w którym zarówno liczba powtórzeń, jak i opóźnienie między nimi powinny być konfigurowalne, oto jeden ze sposobów, aby to zrobić:

repeat=10
delay=1

i=0
while (( i++ < repeat )); do
  echo Repetition $i
  sleep $delay
done

Ta odpowiedź cierpi również na przesunięcie czasowe ujęte w odpowiedzi Keitha .

Jak wspomniano przez gbrandt, jeśli watchpolecenie jest dostępne, zdecydowanie użyj go. Jednak niektóre systemy uniksowe nie mają zainstalowanej domyślnie (przynajmniej nie działają tam, gdzie pracuję).

Oto inne rozwiązanie z nieco inną składnią i wyjściem (działa w BASH i SH):

while [ 1 ] ; do
    <cmd>
    sleep <x>
    echo ">>>>>>>>>>>>>" `date` ">>>>>>>>>>>>>>"
done

Edycja: usunąłem część „.” w ostatnim zestawieniu echa ... pozostałość po moich dniach Perla;)

Jeśli nie zamierzasz wyświetlać komunikatu na ekranie i możesz sobie pozwolić na powtórzenie zadania w minutach , być może najlepszym narzędziem będzie crontab . Na przykład, jeśli chcesz wykonywać polecenie co minutę, w crontabpliku zapisujesz coś takiego :

* * * * * my_precious_command

Zapoznaj się z samouczkiem dla dalszego przykładu. Ponadto możesz łatwo ustawić czasy za pomocą Crontab Code Generator .

Co jeśli mielibyśmy oba?

Oto pomysł: tylko „interwał” powtarza się na zawsze. Z „interwałem” i „czasem” powtarza tę liczbę razy, oddzielonych „interwałem”.

Użycie :

$ loop [interval [times]] command

Algorytm będzie więc:

• Element listy
• jeśli $ 1 zawiera tylko cyfry, jest to interwał (domyślnie 2)
• jeśli 2 $ zawiera tylko cyfry, jest to liczba razy (domyślnie nieskończona)
• podczas pętli z tymi parametrami
  • „przerwa” snu
  • jeśli podano kilka razy, zmniejsz var aż do jego osiągnięcia

W związku z tym :

loop() {
    local i=2 t=1 cond

    [ -z ${1//[0-9]/} ] && i=$1 && shift
    [ -z ${1//[0-9]/} ] && t=$1 && shift && cond=1
    while [ $t -gt 0 ]; do 
        sleep $i
        [ $cond ] && : $[--t]
        $@
    done
}

Skończyło się na tym, że stworzyłem wariant odpowiedzi Swalog. Z nim musiałeś poczekać X sekund na pierwszą iterację, ja również prowadzę moją na pierwszym planie, więc ...

./foo.sh;while sleep 1; do (./foo.sh) ; done

Szybkie, brudne i prawdopodobnie niebezpieczne do uruchomienia, ale jeśli masz ochotę na przygodę i wiesz, co robisz, włóż to repeat.shi chmod 755to,

while true
do 
    eval $1 
    sleep $2 
done

Wywołaj to za pomocą ./repeat.sh <command> <interval>

Mój paskudny zmysł mówi, że jest to prawdopodobnie zły sposób, czy mój pajęczy zmysł, prawda?

Możesz uruchomić skrypt z init (dodając wiersz do / etc / inittab). Ten skrypt musi uruchomić polecenie, spać przez czas, który chcesz poczekać, aż uruchom ponownie skrypt i wyjść z niego. Init uruchomi skrypt ponownie po wyjściu.

Łatwy sposób na powtórzenie zadania z crontab w odstępie krótszym niż jedna minuta (przykład 20 sekund):

crontab: * * * * * script.sh

script.sh:

#!/bin/bash
>>type your commands here.

sleep 20
>>retype your commands here.

sleep 20
>>retype your commands here.

Moc można uzyskać z interpretera Pythona z powłoki.

python3 -c "import time, os
while True:
    os.system('your command')
    time.sleep(5)

wymień pięć w dowolnym czasie (sek.), jaki chcesz.

Uwaga: return użyj SHIFT + ENTER, aby zwrócić dane wejściowe w powłoce. I nie zapomnij wpisać wcięcia 4 SPACJA w każdej linii w pętli while.

To rozwiązanie działa w systemie MacOSX 10.7. Działa cudownie.

bash -c 'while [ 0 ]; do \
      echo "I will not automate this punishment in absurdum."; done'

W moim przypadku

bash -c 'while [ 0 ]; do ls; done'

lub

bash -c 'while [ 0 ]; do mv "Desktop/* Documents/Cleanup"; done'

aby stale sprzątać mój pulpit.

Możesz użyć tej funkcji rekurencyjnej:

#!/bin/bash
ininterval () {
    delay=$1
    shift
    $*
    sleep $delay
    ininterval $delay $*
}

lub dodaj:

ininterval $*

i wywołaj skrypt.

Aby wielokrotnie uruchamiać polecenie w oknie konsoli, zwykle uruchamiam coś takiego:

while true; do (run command here); done

Działa to również w przypadku wielu poleceń, na przykład w celu wyświetlania stale aktualizowanego zegara w oknie konsoli:

while true; do clear; date; sleep 1; done

#! /bin/sh

# Run all programs in a directory in parallel
# Usage: run-parallel directory delay
# Copyright 2013 by Marc Perkel
# docs at http://wiki.junkemailfilter.com/index.php/How_to_run_a_Linux_script_every_few_seconds_under_cron"
# Free to use with attribution

if [ $# -eq 0 ]
then
   echo
   echo "run-parallel by Marc Perkel"
   echo
   echo "This program is used to run all programs in a directory in parallel" 
   echo "or to rerun them every X seconds for one minute."
   echo "Think of this program as cron with seconds resolution."
   echo
   echo "Usage: run-parallel [directory] [delay]"
   echo
   echo "Examples:"
   echo "   run-parallel /etc/cron.20sec 20"
   echo "   run-parallel 20"
   echo "   # Runs all executable files in /etc/cron.20sec every 20 seconds or 3 times a minute."
   echo 
   echo "If delay parameter is missing it runs everything once and exits."
   echo "If only delay is passed then the directory /etc/cron.[delay]sec is assumed."
   echo
   echo 'if "cronsec" is passed then it runs all of these delays 2 3 4 5 6 10 12 15 20 30'
   echo "resulting in 30 20 15 12 10 6 5 4 3 2 executions per minute." 
   echo
   exit
fi

# If "cronsec" is passed as a parameter then run all the delays in parallel

if [ $1 = cronsec ]
then
   $0 2 &
   $0 3 &
   $0 4 &
   $0 5 &
   $0 6 &
   $0 10 &
   $0 12 &
   $0 15 &
   $0 20 &
   $0 30 &
   exit
fi

# Set the directory to first prameter and delay to second parameter

dir=$1
delay=$2

# If only parameter is 2,3,4,5,6,10,12,15,20,30 then automatically calculate 
# the standard directory name /etc/cron.[delay]sec

if [[ "$1" =~ ^(2|3|4|5|6|10|12|15|20|30)$ ]]
then
   dir="/etc/cron.$1sec"
   delay=$1
fi

# Exit if directory doesn't exist or has no files

if [ ! "$(ls -A $dir/)" ]
then
   exit
fi

# Sleep if both $delay and $counter are set

if [ ! -z $delay ] && [ ! -z $counter ]
then
   sleep $delay
fi

# Set counter to 0 if not set

if [ -z $counter ]
then
   counter=0
fi

# Run all the programs in the directory in parallel
# Use of timeout ensures that the processes are killed if they run too long

for program in $dir/* ; do
   if [ -x $program ] 
   then
      if [ "0$delay" -gt 1 ] 
      then
         timeout $delay $program &> /dev/null &
      else
         $program &> /dev/null &
      fi
   fi
done

# If delay not set then we're done

if [ -z $delay ]
then
   exit
fi

# Add delay to counter

counter=$(( $counter + $delay ))

# If minute is not up - call self recursively

if [ $counter -lt 60 ]
then
   . $0 $dir $delay &
fi

# Otherwise we're done

Za pomocą zshi sleepimplementacji, która akceptuje argumenty zmiennoprzecinkowe:

typeset -F SECONDS=0 n=0
repeat 100 {cmd; sleep $(((n+=3) - SECONDS))}

Lub dla forever:

for ((;;)) {cmd; sleep $(((n+=3) - SECONDS))}

Jeśli urządzenie sleepnie obsługuje pływaków, zawsze można zdefiniować ją jako owinięcia wokół zsh„s zselectwbudowanego:

zmodload zsh/zselect
sleep() zselect -t $((($1 * 100) | 0))

... Zastanawiam się, ile skomplikowanych rozwiązań można stworzyć, rozwiązując ten problem.

To może być takie proste ...

open /etc/crontab 

umieść tam 1 następną linię na końcu pliku, np .:

*/NumberOfSeconds * * * * user /path/to/file.sh

Jeśli chcesz uruchomić coś co 1 sekundę, po prostu umieść tam:

*/60 * * * * root /path/to/file.sh 

where that file.sh could be chmod 750 /path/to/file.sh

a wewnątrz tego pliku.sh powinno być:

#!/bin/bash 
#What does it do
#What is it runned by

your code or commands

i to wszystko!

CIESZYĆ SIĘ!

until ! sleep 60; do echo $(date); command; command; command; done

pracuje dla mnie.

1. Nie potrzebuję tego dokładnie co 60 sekund
2. „watch” nie obserwuje poleceń we wszystkich systemach
3. „zegarek” może przyjąć tylko jedno polecenie (lub plik skryptu)
4. ustawienie snu w stan zamiast ciała powoduje, że pętla jest lepiej przerywalna (więc twierdzenie w odpowiedzi na podobne pytanie dotyczące przepełnienia stosu. niestety w tej chwili mogę je znaleźć)
5. Chcę go wykonać raz przed opóźnieniem, więc używam do czasu zamiast