Uso de características experimentales en PowerShell

La compatibilidad con las características experimentales de PowerShell proporciona un mecanismo para que las características experimentales coexistan con las características estables existentes en PowerShell o los módulos de PowerShell.

Una característica experimental es aquella en la el diseño no ha finalizado. La característica está disponible para que los usuarios puedan probar y proporcionar comentarios. Una vez finalizada una característica experimental, los cambios de diseño se vuelven importantes.

Para obtener más información acerca de cómo habilitar o deshabilitar estas características, vea Acerca de las características experimentales.

Características disponibles

En este artículo se describen las características experimentales que están disponibles y cómo usarlas.

Leyenda

• ✔️: indica que la característica experimental está disponible en la versión de PowerShell
• ✅: indica la versión de PowerShell donde la característica experimental ya es estándar
• ❌: indica la versión de PowerShell donde la característica experimental se ha quitado

Microsoft.PowerShell.Utility.PSManageBreakpointsInRunspace

En PowerShell 7.0, el experimento habilita el parámetro BreakAll en los cmdlets Debug-Runspace y Debug-Job para permitir que los usuarios decidan si quieren que PowerShell se interrumpa inmediatamente en la ubicación actual cuando adjunten un depurador.

En PowerShell 7.1, este experimento también agrega el parámetro Runspace a los cmdlets *-PSBreakpoint.

• Disable-PSBreakpoint
• Enable-PSBreakpoint
• Get-PSBreakpoint
• Remove-PSBreakpoint
• Set-PSBreakpoint

El parámetro Runspace especifica un objeto Runspace para interactuar con los puntos de interrupción del espacio de ejecución especificado.

Start-Job -ScriptBlock {
    Set-PSBreakpoint -Command Start-Sleep
    Start-Sleep -Seconds 10
}

$runspace = Get-Runspace -Id 1

$breakpoint = Get-PSBreakPoint -Runspace $runspace

En este ejemplo, se inicia un trabajo y se establece un punto de interrupción para que se interrumpa cuando se ejecute Set-PSBreakPoint. El espacio de ejecución se almacena en una variable y se pasa al comando Get-PSBreakPoint con el parámetro Runspace. Después, puede inspeccionar el punto de interrupción en la variable $breakpoint.

PSAnsiRenderingFileInfo

Este experimento se agregó en PowerShell 7.2. Esta característica agrega el miembro $PSStyle.FileInfo y permite colorear tipos de archivo específicos.

• $PSStyle.FileInfo.Directory: miembro integrado para especificar el color de los directorios.
• $PSStyle.FileInfo.SymbolicLink: miembro integrado para especificar el color de los vínculos simbólicos.
• $PSStyle.FileInfo.Executable: miembro integrado para especificar el color de los ejecutables.
• $PSStyle.FileInfo.Extension: use este miembro para definir colores para diferentes extensiones de archivo. El miembro Extension incluye previamente extensiones para archivar y para archivos de PowerShell.

Para obtener más información, vea about_Automatic_Variables.

PSCommandNotFoundSuggestion

Recomienda comandos potenciales basados en la búsqueda de coincidencias aproximadas después de CommandNotFoundException.

PS> get

get: The term 'get' 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.

Suggestion [4,General]: The most similar commands are: set, del, ft, gal, gbp, gc, gci, gcm, gdr,
gcs.

PSCultureInvariantReplaceOperator

Cuando el operando izquierdo de una instrucción de operador -replace no es una cadena, ese operando se convierte en una cadena.

Cuando esta característica está deshabilitada, el operador -replace realiza una conversión de cadena que tiene en cuenta la referencia cultural. Por ejemplo, si la referencia cultural se establece en francés (fr), el valor 1.2 se convierte a la cadena 1,2.

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
12
PS> [cultureinfo]::CurrentCulture = 'en'
PS> 1.2 -replace ','
1.2

Con la característica habilitada:

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
1.2

PSDesiredStateConfiguration.InvokeDscResource

Habilita la compilación en MOF en sistemas que no son de Windows y permite el uso de Invoke-DSCResource sin LCM.

En versiones preliminares anteriores de PowerShell 7.2, esta característica estaba habilitada de manera predeterminada. A partir de PowerShell 7.2-preview7, se quitó el módulo PSDesiredStateConfiguration y esta característica está deshabilitada de manera predeterminada. Para habilitar esta característica, debe instalar el módulo PSDesiredStateConfiguration v2.0.5 desde la Galería de PowerShell y habilitarla mediante Enable-ExperimentalFeature.

PSImplicitRemotingBatching

Esta característica examina el comando escrito en el shell y, si todos los comandos son comandos proxy de comunicación remota implícita que forman una canalización simple, los comandos se agrupan por lotes y se invocan como una sola canalización remota.

Ejemplo:

# Create remote session and import TestIMod module
$s = nsn -host remoteMachine
icm $s { ipmo 'C:\Users\user\Documents\WindowsPowerShell\Modules\TestIMod\TestIMod.psd1' }
Import-PSSession $s -mod testimod

$maxProcs = 1000
$filter = 'pwsh','powershell*','wmi*'

# Without batching, this pipeline takes approximately 12 seconds to run
Measure-Command { Get-AllProcesses -MaxCount $maxProcs | Select-Custom $filter | Group-Stuff $filter }
Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 12
Milliseconds      : 463

# But with the batching experimental feature enabled, it takes approximately 0.20 seconds
Measure-Command { Get-AllProcesses -MaxCount $maxProcs | Select-Custom $filter | Group-Stuff $filter }
Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 0
Milliseconds      : 209

Tal y como se ha indicado anteriormente, con la característica de procesamiento por lotes habilitada, los tres comandos de proxy remoto implícitos, Get-AllProcesses, Select-Custom, Group-Stuff, se ejecutan en la sesión remota y el resultado de la canalización son los únicos datos que se devuelven al cliente. Esto reduce la cantidad de datos que se envían entre el cliente y la sesión remota, y también reduce la cantidad de serialización y deserialización de objetos.

PSLoadAssemblyFromNativeCode

Expone una API para permitir la carga de ensamblados desde código nativo.

PSNativeCommandArgumentPassing

Cuando esta característica experimental está habilitada, PowerShell usa la propiedad ArgumentList del objeto StartProcessInfo en lugar de nuestro mecanismo actual de reconstrucción de una cadena al invocar un ejecutable nativo.

La característica agrega una nueva variable automática $PSNativeCommandArgumentPassing que permite seleccionar el comportamiento en tiempo de ejecución. Los valores válidos son Legacy, Standard y Windows. Legacy es el comportamiento que se ha usado hasta ahora. El comportamiento predeterminado al habilitar esta característica experimental es el nuevo Standard.

Cuando la variable de preferencia se establece en Windows, las invocaciones de los siguientes archivos usan automáticamente el paso de argumentos de estilo Legacy.

• cmd.exe
• cscript.exe
• wscript.exe
• termina en .bat
• termina en .cmd
• termina en .js
• termina en .vbs
• termina en .wsf

Si $PSNativeArgumentPassing se establece en Legacy o Standard, no se produce la comprobación de estos archivos. El comportamiento predeterminado es específico de cada plataforma. En plataformas Windows la configuración predeterminada es Windows y en plataformas no Windows Standard.

Nuevos comportamientos disponibles con este cambio:

• Las cadenas literales o expandibles con comillas insertadas ahora se conservan:

  PS > $a = 'a" "b'
  PS > $PSNativeCommandArgumentPassing = "Legacy"
  PS > testexe -echoargs $a 'a" "b' a" "b
  Arg 0 is <a b>
  Arg 1 is <a b>
  Arg 2 is <a b>
  PS > $PSNativeCommandArgumentPassing = "Standard"
  PS > testexe -echoargs $a 'a" "b' a" "b
  Arg 0 is <a" "b>
  Arg 1 is <a" "b>
  Arg 2 is <a b>
  

• Las cadenas vacías usadas como argumentos ahora se conservan:

  PS>  $PSNativeCommandArgumentPassing = "Legacy"
  PS> testexe -echoargs '' a b ''
  Arg 0 is <a>
  Arg 1 is <b>
  PS> $PSNativeCommandArgumentPassing = "Standard"
  PS> testexe -echoargs '' a b ''
  Arg 0 is <>
  Arg 1 is <a>
  Arg 2 is <b>
  Arg 3 is <>
  

El nuevo comportamiento no altera las invocaciones que tienen este aspecto:

PS> $PSNativeCommandArgumentPassing = "Legacy"
PS> testexe -echoargs -k com:port=\\devbox\pipe\debug,pipe,resets=0,reconnect
Arg 0 is <-k>
Arg 1 is <com:port=\\devbox\pipe\debug,pipe,resets=0,reconnect>
PS> $PSNativeCommandArgumentPassing = "Standard"
PS> testexe -echoargs -k com:port=\\devbox\pipe\debug,pipe,resets=0,reconnect
Arg 0 is <-k>
Arg 1 is <com:port=\\devbox\pipe\debug,pipe,resets=0,reconnect>

Además, ahora se proporciona seguimiento de parámetros, así que Trace-Command proporciona información útil para la depuración.

PS> $PSNativeCommandArgumentPassing = "Legacy"
PS> trace-command -PSHOST -Name ParameterBinding { testexe -echoargs $a 'a" "b' a" "b }
DEBUG: 2021-02-01 17:19:53.6438 ParameterBinding Information: 0 : BIND NAMED native application line args [/Users/james/src/github/forks/jameswtruher/PowerShell-1/test/tools/TestExe/bin/testexe]
DEBUG: 2021-02-01 17:19:53.6440 ParameterBinding Information: 0 :     BIND argument [-echoargs a" "b a" "b "a b"]
DEBUG: 2021-02-01 17:19:53.6522 ParameterBinding Information: 0 : CALLING BeginProcessing
Arg 0 is <a b>
Arg 1 is <a b>
Arg 2 is <a b>
PS> $PSNativeCommandArgumentPassing = "Standard"
PS> trace-command -PSHOST -Name ParameterBinding { testexe -echoargs $a 'a" "b' a" "b }
DEBUG: 2021-02-01 17:20:01.9829 ParameterBinding Information: 0 : BIND NAMED native application line args [/Users/james/src/github/forks/jameswtruher/PowerShell-1/test/tools/TestExe/bin/testexe]
DEBUG: 2021-02-01 17:20:01.9829 ParameterBinding Information: 0 :     BIND cmd line arg [-echoargs] to position [0]
DEBUG: 2021-02-01 17:20:01.9830 ParameterBinding Information: 0 :     BIND cmd line arg [a" "b] to position [1]
DEBUG: 2021-02-01 17:20:01.9830 ParameterBinding Information: 0 :     BIND cmd line arg [a" "b] to position [2]
DEBUG: 2021-02-01 17:20:01.9831 ParameterBinding Information: 0 :     BIND cmd line arg [a b] to position [3]
DEBUG: 2021-02-01 17:20:01.9908 ParameterBinding Information: 0 : CALLING BeginProcessing
Arg 0 is <a" "b>
Arg 1 is <a" "b>
Arg 2 is <a b>

PSNativePSPathResolution

Si una ruta de acceso de PSDrive que usa el proveedor de sistema de archivos se pasa a un comando nativo, la ruta de acceso del archivo resuelta se pasa al comando nativo. Esto significa que un comando como code temp:/test.txt funciona ahora como se esperaba.

Además, en Windows, si la ruta de acceso comienza con ~, se resuelve en la ruta de acceso completa y se pasa al comando nativo. En ambos casos, la ruta de acceso se normaliza en los separadores de directorio para el sistema operativo correspondiente.

• Si la ruta de acceso no es un parámetro PSDrive o ~ (en Windows), no se produce la normalización de la ruta de acceso
• Si la ruta de acceso está entre comillas simples, no se resuelve y se trata como literal.

PSNotApplyErrorActionToStderr

Cuando esta característica experimental está habilitada, los registros de error redirigidos desde comandos nativos, igual que cuando se usan operadores de redireccionamiento (2>&1), no se escriben en la variable $Error y la variable de preferencia $ErrorActionPreference no afecta a la salida redirigida.

Muchos comandos nativos escriben en stderr a modo de secuencia alternativa para obtener información adicional. Este comportamiento puede llevar a confusión cuando se examinan los errores; también, se puede perder la información de salida adicional para el usuario si $ErrorActionPreference se establece en un estado que silencia la salida.

Cuando un comando nativo tiene un código de salida distinto de cero, $? se establece en $false. Si el código de salida es cero, $? se establece en $true.

PSNullConditionalOperators

Introduce nuevos operadores para los operadores de acceso a miembros condicionales NULL: ?. y ?[]. Los operadores de acceso a miembros "null" se pueden usar en tipos escalares y tipos de matriz. Devuelven el valor del miembro al que se tiene acceso si la variable no es NULL. Si el valor de la variable es NULL, devuelve NULL.

$x = $null
${x}?.propname
${x?}?.propname

${x}?[0]
${x?}?[0]

${x}?.MyMethod()

Se obtiene acceso a la propiedad propname y su valor se devuelve solo si $x no es NULL. Del mismo modo, el indizador solo se utiliza si $x no es NULL. Si $x es NULL, se devuelve NULL.

Los operadores ?. y ?[] son operadores de acceso a miembros y no permiten un espacio entre el nombre de la variable y el operador.

Puesto que PowerShell permite ? como parte del nombre de la variable, se requiere la desambiguación cuando se usan los operadores sin un espacio entre el nombre de la variable y el operador. Para eliminar la ambigüedad, las variables deben usar {} sobre el nombre de la variable, como ${x?}?.propertyName o ${y}?[0].

PSUnixFileStat

Esta característica proporciona más listas de archivos de tipo Unix mediante la inclusión de datos de la API stat de Unix. Agrega una nueva propiedad de nota al proveedor del sistema de archivos denominada UnixStat que incluye una representación de información de la API stat(2) de UNIX.

El resultado deGet-ChildItem debe parecerse a este:

dir | select -first 4 -skip 5


    Directory: /Users/jimtru/src/github/forks/JamesWTruher/PowerShell-1

UnixMode   User      Group           LastWriteTime        Size Name
--------   ----      -----           -------------        ---- ----
drwxr-xr-x jimtru    staff        10/23/2019 13:16         416 test
drwxr-xr-x jimtru    staff         11/8/2019 10:37         896 tools
-rw-r--r-- jimtru    staff         11/8/2019 10:37      112858 build.psm1
-rw-r--r-- jimtru    staff         11/8/2019 10:37      201297 CHANGELOG.md

PSSubsystemPluginModel

Esta característica habilita el modelo de complemento de subsistema en PowerShell. La característica permite separar componentes de System.Management.Automation.dll en subsistemas individuales que residen en su propio ensamblado. Esta separación reduce la superficie de memoria del disco del motor de PowerShell principal y permite que estos componentes se conviertan en características opcionales para una instalación mínima de PowerShell.

Actualmente, solo se admite el subsistema CommandPredictor. Este subsistema se usa junto con el módulo PSReadLine para proporcionar complementos de predicción personalizados. En el futuro, Job, CommandCompleter, Remoting y otros componentes podrían separarse en ensamblados de subsistema fuera de System.Management.Automation.dll.

La característica experimental incluye un nuevo cmdlet, Get-PSSubsystem. Este cmdlet solo está disponible cuando la característica está habilitada y devuelve información sobre los subsistemas que están disponibles en el sistema.