IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Shell et commandes GNU Discussion :

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


Sujet :

Shell et commandes GNU

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Profil pro
    Inscrit en
    Janvier 2006
    Messages
    53
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2006
    Messages : 53
    Par défaut Script récursif de création de répertoire en arbre
    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.

  2. #2
    Modérateur
    Avatar de N_BaH
    Profil pro
    Inscrit en
    Février 2008
    Messages
    7 651
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2008
    Messages : 7 651
    Par défaut
    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.
    N'oubliez pas de consulter les cours shell, la FAQ, et les pages man.

  3. #3
    Expert confirmé Avatar de Flodelarab
    Homme Profil pro
    Inscrit en
    Septembre 2005
    Messages
    5 287
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Charente (Poitou Charente)

    Informations forums :
    Inscription : Septembre 2005
    Messages : 5 287
    Par défaut
    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.

  4. #4
    Expert confirmé Avatar de disedorgue
    Homme Profil pro
    Ingénieur intégration
    Inscrit en
    Décembre 2012
    Messages
    4 347
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur intégration
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : Décembre 2012
    Messages : 4 347
    Par défaut
    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

  5. #5
    Expert confirmé
    Homme Profil pro
    Développeur informatique en retraite
    Inscrit en
    Avril 2008
    Messages
    2 102
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Côtes d'Armor (Bretagne)

    Informations professionnelles :
    Activité : Développeur informatique en retraite

    Informations forums :
    Inscription : Avril 2008
    Messages : 2 102
    Par défaut
    Citation Envoyé par bolivari Voir le message
    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...

Discussions similaires

  1. Script linux pour création de répertoire
    Par Sinon dans le forum Linux
    Réponses: 8
    Dernier message: 30/11/2006, 11h51
  2. création de répertoire
    Par tetef dans le forum C++
    Réponses: 10
    Dernier message: 31/07/2006, 10h19
  3. Création de répertoires sous Unix et Windows
    Par xzed dans le forum Général JavaScript
    Réponses: 2
    Dernier message: 16/05/2006, 16h31
  4. [MS-DOS] Création de répertoires !
    Par Franck.H dans le forum C
    Réponses: 2
    Dernier message: 25/03/2006, 14h13
  5. script qui explore les sous-répertoire ?
    Par farenheit dans le forum Flash
    Réponses: 9
    Dernier message: 20/07/2005, 12h02

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo