Compartir a través de

3. Conceptos básicos

Nota editorial

Importante

La especificación del lenguaje de Windows PowerShell 3.0 se publicó en diciembre de 2012 y se basa en Windows PowerShell 3.0. Esta especificación no refleja el estado actual de PowerShell. No hay ningún plan para actualizar esta documentación para reflejar el estado actual. Esta documentación se presenta aquí para obtener referencia histórica.

El documento de especificación está disponible como un documento de Microsoft Word del Centro de descarga de Microsoft en: https://www.microsoft.com/download/details.aspx?id=36389 Ese documento de Word se ha convertido para su presentación aquí en Microsoft Learn. Durante la conversión, se han realizado algunos cambios editoriales para dar cabida al formato de la plataforma Docs. Se han corregido algunos errores tipográficos y menores.

3.1 Proveedores y unidades

Un proveedor de permite el acceso a datos y componentes que, de lo contrario, no serían fácilmente accesibles en la línea de comandos. Los datos se presentan en un formato coherente que se parece a una unidad de disco del sistema de archivos.

Los datos que expone un proveedor aparecen en una unidad de y se accede a los datos a través de una ruta de acceso de igual que con una unidad de disco. Los cmdlets integrados para cada proveedor administran los datos en la unidad del proveedor.

PowerShell incluye el siguiente conjunto de proveedores integrados para acceder a los distintos tipos de almacenes de datos:

Provider Nombre de la unidad Descripción Ref.
Alias Alias: Alias de PowerShell sección 3.1.1
Medio ambiente Env: Variables de entorno §3.1.2
Sistema de archivos A:, B:, C:, ... Unidades de disco, directorios y archivos §3.1.3
Función Función: Funciones de PowerShell §3.1.4
Variable Variable: Variables de PowerShell §3.1.5

Windows PowerShell:

Provider Nombre de la unidad Descripción
Certificado Cert: Certificados x509 para firmas digitales
Registro HKLM: (HKEY_LOCAL_MACHINE), HKCU: (HKEY_CURRENT_USER) Registro de Windows
WSMan WSMan: información de configuración de WS-Management

Los cmdlets siguientes se encargan de los proveedores y unidades:

  • get-PSProvider: obtiene información sobre uno o varios proveedores.
  • Get-PSDrive: obtiene información sobre una o varias unidades.

El tipo de un objeto que representa un proveedor se describe en §4.5.1. El tipo de un objeto que representa una unidad se describe en la sección 4.5.2.

3.1.1 Alias

Un alias es un nombre alternativo para un comando. Un comando puede tener varios alias y el nombre original y todos sus alias se pueden usar indistintamente. Se puede reasignar un alias. Un alias es un elemento (§3.3).

Se puede asignar un alias a otro alias; sin embargo, el nuevo alias no es un alias del comando original.

El alias del proveedor es un espacio de nombres plano que contiene solo objetos que representan los alias. Las variables no tienen elementos secundarios.

PowerShell incluye un conjunto de alias integrados.

Los siguientes cmdlets gestionan los alias:

Cuando se crea un alias para un comando mediante New-Alias, los parámetros de ese comando no se pueden incluir en ese alias. Sin embargo, la asignación directa a una variable del espacio de nombres Alias: permite incluir parámetros.

Nota:

Sin embargo, es una cuestión sencilla crear una función que no contenga más que contener la invocación de ese comando con todos los parámetros deseados y asignar un alias a esa función.

El tipo de un objeto que representa un alias se describe en §4.5.4.

Los objetos de alias se almacenan en la unidad Alias: (sección 3.1).

3.1.2 Variables de entorno

El proveedor de entorno de PowerShell permite recuperar, agregar, cambiar, borrar y eliminar variables de entorno del sistema operativo.

El proveedor Environment es un espacio de nombres plano que contiene solo objetos que representan las variables de entorno. Las variables no tienen elementos secundarios.

El nombre de una variable de entorno no puede incluir el signo igual (=).

Los cambios en las variables de entorno solo afectan a la sesión actual.

Una variable de entorno es un elemento (§3.3).

El tipo de un objeto que representa una variable de entorno se describe en §4.5.6.

Los objetos de variables de entorno se almacenan en la unidad Env: (§3.1).

3.1.3 Sistema de archivos

El proveedor FileSystem de PowerShell permite crear, abrir, cambiar y eliminar directorios y archivos.

El proveedor FileSystem es un espacio de nombres jerárquico que contiene objetos que representan el sistema de archivos subyacente.

Los archivos se almacenan en unidades con nombres como A:, B:, C:, etc. (§3.1). Se accede a directorios y archivos mediante la notación de ruta de acceso (§3.4).

Un directorio o archivo es un elemento (§3.3).

3.1.4 Funciones

El proveedor de funciones de PowerShell permite recuperar, agregar, cambiar, borrar y eliminar funciones (§8.10) y filtros (§8.10.1).

La función de proveedor es un espacio de nombres plano que contiene solo la función y los objetos de filtro. Las funciones y los filtros no tienen elementos secundarios.

Los cambios en las funciones solo afectan a la sesión actual.

Una función es un elemento (§3.3).

El tipo de un objeto que representa una función se describe en §4.5.10. El tipo de un objeto que representa un filtro se describe en §4.5.11.

Los objetos de función se almacenan en el disco "Function": (§3.1).

3.1.5 Variables

Las variables se pueden definir y manipular directamente en el lenguaje de PowerShell.

La variable de proveedor es un espacio de nombres plano que contiene solo objetos que representan las variables. Las variables no tienen elementos secundarios.

Los siguientes cmdlets también tratan las variables:

Como una variable es un elemento (§3.3), la mayoría de los cmdlets relacionados con item pueden manipularla.

El tipo de un objeto que representa una variable se describe en §4.5.3.

Los objetos variables se almacenan en el disco Variable: (§3.1).

3.2 Ubicaciones de trabajo

La ubicación de trabajo actual es la ubicación predeterminada a la que se dirigen los comandos. Esta es la ubicación que se usa si no se proporciona una ruta de acceso explícita (§3.4) cuando se invoca un comando. Esta ubicación incluye la unidad actual.

Un host de PowerShell puede tener varias unidades, en cuyo caso, cada unidad tiene su propia ubicación actual.

Cuando se especifica un nombre de unidad sin un directorio, la ubicación actual de esa unidad está implícita.

La ubicación de trabajo actual se puede guardar en una pila y, a continuación, establecerla en una nueva ubicación. Más adelante, esa ubicación guardada se puede restaurar desde esa pila y convertirla en la ubicación de trabajo actual. Hay dos tipos de pilas de ubicación: la pila de ubicación de trabajo predeterminada, y cero o más pilas de ubicación de trabajo con nombre definidas por el usuario. Cuando se inicia una sesión, la pila de ubicación de trabajo predeterminada también es la pila de ubicación de trabajo actual. Pero cualquier pila de ubicación de trabajo con nombre se puede convertir en la pila de ubicación de trabajo actual.

Los cmdlets siguientes se encargan de las ubicaciones:

  • Set-Location: establece la ubicación de trabajo actual.
  • Get-Location: determina la ubicación de trabajo actual de las unidades especificadas o las ubicaciones de trabajo de las pilas especificadas.
  • Push-Location: guarda la ubicación de trabajo actual en la parte superior de una pila de ubicaciones especificada.
  • Pop-Location: restaura la ubicación de trabajo actual de la parte superior de una pila de ubicaciones especificada.

Los tipos de objeto que representan una ubicación de trabajo y una pila de ubicaciones de trabajo se describen en §4.5.5.

3.3 Elementos

Un elemento es un alias (sección 3.1.1), una variable (sección 3.1.5), una función (sección 3.1.4), una variable de entorno (sección 3.1.2), o un archivo o directorio en un sistema de archivos (sección 3.1.3).

Los cmdlets siguientes se encargan de los elementos:

  • new-item: crea un nuevo elemento
  • Set-Item: cambia el valor de uno o varios elementos
  • Get-Item: obtiene el elemento en la ubicación especificada.
  • Get-ChildItem: obtiene los elementos secundarios y los elementos en la ubicación especificada.
  • Copiar elemento: copia uno o varios elementos de una ubicación a otra
  • move-item: mueve uno o varios elementos de una ubicación a otra
  • rename-item: cambia el nombre de un elemento
  • Invoke-Item: realiza la acción predeterminada en uno o varios elementos.
  • Clear-Item: elimina el contenido de uno o varios elementos, pero no borra los elementos en sí (consulte
  • Remove-Item: Elimina los elementos especificados.

Los cmdlets siguientes tratan el contenido de los elementos:

El tipo de un objeto que representa un directorio se describe en §4.5.17. El tipo de un objeto que representa un archivo se describe en §4.5.18.

3.4 Nombres de ruta de acceso

Todos los elementos de un almacén de datos accesibles a través de un proveedor de PowerShell se pueden identificar de forma única por sus nombres de ruta de acceso. Un nombre de ruta de acceso es una combinación del nombre del elemento, el contenedor y los subcontenedores en los que se encuentra el elemento, y la unidad de PowerShell por medio de la cual se accede a los contenedores.

Los nombres de ruta de acceso se dividen en uno de dos tipos: completa y relativa. Un nombre de ruta de acceso completa consta de todos los elementos que componen una ruta de acceso. La sintaxis siguiente muestra los elementos de un nombre de ruta de acceso completo:

Sugerencia

La notación ~opt~ en las definiciones de sintaxis indica que la entidad léxica es opcional en la sintaxis.

path:
    provider~opt~   drive~opt~   containers~opt~   item

provider:
    module~opt~   provider   ::

module:
    module-name   \

drive:
    drive-name   :

containers:
    container   \
    containers container   \

nombre de módulo hace referencia al módulo primario.

proveedor hace referencia al proveedor de PowerShell a través del cual se accede al almacén de datos.

La unidad se refiere a la unidad de PowerShell que es compatible con un proveedor de PowerShell específico.

Un contenedor puede contener otros contenedores, los cuales pueden contener otros contenedores, y así sucesivamente, donde el contenedor final contiene un elemento . Los contenedores deben especificarse en el orden jerárquico en el que existen en el almacén de datos.

Este es un ejemplo de un nombre de ruta de acceso:

E:\Accounting\InvoiceSystem\Production\MasterAccount\MasterFile.dat

Si el elemento final de una ruta de acceso contiene otros elementos, es un elemento contenedor; de lo contrario, es un elemento hoja.

En algunos casos, no se necesita un nombre de ruta de acceso completa; basta con proporcionar un nombre de ruta de acceso relativa. Un nombre de ruta de acceso relativa se basa en la ubicación de trabajo actual. PowerShell permite identificar un elemento en función de su ubicación en relación con la ubicación de trabajo actual. Un nombre de ruta de acceso relativa implica el uso de algunos caracteres especiales. En la tabla siguiente se describe cada una de estas características y se proporcionan ejemplos de nombres de ruta relativos y nombres de ruta completos. Los ejemplos de la tabla se basan en el directorio de trabajo actual que se establece en C:\Windows:

Símbolo Descripción Ruta de acceso relativa Ruta de acceso completa
. Ubicación de trabajo actual .\System C:\Windows\System
.. Elemento primario de la ubicación de trabajo actual ..\Program Files C:\Program Files
\ Raíz de la unidad de la ubicación de trabajo actual \Program Files C:\Program Files
Ninguno Sin caracteres especiales System C:\Windows\System

Para usar un nombre de ruta de acceso en un comando, escriba ese nombre como un nombre de ruta de acceso completa o relativa.

Los cmdlets siguientes se encargan de las rutas de acceso:

  • Convert-Path: Convierte una ruta de PowerShell a una ruta de un proveedor de PowerShell.
  • Join-Path: combina una ruta de acceso y una ruta de acceso secundaria en una única ruta de acceso.
  • Resolve-Path: resuelve los caracteres comodín de una ruta de acceso
  • Split-Path : Devuelve la parte especificada de una ruta.
  • Test-Path: determina si los elementos de una ruta de acceso existen o si una ruta de acceso tiene el formato correcto.

Algunos cmdlets (como Add-Content y Copy-Item) usan filtros de archivo. Un filtro de archivos es un mecanismo para especificar los criterios para seleccionar entre un conjunto de rutas de acceso.

El tipo de objeto que representa una ruta de acceso resuelta se describe en §4.5.5. Las rutas de acceso a menudo se manipulan como cadenas.

3.5 Ámbitos

3.5.1 Introducción

Un nombre puede denotar una variable, una función, un alias, una variable de entorno o una unidad. El mismo nombre puede indicar elementos diferentes en diferentes lugares de un script. Para cada elemento diferente que indica un nombre, ese nombre solo es visible en la región del texto de script que se conoce como su ámbito. Los distintos elementos indicados por el mismo nombre tienen ámbitos diferentes o están en espacios de nombres diferentes.

Los ámbitos se pueden anidar. En este caso, un ámbito externo se conoce como ámbito primario y los ámbitos anidados son ámbitos secundarios de ese ámbito primario. El ámbito de un nombre es el ámbito en el que este y todos los ámbitos secundarios se definen, a menos que se convierta en privado. Dentro de un ámbito secundario, un nombre que se define ahí oculta los elementos definidos con el mismo nombre en los ámbitos primarios.

A menos que se use la notación de origen de puntos (§3.5.5), cada uno de los siguientes crea un nuevo ámbito:

  • Un archivo de script
  • Un bloque de script
  • Función o filtro

Considere el ejemplo siguiente:

# Start of script
$x = 2; $y = 3
Get-Power $x $y

# Function defined in script
function Get-Power([int]$x, [int]$y) {
    if ($y -gt 0) {
        return $x * (Get-Power $x (--$y))
    } else {
        return 1
    }
}
# End of script

El ámbito de las variables $x y $y creados en el script es el cuerpo de ese script, incluida la función definida dentro de él. La función Get-Power define dos parámetros con esos mismos nombres. Dado que cada función tiene su propio ámbito, estas variables son diferentes de las definidas en el ámbito primario y ocultan las del ámbito primario. El ámbito de la función está anidado dentro del ámbito del script.

Tenga en cuenta que la función se llama de forma recursiva. Cada vez que lo hace crea otro ámbito anidado, cada uno con sus propias variables $x y $y.

Este es un ejemplo más complejo, que también muestra ámbitos anidados y reutilización de nombres:

# start of script scope
$x = 2              # top-level script-scope $x created
                    # $x is 2
F1                  # create nested scope with call to function F1
                    # $x is 2
F3                  # create nested scope with call to function F3
                    # $x is 2

function F1 {       # start of function scope
                    # $x is 2
    $x = $true      # function-scope $x created
                    # $x is $true

    & {             # create nested scope with script block
                    # $x is $true
        $x = 12.345 # scriptblock-scope $x created
                    # $x is 12.345
    }               # end of scriptblock scope, local $x goes away

                    # $x is $true
    F2              # create nested scope with call to function F2
                    # $x is $true
}                   # end of function scope, local $x goes away

function F2 {       # start of function scope
                    # $x is $true
    $x = "red"      # function-scope $x created
                    # $x is "red"
}                   # end of function scope, local $x goes away

function F3 {       # start of function scope
                    # $x is 2
    if ($x -gt 0) {
                    # $x is 2
        $x = "green"
                    # $x is "green"
    }               # end of block, but not end of any scope
                    # $x is still "green"
}                   # end of function scope, local $x goes away
# end of script scope

3.5.2 Nombres y números de ámbito

PowerShell admite los siguientes ámbitos:

  • Global: este es el ámbito de nivel superior. Todas las variables automáticas y de preferencia se definen en este ámbito. El ámbito global es el ámbito primario de todos los demás ámbitos y el resto de ámbitos son ámbitos secundarios del ámbito global.

  • Local: este es el ámbito actual en cualquier punto de ejecución dentro de un script, un bloque de script o una función. Cualquier ámbito puede ser el ámbito local.

  • Script: este ámbito existe para cada archivo de script que se ejecuta. El ámbito del script es el ámbito primario de todos los ámbitos creados a partir de él. Un bloque de script no tiene su propio ámbito de script; en lugar de eso, su ámbito de script es el del archivo de script antecesor más cercano. Aunque no hay ningún tipo de ámbito de módulo, el ámbito de script proporciona el equivalente.

Los nombres se pueden declarar privados, en cuyo caso no son visibles fuera de su ámbito primario, ni siquiera para los ámbitos secundarios. El concepto de privado no es un ámbito independiente; es un alias para el ámbito local con la añadidura de ocultar el nombre si se usa como una ubicación grabable.

Los ámbitos se pueden hacer referencia a ellos mediante un número, que describe la posición relativa de un ámbito a otro. El ámbito 0 denota el ámbito local, el ámbito 1 denota un ámbito antecesor de 1 generación, el ámbito 2 denota un ámbito antecesor de 2 generaciones, etc. (Los cmdlets que manipulan variables usan números de ámbito).

3.5.3 Ámbito de nombre de variable

Como se muestra en la siguiente producción, se puede especificar un nombre de variable con cualquiera de los seis ámbitos diferentes:

variable-scope:
    Global:
    Local:
    Private:
    Script:
    Using:
    Workflow:
    variable-namespace

El ámbito es opcional. En la tabla siguiente se muestra el significado de cada uno en todos los contextos posibles. También muestra el ámbito cuando no se especifica ningún ámbito explícitamente:

Modificador de ámbito Dentro de un archivo de script dentro de un bloque de scripts En una función
Global Ámbito global Ámbito global Ámbito global
Script Ámbito del archivo de script antecesor más cercano o Global si no hay ningún archivo de script antecesor más cercano Ámbito del archivo de script antecesor más próximo o Global si no hay ningún archivo de script antecesor más próximo Ámbito del archivo de script antecesor más cercano o Global si no hay ningún archivo de script antecesor más cercano
Privada Ámbito global/de script/local Ámbito local Ámbito local
Local Ámbito global/script/local Ámbito local Ámbito local
Uso Implementación definida Implementación definida Implementación definida
Flujo de trabajo Implementación definida Implementación definida Implementación definida
Ninguno Ámbito global/de script/local Ámbito local Ámbito local

Al usar la familia de cmdlets enumerados en (§3.1.5), se puede especificar también información sobre el ámbito de las variables. En concreto, consulte el parámetro Scopey los parámetros Option Private y Option AllScope para obtener más información.

El Using: modificador de ámbito se usa para acceder a las variables definidas en otro ámbito mientras se ejecutan scripts mediante cmdlets como Start-Job, Invoke-Command o en una instrucción inlinescript. Por ejemplo:

$a = 42
Invoke-Command --ComputerName RemoteServer { $Using:a } # returns 42
workflow foo
{
    $b = "Hello"
    inlinescript { $Using:b }
}
foo # returns "Hello"

El flujo de trabajo de ámbito se usa con una instrucción paralela o una instrucción de secuencia para acceder a una variable definida en el flujo de trabajo.

3.5.4 Ámbito de nombre de función

Un nombre de función también puede tener uno de los cuatro ámbitos diferentes y la visibilidad de ese nombre es la misma que para las variables (§3.5.3).

3.5.5 Notación de origen de puntos

Cuando se ejecuta un archivo de script, un bloque de script o una función desde otro archivo de script, bloque de script o función, el archivo de script ejecutado crea un nuevo ámbito anidado. Por ejemplo

Script1.ps1
& "Script1.ps1"
& { ... }
FunctionA

Pero cuando se usa la notación de origen de puntos, no se crea ningún ámbito antes de ejecutar el comando, por lo que las incorporaciones o cambios que habría realizado en su propio ámbito local se realizan en el ámbito actual. Por ejemplo

. Script2.ps1
. "Script2.ps1"
. { ... }
. FunctionA

3.5.6 Módulos

Al igual que un archivo de script de nivel superior se encuentra en la raíz de un árbol jerárquico de ámbitos anidados, también lo está cada módulo (§3.14). Sin embargo, de forma predeterminada, solo los nombres exportados por un módulo están disponibles por nombre desde dentro del contexto de importación. El parámetro Global del cmdlet Import-Module permite que los nombres exportados tengan mayor visibilidad.

3.6 Propiedades ReadOnly y Constant

Las variables y alias se describen mediante objetos que contienen una serie de propiedades. Estas propiedades se establecen y manipulan mediante dos familias de cmdlets (§3.1.5, §3.1.1). Una de estas propiedades es Options, que se puede establecer en ReadOnly o Constant (mediante el parámetro Option). Se puede quitar una variable o alias marcado como ReadOnly y sus propiedades pueden cambiar siempre que se especifique el parámetro Force. Sin embargo, una variable o alias marcado como Constant no se puede quitar ni cambiar sus propiedades.

3.7 Sobrecargas del método y resolución de llamadas

3.7.1 Introducción

Como se indica en §1, un procedimiento externo puesto a disposición por el entorno de ejecución (y escrito en algún lenguaje distinto de PowerShell) se denomina método .

El nombre de un método junto con el número y los tipos de sus parámetros se denominan colectivamente firma del método. (Tenga en cuenta que la firma no incluye el tipo de valor devuelto del método). El entorno de ejecución puede permitir que un tipo tenga varios métodos con el mismo nombre, siempre que cada uno tenga una firma diferente. Cuando se definen varias versiones de algún método, se dice que ese método está sobrecargado. Por ejemplo, el tipo Math (§4.3.8) contiene un conjunto de métodos denominados Abs, que calcula el valor absoluto de un número especificado, donde el número especificado puede tener uno de varios tipos. Los métodos de ese conjunto tienen las siguientes firmas:

Abs(decimal)
Abs(float)
Abs(double)
Abs(int)
Abs(long)
Abs(SByte)
Abs(Int16)

En este caso, todos los métodos tienen el mismo número de argumentos; sus firmas solo difieren en función del tipo de argumento.

Otro ejemplo implica el tipo Array (§4.3.2), que contiene un conjunto de métodos denominado Copy que copia un intervalo de elementos de una matriz a otra, empezando por el principio de cada matriz (de forma predeterminada) o en algún elemento designado. Los métodos de ese conjunto tienen las siguientes firmas:

Copy(Array, Array, int)
Copy(Array, Array, long)
Copy(Array, int, Array, int, int)
Copy(Array, long, Array, long, long)

En este caso, las firmas difieren por tipo de argumento y, en algunos casos, también por número de argumento.

En la mayoría de las llamadas a métodos sobrecargados, el número y el tipo de los argumentos pasados coinciden exactamente con una de las sobrecargas y el método seleccionado es obvio. Sin embargo, si no es así, debe haber una manera de resolver la versión sobrecargada a la que llamar, si existe. Por ejemplo

[Math]::Abs([byte]10) # no overload takes type byte
[array]::Copy($source, 3, $dest, 5L, 4) # both int and long indexes

Otros ejemplos incluyen el tipo cadena (es decir, System.String), que tiene numerosos métodos sobrecargados.

Aunque PowerShell tiene reglas para resolver llamadas a métodos que no coinciden exactamente con una firma sobrecargada, PowerShell no proporciona una manera de definir métodos sobrecargados.

Nota:

Nota del editor: PowerShell 5.0 agregó la capacidad de definir clases basadas en scripts. Estas clases pueden contener métodos sobrecargados.

3.7.2 Resolución de sobrecarga del método

Dada una llamada de método (sección 7.1.3) con una lista de expresiones de argumento y un conjunto de métodos candidatos (es decir, los métodos a los que se podría llamar), el mecanismo para seleccionar el mejor método se denomina resolución de sobrecarga.

Dado el conjunto de métodos candidatos aplicables (§3.7.3), se selecciona el mejor método de ese conjunto. Si el conjunto contiene solo un método, ese método es el mejor método. De lo contrario, el mejor método es el método que es mejor que todos los demás métodos con respecto a la lista de argumentos dada con las reglas que se muestran en §3.7.4. Si no hay exactamente un método que sea mejor que todos los demás métodos, la invocación del método es ambigua y se notifica un error.

El mejor método debe ser accesible en el contexto donde se utiliza. Por ejemplo, un script de PowerShell no puede llamar a un método privado o protegido.

El mejor método para una llamada a un método estático debe ser un método estático y el mejor método para una llamada a un método de instancia debe ser un método de instancia.

Método aplicable 3.7.3

Se dice que un método es aplicable con respecto a una lista de argumentos A cuando se cumple una de las siguientes opciones:

  • El número de argumentos de A es idéntico al número de parámetros que acepta el método.
  • El método tiene parámetros obligatorios M y N parámetros opcionales, y el número de argumentos de A es mayor o igual que M, pero menor que N.
  • El método acepta un número variable de argumentos y el número de argumentos de A es mayor que el número de parámetros que acepta el método.

Además de tener un número adecuado de argumentos, cada argumento de A debe coincidir con el modo de paso de parámetros del argumento y el tipo de argumento debe coincidir con el tipo de parámetro o debe haber una conversión del tipo de argumento al tipo de parámetro.

Si el tipo de argumento es ref (§4.3.6), el parámetro correspondiente también debe ser ref y el tipo de argumento para fines de conversión es el tipo de la propiedad Value del argumento ref.

Si el tipo de argumento es ref, el parámetro correspondiente podría ser out en lugar de ref.

Si el método acepta un número variable de argumentos, el método puede ser aplicable en forma normal o forma expandida. Si el número de argumentos de A es idéntico al número de parámetros que acepta el método y el último parámetro es una matriz, el formulario depende del rango de una de las dos conversiones posibles:

  • Rango de la conversión del tipo del último argumento de A al tipo de matriz para el último parámetro.
  • El rango de la conversión del tipo del último argumento en A al tipo de elemento del tipo de matriz correspondiente al último parámetro.

Si la primera conversión (al tipo de matriz) es mejor que la segunda conversión (al tipo de elemento de la matriz), el método se aplica en forma normal; de lo contrario, se aplica en formato expandido.

Si hay más argumentos que parámetros, el método solo puede aplicarse en formato expandido. Para que sea aplicable en formato expandido, el último parámetro debe tener el tipo de matriz. El método se reemplaza por un método equivalente que tiene el último parámetro reemplazado por parámetros suficientes para tener en cuenta cada argumento no coincidente en A. Cada tipo de parámetro adicional es el tipo de elemento del tipo de matriz para el último parámetro del método original. Las reglas anteriores para un método aplicable se aplican a este nuevo método y a la lista de argumentos A.

3.7.4 Método mejorado

Dada una lista de argumentos A con un conjunto de expresiones de argumento { E~1~, E~2~, ..., E~N~ } y dos métodos de aplicación M~P~ y M~Q~ con tipos de parámetros { P~1~, P~2~, ..., P~N~ } y { Q~1~, Q~2~, ..., Q~N~ }, se define M~P~ ser un método mejor que M~Q~ si la clasificación acumulativa de de conversiones para M~P~ es mejor que para M~Q~.

La clasificación acumulativa de conversiones se calcula de la manera siguiente. Cada conversión vale un valor diferente según el número de parámetros, con la conversión de E~1~ valor N, E~2~ valor N-1, hasta E~N~ valor de 1. Si la conversión de E~X~ a P~X~ es mejor que la de E~X~ a Q~X~, el M~P~ acumula N-X+1; de lo contrario, M~Q~ acumula N-X+1. Si M~P~ y M~Q~ tienen el mismo valor, se usan las siguientes reglas de desempate, aplicadas en orden:

  • La clasificación acumulativa de conversiones entre tipos de parámetros (omitir tipos de argumento) se calcula de forma similar a la clasificación anterior, por lo que se compara P~1~ con Q~1~, P~2~ con Q~2~, ..., y P~N~ en Q~N~. La comparación se omite si el argumento se $null, o si los tipos de parámetro no son tipos numéricos. La comparación también se omite si la conversión de argumentos E~X~ pierde información cuando se convierte en P~X~ pero no pierde información cuando se convierte en Q~X~, o viceversa. Si se comparan los tipos de conversión de parámetros, si la conversión de P~X~ a Q~X~ es mejor que la de Q~X~ a P~X~, el M~P~ acumula N-X+1; de lo contrario, M~Q~ acumula N-X+1. Esta regla de interrupción de empate está pensada para preferir la del método más específico (es decir, el método con parámetros que tienen los tipos de datos más pequeños) si no se pierde información en las conversiones, o para preferir la método más general (es decir, el método con los parámetros con los tipos de datos más grandes) si las conversiones provocan la pérdida de información.
  • Si ambos métodos usan su forma expandida, el método con más parámetros es el mejor método.
  • Si un método usa el formulario expandido y el otro usa el formato normal, el método que usa el formulario normal es el mejor método.

3.7.5 Mejor conversión

El texto siguiente marcado como este es específico de Windows PowerShell.

Las conversiones se clasifican de la siguiente manera, de la más baja a la más alta:

  • T~1~[] a T~2~[] donde no existe ninguna conversión asignable entre T~1~ y T~2~.
  • T a string, donde T es cualquier tipo.
  • T~1~ a T~2~ donde T~1~ o T~2~ definan una conversión personalizada de acuerdo con la implementación.
  • T~1~ a T~2~ donde T~1~ implementa IConvertible
  • T~1~ a T~2~ donde T~1~ o T~2~ implementa el método T~2~ op_Implicit(T1)
  • T~1~ a T~2~ donde T~1~ o T~2~ implementa el método T~2~ op_Explicit(T1)
  • T~1~ a T~2~ donde T~2~ implementa un constructor que toma un único argumento de tipo T~1~
  • Cualquiera de las conversiones siguientes:
    • string a T, donde T implementa un método estático T Parse(string) o T Parse(string, IFormatProvider).
    • T~1~ a T~2~ donde T~2~ es cualquier enumeración y T~1~ es una cadena o una colección de objetos que se pueden convertir en cadena
  • T a PSObject, donde T es cualquier tipo.
  • Cualquiera de las conversiones siguientes: Language
    • T a bool, donde T es cualquier tipo numérico.
    • cadena a T donde T es regex, wmisearcher, wmi, wmiclass, adsi, adsisearchero type
    • T a bool
    • T~1~ a Nullable[T~2~], donde existe una conversión de T~1~ a T~2~.
    • T a void.
    • T~1~[] a T~2~[] donde existe una conversión asignable entre T~1~ y T~2~
    • T~1~ a T~2~[] donde T~1~ es una colección
    • IDictionary a Hashtable
    • T a ref
    • T a xml
    • scriptblock a delegate
    • T~1~ a T~2~ donde T~1~ es un tipo entero y T~2~ es una enumeración
  • $null a T donde T es cualquier tipo de valor
  • $null a T donde T es cualquier tipo de referencia
  • Cualquiera de las conversiones siguientes:

    • byte a T, donde T es SByte.

    • UInt16 a T donde T se SByte, byteo Int16

    • Int16 a T donde T es SByte o byte

    • UInt32 a T donde T es SByte, byte, Int16, UInt16o int

    • int a T donde T es SByte, byte, Int16o UInt16

    • UInt64 a T donde T es SByte, byte, Int16, UInt16, int, UInt32o long

    • long a T donde T es SByte, byte, Int16, UInt16, into UInt32

    • float a T donde T es cualquier tipo entero o decimal

    • double a T donde T es cualquier tipo entero o decimal

    • decimal a T donde T es cualquier tipo entero

  • Cualquiera de las conversiones siguientes:
    • SByte a T donde T es byte, uint6, UInt32o UInt64
    • Int16 a T donde T se UInt16, UInt32o UInt64
    • int a T donde T es UInt32 o UInt64
    • long a UInt64
    • decimal a T donde T es float o double
  • Cualquiera de las conversiones siguientes:
    • T a string donde T es cualquier tipo numérico
    • T a char donde T es cualquier tipo numérico
    • string a T donde T es cualquier tipo numérico
  • Cualquiera de las conversiones siguientes, esta conversión se considera una conversión asignable:
    • byte a T donde T es Int16, UInt16, int, UInt32, long, UInt64, single, doubleo decimal
    • SByte a T donde T es Int16, UInt16, int, UInt32, long, UInt64, single, doubleo decimal
    • UInt16 a T donde T se int, UInt32, longo UInt64, single, doubleo decimal
    • Int16 a T donde T se int, UInt32, longo UInt64, single, doubleo decimal
    • UInt32 a T donde T es long, o UInt64, single, doubleo decimal
    • int a T donde T es long, UInt64, single, doubleo decimal
    • single a double
  • T~1~ a T~2~ donde T~2~ es una clase base o interfaz de T~1~. Esta conversión se considera una conversión asignable.
  • string a char[]
  • T a T: esta conversión se considera una conversión asignable.

Para cada conversión del formulario T~1~ a T~2~[] donde T~1~ no es una matriz y no se aplica ninguna otra conversión, si hay una conversión de T~1~ a T~2~, la clasificación de la conversión es peor que la conversión de T~1~ a T~2~, pero mejor que cualquier conversión clasificada menor que la conversión de T~1~ a T~2~

3.8 Búsqueda de nombres

Es posible tener comandos de diferentes tipos que tengan el mismo nombre. El orden en el que se realiza la búsqueda de nombres en tal caso es alias, función, cmdlet y comando externo.

3.9 Búsqueda de nombres de tipo

En la sección 7.1.10 se incluye la instrucción: "Un elemento literal de tipo se representa en una implementación mediante algún tipo subyacente no especificado. Como resultado, un nombre de tipo es un sinónimo de su tipo subyacente". Ejemplo de tipos son int, double, long[]y Hashtable.

Los nombres de tipo coinciden de la siguiente manera: compare un nombre de tipo determinado con la lista de aceleradores de tipos integrados, como int, long y double. Si se encuentra una coincidencia, ese es el tipo. De lo contrario, presuma que el nombre de tipo está totalmente calificado y compruebe si existe este tipo en el sistema anfitrión. Si se encuentra una coincidencia, ese es el tipo. De lo contrario, agregue el prefijo de espacio de nombres System.. Si se encuentra una coincidencia, ese es el tipo. De lo contrario, el nombre de tipo es un error. Este algoritmo se aplica para cada argumento de tipo para los tipos genéricos. Sin embargo, no es necesario especificar la aridad (el número de argumentos o operandos tomados por una función o operador).

3.10 Administración automática de memoria

Varios operadores y cmdlets dan lugar a la asignación de memoria para objetos de tipo de referencia, como cadenas y matrices. El sistema en tiempo de ejecución de PowerShell administra la asignación y la liberación de esta memoria. Es decir, PowerShell proporciona recolección de elementos no utilizados automática.

3.11 Orden de ejecución

Un efecto secundario es un cambio en el estado del entorno de ejecución de un comando. Un cambio en el valor de una variable (a través de los operadores de asignación o los operadores previos y posteriores al incremento y decremento) es un efecto secundario, como es un cambio en el contenido de un archivo.

A menos que se especifique lo contrario, las instrucciones se ejecutan en orden léxico.

Excepto como se especifica para algunos operadores, el orden de evaluación de términos en una expresión y el orden en el que se producen los efectos secundarios no se especifican.

Una expresión que invoca un comando implica la expresión que designa el comando y cero o más expresiones que designan los argumentos cuyos valores se van a pasar a ese comando. No se especifica el orden en que se evalúan estas expresiones en relación entre sí.

3.12 Control de errores

Cuando un comando falla, esto se considera un error y la información sobre ese error se almacena en un registro de errores , cuyo tipo no está especificado (§4.5.15); sin embargo, este tipo admite subíndices.

Un error se divide en una de las dos categorías. Finaliza la operación (un error de terminación ) o no (un error de no terminación ). Con un error de terminación, el error se registra y la operación se detiene. Con un error de no terminación, el error se registra y la operación continúa.

Los errores de no terminación se escriben en la secuencia de errores. Aunque esa información se puede redirigir a un archivo, los objetos de error se convierten primero en cadenas y la información importante de esos objetos no se capturaría haciendo que el diagnóstico sea difícil si no es imposible. En su lugar, se puede redirigir el texto del error (§7.12) y el objeto de error guardado en una variable, como en $Error1 = command 2>&1.

La variable automática $Error contiene una colección de registros de error que representan errores recientes y el error más reciente se encuentra en $Error[0]. Esta colección se mantiene en un búfer de modo que se descartan los registros antiguos a medida que se agregan nuevos. La variable automática $MaximumErrorCount controla el número de registros que se pueden almacenar.

$Error contiene todos los errores de todos los comandos mezclados juntos en una sola colección. Para recopilar los errores de un comando específico, use el parámetro común ErrorVariable, que permite especificar una variable definida por el usuario para contener la colección.

3.13 Canalizaciones

Una canalización es una serie de uno o varios comandos que separa el operador de canalización | (U+007C). Cada comando recibe su entrada del predecesor y envía su salida al sucesor. A menos que la salida al final de la canalización se descarte o redirija a un archivo, se envía al entorno host, que puede optar por escribirla en la salida estándar. Los comandos de una canalización también pueden recibir entradas de argumentos. Por ejemplo, considere el siguiente uso de comandos Get-ChildItem, Sort-Objecty Process-File, que crean una lista de nombres de archivo en un directorio de sistema de archivos determinado, ordenan un conjunto de registros de texto y realizan algún procesamiento en un registro de texto, respectivamente:

Get-ChildItem
Get-ChildItem E:*.txt | Sort-Object -CaseSensitive | Process-File >results.txt

En el primer caso, Get-ChildItem crea una colección de nombres de los archivos en el directorio actual o predeterminado. Esa colección se envía al entorno host, que, de forma predeterminada, escribe el valor de cada elemento en la salida estándar.

En el segundo caso, Get-ChildItem crea una colección de nombres de los archivos del directorio especificado, utilizando el argumento E:*.txt. Esa colección se escribe en el comando Sort-Object, el cual ‒de manera predeterminada‒ las ordena en orden ascendente, con distinción entre mayúsculas y minúsculas (en virtud del argumento CaseSensitive). A continuación, la colección resultante se escribe en el comando Process-File, que realiza algún procesamiento (desconocido). A continuación, la salida de ese comando se redirige al archivo results.txt.

Si un comando escribe un único objeto, su sucesor recibe ese objeto y, después, finaliza después de escribir sus propios objetos a su sucesor. Sin embargo, si un comando escribe varios objetos, se entregan de uno en uno al comando sucesor, que se ejecuta una vez por objeto. Este comportamiento se denomina streaming. En el procesamiento de secuencias, los objetos se escriben a lo largo de la canalización en cuanto están disponibles, no cuando se ha generado toda la colección.

Al procesar una colección, se puede escribir un comando para que pueda realizar un procesamiento especial antes del elemento inicial y después del elemento final.

3.14 Módulos

Un módulo es una unidad reutilizable independiente que permite dividir, organizar y abstraer código de PowerShell. Un módulo puede contener comandos (como cmdlets y funciones) y elementos (como variables y alias) que se pueden usar como una sola unidad.

Una vez creado un módulo, debe importarse en una sesión antes de que se puedan usar los comandos y elementos que incluye. Una vez importados, los comandos y los elementos se comportan como si se definiesen localmente. Un módulo se importa explícitamente con el comando Import-Module. Un módulo también se puede importar automáticamente según se determine de forma definida por la implementación.

El tipo de un objeto que representa un módulo se describe en §4.5.12.

Los módulos se describen en detalle en §11.

3.15 Expresiones comodín

Una expresión comodín puede contener cero o más de los siguientes elementos:

Elemento Descripción
Carácter distinto de *, ?, o [ Coincide con ese carácter
* Coincide con cero o más caracteres. Para que coincida con un carácter *, use [*].
? Devuelve cualquier carácter. Para que coincida con un carácter character, use [?].
[set]

Coincide con cualquier carácter del conjunto , que no debe estar vacío.

Si el conjunto comienza con ], ese corchete cuadrado derecho se considera parte del conjunto y el siguiente corchete cuadrado derecho cierra el conjunto; si no, el primer corchete cuadrado derecho cierra el conjunto.

Si set comienza o termina con -, el guion menos se considera parte de set. De lo contrario, indica un intervalo de puntos de código Unicode consecutivos con los caracteres a ambos lados del guion menos como delimitadores de intervalo inclusivos. Por ejemplo, A-Z indica las 26 letras mayúsculas en inglés y 0-9 indica los 10 dígitos decimales.

Nota:

Puede encontrar más información en Especificaciones básicas de The Open Group: Coincidencia de patrones, IEEE Std 1003.1, edición de 2004. Pero en PowerShell, el carácter de escape es una tilde aguda, no una barra diagonal inversa.

3.16 Expresiones regulares

Una expresión regular puede contener cero o más de los siguientes elementos:

Elemento Descripción
Carácter distinto de ., [, ^, *, $ o \ Coincide con ese carácter
. Devuelve cualquier carácter. Para que coincida con un carácter character, use \..
[set]
[^set]

El formato [set] coincide con cualquier carácter del conjunto. El formato [^set] no coincide con ningún carácter del conjunto. set no puede estar vacío.

Si conjunto comienza con ] o ^], ese corchete cuadrado derecho se considera parte del conjunto y el siguiente corchete cuadrado derecho termina el conjunto; de lo contrario, el primer corchete cuadrado derecho termina el conjunto.

Si set comienza por - o ^-, o termina con -, el guion menos se considera parte de set. De lo contrario, indica un intervalo de puntos de código Unicode consecutivos con los caracteres a ambos lados del guion menos como delimitadores de intervalo inclusivos. Por ejemplo, A-Z indica las 26 letras mayúsculas en inglés y 0-9 indica los 10 dígitos decimales.
* Coincide con cero o más repeticiones del elemento anterior.
+ Coincide con una de más apariciones del elemento anterior.
? Coincide con cero o una repetición del elemento anterior.
^ Coincide con el inicio de la cadena. Para que coincida con un carácter ^ , use \^.
$ Coincide con el final de la cadena. Para que coincida con un carácter $, use $.
\c Aplica el escape al carácter c, por lo que no se reconoce como un elemento de expresión regular.

Nota:

Puede encontrar más información en Especificaciones básicas de The Open Group: Expresiones regulares, IEEE Std 1003.1, edición de 2004.

Windows PowerShell: se admiten las clases de caracteres disponibles en las expresiones regulares de Microsoft .NET Framework, como se indica a continuación:

Elemento Descripción
\p{name} Coincide con cualquier carácter de la clase de caracteres con nombre especificada por name. Los nombres admitidos son grupos Unicode y intervalos de bloques, como Ll, Nd, Z, IsGreek e IsBoxDrawing.
\P{name} Coincide con el texto no incluido en los grupos e intervalos de bloques especificados en name.
\w Coincide con cualquier carácter de una palabra. Equivalente a las categorías de caracteres Unicode [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}]. Si se especifica el comportamiento compatible con ECMAScript con la opción ECMAScript, \w es equivalente a [a-zA-Z_0-9].
\W Coincide con cualquier carácter que no pertenezca a una palabra. Equivalente a las categorías Unicode [\^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}].
\s Coincide con cualquier carácter de espacio en blanco. Equivalente a las categorías de caracteres Unicode [\f\n\r\t\v\x85\p{Z}].
\S Coincide con cualquier carácter que no sea un espacio en blanco. Equivalente a las categorías de caracteres Unicode [\^\f\n\r\t\v\x85\p{Z}].
\d Coincide con cualquier dígito decimal. Equivalente a \p{Nd} para Unicode y [0-9] para el comportamiento que no sea Unicode.
\D Corresponde a cualquier carácter que no sea un dígito. Equivalente a \P{Nd} para Unicode y [\^0-9] para el comportamiento que no sea Unicode.

Se admiten cuantificadores disponibles en expresiones regulares de Microsoft .NET Framework, como se indica a continuación:

Elemento Descripción
* Especifica cero o más coincidencias; por ejemplo, \w* o (abc)*. Equivalente a {0,}.
+ Coincide con las instancias repetidas de los caracteres anteriores.
? Especifica cero o una coincidencia; por ejemplo, \w? o (abc)?. Equivalente a {0,1}.
{n} Especifica exactamente n coincidencias; por ejemplo, (pizza){2}.
{n,} Especifica al menos n coincidencias; por ejemplo, (abc){2,}.
{n,m} Especifica al menos n coincidencias, pero m como máximo.