Inquerir

Eu uso o Bash. Quando procuro arquivos, geralmente faço o seguinte:

find -name stackexchange.hs

E frequentemente os resultados serão parecidos com:

/youre/the/man/now/dog/stackexchange.hs
/you/are/no/longer/the/dog/dog/stackexchange.hs
/this/is/the/file/i/want/stackexchange.hs

Então, eu quero fazer um dos seguintes:

• Opção 1: abra o último item na lista de resultados no vim .
• Opção 2: abra o item enésimo na lista de resultados no vim .

Atualmente, corto e colo com o mouse. O que me leva à minha pergunta :

1. Existe uma linha fácil para realizar as opções 1 e 2? Observe que isso está ocorrendo após o findcomando.
2. Existe uma maneira de capturar linhas N do stdout em algum tipo de vetor / matriz bash?

Uso ideal

$ find -name am_i_really_all_alone.txt
./borges/library/you_are_not_alone.txt
./borges/library/am_i_really_all_alone.txt
$ vim (N)

(sintaxe e semântica podem ser diferentes, mas você entende)

Similaria

Parece haver várias perguntas semelhantes. Aqui estão minhas diferenças percebidas (estou aberto à iluminação):

• "Abrir arquivo encontrado com o comando find" se concentra na criação de uma linha para canalizar um nome de arquivo findpara vim(ou o que for). No meu caso, quero findprimeiro, canalizar mais tarde (por assim dizer). Minha captura / uso acontece estritamente depois .
• "Reutilizar a última saída do comando Lind" parece estridente, mas parece simplesmente repetir o comando e não fala em capturar a enésima linha de saída. Francamente, isso me assusta.
• "Capturar saída em várias linhas de um Bash Builtin" está próximo, mas não está lá.
• "Qual é a diferença exata entre terminal, shell, tty, console etc." este é realmente apenas uma boa leitura.

Obrigado pela ajuda! Depois de usar o * nix / BSD quando eu era adolescente nos anos 90 e me assustar ao ligar para meu vizinho esgotado e com cabeça ácida para me ajudar a instalar drivers para minha placa de som plug-and-play, fico aliviado ao discutir minúcias de linha com indivíduos (notavelmente) menos assustadores. É bom estar de volta.

Aqui está uma solução potencial para o seu problema que deve ser razoavelmente (mas não perfeitamente) segura na presença de nomes de arquivos descolados (não lida com nomes de arquivos com feeds de linha neles - provavelmente corrigível, mas pode haver outros problemas à espreita).

Duas funções, a primeira é executada findcom os parâmetros que você passa, salva a saída em uma matriz e as exibe. O segundo é apenas um auxiliar para acessar esse array.

myfind() {
  IFS=$'\n' __last_find_result=($(find "$@"));
  printf "%s\n" "${__last_find_result[@]}";
}
myget() {
  echo "${__last_find_result[$1]}";
}

Caso de uso:

$ myfind . -name "c*"
./a b/c d
./.git/config
./.git/hooks/commit-msg.sample
$ vim "$(myget 0)"
# This opens the "./a b/c d" file.
$ vim "$(myget 2)"
# This opens ".git/hooks/commit-msg.sample"

Citações não são necessárias em torno de $(myget index)se você não tiver espaços em branco ou outros caracteres problemáticos em seus nomes de arquivos.
Envia toda a saída findpara o seu ambiente, o que pode ser limitado. (Usar um arquivo temporário em vez dessa matriz resolveria isso, mas tem outros problemas - principalmente o uso simultâneo de vários shells.)

Eu tenho isso no meu .screenrc:

bind -c pasteline 1 eval copy 'stuff "-Y"' 'paste .'
bind -c pasteline 2 eval copy 'stuff "2-Y"' 'paste .'
bind -c pasteline 3 eval copy 'stuff "3-Y"' 'paste .'
bind -c pasteline 4 eval copy 'stuff "4-Y"' 'paste .'
bind -c pasteline 5 eval copy 'stuff "5-Y"' 'paste .'
bind -c pasteline 6 eval copy 'stuff "6-Y"' 'paste .'
bind -c pasteline 7 eval copy 'stuff "7-Y"' 'paste .'
bind -c pasteline 8 eval copy 'stuff "8-Y"' 'paste .'
bind -c pasteline 9 eval copy 'stuff "9-Y"' 'paste .'
bindkey ¬ command -c pasteline

Basicamente, na tela, ¬1cola a linha acima do cursor ¬2, cola a segunda linha acima do cursor ... e assim por diante. Você pode adicionar mais para as linhas 10 e acima, mas acho que, depois das 7, já prefiro usar o screenmodo de cópia do mouse ou do que contar o número de linhas para obter o que quero.

Outra solução é: você pode escrever um script interativo que solicitará automaticamente sua escolha. aqui está o código para o script interativo:

#!/bin/bash

echo "enter your choice : z for last argument or a number for that file"
read choice

case "$choice" in
z) eval vim \$$#;;
*)eval  vim \$$choice;;
esac

salve esse script com qualquer nome, diga "autofind" e chame o script com seu "comando find", pois o argumento aqui é o código para chamar o script:

./autofind `your find command`

Mas antes de usar o script, verifique o seu "comando find", esteja ou não dando resultado. Se estiver mostrando algum resultado, use apenas o script

A resposta de Mats era exatamente o que eu estava procurando. Expandi um pouco o código dele para permitir mais opções de obtenção.

$ f ~/scripts -name '*.sh'
$ vim $(g foo)  # edit all find results matching "foo"
$ vim $(g 1 3 5) # edit find results number 1, 3 and 5
$ vim $(g 3-5) # edit find results 3-5
$ vim $(g 5-) # edit find results 5 to last
$ vim $(g -7) # edit find result 7 from bottom
$ vim $(g 1 4-5 -7 9- foo) # all of the above combined

.

f() {
    IFS=$'\n' __last_find_result=($(find "$@"));
    printf "%s\n" "${__last_find_result[@]}";
}

g() {
    len=${#__last_find_result[@]}
    pad=${#len}
    numbers=""
    if [ "$1" == "-n" ]; then
        numbers=1
        shift
    fi
    if [ -z "$1" ]; then
        if [ -n "$numbers" ]; then
            n=1;
            for e in "${__last_find_result[@]}";do
                printf "%0${pad}d. %s\n" "$n" "$e"
                let n=n+1
            done
        else
            printf "%s\n" "${__last_find_result[@]}"
        fi
    else
        for l in $@;do
            if [[ "$l" =~ ([^0-9-]+) ]];then
                n=1;
                for e in "${__last_find_result[@]}";do
                    if [[ $e =~ $1 ]]; then
                        if [ -n "$numbers" ];then
                            printf "%0${pad}d. %s\n" "$n" "$e"
                        else
                            printf "%s\n" "$e"
                        fi
                    fi
                    let n=n+1
                done
            elif [[ "$l" =~ ^([0-9]+)$ ]];then
                let l=l-1
                echo "${__last_find_result[$l]}";
            elif [[ "$l" =~ ^([0-9]*)(-)?([0-9]*)$ ]]; then
                from=${BASH_REMATCH[1]};
                dash=${BASH_REMATCH[2]};
                to=${BASH_REMATCH[3]};
                if [ -z "$from" ]; then # -n
                    [ $to -gt ${#__last_find_result[@]} ] && to=${#__last_find_result[@]}
                    echo "${__last_find_result[-$to]}";
                else # n-m
                    [ -z "$to" ] && to=${#__last_find_result[@]}
                    [ $to -gt ${#__last_find_result[@]} ] && to=${#__last_find_result[@]}
                    let to=$to-1
                    let from=$from-1
                    n=$(($from+1))
                    for i in `seq $from $to`;do
                        if [ -n "$numbers" ];then
                            printf "%0${pad}d. %s\n" "$n" "${__last_find_result[$i]}"
                        else
                            printf "%s\n" "${__last_find_result[$i]}"
                        fi
                        let n=n+1
                    done
                fi
            fi
        done
    fi
}