Al escribir un archivo por lotes para automatizar algo en un cuadro de Windows, he tenido que pausar su ejecución durante varios segundos (generalmente en un ciclo de prueba / espera, esperando que se inicie un proceso). En ese momento, la mejor solución que pude encontrar utiliza ping (no es broma) para lograr el efecto deseado. He encontrado una mejor redacción aquí , que describe un "wait.bat" invocable, implementado de la siguiente manera:

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

Luego puede incluir llamadas a wait.bat en su propio archivo por lotes, pasando el número de segundos para dormir.

Aparentemente, el Kit de recursos de Windows 2003 proporciona un comando de suspensión similar a Unix (¡por fin!). Mientras tanto, para aquellos de nosotros que todavía usamos Windows XP, Windows 2000 o (lamentablemente) Windows NT , ¿hay una mejor manera?

Modifiqué el sleep.pyscript en la respuesta aceptada , de modo que su valor predeterminado sea un segundo si no se pasan argumentos en la línea de comando:

import time, sys

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

ACTUALIZAR

El timeoutcomando, disponible desde Windows Vista en adelante, debe ser el comando utilizado, como se describe en otra respuesta a esta pregunta. Lo que sigue aquí es una vieja respuesta.

Vieja respuesta

Si tiene instalado Python, o no le importa instalarlo (también tiene otros usos :), simplemente cree el siguiente script sleep.py y agréguelo en algún lugar de su RUTA:

import time, sys

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

Permitirá pausas de menos de un segundo (por ejemplo, 1.5 segundos, 0.1, etc.), en caso de que lo necesite. Si desea llamarlo como en sleeplugar de sleep.py, puede agregar la .PYextensión a su variable de entorno PATHEXT. En Windows XP, puede editarlo en:

Mi PC → Propiedades (menú) → Avanzado (pestaña) → Variables de entorno (botón) → Variables del sistema (marco)

El timeoutcomando está disponible desde Windows Vista en adelante:

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: no funciona con la redirección de entrada; ejemplo trivial:

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

Usar el pingmétodo como se describe es cómo lo hago cuando no puedo (o no quiero) agregar más ejecutables o instalar cualquier otro software.

Debería hacer ping a algo que no está allí, y usar la -wbandera para que falle después de ese período de tiempo, no hacer ping a algo que está allí (como localhost) -nveces. Esto le permite manejar el tiempo en menos de un segundo, y creo que es un poco más preciso.

p.ej

(prueba de que 1.1.1.1 no se toma)

ECHO Waiting 15 seconds

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

SLEEP.exese incluye en la mayoría de los kits de recursos, por ejemplo, el Kit de recursos de Windows Server 2003 que también se puede instalar en Windows XP.

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

No estoy de acuerdo con las respuestas que encontré aquí.

Utilizo el siguiente método completamente basado en las capacidades de Windows XP para retrasar un archivo por lotes:

RETARDO 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

También puede insertar el día en el cálculo para que el método también funcione cuando el intervalo de retraso pase más de la medianoche.

Me enfrenté a un problema similar, pero acabo de abrir una aplicación de consola C ++ muy corta para hacer lo mismo. Simplemente ejecute MySleep.exe 1000 , tal vez más fácil que descargar / instalar todo el kit de recursos.

#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;
}

En Server Fault, se hizo una pregunta similar y la solución fue:

choice /d y /t 5 > nul

Puede usar la capa WSH de cscript de Windows y este archivo JavaScript wait.js :

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

Dependiendo de sus necesidades de compatibilidad, use ping:

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

por ejemplo, esperar 5 segundos, usar

ping -n 6 localhost >nul 2>&1

o en Windows 7 o uso posterior timeout:

timeout 6 >nul

Puedes usar ping:

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

Esperará 10 segundos.

La razón por la que tiene que usar 11 es porque el primer ping se apaga inmediatamente, no después de un segundo. El número siempre debe ser uno más que la cantidad de segundos que desea esperar.

Tenga en cuenta que el propósito de la -wno es esperar un segundo. Es para asegurarse de que no espere más de un segundo en caso de que haya problemas de red. pingpor sí solo enviará un paquete ICMP por segundo. Probablemente no sea necesario para el host local, pero los viejos hábitos son difíciles.

Hay una mejor manera de dormir usando ping. Querrá hacer ping a una dirección que no existe, por lo que puede especificar un tiempo de espera con precisión de milisegundos. Afortunadamente, dicha dirección se define en un estándar (RFC 3330), y lo es 192.0.2.x. Esto no está inventado, realmente es una dirección con el único propósito de no existir (puede que no esté claro, pero se aplica incluso en redes locales):

192.0.2.0/24: este bloque se asigna como "TEST-NET" para su uso en documentación y código de ejemplo. A menudo se usa junto con los nombres de dominio example.com o example.net en la documentación del proveedor y del protocolo. Las direcciones dentro de este bloque no deben aparecer en Internet pública.

Para dormir 123 milisegundos, use ping 192.0.2.1 -n 1 -w 123 >nul

Si tiene PowerShell en su sistema, puede ejecutar este comando:

powershell -command "Start-Sleep -s 1"

Editar: a partir de mi respuesta en un hilo similar , las personas plantearon un problema en el que la cantidad de tiempo que toma PowerShell para comenzar es significativa en comparación con el tiempo que está tratando de esperar. Si la precisión del tiempo de espera es importante (es decir, un segundo o dos retrasos adicionales no son aceptables), puede utilizar este enfoque:

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

Esto lleva el tiempo en que se emitió el comando de Windows, y el script de PowerShell duerme hasta 5 segundos después de ese tiempo. Por lo tanto, siempre que el PowerShell demore menos en iniciarse que la duración de su sueño, este enfoque funcionará (son alrededor de 600 ms en mi máquina).

timeout /t <seconds> <options>

Por ejemplo, para hacer que el script realice una espera ininterrumpible de 2 segundos:

timeout /t 2 /nobreak >NUL

Lo que significa que el script esperará 2 segundos antes de continuar.

Por defecto, una pulsación de tecla interrumpirá el tiempo de espera, por lo tanto, use el /nobreakinterruptor si no desea que el usuario pueda interrumpir (cancelar) la espera. Además, el tiempo de espera proporcionará notificaciones por segundo para notificar al usuario cuánto tiempo le queda esperar; esto se puede eliminar canalizando el comando a NUL.

editar: como señala @martineau en los comentarios , el timeoutcomando solo está disponible en Windows 7 y versiones posteriores. Además, el pingcomando usa menos tiempo de procesador que timeout. Sin embargo, todavía creo en usarlo timeoutsiempre que sea posible, ya que es más legible que el ping'hack'. Lee más aquí .

Simplemente coloque esto en su archivo por lotes donde desea esperar.

@ping 127.0.0.1 -n 11 -w 1000 > null

En el Bloc de notas, escriba:

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

Ahora guárdelo como wait.bat en la carpeta C: \ WINDOWS \ System32, luego, cuando quiera esperar, use:

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

El Kit de recursos siempre ha incluido esto. Al menos desde Windows 2000.

¡Además, el paquete Cygwin tiene un sleep- plop que en su RUTA e incluye cygwin.dll(o como se llame) y el camino a seguir!

Me gusta la respuesta de Aacini . Le agregué para manejar el día y también habilitarlo para manejar centisegundos ( %TIME%salidas 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

He estado usando este programa de sueño C #. Puede ser más conveniente para usted si C # es su idioma preferido:

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");
            }
        }
    }
}

Aún más liviano que la solución Python es un Perl one-liner.

Para dormir durante siete segundos ponga esto en el script BAT:

perl -e "sleep 7"

Esta solución solo proporciona una resolución de un segundo.

Si necesita una resolución más alta, use el módulo Time :: HiRes de CPAN. Proporciona usleep()qué duerme en microsegundos y nanosleep()qué duerme en nanosegundos (ambas funciones toman solo argumentos enteros). Ver la pregunta de desbordamiento de pila ¿ Cómo duermo un milisegundo en Perl? para mas detalles.

He usado ActivePerl por muchos años. Es muy fácil de instalar.

O línea de comando Python, por ejemplo, durante 6 segundos y medio:

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

El uso de ping es bueno, siempre y cuando solo quieras "esperar un poco". Esto ya que depende de otras funciones debajo, como el funcionamiento de su red y el hecho de que no hay nada que responda en 127.0.0.1. ;-) Tal vez no sea muy probable que falle, pero no es imposible ...

Si desea asegurarse de que está esperando exactamente el tiempo especificado, debe usar el sleep funcionalidad (que también tiene la ventaja de que no usa la potencia de la CPU o espera a que una red esté lista).

Encontrar un ejecutable ya hecho para dormir es la forma más conveniente. Simplemente colóquelo en su carpeta de Windows o en cualquier otra parte de su ruta estándar y siempre estará disponible.

De lo contrario, si tiene un entorno de compilación, puede hacer uno fácilmente. La Sleepfunción está disponible en kernel32.dll, por lo que solo necesita usar esa. :-) Para VB / VBA declare lo siguiente al comienzo de su fuente para declarar una función de suspensión:

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

Para C #:

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

Aquí encontrará más información sobre esta funcionalidad (disponible desde Windows 2000) en la función Suspender (MSDN).

En el estándar C, sleep()se incluye en la biblioteca estándar y en Visual Studio C de Microsoft se nombra la función Sleep(), si la memoria me sirve. ;-) Esos dos toman el argumento en segundos, no en milisegundos como las dos declaraciones anteriores.

La mejor solución que debería funcionar en todas las versiones de Windows después de Windows 2000 sería:

timeout numbersofseconds /nobreak > nul

El pathping.exe puede dormir menos de un segundo.

@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

Estoy impresionado con este:

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

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

Técnicamente, le estás diciendo al choicecomando que acepte solo y. Su valor predeterminado es y, hacerlo en 5 segundos, no dibujar ningún aviso y volcar todo lo que le dice a NUL (como un terminal nulo en Linux).

También puede usar un archivo .vbs para hacer tiempos de espera específicos:

El siguiente código crea el archivo .vbs. Pon esto cerca de la parte superior de tu código de lote:

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

El siguiente código abre el archivo .vbs y especifica cuánto tiempo esperar:

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

En el código anterior, el "1000" es el valor del retraso de tiempo que se enviará al archivo .vbs en milisegundos, por ejemplo, 1000 ms = 1 s. Puede modificar esta parte para que sea lo largo que desee.

El siguiente código elimina el archivo .vbs después de que haya terminado con él. Ponga esto al final de su archivo por lotes:

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

Y aquí está todo el código, así que es fácil de copiar:

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

Desde Windows Vista en adelante, tiene los comandos TIMEOUT y SLEEP , pero para usarlos en Windows XP o Windows Server 2003, necesitará el kit de herramientas de recursos de Windows Server 2003 .

Aquí tiene una buena visión general de las alternativas de suspensión (el enfoque de ping es el más popular, ya que funcionará en todas las máquinas con Windows), pero hay (al menos) una que no se menciona que (ab) usa el W32TMcomando (Servicio de tiempo):

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

Donde debe reemplazar la N con los segundos que desea pausar. Además, funcionará en todos los sistemas Windows sin requisitos previos.

Typeperf también se puede usar:

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

Con mshta y javascript (se puede usar para dormir menos de un segundo):

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

Esto debería ser aún más preciso (para esperar menos de un segundo): el ejecutable de compilación automática depende de .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);
}

Hay muchas formas de lograr un ' sueño ' en cmd / lote:

Mi favorito:

TIMEOUT /NOBREAK 5 >NUL 2>NUL

Esto detendrá la consola durante 5 segundos, sin ninguna salida.

Más usado:

ping localhost -n 5 >NUL 2>NUL

Esto intentará hacer una conexión localhost5 veces. Como está alojado en su computadora, siempre llegará al host, por lo que cada segundo probará lo nuevo cada segundo. La -nbandera indica cuántas veces el script intentará la conexión. En este caso es 5, por lo que durará 5 segundos.

Variantes de la última:

ping 1.1.1.1 -n 5 >nul

En este script hay algunas diferencias comparándolo con el último. Esto no intentará llamar localhost. En cambio, intentará conectarse a 1.1.1.1un sitio web muy rápido. La acción durará 5 segundos solo si tiene una conexión a Internet activa. De lo contrario, durará aproximadamente 15 para completar la acción . No recomiendo usar este método.

ping 127.0.0.1 -n 5 >nul

Esto es exactamente lo mismo que en el ejemplo 2 (el más utilizado). Además, también puedes usar:

ping [::1] -n 5 >nul

Esto, en cambio, usa la localhostversión de IPv6 .

Hay muchos métodos para realizar esta acción. Sin embargo, prefiero el método 1 para Windows Vista y versiones posteriores y el método más utilizado (método 2) para versiones anteriores del sistema operativo.

Puedes ponerte elegante poniendo el mensaje PAUSE en la barra de título:

@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

Esto se probó en Windows XP SP3 y Windows 7 y utiliza CScript. Me puse algunas medidas de seguridad para evitar la "" incitación. ( /qsería peligroso)

Espera un segundo:

sleepOrDelayExecution 1000

Espere 500 ms y luego ejecute cosas después de:

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

Como otros sugieren programas de terceros (Python, Perl, aplicaciones personalizadas, etc.), otra opción es GNU CoreUtils para Windows disponible en http://gnuwin32.sourceforge.net/packages/coreutils.htm .

2 opciones para la implementación:

1. Instale el paquete completo (que incluirá el conjunto completo de CoreUtils, dependencias, documentación, etc.).
2. Instale solo las dependencias binarias y necesarias de 'sleep.exe' (use depe.exe para obtener dependencias).

Una ventaja de implementar CoreUtils es que además obtendrá una gran cantidad de otros programas que son útiles para la creación de scripts (el lote de Windows deja mucho que desear).