RUBRIQUE
Variables de préférence
DESCRIPTION COURTE
Variables qui personnalisent le comportement de Windows PowerShell
DESCRIPTION LONGUE
Windows PowerShell inclut un jeu de variables qui vous permettent
de personnaliser son comportement. Ces " variables de préférence "
fonctionnent comme les options des systèmes basés sur une interface
utilisateur graphique.
Les variables de préférence affectent l'environnement
d'exploitation de Windows PowerShell et toutes les commandes
exécutées dans celui-ci. Bien souvent, les applets de commande
ont des paramètres que vous pouvez utiliser pour remplacer le
comportement de préférence d'une commande spécifique.
Le tableau suivant répertorie les variables de préférence et leur
valeur par défaut.
Variable Valeur par défaut
-------- -------------
$ConfirmPreference High
$DebugPreference SilentlyContinue
$ErrorActionPreference Continue
$ErrorView NormalView
$FormatEnumerationLimit 4
$LogCommandHealthEvent False (non enregistré)
$LogCommandLifecycleEvent False (non enregistré)
$LogEngineHealthEvent True (enregistré)
$LogEngineLifecycleEvent True (enregistré)
$LogProviderLifecycleEvent True (enregistré)
$LogProviderHealthEvent True (enregistré)
$MaximumAliasCount 4096
$MaximumDriveCount 4096
$MaximumErrorCount 256
$MaximumFunctionCount 4096
$MaximumHistoryCount 64
$MaximumVariableCount 4096
$OFS (Espace (" "))
$OutputEncoding Objet ASCIIEncoding
$ProgressPreference Continue
$PSEmailServer (Aucune)
$PSSessionApplicationName WSMAN
$PSSessionConfigurationName https://schemas.microsoft.com/powershell/microsoft.powershell
$PSSessionOption (Voir ci-dessous)
$VerbosePreference SilentlyContinue
$WarningPreference Continue
$WhatIfPreference 0
Windows PowerShell inclut également les variables d'environnement
suivantes, qui stockent les préférences utilisateur. Pour plus
d'informations sur les variables d'environnement, consultez
about_environment_variables.
Variable
--------
PSModulePath
UTILISATION DES VARIABLES DE PRÉFÉRENCE
Ce document décrit chacune des variables de préférence.
Pour afficher la valeur actuelle d'une variable de préférence
spécifique, tapez le nom de la variable. En réponse, Windows
PowerShell fournit la valeur. Par exemple, la commande suivante
affiche la valeur de la variable $ConfirmPreference.
PS> $ConfirmPreference
High
Pour modifier la valeur d'une variable, utilisez une instruction
d'assignation. Par exemple, l'instruction suivante affecte la
valeur " Medium " (Moyenne) à la variable $ConfirmPreference.
PS> $ConfirmPreference = "Medium"
Comme pour toutes les variables, les valeurs que vous définissez
sont spécifiques à la fenêtre Windows PowerShell actuelle. Pour
qu'elles deviennent effectives dans toutes les fenêtres Windows
PowerShell, ajoutez-les à votre profil Windows PowerShell. Pour plus
d'informations, consultez about_profiles.
TRAVAIL À DISTANCE
Lorsque vous exécutez des commandes sur un ordinateur distant, les
commandes distantes sont uniquement soumises au jeu de préférences
du client Windows PowerShell de l'ordinateur distant. Par exemple,
lorsque vous exécutez une commande distante, la valeur de la variable
$DebugPreference de l'ordinateur distant détermine comment Windows
PowerShell répond aux messages de débogage.
Pour plus d'informations sur les commandes distantes, consultez
about_remote.
$ConfirmPreference
------------------
Détermine quelles actions d'applet de commande demandent
automatiquement la confirmation de l'utilisateur avant exécution.
Lorsque la valeur de $ConfirmPreference (High, Medium, Low, None
[Élevée, Moyenne, Faible, Aucune]) est supérieure ou égale au
risque de l'action d'applet de commande (High, Medium, Low, None),
Windows PowerShell demande automatiquement la confirmation de
l'utilisateur avant d'exécuter l'action.
Vous pouvez utiliser le paramètre Confirm d'une applet de
commande pour remplacer la préférence pour une commande spécifique.
Valeurs valides :
None (Aucune) : Aucune action d'applet de commande
n'est confirmée automatiquement.
Les utilisateurs doivent utiliser
le paramètre Confirm pour demander
la confirmation de commandes spécifiques.
Low (Faible) : Les actions d'applet de commande
avec un risque faible, moyen ou élevé
sont automatiquement confirmées. Pour
supprimer la confirmation d'une
commande spécifique, utilisez
-Confirm:$false.
Medium: Les actions d'applet de commande avec
(Moyenne) un risque moyen ou élevé sont automatiquement
confirmées. Pour activer la confirmation
d'une commande spécifique, utilisez -confirm.
Pour supprimer la confirmation d'une
commande spécifique, utilisez confirm:$false.
High: Les actions d'applet de commande avec
(Élevée, unrisque élevé sont automatiquement confirmées.
valeur par défaut) Pour activer la confirmation d'une commande
spécifique, utilisez -confirm. Pour supprimer la
confirmation d'une commande spécifique, utilisez
-confirm:$false.
EXPLICATION DÉTAILLÉE
Lorsqu'une action d'applet de commande affecte considérablemen
t le système, par exemple lorsqu'elle supprime des données ou
utilise de nombreuses ressources système, Windows PowerShell
peut vous inviter automatiquement à la confirmer avant son
exécution.
Par exemple :
PS> remove-item pref2.txt
Confirmer
Êtes-vous sûr de vouloir effectuer cette action ?
Opération " Supprimer le fichier " en cours sur la cible
" C:\pref2.txt ".
[O] Oui [T] Oui pour tout [N] Non [U] Non pour tout [S]
Suspendre [?] Aide (la valeur par défaut est " O ") :
L'évaluation du risque correspond à la partie de l'applet de
commande appelée " ConfirmImpact ". Vous ne pouvez pas
modifier cette partie.
Une applet de commande susceptible de représenter un risque
pour le système comporte un paramètre Confirm, que vous
pouvez utiliser pour demander ou supprimer la confirmation
pour une commande spécifique.
Parce que la plupart des applets de commande utilisent la
valeur de risque par défaut Medium et que la valeur par défaut
de $ConfirmPreference est High, la confirmation automatique
a rarement lieu. Toutefois, vous pouvez activer la
confirmation automatique en remplaçant la valeur de
$ConfirmPreference Medium par Low.
EXEMPLES
Cet exemple montre l'effet de la valeur par défaut de
$ConfirmPreference. La valeur High confirme uniquement les
actions d'applet de commande à haut risque. Étant donné que la
plupart des actions représentent un risque moyen, elles ne sont
pas automatiquement confirmées, bien que vous puissiez utiliser
le paramètre Confirm de l'applet de commande pour demander la
confirmation d'une commande spécifique.
PS> $confirmpreference #Obtenir la valeur actuelle de la variable
High
PS> remove-item temp1.txt #Supprimer un fichier
PS> #Supprimé sans confirmation
PS> remove-item temp2.txt -confirm #Utiliser le paramètre Confirm
Confirmer
Êtes-vous sûr de vouloir effectuer cette action ?
Opération " Supprimer le fichier " en cours sur la cible
" C:\temp2.txt ".
[O] Oui [T] Oui pour tout [N] Non [U] Non pour tout [S]
Suspendre [?] Aide (la valeur par défaut est " O ") :
Cet exemple montre l'effet du remplacement de la valeur de
$ConfirmPreference par Medium. Étant donné que la plupart des
actions d'applet de commande représentent un risque moyen,
elles sont automatiquement confirmées et vous devez utiliser
le paramètre Confirm avec une valeur $false pour supprimer
la demande de confirmation pour une commande spécifique.
PS> $confirmpreference = "Medium"
#Modifier la valeur de $ConfirmPreference
PS> remove-item temp2.txt
#La suppression d'un fichier
déclenche la confirmation
Confirmer
Êtes-vous sûr de vouloir effectuer cette action ?
Opération " Supprimer le fichier " en cours sur la cible
" C:\temp2.txt ".
[O] Oui [T] Oui pour tout [N] Non [U] Non pour tout [S]
Suspendre [?] Aide (la valeur par défaut est " O ") :
PS> remove-item temp3.txt -confirm:$false #Utiliser le
paramètre Confirm pour supprimer la confirmation
PS>
$DebugPreference
------------------
Détermine comment Windows PowerShell répond aux messages de débogage
générés par un script, une applet de commande ou un fournisseur,
ou par une commande Write-Debug à la ligne de commande.
Certaines applets de commande affichent des messages de
débogage, qui sont généralement des messages très techniques,
conçus pour les programmeurs et les professionnels du
support technique. Par défaut, les messages de débogage
ne s'affichent pas, mais vous pouvez les afficher en
modifiant la valeur de $DebugPreference.
Vous pouvez également utiliser le paramètre courant Debug
d'une applet de commande pour afficher ou masquer les
messages de débogage pour une commande spécifique. Pour plus
d'informations, tapez : " get-help about_commonparameters ".
Valeurs valides :
Stop (Arrêter) : Affiche le message de débogage
et arrête l'exécution.
Écrit une erreur sur la console.
Inquire (Demander) : Affiche le message de
débogage et vous demande
si vous souhaitez continuer.
Continue (Continuer) : Affiche le message
de débogage et continue
l'exécution.
SilentlyContinue : Aucun effet. Le message de
(Continuer en mode débogage n'est pas affiché
silencieux, valeur et l'exécution continue
par défaut) sans interruption.
EXEMPLES
Les exemples suivants montrent l'effet de la modification des
valeurs de $DebugPreference lorsqu'une commande Write-Debug est
entrée à la ligne de commande. La modification affecte tous les
messages de débogage, y compris ceux générés par les applets de
commande et les scripts. Les exemples montrent également
l'utilisation du paramètre courant Debug, qui affiche ou masque
les messages de débogage liés à une commande simple.
Cet exemple montre l'effet de la valeur par défaut " SilentlyConti
nue " (Continuer en mode silencieux). Le message de débogage
n'est pas affiché et le traitement continue. La dernière commande
utilise le paramètre Debug pour remplacer la préférence pour une
commande simple.
PS> $debugpreference # Obtenir la valeur actuelle de
SilentlyContinue $DebugPreference
PS> write-debug "Bonjour le monde"
PS> # Le message de débogage
n'est pas affiché.
PS> write-debug "Bonjour # Utiliser le paramètre Debug
le monde" -Debug
DÉBOGUER : Bonjour le monde Le message de
débogage est demandé
Confirmer
Voulez-vous continuer cette opération ?
[O] Oui [T] Oui pour tout [I] Interrompre la commande [S]
Suspendre [?] Aide (" O " par défaut) :
Cet exemple montre l'effet de la valeur " Continue " (Continuer).
La dernière commande utilise le paramètre Debug avec une valeur
$false pour supprimer le message pour une commande simple.
PS> $debugpreference = "Continue" # Remplacer la valeur par
" Continue " (Continuer)
PS> write-debug "Bonjour le monde"
DÉBOGUER : Bonjour le monde # Le message de
débogage est affiché
et le traitement continue.
PS>
PS> write-debug "Bonjour le monde" -Debug:$false
# Utiliser le paramètre
Debug avec la valeur
" false " (faux).
PS> # Le message de débogage
n'est pas affiché.
Cet exemple montre l'effet de la valeur " Stop " (Arrêter). La
dernière commande utilise le paramètre Debug avec une valeur
$false pour supprimer le message pour une commande simple.
PS> $debugpreference = "Stop" # Remplacer la valeur par
" Stop " (Arrêter)
PS> write-debug "Bonjour le monde"
DÉBOGUER : Bonjour le monde
Write-Debug : L'exécution de la commande s'est arrêtée, car
la variable d'interpréteur de commandes " DebugPreference " a
la valeur Stop.
À la ligne : 1 Caractère : 12
+ write-debug <<<< "Bonjour le monde"
PS> write-debug "Bonjour le monde" -Debug:$false
# Utiliser le paramètre
Debug avec $false
PS> # Le message de débogage
n'est pas affiché
et le traitement
n'est pas arrêté.
Cet exemple montre l'effet de la valeur " Inquire " (Demander).
La dernière commande utilise le paramètre Debug avec une valeur
$false pour supprimer le message pour une commande simple.
PS> $debugpreference = "Inquire"
PS> write-debug "Bonjour le monde"
DÉBOGUER : Bonjour le monde
Confirmer
Voulez-vous continuer cette opération ?
[O] Oui [T] Oui pour tout [I] Interrompre la commande [S]
Suspendre [?] Aide (" O " par défaut) :
PS> write-debug "Bonjour le monde" -Debug:$false
# Utiliser le paramètre
Debug avec $false
PS> # Le message de débogage
n'est pas affiché
et le traitement continue
sans interruption.
$ErrorActionPreference
----------------------
Détermine comment Windows PowerShell répond à une erreur sans fin
d'exécution (erreur qui n'arrête pas le traitement d'applet de
commande) à la ligne de commande ou dans un script, une applet
de commande ou un fournisseur, telle que les erreurs générées
par l'applet de commande Write-Error.
Vous pouvez également utiliser le paramètre courant
ErrorAction d'une applet de commande pour remplacer la
préférence pour une commande spécifique. Pour plus
d'informations, tapez : " get-help about_commonparameters ".
Valeurs valides :
Stop (Arrêter) : Affiche le message d'erreur et
arrête l'exécution.
Inquire (Demander) : Affiche le message
d'erreur et vous demande
si vous souhaitez continuer.
Continue (Continuer) : Affiche le message
d'erreur et continue
l'exécution.
SilentlyContinue: Aucun effet. Le message
(Continuer en mode d'erreur n'est pas
silencieux, valeur affiché et l'exécution
par défaut) continue sans interruption.
Ni $ErrorActionPreference, ni le paramètre courant ErrorAction
n'affectent la façon dont Windows PowerShell répond aux
erreurs avec fin d'exécution (celles qui arrêtent le
traitement d'applet de commande).
Pour plus d'informations sur le paramètre courant ErrorAction,
tapez " get-help about_commonparameters ".
EXEMPLES
Ces exemples montrent l'effet des différentes valeurs de
$ErrorActionPreference et l'utilisation du paramètre courant
ErrorAction pour remplacer la préférence pour une commande
simple. Le paramètre ErrorAction a les mêmes valeurs valides que
la variable $ErrorActionPreference.
Cet exemple montre l'effet de la valeur " Continue " (Continuer),
qui est la valeur par défaut.
PS> $erroractionpreference
Continue # Afficher la valeur de la préférence.
PS> write-error "Bonjour le monde"
# Générer une erreur sans fin d'exécution.
write-error "Bonjour le monde" : Bonjour le monde
# Le message d'erreur est affiché et
l'exécution continue.
PS> write-error "Bonjour le monde" -ErrorAction:SilentlyContinue
# Utiliser le paramètre ErrorAction
avec une valeur " SilentlyContinue "
(Continuer en mode silencieux).
PS>
# Le message d'erreur n'est pas affiché et
l'exécution continue.
Cet exemple montre l'effet de la valeur " SilentlyContinue "
(Continuer en mode silencieux).
PS> $ErrorActionPreference = "SilentlyContinue"
# Modifier la valeur de la préférence.
PS> write-error "Bonjour le monde"
# Générer un message d'erreur.
PS>
# Le message d'erreur est supprimé.
PS> write-error "Bonjour le monde" -erroraction:continue
# Utiliser le paramètre ErrorAction
avec une valeur " Continue " (Continuer).
write-error "Bonjour le monde" -erroraction:continue :
Bonjour le monde
# Le message d'erreur est affiché et
l'exécution continue.
Cet exemple montre l'effet d'une vraie erreur. Dans ce cas, la
commande obtient un fichier inexistant, nofile.txt. L'exemple
utilise également le paramètre courant ErrorAction pour remplacer
la préférence.
PS> $erroractionpreference
SilentlyContinue # Afficher la valeur de la préférence.
PS> get-childitem -path nofile.txt
PS> # Le message d'erreur est supprimé.
PS> $ErrorActionPreference = "Continue"
# Remplacer la valeur par
" Continue " (Continuer).
PS> get-childitem -path nofile.txt
Get-ChildItem : Impossible de trouver le chemin d'accès
" C:\nofile.txt ", car il n'existe pas.
À la ligne : 1 Caractère : 4
+ get-childitem <<<< nofile.txt
PS> get-childitem -path nofile.txt -erroraction SilentlyContinue
# Utiliser le paramètre ErrorAction
PS>
# Le message d'erreur est supprimé.
PS> $ErrorActionPreference = "Inquire"
# Remplacer la valeur par " Inquire "
(Demander).
PS> get-childitem -path nofile.txt
Confirmer
Impossible de trouver le chemin d'accès " C:\nofile.txt ",
car il n'existe pas.
[O] Oui [T] Oui pour tout [I] Interrompre la commande [S]
Suspendre [?] Aide (" O " par défaut) : o
Get-ChildItem : Impossible de trouver le chemin d'accès
" C:\nofile.txt ", car il n'existe pas.
À la ligne : 1 Caractère : 4
+ get-childitem <<<< nofile.txt
PS> $ErrorActionPreference = "Continue"
# Remplacer la valeur par
" Continue " (Continuer).
PS> Get-Childitem nofile.txt -erroraction "Inquire"
# Utiliser le paramètre ErrorAction
pour remplacer la valeur de préférence.
Confirmer
Impossible de trouver le chemin d'accès " C:\nofile.txt ",
car il n'existe pas. [O] Oui [T] Oui pour tout [I]
Interrompre la commande [S] Suspendre [?] Aide (" O " par défaut) :
$ErrorView
----------
Détermine le format d'affichage des messages d'erreur dans
Windows PowerShell.
Valeurs valides :
NormalView : Une vue détaillée conçue pour la plupart
(valeur par défaut) des utilisateurs. Comprend une description
de l'erreur, le nom de l'objet impliqué dans
l'erreur et des flèches (<<<<) qui pointent
vers les mots de la commande qui ont
provoqué l'erreur.
CategoryView : Une vue succincte, structurée, conçue pour
les environnements de production.
Le format est : {Category}:
({TargetName}:{TargetType}):[{Activity}],
{Reason}
Pour plus d'informations sur les champs de CategoryView,
consultez " Classe ErrorCategoryInfo " dans le Kit de
développement logiciel (SDK) Windows PowerShell.
EXEMPLES
Ces exemples montrent l'effet des valeurs ErrorView.
Cet exemple montre comment une erreur apparaît lorsque la valeur
de $ErrorView est NormalView. Dans ce cas, la commande
Get-ChildItem est utilisée pour rechercher un fichier inexistant.
PS> $ErrorView # Vérifier la valeur.
NormalView
PS> get-childitem nofile.txt # Rechercher un fichier inexistant.
Get-ChildItem : Impossible de trouver le chemin d'accès " C:\nofile.txt ",
car il n'existe pas.
À la ligne : 1 Caractère : 14
+ get-childitem <<<< nofile.txt
Cet exemple montre comment la même erreur apparaît lorsque la
valeur de $ErrorView est CategoryView.
PS> $ErrorView = "CategoryView" # Remplacer la
valeur par
CategoryView
PS> get-childitem nofile.txt
ObjectNotFound: (C:\nofile.txt:String) [Get-ChildItem], ItemNotFoundException
Cet exemple montre que la valeur de ErrorView affecte seulement
l'affichage de l'erreur et pas la structure de l'objet erreur
stocké dans la variable automatique $error. Pour plus
d'informations sur la variable automatique $error, consultez
about_automatic_variables.
Cette commande prend l'objet ErrorRecord associé à l'erreur la
plus récente du tableau d'erreurs (élément 0) et met en forme
toutes les propriétés de l'objet erreur dans une liste.
PS> $error[0] | format-list -property * -force
Exception : System.Management.Automation.ItemNotFoundException : Impossible de trouver
le chemin d'accès " C:\nofile.txt ", car il n'existe pas. at
System.Management.Automation.SessionStateInternal.GetChildItems
(String path, Boolean recurse, CmdletProviderContext context) at
System.Management.Automation.ChildItemCmdletProviderIntrinsics.Get
(String path, Boolean recurse, CmdletProviderContext context) at
Microsoft.PowerShell.Commands.GetChildItemCommand.ProcessRecord() :
TargetObject : C:\nofile.txt
CategoryInfo : ObjectNotFound: (C:\nofile.txt : String) [Get-ChildItem],
ItemNotFoundException
FullyQualifiedErrorId : PathNotFound,Microsoft.PowerShell.Commands.GetChildItemCommand :
ErrorDetails :
InvocationInfo : System.Management.Automation.InvocationInfo
$FormatEnumerationLimit
-----------------------
Détermine le nombre d'éléments énumérés inclus dans un
affichage. Cette variable n'affecte pas les objets
sous-jacents ; simplement l'affichage. Lorsque la valeur
de $FormatEnumerationLimit est inférieure au nombre
d'éléments énumérés, Windows PowerShell ajoute des
points de suspension (...) pour indiquer que certains
éléments ne sont pas affichés.
Valeurs valides : nombres entiers (Int32)
Valeur par défaut : 4
EXEMPLES
Cet exemple montre comment utiliser la variable
$FormatEnumerationLimit pour améliorer l'affichage d'éléments
énumérés.
La commande de cet exemple génère une table qui répertorie
tous les services s'exécutant sur l'ordinateur en deux
groupes ; un pour les services en cours d'exécution, un pour
les services arrêtés. Elle utilise une commande Get-Service
pour obtenir tous les services, puis envoie les résultats à
travers le pipeline à l'applet de commande Group-Object, qui
groupe les résultats par état de service.
L'affichage résultant est une table qui répertorie l'état
dans la colonne Nom et les processus présentant cet état dans
la colonne Groupe. (Pour modifier les noms de colonne,
utilisez une table de hachage. Pour plus d'informations,
consultez les exemples de " get-help format-table -examples ".)
Au maximum, 4 services sont répertoriés dans la colonne
Groupe pour chaque état. Pour accroître le nombre d'éléments
répertoriés, augmentez la valeur de $FormatEnumerationLimit à
1000.
Dans l'affichage résultant, la liste de la colonne Groupe est
maintenant limitée par la longueur de ligne. Dans la dernière
commande de l'exemple, utilisez le paramètre Wrap de
Format-Table pour afficher tous les processus de chaque
groupe État.
PS> $formatenumerationlimit # Rechercher la valeur actuelle
4
PS> get-service | group-object -property status
# Répertorier tous les
services regroupés par état
Nombre Nom Groupe
----- ---- -----
60 Running {AdtAgent, ALG, Ati HotKey Poller, AudioSrv...}
41 Stopped {Alerter, AppMgmt, aspnet_state, ATI Smart...}
# La liste est tronquée
après 4 éléments.
PS> $formatenumerationlimit = 1000
# Augmenter la limite à 1000.
PS> get-service | group-object -property status
# Répéter la commande.
Nombre Nom Groupe
----- ---- -----
60 Running {AdtAgent, ALG, Ati HotKey Poller, AudioSrv, BITS, CcmExec...
41 Stopped {Alerter, AppMgmt, aspnet_state, ATI Smart, Browser, CiSvc...
PS> get-service | group-object -property status |
format-table -wrap
# Ajouter le paramètre Wrap.
Nombre Nom Groupe
----- ---- -----
60 Running {AdtAgent, ALG, Ati HotKey Poller, AudioSrv, BITS, CcmExec,
Client for NFS, CryptSvc, DcomLaunch, Dhcp, dmserver, Dnscache,
ERSvc, Eventlog, EventSystem, FwcAgent, helpsvc, HidServ, IISADMIN,
InoRPC, InoRT, InoTask, lanmanserver, lanmanworkstation, LmHosts,
MDM, Netlogon, Netman, Nla, NtLmSsp, PlugPlay, PolicyAgent,
ProtectedStorage, RasMan, RemoteRegistry, RpcSs, SamSs, Schedule,
seclogon, SENS, SharedAccess, ShellHWDetection, SMT PSVC, Spooler,
srservice, SSDPSRV, stisvc, TapiSrv, TermService, Themes, TrkWks,
UMWdf, W32Time, W3SVC, WebClient, winmgmt, wscsvc, wuauserv,
ZCSVC, zzInterix}
41 Stopped {Alerter, AppMgmt, aspnet_state, ATI Smart, Browser, CiSvc,
ClipSrv, clr_optimization_v2.0.50727_32, COMSysApp, CronService,
dmadmin, FastUserSwitchingCompatibility, HTTPFilter, ImapiService,
Mapsvc, Messenger, mnmsrvc, MSDTC, MSIServer, msvsmon80,
NetDDE, NetDDEdsdm, NtmsSvc, NVSvc, ose, RasAuto, RDSessMgr,
RemoteAccess, RpcLocator, RSVP, SCardSvr, SwPrv, SysmonLog,
TlntSvr, upnphost, UPS, VSS, WmdmPmSN, Wmi, WmiApSrv, xmlprov}
$Log*Event
----------
Les variables de préférence Log*Event déterminent quels types
d'événements sont écrits dans le journal des événements
Windows PowerShell de l'Observateur d'événements. Par défaut,
seuls les événements de moteur et de fournisseur sont
enregistrés, mais vous pouvez utiliser les variables de
préférence Log*Event pour personnaliser votre journal, par
exemple pour qu'il enregistre les événements de commande.
Les variables de préférence Log*Event sont comme suit :
$LogCommandHealthEvent : Enregistre les erreurs et exceptions
survenues lors de l'initialisation et du traitement de
commandes. Valeur par défaut = $false (non enregistré).
$LogCommandLifecycleEvent :
Enregistre le démarrage et l'arrêt de commandes et de
pipelines de commandes, ainsi que les exceptions de
sécurité survenues lors de la découverte de commande.
Valeur par défaut = $false (non enregistré).
$LogEngineHealthEvent : Enregistre les erreurs et
défaillances des sessions. Valeur par
défaut = $true (enregistré).
$LogEngineLifecycleEvent : Enregistre l'ouverture et la
fermeture des sessions. Valeur par défaut = $true (enregistré).
$LogProviderHealthEvent : Enregistre les erreurs de fournisseur,
telles que les erreurs en lecture et en écriture,
les erreurs de recherche et les erreurs d'appel.
Valeur par défaut = $true (enregistré).
$LogProviderLifecycleEvent : Enregistre l'ajout et la
suppression de fournisseurs Windows PowerShell.
Valeur par défaut = $true (enregistré). (Pour plus
d'informations sur les fournisseurs Windows
PowerShell, tapez : " get-help about_provider ".)
Pour activer une variable Log*Event, tapez la variable avec
une valeur $true, par exemple :
$LogCommandLifeCycleEvent
- ou -
$LogCommandLifeCycleEvent = $true
Pour désactiver un type d'événement, tapez la variable avec
une valeur $false, par exemple :
$LogCommandLifeCycleEvent = $false
Les événements que vous activez sont uniquement effectifs
pour la console Windows PowerShell actuelle. Pour appliquer
la configuration à toutes les consoles, enregistrez les
paramètres de variable dans votre profil Windows PowerShell.
$MaximumAliasCount
------------------
Détermine le nombre d'alias autorisés dans une session
Windows PowerShell. La valeur par défaut, 4096, doit suffire
pour la plupart des utilisations, mais vous pouvez l'ajuster
pour satisfaire vos besoins.
Valeurs valides : 1024 - 32768 (Int32)
Valeur par défaut : 4096
Pour compter les alias de votre système, tapez :
(get-alias).count
$MaximumDriveCount
------------------
Détermine le nombre de lecteurs Windows PowerShell autorisés
dans une session donnée. Ce nombre inclut les lecteurs de
système de fichiers et les magasins de données exposés par
les fournisseurs Windows PowerShell qui apparaissent en tant
que lecteurs, tels que les lecteurs Alias: et HKLM:.
Valeurs valides : 1024 - 32768 (Int32)
Valeur par défaut : 4096
Pour compter les alias de votre système, tapez :
(get-psdrive).count
$MaximumErrorCount
------------------
Détermine le nombre d'erreurs enregistrées dans l'historique
d'erreur pour la session.
Valeurs valides : 256 - 32768 (Int32)
Valeur par défaut : 256
Les objets qui représentent chaque erreur conservée sont
stockés dans la variable automatique $Error. Cette variable
contient un tableau d'objets d'enregistrements d'erreurs (un
objet pour chaque erreur). L'erreur la plus récente est
représentée par le premier objet du tableau ($Error[0]).
Pour compter les erreurs de votre système, utilisez la
propriété Count du tableau $Error. Tapez :
$Error.count
Pour afficher une erreur spécifique, utilisez la notation
sous forme de tableau. Par exemple, pour afficher l'erreur la
plus récente, tapez :
$Error[0]
Pour afficher l'erreur la plus ancienne, tapez :
$Error[($Error.Count -1]
Pour afficher les propriétés de l'objet ErrorRecord, tapez :
$Error[0] | format-list -property * -force
Dans cette commande, le paramètre Force remplace la mise en
forme spéciale des objets ErrorRecord et revient au format
classique.
Pour supprimer toutes les erreurs de l'historique d'erreur,
utilisez la méthode Clear du tableau d'erreurs.
PS> $Error.count
17
PS> $Error.clear()
PS>
PS> $Error.count
0
Pour rechercher toutes les propriétés et méthodes d'un tableau
d'erreurs, utilisez l'applet de commande Get-Member avec son
paramètre InputObject. Lorsque vous redirigez une collection
d'objets vers Get-Member, Get-Member affiche les propriétés et
méthodes des objets de la collection. Lorsque vous utilisez le
paramètre InputObject de Get-Member, Get-Member affiche les
propriétés et méthodes de la collection.
$MaximumFunctionCount
------------------
Détermine le nombre de fonctions autorisées dans une session
donnée.
Valeurs valides : 1024 - 32768 (Int32)
Valeur par défaut : 4096
Pour afficher les fonctions de votre session, utilisez le
lecteur Function: de Windows PowerShell, exposé par le
fournisseur Function de Windows PowerShell. (Pour plus
d'informations sur le fournisseur Function, tapez
" get-help function ".)
Pour répertorier les fonctions de la session active, tapez :
get-childitem function:
Pour compter les fonctions de la session active, tapez :
(get-childitem function:).count
$MaximumHistoryCount
------------------
Détermine le nombre de commandes enregistrées dans
l'historique des commandes pour la session active.
Valeurs valides : 1 - 32768 (Int32)
Valeur par défaut : 64
Pour déterminer le nombre actuel de commandes enregistrées
dans l'historique des commandes, tapez :
(get-history).count
Pour afficher la commande enregistrée dans votre historique
de session, utilisez l'applet de commande Get-History. Pour
plus d'informations, tapez : " get-help about_history ".
$MaximumVariableCount
------------------
Détermine le nombre de variables autorisées dans une session
donnée, notamment les variables automatiques, variables de
préférence et variables que vous créez dans des commandes et
des scripts.
Valeurs valides : 1024 - 32768 (Int32)
Valeur par défaut : 4096
Pour afficher les variables de votre session, utilisez
l'applet de commande Get-Variable et les fonctionnalités
du lecteur Variable: de Windows PowerShell ainsi que le
fournisseur de variables Windows PowerShell. Pour plus
d'informations sur le fournisseur de variables, tapez
" get-help variable ".
Pour rechercher le nombre actuel de variables sur le système,
tapez :
(get-variable).count
$OFS
----
Séparateur des champs de sortie. Spécifie le caractère qui
sépare les éléments d'un tableau lorsque celui-ci est
converti en chaîne.
Valeurs valides : Toute chaîne.
Valeur par défaut : Espace
Par défaut, la variable $OFS n'existe pas et le séparateur
de fichier de sortie est un espace, mais vous pouvez ajouter
cette variable et la définir sur n'importe quelle chaîne.
EXEMPLES
Cet exemple montre qu'un espace est utilisé pour séparer les
valeurs lorsqu'un tableau est converti en chaîne. Dans ce cas,
un tableau de nombres entiers est stocké dans une variable,
puis la variable est transtypée en chaîne.
PS> $array = 1,2,3 # Stocker un tableau de nombres
entiers.
PS> [chaîne]$array # Transtyper le tableau en chaîne.
1 2 3 # Des espaces séparent les éléments
Pour modifier le séparateur, ajoutez la variable $OFS en lui
affectant une valeur. Pour fonctionner correctement, la variable
doit être nommée $OFS.
PS> $OFS = "+" # Créer $OFS et lui affecter le
signe " + "
PS> [chaîne]$array # Répéter la commande
1+2+3 # Des signes " + " séparent
les éléments
Pour restaurer le comportement par défaut, vous pouvez affecter
un espace (" ") à la valeur de $OFS ou supprimer la variable.
Cette commande supprime la variable, puis vérifie que le
séparateur est un espace.
PS> Remove-Variable OFS # Supprimer $OFS
PS>
PS> [chaîne]$array # Répéter la commande
1 2 3 # Des espaces séparent les éléments
$OutputEncoding
---------------
Détermine la méthode d'encodage de caractères utilisée par
Windows PowerShell lorsqu'il envoie du texte à d'autres
applications. Par exemple, si une application retourne des
chaînes Unicode à Windows PowerShell, vous devrez peut-être
modifier la valeur pour envoyer les caractères correctement.
Valeurs valides : Objets dérivés d'une classe d'encodage, tels que
ASCIIEncoding, SBCSCodePageEncoding, UTF7Encoding,
UTF8Encoding, UTF32Encoding et UnicodeEncoding.
Valeur par défaut : Objet ASCIIEncoding (System.Text.ASCIIEncoding)
EXEMPLES
Cet exemple montre comment faire fonctionner la commande
FINDSTR de Windows dans Windows PowerShell sur un ordinateur
localisé pour une langue qui utilise des caractères Unicode,
telle que le chinois.
La première commande recherche la valeur de $OutputEncoding.
Étant donné que la valeur est un objet d'encodage, seule sa
propriété EncodingName est affichée.
PS> $OutputEncoding.EncodingName # Rechercher la valeur
actuelle US-ASCII
Dans cet exemple, une commande FINDSTR est utilisée pour
rechercher deux caractères chinois présents dans le fichier
Test.txt. Lorsque cette commande FINDSTR est exécutée dans
l'invite de commandes de Windows (Cmd.exe), FINDSTR recherche
les caractères dans le fichier texte. Toutefois, lorsque vous
exécutez la même commande FINDSTR dans Windows PowerShell, les
caractères sont introuvables car Windows PowerShell les envoie
à FINDSTR en texte ASCII, au lieu de les envoyer en texte Unicode.
PS> findstr <caractères-Unicode> # Utiliser findstr pour la
recherche.
PS> # Rien trouvé.
Pour que la commande fonctionne dans Windows PowerShell,
définissez la valeur de $OutputEncoding sur la valeur de la
propriété OutputEncoding de la console, basée sur les
paramètres régionaux sélectionnés pour Windows. Étant donné
que OutputEncoding est une propriété statique de la console,
utilisez des deux-points doubles (::) dans la commande.
PS> $OutputEncoding = [console]::outputencoding
PS> # Définir la valeur sur
celle de la propriété
OutputEncoding de la
console.
PS> $OutputEncoding.EncodingName
OEM États-Unis
# Rechercher la valeur
résultante.
Suite à cette modification, la commande FINDSTR recherche les
caractères.
PS> findstr <caractères-Unicode>
test.txt: <caractères-Unicode>
# Utiliser findstr pour effectuer
la recherche. La commande trouve
les caractères dans le fichier
texte.
$ProgressPreference
-------------------
Détermine la façon dont Windows PowerShell répond aux mises à jour
de progression générées par un script, une applet de commande ou
un fournisseur, telles que les barres de progression générées par
l'applet de commande Write-Progress. L'applet de commande
Write-Progress crée des barres de progression qui représentent
l'état d'une commande.
Valeurs valides :
Stop: N'affiche pas la barre de
(Arrêter) progression. Au lieu de cela,
affiche un message d'erreur et
arrête l'exécution.
Inquire: N'affiche pas la barre de progression.
(Demander) Demande l'autorisation de continuer.
Si vous répondez par O ou T,
affiche la barre de progression.
Continue: Affiche la barre de progression et continue
(Continuer, l'exécution.
valeur par défaut)
SilentlyContinue: Exécute la commande, mais n'affiche
(Continuer en pas la barre de progression.
mode silencieux)
$PSEmailServer
--------------
Spécifie le serveur de messagerie par défaut utilisé pour
envoyer des messages électroniques. Cette variable de
préférence est utilisée par les applets de commande qui
envoient des messages électroniques, telles que l'applet
de commande Send-MailMessage.
$PSSessionApplicationName
---------------------------
Spécifie le nom d'application par défaut pour une commande
distante qui utilise la technologie Gestion des services Web.
Le nom d'application système par défaut est WSMAN, mais vous
pouvez utiliser cette variable de préférence pour modifier la
valeur par défaut.
Le nom d'application est le dernier nœud d'un URI de connexion.
Par exemple, le nom d'application dans l'exemple d'URI suivant
est WSMAN.
http://Server01:8080/WSMAN
Le nom d'application par défaut est utilisé lorsque la
commande distante ne spécifie pas d'URI de connexion,
ni de nom d'application.
Le service WinRM utilise le nom d'application pour sélectionner
un écouteur pour traiter la demande de connexion. La valeur
de ce paramètre doit correspondre à la valeur de la propriété
URLPrefix d'un écouteur sur l'ordinateur distant.
Pour remplacer la valeur système par défaut et la valeur
de cette variable, et pour sélectionner un autre nom
d'application pour une session particulière, utilisez les
paramètres ConnectionURI ou ApplicationName des applets de
commande New-PSSession, Enter-PSSession ou Invoke-Command.
Cette variable de préférence est définie sur l'ordinateur
local, mais elle spécifie un écouteur sur l'ordinateur
distant. Si le nom d'application que vous spécifiez n'existe
pas sur l'ordinateur distant, la commande servant à établir
la session échoue.
$PSSessionConfigurationName
---------------------------
Spécifie la configuration de session par défaut, utilisée
pour les sessions PSSession créées dans la session active.
Cette variable de préférence est définie sur l'ordinateur
local, mais elle spécifie une configuration de session se
trouvant sur l'ordinateur distant.
La valeur de la variable $PSSessionConfigurationName
est un URI de ressource complet.
La valeur par défaut :
https://schemas.microsoft.com/powershell/microsoft.powershell
indique la configuration de session Microsoft.PowerShell de
l'ordinateur distant.
Si vous spécifiez uniquement un nom de configuration,
l'URI de schéma suivant est ajouté en tant que préfixe :
https://schemas.microsoft.com/powershell/
Vous pouvez remplacer la valeur par défaut et sélectionner
une configuration de session différente pour une session
particulière à l'aide du paramètre ConfigurationName des
applets de commande New-PSSession, Enter-PSSession ou
Invoke-Command.
Vous pouvez modifier la valeur de cette variable à tout
moment. Lorsque vous la modifiez, rappelez-vous que la
configuration de session que vous sélectionnez doit exister
sur l'ordinateur distant. Si tel n'est pas le cas, la commande
servant à créer une session qui utilise la configuration de
session échoue.
Cette variable de préférence ne détermine pas les configurations
de session locales utilisées lorsque des utilisateurs distants
créent une session qui se connecte à cet ordinateur. Toutefois,
vous pouvez utiliser les autorisations pour les configurations
de session locales afin de déterminer quels utilisateurs peuvent
utiliser ces dernières.
$PSSessionOption
----------------
Établit les valeurs par défaut pour les options d'utilisateur
expérimenté dans une session à distance. Ces préférences
d'option remplacent les valeurs système par défaut pour les
options de session.
Vous pouvez également définir des options personnalisées pour
une session à distance particulière en utilisant le paramètre
SessionOption dans des applets de commande qui créent une
session, telles que New-PSSession, Enter-PSSession et
Invoke-Command. La valeur de paramètre SessionOption est
prioritaire sur les valeurs système par défaut et les valeurs
par défaut définies dans cette variable.
La variable $PSSessionOption contient un objet PSSessionOption
(System.Management.Automation.Remoting.PSSessionObject).
Chaque propriété de l'objet représente une option de session.
Par exemple, la propriété NoCompression désactive la
compression de données pendant la session.
Pour créer la variable de préférence $PSSessionOption,
utilisez l'applet de commande New-PSSessionOption.
Enregistrez la sortie dans une variable appelée
$PSSessionOption.
Par exemple :
$PSSessionOption = New-PSSessionOption -NoCompression
Pour utiliser la variable de préférence $PSSessionOption dans
chaque session Windows PowerShell, ajoutez une commande
New-PSSessionOption qui crée la variable $PSSessionOption à
votre profil Windows PowerShell.
Pour plus d'informations sur l'applet de commande
New-PSSessionOption, consultez la rubrique d'aide
correspondante (New-PSSessionOption). Pour plus
d'informations sur les sessions et commandes distantes,
consultez about_Remote et about_PSSessions. Pour plus
d'informations sur l'utilisation d'un profil,
consultez about_Profiles.
$VerbosePreference
------------------
Détermine comment Windows PowerShell répond aux messages commentés
générés par un script, une applet de commande ou un fournisseur,
tels que les messages générés par l'applet de commande Write-Verbose.
En général, les messages commentés décrivent les actions
effectuées pour exécuter une commande.
Par défaut, les messages commentés ne sont pas affichés, mais
vous pouvez modifier ce comportement en modifiant la valeur de
$VerbosePreference.
Vous pouvez également utiliser le paramètre courant Verbose
d'une applet de commande pour afficher ou masquer les
messages commentés pour une commande spécifique. Pour plus
d'informations, tapez : " get-help about_commonparameters ".
Valeurs valides :
Stop (Arrêter) : Affiche le message commenté et
un message d'erreur, puis arrête l'exécution.
Inquire : Affiche le message commenté,
(Demander) puis une invite qui vous demande
si vous souhaitez continuer.
Continue: Affiche le message commenté,
(Continuer) puis continue l'exécution.
SilentlyContinue : N'affiche pas le message commenté.
(Continuer en Continue l'exécution.
mode silencieux,
valeur par défaut)
EXEMPLES
Ces exemples montrent l'effet des différentes valeurs de
$VerbosePreference et l'utilisation du paramètre courant
Verbose pour remplacer la valeur de préférence.
Cet exemple montre l'effet de la valeur " SilentlyContinue "
(Continuer en mode silencieux), qui est la valeur par défaut.
PS> $VerbosePreference # Rechercher la valeur actuelle.
SilentlyContinue
PS> Write-Verbose "Test de message commenté."
PS> # Écrire un message commenté.
# Le message n'est pas affiché.
PS> Write-Verbose "Test de message commenté." -verbose
COMMENTAIRES : test de message commenté.
# Utiliser le paramètre Verbose.
Cet exemple montre l'effet de la valeur " Continue " (Continuer).
PS> $VerbosePreference = "Continue"
# Remplacer la valeur par
" Continue " (Continuer).
PS> Write-Verbose "Test de message commenté."
# Écrire un message commenté.
COMMENTAIRES : test de message commenté.
# Le message est affiché.
PS> Write-Verbose "Test de message commenté." -verbose:$false
# Utiliser le paramètre
Verbose avec une valeur $false.
PS>
# Le message n'est pas affiché.
Cet exemple montre l'effet de la valeur " Stop " (Arrêter).
PS> $VerbosePreference = "Stop"
# Remplacer la valeur par
" Stop " (Arrêter).
PS> Write-Verbose "Test de message commenté."
# Écrire un message commenté.
COMMENTAIRES : test de message commenté.
Write-Verbose : L'exécution de la commande s'est arrêtée, car
la variable d'interpréteur de commandes " VerbosePreference "
a la valeur Stop.
À la ligne : 1 Caractère : 14
+ Write-Verbose <<<< "Test de message commenté."
PS> Write-Verbose "Test de message commenté." -verbose:$false
# Utiliser le paramètre
Verbose avec une valeur $false
# Le message n'est pas affiché.
Cet exemple montre l'effet de la valeur " Inquire " (Demander).
PS> $VerbosePreference = "Inquire"
# Remplacer la valeur par
" Inquire " (Demander).
PS> Write-Verbose "Test de message commenté."
COMMENTAIRES : test de message commenté.
# Écrire un message commenté.
Confirmer
Voulez-vous continuer cette opération ?
[O] Oui [T] Oui pour tout [I] Interrompre la commande [S]
Suspendre [?] Aide (" O " par défaut) : o
PS> Write-Verbose "Test de message commenté." -verbose:$false
# Utiliser le paramètre Verbose.
PS>
# Le message n'est pas affiché.
$WarningPreference
------------------
Détermine comment Windows PowerShell répond aux messages
d'avertissement générés par un script, une applet de commande
ou un fournisseur, tels que les messages générés par l'applet
de commande Write-Warning.
Par défaut, les messages d'avertissement sont affichés et
l'exécution continue, mais vous pouvez modifier ce
comportement en modifiant la valeur de $WarningPreference.
Vous pouvez également utiliser le paramètre courant
WarningAction d'une applet de commande pour déterminer
comment Windows PowerShell répond aux avertissements
provenant d'une commande particulière. Pour plus
d'informations, tapez : " get-help about_commonparameters ".
Valeurs valides :
Stop: Affiche le message d'avertissement et un
(Arrêter) message d'erreur, puis arrête l'exécution.
Inquire : Affiche le message d'avertissement,
(Demander) puis demande l'autorisation de continuer.
Continue : Affiche le message d'avertissement,
(Continuer, puis continue l'exécution.
valeur par défaut)
SilentlyContinue : N'affiche pas le message d'avertissement.
(Continuer en Continue l'exécution.
mode silencieux)
EXEMPLES
Ces exemples montrent l'effet des différentes valeurs de
$WarningPreference et l'utilisation du paramètre courant
WarningAction pour remplacer la valeur de préférence.
Cet exemple montre l'effet de la valeur " Continue " (Continuer),
qui est la valeur par défaut.
PS> $WarningPreference # Rechercher la valeur actuelle.
Continue
# Écrire un message d'avertissement.
PS> Write-Warning "Cette action peut supprimer des données."
AVERTISSEMENT : cette action peut supprimer des données.
# Utiliser le paramètre
# WarningAction pour
PS> Write-Warning "Cette action peut supprimer des données."
-warningaction silentlycontinue
Cet exemple montre l'effet de la valeur " SilentlyContinue "
(Continuer en mode silencieux).
PS> $WarningPreference = "SilentlyContinue"
# Remplacer la valeur par SilentlyContinue.
PS> Write-Warning "Cette action peut supprimer des données."
PS> # Écrire un message d'avertissement.
PS> Write-Warning "Cette action peut supprimer des données."
-warningaction stop
# Utiliser le paramètre
# WarningAction pour arrêter
# le traitement lorsque cette
# commande génère un.
AVERTISSEMENT : cette action peut supprimer des données.
Write-Warning : L'exécution de la commande s'est arrêtée,
car la variable d'interpréteur de commandes " WarningPreference "
a la valeur Stop.
À la ligne : 1 Caractère : 14
+ Write-Warning <<<< "Cette action peut supprimer des données."
-warningaction stop
Cet exemple montre l'effet de la valeur " Inquire " (Demander).
PS> $WarningPreference = "Inquire"
# Remplacer la valeur par
" Inquire " (Demander).
PS> Write-Warning "Cette action peut supprimer des données."
# Écrire un message
d'avertissement.
AVERTISSEMENT : cette action peut supprimer des données.
Confirmer
Voulez-vous continuer cette opération ?
[O] Oui [T] Oui pour tout [I] Interrompre la commande [S]
Suspendre [?] Aide (" O " par défaut) : o
PS> Write-Warning "Cette action peut supprimer des données."
-warningaction silentlycontinue
PS> # Utiliser le paramètre WarningAction
# pour modifier la réponse à un
# avertissement pour la commande actuelle.
Cet exemple montre l'effet de la valeur " Stop " (Arrêter).
PS> $WarningPreference = "Stop"
# Remplacer la valeur par
" Stop " (Arrêter).
PS> Write-Warning "Cette action peut supprimer des données."
# Écrire un message d'avertissement.
AVERTISSEMENT : cette action peut supprimer des données.
Write-Warning : L'exécution de la commande s'est arrêtée,
car la variable d'interpréteur de commandes " WarningPrefer
ence " a la valeur Stop.
À la ligne : 1 Caractère : 14
+ Write-Warning <<<< "Cette action peut supprimer des données."
PS> Write-Warning "Cette action peut supprimer des données."
-warningaction inquire
AVERTISSEMENT : cette action peut supprimer des données.
Confirmer
Voulez-vous continuer cette opération ?
[O] Oui [T] Oui pour tout [I] Interrompre la commande [S]
Suspendre [?] Aide (" O " par défaut) :
# Utiliser le paramètre WarningAction
# pour modifier la réponse à un
# avertissement pour la commande actuelle.
$WhatIfPreference
------------------
Détermine si le paramètre WhatIf est activé automatiquement
pour chaque commande qui le prend en charge. Lorsque WhatIf
est activé, l'applet de commande signale l'effet attendu de
la commande, mais n'exécute pas cette dernière.
Valeurs valides :
0 : WhatIf n'est pas activé automatiquement.
(valeur par défaut) Pour l'activer manuellement, utilisez le
paramètre WhatIf de la commande.
1 : WhatIf est activé automatiquement sur
toute commande qui le prend en charge.
Les utilisateurs peuvent utiliser la
commande WhatIf avec une valeur False
pour la désactiver manuellement
(WhatIf:$false).
EXPLICATION DÉTAILLÉE
Lorsqu'une applet de commande prend en charge WhatIf, elle
signale l'effet attendu de la commande au lieu de l'exécuter.
Par exemple, au lieu de supprimer le fichier test.txt en
réponse à une commande Remove-Item, Windows PowerShell
signale ce qu'il supprimerait. Une commande Get-Childitem
suivante confirme que le fichier n'a pas été supprimé.
PS> remove-item test.txt
What if: Opération " Remove-Item " en cours sur la
cible " Élément : C:\test.txt "
PS> get-childitem test.txt
Directory: Microsoft.PowerShell.Core\FileSystem::C:
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a--- 29/07/2006 19:15 84 test.txt
EXEMPLES
Ces exemples montrent l'effet des différentes valeurs de
$WhatIfPreference. Ils indiquent également comment utiliser
le paramètre d'applet de commande WhatIf pour remplacer la
valeur de préférence pour une commande spécifique.
Cet exemple montre l'effet de la valeur 0 (non activé), qui est
la valeur par défaut.
PS> $whatifpreference
0 # Vérifier la valeur actuelle.
PS> get-childitem test.txt | format-list FullName
FullName : C:\test.txt
# Vérifier que le fichier existe.
PS> remove-item test.txt
PS> # Supprimer le fichier.
PS> get-childitem test.txt | format-list -property FullName
# Vérifier que le fichier est
supprimé.
Get-ChildItem : Impossible de trouver le chemin d'accès
" C:\test.txt ", car il n'existe pas.
À la ligne : 1 Caractère : 14
+ get-childitem <<<< test.txt | format-list fullname
Cet exemple montre l'effet de l'utilisation du paramètre WhatIf
lorsque la valeur de $WhatIfPreference est 0.
PS> get-childitem test2.txt | format-list -property FullName
FullName : C:\test2.txt
# Vérifier que le fichier existe.
PS> remove-item test2.txt -whatif
What if: Opération " Supprimer le fichier " en cours sur
la cible " C:\test2.txt ".
# Utiliser le paramètre WhatIf
PS> get-childitem test2.txt | format-list -property FullName
FullName : C:\test2.txt
# Vérifier que le fichier n'a
pas été supprimé
Cet exemple montre l'effet de la valeur 1 (WhatIf activé).
Lorsque vous utilisez Remove-Item pour supprimer une applet de
commande, Remove-Item affiche le chemin d'accès au fichier qu'il
supprimerait, mais ne le supprime pas.
PS> $whatifpreference = 1
PS> $whatifpreference
1 # Remplacer la valeur.
PS> remove-item test.txt
What if: Opération " Supprimer le fichier " en cours sur
la cible " C:\test.txt ".
# Essayer de supprimer un fichier.
PS> get-childitem test.txt | format-list FullName
FullName : C:\test.txt
# Vérifier que le fichier existe.
Cet exemple montre comment supprimer un fichier lorsque la valeur de
$WhatIfPreference est 1. Il utilise le paramètre WhatIf avec une
valeur $false.
PS> remove-item test.txt -whatif:$false
# Utiliser le paramètre WhatIf
avec $false.
Cet exemple montre que certaines applets de commande prennent en
charge le comportement WhatIf et d'autres non. Dans cet exemple
dans lequel la valeur de $WhatIfPreference est 1 (activé), une
commande Get-Process, qui ne prend pas en charge WhatIf est
exécutée, mais une commande Stop-Process exécute le comportement
WhatIf. Vous pouvez remplacer le comportement WhatIf de la commande
Stop-Process en utilisant le paramètre WhatIf avec une valeur $false.
PS> $whatifpreference = 1
# Remplacer la valeur par 1.
PS> get-process winword
# Une commande Get-Process s'exécute.
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
234 8 6324 15060 154 0.36 2312 WINWORD
PS> stop-process -name winword
What if: Opération " Stop-Process " en cours sur la cible " WINWORD (2312) ".
# Une commande Stop-Process utilise WhatIf.
PS> stop-process -name winword -whatif:$false
PS> # WhatIf:$false remplace la préférence.
PS> get-process winword
Get-Process : Impossible de trouver un processus nommé " winword ".
Vérifiez le nom du processus et appelez de nouveau l'applet de commande.
À la ligne : 1 Caractère : 12
+ get-process <<<< winword
# Vérifier que le processus est arrêté.
VOIR AUSSI
about_Automatic_Variables
about_CommonParameters
about_Environment_Variables
about_Profiles
about_Remote
about_Scopes
about_Variables