PowerShell e tudo o que você precisa saber sobre este utilitário

E se o seu PC pudesse lidar com as tarefas mundanas para você? Com ​​o Windows PowerShell, ele pode. Veja como usar o PowerShell para automatizar as tarefas repetitivas do dia a dia que ninguém quer fazer repetidamente.

Índice

• O que é PowerShell?
• Um breve histórico dos utilitários de linha de comando do Windows
• Apresentando ferramentas, comandos e módulos do PowerShell
  • Ferramentas do PowerShell
  • cmdlets no PowerShell
  • Módulos no PowerShell
  • Gerenciamento de arquivos e pastas
• Parâmetros do PowerShell explicados
• Criar pipeline
• Salvar pipeline como script PS1
• Exemplo de um script do PowerShell
• Como o PowerShell ajuda você a automatizar qualquer coisa no seu PC
  • Escreva scripts simples do PowerShell
  • Escreva um script do PowerShell para organizar arquivos automaticamente diariamente
  • Agendar e executar tarefas

O que é PowerShell?

O Microsoft PowerShell é um utilitário de linha de comando e linguagem de script que oferece uma ferramenta poderosa para administradores automatizarem uma ampla gama de tarefas em computadores e redes. O PowerShell contém componentes do Prompt de Comando e é baseado no .NET Framework. Se você está lendo sobre o WebTech360, saiba que o PowerShell é a ferramenta preferida de administradores de TI para gerenciar grandes redes.

Aprender a usar o PowerShell simplificará muitas tarefas tediosas do dia a dia. Você também pode fazer alterações em todo o sistema pela rede sem precisar configurar cada servidor individualmente. O PowerShell está se tornando uma parte essencial da execução de ambientes de nuvem híbrida .

O PowerShell tem diversas utilidades para ajudar você a trabalhar com mais eficiência e manter sua rede funcionando com eficiência. As mais básicas incluem: agendar atualizações diárias nos sistemas, gerar relatórios sobre processos atuais, serviços periódicos e muito mais. Embora muitas dessas tarefas possam ser realizadas por meio da interface gráfica do usuário (GUI), o objetivo do PowerShell é executá-las com mais rapidez.

Se você tem uma tarefa de manutenção de rotina que leva alguns minutos para configurar, pode criar um script com a mesma funcionalidade em um único comando, chamado PowerShell. Assim, na próxima vez que você abrir esse script, ele será executado em segundo plano. Dominar a lógica de script do PowerShell, entender como objetos e variáveis ​​funcionam e implantá-lo de forma inteligente em sua rede fará você se perguntar por que não usou o PowerShell antes.

Este tutorial abordará os conceitos básicos do PowerShell, o que será útil para iniciantes em TI, especialmente se você estiver familiarizado com o Prompt de Comando do Windows. Ele abordará como usar ferramentas e comandos básicos, como trabalhar com arquivos e pastas, entender objetos, usar variáveis ​​e gerenciar servidores remotos.

Um breve histórico dos utilitários de linha de comando do Windows

Após o lançamento do Windows NT, o CMD.EXE tornou-se o utilitário de linha de comando do Windows. Embora o CMD.EXE tenha herdado alguns elementos de seu antecessor do DOS (COMMAN.COM), ele ainda se baseava em uma linguagem de script bastante "primitiva": usando arquivos de comando do Windows (.CMD e .BAT). A adição do Windows Scripting Host e das linguagens VBScript e JScript aprimorou significativamente os recursos de script do utilitário.

Essas tecnologias são uma mistura bastante equilibrada de utilitários avançados de linha de comando e ambientes de script. A verdadeira preocupação não é quantos arquivos CMD.EXE, .CMD e Windows Scripting Host podem ser manipulados com elas. A principal reclamação e preocupação é a execução de algumas tarefas aparentemente simples.

Utilizando uma "estrutura" de ferramentas de linha de comando e script, qualquer script moderadamente abrangente requer uma combinação de comandos em lote, o Windows Scripting Host e executáveis ​​independentes. Cada script utiliza convenções diferentes para execução e solicitações, análise e retorno de dados.

Suporte deficiente a variáveis ​​no CMD.EXE, interfaces inconsistentes e acesso limitado às configurações do Windows, combinados com outra fraqueza, tornam a criação de scripts de linha de comando difícil de implementar e usar. O que é essa "outra fraqueza", você pode perguntar? É texto. Nessas tecnologias, tudo é texto. A saída de um comando ou script é texto e deve ser analisada e reformatada para servir de entrada para o próximo comando. Este é o ponto de partida básico que o PowerShell toma de todos os shells tradicionais.

Apresentando ferramentas, comandos e módulos do PowerShell

Os três conceitos apresentados nesta seção são apenas o básico para entender os principais conceitos que formam a base do PowerShell. Você precisará dedicar mais tempo para aprender e dominar os conceitos mais avançados à medida que se familiariza com os comandos do PowerShell.

Ferramentas do PowerShell

O PowerShell é instalado por padrão no Windows 10, Windows 7, Windows Server 2008 R2 e versões mais recentes do Windows. Versões mais recentes do PowerShell adicionam novos recursos e "cmdlets" (termo da Microsoft para comandos do PowerShell - pronunciado "command-lets") e são instaladas com a versão correspondente do Windows Management Framework (WMF).

Atualmente, o WMF 5.1 é a versão mais recente recomendada. Em alguns casos, alguns novos recursos dependem do sistema operacional, além da versão do WMF. Por exemplo, o Windows 8 e o Windows Server 2012 oferecem suporte ao cmdlet Test-NetConnection, que permite testar a conectividade com uma porta TCP/IP específica , mas esse cmdlet não está disponível no Windows 7, mesmo com a versão mais recente do WMF em execução.

Na maioria dos sistemas Windows, os usuários terão dois ambientes PowerShell disponíveis: o console do PowerShell e o PowerShell ISE (Ambiente de Script Integrado). O console do PowerShell se parece com uma linha de comando tradicional, mas com toda a funcionalidade do PowerShell por trás. Nomes de variáveis, loops, preenchimento automático de comandos e pipelines estão todos disponíveis no console do PowerShell.

Para uso mais avançado (como scripts), o PowerShell ISE oferece preenchimento automático de comandos, destaque de código e preenchimento automático de código Intellisense da Microsoft para ajudar você a criar e testar código do PowerShell. O PowerShell ISE também permite que você trabalhe com vários scripts do PowerShell simultaneamente usando a navegação por guias.

cmdlets no PowerShell

A base dos comandos do PowerShell é o cmdlet. A Microsoft adotou diversas estratégias de design ao criar cmdlets no PowerShell.

A primeira é a capacidade de inferir facilmente nomes de cmdlets, ou pelo menos torná-los mais detectáveis. Os comandos ou cmdlets do PowerShell também foram projetados para serem mais fáceis de usar, com sintaxe padronizada, facilitando a criação de scripts a partir da interface de linha de comando.

Os cmdlets usam o formato Verbo-Substantivo, como em Get-Service, Stop-Service ou Import-Csv. A parte verbal do nome do cmdlet indica a ação executada no substantivo. Normalmente, os cmdlets usados ​​para recuperar informações têm o verbo Get no nome, como Get-Process ou Get-Content . Os comandos usados ​​para modificar algo geralmente começam com o verbo Set , e os comandos usados ​​para adicionar uma nova entidade a algo geralmente começam com Add ou New .

Em segundo lugar, os parâmetros comumente usados ​​no PowerShell também recebem nomes padronizados. Por exemplo, o parâmetro -ComputerName permite que o cmdlet seja executado em um ou mais computadores remotos. -Credential é usado para fornecer um objeto de autenticação, contendo credenciais de usuário, para executar o comando como um usuário específico.

Módulos no PowerShell

Você pode usar aliases para cmdlets e parâmetros para economizar pressionamentos de tecla e reduzir o comprimento total do comando (útil ao encadear vários comandos). Embora esses aliases nem sempre usem convenções de nomenclatura padrão, eles ainda refletem os utilitários tradicionais de linha de comando.

No PowerShell, aliases como DIR, CD, DEL e CLS correspondem aos cmdlets Get-ChildItem, Set-Location, Remove-Item e Clear-Host, respectivamente. Aliases de parâmetros podem funcionar de duas maneiras: podem usar um alias predefinido fornecido pelo cmdlet ou podem ser aliasados ​​inserindo caracteres suficientes para criar uma correspondência exclusiva entre os parâmetros suportados pelo cmdlet.

Gerenciamento de arquivos e pastas

A maioria dos administradores de sistema precisa manipular arquivos e pastas ao longo de seu trabalho, seja movendo uma pasta para outro local no servidor, arquivando arquivos de log ou pesquisando arquivos grandes. Nos casos em que as mesmas operações são repetidas em muitos arquivos, usar o PowerShell para automatizá-las será uma solução eficaz para economizar tempo.

Para encontrar arquivos e pastas, uma das primeiras ferramentas de linha de comando que um administrador aprenderia nos velhos tempos da computação era o comando dir. O comando dir lista os arquivos e pastas contidos no diretório especificado.

O PowerShell possui um comando semelhante na forma do cmdlet Get-ChildItem . O Get-ChildItem permite criar rapidamente uma lista de arquivos em um diretório, permitindo que você manipule os arquivos por meio de um comando pipe ou atribua a saída a uma variável.

O Get-ChildItem pode ser usado simplesmente fornecendo um caminho, seja por meio de um pipeline, usando o parâmetro -Path ou diretamente após o nome do cmdlet. Para modificar a resposta retornada pelo Get-ChildItem, é necessário considerar alguns parâmetros disponibilizados pelo cmdlet.

O parâmetro -Filter é uma maneira de pesquisar arquivos. Por padrão, Get-ChildItem retorna apenas os filhos diretos do diretório de destino. Essa funcionalidade pode ser estendida usando o parâmetro -Recurse , que pesquisa recursivamente os diretórios contidos no diretório atual.

No PowerShell 4.0, Get-ChildItem adicionou a capacidade de limitar os resultados a arquivos ou diretórios usando a opção –File ou –Directory . Versões anteriores do PowerShell precisavam passar os resultados para Where-Object, filtrando pela propriedade PSIsContainer para fazer essa determinação. Um exemplo de ambas as técnicas usadas para retornar diretórios contidos em C:\Users é mostrado aqui:

Get-ChildItem C:Users -Directory Get-ChildItem C:Users | Where-Object {$_.PSIsContainer –eq $true}

Para detectar arquivos ocultos ou de sistema, é necessário usar  -Force . Get-ChildItem no PowerShell 4.0 e versões posteriores também pode ser usado para retornar apenas arquivos ocultos, somente leitura ou de sistema usando -Hidden, -ReadOnly e –System , respectivamente. Funcionalidades semelhantes podiam ser obtidas em versões anteriores filtrando a propriedade Mode usando Where-Object:

Get-ChildItem C:Users | Where-Object {$_.Mode -like '*R*'}

Verifique se o arquivo existe

Normalmente, ao trabalhar com arquivos, tudo o que precisamos saber é se o arquivo existe ou se o caminho do diretório é válido. O PowerShell fornece um cmdlet para isso no formato Test-Path, que retorna o valor true ou false.

O Test-Path é usado como uma etapa de precaução antes de tentar copiar ou excluir um arquivo específico.

Copiar, mover e excluir arquivos

Copy-Item: Copia um ou mais arquivos ou diretórios de um local, especificado pelo parâmetro -Path, para o local especificado pela opção -Destination.

Mover item: mover um arquivo ou pasta.

Ao copiar ou mover uma estrutura de diretório, -Recurse deve ser usado para que o cmdlet execute a ação no diretório e em seu conteúdo. Em alguns casos, -Force também é necessário, como quando um arquivo somente leitura é substituído por uma operação de cópia.

Remove-Item: Excluir arquivo, pasta.

A opção -Force deve ser usada ao encontrar um arquivo somente leitura e -Recurse deve ser usada ao excluir um diretório e seu conteúdo.

Usando PowerShell -WhatIf e -Confirm

Antes de realizar uma exclusão em massa séria, use -WhatIf . -WhatIf permite que você veja o que aconteceria se executasse um script ou comando e se isso teria algum impacto negativo potencial ao excluir dados comerciais importantes. Vale ressaltar também que -WhatIf não se limita a operações com arquivos, sendo amplamente utilizado no PowerShell.

Para scripts que você pretende executar manualmente ou, pior, que possuem comandos dependentes que são executados manualmente, considere usar -Confirm . Isso permite que você exija a interação do usuário antes que a operação realmente ocorra.

Scripts do PowerShell = Arquivos em lote com esteróides

O PowerShell em si é escrito na linguagem .NET e fortemente baseado no .NET Framework. Como tal, o PowerShell foi projetado como uma linguagem de script e shell orientada a objetos. Tudo no PowerShell é tratado como um objeto com todos os recursos do .NET Framework. Um comando expõe uma coleção de objetos que podem ser usados ​​com as propriedades e métodos daquele tipo de objeto. Quando você deseja canalizar a saída de um comando para outro, o PowerShell, na verdade, passa o objeto, não apenas a saída de texto do primeiro comando. Isso dá ao próximo comando acesso total a todas as propriedades e métodos do objeto no pipeline.

Tratar tudo como um objeto e ser capaz de aceitar objetos entre comandos é uma grande mudança na teoria dos utilitários de linha de comando. Dito isso, o PowerShell ainda funciona como um shell tradicional. Comandos, scripts e executáveis ​​podem ser digitados e executados a partir da linha de comando, e os resultados são exibidos como texto. Arquivos .CMD e .BAT do Windows, VBScripts, JScripts e os executáveis ​​que rodam dentro do CMD.EXE ainda rodam no PowerShell. No entanto, como não são orientados a objetos, eles não têm acesso total aos objetos criados e usados ​​no PowerShell. Esses scripts e executáveis ​​legados ainda tratarão tudo como texto, mas você pode combinar o PowerShell com uma série de outras tecnologias. Isso é especialmente importante se você quiser começar a usar o PowerShell com uma coleção de scripts existentes que não pode converter todos de uma vez.

Parâmetros do PowerShell explicados

Os cmdlets podem aceitar parâmetros para alterar seu comportamento. Ao executar um cmdlet ou função, você pode fornecer valores de parâmetros para especificar o que, quando, onde e como cada comando do PowerShell será executado.

Por exemplo, Get-Process recuperará e listará todos os processos em execução no seu sistema operacional:

Mas e se você quiser obter apenas um processo específico? Você pode fazer isso usando parâmetros. Por exemplo, para obter todos os processos do Slack, você pode usar o parâmetro Name com o cmdlet Get-Process:

Get-Process -Name Slack

Então você verá apenas processos chamados "slack":

Dica : Alguns parâmetros são "posicionais", o que significa que seus nomes são opcionais. Neste caso, Get-Process -Name Slack e Get-Process Slack executam a mesma tarefa.

Cada cmdlet aceita diferentes tipos de parâmetros. Use o comando Get-Help para ver os parâmetros aceitos pelo cmdlet na seção SINTAXE.

Get-Help Get-Process

Você verá uma lista de todas as maneiras possíveis de executar o cmdlet fornecido:

Neste caso, o cmdlet Get-Process aceita parâmetros como Nome, Id, NomeDoComputador, Módulo, FileVersionInfo e outros parâmetros comuns. Os símbolos aqui significam:

Os parâmetros aceitam um conjunto de valores que indicarão o tipo de dado que eles requerem, como string, inteiro, booleano ou data e hora. Por exemplo, o seguinte comando:

Get-Process [[-Name] ]

... significa que o parâmetro Nome aceita um ou mais valores de string, enquanto este comando:

Get-Process -Id 

... significa que o parâmetro Id aceita um ou mais valores inteiros.

O exemplo anterior de Get-Process usou o parâmetro Name para restringir os resultados. No entanto, se você quiser restringir a um processo mais específico, pode usar o parâmetro ID , que requer um inteiro, conforme indicado em sua sintaxe.

Get-Process -Id 3016

Então você verá apenas um processo na lista:

Criar pipeline

O PowerShell processa todos os dados como objetos. Para criar um script, esses objetos são executados por meio de uma série de Cmdlets ou funções conectados pelo símbolo de barra vertical (|). Escolher os Cmdlets corretos e conectá-los em uma sequência lógica usando um pipeline é importante para um script eficiente.

Suponha que você esteja criando um script para classificar e exibir os 5 arquivos que ocupam mais espaço em um diretório. Existem maneiras mais poderosas de escrever um script de classificação de arquivos, mas esta é simples e fácil de entender:

Para fazer isso no PowerShell, use um pipeline parecido com este:

Get-ChildItem -Path "C:\Directory" -File | Sort-Object Length -Descending `
 | Select-Object -First 5 | Format-Table Name, Length -AutoSize

Salvar pipeline como script PS1

Agora que temos um pipeline funcionando, você pode salvá-lo como um arquivo de script PS1 para não precisar importá-lo toda vez que usá-lo.

A maneira mais simples de criar um arquivo PS1 é colar seu script no Bloco de Notas e salvar o arquivo com a extensão .ps1.

Depois de criar o arquivo PS1, você pode usá-lo no PowerShell executando ./ScriptName.ps1 :

Dica : se você receber um erro de permissão, a solução mais rápida é executar o PowerShell com direitos de administrador ao executar seu script.

Parabéns! Agora você pode criar scripts do PowerShell PS1.

Exemplo de um script do PowerShell

Ler e entender as maravilhas das novas tecnologias é uma coisa, mas usá-las de fato é outra! No restante deste artigo, desenvolveremos um script do PowerShell para demonstrar seus recursos e como usá-lo.

DIR é um dos comandos mais comuns no CMD.EXE . Este comando exibe todos os arquivos e subdiretórios contidos em um diretório pai (como mostrado na Figura 1). Além do nome de cada objeto, as informações fornecidas incluem a data e hora da última atualização e o tamanho de cada arquivo. DIR também exibe o tamanho combinado de todos os arquivos no diretório, bem como o número total de arquivos e subdiretórios.

Figura 1

Executar DIR no PowerShell também produz uma listagem de diretórios como a da Figura 2, mas de uma maneira ligeiramente diferente. O PowerShell não possui um comando DIR, mas sim Get-ChildItem, que executa a mesma função. No PowerShell, DIR é um alias para Get-ChildItem. Não pretendo entrar em detalhes sobre aliases neste artigo. Você pode pensar em DIR no PowerShell como uma abreviação de Get-ChildItem.

O DIR no PowerShell fornece muitas das mesmas informações mencionadas acima: uma lista de arquivos e pastas, a data e a hora da última modificação e o tamanho de cada arquivo. No entanto, faltam as informações resumidas que o DIR no CMD.EXE fornece: o tamanho total de todos os arquivos na pasta, o número total de arquivos e o número total de subpastas.

Figura 2

Para o cenário de exemplo, você precisará criar um script do PowerShell que simule o comando CMD.EXE DIR. A seguir, explicarei as partes mais essenciais de um script.

DIR.PS1: Cabeçalho

Um script do PowerShell consiste em comandos do PowerShell em um arquivo de texto simples com a extensão .PS1. Em vez de DIR, você usaria um arquivo de texto chamado DIR.PS1.

Para executar o script, digite o seguinte comando na tela do PowerShell:

.DIR.PS1 X:Folder

Onde X é a letra da partição da unidade (como C, D, E) e Pasta é o nome da pasta.

Se quiser obter informações sobre a partição de uma unidade, você precisará usar o Windows Management Instrumentation (WMI). Os detalhes do WMI estão além do escopo deste artigo, portanto, não os abordaremos aqui. Mas o código do PowerShell abaixo é fácil de entender sem usar o WMI. Você pode criar uma variável "$filter" para usar com o comando Get-WmiObject. Este filtro informa ao comando Get-WmiObject que você deseja apenas informações sobre uma unidade específica. Os resultados do comando Get-WmiObject são armazenados em uma variável chamada $volInfo. Lembre-se: no PowerShell, tudo é um objeto; $volInfo agora é um objeto retornado por Get-WmiObject.

$filter = "DeviceID = '" + $drive + ":'"
$volInfo = Get-WmiObject -Class Win32_LogicalDisk -Filter $filter

Agora você tem acesso a todos os objetos e métodos associados ao objeto. O número de série do volume pode ser acessado por meio da propriedade VolumeSerialNumber. O número retornado é uma string de 8 caracteres. Mas, muitas vezes, você deseja formatá-lo como quatro números, separados por um hífen. Isso pode ser feito de forma semelhante à linha a seguir. O hífen no final da primeira linha é o caractere de continuação de linha no PowerShell. Ele basicamente informa ao PowerShell que a linha não quebra e que inclui a próxima linha. Quebras de linha não são necessárias ao escrever código, mas para reduzir a largura e tornar o código mais legível, você deve fazê-lo.

$serial = $volInfo.VolumeSerialNumber.SubString(0, 4) + "-" + `
$volInfo.VolumeSerialNumber.SubString(4, 4)

Agora que você tem um objeto $volInfo, pode gravar as informações do cabeçalho DIR na tela. Se a unidade não tiver nome, o texto gravado na tela será ligeiramente diferente do que se a unidade tivesse um nome. Uma instrução If-Else simples é usada para verificar se a propriedade VolumeName é uma string vazia. A instrução Write-Host é usada para gravar cada linha de texto na tela.

If ($volInfo.VolumeName -eq "") { Write-Host (" Volume in drive " + $drive + " has no label") } Else { Write-Host (" Volume in drive " + $drive + " is " + $volInfo.VolumeName) } Write-Host (" Volume Serial Number is " + $serial) Write-Host ("`n Directory of " + $args[0] + "`n")

O caractere ``n`` no início e no final do comando Write-Host é usado para inserir uma nova linha antes e depois do texto. O comando Write-Host adiciona uma nova linha ao final de cada linha. Portanto, o efeito de ``n`` é criar uma linha em branco antes e depois do texto.

Você notou o ``-eq`` no comando If? É um operador de comparação de igualdade. A tabela abaixo mostra todos os operadores de comparação:

O caractere -i antes dos operadores de comparação indica que o operador não diferencia maiúsculas de minúsculas.

Figura 3: Dados de saída do script que você tem atualmente

DIR.PS1: Lista de arquivos/pastas

Agora, você está pronto para exibir o conteúdo e as propriedades desta pasta. A primeira coisa a fazer é chamar o comando Get-ChildItem do PowerShell para obter uma coleção de arquivos e passá-la ao script como parâmetro. O comando Get-ChildItem obterá uma coleção de objetos de arquivo e pasta, não apenas seus nomes, mas também os redirecionará diretamente para o comando Sort-Object para classificá-los. Por padrão, o comando Sort-Object classificará os objetos com base na propriedade Name. Portanto, você não precisa especificar nenhum outro parâmetro. A coleção de objetos classificada será armazenada em uma variável chamada $items.

$items = Get-ChildItem $args[0] | Sort-Object

Depois de ter uma coleção de objetos de arquivo e pasta, você precisa percorrê-los e exibir as propriedades apropriadas. O comando para isso é ForEach. Para cada arquivo ou pasta, as propriedades exibidas serão a data e hora da última modificação, o nome, o comprimento ou o tamanho do arquivo. As strings de aparência estranha dentro dos parênteses são códigos de formato de string do .NET. Eles são usados ​​para alinhar campos à esquerda/direita e formatar datas, horas e números. Entender esses códigos de formato de string não é muito importante, pois eles não são essenciais para a natureza deste script.

A instrução If é onde você determina se um objeto é um diretório ou não. Se o primeiro caractere do atributo Mode for "d", o objeto é um diretório. Você precisa verificar novamente, pois o código para diretórios geralmente é diferente do código para arquivos.

Observe a linha $totalDirs++ dentro da instrução If. Este é um contador responsável por manter o controle do número de diretórios. Da mesma forma, há uma variável $totalFiles que é usada para manter o controle do tamanho total de todos os arquivos. Esses valores são sempre calculados durante a execução. Mas eles só são exibidos quando o processo de listagem de arquivos é concluído.

ForEach ($i In $items)
{
$date = "{0, -20:MM/dd/yyyy hh:mm tt}" -f $i.LastWriteTime
$file = $i.Name
If ($i.Mode.SubString(0, 1) -eq "d")
{
$totalDirs++
$list = $date + " {0, -15}" -f "
" + " " + $file
}
Else
{
$totalFiles++
$size = "{0, 18:N0}" -f $i.Length
$list = $date + $size + " " + $file
}
$totalSize += $i.Length
Write-Host $list
}

Figura 4: Exibe os dados de saída do script atualizado.

DIR.PS1: Rodapé

A única coisa que resta a fazer é escrever na tela o número total de arquivos, diretórios, o tamanho total de todos os arquivos e o espaço livre nesta partição do disco. Para isso, você precisará usar as variáveis ​​de contagem ($totalFiles, $totalDirs, $totalSize) criadas na seção anterior. Você pode descobrir a quantidade de espaço livre na variável $volInfo criada no início do script.

Write-Host ("{0, 16:N0}" -f $totalFiles + " File(s)" + `
"{0, 15:N0}" -f $totalSize + " bytes")
Write-Host ("{0, 16:N0}" -f $totalDirs + " Dir(s)" + `
"{0, 16:N0}" -f $volInfo.FreeSpace + " bytes free`n")

Figura 5: Exibe os dados de saída completos do script.

Previsões e melhorias podem ser

Embora o script criado produza uma saída quase idêntica ao comando CMD.EXE DIR, há algumas ressalvas que você deve conhecer e algumas melhorias que podem ser feitas.

• Este script não executa nenhuma verificação de erros.
• Se um caminho válido não for passado para o script, o script falhará com uma mensagem de erro do PowerShell.
• O número total de diretórios fornecidos no script é 2 a menos que o resultado do comando CMD.EXE DIR porque o comando Get-ChildItem não conta os dois diretórios “.” e “..” como no CMD.EXE.
• Seu script classifica apenas por nome de arquivo, nome de pasta e não fornece nenhuma outra classificação por atributos.
• Seu script não consegue exibir o conteúdo da pasta e de todas as subpastas.

Como o PowerShell ajuda você a automatizar qualquer coisa no seu PC

Escreva scripts simples do PowerShell

Você pode usar o PowerShell para automatizar quase tudo, como renomear arquivos em lote para manter a consistência ou iniciar aplicativos automaticamente. Vamos escrever alguns scripts simples do Windows PowerShell para ver como funciona.

Observação : se você encontrar um erro ao executar o script em relação à política de execução, talvez seja necessário permitir temporariamente que o script seja executado executando "Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass".

Renomear arquivos em lote em uma pasta

Você pode usar o PowerShell para copiar, mover e excluir arquivos do seu PC. Você também pode renomear arquivos de um tipo específico em massa. Por exemplo, veja como renomear vários arquivos de texto substituindo o prefixo "oldco" por "newco" nos nomes deles:

Get-ChildItem -Path "C:\CompanyFiles" -Filter "*.txt" | Rename-Item -NewName {$_.Name -replace "oldco","newco"}

No script acima, ".txt" é o filtro de extensão de arquivo. Você pode modificá-lo e defini-lo como .jpg, .docx, etc. para pesquisar diferentes tipos de arquivo.

Aplicativo de inicialização automática

Se você abrir o mesmo conjunto de aplicativos todos os dias, poderá escrever um script do PowerShell para iniciá-los com um único clique:

#Open multiple apps with a single click
Start-Process "notepad.exe"
Start-Process "calc.exe"
Start-Process "Chrome.exe"
Start-Process "slack.exe"

Cole o script em um arquivo do Bloco de Notas e salve-o como LaunchFavoriteApps.ps1. Em seguida, clique duas vezes no arquivo para iniciar todos os aplicativos listados no script.

Copie arquivos importantes para um local de backup

Você pode fazer backup periódico de arquivos importantes em um local de backup usando o seguinte script. Certifique-se de alterar os caminhos de origem e destino conforme necessário:

#Copy MyFiles folder contents to MyFilesBackup in D:\
Copy-Item -Path "C:\Documents\MyFiles" -Destination "D:\MyFilesBackup" -Recurse

Escreva um script do PowerShell para organizar arquivos automaticamente diariamente

Como muitos tipos de arquivos são baixados todos os dias, a pasta Downloads pode ficar rapidamente lotada com todos os tipos de arquivos espalhados. Para corrigir isso, podemos escrever um script do PowerShell que classifica os arquivos baixados em pastas por tipo de arquivo ao final de cada dia.

Abra um novo arquivo do Bloco de Notas e cole o seguinte script. Certifique-se de alterar o caminho da pasta de origem no script para corresponder ao caminho da pasta Downloads:

# Change the source folder path below
$sourcePath = "E:\Downloads"
# Add file mapping folder names; the Others folder includes all the files that do not match file types in the other categories
$fileTypes = @{
"Documents" = @("*.docx", "*.pdf", "*.txt")
"Images" = @("*.jpg", "*.png", "*.gif")
"Media" = @("*.mp4", "*.mp3", "*.mov")
"Zip" = @("*.zip", "*.rar")
"ISO" = @("*.iso")
"Others" = @("*")
}
# Iterate through each folder type and prepare a destination folder for organizing files
foreach ($folder in $fileTypes.Keys) {
# Create the destination folder path
$destPath = Join-Path -Path $sourcePath -ChildPath $folder
# Check if the destination folder exists, and create it if it doesn't
if (!(Test-Path -Path $destPath)) {
New-Item -ItemType Directory -Path $destPath | Out-Null
}
# Move matching files from the source folder to the destination folder based on file type patterns
foreach ($pattern in $fileTypes[$folder]) {
Get-ChildItem -Path $sourcePath -Filter $pattern -File -ErrorAction SilentlyContinue | ForEach-Object {
try {
Move-Item -Path $_.FullName -Destination $destPath -Force -ErrorAction Stop
Write-Output "Moved: $($_.FullName) to $destPath"
} catch {
Write-Warning "Failed to move file: $($_.FullName). Error: $_"
}
}
}
}
Write-Output "Files organized successfully!"

Para salvar o arquivo, clique em Arquivo > Salvar como e digite OrganizeDownloadsFolder.ps1 como nome do arquivo. Em seguida, clique em Salvar como Tipo e selecione Todos os Arquivos . Clique duas vezes no arquivo OrganizeDownloadsFolder.ps1 para executar o script.

Agendar e executar tarefas

É claro que escrever um script é uma parte do processo de automação. A segunda parte é garantir que o script possa ser executado automaticamente para realizar a tarefa. Para isso, podemos criar tarefas agendadas para executar o script diariamente ou conforme necessário.

Abra o PowerShell, copie e cole o script a seguir e pressione Enter . Certifique-se de substituir "J:\OrganizeDownloadsFolder.ps1" pelo caminho completo do arquivo para o seu script OrganizeDownloadsFolder.ps1.

$action = New-ScheduledTaskAction -Execute "PowerShell.exe" -Argument "-File 'J:\OrganizeDownloadsFolder.ps1'"
$trigger = New-ScheduledTaskTrigger -Daily -At "5:00 PM"
Register-ScheduledTask -Action $action -Trigger $trigger -TaskName "OrganizeDownloadsFolderDaily"

Após concluir, pressione Enter . O script criará uma tarefa agendada no Agendador de Tarefas para executar o script de organização de arquivos todos os dias às 17h. Se preferir um horário diferente, você pode modificá-lo no script acima.

Além disso, você pode usar o PowerShell para automatizar outras tarefas cotidianas, como um script de monitoramento de espaço que o alerta quando você fica sem espaço livre na sua unidade principal, proteger com senha lotes de documentos PDF e até mesmo aplicar papéis de parede animados da sua pasta de imagens.

Embora o PowerShell seja um utilitário e uma linguagem de script poderosos, leva um tempo para entendê-lo e usá-lo, especialmente se você não estiver familiarizado com o ambiente .NET Framework. Espero que este artigo e o script de exemplo sejam úteis para quem deseja entender o PowerShell. Mas o script de exemplo criado no artigo é bastante simples. Acredito que ele pode ser construído e desenvolvido de forma mais completa para atender a aplicações mais complexas.