TEMA
    about_arithmetic_operators

DESCRIPCIÓN BREVE
    Describe los operadores que realizan operaciones aritméticas en 
    Windows PowerShell.

DESCRIPCIÓN DETALLADA

    Los operadores aritméticos calculan valores numéricos. Puede 
    utilizar uno o más operadores aritméticos para sumar, restar, 
    multiplicar y dividir valores, así como para calcular el resto 
    (módulo) de una operación de división.

    Además, el operador de adición (+) y el operador de 
    multiplicación (*) también funcionan con cadenas, matrices y 
    tablas hash. El operador de adición concatena la entrada. El 
    operador de multiplicación devuelve varias copias de la entrada. 
    Incluso se pueden mezclar tipos de objetos en una instrucción 
    aritmética.
    El tipo del objeto del extremo izquierdo de la expresión 
    determina el método que se utiliza para evaluar la instrucción.

    Windows PowerShell admite los siguientes operadores aritméticos:


    Operador  Descripción                             Ejemplo
    --------  -----------                             -------
    +         Suma números enteros; concatena         6+2
              cadenas, matrices y tablas hash.        "archivo" + "nombre"

    -         Resta un valor de otro.                 6-2 
                                                      (get-date).date - 1

    -         Convierte un número en negativo.        -6+2
                                                      -4

    *         Multiplica números enteros; copia       6*2
              las cadenas y las matrices el número    "w" * 3
              de veces especificado.     
                   
    /         Divide dos valores.                     6/2


    %         Devuelve el resto de una operación      7%2
              de división.     
 
 

    PRIORIDAD DE OPERADORES
    Windows PowerShell procesa los operadores aritméticos en el orden 
    siguiente:

        Paréntesis ()
        - (para un número negativo)
        *, /, %
        +, - (para la resta)


    Windows PowerShell procesa las expresiones de izquierda a 
    derecha, según las reglas de precedencia. En los ejemplos 
    siguientes se muestra el efecto de las reglas de precedencia: 

        C:\PS> 3+6/3*4 
        11

        C:\PS> 10+4/2
        12

        C:\PS> (10+4)/2
        7

        C:\PS> (3+3)/ (1+1)
        3
 
    El orden en el que Windows PowerShell evalúa las expresiones 
    podría variar con respecto al de otros lenguajes de programación 
    y creación de script utilizados. En el ejemplo siguiente se 
    muestra una instrucción de asignación complicada.

        C:\PS> $a = 0
        C:\PS> $b = 1,2
        C:\PS> $c = -1,-2
        
        C:\PS> $b[$a] = $c[$a++]
        
        C:\PS> $b
        1
        -1

    En este ejemplo, la expresión $a++ se evalúa antes que $c[$a++]. 
    Al evaluar $a++, cambia el valor de $a. La variable $a de $b[$a] 
    es igual a 1, no a 0, de modo que la instrucción asigna un valor 
    a $b[1], no a $b[0].



    SUMAR Y MULTIPLICAR TIPOS NO NUMÉRICOS
    Es posible sumar números, cadenas, matrices y tablas hash. 
    Además, se pueden multiplicar números, cadenas y matrices. Sin 
    embargo, no se pueden multiplicar las tablas hash.

    Al sumar cadenas, matrices o tablas hash, se concatenan los 
    elementos. Al concatenar colecciones, como matrices o tablas 
    hash, se crea un nuevo objeto que contiene los objetos de ambas 
    colecciones. Si se intentan concatenar tablas hash que tienen la 
    misma clave, se produce un error en la operación.

    Por ejemplo, los comandos siguientes crean dos matrices y, a 
    continuación, las suman:


	C:\PS> $a = 1,2,3
	C:\PS> $b = "A","B,"C"
	C:\PS> $a + $b
	1
	2
	3
	A
	B
	C
 

    También es posible realizar operaciones aritméticas con objetos 
    de tipos diferentes. El tipo de Microsoft .NET Framework del 
    objeto del extremo izquierdo de la operación determina la 
    operación que Windows PowerShell realiza.Windows PowerShell 
    intenta convertir todos los objetos de la operación al tipo de 
    .NET Framework del primer objeto. Si consigue convertir los objetos 
    correctamente, realiza la operación adecuada para el tipo de .NET 
    Framework del primer objeto. Si no convierte cualquiera de los objetos, 
    se produce un error en la operación. 

    En el ejemplo siguiente se demuestra el uso de los operadores de 
    adición y multiplicación en operaciones que incluyen tipos de objetos 
    diferentes:


        C:\PS> "archivo" + 16
        archivo16

        C:\PS> $array = 1,2,3
        C:\PS> $array + 16
        1
        2
        3
        16

	C:\PS> $array + "archivo"
        1
        2
        3
        archivo

        C:\PS> "archivo" * 3
        archivoarchivoarchivo
 
    Dado que el objeto del extremo izquierdo determina qué método se 
    usa para evaluar las instrucciones, en Windows PowerShell las 
    operaciones de suma y multiplicación no son estrictamente 
    conmutativas. Por ejemplo, (a + b) no siempre es igual a (b + a), 
    y (a * b) no siempre es igual a (b * a).

    En el siguiente ejemplo se muestra este principio:

        C:\PS> "archivo" + 2
        archivo2

        C:\PS> 2 + "archivo"
        No se puede convertir el valor "archivo" a tipo 
        "System.Int32". Error: "La cadena de entrada no tiene el 
        formato correcto."
        En línea:1 carácter:4
        + 2 + <<<< "archivo"

        C:\PS> "archivo" * 3
        archivoarchivoarchivo

        C:\PS> 3 * "archivo"
        No se puede convertir el valor "archivo" a tipo 
        "System.Int32". Error: "La cadena de entrada no tiene el 
        formato correcto."
        En línea:1 carácter:4
        + 3 * <<<< "archivo"
 

    Las tablas hash son un caso ligeramente diferente. Las tablas 
    hash se pueden sumar. También es posible sumar una tabla hash a 
    una matriz. Sin embargo, no se puede sumar ningún otro tipo a una 
    tabla hash. 

    En los ejemplos siguientes se muestra cómo sumar tablas hash 
    entre sí y cómo sumarlas a otros objetos:


        C:\PS> $hash1 = @{a=1; b=2; c=3}
        C:\PS> $hash2 = @{c1="Server01"; c2="Server02"}
        C:\PS> $hash1 + $hash2

        Nombre                         Valor
        ----                           -----
        c2                             Server02 1
        a                              1
        b                              2
        c1                             Server01 3
        c                              3


        C:\PS> $hash1 + 2
        Solo se puede agregar una tabla de hash a otra tabla de hash.
        En línea:1 carácter:9
        + $hash1 + <<<< 2


        C:\PS> 2 + $hash1
        No se puede convertir "System.Collections.Hashtable" a "System.Int32".
        En línea:1 carácter:4
        + 2 + <<<< $hash1
 

    En los ejemplos siguientes se muestra que se puede sumar una 
    tabla hash a una matriz. La tabla hash completa se suma a la 
    matriz como un único objeto.


        C:\PS> $array = 1,2,3
        C:\PS> $array + $hash1
        1
        2
        3

        Nombre                         Valor
        ----                           -----
        a                              1
        b                              2
        c                              3


        C:\PS> $sum = $array + $hash1
        C:\PS> $sum.count
        4

        C:\PS> $sum[3]
        Nombre                         Valor
        ----                           -----
        a                              1
        b                              2
        c                              3


        PS C:\ps-test> $sum + $hash2
        1
        2
        3

        Nombre                         Valor
        ----                           -----
        a                              1
        b                              2
        c                              3
        c2                             Server02 


    En el ejemplo siguiente se muestra que no se pueden sumar tablas 
    hash que contienen la misma clave:

        C:\PS> $hash1 = @{a=1; b=2; c=3}
        C:\PS> $hash2 = @{c="red"}
        C:\PS> $hash1 + $hash2
        Argumento incorrecto para el operador '+': Ya se ha agregado 
        el elemento. Clave en el diccionario: 'c' Clave agregada: 'c.'
        En línea:1 carácter:9
        + $hash1 + <<<< $hash2
 


    Aunque los operadores de adición son muy útiles, deben utilizarse los 
    operadores de asignación para agregar elementos a las tablas hash y a 
    las matrices. Para obtener más información, vea about_assignment_opera
    tors. En los ejemplos siguientes se utiliza el operador de asignación 
    += para agregar elementos a una matriz:

        C:\PS> $array
        1
        2
        3

        C:\PS> $array + "archivo"
        1
        2
        3
        archivo

        C:\PS> $array
        1
        2
        3

        C:\PS> $array += "archivo"
        C:\PS> $array
        1
        2
        3
        archivo

        C:\PS> $hash1

        Nombre                           Valor
        ----                           -----
        a                              1
        b                              2
        c                              3

        C:\PS> $hash1 += @{e = 5}
        C:\PS> $hash1

        Nombre                           Valor
        ----                           -----
        a                              1
        b                              2
        e                              5
        c                              3
 

    Windows PowerShell selecciona automáticamente el tipo numérico de .NET 
    Framework que mejor expresa el resultado sin perder precisión. Por ejemplo:

        C:\PS> 2 + 3.1
        5.1
        C:\PS> (2). GetType().FullName
        System.Int32
        C:\PS> (2 + 3.1).GetType().FullName
        System.Double

    Si el resultado de una operación es demasiado grande para el 
    tipo, el tipo del resultado se amplía para alojar el resultado, 
    como en el ejemplo siguiente: 

        C:\PS> (512MB).GetType().FullName
        System.Int32
        C:\PS> (512MB * 512MB).GetType().FullName
        System.Double

    El tipo del resultado no será necesariamente igual que el de uno 
    de los operandos. En el ejemplo siguiente, el valor negativo no 
    se puede convertir a un entero sin signo y el entero sin signo es 
    demasiado grande para convertirse a Int32:

        C:\PS> ([int32]::minvalue + [uint32]::maxvalue).gettype().fullname
        System.Int64

    En este ejemplo, Int64 admite ambos tipos.

    El tipo System.Decimal es una excepción. Si cualquier operando 
    tiene el tipo Decimal, el resultado será del tipo Decimal. Si el 
    resultado es demasiado grande para el tipo Decimal, no se 
    convertirá a Double, sino que se producirá un error.
    
        C:\PS> [Decimal]::maxvalue
        79228162514264337593543950335
        C:\PS> [Decimal]::maxvalue + 1
        Valor demasiado grande o demasiado pequeño para Decimal.
        En línea:1 carácter:22
        + [Decimal]::maxvalue + <<<< 1


    OPERADORES ARITMÉTICOS Y VARIABLES
    Los operadores aritméticos también se pueden utilizar con 
    variables. Los operadores se aplican a los valores de las 
    variables. En los ejemplos siguientes se muestra cómo se usan los 
    operadores aritméticos con variables:

        C:\PS> $intA = 6 
        C:\PS> $intB = 4 
        C:\PS> $intA + $intB 

        10 


        C:\PS> $a = "Windows " 
        C:\PS> $b = "PowerShell " 
        C:\PS> $c = 2 
	C:\PS> $a + $b + $c

        Windows PowerShell 2 


    OPERADORES ARITMÉTICOS Y COMANDOS
    Normalmente, los operadores aritméticos se utilizan en 
    expresiones con números, cadenas y matrices. Sin embargo, también 
    se pueden utilizar con los objetos que los comandos devuelven y 
    con las propiedades de esos objetos.

    En los ejemplos siguientes se muestra cómo utilizar los 
    operadores aritméticos en expresiones con comandos de Windows 
    PowerShell:


	C:\PS> get-date
	Miércoles, 2 de enero de 2008 1:28:42 p.m.


	C:\PS> $day = new-timespan -day 1
	C:\PS> get-date + $day
	Jueves, 3 de enero de 2008 1:28:42 p.m.


	C:\PS> get-process | where {($_.ws * 2) -gt 50mb}
	Handles  NPM(K)   PM(K)   WS(K)  VM(M)  CPU(s)    Id ProcessName 
        -------  ------   -----   -----  -----  ------    -- -----------
        1896     39       50968   30620  264  1,572.55  1104 explorer 
        12802    78      188468   81032  753  3,676.39  5676 OUTLOOK 
        600       9       36168   26956  143     12.20  988 powershell 
        561      14        6592   28144  110  1,010.09  496 services 
        3476     80       34664   26092  234  ...45.69  876 svchost 
        967      30       58804   59496  416    930.97  2508 WINWORD 


EJEMPLOS
    En los ejemplos siguientes se muestra cómo utilizar los 
    operadores aritméticos en Windows PowerShell:

	C:\PS> 1 + 1
	2 

	C:\PS> 1 - 1 
	0 

	C:\PS> -(6 + 3) 
	-9 

	C:\PS> 6 * 2 
	12 

	C:\PS> 7 / 2 
	3,5 

	C:\PS> 7 % 2 
	1 

	C:\PS> w * 3 
	www 

	C:\PS> 3 * "w" 
	No se puede convertir el valor "w" a tipo "System.Int32". Error: 
        "La cadena de entrada no tiene el formato correcto." 
	En línea:1 carácter:4 
	+ 3 * <<<< "w" 

	PS C:\ps-test> "Windows" + " " + "PowerShell" 
	Windows PowerShell 

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

	C:\PS> $a[0] 
	W 

	C:\PS> $a = "archivosPrueba.txt" 
	C:\PS> $b = "C:\Logs\" 
	C:\PS> $b + $a 
	C:\Logs\archivosPrueba.txt 

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

	C:\PS> $servers = @{0 = "LocalHost"; 1 = "Server01"; 2 = "Server02"} 
	C:\PS> $servers + @{3 = "Server03"} 
	Nombre Valor 
	----   ----- 
	3 Server03 
	2 Server02 
	1 Server01 
	0 LocalHost 

	C:\PS> $servers 
	Nombre Valor 
	----   ----- 
	2 Server02 
	1 Server01 
	0 LocalHost 

	C:\PS> $servers += @{3 = "Server03"} #Usar operador de asignación 
	C:\PS> $servers 
	Nombre Valor 
	----   ----- 
	3 Server03 
	2 Server02 
	1 Server01 
	0 LocalHost 


VEA TAMBIÉN
    about_arrays
    about_assignment_operators
    about_comparison_operators
    about_hash_tables
    about_operators
    about_variables
    Get-Date
    New-TimeSpan




Tabla de contenido