अगर मैं होता:
$string = "PascalCase";
मुझे जरूरत है
"pascal_case"
क्या PHP इस उद्देश्य के लिए एक फ़ंक्शन प्रदान करता है?
अगर मैं होता:
$string = "PascalCase";
मुझे जरूरत है
"pascal_case"
क्या PHP इस उद्देश्य के लिए एक फ़ंक्शन प्रदान करता है?
जवाबों:
आकार के लिए इसे पहनकर देखें:
$tests = array(
'simpleTest' => 'simple_test',
'easy' => 'easy',
'HTML' => 'html',
'simpleXML' => 'simple_xml',
'PDFLoad' => 'pdf_load',
'startMIDDLELast' => 'start_middle_last',
'AString' => 'a_string',
'Some4Numbers234' => 'some4_numbers234',
'TEST123String' => 'test123_string',
);
foreach ($tests as $test => $result) {
$output = from_camel_case($test);
if ($output === $result) {
echo "Pass: $test => $result\n";
} else {
echo "Fail: $test => $result [$output]\n";
}
}
function from_camel_case($input) {
preg_match_all('!([A-Z][A-Z0-9]*(?=$|[A-Z][a-z0-9])|[A-Za-z][a-z0-9]+)!', $input, $matches);
$ret = $matches[0];
foreach ($ret as &$match) {
$match = $match == strtoupper($match) ? strtolower($match) : lcfirst($match);
}
return implode('_', $ret);
}
आउटपुट:
Pass: simpleTest => simple_test
Pass: easy => easy
Pass: HTML => html
Pass: simpleXML => simple_xml
Pass: PDFLoad => pdf_load
Pass: startMIDDLELast => start_middle_last
Pass: AString => a_string
Pass: Some4Numbers234 => some4_numbers234
Pass: TEST123String => test123_string
यह निम्नलिखित नियमों को लागू करता है:
एक छोटा समाधान: सरल नियमित अभिव्यक्ति के साथ संपादक के समान और "ट्रेलिंग-अंडरस्कोर" समस्या को ठीक करना:
$output = strtolower(preg_replace('/(?<!^)[A-Z]/', '_$0', $input));
ध्यान दें कि उपरोक्त समाधानों का उपयोग SimpleXML
करने के लिए simple_x_m_l
इस तरह के मामलों को परिवर्तित किया जाएगा । यह भी ऊंट मामले संकेतन का एक गलत उपयोग माना जा सकता है (सही होगा SimpleXml
) एल्गोरिथ्म की एक बग के बजाय क्योंकि ऐसे मामले हमेशा अस्पष्ट होते हैं - यहां तक कि अपरकेस वर्णों को एक स्ट्रिंग में शामिल करके ( simple_xml
) ऐसा एल्गोरिथ्म हमेशा अन्य मामलों में विफल होगा XMLHTMLConverter
संक्षिप्तीकरण आदि के पास एक या एक अक्षर के शब्द जैसे , यदि आप (बल्कि दुर्लभ) किनारे के मामलों के बारे में बुरा नहीं मानते हैं और SimpleXML
सही तरीके से संभालना चाहते हैं , तो आप थोड़ा और जटिल समाधान का उपयोग कर सकते हैं:
$output = ltrim(strtolower(preg_replace('/[A-Z]([A-Z](?![a-z]))*/', '_$0', $input)), '_');
एक संक्षिप्त समाधान और कुछ मुश्किल मामलों का उपयोग कर सकते हैं:
function decamelize($string) {
return strtolower(preg_replace(['/([a-z\d])([A-Z])/', '/([^_])([A-Z][a-z])/'], '$1_$2', $string));
}
इन सभी मामलों को संभाल सकते हैं:
simpleTest => simple_test
easy => easy
HTML => html
simpleXML => simple_xml
PDFLoad => pdf_load
startMIDDLELast => start_middle_last
AString => a_string
Some4Numbers234 => some4_numbers234
TEST123String => test123_string
hello_world => hello_world
hello__world => hello__world
_hello_world_ => _hello_world_
hello_World => hello_world
HelloWorld => hello_world
helloWorldFoo => hello_world_foo
hello-world => hello-world
myHTMLFiLe => my_html_fi_le
aBaBaB => a_ba_ba_b
BaBaBa => ba_ba_ba
libC => lib_c
आप इस फ़ंक्शन का परीक्षण यहां कर सकते हैं: http://syframework.alwaysdata.net/decamelize
रूबी String#camelize
और से पोर्ट किया गया String#decamelize
।
function decamelize($word) {
return preg_replace(
'/(^|[a-z])([A-Z])/e',
'strtolower(strlen("\\1") ? "\\1_\\2" : "\\2")',
$word
);
}
function camelize($word) {
return preg_replace('/(^|_)([a-z])/e', 'strtoupper("\\2")', $word);
}
उपरोक्त समाधान में से एक चाल चूक हो सकती है 'ई' संशोधक जो preg_replace
प्रतिस्थापन कोड का मूल्यांकन पीएचपी कोड के रूप में करता है।
e
ध्वज preg_replace
PHP 5.5 में चित्रित किया जा रहा है।
^|
या strlen
।
Symfony Serializer घटक एक है CamelCaseToSnakeCaseNameConverter दो विधियों है कि normalize()
और denormalize()
। इन्हें निम्नानुसार इस्तेमाल किया जा सकता है:
$nameConverter = new CamelCaseToSnakeCaseNameConverter();
echo $nameConverter->normalize('camelCase');
// outputs: camel_case
echo $nameConverter->denormalize('snake_case');
// outputs: snakeCase
$nameConverter->normalize('CamelCase')
आउटपुट _camel_case
।
यहां ज्यादातर समाधान भारी हाथ लगता है। यहाँ मेरा उपयोग है:
$underscored = strtolower(
preg_replace(
["/([A-Z]+)/", "/_([A-Z]+)([A-Z][a-z])/"],
["_$1", "_$1_$2"],
lcfirst($camelCase)
)
);
"CamelCASE" को "camel_case" में बदल दिया गया है
lcfirst($camelCase)
पहले वर्ण को कम कर देगा (अंडरसेलकोर के साथ शुरू करने के लिए 'कैमलकेयर' परिवर्तित आउटपुट से बचा जाता है)[A-Z]
बड़े अक्षरों का पता लगाता है+
हर लगातार अपरकेस को एक शब्द के रूप में मानेंगे ('CamelCASE' से बचता है जिसे camel_C_A_S_E में परिवर्तित किया जाता है)ThoseSPECCases
-> those_spec_cases
के लिए हैthose_speccases
strtolower([…])
आउटपुट को लोअरकेस में बदल देता हैlcfirst
$ camelCase में फ़ंक्शन जोड़ने की आवश्यकता है
ucfirst()
कॉल के कारण इस समाधान से अप्रत्याशित रूप से विभाजित हो जाएगी । डेमोUSADollarSymbol
हो जाता है मैं इस समाधान की सिफारिश नहीं करता हूं, क्योंकि इसे regex के साथ इनपुट स्ट्रिंग के माध्यम से दो पास करना पड़ता है - एक अपरिष्कृत पैटर्न का संकेत। u_sa_dollar_symbol
php इस afaik के लिए बिल्ट इन फंक्शन की पेशकश नहीं करता है, लेकिन यहाँ मैं उपयोग करता हूँ
function uncamelize($camel,$splitter="_") {
$camel=preg_replace('/(?!^)[[:upper:]][[:lower:]]/', '$0', preg_replace('/(?!^)[[:upper:]]+/', $splitter.'$0', $camel));
return strtolower($camel);
}
स्प्लिटर को फ़ंक्शन कॉल में निर्दिष्ट किया जा सकता है, इसलिए आप इसे कॉल कर सकते हैं
$camelized="thisStringIsCamelized";
echo uncamelize($camelized,"_");
//echoes "this_string_is_camelized"
echo uncamelize($camelized,"-");
//echoes "this-string-is-camelized"
mb_strtolower
और /u
विकल्प पर संगत बना सकते हैं preg_replace
।
आपको इसके माध्यम से एक रेगेक्स चलाने की आवश्यकता है जो कि प्रत्येक अपरकेस पत्र से मेल खाता है, भले ही यह शुरुआत में हो और इसे अंडरस्कोर प्लस के साथ बदलें। एक utf-8 समाधान यह है:
header('content-type: text/html; charset=utf-8');
$separated = preg_replace('%(?<!^)\p{Lu}%usD', '_$0', 'AaaaBbbbCcccDdddÁáááŐőőő');
$lower = mb_strtolower($separated, 'utf-8');
echo $lower; //aaaa_bbbb_cccc_dddd_áááá_őőőő
यदि आप सुनिश्चित नहीं हैं कि आपका स्ट्रिंग किस मामले में है, तो इसे पहले जांचना बेहतर है, क्योंकि यह कोड मानता है कि इनपुट camelCase
इसके बजाय है underscore_Case
या नहीं dash-Case
, इसलिए यदि लैटर्स में अपरकेस अक्षर हैं, तो यह उनके लिए अंडरस्कोर जोड़ देगा।
क्लेटस से स्वीकृत उत्तर वैसे भी बहुत अधिक नकल है और यह केवल लैटिन वर्णों के साथ काम करता है। मुझे लगता है कि यह वास्तव में बुरा समाधान है और मुझे आश्चर्य है कि इसे बिल्कुल स्वीकार क्यों किया गया। परिवर्तित TEST123String
में test123_string
जरूरी एक वैध आवश्यकता नहीं है। मैंने बल्कि इसे सरल रखा और इसके बजाय इसे अलग ABCccc
कर a_b_cccc
दिया ab_cccc
क्योंकि यह इस तरह से जानकारी नहीं खोता है और पीछे का रूपांतरण उसी स्ट्रिंग को देगा जो हमने शुरू किया था। यहां तक कि अगर आप इसे दूसरे तरीके से करना चाहते हैं, भले ही आप (?<!^)\p{Lu}\p{Ll}|(?<=\p{Ll})\p{Lu}
रिजेक्स विशेषज्ञ नहीं हैं, तो पॉज़िटिव लुकबाइंड या दो रेगेक्स के साथ रेगेक्स लिखना आसान नहीं है। वहाँ नहीं करने के लिए बीच में निर्णय लेने का उल्लेख नहीं है strtolower
और lcfirst
जहां का उपयोग कर strtolower
पूरी तरह से ठीक हो जाएगा को विभाजित करने की आवश्यकता नहीं है।
यदि आप एक PHP 5.4 संस्करण की तलाश कर रहे हैं और बाद में उत्तर यहाँ कोड है:
function decamelize($word) {
return $word = preg_replace_callback(
"/(^|[a-z])([A-Z])/",
function($m) { return strtolower(strlen($m[1]) ? "$m[1]_$m[2]" : "$m[2]"); },
$word
);
}
function camelize($word) {
return $word = preg_replace_callback(
"/(^|_)([a-z])/",
function($m) { return strtoupper("$m[2]"); },
$word
);
}
सभी के लिए फैंसी नहीं बल्कि साधारण और तेज नरक के रूप में:
function uncamelize($str)
{
$str = lcfirst($str);
$lc = strtolower($str);
$result = '';
$length = strlen($str);
for ($i = 0; $i < $length; $i++) {
$result .= ($str[$i] == $lc[$i] ? '' : '_') . $lc[$i];
}
return $result;
}
echo uncamelize('HelloAWorld'); //hello_a_world
++$i
इसके बजाय $i++
यह थोड़ा तेज होगा;)
"कैमलकेस" से "कैमलकेस":
function camelToSnake($camel)
{
$snake = preg_replace('/[A-Z]/', '_$0', $camel);
$snake = strtolower($snake);
$snake = ltrim($snake, '_');
return $snake;
}
या:
function camelToSnake($camel)
{
$snake = preg_replace_callback('/[A-Z]/', function ($match){
return '_' . strtolower($match[0]);
}, $camel);
return ltrim($snake, '_');
}
this-kind-of-output
एक संस्करण जो रेगेक्स का उपयोग नहीं करता है वह अल्कक्टेक्ट स्रोत में पाया जा सकता है :
decamelize($str, $glue='_')
{
$counter = 0;
$uc_chars = '';
$new_str = array();
$str_len = strlen($str);
for ($x=0; $x<$str_len; ++$x)
{
$ascii_val = ord($str[$x]);
if ($ascii_val >= 65 && $ascii_val <= 90)
{
$uc_chars .= $str[$x];
}
}
$tok = strtok($str, $uc_chars);
while ($tok !== false)
{
$new_char = chr(ord($uc_chars[$counter]) + 32);
$new_str[] = $new_char . $tok;
$tok = strtok($uc_chars);
++$counter;
}
return implode($new_str, $glue);
}
तो यहाँ एक लाइनर है:
strtolower(preg_replace('/(?|([a-z\d])([A-Z])|([^\^])([A-Z][a-z]))/', '$1_$2', $string));
g
इस रेगेक्स में एक संशोधक जोड़ने की सलाह दूंगा।
g
और यह मेरे लिए ठीक काम करता है।
g
। लेकिन मैं उस वाक्यांश को याद नहीं रख सकता, जिसका मैंने परीक्षण किया था।
danielstjules / Stringy ने कैमलकेस से स्ट्रिंग को सॉनेसेज़ में बदलने की एक विधि साबित की।
s('TestUCase')->underscored(); // 'test_u_case'
लारवेल 5.6 ऐसा करने का एक बहुत ही सरल तरीका प्रदान करता है:
/**
* Convert a string to snake case.
*
* @param string $value
* @param string $delimiter
* @return string
*/
public static function snake($value, $delimiter = '_'): string
{
if (!ctype_lower($value)) {
$value = strtolower(preg_replace('/(.)(?=[A-Z])/u', '$1'.$delimiter, $value));
}
return $value;
}
यह क्या करता है: यदि यह देखता है कि दिए गए स्ट्रिंग में कम से कम एक कैपिटल लेटर है, तो यह किसी भी वर्ण ( ) के लिए पॉज़िटिव लुकहेड का उपयोग करता है, .
उसके बाद कैपिटल लेटर ( (?=[A-Z])
)। इसके बाद पाया गया अक्षर बदल देता है और इसके बाद विभाजक का मान होता है _
।
रेल से सीधा बंदरगाह (& #: या परिवर्णी के लिए उनकी विशेष हैंडलिंग माइनस) होगा
function underscore($word){
$word = preg_replace('#([A-Z\d]+)([A-Z][a-z])#','\1_\2', $word);
$word = preg_replace('#([a-z\d])([A-Z])#', '\1_\2', $word);
return strtolower(strtr($word, '-', '_'));
}
PHP को जानना, यह मैनुअल पार्सिंग की तुलना में तेज़ होगा जो यहां दिए गए अन्य उत्तरों में हो रहा है। नुकसान यह है कि आपको शब्दों के बीच विभाजक के रूप में उपयोग करने के लिए चुना नहीं जाता है, लेकिन यह सवाल का हिस्सा नहीं था।
यह भी जांच प्रासंगिक रेल स्रोत कोड
ध्यान दें कि यह ASCII पहचानकर्ताओं के साथ उपयोग के लिए है। यदि आपको ASCII रेंज के बाहर के पात्रों के साथ ऐसा करने की आवश्यकता है, तो '/ u' संशोधक preg_match
का उपयोग करें और उपयोग करें mb_strtolower
।
यहाँ भगवान के साथ एक छह साल पुराने सवाल पर मेरा योगदान है कि कितने जवाब हैं ...
यह प्रदान किए गए स्ट्रिंग में सभी शब्दों को रूपांतरित कर देगा जो ऊंट में snakecase में हैं। उदाहरण के लिए "SuperSpecialAwesome और भी FizBuzz ΚάταιΑκόιαμα" को "super_special_awesome और भी fizz_buzz και_κάτι_ακόμα" में परिवर्तित किया जाएगा।
mb_strtolower(
preg_replace_callback(
'/(?<!\b|_)\p{Lu}/u',
function ($a) {
return "_$a[0]";
},
'SuperSpecialAwesome'
)
);
Yii2 शब्द को CamelCase से स्नेक_केस बनाने के लिए अलग-अलग फ़ंक्शन है।
/**
* Converts any "CamelCased" into an "underscored_word".
* @param string $words the word(s) to underscore
* @return string
*/
public static function underscore($words)
{
return strtolower(preg_replace('/(?<=\\w)([A-Z])/', '_\\1', $words));
}
लघु समाधान:
$subject = "PascalCase";
echo strtolower(preg_replace('/\B([A-Z])/', '_$1', $subject));
मेरे पास भी ऐसी ही समस्या थी, लेकिन ऐसा कोई जवाब नहीं मिला जो संतुष्ट करता हो कि कैमलकेस को स्नेक_केस में कैसे बदला जाए, जबकि _
अंडरस्कोर, या सभी कैप्स के संक्षिप्त नाम के साथ डुप्लिकेट या निरर्थक अंडरस्कोर को टालना ।
गु समस्या इस प्रकार है:
CamelCaseClass => camel_case_class
ClassName_WithUnderscores => class_name_with_underscore
FAQ => faq
मैंने जो हल लिखा है वह एक सरल दो फ़ंक्शन कॉल, लोअरकेस और खोज है और लगातार लोअरकेस-अपरकेस अक्षरों के लिए प्रतिस्थापित करता है:
strtolower(preg_replace("/([a-z])([A-Z])/", "$1_$2", $name));
function camel2snake($name) {
$str_arr = str_split($name);
foreach ($str_arr as $k => &$v) {
if (ord($v) >= 64 && ord($v) <= 90) { // A = 64; Z = 90
$v = strtolower($v);
$v = ($k != 0) ? '_'.$v : $v;
}
}
return implode('', $str_arr);
}
$name{$k}
(या $name[$k]
) का उपयोग करके वर्णों तक पहुंच सकते हैं , जो आपके कोड को लंबा कर देगा, लेकिन इसे एक सरणी से और इसके लिए परिवर्तित करने के बड़े ओवरहेड से बचा जाता है।
यहाँ पर सबसे खराब उत्तर सबसे अच्छा होने के करीब था (एक रूपरेखा का उपयोग करें)। नहीं, बस स्रोत कोड पर एक नज़र रखना। यह देखते हुए कि एक अच्छी तरह से स्थापित रूपरेखा का उपयोग क्या अधिक विश्वसनीय दृष्टिकोण (कोशिश और परीक्षण) होगा। ज़ेंड फ्रेमवर्क में कुछ शब्द फिल्टर हैं जो आपकी आवश्यकताओं के अनुरूप हैं। स्रोत ।
यहाँ कुछ तरीके हैं जो मैंने स्रोत से अनुकूलित किए हैं।
function CamelCaseToSeparator($value,$separator = ' ')
{
if (!is_scalar($value) && !is_array($value)) {
return $value;
}
if (defined('PREG_BAD_UTF8_OFFSET_ERROR') && preg_match('/\pL/u', 'a') == 1) {
$pattern = ['#(?<=(?:\p{Lu}))(\p{Lu}\p{Ll})#', '#(?<=(?:\p{Ll}|\p{Nd}))(\p{Lu})#'];
$replacement = [$separator . '\1', $separator . '\1'];
} else {
$pattern = ['#(?<=(?:[A-Z]))([A-Z]+)([A-Z][a-z])#', '#(?<=(?:[a-z0-9]))([A-Z])#'];
$replacement = ['\1' . $separator . '\2', $separator . '\1'];
}
return preg_replace($pattern, $replacement, $value);
}
function CamelCaseToUnderscore($value){
return CamelCaseToSeparator($value,'_');
}
function CamelCaseToDash($value){
return CamelCaseToSeparator($value,'-');
}
$string = CamelCaseToUnderscore("CamelCase");
यह कार्यक्षमता प्रदान करने वाला एक पुस्तकालय है :
SnakeCaseFormatter::run('CamelCase'); // Output: "camel_case"
यदि आप लारवेल फ्रेमवर्क का उपयोग करते हैं, तो आप सिर्फ साँप_केस () पद्धति का उपयोग कर सकते हैं ।
यह छोटे तरीकों में से एक है:
function camel_to_snake($input)
{
return strtolower(ltrim(preg_replace('/([A-Z])/', '_\\1', $input), '_'));
}
रेगेक्स का उपयोग किए बिना डी-कैमेलाइज़ कैसे करें:
function decamelize($str, $glue = '_') {
$capitals = [];
$replace = [];
foreach(str_split($str) as $index => $char) {
if(!ctype_upper($char)) {
continue;
}
$capitals[] = $char;
$replace[] = ($index > 0 ? $glue : '') . strtolower($char);
}
if(count($capitals) > 0) {
return str_replace($capitals, $replace, $str);
}
return $str;
}
एक संपादित करें:
2019 में मैं यह कैसे करूंगा:
function toSnakeCase($str, $glue = '_') {
return preg_replace_callback('/[A-Z]/', function ($matches) use ($glue) {
return $glue . strtolower($matches[0]);
}, $str);
}
और जब PHP 7.4 जारी किया जाएगा:
function toSnakeCase($str, $glue = '_') {
return preg_replace_callback('/[A-Z]/', fn($matches) => $glue . strtolower($matches[0]), $str);
}
Zend Word फिल्टर के फ़िल्टर वर्गों का उपयोग करना आसान है :
<?php
namespace MyNamespace\Utility;
use Zend\Filter\Word\CamelCaseToUnderscore;
use Zend\Filter\Word\UnderscoreToCamelCase;
class String
{
public function test()
{
$underscoredStrings = array(
'simple_test',
'easy',
'html',
'simple_xml',
'pdf_load',
'start_middle_last',
'a_string',
'some4_numbers234',
'test123_string',
);
$camelCasedStrings = array(
'simpleTest',
'easy',
'HTML',
'simpleXML',
'PDFLoad',
'startMIDDLELast',
'AString',
'Some4Numbers234',
'TEST123String',
);
echo PHP_EOL . '-----' . 'underscoreToCamelCase' . '-----' . PHP_EOL;
foreach ($underscoredStrings as $rawString) {
$filteredString = $this->underscoreToCamelCase($rawString);
echo PHP_EOL . $rawString . ' >>> ' . $filteredString . PHP_EOL;
}
echo PHP_EOL . '-----' . 'camelCaseToUnderscore' . '-----' . PHP_EOL;
foreach ($camelCasedStrings as $rawString) {
$filteredString = $this->camelCaseToUnderscore($rawString);
echo PHP_EOL . $rawString . ' >>> ' . $filteredString . PHP_EOL;
}
}
public function camelCaseToUnderscore($input)
{
$camelCaseToSeparatorFilter = new CamelCaseToUnderscore();
$result = $camelCaseToSeparatorFilter->filter($input);
$result = strtolower($result);
return $result;
}
public function underscoreToCamelCase($input)
{
$underscoreToCamelCaseFilter = new UnderscoreToCamelCase();
$result = $underscoreToCamelCaseFilter->filter($input);
return $result;
}
}
----- underscoreToCamelCase -----
simple_test >>> SimpleTest
आसान >>> आसान
html >>> एचटीएमएल
simple_xml >>> SimpleXml
pdf_load >>> PdfLoad
start_middle_last >>> StartMiddleLast
a_string >>> AString
some4_numbers234 >>> Some4Numbers234
test123_string >>> Test123String
----- camelCaseToUnderscore -----
simpleTest >>> simple_test
आसान >>> आसान
HTML >>> html
simpleXML >>> simple_xml
PDFLoad >>> pdf_load
startMIDDLELast >>> start_middle_last
एस्ट्रिंग >>> a_string
Some4Numbers234 >>> some4_numbers234
TEST123String >>> test123_string
ओपन सोर्स TurboCommons लाइब्रेरी में StringUtils वर्ग के अंदर एक सामान्य उद्देश्य फॉर्मेटकेस () पद्धति है, जो आपको कई स्ट्रिंग केस प्रारूप में बदलने की सुविधा देती है, जैसे CamelCase, UpperCamelCase, LowerCamelbase, snake_case, Title Case और कई और।
https://github.com/edertone/TurboCommons
इसका उपयोग करने के लिए, अपनी परियोजना के लिए चरण फ़ाइल आयात करें और:
use org\turbocommons\src\main\php\utils\StringUtils;
echo StringUtils::formatCase('camelCase', StringUtils::FORMAT_SNAKE_CASE);
// will output 'camel_Case'
यदि आप इसके साथ शुरू कर सकते हैं:
$string = 'Camel_Case'; // underscore or any other separator...
तब आप या तो मामले में बदल सकते हैं:
$pascal = str_replace("_", "", $string);
$snake = strtolower($string);
या कोई अन्य मामले:
$capitalized = str_replace("_", " ", $string); // Camel Case
$constant = strtoupper($string); // CAMEL_CASE
$train = str_replace("_", "-", $snake); // camel-case