Dapatkah seseorang membantu saya menyelesaikan fungsi PHP ini? Saya ingin mengambil string seperti ini: 'this-is-a-string' dan mengubahnya menjadi ini: 'thisIsAString':

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


    return $string;
}

Tidak perlu regex atau callback. Hampir semua pekerjaan bisa dilakukan dengan 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');

Jika Anda menggunakan PHP> = 5.3, Anda dapat menggunakan lcfirst sebagai ganti strtolower.

Memperbarui

Parameter kedua telah ditambahkan ke ucwords di PHP 5.4.32 / 5.5.16 yang berarti kita tidak perlu terlebih dahulu mengubah tanda hubung ke spasi (terima kasih kepada Lars Ebert dan PeterM untuk menunjukkan hal ini). Ini kode yang diperbarui:

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

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

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

    return $str;
}

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

Ini dapat dilakukan dengan sangat sederhana, dengan menggunakan ucwords yang menerima pembatas sebagai param:

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

CATATAN: Membutuhkan php setidaknya 5.4.32, 5.5.16

ini adalah variasi saya tentang cara menghadapinya. Di sini saya memiliki dua fungsi, pertama camelCase mengubah apapun menjadi camelCase dan tidak akan berantakan jika variabel sudah berisi cameCase. UncamelCase kedua mengubah camelCase menjadi garis bawah (fitur hebat saat menangani kunci database).

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

mari kita uji keduanya:

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

Satu baris kelebihan beban, dengan blok dokumen ...

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

Saya mungkin akan menggunakan preg_replace_callback(), seperti ini:

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

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

Anda mencari preg_replace_callback , Anda dapat menggunakannya seperti ini:

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

Kode yang belum teruji. Periksa dokumen PHP untuk mengetahui fungsi im- / explode dan ucfirst.

Satu liner, PHP> = 5.3:

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

di sini adalah solusi yang sangat mudah dalam kode satu baris

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

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

keluaran ThisIsAString

Atau, jika Anda memilih untuk tidak menggunakan regex, dan ingin menghindari loop eksplisit :

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

Pendekatan sederhana lainnya:

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

Pustaka TurboCommons berisi metode formatCase () tujuan umum di dalam kelas StringUtils, yang memungkinkan Anda mengonversi string ke banyak format kasus umum, seperti CamelCase, UpperCamelCase, LowerCamelCase, snake_case, Title Case, dan banyak lagi.

https://github.com/edertone/TurboCommons

Untuk menggunakannya, impor file phar ke proyek Anda dan:

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

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

// will output 'sNakeCase'

Berikut tautan ke kode sumber metode:

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

Coba ini:

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

Keluaran:

Snake_Case remove _ with str_replace

Dalam penggunaan Laravel 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;
         },
         '');
}

Jelasnya, jika pembatas lain selain '-', misalnya '_', harus dicocokkan juga, maka ini tidak akan berfungsi, maka preg_replace dapat mengonversi semua pembatas (berturut-turut) menjadi '-' dalam $ text terlebih dahulu ...

Fungsi ini mirip dengan fungsi @ 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);
}

Tapi yang lebih jelas, (menurut saya: D) dan dengan parameter opsional untuk mengkapitalisasi huruf pertama atau tidak.

Pemakaian:

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

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

Jika Anda menggunakan framework Laravel, Anda dapat menggunakan metode camel_case () saja .

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

Ini opsi lain:

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; keluaran: PendingSellerConfirmation

ucwordsparameter kedua (opsional) membantu dalam mengidentifikasi pemisah untuk menjadikan string camelize. str_replacedigunakan untuk menyelesaikan keluaran dengan melepas pemisah.

Berikut adalah fungsi pembantu kecil menggunakan pendekatan fungsional array_reduce . Membutuhkan setidaknya 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);
        }
    );
}

Banyak solusi bagus di atas, dan saya bisa memberikan cara berbeda yang belum ada yang menyebutkan sebelumnya. Contoh ini menggunakan array. Saya menggunakan metode ini pada proyek saya 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;
}

Menguji:

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

Hasil:

ThisIsExample

Coba ini:

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

Ini lebih sederhana:

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