PSReadLine

À propos de PSReadLine

DESCRIPTION COURTE

PSReadLine offre une expérience améliorée de modification de ligne de commande dans la console PowerShell.

DESCRIPTION DÉTAILLÉE

PSReadLine offre une expérience d’édition de ligne de commande puissante pour la console PowerShell. Il offre :

• Coloration de syntaxe de la ligne de commande
• Indication visuelle des erreurs de syntaxe
• Une meilleure expérience multiligne (édition et historique)
• Liaisons de clés personnalisables
• Modes Cmd et Emacs
• De nombreuses options de configuration
• Achèvement du style Bash (facultatif en mode Cmd, par défaut en mode Emacs)
• Anneau d’élimination Emacs
• Déplacement et mise à mort de « mots » basés sur un jeton PowerShell

Les fonctions suivantes sont disponibles dans la classe [Microsoft.PowerShell.PSConsoleReadLine].

Déplacement du curseur

Fin de Ligne

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

Si l’entrée a plusieurs lignes, passez à la fin de la ligne active ou, si déjà à la fin de la ligne, passez à la fin de l’entrée. Si l’entrée a une seule ligne, passez à la fin de l’entrée.

BeginningOfLine

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

Si l’entrée comporte plusieurs lignes, passez au début de la ligne active ou, si déjà au début de la ligne, passez au début de l’entrée. Si l’entrée a une seule ligne, passez au début de l’entrée.

NextLine

• Cmd : non lié
• Emacs : non lié

Déplacez le curseur sur la ligne suivante si l’entrée comporte plusieurs lignes.

PrécédentLigne

• Cmd : non lié
• Emacs : non lié

Déplacez le curseur sur la ligne précédente si l’entrée comporte plusieurs lignes.

ForwardChar

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

Déplacez le curseur d’un caractère vers la droite. Cela peut déplacer le curseur sur la ligne suivante d’entrée multiligne.

BackwardChar

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

Déplacez le curseur un caractère vers la gauche. Cela peut déplacer le curseur sur la ligne précédente d’entrée multiligne.

ForwardWord

• Cmd : non lié
• Emacs: <Alt+F>

Déplacez le curseur vers l’avant jusqu’à la fin du mot actuel, ou s’il existe entre les mots, jusqu’à la fin du mot suivant. Vous pouvez définir des caractères de délimitation de mots avec :

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

Mot suivant

• Cmd :<Ctrl+RightArrow>
• Emacs : non lié

Déplacez le curseur vers le début du mot suivant. Vous pouvez définir des caractères de délimitation de mots avec :

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

Mot à l’envers

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

Déplacez le curseur vers le début du mot actuel, ou s’il existe entre les mots, le début du mot précédent. Vous pouvez définir des caractères de délimitation de mots avec :

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

ShellForwardWord

• Cmd : non lié
• Emacs : non lié

Comme ForwardWord, sauf que les limites de mots sont définies par des limites de jeton PowerShell.

CoquillageSuivantMot

• Cmd : non lié
• Emacs : non lié

Comme NextWord, sauf que les limites de mots sont définies par des limites de jeton PowerShell.

ShellBackwardWord

• Cmd : non lié
• Emacs : non lié

Comme BackwardWord, sauf que les limites de mots sont définies par des limites de jeton PowerShell.

GotoBrace

• Cmd :<Ctrl+}>
• Emacs : non lié

Passez à la parenthèse correspondante, à l’accolade ou au crochet carré.

AddLine

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

L’invite de continuation s’affiche sur la ligne suivante et PSReadLine attend que les clés modifient l’entrée actuelle. Cela est utile pour entrer une entrée multiligne sous la forme d’une seule commande, même lorsqu’une seule ligne est terminée par elle-même.

Modification de base

CancelLine

• Cmd : non lié
• Emacs : non lié

Annulez toutes les modifications de la ligne, laissez la ligne d’entrée à l’écran, mais revenez de PSReadLine sans exécuter l’entrée.

RevertLine

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

Rétablit toutes les entrées depuis que la dernière entrée a été acceptée et exécutée. Cela équivaut à utiliser la commande Annuler jusqu’à ce qu’il n’y ait plus rien à annuler.

BackwardDeleteChar

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

Supprimez le caractère avant le curseur.

SupprimerChar

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

Supprimez le caractère sous le curseur.

DeleteCharOrExit

• Cmd : non lié
• Emacs: <Ctrl+D>

Comme DeleteChar, sauf si la ligne est vide, auquel cas quittez le processus.

AcceptLine

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

Essayez d’exécuter l’entrée actuelle. Si l’entrée actuelle est incomplète (par exemple, il manque une parenthèse fermante, un crochet ou un guillemet), l’invite de continuation s’affiche sur la ligne suivante et PSReadLine attend les touches pour modifier l’entrée actuelle.

AccepterAndGetNext

• Cmd : non lié
• Emacs: <Ctrl+O>

Comme AcceptLine, mais une fois la ligne terminée, commencez à modifier la ligne suivante à partir de l’historique.

ValideretAccepterLigne

• Cmd : non lié
• Emacs : non lié

Comme AcceptLine, mais effectue une validation supplémentaire, notamment :

• Vérifie les erreurs d’analyse supplémentaires
• Vérifie que les noms de commande sont tous trouvés
• Si vous exécutez PowerShell 4.0 ou une version ultérieure, valide les paramètres et les arguments

S’il y a des erreurs, le message d’erreur s’affiche et n’est ni accepté ni ajouté à l’historique, sauf si vous corrigez la ligne de commande ou exécutez à nouveau AcceptLine ou ValidateAndAcceptLine pendant que le message d’erreur est affiché.

RétroactionDeleteLine

• Cmd :<Ctrl+Home>
• Emacs : non lié

Supprimez le texte depuis le début de la saisie jusqu’au curseur.

ForwardDeleteLine

• Cmd :<Ctrl+End>
• Emacs : non lié

Supprimez le texte du curseur à la fin de la saisie.

SelectBackwardChar

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

Ajustez la sélection actuelle pour inclure le caractère précédent.

SelectForwardChar

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

Ajustez la sélection actuelle pour inclure le caractère suivant.

SélectionnerBackwardWord

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

Ajustez la sélection actuelle pour inclure le mot précédent.

SélectionnerForwardWord

• Cmd : non lié
• Emacs: <Alt+Shift+F>

Ajustez la sélection actuelle pour inclure le mot suivant à l’aide de ForwardWord.

SélectionnerMot suivant

• Cmd :<Shift+Ctrl+RightArrow>
• Emacs : non lié

Ajustez la sélection actuelle pour inclure le mot suivant à l’aide de NextWord.

SélectionnerShellForwardWord

• Cmd : non lié
• Emacs : non lié

Ajustez la sélection actuelle pour inclure le mot suivant à l’aide de ShellForwardWord.

SélectionnerCoquillageSuivantMot suivant

• Cmd : non lié
• Emacs : non lié

Ajustez la sélection actuelle pour inclure le mot suivant à l’aide de ShellNextWord.

SelectShellBackwardWord

• Cmd : non lié
• Emacs : non lié

Ajustez la sélection actuelle pour inclure le mot précédent à l’aide de ShellBackwardWord.

SélectionnerLigne BackwardsLine

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

Ajustez la sélection actuelle à inclure du curseur au début de la ligne.

SélectionnerLigne

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

Ajustez la sélection actuelle à inclure du curseur à la fin de la ligne.

Tout sélectionner

• Cmd :<Ctrl+A>
• Emacs : non lié

Sélectionnez la ligne entière. Déplace le curseur à la fin de la ligne.

Auto-insertion

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

Insérez la clé saisie.

Refaire

• Cmd :<Ctrl+Y>
• Emacs : non lié

Rétablissez une insertion ou une suppression qui a été annulée par Annuler.

Aucun changement nécessaire, la traduction actuelle est déjà précise.

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

Annuler une insertion ou une suppression précédente.

Histoire

Effacer l’histoire

• Cmd :<Alt+F7>
• Emacs : non lié

Efface l’historique dans PSReadLine. Cela n’affecte pas l’historique PowerShell.

PrécédentHistoire

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

Remplacez l’entrée actuelle par l’élément précédent de l’historique de PSReadLine.

SuivantHistoire

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

Remplacez l’entrée actuelle par l’élément suivant de l’historique PSReadLine.

ForwardSearchHistory

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

Effectuez une recherche interactive à partir de la ligne d’historique actuelle.

ReverseSearchHistory

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

Effectuez une recherche interactive à partir de la ligne d’historique actuelle.

HistorySearchBackward

• Cmd :<F8>
• Emacs : non lié

Remplacez l’entrée actuelle par l’élément précédent de l’historique PSReadLine qui correspond aux caractères entre le début et l’entrée et le curseur.

HistoireRechercheForward

• Cmd :<Shift+F8>
• Emacs : non lié

Remplacez l’entrée actuelle par l’élément suivant de l’historique PSReadLine qui correspond aux caractères entre le début et l’entrée et le curseur.

Début de l’histoire

• Cmd : non lié
• Emacs: <Alt+<>

Remplacez l’entrée actuelle par le dernier élément de l’historique PSReadLine.

Fin de l’histoire

• Cmd : non lié
• Emacs: <Alt+>>

Remplacez l’entrée actuelle par le dernier élément de l’historique PSReadLine, c’est-à-dire l’entrée éventuellement vide qui a été saisie avant toute commande d’historique.

Saisie semi-automatique de l’onglet

TabCompleteNext

• Cmd :<Tab>
• Emacs : non lié

Essayez de terminer le texte entourant le curseur avec la fin suivante disponible.

TabCompletePrécédent

• Cmd :<Shift-Tab>
• Emacs : non lié

Essayez de compléter le texte entourant le curseur avec la prochaine fois que vous avez terminé.

Terminé

• Cmd : non lié
• Emacs: <Tab>

Essayez d’effectuer la saisie semi-automatique sur le texte entourant le curseur. S’il existe plusieurs achèvements possibles, le préfixe non ambigu le plus long est utilisé pour l’achèvement. Si vous essayez d’effectuer l’achèvement sans ambiguïté le plus long, une liste des achèvements possibles s’affiche.

Menu Complet

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

Essayez d’effectuer la saisie semi-automatique sur le texte entourant le curseur. S’il y a plusieurs saisies semi-automatiques possibles, une liste des saisies semi-automatiques possibles s’affiche et vous pouvez sélectionner la saisie semi-automatique correcte à l’aide des touches fléchées ou de la touche Tab/Maj+Tab. Échap et Ctrl+G annulent la sélection de menu et rétablissent l’état de la ligne avant d’appeler MenuComplete.

Achèvements possibles

• Cmd : non lié
• Emacs: <Alt+Equals>

Affichez la liste des achèvements possibles.

SetMark

• Cmd : non lié
• Emacs: <Alt+Space>

Marquez l’emplacement actuel du curseur à utiliser dans une commande d’édition suivante.

ExchangePointAndMark

• Cmd : non lié
• Emacs: <Ctrl+X,Ctrl+X>

Le curseur est placé à l’emplacement de la marque et la marque est déplacée vers l’emplacement du curseur.

Tuer/Tirer

Kill et Yank fonctionnent sur un presse-papiers dans le module PSReadLine. Il existe un tampon d’anneau appelé l’anneau d’élimination - le texte tué est ajouté à l’anneau d’élimination et tirk copiera le texte de l’élimination la plus récente. YankPop parcourt les objets de l’anneau d’élimination. Lorsque l’anneau d’élimination est plein, de nouveaux objets remplacent les objets les plus anciens. Une opération d’élimination qui est immédiatement précédée d’une autre opération d’élimination ajoute l’élimination précédente, au lieu d’ajouter un nouvel objet ou de remplacer un objet dans l’anneau d’élimination. C’est ainsi que vous pouvez couper une partie d’une ligne, par exemple, avec plusieurs opérations KillWord, puis les retirer ailleurs en un seul tir.

Ligne d’arrêt

• Cmd : non lié
• Emacs: <Ctrl+K>

Effacez l’entrée du curseur jusqu’à la fin de la ligne. Le texte effacé est placé dans l’anneau d’élimination.

BackwardKillLine

• Cmd : non lié
• Emacs : <Ctrl+U> ou <Ctrl+X,Backspace>

Effacez l’entrée du début de l’entrée au curseur. Le texte effacé est placé dans l’anneau d’élimination.

KillWord (en anglais)

• Cmd : non lié
• Emacs: <Alt+D>

Effacez l’entrée du curseur à la fin du mot actuel. Si le curseur se trouve entre les mots, l’entrée est effacée du curseur à la fin du mot suivant. Le texte effacé est placé dans l’anneau d’élimination.

BackwardKillWord

• Cmd : non lié
• Emacs: <Alt+Backspace>

Effacez l’entrée du début du mot actuel au curseur. Si le curseur se trouve entre les mots, l’entrée est effacée du début du mot précédent au curseur. Le texte effacé est placé dans l’anneau d’élimination.

ShellKillWord

• Cmd : non lié
• Emacs : non lié

Comme KillWord, sauf que les limites de mots sont définies par les limites de jeton PowerShell.

ShellBackwardKillWord

• Cmd : non lié
• Emacs : non lié

Comme BackwardKillWord, sauf que les limites de mots sont définies par les limites de jeton PowerShell.

UnixWordRubout

• Cmd : non lié
• Emacs: <Ctrl+W>

Comme BackwardKillWord, sauf que les limites des mots sont définies par des espaces.

KillRegion

• Cmd : non lié
• Emacs : non lié

Supprimez le texte entre le curseur et la marque.

Copier

• Cmd :<Ctrl+Shift+C>
• Emacs : non lié

Copiez la région sélectionnée dans le Presse-papiers système. Si aucune région n’est sélectionnée, copiez la ligne entière.

CopyOrCancelLine

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

Copiez le texte sélectionné dans le presse-papiers ou, si aucun texte n’est sélectionné, annulez la modification de la ligne à l’aide de CancelLine.

Couper

• Cmd :<Ctrl+X>
• Emacs : non lié

Supprimez la région sélectionnée en plaçant le texte supprimé dans le Presse-papiers système.

Amerloque

• Cmd : non lié
• Emacs: <Ctrl+Y>

Ajoutez le texte le plus récemment tué à l’entrée.

YankPop

• Cmd : non lié
• Emacs: <Alt+Y>

Si l’opération précédente était Yank ou YankPop, remplacez le texte précédemment retiré par le texte tué suivant de l’anneau d’arrêt.

ClearKillRing

• Cmd : non lié
• Emacs : non lié

Le contenu de l’anneau d’arrêt est nettoyé.

Coller

• Cmd :<Ctrl+V>
• Emacs : non lié

C’est similaire à Yank, mais utilise le presse-papiers du système au lieu de l’anneau d’arrêt.

[! IMPORTANT]

Lorsque vous utilisez la fonction Coller , le contenu entier de la mémoire tampon du Presse-papiers est collé dans la mémoire tampon d’entrée de PSReadLine. La mémoire tampon d’entrée est ensuite passée à l’analyseur PowerShell. L’entrée collée à l’aide de la méthode de collage de clic droit de l’application console est copiée dans la mémoire tampon d’entrée un caractère à la fois. La mémoire tampon d’entrée est passée à l’analyseur lorsqu’un caractère de ligne est copié. Par conséquent, l’entrée est analysée d’une ligne à la fois. La différence entre les méthodes de collage entraîne un comportement d’exécution différent.

YankLastArg

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

Insérez le dernier argument de la commande précédente dans l’historique. Les opérations répétées remplacent le dernier argument inséré par le dernier argument de la commande précédente (donc Alt+. Alt+. insérera le dernier argument de l’avant-dernière ligne d’historique).

Avec un argument, la première fois YankLastArg se comporte comme YankNthArg. Un argument négatif lors des appels YankLastArg suivants change la direction lors de la lecture de l’historique. Par exemple, si vous appuyez sur Alt+. une fois de trop, vous pouvez taper Alt+- Alt+. pour inverser la direction.

Les arguments sont basés sur des jetons PowerShell.

YankNthArg

• Cmd : non lié
• Emacs: <Alt+Ctrl+Y>

Insérez le premier argument (et non le nom de la commande) de la commande précédente dans l’historique.

Avec un argument, insérez le nième argument où 0 est généralement la commande. Les arguments négatifs commencent par la fin.

Les arguments sont basés sur des jetons PowerShell.

Divers

Abandon

• Cmd : non lié
• Emacs: <Ctrl+G>

Abandonner l’action en cours ; Par exemple, arrêtez la recherche interactive dans l’historique. N’annule pas l’entrée comme CancelLine.

Recherche de personnage

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

Lisez une touche et recherchez ce caractère dans les avants. À l’aide d’un argument, recherchez la énième occurrence de cet argument. Avec un argument négatif, recherche à rebours.

CharacterSearchBackward

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

Comme CharacterSearch, mais recherche à l’envers. Avec un argument négatif, les recherches avancent.

ClearScreen

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

Efface l’écran et affiche l’invite et l’entrée actuelles en haut de l’écran.

ArgumentNumérique

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

Utilisé pour passer des arguments numériques à des fonctions telles que CharacterSearch ou YankNthArg. Alt+- bascule l’argument en négatif/non négatif. Pour entrer 80 caractères '*', vous pouvez taper Alt+8 Alt+0 *.

CaptureÉcran

• Cmd : non lié
• Emacs : non lié

Copie les lignes sélectionnées dans le presse-papiers aux formats texte et RTF. Utilisez les touches fléchées haut/bas jusqu’à la première ligne pour sélectionner, puis Maj+Flèche haut/Maj+Flèche bas pour sélectionner plusieurs lignes. Après avoir sélectionné, appuyez sur Entrée pour copier le texte. Échap/Ctrl+C/Ctrl+G annulent l’opération, de sorte que rien n’est copié dans le presse-papiers.

InvokePrompt

• Cmd : non lié
• Emacs : non lié

Efface l’invite actuelle et appelle la fonction d’invite pour réafficher l’invite. Utile pour les gestionnaires de clés personnalisés qui changent d’état, par exemple en modifiant le répertoire actuel.

Qu’est-ce que c’est

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

Lisez une tonalité ou un accord et affichez la combinaison de touches.

ShowKeyBindings

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

Affichez toutes les clés actuellement liées.

DéfilementAffichagevers le haut

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

Faites défiler l’affichage vers le haut d’un écran.

ScrollDisplayUpLine

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

Faites défiler l’affichage vers le haut d’une ligne.

DéfilementAffichagevers le bas

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

Faites défiler l’affichage vers le bas d’un écran.

ScrollDisplayDownLine

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

Faites défiler l’affichage vers le bas d’une ligne.

DéfilementAffichageHaut de page

• Cmd : non lié
• Emacs: <Ctrl+Home>

Faites défiler l’affichage vers le haut.

ScrollDisplayToCursor

• Cmd : non lié
• Emacs: <Ctrl+End>

Faites défiler l’affichage jusqu’au curseur.

Liaisons de clés personnalisées

PSReadLine prend en charge les raccourcis clavier personnalisés à l’aide de l’applet Set-PSReadLineKeyHandlerde commande . La plupart des raccourcis clavier personnalisés appellent l’une des fonctions ci-dessus, par exemple

Set-PSReadLineKeyHandler -Key UpArrow -Function HistorySearchBackward

Vous pouvez lier un ScriptBlock à une clé. Le ScriptBlock peut faire presque tout ce que vous voulez. Voici quelques exemples utiles :

• modifier la ligne de commande
• l’ouverture d’une nouvelle fenêtre (par exemple, aide)
• modifier les répertoires sans modifier la ligne de commande

ScriptBlock reçoit deux arguments :

• $key : objet [ConsoleKeyInfo] clé qui a déclenché la liaison personnalisée. Si vous liez le même ScriptBlock à plusieurs clés et que vous devez effectuer des actions différentes en fonction de la clé, vous pouvez vérifier $key. De nombreuses liaisons personnalisées ignorent cet argument.

• $arg - Argument arbitraire. Le plus souvent, il s’agit d’un argument entier transmis par l’utilisateur à partir des liaisons de clé DigitArgument. Si votre liaison n’accepte pas d’arguments, il est raisonnable d’ignorer cet argument.

Examinons un exemple qui ajoute une ligne de commande à l’historique sans l’exécuter. Cela est utile lorsque vous réalisez que vous avez oublié de faire quelque chose, mais ne souhaitez pas entrer à nouveau la ligne de commande que vous avez déjà entrée.

$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

Vous pouvez voir de nombreux autres exemples dans le fichier SamplePSReadLineProfile.ps1 qui est installé dans le dossier du module PSReadLine.

La plupart des liaisons clés utilisent certaines fonctions d’assistance pour modifier la ligne de commande. Ces API sont documentées dans la section suivante.

API de prise en charge des liaisons de clés personnalisées

Les fonctions suivantes sont publiques dans Microsoft.PowerShell.PSConsoleReadLine, mais ne peuvent pas être directement liées à une clé. La plupart sont utiles dans les liaisons de clés personnalisées.

void AddToHistory(string command)

Ajoutez une ligne de commande à l’historique sans l’exécuter.

void ClearKillRing()

Nettoyez l’anneau d’élimination. Ceci est principalement utilisé pour les tests.

void Delete(int start, int length)

Supprimez les caractères de longueur du début. Cette opération prend en charge l’annulation/restauration automatique.

void Ding()

Effectuez l’action Ding en fonction des préférences de l’utilisateur.

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

Ces deux fonctions récupèrent des informations utiles sur l’état actuel de la mémoire tampon d’entrée. La première est plus couramment utilisée pour les cas simples. La seconde est utilisée si votre liaison effectue quelque chose de plus avancé avec l’Ast.

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

Cette fonction est utilisée par Get-PSReadLineKeyHandler et n’est probablement pas utile dans une combinaison de touches personnalisée.

Microsoft.PowerShell.PSConsoleReadLineOptions GetOptions()

Cette fonction est utilisée par Get-PSReadLineOption et n’est probablement pas trop utile dans une liaison de clé personnalisée.

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

S’il n’y a pas de sélection sur la ligne de commande, -1 sera renvoyée à la fois dans start et length. S’il y a une sélection sur la ligne de commande, le début et la durée de la sélection sont renvoyés.

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

Insérez un caractère ou une chaîne au niveau du curseur. Cette opération prend en charge l’annulation/restauration automatique.

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

Il s’agit du point d’entrée principal vers PSReadLine. Il ne prend pas en charge la récursivité, il n’est donc pas utile dans une combinaison de touches personnalisée.

void RemoveKeyHandler(string[] key)

Cette fonction est utilisée par Remove-PSReadLineKeyHandler et n’est probablement pas trop utile dans une liaison de clé personnalisée.

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

Remplacez une partie de l’entrée. Cette opération prend en charge l’annulation/restauration automatique. Cette option est préférée à celle de Supprimer suivie d’Insérer, car elle est traitée comme une action unique pour l’annulation.

void SetCursorPosition(int cursor)

Déplacez le curseur vers le décalage donné. Le mouvement du curseur n’est pas suivi pour l’annulation.

void SetOptions(Microsoft.PowerShell.SetPSReadLineOption options)

Cette fonction est une méthode d’assistance utilisée par l’applet de commande Set-PSReadLineOption, mais peut être utile à une liaison de touches personnalisée qui souhaite modifier temporairement un paramètre.

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

Cette méthode d’assistance est utilisée pour les liaisons personnalisées qui respectent DigitArgument. Un appel classique ressemble à

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

NOTE

COMPATIBILITÉ POWERSHELL

PSReadLine nécessite PowerShell 3.0 ou une version ultérieure et l’hôte de la console. Il ne fonctionne pas dans PowerShell ISE. Il fonctionne dans la console de Visual Studio Code.

HISTORIQUE DES COMMANDES

PSReadLine gère un fichier d’historique contenant toutes les commandes et données que vous avez saisies à partir de la ligne de commande. Celui-ci peut contenir des données sensibles, y compris des mots de passe. Par exemple, si vous utilisez l’applet ConvertTo-SecureString de commande, le mot de passe est consigné dans le fichier d’historique en texte brut. Les fichiers d’historique sont un fichier nommé $($host.Name)_history.txt. Sur les systèmes Windows, le fichier d’historique est stocké à $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine.

RETOUR D’INFORMATION ET CONTRIBUTION À PSReadLine

PSReadLine sur GitHub

N’hésitez pas à envoyer une demande de tirage (pull request) ou à envoyer des commentaires sur la page GitHub.

VOIR AUSSI

PSReadLine est fortement influencé par la bibliothèque readline GNU.