Ruby File :: répertoire? Problèmes

Marque westling membres a déjà répondu à votre question, mais puisque vous parlez de vous qui sont nouveaux pour les Rubis, voici quelques autres suggestions de style:

def subdirs
  subdirs = Array.new

Il est généralement préférable d'utiliser la syntaxe littérale, si possible, de sorte que la voie commune pour exprimer ce serait subdirs = [].

  self.each do |x|

self est l'implicite récepteur en Ruby, de sorte que vous pouvez simplement laisser de côté. (Ce n'est pas Python, après tout.) Toutefois, le principal objectif du code est de la communication, de sorte que si vous croyez, il communique votre intention de mieux, la laisser à.

Parlant de la communication: x est pas très communicatif nom, à moins que vous parlez de points dans un système de coordonnées cartésiennes. Que diriez -fileou si vous êtes mal à l'aise avec les Unix notion que les répertoires sont également des fichiers, le plus neutre entry? (En fait, le mieux serait probablement pathmais nous verrons bientôt comment cela pourrait devenir source de confusion.)

Ma troisième suggestion est en fait question de préférence personnelle qui est contraire à la commune de Ruby style: commune de Ruby style dicte une ligne de blocs sont délimités avec {/} et multiligne blocs sont délimités avec do/endtout comme vous l'avez fait. Je n'aime pas ça, parce que c'est une distinction arbitraire, qui ne rend pas tout sens. (Rappelez-vous que la "communication"?) Donc, en fait, je fais les choses différemment: si le bloc est impératif dans la nature et, par exemple, certains changements d'état global, j'utilise les mots clés (parce que le bloc est en fait doing peu de travail) et si le bloc est de nature fonctionnelle et retourne un nouvel objet, je préfère utiliser des accolades (parce qu'ils sont joliment mathématique). Donc, dans ce cas, je voudrais utiliser des accolades.

    if File.directory?(x)

Comme Marque déjà expliqué, vous avez besoin de faire quelque chose comme File.directory?(File.join(path, entry)) ici, où Dir#path est un attribut public de la Dir classe de retourner le chemin qui Dir.new a été initialisé avec.

Ici vous voyez aussi, pourquoi nous n'avons pas utilisé path comme le nom du bloc de paramètres. Sinon, nous aurions besoin d'écrire File.directory?(File.join(self.path, path)).

      subdirs.push(x)

La manière canonique pour ajouter un élément à un tableau, ou même ajouter à peu près tout ce à quoi que ce soit en Ruby, est le << de l'opérateur. Donc, cela devrait lire subdirs << entry.

Array#push est un alias de Array#<<qui est principalement destiné à vous permettre d'utiliser un Array comme une pile (en collaboration avec Array#pop).

    end
  end
  return subdirs

Voici un autre décalage entre mon style personnel et commun Ruby style: Ruby, si ce n'est pas explicite returnla valeur de retour est tout simplement la valeur de la dernière expression. Cela signifie que vous pouvez laisser tomber le return mot-clé et la commune de Ruby style dit que vous devriez. Toutefois, je préfère utiliser ce similaires au bloc délimiteurs: utilisation return pour les méthodes qui sont de nature fonctionnelle (parce qu'ils ont fait "retour" d'une valeur) et pas de return pour impératif méthodes (parce que leur réel valeur de retour n'est pas ce qui vient après la return mot-clé, mais de quel côté effets qu'ils ont sur l'environnement). Donc, comme vous, je voudrais utiliser une return mot-clé ici, en dépit d'un style commun.

Il est de coutume, pour séparer la valeur de retour du reste du corps de la méthode par une ligne vide. (Il en va de même pour le code d'installation, par le chemin.)

end

Donc, voilà où nous en sommes aujourd'hui:

def subdirs
  subdirs = []

  each { |entry|
    if File.directory?(File.join(path, entry))
      subdirs << entry
    end
  }

  return subdirs
end

Comme vous pouvez le voir, le if expression vraiment ne sert à sauter une itération de la boucle. C'est beaucoup mieux communiquées par l'aide de la next mot-clé:

def subdirs
  subdirs = []

  each { |entry|
    next  unless File.directory?(File.join(path, entry))
    subdirs << entry
  }

  return subdirs
end

Comme vous pouvez le voir, nous avons réussi à supprimer un niveau d'imbrication de la structure de bloc, qui est toujours un bon signe.

Cet idiome est appelé le "gardien de l'article", et est très populaire dans la programmation fonctionnelle, où beaucoup de langues ont même garde construits, mais il est aussi largement utilisé dans à peu près toute autre langue sur la planète, car il simplifie considérablement le flux de contrôle: l'idée est analogue à un garde posté à l'extérieur d'un château: au lieu de laisser les méchants dans le château (méthode, procédure, fonction, bloc, ...) et puis, péniblement en essayant de suivre chacun de leurs mouvements et constamment peur de rater quelque chose ou perdez, il vous suffit de poster un garde à la entrée de votre château (le début de votre méthode, bloc, ...) qui ne leur laisse pas pour commencer (qui saute à la fin de la procédure, retourne au début de la méthode, saute une itération de la boucle, ...). En Ruby, vous pouvez utiliser raisereturnnext et break pour cela. Dans d'autres langues, même GOTO est très bien (c'est un de ces rares cas où un GOTO peut effectivement clair jusqu' flux de contrôle).

Cependant, nous pouvons simplifier encore plus loin, en reconnaissant l'itérateur motif: vous prenez une liste (les entrées du répertoire), puis vous "squash" cette liste à un seul objet (le subdirs tableau). Pour un théoricien de la catégorie, cela hurle "catamorphism", pour un hardcore programmeur fonctionnel "fold", à un softcore programmeur fonctionnel "reduce", à une Causerie programmeur "inject:into:" et à un Rubyist "Enumerable#inject":

def subdirs
  return inject([]) { |subdirs, entry|
    next subdirs  unless File.directory?(File.join(path, entry))
    subdirs << entry
  }
end

inject utilise la valeur de retour de l'itération précédente pour les semences de la prochaine, c'est pourquoi nous devons retourner subdirsmême si nous sommes en sautant d'une itération, en utilisant next subdirs au lieu de la plaine next (qui permettrait le retour nilde sorte que la prochaine itération subdirs serait nil et subdirs << entry soulèverait un NoMethodError.)

(Remarquez que j'ai utilisé des accolades pour le bloc, même si le bloc modifie en fait son argument. J'ai l'impression que c'est encore un "fonctionnelle" du bloc, mais. YMMV.)

La dernière chose que nous pouvons faire est de reconnaître que ce que nous faisons est juste de filtrage (ou en d'autres termes la "sélection"), les éléments d'un tableau. Et Ruby a déjà une méthode construite en, qui fait exactement cela: Enumerable#select. Témoin de la ligne unique de trucs que l'utilisation de la pleine puissance de Ruby génère:

def subdirs
  return select { |entry| File.directory?(File.join(path, entry)) }
end

Comme une pointe générale: découvrir les merveilles de Enumerable. Il est la cheval de bataille de programmation Ruby, semblable à IEnumerable<T>.NET, dicts en Python, les listes dans les langages fonctionnels ou de tableaux associatifs en PHP et Perl.

Remplacer * par quelle que soit la voie que vous voulez et vous êtes bon pour aller. Glob vous reçoit tous les fichiers dans le chemin à l'aide de bash expansion de sorte que vous pouvez utiliser * et ** ainsi que les plages, etc. Assez doux.

Le sélectionner des œuvres comme le contraire de rejeter, cherry-picking uniquement les valeurs qui sont vraies dans le bloc.

Dir.glob("*").sélectionnez {|f| Fichier.répertoire?(f) }