Pregunta Insensible a mayúsculas y minúsculas 'Contiene (cadena)'


¿Hay alguna manera de hacer que el siguiente retorno sea cierto?

string title = "ASTRINGTOTEST";
title.Contains("string");

No parece haber una sobrecarga que me permita establecer la sensibilidad de las mayúsculas y minúsculas. Actualmente ME SUPERIORO a ambas, pero eso es una tontería (por lo que me refiero al i18n problemas que vienen con la carcasa hacia arriba y hacia abajo).

ACTUALIZAR
Esta pregunta es antigua y desde entonces me he dado cuenta de que pedí una respuesta simple para un tema realmente vasto y difícil si te interesa investigarlo por completo.
Para la mayoría de los casos, en bases de código monolingüe e inglés esta la respuesta será suficiente. Sospecho que porque la mayoría de las personas que entran aquí caen en esta categoría, esta es la respuesta más popular.
Esta Sin embargo, la respuesta plantea el problema inherente de que no podemos comparar mayúsculas y minúsculas hasta que sepamos que ambos textos son de la misma cultura y sabemos cuál es esa cultura. Esta es quizás una respuesta menos popular, pero creo que es más correcta y es por eso que la marqué como tal.


2416
2018-01-14 21:39


origen


Respuestas:


Para probar si la cadena paragraph contiene la cadena word (gracias @QuarterMeister)

culture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0

Dónde culture es la instancia de CultureInfo describiendo el idioma en el que está escrito el texto

Esta solución es transparente la definición de insensibilidad a mayúsculas y minúsculas, que depende del idioma. Por ejemplo, el idioma inglés usa los personajes I y i para las versiones en mayúscula y minúscula de la novena letra, mientras que el idioma turco utiliza estos caracteres para el undécima y duodécima letras de su alfabeto de 29 letras. La versión turca de mayúscula de 'i' es el carácter desconocido 'İ'.

Por lo tanto, las cuerdas tin y TIN son la misma palabra en inglés, pero diferentes palabras en turco. Según entiendo, uno significa 'espíritu' y el otro es una palabra de onomatopeya. (Turcos, por favor corríjanme si me equivoco, o sugieran un mejor ejemplo)

Para resumir, solo puede responder la pregunta "¿son estas dos cadenas iguales pero en casos diferentes? si sabes en qué idioma está el texto. Si no lo sabes, tendrás que tomar una punt. Dada la hegemonía del inglés en el software, probablemente debería recurrir a CultureInfo.InvariantCulture, porque va a estar mal de maneras familiares.


1083
2018-03-17 18:22



Podrías usar el Método String.IndexOf y pase StringComparison.OrdinalIgnoreCase como el tipo de búsqueda para usar:

string title = "STRING";
bool contains = title.IndexOf("string", StringComparison.OrdinalIgnoreCase) >= 0;

Aún mejor es definir un nuevo método de extensión para la cadena:

public static class StringExtensions
{
    public static bool Contains(this string source, string toCheck, StringComparison comp)
    {
        return source?.IndexOf(toCheck, comp) >= 0;
    }
}

Tenga en cuenta que propagación nula  ?. está disponible desde C # 6.0 (VS 2015), para versiones anteriores use

if (source == null) return false;
return source.IndexOf(toCheck, comp) >= 0;

USO:

string title = "STRING";
bool contains = title.Contains("string", StringComparison.OrdinalIgnoreCase);

2356
2018-01-14 21:44



Puedes usar IndexOf() Me gusta esto:

string title = "STRING";

if (title.IndexOf("string", 0, StringComparison.CurrentCultureIgnoreCase) != -1)
{
    // The string exists in the original
}

Como 0 (cero) puede ser un índice, se compara con -1.

MSDN

La posición de valor del índice basado en cero si se encuentra esa cadena, o -1   si no es. Si el valor es String.Empty, el valor devuelto es 0.


203
2018-01-14 21:48



Solución alternativa usando Regex:

bool contains = Regex.IsMatch("StRiNG to search", "string", RegexOptions.IgnoreCase);

darse cuenta

Como @cHao ha señalado en su comentario, hay situaciones que harán que esta solución arroje resultados incorrectos. Asegúrese de saber lo que está haciendo antes de implementar esta solución al azar.


115
2017-07-28 17:18



Siempre puedes subir o bajar las cuerdas primero.

string title = "string":
title.ToUpper().Contains("STRING")  // returns true

Vaya, acabo de ver eso último. Una comparación insensible a mayúsculas y minúsculas *probablemente* haga lo mismo de todos modos, y si el rendimiento no es un problema, no veo un problema para crear copias en mayúsculas y compararlas. Podría haber jurado que una vez vi una comparación insensible a mayúsculas una vez ...


62
2018-01-14 21:42



Un problema con la respuesta es que emitirá una excepción si una cadena es nula. Puede agregar eso como un cheque para que no lo haga:

public static bool Contains(this string source, string toCheck, StringComparison comp)
{
    if (string.IsNullOrEmpty(toCheck) || string.IsNullOrEmpty(source))
        return true;

    return source.IndexOf(toCheck, comp) >= 0;
} 

48
2017-12-07 21:11



La clase StringExtension es el camino a seguir, he combinado algunas de las publicaciones anteriores para dar un ejemplo completo de código:

public static class StringExtensions
{
    /// <summary>
    /// Allows case insensitive checks
    /// </summary>
    public static bool Contains(this string source, string toCheck, StringComparison comp)
    {
        return source.IndexOf(toCheck, comp) >= 0;
    }
}

32
2017-11-18 16:48



Esto es limpio y simple.

Regex.IsMatch(file, fileNamestr, RegexOptions.IgnoreCase)

31
2017-11-09 04:25



OrdinalIgnoreCase, CurrentCultureIgnoreCase o InvariantCultureIgnoreCase?

Como esto falta, aquí hay algunas recomendaciones sobre cuándo usar cuál:

Dos

  • Utilizar StringComparison.OrdinalIgnoreCase para comparaciones como su valor predeterminado seguro para la concordancia de cadena cultural-agnóstica.
  • Utilizar StringComparison.OrdinalIgnoreCase comparaciones para una mayor velocidad.
  • Utilizar StringComparison.CurrentCulture-based operaciones de cuerda cuando se muestra la salida al usuario.
  • Cambiar el uso actual de operaciones de cadena basadas en la invariante cultura para usar lo no lingüístico StringComparison.Ordinal o StringComparison.OrdinalIgnoreCase cuando la comparación es
    lingüísticamente irrelevante (simbólico, por ejemplo).
  • Utilizar ToUpperInvariant más bien que ToLowerInvariant cuando normalizando cadenas para la comparación.

Qué no hacer

  • Use sobrecargas para operaciones de cadena que no explícitamente o implícitamente especifique el mecanismo de comparación de cadenas.
  • Utilizar StringComparison.InvariantCulture cadena a base de
    operaciones en la mayoría de los casos; una de las pocas excepciones sería
    persistencia de datos lingüísticamente significativos pero culturalmente agnósticos.

En base a estas reglas, debe usar:

string title = "STRING";
if (title.IndexOf("string", 0, StringComparison.[YourDecision]) != -1)
{
    // The string exists in the original
}

mientras que [YourDecision] depende de las recomendaciones de arriba.

enlace de la fuente: http://msdn.microsoft.com/en-us/library/ms973919.aspx


24
2018-06-17 10:31