TÓPICO
    about_assignment_operators

DESCRIÇÃO RESUMIDA
    Descreve como usar operadores para atribuir valores a variáveis.



DESCRIÇÃO LONGA
    Os operadores de atribuição atribuem um ou mais valores a uma 
    variável. Eles podem executar operações numéricas nos valores antes da 
    atribuição.


    O Windows PowerShell oferece suporte aos seguintes operadores de 
    atribuição.


    Operador  Descrição  
    -------   -----------
    =         Define o valor de uma variável para o valor especificado.

    +=        Aumenta o valor de uma variável segundo o valor especificado 
    	      ou acrescenta o valor especificado ao valor existente.
 
    -=        Diminui do valor de uma variável o valor especificado.
 
    *=        Multiplica o valor de uma variável pelo valor especificado 
              ou acrescenta o valor especificado ao valor existente.
 
    /=        Divide o valor de uma variável pelo valor especificado.
 
    %=        Divide o valor de uma variável pelo valor especificado 
              e atribui o resto (módulo) à variável.

    ++        Aumenta em 1 o valor de uma variável, propriedade que 
              pode ser atribuída ou elemento da matriz.

    --        Diminui em 1 o valor de uma variável, propriedade que 
              pode ser atribuída ou elemento da matriz.
 

  SINTAXE
    A sintaxe dos operadores de atribuição é a seguinte:


        <expressão-atribuível> <operador-atribuição> <valor>


    Expressões que podem ser atribuídas incluem variáveis e 
    propriedades. O valor pode ser único, uma matriz de valores e 
    também um comando, uma expressão ou uma instrução.


    Os operadores de incremento e decremento são operadores unários. 
    Cada um deles tem versões prefixada e pós-fixada.


        <expressão-atribuível><operador>
        <operador><expressão-atribuível>


    A expressão atribuível deve ser um número ou deve poder ser 
    convertida em um número.


  ATRIBUINDO VALORES
    Variáveis são espaços de memória nomeados que armazenam valores. Você 
    armazena os valores em variáveis usando o operador de atribuição (=). 
    O novo valor pode substituir o valor existente da variável ou você 
    pode acrescentar um novo valor ao valor existente.


    O operador de atribuição básico é o sinal de igual (=)(ASCII 61).  
    Por exemplo, a instrução a seguir atribui o valor Windows PowerShell à 
    variável $MyShell:


        $MyShell = "Windows PowerShell" 


    Quando você atribui um valor a uma variável no Windows PowerShell,  
    a variável é criada caso ainda não exista. Por exemplo, a primeira das  
    duas instruções de atribuição a seguir cria a variável $a e atribui o 
    valor 6 a $a. A segunda instrução de atribuição atribui o valor 12 a $a. 
    A primeira instrução cria uma nova variável. A segunda instrução altera 
    apenas seu valor:


        $a = 6
        $a = 12

 
    Variáveis no Windows PowerShell não têm um tipo de dados 
    específico a menos que você as converta. Quando uma variável 
    contiver apenas um objeto, ela assumirá o tipo de dados desse 
    objeto. Quando uma variável contiver um conjunto de objetos, ela 
    terá o tipo de dados System.Object. Portanto, você pode atribuir 
    qualquer tipo de objeto ao conjunto. O exemplo a seguir mostra 
    que você pode adicionar objetos de processos, objetos de serviço, 
    cadeias de caracteres e inteiros a uma variável sem gerar um erro: 


        $a = get-process
        $a += get-service
        $a += "string"
        $a += 12
 

    Como o operador de atribuição (=) tem uma precedência inferior à 
    do operador de pipeline (|), os parênteses não são necessários 
    para atribuir o resultado de um pipeline de comando a uma variável. 
    Por exemplo, o comando a seguir classifica os serviços no 
    computador e atribui os serviços classificados à variável $a:


        $a = get-service | sort name


    Você também pode atribuir o valor criado por uma instrução a uma 
    variável, conforme mostrado no exemplo a seguir: 


        $a = if ($b -lt 0) { 0 } else { $b }


    Este exemplo atribui 0 à variável $a se o valor de $b for menor 
    que 0. Ele atribui o valor de $b a $a se o valor de $b não for 
    menor que zero. 

 

  O OPERADOR DE ATRIBUIÇÃO (=)
    O operador de atribuição (=)atribui valores a variáveis. Se a 
    variável já tiver um valor, o operador de atribuição (=) 
    substituirá o valor sem aviso.


    A instrução a seguir atribui o valor inteiro 6 à variável $a:


        $a = 6 

    Para atribuir um valor de cadeia de caracteres a uma variável, 
    coloque o valor entre aspas, conforme mostrado a seguir:


        $a = "beisebol" 


    Para atribuir uma matriz (vários valores) a uma variável, separe 
    os valores com vírgulas, conforme mostrado a seguir:


        $a = "maçã", "laranja", "limão", "uva" 

    Para atribuir uma tabela de hash a uma variável, use a notação 
    padrão de tabela de hash no Windows PowerShell. Digite um sinal 
    de arroba (@) seguido de pares de chave/valor separados por 
    ponto-e-vírgulas (;) e colocados entre chaves ({ }). Por exemplo,  
    para atribuir uma tabela de hash à variável $a, digite:


        $a = @{um=1; dois=2; três=3} 


    Para atribuir valores hexadecimais a uma variável, coloque "0x" 
    antes do valor. O Windows PowerShell converte o valor hexadecimal 
    (0x10) em um valor decimal (neste caso, 16) e atribui esse valor 
    à variável $a. Por exemplo, para atribuir o valor 0x10 à variável 
    $a, digite:


        $a = 0x10 


    Para atribuir um valor exponencial a uma variável, digite o 
    número da raiz, a letra "e" e um número que represente um 
    múltiplo de 10. Por exemplo, para atribuir o valor 3,1415 elevado 
    à potência 1.000 à variável $a, digite:


        $a = 3.1415e3 


    O Windows PowerShell também pode converter kilobytes (KB), 
    megabytes (MB) e gigabytes (GB) em bytes. Por exemplo, para 
    atribuir o valor 10 kilobytes à variável $a, digite:


        $a = 10kb


  O OPERADOR DE ATRIBUIÇÃO POR ADIÇÃO (+=)
    O operador de atribuição por adição (+=) incrementa o valor de 
    uma variável ou acrescenta o valor especificado ao valor existente.
    A ação depende de a variável ter um tipo numérico ou de cadeia 
    de caracteres e também de conter um único valor (escalar) ou 
    vários valores (um conjunto).


    O operador += combina duas operações. Primeiro, ele adiciona e depois 
    atribui. Portanto, as seguintes instruções são equivalentes:


        $a += 2
        $a = ($a + 2)

 
    Quando a variável contém um único valor numérico, o operador += 
    incrementa ao valor existente a quantidade especificada do lado 
    direito do operador. Em seguida, o operador atribui o valor 
    resultante à variável.
    O exemplo a seguir mostra como usar o operador += para aumentar o 
    valor de uma variável:


        C:\PS> $a = 4
        C:\PS> $a += 2
        C:\PS> $a
        6
 

    Quando o valor da variável é uma cadeia de caracteres, o valor no lado 
    direito do operador é acrescentado à cadeia, da seguinte forma: 


        C:\PS> $a = "Windows"
        C:\PS> $a +- " PowerShell"
        C:\PS> $a
        Windows PowerShell 


    Quando o valor da variável está em uma matriz, o operador += 
    acrescenta os valores no lado direito do operador à matriz. A 
    menos que a matriz seja explicitamente digitada por transmissão, 
    você pode acrescentar qualquer tipo de valor à matriz, da 
    seguinte forma:


        C:\PS> $a = 1,2,3
        C:\PS> $a += 2
        C:\PS> $a
        1
        2
        3
        2
        C:\PS> $a += "String"
        C:\PS> $a
        1
        2
        3
        2
        String

 
    Quando o valor de uma variável é uma tabela de hash, o operador += 
    acrescenta o valor no lado direito do operador à tabela de hash. 
    Porém, como o único tipo que você pode adicionar a uma tabela de hash 
    é outra tabela de hash, todas as outras atribuições falharão.


    Por exemplo, o comando a seguir atribui uma tabela de hash à 
    variável $a.
    Em seguida, ele usa o operador += para acrescentar outra tabela 
    de hash à tabela de hash existente, adicionando de modo eficaz um 
    novo par chave/valor à tabela de hash existente. Esse comando é 
    bem-sucedido, conforme mostrado na saída:


        C:\PS> $a = @{a = 1; b = 2; c = 3}
        C:\PS> $a += @{mode = "write"}
        C:\PS> $a
        Nome                           Valor
        ----                           -----
        a                              1
        b                              2
        mode                           write
        c                              3


    O seguinte comando tenta acrescentar um inteiro (1) à tabela de 
    hash na variável $a. Este comando falha:


        C:\PS> $a = @{a = 1; b = 2; c = 3}
        C:\PS> $a += 1
        Você pode adicionar outra tabela de hash somente a uma tabela 
        de hash.
        At line:1 char:6
        + $a += <<<< 1


  O OPERADOR DE ATRIBUIÇÃO POR SUBTRAÇÃO (-=)
    O operador de atribuição por subtração -= decrementa do valor de uma 
    variável o valor especificado no lado direito do operador.
    Esse operador não pode ser usado com variáveis de cadeia de 
    caracteres e não pode ser usado para remover um elemento de um 
    conjunto.


    O operador -= combina duas operações. Primeiro, ele subtrai. 
    Depois, atribui. Portanto, as seguintes instruções são equivalentes:


        $a -= 2
        $a = ($a - 2)

 
    O exemplo a seguir mostra como usar o operador -= para diminuir o 
    valor de uma variável:


        C:\PS> $a = 8
        C:\PS> $a -= 2
        C:\PS> $a
        6

 
    Você também pode usar o operador de atribuição -= para diminuir o 
    valor de um membro de uma matriz numérica. Para isso, especifique 
    o índice do elemento da matriz que deseja alterar. No exemplo a 
    seguir, o valor do terceiro elemento de uma matriz (elemento 2) é 
    diminuído em 1:


        C:\PS> $a = 1,2,3
        C:\PS> $a[2] -= 1.
        C:\PS> $a
        1
        2
        2

 
    Você não pode usar o operador -= para excluir os valores de uma 
    variável. Para excluir todos os valores que são atribuídos a uma 
    variável, use os cmdlets Clear-Item ou Clear-Variable para 
    atribuir o valor $null ou "" à variável.


        $a = $null 


    Para excluir um valor específico de uma matriz, use notação de 
    matriz para atribuir o valor $null ao item específico. Por exemplo, a 
    seguinte instrução exclui o segundo valor (posição de índice 1) da matriz.



        C:\PS> $a = 1,2,3
        C:\PS> $a
        1
        2
        3

        C:\PS> $a[1] = $null
        C:\PS> $a
        1
        3
 

    Para excluir uma variável, use o cmdlet Remove-Variable. Esse 
    método é útil quando a variável é convertida explicitamente em um 
    tipo de dados específico e você deseja uma variável sem tipo.  
    O comando a seguir exclui a variável $a:


        remove-variable a
 

  O OPERADOR DE A ATRIBUIÇÃO POR MULTIPLICAÇÃO (*=) 
    O operador de atribuição por multiplicação (*=) multiplica um valor 
    numérico ou acrescenta o número especificado de cópias do valor da 
    cadeia de caracteres de uma variável. 


    Quando uma variável contém um único valor numérico, esse valor é 
    multiplicado pelo valor no lado direito do operador. O exemplo a 
    seguir mostra como usar o operador *= para multiplicar o valor 
    de uma variável:


        C:\PS> $a = 3
        C:\PS> $a *= 4
        C:\PS> $a
        12
 

    Neste caso, o operador *= combina duas operações. Primeiro, ele 
    multiplica. Depois, atribui. Portanto, as seguintes instruções são 
    equivalentes:


        $a *= 2
        $a = ($a * 2)

 
    Quando uma variável contém um valor de cadeia de caracteres, o Windows 
    PowerShell acrescenta o número especificado de cadeias ao valor, conforme 
    mostrado a seguir:


        C:\PS> $a = "arquivo"
        C:\PS> $a *= 4 
        C:\PS> $a
        arquivoarquivoarquivoarquivo

 
    Para multiplicar um elemento de uma matriz, use um índice para 
    identificar o elemento que deseja multiplicar. Por exemplo,  
    o comando a seguir multiplica o primeiro elemento da matriz 
    (posição de índice 0) por 2:


        $a[0] *= 2
 

  O OPERADOR DE ATRIBUIÇÃO POR DIVISÃO (/=)
    O operador de atribuição por divisão (/=) divide um valor 
    numérico pelo valor especificado no lado direito do operador.  
    O operador não pode ser usado com variáveis de cadeias de caracteres.


    O operador /= combina duas operações. Primeiro, ele divide. 
    Depois, atribui. Portanto, as duas seguintes instruções são 
    equivalentes:


        $a /= 2
        $a = ($a / 2)

 
    Por exemplo, o comando a seguir usa o operador /= para dividir o 
    valor de uma variável:


        C:\PS> $a = 8
        C:\PS> $a /=2
        C:\PS> $a
        4

 
    Para dividir um elemento de uma matriz, use um índice para 
    identificar o elemento que deseja alterar. Por exemplo, o comando 
    a seguir divide o segundo elemento na matriz (posição de índice 1) 
    por 2:


        $a[1] /= 2
 

  O OPERADOR DE ATRIBUIÇÃO POR MÓDULO (%=)
    O operador de atribuição por módulo (%=) divide o valor de uma 
    variável pelo valor no lado direito do operador. Em seguida, o 
    operador %= atribui o resto (conhecido como módulo) à variável. 
    Você só pode usar esse operador quando uma variável contém um 
    único valor numérico. Não é possível usá-lo quando uma variável 
    contém uma variável de cadeia de caracteres ou uma matriz.


    O operador %= combina duas operações. Primeiro, ele divide e 
    determina o resto e, em seguida, atribui o resto à variável. 
    Portanto, as seguintes instruções são equivalentes:


        $a %= 2
        $a = ($a % 2)

 
    O exemplo a seguir mostra como usar o operador %= para salvar o 
    resto de um quociente:


        C:\PS> $a = 7
        C:\PS> $a %= 4
        C:\PS> $a
        3


  OS OPERADORES DE INCREMENTO E DECREMENTO

    O operador de incremento (++) aumenta o valor de uma variável em 1. 
    Quando você usa o operador de incremento em uma instrução simples, 
    nenhum valor é retornado.
    Para ver o resultado, exiba o valor da variável, da seguinte forma:


        C:\PS> $a = 7
        C:\PS> ++$a
        C:\PS> $a
        8


    Para forçar um valor a ser retornado, coloque a variável e o 
    operador entre parênteses, da seguinte forma:


        C:\PS> $a = 7
        C:\PS> (++$a)
        8


    O operador de incremento pode ser colocado antes de (prefixado) 
    ou depois de (pós-fixado) uma variável. A versão prefixada do operador 
    incrementa uma variável antes de seu valor ser usado na instrução, da 
    seguinte forma:


        C:\PS> $a = 7
        C:\PS> $c = ++$a
        C:\PS> $a
        8
        C:\PS> $c
        8


    A versão pós-fixada do operador incrementa uma variável depois de 
    seu valor ser usado na instrução. No exemplo a seguir, as 
    variáveis $c e $a têm valores diferentes porque o valor é 
    atribuído a $c antes de $a ser alterada:


        C:\PS> $a = 7
        C:\PS> $c = $a++
        C:\PS> $a
        8
        C:\PS> $c
        7


    O operador de decremento (--) reduz o valor de uma variável em 1. Como 
    ocorre com o operador de incremento, nenhum valor é retornado quando 
    se usa o operador em uma instrução simples. Use parênteses para 
    retornar um valor, da seguinte forma:


        C:\PS> $a = 7
        C:\PS> --$a
        C:\PS> $a
        6
        C:\PS> (--$a)
        5


    A versão prefixada do operador decrementa uma variável antes de 
    seu valor ser usado na instrução, da seguinte forma:


        C:\PS> $a = 7
        C:\PS> $c = --$a
        C:\PS> $a
        6
        C:\PS> $c
        6


    A versão pós-fixada do operador decrementa uma variável depois de 
    seu valor ser usado na instrução. No exemplo a seguir, as 
    variáveis $d e $a têm valores diferentes porque o valor é 
    atribuído a $d antes de $a ser alterada:


        C:\PS> $a = 7
        C:\PS> $d = $a--
        C:\PS> $a
        6
        C:\PS> $d
        7


  TIPOS DO MICROSOFT .NET FRAMEWORK
    Por padrão, quando uma variável tem apenas um valor, o valor atribuído 
    a ela determina o tipo de dados da variável. Por exemplo, o comando 
    a seguir cria uma variável que tem o tipo Inteiro (System.Int32):


        $a = 6 


    Para localizar o tipo do .NET Framework de uma variável, use o método 
    GetType e sua propriedade FullName, conforme mostrado a seguir. Inclua os 
    parênteses depois do nome de método GetType, mesmo que a chamada de 
    método não tenha argumentos:


        C:\PS> $a = 6 
        C:\PS> $a.gettype().fullname 
        System.Int32 


    Para criar uma variável que contenha uma cadeia de caracteres, 
    atribua um valor da cadeia de caracteres à variável. Para indicar 
    que o valor é uma cadeia de caracteres, coloque-o entre aspas, 
    conforme mostrado a seguir:


        C:\PS> $a = "6"
        C:\PS> $a.gettype().fullname
        System.String

 
    Se o primeiro valor atribuído à variável for uma cadeia de 
    caracteres, o Windows PowerShell tratará todas as operações como 
    de cadeias de caracteres e converterá novos valores em cadeias. 
    Isso ocorre no seguinte exemplo:


        C:\PS> $a = "arquivo"
        C:\PS> $a += 3
        C:\PS> $a
        arquivo3

 
    Se o primeiro valor for um número inteiro, o Windows PowerShell 
    tratará todas as operações como sendo com inteiros e converterá  
    novos valores em inteiros. Isso ocorre no seguinte exemplo:


        C:\PS> $a = 6
        C:\PS> $a += "3"
        C:\PS> $a
        9

 
    Você pode converter uma nova variável escalar em qualquer tipo do .NET 
    Framework, colocando o nome do tipo entre colchetes, que precedam o 
    nome da variável ou o primeiro valor de atribuição. Ao converter uma 
    variável, você pode determinar os tipos de dados que podem ser 
    armazenados na variável. Pode determinar também como a variável se 
    comporta quando você a manipula.


    Por exemplo, o comando a seguir converte a variável como um tipo 
    de cadeia de caracteres:


        C:\PS> [string]$a = 27
        C:\PS> $a += 3
        C:\PS> $a
        273
 

    O exemplo a seguir converte o primeiro valor, em vez de converter 
    a variável:


        $a = [string]27

 
    Ao converter uma variável para um tipo específico, a convenção comum é 
    converter a variável, mas não o valor. Porém, você não poderá 
    reconverter o tipo de dados de uma variável existente se o seu valor 
    não puder ser convertido no novo tipo de dados. Para alterar o tipo 
    de dados, você deve substituir seu valor, da seguinte forma:


        C:\PS> $a = "string"
        C:\PS> [int]$a
        Não é possível converter o valor "string" para o tipo 
        "System.Int32". Erro: "A cadeia de caracteres de entrada não 
        está em um formato correto".
        At line:1 char:8
        + [int]$a <<<<

        C:\PS> [int]$a =3
 

    Além disso, ao colocar um tipo de dados antes do nome de uma 
    variável, o tipo dessa variável é bloqueado até que você substitua
    explicitamente o tipo, especificando outro tipos de dados. Se você 
    tentar atribuir um valor incompatível com o tipo existente e não substituir 
    explicitamente o tipo, o Windows PowerShell exibirá um erro, conforme 
    mostrado no exemplo a seguir:


        C:\PS> $a = 3
        C:\PS> $a = "string"

        C:\PS> [int]$a = 3
        C:\PS> $a = "string"
        Não é possível converter o valor "string" para o tipo 
        "System.Int32". Erro: "A cadeia de caracteres de entrada não 
        está em um formato correto".
        At line:1 char:3
        + $a <<<< = "string"

        C:\PS> [string]$a = "string"
 

    No Windows PowerShell, os tipos de dados de variáveis que contêm 
    vários itens em uma matriz são tratados de modo diferente dos 
    tipos de dados de variáveis que contêm um único item. A menos que 
    um tipo de dados seja especificamente atribuído a uma variável de 
    matriz, ele sempre será System.Object []. Esse tipo de dados é 
    específico de matrizes.


    Em alguns casos, você pode substituir o tipo padrão especificando 
    outro tipo. Por exemplo, o comando a seguir converte a variável 
    em um tipo de matriz string []:



        [string []] $a = "um", "dois", "três"
 

    As variáveis do Windows PowerShell podem ser de qualquer tipo de dados 
    do .NET Framework. Além disso, você pode atribuir qualquer tipo de dados 
    totalmente qualificado do .NET Framework disponível no processo atual. Por 
    exemplo, o seguinte comando especifica um tipo de dados System.DateTime:


        [system.datetime]$a = "31/5/2005"

 
    Será atribuído um valor à variável em conformidade com o tipo de dados 
    System.DateTime. O valor da variável $a seria o seguinte:


        Terça-feira, 31 de maio de 2005 00:00:00


  ATRIBUINDO VÁRIAS VARIÁVEIS
    No Windows PowerShell, você pode atribuir valores a muitas 
    variáveis com um único comando. O primeiro elemento do valor de 
    atribuição é atribuído à primeira variável, o segundo é atribuído 
    à segunda, o terceiro à terceira e assim por diante. Por exemplo, 
    o comando a seguir atribui o valor 1 à variável $a, o valor 2 à 
    variável $b e o valor 3 à variável $c.


        C:\PS> $a, $b, $c = 1, 2, 3

 
    Se o valor de atribuição contiver mais elementos do que variáveis,
    todos os valores restantes serão atribuídos à última variável.
    Por exemplo, o comando a seguir contém três variáveis e cinco 
    valores:


        $a, $b, $c = 1, 2, 3, 4, 5

 
    Portanto, o Windows PowerShell atribui o valor 1 à variável $a e 
    o valor 2 à variável $b. Ele atribui os valores 3, 4 e 5 à 
    variável $c. Para atribuir os valores na variável $c a três 
    outras variáveis, use o seguinte formato:


        $d, $e, $f = $c


    Esse comando atribui o valor 3 à variável $d, o valor 4 à 
    variável $e e o valor 5 à variável $f.


    Você também pode atribuir um único valor a várias variáveis 
    encadeando as variáveis. Por exemplo, o comando a seguir atribui 
    um valor de "três" a todas as quatro variáveis:


        $a = $b = $c = $d = "três"

    
  CMDLETS RELACIONADOS A VARIÁVEIS
    Além de usar uma operação de atribuição para definir um valor de 
    variável, você também pode usar o cmdlet Set-Variable. Por exemplo, 
    o comando a seguir usa Set-Variable para atribuir uma matriz de  
    1, 2, 3 à variável $a.


        Set-Variable -name a -value 1, 2, 3 

CONSULTE TAMBÉM
    about_Arrays
    about_Hash_Tables
    about_Variables
    Clear-Variable
    Remove-Variable
    Set-Variable




Sumário