PSReadLine

about_PSReadLine

BREVE DESCRIÇÃO

O PSReadLine proporciona uma experiência de edição de linha de comando melhorada na consola PowerShell.

LONGA DESCRIÇÃO

O PSReadLine fornece uma poderosa experiência de edição de linha de comando para a consola PowerShell. Fornece:

• Coloração sintaxe da linha de comando
• Uma indicação visual de erros de sintaxe
• Uma melhor experiência multi-linha (edição e história)
• Encadernações de chaves personalizáveis
• Modos Cmd e Emacs
• Muitas opções de configuração
• Conclusão do estilo bash (opcional no modo Cmd, padrão no modo Emacs)
• Anel de emacs yank/kill
• Movimento e morte de "palavra" baseado em powerShell

As seguintes funções estão disponíveis na classe [Microsoft.PowerShell.PSConsoleReadLine].

Movimento cursor

EndOfLine

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

Se a entrada tiver várias linhas, mova-se para o fim da linha atual, ou se já no final da linha, mova-se para o fim da entrada. Se a entrada tiver uma única linha, mova-se para o fim da entrada.

BeginningOfLine

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

Se a entrada tiver várias linhas, mova-se para o início da linha atual, ou se já no início da linha, mova-se para o início da entrada. Se a entrada tiver uma única linha, mova-se para o início da entrada.

NextLine

• Cmd: unbound
• Emacs: unbound

Mova o cursor para a linha seguinte se a entrada tiver várias linhas.

Linha Anterior

• Cmd: unbound
• Emacs: unbound

Mova o cursor para a linha anterior se a entrada tiver várias linhas.

ForwardChar

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

Mova o cursor um personagem para a direita. Isto pode mover o cursor para a próxima linha de entrada multi-linha.

BackwardChar

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

Mova o cursor um personagem para a esquerda. Isto pode mover o cursor para a linha anterior de entrada multi-linha.

Palavra de avanço

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

Mova o cursor para a frente até ao fim da palavra atual, ou se entre palavras, para o fim da próxima palavra. Pode definir caracteres delimiter de palavra com:

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

NextWord

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

Mova o cursor para a frente para o início da próxima palavra. Pode definir caracteres delimiter de palavra com:

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

Palavra de trás

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

Desloque o cursor de volta para o início da palavra atual, ou se entre palavras, o início da palavra anterior. Pode definir caracteres delimiter de palavra com:

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

ShellForwardWord

• Cmd: unbound
• Emacs: unbound

Tal como o ForwardWord, exceto que os limites de palavras são definidos pelos limites do token PowerShell.

ShellNextWord

• Cmd: unbound
• Emacs: unbound

Como nextWord exceto os limites de palavras são definidos por limites de token PowerShell.

ShellBackwardWord

• Cmd: unbound
• Emacs: unbound

Como o BackwardWord, exceto que os limites de palavras são definidos pelos limites do token PowerShell.

GotoBrace

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

Vá para o parênteses correspondente, cinta encaracolada ou suporte quadrado.

AddLine

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

A solicitação de continuação é exibida na linha seguinte e o PSReadLine aguarda as teclas para editar a entrada atual. Isto é útil para introduzir a entrada multi-linha como um único comando, mesmo quando uma única linha é completamente a entrada por si só.

Edição básica

CancelLine

• Cmd: unbound
• Emacs: unbound

Cancele toda a edição para a linha, deixe a linha de entrada no ecrã mas regresse do PSReadLine sem executar a entrada.

RevertLine

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

Reverte toda a entrada desde que a última entrada foi aceite e executada. Isto equivale a usar o comando desfazer até não restar nada para desfazer.

BackwardDeleteChar

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

Elimine o carácter antes do cursor.

DeleteChar

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

Elimine o carácter sob o cursor.

ExcluirCharOrExit

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

Como DeleteChar, a menos que a linha esteja vazia, nesse caso sai do processo.

AcceptLine

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

Tente executar a entrada atual. Se a entrada atual estiver incompleta (por exemplo, falta um parênteses de fecho, suporte ou citação), então o pedido de continuação é apresentado na linha seguinte e o PSReadLine aguarda as teclas para editar a entrada atual.

AcceptAndGetNext

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

Como AcceptLine, mas depois que a linha termina, comece a editar a próxima linha da história.

ValidarAndAcceptLine

• Cmd: unbound
• Emacs: unbound

Como AcceptLine mas executa validação adicional, incluindo:

• Verifica erros adicionais de análise
• Valida que os nomes de comando são todos encontrados
• Se estiver a executar PowerShell 4.0 ou mais recente, valida os parâmetros e argumentos

Se houver erros, a mensagem de erro é exibida e não aceite nem adicionada ao histórico, a menos que corrija a linha de comando ou execute AcceptLine ou ValideEAcceptLine novamente enquanto a mensagem de erro é exibida.

Linha DeTrásDelete

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

Elimine o texto desde o início da entrada para o cursor.

ForwardDeleteLine

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

Elimine o texto do cursor até ao fim da entrada.

SelectBackwardChar

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

Ajuste a seleção atual para incluir o carácter anterior.

SelectForwardChar

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

Ajuste a seleção atual para incluir o próximo personagem.

SelecioneBackwardWord

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

Ajuste a seleção atual para incluir a palavra anterior.

SelecioneForwardWord

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

Ajuste a seleção atual para incluir a próxima palavra utilizando o ForwardWord.

SelecioneNeword

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

Ajuste a seleção atual para incluir a próxima palavra usando nextWord.

SelecioneShellForwardWord

• Cmd: unbound
• Emacs: unbound

Ajuste a seleção atual para incluir a próxima palavra usando o ShellForwardWord.

SelecioneShellNextWord

• Cmd: unbound
• Emacs: unbound

Ajuste a seleção atual para incluir a próxima palavra usando o ShellNextWord.

SelecioneShellBackwardWord

• Cmd: unbound
• Emacs: unbound

Ajuste a seleção atual para incluir a palavra anterior usando o ShellBackwardWord.

SelectBackwardsLine

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

Ajuste a seleção atual para incluir do cursor até ao início da linha.

SelectLine

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

Ajuste a seleção atual para incluir do cursor até ao fim da linha.

SelectAll

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

Selecione toda a linha. Move o cursor para o fim da linha.

SelfInsert

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

Insira a chave inserida.

Refazer

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

Refaça uma inserção ou supressão que foi desfeita por Undo.

Anular

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

Desfaça uma inserção ou supressão anteriores.

Histórico

Limpar A História

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

Limpa a história no PSReadLine. Isto não afeta a história da PowerShell.

História anterior

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

Substitua a entrada atual pelo item anterior do histórico PSReadLine.

Próxima História

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

Substitua a entrada atual pelo próximo item do histórico PSReadLine.

ForwardSearchHistory

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

Procure para a frente a partir da linha de história atual interativamente.

ReverseSearchHistory

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

Procure para trás a partir da linha de história atual interativamente.

HistóriaSearchBackward

• Cmd:<F8>
• Emacs: unbound

Substitua a entrada atual pelo item anterior do histórico PSReadLine que corresponda aos caracteres entre o início e a entrada e o cursor.

HistóriaSearchForward

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

Substitua a entrada atual pelo próximo item do histórico PSReadLine que corresponda aos caracteres entre o início e a entrada e o cursor.

Início da História

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

Substitua a entrada atual pelo último item do histórico PSReadLine.

Fim da História

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

Substitua a entrada atual pelo último item na história do PSReadLine, que é a entrada possivelmente vazia que foi inserida antes de qualquer comando histórico.

Conclusão do separador

TabCompleteNext

• Cmd:<Tab>
• Emacs: unbound

Tente completar o texto em torno do cursor com a próxima conclusão disponível.

TabCompletePrevious

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

Tente completar o texto que rodeia o cursor com a conclusão anterior.

Concluído

• Cmd: unbound
• Emacs:<Tab>

Tente realizar a conclusão do texto que rodeia o cursor. Se houver múltiplas possíveis conclusões, o prefixo mais longo e inequívoco é usado para a conclusão. Se estiver a tentar completar a maior conclusão inequívoca, é apresentada uma lista de possíveis conclusões.

MenuComplete

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

Tente realizar a conclusão do texto que rodeia o cursor. Se houver várias possíveis conclusões, é apresentada uma lista de possíveis acabamentos, e pode selecionar a conclusão correta utilizando as teclas de seta, ou Tab/Shift+Tab. Escape e Ctrl+G cancelar a seleção do menu e reverter a linha para o estado antes de invocar menuComplete.

PossíveisConselhos

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

Mostrar a lista de possíveis conclusões.

SetMark

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

Marque a localização atual do cursor para utilização num comando de edição subsequente.

ExchangePointAndMark

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

O cursor é colocado no local da marca e a marca é movida para o local do cursor.

Matar/Yank

Kill e Yank operam numa área de transferência no módulo PSReadLine. Há um tampão chamado anel de morte - o texto morto é adicionado ao anel de morte e o yank copiará o texto da morte mais recente. YankPop passa por itens no anel de morte. Quando o anel de morte estiver cheio, os novos itens substituem os itens mais antigos. Uma operação de morte que é imediatamente precedida por outra operação de morte anexa a morte anterior, em vez de adicionar um novo item ou substituir um item no anel de morte. É assim que se pode cortar uma parte de uma linha, por exemplo, com várias operações killWord, e depois puxá-las para outro lugar como um único puxão.

KillLine

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

Limpe a entrada do cursor até ao fim da linha. O texto limpo é colocado no anel de morte.

Linha De Trás

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

Limpe a entrada desde o início da entrada para o cursor. O texto limpo é colocado no anel de morte.

Palavra de Morte

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

Limpe a entrada do cursor até ao fim da palavra atual. Se o cursor estiver entre palavras, a entrada é limpa do cursor até ao fim da próxima palavra. O texto limpo é colocado no anel de morte.

Palavra de Trás-Atrás

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

Limpe a entrada desde o início da palavra atual para o cursor. Se o cursor estiver entre palavras, a entrada é apurada desde o início da palavra anterior ao cursor. O texto limpo é colocado no anel de morte.

ShellKillWord

• Cmd: unbound
• Emacs: unbound

Tal como o KillWord, exceto que os limites de palavras são definidos pelos limites do token PowerShell.

ShellBackwardKillWord

• Cmd: unbound
• Emacs: unbound

Tal como o BackwardKillWord, exceto que os limites de palavras são definidos pelos limites do token PowerShell.

UnixWordRubout

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

Como o BackwardKillWord, exceto que os limites de palavras são definidos pelo espaço branco.

KillRegion

• Cmd: unbound
• Emacs: unbound

Desligue o texto entre o cursor e a marca.

Copiar

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

Copie a região selecionada para a área de transferência do sistema. Se não for selecionada nenhuma região, copie toda a linha.

CopyOrCancelLine

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

Ou copia texto selecionado para a área de transferência, ou se nenhum texto for selecionado, cancele a edição da linha com a CancelLine.

Cortar

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

Eliminar a região selecionada colocando texto eliminado na área de transferência do sistema.

Rio Yank

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

Adicione o texto mais recentemente morto à entrada.

YankPop

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

Se a operação anterior foi Yank ou YankPop, substitua o texto anteriormente arrancado pelo próximo texto morto do anel de morte.

ClearKillRing

• Cmd: unbound
• Emacs: unbound

O conteúdo do anel de morte está limpo.

Colar

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

Isto é semelhante ao Yank, mas usa a prancheta do sistema em vez do anel de morte.

[!IMPORTANT]

Ao utilizar a função Pasta, todo o conteúdo do tampão da área de transferência é colado no tampão de entrada do PSReadLine. O tampão de entrada é então passado para o parser PowerShell. A entrada colada utilizando o método de pasta de clique direito da aplicação da consola é copiada para o tampão de entrada um personagem de cada vez. O tampão de entrada é passado para o parser quando um personagem de linha nova é copiado. Portanto, a entrada é analisada uma linha de cada vez. A diferença entre métodos de pasta resulta em diferentes comportamentos de execução.

YankLastArg

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

Insira o último argumento do comando anterior na história. As operações repetidas substituem o último argumento inserido com o último argumento do comando anterior (assim Alt+. Alt+. vai inserir o último argumento da segunda à última linha da história).

Com uma discussão, a primeira vez que YankLastArg se comporta como YankNthArg. Um argumento negativo sobre as chamadas yankLastArg subsequentes muda a direção enquanto passa pela história. Por exemplo, se premir Alt+. umas demasiadas vezes, podes escrever Alt+- Alt+. para inverter a direção.

Os argumentos são baseados em fichas PowerShell.

YankNthArg

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

Insira o primeiro argumento (não o nome de comando) do comando anterior na história.

Com um argumento, insira o noth argumento onde 0 é tipicamente o comando. Os argumentos negativos começam do fim.

Os argumentos são baseados em fichas PowerShell.

Diversos

Abortar

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

Abortar a ação atual; por exemplo, parar a pesquisa de histórico interativo. Não cancela a entrada como a CancelLine.

CharacterSearch

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

Leia uma chave e procure para a frente por esse personagem. Com um argumento, procurem pela noth ocorrência desse argumento. Com um argumento negativo, procura ao contrário.

CharacterSearchBackward

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

Como o CharacterSearch, mas procura ao contrário. Com um argumento negativo, procura para a frente.

ClearScreen

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

Limpa o ecrã e exibe a solicitação e a entrada atuais na parte superior do ecrã.

DígitoArgument

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

Usado para passar argumentos numéricos para funções como CharacterSearch ou YankNthArg. Alt+- alterna o argumento para ser negativo/não negativo. Para introduzir caracteres de 80 * ' ' pode escrever Alt+8 Alt+0 * .

Ecrã de captura

• Cmd: unbound
• Emacs: unbound

Copia linhas selecionadas para a área de transferência em ambos os formatos de texto e RTF. Utilize teclas de seta para cima/para baixo na primeira linha para selecionar e, em seguida, Shift+UpArrow/Shift+DownArrow para selecionar várias linhas. Depois de selecionar, prima Enter para copiar o texto. A fuga/Ctrl+C/Ctrl+G cancela a operação, pelo que nada é copiado para a área de transferência.

InvocarPrompt

• Cmd: unbound
• Emacs: unbound

Apaga a solicitação atual e chama a função de solicitação para reprodução do pedido. Útil para manipuladores de chaves personalizados que mudam de estado, como alterar o diretório atual.

WhatIsKey

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

Leia uma chave ou acorde e apresente a chave de encadernação.

ShowKeyBindings

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

Mostre todas as chaves atualmente ligadas.

ScrollDisplayUp

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

Desloque o visor para cima de um ecrã.

ScrollDisplayUpLine

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

Desloque o visor para cima de uma linha.

ScrollDisplayDown

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

Desloque o visor para baixo com um ecrã.

ScrollDisplayDownLine

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

Desloque o visor para baixo numa linha.

RolodisplayTop

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

Desloque o visor para a parte superior.

ScrollDisplayToCursor

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

Desloque o visor para o cursor.

Encadernações de chave personalizadas

O PSReadLine suporta ligações de chaves personalizadas utilizando o cmdlet Set-PSReadLineKeyHandler . A maioria das ligações de chaves personalizadas chamam uma das funções acima, por exemplo

Set-PSReadLineKeyHandler -Key UpArrow -Function HistorySearchBackward

Pode ligar um ScriptBlock a uma chave. O ScriptBlock pode fazer o que quiser. Alguns exemplos úteis incluem

• editar a linha de comando
• abertura de uma nova janela (por exemplo, ajuda)
• mudar diretórios sem alterar a linha de comando

O ScriptBlock recebe dois argumentos:

• $key- Um objeto [ConsoleKeyInfo] que é a chave que desencadeou a ligação personalizada. Se ligar o mesmo ScriptBlock a várias teclas e precisar de executar diferentes ações dependendo da chave, pode verificar $key. Muitas encadernações personalizadas ignoram este argumento.

• $arg- Um argumento arbitrário. Na maioria das vezes, este seria um argumento inteiro que o utilizador passa a partir das chaves ligações DigitArgument. Se a sua ligação não aceita argumentos, é razoável ignorar este argumento.

Vamos dar uma olhada num exemplo que adiciona uma linha de comando à história sem executá-la. Isto é útil quando te apercebes que te esqueceste de fazer alguma coisa, mas não queres voltar a entrar na linha de comando que já entraste.

$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

Pode ver muitos mais exemplos no ficheiro SamplePSReadLineProfile.ps1 que está instalado na pasta do módulo PSReadLine.

A maioria das ligações principais utilizam algumas funções de ajudante para editar a linha de comando. Essas APIs estão documentadas na próxima secção.

APIs de suporte de ligação de chaves personalizadas

As seguintes funções são públicas em Microsoft.PowerShell.PSConsoleReadLine, mas não podem ser diretamente ligadas a uma chave. A maioria é útil em encadernações de chaves personalizadas.

void AddToHistory(string command)

Adicione uma linha de comando à história sem executá-la.

void ClearKillRing()

Limpem o anel de morte. Isto é usado principalmente para testes.

void Delete(int start, int length)

Elimine os caracteres de comprimento desde o início. Esta operação suporta desfazer/refazer.

void Ding()

Execute a ação Ding com base na preferência dos utilizadores.

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

Estas duas funções recuperam informações úteis sobre o estado atual do tampão de entrada. O primeiro é mais comumente usado para casos simples. A segunda é usada se a sua ligação estiver a fazer algo mais avançado com o Ast.

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

Esta função é utilizada pelo Get-PSReadLineKeyHandler e provavelmente não é útil numa ligação de chave personalizada.

Microsoft.PowerShell.PSConsoleReadLineOptions GetOptions()

Esta função é utilizada pela Get-PSReadLineOption e provavelmente não é muito útil numa ligação de chave personalizada.

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

Se não houver seleção na linha de comando, -1 será devolvido tanto no início como no comprimento. Se houver uma seleção na linha de comando, o início e a duração da seleção são devolvidos.

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

Insira um carácter ou corda no cursor. Esta operação suporta desfazer/refazer.

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

Este é o principal ponto de entrada para o PSReadLine. Não suporta a recursão, pelo que não é útil numa chave personalizada.

void RemoveKeyHandler(string[] key)

Esta função é utilizada por Remove-PSReadLineKeyHandler e provavelmente não é muito útil numa ligação de chave personalizada.

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

Substitua parte da entrada. Esta operação suporta desfazer/refazer. Isto é preferido sobre Delete seguido por Insert porque é tratado como uma única ação para desfazer.

void SetCursorPosition(int cursor)

Mova o cursor para o offset dado. O movimento cursor não é rastreado para desfazer.

void SetOptions(Microsoft.PowerShell.SetPSReadLineOption options)

Esta função é um método de ajuda utilizado pelo cmdlet Set-PSReadLineOption, mas pode ser útil para uma ligação de chave personalizada que quer alterar temporariamente uma definição.

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

Este método de ajuda é usado para encadernações personalizadas que honram o DigitArgument. Uma chamada típica parece

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

NOTA

COMPATIBILIDADE POWERSHELL

O PSReadLine requer o PowerShell 3.0, ou mais recente, e o anfitrião da consola. Não funciona na PowerShell ISE. Funciona na consola do Código do Estúdio Visual.

HISTÓRICO DE COMANDO

O PSReadLine mantém um ficheiro de histórico contendo todos os comandos e dados introduzidos a partir da linha de comando. Isto pode conter dados sensíveis, incluindo palavras-passe. Por exemplo, se utilizar o ConvertTo-SecureString cmdlet, a palavra-passe é registada no ficheiro histórico como texto simples. Os ficheiros de histórico são um ficheiro chamado $($host.Name)_history.txt . Nos sistemas Windows, o ficheiro de histórico é armazenado em $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine .

FEEDBACK & a contribuir para o PSReadLine

PSReadLine no GitHub

Sinta-se livre para submeter um pedido de puxar ou enviar feedback na página gitHub.

VER TAMBÉM

O PSReadLine é fortemente influenciado pela biblioteca de leitura do GNU.