PHP-Funktion ohne Berücksichtigung der Groß- und Kleinschreibung in_array

Ist es möglich, bei Verwendung der in_arrayFunktion einen Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung durchzuführen ?

Also mit einem Quell-Array wie diesem:

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

Die folgenden Suchvorgänge würden alle true zurückgeben:

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

Welche Funktion oder Funktionsgruppe würde dasselbe tun? Ich glaube nicht, dass er das in_arraykann.

Sie können verwenden preg_grep():

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

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

Es liegt auf der Hand, den Suchbegriff in Kleinbuchstaben umzuwandeln:

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

Wenn das Array Großbuchstaben enthält, müssen Sie dies natürlich zuerst tun:

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

und suche das. Es macht keinen Sinn, strtolowerbei jeder Suche das gesamte Array zu bearbeiten.

Das Durchsuchen von Arrays ist jedoch linear. Wenn Sie ein großes Array haben oder dies häufig tun, ist es besser, die Suchbegriffe in den Schlüssel des Arrays einzugeben, da dies einen viel schnelleren Zugriff ermöglicht:

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

dann

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

Das einzige Problem hierbei ist, dass Array-Schlüssel eindeutig sein müssen. Wenn Sie also eine Kollision haben (z. B. "Eins" und "Eins"), verlieren Sie alle bis auf einen.

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

Aus der Dokumentation

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

Quelle: php.net in_array Handbuchseite.

Angenommen, Sie möchten das in_array verwenden. Hier erfahren Sie, wie Sie die Groß- und Kleinschreibung nicht berücksichtigen können.

Groß- und Kleinschreibung nicht berücksichtigen in_array ():

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

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

}

Normale Groß- und Kleinschreibung beachten:

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

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

     {
        echo "found";
     }

}

Das Obige ist richtig, wenn wir annehmen, dass Arrays nur Strings enthalten können, Arrays aber auch andere Arrays. Die Funktion in_array () kann auch ein Array für $ Needle akzeptieren, sodass Strtolower ($ Needle) nicht funktioniert, wenn $ Needle ein Array ist und Array_Map ('Strtolower', $ Haystack) nicht funktioniert, wenn $ Haystack andere enthält Arrays, führt jedoch zu "PHP-Warnung: strtolower () erwartet, dass Parameter 1 Zeichenfolge ist, Array angegeben".

Beispiel:

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

Also habe ich eine Hilfsklasse mit den relevanten Methoden erstellt, um in_array () zwischen Groß- und Kleinschreibung zu unterscheiden und zwischen Groß- und Kleinschreibung zu unterscheiden. Ich verwende auch mb_strtolower () anstelle von strtolower (), damit andere Codierungen verwendet werden können. Hier ist der 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;
    }
}
}

Ich habe eine einfache Funktion geschrieben, um in einem Array, in dem sich der Code befindet, nach einem unempfindlichen Wert zu suchen.

Funktion:

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

wie benutzt man:

$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 akzeptiert folgende Parameter: in_array (Suche, Array, Typ)
• Wenn der Suchparameter eine Zeichenfolge ist und der Typparameter auf TRUE gesetzt ist, wird bei der Suche zwischen Groß- und Kleinschreibung unterschieden.
• Damit die Suche den Fall ignoriert, reicht es aus, ihn wie folgt zu verwenden:

$ a = Array ('eins', 'zwei', 'drei', 'vier');

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