При порівнянні, що не враховує регістр, чи ефективніше перетворити рядок у верхній чи нижній регістр? Це взагалі має значення?

У цій публікації SO висувається припущення, що C # є більш ефективним у роботі з ToUpper, оскільки "Microsoft оптимізувала його таким чином". Але я також прочитав цей аргумент, що перетворення ToLower проти ToUpper залежить від того, що ваші рядки містять більше, і що, як правило, рядки містять більше символів нижнього регістру, що робить ToLower більш ефективним.

Зокрема, я хотів би знати:

• Чи є спосіб оптимізувати ToUpper або ToLower таким чином, що один швидший за інший?
• Чи швидше зробити нечутливе до регістру порівняння між рядками верхнього чи нижнього регістру, і чому?
• Чи існують середовища програмування (наприклад, C, C #, Python, будь-які), де один випадок явно кращий за інший, і чому?

Перетворення на верхній або нижній регістр для порівняння, що не враховує регістр, є неправильним через "цікаві" особливості деяких культур, зокрема Туреччини. Натомість використовуйте StringComparer із відповідними параметрами.

MSDN має кілька чудових вказівок щодо обробки рядків. Можливо, ви також захочете перевірити, чи ваш код проходить тест Туреччини .

EDIT: Зверніть увагу на коментар Ніла щодо порядкових порівнянь, що не враховують регістр. Вся ця сфера досить мутна :(

Від Microsoft на MSDN:

Найкращі практики використання рядків у .NET Framework

Рекомендації щодо використання рядків

• Використовуйте метод String.ToUpperInvariant замість методу String.ToLowerInvariant, коли ви нормалізуєте рядки для порівняння.

Чому? Від Microsoft :

Нормалізуйте рядки у верхній регістр

Існує невелика група символів, які при перетворенні в малу літеру не можуть здійснити зворотний шлях.

Який приклад такого персонажа, який не може здійснити поїздку в обидва кінці?

• Початок : грецький символ Ро (U + 03f1) ϱ
• Великі літери : столиця грецька Rho (U + 03a1) Ρ
• Малі регістри: мала грецька ро (U + 03c1) ρ

ϱ, Ρ , ρ

.NET Скрипка

Original: ϱ
ToUpper: Ρ
ToLower: ρ

Ось чому, якщо ви хочете робити порівняння, що не враховують регістр, ви перетворюєте рядки у великі, а не в маленькі регістри.

Тож якщо вам доводиться вибирати одну, вибирайте великі літери .

Згідно з MSDN , ефективніше передати рядки та сказати порівняння, щоб ігнорувати регістр:

String.Compare (strA, strB, StringComparison.OrdinalIgnoreCase) еквівалентно ( але швидше ніж ) виклику

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

Ці порівняння все ще дуже швидкі.

Звичайно, якщо ви порівнюєте один рядок знову і знову, це може не мати місця.

На основі рядків, що мають тенденцію до більшої кількості нижчих регістрів, ToLower теоретично повинен бути швидшим (багато порівнянь, але мало призначень).

У C, або при використанні індивідуально доступних елементів кожного рядка (наприклад, рядків C або типу рядка STL в C ++), це насправді байтове порівняння - тому порівняння UPPERнічим не відрізняється від lower.

Якби ви були підступним і longнатомість завантажували свої рядки в масиви, ви отримали б дуже швидке порівняння цілого рядка, оскільки він міг порівнювати 4 байти одночасно. Однак час завантаження може зробити це не вартом.

Чому потрібно знати, що швидше? Якщо ви не робите метричного порівняльного порівняння, той, який працює на пару циклів швидше, не має значення для швидкості загального виконання і звучить як передчасна оптимізація :)

Microsoft оптимізувала ToUpperInvariant(), ні ToUpper(). Різниця полягає в тому, що інваріант є більш сприятливим для культури. Якщо вам потрібно зробити порівняння без урахування регістру рядків, які можуть відрізнятися за культурою, використовуйте Invariant, інакше ефективність перетворення інваріантів не повинна мати значення.

Не можу сказати, швидше ToUpper () чи ToLower (). Я ніколи не пробував, оскільки ніколи не мав ситуації, коли продуктивність так сильно мала значення.

Якщо ви робите порівняння рядків у C #, це значно швидше використовувати .Equals () замість перетворення обох рядків у верхній чи нижній регістр. Ще одним великим плюсом використання .Equals () є те, що для 2 нових рядків верхнього / нижнього регістру не виділяється більше пам'яті.

Це справді ніколи не повинно мати значення. Для символів ASCII це однозначно не має значення - це лише кілька порівнянь і трохи перекидання для будь-якого напрямку. Юнікод може бути дещо складнішим, оскільки є деякі символи, які змінюють регістр дивними способами, але насправді не повинно бути ніякої різниці, якщо ваш текст не заповнений цими спеціальними символами.

Роблячи це правильно, має бути невелика, незначна перевага в швидкості, якщо ви перетворюєте на нижній регістр, але це, як вже натякали багато, залежить від культури і не успадковується у функції, а в рядках, які ви перетворюєте (багато малих літер означає незначне призначення пам’яті) - перетворення у верхній регістр відбувається швидше, якщо у вас є рядок з великою кількістю великих літер.

Це залежить. Як зазначено вище, звичайний ASCII, його ідентичний. У .NET читайте про String та використовуйте його. Порівняйте його правильний для матеріалів i18n (культури мов та Unicode). Якщо ви щось знаєте про ймовірність введення, скористайтеся більш поширеним випадком.

Пам'ятайте, якщо ви виконуєте кілька рядків, порівняння довжини є прекрасним першим розпізнавачем.

Якщо ви маєте справу з чистим ASCII, це не має значення. Це просто АБО x, 32 проти AND x, 224. Юнікод, я поняття не маю ...