Windows cmd wait command

1. Use /WAIT to Wait for the Command to Finish Execution in Batch Script

2. Use the TIMEOUT Command to Delay the Execution in Batch Script

3. Use the PAUSE Command to Pause the Execution in Batch Script

4. Use the CALL Command to Wait for the Command to Finish Execution in Batch Script

5. Use the && Operator to Wait for Command to Finish Execution in Batch Script

6. Use a Loop to Wait for Command to Finish Execution in Batch Script

7. Conclusion

Картинка с сайта: www.delftstack.com

Batch scripting in Windows allows users to automate tasks by writing a series of commands that the system can execute. Often, it’s crucial to ensure that a command finishes its execution before moving on to the next one.

There are multiple commands and installation processes in a Batch file that usually take some time to complete. But when a Batch file is run, it does not wait for a command process to finish; it executes all commands line by line.

It is important to make those commands wait for them to finish and then execute the next commands. For a process to wait until it is finished, we use the /wait parameter with the START command.

Instead of starting a command, if there is a need to insert delays in the Batch file for some time interval, we can use commands such as TIMEOUT and PAUSE to stop the execution of the next process for a short interval of time or until a key is pressed.

This tutorial illustrates different ways to wait for a command or a program to finish before executing the next command in the Windows Batch file.

Use /WAIT to Wait for the Command to Finish Execution in Batch Script

The /WAIT parameter is used with the START command in a Batch file. It instructs the command prompt to wait for the command or application to complete its execution before moving on to the next line in the Batch script.

This parameter is particularly useful when you need to launch an application or script and ensure it finishes before proceeding.

The syntax of the START command with the /WAIT parameter is as follows:

START "title" [/D path] [/I] [/MIN] [/MAX] [/SEPARATE | /SHARED]
      [/LOW | /NORMAL | /HIGH | /REALTIME | /ABOVENORMAL | /BELOWNORMAL]
      [/AFFINITY <hex affinity>] [/WAIT] [/B] [command/program]
      [parameters]

• /WAIT: This is the parameter we’re focusing on in this guide. It causes the START command to wait for the executed command or program to finish before proceeding with the Batch script.

When we start a program in a Batch file using the START command, we can wait until the program is finished by adding /wait to the START command. Even if there are multiple commands, /wait can be used for each process to finish and move to the next one.

Also, the parameter /B is used to stay in the same process without creating a new window. The START command without the /B parameter opens the program or command in a new window.

Wait for a Command to Finish Execution

For example, we need to wait for a command to finish execution before running the next one.

@echo off
echo starting first program.
START /B /WAIT cmd /c "C:\Users\Aastha Gas Harda\Desktop\testfile1.bat" > output.txt
echo The first program is executed successfully.
START /B systeminfo >> stdout.txt
echo All the programs are executed successfully
cmd /k

Картинка с сайта: www.delftstack.com

This Batch script executes two programs sequentially. It starts by running testfile1.bat and waits for it to finish before echoing a success message.

Then, it gathers system information using systeminfo and appends the output to output.txt. Finally, it opens a new command prompt window for further interaction.

Output:

Картинка с сайта: www.delftstack.com

Wait for the .exe File to Finish Execution

Another example is where we need to run a .exe file and wait until the execution is done completely.

@echo off
echo starting first program.
START /B /WAIT JRuler.exe
echo The first program is executed successfully.
START /B systeminfo >> output.txt
echo All the programs are executed successfully
cmd /k

Картинка с сайта: www.delftstack.com

This Batch script first runs an application called JRuler.exe and waits for it to finish. It then echoes a success message.

Next, it gathers system information using the systeminfo command and appends the output to a file called output.txt. Finally, it opens a new command prompt window for further interaction.

Output:

Картинка с сайта: www.delftstack.com

As soon as you close the .exe file, the second program will begin execution. cmd /k in the last line is used to prevent the command prompt from exiting after execution.

If there are multiple programs, you can use /WAIT with each command to wait until the execution is finished. The START command with the /WAIT parameter doesn’t have any timeout, i.e., it does not matter how long the process will take to finish; it will wait until the process is completed.

@echo off
START /WAIT install1.exe
START /WAIT install2.exe

/WAIT can only be used with the START command. We can insert a time delay for other commands by using the TIMEOUT and PAUSE commands.

Use the TIMEOUT Command to Delay the Execution in Batch Script

The TIMEOUT command is used in Batch scripts to introduce a delay in the execution. It allows you to pause the script for a specified amount of time, measured in seconds.

This is particularly useful when you need to ensure that a process or task is completed before moving on to the next step.

The range for the TIMEOUT command varies between -1 and 100000. If the delay is set to -1, it will act as a pause command to wait until a key is pressed.

As in the previous method, we can replace the /wait by inserting the TIMEOUT command with the /t parameter. The syntax for the TIMEOUT command is given below:

TIMEOUT [/T timeout] [/NOBREAK]

• /T timeout: This option specifies the delay time in seconds. If omitted, the default delay is 10 seconds.
• /NOBREAK: This option allows users to interrupt the countdown by pressing any key. If omitted, the countdown cannot be interrupted.

Let’s take the example in the previous method and add a time delay of 30 seconds after the execution of the first program.

@echo off
echo starting first program.
START /B JRuler.exe
TIMEOUT /t 30
echo The first program is executed successfully.
START /B systeminfo >> output.txt
echo All the programs are executed successfully
cmd /k

Картинка с сайта: www.delftstack.com

This Batch script automates the execution of two programs. It starts with JRuler.exe and waits for 30 seconds.

Afterward, it echoes a success message. Then, it runs the systeminfo command and appends the output to output.txt.

Finally, it opens a new command prompt window for further interaction.

Output:

Картинка с сайта: www.delftstack.com

After 30 seconds, the second program will begin execution. Also, if a user presses a key before the timeout, the second program will begin execution.

Картинка с сайта: www.delftstack.com

To prevent user keystrokes, use the /nobreak parameter with the TIMEOUT command. This will ignore any key presses by the user.

However, you can stop the delay by pressing the Ctrl+C, which will raise the errorlevel1.

Use the PAUSE Command to Pause the Execution in Batch Script

The PAUSE command in Batch scripting serves as a mechanism to temporarily halt the execution of a script. It displays the message "Press any key to continue..." and waits for user input.

This is especially useful when you want to give users an opportunity to review information or confirm an action before proceeding with the script.

The PAUSE command is simple and does not require any additional parameters or options. It is used as follows:

When the PAUSE command is encountered in a Batch script, it prompts the user to press any key. Once a key is pressed, the script continues its execution.

The PAUSE command is used to pause the execution of a Batch file until a key is pressed. It is useful if the user wants to read the output text or wait until a process is finished.

However, there is no timeout, and it will only continue until the user presses a key.

@echo off
echo starting first program.
START /B cmd /c "C:\Users\Aastha Gas Harda\Desktop\testfile1.bat" > output.txt
echo The first program is executed successfully.
PAUSE
START /B systeminfo >> output.txt
echo All the programs are executed successfully
cmd /k

Картинка с сайта: www.delftstack.com

This Batch script automates the execution of two programs. It starts with testfile1.bat, captures its output to output.txt, and confirms successful execution.

The script then prompts the user to press a key to continue. Next, it runs the systeminfo command and appends its output to output.txt.

Finally, it opens a new command prompt window for further interaction.

Output:

Картинка с сайта: www.delftstack.com

All the methods mentioned above work fine. If you use the START command, it is recommended to use /wait instead of delay commands as the process may take longer than specified.

Use the CALL Command to Wait for the Command to Finish Execution in Batch Script

The CALL command in Batch scripting is used to run another Batch file within the current script.

It essentially creates a temporary subroutine, allowing the original script to wait for the called script’s completion before proceeding. This makes it an effective method for synchronizing the execution of commands.

The syntax of the CALL command is as follows:

CALL :label arguments
CALL [drive:][path]filename [arguments]

• :label arguments: This form is used to call a subroutine within the same Batch file, identified by a label.
• [drive:][path]filename [arguments]: This form is used to call an external Batch file by specifying its full path along with any required arguments.

Let’s explore practical examples to demonstrate the use of the CALL command.

Calling a Subroutine within the Same Batch File

@echo off
echo Starting Process I
CALL :ProcessI
echo Process I completed.
pause
exit

:ProcessI
echo Performing Process I...
:: Add your commands for Process I here
:: For example, "ping -n 5 127.0.0.1" simulates a delay
ping -n 5 127.0.0.1
exit /b

• In this script, we have a main section and a subroutine (:ProcessI).
• The CALL :ProcessI command invokes the subroutine. The execution of the main Batch file will pause until :ProcessI completes.
• The exit /b command at the end of :ProcessI is used to return to the main Batch file after completion.

Output:

Картинка с сайта: www.delftstack.com

Calling an External Batch File

This script uses CALL to execute an external Batch file named testfile2.bat located on the desktop.

@echo off
echo Starting Process J
CALL "C:\Users\Username\Desktop\testfile2.bat"
echo Process J completed.
pause
exit

This script automates the execution of an external Batch file, captures its output, and provides feedback along the way. The user is prompted to press a key to continue after the program finishes.

Output:

Картинка с сайта: www.delftstack.com

Use the && Operator to Wait for Command to Finish Execution in Batch Script

The && operator in Batch scripting allows you to execute commands sequentially, where the second command only runs if the first one succeeds. This creates a dependency between the commands, ensuring that they execute in a specific order.

The syntax of the && operator is as follows:

• command1: This is the first command that is executed.
• command2: This is the second command that is only executed if command1 succeeds (returns a zero exit code).

Let’s explore practical examples to demonstrate the use of the && operator.

Example 1: Running Commands Sequentially

@echo off
echo Starting Process K
echo Performing Process K... && ping -n 5 127.0.0.1
echo Process K completed successfully.
pause
exit

• In this script, the echo Performing Process K... command is followed by &&, which means the next command (ping) will only execute if the first command is successful.
• The ping command simulates a delay by waiting for 5 seconds (-n 5) on the local machine (127.0.0.1).
• The script then echoes a message indicating successful completion.

Output:

Картинка с сайта: www.delftstack.com

Example 2: Using Conditional Execution with Batch Files

@echo off
echo Starting Process L
call :ProcessL && (
    echo Process L completed successfully.
) || (
    echo Process L encountered an error.
)
pause
exit

:ProcessL
echo Performing Process L...
:: Add your commands for Process L here
:: For example, "dir" lists files in the current directory
dir
exit /b

• In this script, the call :ProcessL command is followed by &&.
• The subsequent block of code within the ( and ) is executed only if the call :ProcessL succeeds (returns a zero exit code).
• If the call :ProcessL returns a non-zero exit code, the code after || is executed instead.
• This demonstrates how to conditionally execute different blocks of code based on the success of a preceding command.

Output:

Картинка с сайта: www.delftstack.com

Use a Loop to Wait for Command to Finish Execution in Batch Script

In Batch scripting, a loop is a control structure that allows a set of commands to be executed repeatedly. By utilizing a loop, you can continuously check the status of a process until it completes.

This approach is particularly useful for scenarios where you need to wait for a specific task to finish before proceeding.

Let’s delve into a practical example to demonstrate how to use a loop to wait for a command to complete.

@echo off
echo Starting Process K
echo Performing Process K...

:CheckProcess
tasklist | find /i "process_name.exe" >nul
if %errorlevel% neq 0 (
    timeout /t 2 >nul
    goto :CheckProcess
)

echo Process K completed successfully.
pause
exit

The Batch script begins with turning off command echoing using @echo off. It echoes a message indicating the start of a process (Process K).

Then, the :CheckProcess label marks the start of a loop. This is where the script checks the status of the target process.

tasklist | find /i "process_name.exe" >nul retrieves a list of running processes and searches for a process with the specified name (replace process_name.exe with the actual process name). The >nul part suppresses the output.

Next, the if %errorlevel% neq 0 checks the return code of the previous command. If it’s not equal to 0 (indicating that the process is still running), the loop continues.

timeout /t 2 >nul introduces a 2 second delay using the timeout command. The goto :CheckProcess redirects the script back to the :CheckProcess label, effectively creating a loop.

Once the process is no longer found, the script proceeds. Finally, it echoes a message confirming the successful completion of Process K and waits for user confirmation before exiting.

Output:

Картинка с сайта: www.delftstack.com

Conclusion

This tutorial explores various methods to wait for a command to finish execution in Windows Batch scripting.

1. Using /WAIT with START: This method ensures the script waits for a command or application to complete using the /WAIT parameter with the START command. It’s ideal for launching applications that need to finish their tasks.
2. Introducing Delays with TIMEOUT: The TIMEOUT command allows for a specified delay in script execution. This is helpful when you want to provide a process with enough time to complete.
3. Temporary Halt with PAUSE: The PAUSE command temporarily stops script execution and prompts the user to press a key before continuing. This is useful for user interaction and confirmation.
4. Using CALL for Script Synchronization: The CALL command enables the execution of another Batch file within the current script, creating a temporary subroutine. This allows the original script to wait for the called script’s completion.
5. Conditional Execution with &&: The && operator ensures that the second command only runs if the first one succeeds, establishing a dependency between commands. This is useful for sequential execution.
6. Implementing Loops for Continuous Checking: A loop is a control structure that repeatedly checks the status of a process until it completes. This is valuable for scenarios where you need to wait for a specific task to finish.

By understanding these methods, you have gained a comprehensive toolkit for handling command execution and synchronization in Windows Batch scripting. These techniques are invaluable for automating various tasks efficiently.

The `wait` command in CMD is often used in batch scripts to pause the execution of the script for a specified amount of time.

Here’s an example of a simple batch script that uses `timeout` to create a wait time:

@echo off
echo Waiting for 5 seconds...
timeout /t 5
echo Done waiting!

What is the `wait` Command?

The `wait` command in CMD is a powerful utility that allows users to introduce a delay in the execution of commands or scripts. This command is essential for scenarios where timing is crucial, such as when waiting for a process to finish or allowing time for an operation to stabilize.

Картинка с сайта: cmdmastery.com

Mastering Git-Cmd: Your Quick Start Guide

How to Use the `wait` Command

Syntax Overview

The basic syntax of the `wait` command is:

wait [duration]

• `duration` specifies the time to wait before the command continues. It can be expressed in seconds or milliseconds, depending on your needs.

Basic Example of the `wait` Command

Here’s a simple example that showcases the `wait` command in action:

echo Starting Process...
wait 5
echo Process Resumed!

In this example, the first line prints “Starting Process…”. The command then pauses execution for 5 seconds due to the `wait` command, after which it resumes and prints “Process Resumed!”. This illustrates how you can create pauses in between commands for better readability and timing in your scripts.

Картинка с сайта: cmdmastery.com

Master Win Cmd: Your Quick Start Guide to Commands

Practical Applications of the `wait` Command

Delaying Batch File Execution

The `wait` command is particularly useful when creating batch files where order of operations and timing matter. For example, you might need to pause between steps in a process. Consider this batch file:

@echo off
echo Step 1: Initializing...
wait 10
echo Step 2: Processing...
wait 5
echo Step 3: Complete.

In this script:

• Step 1 initializes a process, followed by a 10-second wait.
• Step 2 proceeds after the wait, indicating to the user that something is occurring.
• After another 5-second wait, Step 3 confirms completion.

Each step adds clarity to what the script is doing in real-time.

Working with Scripts that Require Time Gaps

There are scenarios where scripts must wait for certain services or applications to be ready. For instance, if you are starting a service, ensuring it is fully operational before proceeding can prevent errors:

@echo off
net start "ServiceName"
wait 30
if errorlevel 1 (
    echo Failed to start the service.
) else (
    echo Service started successfully.
)

In this example:

• The script attempts to start a service named «ServiceName».
• It then uses the `wait` command to pause for 30 seconds, allowing the service time to initialize.
• After the wait, it checks if the service started successfully, providing feedback based on the result.

Картинка с сайта: cmdmastery.com

Mastering Wget Cmd: A Quick Guide to Downloads

Common Mistakes When Using `wait`

Forgetting to Specify Duration

One of the most common mistakes users make is omitting the duration. Failing to specify how long to wait can lead to circumstances where the script runs without any effective pauses, often resulting in processes overlapping or commands being executed out of order.

Misunderstanding Time Formats

Another common misunderstanding arises from time formats. Users might assume that the command accepts multiple time formats. However, if you enter an unsupported time format, CMD will raise an error. Always check your entry to ensure it matches the expected duration format to avoid execution issues.

Картинка с сайта: cmdmastery.com

Mastering Bat Cmd: Quick Tips for Command Line Success

Alternative Commands to `wait` in CMD

Using `timeout`

The `timeout` command is a popular alternative to `wait`. It has a similar purpose, with a slightly different interface. The syntax is as follows:

timeout [duration]

For example, using `timeout`:

echo Pausing for 10 seconds...
timeout 10
echo Resuming now.

This command pauses execution for 10 seconds and then resumes, providing a similar delay effect as `wait`.

Combining Commands for More Control

You can also manage the execution of external programs using the `start /wait` command. This combination allows you to launch an application and wait for it to complete before moving forward.

Here is an example:

start /wait myprogram.exe
echo Program has completed execution.

In this command, `myprogram.exe` is started, and the script automatically halts until this program finishes running. This approach is valuable when automating workflows that require the completion of specific applications before proceeding to the next step.

Картинка с сайта: cmdmastery.com

What Cmd: A Quick Guide to Cmd Commands

Summary of Key Points

The `wait` command is a critical tool for creating effective and organized CMD scripts. It introduces necessary pauses, enhances script clarity, and ensures that operations have time to complete, especially during automation.

Картинка с сайта: cmdmastery.com

Start Cmd: Your Quick Guide to Command Basics

Conclusion: Elevate Your CMD Skills

Practicing the `wait` command will significantly improve your CMD scripting skills and overall productivity. Mastering this command, along with understanding its alternatives, will equip you to handle time-sensitive operations efficiently. Continue exploring tutorials and resources to further enhance your CMD capabilities.

Картинка с сайта: cmdmastery.com

Mastering Netstat Cmd: Quick Tips for Network Analysis

Additional Resources

Documentation and References

For comprehensive details on the `wait` command and other CMD functionality, refer to the official Microsoft CMD documentation. Engaging with online forums and communities can also provide practical insights and tips from experienced users.

`wait` Command Related Articles

Consider reading additional articles on advanced CMD techniques for an even deeper understanding of CMD commands and scripting strategies, enabling you to harness the full potential of your CMD skills.

Is this article up to date?

1. @ECHO OFF

2. :: Check Windows version

3. IF NOT "%OS%"=="Windows_NT" GOTO Syntax

5. :: Check if a valid timeout period is specified

6. IF     "%~1"=="" GOTO Syntax

7. IF NOT "%~2"=="" GOTO Syntax

8. ECHO.%*| FINDSTR /R /X /C:"[0-9][0-9]*" >NUL || GOTO Syntax

9. IF %~1 LSS    1 GOTO Syntax

10. IF %~1 GTR 3600 GOTO Syntax

12. :: Use local variable

13. SETLOCAL

15. :: Add 1 second for IPv4

16. SET /A seconds = %1 + 1

18. :: The actual command: try IPv4 first, if that fails try IPv6

19. PING -n %seconds% 127.0.0.1 >NUL 2>&1 || PING -n %1 ::1 >NUL 2>&1

21. :: Done

22. ENDLOCAL

23. GOTO:EOF

26. :Syntax

27. ECHO.

28. ECHO PMSleep.bat

29. ECHO Poor Man's SLEEP utility,  Version 3.00 for Windows NT 4 and later.

30. ECHO Wait for a specified number of seconds.

31. ECHO.

32. ECHO Usage:  CALL  PMSLEEP  seconds

33. ECHO.

34. ECHO Where:        seconds  is the number of seconds to wait (1..3600)

35. ECHO.

36. ECHO Notes:  The script uses PING for the delay, so an IP stack is required.

37. ECHO         The delay time will not be very accurate.

38. ECHO.

39. ECHO Written by Rob van der Woude

40. ECHO http://www.robvanderwoude.com

42. IF "%OS%"=="Windows_NT" EXIT /B 1

1. @ECHO OFF

2. :: Check if a timeout period is specified

3. IF "%1"=="" GOTO Syntax

5. :: Filter out slashes, they make the IF command crash

6. ECHO.%1 | FIND "/" >NUL

7. IF NOT ERRORLEVEL 1 GOTO Syntax

9. :: Check for a non-existent IP address

10. :: Note: this causes a small extra delay!

11. IF "%NonExist%"=="" SET NonExist=10.255.255.254

12. PING %NonExist% -n 1 -w 100 | FIND "TTL=" >NUL

13. IF ERRORLEVEL 1 GOTO Delay

14. SET NonExist=1.1.1.1

15. PING %NonExist% -n 1 -w 100 | FIND "TTL=" >NUL

16. IF NOT ERRORLEVEL 1 GOTO NoNonExist

18. :Delay

19. :: Use PING time-outs to create the delay

20. PING %NonExist% -n 1 -w %1000 >NUL

22. :: Show online help on errors

23. IF ERRORLEVEL 1 GOTO Syntax

25. :: Done

26. GOTO End

28. :NoNonExist

29. ECHO.

30. ECHO This batch file needs an invalid IP address to function

31. ECHO correctly.

32. ECHO Please specify an invalid IP address in an environment

33. ECHO variable named NonExist and run this batch file again.

35. :Syntax

36. ECHO.

37. ECHO PMSlpW9x.bat

38. ECHO Poor Man's SLEEP utility,  Version 2.10 for Windows 95 / 98

39. ECHO Wait for a specified number of seconds.

40. ECHO.

41. ECHO Written by Rob van der Woude

42. ECHO http://www.robvanderwoude.com

43. ECHO Corrected and improved by Todd Renzema and Greg Hassler

44. ECHO.

45. ECHO Usage:    CALL PMSLPW9X nn

46. ECHO.

47. ECHO Where:    nn is the number of seconds to wait

48. ECHO.

49. ECHO Example:  CALL PMSLPW9X 10

50. ECHO           will wait for 10 seconds

51. ECHO.

52. ECHO Note:     Due to "overhead" the actual delay may

53. ECHO           prove to be up to a second longer

55. :End

1. @ECHO OFF

2. IF "%1"=="" GOTO Syntax

3. ECHO.

4. ECHO Waiting %1 seconds

5. ECHO.

6. REM | CHOICE /C:AB /T:A,%1 > NUL

7. IF ERRORLEVEL 255 ECHO Invalid parameter

8. IF ERRORLEVEL 255 GOTO Syntax

9. GOTO End

11. :Syntax

12. ECHO.

13. ECHO WAIT for a specified number of seconds

14. ECHO.

15. ECHO Usage:  WAIT  n

16. ECHO.

17. ECHO Where:  n  =  the number of seconds to wait (1 to 99)

18. ECHO.

20. :End

1. @ECHO OFF

2. IF NOT "%OS%"=="Windows_NT" GOTO Syntax

3. IF "%~1"=="" GOTO Syntax

4. ECHO.

5. ECHO Waiting %~1 seconds

6. ECHO.

7. CHOICE /C:AB /D:A /T:%1 > NUL

8. IF ERRORLEVEL 255 (

9. 	ECHO Invalid parameter

10. 	GOTO Syntax

11. )

12. GOTO:EOF

14. :Syntax

15. ECHO.

16. ECHO WAIT for a specified number of seconds

17. ECHO.

18. ECHO Usage:  WAIT  n

19. ECHO.

20. ECHO Where:  n  =  the number of seconds to wait (1 to 99)

21. ECHO.

22. EXIT /B 1

1. @ECHO OFF

2. SET Message=It is time for your daily backup.\nPlease save and close all documents,\nor press any key to skip the backup.

3. START /B SystemTrayMessage.exe "%Message%" /T:"Backup Time" /V:20 /S:186 /W

4. ECHO Press any key to skip the backup . . .

5. SET /P "=Seconds to start of backup: " < NUL

6. CountDown.exe 20

7. IF ERRORLEVEL 2 (

8. 	ECHO.

9. 	ECHO Backup has been skipped . . .

10. 	EXIT /B 1

11. )

12. SystemTrayMessage.exe "Your daily backup has been started" /T:"Backup Running" /V:20 /S:186

13. REM Insert your backup command here

1. Start-Sleep -Seconds 10 # wait 10 seconds

2. Start-Sleep 10 # wait 10 seconds

3. Start-Sleep -Seconds 2.7 # wait 3 seconds, rounded to integer

4. Start-Sleep -MilliSeconds 500 # wait half a second

1. @ECHO OFF

2. REM %1 is the number of seconds for the delay, as specified on the command line

3. powershell.exe -Command "Start-Sleep -Seconds %1"

1. @ECHO OFF

2. REM %1 is the number of seconds (fractions allowed) for the delay, as specified on the command line

3. powershell.exe -Command "Start-Sleep -MilliSeconds ( 1000 * %1 )"

1. @ECHO OFF

2. REM %1 is the number of seconds for the delay, as specified on the command line

3. > "%Temp%.\sleep.vbs" ECHO WScript.Sleep %~1 * 1000

4. CSCRIPT //NoLogo "%Temp%.\sleep.vbs"

5. DEL "%Temp%.\sleep.vbs"

1. @ECHO OFF

2. REM %1 is the number of seconds for the delay, as specified on the command line

3. >  "%Temp%.\sleep.vbs" ECHO Set wshShell = CreateObject( "WScript.Shell" )

4. >> "%Temp%.\sleep.vbs" ECHO ret = wshShell.Popup( "Waiting %~1 seconds", %~1, "Please Wait", vbInformation )

5. >> "%Temp%.\sleep.vbs" ECHO Set wshShell = Nothing

6. CSCRIPT //NoLogo "%Temp%.\sleep.vbs"

7. DEL "%Temp%.\sleep.vbs"

page last modified: 2023-09-12; loaded in 0.0075 seconds