Convertir des tirets en CamelCase en PHP

Question

Quelqu'un peut-il m'aider à compléter cette fonction PHP? Je veux prendre une chaîne comme ceci: 'this-is-a-string' et le convertir à ceci: 'thisIsAString':

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


    return $string; 
} 

Answer 1

Pas regex ou callbacks nécessaire. Presque tout le travail peut être fait avec 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 vous utilisez PHP> = 5.3, vous pouvez utiliser lcfirst au lieu de strtolower.

Mise à jour

Un second paramètre a été ajouté à ucwords en PHP 5.4.32/5.5.16 qui signifie que nous ne devons d'abord changer les tirets aux espaces (grâce à Lars Ebert et PeterM pour avoir signalé). Voici le code mis à jour:

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

code non testé. Vérifiez les docs PHP pour les fonctions im-/explode et ucfirst.

Answer 3

Je probablement utiliser preg_replace_callback(), comme ceci:

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

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

Answer 4

Essayez ceci:

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

Answer 5

C'est plus simple:

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

Answer 6

c'est ma variation sur la façon de traiter avec elle. Ici, j'ai deux fonctions, la première camelCase transforme n'importe quoi dans un camelCase et il ne gâchera pas si la variable contient déjà cameCase. Seconde uncamelCase transforme camelCase en trait de soulignement (très pratique pour les clés de base de données).

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

permet de tester à la fois:

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

De toute évidence, si un autre delimiter que '-', par exemple '_', est à mettre en correspondance aussi, alors cela ne fonctionnera pas, alors un preg_replace pourrait convertir tous les délimiteurs (consécutifs) à '-' en $ text d'abord ...

Answer 8

Sinon, si vous préférez ne pas traiter avec regex, et que vous voulez éviter explicites boucles:

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

Answer 9

vous cherchez preg_replace_callback, vous pouvez l'utiliser comme ceci:

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

Answer 10

cette fonction est similaire à la fonction @ 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); 
} 

Mais plus clair, (je pense: D) et avec le paramètre optionnel pour mettre en majuscule la première lettre ou non.

Utilisation:

$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

Cela peut se faire très simplement, bu à l'aide ucwords qui accepte delimiter comme param:

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

REMARQUE: besoin php au moins 5.4.32, 5.5. 16

Answer 12

Un revêtement, PHP> = 5.3:

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

Answer 13

Une autre approche simple:

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

Answer 14

Surchargé oneliner, avec wrapper bloc doc ...

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

ici est une solution très très facile dans un code de ligne

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

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

sortie ThisIsAString

Answer 16

Si vous utilisez le framework Laravel, vous pouvez utiliser uniquement la méthode camel_case().

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

Answer 17

La bibliothèque TurboCommons contient un objectif général de la méthode formatCase() dans la classe StringUtils, ce qui vous permet de convertir une chaîne à beaucoup de formats de cas communs, comme CamelCase, UpperCamelCase, lowerCamelCase, snake_case, Titre du cas, et beaucoup plus.

https://github.com/edertone/TurboCommons

Pour l'utiliser, importer le fichier phar à votre projet et:

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

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

// will output 'sNakeCase' 

Answer 18

Voici une autre option:

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

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

    return implode('', $parts); 
}