Retrieve multiple array values with extract

One way (if you only want to keep a few results):

Hash::merge(
    Hash::extract($array, '{n}.index1'),
    Hash::extract($array, '{n}.index2')
);

Another way (if you only want to remove a few):

Hash::remove($array, '{n}.index3');

Have you tried Set::extract($array, '{n}.{s}'); ?

EDIT: If your array dimension is exactly like the one in your answer, you could try array_keys(Set::extract($array, '{n}.{s}'));

I am not sure why you want to stick with the Set class ? If it doesn't suit your need, why would you absolutely use it and not create your own function ? You say in one of your comments that you want to avoid foreach loops. But the Set class methods are full of foreach loops themselve. I may miss the point...

Personnaly I would do it simply with a function like this one:

function filter_fields($array_to_filter, $fields_to_keep)
{
    foreach($array_to_filter as $i => $sub_array)
    {
        foreach($sub_array as $field => $value)
        {
            if(!in_array($field, $fields_to_keep))
            {
                unset($array_to_filter[$i][$field]);
            }
        }
    }

    return $array_to_filter;
}

Here is an example of what it would return:

print_r($array_to_filter);
/*
Array
(
    [0] => Array
        (
            [index1] => abc
            [index2] => def
            [index3] => ghi
        )

    [1] => Array
        (
            [index1] => jkl
            [index2] => mno
            [index3] => poq
        )
)
*/

$filtered_array = filter_fields($array_to_filter, array('index1', 'index3'));

print_r($filtered_array);
/*
Array
(
    [0] => Array
        (
            [index1] => abc
            [index3] => ghi
        )

    [1] => Array
        (
            [index1] => jkl
            [index3] => poq
        )
)
*/

Set is AWESOME! You can't do this directly with Set::extract, but you CAN build an associative array of the the two array indexes using Set::combine:

Set::combine($myArray, '{n}.index1', '{n}.index2')

A working example looks like this:

$myArray = array(
    array('index1'=>'something 1', 'index2'=>'something else 1', 'index3'=>'something more 1'),
    array('index1'=>'something 2', 'index2'=>'something else 2', 'index3'=>'something more 2'),
    array('index1'=>'something 3', 'index2'=>'something else 3', 'index3'=>'something more 3'),
);

debug(Set::combine($myArray, '{n}.index1', '{n}.index2'));

This will take an array like you mentioned:

array(
[0]=>
    [index1]=>something 1
    [index2]=>something else 1
    [index3]=>something more 1
[1]=>
    [index1]=>something 2
    [index2]=>something else 2
    [index3]=>something more 2
[2]=>
    [index1]=>something 3
    [index2]=>something else 3
    [index3]=>something more 3

)

and turn it into this:

Array (
    [something1] => something else 1
    [something2] => something else 2
    [something3] => something else 3
)

[ +10 ] Big thumbs up for revealing the classicExtract method to me in this post.

Example array:

$params = array(
  'key-1'=>array('subkey'=>array('x'), 'junk'), 
  'key-2'=>array('subkey'=>array('y'), 'otherkey'=>'more junk')
);

The problem i had:

The base key gets converted to int.

 eg. array(0=>array('x'), 1=>array('y'))

Solution:

$array = Hash::filter(Set::classicExtract($params, '{[a-zA-Z0-9-_.]}.subkey'));

returns:

eg. array('key-1'=>array('x'), 'key-2'=>array('y'))

Modify regex in key as needed.

Just wrote this function

It will give the ability to parse array by using {a) instead of {s}

{a} for associative key for base.

called like so: static::extract($array, '{a}.subkey');

  public static function extract($array, $path, $filter=true){
    $path = str_replace("{a}", "{[a-zA-Z0-9-_.]}", $path);
    if(is_array($array)){
      $return = Set::classicExtract($array, $path);
      if($filter){
        if(is_array($return)){
          $return = Hash::filter($return);
        }
      }
      return $return;
    }
  }

[[ UPDATE FOR CAKE 3 ]]

If you were using this function I see cakephp just removed the set class. You can get it to work again by adding the classicExtract method to you class

use Cake\Utility\Hash;

public static function classicExtract($data, $path = null)
{
    if (empty($path)) {
        return $data;
    }
    if (is_object($data)) {
        if (!($data instanceof \ArrayAccess || $data instanceof \Traversable)) {
            $data = get_object_vars($data);
        }
    }
    if (empty($data)) {
        return null;
    }
    if (is_string($path) && strpos($path, '{') !== false) {
        $path = \Cake\Utility\String::tokenize($path, '.', '{', '}');
    } elseif (is_string($path)) {
        $path = explode('.', $path);
    }
    $tmp = array();

    if (empty($path)) {
        return null;
    }

    foreach($path as $i => $key) {
        if (is_numeric($key) && intval($key) > 0 || $key === '0') {
            if (isset($data[$key])) {
                $data = $data[$key];
            } else {
                return null;
            }
        } elseif ($key === '{n}') {
            foreach($data as $j => $val) {
                if (is_int($j)) {
                    $tmpPath = array_slice($path, $i + 1);
                    if (empty($tmpPath)) {
                        $tmp[] = $val;
                    } else {
                        $tmp[] = static::classicExtract($val, $tmpPath);
                    }
                }
            }
            return $tmp;
        } elseif ($key === '{s}') {
            foreach($data as $j => $val) {
                if (is_string($j)) {
                    $tmpPath = array_slice($path, $i + 1);
                    if (empty($tmpPath)) {
                        $tmp[] = $val;
                    } else {
                        $tmp[] = static::classicExtract($val, $tmpPath);
                    }
                }
            }
            return $tmp;
        } elseif (strpos($key, '{') !== false && strpos($key, '}') !== false) {
            $pattern = substr($key, 1, -1);

            foreach($data as $j => $val) {
                if (preg_match('/^'.$pattern.'/s', $j) !== 0) {
                    $tmpPath = array_slice($path, $i + 1);
                    if (empty($tmpPath)) {
                        $tmp[$j] = $val;
                    } else {
                        $tmp[$j] = static::classicExtract($val, $tmpPath);
                    }
                }
            }
            return $tmp;
        } else {
            if (isset($data[$key])) {
                $data = $data[$key];
            } else {
                return null;
            }
        }
    }
    return $data;
}

//CAKEPHP METHODS
public static function extract($array, $path, $filter = true)
{
    $return = [];
    if (is_array($array)) {
        if (stristr($path, '{a}')) {
            $return = static::classicExtract($array, str_replace("{a}", "{[a-zA-Z0-9-_. ]}", $path));
        } else {
            $return = Hash::extract($array, $path);
        }
    }
    if ($filter && is_array($return)) {
        $return = Hash::filter($return);
    }
    return $return;
}