Linux Complete Interview Pack 2: Coding Exercises सह 150 Shell Scripting Interview प्रश्न आणि उत्तरं

क्रमाने चालणाऱ्या shell commands असलेली text file. Backups, log cleanup, deployments आणि reports सारखी वारंवार होणारी कामं automate करते.

#!/usr/bin/env bash सारखी पहिली line, script थेट execute केल्यावर कोणता interpreter वापरायचा ते system ला सांगते.

chmod +x script.sh मग ./script.sh, किंवा execute permission शिवाय bash script.sh. source script.sh current shell मधे चालवतो.

bash नवा child shell सुरू करतो, म्हणून variables आणि cd तुमच्या shell वर परिणाम करत नाहीत. source (किंवा .) current shell मधे चालतो, म्हणून बदल राहतात.

= च्या दोन्ही बाजूंना space न ठेवता name=value. $name किंवा "${name}" ने वाचा. Spaces असलेल्या values quote करा: city="New Delhi".

Quotes शिवाय shell values spaces वर तोडतो आणि globs expand करतो, म्हणून my file.txt नावाची file दोन words होते. "$var" ती एकच ठेवतो.

Single quotes सगळं literal ठेवतात. Double quotes $var, $(cmd) आणि backslash escapes चालू देतात पण word splitting थांबवतात.

today=$(date +%F). जुना backtick form `date` चालतो पण nest करायला कठीण.

read -rp 'Enter name: ' name. Passwords साठी input लपवायला -s आणि timeout साठी -t 10.

$1, $2 वगैरे arguments, $0 script name, $# count, "$@" सगळे वेगवेगळे आणि $* सगळे एक string म्हणून. shift त्यांना डावीकडे सरकवतो.

if [[ -f /etc/app.conf ]]; then echo found; else echo missing; fi. जास्त branches साठी elif.

-f regular file, -d directory, -e exists, -r readable, -w writable, -x executable, -s रिकामी नाही, -L symlink.

Numbers: -eq, -ne, -lt, -le, -gt, -ge, किंवा (( a > b )). Strings: [[ ]] मधे == आणि !=, रिकाम्यासाठी -z आणि रिकामं नसलेल्यासाठी -n.

[ ] POSIX test command आहे आणि काळजीपूर्वक quoting लागतं. [[ ]] bash keyword आहे जो रिकामे variables handle करतो, && आणि || support करतो, == ने pattern matching आणि =~ ने regex.

for f in *.log; do gzip "$f"; done. Numbers साठी: for i in {1..5} किंवा for ((i=1;i<=5;i++)).

while condition; do ...; done. उदा. while ! curl -sf localhost:8080; do sleep 2; done app up होईपर्यंत थांबतो. until condition false असेपर्यंत चालतो.

break loop मधून बाहेर पडतो. continue पुढच्या iteration ला जातो. Nested loops साठी दोन्ही number घेतात, उदा. break 2.

case "$1" in start) start_app;; stop) stop_app;; *) echo "usage: $0 start|stop";; esac. अनेक elif branches पेक्षा स्वच्छ.

greet() { echo "Hi $1"; } मग greet Asha. आतल्या variables साठी local, आणि status साठी return N किंवा output साठी echo.

प्रत्येक command परत देणारा 0 ते 255 number. 0 म्हणजे success. $? शेवटचा ठेवतो आणि exit N script N सह संपवतो.

काय करतात? || a && b फक्त a success झाल्यावर b चालवतो. a || b फक्त a fail झाल्यावर b चालवतो. mkdir -p dir && cd dir || exit 1 हा common pattern.

Integers साठी $(( a + b )), increment साठी (( count++ )), let आणि expr जुने forms. Decimals साठी bc किंवा awk, उदा. echo '3.5*2' | bc.

# line च्या शेवटपर्यंत comment सुरू करतो. Block साठी बरेच जण अनेक # lines वापरतात; : ला here-doc पण चालतो पण कमी स्पष्ट.

bash -x script.sh किंवा आत set -x प्रत्येक command चालण्याआधी print करतो. bash -n न चालवता syntax तपासतो आणि shellcheck common bugs शोधतो.

List variable: servers=(web1 web2 db1). ${servers[0]} पहिला, "${servers[@]}" सगळे items, ${#servers[@]} count. declare -A key-value maps बनवतो.

Command ला अनेक lines द्यायचा मार्ग: cat <<EOF > file मग lines मग EOF. आत variable expansion थांबवायला 'EOF' quote करा.

if command -v jq >/dev/null; then ... fi. Scripts मधे which टाळा कारण त्याचा output systems नुसार बदलतो.

त्यात लिहिलेलं सगळं टाकून देणारी special file. cmd >/dev/null 2>&1 सगळा output शांत करतो.

printf 'Name: %s Age: %d\n' Asha 30 exact formatting देतो. echo -n newline शिवाय print करतो पण echo shells नुसार बदलतो, म्हणून printf जास्त safe.

backup-$(date +%F).tgz ने backup-2026-10-26.tgz मिळतं. पूर्ण stamp साठी date +%Y%m%d-%H%M%S.

Unquoted दोन्ही सारखे. "$@" प्रत्येक argument वेगळा ठेवतो (पुढे पाठवायला बरोबर), तर "$*" सगळे IFS च्या पहिल्या character ने जोडून एक string करतो.

$$ current shell चा PID, बहुतेक temp file names साठी. $! शेवटच्या background job चा PID, wait किंवा kill सह वापरतात.

Command साठी छोटं नाव, जसं alias ll='ls -lah'. Aliases interactive shells साठी; scripts मधे functions वापरा.

.bash_profile (किंवा .profile) SSH sessions सारख्या login shells साठी चालतो; .bashrc नव्या terminal tabs सारख्या interactive non-login shells साठी. बहुतेक setups .bash_profile मधून .bashrc source करतात.

export NAME=value. export शिवाय variable फक्त current shell मधे असतो. env NAME=value cmd एका command साठी set करतो.

String रिकामी असेल किंवा variable unset असेल तेव्हा true. -n उलटं.

echo 'config missing' >&2; exit 1. Errors stderr (>&2) वर लिहा म्हणजे normal output मधे मिसळत नाहीत.

तीन standard streams: 0 input, 1 normal output, 2 errors. <, > किंवा 1>, आणि 2> ने redirect करा.

while IFS= read -r line; do ...; done < <(cmd). यामुळे spaces राहतात आणि loop current shell मधे चालतो म्हणून variables टिकतात.

sh हा POSIX shell (Ubuntu वर dash, RHEL वर sh mode मधला bash). bash arrays, [[ ]], brace expansion, process substitution आणि बरंच जोडतो. #!/bin/sh script ने bash-only features टाळायला हवेत.

{a,b,c} आणि {1..5} command चालण्याआधी lists बनवतात: mkdir -p app/{logs,conf,data} तीन folders बनवतो आणि cp file{,.bak} backup copy बनवतो.

Command चालण्याआधी shell *.log, file?.txt आणि [0-9]* सारखे patterns matching file names मधे expand करतो. काहीच match झालं नाही तर nullglob set नसेल तर pattern तसाच राहतो.

env=${1:-dev} $1 रिकामा असेल तर dev वापरतो. ${VAR:?message} missing असेल तर error ने थांबतो.

${#var}. उदा. name=Pune; echo ${#name} 4 दाखवतो.

Syntax stderr वर print करून exit 1 करणारं usage function लिहा, आणि [[ $# -lt 1 ]] असेल किंवा -h वर ते call करा.

Internal Field Separator shell words कसे तोडतो आणि read fields कसे तोडतो ते ठरवतो. IFS=, read -r a b c <<< "$line" CSV line तोडतो.

sleep 5 पाच seconds थांबतो; GNU sleep सह sleep 1m आणि sleep 0.5 पण चालतात.

( ), pipes किंवा $( ) ने बनलेली shell ची child copy. आतले बदल, जसे cd किंवा variables, parent वर परिणाम करत नाहीत.

वर set -euo pipefail ठेवा, आणि अपेक्षित failures || true किंवा if blocks ने handle करा.

0 * * * * /opt/scripts/report.sh >> /var/log/report.log 2>&1 सारखी cron line टाका, किंवा OnCalendar=hourly सह systemd timer बनवा.

-e errors वर exit करतो पण if conditions, && chains आणि conditions मधे call केलेल्या functions मधे ignore होतो. -u unset variables वर fail करतो, म्हणून optional साठी ${VAR:-} वापरा. pipefail pipeline मधला शेवटचा non-zero status परत देतो. Match न झालेला grep 1 परत देतो आणि script अनपेक्षितपणे थांबवू शकतो.

Signals किंवा exit वर code चालवतो: trap 'rm -f "$tmp"' EXIT temp files साफ करतो, trap 'echo failed at line $LINENO' ERR errors सांगतो, आणि trap '' INT Ctrl+C ignore करतो.

tmp=$(mktemp) किंवा dir=$(mktemp -d) unique, private path देतो. trap 'rm -rf "$dir"' EXIT सोबत वापरा. /tmp/out.txt सारखी fixed names कधीही वापरू नका.

flock वापरा: exec 9>/var/lock/backup.lock; flock -n 9 || { echo running; exit 1; }. किंवा cron line ला flock -n /var/lock/job.lock script.sh ने wrap करा.

getopts short flags handle करतो: while getopts 'e:vh' o; do case $o in e) env=$OPTARG;; v) verbose=1;; h) usage;; esac; done; shift $((OPTIND-1)). Long options साठी $1 वर case आणि shift असलेला while loop.

log(){ printf '%s %s\n' "$(date '+%F %T')" "$*" | tee -a "$LOG"; } मग log 'backup started'. logger -t backup 'started' syslog किंवा journal ला पाठवतो.

वर exec > >(tee -a "$LOG") 2>&1 त्यानंतरचं सगळं redirect करतो.

<(cmd) command चा output file path म्हणून देतो. diff <(sort a) <(sort b) temp files शिवाय sorted files compare करतो. >(cmd) उलटं करतो.

Pipeline चा प्रत्येक भाग subshell मधे चालतो, म्हणून cat f | while read l; do n=$((n+1)); done नंतर n बदलत नाही. done < f, done < <(cmd), किंवा shopt -s lastpipe वापरा.

for i in 1 2 3 4 5; do cmd && break; sleep $((i*2)); done. Loop नंतर final status तपासा आणि कधीच success झालं नसेल तर exit करा.

timeout 30 curl -s URL 30 seconds नंतर kill करतो आणि 124 परत देतो. timeout -k 5 30 cmd TERM नंतर 5 seconds ने KILL पाठवतो.

प्रत्येक & ने सुरू करा आणि wait call करा. प्रत्येक status wait $pid ने तपासायला PIDs save करा. xargs -P 4 किंवा GNU parallel एका वेळी किती चालतील ते limit करतात.

Quotes सह for f in ./*.csv; do ... "$f"; done चालतो. find results साठी find . -name '*.csv' -print0 | while IFS= read -r -d '' f; do ...; done. for f in $(ls) कधीही वापरू नका.

declare -A port=([web]=80 [db]=5432); echo "${port[db]}"; for k in "${!port[@]}"; do echo "$k=${port[$k]}"; done. bash 4 लागतो.

${f%.*} शेवटचं extension काढतो, ${f##*/} file name ठेवतो आणि ${f%/*} folder ठेवतो, सगळं external commands शिवाय.

${v/old/new} पहिला match आणि ${v//old/new} सगळे बदलतो. ${v^^} आणि ${v,,} case बदलतात.

[[ $ip =~ ^([0-9]{1,3}\.){3}[0-9]{1,3}$ ]] && echo ok. Captured groups BASH_REMATCH मधे. Regex unquoted किंवा variable मधे ठेवा.

grep pattern शी जुळणाऱ्या lines शोधतो. sed streams edit करतो (substitute, delete, insert lines). awk columns आणि calculations साठी छोटी language, जसं field ची बेरीज किंवा grouping.

awk -F, '{s+=$3} END {print s}' sales.csv तिसऱ्या CSV column ची बेरीज करतो. Header skip करायला NR>1 जोडा.

sed -n '/START/,/END/p' file. sed -n '10,20p' file lines 10 ते 20 दाखवतो.

while IFS='=' read -r k v; do [[ $k =~ ^[A-Z_]+$ ]] && declare "$k=$v"; done < app.conf ने loop करा. Untrusted file source केली तर आतला कोणताही code चालतो, म्हणून ते टाळा.

jq वापरा: jq -r '.items[].name' data.json, curl -s api | jq '.status', CSV साठी jq -r '.[] | [.id,.name] | @csv'. JSON grep किंवा sed ने parse करू नका.

code=$(curl -s -o /dev/null -w '%{http_code}' "$url"); [[ $code == 200 ]] || alert. कधीही अडकू नये म्हणून --max-time 10 जोडा.

if ! diff -q a b >/dev/null; then echo changed; fi, किंवा cmp -s a b ने compare करा. comm -13 <(sort a) <(sort b) फक्त b मधल्या lines दाखवतो.

Value print करून capture करा: get_ip(){ hostname -I | awk '{print $1}'; }; ip=$(get_ip). return फक्त 0 ते 255 status code देतो. nameref (declare -n) caller च्या variable मधे पण लिहू शकतो.

local शिवाय function मधले variables त्याच नावाचे globals overwrite करतात, आणि कठीण bugs येतात. local त्यांना function मधेच ठेवतो.

Shared functions lib.sh मधे ठेवा आणि source "$(dirname "$0")/lib.sh" ने load करा. दोनदा load होण्यापासून guard करा आणि library मधे top-level actions ठेवू नका.

dir=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd). दुसऱ्या folder मधून किंवा source मार्फत call केलं तरी चालतं.

[[ $EUID -eq 0 ]] || { echo 'run as root' >&2; exit 1; }.

Actions wrap करा: run(){ if [[ $DRY == 1 ]]; then echo "+ $*"; else "$@"; fi; } मग run rm -f "$f". होण्याआधी काय होईल ते users बघू शकतात.

find . -name '*.tmp' -print0 | xargs -0 rm -f spaces handle करतो. -n 1 प्रत्येक command ला एक item देतो, -P 4 एका वेळी चार चालवतो आणि -I{} item हव्या त्या जागी ठेवतो.

exec shell ला cmd ने बदलतो, म्हणून script तिथेच संपते आणि cmd ला तोच PID राहतो. Container entrypoints मधे common आहे म्हणजे signals app पर्यंत पोचतात. फक्त redirects सह exec script चे file descriptors बदलतो.

use=$(df --output=pcent / | tail -1 | tr -dc 0-9); (( use > 85 )) && echo "disk ${use}%" | mail -s alert ops@example.com.

साधा awk -F, "Pune, MH" वर तुटतो. csvkit, mlr (Miller) किंवा Python चा csv module सारखा योग्य tool वापरा; किंवा GNU awk मधे FPAT='([^,]+)|("[^"]+")' सह awk.

Quoting bugs, न वापरलेले variables, चुकीचे tests आणि portability issues शोधणारा linter, प्रत्येकाला SC2086 सारखा code. Editor आणि CI मधे चालवा.

export PS4='+ ${BASH_SOURCE}:${LINENO}: ' मग set -x. मग प्रत्येक traced line file आणि line दाखवते.

. /etc/os-release आणि $ID ने detect करा, मग case statement मधे dnf किंवा apt, service names (httpd किंवा apache2) आणि paths निवडा. Tools तपासायला command -v वापरा.

trap 'echo stopping; kill $(jobs -p) 2>/dev/null; exit 130' INT TERM. Handler मधे children आणि temp files साफ करा.

select opt in start stop status quit; do case $opt in quit) break;; *) systemctl "$opt" app;; esac; done. PS3 prompt set करतो.

sudo echo x > /etc/file fail होतो कारण redirect तुम्ही म्हणून चालतो. echo x | sudo tee /etc/file >/dev/null, किंवा append साठी sudo tee -a वापरा.

cat file | grep pattern ऐवजी grep pattern file, आणि cat file | while read ऐवजी while read ... done < file वापरा. एक process वाचतो आणि variables टिकतात.

openssl rand -base64 18, किंवा tr -dc 'A-Za-z0-9' </dev/urandom | head -c 16. $RANDOM jitter साठी ठीक पण secrets साठी नाही.

timeout 3 bash -c "</dev/tcp/$host/$port" && echo open || echo closed. हे bash चं built-in /dev/tcp वापरतं.

ssh host "bash -s" -- "$env" < deploy.sh local script आणि arguments पाठवतो. किंवा काळजीपूर्वक quoting सह ssh host "cd /app && ENV=$env ./run.sh".

<<-EOF वापरा आणि lines tabs ने indent करा (spaces नाही); सुरुवातीचे tabs काढले जातात.

find /var/log/app -type f -name '*.log' -mtime +7 -print, list बरोबर दिसल्यावर तेच -delete सह.

Action आधी तपासा: mkdir -p, id user || useradd user, grep -q line file || echo line >> file, आणि enable आधी systemctl is-enabled. दोनदा चालवली तर दुसऱ्यांदा काहीच बदलू नये.

126 सापडली पण executable नाही, 127 command not found, 130 Ctrl+C ने थांबली (128 अधिक signal 2). 137 म्हणजे signal 9 ने kill आणि 143 signal 15 ने.

पूर्ण run साठी time ./script.sh, किंवा आत start=$SECONDS; ...; echo "took $((SECONDS-start))s".

Unit tests साठी bats-core, lint साठी shellcheck, syntax साठी bash -n, clean environments साठी container मधे चालवा, आणि CI job जोडा. Functions छोटी ठेवा म्हणजे test करायला सोपी.

Script ला complex data structures, काही jq calls पलीकडचं JSON किंवा API काम, जड error handling, unit tests, concurrency control लागतं किंवा ती काहीशे lines पलीकडे वाढते तेव्हा. Commands जोडणे, bootstrapping आणि साधं automation यासाठी bash सर्वोत्तम.

Strict mode, lock, validation सह स्पष्ट arguments, dry-run flag, timestamps सह logging, pre-checks (disk, health, versions), atomic switch (symlink swap किंवा नवा release folder), deploy नंतर health check, failure वर automatic rollback, idempotent steps आणि अर्थपूर्ण exit codes.

त्याच filesystem वर temp file मधे लिहा, गरज असेल तर sync, मग mv tmp target. rename atomic आहे, म्हणून readers ना जुनी किंवा नवी file दिसते, कधीच अर्धी नाही.

Unquoted variables (injection आणि globbing), user input वर eval, predictable temp files, ps मधे दिसणारे arguments मधले secrets, world-writable script paths, PATH वर विश्वास, आणि untrusted files source करणे. Quoting, mktemp, absolute paths, secrets files किंवा env मधून वाचणे, आणि कडक permissions ने fix करा.

Root-only file (chmod 600), systemd किंवा CI ने inject केलेला environment variable, किंवा aws secretsmanager किंवा vault सारखा secret manager CLI मधून वाचा. Command-line arguments टाळा आणि secret वापराभोवती set +x ठेवा म्हणजे traces मधे ते print होणार नाहीत.

eval कोणताही text code म्हणून चालवतो, म्हणून ; rm -rf / सारखा user data command होतो. Commands बांधायला arrays (cmd=(rsync -a "$src" "$dst"); "${cmd[@]}"), dynamic variables साठी declare किंवा printf -v, आणि dispatch साठी case वापरा.

flock फक्त एका host वर चालतो. Hosts पलीकडे distributed lock (expiry सह DynamoDB किंवा Redis key, Consul किंवा etcd) वापरा, किंवा एका leader वर schedule करा, किंवा job idempotent करा म्हणजे duplicates निरुपद्रवी.

logger ने journal ला structured log lines (key=value किंवा JSON), अर्थपूर्ण exit codes, heartbeat किंवा push metric (Prometheus pushgateway किंवा CloudWatch put-metric-data), trap ERR मार्फत failure वर alerts, आणि status आणि history साठी systemd units म्हणून चालवा.

Timers journalctl मधे logs, dependency ordering, चुकलेले runs पकडायला Persistent=true, randomized delays, resource limits आणि सोपा status देतात. Cron सोपा आणि सगळीकडे आहे. Production services साठी timers सहसा चांगले.

#!/bin/sh, [[ ]] ऐवजी [ ], arrays नाहीत, $(...) ठीक, echo ऐवजी printf, strict POSIX मधे local नाही (dash support करतो तरी), brace expansion किंवा process substitution नाही, आणि dash आणि checkbashisms ने test करा.

मोठ्या loops मधे processes spawn करणे टाळा (parameter expansion, builtins आणि अनेक greps ऐवजी एक awk pass वापरा), xargs किंवा parallel ने batch करा, ControlMaster वापरून वारंवार ssh टाळा, आणि time आणि set -x timestamps ने measure करा.

Strict mode आणि quoting, input validation, error handling आणि cleanup, idempotency, hardcoded paths किंवा secrets, checks ने guarded destructive commands, shellcheck output, logging, आणि ते config management task असायला हवं का ते तपासा.

set -u आणि ${DIR:?} वापरा म्हणजे रिकामा variable script थांबवतो, path अपेक्षित root खाली आहे ते तपासा, गरज नसताना root म्हणून चालवू नका, आणि आधी trash folder मधे हलवणे prefer करा.

अनेक servers ची state manage करताना: Ansible idempotent modules, inventory, templating, check mode, roles आणि reporting देतो. एका host वरच्या tasks किंवा Ansible च्या shell module मधल्या glue साठी shell ठीक.

प्रत्येक host चे results associative array मधे गोळा करा, failure वर पुढे चला, summary table print करा, आणि कोणताही host fail झाला तर non-zero exit करा. फक्त failed retry करायला --hosts flag जोडा.

macOS bash 3.2 देतो (associative arrays नाहीत, ${var^^} नाही, mapfile नाही). जुन्या RHEL वर bash 4.2. wait -n सारख्या features ला 4.3 आणि ${var@Q} ला 4.4 लागतो. गरज असेल तेव्हा BASH_VERSINFO तपासा.

Timestamp सह backup घ्या, validate करणाऱ्या tool ने edit करा (visudo -cf, nginx -t, sshd -t), atomically लिहा, log मधे diff ठेवा, आणि validation किंवा service restart fail झाला तर automatically roll back करा.

Style guide (Google shell style), main function, छोटी नावाची functions, purpose आणि usage असलेला header, review सह version control, CI मधे shellcheck आणि bats, आणि examples सह README.

Foreground command संपल्यानंतरच traps चालतात. पटकन react करायला command background मधे चालवा आणि wait करा; trapped signal आला की wait लवकर परत येतो.

set -e वापरा, env vars मधून config तयार करा, मग exec "$@" म्हणजे app PID 1 होतो आणि SIGTERM मिळतो. App child processes reap करत नसेल तर tini किंवा --init वापरा.

Strict mode आणि file ला logging, package updates, agents install (SSM, CloudWatch), users आणि SSH keys बनवणे, SSH harden करणे, UUID ने disks mount, S3 किंवा Parameter Store मधून config आणणे, services सुरू करणे, आणि orchestrator ला success किंवा failure कळवणे.

Load न करता stream करा: fixed strings साठी grep -F, जलद matching साठी LC_ALL=C, compressed logs साठी zgrep किंवा zcat, awk single pass aggregates, memory साठी sort -S आणि --parallel, आणि आधी time window ने split करा.

0 success, 1 general error, 2 usage error, आणि 3 config missing किंवा 4 dependency down सारखे documented specific codes. ते stable ठेवा, कारण monitoring आणि CI त्यावर अवलंबून असतात.

STAR वापरा: situation (उदा. दर महिन्याला 40 servers हाताने patch), task, काय बांधलं (health checks आणि rollback सह parallel, logged, idempotent patch script), आणि numbers मधे result (वाचलेले तास, कमी झालेल्या errors).

UTC मधे store आणि log करा (date -u), फक्त display साठी TZ=Asia/Kolkata date ने convert करा, ISO 8601 formats वापरा, आणि GNU date मधे date -d '7 days ago' +%F सारख्या arithmetic साठी date -d.

Argument whole number आहे ते तपासा, मग remainder operator वापरा.

#!/usr/bin/env bash
set -euo pipefail
n=${1:?usage: $0 NUMBER}
[[ $n =~ ^-?[0-9]+$ ]] || { echo 'not a number' >&2; exit 2; }
if (( n % 2 == 0 )); then echo "$n is even"; else echo "$n is odd"; fi

Substring expansion वापरून शेवटच्या character पासून पहिल्यापर्यंत string वर फिरा.

#!/usr/bin/env bash
s=${1:?usage: $0 TEXT}
out=''
for (( i=${#s}-1; i>=0; i-- )); do out+=${s:i:1}; done
echo "$out"

Lower-case करा, उलटा करा, आणि compare करा.

#!/usr/bin/env bash
w=${1,,}
r=$(printf '%s' "$w" | rev)
[[ $w == "$r" ]] && echo palindrome || echo 'not palindrome'

दोन variables ठेवा आणि प्रत्येक step ला त्यांना पुढे सरकवा.

#!/usr/bin/env bash
n=${1:-10}; a=0; b=1
for (( i=0; i<n; i++ )); do printf '%s ' "$a"; (( t=a+b, a=b, b=t )); done; echo

Loop मधे गुणा करा; bash integers 64-bit आहेत, म्हणून 20! पर्यंत safe.

#!/usr/bin/env bash
n=${1:?}; f=1
for (( i=2; i<=n; i++ )); do (( f*=i )); done
echo "$n! = $f"

Line by line वाचा आणि बेरीज करा; यातून loops आणि expansion कसे चालतात ते दिसतं.

#!/usr/bin/env bash
l=0 w=0 c=0
while IFS= read -r line || [[ -n $line ]]; do
  (( l++ )); set -- $line; (( w+=$# )); (( c+=${#line}+1 ))
done < "${1:?file}"
echo "$l $w $c"

Client IP पहिला field आहे; sort आणि uniq ने मोजा.

awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -5

Combined log format मधे status field 9 आहे.

awk '{c[$9]++} END {for (s in c) print s, c[s]}' /var/log/nginx/access.log | sort

Fixed columns सह df वापरा, tmpfs skip करा, आणि threshold पेक्षा जास्त असेल तर alert द्या.

#!/usr/bin/env bash
set -euo pipefail
limit=${1:-80}
df -P -x tmpfs -x devtmpfs | awk 'NR>1 {gsub("%","",$5); print $5, $6}' |
while read -r use mnt; do
  (( use >= limit )) && echo "ALERT $mnt at ${use}%"
done
exit 0

Archive बनवा, मग जुने वेळेनुसार list करा आणि 7 पलीकडचे delete करा.

#!/usr/bin/env bash
set -euo pipefail
src=${1:?src}; dst=${2:?dst}
mkdir -p "$dst"
tar -czf "$dst/backup-$(date +%F-%H%M).tgz" -C "$(dirname "$src")" "$(basename "$src")"
ls -1t "$dst"/backup-*.tgz | tail -n +8 | xargs -r rm -f

Names वर loop करा, systemctl is-active वापरा, आणि actions log करा.

#!/usr/bin/env bash
for s in nginx sshd crond; do
  if ! systemctl is-active --quiet "$s"; then
    echo "$(date '+%F %T') $s down, restarting"
    systemctl restart "$s" || echo "restart of $s failed" >&2
  fi
done

प्रत्येक line वाचा, header skip करा, group आणि user missing असतील तरच बनवा.

#!/usr/bin/env bash
set -euo pipefail
while IFS=, read -r u g; do
  [[ $u == username ]] && continue
  getent group "$g" >/dev/null || groupadd "$g"
  id "$u" &>/dev/null || useradd -m -g "$g" "$u"
done < "${1:?csv}"

Size output सह find आणि sort वापरा.

find "${1:-.}" -type f -printf '%s %p
' 2>/dev/null | sort -rn | head -10 | awk '{printf "%.1f MB %s
", $1/1048576, $2}'

Extension बदलायला parameter expansion आणि overwrite टाळायला mv -n वापरा.

for f in *.jpeg; do [[ -e $f ]] || continue; mv -n -- "$f" "${f%.jpeg}.jpg"; done

curl सह loop आणि SECONDS वापरून deadline.

#!/usr/bin/env bash
url=${1:-http://localhost:8080/health}
end=$((SECONDS+60))
until [[ $(curl -s -o /dev/null -w '%{http_code}' --max-time 3 "$url") == 200 ]]; do
  (( SECONDS >= end )) && { echo 'timed out' >&2; exit 1; }
  sleep 2
done
echo up

comm sorted input वर चालतो.

comm -23 <(sort -u a.txt) <(sort -u b.txt)

प्रत्येक file hash करा, मग एकापेक्षा जास्त वेळा दिसलेले hashes दाखवा.

find "${1:-.}" -type f -exec md5sum {} + | sort | awk '{h=$1; $1=""; if (h==p) {print pf; print $0} p=h; pf=$0}' | sort -u

tail -F rotation follow करतो; grep --line-buffered lines लगेच पुढे देतो.

tail -Fn0 /var/log/app/app.log | grep --line-buffered ERROR | while read -r line; do
  logger -t appwatch "ERROR seen: $line"
done

प्रत्येक ssh background मधे चालवा, PIDs array मधे ठेवा, आणि प्रत्येकाची wait करा.

#!/usr/bin/env bash
declare -A pid
for h in web1 web2 db1; do ssh -o ConnectTimeout=5 "$h" uptime > "/tmp/$h.out" 2>&1 & pid[$h]=$!; done
fail=0
for h in "${!pid[@]}"; do wait "${pid[$h]}" || { echo "FAIL $h"; fail=1; }; done
exit $fail

Regex ने shape तपासा, मग प्रत्येक octet 0 ते 255.

valid_ip(){
  local ip=$1 o
  [[ $ip =~ ^([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$ ]] || return 1
  for o in "${BASH_REMATCH[@]:1}"; do (( 10#$o <= 255 )) || return 1; done
}
valid_ip 10.0.0.256 && echo ok || echo bad

Words मधे तोडा, lower-case करा, मोजा आणि sort करा.

tr -cs '[:alpha:]' '
' < book.txt | tr '[:upper:]' '[:lower:]' | sort | uniq -c | sort -rn | head -10

Comma separator सह awk fields swap करून line पुन्हा बांधतो.

awk -F, -v OFS=, '{t=$1; $1=$2; $2=t; print}' in.csv

stat ने size तपासा आणि लिहिण्याआधी timestamp सह बाजूला हलवा.

log=/var/log/myjob.log
if [[ -f $log ]] && (( $(stat -c %s "$log") > 10485760 )); then
  mv "$log" "$log.$(date +%F-%H%M%S)"; gzip "$log".*[0-9] 2>/dev/null || true
fi
echo "$(date '+%F %T') run" >> "$log"

ps RSS KB मधे दाखवतो; awk बेरीज करतो.

ps -C "${1:-nginx}" -o rss= | awk '{s+=$1} END {printf "%.1f MB
", s/1024}'

नव्या release folder मधे unpack करा, current link बदला, health check करा, आणि failure वर परत बदला.

#!/usr/bin/env bash
set -euo pipefail
rel=/opt/app/releases/$(date +%Y%m%d%H%M%S)
prev=$(readlink -f /opt/app/current || true)
mkdir -p "$rel" && tar -xzf "${1:?artifact}" -C "$rel"
ln -sfn "$rel" /opt/app/current && systemctl restart app
if ! curl -sf --max-time 5 localhost:8080/health; then
  echo 'health failed, rolling back' >&2
  [[ -n $prev ]] && ln -sfn "$prev" /opt/app/current && systemctl restart app
  exit 1
fi
echo "deployed $rel"

काही live rounds मधे man pages allow करतात; बरेच Google allow करत नाहीत. सुरुवातीला विचारा.

त्यांनी POSIX सांगितलं नसेल तर bash. कोणता निवडला आणि का ते सांगा.

awk columns आणि sums चांगले handle करतो; JSON, APIs किंवा complex logic साठी Python वापराल असं सांगा.

इथलं प्रत्येक solution हाताने type करा, चालवा, बिघडवा आणि fix करा. मग आठवणीतून परत लिहा.

सहसा common one-liners: substitution, ranges, column sums आणि grouping.

मदत करतं पण traps आहेत. pipefail सोबत वापरता आणि अपेक्षित failures explicitly handle करता असं सांगा.

Unquoted variables, खूप जास्त.

नाही, ते अनेक companies मधे typical आणि नेहमी विचारले जातात असं सांगितलं जाणारे आहेत.

शेवटच्या command चा exit status.

chmod +x script.sh.

for i in {1..10}; do echo $i; done.

while IFS= read -r line; do ...; done < file.

trap 'cleanup' EXIT INT TERM.

getopts 'vf:'.

Lock file वर flock -n.

cd "$(dirname "${BASH_SOURCE[0]}")" && pwd.

Idempotent steps, release folders, symlink switch, health check आणि automatic rollback.

Files किंवा env मधून वाचा, त्याभोवती set +x, arguments म्हणून कधीही पाठवू नका.

Complex data, JSON APIs, जड logic, long-lived services किंवा tests आणि types महत्त्वाचे असतील तेव्हा.

shellcheck, bash -n, bats-core tests आणि clean container मधे चालवणे.