Shell Builtin and Scripting Commands in Linux (original) (raw)

Last Updated : 12 Jan, 2026

Shell built-in and scripting commands are mainly used inside the shell to control execution flow, manage variables, automate tasks, and write scripts. These commands are either built into the shell itself or commonly used alongside shell scripting for efficient command execution.

• Used for scripting, looping, and conditional execution
• Help automate repetitive administrative tasks
• Control program flow inside shell scripts
• Improve script readability and execution efficiency

Shell built-in and scripting commands in linux

Below are some of commonly used Shell Built-in and Scripting Commands

1. alias

The alias command is used to create shortcut names for longer or frequently used commands. It helps reduce typing effort and makes command usage faster and more convenient, especially during daily terminal work or inside shell configuration files.

• Creates custom short names for long commands
• Improves efficiency and reduces typing errors
• Mostly used in interactive shells
• Commonly defined in shell startup files like .bashrc

**Basic Usage of alias Command

**Syntax:

alias name='command'

• **name : The shortcut name you want to create
• **Command: The actual command that will run when the alias is used

**Example: Create a Simple Alias

Create a shortcut for a frequently used command to reduce typing and improve efficiency during interactive shell sessions or within scripts.

**Command:

alias CD='cd Desktop'

• CD becomes a shortcut for `cd Desktop`
• The alias works only in the current shell session unless saved

**Output:

2. bind

The bind command is used to display or modify Readline key bindings. Readline is the library responsible for handling keyboard input in interactive shells like Bash. Using bind, you can customize how keys behave when typing commands in the terminal.

• Displays current keyboard shortcuts used by the shell
• Allows customization of key behavior
• Useful for improving command-line productivity
• Mainly used in interactive shell environments

**Syntax:

bind [options]

• [options] : Control what information is displayed or modified

**Example: Display All Current Key Bindings

List all keyboard shortcuts currently active in the shell to understand assigned key combinations and customize key behavior for improved command-line productivity.

**Command:

bind -p

• -p prints all current key bindings
• Shows key sequences and the actions they trigger
• Useful when customizing or debugging shell input behavior

**Output:

3. break

The break command is used to immediately terminate a loop (for, while, or until) before it finishes all iterations. It is mainly used in scripting when a specific condition is met and continuing the loop is no longer required.

• This command helps in:
• Controlling script flow
• Stopping loops early to save time or resources
• Making scripts more readable and efficient

**Syntax:

break [n]

• n (optional) specifies how many nested loops to exit
• If omitted, break exits only the current loop

**Example: Exit a Loop When a Condition Is Met

Stops the loop once the value reaches 3, printing only numbers before it, demonstrating early termination in a loop.

**Script :

for i in 1 2 3 4 5
do
if [ "$i" -eq 3 ]; then
break
fi
echo $i
done

**Output:

Break stops a loop

4. builtin

The builtin command is used to run another built-in command directly, even if a command with the same name exists as an external program, function, or alias. It ensures that the shell’s internal version of a command is executed.

• A built-in command name conflicts with an alias or function
• You want predictable shell behaviour in scripts
• Debugging shell environments

**Syntax:

builtin command [arguments]

• **Command: is the name of a shell built-in
• **arguments : are passed to that built-in command

**Example: Run the Built-in echo Command

Uses builtin to execute the shell’s internal echo, printing a message even if an alias or external command with the same name exists.

**Command:

builtin echo "Hello from builtin"

**Output:

Built-in echo command

5. continue

The continue command is used inside loops (for, while, until) to skip the rest of the current iteration and move directly to the next iteration. It is useful when you want to ignore certain conditions without exiting the loop entirely.

• Skipping invalid input or errors in a loop
• Ignoring certain items in a list while processing the rest
• Improving flow control in repetitive tasks

**Syntax:

continue [n]

• **n (optional) : specifies how many levels of loops to skip ahead. Default is 1 (current loop).

**Example: Skip Even Numbers in a Loop

Skips printing even numbers while iterating from 1 to 5, demonstrating how continue moves to the next iteration without exiting the loop.

**Command:

#!/bin/bash

for i in 1 2 3 4 5
do
if [ $((i % 2)) -eq 0 ]; then
continue
fi
echo "Processing number $i"
done

**Output:

Skiping even numbers in a loop

6. declare

The declare command is used to declare variables and assign attributes to them. It allows you to set data types, read-only status, arrays, and other properties for variables within shell scripts. This is particularly useful for writing robust scripts with predictable behavior.

• Marking variables as read-only to prevent accidental changes
• Defining arrays or indexed variables
• Restricting variable values to integers

**Syntax:

declare [options] variable_name[=value]

**Common Options:

• **-r : Make variable read-only
• **-i : Treat variable as an integer
• **-a : Declare an array
• **-x : Export variable to child processes

**Example: Declare a Read-Only Variable

Creates a read-only variable MY_NAME, prints its value, and shows that attempting to change it fails, demonstrating protected variable behavior.

**Command:

#!/bin/bash

Declare a read-only variable

declare -r MY_NAME="GeeksforGeeks"

Try to print and change it

echo $MY_NAME
MY_NAME="NewName"

**Output:

Declaring a Read-Only Variable

7. enable

The enable command in Linux is used to enable or disable other shell built-in commands. This allows you to control which built-ins are available in the current shell session, which can be useful for testing, debugging, or restricting certain commands in scripts.

• Temporarily disabling a built-in to test external command alternatives
• Re-enabling a previously disabled built-in
• Checking which built-ins are currently enabled

**Syntax:

enable [options] [name ...]

**Common Options:

• -n : Disable a built-in command
• -d : Display disabled built-ins
• -p : Display all built-ins and their status

**Example: Disable and Re-enable a Built-in

Temporarily disables the echo built-in, shows that it cannot run, then re-enables it to demonstrate controlling command availability in the shell.

**Command:

#!/bin/bash

Disable the echo built-in

enable -n echo

Try using echo (should fail)

echo "Hello"

Re-enable echo built-in

enable echo

Use echo again (should work)

echo "Hello again"

**Output:

Disabling the echo built-in temporarily

8. eval

The eval command is used to evaluate arguments as a shell command and then execute them. It takes a string, processes it as if it were typed directly into the shell, and runs the resulting command. This is mainly useful in scripting when commands are stored in variables or built dynamically.

• Execute commands stored in variables
• Process dynamically constructed command strings
• Advanced scripting scenarios (use carefully)

**Syntax:

eval [arguments]

**Example: Execute a Command Stored in a Variable

Stores a command in a variable and runs it with eval, running the command as if typed directly in the shell.

**Command:

#!/bin/bash

Store a command in a variable

cmd="ls -l"

Execute the command using eval

eval $cmd

**Output:

Executing a command stored in a variable

9. exec

The exec command is used to replace the current shell process with another command. Unlike normal command execution, exec does not create a new process. Instead, it runs the specified command in place of the current shell, meaning the shell does not return after execution.

• Replace the shell with another program
• Run a command as the final step in a script
• Optimise process usage by avoiding extra processes

**Syntax:

exec command [arguments]

**Example: Replace the Shell with a Command

Replaces the current shell process with the ls command, immediately ending the shell session and running ls without returning to the original shell.

**Command:

#!/bin/bash

Replace the current shell with the 'ls' command

exec ls

**Output:

10. exit

The exit command is used to terminate the current shell session or end the execution of a shell script. It can optionally return an exit status code, which is useful in scripting to indicate whether a command or script completed successfully or failed.

• Exit an interactive shell session
• Stop script execution at a specific point
• Return a status code to the calling process

**Syntax:

exit [status]

• status (optional): An integer value returned to the parent process (0 usually means success).

**Example: Exit a Script with a Status Code

Stops the script execution at a specific point, returns a status code to the parent process, and prevents any commands after exit from running.

**Command:

#!/bin/bash

echo "Script is starting"

Exit with status 0

exit 0

echo "This will not be printed"

**Output:

Exit a script with a status code

11. export

The export command is used to define environment variables and make them available to child processes. Variables created with export can be accessed by programs, scripts, and subshells launched from the current shell session.

• Share variables with shell scripts
• Configure application settings via environment variables
• Set paths and runtime options

**Syntax:

export VARIABLE=value

**Example: Export an Environment Variable

Creates a variable and exports it, making the value available to child processes and other scripts run from the current shell session.

**Command:

#!/bin/bash

Export a variable

export MY_VAR="Linux"

Print the variable

echo $MY_VAR

**Output:

Exporting an environment variable

12. fc

The fc command in Linux is used to work with commands stored in the shell history. It allows you to list previously executed commands. This is especially useful when you want to correct a mistake in a long command or repeat a complex command without typing it again.

• The name fc stands for fix command
• Accesses and manages command history
• Can edit previous commands before executing them
• Helps avoid retyping long or complex commands
• Useful in interactive shell sessions

**Syntax:

fc [options] [first] [last]

• options : Control how history commands are listed or executed
• first and last : Specify the range of history commands

**Example: Re-execute the Most Recent Command

Uses fc -s to rerun the last executed command from shell history, allowing quick repetition or correction of previously typed commands.

**Command:

fc -s

**Output:

Re-execute the most recent command

13. let

The let command in Linux is used to perform arithmetic operations directly within the shell. It allows evaluation of expressions involving integers and supports assignment, increment, decrement, and basic mathematical operations.

**Syntax:

let expression

• expression : The arithmetic expression to evaluate. Can include variables and operators
• Multiple expressions can be evaluated at once, separated by spaces

**Example: Increment a Variable

Uses let to increase the value of a variable by 1, performing arithmetic directly within the shell without external tools or commands.

**Command:

#!/bin/bash

Initialize a variable

count=5

Increment the variable using let

let count=count+1

Print the result

echo $count

**Output:

Increment a variable

14. printf

The printf command in Linux is used to format and print text to the terminal or a file. Unlike echo, printf provides precise control over output formatting, including field width, alignment, padding, and numerical precision.

• Prints formatted text or numbers
• Supports format specifiers similar to C’s printf (e.g., %s, %d, %f)
• Avoids issues like unwanted newlines, spacing, or escape sequences that echo may introduce
• Can redirect output to files for reporting

**Syntax:

printf FORMAT [ARGUMENT]...

• FORMAT : A string with format specifiers defining how the arguments should be displayed
• ARGUMENT : Values to be printed according to the FORMAT

**Example: Print Formatted Text

Prints a student’s name and score using printf, aligning text and numbers neatly for clearer, structured output in the terminal.

**Command:

#!/bin/bash

name="Alice"
score=95

Print formatted output

printf "Student: %s\nScore: %d\n" "$name" "$score"

**Output:

Printing formatted text

15. read

The read command in Linux is a built-in shell command used to take input from the user or from a file/pipe. It is commonly used in shell scripts to pause execution and store user-provided values into variables for further processing.

• Reads a line of input and stores it in one or more variables
• Supports prompts with -p
• Can read silent input (e.g., passwords) with -s
• Useful in scripts to capture user responses or pipeline data

**Syntax:

read [options] VARIABLE...

• VARIABLE : Name(s) of the variable(s) where input will be stored
• Common options:
• -p "prompt" : Display a prompt before reading input
• -s : Silent mode (input not displayed on terminal)
• -t N : Timeout after N seconds
• -a ARRAY : Store input words into an array

**Example: Read Name and Age from User

Prompts the user to enter their name and age, stores the input values in separate variables, and then displays both values clearly in the terminal output.

**Command:

#!/bin/bash

Prompt user for input

read -p "Enter your name and age: " name age

Display the input

echo "Name: $name"
echo "Age: $age"

**Output:

Read name and age from user

16. return

The return command in Linux is used to exit a function and optionally provide an exit status. The return command only affects the function in which it is called. This makes it an essential tool for controlling function flow and signaling success or failure from a function back to the main script.

• Used inside shell functions only
• Can return a numeric exit status (0–255)
• Helps in conditional checks based on function results
• Default return value is 0 if none is specified

**Syntax:

return [n]

• n : Optional numeric status to return (0 for success, non-zero for failure)

**Example: Function Returning Status

Defines a function that checks if a number is even, returns a status code accordingly, and prints whether the number is even or odd after the function call.

**Command:

#!/bin/bash

check_even() {
if [ $1 -eq 0 ]; then
return 1 # Not even
elif [ ((((((1 % 2)) -eq 0 ]; then
return 0 # Even
else
return 1 # Odd
fi
}

Call the function

check_even 10

Check the return status

if [ $? -eq 0 ]; then
echo "Number is even"
else
echo "Number is odd"
fi

**Output:

Function returning status

17. shift

The shift command is used in scripting to manipulate positional parameters. It allows you to move the command-line arguments to the left, effectively discarding the first argument and shifting all remaining arguments one position down.

• Operates on positional parameters ($1, 2,2, 2,3, …)
• Shifts all arguments to the left
• 1isdiscardedaftertheshift,1 is discarded after the shift, 1isdiscardedaftertheshift,2 becomes 1,1, 1,3 becomes $2, and so on
• Can take an optional number to shift multiple positions at once

**Syntax:

shift [n]

• n : Optional. Number of positions to shift. Default is 1.

**Example: Process Multiple Arguments

shift moves command-line arguments one position to the left, discarding the first argument each time, letting the script handle all arguments in order.

**Script :

#!/bin/bash
echo "Starting script"
while [ "$1" != "" ]; do
echo "Processing argument: $1"
shift
done

**Command:

bash shift_example.sh apple banana cherry

**Output:

Processing multiplea Arguments

18. source

The source command is used to read and execute commands from a file in the current shell environment. The command source does not spawn a new shell; any variables, functions, or changes made in the sourced file persist in the current session.

• used to load environment variables, functions, or configuration scripts without starting a separate shell process.

**Syntax:

source filename

or using the shorthand

. filename

• filename : Path to the file containing shell commands

**Example: Load Environment Variables from a File

Loads variables from another file into the current shell, then prints their values, making the data available immediately without starting a new shell.

**File: env_file.sh

#!/bin/bash

MY_NAME="Sam"
MY_CITY="Delhi"

**File: source_example.sh

#!/bin/bash

Load variables from env_file.sh

source env_file.sh

Display loaded variables

echo "Name: MYNAME,City:MY_NAME, City: MYN​AME,City:MY_CITY"

**Output:

Load environment variables from a file

19. type

The type command is used to identify how a command name is interpreted by the shell. It helps determine whether a command is a built-in, an alias, a function, or an external executable.

• Identifies whether a command is built-in, alias, function, or external
• Displays the actual path of external commands
• Helps avoid command name conflicts
• Useful for debugging shell scripts

Syntax:

type command_name

• command_name : The command you want to examine

**Example: Check Command Type

Checks a command and shows whether it is built-in, an alias, a function, or an external program, helping identify its source before execution.

**Command:

type echo
type ls

**Output:

Checking command type