Najlepszy sposób na skrócenie opcji poleceń w * nix

Jaki byłby najlepszy sposób w * nix (alias, skrypt itp.), Aby skrócić dostępne opcje dla polecenia, które nie zapewnia krótkiej formy?

Pomysł polegałby na tym, że w jakiś sposób można zawinąć polecenie, aby móc skrócić tylko pierwszą opcję. Pozwala to również na użycie oryginalnych.

Zwykłe polecenie:

 > command option1 file.txt
 > command option2 file.txt

Korzystanie z opakowania:

> command o1 file.txt
> command o2 file.txt

Oto pseudokod przedstawiający możliwe rozwiązanie, które przyszło mi do głowy, używając skryptu powłoki o tej samej nazwie polecenia i umieszczając go na pierwszym miejscu w ścieżce PATH.

 if $first_argument == "o1"
    call <command> option1 $additional_arguments
 else if $first_argument == "o2"
    call <command> option2 $additional_arguments
 else
    call <command> $first_argument $additional_arguments

Czy to byłoby możliwe?

Możesz tworzyć aliasy w swoim pliku ~ / .bashrc. Na przykład utworzenie 7-zipowego archiwum folderu, którym zwykle byłby

7z a -m0=lzma2 -mx=9 -ms=on -mf=on -mtc=on archive_name.7z folder_name

w swoim ~ / .bashrc wstaw:

alias 7zipfolder='7z a -m0=lzma2 -mx=9 -ms=on -mf=on -mtc=on'

Potem możesz po prostu zrobić,

7zipfolder archive_name.7z folder_name

Musisz się wylogować i zalogować ponownie, aby zadziałało, lub wykonaj source ~ / .bashrc

HTH :)

==== EDYCJA: Biorąc pod uwagę poniższe odpowiedzi, cóż, myślę, że możesz to zrobić, jeśli zmodyfikujesz PATH, aby najpierw przeglądać osobiste foldery skryptów, takie jak

ŚCIEŻKA = ~ /. Krótkie polecenia: $ ŚCIEŻKA

Następnie możesz utworzyć skrypty o tych samych nazwach, które są zainstalowane w np. / Usr / sbin, zapętlić wszystkie argumenty, rozwinąć te, które chcesz, a następnie zakończyć wywoływanie „prawdziwego” skryptu / aplikacji w jego ścieżka bezwzględna z przetłumaczonym zestawem opcji.

Na przykład

  7z --folder Documents.7z Documents/

połączenia

  ~/.shortcommands/7z

co przekłada się na:

  /usr/bin/7z a -m0=lzma2 -mx=9 -ms=on -mf=on -mtc=on Documents.7z Documents/

Sam skrypt będzie iterował listę argumentów, a następnie przetłumaczyłby, co ma sens dla twoich potrzeb. Prawdopodobnie byłbyś daleko od możliwości stworzenia „powłoki” na podstawie oryginalnego polecenia, ale oczywiście nie tego szukasz. Nie jestem pewien, czy jesteś biegły w skryptach bash, ale jest tam mnóstwo bardzo dobrych zasobów. Aby służyć jako przykład dla iteracji argumentów, oto fragment skryptu, nad którym obecnie pracuję, który tworzy / sprawdza dane parzystości i pliki sum kontrolnych dla innych plików:

# Iterate arguments while shifting off those meant for us, leaving behind files to process.
# No clue how to directly index on the arguments array, so I copy it:
args=("$@")
files=()
files_count=0

# Then we iterate over each argument, collecting anything that's for us, and adding files
# to our files array, making sure to get absolute paths should we somehow get relative ones
# (e.g. from Nautilus or the commandline):
for ((i=0; $i<$#; i++)); do
        argument=${args[$i]}
        # How deep to go into FILE before starting to create/check protection files:
        if [ "$argument" = "-d" -o "$argument" = "--depth" ]; then
                # Seek to the next argument, i.e. the value:
                let "i=i+1"
                # We'll get an error if we try to just grab the next argument and it isn't there:
                if [ $i -eq $# ]; then
                        print_argument_error "${args[$i-1]} needs a value."
                else
                        target_depth="${args[$i]}"
                        # Okay, so is the value sane?
                        if [[ ! $target_depth =~ ^[1-9][0-9]{0,}$ ]]; then
                                print_argument_error "${args[$i-1]} must be 1 or higher."
                        fi
                fi
        # Whether or not to include output from our client commands, too:
        elif [ "$argument" = "-v" -o "$argument" = "--verbose" ]; then
                print_client_output=1
        # Whether or not to verify files:
        elif [ "$argument" = "-V" -o "$argument" = "--verify" ]; then
                check=1
        # Whether or not to create validation files:
        elif [ "$argument" = "-C" -o "$argument" = "--create" ]; then
                verify=1
        # Whether or not to repair files when possible:
        elif [ "$argument" = "-R" -o "$argument" = "--repair" ]; then
                verify=1
                repair=1
        # That's all the arguments we understand, the rest must be files:
        else
                # So we assume anything but an option is an input file or dir. Get the item:
                item="$argument"

                # If it's a file, we get its directory location and convert it to absolute,
                # then prepend the file name back onto that before pushing it onto our files
                # array. If it's a dir, we just convert it to absolute before pushing it:
                if [ -f "$item" ]; then
                        dir="`dirname "$item"`"
                        files[${files_count}]="`cd "$dir"; pwd`/`basename "$item"`"
                        let "files_count=files_count+1"
                elif [ -d "$item" ]; then
                        files[${files_count}]="`cd "$item"; pwd`"
                        let "files_count=files_count+1"
                fi
        fi
done

Zależy to częściowo od tego, jak polecenie analizuje opcje. W przypadku programów, które są budowane przy użyciu biblioteki parsowania argumentów popt, wbudowany jest mechanizm aliasingu, w którym można tworzyć opcje aliasów, które rozszerzają się do istniejących opcji, używając pliku rc w katalogu domowym. Niestety, dokumentacja popt nie jest specjalnie skierowana do użytkowników końcowych, ale do programistów chcących skorzystać z biblioteki w swoich programach. Jednak informacje na temat /etc/popti ${HOME}/.poptmożna znaleźć w rozdziale 3 ręcznym stronie poptw opcji aliasingu sekcji.

Dotyczy to oczywiście tylko programów zbudowanych z myślą o użyciu popt. Jak wspomniano powyżej, nie ma uniwersalnego mechanizmu, ponieważ nie ma jednego mechanizmu analizy argumentów używanego przez wszystkie programy. Skrypty i aliasy opakowań są regresem dla programów, w których nie ma dostępnego mechanizmu pop lub podobnego do popt.

Czy ma to ułatwić ich pisanie? Możesz sprawdzić Programowalne zakończenie wiersza poleceń . Może sprawić, że pisanie będzie bardziej wydajne.