Partilhar via

Executando comandos no shell

O PowerShell é um shell de linha de comando e uma linguagem de script usada para automação. Semelhante a outros shells, como bash no Linux ou no Windows Command Shell (),cmd.exe o PowerShell permite executar qualquer comando disponível no seu sistema, não apenas comandos do PowerShell.

Tipos de comandos

Para qualquer shell em qualquer sistema operacional, existem três tipos de comandos:

  • termos-chave da linguagem de comandos do shell fazem parte da linguagem de script do shell.

    • Exemplos de palavras-chave bash incluem: if, then, else, elife fi.
    • Exemplos de palavras-chave cmd.exe incluem: dir, copy, move, ife echo.
    • Exemplos de palavras-chave do PowerShell incluem: for, foreach, try, catche trap.

    As palavras-chave da linguagem Shell só podem ser usadas dentro do ambiente de tempo de execução do shell. Não existe nenhum ficheiro executável, externo ao shell, que forneça a funcionalidade da palavra-chave.

  • comandos nativos do SO são ficheiros executáveis instalados no sistema operativo. Os executáveis podem ser executados a partir de qualquer shell de linha de comando, como o PowerShell. Isto inclui ficheiros de script que requerem outros shells para funcionarem corretamente. Por exemplo, se executares um script de lote do Windows (ficheiro.cmd) no PowerShell, este executa cmd.exe e passa o ficheiro de lote para execução.

  • comandos específicos do ambiente do Shell são comandos definidos em arquivos externos que só podem ser usados dentro do ambiente de tempo de execução do shell. Isto inclui scripts, funções e módulos que adicionam comandos ao runtime do shell. No PowerShell, estes comandos adicionados por um módulo são conhecidos como cmdlets (pronuncia-se "command-lets").

Executando comandos nativos

Qualquer comando nativo pode ser executado a partir da linha de comando do PowerShell. Normalmente, você executa o comando exatamente como faria em bash ou cmd.exe. O exemplo a seguir mostra a execução do comando grep no bash no Ubuntu Linux.

sdwheeler@circumflex:~$ grep sdwheeler /etc/passwd
sdwheeler:x:1000:1000:,,,:/home/sdwheeler:/bin/bash
sdwheeler@circumflex:~$ pwsh
PowerShell 7.2.6
Copyright (c) Microsoft Corporation.

https://aka.ms/powershell
Type 'help' to get help.

Depois de iniciar o PowerShell no Ubuntu, você pode executar o mesmo comando na linha de comando do PowerShell:

PS /home/sdwheeler> grep sdwheeler /etc/passwd
sdwheeler:x:1000:1000:,,,:/home/sdwheeler:/bin/bash

Passando argumentos para comandos nativos

A maioria dos shells inclui recursos para usar variáveis, avaliar expressões e manipular cadeias de caracteres. Mas cada concha faz essas coisas de forma diferente. No PowerShell, todos os parâmetros começam com um caractere de hífen (-). Em cmd.exe, a maioria dos parâmetros de comando usa um carácter de barra para a frente (/). Outras ferramentas da linha de comandos podem usar espaços, hífens, dois traços (--).

Cada shell tem sua própria maneira de manipular e avaliar cadeias de caracteres na linha de comando. Ao executar comandos nativos no PowerShell que exigem que as cadeias de caracteres sejam entre aspas de uma forma específica, pode ser necessário ajustar a forma como passa essas cadeias de caracteres.

Para obter mais informações, consulte os seguintes artigos:

O PowerShell 7.2 introduziu um novo recurso experimental PSNativeCommandArgumentPassing que melhorou a manipulação de comandos nativos. Para obter mais informações, consulte $PSNativeCommandArgumentPassing.

Tratamento de resultados e erros

O PowerShell também possui vários fluxos de saída adicionais em comparação com outros shells. As conchas bash e cmd.exe têm o stdout e o stderr. O PowerShell tem seis fluxos de saída. Para obter mais informações, consulte about_Redirection e about_Output_Streams.

Em geral, a saída enviada para o stdout por um comando nativo é enviada para o fluxo Success no PowerShell. A saída enviada para stderr por um comando nativo é enviada para o fluxo de erro no PowerShell.

Quando um comando nativo tem um código de saída não nulo, $? é definido como $false. Se o código de saída for zero, $? será definido como $true.

No entanto, o PowerShell 7.2 alterou este comportamento. Os registros de erro redirecionados de comandos nativos, como ao usar operadores de redirecionamento (2>&1), não são gravados na variável $Error do PowerShell e a variável de preferência $ErrorActionPreference não afeta a saída redirecionada.

Muitos comandos nativos gravam em stderr como um fluxo alternativo para fornecer informações adicionais. Esse comportamento pode causar confusão no PowerShell ao examinar erros e as informações de saída adicionais podem ser perdidas se $ErrorActionPreference estiver definido como um estado que silencia a saída.

O PowerShell 7.3 adicionou uma nova funcionalidade experimental PSNativeCommandErrorActionPreference que permite controlar como lidar com códigos de saída não nulos de comandos nativos. Para obter mais informações, consulte $PSNativeCommandUseErrorActionPreference.

Executando comandos do PowerShell

Como observado anteriormente, os comandos do PowerShell são conhecidos como cmdlets. Os cmdlets são coletados em módulos do PowerShell que podem ser carregados sob demanda. Os cmdlets podem ser escritos em qualquer linguagem .NET compilada ou usando a própria linguagem de script do PowerShell.

Comandos do PowerShell que executam outros comandos

O operador de chamada do PowerShell (&) permite executar comandos armazenados em variáveis e representados por cadeias de caracteres ou blocos de script. Podes usar o operador para executar qualquer comando nativo ou comando PowerShell. Isso é útil em um script quando você precisa construir dinamicamente os parâmetros de linha de comando para um comando nativo. Para obter mais informações, consulte o operador de chamada.

O cmdlet Start-Process pode ser usado para executar comandos nativos, mas só deve ser usado quando você precisar controlar como o comando é executado. O cmdlet tem parâmetros para dar suporte aos seguintes cenários:

  • Executar um comando usando credenciais diferentes
  • Ocultar a janela do console criada pelo novo processo
  • Redirecionar stdin, stdoute stderr streams
  • Usar um diretório de trabalho diferente para o comando

O exemplo a seguir executa o comando nativo sort.exe com fluxos de entrada e saída redirecionados.

$processOptions = @{
    FilePath = "sort.exe"
    RedirectStandardInput = "TestSort.txt"
    RedirectStandardOutput = "Sorted.txt"
    RedirectStandardError = "SortError.txt"
    UseNewEnvironment = $true
}
Start-Process @processOptions

Para mais informações, consulte Start-Process.

No Windows, o cmdlet Invoke-Item executa a ação padrão para o item especificado. Por exemplo, ele executa um arquivo executável ou abre um arquivo de documento usando o aplicativo associado ao tipo de arquivo de documento. A ação predefinida depende do tipo de item e do provedor PowerShell que fornece acesso ao item.

O exemplo a seguir abre o repositório de código-fonte do PowerShell em seu navegador da Web padrão.

Invoke-Item https://github.com/PowerShell/PowerShell

Para obter mais informações, consulte Invoke-Item.

  • Last updated on