about_PSReadLine

Breve descrizione

PSReadLine offre un'esperienza di modifica della riga di comando migliorata nella console di PowerShell.

Descrizione lunga

PSReadLine 2.0 offre una potente esperienza di modifica della riga di comando per la console di PowerShell. Fornisce:

Colorazione della sintassi della riga di comando
Indicazione visiva degli errori di sintassi
Un'esperienza multilinea migliore (modifica e cronologia)
Tasti di scelta rapida personalizzabili
Modalità Cmd ed Emacs
Molte opzioni di configurazione
Completamento dello stile Bash (facoltativo in modalità Cmd, impostazione predefinita in modalità Emacs)
Emacs yank/kill-ring
Spostamento ed eliminazione basata su token di PowerShell

PSReadLine richiede PowerShell 3.0 o versione successiva. PSReadLine funziona con l'host della console predefinito, Visual Studio Code e Terminale finestra. Non funziona in PowerShell ISE.

PSReadLine 2.1.0 viene fornito con PowerShell 7.2 ed è supportato in tutte le versioni supportate di PowerShell. È disponibile per l'installazione da PowerShell Gallery. Per installare PSReadLine 2.1.0 in una versione supportata di PowerShell, eseguire il comando seguente.

Install-Module -Name PSReadLine -RequiredVersion 2.1.0

Nota

A partire da PowerShell 7.0, PowerShell ignora il caricamento automatico di PSReadLine in Windows se viene rilevato un programma per la lettura dello schermo. Attualmente PSReadLine non funziona bene con le utilità per la lettura dello schermo. Il rendering e la formattazione predefiniti di PowerShell 7.0 in Windows funzionano correttamente. Se necessario, è possibile caricare manualmente il modulo.

Le funzioni seguenti sono disponibili nella classe Microsoft.PowerShell.PSConsoleReadLine.

Funzioni di modifica di base

Abortire

Interrompere l'azione corrente, ad esempio: ricerca cronologia incrementale.

Emacs: <Ctrl+g>

AcceptAndGetNext

Tentare di eseguire l'input corrente. Se può essere eseguito (ad esempio AcceptLine), richiamare l'elemento successivo dalla cronologia alla successiva chiamata a ReadLine.

Emacs: <Ctrl+o>

AcceptLine

Tentare di eseguire l'input corrente. Se l'input corrente è incompleto (ad esempio c'è una parentesi chiusa mancante, parentesi quadre o virgolette), la richiesta di continuazione viene visualizzata nella riga successiva e PSReadLine attende che le chiavi modifichino l'input corrente.

Cmd: <Enter>
Emacs: <Enter>
Modalità di inserimento vi: <Enter>

AddLine

Il prompt di continuazione viene visualizzato nella riga successiva e PSReadLine attende che le chiavi modifichino l'input corrente. Ciò è utile per immettere l'input su più righe come singolo comando anche quando una singola riga è completa di input da sola.

Cmd: <Shift+Enter>
Emacs: <Shift+Enter>
Modalità di inserimento vi: <Shift+Enter>
Modalità di comando Vi: <Shift+Enter>

BackwardDeleteChar

Eliminare il carattere prima del cursore.

Cmd: <Backspace>, <Ctrl+h>
Emacs: <Backspace>, <Ctrl+Backspace>, <Ctrl+h>
Modalità di inserimento vi: <Backspace>
Modalità di comando Vi: <X>, <d,h>

BackwardDeleteLine

Come BackwardKillLine: elimina il testo dal punto all'inizio della riga, ma non inserisce il testo eliminato nell'anello di terminazioni.

Cmd: <Ctrl+Home>
Modalità di inserimento vi: <Ctrl+u>, <Ctrl+Home>
Modalità di comando Vi: <Ctrl+u>, <Ctrl+Home>, <d,0>

BackwardDeleteWord

Elimina la parola precedente.

Modalità di comando Vi: <Ctrl+w>, <d,b>

BackwardKillLine

Cancellare l'input dall'inizio dell'input al cursore. Il testo cancellato viene inserito nel kill-ring.

Emacs: <Ctrl+u>, <Ctrl+x,Backspace>

BackwardKillWord

Cancellare l'input dall'inizio della parola corrente al cursore. Se il cursore è compreso tra le parole, l'input viene cancellato dall'inizio della parola precedente al cursore. Il testo cancellato viene inserito nel kill-ring.

Cmd: <Ctrl+Backspace>, <Ctrl+w>
Emacs: <Alt+Backspace>, <Escape,Backspace>
Modalità di inserimento vi: <Ctrl+Backspace>
Modalità di comando Vi: <Ctrl+Backspace>

CancelLine

Annullare l'input corrente, lasciando l'input sullo schermo, ma torna all'host in modo che la richiesta venga valutata di nuovo.

Modalità di inserimento vi: <Ctrl+c>
Modalità di comando Vi: <Ctrl+c>

Copiare

Copiare l'area selezionata negli Appunti di sistema. Se non è selezionata alcuna area, copiare l'intera riga.

Cmd: <Ctrl+C>

CopyOrCancelLine

Se il testo è selezionato, copiare negli Appunti; in caso contrario, annullare la riga.

Cmd: <Ctrl+c>
Emacs: <Ctrl+c>

Tagliare

Elimina l'area selezionata inserendo testo eliminato negli Appunti di sistema.

Cmd: <Ctrl+x>

DeleteChar

Eliminare il carattere sotto il cursore.

Cmd: <Delete>
Emacs: <Delete>
Modalità di inserimento vi: <Delete>
Modalità di comando vi: <Delete>, <x>, <d,l>, <d,Spacebar>

DeleteCharOrExit

Eliminare il carattere sotto il cursore oppure se la riga è vuota, uscire dal processo.

Emacs: <Ctrl+d>

DeleteEndOfBuffer

Elimina fino alla fine del buffer su più righe.

Modalità di comando Vi: <d,G>

DeleteEndOfWord

Elimina alla fine della parola.

Modalità di comando Vi: <d,e>

DeleteLine

Elimina la riga logica corrente di un buffer su più righe, abilitando l'annullamento.

Modalità di comando Vi: <d,d>, <d,_>

DeletePreviousLines

Elimina le righe logiche richieste precedenti e la riga logica corrente in un buffer su più righe.

Modalità di comando Vi: <d,k>

DeleteRelativeLines

Elimina dall'inizio del buffer alla riga logica corrente in un buffer su più righe.

Come la maggior parte dei comandi Vi, il comando <d,g,g> può essere preceduto da un argomento numerico che specifica un numero di riga assoluto, che, insieme al numero di riga corrente, costituisce un intervallo di righe da eliminare. Se non specificato, per impostazione predefinita l'argomento numerico è 1, che fa riferimento alla prima riga logica in un buffer su più righe.

Il numero effettivo di righe da eliminare dalla multilinea viene calcolato come differenza tra il numero di riga logico corrente e l'argomento numerico specificato, che può quindi essere negativo. Di conseguenza, il relativo parte del nome del metodo.

Modalità di comando Vi: <d,g,g>

DeleteNextLines

Elimina la riga logica corrente e le righe logiche richieste successive in un buffer su più righe.

Modalità di comando Vi: <d,j>

DeleteLineToFirstChar

Elimina il testo dal cursore al primo carattere non vuoto della riga.

Modalità di comando Vi: <d,^>

DeleteToEnd

Elimina alla fine della riga.

Modalità di comando Vi: <D>, <d,$>

DeleteWord

Eliminare la parola successiva.

Modalità di comando Vi: <d,w>

ForwardDeleteLine

Come ForwardKillLine: elimina il testo dal punto alla fine della riga, ma non inserisce il testo eliminato nell'anello di terminazioni.

Cmd: <Ctrl+End>
Modalità di inserimento vi: <Ctrl+End>
Modalità di comando Vi: <Ctrl+End>

InsertLineAbove

Viene creata una nuova riga vuota sopra la riga corrente, indipendentemente dalla posizione in cui si trova il cursore sulla riga corrente. Il cursore si sposta all'inizio della nuova riga.

Cmd: <Ctrl+Enter>

InsertLineBelow

Sotto la riga corrente viene creata una nuova riga vuota indipendentemente dalla posizione in cui si trova il cursore nella riga corrente. Il cursore si sposta all'inizio della nuova riga.

Cmd: <Shift+Ctrl+Enter>

InvertCase

Inverti la maiuscola del carattere corrente e passa alla successiva.

Modalità di comando Vi: <~>

KillLine

Cancellare l'input dal cursore alla fine dell'input. Il testo cancellato viene inserito nel kill-ring.

Emacs: <Ctrl+k>

KillRegion

Terminare il testo tra il cursore e il segno.

La funzione non è associato.

KillWord

Cancellare l'input dal cursore alla fine della parola corrente. Se il cursore è compreso tra le parole, l'input viene cancellato dal cursore alla fine della parola successiva. Il testo cancellato viene inserito nel kill-ring.

Cmd: <Alt+d>, <Ctrl+Delete>
Emacs: <Alt+d>, <Escape,d>
Modalità di inserimento vi: <Ctrl+Delete>
Modalità di comando Vi: <Ctrl+Delete>

Incollare

Incollare testo dagli Appunti di sistema.

Cmd: <Ctrl+v>, <Shift+Insert>
Modalità di inserimento vi: <Ctrl+v>
Modalità di comando Vi: <Ctrl+v>

Importante

Quando si usa la funzione incolla , l'intero contenuto del buffer degli Appunti viene incollato nel buffer di input di PSReadLine. Il buffer di input viene quindi passato al parser di PowerShell. L'input incollato usando il dell'applicazione console, fare clic con il pulsante destro del mouse metodo paste viene copiato nel buffer di input un carattere alla volta. Il buffer di input viene passato al parser quando viene copiato un carattere di nuova riga. Di conseguenza, l'input viene analizzato una riga alla volta. La differenza tra i metodi Paste comporta un comportamento di esecuzione diverso.

PasteAfter

Incollare gli Appunti dopo il cursore, spostando il cursore alla fine del testo incollato.

Modalità di comando Vi:

PasteBefore

Incollare gli Appunti prima del cursore, spostando il cursore alla fine del testo incollato.

Modalità di comando Vi:

PrependAndAccept

Anteporre un '#' e accettare la riga.

Modalità di comando Vi: <#>

Rifare

Annullare un'annullamento.

Cmd: <Ctrl+y>
Modalità di inserimento vi: <Ctrl+y>
Modalità di comando Vi: <Ctrl+y>

RepeatLastCommand

Ripetere l'ultima modifica del testo.

Modalità di comando Vi: <.>

RevertLine

Ripristina tutto l'input all'input corrente.

Cmd: <Escape>
Emacs: <Alt+r>, <Escape,r>

ShellBackwardKillWord

La funzione non è associato.

ShellKillWord

La funzione non è associato.

SwapCharacters

Scambia il carattere corrente e quello prima.

Emacs: <Ctrl+t>
Modalità di inserimento vi: <Ctrl+t>
Modalità di comando Vi: <Ctrl+t>

Disfare

Annullare una modifica precedente.

Cmd: <Ctrl+z>
Emacs: <Ctrl+_>, <Ctrl+x,Ctrl+u>
Modalità di inserimento vi: <Ctrl+z>
Modalità di comando Vi: <Ctrl+z>,

AnnullaTutti

Annulla tutte le modifiche precedenti per la riga.

Modalità di comando Vi:

UnixWordRubout

Emacs: <Ctrl+w>

ValidateAndAcceptLine

Emacs: <Ctrl+m>

ViAcceptLine

Accettare la riga e passare alla modalità Inserisci.

Modalità di comando Vi: <Enter>

ViAcceptLineOrExit

Come DeleteCharOrExit in modalità Emacs, ma accetta la riga anziché eliminare un carattere.

Modalità di inserimento vi: <Ctrl+d>
Modalità di comando Vi: <Ctrl+d>

ViAppendLine

Sotto la riga corrente viene inserita una nuova riga.

Modalità di comando Vi: <o>

ViBackwardDeleteGlob

Elimina la parola precedente, utilizzando solo spazi vuoti come delimitatore di parola.

Modalità di comando Vi: <d,B>

ViBackwardGlob

Sposta di nuovo il cursore all'inizio della parola precedente, utilizzando solo spazi vuoti come delimitatori.

Modalità di comando Vi:

ViDeleteBrace

Trovare la parentesi graffa corrispondente, parentesi quadre o parentesi quadre ed eliminare tutto il contenuto all'interno, inclusa la parentesi graffa.

Modalità di comando Vi: <d,%>

ViDeleteEndOfGlob

Elimina alla fine della parola.

Modalità di comando Vi: <d,E>

ViDeleteGlob

Eliminare il glob successivo (parola delimitata da spazi vuoti).

Modalità di comando Vi: <d,W>

ViDeleteToBeforeChar

Elimina fino a quando non viene specificato il carattere.

Modalità di comando Vi: <d,t>

ViDeleteToBeforeCharBackward

Elimina fino a quando non viene specificato il carattere.

Modalità di comando Vi: <d,T>

ViDeleteToChar

Elimina fino a quando non viene specificato il carattere.

Modalità di comando Vi: <d,f>

ViDeleteToCharBackward

Elimina all'indietro fino a quando non viene specificato il carattere.

Modalità di comando Vi: <d,F>

ViInsertAtBegining

Passare alla modalità Inserisci e posizionare il cursore all'inizio della riga.

Modalità di comando Vi:

ViInsertAtEnd

Passare alla modalità Inserisci e posizionare il cursore alla fine della riga.

Modalità di comando Vi: <A>

ViInsertLine

Una nuova riga viene inserita sopra la riga corrente.

Modalità di comando Vi: <O>

ViInsertWithAppend

Accodamento dalla posizione della riga corrente.

Modalità di comando Vi: <a>

ViInsertWithDelete

Eliminare il carattere corrente e passare alla modalità Inserisci.

Modalità di comando Vi: <s>

ViJoinLines

Unisce la riga corrente e la riga successiva.

Modalità di comando Vi: <J>

ViReplaceLine

Cancellare l'intera riga di comando.

Modalità di comando Vi: <S>, <c,c>

ViReplaceToBeforeChar

Sostituisce fino a quando non viene specificato il carattere.

Modalità di comando Vi: <c,t>

ViReplaceToBeforeCharBackward

Sostituisce fino a quando non viene specificato il carattere.

Modalità di comando Vi: <c,T>

ViReplaceToChar

Elimina fino a quando non viene specificato il carattere.

Modalità di comando Vi: <c,f>

ViReplaceToCharBackward

Sostituisce fino a quando non viene specificato il carattere.

Modalità di comando Vi: <c,F>

ViYankBeginningOfLine

Yank dall'inizio del buffer al cursore.

Modalità di comando Vi: <y,0>

ViYankEndOfGlob

Yank dal cursore alla fine delle PAROLE.

Modalità di comando Vi: <y,E>

ViYankEndOfWord

Yank dal cursore alla fine delle parole.

Modalità di comando Vi: <y,e>

ViYankLeft

Caratteri Yank a sinistra del cursore.

Modalità di comando Vi: <y,h>

ViYankLine

Yank l'intero buffer.

Modalità di comando Vi: <y,y>

ViYankNextGlob

Yank dal cursore all'inizio delle parole successive.

Modalità di comando Vi: <y,W>

ViYankNextWord

Yank le parole dopo il cursore.

Modalità di comando Vi: <y,w>

ViYankPercent

Yank da/verso parentesi graffe corrispondenti.

Modalità di comando Vi: <y,%>

ViYankPreviousGlob

Yank dall'inizio delle parole al cursore.

Modalità di comando Vi: <y,B>

ViYankPreviousWord

Yank le parole prima del cursore.

Modalità di comando Vi: <y,b>

ViYankRight

Caratteri Yank sotto e a destra del cursore.

Modalità di comando Vi: <y,l>, <y,Spacebar>

ViYankToEndOfLine

Yank dal cursore alla fine del buffer.

Modalità di comando Vi: <y,$>

ViYankToFirstChar

Yank dal primo carattere non vuoto al cursore.

Modalità di comando Vi: <y,^>

Strattone

Aggiungere il testo terminato più di recente all'input.

Emacs: <Ctrl+y>

YankLastArg

Yank l'ultimo argomento della riga di storia precedente. Con un argomento, la prima volta che viene richiamata, si comporta proprio come YankNthArg. Se richiamato più volte, invece scorre la cronologia e arg imposta la direzione (negativo inverte la direzione).

Cmd: <Alt+.>
Emacs: <Alt+.>, <Alt+_>, <Escape,.>, <Escape,_>

YankNthArg

Yank il primo argomento (dopo il comando) dalla riga di cronologia precedente. Con un argomento, creare il n° argomento (a partire da 0), se l'argomento è negativo, iniziare dall'ultimo argomento.

Emacs: <Ctrl+Alt+y>, <Escape,Ctrl+y>

YankPop

Se l'operazione precedente era Yank o YankPop, sostituire il testo precedentemente yanked con il successivo testo ucciso dal kill-ring.

Emacs: <Alt+y>, <Escape,y>

Funzioni di spostamento del cursore

BackwardChar

Spostare il cursore un carattere a sinistra. Questo può spostare il cursore sulla riga precedente di input su più righe.

Cmd: <LeftArrow>
Emacs: <LeftArrow>, <Ctrl+b>
Modalità di inserimento vi: <LeftArrow>
Modalità di comando Vi: <LeftArrow>, <Backspace>, <h>

IndietroWord

Spostare di nuovo il cursore all'inizio della parola corrente o se tra parole, l'inizio della parola precedente. I limiti di Word sono definiti da un set configurabile di caratteri.

Cmd: <Ctrl+LeftArrow>
Emacs: <Alt+b>, <Escape,b>
Modalità di inserimento vi: <Ctrl+LeftArrow>
Modalità di comando Vi: <Ctrl+LeftArrow>

I caratteri che definiscono i limiti delle parole vengono configurati nella proprietà WordDelimiters dell'oggetto PSConsoleReadLineOptions . Per visualizzare o modificare la proprietà di WordDelimiters , vedere Get-PSReadLineOption e Set-PSReadLineOption.

BeginningOfLine

Se l'input ha più righe, passare all'inizio della riga corrente o, se già all'inizio della riga, passare all'inizio dell'input. Se l'input ha una singola riga, passare all'inizio dell'input.

Cmd: <Home>
Emacs: <Home>, <Ctrl+a>
Modalità di inserimento vi: <Home>
Modalità di comando Vi: <Home>

EndOfLine

Se l'input ha più righe, spostarsi alla fine della riga corrente o, se già alla fine della riga, passare alla fine dell'input. Se l'input ha una singola riga, passare alla fine dell'input.

Cmd: <End>
Emacs: <End>, <Ctrl+e>
Modalità di inserimento vi: <End>

ForwardChar

Spostare il cursore un carattere a destra. Questo può spostare il cursore alla riga successiva di input su più righe.

Cmd: <RightArrow>
Emacs: <RightArrow>, <Ctrl+f>
Modalità di inserimento vi: <RightArrow>
Modalità di comando Vi: <RightArrow>, <Space>, <l>

ForwardWord

Spostare il cursore in avanti fino alla fine della parola corrente, o se tra parole, alla fine della parola successiva. I limiti di Word sono definiti da un set configurabile di caratteri.

Emacs: <Alt+f>, <Escape,f>

GotoBrace

Passare alla parentesi graffa, alla parentesi quadra o alla parentesi quadra corrispondente.

Cmd: <Ctrl+]>
Modalità di inserimento vi: <Ctrl+]>
Modalità di comando Vi: <Ctrl+]>

GotoColumn

Passare alla colonna indicata da arg.

Modalità di comando Vi: <|>

GotoFirstNonBlankOfLine

Spostare il cursore sul primo carattere non vuoto nella riga.

Modalità di comando Vi: <^>, <_>

MoveToEndOfLine

Spostare il cursore alla fine dell'input.

Modalità di comando Vi: <End>, <$>

NextLine

Spostare il cursore alla riga successiva.

La funzione non è associato.

NextWord

Spostare il cursore in avanti fino all'inizio della parola successiva. I limiti di Word sono definiti da un set configurabile di caratteri.

Cmd: <Ctrl+RightArrow>
Modalità di inserimento vi: <Ctrl+RightArrow>
Modalità di comando Vi: <Ctrl+RightArrow>

NextWordEnd

Spostare il cursore in avanti fino alla fine della parola corrente, o se tra parole, alla fine della parola successiva. I limiti di Word sono definiti da un set configurabile di caratteri.

Modalità di comando Vi: <e>

PreviousLine

Spostare il cursore sulla riga precedente.

La funzione non è associato.

ShellBackwardWord

Spostare di nuovo il cursore all'inizio della parola corrente o se tra parole, l'inizio della parola precedente. I limiti di Word sono definiti dai token di PowerShell.

La funzione non è associato.

ShellForwardWord

Spostare il cursore in avanti fino all'inizio della parola successiva. I limiti di Word sono definiti dai token di PowerShell.

La funzione non è associato.

ShellNextWord

Spostare il cursore in avanti fino alla fine della parola corrente, o se tra parole, alla fine della parola successiva. I limiti di Word sono definiti dai token di PowerShell.

La funzione non è associato.

ViBackwardChar

Spostare il cursore a sinistra nella modalità di modifica Vi. Questo può spostare il cursore sulla riga precedente di input su più righe.

Modalità di inserimento vi: <LeftArrow>
Modalità di comando Vi: <LeftArrow>, <Backspace>, <h>

ViBackwardWord

Spostare di nuovo il cursore all'inizio della parola corrente o se tra parole, l'inizio della parola precedente. I limiti di Word sono definiti da un set configurabile di caratteri.

Modalità di comando Vi:

ViForwardChar

Spostare il cursore a destra nella modalità di modifica Vi. Questo può spostare il cursore alla riga successiva di input su più righe.

Modalità di inserimento vi: <RightArrow>
Modalità di comando Vi: <RightArrow>, <Spacebar>, <l>

ViEndOfGlob

Sposta il cursore alla fine della parola, utilizzando solo spazi vuoti come delimitatori.

Modalità di comando Vi: <E>

ViEndOfPreviousGlob

Passa alla fine della parola precedente, utilizzando solo spazi vuoti come delimitatore di parole.

La funzione non è associato.

ViGotoBrace

Simile a GotoBrace, ma è basato su caratteri anziché basato su token.

Modalità di comando Vi: <%>

ViNextGlob

Passa alla parola successiva, utilizzando solo spazi vuoti come delimitatore di parole.

Modalità di comando Vi: <W>

ViNextWord

Spostare il cursore in avanti fino all'inizio della parola successiva. I limiti di Word sono definiti da un set configurabile di caratteri.

Modalità di comando Vi: <w>

Funzioni cronologia

BeginningOfHistory

Passare al primo elemento della cronologia.

Emacs: <Alt+<>

ClearHistory

Cancella la cronologia in PSReadLine. Ciò non influisce sulla cronologia di PowerShell.

Cmd: <Alt+F7>

EndOfHistory

Passare all'ultimo elemento (l'input corrente) nella cronologia.

Emacs: <Alt+>>

ForwardSearchHistory

Eseguire una ricerca incrementale in avanti nella cronologia.

Cmd: <Ctrl+s>
Emacs: <Ctrl+s>

HistorySearchBackward

Sostituire l'input corrente con l'elemento 'previous' della cronologia PSReadLine che corrisponde ai caratteri tra l'inizio e l'input e il cursore.

Cmd: <F8>

HistorySearchForward

Sostituire l'input corrente con l'elemento 'next' della cronologia PSReadLine che corrisponde ai caratteri tra l'inizio e l'input e il cursore.

Cmd: <Shift+F8>

NextHistory

Sostituire l'input corrente con l'elemento 'next' della cronologia di PSReadLine.

Cmd: <DownArrow>
Emacs: <DownArrow>, <Ctrl+n>
Modalità di inserimento vi: <DownArrow>
Modalità di comando Vi: <DownArrow>, <j>, <+>

PreviousHistory

Sostituire l'input corrente con l'elemento 'precedente' della cronologia di PSReadLine.

Cmd: <UpArrow>
Emacs: <UpArrow>, <Ctrl+p>
Modalità di inserimento vi: <UpArrow>
Modalità di comando Vi: <UpArrow>, <k>, <->

ReverseSearchHistory

Eseguire una ricerca incrementale all'indietro nella cronologia.

Cmd: <Ctrl+r>
Emacs: <Ctrl+r>

ViSearchHistoryBackward

Richiede una stringa di ricerca e avvia la ricerca su AcceptLine.

Modalità di inserimento vi: <Ctrl+r>
Modalità di comando Vi: </>, <Ctrl+r>

Funzioni di completamento

Completo

Tentare di eseguire il completamento del testo che circonda il cursore. Se sono presenti più completamenti possibili, per il completamento viene usato il prefisso non ambiguo più lungo. Se si tenta di completare il completamento non ambiguo più lungo, viene visualizzato un elenco di possibili completamenti.

Emacs: <Tab>

MenuComplete

Cmd: <Ctrl+@>, <Ctrl+Spacebar>
Emacs: <Ctrl+Spacebar>

PossibleCompletions

Visualizzare l'elenco dei possibili completamenti.

Emacs: <Alt+=>
Modalità di inserimento vi: <Ctrl+Spacebar>
Modalità di comando Vi: <Ctrl+Spacebar>

TabCompleteNext

Tentare di completare il testo che circonda il cursore con il completamento successivo disponibile.

Cmd: <Tab>
Modalità di comando Vi: <Tab>

TabCompletePrevious

Tentare di completare il testo che circonda il cursore con il completamento disponibile precedente.

Cmd: <Shift+Tab>
Modalità di comando Vi: <Shift+Tab>

ViTabCompleteNext

Termina il gruppo di modifica corrente, se necessario, e richiama TabCompleteNext.

Modalità di inserimento vi: <Tab>

ViTabCompletePrevious

Termina il gruppo di modifica corrente, se necessario, e richiama TabCompletePrevious.

Modalità di inserimento vi: <Shift+Tab>

Funzioni varie

AcceptNextSuggestionWord

Accettare la parola successiva del suggerimento inline o selezionato.

La funzione non è associato.

AcceptSuggestion

Accettare il suggerimento corrente inline o selezionato.

La funzione non è associato.

CaptureScreen

Avviare l'acquisizione di schermata interattiva: le frecce su/giù selezionano le righe, immettere copie del testo selezionato negli Appunti come testo e HTML.

La funzione non è associato.

ClearScreen

Cancellare la schermata e disegnare la linea corrente nella parte superiore dello schermo.

Cmd: <Ctrl+l>
Emacs: <Ctrl+l>
Modalità di inserimento vi: <Ctrl+l>
Modalità di comando Vi: <Ctrl+l>

DigitArgument

Avviare un nuovo argomento di cifra da passare ad altre funzioni. È possibile usarlo come moltiplicatore per la funzione successiva richiamata da un tasto di scelta rapida. Ad esempio, premendo il valore argomento cifre viene impostato su 10. Premere quindi il tasto # invia 10 caratteri # (##########) alla riga di input. Analogamente, è possibile usarlo con altre operazioni, ad esempio <Delete> o Left-Arrow.

Cmd: <Alt+0>, <Alt+1>, <Alt+2>, <Alt+3>, <Alt+4>, <Alt+5>, <Alt+6>, <Alt+7>, <Alt+8>, <Alt+9>, <Alt+->
Emacs: <Alt+0>, <Alt+1>, <Alt+2>, <Alt+3>, <Alt+4>, <Alt+5>, <Alt+6>, <Alt+7>, <Alt+8>, <Alt+9>, <Alt+->
Modalità di comando Vi: <0>, <1>, <2>, <3>, <4>, <5>, <6>, <7>, <8>, <9>

InvokePrompt

Cancella il prompt corrente e chiama la funzione prompt per riprodurre nuovamente il prompt. Utile per i gestori di chiavi personalizzati che modificano lo stato. Ad esempio, modificare la directory corrente.

La funzione non è associato.

ScrollDisplayDown

Scorrere la visualizzazione verso il basso di una schermata.

Cmd: <PageDown>
Emacs: <PageDown>

ScrollDisplayDownLine

Scorrere la visualizzazione verso il basso di una riga.

Cmd: <Ctrl+PageDown>
Emacs: <Ctrl+PageDown>

ScrollDisplayToCursor

Scorrere la visualizzazione fino al cursore.

Emacs: <Ctrl+End>

ScrollDisplayTop

Scorrere la visualizzazione fino alla parte superiore.

Emacs: <Ctrl+Home>

ScrollDisplayUp

Scorrere lo schermo verso l'alto di una schermata.

Cmd: <PageUp>
Emacs: <PageUp>

ScrollDisplayUpLine

Scorrere la visualizzazione verso l'alto di una riga.

Cmd: <Ctrl+PageUp>
Emacs: <Ctrl+PageUp>

SelfInsert

Inserire la chiave.

La funzione non è associato.

ShowKeyBindings

Mostra tutte le chiavi associate.

Cmd: <Ctrl+Alt+?>
Emacs: <Ctrl+Alt+?>
Modalità di inserimento vi: <Ctrl+Alt+?>

ViCommandMode

Passare dalla modalità operativa corrente da Vi-Insert a Vi-Command.

Modalità di inserimento vi: <Escape>

ViDigitArgumentInChord

Avviare un nuovo argomento di cifra da passare ad altre funzioni mentre in uno degli accordi di vi.

La funzione non è associato.

ViEditVisually

Modificare la riga di comando in un editor di testo specificato da $env:EDITOR o $env:VISUAL.

Emacs: <Ctrl+x,Ctrl+e>
Modalità di comando Vi: <v>

ViExit

Esce dalla shell.

La funzione non è associato.

ViInsertMode

Passare alla modalità Di inserimento.

Modalità di comando Vi:

WhatIsKey

Leggere una chiave e indicare a cosa è associata la chiave.

Cmd: <Alt+?>
Emacs: <Alt+?>

Funzioni di selezione

ExchangePointAndMark

Il cursore viene posizionato nella posizione del contrassegno e il segno viene spostato nella posizione del cursore.

Emacs: <Ctrl+x,Ctrl+x>

SelectAll (Seleziona tutto)

Selezionare l'intera riga.

Cmd: <Ctrl+a>

SelectBackwardChar

Regolare la selezione corrente per includere il carattere precedente.

Cmd: <Shift+LeftArrow>
Emacs: <Shift+LeftArrow>

SelectBackwardsLine

Regolare la selezione corrente in modo da includere dal cursore all'inizio della riga.

Cmd: <Shift+Home>
Emacs: <Shift+Home>

SelectBackwardWord

Regolare la selezione corrente in modo da includere la parola precedente.

Cmd: <Shift+Ctrl+LeftArrow>
Emacs: <Alt+B>

SelectForwardChar

Regolare la selezione corrente per includere il carattere successivo.

Cmd: <Shift+RightArrow>
Emacs: <Shift+RightArrow>

SelectForwardWord

Regolare la selezione corrente in modo da includere la parola successiva usando ForwardWord.

Emacs: <Alt+F>

SelectLine

Regolare la selezione corrente in modo da includere dal cursore alla fine della riga.

Cmd: <Shift+End>
Emacs: <Shift+End>

SelectNextWord

Regolare la selezione corrente per includere la parola successiva.

Cmd: <Shift+Ctrl+RightArrow>

SelezionareShellBackwardWord

Regolare la selezione corrente per includere la parola precedente usando ShellBackwardWord.

La funzione non è associato.

SelezionareShellForwardWord

Regolare la selezione corrente per includere la parola successiva usando ShellForwardWord.

La funzione non è associato.

SelezionareShellAvantiWord

Regolare la selezione corrente per includere la parola successiva usando ShellNextWord.

La funzione non è associato.

SetMark

Contrassegnare la posizione corrente del cursore da usare in un comando di modifica successivo.

Emacs: <Ctrl+@>

Funzioni IntelliSense predittive

Nota

Per usare queste funzioni, è necessario abilitare IntelliSense predittivo.

AcceptNextWordSuggestion

Accetta la parola successiva del suggerimento inline da IntelliSense predittivo. Questa funzione può essere associata con CTRL+F eseguendo il comando seguente.

Set-PSReadLineKeyHandler -Chord "Ctrl+f" -Function ForwardWord

AcceptSuggestion

Accetta il suggerimento inline corrente da Predictive IntelliSense premendo RightArrow quando il cursore si trova alla fine della riga corrente.

Funzioni di ricerca

CharacterSearch

Leggere un carattere e cercare in avanti l'occorrenza successiva di tale carattere. Se viene specificato un argomento, cercare avanti (o indietro, se negativo) per l'ennesima occorrenza.

Cmd: <F3>
Emacs: <Ctrl+]>
Modalità di inserimento vi: <F3>
Modalità di comando Vi: <F3>

CharacterSearchBackward

Leggere un carattere e cercare all'indietro l'occorrenza successiva di tale carattere. Se viene specificato un argomento, eseguire la ricerca all'indietro (o avanti se negativo) per l'ennesima occorrenza.

Cmd: <Shift+F3>
Emacs: <Ctrl+Alt+]>
Modalità di inserimento vi: <Shift+F3>
Modalità di comando Vi: <Shift+F3>

RepeatLastCharSearch

Ripetere l'ultima ricerca di caratteri registrata.

Modalità di comando Vi: <;>

RepeatLastCharSearchBackwards

Ripetere l'ultima ricerca di caratteri registrata, ma nella direzione opposta.

Modalità di comando Vi: <,>

RepeatSearch

Ripetere l'ultima ricerca nella stessa direzione di prima.

Modalità di comando Vi: <n>

RepeatSearchBackward

Ripetere l'ultima ricerca nella stessa direzione di prima.

Modalità di comando Vi: <N>

SearchChar

Leggere il carattere successivo e quindi trovarlo, andare avanti e quindi tornare indietro di un carattere. Questo vale per la funzionalità 't'.

Modalità di comando Vi: <f>

SearchCharBackward

Leggere il carattere successivo e quindi trovarlo, tornare indietro e quindi tornare indietro di un carattere. Questo è per la funzionalità 'T'.

Modalità di comando Vi: <F>

SearchCharBackwardWithBackoff

Leggere il carattere successivo e quindi trovarlo, tornare indietro e quindi tornare indietro di un carattere. Questo è per la funzionalità 'T'.

Modalità di comando Vi: <T>

SearchCharWithBackoff

Leggere il carattere successivo e quindi trovarlo, andare avanti e quindi tornare indietro di un carattere. Questo vale per la funzionalità 't'.

Modalità di comando Vi: <t>

SearchForward

Richiede una stringa di ricerca e avvia la ricerca su AcceptLine.

Modalità di inserimento vi: <Ctrl+s>
Modalità di comando Vi: <?>, <Ctrl+s>

Tasti di scelta rapida personalizzati

PSReadLine supporta associazioni di chiavi personalizzate usando il cmdlet Set-PSReadLineKeyHandler. La maggior parte delle associazioni di tasti personalizzate chiama una delle funzioni precedenti, ad esempio

Set-PSReadLineKeyHandler -Key UpArrow -Function HistorySearchBackward

È possibile associare un oggetto ScriptBlock a una chiave. ScriptBlock può eseguire praticamente qualsiasi operazione desiderata. Alcuni esempi utili includono

modificare la riga di comando
apertura di una nuova finestra (ad esempio, guida)
modificare le directory senza modificare la riga di comando

ScriptBlock riceve due argomenti:

$key: oggetto [ConsoleKeyInfo] che rappresenta la chiave che ha attivato l'associazione personalizzata. Se si associa lo stesso ScriptBlock a più chiavi ed è necessario eseguire azioni diverse a seconda della chiave, è possibile controllare $key. Molte associazioni personalizzate ignorano questo argomento.
$arg: argomento arbitrario. Nella maggior parte dei casi, si tratta di un argomento integer che l'utente passa dalle associazioni di chiave DigitArgument. Se l'associazione non accetta argomenti, è ragionevole ignorare questo argomento.

Di seguito viene illustrato un esempio che aggiunge una riga di comando alla cronologia senza eseguirla. Ciò è utile quando ci si rende conto di aver dimenticato di eseguire un'operazione, ma non si vuole immettere nuovamente la riga di comando già immessa.

$parameters = @{
    Key = 'Alt+w'
    BriefDescription = 'SaveInHistory'
    LongDescription = 'Save current line in history but do not execute'
    ScriptBlock = {
      param($key, $arg)   # The arguments are ignored in this example

      # GetBufferState gives us the command line (with the cursor position)
      $line = $null
      $cursor = $null
      [Microsoft.PowerShell.PSConsoleReadLine]::GetBufferState([ref]$line,
        [ref]$cursor)

      # AddToHistory saves the line in history, but does not execute it.
      [Microsoft.PowerShell.PSConsoleReadLine]::AddToHistory($line)

      # RevertLine is like pressing Escape.
      [Microsoft.PowerShell.PSConsoleReadLine]::RevertLine()
  }
}
Set-PSReadLineKeyHandler @parameters

È possibile visualizzare molti altri esempi nel file SamplePSReadLineProfile.ps1 installato nella cartella del modulo PSReadLine.

La maggior parte dei tasti di scelta rapida usa alcune funzioni helper per la modifica della riga di comando. Queste API sono documentate nella sezione successiva.

API di supporto per l'associazione di chiavi personalizzate

Le funzioni seguenti sono pubbliche in Microsoft.PowerShell.PSConsoleReadLine, ma non possono essere associate direttamente a una chiave. La maggior parte è utile nelle associazioni di tasti personalizzate.

void AddToHistory(string command)

Aggiungere una riga di comando alla cronologia senza eseguirla.

void ClearKillRing()

Cancellare l'anello di morte. Questa operazione viene usata principalmente per i test.

void Delete(int start, int length)

Eliminare i caratteri di lunghezza dall'inizio. Questa operazione supporta l'annullamento/rollforward.

void Ding()

Eseguire l'azione Ding in base alle preferenze degli utenti.

void GetBufferState([ref] string input, [ref] int cursor)
void GetBufferState([ref] Ast ast, [ref] Token[] tokens,
  [ref] ParseError[] parseErrors, [ref] int cursor)

Queste due funzioni recuperano informazioni utili sullo stato corrente del buffer di input. Il primo è più comunemente usato per i casi semplici. Il secondo viene usato se l'associazione esegue un'operazione più avanzata con Ast.

IEnumerable[Microsoft.PowerShell.KeyHandler]
  GetKeyHandlers(bool includeBound, bool includeUnbound)

IEnumerable[Microsoft.PowerShell.KeyHandler]
  GetKeyHandlers(string[] Chord)

Queste due funzioni vengono usate da Get-PSReadLineKeyHandler. Il primo viene usato per ottenere tutti i tasti di scelta rapida. Il secondo viene usato per ottenere associazioni di tasti specifiche.

Microsoft.PowerShell.PSConsoleReadLineOptions GetOptions()

Questa funzione viene usata da Get-PSReadLineOption e probabilmente non è troppo utile in un'associazione di tasti personalizzata.

void GetSelectionState([ref] int start, [ref] int length)

Se non è presente alcuna selezione nella riga di comando, la funzione restituisce -1 sia all'inizio che alla lunghezza. Se è presente una selezione nella riga di comando, viene restituita la lunghezza e l'inizio della selezione.

void Insert(char c)
void Insert(string s)

Inserire un carattere o una stringa nel cursore. Questa operazione supporta l'annullamento/rollforward.

string ReadLine(runspace remoteRunspace,
  System.Management.Automation.EngineIntrinsics engineIntrinsics)

Si tratta del punto di ingresso principale di PSReadLine. Non supporta la ricorsione, pertanto non è utile in un'associazione di tasti personalizzata.

void RemoveKeyHandler(string[] key)

Questa funzione viene usata da Remove-PSReadLineKeyHandler e probabilmente non è troppo utile in un'associazione di tasti personalizzata.

void Replace(int start, int length, string replacement)

Sostituire parte dell'input. Questa operazione supporta l'annullamento/rollforward. Questa opzione è preferibile rispetto a Elimina seguita da Inserisci perché viene considerata come una singola azione per l'annullamento.

void SetCursorPosition(int cursor)

Spostare il cursore sull'offset specificato. Lo spostamento del cursore non viene rilevato per l'annullamento.

void SetOptions(Microsoft.PowerShell.SetPSReadLineOption options)

Questa funzione è un metodo helper usato dal cmdlet Set-PSReadLineOption, ma potrebbe essere utile per un'associazione di tasti personalizzata che desidera modificare temporaneamente un'impostazione.

bool TryGetArgAsInt(System.Object arg, [ref] int numericArg,
  int defaultNumericArg)

Questo metodo helper viene usato per associazioni personalizzate che rispettano DigitArgument. Una chiamata tipica ha un aspetto simile al seguente

[int]$numericArg = 0
[Microsoft.PowerShell.PSConsoleReadLine]::TryGetArgAsInt($arg,
  [ref]$numericArg, 1)

Note

Cronologia comandi

PSReadLine gestisce un file di cronologia contenente tutti i comandi e i dati immessi dalla riga di comando. I file di cronologia sono un file denominato $($host.Name)_history.txt. Nei sistemi Windows il file di cronologia viene archiviato in $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine. Nei sistemi non Windows i file di cronologia vengono archiviati in $env:XDG_DATA_HOME/powershell/PSReadLine o $env:HOME/.local/share/powershell/PSReadLine.

La cronologia può contenere dati sensibili, incluse le password. PSReadLine tenta di filtrare le informazioni riservate. Le righe di comando contenenti le stringhe seguenti non vengono scritte nel file di cronologia.

parola d’ordine
asplaintext
token
apikey
segreto

Feedback & contribuire a PSReadLine

PSReadLine in GitHub

È possibile inviare una richiesta pull o inviare commenti e suggerimenti nella pagina GitHub.

Vedere anche

PSReadLine è fortemente influenzato dalla libreria gnu readline.

Ultimo aggiornamento: 2022-03-02