création shell commande

Version imprimable

03/12/2008, 13h58
david06600

création shell commande

Bonjour, voila je voudrai savoir comment créer des commandes linux, accessible par le shell.
Par exemple je créé mon script sh avec mes commandes - commande1() et commande2() - comment faire, pour qu'il soit possible d'appeler en ligne de commande commande1 et commande2 comme une commande normale linux.

J'ai trouvé un moyen de faire en appelant source avec le fichier de script dans .bashrc.
Y a til une autre façon de procéder ?
Merci
03/12/2008, 14h35
Invité
Salut,

Tu dois rendre ton script executable:
Code:

1 2 chmod +x ton_script.sh
et dans ton script tu ajoutes cette ligne tout en haut
Code:

1 2 3 #!/chemin/vers/type/shell/que/tu/souhaites/utiliser exemple : #!/usr/bin/bash
03/12/2008, 14h44
david06600

Non cela ne me permet pas d'executer les fonctions de mon scripts comme des commandes.
J'ai un script, script.sh avec des fonctions définies a l'intérieur, commande1(), commande2() etc....
Je voudrais pouvoir appeler directement à partir du shell commande1 par exemple, sans invoquer ./mon_script.sh

J'ai éventuellement une solution avec getopt (même si ça peut paraître démesuré :aie:)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #!/bin/bash fonction1() { echo "execution fonction1" } fonction2() { echo "execution fonction2" } set -- `getopt ab $*` while [ $1 != -- ] ; do case $1 in -a) fonction1 ;; -b) fonction2 ;; esac shift done
On peut appeler le script avec l'option -a ET/OU -b.
On peut même en combiner plusieurs dans le genre (-a -b -a -a -b ) ce qui aura pour effet de donner :

Citation:

execution fonction1
execution fonction2
execution fonction1
execution fonction1
execution fonction2

EDIT: Oups j'arrive un poil trop tard
Mais par contre à ma connaissance je ne pense pas que l'on puisse directement appeler en ligne de commande une fonction définie dans un script shell ...

03/12/2008, 14h57
david06600

ben la j'appelle directement mes fonctions que j'ai définie dans mon script en editant .bashrc en lui rajoutant . ~/bin/mon_script.sh. Cela me permet d'appeler les fonctions de mon script directement a partir du shell, mais a chaque modification je suis obligé de changer de compte et de relogger pour que ce soit pris en compte.
Sinon en fait je voulais juste avoir le même comportement qu'avec les commandes déja défini comme ls, mkdir etc....
On les invoque directement, sans faire ./ls, ou ./mkdir. Comment arriver a ça dans la logique de linux ?
Merci

Citation:

Sinon en fait je voulais juste avoir le même comportement qu'avec les commandes déja défini comme ls, mkdir etc....

les commandes ls, mdkir sont des programmes executables et non des fonctions.

on ne tape pas ./ devant car le chemin vers ces commandes est définie dans le PATH

exemple
Code:

1 2 3 4 5 6 7 (user@hespera:/)% which ls /usr/bin/ls (user@hespera:/)% env | grep PATH PATH=/usr/bin:/usr/local/bin:/opt/bin:/opt/local/bin:/usr/ccs/bin:/usr/xpg4/bin:/opt/sfw/bin:/usr/sbin (user@hespera:/)% file /usr/bin/ls /usr/bin/ls: ELF 32-bit MSB executable SPARC Version 1, dynamically linked, stripped
Pourrais-tu également montrer le contenu de ton script stp?

03/12/2008, 15h19
david06600
Comment donc créer une commande, qui puisse être invoquer juste avec un nom simplement, sans avoir a faire ./mon_script.sh, mais juste en entrant en ligne de commande mon_script ?
Dans mon script il n'y a rien de particuliers pour le moment, je commence directement avec :
Code:

1 2 3 4 function blabla() { #quelques lignes de code pour tester }
03/12/2008, 15h25
CedrX
Petite question subsidiaire:
Les fonctions que tu crées dans ton script tu les appelles quelquepart dans ton script.

Ensuite pour ne pas avoir besoin de mettre un ./ tu peux toujours modifier ta variable PATH dans ton (.profile ou .bash_profile ou .bashrc) pour rajouter le répertoire bin de ton Home directory
Code:

1 2 3 PATH=$PATH:/home/moi/bin export PATH
Ensuite tu placeras ton script dans ce répertoire et tu pourras l'appeler sans ./

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
[user@electre: ~]$ cat mon_script.sh
#!/usr/bin/bash

#creation de la fonction
my_function()
{
echo "hello from function"
}
#appel de la fonction
my_function

[user@electre: ~]$ ./mon_script.sh
hello from function

[user@electre: ~]$ mon_script.sh
bash: mon_script.sh: command not found

[user@electre: ~]$ pwd
/export/home/user
[user@electre: ~]$ export PATH=$PATH:/export/home/user

[user@electre: ~]$ mon_script.sh
hello from function
[user@electre: ~]$

03/12/2008, 15h33
david06600

Citation:

Petite question subsidiaire:
Les fonctions que tu crées dans ton script tu les appelles quelquepart dans ton script.

Certaines oui, certaines non :). Mais dans d'autres fonctions principalement.
Mais sinon je voulais juste trouver un mécanisme afin d'avoir des commandes comme celle que l'on utilise en ligne de commande dans le shell. C'est plus simple de rentrer commande, que ./commande.sh. Je pensai que c'était configurable d'une façon ou d'une autre apparament non. Pas grave je taperai ./commande.sh ou commande.sh
03/12/2008, 15h36
david06600

Mais alors comment passer des arguments en ligne de commande à mes fonctions ??? Je suis perdu dsl :oops:
Pour être plus simple disons que je voudrai entrer ceci en ligne de commande :

Code:

addfile -f /blabla/file

C'est ce que je souhaite faire. Comment faut il procéder ?

Je reprends mon script avec un exemple de passage d'argument à une fonction.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/bin/bash

fonction1() {
        #$1 sera le paramètre passé à la fonction
        echo "execution fonction1 avec parametre $1"
}

fonction2() {
        echo "execution fonction2 avec paramètre $1"
}

set -- `getopt a:b: $*`
while [ $1 != -- ] ; do
        case $1 in
        -a)
                parametre=$2
                fonction1 $parametre
                ;;
        -b)
                parametre=$2
                fonction2 $parametre
                ;;
        esac
        shift
done

03/12/2008, 15h58
david06600

Et tu l'appelles comment ton script avec les paramètres ?

Ben là dans le cas de ce script ça serait plutot 1 paramètre après l'option:
Code:

1 2 3 4 5 ./mon_script -a toto -b tata -a titi execution fonction1 avec paramètre toto execution fonction2 avec paramètre tata execution fonction1 avec paramètre titi

03/12/2008, 16h09
david06600

D'accord je te remercie. Par contre c'est peu ordinaire comme façon de faire. Le mieux selon vous pour créer une commande serai donc de le faire en C et de créer un executable ??
Le shell scrip n'est donc pas super adapté pour ça.
03/12/2008, 16h33
CedrX
Code:

Par contre c'est peu ordinaire comme façon de faire.

Je ne sais pas :aie:
Tu l'aurais vu comment le passage d'arguments ?

Par contre un truc que je ne sais pas, c'est si on peut passer plusieurs arguments derrière une option.
Moi pour l'instant j'avoue ne pas avoir réussi à le faire mais j'avoue aussi que je n'ai pas regardé de fond en comble les options de getopt
Du genre
Code:

1 2 mon_script.sh -a argument1 argument2 -b argument3
Je rebondis donc sur ce thread pour poser la question. Si une bonne âme connaît la réponse ... :)
03/12/2008, 16h42
david06600

Quand j'ai dit peu ordinaire, je voulais dire que le shell script n'est pas vraiment adapté pour faire ça, bien qu'il est une commande getopts. Je pensai que l'on pouvait faire un appel direct d'un shell script lui passer des arguments en ligne de commande et tout comme pour un "ls" par exemple.
Et sinon sourcer le script dans .bashrc n'est pas une bonne façon de faire ??
De cette façon tu n'as pas besoin du shebang ni de rendre ton fichier executable et tu appelles les fonctions que tu as défini comme si c'était des commandes :)
03/12/2008, 21h06
Winnt

Salut,

J'ai l'impression que c'est cela que vous cherchez.

Citation:

Envoyé par Introduction à la programmation en Bash Version 0.1 Eric Sanchis

2.2.4. Paramètres de position et fichiers shell
Dans un fichier shell, les paramètres de position sont utilisés pour accéder aux valeurs des arguments qui ont été passés lors de son appel : cela signifie qu’au sein du fichier shell, les occurrences de $1 sont remplacées par la valeur du premier argument, celles de $2 par la valeur du deuxième argument, etc. Le paramètre spécial $# contient le nombre d’arguments passés lors de l’appel.
Le paramètre de position 0 contient le nom complet du programme shell qui s’exécute.
Soit le programme shell copie :
#!/bin/bash
# @(#) copie
echo "Nom du programme : $0"
echo "Nb d'arguments : $#"
echo "Source : $1"
echo "Destination : $2"
cp $1 $2

Pour exécuter ce fichier shell :
Ex : $ chmod u+x copie
$
$ copie /etc/passwd X
Nom du programme : ./copie
Nb d'arguments : 2
Source : /etc/passwd
Destination : X
$
Dans le fichier copie, chaque occurrence de $1 a été remplacée par la chaîne de caractères
/etc/passwd, celles de $2 par X.

PS : merci à Eric Sanchis pour son manuel du Bash très utile.