Материал из Linuxformat.

Ко­манд­ная стро­ка Мень­ше пу­тать­ся с ко­ман­да­ми и ра­бо­тать на 110% эф­фек­тив­нее

Содержание 1 Терминал: ­Мощь инструментов 1.1 За­цик­лим цикл 1.2 Мень­шее — это боль­шее 1.3 В по­ис­ке 1.4 Най­ти ста­рые ко­ман­ды 1.5 Ме­тод пе­ре­бо­ра 1.6 Мно­го­за­дач­ность 1.7 Гра­фи­че­ский тер­ми­на­л – не ок­сю­мо­рон 1.8 Grep – это Бог 1.9 Со­ве­ты про­фес­сио­на­ла 1.10 Управ­ля­ем про­цес­са­ми

Терминал: ­Мощь инструментов

Ес­ли вам пре­тит по­ро­чить свою ре­пу­та­цию свя­зя­ми с гра­фи­че­ским ин­тер­фей­сом, ус­корь­те путь к нир­ва­не при со­дей­ст­вии Бо­ба Мос­са.

К тем, кто от­ва­жит­ся зая­вить, что ра­бо­та­ет в Linux, сра­зу при­ме­ня­ет­ся сте­рео­тип: все ду­ма­ют, что они, за­бив­шись в угол ро­ди­тель­ско­го до­ма, ко­ро­та­ют вре­мя за на­бо­ром непо­нят­ных сим­во­лов на чер­ном эк­ране, с це­лью пе­ре­за­гру­зить Мат­ри­цу или взло­мать за­щи­ту Пен­та­го­на. Но в ре­аль­но­сти лю­ди уже дав­но за­бы­ли эпо­ху команд­ной стро­ки, при­вык­ли к панелям ин­ст­ру­мен­тов, икон­кам и мы­ши и вы­ну­ж­де­ны счи­тать­ся с уз­ко­ло­бо­стью гра­фи­че­­ско­­го ин­тер­фей­са.

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

По­ка вам доста­точ­но бу­дет на­чать с про­стей­ше­го: оп­ре­де­лить пе­ре­мен­ную в команд­ной стро­ке. Это осо­бен­но удоб­но при ра­бо­те с одним и тем же фай­лом, ес­ли вам неохо­та ка­ж­дый раз на­би­рать пол­ный путь к нему в команд­ной стро­ке. К сча­стью, это до­воль­но про­сто:

var=1
var2=false
var3=“/home/$user/file.txt”

Все эти объ­яв­ления пе­ре­мен­ных кор­рект­ны, и тип пе­ре­мен­ной за­да­вать не нуж­но: он оп­ре­де­ля­ет­ся ав­то­ма­ти­че­­ски. Что­бы восполь­зо­вать­ся пе­ре­мен­ной в команд­ной стро­ке, про­сто до­бавь­те пе­ред ее именем знак дол­ла­ра. Ана­ло­гич­но мож­но ис­поль­зо­вать так на­зы­вае­мые «алиа­сы» для час­то ис­поль­зуе­мых команд.

alias la=‘ls -a’
alias pa=‘ps -a’

Не­дос­та­ток обо­их этих ме­то­дов в том, что пе­ре­мен­ные су­ще­ст­ву­ют толь­ко в пре­де­лах од­но­го се­ан­са тер­ми­на­ла. Что­бы они про­жи­ли по­доль­ше, до­бавь­те их в ~/.bash_aliases, а пе­ре­мен­ные мож­но со­хра­нить в ~/.bashrc.

Ес­ли вам ну­жен опе­ра­тор ус­ло­вия, вы бу­де­те ра­ды ус­лы­шать, что для за­да­ния спо­со­ба по­лу­че­ния ре­зуль­та­та мож­но ис­поль­зо­вать вы­ра­же­ния if-else. Вот при­мер:

if uname -a | grep “GNU/Linux” > /dev/null; then echo
“У вас ра­бо­та­ет Linux”;fi

Эта ко­ман­да на­прав­ля­ет по­лу­чен­ную сис­тем­ную ин­фор­ма­цию ко­ман­де grep (что­бы уз­нать о ней под­робнее, см. врез­ку) и от­прав­ля­ет ее ре­зуль­тат в  /dev/null, так что на эк­ран ниче­го не вы­во­дит­ся. Опе­ра­тор усло­вия if оп­ре­де­ля­ет, воз­вра­щен ли ре­зуль­тат от grep, и ес­ли да, вы­во­дит стро­ку «У вас ра­бо­та­ет Linux» в ок­но тер­ми­на­ла. Те­перь мож­но рас­ши­рить эту ко­ман­ду, до­ба­вив вы­ра­жение else как в при­ве­ден­ном ниже при­ме­ре:

if uname -a | grep “GNU/Linux” > /dev/null; then echo “Вы хо­ро­ший че­ло­век”; else echo “Ри­чард Стол­лмен вас не по­лю­бит”; fi

Опе­ра­то­ры if мож­но так­же вкла­ды­вать в вы­ра­же­ния else, по той же схе­ме.

За­цик­лим цикл

Вы мо­же­те спро­сить: за­чем во­об­ще нуж­ны цик­лы в команд­ной стро­ке? Ну, до­пустим, что­бы ско­пи­ро­вать стро­го оп­ре­де­лен­ные фай­лы из од­но­го мес­та в дру­гое на осно­ве кри­те­рия, ко­то­рый со­дер­жит­ся в пе­ре­мен­ной, по­сто­ян­но об­нов­ляе­мой дру­гим про­цес­сом. Впро­чем, бо­лее ве­ро­ят­но бы­ва­ет, что тре­бу­ет­ся рас­па­ко­вать боль­шое ко­ли­че­­ст­во tar-ар­хи­вов. Для это­го при­го­дят­ся цик­лы for или while. Восполь­зу­ем­ся пер­вым ва­ри­ан­том, так как нам необ­хо­ди­мо вы­полнить все ите­ра­ции и пе­рей­ти к дру­гим дей­ст­ви­ям, а не си­деть и ждать со­бы­тия, ко­то­рое нас оста­но­вит:

for i in *.tar.gz; do tar xfs “$i”; done

Са­мая хит­рая часть этой ко­ман­ды – мас­ка для по­ис­ка всех фай­лов с рас­ши­рением tar.gz. За­тем для ка­ж­до­го со­от­вет­ст­вую­ще­го i рас­па­ко­вы­ва­ет­ся со­дер­жи­мое ар­хи­ва. Цикл за­кан­чи­ва­ет­ся по­сле об­ра­бот­ки всех фай­лов, пре­достав­лен­ных ко­ман­дой ls.

Кста­ти, цикл мож­но кон­тро­ли­ро­вать пе­ре­мен­ной, из­ме­няе­мой в дру­гом тер­ми­на­ле (на­при­мер, на­до сде­лать что-то сра­зу по за­вер­шении сбор­ки). За­пусти­те в од­ном тер­ми­на­ле та­кую ко­ман­ду:

while(checkVar); do sleep 1; echo “ждем…”; done

Она бу­дет ожи­дать, по­ка зна­чение пе­ре­мен­ной checkVar не из­менит­ся на false, а до тех пор бу­дет раз в се­кун­ду вы­во­дить в ок­но тер­ми­на­ла со­об­щение “ждем…”. Ес­ли вам когда-нибудь по­на­до­бить­ся вве­сти ко­ман­ду дли­ной бо­лее од­ной стро­ки, про­сто на­бе­ри­те \ и на­жми­те Enter. Сле­ва поя­вит­ся сим­вол >, и вы смо­же­те на­би­рать ко­ман­ду даль­ше.

Те­перь, нау­чив­шись ра­бо­тать с фай­ла­ми, по­ра на­чать счи­ты­вать из них и за­пи­сы­вать в них дан­ные. Од­на из са­мых важ­ных ко­манд в ва­шем ар­се­на­ле – less. В Ин­тер­не­те име­ют­ся ру­ко­во­дства, со­ве­тую­щие ис­поль­зо­вать ее так:

cat ~/myFile.txt | less

Не верь­те им! То­го же са­мо­го (при этом по-преж­не­му мож­но бу­дет про­кру­чи­вать файл кла­ви­ша­ми управ­ле­ния кур­со­ром) мож­но до­бить­ся ко­ман­дой

less ~/myFile.txt

Мень­шее — это боль­шее

У less на диво мно­го па­ра­мет­ров, спо­соб­ных вам при­го­дить­ся. На­при­мер, ес­ли у вас ошиб­ки в ка­ких-то стро­ках, пе­ре­дай­те ко­ман­де па­ра­метр -N, и она по­ка­жет но­ме­ра строк. Ес­ли вам нуж­на до­пол­ни­тель­ная ин­фор­ма­ция (имя фай­ла, сме­ще­ние от на­ча­ла фай­ла в про­цен­тах и т. д.), вос­поль­зуй­тесь вме­сто не­го клю­чом -M.

Кро­ме то­го, с по­мо­щью less мож­но от­кры­вать бо­лее од­но­го фай­ла, та­ким об­ра­зом:

less file1.txt file2.txt

С по­мо­щью :n и :p («сле­дую­щий» и «пре­ды­ду­щий», со­от­вет­ст­вен­но) мож­но пе­ре­клю­чать­ся ме­ж­ду дву­мя фай­ла­ми. Ес­ли не­об­хо­ди­мо от­крыть еще один файл, не за­кры­вая два уже от­кры­тых, на­бе­ри­те :e и имя фай­ла. Что­бы за­крыть те­ку­щий файл, на­бе­ри­те :d.

Од­на­ко са­мая ин­те­рес­ная воз­мож­ность less – это вос­кли­ца­тель­ный знак !. На­бе­ри­те его вме­сте с ко­ман­дой, и less ис­чез­нет; бу­дет за­пу­ще­на ко­ман­да, а за­тем less поя­вит­ся сно­ва. Это удоб­но для ре­ше­ния не­сколь­ких за­дач од­но­вре­мен­но, но еще удоб­нее, ес­ли ис­поль­зо­вать % для ссыл­ки на те­ку­щий файл. Та­ким об­ра­зом, дос­та­точ­но на­брать

!ls $home >> %

и ре­зуль­тат вы­пол­не­ния ко­ман­ды ls до­ба­вит­ся пря­мо в файл, ко­то­рый вы про­смат­ри­вае­те. При воз­вра­ще­нии в less бу­фер об­но­вит­ся, и вы смо­же­те про­дол­жать ра­бо­ту как обыч­но.

Ко­гда-ни­будь про­сто­го про­смот­ра тек­сто­вых фай­лов ста­нет не­дос­та­точ­но, и вы столк­не­тесь с не­об­хо­ди­мо­стью срав­нить со­дер­жи­мое двух фай­лов на на­ли­чие из­ме­не­ний. Это осо­бен­но удоб­но для раз­ра­бот­чи­ков ПО, у ко­то­рых есть не­сколь­ко ра­бо­чих ко­пий ис­ход­но­го ко­да, но мо­жет при­го­дить­ся и при ра­бо­те с ре­зерв­ны­ми ко­пия­ми. Ес­ли вы хо­ти­те про­сто вы­вес­ти раз­ли­чия в ок­но тер­ми­на­ла, вы­пол­ни­те эту ко­ман­ду:

diff file1.txt file2.txt

Это са­мо по се­бе ин­те­рес­но, но не слиш­ком по­лез­но. А ес­ли мы за­хо­тим при­ме­нить раз­ли­чия ме­ж­ду дву­мя фай­ла­ми к file1? Мы запишем их в файл, а за­тем «за­ла­та­ем» (patch) файл с по­мо­щью сле­дую­щих ко­манд:

diff -u file1.txt file2.txt >> changes.diff
patch changes.diff

Ключ -u га­ран­ти­ру­ет, что раз­ли­чия вы­во­дят­ся в стан­дарт­ном фор­ма­те diff, а ес­ли тек­сто­вые фай­лы на­хо­дят­ся в под­ка­та­ло­гах те­ку­ще­го ка­та­ло­га, до­бавь­те к ко­ман­де patch ключ -R.

В по­ис­ке

По­след­няя важ­ная ути­ли­та, по­сле ос­вое­ния ко­то­рой, вы, ве­ро­ят­но, пре­вра­ти­тесь из но­вич­ка в мас­те­ра – ко­ман­да find.

Пер­вое, что нуж­но уяс­нить – ко­ман­да от­нюдь не оче­вид­на. Не во­об­ра­жай­те, что на­брав ‘find this’ или ‘find that’, вы уви­ди­те ре­зуль­тат. К со­жа­ле­нию, у раз­ра­бот­чи­ков бы­ли дру­гие пла­ны, и они на­ме­рен­но ус­лож­ни­ли ко­ман­ду, для га­ран­тии, что­б вы про­чли до­ку­мен­та­цию, над ко­то­рой они кор­пе­ли, пре­неб­ре­гая лич­ной жиз­нью… ве­ро­ят­но. Как бы то ни бы­ло, кри­вая ее обу­че­ния кру­тая, и мы пре­одо­ле­ем ее за не­сколь­ко ша­гов.

Вот про­стей­ший из ва­ри­антов ко­ман­ды find, который может вам встретиться

find .

Впе­чат­ля­ет? Эта ма­лень­кая ко­ман­да вы­во­дит спи­сок всех фай­лов в ва­шем до­маш­нем ка­та­ло­ге. Но мы яв­но хо­тим боль­ше­го: на­при­мер, най­ти фай­лы с оп­ре­де­лен­ным име­нем. Для это­го вос­поль­зу­ем­ся ко­ман­дой

find . -name=“* a”

Эта ко­ман­да на­хо­дит все фай­лы в те­ку­щем ка­та­ло­ге, име­на ко­то­рых со­дер­жат ‘a’. Мож­но ис­кать фай­лы и по раз­ме­ру, ис­поль­зуя -size +10k для фай­лов, раз­мер ко­то­рых боль­ше 10 КБ, или -size -10M для фай­лов, раз­мер ко­то­рых мень­ше 10 МБ. Для по­ис­ка фай­лов оп­ре­де­лен­но­го вла­дель­ца вос­поль­зуй­тесь па­ра­мет­ром -user, на­при­мер, -user bob, а для по­ис­ка ре­зуль­та­тов, не со­от­вет­ст­вую­щих кри­те­рию – па­ра­мет­ром -not. Те­перь до­ба­вим все это в при­ве­ден­ную ра­нее ко­ман­ду:

find . -name=”* tex” -size +1M -user bob
find . -not -name=”* tex” -size +1M -not -user bob

Пер­вая ко­ман­да на­хо­дит все фай­лы, в име­ни ко­то­рых со­дер­жит­ся tex, с раз­ме­ром боль­ше 1 МБ и вла­дель­цем bob. Вто­рая ко­ман­да (бла­го­да­ря уме­ло рас­став­лен­ным not) най­дет все фай­лы, в име­ни ко­то­рых не со­дер­жит­ся tex, с раз­ме­ром боль­ше 1 МБ и вла­дель­цем ко­то­рых не яв­ля­ет­ся поль­зо­ва­тель bob. Мож­но по­ста­вить да­же двой­ное от­ри­ца­ние (-not -not), но, по­нят­ное де­ло, раз­ве что для соб­ст­вен­но­го раз­вле­че­ния.

И, на­ко­нец, па­ра­метр -newer, бла­го­да­ря ко­то­ро­му мы най­дем фай­лы, бо­лее но­вые по срав­не­нию с за­дан­ным. Эта воз­мож­ность осо­бен­но при­го­дит­ся сис­тем­ным ад­ми­ни­ст­ра­то­рам (или лю­бо­пыт­ной Вар­ва­ре), же­лаю­щим уз­нать, что за фай­лы поль­зо­ва­тель соз­дал в не­ком ка­та­ло­ге. Для это­го ско­ман­дуй­те

find . -newer /path/to/file

Най­ти ста­рые ко­ман­ды

Мы крат­ко упо­мя­ну­ли о том, что с по­мо­щью кла­ви­ши Tab мож­но ав­то­ма­ти­че­ски до­пол­нять ко­ман­ды, а «стрел­кой вверх» про­смат­ри­вать пре­ды­ду­щие ко­ман­ды, но на­блю­да­тель­ные поль­зо­ва­те­ли за­ме­тят, что ес­ли про­дол­жать на­жи­мать «стрел­ку вверх», мож­но уви­деть все ко­ман­ды, на­бран­ные вче­ра, по­за­в­че­ра и на всей про­шлой не­де­ле: Bash со­хра­ня­ет все ко­ман­ды, ко­то­рые вы наза­пус­ка­ли в про­шлом, и с этой до­пол­ни­тель­ной воз­мож­но­стью вы ста­не­те нинд­зя ко­манд­ной стро­ки.

Что­бы най­ти ко­ман­ду, вы­пол­нен­ную ра­нее, вос­поль­зуй­тесь сим­во­лом !. Про­сто на­бе­ри­те его по­сле не­сколь­ких сим­во­лов ис­ко­мой ко­ман­ды. На­при­мер, ко­ман­ду:

mkdir /etc/init.d/random_folder

мож­но вы­звать сно­ва с по­мо­щью

!mk

Об­ласть по­ис­ка мож­но рас­ши­рить, не ог­ра­ни­чи­вая ее толь­ко на­ча­лом ко­ман­ды, с по­мо­щью сим­во­лов !?, и вы­звать пре­ды­ду­щую ко­ман­ду та­ким об­ра­зом:

!?dom

Как ви­ди­те, здесь для за­пус­ка по­след­ней ко­ман­ды мы упот­ре­би­ли “dom” из “random”.

Хо­тя этот при­ем удо­бен, его не сле­ду­ет при­ме­нять с раз­ру­ши­тель­ны­ми ко­ман­да­ми вро­де rm, так как ко­ман­да не толь­ко на­хо­дит­ся, но и не­мед­лен­но вы­пол­ня­ет­ся, и ес­ли вы со­вер­ши­те ро­ко­вую ошиб­ку, ос­та­но­вить обо­лоч­ку не уда­ст­ся!

Од­на­ко мы не все­гда мо­жем пред­ви­деть, что про­изой­дет при вы­пол­не­нии ко­манд с по­мо­щью этих ма­лень­ких трю­ков. Для это­го нуж­но уг­лу­бить­ся в ис­то­рию ко­манд Bash. Для на­ча­ла на­жми­те Ctrl+R – это пе­ре­ве­дет Bash в ре­жим по­ис­ка по ис­то­рии ко­манд. По ме­ре на­бо­ра ко­ман­ды бу­дут по­яв­лять­ся ве­ро­ят­ные ва­ри­ан­ты, по­ка не возникнет ко­ман­да, ко­то­рая вам нуж­на. Ко­гда это про­изой­дет, ли­бо на­жми­те Enter и не­мед­лен­но вы­пол­ни­те ко­ман­ду, ли­бо на­ж­ми­те Esc, что­бы вы­брать ко­ман­ду из ис­то­рии и про­дол­жить ее ре­дак­ти­ро­ва­ние. Это осо­бен­но удоб­но, ес­ли вы по­тра­ти­ли не­сколь­ко ча­сов на ис­прав­ле­ние ошиб­ки, вы­зван­ной не­ко­то­рой ко­ман­дой, и те­перь хо­ти­те соз­дать пра­виль­ную вер­сию этой ко­ман­ды…

Ме­тод пе­ре­бо­ра

Ес­ли вы точ­но не знае­те, ка­кая ко­ман­да вам нуж­на, но ощу­щае­те де­жа-вю по по­во­ду про­бле­мы, ко­то­рую вы пы­тае­тесь ре­шить, вы­тя­ни­те всю ис­то­рию ко­манд и за­тем вы­пол­ни­те кон­крет­ную ко­ман­ду от­ту­да. Сна­ча­ла вы­ве­дем все ко­ман­ды в па­мя­ти с их ID-но­ме­ра­ми с по­мо­щью сле­дую­щей ко­ман­ды:

history | grep -i “ку­сок_ко­ман­ды”

Здесь ку­сок_ко­ман­ды – кри­те­рий по­ис­ка. Найдя нуж­ную ко­ман­ду, про­сто на­бе­ри­те

!n

где n – но­мер ко­ман­ды в ис­то­рии.

И по­след­нее за­ме­ча­ние. По вы­пол­не­нии вы­бран­ной ко­ман­ды она ста­но­вит­ся ва­шей по­след­ней ко­ман­дой, а зна­чит, по­след­ней ко­ман­дой в ис­то­рии Bash. Это сто­ит пом­нить, так как по­пыт­ка вы­пол­нить од­ну и ту же ко­ман­ду из пре­дыс­то­рии мо­жет при­вес­ти к очень стран­ным ре­зуль­та­там, по­то­му что свя­зан­ное с ней со­дер­жи­мое бу­дет ме­нять­ся с ка­ж­дым за­пус­ком!

Мно­го­за­дач­ность

Когда вы пе­ре­клю­чи­те свою обо­лоч­ку в ре­жим пол­но­го эк­ра­на, вам мо­жет по­ка­зать­ся, что вы вер­ну­лись во вре­ме­на Тэт­че­риз­ма и «Смитс», по­то­му что с ви­ду мож­но ра­бо­тать толь­ко с од­ной за­да­чей в один мо­мент вре­мени.

Вы бу­де­те ра­ды уз­нать, что на са­мом де­ле это не так. Как и в боль­шин­ст­ве вер­сий Unix, ком­би­на­ция кла­виш Ctrl+Alt+F1...F6 про­ве­дет вас по вир­ту­аль­ным тер­ми­на­лам и гра­фи­че­­ской сре­де. Это оз­на­ча­ет, что в один мо­мент вре­мени мож­но вы­пол­нять несколь­ко за­дач и в слу­чае за­ви­си­мо­сти од­ной ко­ман­ды от ре­зуль­та­та дру­гой поль­зо­вать­ся ко­ман­дой watch, опи­сан­ной да­лее в этой ста­тье.

При­чи­на, по ко­то­рой ваш ра­бо­чий стол (на­при­мер) на­хо­дит­ся в од­ном из этих вир­ту­аль­ных тер­ми­на­лов – в том, что X-сер­вер вы­пол­ня­ет­ся в од­ном из них, а ес­ли бы мно­го­за­дач­ность не под­дер­жи­ва­лась, вы бы смог­ли за­пустить толь­ко ра­бо­чий стол и ниче­го боль­ше!

Гра­фи­че­ский тер­ми­на­л – не ок­сю­мо­рон

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

На­при­мер, на­жа­тие Tab по­сле на­бо­ра не­сколь­ких букв име­ни фай­ла или ко­ман­ды за­вер­шит стро­ку, ко­то­рую в про­тив­ном слу­чае при­шлось бы на­би­рать пол­но­стью. А с по­мо­щью кла­ви­ши «стрел­ка вверх» мож­но пе­ре­ме­щать­ся по пре­ды­ду­щим ко­ман­дам, не на­би­рая их сно­ва.

Ес­ли вы поль­зуе­тесь Konsole, мож­но на­стро­ить ус­та­нов­ку на сле­же­ние за ак­тив­но­стью дру­гих тер­ми­на­лов (на­при­мер, ожи­дать за­вер­ше­ния дол­гой за­да­чи сбор­ки) с по­мо­щью ко­ман­ды watch. И, ко­неч­но, мож­но от­крыть не­сколь­ко вкла­док с вир­ту­аль­ны­ми тер­ми­на­ла­ми, вме­сто то­го что­бы по­сто­ян­но пе­ре­клю­чать­ся из гра­фи­че­ско­го ок­ру­же­ния в тек­сто­вые эк­ра­ны.

Grep – это Бог

Grep – мощ­ней­шая ко­ман­да по­ис­ка, хо­тя боль­шин­ст­во поль­зо­ва­те­лей Linux не поль­зу­ют­ся ею ре­гу­ляр­но. Обыч­но ко­ман­ды, ко­то­рые вам, воз­мож­но, уже по­па­да­лись, вклю­ча­ют не­что по­доб­ное та­кой про­стей­шей ко­ман­де grep:

grep “dogs” *

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

• -c По­счи­тать чис­ло со­от­вет­ст­вий в фай­ле.
• -i Сде­лать по­иск не­чув­ст­ви­тель­ным к ре­ги­ст­ру.
• -l Вы­вес­ти име­на фай­лов с со­от­вет­ст­вия­ми.
• -n Вы­вес­ти но­мер стро­ки со­от­вет­ст­вия.
• -r Ре­кур­сив­но об­ра­ба­ты­вать под­ка­та­ло­ги.
• -v По­ка­зать со­дер­жи­мое, не со­от­вет­ст­вую­щее кри­те­рию по­ис­ка.

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

grep -ilrv “dogs” *

Ко­ман­ды grep мож­но со­еди­нять че­рез ка­нал; за­пус­тим при­ве­ден­ную вы­ше ко­ман­ду сно­ва, но из­ме­ним ее так, что­бы вклю­ча­лись толь­ко фай­лы, со­от­вет­ст­вую­щие кри­те­рию. Од­на­ко ис­клю­чим все фай­лы с рас­ши­ре­ни­ем .log:

grep -ilr “dogs” * | grep -cv “\.log$”

Об­ра­ти­те вни­ма­ние на об­рат­ный слэш в па­ра­мет­ре вто­рой ко­ман­ды: он не­об­хо­дим для эк­ра­ни­ро­ва­ния точ­ки и зна­ка дол­ла­ра, что­бы они не ин­тер­пре­ти­ро­ва­лись как сим­во­лы мас­ки и об­ра­ба­ты­ва­лись бы толь­ко фай­лы, за­кан­чи­ваю­щие­ся рас­ши­ре­ни­ем .log. Впро­чем, File.log.bin не по­дой­дет. В кон­це ко­ман­ды ре­ко­мен­ду­ет­ся при­ста­вить па­ра­метр -color, под­кра­сив ре­зуль­тат, что­бы он вы­де­лял­ся на фо­не боль­шо­го объ­е­ма вы­во­да; да и для глаз это при­ят­нее, чем мо­но­хром.

Со­ве­ты про­фес­сио­на­ла

Ес­ли вы освои­лись в команд­ной стро­ке и уже хо­ти­те пры­гать че­рез несколь­ко ша­гов, то бу­де­те ра­ды уз­нать, что мож­но про­из­ве­сти кое-ка­кие со­кра­щения. На­при­мер, в сис­те­мах, при­ме­няю­щих sudo, мож­но, на­брав ко­ман­ду, нар­вать­ся на со­об­щение «x тре­бу­ет прав досту­па root» вме­сто же­лае­мо­го ре­зуль­та­та. Что­бы не пе­ре­на­би­рать всю стро­ку или ис­поль­зо­вать кла­ви­ши up+home и до­пи­сы­вать sudo, восполь­зуйте­сь вза­мен сле­дую­щей ко­ман­дой, ко­то­рая по­вто­рит пре­ды­ду­щую ко­ман­ду с пра­ва­ми досту­па root:

sudo !!

Так­же имеется со­че­тание кла­виш «Ме­та» + «.». Ме­та-кла­ви­ша в Bash – Esc (хо­тя иногда она по­ме­ща­ет­ся спра­ва от кла­ви­ши про­бе­ла), и по на­жа­тию этой ком­би­на­ции кла­виш по­следний ар­гу­мент пре­ды­ду­щей ко­ман­ды встав­ит­ся в ко­нец на­би­раемой стро­ки. Это осо­бен­но удоб­но, на­при­мер, ес­ли вы пе­ре­мес­ти­ли тек­сто­вый файл в ка­та­лог и по­том за­хо­те­ли до­ба­вить ту­да текст. На­жа­тие этой ком­би­на­ции сра­зу по­сле на­бо­ра ко­ман­ды

echo “appended text” >>

ско­пи­ру­ет файл на­зна­че­ния в ко­нец ва­шей ко­ман­ды.

Управ­ля­ем про­цес­са­ми

Наискорейший спо­соб най­ти «по­жи­ра­те­лей ре­сур­сов» в ва­шей сис­те­ме – на­брать top в окне тер­ми­на­ла и на­жать Enter. Это од­на из пер­вых команд, ко­то­рая рас­смат­ри­ва­ет­ся в ру­ко­во­дствах по команд­ной стро­ке Unix; она пре­достав­ля­ет большой объем ин­фор­ма­ции, но с по­мо­щью оп­ре­де­лен­ных со­че­таний кла­виш мож­но от­се­ять лишнее и про­смот­реть важ­ную ин­фор­ма­цию.

Са­мые важ­ные столб­цы: PID (иден­ти­фи­ка­тор про­цес­са); USER (поль­зо­ва­тель, от имени ко­то­ро­го вы­пол­ня­ет­ся про­цесс); NI (зна­чение па­ра­мет­ра nice), управ­ля­ющее тем, как лег­ко про­цесс раз­де­ля­ет ре­сур­сы; и ко­ман­да, с ко­то­рой он свя­зан. Все столб­цы, по­ме­чен­ные звез­доч­кой, не обя­за­тель­ны – про­сто на­жми­те на кла­виа­ту­ре кла­ви­шу с бу­к­вой, ко­то­рую вы ви­ди­те сле­ва от стро­ки, и со­от­вет­ст­вую­щий стол­бец бу­дет по­ка­зан или скрыт.

На­жав Shift+F, вы смо­же­те вы­брать стол­бец, по ко­то­ро­му сор­ти­ро­вать дан­ные. Ря­дом с ка­ж­дым столб­цом есть бу­к­вы – про­сто на­жми­те со­от­вет­ст­вую­щую кла­ви­шу. Те­перь, ви­дя все дан­ные, мо­же­те на­жать K и до­ба­вить иден­ти­фи­ка­тор про­цес­са, что­бы убить кон­крет­ный про­цесс. Это го­раз­до про­ще, чем на­би­рать kill 0100 пол­но­стью (здесь ‘0100’' – иден­ти­фи­ка­тор про­цес­са, ко­то­рый вы хо­ти­те убить), так как при­дет­ся ли­бо за­кры­вать top, ли­бо за­пускать ко­ман­ду в дру­гом вир­ту­аль­ном тер­ми­на­ле. Ес­ли вы хо­ти­те по­вы­сить при­ори­тет про­цес­са, на­жми­те R (re-nice) и вве­ди­те иден­ти­фи­ка­тор про­цес­са точ­но так же, как с K; но в этом слу­чае вы уви­ди­те, как снизит­ся зна­чение па­ра­мет­ра nice, по­ка­зав, что ве­ро­ят­ность ото­брать ис­поль­зуе­мые этой за­да­чей ре­сур­сы умень­ши­лась.