PHP tablica_mapy zawierająca klucze


208

Czy istnieje sposób na zrobienie czegoś takiego:

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

Ale zamiast wywoływać array_keysi array_valuesbezpośrednio przekazywać $test_arrayzmienną?

Pożądane wyjście to:

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

Zobacz także: stackoverflow.com/search?q=each_with_index, aby uzyskać kontrastowe podejście do tego ogólnego problemu
dreftymac

Odpowiedzi:


206

Nie z array_map, ponieważ nie obsługuje kluczy.

array_walk robi:

$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"
// }

Zmienia jednak tablicę podaną jako parametr, więc nie jest to do końca funkcjonalne programowanie (ponieważ masz tak oznaczone pytanie). Ponadto, jak wskazano w komentarzu, spowoduje to jedynie zmianę wartości tablicy, więc klucze nie będą zgodne z danymi podanymi w pytaniu.

Jeśli chcesz, możesz napisać funkcję, która naprawia punkty powyżej.

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"
// }

Z wyjątkiem tego, że w tym przypadku chcesz $a = "$b loves $a"dopasować pożądane wyjście OP.
cmbuckley

1
poprawne, zmienione :) Fajnie, jak różni się tablica_map od tablicy.
eis

Fajnie dzięki. Aby uniknąć bałaganu w oryginalnej tablicy, oto co ostatecznie zrobiłem (spójrz na moją odpowiedź poniżej)
José Tomás Tocino,

3
Nie jest to jednak „programowanie funkcjonalne”, ponieważ array_walk()nie zwraca wynikowej tablicy, ale bool.
mae

@ mae tak, tak jak napisałem w odpowiedzi - zamiast zwracać wartość zmienia parametr
eis

145

Jest to prawdopodobnie najkrótszy i najłatwiejszy do uzasadnienia temat:

$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
Właśnie zdałem sobie sprawę, że pytanie wyraźnie mówi, aby nie używać array_keys(). Wydaje się to jednak głupim wymogiem.
Kevin Beal,

3
Pytanie zapewniło rozwiązanie za pomocą array_keys (), głupie byłoby udzielenie odpowiedzi, która nie ma przewagi (np. Wywołanie mniejszej liczby funkcji) w stosunku do obecnego rozwiązania.
Chinoto Vokro

Odpowiedź na pierwotne pytanie brzmi NIE, i jest to najbardziej odpowiednie rozwiązanie.
usoban

65

Oto moje bardzo proste rozwiązanie kompatybilne z PHP 5.5:

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

Podane przez Ciebie wywołanie powinno zwrócić tablicę z dwiema wartościami, tj return [key, value]. Wewnętrzne wezwanie do array_maptworzy zatem tablicę tablic. To następnie jest konwertowane z powrotem do tablicy jednowymiarowej przez array_column.

Stosowanie

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

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

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

Wynik

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

Częściowe zastosowanie

W przypadku, gdy trzeba używać tej funkcji wiele razy z różnymi tablicami, ale z tą samą funkcją mapowania, można zrobić coś, co nazywa się aplikacją funkcji częściowej (związaną z „ curry ”), co pozwala na przekazanie tablicy danych tylko po wywołaniu:

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

Który daje taką samą wydajność, podaną $funci $ordinalssą jak wcześniej.

UWAGA: jeśli funkcja zamapowana zwraca ten sam klucz dla dwóch różnych danych wejściowych, wartość powiązana z późniejszym kluczem wygra. Odwróć tablicę wejściową i wynik wyjściowy, array_map_assocaby umożliwić wygrywanie wcześniejszym kluczom. (Zwrócone klucze w moim przykładzie nie mogą kolidować, ponieważ zawierają klucz tablicy źródłowej, która z kolei musi być unikalna).


Alternatywny

Poniżej przedstawiono wariant powyższego, który dla niektórych może okazać się bardziej logiczny, ale wymaga PHP 5.6:

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

W tym wariancie podana funkcja (na której odwzorowana jest tablica danych) powinna zamiast tego zwrócić tablicę asocjacyjną z jednym wierszem, tj return [key => value]. Wynik mapowania wywoływanego elementu jest następnie po prostu rozpakowywany i przekazywany do array_merge. Tak jak wcześniej, zwrócenie duplikatu klucza spowoduje wygraną późniejszych wartości.

nb Alex83690 zauważył w komentarzu, że użycie array_replacetutaj w miejsce array_mergezachowałoby klucze do liczb całkowitych. array_replacenie modyfikuje tablicy wejściowej, więc jest bezpieczny dla kodu funkcjonalnego.

Jeśli korzystasz z PHP 5.3 do 5.5, poniższe są równoważne. Wykorzystuje array_reducei +operator tablicy binarnej do konwersji wynikowej tablicy dwuwymiarowej na tablicę jednowymiarową przy jednoczesnym zachowaniu kluczy:

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;
    }, []);
}

Stosowanie

Oba te warianty zostałyby wykorzystane w ten sposób:

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

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

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

Uwaga =>zamiast ,w $func.

Dane wyjściowe są takie same jak poprzednio i każdy może być częściowo zastosowany w taki sam sposób jak poprzednio.


 Podsumowanie

Pierwotne pytanie ma na celu uproszczenie wywołania wywołania kosztem posiadania bardziej skomplikowanej funkcji, która zostanie wywołana; szczególnie, aby mieć możliwość przekazania tablicy danych jako jednego argumentu, bez dzielenia kluczy i wartości. Korzystanie z funkcji dostarczonej na początku tej odpowiedzi:

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

Lub, tylko dla tego pytania, możemy uprościć array_map_assoc()funkcję, która upuszcza klucze wyjściowe, ponieważ pytanie nie wymaga ich:

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

Tak więc odpowiedź brzmi NIE , nie można uniknąć dzwonienia array_keys, ale można wykreślić miejsce, w którym array_keyswywoływana jest funkcja wyższego rzędu, co może być wystarczająco dobre.


7
Wydaje się, że to powinno być oznaczone jako poprawna odpowiedź.
eddiewould

6
Dzięki @eddiewould, ale jestem o 4½ lat za późno :) Przyjechałem tutaj, szukając rozwiązania, nie znalazłem żadnego, który mi się podoba, więc wymyśliłem własny.
Nicholas Shanks,

1
Będę tym facetem. PHP 5.3 nie powinno już być wymaganiem dla daty tej odpowiedzi. MOIM ZDANIEM.
Erutan409

1
Twoje pierwsze alternatywne rozwiązanie jest nieprawidłowe. musisz zastąpić array_mergeprzez, array_replaceaby zachować klucze, które byłyby liczbami całkowitymi.
Alex83690,

1
@ Alex83690 Dzięki! Chociaż powiedziałbym, że „nieprawidłowy” jest nieco mylący - w porządku, jeśli nie masz żadnych kluczy całkowitych (jak było w moim przypadku).
Nicholas Shanks

20

W wersji PHP 5.3 lub nowszej:

$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
Myślę, że wymaganiem było „zamiast wywoływać klucze tablic i wartości tablic, bezpośrednio przekazując zmienną $ test_array”, czy można tego użyć bez kluczy tablic?
eis

4

Tak zaimplementowałem to w moim projekcie.

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

Bardzo czysty i nie zmienia oryginalnej tablicy!
Raffaele Candeliere

4

Popatrz tutaj! Istnieje trywialne rozwiązanie!

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

Jak stwierdzono w pytaniu, array_map ma już dokładnie wymaganą funkcjonalność . Inne odpowiedzi tutaj poważnie komplikują: array_walknie działa.

Stosowanie

Dokładnie tak, jak można oczekiwać po swoim przykładzie:

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

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

inne odpowiedzi komplikują sprawy, ponieważ podane pytanie qrrqy_keys()nie powinno być używane przez #reasons
Brad Kent,

2

Przez „ręczną pętlę” miałem na myśli napisanie niestandardowej funkcji, która używa foreach. Zwraca to nową tablicę, podobnie jak array_maprobi, ponieważ zasięg funkcji powoduje, $arrayże jest to kopia, a nie odwołanie:

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

Twoja technika używania array_mapz array_keyschociaż wydaje się być prostsza i bardziej wydajna, ponieważ możesz użyć nulljako wywołania zwrotnego, aby zwrócić pary klucz-wartość:

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

zapętlanie tablicy z referencją może powodować upiorne rzeczy
janenz00,

To nie jest straszne, to po prostu oznacza, że ​​zapomniałeś, unset( $value )ponieważ wciąż istnieje w zdefiniowanym zakresie.
aziz punjani

@azis, żartował z powodu upiorności, odnosząc się do artykułu. Stworzy nieoczekiwane efekty, jeśli zapomnisz rozbroić.
janenz00

1
Dzięki za odpowiedź, ale pomyślałem, że było całkiem jasne, że nie chcę używać tradycyjnej pętli.
José Tomás Tocino

@ janenz00 Zobacz edytowaną odpowiedź dla wyjaśnienia. Miałem na myśli zapętlenie w czystym zmiennym zakresie.
ryanve

1

W oparciu o odpowiedź eis , oto co ostatecznie zrobiłem, aby uniknąć bałaganu w oryginalnej tablicy:

$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
Dlaczego jest to łatwiejsze niż przekazywanie wartości tablicy i kluczy bezpośrednio do array_map? Jest wolniejszy i bardziej skomplikowany, nie widzę przewagi.
Ariel

1
@Ariel, czy możesz poprzeć twierdzenie, że byłoby wolniejsze, nawet przy dużych liczbach? Musi iterować tablicę tylko raz, więc myślę, że powinna być o wielkości szybsza w dużej notacji O. Zgadzam się jednak co do złożoności.
eis

@eis Jest wolniejszy, ponieważ tworzy tablicę wyników pojedynczo w PHP, zamiast masowo w C. Unika jednak wywołania array_keys (chociaż jest to szybkie, ponieważ jest w C). Benchmark to - zobacz, który jest szybszy, nie jestem do końca pewien, ale zwykle więcej kodu = wolniejszy kod. Złożoność jest jednak zdecydowanie gorsza i jest to ważniejsze niż prędkość przez większość czasu.
Ariel,

1
Nie musisz wysyłać trzeciego argumentu, array_walkponieważ nie odwołujesz się do niego w zamknięciu.
Steven Lu

1

Zrobiłem tę funkcję na podstawie odpowiedzi 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;
}

Przykład:

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

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

Wynik:

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

Oczywiście możesz użyć, array_valuesaby zwrócić dokładnie to, czego chce OP.

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

@KevinBeal Bardzo często używam tej funkcji w swojej pracy. Czy możesz wskazać, gdzie są błędy?
Julio Vedovatto

2
Po pierwsze, w obecnym kodzie brakuje czeku $arrtypu tablica typów, jednak jeśli wpiszesz podpowiedzi jako callablei arraymożesz zamiast tego upuścić czek do is_callable. Następnie tworzysz przypisanie do wartości $, która jest następnie nieużywana. Powinieneś po prostu zignorować wartość zwracaną. Po trzecie, lepiej byłoby zgłosić wyjątek w wywołaniu zwrotnym niż zwrócić wartość false. Wówczas albo zawsze zwracałby prawidłową wartość, albo zawsze rzucał.
Nicholas Shanks

1

Biblioteka YaLinqo * dobrze nadaje się do tego rodzaju zadań. Jest to port LINQ z .NET, który w pełni obsługuje wartości i klucze we wszystkich wywołaniach zwrotnych i przypomina SQL. Na przykład:

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

Lub tylko:

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

Oto '"$k loves $v"'skrót do składni pełnego zamknięcia obsługiwanej przez tę bibliotekę. toArray()w końcu jest opcjonalny. Łańcuch metod zwraca iterator, więc jeśli wynik wymaga tylko iteracji za pomocą foreach, toArraywywołanie można usunąć.

* opracowane przeze mnie


1

Zrobiłbym coś takiego:

<?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",
)));

?>

Wyniki:

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

1

Dodam jeszcze jedno rozwiązanie problemu przy użyciu wersji 5.6 lub nowszej. Nie wiem, czy jest bardziej wydajny niż i tak już świetne rozwiązania (prawdopodobnie nie), ale dla mnie jest po prostu łatwiej czytać:

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

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

Używając strval()jako przykładowej funkcji w array_map, wygeneruje:

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

Mam nadzieję, że nie tylko ja uważam to za dość proste. array_combinetworzy key => valuetablicę z tablicy kluczy i tablicy wartości, reszta jest dość oczywista.


1

Możesz użyć metody mapowania z tej biblioteki tablic, aby osiągnąć dokładnie to, czego chcesz tak łatwo, jak:

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

zachowuje również klucze i zwraca nową tablicę, nie wspominając o kilku różnych trybach, które pasują do twoich potrzeb.


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

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

Źródło


0

Zawsze lubię javascriptowy wariant mapy tablic. Najprostsza wersja to:

/**
 * @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;
}

Teraz możesz przekazać funkcję wywołania zwrotnego, jak skonstruować wartości.

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

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

Jest bardziej przydatne dane jako ostatni argument do dowolnej funkcji piszesz, jak można następnie utworzyć nową funkcję, która piecze-w jakimś konkretnym zwrotnego (zachowania) - tzn masz złożenie funkcji: h(g(f($data)))zastosowanie f, a następnie g, po czym hdo listy dane. Generalnie uważa się za bardziej uniwersalne w programowaniu funkcjonalnym posiadanie funkcji, która wykonuje tę samą operację na danych nurków, niż funkcja, która stosuje funkcje nurków do ustalonego zestawu danych.
Nicholas Shanks

W twoim przykładzie masz tylko 1 argument do funkcji. Uważam, że łatwiej jest umieścić dane jako pierwszy argument, np. Array_filter, array_reduce i funkcje tablicowe w javascript.
blablabla

To mój punkt! Przekazywanie danych na końcu pozwala na curry funkcji (utworzenie nowej funkcji, która łączy zapętlenie z określoną operacją) i zastosowanie jej do danych poprzez wywołanie nowej funkcji za pomocą jednego parametru. Ta zasada została wyjaśniona lepiej niż ja tutaj, w tej odpowiedzi: stackoverflow.com/a/5863222
Nicholas Shanks

Czy używanie funkcji tworzenia w języku takim jak PHP nie jest lepszym rozwiązaniem tego problemu?
blablabla

1
Jest to alternatywa, ale wymaga znacznie większych inwestycji w FP, na przykład: github.com/nickshanks/fp-php-talk/blob/master/lib.php#L24 lub to: github.com/nickshanks/php-fp/blob /master/src/fp.php#L62
Nicholas Shanks

0

Inny sposób na zrobienie tego z (poza) zachowaniem kluczy:

$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

Widzę, że brakuje oczywistej odpowiedzi:

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;
}

Działa dokładnie tak, jak array_map. Prawie.

W rzeczywistości nie jest tak czysty, mapjak znasz go z innych języków. Php jest bardzo dziwny, dlatego wymaga bardzo dziwnych funkcji użytkownika, ponieważ nie chcemy zerwać z naszym dokładnie zepsutym worse is betterpodejściem.

Naprawdę wcale tak nie jest map. Jednak nadal jest bardzo przydatny.

  • Pierwszą oczywistą różnicą od array_map jest to, że callback pobiera dane wyjściowe each()z każdej tablicy wejściowej zamiast samej wartości. Nadal możesz iterować więcej tablic jednocześnie.

  • Druga różnica polega na sposobie obsługi klucza po jego zwróceniu z wywołania zwrotnego; wartość zwracana z funkcji zwrotnej powinna wynosić array('new_key', 'new_value'). Klucze można i będą zmieniane, te same klucze mogą nawet spowodować zastąpienie poprzedniej wartości, jeśli ten sam klucz został zwrócony. To nie jest powszechne mapzachowanie, ale pozwala przepisać klucze.

  • Trzecią dziwną rzeczą jest to, że jeśli pominiesz keywartość zwracaną (przez array(1 => 'value')lub array(null, 'value')), zostanie przypisany nowy klucz, tak jakby $array[] = $valuezostał użyty. To też nie mapjest powszechne zachowanie, ale wydaje mi się, że czasem przydaje się.

  • Czwarta dziwna rzecz: jeśli funkcja zwrotna nie zwraca wartości lub zwraca null, cały zestaw bieżących kluczy i wartości jest pomijany na wyjściu, jest po prostu pomijany. Ta funkcja jest całkowicie mapniedostępna, ale sprawiłaby, że ta funkcja byłaby doskonała dla kaskaderów array_filter_assoc, gdyby była taka funkcja.

  • Jeśli pominiesz drugi element ( 1 => ...) ( część wartości ) w zwrocie wywołania zwrotnego, nullzostanie użyty zamiast wartości rzeczywistej.

  • Wszelkie inne elementy oprócz tych z kluczami 0i 1po oddzwonieniu są ignorowane.

  • I na koniec, jeśli lambda zwraca dowolną wartość oprócz nulllub tablicę, jest to traktowane tak, jakby pominięto zarówno klucz, jak i wartość, więc:

    1. przypisano nowy klucz dla elementu
    2. null jest używany jako jego wartość
OSTRZEŻENIE:
Pamiętaj, że ta ostatnia funkcja jest jedynie pozostałością po poprzednich funkcjach i prawdopodobnie jest całkowicie bezużyteczna. Poleganie na tej funkcji jest wysoce odradzane, ponieważ ta funkcja będzie losowo przestarzała i niespodziewanie zmieniana w przyszłych wydaniach.

UWAGA:
W przeciwieństwie do in array_map, wszystkie parametry niebędące array_map_assocmacierzami, z wyjątkiem pierwszego parametru wywołania zwrotnego, są dyskretnie rzutowane na tablice.

PRZYKŁADY:
// TODO: examples, anyone?

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.