PHP fonction in_array insensible à la casse
Est-il possible de faire une comparaison insensible à la casse en utilisant la fonction in_array?
Donc, avec un tableau source comme celui-ci:
$a= array(
'one',
'two',
'three',
'four'
);
Les recherches suivantes renvoient toutes la valeur true:
in_array('one', $a);
in_array('two', $a);
in_array('ONE', $a);
in_array('fOUr', $a);
Quelle fonction ou ensemble de fonctions ferait la même chose? Je ne pense pas que in_array puisse le faire lui-même.
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 minuscule:
if (in_array(strtolower($Word), $a) {
...
bien sûr, s'il y a des lettres majuscules dans le tableau, vous devez le faire en premier:
$search_array = array_map('strtolower', $a);
et chercher ça. Il est inutile de faire strtolower sur tout le tableau à chaque recherche.
La recherche de tableaux est cependant linéaire. Si vous avez un grand tableau ou si vous allez le faire beaucoup, il serait préférable de mettre les termes de recherche dans la clé du tableau car il s'agira d'un accès beaucoup plus rapide de beaucoup:
$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. Ainsi, en cas de collision (par exemple, "Un" et "Un"), vous perdrez tout sauf un.
function in_arrayi($needle, $haystack) {
return in_array(strtolower($needle), array_map('strtolower', $haystack));
}
function in_arrayi($needle, $haystack) {
return in_array(strtolower($needle), array_map('strtolower', $haystack));
}
Source: php.net page de manuel 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";
}
}
Cas 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 les tableaux peuvent également contenir d’autres tableaux. Aussi la fonction in_array () peut accepter un tableau pour $ needle, donc strtolower ($ needle) ne fonctionnera pas si $ needle est un tableau et array_map ('strtolower', $ haystack) ne fonctionnera pas si $ haystack contient "" Avertissement PHP: strtolower () s'attend à ce que le paramètre 1 soit une chaîne, un 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 correspondantes pour effectuer des contrôles in_array () sensibles à la casse et insensibles à la casse. J'utilise également mb_strtolower () au lieu de strtolower (), afin que d'autres encodages puissent ê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 rechercher une valeur insensible dans un tableau.
une 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);