Script récursif de création de répertoire en arbre

Version imprimable

Bonjour,
Je cherche a créé une fonction récursive qui pourrai créé des répertoires ou autre chose en fonction d'une profondeur.

Voici mon code actuel:

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
#!/bin/sh
 
nbdir=3
depth=4
if [ $1 ];then cd $1;else exit 1;fi
 
dir=''
 
d=0
i=1
j=1
k=1
maketree(){
echo $d
if [ $d -lt $depth ];then d=$(($d+1));echo "do"$d;k=1;dirk='';else echo "exit";exit 0;fi;
 
 
i=1;while [ $i -le $nbdir ];do
 
	nbi=$(echo "000"$i);
	dir='dir.'$nbi;
	if [ $d -eq 1 ];then
	echo "nbdiri"$i
 
	dir=$dir
	echo $dir
	else
	j=1;while [ $j -le $nbdir ];do
 
		echo 'nbdirj'$j;nbj=$(echo "000"$j);dirr='dir.'$nbj;
 
		dirr=$dir/$dirr;
		echo 'nbdirk'$k;nbk=$(echo "000"$k);dirk='dir.'$nbk;
		dirr=$dirr/$dirk
 
		echo $dirr;
 
		echo $j
		echo $k
		j=$(($j+1))
		if [ $j -gt $nbdir ];then k=$(($k+1));fi
 
 
	done
 
	fi
	i=$(($i+1));
 
done
echo "maketree";maketree;
 
 
}
 
 
pwd
maketree

Mon problème est qu'il ne supporte pas une profondeur supérieur a 3.

Peut être je m'y prend mal. :(

Merci d'avance pour vos réponse.

02/03/2020, 16h00
N_BaH

Bonjour,

Citation:

cré[er] des répertoires ou autre chose en fonction d'une profondeur

cette description est un peu courte.
si on ajoute l'absence de commentaires dans le script et des noms de variables qui ne disent pas ce qu'elles sont... :aie:
ce code est pénible à lire.
02/03/2020, 16h07
Flodelarab

Bonjour :coucou:

La variable "d" part de 1, et s'incrémente à chaque passage dans la fonction, jusqu'à atteindre la variable $depth, ce qui provoque la sortie du programme. Donc 1, 2, 3, sortie. Qu'est-ce qui te choque ? C'est ce que tu as programmé. Ligne 16.

La récursivité est un choix d'autant plus douteux qu'en bash, les fonctions ne sont pas des espaces confinés.

Après ça dépend aussi du besoin, parce que mkdir fait déjà de la profondeur:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
$ find foobar
find: ‘foobar’: No such file or directory
$ mkdir -p foobar/foo{01..03}/bar{004..005}/barfoo
$ find foobar
foobar
foobar/foo01
foobar/foo01/bar004
foobar/foo01/bar004/barfoo
foobar/foo01/bar005
foobar/foo01/bar005/barfoo
foobar/foo02
foobar/foo02/bar004
foobar/foo02/bar004/barfoo
foobar/foo02/bar005
foobar/foo02/bar005/barfoo
foobar/foo03
foobar/foo03/bar004
foobar/foo03/bar004/barfoo
foobar/foo03/bar005
foobar/foo03/bar005/barfoo

02/03/2020, 22h47
jack-ft
Citation:

Envoyé par bolivari

Je cherche a créé une fonction récursive qui pourrai créé des répertoires ou autre chose en fonction d'une profondeur.

Voici mon code actuel:

Dans la plupart des exemples que j'ai vus (difficile d'évaluer leur nombre en 40 ans de programmation lisp!), une fonction récursive a au moins un argument qui sert justement à limiter la profondeur.
Ce peut être un nombre, une liste ou bien un pointeur dans une structure, comme dans :
Code:

1 2 3 4 5 fact(n) ::= n * fact(n-1) length(l) ::= 1 + length(butfirst(l)) grd(tree) ::= combine(grd(gauche(tree)), racine(tree), grd(droite(tree)))
Dans ces cas-là, la structure de la fonction (notamment pour une fonction simplement récursive, c'est-à-dire itérative) ressemble à quelque chose comme:
Code:

1 2 3 4 Pour fct(x) si x est terminal alors retourner résultat immédiat (x) sinon retourner combine(x, fct(successeur(x)))
Ici, ta fonction maketree n'a pas d'argument, qui apparaîtrait comme $1 à l'intérieur du code de la fonction.
Du coup, je vois mal comment elle pourrait faire une récursivité normale... :koi: