Pourquoi les points d'exclamation sont-ils utilisés dans les méthodes Ruby?

Dans Ruby, certaines méthodes ont un point d'interrogation ( ?) qui pose une question commeinclude? celle-ci demande si l'objet en question est inclus, cela retourne alors un vrai / faux.

Mais pourquoi certaines méthodes ont-elles des points d'exclamation ( !) alors que d'autres n'en ont pas?

Qu'est-ce que ça veut dire?

En général, les méthodes qui se terminent par !indiquent que la méthode modifiera l'objet auquel elle est appelée . Ruby les appelle des " méthodes dangereuses " car elles changent d'état auquel quelqu'un d'autre pourrait avoir une référence. Voici un exemple simple pour les chaînes:

foo = "A STRING"  # a string called foo
foo.downcase!     # modifies foo itself
puts foo          # prints modified foo

Cela produira:

a string

Dans les bibliothèques standard, il y a beaucoup d'endroits où vous verrez des paires de méthodes de nom similaire, une avec !et une sans. Ceux sans sont appelés "méthodes sûres", et ils retournent une copie de l'original avec les modifications appliquées à la copie , avec l'appelé inchangé. Voici le même exemple sans !:

foo = "A STRING"    # a string called foo
bar = foo.downcase  # doesn't modify foo; returns a modified string
puts foo            # prints unchanged foo
puts bar            # prints newly created bar

Cela produit:

A STRING
a string

Gardez à l'esprit que ce n'est qu'une convention, mais beaucoup de classes Ruby la suivent. Il vous aide également à garder une trace de ce qui est modifié dans votre code.

Le point d'exclamation signifie beaucoup de choses, et parfois vous ne pouvez pas en dire grand-chose d'autre que "c'est dangereux, soyez prudent".

Comme d'autres l'ont dit, dans les méthodes standard, il est souvent utilisé pour indiquer une méthode qui provoque la mutation d'un objet, mais pas toujours. Notez que de nombreuses méthodes standard changer leur récepteur et ne dispose pas d' un point d'exclamation ( pop, shift, clear), et quelques méthodes avec des points d'exclamation ne changent pas leur récepteur ( exit!). Voir cet article par exemple.

D'autres bibliothèques peuvent l'utiliser différemment. Dans Rails, un point d'exclamation signifie souvent que la méthode lèvera une exception en cas d'échec plutôt que d'échouer silencieusement.

C'est une convention d'appellation mais beaucoup de gens l'utilisent de manière subtilement différente. Dans votre propre code, une bonne règle est de l'utiliser chaque fois qu'une méthode fait quelque chose de "dangereux", en particulier lorsque deux méthodes portant le même nom existent et que l'une d'entre elles est plus "dangereuse" que l'autre. "Dangereux" peut cependant signifier presque n'importe quoi.

Cette convention de dénomination est supprimée du schéma .

1.3.5 Conventions de dénomination

Par convention, les noms des procédures qui renvoient toujours une valeur booléenne se terminent généralement par ``? ''. Ces procédures sont appelées prédicats.

Par convention, les noms des procédures qui stockent des valeurs dans des emplacements précédemment alloués (voir section 3.4) se terminent généralement par ``! ''. De telles procédures sont appelées procédures de mutation. Par convention, la valeur renvoyée par une procédure de mutation n'est pas spécifiée.

! signifie généralement que la méthode agit sur l'objet au lieu de renvoyer un résultat. Extrait du livre Programming Ruby :

Les méthodes qui sont «dangereuses» ou qui modifient le récepteur peuvent être nommées avec un «!» De fin.

Il est plus juste de dire que les méthodes avec un Bang! sont la version la plus dangereuse ou surprenante . Il existe de nombreuses méthodes qui mutent sans Bang, telles que.destroy et en général, les méthodes n'ont que des bangs où une alternative plus sûre existe dans la lib de base.

Par exemple, sur Array, nous avons .compactet .compact!, les deux méthodes mutent le tableau, mais.compact! retournent nil au lieu de self s'il n'y a pas de nil dans le tableau, ce qui est plus surprenant que de simplement retourner self.

La seule méthode non que j'ai trouvé muter avec un bang Kernel« s .exit!qui est plus surprenant que .exitparce que vous ne pouvez pas attraper SystemExitalors que le processus se ferme.

Rails et ActiveRecord poursuivent cette tendance dans la mesure où ils utilisent le bang pour des effets plus «surprenants» comme ceux .create!qui provoquent des erreurs en cas d'échec.

De themomorohoax.com:

Un bang peut être utilisé de la manière suivante, dans l'ordre de mes préférences personnelles.

1) Une méthode d'enregistrement active génère une erreur si la méthode ne fait pas ce qu'elle dit.

2) Une méthode d'enregistrement active enregistre l'enregistrement ou une méthode enregistre un objet (par exemple une bande!)

3) Une méthode fait quelque chose de «supplémentaire», comme des publications à un endroit ou fait une action.

Le point est: n'utilisez un bang que lorsque vous avez vraiment réfléchi à la nécessité, pour éviter aux autres développeurs la gêne d'avoir à vérifier pourquoi vous utilisez un bang.

Le bang fournit deux indices aux autres développeurs.

1) qu'il n'est pas nécessaire de sauvegarder l'objet après avoir appelé la méthode.

2) lorsque vous appelez la méthode, la base de données va être modifiée.

http://www.themomorohoax.com/2009/02/11/when-to-use-a-bang-exclamation-point-after-rails-methods

Explication simple:

foo = "BEST DAY EVER" #assign a string to variable foo.

=> foo.downcase #call method downcase, this is without any exclamation.

"best day ever"  #returns the result in downcase, but no change in value of foo.

=> foo #call the variable foo now.

"BEST DAY EVER" #variable is unchanged.

=> foo.downcase! #call destructive version.

=> foo #call the variable foo now.

"best day ever" #variable has been mutated in place.

Mais si jamais vous appelez une méthode downcase!dans l'explication ci-dessus, fooelle deviendrait définitivement downcase. downcase!ne retournerait pas un nouvel objet chaîne mais remplacerait la chaîne en place, changeant totalement le fooen downcase. Je vous suggère de ne pas l'utiliser à downcase!moins que ce ne soit totalement nécessaire.

!

J'aime à voir cela comme un changement explosif qui détruit tout ce qui l'a précédé. Un coup ou un point d'exclamation signifie que vous apportez une modification enregistrée permanente dans votre code.

Si vous utilisez par exemple la méthode de Ruby pour la substitution globalegsub! la substitution que vous effectuez est permanente.

Vous pouvez également l'imaginer en ouvrant un fichier texte et en effectuant une recherche et un remplacement, suivi de l'enregistrement. !fait de même dans votre code.

Un autre rappel utile si vous venez du monde bash est sed -ia cet effet similaire de faire un changement enregistré permanent.

Appelées «méthodes destructives», elles ont tendance à modifier la copie originale de l'objet auquel vous faites référence.

numbers=[1,0,10,5,8]
numbers.collect{|n| puts n*2} # would multiply each number by two
numbers #returns the same original copy
numbers.collect!{|n| puts n*2} # would multiply each number by two and destructs the original copy from the array
numbers   # returns [nil,nil,nil,nil,nil]

Conclusion: les !méthodes modifient simplement la valeur de l'objet auquel elles sont appelées, tandis qu'une méthode sans! retourne une valeur manipulée sans écraser l'objet auquel la méthode a été appelée.

À utiliser uniquement !si vous ne prévoyez pas d'avoir besoin de la valeur d'origine stockée dans la variable sur laquelle vous avez appelé la méthode.

Je préfère faire quelque chose comme:

foo = "word"
bar = foo.capitalize
puts bar

OU

foo = "word"
puts foo.capitalize

Au lieu de

foo = "word"
foo.capitalize!
puts foo

Juste au cas où je voudrais accéder à nouveau à la valeur d'origine.