Partager via


about_Preference_Variables

Mis à jour: août 2012

S'applique à: Windows PowerShell 2.0, Windows PowerShell 3.0

RUBRIQUE

Variables des préférences

DESCRIPTION COURTE

Variables qui personnalisent le comportement de Windows PowerShell

DESCRIPTION DÉTAILLÉE

Windows PowerShell inclut un ensemble de variables qui vous permettent de personnaliser son comportement. Ces « variables des préférences » fonctionnent comme les options dans les systèmes basés sur l’interface utilisateur graphique.

Les variables des préférences affectent l’environnement opératoire Windows PowerShell et toutes les commandes exécutées dans l’environnement. Dans de nombreux cas, les applets de commande ont des paramètres que vous pouvez utiliser pour remplacer le comportement de préférence pour une commande spécifique.

Le tableau suivant répertorie les variables des préférences et leurs valeurs par défaut.

    Variable                             Default Value
    --------                             -------------
    $ConfirmPreference                   High
    $DebugPreference                     SilentlyContinue
    $ErrorActionPreference               Continue
    $ErrorView                           NormalView
    $FormatEnumerationLimit              4
    $LogCommandHealthEvent               False (not logged)
    $LogCommandLifecycleEvent            False (not logged)
    $LogEngineHealthEvent                True (logged)
    $LogEngineLifecycleEvent             True (logged)
    $LogProviderLifecycleEvent           True (logged)
    $LogProviderHealthEvent              True (logged)
    $MaximumAliasCount                   4096
    $MaximumDriveCount                   4096
    $MaximumErrorCount                   256
    $MaximumFunctionCount                4096
    $MaximumHistoryCount                 4096
    $MaximumVariableCount                4096
    $OFS                                 (Space character (" "))
    $OutputEncoding                      ASCIIEncoding object
    $ProgressPreference                  Continue
    $PSDefaultParameterValues            (None - empty hash table)     
    $PSEmailServer                       (None)
    $PSModuleAutoLoadingPreference       All
    $PSSessionApplicationName            WSMAN
    $PSSessionConfigurationName          https://schemas.microsoft.com/PowerShell/microsoft.PowerShell 
    $PSSessionOption                     (See below)
    $VerbosePreference                   SilentlyContinue
    $WarningPreference                   Continue
    $WhatIfPreference                    0

Windows PowerShell inclut également les variables d’environnement suivantes qui stockent les préférences de l’utilisateur. Pour plus d’informations sur ces variables d’environnement, consultez about_Environment_Variables.

    Variable                                         
    --------    
    PSExecutionPolicyPreference                     
    PSModulePath                        

UTILISATION DES VARIABLES DES PRÉFÉRENCES

Ce document décrit chacune des variables des préférences.

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 » à la variable $ConfirmPreference.

        PS> $ConfirmPreference = "Medium"

Comme toutes les variables, les valeurs que vous définissez sont spécifiques à la session Windows PowerShell active. Pour les rendre effectives dans toutes les sessions Windows PowerShell, ajoutez-les à votre profil Windows PowerShell. Pour plus d'informations, consultez about_Providers.

UTILISATION À DISTANCE

Quand vous exécutez des commandes sur un ordinateur distant, les commandes à distance ne sont soumises qu’aux préférences définies dans le client Windows PowerShell sur l’ordinateur distant. Par exemple, quand vous exécutez une commande à distance, la valeur de la variable $DebugPreference sur l’ordinateur distant détermine comment Windows PowerShell répond aux messages de débogage.

Pour plus d’informations sur les commandes à distance, consultez about_remote.

$ConfirmPreference
------------------

Détermine si Windows PowerShell vous demande automatiquement confirmation avant d’exécuter une applet de commande ou une fonction.

Quand la valeur de la variable $ConfirmPreference (High, Medium, Low) est inférieure ou égale au risque affecté à l’applet de commande ou à la fonction (élevé, moyen, faible), Windows PowerShell vous demande automatiquement confirmation avant d’exécuter l’applet de commande ou la fonction.

Si la valeur de la variable $ConfirmPreference est None, Windows PowerShell ne vous demande jamais automatiquement confirmation avant d’exécuter une applet de commande ou une fonction.

Pour modifier le comportement de confirmation pour toutes les applets de commande et fonctions dans la session, modifiez la valeur de la variable $ConfirmPreference.

Pour remplacer la variable $ConfirmPreference pour une seule commande, utilisez le paramètre Confirm de la fonction ou l’applet de commande. Pour demander confirmation, utilisez -Confirm. Pour supprimer la confirmation, utilisez -Confirm:$false.

Valeurs valides de $ConfirmPreference :

None : Windows PowerShell ne demande pas automatiquement confirmation. Pour demander confirmation d’une commande particulière, utilisez le paramètre Confirm de la fonction ou l’applet de commande.

Low : Windows PowerShell demande confirmation avant d’exécuter des fonctions ou des applets de commande avec un risque faible, moyen ou élevé.

Medium : Windows PowerShell demande confirmation avant d’exécuter des fonctions ou des applets de commande avec un risque moyen ou élevé.

High : Windows PowerShell demande confirmation avant d’exécuter des fonctions ou des applets de commande avec un risque élevé.

EXPLICATION DÉTAILLÉE

Quand les actions d’une applet de commande ou fonction affectent de manière significative le système, telles que celles qui suppriment des données ou utilisent une quantité importante de ressources système, Windows PowerShell peut vous demander automatiquement confirmation avant d’effectuer l’action.

Par exemple,

    PS> remove-item file.txt

            Confirm
            Are you sure you want to perform this action?
            Performing operation "Remove File" on Target "C:\file.txt".
            [Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "Y"):

L’estimation du risque est un attribut de l’applet de commande ou de la fonction appelé « ConfirmImpact ». Les utilisateurs ne peuvent pas le modifier.

Les applets de commande et fonctions qui peuvent représenter un risque pour le système ont un paramètre Confirm que vous pouvez utiliser pour demander ou supprimer la confirmation pour une commande unique.

Comme la plupart des applets de commande et fonctions utilisent la valeur par défaut de risque moyen (ConfirmImpact) et que la valeur par défaut de $ConfirmPreference est High, une confirmation automatique se produit rarement. Toutefois, vous pouvez activer la confirmation automatique en remplaçant la valeur de $ConfirmPreference par Medium ou Low.

EXEMPLES

Cet exemple montre l’effet de la valeur par défaut de $ConfirmPreference. La valeur High confirme uniquement les fonctions et les applets de commande à risque élevé. Étant donné que la plupart des applets de commande et fonctions sont à risque moyen, elles ne sont pas automatiquement confirmées.

          PS> $confirmpreference              #Get the current value of the
          High                                 variable
          
          PS> remove-item temp1.txt           #Delete a file
          PS>                                 #Deleted without confirmation

           
          PS> remove-item temp2.txt -confirm  #Use the Confirm parameter to
                                               request confirmation

          Confirm
          Are you sure you want to perform this action?
          Performing operation "Remove File" on Target "C:\temp2.txt".
          [Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "Y"):

L’exemple suivant montre l’effet du remplacement de la valeur de $ConfirmPreference par Medium. Étant donné que la plupart des applets de commande et fonctions sont à risque moyen, elles sont automatiquement confirmées. Pour supprimer l’invite de confirmation pour une commande unique, utilisez le paramètre Confirm avec la valeur $false

            
          PS> $confirmpreference = "Medium"  #Change the value of $ConfirmPreference
          PS> remove-item temp2.txt          #Deleting a file triggers confirmation         
                                     
          Confirm
          Are you sure you want to perform this action?
          Performing operation "Remove File" on Target "C:\temp2.txt".
          [Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "Y"):


          PS> remove-item temp3.txt -confirm:$false   #Use Confirm parameter
                                                       to suppress 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 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 sont pas affichés, mais vous pouvez les afficher en modifiant la valeur de $DebugPreference.

Vous pouvez également utiliser le paramètre commun 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 : Affiche le message de débogage et arrête l’exécution. Écrit une erreur dans la console.

Inquire : Affiche le message de débogage et vous demande si vous souhaitez continuer. Notez que l’ajout du paramètre commun Debug à une commande (quand la commande est configurée pour générer un message de débogage) remplace la valeur de la variable $DebugPreference par Inquire.

Continue : Affiche le message de débogage et poursuit l’exécution.

SilentlyContinue : (valeur par défaut) Aucun effet. Le message de débogage n’est pas affiché et l’exécution se poursuit sans interruption.

EXEMPLES

Les exemples suivants illustrent l’effet de la modification des valeurs de $DebugPreference quand 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 scripts. Les exemples montrent également l’utilisation du paramètre commun Debug, qui affiche ou masque les messages de débogage liés à une commande unique.

Cet exemple illustre l’effet de la valeur par défaut, « SilentlyContinue ». 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 unique.

        PS> $debugpreference                    # Get the current value of
        SilentlyContinue                          $DebugPreference

        PS> write-debug "Hello, World"
        PS>                                     # The debug message is not
                                                  displayed.

        PS> write-debug "Hello, World" -Debug   # Use the Debug parameter
        DEBUG: Hello, World                     # The debug message is
                                                  is requested.                                                                                                    displayed and confirmation
        Confirm
        Continue with this operation?
        [Y] Yes  [A] Yes to All  [H] Halt Command  [S] Suspend  [?] Help (default is "Y"):

Cet exemple illustre l’effet de la valeur « Continue ». La dernière commande utilise le paramètre Debug avec la valeur $false pour supprimer le message pour une commande unique.

        PS> $debugpreference = "Continue"   # Change the value to "Continue"

        PS> write-debug "Hello, World"
        DEBUG: Hello, World                 # The debug message is displayed
        PS>                                   and processing continues.
                                           

        PS> write-debug "Hello, World" -Debug:$false   
                                            # Use the Debug parameter with
                                              false.
        PS>                                 # The debug message is not
                                              displayed.

Cet exemple illustre l’effet de la valeur « Stop ». La dernière commande utilise le paramètre Debug avec la valeur $false pour supprimer le message pour une commande unique.

        PS> $debugpreference = "Stop"       #Change the value to "Stop"
        PS> write-debug "Hello, World"
        DEBUG: Hello, World
        Write-Debug : Command execution stopped because the shell variable "DebugPreference" is
        set to Stop.
        At line:1 char:12
        + write-debug  <<<< "Hello, World"

        PS> write-debug "Hello, World" -Debug:$false   
                                            # Use the Debug parameter with
                                              $false
        PS>                                 # The debug message is not 
                                              displayed and processing is
                                              not stopped.

Cet exemple illustre l’effet de la valeur « Inquire ». La dernière commande utilise le paramètre Debug avec la valeur $false pour supprimer le message pour une commande unique.

        PS> $debugpreference = "Inquire"
        PS> write-debug "Hello, World"
        DEBUG: Hello, World

        Confirm
        Continue with this operation?
        [Y] Yes  [A] Yes to All  [H] Halt Command  [S] Suspend  [?] Help (default is "Y"):

        PS> write-debug "Hello, World" -Debug:$false   
                                            # Use the Debug parameter with
                                              $false
        PS>                                 # The debug message is not
                                              displayed and processing
                                              continues without interruption.

$ErrorActionPreference
----------------------

Détermine comment Windows PowerShell répond à une erreur sans fin d’exécution (une erreur qui n’arrête pas le traitement de l’applet de commande) à la ligne de commande ou dans un script, une applet de commande ou un fournisseur, comme les erreurs générées par l’applet de commande Write-Error.

Vous pouvez également utiliser le paramètre commun ErrorAction d’une applet de commande pour remplacer la préférence pour une commande spécifique.

Valeurs valides :

Stop : Affiche le message d’erreur et arrête l’exécution.

Inquire : Affiche le message d’erreur et vous demande si vous souhaitez continuer.

Continue (valeur par défaut) : Affiche le message d’erreur et poursuit l’exécution.

Suspend : Interrompt automatiquement une tâche de workflow pour permettre une analyse plus approfondie. Après l'analyse, le workflow peut reprendre.

SilentlyContinue : Aucun effet. Le message d’erreur n’est pas affiché et l’exécution se poursuit sans interruption.

REMARQUE :

La valeur Ignore du paramètre commun ErrorAction n’est pas une valeur valide de la variable $ErrorActionPreference. La valeur Ignore est destinée à une utilisation par commande, et non à être utilisée comme préférence enregistrée.

Ni la variable $ErrorActionPreference ni le paramètre commun ErrorAction n’affectent la façon dont Windows PowerShell répond aux erreurs avec fin d’exécution (celles qui arrêtent le traitement de l’applet de commande).

Pour plus d’informations sur le paramètre commun ErrorAction, consultez about_CommonParameters (https://go.microsoft.com/fwlink/?LinkID=113216).

EXEMPLES

Ces exemples illustrent l’effet des différentes valeurs de $ErrorActionPreference et l’utilisation du paramètre commun ErrorAction pour remplacer la préférence pour une commande unique. Le paramètre ErrorAction a les mêmes valeurs valides que la variable $ErrorActionPreference.

Cet exemple illustre l’effet de la valeur Continue, qui est la valeur par défaut.

        PS> $erroractionpreference                      
        Continue# Display the value of the preference.          
                                  
        PS> write-error "Hello, World"                  
                                # Generate a non-terminating error.

        write-error "Hello, World" : Hello, World       
                                # The error message is displayed and
                                  execution continues.

        PS> write-error "Hello, World" -ErrorAction:SilentlyContinue
                                # Use the ErrorAction parameter with a 
                                  value of "SilentlyContinue".
        PS>                                             
                                # The error message is not displayed and
                                  execution continues.

Cet exemple illustre l’effet de la valeur SilentlyContinue.

        PS> $ErrorActionPreference = "SilentlyContinue"
                                # Change the value of the preference.
        PS> write-error "Hello, World"                  
                                # Generate an error message.
        PS>                     
                                # Error message is suppressed.
        PS> write-error "Hello, World" -erroraction:continue
                                # Use the ErrorAction parameter with a
                                  value of "Continue".
        write-error "Hello, World" -erroraction:continue : Hello, World
                                # The error message is displayed and
                                  execution continues.

Cet exemple illustre l’effet d’une erreur réelle. Dans ce cas, la commande obtient un fichier inexistant, nofile.txt. L’exemple utilise également le paramètre commun ErrorAction pour remplacer la préférence.

        PS> $erroractionpreference                      
        SilentlyContinue        # Display the value of the preference.     
                                

        PS> get-childitem -path nofile.txt
        PS>                     # Error message is suppressed.

        PS> $ErrorActionPreference = "Continue" 
                                # Change the value to Continue.

        PS> get-childitem -path nofile.txt
        Get-ChildItem : Cannot find path 'C:\nofile.txt' because it does not exist.
        At line:1 char:4
        + get-childitem  <<<< nofile.txt

        PS> get-childitem -path nofile.txt -erroraction SilentlyContinue
                                # Use the ErrorAction parameter
        PS>                     
                                # Error message is suppressed.
  
        PS> $ErrorActionPreference = "Inquire"          
                                # Change the value to Inquire.
        PS> get-childitem -path nofile.txt

        Confirm
        Cannot find path 'C:\nofile.txt' because it does not exist.
        [Y] Yes  [A] Yes to All  [H] Halt Command  [S] Suspend  [?] Help (default is "Y"): y
        
        Get-ChildItem : Cannot find path 'C:\nofile.txt' because it does not exist.
        At line:1 char:4
        + get-childitem  <<<< nofile.txt

        PS> $ErrorActionPreference = "Continue"                  
                                # Change the value to Continue.
        PS> Get-Childitem nofile.txt -erroraction "Inquire"      
                                # Use the ErrorAction parameter to override
                                  the preference value.

        Confirm
        Cannot find path 'C:\nofile.txt' because it does not exist.         
        [Y] Yes  [A] Yes to All  [H] Halt Command  [S] Suspend  [?] Help (default is "Y"):

$ErrorView
----------

Détermine le format d’affichage des messages d’erreur dans Windows PowerShell.

Valeurs valides

NormalView (valeur par défaut) : Vue détaillée, conçue pour la plupart 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 à l’origine de l’erreur.

CategoryView : Vue concise et 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 « ErrorCategoryInfo, classe » dans le Kit de développement logiciel (SDK) Windows PowerShell.

EXEMPLES

Ces exemples illustrent l’effet des valeurs ErrorView.

Cet exemple montre comment une erreur s’affiche quand la valeur de $ErrorView est NormalView. Dans ce cas, la commande Get-ChildItem est utilisée pour rechercher un fichier inexistant.

        PS> $ErrorView                         # Verify the value.
        NormalView

        PS> get-childitem nofile.txt           # Find a non-existent file.
        Get-ChildItem : Cannot find path 'C:\nofile.txt' because it does not exist.
        At line:1 char:14
        + get-childitem  <<<< nofile.txt

Cet exemple montre comment la même erreur s’affiche quand la valeur de $ErrorView est CategoryView.

        PS> $ErrorView = "CategoryView"        # Change the value to 
                                                 CategoryView

        PS> get-childitem nofile.txt
        ObjectNotFound: (C:\nofile.txt:String) [Get-ChildItem], ItemNotFoundException

Cet exemple montre que la valeur d’ErrorView affecte uniquement l’affichage de l’erreur ; elle ne modifie pas la structure de l’objet d’erreur qui est 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 dans le tableau d’erreurs (élément 0) et met en forme toutes les propriétés de l’objet d’erreur dans une liste.

        PS> $error[0] | format-list -property * -force

        Exception    : System.Management.Automation.ItemNotFoundException: Cannot find path
                       'C:\nofile.txt' because it does not exist.
                       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é inclus dans un affichage. Cette variable n’affecte pas les objets sous-jacents, juste l’affichage. Quand la valeur de $FormatEnumerationLimit est inférieure au nombre d’éléments énumérés, Windows PowerShell ajoute des points de suspension (...) pour indiquer des éléments non affichés.

        Valid values: Integers (Int32)
        Default value: 4

EXEMPLES

Cet exemple montre comment utiliser la variable $FormatEnumerationLimit afin d’améliorer l’affichage des éléments énumérés.

Dans cet exemple, la commande génère une table qui répertorie tous les services exécutés sur l’ordinateur dans deux groupes : un pour les services en cours d’exécution et un pour les services arrêtés. Elle utilise une commande Get-Service pour obtenir tous les services et envoyer les résultats via le pipeline à l’applet de commande Group-Object, qui regroupe les résultats selon l’état du service.

L’affichage obtenu est une table qui répertorie l’état dans la colonne Nom et les processus avec cet état dans la colonne Groupe. (Pour modifier les étiquettes de colonne, utilisez une table de hachage. Pour plus d’informations, consultez les exemples dans « get-help format-table -examples ».)

Il existe un maximum de 4 services répertoriés dans la colonne Groupe pour chaque état. Pour augmenter le nombre d’éléments répertoriés, remplacez la valeur de $FormatEnumerationLimit par 1 000.

Dans l’affichage obtenu, la liste dans la colonne Groupe est désormais 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 dans chaque groupe d’états.

        PS> $formatenumerationlimit         # Find the current value
        4
        
        PS> get-service | group-object -property status           
                                            # List all services grouped by
                                              status

        Count Name                      Group
        ----- ----                      -----
           60 Running                   {AdtAgent, ALG, Ati HotKey Poller, AudioSrv...}   
           41 Stopped                   {Alerter, AppMgmt, aspnet_state, ATI Smart...}

                                           # The list is truncated after
                                             4 items.


        PS> $formatenumerationlimit = 1000
                                           # Increase the limit to 1000.
        
        PS> get-service | group-object -property status           
                                           # Repeat the command.

        Count Name     Group
        ----- ----     -----
           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
                                           # Add the Wrap parameter.

        Count Name       Group
        ----- ----       -----
           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,
                         WZCSVC, 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, SCardSvr, SwPrv, SysmonLog, TlntSvr, upnphost, UPS, 
                         VSS, WmdmPmSN, Wmi, WmiApSrv, xmlprov}

$Log*Event
----------

Les variables des préférences Log*Event déterminent les types d’événements qui sont consignés dans le journal des événements Windows PowerShell dans 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 des préférences Log*Event pour personnaliser votre journal, par exemple pour enregistrer des événements sur les commandes.

Les variables des préférences Log*Event se présentent comme suit :

            $LogCommandHealthEvent: Logs errors and exceptions in command initialization
                and processing. Default = $false (not logged).

            $LogCommandLifecycleEvent: 
                Logs the starting and stopping of commands and command pipelines
                and security exceptions in command discovery. Default = $false (not logged).

            $LogEngineHealthEvent: Logs errors and failures of sessions. Default = $true (logged).

            $LogEngineLifecycleEvent: Logs the opening and closing of sessions. 
                Default = $true (logged).

            $LogProviderHealthEvent: Logs provider errors, such as read and write errors,
                lookup errors, and invocation errors. Default = $true (logged).

            $LogProviderLifecycleEvent: Logs adding and removing of Windows PowerShell providers.
                Default = $true (logged). (For information about Windows PowerShell providers, type:
                "get-help about_provider".

Pour activer une variable Log*Event, tapez la variable avec la valeur $true, par exemple :

            $LogCommandLifeCycleEvent

            - or -

            $LogCommandLifeCycleEvent = $true

Pour désactiver un type d’événement, tapez la variable avec la valeur $false, par exemple :

            $LogCommandLifeCycleEvent = $false

Les événements que vous activez sont effectifs uniquement 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, 4 096, devrait être suffisante pour la plupart des utilisations, mais vous pouvez l’adapter à vos besoins.

        Valid values: 1024 - 32768 (Int32)
        Default: 4096
      
        To count the aliases on your system, type: 

(get-alias).count

$MaximumDriveCount
------------------

Détermine le nombre de lecteurs Windows PowerShell autorisés dans une session donnée. Cela inclut les lecteurs de système de fichiers et magasins de données qui sont exposés par les fournisseurs Windows PowerShell et apparaissent comme des lecteurs, tels que les lecteurs Alias: et HKLM: .

        Valid values: 1024 - 32768 (Int32)
        Default: 4096
      
        To count the aliases on your system, type: 

(get-psdrive).count

$MaximumErrorCount
------------------

Détermine le nombre d’erreurs enregistrées dans l’historique des erreurs pour la session.

        Valid values: 256 - 32768 (Int32)
        Default: 256

Les objets qui représentent chaque erreur retenue sont stockés dans la variable automatique $Error. Cette variable contient un tableau d’objets d’enregistrements d’erreur, un pour chaque erreur. L’erreur la plus récente est le premier objet dans le tableau ($Error[0]).

Pour compter les erreurs sur votre système, utilisez la propriété Count du tableau $Error. Tapez :

$Error.count

Pour afficher une erreur spécifique, utilisez la notation de tableau. Par exemple, pour voir l’erreur la plus récente, tapez :

                $Error[0]

Pour afficher l’erreur retenue 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 rétablit le format conventionnel.

Pour supprimer toutes les erreurs de l’historique des erreurs, 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. Quand vous redirigez une collection d’objets vers Get-Member, Get-Member affiche les propriétés et méthodes des objets dans la collection. Quand 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.

        Valid values: 1024 - 32768 (Int32)
        Default: 4096

Pour afficher les fonctions dans votre session, utilisez le lecteur Windows PowerShell Function: qui est exposé par le fournisseur de fonctions Windows PowerShell. (Pour plus d’informations sur le fournisseur de fonctions, tapez « get-help function ».)

Pour répertorier les fonctions dans la session active, tapez :

            get-childitem function:

Pour compter les fonctions dans 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.

        Valid values: 1 - 32768 (Int32)
        Default: 4096

Pour déterminer le nombre de commandes actuellement 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, consultez about_History (https://go.microsoft.com/fwlink/?LinkID=113233).

REMARQUE : Dans Windows PowerShell 2.0, la valeur par défaut de la variable $MaximumHistoryCount est 64.

$MaximumVariableCount
------------------

Détermine le nombre de variables autorisées dans une session donnée, y compris les variables automatiques, les variables des préférences et les variables que vous créez dans les commandes et scripts.

        Valid values: 1024 - 32768 (Int32)
        Default: 4096

Pour afficher les variables dans votre session, utilisez l’applet de commande Get-Variable et les fonctionnalités du lecteur Windows PowerShell Variable: et du 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 de champs de sortie. Spécifie le caractère qui sépare les éléments d’un tableau quand le tableau est converti en une chaîne.

        Valid values: Any string.
        Default: Space

Par défaut, la variable $OFS n’existe pas et le séparateur de fichiers 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 quand un tableau est converti en une chaîne. Dans ce cas, un tableau d’entiers est stocké dans une variable et la variable devient une chaîne via une conversion de type (transtypage).

       PS> $array = 1,2,3                 # Store an array of integers.       

       PS> [string]$array                 # Cast the array to a string.
       1 2 3                              # Spaces separate the elements

Pour modifier le séparateur, ajoutez la variable $OFS en lui assignant une valeur. Pour fonctionner correctement, la variable doit être nommée $OFS.

       PS> $OFS = "+"                     # Create $OFS and assign a "+"

       PS> [string]$array                 # Repeat the command
       1+2+3                              # Plus signs separate the elements

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            # Delete $OFS
       PS>

       PS> [string]$array                 # Repeat the command
       1 2 3                              # Spaces separate the elements
       

$OutputEncoding
---------------

Détermine la méthode de codage de caractères utilisée par Windows PowerShell quand il envoie du texte à d’autres applications.

Par exemple, si une application retourne des chaînes Unicode à Windows PowerShell, vous devrez peut-être remplacer la valeur par UnicodeEncoding pour envoyer correctement les caractères.

        Valid values: Objects derived from an Encoding class, such as
                      ASCIIEncoding, SBCSCodePageEncoding, UTF7Encoding, 
                      UTF8Encoding, UTF32Encoding, and UnicodeEncoding.

        Default: ASCIIEncoding object (System.Text.ASCIIEncoding)

EXEMPLES

Cet exemple montre comment faire en sorte que la commande FINDSTR dans Windows fonctionne dans Windows PowerShell sur un ordinateur localisé dans 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 de codage, affichez uniquement sa propriété EncodingName.

          PS> $OutputEncoding.EncodingName  # Find the current value
          US-ASCII

Dans cet exemple, une commande FINDSTR est utilisée pour rechercher deux caractères chinois qui sont présents dans le fichier Test.txt. Quand cette commande FINDSTR est exécutée dans l’invite de commandes Windows (Cmd.exe), FINDSTR recherche les caractères dans le fichier texte. Toutefois, quand 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 et non en texte Unicode.

          PS> findstr <Unicode-characters>  # Use findstr to search.
          PS>                               # None found.

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, qui est basée sur les paramètres régionaux sélectionnés pour Windows. OutputEncoding étant une propriété statique de la console, utilisez le double signe deux-points (::) dans la commande.

          PS> $OutputEncoding = [console]::outputencoding
          PS>                               # Set the value equal to the
                                              OutputEncoding property of the
                                              console.
          PS> $OutputEncoding.EncodingName               
          OEM United States
                                            # Find the resulting value.

Suite à cette modification, la commande FINDSTR recherche les caractères.

          PS> findstr <Unicode-characters>               
          test.txt:         <Unicode-characters>        

# Use findstr to search. It find the
                                          characters in the text file.

$ProgressPreference
-------------------

Détermine comment Windows PowerShell répond aux mises à jour de progression générées par une applet de commande, un script 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 décrivent l’état d’une commande.

Valeurs valides :

Stop : N’affiche pas la barre de progression. À la place, elle affiche un message d’erreur et arrête l’exécution.

Inquire : N’affiche pas la barre de progression. Demande l’autorisation de continuer. Si vous répondez par Y ou A, elle affiche la barre de progression.

Continue (valeur par défaut) : Affiche la barre de progression et poursuit l’exécution.

SilentlyContinue : Exécute la commande, mais n’affiche pas la barre de progression.

$PSEmailServer
--------------

Spécifie le serveur de messagerie par défaut qui est utilisé pour envoyer des messages électroniques. Cette variable de préférence est utilisée par les applets de commande qui envoient du courrier électronique, telles que l’applet de commande Send-MailMessage.

$PSDefaultParameterValues
-------------------------

Spécifie les valeurs par défaut pour les paramètres des applets de commande et fonctions avancées. La valeur de PSDefaultParameterValues est une table de hachage où la clé est composée du nom de l’applet de commande et du nom du paramètre séparés par un signe deux-points (:), et où la valeur correspond à une valeur par défaut personnalisée que vous spécifiez.

Cette variable a été introduite dans Windows PowerShell 3.0.

Pour plus d’informations sur cette variable de préférence, consultez about_Parameters_Default_Values.

$PSModuleAutoloadingPreference
------------------------------

Active et désactive l’importation automatique de modules dans la session. « All » est la valeur par défaut. Quelle que soit la valeur de cette variable, vous pouvez utiliser l’applet de commande Import-Module pour importer un module.

Les valeurs valides sont :

All Les modules sont importés automatiquement lors de la première utilisation. Pour importer un module, obtenez (Get-Command) ou utilisez toute commande dans le module.

ModuleQualified

Les modules ne sont importés automatiquement que quand un utilisateur emploie le nom qualifié de module d’une commande dans le module. Par exemple, si l’utilisateur tape « MyModule\MyCommand », Windows PowerShell importe le module MyModule.

None L’importation automatique de modules est désactivée dans la session. Pour importer un module, utilisez l’applet de commande Import-Module.

Pour plus d’informations sur l’importation automatique de modules, consultez about_Modules (https://go.microsoft.com/fwlink/?LinkID=144311).

$PSSessionApplicationName
---------------------------

Spécifie le nom d’application par défaut pour une commande à distance qui utilise la technologie WS-Management.

Le nom d’application par défaut du système 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 dans 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é quand la commande à distance ne spécifie pas d’URI de connexion ni de nom d’application.

Le service WinRM utilise le nom de l'application pour sélectionner un port d'écoute et 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 par défaut du système et la valeur de cette variable, puis sélectionner un nom d’application différent 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 pour établir la session échoue.

$PSSessionConfigurationName
---------------------------

Spécifie la configuration de session par défaut qui est 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 située 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 sur l’ordinateur distant.

Si vous spécifiez uniquement un nom de configuration, l’URI de schéma suivant est ajouté :

           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 en utilisant le paramètre ConfigurationName des applets de commande New-PSSession, Enter-PSSession ou Invoke-Command.

Vous pouvez modifier la valeur de cette variable à tout moment. Quand vous effectuez cette opération, n’oubliez pas que la configuration de session que vous sélectionnez doit exister sur l’ordinateur distant. Dans le cas contraire, la commande pour 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 locale qui sont utilisées quand des utilisateurs distants créent une session qui se connecte à cet ordinateur. Toutefois, vous pouvez utiliser les autorisations pour les configurations de session locale afin de déterminer quels utilisateurs peuvent les utiliser.

$PSSessionOption
----------------

Établit les valeurs par défaut pour les options utilisateur avancées dans une session à distance. Ces préférences d’options remplacent les valeurs par défaut du système pour les options de session.

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 active la compression de données pendant la session.

Par défaut, la variable $PSSessionOption contient un objet PSSessionOption avec les valeurs par défaut pour toutes les options, comme illustré ci-dessous.

            MaximumConnectionRedirectionCo For descriptions of these options, see the help topic for the unt : 5
            NoCompression                     : False
            NoMachineProfile                  : False
            ProxyAccessType                   : None
            ProxyAuthentication               : Negotiate
            ProxyCredential                   :
            SkipCACheck                       : False
            SkipCNCheck                       : False
            SkipRevocationCheck               : False
            OperationTimeout                  : 00:03:00
            NoEncryption                      : False
            UseUTF16                          : False
            IncludePortInSPN                  : False
            OutputBufferingMode               : None
            Culture                           :
            UICulture                         :
            MaximumReceivedDataSizePerCommand :
            MaximumReceivedObjectSize         : 209715200
            ApplicationArguments              :
            OpenTimeout                       : 00:03:00
            CancelTimeout                     : 00:01:00
            IdleTimeout                       : -00:00:00.0010000

Pour obtenir les descriptions de ces options, consultez la rubrique d’aide pour l’applet de commande New-PSSessionOption.

Pour modifier la valeur de la variable de préférence $PSSessionOption, utilisez l’applet de commande New-PSSessionOption pour créer un objet PSSessionOption avec les valeurs d’options souhaitées. Enregistrez le résultat 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 dans votre profil Windows PowerShell.

Vous pouvez également définir des options personnalisées pour une session à distance particulière. Les options que vous définissez ont priorité sur les valeurs par défaut du système et la valeur de la variable de préférence $PSSessionOption.

Pour définir des options de session personnalisées, utilisez l’applet de commande New-PSSessionOption pour créer un objet PSSessionOption. Ensuite, utilisez l’objet PSSessionOption comme valeur du paramètre SessionOption dans les applets de commande qui créent une session, comme New-PSSession, Enter-PSSession et Invoke-Command.

Pour plus d’informations sur l’applet de commande New-PSSessionOption, consultez la rubrique d’aide pour New-PSSessionOption. Pour plus d’informations sur les sessions et commandes à distance, 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 une applet de commande, un script ou un fournisseur, comme 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 changeant la valeur de $VerbosePreference.

Vous pouvez également utiliser le paramètre commun 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 : Affiche le message commenté ainsi qu’un message d’erreur et arrête l’exécution.

Inquire : Affiche le message commenté, puis une invite vous demandant si vous souhaitez continuer.

Continue : Affiche le message commenté et poursuit l’exécution.

SilentlyContinue (valeur par défaut) : N’affiche pas le message commenté. Poursuit l’exécution.

EXEMPLES

Ces exemples illustrent l’effet des différentes valeurs de $VerbosePreference et l’utilisation du paramètre commun Verbose pour remplacer la valeur de préférence.

Cet exemple illustre l’effet de la valeur SilentlyContinue, qui est la valeur par défaut.

        PS> $VerbosePreference             # Find the current value.
        SilentlyContinue

        PS> Write-Verbose "Verbose message test."              
        PS>                                # Write a verbose message.
                                           # Message is not displayed.

        PS> Write-Verbose "Verbose message test." -verbose     
        VERBOSE: Verbose message test.
                                   # Use the Verbose parameter.

Cet exemple illustre l’effet de la valeur Continue.

        PS> $VerbosePreference = "Continue"                    
                                           # Change the value to Continue.
        PS> Write-Verbose "Verbose message test."              
                                           # Write a verbose message.
        VERBOSE: Verbose message test.                         
                                           # Message is displayed.

        PS> Write-Verbose "Verbose message test." -verbose:$false
                                           # Use the Verbose parameter with
                                             a value of $false.
        PS>                                  
                                           # Message is not displayed.

Cet exemple illustre l’effet de la valeur Stop.

        PS> $VerbosePreference = "Stop"                        
                                           # Change the value to Stop.
        PS> Write-Verbose "Verbose message test."              
                                           # Write a verbose message.
        VERBOSE: Verbose message test.
        Write-Verbose : Command execution stopped because the shell variable "VerbosePreference"
        is set to Stop.
        At line:1 char:14
        + Write-Verbose  <<<< "Verbose message test."

       PS> Write-Verbose "Verbose message test." -verbose:$false
                                          # Use the Verbose parameter with
                                            a value of $false
       PS>                                  
                                          # Message is not displayed.

Cet exemple illustre l’effet de la valeur Inquire.

       PS> $VerbosePreference = "Inquire"                      
                                         # Change the value to Inquire.
       PS> Write-Verbose "Verbose message test."               
       VERBOSE: Verbose message test.
                                         # Write a verbose message.
       Confirm
       Continue with this operation?
       [Y] Yes  [A] Yes to All  [H] Halt Command  [S] Suspend  [?] Help (default is "Y"): y
       PS>

       PS> Write-Verbose "Verbose message test." -verbose:$false
                                        # Use the Verbose parameter.
       PS>                              
                                        # Message is not displayed.

$WarningPreference
------------------

Détermine comment Windows PowerShell répond aux messages d’avertissement générés par une applet de commande, un script ou un fournisseur, comme 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 se poursuit, mais vous pouvez modifier ce comportement en changeant la valeur de $WarningPreference.

Vous pouvez également utiliser le paramètre commun WarningAction d’une applet de commande pour déterminer comment Windows PowerShell répond aux avertissements à partir d’une commande particulière. Pour plus d’informations, tapez : « get-help about_commonparameters ».

Valeurs valides :

Stop : Affiche le message d’avertissement ainsi qu’un message d’erreur et arrête l’exécution.

Inquire : Affiche le message d’avertissement, puis demande l’autorisation de continuer.

Continue (valeur par défaut) : Affiche le message d’avertissement et poursuit l’exécution.

SilentlyContinue : N’affiche pas le message d’avertissement. Poursuit l’exécution.

EXEMPLES

Ces exemples illustrent l’effet des différentes valeurs de $WarningPreference et l’utilisation du paramètre commun WarningAction pour remplacer la valeur de préférence.

Cet exemple illustre l’effet de la valeur Continue, qui est la valeur par défaut.

            PS> $WarningPreference    # Find the current value.                           
            Continue                  

                                      # Write a warning message.
            PS> Write-Warning "This action can delete data."     
            WARNING: This action can delete data.
                                      
                                      # Use the WarningAction parameter to 
                                      # suppress the warning for this command                                             
            PS> Write-Warning "This action can delete data." -warningaction silentlycontinue     

Cet exemple illustre l’effet de la valeur SilentlyContinue.

            PS> $WarningPreference = "SilentlyContinue"           
                                      # Change the value to SilentlyContinue.
 
            PS> Write-Warning "This action can delete data."      
            PS>                        # Write a warning message.

       
            PS> Write-Warning "This action can delete data." -warningaction stop     
                                      # Use the WarningAction parameter to stop
                                      # processing when this command generates a
                                      # warning.         
            WARNING: This action can delete data.
            Write-Warning : Command execution stopped because the shell variable
            "WarningPreference" is set to Stop.
            At line:1 char:14
            + Write-Warning <<<<  "This action can delete data." -warningaction stop
                                 

Cet exemple illustre l’effet de la valeur Inquire.

           PS> $WarningPreference = "Inquire"                    
                                      # Change the value to Inquire.
           PS> Write-Warning "This action can delete data."   
                                      # Write a warning message.     
           WARNING: This action can delete data.

           Confirm
           Continue with this operation?
           [Y] Yes  [A] Yes to All  [H] Halt Command  [S] Suspend  [?] Help (default is "Y"): y
           PS>

           PS> Write-Warning "This action can delete data." -warningaction silentlycontinue
           PS>                         # Use the WarningAction parameter to change the
                                       # response to a warning for the current command.

Cet exemple illustre l’effet de la valeur Stop.

           PS> $WarningPreference = "Stop"                       
                                     # Change the value to Stop.

           PS> Write-Warning "This action can delete data."      
                                     # Write a warning message.
           WARNING: This action can delete data.
           Write-Warning : Command execution stopped because the shell variable 
             "WarningPreference" is set to Stop.
           At line:1 char:14
           + Write-Warning  <<<< "This action can delete data."


           PS> Write-Warning "This action can delete data." -warningaction inquire
           WARNING: This action can delete data.

           Confirm
           Continue with this operation?
           [Y] Yes  [A] Yes to All  [H] Halt Command  [S] Suspend  [?] Help (default is "Y"):                        
                                       # Use the WarningAction parameter to change the
                                       # response to a warning for the current command.

$WhatIfPreference
------------------

Détermine si WhatIf est automatiquement activé pour toutes les commandes qui le prennent en charge. Quand WhatIf est activé, l’applet de commande signale l’effet attendu de la commande, mais n’exécute pas la commande.

Valeurs valides :

0 (valeur par défaut) : WhatIf n’est pas automatiquement activé. Pour l’activer manuellement, utilisez le paramètre WhatIf de la commande.

1: WhatIf est automatiquement activé sur toute commande qui le prend en charge. Les utilisateurs peuvent employer la commande WhatIf avec la valeur False pour le désactiver manuellement (WhatIf:$false).

EXPLICATION DÉTAILLÉE

Quand une applet de commande prend en charge WhatIf, l’applet de commande signale l’effet attendu de la commande, au lieu d’exécuter la commande. Par exemple, au lieu de supprimer le fichier test.txt en réponse à une commande Remove-Item, Windows PowerShell signale la suppression à effectuer. Une commande Get-Childitem postérieure confirme que le fichier n’a pas été supprimé.

              PS> remove-item test.txt
              What if: Performing operation "Remove-Item" on Target "Item: 
                C:\test.txt
              PS> get-childitem test.txt

              Directory: Microsoft.PowerShell.Core\FileSystem::C:


              Mode                LastWriteTime     Length     Name
              ----                -------------     ------     ----
              -a---         7/29/2006   7:15 PM         84     test.txt

EXEMPLES

Ces exemples illustrent l’effet des différentes valeurs de $WhatIfPreference. Ils montrent é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 illustre l’effet de la valeur 0 (non activé), qui est la valeur par défaut.

             PS> $whatifpreference                     
             0                         # Check the current value.

             PS> get-childitem test.txt | format-list FullName
             FullName : C:\test.txt
                                       # Verify that the file exists.

             PS> remove-item test.txt                  
             PS>                       # Delete the file.

             PS> get-childitem test.txt | format-list -property FullName
                                       # Verify that the file is deleted.

             Get-ChildItem : Cannot find path 'C:\test.txt' because it does not exist.
             At line:1 char:14
             + get-childitem  <<<< test.txt | format-list fullname

Cet exemple illustre l’effet de l’utilisation du paramètre WhatIf quand la valeur de $WhatIfPreference est 0.

             PS> get-childitem test2.txt | format-list -property FullName 
             FullName : C:\test2.txt
                                      # Verify that the file exists.

             PS> remove-item test2.txt -whatif         
             What if: Performing operation "Remove File" on Target "C:\test2.txt".
                                      # Use the WhatIf parameter

             PS> get-childitem test2.txt | format-list -property FullName
             FullName : C:\test2.txt
                                      # Verify that the file was not deleted

Cet exemple illustre l’effet de la valeur 1 (WhatIf activé). Quand vous utilisez Remove-Item pour supprimer une applet de commande, Remove-Item affiche le chemin d’accès au fichier à supprimer, mais ne supprime pas le fichier.

             PS> $whatifpreference = 1                 
             PS> $whatifpreference
             1                        # Change the value.
                                      
             PS> remove-item test.txt                  
             What if: Performing operation "Remove File" on Target "C:\test.txt".
                                      # Try to delete a file.

             PS> get-childitem test.txt | format-list FullName
             FullName : C:\test.txt
                                      # Verify that the file exists.

Cet exemple montre comment supprimer un fichier quand la valeur de $WhatIfPreference est 1. Il utilise le paramètre WhatIf avec la valeur $false.

             PS> remove-item test.txt -whatif:$false
                                      # Use the WhatIf parameter with $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 la valeur $false.

            PS> $whatifpreference = 1                  
                                     # Change the value to 1.
                                                      
            PS> get-process winword  
                                    # A Get-Process command completes.

            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: Performing operation "Stop-Process" on Target "WINWORD (2312)".
                                    # A Stop-Process command uses WhatIf.

           PS> stop-process -name winword  -whatif:$false
           PS>                      # WhatIf:$false overrides the preference.
           
           PS> get-process winword                     
           Get-Process : Cannot find a process with the name 'winword'. Verify the process name
            and call the cmdlet again.
           At line:1 char:12
           + get-process  <<<< winword
                                    # Verify that the process is stopped.

VOIR AUSSI

about_Automatic_Variables

about_CommonParameters

about_Environment_Variables

about_Profiles

about_Remote about_Scopes