Como definir um valor com nova linha pelo comando `env`?

Seu entendimento está incorreto. Quando você armazena o conteúdo "hello\nworld"em uma variável, o \né interpretado literalmente. Somente se você invocar ferramentas como printfou echocom -esinalizador, elas expandirão essas sequências de barra invertida ao imprimir no console.

No seu caso, você deseja passar a variável para o ambiente com o caractere de nova linha expandido, sugira usar o estilo ANSI C citando no bash para isso

env FOO=$'hello\nworld' ruby -e 'puts ENV["FOO"]'

Ou se a portabilidade for um problema, uma solução trivial é colocar essas novas linhas onde você quiser

f="hello
world"

env FOO="$f" ruby -e 'puts ENV["FOO"]'

GNU's e FreeBSD's env têm uma -Sopção ("split")[1] que divide seu argumento em espaços e então interpreta muitos escapes nas strings resultantes, incluindo, mas não limitado a \n:

$ env -S 'foo=bar\nquux printenv foo'
bar
quux
$ env -S 'foo=bar\nquux' printenv foo
bar
quux

[1] seu uso principal é para #! ...linhas shebang, mas pode ser usado em outros lugares onde uma linha de comando é esperada, mas um analisador ad-hoc em vez de um shell é usado para interpretá-lo, como a -eopção da maioria dos baseados em vte terminais.

O envcomando, quando executado, recebe vários argumentos --assim como qualquer comando-- da execve()chamada do sistema. O processo que o executa fará algo como:

execve("/path/to/env", ["env", "-options", "var=value", "cmd", "arg"], environ);

E env, por sua vez, fará (geralmente no mesmo processo):

execve("/path/to/cmd", ["cmd", "arg"], modified_environ);

onde modified_environé environmas com var=valueanexado a ele, ou se já havia uma ou mais strings começando com var=in environ, a primeira delas (pelo menos) substituída por var=value.

Esses argumentos são matrizes de bytes terminadas em NUL, portanto, os únicos bytes que eles não podem conter são o byte NUL. O mesmo se aplica a variáveis ​​de ambiente cujo nome nem valor podem conter bytes NUL.

env, na inicialização, processa seus argumentos do primeiro ao último.

Aqueles no início que começam com -seriam tomados como opções.

-sozinho também é tratado como a forma antiga de -iignorar environ.

As opções seguintes (ou --que podem ser usadas para marcar o fim das opções) que contenham pelo menos uma =serão consideradas como env var strings (para colocar modified_environacima). O primeiro argumento não opcional que não contém um =caractere é considerado como o nome do comando (que será passado como primeiro argumento para o comando e também usado para pesquisar o caminho do executável em $PATH).

Qualquer argumento depois disso será passado como argumentos para o comando, mesmo que comece com -ou contenha =caracteres.

Portanto, por envsi só, apenas os caracteres -e =são especiais; -somente durante o processamento da opção e =somente até que o nome do comando seja localizado.

Para poder passar um nome de variável de ambiente que comece com -ou um nome de comando que comece com -, você pode simplesmente usar --:

execve("/usr/bin/env", ["env", "--", "-var-=value", "cmd"], environ);

execve("/usr/bin/env", ["env", "--", "-cmd-"], environ);

Com várias envimplementações, -seguir sozinho --ainda não seria considerado como um nome de comando. Então, se você quisesse chamar o comando chamado -, você precisaria passar pelo menos uma variável de ambiente antes:

execve("/usr/bin/env", ["env", "--", "dummy=", "-", "args"], environ);

(ou use /path/to/-ou ./-em vez de -e bypath $PATHprocure por esse -comando).

envno entanto, não permite que você execute um comando cujo nome contenha =caracteres e não possa passar uma string sem =caracteres no arquivo modified_environ. Não há como escapar do =personagem nesses casos.

Mas no seu caso de env FOO=LITERAL_STRING, não há LITERAL_STRINGoutro caractere além do byte NUL que seria um problema no que diz respeito a envsi mesmo.

Agora, ao escrever código em algum idioma para executar esse envcomando, provavelmente haverá caracteres nesse idioma que não podem ser inseridos literalmente.

Por exemplo, em perl, você faria:

exec "env", "--", "-text-=hello\nworld\n", "printenv", "--", "-text-";

Com o caractere de nova linha expresso \nentre aspas duplas, embora você também possa fazer:

exec qw(env --), q(-text-=hello
world
), qw(printenv -- -text-);

Para passar strings que contêm caracteres de nova linha.

Na sintaxe de linguagens de shell do tipo Bourne, o caractere de nova linha não é especial quando está entre aspas simples ou duplas (como para os operadores ou aspas de q(...)) , então você pode fazer:qq(...)perl

exec env -- "-text-=hello
world
" printenv -- -text

Seria uma questão diferente no shell C ou no shell rc, onde "..."não há um operador de cotação.

Seu env FOO=LITERAL_STRING ruby -e 'puts ENV["FOO"]'se parece com o código em uma linguagem shell. Essa sintaxe seria válida com a maioria dos shells, pois praticamente todos entendem o espaço como delimitadores de palavras e '...'como um operador de aspas.

Quando você omite execno início, os shells executam o comando em um processo filho e, em seguida, esperam que esse processo termine ou seja suspenso.

Se env FOO=LITERAL_STRING ruby -e 'puts ENV["FOO"]'for para um idioma que não permite inserir caracteres de nova linha literalmente (provavelmente não um shell) nem usar alguma forma de codificação ( \n, %0a, 
...), mas aparentemente suporta '...'como um operador de citação como a maioria dos shells, além do BSD env -Struque já sugerido por @UncleBilly , você pode invocar um interpretador ou uma linguagem que pode executar comandos e permite especificar uma nova linha de alguma forma codificada, como perl, ruby, python, ksh93, zsh, bash...

Já que você já tem ruby:

ruby -e 'exec "env", "FOO=a\n\n\nb", *ARGV' -- ruby -e 'puts ENV["FOO"]'

Mas qualquer linguagem de programação descendente, inclusive, rubypode definir variáveis ​​de ambiente por si só, então você não precisa env:

ruby -e 'ENV["FOO"]="a\n\n\nb"; exec *ARGV' -- ruby -e 'puts ENV["FOO"]'

Use uma nova linha literal no valor:

$ env FOO="hello                                  
world" ruby -e 'puts ENV["FOO"]'

Resultado:

hello
world

Se você tiver uma string com \na qual deseja converter em uma nova linha real, use um utilitário como printf, assim como faria em qualquer outro lugar:

$ env FOO="$(printf "%b" 'hello\nworld')" ruby -e 'puts ENV["FOO"]'

hello
world

envnão é especial a esse respeito (na verdade, envsó vê a nova linha real, porque é expandida antes do início do processo).