BASH on Ricky

Articles

Mon, 20 Jul 2026 09:19:00 +0800

iPhone引導模式怎麼開？借手機人不怕隱私外洩和一鍵鎖定App

開啟與設定功能

打開 iPhone 上的 「設定」 App。
點選 「輔助使用」。
往下找到並點選 「引導使用模式」，然後將其開啟。
建議順便進行以下設定：

密碼設定：點一下「密碼設定」>「設定引導使用模式密碼」，輸入一組解鎖密碼，並可同時開啟 Face ID 或 Touch ID 作為快速解鎖/結束的方式。
輔助使用快速鍵：建議將其開啟，之後只要連按三下側邊按鈕就能快速叫出或退出此模式。

開始使用（將 iPhone 鎖定在單一 App）

打開你想要讓別人（或自己專注）使用的 App。
啟動引導使用模式：

具備 Face ID 的 iPhone（全螢幕機型）：連按三下側邊按鈕（電源鍵）。
具備主畫面按鈕的舊款 iPhone：連按三下主畫面按鈕（Home 鍵）。
或者也可以呼叫 Siri：「打開引導使用模式」。

如果跳出輔助使用快速鍵面板，請點選 「引導使用模式」。
自訂限制區域（選用）：

如果想讓螢幕上的特定區域無法被觸控點擊（例如遊戲內的廣告區塊），直接用手指在該區域畫一個圓圈，之後可以拖曳邊框來調整大小。

點一下右下角的「階段設定」（或選項），可以自由決定是否停用以下功能：

側邊按鈕 / 頂端按鈕
音量按鈕
動作（防止螢幕自動旋轉或因晃動而有反應）
軟體鍵盤
觸控（若想完全讓整個螢幕無法觸控可關閉此項）
時間限制

設定完成後，點一下右上角的 「完成」，再點一下 「開始」 即可正式鎖定。

如何結束引導使用模式

連按三下側邊按鈕（或主畫面按鈕）。
輸入你剛剛設定的引導使用模式密碼（或直接使用 Face ID / Touch ID 驗證）。
畫面左上角會出現 「結束」 按鈕，點下去即可退出此模式。

TIL: timeout in Bash scripts

Thu, 12 Jun 2025 09:04:00 +0800

TIL: timeout in Bash scripts
timeout 1m ./until.sh
wrap

timeout 1m bash -c "until curl --silent --fail-with-body 10.0.0.1:8080/health; do
 sleep 1
done"

Advanced Shell Scripting Techniques: Automating Complex Tasks with Bash

Wed, 25 Sep 2024 09:23:00 +0800

Advanced Shell Scripting Techniques: Automating Complex Tasks with Bash

Use Built-in Commands

Built-in commands execute faster because they don’t require loading an external process.

Minimize Subshells

Subshells can be expensive in terms of performance.

# Inefficient
output=$(cat file.txt)

# Efficient
output=$(<file.txt)

Use Arrays for Bulk Data

When handling a large amount of data, arrays can be more efficient and easier to manage than multiple variables.

# Inefficient
item1="apple"
item2="banana"
item3="cherry"

# Efficient
items=("apple" "banana" "cherry")
for item in "${items[@]}"; do
 echo "$item"
done

Enable Noclobber

To prevent accidental overwriting of files.

set -o noclobber

Use Functions

Functions allow you to encapsulate and reuse code, making scripts cleaner and reducing redundancy.

Efficient File Operations

When performing file operations, use efficient techniques to minimize resource usage.

# Inefficient
while read -r line; do
 echo "$line"
done < file.txt

# Efficient
while IFS= read -r line; do
 echo "$line"
done < file.txt

Parallel Processing

Tools like xargs and GNU parallel can be incredibly useful.

Error Handling

Robust error handling is critical for creating reliable and maintainable scripts.

# Exit on Error: Using set -e ensures that your script exits immediately if any command fails, preventing cascading errors.
set -e

# Custom Error Messages: Implement custom error messages to provide more context when something goes wrong.
command1 || { echo "command1 failed"; exit 1; }

# Trap Signals: Use the `trap` command to catch and handle signals and errors gracefully.
trap 'echo "Error occurred"; cleanup; exit 1' ERR

function cleanup() {
 # Cleanup code
}

# Validate Inputs: Always validate user inputs and script arguments to prevent unexpected behavior.
if [[ -z "$1" ]]; then
 echo "Usage: $0 <argument>"
 exit 1
fi

# Logging: Implement logging to keep track of script execution and diagnose issues.
logfile="script.log"
exec > >(tee -i $logfile)
exec 2>&1

echo "Script started"

Automating Complex System Administration Tasks:

Automated Backups
System Monitoring
User Management
Automated Updates
Network Configuration

Makefiles for Web Projects: Manage Your Environment Workflow

Mon, 05 Aug 2024 17:21:24 +0800

Note: Makefile indentation must use tabs, otherwise you’ll get syntax errors.

The Core of a Makefile: Targets

up:
 cp .env.example .env
 docker compose up -d workspace

stop:
 docker compose stop

zsh:
 docker compose exec workspace zsh

This example has three targets: up, stop, and zsh. By default, Make treats the first target as the Goal (it cannot start with a dot), which is the project’s primary workflow. In this case, make and make up do the same thing.
But the copy step above is not a typical Make use case. Make shines at deciding whether each target needs to run. For example, we often store secrets in .env. If .env already exists, we shouldn’t overwrite it by copying .env.example again. In that case, we can make .env a target:

up: .env
 docker compose up -d workspace

.env:
 cp .env.example .env

By default, target names are treated as filenames. The name “make” implies building a target; it will only execute the target’s recipe when the conditions are met (like the file not existing).
- In this example, when you run the up target, if .env doesn’t exist it will run the .env target first to create it, then start the workspace container. If .env already exists, it skips the .env target and starts the container directly.
- Likewise, if there is a file named up in the directory, the up target won’t run. You can define Phony Targets to tell Make that certain targets aren’t filenames, but named workflows instead:

.PHONY: up stop zsh

Add Some Variables

Make supports variables (Variable). Following common Unix environment variable conventions, we usually write them in SCREAMING_SNAKE_CASE. When used, variables are wrapped in $().

Bash Bitwise Operators

Mon, 04 Jul 2022 15:20:39 +0800

Bash Bitwise Operators

Bash’s Tools for Base Conversion

Bash’s arithmetic expansion allows us to write numbers in any base by prefixing the numeric digits of the base followed by the hash symbol.

$ echo $((2#1001))
9

bc allows us to convert effortlessly between bases, using the parameters ibase (for the input base) and obase (for the output base). So, let’s convert the decimal number 9 to base 2

$ echo "ibase=10;obase=2;9" | bc
1001

Parse Command Line Arguments in Bash

Tue, 07 Jun 2022 14:48:47 +0800

Parse Command Line Arguments in Bash

getopts

getopts optstring opt [arg ...]

#!/bin/bash

while getopts 'abc:h' opt; do
 case "$opt" in
 a)
 echo "Processing option 'a'"
 ;;

 b)
 echo "Processing option 'b'"
 ;;

 c)
 arg="$OPTARG"
 echo "Processing option 'c' with '${OPTARG}' argument"
 ;;

 ?|h)
 echo "Usage: $(basename $0) [-a] [-b] [-c arg]"
 exit 1
 ;;
 esac
done
shift "$(($OPTIND -1))"

optstring represents the supported options. The option expects an argument if there is a colon (:) after it. For instance, if option c expects an argument, then it would be represented as c: in the optstring
When an option has an associated argument, then getopts stores the argument as a string in the OPTARG shell variable. For instance, the argument passed to option c would be stored in the OPTARG variable.
opt contains the parsed option.

#!/bin/bash

while getopts ':abc:h' opt; do
 case "$opt" in
 a)
 echo "Processing option 'a'"
 ;;

 b)
 echo "Processing option 'b'"
 ;;

 c)
 arg="$OPTARG"
 echo "Processing option 'c' with '${OPTARG}' argument"
 ;;

 h)
 echo "Usage: $(basename $0) [-a] [-b] [-c arg]"
 exit 0
 ;;

 :)
 echo -e "option requires an argument.\nUsage: $(basename $0) [-a] [-b] [-c arg]"
 exit 1
 ;;

 ?)
 echo -e "Invalid command option.\nUsage: $(basename $0) [-a] [-b] [-c arg]"
 exit 1
 ;;
 esac
done
shift "$(($OPTIND -1))"

Note that we’ve updated optstring as well. Now it starts with the colon(:) character, which suppresses the default error message.
The getopts function disables error reporting when the OPTERR variable is set to zero.

Parsing Long Command-Line Options With getopt

#!/bin/bash

VALID_ARGS=$(getopt -o abg:d: --long alpha,beta,gamma:,delta: -- "$@")
if [[ $? -ne 0 ]]; then
 exit 1;
fi

eval set -- "$VALID_ARGS"
while [ : ]; do
 case "$1" in
 -a | --alpha)
 echo "Processing 'alpha' option"
 shift
 ;;
 -b | --beta)
 echo "Processing 'beta' option"
 shift
 ;;
 -g | --gamma)
 echo "Processing 'gamma' option. Input argument is '$2'"
 shift 2
 ;;
 -d | --delta)
 echo "Processing 'delta' option. Input argument is '$2'"
 shift 2
 ;;
 --) shift;
 break
 ;;
 esac
done

-o option represents the short command-line options
--long option represents the long command-line options

Best Practices for Writing Bash Scripts

Mon, 06 Dec 2021 11:11:54 +0800

#!/usr/bin/env bash
# Bash3 Boilerplate. Copyright (c) 2014, kvz.io
set -o errexit
set -o pipefail
set -o nounset
# set -o xtrace

# Set magic variables for current file & dir
__dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
__file="${__dir}/$(basename "${BASH_SOURCE[0]}")"
__base="$(basename ${__file} .sh)"
__root="$(cd "$(dirname "${__dir}")" && pwd)" # <-- change this as it depends on your app

arg1="${1:-}"

Use shift to read function arguments

This makes it easier to reorder arguments, if you change your mind later.