Condividi tramite

PSReadLine

  • Articolo

about_PSReadLine

DESCRIZIONE BREVE

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

DESCRIZIONE LUNGA

PSReadLine 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
  • Movimento e terminamento basato su token di PowerShell

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

Spostamento cursore

EndOfLine

  • Cmd: <End>
  • Emacs: <End> o <Ctrl+E>

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.

BeginningOfLine

  • Cmd: <Home>
  • Emacs: <Home> o <Ctrl+A>

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.

NextLine

  • Cmd: unbound
  • Emacs: unbound

Spostare il cursore alla riga successiva se l'input ha più righe.

PreviousLine

  • Cmd: unbound
  • Emacs: unbound

Spostare il cursore sulla riga precedente se l'input ha più righe.

ForwardChar

  • Cmd: <RightArrow>
  • Emacs: <RightArrow> o <Ctrl+F>

Spostare il cursore un carattere a destra. Questo potrebbe spostare il cursore alla riga successiva dell'input su più righe.

BackwardChar

  • Cmd: <LeftArrow>
  • Emacs: <LeftArrow> o <Ctrl+B>

Spostare il cursore un carattere a sinistra. Questo potrebbe spostare il cursore nella riga precedente di input su più righe.

ForwardWord

  • Cmd: unbound
  • Emacs: <Alt+F>

Spostare il cursore verso la fine della parola corrente o, se tra le parole, alla fine della parola successiva. È possibile impostare caratteri delimitatori di parola con:

Set-PSReadLineOption -WordDelimiters `<string of delimiter characters>`

NextWord

  • Cmd: <Ctrl+RightArrow>
  • Emacs: unbound

Spostare il cursore avanti all'inizio della parola successiva. È possibile impostare caratteri delimitatori di parola con:

Set-PSReadLineOption -WordDelimiters `<string of delimiter characters>`

BackwardWord

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

Spostare di nuovo il cursore all'inizio della parola corrente oppure, se tra le parole, l'inizio della parola precedente. È possibile impostare caratteri delimitatori di parola con:

Set-PSReadLineOption -WordDelimiters `<string of delimiter characters>`

ShellForwardWord

  • Cmd: unbound
  • Emacs: unbound

Analogamente a ForwardWord, ad eccezione dei limiti delle parole, vengono definiti dai limiti del token di PowerShell.

ShellNextWord

  • Cmd: unbound
  • Emacs: unbound

Analogamente a NextWord, ad eccezione dei limiti delle parole, vengono definiti dai limiti del token di PowerShell.

ShellBackwardWord

  • Cmd: unbound
  • Emacs: unbound

Analogamente a BackwardWord, ad eccezione dei limiti delle parole, sono definiti dai limiti del token di PowerShell.

GotoBrace

  • Cmd: <Ctrl+}>
  • Emacs: unbound

Passare alla parentesi corrispondente, parentesi graffa o parentesi quadrata.

AddLine

  • Cmd: <Shift-Enter>
  • Emacs: <Shift-Enter>

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 è l'input completo da solo.

Modifica di base

CancelLine

  • Cmd: unbound
  • Emacs: unbound

Annullare tutte le modifiche alla riga, lasciare la riga di input sullo schermo, ma tornare da PSReadLine senza eseguire l'input.

RevertLine

  • Cmd: <ESC>
  • Emacs: <Alt+R>

Ripristina tutto l'input dall'ultimo input accettato ed eseguito. Equivale all'uso del comando Annulla finché non viene lasciato nulla per annullare.

BackwardDeleteChar

  • Cmd: <Backspace>
  • Emacs: <Backspace> o <Ctrl+H>

Eliminare il carattere prima del cursore.

DeleteChar

  • Cmd: <Delete>
  • Emacs: <Delete>

Eliminare il carattere sotto il cursore.

DeleteCharOrExit

  • Cmd: unbound
  • Emacs: <Ctrl+D>

Come DeleteChar, a meno che la riga non sia vuota, in questo caso uscire dal processo.

AcceptLine

  • Cmd: <Enter>
  • Emacs: <Enter> o <Ctrl+M>

Tentare di eseguire l'input corrente. Se l'input corrente è incompleto (ad esempio, esiste una parentesi di chiusura, parentesi quadre o virgolette mancanti), il prompt di continuazione viene visualizzato nella riga successiva e PSReadLine attende che le chiavi vengano modificate dall'input corrente.

AcceptAndGetNext

  • Cmd: unbound
  • Emacs: <Ctrl+O>

Come AcceptLine, ma dopo il completamento della riga, iniziare a modificare la riga successiva dalla cronologia.

ValidateAndAcceptLine

  • Cmd: unbound
  • Emacs: unbound

Come AcceptLine, ma esegue una convalida aggiuntiva, tra cui:

  • Verifica la presenza di errori di analisi aggiuntivi
  • Convalida che i nomi dei comandi siano tutti trovati
  • Se si esegue PowerShell 4.0 o versione successiva, convalida i parametri e gli argomenti

Se si verificano errori, il messaggio di errore viene visualizzato e non è stato accettato né aggiunto alla cronologia, a meno che non si corregge la riga di comando o si esequisi accettoLine o ValidateAndAcceptLine nuovamente mentre viene visualizzato il messaggio di errore.

BackwardDeleteLine

  • Cmd: <Ctrl+Home>
  • Emacs: unbound

Eliminare il testo dall'inizio dell'input al cursore.

ForwardDeleteLine

  • Cmd: <Ctrl+End>
  • Emacs: unbound

Eliminare il testo dal cursore alla fine dell'input.

SelectBackwardChar

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

Modificare la selezione corrente per includere il carattere precedente.

SelectForwardChar

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

Modificare la selezione corrente per includere il carattere successivo.

SelectBackwardWord

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

Modificare la selezione corrente per includere la parola precedente.

SelectForwardWord

  • Cmd: unbound
  • Emacs: <Alt+Shift+F>

Modificare la selezione corrente per includere la parola successiva usando ForwardWord.

SelectNextWord

  • Cmd: <Shift+Ctrl+RightArrow>
  • Emacs: unbound

Modificare la selezione corrente per includere la parola successiva usando NextWord.

SelezionareShellForwardWord

  • Cmd: unbound
  • Emacs: unbound

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

SelezionareShellNextWord

  • Cmd: unbound
  • Emacs: unbound

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

SelezionareShellBackwardWord

  • Cmd: unbound
  • Emacs: unbound

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

SelectBackwardsLine

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

Modificare la selezione corrente da includere dal cursore all'inizio della riga.

Selectline

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

Modificare la selezione corrente da includere dal cursore alla fine della riga.

SelectAll

  • Cmd: <Ctrl+A>
  • Emacs: unbound

Selezionare l'intera riga. Sposta il cursore alla fine della riga.

SelfInsert

  • Cmd: <a>, <b>...
  • Emacs: <a>, <b>...

Inserire la chiave immessa.

Ripeti

  • Cmd: <Ctrl+Y>
  • Emacs: unbound

Ripetere un inserimento o un'eliminazione annullata da Annulla.

Annulla

  • Cmd: <Ctrl+Z>
  • Emacs: <Ctrl+_>

Annullare un inserimento o un'eliminazione precedenti.

Cronologia

ClearHistory

  • Cmd: <Alt+F7>
  • Emacs: unbound

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

PrecedenteHistory

  • Cmd: <UpArrow>
  • Emacs: <UpArrow> o <Ctrl+P>

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

NextHistory

  • Cmd: <DownArrow>
  • Emacs: <DownArrow> o <Ctrl+N>

Sostituire l'input corrente con l'elemento successivo dalla cronologia di PSReadLine.

ForwardSearchHistory

  • Cmd: <Ctrl+S>
  • Emacs: <Ctrl+S>

Search in avanti dalla riga di cronologia corrente in modo interattivo.

ReverseSearchHistory

  • Cmd: <Ctrl+R>
  • Emacs: <Ctrl+R>

Search indietro rispetto alla riga di cronologia corrente in modo interattivo.

HistorySearchBackward

  • Cmd: <F8>
  • Emacs: unbound

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

HistorySearchForward

  • Cmd: <Shift+F8>
  • Emacs: unbound

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

BeginningOfHistory

  • Cmd: unbound
  • Emacs: <Alt+<>

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

EndOfHistory

  • Cmd: unbound
  • Emacs: <Alt+>>

Sostituire l'input corrente con l'ultimo elemento nella cronologia di PSReadLine, ovvero l'input possibilmente vuoto immesso prima di tutti i comandi della cronologia.

Completamento tramite tabulazione

TabCompleteNext

  • Cmd: <Tab>
  • Emacs: unbound

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

TabCompletePrevious

  • Cmd: <Shift-Tab>
  • Emacs: unbound

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

Operazione completata

  • Cmd: unbound
  • Emacs: <Tab>

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

  • Cmd: <Ctrl+Space>
  • Emacs: <Ctrl+Space>

Tentare di eseguire il completamento sul testo che circonda il cursore. Se sono presenti più completamenti possibili, viene visualizzato un elenco di possibili completamenti ed è possibile selezionare il completamento corretto usando i tasti di direzione oppure TAB/MAIUSC+TAB. Premere CTRL+G per annullare la selezione del menu e ripristinare lo stato della riga prima di richiamare MenuComplete.

PossibleCompletions

  • Cmd: unbound
  • Emacs: <Alt+Equals>

Visualizzare l'elenco dei possibili completamenti.

SetMark

  • Cmd: unbound
  • Emacs: <Alt+Space>

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

ExchangePointAndMark

  • Cmd: unbound
  • Emacs: <Ctrl+X,Ctrl+X>

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

Kill/Yank

Kill e Yank operano su un Appunti nel modulo PSReadLine. C'è un buffer circolare denominato kill ring - il testo ucciso viene aggiunto all'anello kill up e yank copierà il testo dalla kill più recente. YankPop scorre gli elementi nell'anello kill. Quando l'anello kill è pieno, i nuovi elementi sostituiscono gli elementi meno recenti. Un'operazione di terminazione immediatamente preceduta da un'altra operazione di terminazione aggiunge l'interruzione precedente, anziché aggiungere un nuovo elemento o sostituire un elemento nell'anello di terminazione. Questo è il modo in cui è possibile tagliare una parte di una linea, ad esempio, con più operazioni KillWord, quindi strapparle altrove come un singolo yank.

KillLine

  • Cmd: unbound
  • Emacs: <Ctrl+K>

Cancellare l'input dal cursore alla fine della riga. Il testo cancellato viene inserito nell'anello kill.

BackwardKillLine

  • Cmd: unbound
  • Emacs: <Ctrl+U> o <Ctrl+X,Backspace>

Cancellare l'input dall'inizio dell'input al cursore. Il testo cancellato viene inserito nell'anello kill.

KillWord

  • Cmd: unbound
  • Emacs: <Alt+D>

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 nell'anello kill.

BackwardKillWord

  • Cmd: unbound
  • Emacs: <Alt+Backspace>

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 nell'anello kill.

ShellKillWord

  • Cmd: unbound
  • Emacs: unbound

Come KillWord, ad eccezione dei limiti delle parole sono definiti dai limiti del token di PowerShell.

ShellBackwardKillWord

  • Cmd: unbound
  • Emacs: unbound

Analogamente a BackwardKillWord, ad eccezione dei limiti delle parole sono definiti dai limiti del token di PowerShell.

UnixWordRubout

  • Cmd: unbound
  • Emacs: <Ctrl+W>

Analogamente a BackwardKillWord, ad eccezione dei limiti delle parole sono definiti da spazi vuoti.

KillRegion

  • Cmd: unbound
  • Emacs: unbound

Terminare il testo tra il cursore e il segno.

Copia

  • Cmd: <Ctrl+Shift+C>
  • Emacs: unbound

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

CopyOrCancelLine

  • Cmd: <Ctrl+C>
  • Emacs: <Ctrl+C>

Copiare il testo selezionato negli Appunti oppure, se non è selezionato alcun testo, annullare la modifica della riga con CancelLine.

Taglia

  • Cmd: <Ctrl+X>
  • Emacs: unbound

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

Yankee

  • Cmd: unbound
  • Emacs: <Ctrl+Y>

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

YankPop

  • Cmd: unbound
  • Emacs: <Alt+Y>

Se l'operazione precedente era Yank o YankPop, sostituire il testo precedentemente eliminato con il testo ucciso successivo dall'anello kill.

ClearKillRing

  • Cmd: unbound
  • Emacs: unbound

Il contenuto dell'anello kill viene cancellato.

Incolla

  • Cmd: <Ctrl+V>
  • Emacs: unbound

Questo è simile a Yank, ma usa gli Appunti di sistema invece dell'anello kill.

[! IMPORTANTE]

Quando si usa la funzione Paste , 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 metodo incollato con il pulsante destro del mouse dell'applicazione console 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.

YankLastArg

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

Inserire l'ultimo argomento del comando precedente nella cronologia. Le operazioni ripetute sostituiscono l'ultimo argomento inserito con l'ultimo argomento del comando precedente (quindi ALT+. ALT+. inserirà l'ultimo argomento del secondo all'ultima riga della cronologia.

Con un argomento, la prima volta YankLastArg si comporta come YankNthArg. Un argomento negativo sulle successive chiamate YankLastArg cambia la direzione durante l'attraversamento della cronologia. Ad esempio, se si preme ALT+. un numero eccessivo di volte, è possibile digitare ALT+- ALT+. per invertire la direzione.

Gli argomenti sono basati sui token di PowerShell.

YankNthArg

  • Cmd: unbound
  • Emacs: <Alt+Ctrl+Y>

Inserire il primo argomento (non il nome del comando) del comando precedente nella cronologia.

Con un argomento, inserire l'n° argomento in cui 0 è in genere il comando . Gli argomenti negativi iniziano dalla fine.

Gli argomenti sono basati sui token di PowerShell.

Varie

Interruzione

  • Cmd: unbound
  • Emacs: <Ctrl+G>

Interrompere l'azione corrente; Ad esempio, interrompere la ricerca nella cronologia interattiva. Non annulla l'input, ad esempio CancelLine.

CharacterSearch

  • Cmd: <F3>
  • Emacs: <Ctrl+]>

Legge una chiave e cerca in avanti per tale carattere. Con un argomento, cercare in avanti l'n occorrenza di tale argomento. Con un argomento negativo, esegue la ricerca all'indietro.

CharacterSearchBackward

  • Cmd: <Shift+F3>
  • Emacs: <Alt+Ctrl+]>

Come CharacterSearch, ma esegue ricerche all'indietro. Con un argomento negativo, esegue la ricerca in avanti.

ClearScreen

  • Cmd: <Ctrl+L>
  • Emacs: <Ctrl+L>

Cancella la schermata e visualizza la richiesta e l'input correnti nella parte superiore della schermata.

DigitArgument

  • Cmd: unbound
  • Emacs: <Alt+[0..9]>,<any char>,<Alt+->

Usato per passare argomenti numerici a funzioni come CharacterSearch o YankNthArg. Alt+- attiva o disattiva l'argomento in modo che sia negativo/non negativo. Per immettere 80 caratteri '*', è possibile digitare ALT+8 ALT+0 *.

CaptureScreen

  • Cmd: unbound
  • Emacs: unbound

Copia le righe selezionate negli Appunti in formati di testo e RTF. Usare i tasti freccia su/giù per la prima riga da selezionare, quindi MAIUSC+SuArrow/MAIUSC+GiùArrow per selezionare più righe. Dopo aver selezionato, premere INVIO per copiare il testo. Escape/CTRL+C/CTRL+G annulla l'operazione, quindi non viene copiato nulla negli Appunti.

InvokePrompt

  • Cmd: unbound
  • Emacs: unbound

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 la modifica della directory corrente.

WhatIsKey

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

Leggere una chiave o un accordo e visualizzare l'associazione di tasti.

ShowKeyBindings

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

Mostra tutte le chiavi attualmente associate.

ScrollDisplayUp

  • Cmd: <PageUp>
  • Emacs: <PageUp>

Scorrere la visualizzazione verso l'alto di una schermata.

ScrollDisplayUpLine

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

Scorrere la visualizzazione verso l'alto di una riga.

ScrollDisplayDown

  • Cmd: <PageDown>
  • Emacs: <PageDown>

Scorrere la visualizzazione verso il basso di una schermata.

ScrollDisplayDownLine

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

Scorrere la visualizzazione verso il basso di una riga.

ScrollDisplayTop

  • Cmd: unbound
  • Emacs: <Ctrl+Home>

Scorrere la visualizzazione fino alla parte superiore.

ScrollDisplayToCursor

  • Cmd: unbound
  • Emacs: <Ctrl+End>

Scorrere la visualizzazione fino al cursore.

Tasti di scelta rapida personalizzati

PSReadLine supporta associazioni di chiavi personalizzate tramite 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 uno 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 dai tasti di scelta rapida DigitArgument. Se l'associazione non accetta argomenti, è ragionevole ignorare questo argomento.

Esaminiamo 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 modificare la riga di comando. Queste API sono documentate nella sezione successiva.

API di supporto dell'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 nei tasti di scelta rapida personalizzati.

void AddToHistory(string command)

Aggiungere una riga di comando alla cronologia senza eseguirla.

void ClearKillRing()

Cancella l'anello di morte. Viene usato 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)

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

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, verrà restituito -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)

NOTA

COMPATIBILITÀ DI POWERSHELL

PSReadLine richiede PowerShell 3.0 o versione successiva e l'host della console. Non funziona in PowerShell ISE. Funziona nella console di Visual Studio Code.

CRONOLOGIA COMANDI

PSReadLine gestisce un file di cronologia contenente tutti i comandi e i dati immessi dalla riga di comando. Può contenere dati sensibili, incluse le password. Ad esempio, se si usa il ConvertTo-SecureString cmdlet la password viene registrata nel file di cronologia come testo normale. 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.

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 di lettura GNU.