🔀 धडा 03 — Pipes आणि redirection: कॉरिडॉर

📍 तुम्ही इथे आहात: 12 पैकी धडा 03 · पुढे: lesson-04-text-tools

📦 या ब्रँचमध्ये काय आहे

धडे 01–03. प्रत्येक command कडे असणारे तीन streams, आणि commands ना एकमेकांशी व files शी जोडणारी plumbing.

lib/log.sh — log() >&2 ने stderr वर लिहितो, म्हणून report स्वच्छ राहतो
bin/school.sh — cmd_list ही एक pipeline आहे: tail | grep | sort | column

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

प्रत्येक command ला तीन कॉरिडॉर असतात: एक आत येणारा (stdin, 0), एक report साठी बाहेर जाणारा (stdout, 1), आणि एक तक्रारींसाठी (stderr, 2). pipe | एका command चा बाहेरचा कॉरिडॉर पुढच्या command च्या आतल्या कॉरिडॉरला जोडतो, म्हणून चार छोटे tools मिळून एका प्रश्नाचे उत्तर देऊ शकतात. > report file मध्ये पाठवतो, >> शेवटी जोडतो, 2> तक्रारी दुसरीकडे पाठवतो. सगळे चालवणारा नियम: report आणि log कधीच एक कॉरिडॉर वाटून घेत नाहीत.

🗺️ आकृती

flowchart LR
  K["⌨️ stdin 0"] --> C["⚙️ command"]
  C -->|"1 stdout"| O["📄 report → | next · > file · >> file"]
  C -->|"2 stderr"| E["📣 log → 2> file · 2>&1 · 2>/dev/null"]

❓ काय

cmd > file बदलून टाका · >> file शेवटी जोडा · < file तिथून वाचा · 2> file errors तिकडे · 2>&1 errors report मध्ये मिसळतात · &> दोन्ही · | tee file file मध्ये copy करा आणि पुढे चालू ठेवा · /dev/null कचरापेटी.
क्रम महत्त्वाचा: cmd > out 2>&1 (errors stdout च्या मागे file मध्ये जातात); cmd 2>&1 > out (errors terminal वर जातात).
Pipes सगळे commands एकाच वेळी चालवतात; set -o pipefail (धडा 08) मधला command fail झाला तर पूर्ण pipe fail करतो.
Here-docs <<EOF … EOF अनेक ओळींचा text आत देतात; xargs ओळींचे arguments बनवतो.

🤔 का

pipeline म्हणजे जोडणी: list | grep 3A | wc -l "3A मध्ये किती" याचे उत्तर एकमेकांबद्दल कधीच न ऐकलेल्या tools ने देतो. हे तेव्हाच चालते जेव्हा stdout वर फक्त data असतो, म्हणूनच log() stderr वर जातो.

🔧 कसे (या repo मध्ये)

log() >&2 ने संपतो. cmd_list { header; tail | filter | sort; } | column -t बांधतो. smoke test मधला L03 दोन कॉरिडॉर वेगळे दाखवतो: 2>/dev/null log लपवतो, 2>&1 >/dev/null फक्त log ठेवतो.

🧪 करून पाहा

bin/school.sh enrol Zoya 3B A > report.txt 2> log.txt; cat report.txt; echo ---; cat log.txt
bin/school.sh list | grep 3B | wc -l                   # a question, answered by three tools
bin/school.sh list 2>/dev/null | tee copy.txt | head -2 # tee: a copy on the way through
bin/school.sh enrol Bad 9Z 2>&1 >/dev/null              # only the complaint (note the order)
cat <<'EOF' | wc -l
one
two
EOF
bin/school.sh remove Zoya; rm -f report.txt log.txt copy.txt

✅ तपासा — तुम्हाला काय दिसायला हवे

report.txt रिकामी असते आणि log.txt मध्ये enrolled Zoya असते; enrol नंतर pipeline 3 छापते (Meera, Rohan, Zoya); चुकीच्या enrol मध्ये फक्त error ची ओळ दिसते; here-doc 2 मोजतो.

🏁 तुम्ही आत्ताच काय सिद्ध केले

तुम्ही तिन्ही streams पैकी प्रत्येक कुठेही वळवू शकता, आणि script चा log तिच्या report पासून दूर का ठेवायचा ते तुम्हाला माहीत आहे.

⚠️ नेहमीच्या चुका

ज्या function चे output capture होते त्यात stdout वर echo "error" — error हाच data बनतो.
> file 2>&1 म्हणायचे असताना 2>&1 > file.
stdin ऐवजी file argument वाचणाऱ्या command मध्ये pipe करणे (pipe केल्यावर grep pattern ला filename लागत नाही).

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: CI stdout artifacts म्हणून आणि stderr logs म्हणून capture करते; दोन्ही मिसळणारी script मध्येच "WARNING" असलेले JSON बनवते. प्रत्येक pipeline step च्या पहिल्या ओळीत 2>&1 | tee build.log असते.

⏭️ पुढे

धडा 04 — text tools: grep, sed, awk आणि त्यांचे मित्र नोंदवहीतून उत्तरे काढतात.

🔀 Lesson 03 — Pipes & redirection: the corridors

📍 You are here: Lesson 03 of 12 · Next: lesson-04-text-tools

📦 What's in this branch

Lessons 01–03. The three streams every command has, and the plumbing that connects commands to each other and to files.

lib/log.sh — log() writes to stderr with >&2, so the report stays clean
bin/school.sh — cmd_list is a pipeline: tail | grep | sort | column

🧒 Explain like I'm 5

Every command has three corridors: one in (stdin, 0), one out for the report (stdout, 1), one for complaints (stderr, 2). A pipe | joins one command's out-corridor to the next one's in-corridor, so four small tools can answer one question. > sends the report into a file, >> adds to the end, 2> sends the complaints somewhere else. The rule that makes it all work: the report and the log never share a corridor.

🗺️ Diagram

flowchart LR
  K["⌨️ stdin 0"] --> C["⚙️ command"]
  C -->|"1 stdout"| O["📄 report → | next · > file · >> file"]
  C -->|"2 stderr"| E["📣 log → 2> file · 2>&1 · 2>/dev/null"]

❓ What

cmd > file replace · >> file append · < file read from · 2> file errors to · 2>&1 errors join the report · &> both · | tee file copy to a file and keep going · /dev/null the bin.
Order matters: cmd > out 2>&1 (errors follow stdout to the file); cmd 2>&1 > out (errors go to the terminal).
Pipes run the commands at once; set -o pipefail (lesson 08) makes a failing middle command fail the whole pipe.
Here-docs <<EOF … EOF feed multi-line text in; xargs turns lines into arguments.

🤔 Why

A pipeline is composition: list | grep 3A | wc -l answers "how many in 3A" with tools that never heard of each other. That only works if stdout carries data only, which is why log() goes to stderr.

🔧 How (in this repo)

log() ends with >&2. cmd_list builds { header; tail | filter | sort; } | column -t. The smoke test's L03 shows the two corridors split: 2>/dev/null hides the log, 2>&1 >/dev/null keeps only the log.

🧪 Try it

bin/school.sh enrol Zoya 3B A > report.txt 2> log.txt; cat report.txt; echo ---; cat log.txt
bin/school.sh list | grep 3B | wc -l                   # a question, answered by three tools
bin/school.sh list 2>/dev/null | tee copy.txt | head -2 # tee: a copy on the way through
bin/school.sh enrol Bad 9Z 2>&1 >/dev/null              # only the complaint (note the order)
cat <<'EOF' | wc -l
one
two
EOF
bin/school.sh remove Zoya; rm -f report.txt log.txt copy.txt

✅ Verify — what you should see

report.txt is empty and log.txt holds enrolled Zoya; the pipeline prints 3 after the enrol (Meera, Rohan, Zoya); the bad enrol shows only the error line; the here-doc counts 2.

🏁 What you just proved

You can route each of the three streams anywhere, and you know why a script's log must stay out of its report.

⚠️ Common mistakes

echo "error" to stdout inside a function whose output is captured — the error becomes data.
2>&1 > file when you meant > file 2>&1.
Piping into a command that reads a file argument instead of stdin (grep pattern needs no filename when piped).

🏭 Why this matters in production: CI captures stdout as artifacts and stderr as logs; a script that mixes them produces JSON with "WARNING" in the middle. 2>&1 | tee build.log is on the first line of every pipeline step.

⏭️ Next

Lesson 04 — the text tools: grep, sed, awk and friends turn the register into answers.

← Previousfiles and paths Next →text tools

This page is the lesson's README from the lesson-03-pipes-redirection branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.