Журнал LinuxFormat - перейти на главную

LXF141:Shell

Материал из Linuxformat
Перейти к: навигация, поиск
Подписка на печатную версию
Весь 2015 год (12 номеров)
Первое полугодие (6 номеров)
Второе полугодие (6 номеров)
Подписка на электронную версию
Весь 2015 год (12 номеров)
Первое полугодие (6 номеров)
Второе полугодие (6 номеров)
Подшивки старых номеров журнала (печатные версии)
Весь 2014 год (12 номеров)
Первое полугодие (6 номеров)
Второе полугодие (6 номеров)
Ко­манд­ная стро­ка Мень­ше пу­тать­ся с ко­ман­да­ми и ра­бо­тать на 110% эф­фек­тив­нее

Содержание

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

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


К тем, кто от­ва­жит­ся зая­вить, что ра­бо­та­ет в 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, по­ка­зав, что ве­ро­ят­ность ото­брать ис­поль­зуе­мые этой за­да­чей ре­сур­сы умень­ши­лась.

Источник — «http://wiki.linuxformat.ru/wiki/index.php?title=LXF141:Shell&oldid=13673»
Персональные инструменты
купить
подписаться
Яндекс.Метрика