Minden, amit tudni akartál $nullEverything you wanted to know about $null

A PowerShell $null gyakran úgy tűnik, hogy egyszerű, de sok árnyalattal rendelkezik.The PowerShell $null often appears to be simple but it has a lot of nuances. Ismerkedjen meg közelebbről, hogy $null megtudja, mi történik, ha váratlanul futtat egy $null értéket.Let's take a close look at $null so you know what happens when you unexpectedly run into a $null value.

Megjegyzés

A cikk [eredeti verziója][] a által írt blogon jelent meg @KevinMarquette .The original version of this article appeared on the blog written by @KevinMarquette. A PowerShell-csapat köszönetet Kevin, hogy ossza meg velünk a tartalmat.The PowerShell team thanks Kevin for sharing this content with us. Tekintse meg a blogját a következő címen: PowerShellExplained.com.Please check out his blog at PowerShellExplained.com.

Mi az a NULL?What is NULL?

A NULL értéket ismeretlen vagy üres értékként lehet gondolni.You can think of NULL as an unknown or empty value. A változó értéke NULL, amíg hozzá nem rendel egy értéket vagy egy objektumot.A variable is NULL until you assign a value or an object to it. Ez fontos lehet, mert vannak olyan parancsok, amelyeknek értékre van szükségük, és ha az érték NULL, akkor hibákat kell előállítania.This can be important because there are some commands that require a value and generate errors if the value is NULL.

PowerShell-$nullPowerShell $null

$null a a PowerShellben a NULL érték jelölésére használt automatikus változó.$null is an automatic variable in PowerShell used to represent NULL. Hozzárendelheti a változóhoz, összehasonlíthatja azokat, és a gyűjteményben NULL értékűre használhatja.You can assign it to variables, use it in comparisons and use it as a place holder for NULL in a collection.

A PowerShell $null a NULL értékkel rendelkező objektumként kezeli.PowerShell treats $null as an object with a value of NULL. Ez eltér a várttól, ha más nyelvről származik.This is different than what you may expect if you come from another language.

Példák $nullExamples of $null

Ha olyan változót próbál használni, amelyet még nem inicializált, akkor az érték a következő: $null .Anytime you try to use a variable that you have not initialized, the value is $null. Ez az egyik leggyakoribb módszer a $null kódban való betekintéshez.This is one of the most common ways that $null values sneak into your code.

PS> $null -eq $undefinedVariable
True

Ha nem írja be a változó nevét, akkor a PowerShell más változóként látja, és az érték $null .If you happen to mistype a variable name then PowerShell sees it as a different variable and the value is $null.

A másik lehetőség az értékek megkeresése $null , ha más parancsokból származnak, amelyek nem biztosítanak semmilyen eredményt.The other way you find $null values is when they come from other commands that don't give you any results.

PS> function Get-Nothing {}
PS> $value = Get-Nothing
PS> $null -eq $value
True

$null hatásaImpact of $null

$null az értékek a kód helyétől függően eltérőek lesznek.$null values impact your code differently depending on where they show up.

KarakterláncokbanIn strings

Ha $null sztringben használja, akkor ez egy üres érték (vagy üres karakterlánc).If you use $null in a string, then it's a blank value (or empty string).

PS> $value = $null
PS> Write-Output "The value is $value"
The value is

Ez az egyik oka, hogy a rendszer zárójeleket helyez el a változók köré, amikor a naplófájlokban használják őket.This is one of the reasons that I like to place brackets around variables when using them in log messages. Még ennél is fontosabb a változó értékek széleinek azonosítása, ha az érték a karakterlánc végén található.It's even more important to identify the edges of your variable values when the value is at the end of the string.

PS> $value = $null
PS> Write-Output "The value is [$value]"
The value is []

Így az üres karakterláncok és értékek könnyen elérhetővé válik $null .This makes empty strings and $null values easy to spot.

Numerikus egyenletbenIn numeric equation

Ha egy $null numerikus egyenletben értéket használ, akkor az eredmények érvénytelenek, ha nem ad meg hibát.When a $null value is used in a numeric equation then your results are invalid if they don't give an error. Időnként a $null kiértékelése 0 és a más időpontok is a teljes eredményt teszik $null .Sometimes the $null evaluates to 0 and other times it makes the whole result $null. Az alábbi példa egy olyan szorzást mutat be, amely az $null értékek sorrendjétől függően 0 értéket ad meg.Here is an example with multiplication that gives 0 or $null depending on the order of the values.

PS> $null * 5
PS> $null -eq ( $null * 5 )
True

PS> 5 * $null
0
PS> $null -eq ( 5 * $null )
False

Gyűjtemény helyettIn place of a collection

A gyűjtemények lehetővé teszik az értékek elérését index használatával.A collection allow you use an index to access values. Ha tulajdonképpen egy gyűjteménybe próbál indexelni null , akkor a következő hibaüzenet jelenik meg: Cannot index into a null array .If you try to index into a collection that is actually null, you get this error: Cannot index into a null array.

PS> $value = $null
PS> $value[10]
Cannot index into a null array.
At line:1 char:1
+ $value[10]
+ ~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [], RuntimeException
    + FullyQualifiedErrorId : NullArray

Ha van egy gyűjteménye, de megpróbál hozzáférni egy olyan elemhez, amely nem szerepel a gyűjteményben, egy $null eredményt kap.If you have a collection but try to access an element that is not in the collection, you get a $null result.

$array = @( 'one','two','three' )
$null -eq $array[100]
True

Objektum helyettIn place of an object

Ha olyan objektumhoz próbál hozzáférni egy tulajdonsághoz vagy altulajdonsághoz, amely nem rendelkezik a megadott tulajdonsággal, akkor a nem $null definiált változóhoz hasonló értéket kap.If you try to access a property or sub property of an object that doesn't have the specified property, you get a $null value like you would for an undefined variable. Ebben az esetben nem számít, hogy a változó $null vagy egy tényleges objektum-e.It doesn't matter if the variable is $null or an actual object in this case.

PS> $null -eq $undefined.some.fake.property
True

PS> $date = Get-Date
PS> $null -eq $date.some.fake.property
True

Metódus null értékű kifejezésenMethod on a null-valued expression

Egy metódus hívása egy $null objektumon RuntimeException .Calling a method on a $null object throws a RuntimeException.

PS> $value = $null
PS> $value.toString()
You cannot call a method on a null-valued expression.
At line:1 char:1
+ $value.tostring()
+ ~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [], RuntimeException
    + FullyQualifiedErrorId : InvokeMethodOnNull

Amikor megjelenik a kifejezés, You cannot call a method on a null-valued expression akkor az első, amit keresek, olyan helyek, ahol a metódust egy változóban Szeretném megkeresni anélkül, hogy először azt kellene ellenőrizni $null .Whenever I see the phrase You cannot call a method on a null-valued expression then the first thing I look for are places where I am calling a method on a variable without first checking it for $null.

$null ellenőrzéseChecking for $null

Előfordulhat, hogy észrevette, hogy mindig a $null bal oldalon helyezem el a következőt a $null saját példákban való ellenőrzéskor.You may have noticed that I always place the $null on the left when checking for $null in my examples. Ez szándékos és a PowerShell ajánlott eljárása.This is intentional and accepted as a PowerShell best practice. Vannak olyan helyzetek, amikor a jobb oldali elhelyezése nem biztosítja a várt eredményt.There are some scenarios where placing it on the right doesn't give you the expected result.

Tekintse meg a következő példát, és próbálja meg előre megjósolni az eredményeket:Look at this next example and try to predict the results:

if ( $value -eq $null )
{
    'The array is $null'
}
if ( $value -ne $null )
{
    'The array is not $null'
}

Ha nem határozom meg $value , az első kiértékeli, hogy az üzenet a következő: $true The array is $null .If I do not define $value, the first one evaluates to $true and our message is The array is $null. A csapda itt lehet létrehozni $value , amely lehetővé teszi, hogy mindkettő $falseThe trap here is that it's possible to create a $value that allows both of them to be $false

$value = @( $null )

Ebben az esetben a egy $value tömb, amely a következőt tartalmazza: $null .In this case, the $value is an array that contains a $null. Az -eq ellenőrzi a tömb minden értékét, és visszaadja az $null egyező értéket.The -eq checks every value in the array and returns the $null that is matched. A rendszer kiértékeli a következőt: $false .This evaluates to $false. A -ne visszaadja mindazt, ami nem egyezik, $null és ebben az esetben nincs eredmény (ez a következőt is kiértékeli $false ).The -ne returns everything that doesn't match $null and in this case there are no results (This also evaluates to $false). Egyik sem $true lehet még, ha úgy tűnik, hogy az egyik ilyen.Neither one is $true even though it looks like one of them should be.

Nem csak olyan értéket hozhatunk létre, amely mindkét esetben kiértékeli a értékét $false , így létrehozhat egy értéket, amelyben a kiértékelésük is megtörténik $true .Not only can we create a value that makes both of them evaluate to $false, it's possible to create a value where they both evaluate to $true. A Mathias Jessen ( @IISResetMe ) egy [jó postával][] rendelkezik, amely ebben a forgatókönyvben merül fel.Mathias Jessen (@IISResetMe) has a good post that dives into that scenario.

PSScriptAnalyzer és VSCodePSScriptAnalyzer and VSCode

A PSScriptAnalyzer modulhoz tartozik egy szabály, amely ezt a problémát ellenőrzi PSPossibleIncorrectComparisonWithNull .The PSScriptAnalyzer module has a rule that checks for this issue called PSPossibleIncorrectComparisonWithNull.

PS> Invoke-ScriptAnalyzer ./myscript.ps1

RuleName                              Message
--------                              -------
PSPossibleIncorrectComparisonWithNull $null should be on the left side of equality comparisons.

Mivel a VS Code a PSScriptAnalyser-szabályokat is használja, kiemeli vagy azonosítja ezt a hibát a parancsfájlban.Because VS Code uses the PSScriptAnalyser rules too, it also highlights or identifies this as a problem in your script.

Egyszerű, ha be vanSimple if check

Az, hogy az emberek egy nem $null értéket keresenek, egy egyszerű if() utasítás használata az összehasonlítás nélkül.A common way that people check for a non-$null value is to use a simple if() statement without the comparison.

if ( $value )
{
    Do-Something
}

Ha ez az érték, akkor a rendszer $null kiértékeli a következőt: $false .If the value is $null, this evaluates to $false. Ez könnyen olvasható, de ügyeljen arra, hogy pontosan azt keresi meg, amit várt.This is easy to read, but be careful that it's looking for exactly what you're expecting it to look for. Elolvastam a kód sorát:I read that line of code as:

Ha $value van érték.If $value has a value.

Ez azonban nem a teljes történet.But that's not the whole story. A sor valójában a következőket mondja:That line is actually saying:

Ha $value a nem $null vagy a vagy 0 $false a empty stringIf $value is not $null or 0 or $false or an empty string

Az alábbi példa az adott utasításhoz tartozó átfogóbb minta.Here is a more complete sample of that statement.

if ( $null -ne $value -and
        $value -ne 0 -and
        $value -ne '' -and
        $value -ne $false )
{
    Do-Something
}

Az alapszintű ellenőrzések csak akkor használhatók if , ha emlékszik a többi értékre, $false és nem csak azt, hogy egy változó értéke.It's perfectly OK to use a basic if check as long as you remember those other values count as $false and not just that a variable has a value.

Ezt a problémát azért futtattam, amikor néhány nappal ezelőtt újradolgoztam egy kódot.I ran into this issue when refactoring some code a few days ago. Ehhez hasonló alapszintű tulajdonság-ellenőrzési lehetőség volt.It had a basic property check like this.

if ( $object.property )
{
    $object.property = $value
}

Csak akkor kívánok értéket rendelni az Object tulajdonsághoz, ha az már létezik.I wanted to assign a value to the object property only if it existed. A legtöbb esetben az eredeti objektum olyan értékkel rendelkezett, amely $true Az utasításban lenne kiértékelve if .In most cases, the original object had a value that would evaluate to $true in the if statement. Egy olyan hibába ütközött, ahol az érték időnként nem lett beállítva.But I ran into an issue where the value was occasionally not getting set. Feltettem a kódot, és megállapította, hogy az objektumnak volt a tulajdonsága, de üres sztring volt.I debugged the code and found that the object had the property but it was a blank string value. Ez megakadályozta, hogy az előző logikával valaha is frissült.This prevented it from ever getting updated with the previous logic. Ezért tettem hozzá egy megfelelő $null ellenőrzési és minden működött.So I added a proper $null check and everything worked.

if ( $null -ne $object.property )
{
    $object.property = $value
}

Nagyon sok olyan hiba van, amely nehezen látható, és agresszíven értékeli az értékeket $null .It's little bugs like these that are hard to spot and make me aggressively check values for $null.

$null. Száma$null.Count

Ha egy érték tulajdonságára próbál hozzáférni $null , akkor a tulajdonság is $null .If you try to access a property on a $null value, that the property is also $null. A count tulajdonság a szabály alól kivétel.The count property is the exception to this rule.

PS> $value = $null
PS> $value.count
0

Ha van egy $null értéke, akkor a count 0 .When you have a $null value, then the count is 0. Ezt a speciális tulajdonságot a PowerShell adja hozzá.This special property is added by PowerShell.

Pscustomobject formájában kapja Száma[PSCustomObject] Count

A PowerShellben majdnem minden objektum rendelkezik a Count tulajdonsággal.Almost all objects in PowerShell have that count property. Az egyik fontos kivétel a [PSCustomObject] Windows powershell 5,1-ben (ez a PowerShell 6,0-ben van rögzítve).One important exception is the [PSCustomObject] in Windows PowerShell 5.1 (This is fixed in PowerShell 6.0). Nem rendelkezik Count tulajdonsággal, így Ön a használni kívánt értéket kapja meg $null .It doesn't have a count property so you get a $null value if you try to use it. Ezt azért hívjuk meg itt, hogy ne próbálkozzon az .Count $null ellenőrzések helyett.I call this out here so that you don't try to use .Count instead of a $null check.

A példa futtatása a Windows PowerShell 5,1-ben és a PowerShell 6,0-ben különböző eredményeket biztosít.Running this example on Windows PowerShell 5.1 and PowerShell 6.0 gives you different results.

$value = [PSCustomObject]@{Name='MyObject'}
if ( $value.count -eq 1 )
{
    "We have a value"
}

Üres nullEmpty null

Létezik egy speciális típus, $null amely másként viselkedik, mint a többi.There is one special type of $null that acts differently than the others. Üresen fogom hívni, $null de ez tényleg System. Management. Automation. internal. AutomationNull.I am going to call it the empty $null but it's really a System.Management.Automation.Internal.AutomationNull. Ez az üres érték egy olyan $null függvény vagy parancsfájl-blokk eredménye, amely nem ad vissza semmit (egy Void eredmény).This empty $null is the one you get as the result of a function or script block that returns nothing (a void result).

PS> function Get-Nothing {}
PS> $nothing = Get-Nothing
PS> $null -eq $nothing
True

Ha összehasonlítja a $null -val, egy $null értéket kap.If you compare it with $null, you get a $null value. Ha olyan kiértékelést használ, amelyben értéket kell megadni, az érték mindig $null .When used in an evaluation where a value is required, the value is always $null. Ha azonban egy tömbbe helyezi, azt a rendszer az üres tömbhöz hasonlóan kezeli.But if you place it inside an array, it's treated the same as an empty array.

PS> $containempty = @( @() )
PS> $containnothing = @($nothing)
PS> $containnull = @($null)

PS> $containempty.count
0
PS> $containnothing.count
0
PS> $containnull.count
1

Rendelkezhet egy olyan tömbvel, amely egy $null értéket és annak értékét tartalmazza count 1 .You can have an array that contains one $null value and its count is 1. Ha azonban egy tömbön belül üres eredményt ad, akkor nem számít elemnek.But if you place an empty result inside an array then it's not counted as an item. A szám a következő: 0 .The count is 0.

Ha az üres $null gyűjteményt kezeli, akkor üres.If you treat the empty $null like a collection, then it's empty.

FolyamatPipeline

Az elsődleges hely, ahol a különbség a folyamat használatakor jelenik meg.The primary place you see the difference is when using the pipeline. Adatcsatornán keresztül is át lehet adni egy $null értéket, nem pedig üres $null értéket.You can pipe a $null value but not an empty $null value.

PS> $null | ForEach-Object{ Write-Output 'NULL Value' }
'NULL Value'
PS> $nothing | ForEach-Object{ Write-Output 'No Value' }

A kóddal függően a logikájában kell megjelennie $null .Depending on your code, you should account for the $null in your logic.

Vagy az $null első kereséseEither check for $null first

  • Kiszűri a null értéket a folyamaton ( ... | Where {$null -ne $_} | ... )Filter out null on the pipeline (... | Where {$null -ne $_} | ...)
  • Kezelés a folyamat függvénybenHandle it in the pipeline function

foreachforeach

Az egyik kedvenc funkciója, foreach hogy az nem egy gyűjteményre van felsorolva $null .One of my favorite features of foreach is that it doesn't enumerate over a $null collection.

foreach ( $node in $null )
{
    #skipped
}

Ezzel elmentem, hogy $null az enumerálás előtt a gyűjteményt ellenőriznie kell.This saves me from having to $null check the collection before I enumerate it. Ha az értékek egy gyűjteménye van $null , a $node továbbra is lehetséges $null .If you have a collection of $null values, the $node can still be $null.

A foreach a PowerShell 3,0 használatával kezdte meg működését.The foreach started working this way with PowerShell 3.0. Ha régebbi verziójú verziót használ, akkor ez nem így van.If you happen to be on an older version, then this is not the case. Ez az egyik fontos változás, amely az 2,0-kompatibilitásra vonatkozó, a biztonsági mentéshez használt kód esetében szükséges.This is one of the important changes to be aware of when back-porting code for 2.0 compatibility.

Értékek típusaiValue types

Technikailag csak a hivatkozási típusok használhatók $null .Technically, only reference types can be $null. A PowerShell azonban nagyon nagyvonalú, és lehetővé teszi, hogy a változók bármilyen típusúak legyenek.But PowerShell is very generous and allows for variables to be any type. Ha úgy dönt, hogy erősen írja be az értéket, az nem lehet $null .If you decide to strongly type a value type, it cannot be $null. A PowerShell $null számos típusú alapértelmezett értékre konvertál.PowerShell converts $null to a default value for many types.

PS> [int]$number = $null
PS> $number
0

PS> [bool]$boolean = $null
PS> $boolean
False

PS> [string]$string = $null
PS> $string -eq ''
True

Vannak olyan típusok, amelyekhez nem tartozik érvényes konverzió $null .There are some types that do not have a valid conversion from $null. Ezek a típusok hibát eredményeznek Cannot convert null to type .These types generate a Cannot convert null to type error.

PS> [datetime]$date = $null
Cannot convert null to type "System.DateTime".
At line:1 char:1
+ [datetime]$date = $null
+ ~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : MetadataError: (:) [], ArgumentTransformationMetadataException
    + FullyQualifiedErrorId : RuntimeException

Függvény paramétereiFunction parameters

A függvények paramétereinek szigorúan beírt értékei nagyon gyakoriak.Using a strongly typed values in function parameters is very common. A paraméterek típusait általában akkor is megtudhatjuk, ha nem definiáljuk a parancsfájlok más változóinak típusait.We generally learn to define the types of our parameters even if we tend not to define the types of other variables in our scripts. Előfordulhat, hogy már van néhány nagy mértékben beírt változó a függvények között, és még nem is tudja megvalósítani.You may already have some strongly typed variables in your functions and not even realize it.

function Do-Something
{
    param(
        [String] $Value
    )
}

Amint beállítja a paraméter típusát string , az érték soha nem lehet $null .As soon as you set the type of the parameter as a string, the value can never be $null. Gyakori, hogy az érték azt vizsgálja, $null hogy a felhasználó értéket adott-e meg, vagy sem.It's common to check if a value is $null to see if the user provided a value or not.

if ( $null -ne $Value ){...}

$Value üres karakterlánc, '' Ha nincs megadva érték.$Value is an empty string '' when no value is provided. Használja helyette az automatikus változót $PSBoundParameters.Value .Use the automatic variable $PSBoundParameters.Value instead.

if ( $null -ne $PSBoundParameters.Value ){...}

$PSBoundParameters csak a függvény meghívásakor megadott paramétereket tartalmazza.$PSBoundParameters only contains the parameters that were specified when the function was called. A metódust is használhatja a ContainsKey tulajdonság kereséséhez.You can also use the ContainsKey method to check for the property.

if ( $PSBoundParameters.ContainsKey('Value') ){...}

IsNotNullOrEmptyIsNotNullOrEmpty

Ha az érték egy karakterlánc, egy statikus karakterlánc-függvénnyel ellenőrizhető, hogy az érték $null vagy egy üres karakterlánc-e egyszerre.If the value is a string, you can use a static string function to check if the value is $null or an empty string at the same time.

if ( -not [string]::IsNullOrEmpty( $value ) ){...}

Ezt gyakran használom, ha tudom, hogy az érték típusa csak sztring lehet.I find myself using this often when I know the value type should be a string.

$null ellenőrzéseWhen I $null check

Védekező parancsfájlt használok.I am a defensive scripter. Bármikor hívom a függvényt, és rendelje hozzá egy változóhoz $null .Anytime I call a function and assign it to a variable, I check it for $null.

$userList = Get-ADUser kevmar
if ($null -ne $userList){...}

Sokkal inkább a használatával használom a if -t vagy a-t foreach try/catch .I much prefer using if or foreach over using try/catch. Ne értsen rosszat, még mindig try/catch sokat használok.Don't get me wrong, I still use try/catch a lot. Ha azonban egy hiba feltételét vagy az eredmények üres készletét szeretném tesztelni, Engedélyezem a kivételek kezelését az igaz kivételek esetében.But if I can test for an error condition or an empty set of results, I can allow my exception handling be for true exceptions.

Azt is érdemes megkeresni, hogy $null még mielőtt indexelem az értékeket vagy a hívási metódusokat egy objektumon.I also tend to check for $null before I index into a value or call methods on an object. Ez a két művelet meghiúsul egy $null objektum esetében, ezért fontos, hogy először érvényesítse őket.These two actions fail for a $null object so I find it important to validate them first. Már említettük ezeket a forgatókönyveket a bejegyzés korábbi részében.I already covered those scenarios earlier in this post.

Nincs találati forgatókönyvNo results scenario

Fontos tudni, hogy a különböző függvények és parancsok eltérő módon kezelik a No Results forgatókönyvet.It's important to know that different functions and commands handle the no results scenario differently. Számos PowerShell-parancs az üres $null és egy hibát ad vissza a hiba-adatfolyamban.Many PowerShell commands return the empty $null and an error in the error stream. Mások azonban kivételeket jeleznek, vagy megadhatnak egy status objektumot.But others throw exceptions or give you a status object. Még mindig tisztában van azzal, hogy az Ön által használt parancsok milyen eredményekkel és hibákkal foglalkoznak.It's still up to you to know how the commands you use deal with the no results and error scenarios.

Inicializálás $nullInitializing to $null

Az egyik szokás, hogy felvettem az összes változót, mielőtt felhasználom őket.One habit that I have picked up is initializing all my variables before I use them. Ezt más nyelveken is meg kell tennie.You are required to do this in other languages. A függvény tetején vagy egy foreach hurok megadásakor definiálom az összes olyan értéket, amelyet használok.At the top of my function or as I enter a foreach loop, I define all the values that I'm using.

Íme egy olyan forgatókönyv, amely azt szeretném, hogy vessen egy alapos pillantást.Here is a scenario that I want you to take a close look at. Ez egy példa egy olyan hibára, amelyet korábban le kellett kergetni.It's an example of a bug I had to chase down before.

function Do-Something
{
    foreach ( $node in 1..6 )
    {
        try
        {
            $result = Get-Something -ID $node
        }
        catch
        {
            Write-Verbose "[$result] not valid"
        }

        if ( $null -ne $result )
        {
            Update-Something $result
        }
    }
}

A várt érték azt jelenti, hogy Get-Something egy eredményt vagy egy üres értéket ad vissza $null .The expectation here is that Get-Something returns either a result or an empty $null. Ha hiba lép fel, a rendszer naplózza.If there is an error, we log it. Ezt követően ellenőrizzük, hogy érvényes eredményt kaptunk-e a feldolgozás előtt.Then we check to make sure we got a valid result before processing it.

Az ebben a kódban található hiba akkor jelenik meg, ha Get-Something kivételt jelez, és nem rendel hozzá értéket $result .The bug hiding in this code is when Get-Something throws an exception and doesn't assign a value to $result. A hozzárendelés előtt sikertelen, így még nem is rendelhető hozzá $null a $result változóhoz.It fails before the assignment so we don't even assign $null to the $result variable. $result továbbra is az előző érvényességet tartalmazza $result más iterációk alapján.$result still contains the previous valid $result from other iterations. Update-Something több alkalommal is végrehajthat ugyanazon az objektumon ebben a példában.Update-Something to execute multiple times on the same object in this example.

$resultA foreach hurokban úgy állítottam be, hogy a $null probléma enyhítése előtt használjam.I set $result to $null right inside the foreach loop before I use it to mitigate this issue.

foreach ( $node in 1..6 )
{
    $result = $null
    try
    {
        ...

Hatókörrel kapcsolatos problémákScope issues

Ez segít a hatóköri problémák enyhítésében is.This also helps mitigate scoping issues. Ebben a példában az értékeket $result egy hurokban kell átadni.In that example, we assign values to $result over and over in a loop. Mivel azonban a PowerShell lehetővé teszi a függvényen kívüli változó értékek kiléptetését az aktuális függvény hatókörére, a függvényen belüli inicializálás csökkenti az így bevezetett hibákat.But because PowerShell allows variable values from outside the function to bleed into the scope of the current function, initializing them inside your function mitigates bugs that can be introduced that way.

A függvényben nem inicializált változó nem, $null Ha egy szülő hatókörben lévő értékre van beállítva.An uninitialized variable in your function is not $null if it's set to a value in a parent scope. A szülő hatókör lehet egy másik függvény, amely meghívja a függvényt, és ugyanazokat a változók nevét használja.The parent scope could be another function that calls your function and uses the same variable names.

Ha ugyanezt a példát elvégezem Do-something , és el is távolítom a hurkot, akkor a következő példához hasonló dolgot kell tennie:If I take that same Do-something example and remove the loop, I would end up with something that looks like this example:

function Invoke-Something
{
    $result = 'ParentScope'
    Do-Something
}

function Do-Something
{
    try
    {
        $result = Get-Something -ID $node
    }
    catch
    {
        Write-Verbose "[$result] not valid"
    }

    if ( $null -ne $result )
    {
        Update-Something $result
    }
}

Ha a hívás Get-Something kivételt jelez, akkor az ellenőrzési pont $null megkeresi a $result from elemet Invoke-Something .If the call to Get-Something throws an exception, then my $null check finds the $result from Invoke-Something. A függvényen belüli érték inicializálása csökkenti ezt a problémát.Initializing the value inside your function mitigates this issue.

Az elnevezési változók nehézek, és a szerzők gyakran ugyanazt a változót használják több függvényben.Naming variables is hard and it's common for an author to use the same variable names in multiple functions. Tudom, hogy állandóan használom $node $result $data .I know I use $node,$result,$data all the time. Így a különböző hatókörökből származó értékek nagyon egyszerűek lesznek, hogy megjelenjenek azok a helyek, ahol nem lehetnek.So it would be very easy for values from different scopes to show up in places where they should not be.

Kimenet átirányítása a $nullbaRedirect output to $null

A $null teljes cikk értékeit beszélem, de a témakör nem fejeződött be, ha nem említem a kimenet átirányítását $null .I have been talking about $null values for this entire article but the topic is not complete if I didn't mention redirecting output to $null. Időnként vannak olyan parancsok, amelyek kimeneti információit vagy objektumait szeretné letiltani.There are times when you have commands that output information or objects that you want to suppress. A kimenet átirányítása a következőre: $null .Redirecting output to $null does that.

Kimenő – nullOut-Null

Az out-null parancs a folyamaton belüli adatátvitelre szolgáló beépített módszer $null .The Out-Null command is the built-in way to redirect pipeline data to $null.

New-Item -Type Directory -Path $path | Out-Null

Hozzárendelés $nullAssign to $null

A parancs eredményét hozzárendelheti $null ugyanarra a hatásra, mint a használatával Out-Null .You can assign the results of a command to $null for the same effect as using Out-Null.

$null = New-Item -Type Directory -Path $path

Mivel $null egy konstans érték, soha nem lehet felülírni.Because $null is a constant value, you can never overwrite it. Nem szeretem, ahogy a kódban, de gyakran gyorsabb, mint a Out-Null .I don't like the way it looks in my code but it often performs faster than Out-Null.

Átirányítás $nullRedirect to $null

Az átirányítás operátorral kimenetet is küldhet a alkalmazásnak $null .You can also use the redirection operator to send output to $null.

New-Item -Type Directory -Path $path > $null

Ha olyan parancssori végrehajtható fájlokkal foglalkozik, amelyek a különböző streameken vannak kimenetben.If you're dealing with command-line executables that output on the different streams. Az összes kimeneti streamet átirányíthatja a $null következőhöz hasonló módon:You can redirect all output streams to $null like this:

git status *> $null

ÖsszegzésSummary

Sok terepet érintettem ezen a területen, és tudom, hogy ez a cikk jobban töredezett, mint a legtöbb mély merülésem.I covered a lot of ground on this one and I know this article is more fragmented than most of my deep dives. Ennek az az oka, hogy az $null értékek a PowerShell számos különböző helyén bejelentkezhetnek, és az összes árnyalat az adott helyen található.That is because $null values can pop up in many different places in PowerShell and all the nuances are specific to where you find it. Reméljük, hogy ez jobban megértette, és tisztában van azzal, hogy miként $null lehet a több homályos forgatókönyv.I hope you walk away from this with a better understanding of $null and an awareness of the more obscure scenarios you may run into.