Normalerweise fügen Sie ein Skript mit "source" ein.

z.B:

main.sh:

#!/bin/bash

source incl.sh

echo "The main script"

inkl.sh:

echo "The included script"

Die Ausgabe der Ausführung von "./main.sh" lautet:

The included script
The main script

... Wenn Sie nun versuchen, dieses Shell-Skript von einem anderen Speicherort aus auszuführen, kann es das Include nur finden, wenn es sich in Ihrem Pfad befindet.

Was ist ein guter Weg, um sicherzustellen, dass Ihr Skript das Include-Skript findet, insbesondere wenn das Skript beispielsweise portabel sein muss?

Ich neige dazu, meine Skripte alle relativ zueinander zu machen. Auf diese Weise kann ich dirname verwenden:

#!/bin/sh

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

"$my_dir/other_script.sh"

Ich weiß, dass ich zu spät zur Party komme, aber das sollte funktionieren, egal wie Sie das Skript starten und ausschließlich integrierte Funktionen verwenden:

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

.(dot) Befehl ist ein Alias ​​für source, $PWDist der Pfad für das Arbeitsverzeichnis, BASH_SOURCEist eine Array-Variable, deren Mitglieder die Quelldateinamen sind, entfernt die ${string%substring}kürzeste Übereinstimmung von $ substring von der Rückseite von $ string

Eine Alternative zu:

scriptPath=$(dirname $0)

ist:

scriptPath=${0%/*}

.. der Vorteil ist, dass Sie nicht von dirname abhängig sind, was kein integrierter Befehl ist (und in Emulatoren nicht immer verfügbar ist).

Wenn es sich im selben Verzeichnis befindet, können Sie Folgendes verwenden dirname $0:

#!/bin/bash

source $(dirname $0)/incl.sh

echo "The main script"

Ich denke, der beste Weg, dies zu tun, besteht darin, den Weg von Chris Boran zu verwenden, ABER Sie sollten MY_DIR folgendermaßen berechnen:

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

So zitieren Sie die Manpages für 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

Ich bin noch nie auf einen Anwendungsfall gestoßen, bei dem die MY_DIRBerechnung nicht korrekt ist. Wenn Sie über einen Symlink in Ihrem Skript auf Ihr Skript zugreifen $PATH, funktioniert es.

Eine Kombination der Antworten auf diese Frage bietet die robusteste Lösung.

Es funktionierte für uns in produktionsfähigen Skripten mit großer Unterstützung von Abhängigkeiten und Verzeichnisstrukturen:

#! / bin / bash

# Vollständiger Pfad des aktuellen Skripts
THIS = `readlink -f" $ {BASH_SOURCE [0]} "2> / dev / null || echo $ 0`

# Das Verzeichnis, in dem sich das aktuelle Skript befindet
DIR = `dirname" $ ​​{THIS} "`

# 'Punkt' bedeutet 'Quelle', dh 'Einschließen':
. "$ DIR / compile.sh"

Die Methode unterstützt alle diese:

• Leerzeichen im Pfad
• Links (via readlink)
• ${BASH_SOURCE[0]} ist robuster als $0

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

Dies funktioniert auch dann, wenn das Skript verwendet wird:

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

1. Am ordentlichsten

Ich habe fast jeden Vorschlag untersucht und hier ist der ordentlichste, der für mich funktioniert hat:

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

Es funktioniert auch, wenn das Skript mit einem $PATHVerzeichnis verknüpft ist .

Sehen Sie es hier in Aktion: https://github.com/pendashteh/hcagent/blob/master/bin/hcagent

2. Das coolste

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

Dies ist eigentlich eine andere Antwort auf dieser Seite, aber ich füge sie auch meiner Antwort hinzu!

2. Das zuverlässigste

In dem seltenen Fall, dass diese nicht funktionierten, ist hier der kugelsichere Ansatz:

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

Sie können es in Aktion in der taskrunnerQuelle sehen: https://github.com/pendashteh/taskrunner/blob/master/bin/taskrunner

Hoffe das hilft jemandem da draußen :)

Bitte hinterlassen Sie es auch als Kommentar, wenn einer für Sie nicht funktioniert hat, und geben Sie Ihr Betriebssystem und Ihren Emulator an. Vielen Dank!

Sie müssen den Speicherort der anderen Skripte angeben, es gibt keinen anderen Weg, um dies zu umgehen. Ich würde eine konfigurierbare Variable oben in Ihrem Skript empfehlen:

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

. $installpath/incl.sh

echo "The main script"

Alternativ können Sie darauf bestehen, dass der Benutzer eine Umgebungsvariable verwaltet, die angibt, wo sich Ihr Programm zu Hause befindet, z. B. PROG_HOME oder ähnliches. Dies kann für den Benutzer automatisch bereitgestellt werden, indem in /etc/profile.d/ ein Skript mit diesen Informationen erstellt wird, das bei jeder Anmeldung eines Benutzers abgerufen wird.

Ich würde vorschlagen, dass Sie ein Setenv-Skript erstellen, dessen einziger Zweck darin besteht, Speicherorte für verschiedene Komponenten in Ihrem System bereitzustellen.

Alle anderen Skripte würden dann dieses Skript als Quelle verwenden, sodass alle Speicherorte für alle Skripte mit dem Setenv-Skript gleich sind.

Dies ist sehr nützlich, wenn Sie Cronjobs ausführen. Wenn Sie cron ausführen, erhalten Sie eine minimale Umgebung. Wenn Sie jedoch festlegen, dass alle cron-Skripte zuerst das setenv-Skript enthalten, können Sie die Umgebung steuern und synchronisieren, in der die cronjobs ausgeführt werden sollen.

Wir haben eine solche Technik bei unserem Build-Affen verwendet, die für die kontinuierliche Integration in ein Projekt von etwa 2.000 kSLOC verwendet wurde.

Steves Antwort ist definitiv die richtige Technik, sollte jedoch überarbeitet werden, damit sich Ihre Installationspfadvariable in einem separaten Umgebungsskript befindet, in dem alle derartigen Deklarationen abgegeben werden.

Dann beziehen alle Skripte dieses Skript und sollten sich der Installationspfad ändern, müssen Sie es nur an einem Ort ändern. Macht die Dinge zukunftssicherer. Gott, ich hasse dieses Wort! (-:

Übrigens: Sie sollten die Variable wirklich mit $ {installpath} referenzieren, wenn Sie sie wie in Ihrem Beispiel gezeigt verwenden:

. ${installpath}/incl.sh

Wenn die geschweiften Klammern weggelassen werden, versuchen einige Shells, die Variable "installpath / incl.sh" zu erweitern!

Shell Script Loader ist meine Lösung dafür.

Es bietet eine Funktion namens include (), die in vielen Skripten mehrmals aufgerufen werden kann, um auf ein einzelnes Skript zu verweisen, das Skript jedoch nur einmal lädt. Die Funktion kann vollständige oder teilweise Pfade akzeptieren (das Skript wird in einem Suchpfad durchsucht). Eine ähnliche Funktion namens load () wird ebenfalls bereitgestellt, mit der die Skripte bedingungslos geladen werden.

Es funktioniert für bash , ksh , pd ksh und zsh mit optimierten Skripten für jedes von ihnen; und andere Shells, die generisch mit dem Original-Sh kompatibel sind, wie Asche , Armaturenbrett , Erbstück Sh usw., über ein universelles Skript, das seine Funktionen abhängig von den Funktionen, die die Shell bieten kann, automatisch optimiert.

[Geflügeltes Beispiel]

start.sh

Dies ist ein optionales Starterskript. Das Platzieren der Startmethoden hier ist nur eine Annehmlichkeit und kann stattdessen im Hauptskript platziert werden. Dieses Skript wird auch nicht benötigt, wenn die Skripte kompiliert werden sollen.

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

# ...

Asche

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

Ausgabe:

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

Das Beste daran ist, dass darauf basierende Skripte auch zu einem einzigen Skript mit dem verfügbaren Compiler kompiliert werden können.

Hier ist ein Projekt, das es verwendet: http://sourceforge.net/p/playshell/code/ci/master/tree/ . Es kann portabel mit oder ohne Kompilieren der Skripte ausgeführt werden. Das Kompilieren zur Erstellung eines einzelnen Skripts kann ebenfalls erfolgen und ist bei der Installation hilfreich.

Ich habe auch einen einfacheren Prototyp für jede konservative Partei erstellt, die eine kurze Vorstellung davon haben möchte, wie ein Implementierungsskript funktioniert: https://sourceforge.net/p/loader/code/ci/base/tree/loader-include-prototype .bash . Es ist klein und jeder kann den Code einfach in sein Hauptskript aufnehmen, wenn er möchte, wenn sein Code mit Bash 4.0 oder neuer ausgeführt werden soll, und er wird auch nicht verwendet eval.

Legen Sie alle Bibliotheken persönlich in einem libOrdner ab und importladen Sie sie mithilfe einer Funktion.

Ordnerstruktur

script.sh Inhalt

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

Beachten Sie, dass diese Importfunktion am Anfang Ihres Skripts stehen sollte und Sie Ihre Bibliotheken dann einfach wie folgt importieren können:

import "utils"
import "requirements"

Fügen Sie oben in jeder Bibliothek eine einzelne Zeile hinzu (z. B. utils.sh):

IMPORTED="$BASH_SOURCE"

Jetzt haben Sie Zugriff auf Funktionen innerhalb utils.shund requirements.shvonscript.sh

TODO: Schreiben Sie einen Linker, um eine einzelne shDatei zu erstellen

Wenn Sie source oder $ 0 verwenden, erhalten Sie nicht den tatsächlichen Pfad Ihres Skripts. Sie können die Prozess-ID des Skripts verwenden, um den tatsächlichen Pfad abzurufen

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

Ich benutze dieses Skript und es hat mir immer gut gedient :)

Ich habe alle meine Startskripte in einem .bashrc.d-Verzeichnis abgelegt. Dies ist eine übliche Technik an Orten wie /etc/profile.d usw.

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

Das Problem mit der Lösung mit Globbing ...

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

... ist, dass Sie möglicherweise eine Dateiliste haben, die "zu lang" ist. Ein Ansatz wie ...

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

... läuft, ändert aber nicht die gewünschte Umgebung.

Natürlich für jeden sein eigenes, aber ich denke, der Block unten ist ziemlich solide. Ich glaube, dies beinhaltet den "besten" Weg, ein Verzeichnis zu finden, und den "besten" Weg, ein anderes Bash-Skript aufzurufen:

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

echo "The main script"

Dies ist möglicherweise der "beste" Weg, um andere Skripte einzuschließen. Dies basiert auf einer anderen "besten" Antwort, die einem Bash-Skript mitteilt, wo es gespeichert ist

Dies sollte zuverlässig funktionieren:

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

source_relative incl.sh

wir müssen nur den Ordner herausfinden, in dem unsere inkl.sh und main.sh gespeichert sind; Ändern Sie einfach Ihre main.sh damit:

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"

Entsprechend man hiergeeigneter Stelle für das Skript ist/usr/local/lib/

/ usr / local / lib

Dateien, die lokal installierten Programmen zugeordnet sind.

Persönlich bevorzuge ich /usr/local/lib/bash/includesfür enthält. Es gibt eine Bash-Helfer- Bibliothek, um Bibliotheken auf diese Weise einzuschließen:

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

Sie können auch verwenden:

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