No recomendaría que el aliasing rm to mv , ya que puede adquirir el hábito de que rm no elimine los archivos de forma permanente y luego tenga problemas en otras computadoras o en otras cuentas de usuario cuando sí lo haga. eliminar permanentemente.

Escribí un conjunto de secuencias de comandos bash que agregan más herramientas de línea de comandos similares a Mac OS X (además de una serie de herramientas integradas como open , pbcopy , pbpaste , etc. ), lo más importante trash . Mi versión de trash hará todas las cosas correctas que el aliasing rm no hará (y espero que no sea malo, pero lo he estado usando en mis propias Mac desde hace algunos años sin ninguna pérdida de datos), incluyendo: cambiar el nombre del archivo como lo hace el Finder si ya existe un archivo con el mismo nombre, colocando los archivos en la carpeta de la Papelera correcta en volúmenes externos; también tiene algunas mejoras añadidas, como: intenta usar AppleScript cuando está disponible para obtener el buen sonido de la basura y demás (pero no lo requiere, por lo que aún puede usarlo a través de SSH cuando ningún usuario ha iniciado sesión), puede le da el tamaño de la Papelera en todos los volúmenes.

Puede obtener mi tools-osx suite de mi sitio o la última y mejor versión de el repositorio de GitHub .

También hay un comando trash desarrollado por Ali Rantakari , pero no lo he probado yo mismo.

La herramienta de línea de comandos trash se puede instalar a través de brew install trash .

Le permite restaurar archivos en papel a través de la línea de comandos o el Finder.

Tengo un ejecutable llamado rem en algún lugar de mi $PATH con el siguiente contenido:

EDITAR: el código a continuación es una versión revisada y mejorada en colaboración 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

Se comporta exactamente de la misma manera que se elimina del Finder. (Consulte la publicación del blog aquí .)

Encontré un código muy bueno que se puede agregar al final del perfil de lotes del usuario y hace que rm mueva los archivos a la basura cada vez que se ejecuta.

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
}

fuente: enlace

Use el comando de terminal osascript, el intérprete de AppleScript.

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

Esto le dice a AppleScript que le diga a Finder que envíe el archivo a la papelera.

Se necesita PWD para las rutas de archivo relativas, ya que AppleScript no se maneja tan bien.

Hay dos utilidades instalables a través de Homebrew que pueden lograr esto:

1. trash

   Este es un pequeño programa de línea de comandos para OS X que mueve archivos o carpetas a la papelera. La USP de este comando es que permite restaurar fácilmente los archivos. Un comando para eliminar archivos / carpetas no sirve de nada si no puede restaurar archivos / carpetas después de eliminarlos. Desde el sitio web del comando:

  

De forma predeterminada, trash le pide al Buscador que mueva los archivos / carpetas especificados a la papelera en lugar de llamar a la API del sistema para hacer esto debido a la función de "recuperación" que solo funciona cuando se eliminan archivos a través del Finder.

  

-F

     

Pida al Finder que mueva los archivos a la papelera, en lugar de usar la API del sistema. Esto es más lento, pero utiliza la interfaz de usuario de Finder (por ejemplo, los sonidos) y garantiza que la función de "volver a poner" funcione.

     

-l

     

Lista de elementos actualmente en la papelera. Si se utiliza este argumento, no es necesario especificar ningún archivo.

     

-e

     

Vacía la basura. La papelera solicita confirmación antes de ejecutar esta acción. Si se utiliza este argumento, no es necesario especificar ningún archivo.

Para instalar trash ejecute lo siguiente en la Terminal:

brew install trash .

2. rmtrash

   Una herramienta de línea de comandos que mueve archivos a la papelera. Desde la página del comando:

  

Este comando mueve los archivos a la papelera en lugar de eliminarlos totalmente del sistema de archivos. Muy útil si decides que quieres ese archivo después de todo ...

  

-u NOMBRE DE USUARIO

     

un argumento opcional. Esto moverá el archivo a la papelera del usuario especificado. Tenga en cuenta que necesita suficientes privilegios para lograr esto.

Para instalar rmtrash ejecute lo siguiente en la Terminal:

brew install rmtrash .

un enfoque moderno usando swift

enlace

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

Aunque es posible hacer que rm mueva los archivos a la Papelera en lugar de eliminarlos, aconsejaría no llevar la mentalidad de la red de seguridad de las interfaces gráficas de usuario al shell de UNIX. Hay muchas formas de hacer daño grave utilizando el terminal. El mejor consejo IMHO es simplemente pensar dos veces antes de presionar la tecla enter en una ventana de shell.

Si desea que rm le recuerde que está a punto de eliminar un archivo, considere usar el siguiente alias (para /bin/bash ponga esta línea en .bashrc en su directorio de inicio):

alias rm "rm -i"

Esto hará que rm solicite confirmación antes de intentar eliminar cada archivo .

Si tiene TimeMachine en ejecución (¡espero que así sea!), siempre puede obtener su archivo desde la copia de seguridad. De esta manera puedes perder como máximo una hora de trabajo. Lo cual es bastante malo, por supuesto. Así que piénselo nuevamente antes de presionar la tecla ingresar !

Consulte trash-cli . Funciona multiplataforma, sin sonido de basura, y es compatible con Put Back.

Puede instalarlo con (requiere Node.js ) :

$ npm install --global trash-cli

Alternativamente, si no desea utilizar Node.js, puede instalar el binario nativo osx-trash manualmente.

Aquí hay una solución de una línea bastante trivial para agregar a tu perfil de bash. Tenga en cuenta que ya sobrescribirá algo con el mismo nombre en la papelera.

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

La eliminación correcta de cosas (para que sea recuperable definitivamente) es más complicada que simplemente un mv a ~/.Trash .

osx-trash puede ser lo que estás buscando. ( Caveat emptor : no lo he probado y no puedo responder por lo seguro que es).

En tu .bashrc (o donde sea que guardes los parámetros para tu shell), intenta agregar un alias que cambie el comportamiento de rm para mover cosas a ~ / .Trash, como en:

alias rm='move/to/.Trash'

Sin embargo, este alias está lejos de ser trivial para implementarlo (al menos para mí), porque el uso de mv (el candidato principal para este trabajo) es

mv file where

por lo tanto, tener un alias que coloque la parte 'donde' delante del archivo que se va a mover puede ser bastante incompleto. Lo investigaré y podré obtener consejos más sustanciales.

EDITAR: acabo de intentar agregar lo siguiente a mi .bashrc, y funciona:

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

Es mucho más primitivo que otras sugerencias, pero evita instalar cosas nuevas.

Simplemente he puesto este 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

en ~/bin/trash , lo convirtió en chmod +x ~/bin/trash , y agregó la siguiente línea a ~/.bash_profile

PATH=$PATH:$HOME/bin

Entonces uno puede usarlo como

$ trash broken.js olddir cleanup.*

Una función simple podría permitirle eliminar los archivos moviéndolos a la carpeta .Trash del usuario:

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