文字列を大文字小文字を無視して比較する snippet

-- PostgreSQL is case-SENSITIVE by default — fold explicitly:
SELECT LOWER('Hello') = LOWER('HELLO') AS plain_ci; -- true

-- ICU collation at primary strength folds ß=ss for real:
CREATE COLLATION IF NOT EXISTS ci_primary (
  provider = icu, locale = 'und-u-ks-level1', deterministic = false
);
SELECT 'Straße' = 'STRASSE' COLLATE ci_primary AS esszett_ci; -- true

const a = 'Straße';
const b = 'STRASSE';

// toLowerCase is Unicode-aware but does NOT full-fold ß to ss:
console.log(a.toLowerCase() === b.toLowerCase()); // false

// Full folding lives in Intl.Collator, not in string methods:
const de = new Intl.Collator('de', { sensitivity: 'base' });
console.log(de.compare(a, b) === 0); // true

// Locale bites on the Turkish dotless i:
console.log('I'.toLowerCase() === 'i');           // true — locale-free
console.log('I'.toLocaleLowerCase('tr') === 'i'); // false — it is 'ı'

function equalsIgnoreCase(a: string, b: string, locale?: string): boolean {
  if (locale) {
    return a.toLocaleLowerCase(locale) === b.toLocaleLowerCase(locale);
  }
  return a.toLowerCase() === b.toLowerCase();
}

console.log(equalsIgnoreCase('Hello', 'HELLO'));          // true
console.log(equalsIgnoreCase('TITLE', 'title', 'tr'));   // false — İ/ı rules

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.EqualFold("Hello", "HELLO"))              // true
	fmt.Println(strings.EqualFold("Straße", "STRASSE"))           // false — simple fold keeps ß
	fmt.Println(strings.EqualFold("İstanbul", "istanbul"))       // false — no locale in simple folding
}

fn main() {
    let a = "Hello";
    let b = "HELLO";

    println!("{}", a.eq_ignore_ascii_case(b)); // true — ASCII only, zero-cost

    // Unicode: lowercase both (full, locale-free mapping) and compare:
    println!("{}", a.to_lowercase() == b.to_lowercase());                  // true
    println!("{}", "Straße".to_lowercase() == "STRASSE".to_lowercase());  // false — ß stays ß
}

<?php
// strcasecmp: POSIX, ASCII, byte-safe — fine for headers and enums:
var_dump(strcasecmp('Hello', 'HELLO') === 0); // true

// Unicode text: mbstring, and pass the encoding explicitly:
var_dump(mb_strtolower('HÉLLO', 'UTF-8') === mb_strtolower('héllo', 'UTF-8')); // true
var_dump(mb_stripos('HÉLLO', 'héllo', 0, 'UTF-8') === 0);                      // true

// Folding asymmetry — lowercasing never turns ß into ss:
var_dump(mb_strtolower('Straße', 'UTF-8') === mb_strtolower('STRASSE', 'UTF-8')); // false

print("Hello".lower() == "HELLO".lower())             # True
print("Straße".casefold() == "STRASSE".casefold())   # True — casefold, not lower
print("I".casefold() == "i")  # casefold is locale-free — no Turkish variant exists

#include <stdio.h>
#include <strings.h> /* strcasecmp lives here, NOT string.h, on POSIX */

int main(void) {
    printf("%d\n", strcasecmp("Hello", "HELLO") == 0); /* 1 — ASCII fold */

    /* Only ASCII folds — the UTF-8 bytes of É vs é differ, so two strings
       that differ ONLY by the case of an accented letter compare UNEQUAL.
       This prints 0: */
    const char *u = "caf\xC3\x89"; /* café with capital É */
    const char *l = "caf\xC3\xA9"; /* café with lowercase é */
    printf("%d\n", strcasecmp(u, l) == 0); /* 0 */
    return 0;
}

#include <algorithm>
#include <cctype>
#include <iostream>
#include <string>

// ASCII fold both, comparing equal lengths first. The unsigned char casts
// are load-bearing: a signed char with the high bit set is UB for tolower.
bool equals_ignore_case_ascii(const std::string& a, const std::string& b) {
    return a.size() == b.size() &&
           std::equal(a.begin(), a.end(), b.begin(), b.end(),
                      [](unsigned char x, unsigned char y) {
                          return std::tolower(x) == std::tolower(y);
                      });
}

int main() {
    std::cout << std::boolalpha
              << equals_ignore_case_ascii("Hello", "HELLO") << '\n'; // true
}

using System;

string a = "Hello", b = "HELLO";

// OrdinalIgnoreCase is the correct default — fast, stable, culture-free:
Console.WriteLine(string.Equals(a, b, StringComparison.OrdinalIgnoreCase)); // True

// Culture variants exist and diverge on exactly the characters you fear:
Console.WriteLine("ß".ToUpperInvariant() == "SS"); // True — fold asymmetries are real
Console.WriteLine(string.Equals("i", "I", StringComparison.InvariantCultureIgnoreCase)); // True — but 'ı' is not 'i' in tr-TR

import java.util.Locale;

public class IgnoreCase {
    public static void main(String[] args) {
        System.out.println("Hello".equalsIgnoreCase("HELLO")); // true

        // equalsIgnoreCase is locale-free, but (to|from)String case methods
        // are not — the classic Turkish-I production bug:
        Locale tr = Locale.forLanguageTag("tr");
        System.out.println("title".toUpperCase(tr));       // TİTLE — dotted capital İ
        System.out.println("title".toUpperCase(Locale.ROOT)); // TITLE
    }
}

let a = "Hello", b = "HELLO"

print(a.caseInsensitiveCompare(b) == .orderedSame) // true — Unicode-aware
print(a.lowercased() == b.lowercased())            // true — full case mapping

// Neither is locale-aware; hand the locale in when the text has one:
let tr = Locale(identifier: "tr")
print("I".lowercased(with: tr) == "ı") // true — dotted/dotless i

fun main() {
    println("Hello".equals("HELLO", ignoreCase = true)) // true

    val headers = mapOf("Content-Type" to "application/json")
    println(headers.keys.any { it.equals("content-type", ignoreCase = true) }) // true
}

puts 'Hello'.casecmp?('HELLO')     # true — Unicode-aware fold
puts 'ä'.casecmp?('Ä')             # true — not just ASCII
puts 'Straße'.casecmp?('STRASSE') # false — no ß→ss expansion

# casecmp (no ?) returns -1/0/1 for sorting instead of a boolean:
puts 'Hello'.casecmp('HELLO').zero? # true

const std = @import("std");

/// Case-insensitive equality — ASCII only. UTF-8 bytes above 0x7F
/// pass through untouched, so accented pairs compare unequal.
fn eqlIgnoreCase(a: []const u8, b: []const u8) bool {
    if (a.len != b.len) return false;
    for (a, b) |x, y| {
        if (std.ascii.toLower(x) != std.ascii.toLower(y)) return false;
    }
    return true;
}

pub fn main() void {
    std.debug.print("{}\n", .{eqlIgnoreCase("Hello", "HELLO")}); // true
}