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

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


    return $string;
}

Aucun regex ou rappel nécessaire. Presque tout le travail peut être effectué 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.

Mettre à jour

Un deuxième paramètre a été ajouté à ucwords dans PHP 5.4.32 / 5.5.16, ce qui signifie que nous n'avons pas besoin de changer d'abord les tirets en espaces (merci à Lars Ebert et PeterM pour l'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');

Cela peut être fait très simplement, en utilisant ucwords qui accepte le délimiteur comme paramètre:

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

REMARQUE: nécessite php au moins 5.4.32, 5.5.16

ceci est ma variation sur la façon de gérer cela. Ici, j'ai deux fonctions, la première camelCase transforme quoi que ce soit en camelCase et il ne gâchera pas si la variable contient déjà cameCase. Le second uncamelCase transforme camelCase en trait de soulignement (fonctionnalité intéressante 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;
}

testons les deux:

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

Monotouche surchargé, avec 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))));
}

J'utiliserais probablement 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]);
}

Vous recherchez preg_replace_callback , vous pouvez l'utiliser comme ceci:

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

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

echo ($this->camelize('someWeir-d-string'));
// output: 'someWeirdString';

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

Code non testé. Consultez la documentation PHP pour les fonctions im- / explode et ucfirst.

Une ligne, PHP> = 5.3:

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

voici une solution très très simple en une seule ligne de code

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

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

production ThisIsAString

Alternativement, si vous préférez ne pas gérer les regex et que vous voulez éviter les boucles explicites :

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

Une autre approche simple:

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

La bibliothèque TurboCommons contient une méthode formatCase () à usage général dans la classe StringUtils, qui vous permet de convertir une chaîne en de nombreux formats de cas courants, tels que CamelCase, UpperCamelCase, LowerCamelCase, snake_case, Title Case, et bien d'autres.

https://github.com/edertone/TurboCommons

Pour l'utiliser, importez le fichier phar dans votre projet et:

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

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

// will output 'sNakeCase'

Voici le lien vers le code source de la méthode:

https://github.com/edertone/TurboCommons/blob/b2e015cf89c8dbe372a5f5515e7d9763f45eba76/TurboCommons-Php/src/main/php/utils/StringUtils.php#L653

Essaye ça:

$var='snake_case';
echo ucword($var,'_');

Production:

Snake_Case remove _ with str_replace

Dans Laravel utiliser Str::camel()

use Illuminate\Support\Str;

$converted = Str::camel('foo_bar');

// fooBar

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

Évidemment, si un autre délimiteur que '-', par exemple '_', doit être mis en correspondance également, cela ne fonctionnera pas, alors un preg_replace pourrait convertir tous les délimiteurs (consécutifs) en '-' dans $ text d'abord ...

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

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

Usage:

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

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

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

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

Voici une autre option:

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

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

    return implode('', $parts);
}

$stringWithDash = 'Pending-Seller-Confirmation'; $camelize = str_replace('-', '', ucwords($stringWithDash, '-')); echo $camelize; sortie: PendingSellerConfirmation

ucwordsLe deuxième paramètre (facultatif) aide à identifier un séparateur pour caméliser la chaîne. str_replaceest utilisé pour finaliser la sortie en supprimant le séparateur.

Voici une petite fonction d'assistance utilisant une approche fonctionnelle array_reduce . Nécessite au moins PHP 7.0

private function toCamelCase(string $stringToTransform, string $delimiter = '_'): string
{
    return array_reduce(
        explode($delimiter, $stringToTransform),
        function ($carry, string $part): string {
            return $carry === null ? $part: $carry . ucfirst($part);
        }
    );
}

Beaucoup de bonnes solutions ci-dessus, et je peux fournir une manière différente que personne ne mentionne auparavant. Cet exemple utilise array. J'utilise cette méthode sur mon projet Shieldon Firewall .

/**
 * Covert string with dashes into camel-case string.
 *
 * @param string $string A string with dashes.
 *
 * @return string
 */
function getCamelCase(string $string = '')
{
    $str = explode('-', $string);
    $str = implode('', array_map(function($word) {
        return ucwords($word); 
    }, $str));

    return $str;
}

Essaye-le:

echo getCamelCase('This-is-example');

Résultat:

ThisIsExample

Essaye ça:

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

C'est plus simple:

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