Nota
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
Cuando empecé a aprender PowerShell, inicialmente confiaba en la interfaz gráfica de usuario (GUI) para las tareas que parecían demasiado complejas para comandos sencillos de PowerShell. Sin embargo, a medida que continuaba aprendiendo, mejoré mis habilidades y me mudé de líneas únicas básicas a la creación de scripts, funciones y módulos. Es importante recordar que sentirse abrumado por ejemplos avanzados en línea es normal. Nadie comienza como experto en PowerShell; todos empezamos como principiantes.
Para aquellos que usan principalmente la GUI para tareas administrativas, instale las herramientas de administración en la estación de trabajo administrativa para administrar de forma remota los servidores. Tanto si el servidor usa una GUI como la instalación del sistema operativo Server Core, este enfoque es beneficioso. Es una manera práctica de familiarizarse con la administración remota del servidor en preparación para realizar tareas administrativas con PowerShell.
Al igual que con los capítulos anteriores, pruebe estos conceptos en el entorno de laboratorio.
Comandos únicos de una línea
Un comando de una línea de PowerShell es una canalización continua. Es una idea errónea común pensar que un comando en una sola línea es un one-liner de PowerShell, pero esto no siempre es cierto.
Por ejemplo, considere el siguiente caso: el comando se extiende a través de varias líneas físicas, pero es un comando de PowerShell de una sola línea porque forma una canalización continua. Se recomienda dividir un comando largo de una línea en el símbolo de canalización, un punto de interrupción natural en PowerShell, para mejorar la legibilidad y la claridad. Este uso estratégico de saltos de línea mejora la legibilidad sin interrumpir el flujo de la canalización.
Get-Service |
Where-Object CanPauseAndContinue -EQ $true |
Select-Object -Property *
Name : LanmanWorkstation
RequiredServices : {NSI, MRxSmb20, Bowser}
CanPauseAndContinue : True
CanShutdown : False
CanStop : True
DisplayName : Workstation
DependentServices : {SessionEnv, Netlogon}
MachineName : .
ServiceName : LanmanWorkstation
ServicesDependedOn : {NSI, MRxSmb20, Bowser}
ServiceHandle :
Status : Running
ServiceType : Win32OwnProcess, Win32ShareProcess
StartType : Automatic
Site :
Container :
Name : Netlogon
RequiredServices : {LanmanWorkstation}
CanPauseAndContinue : True
CanShutdown : False
CanStop : True
DisplayName : Netlogon
DependentServices : {}
MachineName : .
ServiceName : Netlogon
ServicesDependedOn : {LanmanWorkstation}
ServiceHandle :
Status : Running
ServiceType : Win32ShareProcess
StartType : Automatic
Site :
Container :
Name : vmicheartbeat
RequiredServices : {}
CanPauseAndContinue : True
CanShutdown : False
CanStop : True
DisplayName : Hyper-V Heartbeat Service
DependentServices : {}
MachineName : .
ServiceName : vmicheartbeat
ServicesDependedOn : {}
ServiceHandle :
Status : Running
ServiceType : Win32OwnProcess, Win32ShareProcess
StartType : Manual
Site :
Container :
Name : vmickvpexchange
RequiredServices : {}
CanPauseAndContinue : True
CanShutdown : False
CanStop : True
DisplayName : Hyper-V Data Exchange Service
DependentServices : {}
MachineName : .
ServiceName : vmickvpexchange
ServicesDependedOn : {}
ServiceHandle :
Status : Running
ServiceType : Win32OwnProcess, Win32ShareProcess
StartType : Manual
Site :
Container :
Name : vmicrdv
RequiredServices : {}
CanPauseAndContinue : True
CanShutdown : False
CanStop : True
DisplayName : Hyper-V Remote Desktop Virtualization Service
DependentServices : {}
MachineName : .
ServiceName : vmicrdv
ServicesDependedOn : {}
ServiceHandle :
Status : Running
ServiceType : Win32OwnProcess, Win32ShareProcess
StartType : Manual
Site :
Container :
Name : vmicshutdown
RequiredServices : {}
CanPauseAndContinue : True
CanShutdown : False
CanStop : True
DisplayName : Hyper-V Guest Shutdown Service
DependentServices : {}
MachineName : .
ServiceName : vmicshutdown
ServicesDependedOn : {}
ServiceHandle :
Status : Running
ServiceType : Win32OwnProcess, Win32ShareProcess
StartType : Manual
Site :
Container :
Name : vmicvss
RequiredServices : {}
CanPauseAndContinue : True
CanShutdown : False
CanStop : True
DisplayName : Hyper-V Volume Shadow Copy Requestor
DependentServices : {}
MachineName : .
ServiceName : vmicvss
ServicesDependedOn : {}
ServiceHandle :
Status : Running
ServiceType : Win32OwnProcess, Win32ShareProcess
StartType : Manual
Site :
Container :
Name : webthreatdefsvc
RequiredServices : {RpcSs, wtd}
CanPauseAndContinue : True
CanShutdown : True
CanStop : True
DisplayName : Web Threat Defense Service
DependentServices : {}
MachineName : .
ServiceName : webthreatdefsvc
ServicesDependedOn : {RpcSs, wtd}
ServiceHandle :
Status : Running
ServiceType : Win32OwnProcess, Win32ShareProcess
StartType : Manual
Site :
Container :
Name : webthreatdefusersvc_644de
RequiredServices : {}
CanPauseAndContinue : True
CanShutdown : True
CanStop : True
DisplayName : Web Threat Defense User Service_644de
DependentServices : {}
MachineName : .
ServiceName : webthreatdefusersvc_644de
ServicesDependedOn : {}
ServiceHandle :
Status : Running
ServiceType : 240
StartType : Automatic
Site :
Container :
Name : Winmgmt
RequiredServices : {RPCSS}
CanPauseAndContinue : True
CanShutdown : True
CanStop : True
DisplayName : Windows Management Instrumentation
DependentServices : {}
MachineName : .
ServiceName : Winmgmt
ServicesDependedOn : {RPCSS}
ServiceHandle :
Status : Running
ServiceType : Win32OwnProcess, Win32ShareProcess
StartType : Automatic
Site :
Container :
Los saltos de línea naturales pueden producirse en caracteres usados habitualmente, como coma (,) y corchetes de apertura ([), llaves ({) y paréntesis ((). Otros que no son tan comunes incluyen el punto y coma (;), el signo igual (=) y las comillas de apertura simples y dobles (',").
El uso del acento grave (`) como carácter de continuación de línea es un tema controvertido. Es mejor evitarlo si es posible. El uso del acento grave tras un carácter de salto de línea natural es un error común. Esta redundancia no es necesaria y puede desordenado el código.
Los comandos del ejemplo siguiente se ejecutan correctamente desde la consola de PowerShell. Sin embargo, al intentar ejecutarlos en el panel de consola del entorno de scripting integrado (ISE) de PowerShell se produce un error. Esta diferencia se produce porque, a diferencia de la consola de PowerShell, el panel de consola del ISE no prevé automáticamente la continuación de un comando en la línea siguiente. Para evitar este problema, pulse Mayús+Enter en el panel de consola del ISE en lugar de Enter cuando necesite ampliar un comando a varias líneas. Esta combinación de teclas indica al ISE que el comando continúa en la siguiente línea, lo que impide la ejecución que conduce a errores.
Get-Service -Name w32time |
Select-Object -Property *
Name : w32time
RequiredServices : {}
CanPauseAndContinue : False
CanShutdown : True
CanStop : True
DisplayName : Windows Time
DependentServices : {}
MachineName : .
ServiceName : w32time
ServicesDependedOn : {}
ServiceHandle :
Status : Running
ServiceType : Win32OwnProcess, Win32ShareProcess
StartType : Manual
Site :
Container :
Este siguiente ejemplo no se califica como una línea de código de PowerShell porque no es un flujo de trabajo continuo. En su lugar, es dos comandos independientes colocados en una sola línea, separados por un punto y coma. Este punto y coma indica el final de un comando y el principio de otro.
$Service = 'w32time'; Get-Service -Name $Service
Status Name DisplayName
------ ---- -----------
Running w32time Windows Time
Muchos lenguajes de programación y scripting requieren un punto y coma al final de cada línea. Sin embargo, en PowerShell, los punto y coma al final de las líneas son innecesarios y no se recomiendan. Deberías evitarlos para obtener un código más limpio y legible.
Filtro a la izquierda
En este capítulo se muestra cómo filtrar los resultados de varios comandos.
Es un procedimiento recomendado en PowerShell filtrar los resultados lo antes posible en la canalización. Esto implica aplicar filtros mediante parámetros en el comando inicial, normalmente al principio de la canalización. Esto se conoce normalmente como filtrado a la izquierda.
Para ilustrar este concepto, considere el ejemplo siguiente: Use el parámetro Name de Get-Service para filtrar los resultados al principio de la canalización, devolviendo solo los detalles del servicio hora de Windows. Este método muestra una recuperación de datos eficaz, lo que garantiza que solo se devuelve la información necesaria y pertinente.
Get-Service -Name w32time
Status Name DisplayName
------ ---- -----------
Running w32time Windows Time
Es habitual ver ejemplos en línea de un comando de PowerShell que se canaliza al cmdlet Where-Object para filtrar sus resultados. Esta técnica es ineficaz si un comando anterior de la canalización tiene un parámetro para realizar el filtrado.
Get-Service | Where-Object Name -EQ w32time
Status Name DisplayName
------ ---- -----------
Running W32Time Windows Time
En el primer ejemplo se muestra el filtrado directamente en el origen, devolviendo resultados específicamente para el servicio hora de Windows. En cambio, el segundo ejemplo recupera todos los servicios y, a continuación, usa otro comando para filtrar los resultados. Esto puede parecer insignificante en escenarios a pequeña escala, pero considere una situación que implique un conjunto de datos grande, como Active Directory. Es ineficaz recuperar detalles de miles de cuentas de usuario solo para restringirlos a un subconjunto pequeño. Practique filtrar a la izquierda aplicando filtros lo antes posible en la secuencia de comandos, incluso en casos aparentemente triviales. Este hábito garantiza la eficiencia en escenarios más complejos en los que se vuelve más importante.
Secuenciación de comandos para un filtrado eficaz
Hay una idea errónea de que el orden de los comandos en PowerShell es inconsecuente, pero esto es un malentendido. La secuencia en la que organiza comandos, especialmente al filtrar, es importante. Por ejemplo, supongamos que usa Select-Object para elegir propiedades específicas y Where-Object filtrar. En ese caso, es esencial aplicar primero el filtrado. Si no lo hace, es posible que las propiedades necesarias no estén disponibles en la canalización para el filtrado, lo que provoca resultados ineficaces o erróneos.
En el ejemplo siguiente no se producen resultados porque la propiedad CanPauseAndContinue está ausente cuando Select-Object se canaliza a Where-Object. Esto se debe a que la propiedad CanPauseAndContinue no se incluyó en la selección realizada por Select-Object. De hecho, se excluye o filtra.
Get-Service |
Select-Object -Property DisplayName, Running, Status |
Where-Object CanPauseAndContinue
Revertir el orden de Select-Object y Where-Object genera los resultados deseados.
Get-Service |
Where-Object CanPauseAndContinue |
Select-Object -Property DisplayName, Status
DisplayName Status
----------- ------
Workstation Running
Netlogon Running
Hyper-V Heartbeat Service Running
Hyper-V Data Exchange Service Running
Hyper-V Remote Desktop Virtualization Service Running
Hyper-V Guest Shutdown Service Running
Hyper-V Volume Shadow Copy Requestor Running
Web Threat Defense Service Running
Web Threat Defense User Service_644de Running
Windows Management Instrumentation Running
Canalización
Como se ve en muchos ejemplos de este libro, a menudo puede usar la salida de un comando como entrada para otro comando. En el capítulo 3, se usó Get-Member para determinar qué tipo de objeto genera un comando.
En el capítulo 3 también se muestra el uso del parámetro ParameterType de Get-Command para determinar qué comandos aceptaron ese tipo de entrada. En función de lo exhaustiva que sea la ayuda de un comando, puede incluir una sección de ENTRADAS y una de SALIDAS.
La sección ENTRADAS indica que puede canalizar un objeto ServiceController o String al cmdlet Stop-Service.
help Stop-Service -Full
La siguiente salida se abrevia para mostrar la parte relevante de la ayuda.
...
INPUTS
System.ServiceProcess.ServiceController
You can pipe a service object to this cmdlet.
System.String
You can pipe a string that contains the name of a service to this
cmdlet.
OUTPUTS
None
By default, this cmdlet returns no output.
System.ServiceProcess.ServiceController
When you use the PassThru parameter, this cmdlet returns a
ServiceController object representing the service.
...
Sin embargo, no especifica qué parámetros aceptan este tipo de entrada. Puede determinar esa información comprobando los distintos parámetros en la versión completa de la ayuda del cmdlet Stop-Service.
help Stop-Service -Full
Una vez más, solo se muestra la ayuda pertinente en los siguientes resultados. Tenga en cuenta que el parámetro DisplayName no acepta entradas de canalización. El parámetro InputObject acepta la entrada de canalización por valor para objetos ServiceController. El parámetro Name acepta la entrada de canalización por valor para objetos String y entrada de canalización por nombre de propiedad.
...
-DisplayName <System.String[]>
Specifies the display names of the services to stop. Wildcard
characters are permitted.
Required? true
Position? named
Default value None
Accept pipeline input? False
Accept wildcard characters? true
-InputObject <System.ServiceProcess.ServiceController[]>
Specifies ServiceController objects that represent the services to
stop. Enter a variable that contains the objects, or type a command
or expression that gets the objects.
Required? true
Position? 0
Default value None
Accept pipeline input? True (ByValue)
Accept wildcard characters? false
-Name <System.String[]>
Specifies the service names of the services to stop. Wildcard
characters are permitted.
Required? true
Position? 0
Default value None
Accept pipeline input? True (ByPropertyName, ByValue)
Accept wildcard characters? true
...
Al controlar la entrada de canalización, un parámetro que acepta la entrada de canalización por nombre de propiedad y por valor prioriza primero por enlace de por valor. Si se produce un error en este método, intenta procesar la entrada de canalización por nombre de propiedad. Sin embargo, el término por valor puede ser engañoso. Una descripción más precisa es por tipo.
Por ejemplo, si canaliza la salida de un comando que genera un objeto ServiceController para Stop-Service, esta salida se enlaza al parámetro InputObject. Si el comando canalado genera un objeto string Stop-Service enlaza el valor de la propiedad Name a su parámetro Name.
Determine qué tipo de salida genera el comando Get-Service.
Get-Service -Name w32time | Get-Member
Get-Service genera un objeto tipo ServiceController.
TypeName: System.ServiceProcess.ServiceController
Como se muestra en la ayuda del cmdlet Stop-Service, el parámetro InputObject acepta objetos ServiceController a través de la canalización por valor. Esto implica que cuando canaliza la salida del cmdlet Get-Service a Stop-Service, los objetos ServiceController generados por Get-Service enlazan al parámetro InputObject de Stop-Service.
Get-Service -Name w32time | Stop-Service
Ahora pruebe la entrada de cadena. Canalice w32time a Get-Member para confirmar que es una cadena.
'w32time' | Get-Member
TypeName: System.String
En la documentación de ayuda de PowerShell se muestra que, al canalizar una cadena a Stop-Service, se enlaza al parámetro Namepor valor. Realice una prueba práctica para ver esto en acción: canalice la cadena w32time a Stop-Service. En este ejemplo se muestra cómo Stop-Service procesa la cadena w32time como nombre del servicio que se va a detener. Ejecute el siguiente comando para observar este enlace y la ejecución de comandos en acción.
Observe que w32time se incluye entre comillas simples. En PowerShell, se recomienda usar comillas simples para cadenas estáticas, reservando comillas dobles para situaciones en las que la cadena contiene variables que requieren expansión. Las comillas simples indican a PowerShell que trate el contenido literalmente sin analizar las variables. Este enfoque no solo garantiza la precisión en la forma en que el script interpreta la cadena, sino que también mejora el rendimiento, ya que PowerShell gasta menos esfuerzo de procesamiento en cadenas entre comillas simples.
'w32time' | Stop-Service
Cree un objeto personalizado para probar la entrada de la canalización por nombre de propiedad para el parámetro Name de Stop-Service.
$customObject = [pscustomobject]@{
Name = 'w32time'
}
El contenido de la variable CustomObject es un tipo de objeto PSCustomObject y contiene una propiedad denominada Name.
$customObject | Get-Member
TypeName: System.Management.Automation.PSCustomObject
Name MemberType Definition
---- ---------- ----------
Equals Method bool Equals(System.Object obj)
GetHashCode Method int GetHashCode()
GetType Method type GetType()
ToString Method string ToString()
Name NoteProperty string Name=w32time
Al trabajar con variables en PowerShell, como $customObject en este ejemplo, es importante usar comillas dobles si necesita incluir la variable entre comillas. Las comillas dobles permiten la expansión de variables: PowerShell evalúa la variable y usa su valor. Por ejemplo, si incluye $customObject entre comillas dobles y la canaliza a Get-Member, PowerShell procesa el valor de $customObject. Por el contrario, el uso de comillas simples daría lugar a canalizar la cadena literal $customObject a Get-Member, y no el valor de la variable. Esta distinción es importante para escenarios en los que es necesario evaluar el valor de las variables.
Al canalizar el contenido de la variable $customObject al cmdlet Stop-Service, el enlace al parámetro Name se produce mediante nombre de propiedad en lugar de por valor. Esto se debe a que $customObject es un objeto que contiene una propiedad denominada Nombre. En este escenario, PowerShell identifica la propiedad Name dentro de $customObject y utiliza su valor para el parámetro Name de Stop-Service.
Cree otro objeto personalizado mediante un nombre de propiedad diferente, como Service.
$customObject = [pscustomobject]@{
Service = 'w32time'
}
Se produce un error al intentar detener el servicio de w32time canalizando $customObject a Stop-Service. Se produce un error en el enlace de canalización porque $customObject no genera un objeto ServiceController ni un objeto String y no contiene una propiedad Name.
$customObject | Stop-Service
Stop-Service : Cannot find any service with service name
'@{Service=w32time}'.
At line:1 char:17
+ $customObject | Stop-Service
+ ~~~~~~~~~~~~
+ CategoryInfo : ObjectNotFound: (@{Service=w32time}:String) [
Stop-Service], ServiceCommandException
+ FullyQualifiedErrorId : NoServiceFoundForGivenName,Microsoft.PowerShe
ll.Commands.StopServiceCommand
Cuando los nombres de propiedad de salida de un comando no coinciden con los requisitos de entrada de canalización de otro comando, puede usar Select-Object para cambiar el nombre de las propiedades para que se alineen correctamente.
En el ejemplo siguiente, use Select-Object para cambiar el nombre de la propiedad Service a una propiedad denominada Name.
A primera vista, la sintaxis de este ejemplo podría parecer compleja. Sin embargo, es esencial comprender que se necesita más que copiar y pegar código para aprender la sintaxis. En su lugar, tómese el tiempo para escribir el código manualmente. Esta práctica directa te ayuda a recordar la sintaxis y se vuelve más intuitiva con el esfuerzo repetido. El uso de varios monitores o pantalla dividida también puede ayudar en el proceso de aprendizaje. Muestra el código de ejemplo en una pantalla mientras escribe y experimenta activamente con él en otro. Esta configuración facilita el seguimiento y mejora la comprensión y retención de la sintaxis.
$customObject |
Select-Object -Property @{Name='Name';Expression={$_.Service}} |
Stop-Service
Hay instancias en las que es posible que tenga que usar un parámetro que no acepte la entrada de canalización. En tales casos, todavía puede usar la salida de un comando como entrada para otro. En primer lugar, capture y guarde los nombres visibles de algunos servicios específicos de Windows en un archivo de texto. Este paso permite usar los datos guardados como entrada para otro comando.
'Background Intelligent Transfer Service', 'Windows Time' |
Out-File -FilePath $env:TEMP\services.txt
Puede usar paréntesis para pasar la salida de un comando como entrada para un parámetro a otro comando.
Stop-Service -DisplayName (Get-Content -Path $env:TEMP\services.txt)
Este concepto es como el orden de las operaciones en Álgebra. Al igual que las operaciones matemáticas entre paréntesis se calculan primero, el comando entre paréntesis se ejecuta antes del comando externo.
PowerShellGet
PowerShellGet, un módulo incluido con powerShell versión 5.0 y posteriores, proporciona comandos para detectar, instalar, actualizar y publicar módulos de PowerShell y otros elementos en un repositorio de NuGet. Para aquellos que usan PowerShell versión 3.0 y posteriores, PowerShellGet también está disponible como descarga independiente.
La Galería de PowerShell es un repositorio en línea hospedado por Microsoft, diseñado como un centro para compartir módulos, scripts y otros recursos de PowerShell. Aunque Microsoft hospeda la Galería de PowerShell, la comunidad de PowerShell contribuye a la mayoría de los módulos y scripts disponibles. Dado el origen de estos módulos y scripts, tenga cuidado antes de integrar cualquier código de la Galería de PowerShell en su entorno. Revise y pruebe las descargas de la Galería de PowerShell en un entorno de prueba aislado. Este proceso garantiza que el código sea seguro y confiable, funcione según lo previsto y proteja su entorno de posibles problemas o vulnerabilidades derivados del código no edredado.
Muchas organizaciones optan por establecer su propio repositorio interno y privado de NuGet. Este repositorio sirve de doble propósito. En primer lugar, actúa como una ubicación segura para almacenar módulos desarrollados internamente, diseñados únicamente para uso interno. En segundo lugar, proporciona una colección investigada de módulos de origen externo, incluidos los de repositorios públicos. Normalmente, las empresas realizan un proceso de validación exhaustivo antes de agregar estos módulos externos al repositorio interno. Este proceso es importante para asegurarse de que los módulos están libres de contenido malintencionado y se alinean con los estándares operativos y de seguridad de la empresa.
Utilice el cmdlet Find-Module que forma parte del módulo PowerShellGet para buscar un módulo en la Galería de PowerShell que he escrito llamado MrToolkit.
Find-Module -Name MrToolkit
NuGet provider is required to continue
PowerShellGet requires NuGet provider version '2.8.5.201' or newer to
interact with NuGet-based repositories. The NuGet provider must be available
in 'C:\Program Files\PackageManagement\ProviderAssemblies' or
'C:\Users\mikefrobbins\AppData\Local\PackageManagement\ProviderAssemblies'.
You can also install the NuGet provider by running 'Install-PackageProvider
-Name NuGet -MinimumVersion 2.8.5.201 -Force'. Do you want PowerShellGet to
install and import the NuGet provider now?
[Y] Yes [N] No [S] Suspend [?] Help (default is "Y"):
Version Name Repository Description
------- ---- ---------- -----------
1.3 MrToolkit PSGallery Misc PowerShell Tools
La primera vez que use uno de los comandos del módulo PowerShellGet, se le pedirá que instale el proveedor de NuGet.
Para instalar el módulo MrToolkit, canalice el comando anterior a Install-Module.
Find-Module -Name MrToolkit | Install-Module -Scope CurrentUser
Untrusted repository
You are installing the modules from an untrusted repository. If you trust
this repository, change its InstallationPolicy value by running the
Set-PSRepository cmdlet. Are you sure you want to install the modules from
'https://www.powershellgallery.com/api/v2'?
[Y] Yes [A] Yes to All [N] No [L] No to All [S] Suspend [?] Help
(default is "N"):y
Dado que la Galería de PowerShell es un repositorio que no es de confianza, se le pide que apruebe la instalación del módulo.
Búsqueda de la entrada de canalización de forma sencilla
El módulo MrToolkit incluye una función denominada Get-MrPipelineInput. Este cmdlet está diseñado para proporcionar a los usuarios un método práctico para identificar los parámetros de un comando capaz de aceptar la entrada de canalización. En concreto, revela tres aspectos clave:
- Qué parámetros de un comando pueden recibir entradas de canalización
- El tipo de objeto que acepta cada parámetro
- Si aceptan la entrada de canalización por valor o por nombre de propiedad
Esta funcionalidad simplifica drásticamente el proceso de comprensión y uso de las funcionalidades de canalización de comandos de PowerShell.
La información obtenida anteriormente mediante el análisis de la documentación de ayuda se puede determinar mediante esta función.
Get-MrPipelineInput -Name Stop-Service | Format-List
ParameterName : InputObject
ParameterType : System.ServiceProcess.ServiceController[]
ValueFromPipeline : True
ValueFromPipelineByPropertyName : False
ParameterName : Name
ParameterType : System.String[]
ValueFromPipeline : True
ValueFromPipelineByPropertyName : True
Resumen
En este capítulo, aprendiste sobre las complejidades de los comandos de una sola línea en PowerShell. También ha visto que el recuento de líneas físicas de un comando es irrelevante para su clasificación como una sola línea de PowerShell. Además, ha obtenido información sobre conceptos clave, como el filtro hacia la izquierda, la canalización y PowerShellGet.
Revisión
- ¿Qué es un solo liner de PowerShell?
- ¿Cuáles son algunos caracteres en los que pueden producirse saltos de línea naturales en PowerShell?
- ¿Por qué debería filtrar hacia la izquierda?
- ¿Cuáles son las dos maneras en que un comando de PowerShell puede aceptar la entrada de canalización?
- ¿Por qué no debe confiar en los comandos encontrados en la Galería de PowerShell?
Referencias
- about_Pipelines
- acerca_de_Sintaxis_de_Comandos
- acerca_de_Parámetros
- PowerShellGet: la manera BIG EASY de descubrir, instalar y actualizar módulos de PowerShell
Pasos siguientes
En el siguiente capítulo, obtendrá información sobre el formato, los alias, los proveedores y los operadores de comparación.
Colaborar con nosotros en GitHub
El origen de este contenido se puede encontrar en GitHub, donde también puede crear y revisar problemas y solicitudes de incorporación de cambios. Para más información, consulte nuestra guía para colaboradores.
