Acerca de los operadoresAbout Operators

Descripción breveShort description

Describe los operadores que son compatibles con PowerShell.Describes the operators that are supported by PowerShell.

Descripción largaLong description

Un operador es un elemento de lenguaje que se puede usar en un comando o una expresión.An operator is a language element that you can use in a command or expression. PowerShell admite varios tipos de operadores para ayudarle a manipular los valores.PowerShell supports several types of operators to help you manipulate values.

Operadores aritméticosArithmetic Operators

Use operadores aritméticos ( + , - , * , / , % ) para calcular valores en un comando o una expresión.Use arithmetic operators (+, -, *, /, %) to calculate values in a command or expression. Con estos operadores, puede sumar, restar, multiplicar o dividir valores, y calcular el resto (módulo) de una operación de división.With these operators, you can add, subtract, multiply, or divide values, and calculate the remainder (modulus) of a division operation.

El operador de suma concatena los elementos.The addition operator concatenates elements. El operador de multiplicación devuelve el número especificado de copias de cada elemento.The multiplication operator returns the specified number of copies of each element. Puede usar operadores aritméticos en cualquier tipo .net que los implemente, como: Int ,, String DateTime , Hashtable y matrices.You can use arithmetic operators on any .NET type that implements them, such as: Int, String, DateTime, Hashtable, and Arrays.

Los operadores bit a bit ( -band , -bor , -bxor , -bnot , -shl , -shr ) manipulan los patrones de bits de los valores.Bitwise operators (-band, -bor, -bxor, -bnot, -shl, -shr) manipulate the bit patterns in values.

Para obtener más información, vea about_Arithmetic_Operators.For more information, see about_Arithmetic_Operators.

Operadores de asignaciónAssignment Operators

Use operadores de asignación ( = , += , -= , *= , /= , %= ) para asignar, cambiar o anexar valores a variables.Use assignment operators (=, +=, -=, *=, /=, %=) to assign, change, or append values to variables. Puede combinar operadores aritméticos con asignación para asignar el resultado de la operación aritmética a una variable.You can combine arithmetic operators with assignment to assign the result of the arithmetic operation to a variable.

Para obtener más información, vea about_Assignment_Operators.For more information, see about_Assignment_Operators.

Operadores de comparaciónComparison Operators

Utilice operadores de comparación ( -eq , -ne , -gt , -lt , -le , -ge ) para comparar valores y condiciones de prueba.Use comparison operators (-eq, -ne, -gt, -lt, -le, -ge) to compare values and test conditions. Por ejemplo, puede comparar dos valores de cadena para determinar si son iguales.For example, you can compare two string values to determine whether they are equal.

Los operadores de comparación también incluyen operadores que buscan o reemplazan patrones en el texto.The comparison operators also include operators that find or replace patterns in text. Los -match operadores (, -notmatch , -replace ) usan expresiones regulares y ( -like , -notlike ) usan caracteres comodín * .The (-match, -notmatch, -replace) operators use regular expressions, and (-like, -notlike) use wildcards *.

Los operadores de comparación de contención determinan si un valor de prueba aparece en un conjunto de referencia ( -in , -notin , -contains , -notcontains ).Containment comparison operators determine whether a test value appears in a reference set (-in, -notin, -contains, -notcontains).

Los operadores de comparación -is de tipos (, -isnot ) determinan si un objeto es de un tipo determinado.Type comparison operators (-is, -isnot) determine whether an object is of a given type.

Para obtener más información, vea about_Comparison_Operators.For more information, see about_Comparison_Operators.

Operadores lógicosLogical Operators

Utilice los operadores lógicos ( -and , -or , -xor , -not , ! ) para conectar las instrucciones condicionales a una única condicional compleja.Use logical operators (-and, -or, -xor, -not, !) to connect conditional statements into a single complex conditional. Por ejemplo, puede usar un operador lógico -and para crear un filtro de objetos con dos condiciones diferentes.For example, you can use a logical -and operator to create an object filter with two different conditions.

Para obtener más información, vea about_Logical_Operators.For more information, see about_Logical_Operators.

Operadores de redireccionamientoRedirection Operators

Use los operadores de redirección ( > , >> , 2> , 2>> y 2>&1 ) para enviar la salida de un comando o una expresión a un archivo de texto.Use redirection operators (>, >>, 2>, 2>>, and 2>&1) to send the output of a command or expression to a text file. Los operadores de redireccionamiento funcionan como el Out-File cmdlet (sin parámetros), pero también permiten redirigir la salida de errores a los archivos especificados.The redirection operators work like the Out-File cmdlet (without parameters) but they also let you redirect error output to specified files. También puede usar el Tee-Object cmdlet para redirigir los resultados.You can also use the Tee-Object cmdlet to redirect output.

Para obtener más información, vea about_RedirectionFor more information, see about_Redirection

Operadores de división y combinaciónSplit and Join Operators

Los -split -join operadores y dividen y combinan subcadenas.The -split and -join operators divide and combine substrings. El -split operador divide una cadena en subcadenas.The -split operator splits a string into substrings. El -join operador concatena varias cadenas en una sola cadena.The -join operator concatenates multiple strings into a single string.

Para obtener más información, vea about_Split y about_Join.For more information, see about_Split and about_Join.

Operadores de tipoType Operators

Utilice los operadores de tipo ( -is , -isnot , -as ) para buscar o cambiar el tipo de .NET Framework de un objeto.Use the type operators (-is, -isnot, -as) to find or change the .NET Framework type of an object.

Para obtener más información, vea about_Type_Operators.For more information, see about_Type_Operators.

Operadores unariosUnary Operators

Use operadores unarios para aumentar o disminuir las variables u propiedades de objeto y para establecer enteros en números positivos o negativos.Use unary operators to increment or decrement variables or object properties and to set integers to positive or negative numbers. Por ejemplo, para incrementar la variable $a de 9 a 10 , escriba $a++ .For example, to increment the variable $a from 9 to 10, you type $a++.

Operadores especialesSpecial Operators

Los operadores especiales tienen casos de uso específicos que no caben en ningún otro grupo de operadores.Special operators have specific use-cases that do not fit into any other operator group. Por ejemplo, los operadores especiales permiten ejecutar comandos, cambiar el tipo de datos de un valor o recuperar elementos de una matriz.For example, special operators allow you to run commands, change a value's data type, or retrieve elements from an array.

Operador de agrupación ( )Grouping operator ( )

Como en otros lenguajes, (...) sirve para invalidar la prioridad de los operadores en expresiones.As in other languages, (...) serves to override operator precedence in expressions. Por ejemplo: (1 + 2) / 3For example: (1 + 2) / 3

Sin embargo, en PowerShell hay comportamientos adicionales.However, in PowerShell, there are additional behaviors.

  • (...) permite permitir que los resultados de un comando participen en una expresión.(...) allows you to let output from a command participate in an expression. Por ejemplo:For example:

    PS> (Get-Item *.txt).Count -gt 10
    True
    
  • Cuando se usa como primer segmento de una canalización, si se ajusta un comando o una expresión entre paréntesis, se produce una enumeración invariable del resultado de la expresión.When used as the first segment of a pipeline, wrapping a command or expression in parentheses invariably causes enumeration of the expression result. Si los paréntesis encapsulan un comando, se ejecutan hasta completarse con todos los resultados recopilados en memoria antes de que los resultados se envíen a través de la canalización.If the parentheses wrap a command, it is run to completion with all output collected in memory before the results are sent through the pipeline.

Subexpresión (operador) $( )Subexpression operator $( )

Devuelve el resultado de una o más instrucciones.Returns the result of one or more statements. Para un único resultado, devuelve un valor escalar.For a single result, returns a scalar. En el caso de varios resultados, devuelve una matriz.For multiple results, returns an array. Utilícelo cuando desee usar una expresión dentro de otra expresión.Use this when you want to use an expression within another expression. Por ejemplo, para insertar los resultados del comando en una expresión de cadena.For example, to embed the results of command in a string expression.

PS> "Today is $(Get-Date)"
Today is 12/02/2019 13:15:20

PS> "Folder list: $((dir c:\ -dir).Name -join ', ')"
Folder list: Program Files, Program Files (x86), Users, Windows

Operador de subexpresión de matriz @( )Array subexpression operator @( )

Devuelve el resultado de una o varias instrucciones como una matriz.Returns the result of one or more statements as an array. Si solo hay un elemento, la matriz tiene un solo miembro.If there is only one item, the array has only one member.

@(Get-CimInstance win32_logicalDisk)

Sintaxis de literales de tabla hash @{}Hash table literal syntax @{}

De forma similar a la subexpresión de matriz, esta sintaxis se utiliza para declarar una tabla hash.Similar to the array subexpression, this syntax is used to declare a hash table. Para obtener más información, vea about_Hash_Tables.For more information, see about_Hash_Tables.

Call (operador) &Call operator &

Ejecuta un comando, un script o un bloque de script.Runs a command, script, or script block. El operador de llamada, también conocido como "operador de invocación", le permite ejecutar comandos que se almacenan en variables y se representan mediante cadenas o bloques de scripts.The call operator, also known as the "invocation operator", lets you run commands that are stored in variables and represented by strings or script blocks. El operador de llamada se ejecuta en un ámbito secundario.The call operator executes in a child scope. Para obtener más información sobre los ámbitos, vea about_Scopes.For more about scopes, see about_Scopes.

En este ejemplo se almacena un comando en una cadena y se ejecuta mediante el operador de llamada.This example stores a command in a string and executes it using the call operator.

PS> $c = "get-executionpolicy"
PS> $c
get-executionpolicy
PS> & $c
AllSigned

El operador de llamada no analiza las cadenas.The call operator does not parse strings. Esto significa que no se pueden utilizar parámetros de comando dentro de una cadena cuando se usa el operador de llamada.This means that you cannot use command parameters within a string when you use the call operator.

PS> $c = "Get-Service -Name Spooler"
PS> $c
Get-Service -Name Spooler
PS> & $c
& : The term 'Get-Service -Name Spooler' is not recognized as the name of a
cmdlet, function, script file, or operable program. Check the spelling of
the name, or if a path was included, verify that the path is correct and
try again.

El cmdlet Invoke-Expression puede ejecutar código que produce errores de análisis al utilizar el operador de llamada.The Invoke-Expression cmdlet can execute code that causes parsing errors when using the call operator.

PS> & "1+1"
& : The term '1+1' is not recognized as the name of a cmdlet, function, script
file, or operable program. Check the spelling of the name, or if a path was
included, verify that the path is correct and try again.
At line:1 char:2
+ & "1+1"
+  ~~~~~
    + CategoryInfo          : ObjectNotFound: (1+1:String) [], CommandNotFoundException
    + FullyQualifiedErrorId : CommandNotFoundException
PS> Invoke-Expression "1+1"
2

Puede usar el operador de llamada para ejecutar scripts mediante sus nombres de archivo.You can use the call operator to execute scripts using their filenames. En el ejemplo siguiente se muestra un nombre de archivo de script que contiene espacios.The example below shows a script filename that contains spaces. Al intentar ejecutar el script, en su lugar, PowerShell muestra el contenido de la cadena entrecomillada que contiene el nombre de archivo.When you try to execute the script, PowerShell instead displays the contents of the quoted string containing the filename. El operador Call permite ejecutar el contenido de la cadena que contiene el nombre de archivo.The call operator allows you to execute the contents of the string containing the filename.

PS C:\Scripts> Get-ChildItem

    Directory: C:\Scripts


Mode                LastWriteTime         Length Name
----                -------------         ------ ----
-a----        8/28/2018   1:36 PM             58 script name with spaces.ps1

PS C:\Scripts> ".\script name with spaces.ps1"
.\script name with spaces.ps1
PS C:\Scripts> & ".\script name with spaces.ps1"
Hello World!

Para obtener más información sobre los bloques de scripts, vea about_Script_Blocks.For more about script blocks, see about_Script_Blocks.

Background (operador) &Background operator &

Ejecuta la canalización antes de que se ejecute en segundo plano, en un trabajo de PowerShell.Runs the pipeline before it in the background, in a PowerShell job. Este operador actúa de forma similar al operador de control de UNIX y comercial ( & ), que ejecuta el comando antes de que se ejecute de forma asincrónica en el subshell como un trabajo.This operator acts similarly to the UNIX control operator ampersand (&), which runs the command before it asynchronously in subshell as a job.

Este operador es funcionalmente equivalente a Start-Job .This operator is functionally equivalent to Start-Job. De forma predeterminada, el operador de fondo inicia los trabajos en el directorio de trabajo actual del autor de la llamada que inició las tareas paralelas.By default, the background operator starts the jobs in the current working directory of the caller that started the parallel tasks. En el ejemplo siguiente se muestra el uso básico del operador de trabajo en segundo plano.The following example demonstrates basic usage of the background job operator.

Get-Process -Name pwsh &

Ese comando es funcionalmente equivalente al siguiente uso de Start-Job :That command is functionally equivalent to the following usage of Start-Job:

Start-Job -ScriptBlock {Get-Process -Name pwsh}

Al igual Start-Job que, el & operador Background devuelve un Job objeto.Just like Start-Job, the & background operator returns a Job object. Este objeto se puede utilizar con Receive-Job y Remove-Job , igual que si se hubiera usado Start-Job para iniciar el trabajo.This object can be used with Receive-Job and Remove-Job, just as if you had used Start-Job to start the job.

$job = Get-Process -Name pwsh &
Receive-Job $job -Wait

 NPM(K)    PM(M)      WS(M)     CPU(s)      Id  SI ProcessName
 ------    -----      -----     ------      --  -- -----------
      0     0.00     221.16      25.90    6988 988 pwsh
      0     0.00     140.12      29.87   14845 845 pwsh
      0     0.00      85.51       0.91   19639 988 pwsh

Remove-Job $job

El & operador en segundo plano también es un terminador de instrucciones, al igual que el operador de control de UNIX y comercial ( & ).The & background operator is also a statement terminator, just like the UNIX control operator ampersand (&). Esto le permite invocar comandos adicionales después del & operador background.This allows you to invoke additional commands after the & background operator. En el ejemplo siguiente se muestra la invocación de comandos adicionales después del & operador background.The following example demonstrates the invocation of additional commands after the & background operator.

$job = Get-Process -Name pwsh & Receive-Job $job -Wait

 NPM(K)    PM(M)      WS(M)     CPU(s)      Id  SI ProcessName
 ------    -----      -----     ------      --  -- -----------
      0     0.00     221.16      25.90    6988 988 pwsh
      0     0.00     140.12      29.87   14845 845 pwsh
      0     0.00      85.51       0.91   19639 988 pwsh

Esto es equivalente al script siguiente:This is equivalent to the following script:

$job = Start-Job -ScriptBlock {Get-Process -Name pwsh}
Receive-Job $job -Wait

Si desea ejecutar varios comandos, cada uno en su propio proceso en segundo plano, pero todo en una sola línea, simplemente coloque & entre y después de cada uno de los comandos.If you want to run multiple commands, each in their own background process but all on one line, simply place & between and after each of the commands.

Get-Process -Name pwsh & Get-Service -Name BITS & Get-CimInstance -ClassName Win32_ComputerSystem &

Para obtener más información sobre los trabajos de PowerShell, consulte about_Jobs.For more information on PowerShell jobs, see about_Jobs.

Operador de conversión [ ]Cast operator [ ]

Convierte o limita objetos al tipo especificado.Converts or limits objects to the specified type. Si los objetos no se pueden convertir, PowerShell genera un error.If the objects cannot be converted, PowerShell generates an error.

[DateTime]"2/20/88" - [DateTime]"1/20/88"
[Int] (7/2)
[String] 1 + 0
[Int] '1' + 0

También se puede realizar una conversión cuando se asigna una variable a mediante la notación de conversión.A cast can also be performed when a variable is assigned to using cast notation.

Coma (operador) ,Comma operator ,

Como operador binario, la coma crea una matriz o anexa a la matriz que se va a crear.As a binary operator, the comma creates an array or appends to the array being created. En el modo de expresión, como un operador unario, la coma crea una matriz con un solo miembro.In expression mode, as a unary operator, the comma creates an array with just one member. Coloque la coma delante del miembro.Place the comma before the member.

$myArray = 1,2,3
$SingleArray = ,1
Write-Output (,1)

Puesto que Write-Object espera un argumento, debe colocar la expresión entre paréntesis.Since Write-Object expects an argument, you must put the expression in parentheses.

Operador de origen de puntos .Dot sourcing operator .

Ejecuta un script en el ámbito actual para que las funciones, los alias y las variables que crea el script se agreguen al ámbito actual, invalidando los existentes.Runs a script in the current scope so that any functions, aliases, and variables that the script creates are added to the current scope, overriding existing ones. Los parámetros declarados por el script se convierten en variables.Parameters declared by the script become variables. Los parámetros para los que no se ha proporcionado ningún valor se convierten en variables sin ningún valor.Parameters for which no value has been given become variables with no value. Sin embargo, se conserva la variable automática $args .However, the automatic variable $args is preserved.

. c:\scripts\sample.ps1 1 2 -Also:3

Nota

El operador de origen de puntos va seguido de un espacio.The dot sourcing operator is followed by a space. Utilice el espacio para distinguir el punto del símbolo de punto ( . ) que representa el directorio actual.Use the space to distinguish the dot from the dot (.) symbol that represents the current directory.

En el siguiente ejemplo, el script de Sample.ps1 en el directorio actual se ejecuta en el ámbito actual.In the following example, the Sample.ps1 script in the current directory is run in the current scope.

. .\sample.ps1

Format (operador) -fFormat operator -f

Da formato a las cadenas mediante el método de formato de los objetos de cadena.Formats strings by using the format method of string objects. Escriba la cadena de formato en el lado izquierdo del operador y los objetos a los que se va a dar formato en el lado derecho del operador.Enter the format string on the left side of the operator and the objects to be formatted on the right side of the operator.

"{0} {1,-10} {2:N}" -f 1,"hello",[math]::pi
1 hello      3.14

Si tiene que mantener las llaves ( {} ) en la cadena con formato, puede usar secuencias de escape con las llaves.If you need to keep the curly braces ({}) in the formatted string, you can escape them by doubling the curly braces.

"{0} vs. {{0}}" -f 'foo'
foo vs. {0}

Para obtener más información, vea el método String. Format y el formato compuesto.For more information, see the String.Format method and Composite Formatting.

Index (operador) [ ]Index operator [ ]

Selecciona objetos de colecciones indizadas, como matrices y tablas hash.Selects objects from indexed collections, such as arrays and hash tables. Los índices de matriz se basan en cero, por lo que el primer objeto se indiza como [0] .Array indexes are zero-based, so the first object is indexed as [0]. En el caso de las matrices (solo), también puede utilizar índices negativos para obtener los últimos valores.For arrays (only), you can also use negative indexes to get the last values. Las tablas hash se indizan por valor de clave.Hash tables are indexed by key value.

PS> $a = 1, 2, 3
PS> $a[0]
1
PS> $a[-1]
3
(Get-HotFix | Sort-Object installedOn)[-1]
$h = @{key="value"; name="PowerShell"; version="2.0"}
$h["name"]
PowerShell
$x = [xml]"<doc><intro>Once upon a time...</intro></doc>"
$x["doc"]
intro
-----
Once upon a time...

Operador de canalización |Pipeline operator |

Envía ("canaliza") el resultado del comando que lo precede al comando que le sigue.Sends ("pipes") the output of the command that precedes it to the command that follows it. Cuando la salida incluye más de un objeto (una "colección"), el operador de canalización envía los objetos de uno en uno.When the output includes more than one object (a "collection"), the pipeline operator sends the objects one at a time.

Get-Process | Get-Member
Get-Service | Where-Object {$_.StartType -eq 'Automatic'}

Operadores de cadena && de canalización y ||Pipeline chain operators && and ||

Ejecute la canalización del lado derecho de forma condicional en función del éxito de la canalización de la izquierda.Conditionally execute the right-hand side pipeline based on the success of the left-hand side pipeline.

# If Get-Process successfully finds a process called notepad,
# Stop-Process -Name notepad is called
Get-Process notepad && Stop-Process -Name notepad
# If npm install fails, the node_modules directory is removed
npm install || Remove-Item -Recurse ./node_modules

Para obtener más información, vea About_Pipeline_Chain_Operators.For more information, see About_Pipeline_Chain_Operators.

Range (operador) ..Range operator ..

Representa los enteros secuenciales en una matriz de enteros, dados un límite superior y otro inferior.Represents the sequential integers in an integer array, given an upper, and lower boundary.

1..10
foreach ($a in 1..$max) {Write-Host $a}

También puede crear intervalos en orden inverso.You can also create ranges in reverse order.

10..1
5..-5 | ForEach-Object {Write-Output $_}

A partir de PowerShell 6, el operador de intervalo funciona con caracteres , así como enteros.Beginning in PowerShell 6, the range operator works with Characters as well as Integers.

Para crear un intervalo de caracteres, escriba los caracteres de límite entre comillas.To create a range of characters, enclose the boundary characters in quotes.

PS> 'a'..'f'
a
b
c
d
e
f
PS> 'F'..'A'
F
E
D
C
B
A

Operador de acceso a miembros .Member access operator .

Obtiene acceso a las propiedades y métodos de un objeto.Accesses the properties and methods of an object. El nombre del miembro puede ser una expresión.The member name may be an expression.

$myProcess.peakWorkingSet
(Get-Process PowerShell).kill()
'OS', 'Platform' | Foreach-Object { $PSVersionTable. $_ }

Operador de miembro estático ::Static member operator ::

Llama a las propiedades y los métodos estáticos de una clase .NET Framework.Calls the static properties and methods of a .NET Framework class. Para buscar las propiedades y los métodos estáticos de un objeto, use el parámetro static del Get-Member cmdlet.To find the static properties and methods of an object, use the Static parameter of the Get-Member cmdlet. El nombre del miembro puede ser una expresión.The member name may be an expression.

[datetime]::Now
'MinValue', 'MaxValue' | Foreach-Object { [int]:: $_ }

Ternario (operador) ? <if-true> : <if-false>Ternary operator ? <if-true> : <if-false>

Puede usar el operador ternario como sustituto de la if-else instrucción en casos condicionales simples.You can use the ternary operator as a replacement for the if-else statement in simple conditional cases.

Para obtener más información, vea about_If.For more information, see about_If.

Operador de uso combinado de null ??Null-coalescing operator ??

El operador de fusión de NULL ?? devuelve el valor de su operando de la izquierda si no es NULL.The null-coalescing operator ?? returns the value of its left-hand operand if it isn't null. De lo contrario, evalúa el operando de la derecha y devuelve su resultado.Otherwise, it evaluates the right-hand operand and returns its result. El operador ?? no evalúa su operando de la derecha si el operando de la izquierda se evalúa como no NULL.The ?? operator doesn't evaluate its right-hand operand if the left-hand operand evaluates to non-null.

$x = $null
$x ?? 100
100

En el ejemplo siguiente, no se evaluará el operando de la derecha.In the following example, the right-hand operand won't be evaluated.

[string] $todaysDate = '1/10/2020'
$todaysDate ?? (Get-Date).ToShortDateString()
1/10/2020

Operador de asignación de uso combinado de null ??=Null-coalescing assignment operator ??=

El operador de asignación de uso combinado de NULL ??= asigna el valor del operando derecho a su operando izquierdo solo si el operando izquierdo se evalúa como null.The null-coalescing assignment operator ??= assigns the value of its right-hand operand to its left-hand operand only if the left-hand operand evaluates to null. El operador ??= no evalúa su operando de la derecha si el operando de la izquierda se evalúa como no NULL.The ??= operator doesn't evaluate its right-hand operand if the left-hand operand evaluates to non-null.

$x = $null
$x ??= 100
$x
100

En el ejemplo siguiente, no se evaluará el operando de la derecha.In the following example, the right-hand operand won't be evaluated.

[string] $todaysDate = '1/10/2020'
$todaysDate ??= (Get-Date).ToShortDateString()
1/10/2020

Operadores condicionales null ?. y ?[]Null-conditional operators ?. and ?[]

Nota

Esta característica se ha pasado de experimental a estándar en PowerShell 7,1.This feature was moved from experimental to mainstream in PowerShell 7.1.

Un operador condicional null aplica un acceso a miembros, ?. , o el acceso a los elementos, ?[] , a su operando solo si ese operando se evalúa como no NULL; de lo contrario, devuelve NULL.A null-conditional operator applies a member access, ?., or element access, ?[], operation to its operand only if that operand evaluates to non-null; otherwise, it returns null.

Puesto que PowerShell permite que ? forme parte del nombre de la variable, se requiere la especificación formal del nombre de la variable para utilizar estos operadores.Since PowerShell allows ? to be part of the variable name, formal specification of the variable name is required for using these operators. Por lo tanto, es necesario usar {} en torno a los nombres de variable como ${a} o cuando ? forma parte del nombre de la variable ${a?}.So it is required to use {} around the variable names like ${a} or when ? is part of the variable name ${a?}.

En el ejemplo siguiente, se devuelve el valor de PropName .In the following example, the value of PropName is returned.

$a = @{ PropName = 100 }
${a}?.PropName
100

En el ejemplo siguiente se devolverá null, sin intentar tener acceso al nombre de miembro NombreDePropiedad.The following example will return null, without trying to access the member name PropName.

$a = $null
${a}?.PropName

Del mismo modo, se devolverá el valor del elemento.Similarly, the value of the element will be returned.

$a = 1..10
${a}?[0]
1

Y cuando el operando es null, no se tiene acceso al elemento y se devuelve NULL.And when the operand is null, the element isn't accessed and null is returned.

$a = $null
${a}?[0]

Nota

Puesto que PowerShell permite que ? forme parte del nombre de la variable, se requiere la especificación formal del nombre de la variable para utilizar estos operadores.Since PowerShell allows ? to be part of the variable name, formal specification of the variable name is required for using these operators. Por lo tanto, es necesario usar {} en torno a los nombres de variable como ${a} o cuando ? forma parte del nombre de la variable ${a?}.So it is required to use {} around the variable names like ${a} or when ? is part of the variable name ${a?}.

La sintaxis de nombre de variable de ${<name>} no se debe confundir con el $() operador subexpresión.The variable name syntax of ${<name>} should not be confused with the $() subexpression operator. Para obtener más información, vea la sección nombre de variable de about_Variables.For more information, see Variable name section of about_Variables.

Consulta tambiénSee also

about_Arithmetic_Operatorsabout_Arithmetic_Operators

about_Assignment_Operatorsabout_Assignment_Operators

about_Comparison_Operatorsabout_Comparison_Operators

about_Logical_Operatorsabout_Logical_Operators

about_Operator_Precedenceabout_Operator_Precedence

about_Type_Operatorsabout_Type_Operators

about_Pipeline_Chain_Operatorsabout_Pipeline_Chain_Operators

about_Splitabout_Split

about_Joinabout_Join

about_Redirectionabout_Redirection