How to tell PowerShell to wait for each command to end before starting the next?

Normally, for internal commands PowerShell does wait before starting the next command. One exception to this rule is external Windows subsystem based EXE. The first trick is to pipeline to Out-Null like so:

Notepad.exe | Out-Null

PowerShell will wait until the Notepad.exe process has been exited before continuing. That is nifty but kind of subtle to pick up from reading the code. You can also use Start-Process with the -Wait parameter:

Start-Process <path to exe> -NoNewWindow -Wait

If you are using the PowerShell Community Extensions version it is:

$proc = Start-Process <path to exe> -NoNewWindow -PassThru
$proc.WaitForExit()

Another option in PowerShell 2.0 is to use a background job:

$job = Start-Job { invoke command here }
Wait-Job $job
Receive-Job $job

Besides using Start-Process -Wait, piping the output of an executable will make Powershell wait. Depending on the need, I will typically pipe to Out-Null, Out-Default, Out-String or Out-String -Stream. Here is a long list of some other output options.

# Saving output as a string to a variable.
$output = ping.exe example.com | Out-String

# Filtering the output.
ping stackoverflow.com | where { $_ -match '^reply' }

# Using Start-Process affords the most control.
Start-Process -Wait SomeExecutable.com

I do miss the CMD/Bash style operators that you referenced (&, &&, ||). It seems we have to be more verbose with Powershell.

Just use "Wait-process" :

"notepad","calc","wmplayer" | ForEach-Object {Start-Process $_} | Wait-Process ;dir

job is done

If you use Start-Process <path to exe> -NoNewWindow -Wait

You can also use the -PassThru option to echo output.

Some programs can't process output stream very well, using pipe to Out-Null may not block it.
And Start-Process needs the -ArgumentList switch to pass arguments, not so convenient.
There is also another approach.

$exitCode = [Diagnostics.Process]::Start(<process>,<arguments>).WaitForExit(<timeout>)

Building upon @Justin & @Nathan Hartley 's answers:

& "my.exe" | Out-Null    #go nowhere    
& "my.exe" | Out-Default # go to default destination  (e.g. console)
& "my.exe" | Out-String  # return a string

the piping will return it in real-time

& "my.exe" | %{    
   if ($_ -match 'OK')    
   { Write-Host $_ -f Green }    
   else if ($_ -match 'FAIL|ERROR')   
   { Write-Host $_ -f Red }   
   else    
   { Write-Host $_ }    
}

Note: If the executed program returns anything other than a 0 exitcode, the piping will not work. You can force it to pipe with redirection operators such as 2>&1

& "my.exe" 2>&1 | Out-String

sources:

https://stackoverflow.com/a/7272390/254276

https://social.technet.microsoft.com/forums/windowsserver/en-US/b6691fba-0e92-4e9d-aec2-47f3d5a17419/start-process-and-redirect-output-to-powershell-window

Including the option -NoNewWindow gives me an error: Start-Process : This command cannot be executed due to the error: Access is denied.

The only way I could get it to work was to call:

Start-Process <path to exe> -Wait

Taking it further you could even parse on the fly

e.g.

& "my.exe" | %{
    if ($_ -match 'OK')
    { Write-Host $_ -f Green }
    else if ($_ -match 'FAIL|ERROR')
    { Write-Host $_ -f Red }
    else 
    { Write-Host $_ }
}

There's always cmd.

cmd /c start /wait notepad

Or

notepad | out-host
powershell notepad | write-output  # pipe to anything
powershell notepad > $null

Here's another odd one. Start-process keeps waiting for notepad, even though the 2nd powershell exits. ("cmd /c start /wait powershell notepad" doesn't do this.) So even if anything in the process tree runs in the background (the NSIS uninstaller un_a.exe does this in foldingathome, notepad++, psychopy, ciscoamp, firefox, scratch), it still waits.

start-process -wait powershell notepad

This waits in windows 10 but not windows 11:

cmd /c notepad

Note that you're describing unconditional sequencing of commands, whereas the && operator is conditional in that it only executes the RHS command if the LHS one indicated success.

• For unconditional sequencing (the equivalent of cmd.exe's & operator), use ;, PowerShell's statement separator (<cmd1> and <cmd2> are placeholders for arbitrary commands):

  # First run <cmd1> to completion, then <cmd2>
  <cmd1>; <cmd2>
  

  • Note:

    • If the commands are external executables, the assumptions is that they're console applications, which PowerShell executes synchronously, resulting in the desired sequencing (first run <cmd1> to completion, then <cmd2>).

    • If they're GUI applications, which execute asynchronously by default, you can use the approaches shown in Keith's answer, <cmd1> | Out-Null, or Start-Process -Wait <cmd1>; the latter, which requires specifying pass-through arguments separately, has the advantage that it also works for GUI applications that use a short-lived startup process that defers to a child process; however, even that may not be sufficient for modern UWP applications; see this answer for more information.

• For conditional sequencing, whether with && logic or its negation, ||:

  • Only PowerShell (Core) v7 supports && and ||, the pipeline-chaining operators:

    # Run <cmd1> to completion and only if it *succeeded* run <cmd2>.
    <cmd1> && <cmd2> 
    
    # Run <cmd1> to completion and only if it *failed* run <cmd2>.
    <cmd1> || <cmd2> 
    

    • Notable pitfalls are:

      • These operators do not work with PowerShell-native Test- commands (because they report a Boolean value as output rather than as their execution success status).
      • Language statements such as exit and throw on the RHS must be wrapped in $(...).

  • In Windows PowerShell (the legacy, ships-with-Windows edition whose latest and final version is 5.1), you must emulate these operators:

    # Emulate `&&`:
    # Run <cmd1> to completion and only if it *succeeded* run <cmd2>.
    <cmd1>; if ($?) { <cmd1> } 
    
    # Emulate `||`:
    # Run <cmd1> to completion and only if it *failed* run <cmd2>.
    <cmd1>; if (-not $?) { <cmd2> } 
    

    • Notable pitfall:

      • With external programs, if a 2> redirection is involved, $? can yield false negatives;^[1] therefore, it is more robust to use the following:

         # With EXTERNAL PROGRAMS only:
        
         # Emulate `&&`:
         # Run <cmd1> to completion and only if it *succeeded* run <cmd2>.
         <cmd1>; if ($LASTEXITCODE -eq 0) { <cmd1> } 
        
         # Emulate `||`:
         # Run <cmd1> to completion and only if it *failed* run <cmd2>.
         <cmd1>; if ($LASTEXITCODE -ne 0) { <cmd2> } 
        

  • See this answer for more information.

^{[1] This problem has been fixed in PowerShell (Core) 7; however, there it is simpler to use && and || directly.}