Yang berbeda.

foreach iterates atas daftar dan menerapkan beberapa operasi dengan efek samping setiap daftar anggota (seperti menyimpan masing-masing satu ke database misalnya)

peta iterates atas daftar, berubah masing-masing anggota dari daftar itu, dan kembali daftar lain dengan ukuran yang sama dengan mengubah anggota (seperti mengubah daftar dari string ke huruf besar)

Perbedaan penting antara keduanya adalah bahwa peta terakumulasi semua hasil ke koleksi, sedangkan foreach mengembalikan apa-apa. peta ini biasanya digunakan ketika anda ingin mengubah sebuah kumpulan dari elemen-elemen dengan fungsi, sedangkan foreach hanya mengeksekusi suatu tindakan untuk masing-masing elemen.

Singkatnya, foreach adalah untuk menerapkan operasi pada masing-masing elemen dari suatu kumpulan dari elemen-elemen, sedangkan peta adalah untuk mengubah satu koleksi yang lain.

Ada dua perbedaan yang signifikan antara foreach dan peta.

1. foreach tidak memiliki konseptual pembatasan pada operasi itu berlaku, selain mungkin menerima unsur sebagai argumen. Artinya, operasi dapat melakukan apa-apa, mungkin memiliki efek samping, dapat mengembalikan nilai atau tidak mengembalikan nilai. Semua foreach peduli tentang adalah untuk iterate atas kumpulan dari elemen-elemen, dan menerapkan operasi pada masing-masing elemen.

peta, di sisi lain, tidak memiliki pembatasan pada operasi: ia mengharapkan operasi untuk mengembalikan unsur, dan mungkin juga menerima unsur sebagai argumen. Peta operasi iterates atas kumpulan dari elemen-elemen, menerapkan operasi pada masing-masing elemen, dan akhirnya menyimpan hasil dari setiap doa dari operasi ke koleksi lain. Dengan kata lain, peta transforms satu koleksi yang lain.

1. foreach bekerja dengan satu kumpulan dari elemen-elemen. Ini adalah koleksi input.

peta bekerja dengan dua koleksi dari unsur-unsur: koleksi input dan output koleksi.

Itu bukan sebuah kesalahan untuk menghubungkan dua algoritma: pada kenyataannya, anda mungkin melihat dua hierarkis, di mana peta adalah spesialisasi foreach. Artinya, anda bisa menggunakan foreach dan memiliki operasi mengubah argumen dan masukkan ke dalam koleksi yang lain. Jadi, foreach algoritma adalah sebuah abstraksi, generalisasi, dari peta algoritma. Pada kenyataannya, karena foreach tidak memiliki pembatasan pada operasi kita dapat dengan aman mengatakan bahwa foreach adalah yang paling sederhana perulangan mekanisme di luar sana, dan ia bisa melakukan apa-apa loop dapat dilakukan. peta, serta lainnya berupa algoritma, ada ekspresi: jika anda ingin peta (atau mengubah) satu koleksi ke yang lain, tujuan anda adalah jelas jika anda menggunakan peta dari jika anda menggunakan foreach.

Kita dapat memperpanjang diskusi ini lebih lanjut, dan mempertimbangkan copy algoritma: loop yang klon koleksi. Algoritma ini juga merupakan spesialisasi dari foreach algoritma. Anda bisa mendefinisikan sebuah operasi yang diberikan elemen, akan menyisipkan elemen yang sama dalam koleksi yang lain. Jika anda menggunakan foreach dengan operasi anda pada dasarnya melakukan copy algoritma, meskipun dengan mengurangi kejelasan, ekspresif atau ketegasan. Let's lebih jauh lagi: Kita dapat mengatakan bahwa peta adalah spesialisasi copy, sendiri merupakan spesialisasi dari foreach. peta mungkin change setiap elemen itu iterates atas. Jika peta doesn't mengubah salah satu elemen maka hanya copied unsur-unsur, dan menggunakan copy akan mengungkapkan maksud dengan lebih jelas.

The foreach algoritma itu sendiri mungkin atau mungkin tidak memiliki nilai kembali, tergantung pada bahasa. Dalam C++, misalnya, foreach kembali operasi itu awalnya diterima. Idenya adalah bahwa operasi mungkin memiliki sebuah negara, dan anda mungkin ingin bahwa operasi kembali untuk memeriksa bagaimana hal itu berevolusi lebih dari unsur-unsur. peta, terlalu, mungkin atau mungkin tidak mengembalikan nilai. Dalam C++ mengubah (setara untuk peta di sini) terjadi untuk mengembalikan sebuah iterator untuk akhir output wadah (koleksi). Di Ruby, nilai kembali dari peta adalah output urutan (koleksi). Jadi, nilai kembali dari algoritma adalah benar-benar sebuah implementasi detail; efek mereka mungkin atau mungkin tidak menjadi apa yang mereka kembali.

Array.protototype.peta metode & Array.protototype.forEach keduanya cukup mirip.

Jalankan kode berikut: 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));
});

Mereka memberikan tepat ditto hasil.

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

Tapi memutar datang ketika anda menjalankan kode berikut:-

Di sini saya've hanya ditugaskan hasil nilai kembali dari peta dan forEach metode.

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();

Sekarang hasilnya adalah sesuatu yang rumit!

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

Kesimpulan

Array.prototipe.peta mengembalikan array tapi Array.prototipe.forEach doesn't. Sehingga anda dapat memanipulasi array kembali dalam fungsi callback dilewatkan ke metode peta dan kemudian kembali.

Array.prototipe.forEach hanya berjalan melalui diberikan array sehingga anda dapat melakukan hal-hal yang sementara berjalan array.

yang paling 'terlihat' perbedaannya adalah bahwa peta terakumulasi hasil dalam koleksi baru, sementara foreach ini dilakukan hanya untuk eksekusi itu sendiri.

tetapi ada beberapa tambahan asumsi: sejak 'tujuan' peta adalah daftar yang baru dari nilai-nilai, itu doesn't benar-benar penting urutan eksekusi. bahkan, beberapa eksekusi lingkungan yang menghasilkan paralel kode, atau bahkan memperkenalkan beberapa memoizing untuk menghindari menyerukan berulang-nilai, atau malas, untuk menghindari memanggil beberapa di semua.

foreach, di sisi lain, disebut secara khusus untuk efek samping; oleh karena itu agar lebih penting, dan biasanya dapat't menjadi parallelised.

Jawaban singkat: peta dan forEach yang berbeda. Juga, berbicara secara informal, peta yang ketat superset dari forEach.

Jawaban panjang: Pertama, let's datang dengan satu baris deskripsi forEach dan peta:

• forEach iterates lebih dari semua elemen, menyebut disediakan pada fungsi masing-masing.
• peta iterates lebih dari semua elemen, menyebut disediakan pada fungsi masing-masing, dan menghasilkan berubah array dengan mengingat hasil dari setiap fungsi panggilan.

Dalam banyak bahasa, forEach sering disebut hanya masing-masing. Berikut diskusi menggunakan JavaScript hanya untuk referensi. Itu benar-benar bisa menjadi bahasa lain.

Sekarang, let's menggunakan masing-masing fungsi tersebut.

Menggunakan forEach:

Tugas 1: Menulis fungsi printSquares, yang menerima sebuah array dari angka arr, dan cetakan persegi yang setiap elemen di dalamnya.

Solusi 1:

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

Menggunakan peta:

Tugas 2: Menulis fungsi selfDot, yang menerima sebuah array dari angka arr, dan mengembalikan array dimana masing-masing elemen adalah kuadrat dari elemen yang sesuai dalam arr.

Selain Itu, dalam istilah slang, kami mencoba untuk persegi array input. Secara resmi, kami mencoba untuk menghitung itu's dot produk dengan dirinya sendiri.

Solusi 2:

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

Bagaimana peta superset dari forEach?

Anda dapat menggunakan peta untuk menyelesaikan tugas kedua, Tugas 1 dan Tugas 2. Namun, anda tidak dapat menggunakan forEach untuk memecahkan Tugas 2.

Di Solusi 1, jika anda cukup mengganti forEach dengan peta, solusi masih akan tetap berlaku. Di Solusi 2 namun, mengganti peta dengan forEach akan mematahkan anda sebelumnya bekerja solusi.

Menerapkan forEach dalam hal peta:

Cara lain untuk mewujudkan peta's superioritas adalah dengan menerapkan forEach dalam hal peta. Karena kami adalah programmer yang baik, kita'll won't memanjakan diri dalam namespace polusi. Kami'll hubungi kami forEach, hanya masing-masing.

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

Sekarang, jika anda don't seperti prototipe omong kosong, di sini anda pergi:

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

Jadi, umm.. Kenapa's tidak forEach bahkan ada?

Jawabannya adalah efisiensi. Jika anda tidak tertarik dalam mengubah sebuah array ke array lain, mengapa anda harus menghitung berubah array? Hanya untuk membuangnya? Tentu saja tidak! Jika anda don't ingin transformasi, seharusnya kau't melakukan transformasi.

Jadi sementara peta dapat digunakan untuk memecahkan Tugas 1, itu mungkin seharusnya't. Untuk masing-masing kandidat yang tepat untuk itu.

Jawaban asli:

Sementara saya sangat setuju dengan @madlep 's jawaban, aku'd ingin menunjukkan bahwa peta() adalah ketat super-set dari forEach().

Ya, peta() biasanya digunakan untuk membuat array baru. Namun, hal itu mungkin juga **** dapat digunakan untuk mengubah arus array.

Berikut ini's contoh:

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!!"]

Dalam contoh di atas, a itu terletak sedemikian rupa sehingga a[i] === aku untuk i < a.panjang. Meski begitu, hal ini menunjukkan kekuatan dari peta().

Di sini's keterangan resmi dari peta(). Perhatikan bahwa peta() bahkan dapat mengubah array yang disebut! Salam peta().

Semoga ini bisa membantu.

Diedit 10-Jan-2015: Menambahkan elaborasi.

Berikut ini adalah contoh di Scala menggunakan daftar: peta mengembalikan daftar, foreach mengembalikan apa-apa.

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

Jadi peta mengembalikan daftar yang dihasilkan dari penerapan fungsi f untuk setiap elemen list:

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 hanya berlaku f untuk masing-masing elemen:

scala> var sum = 0
sum: Int = 0

scala> list foreach (sum += _)

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

Jika anda're berbicara tentang Javascript khususnya, perbedaan adalah bahwa peta adalah fungsi loop sementara forEach adalah sebuah iterator.

Menggunakan peta ketika anda ingin menerapkan operasi untuk masing-masing anggota dari daftar dan mendapatkan hasil sebagai daftar baru, tanpa mempengaruhi asli daftar.

Gunakan forEach ketika anda ingin melakukan sesuatu atas dasar masing-masing elemen dari daftar. Anda mungkin akan menambahkan hal-hal ke halaman, misalnya. Pada dasarnya, it's bagus untuk ketika anda ingin "efek samping".

Perbedaan lainnya: forEach mengembalikan apa-apa (karena itu adalah benar-benar mengontrol fungsi aliran), dan berlalu-in fungsi mendapat referensi dan indeks seluruh daftar, sedangkan peta mengembalikan daftar baru dan hanya lewat di elemen saat ini.

ForEach mencoba untuk menerapkan fungsi seperti menulis untuk db dll pada setiap elemen dari DRD tanpa kembali apa-apa kembali.

Tapi peta() berlaku beberapa fungsi dari unsur-unsur drd dan kembali drd. Jadi, ketika anda berjalan di bawah metode ini tidak't gagal di line3 tapi sambil mengumpulkan drd setelah menerapkan foreach itu akan gagal dan melempar kesalahan yang mengatakan

File "<stdin>", line 5, dalam <modul>

AttributeError: 'NoneType' objek memiliki atribut 'mengumpulkan'

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())