{"id":4698,"date":"2015-05-02T22:26:51","date_gmt":"2015-05-02T14:26:51","guid":{"rendered":"http:\/\/rmohan.com\/?p=4698"},"modified":"2015-05-04T13:39:14","modified_gmt":"2015-05-04T05:39:14","slug":"bash-reference","status":"publish","type":"post","link":"https:\/\/mohan.sg\/?p=4698","title":{"rendered":"bash reference"},"content":{"rendered":"

Shell program<\/p>\n

View System Date, Calender<\/p>\n

Calender<\/p>\n

[root@cluster1 ~]# cal
\n April 2015
\nSu Mo Tu We Th Fr Sa
\n 1 2 3 4
\n 5 6 7 8 9 10 11
\n12 13 14 15 16 17 18
\n19 20 21 22 23 24 25
\n26 27 28 29 30<\/p>\n

[root@cluster1 ~]# cal 7 2015
\n July 2015
\nSu Mo Tu We Th Fr Sa
\n 1 2 3 4
\n 5 6 7 8 9 10 11
\n12 13 14 15 16 17 18
\n19 20 21 22 23 24 25
\n26 27 28 29 30 31<\/p>\n

date <\/p>\n

Syntax to specify format
\ndate +FORMAT<\/p>\n

[root@cluster1 ~]# date
\nMon Apr 27 23:14:35 SGT 2015
\n[root@cluster1 ~]# date ‘+DATE:%m-%y%nTime:%H:%M:%S’
\nDATE:04-15
\nTime:23:15:14
\n[root@cluster1 ~]#<\/p>\n

[root@cluster1 ~]# date +%Y%m%d
\n20150427
\n[root@cluster1 ~]# date +%Y-%m-%d
\n2015-04-27
\n[root@cluster1 ~]# date ‘+%d\/%m\/%Y_%H:%M:%S
\n[root@cluster1 ~]# date ‘+%d\/%m\/%Y_%H:%M:%S’
\n27\/04\/2015_23:16:39
\n[root@cluster1 ~]# date ‘+%d\/%m\/%Y-%H:%M:%S’
\n27\/04\/2015-23:16:49<\/p>\n

[root@cluster1 ~]# date +”%x %r %Z”
\n04\/27\/2015 11:18:01 PM SGT<\/p>\n

[root@cluster1 ~]# right_now=$(date +”%x %r %Z”)
\ntime_stamp=”Updated on $right_now by $USER”
\n[root@cluster1 ~]# echo $time_stamp
\nUpdated on 04\/27\/2015 11:18:23 PM SGT by root<\/p>\n

Task: Display date in mm-dd-yy format
\nType the command as follows:
\n$ date +”%m-%d-%y”
\nOutput:
\n02-27-07
\nTurn on 4 digit year display:
\n$ date +”%m-%d-%Y”
\nJust display date as mm\/dd\/yy format:
\n$ date +”%D”
\nTask: Display time only
\nType the command as follows:
\n$ date +”%T”
\nOutput:
\n19:55:04
\nDisplay locale\u2019s 12-hour clock time
\n$ date +”%r”
\nOutput:
\n07:56:05 PM
\nDisplay time in HH:MM format:
\n$ date +”%H-%M”
\nHow do I save time\/date format to a variable?
\nSimply type command as follows at a shell prompt:
\n$ NOW=$(date +”%m-%d-%Y”)
\nTo display a variable use echo \/ printf command:
\n$ echo $NOW
\nSample shell script:
\n#!\/bin\/bash
\nNOW=$(date +”%m-%d-%Y”)
\nFILE=”backup.$NOW.tar.gz”
\n# rest of script Complete list of FORMAT control characters supported by date command
\nFORMAT controls the output.It can be the combination of any one of the following:
\n%%
\na literal %
\n%a
\nlocale’s abbreviated weekday name (e.g., Sun)
\n%A
\nlocale’s full weekday name (e.g., Sunday)
\n%b
\nlocale’s abbreviated month name (e.g., Jan)
\n%B
\nlocale’s full month name (e.g., January)
\n%c
\nlocale’s date and time (e.g., Thu Mar 3 23:05:25 2005)
\n%C
\ncentury; like %Y, except omit last two digits (e.g., 21)
\n%d
\nday of month (e.g, 01)
\n%D
\ndate; same as %m\/%d\/%y
\n%e
\nday of month, space padded; same as %_d
\n%F
\nfull date; same as %Y-%m-%d
\n%g
\nlast two digits of year of ISO week number (see %G)
\n%G
\nyear of ISO week number (see %V); normally useful only with %V
\n%h
\nsame as %b
\n%H
\nhour (00..23)
\n%I
\nhour (01..12)
\n%j
\nday of year (001..366)
\n%k
\nhour ( 0..23)
\n%l
\nhour ( 1..12)
\n%m
\nmonth (01..12)
\n%M
\nminute (00..59)
\n%n
\na newline
\n%N
\nnanoseconds (000000000..999999999)
\n%p
\nlocale’s equivalent of either AM or PM; blank if not known
\n%P
\nlike %p, but lower case
\n%r
\nlocale’s 12-hour clock time (e.g., 11:11:04 PM)
\n%R
\n24-hour hour and minute; same as %H:%M
\n%s
\nseconds since 1970-01-01 00:00:00 UTC
\n%S
\nsecond (00..60)
\n%t
\na tab
\n%T
\ntime; same as %H:%M:%S
\n%u
\nday of week (1..7); 1 is Monday
\n%U
\nweek number of year, with Sunday as first day of week (00..53)
\n%V
\nISO week number, with Monday as first day of week (01..53)
\n%w
\nday of week (0..6); 0 is Sunday
\n%W
\nweek number of year, with Monday as first day of week (00..53)
\n%x
\nlocale’s date representation (e.g., 12\/31\/99)
\n%X
\nlocale’s time representation (e.g., 23:13:48)
\n%y
\nlast two digits of year (00..99)
\n%Y
\nyear
\n%z
\n+hhmm numeric timezone (e.g., -0400)
\n%:z
\n+hh:mm numeric timezone (e.g., -04:00)
\n%::z
\n+hh:mm:ss numeric time zone (e.g., -04:00:00)
\n%:::z
\nnumeric time zone with : to necessary precision (e.g., -04, +05:30)
\n%Z<\/p>\n

Retrieve yesterday date using bash shell <\/p>\n

$ date ‘+%A, %Y-%m-%d’
\nSaturday, 2014-06-28
\n$ date -d “yesterday” ‘+%A, %Y-%m-%d’
\nFriday, 2014-06-27<\/p>\n

[root@cluster1 ~]# echo “Today is `date +%A` `date +%e`th of `date +%B` ”
\nToday is Wednesday 29th of April<\/p>\n

A specific date minus one day, formatted as we wish:
\ndate -d “2014-10-01 -1 day” +%Y-%m-%d
\n2014-09-30<\/p>\n

==============================================================================================================================<\/p>\n

Create Files & Directories<\/p>\n

a) touch
\nb) mkdir <\/p>\n

mkdir dir1
\nmkdir – create directory
\nmkdir command can take more arguments. For example we can take two directories with only one command:<\/p>\n

mkdir dir2 dir3
\nmkdir – create two directories
\nmkdir command can also create entire directory tree. By using -p option mkdir will also create parent directories if required:<\/p>\n

mkdir -p dir4\/dir4.1 <\/p>\n

mkdir -m 744 dir5 <\/p>\n

mkdir -p \/home\/mohan\/test1 \/home\/mohan\/test2 \/home\/mohan\/test3 <\/p>\n

c) PWD<\/p>\n

d) cat <\/p>\n

cat > test
\nthis test file <\/p>\n

cat < test\nthis test file \n\n\ncat test test1 > test2 <\/p>\n

cat test2
\nthis test file
\nthis test1 file<\/p>\n

e) touch <\/p>\n

g) mv<\/p>\n

h) rm<\/p>\n

i) rmdir<\/p>\n

=======================================================================================================================
\nCopies, Links to Files & Directories<\/p>\n

copy <\/p>\n

cp [OPTION]… [-T] SOURCE DEST
\ncp [OPTION]… SOURCE… DIRECTORY
\ncp [OPTION]… -t DIRECTORY SOURCE… <\/p>\n

-i, –interactive
\n prompt before overwrite
\n-p same as –preserve=mode,ownership,timestamps
\n-R, -r, –recursive
\n copy directories recursively
\n-v, –verbose explain what is being done <\/p>\n

cp -r dir2\/ dir1\/ <\/p>\n

Copy file1 from dir1 to dir2 but prompt before overwrite:<\/p>\n

cp -i dir1\/file1 dir2\/ <\/p>\n

Copy file1 from dir1 to dir2 but prompt before overwrite:<\/p>\n

cp -i dir1\/file1 dir2\/ <\/p>\n

Link command <\/p>\n

HARD LINK :It is copy of the old file to new file if the source file is deleted still we can have the use link file <\/p>\n

ln old new <\/p>\n

ln with soft link<\/p>\n

SOFT LINK :It is copy of the old file to if the source file is deleted we wil lose the new link as well.<\/p>\n

ln -s old old_soft<\/p>\n

rm old <\/p>\n

cat old_soft
\nerror doesnt exist <\/p>\n

=========================================================================================================================
\nFile Permissions list files ls<\/p>\n

chmod 775
\numask<\/p>\n

ls <\/p>\n

ls -d<\/p>\n

ls -l<\/p>\n

=====================================================================================================================================
\nuname -a <\/p>\n

#!\/bin\/sh<\/p>\n

SYSTEM=`uname -s`
\nif [ $SYSTEM = “Linux” ] ; then
\necho “Linux”
\nelif [ $SYSTEM = “FreeBSD” ] ; then
\necho “FreeBSD”
\nelif [ $SYSTEM = “Solaris” ] ; then
\necho “Solaris”
\nelse
\necho “What?”
\nfi <\/p>\n

#system info
\nsystem_info() {
\necho “**********************************************”
\necho “system info:”
\necho
\necho ” System-release : `cat \/etc\/redhat-release`”
\necho ” Kernel-release : `uname -a|awk ‘{print $1,$3}’`”
\necho ” Server-Model : `dmidecode | grep “Product Name:”|sed -n ‘1p’|awk -F’: ‘ ‘{print $2}’`”
\necho
\n} <\/p>\n

fn_distro(){
\narch=$(uname -m)
\nkernel=$(uname -r)
\nif [ -f \/etc\/lsb-release ]; then
\n os=$(lsb_release -s -d)
\nelif [ -f \/etc\/debian_version ]; then
\n os=”Debian $(cat \/etc\/debian_version)”
\nelif [ -f \/etc\/redhat-release ]; then
\n os=`cat \/etc\/redhat-release`
\nelse
\n os=”$(uname -s) $(uname -r)”
\nfi
\n} <\/p>\n

#!\/bin\/bash
\nfn_distro(){
\narch=$(uname -m)
\nkernel=$(uname -r)
\nif [ -f \/etc\/lsb-release ]; then
\n os=$(lsb_release -s -d)
\nelif [ -f \/etc\/debian_version ]; then
\n os=”Debian $(cat \/etc\/debian_version)”
\nelif [ -f \/etc\/redhat-release ]; then
\n os=`cat \/etc\/redhat-release`
\nelse
\n os=”$(uname -s) $(uname -r)”
\nfi
\n}<\/p>\n

fn_uptime(){
\nuptime=$(
\n===================================================================================================================<\/p>\n

Count Lines, Words & Characters Using ‘wc’<\/p>\n

$ cat sample.txt
\ntoday is a
\ngood day<\/p>\n

$ wc -w sample.txt
\n5 sample.txt<\/p>\n

time perl -nle ‘$word += scalar(split(” “, $_)); END{print $word}’ subst.c<\/p>\n

real 0m0.021s
\nuser 0m0.016s
\nsys 0m0.004s<\/p>\n

wc -l : Prints the number of lines in a file.
\nwc -w : prints the number of words in a file.
\nwc -c : Displays the count of bytes in a file.
\nwc -m : prints the count of characters from a file.
\nwc -L : prints only the length of the longest line in a file.
\n===================================================================================================================
\nsort <\/p>\n

cat > animals
\nowls
\ncamels
\npigs
\ndogs
\nlions
\nelephants
\nasses<\/p>\n

ctrl D<\/p>\n

base ball
\n[root@cluster1 tmp]# sort animals
\nasses
\ncamels
\ndogs
\nelephants
\nlions
\nowls
\npigs
\n[root@cluster1 tmp]# sort sports
\nbase ball
\ncricket
\nice hockey
\nsoccer<\/p>\n

$ cat test
\nzzz
\nsss
\nqqq
\naaa
\nBBB
\nddd
\nAAA<\/p>\n

sort test <\/p>\n

Create the following test file for this example:<\/p>\n

$ cat test
\n2K
\n2G
\n1K
\n6T
\n1T
\n1G
\n2M
\nThe following sort command sorts human readable numbers (i.e 1K = 1 Thousand, 1M = 1 Million, 1G = 1 Giga, 1T = 1 Tera) in test file and displays sorted output.<\/p>\n

$ sort -h test
\n1K
\n2K
\n2M
\n1G
\n2G
\n1T
\n6T
\n3. Sort Months of an Year using -M option<\/p>\n

If we want to sort in the order of months of year, then we can use -M or \u2013month-sort option.<\/p>\n

Create the following test file for this example:<\/p>\n

$ cat test
\nsept
\naug
\njan
\noct
\napr
\nfeb
\nmar11
\nThe following sort command sorts lines in test file as per month order. Note, lines in file should contain at least 3 character name of month name at start of line (e.g. jan, feb, mar). If we will give, ja for January or au for August, then sort command would not consider it as month name.<\/p>\n

$ sort -M test
\njan
\nfeb
\nmar11
\napr
\naug
\nsept
\noct
\n4. Check if Content is Already Sorted using -c option<\/p>\n

If we want to check data in text file is sorted or not, then we can use -c or \u2013check, \u2013check=diagnose-first option.<\/p>\n

Create the following test file for this example:<\/p>\n

$ cat test
\n2
\n5
\n1
\n6
\nThe following sort command checks whether text file data is sorted or not. If it is not, then it shows first occurrence with line number and disordered value.<\/p>\n

$ sort -c test
\nsort: test:3: disorder: 1
\n5. Reverse the Output and Check for Uniqueness using -r and -u options<\/p>\n

If we want to get sorted output in reverse order, then we can use -r or \u2013reverse option. If file contains duplicate lines, then to get unique lines in sorted output, \u201c-u\u201d option can be used.<\/p>\n

Create the following test file for this example:<\/p>\n

$ cat test
\n5
\n2
\n2
\n1
\n4
\n4
\nThe following sort command sorts lines in test file in reverse order and displays sorted output.<\/p>\n

$ sort -r test
\n5
\n4
\n4
\n2
\n2
\n1
\nThe following sort command sorts lines in test file in reverse order and removes duplicate lines from sorted output.<\/p>\n

$ sort -r -u test
\n5
\n4
\n2
\n1
\n6. Selectively Sort the Content, Customize delimiter, Write output to a file using -k, -t, -o options<\/p>\n

If we want to sort on the column or word position in lines of text file, then \u201c-k\u201d option can be used. If we each word in each line of file is separated by delimiter except \u2018space\u2019, then we can specify delimiter using \u201c-t\u201d option. We can get sorted output in any specified output file (using \u201c-o\u201d option) instead of displaying output on standard output.<\/p>\n

Create the following test file for this example:<\/p>\n

$ cat test
\naa aa zz
\naa aa ff
\naa aa tt
\naa aa kk
\nThe following sort command sorts lines in test file on the 3rd word of each line and displays sorted output.<\/p>\n

$ sort -k3 test
\naa aa ff
\naa aa kk
\naa aa tt
\naa aa zz
\n$ cat test
\naa|5a|zz
\naa|2a|ff
\naa|1a|tt
\naa|3a|kk
\nHere, several options are used altogether. In test file, words in each line are separated by delimiter \u2018|\u2019. It sorts lines in test file on the 2nd word of each line on the basis of numeric value and stores sorted output into specified output file.<\/p>\n

$ sort -n -t’|’ -k2 test -o outfile
\nThe contents of output file are shown below.<\/p>\n

$ cat outfile
\naa|1a|tt
\naa|2a|ff
\naa|3a|kk
\naa|5a|zz<\/p>\n

sort -r filename.txt<\/p>\n

Example6: Some times its required to sort the file and display only uniq values.<\/p>\n

sort -u filename<\/p>\n

Note: though the values on other field are different this will not consider by -u option.<\/p>\n

Example7: I want to sort a file according to my requirement and save it to a different file. Use -o option to save the sorted output to a file.<\/p>\n

sort -o temp.txt filename.txt<\/p>\n

Example8: Do you have file content with sizes like 10K, 20G, 45M, 32T etc. You can sort accourding to human readable by using -h option. This option works RHEL5 and above versions.<\/p>\n

sort -h filename.txt<\/p>\n

Similar to above example we can use -m for sorting according to month of the year.<\/p>\n

sort -M filename.txt<\/p>\n

Example9: Check if the file is alrady in sorted format or not by using -c option. This option will show you what is the first occurence disorderd value.<\/p>\n

sort -c filename.txt<\/p>\n

You can now mix above options to get your sorting work done.<\/p>\n

There are two types of sorting keys definition in Unix sort:<\/p>\n

new (with -k option)
\nold (+n -n).<\/p>\n

New-style sort keys definitions<\/p>\n

New style definition use -k option:
\n-k field_start [type] [,field_end [type] ]<\/p>\n

where:
\nfield_start and field_end
\ndefine a key field restricted to a portion of the line.<\/p>\n

type
\nis a modifier from the list of characters bdfiMnr. The b modifier behaves like the -b option, but applies only to the field_start or field_end to which it is attached and characters within a field are counted from the first non-blank character in the field. (This applies separately to first_character and last_character.) The other modifiers behave like the corresponding options, but apply only to the key field to which they are attached. They have this effect if specified with field_start, field_end or both. If any modifier is attached to a field_start or to a field_end, no option applies to either.<\/p>\n

When there are multiple key fields, later keys are compared only after all earlier keys compare equal. Except when the -u option is specified, lines that otherwise compare equal are ordered as if none of the options -d, -f, -i, -n or -k were present (but with -r still in effect, if it was specified) and with all bytes in the lines significant to the comparison.<\/p>\n

The notation:
\n-k field_start[type][,field_end[type]]<\/p>\n

defines a key field that begins at field_start and ends at field_end inclusive, unless field_start falls beyond the end of the line or after field_end, in which case the key field is empty. A missing field_end means the last character of the line.
\nA field comprises a maximal sequence of non-separating characters and, in the absence of option -t, any preceding field separator.<\/p>\n

The field_start portion of the keydef option-argument has the form:<\/p>\n

field_number[.first_character]<\/p>\n

Fields and characters within fields are numbered starting with 1. field_number and first_character, interpreted as positive decimal integers, specify the first character to be used as part of a sort key. If .first_character is omitted, it refers to the first character of the field.<\/p>\n

The field_end portion of the keydef option-argument has the form:<\/p>\n

field_number[.last_character]<\/p>\n

The field_number is as described above for field_start. last_character, interpreted as a non-negative decimal integer, specifies the last character to be used as part of the sort key. If last_character evaluates to zero or .last_character is omitted, it refers to the last character of the field specified by field_number.<\/p>\n

If the -b option or b type modifier is in effect, characters within a field are counted from the first non-blank character in the field. (This applies separately to first_character and last_character.)<\/p>\n

Old-style keys definition
\nThere is also “old-style” key definition[+pos1 [-pos2]] that are now formally obsolite, but still is extremly widely used. Provide functionality equivalent to the -kkeydef option.<\/p>\n

pos1 and pos2 each have the form m.n optionally followed by one or more of the flags bdfiMnr. A starting position specified by +m.n is interpreted to mean the n+1st character in the m+1st field. A missing .n means .0, indicating the first character of the m+1st field. If the b flag is in effect n is counted from the first non-blank in the m+1st field; +m.0b refers to the first non-blank character in the m+1st field.<\/p>\n

A last position specified by -m.n is interpreted to mean the nth character (including separators) after the last character of the mth field. A missing .n means .0, indicating the last character of the mth field. If the b flag is in effect n is counted from the last leading blank in the m+1st field; -m.1b refers to the first non-blank in the m+1st field.<\/p>\n

The fully specified +pos1 -pos2 form with type modifiers T and U: +w.xT -y.zU<\/p>\n

is equivalent to:<\/p>\n

undefined (z==0 & U contains b & -t is present)
\n-k w+1.x+1T,y.0U (z==0 otherwise)
\n-k w+1.x+1T,y+1.zU (z > 0)<\/p>\n

Implementations support at least nine occurrences of the sort keys (the -k option and obsolescent +pos1 and -pos2) which are significant in command line order. If no sort key is specified, a default sort key of the entire line is used.<\/p>\n

If the ordering rule options precede the sort key options, they are globally applied to all sort keys. For example, sort -r +2 -3 infile
\nreverses the order based on field 3. If the ordering rule options are attached to a sort key option, they override the global ordering options for only that sort key. For example,<\/p>\n

sort -r +2d -3d infile<\/p>\n

sorts field 3 by dictionary comparison but sorts the rest of the line using reverse comparison.<\/p>\n

The most common mistake is to forget to use -n option for sorting numeric fields. Also specifying delimiter (option -t) with an unquoted character after it can be a source of problems; it’s better to use single quotes around the character that you plan to use as a delimiter. for example -t ‘:’<\/p>\n

The most common mistake is to forget to use -n option for sorting numeric fields<\/p>\n

Here is a standard example of usage of the sort utility, sorting \/etc\/passwd file (user database) by UID (the third colon-separated field in the passwd file structure):<\/p>\n

sort -t ‘:’ +2 \/etc\/passwd # incorrect result, the field is numeric
\nsort -n -t ‘:’ +2 \/etc\/passwd # order of the numbers is now correct<\/p>\n

sort -t ‘:’ -k 3,3n \/etc\/passwd
\nsort -t ‘:’ +2 -3n \/etc\/passwd
\nsort -n -t ‘:’ -k 3,3 \/etc\/passwd<\/p>\n

See Sorting key definitions and Examples for more details. Generally you will be surprised how often the result is not what you want due to the obscurity of the definitions<\/p>\n

Be careful and always test your sorting keys on a small sample before sorting the whole file. You will be surprised how often the result is not what you want.<\/p>\n

By default sort sorts the file in ascending order using the entire line as a sorting key. Please note that a lot of WEB resources interpret this sort utility behavior incorrectly (most often they state that by default sorting is performed on the first key).<\/p>\n

The three most important options of Unix soft are -n (numeric keys sorting), +n (sorting using n-th field, counting from zero) and -r (sort in reverse). For example:
\nSort the entire lines as a key: sort
\nSort in numeric order: sort -n
\nSort on n+1 st field (old style key definition): sort +n<\/p>\n

Comparisons are based on one or more sort keys extracted from each line of input. Again, please remember that by default, there is one sort key, the entire input line.<\/p>\n

Lines are ordered according to the collating sequence of the current locale. By changing locale you can change the behavior of the sort.<\/p>\n

In Solaris there are two variants of sort: System V version and BSD version. Both have identical options:<\/p>\n

\/usr\/bin\/sort [ -cmu ] [ -o output ] [ -T directory ] [ -y [ kmem ]] [ -z recsz ] [ -dfiMnr ] [ – b ] [ t char ] [ -k keydef ] [ +pos1 [ -pos2 ]] [ file…] <\/p>\n

\/usr\/xpg4\/bin\/sort [ -cmu ] [ -o output ] [ -T directory ] [ -y [ kmem ]] [ -z recsz ] [ – dfiMnr ] [ -b ] [ -t char ] [ -k keydef ] [ +pos1 [ -pos2 ]] [ file…]<\/p>\n

The sort command can (and should) be used in pipes or have its output redirected as desired. Here are some practically important examples that illustrates using of this utility (for more examples please look into our sort examples collection page): <\/p>\n

1. Sort the file and display the sorted file, one page at a time. (If you prefer the standard command “more”, you can use this instead of “less”. “less” is an enhanced version of “more” – for example, it allows you to move backwards and forwards in the file; to exit “less” , use “q”.)
\nsort file less <\/p>\n

2. Read and sorts infile and display the result on standard output, which has been redirected to outfile:<\/p>\n

sort infile > outfile # sorts infile and writes the results to outfile <\/p>\n

3. Write sorted output directly to outfile.<\/p>\n

sort -o outfile infile # same as in 1, but using an option -o <\/p>\n

4. Read and sort infile “in place” writing to the same file<\/p>\n

sort -o infile infile # sort file “in place” <\/p>\n

5. Sort the file and pipe it to uniq command with the number of identical keys counter printed (-c option in uniq)<\/p>\n

sort infile uniq -c <\/p>\n

6. Pipe the output of the who command to the input of the sort command:<\/p>\n

who sort <\/p>\n

7. Classic “number of instances” analysis of log files:<\/p>\n

cat messages awk ‘{“select the keywords”}’ sort uniq -c sort -nr<\/p>\n

In simple cases cut can be used instead of AWK. For example the following example couts distinc visitors from HTTP logs (assuming this is the first field in the logs):<\/p>\n

cat http.log cut -d ” ” -f 1 sort uniq -c sort -nr <\/p>\n

8. Sort the file, then prepend line numbers to each line (not many Unix adminitrators know that cat can be used to number lines):<\/p>\n

sort -n file cat -n<\/p>\n

This can be useful if you want to count the number of lines in which the first entry is in a given range: simply subtract the line numbers corresponding to the beginning and end of the range. <\/p>\n

As I mentioned about by default the sort command uses entire lines as a key. It compares the characters starting with the first, until non-matching character or the end of the shortest line. Leading blanks (spaces and tabs) are considered valid characters to compare. Thus a line beginning with a space precedes a line beginning with the letter A. If you do not want this effect you need to delete leading spaces beforehand. <\/p>\n

Multiple sort keys may be used on the same command line. If two lines have the same value in the same field, sort uses the next set of sort keys to resolve the equal comparison. For example,<\/p>\n

sort +4 -5 +1 -2 infile<\/p>\n

means to sort based on field 5 (+4 -5). If two lines have the same value in field 5, sort those two lines based on field 2 (+1 -2).<\/p>\n

Beside sorting Unix sort is useful for merging files (option -m). It can also checked whether the file is sorted or not (option -c). It can also suppress duplicates (option -u):<\/p>\n

-c Check whether the given files are already sorted: if they are not all sorted, print an error message and exit with a status of 1.<\/p>\n

-m Merge the given files by sorting them as a group. Each input file should already be individually sorted. It always works to sort instead of merge; merging is provided because it is faster, in the case where it works.<\/p>\n

-u Suppress all but one occurrence of matching keys.<\/p>\n

In case Unix sort does not produce the required results you might want to look into Perl built-in function. If it is too slow more memory can be specified on invocation.<\/p>\n

The most important options<\/p>\n

The following list describes the options and their arguments that may be used to control how sort functions.<\/p>\n

– Forces sort to read from the standard input. Useful for reading from pipes and files simultaneously.<\/p>\n

-c Verifies that the input is sorted according to the other options specified on the command line. If the input is sorted correctly then no output is provided. If the input is not sorted then sort informs you of the situation. The message resembles this.<\/p>\n

sort: disorder: This line not in sorted order.<\/p>\n

-m Merges the sorted input. sort assumes the input is already sorted. sort normally merges input as it sorts. This option informs sort that the input is already sorted, thus sort runs much faster.<\/p>\n

-o output Sends the output to file output instead of the standard output. The output file may be the same name as one of the input files.<\/p>\n

-u Suppress all but one occurrence of matching keys. Normally, the entire line is the key. If field or character keys are specified, then the suppressing is done based on the keys.<\/p>\n

-y kmem Use kmem kilobytes of main memory to initially start the sorting. If more memory is needed, sort automatically requests it from the operating system. The amount of memory allocated for the sort impacts the speed of the sort significantly. If no kmem is specified, sort starts with the default amount of memory (usually 32K). The maximum (usually 1 Megabyte) amount of memory may be allocated if needed. If 0 is specified for kmem, the minimum (usually 16K) amount of memory is allocated.<\/p>\n

-z recsz Specifies the record size used to store each line. Normally the recsz is set to the longest line read during the sort phase. If the -c or -m options are specified, the sort phase is not performed and thus the record size defaults to a system size. If this default size is not large enough, sort may abort during the merge phase. To alleviate this problem you can specify a recsz that will allow the merge phase to run without aborting.<\/p>\n

Ordering Options<\/p>\n

-d Specifies dictionary sort. Only blanks, digits, and alphabetic characters are significant in the comparison.<\/p>\n

-f Fold lowercase letters to uppercase. Ignores the difference between upper and lowercase ASCII characters.<\/p>\n

-i Ignore characters outside the ASCII range of 040 (octal) and 0176 (octal). Only alphabetic characters, blanks, digits, and punctuation are used for comparison (printable characters). Control characters are ignored. This is only valid for nonnumeric sorts.<\/p>\n

-M Compare fields as months. The first three nonblank characters are folded (see -i option) to uppercase and compared. Thus January is compared as JAN. JAN precedes FEB, and fields not containing months precede JAN. The -b option is placed in effect automatically.<\/p>\n

-n Sorts the input numerically. The comparison is based on numerical value instead of alphabetic value. The number field used for comparison can contain optional blanks, optional minus signs, optional decimal point, and zero or more digits. The -b option is placed in effect automatically. Exponential numbers are not sorted correctly.<\/p>\n

-r Reverse the order of the output.<\/p>\n

Old-style Sort Key Options<\/p>\n

+pos1
\nSpecifies the beginning position of the input line used for field comparison. If pos1 is not specified then comparison begins at the beginning of the line. The pos1 position has the notation of f.c. The f specifies the number of fields to skip. The c specifies the number of characters to skip. For example, 3.2 is interpreted as skip three fields and two characters before performing comparisons. Omitting the .c portion is equivalent to specifying .0. Field one is referred to as position 0. If f is set to 0 then character positions are used for comparison.<\/p>\n

-pos2
\nSpecifies the ending position of the input line used for field comparison. If pos2 is not specified then comparison is done through the end of the line. The pos2 position has the notation of f.c. The f specifies to compare through field f. The c specifies the number of characters to compare through after field f. For example, -4.3 is interpreted as compare through three characters after the end of field four. Omitting the .c portion is equivalent to specifying .0.<\/p>\n

-b
\nIgnores leading blanks when using the restricted sort key positions (+pos1 and -pos2). If the -b option is placed before the first +pos1 argument, then it applies to all +pos1 arguments. The -b option can be attached to each pos string to affect only that field.<\/p>\n

-t c
\nUse character c as the field separator. Multiple adjacent c’s in the records are interpreted empty fields surrounded by separators. If you need to use multiple characters as a separator you need to convert record so that they are represented by a single character using sed or AWK. You can use nonprintable characters as a separator to ensure their uniqueness.<\/p>\n

Old News \ud83d\ude09
\n[Jul 14, 2007] My SysAd Blog — UNIX Sort Files by Their Filesizes
\nHere’s a convenient way of finding those space hogs in your home directory (can be any directory). For me, those large files are usually a result of mkfile event (testing purposes) and can be promptly deleted. Here’s an example of its use.<\/p>\n

#cd \/export\/home\/esofthub
\n#ls -l sort +4n awk ‘{print $5 “\\t” $9}’<\/p>\n

Find recursively (a little awkward)
\n#ls -lR sort +4n awk ‘{print $5 “\\t” $9}’ more<\/p>\n

ps -ef sort<\/p>\n

This command pipeline sorts the output of the “ps -ef” command. Because no arguments are supplied to the sort command, the output is sorted in alphabetic order by the first column of the ps -ef output (i.e., the output is sorted alphabetically by username).<\/p>\n

ls -al sort +4n<\/p>\n

This command performs a numeric sort on the fifth column of the “ls -al” output. This results in a file listing where the files are listed in ascending order, from smallest in size to largest in size.<\/p>\n

ls -al sort +4n more<\/p>\n

The same command as the previous, except the output is piped into the more command. This is useful when the output will not all fit on one screen.<\/p>\n

ls -al sort +4nr<\/p>\n

This command reverses the order of the numeric sort, so files are listed in descending order of size, with the largest file listed first, and the smallest file listed last.<\/p>\n

[Feb 15, 2007] UNIX Disk Usage Simplifying Analysis with sort
\nThe output of du has been very informative, but it’s difficult to scan a listing to ascertain the four or five largest directories, particularly as more and more directories and files are included in the output. The good news is that the Unix sort utility is just the tool we need to sidestep this problem.
\n# du -s * sort -nr
\n13984 Lynx
\n10464 IBM
\n3092 Gator
\n412 bin
\n196 DEMO
\n84 etcpasswd
\n76 CBO_MAIL
\n48 elance
\n36 CraigsList
\n16 Exchange
\n4 gettermsheet.sh
\n4 getstocks.sh
\n4 getmodemdriver.sh
\n4 buckaroo
\n4 browse.sh
\n4 badjoke.rot13
\n4 badjoke
\n0 gif.gif<\/p>\n

One final concept and we’re ready to move along. If you want to only see the five largest files or directories in a specific directory, all that you’d need to do is pipe the command sequence to head:<\/p>\n

# du -s * sort -nr head -5
\n13984 Lynx
\n10464 IBM
\n3092 Gator
\n412 bin
\n196 DEMO<\/p>\n

The ! command (pronounced “bang”) creates a temporary file to be used with a program that requires a filename in its command line. This is useful with shells that don’t support process substitution. For example, to diff two files after sorting them, you might do:<\/p>\n

diff `! sort file1` `! sort file2`<\/p>\n

This command pipeline sorts the output of the “ps -ef” command. Because no arguments are supplied to the sort command, the output is sorted in alphabetic order by the first column of the ps -ef output (i.e., the output is sorted alphabetically by username).<\/p>\n

ls -al sort +4n<\/p>\n

This command performs a numeric sort on the fifth column of the “ls -al” output. This results in a file listing where the files are listed in ascending order, from smallest in size to largest in size.<\/p>\n

ls -al sort +4n more<\/p>\n

The same command as the previous, except the output is piped into the more command. This is useful when the output will not all fit on one screen.<\/p>\n

ls -al sort +4nr<\/p>\n

This command reverses the order of the numeric sort, so files are listed in descending order of size, with the largest file listed first, and the smallest file listed last.
\n======================================================================================================================================<\/p>\n

Cut Command<\/p>\n

Linux command cut is used for text processing. You can use this command to extract portion of text from a file by selecting columns.<\/p>\n

Cutting specific fileds
\nComma as Delimiter
\nSpace as Delimiter
\nPipe as Delimiter
\nCutting from first field
\nCutting till last field
\nCutting range of fields
\nIgnore lines without delimiter
\nInvert field selection
\nSpecify output delimiter
\nCut specified characters
\nCut specified bytes<\/p>\n

-c, –characters=LIST
\n select only these characters
\n-d, –delimiter=DELIM
\n use DELIM instead of TAB for field delimiter
\n-f, –fields=LIST
\n select only these fields; also print any line that contains no delimiter character, unless the -s option is specified
\n-s, –only-delimited
\n do not print lines not containing delimiters<\/p>\n

The cut command, as the man page states, \u201cremoves sections from each line of a file.\u201d The cut command can also be used on a stream and it can do more than just remove section. If a file is not specified or \u201c-\u201d is used the cut command takes input from standard in. The cut command can be used to extract sections from a file or stream based upon a specific criteria. An example of this would be cutting specific fields from a csv (comma separated values) file. For instance, cut can be used to extract the name and email address from a csv file with the following content:<\/p>\n

id, date, username, first name, last name, email address, phone, fax
\n1,2012-01-01,franklinf, Ford, Franklin, ff@gmail.com, 7575551212, 7775551234
\n2,2012-02-01,levona, Allan, Levon, allanl@tllts.org, 3177771212,
\n3,2012-02-17,mannyt, Trish, Manny, tmanny@hpr.org,7275551212,8885551236<\/p>\n

he syntax for cut would be:<\/p>\n

cut -d\u201d,\u201d -f4,5,6 users.csv<\/p>\n

The result would be displayed on standard out:<\/p>\n

first name, last name, email address
\nFord, Franklin, ff@gmail.ccom
\nAllan, Levon, allanl@tllts.org
\nTrish, Manny, tmanny@hpr.org<\/p>\n

The -d option specifies the delimiter which is defaults to a TAB. In the example above the cut command will \u201ccut\u201d the line at each \u201c,\u201d instead of a TAB. The -f option indicates which fields to select, in this case fields 4, 5, and 6 which correspond to \u201cfirst name,\u201d \u201clast name,\u201d and \u201cemail address.\u201d<\/p>\n

The cut command can operate on fields, characters or bytes and must include one and only one of these options.<\/p>\n

The field option operates on the cuts defined by the delimiter (-d), which is TAB by default. The -d option can only be used with the field option. Attempting to use the -d option with the character (-c) or bytes (-b) options will result in an error. The -f value can be a command separated list or a range separated by a \u201c-\u201c:<\/p>\n

cut -d\u201d,\u201d -f 1,2,3,4
\ncut -d\u201d,\u201d -f 1-4
\ncut -f 1-4,7,9
\ncut -d\u201d,\u201d -f -7
\ncut -d\u201d,\u201d -f 7-<\/p>\n

cut is a very frequently used command for file parsing. It is very useful in splitting columns on files with or without delimiter. In this article, we will see how to use the cut command on files having a delimiter.<\/p>\n

Let us consider a sample file, say file1, with a comma as delimiter as shown below:
\n$ cat file1
\nRakesh,Father,35,Manager
\nNiti,Mother,30,Group Lead
\nShlok,Son,5,Student
\n The first column indicates name, second relationship, the third being the age, and the last one is their profession.<\/p>\n

cut command has 2 main options to work on files with delimiters:<\/p>\n

-f – To indicate which field(s) to cut.
\n -d – To indicate the delimiter on the basis of which the cut command will cut the fields.<\/p>\n

Let us now try to work with this command with a few examples:<\/p>\n

1. To get the list of names alone from the file, which is the first column:
\n$ cut -d, -f 1 file1
\nRakesh
\nNiti
\nShlok
\n The option “-d’ followed by a comma indicates to cut the file on the basis of comma. “-f” followed by 1 indicates to retrieve the field 1 from the file1, and hence we got the names alone.<\/p>\n

2. To get the relationship alone:, i.e, 2nd field
\n$ cut -d, -f 2 file1
\nFather
\nMother
\nSon
\n3. To get 2 fields, say Name and Age:
\n$ cut -d, -f 1,3 file1
\nRakesh,35
\nNiti,30
\nShlok,5
\n Giving 1,3 means to retrieve the first and third fields which happens to be name and age respectively.<\/p>\n

4. To get the name, relationship and age, excluding the profession, i.e, 1st to 3rd fields:
\n$ cut -d, -f 1-3 file1
\nRakesh,Father,35
\nNiti,Mother,30
\nShlok,Son,5
\n The option 1-3 means from first field till third field. Whenever we need a range of fields to be retrieved, we use the ‘-‘ option.<\/p>\n

The same result above can also be retrieved in other ways also:
\n$ cut -d, -f -3 file1
\nRakesh,Father,35
\nNiti,Mother,30
\nShlok,Son,5
\nThis is the best of the 3 methods to retrieve a range of fields. The option “-3” means from the beginning i.e, the first field till the third field. And hence we get the fields 1, 2 and 3.<\/p>\n

5. To retrieve all the fields except the name field. i.e, to retrieve from field 2 to field 4:
\n$ cut -d, -f 2- file1
\nFather,35,Manager
\nMother,30,Group Lead
\nSon,5,Student
\n Similar to the last result, “2-” means from the second field till the end which is the 4th field. Whenever the beginning of the range is not specified, it defaults to 1, similarly when the end of the range is not given, it defaults to the last field. The same result could have been achieved using the option “2-4″ as well.<\/p>\n

Let us consider the same input file with a space as the delimiter:
\n$ cat file1
\nRakesh Father 35 Manager
\nNiti Mother 30 GL
\nShlok Son 5 Student
\n The same options and commands used above hold good but for the delimiter specified. When comma is the delimiter, we can give it after the -d option. However, for the space as delimiter, we need to quote the delimiter as shown below. In fact, we can always quote the delimiter to be in the safer side.<\/p>\n

6. To retrieve the first field from a space delimited file:
\n$ cut -d” ” -f 1 file1
\nRakesh
\nNiti
\nShlok
\nLet us consider the same file separated by tab space:
\n$ cat file1
\nRakesh Father 35 Manager
\nNiti Mother 30 GL
\nShlok Son 5 Student
\n To actually confirm the file is indeed separated by tab space, use the “-t” option with the cat command:
\n$ cat -t file1
\nRakesh^IFather^I35^IManager
\nNiti^IMother^I30^IGL
\nShlok^ISon^I5^IStudent
\n The ^I indicates a tab space.<\/p>\n

7. To retrieve the first field from this tab separated file. How to specify the tab space with the “-d” option?
\n$ cut -f 1 file1
\nRakesh
\nNiti
\nShlok<\/p>\n

he options to cut by are below.<\/p>\n

N N\u2019th byte, character or field, counted from 1
\nN- from N\u2019th byte, character or field, to end of line
\nN-M from N\u2019th to M\u2019th (included) byte, character or field
\n-M from first to M\u2019th (included) byte, character or field<\/p>\n

The options pretty much explain themselves but I have included some simple examples below:
\nCutting by characters (command on top, output below)<\/p>\n

echo “123456789” | cut -c -5
\n12345<\/p>\n

echo “123456789” | cut -c 5-
\n56789<\/p>\n

echo “123456789” | cut -c 3-7
\n34567<\/p>\n

echo “123456789” | cut -c 5
\n5<\/p>\n

Sometimes output from a command is delimited so a cut by characters will not work. Take the example below:<\/p>\n

echo -e “1\\t2\\t3\\t4\\t5” |cut -c 5-7
\n3 4<\/p>\n

To echo a tab you have to use the -e switch to enable echo to process back slashed characters. If the desired output is 3\\t4 then this would work great if the strings were always 1 character but if anywhere before field 3 a character was added the output would be completely changed as followed:<\/p>\n

echo -e “1a\\t2b\\t3c\\t4d\\t5e” | cut -c 5-7
\nb 3<\/p>\n

This is resolved by cutting by fields.
\nCutting by fields<\/p>\n

The syntax to cut by fields is the same as characters or bytes. The two examples below display different output but are both displaying the same fields (Fields 3 Through to the end of line.)<\/p>\n

echo -e “1\\t2\\t3\\t4\\t5” | cut -f 3-
\n3 4 5<\/p>\n

echo -e “1a\\t2a\\t3a\\t4a\\t5a” | cut -f 3-
\n3a 4a 5a<\/p>\n

The default delimiter is a tab, if the output is delimited another way a custom delimiter can be specified with the -d option. It can be just about any printable character, just make sure that the character is escaped (back slashed) if needed. In the example below I cut the string up using the pipe as the delimiter.<\/p>\n

echo “1|2|3|4|5” | cut -f 3- -d \\|
\n3|4|5<\/p>\n

One great feature of cut is that the delimiter that was used for input can be changed by the output of cut. In the example below I change the format of the string from a dash delimited output and change it to a comma.<\/p>\n

echo -e “1a-2a-3a-4a-5a” | cut -f 3- -d \u2013 –output-delimiter=,
\n3a,4a,5a<\/p>\n

Formatting with Cut Example<\/p>\n

Sometimes certain Linux applications such as uptime do not have options to format the output. Cut can be used to pull out the information that is desired.
\nNormal up-time Command:<\/p>\n

root@cluster1 :~$ uptime
\n19:18:40 up 1 day, 22:15, 4 users, load average: 0.45, 0.10, 0.03<\/p>\n

Time with up-time displayed:<\/p>\n

root@cluster1 :~$ uptime |cut -d , -f 1,2 | cut -c 2-
\n19:19:36 up 1 day, 22:22<\/p>\n

For the above example I pipe the output of uptime to cut and tell it I want to split it with a comma , delimiter. I then choose fields 1 and 2. The output from that cut is piped into another cut that removes the spaces in front of the output.
\nLoad averages extracted from uptime:<\/p>\n

root@cluster1 :~$ uptime |cut -d , -f 4- | cut -c 3-
\nload average: 0.42, 0.10, 0.03<\/p>\n

This is about the same as the previous example except the fields changed. Instead of fields 1 and 2 I told it to display fields 4 through the end. The output from that is piped to another cut which removes the three spaces that were after the comma in “4 users, ” by starting at the 3rd character.
\nThe great thing about cutting by fields is that no matter if the field length changes the data stays the same. Take the example below. I now have 17 users logged in which would have broke the output if I had used -c (since there is an extra character due to a double digit number of users being logged in.)<\/p>\n

root@cluster1 :~$ uptime
\n19:25:11 up 1 day, 22:28, 17 users, load average: 0.00, 0.06, 0.04<\/p>\n

root@cluster1 :~$ uptime |cut -d , -f 4- | cut -c 3-
\nload average: 0.00, 0.06, 0.04<\/p>\n

That just about covers everything for the cut command. Now you know about it you can use cut to chop up all types of strings. It is one of the many great tools available for string manipulation in bash. If you can remember what cut does it will make your shell scripting easier, you don\u2019t need to memorize the syntax because all of the information on how to use cut is available here, in the man pages and all over the web.<\/p>\n

========================================================================================================================================================================================================
\nConvert & Copy Files With ‘dd’<\/p>\n

The Linux command \u2018dd\u2019 is one of the very powerful utility which can be used in a variety of ways. This tool is mainly used for copying and converting data, hence it stands for \u2018data duplicator\u2019.<\/p>\n

This tool can be used for.<\/p>\n

\u2022 Backing up and restoring an entire hard drive or a partition<\/p>\n

\u2022 Copy regions of raw device files like backing up MBR(master boot record)<\/p>\n

\u2022 Converting data formats like ASCII to EBCDIC<\/p>\n

\u2022 Converting lowercase to uppercase and vice versa<\/p>\n

\u2022 Creating files with fixed size<\/p>\n

Only superuser can execute this command. You should be very careful while using this command as improper usage may cause huge data loss. So, some people consider this tool as \u2018data destroyer\u2019.<\/p>\n

Syntax of \u2018dd\u2019 command<\/p>\n

dd if=of= [Options]<\/p>\n

[root@cluster1 tmp]# cat doc
\nHi how are you and Now you know about it you can use cut to chop up all types of strings.<\/p>\n

[root@cluster1 tmp]# dd if=doc of=out conv=ucase
\n0+1 records in
\n0+1 records out
\n90 bytes (90 B) copied, 0.00021344 s, 422 kB\/s<\/p>\n

1. Backing up and restoring an entire hard drive or a partition<\/p>\n

a. Backup entire hard drive to another drive.<\/p>\n

dd if=\/dev\/sda of=\/dev\/sdb bs=4096 conv=noerror,sync<\/p>\n

Here, \u2018if\u2019 stands for input file , \u2018of\u2019 stands for output file and \u2018bs\u2019 stands for the block size (number of bytes to be read\/write at a time). The conversion parameter \u2018noerror\u2019 allows the tool to continue to copy the data eventhough it encounter any errors. The sync option allows to use synchronized I\/O.<\/p>\n

The above command will copy all the data from the disk \/dev\/sda to \/dev\/sdb. \u2018dd\u2019 doesn\u2019t know anything about the filesystem or partitions- it will just copy everything from \/dev\/sda to \/dev\/sdb. So, this will clone the disk with the same data on same partition.<\/p>\n

b. Creating a disk image<\/p>\n

dd if=\/dev\/sda of=\/tmp\/sdadisk.img<\/p>\n

Backing up a disk to an image will be faster than copying the exact data. Also, disk image make the restoration much more easier.<\/p>\n

c. Creating a compressed disk image<\/p>\n

dd if=\/dev\/sda | gzip >\/tmp\/sdadisk.img.gz<\/p>\n

d. Restoring hard disk image<\/p>\n

dd if=\/tmp\/sdadisk.img of=\/dev\/sda<\/p>\n

e. Restoring compressed image<\/p>\n

gzip \u2013dc \/tmp\/sdadisk.img.gz | dd of=\/dev\/sda<\/p>\n

f. Clone one partition to another<\/p>\n

dd if=\/dev\/sda1 of=\/dev\/sdb1 bs=4096 conv=noerror,sync<\/p>\n

This will synchronize the partition \/dev\/sda1 to \/dev\/sdb1. You must verify that the size of \/dev\/sdb1 should be larger than \/dev\/sda1<\/p>\n

2. Backing up and Restoring MBR<\/p>\n

Master Boot record is the boot sector which houses the GRUB boot loader. If MBR got corrupted, we will not be able to boot into Linux. MBR -512 byte data- is located at the first sector of the hard disk. It consists of 446 byte bootstrap, 64 byte partition table and 2 bytes signature.<\/p>\n

a. Backing up MBR<\/p>\n

dd if=\/dev\/sda of=\/tmp\/mbr.img bs=512 count=1<\/p>\n

The option \u201ccount\u201d refers to the number of input blocks to be copied<\/p>\n

b. Backing up the boot data of MBR excluding the partition table<\/p>\n

dd if=\/dev\/sda of=\/tmp\/mbr.img bs=446 count=1<\/p>\n

c. Restoring MBR from MBR image<\/p>\n

dd if=\/tmp\/mbr.img of=\/dev\/sda<\/p>\n

d. Display master boot record<\/p>\n

dd if=\/dev\/hda of=mbr.bin bs=512 count=1
\nod -xa mbr.bin<\/p>\n

3. Converting data formats<\/p>\n

a. Convert the data format of a file from ASCII to EBCDIC<\/p>\n

dd if=textfile.ascii of=textfile.ebcdic conv=ebcdic<\/p>\n

b. Convert the data format of a file from EBCDIC to ASCII<\/p>\n

dd if=textfile.ebcdic of=textfile.ascii conv=ascii<\/p>\n

4. Converting case of a file<\/p>\n

a. Converting a file to Uppercase<\/p>\n

dd if=file1 of=file2 conv=ucase<\/p>\n

b. Converting a file to lowercase<\/p>\n

dd if=file1 of=file2 conv=lcase<\/p>\n

5. Creating or modifying data files<\/p>\n

a. Create a fixed size, say 10MB file<\/p>\n

dd if=\/dev\/zero of=file1 bs=10485760 count=1<\/p>\n

The block size is calculated as 10MB=10*1024*1024<\/p>\n

b. Modify the first 512 bytes of a file with null data<\/p>\n

dd if=\/dev\/zero of=file1 bs=512 count=1 conv=notrunc<\/p>\n

The option \u2018notrunc\u2019 refers to do not truncate the file, only replace the first 512 bytes, if it exists. Otherwise, you will get a 512 byte file.<\/p>\n

Creating an image file with dd command
\nFirst, make sure you’ve sufficient disk space to create a image file using dd:
\n$ df -H<\/p>\n

To create 1MB file (1024kb), enter:
\n$ dd if=\/dev\/zero of=test.img bs=1024 count=0 seek=1024<\/p>\n

You will get an empty files (also known as “sparse file”) of arbitrary size using above syntax. To create 10MB file , enter:
\n$ dd if=\/dev\/zero of=test.img bs=1024 count=0 seek=$[1024*10]<\/p>\n

To create 100MB file , enter:
\n$ dd if=\/dev\/zero of=test.img bs=1024 count=0 seek=$[1024*100]
\n$ ls -lh test.img<\/p>\n

To create 1GB, file:
\n$ dd if=\/dev\/zero of=1g.img bs=1 count=0 seek=1G
\nSample output:<\/p>\n

0+0 records in
\n0+0 records out
\n0 bytes (0 B) copied, 0.000235686 s, 0.0 kB\/s
\nVerify file size (note bs factor in original dd command):
\n$ ls -lh 1g.img
\n$ stat 1g.img
\n$ du -h 1g.im<\/p>\n

Burn an ISO File<\/p>\n

Using the Terminal<\/p>\n

To burn the iso on an usb stick, enter the following command in a terminal :
\ndd bs=4M if=\/path\/to\/manjaro.iso of=\/dev\/sd[drive letter]
\nWhere [drive letter] is the letter of your removable device. Please note that it is the device (e.g. \/dev\/sdb), and not the partition number (e.g. \/dev\/sdb1).
\nTo find which drive letter it might be write:
\nfdisk -l<\/p>\n

============================================================================================================<\/p>\n

Get Help, View Fancy Text & Reduce File Size<\/p>\n

man <\/p>\n

banner command <\/p>\n

How do I use figlet?<\/p>\n

Simply use it as follows:
\nfiglet “Shell Hacks”
\n ____ _ _ _ _ _ _
\n\/ ___|| |__ ___| | | | | | | __ _ ___| | _____
\n\\___ \\| ‘_ \\ \/ _ \\ | | | |_| |\/ _` |\/ __| |\/ \/ __|
\n ___) | | | | __\/ | | | _ | (_| | (__| <\\__ \\\n|____\/|_| |_|\\___|_|_| |_| |_|\\__,_|\\___|_|\\_\\___\/\nTo change the font, use the -f option, for example :\n\n$ figlet -f digital \"Shell Hacks\"\n+-+-+-+-+-+ +-+-+-+-+-+\n|S|h|e|l|l| |H|a|c|k|s|\n+-+-+-+-+-+ +-+-+-+-+-+\nUse the -c option if you would prefer centered output :\n\n$ figlet -c \"Shell Hacks\"\n _ _____ __ _\n (_) \/ ____| \/ _| |\n _ __ ___ _| | _ __ __ _| |_| |_\n| '_ \\| \\ \\\/ \/ | | '__\/ _` | _| __|\n| | | | |> <| |____| | | (_| | | | |_\n|_| |_|_\/_\/\\_\\\\_____|_| \\__,_|_| \\__|\n\n\n======================================================================================================================\n\nProgramming 1 \n\n\nHello World\n\n\n\n[root@cluster1 shell]# cat test.sh\n#!\/bin\/bash\necho \"Hello World\"\n\n\n\necho -e \"\n##################################\n#\n# Welcome to `hostname`\n# This system is running `cat \/etc\/redhat-release`\n# kernel is `uname -r`\n#\n# You are logged in as `whoami`\n#\n##################################\n\"\n=========================================================================================================================\nShell Variables, Grab User Input Using 'read'\n\n===========================================================================================================================================================\n\n###########Positional Parameters###########\n\na=25\necho$a\n25\n\na=\"Hey, what's up\"\n\necho $a\n\n\n#!\/bin\/bash\necho \"please provide the arugument\"\nmv $1 $2\ncat $2\n\n\n#!\/bin\/bash\nchmod 744 $1\nls -l $1 \n\n\n\nset I love india\n\necho $1\n\necho $*\n\n\nReverse Quotes Or Accent Graves\n\n#!\/bin\/bash\nname=$1\nset `who am i `\nmv $name $name.$1\n\n\n[root@cluster1 shell]# cat shell2.sh\necho i am not doing good while runing this shell program=$#\n\n[root@cluster1 shell]# .\/shell2.sh Count The Number of Command Line Arguments Using\ni am not doing good while runing this shell program=8\n\n==================================================================================================================================================================================\nMath On Integers Using 'expr'\n\n\n\nInteger Math\n\nFirst way to do math with integer (and only integer) is to use the command \u201cexpr \u2014 evaluate expression\u201d.\n\nroot@cluster1 $ expr 1 + 1\n2\nroot@cluster1 $ myvar=$(expr 1 + 1)\nroot@cluster1 $ echo $myvar\n2\nroot@cluster1 $ expr $myvar + 1\n3\nroot@cluster1 $ expr $myvar \/ 3\n1\nroot@cluster1 $ expr $myvar \\* 3\n9\nWhen doing a \u201cmultiply by\u201d make sure to backslash the \u201casterisk\u201d as it\u2019s a wildcard in Bash used for expansion.\n\nAnother alternative to expr, is to use the bash builtin command let.\n\nroot@cluster1 $ echo $myvar\n6\nroot@cluster1 $ let myvar+=1\nroot@cluster1 $ echo $myvar\n7\nroot@cluster1 $ let myvar+1\nroot@cluster1 $ echo $myvar\n7\nroot@cluster1 $ let myvar2=myvar+1\nroot@cluster1 $ echo $myvar2\n8\nAlso, you can simply use the parentheses or square brackets :\n\nroot@cluster1 $ echo $myvar\n3\nroot@cluster1 $ echo $((myvar+2))\n5\nroot@cluster1 $ echo $[myvar+2]\n5\nroot@cluster1 $ myvar=$((myvar+3))\nThis allow you to use C-style programming :\n\nroot@cluster1 $ echo $myvar\n3\nroot@cluster1 $ echo $((myvar++))\n3\nroot@cluster1 $ echo $myvar\n4\nroot@cluster1 $ echo $((++myvar))\n5\nroot@cluster1 $ echo $myvar\n5\nFloating point arithmetic\n\nYou can\u2019t do floating point arithmetic natively in bash, you will have to use a command line tool, the most common one being \u201cbc - An arbitrary precision calculator language\u201d.\n\nroot@cluster1 $ bc\nbc 1.06\nCopyright 1991-1994, 1997, 1998, 2000 Free Software Foundation, Inc.\nThis is free software with ABSOLUTELY NO WARRANTY.\nFor details type `warranty'.\n3*5.2+7\/8\n15.6\n15.6+299.33*2.3\/7.4\n108.6\nOf course you can use the STDIN to send your formula to \u201cbc\u201d then get the output on STDOUT.\n\n\nroot@cluster1 $ echo \"3.4+7\/8-(5.94*3.14)\" | bc\n-15.25\nor by using the here-doc notation:\n\nroot@cluster1 $ bc <<< \"3.4+7\/8-(5.94*3.14)\"\n-15.25\nI encourage you too take a look at the man pages to get more detail on how it works (man bc).\n\nThere are four special variables, scale, ibase, obase, and last. scale defines how some operations use digits after the decimal point. The default value of scale is 0. ibase and obase define the conver-\nsion base for input and output numbers. The default for both input and output is base 10. last (an extension) is a variable that has the value of the last printed number.\nThe \u201cscale\u201d variable is really important for the precision of your results, especially when using integers only (Note: you can also use \u201cbc -l\u201d to use mathlib and see the result at max scale) .\n\n\n\nroot@cluster1 $ echo \"2\/3\" | bc\n0\nroot@cluster1 $ echo \"scale=2; 2\/3\" | bc\n.66\nroot@cluster1 $ echo \"(2\/3)+(7\/8)\" | bc\n0\nroot@cluster1 $ echo \"scale=2;(2\/3)+(7\/8)\" | bc\n1.53\nroot@cluster1 $ echo \"scale=4;(2\/3)+(7\/8)\" | bc\n1.5416\nroot@cluster1 $ echo \"scale=6;(2\/3)+(7\/8)\" | bc\n1.541666\nroot@cluster1 $ echo \"(2\/3)+(7\/8)\" | bc -l\n1.54166666666666666666\nAnother way to do floating point arithmetic is to use AWK:\n\nroot@cluster1 $ awk \"BEGIN {print 100\/3}\"\n33.3333\nYou can use printf to adjust the precision of the results:\n\n\nroot@cluster1 $ awk \"BEGIN {printf \\\"%.2f\\n\\\", 100\/3}\"\n33.33\nWhen using negative values, make sure to leave a white space between signs.\n\nWRONG\n\nroot@cluster1 $ awk \"BEGIN {print -8.4--8}\"\nawk: cmd. line:1: BEGIN {print -8.4--8}\nawk: cmd. line:1: ^ syntax error\nGOOD\n\nroot@cluster1 $ awk \"BEGIN {print -8.4 - -8}\"\n-0.4\n\n\n\n\n\n\n#!\/bin\/bash\na=30 b=30\necho `expr $a + $b`\necho `expr $a - $b`\necho `expr $a \\* $b`\necho `expr $a \/ $b`\necho `expr $a % $b`\n\n==================================================================================================================================================================================\nOperator Precedence\n\n\n1st preference = \/, * , % \n2nd preference = +, - \n\n#!\/bin\/bash\na=40 b=35 c=25 d=50\n\n#!\/bin\/bash\na=40 b=35 c=25 d=50\necho `expr $a \\* \\( $b + $c \\) \/ $d`\n\n==================================================================================================================================================================================\n\nMath On Real Numbers Floating Point Arithmetic \n\nbc\n\n\n#!\/bin\/bash\na=2.5 b=3.5\nc=`echo $a + $b | bc`\nd=`echo $a - $b | bc`\nf=`echo $a \\* $b | bc`\ng=`echo $a \/ $b | bc`\necho $c, $d, $e, $f\n\n\n\n\n $ result=$(echo \"scale=2; 5 * 7 \/3;\" | bc)\n $ echo $result\n 11.66\n \necho 'scale=2; (2.777 - 1.4744)\/1' | bc \n1.30\n\nIn contrast, note that the bash shell only performs integer arithmetic, e.g.:\n $ result=$((5 * 7 \/3))\n $ echo $result\n 11\n \nCommand substitution stores the output of a command into a variable.\nvar3=$(echo \"scale=2;$var1\/$var2\" | bc)\n\nCalculate for float values\n\n printf \"%s\\n\" 'scale = 10; 196.304492\/615.348986' | bc\n\nbash-3.00$ x=$( printf \"%s\\n\" 'scale = 10; 196.304492\/615.348986' | bc)\nbash-3.00$ echo $x\n.3190132696\n\n\n\nA bash round function:\n\nround()\n{\necho $(printf %.$2f $(echo \"scale=$2;(((10^$2)*$1)+0.5)\/(10^$2)\" | bc))\n};\nUsed in your code example:\n\n#!\/bin\/bash\n# the function \"round()\" was taken from \n# the round function:\nround()\n{\necho $(printf %.$2f $(echo \"scale=$2;(((10^$2)*$1)+0.5)\/(10^$2)\" | bc))\n};\n\necho \"Insert the price you want to calculate:\"\nread float\necho \"This is the price without taxes:\"\n#echo \"scale=2; $float\/1.18\" |bc -l\necho $(round $float\/1.18 2);\nread -p \"Press any key to continue...\"\n\n\n\n\n#!\/bin\/bash\n\necho \"----- Addition ------\"\nx=10.2\ny=20.2\nz=`echo $x+$y|bc`\necho $z\necho \"------ Division -----\"\nx=3\ny=25\nz=`echo $y\/$x|bc`\necho $z\n\necho \"----- Substration -----\"\nx=20.9\ny=33.67\nz=`echo $y-$x|bc`\necho $z\n\necho \"----- Multiply -----\"\nx=2.23\ny=4.44\nz=`echo $x*$y|bc`\necho $z\n\necho \"----- Square root -----\"\nx=215\nz=`echo \"scale=4;sqrt($x)\" | bc -l`\necho $z\n\necho \"----- Powers of -----\"\nx=4.2\ny=2\nz=`echo $x^$y | bc -l`\necho $z\n\nOutput: \/floating.sh \n----- Addition ------\n30.4\n------ Division -----\n8\n----- Substration -----\n12.77\n----- Multiply -----\n9.90\n----- Square root -----\n14.6628\n----- Powers of -----\n17.64\n\n\nMath in Shell Scripts\n\n One thing that often confuses new users to the Unix \/ Linux shell, is\nhow to do (even very simple) maths. In most languages, x = x + 1 (or\neven x++) does exactly what you would expect. The Unix\/Linux shell is\ndifferent,however. It doesn\u2019t have any built-in mathematical operators\nfor variables. It can do comparisons, but maths isn\u2019t supported, not\neven simple addition.\n\n Shell script variables are by default treated as strings,not numbers,\nwhich adds some complexity to doing math in shell script. To keep with\nscript programming paradigm and allow for better math support, langua-\nges such Perl or Python would be better suited when math is desired.\nHowever, it is possible to do math with shell script.In fact, over the\nyears, multiple facilities have been added to Unix to support working\nwith numbers.\n\n You can do maths using any one of the following methods.\n\n1. Using expr command\n2 Using $(()) construct.\n3 Using let command\n4 Using bc command.\n5 Using $[] construct.\n\nexpr command:\n\n expr command performs arithmetic operations on integers. It can\nperform the four basic arithmetic operations, as well as the modulus\n(remainder function).\n\n$ expr 5 + 10\n15\n$ a=10 b=5\n$ expr $a + $b\n15\n$ expr $a \/ $b\n2\n$ expr $a * $b\nexpr: syntax error\n$ expr $a \\* $b\n50\n\n\n The operand, be it +,-,* etc., must be enclosed on either side by\nwhitespace. Observe that the multiplication operand (*) has to be\nescaped to prevent the shell from interpreting it as the filename meta\ncharacter. Since expr can handle only integers, division yields only\nthe integral part.\n\n expr is often used with command substitution to assign a variable.\nFor example, you can set a variable x to the sum of two numbers:\n\n$ x=`expr $a + $b`\n$ echo $x\n15\n\n Note: As you can see, for expr, you must put spaces around the\n arguments: \"expr 123+456\" doesn\u2019t work. \"expr 123 + 456\" works.\n\n\nWith double parentheses: $(()) and (())\n\n In bash version 3.2 and later you can (and should) use $(()) and (())\nfor integer arithmetic expressions. You may have may not have spaces\naround the operators, but you must not have spaces around the equal\nsign, as with any bash variable assignment.\n\n$ c=$(($a+9))\n$ echo $c\n19\n$ c=$((a+9)) #Also correct, no need of $ sign.\n$ c=$((a + 9)) #Also correct, no restriction on spaces.\n$ c= $((a + b)) #Incorrect, space after assignment operator.\n\n\n You may also use operations within double parentheses without\nassignment.\n\n$ ((a++))\n$ echo $a\n11\n$ ((a+=1)) ; echo $a\n12\n$ ((d=a+b+9)) ; echo $d\n26\n$ ((a+=$b)) #Correct\n$ (($a+=1)) #Incorrect\n\nlet command:\n\n The let command carries out arithmetic operations on variables. In\nmany cases, it functions as a less complex version of expr command.\nAs you can see, it is also a little picky about spaces, but it wants\nthe opposite of what expr wanted. let also relaxes the normal rule of\nneeding a $ in front of variables to be read.\n\n$ let a=10 # Same as 'a=11'\n$ let a=a+5 # Equivalent to let \"a = a + 5\"\n\n# Quotes permit the use of spaces in variable assignment. (Double\n# quotes and spaces make it more readable.)\n\n$ let a=$a + 5 # Without quotes spaces not allowed.\nbash: let: +: syntax error: operand expected (error token is \"+\")\n\n\n You need to use quotes if you want to use spaces between tokens of\nthe expression, for example\n\n$ let \"a = a + 5\";echo $a\n20\n\n The only construct that is more convenient to use with let is incre-\nment such as\n\n$ let a++ ; echo $a # as well as to ((i++))\n16\n\nbc: THE CALCULATOR\n\n Bash doesn't support floating point arithmetic. The obvious candidate\nfor adding floating point capabilities to bash is bc. bc is not only a\ncommand, it also a pseudo-programming language featuring arrays,funct-\nions,conditional(if) and loops(for and while). It also comes with a\nlibrary for performing scientific calculations. It can handle very,\nvery large numbers. If a computation results in a 900 digit number, bc\nwill show each and every digit. But you have to treat the variables as\nstrings.\n\n Here is what happens when we try to do floating point math with the\nshell:\n\n$ let a=12.5\nbash: let: a=12.5: syntax error: invalid arithmetic operator (error\ntoken is \".5\")\n$ ((b=1*0.5))\nbash: ((: b=1*0.5: syntax error: invalid arithmetic operator (error\ntoken is \".5\")\n\n\n I can't explain everything about bc here, it needs another post.\nBut I will give some examples here.\n\nMost of the bellow examples follow a simple formula:\n\n$ echo '57+43' | bc\n100\n$ echo '57*43' | bc\n2451\n$ echo '6^6' | bc # Power\n46656\n$ echo '1.5*5'|bc # Allows floating point math.\n7.5\n\n$[] construct: \n\n$ x=85\n$ y=15\n$ echo $[x+y]\n100\n$ echo $[x\/y]\n5\n$ c=$[x*y]\n$ echo $c\n1275\n\n\n Working of above methods shell dependent. Bash shell supports all 5\nmethods. Following shell script demonstrates above methods.\n\n#!\/bin\/bash\n# SCRIPT: basicmath.sh\n# USAGE: basicmath.sh\n# PURPOSE: Addition, Subtraction, Division and Multiplication of\n# two numbers.\n# \\\\\\\\ \/\/\/\/\n# \\\\ - - \/\/\n# @ @\n# ---oOOo-( )-oOOo---\n#\n#####################################################################\n# Variable Declaration #\n#####################################################################\n\nclear #Clears Screen\n\nBold=\"\\033[1m\" #Storing escape sequences in a variable.\nNormal=\"\\033[0m\"\n\necho -e \"$Bold Basic mathematics using bash script $Normal\\n\"\n\nitems=\"1. ADDITTION\n 2. SUBTRACTION\n 3. MULTIPLICATION\n 4. DIVISION\n 5. EXIT\"\n\nchoice=\n\n#####################################################################\n# Define Functions Here #\n#####################################################################\n\n# If didn't understand these functions, simply remove functions and\n# its entries from main script.\n\nexit_function()\n{\n clear\n exit\n}\n\n#Function enter is used to go back to menu and clears screen\n\nenter()\n{\n unset num1 num2\n ans=\n echo \"\"\n echo -e \"Do you want to continue(y\/n):\\c\"\n stty -icanon min 0 time 0\n\n# When -icanon is set then one character has been received.\n# min 0 means that read should read 0 characters.\n# time 0 ensures that read is terminated the moment one character\n# is hit.\n\nwhile [ -z \"$ans\" ]\ndo\n read ans\ndone\n\n#The while loop ensures that so long as at least one character is\n# not received read continue to get executed\n\nif [ \"$ans\" = \"y\" -o \"$ans\" = \"Y\" ]\nthen\n stty sane # Restoring terminal settings\n clear\nelse\n stty sane\n exit_function\nfi\n}\n\n#####################################################################\n# Main Starts #\n#####################################################################\n\nwhile true\ndo\n echo -e \"$Bold \\tPROGRAM MENU $Normal\\n\"\n echo -e \"\\t$items \\n\"\n echo -n \"Enter your choice : \"\n read choice\n\n case $choice in\n 1) clear\n echo \"Enter two numbers for Addition : \"\n echo -n \"Number1: \"\n read num1\n echo -n \"Number2: \"\n read num2\n echo \"$num1 + $num2 = `expr $num1 + $num2`\"\n enter ;;\n 2) clear\n echo \"Enter two numbers for Subtraction : \"\n echo -n \"Number1: \"\n read num1\n echo -n \"Number2: \"\n read num2\n echo \"$num1 - $num2 = $((num1-num2))\"\n enter ;;\n 3) clear\n echo \"Enter two numbers for Multiplication : \"\n echo -n \"Number1: \"\n read num1\n echo -n \"Number2: \"\n read num2\n echo \"$num1 * $num2 = `echo \"$num1*$num2\"|bc`\"\n enter ;;\n 4) clear\n echo \"Enter two numbers for Division : \"\n echo -n \"Number1: \"\n read num1\n echo -n \"Number2: \"\n read num2\n let div=num1\/num2\n echo \"$num1 \/ $num2 = $div\"\n enter ;;\n 5) exit_function ;;\n *) echo \"You entered wrong option, Please enter 1,2,3,4 or 5\"\n echo \"Press enter to continue\"\n read\n clear\n esac\n\ndone \n\nOUTPUT:\n [venu@localhost ~]$ sh basicmath.sh\n\n Basic mathematics using bash script\n\n PROGRAM MENU\n\n 1. ADDITTION\n 2. SUBTRACTION\n 3. MULTIPLICATION\n 4. DIVISION\n 5. EXIT\n\nEnter your choice : 1\n\nEnter two numbers for Addition :\nNumber1: 123\nNumber2: 456\n123 + 456 = 579\n\nDo you want to continue(y\/n):y\n\n PROGRAM MENU\n\n 1. ADDITTION\n 2. SUBTRACTION\n 3. MULTIPLICATION\n 4. DIVISION\n 5. EXIT\n\nEnter your choice : 3\nEnter two numbers for Multiplication :\nNumber1: 12.5\nNumber2: 2\n12.5 * 2 = 25.0\n\nDo you want to continue(y\/n):n\n\n\n\nrithmetic Operators:\nThere are following arithmetic operators supported by Bourne Shell.\n\nAssume variable a holds 10 and variable b holds 20 then:\n\nShow Examples\n\nOperator\tDescription\tExample\n+\tAddition - Adds values on either side of the operator\t`expr $a + $b` will give 30\n-\tSubtraction - Subtracts right hand operand from left hand operand\t`expr $a - $b` will give -10\n*\tMultiplication - Multiplies values on either side of the operator\t`expr $a \\* $b` will give 200\n\/\tDivision - Divides left hand operand by right hand operand\t`expr $b \/ $a` will give 2\n%\tModulus - Divides left hand operand by right hand operand and returns remainder\t`expr $b % $a` will give 0\n=\tAssignment - Assign right operand in left operand\ta=$b would assign value of b into a\n==\tEquality - Compares two numbers, if both are same then returns true.\t[ $a == $b ] would return false.\n!=\tNot Equality - Compares two numbers, if both are different then returns true.\t[ $a != $b ] would return true.\nIt is very important to note here that all the conditional expressions would be put inside square braces with one spaces around them, for example [ $a == $b ] is correct where as [$a==$b] is incorrect.\n\nAll the arithmetical calculations are done using long integers.\n\nRelational Operators:\nBourne Shell supports following relational operators which are specific to numeric values. These operators would not work for string values unless their value is numeric.\n\nFor example, following operators would work to check a relation between 10 and 20 as well as in between \"10\" and \"20\" but not in between \"ten\" and \"twenty\".\n\nAssume variable a holds 10 and variable b holds 20 then:\n\nShow Examples\n\nOperator\tDescription\tExample\n-eq\tChecks if the value of two operands are equal or not, if yes then condition becomes true.\t[ $a -eq $b ] is not true.\n-ne\tChecks if the value of two operands are equal or not, if values are not equal then condition becomes true.\t[ $a -ne $b ] is true.\n-gt\tChecks if the value of left operand is greater than the value of right operand, if yes then condition becomes true.\t[ $a -gt $b ] is not true.\n-lt\tChecks if the value of left operand is less than the value of right operand, if yes then condition becomes true.\t[ $a -lt $b ] is true.\n-ge\tChecks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true.\t[ $a -ge $b ] is not true.\n-le\tChecks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true.\t[ $a -le $b ] is true.\n\nIt is very important to note here that all the conditional expressions would be put inside square braces with one spaces around them, \nfor example [ $a <= $b ] is correct where as [$a <= $b] is incorrect.\n\nBoolean Operators:\nThere are following boolean operators supported by Bourne Shell.\n\nAssume variable a holds 10 and variable b holds 20 then:\n\nShow Examples\n\nOperator\tDescription\tExample\n!\tThis is logical negation. This inverts a true condition into false and vice versa.\t[ ! false ] is true.\n-o\tThis is logical OR. If one of the operands is true then condition would be true.\t[ $a -lt 20 -o $b -gt 100 ] is true.\n-a\tThis is logical AND. If both the operands are true then condition would be true otherwise it would be false.\t[ $a -lt 20 -a $b -gt 100 ] is false.\nString Operators:\nThere are following string operators supported by Bourne Shell.\n\nAssume variable a holds \"abc\" and variable b holds \"efg\" then:\n\nShow Examples\n\nOperator\tDescription\tExample\n=\tChecks if the value of two operands are equal or not, if yes then condition becomes true.\t[ $a = $b ] is not true.\n!=\tChecks if the value of two operands are equal or not, if values are not equal then condition becomes true.\t[ $a != $b ] is true.\n-z\tChecks if the given string operand size is zero. If it is zero length then it returns true.\t[ -z $a ] is not true.\n-n\tChecks if the given string operand size is non-zero. If it is non-zero length then it returns true.\t[ -z $a ] is not false.\nstr\tCheck if str is not the empty string. If it is empty then it returns false.\t[ $a ] is not false.\nFile Test Operators:\nThere are following operators to test various properties associated with a Unix file.\n\nAssume a variable file holds an existing file name \"test\" whose size is 100 bytes and has read, write and execute permission on:\n\nShow Examples\n\nOperator\tDescription\tExample\n-b file\tChecks if file is a block special file if yes then condition becomes true.\t[ -b $file ] is false.\n-c file\tChecks if file is a character special file if yes then condition becomes true.\t[ -c $file ] is false.\n-d file\tCheck if file is a directory if yes then condition becomes true.\t[ -d $file ] is not true.\n-f file\tCheck if file is an ordinary file as opposed to a directory or special file if yes then condition becomes true.\t[ -f $file ] is true.\n-g file\tChecks if file has its set group ID (SGID) bit set if yes then condition becomes true.\t[ -g $file ] is false.\n-k file\tChecks if file has its sticky bit set if yes then condition becomes true.\t[ -k $file ] is false.\n-p file\tChecks if file is a named pipe if yes then condition becomes true.\t[ -p $file ] is false.\n-t file\tChecks if file descriptor is open and associated with a terminal if yes then condition becomes true.\t[ -t $file ] is false.\n-u file\tChecks if file has its set user id (SUID) bit set if yes then condition becomes true.\t[ -u $file ] is false.\n-r file\tChecks if file is readable if yes then condition becomes true.\t[ -r $file ] is true.\n-w file\tCheck if file is writable if yes then condition becomes true.\t[ -w $file ] is true.\n-x file\tCheck if file is execute if yes then condition becomes true.\t[ -x $file ] is true.\n-s file\tCheck if file has size greater than 0 if yes then condition becomes true.\t[ -s $file ] is true.\n-e file\tCheck if file exists. Is true even if file is a directory but exists.\t[ -e $file ] is true.\n\n\n\n\n==================================================================================================================================================================================\nEscape Sequences\n\n\n\n Escape Characters\nCertain characters are significant to the shell; we have seen, for example, that the use of double quotes (\") characters affect how spaces and TAB characters are treated, for example:\n\n$ echo Hello World\nHello World\n$ echo \"Hello World\"\nHello World\nSo how do we display: Hello \"World\" ?\n\n\n$ echo \"Hello \\\"World\\\"\"\nThe first and last \" characters wrap the whole lot into one parameter passed to echo so that the spacing between the two words is kept as is. But the code:\n\n$ echo \"Hello \" World \"\"\nwould be interpreted as three parameters:\n\n\"Hello \"\nWorld\n\"\"\nSo the output would be\n\nHello World\nNote that we lose the quotes entirely. This is because the first and second quotes mark off the Hello and following spaces; the second argument is an unquoted \"World\" and the third argument is the empty string; \"\".\n\nThanks to Patrick for pointing out that this:\n\n\n$ echo \"Hello \"World\"\"\nis actually only one parameter (no spaces between the quoted parameters), and that you can test this by replacing the echo command with (for example) ls.\nMost characters (*, ', etc) are not interpreted (ie, they are taken literally) by means of placing them in double quotes (\"\"). They are taken as is and passed on to the command being called. An example using the asterisk (*) goes:\n\n\n$ echo *\ncase.shtml escape.shtml first.shtml \nfunctions.shtml hints.shtml index.shtml \nip-primer.txt raid1+0.txt\n$ echo *txt\nip-primer.txt raid1+0.txt\n$ echo \"*\"\n*\n$ echo \"*txt\"\n*txt\nIn the first example, * is expanded to mean all files in the current directory.\nIn the second example, *txt means all files ending in txt.\nIn the third, we put the * in double quotes, and it is interpreted literally.\nIn the fourth example, the same applies, but we have appended txt to the string.\n\n\n \nHowever, \", $, `, and \\ are still interpreted by the shell, even when they're in double quotes. \nThe backslash (\\) character is used to mark these special characters so that they are not interpreted by the shell, but passed on to the command being run (for example, echo). \nSo to output the string: (Assuming that the value of $X is 5):\n\nA quote is \", backslash is \\, backtick is `.\nA few spaces are and dollar is $. $X is 5.\nwe would have to write:\n\n$ echo \"A quote is \\\", backslash is \\\\, backtick is \\`.\"\nA quote is \", backslash is \\, backtick is `.\n$ echo \"A few spaces are ; dollar is \\$. \\$X is ${X}.\"\nA few spaces are ; dollar is $. $X is 5.\nWe have seen why the \" is special for preserving spacing. Dollar ($) is special because it marks a variable, so $X is replaced by the shell with the contents of the variable X. Backslash (\\) is special because it is itself used to mark other characters off; we need the following options for a complete shell:\n\n$ echo \"This is \\\\ a backslash\"\nThis is \\ a backslash\n$ echo \"This is \\\" a quote and this is \\\\ a backslash\"\nThis is \" a quote and this is \\ a backslash\n\n\n\n\nQuotes and escaping\n\nQuoting and escaping is really an important way to influence the way, Bash treats your input. There are three recognized types:\n\nper-character escaping using a backslash: \\$stuff\nweak quoting with double-quotes: \"stuff\"\nstrong quoting with single-quotes: 'stuff'\nAll three forms have the very same purpose: They give you general control over parsing, expansion and expansion's results.\n\nBeside these common basic variants, there are some more special quoting methods (like interpreting ANSI-C escapes in a string) you'll meet below.\n\n\u2757 ATTENTION \u2757 These quote characters (\", double quote and ', single quote) are a syntax element that influences parsing. It is not related to eventual quote characters that are passed as text to the commandline! The syntax-quotes are removed before the command is called! Look:\n\n### NO NO NO: this passes three strings:\n### (1) \"my\n### (2) multiword\n### (3) argument\"\nMYARG=\"\\\"my multiword argument\\\"\"\nsomecommand $MYARG\n\n### THIS IS NOT (!!!!) THE SAME AS ###\ncommand \"my multiword argument\"\n\n### YOU NEED ###\nMYARG=\"my multiword argument\"\ncommand \"$MYARG\"\nPer-character escaping\n\nPer-character escaping is useful in different places, also here, on expansions and substitutions. In general, a character that has a special meaning for Bash, like the dollar-sign ($) to introduce some expansion types, can be masked to not have that special meaning using the backslash:\n\necho \\$HOME is set to \\\"$HOME\\\"\n\\$HOME won't expand because it's not variable expansion syntax anymore\nThe quotes are masked with the backslash to be literal - otherwise they would be interpreted by Bash\nThe sequence \\ (an unquoted backslash, followed by a character) is interpreted as line continuation. It is removed from the input stream and thus effectively ignored. Use it to beautify your code:<\/p>\n

# escapestr_sed()
\n# read a stream from stdin and escape characters in text that could be interpreted as
\n# special characters by sed
\nescape_sed() {
\n sed \\
\n -e ‘s\/\\\/\/\\\\\\\/\/g’ \\
\n -e ‘s\/\\&\/\\\\\\&\/g’
\n}
\nThe backslash can be used to mask every character that has a special meaning for bash. Exception: Inside a single-quoted string (see below).<\/p>\n

Weak quoting<\/p>\n

Inside a weak-quoted string there’s no special interpretion of:<\/p>\n

spaces as word-separators (on inital commandline splitting and on word splitting!)
\nsingle-quotes to introduce strong-quoting (see below)
\ncharacters for pattern matching
\npathname expansion
\nprocess substitution
\nEverything else, especially parameter expansion, is performed!<\/p>\n

ls -l “*”
\nWill not be expanded. ls gets the literal * as argument. It will, unless you have a file named *, spit out an error.
\necho “Your PATH is: $PATH”
\nWill work as expected. $PATH is expanded, because it’s only double- (weak-) quoted.
\nIf a backslash in double-quotes (“weak quoting”) occurs, there are 2 ways to deal with it<\/p>\n

if the baskslash is followed by a character that would have a special meaning even inside double-quotes, the backslash is removed and the following character looses its special meaning
\nif the backslash is followed by a character without special meaning, the backslash is not removed
\nIn particuar this means that “\\$” will become $, but “\\x” will become \\x.<\/p>\n

Strong quoting<\/p>\n

Strong quoting is very easy to explain:<\/p>\n

Inside a single-quoted string nothing(!!!!) is interpreted, except the single-quote that closes the quoting.<\/p>\n

echo ‘Your PATH is: $PATH’
\nThat $PATH won’t be expanded, it’s interpreted as normal ordinary text, because it’s surrounded by strong quotes.
\nIn practise that means, to produce a text like Here’s my test\u2026 as a single-quoted string, you have to leave and re-enter the single-quoting to get the character “‘” as literal text:<\/p>\n

# WRONG
\necho ‘Here’s my test…’<\/p>\n

# RIGHT
\necho ‘Here’\\”s my test…’<\/p>\n

# ALTERNATIVE: It’s also possible to mix-and-match quotes for readability:
\necho “Here’s my test”
\nANSI C like strings<\/p>\n

There’s another quoting mechanism, Bash provides: Strings that are scanned for ANSI C like escape sequences. The Syntax is<\/p>\n

$’string’
\nwhere the following escape sequences are decoded in string:
\nCode\tMeaning
\n\\”\tdouble-quote
\n\\’\tsingle-quote
\n\\\\\tbackslash
\n\\a\tterminal alert character (bell)
\n\\b\tbackspace
\n\\e\tescape (ASCII 033)
\n\\E\tescape (ASCII 033) \\E is non-standard
\n\\f\tform feed
\n\\n\tnewline
\n\\r\tcarriage return
\n\\t\thorizontal tab
\n\\v\tvertical tab
\n\\cx\ta control-x character, for example $’\\cZ’ to print the control sequence composed by Ctrl-Z (^Z)
\n\\uXXXX\tInterprets XXXX as hexadecimal number and prints the corresponding character from the character set (4 digits) (Bash 4.2-alpha)
\n\\UXXXXXXXX\tInterprets XXXX as hexadecimal number and prints the corresponding character from the character set (8 digits) (Bash 4.2-alpha)
\n\\nnn\tthe eight-bit character whose value is the octal value nnn (one to three digits)
\n\\xHH\tthe eight-bit character whose value is the hexadecimal value HH (one or two hex digits)<\/p>\n

hell scripts commonly used ANSI escape codes for color output.
\nFollowing table shows Numbers representing colors in Escape Sequences.<\/p>\n

Color\tForeground\tBackground
\nBlack\t30\t40
\nRed\t31\t41
\nGreen\t32\t42
\nYellow\t33\t43
\nBlue\t34\t44
\nMagenta\t35\t45
\nCyan\t36\t46
\nWhite\t37\t47<\/p>\n

The numbers in the above table work for xterm terminal.Result may vary
\nfor other terminal emulators.<\/p>\n

Use the following template for writing colored text.<\/p>\n

echo -e “\\033[COLORm Sample text”<\/p>\n

The “\\033[” begins the escape sequence.You can also use “\\e[” instead
\nof “\\033[“. COLOR specifies a foreground color, according to the table
\nabove.The “m” terminates escape sequence, and text begins immediately
\nafter that.<\/p>\n

Note: With an echo, the -e option enables the escape sequences.You can<\/p>\n

also use printf instead of echo.<\/p>\n

printf “\\e[COLORm sample text\\n”<\/p>\n

To print Green text<\/p>\n

echo -e “\\033[32m Hello World”
\n or
\nprintf “\\e[32m Hello World”<\/p>\n

The problem with above statement is that the blue color that starts
\nwith the 32 color code is never switched back to the regular color, so
\nany text you type after the prompt and even prompt also is still in the
\nGreen color.<\/p>\n

To return to the plain, normal mode, we have yet another sequence.<\/p>\n

echo -e “\\033[0m”<\/p>\n

Now you won’t see anything new on the screen, as this echo statement
\nwas not passed any string to display. But it has done its job, which
\nwas to restore the normal viewing mode. Whatever yor type now will be
\navoid of any fancy effects.<\/p>\n

Escape sequence also allow you to control the manner in which
\ncharacters are displayed on the screen.<\/p>\n

The following table summarizes numbers representing text attributes
\nin Escape Sequences.<\/p>\n

ANSI CODE\tMeaning
\n0\tNormal Characters
\n1\tBold Characters
\n4\tUnderlined Characters
\n5\tBlinking Characters
\n7\tReverse video Characters<\/p>\n

Note: Blink attribute doesn’t work in any terminal emulator, but it<\/p>\n

will work on the console.<\/p>\n

Combining all these Escape Sequences, you can get more fancy effect.
\nUse the following template for writing colored text on a colored
\nbackground.<\/p>\n

echo -e “\\033[COLOR1;COLOR2m sample text\\033[0m”<\/p>\n

The semicolon separated numbers “COLOR1” and “COLOR2″ specify a
\nforeground and a background color.The order of the numbers does not
\nmatter, since the foreground and background numbers fall in non-
\noverlapping ranges.”m” terminates the escape sequence, and the text
\nbegins immediately after that.Although setting the colors separately
\nalso work (i.e. \\033[44m\\033[32m).<\/p>\n

There are some differences between colors when combining colors with
\nbold text attribute.<\/p>\n

The following table summarises these differences.<\/p>\n

Bold off\tcolor\tBold on\tcolor
\n0;30\tBalck\t1;30\tDark Gray
\n0;31\tRed\t1;31\tDark Red
\n0;32\tGreen\t1;32\tDark Green
\n0;33\tBrown\t1;33\tYellow
\n0;34\tBlue\t1;34\tDark Blue
\n0;35\tMagenta\t1;35\tDark Magenta
\n0;36\tCyan\t1;30\tDark Cyan
\n0;37\tLight Gray\t1;30\tWhite<\/p>\n

The following shell script prints all the colors and codes on the
\nscreen.<\/p>\n

#!\/bin\/bash<\/p>\n

# This script echoes colors and codes<\/p>\n

echo -e “\\n\\033[4;31mLight Colors\\033[0m \\t\\t\\033[1;4;31mDark Colors\\033[0m”<\/p>\n

echo -e “\\e[0;30;47m Black \\e[0m 0;30m \\t\\e[1;30;40m Dark Gray \\e[0m 1;30m”<\/p>\n

echo -e “\\e[0;31;47m Red \\e[0m 0;31m \\t\\e[1;31;40m Dark Red \\e[0m 1;31m”<\/p>\n

echo -e “\\e[0;32;47m Green \\e[0m 0;32m \\t\\e[1;32;40m Dark Green \\e[0m 1;32m”<\/p>\n

echo -e “\\e[0;33;47m Brown \\e[0m 0;33m \\t\\e[1;33;40m Yellow \\e[0m 1;33m”<\/p>\n

echo -e “\\e[0;34;47m Blue \\e[0m 0;34m \\t\\e[1;34;40m Dark Blue \\e[0m 1;34m”<\/p>\n

echo -e “\\e[0;35;47m Magenta \\e[0m 0;35m \\t\\e[1;35;40m DarkMagenta\\e[0m 1;35m”<\/p>\n

echo -e “\\e[0;36;47m Cyan \\e[0m 0;36m \\t\\e[1;36;40m Dark Cyan \\e[0m 1;36m”<\/p>\n

echo -e “\\e[0;37;47m LightGray\\e[0m 0;37m \\t\\e[1;37;40m White \\e[0m 1;37m”<\/p>\n

OUTPUT:<\/p>\n

Some examples:<\/p>\n

Block background and white text<\/p>\n

echo -e “\\033[40;37m Hello World\\033[0m”<\/p>\n

Reverse video text attribute option interchanges fg and bg colors.
\nBellow statement prints block on white<\/p>\n

echo -e “\\033[40;37;7m Hello World\\033[0m”<\/p>\n

echo -e “\\033[33;44m Yellow text on blue background\\033[0m”
\necho -e “\\033[1;33;44m Bold yellow text on blue background\\033[0m”
\necho -e “\\033[1;4;33;44mBold yellow underlined text on blue background\\033[0m”<\/p>\n

The “tput” command:<\/p>\n

Other than echo there is a command called tput using which we
\ncan control the way the output is displayed on the screen.But it is
\nless flexible than ANSI escape sequences.<\/p>\n

#!\/bin\/bash
\necho “Hey world, \\what’s up?”<\/p>\n

Users who have been using Linux for awhile often learn that creating a basic script is a good way to run multiple, often-repeated commands. Adding a little color to scripts can additionally provide nice feedback. This can be done in a fairly straight-forward way by using the tput command.<\/p>\n

A common way of doing this is to define the colors that tput can produce by putting them at the beginning of the bash script:<\/p>\n

#!\/bin\/bash
\n# scriptname – description of script<\/p>\n

# Text color variables
\ntxtund=$(tput sgr 0 1) # Underline
\ntxtbld=$(tput bold) # Bold
\nbldred=${txtbld}$(tput setaf 1) # red
\nbldblu=${txtbld}$(tput setaf 4) # blue
\nbldwht=${txtbld}$(tput setaf 7) # white
\ntxtrst=$(tput sgr0) # Reset
\ninfo=${bldwht}*${txtrst} # Feedback
\npass=${bldblu}*${txtrst}
\nwarn=${bldred}*${txtrst}
\nques=${bldblu}?${txtrst}
\nWhen writing new scripts using templates with these variables already defined can quicken the creation process and help keep scripts organized (my Bash Templates).<\/p>\n

If just needing to use tput colors for specific instances this script can display the tput definitions and their corresponding possibilities:<\/p>\n

#!\/bin\/bash
\n# tputcolors<\/p>\n

echo
\necho -e “$(tput bold) reg bld und tput-command-colors$(tput sgr0)”<\/p>\n

for i in $(seq 1 7); do
\n echo ” $(tput setaf $i)Text$(tput sgr0) $(tput bold)$(tput setaf $i)Text$(tput sgr0) $(tput sgr 0 1)$(tput setaf $i)Text$(tput sgr0) \\$(tput setaf $i)”
\ndone<\/p>\n

echo ‘ Bold $(tput bold)’
\necho ‘ Underline $(tput sgr 0 1)’
\necho ‘ Reset $(tput sgr0)’
\necho<\/p>\n

tput Command<\/p>\n

The tput command is used to set terminal features. With tput you can set:<\/p>\n

Move the cursor around the screen.
\nGet information about terminal.
\nSet colors (background and foreground).
\nSet bold mode.
\nSet reverse mode and much more.
\nHere is a sample code:<\/p>\n

#!\/bin\/bash<\/p>\n

# clear the screen
\ntput clear<\/p>\n

# Move cursor to screen location X,Y (top left is 0,0)
\ntput cup 3 15<\/p>\n

# Set a foreground colour using ANSI escape
\ntput setaf 3
\necho “XYX Corp LTD.”
\ntput sgr0<\/p>\n

tput cup 5 17
\n# Set reverse video mode
\ntput rev
\necho “M A I N – M E N U”
\ntput sgr0<\/p>\n

tput cup 7 15
\necho “1. User Management”<\/p>\n

tput cup 8 15
\necho “2. Service Management”<\/p>\n

tput cup 9 15
\necho “3. Process Management”<\/p>\n

tput cup 10 15
\necho “4. Backup”<\/p>\n

# Set bold mode
\ntput bold
\ntput cup 12 15
\nread -p “Enter your choice [1-4] ” choice<\/p>\n

tput clear
\ntput sgr0
\ntput rc<\/p>\n

===================================if-then=====================================================================================
\nif-then’ Statement in Action<\/p>\n

check the exit status wither command executed successfully or not <\/p>\n

[root@cluster1 shell]# mkdir test
\n[root@cluster1 shell]# echo $?
\n0
\n[root@cluster1 shell]# mkdir test
\nmkdir: cannot create directory `test’: File exists
\n[root@cluster1 shell]# echo $?
\n1
\n[root@cluster1 shell]#<\/p>\n

What Are Conditions?<\/p>\n

Conditions in the realm of computing work similarly. We can test whether a string matches another string, whether it doesn\u2019t match another string, or even if it exists at all.
\nSimilarly, we can test numerical arguments to see if one is great than, less than, or equal to another. <\/p>\n

To get something to happen after the conditions of the test are met, we use \u201cif-then\u201d statements. Their format is pretty simple.<\/p>\n

if CONDITION
\nthen
\ncommand1
\ncommand2
\n\u2026
\ncommandn
\nfi<\/p>\n

if test $1 -gt $2
\nthen
\necho \u201c$1 is greater than $2?
\nfi<\/p>\n

if…fi statement is the fundamental control statement that allows Shell to make decisions and execute statements conditionally.<\/p>\n

Syntax:
\nif [ expression ]
\nthen
\n Statement(s) to be executed if expression is true
\nfi
\nHere Shell expression is evaluated. If the resulting value is true, given statement(s) are executed. If expression is false then no statement would be not executed. Most of the times you will use comparison operators while making decisions.<\/p>\n

Give you attention on the spaces between braces and expression. This space is mandatory otherwise you would get syntax error.<\/p>\n

If expression is a shell command then it would be assumed true if it return 0 after its execution. If it is a boolean expression then it would be true if it returns true.<\/p>\n

Example:
\n#!\/bin\/sh<\/p>\n

a=10
\nb=20<\/p>\n

if [ $a == $b ]
\nthen
\n echo “a is equal to b”
\nfi<\/p>\n

if [ $a != $b ]
\nthen
\n echo “a is not equal to b”
\nfi
\nThis will produce following result:<\/p>\n

a is not equal to b<\/p>\n

Here are some other numerical operators you may want to try out:<\/p>\n

-eq: equal to
\n-ne: not equal to
\n-lt: less than
\n-le: less than or equal to
\n-gt: greater than
\n-ge: greater than or equal to<\/p>\n

Shell scripts use fairly standard syntax for if statements. The conditional statement is executed using either the test command or the [ command. In its most basic form an if statement is:<\/p>\n

#!\/bin\/bash<\/p>\n

if [ “$#” -gt 0 ]
\nthen
\n echo “There’s Beans”
\nfi<\/p>\n

if [ “$1” = “cool” ]
\nthen
\n echo “Cool Beans”
\nfi
\n(Notice that the fi is simply if spelled backwards). To add an else, we just use standard syntax.<\/p>\n

#!\/bin\/bash<\/p>\n

if [ “$1” = “cool” ]
\nthen
\n echo “Cool Beans”
\nelse
\n echo “Not Cool Beans”
\nfi
\nAdding an else-if statement structure is used with the elif command.<\/p>\n

#!\/bin\/bash<\/p>\n

if [ “$1” = “cool” ]
\nthen
\n echo “Cool Beans”
\nelif [ “$1” = “neat” ]
\nthen
\n echo “Neato cool”
\nelse
\n echo “Not Cool Beans”
\nfi
\nAn if statement does not require two parameters. You can use single flags as well. The following code tests to see if the first parameter is a file or not.<\/p>\n

#!\/bin\/bash<\/p>\n

if [ -f “$1” ]
\nthen
\n echo “$1 is a file”
\nelse
\n echo “$1 is not a file”
\nfi
\nThere are many different ways that an conditional statement can be used. These are summarized here:<\/p>\n

String Comparison\tDescription
\nStr1 = Str2\tReturns true if the strings are equal
\nStr1 != Str2\tReturns true if the strings are not equal
\n-n Str1\tReturns true if the string is not null
\n-z Str1\tReturns true if the string is null<\/p>\n

Numeric Comparison\tDescription
\nexpr1 -eq expr2\tReturns true if the expressions are equal
\nexpr1 -ne expr2\tReturns true if the expressions are not equal
\nexpr1 -gt expr2\tReturns true if expr1 is greater than expr2
\nexpr1 -ge expr2\tReturns true if expr1 is greater than or equal to expr2
\nexpr1 -lt expr2\tReturns true if expr1 is less than expr2
\nexpr1 -le expr2\tReturns true if expr1 is less than or equal to expr2
\n! expr1\tNegates the result of the expression<\/p>\n

File Conditionals\tDescription
\n-d file\tTrue if the file is a directory
\n-e file\tTrue if the file exists (note that this is not particularly portable, thus -f is generally used)
\n-f file\tTrue if the provided string is a file
\n-g file\tTrue if the group id is set on a file
\n-r file\tTrue if the file is readable
\n-s file\tTrue if the file has a non-zero size
\n-u\tTrue if the user id is set on a file
\n-w\tTrue if the file is writable
\n-x\tTrue if the file is an executable<\/p>\n

File attributes comparisons<\/p>\n

-a file
\nTrue if file exists.<\/p>\n

Example
\n[ -a \/etc\/resolv.conf ] && echo “File found” || echo “Not found”
\n-b file
\nTrue if file exists and is a block special file.<\/p>\n

Example
\n[ -b \/dev\/zero ] && echo “block special file found” || echo “block special file not found”
\nOR<\/p>\n

[ -b \/dev\/sda ] && echo “block special file found” || echo “block special file not found”
\n-c file
\nTrue if file exists and is a character special file.<\/p>\n

Example
\n[ -c \/dev\/tty0 ] && echo “Character special file found.” || echo “Character special file not found.”
\n-d dir
\nTrue if file exists and is a directory.<\/p>\n

Example
\n#!\/bin\/bash
\nDEST=”\/backup”
\nSRC=”\/home”<\/p>\n

# Make sure backup dir exits
\n[ ! -d “$DEST” ] && mkdir -p “$DEST”<\/p>\n

# If source directory does not exits, die…
\n[ ! -d “$SRC” ] && { echo “$SRC directory not found. Cannot make backup to $DEST”; exit 1; }<\/p>\n

# Okay, dump backup using tar
\necho “Backup directory $DEST…”
\necho “Source directory $SRC…”
\n\/bin\/tar zcf “$DEST\/backup.tar.gz” “$SRC” 2>\/dev\/null<\/p>\n

# Find out if our backup job failed or not and notify on screen
\n[ $? -eq 0 ] && echo “Backup done!” || echo “Backup failed”
\n-e file
\nTrue if file exists.<\/p>\n

Example
\n[ -e \/tmp\/test.txt ] && echo “File found” || echo “File not found”
\n-f file
\nTrue if file exists and is a regular file.<\/p>\n

Example
\n[ ! -f \/path\/to\/file ] && echo “File not found!”
\nA sample shell script that compare various file attributes and create webalizer (application that generates web pages of analysis, from access and usage log) stats configuration file to given Internet domain name.<\/p>\n

#!\/bin\/bash
\n# Purpose: A Shell Script To Create Webalizer Stats Configration File
\n# Written by: Vivek Gite
\n# ———————————————————————
\n# Set vars<\/p>\n

# Apache vroot for each domain
\nHTTPDROOT=”\/home\/httpd”<\/p>\n

# Path to GeoIP DB
\nGEOIPDBPATH=”\/usr\/local\/share\/GeoIP\/GeoIP.dat”<\/p>\n

# Get the Internet domain such as cyberciti.biz
\necho “*** A Shell Script To Create Webalizer Stats Configration File ***”
\nread -p “Enter a domain name : ” DOMAIN<\/p>\n

# Make sure we got the Input else die with an error on screen
\n[ -z $DOMAIN ] && { echo “Please enter a domain name. Try again!”; exit 1; }<\/p>\n

# Alright, set some variable based upon $DOMAIN
\nOUT=”$HTTPDROOT\/$DOMAIN\/stats\/webalizer.conf”
\nCONFROOT=”$HTTPDROOT\/$DOMAIN\/stats”
\nLOGFILE=”$HTTPDROOT\/$DOMAIN\/logs\/access.log”<\/p>\n

# Die if configuration file exits…
\n[ -f $OUT ] && { echo “Webalizer configuration file ‘$OUT’ exits for domain $DOMAIN.”; exit 2; }<\/p>\n

# Make sure configuration directory exists
\n[ ! -d $CONFROOT ] && mkdir -p $CONFROOT <\/p>\n

# Write a log file <\/p>\n

>$OUT
\necho “LogFile $LOGFILE” >> $OUT
\necho “LogType clf” >> $OUT
\necho “OutputDir $CONFROOT\/out” >> $OUT
\necho “HistoryName $CONFROOT\/webalizer.hist” >> $OUT
\necho “Incremental yes” >> $OUT
\necho “IncrementalName $CONFROOT\/webalizer.current” >> $OUT
\necho “HostName $DOMAIN” >> $OUT
\necho “Quiet yes” >> $OUT
\necho “FoldSeqErr yes” >> $OUT
\necho “AllSearchStr yes” >> $OUT
\necho “HideSite $DOMAIN” >> $OUT
\necho “HideSite localhost” >> $OUT
\necho “HideReferrer $DOMAIN” >> $OUT
\necho “HideURL *.gif” >> $OUT
\necho “HideURL *.GIF” >> $OUT
\necho “HideURL *.jpg” >> $OUT
\necho “HideURL *.JPG” >> $OUT
\necho “HideURL *.png” >> $OUT
\necho “HideURL *.PNG” >> $OUT
\necho “HideURL *.ra” >> $OUT
\necho “GroupReferrer yahoo.com\/ Yahoo!” >> $OUT
\necho “GroupReferrer excite.com\/ Excite” >> $OUT
\necho “GroupReferrer infoseek.com\/ InfoSeek” >> $OUT
\necho “GroupReferrer webcrawler.com\/ WebCrawler” >> $OUT
\necho “SearchEngine .yahoo. p=” >> $OUT
\necho “SearchEngine altavista.com q=” >> $OUT
\necho “SearchEngine .google. q=” >> $OUT
\necho “SearchEngine eureka.com q=” >> $OUT
\necho “SearchEngine lycos.com query=” >> $OUT
\necho “SearchEngine hotbot.com MT=” >> $OUT
\necho “SearchEngine msn.com MT=” >> $OUT
\necho “SearchEngine infoseek.com qt=” >> $OUT
\necho “SearchEngine webcrawler searchText=” >> $OUT
\necho “SearchEngine excite search=” >> $OUT
\necho “SearchEngine netscape.com search=” >> $OUT
\necho “SearchEngine mamma.com query=” >> $OUT
\necho “SearchEngine alltheweb.com query=” >> $OUT
\necho “SearchEngine northernlight.com qr=” >> $OUT
\necho “CountryFlags yes” >> $OUT
\necho “GeoIP yes” >> $OUT
\necho “GeoIPDatabase $GEOIPDBPATH” >> $OUT
\necho “GraphMonths 72” >> $OUT
\necho “IndexMonths 120” >> $OUT
\necho “GraphMonths 72” >> $OUT
\necho “TopReferrers 20” >> $OUT
\necho “TopSites 20” >> $OUT
\necho “TopURLs 50” >> $OUT
\necho “TopKURLs 50” >> $OUT<\/p>\n

echo “Weblizer config wrote to $OUT”
\n-g file
\nTrue if file exists and is set-group-id.<\/p>\n

-h file
\nTrue if file exists and is a symbolic link.<\/p>\n

-k file
\nTrue if file exists and its \u2018\u2018sticky\u2019\u2019 bit is set.<\/p>\n

-p file
\nTrue if file exists and is a named pipe (FIFO).<\/p>\n

-r file
\nTrue if file exists and is readable.<\/p>\n

-s file
\nTrue if file exists and has a size greater than zero.<\/p>\n

-t fd
\nTrue if file descriptor fd is open and refers to a terminal.<\/p>\n

-u file
\nTrue if file exists and its set-user-id bit is set.<\/p>\n

-w file
\nTrue if file exists and is writable.<\/p>\n

-x file
\nTrue if file exists and is executable.<\/p>\n

-O file
\nTrue if file exists and is owned by the effective user id.<\/p>\n

-G file
\nTrue if file exists and is owned by the effective group id.<\/p>\n

-L file
\nTrue if file exists and is a symbolic link.<\/p>\n

-S file
\nTrue if file exists and is a socket.<\/p>\n

-N file
\nTrue if file exists and has been modified since it was last read.<\/p>\n

In its most basic form an if statement is:
\n#!\/bin\/bash if [ “$1” -eq “abc” ] then echo “in if block” fi
\n(Notice that the fi is simply if spelled backwards).<\/p>\n

To add an else, we just use standard syntax.<\/p>\n

#!\/bin\/bash if [ “$1” -eq “abc” ] then echo “in if block” else echo “in else block” fi
\nAdding an else-if statement structure is used with the elif command.<\/p>\n

#!\/bin\/bash if [ “$1” -eq “abc” ] then echo “in if block” elif [ “$1” -eq “xyz” ] echo “in else if block” else echo “in else block” fi
\nAn if statement does not require two parameters.<\/p>\n

You can use single flags as well. The following code tests to see if the first parameter is a file or not.<\/p>\n

#!\/bin\/bash if [ -f “$1” ] then echo “$1 is a file” else echo “$1 is not a file” fi<\/p>\n

#!\/bin\/bash
\n#if then statement
\necho “Enter source and target files names.”
\nread source target
\nif mv $source $target
\nthen
\necho “Your file has been successully renamed..”
\nfi <\/p>\n

Enter source and target files names.
\ntest test1
\nYour file has been successully renamed..
\n[root@cluster1 shell]# ls -ltr<\/p>\n

if…else…fi statement is the next form of control statement that allows Shell to execute statements in more controlled way and making decision between two choices.<\/p>\n

Syntax:
\nif [ expression ]
\nthen
\n Statement(s) to be executed if expression is true
\nelse
\n Statement(s) to be executed if expression is not true
\nfi
\nHere Shell expression is evaluated. If the resulting value is true, given statement(s) are executed. If expression is false then no statement would be not executed.<\/p>\n

then
\n command executed successfully
\n execute all commands up to else statement
\n or to fi if there is no else statement<\/p>\n

else
\n command failed so
\n execute all commands up to fi
\n fi
\nOR<\/p>\n

if test var -eq val
\n then
\n command executed successfully
\n execute all commands up to else statement
\n or to fi if there is no else statement<\/p>\n

else
\n if command failed then
\n execute all commands up to fi
\n fi
\nOR<\/p>\n

if [ condition ]
\n then
\n if given condition true
\n execute all commands up to else statement
\n or to fi if there is no else statement<\/p>\n

else
\n if given condition false
\n execute all commands up to fi
\n fi<\/p>\n

if [ condition ]
\nthen
\n < code block >
\nfi
\nFor example \u2013 If we need to check if input value is equal to 10 or not. If value is equal to 10, then it will print \u201cValue of i is 10?, but if not nothing will be printed.<\/p>\n

#!\/bin\/bash
\nread -p “Enter value of i :” i<\/p>\n

if [ $i -eq 10 ]
\nthen
\n echo “Value of i is 10”
\nfi
\n2. Bash if else Statement<\/p>\n

if else statements are useful where we have a two programs for execution, and need to execute only one based on results of if condition.<\/p>\n

if [ condition ]
\nthen
\n < code block >
\nelse
\n < code block >
\nfi
\nFor example \u2013 If input taken value is 10 then it will print \u201cValue of i is 10?, if not program will execute else block statement and print \u201cValue of i is not equal to 10?.<\/p>\n

#!\/bin\/bash
\nread -p “Enter value of i :” i<\/p>\n

if [ $i -eq 10 ]
\nthen
\n echo “Value of i is 10”
\nelse
\n echo “Value of i is not equal to 10”
\nfi
\n3. Bash if elif Statement<\/p>\n

if elif and else statements are useful where we have more than two programs for execution, and need to execute only one based on results of if and elif condition.<\/p>\n

if [ condition ]
\nthen
\n < code block >
\nelif [ condition ]
\nthen
\n < code block >
\nelse
\n < code block >
\nfi
\nFor example \u2013 Below example will check input value if equal to 5, if its true then program will print \u201cValue of i is 5? otherwise program will go to elif statement where one more conditional will be checked and based of these results elif or elase block code will be executed.<\/p>\n

#!\/bin\/bash
\nread -p “Enter value of i :” i<\/p>\n

if [ $i -eq 5 ]
\nthen
\n echo “Value of i is 5”
\nelif [ $i -eq 10 ]
\nthen
\n echo “Value of i is 10”
\nelse
\n echo “Value of i is not equal to 5 or 10”
\nfi
\n4. Bash elif Ladder Statements<\/p>\n

This is something similar to above one where we are adding multiple elif statements together. elif (else if) ladder are useful where we have multiple programs for execution and need to execute only one based on results of if and elif condition.<\/p>\n

if [ condition ]
\nthen
\n < code block ><\/p>\n

elif [ condition ]
\nthen
\n < code block ><\/p>\n

elif [ condition ]
\nthen
\n < code block ><\/p>\n

elif [ condition ]
\nthen
\n < code block ><\/p>\n

else
\n < code block >
\nfi
\nFor example \u2013<\/p>\n

#!\/bin\/bash
\nread -p “Enter value of i :” i<\/p>\n

if [ $i -eq 5 ]
\nthen
\n echo “Value of i is 5”
\nelif [ $i -eq 10 ]
\nthen
\n echo “Value of i is 10”
\nelif [ $i -eq 20 ]
\nthen
\n echo “Value of i is 20”
\nelif [ $i -eq 30 ]
\nthen
\n echo “Value of i is 30”
\nelse
\n echo “Value of i is not equal to 5,10,20 or 30”
\nfi
\n5. Bash nested if Statements<\/p>\n

Nested if are useful in the situation where one condition will be checked based on results of outer condition.<\/p>\n

if [ condition ]
\nthen
\n if [ condition ]
\n then
\n < code block >
\n else
\n < code block >
\n fi
\nelse
\n if [ condition ]
\n then
\n < code block >
\n fi
\nfi
\nFor example below small shell program is for finding the greatest value between 3 values taken input by user. This program will work with numeric values only. If two values are similar it will print only one value.<\/p>\n

#!\/bin\/bash<\/p>\n

read -p “Enter value of i :” i
\nread -p “Enter value of j :” j
\nread -p “Enter value of k :” k<\/p>\n

if [ $i -gt $j ]
\nthen
\n if [ $i -gt $k ]
\n then
\n echo “i is greatest”
\n else
\n echo “k is greatest”
\n fi
\nelse
\n if [ $j -gt $k ]
\n then
\n echo “j is greatest”
\n else
\n\t echo “k is greatest”
\n fi
\nfi<\/p>\n

Nested ifs<\/p>\n

if condition
\n\tthen
\n\t\tif condition
\n\t\tthen
\n\t\t\t…..
\n\t\t\t..
\n\t\t\tdo this
\n\t\telse
\n\t\t\t….
\n\t\t\t..
\n\t\t\tdo this
\n\t\tfi
\n\telse
\n\t\t…
\n\t\t…..
\n\t\tdo this
\n\tfi<\/p>\n

Number Testing Script
\nCreate a shell script called testnum.sh:
\n#!\/bin\/bash
\nread -p “Enter number : ” n
\nif test $n -ge 0
\nthen
\n\techo “$n is positive number.”
\nelse
\n\techo “$n number is negative number.”
\nfi<\/p>\n

!\/bin\/bash
\n#if then statement
\necho “Enter source and target files names.”
\nread source target
\nif mv $source $target
\nthen
\necho “Your file has been successully renamed..”
\nelse
\necho “Your file is not been moved…”
\nfi<\/p>\n

#!\/bin\/bash<\/p>\n

read -p “Enter first Number:” n1
\nread -p “Enter second Number:” n2
\nread -p “Enter third Number:” n3
\nread -p “Enter fourth Number:” n4<\/p>\n

if((n1>n2)) ; then
\nif((n1>n3)); then
\n if((n1>n4)); then
\necho “$n1 is a Greatest Number”
\nelse
\necho “$n4 is a Greatest Number”
\nfi
\n elif((n3>n4)); then
\necho “$n3 is a Greatest Number”
\nelse
\necho “$n4 is a Greatest Number”
\nfi
\nelif((n2>n3)); then
\nif((n2>n4)); then
\necho “$n2 is a Greatest Number”
\nelse
\necho “$n4 is a Greatest Number”
\n fi
\nelif((n3>n4)); then
\necho “$n3 is a Greatest Number”
\nelse
\necho “$n4 is a Greatest Number”
\nfi<\/p>\n

========================================Exit status of a command Parameters Set by the Shell==================================================================<\/p>\n

exit status of a command Parameters Set by the Shell<\/p>\n

Bash shell set several special parameters. For example $? (see return values section) holds the return value of the executed command.<\/p>\n

All command line parameters or arguments can be accessed via $1, $2, $3,…, $9.
\n$* holds all command line parameters or arguments.
\n$# holds the number of positional parameters.
\n$- holds flags supplied to the shell.
\n$? holds the return value set by the previously executed command.
\n$$ holds the process number of the shell (current shell).
\n$! hold the process number of the last background command.
\n$@ holds all command line parameters or arguments.
\nUse echo command to display special shell parameters:<\/p>\n

echo $#
\nYou can store them to a shell variables as follows:<\/p>\n

status=$?
\n[ $status -eq 0 ] && echo “Lighttpd … [Ok]” || echo “Lighttpd … [Failed]”
\nAssignment to special parameter is not allowed:
\n# okay
\nstatus=$?
\n# noop not allowed
\n$?=-1<\/p>\n

Exit Status
\nEvery Linux command executed by the shell script or user, has an exit status.
\nThe exit status is an integer number.
\nThe Linux man pages stats the exit statuses of each command.
\n0 exit status means the command was successful without any errors.
\nA non-zero (1-255 values) exit status means command was failure.
\nYou can use special shell variable called ? to get the exit status of the previously executed command. To print ? variable use the echo command:
\necho $?
\ndate # run date command
\necho $? # print exit status
\nfoobar123 # not a valid command
\necho $? # print exit status
\nHow Do I See Exit Status Of The Command?
\nType the following command:
\ndate
\nTo view exist status of date command, enter:<\/p>\n

echo $?
\nSample Output:<\/p>\n

0
\nTry non-existence command<\/p>\n

date1
\necho $?
\nls \/eeteec
\necho $?
\nSample Output:<\/p>\n

2
\nAccording to ls man page – exit status is 0 if OK, 1 if minor problems, 2 if serious trouble.<\/p>\n

How Do I Store Exit Status Of The Command In a Shell Variable?
\nAssign $? to a shell variable:<\/p>\n

ls -l \/tmp
\nstatus=$?
\necho “ls command exit stats – $status”
\nExit Status Shell Script Example
\nA simple shell script to locate username (finduser.sh)<\/p>\n

#!\/bin\/bash
\n# set var
\nPASSWD_FILE=\/etc\/passwd<\/p>\n

# get user name
\nread -p “Enter a user name : ” username<\/p>\n

# try to locate username in in \/etc\/passwd
\ngrep “^$username” $PASSWD_FILE > \/dev\/null<\/p>\n

# store exit status of grep
\n# if found grep will return 0 exit stauts
\n# if not found, grep will return a nonzero exit stauts
\nstatus=$?<\/p>\n

if test $status -eq 0
\nthen
\n\techo “User ‘$username’ found in $PASSWD_FILE file.”
\nelse
\n\techo “User ‘$username’ not found in $PASSWD_FILE file.”
\nfi
\nSave and close the file. Run it as follows:<\/p>\n

chmod +x finduser.sh
\n.\/finduser.sh
\nSample Outputs:<\/p>\n

Enter a user name : vivek
\nUser ‘vivek’ found in \/etc\/passwd file.
\nRun it again:<\/p>\n

chmod +x finduser.sh
\n.\/finduser.sh
\nSample Outputs:<\/p>\n

Enter a user name : tommy
\nUser ‘tommy’ not found in \/etc\/passwd file.
\nYou can combine the grep and if command in a single statement as follows:<\/p>\n

if grep “^$username:” \/etc\/passwd >\/dev\/null
\nthen
\n\techo “User ‘$username’ found in $PASSWD_FILE file.”
\nelse
\n\techo “User ‘$username’ not found in $PASSWD_FILE file.”
\nfi<\/p>\n

#!\/bin\/bash
\necho “Enter a number between 10 and 20 ”
\nread num
\nif [ $num -lt 10 ]
\nthen
\necho “That was under the limit you entered”
\nelif [ $num -gt 20 ]
\nthen
\necho “That over the limit you entered”
\nelse
\n echo “Now your are over the limit”
\nfi <\/p>\n

#!\/bin\/bash
\necho “Enter file name :\\c”
\nread fname
\nif [ -f $fname ]
\nthen
\n if [ -w $fname ]
\n\t then
\n\t\t echo “Type matter to append. To quit press ctrl+d ”
\n cat >> $fname
\n else
\n echo “You do not have permission to write. ”
\n fi
\nfi \t\t <\/p>\n

#!\/bin\/sh<\/p>\n

# Prompt for a user name…
\necho “Please enter your name:”
\nread USERNAME<\/p>\n

# Check for the file.
\nif [ -s ${USERNAME}_DAT ]; then
\n # Read the age from the file.
\n AGE=`cat ${USERNAME}_DAT`
\n echo “You are $AGE years old!”
\nelse
\n # Ask the user for his\/her age
\n echo “How old are you?”
\n read AGE<\/p>\n

\tif [ “$AGE” -le 2 ]; then
\n\t\techo “You are too young!”
\n\telse
\n\t\tif [ “$AGE” -ge 100 ]; then
\n\t\t\techo “You are too old!”
\n\t\telse
\n \t\t# Write the age to a new file.
\n \t\techo $AGE > ${USERNAME}_DAT
\n \tfi
\n fi
\nfi<\/p>\n

The syntax is as follows:<\/p>\n

exit N
\nThe exit statement is used to exit from the shell script with a status of N.
\nUse the exit statement to indicate successful or unsuccessful shell script termination.
\nThe value of N can be used by other commands or shell scripts to take their own action.
\nIf N is omitted, the exit status is that of the last command executed.
\nUse the exit statement to terminate shell script upon an error.
\nIf N is set to 0 means normal shell exit. Create a shell script called exitcmd.sh:
\n#!\/bin\/bash
\necho “This is a test.”
\n# Terminate our shell script with success message
\nexit 0
\nSave and close the file. Run it as follows:<\/p>\n

chmod +x exitcmd.sh
\n.\/exitcmd.sh
\nSample outputs:<\/p>\n

This is a test.
\nTo see exit status of the script, enter (see the exit status of a command for more information about special shell variable $?) :<\/p>\n

echo $?
\nShell script example
\nAny non zero value indicates unsuccessful shell script termination.
\nCreate a shell script called datatapebackup.sh:
\n#!\/bin\/bash
\nBAK=\/data2
\nTAPE=\/dev\/st0
\necho “Trying to backup ${BAK} directory to tape device ${TAPE} ..”<\/p>\n

# See if $BAK exits or not else die
\n# Set unsuccessful shell script termination with exit status # 1
\n[ ! -d $BAK ] && { echo “Source backup directory $BAK not found.”; exit 1; }<\/p>\n

# See if $TAPE device exits or not else die
\n# Set unsuccessful shell script termination with exit status # 2
\n[ ! -b $TAPE ] && { echo “Backup tape drive $TAPE not found or configured.”; exit 2; }<\/p>\n

# Okay back it up
\ntar cvf $TAPE $BAK 2> \/tmp\/error.log<\/p>\n

if [ $? -ne 0 ]
\nthen
\n # die with unsuccessful shell script termination exit status # 3
\n echo “An error occurred while making a tape backup, see \/tmp\/error.log file”.
\n exit 3
\nfi<\/p>\n

# Terminate our shell script with success message i.e. backup done!
\nexit 0
\nSave and close the file. Run it as follows:<\/p>\n

chmod +x datatapebackup.sh
\n.\/datatapebackup.sh
\necho $?<\/p>\n

=============================================================================================
\nString Comparison Operators in Shell Script<\/p>\n

OPERATOR DESCRIPTION
\nstr1 = str2 True if str1 and str2 are identical
\nstr1 != str2 True if str1 and str2 are not identical
\n-n str1 True if str1 is not null (size is greater than zero)
\n-z str1 True if str1 is null <\/p>\n

$ cat > strtest.sh <\/p>\n

#!\/bin\/bash
\na=’mohan’ b=’mohan’ c=’server’
\n#null string
\nd=’ ‘
\nif [ $a = $b ] ; then
\necho “a and b are identical”
\nfi
\nif [ $a != $c ] ; then
\necho “a and c are not identical” fi
\nif [ -z $d ] ; then
\necho “d is a null string”
\nfi <\/p>\n

Sourcesystem=”ABC”<\/p>\n

if [ “$Sourcesystem” = “XYZ” ]; then
\n echo “Sourcesystem Matched”
\nelse
\n echo “Sourcesystem is NOT Matched $Sourcesystem”
\nfi;<\/p>\n

if [ ‘XYZ’ == ‘ABC’ ]; then # Double equal to will work in Linux but not on HPUX boxes it should be if [ ‘XYZ’ = ‘ABC’ ] which will work on both
\n echo “Match”
\nelse
\n echo “No Match”
\nfi<\/p>\n

if [ “$var” == “” ] then
\necho variable is null
\nfi<\/p>\n

To determine if the value of a variable is not empty:<\/p>\n

if [ “$var” != “” ] then
\necho variable is not null
\nfi<\/p>\n

To compare the contents of a variable to a fixed string:<\/p>\n

if [ “$var” == “value” ] then
\necho is the same
\nfi<\/p>\n

To determine if variable\u2019s contents are not equal to a fixed string:<\/p>\n

if [ “$var” != “value” ] then
\necho not the same
\nfi<\/p>\n

Empty string in Bash<\/p>\n

In Bash you quite often need to check to see if a variable has been set or has a value other than an empty string. This can be done using the -n or -z string comparison operators.<\/p>\n

The -n operator checks whether the string is not null. Effectively, this will return true for every case except where the string contains no characters. ie:<\/p>\n

VAR=”hello”
\nif [ -n “$VAR” ]; then
\n echo “VAR is not empty”
\nfi<\/p>\n

Similarly, the -z operator checks whether the string is null. ie:<\/p>\n

VAR=””
\nif [ -z “$VAR” ]; then
\n echo “VAR is empty”
\nfi<\/p>\n

The following program shows the comparison of two strings in shell script<\/p>\n

#!\/bin\/sh
\nstr1=”happy”
\nstr2=”happy”
\n[ $str1 = $str2 ]
\necho $?<\/p>\n

Case Insensitive comparision of strings in Shell script<\/p>\n

str1=”MATCH”
\nstr2=”match”
\nshopt -s nocasematch
\ncase “$str1” in
\n $str2 ) echo “match”;;
\n *) echo “no match”;;
\nesac<\/p>\n

var1=match
\nvar2=MATCH
\nif echo $var1 | grep -i “^${var2}$” > \/dev\/null ; then
\n echo “MATCH”
\nfi<\/p>\n

I want to compare 2 strings with ignore case in bash shell.<\/p>\n

Suppose, if [ “test” = “TEst” ] … should be true and enter into if loop.<\/p>\n

Solution:<\/p>\n

Please try this:<\/p>\n

if [ `echo “TeSt” | tr -s ‘[:upper:]’ ‘[:lower:]` = `echo “Test” | tr -s ‘[:upper:]’ ‘[:lower:]` ]
\nthen
\necho “true”
\nelse
\necho “false”
\nfi<\/p>\n

or<\/p>\n

Try similar, it still worked.<\/p>\n

input=TESt
\ninput=`echo $input | tr ‘[A-Z]’ ‘[a-z]’`<\/p>\n

if [[ “$input” =~ “test” ]]; then
\necho “equal”
\nelse
\necho “not equal”
\nfi<\/p>\n

#!\/bin\/bash
\nstr1=”Hey You!”
\nstr2=”What’s up?”
\nstr3=””<\/p>\n

[ “$str1” = “$str2” ]
\necho $?<\/p>\n

[ “$str1” != “$str2” ]<\/p>\n

echo $?<\/p>\n

[ -n “$str1” ]<\/p>\n

echo $?<\/p>\n

[ -z “$str3” ]<\/p>\n

echo $?<\/p>\n

=================================================================================================
\nThe ‘AND’ Logical Operator<\/p>\n

Logical and (&&) is boolean operator. It can execute commands or shell functions based on the exit status of another command.<\/p>\n

command1 && command2
\nOR<\/p>\n

First_command && Second_command<\/p>\n

Boolean AND:<\/p>\n

&& or -a used to do boolean AND operations in bash\/shell scripts.<\/p>\n

To validate boolean AND condition there are two ways:<\/p>\n

if [ $condition1 ] && [ $condition2 ]
\nYou can also validate as<\/p>\n

if [ $condition1 -a $condition2 ]<\/p>\n

Type the following at a shell prompt:<\/p>\n

rm \/tmp\/filename && echo “File deleted.”
\nLookup a username in \/etc\/passwd file
\ngrep “^vivek” \/etc\/passwd && echo “Vivek found in \/etc\/passwd”
\nExit if a directory \/tmp\/foo does not exist
\ntest ! -d \/tmp\/foo && { read -p “Directory \/tmp\/foo not found. Hit [Enter] to exit…” enter; exit 1; }<\/p>\n

#!\/bin\/bash
\necho “Enter a number between 50 and 100”
\nread num
\nif [ $num -le 100 -a $num -ge 50 ]
\nthen
\n echo “You are within limits.”
\nelse
\n echo “Your are out of limits.”
\nfi<\/p>\n

You can test multiple expressions at once by using the || (or) operator or the && (and) operator. This can save you from writing extra code to nest if statements. The above code has a nested if statement where it checks if the age is greater than or equal to 100. This could be changed as well by using elif (else if). The structure of elif is the same as the structure of if, we will use it in an example below. In this example, we will check for certain age ranges. If you are less than 20 or greater than 50, you are out of the age range. If you are between 20 and 30 you are in your 20’s and so on.
\n#!\/bin\/sh<\/p>\n

# Prompt for a user name…
\necho “Please enter your age:”
\nread AGE<\/p>\n

if [ “$AGE” -lt 20 ] || [ “$AGE” -ge 50 ]; then
\n\techo “Sorry, you are out of the age range.”
\nelif [ “$AGE” -ge 20 ] && [ “$AGE” -lt 30 ]; then
\n\techo “You are in your 20s”
\nelif [ “$AGE” -ge 30 ] && [ “$AGE” -lt 40 ]; then
\n\techo “You are in your 30s”
\nelif [ “$AGE” -ge 40 ] && [ “$AGE” -lt 50 ]; then
\n\techo “You are in your 40s”
\nfi<\/p>\n

Count The Number of Characters in User’s Input in Your Script<\/p>\n

#!\/bin\/bash
\necho “Enter a charcter ”
\nread var
\nif [ ‘echo $var | wc -c ` -eq 2 ]
\nthen
\n echo “You entered a character. ”
\nelse
\n echo “Invalid Input.”
\nfi <\/p>\n

===========================================================================================
\nLogical OR<\/p>\n

Logical OR (||) is boolean operator. It can execute commands or shell functions based on the exit status of another command.<\/p>\n

Syntax
\ncommand1 || command2
\nOR<\/p>\n

First_command || Second_command
\ncommand2 is executed if, and only if, command1 returns a non-zero exit status. In other words, run command1 successfully or run command2.<\/p>\n

Boolean OR:<\/p>\n

|| or -o used to do boolean OR operations in bash\/shell scripts.<\/p>\n

To validate boolean OR there are 2 ways:<\/p>\n

if [ $condition1 ] || [ $condition2 ]
\nYou can also validate boolean OR as<\/p>\n

if [ $condition1 -o $condition2 ]<\/p>\n

Example
\ncat \/etc\/shadow 2>\/dev\/null || echo “Failed to open file”
\nThe cat command will try to display \/etc\/shadow file and it (the cat command) sets the exit stats to non-zero value if it failed to open \/etc\/shadow file. Therefore, ‘Failed to open file’ will be displayed cat command failed to open the file.<\/p>\n

Find username else display an error
\ngrep “^vivek” \/etc\/passwd || echo “User vivek not found in \/etc\/passwd”
\nHow Do I Combine Both Logical Operators?
\nTry it as follows:<\/p>\n

cat \/etc\/shadow 2>\/dev\/null && echo “File successfully opened.” || echo “Failed to open file.”
\nMake sure only root can run this script:<\/p>\n

test $(id -u) -eq 0 && echo “You are root” || echo “You are NOT root”
\nOR<\/p>\n

test $(id -u) -eq 0 && echo “Root user can run this script.” || echo “Use sudo or su to become a root user.”<\/p>\n

=============================================================================================================================================================<\/p>\n

Logical Not !<\/p>\n

Logical not (!) is boolean operator, which is used to test whether expression is true or not. For example, if file not exists, then display an error on screen.<\/p>\n

Syntax
\nThe test command syntax is as follows:<\/p>\n

! expression
\nOR<\/p>\n

[ ! expression ]
\nOR<\/p>\n

if test ! condition
\nthen
\n command1
\n command2
\nfi
\nif [ ! condition ]
\nthen
\n command1
\n command2
\nfi
\nWhere,<\/p>\n

True if expression is false.
\nExamples
\nTry the following example:<\/p>\n

test ! -f \/etc\/resolv.conf && echo “File \/etc\/resolv.conf not found.”
\nOR<\/p>\n

test ! -f \/etc\/resolv.conf && echo “File \/etc\/resolv.conf not found.” || echo “File \/etc\/resolv.conf found.”
\nCreate a directory \/backup, if doesn’t exits:<\/p>\n

[ ! -d \/backup ] && mkdir \/backup
\nDie (exit) if $HOME\/.config file not found:<\/p>\n

[ ! -f $HOME\/.config ] && { echo “Error: $HOME\/.config file not found.”; exit 1; }
\nDie (exit) if directory \/usr\/bin not found<\/p>\n

[ ! -d \/usr\/bin ] && exit<\/p>\n

================================================================================================================<\/p>\n

count<\/p>\n

#!\/bin\/bash
\nBEGIN=1 # Start counting here
\nEND=10 # Stop counting here<\/p>\n

END=`expr $END + 1`<\/p>\n

while [ $END -ne $BEGIN ]; do # While END is not equal to BEGIN do …
\n echo This is iteration $BEGIN
\n BEGIN=`expr $BEGIN + 1` # Increasing the value of BEGIN by one
\ndone<\/p>\n

========================================================================================================
\nConditional expression<\/p>\n

The test command is used to check file types and compare values. You can also use [ as test command. It is used for:<\/p>\n

File attributes comparisons
\nPerform string comparisons.
\nArithmetic comparisons.
\nSyntax
\n[ condition ]
\nOR<\/p>\n

[ ! condition ]
\nOR<\/p>\n

[ condition ] && true-command
\nOR<\/p>\n

[ condition ] || false-command
\nOR<\/p>\n

[ condition ] && true-command || false-command
\nExamples
\n[ 5 == 5 ] && echo “Yes” || echo “No”
\n[ 5 == 15 ] && echo “Yes” || echo “No”
\n[ 5 != 10 ] && echo “Yes” || echo “No”
\n[ -f \/etc\/resolv.conf ] && echo “File \/etc\/resolv.conf found.” || echo “File \/etc\/resolv.conf not found.”
\n[ -f \/etc\/resolv1.conf ] && echo “File \/etc\/resolv.conf found.” || echo “File \/etc\/resolv.conf not found.”<\/p>\n

====================================================================================================
\nThe ‘case’ Statement<\/p>\n

he case statement is good alternative to multilevel if-then-else-fi statement. It enable you to match several values against one variable. It is easier to read and write.<\/p>\n

Syntax
\nThe syntax is as follows:<\/p>\n

case $variable-name in
\n pattern1)
\n \t\t command1
\n …
\n ….
\n commandN
\n ;;
\n pattern2)
\n \t\t command1
\n …
\n ….
\n commandN
\n ;;
\n patternN)
\n \t\t command1
\n …
\n ….
\n commandN
\n ;;
\n *)
\n esac
\nOR<\/p>\n

case $variable-name in
\n pattern1|pattern2|pattern3)
\n \t\t command1
\n …
\n ….
\n commandN
\n ;;
\n pattern4|pattern5|pattern6)
\n \t\t command1
\n …
\n ….
\n commandN
\n ;;
\n pattern7|pattern8|patternN)
\n \t\t command1
\n …
\n ….
\n commandN
\n ;;
\n *)
\n esac
\nThe case statement allows you to easily check pattern (conditions) and then process a command-line if that condition evaluates to true.
\nIn other words the $variable-name is compared against the patterns until a match is found.
\n*) acts as default and it is executed if no match is found.
\nThe pattern can include wildcards.
\nYou must include ;; at the end of each commandN. The shell executes all the statements up to the two semicolons that are next to each other.
\nThe esac is always required to indicate end of case statement.
\nExample
\nCreate a shell script called rental.sh:<\/p>\n

#!\/bin\/bash<\/p>\n

# if no command line arg given
\n# set rental to Unknown
\nif [ -z $1 ]
\nthen
\n rental=”*** Unknown vehicle ***”
\nelif [ -n $1 ]
\nthen
\n# otherwise make first arg as a rental
\n rental=$1
\nfi<\/p>\n

# use case statement to make decision for rental
\ncase $rental in
\n “car”) echo “For $rental rental is Rs.20 per k\/m.”;;
\n “van”) echo “For $rental rental is Rs.10 per k\/m.”;;
\n “jeep”) echo “For $rental rental is Rs.5 per k\/m.”;;
\n “bicycle”) echo “For $rental rental 20 paisa per k\/m.”;;
\n “enfield”) echo “For $rental rental Rs.3 per k\/m.”;;
\n “thunderbird”) echo “For $rental rental Rs.5 per k\/m.”;;
\n *) echo “Sorry, I can not get a $rental rental for you!”;;
\nesac
\nSave and close the file. Run it as follows:<\/p>\n

chmod +x rental.sh
\n.\/rental.sh
\n.\/rental.sh jeep
\n.\/rental.sh enfield
\n.\/rental.sh bike
\nSample outputs:<\/p>\n

Sorry, I can not get a *** Unknown vehicle *** rental for you!
\nFor jeep rental is Rs.5 per k\/m.
\nFor enfield rental Rs.3 per k\/m.
\nSorry, I can not get a bike rental for you!
\nThe case statement first checks $rental against each option for a match. If it matches “car”, the echo command will display rental for car. If it matches “van”, the echo command will display rental for van and so on. If it matches nothing i.e. * (default option), an appropriate warning message is printed.<\/p>\n

Using Multiple Patterns
\n#!\/bin\/bash
\nNOW=$(date +”%a”)
\ncase $NOW in
\n\tMon)
\n\t\techo “Full backup”;;
\n\tTue|Wed|Thu|Fri)
\n\t\techo “Partial backup”;;
\n\tSat|Sun)
\n\t\techo “No backup”;;
\n\t*) ;;
\nesac
\nThe following shell script demonstrate the concept of command line parameters processing using the case statement (casecmdargs.sh):<\/p>\n

#!\/bin\/bash
\nOPT=$1 # option
\nFILE=$2 # filename<\/p>\n

# test -e and -E command line args matching
\ncase $OPT in
\n -e|-E)
\n \techo “Editing $2 file…”
\n # make sure filename is passed else an error displayed
\n \t[ -z $FILE ] && { echo “File name missing”; exit 1; } || vi $FILE
\n \t;;
\n -c|-C)
\n \techo “Displaying $2 file…”
\n \t[ -z $FILE ] && { echo “File name missing”; exit 1; } || cat $FILE
\n \t;;
\n -d|-D)
\n \techo “Today is $(date)”
\n \t;;
\n *)
\n echo “Bad argument!”
\n echo “Usage: $0 -ecd filename”
\n echo ”\t-e file : Edit file.”
\n echo ”\t-c file : Display file.”
\n echo ”\t-d : Display current date and time.”
\n ;;
\nesac
\nRun it as follows:<\/p>\n

chmod +x casecmdargs.sh
\n.\/casecmdargs.sh
\n.\/casecmdargs.sh -e \/tmp\/file
\n.\/casecmdargs.sh -E \/tmp\/file
\n.\/casecmdargs.sh -e
\n.\/casecmdargs.sh -D
\nCreating a backup script
\nCreate a backup script called allinonebackup.sh:<\/p>\n

#!\/bin\/bash
\n# A shell script to backup mysql, webserver and files to tape
\nopt=$1
\ncase $opt in
\n sql)
\n echo “Running mysql backup using mysqldump tool…”
\n ;;
\n sync)
\n echo “Running backup using rsync tool…”
\n ;;
\n tar)
\n echo “Running tape backup using tar tool…”
\n ;;
\n *)
\n \t echo “Backup shell script utility”
\n echo “Usage: $0 {sql|sync|tar}”
\n echo ”\tsql : Run mySQL backup utility.”
\n echo ”\tsync : Run web server backup utility.”
\n echo ”\ttar : Run tape backup utility.”\t;;
\nesac
\nSave and close the file. Run it as follows:<\/p>\n

chmod +x allinonebackup.sh
\n# run sql backup
\n.\/allinonebackup.sh sql
\n# Dump file system using tape device
\n.\/allinonebackup.sh tar
\n# however, the following will fail as patterns are case sensitive
\n# you must use command line argument tar and not TAR, Tar, TaR etc.
\n.\/allinonebackup.sh TAR<\/p>\n

#!\/bin\/sh<\/p>\n

echo “Please talk to me …”
\nwhile :
\ndo
\n read INPUT_STRING
\n case $INPUT_STRING in
\n hello)
\n echo “Hello yourself!”
\n ;;
\n bye)
\n echo “See you again!”
\n break
\n ;;
\n *)
\n echo “Sorry, I don’t understand”
\n ;;
\n esac
\ndone
\necho
\necho “That’s all folks!”
\nOkay, so it’s not the best conversationalist in the world; it’s only an example!
\nTry running it and check how it works…<\/p>\n

$ .\/talk.sh
\nPlease talk to me …
\nhello
\nHello yourself!
\nWhat do you think of politics?
\nSorry, I don’t understand
\nbye
\nSee you again!<\/p>\n

That’s all folks!<\/p>\n

#!\/bin\/bash<\/p>\n

MENU=”
\n1 Date and Time
\n2 Calendar for current month
\n3 quit
\n”<\/p>\n

while true; do
\n clear
\n echo “$MENU”
\n echo -n “Please make your choice: ”
\n read INPUT # Read user input and assign it to variable INPUT<\/p>\n

case $INPUT in
\n 1)
\n date
\n echo press ENTER to continue
\n read
\n ;;
\n 2)
\n cal
\n echo press ENTER to continue
\n read
\n ;;
\n 3|q|Q) # If user presses 3, q or Q we terminate
\n exit 0
\n ;;
\n *) # All other user input results in an usage message
\n clear
\n echo Please choose alternatves 1, 2 or 3
\n sleep 2
\n ;;
\n esac<\/p>\n

done<\/p>\n

!\/bin\/sh<\/p>\n

FRUIT=”apple”<\/p>\n

case “$FRUIT” in
\n “apple”) echo “Apple pie is quite tasty.”
\n ;;
\n “banana”) echo “I like banana nut bread.”
\n ;;
\n “kiwi”) echo “New Zealand is famous for kiwi.”
\n ;;
\nesac<\/p>\n

#!\/bin\/sh
\necho “Enter a character”
\nread var
\ncase $var in
\n[a-z])
\n echo “You entered a lower case alphabet.”
\n ;;
\n[A-Z])
\n echo “You entered a upper case alphabet.”
\n ;;
\n[0-9])
\n echo ” You entered a digit.”
\n ;;
\n?)
\n echo ” You entered a speical sysmbol.”
\n ;;
\n*)
\n echo ” You entered more than one character.”
\n ;;
\nesac<\/p>\n

root@cluster1 shell]# .\/case.sh
\nEnter a character
\na
\nYou entered a lower case alphabet.
\n[root@cluster1 shell]# .\/case.sh
\nEnter a character
\nA
\nYou entered a lower case alphabet.
\n[root@cluster1 shell]# .\/case.sh
\nEnter a character
\nasfhadad<\/p>\n

=============================================================================================================================<\/p>\n

=================================================================================================================================================
\nQuick Reference
\nThis is a quick reference guide to the meaning of some of the less easily guessed commands and codes.
\nCommand\tDescription\tExample
\n&\tRun the previous command in the background\tls &
\n&&\tLogical AND\tif [ “$foo” -ge “0” ] && [ “$foo” -le “9”]
\n||\tLogical OR\tif [ “$foo” -lt “0” ] || [ “$foo” -gt “9” ] (not in Bourne shell)
\n^\tStart of line\tgrep “^foo”
\n$\tEnd of line\tgrep “foo$”
\n=\tString equality (cf. -eq)\tif [ “$foo” = “bar” ]
\n!\tLogical NOT\tif [ “$foo” != “bar” ]
\n$$\tPID of current shell\techo “my PID = $$”
\n$!\tPID of last background command\tls & echo “PID of ls = $!”
\n$?\texit status of last command\tls ; echo “ls returned code $?”
\n$0\tName of current command (as called)\techo “I am $0”
\n$1\tName of current command’s first parameter\techo “My first argument is $1”
\n$9\tName of current command’s ninth parameter\techo “My ninth argument is $9”
\n$@\tAll of current command’s parameters (preserving whitespace and quoting)\techo “My arguments are $@”
\n$*\tAll of current command’s parameters (not preserving whitespace and quoting)\techo “My arguments are $*”
\n-eq\tNumeric Equality\tif [ “$foo” -eq “9” ]
\n-ne\tNumeric Inquality\tif [ “$foo” -ne “9” ]
\n-lt\tLess Than\tif [ “$foo” -lt “9” ]
\n-le\tLess Than or Equal\tif [ “$foo” -le “9” ]
\n-gt\tGreater Than\tif [ “$foo” -gt “9” ]
\n-ge\tGreater Than or Equal\tif [ “$foo” -ge “9” ]
\n-z\tString is zero length\tif [ -z “$foo” ]
\n-n\tString is not zero length\tif [ -n “$foo” ]
\n-nt\tNewer Than\tif [ “$file1” -nt “$file2” ]
\n-d\tIs a Directory\tif [ -d \/bin ]
\n-f\tIs a File\tif [ -f \/bin\/ls ]
\n-r\tIs a readable file\tif [ -r \/bin\/ls ]
\n-w\tIs a writable file\tif [ -w \/bin\/ls ]
\n-x\tIs an executable file\tif [ -x \/bin\/ls ]
\nparenthesis:
\n( … )\tFunction definition\tfunction myfunc() { echo hello }<\/p>\n

Quiz: ShellCheck is aware of many common usage problems. Are you?<\/p>\n

find . -name *.mp3
\nsudo echo 3 > \/proc\/sys\/vm\/drop_caches
\nPS1=’\\e[0;32m\\$\\e[0m ‘
\nfind . | grep “*.mp3”
\n[ $n > 7 ]
\n[[ $n > 7 ]]
\ntr ‘A-Z’ ‘a-z’
\ncmd 2>&1 > log
\narray=(1, 2, 3)
\necho $10
\n[[ $a=$b ]]
\n[[ $a = $b ]]
\nprogress=$((i\/total*100))
\ntrap “echo \\”Time used: $SECONDS\\”” EXIT
\nfind dir -exec cp {} \/backup && rm {} \\;
\n[[ $keep = [yY] ]] && mv file \/backup || rm file<\/p>\n

ShellCheck gives more helpful messages for many Bash syntax errors<\/p>\n

Bash says\tShellCheck points to the exact position and says
\n: command not found\tLiteral carriage return. Run script through tr -d \u2018\\r\u2019
\nunexpected token: `fi\u2019\tCan\u2019t have empty then clauses (use \u2018true\u2019 as a no-op)
\nunexpected token `(\u2018\tShells are space sensitive. Use \u2018< <(cmd)', not '<<(cmd)'\nunexpected token `(\u2018\t\u2018(\u2018 is invalid here. Did you forget to escape it?\necho foo: command not found\tThis is a  . Delete it and retype as space.\n \n \nShellCheck suggests style improvements\n\nCode\tShellCheck suggestion\nbasename \"$var\"\tUse parameter expansion instead, such as ${var##*\/}\nls | grep 'mp3$'\tDon\u2019t use ls | grep. Use a glob or a for loop with a condition.\nexpr 3 + 2\tUse $((..)), ${} or [[ ]] in place of antiquated expr.\ncat foo | grep bar\tUseless cat. Consider \u2018cmd < file | ..' or 'cmd file | ..' instead.\nlength=$(echo \"$var\" | wc -c\")\tSee if you can use ${#variable} instead\n\n\n\nShellCheck recognizes common but wrong attempts at doing things\n\nCode\tShellCheck tip\nvar$n=42\tFor indirection, use (associative) arrays or \u2018read \u201cvar$n\u201d <<< \"value\"'\".\n(Bash says \u201cvar3=42: command not found\u201d)\n${var$n}\tTo expand via indirection, use name=\u201dfoo$n\u201d; echo \u201c${!name}\u201d \n(Bash says \u201cbad substitution\u201d. )\necho 'It\\'s time'\tAre you trying to escape that single quote? echo \u2018You\u2019\\\u201dre doing it wrong\u2019\n(Bash says \u201cunexpected end of file\u201d)\n[ grep a b ]\tUse \u2018if cmd; then ..\u2019 to check exit code, or \u2018if [[ $(cmd) == .. ]]\u2019 to check output\n(Bash says \u201c[: a: binary operator expected\u201d)\nvar=grep a b\tTo assign the output of a command, use var=$(cmd)\n(Bash says \u201ca: command not found\u201d)\n\n\n\n=================================================================================================================================================\n<\/p>\n","protected":false},"excerpt":{"rendered":"

Shell program<\/p>\n

View System Date, Calender<\/p>\n

Calender<\/p>\n

[root@cluster1 ~]# cal April 2015 Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30<\/p>\n

[root@cluster1 ~]# cal 7 2015 July […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[47],"tags":[],"_links":{"self":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts\/4698"}],"collection":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=4698"}],"version-history":[{"count":3,"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts\/4698\/revisions"}],"predecessor-version":[{"id":4711,"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts\/4698\/revisions\/4711"}],"wp:attachment":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=4698"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=4698"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=4698"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}