La sortie texte des commandes dans la fenêtre de l'interpréteur PowerShell n'est qu'un moyen d'afficher des informations sous une forme adaptée à la perception humaine. En fait mercredi pour travailler avec des objets : les applets de commande et les fonctions les reçoivent en entrée et , et les types de variables disponibles de manière interactive et dans les scripts sont basés sur les classes .NET. Dans le quatrième article de la série, nous étudierons plus en détail le travail avec des objets.
Table des matières:
Objets dans PowerShell
Rappelons qu'un objet est un ensemble de champs de données (propriétés, événements, etc.) et de méthodes permettant de les traiter (méthodes). Sa structure est spécifiée par un type, généralement basé sur les classes utilisées dans la plateforme unifiée .NET Core. Il est également possible de travailler avec des objets COM, CIM (WMI) et ADSI. Des propriétés et des méthodes sont nécessaires pour effectuer diverses actions sur les données ; de plus, dans PowerShell, les objets peuvent être transmis comme arguments aux fonctions et applets de commande, attribuer leurs valeurs aux variables, et il existe également (convoyeur ou pipeline). Chaque commande du pipeline transmet tour à tour sa sortie à la suivante, objet par objet. Pour le traitement, vous pouvez utiliser des applets de commande compilées ou créer les vôtres pour effectuer diverses manipulations avec les objets dans le pipeline : filtrer, trier, regrouper et même modifier leur structure. La transmission de données sous cette forme présente un sérieux avantage : l'équipe réceptrice n'a pas besoin d'analyser le flux d'octets (texte), toutes les informations nécessaires sont facilement récupérées en appelant les propriétés et méthodes appropriées.
Visualisation de la structure des objets
Par exemple, exécutons l'applet de commande Get-Process, qui vous permet d'obtenir des informations sur les processus exécutés dans le système :
Il affichera des données texte formatées qui ne donnent aucune idée des propriétés des objets renvoyés et de leurs méthodes. Pour affiner le résultat, nous devons apprendre à examiner la structure des objets, et l'applet de commande Get-Member nous y aidera :
Get-Process | Get-Member
Ici, nous voyons déjà le type et la structure, et à l'aide de paramètres supplémentaires, nous pouvons, par exemple, afficher uniquement les propriétés de l'objet inclus dans l'entrée :
Get-Process | Get-Member -MemberType PropertyCes connaissances seront nécessaires pour résoudre des problèmes d'administration de manière interactive ou pour écrire vos propres scripts : par exemple, pour obtenir des informations sur les processus bloqués à l'aide de la propriété Responding.
Filtrage des objets
PowerShell permet aux objets qui remplissent une certaine condition de passer par un pipeline :
Where-Object { блок сценария }Le résultat de l’exécution du bloc de script entre parenthèses doit être une valeur booléenne. Si c'est vrai ($true), l'objet entré dans l'applet de commande Where-Object sera transmis le long du pipeline, sinon ($false), il sera supprimé. Par exemple, affichons une liste des services Windows Server arrêtés, c'est-à-dire ceux dont la propriété Status est définie sur « Stopped » :
Get-Service | Where-Object {$_.Status -eq "Stopped"}
Ici encore, nous voyons une représentation textuelle, mais si vous voulez comprendre le type et la structure interne des objets passant par le pipeline, ce n'est pas difficile :
Get-Service | Where-Object {$_.Status -eq "Stopped"} | Get-Member
Trier les objets
Lors du traitement en pipeline d’objets, il est souvent nécessaire de les trier. L'applet de commande Sort-Object reçoit les noms des propriétés (clés de tri) et renvoie les objets classés par leurs valeurs. Il est facile de trier le résultat des processus en cours d'exécution par temps CPU passé (propriété CPU) :
Get-Process | Sort-Object –Property cpuLe paramètre -Property peut être omis lors de l’appel de l’applet de commande Sort-Object ; il est utilisé par défaut. Pour le tri inversé, utilisez le paramètre -Descending :
Get-Process | Sort-Object cpu -Descending
Sélection d'objets et de leurs parties
L'applet de commande Select-Object vous permet de sélectionner un nombre spécifique d'objets au début ou à la fin d'un pipeline à l'aide des paramètres -First ou -Last. Avec son aide, vous pouvez sélectionner des objets uniques ou certaines propriétés, ainsi que créer de nouveaux objets basés sur eux. Examinons le fonctionnement de l'applet de commande à l'aide d'exemples simples.
La commande suivante affiche des informations sur les 10 processus consommant la quantité maximale de RAM (propriété WS) :
Get-Process | Sort-Object WS -Descending | Select-Object -First 10
Vous pouvez sélectionner uniquement certaines propriétés des objets passant par le pipeline et en créer de nouvelles en fonction de celles-ci :
Get-Process | Select-Object ProcessName, Id -First 1À la suite du fonctionnement du pipeline, nous recevrons un nouvel objet dont la structure sera différente de celle renvoyée par l'applet de commande Get-Process. Vérifions cela en utilisant Get-Member :
Get-Process | Select-Object ProcessName, Id -First 1 | Get-Member
Notez que Select-Object renvoie un seul objet (-First 1) qui ne contient que deux des champs que nous avons spécifiés : leurs valeurs ont été copiées à partir du premier objet transmis au pipeline par la cmdlet Get-Process. L'une des façons de créer des objets dans les scripts PowerShell est basée sur l'utilisation de Select-Object :
$obj = Get-Process | Select-Object ProcessName, Id -First 1
$obj.GetType()
À l'aide de Select-Object, vous pouvez ajouter des propriétés calculées aux objets qui doivent être représentés comme . Dans ce cas, la valeur de sa première clé correspond au nom de la propriété, et la valeur de la deuxième clé correspond à la valeur de la propriété de l'élément de pipeline actuel :
Get-Process | Select-Object -Property ProcessName, @{Name="StartTime"; Expression = {$_.StartTime.Minute}}
Regardons la structure des objets passant par le convoyeur :
Get-Process | Select-Object -Property ProcessName, @{Name="StartTime"; Expression = {$_.StartTime.Minute}} | Get-Member
ForEach-Object, Group-Object et Measure-Object
Il existe d'autres applets de commande pour travailler avec des objets. A titre d'exemple, parlons des trois plus utiles :
PourChaque-Objet vous permet d'exécuter du code PowerShell pour chaque objet du pipeline :
ForEach-Object { блок сценария }Groupe-Objet regroupe les objets par valeur de propriété :
Group-Object PropertyNameSi vous l'exécutez avec le paramètre -NoElement, vous pouvez connaître le nombre d'éléments dans les groupes.
Mesure-Objet agrège divers paramètres récapitulatifs par valeurs de champ d'objet dans le pipeline (calcule la somme et trouve également la valeur minimale, maximale ou moyenne) :
Measure-Object -Property PropertyName -Minimum -Maximum -Average -SumEn règle générale, les applets de commande évoquées sont utilisées de manière interactive et sont souvent créées dans des scripts. avec les blocs Begin, Process et End.
Création d'objets .NET et COM (New-Object)
Il existe de nombreux composants logiciels dotés d'interfaces .NET Core et COM qui sont utiles aux administrateurs système. À l'aide de la classe System.Diagnostics.EventLog, vous pouvez gérer les journaux système directement à partir de Windows PowerShell. Examinons un exemple de création d'une instance de cette classe à l'aide de l'applet de commande New-Object avec le paramètre -TypeName :
New-Object -TypeName System.Diagnostics.EventLog
Puisque nous n’avons pas spécifié de journal d’événements spécifique, l’instance résultante de la classe ne contient aucune donnée. Pour changer cela, vous devez appeler une méthode constructeur spéciale lors de sa création à l'aide du paramètre -ArgumentList. Si nous voulons accéder au journal de l'application, nous devons passer la chaîne "Application" comme argument au constructeur :
$AppLog = New-Object -TypeName System.Diagnostics.EventLog -ArgumentList Application
$AppLog
Veuillez noter que nous avons enregistré le résultat de la commande dans la variable $AppLog. Bien que les pipelines soient couramment utilisés en mode interactif, l'écriture de scripts nécessite souvent de conserver une référence à un objet. De plus, les classes principales de .NET Core sont contenues dans l'espace de noms System : PowerShell y recherche par défaut les types spécifiés, donc écrire Diagnostics.EventLog au lieu de System.Diagnostics.EventLog est tout à fait correct.
Pour travailler avec le journal, vous pouvez utiliser les méthodes appropriées :
$AppLog | Get-Member -MemberType Method
Disons qu'il est effacé par la méthode Clear() s'il existe des droits d'accès :
$AppLog.Clear()L'applet de commande New-Object est également utilisée pour utiliser les composants COM. Il en existe un grand nombre, depuis les bibliothèques fournies avec le serveur de script Windows jusqu'aux applications ActiveX, telles qu'Internet Explorer. Pour créer un objet COM, vous devez définir le paramètre -ComObject avec le ProgId programmatique de la classe souhaitée :
New-Object -ComObject WScript.Shell
New-Object -ComObject WScript.Network
New-Object -ComObject Scripting.Dictionary
New-Object -ComObject Scripting.FileSystemObjectPour créer vos propres objets avec une structure arbitraire, l'utilisation de New-Object semble trop archaïque et lourde ; cette applet de commande est utilisée pour travailler avec des composants logiciels externes à PowerShell. Dans les prochains articles, cette question sera abordée plus en détail. En plus des objets .NET et COM, nous explorerons également les objets CIM (WMI) et ADSI.
Appel de méthodes statiques
Certaines classes .NET Core ne peuvent pas être instanciées, notamment System.Environment et System.Math. Ils sont et ne contiennent que des propriétés et des méthodes statiques. Il s'agit essentiellement de bibliothèques de référence qui s'utilisent sans créer d'objets. Vous pouvez faire référence à une classe statique via un littéral en mettant le nom du type entre crochets. Cependant, si nous regardons la structure de l'objet à l'aide de Get-Member, nous verrons le type System.RuntimeType au lieu de System.Environment :
[System.Environment] | Get-Member
Pour afficher uniquement les membres statiques, appelez Get-Member avec le paramètre -Static (notez le type d'objet) :
[System.Environment] | Get-Member -Static
Pour accéder aux propriétés et méthodes statiques, utilisez deux deux-points consécutifs au lieu d'un point après le littéral :
[System.Environment]::OSVersionOu
$test=[System.Math]::Sqrt(25)
$test
$test.GetType()
Tapez PSCustomObject
Parmi les nombreux types de données disponibles dans PowerShell, il convient de mentionner PSCustomObject, conçu pour stocker des objets avec une structure arbitraire. La création d'un tel objet à l'aide de l'applet de commande New-Object est considérée comme une méthode classique, mais lourde et obsolète :
$object = New-Object –TypeName PSCustomObject -Property @{Name = 'Ivan Danko';
City = 'Moscow';
Country = 'Russia'}
Regardons la structure de l'objet :
$object | Get-Member
À partir de PowerShell 3.0, une autre syntaxe est disponible :
$object = [PSCustomObject]@{Name = 'Ivan Danko';
City = 'Moscow';
Country = 'Russia'
}
Vous pouvez accéder aux données de l'une des manières équivalentes :
$object.Name
$object.'Name'
$value = 'Name'
$object.$value
Voici un exemple de conversion d'une table de hachage existante en objet :
$hash = @{'Name'='Ivan Danko'; 'City'='Moscow'; 'Country'='Russia'}
$hash.GetType()
$object = [pscustomobject]$hash
$object.GetType()
L’un des inconvénients des objets de ce type est que l’ordre de leurs propriétés peut changer. Pour éviter cela, vous devez utiliser l'attribut [ordered] :
$object = [PSCustomObject][ordered]@{Name = 'Ivan Danko';
City = 'Moscow';
Country = 'Russia'
}
Il existe d'autres options pour créer un objet : ci-dessus, nous avons examiné l'utilisation de l'applet de commande . Il ne reste plus qu'à déterminer l'ajout et la suppression d'éléments. Faire cela pour l’objet de l’exemple précédent est assez simple :
$object | Add-Member –MemberType NoteProperty –Name Age –Value 33
$object | Get-Member
L'applet de commande Add-Member vous permet d'ajouter non seulement des propriétés, mais également des méthodes à un $object créé précédemment à l'aide de la construction « -MemberType ScriptMethod » :
$ScriptBlock = {
# код
}
$object | Add-Member -Name "MyMethod" -MemberType ScriptMethod -Value $ScriptBlock
$object | Get-Member
Veuillez noter que nous avons utilisé la variable $ScriptBlock de type ScriptBlock pour stocker le code de la nouvelle méthode.
Pour supprimer des propriétés, utilisez la méthode correspondante :
$object.psobject.properties.remove('Name')
Créer vos propres classes
PowerShell 5.0 a introduit la possibilité de définir en utilisant la syntaxe caractéristique des langages de programmation orientés objet. Le mot de service Class est destiné à cela, après quoi vous devez spécifier le nom de la classe et décrire son corps entre parenthèses d'opérateur :
class MyClass
{
# тело класса
}
Il s'agit d'un véritable type .NET Core, avec un corps qui décrit ses propriétés, méthodes et autres éléments. Regardons un exemple de définition de la classe la plus simple :
class MyClass
{
[string]$Name
[string]$City
[string]$Country
}
Pour créer un objet (instance de classe), utilisez l'applet de commande , ou un littéral de type [MyClass] et new (constructeur par défaut) :
$object = New-Object -TypeName MyClassou
$object = [MyClass]::new()Analysons la structure de l'objet :
$object | Get-Member
N'oubliez pas la portée : vous ne pouvez pas faire référence à un nom de type sous forme de chaîne ou utiliser un littéral de type en dehors du script ou du module dans lequel la classe est définie. Dans ce cas, les fonctions peuvent renvoyer des instances de classe (objets) qui seront accessibles en dehors du module ou du script.
Après avoir créé l'objet, renseignez ses propriétés :
$object.Name = 'Ivan Danko'
$object.City = 'Moscow'
$object.Country = 'Russia'
$object
Notez que la description de la classe spécifie non seulement les types de propriétés, mais également leurs valeurs par défaut :
class Example
{
[string]$Name = 'John Doe'
}
La description d'une méthode de classe ressemble à la description d'une fonction, mais sans utiliser le mot fonction. Comme dans une fonction, les paramètres sont passés aux méthodes si nécessaire :
class MyClass
{
[string]$Name
[string]$City
[string]$Country
#описание метода
Smile([bool]$param1)
{
If($param1) {
Write-Host ':)'
}
}
}
Maintenant, le représentant de notre classe peut sourire :
$object = [MyClass]::new()
$object.Smile($true)
Les méthodes peuvent être surchargées ; de plus, une classe a , ainsi que les constructeurs dont les noms coïncident avec le nom de la classe elle-même. Une classe définie dans un script ou un module PowerShell peut servir de base à une autre - c'est ainsi que l'héritage est implémenté. Dans ce cas, il est permis d'utiliser les classes .NET existantes comme classes de base :
class MyClass2 : MyClass
{
#тело нового класса, базовым для которого является MyClass
}
[MyClass2]::new().Smile($true)
Notre description de l’utilisation d’objets dans PowerShell n’est guère exhaustive. Dans les publications suivantes, nous tenterons de l'approfondir avec des exemples pratiques : le cinquième article de la série sera consacré aux problématiques d'intégration de PowerShell avec des composants logiciels tiers. Les parties antérieures peuvent être trouvées sur les liens ci-dessous.
Source: habr.com