Ускорение работы в терминале

На своей первой айтишной работе я поставил себе целью работать как можно меньше, чтобы по максимуму высвободить время для изучения каких-нибудь интересных материалов, учёбы или хотя бы просмотра видео на ютубе.

Спустя пару лет ютуб я так и не стал смотреть, но зато довольно сильно увеличил свою продуктивность во всех сферах жизни и сократил все рутинные операции на работе, высвободив себе время для изучения нового и всяких творческих экспериментов.

Так что первоначально я записал эти принципы как набор лайфхаков для джунов в своей компании, но в определённый момент понял, что если подойти к ним правильно, то можно довольно здорово повысить продуктивность всего отдела (если они достаточно упороты, чтобы инвестировать в это время, или вы умеете их мотивировать).

Если вам интересно как можно работать меньше без снижения качества работы и вы входите в одну из категорий следующих лиц, то можете читать дальше.

Итак, кому подойдёт эта статья:

• всем, кому приходится много писать (неважно - заполнять таски в задачах, вести документацию или кодить)

• тем, кто преимущественно работает в графической оболочке, но также имеет дело с большим количеством рутинных операций на unix-машинах

• кому приходится много работать в терминале

А также если вам часто приходится:

• копаться в недрах кубернетеса среди логов микросервисов,

• искать нужный файл среди сонма ему подобных в виртуальной файловой системе и вы думаете как это всё можно оптимизировать, чтобы делать быстрее, проще, легче, то эта статья для вас.

Содержание

Введение

Принцип первый: hotkeys

Принцип второй: упрощение команд

Принцип третий: использование алиасов и переменных

Небольшой бонус

Выводы

Для начала проговорим самые основы, так что если вы опытный юзер, это вступление можете пропустить.

Данная статья содержит упор на:

• совместном использование GUI (привычной и интуитивно понятной нам графической оболочки) и

• выполнении команд в терминале (текстовая среда ввода/вывода, позволяющая запускать оболочку и выполнять команды на компьютере).

В качестве оболочки (интерпретатор, позволяющий давать команды ядру операционной системы и получать от него ответы) я буду давать примеры на bash.

Введение. GUI или CLI?

Управлять операционной системой можно двумя способами:

1. через графическую оболочку и

2. через консоль/терминал.

GUI - (Graphical user interface) - та самая графическая оболочка, наиболее известная нам по системе Windows + вспомните любой браузер (окна, кнопки, поля для ввода данных, чекбоксы и т. д.). Клики мышкой и последующие заполнения нужных нам полей - основной способ управления системой.

CLI - (Command-line interface) - интерфейс командной строки - другой вариант взаимодействия человека и компьютера. Ввод текста в терминал/консоль - основной способ общения с системой.

В интернете есть много статей на тему GUI против CLI и так как наша статья немного проходится по ней, я сделаю краткий обзор.

Обычно битва этих титанов (в невыгодном для графики виде) выглядит так:

«Уберите руку с клавиатуры и возьмите мышь, перейдите в панель запуска программ и найдите нужный текстовый редактор. Откройте программу. Щелкните в области редактирования текста. Уберите руку с мыши и введите „Hello World“ в файл. Уберите руку с клавиатуры и возьмите мышь, перейдите к значку или пункту меню, чтобы сохранить файл. Выберите место для его сохранения. Закройте файл.

Теперь, вместо этого, введите Ctrl + Alt + T (или любой другой способ вызвать терминал) и введите:
echo 'Hello World' > ~/myfile.txt».

Взято у Джейсона Престона с одного из блогов (к сожалению, потерял ссылку).

Это довольно наглядный пример того, насколько быстрее простейшие операции можно выполнять в терминале. Разберём преимущества терминала чуть более подробно.

Преимущества CLI

1. Больше возможностей + скорость.
   
   В графическом интерфейсе вы ограничены дизайном программиста (вы можете выполнять только те функции, иконки которых найдёте + всякий раз их ещё разглядеть нужно).
   
   CLI же всегда содержит куда более всеобъемлющий набор команд, чем GUI, и перед тем как возможность выполнить команду появится в графическом интерфейсе, она всегда сначала будет реализована в CLI.
   
   Также, зная нужную команду, вы всегда можете сразу выполнить её в терминале, в то время как в графической оболочке потребуется какое-то время, чтобы найти где находятся нужные вам иконки и кликнуть по ним.

   Сравните сами что быстрее: зайти, кликая мышкой, в какую-нибудь глубоковложенную папку с логами или просто вбить её путь в консоли? (при условии, что вы его знаете)

2. Меньше нагрузка.
   
   По сути выполнение операций в графической оболочке - это то же самое общение с операционной системой. Просто сюда добавляются дополнительные накладные расходы на графику, которые необходимо визуализировать и иногда обновлять каждые несколько секунд.
   
   (Например, открыть в проводнике папку "Downloads" - это та же программа "cd ~/Downloads", просто со "спецэффектами" и озвучкой).
   
   Эта нагрузка на графику часто занимает больше памяти, чем сама задача.

   В то же время при исполнении команды напрямую в консоли, выполняется только поставленная задача и всё получается быстрее.

3. Автоматизация.
   
   Выполнение повторяющихся задач в GUI зачастую весьма рутинно и удручающе, так как занимает довольно много времени и моральных сил.
   
   В CLI те же задачи всегда можно автоматизировать с помощью скриптов или сторонних программ - в зависимости от цели, которую вы себе ставите.

4. UPD от пользователя siberianlaika
   Однако важно учитывать, что основные преимущества CLI перед GUI не в скорости выполнения операций, поскольку это сильно зависит от поставленной задачи.
   Классический пример преимущества GUI - это редактирование графики, где на перемещение курсора и движение указателем завязано большинство действий.
   В GUI при этом также необходимо задействовать клавиатуру, вводить команды (если это позволяет приложение), что по сути роднит его по способам работы с CLI.

   А вот уникальное для CLI преимущество состоит в легкости воспроизведения команд. Текст легко копируется и редактируется, команды можно вставить, например, в документацию на сайте и оттуда быстро скопировать в терминал для исполнения.
   Сравните руководства по настройке какого-нибудь софта с использованием CLI, где руководство - это по сути набор готовых команд, чередующихся с пояснениями, против руководств для GUI, где те же операции требуют описаний в стиле: "Вот в этом окне нажмите вон ту кнопку справа". Для GUI воспроизведение команд требует больше усилий.

   Так что область эффективного применения CLI это скорее управление компьютером, его администрирование.
   Имхо, тут долго еще CLI и текстовые конфиги, которые можно открыть в редакторе и поправить вручную, будут вне конкуренции, по сравнению с конфигами в виде оконных форм с флажками-опциями и отдельными полями ввода.

Важно! При этом я не утверждаю что нужно пользоваться только терминалом.
Есть вещи, которые проще и быстрее сделать через GUI (например, взятие скриншотов).
Но раз уж по долгу работы нам приходится трудиться в терминале, то я предлагаю делать это быстро, профессионально и с минимумом усилий, вспоминая древнюю истину:

"Хороший системный администратор - это ленивый системный администратор".

Тезис:
Большинство операций, которые выполняются с помощью мыши могут быть сделаны без неё, быстрее и проще, а иногда их и вовсе можно автоматизировать.

Если вы работаете на unix-машине, то учитывайте, что изначально она затачивалась на чистую работу с консолью, а значит вы можете значительно ускорить свою работу, просто запомнив и начав применять некоторые трюки по работе с CLI (и не только).
Вот они:

Hotkeys

Это комбинации клавиш, нажимая на которые вы совершаете определённые операции в системе.

Они позволяют нам выполнять действия без необходимости использовать мышь или навигацию по меню и представляют собой один из самых простых, удобных и эффективных способов повысить производительность и скорость работы.

Hotkeys бывают разных видов, мы рассмотрим три из них:

• Хоткеи DE (Desktop Environment)
  Всё то, что вы используете в графической оболочке для ускорения своей работы (например, Ctrl + W (для закрытия активной вкладки в бразуере), Alt + F4, Ctrl + Alt + Delete и т. д.)

• Хоткеи терминального эмулятора
  Комбинации клавиш, ускоряющие работу в терминале

• Текстовые хоткеи
  Горячие клавиши, значительно ускоряющие работу в любых текстовых полях, будь то сообщение в мессенджере, вк, блокноте или любом другом графическом поле для ввода текста.

Hotkeys

Ctrl + Shift + T -> открыть вторую вкладку в терминале.
Ctrl + Page_Up -> переключиться на соседнюю вкладку в терминале (справа).
Ctrl + Page_Down -> переключиться на соседнюю вкладку в терминале (слева).
Те же самые быстрые переключения между вкладками работают в Firefox, Chrome и даже таких программах как Dbeaver:
всё сделано для вашего удобства!

Бывает ли такое, что вам нужно стереть что-то в терминале и написать вместо этого что-нибудь другое?
Если да и для этой цели вы жмёте Backspace несколько секунд, а потом, иногда, удаляете лишнее и, ругаясь начинаете набирать заново, то есть полезные клавиши и на этот случай жизни:
Ctrl + W -> стереть одно слово слева от курсора.
Ctrl + U -> стереть всю строку слева от курсора.
Ctrl + K -> стереть всю строку справа от курсора.
И немного выбивающийся из колеи:
Alt + D -> стереть слово справа от курсора.
Кстати, эти команды не просто удаляют эти символы безвозвратно, они копируют их во внутренний буфер обмена
и следующая комбинация:
Ctrl + Y -> позволяет вставлять их в командную строку обратно (на случай, если вы вдруг ошиблись и стёрли лишнее).
Ctrl + D -> стереть символ под курсором (вот эта команда во внутренний буфер не идёт, но от случайных ошибок
в ней может спасти следующая:)
Ctrl + Shift + '-' или Ctrl + X + U -> просто отменить последние изменения в консоли.
Ctrl + X + E -> копирует всю текущую, набранную в терминале строку, в ваш editor по умолчанию. Помогает в случае, если вам нужно сохранить себе эту команду.
(См. команды editor и sudo update-alternatives --config editor)

Следующие две комбинации хорошо работают в сочетании с клавишами стирания (Ctrl + W, Ctrl + K, etc.):
Ctrl + A -> быстрое перемещение в начало строки. (Довольно просто запомнить - с буквы А начинается алфавит)
Ctrl + E -> быстрое перемещение в конец строки. (Тоже просто - E - End).
Также есть две удобные комбинации, когда используются просто стрелки:
Ctrl + Left - переместиться на одно слово влево.
Ctrl + Right - переместиться на одно слово вправо.
Однажды освоив последние пару хоткеев в терминале, вы обнаружите, что можно применять их в телеграмме, вк и прочих приложениях, где есть поля набора текста. Поверьте, это очень здорово сокращает беготню по текстовым полотнам и опять же удобно применять их с клавишами стирания, чтобы быстро изменить нужную команду (или с зажиманием клавиши Shift, чтобы выделить всё слово сразу (в тг/вк. Не в терминале))
Так же есть две, иногда полезные, комбинации:
Alt + C -> Case upper - заменить стоящую под курсором букву на заглавную.
Alt + L -> lower - заменить стоящую под курсором букву на строчную.
Ctrl + X + X - первое нажатие вернёт вас в начало строки, второе - в то место, где курсор находился изначально.

Также, как подсказывает пользователь CaptainFlint, можно быстро вставлять использованный ранее последний аргумент хоткеем:
<Esc> + <.> или <Alt> + <.>
(Работает если вы не меняли дефолтную привязку клавиш библиотеки Readline с emacs на vim (нет “set -o vi” в .bashrc)
Хорошо подходит для случаев, например, когда вы изначально разведали нужный файл, например:

cat /long/long/long/path

а затем хотите быстро удалить его:
достаточно набрать: rm и зажать <Esc> + <.>, после чего строка в терминале автоматически примет вид:

rm /long/long/long/path

Также есть комбинация "!$", которая хранит последний параметр предыдущей команды.
т. е. того же результата можно достичь, набрав в терминале:

rm !$

но он не отображает автоматически последнего аргумента и исполняет операцию “вслепую”, что может быть неудобно для тех, кому важен визуальный контроль.

Комбинаций существует больше, я привёл основные только чтобы показать насколько может сократиться нудное зажатие клавиш Backspace и стрелок, чтобы скорректировать ошибку в одну букву, написанную в терминале.

Второй элемент в ускорении работы с терминалом - оптимизация набора команд.

Оптимизация написания команд

Как это всё можно оптимизировать?

1-ый пример приведём на kubernetes, но, как я покажу в конце этого блока, данное правило касается довольно многих команд в принципе.

Типичная проверка состояния пода в нэймспейсе (а затем и чтение логов нужного нам микросервиса) выглядят так:

kubectl get po -n my-namespace
kubectl logs my-pod-blablabla-blabla -n my-namespace

И чтобы после первой команды набрать вторую, мы вынуждены либо набирать всю команду заново, либо много раз жать стрелку влево, чтобы добраться до второго и третьего аргумента, затем много раз жать Backspace, чтобы стереть их. И только после этого мы можем дописать нужную нам часть команды.

Увеличить скорость работы в этом примере можно двумя способами:
1-ый способ - проведя перестановку аргументов:
Команды можно записать следующим образом:

kubectl -n my-namespace get po
kubectl -n my-namespace logs my-pod-blablabla-blabla

В данном случае нам уже не нужно возвращаться в середину команды, чтобы стереть нужный участок. Мы жмём стрелку "вверх", чтобы вызвать предыдущую команду и сразу можем жать Backspace, стирая ненужное и записывая нужное.

2-ой способ - использование hotkey.
Можно сразу зажать Ctrl и, дважды нажав "W", стереть последние слова. Или, если вы не оптимизировали порядок аргументов, прыгнуть через несколько слов комбинацией "Ctrl + Left" и переписать нужные аргументы.
Идеально - использовать оба способа:

1. Помните, что у многих команд (начиная с таких как docker, kubectl, java и заканчивая unix-овыми типа find, grep, ls, etc.) порядок аргументов и их значений может идти в случайном порядке.
   (Исключения составляет небольшая группа аргументов, типа "-maxdepth" у find, которые классифицируются как global options и должны помещаться в начале. Но при попытке выполнить команду ошибочно, сама программа вам об этом скажет).

   Так что имеет смысл ставить более общие и редко изменяемые опции в начале, а те, что нужно часто переписывать - в конце.

2. Использовать hotkeys правда важно и правда ускоряет муторные операции категории домотать до нужного места, стереть, переписать, проверить.

2-ой пример:

нам часто нужно искать данные в локальных логах, зачастую команды при этом выглядят так:

grep -C 50 seek_word /opt/srv/logs/srv_important.log

По умолчанию, чтобы что-то изменить в этой команде, нам опять же нужно лезть в середину команды, удалять ненужное, дописывать нужное.

Уже здесь можно довольно быстро ускориться, либо сразу прыгнув в начало консоли "Ctrl + A" и/либо перескочив нужные нам слова "Ctrl + Right | Ctrl + Left".

Но можно переписать всю команду следующим образом:

cat /opt/srv/logs/srv_important.log | grep -C 50 seek_word

Поначалу это может казаться усложнением: мы сперва даём команду прочитать все логи, а затем перенаправляем вывод на grep, но если присмотреться к этому трюку повнимательнее, то мы увидим, что теперь, чтобы переписать ту часть, где мы что-то ищем, нам достаточно вызвать предыдущую команду и один раз нажать "Ctrl + W".

Однако при таком подходе мы всё равно вынуждены либо писать первую команду целиком, либо искать её по истории сообщений командой:

history | grep cat (подробнее про манипуляции с введёнными ранее командами, history и её переменными см., например, rus-linux.net)

Однако есть и другой метод, чтобы избегнуть этой части рутины: просто написать небольшой bash-скрипт.

Если развивать последний пример, то скрипт может выглядеть, например, так:

#!/bin/bash

cat /opt/srv/logs/srv_important.log | grep -C 40 "$1" --color=auto

Пояснения

#!/bin/bash - сообщает системе, что это исполняемый файл для bash.

"$1" - что это первый аргумент после команды, место, куда мы вставляем искомое слово.

--color=auto я дописал, чтобы он подсвечивал красным найденное, потому что по умолчанию скрипты не считывают стандартные alias'ы

Теперь вам достаточно назвать этот скрипт с какой-нибудь уникальной буквы (чтобы после неё можно было сразу добивать tab'ом всё название, в этом примере я назову srv_log.sh), сделать его исполняемым и написать в командной строке

bash s<TAB> seek_word

Всё: перед вами лог и вам не нужно тратить время для набора всей команды или поисков по истории команд.

При желании тот же скрипт можно дополнить, чтобы он искал по нужному вам пути (или написать несколько скриптов, чтобы один смотрел в один источник, другой в другой и так далее. Здесь вас ограничивает только ваша фантазия)

Сокращение команд и длинных аргументов

Если у вас небольшой список серверов, с которыми вы работаете и ваши команды часто выглядят так:

Спойлер

kafkacat -C -b gitlab-ci-sand-awesome.ru:9092 -t sand-confirmed -o beginning
kafkacat -C -b test-gitlab-ci-node-awesome.ru:9092 -t test-confirmed -o beginning
kafkacat -C -b pred-gitlab-ci-node-brilliant.ru:9092 -t pred-confirmed -o beginning
kafkacat -C -b prod-gitlab-ci-node-amazing.ru:9092 -t prod-confirmed -o beginning

или

/opt/kafka/bin/kafka-console-consumer.sh --bootstrap-server 15.83.178.212:9092 --group node-integrator --topic sand-node-response
/opt/kafka/bin/kafka-console-consumer.sh --bootstrap-server 16.84.179.213:9092 --group node-integrator --topic test-node-response
/opt/kafka/bin/kafka-console-consumer.sh --bootstrap-server 17.85.180.214:9092 --group node-integrator --topic pred-node-response

где нужны разные переменные в зависимости от типа окружения/используемых стендов/чего-бы-то-ни-было-ещё, то можно загнать их в alias или в переменные в своём .bashrc
(bash run command - исполняемый файл, который содержит кастомизацию и сокращения для работы в bash-оболочке.)

Как устроены алиасы:

Пример

Команда ll на самом деле в ~/.bashrc выглядит так:
alias ll='ls -alF'

а несколькими строчками выше ls зашифрована как:
alias ls='ls --color=auto'

Поэтому когда вы набираете в терминале ll, bash в этот момент, руководствуясь вшитыми в ~/.bashrc инструкциями, исполняет команду:
ls -alF --color=auto, подсвечивая разными цветами разные типы файлов ради вашего удобства.

Возвращаясь к нашему примеру, мы можем создать свои переменные, дописав их, к примеру, в конец своего .bashrc.
(А лучше - создать отдельный файл .bash_aliases в своей домашней директории и вносить всё в него.
Так, для переноса всех ваших настроек можно просто перекинуть этот файл на нужный хост, сохранить его в гите и т. д. Благодаря тому, что в .bashrc есть строчки:

if [ -f ~/.bash_aliases ]; then
    . ~/.bash_aliases
fi

Модифицированный вами файл с вашими настройками легко интегрируется в любую другую unix-машину. (Если, конечно, она поддерживает bash).
Достаточно внести изменения и перезапустить bash-оболочку).

Возвращаясь к нашему примеру, ваши настройки могут выглядеть так:

export sand='gitlab-ci-sand-awesome.ru:9092'
export test='test-gitlab-ci-node-awesome.ru:9092'
export pred='pred-gitlab-ci-node-brilliant.ru:9092'
export prod='prod-gitlab-ci-node-amazing.ru:9092'

Теперь мы смело можем считывать данные с нужного адреса, используя эти переменные:

kafkacat -C -b $sand -t nameTopic -o beginning
kafkacat -C -b $test -t nameTopic -o beginning
kafkacat -C -b $pred -t nameTopic -o beginning
kafkacat -C -b $prod -t nameTopic -o beginning

($ для bash обозначает, что сразу после этого знака идёт переменная.)

И нам не нужно лезть в values/сторонний файл/куда-либо ещё, где мы храним все эти названия, после чего делать copy-paste в консоль или ещё как-либо тратить своё время на то, чтобы прочитать сообщения из нужного источника.
(Главное перезагрузить оболочку или набрать команду bash, чтобы он заново считал переменные из bashrc).

Что касается alias, их тоже полезно использовать в своей среде.

Рассмотрим следующий случай: допустим вам часто приходится заглядывать в содержимое виртуальной файловой системы по текущей дате.

Для этого нужна команда вроде:
cd /mnt/tmp/nfs/docs/2024-05-30 (день написания данной статьи).

Чтобы каждый раз не вбивать долго и муторно весь этот путь, вы можете вбить его в alias по следующему образцу:

Пример

alias pn='cd /mnt/tmp/nfs/docs/'$(date +%F)' && ls -l'

&& обозначает, что команда после этих символов исполнится только в случае успешного исполнения предыдущей части команды.
Можно заменить её на символ ";".
Он обозначает, что сперва выполняется предыдущая часть команды, а затем, вне зависимости от результата, правая часть команды. (Но тогда, если переход не выполнится, вы просто увидите содержимое текущей папки).
$(date +%F) обозначает, что перед тем, как исполнить этот скрипт, выполняется команда date +%F, которая подставляет вместо себя текущую дату (в моём случае - 2024-05-30).

Так что в итоге я вбиваю в терминале pn, жму Enter, и он переходит в директорию:

/mnt/tmp/nfs/doc/2024-05-30, после чего выполняет команду ll (или, вернее, ls='ls --color=auto' - помним про alias) и я сразу вижу всё содержимое этой директории.

Главное - подобрать понятную для вас мнемонику.
Я, например, pn расшифровываю для себя как path to nfs.

Это - довольно важный момент, поскольку наверняка в вашей команде есть перечень такого рода операций, которые можно стремительно сократить.

Объединиться и коллективно обсудить как можно сделать свою работу проще - довольно хороший план, поскольку тогда вы сможете написать общий файл ~/.bash_aliases и ускорить работу всей команды.

Вы также можете определить наиболее часто используемые алиасы и необходимые сокращения и вписать их в .bash_profile, внедрив этот файл в любую виртуальную машину или хосты, которые разворачиваются, чтобы максимально автоматизировать этот процесс, но это тема не для этой статьи.

Из бонусов: можно настроить автодополнение в кубере таким образом, чтобы вместо kubectl вы вводили только одну букву: k.

1. Для этого нам необходимо выполнить следующую команду:

kubectl completion bash > kub.sh

Затем мы заходим в полученный файл и видоизменяем последние строки:

Спойлер

if [[ $(type -t compopt) = "builtin" ]]; then
    complete -o default -F __start_kubectl kubectl
else
    complete -o default -o nospace -F __start_kubectl kubectl
fi

До следующего вида:

alias k=kubectl

if [[ $(type -t compopt) = "builtin" ]]; then
    complete -o default -F __start_kubectl kubectl
    complete -o default -F __start_kubectl k
else
    complete -o default -o nospace -F __start_kubectl kubectl
    complete -o default -o nospace -F __start_kubectl k
fi

2. Вписываем следующую строку в своём ~/.bashrc:

source ~/kub.sh

(Другой вариант - просто перенести файл kub.sh в /etc/profile.d, если у вас есть такие права.)

3. Перезапустить bash-оболочку

Готово, теперь автодополнение команд: подстановка имён подов и пр. работает, если вы ввели всего одну букву k вместо семи kubectl.

Хитросплетённые команды, о существовании которых нужно знать и периодически подглядывать в них, если они вдруг становятся актуальны, а вы их не помните

Иногда у нас в одной директории находится очень много файлов и прошерстить их все и сразу командой типа grep "something" ./* не представляется возможным.
В такие моменты баш пишет вам что-то вроде:

bash: /usr/bin/grep: Argument list too long

Избежать этого можно с использованием опций крайне полезной команды find, например так:

find . -type f -exec grep "something" {} +

Расшифровка

Здесь find . обозначает, что нужно искать в текущей директории (вместо точки можно задать другой путь)

-type f обозначает, что искать нужно только файлы (f - files)

-exec grep "something" - exec - execute - "выполнить" команду grep с любыми вашими опциями.

В конце обязательно {} + - оно означает, что все найденные командой find файлы будут по одному вставляться в фигурные скобки как аргументы для команды grep в нашем случае.

Соответственно в grep можно вписывать любые свои флаги, например -l - выводить только имена файлов без содержимого.

Если файлов настолько много, что даже такая команда будет выполняться чрезвычайно долго, но при этом вам известно время создания файла, вы можете использовать расширенные флаги команды find, например, следующая команда:

find . -type f -newermt '2024-03-04 17:25:00' ! -newermt '2024-03-04 17:30:00' \
 -exec grep -l "my-awesome-search" {} +

сперва найдёт все файлы, которые изменялись в промежутке с 17:25:00 до 17:30:00 указанной даты, а затем уже применит к ним grep.

Примечание: можно указывать только дату. Подробнее про манипуляции со временем вы можете посмотреть, например, здесь: dmosk.ru

Надеюсь эти трюки облегчат вашу жизнь и позволят уменьшить количество рутины в повседневной работе, ускорить выполнение ежедневных квестов и оставить время для отдыха, глубокомысленных философских мыслей или изучения каких-нибудь других, полезных для вас, ресурсов.

Раздел маленьких бонусов.

В комментариях подсказали классный приём: использование символа "^".

Он очень хорошо работает в тех случаях, когда вам нужно применить предыдущую команду, но видоизменив её по следующему принципу:
^старое_значение^новое_значение
Оболочка ищет в последней команде подстроку "старое_значение" и заменяет его на "новое_значение", после чего исполняет новую команду.
Это может быть полезно как в тех случаях, когда вы совершили опечатку и вам нужно поменять одно слово в длинной команде, так и в случаях, когда команду нужно изменить незначительно. Классический пример, если после команды:

sudo systemctl restart postgres_exporter.service

Вы напишите:
^restart^status^
то будет исполнена команда:

sudo systemctl status postgres_exporter.service

К сожалению, не нашёл официальной документации по этому приёму, поэтому точно не могу сказать где он работает и от какого окружения/оболочек зависит.

Ещё один маленький бонус - пример синтеза лучших качеств от GUI и CLI:

Инструкция

На примере программы flameshot в Ubuntu:

сперва установите её командой:

sudo apt install flameshot

дальше попробуйте ввести в терминале команду flameshot gui
и, обратите внимание, в момент захвата экрана вам сперва дадут подсказки по hot keys
e. g.:

Ctrl + S - save to file,
Ctrl + C - save to clipboard, etc.

При этом вы можете их проигнорировать и сразу начать работать:
выделить нужный участок экрана, разместить на нём стрелки-указатели, выделить что-то, подчеркнуть аккуратными прямыми линиями, ввести текст и т. д.

Однако для полного счастья я предлагаю зайти дальше:

(Дальнейшая инструкция приведена на Ubuntu, настройки вашей ОС могут отличаться)

1. Откройте на своём компьютере Settings, зайдите во вкладку Keyboards и найдите на ней блок Keyboard shortcuts.

2. Выберите в View and customize shortcuts, раздел Screenshots.

3. Отключите текущую настройку Take a screenshot, если она занимает клавишу PrintScreen

4. Зайдите во вкладку custom shortcuts и добавьте новую.

5. Вам предложат ввести её название (я назвал просто - flameshot),
   заполнить поле command - для этого наберите в консоли

which flameshot

(скорее всего у вас будет путь вроде /usr/bin/flameshot)

6. А теперь запишите в поле Command этот путь и добавьте к нему флаг gui (Пример - /usr/bin/flameshot gui).

Всё, теперь осталось только кликнуть на set shortcut и нажать на кнопку PrintScreen, чтобы она установилась, как вызывающая введённую выше команду.

Это хороший пример объединения лучших качеств GUI и CLI.

Выводы

1. Hotkeys сильно упрощают работу
   Исследуйте то окружение, которое вы используете. Оцените можно ли выполнять рутинные операции быстрее и проще.
   На мой взгляд лучше всякий раз осмысливать: "Как я могу сделать это быстрее?" и понемногу включать новые приёмы в свою работу, т. е. относиться к рутинным процессам как к некой практике осознанности или медитации.
   Это позволит потихоньку непрерывно совершенствоваться в скорости работы и получать всё больше удовольствия от процесса.

2. Оптимизируйте написание команд, гуглите их опции, флаги, исследуйте можно ли их автоматизировать и логически упростить.
   Включая элементы исследования в повседневную практику, вы не только способствуете выработке дофамина (улучшая своё психологическое состояние "нейротрансмиттерами радости"), но и расширяете кругозор, растёте как специалист и уменьшаете рутину.

3. Обсудите с командой как можно сократить написание особенно длинных команд и операций с помощью алиасов или переменных.
   Если есть такая возможность - создайте общий .bash_aliases или .bash_profile, куда будут занесены все наиболее часто используемые переменные и иные сокращения команд.
   Это можно использовать в том числе как дополнительный инструмент для адаптации новых сотрудников, и им не придётся выписывать себе куда-то кучу заметок по тому где и что находится.