Adding methods with ScriptMethod in PowerShell - Time & Space Complexity

Time Complexity: Adding methods with ScriptMethod

O(n)

Understanding Time Complexity

When we add methods to objects using ScriptMethod in PowerShell, it's important to understand how the time to run these methods grows as we add more data or call them multiple times.

We want to know how the execution time changes when using ScriptMethod on objects.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

$object = New-Object PSObject -Property @{Name='Test'; Value=10}
$object | Add-Member -MemberType ScriptMethod -Name 'Multiply' -Value {
    param($x)
    return $this.Value * $x
}
$result = $object.Multiply(5)
Write-Output $result
    

This code creates an object, adds a ScriptMethod called 'Multiply' that multiplies the object's Value by a number, then calls this method.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Calling the ScriptMethod 'Multiply' on the object.
• How many times: Each call runs once, but if called multiple times, it repeats for each call.

How Execution Grows With Input

The method does a simple multiplication each time it is called. If you call it once, it does one multiplication. If you call it 10 times, it does 10 multiplications.

Input Size (n)	Approx. Operations
10	10 multiplications
100	100 multiplications
1000	1000 multiplications

Pattern observation: The number of operations grows directly with how many times you call the method.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows linearly with the number of times you call the ScriptMethod.

Common Mistake

[X] Wrong: "Adding a ScriptMethod makes the method run slower each time because it adds overhead every call."

[OK] Correct: The ScriptMethod itself runs like a normal method; the overhead is very small and does not increase with each call. The time depends mostly on what the method does, not on how it was added.

Interview Connect

Understanding how methods added dynamically behave helps you explain how scripts scale and perform in real tasks. This skill shows you can reason about code efficiency beyond just writing it.

Self-Check

"What if the ScriptMethod contained a loop that ran through a list of size n inside it? How would the time complexity change when calling the method once?"