Fonction in_array insensible à la casse PHP

Est-il possible de faire une comparaison insensible à la casse lors de l'utilisation de la in_arrayfonction?

Donc, avec un tableau source comme celui-ci:

$a= array(
 'one',
 'two',
 'three',
 'four'
);

Les recherches suivantes renverraient toutes true:

in_array('one', $a);
in_array('two', $a);
in_array('ONE', $a);
in_array('fOUr', $a);

Quelle fonction ou quel ensemble de fonctions ferait de même? Je ne pense pas qu'elle in_arraypuisse faire ça.

vous pouvez utiliser preg_grep():

$a= array(
 'one',
 'two',
 'three',
 'four'
);

print_r( preg_grep( "/ONe/i" , $a ) );

La chose évidente à faire est simplement de convertir le terme de recherche en minuscules:

if (in_array(strtolower($word), $array)) { 
  ...

bien sûr, s'il y a des lettres majuscules dans le tableau, vous devrez d'abord le faire:

$search_array = array_map('strtolower', $array);

et recherchez cela. Il ne sert à rien de faire strtolowersur l'ensemble du tableau à chaque recherche.

La recherche de tableaux est cependant linéaire. Si vous avez un grand tableau ou que vous comptez faire beaucoup cela, il serait préférable de mettre les termes de recherche dans la clé du tableau car ce sera un accès beaucoup plus rapide:

$search_array = array_combine(array_map('strtolower', $a), $a);

puis

if ($search_array[strtolower($word)]) { 
  ...

Le seul problème ici est que les clés de tableau doivent être uniques, donc si vous avez une collision (par exemple "One" et "one"), vous en perdrez toutes sauf une.

function in_arrayi($needle, $haystack) {
    return in_array(strtolower($needle), array_map('strtolower', $haystack));
}

De la documentation

function in_arrayi($needle, $haystack) {
    return in_array(strtolower($needle), array_map('strtolower', $haystack));
}

Source: page de manuel de php.net in_array.

Supposons que vous souhaitiez utiliser in_array, voici comment rendre la recherche insensible à la casse.

Insensible à la casse in_array ():

foreach($searchKey as $key => $subkey) {

     if (in_array(strtolower($subkey), array_map("strtolower", $subarray)))
     {
        echo "found";
     }

}

Normalement sensible à la casse:

foreach($searchKey as $key => $subkey) {

if (in_array("$subkey", $subarray))

     {
        echo "found";
     }

}

Ce qui précède est correct si nous supposons que les tableaux ne peuvent contenir que des chaînes, mais que les tableaux peuvent également contenir d'autres tableaux. La fonction in_array () peut également accepter un tableau pour $ aiguille, donc strtolower ($ aiguille) ne fonctionnera pas si $ aiguille est un tableau et array_map ('strtolower', $ haystack) ne fonctionnera pas si $ haystack contient d'autres tableaux, mais entraînera un "avertissement PHP: strtolower () s'attend à ce que le paramètre 1 soit une chaîne, tableau donné".

Exemple:

$needle = array('p', 'H');
$haystack = array(array('p', 'H'), 'U');

J'ai donc créé une classe d'assistance avec les méthodes pertinentes, pour faire des vérifications in_array () sensibles à la casse et insensibles à la casse. J'utilise également mb_strtolower () au lieu de strtolower (), donc d'autres encodages peuvent être utilisés. Voici le code:

class StringHelper {

public static function toLower($string, $encoding = 'UTF-8')
{
    return mb_strtolower($string, $encoding);
}

/**
 * Digs into all levels of an array and converts all string values to lowercase
 */
public static function arrayToLower($array)
{
    foreach ($array as &$value) {
        switch (true) {
            case is_string($value):
                $value = self::toLower($value);
                break;
            case is_array($value):
                $value = self::arrayToLower($value);
                break;
        }
    }
    return $array;
}

/**
 * Works like the built-in PHP in_array() function — Checks if a value exists in an array, but
 * gives the option to choose how the comparison is done - case-sensitive or case-insensitive
 */
public static function inArray($needle, $haystack, $case = 'case-sensitive', $strict = false)
{
    switch ($case) {
        default:
        case 'case-sensitive':
        case 'cs':
            return in_array($needle, $haystack, $strict);
            break;
        case 'case-insensitive':
        case 'ci':
            if (is_array($needle)) {
                return in_array(self::arrayToLower($needle), self::arrayToLower($haystack), $strict);
            } else {
                return in_array(self::toLower($needle), self::arrayToLower($haystack), $strict);
            }
            break;
    }
}
}

J'ai écrit une fonction simple pour vérifier une valeur insensible dans un tableau dont le code est ci-dessous.

fonction:

function in_array_insensitive($needle, $haystack) {
   $needle = strtolower($needle);
   foreach($haystack as $k => $v) {
      $haystack[$k] = strtolower($v);
   }
   return in_array($needle, $haystack);
}

comment utiliser:

$array = array('one', 'two', 'three', 'four');
var_dump(in_array_insensitive('fOUr', $array));

/**
 * in_array function variant that performs case-insensitive comparison when needle is a string.
 *
 * @param mixed $needle
 * @param array $haystack
 * @param bool $strict
 *
 * @return bool
 */
function in_arrayi($needle, array $haystack, bool $strict = false): bool
{

    if (is_string($needle)) {

        $needle = strtolower($needle);

        foreach ($haystack as $value) {

            if (is_string($value)) {
                if (strtolower($value) === $needle) {
                    return true;
                }
            }

        }

        return false;

    }

    return in_array($needle, $haystack, $strict);

}


/**
 * in_array function variant that performs case-insensitive comparison when needle is a string.
 * Multibyte version.
 *
 * @param mixed $needle
 * @param array $haystack
 * @param bool $strict
 * @param string|null $encoding
 *
 * @return bool
 */
function mb_in_arrayi($needle, array $haystack, bool $strict = false, ?string $encoding = null): bool
{

    if (null === $encoding) {
        $encoding = mb_internal_encoding();
    }

    if (is_string($needle)) {

        $needle = mb_strtolower($needle, $encoding);

        foreach ($haystack as $value) {

            if (is_string($value)) {
                if (mb_strtolower($value, $encoding) === $needle) {
                    return true;
                }
            }

        }

        return false;

    }

    return in_array($needle, $haystack, $strict);

}

$a = [1 => 'funny', 3 => 'meshgaat', 15 => 'obi', 2 => 'OMER'];  

$b = 'omer';

function checkArr($x,$array)
{
    $arr = array_values($array);
    $arrlength = count($arr);
    $z = strtolower($x);

    for ($i = 0; $i < $arrlength; $i++) {
        if ($z == strtolower($arr[$i])) {
            echo "yes";
        }  
    } 
};

checkArr($b, $a);

• in_array accepte ces paramètres: in_array (recherche, tableau, type)
• si le paramètre de recherche est une chaîne et que le paramètre de type est défini sur TRUE, la recherche est sensible à la casse.
• donc pour que la recherche ignore la casse, il suffirait de l'utiliser comme ceci:

$ a = tableau ('un', 'deux', 'trois', 'quatre');

$ b = in_array ('ONE', $ a, faux);