Lors de l'écriture d'un fichier batch pour automatiser quelque chose sur une boîte Windows, j'ai dû suspendre son exécution pendant plusieurs secondes (généralement dans une boucle de test / attente, en attendant le démarrage d'un processus). À l'époque, la meilleure solution que j'ai pu trouver utilise le ping (je ne plaisante pas) pour obtenir l'effet souhaité. J'en ai trouvé une meilleure description ici , qui décrit un appelable "wait.bat", implémenté comme suit:

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

Vous pouvez ensuite inclure les appels à wait.bat dans votre propre fichier de commandes, en passant le nombre de secondes pour dormir.

Apparemment, le Kit de ressources Windows 2003 fournit une commande de veille de type Unix (enfin!). En attendant, pour ceux d'entre nous qui utilisent encore Windows XP, Windows 2000 ou (malheureusement) Windows NT , y a-t-il un meilleur moyen?

J'ai modifié le sleep.pyscript dans la réponse acceptée , afin qu'il prenne par défaut une seconde si aucun argument n'est passé sur la ligne de commande:

import time, sys

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

METTRE À JOUR

La timeoutcommande, disponible à partir de Windows Vista et au-delà, doit être la commande utilisée, comme décrit dans une autre réponse à cette question. Ce qui suit est une vieille réponse.

Ancienne réponse

Si Python est installé, ou si cela ne vous dérange pas de l'installer (il a aussi d'autres utilisations :), créez simplement le script sleep.py suivant et ajoutez-le quelque part dans votre PATH:

import time, sys

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

Cela permettra des pauses de moins d'une seconde (par exemple, 1,5 s, 0,1, etc.), si vous en avez besoin. Si vous souhaitez l'appeler comme sleepplutôt que sleep.py, vous pouvez ajouter l' .PYextension à votre variable d'environnement PATHEXT. Sous Windows XP, vous pouvez le modifier dans:

Poste de travail → Propriétés (menu) → Avancé (onglet) → Variables d'environnement (bouton) → Variables système (cadre)

La timeoutcommande est disponible à partir de Windows Vista:

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

Remarque: cela ne fonctionne pas avec la redirection d'entrée - exemple trivial:

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

Utiliser la pingméthode décrite est la façon dont je le fais lorsque je ne peux pas (ou ne veux pas) ajouter plus d'exécutables ou installer tout autre logiciel.

Vous devriez envoyer un ping à quelque chose qui n'est pas là, et utiliser l' -windicateur pour qu'il échoue après ce laps de temps, sans envoyer un ping à quelque chose qui est là (comme localhost) à l' -nheure. Cela vous permet de gérer le temps en moins d'une seconde, et je pense que c'est un peu plus précis.

par exemple

(tester que 1.1.1.1 n'est pas pris)

ECHO Waiting 15 seconds

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

SLEEP.exeest inclus dans la plupart des kits de ressources, par exemple le kit de ressources Windows Server 2003 qui peut également être installé sur Windows XP.

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

Je ne suis pas d'accord avec les réponses que j'ai trouvées ici.

J'utilise la méthode suivante entièrement basée sur les capacités de Windows XP pour retarder un fichier 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

Vous pouvez également insérer le jour dans le calcul afin que la méthode fonctionne également lorsque l'intervalle de retard dépasse minuit.

J'ai rencontré un problème similaire, mais je viens de créer une application console C ++ très courte pour faire la même chose. Exécutez simplement MySleep.exe 1000 - peut-être plus facile que de télécharger / installer tout le kit de ressources.

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

Chez Server Fault, une question similaire a été posée et la solution était:

choice /d y /t 5 > nul

Vous pouvez utiliser la couche WSH Windows cscript et ce fichier JavaScript wait.js :

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

En fonction de vos besoins de compatibilité, utilisez ping:

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

par exemple pour attendre 5 secondes, utilisez

ping -n 6 localhost >nul 2>&1

ou sur Windows 7 ou version ultérieure timeout:

timeout 6 >nul

Vous pouvez utiliser le ping:

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

Il attendra 10 secondes.

La raison pour laquelle vous devez utiliser 11 est que le premier ping s'éteint immédiatement, pas après une seconde. Le nombre doit toujours être un de plus que le nombre de secondes que vous souhaitez attendre.

Gardez à l'esprit que le but du -wn'est pas d'attendre une seconde. C'est pour vous assurer que vous n'attendez pas plus d'une seconde en cas de problèmes de réseau. pingenvoie seul un paquet ICMP par seconde. Ce n'est probablement pas nécessaire pour localhost, mais les vieilles habitudes sont mortes.

Il existe une meilleure façon de dormir en utilisant le ping. Vous souhaiterez envoyer un ping à une adresse qui n'existe pas, afin de pouvoir spécifier un délai d'expiration avec une précision de la milliseconde. Heureusement, une telle adresse est définie dans une norme (RFC 3330), et c'est le cas 192.0.2.x. Ce n'est pas inventé, c'est vraiment une adresse dans le seul but de ne pas exister (cela peut ne pas être clair, mais cela s'applique même dans les réseaux locaux):

192.0.2.0/24 - Ce bloc est affecté comme "TEST-NET" pour une utilisation dans la documentation et le code d'exemple. Il est souvent utilisé en conjonction avec les noms de domaine example.com ou example.net dans la documentation du fournisseur et du protocole. Les adresses de ce bloc ne doivent pas apparaître sur l'Internet public.

Pour dormir pendant 123 millisecondes, utilisez ping 192.0.2.1 -n 1 -w 123 >nul

Si vous avez PowerShell sur votre système, vous pouvez simplement exécuter cette commande:

powershell -command "Start-Sleep -s 1"

Edit: à partir de ma réponse sur un sujet similaire , les gens ont soulevé un problème où le temps que Powershell prend pour démarrer est significatif par rapport au temps que vous essayez d'attendre. Si la précision du temps d'attente est importante (c'est-à-dire qu'un délai supplémentaire ou deux secondes n'est pas acceptable), vous pouvez utiliser cette approche:

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

Cela prend le temps où la commande windows a été émise et le script PowerShell se met en veille jusqu'à 5 secondes après cette heure. Donc, tant que PowerShell prend moins de temps pour démarrer que votre durée de sommeil, cette approche fonctionnera (c'est environ 600 ms sur ma machine).

timeout /t <seconds> <options>

Par exemple, pour que le script effectue une attente non ininterrompue de 2 secondes:

timeout /t 2 /nobreak >NUL

Ce qui signifie que le script attendra 2 secondes avant de continuer.

Par défaut, une pression sur une touche interrompra le délai d'expiration, utilisez donc le /nobreakcommutateur si vous ne voulez pas que l'utilisateur puisse interrompre (annuler) l'attente. En outre, le délai d'expiration fournira des notifications par seconde pour informer l'utilisateur du temps restant à attendre; cela peut être supprimé en dirigeant la commande vers NUL.

edit: Comme le souligne @martineau dans les commentaires , la timeoutcommande n'est disponible que sur Windows 7 et supérieur. De plus, la pingcommande utilise moins de temps processeur que timeout. Je crois toujours qu'il faut utiliser timeoutlà où c'est possible, car il est plus lisible que le ping«hack». En savoir plus ici .

Mettez-le simplement dans votre fichier batch où vous voulez attendre.

@ping 127.0.0.1 -n 11 -w 1000 > null

Dans le Bloc-notes, écrivez:

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

Enregistrez maintenant sous wait.bat dans le dossier C: \ WINDOWS \ System32, puis chaque fois que vous voulez attendre, utilisez:

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

Le kit de ressources l' a toujours inclus. Au moins depuis Windows 2000.

De plus, le paquet Cygwin a un sleep- plop ça dans votre PATH et inclure le cygwin.dll(ou ce qu'il appelle) et le chemin à parcourir!

J'aime la réponse d'Aacini . Je l'ai ajouté pour gérer la journée et lui permettre également de gérer centisecondes ( %TIME%sorties 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

J'utilise ce programme de veille C #. Cela peut être plus pratique pour vous si C # est votre langage préféré:

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

Encore plus léger que la solution Python est un one-liner Perl.

Pour dormir pendant sept secondes, mettez ceci dans le script BAT:

perl -e "sleep 7"

Cette solution ne fournit qu'une résolution d'une seconde.

Si vous avez besoin d'une résolution plus élevée, utilisez le module Time :: HiRes du CPAN. Il fournit usleep()ce qui dort en microsecondes et nanosleep()qui dort en nanosecondes (les deux fonctions ne prennent que des arguments entiers). Voir la question Stack Overflow Comment dormir pendant une milliseconde en Perl? pour plus de détails.

J'utilise ActivePerl depuis de nombreuses années. Il est très facile à installer.

Ou en ligne de commande Python, par exemple, pendant 6 secondes et demie:

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

L'utilisation du ping est bonne, tant que vous voulez juste "attendre un peu". Ceci puisque vous dépendez d'autres fonctions en dessous, comme le fonctionnement de votre réseau et le fait que rien ne répond à 127.0.0.1. ;-) Il est peu probable que cela échoue, mais ce n'est pas impossible ...

Si vous voulez être sûr que vous attendez exactement l'heure spécifiée, vous devez utiliser le sleep fonctionnalité (qui présente également l'avantage de ne pas utiliser la puissance du processeur ou d'attendre qu'un réseau soit prêt).

Trouver un exécutable déjà créé pour sleep est le moyen le plus pratique. Déposez-le simplement dans votre dossier Windows ou dans toute autre partie de votre chemin standard et il est toujours disponible.

Sinon, si vous disposez d'un environnement de compilation, vous pouvez facilement en créer un vous-même. La Sleepfonction est disponible dans kernel32.dll, il vous suffit donc de l'utiliser. :-) Pour VB / VBA, déclarez ce qui suit au début de votre source pour déclarer une fonction de veille:

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

Pour C #:

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

Vous trouverez ici plus d'informations sur cette fonctionnalité (disponible depuis Windows 2000) dans la fonction Veille (MSDN).

En standard C, sleep()est inclus dans la bibliothèque standard et dans Visual Studio C de Microsoft, la fonction est nommée Sleep(), si ma mémoire est bonne. ;-) Ces deux prennent l'argument en secondes, pas en millisecondes comme les deux déclarations précédentes.

La meilleure solution qui devrait fonctionner sur toutes les versions de Windows après Windows 2000 serait:

timeout numbersofseconds /nobreak > nul

Le pathping.exe peut dormir moins d'une seconde.

@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

Je suis impressionné par celui-ci:

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

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

Techniquement, vous dites à la choicecommande d'accepter uniquement y. La valeur par défaut est y, pour le faire en 5 secondes, pour ne dessiner aucune invite et pour vider tout ce qu'il dit à NUL (comme un terminal nul sous Linux).

Vous pouvez également utiliser un fichier .vbs pour effectuer des délais spécifiques:

Le code ci-dessous crée le fichier .vbs. Mettez ceci près du haut de votre code rbatch:

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

Le code ci-dessous ouvre alors le .vbs et spécifie combien de temps attendre:

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

Dans le code ci-dessus, le "1000" est la valeur de la temporisation à envoyer au fichier .vbs en millisecondes, par exemple, 1000 ms = 1 s. Vous pouvez modifier cette partie pour qu'elle soit aussi longue que vous le souhaitez.

Le code ci-dessous supprime le fichier .vbs une fois que vous en avez terminé. Mettez ceci à la fin de votre fichier batch:

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

Et voici le code dans son ensemble, il est donc facile à copier:

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

À partir de Windows Vista, vous disposez des commandes TIMEOUT et SLEEP , mais pour les utiliser sous Windows XP ou Windows Server 2003, vous aurez besoin du kit d'outils de ressources Windows Server 2003 .

Ici, vous avez un bon aperçu des alternatives de sommeil (l'approche ping est la plus populaire car elle fonctionnera sur toutes les machines Windows), mais il y en a (au moins) une non mentionnée qui (ab) utilise la commande W32TM(Time Service):

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

Où vous devez remplacer le N par les secondes que vous souhaitez mettre en pause. En outre, il fonctionnera sur tous les systèmes Windows sans prérequis.

Typeperf peut également être utilisé:

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

Avec mshta et javascript (peut être utilisé pour dormir moins d'une seconde):

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

Cela devrait être encore plus précis (pour attendre moins d'une seconde) - exécutable auto-compilable reposant sur .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);
}

Il existe de nombreuses façons d'accomplir un `` sommeil '' dans cmd / batch:

Mon préféré:

TIMEOUT /NOBREAK 5 >NUL 2>NUL

Cela arrêtera la console pendant 5 secondes, sans aucune sortie.

Plus utilisé:

ping localhost -n 5 >NUL 2>NUL

Cela essaiera d'établir une connexion à localhost5 fois. Puisqu'il est hébergé sur votre ordinateur, il atteindra toujours l'hôte, donc chaque seconde il essaiera le nouveau chaque seconde. L' -nindicateur indique combien de fois le script essaiera la connexion. Dans ce cas est 5, donc cela durera 5 secondes.

Variantes de la dernière:

ping 1.1.1.1 -n 5 >nul

Dans ce script, il y a quelques différences en le comparant avec le dernier. Cela n'essaiera pas d'appeler localhost. Au lieu de cela, il essaiera de se connecter à 1.1.1.1un site Web très rapide. L'action ne durera 5 secondes que si vous disposez d'une connexion Internet active. Sinon, cela durera environ 15 pour terminer l'action . Je ne recommande pas d'utiliser cette méthode.

ping 127.0.0.1 -n 5 >nul

C'est exactement la même chose que l'exemple 2 (le plus utilisé). En outre, vous pouvez également utiliser:

ping [::1] -n 5 >nul

Cela utilise à la place la localhostversion d'IPv6 .

Il existe de nombreuses méthodes pour effectuer cette action. Cependant, je préfère la méthode 1 pour Windows Vista et les versions ultérieures et la méthode la plus utilisée (méthode 2) pour les versions antérieures du système d'exploitation.

Vous pouvez avoir de la fantaisie en mettant le message PAUSE dans la barre de titre:

@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

Cela a été testé sur Windows XP SP3 et Windows 7 et utilise CScript. J'ai mis des gardes sûrs pour éviter les incitations "" del "". ( /qserait dangereux)

Attends une seconde:

sleepOrDelayExecution 1000

Attendez 500 ms, puis exécutez les choses après:

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

Puisque d'autres suggèrent des programmes tiers (Python, Perl, application personnalisée, etc.), une autre option est GNU CoreUtils pour Windows disponible à http://gnuwin32.sourceforge.net/packages/coreutils.htm .

2 options de déploiement:

1. Installez le package complet (qui comprendra la suite complète de CoreUtils, les dépendances, la documentation, etc.).
2. Installez uniquement le binaire 'sleep.exe' et les dépendances nécessaires (utilisez depend.exe pour obtenir les dépendances).

L'un des avantages du déploiement de CoreUtils est que vous obtiendrez en outre une foule d'autres programmes utiles pour la création de scripts (le lot Windows laisse beaucoup à désirer).