ZSH Reference

#!/bin/zsh
# echo prints strings to STDOUT and appends a newline
echo "Hello, World!"

# Execute a ZSH script directly
zsh script.zsh

# Single-line comment for annotations and notes

# Load the datetime module for advanced time handling
zmodload zsh/datetime
# Load the zparseopts module for CLI argument parsing
zmodload zsh/zparseopts
# Load the net/tcp module for network operations
zmodload zsh/net/tcp

# Exit the current shell or script with a status code
# 0 for success, non-zero for error
exit 1 

# Define a special function to catch and handle command errors
TRAPERR() {
    echo "An error occurred during execution"
}

x="Value"       # Dynamic string variable
readonly PI=3.14 # Immutable constant
integer num=5    # Explicitly typed integer
float val=3.1    # Explicitly typed floating point

# Print the maximum 64-bit signed integer value
echo $((9223372036854775807))

integer i=10
# Explicitly cast integer value to float
float f=$i

# Export variable to environment for child processes
export API_KEY="secret"
# Access system-wide PATH variable
echo $PATH

zmodload zsh/datetime

# High-resolution time measurement using EPOCHREALTIME
start=$EPOCHREALTIME
sleep 1
elapsed=$(( EPOCHREALTIME - start ))

# Format the current time using strftime
strftime "%Y-%m-%d %H:%M:%S" $EPOCHSECONDS
# Format current time as UTC ISO 8601
strftime -u "%Y-%m-%dT%H:%M:%SZ" $EPOCHSECONDS 

val=$((10 / 3.0)) # Result: 3.333333333
res=$((10 % 3))   # Result: 1 (remainder)
((x++))           # Post-increment variable x

text="Price: $100"
# Match '$' followed by digits
if [[ $text =~ '\$([0-9]+)' ]]; then
    echo $match[1] # Print first capture group: "100"
fi

zmodload zsh/zparseopts

# v: flag, o: valued flag, tags+: flag that can appear multiple times
zparseopts -D -E v=verbose o:=output -tags+:=tags

# Check if verbose flag was provided
v_set=${#verbose}
# Extract value from output flag array
o_val=${output[2]}

# Define function logic
add() {
    local a=$1 # Positional parameters
    local b=$2
    # Output result to STDOUT to "return" value
    echo $(( a + b )) 
}

# Call function and capture result
result=$(add 10 20)
echo $result

increment() {
    local var_name=$1
    # Evaluate the content of var_name as a variable name and increment it
    (( ${(P)var_name}++ )) 
}

val=10
increment val
echo $val

x=10
# Standard if/elif/else
if [[ $x -gt 10 ]]; then
    echo "Greater"
elif [[ $x -eq 10 ]]; then
    echo "Equal"
else
    echo "Lesser"
fi

# Arithmetic truthiness: non-zero is true in (( ))
if (( 1 )); then echo "Math true"; fi

# Shell success check: 0 is success (true)
if true; then echo "Success"; fi

val="yes"
case $val in
    yes|y) echo "Confirmed" ;;
    no|n)  echo "Denied" ;;
    *)     echo "Unknown" ;;
esac

# Loop through a brace-expanded range
for i in {0..2}; do echo -n $i; done

x=0
# while loop using arithmetic condition
while (( x < 3 )); do
    echo -n $x
    ((x++))
done

for x in {1..5}; do
    if (( x == 2 )); then continue; fi # Skip to next iteration
    if (( x == 4 )); then break; fi    # Exit loop immediately
    echo -n $x
done

# Iterate over elements of an array (ZSH is 1-indexed)
list=("a" "b")
for val in $list; do echo -n $val; done

# Iterate over keys of an associative array
typeset -A map=(["id"]="42")
for k in ${(k)map}; do 
    echo -n " $k:$map[$k]"
done

s="hello world"
echo $#s           # String length (11)
echo $s[1,5]       # Substring from index 1 to 5 (1-based: "hello")
echo ${s/world/zsh} # Replace "world" with "zsh"

p="/usr/local/bin/file.txt"
echo $p:h # Head: Directory portion ("/usr/local/bin")
echo $p:t # Tail: Filename portion ("file.txt")
echo $p:e # Extension portion ("txt")

# Read file line by line using the read builtin
while read -r line; do
    echo "Line: $line"
done < data.txt

# Read the entire contents of a file into a variable
content=$(<file.txt)

# Hex output using printf
printf '\x42\x00'

res=$((0b1010 & 0b1100)) # Bitwise AND
res=$((0b1010 | 0b1100)) # Bitwise OR
res=$((0b1010 ^ 0b1100)) # Bitwise XOR
res=$((~0b1010))         # Bitwise NOT (complement)
res=$((0b0001 << 2))     # Bitwise Shift Left (0b0100)

# Format decimal integer as 2-digit hex
printf '%02x\n' 255

# List (Indexed Array - 1-based indexing)
l=(1 2); l+=(3)

# Map (Associative Array)
typeset -A m; m=(key val)

# Set (Unique Array - duplicates automatically removed)
typeset -U s; s=(1 1 2)

# Extract values using jq
echo '{"id":42}' | jq '.id'

# High-precision math using bc
echo "scale=4; 10/3" | bc

zmodload zsh/net/tcp
# Connect to remote host on port 80
ztcp example.com 80
fd=$REPLY # REPLY contains the file descriptor
# Send HTTP request through the socket
echo "GET / HTTP/1.0\r\n\r\n" >&$fd
# Read response line
read -u $fd line
# Close the TCP connection
ztcp -c $fd

# Use external 'nc' (netcat) for UDP operations
echo "ping" | nc -u -w1 127.0.0.1 8080

# Execute command in the background
command &
# Wait for the last background process to complete
wait $!

# Execute SQL query using the sqlite3 CLI tool
sqlite3 :memory: "SELECT 42;"