Ubuntu cat: Команда cat Linux — Losst

Команда Cat в Linux: Использование и Примеры

VPS

Июл 01, 2020

Olha L.

3хв. читання

Команда cat в Linux — одна из самых полезных утилит, которые обязательно стоит выучить. Являясь сокращением английского слова «concatenate» (конкатенация), она позволяет создавать, объединять, а также выводить содержимое файлов в командной строке или в другом файле.

Утилита не требует дополнительных установок, так как предварительно установленна в пакете coreutils в любой системе на основе Debian или Red Hat.

В этом уроке мы рассмотрим общие способы использования команды Linux cat, объясняя её особенности.

Оглавление

Команда Cat: Синтаксис

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

cat [ОПЦИЯ] [ФАЙЛ]

Чтобы найти все доступные опции, просто введите cat –help в терминале.

Создание Файла с Помощью Команды Cat

С помощью команды cat вы можете быстро создать файл и поместить в него текст. Для этого используйте оператор > redirect, чтобы перенаправить текст в файл.

cat > imiafaila.txt

Файл создан, и вы можете начать заполнять его текстом. Если вы хотите добавить несколько строк, просто нажимайте Enter в конце каждой строки. Когда вы закончите, нажмите CTRL+D, чтобы выйти из файла.

Чтобы убедиться, что файл действительно создан, просто введите в терминале следующую команду ls:

ls -l

Просмотр Содержимого Файла с Помощью Команды Cat

Это один из самых базовых примеров использования команды cat. Без каких-либо дополнительных опций команда прочитает содержимое файла и выведет его в консоли.

cat imiafaila.txt

Для удобного просмотра длинных файлов, используйте параметр | more, который позволит скролить выходные данные по одному скрину за раз:

cat filename. txt | more

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

cat *.txt

Редирект Контента с Помощью Команды Cat

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

cat ishodnyifail.txt > failnaznachenija.txt

Если файл назначения не существует, команда создаст его или перезапишет существующий с таким же именем.

Чтобы добавить содержимое в файл назначения, используйте опцию >>:

cat ishodnyifail.txt >> failnaznachenija.txt

Конкатенация («Склеивание») Файлов с Помощью Команды Cat

Команда cat также позволяет объединять несколько файлов в один. По сути это работает так же, как и функция перенаправления выше, но с несколькими исходными файлами.

cat ishodnyifail1.txt ishodnyifail2. txt > failnaznachenija.txt

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

Обозначение Конца Строки Командой Cat

С помощью команды cat также можно обозначить конец строки. Маркер конца строки — символ $. Чтобы реализовать эту функцию, используйте параметр -E:

cat -E imiafaila.txt

Нумерация Строк с Помощью Команды Cat в Linux

Эта команда также позволяет отобразить содержимое файла с пронумерованными строками. Реализует эту функцию опция  -n:

cat -n imiafaila.txt

Отображение Непечатаемых Символов

Чтобы показать непечатаемые символы, добавьте к команде cat опцию -v, например:

cat -v imiafaila.txt

Чтобы показать только символы табуляции, используйте параметр -T:

cat -T imiafaila.txt

Табуляции будут отображаться как ^I.

Удаление Пустых Строк

Чтобы удалить пустые повторяющиеся строки и сэкономить место на дисплее, вы можете применить опцию -s. Но имейте в виду, что этот параметр удалит только повторяющиеся пустые строки, оставив одну пустую строку.

cat -s imiafaila.txt

Нумерация Непустых Строк с Помощью Команды Cat в Linux

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

cat -b imiafaila.txt

Отображение Файла в Обратном Порядке

Чтобы просмотреть содержимое файла в обратном порядке, начиная с последней строки и заканчивая первой, просто используйте команду tac (команду cat, написанную задом наперёд):

tac imiafaila.txt

Выводы

Вот и всё. Теперь вы знаете, как работает команда cat в Linux и ознакомились с основными примерами её использования. Этого достаточно, чтобы начать применять её на практике. Если же вы хотите изучить эту утилиту более подробно, просто вызовите её справочную страницу с помощью команды man cat!

Мы надеемся, что эта статья помогла вам улучшить навыки работы с командной строкой Linux. Увидимся в следующем руководстве!

Ольга вже близько восьми років працює менеджером у сфері IT, три з яких вона займається SEO. Написання технічних завдань та інструкцій — один з її основних обов’язків. Її хобі — дізнаватися щось нове і створювати цікаві та корисні статті про сучасні технології, веброзробку, мови програмування, пошукову оптимізацію сайтів та багато іншого.

Більше статей від Olha L.

Команда cat в Linux — ИТ Проффи

cat — одна из наиболее часто используемых команд в Linux. Она считывает данные из файлов и выводит их содержимое. Это самый простой способ отображения содержимого файла в командной строке.

Содержание

1. Синтаксис
2. Отображение текстовых файлов
3. Копирование текстового файла
4. Присоединение содержимого текстового файла в конец другого текстового файла
5. Добавление стандартного ввода в вывод cat
6. Опции
7. Заключение

Синтаксис

cat [ОПЦИИ]. .. [ФАЙЛ]...

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

Отображение текстовых файлов

Простейший способ использования cat - задать команде имя файла. Содержимое текстового файла будет выведено на экран. Например, следующая команда прочитает содержимое файла mytext.txt и выведет его в стандартный поток вывода (экран вашего терминала):
cat mytext.txt

Если файл слишком длинный, он пролистается, и вы увидите только последний экран. При необходимости просмотреть документ постранично или прокручивать его вперёд и назад можно воспользоваться такими средствами просмотра как pg, more или less.

Когда указано несколько файлов, cat будет выводить их последовательно, объединяя содержимое в потоке стандартного вывода. Поэтому следующая команда выведет содержимое двух текстовых файлов, как если бы они были одним:

cat mytext. txt mytext2.txt

Копирование текстового файла

Обычно копирование осуществляется командой cp, но для копирования текстовых файлов вы можете аналогичным образом использовать команду cat. cat отправляет результат в stdout (стандартный поток вывода), обычно это экран терминала. Однако, можно перенаправить результат в файл при помощи символа перенаправления “>”.

Например, команда:

cat mytext.txt > newfile.txt

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

Аналогично можно объединять несколько файлов в один. Например, команда

cat mytext.txt mytext2.txt > newfile.txt

считает содержимое mytext.txt и mytext2.txt и запишет объединенный текст в newfile.txt. При отсутствии файла он будет создан, при наличии — перезаписан.

Присоединение содержимого текстового файла в конец другого текстового файла

Вместо перезаписи файла можно присоединить текст файла-источника к другому файлу при помощи оператора перенаправления «>>».
Например, команда:

cat mytext.txt >> another-text-file.txt

Прочтет содержимое mytext.txt и запишет его в конец файла another-text-file.txt. Если этот файл не существует, он будет создан, и содержимое mytext.txt будет записано в новый файл.
Это работает также для нескольких файлов. Следующая команда последовательно запишет содержимое mytext.txt и mytext2.txt в конец файла another-text-file.txt:

cat mytext.txt mytext2.txt >> another-text-file.txt

Добавление стандартного ввода в вывод cat

Если в качестве имени файла задать дефис («-«), cat осуществляет считывание из стандартного потока ввода. Например, если у вас есть файл list.txt со следующим текстом:

яблоки
апельсины
масло
хлеб

вы можете воспользоваться командой echo для вывода текста, направить этот текст команде cat и указать ей объединить его с содержимым файла:

echo "Мой список покупок" | cat - list. I.
-v, —show-nonprinting — показывать непечатаемые символы, кроме табуляции и конца строки.
-t — показывать непечатаемые символы, кроме конца строки.
-e — показывать непечатаемые символы, кроме табуляции.
-A, —show-all — показывать все непечатаемые символы.
—help — вывести справку и выйти.
—version — вывести информацию о версии и выйти.
Заключение
cat — простой, но очень полезный инструмент для работы с данными в текстовых файлах, системных логах, файлах конфигурации и любыми другими читаемыми для человека данными.
Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.
Командная строка 
 - В чем разница между "cat 
 
 TL;DR Версия ответа: 
 
 
 
 С  cat file.txt  приложение (в данном случае  cat ) получило один позиционный параметр, выполняет open( 2) системный вызов на нем, и проверки разрешений происходят в приложениях 
 
 
 
 С  cat < file. txt  оболочка выполнит  dup2()  системный вызов, чтобы преобразовать стандартный ввод в копию файлового дескриптора (обычно следующего доступного, например, 3), соответствующего  file.txt  и закройте этот файловый дескриптор (например, 3). Приложение не выполняет open(2) для файла и не знает о существовании файла; он работает строго со своим файловым дескриптором stdin. Проверка разрешений возлагается на оболочку. Описание открытого файла останется таким же, как при открытии файла оболочкой. 
 
 
 
 Введение 
 
 На первый взгляд  cat file.txt  и  cat < file.txt  ведут себя одинаково, но за кулисами происходит гораздо больше с этой единственной разницей символов. Тот самый 9Символ 0007 <  изменяет то, как оболочка понимает  file.txt  , кто открывает файл и как файл передается между оболочкой и командой. Конечно, чтобы объяснить все эти детали, нам также необходимо понять, как открытие файлов и выполнение команд работает в оболочке, и именно на это направлен мой ответ - рассказать читателю в самых простых словах о том, что на самом деле происходит в эти, казалось бы, простые команды.  В этом ответе вы найдете несколько примеров, в том числе те, которые используют команду strace для резервного копирования объяснений того, что на самом деле происходит за кулисами. 
 
 Поскольку внутренняя работа оболочек и команд основана на стандартных системных вызовах, важно рассматривать  cat  как одну из многих других команд. Если вы новичок, читающий этот ответ, будьте непредвзяты и помните, что  prog file.txt  не всегда будет таким же, как  prog < file.txt  . Другая команда может вести себя совершенно по-разному, когда к ней применяются две формы, и это зависит от разрешений или от того, как написана программа. Прошу вас также воздержаться от суждений и посмотреть на это с точки зрения разных пользователей - для случайного пользователя оболочки потребности могут быть совершенно другими, чем для сисадмина и разработчика. 
 
 execve() Системный вызов и позиционные параметры, которые видит исполняемый файл 
 
 Оболочки запускают команды, создавая дочерний процесс с системным вызовом fork(2) и вызывая системный вызов execve(2), который выполняет команду с указанными аргументами и переменными среды.  Команда, вызванная внутри  execve() , возьмет на себя управление и заменит процесс; например, когда оболочка вызывает  cat , она сначала создает дочерний процесс с PID 12345, а после  execve()  PID 12345 становится  кот  . 
 
 Это подводит нас к разнице между  cat file.txt  и  cat < file.txt  . В первом случае  cat file.txt  — это команда, вызываемая с одним позиционным параметром, и оболочка соберет вместе  execve()  соответствующим образом: 
 
 $ strace -e execve cat testfile.txt
execve("/bin/cat", ["cat", "testfile.txt"], 0x7ffcc6ee95f8 /* 50 переменных */) = 0
привет, я testfile.txt
+++ выход с 0 +++
 
 Во втором случае 9Часть 0007 <  является оператором оболочки, а  < testfile.txt  указывает оболочке открыть  testfile.txt  и преобразовать дескриптор файла stdin 0 в копию дескриптора файла, который соответствует  testfile. txt  . Это означает, что  < testfile.txt  не будет передано самой команде в качестве позиционного аргумента:
 $ strace -e execve cat < testfile.txt
execve("/bin/cat", ["cat"], 0x7ffc6adb5490 /* 50 переменных */) = 0
привет, я testfile.txt
+++ выход с 0 +++
$
 
 Это может иметь значение, если программе требуется позиционный параметр для правильной работы. В этом случае  cat  по умолчанию принимает ввод со стандартного ввода, если не были предоставлены позиционные параметры, соответствующие файлам. Что также подводит нас к следующей теме: стандартный ввод и файловые дескрипторы.
 STDIN и файловые дескрипторы 
 Кто открывает файл -  cat  или оболочка? Как они его открывают? У них вообще есть разрешение открыть его? Это вопросы, которые можно задать, но сначала нам нужно понять, как работает открытие файла.
 Когда процесс выполняет  open()  или  openat()  над файлом, эти функции предоставляют процессу целое число, соответствующее открытому файлу, после чего программы могут вызывать  read()  ,  seek( )  и  вызовы write()  и множество других системных вызовов, ссылаясь на это целое число. Конечно, система (также известная как ядро) будет хранить в памяти, как был открыт конкретный файл, с какими разрешениями, в каком режиме - только чтение, только запись, чтение/запись - и где в файле мы сейчас находимся. - в байте 0 или байте 1024 - что называется смещением. это называется  открыть описание файла  .
 На самом базовом уровне  cat testfile.txt  — это место, где  cat  открывает файл, и на него будет ссылаться следующий доступный файловый дескриптор, равный 3 (обратите внимание на 3 в read(2)).
 $ strace -e read -f cat testfile.txt > /dev/null
...
read(3, "привет, я testfile.txt и thi"..., 131072) = 79
читать(3, "", 131072) = 0
+++ выход с 0 +++
 
 Напротив,  cat < testfile.txt  будет использовать файловый дескриптор 0 (он же stdin):
 $ strace -e read -f cat < testfile.txt > /dev/null
...
read(0, "привет, я testfile.txt и thi"..., 131072) = 79
читать (0, "", 131072) = 0
+++ выход с 0 +++
 
 Помните, как ранее мы узнали, что оболочки запускают команды через тип процесса  fork() , а затем  exec() ? Что ж, оказывается,  то, как файл  открыт, передается дочерним процессам, созданным с помощью шаблона  fork()/exec() . Процитировать руководство open(2):
 Когда дескриптор файла дублируется (используя dup(2) или аналогичный), 
 дубликат относится к тому же открытому описанию файла , что и оригинал
 файловый дескриптор, и, следовательно, два файловых дескриптора  совместно используют
 флаги смещения файла и состояния файла.  Такое совместное использование также может происходить
 между процессами: дочерний процесс, созданный с помощью fork(2), наследует
 дубликаты файловых дескрипторов своего родителя, и эти дубликаты
 обратитесь к тем же описаниям открытых файлов
 Что это означает для  cat file.txt  по сравнению с  cat < file.txt  ? На самом деле много. В  cat file.txt   cat  открывает файл, что означает, что он контролирует, как файл открывается. Во втором случае оболочка откроет файл  file.txt , и способ его открытия останется неизменным для дочерних процессов, составных команд и конвейеров. Где мы сейчас находимся в файле, также останется прежним.
 Давайте используем этот файл в качестве примера:
 $ кошка testfile.txt
привет, я testfile.txt и это первая строка
вторая линия
третья линия
Последняя линия
 
 Посмотрите на пример ниже. Почему слово  строка  не изменилось в первой строке?
 $ { голова -n1; sed 's/линия/картошка/'; } /dev/null
привет, я testfile.txt и это первая строка
картошка два
картошка три
последняя картофелина
 
 Ответ содержится в цитате из руководства open(2) выше: файл, открытый оболочкой, дублируется на стандартный ввод составной команды, и каждая выполняемая команда/процесс разделяет смещение описания открытого файла.  head  просто перематывал файл вперед на одну строку, а  sed  занимался остальным. В частности, мы увидим 2 последовательности системных вызовов  dup2()  /  fork()  /  execve() , и в каждом случае мы получим копию файлового дескриптора, которая ссылается на одно и то же описание файла при открытии . testfile.txt  . Смущенный ? Возьмем немного более безумный пример:
 $ { head -n1; дд of=/dev/null bs=1 count=5; кот; } /dev/null
привет, я testfile.txt и это первая строка
два
третья линия
Последняя линия
 
 Здесь мы напечатали первую строку, затем перемотали описание открытого файла на 5 байт вперед (что исключило слово , строку ), а затем просто напечатали остальное. И как нам это удалось? Описание открытого файла в  testfile.txt  остается прежним, с общим смещением в файле.
 Теперь, почему это полезно понимать, кроме написания сумасшедших составных команд, подобных приведенным выше? Как разработчик, вы можете воспользоваться преимуществами такого поведения или остерегаться его. Скажем вместо  cat  вы написали программу на языке C, которой требуется конфигурация либо в виде файла, либо из стандартного ввода, и вы запускаете ее как  myprog myconfig.json  . Что будет, если вместо этого запустить  { head -n1; myprog;} < myconfig. json  ? В лучшем случае ваша программа получит неполные данные конфигурации, а в худшем - сломает программу. Мы также можем использовать это как преимущество, чтобы создать дочерний процесс и позволить родителю перемотать данные, о которых должен позаботиться дочерний процесс.
 Разрешения и привилегии 
 Давайте на этот раз начнем с примера файла без прав на чтение или запись для других пользователей:
 $ sudo -u картофеля кот < testfile.txt
привет, я testfile.txt и это первая строка
вторая линия
третья линия
Последняя линия
$ sudo -u картофельный кот testfile.txt
cat: testfile.txt: Отказано в доступе
 
 Что здесь произошло? Почему мы можем прочитать файл в первом примере как пользователь  картофеля , но не во втором? Это восходит к той же цитате из справочной страницы open(2), упомянутой ранее. С  < file.txt  оболочка открывает файл, следовательно, проверки разрешений происходят во время  open  /  openat() , выполняемых оболочкой. В это время оболочка запускается с привилегиями владельца файла, у которого есть права на чтение файла. В силу того, что описание открытого файла наследуется через  вызовов dup2 , оболочка передает копию дескриптора открытого файла  sudo  , который передает копию дескриптора файла  cat  , а  cat , не зная ни о чем другом, с радостью читает содержимое файла. В последней команде  cat  под пользователем картошки выполняет  open()  над файлом, и, конечно же, у этого пользователя нет прав на чтение файла.
 Более практично и часто, вот почему пользователи недоумевают, почему что-то подобное не работает (запуск привилегированной команды для записи в файл, который они не могут открыть):
 $ sudo echo 100 > /sys/class/ drm/*/intel_backlight/яркость
bash: /sys/class/drm/card0-eDP-1/intel_backlight/brightness: Отказано в доступе
 
 Но что-то вроде этого работает (используя привилегированную команду для записи в файл, который не требует привилегий):
 $ echo 100 |sudo tee /sys/class/drm/*/intel_backlight/brightness
[sudo] пароль администратора:
100
 
 Теоретический пример ситуации, противоположной той, которую я показал ранее (где  привилегированная_программа < file. txt  не работает, но  привилегированная_прог file.txt  работает) будет с программами SUID. Программы SUID, такие как  passwd , позволяют выполнять действия с разрешениями владельца исполняемого файла. Вот почему команда  passwd  позволяет вам изменить свой пароль, а затем записать это изменение в /etc/shadow, даже если файл принадлежит пользователю root.
 Ради примера и веселья я на самом деле пишу быстрое демо  cat -подобное приложение на C (исходный код здесь) с установленным битом SUID, но если вы поняли суть — не стесняйтесь перейти к следующему разделу этого ответить и игнорировать эту часть. Примечание: ОС игнорирует бит SUID в интерпретируемых исполняемых файлах с  #!  , так что версия этой же вещи на Python потерпит неудачу.
 Давайте проверим разрешения на программу и  testfile.txt  :
 $ ls -l ./privived
-rwsr-xr-x 1 администратор администратор 8672 29 ноября16:39 ./привилегированный
$ ls -l тестовый файл. txt
-rw-r----- 1 администратор администратор 79 ноябрь 29 12:34 testfile.txt
 
 Выглядит хорошо, только владелец файла и те, кто входит в группу  администратор , могут прочитать этот файл. Теперь давайте войдем в систему как пользователь картофеля и попробуем прочитать файл:
 $ su картофеля
Пароль:
картофель@мой-ПК:/дом/администратор$ кот ./testfile.txt
кошка: ./testfile.txt: Отказано в доступе
картофель@мой-ПК:/дом/администратор$ кот < ./testfile.txt
bash: ./testfile.txt: Отказано в доступе
 
 Выглядит нормально, ни оболочка, ни  cat , у которых есть права доступа для картошки, не могут прочитать файл, чтение которого им не разрешено. Обратите также внимание на тех, кто сообщает об ошибке:  cat  vs  bash  . Давайте проверим нашу программу SUID:
 картошка@мой-ПК:/домашний/администратор$ ./привилегированный testfile.txt
привет, я testfile.txt и это первая строка
вторая линия
третья линия
Последняя линия
картофель@мой-ПК:/домашний/администратор$ . /привилегированный < testfile.txt
bash: testfile.txt: Отказано в доступе
 
 Работает по назначению! Опять же, смысл этой небольшой демонстрации заключается в том, что  prog file.txt  и  prog < file.txt  различаются тем, кто открывает файл, и различаются разрешениями на открытие файла.
 Как программы реагируют на STDIN 
 Мы уже знаем, что  < testfile.txt  перезаписывает стандартный ввод таким образом, что данные будут поступать из указанного файла, а не с клавиатуры. Теоретически и исходя из философии Unix «делать одно и делать это хорошо», программы, читающие со стандартного ввода (он же файловый дескриптор 0), должны вести себя согласованно, и поэтому  прог1 | prog2  должен быть похож на  prog2 file.txt  . Но что, если  prog2  хочет перемотать назад с помощью системного вызова lseek, например, чтобы перейти к определенному байту или перемотать в конец, чтобы узнать, сколько данных у нас есть?
 Некоторые программы запрещают чтение данных из канала, поскольку конвейеры нельзя перемотать с помощью системного вызова lseek(2) или данные нельзя загрузить в память с помощью mmap(2) для более быстрой обработки. Это было описано в отличном ответе Стефана Шазеласа на этот вопрос: в чем разница между «cat file | ./binary» и «./binary < файл»? Я настоятельно рекомендую это прочитать.
 К счастью,  cat < file.txt  и  cat file.txt  ведут себя последовательно, а  cat  никоим образом не против каналов, хотя мы знаем, что он читает совершенно разные файловые дескрипторы. Как это применимо в  prog file.txt  по сравнению с  prog < file.txt  в целом? Если программа действительно не хочет ничего делать с пайпами, то отсутствия позиционного параметра  в файле.txt  будет достаточно для выхода с ошибкой, но приложение все равно может использовать  lseek()  на stdin, чтобы проверить, это канал или нет (хотя isatty(3) или определение режима S_ISFIFO в fstat(2), скорее всего, будут использоваться для обнаружения ввода канала), и в этом случае выполните что-то вроде  ./binary <(файл шаблона grep.txt)  или  . /binary < <(файл шаблона grep.txt)  может не работать.
 Влияние типа файла 
 Тип файла может влиять на поведение  prog file  и  prog < file . Что в некоторой степени подразумевает, что как пользователь программы вы выбираете системные вызовы, даже если вы не знаете об этом. Например, предположим, что у нас есть сокет домена Unix, и мы запускаем  nc  сервер для прослушивания, возможно, мы даже подготовили некоторые данные для обслуживания
 $ nc -U -l /tmp/mysocket.sock < testfile.txt
 
 В этом случае  /tmp/mysocket.sock  будет открываться через разные системные вызовы:
 socket(AF_UNIX, SOCK_STREAM, 0) = 3
setsockopt(3, SOL_SOCKET, SO_REUSEADDR, [1], 4) = 0
bind(3, {sa_family=AF_UNIX, sun_path="/tmp/mysocket.sock"}, 20) = 0
 
 Теперь попробуем прочитать данные из этого сокета в другом терминале:
 $ кошка /tmp/mysocket.sock
cat: /tmp/mysocket.sock: нет такого устройства или адреса
$ кошка < /tmp/mysocket. sock
bash: /tmp/mysocket.sock: нет такого устройства или адреса
 
 И shell, и cat выполняют системный вызов  open(2)  для того, что требует совершенно другого системного вызова - пары socket(2) и connect(2). Даже это не работает:
 $ nc -U < /tmp/mysocket.sock
bash: /tmp/mysocket.sock: нет такого устройства или адреса
 
 Но если мы осознаем тип файла и то, как мы можем вызвать правильный системный вызов, мы можем получить желаемое поведение:
 $ nc -U /tmp/mysocket.sock
привет, я testfile.txt и это первая строка
вторая линия
третья линия
Последняя линия
 
 Примечания и другие рекомендуемые материалы: 
 В цитате из руководства open(2) говорится, что разрешения на файловый дескриптор наследуются. Теоретически есть способ изменить разрешения на чтение/запись дескриптора файла, но это нужно сделать на уровне исходного кода.
 Что такое описание открытого файла?. См. также определение POSIX 9.0011
 Как Linux проверяет разрешение для файлового дескриптора?
 Почему поведение команды  1>file. txt 2>file.txt  отличается от поведения команды  1>file.txt 2>&1  ?
 командная строка - Как использовать `cat`, чтобы увидеть начало очень длинного файла? 
 спросил
  5 лет, 3 месяца назад 
 Изменено
 5 лет, 2 месяца назад
 Просмотрено
 27 тысяч раз
 Я хотел бы знать, как
 cat my-verylong-file
 
 и покажите его сверху, а не с конца. Как и команда  man .
 командная строка
 кошка
 2
 Используйте  меньше  , что покажет файл сверху, что позволит вам прокручивать его, как  man  :
 меньше мой-очень-длинный-файл
 
  Нажмите  q  для выхода. 
 Если вам просто интересно увидеть n первых строк файла, альтернативой может быть  head :
 head -n 25 имя файла
 
 покажет 25 первых строк файла.
 То же самое для n последних строк файла с  хвостом  :
 хвост -n 25 имя файла
 
 6
  man  по умолчанию использует  less(1)  в качестве пейджера. Используйте его вместо  cat  . См. Также ответ @vidarlo.
 Как настроить 
 меньше , чтобы сделать его еще лучше:
 Мне нравится псевдоним  m=less  , так что это просто однобуквенная команда, потому что я постоянно ее набираю. Добавление  |m  в конце чего-либо передает его на пейджер.
 В псевдоним можно добавить такие параметры, как  -iMRj5X  (например, псевдоним  m='less -iMRX  ), но я делаю это с моим файлом  ~/. lesskey . (См.  lesskey(1)  ).
  -i  : при поиске не учитывается регистр (если вы не используете заглавные буквы)
  -M  : более длинная строка состояния, показывающая номер строки и процент файла
  -R  : пропустить некоторые управляющие коды, чтобы вы могли передать окрашенные команды в меньшее количество.
  -X  : не переключайтесь на «альтернативный» экран эмулятора терминала, так что все, на что вы смотрели, все еще будет там, когда вы  q  uit из  минус  . (отлично подходит для справочных страниц после того, как вы найдете нужный параметр и захотите просмотреть его во время ввода.)
  -j5  : при поиске целевая строка помещается в строку 5, а не в верхнюю часть экрана. Таким образом, вы можете видеть контекст с обеих сторон результата поиска. (Иногда я меняю это в интерактивном режиме, набирая  -j40  или что-то внутри  меньше  , если наиболее полезно увидеть контекст перед поиском).