Posso "exportar" funções no bash?

source some_file

some_file:

doit ()
{
  echo doit $1
}
export TEST=true

Se eu for fonte de algum arquivo, a função "doit" e a variável TEST estarão disponíveis na linha de comando. Mas executando este script:

script.sh:

#/bin/sh
echo $TEST
doit test2

Retornará o valor de TEST, mas gerará um erro sobre a função desconhecida "doit".

Também posso "exportar" a função ou tenho que usar algum_arquivo no script.sh para usar a função lá?

No Bash, você pode exportar definições de funções para sub-shell com

export -f function_name

Por exemplo, você pode tentar este exemplo simples:

./script1:

    #!/bin/bash

    myfun() {
        echo "Hello!"
    }

    export -f myfun
    ./script2

./script2:

    #!/bin/bash

    myfun

Então, se você ligar ./script1, verá a saída Olá! .

"Exportar" uma função usando export -fcria uma variável de ambiente com o corpo da função. Considere este exemplo:

$ fn(){ echo \'\"\ \ \$; }
$ export -f fn
$ sh -c printenv\ fn
() {  echo \'\"\ \ \$
}

Isso significa que apenas o shell (apenas Bash?) Poderá aceitar a função. Você também pode definir a função, pois o Bash considera apenas os envvars começando com () {como function:

$ fn2='() { echo Hi;}' sh -c fn2
Hi
$ fn3='() {' sh -c :
sh: fn3: line 1: syntax error: unexpected end of file
sh: error importing function definition for `fn3'

Se você precisar "exportar" essa variável pelo SSH, precisará realmente da função como uma string. Isso pode ser feito com a opção de impressão ( -p) para funções ( -f) do declarebuilt-in:

$ declare -pf fn
fn () 
{ 
    echo \'\"\ \ \$
}

Isso é muito útil se você tiver um código mais complexo que precise ser executado no SSH. Considere o seguinte script fictício:

#!/bin/bash
remote_main() {
   local dest="$HOME/destination"

   tar xzv -C "$dest"
   chgrp -R www-data "$dest"
   # Ensure that newly written files have the 'www-data' group too
   find "$dest" -type d -exec chmod g+s {} \;
}
tar cz files/ | ssh user@host "$(declare -pf remote_main); remote_main"

Com base na resposta de @ Lekensteyn ...

Se você usá- declare -pflo, exibirá todas as funções definidas anteriormente no shell atual para STDOUT.

Nesse ponto, você pode redirecionar o STDOUT para onde quiser e, com efeito, colocar as funções definidas anteriormente onde quiser.

A resposta a seguir os colocará em uma variável. Em seguida, repetimos essa variável mais a invocação da função que queremos executar no novo shell que é gerado como um novo usuário. Fazemos isso usando sudoo comutador -u(aka. user) E simplesmente executando o Bash (que receberá o STDOUT canalizado como a entrada a ser executada).

Como sabemos que estamos passando de um shell Bash para um shell Bash, sabemos que o Bash interpretará corretamente as funções definidas pelos shells anteriores. A sintaxe deve estar correta desde que nos movamos entre um shell Bash da mesma versão para um novo shell Bash da mesma versão.

YMMV se você estiver se deslocando entre diferentes shells ou entre sistemas que podem ter versões diferentes do Bash.

#!/bin/bash
foo() {
  echo "hello from `whoami`"
}

FUNCTIONS=`declare -pf`; echo "$FUNCTIONS ; foo" | sudo -u otheruser bash
# $./test.sh
# hello from otheruser

Você não pode exportar funções, não da maneira que está descrevendo. O shell carregará o ~/.bashrcarquivo apenas no início de um shell interativo (procure "Invocação" na página de manual do bash ).

O que você pode fazer é criar uma "biblioteca" que é carregada quando você inicia o programa:

source "$HOME/lib/somefile"

E coloque suas funções e configurações não interativas lá.

eval "$(declare -F | sed -e 's/-f /-fx /')"exportará todas as funções.

Faço isso muito antes de iniciar um shell interativo em um script para me permitir depurar e trabalhar no contexto do script enquanto uso suas funções e variáveis.

Exemplo:

eval "$(declare -F | sed -e 's/-f /-fx /')"
export SOME IMPORTANT VARIABLES AND PASSWORDS
bash -i

As funções não são exportadas para subprocessos. É por isso que existem arquivos denominados .kshrc ou .bashrc: para definir funções que também devem estar disponíveis em subshells.

Se estiver executando um script, os scripts. * Shrc normalmente não são originados. Você teria que codificar isso explicitamente, como em . ~/.kshrc.

Bem, eu sou novo no Linux, mas você pode tentar isso. Em algum arquivo, vamos chamá-lo de 'tmp / general', você cria sua função:

func1(){
   echo "func from general"
}

No seu script de shell, adicione:

. /tmp/general

e corra:

func1

Você vai ter na tela: func from general.

declare -x -f NAME

Mais informações

-f restringe a ação ou exibe os nomes e definições das funções
-x para exportar NAMEs