Действительно ли круглые скобки помещают команду в подшелл?

Судя по тому, что я читал, выполнение команды в скобках должно происходить в подпроцессе, аналогично выполнению скрипта. Если это правда, как он видит переменную x, если x не экспортирована?

x=1

Выполнение (echo $x) в командной строке возвращает 1

Выполнение echo $x в скрипте возвращает ничего, как и ожидалось

Подпроцесс в начале представляет собой практически идентичную копию оригинального процесса оболочки. Внутри оболочка вызывает системный вызов fork¹, который создает новый процесс, код и память которого являются копиями². Когда создается подпроцесс, различий между ним и его родителем очень немного. В частности, у них одинаковые переменные. Даже специальная переменная $$ сохраняет одно и то же значение в подпроцессах: это идентификатор процесса оригинальной оболочки. Аналогично $PPID — это PID родителя оригинальной оболочки.

Некоторые оболочки изменяют некоторые переменные в подпроцессе. Bash ≥4.0 устанавливает BASHPID на PID процесса оболочки, который изменяется в подпроцессах. Bash, zsh и mksh обеспечивают, чтобы $RANDOM выдавал разные значения у родителя и в подпроцессе. Но кроме встроенных специальных случаев, таких как эти, все переменные имеют одно и то же значение в подпроцессе, как в оригинальной оболочке, тот же статус экспорта, тот же статус только для чтения и т.д. Все определения функций, определения псевдонимов, параметры оболочки и другие настройки также наследуются.

Подпроцесс, созданный (…), имеет те же дескрипторы файлов, что и его создатель. Некоторые другие способы создания подпроцессов изменяют некоторые дескрипторы файлов перед выполнением пользовательского кода; например, левая сторона канала выполняется в подпроцессе³ с подключенным стандартным выводом к каналу. Подпроцесс также начинает с той же текущей директории, с той же маской сигналов и т.д. Одним из немногих исключений является то, что подпроцессы не наследуют пользовательские ловушки: игнорируемые сигналы (trap '' SIGNAL) остаются игнорируемыми в подпроцессе, но другие ловушки (trap CODE SIGNAL) сбрасываются на действие по умолчанию⁴.

Таким образом, подпроцесс отличается от выполнения скрипта. Скрипт — это отдельная программа. Эта отдельная программа может случайно быть также скриптом, который выполняется тем же интерпретатором, что и родитель, но это совпадение не дает отдельной программе никакой специальной видимости на внутренние данные родителя. Неэкспортированные переменные — это внутренние данные, поэтому, когда интерпретатор для дочернего скрипта оболочки выполняется, он не видит эти переменные. Экспортированные переменные, т.е. переменные окружения, передаются выполняемым программам.

Таким образом:

x=1
(echo $x)

выводит 1, потому что подпроцесс является репликацией оболочки, которая его создала.

x=1
sh -c 'echo $x'

случайно запускает оболочку как дочерний процесс оболочки, но x на второй строке не имеет большей связи с x на второй строке, чем в

x=1
perl -le 'print $x'

или

x=1
python -c 'print x'

¹ _{Если только оболочка не оптимизирует создание подпроцессов, но эмулирует создание подпроцессов настолько, насколько это необходимо для сохранения поведения кода, который она выполняет. Ksh93 оптимизирует много, другие оболочки в основном нет.}
² _{Семантически это копии. С точки зрения реализации идет много дележа.}
³ _{Для правой стороны это зависит от оболочки.}
⁴ _{Если вы это протестируете, имейте в виду, что вещи типа $(trap) могут сообщать ловушки оригинальной оболочки. Также обратите внимание, что у многих оболочек есть ошибки в крайних случаях, связанных с ловушками. Например, ninjalj отмечает, что с bash 4.3, bash -x -c 'trap "echo ERR at \$BASH_SUBSHELL \$BASHPID" ERR; set -E; false; echo one subshell; (false); echo two subshells; ( (false) )' запускает ловушку ERR из вложенного подпроцесса в случае “двух подпроцессов”, но не ловушку ERR из промежуточного подпроцесса — параметр set -E должен распространять ловушку ERR на все подпроцессы, но промежуточный подпроцесс оптимизирован и поэтому не выполняет свою ловушку ERR.}

Очевидно, да, как говорит вся документация, команда в скобках выполняется в подпроцессе.

Подпроцесс наследует копию всех переменных родителя. Различие в том, что любые изменения, которые вы делаете в подпроцессе, не будут произведены и в родителе.

Страница man для ksh делает это немного яснее, чем для bash:

man ksh:

Команда в скобках выполняется в подпроцессе, не удаляя неэкспортированные переменные.

man bash:

(list)

список выполняется в окружении подпроцесса (см. COMMAND
EXECUTION ENVIRONMENT ниже). Присвоения переменных и
встроенные команды, которые влияют на окружение оболочки, не
остаются в действии после завершения команды.

COMMAND EXECUTION ENVIRONMENT

Оболочка имеет окружение выполнения, которое состоит из следующего:
[…] параметры оболочки, которые устанавливаются с помощью
присвоения переменных […].
Замещение команд, команды, сгруппированные в скобках, и асинхронные команды
вызываются в окружении подпроцесса, которое является дубликатом окружения оболочки, […]

Цена подпроцесса

Другой способ рассмотреть этот вопрос — посмотреть на стоимость выполнения команд в скобках. Если команды выполняются в подпроцессе, должна быть некоторая стоимость в процессорных циклах и времени. Например, две функции, которые идентичны, кроме фигурных скобок ({) и скобок ((), для инкапсуляции списка команд:

# выполняем команды в текущем контексте
foo() { 
    for i in $( seq $1 )
    do 
        { 
            let 'j = 2*i - i'
            echo "итерация $j (уровень: $BASH_SUBSHELL)"
        }
    done
}

# создаем подпроцесс для каждой итерации цикла
bar() { 
    for i in $( seq $1 )
    do 
        ( 
            let 'j = 2*i - i'
            echo "итерация $j (уровень: $BASH_SUBSHELL)"
        )
    done
}

time foo 1000
# реальное    0m0.013s

time bar 1000
# реальное    0m0.596s

Поскольку было выполнено 1000 итераций каждого цикла, стоимость создания каждого подпроцесса составила ~ 0.6 мс.

Я обнаружил, что стоимость схожа, независимо от того, выполняются ли простые или более сложные команды в подпроцессе: это фиксированная стоимость создания подпроцесса, независимо от содержимого. Это было выполнено в Bash 5.2.21.