Powershell para desenvolvedores – Parte 2 – Operadores e funções

Posted on fevereiro 2, 2011 by

4


Olá pessoal, tudo certo?

No primeiro post dessa série, mostrei os elementos fundamentais para utilização do Powershell. No post de hoje, pretendo mostrar elementos que agradam todo programador: Operadores e funções.

Sem delongas…

Operadores de comparação

Powershell oferece um conjunto rico de operadores de comparação. Pela natureza “linha de comando”, não encontramos os opradores em sua sintaxe usual, mas não há nada de realmente desafiador aqui.

Os operadores de comparação ficaram assim:

  • -eq: igual a;
  • -ne: diferente de;
  • -ge: maior ou igual a;
  • -gt: maior que;
  • -le: menor ou igual a;
  • -lt: menor que;
  • -like
  • -notlike
  • -match – Combina com expressão regular;
  • -notmatch – Não combina com expressão regular;
  • -contains
  • -notcontains
  • -is
  • -isnot

Comecemos por um exemplo:


              

                1 PS > (dir).Count 2 25  3 PS > (dir).Count -eq 25  4 True 5 PS > (dir).Count -ne 25  6 False 7 PS > (dir).Count -gt 10  8 True 9 PS > (Get-Process).Count 10 142 11 PS > 1gb -eq 1mb * 1024 12 True
              

              

              

            

            
Nas linhas 1 e 2, evidencio que todo cmdlet que retorne uma “lista” de objetos é somente isso: uma lista. Quantos arquivos tenho em meu diretório atual? Pergunto na linha 1, respondo na linha 2. Quantos processos abertos? Linha 9 pergunta, linha 10 responde. Um gigabyte = 1024 mb? Conforme as linhas 11 e 12, sim!

            
Nas linhas entre 3 e 8, realizo algumas comparações simples. Outro exemplo:

            

              

              

                1 PS > $result = .\curl http://elemarjr.net/feed/ 2 % Total % Received % Xferd Average Speed Time Time Time Current 3 Dload Upload Total Spent Left Speed 4 100 577k 0 577k 0 0 221k 0 --:--:-- 0:00:02 --:--:-- 237k 5 PS > $xml = [xml] $result 6 PS > ($xml.rss.channel.item).Count -gt 5 7 True
              

              

              

            

            
Logo na linha 1, uma operação bacana. Pego o resultado da operação de um aplicativo externo, o cURL (tema suficiente para um post inteiro), que é um “navegador web texto”, e atributo a variável $result.

            
Na linha 5, utilizo o suporte nativo do Powershell para xml. Na linha 6, verifico se a quantidade de nodos Item, em rss.channel, é maior que 10.

            
Agora, um pouco de expressões regulares:

            

              

              

                1 PS > $h = "Hello World"  2 PS > $h -match "H.*World"  3 True 4 PS > $h -match "Hello"  5 True 6 PS > $h -match "Hello$"  7 False 8 PS > $h -match "^Hello"  9 True 10 PS > $h -match "^ello" 11 False
              

              

              

            

            
Aqui, temos algumas “comparações” realizadas com expressões regulares. Agora, considere o exemplo abaixo:

            

              

              

                1 PS > "hello world" -eq "Hello World" 2 True 3 PS > "hello world" -ceq "Hello World" 4 False
              

              

              

            

            
Pelas linha 1 e 2, percebemos que todos os operadores de comparação padrão do Powershell são case-insensitive. Para comparações case-sensitive, basta adicionar um c antes do nome do operador (linhas 3 e 4).

            
Agora, uma idéia dos operadores de lista:

            

              

              

                1 PS > 1..10  2 1  3 2  4 3  5 4  6 5  7 6  8 7  9 8 10 9 11 10 12 PS > 1..10 -contains 3 13 True 14 PS > 1..10 -contains 9 15 True 16 PS > 1..10 -contains 11 17 False
              

              

              

            

            
 

            
Compreendido? 1..10 gera uma lista com números de 1 até 10. O –contains verifica se um elemento está na lista.

            
Aliás, aproveitando a brincadeira, observe:

            

              

              

                1 PS > foreach ($n in 1..10) {$n*$n} 2 1  3 4  4 9  5 16  6 25  7 36  8 49  9 64 10 81 11 100 12 PS >
              

              

              

            

            
Operadores de comparação

            
Os operadores lógicos são:

            
    
              
  • -and
    • 
              
  • -or
    • 
              
  • -xor: ou exclusivo (True –xor False = True; False –xor True = True, falso para todos os outros casos.
    • 
              
  • -not
    • 
            

            
Observe:

            

              

              

                1 PS > (2 -eq 2) -and (4 -gt 2) 2 True 3 PS > -not (2 -eq 2) 4 False 5 PS >
              

              

              

            

            
Auto-explicativo, não é?!

            
Where-Object: o rei dos filtros

            
Agora que já sabemos fazer comparações, vejamos como construir filtros para nossas listas baseados em condições. Observe:

            

              

              

                1 PS > Get-Process | Where-Object { $_.ProcessName -match "^W.*"} 2  3 Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName 4 ------- ------ ----- ----- ----- ------ -- ----------- 5 152 13 30280 7908 103 0,09 6416 WebcamDell2 6 1128 160 151540 148552 463 116,69 9080 WindowsLiveWriter 7 81 10 1744 4664 47 0,08 528 wininit 8 132 10 3512 7824 53 0,27 756 winlogon 9 355 23 7188 15276 85 0,22 1708 wlanext 10 345 21 6808 15232 77 0,19 3500 WLIDSVC 11 59 6 1556 3608 33 0,00 3632 WLIDSVCM 12 442 34 33316 41760 175 9,03 1372 WmiPrvSE 13 355 15 12148 17152 61 9,13 3052 WmiPrvSE 14 124 12 5760 7704 38 0,45 4984 WmiPrvSE 15 142 12 4364 8172 36 0,66 5808 WmiPrvSE 16 593 48 42032 57860 208 79,25 8544 wmplayer 17 93 9 2228 6708 69 0,03 7048 wuauclt 18 200 10 1844 5132 34 0,03 1500 WUDFHost 19 20 21 PS > Get-Process | Where-Object 22 { $_.ProcessName -match "^W.*" -and $_.Handles -lt 100} 23 24 Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName 25 ------- ------ ----- ----- ----- ------ -- ----------- 26 81 10 1744 4664 47 0,08 528 wininit 27 59 6 1556 3608 33 0,00 3632 WLIDSVCM 28 93 9 2228 6708 69 0,03 7048 wuauclt
              

              

              

            

            
Importante: O conteúdo das linhas 21 e 22 deve estar na mesma linha. Utilizei duas para respeitar o layout do blog.

            
O cmdlet WhereObject espera uma “expressão” lógica (que retorne verdadeiro ou falso). O elemento da lista que está sendo avaliado é representado pela variável reservada $_.

            
Refactoring no Powershell – Extract method (!?)

            
Powershell permite que definamos funções. Criando algumas funções utilitárias, podemos simplificar nossos scripts. Observe:

            

              

              

                1 PS C:\Users\Elemar> function EhPar($n) {$n % 2 -eq 0} 2 PS C:\Users\Elemar> EhPar(10) 3 True 4 PS C:\Users\Elemar> EhPar(5) 5 False
              

              

              

            

            
Bonito!

            
Acho que já avançamos o suficiente. Por hoje é isso!

            
Smiley piscando

            
            

              Posted in: Powershell, PS