Powershell: tudo o que queria saber sobre a declaração de FI

como muitas outras línguas, o PowerShell tem declarações para executar o código condicionalmente nos seus programas. Uma dessas declarações é a declaração de fi. Hoje vamos dar um mergulho profundo em um dos comandos mais fundamentais em PowerShell.,

  • Índice
  • execução Condicional
  • se A instrução
  • operadores de Comparação
    • -eq para a igualdade
      • -ne não igual a
    • -gt -ge-lt -le para maior ou menor do que
    • -como curinga corresponde
    • -corresponde à expressão regular
    • -é do tipo
  • Coleção de operadores
    • -contém
    • no
  • operadores Lógicos
    • -não
      • !,pressions
        • Verificação para $null
        • atribuição de Variável
      • Alternativo caminho de execução
        • else
        • if Aninhado
        • elseif
        • switch
      • Pipeline
        • Array inline
      • Simplificar operações complexas
        • continuação de Linha
        • Pré-cálculo de resultados
        • Várias instruções if
        • Usando funções
      • tratamento de Erro
      • palavras Finais

      execução Condicional

      Seus scripts, muitas vezes, precisam tomar decisões e realizar diferentes lógica com base nessas decisões., É isto que quero dizer com execução condicional. Você tem uma declaração ou valor para avaliar, em seguida, executar uma seção diferente de código com base nessa avaliação. Isto é exatamente o que a declaração

faz.

A instrução if

Aqui está um exemplo básico de if declaração:

 $condition = $true if ( $condition ) { Write-Output "The condition was true" }

a primeira coisa que O if instrução faz é avaliar a expressão entre parênteses., If it evaluates to $true, then it will executes the scriptblock in the braces. Se o valor fosse $false, então ele iria saltar sobre esse scriptblock.

no exemplo anterior, a declaração if estava apenas avaliando a variável $condition. Foi $true e teria executado o comando Write-Output dentro do scriptblock.

em algumas línguas, você pode colocar uma única linha de código após a declaração if e ela será executada., Não é esse o caso em PowerShell. Você precisa fornecer um scriptblock com aparelho para que funcione corretamente.

operadores de comparação

a coisa mais comum que você vai usar o if afirmação para é comparar dois itens com o outro. Powershell tem operadores especiais para diferentes cenários de comparação. Quando você usa um operador de comparação, o valor no lado esquerdo é comparado com o valor no lado direito.,

– eq for equality

The -eq does an equality check between two values to make sure they are equal to each other.

 $value = Get-MysteryValue if ( 5 -eq $value ) { # do something }

neste exemplo, eu estou tendo um valor conhecido de 5 e comparando-a com o meu $value para ver se eles combinam.

uma possível usecase é verificar o estado de um valor antes de você tomar uma ação sobre ele. Você pode obter um serviço e verificar se o estado estava em execução antes de chamar Restart-Service nele.,

é comum em outras línguas como C# usar == para a igualdade (ex: 5 == $value) mas isso não funciona com powershell. Outro erro comum que as pessoas cometem é usar o sinal igual (ex: 5 = $value) que é reservado para atribuir valores a variáveis. Colocando o seu valor conhecido à esquerda, torna esse erro mais estranho de fazer.este operador (e outros) têm algumas variações.,

  • -eq sensível a maiúsculas e minúsculas igualdade
  • -ieq sensível a maiúsculas e minúsculas igualdade
  • -ceq sensível a maiúsculas e minúsculas igualdade

-ne não igual a

Muitos operadores têm uma operadora que está verificando o resultado oposto. -ne verificará que os valores não se equivalem entre si.

 if ( 5 -ne $value ) { # do something }

Use isto para certificar-se de que a ação só é executado se o valor não for 5., Um bom uso-casos em que seria para verificar se um serviço estava no estado de execução antes de tentar iniciá-lo.

Variações:

  • -ne sensível a maiúsculas e minúsculas não são iguais
  • -ine sensível a maiúsculas e minúsculas não são iguais
  • -cne sensível a maiúsculas e minúsculas não são iguais

Estes são apenas inverso variações de -eq. Vou agrupar estes tipos quando listar variações para outras operadoras.,

– gt-ge-lt-le para maior ou menor do que

estes operadores são utilizados ao verificar se um valor é maior ou menor do que outro valor. The stand for GreaterThan, GreaterThanOrEqual, less than, and LessThanOrEqual.,comedor do que ou igual a, sensível a maiúsculas e minúsculas

  • -cge maior que ou igual a, sensível a maiúsculas e minúsculas
  • -lt menor que
  • -ilt menor que, sensível a maiúsculas e minúsculas
  • -clt a menos que, sensível a maiúsculas e minúsculas
  • -le menor ou igual
  • -ile menor ou igual a, sensível a maiúsculas e minúsculas
  • -cle menor ou igual a, sensível a maiúsculas e minúsculas
  • eu não sei por que você iria usar maiúsculas e minúsculas e minúsculas opções para estes operadores.,

    -like wildcard matches

    PowerShell has its own wildcard based pattern matching syntax and you can use it with the -like operator. Estes padrões de caracteres especiais são bastante básicos.

    • ? irá corresponder a qualquer caractere único
    • * irá corresponder a qualquer número de caracteres
     $value = 'S-ATX-SQL01' if ( $value -like 'S-*-SQL??') { # do something }

    É importante salientar que o padrão coincide com a seqüência inteira., Se precisar de corresponder a algo no meio do texto, então terá de colocar o * em ambas as extremidades do texto.,iv>

    Variações:

    • -like sensível a maiúsculas e minúsculas curinga
    • -ilike sensível a maiúsculas e minúsculas curinga
    • -clike sensível a maiúsculas e minúsculas curinga
    • -notlike sensível a maiúsculas e minúsculas curinga não correspondido
    • -inotlike sensível a maiúsculas e minúsculas curinga não correspondido
    • -cnotlike sensível a maiúsculas e minúsculas curinga não correspondido

    -corresponde à expressão regular

    -match operador permite que você verifique uma seqüência de caracteres para uma expressão regular com base correspondência., Use isto quando os padrões de caracteres especiais não são suficientemente flexíveis para si.

     $value = 'S-ATX-SQL01' if ( $value -match 'S-\w\w\w-SQL\d\d') { # do something }

    um padrão regex irá corresponder a qualquer ponto da cadeia por omissão. Portanto, você pode especificar uma subseqüência de caracteres que você deseja corresponder como este:

     $value = 'S-ATX-SQL01' if ( $value -match 'SQL') { # do something }

    Regex é um complexo linguagem própria e vale a pena. I talk more about -match and the many ways to use regex in another article.,

    Variations:

    • -match case insensitive regex
    • -imatch case insensitive regex
    • -cmatch case sensitive regex
    • -notmatch case insensitive regex not matched
    • -inotmatch case insensitive regex not matched
    • -cnotmatch case sensitive regex not matched

    -is of type

    You are able to check a value’s type with the -is operator.,

     if ( $value -is ) { # do something }

    pode usar isto se estiver a trabalhar com classes ou a aceitar vários objectos ao longo do gasoduto. Você pode ter um serviço ou um nome de serviço como sua entrada. Em seguida, verifique para ver se você tem um serviço e obtenha o serviço se você só tem o nome.,

     if ( $Service -isnot ) { $Service = Get-Service -Name $Service }

    Variações:

    • -is tipo
    • -isnot não é do tipo

    Coleção de operadores

    Quando você usa os operadores anteriores com um único valor, o resultado é $true ou $false. Isto é tratado de forma ligeiramente diferente quando se trabalha com uma coleção. Cada item da coleção é avaliado e o operador irá, em vez disso, retornar todos os valores que avaliam para $true.,

     PS> 1,2,3,4 -eq 3 3

    Isso ainda funciona corretamente em um if instrução. Então um valor é devolvido pelo seu operador, então a declaração inteira é $true.

     $array = 1..6 if ( $array -gt 3 ) { # do something }

    há uma pequena armadilha escondida nos detalhes aqui que eu preciso apontar. Ao usar o operador -ne desta forma, é fácil olhar erroneamente para a lógica ao contrário., Usando -necom uma colecção irá devolver $true se algum item da colecção não corresponder ao seu valor.

     PS> 1,2,3 -ne 4 1 2 3

    Este pode parecer um truque inteligente, mas temos os operadores -contains e -in que lidar com isso de forma mais eficiente e -notcontains corretamente irá fazer o que você espera.

    – contém

    o-contains o operador irá verificar a colecção quanto ao seu valor., Assim que encontrar um fósforo, ele retornará $true.

     $array = 1..6 if ( $array -contains 3 ) { # do something }

    esta é a forma preferida de ver se uma colecção contém o seu valor. Using Where-Object ( or -eq) will walk the entire list every time and be significantly slower.,

    Variações:

    • -contains sensível a maiúsculas e minúsculas correspondem
    • -icontains sensível a maiúsculas e minúsculas correspondem
    • -ccontains correspondência de maiúsculas e minúsculas
    • -notcontains sensível a maiúsculas e minúsculas não correspondido
    • -inotcontains sensível a maiúsculas e minúsculas não correspondido
    • -cnotcontains sensível a maiúsculas e minúsculas não correspondido

    no

    -in operador é como o -contains operador, exceto a coleção é sobre o lado direito.,

     $array = 1..6 if ( 3 -in $array ) { # do something }

    Variations:

    • -in case insensitive match
    • -iin case insensitive match
    • -cin case sensitive match
    • -notin case insensitive not matched
    • -inotin case insensitive not matched
    • -cnotin case sensitive not matched

    Logical operators

    Logical operators are used to invert or combine other expressions.,

    -não

    -not operador vira uma expressão de $false $true ou de $true $false. Aqui está um exemplo onde queremos executar uma ação quando Test-Path é $false.

     if ( -not ( Test-Path -Path $path ) )

    a Maioria dos operadores nós conversamos sobre fazer ter uma variação onde você não precisa usar o -not operador, mas ainda há vezes que você gostaria de usá-lo.

    !,

    pode utilizar!como nome alternativo para-not.

     if ( -not $value ){} if ( !$value ){}

    você verá! usado mais por pessoas que vêm de outras línguas como C#. Eu prefiro digitá-lo para fora porque eu acho que é difícil de ver quando olhando rapidamente para os meus scripts.

    – e

    pode combinar expressões com o operador -and. Quando você faz isso, ambos os lados precisam ser $true para que toda a expressão seja $true.,

     if ( ($age -gt 13) -and ($age -lt 55) )

    neste exemplo, $age deve ter 13 anos ou mais para o lado esquerdo e inferior a 55 para o lado direito. Eu adicionei parênteses extras para deixar mais claro nesse exemplo, mas eles são opcionais, desde que a expansão seja simples. Aqui está o mesmo exemplo sem eles.

     if ( $age -gt 13 -and $age -lt 55 )

    a avaliação acontece da esquerda para a direita. Se o primeiro item avaliar para $false então ele vai sair mais cedo e não realizar a comparação certa., Isto é útil quando você precisa se certificar de que um valor existe antes de usá-lo. Test-Pathfor example will throw an error if you give it a$null path.

     if ( $null -ne $path -and (Test-Path -Path $path) )

    ou

    -or permite que você especifique duas expressões e retorna $true se qualquer um deles for $true.

     if ( $age -le 13 -or $age -ge 55 )

    assim como -and operador, a avaliação acontece a partir da esquerda para a direita., Exceto que se a primeira parte for $true, então a declaração inteira é $true e não processará o resto da expressão.

    também tome nota de como a sintaxe funciona para estes operadores. Precisas de duas expressões separadas. Eu vi Usuários tentar fazer algo assim $value -eq 5 -or 6 sem perceber seu erro.

    -XOR exclusive ou

    Este é um pouco incomum. -xor permite apenas uma expressão para avaliar a $true., Então, se ambos os itens são $false ou ambos os itens são $true, em seguida, toda a expressão é $false. Outra maneira de olhar para isso é a expressão é apenas $true quando os resultados da expressão são diferentes.

    é raro que alguém alguma vez use este operador lógico e eu não consigo pensar em um bom exemplo de porque eu iria usá-lo.

    operadores Bitwise

    operadores Bitwise realizam cálculos sobre os bits dentro dos valores e produzem um novo valor como resultado., Ensinar operadores bitwise está além do escopo deste artigo, mas aqui está a lista deles.

    • -band binário E
    • -bor binário OU
    • -bxor binário exclusivo OU
    • -bnot binário NÃO
    • -shl shift para a esquerda
    • -shr shift direito

    PowerShell expressões

    podemos normal de utilização do PowerShell dentro da declaração de condição.,

     if ( Test-Path -Path $Path )

    Test-Path retorna $true ou $false quando ele é executado. Isto também se aplica a comandos que devolvem outros valores.

     if ( Get-Process Notepad* )

    Ele irá avaliar a $true se existe um devolvidos processo e $false se não houver nada., É perfeitamente válida para o uso de pipeline expressões ou outros PowerShell afirmações como esta:

     if ( Get-Process | Where Name -eq Notepad )

    Estas expressões podem ser combinados uns com os outros, com o -and e -or operadores, mas você pode ter que usar parênteses para quebrá-los em sub-expressões.

     if ( (Get-Process) -and (Get-Service) )

    Verificação para $null

    apesar nenhum resultado ou uma $null valor de avalia $false if instrução., Ao verificar especificamente para $null, é uma boa prática colocar o $null no lado esquerdo.

     if ( $null -eq $value )

    Há algumas nuances ao lidar com $null valores no PowerShell. Se você está interessado em mergulhar mais fundo, eu tenho um artigo sobre tudo o que você queria saber sobre $null.

    atribuição de variáveis

    quase me esqueci de adicionar este até Prasoon Karunan V me lembrar dele.,

    normalmente, quando você atribui um valor a uma variável, o valor não é passado para o pipeline ou consola. Quando você faz uma atribuição variável em uma sub-expressão, ela é passada para o pipeline.

     PS> $first = 1 PS> ($second = 2) 2

    Veja como o $first atribuição não tem saída e o $second atribuição não? Quando uma atribuição é feita em um ID

    , ela será executada exatamente como o ID

    atribuição acima., Aqui é um exemplo de como você pode utilizar:

     if ( $process = Get-Process Notepad* ) { $process | Stop-Process }

    Se $process é atribuído um valor e, em seguida, a instrução será $true e o $process vai ficar parado.

    certifique-se que não confunde isto com -eq porque isto não é uma verificação da igualdade. Esta é uma característica mais obscura que a maioria das pessoas não percebem que funciona assim.,

    Alternativo caminho de execução

    if instrução permite que você especificar uma ação para não só quando a instrução é $true, mas também para quando é $false. É aqui que a afirmação else entra em jogo.

    else

    The else statement is always the last part of the if statement when used.

    neste exemplo, nós verificamos o $path para ter certeza de que é um arquivo. Se encontrarmos o ficheiro, mudamo-lo. Se não, escrevemos um aviso., Este tipo de lógica ramificada é muito comum.

    if Aninhado

    if e else declarações de levar um bloco de script, de modo que podemos colocar qualquer comando do PowerShell dentro deles, incluindo outra if instrução. Isso permite que você faça uso de uma lógica muito mais complicada.

    neste exemplo, nós testamos o caminho feliz primeiro e, em seguida, tomar medidas sobre ele. Se isso falhar, nós fazemos outra verificação e para fornecer informações mais detalhadas ao usuário.

    elseif

    não estamos limitados a apenas um único controlo condicional., We can chain if and else statements together instead of nesting them by using the elseif statement.

    a execução acontece de cima para baixo. A declaração top if é avaliada primeiro. Se esse é $false, então ele desce para o próximo elseif ou else na lista. Esse último else é a ação padrão a tomar se nenhum dos outros retornar $true.,

    switch

    At tis point, I need to mention the switch statement. Ele fornece uma sintaxe alternativa para fazer comparações múltiplas com um valor. Com o switch, você especifica uma expressão e esse resultado é comparado com vários valores diferentes. Se um desses valores mach, então o bloco de código correspondente é executado. Veja este exemplo:

     $itemType = 'Role' switch ( $itemType ) { 'Component' { 'is a component' } 'Role' { 'is a role' } 'Location' { 'is a location' } }

    Existem três valores possíveis que podem corresponder ao $itemType., Neste caso, irá corresponder com Rolee o is a role seria executado. Usei um exemplo muito simples apenas para lhe dar alguma exposição ao switch operador. Eu falo mais sobre tudo o que você sempre quis saber sobre a declaração de troca em outro artigo.

    Pipeline

    o pipeline é uma característica muito única e importante do PowerShell. Qualquer valor que não seja suprimido ou atribuído a uma variável é colocado no pipeline., O if fornece-nos uma forma de tirar partido do gasoduto de uma forma que nem sempre é óbvia.

     $discount = if ( $age -ge 55 ) { Get-SeniorDiscount } elseif ( $age -le 13 ) { Get-ChildDiscount } else { 0.00 }

    cada bloco de programa está a colocar os resultados dos comandos ou o valor na conduta. Então estamos atribuindo o resultado da instrução if para a variável $discount. Esse exemplo poderia ter facilmente atribuído esses valores à variável$discount diretamente em cada scriptblock., Eu não posso dizer que eu uso isso com a declaração if muitas vezes, mas eu tenho um exemplo onde eu usei isso recentemente.

    Array inline

    i have a function called Invoke-SnowSql that launches an executable with several commandline arguments. Aqui está um clipe dessa função onde eu construo o array de argumentos.

    as variáveis

    e $Path são parâmetros sobre a função que são fornecidos pelo Utilizador Final. Avalio-os em linha dentro da inicialização da minha matriz., Se $Debugfor verdadeiro, então esses valores caem no $snowSqlParam no lugar correto. O mesmo vale para a variável

    .

    Simplifique as operações complexas

    é inevitável que você se depare com uma situação que tem demasiadas comparações para verificar e a sua declaração se desloca para fora do lado direito da tela.

    eles podem ser difíceis de ler e que fazem você mais propenso a cometer erros. Há algumas coisas que podemos fazer quanto a isso.,

    continuação da linha

    Existem alguns operadores em PowerShell que lhe permitem mudar o comando para a linha seguinte. Os operadores lógicos -and e -or são bons operadores de usar se você quiser quebrar a sua expressão em várias linhas.

    ainda há muita coisa acontecendo lá, mas colocar cada peça em sua própria linha faz uma grande diferença. Eu geralmente só faço isso quando eu recebo mais de duas comparações ou se eu tenho que rolar para a direita para ler qualquer um dos ligic.,

    pré-cálculo dos resultados

    podemos retirar essa Declaração da declaração if e apenas verificar o resultado.

    isto apenas se sente muito mais limpo do que o exemplo anterior. Você também tem a oportunidade de usar um nome de variável que explica o que é que você está realmente verificando. Este é também um exemplo de código auto-documentado que poupa comentários desnecessários.

    múltiplo if statements

    We can break this up into multiple statements and check them one at a time. Neste caso, usaremos uma bandeira ou uma variável de rastreamento para combinar os resultados.,

    eu tive que inverter a lógica para fazer a lógica da bandeira funcionar corretamente. Cada avaliação é uma declaração individual

    . A vantagem disso é que quando você está debugging, você pode dizer exatamente o que a lógica está fazendo. Pude adicionar uma verbosidade muito melhor ao mesmo tempo.

    a desvantagem óbvia é que é muito mais código para escrever. O código é mais complexo de se olhar como ele toma uma única linha de lógica e explode-o em 25 ou mais linhas.

    usando funções

    também podemos mover toda a lógica de validação para uma função., Olha como isto parece limpo.

     if ( Test-SecureDriveConfiguration -ADUser $user ) { # do something }

    ainda tem de criar a função para fazer a validação, mas torna este código muito mais fácil de trabalhar. Torna este código mais fácil de testar. Em seus testes, você pode zombar da chamada para Test-ADDriveConfiguration e você só precisa de dois testes para esta função. Um em que devolve $true e outro em que devolve $false. Testar a outra função será mais simples porque é tão pequena.,

    O corpo dessa função ainda pode ser aquele Invólucro único com o qual começamos ou a lógica explodida que usamos na última seção. Isso funciona bem para ambos os cenários e permite que você facilmente mudar essa implementação mais tarde.

    tratamento de erros

    uma utilização realmente importante da declaração

    é verificar as condições de erro antes de se deparar com erros. Um bom exemplo é verificar se uma pasta já existe antes de tentar criá-la.,

     if ( -not (Test-Path -Path $folder) ) { New-Item -Type Directory -Path $folder }

    eu gosto de dizer que se você espera que uma exceção aconteça, então não é realmente uma exceção. Por isso, verifique os seus valores e valide as suas condições onde puder.

    Se você quiser mergulhar um pouco mais na movimentação real de exceções, eu tenho um artigo sobre tudo o que você sempre quis saber sobre exceções.

    Palavras Finais

    a declaraçãoif é uma declaração tão simples, mas é uma peça fundamental de PowerShell. Você vai encontrar-se usando isso várias vezes em quase todos os script que você escreve., Espero que tenhas uma melhor compreensão do que tinhas antes.

    Share

    Deixe uma resposta

    O seu endereço de email não será publicado. Campos obrigatórios marcados com *