前回に引き続き本記事でもLaravelの配列関連のへルパ関数を解説していきたいと思います。

参考になれば幸いです。

:::memo{title=Memo}
Laravelのバージョンは8系統になります。
:::

今回解説するへルパ関数は以下です。

:::info{title=本記事で取り扱うへルパ関数}
- **Arr::toCssClasses CSSのクラス文字を生成**
- **Arr::undot ドット記法を用いた一次元配列を多次元配列に変換**
- **Arr::where クロージャーを使用して配列要素をフィルタリング**
- **Arr::whereNotNull 配列ないからnull要素を削除**
- **Arr::wrap 指定した値を配列にラップ**
:::

本記事以外の配列のへルパ関数は下記からどうぞ！！

:::wrap
- [random、set、shuffle、sort、sortRecursive](https://dev-record-front.vercel.app/php/laravel-helper-array-5)
- [isAssoc、last、only、pluck、prepend、pull、query](https://dev-record-front.vercel.app/php/laravel-helper-array-4)
- [get、has、hasAny](https://dev-record-front.vercel.app/php/laravel-helper-array-3)
- [first、flatten、forget](https://dev-record-front.vercel.app/php/laravel-helper-array-2)
- [accessible、add、collapse、divide、crossJoin、dot、except、exists](https://dev-record-front.vercel.app/php/laravel-helper-array-1)
:::

### Arr::toCssClasses CSSのクラス文字を生成

:m[**配列を条件付きでCSSクラス文字に変換**]します。

:::info{title=toCssClasses}
**Arr::toCssClasses(配列): CSSクラス文字**

- **指定した配列をCSSクラス文字へ変換**
- **連想配列の場合は要素がtrueの場合にキーをCSSクラス文字へ変換**
- **添字配列の場合は常に要素をCSSクラス文字へ含める**
- 多次元配列は使用不可（エラー）
- コレクションもエラーにはならないが正しい挙動にならない
:::

配列をCSSのクラス文字に変換します。:m[**CSSのクラス文字とはHTMLタグに指定するclass**]のことです。
例えば、下記で言うと**main-content active**が**class**になります。

```html:classを含んだHTMLタグ
<div class="main-content active">
    <p>コンテンツ内容</p>
</div>
```

**Arr::toCssClassesはこのclassの文字列を配列から生成するへルパ関数**になります。

下記が使用例になります。

```php:使用例
// クラス文字列の元になる配列
$array = ['class-1' => true, 'class-2' => false, 'class-3'];
Arr::toCssClasses($array);

// 結果（指定した配列からクラス文字列を生成）
"class-1 class-3"
```

例からも分かるように、**クラス文字列として生成される要素には条件**があります。

:m[キーが含まれた要素の場合は**値がtrue**の場合に**キーの文字列がクラス文字列**として生成されます]。

**falseの場合はクラス文字列として生成されません。**

上記の使用例では`'class-1' => true`と`'class-2' => false` がキーを含んだ要素にあたり、

その中でも`'class-1' => true`は値が:m[**true**]であるため、:m[キーである**class-1**が**クラス文字列として生成**されています]。

:::memo{title=キーが含まれている要素}
- **値がtrueの場合、キーがクラス文字列として生成される。**
- 値がfalseの場合、クラス文字列として生成されない。
:::

:m[**添字配列**の要素は**常にクラス文字列**として生成されます]。

こちらも先程の使用例では`'class-3'`が添字配列の要素にあたり、**クラス文字列として生成**されているのがわかります。

:::memo{title=添字配列の要素}
- 値の文字列が常にクラス文字列として生成される。
:::

**多次元配列の場合はエラー**になり使用できません。

```php:多次元配列を使用（エラー）
$array = ['class-1' => true, 'class-2' => false, ['class-3', 'class-4']];
Arr::toCssClasses($array);

// エラー
// Array to string conversion
```

例では`['class-3', 'class-4']`部分が多次元配列になっているため`Array to string conversion`のエラーが出ています。

また、**コレクションの場合もエラーにはなりませんが、クラス文字列として生成されないため使用しない方がいいです**。

```php:コレクションを使用（エラー）
$collection = Collection::make(['class-1' => true, 'class-2' => false]);
Arr::toCssClasses($collection);

// 結果（要素がそのまま文字列として生成されてしまう）
"{"class-1":true,"class-2":false}"
```

例ではコレクション内の要素がそのまま文字列として出力されてしまっています。コレクションでの使用は避けましょう。

### Arr::undot ドット記法を用いた一次元配列を多次元配列に変換

:m[**ドット記法を用いた一次元配列を多次元配列に変換します**]。

:::info{title=undot}
**Arr::undot(配列): 配列**

- **ドット記法の一次元配列を多次元配列に変換**
- コレクションも使用可能
:::

使用例は以下の通りで、:m[**ドット記法部分を多次元配列に展開**]してくれます。

```php:使用例
$array = ['key1.key1-1' => 1, 'key1.key1-2' => 2, 'key2' => 3];
Arr::undot($array);

// 結果（ドット記法を用いた要素が配列として展開される）
array:2 [▼
  "key1" => array:2 [▼
    "key1-1" => 1
    "key1-2" => 2
  ]
  "key2" => 3
]
```

この例では、**配列内でドット記法を用いているキー**が`key1.key1-1`と`key1.key1-2`になるので、下記のように展開されています。

```php:展開部分の例
"key1" => array:2 [▼
  "key1-1" => 1
  "key1-2" => 2
]
```

コレクションでも使用できます。

```php:コレクション
$collection = Collection::make(['key1.key1-1' => 1, 'key1.key1-2' => 2, 'key2' => 3]);
Arr::undot($array);

// 結果
array:2 [▼
  "key1" => array:2 [▼
    "key1-1" => 1
    "key1-2" => 2
  ]
  "key2" => 3
]
```

### Arr::where クロージャーを使用して配列要素をフィルタリング

:m[**クロージャー関数を使用して配列の要素をフィルタリング**]できます。

:::info{title=where}
**Arr::where（配列, クロージャー関数）: フィルタリング後の配列**

- **クロージャー関数内でフィルタリングの条件を指定し要素毎にクロージャー関数を実施**
- **クロージャー関数内では要素の値とキーが渡される**
- **クロージャー関数内でtrueを返した要素が配列として返される**
- コレクションは使用不可
:::

使用例は以下の通りです。

```php:使用例
$array = [1, '1', 2, '2'];

// 値が文字列であることをフィルタリングの条件としてクロージャーを指定
Arr::where($array, function($value, $key) {
    return is_string($value);
});

// 結果（文字列の要素のみがフィルタリングされる）
array:2 [▼
  1 => "1"
  3 => "2"
]
```

:m[**フィルタリングの条件を指定するクロージャー関数は第二引数に指定**]します。

例でいうと下記の部分がフィルタリングを実施する**クロージャー関数**になります。

```php:クロージャー関数部分抜粋
function($value, $key) {
  return is_string($value);
}
```

:m[**配列の各要素毎に第二引数で指定したクロージャー関数が実行され、trueを返した要素のみがArr::whereの返り値として配列で返されます**]。

また、**クロージャー関数内**では、:m[**配列の各要素の値とキーをそれぞれ受け取る**]ことができ、:m[**値が第一引数**]、:m[**キーが第二引数**]としてそれぞれクロージャー関数に渡されます。

:::memo{title=第二引数のクロージャー関数について}
- **第二引数のクロージャー関数でフィルタリングの条件を指定する**
- **クロージャー関数は配列の要素毎に実施されtrueを返した要素がArr::whereの返り値となる**
- **クロージャー関数内では第一引数に要素の値、第二引数に要素のキーを受け取ることができる**
:::

全体の挙動としては、先程の例で説明すると、**配列のフィルタリングの条件**としてクロージャー関数内で`return is_string($value)`としており**文字列の要素のみにフィルタリング**をかけていることがわかります。

**クロージャーは配列内の要素毎に実行**されます。

例では1（数値）、1（文字列）、2（数値）、2（文字列）が配列の要素になるので、順番に**クロージャー関数**が下記のように実行されていきます。

```php:クロージャー関数の実行イメージ

// １周目
// $valueに1(数値)が格納されている
function ($value, $key) {
  // $valueは数値なのでfalseを返す
  return is_string($value);
}

// ２周目
// $valueに1(文字列)が格納されている
function ($value, $key) {
  // $valueは文字列なのでtrueを返す
  return is_string($value);
}

// ３周目
// $valueに2(数値)が格納されている
function ($value, $key) {
  // $valueは数値なのでfalseを返す
  return is_string($value);
}


// ４周目
// $valueに2(文字列)が格納されている
function ($value, $key) {
  // $valueは文字列なのでtrueを返す
  return is_string($value);
}
```

最終的にArr::whereの返り値として:m[**クロージャー関数内でtrueを返した要素**]が返却されます。

例では**2週目と4週目にtrueを返した、1（文字列）、2（文字列）が返されています**。

```php:結果
// 結果
// ２、４週目の要素がtrueを返しているので返り値として返却される
array:2 [▼
  1 => "1"
  3 => "2"
]
```

返り値のキーは例を見て分かる通り**リセットされません**。

コレクションでは使用できずエラーになります。

```php:コレクション（エラー）
$collection = Collection::make([1, '1', 2, '2']);
Arr::where($collection, function($value, $key) {
    return is_string($value);
});

// エラー
// array_filter(): Argument #1 ($array) must be of type array, Illuminate\Support\Collection given
```

### Arr::whereNotNull 配列内からnull要素を削除

:m[**配列内からnull要素を削除**]します。

:::info{title=whereNotNull}
**Arr::whereNotNull(配列): 配列**

- **配列内のnull要素を削除**
:::

```php:使用例
$array = [null, 0, '', [], false];
Arr::whereNotNull($array);

// 結果（null要素が削除されている）
array:4 [▼
  1 => 0
  2 => ""
  3 => []
  4 => false
]
```

上記の例では、:m[**nullが削除された配列**]が返ってきているのがわかります。

添字配列の場合、**null削除後の配列はキーがリセットされません**。

### Arr::wrap 指定した値を配列にラップ

:m[**指定した値を配列にラップ**]します。

:::info{title=wrap}
**Arr::wrap(要素): 配列**

- **指定した値を配列にラップする**
- **引数にnullを指定した場合は空配列を返す**
- **引数に配列を指定した場合はラップしない**
:::

以下の例では**指定した文字列**が**配列として返されています**。

```php:使用例
$string = '1';
Arr::wrap($string);

// 結果
array:1 [▼
  0 => "1"
]
```

**nullが指定された場合は空の配列**が返されます。

```php:nullを指定
Arr::wrap(null);

// 結果
[]
```

また、**配列を指定した場合はそのまま返されます**。

```php:引数に配列を指定
$array = ['1'];
Arr::wrap($array);

// 結果（引数に指定した配列がラップされることなくそのまま返される）
array:1 [▼
  0 => "1"
]
```

今回は**toCssClasses**、**undot**、**where**、**whereNotNull**、**wrap**と5つのへルパ関数を紹介しました。

以下まとめになります。

:::info{title=まとめ}
- **Arr::toCssClasses CSSのクラス文字を生成**
- **Arr::undot ドット記法を用いた一次元配列を多次元配列に変換**
- **Arr::where クロージャーを使用して配列要素をフィルタリング**
- **Arr::whereNotNull 配列ないからnull要素を削除**
- **Arr::wrap 指定した値を配列にラップ**
:::

配列のへルパ関数も残り5つになりました！次回の記事で最後まで紹介していきたいと思います！

本記事以外でも配列のへルパ関数の解説しているので下記からよければどうぞ！

:::wrap
- [random、set、shuffle、sort、sortRecursive](https://dev-record-front.vercel.app/php/laravel-helper-array-5)
- [isAssoc、last、only、pluck、prepend、pull、query](https://dev-record-front.vercel.app/php/laravel-helper-array-4)
- [get、has、hasAny](https://dev-record-front.vercel.app/php/laravel-helper-array-3)
- [first、flatten、forget](https://dev-record-front.vercel.app/php/laravel-helper-array-2)
- [accessible、add、collapse、divide、crossJoin、dot、except、exists](https://dev-record-front.vercel.app/php/laravel-helper-array-1)
:::

【Laravel】ヘルパ関数の紹介 配列編６【toCssClasses、undot、where、whereNotNull、wrap】

前回に引き続き本記事でもLaravelの配列関連のへルパ関数を解説していきたいと思います。

参考になれば幸いです。

:::memo{title=Memo}
Laravelのバージョンは8系統になります。
:::

今回解説するへルパ関数は以下です。

:::info{title=本記事で取り扱うへルパ関数}
- **Arr::random 配列からランダムに値を返す**
- **Arr::set ドット記法を使用して配列に要素を追加**
- **Arr::shuffle 配列内の要素をランダムに入れ替える**
- **Arr::sort 配列の値に基づき要素を昇順ソートする**
- **Arr::sortRecursive 連想配列の場合はキーを添字配列の場合は値を基準にソートする**
:::

### Arr::random 配列からランダムに値を返す

:m[**配列からランダムに値を返します**]。

:::info{title=Arr::random}
**Arr::random(配列, （オプション）取得する個数, （オプション）キーを含めるか)**

- 第二引数にはランダムに返す個数を指定できる
- 第三引数には取得元が連想配列の場合に返す値にキーを含めるか指定できる
- コレクションは使用不可（エラー）
:::

```php:使用例
$array = [1, 2, 3, 4];
dd(Arr::random($array));
// 結果（ランダムに値を返す）
2

dd(Arr::random($array));
// 結果（ランダムに値を返す）
1
```

**第二引数でランダムに返す個数**を指定できます。

```php:第二引数を指定
$array = [1, 2, 3, 4];
// 第二引数にランダムに返す個数を指定
dd(Arr::random($array, 3));

// 結果（3つの値がランダムに返される）
array:3 [▼
  0 => 1
  1 => 3
  2 => 4
]
```

:::alert{title=注意}
第二引数に:m[**１を明示的に指定**]した場合と第二引数に:m[**何も指定しない**]場合で微妙に挙動が変わります。

返される値の個数は共に**１つ**ですが下記の違いがあります。

- 第二引数に１を明示的に指定した場合は:m[**配列で返される**]
- 第二引数に何も指定しない場合は:m[**値そのものが返される**]

```php:例
$array = [1, 2, 3, 4];

// 第二引数に1を指定した場合は配列で返される
dd(Arr::random($array, 1));
// 結果
array:3 [▼
  0 => 1
]

// 第二引数に何も指定しない場合は値そのものが返される
dd(Arr::random($array));
// 結果
1
```
:::

**第三引数をtrue**にすると連想配列の場合**返却される値にキーも反映**されるようになります。

```php:第三引数を指定
$array = ['key-1' => 1, 'key-2' => 2, 'key-3' => 3];
// 第三引数をtrueにして返り値にキーを反映するよう指定
dd(Arr::random($array, 1, true));

// 結果（取得元の配列キーが反映されている）
array:1 [▼
  "key-2" => 2
]

// デフォルトはfalseが指定されている
$array = ['key-1' => 1, 'key-2' => 2, 'key-3' => 3];
dd(Arr::random($array, 1));

// 結果（取得元のキーは反映されず添字配列として返却される）
array:1 [▼
  0 => 1
]
```

コレクションは使用できません。（エラーになります。）

```php:コレクション（エラー）
$collection = Collection::make([1, 2, 3]);
dd(Arr::random($collection));

// エラー
// array_rand(): Argument #1 ($array) must be of type array, Illuminate\Support\Collection given
```

### Arr::set ドット記法を使用して配列に要素を追加

:m[**ドット記法を使用して配列に要素を追加**]できます。

:::info{title=Arr::set}
**Arr::set(&配列, 追加するキー, 追加する値): array**

- ドット記法で追加するキーを指定できる
- 第一引数に渡す配列は**参照渡し**で副作用が生じる
- コレクションは使用不可（エラー）
:::

```php:使用例
$array = ['key-1' => 1, 'key-2' => ['key-2-1' => 2]];
Arr::set($array, 'key-2.key-2-2', 3);
dd($array);

// 結果（ドット記法で指定したキーと値が追加されている）
array:2 [▼
  "key-1" => 1
  "key-2" => array:2 [▼
    "key-2-1" => 2
    "key-2-2" => 3
  ]
]

// 返り値には追加した階層部分の配列が返される
array:2 [▼
  "key-2-1" => 2
  "key-2-2" => 3
]
```

:::memo{title=Memo}
引数に渡した配列は:m[**参照渡し**]です。

Arr::set後は引数に渡した:m[**配列自体の中身が変化する副作用**]が生じます。
:::

コレクションは使用不可で、エラーになります。

```php:コレクション（エラー）
$collection = Collection::make(['key-1' => 1, 'key-2' => ['key-2-1' => 2]]);
Arr::set($collection, 'key-2.key-2-2', 3);

// エラー
// Indirect modification of overloaded element of Illuminate\Support\Collection has no effect
```

### Arr::shuffle 配列内の要素をランダムに入れ替える

:m[**配列内の要素をランダムに入れ替えます**]。

:::info{title=Arr::shuffle}
**Arr::shuffle(配列, （オプション）シード値)**

- 第二引数にはシード値を指定できる。（要素内の入れ替え方を決める値なのでシード値を指定すると毎回同じ実行結果が返ってくる）
- コレクションは使用不可（エラー）
:::

```php:使用例
$array = [1, 2, 3, 4];
dd(Arr::shuffle($array));

// 結果（配列内の要素がランダムに入れ替わる）
// 1回目
array:4 [▼
  0 => 4
  1 => 1
  2 => 2
  3 => 3
]

// 2回目（ランダムに入れ替わるので１回目と異なる並び順になる）
array:4 [▼
  0 => 2
  1 => 3
  2 => 4
  3 => 1
]
```

第二引数には**シード値**を設定できます。

シード値について調べてみたのですがよくわかりませんでした。

乱数生成器を初期化する値のようで、:m[**設定すると毎回同じ乱数を生成するので何度実行しても同じ結果が返ってくるようになります**]。(この理解であっているかはかなり怪しいです)

実行毎に入れ替え方をランダムに変化させたい場合は**設定しない**ようにします。

```php:第二引数を指定
$array = [1, 2, 3, 4];
dd(Arr::shuffle($array, 1));

// 結果（何回実行しても入れ替え方が同じ）
// 1回目
array:4 [▼
  0 => 4
  1 => 1
  2 => 3
  3 => 2
]

// 2回目
array:4 [▼
  0 => 4
  1 => 1
  2 => 3
  3 => 2
]

// 3回目
array:4 [▼
  0 => 4
  1 => 1
  2 => 3
  3 => 2
]
```

コレクションは使用不可でエラーになります。

```php:コレクション（エラー）
$collection = Collection::make([1, 2, 3, 4]);
Arr::shuffle($collection);

// エラー
// shuffle(): Argument #1 ($array) must be of type array, Illuminate\Support\Collection given
```

### Arr::sort 配列の値に基づき要素を昇順ソートする

:m[**配列内の値をソート**]します。

```php:使用例
$array = ['PHP', 'Laravel', 'HTML', 'CSS'];
dd(Arr::sort($array));

// 結果（昇順でソートされている）
array:4 [▼
  3 => "CSS"
  2 => "HTML"
  1 => "Laravel"
  0 => "PHP"
]
```

例をみるとわかるように、**添字配列のキーはリセットされません**。

:m[**第二引数にコールバック関数を使用してソートさせたいキーを指定できます**]。

```php:ソートするキーを指定
$array = [
    ['id' => 4, 'name' => 'PHP'],
    ['id' => 1, 'name' => 'Laravel'],
    ['id' => 3, 'name' => 'HTML'],
    ['id' => 2, 'name' => 'CSS'],
];

// コールバック関数内でidでソートするように指定
dd(Arr::sort($array, function($value) {
    return $value['id'];
}));

// 結果（idの昇順でソートされている）
array:4 [▼
  1 => array:2 [▼
    "id" => 1
    "name" => "Laravel"
  ]
  3 => array:2 [▼
    "id" => 2
    "name" => "CSS"
  ]
  2 => array:2 [▼
    "id" => 3
    "name" => "HTML"
  ]
  0 => array:2 [▼
    "id" => 4
    "name" => "PHP"
  ]
]

$array = [
    ['id' => 4, 'name' => 'PHP'],
    ['id' => 1, 'name' => 'Laravel'],
    ['id' => 3, 'name' => 'HTML'],
    ['id' => 2, 'name' => 'CSS'],
];

// コールバック関数内でnameでソートするように指定
dd(Arr::sort($array, function($value) {
    return $value['name'];
}));

// 結果（nameの昇順でソートされている）
array:4 [▼
  3 => array:2 [▼
    "id" => 2
    "name" => "CSS"
  ]
  2 => array:2 [▼
    "id" => 3
    "name" => "HTML"
  ]
  1 => array:2 [▼
    "id" => 1
    "name" => "Laravel"
  ]
  0 => array:2 [▼
    "id" => 4
    "name" => "PHP"
  ]
]
```

コレクションでも使用できます。

```php:コレクション
$collection = Collection::make([
    ['id' => 4, 'name' => 'PHP'],
    ['id' => 1, 'name' => 'Laravel'],
    ['id' => 3, 'name' => 'HTML'],
    ['id' => 2, 'name' => 'CSS'],
]);
dd(Arr::sort($collection, function($value) {
    return $value['name'];
}));

// 結果
array:4 [▼
  3 => array:2 [▼
    "id" => 2
    "name" => "CSS"
  ]
  2 => array:2 [▼
    "id" => 3
    "name" => "HTML"
  ]
  1 => array:2 [▼
    "id" => 1
    "name" => "Laravel"
  ]
  0 => array:2 [▼
    "id" => 4
    "name" => "PHP"
  ]
]
});
```

### Arr::sortRecursive 連想配列の場合はキーを添字配列の場合は値を基準にソートする

:m[**配列内の要素を連想配列の場合はキーを添字配列の場合は値を基準にソート**]します。


:::info{title=Arr::sortRecursive}
**Arr::sortRecursive(配列, （オプション）ソート方法, （オプション）並び順)**

- 配列は**多次元配列**でも可能
- 第二引数にはソート方法が指定可能
- 第三引数には並び順を指定可能（**trueは降順でfalseが昇順。デフォルトは昇順**）
- コレクションは使用不可（エラー）
:::

```php:使用例
// 添字配列の場合は値の昇順でソート
$array = [5, 4, 3, 2, 1];
dd(Arr::sortRecursive($array));

// 結果（昇順でソートされている）
array:5 [▼
  0 => 1
  1 => 2
  2 => 3
  3 => 4
  4 => 5
]

// 連想配列の場合はキーを基準にソート
$array = ['key-3' => 1, 'key-2' => 2, 'key-1' => 3];
dd(Arr::sortRecursive($array));

// 結果（キーの昇順でソートされている）
array:3 [▼
  "key-1" => 3
  "key-2" => 2
  "key-3" => 1
]
```

多次元配列の場合でも使用できます。

```php:多次元配列
$array = [
    ['key-3' => 1, 'key-2' => 2, 'key-1' => 3],
    [5, 4, 3, 2, ['key-2' => 1, 'key-1' => 2]],
];
dd(Arr::sortRecursive($array));

// 結果
array:2 [▼
  0 => array:3 [▼
    "key-1" => 3
    "key-2" => 2
    "key-3" => 1
  ]
  1 => array:5 [▼
    0 => 2
    1 => 3
    2 => 4
    3 => 5
    4 => array:2 [▼
      "key-1" => 2
      "key-2" => 1
    ]
  ]
]
```

第二引数では:m[**比較方法**]を指定できます。

```php:第二引数に比較方法を指定
$array = [1, 2, 3, 111];
// 第二引数の比較方法に文字列比較を指定する`SORT_STRING`を設定
dd(Arr::sortRecursive($array, SORT_STRING));

// 結果（文字列として比較しているので２番目に111がきている）
array:4 [▼
  0 => 1
  1 => 111
  2 => 2
  3 => 3
]
```

第二引数に指定できるのは、**PHPの組込み関数**の`sort`に指定できるものと同じで下記になります。

（デフォルトでは**SORT_REGULAR**が設定されています。）

:::info{title=第二引数に指定できる値}
- **SORT_REGULAR** ： 通常通りに項目を比較します。
- **SORT_NUMERIC** ： 数値として項目を比較します。
- **SORT_STRING** ： 文字列として項目を比較します。
- **SORT_LOCALE_STRING** ： 現在のロケールに基づいて、文字列として項目を比較します。 比較に使うロケールは、setlocale() 関数で変更できます。
- **SORT_NATURAL** ： 要素の比較を文字列として行い、 natsort() と同様の「自然順」で比較します。
- **SORT_FLAG_CASE** ： SORT_STRING や SORT_NATURAL と (ビットORで) 組み合わせて使い、 文字列のソートで大文字小文字を区別しないようにします。

引用元：[PHP: rsort - Manual](https://www.php.net/manual/ja/function.rsort.php)
:::

一点注意事項として、第二引数に**SORT_STRING**、**SORT_LOCALE_STRING**、**SORT_NATURAL**を使用して**多次元配列**のソートをかけようとするとエラーになります。

これは文字列比較する際に多次元部分の配列を文字列に変換しようとして起こるエラーのようです。

```php:多次元配列で第二引数に文字列比較を設定（エラー）
$array = [1, 2, 3, [111]];
Arr::sortRecursive($array, SORT_LOCALE_STRING);

// エラー
// Array to string conversion
```

:::alert{title=注意}
- 多次元配列のソート時に第二引数に**SORT_STRING**、**SORT_LOCALE_STRING**、**SORT_NATURAL**を指定するとエラーになる
:::

第三引数には:m[**並び順を昇順か降順**]かを指定できます。

第三引数に:m[**trueを指定すると降順**]、:m[**falseを指定すると昇順**]になります。（デフォルトは昇順）

```php:第三引数に並び順を指定
$array = [1, 2, 3, 111];
// 並び順を降順にするため第三引数にtrueを指定
dd(Arr::sortRecursive($array, SORT_STRING, true));

// 結果（降順に並ぶ）
array:4 [▼
  0 => 3
  1 => 2
  2 => 111
  3 => 1
]
```

コレクションは使用不可です。（エラーになります。）

```php:コレクション
$collection = Collection::make([1, 2, 3, 111]);
Arr::sortRecursive($collection, SORT_STRING);

// エラー
// Illuminate\Support\Arr::isAssoc(): Argument #1 ($array) must be of type array, Illuminate\Support\Collection given, called in /var/www/html/vendor/laravel/framework/src/Illuminate/Collections/Arr.php on line 672
```

【Laravel】ヘルパ関数の紹介 配列編５【random、set、shuffle、sort、sortRecursive】

前回に引き続き本記事でもLaravelの配列関連のへルパ関数を解説していきたいと思います。

参考になれば幸いです。

:::memo{title=Memo}
Laravelのバージョンは8系統になります。
:::

今回解説するへルパ関数は以下です。

:::info{title=本記事で取り扱うへルパ関数}
- **Arr::isAssoc 連想配列かを判定**
- **Arr::last 条件に一致した最後の要素を返す**
- **Arr::only 配列を指定したキー/値のペアのみにフィルタリング**
- **Arr::pluck 指定したキーの値を全て取得**
- **Arr::prepend 配列の先頭に要素を追加**
- **Arr::pull 指定したキーの値を取得し、取得元の配列からは削除する**
- **Arr::query 配列をクエリ文字に変換する**
:::

### Arr::isAssoc 連想配列かを判定する

:m[**指定した配列が連想配列の場合にtrueを返します**]。

:::info{title=Arr::isAssoc}
**Arr::isAssoc(配列): bool**

- 連想配列の場合にtrueを返す
- 連想配列と添字配列が混ざっている場合はtrueを返す
- 多次元配列の場合は、一階層目を見て判定する
- コレクションは使用不可（エラーになる）
:::

```php:使用例
// 連想配列の場合にtrue
$array = ['key-1' => 1];
Arr::isAssoc($array)

// 添字配列の場合はfalse
$array = [1, 2];
Arr::isAssoc($array)

// 連想配列と添字配列が混ざっている場合はtrue
$array = [1, 2, 'key-1' => 1];
Arr::isAssoc($array);

// 多次元配列の場合は一階層目を見て判定する
// 下記の場合は一階層目は添字配列なのでfalse
$array = [1, 2, ['key-1' => 3]];

// コレクションは不可（エラー）
// Illuminate\Support\Arr::isAssoc(): Argument #1 ($array) must be of type array
$collection = Collection::make(['key-1' => 1]);
Arr::isAssoc($array)
```

### Arr::last 配列内で条件に一致した最後の要素を返す

:m[**配列内で条件に一致した最後の要素を返します**]。

**条件はコールバック関数で指定し、配列内の要素毎にコールバック関数が実施されます。**

:::info{title=Arr::last}
**Arr::last(配列, 要素を検証するコールバック関数（値, キー）, （オプション）条件に一致する要素がなかった場合に返す値)**

- **第二引数のコールバック関数内に要素を判定する条件を記載します。**
- **コールバック関数は配列の要素毎に実行され、最後にtrueが返った要素が返り値となります。**
- コールバック関数は検証する配列の各要素の値とキーを引数に取れます。（**第一引数に値、第二引数にキー**）
- 第三引数はオプションで指定すると、条件に一致する要素が存在しない場合に返される**デフォルト値**として扱われます。
- コレクションも可
:::

```php:使用例
$array = ['key-1' => 100, 'key-2' => 200, 'key-3' => 300];
dd(Arr::last($array, function($value, $key) {
    return $value >= 200;
}));

// 結果
300
```

上記の例では、第二引数のコールバック関数内で:m[**値が200以上**]という条件を指定しており、条件に一致するのは**200**と**300**になります。

返り値として返されるのは**条件に一致した最後の値**になるので**300**がこの例の場合の返り値になります。

以下はサンプルのコールバック関数の実行イメージになります。

```php:実行例のイメージ
$array = ['key-1' => 100, 'key-2' => 200, 'key-3' => 300];
Arr::last($array, function($value, $key) {
    // コールバック関数は配列の要素毎に実施される
    // 一周目、$value = 100で条件に一致しないので次の要素へ
    // 二周目に$value = 200で条件に一致するのでtrueの判定になり次の要素へ
    // 三周目に$value = 300で条件に一致するのでtrueの判定。
    // 配列の要素が全て検証し終わり、最後に条件に一致したのは$value = 300なので返り値として300が返される
    return $value >= 200;
});
```

第三引数に値を設定すると、:m[**条件に一致する要素がなかった場合のデフォルト値を指定できます**]。

```php:第三引数を設定した場合
$array   = ['key-1' => 100, 'key-2' => 200, 'key-3' => 300];
$default = 'default';

// 第三引数を指定すると条件に一致する値がなかった場合のデフォルト値となる
dd(Arr::last($array, function($value, $key) {
    return $value >= 500;
}, $default));

// 結果
"default"
```

### Arr::only 配列を指定したキー/値のペアのみにフィルタリング

:m[**配列を指定したキー/値のペアのみにフィルタリング**]します。

:::info{title=Arr::only}
**Arr::only(配列, フィルタリングをかけるキー): array**

- フィルタリングをかけるキーは配列で複数指定可能
- コレクションは不可（エラーになる）
- 多次元配列の階層が深い部分のキーは指定できない。
:::

```php:使用例
$array = ['key-1' => 100, 'key-2' => 200, 'key-3' => 300];
dd(Arr::only($array, 'key-1'));

// 結果
array:1 [▼
  "key-1" => 100
]

// 指定したキーが存在しない場合は空の配列が返る
$array = ['key-1' => 100, 'key-2' => 200, 'key-3' => 300];
dd(Arr::only($array, 'key-4'));

// 結果
[]
```

指定するキーは:m[**配列で複数指定**]可能です。

```php:キーを複数指定
$array = ['key-1' => 100, 'key-2' => 200, 'key-3' => 300];
dd(Arr::only($array, ['key-1', 'key-2']));

// 結果
array:2 [▼
  "key-1" => 100
  "key-2" => 200
]
```

コレクションでは使用できず**エラー**になります。

```php:コレクションを使用した場合（エラー）
$collection = Collection::make(['key-1' => 100, 'key-2' => 200, 'key-3' => 300]);
dd(Arr::only($collection, 'key-1'));
// エラー
// array_intersect_key(): Argument #1 ($array) must be of type array, Illuminate\Support\Collection given
```

多次元配列の場合は階層が深い部分のキーは指定できないようです。

```php:多次元配列の階層が深い部分
$array = ['key-1' => 100, 'key-2' => ['key-2-1' => 200]];
dd(Arr::only($array, 'key-2.key-2-1'));

// 結果（期待された動作とならない）
[]
```

### Arr::pluck 指定したキーの値を全て取得する

:m[**配列内の指定したキーの値を全て取得**]します。

:::info{title=Arr::pluck}
**Arr::pluck(配列, 取得するキー, 返り値のキーを指定)**

- 指定するキーはドット記法で深い階層も取得可能
- **キーに*(アスタリスク)を使用することで任意の階層の値を取得することも可能**
- 第三引数を指定することで返り値にキーを指定できます。
- コレクションも使用可能
:::

```php:使用例
$array = [
    ['key-1' => 1, 'key-2' => 2],
    ['key-1' => 3, 'key-2' => 4],
];
dd(Arr::pluck($array, 'key-1'));

// 結果
array:2 [▼
  0 => 1
  1 => 3
]
```

コレクションも可能です。

```php:コレクション
$collection = Collection::make([
    ['id' => 'id-1', 'name' => 'PHP'],
    ['id' => 'id-2', 'name' => 'Laravel'],
]);
dd(Arr::pluck($collection, 'name'));

// 結果
array:2 [▼
  0 => "PHP"
  1 => "Laravel"
]
```

**ドット記法を用いることで多次元配列の深い階層のキー取得可能です。**

```php:ドット記法で深い階層のキーを指定
$array = [
    ['key-1' => ['key-1-1' => 1], 'key-2' => 2],
    ['key-1' => ['key-1-1' => 3], 'key-2' => 4],
];
dd(Arr::pluck($array, 'key-1.key-1-1'));

// 結果
array:2 [▼
  0 => 1
  1 => 3
]
```

指定するキーに*(アスタリスク)を使用することで階層を指定することができます。

```php:*(アスタリスク)を使用
$array = [
    ['key-1' => 1, 'key-2' => 2, ['key-3' => 3, 'key-4' => [4]]],
    ['key-1' => 5, 'key-2' => 6, ['key-3' => 7, 'key-4' => [8]]],
];

// 二階層目の値を全て指定
dd(Arr::pluck($array, '*.*'));

// 結果
array:2 [▼
  0 => array:2 [▼
    0 => 3
    1 => array:1 [▼
      0 => 4
    ]
  ]
  1 => array:2 [▼
    0 => 7
    1 => array:1 [▼
      0 => 8
    ]
  ]
]
```

第三引数で返り値のキーを指定できます。

```php:第三引数を指定
$array = [
    ['id' => 'id-1', 'name' => 'PHP'],
    ['id' => 'id-2', 'name' => 'Laravel'],
];
dd(Arr::pluck($array, 'name', 'id'));

// 結果
array:2 [▼
  "id-1" => "PHP"
  "id-2" => "Laravel"
]
```

### Arr::prepend 配列の先頭に要素を追加

:m[**配列の先頭に要素を追加します**]。

:::info{title=Arr::prepend}
**Arr::prepend(配列, 追加する要素, （オプション）追加するキー)**

- 第三引数には追加するキーを指定可能
- コレクションは使用不可（エラーになる）
:::

```php:使用例
$array = [1, 2, 3, 4];
dd(Arr::prepend($array, 0));

// 結果
array:5 [▼
  0 => 0
  1 => 1
  2 => 2
  3 => 3
  4 => 4
]
```

第三引数に追加する値に対応するキーの指定ができます。

```php:第三引数に追加するキーを指定
$array = ['key-1' => 1, 'key-2' => 2];
dd(Arr::prepend($array, 0, 'key-0'));

// 結果
array:3 [▼
  "key-0" => 0
  "key-1" => 1
  "key-2" => 2
]
```

コレクションは使用できずエラーになります。

```php:コレクションを指定（エラー）
$array = Collection::make([1, 2]);
dd(Arr::prepend($array, 0));

// エラー
// array_unshift(): Argument #1 ($array) must be of type array, Illuminate\Support\Collection given
```

### Arr::pull 指定したキーの値を取得し、取得元の配列からは削除する

:m[**指定したキーの値を取得し、かつ取得元の配列から削除**]します。

:::info{title=Arr::pull}
**Arr::pull(&配列, 削除するキー, （オプション）削除するキーが存在しない場合のデフォルト値): 削除した値**

- 第三引数は指定したキーが存在しない場合に返すデフォルト値
- 削除キーの指定はドット記法が使える
- コレクションも使用可能
:::

```php:使用例
$array = ['key-1' => 1, 'key-2' => 2];
dd(Arr::pull($array, 'key-2'), $array);

// 結果（返り値）
2

// 結果（削除後の配列）
array:1 [▼
  "key-1" => 1
]
```

第三引数を指定した場合は**キーが存在しない場合のデフォルト値**になります。

```php:第三引数を指定
$array = ['key-1' => 1, 'key-2' => 2];
dd(Arr::pull($array, 'key-3', 3), $array);

// 結果（返り値）
3

// 結果（削除元の配列には変化なし）
array:2 [▼
  "key-1" => 1
  "key-2" => 2
]
```

**ドット記法**を用いることで**階層が深いキーの指定**もできます。

```php:ドット記法の使用
$array = ['key-1' => 1, 'key-2' => ['key-2-1' => 2]];
dd(Arr::pull($array, 'key-2.key-2-1'), $array);

// 結果（返り値）
2

// 結果（削除後の配列）
array:2 [▼
  "key-1" => 1
  "key-2" => []
]
```

コレクションでも使用可能です。

```php:コレクション
$collection = Collection::make(['key-1' => 1, 'key-2' => 2]);
dd(Arr::pull($collection, 'key-2'), $collection);

// 結果（返り値）
2

// 結果（削除後のコレクション）
Illuminate\Support\Collection {#306 ▼
  items: array:1 [▼
    "key-1" => 1
  ]
  escapeWhenCastingToString: false
}
```

### Arr::query 配列をクエリ文字に変換する

:m[**配列をクエリ文字列に変換**]します。

:::info{title=Arr::query}
**Arr::query**

- 日本語や%が含まれる場合は**エンコード**される（エンコード形式は[RFC3986](http://www.faqs.org/rfcs/rfc3986.html)）
:::

```php:使用例
$array = ['name' => 'php', 'id' => 1];
dd(Arr::query($array));

// 結果
"name=php&id=1"
```

エンコード対象の文字列が含まれている場合は**エンコード**された状態で出力されます。

エンコードの形式は[RFC3986](http://www.faqs.org/rfcs/rfc3986.html)に沿って変換されます。

```php:エンコードされる例
// 日本語が含まれている場合
$array = ['name' => 'ピーエイチピー', 'title' => '漢字タイトル'];
dd(Arr::query($array));

// 結果
"name=%E3%83%94%E3%83%BC%E3%82%A8%E3%82%A4%E3%83%81%E3%83%94%E3%83%BC&title=%E6%BC%A2%E5%AD%97%E3%82%BF%E3%82%A4%E3%83%88%E3%83%AB"

// %が含まれている場合
$array = ['name' => '%'];
dd(Arr::query($array));

// 結果
"name=%25"
```

今回は７つの配列系へルパ関数の紹介でした。

以下まとめです。

:::info{title=まとめ}
- **Arr::isAssoc 連想配列かを判定**
- **Arr::last 条件に一致した最後の要素を返す**
- **Arr::only 配列を指定したキー/値のペアのみにフィルタリング**
- **Arr::pluck 指定したキーの値を全て取得**
- **Arr::prepend 配列の先頭に要素を追加**
- **Arr::pull 指定したキーの値を取得し、取得元の配列からは削除する**
- **Arr::query 配列をクエリ文字に変換する**
:::

今回はLaravel内部の実装コードも見てみたのですが、公式ドキュメントには記載のない部分も知れて勉強になりました。

残りの配列系のヘルパ関数もまとめていきたいと思います。

【Laravel】ヘルパ関数の紹介 配列編４【isAssoc、last、only、pluck、prepend、pull、query】

前回に引き続き本記事でもLaravelの配列関連のへルパ関数を解説していきたいと思います。

参考になれば幸いです。

:::memo{title=Memo}
Laravelのバージョンは8系統になります。
:::

今回解説するへルパ関数は以下です。

:::info{title=本記事で取り扱うへルパ関数}
- Arr::get（ドット記法で指定したキーの値を取得）
- Arr::has（ドット記法で指定したキーが配列に存在するか判定）
- Arr::hasAny（ドット記法で指定した複数キーが１つ以上配列に存在するか判定）
:::

### Arr::get ドット記法で指定したキーの値を取得

:m[**配列内にドット記法で指定した値を取得**]します。

:::info{title=Arr::get}
**Arr::get(配列, 取得したいキー, (オプション)デフォルト値): 取得した値**

- 第二引数のキーは**ドット記法**で指定可能
- コレクションも可能
- **指定したキーが存在しない場合はnullが返ってくるが、第三引数を指定している場合はその値が返される**
:::

```php:使用例
$array = ['key-1' => 1, 'key-2' => ['key-2-1' => 2]];
dd(Arr::get($array, 'key-2.key-2-1')); // ドット記法で指定可能

// 結果
2
```

**コレクション**でも可能です。

```php:コレクションを使用
$collection = Collection::make(['key-1' => 1, 'key-2' => ['key-2-1' => 2], ]);
dd(Arr::get($collection, 'key-2.key-2-1'));

// 結果
2
```

第三引数で取得する**キーが存在しない場合のデフォルト値**を指定できます。

```php:デフォルト値を指定
$array = ['key-1' => 1, 'key-2' => ['key-2-1' => 2]];
dd(Arr::get($array, 'key-999', 'default value')); // 第三引数にデフォルト値を指定

// 結果（指定したキーが存在しない場合は第三引数に指定した値を出力）
"default value"
```

### Arr::has ドット記法で指定したキーが配列内に存在するか判定

:m[**ドット記法で指定したキーが配列内に存在するか判定**]します。存在する場合は:m[**true**]を存在しない場合は:m[**false**]を返します。

:::info{title=Arr::has}
Arr::has(配列, 検索するキー（ドット記法）): bool

- コレクションも可能
- 検索キーは配列で**複数指定**が可能（**完全一致**）
:::

```php:使用例
$array = ['key-1' => 1, 'key-2' => ['key-2-1' => 2]];

// true
Arr::has($array, 'key-2.key-2-1');

// false
Arr::has($array, 'key-3');
```

**コレクション**でも使用できます。

```php:コレクションを使用
$collection = Collection::make(['key-1' => 1, 'key-2' => ['key-2-1' => 2]]);

// true
Arr::has($collection, 'key-2.key-2-1');

// false
Arr::has($collection, 'key-3');
```

検索キーは配列で:m[**複数指定**]が可能です。

その場合は:m[**完全一致だとtrueが返ります**]。

```php:検索キーを複数指定
$array = ['key-1' => 1, 'key-2' => ['key-2-1' => 2]];

// true
Arr::has($array, ['key-1', 'key-2.key-2-1']);

// false（部分一致の場合はfalseとなるjj）
Arr::has($array, ['key-999', 'key-2.key-2-1']);
```

### Arr::hasAny 指定した複数キーが１つ以上配列に存在するか判定

:m[**ドット記法で指定した複数キーが１つ以上配列に存在する場合はtrue**]が返ります。

**Arr::has**とは異なり、:m[**trueを返す条件は部分一致になります**]。

:::info{title=Arr:hasAny}
Arr::hasAny(配列, 検索するキー（ドット記法）): bool

- コレクションでも可能
:::

```php:使用例
$array = ['key-1' => 1, 'key-2' => ['key-2-1' => 2]];

// true（部分一致で一致していればtrue）
Arr::hasAny($array, ['key-999', 'key-2.key-2-1']);

// false
Arr::hasAny($array, ['key-999', 'key-998']);
```

```php:コレクションを使用
$collection = Collection::make(['key-1' => 1, 'key-2' => ['key-2-1' => 2]]);

// true
Arr::hasAny($collection, ['key-999', 'key-2.key-2-1']);

// false
Arr::hasAny($collection, ['key-999', 'key-998']);
```

今回は`Arr::get`、`Arr::has`、`Arr::hasAny`の三つの配列系へルパ関数の紹介でした。

以下まとめです。

:::info{title=まとめ}
- Arr::get（指定したキーの値を取得）
- Arr::has（キーの検索（完全一致検索））
- Arr::hasAny（キーの検索（部分一致検索））
:::

残りのへルパ関数もまとめていきたいと思いますのでぜひ覗いていってください。

【Laravel】へルパ関数の紹介 配列編３【Arr::get、Arr::has、Arr::hasAny】

前回に引き続き本記事でもLaravelの配列関連のへルパ関数を解説していきたいと思います。

参考になれば幸いです。

:::memo{title=Memo}
Laravelのバージョンは8系統になります。
:::

今回解説するへルパ関数は以下です。

:::info{title=本記事で取り扱うへルパ関数}
- Arr::first（配列内で条件に一致した最初の要素を取得）
- Arr::flatten（多次元配列を一次元配列に変換）
- Arr::forget（ドット記法で指定したキーの値を削除）
:::

### Arr::first 配列内で条件に一致した最初の要素を取得

:m[**配列内で条件に一致した最初の要素を取得**]します。

:::info{title=Arr::first}
**Arr::first(配列, 要素を検証するコールバック関数（値, キー）, （オプション）条件に一致する要素がなかった場合に返す値)**

- **第二引数のコールバック関数内に要素を判定する条件を記載します。**
- **コールバック関数は配列の要素毎に実行され、最初にtrueが返った要素が返り値となります。**
- コールバック関数は検証する配列の各要素の値とキーを引数に取れます。（**第一引数に値、第二引数にキー**）
- 第三引数はオプションで指定すると、条件に一致する要素が存在しない場合に返される**デフォルト値**として扱われます。
- コレクションも可
:::

```php:使用例
$array = ['key-1' => 1, 'key-2' => 2];
dd(Arr::first($array, function($value, $key) {
    return $value === 2 && $key === 'key-2'; // 条件文
}));

// 結果
2
```

上記の例では、第二引数のコールバック関数内で:m[**キーがkey-２でかつ値が2**]という条件を指定しています。

以下はサンプルのコールバック関数の実行イメージになります。

```php:実行例のイメージ
$array = ['key-1' => 1, 'key-2' => 2];
Arr::first($array, function($value, $key) {
    // コールバック関数は配列の要素毎に実施される
    // 一周目に$value = 1, $key = 'key-1'が格納されるので、条件に一致しないので次の要素へ
    // 二周目に$value = 2, $key = 'key-2'が格納され、これは条件に一致するのでtrue
    return $value === 2 && $key === 'key-2';
});
```

```php:第三引数を指定した場合
$array   = ['key-1' => 1, 'key-2' => 2];
$default = 'default value';

dd(Arr::first($array, function ($value, $key) {
    return $value === 3;
}, $default));

// 結果（一致する要素がなかった場合に第三引数に指定した値が返される）
"default value"
```

### Arr::flatten 多次元配列を一次元配列へ変換

:m[**多次元配列を一次元配列に変換**]します。

:::info{title=Arr::flatten}
**Arr::flatten(変換する配列, 変換する階層の深さ（デフォルトは全て）): array**

- コレクションも可
- 変換後の配列は添字配列になる
- **第二引数を指定すると、一次元配列に変換する階層の深さを指定できる**
:::

```php:使用例
$array = ['key-1' => 1, 'key-2' => ['key-2-2' => 2], [3, ['key-3' => 4]]];
dd(Arr::flatten($array));

// 結果（添字配列の一次元配列に変換される）
array:4 [▼
  0 => 1
  1 => 2
  2 => 3
  3 => 4
]
```

```php:コレクション使用時
$collection = Collection::make(['key-1' => 1, 'key-2' => ['key-2-2' => 2], [3, ['key-3' => 4]]]);
dd(Arr::flatten($collection));

// 結果
array:4 [▼
  0 => 1
  1 => 2
  2 => 3
  3 => 4
]
```

第二引数では、:m[**一次元配列に変換する階層を指定**]できます。

```php:第二引数で一次元配列に変換する階層を指定する
$array = ['key-1' => 1, 'key-2' => ['key-2-2' => 2], [3, ['key-3' => 4]]];
dd(Arr::flatten($array));

// 結果（添字配列の一次元配列に変換される）
array:4 [▼
  0 => 1
  1 => 2
  2 => 3
  3 => 4
]
```

上記の例では、第二引数に**１**を指定しているので配列内の一階層以降の部分`['key-3' => 4]`は一次元配列に変換されません。

### Arr::forget ドット記法で指定したキーに対応する要素を削除

:m[**ドット記法で指定したキーを配列から削除**]します。

:::info{title=Arr::forget}
**Arr::forget(&配列, 削除するキー（ドット記法）): void**

- 削除するキーは**ドット記法**で指定可
- 第一引数に渡す配列は**参照渡し**
- **キー削除後の配列は返り値では返ってこない。参照渡しした配列が変換される。**
- 削除するキーは配列で複数指定可
- コレクションは不可（エラーになる）
:::

```php:使用例
$array = [
    'key-1' => 1,
    'key-2' => ['key-2-1' => 2],
    'key-3' => ['key-3-1' => 5],
];
Arr::forget($array, 'key-3.key-3-1'); //ドット記法でキーの指定が可能
dd($array);

// 結果
// key-3-1のキーと値が削除されている
array:3 [▼
  "key-1" => 1
  "key-2" => array:1 [▼
    "key-2-1" => 2
  ]
  "key-3" => []
]
```

**削除するキーは配列で複数指定が可能です。**

```php:削除するキーを複数指定
$array = [
    'key-1' => 1,
    'key-2' => ['key-2-1' => 2],
    'key-3' => ['key-3-1' => 5],
];
Arr::forget($array, ['key-2', 'key-3.key-3-1']);
dd($array);

// 結果
array:2 [▼
  "key-1" => 1
  "key-3" => []
]
```

コレクションを指定すると**エラー**になります。

```php:コレクションを指定するとエラーになる
$collection = Collection::make([
    'key-1' => 1,
    'key-2' => ['key-2-1' => 2],
    'key-3' => ['key-3-1' => 5],
]);
Arr::forget($collection, 'key-3.key-3-1');

// エラー
// Indirect modification of overloaded element of Illuminate\Support\Collection has no effect
```

今回は`Arr::first`、`Arr::flatten`、`Arr::forget`の三つの配列系へルパ関数の紹介でした。

以下まとめです。

:::info{title=まとめ}
- Arr::first（条件に一致した最初の要素を取得）
- Arr::flatten（多次元配列を一次元配列に変換）
- Arr::forget（ドット記法で指定したキーを削除）
:::

残りのへルパ関数もまとめていきたいと思いますのでぜひ覗いていってください。

【Laravel】へルパ関数の紹介 配列編２【Arr::first、Arr::flatten、Arr::forget】

Laravelのへルパ関数超絶便利ですよね。筆者も開発時にはお世話になっています。

ただ、量が多くて全てを把握できていなかったので今回は:m[**配列関連のものに絞って調べてみました**]。

参考になれば幸いです。

:::memo{title=Memo}
Laravelのバージョンは8系統になります。
:::

配列関連のへルパ関数も量が多いので複数回に分けて紹介できればと思います。

今回解説するへルパ関数は以下です。

:::info{title=本記事で取り扱うへルパ関数}
- Arr::accessible（配列にアクセス可能かを判定）
- Arr::add（配列に要素を追加）
- Arr::collapse（配列を一次元配列に変換）
- Arr::crossJoin（複数配列の直積集合を生成）
- Arr::divide（配列をキーと要素で分割）
- Arr::dot（配列をドット記法を使用して一次元配列に変換）
- Arr::except（配列からキーを指定して要素を削除）
- Arr::exists（配列内に指定したキーが存在するかを判定）
:::

### Arr::accessible　配列としてアクセス可能かを判定

:m[**引数に取った値が配列としてアクセス可能かを判定**]します。

```php:accessible.php
$array = ['hoge'];
Arr::accessible($array); // 配列ならtrue

$string = 'test';
Arr::accessible($string); // 配列としてアクセスできないならfalse
```

ちなみに**コレクション**も配列としてアクセスできるので**true**になります。

```php:accessible.php
$collection = Collection::make(['fuga']);
Arr::accessible($collection); // true
```

### Arr::add キーと値を配列に追加する

:m[**指定したkeyと値を配列の要素として追加**]します。

:::info{title=Arr::add}
Arr::add(**追加対象の配列(もしくはコレクション)**, **追加するキー**, **追加する値**)
:::

```php:add.php
// 配列に追加
$array = ['key1' => 'value1'];
dd(Arr::add($array, 'key2', 'value2'));

// 結果
array:2 [▼
  "key1" => "value1"
  "key2" => "value2"
]

// コレクションに追加
$collection = Collection::make(['key1' => 'value1']);
dd(Arr::add($collection, 'key2', 'value2'));

// 結果
Illuminate\Support\Collection {#306 ▼
  #items: array:2 [▼
    "key1" => "value1"
    "key2" => "value2"
  ]
  #escapeWhenCastingToString: false
}
```

追加する値は配列でも可能です。

```php:add.php
$array      = ['key1' => 'value1'];
dd(Arr::add($array, 'key2', ['key3' => 'value2']));

array:2 [▼
  "key1" => "value1"
  "key2" => array:1 [▼
    "key3" => "value2"
  ]
]
```

追加しようとする:**キーが既に存在していた場合**、:m[**null**]の場合のみ値が上書きされます。

```php:add.php
$array      = ['key1' => null];
dd(Arr::add($array, 'key1', 'added value1'));

// 結果
array:1 [▼
  "key1" => "added value1"
]
```

ただし、**値がnull以外の場合**は:m[値は上書きされません]。

```php:add.php
$array = ['key1' => 'value1'];
dd(Arr::add($array, 'key1', 'added value1'));

// 結果
array:1 [▼
  "key1" => "value1"
]
```

ドット記法でキーの指定もできます。
ただし、下記の例のようにドットで指定した**一階層上のキー（例ではkey1）が配列ではない場合**は値が**配列で上書きされてしまいます**。

```php:add.php
$array = ['key1' => 'value1'];
dd(Arr::add($array, 'key1.key1-1', 'value1-1'));

// 結果
// key1のvalue1は上書きされてしまっている
array:1 [▼
  "key1" => array:1 [▼
    "key1-1" => "value1-1"
  ]
]
```

### Arr::collapse 多次元配列を一次元配列へ変換

:m[**指定した多次元配列を一次元配列に変換**]します。

:::info{title=Arr::collapse}
**Arr::collapse(多次元配列): array**

- **コレクション**を引数に取った場合でも返り値は**配列**
- **配列の中に配列がある場合**は一次元にしてくれない
- **キーが被っている場合**は後方の値が優先
:::

```php:使用例
$array = [
    ['value1-1', 'value1-2'],
    ['value2-1', 'value2-2'],
];
dd(Arr::collapse($array));

// 結果
array:4 [▼
  0 => "value1-1"
  1 => "value1-2"
  2 => "value2-1"
  3 => "value2-2"
]
```

```php:コレクションを引数に取った場合は配列が返る
// コレクションでも可能だが返り値は配列になる
$collection = Collection::make([
    ['value1-1', 'value1-2'],
    ['value2-1', 'value2-2'],
]);
dd(Arr::collapse($collection));

array:4 [▼
  0 => "value1-1"
  1 => "value1-2"
  2 => "value2-1"
  3 => "value2-2"
]
```

```php:配列の中の配列は一次元にしてくれない
// 配列の中に配列がある場合は、一次元配列に直してはくれない
$array = [
    ['value1-1', 'value1-2'],
    ['value2-1', 'value2-2', ['value2-3-1', 'value2-3-2']], //　配列の中に配列
];
dd(Arr::collapse($array));

// 結果
array:5 [▼
  0 => "value1-1"
  1 => "value1-2"
  2 => "value2-1"
  3 => "value2-2"
  4 => array:2 [▼
    0 => "value2-3-1"
    1 => "value2-3-2"
  ]
]
```

```php:キーが被っている場合は後方の値が優先される
// キーがかぶっている場合は後方の値が優先
$array = [
    ['key1' => 'value1-1', 'key2' => 'value1-2'],
    ['key1' => 'value2-1', 'key2' => 'value2-2'],
];
dd(Arr::collapse($array));

// 結果
array:2 [▼
  "key1" => "value2-1"
  "key2" => "value2-2"
]
```

### Arr::crossJoin 複数配列の直積集合を生成

:m[**複数配列内の要素の直積集合**]を生成します。

> 直積集合とは
> 複数の集合に対して、各集合から1つずつ要素を取り出して組みにしたものを要素として持つ、新たな集合のこと。
>
> 引用元： [直積集合とは - コトバンク](https://kotobank.jp/word/%E7%9B%B4%E7%A9%8D%E9%9B%86%E5%90%88-5811)

:::info{title=Arr::crossJoin}
**Arr::crossJoin(配列1, 配列2, 配列3, ...): array**

- 引数に取るのは配列以外でもIteratableなものであればいいのでコレクションも可
- 連想配列の場合はキーは無視されて、添字配列として返ってくる
- 多次元配列の場合は、多次元配列部分は１要素として直積集合が生成される
:::

これ自前で実装しようとするとかなり見にくいコードになりそうなので、へルパ関数で提供されているのはありがたいですね。


```php:使用例
dd(Arr::crossJoin([1, 2], [3, 4, 5]));

// 結果
array:6 [▼
  0 => array:2 [▼
    0 => 1
    1 => 3
  ]
  1 => array:2 [▼
    0 => 1
    1 => 4
  ]
  2 => array:2 [▼
    0 => 1
    1 => 5
  ]
  3 => array:2 [▼
    0 => 2
    1 => 3
  ]
  4 => array:2 [▼
    0 => 2
    1 => 4
  ]
  5 => array:2 [▼
    0 => 2
    1 => 5
  ]
]
```

```php:コレクションでの使用例
dd(Arr::crossJoin([1, 2], Collection::make([3, 4, 5])));

// 結果
array:6 [▼
  0 => array:2 [▼
    0 => 1
    1 => 3
  ]
  1 => array:2 [▼
    0 => 1
    1 => 4
  ]
  2 => array:2 [▼
    0 => 1
    1 => 5
  ]
  3 => array:2 [▼
    0 => 2
    1 => 3
  ]
  4 => array:2 [▼
    0 => 2
    1 => 4
  ]
  5 => array:2 [▼
    0 => 2
    1 => 5
  ]
]
```

```php:連想配列で使用した場合
$array1 = ['key1' => 1, 'key2' => 2];
$array2 = ['key3' => 3, 'key4' => 4];

dd(Arr::crossJoin($array1, $array2));

// 結果（キーは除外される）
array:4 [▼
  0 => array:2 [▼
    0 => 1
    1 => 3
  ]
  1 => array:2 [▼
    0 => 1
    1 => 4
  ]
  2 => array:2 [▼
    0 => 2
    1 => 3
  ]
  3 => array:2 [▼
    0 => 2
    1 => 4
  ]
]
```

```php:多次元配列を用いた場合
$array1 = [1, [2, 3]];
$array2 = [4, [5, 6, 7]];
dd(Arr::crossJoin($array1, $array2));

// 結果（多次元配列部分が１要素として直積集合が形成される）
array:4 [▼
  0 => array:2 [▼
    0 => 1
    1 => 4
  ]
  1 => array:2 [▼
    0 => 1
    1 => array:3 [▼
      0 => 5
      1 => 6
      2 => 7
    ]
  ]
  2 => array:2 [▼
    0 => array:2 [▼
      0 => 2
      1 => 3
    ]
    1 => 4
  ]
  3 => array:2 [▼
    0 => array:2 [▼
      0 => 2
      1 => 3
    ]
    1 => array:3 [▼
      0 => 5
      1 => 6
      2 => 7
    ]
  ]
]
```

### Arr::divide 配列のキーと値を分ける

:m[**指定した配列のキーと値をそれぞれ別の変数に格納します**]。

:::info{title=Arr::divide}
**Arr::divide(配列): [キーの配列, 値の配列]**

- 多次元配列を使用した場合は多次元配列部分は１つの値として扱われる
- **純粋な配列しか扱えないのでコレクションを使用するとエラーになる**
:::

```php:使用例
dd(Arr::divide(['key1' => 1, 'key2' => 2, 'key3' => 2]));

// 結果
array:2 [▼
  0 => array:3 [▼ // キー
    0 => "key1"
    1 => "key2"
    2 => "key3"
  ]
  1 => array:3 [▼ // 値
    0 => 1
    1 => 2
    2 => 2
  ]
]
```

```php:多次元配列を使用した場合
dd(Arr::divide([1, [2, 3], 4]));

// 結果
array:2 [▼
  0 => array:3 [▼
    0 => 0
    1 => 1
    2 => 2
  ]
  1 => array:3 [▼
    0 => 1
    1 => array:2 [▼ // 多次元配列部分は一つの要素として扱われる
      0 => 2
      1 => 3
    ]
    2 => 4
  ]
]
```

```php:コレクションを使用するとエラーになる
dd(Arr::divide(Collection::make([1, 2, 3])));

// 結果（エラー）
// array_keys(): Argument #1 ($array) must be of type array, Illuminate\Support\Collection given
```

### Arr::dot 多次元配列をドット記法で表した一次元配列に変換

:m[**多次元配列をドット記法で表した一次元配列に変換**]します。

:::info{title=Arr:dot}
**Arr::dot(多次元配列, キーのプレフィックス文字列（デフォルトは空文字）): array**

- コレクションも可（返り値は配列）
- 添字配列が含まれている場合は、数字で表現される
- **第二引数にキーに使用するプレフィックス**を指定できる（デフォルトは空文字）
:::

```php:使用例（配列）
$array = [
    'key1' => ['key1-1' => 1, 'key1-2' => 2],
    'key2' => ['key2-1' => ['key-2-1-1' => 3], ],
];
dd(Arr::dot($array));

// 結果
array:3 [▼
  "key1.key1-1" => 1
  "key1.key1-2" => 2
  "key2.key2-1.key-2-1-1" => 3
]
```

```php:使用例（コレクション）
$collection = Collection::make([
    'key1' => ['key1-1' => 1, 'key1-2' => 2],
    'key2' => ['key2-1' => ['key-2-1-1' => 3], ],
]);
dd(Arr::dot($array));

// 結果
array:3 [▼
  "key1.key1-1" => 1
  "key1.key1-2" => 2
  "key2.key2-1.key-2-1-1" => 3
]
```

```php:添字配列が含まれている場合
$array = [
    ['key1-1' => 1, 'key1-2' => 2],
    ['key2-1' => ['key-2-1-1' => 3], ],
];
dd(Arr::dot($array));

// 結果（添字配列部分は数字で表現される）
array:3 [▼
  "0.key1-1" => 1
  "0.key1-2" => 2
  "1.key2-1.key-2-1-1" => 3
]
```

```php:第二引数にプレフィックスを使用
$array = [
    'key1' => ['key1-1' => 1, 'key1-2' => 2],
    'key2' => ['key2-1' => ['key-2-1-1' => 3], ],
];
dd(Arr::dot($array, 'key-prefix-'));

// 結果(キーの前に第二引数で指定したkey-prefix-が付与される)
array:3 [▼
  "key-prefix-key1.key1-1" => 1
  "key-prefix-key1.key1-2" => 2
  "key-prefix-key2.key2-1.key-2-1-1" => 3
]
```

### Arr::except 配列から指定したキーと対応する要素を削除する

:m[**配列から指定したキーと対応する要素を削除**]します。

:::info{title=Arr:except}
**Arr::except(配列, 削除するキー): array**

- コレクションも可（削除後のコレクションが返ってくる）
- 削除後に要素がなくなった場合は空の配列が返ってくる
- 削除するキーは配列で複数指定も可能
- 削除するキーが存在しない場合は配列の要素に変化なし
:::

```php:使用例
$array = [
    'key1' => 1,
    'key2' => 2,
];
dd(Arr::except($array, 'key1'));

// 結果（指定したキーの要素が削除される）
array:1 [▼
  "key2" => 2
]
```

```php:コレクションを使用した場合
$collection = Collection::make([
    'key1' => 1,
    'key2' => 2,
]);
dd(Arr::except($collection, 'key1'));

// 結果
Illuminate\Support\Collection {#306 ▼
  items: array:1 [▼
    "key2" => 2
  ]
  escapeWhenCastingToString: false
}
```

```php:削除するキー配列で複数指定
$array = [
    'key1' => 1,
    'key2' => 2,
    'key3' => 3,
];
dd(Arr::except($array, ['key1', 'key2']));

// 結果
array:1 [▼
  "key3" => 3
]
```

### Arr::exists 指定したキーが配列に含まれているかを判定

:m[**指定したキーが配列に含まれている場合にtrue**]を返します。

:::info{title=Arr:exists}
**Arr::exists(配列, 調べるキー): bool**

- 配列が添字配列の場合は、調べるキーに**添字**を指定する
- コレクションも可
- 多次元配列の場合は多次元部分のキーは調べられない
- **コレクションは調べるキーを配列で複数指定可能（完全一致）だが、配列の場合は不可**
:::

```php:使用例
$array = [
    'key1' => 1,
    'key2' => 2,
];
// true
Arr::exists($array, 'key1');

// false
Arr::exists($array, 'key3');
```

```php:添字配列の場合
$array = [1, 2,];

// true
Arr::exists($array, 0);

// false
Arr::exists($array, 2);
```

```php:コレクションの場合
$collection = Collection::make(['key-1' => 1, 'key-2' => 2,]);
// true
Arr::exists($collection, 'key-1');

$collection = Collection::make([1, 2,]);
// false
Arr::exists($collection, 2);
```

```php:多次元配列の場合
$array = ['key-1' => 1, ['key-2' => 2]];

// 多次元部分のキーは調べられない
// false
Arr::exists($array, 'key-2');

// 一階層目のキーは調べられる
// true
Arr::exists($array, 'key-1');
```

:m[コレクションのみ、調べるキーを複数指定が可能]です。

```php:コレクションの場合のみ調べるキーが複数指定可能
$collection = Collection::make(['key-1' => 1, 'key-2' => 2]);

// true
Arr::exists($collection, ['key-1', 'key-2']);

// false
Arr::exists($collection, ['key-1', 'key-3']);
```

配列の場合はエラーになります。

```php:配列の場合はエラー
$array = ['key-1' => 1, 'key-2' => 2];
Arr::exists(['key-1', 'key-2']);

// エラーになる
// array_key_exists(): Argument #1 ($key) must be a valid array offset type
```

:::memo{title=複数のキーを指定した場合について}
Arr::existsの実装部分が以下のコードになります。

```php:Arr:existsの実装コード
/**
* Determine if the given key exists in the provided array.
*
* @param  \ArrayAccess|array  $array
* @param  string|int  $key
* @return bool
*/
public static function exists($array, $key)
{
    if ($array instanceof Enumerable) {
        return $array->has($key);
    }

    if ($array instanceof ArrayAccess) {
        return $array->offsetExists($key);
    }

    return array_key_exists($key, $array);
}
```

**コレクションでは複数キーで検索できる**のに対して**配列の場合はエラー**になってしまう現象ですが、
PHPDocを見ると第二引数の`$key`が`string|int`の型で明記されているので複数キーを指定されることが想定されていないかもしれません。
:::

以上今回は、８つの配列関連のへルパ関数の解説でした。

残りは別記事で解説予定です。

【Laravel】へルパ関数の紹介 配列編１

システム開発をしていると、ステージング環境やリリース前の本番環境にはBasic認証をかけておくことが多いと思います。

ですが、まれに:m[**特定のIPの場合にBasic認証なし**]でアクセスさせたい場合があります。

:::memo{title=実務でのケース}
筆者が遭遇したケースでは、開発中のシステムには:m[サイト内検索]を導入することが決まっており、実現するためにはクローラーがサイト内を循環しなければなりませんでした。
ですがBasic認証がかかったままではクローラーがアクセスできません。なので:m[クローラー元のIPがアクセスした場合のみBasic認証をはずす必要]がありました。
:::

本記事では下記の場合の.htaccessの記述を備忘録的に解説しておきたいと思います。

:::info{title=想定するケース}
- 特定のIP1はBasic認証をかける
- 特定のIP2はBasic認証をせずにアクセスさせる
- 上記以外のIPはアクセス不可
:::

Apacheのバージョンは:m[2.4]とします。

## 完成系

完成系は下記になります。

```cmd:.htaccess
<RequireAny>
    # Basic認証の設定
    <RequireAll>
      AuthUserfile /パス/.htpasswd
      AuthName "Please enter your ID and password"
      AuthType Basic
      require valid-user
      <RequireAny>
        Require ip <Basic認証をかけたいIP>
      </RequireAny>
    </RequireAll>

    # Basic認証をせずにアクセスさせる設定
    <RequireAll>
      Require ip <Basic認証をせずにアクセスさせたいIP>
    </RequireAll>
</RequireAny>
```

## 解説

上記の.htaccessの中で押さえておきたいものは`<RequireAny>`、`<RequireAll>`の2つです。以降で解説します。

### RequireAny、RequireAll

`<RequireAny>`、`<RequireAll>`はアクセス制御をコントロールする役割を果たします。

挙動としては`<RequireAny>`内に記載した:m[**条件の内一つ**]、`<RequireAll>`は:m[**すべての条件に一致**]していればアクセスを許可します。

使用例としてはRequireAny、RequireAllそれぞれ以下のような形です。

```.htaccess:RequireAny使用例
<RequireAny>
    Require ip xxx.xxx.xxx.xxx
    Require ip yyy.yyy.yyy.yyy
</RequireAny>
```

この例ではRequireAnyを使用しているので、IPが**xxx.xxx.xxx.xxx**か**yyy.yyy.yyy.yyy**のどちらかの場合にアクセスできます。

それ以外のIPは条件に一致しないのでアクセスできません。

```.htaccess:RequireAll使用例
<RequireAll>
    Require ip xxx.xxx.xxx.xxx
    Require host host-name-1
</RequireAll>
```

この例ではRequireAllを使用しており、IPが**xxx.xxx.xxx.xxx**かつホスト名が**host-name-1**の場合にアクセスできます。

RequireAnyではないので、IPが**xxx.xxx.xxx.xxx**で片方の条件は満たしていても、ホスト名が**host-name-2**のようにもう片方の条件がみたされていなければ**アクセスできません**。

:::memo{title=Memo}
`<RequireAny>`、`<RequireAll>`はプログラミングでいうところの:m[**if文**]に似ていると思えば理解しやすいかもしれません。

`<RequireAny>`は:m[**if(条件1 || 条件2)**]の**OR条件**で、`<RequierAll>`は:m[**if(条件1 && 条件2)**]の**AND条件**をそれぞれ指定しているイメージです。
:::

このようなアクセス制御を行うディレクティブは全部で**3つ**あります。

:::info{title=アクセス制御ディレクティブ}
- RequireAll
  - すべての条件に一致していればアクセスを許可（AND条件）
- RequireAny
  - いずれかの条件に一致していればアクセスを許可（OR条件）
- RequireNone
  - すべての条件に**一致しなければ**アクセスを許可（NOT条件）
  - RequireAllディレクティブ内でのみ使用可能
:::

下記のように入れ子で使用することもできます。

```.htaccess:入子の例
<RequireAny>

    # 条件1
    <RequireAll>
        # Basic認証の設定
        AuthUserfile /パス/.htpasswd
        AuthName "Please enter your ID and password"
        AuthType Basic
        require valid-user

        # 条件1-1
        <RequireAny>
          Require ip xxx.xxx.xxx.xxx
          Require ip yyy.yyy.yyy.yyy
        </RequireAny>

        # 条件1-2
        <RequireAny>
          Require host host-1
          Require host host-2
        </RequireAny>

    </RequireAll>

    # 条件2
    <RequireAll>
      Require ip yyy.yyy.yyy.yyy
    </RequireAll>
</RequireAny>
```

上記の例では、**条件1**か**条件2**の**どちらかを満たせば**アクセスが可能になります。

条件1の内部を見てみるとRequireAnyで一致条件を指定している以外にも、:m[**Basic認証の記述**]をしているのが分かるかと思います。

この場合条件1に一致した際は:m[**Basic認証が適用される**]ことになります。

同じような理屈で条件2の方は一致条件しか指定していないため、条件2に一致した場合は:m[**Basic認証なし**]でアクセスが可能になります。

### 完成系（再掲）

ここまでで、再度完成系を眺めてみると何をしているのかなんとなくわかるのではないでしょうか？

```cmd:.htaccess

# RequireAnyなのでディレクティブ内のいずれかの条件に一致した場合アクセス可能
<RequireAny>
    # 条件1
    # この条件に一致した場合はBasic認証をかける
    <RequireAll>
      # Basic認証の設定
      AuthUserfile /パス/.htpasswd
      AuthName "Please enter your ID and password"
      AuthType Basic
      require valid-user

      # 条件1の一致条件
      <RequireAny>
        Require ip <Basic認証をかけたいIP>
      </RequireAny>
    </RequireAll>

    # 条件2
    # この条件に一致した場合はBasic認証をせずにアクセスさせる
    <RequireAll>
      Require ip <Basic認証をせずにアクセスさせたいIP>
    </RequireAll>
</RequireAny>
```

ここまでで解説したことを応用すれば、Basic認証以外にも様々な制御が可能になるかと思いますので試してみてください！

特定のIPの場合にBasic認証をかけずにサイトにアクセスさせる方法

開発中にGITでコミットをしようとしたら:m[**fatal: unable to auto-detect email address (got 'xxxxxxxxxxxx')**]のエラーが出てコミットができなかった。

## エラーの原因と解消法

下記がエラー時のログ全文。

```cmd:error.log
Author identity unknown

*** Please tell me who you are.

Run

  git config --global user.email "you@example.com"
  git config --global user.name "Your Name"

to set your account's default identity.
Omit --global to set the identity only in this repository.

fatal: unable to auto-detect email address (got 'xxxxxxxxxxxxx')
```

結論としては、GITにメールアドレスを設定していなかったことが原因。

ログ内にあるように下記でメールアドレスを設定すればOK。(ついでにユーザー名も設定する)

```cmd:set-mail
git config --global user.email "<メールアドレス>"
git config --global user.name "<ユーザー名>"
```

正常に登録できたかを確認するには、`git config -l`で登録した情報が下記のように表示されているかを確認する。

```cmd:conf-info
❯ git config -l
...
user.email=<登録したメールアドレス>
user.name=<登録したユーザー名>
```

再度`git commit`すれば無事にコミットが完了する。

今回開発時に急に上記のエラーが起きた。今までもメールアドレスは登録してなかったのに何故急にこのようになったのかは不明。

Gitでコミット時に「unable to auto-detect email address」のエラーが出た際の解消法

Next.js内で「Storybook」をビルドしようとした際に`error:0308010C:digital envelope routines::unsupported`というエラーが発生した。
ので、エラーの原因と解消法について備忘録として記載する。

## エラーが発生した経緯

[Storybook](https://storybook.js.org/)を導入し、ビルドを行うために`start-storybook -p 6006`を実施したところ`error:0308010C:digital envelope routines::unsupported`のエラーが発生しビルドができなかった。

## エラーの原因

エラーが発生したプロジェクトは:m[**Nodeのバージョンが17**]に対して:m[**webpackのバージョンが5**]であったが、Nodeとwebpack間のバージョンの相性が悪かったらしい。

(webpackのバージョン6では解消済みとのこと)

## 解消方法

`docker-compose.yml`に下記を追加することで解消した。

```yml:docker-compose.yml
environment:
            - NODE_OPTIONS=--openssl-legacy-provider
```