Wie schreiben Sie in die Zwischenablage auf Ubuntu/Linux in R?

Bin ich mit Ubuntu 11.10 und ich möchte in der Lage sein, zu schreiben in die Zwischenablage (oder primäre Selektion). Die folgende gibt einen Fehler,

> x <- 1:10
> dput(x, 'clipboard')
Error in file(file, "wt") : 'mode' for the clipboard must be 'r' on Unix

Wie kann ich das schreiben in die Zwischenablage/primäre Auswahl?

Beachten Sie, dass ich gesehen habe,dieses alte R-Hilfe-die post, aber ich bin mir immer noch nicht klar, was ich tun sollte.

Linux nicht die Zwischenablage, sondern eine X11-Sitzung hat primär-und
sekundäre Auswahl. ?die Datei sagt

Zwischenablage:
  'file' can also be used with 'description = "clipboard"' in mode
  '"r"' only.  It reads the X11 primary selection, which can also be
  specified as '"X11_primary"' and the secondary selection as
  '"X11_secondary"'.

  When the clipboard is opened for reading, the contents are
  immediately copied to internal storage in the connection.

  Unix users wishing to _write_ to the primary selection may be able
  to do so via 'xclip' (<URL:
  http://people.debian.org/~kims/xclip/>), for example by
  'pipe("xclip -i", "w")'.
also RTFM angewendet. Schreiben Sie eine X11-Auswahl braucht mehrere threads
und ich glaube nicht, es lohnt sich die sehr beträchtliche Anstrengung
Umsetzung (anders als bei Windows).

Beachten Sie, dass Fenster-Managern können andere Ablagen, und zum Beispiel
die RGtk2 Paket-Schnittstellen für gtk Zwischenablagen.

InformationsquelleAutor Jeromy Anglim | 2012-06-09

16

Nicht sicher, ob dies die besten Weg, aber hier ist, wie ich bekommen konnte, um es an die Arbeit:
1. Install xclip: sudo apt-get install xclip
2. Lesen Sie das Handbuch: man xclip
3. Schreiben X11 primär in R: write.table(1:10, pipe("xclip -i", "w"))
Update:

Beachten Sie, dass das übergebene Objekt write.table wird nicht in der Zwischenablage, bis das Rohr geschlossen ist. Sie können erzwingen, das Rohr zu schließen, indem Sie gc(). Zum Beispiel:
```
write.table(1:10, pipe("xclip -i", "w"))  # data may not be in clipboard
gc()                                      # data written to primary clipboard
```
Eine bessere Möglichkeit zur Verwaltung der Verbindung ist die Verwendung einer Funktion mit on.exit(close(con)), die in der Nähe der pipe, auch wenn die write.table Aufruf löst einen Fehler. Beachten Sie, dass Sie benötigen, um sicherzustellen, dass Sie das schreiben in die Zwischenablage, die Sie verwenden möchten (primäre) ist die Standardeinstellung, basierend auf Ihrem system-setup.
```
write.xclip <- function(x, selection=c("primary", "secondary", "clipboard"), ...) {
  if (!isTRUE(file.exists(Sys.which("xclip")[1L])))
    stop("Cannot find xclip")
  selection <- match.arg(selection)[1L]
  con <- pipe(paste0("xclip -i -selection ", selection), "w")
  on.exit(close(con))
  write.table(x, con, ...)
}
```
- +1 vielen Dank. Ich weiß es zu schätzen. Ich bin immer noch daran interessiert zu sehen, welche Strategien vorhanden sind. Der Hauptgrund, warum ich gelegentlich gerne einfügen in der Zwischenablage zu speichern, ein paar Sekunden, anstatt Sie in eine Datei schreiben und kopieren von der Datei. Die oben genannten Strategie scheint zu vermuten, dass ich Vorhersagen kann, vor der Zeit, dass ich müsste die Zwischenablage. Ich konnte auch nicht bekommen, es funktioniert in R-Studio. Ich konnte nur das arbeiten mit der Konsole.
- Mir ist auch aufgefallen das war eine RStudio Problem, so dass Sie lieber Bericht zu RStudio-Entwickler. Ich weiß nicht, was Sie Taten, mit die Zwischenablage.
- Dies funktionierte nicht für mich in ubuntu entweder in R-Studio oder in der terminal-version von R. ich gebe zu, dass ich nicht vollständig gelesen, die den Mann xclip (Schritt 2), aber ich glaube nicht, dass sollten die Ergebnisse beeinflussen.
- Hat nicht funktioniert für mich (Linux Mint 18, basiert auf Ubuntu 16.04).
- Der oben hat bei mir nicht funktioniert in einer interaktiven session, sondern die Schaffung einer separaten Verbindung variable und dann manuell aufrufen close() auf, wie in @Freecube die Lösung von unten, hat den trick.
- sieht aus wie das ist, weil das Rohr nicht geleert werden, bis die Verbindung geschlossen wird. Sie können es zwingen, zu schließen, indem Sie gc() ist, aber eine Funktion und on.exit ist robuster. Ich habe aktualisiert, meine Antwort entsprechend.
- Gute Vorschläge! Vielen Dank für die Zeit nehmen, zu aktualisieren, zu beantworten, wie gut.
- Funktion fehlt, ist ein parens, aber ich kann ihn nicht Bearbeiten, weil 6 Zeichen.
- behoben!
InformationsquelleAutor Joshua Ulrich
20
```
clipboard <- function(x, sep="\t", row.names=FALSE, col.names=TRUE){
     con <- pipe("xclip -selection clipboard -i", open="w")
     write.table(x, con, sep=sep, row.names=row.names, col.names=col.names)
     close(con)
}

vec <- c(1,2,3,4)

clipboard(vec)
clipboard(vec, ",", col.names=FALSE)
clipboard(vec, " ", row.names=TRUE)
```
Können Sie wieder alles, was Sie schreiben, in die Zwischenablage, nach dem erstellen der Funktion als solche. Standardmäßig gibt tab-separierte Werte mit der Spalte, aber keine Zeile Namen. Geben Sie anderen Separatoren, include-Zeile Namen oder ausschließen Spaltennamen nach Ihren wünschen, wie gezeigt.

Edit: um Zu klären, müssen Sie noch installieren xclip. Sie brauchen nicht, um es zu starten separat Erster, though.
- Keine dieser Lösungen arbeiten für mich 🙁
InformationsquelleAutor Freecube
6

den clipr-Paket macht das wirklich einfach
```
x <- 1:10
clipr::write_clip(x)
```
InformationsquelleAutor Thomas Luechtefeld

Versionen:

Mint 18.1, Zimt
xclip 0.12
R 3.4.0 (2017-04-21)

Konnte ich nicht bekommen, die anderen Lösungen zu arbeiten, so dass ich maned bis. Dieser Ansatz funktioniert für mich (basiert auf anderen' Lösungen).

write_clipboard = function(x, .rownames = F) {
    #decide how to write
    #windows is easy!
    if (Sys.info()['sysname'] %in% c("Windows")) {
      #just write as normal
      write.table(x, "clipboard", sep = "\t", na = "", row.names = F)
    } else {
      #for non-windows, try xclip approach
      #https://stackoverflow.com/a/10960498/3980197
      write.xclip = function(x) {
        #if xclip not installed
        if (!isTRUE(file.exists(Sys.which("xclip")[1L]))) {
          stop("Cannot find xclip")
        }
        con <- pipe("xclip -selection c", "w")
        on.exit(close(con))
        write.table(x, con, sep = "\t", na = "", row.names = F)
      }

      tryCatch({
        write.xclip(x)
      }, error = function(e) {
        message("Could not write using xclip")
      })
    }
}

Ist es eine verwässerte version von einer Funktion in meine persönliche R-Paket.

Lesen aus der Zwischenablage

Lesen ist auch schwierig. Hier ist eine Begleiter-Funktion für den oben genannten.

read_clipboard = function(header = T,
                          sep = "\t",
                          na.strings = c("", "NA"),
                          check.names = T,
                          stringsAsFactors = F,
                          dec = ".",
                          ...) {
  #decide how to read
  #windows is easy!
  if (Sys.info()['sysname'] %in% c("Windows")) {
    #just read as normal
    read.table(file = con, sep = sep, header = header, check.names = check.names, na.strings = na.strings, stringsAsFactors = stringsAsFactors, dec = dec, ...)
  } else {
    #for non-windows, try xclip approach
    #https://stackoverflow.com/a/10960498/3980197
    read.xclip = function(x) {
      #if xclip not installed
      if (!isTRUE(file.exists(Sys.which("xclip")[1L]))) {
        stop("Cannot find xclip")
      }
      con <- pipe("xclip -o -selection c", "r")
      on.exit(close(con))
      read.table(file = con, sep = sep, header = header, check.names = check.names, na.strings = na.strings, stringsAsFactors = stringsAsFactors, dec = dec, ...)
    }

    tryCatch({
      read.xclip(x)
    }, error = function(e) {
      message(sprintf("error: %s", e$message))
    })
  }
}

InformationsquelleAutor Deleet

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.