c 中调用shell后如何获得shell的返回值

合集下载

对于shell脚本参数获取时的一点小技巧

对于shell脚本参数获取时的⼀点⼩技巧问题如下：
根据脚本参数的个数$#进⾏⼀个循环，在依次输出每个参数$1 $2 $3......
我有⼀个循环变量i
$i 取到这时的i为1，我想使⽤这个1再去调⽤$1,也是就是打印出第⼀个参数
就是$($i)的意思来取到第⼏个参数，当然$($i)是不好⽤的
当时纠结了好久，最后上百度提问，两位⾼⼿给出了答案：
1）
#!/bin/sh
NUMBER=$#
echo $NUMBER
i=1
while [ $i -le $NUMBER ]
do
a[$i]=$1 #将数组a[i]赋值为$1,即取得到第⼀个参数并将值存⼊a[1]
echo ${a[$i]}
((i++)) #数组后移⼀位,变为a[2]
shift #使⽤shift命令将参数后移⼀位,即此时的$1为第⼆个参数
done
数据都存在了数组 a[key] ⾥了
${a[key]} key 是第⼏位例如：a[1] 值为 $1
2）
#!/bin/bash
a=($@) #由$@取到所有参数,并将参数存⼊a
for i in ${a[@]};do #使⽤i在各个参数中循环
echo $i
done。

C#执行PowserShell脚本

C#执⾏PowserShell脚本Windows PowserShell能够很简洁快速通过Script脚本⽅式获得我们想要执⾏效果. 如何在C#中任意执⾏PowerShell脚本.？类似⽬前我要在做⼀个进程管理⼯具. 通过PowerShell脚本⽅式获取当前系统进程调⽤的详细信息. C#如何执⾏Shell Script：步骤如下:<1>前提:安装PowerShell SDK.要在C#执⾏Power Shell 脚本.需要在PowerShell的SDK添加相关引⽤. Windows 7系统⾃动集成Windows PowerShell 2.0版本.<2>新建Console Application项⽬命名:CallPowerShellDemo .添加引⽤:System.Management.Automation 这个命名空间需要引⽤PowerShell SDK中System.Management.Automation.dll. 如果已经PowerShell SDK可以在⽬录:C:\Program Files\Reference Assemblies\Microsoft\WindowsPowerShell\v1.0 下找到:添加相关引⽤:1: //导⼊引⼊2: using System.Management.Automation;3: using System.Management.Automation.Runspaces;4: using System.Management;5: using CallPowerShellDemo.EntityModel;封装参数实体:1: /// <summary>2: /// 定义⼀个封装Shell脚本命令参数实体类3: /// Author：chenkai Date:2010年11⽉9⽇10:27:554: /// </summary>5: public class ShellParameter6: {7: public string ShellKey { get; set; }8: public string ShellValue { get; set; }9: }执⾏脚本⽅法:/// <summary>/// 执⾏PowserShell 脚本核⼼⽅法/// </summary>/// <param name="getshellstrlist">Shell脚本集合</param>/// <param name="getshellparalist">脚本中涉及对应参数</param>/// <returns>执⾏结果返回值</returns>public static string ExecuteShellScript(List<string> getshellstrlist, List<ShellParameter> getshellparalist){string getresutl = null;try{//Create RunspaceRunspace newspace = RunspaceFactory.CreateRunspace();Pipeline newline = newspace.CreatePipeline();//open runspacenewspace.Open();if (getshellstrlist.Count > 0){foreach (string getshellstr in getshellstrlist){//Add Command ShellStringmands.AddScript(getshellstr);}}//Check Parameterif (getshellparalist != null && getshellparalist.Count > 0){int count = 0;foreach (EntityModel.ShellParameter getshellpar in getshellparalist){//Set parameter//注⼊脚本⼀个.NEt对象这样在powershell脚本中就可以直接通过$key访问和操作这个对象//newspace.SessionStateProxy.SetVariable(getshellpar.ShellKey,getshellpar.ShellValue);CommandParameter cmdpara = new CommandParameter(getshellpar.ShellKey, getshellpar.ShellValue);mands[count].Parameters.Add(cmdpara);}}//Exec Restultvar getresult = newline.Invoke();if (getresult != null){StringBuilder getbuilder = new StringBuilder();foreach (var getresstr in getresult){getbuilder.AppendLine(getresstr.ToString());}getresutl = getbuilder.ToString();}//closenewspace.Close();}catch (Exception se){//catch Excetption}return getresutl;}Main⽅法中调⽤:static void Main(string[] args){Console.WriteLine("请输⼊你要执⾏的PowserShell命名:");string gettakeresult = Console.ReadLine();//Main Method Get All ProcessList<string> getshellcmdlist = new List<string>();List<EntityModel.ShellParameter> getpatalist = new List<ShellParameter>{new ShellParameter{ ShellKey="Name",ShellValue="QQ*"}};if (!string.IsNullOrEmpty(gettakeresult)){getshellcmdlist.Add(gettakeresult);}//Execu Cmdstring getresult = Program.ExecuteShellScript(getshellcmdlist, getpatalist);//Output ExecuteResultConsole.WriteLine("执⾏结果:");Console.WriteLine(getresult);Program.OperatorObjectShell();}执⾏结果: 获取以Ca作为开头名称系统进程信息 ShellScript ：get-process Ca*则利⽤PowerShell脚本轻松获取进程名称以Ca开头所有进程名称. 类似我们轻松在获取360在本地系统详细的版本信息: get-process 360* –fileversioninfo对于C#执⾏Shell脚本⽅式. 是通过 ,Runspace主要作⽤是分配⼀块独⽴空间,在空间之上建⽴⼀个独⽴为执⾏Shell命令唯⼀通信通道，Runspace同时也为创建通道环境参数进⾏配置. Runspace主要⽤来构建对象和配置通信环境相关参数. Shell脚本命令通过管道内的运⾏空间主机应⽤程序执⾏，但RunSpace并没有提供对执⾏结果输出. 如果需要输出则需要pipeline.类⽀持<3>Windows PowerShell 与C#之间交互.PowerShell对.NET对象是⽆缝⽀持的, 在Windows PowerShell脚本编程中也提出⾯向对象的概念. 对于Shell脚本中对象和C#语⾔对象是否具有相互可操作性. ？答案是肯定的. 类似我们现在要做⼀个运算, 运算逻辑定义以及执⾏则有Shell脚本. 只需在C#中以对象的⽅式传给Shell 脚本中对象相关的参数.值. ⾃动计算.先定义⼀个计算操作对象:1: /// <summary>2: /// 计算操作的对象3: /// Author:chenkai Date：2010年11⽉9⽇13:54:494: /// </summary>5: public class ConvertPatameter6: {7: public int FirstNum { get; set; }8: public int SecondNum { get; set; }9: public int Sum { get; set; }10: }当我们顶⼀个操作对象. 初始化FirstNum和SecondNum，然后把值传⼊到Shell脚本中执⾏加法运算并把结果赋给Sum参数.Shell Script中定义加法执⾏规则:1: $a=$Result.FirstNum2: $b=$Result.SecondNum3: $Result.Sum=$a+$b4:C#调⽤对象处理Shell脚本执⾏⽅法:1: try2: {3: //zaiShell 执⾏⽅法参数4: List<string> getlist = new List<string>();5: getlist.Add("Set-ExecutionPolicy RemoteSigned");//先执⾏启动安全策略，，使系统可以执⾏powershell脚本⽂件6:7: string pspath = bine(Environment.CurrentDirectory, "PSDoc1.ps1");8: getlist.Add(pspath);9:10: //定义⼀个操作的实体对象11: ConvertPatameter newconvert = new ConvertPatameter12: {13: FirstNum=200,14: SecondNum=80,15: Sum=016: };17:18: if (File.Exists(pspath))19: {20: RunspaceConfiguration runspaceConfiguration = RunspaceConfiguration.Create();21: Runspace newspace = RunspaceFactory.CreateRunspace(runspaceConfiguration);22:23: newspace.Open();24: Pipeline newline = newspace.CreatePipeline();25: RunspaceInvoke scriptInvoker = new RunspaceInvoke(newspace);28: Command getcmd = new Command(pspath);29: mands.Add(getcmd);30:31: //注⼊脚本⼀个.NEt对象这样在powershell脚本中就可以直接通过$key访问和操作这个对象32: //newspace.SessionStateProxy.SetVariable(getshellpar.ShellKey,getshellpar.ShellValue);33: newspace.SessionStateProxy.SetVariable("Result", newconvert);34:35: //执⾏36: var gettakeres=newline.Invoke();38: foreach (var getstr in gettakeres)39: {40: Console.WriteLine(getstr.ToString());41: }42:43: Console.WriteLine("计算结果:" + newconvert.FirstNum.ToString() + "加上"44: + newconvert.SecondNum.ToString() + "等于" + newconvert.Sum.ToString());45: Console.WriteLine("对象的值已经修改:"+newconvert.Sum.ToString());46: }48:49: }50: catch (Exception se)执⾏结果:当把C#中实体对象ConvertPatameter赋给Shell脚本中对象$Result. 注意核⼼注册语句:1: //注⼊脚本⼀个.NEt对象这样在powershell脚本中就可以直接通过$key访问和操作这个对象2: //newspace.SessionStateProxy.SetVariable(getshellpar.ShellKey,getshellpar.ShellValue);3: newspace.SessionStateProxy.SetVariable("Result", newconvert);在脚本注册⼀个.NET对象并赋给Shell对象$Result,则在ShellScript脚本中利⽤加法运算修改原来对象的Sum的属性.并返回给.NET对象中.这是⼀次关于.NEt对象和Shell Script中对象交互⼀次简单操作.本次操作源码下载:。

【例子】C语言获得Shell返回值并进行匹配操作

【例子】C语言获得Shell返回值并进行匹配操作在linux下使用ifconfigl命令能很方便的查看网卡与网线是否连通，运行ifconfig eth0命令大致输出如下：# ifconfig eth0eth0 Link encap:Ethernet HWaddr 00:25:35:68:CC:D6inetaddr:192.168.1.168 Bcast:192.168.1.255 Mask:255.255.255.0 inet6 addr: fe80::215:c5ff:fe18:ccd6/64 Scope:LinkUP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 RX packets:130722 errors:0 dropped:0 overruns:0 frame:0TX packets:112560 errors:0 dropped:0 overruns:0 carrier:0collisions:0 txqueuelen:1000RX bytes:104371099 (99.5 MiB) TX bytes:20518584 (19.5 MiB) Interrupt:16其中的RUNNING就表示网卡与网线正常链接，拔掉网线再运行此命令就会发现RUNNING不在了。

目的是用C语言来实现程序，而linux系统提供了popen/pclose进程管道让C和shell很方便的交互，不过使用的时候要注意设置权限，以免造成安全隐患。

废话不多说，看下面C代码结合shell命令检测网卡与网线连通状况：netstat.c#include#include#include#include/************************************************************** ********* 函数名称： GetNetStat* 功能描述：检测网络链接是否断开* 输入参数：* 输出参数：无* 返回值：正常链接1,断开返回-1* 其它说明：本程序需要超级用户权限才能成功调用ifconfig命令* 修改日期版本号修改人修改内容* ---------------------------------------------------------------------* 2010/04/02 V1.0 eden_mgqw*************************************************************** ********/int GetNetStat( ){char buffer[BUFSIZ];FILE *read_fp;int chars_read;int ret;memset( buffer, 0, BUFSIZ );read_fp = popen("ifconfig eth0 | grep RUNNING", "r");if ( read_fp != NULL ){chars_read = fread(buffer, sizeof(char), BUFSIZ-1, read_fp);if (chars_read > 0){ret = 1;}else{ret = -1;}pclose(read_fp);}else{ret = -1;}return ret;}int main(){int i=0;i = GetNetStat();printf( "nNetStat = %dn", i );return 0;}下面是编译运行程序的输出结果（正常返回1，断开返回-1）：# cc netstat.c# ./a.outNetStat = 1。

pipeline中获取shell命令的返回值

pipeline中获取shell命令的返回值pipeline是一种用于连接多个命令的方式，它将一个命令的输出直接作为另一个命令的输入。

在shell环境中，我们经常使用pipeline来实现复杂的任务，其中获取shell命令的返回值是一个常见的需求。

在本文中，我们将一步一步回答如何在pipeline中获取shell命令的返回值，并探讨其应用场景和实例。

什么是pipeline？Pipeline是一种将多个命令连接在一起执行的方式。

通过使用管道符号" "将一个命令的输出传递给另一个命令作为输入，可以实现命令的组合和串联。

这种方式允许我们将简单的命令组合成复杂的任务，提高了命令行中的操作效率和灵活性。

在Linux和Unix系统中，命令行界面是最常用的操作方式之一。

通过合理使用pipeline，我们可以将多个命令组合在一起，实现更复杂的任务。

pipeline中如何获取shell命令的返回值？在pipeline中获取shell命令的返回值是一个常见的需求。

返回值通常是用来判断命令是否执行成功或者获取命令输出的结果。

下面我们将介绍两种在pipeline中获取shell命令返回值的方法。

# 方法一：使用管道后的命令执行返回值在使用pipeline时，我们可以通过使用"set -o pipefail"命令来获取前一个命令的返回值。

具体步骤如下：1. 添加"set -o pipefail"命令到pipeline的开始。

这个命令会让整个pipeline的返回值等于最后一个执行失败的命令的返回值。

2. 使用管道符号将多个命令链接在一起。

3. 在pipeline结束后，使用"?"获取整个pipeline的返回值。

下面是一个示例，使用这种方法获取前一个命令的返回值：set -o pipefailcommand1 command2 command3pipeline_status=?在这个示例中，pipeline_status将包含整个pipeline的返回值。

cshell语法

cshell语法Cshell是一种Unix Shell程序，主要用于在命令行界面下与操作系统进行交互。

Cshell语法是Cshell编程中必须掌握的一部分，它允许用户编写脚本来自动化一系列操作。

Cshell语法的基本结构与C语言类似，包含命令、参数和控制结构等。

以下是一些常用的Cshell语法：1. 命令和参数：Cshell中，命令和参数是以空格分隔的。

命令用来执行特定的任务，而参数用来给命令传递额外的信息。

例如，在Cshell中执行"ls -l"命令可以列出当前目录下的文件和文件夹，并显示详细信息。

2. 注释：在Cshell中，使用"#"符号来注释一行代码。

注释通常用来解释脚本的功能或提醒自己后续需要添加的代码。

例如，可以在脚本中添加注释，说明某一行代码的作用。

3. 变量：可以在Cshell中使用变量来存储值和临时数据。

变量名不需要预先声明，直接使用即可。

变量赋值使用"="符号，例如"var=100"。

使用变量时需要使用"$"前缀，例如"echo $var"将会输出"100"。

4. 控制结构：Cshell中提供了多种控制结构，用于根据条件执行不同的代码块。

常见的控制结构包括if语句、for循环和while循环。

if语句用于条件判断，for循环用于重复执行一段代码块，while循环用于在满足条件时执行一段代码块。

5. 输入和输出重定向：Cshell提供了输入和输出重定向的功能，允许用户将命令的输入和输出重定向到文件或其他设备。

输出重定向使用">"符号，例如"ls > output.txt"将目录列表输出到名为output.txt的文件中。

输入重定向使用"<"符号，例如"wc -l < input.txt"将会统计input.txt文件中的行数。

C下执行命令行的方法

一、system()--执行shell命令1、包含头文件：#include <stdlib.h>2、定义int system(const char * string);3、参数String：合法的可执行DOS(SHELL)命令4、返回值1）如果system()在调用/bin/sh 时失败则返回127, 其他失败原因返回-1。

2）若参数string 为空指针(NULL), 则返回非零值。

3）如果system()调用成功则最后会返回执行shell 命令后的返回值, 但是此返回值也有可能为system()调用/bin/sh 失败所返回的127, 因此最好能再检查errno 来确认执行成功。

5、说明system()会调用fork()产生子进程, 由子进程来调用/bin/sh-c string 来执行参数string 字符串所代表的命令, 此命令执行完后随即返回原调用的进程. 在调用system()期间SIGCHLD 信号会被暂时搁置,SIGINT 和SIGQUIT 信号则会被忽略。

6、用例system(“ipconfig/all”);7、重定向标准输出流FILE *stream;stream = freopen(“data.txt”,”wb”,stdout);运行结果可以重定向到data.txt8、隐藏控制台窗口#pragma comment( linker, “/subsystem:\”windows\”/entry:\”mainCRTStartup\”” )仍有调用的DOS窗口一闪，且重定向失效。

二、WinExec()—运行可执行程序1、包含头文件#include<windows.h>2、定义UINT Win Exec(LPCSTR lpCmdLine, UINT uCmdShow);3、参数lpCmdLine：指向一个空结束的字符串，串中包含将要执行的应用程序的命令行（文件名加上可选参数）。

shell 获取命令的返回值

shell 获取命令的返回值以Shell获取命令的返回值为标题，本文将从不同角度探讨Shell脚本中如何获取命令的返回值，并介绍一些常用的技巧和方法。

一、使用变量保存返回值在Shell脚本中，可以使用变量来保存命令的返回值。

通过将命令放在反引号或$()中，可以将命令的输出赋值给一个变量。

例如：```result=`ls -l````或者```result=$(ls -l)```这样，变量result就保存了ls -l命令的输出结果。

二、判断命令执行结果在Shell脚本中，经常需要判断命令是否执行成功。

可以根据命令的返回值来判断命令是否执行成功。

一般情况下，命令执行成功时返回值为0，失败时返回值为非0。

可以使用$?来获取上一条命令的返回值。

例如：```ls -lif [ $? -eq 0 ]; thenecho "命令执行成功"elseecho "命令执行失败"fi```三、根据命令返回值进行不同操作有时候，根据命令的返回值需要进行不同的操作。

可以使用if语句来实现不同的逻辑分支。

例如：```result=$(ls -l)if [ $? -eq 0 ]; thenecho "命令执行成功"echo "$result"elseecho "命令执行失败"```在上面的例子中，如果ls -l命令执行成功，就会输出命令执行成功的提示，并打印出ls -l命令的输出结果；如果命令执行失败，就会输出命令执行失败的提示。

四、将命令返回值作为函数的返回值在Shell脚本中，可以将命令的返回值作为函数的返回值。

例如：```function get_return_value() {result=$(ls -l)return $?}get_return_valueif [ $? -eq 0 ]; thenecho "命令执行成功"echo "$result"elseecho "命令执行失败"fi在上面的例子中，get_return_value函数执行ls -l命令，并将返回值作为函数的返回值。

C#Process执行批处理后如何获取返回值？

C#Process执⾏批处理后如何获取返回值？代码如下p.StartInfo = new System.Diagnostics.ProcessStartInfo(path, pwd);p.Start();其中path是个BAT的路径！我想要得到执⾏后的返回值来判断批处理运⾏期间是否错误？请问如何做呢？批处理程序内容如下:@echo offfor /f "delims=" %%a in (PCList.config) do net use \\%%a\ipc$ /deletefor /f "delims=" %%a in (PCList.config) do net use \\%%a\ipc$ %1 /user:administratorpause// Define the namespaces used by this sample.using System;using System.Text;using System.Globalization;using System.IO;using System.Diagnostics;using System.Threading;using ponentModel;namespace ProcessAsyncStreamSamples{class ProcessNetStreamRedirection{// Define static variables shared by class methods.private static StreamWriter streamError =null;private static String netErrorFile = "";private static StringBuilder netOutput = null;private static bool errorRedirect = false;private static bool errorsWritten = false;public static void RedirectNetCommandStreams(){String netArguments;Process netProcess;// Get the input computer name.Console.WriteLine("Enter the computer name for the net view command:");netArguments = Console.ReadLine().ToUpper(CultureInfo.InvariantCulture);if (String.IsNullOrEmpty(netArguments)){// Default to the help command if there is not an input argument.netArguments = "/?";}// Check if errors should be redirected to a file.errorsWritten = false;Console.WriteLine("Enter a fully qualified path to an error log file");Console.WriteLine(" or just press Enter to write errors to console:");netErrorFile = Console.ReadLine().ToUpper(CultureInfo.InvariantCulture);if (!String.IsNullOrEmpty(netErrorFile)){errorRedirect = true;}// Note that at this point, netArguments and netErrorFile// are set with user input. If the user did not specify// an error file, then errorRedirect is set to false.// Initialize the process and its StartInfo properties.netProcess = new Process();netProcess.StartInfo.FileName = "Net.exe";// Build the net command argument list.netProcess.StartInfo.Arguments = String.Format("view {0}",netArguments);// Set UseShellExecute to false for redirection.eShellExecute = false;// Redirect the standard output of the net command.// This stream is read asynchronously using an event handler.netProcess.StartInfo.RedirectStandardOutput = true;netProcess.OutputDataReceived += new DataReceivedEventHandler(NetOutputDataHandler);netOutput = new StringBuilder();if (errorRedirect){// Redirect the error output of the net command.netProcess.StartInfo.RedirectStandardError = true;netProcess.ErrorDataReceived += new DataReceivedEventHandler(NetErrorDataHandler);}else{// Do not redirect the error output.netProcess.StartInfo.RedirectStandardError = false;}Console.WriteLine("\nStarting process: net {0}",netProcess.StartInfo.Arguments);if (errorRedirect){Console.WriteLine("Errors will be written to the file {0}",netErrorFile);}// Start the process.netProcess.Start();// Start the asynchronous read of the standard output stream.netProcess.BeginOutputReadLine();if (errorRedirect){// Start the asynchronous read of the standard// error stream.netProcess.BeginErrorReadLine();}// Let the net command run, collecting the output.netProcess.WaitForExit();if (streamError != null){// Close the error file.streamError.Close();}else{// Set errorsWritten to false if the stream is not// open. Either there are no errors, or the error// file could not be opened.errorsWritten = false;}if (netOutput.Length > 0){// If the process wrote more than just// white space, write the output to the console.Console.WriteLine("\nPublic network shares from net view:\n{0}\n",netOutput);}if (errorsWritten){// Signal that the error file had something// written to it.String [] errorOutput = File.ReadAllLines(netErrorFile);if (errorOutput.Length > 0){Console.WriteLine("\nThe following error output was appended to {0}.", netErrorFile);foreach (String errLine in errorOutput){Console.WriteLine(" {0}", errLine);}}Console.WriteLine();}netProcess.Close();}private static void NetOutputDataHandler(object sendingProcess,DataReceivedEventArgs outLine){// Collect the net view command output.if (!String.IsNullOrEmpty(outLine.Data)){// Add the text to the collected output.netOutput.Append(Environment.NewLine + " " + outLine.Data);}}private static void NetErrorDataHandler(object sendingProcess,DataReceivedEventArgs errLine){// Write the error text to the file if there is something// to write and an error file has been specified.if (!String.IsNullOrEmpty(errLine.Data)){if (!errorsWritten){if (streamError == null){// Open the file.try{streamError = new StreamWriter(netErrorFile, true);}catch (Exception e){Console.WriteLine("Could not open error file!");Console.WriteLine(e.Message.ToString());}}if (streamError != null){// Write a header to the file if this is the first// call to the error output handler.streamError.WriteLine();streamError.WriteLine(DateTime.Now.ToString());streamError.WriteLine("Net View error output:");}errorsWritten = true;}if (streamError != null){// Write redirected errors to the file.streamError.WriteLine(errLine.Data);streamError.Flush();}}}}}string arg = string.Format(backupFmt, server, user, pwd, database, file);Process p = new Process();p.StartInfo.FileName = "cmd.exe";eShellExecute = false;p.StartInfo.WorkingDirectory = location + @"bin";p.StartInfo.Arguments = arg;p.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;p.StartInfo.CreateNoWindow = true;p.StartInfo.RedirectStandardInput = true;p.StartInfo.RedirectStandardOutput = true; p.Start();StreamWriter sw = p.StandardInput;sw.WriteLine(arg);sw.WriteLine(Environment.NewLine);sw.Close();#if DEBUGStreamReader sr = p.StandardOutput;string str = sr.ReadToEnd();if(!string.IsNullOrEmpty(str)){Console.WriteLine("restore file:" + file);Console.WriteLine("message:" + str);}sr.Close();#endifp.WaitForExit();p.Close();在C#中运⾏⼀个命令，并截取输出、输出流的问题，这个问题我以前在Java中实现过，由于在C#中没有遇到过类似的情况，为了避免每次别⼈问都要⼀遍⼀遍演⽰的情况，特地做了⼀个简单的例⼦，实现在WinForm中ping⼀个⽹站，并且将ping的结果显⽰在⼀个⽂本框中。

shell脚本中获取命令的输出

shell脚本中获取命令的输出这个主要介绍的方法是获取命令的输出内容，而不是命令执行成功与否的返回值。

通常情况下，在shell脚本中需要获取命令的输出内容，然后根据输出内容判断下一步的执行操作。

比较常用的一种方式就是，匹配命令输出的内容中是否存在某些关键字，选择执行的不同动作。

比较常用的一种方式就是采用反向单引号的方式 -- 保存结果的变量名=`需要执行的Linux命令`这种方式在使用时，有些细节的地方需要注意。

先用几个例子来说明一下。

比如在CentOS7环境中，使用rpm -qa命令查询某些rpm包是否安装，没有安装的话进行安装操作。

举个简单的例子来说：#!/bin/bashcheck_results=`rpm -qa | grep "zlib"`echo "command(rpm -qa) results are: $check_results"if [[ $check_results =~ "zlib" ]]thenecho "package zlib has already installed. "elseecho "This is going to install package zlib"fi保存为test.sh文件，然后运行$bash test.sh结果为：command(rpm -qa) results are: zlib-1.2.7-13.el7.x86_64package zlib has already installed.这个脚本基本上是可以工作的。

那么，我们同样使用类似的方式来检查iscsi-initiator软件包是否安装。

与上一个命令不同的是，这个命令是否安装不能通过rpm -qa 命令获取。

我们采取另一种方式#!/bin/bashcheck_results=`iscsiadm --version | grep iscsiadm`echo "check command(iscsiadm) available results are: $check_results"if [[ $check_results =~ "iscsiadm" ]]thenecho "command iscsiadm could be used already."elseecho "command iscsiadm can't be used. Install it"rpm -ivh iscsi-initiator-utils-6.2.0.873-29.el7.x86_64.rpmfi执行的结果为：$ bash test.shcheck command(iscsiadm) available results are: iscsiadm version 6.2.0.873-28command iscsiadm could be used already.这时候看起来脚本是工作正常的，显示iscsiadm已经可用。

shell function 用法

shell function 用法1. 什么是 shell functionShell function 是指一段可重复使用的代码片段，用于实现特定的功能。

类似于其他编程语言中的函数，它可以接收参数，执行特定的操作，并返回结果。

2. shell function 的定义和调用2.1 定义 shell function在 Shell 脚本中，可以使用关键字function或直接使用函数名来定义一个函数。

函数定义的一般语法如下：function_name() {# 函数体}为了提高代码的可读性和可维护性，建议在函数体的开头加上一些注释来描述函数的功能和输入输出等信息。

2.2 调用 shell function定义了函数之后，可以在 Shell 脚本的任意位置使用函数名来调用函数。

调用函数的一般语法如下：function_name 参数1 参数2 ...调用函数时，可以传递多个参数，函数内部可以通过变量名${n}来获取对应位置的参数值。

3. shell function 的返回值Shell function 的返回值分为两种：状态码和输出结果。

3.1 状态码状态码是一个整数值，用于表示函数执行的状态。

通常情况下，状态码为 0 表示函数执行成功，非零值表示函数执行失败或出现错误。

函数内部可以通过return命令来设置状态码，例如：return 0 # 执行成功return 1 # 执行失败3.2 输出结果除了状态码之外，函数还可以通过直接输出或通过变量返回一个或多个结果。

下面是几种常见的输出方式：3.2.1 直接输出函数可以直接使用echo或printf等命令来输出结果，例如：function_name() {echo "Hello, world!"}3.2.2 使用变量返回结果函数可以通过变量来返回结果。

在函数内部，可以使用return命令将结果保存到一个变量中，并在函数调用处使用，例如：function_name() {local result="Hello, world!"return "${result}"}output=$(function_name)echo "${output}" # 输出 "Hello, world!"4. shell function 的参数传递4.1 位置参数在调用函数时，可以传递多个参数给函数。

ShellExecute函数用法

4.使用方法：
例如：
ShellExecute(NULL,"open","iloveu.bmp",NULL,NULL,SW_SHOWNORMAL);
用缺省的位图编辑器打开一个叫iloveu.bmp的位图文件，这个缺省的位图编辑器可能是 Microsoft Paint, Adobe Photoshop, 或者 Corel PhotoPaint。
ShExecInfo.lpVerb = "properties";
ShExecInfo.lpFile = "c:\"; //也可以是文件
ShExecInfo.lpParameters = "";
ShExecInfo.lpDirectory = NULL;
ShExecInfo.nShow = SW_SHOW;
总之，ShellExecute函数就是如此简单地打开磁盘文件和Internet文件。如果将第二个参数“OPEN”改为“PRINT”或者“EXPLORE”，ShellExecute将能打印文件和打开文件夹。ShellExecute还有一个扩展函数ShellExecuteEx，所带参数中有一个特殊的结构，功能更强，或者任何你使用的别的浏览器打开文件。
Q: 如何打开一个网页？
ShellExecute(this->m_hWnd,"open","";,"","", SW_SHOW );
Q: 如何激活相关程序，发送EMAIL？
ShellExecute(this->m_hWnd,"open",
或

shell管道和tee使用时获取前面命令返回值

shell管道和tee使⽤时获取前⾯命令返回值BASH SHELL中，通常使⽤ $? 来获取上⼀条命令的返回码。

对于管道中的命令，使⽤$?只能获取管道中最后⼀条命令的返回码，例如下⾯的例⼦中/not/a/valid/filename是⼀个不存在的⽂件cat /not/a/valid/filename | cat第⼀个cat失败，第⼆个cat成功，所以$?的值为0这种情况下，可以使⽤ $PIPESTATUS来获取管道中每个命令的返回码。

注意：1、PIPESTATUS 是⼀个数组，第⼀条命令的返回码存储在${PIPESTATUS[0]}，以此类推，上例中执⾏完管道中所有的命令后，PIPESTATUS数组第⼀个元素值为1，第⼆个元素值为02、如果前⼀条命令不是⼀个管道，⽽是⼀个单独的命令，命令的返回码存储为${PIPESTATUS[0]}，此时${PIPESTATUS[0]}同$?值相同（事实上，PIPESTATUS最后⼀个元素的值总是与$?的值相同）3、每执⾏⼀条命令，切记PIPESTATUS都会更新其值为上⼀条命令的返回码，cat /not/a/valid/filename|catif [ ${PIPESTATUS[0]} -ne 0 ]; then echo ${PIPESTATUS[@]}; fi上例中执⾏完管道后，`${PIPESTATUS[0]}`值为1，`${PIPESTATUS[1]}`值为0但是上⾯的脚本执⾏完成后，输出为0，这是因为if 分⽀的测试命令[root@test output]# cat a.sh#!/bin/sha=3if [ $a -gt 4 ]thenecho "1111111"exit 1fiecho "222222"exit 0[root@test output]# cat b.sh#!/bin/shsh a.sh | tee >>a.logaa=${PIPESTATUS[0]}if [ $aa -ne 0 ]thenecho "aaaaaaaaaaaaaaaa"fi。

shell 函数参数

shell 函数参数Shell是一种命令行解释器，它是在 Linux 和 Unix 系统中广泛使用的。

Shell 脚本是一种用 Shell 编写的脚本，它可以用来自动化一些任务，比如管理文件、运行程序、配置系统等等。

Shell 函数是 Shell 脚本中的一种概念，它可以让我们封装一些常用的操作，以便在脚本中多次使用。

Shell 函数的语法Shell 函数的语法非常简单，它由三部分组成：函数名、参数列表和函数体。

下面是一个最简单的 Shell 函数示例：```#!/bin/bashhello() {echo 'Hello, world!'}hello```这个函数的名字是 `hello`，它没有任何参数，函数体只有一条语句，就是输出一句话。

我们可以在脚本中调用这个函数，只需要写上函数名即可。

函数的参数列表是用括号括起来的，括号内可以包含多个参数，参数之间用空格分隔。

下面是一个带参数的函数示例：```#!/bin/bashgreet() {echo 'Hello, $1!'}greet 'Alice'greet 'Bob'```这个函数的名字是 `greet`，它有一个参数 `$1`，函数体只有一条语句，就是输出一句话。

我们可以在脚本中调用这个函数，传递一个参数给它。

在函数体中，我们可以通过 `$1` 来获取传递给函数的第一个参数。

Shell 函数的参数传递在调用函数时，我们可以传递参数给它。

这些参数会被存储在函数的参数列表中，我们可以在函数体中使用它们。

在函数体中，我们可以通过 `$1`、`$2`、`$3`……来获取传递给函数的参数，它们分别表示第一个参数、第二个参数、第三个参数……以此类推。

下面是一个带多个参数的函数示例：```#!/bin/bashgreet() {echo 'Hello, $1 and $2!'}greet 'Alice' 'Bob'```这个函数的名字是 `greet`，它有两个参数 `$1` 和 `$2`，函数体只有一条语句，就是输出一句话。

shell find 返回值作为判断条件

shell find 返回值作为判断条件如何在shell中使用"find"命令的返回值作为判断条件在shell编程中，我们经常需要根据文件的属性或者某些条件来执行不同的操作。

"find"命令是一个非常强大的工具，它可以搜索文件系统中满足一定条件的文件，并将结果返回给我们。

本文将详细介绍如何使用"find"命令的返回值作为判断条件来实现不同的操作。

一、"find"命令的基本用法"find"命令的基本语法为：find [path...] [expression]其中，path表示要搜索的路径，可以是一个目录或者一个文件。

expression 用于指定搜索的条件。

例如，我们要在当前目录下搜索所有以".txt"结尾的文件，可以使用以下命令：find . -name "*.txt"上述命令会在当前目录及其子目录中搜索所有以".txt"结尾的文件，并将结果打印到屏幕上。

二、使用"find"命令的返回值要在shell脚本中使用"find"命令的返回值，我们需要将其保存到一个变量中。

使用"()"或者"``"将命令括起来可以将命令的输出赋给一个变量。

例如，我们可以将上述的"find"命令的输出保存到一个变量files中，如下所示：files=(find . -name "*.txt")三、判断返回值是否为空一般情况下，我们会在shell脚本中使用"find"命令的返回值来判断是否找到了满足条件的文件。

判断返回值是否为空可以使用"-z"选项。

以下是一个示例代码：files=(find . -name "*.txt")if [ -z "files" ]; thenecho "No files found."elseecho "Files found."fi在上述代码中，我们先将"find"命令的输出保存到变量files中。

Shell$？获取函数返回值或者上一个命令的退出状态

Shell$？获取函数返回值或者上⼀个命令的退出状态$? 是⼀个特殊变量，⽤来获取上⼀个命令的退出状态，或者上⼀个函数的返回值。

所谓退出状态，就是上⼀个命令执⾏后的返回结果。

退出状态是⼀个数字，⼀般情况下，⼤部分命令执⾏成功会返回 0，失败返回 1，这和C语⾔的 main() 函数是类似的。

不过，也有⼀些命令返回其他值，表⽰不同类型的错误。

1) $? 获取上⼀个命令的退出状态编写下⾯的代码，并保存为 test.sh：#!/bin/bashif [ "$1" == 100 ]thenexit 0 #参数正确，退出状态为0elseexit 1 #参数错误，退出状态1fiexit表⽰退出当前 Shell 进程，我们必须在新进程中运⾏ test.sh，否则当前 Shell 会话（终端窗⼝）会被关闭，我们就⽆法取得它的退出状态了。

例如，运⾏ test.sh 时传递参数 100：[mozhiyan@localhost ~]$ cd demo[mozhiyan@localhost demo]$ bash ./test.sh 100 #作为⼀个新进程运⾏[mozhiyan@localhost demo]$ echo $?再如，运⾏ test.sh 时传递参数 89：[mozhiyan@localhost demo]$ bash ./test.sh 89 #作为⼀个新进程运⾏[mozhiyan@localhost demo]$ echo $?12) $? 获取函数的返回值编写下⾯的代码，并保存为 test.sh：#!/bin/bash#得到两个数相加的和function add(){return `expr $1 + $2`}add 23 50 #调⽤函数echo $? #获取函数返回值运⾏结果：73有 C++、C#、Java 等编程经验的读者请注意：严格来说，Shell 函数中的 return 关键字⽤来表⽰函数的退出状态，⽽不是函数的返回值；Shell 不像其它编程语⾔，没有专门处理返回值的关键字。

cshell 参数传递

cshell 参数传递cshell是一种Unix shell，广泛用于Unix和Linux系统中。

参数传递是在cshell 中非常常见且强大的功能之一。

在这篇文章中，我们将详细介绍cshell参数传递的概念、语法、用法，以及一些实际的例子。

什么是参数传递？参数传递是指在执行一个命令或脚本时，向它传递额外的参数。

这些参数可以用于定制化命令的行为或者传递信息给脚本。

通过参数传递的方式，我们可以使命令或脚本更加灵活和可配置。

在cshell中，参数传递以一种特殊的语法来实现，使用`argv`来表示所有的参数，`argc`来表示参数的个数。

其中，`argv[0]`表示命令或脚本本身。

cshell参数传递的语法在cshell中，我们可以使用以下语法来传递参数：command arg1 arg2 arg3 ...其中，`command`是要执行的命令或脚本，`arg1`、`arg2`、`arg3`等是要传递的参数。

cshell参数传递的用法接下来，我们将介绍cshell参数传递的常见用法。

# 传递参数给命令首先，我们可以将参数传递给一个命令。

让我们以一个示例来说明：ls -l argv以上命令将会执行`ls`命令，并且将`argv`传递给它。

在这个例子中，`argv`表示我们在命令行中输入的参数。

例如，如果我们执行`ls -l file1 file2`，那么`argv`的值将会是`file1 file2`。

这样，`ls`命令将会显示`file1`和`file2`的详细信息。

# 传递参数给脚本同样地，我们也可以将参数传递给一个脚本。

例如，考虑以下脚本`myscript.csh`的示例：cshell#!/bin/cshecho "This is a script"echo "Arguments: argv"在这个脚本中，我们使用了`argv`来打印出所有传递给脚本的参数。

通过执行`myscript.csh arg1 arg2 arg3`，我们将得到类似以下的输出：This is a scriptArguments: arg1 arg2 arg3# 取得参数个数通过使用`argc`，我们可以获取传递给命令或脚本的参数个数。

LinuxCC++调用shell命令后获取shell返回值

LinuxCC++调⽤shell命令后获取shell返回值Linux C/C++调⽤shell命令后获取shell返回值项⽬中C/C++调⽤shell命令后，某系处理返回值的过程是以“临时⽂件”的⽅式进⾏；即shell命令执⾏后将返回值存放在临时⽂件（如temp.txt），C/C++程序再访问⽂件，获取shell的返回值。

最经典的就是调⽤WiFi（iwlist wlan0 scan ）扫描指令查询WiFi节点，然后解析获取WiFi数量、名称、信号强度、加密⽅式等信息。

通过“临时⽂件”的⽅式交互数据，是⽐较简单、易⽤和易理解的⽅式，在多进程间、多线程间也可以使⽤，但⼀般不会使⽤。

共享“临时⽂件”有个弊端就是效率上不⽐较低，创建⽂件、删除⽂件然后是访问，都是访问存储器（磁盘、flash），加上⽂件系统的⼀层封装和存储介质映射，访问速度不如访问内存快。

“临时⽂件”的⽅式，个⼈觉得不是很好，通过该案例总结下C/C++调⽤shell命令知识。

1.C/C++调⽤shell命令⽅式Linux 系统中使⽤ C/C++ 调⽤ shell 命令常⽤⽅式：system()函数popen()函数exec函数簇system()函数最常⽤，简单⾼效； popen() 执⾏ shell 命令的开销⽐ system() ⼩；system()和popen()都封装了进程创建、释放，内部实质调⽤的是exec函数簇；exec需⼿动fork进程进，然后再调⽤exec函数簇个，过程⽐前两者稍微复杂。

1.1 system()C语⾔执⾏linux shell命令，对于没有返回结果的，可直接使⽤system()函数，对于有返回结果的，可以⽤popen命令，对其封装后，可以获取相应的返回信息。

函数原型：FILE * popen ( const char * command , const char * type );int pclose ( FILE * stream );command：要执⾏shell命令type：创建的管道的读写类型（"r" 或者 "w"）1.type为“r”时，管道连接到shell⼦进程的标准输出，2.type为“w”时，管道连接到shell⼦进程的标准输⼊“r”就能获取shell命令的执⾏输出结果了。

shell获取c程序返回结果的方法

shell获取c程序返回结果的方法
在Shell脚本中，你可以使用以下方法来获取C程序的返回结果：
1. 运行C程序并捕获输出：你可以在Shell脚本中使用命令替换来运行C
程序，并将输出重定向到一个临时文件中。

然后，你可以读取该临时文件的内容，并将其作为C程序的返回结果。

例如：
```shell
result=$(gcc -o myprogram && ./myprogram)
echo $result
```
上述代码将编译并运行名为``的C程序，并将输出结果存储在`result`变量中。

你可以根据需要修改`gcc`命令和程序名称。

2. 使用特殊变量`$?`：在Shell脚本中，`$?`变量用于获取上一个命令的返
回状态码。

如果C程序成功执行，返回状态码为0，否则为非0值。

你可以将`$?`的值赋给一个变量，并根据该变量的值判断C程序的执行结果。

例如：
```shell
gcc -o myprogram && ./myprogram
if [ $? -eq 0 ]; then
echo "C程序执行成功"
else
echo "C程序执行失败"
fi
```
上述代码将编译并运行名为``的C程序，并根据返回状态码判断程序的执行结果。

如果返回状态码为0，表示程序执行成功，否则表示程序执行失败。

请注意，这些方法适用于简单的C程序，并且假设你已经在系统中安装了GCC编译器。

对于更复杂的C程序或需要更详细错误处理的场景，你可能需要使用其他方法来获取C程序的返回结果。