Array.map() あれこれ

# Array.map() あれこれ

関数の中でmapが好きなので、いろいろな言語のmapを調べてみました。

※ここで言うmapは、主に配列（言語によってはリスト）を受け取って、内部で処理して（多くは無名関数などのコールバック関数）、新しい配列を作って返すような言語に込み込みの標準関数を想定しています。

# mapの気に入っているところ

個人的に下記が気に入っている理由です。



*   ループ処理を書かなくて良い
*   元の配列に影響しない
*   コードが短くて済む

# JavaScript

ここ1年くらいはJSしか書いてないですが。JSでは、個人的にforやforEachよりもmapを良く使います。



*   MDN [Array.prototype.map()](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/map)

```javascript

const array = ['Perl', 'Ruby', 'Scala'];
console.log(array);
let array2 = array.map(v => `Hello ${v}!`);
console.log(array2);
```

# Ruby

RubyのmapはArrayクラスの実装では無く、Arrayクラスが継承する[Enumerable](https://docs.ruby-lang.org/ja/latest/class/Enumerable.html)モジュールにあるんですね。



* [instance method Enumerable#collect](https://docs.ruby-lang.org/ja/latest/method/Enumerable/i/collect.html)

```ruby
array = ['Perl', 'Ruby', 'Scala']
p array
array2 = array.map {|v| "Hello #{v}!"}
p array2
```

# Perl

map歴はPerlからですが、Rubyを使った時にPerlとmapへの配列の渡し方が違うので戸惑いました。



*   [map](https://perldoc.perl.org/5.32.0/functions/map.html)

```perl

my @array = ('Perl', 'Ruby', 'Scala');
print("@array\n");
my @array2 = map { "Hello $_!" } @array;
print("@array2");
```

# Scala

ScalaはJavaとRubyなどのスクリプト言語の手軽さを合わせたような言語です（個人的なイメージ）



*   [List](https://www.scala-lang.org/api/current/scala/collection/immutable/List.html)

```scala
    val array = List("Perl", "Ruby", "Scala")
    println(array)
    val array2 = array.map(v => s"Hello $v!")
    println(array2)
```

# Clojure

Scalaと同じく、JVM上で動作するLisp記法の言語で関数型と並列処理が強み（個人的なイメージです）



*   [map](https://clojuredocs.org/clojure.core/map)

```clojure

(def array ["Perl" "Ruby" "Scala"])
(println array)
(def array2 (map #(format "Hello %s!" %) array))
(println array2)
```

[https://clojuredocs.org/clojure.core/format](https://clojuredocs.org/clojure.core/format)

# PHP

PHPも[無名関数](https://www.php.net/manual/ja/functions.anonymous.php)が使えるんですね。



*   [array_map](https://www.php.net/manual/ja/function.array-map.php)

```php

<?php
$array = ['Perl', 'Ruby', 'Scala'];
var_dump($array);
$array2 = array_map(function ($v){return "Hello " . $v . "!";}, $array);
var_dump($array2);
?>
```

[アロー関数](https://www.php.net/manual/ja/functions.arrow.php)

# Swift

Swift使ったこと無いですが、型推論があるようでスクリプト言語っぽく書けるので中々良いかもです。

変数の文字列展開は\(変数名)な感じで書けます。



*   [map](https://developer.apple.com/documentation/swift/array/3017522-map)

```swift

let array = ["Perl", "Ruby", "Scala"]
print(array)
let array2 = array.map {"Hello \($0)!"}
print(array2)
```

# Python

大人気言語パイソンです。Pythonでは無名関数の定義にlambdaと言う宣言？を使うようです。



*   [map](https://docs.python.org/ja/3/library/functions.html#map)

```python

array = ["Perl", "Ruby", "Scala"];
print(array);
array2 = list(map(lambda v: "Hello " + v + "!", array));
print(array2);
```

[lambda](https://docs.python.org/ja/3/reference/expressions.html#lambda)
[f-string](https://docs.python.org/ja/3/reference/lexical_analysis.html#formatted-string-literals)
`array2 = list(map(lambda v: f"Hello {v}!", array));`
[リスト内包表記](https://docs.python.org/ja/3/tutorial/datastructures.html#list-comprehensions)

# Haskell

Haskellです。関数型言語で型推論を持つ言語です。（多分）



*   [map](https://hackage.haskell.org/package/base-4.14.0.0/docs/Data-List.html#v:map)


```haskell
main = do
  let array = ["Perl", "Ruby", "Scala"]
  print array
  let array2 = map (\ v -> "Hello " ++ v ++ "!") array
  print array2
```

# 感想

kintoneアプリ開発の会社に所属している為、普段は限定された範囲のJavaScriptしか書かないのですが、書籍を持っている範囲の言語で1つの関数の使い方をまとめてみると、言語によっていろいろな考え方などを発見することが出来たので、良かったと思います。

JavaScriptで関数言語のような使い方に傾倒しているので、ScalaとClojureは書きやすいなと感じています。（あと、Swiftも意外と違和感が無かった）

# 参考

動作確認には [paiza.IO](https://paiza.io/ja) を利用させていただきました。ありがとうございます。

# Go

GoにはArray.map()に相当するものが、そもそも無いようでした。

```go
package main
import "fmt"
func main(){
    array := []string{"Perl", "Ruby", "Scala"}
    fmt.Println(array)
    var array2 []string
    for _, v := range array {
        array2 = append(array2, "Hello " + v + "!")
    }
    fmt.Println(array2)
}
```

# Rust

https://www.rust-lang.org/ja

```rust
fn main(){
    let array = vec!["Perl", "Ruby", "Scala"];
    println!("{:?}", array);
    let array2: Vec<String> = array.iter().map(|v| format!("Hello, {}!", v)).collect();
    println!("{:?}", array2);
}
```

# Java

```
import java.util.*;
import java.text.*;

public class Main {
    public static void main(String[] args) throws Exception {
        List<String> array = Arrays.asList("Perl", "Ruby", "Scala");
        System.out.println(array);
        List<String> array2 = new ArrayList<>();
        for (String v : array) {
            array2.add(MessageFormat.format("Hello {0}!", v));
        }
        System.out.println(array2);
    }
}
```
# Kotlin

```
fun main(args: Array<String>) {
    val array = mutableListOf("Perl", "Ruby", "Scala")
    println(array)
    val array2 = mutableListOf<String>()
    for (v in array) {
        array2.add("Hello ${v}!")
    }
    println(array2)
}
```