Il modo in cui normalmente includeresti uno script è con "source"

per esempio:

main.sh:

#!/bin/bash

source incl.sh

echo "The main script"

incl.sh:

echo "The included script"

L'output dell'esecuzione "./main.sh" è:

The included script
The main script

... Ora, se si tenta di eseguire quello script di shell da un'altra posizione, non è possibile trovare l'inclusione a meno che non si trovi nel proprio percorso.

Qual è un buon modo per assicurarsi che il tuo script sia in grado di trovare lo script include, specialmente se, ad esempio, lo script deve essere portatile?

Tendo a rendere i miei script tutti relativi l'uno rispetto all'altro. In questo modo posso usare dirname:

#!/bin/sh

my_dir="$(dirname "$0")"

"$my_dir/other_script.sh"

So di essere in ritardo alla festa, ma questo dovrebbe funzionare indipendentemente da come avvii lo script e usi esclusivamente i builtin:

DIR="${BASH_SOURCE%/*}"
if [[ ! -d "$DIR" ]]; then DIR="$PWD"; fi
. "$DIR/incl.sh"
. "$DIR/main.sh"

. Il comando (punto) è un alias di source , $PWDè il percorso per la directory di lavoro, BASH_SOURCEè una variabile di matrice i cui membri sono i nomi dei file di origine, ${string%substring}elimina la corrispondenza più breve di $ sottostringa dal retro di $ string

Un'alternativa a:

scriptPath=$(dirname $0)

è:

scriptPath=${0%/*}

.. il vantaggio è di non avere la dipendenza da dirname, che non è un comando integrato (e non sempre disponibile negli emulatori)

Se si trova nella stessa directory è possibile utilizzare dirname $0:

#!/bin/bash

source $(dirname $0)/incl.sh

echo "The main script"

Penso che il modo migliore per farlo sia usare la maniera di Chris Boran, MA dovresti calcolare MY_DIR in questo modo:

#!/bin/sh
MY_DIR=$(dirname $(readlink -f $0))
$MY_DIR/other_script.sh

Per citare le pagine man per readlink:

readlink - display value of a symbolic link

...

  -f, --canonicalize
        canonicalize  by following every symlink in every component of the given 
        name recursively; all but the last component must exist

Non ho mai riscontrato un caso d'uso in cui MY_DIRnon è stato calcolato correttamente. Se accedi al tuo script tramite un collegamento simbolico nel tuo $PATHfunziona.

Una combinazione delle risposte a questa domanda fornisce la soluzione più solida.

Ha funzionato per noi negli script di livello di produzione con un grande supporto di dipendenze e struttura delle directory:

#! / Bin / bash

# Percorso completo dello script corrente
THIS = `readlink -f" $ {BASH_SOURCE [0]} "2> / dev / null || echo $ 0`

# La directory in cui risiede lo script corrente
DIR = `dirname" $ ​​{THIS} "`

# 'Punto' significa 'fonte', cioè 'include':
. "$ DIR / compile.sh"

Il metodo supporta tutti questi:

• Spazi nel percorso
• Link (via readlink)
• ${BASH_SOURCE[0]} è più robusto di $0

SRC=$(cd $(dirname "$0"); pwd)
source "${SRC}/incl.sh"

Funziona anche se lo script è di provenienza:

source "$( dirname "${BASH_SOURCE[0]}" )/incl.sh"

1. Più pulito

Ho esplorato quasi tutti i suggerimenti ed ecco il più ordinato che ha funzionato per me:

script_root=$(dirname $(readlink -f $0))

Funziona anche quando lo script è collegato a una $PATHdirectory.

Guardalo in azione qui: https://github.com/pendashteh/hcagent/blob/master/bin/hcagent

2. Il più cool

# Copyright https://stackoverflow.com/a/13222994/257479
script_root=$(ls -l /proc/$$/fd | grep "255 ->" | sed -e 's/^.\+-> //')

Questo è in realtà da un'altra risposta in questa stessa pagina, ma lo sto aggiungendo anche alla mia risposta!

2. Il più affidabile

In alternativa, nel raro caso in cui quelli non funzionassero, ecco l'approccio a prova di proiettile:

# Copyright http://stackoverflow.com/a/7400673/257479
myreadlink() { [ ! -h "$1" ] && echo "$1" || (local link="$(expr "$(command ls -ld -- "$1")" : '.*-> \(.*\)$')"; cd $(dirname $1); myreadlink "$link" | sed "s|^\([^/].*\)\$|$(dirname $1)/\1|"); }
whereis() { echo $1 | sed "s|^\([^/].*/.*\)|$(pwd)/\1|;s|^\([^/]*\)$|$(which -- $1)|;s|^$|$1|"; } 
whereis_realpath() { local SCRIPT_PATH=$(whereis $1); myreadlink ${SCRIPT_PATH} | sed "s|^\([^/].*\)\$|$(dirname ${SCRIPT_PATH})/\1|"; } 

script_root=$(dirname $(whereis_realpath "$0"))

Puoi vederlo in azione nella taskrunnerfonte: https://github.com/pendashteh/taskrunner/blob/master/bin/taskrunner

Spero che questo aiuti qualcuno là fuori :)

Inoltre, ti preghiamo di lasciarlo come commento se uno non ha funzionato per te e menzionare il tuo sistema operativo ed emulatore. Grazie!

Devi specificare la posizione degli altri script, non c'è altro modo per aggirarlo. Consiglierei una variabile configurabile nella parte superiore del tuo script:

#!/bin/bash
installpath=/where/your/scripts/are

. $installpath/incl.sh

echo "The main script"

In alternativa, puoi insistere sul fatto che l'utente mantenga una variabile di ambiente che indica dove si trova la home del tuo programma, come PROG_HOME o somesuch. Questo può essere fornito automaticamente all'utente creando uno script con tali informazioni in /etc/profile.d/, che verrà fornito ogni volta che un utente accede.

Suggerirei di creare uno script setenv il cui unico scopo è fornire posizioni per vari componenti nel sistema.

Tutti gli altri script avrebbero quindi origine questo script in modo che tutte le posizioni siano comuni a tutti gli script utilizzando lo script setenv.

Questo è molto utile quando si eseguono cronjobs. Si ottiene un ambiente minimo quando si esegue cron, ma se si rendono tutti gli script cron che includono prima lo script setenv, si è in grado di controllare e sincronizzare l'ambiente in cui si desidera eseguire cronjobs.

Abbiamo usato una tale tecnica sulla nostra scimmia di costruzione che è stata utilizzata per l'integrazione continua in un progetto di circa 2.000 kSLOC.

La risposta di Steve è sicuramente la tecnica corretta, ma dovrebbe essere rifattorizzata in modo che la variabile installpath sia in uno script di ambiente separato in cui vengono fatte tutte queste dichiarazioni.

Quindi tutti gli script generano tale script e dovrebbero cambiare il percorso di installazione, è necessario solo modificarlo in una posizione. Rende le cose più, ehm, a prova di futuro. Dio odio quella parola! (-:

A proposito, dovresti davvero fare riferimento alla variabile usando $ {installpath} quando la usi nel modo mostrato nel tuo esempio:

. ${installpath}/incl.sh

Se le parentesi graffe vengono lasciate fuori, alcune shell tenteranno di espandere la variabile "installpath / incl.sh"!

Shell Script Loader è la mia soluzione per questo.

Fornisce una funzione chiamata include () che può essere richiamata più volte in molti script per fare riferimento a un singolo script ma caricherà lo script una sola volta. La funzione può accettare percorsi completi o percorsi parziali (lo script viene cercato in un percorso di ricerca). Viene inoltre fornita una funzione simile denominata load () che carica incondizionatamente gli script.

Funziona con bash , ksh , pd ksh e zsh con script ottimizzati per ognuno di essi; e altre shell genericamente compatibili con lo sh originale come ash , dash , sh heirloom , ecc., attraverso uno script universale che ottimizza automaticamente le sue funzioni a seconda delle funzionalità che la shell può fornire.

[Esempio imminente]

start.sh

Questo è uno script iniziale opzionale. Inserire qui i metodi di avvio è solo una comodità e può essere inserito nello script principale. Questo script non è inoltre necessario se gli script devono essere compilati.

#!/bin/sh

# load loader.sh
. loader.sh

# include directories to search path
loader_addpath /usr/lib/sh deps source

# load main script
load main.sh

main.sh

include a.sh
include b.sh

echo '---- main.sh ----'

# remove loader from shellspace since
# we no longer need it
loader_finish

# main procedures go from here

# ...

cenere

include main.sh
include a.sh
include b.sh

echo '---- a.sh ----'

b.sh

include main.sh
include a.sh
include b.sh

echo '---- b.sh ----'

produzione:

---- b.sh ----
---- a.sh ----
---- main.sh ----

La cosa migliore è che gli script basati su di esso possono anche essere compilati per formare un singolo script con il compilatore disponibile.

Ecco un progetto che lo utilizza: http://sourceforge.net/p/playshell/code/ci/master/tree/ . Può essere eseguito in modo portabile con o senza compilare gli script. La compilazione per produrre un singolo script può anche accadere ed è utile durante l'installazione.

Ho anche creato un prototipo più semplice per qualsiasi partito conservatore che potrebbe voler avere una breve idea di come funziona uno script di implementazione: https://sourceforge.net/p/loader/code/ci/base/tree/loader-include-prototype .bash . È piccolo e chiunque può semplicemente includere il codice nel proprio script principale se lo desidera se il suo codice è destinato a funzionare con Bash 4.0 o versioni successive e inoltre non lo utilizza eval.

Metti personalmente tutte le librerie in una libcartella e usa una importfunzione per caricarle.

struttura delle cartelle

script.sh Contenuti

# Imports '.sh' files from 'lib' directory
function import()
{
  local file="./lib/$1.sh"
  local error="\e[31mError: \e[0mCannot find \e[1m$1\e[0m library at: \e[2m$file\e[0m"
  if [ -f "$file" ]; then
     source "$file"
    if [ -z $IMPORTED ]; then
      echo -e $error
      exit 1
    fi
  else
    echo -e $error
    exit 1
  fi
}

Nota che questa funzione di importazione dovrebbe essere all'inizio del tuo script e quindi puoi facilmente importare le tue librerie in questo modo:

import "utils"
import "requirements"

Aggiungi una sola riga nella parte superiore di ogni libreria (ad esempio utils.sh):

IMPORTED="$BASH_SOURCE"

Ora hai accesso alle funzioni all'interno utils.she requirements.shdascript.sh

TODO: scrivere un linker per creare un singolo shfile

L'uso di source o $ 0 non ti darà il vero percorso del tuo script. È possibile utilizzare l'id di processo dello script per recuperare il suo percorso reale

ls -l       /proc/$$/fd           | 
grep        "255 ->"            |
sed -e      's/^.\+-> //'

Sto usando questo script e mi è sempre servito bene :)

Ho messo tutti i miei script di avvio in una directory .bashrc.d. Questa è una tecnica comune in luoghi come /etc/profile.d, ecc.

while read file; do source "${file}"; done <<HERE
$(find ${HOME}/.bashrc.d -type f)
HERE

Il problema con la soluzione utilizzando globbing ...

for file in ${HOME}/.bashrc.d/*.sh; do source ${file};done

... è che potresti avere un elenco di file "troppo lungo". Un approccio come ...

find ${HOME}/.bashrc.d -type f | while read file; do source ${file}; done

... funziona ma non cambia l'ambiente come desiderato.

Certo, a ciascuno il suo, ma penso che il blocco sottostante sia piuttosto solido. Credo che ciò implichi il modo "migliore" per trovare una directory e il modo "migliore" per chiamare un altro script bash:

scriptdir=`dirname "$BASH_SOURCE"`
source $scriptdir/incl.sh

echo "The main script"

Quindi questo potrebbe essere il modo "migliore" per includere altri script. Questo si basa su un'altra "migliore" risposta che dice a uno script bash dove è memorizzato

Questo dovrebbe funzionare in modo affidabile:

source_relative() {
 local dir="${BASH_SOURCE%/*}"
 [[ -z "$dir" ]] && dir="$PWD"
 source "$dir/$1"
}

source_relative incl.sh

dobbiamo solo scoprire la cartella in cui sono memorizzati i nostri incl.sh e main.sh; basta cambiare main.sh con questo:

main.sh

#!/bin/bash

SCRIPT_NAME=$(basename $0)
SCRIPT_DIR="$(echo $0| sed "s/$SCRIPT_NAME//g")"
source $SCRIPT_DIR/incl.sh

echo "The main script"

Secondo il man hierluogo adatto per lo script include è/usr/local/lib/

/ Usr / local / lib

File associati a programmi installati localmente.

Personalmente preferisco /usr/local/lib/bash/includesper include. Esiste una libreria bash-helper per includere le librerie in quel modo:

#!/bin/bash

. /usr/local/lib/bash/includes/bash-helpers.sh

include api-client || exit 1                   # include shared functions
include mysql-status/query-builder || exit 1   # include script functions

# include script functions with status message
include mysql-status/process-checker; status 'process-checker' $? || exit 1
include mysql-status/nonexists; status 'nonexists' $? || exit 1

Puoi anche usare:

PWD=$(pwd)
source "$PWD/inc.sh"