Konwertuj myślniki na CamelCase w PHP

Question

Czy ktoś może mi pomóc w ukończeniu tej funkcji PHP? Chcę podjąć ciąg tak: 'this-is-a-string' i przekształcić ją w ten sposób: '' thisIsAString:

function dashesToCamelCase($string, $capitalizeFirstCharacter = false) { 
    // Do stuff 


    return $string; 
} 

Answer 1

Nie regex lub wywołania zwrotne konieczne. Prawie cała praca może być wykonywana z ucwords:

function dashesToCamelCase($string, $capitalizeFirstCharacter = false) 
{ 

    $str = str_replace(' ', '', ucwords(str_replace('-', ' ', $string))); 

    if (!$capitalizeFirstCharacter) { 
     $str[0] = strtolower($str[0]); 
    } 

    return $str; 
} 

echo dashesToCamelCase('this-is-a-string'); 

Jeśli używasz PHP> = 5.3, można użyć zamiast lcfirst strtolower.

Aktualizacja

Drugi parametr został dodany do ucwords w PHP 5.04.32/5.5.16 co oznacza, że ​​nie trzeba najpierw zmienić kreski do przestrzeni (dzięki Lars Ebert i peterm za wskazanie tego). Oto zaktualizowany kod:

function dashesToCamelCase($string, $capitalizeFirstCharacter = false) 
{ 

    $str = str_replace('-', '', ucwords($string, '-')); 

    if (!$capitalizeFirstCharacter) { 
     $str = lcfirst($str); 
    } 

    return $str; 
} 

echo dashesToCamelCase('this-is-a-string'); 

Answer 2

$string = explode("-", $string); 
$first = true; 
foreach($string as &$v) { 
    if($first) { 
     $first = false; 
     continue; 
    } 
    $v = ucfirst($v); 
} 
return implode("", $string); 

kod niesprawdzone. Sprawdź dokumentację PHP dla funkcji im-/explode i ucfirst.

Answer 3

I prawdopodobnie używać preg_replace_callback() coś takiego:

function dashesToCamelCase($string, $capitalizeFirstCharacter = false) { 
    return preg_replace_callback("/-[a-zA-Z]/", 'removeDashAndCapitalize', $string); 
} 

function removeDashAndCapitalize($matches) { 
    return strtoupper($matches[0][1]); 
} 

Answer 4

Spróbuj tego:

return preg_replace("/\-(.)/e", "strtoupper('\\1')", $string); 

Answer 5

To jest prostsze:

$string = preg_replace('/-(.?)/e',"strtoupper('$1')", strtolower($string)); 

Answer 6

to moja wariacja na temat sposobów radzenia sobie z nim. Tutaj mam dwie funkcje, pierwsza: camelCase zmienia wszystko w camelCase i nie będzie bałagania, jeśli zmienna już zawiera cameCase. Druga uncamelCase zamienia camelCase w podkreślenie (świetna funkcja przy obsłudze kluczy bazy danych).

function camelCase($str) { 
    $i = array("-","_"); 
    $str = preg_replace('/([a-z])([A-Z])/', "\\1 \\2", $str); 
    $str = preg_replace('@[^a-zA-Z0-9\-_ ]+@', '', $str); 
    $str = str_replace($i, ' ', $str); 
    $str = str_replace(' ', '', ucwords(strtolower($str))); 
    $str = strtolower(substr($str,0,1)).substr($str,1); 
    return $str; 
} 
function uncamelCase($str) { 
    $str = preg_replace('/([a-z])([A-Z])/', "\\1_\\2", $str); 
    $str = strtolower($str); 
    return $str; 
} 

umożliwia badanie obu:

$camel = camelCase("James_LIKES-camelCase"); 
$uncamel = uncamelCase($camel); 
echo $camel." ".$uncamel; 

Answer 7

function camelCase($text) { 
    return array_reduce(
     explode('-', strtolower($text)), 
     function ($carry, $value) { 
      $carry .= ucfirst($value); 
      return $carry; 
     }, 
     ''); 
} 

Oczywiście, jeśli inny niż separator '-', np "_" też ma być dopasowane, to nie zadziała, wtedy preg_replace może zamienić wszystkie (kolejne) ograniczniki na "-" najpierw w $ text ...

Answer 8

Ewentualnie, jeśli nie chcesz handlować z regex, a chcesz uniknąć wyraźne pętle:

// $key = 'some-text', after transformation someText    
$key = lcfirst(implode('', array_map(function ($key) { 
    return ucfirst($key); 
}, explode('-', $key)))); 

Answer 9

Szukacie preg_replace_callback, można go używać tak:

$camelCase = preg_replace_callback('/-(.?)/', function($matches) { 
    return ucfirst($matches[1]); 
}, $dashes); 

Answer 10

ta funkcja jest podobna do funkcji @ Svens męska

function toCamelCase($str, $first_letter = false) { 
    $arr = explode('-', $str); 
    foreach ($arr as $key => $value) { 
     $cond = $key > 0 || $first_letter; 
     $arr[$key] = $cond ? ucfirst($value) : $value; 
    } 
    return implode('', $arr); 
} 

Ale wyraźniej, (myślę: D) i z opcjonalnym parametrem, aby wpisać pierwszą literę lub nie.

Zastosowanie:

$dashes = 'function-test-camel-case'; 
$ex1 = toCamelCase($dashes); 
$ex2 = toCamelCase($dashes, true); 

var_dump($ex1); 
//string(21) "functionTestCamelCase" 
var_dump($ex2); 
//string(21) "FunctionTestCamelCase" 

Answer 11

Można to zrobić w bardzo prosty sposób, za pomocą ucwords bu który akceptuje separator jako param:

function camelize($input, $separator = '_') 
{ 
    return str_replace($separator, '', ucwords($input, $separator)); 
} 

UWAGA: Potrzeba php co najmniej 5.4.32, 5.5. 16

Answer 12

Jedna wkładka, PHP> = 5.3:

$camelCase = lcfirst(join(array_map('ucfirst', explode('-', $url)))); 

Answer 13

Innym prostym podejście:

$nasty = [' ', '-', '"', "'"]; // array of nasty characted to be removed 
$cameled = lcfirst(str_replace($nasty, '', ucwords($string))); 

Answer 14

Przeciążone oneliner z bloku doc ​​owijki ...

/** 
* Convert underscore_strings to camelCase (medial capitals). 
* 
* @param {string} $str 
* 
* @return {string} 
*/ 
function snakeToCamel ($str) { 
    // Remove underscores, capitalize words, squash, lowercase first. 
    return lcfirst(str_replace(' ', '', ucwords(str_replace('_', ' ', $str)))); 
} 

Answer 15

tutaj jest bardzo proste rozwiązanie w kodzie jednej linii

$string='this-is-a-string' ; 

    echo str_replace('-', '', ucwords($string, "-")); 

wyjście ThisIsAString

Answer 16

Jeśli korzystasz z frameworka Laravel, możesz użyć tylko metody camel_case().

camel_case('this-is-a-string') // 'thisIsAString' 

Answer 17

Biblioteka TurboCommons zawiera ogólny cel formatCase() metoda wewnątrz klasy StringUtils, która pozwala przekonwertować ciąg do wielu popularnych formatów przypadków, takich jak CamelCase, UpperCamelCase, LowerCamelCase, snake_case tytuł sprawy, a wiele jeszcze.

https://github.com/edertone/TurboCommons

Aby go użyć, należy zaimportować plik Phar do projektu:

use org\turbocommons\src\main\php\utils\StringUtils; 

echo StringUtils::formatCase('sNake_Case', StringUtils::FORMAT_CAMEL_CASE); 

// will output 'sNakeCase' 

Answer 18

Oto kolejna opcja:

private function camelcase($input, $separator = '-')  
{ 
    $array = explode($separator, $input); 

    $parts = array_map('ucwords', $array); 

    return implode('', $parts); 
}