Sposób, w jaki zwykle dołączasz skrypt, to „source”

na przykład:

main.sh:

#!/bin/bash

source incl.sh

echo "The main script"

w tym sh:

echo "The included script"

Wynikiem wykonania polecenia „./main.sh” jest:

The included script
The main script

... Teraz, jeśli spróbujesz wykonać ten skrypt powłoki z innej lokalizacji, nie będzie w stanie znaleźć dołączenia, chyba że jest na twojej ścieżce.

Jaki jest dobry sposób, aby twój skrypt mógł znaleźć skrypt dołączania, zwłaszcza jeśli na przykład skrypt musi być przenośny?

Staram się, aby wszystkie moje skrypty były względem siebie względne. W ten sposób mogę użyć nazwy katalogu:

#!/bin/sh

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

"$my_dir/other_script.sh"

Wiem, że jestem spóźniony na imprezę, ale powinno to działać bez względu na to, jak uruchomisz skrypt i używasz wyłącznie wbudowanych funkcji:

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

.Komenda (kropka) jest aliasem do source, $PWDjest ścieżką do katalogu roboczego, BASH_SOURCEjest zmienną tablicową, której członkowie są źródłowymi nazwami plików, ${string%substring}usuwa najkrótsze dopasowanie $ substring z tyłu $ string

Alternatywa dla:

scriptPath=$(dirname $0)

jest:

scriptPath=${0%/*}

.. zaletą jest brak zależności od dirname, co nie jest wbudowanym poleceniem (i nie zawsze jest dostępne w emulatorach)

Jeśli znajduje się w tym samym katalogu, możesz użyć dirname $0:

#!/bin/bash

source $(dirname $0)/incl.sh

echo "The main script"

Myślę, że najlepszym sposobem na to jest użycie metody Chrisa Borana, ALE powinieneś obliczyć MY_DIR w ten sposób:

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

Aby zacytować strony podręcznika 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

Nigdy nie spotkałem przypadku użycia, w którym MY_DIRnie jest poprawnie obliczony. Jeśli uzyskasz dostęp do skryptu za pomocą dowiązania symbolicznego $PATH, działa.

Kombinacja odpowiedzi na to pytanie zapewnia najbardziej niezawodne rozwiązanie.

Pracował dla nas w skryptach klasy produkcyjnej z doskonałym wsparciem dla zależności i struktury katalogów:

#! / bin / bash

# Pełna ścieżka bieżącego skryptu
TO = `readlink -f" $ {BASH_SOURCE [0]} "2> / dev / null || echo $ 0`

# Katalog, w którym znajduje się bieżący skrypt
DIR = `dirname" $ ​​{THIS} "`

# „Kropka” oznacza „źródło”, tzn. „Dołącz”:
. „$ DIR / compile.sh”

Metoda obsługuje wszystkie te:

• Przestrzenie na ścieżce
• Linki (przez readlink)
• ${BASH_SOURCE[0]} jest bardziej solidny niż $0

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

Działa to nawet wtedy, gdy skrypt pochodzi:

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

1. Najładniejszy

Zbadałem prawie każdą sugestię i oto najładniejsza, która dla mnie działała:

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

Działa nawet wtedy, gdy skrypt jest dowiązaniem symbolicznym do $PATH katalogu.

Zobacz to w akcji tutaj: https://github.com/pendashteh/hcagent/blob/master/bin/hcagent

2. Najfajniejsza

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

To właściwie inna odpowiedź na tej samej stronie, ale dodaję ją również do mojej odpowiedzi!

2. Najbardziej niezawodny

Alternatywnie, w rzadkim przypadku, gdy te nie działały, oto podejście kuloodporne:

# 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"))

Możesz zobaczyć to w akcji w taskrunnerźródle: https://github.com/pendashteh/taskrunner/blob/master/bin/taskrunner

Mam nadzieję, że pomoże to komuś tam :)

Proszę również zostawić to jako komentarz, jeśli jeden nie działał dla Ciebie, i podaj swój system operacyjny i emulator. Dzięki!

Musisz określić lokalizację innych skryptów, nie ma innego wyjścia. Poleciłbym konfigurowalną zmienną u góry skryptu:

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

. $installpath/incl.sh

echo "The main script"

Alternatywnie możesz nalegać, aby użytkownik utrzymywał zmienną środowiskową wskazującą, gdzie znajduje się strona główna programu, na przykład PROG_HOME lub jakoś. Można to podać użytkownikowi automatycznie, tworząc skrypt z tymi informacjami w /etc/profile.d/, który będzie pozyskiwany przy każdym logowaniu użytkownika.

Sugeruję utworzenie skryptu setenv, którego jedynym celem jest zapewnienie lokalizacji dla różnych komponentów w całym systemie.

Wszystkie inne skrypty następnie źródły tego skryptu, dzięki czemu wszystkie lokalizacje są wspólne dla wszystkich skryptów za pomocą skryptu setenv.

Jest to bardzo przydatne podczas uruchamiania cronjobs. Podczas uruchamiania crona otrzymujesz minimalne środowisko, ale jeśli wszystkie skrypty crona najpierw dołączą skrypt setenv, będziesz w stanie kontrolować i synchronizować środowisko, w którym chcesz uruchamiać cronjobs.

Zastosowaliśmy taką technikę na naszej małpce, która była używana do ciągłej integracji w ramach projektu o wielkości około 2000 kSLOC.

Odpowiedź Steve'a jest zdecydowanie poprawną techniką, ale należy ją ponownie przeredagować, aby zmienna installpath znajdowała się w osobnym skrypcie środowiska, w którym składane są wszystkie takie deklaracje.

Następnie wszystkie skrypty źródłowe tego skryptu i powinny zmienić ścieżkę instalacji, wystarczy ją zmienić tylko w jednym miejscu. Sprawia, że ​​wszystko jest bardziej bezpieczne. Boże, nienawidzę tego słowa! (-:

BTW Powinieneś naprawdę odwoływać się do zmiennej za pomocą $ {installpath}, gdy używasz jej w sposób pokazany w twoim przykładzie:

. ${installpath}/incl.sh

Jeśli nawiasy klamrowe zostaną pominięte, niektóre powłoki spróbują rozwinąć zmienną „installpath / incl.sh”!

Shell Script Loader to moje rozwiązanie.

Zapewnia funkcję o nazwie include (), która może być wywoływana wiele razy w wielu skryptach w celu odniesienia jednego skryptu, ale załaduje skrypt tylko raz. Funkcja może akceptować pełne lub częściowe ścieżki (skrypt jest przeszukiwany w ścieżce wyszukiwania). Zapewniona jest również podobna funkcja o nazwie load (), która bezwarunkowo ładuje skrypty.

Działa dla bash , ksh , pd ksh i zsh ze zoptymalizowanymi skryptami dla każdego z nich; oraz inne powłoki, które są ogólnie kompatybilne z oryginalnym sh, takie jak ash , dash , heirloom sh itp., poprzez uniwersalny skrypt, który automatycznie optymalizuje swoje funkcje w zależności od funkcji, które może zapewnić powłoka.

[Przyjęty przykład]

start.sh

To jest opcjonalny skrypt startowy. Umieszczenie tutaj metod uruchamiania jest tylko wygodą i można je zamiast tego umieścić w skrypcie głównym. Ten skrypt nie jest również potrzebny, jeśli skrypty mają zostać skompilowane.

#!/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

# ...

popiół

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 ----'

wynik:

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

Najlepsze są oparte na nim skrypty, które można również skompilować w celu utworzenia pojedynczego skryptu z dostępnym kompilatorem.

Oto projekt, który go wykorzystuje: http://sourceforge.net/p/playshell/code/ci/master/tree/ . Może działać przenośnie z kompilacją skryptów lub bez. Kompilacja w celu utworzenia pojedynczego skryptu może się również zdarzyć i jest pomocna podczas instalacji.

Stworzyłem również prostszy prototyp dla każdej partii konserwatywnej, która może chcieć mieć krótkie wyobrażenie o tym, jak działa skrypt implementacyjny: https://sourceforge.net/p/loader/code/ci/base/tree/loader-include-prototype .bash . Jest mały i każdy może po prostu dołączyć kod do głównego skryptu, jeśli chce, jeśli jego kod ma działać z Bash 4.0 lub nowszym, a także nie używa eval.

Osobiście umieść wszystkie biblioteki w libfolderze i użyj importfunkcji, aby je załadować.

struktura folderów

script.sh zawartość

# 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
}

Pamiętaj, że ta funkcja importowania powinna znajdować się na początku skryptu, a następnie możesz łatwo importować swoje biblioteki w następujący sposób:

import "utils"
import "requirements"

Dodaj pojedynczy wiersz u góry każdej biblioteki (tj. Utils.sh):

IMPORTED="$BASH_SOURCE"

Teraz masz dostęp do funkcji wewnątrz utils.shi requirements.shzscript.sh

DO ZROBIENIA: Napisz linker, aby zbudować pojedynczy shplik

Użycie źródła lub 0 $ nie da prawdziwej ścieżki do twojego skryptu. Możesz użyć identyfikatora procesu skryptu, aby pobrać jego prawdziwą ścieżkę

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

Używam tego skryptu i zawsze mi dobrze służył :)

Wszystkie moje skrypty startowe umieszczam w katalogu .bashrc.d. Jest to powszechna technika w takich miejscach jak /etc/profile.d itp.

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

Problem z rozwiązaniem wykorzystującym globbing ...

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

... czy możesz mieć listę plików, która jest „za długa”. Podejście takie jak ...

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

... działa, ale nie zmienia środowiska zgodnie z oczekiwaniami.

Oczywiście dla każdego z nich, ale myślę, że poniższy blok jest dość solidny. Wierzę, że obejmuje to „najlepszy” sposób na znalezienie katalogu i „najlepszy” sposób na wywołanie innego skryptu bash:

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

echo "The main script"

Może to być „najlepszy” sposób na włączenie innych skryptów. Jest to oparte na innej „najlepszej” odpowiedzi, która informuje skrypt bash, gdzie jest przechowywany

Powinno to działać niezawodnie:

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

source_relative incl.sh

musimy tylko znaleźć folder, w którym przechowywane są nasze pliki inc. sh i main.sh; po prostu zmień plik main.sh za pomocą tego:

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"

Według man hierodpowiednie miejsce na skrypt obejmuje/usr/local/lib/

/ usr / local / lib

Pliki powiązane z lokalnie zainstalowanymi programami.

Osobiście preferuję /usr/local/lib/bash/includesdla obejmuje. Istnieje biblioteka bash-helper do dołączania bibliotek w ten sposób:

#!/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

Możesz także użyć:

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