Faccio molto lavoro terminale e oggi ho avuto l'esperienza di scrivere

rm fileInQuestion.txt

Prima di scoprire che avevo effettivamente bisogno di fileInQuestion.txt. Se avessi eliminato nella GUI, l'avrei appena estratto dal Cestino. Vorrei sapere se è possibile sovraccaricare "rm" nel Terminale in modo tale da inviare il file / i file nel Cestino all'uscita.

Non consiglierei aliasing rma mvcome si potrebbe ottenere l'abitudine di rmfile non eliminazione in modo permanente e quindi incorrere in problemi su altri computer o sotto altri account utente quando si fa in modo permanente eliminare.

Ho scritto una serie di bashscript che aggiungono ulteriori strumenti X-simile della riga di comando di Mac OS (oltre a un certo numero di quelle built-in come open, pbcopy, pbpaste, ecc), la cosa più importante trash. La mia versione di trashfarà tutte le cose corrette che l'aliasing rmnon farà (e si spera niente di male, ma lo sto usando sul mio Mac da qualche anno senza dati persi), tra cui: rinominare il file come fa Finder se esiste già un file con lo stesso nome, inserendo i file nella cartella Cestino corretta su volumi esterni; ha anche alcune bellezze aggiunte, come: tenta di usare AppleScript quando disponibile in modo da ottenere il bel suono spazzatura e simili (ma non lo richiede in modo da poterlo ancora usare tramite SSH quando nessun utente è connesso), può ti dà la dimensione del cestino su tutti i volumi.

Puoi prendere la mia suite tools-osx dal mio sito o l'ultima e la più grande versione dal repository GitHub .

C'è anche un trashcomando sviluppato da Ali Rantakari , ma non l'ho testato da solo.

Lo strumento da riga di comando cestino può essere installato tramite brew install trash.

Ti consente di ripristinare i file nel cestino tramite la riga di comando o il Finder.

Ho un eseguibile chiamato remda qualche parte nel mio $PATHcon i seguenti contenuti:

EDIT: il codice seguente è una versione rivista e migliorata in collaborazione con Dave Abrahams :

#!/usr/bin/env python
import os
import sys
import subprocess

if len(sys.argv) > 1:
    files = []
    for arg in sys.argv[1:]:
        if os.path.exists(arg):
            p = os.path.abspath(arg).replace('\\', '\\\\').replace('"', '\\"')
            files.append('the POSIX file "' + p + '"')
        else:
            sys.stderr.write(
                "%s: %s: No such file or directory\n" % (sys.argv[0], arg))
    if len(files) > 0:
        cmd = ['osascript', '-e',
               'tell app "Finder" to move {' + ', '.join(files) + '} to trash']
        r = subprocess.call(cmd, stdout=open(os.devnull, 'w'))
        sys.exit(r if len(files) == len(sys.argv[1:]) else 1)
else:
    sys.stderr.write(
        'usage: %s file(s)\n'
        '       move file(s) to Trash\n' % os.path.basename(sys.argv[0]))
    sys.exit(64) # matches what rm does on my system

Si comporta esattamente come l'eliminazione dal Finder. (Vedi il post sul blog qui .)

Ho trovato un codice abbastanza carino che può essere aggiunto alla fine del profilo batch dell'utente e fa rmspostare i file nel cestino ogni volta che viene eseguito.

nano ~ / .bash_profile

#... append at the end
function rm () {
  local path
  for path in "$@"; do
    # ignore any arguments
    if [[ "$path" = -* ]]; then :
    else
      # remove trailing slash
      local mindtrailingslash=${path%/}
      # remove preceding directory path
      local dst=${mindtrailingslash##*/}
      # append the time if necessary
      while [ -e ~/.Trash/"$dst" ]; do
        dst="`expr "$dst" : '\(.*\)\.[^.]*'` `date +%H-%M-%S`.`expr "$dst" : '.*\.\([^.]*\)'`"
      done
      mv "$path" ~/.Trash/"$dst"
    fi
  done
}

fonte: http://hints.macworld.com/article.php?story=20080224175659423

Utilizzare il comando terminale osascript, l'interprete AppleScript.

osascript -e "tell application \"Finder\" to delete POSIX file \"${PWD}/${InputFile}\""

Questo dice ad AppleScript di dire a Finder di inviare il file nel cestino.

PWD è necessario per i percorsi di file relativi, poiché AppleScript non gestisce così bene.

un approccio moderno usando swift

https://github.com/reklis/recycle

//
// main.swift
// recycle
//
// usage: recycle <files or directories to throw out>
//

import Foundation
import AppKit

var args = NSProcessInfo.processInfo().arguments
args.removeAtIndex(0) // first item in list is the program itself

var w = NSWorkspace.sharedWorkspace()
var fm = NSFileManager.defaultManager()

for arg in args {
    let path = arg.stringByStandardizingPath;
    let file = path.lastPathComponent
    let source = path.stringByDeletingLastPathComponent

    w.performFileOperation(NSWorkspaceRecycleOperation,
        source:source,
        destination: "",
        files: [file],
        tag: nil)
}

Sebbene sia possibile rmspostare i file nel Cestino anziché rimuoverli, vorrei sconsigliare di portare la mentalità della rete di sicurezza delle interfacce grafiche dell'utente sulla shell UNIX. Esistono molti modi per arrecare gravi danni utilizzando il terminale. Il miglior consiglio di IMHO è semplicemente di pensarci due volte prima di premere la enterchiave in una finestra shell.

Se vuoi rmricordare che stai per eliminare un file, considera l'utilizzo del seguente alias (per /bin/bashinserire questa riga .bashrcnella tua home directory):

alias rm "rm -i"

Ciò consentirà la rmconferma della richiesta prima di tentare di rimuovere ciascun file.

Se hai TimeMachine in esecuzione (lo spero!) Puoi sempre ottenere il tuo file dal backup. In questo modo puoi perdere al massimo un'ora di lavoro. Il che è abbastanza male, ovviamente. Quindi ripensaci prima di premere quel entertasto!

Esistono due utility installabili tramite Homebrew che possono ottenere questo risultato:

1. spazzatura

   Questo è un piccolo programma da riga di comando per OS X che sposta i file o le cartelle nel cestino. L'USP di questo comando è che consente di ripristinare facilmente i file. Un comando per eliminare file / cartelle è inutile se non è possibile ripristinare file / cartelle dopo averli eliminati. Dal sito Web del comando:

Per impostazione predefinita, cestino chiede a Finder di spostare i file / le cartelle specificati nel cestino invece di chiamare l'API di sistema per farlo a causa della funzione "rimessa" che funziona solo quando si esegue il cestino dei file tramite Finder.

-F

Chiedi a Finder di spostare i file nel cestino, invece di utilizzare l'API di sistema. Questo è più lento, ma utilizza l'interfaccia utente del Finder (ad es. Suoni) e garantisce che la funzione "rimessa in funzione" funzioni.

-l

Elenca gli elementi attualmente nel cestino. Se si utilizza questo argomento, non è necessario specificare alcun file.

-e

Svuota il cestino. cestino chiede conferma prima di eseguire questa azione. Se si utilizza questo argomento, non è necessario specificare alcun file.

Per installare trasheseguire quanto segue nel Terminale:

brew install trash.

2. rmtrash

   Uno strumento da riga di comando che sposta i file nel cestino. Dalla pagina man del comando:

Questo comando sposta i file nel cestino anziché rimuoverli totalmente dal file system. Molto utile se decidi di voler quel file dopo tutto ...

-u USERNAME

un argomento facoltativo. Questo sposterà il file nel cestino dell'utente specificato. Si noti che sono necessari privilegi sufficienti per raggiungere questo obiettivo.

Per installare rmtrasheseguire quanto segue nel Terminale:

brew install rmtrash.

Ecco una soluzione di una riga piuttosto banale da aggiungere al tuo profilo bash. Nota che sovrascriverà già qualcosa con lo stesso nome nel cestino.

trash() { mv -fv "$@" ~/.Trash/ ; }

Uso:

• ~/Desktop $$$ touch a b c
• ~/Desktop $$$ ls
a b c
• ~/Desktop $$$ trash a b c
a -> /Users/ryan.tuck/.Trash/a
b -> /Users/ryan.tuck/.Trash/b
c -> /Users/ryan.tuck/.Trash/c
• ~/Desktop $$$ ls
• ~/Desktop $$$

Cestinare correttamente le cose (in modo che sia sicuramente recuperabile) è più complicato di un semplice da mvfare ~/.Trash.

osx-trash potrebbe essere quello che stai cercando. ( Caveat emptor : non l'ho provato e non posso garantire la sua sicurezza.)

Partenza trash-cli. Funziona su più piattaforme, senza audio spazzatura e supporta Put Back.

Puoi installarlo con (richiede Node.js ) :

$ npm install --global trash-cli

In alternativa, se non si desidera utilizzare Node.js, è possibile installare osx-trashmanualmente il file binario nativo .

Nel tuo .bashrc (o ovunque mantieni i parametri per la tua shell), prova ad aggiungere un alias che cambi il comportamento di rm nello spostamento di cose in ~ / .Trash, come in:

alias rm='move/to/.Trash'

Questo alias è tutt'altro che banale da implementare (almeno per me), perché l'uso di mv (il primo candidato da utilizzare per questo lavoro) è

mv file where

quindi avere un alias che mette la parte 'dove' davanti al file da spostare potrebbe essere piuttosto imprecisa. Lo esaminerò e potrei ottenere consigli più sostanziali.

EDIT: Ho appena provato ad aggiungere quanto segue al mio .bashrc, e funziona:

function trash { mv "$@" ~/.Trash ; }

È molto più primitivo rispetto ad altri suggerimenti, ma eviti di installare nuove cose.

Ho semplicemente messo questo script

#!/bin/bash
application=$(basename "$0")
if [ "$#" == 0 ]; then
    echo "Usage: $application path [paths...]"
    exit 1
fi
trashdir="/Users/${USER}/.Trash"
while (( "$#" )); do
    if [ -e "$1" ]; then
        src=$(basename "$1")
        dst=$src
        while [ -e "$trashdir/$dst" ]; do
            dst=$src+`date +%H-%M-%S`
        done
        mv -f "$1" "$trashdir/$dst"
    else
        echo "$1" does not exist.
    fi
    shift
done

in ~/bin/trash, lo ha reso stimabile chmod +x ~/bin/trashe ha aggiunto la seguente riga a~/.bash_profile

PATH=$PATH:$HOME/bin

Quindi si può usare come

$ trash broken.js olddir cleanup.*

Una semplice funzione potrebbe consentire di eliminare i file spostandoli nella cartella .Trash dell'utente:

trash() {
   mv $1 ~/.Trash
}