Veremos aqui um conjunto de operadores de comparação do PowerShell. Pela natureza “linha de comando”, não encontramos os operadores 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.
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 { $_.ProcessName -match "^W.*" -and $_.Handles -lt 100} 22. 23. Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName 24. ------- ------ ----- ----- ----- ------ -- ----------- 25. 81 10 1744 4664 47 0,08 528 wininit 26. 59 6 1556 3608 33 0,00 3632 WLIDSVCM 27. 93 9 2228 6708 69 0,03 7048 wuauclt
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
Bom, fico por aqui, espero que apreciem o conteúdo.
Créditos desta postagem: http://elemarjr.net/2011/02/02/powershell-para-desenvolvedores-parte-2-operadores-e-funes/
