|
Size: 1704
Comment: Clarify FAQ#12
|
Size: 1869
Comment:
|
| Deletions are marked like this. | Additions are marked like this. |
| Line 2: | Line 2: |
| == How do I invoke a bash command from a non-shell application? == | == How do I invoke a shell command from a non-shell application? == |
| Line 4: | Line 4: |
| You can use `bash`'s `-c` option to run the bash process with the sole purpose of executing a short bit of script: | You can use the shell's `-c` option to run the shell with the sole purpose of executing a short bit of script: |
| Line 6: | Line 6: |
| bash -c 'echo "Hi! This is a short script."' | sh -c 'echo "Hi! This is a short script."' |
| Line 9: | Line 9: |
| This is usually pretty useless without a means if passing data to it. The best way to pass bits of data to your bash environment is to pass it as positional arguments. When invoking bash this way, we can set the positional parameters like this: | This is usually pretty useless without a means of passing data to it. The best way to pass bits of data to your shell is to pass them as positional arguments: |
| Line 11: | Line 11: |
| bash -c 'echo "Hi! This short script was ran with the arguments: $@"' -- "foo" "bar" | sh -c 'echo "Hi! This short script was run with the arguments: $@"' -- "foo" "bar" |
| Line 14: | Line 14: |
| Notice the -- before the actual positional parameters. The first argument you pass to the bash process (that isn't the argument to the `-c` option) will be placed in `$0`! Positional parameters start at `$1`, so we put a little placeholder in `$0`. This can be anything you like; in the example, we use the generic `--`. | Notice the -- before the actual positional parameters. The first argument you pass to the shell process (that isn't the argument to the `-c` option) will be placed in `$0`. Positional parameters start at `$1`, so we put a little placeholder in `$0`. This can be anything you like; in the example, we use the generic `--`. |
| Line 16: | Line 16: |
| Alternatively, if your non-shell application allows you to set environment variables; you can do this, and then read them using normal bash variables of the same name as the environment variables. This technique is used often in shell scripting, when trying to have a non-shell CLI utility execute some bash code, such as with `find(1)`: |
This technique is used often in shell scripting, when trying to have a non-shell CLI utility execute some bash code, such as with [[UsingFind|find(1)]]: |
| Line 23: | Line 21: |
| Here, we ask `find(1)` to run the `bash` command for every `*.bar` file it finds, passing it to the `bash` process as the first positional parameter. The `bash` process runs the `mv` command after doing some `Parameter Expansion` on the first positional parameter in order to rename our file's extension from `bar` to `jpg`. | Here, we ask `find` to run the `bash` command for every `*.bar` file it finds, passing it to the `bash` process as the first positional parameter. The `bash` process runs the `mv` command after doing some [[BashFAQ/073|Parameter Expansion]] on the first positional parameter in order to rename our file's extension from `bar` to `jpg`. Alternatively, if your non-shell application allows you to set environment variables, you can do that, and then read them using normal variables of the same name. Similarly, suppose a program (e.g. a file manager) lets you define an external command that an argument will be appended to, but you need that argument somewhere in the middle. In that case: {{{ #!/bin/sh sh -c 'foo "$1" bar' }}} ---- CategoryShell |
How do I invoke a shell command from a non-shell application?
You can use the shell's -c option to run the shell with the sole purpose of executing a short bit of script:
sh -c 'echo "Hi! This is a short script."'
This is usually pretty useless without a means of passing data to it. The best way to pass bits of data to your shell is to pass them as positional arguments:
sh -c 'echo "Hi! This short script was run with the arguments: $@"' -- "foo" "bar"
Notice the -- before the actual positional parameters. The first argument you pass to the shell process (that isn't the argument to the -c option) will be placed in $0. Positional parameters start at $1, so we put a little placeholder in $0. This can be anything you like; in the example, we use the generic --.
This technique is used often in shell scripting, when trying to have a non-shell CLI utility execute some bash code, such as with find(1):
find /foo -name '*.bar' -exec bash -c 'mv "$1" "${1%.bar}.jpg"' -- {} \;Here, we ask find to run the bash command for every *.bar file it finds, passing it to the bash process as the first positional parameter. The bash process runs the mv command after doing some Parameter Expansion on the first positional parameter in order to rename our file's extension from bar to jpg.
Alternatively, if your non-shell application allows you to set environment variables, you can do that, and then read them using normal variables of the same name.
Similarly, suppose a program (e.g. a file manager) lets you define an external command that an argument will be appended to, but you need that argument somewhere in the middle. In that case:
#!/bin/sh
sh -c 'foo "$1" bar'