Ce sont ceux qui sont les symboles de tuyau pour en Ruby?

Quels sont les symboles de tuyau pour en Ruby?

Je suis en train d'apprendre Ruby et RoR, venant de PHP et Java arrière-plan, mais je continue à venir à travers un code comme ceci:

def new 
  @post = Post.new

  respond_to do |format|
    format.html # new.html.erb
    format.xml { render :xml => @post }
  end
end

Quel est le |format| partie faire? Ce qui est l'équivalent de la syntaxe de ces symboles de tuyau en PHP/Java?

InformationsquelleAutor Philip Morton | 2009-03-20

ruby syntax

51

Ils sont les variables qui ont donné au bloc.
```
def this_method_takes_a_block
  yield(5)
end

this_method_takes_a_block do |num|
  puts num
end
```
Qui affiche "5". Un plus des arcanes exemple:
```
def this_silly_method_too(num)
  yield(num + 5)
end

this_silly_method_too(3) do |wtf|
  puts wtf + 1
end
```
La sortie est à "9".
- d'où vient wtf aller quand le |wtf| bloc se termine?
- C'est dans l'étendue du bloc, il est donc indisponible en dehors d'elle. En d'autres termes: il s'en va.
- Si il muable? Il doit être, sinon je n'ai pas la moindre idée de comment Vagrantfile peut les utiliser comme une méthode de configuration.
- Vous ne savez pas si j'ai bien compris votre question. C'est juste un nom de référence à un objet.
- Mutable ce qui signifie que vous pouvez la persistance de changer le nom de référence, par opposition à l'immuable, qui ne peut pas être modifié, par exemple, la variable devrait être réaffecté les muté valeur si vous vouliez conserver un changement.
- Je ne suis pas sûr si vous pouvez changer ce que " wtf " points à l'intérieur du bloc, et/ou ce genre d'erreur que vous pourriez obtenir si vous ne pouvez pas. Mais il peut changer au cours de l'exécution du programme, puisque c'est essentiellement le même comme un argument de fonction, la tenue quelle que soit la valeur de l'appelant de yield passé.
InformationsquelleAutor August Lilleaas
32

C'était très étrange pour moi aussi au début, mais j'espère que cette explication/walkthru vous aide.

La documentation touche le sujet, dans une très bonne façon - si ma réponse ne vous aide pas, je suis sûr que leur guide.

D'abord, le feu Interactif interpréteur Ruby en tapant irb dans votre coquille et en appuyant sur la touche Entrée.

Tapez quelque chose comme:
```
the_numbers = ['ett','tva','tre','fyra','fem'] # congratulations! You now know how to count to five in Swedish.
```
juste de sorte que nous avons un tableau de jouer avec. Nous créons ensuite la boucle:
```
the_numbers.each do |linustorvalds|
    puts linustorvalds
end
```
Il sortira tous les nombres, séparés par des sauts de ligne.

Dans d'autres langues, vous devriez écrire quelque chose comme:
```
for (i = 0; i < the_numbers.length; i++) {
    linustorvalds = the_numbers[i]
    print linustorvalds;
}
```
Les choses importantes à noter que le |thing_inside_the_pipes| peut être n'importe quoi, tant que vous l'utilisez régulièrement. Et de comprendre qu'il est des boucles dont nous parlons, c'était une chose que je n'ai pas eu jusqu'à plus tard.
- Dans certains "autres langues" (Python), vous écrivez for linustorvalds in the_numbers do print linustorvalds. Un peu plus intuitive, peut-être.
- Tout à fait exact. J'ai choisi le C-la syntaxe de style que je pense que plus de gens à venir à ruby sont familiers avec, mais j'espère qu'ils ont lu votre commentaire ainsi.
- Je vous remercie. Les "autres langues", l'article m'a aidé à comprendre ce qui se passait. +1.
InformationsquelleAutor Martin Josefsson
6
```
@names.each do |name|
  puts "Hello #{name}!"
end
```
à http://www.ruby-lang.org/en/documentation/quickstart/4/ est accompagné par cette explication:

each est une méthode qui accepte un bloc de code, puis exécute le bloc de code pour chaque élément dans une liste, et le peu entre les do et end est juste comme un bloc. Un bloc est comme une fonction anonyme ou lambda. La variable entre le tuyau de caractères est le paramètre de ce bloc.

Ce qui se passe ici est que, pour chaque entrée dans une liste, name est lié à cet élément de la liste, et puis l'expression puts "Hello #{name}!" est exécuté avec ce nom.

InformationsquelleAutor Philip Durbin
6

Le code de la do à la end définit un Ruby bloc. Le mot format est un paramètre dans le bloc. Le bloc est transmis en même temps que l'appel de la méthode, et la méthode appelée pouvez yield valeurs pour le bloc.

Voir tout le texte sur le Rubis pour les détails, c'est une caractéristique fondamentale de Rubis que vous verrez tout le temps.
- Non, le code entre le do et la fin est un rubis bloc. Les termes entre les barres verticales sont les paramètres de ce bloc.
- IIRC, le tuyau de la syntaxe est emprunté à partir de Smalltalk.
- Yep, sauf Smalltalk juste utilisé un tuyau.
InformationsquelleAutor unwind
3

L'équivalent en Java serait quelque chose comme
```
// Prior definitions

interface RespondToHandler
{
    public void doFormatting(FormatThingummy format);
}

void respondTo(RespondToHandler)
{
    // ...
}

// Equivalent of your quoted code

respondTo(new RespondToHandler(){
    public void doFormatting(FormatThingummy format)
    {
        format.html();
        format.xml();
    }
});
```
- Brent, si vous entendez par là, que la version de Java est détaillé et verbeuse - yep, je serai d'accord avec vous. Mais là encore, c'est moins idiomatiques de la construction en Java. Ruby utilise tout le temps, Java moins.
- l'format.html(); format.xml(); partie serait probablement plus comme une instruction switch, comme vous pouvez vous en passer sur le format qui a été demandé.
- Un nettoyant exemple est l'équivalent de la construction en JavaScript: respond_to(new function(format) { format.html(); format.xml(); }); je trouve Java manque de vrai foncteur de soutien vraiment ennuyeux; ils ne sont pas difficiles à utiliser à tout - sauf si vous avez appris avec anonyme classes en Java!
InformationsquelleAutor Jon Bright
3

Les paramètres d'un bloc de s'asseoir entre les | symboles.

InformationsquelleAutor dylanfm
1

Pour le rendre encore plus claire, si nécessaire:

la pipe bars essentiellement faire une nouvelle variable pour stocker la valeur générée par l'appel de la méthode avant. Quelque chose qui ressemble à:

Définition d'origine de votre méthode:
```
def example_method_a(argumentPassedIn)
     yield(argumentPassedIn + 200)
end
```
Comment Il est utilisé:
```
example_method_a(100) do |newVariable|
    puts newVariable;
end
```
C'est presque la même que l'écriture de ce:
```
newVariable = example_method_a(100) 
puts newVariable
```
où, newVariable = 200 + 100 = 300 :D!

InformationsquelleAutor Jesse

Vous devez vous connecter pour publier un commentaire.