É possível canalizar de / para a área de transferência no Bash?

Seja na tubulação de / para um identificador de dispositivo ou usando um aplicativo auxiliar, não consigo encontrar nada.

Por exemplo, se /dev/clipfosse um dispositivo vinculado à área de transferência, poderíamos fazer:

cat /dev/clip        # Dump the contents of the clipboard
cat foo > /dev/clip  # Dump the contents of "foo" into the clipboard

Você pode lidar com diversas pranchetas. Espero que você provavelmente seja um usuário do Linux que queira colocar coisas na área de transferência principal do X Windows. Geralmente, a área de transferência com a qual você deseja conversar possui um utilitário que permite conversar com ela.

No caso de X, há xclip(e outros). xclip -selection cenviará dados para a área de transferência que funciona com Ctrl + C, Ctrl + Vna maioria dos aplicativos.

Se você estiver no Mac OS X, existe pbcopy.

Se você estiver em Linux modo de terminal (sem X), em seguida, olhar para gpmou tela que tem uma área de transferência. Tente o screencomando readreg.

No Windows 10+ ou cygwin, use /dev/clipboardou clip.

Certifique-se de que você esteja usando, alias xclip="xclip -selection c" caso contrário, não poderá usar o Ctrl+ vpara colar novamente em um local diferente.

echo test | xclip    

Ctrl+v === test

Instalar

# You can install xclip using `apt-get`
apt-get install xclip

# or `pacman`
pacman -S xclip

# or `dnf`
dnf install xclip

Se você não tem acesso apt-getnem pacman, nem dnf, as fontes estão disponíveis no sourceforge .

Configuração

Bater

Em ~/.bash_aliases, adicione:

alias setclip="xclip -selection c"
alias getclip="xclip -selection c -o"

Não se esqueça de carregar sua nova configuração usando . ~/.bash_aliasesou reiniciando seu perfil.

Peixe

Em ~/.config/fish/config.fish, adicione:

abbr setclip "xclip -selection c"
abbr getclip "xclip -selection c -o"

Não se esqueça de reiniciar sua instância de peixe reiniciando seu terminal para que as alterações sejam aplicadas.

Uso

Agora você pode usar setclipe getclip, por exemplo:

$ echo foo | setclip
$ getclip
foo

No macOS, use os comandos embutidos pbcopye pbpaste.

Por exemplo, se você executar

cat ~/.bashrc | pbcopy

o conteúdo do ~/.bashrcarquivo estará disponível para colar com o atalho Cmd+ v.

Tentar

xclip

xclip - command line interface to X selections (clipboard) 

cara

xsel no Debian / Ubuntu / Mint

# append to clipboard:
cat 'the file with content' | xsel -ib

# or type in the happy face :) and ...
echo 'the happy face :) and content' | xsel -ib

# show clipboard
xsel -b

# Get more info:
man xsel

Instalar

sudo apt-get install xsel

Uau, não acredito em quantas respostas existem para essa pergunta. Não posso dizer que tentei todos eles, mas tentei os 3 ou 4 melhores e nenhum deles funciona para mim. O que funcionou para mim foi uma resposta localizada em um dos comentários escritos por um usuário chamado doug. Como achei útil, decidi reafirmar em uma resposta.

Instale o utilitário xcopy e, quando estiver no Terminal, insira:

cópia de

Thing_you_want_to_copy|xclip -selection c

Colar

myvariable=$(xclip -selection clipboard -o)

Notei muitas respostas recomendadas pbpaste e pbcopy. Se você gosta desses utilitários, mas por algum motivo eles não estão disponíveis no seu repositório, sempre é possível criar um alias para os comandos xcopy e chamá-los de pbpaste e pbcopy.

alias pbcopy="xclip -selection c" 
alias pbpaste="xclip -selection clipboard -o" 

Então, ficaria assim:

Thing_you_want_to_copy|pbcopy
myvariable=$(pbpaste)

2018 resposta

Use clipboard-cli . Funciona com macOS, Windows, Linux, OpenBSD, FreeBSD e Android sem problemas reais.

Instale-o com:

npm install -g clipboard-cli

Então você pode fazer

echo foo | clipboard

Se você quiser, você pode alias para cb, colocando o seguinte no seu .bashrc, .bash_profileou .zshrc:

alias cb=clipboard

No subsistema Windows para Linux, você pode copiar para a área de transferência com clip.exe.

cat file | clip.exe

Lembre-se de usar o |comando pipe. E não um >comando, pois isso não vai funcionar.

Aqui está um script bash pronto para usar para ler a área de transferência que funciona em várias plataformas. Por favor, edite o script aqui se você adicionar funcionalidade (por exemplo, mais plataformas).

#!/bin/bash
# WF 2013-10-04
# multi platform clipboard read access
# supports
#   Mac OS X
#   git shell / Cygwin (Windows)
#   Linux (e.g. Ubuntu)

#
# display an error
#
error() {
  echo "error: $1" 1>&2
  exit 1
}

#
# getClipboard
#
function getClipboard() {
 os=`uname`
      case $os in 
        # git bash  (Windows)
        MINGW32_NT-6.1)
          cat /dev/clipboard;;
        # Mac OS X
        Darwin*)
          pbpaste;;  
        # Linux 
        Linux*)
          # works only for X clipboard - a check that X is running might be due
          xclip -o;;
        *)
          error "unsupported os $os";;
      esac
}

tmp=/tmp/clipboard$$
getClipboard >$tmp
cat $tmp
# comment out for debugging
rm $tmp

No Windows (com Cygwin), tente cat /dev/clipboardou echo "foo" > /dev/clipboardconforme mencionado neste artigo.

Apenas para Mac:

echo "Hello World" | pbcopy
pbpaste

Estes estão localizados /usr/bin/pbcopye /usr/bin/pbpaste.

Existem diferentes pranchetas no Linux; o servidor X possui um, o gerenciador de janelas pode ter outro, etc. Não há dispositivo padrão.

Ah, sim, na CLI, o programa de tela também possui sua própria área de transferência, assim como outros aplicativos como Emacs e vi .

No X, você pode usar o xclip .

Você pode verificar esta discussão para outras respostas possíveis: http://unix.derkeiler.com/Newsgroups/comp.unix.shell/2004-07/0919.html

Copie e cole na área de transferência no Windows (Cygwin):

Vejo:

$ clip.exe -?

CLIP
Description:
    Redirects output of command line tools to the Windows clipboard.
    This text output can then be pasted into other programs.
Parameter List:
/?                  Displays this help message.
Examples:
DIR | CLIP          Places a copy of the current directory
                        listing into the Windows clipboard.
CLIP < README.TXT   Places a copy of the text from readme.txt
                        on to the Windows clipboard.

Também existem o getclip (que pode ser usado em vez de Shift+ Ins!) E o putclip (echo oaeuoa | putclip.exe para colocá-lo em clipe).

Este é um script Python simples que faz exatamente o que você precisa:

#!/usr/bin/python

import sys

# Clipboard storage
clipboard_file = '/tmp/clipboard.tmp'

if(sys.stdin.isatty()): # Should write clipboard contents out to stdout
    with open(clipboard_file, 'r') as c:
        sys.stdout.write(c.read())
elif(sys.stdout.isatty()): # Should save stdin to clipboard
    with open(clipboard_file, 'w') as c:
        c.write(sys.stdin.read())

Salve isso como um executável em algum lugar do seu caminho (salvei-o em /usr/local/bin/clip. Você pode inserir material a ser salvo na sua área de transferência ...

echo "Hello World" | clip

E você pode canalizar o que está na sua área de transferência para outro programa ...

clip | cowsay
 _____________
< Hello World >
 -------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||

Executá-lo por si só simplesmente produzirá o que está na área de transferência.

Encontrei uma boa referência: /unix/69111/

No meu caso, gostaria de colar o conteúdo na área de transferência e também para ver o que foi colado lá, então usei também o teecomando com um descritor de arquivo:

echo "just a test" | tee >(xclip -i -selection clipboard)

>()é uma forma de substituição de processo. bash substitui cada um pelo caminho para um descritor de arquivo conectado à entrada padrão do programa entre parênteses.

o tee comando bifurca seu comando, permitindo que você "canalize seu conteúdo" e veja o resultado na saída padrão "stdout"

você também pode criar aliases para obter e gravar na área de transferência, permitindo usar "pbcopy" e "pbpaste" como se estivesse no MAC. No meu caso, ao usar o zsh, tenho isso no meu arquivo de aliases:

(( $+commands[xclip] )) && {
    alias pbpaste='xclip -i -selection clipboard -o'
    alias pbcopy='xclip -selection clipboard'
}

o (( $+command[name] ))in zsh testa se o comando "name" está instalado no seu sistema, então os dois aliases são agrupados {}. o &&é um binário E, se a então b, portanto, se você tiver o xclip, os aliases serão definidos.

echo "another test" | tee >(pbcopy)

Para obter o conteúdo da área de transferência, digite:

pbpaste | "any-command-you-need-here"

  xsel -b

Faz o trabalho para o X Window, e ele já está instalado. Uma olhada na página de manual do xsel vale o esforço.

Alguns programas do Windows que escrevi anos atrás. Eles permitem despejar, empurrar, acrescentar e imprimir a área de transferência. Funciona assim:

dumpclip | perl -pe "s/monkey/chimp/g;" | pushclip

Inclui código fonte: cmd_clip.zip

Existem algumas maneiras. Algumas das maneiras mencionadas incluem (eu acho) tmux, screen, vim, emacs e o shell. Eu não conheço emacs ou tela, então vou passar pelos outros três.

Tmux

Embora não seja uma seleção X, o tmux tem um modo de cópia acessível via prefix-[( prefixé Ctrl+B por padrão). O buffer usado para esse modo é separado e exclusivo do tmux, o que abre muitas possibilidades e o torna mais versátil do que as seleções X nas situações certas.

Para sair deste modo, pressione q; para navegar, use sua vimou emacsencadernação (padrão = vim); portanto, hjklpara movimento, v/V/C-vpara seleção de caracteres / linha / bloco, etc. Quando você tiver sua seleção, pressioneEnter para copiar e sair do modo.

Para colar nesse buffer, use prefix-].

Concha

Qualquer instalação do X11parece vir com dois programas por padrão: xclipe xsel(meio como também vem com ambos startxe xinit). A maioria das outras respostas menciona xclip, e eu realmente gosto xselpor sua brevidade, então vou cobrir xsel.

Do xsel (1x) :

Opções de entrada

-a, --append

anexar entrada padrão à seleção. Implica -i .

-f, --follow

acrescente à seleção à medida que a entrada padrão cresce. Implica -i .

-i, --input

leia a entrada padrão na seleção.

Opções de saída

-o, - saída

escreva a seleção na saída padrão.

Opções de ação

-c, --clear

limpe a seleção. Substitui todas as opções de entrada.

-d, --delete

Solicite que a seleção atual seja excluída. Isso não apenas limpa a seleção, mas também solicita ao programa em que a seleção reside que o conteúdo selecionado seja excluído. Substitui todas as opções de entrada.

Opções de seleção

-p, --primary

operar na seleção PRIMARY (padrão).

-s, --secondary

operar na seleção SECUNDÁRIA.

-b, --clipboard

operar na seleção CLIPBOARD.

E isso é tudo que você precisa saber. p(ou nada) para PRIMARY, spara SECONDARY, bpara CLIPBOARD, opara saída.

Exemplo: digamos que eu quero copiar a saída de fooum TTY e colá-la em uma página da Web para obter um relatório de erro. Para fazer isso, seria ideal copiar para / da sessão TTY / X. Portanto, a pergunta passa a ser: como acesso a área de transferência a partir do TTY?

Neste exemplo, assumiremos que a sessão X está em exibição :1.

$ foo -v
Error: not a real TTY
details:
blah blah @ 0x0000000040abeaf4
blah blah @ 0x0000000040abeaf8
blah blah @ 0x0000000040abeafc
blah blah @ 0x0000000040abeb00
...
$ foo -v | DISPLAY=:1 xsel -b # copies it into clipboard of display :1

Então eu posso Ctrl-Vcolocá-lo no formulário como de costume.

Agora diga que alguém no site de suporte me fornece um comando para executar para corrigir o problema. É complicado e longo.

$ DISPLAY=:1 xsel -bo
sudo foo --update --clear-cache --source-list="http://foo-software.com/repository/foo/debian/ubuntu/xenial/164914519191464/sources.txt"
$ $(DISPLAY=:1 xsel -bo)
Password for braden:
UPDATING %%%%%%%%%%%%%%%%%%%%%%% 100.00%
Clearing cache...
Fetching sources...
Reticulating splines...
Watering trees...
Climbing mountains...
Looking advanced...
Done.
$ foo
Thank you for your order. A pizza should arrive at your house in the next 20 minutes. Your total is $6.99

Encomendar pizza parece ser um uso produtivo da linha de comando.

...se movendo.

Vim

Se compilado com +clipboard(Isso é importante! Verifique seu vim --version), o Vim deve ter acesso ao X PRIMARYe às CLIPBOARDseleções. As duas seleções são acessíveis nos registros *e +, respectivamente, e podem ser gravadas e lidas a seu tempo, da mesma forma que em qualquer outro registro. Por exemplo:

:%y+    ; copy/yank (y) everything (%) into the CLIPBOARD selection (+)
"+p     ; select (") the CLIPBOARD selection (+) and paste/put it
ggVG"+y ; Alternative version of the first example

Porém, se sua cópia do vim não suportar diretamente o acesso às seleções X, não será o fim do mundo. Você pode apenas usar a xseltécnica conforme descrito na última seção.

:r ! xsel -bo ; read  (r) from the stdout of (!) `xsel -bo`
:w ! xsel -b  ; write (w) to the stdin of    (!) `xsel -b`

Ligue alguns combos principais e você deve ser bom.

Nesse segmento, existe uma opção que não requer a instalação de nenhum software de gclip/ xclip/ xselterceiros.

Um script perl (já que o perl geralmente sempre é instalado)

use Win32::Clipboard;
print Win32::Clipboard::GetText();

O pbcopy é construído no OSX:

Copiando o conteúdo de .bash_profile:

cat ~/.bash_profile | pbcopy

No macOS, use pbpaste .

Por exemplo:

Atualize a área de transferência

pbpaste  | ruby -ne ' puts "\|" + $_.split( )[1..4].join("\|") ' | pbcopy

Se você é como eu e roda em um servidor Linux sem privilégios de root e não há xclip ou GPM, pode solucionar esse problema usando apenas um arquivo temporário. Por exemplo:

$ echo "Hello, World!" > ~/clip
$ echo `cat ~/clip`
Hello, World!

No Linux, isso funciona:

cat filename | xclip

no Wayland, o xcopy parece não funcionar, use wl-clipboard . por exemplo, no fedora

sudo dnf install wl-clipboard

tree | wl-copy

wl-paste > file

Há também xclip-copyfile .

Embora> 1 ano depois, compartilhe uma solução um pouco diferente. Espero que isso seja útil para alguém.

Ontem, me deparei com a pergunta: "Como compartilhar a área de transferência entre diferentes sessões de usuário?" . Ao alternar entre sessões com ctrlaltF7-ctrlaltF8 , na verdade, você não pode colar o que copiou.

Eu vim com a seguinte solução rápida e suja , com base em um pipe nomeado. Certamente é bastante vazio e cru, mas achei funcional:

user1@host:~$ mkfifo /tmp/sharedClip

depois no terminal de envio

user1@host:~$ cat > /tmp/sharedClip

por último, no terminal receptor:

user2@host:~$ cat /tmp/sharedClip

Agora, você digita ou cola qualquer coisa no primeiro terminal e (depois de pressionar return), ele aparecerá imediatamente no terminal de recebimento, de onde você pode copiar / colar novamente em qualquer lugar que desejar.

É claro que isso não apenas restringe o conteúdo da área de transferência do usuário1 para torná-lo disponível na área de transferência do usuário2, mas exige um par adicional de cliques em Colar e Copiar.

O ruby ​​oneliner me inspirou a tentar com python.

Digamos que queremos um comando que recua o que estiver na área de transferência com 4 espaços. Perfeito para compartilhar trechos no stackoverflow.

$ pbpaste | python -c "import sys
 for line in sys.stdin:
   print(f'    {line}')" | pbcopy

isso não é um erro de digitação. O Python precisa de novas linhas para fazer um loop for. Queremos alterar as linhas em uma passagem para evitar a criação de uma matriz extra na memória.

Se você não se importa em criar a matriz extra, tente:

$ pbpaste | python -c "import sys; print(''.join([f'    {l}' for l in sys.stdin]))" | pbcopy

mas honestamente o awk é melhor para isso do que python. Eu defini esse alias no meu ~/.bashrcarquivo

alias indent="pbpaste | awk '{print \"    \"\$0}' | pbcopy"

agora, quando corro o indentque estiver na minha área de transferência, é recuado.