🧩 धडा 07 — Functions आणि arguments: दिनचर्या

📍 तुम्ही इथे आहात: 12 पैकी धडा 07 · पुढे: lesson-08-errors-safety

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

धडे 01–07. एका दिनचर्येला नाव देणे, तिला arguments देणे, आणि प्रत्येक खऱ्या script मध्ये असणारा सांगाडा.

bin/school.sh — पाच cmd_* functions, usage(), main "$@"
lib/log.sh — log, die, need: source द्वारे प्रत्येक script वापरते अशी तीन functions

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

रोज सकाळी केअरटेकरला त्याच सात ओळी सांगण्याऐवजी, तुम्ही त्या एका नाव दिलेल्या कार्डवर लिहिता — एक function — आणि त्याला लागणारी माहिती देता: cmd_enrol Zoya 3B A. आत, $1 म्हणजे पहिली माहिती, $2 दुसरी, "$@" सगळी. script ची शेवटची ओळ, main "$@", तुम्ही टाइप केलेले सगळे एका दिनचर्येकडे देते, जी कोणते कार्ड वापरायचे ते ठरवते.

🗺️ आकृती

flowchart TD
  M["main \"$@\""] --> C{"case $cmd"}
  C -->|list| L["cmd_list --class 3A"]
  C -->|enrol| E["cmd_enrol NAME CLASS [GRADE]"]
  C -->|report| R["cmd_report"]
  C -->|"*"| U["die 'unknown command'"]

❓ काय

name() { …; } define करते; name a b बोलावते. local x variable आतच ठेवतो. return N exit code ठरवतो; value परत द्यायची असेल तर ती echo करा आणि $(name) ने पकडा.
$1 … $9, ${10}, $# संख्या, "$@" प्रत्येक argument अखंड, shift पहिला काढून टाकतो. ${1:?needs NAME} एक argument मागतो.
Flags: while [[ $# -gt 0 ]]; do case "$1" in --class) class="$2"; shift 2;; …; esac; done, किंवा -a value -b -h साठी getopts "a:bh" opt.
source lib/log.sh (किंवा . lib/log.sh) functions या shell मध्ये load करतो.
सांगाडा: shebang · set -euo pipefail · HERE · source · functions · main "$@".
usage() sed -n '2,9p' "$0" ने header comment छापते — --help साठी सत्याचा एकच स्रोत.

🤔 का

functions मुळेच 70 ओळींची script 700 ओळींवरही वाचता येते, दोन scripts एक logger वाटून घेतात, आणि तुम्ही एखादा तुकडा वेगळा काढून test करू शकता (धडा 12).

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

cmd_enrol local आणि ${1:?} वापरतो; cmd_list --class खातो; main shift || true ने sub-command सोलून काढतो आणि case ने काम वाटतो; usage --help साठी 0 ने आणि चुकीच्या वापरासाठी 1 ने exit होते.

🧪 करून पाहा

bin/school.sh --help
bin/school.sh list --class 3B --bogus; echo "exit $?"          # the flag loop refuses
source lib/log.sh; log "hello from my shell"; need tar && echo "tar is here"
f() { local x="$1"; echo "got $#: $*"; return 3; }; f a "b c"; echo "exit $?"
# add a sub-command: copy cmd_report, name it cmd_count, print $(tail -n +2 "$REGISTER" | wc -l), wire it into main's case

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

header comment मधला help text; unknown flag --bogus आणि exit 1; timestamp असलेला hello; got 2: a b c आणि मग exit 3. तुमचा count sub-command जोडल्यावर 5 छापतो.

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

तुम्ही खऱ्या CLI चा सांगाडा वाचू आणि वाढवू शकता: functions, arguments, flags, dispatch, help.

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

local विसरणे: function मधला i बोलावणाऱ्याचा i बिघडवतो.
return "some text": return फक्त आकडा घेतो; values echo करून बाहेर द्या.
unquoted main $@: spaces असलेले arguments तुटतात.

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: एका screen पेक्षा मोठे झालेल्या प्रत्येक ops tool चा हाच सांगाडा असतो; ज्यांचा नसतो त्या 400 ओळींच्या files ना हात लावायची कोणाचीच हिंमत होत नाही.

⏭️ पुढे

धडा 08 — errors आणि safety: आगीची तालीम — मोठ्याने fail व्हा, साफसफाई करा, काहीही न बदलता सराव करा.

🧩 Lesson 07 — Functions & arguments: routines

📍 You are here: Lesson 07 of 12 · Next: lesson-08-errors-safety

📦 What's in this branch

Lessons 01–07. Naming a routine, handing it arguments, and the skeleton every real script shares.

bin/school.sh — five cmd_* functions, usage(), main "$@"
lib/log.sh — log, die, need: three functions shared by every script via source

🧒 Explain like I'm 5

Instead of telling the caretaker the same seven lines every morning, you write them on a card with a name — a function — and hand it any details it needs: cmd_enrol Zoya 3B A. Inside, $1 is the first detail, $2 the second, "$@" all of them. The script's last line, main "$@", hands everything you typed to one routine that decides which card to use.

🗺️ Diagram

flowchart TD
  M["main \"$@\""] --> C{"case $cmd"}
  C -->|list| L["cmd_list --class 3A"]
  C -->|enrol| E["cmd_enrol NAME CLASS [GRADE]"]
  C -->|report| R["cmd_report"]
  C -->|"*"| U["die 'unknown command'"]

❓ What

name() { …; } defines; name a b calls. local x keeps a variable inside. return N sets the exit code; to give a value back, echo it and capture with $(name).
$1 … $9, ${10}, $# count, "$@" each argument whole, shift drops the first. ${1:?needs NAME} demands one.
Flags: while [[ $# -gt 0 ]]; do case "$1" in --class) class="$2"; shift 2;; …; esac; done, or getopts "a:bh" opt for -a value -b -h.
source lib/log.sh (or . lib/log.sh) loads functions into this shell.
The skeleton: shebang · set -euo pipefail · HERE · source · functions · main "$@".
usage() prints the header comment with sed -n '2,9p' "$0" — one source of truth for --help.

🤔 Why

Functions are how a 70-line script stays readable at 700, how two scripts share a logger, and how you test a piece in isolation (lesson 12).

🔧 How (in this repo)

cmd_enrol uses local and ${1:?}; cmd_list eats --class; main peels the sub-command with shift || true and dispatches with case; usage exits 0 for --help and 1 for misuse.

🧪 Try it

bin/school.sh --help
bin/school.sh list --class 3B --bogus; echo "exit $?"          # the flag loop refuses
source lib/log.sh; log "hello from my shell"; need tar && echo "tar is here"
f() { local x="$1"; echo "got $#: $*"; return 3; }; f a "b c"; echo "exit $?"
# add a sub-command: copy cmd_report, name it cmd_count, print $(tail -n +2 "$REGISTER" | wc -l), wire it into main's case

✅ Verify — what you should see

The help text from the header comment; unknown flag --bogus and exit 1; a timestamped hello; got 2: a b c then exit 3. Your count sub-command prints 5 once wired in.

🏁 What you just proved

You can read and extend a real CLI's skeleton: functions, arguments, flags, dispatch, help.

⚠️ Common mistakes

Forgetting local: a function's i clobbers the caller's i.
return "some text": return takes a number; echo values out.
main $@ unquoted: arguments with spaces split.

🏭 Why this matters in production: every ops tool that grew past a screen has this skeleton; the ones that did not are the 400-line files nobody dares to edit.

⏭️ Next

Lesson 08 — errors & safety: the fire drill — fail loudly, clean up, rehearse without touching anything.

← Previousconditions loops Next →errors safety

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