description

# start static method

Future<Process> start(

1. String executable,
2. List<String> arguments, {
3. String? workingDirectory,
4. Map<String, String>? environment,
5. bool includeParentEnvironment = true,
6. bool runInShell = false,
7. ProcessStartMode mode = ProcessStartMode.normal,

})

Starts a process running the `executable` with the specified `arguments`.

Returns a `Future<Process>` that completes with a Process instance when the process has been successfully started. That Process object can be used to interact with the process. If the process cannot be started the returned Future completes with an exception.

Using an absolute path for `executable` is recommended since resolving the `executable` path is platform-specific. On Windows, both any `PATH` set in the `environment` map parameter and the path set in `workingDirectory` parameter are ignored for the purposes of resolving the `executable` path.

Use `workingDirectory` to set the working directory for the process. Note that the change of directory occurs before executing the process on some platforms, which may have impact when using relative paths for the executable and the arguments.

Use `environment` to set the environment variables for the process. If not set the environment of the parent process is inherited. Currently, only US-ASCII environment variables are supported and errors are likely to occur if an environment variable with code-points outside the US-ASCII range is passed in.

If `includeParentEnvironment` is `true`, the process's environment will include the parent process's environment, with `environment` taking precedence. Default is `true`.

If `runInShell` is `true`, the process will be spawned through a system shell. On Linux and OS X, `/bin/sh` is used, while `%WINDIR%\system32\cmd.exe` is used on Windows.

NOTE: On Windows, if `executable` is a batch file ('.bat' or '.cmd'), it may be launched by the operating system in a system shell regardless of the value of `runInShell`. This could result in arguments being parsed according to shell rules. For example:

    void main() async {
      // Will launch notepad.
      Process.start('test.bat', ['test&notepad.exe']);
    }

Users must read all data coming on the stdout and stderr streams of processes started with `Process.start`. If the user does not read all data on the streams the underlying system resources will not be released since there is still pending data.

The following code uses `Process.start` to grep for `main` in the file `test.dart` on Linux.

    var process = await Process.start('grep', ['-i', 'main', 'test.dart']);
    stdout.addStream(process.stdout);
    stderr.addStream(process.stderr);

If `mode` is ProcessStartMode.normal (the default) a child process will be started with `stdin`, `stdout` and `stderr` connected to its parent. The parent process will not exit so long as the child is running, unless exit is called by the parent. If exit is called by the parent then the parent will be terminated but the child will continue running.

If `mode` is ProcessStartMode.detached a detached process will be created. A detached process has no connection to its parent, and can keep running on its own when the parent dies. The only information available from a detached process is its `pid`. There is no connection to its `stdin`, `stdout` or `stderr`, nor will the process' exit code become available when it terminates.

If `mode` is ProcessStartMode.detachedWithStdio a detached process will be created where the `stdin`, `stdout` and `stderr` are connected. The creator can communicate with the child through these. The detached process will keep running even if these communication channels are closed or the parent dies. The process' exit code will not become available when it terminated.

The default value for `mode` is `ProcessStartMode.normal`.

## Implementation

    external static Future<Process> start(
      String executable,
      List<String> arguments, {
      String? workingDirectory,
      Map<String, String>? environment,
      bool includeParentEnvironment = true,
      bool runInShell = false,
      ProcessStartMode mode = ProcessStartMode.normal,
    });