Ai đó có thể giúp tôi hoàn thành chức năng PHP này không? Tôi muốn lấy một chuỗi như sau: 'this-is-a-string' và chuyển đổi nó thành sau: 'thisIsAString':

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


    return $string;
}

Không cần regex hoặc gọi lại. Hầu như tất cả công việc có thể được thực hiện với 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');

Nếu bạn đang sử dụng PHP> = 5.3, bạn có thể sử dụng lcfirst thay vì strtolower.

Cập nhật

Tham số thứ hai đã được thêm vào ucwords trong PHP 5.4.32 / 5.5.16, có nghĩa là trước tiên chúng ta không cần thay đổi dấu gạch ngang thành dấu cách (cảm ơn Lars Ebert và PeterM đã chỉ ra điều này). Đây là mã được cập nhật:

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

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

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

    return $str;
}

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

Điều này có thể được thực hiện rất đơn giản, bằng cách sử dụng ucwords chấp nhận dấu phân cách là tham số:

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

LƯU Ý: Cần php ít nhất là 5.4.32, 5.5.16

đây là biến thể của tôi về cách đối phó với nó. Ở đây tôi có hai hàm, một là camelCase biến bất cứ thứ gì thành camelCase và nó sẽ không gây rối nếu biến đã chứa cameCase. UnamelCase thứ hai biến camelCase thành dấu gạch dưới (tính năng tuyệt vời khi xử lý các khóa cơ sở dữ liệu).

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

hãy kiểm tra cả hai:

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

Một lớp lót quá tải, với khối tài liệu ...

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

Tôi có thể sẽ sử dụng preg_replace_callback(), như thế này:

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

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

Bạn đang tìm kiếm preg_replace_callback , bạn có thể sử dụng nó như sau:

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

Mã chưa được kiểm tra. Kiểm tra tài liệu PHP để biết các hàm im- / boom và ucfirst.

Một lớp lót, PHP> = 5,3:

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

đây là giải pháp rất dễ dàng trong một mã dòng

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

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

xuất ThisIsAString

Ngoài ra, nếu bạn không muốn đối phó với regex và muốn tránh các vòng lặp rõ ràng :

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

Một cách tiếp cận đơn giản khác:

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

Thư viện TurboCommons chứa một phương thức formatCase () có mục đích chung bên trong lớp StringUtils, cho phép bạn chuyển đổi một chuỗi thành nhiều định dạng trường hợp phổ biến, như CamelCase, UpperCamelCase, LowerCamelCase, solid_case, Title Case và nhiều định dạng khác.

https://github.com/edertone/TurboCommons

Để sử dụng nó, hãy nhập tệp phar vào dự án của bạn và:

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

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

// will output 'sNakeCase'

Đây là liên kết đến mã nguồn của phương pháp:

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

Thử đi:

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

Đầu ra:

Snake_Case remove _ with str_replace

Trong sử dụng 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;
         },
         '');
}

Rõ ràng, nếu một dấu phân cách khác với '-', ví dụ: '_', cũng được so khớp, thì điều này sẽ không hoạt động, khi đó một preg_replace có thể chuyển đổi tất cả các dấu phân tách (liên tiếp) thành '-' trong $ text trước ...

Chức năng này tương tự như chức năng của @ 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);
}

Nhưng rõ ràng hơn, (tôi nghĩ: D) và với tham số tùy chọn để viết hoa chữ cái đầu tiên hay không.

Sử dụng:

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

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

Nếu bạn sử dụng khuôn khổ Laravel, bạn có thể chỉ sử dụng phương thức camel_case () .

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

Đây là một tùy chọn khác:

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; đầu ra: PendingSellerConfirmation

ucwordstham số thứ hai (tùy chọn) giúp xác định một dấu phân cách để camelize chuỗi. str_replaceđược sử dụng để hoàn thiện đầu ra bằng cách loại bỏ dấu phân cách.

Đây là một hàm trợ giúp nhỏ sử dụng cách tiếp cận function_reduce . Yêu cầu ít nhất 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);
        }
    );
}

Nhiều giải pháp tốt ở trên, và tôi có thể cung cấp một cách khác mà trước đây chưa ai đề cập đến. Ví dụ này sử dụng mảng. Tôi sử dụng phương pháp này trên Tường lửa Shieldon dự án của mình .

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

Kiểm tra nó:

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

Kết quả:

ThisIsExample

Thử đi:

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

Điều này đơn giản hơn:

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