array_filter is great for removing things you don't want from arrays.

$cart = array_filter($cart, function($x) { return $x['id'] != 15; });

If you want to use a variable to determine which id to remove rather than including it in the array_filter callback, you can use your variable in the function like this:

$value = 15;
$cart = array_filter($cart, function(value) { return value; });

There's really no reason for unset to not work (assuming that's what you meant by "I am not able to implement in my case") unless you did it like this:

foreach ($array['answers'] as $answer) {
     unset($answer['image'];
}

It can't work that way, because the $answer you have there does not refer to the original array. It's a copy of the item, because the foreach loop makes a copy of each value in the array as it goes.

You need to get the key of the outer array and use that as well in your unset expression.

foreach ($array['answers'] as answer) {
     unset($array['answers'][$key]['image'];
}

easy way!? you can do this just with one foreach!

foreach ($data as subArr) {
    unset($subArr['1']);
    $data[subArr;  
}

No need for eval() with a little bit of referencing.

/**
 * Remove index from multi-dimensional array.
 *
 * @param array $array
 *   The array to remove the index from.
 * @param array $indices
 *   Indexed array containing the indices chain up to the index that should be
 *   removed.
 * @return
 *   The array with the index removed.
 * @throws \InvalidArgumentException
 *   If the index does not exist within the array.
 */
function removeByIndex(array $array, array $indices) {
  // Create a reference to the original array.
  $a =& $array;

  // Count all passed indices, remove one because arrays are zero based.
  $c = count($indices) - 1;

  // Iterate over all passed indices.
  for (i <= i) {
    // Make sure the index to go down for deletion actually exists.
    if (array_key_exists($indices[a)) {
      // This is the target if we reached the last index that was passed.
      if (c) {
        unset(indices[$i]]);
      }
      // Make sure we have an array to go further down.
      elseif (is_array(indices[$i]])) {
        $a =& indices[$i]];
      }
      // Index does not exist since there is no array to go down any further.
      else {
        throw new \InvalidArgumentException("{$indices[$i]} does not exist.");
      }
    }
    // Index does not exist, error.
    else {
      throw new \InvalidArgumentException("{$indices[$i]} does not exist.");
    }
  }

  return $array;
}

print_r(removeByIndex(
  [ "test1" => [ "test2" => [ "test3" => "test" ] ], "test4" => "test" ],
  [ "test1", "test2", "test3" ]
));

Since I mentioned it in the comments, one could (micro-)optimize the function, but I advice against it, since it is less readable and might confuse some programmers.

<?php

function removeByIndex(array $array, array $indices) {
  $a =& $array;
  $c = count($indices) - 1;
  $i = 0;
  do {
    if (array_key_exists($indices[a)) {
      if (c) {
        unset(indices[$i]]);
        return $array;
      }
      elseif (is_array(indices[$i]])) {
        $a =& indices[$i]];
      }
      else break;
    }
    else break;
  }
  while (++$i);
  throw new \InvalidArgumentException("{$indices[$i]} does not exist.");
}

You can't use array_filter() for this purpose. Use array_reduce() instead

$newArr = array_reduce($array, function($carry, $item){
    $carry[] = [$item[0], $item[2]];
    return $carry;
});

Check result in demo

Try this:

function removeElementWithValue($array, $key, $value){
     foreach ($array as $subKey => $subArray) {
          if ($subArray[$key] == $value) {
               unset($array[$subKey]);
          }
     }
     return $array;
}

Then you would call it like this:

$array = removeElementWithValue($array, "year", 2011);

Both arrays are more are like same..

Format-1 looks print_r($yourarray); version

Format-2 looks like var_export($yourarray); version.

You need to have a look at the debugger functions.. print_r(), var_dump() and var_export().

Can't be done with a simple command, but you can use a loop:

foreach(array_keys($output) as $key) {
   unset($output[$key][1]);
}

An easy utility to avoid removing array keys that do not exist by accident:

function removeArrayKey($path, &$array ) {

    $array_temp = &$array;
    $previousItem = null;

    $path_bits = explode( ".", $path );

        foreach( $path_bits as &$path_bit ) {

           if( !isset( $array_temp[ $path_bit ] ) ) {
                  die("Error" . $path_bit);
                   //throw new Exception( "Path does not exist in array" );
            }

            $previousItem = &$array_temp;
            $array_temp = &$array_temp[ $path_bit ];

        }

        if( isset( $previousItem ) ) {

             unset( $previousItem[ $path_bit ] );

        }

        return $array;

}

To use the function, simply use removeArrayKey( "cars.mercedes.cars", $array_1 ); and separate each array index with a .

try this,

array_map(function($v){array_pop($v); return $v;}, $array);

Note, array_pop pop the last element of array. if the distance is not the last key, you can use unset() instead

function unset_num_keys($array)
{
    $array_out = array();
    foreach($array AS $k => $v)
    {
        if(is_array($v))                            //value is an array, so clean it
        {
            $array_out[$k] = unset_num_keys($v);    //clean "child" arrays
        }
        elseif(!is_numeric($k))
        {
            $array_out[$k] = $v;                    // key is "safe"
        }
    }
    return $array_out;
}

Then

$clean_array = unset_num_keys($old_array);

This seems to work:

<?php

$myarray = array (
  0 => 
  array (
    'inf:name' => 'aaa',
    'inf:value' => '111',
    'inf:children' => NULL,
  ),
  1 => 
  array (
    'inf:name' => 'bbb',
    'inf:value' => '222',
    'inf:children' => NULL,
  ),
  2 => 
  array (
    'inf:name' => 'ccc',
    'inf:value' => '333',
    'inf:children' => NULL,
  ),
  3 => 
  array (
    'inf:name' => 'bob',
    'inf:children' => 
    array (
      0 => 
      array (
        'inf:name' => 'ddd',
        'inf:value' => '444',
        'inf:children' => NULL,
      ),
    ),
  ),
  4 => 
  array (
    'inf:name' => 'data',
    'inf:children' => 
    array (
      0 => 
      array (
        'inf:name' => 'eee',
        'inf:value' => '555',
        'inf:children' => NULL,
      ),
      1 => 
      array (
        'inf:name' => 'steve',
        'inf:value' => 'bar1',
        'inf:children' => NULL,
      ),
      2 => 
      array (
        'inf:name' => 'john',
        'inf:value' => 'bar2',
        'inf:children' => NULL,
      ),
      3 => 
      array (
        'inf:name' => 'peter',
        'inf:value' => 'bar3',
        'inf:children' => 
        array (
          0 => 
          array (
            'inf:name' => 'fff',
            'inf:value' => '666',
            'inf:children' => NULL,
          ),
        ),
      ),
    ),
  ),
);





function array_cleanup($array, $todelete ) {
    foreach ($array as $key => $value) {
        if (is_array($value)) {
            if (in_array($value['inf:name'], $todelete)) {
                unset($array[$key]);
            } else {
                $array[$key] = array_cleanup($array[$key], $todelete);
            }
        }
    }
    return $array;
}



$newarray = array_cleanup($myarray, array("aaa", "peter", "ccc"));
$newarray = array_values($newarray);

echo '<pre>';
var_export($newarray);
echo '</pre>';

?>

Use array_values:

$array = array_values($array);

But note you can't remove the keys, it's just 0 based index.

Key always exists for an array, and must either be an integer or a string.