Linux

Thanks Alister for the concept. I have 3 related queries please:
1)

Code:

$ IFS=ab
$ echo `echo cabcow`
$ c  cow
$ echo cabcow
$ cabcow

It's confirmed that SHELL parses or splits the fields based on IFS at command substitution or variable evaluation.
But how a command line is split into fields? Here IFS isn't considered!

2)

Code:

IFS=ab
echo $IFS | od -bc
040 012
       \n
echo "$IFS" | od -bc
141 142 012
  a    b    \n

why the space character displayed when not quoted?
3) The effect of double quotes :

Code:

echo `ls`
echo "`ls`"

The former command displays the filenames in a single line with a space in between 2 names.
The latter displays as the 'ls' output is.i,e. one name with newline character in each line.
May I conclude that when quoted, the command hasn't converted the newline character to a space which it was doing when not quoted. That means, here double quotes is interpreted by command also and not only by SHELL.

Ad 1.
Here the field is split in three parts:
- the "c" before the IFS character "a"
- The empty field between "a" and "b"
- And the string "cow" behind the "b"
These 3 fields are separated by spaces.

Ad 2.
The space is diplayed because in IFS there are two characters, "a" and "b". the first field is the empty string before that "a". The second field is the empty string between "a" and "b". The fields are split using a single space, which accounts for the space showing up in the od -c output. Since IFS acts as a field terminator rather then a separator, there is no third empty field after "b".

Ad 3. That is not correct. The output of the commands are input to the echo command. The first is unquoted, therefore it is split according to $IFS. Whereas the second one quoted and thus not split.

What a concept Scrutinizer and especially the 2nd one!!
Thanks a lot!
By the way, my 1st question is still left!

Code:

But how a command line is split into fields? Here IFS isn't considered!

By this I meant: (for ex.)

Code:

grep us file.txt

How the command line is parsed. Or, in other words, how grep understand what is 1st argument and the 2nd one? Here it isn't considering IFS!

That is correct. IFS is only used after parameter expansion, command substitution and arithmetic expansion and with the read command.
So the shells always uses whitespace (space, tab, newline) as a separator between the various arguments and the command.

IFS is only used to split the results of unquoted expansions (such as $var, $(cmd)) and by the read command. The shell does not use it during its initial scan of the command line. During that early step, whitespace always delimits words (tokens, to be more precise), regardless of the value of IFS.

With regard to how grep finds its first argument, that's more involved. Once the shell has finished parsing the command line, it forks (or clones) itself. If all goes well, the new subshell calls one of the functions in the exec family with the command to run and a list of arguments to pass to it. This replaces the subshell with the command that was exec'd. The command's arguments are found in the array argv[], with the first argument at argv[1] (argv[0] is the command's name).

The details of creating the process and locating the list of arguments (and the environment) are overseen by the kernel and the c runtime.

Also, should you need to know every last detail of how your shell interprets command lines, you should read your shell's manual page in its entirety. There is also the POSIX standard's documentation, which will give you detailed knowledge of a common UNIX baseline:

POSIX
sh
Shell Command Language
exec family

Those links aren't intended to silence you (your questions are very welcome). I provide them only in case you are not aware of them.

Regards,
Alister

Thanks Alister and Scrutinizer for the basics!

Thank you too ravisingh for your good questions!