ลบเครื่องหมายกำกับเสียง (ńǹňñṅņṇṋṉ̈ɲƞᶇɳȵ) จากตัวอักษร Unicode

ฉันกำลังมองหาที่อัลกอริทึมที่สามารถ map ระหว่างตัวอักษรกำกับ ( ตัวหนอน , หมวก , ลูกศร , เครื่องหมาย , รอน ) และ "ง่าย" ของพวกเขาตัวอักษร

ตัวอย่างเช่น:

ń  ǹ  ň  ñ  ṅ  ņ  ṇ  ṋ  ṉ  ̈  ɲ  ƞ ᶇ ɳ ȵ  --> n
á --> a
ä --> a
ấ --> a
ṏ --> o

ฯลฯ

1. ฉันต้องการทำสิ่งนี้ใน Java แม้ว่าฉันจะสงสัยว่ามันควรจะเป็น Unicode-y และควรจะทำได้ง่ายพอสมควรในทุกภาษา

2. วัตถุประสงค์: เพื่อให้สามารถค้นหาคำที่มีเครื่องหมายกำกับเสียงได้อย่างง่ายดาย ตัวอย่างเช่นหากฉันมีฐานข้อมูลของนักเทนนิสและป้อนBjörn_Borgฉันจะเก็บ Bjorn_Borg ไว้ด้วยเพื่อที่ฉันจะได้พบว่ามีคนเข้า Bjorn ไม่ใช่Björn

ฉันเพิ่งทำสิ่งนี้ใน Java:

public static final Pattern DIACRITICS_AND_FRIENDS
    = Pattern.compile("[\\p{InCombiningDiacriticalMarks}\\p{IsLm}\\p{IsSk}]+");

private static String stripDiacritics(String str) {
    str = Normalizer.normalize(str, Normalizer.Form.NFD);
    str = DIACRITICS_AND_FRIENDS.matcher(str).replaceAll("");
    return str;
}

สิ่งนี้จะทำตามที่คุณระบุ:

stripDiacritics("Björn")  = Bjorn

แต่มันจะล้มเหลวในตัวอย่างเช่นBiałystokเนื่องจากłอักขระไม่ได้เป็นตัวกำกับเสียง

หากคุณต้องการมีซิมแอมพลิไฟเออร์แบบสตริงแบบเต็มคุณจะต้องมีการล้างรอบที่สองสำหรับอักขระพิเศษบางตัวที่ไม่ใช่ตัวกำกับเสียง คือแผนที่นี้ฉันได้รวมอักขระพิเศษที่พบบ่อยที่สุดที่ปรากฏในชื่อลูกค้าของเรา ไม่ใช่รายการที่สมบูรณ์ แต่จะให้แนวคิดว่าจะขยายอย่างไร immutableMap เป็นเพียงคลาสง่ายๆจาก google-collection

public class StringSimplifier {
    public static final char DEFAULT_REPLACE_CHAR = '-';
    public static final String DEFAULT_REPLACE = String.valueOf(DEFAULT_REPLACE_CHAR);
    private static final ImmutableMap<String, String> NONDIACRITICS = ImmutableMap.<String, String>builder()

        //Remove crap strings with no sematics
        .put(".", "")
        .put("\"", "")
        .put("'", "")

        //Keep relevant characters as seperation
        .put(" ", DEFAULT_REPLACE)
        .put("]", DEFAULT_REPLACE)
        .put("[", DEFAULT_REPLACE)
        .put(")", DEFAULT_REPLACE)
        .put("(", DEFAULT_REPLACE)
        .put("=", DEFAULT_REPLACE)
        .put("!", DEFAULT_REPLACE)
        .put("/", DEFAULT_REPLACE)
        .put("\\", DEFAULT_REPLACE)
        .put("&", DEFAULT_REPLACE)
        .put(",", DEFAULT_REPLACE)
        .put("?", DEFAULT_REPLACE)
        .put("°", DEFAULT_REPLACE) //Remove ?? is diacritic?
        .put("|", DEFAULT_REPLACE)
        .put("<", DEFAULT_REPLACE)
        .put(">", DEFAULT_REPLACE)
        .put(";", DEFAULT_REPLACE)
        .put(":", DEFAULT_REPLACE)
        .put("_", DEFAULT_REPLACE)
        .put("#", DEFAULT_REPLACE)
        .put("~", DEFAULT_REPLACE)
        .put("+", DEFAULT_REPLACE)
        .put("*", DEFAULT_REPLACE)

        //Replace non-diacritics as their equivalent characters
        .put("\u0141", "l") // BiaLystock
        .put("\u0142", "l") // Bialystock
        .put("ß", "ss")
        .put("æ", "ae")
        .put("ø", "o")
        .put("©", "c")
        .put("\u00D0", "d") // All Ð ð from http://de.wikipedia.org/wiki/%C3%90
        .put("\u00F0", "d")
        .put("\u0110", "d")
        .put("\u0111", "d")
        .put("\u0189", "d")
        .put("\u0256", "d")
        .put("\u00DE", "th") // thorn Þ
        .put("\u00FE", "th") // thorn þ
        .build();


    public static String simplifiedString(String orig) {
        String str = orig;
        if (str == null) {
            return null;
        }
        str = stripDiacritics(str);
        str = stripNonDiacritics(str);
        if (str.length() == 0) {
            // Ugly special case to work around non-existing empty strings
            // in Oracle. Store original crapstring as simplified.
            // It would return an empty string if Oracle could store it.
            return orig;
        }
        return str.toLowerCase();
    }

    private static String stripNonDiacritics(String orig) {
        StringBuffer ret = new StringBuffer();
        String lastchar = null;
        for (int i = 0; i < orig.length(); i++) {
            String source = orig.substring(i, i + 1);
            String replace = NONDIACRITICS.get(source);
            String toReplace = replace == null ? String.valueOf(source) : replace;
            if (DEFAULT_REPLACE.equals(lastchar) && DEFAULT_REPLACE.equals(toReplace)) {
                toReplace = "";
            } else {
                lastchar = toReplace;
            }
            ret.append(toReplace);
        }
        if (ret.length() > 0 && DEFAULT_REPLACE_CHAR == ret.charAt(ret.length() - 1)) {
            ret.deleteCharAt(ret.length() - 1);
        }
        return ret.toString();
    }

    /*
    Special regular expression character ranges relevant for simplification -> see http://docstore.mik.ua/orelly/perl/prog3/ch05_04.htm
    InCombiningDiacriticalMarks: special marks that are part of "normal" ä, ö, î etc..
        IsSk: Symbol, Modifier see http://www.fileformat.info/info/unicode/category/Sk/list.htm
        IsLm: Letter, Modifier see http://www.fileformat.info/info/unicode/category/Lm/list.htm
     */
    public static final Pattern DIACRITICS_AND_FRIENDS
        = Pattern.compile("[\\p{InCombiningDiacriticalMarks}\\p{IsLm}\\p{IsSk}]+");


    private static String stripDiacritics(String str) {
        str = Normalizer.normalize(str, Normalizer.Form.NFD);
        str = DIACRITICS_AND_FRIENDS.matcher(str).replaceAll("");
        return str;
    }
}

แพ็กเกจ java.text หลักได้รับการออกแบบมาเพื่อจัดการกับกรณีการใช้งานนี้ (การจับคู่สตริงโดยไม่ต้องคำนึงถึงตัวกำกับเสียงตัวพิมพ์และอื่น ๆ )

กำหนดค่าCollatorเพื่อเรียงลำดับตามPRIMARYความแตกต่างของอักขระ จากนั้นให้สร้างCollationKeyสตริงสำหรับแต่ละสตริง หากโค้ดทั้งหมดของคุณอยู่ใน Java คุณสามารถใช้ไฟล์CollationKey. หากคุณจำเป็นต้องเก็บกุญแจในฐานข้อมูลหรืออื่น ๆ ที่จัดเรียงของดัชนีคุณสามารถแปลงเป็นแถว byte

คลาสเหล่านี้ใช้ข้อมูลการพับกรณีมาตรฐาน Unicodeเพื่อพิจารณาว่าอักขระใดเทียบเท่าและสนับสนุนกลยุทธ์การสลายตัวต่างๆ

Collator c = Collator.getInstance();
c.setStrength(Collator.PRIMARY);
Map<CollationKey, String> dictionary = new TreeMap<CollationKey, String>();
dictionary.put(c.getCollationKey("Björn"), "Björn");
...
CollationKey query = c.getCollationKey("bjorn");
System.out.println(dictionary.get(query)); // --> "Björn"

โปรดทราบว่า collators นั้นขึ้นอยู่กับโลแคล เนื่องจาก "ลำดับตัวอักษร" แตกต่างกันระหว่างภาษา (และเมื่อเวลาผ่านไปเช่นเดียวกับในภาษาสเปน) Collatorระดับบรรเทาคุณจากที่มีการติดตามทั้งหมดของกฎเหล่านี้และให้พวกเขาได้ถึงวันที่

เป็นส่วนหนึ่งของApache Commons Langในเวอร์ชัน 3.1.

org.apache.commons.lang3.StringUtils.stripAccents("Añ");

ผลตอบแทน An

คุณสามารถใช้คลาส Normalizer ได้จากjava.text:

System.out.println(new String(Normalizer.normalize("ń ǹ ň ñ ṅ ņ ṇ ṋ", Normalizer.Form.NFKD).getBytes("ascii"), "ascii"));

แต่ยังมีงานที่ต้องทำเนื่องจาก Java สร้างสิ่งแปลก ๆ ด้วยอักขระ Unicode ที่ไม่สามารถแปลงกลับได้ (ไม่ได้เพิกเฉยต่อพวกเขาและจะไม่เกิดข้อยกเว้น) แต่ฉันคิดว่าคุณสามารถใช้เป็นจุดเริ่มต้นได้

มีรายงานฉบับร่างเกี่ยวกับการพับตัวอักษรบนเว็บไซต์ Unicode ซึ่งมีเนื้อหาที่เกี่ยวข้องจำนวนมาก ดูเฉพาะส่วน 4.1 "ขั้นตอนวิธีการพับ".

นี่คือการอภิปรายและการดำเนินการลบเครื่องหมายกำกับเสียงโดยใช้ Perl

คำถาม SO ที่มีอยู่เหล่านี้เกี่ยวข้อง:

• วิธีแปลง UTF-8 เป็น US ASCII
• วิธีเปลี่ยนอักขระกำกับเสียงเป็นอักขระที่ไม่ใช่ตัวกำกับเสียง

โปรดทราบว่าเครื่องหมายเหล่านี้ไม่ใช่แค่ "เครื่องหมาย" บนอักขระ "ปกติ" บางตัวที่คุณสามารถลบออกได้โดยไม่ต้องเปลี่ยนความหมาย

ในภาษาสวีเดนåäและöเป็นอักขระชั้นหนึ่งที่แท้จริงและเหมาะสมไม่ใช่ "ตัวแปร" ของอักขระอื่น ๆ พวกเขาฟังดูแตกต่างจากอักขระอื่น ๆ ทั้งหมดเรียงลำดับต่างกันและทำให้คำเปลี่ยนความหมาย ("mätt" และ "matt" เป็นคำสองคำที่ต่างกัน)

Unicode มีอักขระไดอะตริกเฉพาะ (ซึ่งเป็นอักขระผสม) และสามารถแปลงสตริงเพื่อให้อักขระและไดเมตริกแยกจากกัน จากนั้นคุณสามารถลบ diatricts ออกจากสตริงและคุณก็ทำเสร็จแล้ว

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการฟื้นฟูการสลายตัวและความเท่าเทียมกันให้ดูมาตรฐาน Unicode ที่หน้าแรกของ Unicode

อย่างไรก็ตามคุณจะบรรลุสิ่งนี้ได้อย่างไรนั้นขึ้นอยู่กับกรอบงาน / OS / ... ที่คุณกำลังดำเนินการอยู่ หากคุณกำลังใช้. NET คุณสามารถใช้เมธอดString.NormalizeยอมรับการแจงนับSystem.Text.NormalizationForm

วิธีที่ง่ายที่สุด (สำหรับฉัน) คือการรักษาอาร์เรย์การแมปแบบกระจัดกระจายซึ่งเพียงแค่เปลี่ยนจุดรหัส Unicode ของคุณเป็นสตริงที่แสดงได้

เช่น:

start    = 0x00C0
size     = 23
mappings = {
    "A","A","A","A","A","A","AE","C",
    "E","E","E","E","I","I","I", "I",
    "D","N","O","O","O","O","O"
}
start    = 0x00D8
size     = 6
mappings = {
    "O","U","U","U","U","Y"
}
start    = 0x00E0
size     = 23
mappings = {
    "a","a","a","a","a","a","ae","c",
    "e","e","e","e","i","i","i", "i",
    "d","n","o","o","o","o","o"
}
start    = 0x00F8
size     = 6
mappings = {
    "o","u","u","u","u","y"
}
: : :

การใช้อาร์เรย์แบบกระจัดกระจายจะช่วยให้คุณแสดงการแทนที่ได้อย่างมีประสิทธิภาพแม้ว่าจะอยู่ในส่วนที่เว้นระยะห่างของตาราง Unicode ก็ตาม การแทนที่สตริงจะอนุญาตให้ลำดับตามอำเภอใจแทนที่การกำกับเสียงของคุณ (เช่นการæกลายเป็นกราฟae)

นี่เป็นคำตอบที่ไม่เชื่อเรื่องพระเจ้าดังนั้นหากคุณมีภาษาเฉพาะในใจก็จะมีวิธีที่ดีกว่านี้ (แม้ว่าพวกเขาทั้งหมดจะลงมาที่ระดับต่ำสุดก็ตาม)

สิ่งที่ต้องพิจารณา: หากคุณพยายามหา "คำแปล" คำเดียวของแต่ละคำคุณอาจพลาดทางเลือกอื่นที่เป็นไปได้

ตัวอย่างเช่นในภาษาเยอรมันเมื่อแทนที่ "s-set" บางคนอาจใช้ "B" ในขณะที่บางคนอาจใช้ "ss" หรือแทนที่ umlauted o ด้วย "o" หรือ "oe" วิธีแก้ปัญหาที่คุณคิดขึ้นฉันคิดว่าควรรวมทั้งสองอย่าง

ใน Windows และ. NET ฉันเพิ่งแปลงโดยใช้การเข้ารหัสสตริง ด้วยวิธีนี้ฉันจะหลีกเลี่ยงการทำแผนที่และการเข้ารหัสด้วยตนเอง

ลองเล่นกับการเข้ารหัสสตริง

ในกรณีของภาษาเยอรมันไม่ต้องการลบเครื่องหมายกำกับเสียงออกจาก Umlauts (ä, ö, ü) แต่จะถูกแทนที่ด้วยการผสมตัวอักษรสองตัว (ae, oe, ue) ตัวอย่างเช่นBjörnควรเขียนเป็น Bjoern (ไม่ใช่ Bjorn) เพื่อให้มีการออกเสียงที่ถูกต้อง

สำหรับสิ่งนั้นฉันจะค่อนข้างมีการแมปแบบฮาร์ดโค้ดซึ่งคุณสามารถกำหนดกฎการแทนที่ทีละกลุ่มสำหรับกลุ่มอักขระพิเศษแต่ละกลุ่ม

สำหรับการอ้างอิงในอนาคตนี่คือวิธีการขยาย C # ที่ลบสำเนียง

public static class StringExtensions
{
    public static string RemoveDiacritics(this string str)
    {
        return new string(
            str.Normalize(NormalizationForm.FormD)
                .Where(c => CharUnicodeInfo.GetUnicodeCategory(c) != 
                            UnicodeCategory.NonSpacingMark)
                .ToArray());
    }
}
static void Main()
{
    var input = "ŃŅŇ ÀÁÂÃÄÅ ŢŤţť Ĥĥ àáâãäå ńņň";
    var output = input.RemoveDiacritics();
    Debug.Assert(output == "NNN AAAAAA TTtt Hh aaaaaa nnn");
}