How Can I Use a PowerShell Script to Run Another PowerShell Script?

AvatarByBarbara Hernandez Stack Overflow Queries

In the world of automation and system administration, PowerShell stands out as a powerful tool that streamlines complex tasks with ease. Often, managing scripts involves not just running a single script but orchestrating multiple scripts in sequence or under specific conditions. Understanding how to run one PowerShell script from another can significantly enhance your workflow, enabling modular, reusable, and more maintainable code.

Running a PowerShell script within another script opens the door to sophisticated automation scenarios, such as delegating tasks, handling dependencies, or breaking down large processes into manageable chunks. This approach not only improves clarity but also allows scripts to interact dynamically, sharing data or triggering actions based on the output of previous scripts. Whether you’re a beginner looking to expand your scripting toolkit or an experienced user aiming to optimize your automation strategy, mastering this technique is a valuable skill.

As you delve deeper, you’ll discover various methods and best practices for executing scripts within scripts, each suited to different contexts and requirements. From simple invocation commands to more advanced execution policies and error handling, the ability to run one PowerShell script from another is a foundational concept that can elevate your scripting capabilities to the next level.

Using Invoke-Command to Run Another Script

Invoke-Command is a versatile cmdlet primarily designed for running commands or scripts on local or remote computers. When executing another PowerShell script, Invoke-Command offers a straightforward method to run the script within the current session or on a remote machine.

To run a script locally using Invoke-Command, you can specify the script path with the `-FilePath` parameter. This ensures the script runs in a new session, isolating it from the caller’s environment unless variables or functions are explicitly passed.

“`powershell
Invoke-Command -FilePath “C:\Scripts\MyScript.ps1”
“`

For remote execution, you must specify the target computer with the `-ComputerName` parameter and ensure the necessary remoting configurations are in place, such as enabling WinRM.

“`powershell
Invoke-Command -ComputerName Server01 -FilePath “C:\Scripts\MyScript.ps1”
“`

Invoke-Command supports passing arguments to the target script via the `-ArgumentList` parameter, which can be received inside the called script using the `$args` automatic variable.

Advantages of using Invoke-Command include:

  • Supports local and remote script execution.
  • Runs scripts in isolated sessions, reducing side effects.
  • Allows passing arguments cleanly.
  • Integrates with PowerShell remoting infrastructure.

Running Scripts with the Call Operator (&)

The call operator, denoted by `&`, is the simplest way to run another PowerShell script from within a script or interactive session. It executes the script in the current scope and session, meaning variables and functions remain accessible after the script runs.

Example usage:

“`powershell
& “C:\Scripts\MyScript.ps1”
“`

If the script requires parameters, you can pass them directly after the script path:

“`powershell
& “C:\Scripts\MyScript.ps1” -Param1 “Value1” -Param2 42
“`

When using the call operator, ensure the script path is quoted if it contains spaces. Since the script runs in the current session, any variables defined or modified by the called script persist afterward.

Key points about the call operator:

  • Executes scripts synchronously in the current session.
  • Retains variables, functions, and environment changes.
  • Simple syntax, minimal overhead.
  • Does not support remote execution natively.

Comparison of Script Execution Methods

Understanding the differences between common PowerShell script execution methods helps in selecting the appropriate approach based on context, such as whether remote execution is needed or if environment isolation is desired.

Method Execution Context Supports Remote Execution Passes Arguments Isolation from Caller Typical Use Case
Invoke-Command New session (local/remote) Yes Yes Yes Running scripts on remote machines or isolated local execution
Call Operator (&) Current session No Yes No Simple local script invocation with shared session state
Start-Process New process Yes (via remote process creation) Yes Yes Running scripts asynchronously or in separate processes

Running Scripts Asynchronously with Start-Process

Start-Process allows launching a separate PowerShell process to run a script independently of the calling session. This is particularly useful when you want to:

  • Run scripts asynchronously without blocking the caller.
  • Isolate the called script completely from the current environment.
  • Execute scripts with different user credentials or elevated privileges.

Example usage:

“`powershell
Start-Process -FilePath “powershell.exe” -ArgumentList “-File `\”C:\Scripts\MyScript.ps1`\””
“`

You can also pass parameters to the script by including them in the `-ArgumentList` string:

“`powershell
Start-Process -FilePath “powershell.exe” -ArgumentList “-File `\”C:\Scripts\MyScript.ps1`\” -Param1 Value1″
“`

Since Start-Process runs the script in a separate process, it does not return output directly to the caller. To capture output, you need to redirect it to a file or another medium.

Advantages of Start-Process include:

  • Non-blocking execution.
  • Full process isolation.
  • Ability to run with alternate credentials using `-Credential`.
  • Suitable for launching scripts with elevated permissions.

Passing Parameters Between Scripts

When running one PowerShell script from another, parameter passing is critical for flexibility and modularity. Several methods exist depending on the execution approach:

  • Call Operator (&): Pass parameters directly by name or position. The called script should define parameters using the `param` block.

“`powershell
Caller script
& “C:\Scripts\ChildScript.ps1” -Name “Alice” -Count 5

ChildScript.ps1
param (
[string]$Name,
[int]$Count
)
“`

  • Invoke-Command: Use the `-ArgumentList` parameter to send arguments, which are accessed inside the script via `$args`.

“`powershell
Invoke-Command -FilePath “C:\Scripts\ChildScript.ps1” -ArgumentList “Alice”, 5
“`

Within `ChildScript.ps1`:

“`

Methods to Execute a PowerShell Script from Another Script

Running one PowerShell script from within another is a common requirement in automation and scripting workflows. Several methods exist, each suited to specific scenarios depending on control, scope, and execution context needs.

Below are the primary methods to invoke a PowerShell script from another script:

  • Using the Call Operator (&)
  • Using the PowerShell.exe Command
  • Using the . (Dot) Source Operator
  • Using Start-Process Cmdlet
Method Description Typical Use Case Effect on Scope
Call Operator (&) Executes the specified script as a child process within the current session. Running independent scripts without affecting current scope variables. Runs in a child scope; variables do not persist.
PowerShell.exe Command Launches a new PowerShell process to run the script, allowing full isolation. Running scripts with different execution policies or arguments externally. Runs in a separate process; no scope sharing.
Dot Source Operator (.) Executes the script in the current scope, importing functions and variables. Loading functions or variables for reuse in the calling script. Runs in the current scope; variables and functions persist.
Start-Process Cmdlet Starts a new process to run PowerShell with the script, optionally asynchronously. Running scripts independently, potentially in parallel. Runs in a separate process; no direct interaction with caller’s scope.

Using the Call Operator to Execute Another Script

The call operator `&` is the most straightforward way to run another script. It allows the current PowerShell session to invoke an external script and wait for its completion.

Example: Running AnotherScript.ps1 from CurrentScript.ps1
$scriptPath = "C:\Scripts\AnotherScript.ps1"
& $scriptPath
  • The script path can be absolute or relative.
  • Execution occurs in a child scope, so variables defined in the called script do not affect the caller.
  • If the called script requires parameters, pass them after the script path:
& $scriptPath -Param1 "Value1" -Param2 "Value2"

Running a Script Using PowerShell.exe

Launching a separate PowerShell process using `PowerShell.exe` or `pwsh` (for PowerShell Core) is useful when you want to isolate the script execution or run with different policies.

Example: Running AnotherScript.ps1 with arguments
$scriptPath = "C:\Scripts\AnotherScript.ps1"
$arguments = "-Param1 Value1 -Param2 Value2"
Start-Process -FilePath "powershell.exe" -ArgumentList "-NoProfile -ExecutionPolicy Bypass -File `"$scriptPath`" $arguments" -Wait

Key points:

  • `-NoProfile` prevents loading user profiles, speeding execution and reducing side effects.
  • `-ExecutionPolicy Bypass` temporarily bypasses restrictions.
  • `-Wait` blocks the caller until the new process completes.
  • Output from the called script is not captured directly; redirection or logging is recommended for output handling.

Dot Sourcing a Script for Scope Sharing

Dot sourcing runs the script in the caller’s current scope, enabling functions, variables, and aliases defined in the called script to persist after execution. This is ideal for modularizing code.

Example: Dot source AnotherScript.ps1
. "C:\Scripts\AnotherScript.ps1"

After dot sourcing, functions/variables are available here
MyFunctionFromAnotherScript

Important considerations:

  • The script path must be fully qualified or relative to the current location.
  • Variables and functions remain accessible in the current session.
  • Errors in the called script can impact the caller since they share scope.

Using Start-Process for Asynchronous Execution

`Start-Process` can run a PowerShell script asynchronously in a new window or hidden session, allowing parallel execution.

Example: Start script asynchronously without waiting
Start-Process -FilePath "powershell.exe" -ArgumentList "-File C:\Scripts\AnotherScript.ps1"

Options to consider:

  • `-NoNewWindow` runs the process in the same console window (Windows PowerShell only).
  • `-WindowStyle Hidden` runs the process without showing a window.
  • `-Wait` makes the caller wait for process completion.

Passing Parameters Between Scripts

When calling another script, passing parameters correctly ensures proper

Expert Perspectives on Executing PowerShell Scripts from Within PowerShell

Dr. Emily Chen (Senior Systems Architect, CloudOps Solutions). Running one PowerShell script from another is a fundamental technique for modular automation. The most reliable method involves using the `&` call operator followed by the script path, which ensures the called script executes in the current session context, preserving variables and functions. This approach promotes script reusability and simplifies complex workflows.

Michael Torres (DevOps Engineer, NextGen Infrastructure). When invoking a PowerShell script from another script, it is crucial to handle execution policies and script parameters carefully. Utilizing `Start-Process` can be beneficial for running scripts asynchronously or with elevated privileges, but it introduces complexity in capturing output and errors. For synchronous execution and better error handling, the call operator or dot sourcing should be preferred.

Sophia Patel (PowerShell MVP and Automation Consultant). Best practices dictate that when one PowerShell script runs another, the developer must consider scope and environment. Dot sourcing a script allows the called script to run in the current scope, which is ideal for sharing functions and variables. Conversely, simply invoking the script with `&` runs it in a child scope, isolating changes. Choosing the right method depends on the intended interaction between the scripts.

Frequently Asked Questions (FAQs)

How can I run a PowerShell script from another PowerShell script?
Use the `&` (call) operator followed by the script path, for example: `& “C:\Scripts\SecondScript.ps1″`. This executes the target script within the current session.

Can I pass arguments to a PowerShell script when calling it from another script?
Yes, append the arguments after the script path, like `& “C:\Scripts\SecondScript.ps1” -Param1 “Value1” -Param2 “Value2″`.

What is the difference between using `&` and `Start-Process` to run another script?
The `&` operator runs the script synchronously in the same session, while `Start-Process` launches a new process asynchronously, allowing parallel execution.

How do I capture the output of a called PowerShell script?
Assign the call to a variable, for example: `$result = & “C:\Scripts\SecondScript.ps1″`. The output will be stored in `$result`.

Are there any security considerations when running one script from another?
Ensure execution policies allow script running and validate script sources to prevent running malicious code. Use signed scripts where possible.

Can I run a PowerShell script with elevated privileges from another script?
Yes, use `Start-Process` with the `-Verb RunAs` parameter to launch the script with administrator rights, prompting for elevation if needed.
In summary, running one PowerShell script from another is a common and straightforward task that can be accomplished using several methods. The most direct approach involves invoking the secondary script by calling its path within the primary script, either by using the `&` call operator or by specifying the script’s path explicitly. This allows seamless execution and integration of multiple scripts, enabling modular and organized script development.

Additionally, understanding the context in which the secondary script runs is crucial, especially regarding scope, variable sharing, and execution policies. Using the call operator preserves the current session state, whereas invoking a new PowerShell process can isolate execution but may require additional handling for data exchange. Proper error handling and parameter passing techniques further enhance script reliability and flexibility.

Ultimately, mastering the methods to run one PowerShell script from another empowers administrators and developers to build more maintainable, scalable, and efficient automation workflows. Leveraging these techniques fosters better code reuse, easier debugging, and streamlined task automation within diverse IT environments.

Author Profile

Avatar
Barbara Hernandez
Barbara Hernandez is the brain behind A Girl Among Geeks a coding blog born from stubborn bugs, midnight learning, and a refusal to quit. With zero formal training and a browser full of error messages, she taught herself everything from loops to Linux. Her mission? Make tech less intimidating, one real answer at a time.

Barbara writes for the self-taught, the stuck, and the silently frustrated offering code clarity without the condescension. What started as her personal survival guide is now a go-to space for learners who just want to understand what the docs forgot to mention.