Quando scrivo un file batch per automatizzare qualcosa su una finestra di Windows, ho bisogno di sospenderne l'esecuzione per alcuni secondi (di solito in un ciclo di test / attesa, in attesa dell'avvio di un processo). Al momento, la migliore soluzione che ho potuto trovare utilizza il ping (non ti scherzo) per ottenere l'effetto desiderato. Ho trovato una migliore scrittura di questo qui , che descrive un callable "wait.bat", implementato come segue:

@ping 127.0.0.1 -n 2 -w 1000 > nul
@ping 127.0.0.1 -n %1% -w 1000> nul

È quindi possibile includere le chiamate a wait.bat nel proprio file batch, passando il numero di secondi di sospensione.

Apparentemente il Resource Kit di Windows 2003 fornisce un comando di sospensione simile a Unix (finalmente!). Nel frattempo, per quelli di noi che usano ancora Windows XP, Windows 2000 o (purtroppo) Windows NT , c'è un modo migliore?

Ho modificato lo sleep.pyscript nella risposta accettata , in modo che sia impostato per impostazione predefinita su un secondo se non viene passato alcun argomento sulla riga di comando:

import time, sys

time.sleep(float(sys.argv[1]) if len(sys.argv) > 1 else 1)

AGGIORNARE

Il timeoutcomando, disponibile da Windows Vista e successivi, dovrebbe essere il comando utilizzato, come descritto in un'altra risposta a questa domanda. Quello che segue qui è un vecchio risposta.

Vecchia risposta

Se hai installato Python o non ti dispiace installarlo (ha anche altri usi :), crea il seguente script sleep.py e aggiungilo da qualche parte nel tuo PERCORSO:

import time, sys

time.sleep(float(sys.argv[1]))

Consentirà pause al secondo secondo (ad esempio, 1,5 sec, 0,1, ecc.), Nel caso in cui ne abbiate bisogno. Se si desidera chiamarlo come sleepanziché anziché sleep.py, è possibile aggiungere il.PY estensione alla variabile di ambiente PATHEXT. Su Windows XP, puoi modificarlo in:

Risorse del computer → Proprietà (menu) → Avanzate (scheda) → Variabili d'ambiente (pulsante) → Variabili di sistema (frame)

Il timeoutcomando è disponibile da Windows Vista in poi:

c:\> timeout /?

TIMEOUT [/T] timeout [/NOBREAK]

Description:
    This utility accepts a timeout parameter to wait for the specified
    time period (in seconds) or until any key is pressed. It also
    accepts a parameter to ignore the key press.

Parameter List:
    /T        timeout       Specifies the number of seconds to wait.
                            Valid range is -1 to 99999 seconds.

    /NOBREAK                Ignore key presses and wait specified time.

    /?                      Displays this help message.

NOTE: A timeout value of -1 means to wait indefinitely for a key press.

Examples:
    TIMEOUT /?
    TIMEOUT /T 10
    TIMEOUT /T 300 /NOBREAK
    TIMEOUT /T -1

Nota: non funziona con il reindirizzamento dell'input - esempio banale:

C:\>echo 1 | timeout /t 1 /nobreak
ERROR: Input redirection is not supported, exiting the process immediately.

L'uso del pingmetodo come indicato è come lo faccio quando non riesco (o non voglio) aggiungere altri eseguibili o installare altri software.

Dovresti eseguire il ping di qualcosa che non è presente e utilizzare il -wflag in modo che non riesca dopo quel lasso di tempo, non eseguire il ping di qualcosa che è lì (come localhost) -nvolte. Ciò ti consente di gestire il tempo in meno di un secondo e penso che sia leggermente più preciso.

per esempio

(prova che 1.1.1.1 non viene preso)

ECHO Waiting 15 seconds

PING 1.1.1.1 -n 1 -w 15000 > NUL
  or
PING -n 15 -w 1000 127.1 >NUL

SLEEP.exeè incluso nella maggior parte dei kit di risorse, ad esempio il Resource Kit di Windows Server 2003 che può essere installato anche su Windows XP.

Usage:  sleep      time-to-sleep-in-seconds
        sleep [-m] time-to-sleep-in-milliseconds
        sleep [-c] commited-memory ratio (1%-100%)

Non sono d'accordo con le risposte che ho trovato qui.

Uso il seguente metodo interamente basato sulle funzionalità di Windows XP per ritardare un file batch:

DELAY.BAT:

@ECHO OFF
REM DELAY seconds

REM GET ENDING SECOND
FOR /F "TOKENS=1-3 DELIMS=:." %%A IN ("%TIME%") DO SET /A H=%%A, M=1%%B%%100, S=1%%C%%100, ENDING=(H*60+M)*60+S+%1

REM WAIT FOR SUCH A SECOND
:WAIT
FOR /F "TOKENS=1-3 DELIMS=:." %%A IN ("%TIME%") DO SET /A H=%%A, M=1%%B%%100, S=1%%C%%100, CURRENT=(H*60+M)*60+S
IF %CURRENT% LSS %ENDING% GOTO WAIT

È inoltre possibile inserire il giorno nel calcolo in modo che il metodo funzioni anche quando l'intervallo di ritardo supera la mezzanotte.

Ho riscontrato un problema simile, ma ho appena rovinato un'applicazione console C ++ molto corta per fare la stessa cosa. Basta eseguire MySleep.exe 1000 , forse più semplice del download / installazione dell'intero kit di risorse.

#include <tchar.h>
#include <stdio.h>
#include "Windows.h"

int _tmain(int argc, _TCHAR* argv[])
{
    if (argc == 2)
    {
        _tprintf(_T("Sleeping for %s ms\n"), argv[1]);
        Sleep(_tstoi(argv[1]));
    }
    else
    {
        _tprintf(_T("Wrong number of arguments.\n"));
    }
    return 0;
}

A Server Fault, è stata posta una domanda simile e la soluzione era:

choice /d y /t 5 > nul

È possibile utilizzare il livello WSH cscript di Windows e questo file JavaScript wait.js :

if (WScript.Arguments.Count() == 1)
    WScript.Sleep(WScript.Arguments(0)*1000);
else
    WScript.Echo("Usage: cscript wait.js seconds");

A seconda delle esigenze di compatibilità, utilizzare ping:

ping -n <numberofseconds+1> localhost >nul 2>&1

ad es. per attendere 5 secondi, utilizzare

ping -n 6 localhost >nul 2>&1

o su Windows 7 o versioni successive utilizzare timeout:

timeout 6 >nul

Puoi usare il ping:

ping 127.0.0.1 -n 11 -w 1000 >nul: 2>nul:

Aspetterà 10 secondi.

Il motivo per cui devi usare 11 è perché il primo ping si spegne immediatamente, non dopo un secondo. Il numero dovrebbe essere sempre uno in più del numero di secondi che si desidera attendere.

Tieni presente che lo scopo del -wnon è di aspettare un secondo. È per garantire che non si attenda più di un secondo nel caso in cui ci siano problemi di rete. pingda solo invierà un pacchetto ICMP al secondo. Probabilmente non è richiesto per localhost, ma le vecchie abitudini sono dure a morire.

C'è un modo migliore per dormire usando il ping. Ti consigliamo di eseguire il ping di un indirizzo che non esiste, quindi puoi specificare un timeout con precisione in millisecondi. Fortunatamente, un tale indirizzo è definito in uno standard (RFC 3330), e lo è 192.0.2.x. Questo non è inventato, è davvero un indirizzo al solo scopo di non esistere (potrebbe non essere chiaro, ma si applica anche nelle reti locali):

192.0.2.0/24 - Questo blocco è assegnato come "TEST-NET" per l'uso nella documentazione e nel codice di esempio. Viene spesso utilizzato insieme ai nomi di dominio example.com o example.net nella documentazione del fornitore e del protocollo. Gli indirizzi all'interno di questo blocco non devono apparire su Internet pubblico.

Per dormire per 123 millisecondi, utilizzare ping 192.0.2.1 -n 1 -w 123 >nul

Se hai PowerShell sul tuo sistema, puoi semplicemente eseguire questo comando:

powershell -command "Start-Sleep -s 1"

Modifica: da mia risposta su un thread simile , le persone hanno sollevato un problema in cui la quantità di tempo necessaria per avviare PowerShell è significativa rispetto a quanto tempo stai cercando di aspettare. Se l'accuratezza del tempo di attesa è importante (cioè un secondo o due ritardi extra non sono accettabili), è possibile utilizzare questo approccio:

powershell -command "$sleepUntil = [DateTime]::Parse('%date% %time%').AddSeconds(5); $sleepDuration = $sleepUntil.Subtract((get-date)).TotalMilliseconds; start-sleep -m $sleepDuration"

Questo richiede il tempo in cui è stato emesso il comando windows e lo script PowerShell rimane inattivo fino a 5 secondi dopo tale orario. Quindi, fino a quando PowerShell impiega meno tempo per iniziare rispetto alla durata del sonno, questo approccio funzionerà (sono circa 600 ms sulla mia macchina).

timeout /t <seconds> <options>

Ad esempio, per fare in modo che lo script esegua un'attesa ininterrotta di 2 secondi:

timeout /t 2 /nobreak >NUL

Ciò significa che lo script attenderà 2 secondi prima di continuare.

Per impostazione predefinita, una sequenza di tasti interromperà il timeout, quindi utilizzare l' /nobreakinterruttore se non si desidera che l'utente sia in grado di interrompere (annullare) l'attesa. Inoltre, il timeout fornirà notifiche al secondo per avvisare l'utente per quanto tempo resta da attendere; questo può essere rimosso reindirizzando il comando aNUL .

modifica: Come sottolinea @martineau nei commenti , il timeoutcomando è disponibile solo su Windows 7 e versioni successive. Inoltre, il pingcomando utilizza meno tempo del processore rispetto a timeout. Credo ancora nell'utilizzare, timeoutove possibile, poiché è più leggibile pingdell'hacking. Leggi di più qui .

Basta inserirlo nel file batch in cui si desidera attendere.

@ping 127.0.0.1 -n 11 -w 1000 > null

Nel Blocco note, scrivi:

@echo off
set /a WAITTIME=%1+1
PING 127.0.0.1 -n %WAITTIME% > nul
goto:eof

Ora salva come wait.bat nella cartella C: \ WINDOWS \ System32, quindi ogni volta che vuoi aspettare, usa:

CALL WAIT.bat <whole number of seconds without quotes>

Il Resource Kit ha sempre incluso questo. Almeno da Windows 2000.

Inoltre, il pacchetto Cygwin ha un sleepplop nel tuo PERCORSO e include il cygwin.dll(o come si chiama) e la strada da percorrere!

Mi piace la risposta di Aacini . L'ho aggiunto per gestire il giorno e consentirgli anche di gestire centisecondi ( %TIME%output H:MM:SS.CC):

:delay
SET DELAYINPUT=%1
SET /A DAYS=DELAYINPUT/8640000
SET /A DELAYINPUT=DELAYINPUT-(DAYS*864000)

::Get ending centisecond (10 milliseconds)
FOR /F "tokens=1-4 delims=:." %%A IN ("%TIME%") DO SET /A H=%%A, M=1%%B%%100, S=1%%C%%100, X=1%%D%%100, ENDING=((H*60+M)*60+S)*100+X+DELAYINPUT
SET /A DAYS=DAYS+ENDING/8640000
SET /A ENDING=ENDING-(DAYS*864000)

::Wait for such a centisecond
:delay_wait
FOR /F "tokens=1-4 delims=:." %%A IN ("%TIME%") DO SET /A H=%%A, M=1%%B%%100, S=1%%C%%100, X=1%%D%%100, CURRENT=((H*60+M)*60+S)*100+X
IF DEFINED LASTCURRENT IF %CURRENT% LSS %LASTCURRENT% SET /A DAYS=DAYS-1
SET LASTCURRENT=%CURRENT%
IF %CURRENT% LSS %ENDING% GOTO delay_wait
IF %DAYS% GTR 0 GOTO delay_wait
GOTO :EOF

Ho usato questo programma di sonno C #. Potrebbe essere più conveniente per te se C # è la tua lingua preferita:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace sleep
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length == 1)
            {
                double time = Double.Parse(args[0]);
                Thread.Sleep((int)(time*1000));
            }
            else
            {
                Console.WriteLine("Usage: sleep <seconds>\nExample: sleep 10");
            }
        }
    }
}

Ancora più leggero della soluzione Python è un rivestimento Perl.

Per dormire per sette secondi, inseriscilo nello script BAT:

perl -e "sleep 7"

Questa soluzione fornisce solo una risoluzione di un secondo.

Se hai bisogno di una risoluzione più alta, usa il modulo Time :: HiRes di CPAN. Fornisce usleep()quali dormono in microsecondi e nanosleep()quali dormono in nanosecondi (entrambe le funzioni accettano solo argomenti interi). Vedi la domanda Stack Overflow Come posso dormire per un millisecondo in Perl? per ulteriori dettagli.

Ho usato ActivePerl per molti anni. È molto facile da installare.

O riga di comando Python, ad esempio, per 6 secondi e mezzo:

python -c "import time;time.sleep(6.5)"

L'uso del ping è buono, purché tu voglia solo "aspettare un po '". Questo perché dipendi da altre funzioni sottostanti, come la tua rete funzionante e dal fatto che non c'è nulla di risposta su 127.0.0.1. ;-) Forse non è molto probabile che fallisca, ma non è impossibile ...

Se vuoi essere sicuro che stai aspettando esattamente il tempo specificato, dovresti usare il sleep funzionalità (che ha anche il vantaggio di non utilizzare la potenza della CPU o attendere che una rete sia pronta).

Trovare un eseguibile già creato per il sonno è il modo più conveniente. Rilascialo nella cartella Windows o in qualsiasi altra parte del percorso standard ed è sempre disponibile.

Altrimenti, se disponi di un ambiente di compilazione, puoi crearne uno tu stesso. La Sleepfunzione è disponibile in kernel32.dll, quindi devi solo usare quella. :-) Per VB / VBA dichiarare quanto segue all'inizio della sorgente per dichiarare una funzione sleep:

private Declare Sub Sleep Lib "kernel32" Alias "Sleep" (byval dwMilliseconds as Long)

Per C #:

[DllImport("kernel32.dll")]
static extern void Sleep(uint dwMilliseconds);

Ulteriori informazioni su questa funzionalità (disponibile da Windows 2000) sono disponibili nella funzione Sleep (MSDN).

Nello standard C, sleep()è incluso nella libreria standard e in Visual Studio C di Microsoft la funzione è denominata Sleep(), se la memoria mi serve. ;-) Quei due prendono l'argomento in pochi secondi, non in millisecondi come le due dichiarazioni precedenti.

La migliore soluzione che dovrebbe funzionare su tutte le versioni di Windows dopo Windows 2000 sarebbe:

timeout numbersofseconds /nobreak > nul

Pathping.exe può dormire meno del secondo.

@echo off
setlocal EnableDelayedExpansion 
echo !TIME! & pathping localhost -n -q 1 -p %~1 2>&1 > nul & echo !TIME!

.

> sleep 10
17:01:33,57
17:01:33,60

> sleep 20
17:03:56,54
17:03:56,58

> sleep 50
17:04:30,80
17:04:30,87

> sleep 100
17:07:06,12
17:07:06,25

> sleep 200
17:07:08,42
17:07:08,64

> sleep 500
17:07:11,05
17:07:11,57

> sleep 800
17:07:18,98
17:07:19,81

> sleep 1000
17:07:22,61
17:07:23,62

> sleep 1500
17:07:27,55
17:07:29,06

Sono impressionato da questo:

http://www.computerhope.com/batch.htm#02

choice /n /c y /d y /t 5 > NUL

Tecnicamente, stai dicendo al choicecomando di accettare solo y. Il valore predefinito è y, per farlo in 5 secondi, per non disegnare alcun prompt e per scaricare tutto ciò che dice a NUL (come un terminale null su Linux).

È inoltre possibile utilizzare un file .vbs per eseguire timeout specifici:

Il codice seguente crea il file .vbs. Metti questo nella parte superiore del tuo codice rbatch:

echo WScript.sleep WScript.Arguments(0) >"%cd%\sleeper.vbs"

Il codice seguente apre quindi i file .vbs e specifica per quanto tempo attendere:

start /WAIT "" "%cd%\sleeper.vbs" "1000"

Nel codice sopra, "1000" è il valore del ritardo da inviare al file .vbs in millisecondi, ad esempio 1000 ms = 1 s. Puoi modificare questa parte in modo che sia lungo quanto desideri.

Il codice seguente elimina il file .vbs dopo aver terminato. Metti questo alla fine del tuo file batch:

del /f /q "%cd%\sleeper.vbs"

Ed ecco il codice tutti insieme, quindi è facile da copiare:

echo WScript.sleep WScript.Arguments(0) >"%cd%\sleeper.vbs"
start /WAIT "" "%cd%\sleeper.vbs" "1000"
del /f /q "%cd%\sleeper.vbs"

Da Windows Vista in poi hai i comandi TIMEOUT e SLEEP , ma per usarli su Windows XP o Windows Server 2003, avrai bisogno del kit di strumenti di risorse di Windows Server 2003 .

Qui hai una buona panoramica delle alternative di sospensione (l'approccio ping è il più popolare in quanto funzionerà su ogni macchina Windows), ma ce n'è (almeno) uno non menzionato che (ab) usa il W32TMcomando (Time Service):

w32tm /stripchart /computer:localhost /period:1 /dataonly /samples:N  >nul 2>&1

Dove dovresti sostituire la N con i secondi che vuoi mettere in pausa. Inoltre, funzionerà su tutti i sistemi Windows senza prerequisiti.

Typeperf può anche essere utilizzato:

typeperf "\System\Processor Queue Length" -si N -sc 1 >nul

Con mshta e javascript (può essere utilizzato per dormire in meno di un secondo):

start "" /wait /min /realtime mshta "javascript:setTimeout(function(){close();},5000)"

Questo dovrebbe essere ancora più preciso (per aspettare meno di un secondo) - eseguibile autocompilante basandosi su .net:

@if (@X)==(@Y) @end /* JScript comment
@echo off
setlocal
::del %~n0.exe /q /f
::
:: For precision better call this like
:: call waitMS 500
:: in order to skip compilation in case there's already built .exe
:: as without pointed extension first the .exe will be called due to the ordering in PATEXT variable
::
::
for /f "tokens=* delims=" %%v in ('dir /b /s /a:-d  /o:-n "%SystemRoot%\Microsoft.NET\Framework\*jsc.exe"') do (
   set "jsc=%%v"
)

if not exist "%~n0.exe" (
    "%jsc%" /nologo /w:0 /out:"%~n0.exe" "%~dpsfnx0"
)


%~n0.exe %*

endlocal & exit /b %errorlevel%


*/


import System;
import System.Threading;

var arguments:String[] = Environment.GetCommandLineArgs();
function printHelp(){
    Console.WriteLine(arguments[0]+" N");
    Console.WriteLine(" N - milliseconds to wait");
    Environment.Exit(0);    
}

if(arguments.length<2){
    printHelp();
}

try{
    var wait:Int32=Int32.Parse(arguments[1]);
    System.Threading.Thread.Sleep(wait);
}catch(err){
    Console.WriteLine('Invalid Number passed');
    Environment.Exit(1);
}

Esistono molti modi per realizzare un ' sleep ' in cmd / batch:

Il mio preferito:

TIMEOUT /NOBREAK 5 >NUL 2>NUL

Ciò arresterà la console per 5 secondi, senza alcun output.

Più usato:

ping localhost -n 5 >NUL 2>NUL

Questo proverà a stabilire una connessione per localhost5 volte. Dal momento che è ospitato sul tuo computer, raggiungerà sempre l'host, quindi ogni secondo proverà il nuovo ogni secondo. Il -nflag indica quante volte lo script tenterà la connessione. In questo caso è 5, quindi durerà 5 secondi.

Varianti dell'ultima:

ping 1.1.1.1 -n 5 >nul

In questo script ci sono alcune differenze comparandolo con l'ultimo. Questo non proverà a chiamare localhost. Invece, proverà a connettersi a 1.1.1.1un sito Web molto veloce. L'azione durerà 5 secondi solo se si dispone di una connessione Internet attiva. Altrimenti durerà circa 15 per completare l'azione . Non consiglio di usare questo metodo.

ping 127.0.0.1 -n 5 >nul

Questo è esattamente lo stesso dell'esempio 2 (il più usato). Inoltre, puoi anche usare:

ping [::1] -n 5 >nul

Questo invece utilizza la localhostversione di IPv6 .

Esistono molti metodi per eseguire questa azione. Tuttavia, preferisco il metodo 1 per Windows Vista e versioni successive e il metodo più utilizzato (metodo 2) per le versioni precedenti del sistema operativo.

Puoi divertirti mettendo il messaggio PAUSA nella barra del titolo:

@ECHO off
SET TITLETEXT=Sleep
TITLE %TITLETEXT%
CALL :sleep 5
GOTO :END
:: Function Section
:sleep ARG
ECHO Pausing...
FOR /l %%a in (%~1,-1,1) DO (TITLE Script %TITLETEXT% -- time left^
 %%as&PING.exe -n 2 -w 1000 127.1>NUL)
EXIT /B 0
:: End of script
:END
pause
::this is EOF

Questo è stato testato su Windows XP SP3 e Windows 7 e utilizza CScript. Ho inserito alcune protezioni per evitare il "" suggerimento. ( /qsarebbe pericoloso)

Aspetta un secondo:

sleepOrDelayExecution 1000

Attendi 500 ms e poi esegui le cose dopo:

sleepOrDelayExecution 500 dir \ /s

sleepOrDelayExecution.bat:

@echo off
if "%1" == "" goto end
if NOT %1 GTR 0 goto end
setlocal
set sleepfn="%temp%\sleep%random%.vbs"
echo WScript.Sleep(%1) >%sleepfn%
if NOT %sleepfn% == "" if NOT EXIST %sleepfn% goto end
cscript %sleepfn% >nul
if NOT %sleepfn% == "" if EXIST %sleepfn% del %sleepfn%
for /f "usebackq tokens=1*" %%i in (`echo %*`) DO @ set params=%%j
%params%
:end

Poiché altri stanno suggerendo programmi di terze parti (Python, Perl, app personalizzate, ecc.), Un'altra opzione è GNU CoreUtils per Windows disponibile su http://gnuwin32.sourceforge.net/packages/coreutils.htm .

2 opzioni per la distribuzione:

1. Installa il pacchetto completo (che includerà la suite completa di CoreUtils, dipendenze, documentazione, ecc.).
2. Installa solo il binario 'sleep.exe' e le dipendenze necessarie (usa depend.exe per ottenere dipendenze).

Uno dei vantaggi della distribuzione di CoreUtils è che otterrai anche una serie di altri programmi utili per gli script (il batch di Windows lascia molto a desiderare).