Kann mir jemand helfen, diese PHP-Funktion zu vervollständigen? Ich möchte einen String wie diesen nehmen: 'this-is-a-string' und ihn in folgenden konvertieren: 'thisIsAString':

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


    return $string;
}

Keine Regex oder Rückrufe erforderlich. Fast die gesamte Arbeit kann mit ucwords erledigt werden:

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

Wenn Sie PHP> = 5.3 verwenden, können Sie lcfirst anstelle von strtolower verwenden.

Aktualisieren

In PHP 5.4.32 / 5.5.16 wurde ucwords ein zweiter Parameter hinzugefügt, was bedeutet, dass wir die Striche nicht zuerst in Leerzeichen ändern müssen (danke an Lars Ebert und PeterM für diesen Hinweis). Hier ist der aktualisierte Code:

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

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

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

    return $str;
}

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

Dies kann sehr einfach durch Verwendung von ucwords erfolgen, die ein Trennzeichen als Parameter akzeptieren:

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

Hinweis: Benötigen Sie mindestens php 5.4.32, 5.5.16

Dies ist meine Variation, wie ich damit umgehen soll. Hier habe ich zwei Funktionen, zuerst verwandelt eine camelCase alles in eine camelCase und es wird nicht durcheinander kommen, wenn die Variable bereits comeCase enthält. Das zweite uncamelCase verwandelt camelCase in einen Unterstrich (großartige Funktion beim Umgang mit Datenbankschlüsseln).

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

Lassen Sie uns beide testen:

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

Überladener Einzeiler mit Dokumentblock ...

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

Ich würde wahrscheinlich so verwenden preg_replace_callback():

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

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

Sie suchen nach preg_replace_callback , Sie können es folgendermaßen verwenden:

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

Ungetesteter Code. Überprüfen Sie die PHP-Dokumente auf die Funktionen im- / explode und ucfirst.

Ein Liner, PHP> = 5,3:

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

Alternativ, wenn Sie es vorziehen, sich nicht mit Regex zu befassen und explizite Schleifen vermeiden möchten :

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

Ein weiterer einfacher Ansatz:

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

Hier ist eine sehr sehr einfache Lösung in einem Zeilencode

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

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

Ausgabe ThisIsAString

Die TurboCommons-Bibliothek enthält eine allgemeine formatCase () -Methode innerhalb der StringUtils-Klasse, mit der Sie eine Zeichenfolge in viele gängige Groß- und Kleinschreibung konvertieren können, z. B. CamelCase, UpperCamelCase, LowerCamelCase, snake_case, Title Case und viele mehr.

https://github.com/edertone/TurboCommons

Um es zu verwenden, importieren Sie die Phar-Datei in Ihr Projekt und:

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

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

// will output 'sNakeCase'

Hier ist der Link zum Methodenquellcode:

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

Versuche dies:

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

Ausgabe:

Snake_Case remove _ with str_replace

In Laravel verwenden 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;
         },
         '');
}

Wenn ein anderes Trennzeichen als '-', z. B. '_', ebenfalls übereinstimmen soll, funktioniert dies natürlich nicht. Dann könnte ein preg_replace alle (aufeinanderfolgenden) Trennzeichen zuerst in $ - 'in $ text konvertieren ...

Diese Funktion ähnelt der Funktion von @ 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);
}

Aber klarer (ich denke: D) und mit dem optionalen Parameter, um den ersten Buchstaben groß zu schreiben oder nicht.

Verwendung:

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

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

Wenn Sie das Laravel-Framework verwenden, können Sie nur die Methode camel_case () verwenden.

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

Hier ist eine weitere 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; Ausgabe: PendingSellerConfirmation

ucwordsDer zweite (optionale) Parameter hilft bei der Identifizierung eines Trennzeichens zum Kamelisieren der Zeichenfolge. str_replacewird verwendet, um die Ausgabe durch Entfernen des Trennzeichens abzuschließen.

Hier ist eine kleine Hilfsfunktion, die einen funktionalen array_reduce- Ansatz verwendet. Benötigt mindestens 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);
        }
    );
}

Viele gute Lösungen oben, und ich kann einen anderen Weg anbieten, den noch niemand erwähnt hat. In diesem Beispiel wird ein Array verwendet. Ich verwende diese Methode in meinem Projekt 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;
}

Probier es aus:

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

Ergebnis:

ThisIsExample

Versuche dies:

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

Das ist einfacher:

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