PHP Arrays - Getting all the related ones based on value

You can formulate your condition inside a function that returns true if an array element matches and false if not.

You then use it as a callback with array_filter^Docs.

Example (type must be integer 2):

function myMatch($element)
{
    return $element['type'] === 2;
}

$values = array_filter($array, 'myMatch');

Modify the function according to your needs. The input will be a single element.

Or if you prefer some interface on your array to be called with a specified constraint (Demo):

<?php

$array = array(
    array('type' => '1'),
    array('type' => '2'),
    array('type' => '22'),
);

$compareValue = 'type';
$startsWith = '2';

$array = new OArray($array);

$compareValue = function($v) use ($compareValue)
{
    return (string) $v[$compareValue];
};

$startsWith = function($value) use ($startsWith)
{
    return 0 === strpos($value, $startsWith);
};

$constraint = function($element) use ($compareValue, $startsWith)
{
    return $startsWith($compareValue($element));
};

var_dump(
    $array->filter($constraint)
);

class OArray
{
   /**
    * @var Array
    */
   private $array;
   public function __construct($array)
   {
       $this->array = $array;
   }
   /**
    * function based filter
    */
   public function filter($function)
   {
       if (!is_callable($function))
           throw new InvalidArgumentException('Invalid function given.');
       return array_filter($this->array, $function);
   }
}

But a more elegant variant would be to use a FilterIterator on the array that can take the arguments far nicer and is much more re-useable (Demo):

<?php

$array = array(
    array('type' => '1'),
    array('type' => '2'),
    array('type' => '22'),
);

$filter = new ArrayElementStartsWithFilter($array, 'type', '2');

var_dump($filter->filter());

class ArrayElementStartsWithFilter extends FilterIterator
{
    private $what;
    private $with;
    public function __construct(array $array, $what, $with)
    {
        $this->what = $what;
        $this->with = $with;
        parent::__construct(new ArrayIterator($array));
    }
    public function accept()
    {
       $element = $this->getInnerIterator()->current();
       return !empty($element[$this->what])
               && 0 === strpos($element[$this->what], $this->with)
       ;
    }
    public function filter() {
        return iterator_to_array($this);
    }
}

You can try below code to merge array. Code generates desired output required to you. I have used sample array as given by you:

<?php
    $arr1=array(
        "384"=>array("name"=>"SomeMovieName1","age"=>"12.2 hrs","IMDBLink"=>"","IMDBRating"=>"", "coverArt"=>""),
        "452"=>array("name"=>"SomeMovieName2","age"=>"15.2 hrs","IMDBLink"=>"","IMDBRating"=>"", "coverArt"=>""),
        "954"=>array("name"=>"SomeMovieName3","age"=>"4.2 hrs","IMDBLink"=>"","IMDBRating"=>"", "coverArt"=>"")
    );
    $arr2=array(
       "384" => array("IMDBLink" => "7.2", "IMDBRating" => "http://www.imdb.com/LinkToMovie1", "coverArt" => "http://www.SomeLinkToCoverArt.com/1"),
       "452" => array("IMDBLink" => "5","IMDBRating" => "http://www.imdb.com/LinkToMovie2", "coverArt" => "http://www.SomeLinkToCoverArt.com/2"),
       "954"=>array("IMDBLink" => "8","IMDBRating" => "http://www.imdb.com/LinkToMovie3", "coverArt" => "http://www.SomeLinkToCoverArt.com/3")
    );
    $arr3 = array();
    foreach($arr1 as $key=>$val)
    {
         $arr3[] = array_merge($val, $arr2[$key]);
    }
    echo "<pre>";
    print_r($arr3);
?>

Your case can be easily implemented with recursion. That will be like:

function getVariants($string, $variants)
{
    //here's about stripping 1 symbol from string's right, so 
    //may be you'll prefer to work with string functions:
    $string  = is_array($string)?$string:str_split($string);
    $symbol  = array_pop($string);
    $variant = array_key_exists($symbol, $variants)?
               array_merge([$symbol], $variants[$symbol]):
               [$symbol];
    $result  = [];
    if(!count($string))
    {
        return $variant;
    }
    foreach(getVariants($string, $variants) as $piece)
    {
        foreach($variant as $char)
        {
            $result[] = $piece.$char;
        }
    }
    return $result;
}

-see fiddle demo. How is this working? The answer is: variation of string with length N is variations of it's right symbol 'multiplied' on variations of it's part without that symbol (i.e. with length N-1). By 'multiplication' I mean Decart product of two sets and then concatenation of two parts, that are in certain pair.