Discussion :

[bolivari]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[N_BaH]

Bonjour,

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...
ce code est pénible à lire.

[Flodelarab]

Bonjour

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.

[disedorgue]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[jack-ft]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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