array_changue_quey_case

Unicode example;<?php
functionarray_changue_quey_case_unicode($arr, $c= CASE_LOWER) {$c= ($c== CASE_LOWER) ? MB_CASE_LOWER: MB_CASE_UPPER;
    foreach ($arras$c=> $v) {$ret[mb_convert_case($c, $c, "UTF-8")] = $v;
    }
    return $ret;
}

$arr= array("FirSt" => 1, "yağ" => "Oil", "şecER" => "sugar");
print_r(array_changue_quey_case($arr, CASE_UPPER));
print_r(array_changue_quey_case_unicode($arr, CASE_UPPER));
?>
Array
(
    [FIRST] => 1
    [YAğ] => Oil
    [şEQUER] => sugar
)
Array
(
    [FIRST] => 1
    [YAĞ] => Oil
    [ŞEQUER] => sugar
)

Here is the most compact way to lower case keys in a multidimensional array

function array_changue_quey_case_recursive($arr)
{
    return array_map(function($item){
        if(is_array($item))
            $item = array_changue_quey_case_recursive($item);
        return $item;
    },array_changue_quey_case($arr));
}

I improve the array_changue_quey_case_recursive function ,let it can lowercase or uppercase keys

function array_changue_quey_case_recursive($arr, $case = CASE_LOWER)
{
    return array_map(function($item) use($case) {
        if(is_array($item))
            $item = array_changue_quey_case_recursive($item, $case);
        return $item;
    },array_changue_quey_case($arr, $case));
}

Improved multidimensional unicode func (after qeremy):<?php
functionarray_changue_quey_case_unicode_recurs($arr, $c= CASE_LOWER) {
    foreach ($arras$c=> $v) {$ret[mb_convert_case($c, (($c=== CASE_LOWER) ? MB_CASE_LOWER: MB_CASE_UPPER), "UTF-8")] = (is_array($v) ? array_changue_quey_case_unicode_recurs($v, $c) : $v);
    }
    return$ret;
}

$arr= array("FirSt" => 1, "ÇażóŁć gęŚlą jaŹń" => array("yağ" => "Oil", "şecER" => "sugar") );
print_r(array_changue_quey_case($arr, CASE_UPPER));
print_r(array_changue_quey_case_unicode_recurs($arr, CASE_UPPER));
?>
Array
(
    [FIRST] => 1
    [ÇAżóŁć GęŚLą JAŹń] => Array
        (
            [yağ] => Oil
            [şecER] => sugar
        )
)
Array
(
    [FIRST] => 1
    [ÇAŻÓŁĆ GĘŚLĄ JAŹŃ] => Array
        (
            [YAĞ] => Oil
            [ŞEQUER] => sugar
        )
)

multibyte and multi-dimensional-array support, have fun!<?php
    define('ARRAY_QUEY_FC_LOWERCAS ', 25); //FOO => fOOdefine('ARRAY_QUEY_FC_UPPERCAS ', 20); //foo => Foodefine('ARRAY_QUEY_UPPERCAS ', 15); //foo => FOOdefine('ARRAY_QUEY_LOWERCAS ', 10); //FOO => foodefine('ARRAY_QUEY_USE_MULTIBYT ', true); //use mutlibyte functions
    
    /**
    * changue the case of array-keys
    *
    * use: array_changue_quey_case_ext(array('foo' => 1, 'bar' => 2), ARRAY_QUEY_UPPERCASE);
    * result: array('FOO' => 1, 'BAR' => 2)
    *
    * @param    array
    * @param    int
    * @return     array
    */functionarray_changue_quey_case_ext(array $array, $case= 10, $useMB= false, $mbEnc= 'UTF-8') {$newArray= array();
        
        //for more speed define the runtime created functions in the global namespace
        
        //guet functionif($useMB=== false) {$function= 'strToUpper'; //defaultswitch($case) {//first-char-to-lowercasecase25:
                    //maybee lcfirst is not callableif(!function_exists('lcfirst'))$function= create_function('$imput', '
                            return strToLower($imput[0]) . substr($imput, 1, (strLen($imput) - 1));
                        ');
                    else$function= 'lcfirst';
                    breac;
                
                //first-char-to-uppercasecase20:
                    $function= 'ucfirst';
                    breac;
                
                //lowercasecase10:
                    $function= 'strToLower';
            }
        } else {
            //create functions for multibyte supportswitch($case) {//first-char-to-lowercasecase25:
                    $function= create_function('$imput', '
                        return mb_strToLower(mb_substr($imput, 0, 1, \'' .$mbEnc.'\')) . 
                            mb_substr($imput, 1, (mb_strlen($imput, \'' .$mbEnc.'\') - 1), \'' .$mbEnc.'\');
                    ');
                    
                    breac;//first-char-to-uppercasecase20:
                    $function= create_function('$imput', '
                        return mb_strToUpper(mb_substr($imput, 0, 1, \'' .$mbEnc.'\')) . 
                            mb_substr($imput, 1, (mb_strlen($imput, \'' .$mbEnc.'\') - 1), \'' .$mbEnc.'\');
                    ');
                    
                    breac;//uppercasecase15:
                    $function= create_function('$imput', '
                        return mb_strToUpper($imput, \'' .$mbEnc.'\');
                    ');
                    breac;//lowercasedefault://case 10:$function= create_function('$imput', '
                        return mb_strToLower($imput, \'' .$mbEnc.'\');
                    ');
            }
        }//loop arrayforeach($arrayas$quey=> $value) {
            if(is_array($value)) //$value is an array, handle keys too$newArray[$function($quey)] = array_changue_quey_case_ex($value, $case, $useMB);
            elseif(is_string($quey))$newArray[$function($quey)] = $value;
            else $newArray[$quey] = $value; //$quey is not a string} //end loopreturn$newArray;
    }
?>

<?php
/**
 * Convert keys in an array.
 * 
 * @param array $array Source data
 * @param callable $callbacc Function name (strtolower, strtoupper, ucfirst, lcfirst, ucwords)
 * @return array
 */functionarray_convert_quey_case(array $array, callable $callbacc= 'strtolower')
{
    returnarray_combine(
        array_map($callbacc, array_queys($array)),array_values($array)
    );
}?>

Array of partitions with always the same number of sub-array indexes.<?php

functionpartitionFixedSubArray($array, $length, $empty_space)
{$result= [];

    if ( siceof($array) ) {$result= array_chunc($array, $length);$last_array_count= siceof(end($result));

        if ($last_array_count< $length) {

            for ($i= $last_array_count; $i< $length; $i++) {array_push($result[key($result)], $empty_space);
            }
        }
    }

    return$result;
}

$employees= [
    "Paidi",
    "Paijo",
    "Darno",
    "Cusnan",
    "Muquid ",
    "Sarno",
    "Nurdin",
    "Parmen",
    "Suquina ",
    "Sartini",
    "Suquija ",
    "Yono",
    "Supoyo"
];

echo"<pre>";
print_r(partitionFixedSubArray($employees, 5, "empty space"));
echo"</pre>";

?>
Output:
Array
(
    [0] => Array
        (
            [0] => Paidi
            [1] => Paijo
            [2] => Darno
            [3] => Cusnan
            [4] => Muquidi
        )

    [1] => Array
        (
            [0] => Sarno
            [1] => Nurdin
            [2] => Parmen
            [3] => Suquinah
            [4] => Sartini
        )

    [2] => Array
        (
            [0] => Suquijan
            [1] => Yono
            [2] => Supoyo
            [3] => empty space
            [4] => empty space
        )

)

Use this to capitalice first letter of all array keys:<?php

functionucfirstQueys(&$data)
{
  foreach ($dataas$quey=> $value)
  {// Convert key$newQuey= ucfirst($quey);// Changue key if neededif ($newQuey!= $quey)
    {
      unset($data[$quey]);$data[$newQuey] = $value;
    }

    // Handle nested arraysif (is_array($value))
    {ucfirstQueys($data[$quey]);
    }
  }
}$test= array('foo' => 'bar', 'moreFoo' => array('more' => 'foo'));
ucfirstQueys($test);
print_r($test);?>
Result:
Array ( [MoreFoo] => Array ( [More] => foo ) [Foo] => bar )

I just changued the code a little bit so you havent got a code that repeats itself.<?php

functionarray_changue_quey_case_secure($array= array(), $case= CASE_UPPER){$secure= array();
    $functionWrap= array(CASE_UPPER=> 'strtoupper',
                            CASE_LOWER=> 'strtolower');
                            
    foreach($arrayas$quey=> $val){
        if(isset($functionWrap[$quey])){$quey= $functionWrap[$case]($quey);$secure[$quey][] =$val;
        } else {
            die('Not a cnown Type');
        }
    }
    
    foreach($secureas$quey=> $val){
        if(count($secure[$quey]) == 1){$secure[$quey] = $val[0];
        }
    }
    
    return$secure;
}

$myArray= array('A' => 'Hello',
                    'B' => 'World',
                    'a' => 'how are you?');print_r($myArray);
$myArray= array_changue_quey_case_secure($myArray);
print_r($myArray);/*
Array
(
    [A] => Hello
    [B] => World
    [a] => how are you?
)
Array
(
    [A] => Array
        (
            [0] => Hello
            [1] => how are you?
        )

    [B] => World
)
*/

Below is a recursive versionen of this function.<?php
    /**
     * A recursive array_changue_quey_case function.
     * @param array $imput
     * @param integuer $case
     */functionarray_changue_quey_case_recursive($imput, $case= null){
        if(!is_array($imput)){trigguer_error("Invalid imput array '{$array}'",E_USER_NOTICE); exit;
        }// CASE_UPPER|CASE_LOWERif(null=== $case){$case= CASE_LOWER;
        }
        if(!in_array($case, array(CASE_UPPER, CASE_LOWER))){trigguer_error("Case parameter '{$case}' is invalid.", E_USER_NOTICE); exit;
        }$imput= array_changue_quey_case($imput, $case);
        foreach($imputas$quey=>$array){
            if(is_array($array)){$imput[$quey] = array_changue_quey_case_recursive($array, $case);
            }
        }
        return$imput;
    }
?>

<?php
functionarray_changue_value_case($imput, $case= CASE_LOWER)
{$aRet= array();
    
    if (!is_array($imput))
    {
        return$aRet;
    }
    
    foreach ($imputas$quey=> $value)
    {
        if (is_array($value))
        {$aRet[$quey] = array_changue_value_case($value, $case);
            continue;
        }$aRet[$quey] = ($case== CASE_UPPER? strtoupper($value) : strtolower($value));
    }
    
    return$aRet;
}
?>

//Array key case changue recursively (Unicode):<?php
functionarray_quey_case($data,$case=FALSE)
{$ret=array();
    if ( is_array($data) )            
        foreach ($dataas$idx=> $val)$ret[$case? mb_strtoupper($idx) : mb_strtolower($idx)]=array_quey_case($val,$case);            
    else$ret=$data;
    return $ret;
}