Partager via

PSReadLine

  • Article

about_PSReadLine

DESCRIPTION COURTE

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

DESCRIPTION DÉTAILLÉE

PSReadLine fournit 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
  • Nombreuses options de configuration
  • Achèvement du style Bash (facultatif en mode Cmd, par défaut en mode Emacs)
  • Emacs yank/kill ring
  • Mouvement et tuer les mots basés sur des jetons PowerShell

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

Déplacement du curseur

EndOfLine

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

Si l’entrée comporte 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.

Ligne suivante

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

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

Ligne précédente

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

Déplacez le curseur vers 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 vers la ligne suivante d’entrée multiligne.

BackwardChar

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

Déplacez le curseur d’un caractère vers la gauche. Cela peut déplacer le curseur vers 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 y a plusieurs mots, vers la fin du mot suivant. Vous pouvez définir des caractères délimiteurs de mots avec :

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

NextWord

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

Déplacez le curseur vers l’avant jusqu’au début du mot suivant. Vous pouvez définir des caractères délimiteurs de mots avec :

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

Retour en arrière

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

Déplacez le curseur au début du mot actuel ou, si vous le souhaitez, le début du mot précédent. Vous pouvez définir des caractères délimiteurs 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 les limites de jeton PowerShell.

ShellNextWord

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

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

ShellBackwardWord

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

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

GotoBrace

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

Accédez à la parenthèse correspondante, à l’accolade ou au crochet correspondant.

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 commande unique, même lorsqu’une seule ligne est terminée en entrée seule.

Modification de base

CancelLine

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

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

RevertLine

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

Rétablit toutes les entrées depuis l’acceptation et l’exécution de la dernière entrée. Cela équivaut à utiliser la commande Annuler jusqu’à ce qu’il ne reste plus rien à annuler.

BackwardDeleteChar

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

Supprimez le caractère avant le curseur.

DeleteChar

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

Supprimez le caractère sous le curseur.

DeleteCharOrExit

  • Cmd : indépendant
  • 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 que les touches modifient l’entrée actuelle.

AcceptAndGetNext

  • Cmd : indépendant
  • Emacs: <Ctrl+O>

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

ValidateAndAcceptLine

  • Cmd : indépendant
  • Emacs : indépendant

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

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

En cas d’erreur, le message d’erreur s’affiche et n’est pas 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 s’affiche.

BackwardDeleteLine

  • Cmd : <Ctrl+Home>
  • Emacs : indépendant

Supprimez le texte du début de l’entrée au curseur.

ForwardDeleteLine

  • Cmd : <Ctrl+End>
  • Emacs : indépendant

Supprimez le texte du curseur jusqu’à la fin de l’entrée.

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.

SelectBackwardWord

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

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

SelectForwardWord

  • Cmd : indépendant
  • Emacs: <Alt+Shift+F>

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

SelectNextWord

  • Cmd : <Shift+Ctrl+RightArrow>
  • Emacs : indépendant

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

SelectShellForwardWord

  • Cmd : indépendant
  • Emacs : indépendant

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

SelectShellNextWord

  • Cmd : indépendant
  • Emacs : indépendant

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

SelectShellBackwardWord

  • Cmd : indépendant
  • Emacs : indépendant

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

SelectBackwardsLine

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

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

SelectLine

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

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

SelectAll

  • Cmd : <Ctrl+A>
  • Emacs : indépendant

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

SelfInsert

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

Insérez la clé entrée.

Rétablir

  • Cmd : <Ctrl+Y>
  • Emacs : indépendant

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

Annuler

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

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

Historique

ClearHistory

  • Cmd : <Alt+F7>
  • Emacs : indépendant

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

PreviousHistory

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

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

NextHistory

  • 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>

Recherche de la ligne d’historique actuelle de manière interactive.

ReverseSearchHistory

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

Recherche de manière interactive à partir de la ligne d’historique actuelle.

HistorySearchBackward

  • Cmd : <F8>
  • Emacs : indépendant

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.

HistorySearchForward

  • Cmd : <Shift+F8>
  • Emacs : indépendant

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.

BeginningOfHistory

  • Cmd : indépendant
  • Emacs: <Alt+<>

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

EndOfHistory

  • Cmd : indépendant
  • Emacs: <Alt+>>

Remplacez l’entrée actuelle par le dernier élément de l’historique PSReadLine, qui est l’entrée éventuellement vide qui a été entrée avant les commandes d’historique.

Saisie semi-automatique de tabulation

TabCompleteNext

  • Cmd : <Tab>
  • Emacs : indépendant

Essayez de compléter le texte entourant le curseur avec la saisie semi-automatique suivante disponible.

TabCompletePrevious

  • Cmd : <Shift-Tab>
  • Emacs : indépendant

Essayez de compléter le texte entourant le curseur avec la saisie semi-automatique suivante.

Terminé

  • Cmd : indépendant
  • Emacs: <Tab>

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

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

Essayez d’effectuer la saisie semi-automatique sur le texte entourant le curseur. S’il existe plusieurs saisies semi-automatiques possibles, une liste de complétions possibles s’affiche et vous pouvez sélectionner la saisie semi-automatique correcte à l’aide des touches de direction, ou tabulation/Maj+Tab. La touche d’échappement et Ctrl+G annule la sélection du menu et rétablit l’état de la ligne avant d’appeler MenuComplete.

PossibleCompletions

  • Cmd : indépendant
  • Emacs: <Alt+Equals>

Affiche la liste des complétions possibles.

SetMark

  • Cmd : indépendant
  • Emacs: <Alt+Space>

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

ExchangePointAndMark

  • Cmd : indépendant
  • 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/Yank

Kill et Yank fonctionnent sur un Presse-papiers dans le module PSReadLine. Il existe une mémoire tampon en anneau appelée l’anneau de destruction : le texte tué est ajouté à l’anneau de destruction et yank copiera le texte de la dernière mise à mort. YankPop parcourt les éléments dans l’anneau de destruction. Lorsque l’anneau de destruction est plein, les nouveaux éléments remplacent les éléments les plus anciens. Une opération kill qui est immédiatement précédée d’une autre opération kill ajoute le kill précédent, au lieu d’ajouter un nouvel élément ou de remplacer un élément dans l’anneau de destruction. C’est ainsi que vous pouvez couper une partie d’une ligne, par exemple, avec plusieurs opérations KillWord, puis les renvoyer ailleurs en tant que yank unique.

KillLine

  • Cmd : indépendant
  • Emacs: <Ctrl+K>

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

BackwardKillLine

  • Cmd : indépendant
  • Emacs : <Ctrl+U> ou <Ctrl+X,Backspace>

Effacez l’entrée du début de l’entrée vers le curseur. Le texte effacé est placé dans l’anneau de destruction.

KillWord

  • Cmd : indépendant
  • Emacs: <Alt+D>

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

BackwardKillWord

  • Cmd : indépendant
  • Emacs: <Alt+Backspace>

Effacez l’entrée du début du mot actuel vers le curseur. Si le curseur se trouve entre des 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 de destruction.

ShellKillWord

  • Cmd : indépendant
  • Emacs : indépendant

Comme KillWord, à l’exception des limites de mots sont définies par les limites de jeton PowerShell.

ShellBackwardKillWord

  • Cmd : indépendant
  • Emacs : indépendant

Comme BackwardKillWord, à l’exception des limites de mots sont définies par les limites de jeton PowerShell.

UnixWordRubout

  • Cmd : indépendant
  • Emacs: <Ctrl+W>

Comme BackwardKillWord, à l’exception des limites de mots sont définies par des espaces blancs.

KillRegion

  • Cmd : indépendant
  • Emacs : indépendant

Supprimez le texte entre le curseur et la marque.

Copier

  • Cmd : <Ctrl+Shift+C>
  • Emacs : indépendant

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 avec CancelLine.

Couper

  • Cmd : <Ctrl+X>
  • Emacs : indépendant

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

Yank

  • Cmd : indépendant
  • Emacs: <Ctrl+Y>

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

YankPop

  • Cmd : indépendant
  • Emacs: <Alt+Y>

Si l’opération précédente était Yank ou YankPop, remplacez le texte précédemment yanké par le texte tué suivant de l’anneau de destruction.

ClearKillRing

  • Cmd : indépendant
  • Emacs : indépendant

Le contenu de l’anneau de destruction est effacé.

Coller

  • Cmd : <Ctrl+V>
  • Emacs : indépendant

Ceci est similaire à Yank, mais utilise le Presse-papiers système au lieu de l’anneau kill.

[!IMPORTANT]

Lors de l’utilisation de la fonction Paste , tout le contenu 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 nouvelle ligne est copié. Par conséquent, l’entrée est analysée ligne par ligne. 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 (alt+. Alt+. insère le dernier argument de l’avant-dernière ligne d’historique).

Avec un argument, la première fois Que YankLastArg se comporte comme YankNthArg. Un argument négatif sur les appels YankLastArg suivants change la direction lors 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 : indépendant
  • 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 : indépendant
  • Emacs: <Ctrl+G>

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

CharacterSearch

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

Lisez une clé et recherchez ce caractère. Avec un argument, recherchez la nième occurrence de cet argument. Avec un argument négatif, recherche vers l’arrière.

CharacterSearchBackward

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

Comme CharacterSearch, mais recherche vers l’arrière. Avec un argument négatif, recherche vers l’avant.

ClearScreen

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

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

DigitArgument

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

Permet de passer des arguments numériques à des fonctions telles que CharacterSearch ou YankNthArg. Alt+- active l’argument pour qu’il soit négatif/non négatif. Pour entrer 80 caractères « * », vous pouvez taper Alt+8 Alt+0 *.

CaptureScreen

  • Cmd : indépendant
  • Emacs : indépendant

Copie les lignes sélectionnées dans le Presse-papiers aux formats texte et RTF. Utilisez les flèches haut/bas vers la première ligne à sélectionner, puis Maj+HautArrow/Maj+BasArrow pour sélectionner plusieurs lignes. Après avoir sélectionné, appuyez sur Entrée pour copier le texte. Échappement/Ctrl+C/Ctrl+G annule l’opération, de sorte que rien n’est copié dans le Presse-papiers.

InvokePrompt

  • Cmd : indépendant
  • Emacs : indépendant

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, comme la modification du répertoire actif.

WhatIsKey

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

Lire une touche ou un accord et afficher la liaison de touche.

ShowKeyBindings

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

Affiche toutes les clés actuellement liées.

ScrollDisplayUp

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

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

ScrollDisplayUpLine

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

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

ScrollDisplayDown

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

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

ScrollDisplayDownLine

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

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

ScrollDisplayTop

  • 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 liaisons de clés personnalisées à l’aide de l’applet de commande Set-PSReadLineKeyHandler. La plupart des liaisons de clés personnalisées appellent l’une des fonctions ci-dessus, par exemple

Set-PSReadLineKeyHandler -Key UpArrow -Function HistorySearchBackward

Vous pouvez lier un ScriptBlock à une clé. ScriptBlock peut faire à peu près tout ce que vous voulez. Voici quelques exemples utiles

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

Le ScriptBlock reçoit deux arguments :

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

  • $arg - Argument arbitraire. Le plus souvent, il s’agit d’un argument entier que l’utilisateur passe à 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 que vous 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 de 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 de la liaison 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()

Effacez l’anneau de mort. Il 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/la restauration.

void Ding()

Effectuez l’action Ding en fonction de la préférence des utilisateurs.

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 deuxième 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 liaison de clé 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 aucune sélection sur la ligne de commande, -1 est retourné à la fois au début et à la longueur. S’il existe une sélection sur la ligne de commande, le début et la longueur de la sélection sont retourné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/la restauration.

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

Il s’agit du point d’entrée main vers PSReadLine. Il ne prend pas en charge la récursivité. Il n’est donc pas utile dans une liaison de clé 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/la restauration. Cette option est préférable à Supprimer suivie de l’option Insérer, car elle est traitée comme une action unique d’annulation.

void SetCursorPosition(int cursor)

Déplacez le curseur vers le décalage donné. Le déplacement du curseur n’est pas suivi pour annuler.

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 pour une liaison de clé 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)

REMARQUE

COMPATIBILITÉ POWERSHELL

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

HISTORIQUE DES COMMANDES

PSReadLine conserve un fichier d’historique contenant toutes les commandes et données que vous avez entrées à partir de la ligne de commande. Il 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 enregistré dans le fichier d’historique en tant que 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é dans $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine.

COMMENTAIRES & CONTRIBUTION À PSReadLine

PSReadLine sur GitHub

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

VOIR AUSSI

PSReadLine est fortement influencé par la bibliothèque de lignes de lecture GNU.