PowerShell — Aide-mémoire

Objets — Créer & Manipuler

# Créer un objet PSCustomObject (la méthode recommandée)
$personne = [PSCustomObject]@{
    Nom      = "Dupont"
    Prénom   = "Jean"
    Age      = 42
    Actif    = $true
}

Accéder aux propriétés
$personne.Nom
$personne.Age

Ajouter une propriété dynamiquement
$personne | Add-Member -MemberType NoteProperty -Name "Email" -Value "[email protected]"

Modifier une propriété
$personne.Age = 43

Créer plusieurs objets (pattern tableau d'objets)
$equipe = @(
    [PSCustomObject]@{ Nom="Alice"; Role="Admin";    Score=95 },
    [PSCustomObject]@{ Nom="Bob";   Role="Dev";      Score=82 },
    [PSCustomObject]@{ Nom="Carol"; Role="Admin";    Score=91 }
)

Filtrer, trier, sélectionner
$admins  = $equipe | Where-Object { $_.Role -eq "Admin" }
$trié    = $equipe | Sort-Object Score -Descending
$colonnes= $equipe | Select-Object Nom, Score
$top2    = $equipe | Sort-Object Score -Descending | Select-Object -First 2

Afficher proprement
$equipe | Format-Table -AutoSize
$equipe | Format-List                           # Une propriété par ligne
$personne | ConvertTo-Json                      # Sérialiser en JSON

Tableaux (Arrays)

# Créer un tableau
$nombres  = @(1, 2, 3, 4, 5)
$vide     = @()
$mixte    = @("texte", 42, $true, $null)
$plage    = 1..10                               # 1 à 10
$lettres  = 'A'..'Z'                            # A à Z

Accéder aux éléments
$nombres[0]                                     # Premier (index 0)
$nombres[-1]                                    # Dernier
$nombres[1..3]                                  # Slice : index 1 à 3
$nombres[-3..-1]                                # 3 derniers éléments

Ajouter / Supprimer (tableaux fixes → utiliser ArrayList pour performances)
$nombres  += 6                                  # Ajoute (recrée le tableau ⚠️)
$nombres   = $nombres | Where-Object { $_ -ne 3 }  # Supprimer la valeur 3

ArrayList (mutable, performant)
$liste = [System.Collections.ArrayList]@(1, 2, 3)
$liste.Add(4)         | Out-Null                # Add retourne l'index, Out-Null le cache
$liste.Remove(2)                                # Supprimer par valeur
$liste.RemoveAt(0)                              # Supprimer par index
$liste.Count                                    # Nombre d'éléments
$liste.Contains(3)                              # $true / $false

Opérations courantes
$nombres.Count                                  # Longueur
$nombres -contains 3                            # Test présence
$nombres | Measure-Object -Sum -Average -Max -Min  # Statistiques
($nombres | Measure-Object -Sum).Sum            # Somme directe
$nombres -join ", "                             # Joindre en chaîne : "1, 2, 3, 4, 5"
"a,b,c" -split ","                              # Diviser : @("a","b","c")

Hashtables (Dictionnaires)

# Créer une hashtable
$config = @{
    Serveur = "192.168.1.10"
    Port    = 5432
    DB      = "production"
    SSL     = $true
}

Accéder / Modifier
$config["Serveur"]                              # Via index
$config.Serveur                                 # Via propriété
$config["NouvelleClé"] = "valeur"              # Ajouter
$config.Remove("SSL")                           # Supprimer
$config.ContainsKey("Port")                     # Test existence
$config.Keys                                    # Toutes les clés
$config.Values                                  # Toutes les valeurs
$config.Count                                   # Nombre d'entrées

Itérer
foreach ($key in $config.Keys) {
    Write-Host "$key = $($config[$key])"
}
$config.GetEnumerator() | Sort-Object Key | Format-Table  # Trié + affiché

Hashtable ordonnée
$ordered = [ordered]@{
    Premier  = 1
    Deuxième = 2
    Troisième = 3
}

Imbriquer des hashtables
$infra = @{
    Prod = @{ IP="10.0.1.1"; RAM=32 }
    Dev  = @{ IP="10.0.2.1"; RAM=8  }
}
$infra.Prod.IP                                  # "10.0.1.1"

Fichiers & Dossiers

# Tester l'existence
Test-Path "C:\fichier.txt"
Test-Path "C:\dossier" -PathType Container      # Dossier uniquement
Test-Path "C:\fichier.txt" -PathType Leaf       # Fichier uniquement

Lire un fichier
Get-Content "fichier.txt"                       # Tableau de lignes
Get-Content "fichier.txt" -Raw                  # Chaîne brute
Get-Content "fichier.txt" -Tail 20              # 20 dernières lignes
Get-Content "fichier.txt" -Wait                 # tail -f

Écrire dans un fichier
"Ligne 1" | Out-File "sortie.txt"               # Crée/écrase (UTF-16 par défaut)
"Ligne 1" | Out-File "sortie.txt" -Encoding utf8
"Ligne 1" | Out-File "sortie.txt" -Append       # Ajouter
Set-Content  "sortie.txt" "Contenu"             # Crée/écrase proprement
Add-Content  "sortie.txt" "Nouvelle ligne"      # Ajouter

Copier / Déplacer / Supprimer
Copy-Item    "source.txt" "dest.txt"
Copy-Item    "dossier\"   "backup\"  -Recurse
Move-Item    "ancien.txt" "nouveau.txt"
Remove-Item  "fichier.txt"
Remove-Item  "dossier\"   -Recurse -Force       # Supprimer récursivement
Rename-Item  "ancien.txt" "nouveau.txt"

Créer
New-Item "fichier.txt" -ItemType File
New-Item "dossier\"    -ItemType Directory
New-Item "fichier.txt" -ItemType File -Value "Contenu initial"

Lister
Get-ChildItem "C:\dossier"                      # ls / dir
Get-ChildItem "C:\dossier" -Recurse             # Récursivement
Get-ChildItem "C:\dossier" -Filter "*.log"      # Filtrer par extension
Get-ChildItem "C:\dossier" -Recurse -File       # Fichiers uniquement
Get-ChildItem "C:\dossier" -Recurse -Directory  # Dossiers uniquement

Métadonnées
$f = Get-Item "fichier.txt"
$f.Name                                         # Nom
$f.FullName                                     # Chemin complet
$f.Extension                                    # .txt
$f.Length                                       # Taille en octets
$f.LastWriteTime                                # Date modification

Trouver les gros fichiers
Get-ChildItem "C:\" -Recurse -File |
    Sort-Object Length -Descending |
    Select-Object -First 20 |
    Format-Table Name, @{N="Mo";E={[math]::Round($_.Length/1MB,1)}}, FullName

Parcourir un objet / Tableau

# ForEach-Object (pipeline) — pour de grands volumes
1..1000 | ForEach-Object { $_ * 2 }
$services | ForEach-Object { Write-Host $_.Name }

foreach (boucle) — plus rapide sur petits tableaux
foreach ($item in $tableau) {
    Write-Host $item
}

ForEach avec index
for ($i = 0; $i -lt $tableau.Count; $i++) {
    Write-Host "[$i] $($tableau[$i])"
}

.ForEach() méthode (PS 4+, le plus rapide)
$tableau.ForEach({ Write-Host $_ })
$tableau.ForEach({ param($x) $x * 2 })

Parcourir un objet (ses propriétés)
$objet = [PSCustomObject]@{ A=1; B=2; C=3 }
$objet.PSObject.Properties | ForEach-Object {
    Write-Host "$($_.Name) = $($_.Value)"
}
Ou via la hashtable si c'est une hashtable
$hash.GetEnumerator() | ForEach-Object {
    Write-Host "$($_.Key) = $($_.Value)"
}

Parcourir récursivement (exemple : JSON imbriqué)
function Traverse($obj, $indent=0) {
    $obj.PSObject.Properties | ForEach-Object {
        $pad = "  " * $indent
        if ($_.Value -is [PSCustomObject]) {
            Write-Host "${pad}$($_.Name):"
            Traverse $_.Value ($indent + 1)
        } else {
            Write-Host "${pad}$($_.Name) = $($_.Value)"
        }
    }
}

Pipelines & Filtres

# Where-Object (filtrer)
$services | Where-Object { $_.Status -eq "Running" }
$services | Where-Object Status -eq "Running"            # Syntaxe courte
$fichiers | Where-Object { $_.Length -gt 1MB }
$logs     | Where-Object { $_ -match "ERROR" }

Select-Object (colonnes)
$objet | Select-Object Nom, Age                          # Garder certaines propriétés
$objet | Select-Object -ExcludeProperty MdP              # Exclure
$objet | Select-Object *                                 # Tout
$objet | Select-Object -ExpandProperty Adresses          # Aplatir un sous-objet
$objet | Select-Object Nom, @{N="NomMaj";E={$_.Nom.ToUpper()}}  # Propriété calculée

Group-Object (regrouper)
$logs | Group-Object Niveau | Format-Table Count, Name
$users | Group-Object Department | Where-Object Count -gt 5

Measure-Object (statistiques)
$fichiers | Measure-Object Length -Sum -Average -Max -Min
Get-Process | Measure-Object CPU -Sum

Sort-Object
$objet | Sort-Object Age
$objet | Sort-Object Age -Descending
$objet | Sort-Object Dept, Age          # Tri multi-colonnes
$objet | Sort-Object { $_.Nom.Length }  # Tri par expression

Tee-Object (bifurquer le pipeline)
Get-Process | Tee-Object -FilePath processes.txt | Where-Object CPU -gt 10

Fonctions

# Fonction simple
function Dire-Bonjour {
    param([string]$Nom = "Monde")
    Write-Host "Bonjour, $Nom !"
}
Dire-Bonjour
Dire-Bonjour -Nom "Alice"

Fonction avec validation et types
function Get-UserInfo {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory, Position=0)]
        [string]$Serveur,

        [Parameter(Mandatory)]
        [ValidateRange(1,65535)]
        [int]$Port = 443,

        [switch]$VerboseOutput
    )

    if ($VerboseOutput) { Write-Verbose "Connexion à $Serveur:$Port" }

    # Retourner un objet structuré
    return [PSCustomObject]@{
        Serveur  = $Serveur
        Port     = $Port
        Statut   = "OK"
        Timestamp = Get-Date
    }
}

Fonctions avec pipeline
function Convertir-Taille {
    process {
        $_ / 1MB  # $_ = objet courant dans le pipeline
    }
}
Get-ChildItem -Recurse -File | Select-Object -ExpandProperty Length | Convertir-Taille

Gestionnaire d'erreurs dans une fonction
function Lire-Config {
    param([string]$Chemin)
    try {
        $contenu = Get-Content $Chemin -Raw -ErrorAction Stop
        return $contenu | ConvertFrom-Json
    }
    catch [System.IO.FileNotFoundException] {
        Write-Warning "Fichier non trouvé : $Chemin"
        return $null
    }
    catch {
        Write-Error "Erreur inattendue : $_"
        throw
    }
    finally {
        Write-Verbose "Lecture terminée"
    }
}

Gestion des erreurs

# $ErrorActionPreference
$ErrorActionPreference = "Stop"             # Toute erreur devient terminale
$ErrorActionPreference = "SilentlyContinue"# Ignorer les erreurs

-ErrorAction par commande
Get-Item "inexistant" -ErrorAction SilentlyContinue
Get-Item "inexistant" -ErrorAction Stop

Try / Catch / Finally
try {
    $r = Invoke-RestMethod "https://api.exemple.com/data" -ErrorAction Stop
}
catch [System.Net.WebException] {
    Write-Warning "Erreur réseau : $($_.Exception.Message)"
}
catch {
    Write-Error "Erreur : $_"
}
finally {
    # Toujours exécuté
}

$? = succès de la dernière commande
Get-Item "fichier.txt"
if (-not $?) { Write-Error "Échec" }

JSON / CSV / XML

# JSON
$obj | ConvertTo-Json                           # Objet → JSON
$obj | ConvertTo-Json -Depth 10                 # Profondeur (défaut: 2)
$json = Get-Content "data.json" -Raw | ConvertFrom-Json
$obj | ConvertTo-Json | Out-File "data.json" -Encoding utf8

CSV
$data | Export-Csv   "rapport.csv" -NoTypeInformation -Encoding UTF8
$data = Import-Csv   "rapport.csv"
$data | Export-Csv   "rapport.csv" -Append -NoTypeInformation

XML
[xml]$xml = Get-Content "config.xml"
$xml.configuration.appSettings.add | Where-Object key -eq "port"

Variables d'environnement
$env:PATH
$env:COMPUTERNAME
[System.Environment]::GetEnvironmentVariable("PATH", "Machine")     # Persistant
[System.Environment]::SetEnvironmentVariable("MYVAR", "val", "User") # Persistant

Commandes essentielles

# Aide
Get-Help Get-Process -Full
Get-Help Get-Process -Examples
Get-Command -Name "service"             # Trouver une commande
Get-Member -InputObject $objet            # Explorer les méthodes/propriétés

Modules
Get-Module -ListAvailable
Import-Module ActiveDirectory
Install-Module -Name PSWindowsUpdate -Scope CurrentUser

Mesurer le temps d'exécution
Measure-Command { Get-ChildItem C:\ -Recurse }

Variables spéciales
$true, $false, $null                      # Booléens et null
$_                                        # Objet courant dans pipeline
$PSVersionTable                           # Version PowerShell
$PSScriptRoot                             # Dossier du script en cours
$MyInvocation.MyCommand.Name             # Nom du script/fonction
$args                                     # Arguments non-nommés