Partager via


about_Preference_Variables

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
              Whatif: 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         
             Whatif: 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                  
             Whatif: 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
           Whatif: 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