Existe uma maneira de impedir que o bash analise o código zsh?

Você pode definir alguns aliases ifbash, ifzsh, endifcomo:

alias if{ba,z}sh=':||:<<"endif"' endif=
if [[ -n $BASH_VERSION ]]; then
  alias ifbash=
  shopt -s expand_aliases
elif [[ -n $ZSH_VERSION ]]; then
  alias ifzsh=
fi

ifbash
f() { echo bash; }
endif

ifzsh
f() echo ${(q+):-zsh}
endif

:||:<<"MARKER"... MARKERé uma maneira idiomática de comentar uma seção de código. É como :<<"MARKER"executar o :noop embutido com um here-doc no stdin, mas com o extra :||, o segundo :não é executado e o here-document nem mesmo foi criado, apenas analisado.

Tenha em atenção que o endifnão deve ser recuado nem seguido de nada; deve compor toda a linha. ifbash/ ifzshs não podem ser aninhados (não que isso faça sentido aqui).

BTW, manparece estar fazendo a análise de citação na MANPAGERvariável de ambiente por si só (em oposição a invocar um shell, quanto mais seu $SHELL) e não parece suportar a $'...'forma de aspas, portanto, usando o q+sinalizador de expansão de parâmetro que pode usar esse formulário de aspas para algumas strings não está correto. Use qq, em vez disso, que usa aspas simples (e \'fora das aspas para escapar das aspas simples¹) como na sua versão do bash.

^{¹ a menos que a rcquotesopção esteja habilitada, caso em que ''à la rcé usado. Adicionar emulate -L zshno início de sua função, para ter um conjunto de opções locais sãs nessa função, não ajudaria, pois a opção precisa ser desativada no momento em que a função é definida, não executada.}

O Bash ainda precisa analisar o arquivo inteiro, mesmo que não execute todas as linhas. Normalmente, você não pode ocultar erros de sintaxe por trás de uma condicional, apenas erros de tempo de execução.

Em seu lugar, eu voltaria a usar arquivos separados .zshrce .bashrc. Em seguida, colocaria as funções comuns em um terceiro arquivo (garantindo que esse arquivo usasse apenas sintaxe compatível com ambos) e o originaria de ambos .zshrce .bashrc.

Na minha opinião, este é o melhor dos mundos:

1. As funções somente zsh entrariam .zshrconde nunca seriam lidas pelo bash. Da mesma forma, coisas somente bash vivem em arquivos .bashrc.
2. As funções comuns teriam uma única definição, então você não precisa manter duas cópias (e elas estariam em um arquivo que é explicitamente cross-shell, então é menos provável que você esqueça de mantê-lo compatível com ambos).
3. Cada shell teria seu arquivo de inicialização com o nome padrão para que seja mais claro e óbvio onde eles estão configurados, e cada um declararia explicitamente que também usa o arquivo comum.
4. Não há necessidade de manter a sintaxe do shell dentro das strings do shell (o que se torna doloroso quando as citações são mais complexas do que no seu exemplo, perde o realce da sintaxe, etc etc).

Qualquer shell tem que analisar o código dentro do condicional para encontrar a parte onde o condicional termina, mesmo que por nenhum outro motivo.

Além de colocar o código específico do shell em outro arquivo ou em uma string para eval, você também pode usar um here-doc para ocultá-lo e sourceo here-doc diretamente. Praticamente o mesmo que usar eval, mas um here-doc tem a vantagem de que o código interno pode conter aspas simples e duplas sem problemas irritantes de escape.

Por exemplo, este script diz hello, 'bar', I'm zshse executado com zsh e gera um erro no Bash:

if [[ -n $ZSH_VERSION ]]; then
    source /dev/stdin <<'EOF'
foo() {
   echo "hello, '$1', I'm zsh"
}
EOF
fi

foo bar

Não tenho certeza se source /dev/stdinfunciona com todos os shells e sistemas. (E sim, sourceé um nome não padrão para o .builtin, mas deve funcionar em Bash e zsh, e de qualquer forma o comando só precisa existir no shell que roda dentro do condicional.)

Outros já apontaram porque o bash está analisando sintaticamente o conteúdo do $shell == zshcondicional.

No zsh você pode usar

  mans() MANPAGER="less -+MFX -p ${(q+)1}" man $2

considerando que isso não é uma sintaxe bash legal (uma função precisaria de {}).

No entanto, no zsh, você também pode usar a sintaxe POSIX para funções, o que manterá os dois shells felizes:

elif [[ $shell == zsh ]]; then
  mans() {
    MANPAGER="less -+MFX -p ${(q+)1}" man $2
  }
fi

Além disso, eu geralmente os alteraria [[para uma sintaxe única [, para que o arquivo não fosse interrompido se executado em outros shells (como dash) que não suportam [[:

[ -n "$BASH_VERSION" ] && shell=bash
[ -n "$ZSH_VERSION" ] && shell=zsh

# Search man page for string
if [ "$shell" = bash ]; then
  mans() {
    local q="\'"
    local q_pattern="'${1//$q/$q\\$q$q}'"
    local MANPAGER="less -+MFX -p $q_pattern"
    man "$2"
  }
elif [ "$shell" = zsh ]; then
  mans() {
    MANPAGER="less -+MFX -p ${(q+)1}" man $2
  }
fi

O método sugerido por @ilkkachu funcionou:

# Search man page for string
if [[ $shell == bash ]]; then
  mans() {
    local q="\'"
    local q_pattern="'${1//$q/$q\\$q$q}'"
    local MANPAGER="less -+MFX -p $q_pattern"
    man "$2"
  }
elif [[ $shell == zsh ]]; then
  mansfunc='mans() MANPAGER="less -+MFX -p ${(q+)1}" man $2'
  eval "$mansfunc"
fi