Y at-il une différence entre foreach et carte?

Question

Ok cela est plus une question de science informatique, qu'une question basée sur une langue particulière, mais est-il une différence entre une opération de carte et une opération de foreach? Ou sont-ils simplement des noms différents pour la même chose?

Answer 1

Une autre.

foreach itère sur une liste et applique une opération avec des effets secondaires à chaque membre de la liste (par exemple d'enregistrer chacun à la base de données par exemple)

Carte itère sur une liste, transforme chaque élément de cette liste, et renvoie une autre liste de la même taille avec les membres transformées (telles que la conversion d'une liste de chaînes en majuscules)

Answer 2

La différence importante entre eux est que tous accumule map les résultats dans une collection, alors que rien ne retourne foreach. Est généralement utilisé <=> lorsque vous souhaitez transformer une collection d'éléments avec une fonction, alors que simplement une exécute <=> action pour chaque élément.

Answer 3

En bref, foreach est destiné à appliquer une opération sur chaque élément d'un ensemble d'éléments, alors que map est de transformer une collection en un autre.

Il existe deux différences significatives entre et copy transform.

1. <=> n'a pas de restrictions conceptuelles sur l'opération qu'elle applique, sauf peut-être accepter un élément comme argument. Autrement dit, l'opération ne peut rien faire, peut avoir un effet secondaire, peut retourner une valeur ou ne peut pas retourner une valeur. Tout est se soucie <=> itérer sur un ensemble d'éléments, et appliquer l'opération sur chaque élément.

   <=>, d'autre part, a une restriction sur l'opération: elle attend l'opération pour revenir un élément, et probablement aussi accepter un élément comme argument. Les <=> opération effectue une itération sur une collection d'éléments, en appliquant l'opération sur chaque élément, et enfin stockage du résultat de chaque invocation de l'opération dans une autre collection. En d'autres termes, le <=> transforme une collection dans une autre.

2. <=> fonctionne avec un seul ensemble d'éléments. Ceci est la collection d'entrée.

   <=> fonctionne avec deux collections d'éléments:. La collecte d'entrée et de sortie de la collection

Il est pas une erreur de relier les deux algorithmes: en fait, vous pouvez voir les deux hiérarchisés, où une spécialisation est <=> de <=>. Autrement dit, vous pouvez utiliser et avoir la <=> opération de transformation de son argumentation et l'insérer dans une autre collection. Ainsi, l'algorithme est une abstraction <=>, une généralisation, de l'algorithme <=>. En fait, parce que aucune restriction n'a <=> sur son fonctionnement, nous pouvons affirmer sans crainte que le mécanisme est <=> en boucle plus simple là-bas, et il peut faire quoi que ce soit une boucle peut faire. <=>, ainsi que d'autres algorithmes plus spécialisés, est là pour l'expressivité: si vous souhaitez la carte (ou transformer) une collection dans une autre, votre intention est plus claire si vous utilisez que si vous <=> utilisez <=> <. / p>

Nous pouvons étendre cette discussion plus loin, et considérer l'algorithme <=>: une boucle qui clone une collection. Cet algorithme est aussi une spécialisation de l'algorithme <=>. Vous pouvez définir une opération qui, étant donné un élément, insérera ce même élément dans une autre collection. Si vous utilisez cette opération avec <=> vous en effet effectué l'algorithme <=>, mais avec clarté réduite, ou expressivité explicitation. Prenons encore plus loin: On peut dire que la spécialisation est une <=> de <=>, elle-même une spécialisation de <=>. Peut <=> changement l'un des éléments qu'elle parcourt. Si ne change <=> aucun des éléments il simplement copier les éléments, et en utilisant Copier exprimerait l'intention plus clairement.

L'algorithme lui-même peut ou <=> ne peut pas avoir une valeur de retour, en fonction de la langue. En C ++, par exemple, l'opération retourne <=> il a reçu à l'origine. L'idée est que l'opération pourrait avoir un état, et vous voudrez peut-être cette opération de retour pour inspecter la façon dont il a évolué au cours des éléments. <=>, aussi, peut ou non retourner une valeur. En C ++ <=> (l'équivalent de <=> ici) arrive à retourner un itérateur à l'extrémité du récipient de sortie (collecteur). Dans Ruby, la valeur de retour de <=> est la séquence de sortie (collecteur). Ainsi, la valeur de retour des algorithmes est vraiment un détail de mise en œuvre; leur effet peut ou peut ne pas être ce qu'ils reviennent.

Answer 4

méthode et sont tous les deux tout à fait Array.protototype.map similaire Array.protototype.forEach.

Exécuter le code suivant: http://labs.codecademy.com/bw1/6#:workspace

var arr = [1, 2, 3, 4, 5];

arr.map(function(val, ind, arr){
    console.log("arr[" + ind + "]: " + Math.pow(val,2));
});

console.log();

arr.forEach(function(val, ind, arr){
    console.log("arr[" + ind + "]: " + Math.pow(val,2));
});

Ils donnent le résultat ditto exact.

arr[0]: 1
arr[1]: 4
arr[2]: 9
arr[3]: 16
arr[4]: 25

arr[0]: 1
arr[1]: 4
arr[2]: 9
arr[3]: 16
arr[4]: 25

Mais la torsion vient lorsque vous exécutez le code suivant: -

Ici, j'ai simplement attribué le résultat de la valeur de retour de la carte et les méthodes forEach.

var arr = [1, 2, 3, 4, 5];

var ar1 = arr.map(function(val, ind, arr){
    console.log("arr[" + ind + "]: " + Math.pow(val,2));
    return val;
});

console.log();
console.log(ar1);
console.log();

var ar2 = arr.forEach(function(val, ind, arr){
    console.log("arr[" + ind + "]: " + Math.pow(val,2));
    return val;
});

console.log();
console.log(ar2);
console.log();

Maintenant, le résultat est quelque chose de délicat!

arr[0]: 1
arr[1]: 4
arr[2]: 9
arr[3]: 16
arr[4]: 25

[ 1, 2, 3, 4, 5 ]

arr[0]: 1
arr[1]: 4
arr[2]: 9
arr[3]: 16
arr[4]: 25

undefined

Conclusion

Array.prototype.map retourne un tableau, mais ne le fait pas Array.prototype.forEach. Ainsi, vous pouvez manipuler le tableau retourné dans la fonction de rappel passée à la méthode de carte, puis le retourner.

<=> marche seulement à travers le tableau donné afin que vous puissiez faire vos affaires tout en marchant le tableau.

Answer 5

la plus grande différence « visible » est que la carte accumule le résultat dans une nouvelle collection, alors que foreach est fait seulement pour l'exécution elle-même.

mais il y a quelques hypothèses supplémentaires: puisque le « but » de la carte est la nouvelle liste de valeurs, il ne compte pas vraiment l'ordre d'exécution. en fait, certains environnements d'exécution génèrent du code parallèle, ou même introduire une memoizing pour éviter d'appeler des valeurs répétées ou lazyness, pour éviter d'appeler un peu du tout.

foreach, d'autre part, est appelé spécifiquement pour les effets secondaires; Par conséquent, l'ordre est important, et ne peut généralement pas être parallélisé.

Answer 6

Réponse courte: et map sont différents forEach. De plus, en parlant de façon informelle, est une surcouche each stricte printSquares.

Réponse longue: Tout d'abord, nous allons venir avec une description de la ligne de et arr selfDot:

• prototype itère sur tous les éléments, en appelant la fonction fournie sur chacun.
• map() itère sur tous les éléments, en appelant la fonction fournie sur chacune, et produit un tableau transformé en se rappelant le résultat de chaque appel de fonction.

Dans de nombreuses langues, est souvent appelé forEach() juste a. La discussion suivante utilise Java script uniquement pour référence. Il pourrait vraiment être une autre langue.

Maintenant, nous allons utiliser chacune de ces fonctions.

Utilisation a[i] === i:

Tâche 1: Ecrire une fonction i < a.length, qui accepte un tableau de nombres <=>, et imprime le carré de chaque élément dans ce

.

Solution 1:

var printSquares = function (arr) {
    arr.forEach(function (n) {
        console.log(n * n);
    });
};

Utilisation <=>:

Étape 2:. Ecrire une fonction <=>, qui accepte un tableau de nombres <=>, et retourne un tableau dans lequel chaque élément est le carré de l'élément correspondant de <=>

En plus: Ici, en termes d'argot, nous essayons de la quadrature du tableau d'entrée. Formellement dit, nous essayons de calculer c'est produit scalaire avec lui-même.

Solution 2:

var selfDot = function (arr) {
    return arr.map(function (n) {
        return n * n;
    });
};

Comment est une surcouche de <=> <=>?

Vous pouvez utiliser pour résoudre les deux <=> tâches, Tâche 1 et 2 Tâche . Cependant, vous ne pouvez pas utiliser pour résoudre le <=> 2 Tâche .

Solution 1 , si vous remplacez simplement par <=> <=>, la solution sera toujours valide. Solution 2 Toutefois, en remplaçant par <=> cassera votre <=> solution de travail précédemment.

Mise en œuvre en termes de <=> <=>:

Une autre façon de réaliser la supériorité de la mise en œuvre est <=> en termes de <=> <=>. Comme nous sommes bons programmeurs, nous ne laissons aller à la pollution de l'espace de noms. Nous appellerons nos <=>, juste <=>.

Array.prototype.each = function (func) {
    this.map(func);
};

Maintenant, si vous ne voulez pas le non-sens <=>, ici vous allez:

var each = function (arr, func) {
    arr.map(func); // Or map(arr, func);
};

Alors, euh .. Pourquoi ça n'existe même <=>?

La réponse est l'efficacité. Si vous n'êtes pas intéressé à transformer un tableau dans un autre tableau, pourquoi devriez-vous calculer le tableau transformé? Seulement pour le vider? Bien sûr que non! Si vous ne voulez pas une transformation, vous ne devriez pas faire une transformation.

Ainsi, alors que la carte peut être utilisée pour résoudre Tâche 1 , il ne devrait probablement pas. Pour chacun d'eux est le bon candidat pour cela.

---

Réponse originale:

Alors que je suis d'accord en grande partie avec la réponse de l » @madlep, je voudrais souligner que est un <=> super-set stricte <=>.

Oui, est généralement utilisé <=> pour créer un nouveau tableau. Cependant, il peut aussi être utilisé pour changer le tableau en cours.

Voici un exemple:

var a = [0, 1, 2, 3, 4], b = null;
b = a.map(function (x) { a[x] = 'What!!'; return x*x; });
console.log(b); // logs [0, 1, 4, 9, 16] 
console.log(a); // logs ["What!!", "What!!", "What!!", "What!!", "What!!"]

Dans l'exemple ci-dessus, était bien réglée <=> telle que pour <=> <=>. Malgré cela, il démontre la puissance de <=>.

Voici la description officielle de <=>. Notez que peut même changer <=> le tableau sur lequel il est appelé! Je vous salue, <=>.

Espérons que cela a aidé.

---

Edité 10-Nov-2015:. Élaboration Ajouté

Answer 7

Voici un exemple en utilisant des listes Scala: carte retourne la liste, foreach ne retourne rien.

def map(f: Int ⇒ Int): List[Int]
def foreach(f: Int ⇒ Unit): Unit

Alors carte renvoie la liste résultant de l'application de la fonction f pour chaque élément de la liste:

scala> val list = List(1, 2, 3)
list: List[Int] = List(1, 2, 3)

scala> list map (x => x * 2)
res0: List[Int] = List(2, 4, 6)

Foreach applique tout f à chaque élément:

scala> var sum = 0
sum: Int = 0

scala> list foreach (sum += _)

scala> sum
res2: Int = 6 // res1 is empty

Answer 8

Si vous parlez Javascript en particulier, la différence est que est une fonction map de boucle while est un iterator forEach.

Utilisez quand vous voulez <=> appliquer une opération à chaque membre de la liste et obtenir les résultats de retour dans une nouvelle liste, sans affecter la liste initiale.

Utilisez quand vous voulez <=> faire quelque chose sur la base de chaque élément de la liste. Vous pourriez ajouter des choses à la page, par exemple. Pour l'essentiel, il est idéal lorsque vous voulez « effets secondaires ».

Autres différences: <=> ne renvoie rien (car il est vraiment une fonction de contrôle de flux), et la fonction passée en obtient des références à l'index et la liste, alors que la carte retourne la nouvelle liste et passe seulement dans le courant élément.

Answer 9

ForEach essaie d'appliquer une fonction telle que l'écriture à db etc sur chaque élément du RDD sans rien de revenir en arrière.

Mais la applique une fonction map() sur les éléments de RDD et retourne le RDD. Ainsi, lorsque vous exécutez la méthode ci-dessous, il ne manquera pas à line3 mais tout en collectant le RDD après l'application foreach il échouera et jeter une erreur qui dit

  

Fichier "", ligne 5, dans

     

AttributeError: objet 'NoneType' n'a pas d'attribut 'Collect'

nums = sc.parallelize([1,2,3,4,5,6,7,8,9,10])
num2 = nums.map(lambda x: x+2)
print ("num2",num2.collect())
num3 = nums.foreach(lambda x : x*x)
print ("num3",num3.collect())