PowerShell
Travailler avec des objets

Mise à jour des objets

Ajout de propriétés

Si vous souhaitez ajouter des propriétés à un objet existant, vous pouvez utiliser l'applet de commande Add-Member. Avec PSObjects, les valeurs sont conservées dans un type de "Propriétés de la note"

$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

Vous pouvez également ajouter des propriétés avec la cmdlet Select-Object (propriétés dites calculées):

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

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

La commande ci-dessus peut être raccourcie à ceci:

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

Suppression de propriétés

Vous pouvez utiliser la cmdlet Select-Object pour supprimer des propriétés d'un objet:

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

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

Créer un nouvel objet

PowerShell, contrairement à d'autres langages de script, envoie des objets via le pipeline. Cela signifie que lorsque vous envoyez des données d'une commande à une autre, il est essentiel de pouvoir créer, modifier et collecter des objets.

Créer un objet est simple. La plupart des objets que vous créez seront des objets personnalisés dans PowerShell et le type à utiliser pour cela est PSObject. PowerShell vous permettra également de créer tout objet que vous pourriez créer dans .NET.

Voici un exemple de création de nouveaux objets avec quelques propriétés:

Option 1: Nouvel objet

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

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

Vous pouvez stocker l'objet dans une variable en faisant précéder la commande de $newObject =

Vous devrez peut-être également stocker des collections d'objets. Cela peut être fait en créant une variable de collection vide et en ajoutant des objets à la collection, comme ceci:

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

Vous pouvez ensuite vouloir parcourir cet objet de collection par objet. Pour ce faire, recherchez la section Boucle dans la documentation.

Option 2: Sélectionner un objet

Une manière moins courante de créer des objets que vous trouverez encore sur Internet est la suivante:

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

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

Option 3: accélérateur de type pscustomobject (PSv3 + requis)

L'accélérateur de type ordonné oblige PowerShell à conserver nos propriétés dans l'ordre que nous avons défini. Vous n'avez pas besoin de l'accélérateur de type ordonné pour utiliser [PSCustomObject] :

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

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

Examiner un objet

Maintenant que vous avez un objet, il peut être intéressant de le comprendre. Vous pouvez utiliser l'applet de commande Get-Member pour voir ce qu'est un objet et ce qu'il contient:

Get-Item c:\windows | Get-Member

Cela donne:

TypeName: System.IO.DirectoryInfo

Suivi d'une liste de propriétés et de méthodes de l'objet.

Une autre façon d'obtenir le type d'un objet consiste à utiliser la méthode GetType, comme ceci:

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

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

Pour afficher la liste des propriétés de l'objet et leurs valeurs, vous pouvez utiliser l'applet de commande Format-List avec son paramètre Property défini sur: * (signifiant tout).

Voici un exemple, avec le résultat obtenu:

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

Création d'instances de classes génériques

Remarque: exemples écrits pour PowerShell 5.1 Vous pouvez créer des instances de classes génériques

#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 

Donne la sortie:

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

Les collections génériques sont également possibles

[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

Donne la sortie:

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