sexta-feira, novembro 24, 2017
Breaking News
Home » Programação/ Scripts » Power Shell » Operadores de comparação PowerShell

Operadores de comparação PowerShell

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.

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 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/

 

Sobre Diego Duarte

Diego Duarte Atua como coordenador de NOC, toca um violãozinho nas horas vagas e tenta eternamente entender o que o fez escolher TI

Veja também!

Aol quer reinventar o email com ALTO

  A AOL iniciou as primeiras operações do Alto, um novo gerenciador de emails totalmente …

Este artigo lhe foi útil? comente e ajude outros acrescentando seu ponto de vista!