Compartilhar via


about_Preference_Variables

TÓPICO
    Variáveis de preferência

DESCRIÇÃO RESUMIDA
    Variáveis que personalizam o comportamento Windows PowerShell 

DESCRIÇÃO LONGA
    O Windows PowerShell inclui um conjunto de variáveis que permitem 
    personalizar seu comportamento. Essas "variáveis de preferência" 
    funcionam como as opções em sistemas baseados em GUI.

    As variáveis de preferência afetam o ambiente de operação do 
    Windows PowerShell e todos os comandos executados no ambiente. Em 
    muitos casos, os cmdlets têm parâmetros que você pode usar para 
    substituir o comportamento de preferência por um comando específico.

    A tabela a seguir lista as variáveis de preferência e seus 
    valores padrão.

    Variável                             Valor padrão
    --------                             -------------
    $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                 64
    $MaximumVariableCount                4096
    $OFS                                 (Space character (" "))
    $OutputEncoding              ASCIIEncoding object
    $ProgressPreference                  Continue
    $PSEmailServer                       (None)
    $PSSessionApplicationName            WSMAN
    $PSSessionConfigurationName          https://schemas.microsoft.com/powershell/microsoft.powershell 
    $PSSessionOption                     (Veja abaixo)
    $VerbosePreference                   SilentlyContinue
    $WarningPreference                   Continue
    $WhatIfPreference                    0


    O Windows PowerShell também inclui as seguintes variáveis de 
    ambiente que armazenam preferências do usuário. Para obter mais 
    informações sobre as variáveis de ambiente, consulte 
    about_environment_variables.

    Variável                                         
    --------                         
    PSModulePath                        

TRABALHANDO COM VARIÁVEIS DE PREFERÊNCIA
    Este documento descreve cada uma das variáveis de preferência.

    Para exibir o valor atual de uma variável de preferência 
    específica, digite o nome da variável. Em resposta, o Windows 
    PowerShell fornece o valor. Por exemplo, o comando a seguir exibe 
    o valor da variável $ConfirmPreference.

        PS> $ConfirmPreference
        High

    Para alterar o valor de uma variável, use uma instrução de 
    atribuição. Por exemplo, a instrução a seguir atribui o valor 
    "Medium" à variável $ConfirmPreference.

        PS> $ConfirmPreference = "Medium"

    Como todas as variáveis, os valores que você define são 
    específicos à janela do Windows PowerShell atual. Para 
    efetivá-las em todas as janelas do Windows PowerShell, 
    adicione-as ao perfil do Windows PowerShell. Para obter mais 
    informações, consulte about_profiles.


TRABALHANDO REMOTAMENTE
   Quando você executa comandos em um computador remoto, os comandos 
   remotos estão sujeitos apenas ao conjunto de preferências no 
   cliente Windows PowerShell no computador remoto. Por exemplo, 
   quando você executa um comando remoto, o valor da variável 
   $DebugPreference no computador remoto determina como o Windows 
   PowerShell responde às mensagens de depuração. 

   Para obter mais informações sobre comandos remotos, consulte 
   about_remote.



$ConfirmPreference
------------------
    Determina quais ações de cmdlet solicitam, automaticamente,  
    a confirmação do usuário antes de serem executadas. 
        
    Quando o valor de $ConfirmPreference (High, Medium, Low, None)  
    é maior ou igual ao risco da ação de cmdlet (High, Medium, Low, 
    None), o Windows PowerShell solicita automaticamente a confirmação 
    do usuário antes de executar a ação. 

    Você pode usar o parâmetro Confirm de um cmdlet para substituir  
    a preferência por um comando específico.

        Valores válidos:
           None: nenhuma ação de cmdlet é confirmada automaticamente.  
             Os usuários devem usar o parâmetro Confirm para solicitar 
             a confirmação de comandos específicos.

            Low: as ações de cmdlet com risco baixo, médio ou alto são 
             confirmadas automaticamente. Para suprimir a confirmação 
             de um comando específico, use -Confirm:$false.

         Medium: as ações de cmdlet com risco médio ou alto são confirmadas 
             automaticamente. Para habilitar a confirmação de um comando 
             específico, use -confirm. Para suprimir a confirmação de um  
             comando específico, use confirm:$false.

              High : as ações de cmdlet com risco alto são confirmadas 
            (padrão) automaticamente. Para habilitar a confirmação de um comando 
                 específico, use -confirm. Para suprimir a confirmação de um 
                 comando específico, use -confirm:$false.


    EXPLICAÇÃO DETALHADA
        Quando uma ação de cmdlet afeta o sistema significativamente, 
        como a exclusão de dados ou o uso de uma quantidade 
        significativa de recursos do sistema, o Windows PowerShell 
        pode solicitar automaticamente uma confirmação antes de 
        executar a ação. 

        Por exemplo,

        PS> remove-item pref2.txt

            Confirmar
            Tem certeza de que deseja executar esta ação?
            Executando operação "Remover Arquivo" no Destino 
            "C:\pref2.txt".
            [Y] Sim [A] Sim para Todos [N] Não [L] Não para Todos [S] 
            Suspender [?] Ajuda (o padrão é "Y"):

        A estimativa do risco é a parte do cmdlet conhecida como 
        "ConfirmImpact". Você não pode alterá-la.

        O Cmdlet que pode representar um risco ao sistema tem um 
        parâmetro Confirm que você pode usar solicitar ou suprimir 
        confirmação para um comando específico.

    Como a maioria dos cmdlets usa o valor de risco padrão Medium, e o 
    valor padrão de $ConfirmPreference é High, a confirmação automática 
    raramente ocorre. Contudo, você pode ativar a confirmação automática 
    alterando o valor de $ConfirmPreference para Medium ou Low. 

    EXEMPLOS
      Este exemplo mostra o efeito do valor padrão de $ConfirmPreferen
      ce. O valor High confirma apenas ações de cmdlet de alto risco. 
      Como a maioria das ações é de risco médio, elas não são 
      confirmadas automaticamente, embora você possa usar o parâmetro 
      Confirm do cmdlet para solicitar confirmação de um comando 
      específico.

          PS> $confirmpreference              #Obtenha o valor 
          High                         atual da variável 

          PS> remove-item temp1.txt           #Exclua um arquivo
          PS>                                 #Excluído sem confirmação 
          PS> remove-item temp2.txt -confirm  #Use o parâmetro Confirm

          Confirmar
          Tem certeza de que deseja executar esta ação?
          Executando operação "Remover Arquivo" no Destino "C:\temp2.txt".
          [Y] Sim [A] Sim para Todos [N] Não [L] Não para Todos  
          [S] Suspender [?] Ajuda (o padrão é "Y"):


       Este exemplo mostra o efeito da alteração do valor de 
       $ConfirmPrefernce para Medium. Como a maioria das ações de 
       cmdlet é de risco médio, elas são confirmadas automaticamente, 
       e você tem que usar o parâmetro Confirm com um valor de $false 
       para suprimir a solicitação de confirmação para um comando 
       específico.

            
          PS> $confirmpreference = "Medium" 
                                     # Altere o valor de $ConfirmPreference 
          PS> remove-item temp2.txt
                                     # A exclusão de um arquivo 
                                     dispara a confirmação 
          Confirmar
          Tem certeza de que deseja executar esta ação?
          Executando operação "Remover Arquivo" no Destino "C:\temp2.txt".
          [Y] Sim [A] Sim para Todos [N] Não [L] Não para Todos 
          [S] Suspender [?] Ajuda (o padrão é "Y"):
    

          PS> remove-item temp3.txt -confirm:$false  # Use o parâmetro Confirm
                                   para suprimir a confirmação 
          PS>

$DebugPreference
------------------
    Determina como o Windows PowerShell responde a mensagens de 
    depuração geradas por um script, cmdlet ou provedor, ou por um 
    comando Write-Debug na linha de comando. 

        Alguns cmdlets exibem mensagens de depuração que normalmente 
        são mensagens muito técnicas, criadas para programadores e 
        profissionais de suporte técnicos. Por padrão, as mensagens 
        de depuração não são exibidas, mas você pode exibi-las 
        alterando o valor de $DebugPreference.
        
        Você também pode usar o parâmetro Debug comum de um cmdlet 
        para exibir ou ocultar as mensagens de depuração para um 
        comando específico. Para obter mais informações, digite "get-help 
        about_commonparameters".

        Valores válidos:
        Stop:               exibe a mensagem de depuração e para  
                    a execução. Grava um erro no console.

            Inquire:            exibe a mensagem de depuração e pergunta 
                        se você deseja continuar.

            Continue:           exibe a mensagem de depuração e continua 
                        a execução.

            SilentlyContinue:   Nenhum efeito. A mensagem de depuração não é 
               (Default)    exibida e a execução continua sem interrupção.
             

    EXEMPLOS
    
    Os exemplos a seguir mostram o efeito da alteração dos valores de 
    $DebugPreference quando em um comando Write-Debug é digitado na 
    linha de comando. A alteração afeta todas as mensagens de 
    depuração, inclusive aquelas geradas por cmdlets e scripts. Os 
    exemplos também mostram o uso do parâmetro Debug comum que exibe 
    ou oculta as mensagens de depuração relacionadas a um único comando.

    Este exemplo mostra o efeito do valor padrão, "SilentlyContinue". 
    A mensagem de depuração não é exibida e o processamento continua. 
    O comando final usa o parâmetro Debug para substituir a 
    preferência para um único comando.

        PS> $debugpreference                    # Obtenha o valor atual de 
        SilentlyContinue                          $DebugPreference

        PS> write-debug "Hello, World"
        PS>                                     # A mensagem de depuração 
                              não é exibida.

    PS> write-debug "Hello, World" -Debug   # Use o parâmetro Debug
        DEBUG: Hello, World                     # A mensagem de depuração 
                              é solicitada Confirmar?
        Continuar esta operação?
        [S] Sim [A] Sim para Todos [P] Parar Comando [U] Suspender 
        [?] Ajuda (o padrão é "S"):

   
    Este exemplo mostra o efeito do valor "Continue". O comando final 
    usa o parâmetro Debug com um valor de $false para suprimir a 
    mensagem para um único comando.

        PS> $debugpreference = "Continue"   # Altere o valor para "Continue"

        PS> write-debug "Hello, World"
        DEBUG: Hello, World                 # A mensagem de depuração 
        PS>                    é exibida e o processamento continua.
        

        PS> write-debug "Hello, World" -Debug:$false  
                                            # Use o parâmetro Debug com false.
        PS>                                 # A mensagem de depuração não é exibida.

        
    Este exemplo mostra o efeito do valor "Stop". O comando final usa 
    o parâmetro Debug com um valor de $false para suprimir a mensagem 
    para um único comando.

        PS> $debugpreference = "Stop"       # Altere o valor para "Stop"
        PS> write-debug "Hello, World"
        DEBUG: Hello, World
        Write-Debug: a execução do comando foi parada porque a variável do shell 
        "DebugPreference" está definida como Stop.
        At line:1 char:12
        + write-debug <<<< "Hello, World"

        PS> write-debug "Hello, World" -Debug:$false  
                                            # Use o parâmetro Debug com $false.
                                            
        PS>                      # A mensagem de depuração não  
                              é exibida e o processamento 
                                              não é parado.
      

    Este exemplo mostra o efeito do valor "Inquire". O comando final 
    usa o parâmetro Debug com um valor de $false para suprimir a 
    mensagem para um único comando.

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

        Confirmar
        Continuar esta operação?
        [S] Sim [A] Sim para Todos [P] Parar Comando [U] Suspender 
        [?] Ajuda (o padrão é "S"):

        PS> write-debug "Hello, World" -Debug:$false  
                                            # Use o parâmetro Debug com $false.
                                            
        PS>                          # A mensagem de depuração não  
                              é exibida e o processamento continua 
                                              sem interrupção.


$ErrorActionPreference
----------------------
    Determina como o Windows PowerShell responde a um erro de 
    não-encerramento (um erro que não para o processamento de cmdlet) na 
    linha de comando ou em um script, cmdlet ou provedor, como os erros 
    gerados pelo cmdlet Write-Error. 

        Você também pode usar o parâmetro ErrorAction comum de um 
        cmdlet para substituir a preferência para um comando 
        específico. Para obter mais informações, digite "get-help 
        about_commonparameters".


        Valores válidos:
        Stop:               exibe a mensagem de erro e para a execução. 

            Inquire:            exibe a mensagem de erro e 
                            pergunta se você deseja continuar.

            Continue:           exibe a mensagem de erro e 
                            continua a execução.

            SilentlyContinue:   Nenhum efeito. A mensagem de erro não é exibida
            (Default)           e a execução continua sem interrupção.


       Nem $ErrorActionPreference nem o parâmetro comum ErrorAction 
       afetam o modo como o Windows PowerShell responde a erros de 
       encerramento (aqueles que param o processamento de cmdlet).

       Para obter mais informações sobre o parâmetro comum 
       ErrorAction, digite "get-help about_commonparameters".


    EXEMPLOS

    Estes exemplos mostram o efeito dos valores diferentes de 
    $ErrorActionPreference e o uso do parâmetro comum ErrorAction 
    para substituir a preferência para um único comando. O parâmetro 
    ErrorAction tem os mesmos valores válidos que a variável 
    $ErrorActionPreference.
    
    Este exemplo mostra o efeito do valor padrão Continue.

        PS> $erroractionpreference                      
        Continue        # Exiba o valor da preferência.                
        
        PS> write-error "Hello, World"                  
                                # Gere um erro de não-encerramento.

        write-error "Hello, World" : Hello, World        
                                # A mensagem de erro é exibida e a 
                                  execução continua.

        PS> write-error "Hello, World" -ErrorAction:SilentlyContinue
                                # Use o parâmetro ErrorAction com um 
                                  valor de "SilentlyContinue".
        PS>                                             
                                # A mensagem de erro não é exibida e 
                                  a execução continua.

    Este exemplo mostra o efeito do valor SilentlyContinue.

        PS> $ErrorActionPreference = "SilentlyContinue"
                                # Altere o valor da preferência.
        PS> write-error "Hello, World"                  
                                # Gere uma mensagem de erro.
        PS>                     
                                # A mensagem de erro é suprimida.
        PS> write-error "Hello, World" -erroraction:continue
                                # Use o parâmetro ErrorAction com um 
                                  valor de "Continue".
        write-error "Hello, World" -erroraction:continue : Hello, World 
                                # A mensagem de erro é exibida 
                                e a execução continua.

       
    Este exemplo mostra o efeito de um erro real. Neste caso, o 
    comando obtém um arquivo inexistente, nofile.txt. O exemplo 
    também usa o parâmetro comum ErrorAction para substituir a 
    preferência.

        PS> $erroractionpreference                      
        SilentlyContinue        # Exiba o valor da preferência.   

        PS> get-childitem -path nofile.txt
        PS>                     # A mensagem de erro é suprimida.

        PS> $ErrorActionPreference = "Continue" 
                                # Altere o valor para Continue.

        PS> get-childitem -path nofile.txt
        Get-ChildItem: não é possível localizar o caminho 
        'C:\nofile.txt' porque ele não existe.
        At line:1 char:4
        + get-childitem <<<< nofile.txt

        PS> get-childitem -path nofile.txt -erroraction SilentlyContinue
                                # Use o parâmetro ErrorAction 
                                # A mensagem de erro é suprimida.
  
        PS> $ErrorActionPreference = "Inquire"          
                                # Altere o valor para Inquire.
        PS> get-childitem -path nofile.txt

        Confirmar
        Não é possível localizar o caminho 'C:\nofile.txt' porque ele 
        não existe.
        [S] Sim [A] Sim para todos [P] Parar Comando [U] Suspender 
        [?] Ajuda (o padrão é "S"): s 
        
        Get-ChildItem: não é possível localizar o caminho 
        'C:\nofile.txt' porque ele não existe.
        At line:1 char:4
        + get-childitem <<<< nofile.txt

        PS> $ErrorActionPreference = "Continue"                  
                                # Altere o valor para Continue.
        PS> Get-Childitem nofile.txt -erroraction "Inquire"   
                                # Use o parâmetro ErrorAction para 
                                  substituir o valor de preferência.

        Confirmar
        Não é possível localizar o caminho 'C:\nofile.txt' porque ele 
        não existe. [S] Sim [A] Sim para Todos [P] Parar Comando 
        [U] Suspender [?] Ajuda (o padrão é "S"):


$ErrorView
----------
        Determina o formato de exibição de mensagens de erro no 
        Windows PowerShell. 

        Valores válidos:
        NormalView:         uma exibição detalhada 
         (padrão)           criada para a maioria dos usuários. 
                            Consiste em uma descrição do 
                            erro, o nome do objeto envolvido no 
                            erro e setas (<<<<) que apontam para 
                            as palavras no comando que causou o erro.

            CategoryView:       uma exibição sucinta, estruturada criada 
                            para ambientes de produção. O formato 
                                é:{Category}: ({TargetName}:{TargetType}):[{Activity}], {Reason}

        Para obter mais informações sobre os campos em CategoryView, 
        consulte "ErrorCategoryInfo class" no Windows PowerShell SDK.
        
    EXEMPLOS

    Estes exemplos mostram o efeito dos valores ErrorView.

    Este exemplo mostra como um erro será exibido quando o valor de 
    $ErrorView for NormalView. Neste caso, o comando Get-ChildItem é 
    usado para localizar um arquivo inexistente.

        PS> $ErrorView                         # Verifique o valor.
        NormalView

        PS> get-childitem nofile.txt           # Localize um arquivo inexistente.
        Get-ChildItem: não é possível localizar o caminho 'C:\nofile.txt' porque 
        ele não existe.
        At line:1 char:14
        + get-childitem <<<< nofile.txt

    Este exemplo mostra como o mesmo erro será exibido quando o valor 
    de $ErrorView for CategoryView.

        PS> $ErrorView = "CategoryView"        # Altere o valor para 
                                                 CategoryView                                                 

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

 
   Este exemplo demonstra que o valor de ErrorView afeta apenas a 
   exibição do erro; ele não a estrutura do objeto de erro que é 
   armazenado na variável automática $erro. Para obter mais 
   informações sobre a variável automática $error, consulte 
   about_automatic_variables.

   Este comando obtém o objeto ErrorRecord associado ao mais recente 
   erro na matriz de erro (elemento 0) e formata todas as 
   propriedades do objeto de erro em uma lista.
           
        PS> $error[0] | format-list -property * -force

        Exception  : System.Management.Automation.ItemNotFoundExceptio
                     n: 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
-----------------------
        Determina quantos itens enumerados são incluídos em uma 
        exibição. Esta variável não afeta os objetos subjacentes; 
        apenas a exibição.
        Quando o valor de $FormatEnumerationLimit for menor que o 
        número de itens enumerados, o Windows PowerShell adicionará 
        reticências (...) para indicar os itens não mostrados.

        Valores válidos: Integers (Int32)
        Valor padrão: 4

    EXEMPLOS

        Este exemplo mostra como usar a variável $FormatEnumerationLim
        it para melhorar a exibição de itens enumerados. 

        O comando neste exemplo gera uma tabela que lista todos os 
        serviços em execução no computador em dois grupos; um para 
        serviços em execução e um para serviços parados. Ele usa um 
        comando Get-Service para obter todos os serviços e, em 
        seguida, enviar os resultados pelo pipeline para o cmdlet 
        Group-Object, que agrupa os resultados por status de serviço. 

        A exibição resultante é uma tabela que lista o status na 
        coluna Nome e os processos com aquele status na coluna Grupo. 
        (Para alterar os rótulos da coluna, use uma tabela de hash. 
        Para obter mais informações, consulte os exemplos em 
        "get-help format-table -examples".) 

        Há um máximo de quatro serviços listado na coluna Grupo para 
        cada status. Para aumentar o número de itens listado, aumente 
        o valor de $FormatEnumerationLimit para 1000.

        Na exibição resultante, a lista na coluna Grupo é limitada 
        agora pelo comprimento de linha. No comando final no exemplo, 
        use o parâmetro Wrap de Format-Table para exibir todos os 
        processos em cada grupo Status.
         

        PS> $formatenumerationlimit         # Localize o valor 
        atual
        4
        
        PS> get-service | group-object -property status           
                                            # Liste todos os serviços 
                                            agrupados por status

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

                                           # A lista é truncada 
                                             depois de quatro itens.


        PS> $formatenumerationlimit = 1000
                                           # Aumente o limite para 1000.
        
        PS> get-service | group-object -property status           
                                           # Repita o comando.

        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
                                           # Adicione o parâmetro Wrap.

        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, FastUserSwitchingCompatibi
                         lity, 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
----------
        As variáveis de preferência Log*Event determinam que tipos de 
        eventos são gravados no log de eventos do Windows PowerShell 
        no Visualizador de Eventos. Por padrão, somente os eventos de 
        mecanismo e provedor são registrados em log, mas você pode 
        usar as variáveis de preferência Log*Event para personalizar 
        seu log, como registrar em log eventos sobre comandos.   

        As variáveis de preferência Log*Event são como segue:

            $LogCommandHealthEvent: registra em log erros e exceções 
                na inicialização e no processamento do comando. 
                Default = $false (not logged).

            $LogCommandLifecycleEvent: 
                Registra em log a inicialização e a parada de 
                comandos e de pipelines de comando e exceções de 
                segurança na descoberta do comando. Default = $false 
                (not logged).

            $LogEngineHealthEvent: erros de logs e falhas de 
                sessões. Default = $true (logged).

            $LogEngineLifecycleEvent: registra em log a abertura e o 
                fechamento de sessões. Default = $true (logged).

            $LogProviderHealthEvent: erros de provedor de Logs, como 
                erros de leitura e gravação, erros de pesquisa e de 
                invocação. Default = $true (logged).

            $LogProviderLifecycleEvent: adição e remoção de logs de 
            provedores do Windows PowerShell.
                Default = $true (logged). (Para obter mais 
                informações sobre os provedores do Windows 
                PowerShell, digite: "get-help about_provider".


        Para habilitar um Log*Event, digite a variável com um valor 
        de $true, por exemplo:

            $LogCommandLifeCycleEvent

            - ou -

            $LogCommandLifeCycleEvent = $true


        Para desabilitar um tipo de evento, digite a variável com um 
        valor de $false, por exemplo:

            $LogCommandLifeCycleEvent = $false

        Os eventos que você habilita serão efetivados somente para o 
        console do Windows PowerShell atual. Para aplicar a 
        configuração a todos os consoles, salve as configurações de 
        variáveis em seu perfil do Windows PowerShell.


$MaximumAliasCount
------------------
        Determina quantos aliases são permitidos em uma sessão do 
        Windows PowerShell. O valor padrão, 4096, deve ser suficiente 
        para a maioria dos usos, mas você pode ajustá-lo para atender 
        a suas necessidades.

        Valores válidos: 1024 - 32768 (Int32)
        Padrão: 4096
      
        Para contar os aliases no seu sistema, digite: 

        (get-alias).count

$MaximumDriveCount
------------------
        Determina quantas unidades do Windows PowerShell são 
        permitidas em uma determinada sessão. Isso inclui unidades do 
        sistema de arquivos e repositórios de dados expostos pelos 
        provedores do Windows PowerShell e exibidos como unidades 
        Alias: e HKLM:, por exemplo.

        Valores válidos: 1024 - 32768 (Int32)
        Padrão: 4096
      
        Para contar os aliases no seu sistema, digite: 

        (get-psdrive).count



$MaximumErrorCount
------------------
        Determina quantos erros são salvos no histórico de erros 
        durante a sessão. 

        Valores válidos: 256 - 32768 (Int32)
        Padrão: 256

        Os objetos que representam cada erro mantido são armazenados 
        na variável automática $Error. Esta variável contém uma 
        matriz de objetos de registro de erros, uma para cada erro.  
        O erro mais recente é o primeiro objeto na matriz ($Error[0]).
      
        Para contar os erros no seu sistema, use a propriedade Count 
        da matriz $Erro. Digite:
        
        $Error.count

        Para exibir um erro específico, use a anotação de matriz. 
        Por exemplo, para ver o erro mais recente, digite:

                $Error[0]

        Para exibir o erro mantido mais antigo, digite:

                $Error[($Error.Count -1]

        Para exibir as propriedades de um objeto ErrorRecord, digite:

                $Error[0] | format-list -property * -force

        Nesse comando, o parâmetro Force substitui a formatação 
        especial de objetos ErrorRecord e reverte para o formato 
        convencional.

        Para excluir todos os erros do histórico de erros, use o 
        método Clear da matriz de erro.

               PS> $Error.count
               17
               PS> $Error.clear()
               PS>
               PS> $Error.count
               0

       Para localizar todas as propriedades e métodos de uma matriz 
       de erro, use o cmdlet Get-Member com o parâmetro InputObject. 
       Quando você envia uma coleção de objetos para Get-Member, 
       Get-Member exibe as propriedades e os métodos dos objetos na 
       coleção. Quando você usa o parâmetro InputObject de 
       Get-Member, Get-Member exibe as propriedades e os métodos da 
       coleção.


$MaximumFunctionCount
------------------
        Determina quantas funções são permitidas em uma determinada 
        sessão. 

        Valores válidos: 1024 - 32768 (Int32)
        Padrão: 4096

        Para consultar as funções na sua sessão, use a unidade 
        Function: do Windows PowerShell que é exposta pelo provedor 
        de função do Windows PowerShell. (Para obter mais informações 
        sobre o provedor de função, digite "get-help function").

        Para listar as funções na sessão atual, digite:

            get-childitem function:

        Para contar as funções na sessão atual, digite:

            (get-childitem function:).count


$MaximumHistoryCount
------------------
        Determina quantos comandos são salvos no histórico de 
        comandos durante a sessão atual. 

        Valores válidos: 1 - 32768 (Int32)
        Padrão: 64

        Para determinar o número de comandos salvos atualmente no 
        histórico de comandos, digite:
 
            (get-history).count

        Para consultar o comando salvo em seu histórico de sessão, 
        use o cmdlet Get-History. Para obter mais informações, digite 
        "get-help about_history".



$MaximumVariableCount
------------------
        Determina quantas variáveis são permitidas em uma determinada 
        sessão, inclusive variáveis automáticas, variáveis de 
        preferência e variáveis que você cria em comandos e scripts. 

        Valores válidos: 1024 - 32768 (Int32)
        Padrão: 4096

        Para consultar as variáveis na sua sessão, use o cmdlet 
        Get-Variable e os recursos da unidade Variable: do Windows 
        PowerShell e o provedor de variável do Windows PowerShell. 
        Para obter informações sobre o provedor de variável, digite: 
        "get-help variable".

        Para localizar o número atual de variáveis no sistema, digite:

            (get-variable).count



$OFS
----
        Separador do campo de saída. Especifica o caractere que 
        separa os elementos de uma matriz quando a matriz é 
        convertida para uma cadeia de caracteres. 

        Valores válidos: qualquer cadeia de caracteres.
        Padrão: espaço

        Por padrão, a variável $OFS não existe e o separador de 
        arquivo de saída é um espaço, mas você pode adicionar essa 
        variável e defini-la para qualquer cadeia de caracteres.

    EXEMPLOS

    Este exemplo mostra que um espaço é usado para separar os valores 
    quando uma matriz é convertida para uma cadeia de caracteres. 
    Neste caso, uma matriz de inteiros é armazenada em uma variável 
    e, em seguida, a variável é convertida para uma cadeia de caracteres.

       PS> $array = 1,2,3                 # Armazene uma matriz de inteiros.    
          

       PS> [string]$array                 # Converta a matriz para 
       1 2 3                                uma cadeia de caracteres.
                                          # Espaços separam os elementos


    Para alterar o separador, adicione a variável $OFS atribuindo um 
    valor a ela. Para funcionar corretamente, a variável deve ser 
    nomeada $OFS. 

       PS> $OFS = "+"                     # Crie $OFS e atribua um "+"

       PS> [string]$array                 # Repita o comando
       1+2+3                              # Sinais de adição separam os elementos


    Para restaurar o comportamento padrão, você pode atribuir um 
    espaço ("") ao valor de $OFS ou pode excluir a variável. Este 
    comando exclui a variável e verifica se o separador é um espaço.
        
       PS> Remove-Variable OFS            # Exclua $OFS
       PS>

       PS> [string]$array                 # Repita o comando
       1 2 3                              # Espaços separam os elementos 

$OutputEncoding
---------------
       Determina o método de codificação de caractere usado pelo 
       Windows PowerShell quando ele envia texto a outros 
       aplicativos. Por exemplo, se um aplicativo retornar cadeias de 
       caracteres Unicode ao Windows PowerShell, talvez você precise 
       alterar o valor para enviar os caracteres corretamente.

        Valores válidos: objetos derivados de uma classe de codificação, 
                         como ASCIIEncoding, SBCSCodePageEncoding, 
                         UTF7Encoding, UTF8Encoding, UTF32Encoding 
                         e UnicodeEncoding.

        Padrão: objeto ASCIIEncoding (System.Text.ASCIIEncoding)

    EXEMPLOS

       Este exemplo mostra como fazer o comando FINDSTR no Windows 
       funcionar no Windows PowerShell em um computador que é 
       localizado para um idioma que usa caracteres Unicode, como o 
       chinês. 

       O primeiro comando localiza o valor de $OutputEncoding. Como o 
       valor é um objeto de codificação, exiba somente sua 
       propriedade EncodingName.
         
          PS> $OutputEncoding.EncodingName # Localize o valor atual
          US-ASCII

       Neste exemplo, um comando FINDSTR é usado para procurar dois 
       caracteres chineses que estão presente no arquivo Test.txt. 
       Quando este comando FINDSTR é executado no Prompt de comando 
       do Windows (Cmd.exe), FINDSTR localiza os caracteres no 
       arquivo de texto. Contudo, quando você executa o mesmo comando 
       FINDSTR no Windows PowerShell, os caracteres não são 
       localizados porque o Windows PowerShell os envia para FINDSTR 
       em texto ASCII, em vez de Unicode.

          PS> findstr <Unicode-characters>  # Use findstr para pesquisa.
          PS>                               # Nenhum encontrado.

        
       Para fazer o comando funcionar no Windows PowerShell, defina o 
       valor de $OutputEncoding como o valor da propriedade 
       OutputEncoding do console que é baseado na localidade 
       selecionada para o Windows. Como OutputEncoding é uma 
       propriedade estática do console, use dois-pontos (::)duplos no 
       comando.

          PS> $OutputEncoding = [console]::outputencoding
          PS>                               # Defina o valor igual a
                                              propriedade OutputEncoding 
                                              do console.
          PS> $OutputEncoding.EncodingName               
          OEM United States
                                            # Localize o valor resultante.
     
       Como resultado desta alteração, o comando FINDSTR localiza os 
       caracteres.

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

                    # Use findstr para pesquisar. Localiza o
                                          caracteres no arquivo de texto.



$ProgressPreference
-------------------
    Determina como o Windows PowerShell responde a atualizações de 
    progresso geradas por um script, cmdlet ou provedor, como as barras 
    de progresso geradas pelo cmdlet Write-Progress. O cmdlet 
    Write-Progress cria barras de progresso que descrevem o status de um 
    comando.

        Valores válidos:
        Stop:               não exibe a barra de progresso. Em vez 
                        disso, ele exibe a mensagem de erro e 
                            para a execução.

            Inquire:            não exibe a barra de progresso. 
                                Solicita permissão para continuar. 
                            Se você responder com Y ou A, exibe 
                            a barra de progresso.

            Continue:           exibe a barra de progresso e 
            (Padrão)            continua a execução.

            SilentlyContinue:   executa o comando, mas não exibe a 
        
            
            barra de progresso.


$PSEmailServer
--------------
       Especifica o servidor de email padrão que é usado para enviar 
       mensagens de email. Esta variável de preferência é usada por 
       cmdlets que enviam email, como o cmdlet Send-MailMessage. 


$PSSessionApplicationName
---------------------------
       Especifica o nome de aplicativo padrão para um comando remoto 
       que usa tecnologia WS-Management.

       O nome de aplicativo padrão do sistema é WSMAN, mas você pode 
       usar essa variável de preferência para alterar o padrão. 

       O nome do aplicativo é o último nó em um URI de conexão. Por 
       exemplo, o nome de aplicativo no URI de exemplo a seguir é WSMAN.

           http://Server01:8080/WSMAN


       O nome de aplicativo padrão é usado quando o comando remoto 
       não especifica um URI de conexão ou um nome de aplicativo.  

       O serviço WinRM usa o nome de aplicativo para selecionar um 
       ouvinte para atender à solicitação de conexão. O valor deste 
       parâmetro deve corresponder ao valor da propriedade URLPrefix 
       de um ouvinte no computador remoto.

       Para substituir o padrão de sistema e o valor dessa variável, 
       e selecionar um nome de aplicativo diferente para uma sessão 
       específica, use os parâmetros ConnectionURI ou ApplicationName 
       de cmdlets New-PSSession, Enter-PSSession ou Invoke-Command.   

       Esta variável de preferência é definida no computador local, 
       mas especifica um ouvinte no computador remoto. Se o nome de 
       aplicativo especificado não existir no computador remoto, 
       ocorrerá uma falha no comando que estabelece a sessão.



$PSSessionConfigurationName
---------------------------
       Especifica a configuração de sessão padrão usada para 
       PSSessions criada na sessão atual.

       Esta variável de preferência é definida no computador local, 
       mas especifica uma configuração de sessão localizada no 
       computador remoto. 

       O valor da variável $PSSessionConfigurationName é um URI de 
       recurso totalmente qualificado. 

       O valor padrão: 

         https://schemas.microsoft.com/powershell/microsoft.powershell 

       indica a configuração da sessão Microsoft.PowerShell no 
       computador remoto. 

       Se você especificar só um nome de configuração, o URI de 
       esquema a seguir será prefixado:

           https://schemas.microsoft.com/powershell/

             
       Você pode substituir o padrão e selecionar uma configuração de 
       sessão diferente para uma sessão específica usando o parâmetro 
       ConfigurationName de cmdlets New-PSSession, Enter-PSSession ou 
       Invoke-Command.   

       Você pode alterar o valor dessa variável a qualquer momento. 
       Quando alterar, lembre-se de que a configuração de sessão que 
       você seleciona deve existir no computador remoto. Se não 
       existir, ocorrerá uma falha no comando para criar uma sessão 
       que usa a configuração de sessão.

       Esta variável de preferência não determina quais configurações 
       de sessão local são usadas quando os usuários remotos criam 
       uma sessão que se conecta a este computador. Contudo, você 
       pode usar as permissões para as configurações de sessão local 
       para determinar quais usuários podem usá-las.


$PSSessionOption
----------------
        Estabelece os valores padrão para opções de usuário avançado 
        em uma sessão remota. Estas preferências de opção substituem 
        os valores padrão de sistema para opções de sessão. 

        Você também pode definir opções personalizadas para uma 
        sessão remota específica usando o parâmetro SessionOption em 
        cmdlets que criam uma sessão, como New-PSSession, 
        Enter-PSSession e Invoke-Command. O valor do parâmetro 
        SessionOption tem precedência sobre os padrões de sistema e 
        os padrões que são definidos nesta variável.

        A variável $PSSessionOption contém um objeto PSSessionOption<c
        h='32' Tm='7'> (System.Management.Automation.Remoting.PSSessio
        nObject). Cada propriedade do objeto representa uma opção de 
        sessão. Por exemplo, as propriedades NoCompression desativam 
        a compactação de dados durante a sessão.

        Para criar a variável de preferência $PSSessionOption, use o 
        cmdlet New-PSSessionOption. Salve a saída em uma variável chamada 
        $PSSessionOption. 

        Por exemplo,

            $PSSessionOption = New-PSSessionOption -NoCompression 

        Para usar a variável de preferência $PSSessionOption em cada 
        sessão do Windows PowerShell, adicione um comando 
        New-PSSessionOption que cria a variável $PSSessionOption ao 
        perfil do Windows PowerShell.

        Para obter mais informações sobre o cmdlet New-PSSessionOption, 
        consulte o tópico da ajuda para New-PSSessionOption. Para 
        obter mais informações sobre sessões e comandos remotos, 
        consulte about_Remote e about_PSSessions.
        Para obter mais informações sobre o uso de um perfil, 
        consulte about_Profiles.




$VerbosePreference
------------------
        Determina como o Windows PowerShell responde a mensagens 
        detalhadas geradas por um script, cmdlet ou provedor, como 
        aquelas geradas pelo cmdlet Write-Verbose. Normalmente, as 
        mensagens detalhadas descrevem as ações realizadas para 
        executar um comando. 

        Por padrão, as mensagens detalhadas não são exibidas, mas 
        você pode alterar esse comportamento alterando o valor de 
        $VerbosePreference.

        Você também pode usar o parâmetro Verbose comum de um cmdlet 
        para exibir ou ocultar as mensagens detalhadas para um 
        comando específico. Para obter mais informações, digite "get-help 
        about_commonparameters".


        Valores válidos:
        Stop:               exibe a mensagem detalhada e uma mensagem 
                            de erro e, em seguida, para a execução.

            Inquire:            Exibe a mensagem detalhada e, em 
                                seguida, exibe um prompt que pergunta se 
                            você deseja continuar.

            Continue:           exibe a mensagem detalhada e, 
                                em seguida, continua a execução.

            SilentlyContinue:   não exibe a mensagem detalhada. Continua a execução.
            (Padrão)

    EXEMPLOS

    Estes exemplos mostram o efeito dos valores diferentes de 
    $VerbosePreference e o uso do parâmetro comum Verbose para 
    substituir o valor de preferência.
    
    Este exemplo mostra o efeito do valor padrão SilentlyContinue.

        PS> $VerbosePreference             # Localize o valor atual.
        SilentlyContinue

        PS> Write-Verbose "Verbose message test."              
        PS>                                # Escreva uma mensagem detalhada.
                                           # A mensagem não é exibida.

        PS> Write-Verbose "Verbose message test." -verbose   
        DETALHE: teste de mensagem detalhada.
                                       # Use o parâmetro Verbose.


    Este exemplo mostra o efeito do valor Continue.

        PS> $VerbosePreference = "Continue"                    
                                           # Altere o valor para Continue.
        PS> Write-Verbose "Verbose message test."              
                                           # Escreva uma mensagem detalhada.
        DETALHE: teste de mensagem detalhada.                          
                                           # A mensagem é exibida.

        PS> Write-Verbose "Verbose message test." -verbose:$false
                                           # Use o parâmetro Verbose 
                                           com um valor de $false.
        PS>                                  
                                           # A mensagem não é exibida.


    Este exemplo mostra o efeito do valor Stop.

        PS> $VerbosePreference = "Stop"                        
                                           # Altere o valor para Stop.
        PS> Write-Verbose "Verbose message test."              
                                           # Escreva uma mensagem detalhada.
        DETALHE: teste de mensagem detalhada.
        Write-Verbose: a execução do comando foi parada porque a 
        variável do shell "VerbosePreference" está definida como Stop.
        At line:1 char:14
        + Write-Verbose <<<< "Verbose message test."

        PS> Write-Verbose "Verbose message test." -verbose:$false
                                          # Use o parâmetro Verbose 
                                            com um valor de $false. 
        PS>   
                                          # A mensagem não é exibida.

    Este exemplo mostra o efeito do valor Inquire.

       PS> $VerbosePreference = "Inquire"                      
                                         # Altere o valor para Inquire.
       PS> Write-Verbose "Verbose message test."               
       DETALHE: teste de mensagem detalhada.
                                         # Escreva uma mensagem detalhada.
       Confirmar
       Continuar esta operação?
       [S] Sim [A] Sim para Todos [P] Parar Comando [U] Suspender 
       [?] Ajuda (o padrão é "S"): s 

       PS> Write-Verbose "Verbose message test." -verbose:$false
                                        # Use o parâmetro Verbose.
       PS>                              
                                        # A mensagem não é exibida.


    
$WarningPreference
------------------
        Determina como o Windows PowerShell responde a mensagens de 
        aviso geradas por um script, cmdlet ou provedor, como aquelas 
        geradas pelo cmdlet Write-Warning.

        Por padrão, as mensagens de aviso não são exibidas e a 
        execução continua, mas você pode alterar esse comportamento 
        alterando o valor de $WarningPreference.

        Também é possível usar o parâmetro comum WarningAction de um 
        cmdlet para determinar como o Windows PowerShell responde a 
        avisos resultantes de um comando específico. Para obter mais 
        informações, digite "get-help about_commonparameters".


        Valores válidos:
        Stop:               exibe a mensagem de aviso e uma mensagem 
                        de erro e, em seguida, para a execução.

            Inquire:            exibe a mensagem de aviso e, em 
                            seguida, solicita permissão para continuar. 

            Continue:           exibe a mensagem de aviso e 
            (Padrão)        continua a execução.

            SilentlyContinue:   não exibe a mensagem de aviso. 
                            Continua a execução.

    EXEMPLOS

    Estes exemplos mostram o efeito dos valores diferentes de 
    $WarningPreference e o uso do parâmetro comum WarningAction para 
    substituir o valor de preferência.

    
    Este exemplo mostra o efeito do valor padrão Continue.

            PS> $WarningPreference  # Localize o valor padrão.                           
            Continue                  

                                      # Grave uma mensagem de aviso.
            PS> Write-Warning "This action can delete data."   
            AVISO: esta ação pode excluir dados.
                                        
                                      # Use o parâmetro WarningAction 
                                      para Write-Warning "This action 
                                      can delete data." 
                                      -warningaction silentlycontinue   



   Este exemplo mostra o efeito do valor SilentlyContinue.

            PS> $WarningPreference = "SilentlyContinue"           
                                      # Altere o valor para SilentlyContinue.
 
            PS> Write-Warning "This action can delete data."   
            PS>                        # Grave uma mensagem de aviso.

       
            PS> Write-Warning "This action can delete data." 
            -warningaction stop   
                                      # Use o parâmetro WarningAction 
                                      para parar o # processamento 
                                      quando esse comando gera 
                                      WARNING: This action can delete data.
            Write-Warning: a execução do comando foi parada porque a 
            variável do shell "WarningPreference" está definida como Stop.
            At line:1 char:14
            + Write-Warning <<<< "This action can delete data." 
            -warningaction stop 


    Este exemplo mostra o efeito do valor Inquire.

           PS> $WarningPreference = "Inquire"                    
                                      # Altere o valor para Inquire.
           PS> Write-Warning "This action can delete data."  
                                      # Grave uma mensagem de aviso.  
                                       AVISO: esta ação pode excluir dados.
                                     
           Confirmar
           Continuar esta operação?
           [S] Sim [A] Sim para Todos [P] Parar Comando [U] Suspender 
           [?] Ajuda (o padrão é "S"): s 

           PS> Write-Warning "This action can delete data." -warningaction 
           silentlycontinue
           PS>                         # Use o parâmetro WarningAction para alterar a
                                       # resposta para um aviso para o comando atual.
                                      


     Este exemplo mostra o efeito do valor Stop.

           PS> $WarningPreference = "Stop"                       
                                     # Altere o valor para Stop.

           PS> Write-Warning "This action can delete data."   
                                     # Grave uma mensagem de aviso.
           AVISO: esta ação pode excluir dados.
           Write-Warning: a execução do comando foi parada porque a 
           variável do shell "WarningPreference" está definida como Stop.
           At line:1 char:14
           + Write-Warning <<<< "This action can delete data."


           PS> Write-Warning "This action can delete data." -warningaction inquire
           AVISO: esta ação pode excluir dados.

           Confirmar
           Continuar esta operação?
           [S] Sim [A] Sim para Todos [P] Parar Comando [U] Suspender 
           [?] Ajuda (o padrão é "S"):                        
                                       # Use o parâmetro WarningAction para 
                                       alterar a # resposta para um 
                                       aviso para o comando atual.


$WhatIfPreference
------------------
        Determina se WhatIf é habilitado automaticamente para cada 
        comando que o aceita. Quando WhatIf é habilitado, o cmdlet 
        relata o efeito esperado do comando, mas não executa o comando. 

        Valores válidos:
        0:                  WhatIf não é habilitado automaticamente. 
        (Padrão)            Para habilitá-lo manualmente, use o parâmetro 
                            WhatIf do comando.
            

            1:                  WhatIf é habilitado automaticamente em 
                                qualquer comando que o aceita. Os usuários 
                                podem usar o comando WhatIf com um valor de  
                                False para desabilitá-lo manualmente (WhatIf:$false).

    EXPLICAÇÃO DETALHADA

        Quando um cmdlet aceita WhatIf, o cmdlet relata o efeito 
        esperado do comando, em vez de executar o comando. Por 
        exemplo, em vez de excluir o arquivo test.txt em resposta a 
        um comando Remove-Item, o Windows PowerShell relata o que 
        excluiria. Um comando Get-Childitem subsequente confirma que 
        o arquivo não foi excluído.

              PS> remove-item test.txt
              What if: executando operação "Remove-Item" no Destino "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



    EXEMPLOS

    Estes exemplos mostram o efeito dos diferentes valores de 
    $WhatIfPreference. Eles também mostram como usar o parâmetro de 
    cmdlet WhatIf para substituir o valor de preferência para um 
    comando específico.
    
    Este exemplo mostra o efeito do valor 0 (não habilitado) padrão.

             PS> $whatifpreference                     
             0                         # Verifique o valor atual.

             PS> get-childitem test.txt | format-list FullName
             FullName : C:\test.txt
                                       # Verifique se o arquivo existe.

             PS> remove-item test.txt                  
             PS>                       # Exclua o arquivo.

             PS> get-childitem test.txt | format-list -property FullName
                                       # Verifique se o arquivo é excluído.
                                      
             Get-ChildItem: não é possível localizar o caminho 
             'C:\test.txt' porque ele não existe.
             At line:1 char:14
             + get-childitem <<<< test.txt | format-list fullname


     Este exemplo mostra o efeito de usar o parâmetro WhatIf quando o 
     valor de $WhatIfPreference é 0.

             PS> get-childitem test2.txt | format-list -property FullName 
             FullName : C:\test2.txt
                                      # Verifique se o arquivo existe.

             PS> remove-item test2.txt -whatif         
             What if: executando a operação "Remover Arquivo" no 
             Destino "C:\test2.txt".
                                      # Use o parâmetro WhatIf.

             PS> get-childitem test2.txt | format-list -property FullName
             FullName : C:\test2.txt
                                      # Verifique se o arquivo não 
                                      foi excluído. 

    Este exemplo mostra o efeito do valor 1 (WhatIf habilitado). 
    Quando você usa Remove-Item para excluir um cmdlet, Remove-Item 
    exibe o caminho para o arquivo que excluiria, mas não exclui o 
    arquivo.

             PS> $whatifpreference = 1                 
             PS> $whatifpreference
             1                        # Altere o valor.
                                      
             PS> remove-item test.txt                  
             What if: executando a operação "Remover Arquivo" no 
             Destino "C:\test.txt".
                                      # Tente excluir um arquivo.

             PS> get-childitem test.txt | format-list FullName
             FullName : C:\test.txt
                                      # Verifique se o arquivo existe.

     Este exemplo mostra como excluir um arquivo quando o valor de 
     $WhatIfPreference é 1. Ele usa o parâmetro WhatIf com um valor 
     de $false.

             PS> remove-item test.txt -whatif:$false
                                      # Use o parâmetro WhatIf com $false.

     Este exemplo demonstra que alguns cmdlets aceitam o 
     comportamento WhatIf e outros não aceitam. Neste exemplo, no 
     qual o valor de $WhatIfPreference é 1 (habilitado), um comando 
     Get-Process que não aceita WhatIf é executado, mas um comando 
     Stop-Process executa o comportamento WhatIf.
     Você pode anular o comportamento WhatIf do comando Stop-Process 
     usando o parâmetro WhatIf com um valor de $false.

            PS> $whatifpreference = 1                  
                                     # Altere o valor para 1.
                                                      
            PS> get-process winword 
                                    # Um comando Get-Process é concluído.

            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: executando operação "Stop-Process" no Destino 
           "WINWORD (2312)".
                                    # Um Stop-Process comando usa WhatIf.

           PS> stop-process -name winword -whatif:$false
           PS>                      # WhatIf:$false substitui a preferência.
           
           PS> get-process winword                     
           Get-Process: não é possível localizar um processo com o 
           nome 'winword'. Verifique o nome de processo e chame o 
           cmdlet novamente.
           At line:1 char:12
           + get-process <<<< winword
                                    # Verifique se o processo é parado.





CONSULTE TAMBÉM
    about_Automatic_Variables
    about_CommonParameters
    about_Environment_Variables
    about_Profiles
    about_Remote
    about_Scopes
    about_Variables