PowerShell
Arbeta med föremål

Uppdatering av objekt

Lägga till egenskaper

Om du vill lägga till egenskaper till ett befintligt objekt kan du använda cmdleten Add-Member. Med PSObjects hålls värden i en typ av "Obsegenskaper"

$object = New-Object -TypeName PSObject -Property @{
        Name = $env:username
        ID = 12
        Address = $null
    }

Add-Member -InputObject $object -Name "SomeNewProp" -Value "A value" -MemberType NoteProperty

# Returns
PS> $Object
Name ID Address SomeNewProp
---- -- ------- -----------
nem  12         A value

Du kan också lägga till egenskaper med Select-Object Cmdlet (så kallade beräknade egenskaper):

$newObject = $Object | Select-Object *, @{label='SomeOtherProp'; expression={'Another value'}}

# Returns
PS> $newObject
Name ID Address SomeNewProp SomeOtherProp
---- -- ------- ----------- -------------
nem  12         A value     Another value

Kommandot ovan kan förkortas till detta:

$newObject = $Object | Select *,@{l='SomeOtherProp';e={'Another value'}}

Ta bort egenskaper

Du kan använda Select-Object Cmdlet för att ta bort egenskaper från ett objekt:

$object = $newObject | Select-Object * -ExcludeProperty ID, Address

# Returns
PS> $object
Name SomeNewProp SomeOtherProp
---- ----------- -------------
nem  A value     Another value

Skapa ett nytt objekt

PowerShell skickar, till skillnad från vissa andra skriptspråk, objekt genom pipeline. Vad detta betyder är att när du skickar data från ett kommando till ett annat, är det viktigt att kunna skapa, ändra och samla objekt.

Att skapa ett objekt är enkelt. De flesta objekt som du skapar är anpassade objekt i PowerShell, och den typ som ska användas för det är PSObject. PowerShell tillåter dig också att skapa alla objekt du kan skapa i .NET.

Här är ett exempel på att skapa ett nytt objekt med några egenskaper:

Alternativ 1: Nytt objekt

$newObject = New-Object -TypeName PSObject -Property @{
    Name = $env:username
    ID = 12
    Address = $null
}

# Returns
PS> $newObject
Name ID Address
---- -- -------
nem  12

Du kan lagra objektet i en variabel genom att förordna kommandot med $newObject =

Du kanske också behöver lagra samlingar av objekt. Detta kan göras genom att skapa en tom samlingsvariabel och lägga till objekt i samlingen, så:

$newCollection = @()
$newCollection += New-Object -TypeName PSObject -Property @{
    Name = $env:username
    ID = 12
    Address = $null
}

Du kanske sedan vill iterera igenom detta samlingsobjekt för objekt. För att göra det, leta upp Loop-avsnittet i dokumentationen.

Alternativ 2: Välj-objekt

Ett mindre vanligt sätt att skapa objekt som du fortfarande hittar på internet är följande:

$newObject = 'unuseddummy' | Select-Object -Property Name, ID, Address
$newObject.Name = $env:username
$newObject.ID = 12

# Returns
PS> $newObject
Name ID Address
---- -- -------
nem  12

Alternativ 3: accelerator av typen PScustomobject (PSv3 + krävs)

Den beställda typen av accelerator tvingar PowerShell att hålla våra egenskaper i den ordning som vi definierade dem. Du behöver inte den beställda typen accelerator för att använda [PSCustomObject] :

$newObject = [PSCustomObject][Ordered]@{
    Name = $env:Username
    ID = 12
    Address = $null
}

# Returns
PS> $newObject
Name ID Address
---- -- -------
nem  12

Undersöker ett objekt

Nu när du har ett objekt kan det vara bra att ta reda på vad det är. Du kan använda Get-Member cmdlet för att se vad ett objekt är och vad det innehåller:

Get-Item c:\windows | Get-Member

Detta ger:

TypeName: System.IO.DirectoryInfo

Följt av en lista med egenskaper och metoder som objektet har.

Ett annat sätt att få typen av ett objekt är att använda GetType-metoden, så här:

C:\> $Object = Get-Item C:\Windows
C:\> $Object.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     DirectoryInfo                            System.IO.FileSystemInfo

För att visa en lista med egenskaper som objektet har, tillsammans med deras värden, kan du använda cmdlet Format-Lista med egenskapsparametern inställd på: * (betyder allt).

Här är ett exempel med den resulterande utgången:

C:\> Get-Item C:\Windows | Format-List -Property *


PSPath            : Microsoft.PowerShell.Core\FileSystem::C:\Windows
PSParentPath      : Microsoft.PowerShell.Core\FileSystem::C:\
PSChildName       : Windows
PSDrive           : C
PSProvider        : Microsoft.PowerShell.Core\FileSystem
PSIsContainer     : True
Mode              : d-----
BaseName          : Windows
Target            : {}
LinkType          :
Name              : Windows
Parent            :
Exists            : True
Root              : C:\
FullName          : C:\Windows
Extension         :
CreationTime      : 30/10/2015 06:28:30
CreationTimeUtc   : 30/10/2015 06:28:30
LastAccessTime    : 16/08/2016 17:32:04
LastAccessTimeUtc : 16/08/2016 16:32:04
LastWriteTime     : 16/08/2016 17:32:04
LastWriteTimeUtc  : 16/08/2016 16:32:04
Attributes        : Directory

Skapa exempel på generiska klasser

Obs: exempel skrivna för PowerShell 5.1 Du kan skapa instanser av generiska klasser

#Nullable System.DateTime
[Nullable[datetime]]$nullableDate = Get-Date -Year 2012
$nullableDate
$nullableDate.GetType().FullName
$nullableDate = $null
$nullableDate

#Normal System.DateTime
[datetime]$aDate = Get-Date -Year 2013
$aDate
$aDate.GetType().FullName
$aDate = $null #Throws exception when PowerShell attempts to convert null to 

Ger output:

Saturday, 4 August 2012 08:53:02
System.DateTime
Sunday, 4 August 2013 08:53:02
System.DateTime
Cannot convert null to type "System.DateTime".
At line:14 char:1
+ $aDate = $null
+ ~~~~~~~~~~~~~~
    + CategoryInfo          : MetadataError: (:) [], ArgumentTransformationMetadataException
    + FullyQualifiedErrorId : RuntimeException

Generiska samlingar är också möjliga

[System.Collections.Generic.SortedDictionary[int, String]]$dict = [System.Collections.Generic.SortedDictionary[int, String]]::new()
$dict.GetType().FullName

$dict.Add(1, 'a')
$dict.Add(2, 'b')
$dict.Add(3, 'c')


$dict.Add('4', 'd') #powershell auto converts '4' to 4
$dict.Add('5.1', 'c') #powershell auto converts '5.1' to 5

$dict

$dict.Add('z', 'z') #powershell can't convert 'z' to System.Int32 so it throws an error

Ger output:

System.Collections.Generic.SortedDictionary`2[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]

Key Value
--- -----
  1 a
  2 b
  3 c
  4 d
  5 c
Cannot convert argument "key", with value: "z", for "Add" to type "System.Int32": "Cannot convert value "z" to type "System.Int32". Error: "Input string was not in a correct format.""
At line:15 char:1
+ $dict.Add('z', 'z') #powershell can't convert 'z' to System.Int32 so  ...
+ ~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodException
    + FullyQualifiedErrorId : MethodArgumentConversionInvalidCastArgument