shell Zsh zle移位选择

wxclj1h5  于 2023-01-13  发布在  Shell
关注(0)|答案(6)|浏览(132)

如何使用shift来选择部分命令行（就像在许多文本编辑器中一样）？

shell

6条答案

按热度按时间
fv2wmkja

fv2wmkja1#

在Stephane 3年前给出的回答的基础上，我又添加了一些绑定，使其行为（几乎）与Windows所有的标准键盘行为完全一致：

  • 使用导航键（箭头、主页、结束）而不切换时，选择被清除
  • Backspace和Del删除活动的选定内容
  • 使用Ctrl+Shift+Left/Ctrl+Shift+Right时，选择扩展到下一个/上一个字
  • Shift+Home和Shift+End分别将选定内容扩展到行首和行尾。Ctrl+Shift+Home和Ctrl+Shift+End的作用相同。

两件事并不完全相同：

  • 扩展选择到下一个单词包括尾随空格，不像窗口。这个可以修复，但它不困扰我。
  • 当有一个活动的选定区域时，键入将不会删除它并用您键入的字符替换它。这似乎需要更多的工作来重新Map整个键盘。对我来说不值得这么麻烦。

注意，默认的mintty行为是绑定Shift+End和Shift+Home来访问回滚缓冲区，这取代了zsh配置;这些键永远不会被传递。为了使这些工作，你需要在/etc/minttyrc或~/.minttyrc中配置一个不同的键（或禁用滚动）。参见“用于滚动的修饰符”here-最简单的解决方案是设置ScrollMod=2将其绑定到Alt而不是Shift。
所以一切：

~/.分钟

ScrollMod=2

~/.zshrc

r-delregion() {
  if ((REGION_ACTIVE)) then
     zle kill-region
  else 
    local widget_name=$1
    shift
    zle $widget_name -- $@
  fi
}

r-deselect() {
  ((REGION_ACTIVE = 0))
  local widget_name=$1
  shift
  zle $widget_name -- $@
}

r-select() {
  ((REGION_ACTIVE)) || zle set-mark-command
  local widget_name=$1
  shift
  zle $widget_name -- $@
}

for key     kcap   seq        mode   widget (
    sleft   kLFT   $'\e[1;2D' select   backward-char
    sright  kRIT   $'\e[1;2C' select   forward-char
    sup     kri    $'\e[1;2A' select   up-line-or-history
    sdown   kind   $'\e[1;2B' select   down-line-or-history

    send    kEND   $'\E[1;2F' select   end-of-line
    send2   x      $'\E[4;2~' select   end-of-line

    shome   kHOM   $'\E[1;2H' select   beginning-of-line
    shome2  x      $'\E[1;2~' select   beginning-of-line

    left    kcub1  $'\EOD'    deselect backward-char
    right   kcuf1  $'\EOC'    deselect forward-char

    end     kend   $'\EOF'    deselect end-of-line
    end2    x      $'\E4~'    deselect end-of-line

    home    khome  $'\EOH'    deselect beginning-of-line
    home2   x      $'\E1~'    deselect beginning-of-line

    csleft  x      $'\E[1;6D' select   backward-word
    csright x      $'\E[1;6C' select   forward-word
    csend   x      $'\E[1;6F' select   end-of-line
    cshome  x      $'\E[1;6H' select   beginning-of-line

    cleft   x      $'\E[1;5D' deselect backward-word
    cright  x      $'\E[1;5C' deselect forward-word

    del     kdch1   $'\E[3~'  delregion delete-char
    bs      x       $'^?'     delregion backward-delete-char

  ) {
  eval "key-$key() {
    r-$mode $widget \$@
  }"
  zle -N key-$key
  bindkey ${terminfo[$kcap]-$seq} key-$key
}

这涵盖了我使用过的几种不同键盘配置的键码。

**注意：**key列中的值没有任何意义，它们只是用来为zle构建一个命名引用，可以是任何值，重要的是seq，mode和widget列。
注2：你可以绑定几乎任何你想要的键，你只需要在你的控制台模拟器中使用的键代码。打开一个普通的控制台（不运行zsh），键入Ctrl+V，然后键入你想要的键。它应该发出代码。^[意味着\E。

赞(0）分享  回复(0）举报  2023-01-13
nfg76nw0

nfg76nw02#

shift-arrow() {
  ((REGION_ACTIVE)) || zle set-mark-command
  zle $1
}
shift-left()  shift-arrow backward-char
shift-right() shift-arrow forward-char
shift-up()    shift-arrow up-line-or-history
shift-down()  shift-arrow down-line-or-history
zle -N shift-left
zle -N shift-right
zle -N shift-up
zle -N shift-down

bindkey $terminfo[kLFT] shift-left
bindkey $terminfo[kRIT] shift-right
bindkey $terminfo[kri]  shift-up
bindkey $terminfo[kind] shift-down

假设您的终端在Shift-Arrows上发送的转义序列与在Arrow上发送的转义序列不同，并且您的terminfo数据库正确地填充了相应的kLFT和kRIT功能，并且您使用的是emacs风格的键绑定。
或者，对代码进行一点因式分解：

shift-arrow() {
  ((REGION_ACTIVE)) || zle set-mark-command
  zle $1
}
for key  kcap seq        widget (
    left  LFT $'\e[1;2D' backward-char
    right RIT $'\e[1;2C' forward-char
    up    ri  $'\e[1;2A' up-line-or-history
    down  ind $'\e[1;2B' down-line-or-history
  ) {
  functions[shift-$key]="shift-arrow $widget"
  zle -N shift-$key
  bindkey ${terminfo[k$kcap]-$seq} shift-$key
}

以上是terminfo数据库没有信息时的硬编码序列（使用xterm序列）。

赞(0）分享  回复(0）举报  2023-01-13
nkoocmlb

nkoocmlb3#

扩展了杰米·特雷沃基的回答。
包括以下功能：

  • cmd+a：选择整个命令行提示文本
  • cmd+x：剪切（复制和删除）当前命令行选择到剪贴板
  • cmd+c：将当前命令行选择复制到剪贴板
  • cmd+v：粘贴剪贴板选定内容
  • ctrl+u：向后删除，直到行首
  • cmd+z：撤消
  • cmd+shift+z：重做
      • 移位选择**：
  • shift-left：选择左边的字符
  • shift-right：选择右侧字符
  • shift-up：向上选择行
  • shift-down：选择实时向下
  • cmd-shift-left：选择到行首
  • cmd-shift-right：选择直到行尾
  • alt-shift-left：选择左侧的单词
  • alt-shift-right：选择右侧的单词
  • ctrl-shift-left：选择到行首
  • ctrl-shift-right：选择直到行尾
  • ctrl-shift-a：选择到行首
  • ctrl-shift-e：选择直到行尾
      • 取消选择**：在left/right、alt-left/right、cmd/ctrl-left/right和esc+esc上按预期工作。
      • 删除选择**：在Delete、ctrl+d、backspace上按预期工作
      • 删除选定内容并插入字符**：对所有可见ASCII字符和空格按预期工作
      • 删除选定内容并插入剪贴板**：按预期工作
.zshrc
# for my own convenience I explicitly set the signals
#   that my terminal sends to the shell as variables.
#   you might have different signals. you can see what
#   signal each of your keys sends by running `$> cat`
#   and pressing keys (you'll be able to see most keys)
#   also some of the signals sent might be set in your 
#   terminal emulator application/program
#   configurations/preferences. finally some terminals
#   have a feature that shows you what signals are sent
#   per key press.
#
# for context, at the time of writing these variables are
#   set for the kitty terminal program, i.e these signals  
#   are mostly ones sent by default by this terminal.
export KEY_ALT_F='ƒ'
export KEY_ALT_B='∫'
export KEY_ALT_D='∂'
export KEY_CTRL_U=$'\x15' # ^U
export KEY_CMD_BACKSPACE=$'^[b'   # arbitrary; added via kitty config (send_text)
export KEY_CMD_Z=^[[122;9u
export KEY_SHIFT_CMD_Z=^[[122;10u
export KEY_CTRL_R=$'\x12' # ^R
export KEY_CMD_C=^[[99;9u
export KEY_CMD_X=^[[120;9u
export KEY_CMD_V=^[[118;9u
export KEY_CMD_A=^[[97;9u
export KEY_CTRL_L=$'\x0c' # ^L
export KEY_LEFT=${terminfo[kcub1]:-$'^[[D'}
export KEY_RIGHT=${terminfo[kcuf1]:-$'^[[C'}
export KEY_SHIFT_UP=${terminfo[kri]:-$'^[[1;2A'}
export KEY_SHIFT_DOWN=${terminfo[kind]:-$'^[[1;2B'}
export KEY_SHIFT_RIGHT=${terminfo[kRIT]:-$'^[[1;2C'}
export KEY_SHIFT_LEFT=${terminfo[kLFT]:-$'^[[1;2D'}
export KEY_ALT_LEFT=$'^[[1;3D'
export KEY_ALT_RIGHT=$'^[[1;3C'
export KEY_SHIFT_ALT_LEFT=$'^[[1;4D'
export KEY_SHIFT_ALT_RIGHT=$'^[[1;4C'
export KEY_CMD_LEFT=$'^[[1;9D'
export KEY_CMD_RIGHT=$'^[[1;9C'
export KEY_SHIFT_CMD_LEFT=$'^[[1;10D'
export KEY_SHIFT_CMD_RIGHT=$'^[[1;10C'
export KEY_CTRL_A=$'\x01' # ^A
export KEY_CTRL_E=$'\x05' # ^E
export KEY_SHIFT_CTRL_A=$'^[[97;6u'
export KEY_SHIFT_CTRL_E=$'^[[101;6u'
export KEY_SHIFT_CTRL_LEFT=$'^[[1;6D'
export KEY_SHIFT_CTRL_RIGHT=$'^[[1;6C'
export KEY_CTRL_D=$'\x04' # ^D

# -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

# copy selected terminal text to clipboard
zle -N widget::copy-selection
function widget::copy-selection {
    if ((REGION_ACTIVE)); then
        zle copy-region-as-kill
        printf "%s" $CUTBUFFER | pbcopy
    fi
}

# cut selected terminal text to clipboard
zle -N widget::cut-selection
function widget::cut-selection() {
    if ((REGION_ACTIVE)) then
        zle kill-region
        printf "%s" $CUTBUFFER | pbcopy
    fi
}

# paste clipboard contents
zle -N widget::paste
function widget::paste() {
    ((REGION_ACTIVE)) && zle kill-region
    RBUFFER="$(pbpaste)${RBUFFER}"
    CURSOR=$(( CURSOR + $(echo -n "$(pbpaste)" | wc -m | bc) ))
}

# select entire prompt
zle -N widget::select-all
function widget::select-all() {
    local buflen=$(echo -n "$BUFFER" | wc -m | bc)
    CURSOR=$buflen   # if this is messing up try: CURSOR=9999999
    zle set-mark-command
    while [[ $CURSOR > 0 ]]; do
        zle beginning-of-line
    done
}

# scrolls the screen up, in effect clearing it
zle -N widget::scroll-and-clear-screen
function widget::scroll-and-clear-screen() {
    printf "\n%.0s" {1..$LINES}
    zle clear-screen
}

function widget::util-select() {
    ((REGION_ACTIVE)) || zle set-mark-command
    local widget_name=$1
    shift
    zle $widget_name -- $@
}

function widget::util-unselect() {
    REGION_ACTIVE=0
    local widget_name=$1
    shift
    zle $widget_name -- $@
}

function widget::util-delselect() {
    if ((REGION_ACTIVE)) then
        zle kill-region
    else
        local widget_name=$1
        shift
        zle $widget_name -- $@
    fi
}

function widget::util-insertchar() {
    ((REGION_ACTIVE)) && zle kill-region
    RBUFFER="${1}${RBUFFER}"
    zle forward-char
}

#                       |  key sequence                   | command
# --------------------- | ------------------------------- | -------------

bindkey                   $KEY_ALT_F                        forward-word
bindkey                   $KEY_ALT_B                        backward-word
bindkey                   $KEY_ALT_D                        kill-word
bindkey                   $KEY_CTRL_U                       backward-kill-line
bindkey                   $KEY_CMD_BACKSPACE                backward-kill-line
bindkey                   $KEY_CMD_Z                        undo
bindkey                   $KEY_SHIFT_CMD_Z                  redo
bindkey                   $KEY_CTRL_R                       history-incremental-search-backward
bindkey                   $KEY_CMD_C                        widget::copy-selection
bindkey                   $KEY_CMD_X                        widget::cut-selection
bindkey                   $KEY_CMD_V                        widget::paste
bindkey                   $KEY_CMD_A                        widget::select-all
bindkey                   $KEY_CTRL_L                       widget::scroll-and-clear-screen

for keyname        kcap   seq                   mode        widget (

    left           kcub1  $KEY_LEFT             unselect    backward-char
    right          kcuf1  $KEY_RIGHT            unselect    forward-char

    shift-up       kri    $KEY_SHIFT_UP         select      up-line-or-history
    shift-down     kind   $KEY_SHIFT_DOWN       select      down-line-or-history
    shift-right    kRIT   $KEY_SHIFT_RIGHT      select      forward-char
    shift-left     kLFT   $KEY_SHIFT_LEFT       select      backward-char

    alt-right         x   $KEY_ALT_RIGHT        unselect    forward-word
    alt-left          x   $KEY_ALT_LEFT         unselect    backward-word
    shift-alt-right   x   $KEY_SHIFT_ALT_RIGHT  select      forward-word
    shift-alt-left    x   $KEY_SHIFT_ALT_LEFT   select      backward-word

    cmd-right         x   $KEY_CMD_RIGHT        unselect    end-of-line
    cmd-left          x   $KEY_CMD_LEFT         unselect    beginning-of-line
    shift-cmd-right   x   $KEY_SHIFT_CMD_RIGHT  select      end-of-line
    shift-cmd-left    x   $KEY_SHIFT_CMD_LEFT   select      beginning-of-line

    ctrl-e            x   $KEY_CTRL_E           unselect    end-of-line
    ctrl-a            x   $KEY_CTRL_A           unselect    beginning-of-line
    shift-ctrl-e      x   $KEY_SHIFT_CTRL_E     select      end-of-line
    shift-ctrl-a      x   $KEY_SHIFT_CTRL_A     select      beginning-of-line
    shift-ctrl-right  x   $KEY_SHIFT_CTRL_RIGHT select      end-of-line
    shift-ctrl-left   x   $KEY_SHIFT_CTRL_LEFT  select      beginning-of-line

    del               x   $KEY_CTRL_D           delselect   delete-char

    a                 x       'a'               insertchar  'a'
    b                 x       'b'               insertchar  'b'
    c                 x       'c'               insertchar  'c'
    d                 x       'd'               insertchar  'd'
    e                 x       'e'               insertchar  'e'
    f                 x       'f'               insertchar  'f'
    g                 x       'g'               insertchar  'g'
    h                 x       'h'               insertchar  'h'
    i                 x       'i'               insertchar  'i'
    j                 x       'j'               insertchar  'j'
    k                 x       'k'               insertchar  'k'
    l                 x       'l'               insertchar  'l'
    m                 x       'm'               insertchar  'm'
    n                 x       'n'               insertchar  'n'
    o                 x       'o'               insertchar  'o'
    p                 x       'p'               insertchar  'p'
    q                 x       'q'               insertchar  'q'
    r                 x       'r'               insertchar  'r'
    s                 x       's'               insertchar  's'
    t                 x       't'               insertchar  't'
    u                 x       'u'               insertchar  'u'
    v                 x       'v'               insertchar  'v'
    w                 x       'w'               insertchar  'w'
    x                 x       'x'               insertchar  'x'
    y                 x       'y'               insertchar  'y'
    z                 x       'z'               insertchar  'z'
    A                 x       'A'               insertchar  'A'
    B                 x       'B'               insertchar  'B'
    C                 x       'C'               insertchar  'C'
    D                 x       'D'               insertchar  'D'
    E                 x       'E'               insertchar  'E'
    F                 x       'F'               insertchar  'F'
    G                 x       'G'               insertchar  'G'
    H                 x       'H'               insertchar  'H'
    I                 x       'I'               insertchar  'I'
    J                 x       'J'               insertchar  'J'
    K                 x       'K'               insertchar  'K'
    L                 x       'L'               insertchar  'L'
    M                 x       'M'               insertchar  'M'
    N                 x       'N'               insertchar  'N'
    O                 x       'O'               insertchar  'O'
    P                 x       'P'               insertchar  'P'
    Q                 x       'Q'               insertchar  'Q'
    R                 x       'R'               insertchar  'R'
    S                 x       'S'               insertchar  'S'
    T                 x       'T'               insertchar  'T'
    U                 x       'U'               insertchar  'U'
    V                 x       'V'               insertchar  'V'
    W                 x       'W'               insertchar  'W'
    X                 x       'X'               insertchar  'X'
    Y                 x       'Y'               insertchar  'Y'
    Z                 x       'Z'               insertchar  'Z'
    0                 x       '0'               insertchar  '0'
    1                 x       '1'               insertchar  '1'
    2                 x       '2'               insertchar  '2'
    3                 x       '3'               insertchar  '3'
    4                 x       '4'               insertchar  '4'
    5                 x       '5'               insertchar  '5'
    6                 x       '6'               insertchar  '6'
    7                 x       '7'               insertchar  '7'
    8                 x       '8'               insertchar  '8'
    9                 x       '9'               insertchar  '9'

    exclamation-mark      x  '!'                insertchar  '!'
    hash-sign             x  '\#'               insertchar  '\#'
    dollar-sign           x  '$'                insertchar  '$'
    percent-sign          x  '%'                insertchar  '%'
    ampersand-sign        x  '\&'               insertchar  '\&'
    star                  x  '\*'               insertchar  '\*'
    plus                  x  '+'                insertchar  '+'
    comma                 x  ','                insertchar  ','
    dot                   x  '.'                insertchar  '.'
    forwardslash          x  '\\'               insertchar  '\\'
    backslash             x  '/'                insertchar  '/'
    colon                 x  ':'                insertchar  ':'
    semi-colon            x  '\;'               insertchar  '\;'
    left-angle-bracket    x  '\<'               insertchar  '\<'
    right-angle-bracket   x  '\>'               insertchar  '\>'
    equal-sign            x  '='                insertchar  '='
    question-mark         x  '\?'               insertchar  '\?'
    left-square-bracket   x  '['                insertchar  '['
    right-square-bracket  x  ']'                insertchar  ']'
    hat-sign              x  '^'                insertchar  '^'
    underscore            x  '_'                insertchar  '_'
    left-brace            x  '{'                insertchar  '{'
    right-brace           x  '\}'               insertchar  '\}'
    left-parenthesis      x  '\('               insertchar  '\('
    right-parenthesis     x  '\)'               insertchar  '\)'
    pipe                  x  '\|'               insertchar  '\|'
    tilde                 x  '\~'               insertchar  '\~'
    at-sign               x  '@'                insertchar  '@'
    dash                  x  '\-'               insertchar  '\-'
    double-quote          x  '\"'               insertchar  '\"'
    single-quote          x  "\'"               insertchar  "\'"
    backtick              x  '\`'               insertchar  '\`'
    whitespace            x  '\ '               insertchar  '\ '
) {
    eval "function widget::key-$keyname() {
        widget::util-$mode $widget \$@
    }"
    zle -N widget::key-$keyname
    bindkey $seq widget::key-$keyname
}

# suggested by "e.nikolov", fixes autosuggest completion being 
# overriden by keybindings: to have [zsh] autosuggest [plugin
# feature] complete visible suggestions, you can assign an array
# of shell functions to the `ZSH_AUTOSUGGEST_ACCEPT_WIDGETS` 
# variable. when these functions are triggered, they will also 
# complete any visible suggestion. Example:
export ZSH_AUTOSUGGEST_ACCEPT_WIDGETS=(
    widget::key-right
    widget::key-shift-right
    widget::key-cmd-right
    widget::key-shift-cmd-right
)
奖金

有些人可能也会觉得它们很有用，尽管我没有在上面包含它们，只是将它们添加到for循环数组中：

  • 选项卡
tab                   x  $'\x09'           insertchar  '\   '
  • 注意制表符完成将失败
  • 其他
send              kEND   $'\E[1;2F'        select      end-of-line
    send2             x      $'\E[4;2~'        select      end-of-line

    shome             kHOM   $'\E[1;2H'        select      beginning-of-line
    shome2            x      $'\E[1;2~'        select      beginning-of-line

    end               kend   $'\EOF'           deselect    end-of-line
    end2              x      $'\E4~'           deselect    end-of-line

    home              khome  $'\EOH'           deselect    beginning-of-line
    home2             x      $'\E1~'           deselect    beginning-of-line

    csend             x      $'\E[1;6F'        select      end-of-line
    cshome            x      $'\E[1;6H'        select      beginning-of-line

    cleft             x      $'\E[1;5D'        deselect    backward-word
    cright            x      $'\E[1;5C'        deselect    forward-word

    del               kdch1   $'\E[3~'         delregion   delete-char

旧的，但可能仍然有用的一些

备注

首先在终端应用程序（在我的例子中是iTerm2）上配置某些键盘键序列，以发送shell程序特定的信号。

➤ iTerm2
   ➤ Preferences
     ➤ Keys
       ➤ Key Bindings:

| 键序列|键绑定|
| - ------|- ------|
| cmd+shift+left|发送转义序列：a|
| cmd+shift+right|发送转义序列：x1米30英寸1x|
| ctrl+shift+a|发送转义序列：a|
| ctrl+shift+e|发送转义序列：e|
| cmd+left|发送十六进制代码：\x01|
| cmd+right|发送十六进制代码：\x05|
| x1米39英寸|发送转义序列：x1米40英寸1x|
| cmd+c|发送转义序列：ç|
| cmd+v|发送转义序列：√|
| cmd+x|发送转义序列：≈|
| cmd+z|发送转义序列：Ω|
| cmd+shift+z|发送转义序列：x1米50英寸|
此步骤将终端键绑定到shell信号，即告诉终端程序/应用程序（iTerm2）在按下某些键盘键序列时向shell程序（zsh）发送什么信号。根据您的终端程序和首选项，您可以按自己喜欢的方式绑定键，或使用默认信号。

keyboard  -->  cmd+z  -->  iTerm2  -->  ^[Ω  -->  zsh  -->  undo (widget)

然后，上面的脚本将接收到的信号绑定到shell函数，称为小部件。也就是说，我们告诉shell程序，在接收到指定的信号（键序列）时运行指定的小部件。
因此，在命令行中，当按下键盘按键序列时，终端向shell发送适当的信号，shell调用相应的小部件（函数）。在本例中，我们告诉shell绑定的函数是编辑命令行本身的函数，就像编辑文件一样。
上面定义的小部件使用zsh内置的zle（zsh行编辑器）模块API，更多信息请参见官方文档：ZSH 18 Zsh线路编辑器，以及官方指南：第四章：Z壳线编辑器。

  • 查看shell接收到什么信号的一个巧妙技巧是运行cat，然后按下键：
❯ cat
^[[1;2D^[[1;2C^[Ω^[≈^[ç

这是按下后的输出：一个米55纳米1 x、一个米56纳米1 x、一个米57纳米1 x、一个米58纳米1 x和一个米59纳米1 x。
某些键可能不显示。在这种情况下，请检查您的终端配置，该键可能与某些终端功能绑定（例如，cmd+n可能打开一个新的终端窗格，cmd+t可能打开一个新的终端选项卡）。
另请参见terminfo(5)，这是查找某些键的另一种方法。

已知问题和问题修复
  • 如果您使用的是iTerm2，更改cmd+v绑定到的对象可能会使粘贴到命令行以外的任何对象的操作有所不同，并且需要在该特定程序上重新Map（例如，在less等程序的搜索提示中）。如果您希望避免这种情况，请不要更改iTerm2的cmd+v的Map，并注解掉/删除widget::paste。
  • esc可能与oh-my-zsh的sudo插件冲突，并产生异常行为。您可以注解掉/删除数组中的esc行，或建议修复。
  • right与zsh-autosuggestion冲突，即它不会接受建议。您可以从数组中注解/删除right，或建议修复。这可能是可能的，我只是目前不知道如何操作，并花了足够的时间现在尝试。

我尝试了很多方法，我认为最接近工作的方法可能是这样的：

function widget::key-right() {
    REGION_ACTIVE=0
    zle autosuggest-accept
    zle forward-char
}
zle -N widget::key-right
bindkey $'\eOC' widget::key-right

但是没有用。它没有完成这个建议。但是你可以为它创建一个新的键绑定：

bindkey $'\e\'' autosuggest-accept

我从Github回购中得到了autosuggestion-accept：zsh-users/zsh-autosuggestions.

要修复与zsh-autosuggestion的右键冲突和/或其他可能存在的冲突，请将以下内容添加到shell初始化文件之一（例如.zshrc）：export ZSH_AUTOSUGGEST_ACCEPT_WIDGETS=(<shell-function> ...)（由E.Nikolov建议）。参见上面的示例。

赞(0）分享  回复(0）举报  2023-01-13
kiayqfof

kiayqfof4#

这个页面上的所有解决方案要么不完整要么太具侵入性，因此它们会对其他插件产生负面影响（例如zsh-autosuggestions或zsh-syntax-highlighting），因此我提出了一个不同的方法，效果明显更好。
https://github.com/jirutka/zsh-shift-select/
这个插件不会覆盖任何现有的小部件，只绑定shift键。它创建了一个新的shift-select键Map，当shift选择被调用时，这个键Map会自动激活（使用任何定义的换档键）并停用（当前键Map切换回main）在没有定义在shift-select键Map中的任何键上。由于这种方法，它不会干扰其他插件（例如，它可以与zsh-autosuggestions一起使用，而无需任何更改）。

赞(0）分享  回复(0）举报  2023-01-13
wh6knrhe

wh6knrhe5#

谢谢你的回答，我把所有的和平和做我的脚本选择和复制只是使用键盘。
如果有人想过滤到的东西更干净，我会很感激。
它是主用户文件夹中~/.zshrc文件的一部分。

alias pbcopy="xclip -selection clipboard"

shift-arrow() {

((REGION_ACTIVE)) || zle set-mark-command 
  zle $1
}
for key  kcap seq        widget (
    left  LFT $'\e[1;2D' backward-char
    right RIT $'\e[1;2C' forward-char
    up    ri  $'\e[1;2A' up-line-or-history
    down  ind $'\e[1;2B' down-line-or-history
    super sup $'\ec' widget::copy-selection
  ) {
  functions[shift-$key]="shift-arrow $widget"
  zle -N shift-$key
  bindkey ${terminfo[k$kcap]-$seq} shift-$key
}
 
zle -N widget::copy-selection

# copy selected terminal text to clipboard
function widget::copy-selection {
    if ((REGION_ACTIVE)); then
        zle copy-region-as-kill
            printf "%s" $CUTBUFFER | pbcopy
    fi
}

我使用了windows+c按钮来复制选中的字符。我使用的是ubuntu20.04，并配置了键盘选项来使用win按钮，如 meta！在此之后，在终结者的首选项中，我将粘贴快捷方式更改为windows+v，jts，因为我认为它会更快，如control+x和COntrol+v

赞(0）分享  回复(0）举报  2023-01-13
gudnpqoy

gudnpqoy6#

适用于Windows和WSL用户。
这是其他作者关于它们的答案的组合，经过修改后可在使用Window Terminal的WSL中使用。Ctrl+Shift+箭头选择、Ctrl+z、x、c、v、a等。

# zsh-shift-select https://stackoverflow.com/a/30899296
r-delregion() {
  if ((REGION_ACTIVE)) then
     zle kill-region
  else
    local widget_name=$1
    shift
    zle $widget_name -- $@
  fi
}
r-deselect() {
  ((REGION_ACTIVE = 0))
  local widget_name=$1
  shift
  zle $widget_name -- $@
}
r-select() {
  ((REGION_ACTIVE)) || zle set-mark-command
  local widget_name=$1
  shift
  zle $widget_name -- $@
}
for key     kcap   seq        mode   widget (
    sleft   kLFT   $'\e[1;2D' select   backward-char
    sright  kRIT   $'\e[1;2C' select   forward-char
    sup     kri    $'\e[1;2A' select   up-line-or-history
    sdown   kind   $'\e[1;2B' select   down-line-or-history
    send    kEND   $'\E[1;2F' select   end-of-line
    send2   x      $'\E[4;2~' select   end-of-line
    shome   kHOM   $'\E[1;2H' select   beginning-of-line
    shome2  x      $'\E[1;2~' select   beginning-of-line
    left    kcub1  $'\EOD'    deselect backward-char
    right   kcuf1  $'\EOC'    deselect forward-char
    end     kend   $'\EOF'    deselect end-of-line
    end2    x      $'\E4~'    deselect end-of-line
    home    khome  $'\EOH'    deselect beginning-of-line
    home2   x      $'\E1~'    deselect beginning-of-line
    csleft  x      $'\E[1;6D' select   backward-word
    csright x      $'\E[1;6C' select   forward-word
    csend   x      $'\E[1;6F' select   end-of-line
    cshome  x      $'\E[1;6H' select   beginning-of-line
    cleft   x      $'\E[1;5D' deselect backward-word
    cright  x      $'\E[1;5C' deselect forward-word
    del     kdch1   $'\E[3~'  delregion delete-char
    bs      x       $'^?'     delregion backward-delete-char
  ) {
  eval "key-$key() {
    r-$mode $widget \$@
  }"
  zle -N key-$key
  bindkey ${terminfo[$kcap]-$seq} key-$key
}
# Fix zsh-autosuggestions https://stackoverflow.com/a/30899296
export ZSH_AUTOSUGGEST_ACCEPT_WIDGETS=(
  key-right
)
# ctrl+x,c,v https://superuser.com/a/271890
function zle-clipboard-cut {
  if ((REGION_ACTIVE)); then
    zle copy-region-as-kill
    print -rn -- $CUTBUFFER | clip.exe
    zle kill-region
  fi
}
zle -N zle-clipboard-cut
function zle-clipboard-copy {
  if ((REGION_ACTIVE)); then
    zle copy-region-as-kill
    print -rn -- $CUTBUFFER | clip.exe
  else
    zle send-break
  fi
}
zle -N zle-clipboard-copy
function zle-clipboard-paste {
  if ((REGION_ACTIVE)); then
    zle kill-region
  fi
  LBUFFER+="$(cat clip.exe)"
}
zle -N zle-clipboard-paste
function zle-pre-cmd {
  stty intr "^@"
}
precmd_functions=("zle-pre-cmd" ${precmd_functions[@]})
function zle-pre-exec {
  stty intr "^C"
}
preexec_functions=("zle-pre-exec" ${preexec_functions[@]})
for key     kcap    seq           widget              arg (
    cx      _       $'^X'         zle-clipboard-cut   _
    cc      _       $'^C'         zle-clipboard-copy  _
    cv      _       $'^V'         zle-clipboard-paste _
) {
  if [ "${arg}" = "_" ]; then
    eval "key-$key() {
      zle $widget
    }"
  else
    eval "key-$key() {
      zle-$widget $arg \$@
    }"
  fi
  zle -N key-$key
  bindkey ${terminfo[$kcap]-$seq} key-$key
}
# ctrl+a https://stackoverflow.com/a/68987551/13658418
function widget::select-all() {
  local buflen=$(echo -n "$BUFFER" | wc -m | bc)
  CURSOR=$buflen  
  zle set-mark-command
  while [[ $CURSOR > 0 ]]; do
    zle beginning-of-line
  done
}
zle -N widget::select-all
bindkey '^a' widget::select-all
# ctrl+z
bindkey "^Z" undo

在带有Windows终端“1.15.3466.0”的WSL 2“Linux 5.15.79.1-微软标准-WSL 2”上进行测试。

赞(0）分享  回复(0）举报  2023-01-13
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com