키를 포함한 PHP의 array_map


208

다음과 같은 방법이 있습니까?

$test_array = array("first_key" => "first_value", 
                    "second_key" => "second_value");

var_dump(array_map(function($a, $b) { return "$a loves $b"; }, 
         array_keys($test_array), 
         array_values($test_array)));

하지만 그 대신 호출 array_keysarray_values직접 전달 $test_array변수를?

원하는 출력은 다음과 같습니다.

array(2) {
  [0]=>
  string(27) "first_key loves first_value"
  [1]=>
  string(29) "second_key loves second_value"
}

이 일반적인 문제에 대한 대조적 인 접근법에 대해서는 stackoverflow.com/search?q=each_with_index참조하십시오
dreftymac

답변:


206

array_map은 키를 처리하지 않으므로 사용하지 않습니다.

array_walk 는 다음을 수행합니다.

$test_array = array("first_key" => "first_value",
                    "second_key" => "second_value");
array_walk($test_array, function(&$a, $b) { $a = "$b loves $a"; });
var_dump($test_array);

// array(2) {
//   ["first_key"]=>
//   string(27) "first_key loves first_value"
//   ["second_key"]=>
//   string(29) "second_key loves second_value"
// }

그러나 매개 변수로 주어진 배열을 변경하므로 정확하게 프로그래밍되지는 않습니다 (질문이 태그 된 것처럼). 또한 주석에서 지적했듯이 배열의 값만 변경되므로 키는 질문에 지정한 값이 아닙니다.

원하는 경우 다음과 같이 자신 위에 포인트를 수정하는 함수를 작성할 수 있습니다.

function mymapper($arrayparam, $valuecallback) {
  $resultarr = array();
  foreach ($arrayparam as $key => $value) {
    $resultarr[] = $valuecallback($key, $value);
  }
  return $resultarr;
}

$test_array = array("first_key" => "first_value",
                    "second_key" => "second_value");
$new_array = mymapper($test_array, function($a, $b) { return "$a loves $b"; });
var_dump($new_array);

// array(2) {
//   [0]=>
//   string(27) "first_key loves first_value"
//   [1]=>
//   string(29) "second_key loves second_value"
// }

이 경우를 제외하고 $a = "$b loves $a"는 OP의 원하는 출력과 일치하도록합니다.
cmbuckley

1
정확하고 변경 :) array_walk와 array_walk를 얼마나 다르게 만들 었는지 멋집니다.
eis

감사합니다 원래 배열을 엉망으로 만들지 않기 위해 여기에 내가 한 일이 있습니다 (아래 답변 참조)
José Tomás Tocino

3
array_walk()결과 배열을 반환하지 않지만 대신 bool을 반환 하지만 "기능 프로그래밍" 은 아닙니다.
mae

예 @mae, 나뿐만 아니라이 질문에 대해 쓴처럼 - 대신이 매개 변수 변경 값을 반환
EIS

145

이것은 아마도 가장 짧고 가장 쉬운 이유입니다.

$states = array('az' => 'Arizona', 'al' => 'Alabama');

array_map(function ($short, $long) {
    return array(
        'short' => $short,
        'long'  => $long
    );
}, array_keys($states), $states);

// produces:
array(
     array('short' => 'az', 'long' => 'Arizona'), 
     array('short' => 'al', 'long' => 'Alabama')
)

15
나는 그 질문이 구체적으로 사용하지 말 것을 깨달았다 array_keys(). 그러나 그것은 바보 같은 요구 사항처럼 보입니다.
Kevin Beal

3
질문은 array_keys ()를 사용하는 솔루션을 제공했지만 현재 솔루션보다 이점이 적은 (예 : 적은 함수 호출) 답변을 제공하는 것은 어리석은 일입니다.
Chinoto Vokro

원래 질문에 대한 답은 아니오이며 이것이 가장 적합한 솔루션입니다.
usoban

65

다음은 매우 간단한 PHP 5.5 호환 솔루션입니다.

function array_map_assoc(callable $f, array $a) {
    return array_column(array_map($f, array_keys($a), $a), 1, 0);
}

제공하는 콜 러블 자체는 두 값을 가진 배열을 반환해야합니다 return [key, value]. 따라서 내부 호출 array_map은 배열 배열을 생성합니다. 그런 다음에 의해 단일 차원 배열로 다시 변환됩니다 array_column.

용법

$ordinals = [
    'first' => '1st',
    'second' => '2nd',
    'third' => '3rd',
];

$func = function ($k, $v) {
    return ['new ' . $k, 'new ' . $v];
};

var_dump(array_map_assoc($func, $ordinals));

산출

array(3) {
  ["new first"]=>
  string(7) "new 1st"
  ["new second"]=>
  string(7) "new 2nd"
  ["new third"]=>
  string(7) "new 3rd"
}

부분 적용

다른 배열이지만 동일한 매핑 함수와 함께 함수를 여러 번 사용해야하는 경우 부분 함수 응용 프로그램 ( ' currying ' 관련 )을 호출하여 호출 할 때만 데이터 배열을 전달할 수 있습니다.

function array_map_assoc_partial(callable $f) {
    return function (array $a) use ($f) {
        return array_column(array_map($f, array_keys($a), $a), 1, 0);
    };
}

...
$my_mapping = array_map_assoc_partial($func);
var_dump($my_mapping($ordinals));

주어진 것과 동일한 출력을 생성 하며 이전 $func$ordinals같습니다.

참고 : 매핑 된 함수가 서로 다른 두 입력에 대해 동일한 키 를 반환 하면 이후 키 와 관련된 값 이 이깁니다. array_map_assoc이전 키가 이길 수 있도록 입력 배열과 출력 결과 를 반대로 바꿉니다. (이 예제에서 반환 된 키는 소스 배열의 키를 통합하므로 충돌 할 수 없으며 차례로 고유해야합니다.)


대안

다음은 위의 변형으로 일부에게는 더 논리적이지만 PHP 5.6이 필요합니다.

function array_map_assoc(callable $f, array $a) {
    return array_merge(...array_map($f, array_keys($a), $a));
}

이 변형에서 제공된 함수 (데이터 배열이 매핑되는 함수)는 대신 하나의 행이있는 연관 배열을 반환해야합니다 return [key => value]. 그런 다음 호출 가능 항목을 매핑 한 결과는 간단히 압축을 풀고로 전달됩니다 array_merge. 앞서와 같이, 중복 키를 반환하면 나중에 값을 얻습니다.

nb Alex83690은 주석 array_replace대신 여기 를 사용 하면 array_merge정수 키가 유지 된다는 의견에 주목했습니다 . array_replace입력 배열을 수정하지 않으므로 기능 코드에 안전합니다.

PHP 5.3 ~ 5.5 인 경우 다음과 같습니다. array_reduce이진 +배열 연산자를 사용 하여 키를 유지하면서 결과 2 차원 배열을 1 차원 배열로 변환합니다.

function array_map_assoc(callable $f, array $a) {
    return array_reduce(array_map($f, array_keys($a), $a), function (array $acc, array $a) {
        return $acc + $a;
    }, []);
}

용법

따라서이 두 가지 변형이 모두 사용됩니다.

$ordinals = [
    'first' => '1st',
    'second' => '2nd',
    'third' => '3rd',
];

$func = function ($k, $v) {
    return ['new ' . $k => 'new ' . $v];
};

var_dump(array_map_assoc($func, $ordinals));

메모 =>대신 ,에서 $func.

출력은 이전과 동일하며 각각 이전과 같은 방식으로 부분적으로 적용 할 수 있습니다.


 요약

원래 질문의 목표는 호출되는 더 복잡한 기능을 희생하면서 가능한 한 간단하게 호출을 호출하는 것입니다. 특히 키와 값을 나누지 않고 데이터 배열을 단일 인수로 전달할 수 있습니다. 이 답변의 시작 부분에 제공된 기능 사용 :

$test_array = ["first_key" => "first_value",
               "second_key" => "second_value"];

$array_map_assoc = function (callable $f, array $a) {
    return array_column(array_map($f, array_keys($a), $a), 1, 0);
};

$f = function ($key, $value) {
    return [$key, $key . ' loves ' . $value];
};

var_dump(array_values($array_map_assoc($f, $test_array)));

또는이 질문에 대해서만 array_map_assoc()출력 키를 삭제 하는 기능을 단순화 할 수 있습니다 . 질문은 요청하지 않기 때문입니다.

$test_array = ["first_key" => "first_value",
               "second_key" => "second_value"];

$array_map_assoc = function (callable $f, array $a) {
    return array_map($f, array_keys($a), $a);
};

$f = function ($key, $value) {
    return $key . ' loves ' . $value;
};

var_dump($array_map_assoc($f, $test_array));

따라서 대답은 NO 이므로 호출을 피할 수 없지만 고차 함수로 호출되는 array_keys곳을 추상화 할 수 있습니다 array_keys.


7
이 답변이 정답으로 표시되어야합니다.
eddiew는

6
감사합니다 @ eddiewould,하지만 나는 약 4½ 년 너무 늦었습니다 :) 나는 해결책을 찾고 여기에 왔고, 내가 좋아하는 것을 찾지 못했기 때문에 내 자신을 생각해 냈습니다.
Nicholas Shanks

1
내가 그 사람이 될거야. PHP 5.3 은이 답변 날짜에 더 이상 필요하지 않습니다 . 이모.
Erutan409

1
잘못된 첫 번째 대안 솔루션입니다. 당신은 교체해야 array_merge의한 array_replace정수 것 키를 보존 할 수 있습니다.
Alex83690

1
감사합니다! 비록 내가 "유효하지 않다"고 말하는 것은 약간 잘못된 것입니다 – 정수 키가 없다면 괜찮습니다
Nicholas Shanks

20

PHP5.3 이상에서 :

$test_array = array("first_key" => "first_value", 
                    "second_key" => "second_value");

var_dump(
    array_map(
        function($key) use ($test_array) { return "$key loves ${test_array[$key]}"; },
        array_keys($test_array)
    )
);

1
요구 사항은 "$ test_array 변수를 직접 전달하여 array_keys 및 array_values를 호출하는 대신"array_keys없이 사용할 수 있다고 생각합니다.
e is

4

이것이 내가 프로젝트에서 이것을 구현 한 방법입니다.

function array_map_associative(callable $callback, $array) {
    /* map original array keys, and call $callable with $key and value of $key from original array. */
    return array_map(function($key) use ($callback, $array){
        return $callback($key, $array[$key]);
    }, array_keys($array));
}

매우 깨끗하고 원래 배열을 변경하지 않습니다!
Raffaele Candeliere

4

이봐! 사소한 해결책이 있습니다!

function array_map2(callable $f, array $a)
{
    return array_map($f, array_keys($a), $a);
}

질문에서 언급했듯이 array_map 이미 필요한 기능이 이미 있습니다 . 다른 답변은 심각하게 복잡 array_walk합니다. 기능적이지 않습니다.

용법

귀하의 예에서 기대할 수 있듯이

$test_array = array("first_key" => "first_value", 
                    "second_key" => "second_value");

var_dump(array_map2(function($a, $b) { return "$a loves $b"; }, $test_array));

다른 질문은 지정된 질문을 # 이유로 qrrqy_keys()사용해서는 안되기 때문에 지나치게 복잡합니다.
Brad Kent

2

"수동 루프"는을 사용하는 사용자 정의 함수를 작성하는 것을 의미했습니다 foreach. array_map함수의 범위가 $array참조가 아닌 복사본 이되기 때문에 새로운 배열을 반환합니다 .

function map($array, callable $fn) {
  foreach ($array as $k => &$v) $v = call_user_func($fn, $k, $v);
  return $array;
}

array_mapwith를 사용 하는 기술 array_keys은 실제로 더 단순 해 보이며 null키-값 쌍을 반환하는 콜백으로 사용할 수 있기 때문에 더 강력합니다 .

function map($array, callable $fn = null) {
  return array_map($fn, array_keys($array), $array);
}

참조와 배열을 반복, 짜증 일이 발생할
janenz00

그것은 짜증나 지 않습니다. 단지 unset( $value )정의 된 범위에 여전히 존재 하기 때문에 잊어 버렸습니다 .
aziz punjani

@azis는 기사를 언급하면서 짜증에 대해 농담했습니다. 설정 해제를 잊어 버린 경우 예기치 않은 효과가 발생합니다.
janenz00

1
답변 주셔서 감사하지만, 나는 전통적인 루프를 사용하고 싶지 않다는 것이 분명하다고 생각했습니다.
José Tomás Tocino

@ janenz00 설명을 보려면 수정 된 답변을 참조하십시오. 깨끗한 변수 범위에서 반복을 의미했습니다.
ryanve

1

eis의 답변을 바탕으로 원래 배열을 어지럽히 지 않기 위해 내가 한 일은 다음과 같습니다.

$test_array = array("first_key" => "first_value",
                    "second_key" => "second_value");

$result_array = array();
array_walk($test_array, 
           function($a, $b) use (&$result_array) 
           { $result_array[] = "$b loves $a"; }, 
           $result_array);
var_dump($result_array);

2
왜 배열 값과 키를 array_map에 직접 전달하는 것보다 쉬운가요? 속도가 느리고 복잡하며 이점을 보지 못합니다.
Ariel

1
@ 아리엘 큰 숫자라도 느리다는 주장을 뒷받침 할 수 있습니까? 배열을 한 번만 반복해야하므로 큰 O 표기법에서는 크기가 더 빨라야한다고 생각합니다. 그래도 복잡성에 동의합니다.
eis

@eis C에서 en이 아니라 PHP로 결과 배열을 한 번에 하나씩 생성하기 때문에 속도가 느립니다. array_keys 호출을 피할 수는 있습니다 (C에 있기 때문에 빠르지 만). 벤치마킹-어느 것이 더 빠를 지, 실제로 확실하지는 않지만 일반적으로 더 많은 코드 = 느린 코드입니다. 복잡성에서는 확실히 더 나쁘고 대부분의 경우 속도보다 중요합니다.
Ariel

1
array_walk클로저에서 참조 하지 않기 때문에 세 번째 인수를 보낼 필요 가 없습니다.
Steven Lu

1

eis의 답변을 기반 으로이 기능을 만들었습니다 .

function array_map_($callback, $arr) {
    if (!is_callable($callback))
        return $arr;

    $result = array_walk($arr, function(&$value, $key) use ($callback) {
        $value = call_user_func($callback, $key, $value);
    });

    if (!$result)
        return false;

    return $arr;
}

예:

$test_array = array("first_key" => "first_value", 
                "second_key" => "second_value");

var_dump(array_map_(function($key, $value){
    return $key . " loves " . $value;
}, $arr));

산출:

array (
  'first_key' => 'first_key loves first_value,
  'second_key' => 'second_key loves second_value',
)

물론 array_valuesOP에서 원하는 것을 정확하게 반환 하는 데 사용할 수 있습니다 .

array_values(array_map_(function($key, $value){
    return $key . " loves " . $value;
}, $test_array))

@ KevinBeal 나는이 기능을 내 작품에 많이 사용합니다. 오류가 어디 있는지 지적 할 수 있습니까?
Julio Vedovatto

2
첫째, 코드 그대로의 $arr배열에는 배열 유형 의 검사가 누락 되었지만 인수를 힌트로 입력 callable하고 array대신 검사를에 드롭 할 수 있습니다 is_callable. 다음으로 $ value에 할당 한 다음 사용하지 않습니다. 반환 값을 무시해야합니다. 셋째, 콜백에서 예외를 throw하는 것이 false를 반환하는 것보다 낫습니다. 그런 다음 항상 유효한 값을 반환하거나 항상 throw합니다.
Nicholas Shanks

1

YaLinqo 라이브러리 *는 이러한 종류의 작업에 적합합니다. 모든 콜백에서 값과 키를 완벽하게 지원하고 SQL과 유사한 .NET의 LINQ 포트입니다. 예를 들면 다음과 같습니다.

$mapped_array = from($test_array)
    ->select(function ($v, $k) { return "$k loves $v"; })
    ->toArray();

또는 그냥 :

$mapped_iterator = from($test_array)->select('"$k loves $v"');

다음 '"$k loves $v"'은이 라이브러리가 지원하는 전체 클로저 구문에 대한 바로 가기입니다. toArray()결국 선택 사항입니다. 메소드 체인은 결과가 바로 사용을 통해 반복 할 필요가 그렇다면, 반복자를 반환 foreach, toArray호출이 제거 될 수있다.

* 나에 의해 개발


1

나는 이런 식으로 할 것입니다 :

<?php

/**
 * array_map_kv()
 *   An array mapping function to map with both keys and values.
 *
 * @param $callback callable
 *   A callback function($key, $value) for mapping values.
 * @param $array array
 *   An array for mapping.
 */
function array_map_kv(callable $callback, array $array) {
  return array_map(
    function ($key) use ($callback, $array) {
      return $callback($key, $array[$key]); // $callback($key, $value)
    },
    array_keys($array)
  );
}

// use it
var_dump(array_map_kv(function ($key, $value) {
  return "{$key} loves {$value}";
}, array(
  "first_key" => "first_value",
  "second_key" => "second_value",
)));

?>

결과 :

array(2) {
  [0]=>
  string(27) "first_key loves first_value"
  [1]=>
  string(29) "second_key loves second_value"
}

1

버전 5.6 이상을 사용하여 문제에 대한 또 다른 솔루션을 추가하겠습니다. 그것이 이미 훌륭한 솔루션보다 더 효율적인지 모르겠지만 (아마도 그렇지는 않지만) 나에게 읽는 것이 더 간단합니다.

$myArray = [
    "key0" => 0,
    "key1" => 1,
    "key2" => 2
];

array_combine(
    array_keys($myArray),
    array_map(
        function ($intVal) {
            return strval($intVal);
        },
        $myArray
    )
);

strval()의 예제 함수로 사용하면 array_map다음이 생성됩니다.

array(3) {
  ["key0"]=>
  string(1) "0"
  ["key1"]=>
  string(1) "1"
  ["key2"]=>
  string(1) "2"
}

잘만되면 나는 이것을 이해하기가 아주 쉬운 사람이 아니길 바란다. 키 배열과 값 배열로 배열을 array_combine만듭니다. key => value나머지는 설명이 필요 없습니다.


1

배열 라이브러리 에서 map 메소드를 사용 하여 원하는 것을 정확하게 달성 할 수 있습니다.

Arr::map($test_array, function($a, $b) { return "$a loves $b"; });

또한 키를 유지하고 필요에 맞는 몇 가지 다른 모드는 말할 것도없고 새로운 배열을 반환합니다.


1
$array = [
  'category1' => 'first category',
  'category2' => 'second category',
];

$new = array_map(function($key, $value) {
  return "{$key} => {$value}";
}, array_keys($array), $array);

출처


0

나는 항상 배열 맵의 자바 스크립트 변형을 좋아합니다. 가장 간단한 버전은 다음과 같습니다.

/**
 * @param  array    $array
 * @param  callable $callback
 * @return array
 */
function arrayMap(array $array, callable $callback)
{
    $newArray = [];

    foreach( $array as $key => $value )
    {
        $newArray[] = call_user_func($callback, $value, $key, $array);
    }

    return $newArray;
}

이제 값을 구성하는 방법을 콜백 함수에 전달할 수 있습니다.

$testArray = [
    "first_key" => "first_value", 
    "second_key" => "second_value"
];

var_dump(
    arrayMap($testArray, function($value, $key) {
        return $key . ' loves ' . $value;
    });
);

당신이 다음 굽는다-에서 일부 특정 콜백 (행동)하는 새로운 기능을 만들 수있는, 당신이 쓰는 모든 함수의 마지막 인수로 데이터가 더 유용합니다 - 즉 당신이 함수의 합성을 얻을이 : h(g(f($data)))적용 f후, g다음 h에 데이터. 다이버 데이터를 고정 데이터 세트에 적용하는 기능을 갖는 것보다 다이버 데이터에 대해 동일한 작업을 수행하는 기능을 갖는 것이 기능 프로그래밍에서 일반적으로 더 다재다능한 것으로 간주됩니다.
니콜라스 정강이

귀하의 예에서는 함수에 대한 인수가 하나뿐입니다. array_filter, array_reduce 및 javascript의 배열 함수와 같은 첫 번째 인수로 데이터를 넣는 것이 더 쉽다는 것을 알았습니다.
blablabla

그게 내 요점이야! 데이터를 마지막으로 전달하면 함수를 카레하고 (루핑을 특정 작업과 결합하는 새 함수 작성) 단일 매개 변수로 새 함수를 호출하여 해당 함수를 데이터에 적용 수 있습니다. 이 교장은이 대답에, 더 나은 내가 여기 수있는 것보다 설명 : stackoverflow.com/a/5863222
니콜라스 정강이를

PHP와 같은 언어에서 작성 기능을 사용하는 것이이 문제에 대한 더 나은 해결책이 아닙니까?
blablabla

1
대안이지만 FP에 대한 추가 투자가 필요합니다 (예 : github.com/nickshanks/fp-php-talk/blob/master/lib.php#L24 또는 this : github.com/nickshanks/php-fp/blob) /master/src/fp.php#L62
Nicholas Shanks

0

키를 유지하면서 이것을하는 또 다른 방법 :

$test_array = [
    "first_key"     => "first_value",
    "second_key"    => "second_value"
];

$f = function($ar) {
    return array_map(
        function($key, $val) {
            return "{$key} - {$val}";
        },
        array_keys($ar),
        $ar
    );
};

#-- WITHOUT preserving keys
$res = $f($test_array);

#-- WITH preserving keys
$res = array_combine(
    array_keys($test_array),
    $f($test_array)
);

-2

나는 명백한 대답이 누락 된 것을 본다.

function array_map_assoc(){
    if(func_num_args() < 2) throw new \BadFuncionCallException('Missing parameters');

    $args = func_get_args();
    $callback = $args[0];

    if(!is_callable($callback)) throw new \InvalidArgumentException('First parameter musst be callable');

    $arrays = array_slice($args, 1);

    array_walk($arrays, function(&$a){
        $a = (array)$a;
        reset($a);
    });

    $results = array();
    $max_length = max(array_map('count', $arrays));

    $arrays = array_map(function($pole) use ($max_length){
        return array_pad($pole, $max_length, null);
    }, $arrays);

    for($i=0; $i < $max_length; $i++){
        $elements = array();
        foreach($arrays as &$v){
            $elements[] = each($v);
        }
        unset($v);

        $out = call_user_func_array($callback, $elements);

        if($out === null) continue;

        $val = isset($out[1]) ? $out[1] : null;

        if(isset($out[0])){
            $results[$out[0]] = $val;
        }else{
            $results[] = $val;
        }
    }

    return $results;
}

array_map과 동일하게 작동합니다. 거의.

실제로 map다른 언어에서 알 수 있듯이 순수하지 않습니다 . Php는 매우 이상하기 때문에 매우 이상한 사용자 기능이 필요합니다 worse is better. 정확하게 깨진 접근법 을 깨뜨리고 싶지 않기 때문 입니다.

실제로 실제로 map는 아닙니다 . 그러나 여전히 매우 유용합니다.

  • array_map과의 첫 번째 명백한 차이점은 콜백이 each()값만 아니라 모든 입력 배열에서 출력을 얻는다는 것입니다. 한 번에 더 많은 배열을 반복 할 수 있습니다.

  • 두 번째 차이점은 키가 콜백에서 반환 된 후 처리되는 방식입니다. 콜백 함수의 반환 값은이어야합니다 array('new_key', 'new_value'). 동일한 키가 반환되면 동일한 키로 인해 이전 값을 덮어 쓸 수도 있습니다. 일반적인 map동작 은 아니지만 키를 다시 쓸 수 있습니다.

  • 세 번째 이상한 점은 key반환 값 ( array(1 => 'value')또는로 array(null, 'value')) 을 생략하면 새 키가 $array[] = $value사용 된 것처럼 할당 됩니다. 그것은 map일반적인 행동 이 아니지만 때로는 편리하다고 생각합니다.

  • 네 번째 이상한 점은 콜백 함수가 값을 반환하지 않거나를 반환하면 null현재 키와 값의 전체 세트가 출력에서 ​​생략되고 단순히 건너 뜁니다. 이 기능은 완전히 map파이가 아니지만 array_filter_assoc그러한 기능이 있다면 이 기능을 탁월한 스턴트 더블로 만듭니다.

  • 콜백의 리턴에서 두 번째 요소 ( 1 => ...) ( 부분) 를 생략하면 null실제 값 대신에 사용됩니다.

  • 키가 0있고 1콜백이 반환 된 요소를 제외한 다른 요소 는 무시됩니다.

  • 마지막으로 람다 null또는 배열을 제외한 값을 반환하면 키와 값이 모두 생략 된 것처럼 처리됩니다.

    1. 요소의 새 키가 할당됩니다
    2. null 가치로 사용됩니다
경고 :
이 마지막 기능은 이전 기능의 일부일 뿐이며 완전히 쓸모가 없음을 명심하십시오. 이 기능은 향후 릴리스에서 임의로 사용되지 않으며 예기치 않게 변경 되므로이 기능을 사용하지 않는 것이 좋습니다 .

참고 :
와 달리 첫 번째 콜백 매개 변수를 제외하고에 array_map전달 된 모든 비 배열 매개 변수 array_map_assoc는 자동으로 배열로 캐스트됩니다.

예 :
// TODO: examples, anyone?

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.