<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="API documentation for the Rust `Command` struct in crate `std`."><meta name="keywords" content="rust, rustlang, rust-lang, Command"><title>std::process::Command - Rust</title><link rel="stylesheet" type="text/css" href="../../normalize.css"><link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../../dark.css"><link rel="stylesheet" type="text/css" href="../../light.css" id="themeStyle"><script src="../../storage.js"></script><link rel="shortcut icon" href="https://doc.rust-lang.org/favicon.ico"></head><body class="rustdoc struct"><!--[if lte IE 8]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="sidebar-menu">☰</div><a href='../../std/index.html'><img src='https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png' alt='logo' width='100'></a><p class='location'>Struct Command</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.new">new</a><a href="#method.arg">arg</a><a href="#method.args">args</a><a href="#method.env">env</a><a href="#method.envs">envs</a><a href="#method.env_remove">env_remove</a><a href="#method.env_clear">env_clear</a><a href="#method.current_dir">current_dir</a><a href="#method.stdin">stdin</a><a href="#method.stdout">stdout</a><a href="#method.stderr">stderr</a><a href="#method.spawn">spawn</a><a href="#method.output">output</a><a href="#method.status">status</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Debug">Debug</a><a href="#impl-CommandExt">CommandExt</a></div><a class="sidebar-title" href="#synthetic-implementations">Auto Trait Implementations</a><div class="sidebar-links"><a href="#impl-Send">Send</a><a href="#impl-Sync">!Sync</a></div></div><p class='location'><a href='../index.html'>std</a>::<wbr><a href='index.html'>process</a></p><script>window.sidebarCurrent = {name: 'Command', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div></nav><div class="theme-picker"><button id="theme-picker" aria-label="Pick another theme!"><img src="../../brush.svg" width="18" alt="Pick another theme!"></button><div id="theme-choices"></div></div><script src="../../theme.js"></script><nav class="sub"><form class="search-form js-only"><div class="search-container"><input class="search-input" name="search" autocomplete="off" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"><a id="settings-menu" href="../../settings.html"><img src="../../wheel.svg" width="18" alt="Change settings"></a></div></form></nav><section id="main" class="content"><h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>std</a>::<wbr><a href='index.html'>process</a>::<wbr><a class="struct" href=''>Command</a></span><span class='out-of-band'><span class='since' title='Stable since Rust version 1.0.0'>1.0.0</span><span id='render-detail'><a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">[<span class='inner'>−</span>]</a></span><a class='srclink' href='../../src/std/process.rs.html#385-387' title='goto source code'>[src]</a></span></h1><div class="docblock type-decl"><pre class='rust struct'>pub struct Command { /* fields omitted */ }</pre></div><div class='docblock'><p>A process builder, providing fine-grained control
over how a new process should be spawned.</p>
<p>A default configuration can be
generated using <code>Command::new(program)</code>, where <code>program</code> gives a path to the
program to be executed. Additional builder methods allow the configuration
to be changed (for example, by adding arguments) prior to spawning:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::<span class="ident">Command</span>;
<span class="kw">let</span> <span class="ident">output</span> <span class="op">=</span> <span class="kw">if</span> <span class="macro">cfg</span><span class="macro">!</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"windows"</span>) {
<span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"cmd"</span>)
.<span class="ident">args</span>(<span class="kw-2">&</span>[<span class="string">"/C"</span>, <span class="string">"echo hello"</span>])
.<span class="ident">output</span>()
.<span class="ident">expect</span>(<span class="string">"failed to execute process"</span>)
} <span class="kw">else</span> {
<span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"sh"</span>)
.<span class="ident">arg</span>(<span class="string">"-c"</span>)
.<span class="ident">arg</span>(<span class="string">"echo hello"</span>)
.<span class="ident">output</span>()
.<span class="ident">expect</span>(<span class="string">"failed to execute process"</span>)
};
<span class="kw">let</span> <span class="ident">hello</span> <span class="op">=</span> <span class="ident">output</span>.<span class="ident">stdout</span>;<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aprocess%3A%3ACommand%3B%0A%0Alet%20output%20%3D%20if%20cfg!(target_os%20%3D%20%22windows%22)%20%7B%0A%20%20%20%20Command%3A%3Anew(%22cmd%22)%0A%20%20%20%20%20%20%20%20%20%20%20%20.args(%26%5B%22%2FC%22%2C%20%22echo%20hello%22%5D)%0A%20%20%20%20%20%20%20%20%20%20%20%20.output()%0A%20%20%20%20%20%20%20%20%20%20%20%20.expect(%22failed%20to%20execute%20process%22)%0A%7D%20else%20%7B%0A%20%20%20%20Command%3A%3Anew(%22sh%22)%0A%20%20%20%20%20%20%20%20%20%20%20%20.arg(%22-c%22)%0A%20%20%20%20%20%20%20%20%20%20%20%20.arg(%22echo%20hello%22)%0A%20%20%20%20%20%20%20%20%20%20%20%20.output()%0A%20%20%20%20%20%20%20%20%20%20%20%20.expect(%22failed%20to%20execute%20process%22)%0A%7D%3B%0A%0Alet%20hello%20%3D%20output.stdout%3B%0A%7D">Run</a></pre>
</div>
<h2 id='methods' class='small-section-header'>
Methods<a href='#methods' class='anchor'></a>
</h2>
<h3 id='impl' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code><a href='#impl' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#389-765' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.new' class="method"><span id='new.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.new' class='fnname'>new</a><S: <a class="trait" href="../../std/convert/trait.AsRef.html" title="trait std::convert::AsRef">AsRef</a><<a class="struct" href="../../std/ffi/struct.OsStr.html" title="struct std::ffi::OsStr">OsStr</a>>>(program: S) -> <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#421-423' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Constructs a new <code>Command</code> for launching the program at
path <code>program</code>, with the following default configuration:</p>
<ul>
<li>No arguments to the program</li>
<li>Inherit the current process's environment</li>
<li>Inherit the current process's working directory</li>
<li>Inherit stdin/stdout/stderr for <code>spawn</code> or <code>status</code>, but create pipes for <code>output</code></li>
</ul>
<p>Builder methods are provided to change these defaults and
otherwise configure the process.</p>
<p>If <code>program</code> is not an absolute path, the <code>PATH</code> will be searched in
an OS-defined way.</p>
<p>The search path to be used may be controlled by setting the
<code>PATH</code> environment variable on the Command,
but this has some implementation limitations on Windows
(see <a href="https://github.com/rust-lang/rust/issues/37519">https://github.com/rust-lang/rust/issues/37519</a>).</p>
<h1 id="examples" class="section-header"><a href="#examples">Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::<span class="ident">Command</span>;
<span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"sh"</span>)
.<span class="ident">spawn</span>()
.<span class="ident">expect</span>(<span class="string">"sh command failed to start"</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aprocess%3A%3ACommand%3B%0A%0ACommand%3A%3Anew(%22sh%22)%0A%20%20%20%20%20%20%20%20.spawn()%0A%20%20%20%20%20%20%20%20.expect(%22sh%20command%20failed%20to%20start%22)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.arg' class="method"><span id='arg.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.arg' class='fnname'>arg</a><S: <a class="trait" href="../../std/convert/trait.AsRef.html" title="trait std::convert::AsRef">AsRef</a><<a class="struct" href="../../std/ffi/struct.OsStr.html" title="struct std::ffi::OsStr">OsStr</a>>>(&mut self, arg: S) -> &mut <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#462-465' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Add an argument to pass to the program.</p>
<p>Only one argument can be passed per use. So instead of:</p>
<pre class="rust rust-example-rendered">
.<span class="ident">arg</span>(<span class="string">"-C /path/to/repo"</span>)<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Astd%3A%3Aprocess%3A%3ACommand%3A%3Anew(%22sh%22)%0A.arg(%22-C%20%2Fpath%2Fto%2Frepo%22)%0A%3B%0A%7D">Run</a></pre>
<p>usage would be:</p>
<pre class="rust rust-example-rendered">
.<span class="ident">arg</span>(<span class="string">"-C"</span>)
.<span class="ident">arg</span>(<span class="string">"/path/to/repo"</span>)<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Astd%3A%3Aprocess%3A%3ACommand%3A%3Anew(%22sh%22)%0A.arg(%22-C%22)%0A.arg(%22%2Fpath%2Fto%2Frepo%22)%0A%3B%0A%7D">Run</a></pre>
<p>To pass multiple arguments see <a href="#method.args"><code>args</code></a>.</p>
<h1 id="examples-1" class="section-header"><a href="#examples-1">Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::<span class="ident">Command</span>;
<span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"ls"</span>)
.<span class="ident">arg</span>(<span class="string">"-l"</span>)
.<span class="ident">arg</span>(<span class="string">"-a"</span>)
.<span class="ident">spawn</span>()
.<span class="ident">expect</span>(<span class="string">"ls command failed to start"</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aprocess%3A%3ACommand%3B%0A%0ACommand%3A%3Anew(%22ls%22)%0A%20%20%20%20%20%20%20%20.arg(%22-l%22)%0A%20%20%20%20%20%20%20%20.arg(%22-a%22)%0A%20%20%20%20%20%20%20%20.spawn()%0A%20%20%20%20%20%20%20%20.expect(%22ls%20command%20failed%20to%20start%22)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.args' class="method"><span id='args.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.args' class='fnname'>args</a><I, S>(&mut self, args: I) -> &mut <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../std/iter/trait.IntoIterator.html" title="trait std::iter::IntoIterator">IntoIterator</a><Item = S>,<br> S: <a class="trait" href="../../std/convert/trait.AsRef.html" title="trait std::convert::AsRef">AsRef</a><<a class="struct" href="../../std/ffi/struct.OsStr.html" title="struct std::ffi::OsStr">OsStr</a>>, </span></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#486-493' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Add multiple arguments to pass to the program.</p>
<p>To pass a single argument see <a href="#method.arg"><code>arg</code></a>.</p>
<h1 id="examples-2" class="section-header"><a href="#examples-2">Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::<span class="ident">Command</span>;
<span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"ls"</span>)
.<span class="ident">args</span>(<span class="kw-2">&</span>[<span class="string">"-l"</span>, <span class="string">"-a"</span>])
.<span class="ident">spawn</span>()
.<span class="ident">expect</span>(<span class="string">"ls command failed to start"</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aprocess%3A%3ACommand%3B%0A%0ACommand%3A%3Anew(%22ls%22)%0A%20%20%20%20%20%20%20%20.args(%26%5B%22-l%22%2C%20%22-a%22%5D)%0A%20%20%20%20%20%20%20%20.spawn()%0A%20%20%20%20%20%20%20%20.expect(%22ls%20command%20failed%20to%20start%22)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.env' class="method"><span id='env.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.env' class='fnname'>env</a><K, V>(&mut self, key: K, val: V) -> &mut <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a> <span class="where fmt-newline">where<br> K: <a class="trait" href="../../std/convert/trait.AsRef.html" title="trait std::convert::AsRef">AsRef</a><<a class="struct" href="../../std/ffi/struct.OsStr.html" title="struct std::ffi::OsStr">OsStr</a>>,<br> V: <a class="trait" href="../../std/convert/trait.AsRef.html" title="trait std::convert::AsRef">AsRef</a><<a class="struct" href="../../std/ffi/struct.OsStr.html" title="struct std::ffi::OsStr">OsStr</a>>, </span></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#513-518' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Inserts or updates an environment variable mapping.</p>
<p>Note that environment variable names are case-insensitive (but case-preserving) on Windows,
and case-sensitive on all other platforms.</p>
<h1 id="examples-3" class="section-header"><a href="#examples-3">Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::<span class="ident">Command</span>;
<span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"ls"</span>)
.<span class="ident">env</span>(<span class="string">"PATH"</span>, <span class="string">"/bin"</span>)
.<span class="ident">spawn</span>()
.<span class="ident">expect</span>(<span class="string">"ls command failed to start"</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aprocess%3A%3ACommand%3B%0A%0ACommand%3A%3Anew(%22ls%22)%0A%20%20%20%20%20%20%20%20.env(%22PATH%22%2C%20%22%2Fbin%22)%0A%20%20%20%20%20%20%20%20.spawn()%0A%20%20%20%20%20%20%20%20.expect(%22ls%20command%20failed%20to%20start%22)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.envs' class="method"><span id='envs.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.envs' class='fnname'>envs</a><I, K, V>(&mut self, vars: I) -> &mut <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a> <span class="where fmt-newline">where<br> I: <a class="trait" href="../../std/iter/trait.IntoIterator.html" title="trait std::iter::IntoIterator">IntoIterator</a><Item = <a class="primitive" href="../primitive.tuple.html">(</a>K, V<a class="primitive" href="../primitive.tuple.html">)</a>>,<br> K: <a class="trait" href="../../std/convert/trait.AsRef.html" title="trait std::convert::AsRef">AsRef</a><<a class="struct" href="../../std/ffi/struct.OsStr.html" title="struct std::ffi::OsStr">OsStr</a>>,<br> V: <a class="trait" href="../../std/convert/trait.AsRef.html" title="trait std::convert::AsRef">AsRef</a><<a class="struct" href="../../std/ffi/struct.OsStr.html" title="struct std::ffi::OsStr">OsStr</a>>, </span></code></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.19.0'>1.19.0</div><a class='srclink' href='../../src/std/process.rs.html#545-552' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Add or update multiple environment variable mappings.</p>
<h1 id="examples-4" class="section-header"><a href="#examples-4">Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::{<span class="ident">Command</span>, <span class="ident">Stdio</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">env</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">HashMap</span>;
<span class="kw">let</span> <span class="ident">filtered_env</span> : <span class="ident">HashMap</span><span class="op"><</span><span class="ident">String</span>, <span class="ident">String</span><span class="op">></span> <span class="op">=</span>
<span class="ident">env</span>::<span class="ident">vars</span>().<span class="ident">filter</span>(<span class="op">|</span><span class="kw-2">&</span>(<span class="kw-2">ref</span> <span class="ident">k</span>, <span class="kw">_</span>)<span class="op">|</span>
<span class="ident">k</span> <span class="op">==</span> <span class="string">"TERM"</span> <span class="op">||</span> <span class="ident">k</span> <span class="op">==</span> <span class="string">"TZ"</span> <span class="op">||</span> <span class="ident">k</span> <span class="op">==</span> <span class="string">"LANG"</span> <span class="op">||</span> <span class="ident">k</span> <span class="op">==</span> <span class="string">"PATH"</span>
).<span class="ident">collect</span>();
<span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"printenv"</span>)
.<span class="ident">stdin</span>(<span class="ident">Stdio</span>::<span class="ident">null</span>())
.<span class="ident">stdout</span>(<span class="ident">Stdio</span>::<span class="ident">inherit</span>())
.<span class="ident">env_clear</span>()
.<span class="ident">envs</span>(<span class="kw-2">&</span><span class="ident">filtered_env</span>)
.<span class="ident">spawn</span>()
.<span class="ident">expect</span>(<span class="string">"printenv failed to start"</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aprocess%3A%3A%7BCommand%2C%20Stdio%7D%3B%0Ause%20std%3A%3Aenv%3B%0Ause%20std%3A%3Acollections%3A%3AHashMap%3B%0A%0Alet%20filtered_env%20%3A%20HashMap%3CString%2C%20String%3E%20%3D%0A%20%20%20%20env%3A%3Avars().filter(%7C%26(ref%20k%2C%20_)%7C%0A%20%20%20%20%20%20%20%20k%20%3D%3D%20%22TERM%22%20%7C%7C%20k%20%3D%3D%20%22TZ%22%20%7C%7C%20k%20%3D%3D%20%22LANG%22%20%7C%7C%20k%20%3D%3D%20%22PATH%22%0A%20%20%20%20).collect()%3B%0A%0ACommand%3A%3Anew(%22printenv%22)%0A%20%20%20%20%20%20%20%20.stdin(Stdio%3A%3Anull())%0A%20%20%20%20%20%20%20%20.stdout(Stdio%3A%3Ainherit())%0A%20%20%20%20%20%20%20%20.env_clear()%0A%20%20%20%20%20%20%20%20.envs(%26filtered_env)%0A%20%20%20%20%20%20%20%20.spawn()%0A%20%20%20%20%20%20%20%20.expect(%22printenv%20failed%20to%20start%22)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.env_remove' class="method"><span id='env_remove.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.env_remove' class='fnname'>env_remove</a><K: <a class="trait" href="../../std/convert/trait.AsRef.html" title="trait std::convert::AsRef">AsRef</a><<a class="struct" href="../../std/ffi/struct.OsStr.html" title="struct std::ffi::OsStr">OsStr</a>>>(&mut self, key: K) -> &mut <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#569-572' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Removes an environment variable mapping.</p>
<h1 id="examples-5" class="section-header"><a href="#examples-5">Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::<span class="ident">Command</span>;
<span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"ls"</span>)
.<span class="ident">env_remove</span>(<span class="string">"PATH"</span>)
.<span class="ident">spawn</span>()
.<span class="ident">expect</span>(<span class="string">"ls command failed to start"</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aprocess%3A%3ACommand%3B%0A%0ACommand%3A%3Anew(%22ls%22)%0A%20%20%20%20%20%20%20%20.env_remove(%22PATH%22)%0A%20%20%20%20%20%20%20%20.spawn()%0A%20%20%20%20%20%20%20%20.expect(%22ls%20command%20failed%20to%20start%22)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.env_clear' class="method"><span id='env_clear.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.env_clear' class='fnname'>env_clear</a>(&mut self) -> &mut <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#589-592' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Clears the entire environment map for the child process.</p>
<h1 id="examples-6" class="section-header"><a href="#examples-6">Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::<span class="ident">Command</span>;
<span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"ls"</span>)
.<span class="ident">env_clear</span>()
.<span class="ident">spawn</span>()
.<span class="ident">expect</span>(<span class="string">"ls command failed to start"</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aprocess%3A%3ACommand%3B%0A%0ACommand%3A%3Anew(%22ls%22)%0A%20%20%20%20%20%20%20%20.env_clear()%0A%20%20%20%20%20%20%20%20.spawn()%0A%20%20%20%20%20%20%20%20.expect(%22ls%20command%20failed%20to%20start%22)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.current_dir' class="method"><span id='current_dir.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.current_dir' class='fnname'>current_dir</a><P: <a class="trait" href="../../std/convert/trait.AsRef.html" title="trait std::convert::AsRef">AsRef</a><<a class="struct" href="../../std/path/struct.Path.html" title="struct std::path::Path">Path</a>>>(&mut self, dir: P) -> &mut <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#609-612' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Sets the working directory for the child process.</p>
<h1 id="examples-7" class="section-header"><a href="#examples-7">Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::<span class="ident">Command</span>;
<span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"ls"</span>)
.<span class="ident">current_dir</span>(<span class="string">"/bin"</span>)
.<span class="ident">spawn</span>()
.<span class="ident">expect</span>(<span class="string">"ls command failed to start"</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aprocess%3A%3ACommand%3B%0A%0ACommand%3A%3Anew(%22ls%22)%0A%20%20%20%20%20%20%20%20.current_dir(%22%2Fbin%22)%0A%20%20%20%20%20%20%20%20.spawn()%0A%20%20%20%20%20%20%20%20.expect(%22ls%20command%20failed%20to%20start%22)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.stdin' class="method"><span id='stdin.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.stdin' class='fnname'>stdin</a><T: <a class="trait" href="../../std/convert/trait.Into.html" title="trait std::convert::Into">Into</a><<a class="struct" href="../../std/process/struct.Stdio.html" title="struct std::process::Stdio">Stdio</a>>>(&mut self, cfg: T) -> &mut <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#635-638' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Configuration for the child process's standard input (stdin) handle.</p>
<p>Defaults to <a href="struct.Stdio.html#method.inherit"><code>inherit</code></a> when used with <code>spawn</code> or <code>status</code>, and
defaults to <a href="struct.Stdio.html#method.piped"><code>piped</code></a> when used with <code>output</code>.</p>
<h1 id="examples-8" class="section-header"><a href="#examples-8">Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::{<span class="ident">Command</span>, <span class="ident">Stdio</span>};
<span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"ls"</span>)
.<span class="ident">stdin</span>(<span class="ident">Stdio</span>::<span class="ident">null</span>())
.<span class="ident">spawn</span>()
.<span class="ident">expect</span>(<span class="string">"ls command failed to start"</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aprocess%3A%3A%7BCommand%2C%20Stdio%7D%3B%0A%0ACommand%3A%3Anew(%22ls%22)%0A%20%20%20%20%20%20%20%20.stdin(Stdio%3A%3Anull())%0A%20%20%20%20%20%20%20%20.spawn()%0A%20%20%20%20%20%20%20%20.expect(%22ls%20command%20failed%20to%20start%22)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.stdout' class="method"><span id='stdout.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.stdout' class='fnname'>stdout</a><T: <a class="trait" href="../../std/convert/trait.Into.html" title="trait std::convert::Into">Into</a><<a class="struct" href="../../std/process/struct.Stdio.html" title="struct std::process::Stdio">Stdio</a>>>(&mut self, cfg: T) -> &mut <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#661-664' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Configuration for the child process's standard output (stdout) handle.</p>
<p>Defaults to <a href="struct.Stdio.html#method.inherit"><code>inherit</code></a> when used with <code>spawn</code> or <code>status</code>, and
defaults to <a href="struct.Stdio.html#method.piped"><code>piped</code></a> when used with <code>output</code>.</p>
<h1 id="examples-9" class="section-header"><a href="#examples-9">Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::{<span class="ident">Command</span>, <span class="ident">Stdio</span>};
<span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"ls"</span>)
.<span class="ident">stdout</span>(<span class="ident">Stdio</span>::<span class="ident">null</span>())
.<span class="ident">spawn</span>()
.<span class="ident">expect</span>(<span class="string">"ls command failed to start"</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aprocess%3A%3A%7BCommand%2C%20Stdio%7D%3B%0A%0ACommand%3A%3Anew(%22ls%22)%0A%20%20%20%20%20%20%20%20.stdout(Stdio%3A%3Anull())%0A%20%20%20%20%20%20%20%20.spawn()%0A%20%20%20%20%20%20%20%20.expect(%22ls%20command%20failed%20to%20start%22)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.stderr' class="method"><span id='stderr.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.stderr' class='fnname'>stderr</a><T: <a class="trait" href="../../std/convert/trait.Into.html" title="trait std::convert::Into">Into</a><<a class="struct" href="../../std/process/struct.Stdio.html" title="struct std::process::Stdio">Stdio</a>>>(&mut self, cfg: T) -> &mut <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#687-690' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Configuration for the child process's standard error (stderr) handle.</p>
<p>Defaults to <a href="struct.Stdio.html#method.inherit"><code>inherit</code></a> when used with <code>spawn</code> or <code>status</code>, and
defaults to <a href="struct.Stdio.html#method.piped"><code>piped</code></a> when used with <code>output</code>.</p>
<h1 id="examples-10" class="section-header"><a href="#examples-10">Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::{<span class="ident">Command</span>, <span class="ident">Stdio</span>};
<span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"ls"</span>)
.<span class="ident">stderr</span>(<span class="ident">Stdio</span>::<span class="ident">null</span>())
.<span class="ident">spawn</span>()
.<span class="ident">expect</span>(<span class="string">"ls command failed to start"</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aprocess%3A%3A%7BCommand%2C%20Stdio%7D%3B%0A%0ACommand%3A%3Anew(%22ls%22)%0A%20%20%20%20%20%20%20%20.stderr(Stdio%3A%3Anull())%0A%20%20%20%20%20%20%20%20.spawn()%0A%20%20%20%20%20%20%20%20.expect(%22ls%20command%20failed%20to%20start%22)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.spawn' class="method"><span id='spawn.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.spawn' class='fnname'>spawn</a>(&mut self) -> <a class="type" href="../../std/io/type.Result.html" title="type std::io::Result">Result</a><<a class="struct" href="../../std/process/struct.Child.html" title="struct std::process::Child">Child</a>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#708-710' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Executes the command as a child process, returning a handle to it.</p>
<p>By default, stdin, stdout and stderr are inherited from the parent.</p>
<h1 id="examples-11" class="section-header"><a href="#examples-11">Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::<span class="ident">Command</span>;
<span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"ls"</span>)
.<span class="ident">spawn</span>()
.<span class="ident">expect</span>(<span class="string">"ls command failed to start"</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aprocess%3A%3ACommand%3B%0A%0ACommand%3A%3Anew(%22ls%22)%0A%20%20%20%20%20%20%20%20.spawn()%0A%20%20%20%20%20%20%20%20.expect(%22ls%20command%20failed%20to%20start%22)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.output' class="method"><span id='output.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.output' class='fnname'>output</a>(&mut self) -> <a class="type" href="../../std/io/type.Result.html" title="type std::io::Result">Result</a><<a class="struct" href="../../std/process/struct.Output.html" title="struct std::process::Output">Output</a>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#736-739' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Executes the command as a child process, waiting for it to finish and
collecting all of its output.</p>
<p>By default, stdout and stderr are captured (and used to provide the
resulting output). Stdin is not inherited from the parent and any
attempt by the child process to read from the stdin stream will result
in the stream immediately closing.</p>
<h1 id="examples-12" class="section-header"><a href="#examples-12">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::<span class="ident">Command</span>;
<span class="kw">let</span> <span class="ident">output</span> <span class="op">=</span> <span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"/bin/cat"</span>)
.<span class="ident">arg</span>(<span class="string">"file.txt"</span>)
.<span class="ident">output</span>()
.<span class="ident">expect</span>(<span class="string">"failed to execute process"</span>);
<span class="macro">println</span><span class="macro">!</span>(<span class="string">"status: {}"</span>, <span class="ident">output</span>.<span class="ident">status</span>);
<span class="macro">println</span><span class="macro">!</span>(<span class="string">"stdout: {}"</span>, <span class="ident">String</span>::<span class="ident">from_utf8_lossy</span>(<span class="kw-2">&</span><span class="ident">output</span>.<span class="ident">stdout</span>));
<span class="macro">println</span><span class="macro">!</span>(<span class="string">"stderr: {}"</span>, <span class="ident">String</span>::<span class="ident">from_utf8_lossy</span>(<span class="kw-2">&</span><span class="ident">output</span>.<span class="ident">stderr</span>));
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">output</span>.<span class="ident">status</span>.<span class="ident">success</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aprocess%3A%3ACommand%3B%0Alet%20output%20%3D%20Command%3A%3Anew(%22%2Fbin%2Fcat%22)%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20.arg(%22file.txt%22)%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20.output()%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20.expect(%22failed%20to%20execute%20process%22)%3B%0A%0Aprintln!(%22status%3A%20%7B%7D%22%2C%20output.status)%3B%0Aprintln!(%22stdout%3A%20%7B%7D%22%2C%20String%3A%3Afrom_utf8_lossy(%26output.stdout))%3B%0Aprintln!(%22stderr%3A%20%7B%7D%22%2C%20String%3A%3Afrom_utf8_lossy(%26output.stderr))%3B%0A%0Aassert!(output.status.success())%3B%0A%7D">Run</a></pre>
</div><h4 id='method.status' class="method"><span id='status.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.status' class='fnname'>status</a>(&mut self) -> <a class="type" href="../../std/io/type.Result.html" title="type std::io::Result">Result</a><<a class="struct" href="../../std/process/struct.ExitStatus.html" title="struct std::process::ExitStatus">ExitStatus</a>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#761-764' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Executes a command as a child process, waiting for it to finish and
collecting its exit status.</p>
<p>By default, stdin, stdout and stderr are inherited from the parent.</p>
<h1 id="examples-13" class="section-header"><a href="#examples-13">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">process</span>::<span class="ident">Command</span>;
<span class="kw">let</span> <span class="ident">status</span> <span class="op">=</span> <span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"/bin/cat"</span>)
.<span class="ident">arg</span>(<span class="string">"file.txt"</span>)
.<span class="ident">status</span>()
.<span class="ident">expect</span>(<span class="string">"failed to execute process"</span>);
<span class="macro">println</span><span class="macro">!</span>(<span class="string">"process exited with: {}"</span>, <span class="ident">status</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">status</span>.<span class="ident">success</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Ause%20std%3A%3Aprocess%3A%3ACommand%3B%0A%0Alet%20status%20%3D%20Command%3A%3Anew(%22%2Fbin%2Fcat%22)%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20.arg(%22file.txt%22)%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20.status()%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20.expect(%22failed%20to%20execute%20process%22)%3B%0A%0Aprintln!(%22process%20exited%20with%3A%20%7B%7D%22%2C%20status)%3B%0A%0Aassert!(status.success())%3B%0A%7D">Run</a></pre>
</div></div>
<h2 id='implementations' class='small-section-header'>
Trait Implementations<a href='#implementations' class='anchor'></a>
</h2>
<div id='implementations-list'><h3 id='impl-Debug' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl <a class="trait" href="../../std/fmt/trait.Debug.html" title="trait std::fmt::Debug">Debug</a> for <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code><a href='#impl-Debug' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#768-775' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.fmt' class="method"><span id='fmt.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../std/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="../../std/fmt/struct.Formatter.html" title="struct std::fmt::Formatter">Formatter</a>) -> <a class="type" href="../../std/fmt/type.Result.html" title="type std::fmt::Result">Result</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/process.rs.html#772-774' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Format the program and arguments of a Command for display. Any
non-utf8 data is lossily converted using the utf8 replacement
character.</p>
</div></div><h3 id='impl-CommandExt' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl <a class="trait" href="../../std/os/unix/process/trait.CommandExt.html" title="trait std::os::unix::process::CommandExt">CommandExt</a> for <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code><a href='#impl-CommandExt' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/sys/unix/ext/process.rs.html#99-120' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.uid' class="method"><span id='uid.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../std/os/unix/process/trait.CommandExt.html#tymethod.uid' class='fnname'>uid</a>(&mut self, id: <a class="primitive" href="../primitive.u32.html">u32</a>) -> &mut <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/sys/unix/ext/process.rs.html#100-103' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='stability'><div class='stab portability'>This is supported on <strong>Unix</strong> only.</div></div><div class='docblock'><p>Sets the child process's user id. This translates to a <code>setuid</code> call in the child process. Failure in the <code>setuid</code> call will cause the spawn to fail. <a href="../../std/os/unix/process/trait.CommandExt.html#tymethod.uid">Read more</a></p>
</div><h4 id='method.gid' class="method"><span id='gid.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../std/os/unix/process/trait.CommandExt.html#tymethod.gid' class='fnname'>gid</a>(&mut self, id: <a class="primitive" href="../primitive.u32.html">u32</a>) -> &mut <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/sys/unix/ext/process.rs.html#105-108' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='stability'><div class='stab portability'>This is supported on <strong>Unix</strong> only.</div></div><div class='docblock'><p>Similar to <code>uid</code>, but sets the group id of the child process. This has the same semantics as the <code>uid</code> field. <a href="../../std/os/unix/process/trait.CommandExt.html#tymethod.gid">Read more</a></p>
</div><h4 id='method.before_exec' class="method"><span id='before_exec.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../std/os/unix/process/trait.CommandExt.html#tymethod.before_exec' class='fnname'>before_exec</a><F>(&mut self, f: F) -> &mut <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a> <span class="where fmt-newline">where<br> F: <a class="trait" href="../../std/ops/trait.FnMut.html" title="trait std::ops::FnMut">FnMut</a>() -> <a class="type" href="../../std/io/type.Result.html" title="type std::io::Result">Result</a><<a class="primitive" href="../primitive.unit.html">()</a>> + <a class="trait" href="../../std/marker/trait.Send.html" title="trait std::marker::Send">Send</a> + <a class="trait" href="../../std/marker/trait.Sync.html" title="trait std::marker::Sync">Sync</a> + 'static, </span></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/sys/unix/ext/process.rs.html#110-115' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='stability'><div class='stab portability'>This is supported on <strong>Unix</strong> only.</div></div><div class='docblock'><p>Schedules a closure to be run just before the <code>exec</code> function is invoked. <a href="../../std/os/unix/process/trait.CommandExt.html#tymethod.before_exec">Read more</a></p>
</div><h4 id='method.exec' class="method"><span id='exec.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../std/os/unix/process/trait.CommandExt.html#tymethod.exec' class='fnname'>exec</a>(&mut self) -> <a class="struct" href="../../std/io/struct.Error.html" title="struct std::io::Error">Error</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/sys/unix/ext/process.rs.html#117-119' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='stability'><div class='stab portability'>This is supported on <strong>Unix</strong> only.</div></div><div class='docblock'><p>Performs all the required setup by this <code>Command</code>, followed by calling the <code>execvp</code> syscall. <a href="../../std/os/unix/process/trait.CommandExt.html#tymethod.exec">Read more</a></p>
</div></div><h3 id='impl-CommandExt-1' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl <a class="trait" href="../../std/os/windows/process/trait.CommandExt.html" title="trait std::os::windows::process::CommandExt">CommandExt</a> for <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code><a href='#impl-CommandExt-1' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.16.0'>1.16.0</div><a class='srclink' href='../../src/std/sys/windows/ext/process.rs.html#118-123' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.creation_flags' class="method"><span id='creation_flags.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../std/os/windows/process/trait.CommandExt.html#tymethod.creation_flags' class='fnname'>creation_flags</a>(&mut self, flags: <a class="primitive" href="../primitive.u32.html">u32</a>) -> &mut <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/std/sys/windows/ext/process.rs.html#119-122' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='stability'><div class='stab portability'>This is supported on <strong>Windows</strong> only.</div></div><div class='docblock'><p>Sets the [process creation flags][1] to be passed to <code>CreateProcess</code>. <a href="../../std/os/windows/process/trait.CommandExt.html#tymethod.creation_flags">Read more</a></p>
</div></div></div>
<h2 id='synthetic-implementations' class='small-section-header'>
Auto Trait Implementations<a href='#synthetic-implementations' class='anchor'></a>
</h2>
<div id='synthetic-implementations-list'>
<h3 id='impl-Send' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl <a class="trait" href="../../std/marker/trait.Send.html" title="trait std::marker::Send">Send</a> for <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code><a href='#impl-Send' class='anchor'></a></span></td><td><span class='out-of-band'></span></td></tr></tbody></table></h3><div class='impl-items'></div><h3 id='impl-Sync' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl !<a class="trait" href="../../std/marker/trait.Sync.html" title="trait std::marker::Sync">Sync</a> for <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code><a href='#impl-Sync' class='anchor'></a></span></td><td><span class='out-of-band'></span></td></tr></tbody></table></h3><div class='impl-items'></div></div></section><section id="search" class="content hidden"></section><section class="footer"></section><aside id="help" class="hidden"><div><h1 class="hidden">Help</h1><div class="shortcuts"><h2>Keyboard Shortcuts</h2><dl><dt><kbd>?</kbd></dt><dd>Show this help dialog</dd><dt><kbd>S</kbd></dt><dd>Focus the search field</dd><dt><kbd>↑</kbd></dt><dd>Move up in search results</dd><dt><kbd>↓</kbd></dt><dd>Move down in search results</dd><dt><kbd>↹</kbd></dt><dd>Switch tab</dd><dt><kbd>⏎</kbd></dt><dd>Go to active search result</dd><dt><kbd>+</kbd></dt><dd>Expand all sections</dd><dt><kbd>-</kbd></dt><dd>Collapse all sections</dd></dl></div><div class="infos"><h2>Search Tricks</h2><p>Prefix searches with a type followed by a colon (e.g. <code>fn:</code>) to restrict the search to a given type.</p><p>Accepted types are: <code>fn</code>, <code>mod</code>, <code>struct</code>, <code>enum</code>, <code>trait</code>, <code>type</code>, <code>macro</code>, and <code>const</code>.</p><p>Search functions by type signature (e.g. <code>vec -> usize</code> or <code>* -> vec</code>)</p><p>Search multiple things at once by splitting your query with comma (e.g. <code>str,u8</code> or <code>String,struct:Vec,test</code>)</p></div></div></aside><script>window.rootPath = "../../";window.currentCrate = "std";</script><script src="../../aliases.js"></script><script src="../../main.js"></script><script defer src="../../search-index.js"></script></body></html>
distrib
>
Mageia
>
6
>
armv7hl
>
media
>
core-updates
>
by-pkgid
>
4e2dbb669434a7691662cb2f0ad38972
>
files
>
14246
