{"id":10791,"date":"2006-04-25T12:18:00","date_gmt":"2006-04-25T12:18:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/powershell\/2006\/04\/25\/comparative-examples-in-msh-and-ksh\/"},"modified":"2019-02-18T13:25:02","modified_gmt":"2019-02-18T20:25:02","slug":"comparative-examples-in-msh-and-ksh","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/powershell\/comparative-examples-in-msh-and-ksh\/","title":{"rendered":"Comparative Examples in MSH and KSH"},"content":{"rendered":"
\n

 <\/h2>\n

M<\/font>ost shells (such as Windows CMD.EXE and the UNIX shells SH, KSH, CSH, and BASH) operate by executing a command or utility in a new process, and presenting the results (or errors) to the user as text. Text-based processing is the way in which system interaction is done with these shells. Over the years, a large number of text processing utilities\u2014such as sed, AWK, and PERL\u2014have evolved to support this interaction. The heritage of this operational process is very rich. <\/p>\n

MSH is very different from these traditional shells. First, this shell does not use text as the basis for interaction with the system, but uses an object model based on the .NET platform. Second, the list of built-in commands is much larger; this is done to ensure that the interaction with the object model is accomplished with the highest regard to integrity with respect to interacting with the system. Third, the shell provides consistency with regard to interacting with built-in commands through the use of a single parser, rather than relying on each command to create its own parser for parameters. <\/p>\n

This document constrasts the Korn Shell (KSH) and MSH by providing a number of examples of each. <\/p>\n

Example 1<\/b><\/p>\n

To stop all processes that begin with the letter “p” on a UNIX system, an administrator would have to type the following shell command line:<\/p>\n

\n

$ ps<\/span><\/span> -e | grep<\/span> ” p” | awk<\/span> ‘{ print $1 }’ | xargs<\/span> kill<\/p>\n<\/div>\n

The ps<\/span><\/span> command retrieves list of processes and directs (|) the grep<\/span><\/span> command to determine which process begins with “p”; which in turn directs (|) the awk<\/span><\/span> command to select the 1st column (which is in the process id) and then passes (|) those to the xargs<\/span><\/span> command which then executes the kill<\/span> command for each process.  <\/span>The fragility of this command line may not be evident, but if the ps<\/span><\/span> command behaves differently on different systems, where the “-e” flag may not be present, or if the processed command is not in column 1 of the output, this command-line procedure will fail. <\/p>\n

MSH:<\/p>\n

\n

MSH> get-process p* | stop-process<\/p>\n<\/div>\n

Thus, the command line may now be expressed as “get the processes whose name starts with “p” and stop them”.  <\/span>The get-process<\/span> Cmdlet takes an argument that matches the process name; the objects returned by get-process<\/span> are passed directly to the stop-process<\/span> Cmdlet that acts on those objects by stopping them.<\/p>\n

The second, more convoluted example, which stops processes that use more than 10 MB of memory<\/span> becomes quite simple.<\/p>\n

Example 2<\/b><\/p>\n

Another, even more complex example, such as “find the processes that use more than 10 MB of memory and kill them” can lead to an equally failed outcome:<\/p>\n

\n

$ ps<\/span><\/span> -el | awk<\/span> ‘{ if ( $6 > (1024*10)) { print $3 } }’ | grep<\/span> -v PID | xargs<\/span> kill<\/p>\n<\/div>\n

The success of this command line relies on the user knowing that the ps<\/span><\/span> -el<\/span> command will return the size of the process in kilobytes (kb) in column 6 and that the PID of the process is in column 3.  <\/span>It is still required that the first row is removed.<\/p>\n

Comparing Example 1 using a standard shell to Example 1a using MSH, we can see that the commands act against objects rather than against text.<\/p>\n

MSH:<\/p>\n

\n

MSH> get-process | where { $<\/span>_.WS –gt<\/span> 10MB } | stop-process<\/p>\n<\/div>\n

There is no issue about determining the column that contains the size of the process, or which column contains the ProcessID<\/span>.  <\/span>The memory size may be referred to logically, by its name.  <\/span>The where<\/span> Cmdlet can inspect the incoming object directly and refer to its properties.  <\/span>The comparison of the value for that property is direct and understandable.<\/p>\n

Example 3<\/b><\/p>\n

For example, if you wanted to calculate the number of bytes in the files in a directory, you would iterate over the files, getting the length and adding to a variable, and then print the variable:<\/p>\n

\n

$ tot=<\/span>0; for file in $( ls<\/span> )<\/p>\n

> do<\/p>\n

>     <\/span>set — $( ls<\/span><\/span> -log $file  <\/span>)<\/p>\n

>     <\/span>echo $3<\/p>\n

>     <\/span>(( tot<\/span> = $tot + $3 ))<\/p>\n

> done; echo $tot<\/p>\n<\/div>\n

This example uses the set<\/span> shell command that creates numbered variables for each white space separated element in the line rather than the awk<\/span><\/span> command as in the examples above.  <\/span>If the awk<\/span><\/span> command were used, it would be possible to reduce the steps to the following:<\/p>\n

\n

$ ls<\/span><\/span> \u2013l | awk<\/span> \u2018{ tot += $5; print tot; }\u2019 | tail -1<\/p>\n<\/div>\n

This reduces the complexity, but requires specific knowledge of a new language, the language that is associated with the awk<\/span><\/span> command. <\/p>\n

The MSH loop is similar; each file in the directory is needed, but it is far simpler as the information about the file is already retrieved:<\/p>\n

MSH:<\/p>\n

\n

MSH> get-childitem<\/span> | measure-object -Property length -Sum<\/p>\n<\/div>\n

The measure-object<\/span> Cmdlet interacts with objects and if it is provided with a property from the object, it will sum the values of that property.  <\/span>Because the property length represents the length of the file, the measure-object<\/span> Cmdlet is able to act directly on the object by referring to the property name rather than \u201cknowing\u201d that the length of the file is in column 3 or column 5.<\/p>\n

Example 4<\/b><\/p>\n

Many objects provided by the system are not static, but dynamic.  <\/span>This means that after an object is acquired, it is not necessary to acquire the object at a later time.  <\/span>The data in the object is updated as the conditions of the system change.  <\/span>Also, changes to these objects are reflected immediately in the system.<\/p>\n

As an example, suppose one wanted to collect the amount of processor time that a process used over time.  <\/span>In the traditional UNIX model, the ps<\/span><\/span> command would need to be run iteratively and the appropriate column in the output would need to be found and then the subtraction would need to be done.  <\/span>With a shell that is able to access the process object of the system, it is possible to acquire the process object once, and since this object is continually updated by the system; all that is necessary is to refer to the property.  <\/span>The following examples illustrate the differences, where the memory size of an application is checked in ten second intervals and the differences are output:<\/p>\n

\n

$ while<\/span> [ true ]<\/p>\n

do<\/span><\/p>\n

   <\/span>msize1=$( ps<\/span> -el | grep<\/span> application | grep<\/span> -v grep<\/span> | awk<\/span> ‘{  <\/span>print $6 }’ )<\/p>\n

   <\/span>sleep<\/span> 10<\/p>\n

   <\/span>msize2=$( ps<\/span><\/span> -el | grep<\/span> application | grep<\/span> -v grep<\/span> | awk<\/span> ‘{  <\/span>print $6 }’ )<\/p>\n

   <\/span>expr<\/span><\/span> $msize2 – $msize1<\/p>\n

   <\/span>msize1=$msize2<\/p>\n

done<\/span><\/p>\n<\/div>\n

MSH:<\/p>\n

\n

MSH> $app = get-process application<\/p>\n

MSH> while ( 1<\/span> ) {       <\/span><\/p>\n

>> $msize1 = $app.VS<\/span><\/p>\n

>> start-sleep<\/span> 10<\/p>\n

>> $app.VS<\/span> – $msize1   <\/span><\/p>\n

>> }<\/p>\n<\/div>\n

Example 5<\/b><\/p>\n

It is even more difficult to determine whether a specific process is no longer running.  <\/span>In this case, the UNIX user must collect the list of processes and compare them to another list.  <\/span><\/p>\n

\n

$ processToWatch<\/span><\/span>=$( ps<\/span> -e | grep<\/span> application | awk<\/span> ‘{ print $1 }’<\/p>\n

$ while<\/span> [ true ]<\/p>\n

> do<\/p>\n

>     <\/span>sleep 10<\/p>\n

>     <\/span>processToCheck<\/span><\/span>=$(ps<\/span> -e | grep<\/span> application | awk<\/span> ‘{ print $1 }’ )<\/p>\n

>     <\/span>if<\/span> [ -z “$processToCheck<\/span>” -or “$processToWatch<\/span>” != “$processToCheck<\/span>” ]<\/p>\n

>     <\/span>then<\/span><\/p>\n

>        <\/span>echo “Process application is not running”<\/p>\n

>        <\/span>return<\/p>\n

>     <\/span>fi<\/span><\/span><\/p>\n

> done<\/p>\n<\/div>\n

MSH:<\/p>\n

\n

MSH> $processToWatch<\/span> = get-process application<\/p>\n

MSH> $processToWatch.WaitForExit<\/span><\/span>()<\/span><\/p>\n<\/div>\n

As is seen in this example, the MSH user need only collect the object and then subsequently refer to that object.  <\/span><\/p>\n

Example 6<\/b><\/p>\n

For example, suppose the user wanted to determine which processes were compiled as PreRelease<\/span> code, such as when applications have been compiled in such a way to mark them as “PreRelease<\/span>“.<\/p>\n

\n

$ ???<\/p>\n<\/div>\n

This information is not kept in the standard UNIX executable.  <\/span>To determine this information, one would need to have a set of specialized utilities to add this information to the binary and then another set of utilities to collect this information.  <\/span>These utilities do not exist; it is not possible to accomplish this task.<\/p>\n

MSH:<\/p>\n

\n

MSH> get-process | where {$_.mainmodule.FileVersioninfo.isPreRelease<\/span>}<\/p>\n

Handles  <\/span>NPM<\/span>(K)    <\/span>PM(K)      <\/span>WS(K) VS(M)   <\/span>CPU(s)     <\/span>Id ProcessName<\/span><\/p>\n

——-  <\/span>——    <\/span>—–      <\/span>—– —–   <\/span>——     <\/span>— ———–<\/p>\n

    <\/span>643      <\/span>88     <\/span>1024       <\/span>1544    <\/span>15    <\/span>14.06   <\/span>1700 AdtAgent<\/span><\/p>\n

    <\/span>453      <\/span>15    <\/span>25280       <\/span>7268   <\/span>199    <\/span>91.70   <\/span>3952 devenv<\/span><\/p>\n<\/div>\n

In this example, a cascade of properties is done.  <\/span>The appropriate property from the process object (MainModule<\/span>) is inspected, the property “FileVersionInfo<\/span>” is referenced (a property of MainModule<\/span>) and the value of the property “IsPreRelease<\/span>” is used to filter the results.  <\/span>If IsPreRelease<\/span> is true, the objects that are output by the get-process<\/span> Cmdlet are output.<\/p>\n

Example 7<\/b><\/p>\n

Each object may or may not provide methods; MSH provides commands to aid the discovery of methods that are available for a specific object via the get-member<\/span> Cmdlet.  <\/span>For example, the string object has a large number of methods:<\/p>\n

MSH:<\/p>\n

\n

MSH> get-member -input “String” –membertype<\/span> method | format-table “$_”<\/p>\n

“$_”<\/p>\n

———<\/p>\n

System.Object<\/span> Clone()<\/span><\/p>\n

Int32 Compare(<\/span>System.String<\/span>, System.String<\/span>, Boolean, System.Globalization.Cul<\/span>..<\/p>\n

Int32 CompareOrdinal<\/span><\/span>(<\/span>System.String<\/span>, Int32, System.String<\/span>, Int32, Int32)<\/p>\n

Int32 CompareTo<\/span><\/span>(<\/span>System.String<\/span>)<\/p>\n

System.String<\/span> Concat<\/span><\/span>(<\/span>System.String<\/span>, System.String<\/span>)<\/p>\n

Boolean Contains(<\/span>System.String<\/span>)<\/p>\n

System.String<\/span> Copy(<\/span>System.String<\/span>)<\/p>\n

Void CopyTo<\/span><\/span>(<\/span>Int32, Char[], Int32, Int32)<\/p>\n

Boolean EndsWith<\/span><\/span>(<\/span>System.String<\/span>, Boolean, System.Globalization.CultureInfo<\/span>)<\/p>\n

Boolean Equals(<\/span>System.String<\/span>, System.StringComparison<\/span>)<\/p>\n

System.String<\/span> Format(<\/span>System.String<\/span>, System.Object<\/span>, System.Object<\/span>)<\/p>\n

Char get_Chars<\/span><\/span>(<\/span>Int32)<\/p>\n

Int32 get_Length<\/span><\/span>()<\/span><\/p>\n

System.CharEnumerator<\/span> GetEnumerator<\/span><\/span>()<\/span><\/p>\n

Int32 GetHashCode<\/span><\/span>()<\/span><\/p>\n

System.Type<\/span> GetType<\/span><\/span>()<\/span><\/p>\n

System.TypeCode<\/span> GetTypeCode<\/span><\/span>()<\/span><\/p>\n

Int32 IndexOf<\/span><\/span>(<\/span>System.String<\/span>, Int32)<\/p>\n

Int32 IndexOfAny<\/span><\/span>(<\/span>Char[], Int32, Int32)<\/p>\n

System.String<\/span> Insert(<\/span>Int32, System.String<\/span>)<\/p>\n

System.String<\/span> Intern(<\/span>System.String<\/span>)<\/p>\n

System.String<\/span> IsInterned<\/span><\/span>(<\/span>System.String<\/span>)<\/p>\n

Boolean IsNormalized<\/span><\/span>()<\/span><\/p>\n

Boolean IsNullOrEmpty<\/span><\/span>(<\/span>System.String<\/span>)<\/p>\n

System.String<\/span> Join(<\/span>System.String<\/span>, System.String<\/span>[])<\/p>\n

Int32 LastIndexOf<\/span><\/span>(<\/span>Char, Int32)<\/p>\n

Int32 LastIndexOfAny<\/span><\/span>(<\/span>Char[], Int32)<\/p>\n

System.String<\/span> Normalize(<\/span>System.Text.NormalizationForm<\/span>)<\/p>\n

Boolean op_Equality<\/span><\/span>(<\/span>System.String<\/span>, System.String<\/span>)<\/p>\n

Boolean op_Inequality<\/span><\/span>(<\/span>System.String<\/span>, System.String<\/span>)<\/p>\n

System.String<\/span> PadLeft<\/span><\/span>(<\/span>Int32, Char)<\/p>\n

System.String<\/span> PadRight<\/span><\/span>(<\/span>Int32, Char)<\/p>\n

System.String<\/span> Remove(<\/span>Int32)<\/p>\n

System.String<\/span> Replace(<\/span>System.String<\/span>, System.String<\/span>)<\/p>\n

System.String<\/span><\/span>[<\/span>] Split(System.String<\/span>[], System.StringSplitOptions<\/span>)<\/p>\n

Boolean StartsWith<\/span><\/span>(<\/span>System.String<\/span>)<\/p>\n

System.String<\/span> Substring(<\/span>Int32)<\/p>\n

Char[<\/span>] ToCharArray<\/span>(Int32, Int32)<\/p>\n

System.String<\/span> ToLower<\/span><\/span>()<\/span><\/p>\n

System.String<\/span> ToLowerInvariant<\/span><\/span>()<\/span><\/p>\n

System.String<\/span> ToString<\/span><\/span>(<\/span>System.IFormatProvider<\/span>)<\/p>\n

System.String<\/span> ToUpper<\/span><\/span>(<\/span>System.Globalization.CultureInfo<\/span>)<\/p>\n

System.String<\/span> ToUpperInvariant<\/span><\/span>()<\/span><\/p>\n

System.String<\/span> Trim()<\/span><\/p>\n

System.String<\/span> TrimEnd<\/span><\/span>(<\/span>Char[])<\/p>\n

System.String<\/span> TrimStart<\/span><\/span>(<\/span>Char[])<\/p>\n<\/div>\n

As can be seen, 46 different methods are available to the string object all of which are available to the MSH user.  <\/span>Unfortunately, the semantics of these methods is not visible from the shell, but a number of .NET object help is available online. <\/p>\n

Example 8<\/b><\/p>\n

The availability of these methods creates an explosion of possibilities.  <\/span>For example, if I wanted to change the case of a string from lower to upper I would do the following: (first ksh<\/span> and then MSH).<\/p>\n

\n

$ echo “this is a string” | tr<\/span> [:lower<\/span>:] [:upper:]<\/p>\n<\/div>\n

or<\/span><\/p>\n

\n

$ echo “this is a string” | tr<\/span><\/span> ‘[a-z]’ ‘<\/span>[A-Z]’<\/p>\n<\/div>\n

MSH:<\/p>\n

\n

MSH> “this is a string”.ToUpper<\/span><\/span>()<\/span><\/p>\n<\/div>\n

The UNIX example relies on the tr<\/span><\/span><\/span> cmdlet.  <\/span><\/p>\n

Example 9<\/b><\/p>\n

For example, suppose the string “ABC” was to be inserted after the first character in the word “string” to have the result “sABCtring<\/span>“.  <\/span>Here are the following, first with ksh<\/span>, then with MSH:<\/p>\n

\n

$ echo “string” | sed<\/span> “s|\\(<\/span>.\\)\\(.*)|\\1ABC\\2|”<\/p>\n<\/div>\n

MSH:<\/p>\n

\n

MSH> “string”.Insert<\/span><\/span>(<\/span>1,”ABC”)<\/p>\n<\/div>\n

Both examples require specific knowledge; however, using the “insert” method is more intuitive than using the capture buffers available in sed<\/span>.  <\/span>Moreover, the domain specific knowledge of the “sed<\/span>” language required may be somewhat more advanced than is required to use the Insert method.<\/p>\n

\n

<\/p>\n

Jim Truher and Jeffrey Snover<\/p>\n<\/div>\n

[Edit: Monad has now been renamed to Windows PowerShell. This script or discussion may require slight adjustments before it applies directly to newer builds.<\/i>]<\/p>\n

PSMDTAG:FAQ: KSH BASH – how does PowerShell compare to KSH and BASH?
PSMDTAG:DOTNET: Leverage System.String to do KSH\/BASH type functions.<\/p>\n","protected":false},"excerpt":{"rendered":"

  Most shells (such as Windows CMD.EXE and the UNIX shells SH, KSH, CSH, and BASH) operate by executing a command or utility in a new process, and presenting the results (or errors) to the user as text. Text-based processing is the way in which system interaction is done with these shells. Over the years, […]<\/p>\n","protected":false},"author":600,"featured_media":13641,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[14,10,21],"class_list":["post-10791","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-powershell","tag-dotnet","tag-faq","tag-shell"],"acf":[],"blog_post_summary":"

  Most shells (such as Windows CMD.EXE and the UNIX shells SH, KSH, CSH, and BASH) operate by executing a command or utility in a new process, and presenting the results (or errors) to the user as text. Text-based processing is the way in which system interaction is done with these shells. Over the years, […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/posts\/10791","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/users\/600"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/comments?post=10791"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/posts\/10791\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/media\/13641"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/media?parent=10791"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/categories?post=10791"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/powershell\/wp-json\/wp\/v2\/tags?post=10791"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}