Quelle est la “carte” la méthode le faire en Ruby?

Je suis nouveau en programmation. Quelqu'un peut m'expliquer ce que .map ferait dans:

params = (0...param_count).map

Posez une question à la fois. map est une commune "fonctionnelle" méthode trouvée sur Énumération des objets utilisés pour transformer les valeurs dans une séquence (avec des considérations spéciales). .. et ... sont des moyens de créer des plages. Aussi, de se familiariser avec le REPL, où vous pouvez essayer ce genre de choses vous-même! 🙂
REPL pour le rubis est la cisr pour les Rails, il est rails c. REPL vous permet de tester le code directement à l'encontre de la langue shell lui-même.

InformationsquelleAutor Edmund | 2012-08-23

419

La map méthode prend un objet énumérable et d'un bloc, et exécute le bloc pour chaque élément, en sortie de chaque valeur retournée par le bloc (de l'objet d'origine est inchangé, sauf si vous utilisez map!):
```
[1, 2, 3].map { |n| n * n } #=> [1, 4, 9]
```
Array et Range sont énumérables types. map avec un bloc retourne un Tableau. map! se transforme le tableau d'origine.

Où est-ce utile, et quelle est la différence entre map! et each? Voici un exemple:
```
names = ['danil', 'edmund']

# here we map one array to another, convert each element by some rule
names.map! {|name| name.capitalize } # now names contains ['Danil', 'Edmund']

names.each { |name| puts name + ' is a programmer' } # here we just do something with each element
```
La sortie:
```
Danil is a programmer
Edmund is a programmer
```
- grâce speransky pour l'exemple. alors comment est .carte différent .chaque?
- Ahhh je l'obtenir. Donc .carte de mutation de la matrice tout .chacun parcourt le tableau pour accéder aux valeurs, tout en laissant le tableau d'origine intacte?
- Je ne le pense pas. each et map fonctionne de la même manière, mais tout each est un itérateur seulement, map a map! forme, qui transforme un objet donné. Aussi map a un collect synonyme avec pas de différences.
- c'est sur @Edmund et de son commentaire, que vous pouvez voir juste au-dessus de la mienne, pour cette partie: "de la Sorte .carte de mutation de la matrice tout .chaque boucles tout". #map ne fait pas muter n'importe quoi, #map! n'.
- Il est dangereux pour les lecteurs occasionnels dans la première phrase décrit map comme si c'était map!
- n'était pas mauvais, mais qui pourrait être un peu plus explicite. Mise À Jour Q
- pour voir la différence entre la carte et chaque, ouvrez une fenêtre de la CISR et regardez les résultats de y et z dans le code suivant: y = [1,2,3].chaque {|x| x + 1}; z = [1,2,3].carte {|x| x + 1}
- Waouh, j'ai eu des réponses différentes à partir de deux d'entre eux, mais je ne comprends pas pourquoi est-ce donc?
- retourne un tableau qui l'appelle (dans l'exemple, [1,2,3]) lorsqu'un bloc est fourni, 'carte' renvoie un nouveau tableau rempli avec les valeurs calculées par le bloc. Cela peut aider à: définir la variable ary = [1,2,3], et vérifiez qu'il n'est object_id. Ensuite, exécutez y = ary.chaque {|x| x + 1}; z = ary.carte {|x| x + 1}. Maintenant, vérifiez l'object_id est de y et z. y a le même object_id comme ary (parce que chaque retourné ary), mais z est différent de object_id, parce que la carte a renvoyé un nouveau tableau.
InformationsquelleAutor Danil Speransky
62

map, avec select et each est l'un des Rubis de chevaux de trait dans mon code.

Il vous permet d'exécuter une opération sur chacun de vos tableau d'objets et de les renvoyer tous dans le même endroit. Un exemple serait d'incrémenter un tableau de nombres par un:
```
[1,2,3].map {|x| x + 1 }
#=> [2,3,4]
```
Si vous pouvez exécuter une méthode unique sur votre éléments du tableau, vous pouvez le faire dans un texte-style comme:
1. Pour ce faire avec l'exemple ci-dessus que vous avez à faire quelque chose comme ceci
```
class Numeric
  def plusone
    self + 1
  end
end
[1,2,3].map(&:plusone)
#=> [2,3,4]
```
2. Plus simplement utiliser l'esperluette raccourci technique, prenons un autre exemple:
```
["vanessa", "david", "thomas"].map(&:upcase)
#=> ["VANESSA", "DAVID", "THOMAS"]
```
De transformer des données en Ruby implique souvent une cascade de map opérations. Étude map & select, ils sont quelques-uns des plus utiles méthodes Ruby dans la bibliothèque du primaire. Ils sont aussi importants que each.

(map est aussi un alias pour collect. Utilisez ce qui fonctionne le mieux pour vous sur le plan conceptuel.)

Informations plus utiles:

Si le Énumérable objet que vous êtes en cours d'exécution each ou map sur contient un ensemble Énumérable éléments (tables de hachage, les tableaux), vous pouvez déclarer chacun de ces éléments à l'intérieur de votre bloc de tubes comme:
```
[["audi", "black", 2008], ["bmw", "red", 2014]].each do |make, color, year|
  puts "make: #{make}, color: #{color}, year: #{year}"
end
# Output:
# make: audi, color: black, year: 2008
# make: bmw, color: red, year: 2014
```
Dans le cas d'une table de Hachage (également un Enumerable objet, une table de Hachage est tout simplement un tableau de n-uplets avec des instructions spéciales pour l'interprète). La première "pipe paramètre" est la clé, la deuxième est la valeur.
```
{:make => "audi", :color => "black", :year => 2008}.each do |k,v|
    puts "#{k} is #{v}"
end
#make is audi
#color is black
#year is 2008
```
Pour répondre à la question réelle:

En supposant que params est une table de hachage, ce serait le meilleur moyen de la carte à travers: Utiliser deux paramètres de bloc au lieu d'une pour la capture de la clé & valeur paire pour chaque interprété tuple dans la table de hachage.
```
params = {"one" => 1, "two" => 2, "three" => 3}
params.each do |k,v|
  puts "#{k}=#{v}"
end
# one=1
# two=2
# three=3
```
- Cela ne fonctionne pas pour moi dans la cisr. Je reçois NoMethodError: private method 'plusone' called for 1:Fixnum en ruby 2 et "mauvais nombre d'arguments" en ruby 1.9/1.8. De toute façon, j'ai utilisé un lambda: plusone = ->(x) { x + 1 } sortir le symbole rédacteur de devis: [1,2,3].map(&plusone).
- hmm sonne comme vous avez déclaré private à l'intérieur de la classe dans laquelle vous mettez votre méthode avant de mettre votre méthode
- Ouais, c'est complètement n'. Sauf qu'il ne l'était pas. 🙁 Tout d'abord, il a été tout droit dans un script w/o classes, d'autre part, dans la plaine de la cisr. Voici mon copier/coller de ton code: gist.github.com/tjmcewan/a7e4feb2976a93a5eef9
- Ouais, je suis tout à fait juste mis un mauvais exemple dans mon code, je suis désolé. Essayez le code modifié. Il fonctionne maintenant...
- est-il un moyen de le faire avec une méthode normale — comme dans, pas une méthode de la classe?
- rien dans le code ci-dessus utilise les méthodes de la classe. Les méthodes de la classe sont déclarées à l'intérieur d'une classe par le présent code def self.methodnam. Ce que j'ai fait ci-dessus est de créer exemple méthodes via def methodnam.
- Il a été un certain temps depuis que j'ai posé cette question, mais je crois que je voulais dire "Peut-on carte sur une Énumération avec une méthode en dehors de la classe?" Mais il n'importe pas beaucoup plus 🙂
- "Ruby chevaux de bataille"
InformationsquelleAutor boulder_ruby
5

À l'aide de ruby 2.4 vous pouvez faire la même chose en utilisant transform_values, cette fonction extrait de rails ruby.
```
h = {a: 1, b: 2, c: 3}

h.transform_values { |v| v * 10 }
 #=> {a: 10, b: 20, c: 30}
```
InformationsquelleAutor tokhi
4

0..param_count signifie "jusqu'à et y compris param_count".
0...param_count signifie "jusqu'à, mais pas y compris param_count".

Range#map ne renvoie pas un Enumerable, il fait les cartes à un tableau. C'est le même que Range#to_a.

InformationsquelleAutor Pedro Nascimento
3

Il "cartes" d'une fonction à chaque élément dans un Enumerable - dans ce cas, une gamme. Alors il appelle le bloc passé une seule fois pour chaque nombre entier de 0 à param_count (exclusif - vous avez raison sur les points) et retourne un tableau contenant chaque valeur de retour.

Voici la documentation de Énumérable#map. Il dispose également d'un alias, collect.
- C'est bizarre, mais Range#map en fait la convertit en un tableau.
- Ouais... c'est ce que j'ai dit?
- Désolé, je ne savais pas que la carte appelée par lui-même n'a pas de retour d'un Enumerable, comme chaque. Je le croyais.
InformationsquelleAutor Ry-

Carte est une partie de l'énumérable module. Très similaire à "recueillir", Par Exemple:

  Class Car

    attr_accessor :name, :model, :year

    Def initialize (make, model, year)
      @make, @model, @year = make, model, year
    end

  end

  list = []
  list << Car.new("Honda", "Accord", 2016)
  list << Car.new("Toyota", "Camry", 2015)
  list << Car.new("Nissan", "Altima", 2014)

  p list.map {|p| p.model}

Carte fournit des valeurs d'une itération dans un tableau qui lui sont renvoyées par le bloc de paramètres.

la carte est exactement la même que la recueillir.

InformationsquelleAutor gkstr1

Vous devez vous connecter pour publier un commentaire.