<!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="../../normalize1.35.0.css"><link rel="stylesheet" type="text/css" href="../../rustdoc1.35.0.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../../dark1.35.0.css"><link rel="stylesheet" type="text/css" href="../../light1.35.0.css" id="themeStyle"><script src="../../storage1.35.0.js"></script><noscript><link rel="stylesheet" href="../../noscript1.35.0.css"></noscript><link rel="shortcut icon" href="../../favicon1.35.0.ico"><style type="text/css">#crate-search{background-image:url("../../down-arrow1.35.0.svg");}</style></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='../../rust-logo1.35.0.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.arg">arg</a><a href="#method.args">args</a><a href="#method.current_dir">current_dir</a><a href="#method.env">env</a><a href="#method.env_clear">env_clear</a><a href="#method.env_remove">env_remove</a><a href="#method.envs">envs</a><a href="#method.new">new</a><a href="#method.output">output</a><a href="#method.spawn">spawn</a><a href="#method.status">status</a><a href="#method.stderr">stderr</a><a href="#method.stdin">stdin</a><a href="#method.stdout">stdout</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-CommandExt">CommandExt</a><a href="#impl-Debug">Debug</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><a class="sidebar-title" href="#blanket-implementations">Blanket Implementations</a><div class="sidebar-links"><a href="#impl-Any">Any</a><a href="#impl-Borrow">Borrow</a><a href="#impl-BorrowMut">BorrowMut</a><a href="#impl-From">From</a><a href="#impl-Into">Into</a><a href="#impl-TryFrom">TryFrom</a><a href="#impl-TryInto">TryInto</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="../../brush1.35.0.svg" width="18" alt="Pick another theme!"></button><div id="theme-choices"></div></div><script src="../../theme1.35.0.js"></script><nav class="sub"><form class="search-form js-only"><div class="search-container"><div><select id="crate-search"><option value="All crates">All crates</option></select><input class="search-input" name="search" autocomplete="off" spellcheck="false" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"></div><a id="settings-menu" href="../../settings.html"><img src="../../wheel1.35.0.svg" width="18" alt="Change settings"></a></div></form></nav><section id="main" class="content"><h1 class='fqn'><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#408-410' title='goto source code'>[src]</a></span><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></h1><div class="docblock type-decl hidden-by-usual-hider"><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>
<div class="example-wrap"><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>
<p><code>Command</code> can be reused to spawn multiple processes. The builder methods
change the command without needing to immediately spawn the process.</p>
<div class="example-wrap"><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="kw-2">mut</span> <span class="ident">echo_hello</span> <span class="op">=</span> <span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"sh"</span>);
<span class="ident">echo_hello</span>.<span class="ident">arg</span>(<span class="string">"-c"</span>)
.<span class="ident">arg</span>(<span class="string">"echo hello"</span>);
<span class="kw">let</span> <span class="ident">hello_1</span> <span class="op">=</span> <span class="ident">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_2</span> <span class="op">=</span> <span class="ident">echo_hello</span>.<span class="ident">output</span>().<span class="ident">expect</span>(<span class="string">"failed to execute process"</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%20mut%20echo_hello%20%3D%20Command%3A%3Anew(%22sh%22)%3B%0Aecho_hello.arg(%22-c%22)%0A%20%20%20%20%20%20%20%20%20%20.arg(%22echo%20hello%22)%3B%0Alet%20hello_1%20%3D%20echo_hello.output().expect(%22failed%20to%20execute%20process%22)%3B%0Alet%20hello_2%20%3D%20echo_hello.output().expect(%22failed%20to%20execute%20process%22)%3B%0A%7D">Run</a></pre></div>
<p>Similarly, you can call builder methods after spawning a process and then
spawn a new process with the modified settings.</p>
<div class="example-wrap"><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="kw-2">mut</span> <span class="ident">list_dir</span> <span class="op">=</span> <span class="ident">Command</span>::<span class="ident">new</span>(<span class="string">"ls"</span>);
<span class="comment">// Execute `ls` in the current directory of the program.</span>
<span class="ident">list_dir</span>.<span class="ident">status</span>().<span class="ident">expect</span>(<span class="string">"process failed to execute"</span>);
<span class="macro">println</span><span class="macro">!</span>(<span class="string">""</span>);
<span class="comment">// Change `ls` to execute in the root directory.</span>
<span class="ident">list_dir</span>.<span class="ident">current_dir</span>(<span class="string">"/"</span>);
<span class="comment">// And then execute `ls` again but in the root directory.</span>
<span class="ident">list_dir</span>.<span class="ident">status</span>().<span class="ident">expect</span>(<span class="string">"process failed to execute"</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%20mut%20list_dir%20%3D%20Command%3A%3Anew(%22ls%22)%3B%0A%0A%2F%2F%20Execute%20%60ls%60%20in%20the%20current%20directory%20of%20the%20program.%0Alist_dir.status().expect(%22process%20failed%20to%20execute%22)%3B%0A%0Aprintln!(%22%22)%3B%0A%0A%2F%2F%20Change%20%60ls%60%20to%20execute%20in%20the%20root%20directory.%0Alist_dir.current_dir(%22%2F%22)%3B%0A%0A%2F%2F%20And%20then%20execute%20%60ls%60%20again%20but%20in%20the%20root%20directory.%0Alist_dir.status().expect(%22process%20failed%20to%20execute%22)%3B%0A%7D">Run</a></pre></div>
</div><h2 id='methods' class='small-section-header'>Methods<a href='#methods' class='anchor'></a></h2><h3 id='impl' class='impl'><code class='in-band'>impl <a class="struct" href="../../std/process/struct.Command.html" title="struct std::process::Command">Command</a></code><a href='#impl' class='anchor'></a><a class='srclink' href='../../src/std/process.rs.html#412-799' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.new' class="method"><code id='new.v'>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><a class='srclink' href='../../src/std/process.rs.html#444-446' title='goto source code'>[src]</a></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 issue #37519).</p>
<h1 id="examples" class="section-header"><a href="#examples">Examples</a></h1>
<p>Basic usage:</p>
<div class="example-wrap"><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>
</div><h4 id='method.arg' class="method"><code id='arg.v'>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><a class='srclink' href='../../src/std/process.rs.html#485-488' title='goto source code'>[src]</a></h4><div class='docblock'><p>Adds an argument to pass to the program.</p>
<p>Only one argument can be passed per use. So instead of:</p>
<div class="example-wrap"><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></div>
<p>usage would be:</p>
<div class="example-wrap"><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></div>
<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>
<div class="example-wrap"><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>
</div><h4 id='method.args' class="method"><code id='args.v'>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><a class='srclink' href='../../src/std/process.rs.html#509-516' title='goto source code'>[src]</a></h4><div class='docblock'><p>Adds 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>
<div class="example-wrap"><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>
</div><h4 id='method.env' class="method"><code id='env.v'>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><a class='srclink' href='../../src/std/process.rs.html#536-541' title='goto source code'>[src]</a></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>
<div class="example-wrap"><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>
</div><h4 id='method.envs' class="method"><code id='envs.v'>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><div class='since' title='Stable since Rust version 1.19.0'>1.19.0</div><a class='srclink' href='../../src/std/process.rs.html#568-575' title='goto source code'>[src]</a></h4><div class='docblock'><p>Adds or updates multiple environment variable mappings.</p>
<h1 id="examples-4" class="section-header"><a href="#examples-4">Examples</a></h1>
<p>Basic usage:</p>
<div class="example-wrap"><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>
</div><h4 id='method.env_remove' class="method"><code id='env_remove.v'>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><a class='srclink' href='../../src/std/process.rs.html#592-595' title='goto source code'>[src]</a></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>
<div class="example-wrap"><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>
</div><h4 id='method.env_clear' class="method"><code id='env_clear.v'>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><a class='srclink' href='../../src/std/process.rs.html#612-615' title='goto source code'>[src]</a></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>
<div class="example-wrap"><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>
</div><h4 id='method.current_dir' class="method"><code id='current_dir.v'>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><a class='srclink' href='../../src/std/process.rs.html#642-645' title='goto source code'>[src]</a></h4><div class='docblock'><p>Sets the working directory for the child process.</p>
<h1 id="platform-specific-behavior" class="section-header"><a href="#platform-specific-behavior">Platform-specific behavior</a></h1>
<p>If the program path is relative (e.g., <code>"./script.sh"</code>), it's ambiguous
whether it should be interpreted relative to the parent's working
directory or relative to <code>current_dir</code>. The behavior in this case is
platform specific and unstable, and it's recommended to use
<a href="../fs/fn.canonicalize.html"><code>canonicalize</code></a> to get an absolute program path instead.</p>
<h1 id="examples-7" class="section-header"><a href="#examples-7">Examples</a></h1>
<p>Basic usage:</p>
<div class="example-wrap"><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>
</div><h4 id='method.stdin' class="method"><code id='stdin.v'>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><a class='srclink' href='../../src/std/process.rs.html#668-671' title='goto source code'>[src]</a></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>
<div class="example-wrap"><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>
</div><h4 id='method.stdout' class="method"><code id='stdout.v'>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><a class='srclink' href='../../src/std/process.rs.html#694-697' title='goto source code'>[src]</a></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>
<div class="example-wrap"><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>
</div><h4 id='method.stderr' class="method"><code id='stderr.v'>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><a class='srclink' href='../../src/std/process.rs.html#720-723' title='goto source code'>[src]</a></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>
<div class="example-wrap"><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>
</div><h4 id='method.spawn' class="method"><code id='spawn.v'>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><a class='srclink' href='../../src/std/process.rs.html#741-743' title='goto source code'>[src]</a></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>
<div class="example-wrap"><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>
</div><h4 id='method.output' class="method"><code id='output.v'>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><a class='srclink' href='../../src/std/process.rs.html#770-773' title='goto source code'>[src]</a></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>
<div class="example-wrap"><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">use</span> <span class="ident">std</span>::<span class="ident">io</span>::{<span class="self">self</span>, <span class="ident">Write</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="ident">io</span>::<span class="ident">stdout</span>().<span class="ident">write_all</span>(<span class="kw-2">&</span><span class="ident">output</span>.<span class="ident">stdout</span>).<span class="ident">unwrap</span>();
<span class="ident">io</span>::<span class="ident">stderr</span>().<span class="ident">write_all</span>(<span class="kw-2">&</span><span class="ident">output</span>.<span class="ident">stderr</span>).<span class="ident">unwrap</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%0Ause%20std%3A%3Aio%3A%3A%7Bself%2C%20Write%7D%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%0Aio%3A%3Astdout().write_all(%26output.stdout).unwrap()%3B%0Aio%3A%3Astderr().write_all(%26output.stderr).unwrap()%3B%0A%0Aassert!(output.status.success())%3B%0A%7D">Run</a></pre></div>
</div><h4 id='method.status' class="method"><code id='status.v'>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><a class='srclink' href='../../src/std/process.rs.html#795-798' title='goto source code'>[src]</a></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>
<div class="example-wrap"><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></div><h2 id='implementations' class='small-section-header'>Trait Implementations<a href='#implementations' class='anchor'></a></h2><div id='implementations-list'><h3 id='impl-CommandExt' class='impl'><code class='in-band'>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><a class='srclink' href='../../src/std/sys/unix/ext/process.rs.html#109-130' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.uid' class="method hidden"><code id='uid.v'>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><a class='srclink' href='../../src/std/sys/unix/ext/process.rs.html#110-113' title='goto source code'>[src]</a></h4><div class='stability hidden'><div class='stab portability'>This is supported on <strong>Unix</strong> only.</div></div><div class='docblock hidden'><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 hidden"><code id='gid.v'>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><a class='srclink' href='../../src/std/sys/unix/ext/process.rs.html#115-118' title='goto source code'>[src]</a></h4><div class='stability hidden'><div class='stab portability'>This is supported on <strong>Unix</strong> only.</div></div><div class='docblock hidden'><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.pre_exec' class="method hidden"><code id='pre_exec.v'>unsafe fn <a href='../../std/os/unix/process/trait.CommandExt.html#tymethod.pre_exec' class='fnname'>pre_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><a class='srclink' href='../../src/std/sys/unix/ext/process.rs.html#120-125' title='goto source code'>[src]</a></h4><div class='stability hidden'><div class='stab portability'>This is supported on <strong>Unix</strong> only.</div></div><div class='docblock hidden'><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.pre_exec">Read more</a></p>
</div><h4 id='method.exec' class="method hidden"><code id='exec.v'>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><a class='srclink' href='../../src/std/sys/unix/ext/process.rs.html#127-129' title='goto source code'>[src]</a></h4><div class='stability hidden'><div class='stab portability'>This is supported on <strong>Unix</strong> only.</div></div><div class='docblock hidden'><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><h4 id='method.before_exec' class="method"><code id='before_exec.v'>fn <a href='../../std/os/unix/process/trait.CommandExt.html#method.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><div class='since' title='Stable since Rust version 1.15.0'>1.15.0</div><a class='srclink' href='../../src/std/sys/unix/ext/process.rs.html#69-73' title='goto source code'>[src]</a></h4><div class='stability'><div class='stab deprecated'>Deprecating in 1.37.0: <p>should be unsafe, use <code>pre_exec</code> instead</p>
</div><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#method.before_exec">Read more</a></p>
</div></div><h3 id='impl-CommandExt-1' class='impl'><code class='in-band'>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><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#108-113' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.creation_flags' class="method hidden"><code id='creation_flags.v'>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><a class='srclink' href='../../src/std/sys/windows/ext/process.rs.html#109-112' title='goto source code'>[src]</a></h4><div class='stability hidden'><div class='stab portability'>This is supported on <strong>Windows</strong> only.</div></div><div class='docblock hidden'><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><h3 id='impl-Debug' class='impl'><code class='in-band'>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><a class='srclink' href='../../src/std/process.rs.html#802-809' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.fmt' class="method"><code id='fmt.v'>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><a class='srclink' href='../../src/std/process.rs.html#806-808' title='goto source code'>[src]</a></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></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'><code class='in-band'>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></h3><div class='impl-items'></div><h3 id='impl-Sync' class='impl'><code class='in-band'>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></h3><div class='impl-items'></div></div><h2 id='blanket-implementations' class='small-section-header'>Blanket Implementations<a href='#blanket-implementations' class='anchor'></a></h2><div id='blanket-implementations-list'><h3 id='impl-TryFrom' class='impl'><code class='in-band'>impl<T, U> <a class="trait" href="../../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="../../std/convert/trait.Into.html" title="trait std::convert::Into">Into</a><T>, </span></code><a href='#impl-TryFrom' class='anchor'></a><a class='srclink' href='../../src/core/convert.rs.html#565-571' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Error' class="type"><code id='Error.t'>type <a href='../../std/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="enum" href="../../std/convert/enum.Infallible.html" title="enum std::convert::Infallible">Infallible</a></code></h4><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from' class="method hidden"><code id='try_from.v'>fn <a href='../../std/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(value: U) -> <a class="enum" href="../../std/result/enum.Result.html" title="enum std::result::Result">Result</a><T, <T as <a class="trait" href="../../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><U>>::<a class="type" href="../../std/convert/trait.TryFrom.html#associatedtype.Error" title="type std::convert::TryFrom::Error">Error</a>></code><a class='srclink' href='../../src/core/convert.rs.html#568-570' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-From' class='impl'><code class='in-band'>impl<T> <a class="trait" href="../../std/convert/trait.From.html" title="trait std::convert::From">From</a> for T</code><a href='#impl-From' class='anchor'></a><a class='srclink' href='../../src/core/convert.rs.html#546-548' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from' class="method hidden"><code id='from.v'>fn <a href='../../std/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(t: T) -> T</code><a class='srclink' href='../../src/core/convert.rs.html#547' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-TryInto' class='impl'><code class='in-band'>impl<T, U> <a class="trait" href="../../std/convert/trait.TryInto.html" title="trait std::convert::TryInto">TryInto</a> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="../../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><T>, </span></code><a href='#impl-TryInto' class='anchor'></a><a class='srclink' href='../../src/core/convert.rs.html#553-560' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Error-1' class="type"><code id='Error.t-1'>type <a href='../../std/convert/trait.TryInto.html#associatedtype.Error' class="type">Error</a> = <U as <a class="trait" href="../../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><T>>::<a class="type" href="../../std/convert/trait.TryFrom.html#associatedtype.Error" title="type std::convert::TryFrom::Error">Error</a></code></h4><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_into' class="method hidden"><code id='try_into.v'>fn <a href='../../std/convert/trait.TryInto.html#tymethod.try_into' class='fnname'>try_into</a>(self) -> <a class="enum" href="../../std/result/enum.Result.html" title="enum std::result::Result">Result</a><U, <U as <a class="trait" href="../../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><T>>::<a class="type" href="../../std/convert/trait.TryFrom.html#associatedtype.Error" title="type std::convert::TryFrom::Error">Error</a>></code><a class='srclink' href='../../src/core/convert.rs.html#557-559' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-Into' class='impl'><code class='in-band'>impl<T, U> <a class="trait" href="../../std/convert/trait.Into.html" title="trait std::convert::Into">Into</a> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="../../std/convert/trait.From.html" title="trait std::convert::From">From</a><T>, </span></code><a href='#impl-Into' class='anchor'></a><a class='srclink' href='../../src/core/convert.rs.html#537-542' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.into' class="method hidden"><code id='into.v'>fn <a href='../../std/convert/trait.Into.html#tymethod.into' class='fnname'>into</a>(self) -> U</code><a class='srclink' href='../../src/core/convert.rs.html#539-541' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-Borrow' class='impl'><code class='in-band'>impl<T> <a class="trait" href="../../std/borrow/trait.Borrow.html" title="trait std::borrow::Borrow">Borrow</a> for T <span class="where fmt-newline">where<br> T: ?<a class="trait" href="../../std/marker/trait.Sized.html" title="trait std::marker::Sized">Sized</a>, </span></code><a href='#impl-Borrow' class='anchor'></a><a class='srclink' href='../../src/core/borrow.rs.html#213-215' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.borrow' class="method hidden"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="../primitive.reference.html">&'_ mut </a>F</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="../primitive.reference.html">&'_ mut </a>F</h3><code class="content"><span class="where fmt-newline">impl<'_, F> <a class="trait" href="../../std/future/trait.Future.html" title="trait std::future::Future">Future</a> for <a class="primitive" href="../primitive.reference.html">&'_ mut </a>F <span class="where fmt-newline">where<br> F: <a class="trait" href="../../std/marker/trait.Unpin.html" title="trait std::marker::Unpin">Unpin</a> + <a class="trait" href="../../std/future/trait.Future.html" title="trait std::future::Future">Future</a> + ?<a class="trait" href="../../std/marker/trait.Sized.html" title="trait std::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='../../std/future/trait.Future.html#associatedtype.Output' class="type">Output</a> = <F as <a class="trait" href="../../std/future/trait.Future.html" title="trait std::future::Future">Future</a>>::<a class="type" href="../../std/future/trait.Future.html#associatedtype.Output" title="type std::future::Future::Output">Output</a>;</span><span class="where fmt-newline">impl<'_, I> <a class="trait" href="../../std/iter/trait.Iterator.html" title="trait std::iter::Iterator">Iterator</a> for <a class="primitive" href="../primitive.reference.html">&'_ mut </a>I <span class="where fmt-newline">where<br> I: <a class="trait" href="../../std/iter/trait.Iterator.html" title="trait std::iter::Iterator">Iterator</a> + ?<a class="trait" href="../../std/marker/trait.Sized.html" title="trait std::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='../../std/iter/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="../../std/iter/trait.Iterator.html" title="trait std::iter::Iterator">Iterator</a>>::<a class="type" href="../../std/iter/trait.Iterator.html#associatedtype.Item" title="type std::iter::Iterator::Item">Item</a>;</span><span class="where fmt-newline">impl<R: <a class="trait" href="../../std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="../../std/marker/trait.Sized.html" title="trait std::marker::Sized">Sized</a>, '_> <a class="trait" href="../../std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="../primitive.reference.html">&'_ mut </a>R</span><span class="where fmt-newline">impl<W: <a class="trait" href="../../std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="../../std/marker/trait.Sized.html" title="trait std::marker::Sized">Sized</a>, '_> <a class="trait" href="../../std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="../primitive.reference.html">&'_ mut </a>W</span></code></div></div><code id='borrow.v'>fn <a href='../../std/borrow/trait.Borrow.html#tymethod.borrow' class='fnname'>borrow</a>(&self) -> <a class="primitive" href="../primitive.reference.html">&</a>T</code><a class='srclink' href='../../src/core/borrow.rs.html#214' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Immutably borrows from an owned value. <a href="../../std/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></p>
</div></div><h3 id='impl-BorrowMut' class='impl'><code class='in-band'>impl<T> <a class="trait" href="../../std/borrow/trait.BorrowMut.html" title="trait std::borrow::BorrowMut">BorrowMut</a> for T <span class="where fmt-newline">where<br> T: ?<a class="trait" href="../../std/marker/trait.Sized.html" title="trait std::marker::Sized">Sized</a>, </span></code><a href='#impl-BorrowMut' class='anchor'></a><a class='srclink' href='../../src/core/borrow.rs.html#218-220' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.borrow_mut' class="method hidden"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="../primitive.reference.html">&'_ mut </a>F</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="../primitive.reference.html">&'_ mut </a>F</h3><code class="content"><span class="where fmt-newline">impl<'_, F> <a class="trait" href="../../std/future/trait.Future.html" title="trait std::future::Future">Future</a> for <a class="primitive" href="../primitive.reference.html">&'_ mut </a>F <span class="where fmt-newline">where<br> F: <a class="trait" href="../../std/marker/trait.Unpin.html" title="trait std::marker::Unpin">Unpin</a> + <a class="trait" href="../../std/future/trait.Future.html" title="trait std::future::Future">Future</a> + ?<a class="trait" href="../../std/marker/trait.Sized.html" title="trait std::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='../../std/future/trait.Future.html#associatedtype.Output' class="type">Output</a> = <F as <a class="trait" href="../../std/future/trait.Future.html" title="trait std::future::Future">Future</a>>::<a class="type" href="../../std/future/trait.Future.html#associatedtype.Output" title="type std::future::Future::Output">Output</a>;</span><span class="where fmt-newline">impl<'_, I> <a class="trait" href="../../std/iter/trait.Iterator.html" title="trait std::iter::Iterator">Iterator</a> for <a class="primitive" href="../primitive.reference.html">&'_ mut </a>I <span class="where fmt-newline">where<br> I: <a class="trait" href="../../std/iter/trait.Iterator.html" title="trait std::iter::Iterator">Iterator</a> + ?<a class="trait" href="../../std/marker/trait.Sized.html" title="trait std::marker::Sized">Sized</a>, </span></span><span class="where fmt-newline"> type <a href='../../std/iter/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <I as <a class="trait" href="../../std/iter/trait.Iterator.html" title="trait std::iter::Iterator">Iterator</a>>::<a class="type" href="../../std/iter/trait.Iterator.html#associatedtype.Item" title="type std::iter::Iterator::Item">Item</a>;</span><span class="where fmt-newline">impl<R: <a class="trait" href="../../std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="../../std/marker/trait.Sized.html" title="trait std::marker::Sized">Sized</a>, '_> <a class="trait" href="../../std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="../primitive.reference.html">&'_ mut </a>R</span><span class="where fmt-newline">impl<W: <a class="trait" href="../../std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="../../std/marker/trait.Sized.html" title="trait std::marker::Sized">Sized</a>, '_> <a class="trait" href="../../std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="../primitive.reference.html">&'_ mut </a>W</span></code></div></div><code id='borrow_mut.v'>fn <a href='../../std/borrow/trait.BorrowMut.html#tymethod.borrow_mut' class='fnname'>borrow_mut</a>(&mut self) -> <a class="primitive" href="../primitive.reference.html">&mut </a>T</code><a class='srclink' href='../../src/core/borrow.rs.html#219' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Mutably borrows from an owned value. <a href="../../std/borrow/trait.BorrowMut.html#tymethod.borrow_mut">Read more</a></p>
</div></div><h3 id='impl-Any' class='impl'><code class='in-band'>impl<T> <a class="trait" href="../../std/any/trait.Any.html" title="trait std::any::Any">Any</a> for T <span class="where fmt-newline">where<br> T: 'static + ?<a class="trait" href="../../std/marker/trait.Sized.html" title="trait std::marker::Sized">Sized</a>, </span></code><a href='#impl-Any' class='anchor'></a><a class='srclink' href='../../src/core/any.rs.html#100-102' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.type_id' class="method hidden"><code id='type_id.v'>fn <a href='../../std/any/trait.Any.html#tymethod.type_id' class='fnname'>type_id</a>(&self) -> <a class="struct" href="../../std/any/struct.TypeId.html" title="struct std::any::TypeId">TypeId</a></code><a class='srclink' href='../../src/core/any.rs.html#101' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Gets the <code>TypeId</code> of <code>self</code>. <a href="../../std/any/trait.Any.html#tymethod.type_id">Read more</a></p>
</div></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="../../main1.35.0.js"></script><script defer src="../../search-index.js"></script></body></html>
distrib
>
Mageia
>
7
>
armv7hl
>
media
>
core-release
>
by-pkgid
>
0c2243f8a1696816431e7210e991fa52
>
files
>
16540
