Я знайшов блискучий RegEx для вилучення частини виразу camelCase або TitleCase.

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

Це працює, як очікувалося:

• значення -> значення
• camelValue -> верблюд / значення
• TitleValue -> Заголовок / Значення

Наприклад, з Java:

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

Моя проблема полягає в тому, що це не працює в деяких випадках:

• Випадок 1: ЦІННІСТЬ -> V / A / L / U / E
• Випадок 2: eclipseRCPExt -> eclipse / R / C / P / Ext

На мою думку, результатом має бути:

• Випадок 1: ЦІННІСТЬ
• Випадок 2: затемнення / RCP / Ext

Іншими словами, дано n великих символів:

• якщо за n символами слідують символи нижнього регістру, групи повинні бути: (n-1 символи) / (n-й символ + нижні символи)
• якщо n символів в кінці, то група повинна бути: (n символів).

Будь-яка ідея про те, як покращити цей регулярний вираз?

Наступний регулярний вираз працює для всіх наведених прикладів:

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

Це працює, змушуючи негативний погляд позаду не тільки ігнорувати збіги на початку рядка, але також ігнорувати збіги, де перед великою літерою передує інша велика літера. Це обробляє випадки типу "VALUE".

Перша частина регулярного виразу самостійно зазнає невдачі на "eclipseRCPExt", оскільки не вдається розділити між "RPC" та "Ext". Це мета другого пункту: (?<!^)(?=[A-Z][a-z]. Цей пункт допускає розділення перед кожною великою літерою, після якої йде мала літера, за винятком початку рядка.

Здається, ви робите це складніше, ніж це повинно бути. Для camelCase місце розділення - це просто де-небудь велика буква відразу за малою :

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

Ось як цей регулярний вираз розділяє ваші приклади даних:

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

Єдина відмінність від бажаного результату полягає у значенні eclipseRCPExt, яке, на мою думку, тут правильно розділене.

Додаток - вдосконалена версія

Примітка: Ця відповідь нещодавно отримала позитивну оцінку, і я зрозумів, що є кращий спосіб ...

Додавши другу альтернативу до вищезазначеного регулярного виразу, усі тестові випадки OP правильно розділені.

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

Ось як вдосконалений регулярний вираз розділяє приклади даних:

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

Редагувати: 20130824 Додано вдосконалену версію для обробки RCPExt -> RCP / Extсправи.

Іншим рішенням було б використання спеціального методу в commons-lang : StringUtils # splitByCharacterTypeCamelCase

Я не зміг змусити рішення aix працювати (і воно також не працює на RegExr), тому я придумав своє власне, яке я протестував і, схоже, робить саме те, що ви шукаєте:

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

і ось приклад його використання:

; 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)

Тут я розділяю кожне слово пробілом, тому ось кілька прикладів того, як рядок трансформується:

• ThisIsATitleCASEString => Це рядок CASE заголовка
• andThisOneIsCamelCASE => і це КАМЕР КЕЙЛ

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

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

і приклад його використання:

; 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)

І ось кілька прикладів того, як рядок із числами трансформується за допомогою цього регулярного виразу:

• myVariable123 => моя змінна 123
• my2Variables => мої 2 змінні
• The3rdVariableIsHere => Третя змінна вже тут
• 12345NumsAtTheStartIncludedToo => 12345 Номери на початку також включені

Щоб обробити більше листів, ніж просто A-Z:

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

Або:

• Розділити після будь-якої малої літери, після якої йде велика літера.

Наприклад , parseXML-> parse, XML.

або

• Розділити після будь-якої літери, після якої слідують великі та малі літери.

Наприклад , XMLParser-> XML, Parser.

У більш зручній для читання формі:

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"));
    }    
}

Короткий

Обидві найпопулярніші відповіді тут містять код, використовуючи позитивний погляд, який не підтримується усіма варіантами регулярних виразів. Регулярний вираз, наведений нижче, охоплює як PascalCaseі, так camelCaseі може використовуватися різними мовами.

Примітка: Я усвідомлюю, що це питання стосується Java, однак, я також бачу кілька згадувань про цю публікацію в інших питаннях, позначених різними мовами, а також деякі коментарі щодо цього питання щодо того самого.

Код

Подивіться цей регулярний вираз, що використовується тут

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

Результати

Зразок введення

eclipseRCPExt

SomethingIsWrittenHere

TEXTIsWrittenHERE

VALUE

loremIpsum

Зразок результату

eclipse
RCP
Ext

Something
Is
Written
Here

TEXT
Is
Written
HERE

VALUE

lorem
Ipsum

Пояснення

• Зіставте один або кілька великих літер букви [A-Z]+
• Або збігаються з нулем або одним великим літерним символом [A-Z]?, за яким слід один або кілька малих літерних символів[a-z]+
• Переконайтеся, що далі йде символ великого регістру [A-Z]або символ межі слова\b

Ви можете використовувати StringUtils. splitByCharacterTypeCamelCase ("loremIpsum") від Apache Commons Lang.

Ви можете використовувати вираз нижче для Java:

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

Замість того, щоб шукати сепаратори, яких немає, ви можете також розглянути можливість пошуку компонентів імен (вони, безумовно, є):

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);

Це виводить [eclipse, 福福, RCP, Ext]. Перетворення в масив, звичайно, просто.

Я можу підтвердити, що рядок регулярних ([A-Z]+|[A-Z]?[a-z]+)(?=[A-Z]|\b)виразів, вказаний вище ctwheels, працює зі смаком регулярного виразу Microsoft.

Я також хотів би запропонувати наступну альтернативу, засновану на регулярних виразах ctwheels ', який обробляє цифрові символи: ([A-Z0-9]+|[A-Z]?[a-z]+)(?=[A-Z0-9]|\b).

Це може розділити рядки, такі як:

ВодінняB2BTradeIn2019Нагорі

до

Сприяння торгівлі B2B у 2019 році

Рішення 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('!');
};