Utilisation de l'instruction Ruby Case (Switch)

Dans la plupart des langages informatiques, le cas ou conditionnel (également appelé commutateur) compare la valeur d'une variable avec celle de plusieurs constantes ou littéraux et exécute le premier chemin avec une casse correspondante. En Ruby, c'est un peu plus flexible (et puissant).

Au lieu d'un simple test d'égalité, l'opérateur d'égalité de cas est utilisé, ouvrant la porte à de nombreuses nouvelles utilisations.

Il existe cependant quelques différences par rapport aux autres langues. En C, une instruction switch est une sorte de remplacement pour une série de si et goto déclarations. Les cas sont techniquement des étiquettes, et l'instruction switch ira à l'étiquette correspondante. Cela présente un comportement appelé "fallthrough", car l'exécution ne s'arrête pas lorsqu'elle atteint une autre étiquette.

Cela est généralement évité à l'aide d'une instruction break, mais la solution est parfois intentionnelle. La déclaration de cas dans Ruby, d'autre part, peut être considérée comme un raccourci pour une série de si déclarations. Il n'y a pas de solution, seul le premier cas correspondant sera exécuté.

La forme de base d'une déclaration de cas

La forme de base d'une déclaration de cas est la suivante.

Comme vous pouvez le voir, c'est structuré quelque chose comme une instruction conditionnelle if / else if / else. Le nom (que nous appellerons valeur), dans ce cas entré à partir du clavier, est comparé à chacun des cas du quand clauses (c'est-à-dire. cas), et le premier bloc when avec un cas correspondant sera exécuté. Si aucun d'entre eux ne correspond, autre le bloc sera exécuté.

Ce qui est intéressant ici, c'est Comment la valeur est comparée à chacun des cas. Comme mentionné ci-dessus, en C ++ et dans d'autres langages de type C, une comparaison de valeurs simple est utilisée. Dans Ruby, l'opérateur d'égalité de casse est utilisé.

N'oubliez pas que le type du côté gauche d'un opérateur d'égalité de cas est important et que les cas sont toujours du côté gauche. Donc, pour chaque quand clause, Ruby évaluera case === valeur jusqu'à ce qu'il trouve une correspondance.

Si nous devions entrer Bob, Ruby évaluerait d'abord "Alice" === "Bob", ce qui serait faux puisque Chaîne # === est défini comme la comparaison des chaînes. Prochain, /[qrz[.+/i === "Bob" serait exécuté, ce qui est faux car Bob ne commence pas par Q, R ou Z.

Puisqu'aucun des cas ne correspond, Ruby exécutera alors la clause else.

Comment le type entre en jeu

Une utilisation courante de l'instruction case est de déterminer le type de valeur et de faire quelque chose de différent selon son type. Bien que cela brise la frappe habituelle de Ruby, il est parfois nécessaire de faire avancer les choses.

Cela fonctionne en utilisant le Classe # === (techniquement, le Module # ===), qui teste si le côté droit est un? côté gauche.

La syntaxe est simple et élégante:

Une autre forme possible

Si la valeur est omis, l'instruction case fonctionne un peu différemment: elle fonctionne presque exactement comme une instruction if / else if / else. Les avantages de l'utilisation de l'énoncé de cas sur un si déclaration, dans ce cas, sont purement cosmétiques.

Une syntaxe plus compacte

Il y a des moments où il y a un grand nombre de petits quand clauses. Une telle déclaration de cas devient facilement trop grande pour tenir sur l'écran. Dans ce cas (sans jeu de mots), vous pouvez utiliser le ensuite mot-clé pour mettre le corps du quand clause sur la même ligne.

Bien que cela donne un code très dense, tant que chaque quand clause est très similaire, elle devient en fait plus lisible.

Lorsque vous devez utiliser des clauses sur une seule ligne et sur plusieurs lignes, c'est une question de style. Cependant, le mélange des deux n'est pas recommandé - une déclaration de cas doit suivre un modèle pour être aussi lisible que possible.

Affectation de cas

Comme pour les instructions if, les instructions case se comparent à la dernière instruction du quand clause. En d'autres termes, ils peuvent être utilisés dans les affectations pour fournir une sorte de tableau. Cependant, n'oubliez pas que les instructions case sont beaucoup plus puissantes que les simples recherches de tableau ou de hachage. Une telle table n'a pas nécessairement besoin d'utiliser des littéraux dans le quand clauses.

S'il n'y a pas de clause when correspondante ni de clause else, l'instruction case évaluera néant.