Asegúrese de que está utilizando alias xclip="xclip -selection c" de lo contrario, no se puede utilizar simplemente para Ctrl+v para pegarlo de nuevo en un lugar 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

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

Configuración

Bash

En ~/.bash_aliases, añádase:

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

No olvide cargar su nueva configuración usando . ~/.bash_aliases o reiniciando su perfil.

Pescado

En ~/.config/fish/config.fish, añádase:

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

No olvide reiniciar su instancia fish reiniciando su terminal para los cambios a aplicar.

Uso

Ahora puede usar setclip y getclip, por ejemplo:

$ echo foo | setclip
$ getclip
foo

En Mac OS X puede encontrar estas herramientas de línea de comandos a mano:

• pbcopy
• pbpaste

EJEMPLO:

cat ~/.bashrc | pbcopy

Después de ese comando, el contenido del archivo ~/.bashrc estará disponible para pegar con cmd+v atajo.

Intenta

xclip

xclip - command line interface to X selections (clipboard) 

Man

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

sudo apt-get install xsel

Aquí hay un script bash listo para usar para leer el portapapeles que funciona en múltiples plataformas. Por favor, 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) probar cat /dev/clipboard o echo "foo" > /dev/clipboard como se menciona en este artículo.

Solo para Mac:

echo "Hello World" | pbcopy
pbpaste

Se encuentran /usr/bin/pbcopy y /usr/bin/pbpaste.

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

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

En X, puedes usar xclip.

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

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

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

Copiar

Thing_you_want_to_copy|xclip -selection c

Pegar

myvariable=$(xclip -selection clipboard -o)

Me di cuenta de un montón de respuestas recomendadas pbpaste y pbcopy. Si te gustan esas utilidades pero por alguna razón no están disponibles en tu repositorio, siempre puedes 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)

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

Véase:

Clip clip.exe -?

CLIP Descripci: Redirige la salida de las herramientas de línea de comandos al portapapeles de Windows. Esta salida de texto se puede pegar en otros programas. Lista de Parámetros: /? Muestra este mensaje de ayuda. Ejemplos: DIR / CLIP Coloca una copia del directorio actual listado en el portapapeles de Windows. CLIP

También existe getclip (se puede usar en lugar de shift+ins!), putclip (echo oaeuoa / putclip.exe para ponerlo en el clip)

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

cat file | clip.exe

Tenga en cuenta usar el comando pipe |. Y no un comando >, ya que eso no funcionará.

Este es un simple script 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é en /usr/local/bin/clip. Puede canalizar las cosas que se guardarán en el portapapeles...

echo "Hello World" | clip

Y puedes canalizar lo que está en tu portapapeles a algún otro programa...

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

Ejecutarlo por sí solo simplemente generará lo que hay en el portapapeles.

  xsel -b

Hace el trabajo para x11, en su mayoría ya está instalado. Una mirada en la página de manual de xsel vale la pena el esfuerzo.

Si eres como yo y corres en un servidor linux sin privilegios de root y no hay xclip o gpm, podrías solucionar este problema simplemente usando un archivo temporal. Por ejemplo:

$ echo "hello world" > ~/clip
$ echo `cat ~/clip`
hello world

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

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

Incluye el 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 a Emacs ni a Screen, así que repasaré los otros tres.

Tmux

Aunque no es una selección X, tmux tiene un modo de copia accesible a través de prefix-[ (prefix is Ctrl+B por defecto). El búfer utilizado para este modo es independiente y exclusivo de tmux, lo que abre bastantes posibilidades y lo hace más versátil que el X selecciones en las situaciones correctas.

Para salir de este modo, presione q; para navegar, use su enlace vim o emacs (por defecto = vim), así que hjkl para el movimiento, v/V/C-v para la selección de caracteres/líneas/bloques, etc. Cuando tenga su selección, presione Enter para copiar y salir del modo.

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

Shell

Cualquier instalación de X11 parece venir con dos programas por defecto: xclip y xsel (un poco como la forma en que también viene con startx y xinit). La mayoría de las otras respuestas mencionan xclip, y realmente me gusta xsel por su brevedad, así que voy a cubrir xsel.

De xsel (1x):

Opciones de entrada

- a, app append

Añadir entrada estándar a la selección. Implica -i.

- f, follow follow

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

- i, input input

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

Opciones de salida

- o, output output

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

Opciones de acción

- c, clear clear

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

- d, delete 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 el los contenidos seleccionados se eliminarán. Anula todas las opciones de entrada.

Opciones de selección

-p, primary primaria

Operar en la selección PRINCIPAL (por defecto).

-s, secondary secundaria

Operar en la selección SECUNDARIA.

- b, clip portapapeles

Operar en la selección del PORTAPAPELES.

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

Ejemplo: digamos que quiero copiar la salida de foo desde un TTY y pegarla en una página web para un informe de error. Para hacer esto, sería ideal copiar a/desde la sesión TTY/X. Así que la pregunta es ¿cómo puedo acceder al portapapeles desde el TTY?

Para este ejemplo, asumiremos que la sesión X está en pantalla :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-V en la forma como de costumbre.

Ahora diga que alguien en el sitio de soporte me da un comando para corre a arreglar 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 comandos.

...continuemos.

Vim

Si se compila con +clipboard (Esto es importante! Compruebe su vim --version), Vim debe tener acceso a las selecciones X PRIMARY y CLIPBOARD. Las dos selecciones son accesibles desde los registros * y +, respectivamente, y se pueden escribir y leer en su tiempo libre, al igual que cualquier otro registrar. 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

Si su copia de vim no admite directamente el acceso a X selecciones, sin embargo, no es el fin del mundo. Solo puede usar la técnica xsel 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`

Ata un par de combinaciones de teclas y deberías ser bueno.

Desde este hilo, hay una opción que no requiere instalar ninguna gclip/xclip/xsel software de terceros.

Un script de perl (ya que perl suele estar siempre instalado)

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

Respuesta de 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 cb poniendo lo siguiente en su .bashrc, .bash_profile, o .zshrc:

alias cb=clipboard

En macOS use pbpaste

Eg:

Actualizar el portapapeles

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

Disfruta.

También existe 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?". Cuando se cambia entre sesiones con ctrlaltF7 - ctrlaltF8, de hecho, no se puede pegar lo copiado.

Se me ocurrió la siguiente solución quick & dirty, basada en una tubería con nombre. Es seguramente bastante desnudo y crudo, pero lo encontré funcional:

user1@host:~$ mkfifo /tmp/sharedClip

Luego en el terminal de envío

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

Por último, en el terminal receptor:

user2@host:~$ cat /tmp/sharedClip

Ahora, escriba o pegue cualquier cosa en el primer terminal, y (después de presionar return), aparecerá inmediatamente en el terminal receptor, desde donde podrá Copiar/Pegar de nuevo en cualquier lugar que desee.

Por supuesto, esto no solo toma estrictamente el contenido del portapapeles del usuario 1 para hacerlo disponible en el usuario 2 portapapeles, sino que requiere un par adicional de clics de Pegar y copiar.