Convertir guiones en CamelCase en PHP

Question

¿Alguien me puede ayudar a completar esta función de PHP? Quiero tomar una cadena como esta: 'this-is-a-cadena' y convertirlo a esto: 'thisIsAString':

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


    return $string; 
} 

Answer 1

Sin expresiones regulares o devoluciones de llamada es necesario. Casi todo el trabajo se puede hacer con 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'); 

Si está usando PHP> = 5.3, se puede utilizar en lugar de lcfirst strtolower.

actualización

Un segundo parámetro se añadió a ucwords en PHP 4.5.32/5.5.16 lo que significa que no tenemos que cambiar primero los guiones a los espacios (gracias a Lars Ebert y PeterM por señalar esto) Aquí está el código de actualización:

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

código no probado. Compruebe los documentos PHP para las funciones im-/explode y ucfirst.

Answer 3

utilizaría probablemente preg_replace_callback(), así:

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

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

Answer 4

Prueba esto:

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

Answer 5

Esto es más sencillo:

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

Answer 6

esta es mi variación sobre cómo tratar con él. Aquí tengo dos funciones, la primera camelCase convierte cualquier cosa en un camelCase y no se ensuciará si la variable ya contiene cameCase. La segunda uncamelCase convierte camelCase en guión bajo (gran característica cuando se trata de claves de bases de datos).

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

permite tanto la prueba:

$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; 
     }, 
     ''); 
} 

Obviamente, si otro delimitador de '-', por ejemplo, '_', debe coincidir también, entonces esto no funcionará, entonces un preg_replace podría convertir todos los delimitadores (consecutivos) a '-' en $ text primero ...

Answer 8

Alternativamente, si prefiere no tratar con expresiones regulares, y desea evitar explícitas bucles:

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

Answer 9

usted está buscando preg_replace_callback, se puede utilizar de esta manera:

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

Answer 10

esta función es similar a la función de @ Svens

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

Pero más claro, (creo que: D) y con el parámetro opcional para mayúscula o no en la primera letra.

Uso:

$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

Esto se puede hacer de manera muy sencilla, utilizando bu ucwords delimitador que acepta como parámetro:

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

NOTA: Necesita al menos php 4.5.32, 5.5. 16

Answer 12

Un forro, PHP> = 5,3:

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

Answer 13

Otro enfoque simple:

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

Answer 14

oneliner sobrecargado, con el bloque doc envoltorio ...

/** 
* 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

aquí es solución muy muy fácil de código de una línea

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

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

salida ThisIsAString

Answer 16

Si usa Laravel framework, puede usar el método camel_case().

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

Answer 17

La biblioteca TurboCommons contiene un propósito general formatCase() método dentro de la clase StringUtils, que permite convertir una cadena a una gran cantidad de formatos de casos comunes, como CamelCase, UpperCamelCase, LowerCamelCase, snake_case, Título del caso, y muchos Más.

https://github.com/edertone/TurboCommons

Para usarlo, importar el archivo Phar a su proyecto y:

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

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

// will output 'sNakeCase' 

Answer 18

Aquí hay otra opción:

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

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

    return implode('', $parts); 
}