Al hacer comparaciones que no distinguen entre mayúsculas y minúsculas, ¿es más eficiente convertir la cadena a mayúsculas o minúsculas? ¿Incluso importa?

En esta publicación de SO se sugiere que C # es más eficiente con ToUpper porque "Microsoft lo optimizó de esa manera". Pero también he leído este argumento de que la conversión de ToLower frente a ToUpper depende de lo que contengan más cadenas de caracteres, y que normalmente las cadenas contienen más caracteres en minúsculas, lo que hace que ToLower sea más eficiente.

En particular, me gustaría saber:

• ¿Hay alguna forma de optimizar ToUpper o ToLower de modo que uno sea más rápido que el otro?
• ¿Es más rápido hacer una comparación sin distinción entre mayúsculas y minúsculas y por qué?
• ¿Existen entornos de programación (por ejemplo, C, C #, Python, lo que sea) donde un caso es claramente mejor que el otro y por qué?

La conversión a mayúsculas o minúsculas para realizar comparaciones que no distinguen entre mayúsculas y minúsculas es incorrecta debido a las características "interesantes" de algunas culturas, especialmente Turquía. En su lugar, utilice StringComparer con las opciones adecuadas.

MSDN tiene excelentes pautas sobre el manejo de cadenas. También es posible que desee verificar que su código pase la prueba de Turquía .

EDITAR: Tenga en cuenta el comentario de Neil sobre las comparaciones ordinales que no distinguen entre mayúsculas y minúsculas. Todo este reino es bastante turbio :(

De Microsoft en MSDN:

Prácticas recomendadas para el uso de cadenas en .NET Framework

Recomendaciones para el uso de cadenas

• Utilice el método String.ToUpperInvariant en lugar del método String.ToLowerInvariant cuando normalice cadenas para la comparación.

¿Por qué? De Microsoft :

Normalizar cadenas a mayúsculas

Hay un pequeño grupo de caracteres que cuando se convierten a minúsculas no pueden realizar un viaje de ida y vuelta.

¿Cuál es el ejemplo de un personaje que no puede hacer un viaje de ida y vuelta?

• Inicio : Símbolo griego Rho (U + 03f1) ϱ
• Mayúsculas: mayúscula griega Rho (U + 03a1) Ρ
• Minúscula: Rho griega pequeña (U + 03c1) ρ

ϱ, Ρ , ρ

.NET Fiddle

Original: ϱ
ToUpper: Ρ
ToLower: ρ

Por eso, si desea hacer comparaciones que no distingan entre mayúsculas y minúsculas, convierta las cadenas a mayúsculas y no a minúsculas.

Entonces, si tiene que elegir uno, elija Mayúsculas .

Según MSDN , es más eficiente pasar las cadenas y decirle a la comparación que ignore el caso:

String.Compare (strA, strB, StringComparison.OrdinalIgnoreCase) es equivalente a ( pero más rápido que ) llamar

String.Compare (ToUpperInvariant (strA), ToUpperInvariant (strB), StringComparison.Ordinal).

Estas comparaciones siguen siendo muy rápidas.

Por supuesto, si está comparando una cadena una y otra vez, es posible que esto no sea así.

Basado en cadenas que tienden a tener más entradas en minúsculas, ToLower debería ser teóricamente más rápido (muchas comparaciones, pero pocas asignaciones).

En C, o cuando se utilizan elementos accesibles individualmente de cada cadena (como cadenas C o el tipo de cadena de STL en C ++), en realidad es una comparación de bytes, por lo que comparar UPPERno es diferente de lower.

Si fuera astuto y cargara sus cadenas en longmatrices, obtendría una comparación muy rápida en toda la cadena porque podría comparar 4 bytes a la vez. Sin embargo, el tiempo de carga puede hacer que no valga la pena.

¿Por qué necesitas saber cuál es más rápido? A menos que esté haciendo una gran cantidad de comparaciones métricas, una que se ejecute un par de ciclos más rápido es irrelevante para la velocidad de ejecución general y suena como una optimización prematura :)

Microsoft ha optimizado ToUpperInvariant(), no ToUpper(). La diferencia es que invariante es más amigable con la cultura. Si necesita hacer comparaciones que no distingan entre mayúsculas y minúsculas en cadenas que pueden variar en la cultura, use Invariant; de lo contrario, el rendimiento de la conversión invariante no debería importar.

Sin embargo, no puedo decir si ToUpper () o ToLower () es más rápido. Nunca lo probé, ya que nunca había tenido una situación en la que el rendimiento fuera tan importante.

Si está haciendo una comparación de cadenas en C #, es significativamente más rápido usar .Equals () en lugar de convertir ambas cadenas a mayúsculas o minúsculas. Otra gran ventaja de usar .Equals () es que no se asigna más memoria para las 2 nuevas cadenas de mayúsculas / minúsculas.

Realmente nunca debería importar. Con los caracteres ASCII, definitivamente no importa: son solo algunas comparaciones y un poco de cambio en cualquier dirección. Unicode puede ser un poco más complicado, ya que hay algunos caracteres que cambian entre mayúsculas y minúsculas de formas extrañas, pero realmente no debería haber ninguna diferencia a menos que su texto esté lleno de esos caracteres especiales.

Haciéndolo bien, debería haber una ventaja de velocidad pequeña e insignificante si convierte a minúsculas, pero esto, como muchos han insinuado, depende de la cultura y no se hereda en la función sino en las cadenas que convierte (muchas letras minúsculas significa pocas asignaciones a la memoria): convertir a mayúsculas es más rápido si tiene una cadena con muchas letras mayúsculas.

Depende. Como se indicó anteriormente, solo ASCII simple, es idéntico. En .NET, lea y use String.Compare su correcto para las cosas i18n (culturas de idiomas y unicode). Si sabe algo sobre la probabilidad de la entrada, use el caso más común.

Recuerde, si está haciendo varias comparaciones de cadenas, la longitud es un excelente primer discriminador.

Si se trata de ASCII puro, no importa. Es solo un OR x, 32 frente a un AND x, 224. Unicode, no tengo ni idea ...