¿Es posible canalizar hacia / desde el portapapeles en Bash?

Si se trata de una tubería desde / hacia un dispositivo o mediante una aplicación auxiliar, no puedo encontrar nada.

Por ejemplo, si /dev/clipse tratara de un dispositivo vinculado al portapapeles, podríamos hacer:

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

Hay una gran cantidad de portapapeles con los que podrías estar lidiando. Supongo que probablemente eres un usuario de Linux que quiere poner cosas en el portapapeles primario de X Windows. Por lo general, el portapapeles con el que desea hablar tiene una utilidad que le permite hablar con él.

En el caso de X, hay xclip(y otros). xclip -selection cenviará datos al portapapeles con el que funciona Ctrl + C, Ctrl + Ven la mayoría de las aplicaciones.

Si estás en Mac OS X, hay pbcopy. p.ejcat example.txt | pbcopy

Si estás en Linux modo terminal (NO x) y luego mirar hacia gpmo pantalla que tiene un portapapeles. Prueba el screencomando readreg.

En Windows 10+ o cygwin, use /dev/clipboardo clip.

Asegúrate de que lo estás utilizando; de lo alias xclip="xclip -selection c" contrario, no puedes usar Ctrl+ vpara pegarlo en un lugar diferente.

echo test | xclip    

Ctrl+v === test

Instalar en pc

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

# or `pacman`
pacman -S xclip

# or `dnf`
dnf install xclip

Si no tiene acceso a apt-getni pacman, ni dnf, las fuentes están disponibles en sourceforge .

Preparar

Golpetazo

En ~/.bash_aliases, agregue:

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

No olvide cargar su nueva configuración utilizando . ~/.bash_aliaseso reiniciando su perfil.

Pez

En ~/.config/fish/config.fish, agregue:

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

No olvide reiniciar su instancia de fish reiniciando su terminal para que se apliquen los cambios.

Uso

Ahora puede usar setclipy getclip, por ejemplo:

$ echo foo | setclip
$ getclip
foo

En macOS, use el incorporado pbcopyypbpaste comandos.

Por ejemplo, si corres

cat ~/.bashrc | pbcopy

el contenido del ~/.bashrcarchivo estará disponible para pegar con el acceso directo Cmd+ v.

Tratar

xclip

xclip - command line interface to X selections (clipboard) 

hombre

xsel en 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 en pc

sudo apt-get install xsel

Wow, no puedo creer cuántas respuestas hay para esta pregunta. No puedo decir que los haya probado todos, pero he probado los 3 o 4 mejores y ninguno de ellos me funciona. Lo que funcionó para mí fue una respuesta ubicada en uno de los comentarios escritos por un usuario llamado doug. Como lo encontré tan útil, decidí repetir una respuesta.

Instale la utilidad xcopy y cuando esté en la Terminal, ingrese:

Copiar

Thing_you_want_to_copy|xclip -selection c

Pegar

myvariable=$(xclip -selection clipboard -o)

Noté muchas respuestas recomendadas pbpaste y pbcopy. Si le gustan esas utilidades, pero por alguna razón no están disponibles en su repositorio, siempre puede crear un alias para los comandos xcopy y llamarlos pbpaste y pbcopy.

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

Entonces se vería así:

Thing_you_want_to_copy|pbcopy
myvariable=$(pbpaste)

Respuesta 2018

Use portapapeles-cli . Funciona con macOS, Windows, Linux, OpenBSD, FreeBSD y Android sin ningún problema real.

Instalarlo con:

npm install -g clipboard-cli

Entonces puedes hacer

echo foo | clipboard

Si lo desea, puede alias cbponiendo lo siguiente en su .bashrc, .bash_profileo .zshrc:

alias cb=clipboard

En el subsistema de Windows para Linux, puede copiar al portapapeles con clip.exe.

cat file | clip.exe

Recuerde usar el |comando de tubería. Y no es un >comando, ya que eso no funcionará.

Aquí hay un script bash listo para usar para leer el portapapeles que funciona en múltiples plataformas. Edite el script aquí si agrega funcionalidad (por ejemplo, más 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

En Windows (con Cygwin) intente cat /dev/clipboardo echo "foo" > /dev/clipboardcomo se menciona en este artículo.

Solo para Mac:

echo "Hello World" | pbcopy
pbpaste

Estos se encuentran /usr/bin/pbcopyy /usr/bin/pbpaste.

Hay diferentes portapapeles en Linux; el servidor X tiene uno, el administrador de ventanas puede tener otro, etc. No hay un dispositivo estándar.

Ah, sí, en CLI, el programa de pantalla también tiene su propio portapapeles, al igual que otras aplicaciones como Emacs y vi .

En X, puedes usar xclip .

Puede consultar este hilo para otras posibles respuestas: http://unix.derkeiler.com/Newsgroups/comp.unix.shell/2004-07/0919.html

Copie y pegue en el portapapeles en Windows (Cygwin):

Ver:

$ 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.

También existen getclip (se puede usar en lugar de Shift+ Ins!) Y putclip (echo oaeuoa | putclip.exe para ponerlo en clip).

Este es un script simple de Python que hace justo lo que necesita:

#!/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())

Guarde esto como un ejecutable en algún lugar de su ruta (lo guardé /usr/local/bin/clip. Puede canalizar cosas para guardarlas en su portapapeles ...

echo "Hello World" | clip

Y puede canalizar lo que está en su portapapeles a otro programa ...

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

Ejecutarlo solo generará lo que está en el portapapeles.

He encontrado una buena referencia: /unix/69111/

En mi caso, me gustaría pegar contenido en el portapapeles y también ver lo que se ha pegado allí, así que también utilicé el teecomando con un descriptor de archivo:

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

>()Es una forma de sustitución del proceso. bash reemplaza cada uno con la ruta a un descriptor de archivo que está conectado a la entrada estándar del programa entre paréntesis.

El teecomando bifurca su comando permitiéndole "canalizar su contenido" y ver el resultado en la salida estándar "stdout"

También puede crear alias para obtener y escribir en el portapapeles, lo que le permite utilizar "pbcopy" y "pbpaste" como si estuviera en MAC. En mi caso, cuando uso zsh tengo esto en mi archivo de alias:

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

el (( $+command[name] ))de pruebas zsh si el "nombre" de comandos está instalado en su sistema, entonces los dos alias se agrupan con {}. the &&es un AND binario, si a luego b, por lo tanto, si tiene xclip, se establecerán los alias.

echo "another test" | tee >(pbcopy)

Para obtener el contenido de su portapapeles simplemente escriba:

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

  xsel -b

Hace el trabajo para X Window, y en su mayoría ya está instalado. Merece la pena echar un vistazo a la página de manual de xsel .

Algunos programas de Windows que escribí hace años. Le permiten volcar, empujar, agregar e imprimir el portapapeles. Funciona así:

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

Incluye código fuente: cmd_clip.zip

Hay un par de maneras. Algunas de las formas que se han mencionado incluyen (creo) tmux, screen, vim, emacs y el shell. No conozco emacs ni screen, así que repasaré los otros tres.

Tmux

Si bien no es una selección X, tmux tiene un modo de copia accesible mediante prefix-[( prefixes Ctrl+ Bpor defecto). El búfer utilizado para este modo es separado y exclusivo de tmux, lo que abre muchas posibilidades y lo hace más versátil que las selecciones X en las situaciones correctas.

Para salir de este modo, presione q; para navegar, use su vimo emacsenlace (predeterminado = vim), hjklpor lo que para el movimiento, v/V/C-vpara la selección de caracteres / línea / bloque, etc. Cuando tenga su selección, presione Enterpara copiar y salir del modo.

Para pegar desde este búfer, use prefix-].

Cáscara

Cualquier instalación de X11parece venir con dos programas por defecto: xclipy xsel(algo así como también viene con ambos startxy xinit). La mayoría de las otras respuestas mencionan xclip, y realmente me gusta xselpor su brevedad, así que voy a cubrir xsel.

De xsel (1x) :

Opciones de entrada

-a, --append

agregar entrada estándar a la selección. Implica -i .

-f, --sigue

agregar a la selección a medida que crece la entrada estándar. Implica -i .

-i, --input

lea la entrada estándar en la selección.

Opciones de salida

-o, --salida

escriba la selección en la salida estándar.

Opciones de acción

-c, --clear

Borrar la selección. Anula todas las opciones de entrada.

-d, --delete

Solicite que se elimine la selección actual. Esto no solo borra la selección, sino que también solicita al programa en el que reside la selección que se eliminen los contenidos seleccionados. Anula todas las opciones de entrada.

Opciones de selección

-p, --primaria

operar en la selección PRIMARIA (predeterminado).

-s, --secondary

operar en la selección SECUNDARIA.

-b, --clipboard

operar en la selección de CLIPBOARD.

Y eso es todo lo que necesitas saber. p(o nada) para PRIMARY, spara SECONDARY, bpara CLIPBOARD, opara salida.

Ejemplo: digamos que quiero copiar el resultado de fooun TTY y pegarlo en una página web para obtener un informe de error. Para hacer esto, sería ideal copiar a / desde la sesión TTY / X. Entonces, la pregunta es cómo accedo al portapapeles desde el TTY.

Para este ejemplo, asumiremos que la sesión X está en exhibición :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

Entonces puedo Ctrl-Vhacerlo en la forma habitual.

Ahora digamos que alguien en el sitio de soporte me da un comando para ejecutar para solucionar el problema. Es complicado y largo.

$ 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

Ordenar pizza parece un uso productivo de la línea de comando.

...hacia adelante.

Empuje

Si se compila con +clipboard(¡Esto es importante! Compruebe su vim --version), Vim debería tener acceso a la X PRIMARYy las CLIPBOARDselecciones. Se puede acceder a las dos selecciones desde los registros *y +, respectivamente, y se pueden escribir y leer en su tiempo libre como cualquier otro registro. Por ejemplo:

:%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

Sin embargo, si su copia de vim no admite directamente el acceso a las selecciones X, no es el fin del mundo. Simplemente puede usar la xseltécnica como se describe en la última sección.

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

Ate un par de combinaciones de teclas y debería ser bueno.

Desde este hilo, hay una opción que no requiere instalar ningún gclip/ xclip/ xselsoftware de terceros.

Un script perl (ya que perl generalmente siempre está instalado)

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

pbcopy está construido en OSX:

Copiando el contenido de .bash_profile:

cat ~/.bash_profile | pbcopy

En macOS, use pbpaste .

Por ejemplo:

Actualiza el portapapeles

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

Si eres como yo y corres en un servidor Linux sin privilegios de root y no hay ningún xclip o GPM, puedes solucionar este problema simplemente usando un archivo temporal. Por ejemplo:

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

En Linux esto funciona:

cat filename | xclip

en Wayland xcopy no parece funcionar, use wl-clipboard en su lugar. por ejemplo, en fedora

sudo dnf install wl-clipboard

tree | wl-copy

wl-paste > file

También hay xclip-copyfile .

Aunque> 1 año después, comparto una solución ligeramente diferente. Espero que esto sea útil para alguien.

Ayer me encontré con la pregunta: "¿Cómo compartir el portapapeles entre diferentes sesiones de usuario?" . Al cambiar entre sesiones con ctrlaltF7-ctrlaltF8 , de hecho, no se puede pegar lo que ha copiado.

Se me ocurrió la siguiente solución rápida y sucia , basada en una tubería con nombre. Seguramente es bastante simple y crudo, pero lo encontré funcional:

user1@host:~$ mkfifo /tmp/sharedClip

luego en la terminal de envío

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

por último, en la terminal receptora:

user2@host:~$ cat /tmp/sharedClip

Ahora, escribe o pega cualquier cosa en la primera terminal y (después de presionar return ), aparecerá inmediatamente en el terminal receptor, desde donde puede copiar / pegar nuevamente en cualquier lugar que desee.

Por supuesto, esto no solo toma estrictamente el contenido del portapapeles del usuario1 para que esté disponible en el portapapeles del usuario2, sino que requiere un par adicional de clics de Pegar y Copiar.

El rubel oneliner me inspiró a probar con python.

Digamos que queremos un comando que sangra lo que esté en el portapapeles con 4 espacios. Perfecto para compartir fragmentos en stackoverflow.

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

Eso no es un error tipográfico. Python necesita nuevas líneas para hacer un bucle for. Queremos alterar las líneas en una pasada para evitar construir una matriz adicional en la memoria.

Si no te importa construir la matriz adicional, prueba:

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

pero honestamente, awk es mejor para esto que python. Definí este alias en mi ~/.bashrcarchivo

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

ahora cuando ejecuto indentlo que está en mi portapapeles está sangrado.