Блог о всякой и всяческой ерунде. Xargs: многообразие вариантов использования

В Linux существует очень странная команда xargs , которую весьма любят гуру, но не спешат объяснять как она работает. Интернет завален рецептами "как пользоваться xargs", но ни в одном из них внятно не написано самого главного: что эта команда вообще делает.

Самое главное

В общих чертах везде написано одно и то же: команда xargs принимает входной поток (именно поэтому ее всегда предваряет какая-нибудь команда и символ перенаправления потока "|"), и каким-то волшебным синтаксисом выполняет указанную в ней команду.

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

Да, в этом определении дважды используется понятие "право". Подробности разжовываются чуть ниже. А пока лучше посмотреть на структуру команды xargs в виде картинки. Синтаксически команда xargs состоит как бы из двух частей - левой и правой:

Причем однозначного визуального разделения, где левая, а где правая часть, просто нет. Если вы пытаетесь понять написанную другим человеком команду xargs, эту "границу раздела" нужно уметь находить самостоятельно. Вот несколько примеров:

То есть, здесь действует правило: если после xargs идут символы, предваряемые знаком минус "-" , значит это опции команды xargs . Как только пошли символы без знака минус, значит это уже символы правой части. Но нужно учитывать, что некоторые опции xargs требуют после себя еще каких-то данных, которые не будут предваряться знаком минус (см. пример с опцией -I ).

А теперь самое главное: какую же команду выполняет xargs ? Куда она пихает пачку символов, которую она вычленила во входном потоке? Все просто: она кладет эти символы справа от команды, прописанной в правой части. Понимаю, тут два раза используется понятие "право". Тогда вот картинка, которая все расставляет на свои места:

Возьмем конкретный пример. В каталоге лежат файлы:

main.cpp

main.h

version.cpp

version.h

config.cpp

config.h

data.cpp

data.h

Внутри этого каталога выполняется команда:

$ find . -name "*.cpp" | xargs -n 1 rm -rf

Какие команды сгенерирует xargs? Чтобы ответить на это, нужно понять, что будет подано на ее вход. А на вход будет подан результат работы команды find:

./main.cpp

./version.cpp

./config.cpp

./data.cpp

Команда xargs считает разделителем пробел , табуляцию или перевод строки (и их непрерывные последовательности). Таким образом, в итоге будут выполнены четыре команды:

rm -rf ./main.cpp

rm -rf ./version.cpp

rm -rf ./config.cpp

rm -rf ./data.cpp

Очень важное замечание про волшебную опцию

Есть одно очень важное замечание. Если вы его не осознаете, то не сможете нормально работать с xargs, и уподобитесь авторам статей, которые думают, что понимают как работает xargs, а на самом деле пишут лютую чушь. В вышеприведенном примере не просто так прописана опция "-n 1" .

Опция "-n 1" заставляет xargs выполнять команду для каждого очередного куска из входного потока. Да, понимаю, что это звучит бредово: ведь команда xargs и так должна делать именно это! В конце концов, в мануале написано следующее: "xargs reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and executes the command (default is /bin/echo) one or more times with any initial-arguments followed by items read from standard input." Проблема в том, что по-умолчанию, если не указать "-n 1" , xargs воспринимает весь входящий поток, разбитый пробелами, табами, и переносами строк, как ОДИН аргумент. И по-сути, весь входящий поток просто подставляется в выполняемую команду. Вот так сюрприз от разработчиков!

Вопрос: А как же тогда срабатывают примеры, приводимые в статьях, типа

$ find . -name "*.cpp" | xargs rm -rf

$ find . -name "*.cpp" | xargs wc -l

А срабатывают они просто потому, что сами команды rm , wc и им подобные умеют работать с набором имен файлов. А пользователи ошибочно думают, что это xargs несколько раз вызывает данные команды для каждого имени файла. И чтобы в этом убедиться, можно воспользоваться опцией -t (печать команды, генерируемой xargs , перед ее выполнением). Но чтобы увидеть результат, нужно еще использовать конструкцию перенаправления вывода из потока ошибок 2>&1 (потому что использование опции -t даёт вывод в поток ошибок, а не в стандартную консоль). И вот что можно увидеть.

Если писать команду xargs без опции "-n 1" , то произойдет следующее:

$ find . -name "*.cpp" | xargs -t rm -rf 2>&1

rm -rf ./main.cpp ./version.cpp ./config.cpp ./data.cpp

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

Если же воспользоваться опцией "-n 1" , то картина будет другая:

$ find . -name "*.cpp" | xargs -n 1 -t rm -rf 2>&1

rm -rf ./main.cpp

rm -rf ./version.cpp

rm -rf ./config.cpp

rm -rf ./data.cpp

Здесь поведение именно такое, как и обещалось. Помните об этой опции, и не удивляйтесь, что xargs работает как-то не так, если эту опцию не используете. А еще помните, что во многих статьях в Интернете команды с xargs просто неработоспособны. Авторы думают что знают, какой должен быть результат, и даже не проверяют "очевидное", вследствие чего неподготовленый пользователь, который решит повторить то, что написано в статье, ничего толком не поймет.

Есть еще один тонкий момент. В xargs есть ограничение на длину входного потока. И если входной поток слишком большой, xargs таки разобъет его на два или больше куска, и для каждого куска все-таки вызовет отдельную команду, указанную в правой части. Чтобы таких непредвиденных ситуаций не было, пользуйтесь опцией "-n 1" .

Команда xargs без аргументов

Иногда можно встретить обескураживающую конструкцию, типа:

tr -dc A-Za-z0-9_ < /dev/urandom | head -c 10 | xargs

Данная команда генерирует случайный пароль длиной 10 символов. Но что значит команда xargs без аргументов в конце этой команды?

Ответ прост. Команда xargs без аргументов на самом деле считает, что в ее правой части стоит команда /bin/echo . И пропускает входящий поток через команду echo . Зачем это нужно? В данном примере это нужно просто для того, чтобы итоговый результат завершался символом перевода строки. Вот пример, демонстрирующий разницу между командой, в которой нет xargs и есть xargs :

> tr -dc A-Za-z0-9_ < /dev/urandom | head -c 10

7jk2qx4cX8>

> tr -dc A-Za-z0-9_ < /dev/urandom | head -c 10 | xargs

zSlr2HsbSa

Пробелы в именах файлов

Так как xargs считает разделителями пробелы, табы и переводы строк, то возникает проблема с обработкой имен файлов, содержащих пробельные символы.

Обычно, имена файлов на вход программы xargs подаются из результата работы команды find . И для решения этой проблемы у команды find есть опция "-print0" . Она заменяет перенос строки на нуль-символ \x0 . А у команды xargs есть опция "-0" (минус ноль), с помощью которой входной поток разбивается на части, разделенные символом \x0 .

Предположим, в директории появился файл с именем "new file.cpp" . Если не пользоваться опциями преобразования перевода строк в нуль-символ, произойдет следующее:

$ find . -name "*.cpp" | xargs -n 1 -t rm -rf 2>&1

rm -rf ./new

rm -rf file.cpp

и, естественно, файл "new file.cpp" не будет удален. Если же добавить вышеприведенные опции, то команда сработает правильно:

$ find . -name "*.cpp" -print0 | xargs -n 1 -t -0 rm -rf 2>&1

rm -rf ./new file.cpp

и файл будет удален.

А что будет, если не писать опцию "-n" ?

Надо обратить внимание, что в вышеприведенных командах используется опция "-n 1" . А что будет, если ее не писать? В принципе, все сработает точно так же. Но вот как это работает, мало кто сможет объяснить, ибо визуально команды будут одни и те же, а результат разный. Вот пример.

Команда без опции "-n 1" и без опций преобразования нуль-символа:

$ find . -name "*.cpp" | xargs -t rm -rf 2>&1

"rm ..." , и она не удалит файл "new file.cpp" .

А теперь команда без опции "-n 1", но с опциями преобразования нуль-символа:

$ find . -name "*.cpp" -print0 | xargs -t -0 rm -rf 2>&1

rm -rf ./main.cpp ./data.cpp ./config.cpp ./version.cpp ./new file.cpp

В результате сконструирована команда "rm ..." , внешне абсолютно идентичная предыдущей, но она удалит файл "new file.cpp" !

Как это работает объяснить сложно. Ведь опцию "-0" имеет команда xargs , а не команда rm . В man-странице команды rm нет никаких указаний на то, что в случае разделения имен файлов нулевыми символами пробельные символы в именах файлов будут обрабатываться как литералы, а не как разделители. Для автора статьи такое поведение остается загадкой, и пока не нашлось специалиста, который бы объяснил, что же на самом деле происходит.

Самый главный вопрос

А как же конструировать команды, в которых нужно не просто добавить справа найденные последовательности символов? А если нужно и после подставленного справа значения еще что-то дописать? Как быть? А вот никак! Вот такой ответ. С помощью xargs невозможно сконструировать произвольную команду. Можно сконструировать только команду, состоящую из базовой (фиксированой) части и правой (подстановочной) части. И всё!

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

Так неужели в *NIX невозможно сконструировать нужную команду? Конечно, возможно. Для этого можно использовать команду awk и ее функцию system(). Как это делать, написано в статье: .

Недавно я был вдохновлен на написание этого поста после того когда я наткнулся на ситуации когда мне нужно было отредактировать несколько файлов из проекта и заменить одни слова на другие. Раньше я это делал через Notepad++ (CTRL + H), но это хорошо если мы знаем в каком файле нам надо заменить слово, а если этих файлов тысячи. Так вот я хочу вам представить 3 базовых инструмента системы UNIX на сегодняшний день: grep , xargs , и sed .

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

Grep

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

Grep "footer" index.html

Теперь добавим несколько опции для поиска:

• i - Игнорирует регистр символов при сравнениях.
• n - Выдает перед каждой строкой ее номер в файле.
• b - Выдает номер столбца в найдено файле.

А теперь поиск по цельным словам:

• w - Ведет поиск по цельным словам. Например при обычном поиске строки text grep может найти слово textarea . А если используется данный ключ то будут найдены только строки где есть слово text.

Поиск по файлу это хорошо но лучше если мы сможем искать файлы рекурсивно по проекту.

• r - Рекурсивный поиск файлов из текущей директории.
• l - Выдает только имена файлов, содержащие искомое значение.

А теперь попробуем вывести файлы в которых нет искомого значения.

• L - Выводит имена файлов в которых нету искомого значения.

Также очень часто нам надо искать в конкретных типах файлов данное значения.

• –include=«PATTERN» - Поиск в файлах по заданному шаблону

Поиск по файлам которые начинаются на index и заканчиваются на.php

Grep -r --include="index*.php" -l "footer" ./

Теперь давайте передадим результат работы в файл.

Grep -r -l "footer" ./ > out.txt

Xargs

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

Разбивай стандартный поток на аргументы.

• –n - Указываем количество возвращаемых аргументов.

Теперь зададим разделитель аргументов.

• –d - Указывает на разделитель для вывода аргументов.

Вот более интересный пример где xargs используется для передачи файлов которых надо удалить.

Find . -name "*.txt"| xargs rm -rf

Вся суть использования xargs это дробления входящих аргументов для последующей передачи аргументов другим программам.

Sed

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

Делаем простую замену строк из файла text.txt и сохраняем в файл out.txt.

Sed "s/text/test/g" text.txt > out.txt

А теперь сохраним все изменения в текущий файл.

• i - для записи изменений в текущий файл.

Комбинируем все вмести

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

Grep -r -l "foo" ./ | xargs sed -i "s/foo/bar/g"

Таким образом мы смогли заменить все foo на bar используя простую комбинацию из этих программ.

Теперь когда мы узнали основы по работе таких замечательных инструментах как grep, xargs и sed. Мы сможем писать более продвинутых сценарии для наших задач.

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

xargs - разбивает входной поток на аргументы и передает их выполнение любой команде (по умолчанию echo). Читает либо со стандартного ввода, либо через pipe.

Режимы обработки xargs входящих данных

По умолчанию разделителем аргументов считается любой пробельный символ: пробел, табуляция, вертикальная табуляция или перевод строки. Но как и в командной оболочке можно использовать "" или \ что бы предотвратить разбиение аргумента.

Режим, включающийся параметром -L. Практически идентичен предыдущему, за исключением того, что xargs запоминает, какой аргумент на какой строке находится. Более того, если строка оканчивается пробелом или табуляцией, следующая строка считается продолжением текущей.

По строкам. Включается при использовании опции -I или -0. При этом вся строка считается одним целым аргументом, несмотря на пробелы и табуляции внутри. Для -I концом строки является символ "\n" а для -0 символ "\0"

Пример: поиск в /home/user1 всех файлов, имена которых оканчиваются на ".txt", и копирование их в другую директорию. find /home/user1 -name "*.txt" | xargs cp -av --target-directory=/home/backup/ --parents

Найти во всех файлах, расположенных в каталоге /etc/samba вхождение словосочетания logon home. $ find /etc/samba | xargs grep -ni "logon home"

Удалить список файлов. Пути к файлу построчно записаны в файл delfiles.txt xargs rm < delfiles.txt

Об утилите xargs написано очень много — что можно написать еще? Но если, что называется, копнуть поглубже, то выясняется, что во многих публикациях излагаются лишь самые основы, но нет главного: не объясняется, как можно применять xargs в реальной практике. Статей с разбором сложных и нетривиальных вариантов применения этого весьма полезного для системного администратора инструмента, к сожалению, очень мало. Именно поэтому мы написали свою статью и постарались включить в нее как можно больше примеров использования xargs для решения различных проблем.

Сначала мы рассмотрим принцип работы xargs и разберем примеры попроще, а затем перейдем к разбору сложных и интересных кейсов.

Вспоминаем основы

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

В общем виде синтаксис команды xargs можно представить так:

[команда_генератор_списка] | xargs [опции_xargs] [команда]
Рассмотрим, как все это работает, на материале простых и хрестоматийных примеров.

Удаление файлов

Одна из самых частых ситуаций, в которых используется xargs — удаление файлов, найденных при помощи команды find.

Представим себе следующую ситуацию: имеется директория, в которой хранится большое количество файлов. Из нее нужно удалить файлы определенного типа (в нашем примере — файлы с расширением *.sh). Чтобы осуществить эту операцию, нужно передать xargs вывод команды find, и к файлам с указанным расширением будет применена команда -rm:

$ ls one.sh one.py two.sh two.py $ find . -name "*.sh"| xargs rm -rf $ ls one.py two.py

Отметим, что операцию удаления файлов можно осуществить и без xargs, а с помощью команды

$ find . -name "*.sh" -exec rm -rf "{}" \

Описанный способ не сработает, если в имени одного из удаляемых файлов содержится пробел. Имя, состоящее из двух слов, разделенных пробелом, не будет воспринято как единое целое.

Проиллюстрируем это следующим примером:

$ ls new file.sh one.sh one.py two.sh two.py $ find . -name "*.sh"| xargs rm -rf $ ls new file.sh one.py two.py

Как видим, файл, в имени которого имеется пробел, не был удалён.

Чтобы решить эту проблему, используется опция print0 для команды find и опция -0 для команды xargs. Она заменяет стандартный разделитель (перенос строки на нуль-символ (\x0), который и означает конец хранимой строки:

$ find . -name "*.sh" -print0 | xargs -0 rm -rf

Xargs может также помочь, например, быстро удалить все временные файлы, имеющие расширение tmp:

$ find /tmp -name "*.tmp"| xargs rm

Сжатие файлов

Сжать все файлы в текущей директории с помощью gzip можно, введя следующую команду:

$ ls | xargs -p -l gzip

Рассмотрим еще один пример: сжатие с помощью tar всех файлов с расширением *.pl:

$ find . -name "*.pl" | xargs tar -zcf pl.tar.gz

Переименование файлов

С помощью xargs можно осуществлять массовое переименование файлов. Представим себе, что у нас есть группа файлов с расширением *.txt, и нам нужно заменить это расширение на *.sql. Это можно сделать при помощи xargs и потокового текстового редактора sed:

$ ls | sed -e "p;s/.txt$/.sql/" | xargs -n2 fmv

В результате ее выполнения на консоль будет выведен список переименованных файлов.

С помощью xargs можно также добавлять к дополнительные элементы к именам файлов (например, дату):

$ ls | xargs -I FILE mv {} <...>-{}

Вместо <..> можно подставить всё, что угодно.
Фигурные скобки {} в этом примере означают «текущий аргумент» (т.е. текущее имя файла).

Изменение прав для папок и файлов

С помощью xargs можно также ускорить процесс смены прав на файлы и папки для определенного пользователя или группы. Предположим, нам нужно найти все папки пользователя root и заменить их владельца на temp. Эта операция осуществляется при помощи команды:

$ find . -group root -print | xargs chown temp

Чтобы найти все папки группы root и заменить группу на temp, используется команда:

$ find . -group root -print | xargs chgrp temp

Xargs и find: сложные операции

С помощью команд find и xargs можно выполнять и более сложные операции. Вот так, например, можно удалить временные файлы, созданные более 7 дней назад:

$ find /tmp -type f -name "*" -mtime +7 -print0 | xargs -0 rm -f

А вот так — принудительно остановить процессы, которые уже работают больше 7 дней:

$ find /proc -user myuser -maxdepth 1 -type d -mtime +7 -exec basename {} \; | xargs kill -9

Xargs и сut

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

$ cut -d: -f1 < /etc/passwd | sort | xargs echo

А команда вида

File * | grep ASCII | cut -d":" -f1 | xargs -p vim
будет последовательно открывать файлы для редактирования в vim.
Обратим внимание на опцию -p. Благодаря ей команда будет выполняться в интерактивном режиме: перед открытием каждого файла будет запрашиваться подтверждение (y/n).

В заключение приведём ещё один сложный и интересный пример — рекурсивный поиск файлов самого большого размера в некоторой директории:

$ find . -type f -printf "%20s %p\n" | sort -n | cut -b22- | tr "\n" "\000" | xargs -0 ls -laSr

Параллельный запуск процессов

Xargs часто используется для параллельного запуска нескольких процессов. Вот так, например, можно одновременно cжать несколько директорий в tar.gz:

$ echo dir1 dir2 dir3 | xargs -P 3 -I NAME tar czf NAME.tar.gz NAME

В приведенном примере используется ключ -P. Он указывает максимальное количество процессов, которые будут выполняться одновременно. Предположим, что у нас на входе имеется 10 аргументов. Если мы введём команду xargs с ключoм -P 3, то будет запущено 3 экземпляра команды, следующей после xargs, с каждым из этих аргументов.

С помощью xargs можно также параллельно загружать из Интернета множество файлов:

В приведенном примере с указанного адреса будут скачаны все графические файлы с расширением jpg; ключ -P указывает, что требуется скачивать по 10 файлов одновременно.

Предварительные итоги

Подведём предварительные итоги и сформулируем несколько правил работы с xargs.

1. Xargs не работает с файлами, в имени которых присутствует пробел. Для решения этой проблемы с командой xargs используется опция −0. Пробел в имени файла можно обойти также следующим образом:
   $ xargs -I FILE my_command “FILE”
2. Команда xargs принимает команды из со стандартного ввода, разделенные пробелом или переводом строки. Чтобы группировать эти команды, можно использовать двойные или одинарные кавычки. Можно также указать разделитель с помощью опции -d;
3. Если команде xargs не передать вообще никаких аргументов, то по умолчанию будет выполнена команда /bin/echo;
4. Во многих случаях команду xargs можно заменить циклом for. Например, команда
   $ find . -type f -and -iname "*.deb" | xargs -n 1 dpkg -I
   полностью эквивалента циклу
   $ for file in `find . -type f -and -iname "*.deb"`; do dpkg -I "$file"; done

Нетривиальные примеры

Основы мы вспомнили, типичные варианты использования рассмотрели… Перейдем теперь к более сложным и нетривиальным примерам. До некоторых из них мы додумались самостоятельно, работая над повседневными задачами, а некоторые — почерпнули с сайта http://www.commandlinefu.com (всем желающим научиться тонкостям работы с командной строкой очень рекомендуем время от времени его посещать — там порой можно найти очень полезные советы).

Баним IP-адреса из списка

Чтобы забанить IP-адреса из списка, нужно их добавить в IP tables c правилом DROP. Эта операция осуществляется при помощи команды:

$ cat bad_ip_list | xargs -I IP iptables -A INPUT -s IP -j DROP
Можно проделать и более сложную операцию и забанить все адреса по AS:

$ /usr/bin/whois -H -h whois.ripe.net -T route -i origin AS<номер>|egrep "^route"|awk "{print $2}" |xargs -I NET iptables -A INPUT -s NET -j DROP

Изменяем формат URL

Преобразовать URL вида «http%3A%2F%2Fwww.google.com» в «www ,google.com» можно при помощи команды:

Echo "http%3A%2F%2Fwww.google.com" | sed -e"s/%\(\)/\\\\\x\1/g" | xargs echo -e

Генерируем пароль из 10 символов

Сгенерировать надежный пароль можно при помощи команды вида:

$ tr -dc A-Za-z0-9_ < /dev/urandom | head -c 10 | xargs

Генерировать пароли можно и без помощи xargs: для этого cуществует специализированная утилита pwgen. Некоторые другие способы генерации паролей описаны также .

Ищем бинарные файлы, установленные без использования dpkg

Такая операция может потребоваться в случае, если, например, машина стала жертвой хакерской атаки и на ней было установлено вредоносное программное обеспечение. Выявить, что за программы поставили злоумышленники, поможет следующая команда (она ищет запущенные «бинарники», установленные без использования менеджера пакетов dpkg):

$ сat /var/lib/dpkg/info/*.list > /tmp/listin ; ls /proc/*/exe |xargs -l readlink | grep -xvFf /tmp/listin; rm /tmp/listin

Удаляем устаревшие пакеты ядра

$ dpkg -l linux-* | awk "/^ii/{ print $2}" | grep -v -e `uname -r | cut -f1,2 -d"-"` | grep -e | xargs sudo apt-get -y purge

Проблема удаления старых ядер уже обсуждалась на Хабре — см. (по этой же ссылке можно найти любопытные примеры команд).

Преобразуем скрипт в строку

Иногда возникает необходимость преобразовать большой скрипт в одну строку. Сделать это можно так: Добавить метки