PowerShell全局与局部作用域中哈希表与其他变量的行为差异问询

Great question! This behavior boils down to two key things in PowerShell: how scope interacts with value vs. reference types, and the specific behavior of operators like += on different variable types. Let's break down each part of your example step by step:

1. PowerShell's Scope Basics #

By default, when you access a variable in a local scope (like inside a function), PowerShell first checks the current scope. If it doesn't find the variable there, it looks to parent scopes (like the global scope) to read the value. However, when you modify the variable (assign a new value), PowerShell creates a local copy of the variable by default—unless you explicitly use the $global: prefix to target the global variable directly.

The real difference comes in how this rule applies to value types versus reference types.

2. Why Hashtables ($hash) Behave Globally #

Hashtables are reference types. When you assign a hashtable to a variable, the variable stores a reference (a pointer) to the actual object in memory, not the object itself.

In your function:

$hash["b"] = "Battle";

You're not modifying the $hash variable itself—you're modifying the contents of the object that $hash points to. Since the local $hash variable is just referencing the same global hashtable object, those changes automatically show up in the global scope. No $global: prefix is needed here because you're not reassigning the variable, just updating the object it points to.

3. Why Arrays ($array) Don't Update Globally #

Arrays in PowerShell are also reference types, but they have a critical quirk: they're fixed-size. When you use the += operator on an array, PowerShell doesn't add an element to the existing array—it creates a new array with the original elements plus the new one, then assigns this new array to the variable.

In your function:

$array += "second";

This creates a new local $array variable that points to the new array. The global $array still points to the original array with only "first", so the global scope never sees the change. To modify the global array, you'd need to use $global:array += "second".

4. Numeric Variables ($count and $glob) #

Numeric types (like integers) are value types. When you read a value type variable from the global scope in a function, you get a copy of its value, not a reference.

About $count's Odd Behavior #

Let's walk through your $count steps (note: modern PowerShell versions might behave slightly differently than your comment suggests):

Write-Host "count locally: $count" # Reads the global $count (1)
$count += 1; # Creates a local $count variable, copies the global value (1), adds 1 → 2
Write-Host "count locally: $count" # Should display 2 (the local copy)
$count = $count+1; # Takes the local $count (2), adds 1 → 3
Write-Host "count locally: $count" # Should display 3

If your test showed the value stayed 1 after $count +=1, that might be a quirk of an older PowerShell version or a typo in your test. Regardless, the core rule holds: without $global:, modifying a value type variable creates a local copy, so the global variable remains unchanged.

Why $glob Works #

You explicitly used $global:glob +=1, which tells PowerShell to modify the global variable directly instead of creating a local copy. That's why the global scope sees the updated value (2).

Quick Rule Summary #

• Reference types (hashtables, custom objects): Modifying their contents (not reassigning the variable) affects the global object—no $global: needed.
• Arrays: += creates a new array, so you need $global: to update the global variable.
• Value types (numbers, strings, booleans): Any modification creates a local copy unless you use $global:.

内容的提问来源于stack exchange，提问作者Piero