È possibile eseguire il pipe negli / dagli Appunti in Bash?

Che si tratti di eseguire il piping da / verso un handle di dispositivo o di utilizzare un'applicazione ausiliaria, non riesco a trovare nulla.

Ad esempio, se /dev/clipfosse un dispositivo collegato agli Appunti potremmo fare:

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

Ci sono molti appunti che potresti avere a che fare. Mi aspetto che tu sia probabilmente un utente Linux che vuole mettere cose negli Appunti primari di X Windows. Di solito, gli appunti con cui vuoi parlare hanno un'utilità che ti consente di parlarci.

Nel caso di X, c'è xclip(e altri). xclip -selection cinvierà i dati negli Appunti con cui funziona Ctrl + C, Ctrl + Vnella maggior parte delle applicazioni.

Se sei su Mac OS X, c'è pbcopy. per esempiocat example.txt | pbcopy

Se sei in modalità terminale Linux (no X), guarda gpmo fai uno schermo con degli appunti. Prova il screencomando readreg.

In Windows 10+ o cygwin, utilizzare /dev/clipboardo clip.

Assicurati di utilizzare alias xclip="xclip -selection c" altrimenti non puoi semplicemente utilizzare Ctrl+ vper incollarlo nuovamente in un posto diverso.

echo test | xclip    

Ctrl+v === test

Installare

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

# or `pacman`
pacman -S xclip

# or `dnf`
dnf install xclip

Se non si dispone di accesso alla apt-getnè pacman, nè dnf, le sorgenti sono disponibili su sourceforge .

Impostare

bash

In ~/.bash_aliases, aggiungi:

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

Non dimenticare di caricare la nuova configurazione utilizzando . ~/.bash_aliaseso riavviando il profilo.

Pesce

In ~/.config/fish/config.fish, aggiungi:

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

Non dimenticare di riavviare l'istanza di pesce riavviando il terminale per applicare le modifiche.

uso

Ora puoi usare setclipe getclip, ad esempio:

$ echo foo | setclip
$ getclip
foo

Su macOS usa i comandi pbcopye quelli integrati pbpaste.

Ad esempio, se corri

cat ~/.bashrc | pbcopy

il contenuto del ~/.bashrcfile sarà disponibile per incollare con il collegamento Cmd+ v.

Provare

xclip

xclip - command line interface to X selections (clipboard) 

uomo

xsel su 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

Installare

sudo apt-get install xsel

Wow, non posso credere a quante risposte ci sono per questa domanda. Non posso dire di averli provati tutti, ma ho provato i primi 3 o 4 e nessuno di loro funziona per me. Ciò che ha funzionato per me è stata una risposta contenuta in uno dei commenti scritti da un utente chiamato doug. Da quando l'ho trovato così utile, ho deciso di riaffermare una risposta.

Installa l'utility xcopy e quando sei nel Terminale, inserisci:

copia

Thing_you_want_to_copy|xclip -selection c

Incolla

myvariable=$(xclip -selection clipboard -o)

Ho notato molte risposte consigliate pbpaste e pbcopy. Se ti piacciono quelle utility ma per qualche motivo non sono disponibili nel tuo repository, puoi sempre creare un alias per i comandi xcopy e chiamarli pbpaste e pbcopy.

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

Quindi sembrerebbe così:

Thing_you_want_to_copy|pbcopy
myvariable=$(pbpaste)

Risposta 2018

Usa appunti-cli . Funziona con macOS, Windows, Linux, OpenBSD, FreeBSD e Android senza problemi reali.

Installalo con:

npm install -g clipboard-cli

Quindi puoi farlo

echo foo | clipboard

Se si desidera, è possibile alias cbinserendo la seguente nel vostro .bashrc, .bash_profileoppure .zshrc:

alias cb=clipboard

Sul sottosistema Windows per Linux è possibile copiare negli appunti con clip.exe.

cat file | clip.exe

Ricorda di usare il |comando pipe. E non un >comando, dal momento che non funzionerà.

Ecco uno script bash pronto per l'uso per leggere gli Appunti che funziona su più piattaforme. Modifica lo script qui se aggiungi funzionalità (ad es. Più piattaforme).

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

Su Windows (con Cygwin) provare cat /dev/clipboardo echo "foo" > /dev/clipboardcome indicato in questo articolo.

Solo per Mac:

echo "Hello World" | pbcopy
pbpaste

Questi sono situati /usr/bin/pbcopye /usr/bin/pbpaste.

Ci sono diversi appunti in Linux; il server X ne ha uno, il gestore delle finestre potrebbe averne un altro, ecc. Non esiste un dispositivo standard.

Oh, sì, sulla CLI, anche il programma dello schermo ha i suoi appunti, così come altre applicazioni come Emacs e vi .

In X, puoi usare xclip .

Puoi controllare questa discussione per altre possibili risposte: http://unix.derkeiler.com/Newsgroups/comp.unix.shell/2004-07/0919.html

Copia e incolla negli appunti in Windows (Cygwin):

Vedere:

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

Esistono anche getclip (può essere usato al posto di Shift+ Ins!) E putclip (echo oaeuoa | putclip.exe per metterlo in clip).

Questo è un semplice script Python che fa proprio quello che ti serve:

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

Salvalo come eseguibile da qualche parte nel tuo percorso (l'ho salvato in /usr/local/bin/clip. Puoi inserire elementi da salvare negli Appunti ...

echo "Hello World" | clip

E puoi reindirizzare ciò che è negli appunti ad un altro programma ...

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

Eseguendolo da solo verrà semplicemente visualizzato ciò che è negli Appunti.

Ho trovato un buon riferimento: /unix/69111/

Nel mio caso vorrei incollare il contenuto negli appunti e anche vedere cosa è stato incollato lì, quindi ho usato anche il teecomando con un descrittore di file:

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

>()è una forma di sostituzione del processo. bash sostituisce ciascuno con il percorso di un descrittore di file che è collegato all'input standard del programma tra parentesi.

Il teecomando inoltra il tuo comando permettendoti di "convogliarne il contenuto" e vedere il risultato sullo standard output "stdout"

puoi anche creare alias per ottenere e scrivere negli appunti, permettendoti di usare "pbcopy" e "pbpaste" come se fossi su MAC. Nel mio caso, mentre uso zsh ho questo sul mio file alias:

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

il (( $+command[name] ))se il comando "nome" è installato sul sistema in prove zsh, quindi entrambi gli alias sono raggruppati con {}. il &&è un binario e, se poi b, quindi se avete xclip allora gli alias verrà impostata.

echo "another test" | tee >(pbcopy)

Per ottenere il contenuto degli Appunti basta digitare:

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

  xsel -b

Fa il lavoro per X Window ed è per lo più già installato. Uno sguardo nella pagina man di xsel vale la pena.

Alcuni programmi Windows che ho scritto anni fa. Ti permettono di scaricare, spingere, aggiungere e stampare gli appunti. Funziona così:

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

Include il codice sorgente: cmd_clip.zip

Ci sono un paio di modi. Alcuni dei modi che sono stati menzionati includono (penso) tmux, screen, vim, emacs e shell. Non conosco emacs o screen, quindi esaminerò gli altri tre.

tmux

Pur non essendo una selezione X, tmux ha una modalità di copia accessibile tramite prefix-[( prefixè Ctrl+ Bper impostazione predefinita). Il buffer utilizzato per questa modalità è separato ed esclusivo di tmux, il che apre parecchie possibilità e lo rende più versatile delle selezioni X nelle giuste situazioni.

Per uscire da questa modalità, premi q; per navigare, usare la tua vimo la emacsrilegatura (default = vim), quindi hjklper il movimento, v/V/C-vper la selezione di caratteri / linea / blocco, ecc. Quando hai la tua selezione, premi Enterper copiare ed uscire dalla modalità.

Per incollare da questo buffer, utilizzare prefix-].

Conchiglia

Ogni installazione di X11sembra avere due programmi di default: xclipe xsel(un po 'come viene fornito anche con entrambi startxe xinit). La maggior parte delle altre risposte menziona xclip, e mi piace molto xselper la sua brevità, quindi parlerò xsel.

Da xsel (1x) :

Opzioni di input

-a, --appendi

aggiunge input standard alla selezione. Implica -i .

-f, --segui

accoda alla selezione man mano che aumenta l'input standard. Implica -i .

-i, --input

leggere l'input standard nella selezione.

Opzioni di output

-o, --output

scrivere la selezione sullo standard output.

Opzioni di azione

-c, --clear

cancella la selezione. Sostituisce tutte le opzioni di input.

-d, --delete

Richiedi l'eliminazione della selezione corrente. Ciò non solo cancella la selezione, ma richiede anche al programma in cui la selezione risiede che i contenuti selezionati vengano eliminati. Sostituisce tutte le opzioni di input.

Opzioni di selezione

-p, --primary

operare sulla selezione PRIMARY (impostazione predefinita).

-s, --secondary

operare sulla selezione SECONDARIA.

-b, --clipboard

operare sulla selezione CLIPBOARD.

E questo è tutto ciò che devi sapere. p(o niente) per PRIMARY, sper SECONDARY, bper CLIPBOARD, oper l'output.

Esempio: dire che voglio copiare l'output di fooun TTY e incollarlo in una pagina Web per una segnalazione di bug. Per fare ciò, sarebbe l'ideale copiare nella / dalla sessione TTY / X. Quindi la domanda diventa come posso accedere agli Appunti dal TTY?

Per questo esempio, supponiamo che la sessione X sia visualizzata :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

Quindi posso Ctrl-Vfarlo nella forma come al solito.

Ora dì che qualcuno sul sito di supporto mi dà un comando da eseguire per risolvere il problema. È complicato e lungo.

$ 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

L'ordinamento della pizza sembra un uso produttivo della riga di comando.

...andare avanti.

Vim

Se compilato con +clipboard(Questo è importante! Controlla il tuo vim --version), Vim dovrebbe avere accesso alla X PRIMARYe alle CLIPBOARDselezioni. Le due selezioni sono accessibili dai registri *e +, rispettivamente, e possono essere scritte e lette a piacimento come qualsiasi altro registro. Per esempio:

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

Se la tua copia di vim non supporta direttamente l'accesso alle selezioni X, tuttavia, non è la fine del mondo. Puoi semplicemente usare la xseltecnica come descritto nell'ultima sezione.

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

Associa un paio di combinazioni di tasti e dovresti essere bravo.

Da questo thread, c'è un'opzione che non richiede l'installazione di alcun software gclip/ xclip/ di xselterze parti.

Uno script perl (dal momento che perl è sempre installato)

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

pbcopy è integrato in OSX:

Copia del contenuto di .bash_profile:

cat ~/.bash_profile | pbcopy

In macOS, usa pbpaste.

Per esempio:

Aggiorna gli Appunti

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

Se sei come me e corri su un server Linux senza i privilegi di root e non ci sono xclip o GPM, puoi risolvere questo problema semplicemente usando un file temporaneo. Per esempio:

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

In Linux funziona:

cat filename | xclip

su Wayland xcopy non sembra funzionare, usa invece wl-appunti . ad es. su fedora

sudo dnf install wl-clipboard

tree | wl-copy

wl-paste > file

C'è anche xclip-copyfile .

Anche se> 1 anno dopo, condivido una soluzione leggermente diversa. Spero che questo sia utile per qualcuno.

Ieri mi sono trovato con la domanda: "Come condividere gli Appunti tra sessioni utente diverse?" . Quando si passa da una sessione all'altra con ctrlaltF7-ctrlaltF8 , in effetti, non è possibile incollare ciò che è stato copiato.

Ho trovato la seguente soluzione rapida e sporca , basata su una pipa denominata. È sicuramente abbastanza spoglio e crudo, ma l'ho trovato funzionale:

user1@host:~$ mkfifo /tmp/sharedClip

quindi nel terminale di invio

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

infine, nel terminale ricevente:

user2@host:~$ cat /tmp/sharedClip

Ora, scrivi o incolla qualsiasi cosa nel primo terminale e (dopo aver colpito return), apparirà immediatamente nel terminale di ricezione, da dove puoi copiare / incollare di nuovo ovunque tu voglia.

Naturalmente questo non solo prende strettamente il contenuto dagli appunti di user1 per renderlo disponibile negli appunti di user2, ma piuttosto richiede una coppia aggiuntiva di incolla e copia clic.

L'eliner rubino mi ha ispirato a provare con il pitone.

Diciamo che vogliamo un comando che indenta qualsiasi cosa sia negli appunti con 4 spazi. Perfetto per la condivisione di frammenti su StackOverflow.

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

non è un refuso. Python ha bisogno di nuove righe per eseguire un ciclo for. Vogliamo modificare le linee in un passaggio per evitare di creare un array aggiuntivo in memoria.

Se non ti dispiace costruire l'array extra prova:

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

ma onestamente awk è meglio di questo rispetto a Python. Ho definito questo alias nel mio ~/.bashrcfile

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

ora quando corro indenttutto ciò che è nei miei appunti è rientrato.