Non consiglierei l'aliasing di rm a mv come potresti abituarti a rm a non eliminare in modo permanente i file e quindi a eseguire problemi su altri computer o sotto altri account utente quando fa elimina definitivamente.

Ho scritto un insieme di script bash che aggiungono altri strumenti da riga di comando simili a Mac OS X (oltre a un numero di quelli incorporati come open , pbcopy , pbpaste , ecc. ), soprattutto trash . La mia versione di trash farà tutte le cose giuste che l'aliasing rm non (e spero non sia nulla di male, ma l'ho usato sui miei Mac per alcuni anni senza dati persi), tra cui: rinominare il file come Finder se esiste già un file con lo stesso nome, mettendo i file nella cartella Cestino corretta su volumi esterni; ha anche alcune sottigliezze aggiunte, come: tenta di utilizzare AppleScript quando è disponibile, in modo da ottenere il bel suono del cestino e tale (ma non lo richiede in modo da poterlo comunque utilizzare tramite SSH quando nessun utente ha effettuato l'accesso), può fornisci la dimensione del Cestino su tutti i volumi.

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

C'è anche un comando di trash sviluppato da Ali Rantakari , ma non l'ho provato io stesso.

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

Permette di ripristinare i file trash tramite la riga di comando o il Finder.

Ho un eseguibile chiamato rem da qualche parte nel mio $PATH con i seguenti contenuti:

EDIT: il codice di seguito è una versione riveduta 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 allo stesso modo dell'eliminazione dal Finder. (Vedi post del blog qui ).

Ho trovato un codice piuttosto carino che può essere aggiunto alla fine del profilo batch dell'utente e causa rm per spostare 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: link

Utilizza il terminale di comando osascript, l'interprete di AppleScript.

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

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

PWD è necessario per i percorsi di file relativi, in quanto AppleScript non gestisce molto bene.

Ci sono due utilità installabili tramite Homebrew che può realizzare questo:

1. cestino

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

By default, trash asks Finder to move the specified files/folders to the trash instead of calling the system API to do this because of the "put back" feature that only works when trashing files through Finder.

-F

Ask Finder to move the files to the trash, instead of using the system API. This is slower, but it utilizes Finder's UI (e.g. sounds) and ensures that the "put back" feature works.

-l

List items currently in the trash. If this argument is used, no files need to be specified.

-e

Empty the trash. trash asks for confirmation before executing this action. If this argument is used, no files need to be specified.

Per installare trash , esegui quanto segue in Terminale:

brew install trash .

2. rmtrash

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

This command moves files to the trash rather than removing them totally from the file system. Very useful if you decide you want that file after all...

-u USERNAME

an optional argument. This will move the file to the specified user's trash. Note that you need sufficient privileges to accomplish this.

Per installare rmtrash , esegui quanto segue in Terminale:

brew install rmtrash .

un approccio moderno con swift

link

//
// 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)
}

Mentre è possibile rendere rm spostare i file nel Cestino invece di rimuoverli, vorrei sconsigliare di portare la mentalità della rete di sicurezza delle interfacce utente grafiche alla shell UNIX. Ci sono molti modi per fare seri danni usando il terminale. Il miglior consiglio di IMHO è quello di pensarci due volte prima di premere il tasto invio in una finestra della shell.

Se vuoi rm per ricordarti che stai per eliminare un file, considera l'utilizzo del seguente alias (per /bin/bash metti questa riga in .bashrc nella tua home directory):

alias rm "rm -i"

Ciò renderà la conferma della richiesta di rm prima di provare a rimuovere ogni 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 brutto, ovviamente. Quindi ripensaci prima di premere quel tasto invio !

Dai un'occhiata a trash-cli . Funziona su più piattaforme, nessun suono spazzatura e supporta la funzionalità di Put Back.

Puoi installarlo con (richiede Node.js ) :

$ npm install --global trash-cli

In alternativa, se non vuoi usare Node.js, puoi installare il file binario nativo osx-trash manualmente.

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

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

Utilizzo:

• ~/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 $$$

Eliminare correttamente elementi (in modo che sia definitivamente ripristinabile) è più complicato di un semplice mv in ~/.Trash .

osx-trash potrebbe essere quello che stai cercando. ( Caveat emptor - Non l'ho provato, e non posso garantire per quanto sia sicuro.)

Nel tuo .bashrc (o dovunque mantieni i parametri per la tua shell), prova ad aggiungere un alias che modifichi 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 'where' davanti al file da spostare potrebbe essere piuttosto approssimativo. Lo esaminerò e potrei ricevere un consiglio più sostanziale.

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

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

È molto più primitivo di 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 , reso excutable chmod +x ~/bin/trash e 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 trascinare i file spostandoli nella cartella .Trash dell'utente:

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