about_PSReadLine

Kort beskrivning

PSReadLine ger en förbättrad kommandoradsredigering i PowerShell-konsolen.

Lång beskrivning

PSReadLine 2.1 ger en kraftfull kommandoradsredigeringsupplevelse för PowerShell-konsolen. Den tillhandahåller:

• Syntaxfärgning för kommandoraden
• En visuell indikation på syntaxfel
• En bättre flerradsupplevelse (både redigering och historik)
• Anpassningsbara nyckelbindningar
• Cmd- och Emacs-lägen
• Många konfigurationsalternativ
• Slutförande av Bash-format (valfritt i cmd-läge, standard i Emacs-läge)
• Emacs kill-ring
• PowerShell-tokenbaserad "ordförflyttning och borttagning"
• Förutsägande IntelliSense

PSReadLine kräver PowerShell 3.0 eller nyare. PSReadLine fungerar med standardkonsolvärd, Visual Studio Code och Windows Terminal. Det fungerar inte i PowerShell ISE.

PSReadLine 2.1.0 levereras med PowerShell 7.2 och stöds i alla versioner av PowerShell som stöds. Det går att installera från PowerShell-galleriet. Kör följande kommando för att installera PSReadLine 2.1.0 i en version av PowerShell som stöds.

PSReadLine 2.2.0 (beta) har lagt till två nya prediktiva IntelliSense-funktioner:

• Parametern PredictionViewStyle har lagts till för att tillåta valet av den nya ListView .
• Ansluten PSReadLine till API:erna som introducerades i PS 7.1 för att tillåta att en användare kan importera en förutsägelsemodul som kan återge förslagen CommandPrediction från en anpassad källa.

Install-Module -Name PSReadLine -AllowPrerelease

Förutsägande IntelliSense

Predictive IntelliSense är ett tillägg till begreppet tab-slutförande som hjälper användaren att slutföra kommandon. Det gör det möjligt för användare att identifiera, redigera och köra fullständiga kommandon baserat på matchande förutsägelser från användarens historik och ytterligare domänspecifika plugin-program.

Aktivera Predictive IntelliSense

Predictive IntelliSense är inaktiverat som standard. Om du vill aktivera förutsägelser kör du bara följande kommando:

Set-PSReadLineOption -PredictionSource History

Parametern PredictionSource kan också acceptera plugin-program för domänspecifika och anpassade krav.

Om du vill inaktivera Predictive IntelliSense kör du bara:

Set-PSReadLineOption -PredictionSource None

Följande funktioner är tillgängliga i klassen Microsoft.PowerShell.PSConsoleReadLine.

Grundläggande redigeringsfunktioner

Avbryta

Avbryt den aktuella åtgärden, till exempel inkrementell historiksökning.

• Emacs: <Ctrl+g>

AcceptAndGetNext

Försök att köra aktuella indata. Om den kan köras (t.ex. AcceptLine) återkallar du nästa objekt från historiken nästa gång ReadLine anropas.

• Emacs: <Ctrl+o>

AcceptLine

Försök att köra aktuella indata. Om aktuella indata är ofullständiga (till exempel om det saknas en avslutande parentes, hakparentes eller citattecken) visas fortsättningsprompten på nästa rad och PSReadLine väntar på att nycklar ska redigera aktuella indata.

• Cmd: <Enter>
• Emacs: <Enter>
• Vi-infogningsläge: <Enter>

AddLine

Fortsättningsfråga visas på nästa rad och PSReadLine väntar på att nycklar ska redigera aktuella indata. Detta är användbart för att ange indata med flera linjer som ett enda kommando även när en enskild rad är fullständig indata på egen hand.

• Cmd: <Shift+Enter>
• Emacs: <Shift+Enter>
• Vi-infogningsläge: <Shift+Enter>
• Vi-kommandoläge: <Shift+Enter>

BackwardDeleteChar

Ta bort tecknet före markören.

• Cmd: <Backspace> , <Ctrl+h>
• Emacs: <Backspace> , <Ctrl+Backspace> , <Ctrl+h>
• Vi-infogningsläge: <Backspace>
• Vi-kommandoläge: <X> , <d,h>

BackwardDeleteInput

Precis som BackwardKillInput – tar bort text från punkten till början av indata, men lägger inte till den borttagna texten i kill-ringen.

• Cmd: <Ctrl+Home>
• Vi-infogningsläge: <Ctrl+u> , <Ctrl+Home>
• Vi-kommandoläge: <Ctrl+u> , <Ctrl+Home>

BackwardDeleteLine

Precis som BackwardKillLine – tar bort text från punkten till början av raden, men lägger inte till den borttagna texten i kill-ringen.

• Vi-kommandoläge: <d,0>

BackwardDeleteWord

Tar bort föregående ord.

• Vi-kommandoläge: <Ctrl+w> , <d,b>

BackwardKillInput

Rensa texten från början av indata till markören. Den rensade texten placeras i kill-ringen.

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

BackwardKillLine

Rensa texten från början av den aktuella logiska raden till markören. Den rensade texten placeras i kill-ringen.

• Funktionen är obunden.

BackwardKillWord

Rensa indata från början av det aktuella ordet till markören. Om markören är mellan ord rensas indata från början av föregående ord till markören. Den rensade texten placeras i kill-ringen.

• Cmd: <Ctrl+Backspace> , <Ctrl+w>
• Emacs: <Alt+Backspace> , <Escape,Backspace>
• Vi-infogningsläge: <Ctrl+Backspace>
• Vi-kommandoläge: <Ctrl+Backspace>

CancelLine

Avbryt aktuella indata och lämna indata på skärmen, men återgår till värden så att frågan utvärderas igen.

• Vi-infogningsläge: <Ctrl+c>
• Vi-kommandoläge: <Ctrl+c>

Kopiera

Kopiera den valda regionen till Urklipp i systemet. Om ingen region har valts kopierar du hela raden.

• Cmd: <Ctrl+C>

CopyOrCancelLine

Om text är markerad kopierar du till Urklipp, annars avbryter du raden.

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

Klipp ut

Ta bort markerad region och placera bortd text i Urklipp i systemet.

• Cmd: <Ctrl+x>

Ta bortdiagram

Ta bort tecknet under markören.

• Cmd: <Delete>
• Emacs: <Delete>
• Vi-infogningsläge: <Delete>
• Vi-kommandoläge: <Delete> , <x> , <d,l> , <d,Spacebar>

DeleteCharOrExit

Ta bort tecknet under markören eller avsluta processen om raden är tom.

• Emacs: <Ctrl+d>

DeleteEndOfBuffer

Tar bort i slutet av flerradsbufferten.

• Vi-kommandoläge: <d,G>

DeleteEndOfWord

Ta bort i slutet av ordet.

• Vi-kommandoläge: <d,e>

DeleteLine

Tar bort den aktuella logiska raden i en flerradsbuffert, vilket aktiverar ångra.

• Vi-kommandoläge: <d,d> , <d,_>

DeletePreviousLines

Tar bort de tidigare begärda logiska raderna och den aktuella logiska raden i en flerradsbuffert.

• Vi-kommandoläge: <d,k>

DeleteRelativeLines

Tar bort från början av bufferten till den aktuella logiska raden i en flerradsbuffert.

Som de flesta Vi-kommandon kan kommandot läggas till i ett numeriskt argument som anger ett absolut radnummer, som tillsammans med det aktuella radnumret utgör ett radintervall som <d,g,g> ska tas bort. Om det inte anges används standardvärdet 1 för det numeriska argumentet, som refererar till den första logiska raden i en flerradsbuffert.

Det faktiska antalet rader som ska tas bort från flera rader beräknas som skillnaden mellan det aktuella logiska radnumret och det angivna numeriska argumentet, vilket kan vara negativt. Därav den relativa delen av metodnamnet.

• Vi-kommandoläge: <d,g,g>

DeleteNextLines

Tar bort den aktuella logiska raden och nästa begärda logiska rader i en flerradsbuffert.

• Vi-kommandoläge: <d,j>

DeleteLineToFirstChar

Tar bort från det första icke-tomma tecknet på den aktuella logiska raden i en flerradsbuffert.

• Vi-kommandoläge: <d,^>

DeleteToEnd

Ta bort i slutet av raden.

• Vi-kommandoläge: <D> , <d,$>

DeleteWord

Ta bort nästa ord.

• Vi-kommandoläge: <d,w>

ForwardDeleteInput

Precis som KillLine – tar bort text från punkten till slutet av indata, men lägger inte till den borttagna texten i kill-ring.

• Cmd: <Ctrl+End>
• Vi-infogningsläge: <Ctrl+End>
• Vi-kommandoläge: <Ctrl+End>

ForwardDeleteLine

Tar bort text från punkten till slutet av den aktuella logiska raden, men lägger inte till den borttagna texten i kill-ringen.

• Funktionen är obunden

InsertLineAbove

En ny tom rad skapas ovanför den aktuella raden oavsett var markören finns på den aktuella raden. Markören flyttas till början av den nya raden.

• Cmd: <Ctrl+Enter>

InsertLineBelow

En ny tom rad skapas under den aktuella raden oavsett var markören finns på den aktuella raden. Markören flyttas till början av den nya raden.

• Cmd: <Shift+Ctrl+Enter>

Invertera

Invertera fallet med det aktuella tecknet och gå till nästa.

• Vi-kommandoläge: <~>

KillLine

Rensa indata från markören till slutet av indata. Den rensade texten placeras i kill-ringen.

• Emacs: <Ctrl+k>

KillRegion

Kill the text between the cursor and the mark.

• Funktionen är obunden.

KillWord

Rensa indata från markören till slutet av det aktuella ordet. Om markören är mellan ord rensas indata från markören till slutet av nästa ord. Den rensade texten placeras i kill-ringen.

• Cmd: <Alt+d> , <Ctrl+Delete>
• Emacs: <Alt+d> , <Escape,d>
• Vi-infogningsläge: <Ctrl+Delete>
• Vi-kommandoläge: <Ctrl+Delete>

Klistra in

Klistra in text från Urklipp i systemet.

• Cmd: <Ctrl+v> , <Shift+Insert>
• Vi-infogningsläge: <Ctrl+v>
• Vi-kommandoläge: <Ctrl+v>

PasteAfter

Klistra in Urklipp efter markören och flytta markören till slutet av den inklistrad texten.

• Vi-kommandoläge: <p>

PasteBefore

Klistra in Urklipp före markören och flytta markören till slutet av den inklistrad texten.

• Vi-kommandoläge: <P>

PrependAndAccept

Lägg till ett #-värde och acceptera raden.

• Vi-kommandoläge: <#>

Gör om

Ångra en ångrande.

• Cmd: <Ctrl+y>
• Vi-infogningsläge: <Ctrl+y>
• Vi-kommandoläge: <Ctrl+y>

RepeatLastCommand

Upprepa den senaste textändringen.

• Vi-kommandoläge: <.>

RevertLine

Återställer alla indata till aktuella indata.

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

ShellBackwardKillWord

Rensa indata från början av det aktuella ordet till markören. Om markören är mellan ord rensas indata från början av föregående ord till markören. Den rensade texten placeras i kill-ringen.

Funktionen är obunden.

ShellKillWord

Rensa indata från markören till slutet av det aktuella ordet. Om markören är mellan ord rensas indata från markören till slutet av nästa ord. Den rensade texten placeras i kill-ringen.

Funktionen är obunden.

SwapCharacters

Växla det aktuella tecknet och det före det.

• Emacs: <Ctrl+t>
• Vi-infogningsläge: <Ctrl+t>
• Vi-kommandoläge: <Ctrl+t>

Ångra

Ångra en tidigare redigering.

• Cmd: <Ctrl+z>
• Emacs: <Ctrl+_> , <Ctrl+x,Ctrl+u>
• Vi-infogningsläge: <Ctrl+z>
• Vi-kommandoläge: <Ctrl+z> , <u>

ÅngraAlla

Ångra alla tidigare redigeringar för raden.

• Vi-kommandoläge: <U>

UnixWordRubout

Rensa indata från början av det aktuella ordet till markören. Om markören är mellan ord rensas indata från början av föregående ord till markören. Den rensade texten placeras i kill-ringen.

• Emacs: <Ctrl+w>

ValidateAndAcceptLine

Försök att köra aktuella indata. Om aktuella indata är ofullständiga (till exempel om det saknas en avslutande parentes, hakparentes eller citattecken) visas fortsättningsprompten på nästa rad och PSReadLine väntar på att nycklar ska redigera aktuella indata.

• Emacs: <Ctrl+m>

ViAcceptLine

Acceptera raden och växla till Infogningsläge.

• Vi-kommandoläge: <Enter>

ViAcceptLineOrExit

Precis som DeleteCharOrExit i Emacs-läge, men accepterar raden i stället för att ta bort ett tecken.

• Vi-infogningsläge: <Ctrl+d>
• Vi-kommandoläge: <Ctrl+d>

ViAppendLine

En ny rad infogas under den aktuella raden.

• Vi-kommandoläge: <o>

ViBackwardDeleteGlob

Tar bort föregående ord med endast blanksteg som avgränsare.

• Vi-kommandoläge: <d,B>

ViBackwardGlob

Flyttar markören tillbaka till början av föregående ord, med endast blanksteg som avgränsare.

• Vi-kommandoläge: <B>

ViDeleteBrace

Hitta den matchande klammerparentesen, parentesen eller hakparentesen och ta bort allt innehåll inom klammerparentesen.

• Vi-kommandoläge: <d,%>

ViDeleteEndOfGlob

Ta bort i slutet av ordet.

• Vi-kommandoläge: <d,E>

ViDeleteGlob

Ta bort nästa glob (blanksteg avgränsat ord).

• Vi-kommandoläge: <d,W>

ViDeleteToBeforeChar

Tar bort tills det angivna tecknet.

• Vi-kommandoläge: <d,t>

ViDeleteToBeforeCharBackward

Tar bort tills det angivna tecknet.

• Vi-kommandoläge: <d,T>

ViDeleteToChar

Tar bort tills det angivna tecknet.

• Vi-kommandoläge: <d,f>

ViDeleteToCharBackward

Tar bort bakåt tills det angivna tecknet har getts.

• Vi-kommandoläge: <d,F>

ViInsertAtBegining

Växla till Infogningsläge och placera markören i början av raden.

• Vi-kommandoläge: <I>

ViInsertAtEnd

Växla till Infogningsläge och placera markören i slutet av raden.

• Vi-kommandoläge: <A>

ViInsertLine

En ny rad infogas ovanför den aktuella raden.

• Vi-kommandoläge: <O>

ViInsertWithAppend

Lägg till från den aktuella radpositionen.

• Vi-kommandoläge: <a>

ViInsertWithDelete

Ta bort det aktuella tecknet och växla till Infogningsläge.

• Vi-kommandoläge: <s>

ViJoinLines

Ansluter till den aktuella raden och nästa rad.

• Vi-kommandoläge: <J>

ViReplaceLine

Radera hela kommandoraden.

• Vi-kommandoläge: <S> , <c,c>

ViReplaceToBeforeChar

Ersätter tills det angivna tecknet.

• Vi-kommandoläge: <c,t>

ViReplaceToBeforeCharBackward

Ersätter tills det angivna tecknet.

• Vi-kommandoläge: <c,T>

ViReplaceToChar

Tar bort tills det angivna tecknet.

• Vi-kommandoläge: <c,f>

ViReplaceToCharBackward

Ersätter tills det angivna tecknet.

• Vi-kommandoläge: <c,F>

ViDiagramkBeginningOfLine

– Från början av bufferten till markören.

• Vi-kommandoläge: <y,0>

ViGenkEndOfGlob

Piltangenten från markören till slutet av WORD(erna).

• Vi-kommandoläge: <y,E>

ViRankkEndOfWord

Piltangenten från markören till slutet av ordet/orden.

• Vi-kommandoläge: <y,e>

ViRankkLeft

Character(s) till vänster om markören.

• Vi-kommandoläge: <y,h>

ViRankkLine

– Hela bufferten.

• Vi-kommandoläge: <y,y>

ViGenkNextGlob

Piltangenten från markören till början av nästa WORD(er).

• Vi-kommandoläge: <y,W>

ViJankNextWord

Använd ordet(erna) efter markören.

• Vi-kommandoläge: <y,w>

ViGenkPercent

– från matchande kparentes.

• Vi-kommandoläge: <y,%>

ViRankkPreviousGlob

Från början av WORD(erna) till markören.

• Vi-kommandoläge: <y,B>

ViRankkPreviousWord

Använd ordet(erna) före markören.

• Vi-kommandoläge: <y,b>

ViRankkRight

Tecken under och till höger om markören.

• Vi-kommandoläge: <y,l> , <y,Spacebar>

ViDiagramkToEndOfLine

– från markören till slutet av bufferten.

• Vi-kommandoläge: <y,$>

ViChargekToFirstChar

Från det första blankstegstecknet till markören.

• Vi-kommandoläge: <y,^>

Ryck

Lägg till den senast avlivade texten i indata.

• Emacs: <Ctrl+y>

TruckkLastArg

Det sista argumentet från den tidigare historikraden. Med ett argument fungerar första gången det anropas, precis som MedkNthArg. Om den anropas flera gånger itererar den i stället genom historiken och arg anger riktningen (negativ inverterar riktningen).)

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

TruckkNthArg

Det första argumentet (efter kommandot) från den tidigare historikraden. Med ett argument kan du starta det n:e argumentet (med början från 0) om argumentet är negativt från det sista argumentet.

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

Så här gör du med PåkPop

Om den tidigare åtgärden var Såk eller Så ersätter du den tidigare bebodda texten med nästa avlivade text från kill-ringen.

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

Markörförflyttningsfunktioner

Bakåtdiagram

Flytta markören ett tecken till vänster. Detta kan flytta markören till föregående rad med flerradsinmatning.

• Cmd: <LeftArrow>
• Emacs: <LeftArrow> , <Ctrl+b>
• Vi-infogningsläge: <LeftArrow>
• Vi-kommandoläge: <LeftArrow> , <Backspace> , <h>

BackwardWord

Flytta markören tillbaka till början av det aktuella ordet, eller om det är mellan ord, början av föregående ord. Ordgränser definieras av en konfigurerbar uppsättning tecken.

• Cmd: <Ctrl+LeftArrow>
• Emacs: <Alt+b> , <Escape,b>
• Vi-infogningsläge: <Ctrl+LeftArrow>
• Vi-kommandoläge: <Ctrl+LeftArrow>

BeginningOfLine

Om indata har flera rader, flytta till början av den aktuella raden, eller om de redan finns i början av raden, flytta till början av indata. Om indata har en enda rad går du till början av indata.

• Cmd: <Home>
• Emacs: <Home> , <Ctrl+a>
• Vi-infogningsläge: <Home>
• Vi-kommandoläge: <Home>

EndOfLine

Om indata har flera rader, flytta till slutet av den aktuella raden, eller om de redan finns i slutet av raden, flytta till slutet av indata. Om indata har en enda rad går du till slutet av indata.

• Cmd: <End>
• Emacs: <End> , <Ctrl+e>
• Vi-infogningsläge: <End>

ForwardChar

Flytta markören ett tecken till höger. Detta kan flytta markören till nästa rad med flerradsinmatning.

• Cmd: <RightArrow>
• Emacs: <RightArrow> , <Ctrl+f>
• Vi-infogningsläge: <RightArrow>
• Vi-kommandoläge: <RightArrow> , <Space> , <l>

ForwardWord

Flytta markören framåt till slutet av det aktuella ordet, eller om det är mellan ord, till slutet av nästa ord. Ordgränser definieras av en konfigurerbar uppsättning tecken.

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

Gå tillBrace

Gå till matchande klammerparentes, parentes eller hakparentes.

• Cmd: <Ctrl+]>
• Vi-infogningsläge: <Ctrl+]>
• Vi-kommandoläge: <Ctrl+]>

GotoColumn

Flytta till kolumnen som anges av arg.

• Vi-kommandoläge: <|>

GotoFirstNonBlankOfLine

Flytta markören till det första icke-tomma tecknet på raden.

• Vi-kommandoläge: <^> , <_>

MoveToEndOfLine

Flytta markören till slutet av indata.

• Vi-kommandoläge: <End> , <$>

NextLine

Flytta markören till nästa rad.

• Funktionen är obunden.

NextWord

Flytta markören framåt till början av nästa ord. Ordgränser definieras av en konfigurerbar uppsättning tecken.

• Cmd: <Ctrl+RightArrow>
• Vi-infogningsläge: <Ctrl+RightArrow>
• Vi-kommandoläge: <Ctrl+RightArrow>

NextWordEnd

Flytta markören framåt till slutet av det aktuella ordet, eller om det är mellan ord, till slutet av nästa ord. Ordgränser definieras av en konfigurerbar uppsättning tecken.

• Vi-kommandoläge: <e>

PreviousLine

Flytta markören till föregående rad.

• Funktionen är obunden.

ShellBackwardWord

Flytta markören tillbaka till början av det aktuella ordet, eller om det är mellan ord, början av föregående ord. Ordgränser definieras av PowerShell-token.

• Funktionen är obunden.

ShellForwardWord

Flytta markören framåt till början av nästa ord. Ordgränser definieras av PowerShell-token.

• Funktionen är obunden.

ShellNextWord

Flytta markören framåt till slutet av det aktuella ordet, eller om det är mellan ord, till slutet av nästa ord. Ordgränser definieras av PowerShell-token.

• Funktionen är obunden.

ViBackwardChar

Flytta markören ett tecken till vänster i redigeringsläget Vi. Detta kan flytta markören till föregående rad med flerradsinmatning.

• Vi-infogningsläge: <LeftArrow>
• Vi-kommandoläge: <LeftArrow> , <Backspace> , <h>

ViBackwardWord

Flytta markören tillbaka till början av det aktuella ordet, eller om det är mellan ord, början av föregående ord. Ordgränser definieras av en konfigurerbar uppsättning tecken.

• Vi-kommandoläge: <b>

ViForwardChar

Flytta markören ett tecken till höger i redigeringsläget Vi. Detta kan flytta markören till nästa rad med flerradsinmatning.

• Vi-infogningsläge: <RightArrow>
• Vi-kommandoläge: <RightArrow> , <Spacebar> , <l>

ViEndOfGlob

Flyttar markören till slutet av ordet, med endast blanksteg som avgränsare.

• Vi-kommandoläge: <E>

ViEndOfPreviousGlob

Flyttar till slutet av föregående ord, med endast blanksteg som en ordavgränsare.

• Funktionen är obunden.

ViGotoBrace

Liknar GotoBrace, men är teckenbaserat i stället för tokenbaserat.

• Vi-kommandoläge: <%>

ViNextGlob

Flyttar till nästa ord, med endast blanksteg som en ordavgränsare.

• Vi-kommandoläge: <W>

ViNextWord

Flytta markören framåt till början av nästa ord. Ordgränser definieras av en konfigurerbar uppsättning tecken.

• Vi-kommandoläge: <w>

Historikfunktioner

BeginningOfHistory

Flytta till det första objektet i historiken.

• Emacs: <Alt+<>

ClearHistory

Rensar historiken i PSReadLine. Detta påverkar inte PowerShell-historiken.

• Cmd: <Alt+F7>

EndOfHistory

Flytta till det sista objektet (aktuella indata) i historiken.

• Emacs: <Alt+>>

ForwardSearchHistory

Utför en inkrementell framåtsökning genom historiken.

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

HistorySearchBackward

Ersätt aktuella indata med det "föregående" objektet från PSReadLine-historiken som matchar tecknen mellan start- och indata och markören.

• Cmd: <F8>

HistorySearchForward

Ersätt aktuella indata med nästa-objektet från PSReadLine-historiken som matchar tecknen mellan start- och indata och markören.

• Cmd: <Shift+F8>

NextHistory

Ersätt aktuella indata med "nästa"-objektet från PSReadLine-historiken.

• Cmd: <DownArrow>
• Emacs: <DownArrow> , <Ctrl+n>
• Vi-infogningsläge: <DownArrow>
• Vi-kommandoläge: <DownArrow> , <j> , <+>

PreviousHistory

Ersätt aktuella indata med föregående objekt från PSReadLine-historiken.

• Cmd: <UpArrow>
• Emacs: <UpArrow> , <Ctrl+p>
• Vi-infogningsläge: <UpArrow>
• Vi-kommandoläge: <UpArrow> , <k> , <->

ReverseSearchHistory

Utför en inkrementell bakåtsökning genom historiken.

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

ViSearchHistoryBackward

Frågar efter en söksträng och initierar sökningen på AcceptLine.

• Vi-infogningsläge: <Ctrl+r>
• Vi-kommandoläge: </> , <Ctrl+r>

Funktioner för slutförande

Klart

Försök att utföra slutförande på texten som omger markören. Om det finns flera möjliga slutföranden används det längsta entydiga prefixet för slutförande. Om du försöker slutföra den längsta entydiga slutförandet visas en lista över möjliga slutföranden.

• Emacs: <Tab>

MenySlutför

Försök att utföra slutförande på texten som omger markören. Om det finns flera möjliga slutföranden används det längsta entydiga prefixet för slutförande. Om du försöker slutföra den längsta entydiga slutförandet visas en lista över möjliga slutföranden.

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

PossibleCompletions

Visa listan över möjliga slutföranden.

• Emacs: <Alt+=>
• Vi-infogningsläge: <Ctrl+Spacebar>
• Vi-kommandoläge: <Ctrl+Spacebar>

TabCompleteNästa

Försök att slutföra texten som omger markören med nästa tillgängliga slutförande.

• Cmd: <Tab>
• Vi-kommandoläge: <Tab>

TabCompletePrevious

Försök att slutföra texten som omger markören med föregående tillgängliga slutförande.

• Cmd: <Shift+Tab>
• Vi-kommandoläge: <Shift+Tab>

ViTabCompleteNästa

Avslutar den aktuella redigeringsgruppen, om det behövs, och anropar TabCompleteNext.

• Vi-infogningsläge: <Tab>

ViTabCompletePrevious

Avslutar den aktuella redigeringsgruppen om det behövs och anropar TabCompletePrevious.

• Vi-infogningsläge: <Shift+Tab>

Förutsägelsefunktioner

AcceptNextSuggestionWord

När du InlineView använder som visningsformat för förutsägelse godkänner du nästa ord i det infogade förslaget.

• Funktionen är obunden.

AcceptSuggestion

När du InlineView använder som visningsformat för förutsägelse godkänner du det aktuella infogade förslaget.

• Funktionen är obunden.

Nästa förslag

När du ListView använder som visningsformat för förutsägelse navigerar du till nästa förslag i listan.

• Funktionen är obunden.

Föregående förslag

När du ListView använder som visningsformat för förutsägelse navigerar du till föregående förslag i listan.

• Funktionen är obunden.

SwitchPredictionView

Växla vyformatet för förutsägelse mellan InlineView och ListView .

• Cmd: <F2>

Diverse funktioner

CaptureScreen

Starta interaktiv skärmdump – upp-/nedpilar väljer rader, anger kopior av markerad text till Urklipp som text och HTML.

• Funktionen är obunden.

ClearScreen

Rensa skärmen och rita den aktuella linjen överst på skärmen.

• Cmd: <Ctrl+l>
• Emacs: <Ctrl+l>
• Vi-infogningsläge: <Ctrl+l>
• Vi-kommandoläge: <Ctrl+l>

DigitArgument

Starta ett nytt sifferargument som ska överföras till andra funktioner.

• 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+->
• Vi-kommandoläge: <0> , , , , , , , , <1> , <2> <3> <4> <5> <6> <7> <8> , <9>

InvokePrompt

Raderar den aktuella prompten och anropar promptfunktionen för att spela upp prompten igen. Användbart för anpassade nyckelhanterare som ändrar tillstånd. Du kan till exempel ändra den aktuella katalogen.

• Funktionen är obunden.

ScrollDisplayDown

Rulla skärmen nedåt en skärm.

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

ScrollDisplayDownLine

Rulla visningen nedåt en rad.

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

ScrollDisplayToCursor

Rulla visningen till markören.

• Emacs: <Ctrl+End>

ScrollDisplayTop

Rulla visningen längst upp.

• Emacs: <Ctrl+Home>

ScrollDisplayUp

Rulla upp en skärm.

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

ScrollDisplayUpLine

Rulla uppåt en rad.

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

SelfInsert

Infoga nyckeln.

• Funktionen är obunden.

ShowCommandHelp

Ger en vy över fullständig cmdlet-hjälp. När markören är i slutet av en fullständigt expanderad parameter och trycker på tangenten positionerar visningen av hjälp <F1> vid platsen för den parametern.

Hjälpen visas på en alternativ skärmbuffert med hjälp av en Pager från Microsoft.PowerShell.Pager. När du avslutar pager returneras du till den ursprungliga markörpositionen på den ursprungliga skärmen. Den här pager fungerar bara i moderna terminalprogram, till exempel Windows-terminal.

• Cmd: <F1>
• Emacs: <F1>
• Vi-infogningsläge: <F1>
• Vi-kommandoläge: <F1>

ShowKeyBindings

Visa alla bundna nycklar.

• Cmd: <Ctrl+Alt+?>
• Emacs: <Ctrl+Alt+?>
• Vi-infogningsläge: <Ctrl+Alt+?>

ShowParameterHelp

Ger dynamisk hjälp för parametrar genom att visa den under den aktuella kommandoraden som MenuComplete . Markören måste vara i slutet av det fullständigt expanderade parameternamnet när du trycker på <Alt+h> tangenten.

• Cmd: <Alt+h>
• Emacs: <Alt+h>
• Vi-infogningsläge: <Alt+h>
• Vi-kommandoläge: <Alt+h>

ViCommandMode

Växla det aktuella driftläget från Vi-Insert till Vi-Command.

• Vi-infogningsläge: <Escape>

ViDigitArgumentInChord

Starta ett nytt sifferargument som ska överföras till andra funktioner i ett av vi-strängarna.

• Funktionen är obunden.

ViEditVisually

Redigera kommandoraden i en textredigerare som anges av $env:EDITOR eller $env:VISUAL.

• Emacs: <Ctrl+x,Ctrl+e>
• Vi-kommandoläge: <v>

ViExit

Avslutar gränssnittet.

• Funktionen är obunden.

ViInsertMode

Växla till Infogningsläge.

• Vi-kommandoläge: <i>

WhatIsKey

Läs en nyckel och berätta vad nyckeln är bunden till.

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

Markeringsfunktioner

ExchangePointAndMark

Markören placeras på platsen för markeringen och markeringen flyttas till markörens plats.

• Emacs: <Ctrl+x,Ctrl+x>

VäljAlla

Markera hela raden.

• Cmd: <Ctrl+a>

SelectBackwardChar

Justera den aktuella markeringen så att den inkluderar föregående tecken.

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

SelectBackwardsLine

Justera den aktuella markeringen så att den inkluderar från markören till början av raden.

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

SelectBackwardWord

Justera den aktuella markeringen så att den innehåller föregående ord.

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

SelectCommandArgument

Gör ett visuellt val av kommandoargumenten. Valet av argument är begränsad till ett skriptblock. Baserat på markörens position söker den från det innersta skriptblocket till det översta skriptblocket och stoppas när den hittar argument i ett skriptblocksomfång.

Den här funktionen använder DigitArgument. Den behandlar positiva eller negativa argumentvärden som framåt- eller bakåtförskjutningar från det valda argumentet eller från den aktuella markörpositionen när inget argument har valts.

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

SelectForwardChar

Justera den aktuella markeringen så att nästa tecken inkluderas.

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

SelectForwardWord

Justera den aktuella markeringen så att nästa ord inkluderas med forwardword.

• Emacs: <Alt+F>

SelectLine

Justera den aktuella markeringen så att den inkluderar från markören till slutet av raden.

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

SelectNextWord

Justera den aktuella markeringen så att nästa ord inkluderas.

• Cmd: <Shift+Ctrl+RightArrow>

SelectShellBackwardWord

Justera det aktuella valet så att det föregående ordet inkluderas med Hjälp av ShellBackwardWord.

• Funktionen är obunden.

SelectShellForwardWord

Justera den aktuella markeringen så att nästa ord inkluderas med Hjälp av ShellForwardWord.

• Funktionen är obunden.

SelectShellNextWord

Justera den aktuella markeringen så att nästa ord inkluderas med ShellNextWord.

• Funktionen är obunden.

SetMark

Markera den aktuella platsen för markören för användning i ett efterföljande redigeringskommando.

• Emacs: <Ctrl+@>

Förutsägande IntelliSense-funktioner

AcceptNextWordSuggestion

Godkänner nästa ord i det infogade förslaget från Predictive IntelliSense. Den här funktionen kan bindas med Ctrl + F genom att köra följande kommando.

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

Acceptera förslag

Godkänner det aktuella infogade förslaget från Predictive IntelliSense genom att trycka på RightArrow när markören är i slutet av den aktuella raden.

Sökfunktioner

CharacterSearch

Läs ett tecken och sök framåt efter nästa förekomst av tecknet. Om ett argument har angetts söker du framåt (eller bakåt om det är negativt) efter den n:e förekomsten.

• Cmd: <F3>
• Emacs: <Ctrl+]>
• Vi-infogningsläge: <F3>
• Vi-kommandoläge: <F3>

CharacterSearchBackward

Läs ett tecken och sök bakåt efter nästa förekomst av tecknet. Om ett argument har angetts söker du bakåt (eller framåt om det är negativt) efter den n:e förekomsten.

• Cmd: <Shift+F3>
• Emacs: <Ctrl+Alt+]>
• Vi-infogningsläge: <Shift+F3>
• Vi-kommandoläge: <Shift+F3>

RepeatLastCharSearch

Upprepa den senast registrerade teckensökningen.

• Vi-kommandoläge: <;>

RepeatLastCharSearchBackwards

Upprepa den senast registrerade teckensökningen, men i motsatt riktning.

• Vi-kommandoläge: <,>

RepeatSearch

Upprepa den senaste sökningen i samma riktning som tidigare.

• Vi-kommandoläge: <n>

RepeatSearchBackward

Upprepa den senaste sökningen i samma riktning som tidigare.

• Vi-kommandoläge: <N>

SearchChar

Läs nästa tecken och leta upp det, gå vidare och backa sedan bort ett tecken. Det här är för "inte"-funktionen.

• Vi-kommandoläge: <f>

SearchCharBackward

Läs nästa tecken och leta upp det, gå bakåt och backa sedan bort ett tecken. Det här är för T-funktioner.

• Vi-kommandoläge: <F>

SearchCharBackwardWithBackoff

Läs nästa tecken och leta upp det, gå bakåt och backa sedan bort ett tecken. Det här är för T-funktioner.

• Vi-kommandoläge: <T>

SearchCharWithBackoff

Läs nästa tecken och leta upp det, gå vidare och backa sedan bort ett tecken. Det här är för "inte"-funktionen.

• Vi-kommandoläge: <t>

SearchForward

Frågar efter en söksträng och initierar sökningen på AcceptLine.

• Vi-infogningsläge: <Ctrl+s>
• Vi-kommandoläge: <?> , <Ctrl+s>

Anpassade nyckelbindningar

PSReadLine stöder anpassade nyckelbindningar med hjälp av cmdleten Set-PSReadLineKeyHandler . De flesta anpassade nyckelbindningar anropar någon av ovanstående funktioner, till exempel

Set-PSReadLineKeyHandler -Key UpArrow -Function HistorySearchBackward

Du kan binda ett ScriptBlock till en nyckel. ScriptBlock kan i stort sett göra vad du vill. Några användbara exempel är

• redigera kommandoraden
• öppna ett nytt fönster (till exempel hjälp)
• ändra kataloger utan att ändra kommandoraden

ScriptBlock tar emot två argument:

• $key – Ett [ConsoleKeyInfo]-objekt som är den nyckel som utlöste den anpassade bindningen. Om du binder samma ScriptBlock till flera nycklar och behöver utföra olika åtgärder beroende på nyckeln kan du kontrollera $key. Många anpassade bindningar ignorerar det här argumentet.

• $arg – Ett godtyckligt argument. Oftast är detta ett heltalsargument som användaren skickar från nyckelbindningarna DigitArgument. Om bindningen inte accepterar argument är det rimligt att ignorera det här argumentet.

Låt oss ta en titt på ett exempel som lägger till en kommandorad i historiken utan att köra den. Detta är användbart när du inser att du har glömt att göra något, men inte vill ange kommandoraden som du redan har angett på nytt.

$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

Du kan se många fler exempel i filen SamplePSReadLineProfile.ps1 som är installerade i PSReadLine-modulmappen.

De flesta nyckelbindningar använder vissa hjälpfunktioner för att redigera kommandoraden. Dessa API:er dokumenteras i nästa avsnitt.

API:er för stöd för anpassad nyckelbindning

Följande funktioner är offentliga i Microsoft.PowerShell.PSConsoleReadLine, men kan inte bindas direkt till en nyckel. De flesta är användbara i anpassade nyckelbindningar.

void AddToHistory(string command)

Lägg till en kommandorad i historiken utan att köra den.

void ClearKillRing()

Rensa kill-ring. Detta används främst för testning.

void Delete(int start, int length)

Ta bort längdtecken från början. Den här åtgärden stöder ångra/gör om.

void Ding()

Utför Ding-åtgärden baserat på användarnas inställningar.

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

Dessa två funktioner hämtar användbar information om indatabuffertens aktuella tillstånd. Den första används oftast för enkla fall. Den andra används om bindningen gör något mer avancerat med Ast.

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

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

Dessa två funktioner används av Get-PSReadLineKeyHandler . Den första används för att hämta alla nyckelbindningar. Den andra används för att hämta specifika nyckelbindningar.

Microsoft.PowerShell.PSConsoleReadLineOptions GetOptions()

Den här funktionen används av Get-PSReadLineOption och är förmodligen inte så användbar i en anpassad nyckelbindning.

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

Om det inte finns något val på kommandoraden returnerar funktionen -1 både start och längd. Om det finns ett val på kommandoraden returneras start och längd för markeringen.

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

Infoga ett tecken eller en sträng vid markören. Den här åtgärden stöder ångra/gör om.

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

Det här är den huvudsakliga startpunkten för PSReadLine. Det stöder inte rekursion, så det är inte användbart i en anpassad nyckelbindning.

void RemoveKeyHandler(string[] key)

Den här funktionen används av Remove-PSReadLineKeyHandler och är förmodligen inte så användbar i en anpassad nyckelbindning.

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

Ersätt några av indata. Den här åtgärden stöder ångra/gör om. Detta rekommenderas framför Ta bort följt av Infoga eftersom det behandlas som en enda åtgärd för att ångra.

void SetCursorPosition(int cursor)

Flytta markören till den angivna förskjutningen. Markörförflyttning spåras inte för att ångra.

void SetOptions(Microsoft.PowerShell.SetPSReadLineOption options)

Den här funktionen är en hjälpmetod som används av cmdleten Set-PSReadLineOption, men kan vara användbar för en anpassad nyckelbindning som tillfälligt vill ändra en inställning.

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

Den här hjälpmetoden används för anpassade bindningar som respekterar DigitArgument. Ett typiskt anrop ser ut så här

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

Kommentarer

Kommandohistorik

PSReadLine har en historikfil som innehåller alla kommandon och data som du har angett från kommandoraden. Historikfilerna är en fil med namnet $($host.Name)_history.txt . På Windows lagras historikfilen på $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine . I icke-Windows-system lagras historikfilerna på $env:XDG_DATA_HOME/powershell/PSReadLine eller $env:HOME/.local/share/powershell/PSReadLine .

Historiken kan innehålla känsliga data, inklusive lösenord. PSReadLine försöker filtrera bort känslig information. Kommandorader som innehåller följande strängar skrivs inte till historikfilen.

• password
• asplaintext
• token
• apikey
• hemlighet

PSReadLine 2.2.0 förbättrar filtreringen av känsliga data på följande sätt:

• Använder PowerShell AST (Abstract Syntax Tree) för den parsade kommandoraden för att söka efter känsliga data.
• Använder en lista över säkra cmdlets från SecretManagement-modulen så att dessa kommandon kan läggas till i historiken. Listan över tillåtna innehåller:
  • Get-Secret
  • Get-SecretInfo
  • Get-SecretVault
  • Register-SecretVault
  • Remove-Secret
  • Set-SecretInfo
  • Set-SecretVaultDefault
  • Test-SecretVault
  • Unlock-SecretVault
  • Unregister-SecretVault

Följande kommandon kan till exempel skrivas till historikfilen:

Get-Secret PSGalleryApiKey -AsPlainText # Get-Secret is in the allowlist
$token = Get-Secret -Name github-token -Vault MySecret
[MyType]::CallRestAPI($token, $url, $args)
$template -f $token

Följande kommando skrivs inte till historikfilen:

$token = 'abcd' # Assign expr-value to sensitive variable name.
Set-Secret abc $mySecret # Set-Secret is not in the allowlist.
ConvertTo-SecureString stringValue -AsPlainText # '-AsPlainText' is an alert.
Invoke-WebRequest -Token xxx # Expr-value as argument to '-Token'.
Get-ResultFromTwo -Secret1 (Get-Secret -Name blah -AsPlainText) -Secret2 sdv87ysdfayf798hfasd8f7ha # '-Secret2' has expr-value argument.

Feedback & bidra till PSReadLine

PSReadLine på GitHub

Skicka gärna en pull-begäran eller skicka feedback på GitHub sidan.

Se även

PSReadLine påverkas kraftigt av GNU-läslinebiblioteket.