it-roy-ru.com

Разбейте слово верблюда на слова с помощью php preg_match (Regular Expression)

Как бы я пошел о разделении Слова:

oneTwoThreeFour

в массив, чтобы я мог получить:

one Two Three Four

с preg_match?

Я устал от этого, но это просто дает все Слово

$words = preg_match("/[a-zA-Z]*(?:[a-z][a-zA-Z]*[A-Z]|[A-Z][a-zA-Z]*[a-z])[a-zA-Z]*\b/", $string, $matches)`;
59
Good-bye

Вы также можете использовать preg_match_all как:

preg_match_all('/((?:^|[A-Z])[a-z]+)/',$str,$matches);

Объяснение:

(        - Start of capturing parenthesis.
 (?:     - Start of non-capturing parenthesis.
  ^      - Start anchor.
  |      - Alternation.
  [A-Z]  - Any one capital letter.
 )       - End of non-capturing parenthesis.
 [a-z]+  - one ore more lowercase letter.
)        - End of capturing parenthesis.
74
codaddict

Вы можете использовать preg_split как:

$arr = preg_split('/(?=[A-Z])/',$str);

Видеть это

Я в основном разбиваю входную строку непосредственно перед заглавной буквой. Используемое регулярное выражение (?=[A-Z]) соответствует точке непосредственно перед заглавной буквой.

65
codaddict

Я знаю, что это старый вопрос с принятым ответом, но ИМХО есть лучшее решение:

<?php // test.php Rev:20140412_0800
$ccWord = 'NewNASAModule';
$re = '/(?#! splitCamelCase Rev:20140412)
    # Split camelCase "words". Two global alternatives. Either g1of2:
      (?<=[a-z])      # Position is after a lowercase,
      (?=[A-Z])       # and before an uppercase letter.
    | (?<=[A-Z])      # Or g2of2; Position is after uppercase,
      (?=[A-Z][a-z])  # and before upper-then-lower case.
    /x';
$a = preg_split($re, $ccWord);
$count = count($a);
for ($i = 0; $i < $count; ++$i) {
    printf("Word %d of %d = \"%s\"\n",
        $i + 1, $count, $a[$i]);
}
?>

Обратите внимание, что это регулярное выражение (как и решение '/(?=[A-Z])/' от codaddict, которое работает как талисман для правильно сформированных слов camelCase), соответствует только position в строке и вообще не потребляет текст. Это решение имеет дополнительное преимущество, заключающееся в том, что оно также работает корректно для плохо сформированных псевдо-верблюжьих слов, таких как: StartsWithCap и: hasConsecutiveCAPS.

Входные данные:

oneTwoThreeFour
StartsWithCap
hasConsecutiveCAPS
NewNASAModule 

Результат:

Word 1 of 4 = "one"
Word 2 of 4 = "Two"
Word 3 of 4 = "Three"
Word 4 of 4 = "Four" 

Word 1 of 3 = "Starts"
Word 2 of 3 = "With"
Word 3 of 3 = "Cap" 

Word 1 of 3 = "has"
Word 2 of 3 = "Consecutive"
Word 3 of 3 = "CAPS" 

Word 1 of 3 = "New"
Word 2 of 3 = "NASA"
Word 3 of 3 = "Module" 

Отредактировано: 2014-04-12: Изменено регулярное выражение, сценарий и тестовые данные для правильного разделения: "NewNASAModule" case (в ответ на комментарий rr).

49
ridgerunner

Функциональная версия ответа @ ridgerunner.

/**
 * Converts camelCase string to have spaces between each.
 * @param $camelCaseString
 * @return string
 */
function fromCamelCase($camelCaseString) {
        $re = '/(?<=[a-z])(?=[A-Z])/x';
        $a = preg_split($re, $camelCaseString);
        return join($a, " " );
}
11
blak3r

Несмотря на то, что ответ Ridgerunner работает отлично, похоже, он не работает с подстроками со всеми заглавными буквами, которые появляются в середине предложения. Я использую следующее, и, похоже, с этим все в порядке:

function splitCamelCase($input)
{
    return preg_split(
        '/(^[^A-Z]+|[A-Z][^A-Z]+)/',
        $input,
        -1, /* no limit for replacement count */
        PREG_SPLIT_NO_EMPTY /*don't return empty elements*/
            | PREG_SPLIT_DELIM_CAPTURE /*don't strip anything from output array*/
    );
}

Некоторые тестовые случаи:

assert(splitCamelCase('lowHigh') == ['low', 'High']);
assert(splitCamelCase('WarriorPrincess') == ['Warrior', 'Princess']);
assert(splitCamelCase('SupportSEELE') == ['Support', 'SEELE']);
assert(splitCamelCase('LaunchFLEIAModule') == ['Launch', 'FLEIA', 'Module']);
assert(splitCamelCase('anotherNASATrip') == ['another', 'NASA', 'Trip']);
10
rr-
$string = preg_replace( '/([a-z0-9])([A-Z])/', "$1 $2", $string );

Уловка - это повторяющийся шаблон $ 1 $ 2 $ 1 $ 2 или ниже UPPERlower UPPERlower и т.д. .... Например HelloWorld = $ 1 соответствует "привет", $ 2 соответствует "W", а $ 1 соответствует "orld" снова, так что короче Вы получаете $ 1 $ 2 $ 1 или «Hello World», соответствует HelloWorld как $ 2 $ 1 $ 2 $ 1 или снова «Hello World». Затем вы можете использовать строчные буквы в верхнем регистре первого слова Word или разбить их на пробел, или использовать _ или какой-либо другой символ, чтобы разделить их.

Коротко и просто.

5
ArtisticPheonix

Я взял код классного парня Риджеруннера (см. Выше) и превратил его в функцию:

echo deliciousCamelcase('NewNASAModule');

function deliciousCamelcase($str)
{
    $formattedStr = '';
    $re = '/
          (?<=[a-z])
          (?=[A-Z])
        | (?<=[A-Z])
          (?=[A-Z][a-z])
        /x';
    $a = preg_split($re, $str);
    $formattedStr = implode(' ', $a);
    return $formattedStr;
}

Это вернет: New NASA Module

2
Jarrod

При определении наилучшего шаблона для вашего проекта вам необходимо учитывать следующие факторы шаблона:

  1. Точность (робастность) - является ли модель правильной во всех случаях и является ли она обоснованной на будущее
  2. Эффективность - шаблон должен быть прямым, обдуманным и избегать ненужного труда
  3. Краткость - шаблон должен использовать соответствующие методы, чтобы избежать ненужной длины символов
  4. Читаемость - шаблон должен быть максимально простым

Вышеперечисленные факторы также оказываются в иерархическом порядке, который стремится подчиняться. Другими словами, для меня не имеет большого смысла расставлять приоритеты 2, 3 или 4, когда 1 не совсем удовлетворяет требованиям. Читаемость находится внизу списка для меня, потому что в большинстве случаев я могу следовать синтаксису.

Группы захвата и Lookarounds часто влияют на эффективность шаблона. Правда в том, что если вы не выполняете это регулярное выражение для тысяч входных строк, вам не нужно трудиться над эффективностью. Возможно, более важно сосредоточиться на удобочитаемости шаблона, что может быть связано с краткостью шаблона.

Для некоторых шаблонов ниже потребуется дополнительная обработка/пометка с помощью их функции preg_, но вот некоторые сравнения шаблонов, основанные на вводе образца OP:

Шаблоны preg_split():

  • /^[^A-Z]+\K|[A-Z][^A-Z]+\K/ (21 шаг)
  • /(^[^A-Z]+|[A-Z][^A-Z]+)/ (26 шагов)
  • /[^A-Z]+\K(?=[A-Z])/ (43 шага)
  • /(?=[A-Z])/ (50 шагов)
  • /(?=[A-Z]+)/ (50 шагов)
  • /([a-z]{1})[A-Z]{1}/ (53 шага)
  • /([a-z0-9])([A-Z])/ (68 шагов)
  • /(?<=[a-z])(?=[A-Z])/x (94 шага) ... для записи x бесполезен.
  • /(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/ (134 шага)

Шаблоны preg_match_all():

  • /[A-Z]?[a-z]+/ (14 шагов)
  • /((?:^|[A-Z])[a-z]+)/ (35 шагов)

Я укажу, что между выводами preg_match_all() и preg_split() есть небольшая разница. preg_match_all() выведет 2-мерный массив, другими словами, все совпадения полной строки будут находиться в подмассиве [0]; если используется группа захвата, эти подстроки будут находиться в подмассиве [1]. С другой стороны, preg_split() выводит только одномерный массив и, следовательно, обеспечивает менее раздутый и более прямой путь к желаемому результату.

Некоторые шаблоны недостаточны при работе со строками camelCase, которые содержат в себе подстроку ALLCAPS/акроним. Если это ограниченный случай, который возможен в вашем проекте, логично рассматривать только шаблоны, которые правильно обрабатывают эти случаи. Я не буду тестировать строки ввода TitleCase, потому что это слишком далеко от вопроса.

Новая расширенная батарея тестовых строк:

oneTwoThreeFour
hasConsecutiveCAPS
newNASAModule
USAIsGreatAgain 

Подходящие preg_split() шаблоны:

  • /[a-z]+\K|(?=[A-Z][a-z]+)/ (149 шагов) * Мне пришлось использовать [a-z] для демо, чтобы правильно считать
  • /(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/ (547 шагов)

Подходящий шаблон preg_match_all():

  • /[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|$)/ (75 шагов)

Наконец, мои рекомендации основаны на моих шаблонных принципах/факторной иерархии. Кроме того, я рекомендую preg_split() over preg_match_all() (несмотря на то, что шаблоны имеют меньше шагов) в качестве непосредственного направления к желаемой структуре вывода. (конечно, выбирай что хочешь)

Код: ( Демо )

$noAcronyms = 'oneTwoThreeFour';
var_export(preg_split('~^[^A-Z]+\K|[A-Z][^A-Z]+\K~', $noAcronyms, 0, PREG_SPLIT_NO_EMPTY));
echo "\n---\n";
var_export(preg_match_all('~[A-Z]?[^A-Z]+~', $noAcronyms, $out) ? $out[0] : []);

Код: ( Демо )

$withAcronyms = 'newNASAModule';
var_export(preg_split('~[^A-Z]+\K|(?=[A-Z][^A-Z]+)~', $withAcronyms, 0, PREG_SPLIT_NO_EMPTY));
echo "\n---\n";
var_export(preg_match_all('~[A-Z]?[^A-Z]+|[A-Z]+(?=[A-Z][^A-Z]|$)~', $withAcronyms, $out) ? $out[0] : []);
1
mickmackusa

Другой вариант соответствует /[A-Z]?[a-z]+/ - если вы знаете, что ваш ввод в правильном формате, он должен работать хорошо.

[A-Z]? будет соответствовать заглавной букве (или ничего). [a-z]+ будет соответствовать всем следующим строчным буквам до следующего соответствия.

Рабочий пример: https://regex101.com/r/kNZfEI/1

1
Kobi

Полная функция, основанная на ответе @codaddict:

function splitCamelCase($str) {
    $splitCamelArray = preg_split('/(?=[A-Z])/', $str);

    return ucwords(implode($splitCamelArray, ' '));
}
0
guizo

Может быть, мой вопрос может помочь вам. Я вчера спросил то же самое, но о Java

разбить строки на символы в верхнем регистре

0
pringlesinn

Вы можете разделить «скольжение» из строчных в прописные таким образом:

$parts = preg_split('/([a-z]{1})[A-Z]{1}/', $string, -1, PREG_SPLIT_DELIM_CAPTURE);        
//PREG_SPLIT_DELIM_CAPTURE to also return bracketed things
var_dump($parts);

Досадно, что тогда вам придется перестраивать слова из каждой соответствующей пары предметов в $ parts

Надеюсь это поможет

0
Daniel Rhodes

Прежде всего, спасибо за ваш шаблон, это очень помогло!

Мне нужно решение, которое работает, если существует предлог «а»:

например thisIsACamelcaseSentence.

Я нашел решение, выполнив два шага preg_match, и сделал функцию с некоторыми опциями: 

/*
 * input: 'thisIsACamelCaseSentence' output: 'This Is A Camel Case Sentence'
 * options $case: 'allUppercase'[default] >> 'This Is A Camel Case Sentence'
 *                'allLowerCase'          >> 'this is a camel case sentence'
 *                'firstUpperCase'        >> 'This is a camel case sentence'
 * @return: string
 */

function camelCaseToWords($string, $case = null){
    isset($case) ? $case = $case : $case = 'allUpperCase';

    // Find first occurances of two capitals
    preg_match_all('/((?:^|[A-Z])[A-Z]{1})/',$string, $twoCapitals);

    // Split them with the 'zzzzzz' string. e.g. 'AZ' turns into 'AzzzzzzZ'
    foreach($twoCapitals[0] as $match){
        $firstCapital = $match[0];
        $lastCapital = $match[1];
        $temp = $firstCapital.'zzzzzz'.$lastCapital;
        $string = str_replace($match, $temp, $string);  
    }

    // Now split words
    preg_match_all('/((?:^|[A-Z])[a-z]+)/', $string, $words);

    $output = "";
    $i = 0;
    foreach($words[0] as $Word){

            switch($case){
                case 'allUpperCase':
                $Word = ucfirst($Word);
                break;

                case 'allLowerCase': 
                $Word = strtolower($Word);
                break;

                case 'firstUpperCase':
                ($i == 0) ? $Word = ucfirst($Word) : $Word = strtolower($Word);
                break;                  
            }

            // remove te 'zzzzzz' from a Word if it has
            $Word = str_replace('zzzzzz','', $Word);    
            $output .= $Word." ";
            $i++;
    }
    return $output; 
}

Не стесняйтесь использовать его, и если есть «более простой» способ сделать это за один шаг, пожалуйста, прокомментируйте!

0
joronimo