Shell Scripting Interview Questions and Answers 2025

In a shell script, we can use the if statement to execute a block of commands based on the value of a particular expression. The syntax for an if statement is: 

if condition 
then 
command1 
command2 
... 
fi 

We can also use the else and elif (else-if) clauses to specify additional conditions and blocks of commands to execute. 

Below is an illustration of an if statement that checks to see if a file is present:  

#!/bin/bash 
if [ -f "/path/to/file" ] 
then 
echo "File exists" 
else 
echo "File does not exist" 
fi 

In this example, the [ -f "/path/to/file" ] is a test that checks whether the file at the specified path exists and is a regular file. If the test evaluates to true, the echo command will be executed; if it evaluates to false, the else block will be executed. 

We can also use the case statement to execute a block of commands based on the value of a particular expression. The syntax for a case statement is: 

case expression in 
pattern1) 
command1 
command2 
... 
;; 
pattern2) 
command1 
command2 
... 
;; 
... 
esac 

Below is an example of a case statement that tests the value of a variable: 

#!/bin/bash 
case $VAR in 
abc) 
echo "VAR is set to 'abc'" 
;; 
def) 
echo "VAR is set to 'def'" 
;; 
*) 
echo "VAR is set to something else" 
;; 
esac 

In this example, the case statement will execute the appropriate block of commands based on the value of the $VAR variable. The * pattern is a catch-all that will match any value not matched by the other patterns. 

Errors and exceptions in a shell script can be handled using the following methods:

exit status: Every command in a shell script returns an exit status. An exit status of zero indicates success, while a non-zero exit status indicates failure. We can use the $? variable to check the exit status of a command and take appropriate action based on the status. For example: 

#!/bin/bash 
# run a command 
some_command 
# check its exit status 
if [ $? -eq 0 ]; then 
echo "Command succeeded" 
else 
echo "Command failed" 
fi 

try-catch blocks: Bash version 4.0 and above support the try and throw statements for handling errors and exceptions. The try block contains the code that might throw an exception, and the catch block contains the code to handle the exception. Below is an example: 

#!/bin/bash 
try() { 
# code that might throw an exception 
some_command 
# throw an exception if the command failed 
if [ $? -ne 0 ]; then 
throw "Exception: some_command failed" 
fi 
} 
catch() { 
# code to handle the exception 
echo $1 
} 
# run the try block 
try 
# if an exception was thrown, run the catch block 
if [ $? -eq 0 ]; then 
echo "try block succeeded" 
else 
echo "try block failed" 
fi 

trap: The trap command allows us to specify a command to run when a particular signal is received by the script. We can use the trap command to handle exceptions and errors in our script. For example: 

#!/bin/bash 
# define the trap function 
trap 'echo "Error: command failed" >&2; exit 1' ERR 
# run a command that might fail 
some_command 
# remove the trap 
trap - ERR 
echo "Command succeeded" 

set -e: We can use the set -e option to make the script exit immediately if any command returns a non-zero exit status. This can be useful for handling errors and exceptions in your script. For example: 

#!/bin/bash 
# set the -e option 
set -e 
# run a command that might fail 
some_command 
echo "Command succeeded" 

Expect to come across this popular question in UNIX Scripting interviews.  

There are many ways to work with files and directories in a shell script. Here are a few common ones: 

Listing Files and Directories: We can use the ls command to list the files and directories in a directory. For example, to list all the files and directories in the current directory, we can use: 

#!/bin/bash 
Ls 

We can use various options with the ls command to customize the output. For example, to list the files and directories in a long format, sorted by modification time, we can use: 

#!/bin/bash 
ls -lt 

Changing Directories: We can use the cd command to change the current working directory.  

For example, to change the current directory to /etc, we can use: 

#!/bin/bash 
cd /etc 

Reading from Files: We can use the cat command to print the contents of a file to the terminal. For example, to print the contents of a file myfile.txt, we can use: 

#!/bin/bash 
cat myfile.txt 

We can also use the more and less commands to view the contents of a file, which allows to page through the file. 

Writing to Files: We can use the echo command to write text to a file. For example, to write the text "Hello, World!" to a file myfile.txt, you can use: 

#!/bin/bash 
echo "Hello, World!" > myfile.txt 

We can also use the tee command to write the output of a command to a file, while still printing it to the terminal. For example: 

#!/bin/bash 
some_command | tee myfile.txt 

Copying Files: We can use the cp command to copy a file. For example, to copy a file src.txt to dest.txt, we can use: 

#!/bin/bash 
cp src.txt dest.txt 

We can also use the cp command to copy directories. For example, to copy a directory src to dest, we can use: 

#!/bin/bash 
cp -r src dest 

Moving and Renaming Files: We can use the mv command to move or rename a file. For example, to rename a file src.txt to dest.txt, we can use: 

#!/bin/bash 
mv src.txt dest.txt 

We can also use the mv command to move a file to a different directory. For example, to move a file src.txt to the /tmp directory: 

#!/bin/bash 
mv src.txt /tmp 

Removing Files: We can use the rm command to remove a file. For example, to remove a file myfile.txt: 

#!/bin/bash 
rm myfile.txt 

We can also use the rm command to remove directories. 

Here are a few common pitfalls to watch out for when writing shell scripts: 

• Not Using set -e: The set -e option tells the script to exit immediately if any command returns a non-zero exit status. This can be very useful for handling errors and exceptions in the script. However, if we forget to set this option, our script may continue to run even if a command has failed, which can lead to unexpected behavior. 
• Not Checking Exit Status: Every command in a shell script returns an exit status. It is important to check the exit status of a command and take appropriate action based on the status. For example, we should check the exit status of a command that might fail, and exit the script or raise an error if the status is non-zero. 
• Not Quoting Variables: It is a good practice to always quote variables in shell scripts, to avoid issues with spaces and special characters in the values of the variables. For example, instead of echo $var, we should use echo "$var". 
• Not Handling Input: If our script takes input from the user or from another command, we should validate and sanitize the input to avoid issues such as command injection attacks. 
• Not Testing Thoroughly: It is important to thoroughly test our script to make sure it is working as expected. This includes testing the script with different inputs, edge cases, and error conditions. 
• Not Using Version Control: If we are working on a larger or collaborative project, it is a good idea to use version control to track changes to our script. This will allow us to easily revert to previous versions of the script if needed and collaborate with others on the project. 

To pass arguments to a shell script, we can simply list them after the script name, separated by space. For example: 

./myscript.sh arg1 arg2 arg3 

Inside the script, we can access the arguments using the $1, $2, $3, etc. variables. For example: 

#!/bin/bash 
echo "Argument 1: $1" 
echo "Argument 2: $2" 
echo "Argument 3: $3" 

We can also use the $* and $@ variables to access all of the arguments as a single string or as separate strings, respectively. 

For example: 

#!/bin/bash 
# Print all arguments as a single string 
echo "All arguments: $*" 
# Print all arguments as separate strings 
echo "All arguments: $@" 

We can also use the $# variable to get the total number of arguments passed to the script. 

For example: 

#!/bin/bash 
echo "Total number of arguments: $#" 

In Unix and Unix-like operating systems, a file or directory name that starts with a dot (.) is considered to be a hidden file or directory. Hidden files and directories are not normally displayed when listing the contents of a directory using commands such as ls.

To list hidden files and directories, we can use the ls -a command, which will show all files and directories, including hidden ones.

The dot (.) at the beginning of a file name has no special meaning to the operating system, but it is often used by convention to indicate a configuration file or other file that is meant to be hidden from normal view. For example, the file .bashrc in a user's home directory is a configuration file for the Bash shell, and the file .gitignore is used to specify files that should be ignored by Git.

Keep in mind that the dot (.) is also used to represent the current directory and the parent directory in a file path. For example,./myfile refers to the file myfile in the current directory, and ../myfile refers to the file myfile in the parent directory.

The printf command is an alternative to echo that is available in Unix and Unix-like operating systems. Like echo, printf is used to output text to the console or to a file. 

One advantage of printf over echo is that it is more flexible and can be used to print text in a specific format. It can also handle escape sequences and special characters more reliably than echo. 

Here is an example of how printf can be used: 

printf "Hello, %s\n" "world" 

This will print the string "Hello, world" followed by a newline character. The %s is a placeholder for a string, and the \n is an escape sequence that represents a newline. 

We can use other placeholders to print different types of data, such as integers (%d), floating point numbers (%f), and more. 

For example: 

printf "Number: %d\n" 42 
printf "Float: %.2f\n" 3.1415 

This will print "Number: 42" and "Float: 3.14", respectively. 

We should keep in mind that printf is not available in all shells and may not be available on all systems. However, it is a useful tool to have in your toolkit when working with shell scripts. 

To find out how long a Unix or Linux system has been running, we can use the uptime command. This command will show the current time, the length of time the system has been running, the number of users logged in, and the load average over the last 1, 5, and 15 minutes.

For example: 

$ uptime 
 21:52:06 up 3 days, 6:22, 2 users, load average: 0.00, 0.00, 0.00 

In this example, the system has been running for 3 days and 6 hours (3 days, 6:22). 

We can also use the who -b command to show the time that the system was last booted. For example: 

$ who -b 
system boot 2021-07-14 21:50 

This will show the date and time that the system was last booted. 

Keep in mind that these commands may not work on all systems, and the output may vary depending on the specific operating system and version. 

A must-know for anyone heading into a Shell Scripting interview, this is one of the most frequently asked UNIX Shell Scripting interview questions.  

To find out which shells are available on the Unix or Linux system, we can use the cat command to display the contents of the /etc/shells file. This file contains a list of all the shells that are available on the system. 

For example: 

$ cat /etc/shells 
# /etc/shells: valid login shells 
/bin/sh 
/bin/bash 
/usr/bin/sh 
/usr/bin/bash 
/usr/local/bin/bash 

We can also use chsh (change shell) command to see which shells are available and to change the default shell for the user account. For example: 

$ chsh 
Changing the login shell for username 
Enter the new value, or press ENTER for the default 
        Login Shell [/bin/bash]: 

This will display a list of available shells, and we can choose one from the list or enter the path to a different shell.

We should know that the list of available shells may vary depending on the specific operating system and version, and may include other shells such as zsh, csh, and more.

There are several commands available in Unix and Unix-like operating systems to check the disk usage of a file system. Some of the most common ones are:

df: The df command displays information about the available and used disk space on a file system. By default, it shows the size, used space, and available space for all file systems. 

For example: 

$ df 
Filesystem 1K-blocks Used Available Use% Mounted on 
/dev/sda1 469059992 415097728 53962256 89% / 

We can use the -h option to display the sizes in "human-readable" format, with units such as MB and GB. 

For example: 

$ df -h 
Filesystem Size Used Avail Use% Mounted on 
/dev/sda1 450G 391G 51G 89% / 

du: The du command displays the disk usage of individual directories and files. By default, it shows the sizes of directories and their contents in blocks. 

For example: 

$ du 
16 ./dir1 
8 ./dir1/file1 
4 ./dir1/file2 
4 ./dir2 
4 ./dir2/file1 
8 . 

We can use the -h option to display the sizes in "human-readable" format, with units such as MB and GB. 

For example: 

$ du -h 
16K ./dir1 
8.0K ./dir1/file1 
4.0K ./dir1/file2 
4.0K ./dir2 
4.0K ./dir2/file1 
8.0K . 

We can also use the -c option to show the total size of all directories and files. 

For example: 

$ du -ch 
16K ./dir1 
8.0K ./dir1/file1 
4.0K ./dir1/file2 
4.0K ./dir2 
4.0K ./dir2/file1 
8.0K . 
32K total 

ncdu is a text-based disk usage viewer that allows you to navigate through directories and see the sizes of individual files and directories in real-time. It is a useful tool for finding and deleting large files and directories to free up space on your file system. 

To use ncdu, we need to run the ncdu command and navigate through the directories using the arrow keys and the enter key. Pressing d will delete a file or directory and pressing q will exit the program. 

We should know that these are just a few examples of the commands available to check disk usage. There are many other tools and options available, depending on specific needs and preferences.

It's no surprise that this one pops up often in Shell Scripting interview questions for DevOps.

Awk is a command-line utility that allows you to perform operations on a stream of text data, such as extracting and transforming the contents of a file or generating reports from data. It is particularly useful for working with structured data, such as tab-separated values (TSV) or comma-separated values (CSV).

Below is a brief overview of how awk works: 

Awk reads input one line at a time and splits each line into fields based on a predefined separator (by default, this is a whitespace character). 

The fields can then be accessed and manipulated using special variables (e.g., $1 refers to the first field, $2 to the second field, etc.). 

awk processes each line according to a set of rules, which specify the actions to be taken based on the contents of the fields. 

The modified lines are then printed to the output. 

Here is an example of using awk to print the second and fifth fields of a file containing tab-separated values: 

//code 
awk -F'\t' '{print $2, $5}' input.txt > output.txt 

This command reads the contents of input.txt, sets the field separator to a tab character (-F'\t'), and then prints the second and fifth fields of each line to output.txt. 

Awk is a very powerful and versatile utility, and there are many additional commands and options available for performing more complex operations.  

Practice more Shell Scripting interview questions and answers like this to make a lasting impression on your recruiters.

UNIX provides several security provisions for protecting files and data: 

• File Permissions: File permissions control who is allowed to read, write, or execute a file. File permissions can be set for the owner of the file, the group that the file belongs to, and other users (also known as "others" or "world"). 
• Access Control Lists (ACLs): ACLs are an extended version of file permissions that allow us to specify more fine-grained access controls for a file. With ACLs, we can specify permissions for specific users or groups, rather than just the owner, group, and others. 
• Encryption: Encrypting a file or data ensures that it can only be read by someone with the appropriate decryption key. This can be useful for protecting sensitive information, such as passwords or financial data. 

It is important to note that these security provisions are not mutually exclusive, and we can use a combination of these measures to protect our files and data. 

sed is a command-line utility that allows you to perform text transformations on an input stream (a file or input from a pipeline). It is commonly used for extracting part of a file, transforming the contents of a file, or deleting lines from a file. 

Here is a brief overview of how sed works: 

sed reads input one line at a time and performs the specified transformation on each line. 

The transformations are specified using a set of commands, which are provided as arguments to sed. 

The modified lines are then printed to the output. 

Here is an example of using sed to replace all occurrences of the word "apple" with the word "banana" in a file: 

//code 
sed 's/apple/banana/g' input.txt > output.txt 

This command reads the contents of input.txt, performs a substitution on each line to replace "apple" with "banana", and writes the modified lines to output.txt. The g at the end of the substitution command specifies that the substitution should be performed globally on each line (i.e., all occurrences of "apple" should be replaced, not just the first one). 

sed is a very powerful and versatile utility, and there are many additional commands and options available for performing more complex transformations. 

Bash is a weakly typed language because it does not require variables to be explicitly declared with a specific data type. Instead, variables in bash are automatically interpreted based on the context in which they are used. This means that we can use a variable in one part of the script as a string, and then use it in another part of the script as an integer, for example.

This can be both a strength and a weakness of bash. On one hand, it makes it easy to use variables and write scripts quickly, as we don't have to worry about declaring the data types of the variables. On the other hand, it can also make it easy to introduce bugs into our scripts, as we might not realize that a variable is being interpreted differently than we intended.

Overall, the weakly typed nature of bash is something that we should be aware of as we write scripts, and we should ensure that the variables are being used in the way that we intended.

In Unix-like systems, the pipe operator (|) is used to redirect the output of one command to the input of another command. It allows us to chain multiple commands together and process the output of one command as the input of the next command.

For example, consider the following command:

ls -l | grep "foo" 

This command will list the files in the current directory using the ls command, and then filter the output to display only the lines that contain the string "foo" using the grep command. The output of the ls command is piped to the grep command using the | operator, allowing the grep command to process the output of the ls command as its input.

We can use multiple pipe operators to chain together multiple commands. For example:

cat file.txt | grep "foo" | sort | uniq -c 

This command will display the contents of the file "file.txt" using the cat command, filter the output to display only the lines that contain string "foo" using the grep command, sort the output alphabetically using the sort command, and count the number of occurrences of each unique line using the uniq command with the -c option.

Overall, the pipe operator allows us to run several commands in one line by chaining them together and processing the output of one command as the input of the next. This can be a powerful and efficient way to manipulate data and perform complex tasks on the command line.

Shell scripts can be used to integrate with other tools or systems in a variety of ways. Some common ways to use shell scripts for integration include: 

• Running Other Command-line Tools or Utilities: Shell scripts can be used to execute other command-line tools or utilities as part of an automated workflow. For example, we might use a shell script to automate the process of running a database backup, by calling the appropriate command-line utility to perform the backup. 
• Wrapping API Calls: Shell scripts can be used to make API calls to other systems or services, as long as the API is accessible over the network. This can be useful for integrating with cloud services or other web-based systems. 
• Building and Deploying Software: Shell scripts can be used to automate the process of building and deploying software, by executing the necessary commands to check out the code from version control, build the software, and then deploy it to the appropriate servers. 
• Running System Maintenance Tasks: Shell scripts can be used to automate routine system maintenance tasks, such as cleaning up log files or checking for system updates. 

Overall, shell scripts are a powerful tool for automating and integrating a wide variety of tasks and processes within a larger ecosystem. 

There are many ways to use shell scripts to automate tasks such as deployment or testing. Here are a few examples: 

Deployment: Shell scripts can be used to automate the process of deploying software to various environments. For example, we might use a shell script to perform the following tasks as part of a deployment process: 

1. a. Check out the latest code from version control.
2. Build the software.
3. Run tests to ensure that the software is working correctly.
4. Package the software into a deployable package (e.g., a jar file or a docker container)
5. Deploy the package to the appropriate servers.

Testing: Shell scripts can be used to automate the process of running tests against software. For example, you might use a shell script to perform the following tasks as part of a testing process: 

1. Check out the latest code from version control
2. Build the software
3. Run unit tests to ensure that individual components are working correctly
4. Run integration tests to ensure that the software works correctly when all of the components are combined
5. Run acceptance tests to ensure that the software meets the required specifications
6. Overall, shell scripts are a powerful tool for automating tasks such as deployment and testing, as they allow you to define a set of steps that can be executed automatically, saving time, and reducing the risk of errors.

This question is a regular feature in Shell Scripting interview questions for DevOps, be ready to tackle it.  

Below are several ways to use shell scripts to interact with APIs and other external services. Below are a few examples: 

curl: The curl command can be used to send HTTP requests to an API and receive the response. For example: 

curl https://api.example.com/endpoint 

jq: The jq command is a tool for parsing and manipulating JSON data. It can be used in combination with curl to extract specific values from the API response. For example: 

curl https://api.example.com/endpoint | jq .key 

wget: The wget command can be used to download files from the web, including files returned by an API. For example: 

wget https://api.example.com/endpoint/file.zip 

grep: The grep command can be used to search for specific patterns in text. It can be used in combination with other commands, such as curl, to extract specific information from the output. For example: 

curl https://api.example.com/endpoint | grep pattern 

There are many other tools and techniques that can be used to interact with APIs and other external services from a shell script. 

Shell scripts can be used to manage and manipulate files and directories in a variety of ways. Some common tasks that can be performed using shell scripts include: 

• Creating and Deleting Files and Directories: We can use shell commands such as touch, mkdir, rm, and rmdir to create and delete files and directories from within a shell script. 
• Copying and Moving Files and Directories: Shell commands such as cp and mv can be used to copy and move files and directories from within a shell script. 
• Renaming Files and Directories: We can use the mv command to rename files and directories from within a shell script. 
• Searching for Files and Directories: Can use the find command to search for files and directories based on various criteria, such as their name, size, or modification date. 
• Archiving and Compressing Files: Use the tar command to create archive files containing multiple files and directories, and the gzip and bzip2 commands to compress files. 

Overall, shell scripts provide a powerful set of tools for managing and manipulating files and directories on a system, allowing us to automate tasks such as backups, file cleanup, and more. 

To check if a file exists on the filesystem using a bash shell script, we can use the test command with the -f option. Below is an example of how we might use this command to check if a file called "file.txt" exists:

if test -f "file.txt"; then 
echo "File exists" 
else 
echo "File does not exist" 
fi 

Alternatively, we can use the [ -f "file.txt" ] syntax to achieve the same result. 

Below is an example of how we might use this command in a script: 

#!/bin/bash 
if [ -f "file.txt" ]; then 
echo "File exists" 
else 
echo "File does not exist" 
fi 

This script will check for the existence of a file called "file.txt" and will print "File exists" if the file exists or "File does not exist" if the file does not exist. 

We can also use the -d option to check for the existence of a directory or the -e option to check for the existence of either a file or a directory. This is also one of the most frequently asked Shell Scripting questions.  

The difference between [[ $string == "efg*" ]] and [[ $string == efg* ]] is the presence of double quotes around the string being compared. 

In the first example, [[ $string == "efg*" ]], the double quotes around "efg*" indicate that the string should be treated literally, and the * character should be interpreted as a literal asterisk. This means that the expression will only evaluate to true if the value of $string is exactly "efg*". 

In the second example, [[ $string == efg* ]], the double quotes are not present, which means that the * character will be interpreted as a wildcard. This means that the expression will evaluate to true if the value of $string starts with "efg" followed by any number of characters. 

For example: 

string="efgabc" 
if [[ $string == "efg*" ]]; then 
echo "Match with double quotes" 
else 
echo "No match with double quotes" 
fi 
if [[ $string == efg* ]]; then 
echo "Match without double quotes" 
else 
echo "No match without double quotes" 
fi 

The output of this script would be: 

No match with double quotes 
Match without double quotes 

Overall, the use of double quotes can be important in bash to ensure that strings are treated literally, and to prevent special characters from being interpreted as wildcards or other special symbols. 

The crontab command is used to schedule tasks to be executed automatically at a specified time. When we use the crontab command to schedule a task, the task is stored in one of two files: 

• The system-wide crontab File: This file is usually located at /etc/crontab, and it contains tasks that are executed by the system on behalf of all users. This file is usually reserved for tasks that need to be run with superuser privileges. 
• The user crontab File: Each user on a system has their own crontab file, which is stored in the /var/spool/cron directory. This file contains tasks that are specific to the individual user, and that are executed with the permissions of that user. 

To view the tasks in user crontab file, we can use the crontab -l command. To edit the user crontab file, we can use the crontab -e command. To remove the user crontab file, we can use the crontab -r command. 

To schedule a task using the crontab command, we need to specify the time and date when the task should be executed, as well as the command that should be executed. The time and date are specified using a special syntax called the "crontab format," which consists of five fields: minute, hour, day of month, month, and day of week. Each field can contain a single value, a list of values, or a range of values, separated by commas. 

For example, to schedule a task to be executed every hour, you might use a crontab entry like this: 

0 * * * * /path/to/command 

This entry specifies that the task should be run every hour, at the top of the hour (when the minute field is 0). 

To count the number of words in a given file using a bash shell script, we can use the wc command with the -w option. 

Here is an example of a command sequence that we can use to count the words in a file called "file.txt": 

# Count the number of words in the file 
word_count=$(wc -w "file.txt") 
# Print the result 
echo "Number of words: $word_count" 

This script will execute the wc command with the -w option, which counts the number of words in the file. The output of the wc command will be captured by the $(...) syntax and stored in the word_count variable. The script will then print the value of the word_count variable using the echo command. 

The wc command can also be used to count the number of lines in a file (using the -l option) or the number of bytes in a file (using the -c option). 

For example, to count the number of lines in a file called "file.txt", we could use the following script: 

# Count the number of lines in the file 
line_count=$(wc -l "file.txt") 
# Print the result 
echo "Number of lines: $line_count" 

And to count the number of bytes in a file called "file.txt", you could use the following script: 

# Count the number of bytes in the file 
byte_count=$(wc -c "file.txt") 
# Print the result 
echo "Number of bytes: $byte_count"

In Unix-like operating systems, the "s" permission bit is used to set the setuid (or setgid) permission on a file. When the setuid permission is set on a file, it allows the file to be executed with the permissions of the owner of the file, rather than the permissions of the user who is executing the file. This can be useful for allowing users to execute a program with superuser privileges, even if they do not have the necessary permissions to run the program directly.

For example, considering a file called "sudo", which is owned by the root user and has the setuid permission set. If a user executes this file, it will be run with the permissions of the root user, even if the user does not have root permissions themselves. This can be useful for allowing users to execute commands that require superuser privileges, such as installing software or modifying system settings.

The setgid permission works in a similar way, but it allows the file to be executed with the permissions of the group owner of the file, rather than the permissions of the user who is executing the file.

The setuid and setgid permissions are represented by the "s" permission bit in the file's permissions string. For example, if a file has the permissions "rwxsr-xr-x", the "s" permission bits indicate that the setuid and setgid permissions are set on the file.

It is important to use the setuid and setgid permissions carefully, as they can be a security risk if used improperly. In particular, it is important to make sure that setuid and setgid programs are carefully designed and implemented, as vulnerabilities in these programs can be exploited to gain unauthorized access to the system.

Expect to come across this popular question in UNIX Scripting interviews.  

To create a directory with the desired permissions, I can use the mkdir command and specify the -m option to set the permissions of the directory. 

To allow anyone in the group to create and access files in the directory, but not delete files created by others, I can use the following permissions: 

• rwx for the owner (read, write, and execute permissions) 
• rwx for the group (read, write, and execute permissions) 
• r-x for others (read and execute permissions, but no write permission) 
• I can specify these permissions using the octal notation, where 7 represents read, write, and execute permissions, 6 represents read and write permissions, and 5 represents read and execute permissions. 

To create the directory with these permissions, I will use the following command: 

mkdir -m 775 /path/to/directory 

This will create the directory with the permissions rwxrwxr-x, which will allow the owner and members of the group to create and access files in the directory but will prevent others from deleting files created by others. 

It is also important to note that setgid permission can be used to ensure that new files created in the directory are automatically owned by the group, rather than the user who created the file. To set the setgid permission on the directory, I will use the chmod command with the g+s option: 

chmod g+s /path/to/directory 

will set the setgid permission on the directory, ensuring that new files created in the directory are automatically owned by the group. 

To monitor a log file that is constantly updating, we can use the tail command with the -f option. The tail command is used to display the last few lines of a file, and the -f option allows it to follow the file and display new lines as they are added to the file. 

For example, to monitor the log file "log.txt" and display new lines as they are added to the file, we can use the following command: 

tail -f log.txt 

This will display the last few lines of the log file, and then continue to display new lines as they are added to the file. The tail command will keep running until we stop it, so we can use it to effectively monitor the log file in real-time. 

We can also use the -n option to specify the number of lines to display, or the -s option to specify the interval between updates. 

For example, to display the last 100 lines of the log file and update the display every 5 seconds, we can use the following command: 

tail -n 100 -s 5 log.txt 

Overall, the tail command is a useful tool for monitoring log files and other files that are constantly updating. It allows us to view new lines as they are added to the file, making it easier to track changes and identify issues. 

To set a connection to a remote server where we can execute commands, we'll need the following methods.

• SSH (Secure Shell) is a network protocol that allows us to securely connect to a distant server and issue commands. To use SSH, we will need to install an SSH client on the local machine and connect to the server using the ssh command. For example: 
• ssh user@server: This will open an SSH session to the server, allowing us to issue commands and interact with the server as if we were logged in directly. 
• Telnet is a network protocol that allows us to connect to a distant server and issue commands. To use Telnet, we will need to install a Telnet client on a local machine and connect to the server using the telnet command. For example: 
• Telnet Server will open a Telnet session to the server, letting us issue commands and interact with the server as if we were logged in directly. 
• Remote Desktop: If the distant server is running a graphical desktop environment, we can use a remote desktop protocol such as VNC (Virtual Network Computing) or RDP (Remote Desktop Protocol) to connect to the server and interact with it as if we were sitting in front of the machine. To use a remote desktop protocol, we will need to install a remote desktop client on the local machine and connect to the server using the appropriate protocol. 

Overall, the choice of which method to use to connect to a distant server will depend on your specific needs and the capabilities of the server. SSH and Telnet are commonly used for command-line access to servers, while remote desktop protocols are more suitable for interacting with a graphical desktop environment. 

A must-know for anyone heading into a Shell Scripting interview, this is one of the most frequently asked UNIX Scripting interview questions.

To find the number of lines in a file that contains the word "LINUX" using a bash shell script, we can use the grep command with the -c option. 

Below is an example of a script that you can use to find the number of lines in a file called "file.txt" that contain the word "LINUX": 

# Find the count of lines containing "LINUX" in the file 
line_count=$(grep -c "LINUX" "file.txt") 
# Print the result 

echo "Number of lines containing LINUX: $line_count" 

This script will execute the grep command with the -c option, which searches for the specified pattern ("LINUX") in the file and counts the number of lines that match the pattern. The output of the grep command will be captured by the $(...) syntax and stored in the line_count variable. The script will then print the value of the line_count variable using the echo command. 

We can also use the -i option to ignore case when searching for the pattern, or the -w option to match only whole words. 

For example, to search for the pattern "linux" regardless of case, we can use the following script: 

# Find the count of lines containing "linux" in the file, ignoring case 
line_count=$(grep -ci "linux" "file.txt") 
# Print the result 
echo "Number of lines containing linux: $line_count" 

These types of questions are shell scripting scenario-based interview questions and generally asked with experienced candidates. 

To print a list of every user's login names on a Unix-like system, we can use the cut and sort commands to extract the login names from the /etc/passwd file and sort them alphabetically. 

Below is an example of a command sequence that we can use to print a list of login names: 

# Extract the login names from the /etc/passwd file 
login_names=$(cut -d: -f1 /etc/passwd) 
# Sort the login names alphabetically 
sorted_login_names=$(echo "$login_names" | sort) 
# Print the login names 
echo "$sorted_login_names" 

This script will use the cut command to extract the first field (the login name) from each line of the /etc/passwd file, using the : character as the delimiter. The output of the cut command will be stored in the login_names variable. 

The script will then use the sort of command to sort the login names alphabetically, and store the sorted list in the sorted_login_names variable. Finally, the script will use the echo command to print the login names. 

The /etc/passwd file is a system file that contains information about the users on the system, including their login names, home directories, and other details. Each line of the file represents a single user, and the fields are separated by: characters.  

There are several ways to send mail using a shell script. One option is to use the mail command, which is a command-line utility for sending and receiving mail.

To use the mail command to send a message, you can use the following syntax: 

echo "message" | mail -s "subject" recipient@example.com 

This will send a message with the specified subject to the specified recipient. The message can be entered directly on the command line, or it can be piped to the mail command from another command. 

For example, to send a message with the subject "Hello" to the recipient "user@example.com", you can use the following command: 

echo "Hello, how are you?" | mail -s "Hello" user@example.com 

We can also use the -a option to attach a file to the message or the -c option to specify a carbon copy recipient. 

For example, to send a message with the subject "Hello" to the recipient "user@example.com", with a carbon copy to "cc@example.com" and an attachment "attachment.txt", we can use the following command: 

echo "Hello, here is the attachment you requested." | mail -s "Hello" -a "attachment.txt" -c cc@example.com user@example.com 

A common question in Shell Scripting interviews, don't miss this one.