Dormir dans un fichier de commandes

La timeout de commande est disponible à partir de Windows Vista à partir de:

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: Il 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.

Je suis en désaccord avec les réponses que j'ai trouvé ici.

J'utilise la méthode suivante entièrement basé sur Windows XP capacités de faire un retard dans un fichier de commandes:

RETARD.Chauve-souris:

@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 la journée dans le calcul de sorte que la méthode fonctionne également lorsque l'intervalle de temps de passer au-dessus de minuit.

J'ai fait face à un problème similaire, mais je viens juste d'en haut une très courte application console C++ pour faire la même chose. Il suffit d'exécuter MySleep.exe 1000 - peut-être plus facile que le téléchargement/installation de l'ensemble du 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;
}

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

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

Vous pouvez utiliser la commande ping:

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

Il faudra attendre 10 secondes.

La raison pour laquelle vous devez utiliser 11 est parce que le premier ping sort immédiatement, pas au bout d'une seconde. Le nombre doit toujours être un de plus que le nombre de secondes que vous voulez attendre.

Garder à l'esprit que le but de la -w est de ne pas attendre une seconde. C'est pour s'assurer que vous n'attendez plus qu'une seconde dans le cas où il y a des problèmes de réseau. ping sur ses propres va envoyer un paquet ICMP par seconde. Ce n'est probablement pas nécessaire pour localhost, mais les vieilles habitudes ont la vie dure.

timeout /t <seconds> <options>

Par exemple, pour rendre le script effectuer une non sans coupure de 2 secondes d'attente:

timeout /t 2 /nobreak >NUL

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

Par défaut, d'une touche permet d'interrompre le délai d'attente, donc utiliser le /nobreak commutateur si vous ne voulez pas que l'utilisateur soit en mesure d'interrompre (annuler) l'attente. En outre, le délai d'attente fournira par la deuxième notification pour notifier à l'utilisateur combien de temps est laissé à attendre; ce peut être retiré par la tuyauterie de la commande à NUL.

edit: Comme @martineau points dans les commentaires, le timeout commande n'est disponible que sur Windows 7 et au-dessus. En outre, la ping commande utilise de moins en moins de temps processeur que timeout. Je crois encore à l'aide de timeout si possible, même si, comme il est plus lisible que le ping "hack". Lire plus ici.

Dans le bloc-notes, écrire:

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

Enregistrer maintenant que d'attendre.bat dans le dossier C:\WINDOWS\System32,
alors à chaque fois que vous voulez attendre, utilisation:

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

La Kit De Ressources a toujours inclus cette. Au moins depuis Windows 2000.

Aussi, l'environnement Cygwin est un sleep - plop-la dans votre CHEMIN et comprennent la cygwin.dll (ou quelque chose comme ça) et de chemin à faire!

J'ai été en utilisant cette C# programme de sommeil. Il peut être plus pratique pour vous si C# est la langue de votre choix:

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

L'utilisation de ping est bon, aussi longtemps que vous voulez juste "attendre un peu". Puisque vous êtes dépendant des autres fonctions de l'en-dessous, à l'instar de votre réseau de travail et le fait qu'il n'y a rien à répondre sur 127.0.0.1. 😉 Peut-être qu'il n'est pas très probable, il échoue, mais il n'est pas impossible...

Si vous voulez être sûr que vous attendez exactement le temps imparti, vous devez utiliser le sleep fonctionnalité (qui ont aussi l'avantage de ne pas utiliser la puissance du CPU ou attendre un réseau de prêt).

De trouver une déjà faite exécutable pour le sommeil est le moyen le plus pratique. Il suffit de déposer dans votre dossier Windows ou toute autre partie de votre chemin d'accès standard et il est toujours disponible.

Sinon, si vous avez une compilation de l'environnement, vous pouvez facilement faire vous-même.
Le Sleep fonction est disponible dans kernel32.dll, donc vous avez juste besoin d'utiliser celle-ci. 🙂
Pour VB /VBA déclare ce qui suit au début de votre source de 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 à propos de cette fonctionnalité (disponible depuis Windows 2000) dans Fonction de veille (MSDN).

Dans la norme C, sleep() est inclus dans la bibliothèque standard et dans Microsoft Visual Studio C la fonction est nommée Sleep(), si la mémoire me sert. 😉 Ces deux prend l'argument en quelques secondes, pas en millisecondes comme les deux précédentes déclarations.

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

timeout numbersofseconds /nobreak > nul

Je suis impressionné par celui-ci:

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

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

Techniquement, vous racontez l' choice de commande pour accepter uniquement les y de. La valeur par défaut y, à le faire dans les 5 secondes, de ne pas tracer de commandes, et de vider tout ce qu'il ne dis NUL (comme nulle terminal sous Linux).

Vous pouvez également utiliser un .fichier vbs pour faire des timeouts:

Le code ci-dessous crée la .fichier vbs. Mettre cette près du haut de vous rbatch code:

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

Le code ci-dessous s'ouvre alors la .vbs et spécifie combien de temps à attendre:

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

Dans le code ci-dessus, le "1000" est la valeur du temps de retard pour être envoyé à l' .fichier vbs en millisecondes, par exemple, 1000 ms = 1 s. Vous pouvez modifier la présente partie, aussi longtemps que vous le souhaitez.

Le code ci-dessous supprime le .fichier vbs, après vous avez terminé avec elle. Mettre ceci à la fin de votre fichier de commandes:

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

Et voici le code qui, tous ensemble, de sorte qu'il est facile de copier:

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

Cela a été testé sur Windows XP SP3 et Windows 7 et utilise CScript. Je l'ai mis dans certains gardes de sécurité pour éviter la del "" l'impulsion. (/q serait dangereux)

Attendez une seconde:

sleepOrDelayExecution 1000

Attendre de 500 ms et exécutez ensuite trucs après:

sleepOrDelayExecution 500 dir \ /s

sleepOrDelayExecution.chauve-souris:

@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

ping -n X 127.0.0.1 > nul

Remplacer X par le nombre de secondes + 1.

Par exemple, si vous attendez 10 secondes, remplacer X par 11. Attendre 5 secondes, utilisation 6.

Lire les réponses précédentes pour millisecondes.