RegEx để tách camelCase hoặc TitleCase (nâng cao)

Question 1

Tôi đã tìm thấy một RegEx tuyệt vời để trích xuất một phần của biểu thức camelCase hoặc TitleCase.

 (?<!^)(?=[A-Z])

Nó hoạt động như mong đợi:

giá trị -> giá trị
camelValue -> lạc đà / Giá trị
TitleValue -> Tiêu đề / Giá trị

Ví dụ với Java:

String s = "loremIpsum";
words = s.split("(?<!^)(?=[A-Z])");
//words equals words = new String[]{"lorem","Ipsum"}

Vấn đề của tôi là nó không hoạt động trong một số trường hợp:

Trường hợp 1: VALUE -> V / A / L / U / E
Trường hợp 2: eclipseRCPExt -> eclipse / R / C / P / Ext

Theo suy nghĩ của tôi, kết quả sẽ là:

Trường hợp 1: VALUE
Trường hợp 2: eclipse / RCP / Ext

Nói cách khác, n ký tự hoa cho trước:

nếu n ký tự được theo sau bởi ký tự viết thường, các nhóm phải là: (n-1 ký tự) / (n-thứ ký tự + ký tự thường)
nếu n ký tự ở cuối, nhóm phải là: (n ký tự).

Bất kỳ ý tưởng về cách cải thiện regex này?

Question 2

Regex sau hoạt động cho tất cả các ví dụ trên:

public static void main(String[] args)
{
    for (String w : "camelValue".split("(?<!(^|[A-Z]))(?=[A-Z])|(?<!^)(?=[A-Z][a-z])")) {
        System.out.println(w);
    }
}

Nó hoạt động bằng cách buộc cái nhìn sau phủ định không chỉ bỏ qua các kết quả phù hợp ở đầu chuỗi mà còn bỏ qua các kết quả phù hợp có một chữ hoa đứng trước một chữ hoa khác. Điều này xử lý các trường hợp như "VALUE".

Phần đầu tiên của regex không thành công trên "eclipseRCPExt" do không thể phân chia giữa "RPC" và "Ext". Đây là mục đích của mệnh đề thứ hai: (?<!^)(?=[A-Z][a-z]. Mệnh đề này cho phép phân tách trước mỗi ký tự hoa theo sau là một ký tự thường, ngoại trừ ở đầu chuỗi.

Question 3

Có vẻ như bạn đang làm cho việc này phức tạp hơn mức cần thiết. Đối với camelCase , vị trí phân tách chỉ đơn giản là bất kỳ nơi nào một ký tự hoa ngay sau một ký tự viết thường:

(?<=[a-z])(?=[A-Z])

Đây là cách regex này chia nhỏ dữ liệu mẫu của bạn:

value -> value
camelValue -> camel / Value
TitleValue -> Title / Value
VALUE -> VALUE
eclipseRCPExt -> eclipse / RCPExt

Sự khác biệt duy nhất so với đầu ra mong muốn của bạn là với eclipseRCPExt, mà tôi cho rằng được phân chia chính xác ở đây.

Phụ lục - Phiên bản cải tiến

Lưu ý: Câu trả lời này gần đây đã nhận được một ủng hộ và tôi nhận ra rằng có một cách tốt hơn ...

Bằng cách thêm phương án thay thế thứ hai vào regex ở trên, tất cả các trường hợp thử nghiệm của OP đều được phân tách chính xác.

(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])

Đây là cách regex cải tiến chia nhỏ dữ liệu mẫu:

value -> value
camelValue -> camel / Value
TitleValue -> Title / Value
VALUE -> VALUE
eclipseRCPExt -> eclipse / RCP / Ext

Chỉnh sửa: 20130824 Đã thêm phiên bản cải tiến để xử lý RCPExt -> RCP / Exttrường hợp.

Question 4

Một giải pháp khác sẽ là sử dụng một phương pháp chuyên dụng trong commons-lang : StringUtils # splitByCharacterTypeCamelCase

Question 5

Tôi không thể làm cho giải pháp của aix hoạt động (và nó cũng không hoạt động trên RegExr), vì vậy tôi đã đưa ra giải pháp của riêng mình mà tôi đã thử nghiệm và dường như làm chính xác những gì bạn đang tìm kiếm:

((^[a-z]+)|([A-Z]{1}[a-z]+)|([A-Z]+(?=([A-Z][a-z])|($))))

và đây là một ví dụ về việc sử dụng nó:

; Regex Breakdown:  This will match against each word in Camel and Pascal case strings, while properly handling acrynoms.
;   (^[a-z]+)                       Match against any lower-case letters at the start of the string.
;   ([A-Z]{1}[a-z]+)                Match against Title case words (one upper case followed by lower case letters).
;   ([A-Z]+(?=([A-Z][a-z])|($)))    Match against multiple consecutive upper-case letters, leaving the last upper case letter out the match if it is followed by lower case letters, and including it if it's followed by the end of the string.
newString := RegExReplace(oldCamelOrPascalString, "((^[a-z]+)|([A-Z]{1}[a-z]+)|([A-Z]+(?=([A-Z][a-z])|($))))", "$1 ")
newString := Trim(newString)

Ở đây tôi đang phân tách từng từ bằng dấu cách, vì vậy đây là một số ví dụ về cách chuỗi được chuyển đổi:

ThisIsATitleCASEString => Đây là chuỗi trường hợp tiêu đề
andThisOneIsCamelCASE => và This One Is Camel CASE

Giải pháp ở trên thực hiện những gì bài đăng gốc yêu cầu, nhưng tôi cũng cần một regex để tìm các chuỗi lạc đà và pascal bao gồm các số, vì vậy tôi cũng đã đưa ra biến thể này để bao gồm các số:

((^[a-z]+)|([0-9]+)|([A-Z]{1}[a-z]+)|([A-Z]+(?=([A-Z][a-z])|($)|([0-9]))))

và một ví dụ về việc sử dụng nó:

; Regex Breakdown:  This will match against each word in Camel and Pascal case strings, while properly handling acrynoms and including numbers.
;   (^[a-z]+)                               Match against any lower-case letters at the start of the command.
;   ([0-9]+)                                Match against one or more consecutive numbers (anywhere in the string, including at the start).
;   ([A-Z]{1}[a-z]+)                        Match against Title case words (one upper case followed by lower case letters).
;   ([A-Z]+(?=([A-Z][a-z])|($)|([0-9])))    Match against multiple consecutive upper-case letters, leaving the last upper case letter out the match if it is followed by lower case letters, and including it if it's followed by the end of the string or a number.
newString := RegExReplace(oldCamelOrPascalString, "((^[a-z]+)|([0-9]+)|([A-Z]{1}[a-z]+)|([A-Z]+(?=([A-Z][a-z])|($)|([0-9]))))", "$1 ")
newString := Trim(newString)

Và đây là một số ví dụ về cách một chuỗi với các số được chuyển đổi với regex này:

myVariable123 => Biến 123 của tôi
my2Variables => 2 biến của tôi
The3rdVariableIsHere => The 3 rdVariable is Here
12345NumsAtTheStartIncludedToo => 12345 Nums lúc bắt đầu cũng được bao gồm

Question 6

Để xử lý nhiều chữ cái hơn là chỉ `A-Z`:

s.split("(?<=\\p{Ll})(?=\\p{Lu})|(?<=\\p{L})(?=\\p{Lu}\\p{Ll})");

Hoặc:

Phân tách sau bất kỳ ký tự thường nào, được theo sau bởi ký tự hoa.

Ví dụ: parseXML-> parse, XML.

hoặc là

Phân chia sau bất kỳ chữ cái nào, theo sau là chữ hoa và chữ thường.

Ví dụ: XMLParser-> XML, Parser.

Ở dạng dễ đọc hơn:

public class SplitCamelCaseTest {

    static String BETWEEN_LOWER_AND_UPPER = "(?<=\\p{Ll})(?=\\p{Lu})";
    static String BEFORE_UPPER_AND_LOWER = "(?<=\\p{L})(?=\\p{Lu}\\p{Ll})";

    static Pattern SPLIT_CAMEL_CASE = Pattern.compile(
        BETWEEN_LOWER_AND_UPPER +"|"+ BEFORE_UPPER_AND_LOWER
    );

    public static String splitCamelCase(String s) {
        return SPLIT_CAMEL_CASE.splitAsStream(s)
                        .collect(joining(" "));
    }

    @Test
    public void testSplitCamelCase() {
        assertEquals("Camel Case", splitCamelCase("CamelCase"));
        assertEquals("lorem Ipsum", splitCamelCase("loremIpsum"));
        assertEquals("XML Parser", splitCamelCase("XMLParser"));
        assertEquals("eclipse RCP Ext", splitCamelCase("eclipseRCPExt"));
        assertEquals("VALUE", splitCamelCase("VALUE"));
    }    
}

Question 7

Tóm tắt

Cả hai câu trả lời hàng đầu ở đây đều cung cấp mã sử dụng giao diện tích cực, không được hỗ trợ bởi tất cả các phiên bản regex. Regex bên dưới sẽ ghi lại cả hai PascalCasevà camelCasevà có thể được sử dụng bằng nhiều ngôn ngữ.

Lưu ý: Tôi nhận thấy câu hỏi này liên quan đến Java, tuy nhiên, tôi cũng thấy nhiều đề cập về bài đăng này trong các câu hỏi khác được gắn thẻ cho các ngôn ngữ khác nhau, cũng như một số nhận xét về câu hỏi này cho cùng một câu hỏi.

Mã

Xem regex này đang được sử dụng tại đây

([A-Z]+|[A-Z]?[a-z]+)(?=[A-Z]|\b)

Các kết quả

Đầu vào mẫu

eclipseRCPExt

SomethingIsWrittenHere

TEXTIsWrittenHERE

VALUE

loremIpsum

Đầu ra mẫu

eclipse
RCP
Ext

Something
Is
Written
Here

TEXT
Is
Written
HERE

VALUE

lorem
Ipsum

Giải trình

Khớp một hoặc nhiều ký tự alpha viết hoa [A-Z]+
Hoặc khớp với 0 hoặc một ký tự alpha viết hoa [A-Z]?, theo sau là một hoặc nhiều ký tự alpha viết thường[a-z]+
Đảm bảo những gì sau đây là ký tự alpha viết hoa [A-Z]hoặc ký tự ranh giới từ\b

Question 8

Bạn có thể sử dụng StringUtils. splitByCharacterTypeCamelCase ("loremIpsum") từ Apache Commons Lang.

Question 9

Bạn có thể sử dụng biểu thức bên dưới cho Java:

(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|(?=[A-Z][a-z])|(?<=\\d)(?=\\D)|(?=\\d)(?<=\\D)

Question 10

Thay vì tìm kiếm các dấu phân cách không có ở đó, bạn cũng có thể xem xét việc tìm các thành phần tên (chắc chắn là ở đó):

String test = "_eclipse福福RCPExt";

Pattern componentPattern = Pattern.compile("_? (\\p{Upper}?\\p{Lower}+ | (?:\\p{Upper}(?!\\p{Lower}))+ \\p{Digit}*)", Pattern.COMMENTS);

Matcher componentMatcher = componentPattern.matcher(test);
List<String> components = new LinkedList<>();
int endOfLastMatch = 0;
while (componentMatcher.find()) {
    // matches should be consecutive
    if (componentMatcher.start() != endOfLastMatch) {
        // do something horrible if you don't want garbage in between

        // we're lenient though, any Chinese characters are lucky and get through as group
        String startOrInBetween = test.substring(endOfLastMatch, componentMatcher.start());
        components.add(startOrInBetween);
    }
    components.add(componentMatcher.group(1));
    endOfLastMatch = componentMatcher.end();
}

if (endOfLastMatch != test.length()) {
    String end = test.substring(endOfLastMatch, componentMatcher.start());
    components.add(end);
}

System.out.println(components);

Kết quả này [eclipse, 福福, RCP, Ext]. Tất nhiên, việc chuyển đổi sang một mảng rất đơn giản.

Question 11

Tôi có thể xác nhận rằng chuỗi regex ([A-Z]+|[A-Z]?[a-z]+)(?=[A-Z]|\b)được cung cấp bởi ctwheels, ở trên, hoạt động với phiên bản regex của Microsoft.

Tôi cũng muốn để đề nghị thay thế sau đây, dựa trên regex ctwheels', mà xử lý ký tự số: ([A-Z0-9]+|[A-Z]?[a-z]+)(?=[A-Z0-9]|\b).

Điều này có thể chia các chuỗi chẳng hạn như:

DrivingB2BTradeIn2019Onwards

đến

Thúc đẩy giao dịch B2B trong năm 2019 trở đi

Question 12

Giải pháp JavaScript

/**
 * howToDoThis ===> ["", "how", "To", "Do", "This"]
 * @param word word to be split
 */
export const splitCamelCaseWords = (word: string) => {
    if (typeof word !== 'string') return [];
    return word.replace(/([A-Z]+|[A-Z]?[a-z]+)(?=[A-Z]|\b)/g, '!$&').split('!');
};