Aprenda Powershell

  • Página Inicial
  • Contato!
  • Tudo sobre Powershell Parte 1!
  • Tudo sobre Powershell Parte 2!
  • Tudo sobre Powershell Parte 3!
  • Tudo sobre Powershell Parte 4!
    •

    Tudo sobre Powershell Parte 1

    O Shell Powershell

    Apesar da linha de comando padrão do Windows ser o CMD, temos também no Windows 7 e posteriores, a opção de usar o PowerShell, que conta com outros comandos, especialmente para administradores de sistema.

    Esses são os comando mais comuns do Powershell:

    É possível navegar pelas chaves do registro pelo Powershell digitando Set-Location HKCU: (pode ser HKCR, HKLM, HKU e HKCC), para voltar ao sistema de pastas, digite Set-Location C:.

    Para exibir os dados da BIOS do computador, digitamos Get-WmiObject -Class Win32_BIOS -ComputerName $env:COMPUTERNAME.

    Para vermos os processos que mais usam memória, usamos o comando Get-Process | Sort-Object –p ws | Select-Object –Last 5.

    Para listar os programas instalados no PC, usamos o comando Get-WmiObject -Class Win32_Product | Select-Object -Property Name.

    Para escrever um conteúdo no arquivo, fazemos igual no CMD, usando o Write-Output ou outro comando que imprima alguma saída. por exemplo Get-ChildItem >> arquivo.txt (pode ser necessário dar um espaço entre os comandos).

    PS: Usando dois >> ele adicionará uma nova linha no arquivo, caso exista, se usar um só > ele sobrescreverá o arquivo existente.

    Para criarmos variáveis, usamos o cifrão no começo delas, por exemplo:

    
# Criando uma variável:

$variavel

# Atribuindo valor:

$variavel = "Olá Mundo"

# Exibindo:

Write-Output $variavel

    Para usar as variáveis de ambiente do Windows em comandos, use o $env: antes dela, por exemplo:

    
Write-Output $env:SystemRoot
Set-Location $env:UserProfile

    É possível fazermos contas no Powershell também, digitando diretamente as contas (como 10 + 5).

    PS: Muitos comandos do CMD funcionam também no Powershell, ou até mesmo alguns do Unix (para executar um arquivo, por exemplo, usamos algo como ./arquivo.exe), esses são alias para os comandos mais longos.

    Para criar um arquivo de script powershell, basta salvar ele no formato ps1 e colocar os comandos, mas geralmente os sistemas são configurados para não rodar esse tipo de script, para desbloquear isso use o comando Set-ExecutionPolicy RemoteSigned no Powershell, executando como administrador, para bloquear novamente use Set-ExecutionPolicy Restricted.

    Para gerar hashs de arquivos pelo Powershell, use esses comandos:

    
Get-FileHash nomedoarquivo.extensão -Algorithm md5 | Format-List

    Isso mostrará o hash no Powershell, de acordo com o algoritmo escolhido (MD5, SHA1, etc). Para salvá-lo em um arquivo de texto, faça o seguinte:

    
Get-FileHash nomedoarquivo.extensão -Algorithm md5 | Format-List > arquivo.txt

    Essas são as variáveis do sistema (usadas com $env:):

    Variável Conteúdo Exibido
    USERPROFILE C:\Users\UsuarioAtual
    PROGRAMDATA C:\Programdata
    ALLUSERSPROFILE C:\Programdata
    WINDIR C:\Windows
    SYSTEMROOT C:\Windows
    PROGRAMFILES C:\Program Files
    COMMONPROGRAMFILES C:\Program Files\Common Files
    USERNAME "UsuarioAtual"
    COMPUTERNAME Nome do Computador
    LOCALAPPDATA C:\Users\Usuário Atual\AppData\Local
    APPDATA C:\Users\Usuário Atual\AppData\Roaming
    USERDOMAIN Nome do Computador
    SYSTEMDRIVE C:
    HOMEDRIVE C:
    SYSTEMDIRECTORY C:\Windows\System32
    COMSPEC C:\Windows\System32\cmd.exe
    TEMP C:\Users\Usuário Atual\AppData\Local\Temp
    TMP C:\Users\Usuário Atual\AppData\Local\Temp
    HOMEPATH \Users\Usuário Atual
    PATH Retorna o path do sistema
    PATHEXT Retorna as extensões de executáveis
    OS Retorna o nome do Sistema Operacional
    PROCESSOR_IDENTIFIER Retorna dados sobre o processador
    PROCESSOR_ARCHITECTURE Retorna a arquitetura do processador

    PS: Em sistemas 64 bits, a variável PROGRAMFILES é referente a pasta de aplicações 64 bits, para acessar a pasta de aplicações 32 bits, use PROGRAMFILES(x86). O mesmo vale para a COMMONPROGRAMFILES, que em aplicativos de 32 bits é COMMONPROGRAMFILES(x86). Nesses casos, coloque tudo entre aspas.

    Para "grudar" mais de um comando no Powershell, use o ponto-e-vírgula.

    Tipos de Dados - Parte 1

    O Powershell tem os tipos baseados no .NET, e são vários tipos, e todos eles são objetos, ou seja, eles tem propriedades e métodos.

    Digitando Get-Item .\arquivo.txt Podemos ver os dados do arquivo especificado. Ele cria um objeto no Powershell baseado nesse arquivo. Dessa forma, podemos atribuir a uma variável assim:

    
$arq = Get-Item .\arquivo.txt

# Visualizando métodos do arquivo:

$arq | Get-Member -MemberType Methods

# Visualizando propriedades do arquivo:

$arq | Get-Member -MemberType Property

# Nome do arquivo:

$arq.Name

# Extensão do arquivo:

$arq.Extension

# Nome simples do arquivo:

$arq.Basename

# Tipo do objeto:

$arq.GetType()

    Isso aí acima, é pra acessar métodos e propriedades de um objeto. Para métodos e atributos estáticos, usamos ::, por exemplo:

    
[string]::Join("-", @("instituto", "de", "scripts"))

[string]::Join("-", @("instituto", "de", "scripts")).GetType()

[string]::Format("{0} {1} {2}", "instituto", "de", "scripts")

    PS: Para formatar valores float, faça assim, colocando a quantidade de casas com zeros:

    
$real = 12345.6789

Write-Host ([string]::Format("{0:0.00}", $real))

    PS: Quando usar numa exibição, coloque tudo entre parênteses para exibir.

    Tipos de Dados - Parte 2

    Podemos também usar os métodos diretamente na string, ao invés do objeto, por exemplo:

    
"Instituto de Scripts".ToUpper()

"Instituto de Scripts".ToLower()

"Instituto de Scripts".Replace(" ", "-")

"Instituto de Scripts".Length

    Os métodos são vários, além desses, por exemplo:

    
[int]"1"

([int]"1").GetType()

    Não dá para converter uma string para char, exceto quando for um array de char, por exemplo:

    
[char[]]"HAL"

([char[]]"HAL").GetType()

# Isso mostra o número ASCII corresponde a mesma letra:

[int[]][char[]]"HAL"

    Com um foreach incrementando:

    
[int[]][char[]]"HAL" | foreach {
    # Underline é o item atual:
    
    $_ + 1
}

    Reconvertendo para char e depois string:

    
[string][char[]]([int[]][char[]]"HAL" | foreach {
    # Underline é o item atual:
    
    $_ + 1
})

    Outro exemplo:

    
[string][char[]]([int[]][char[]]"VMS" | foreach {
    # Underline é o item atual:
    
    $_ + 1
})

    PS: Podemos alterar a variável do sistema $ofs para inserir algum conteúdo entre as letras, o padrão é o "".

    Tipos de Dados - Parte 3

    Podemos fazer contas com datas, por exemplo esta que mostra quantos dias faltam pro Natal:

    
[Datetime]"12/25/2020" - [Datetime]::Now

    Os tipos primitivos mais comuns são [int], [single] (equivalente ao float) e [string], mas existem outros como já vistos. Os números de ponto flutuante são usados com pontos, como na maioria das linguagens.

    Geralmente os números de ponto flutuante são reconhecidos como double, por exemplo:

    
(1.25).GetType()

    Isso acontece porque o double tem maior precisão de casas decimais que o single/float.

    Manipulando Texto

    Temos outras funções para trabalhar com strings, como a Replace (que substitui algo na string), e a Concat da classe String, que concatena algo. Veja o uso delas:

    
$frase = "Isso é uma String"
            
Write-Host $frase.Replace("String", "Frase") # Substitui algo

Write-Host ([string]::Concat($frase, " e ela foi concatenada!")) # Concatena com mais algo

    Para inverter strings, fazemos assim:

    
$frase = "Isso é uma String"
            
$novo = [char[]]$frase

[array]::Reverse($novo)

$frase = [string]($novo -join '')

Write-Host $frase

    Para remover espaços desnecessário de strings, basta usar o Trim, assim:

    
$texto = "        Exemplo de String!          "

Write-Host $texto.Trim()

    Para transformar todas as letras em maiúsculas e minúsculas, use os métodos ToUpper() e ToLower() do objeto, respectivamente:

    
$frase = "Isso é uma String"
            
Write-Host $frase.ToUpper() # Converte pra maiúscula

Write-Host $frase.ToLower() # Converte pra minúscula

# Com char fazemos assim:

Write-Host ([char]::ToUpper('s'))

    Para ver a quantidade de caracteres de uma string, use o atributo Length do objeto, assim:

    
$frase = "Exemplo de String"
            
Write-Host -NoNewLine "Quantidade de caracteres: " $frase.Length "`n"

    PS: Note que o -NoNewLine faz o Write-Host não pular de linha.

    Operadores

    Basicamente, existem vários tipos de operadores no Powershell.

    Veja como é realizada uma contagem de 1 até 10 no Powershell:

    
# Conta de 1 até 10:

1..10

    Para substituir os nomes de um arquivo de texto por alguma palavra, podemos fazer assim:

    
(Get-Content .\teste.txt) -replace "(pal1|pal2)", "SUBSTITUTO" > novo.txt

    Podemos fazer um vetor com números de 1 a 10, assim:

    
$vetor = 1..10

$vetor

    E consequentemente, podemos verificar se um conteúdo está dentro do vetor ou não:

    
$vetor = 1..10

$vetor -contains 6

$vetor -contains 11

    E também verificar se os dados é de um determinado tipo:

    
"WPS" -is [int]

"WPS" -is [string]

    E também converter dados:

    
("07/08/2035").GetType()

"07/08/2035" -as [Datetime]

("07/08/2035" -as [Datetime]).GetType()