क्या कोई इस PHP फंक्शन को पूरा करने में मेरी मदद कर सकता है? मैं इस तरह एक स्ट्रिंग लेना चाहता हूं: 'यह-यह-एक-स्ट्रिंग' और इसे इस में परिवर्तित करें: 'thisIsASring':
function dashesToCamelCase($string, $capitalizeFirstCharacter = false) {
// Do stuff
return $string;
}
जवाबों:
कोई रेगेक्स या कॉलबैक आवश्यक नहीं है। लगभग सभी काम 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');
यदि आप PHP> = 5.3 का उपयोग कर रहे हैं, तो आप स्ट्रेटोलॉवर के बजाय lcfirst का उपयोग कर सकते हैं।
PHP 5.4.32 / 5.5.16 में एक दूसरे पैरामीटर को ucwords में जोड़ा गया था, जिसका अर्थ है कि हमें पहले डैश को रिक्त स्थान में बदलने की आवश्यकता नहीं है (इसे इंगित करने के लिए लार्स एबर्ट और पीटरम के लिए धन्यवाद)। यहाँ अद्यतन कोड है:
function dashesToCamelCase($string, $capitalizeFirstCharacter = false)
{
$str = str_replace('-', '', ucwords($string, '-'));
if (!$capitalizeFirstCharacter) {
$str = lcfirst($str);
}
return $str;
}
echo dashesToCamelCase('this-is-a-string');
ucwordsवास्तव में एक परिसीमन को दूसरे पैरामीटर के रूप में स्वीकार करता है ( पीटरएम द्वारा उत्तर देखें ), इसलिए str_replaceकॉल में से एक अनावश्यक होगा।
$str = ! $capitalizeFirstCharacter ? lcfirst($str) : $str;मुख्य रूप से पठनीयता (हालांकि कुछ असहमत हो सकती है) और / या कोड जटिलता को कम करने के लिए टर्नरी ऑपरेटर के उपयोग के साथ फिर से लिखा जा सकता है।
इससे निपटने के तरीके के बारे में मेरी भिन्नता है। यहाँ मेरे पास दो कार्य हैं, पहला एक कैमकेले , एक कैमसेल में कुछ भी बदल जाता है और अगर पहले से ही कैमकेस होता है तो यह गड़बड़ नहीं करेगा। दूसरा अनमेलकैस कैमलकेस को अंडरस्कोर (महान कुंजी जब डेटाबेस कुंजी के साथ काम करता है) में बदल देता है।
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;
}
दोनों का परीक्षण करने देता है:
$camel = camelCase("James_LIKES-camelCase");
$uncamel = uncamelCase($camel);
echo $camel." ".$uncamel;
डॉक ब्लॉक के साथ एक-लाइनर, अतिभारित ...
/**
* 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))));
}
null
return... अपडेट किया गया, धन्यवाद। यहाँ इस लिंक को 3v4l.org/YBHPd
मैं शायद 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]);
}
आप preg_replace_callback की तलाश में हैं , आप इसे इस तरह उपयोग कर सकते हैं:
$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='this-is-a-string' ;
echo str_replace('-', '', ucwords($string, "-"));
आउटपुट ThisIsAString
वैकल्पिक रूप से, यदि आप रेगेक्स से निपटना पसंद नहीं करते हैं, और स्पष्ट छोरों से बचना चाहते हैं :
// $key = 'some-text', after transformation someText
$key = lcfirst(implode('', array_map(function ($key) {
return ucfirst($key);
}, explode('-', $key))));
एक और सरल दृष्टिकोण:
$nasty = [' ', '-', '"', "'"]; // array of nasty characted to be removed
$cameled = lcfirst(str_replace($nasty, '', ucwords($string)));
TurboCommons लाइब्रेरी में StringUtils वर्ग के अंदर एक सामान्य उद्देश्य प्रारूपकैश () पद्धति है, जो आपको कई स्ट्रिंग के सामान्य प्रारूप, जैसे कि CamelCase, UpperCamelCase, LowerCamelCase, snake_case, Title Case, और कई और अधिक में कनवर्ट करने देता है।
https://github.com/edertone/TurboCommons
इसका उपयोग करने के लिए, अपनी परियोजना के लिए चरण फ़ाइल आयात करें और:
use org\turbocommons\src\main\php\utils\StringUtils;
echo StringUtils::formatCase('sNake_Case', StringUtils::FORMAT_CAMEL_CASE);
// will output 'sNakeCase'
यहां विधि स्रोत कोड का लिंक दिया गया है:
इसे इस्तेमाल करे:
$var='snake_case';
echo ucword($var,'_');
आउटपुट:
Snake_Case remove _ with str_replace
लारवेल के उपयोग में 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;
},
'');
}
जाहिर है, अगर '-', उदाहरण के लिए '_' की तुलना में एक और सीमांकक भी मिलान किया जाना है, तो यह काम नहीं करेगा, तो एक preg_replace $ टेक्स्ट में पहले (लगातार) सीमांकक को '-' में परिवर्तित कर सकता है ...
यह फ़ंक्शन @ 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);
}
लेकिन स्पष्ट, (मुझे लगता है: डी) और पहले पत्र को कैपिटल करने के लिए वैकल्पिक पैरामीटर के साथ या नहीं।
उपयोग:
$dashes = 'function-test-camel-case';
$ex1 = toCamelCase($dashes);
$ex2 = toCamelCase($dashes, true);
var_dump($ex1);
//string(21) "functionTestCamelCase"
var_dump($ex2);
//string(21) "FunctionTestCamelCase"
यदि आप लारवेल फ्रेमवर्क का उपयोग करते हैं, तो आप बस कैमेल_केस () विधि का उपयोग कर सकते हैं ।
camel_case('this-is-a-string') // 'thisIsAString'
यहाँ एक और विकल्प है:
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;
आउटपुट: PendingSellerConfirmation
ucwordsदूसरा (वैकल्पिक) पैरामीटर स्ट्रिंग को व्यवस्थित करने के लिए एक विभाजक की पहचान करने में मदद करता है।
str_replaceविभाजक को हटाकर आउटपुट को अंतिम रूप देने के लिए उपयोग किया जाता है।
एक कार्यात्मक array_reduce दृष्टिकोण का उपयोग करके यहां एक छोटा सहायक फ़ंक्शन है । कम से कम 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);
}
);
}
ऊपर कई अच्छे समाधान, और मैं एक अलग तरीका प्रदान कर सकता हूं जिसका पहले कोई उल्लेख नहीं करता है। यह उदाहरण सरणी का उपयोग करता है। मैं अपने प्रोजेक्ट शील्डन फ़ायरवॉल पर इस विधि का उपयोग करता हूं ।
/**
* 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;
}
झसे आज़माओ:
echo getCamelCase('This-is-example');
परिणाम:
ThisIsExample
इसे इस्तेमाल करे:
return preg_replace("/\-(.)/e", "strtoupper('\\1')", $string);
यह सरल है:
$string = preg_replace( '/-(.?)/e',"strtoupper('$1')", strtolower( $string ) );
if (!$capitalizeFirstCharacter) { $str = lcfirst($str); }