Condividi tramite

Get-Command

  • Riferimento
Modulo:
Microsoft.PowerShell.Core

Ottiene tutti i comandi.

Sintassi

Get-Command
   [-Verb <String[]>]
   [-Noun <String[]>]
   [-Module <String[]>]
   [-FullyQualifiedModule <ModuleSpecification[]>]
   [-TotalCount <Int32>]
   [-Syntax]
   [-ShowCommandInfo]
   [[-ArgumentList] <Object[]>]
   [-All]
   [-ListImported]
   [-ParameterName <String[]>]
   [-ParameterType <PSTypeName[]>]
   [<CommonParameters>]
Get-Command
   [[-Name] <String[]>]
   [-Module <String[]>]
   [-FullyQualifiedModule <ModuleSpecification[]>]
   [-CommandType <CommandTypes>]
   [-TotalCount <Int32>]
   [-Syntax]
   [-ShowCommandInfo]
   [[-ArgumentList] <Object[]>]
   [-All]
   [-ListImported]
   [-ParameterName <String[]>]
   [-ParameterType <PSTypeName[]>]
   [-UseFuzzyMatching]
   [-FuzzyMinimumDistance <UInt32>]
   [-UseAbbreviationExpansion]
   [<CommonParameters>]

Descrizione

Il Get-Command cmdlet ottiene tutti i comandi installati nel computer, inclusi cmdlet, alias, funzioni, filtri, script e applicazioni. Get-Command ottiene i comandi dai moduli e dai comandi di PowerShell importati da altre sessioni. Per ottenere solo i comandi importati nella sessione corrente, usare il parametro ListImported .

Senza parametri, Get-Command ottiene tutti i cmdlet, le funzioni e gli alias installati nel computer. Get-Command * ottiene tutti i tipi di comandi, inclusi tutti i file non Di PowerShell nella variabile di ambiente Path ($env:Path), che elenca nel tipo di comando Application.

Get-Command che usa il nome esatto del comando, senza caratteri jolly, importa automaticamente il modulo che contiene il comando in modo che sia possibile usare immediatamente il comando. Per abilitare, disabilitare e configurare l'importazione automatica dei moduli, usare la $PSModuleAutoLoadingPreference variabile di preferenza. Per altre informazioni, vedere about_Preference_Variables.

Get-Command ottiene i dati direttamente dal codice del comando, a differenza Get-Helpdi , che ottiene le informazioni dagli argomenti della Guida.

A partire da Windows PowerShell 5.0, i risultati del Get-Command cmdlet visualizzano una colonna Version per impostazione predefinita. È stata aggiunta una nuova proprietà Version alla classe CommandInfo .

Esempio

Esempio 1: Ottenere cmdlet, funzioni e alias

Questo comando ottiene i cmdlet, le funzioni e gli alias di PowerShell installati nel computer.

Get-Command

Esempio 2: Ottenere i comandi nella sessione corrente

Questo comando usa il parametro ListImported per ottenere solo i comandi nella sessione corrente.

Get-Command -ListImported

Esempio 3: Ottenere i cmdlet e visualizzarli in ordine

Questo comando ottiene tutti i cmdlet, li dispone in ordine alfabetico in base al sostantivo incluso nel nome del cmdlet e li visualizza in gruppi basati sui sostantivi. Questa visualizzazione consente di individuare i cmdlet per un'attività.

Get-Command -Type Cmdlet | Sort-Object -Property Noun | Format-Table -GroupBy Noun

Esempio 4: Ottenere i comandi in un modulo

Questo comando usa il parametro Module per ottenere i comandi nei moduli Microsoft.PowerShell.Security e Microsoft.PowerShell.Utility.

Get-Command -Module Microsoft.PowerShell.Security, Microsoft.PowerShell.Utility

Esempio 5: Ottenere informazioni su un cmdlet

Questo comando ottiene informazioni sul Get-AppLockerPolicy cmdlet. Importa anche il modulo AppLocker , che aggiunge tutti i comandi nel modulo AppLocker alla sessione corrente.

Get-Command Get-AppLockerPolicy

Quando un modulo viene importato automaticamente, l'effetto equivale all'uso del cmdlet Import-Module. Il modulo può aggiungere comandi, tipi e file di formattazione ed eseguire script nella sessione. Per abilitare, disabilitare e configurare l'importazione automatica dei moduli, usare la $PSModuleAutoLoadingPreference variabile di preferenza. Per altre informazioni, vedere about_Preference_Variables.

Esempio 6: Ottenere la sintassi di un cmdlet

Questo comando usa i parametri ArgumentList e Syntax per ottenere la sintassi del Get-ChildItem cmdlet quando viene usato nell'unità Cert: . L'unità Cert: è un'unità di PowerShell che il provider di certificati aggiunge alla sessione.

Get-Command  -Name Get-Childitem -Args Cert: -Syntax

Quando si confronta la sintassi visualizzata nell'output con la sintassi visualizzata quando si omette il parametro Args (ArgumentList), si noterà che il provider di certificati aggiunge un parametro dinamico, CodeSigningCert, al Get-ChildItem cmdlet .

Per altre informazioni sul provider di certificati, vedere about_Certificate_Provider.

Esempio 7: Ottenere parametri dinamici

Il comando nell'esempio usa la Get-DynamicParameters funzione per ottenere i parametri dinamici aggiunti dal provider di certificati al Get-ChildItem cmdlet quando viene usato nell'unità Cert: .

function Get-DynamicParameters
{
    param ($Cmdlet, $PSDrive)
    (Get-Command -Name $Cmdlet -ArgumentList $PSDrive).ParameterSets |
      ForEach-Object {$_.Parameters} |
        Where-Object { $_.IsDynamic } |
          Select-Object -Property Name -Unique
}
Get-DynamicParameters -Cmdlet Get-ChildItem -PSDrive Cert:

Name
----
CodeSigningCert

La Get-DynamicParameters funzione in questo esempio ottiene i parametri dinamici di un cmdlet. Si tratta di un'alternativa rispetto al metodo usato nell'esempio precedente. I parametri dinamici possono essere aggiunti a un cmdlet da un altro cmdlet o da un provider.

Esempio 8: Ottenere tutti i comandi di tutti i tipi

Questo comando ottiene tutti i comandi di tutti i tipi nel computer locale, inclusi i file eseguibili nei percorsi della variabile di ambiente Path ($env:path).

Get-Command *

Restituisce un oggetto ApplicationInfo (System.Management.Automation.ApplicationInfo) per ogni file, non un oggetto FileInfo (System.IO.FileInfo).

Esempio 9: Ottenere i cmdlet usando un nome e un tipo di parametro

Questo comando ottiene i cmdlet con un parametro il cui nome include Auth e il cui tipo è AuthenticationMechanism.

Get-Command -ParameterName *Auth* -ParameterType AuthenticationMechanism

È possibile usare un comando simile a questo per trovare i cmdlet che consentono di specificare il metodo usato per autenticare l'utente.

Il parametro ParameterType distingue i parametri che accettano un valore AuthenticationMechanism da quelli che accettano un parametro AuthenticationLevel , anche quando hanno nomi simili.

Esempio 10: Ottenere un alias

In questo esempio viene illustrato come usare il Get-Command cmdlet con un alias.

Get-Command -Name dir

CommandType     Name                                               ModuleName
-----------     ----                                               ----------
Alias           dir -> Get-ChildItem

Anche se in genere viene usato su cmdlet e funzioni, Get-Command ottiene anche script, funzioni, alias e file eseguibili.

L'output del comando mostra la visualizzazione speciale del valore della proprietà Name per gli alias. La visualizzazione mostra l'alias e il nome del comando completo.

Esempio 11: Ottenere la sintassi da un alias

In questo esempio viene illustrato come ottenere la sintassi insieme al nome standard di un alias.

L'output del comando mostra l'alias etichettato con il nome standard, seguito dalla sintassi .

Get-Command -Name dir -Syntax

dir (alias) -> Get-ChildItem

dir [[-Path] <string[]>] [[-Filter] <string>] [-Include <string[]>] [-Exclude <string[]>] [-Recurse] [-Depth <uint>] [-Force] [-Name] [-Attributes <FlagsExpression[FileAttributes]>] [-FollowSymlink] [-Directory] [-File] [-Hidden] [-ReadOnly] [-System] [<CommonParameters>]

dir [[-Filter] <string>] -LiteralPath <string[]> [-Include <string[]>] [-Exclude <string[]>] [-Recurse] [-Depth <uint>] [-Force] [-Name] [-Attributes <FlagsExpression[FileAttributes]>] [-FollowSymlink] [-Directory] [-File] [-Hidden] [-ReadOnly] [-System] [<CommonParameters>]

Esempio 12: Ottenere tutte le istanze del comando Blocco note

In questo esempio viene utilizzato il parametro All del Get-Command cmdlet per visualizzare tutte le istanze del Notepad comando nel computer locale.

Get-Command Notepad -All | Format-Table CommandType, Name, Definition

CommandType     Name           Definition
-----------     ----           ----------
Application     notepad.exe    C:\WINDOWS\system32\notepad.exe
Application     NOTEPAD.EXE    C:\WINDOWS\NOTEPAD.EXE

Il parametro All è utile quando nella sessione sono presenti più comandi con lo stesso nome.

A partire da Windows PowerShell 3.0, per impostazione predefinita, quando la sessione include più comandi con lo stesso nome, Get-Command ottiene solo il comando eseguito quando si digita il nome del comando. Con il parametro All , Get-Command ottiene tutti i comandi con il nome specificato e li restituisce nell'ordine di precedenza dell'esecuzione. Per eseguire un comando diverso dal primo nell'elenco, digitare il percorso completo del comando.

Per altre informazioni sulla precedenza dei comandi, vedere about_Command_Precedence.

Esempio 13: Ottenere il nome di un modulo che contiene un cmdlet

Questo comando ottiene il nome del modulo in cui ha avuto origine il Get-Date cmdlet. Il comando usa la proprietà ModuleName di tutti i comandi.

(Get-Command Get-Date).ModuleName

Microsoft.PowerShell.Utility

Questo formato di comando funziona sui comandi nei moduli di PowerShell, anche se non vengono importati nella sessione.

Esempio 14: Ottenere cmdlet e funzioni con un tipo di output

Get-Command -Type Cmdlet | Where-Object OutputType | Format-List -Property Name, OutputType

Questo comando ottiene i cmdlet e le funzioni per i quali sono stati definiti un tipo di output e il tipo di oggetti che vengono restituiti.

La prima parte del comando ottiene tutti i cmdlet. Un operatore pipeline (|) invia i cmdlet al Where-Object cmdlet , che seleziona solo quelli in cui viene popolata la proprietà OutputType . Un altro operatore pipeline invia gli oggetti cmdlet selezionati al Format-List cmdlet, che visualizza il nome e il tipo di output di ogni cmdlet in un elenco.

La proprietà OutputType di un oggetto CommandInfo ha un valore non Null solo quando il codice del cmdlet definisce l'attributo OutputType per il cmdlet.

Esempio 15: Ottenere cmdlet che accettano un tipo di oggetto specifico come input

Get-Command -ParameterType (((Get-NetAdapter)[0]).PSTypeNames)

CommandType     Name                                               ModuleName
-----------     ----                                               ----------
Function        Disable-NetAdapter                                 NetAdapter
Function        Enable-NetAdapter                                  NetAdapter
Function        Rename-NetAdapter                                  NetAdapter
Function        Restart-NetAdapter                                 NetAdapter
Function        Set-NetAdapter                                     NetAdapter

Questo comando consente di trovare i cmdlet che accettano oggetti scheda di rete come input. È possibile usare questo formato di comando per trovare i cmdlet che accettano il tipo di oggetti restituito da qualsiasi comando.

Il comando usa la proprietà intrinseca PSTypeNames di tutti gli oggetti, che ottiene i tipi che descrivono l'oggetto. Per ottenere la proprietà PSTypeNames di una scheda net e non la proprietà PSTypeNames di una raccolta di net adapter, il comando usa la notazione della matrice per ottenere la prima scheda net restituita dal cmdlet.

Esempio 16: Ottenere i comandi usando una corrispondenza fuzzy

In questo esempio il nome del comando ha deliberatamente un errore di digitamento come 'get-commnd'. Usando l'opzione -UseFuzzyMatching , il cmdlet ha determinato che la corrispondenza migliore è stata Get-Command seguita da altri comandi nativi nel sistema che erano una corrispondenza simile.

Get-Command get-commnd -UseFuzzyMatching

CommandType     Name                                               Version    Source
-----------     ----                                               -------    ------
Cmdlet          Get-Command                                        6.2.0.0    Microsoft.PowerShell.Core
Application     getconf                                            0.0.0.0    /usr/bin/getconf
Application     command                                            0.0.0.0    /usr/bin/command

Parametri

-All

Indica che questo cmdlet ottiene tutti i comandi, inclusi i comandi dello stesso tipo con lo stesso nome. Per impostazione predefinita, Get-Command ottiene solo i comandi eseguiti quando si digita il nome del comando.

Per altre informazioni sul metodo usato da PowerShell per selezionare il comando da eseguire quando più comandi hanno lo stesso nome, vedere about_Command_Precedence. Per informazioni sui nomi dei comandi qualificati dal modulo e sull'esecuzione di comandi che non vengono eseguiti per impostazione predefinita a causa di un conflitto di nomi, vedere about_Modules.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

In Windows PowerShell 2.0 Get-Command ottiene tutti i comandi per impostazione predefinita.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:False
Necessario:False
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-ArgumentList

Specifica una matrice di argomenti. Questo cmdlet ottiene informazioni su un cmdlet o una funzione quando viene usata con i parametri specificati ("argomenti"). L'alias per ArgumentList è Args.

Per rilevare i parametri dinamici disponibili solo quando vengono usati determinati altri parametri, impostare il valore di ArgumentList sui parametri che attivano i parametri dinamici.

Per rilevare i parametri dinamici aggiunti da un provider a un cmdlet, impostare il valore del parametro ArgumentList su un percorso nell'unità del provider, ad esempio WSMan:, HKLM:o Cert:. Quando il comando è un cmdlet del provider PowerShell, immettere un solo percorso in ogni comando. I cmdlet del provider restituiscono solo i parametri dinamici per il primo percorso il valore di ArgumentList. Per informazioni sui cmdlet del provider, vedere about_Providers.

Tipo:Object[]
Alias:Args
Posizione:1
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-CommandType

Specifica i tipi di comandi che ottiene questo cmdlet. Immettere uno o più tipi di comando. Usare CommandType o il relativo alias, Type. Per impostazione predefinita, Get-Command ottiene tutti i cmdlet, le funzioni e gli alias.

I valori validi per questo parametro sono:

  • Alias: ottiene gli alias di tutti i comandi di PowerShell. Per altre informazioni, vedere about_Aliases.

  • All: ottiene tutti i tipi di comando. Questo valore di parametro è l'equivalente di Get-Command *.

  • Application: ottiene i file non di PowerShell nei percorsi elencati nella variabile di ambiente Path ($env:path), inclusi .txti file , .exee .dll . Per altre informazioni sulla variabile di ambiente Path , vedere about_Environment_Variables.

  • Cmdlet: ottiene tutti i cmdlet.

  • ExternalScript: ottiene tutti i .ps1 file nei percorsi elencati nella variabile di ambiente Path ($env:path).

  • Filter e Function: ottiene tutte le funzioni e i filtri avanzati e semplici di PowerShell.

  • Script: ottiene tutti i blocchi di script. Per ottenere script di PowerShell (.ps1 file), usare il ExternalScript valore .

Questi valori sono definiti come enumerazione basata su flag. È possibile combinare più valori per impostare più flag usando questo parametro. I valori possono essere passati al parametro CommandType come matrice di valori o come stringa delimitata da virgole di tali valori. Il cmdlet combina i valori usando un'operazione binary-OR. Il passaggio di valori come matrice è l'opzione più semplice e consente anche di usare il completamento tramite tabulazione sui valori.

Tipo:CommandTypes
Alias:Type
Valori accettati:Alias, Function, Filter, Cmdlet, ExternalScript, Application, Script, Workflow, Configuration, All
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-FullyQualifiedModule

Il valore può essere un nome di modulo, una specifica completa del modulo o un percorso di un file di modulo.

Quando il valore è un percorso, il percorso può essere completo o relativo. Un percorso relativo viene risolto rispetto allo script che contiene l'istruzione using.

Quando il valore è un nome o una specifica del modulo, PowerShell cerca il modulo specificato in PSModulePath .

Una specifica del modulo è una tabella hash con le chiavi seguenti.

  • ModuleName - Obbligatorio Specifica il nome del modulo.

  • GUID - Facoltativo Specifica il GUID del modulo.

  • È anche obbligatorio specificare almeno una delle tre chiavi seguenti.

    • ModuleVersion - Specifica una versione minima accettabile del modulo.

    • MaximumVersion - Specifica la versione massima accettabile del modulo.

    • RequiredVersion - Specifica una versione esatta e obbligatoria del modulo. Non è possibile usare questa opzione con le altre chiavi di versione.

Non è possibile specificare il parametro FullyQualifiedModule nello stesso comando di un parametro Module . I due parametri si escludono a vicenda.

Tipo:ModuleSpecification[]
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-FuzzyMinimumDistance

Questo parametro consente di filtrare i risultati fuzzy in modo che siano più o meno accurati. La distanza viene calcolata usando l'algoritmo Damerau Levenshtein Distance, che indica il numero di passaggi corrisponde al valore originale. Una distanza inferiore è più accurata. Una distanza pari a zero è una corrispondenza esatta.

Tipo:UInt32
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-ListImported

Indica che questo cmdlet ottiene solo i comandi nella sessione corrente.

A partire da PowerShell 3.0, per impostazione predefinita, Get-Command ottiene tutti i comandi installati, tra cui, ma non solo, i comandi nella sessione corrente. In PowerShell 2.0 ottiene solo i comandi nella sessione corrente.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-Module

Specifica una matrice di moduli. Questo cmdlet ottiene i comandi provenienti dai moduli specificati. Immettere i nomi dei moduli o degli oggetti modulo.

Questo parametro accetta valori stringa, ma il valore di questo parametro può anche essere un oggetto PSModuleInfo , ad esempio gli oggetti restituiti dai Get-Module cmdlet e Import-PSSession .

Tipo:String[]
Alias:PSSnapin
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:True
Accettare caratteri jolly:True

-Name

Specifica una matrice di nomi. Questo cmdlet ottiene solo i comandi con il nome specificato. Immettere un nome o un modello di nome. I caratteri jolly sono consentiti.

Per ottenere i comandi con lo stesso nome, usare il parametro All . Quando due comandi hanno lo stesso nome, per impostazione predefinita, Get-Command ottiene il comando che viene eseguito quando si digita il nome del comando.

Tipo:String[]
Posizione:0
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:True
Accettare caratteri jolly:True

-Noun

Specifica una matrice di sostantivi di comando. Questo cmdlet ottiene i comandi, che includono cmdlet, funzioni e alias, con nomi che includono il sostantivo specificato. Immettere uno o più sostantivi o modelli di sostantivo. I caratteri jolly sono consentiti.

Tipo:String[]
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:True
Accettare caratteri jolly:True

-ParameterName

Specifica una matrice di nomi di parametri. Questo cmdlet ottiene i comandi nella sessione con i parametri specificati. Immettere i nomi dei parametri o gli alias dei parametri. I carattere jolly sono supportati.

I parametri ParameterName e ParameterType cercano solo i comandi nella sessione corrente.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

Tipo:String[]
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:True

-ParameterType

Specifica una matrice di nomi di parametri. Questo cmdlet ottiene i comandi nella sessione con parametri del tipo specificato. Immettere il nome completo o parziale di un tipo di parametro. I carattere jolly sono supportati.

I parametri ParameterName e ParameterType cercano solo i comandi nella sessione corrente.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

Tipo:PSTypeName[]
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:True

-ShowCommandInfo

Indica che questo cmdlet visualizza le informazioni sul comando.

Questo parametro è stato introdotto in Windows PowerShell 5.0.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-Syntax

Indica che questo cmdlet ottiene solo i dati specificati seguenti relativi al comando:

  • Alias. Ottiene il nome standard.
  • Cmdlet. Ottiene la sintassi.
  • Funzioni e filtri. Ottiene la definizione della funzione.
  • Script e applicazioni o file. Ottiene il percorso e il nome file.
Tipo:SwitchParameter
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-TotalCount

Specifica il numero di comandi da ottenere. È possibile usare questo parametro per limitare l'output di un comando.

Tipo:Int32
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-UseAbbreviationExpansion

Indica l'uso della corrispondenza dei caratteri nel comando per trovare con caratteri maiuscoli in un comando. Ad esempio, i-psdf corrisponderebbe Import-PowerShellDataFile come ognuno dei caratteri per trovare corrisponde a un carattere maiuscolo nel risultato. Quando si usa questo tipo di corrispondenza, tutti i caratteri jolly non genereranno corrispondenze.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-UseFuzzyMatching

Indica l'uso di un algoritmo di corrispondenza fuzzy durante la ricerca di comandi. L'ordine dell'output è dalla corrispondenza più vicina alla corrispondenza meno probabile. I caratteri jolly non devono essere usati con la corrispondenza fuzzy perché tenteranno di trovare la corrispondenza con i comandi che possono contenere tali caratteri jolly.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-Verb

Specifica una matrice di verbi di comando. Questo cmdlet ottiene i comandi, che includono cmdlet, funzioni e alias, con nomi che includono il verbo specificato. Immettere uno o più verbi o modelli di verbo. I caratteri jolly sono consentiti.

Tipo:String[]
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:True
Accettare caratteri jolly:True

Input

String

È possibile inviare tramite pipe i nomi dei comandi a questo cmdlet.

Output

CommandInfo

Questo cmdlet restituisce oggetti derivati dalla classe CommandInfo . Il tipo di oggetto restituito dipende dal tipo di comando che Get-Command ottiene.

AliasInfo

Rappresenta gli alias.

ApplicationInfo

Rappresenta applicazioni e file.

CmdletInfo

Rappresenta i cmdlet.

FunctionInfo

Rappresenta funzioni e filtri.

Note

PowerShell include gli alias seguenti per Get-Command:

  • Tutte le piattaforme:

    • gcm

  • Quando sono disponibili più comandi con lo stesso nome per la sessione, Get-Command restituisce il comando eseguito quando si digita il nome del comando. Per ottenere i comandi con lo stesso nome, elencati nell'ordine di esecuzione, usare il parametro All . Per altre informazioni, vedere about_Command_Precedence.

  • Quando un modulo viene importato automaticamente, l'effetto equivale all'uso del Import-Module cmdlet . Il modulo può aggiungere comandi, tipi e file di formattazione ed eseguire script nella sessione. Per abilitare, disabilitare e configurare l'importazione automatica dei moduli, usare la $PSModuleAutoLoadingPreference variabile di preferenza. Per altre informazioni, vedere about_Preference_Variables.