உரையை camelCase ஆக மாற்றுதல் முதல்சொல்சிறியது இலவசம் ஆன்லைன் பாதுகாப்பு
ஒரு வரியை ஒட்டினால் உடனே camelCase இல் படிக்கலாம். எல்லாம் உங்கள் உலாவியிலேயே நடக்கிறது — நீங்கள் எழுதுவது எங்கும் அனுப்பப்படுவதில்லை — விதிகள் ஆங்கிலத்தினுடையவை அல்ல, இந்தப் பக்கத்தின் மொழியுடையவை.
இதை வேறு விதமாக எழுதுங்கள்
எதுவும் பதிவேற்றப்படுவதில்லை
அதே வரி, ஏழு எழுத்து முறைகளிலும்
| எழுத்து முறை | அதே வரி, அந்த முறையில் |
|---|---|
| பெரிய எழுத்து | CRÈME BRÛLÉE 2 பேருக்கு — STRASSE 17, FOOBAR |
| சிறிய எழுத்து | crème brûlée 2 பேருக்கு — straße 17, foobar |
| Title Case | Crème Brûlée 2 பேருக்கு — Straße 17, Foobar |
| snake_case | crème_brûlée_2_ப_ர_க_க_straße_17_foo_bar |
| kebab-case | crème-brûlée-2-ப-ர-க-க-straße-17-foo-bar |
| camelCase | crèmeBrûlée2பரககStraße17FooBar |
| ஒரு URL முகவரி | creme-brulee-2-ப-ர-க-க-strasse-17-foobar |
இந்த வடிவங்கள் எங்கிருந்து வந்தன
பெரிய எழுத்தும் சிறிய எழுத்தும் ஒரு காலத்தில் வெவ்வேறு இரு எழுத்துமுறைகள். பெரிய எழுத்துகள் ரோமானியவை, உளியால் கல்லில் செதுக்கப்பட்டவை; சிறிய எழுத்துகள் கரோலிஞ்சியச் சிற்றெழுத்திலிருந்து இறங்கியவை — தோற்சுவடியின் மேல் விரைந்தோடிய எழுதுகோல் வடித்தவை. அச்சுப் பணியாளர்கள் இரண்டையும் தனித்தனிப் பெட்டிகளில் வைத்திருந்தனர் — மேல் பெட்டியும் கீழ் பெட்டியும் — பெட்டிகள் மறைந்த பின்னும் அப்பெயர்கள் நெடுங்காலம் நின்றன. நிரலாக்க வடிவங்கள் மிக இளையவை; ஒரே ஒரு சிக்கலைத் தீர்க்கவே கண்டுபிடிக்கப்பட்டவை: ஒரு பெயரில் இடைவெளி இருக்கக்கூடாது. snake_case ஆரம்பகால C-இலிருந்து, camelCase ஸ்மால்டாக்கிலிருந்து, kebab-case லிஸ்பிலிருந்து, முகவரியின் slug — இடைவெளிகளும் ஒலிக்குறிகளும் அனுமதிக்கப்படாத ஒரு முகவரிக்குள் மனிதர் படிக்கும் தலைப்பை வைக்க வேண்டிய தேவையிலிருந்து.
இவற்றை எங்கே சந்திப்பீர்கள்
ஒவ்வொரு சொல்லின் முதல் எழுத்தையும் பெரிதாக்குவது தலைப்புகளுக்கும் நூல் அட்டைகளுக்கும் உரியது; தொடக்க எழுத்தை மட்டும் பெரிதாக்குவது மற்ற ஏறத்தாழ எல்லாவற்றுக்கும், நாளுக்கு நாள் இடைமுகங்களுக்கும் — ஏனெனில் அது விரைவாகப் படிக்கப்படுகிறது. snake_case தரவுத்தள நெடுவரிசைகளுக்கும் பைத்தான் மாறிகளுக்கும் பெயரிடுகிறது; camelCase ஜாவாஸ்கிரிப்ட் மாறிகளுக்கும் ஜாவா முறைகளுக்கும்; kebab-case CSS வகுப்புகளுக்கும் வலைத் திட்டக் கோப்புப் பெயர்களுக்கும். slug என்பது ஒரு கட்டுரையின் தலைப்பை அதன் முகவரியின் கடைசிப் பகுதியாக மாற்றுவது; இங்குள்ள மாற்றங்களுள் தேடுபொறிகள் படிப்பது அது ஒன்றே.
அடிக்கடி கேட்கப்படும் கேள்விகள்
பெரிய எழுத்துக்கு மாற்றும்போது எழுத்துகளின் எண்ணிக்கை ஏன் சில வேளை மாறுகிறது?
ஏனெனில் எழுத்தின் பெரிது-சிறிது என்பது மொழியின் பண்பு, எழுத்துருவின் பண்பு அல்ல. ஜெர்மன் ß பெரிய எழுத்தில் SS ஆகிறது; ஓர் எழுத்து இரண்டாகிறது. துருக்கியில் புள்ளியுடைய i-யும் புள்ளியற்ற ı-வும் உண்டு; i-இன் பெரிய வடிவம் I அல்ல, İ — இங்கே தவறினால் ஒரு துருக்கியச் சொல் வேறொரு சொல்லாகிவிடும். இங்குள்ள மாற்றங்கள் அந்தந்தப் பக்கத்தின் மொழி விதிகளைப் பின்பற்றுகின்றன; அதனால்தான் ஒரே உள்ளீடு துருக்கியப் பக்கத்திலும் ஆங்கிலப் பக்கத்திலும் வெவ்வேறு விடையைத் தரக்கூடும்.
slug ஏன் ஒலிக்குறிகளையும் நிறுத்தற்குறிகளையும் நீக்குகிறது?
ஏனெனில் ஒரு முகவரி, செய்தியில் நகலெடுக்கப்படுவதையும், காகிதத்தில் அச்சிடப்படுவதையும், கையால் மீண்டும் தட்டச்சு செய்யப்படுவதையும் தாங்க வேண்டும். ஒலிக்குறியுள்ள எழுத்துகள் இன்றைய முகவரியில் செல்லுபடியாகும்; ஆனால் நகலெடுக்கும்போது விழுக்காட்டுக் குறியீடாக மாறி, படிக்கத்தக்க முகவரி ஒரு குறியீட்டு வரிசையாகிவிடும். அவற்றை எளிய எழுத்துகள், இலக்கங்கள், இணைப்புக்கோடுகள் வரை குறைப்பது, முகவரியைப் படிக்கத்தக்கதாகவும், பகிரத்தக்கதாகவும், தோன்றும் இடமெங்கும் ஒரே மாதிரியாகவும் வைத்திருக்கிறது.
விடை துல்லியமானதா?
இரு அலகுகளும் முழு எண்களால் ஒன்றையொன்று வரையறுக்கும் இடத்தில் ஆம் — பக்கம் அதை எண்ணுக்கு மேலே சொல்கிறது, வட்டமிடல் என்பது எத்தனை இலக்கங்கள் காட்டப்படுகின்றன என்பதில் மட்டுமே. விகிதத்துக்கு முடிவுறு தசமம் இல்லாத இடத்தில், பக்கம் பன்னிரண்டு கணிசமான இலக்கங்களைக் காட்டி, தொடர்பு தோராயமானது என்று சொல்கிறது — வேறு மாதிரி நடிப்பதில்லை.
நான் தட்டச்சு செய்வது என் சாதனத்தை விட்டு வெளியேறுகிறதா?
இல்லை. கணக்கு உங்கள் உலாவியிலேயே நடக்கிறது; எதுவும் பதிவேற்றப்படுவதில்லை, பதிவேற்ற ஒரு வழங்கியும் இல்லை. பக்கத்தை ஒருமுறை ஏற்றினால், இணையத்தை அணைத்தாலும் வேலை செய்யும்.
உரையை camelCase ஆக ஏன் மாற்றுகிறீர்கள்
கிட்டத்தட்ட எந்த JavaScript கோப்பையும், எந்த Java வகுப்பையும், எந்த Swift அல்லது Kotlin மூலக் குறியீட்டையும் திறந்து பாருங்கள், பெயர்கள் ஒரே மாதிரி இருக்கும்: userName, totalPrice, getCustomerById, isLoggedIn. சொற்கள் இடைவெளியும் பிரிப்பானும் இன்றி ஒன்றாகச் சேர்க்கப்பட்டுள்ளன, முதல் சொல் சிறிய எழுத்துகளில், அதற்குப் பிறகு ஒவ்வொன்றும் ஒரு பெரிய எழுத்தில் தொடங்குகிறது, சொல்லின் நடுவிலுள்ள திமில்கள் இந்தப் பாணிக்குப் பெயரைத் தருகின்றன. இது camelCase, மாறிகளுக்கும் செயல்கூறுகளுக்கும் C குடும்ப மொழிகளில் பெரும்பாலானவை இறுதியாகத் தேர்ந்தெடுத்த வடிவம் இதுவே. உரையை camelCase ஆக மாற்றுவது என்பது ஒரு மனிதர் எழுதும் சொற்றொடரை ஒரு நிரல் ஏற்கும், ஒரு நிரலர் அடையாளம் காணும் ஒரு பெயராக மாற்றுவது.
ஒரு வரியை ஒட்டி camelCase இல் திரும்பப் படியுங்கள். மாற்றம் உங்கள் உலாவியில் நடக்கிறது, நீங்கள் தட்டச்சு செய்வது எங்கும் அனுப்பப்படுவதில்லை, விதிகள் ஆங்கிலத்தை அல்ல இந்தப் பக்கத்தின் மொழியைப் பின்பற்றுகின்றன. இது வரியைச் சொற்களாக வெட்டுகிறது, முதல் சொல்லைச் சிறியதாக விடுகிறது, அதற்குப் பிறகு ஒவ்வொன்றின் முதல் எழுத்தை உயர்த்துகிறது, இடையில் எதுவுமின்றி இணைக்கிறது. இந்தப் பக்கம் சரியாக என்ன செய்கிறது என்ன செய்யவில்லை, வெவ்வேறு மொழிகளின் சிக்கலான எழுத்துகளை எப்படிக் கையாளுகிறது, camelCase க்கும் அதன் பெரிய எழுத்து உடன்பிறப்புக்கும் உள்ள வேறுபாடு, இந்த வடிவம் எங்கே மரபு எங்கே இல்லை, அவசரத்தில் உரையை camelCase ஆக மாற்றுபவர்களைச் சிக்க வைக்கும் பொறிகள் ஆகியவற்றைக் கீழே காண்பீர்கள்.
மாற்றம் என்ன செய்கிறது
வெட்டுதல், முதலில் சிறியது, பிறகு பெரியது, இணைத்தல்
இந்தப் பக்கம் முதலில் வரியைச் சொற்களாக வெட்டுகிறது. முதல் சொல் சிறியதாகவே இருக்கிறது. அதற்குப் பிறகு ஒவ்வொரு சொல்லும் தொடக்கத்தில் ஒரு பெரிய எழுத்தைப் பெறுகிறது, மீதம் சிறிய எழுத்துகளில். பிறகு சொற்கள் இடையில் எதுவுமின்றி இணைக்கப்படுகின்றன. Crème brûlée for 2 — straße 17, fooBar என்ற வரி crèmeBrûléeFor2Straße17FooBar என்று திரும்ப வருகிறது. உச்சரிப்புக் குறிகள் வைக்கப்படுகின்றன, எண்கள் தனிச் சொற்களாக நிற்கின்றன, கோடும் காற்புள்ளியும் போய்விட்டன, இந்தப் பக்கம் அதன் பெரிய எழுத்தில் வெட்டும் fooBar இறுதியில் FooBar ஆக மீண்டும் ஒன்றிணைந்துள்ளது.
வெட்டுகள் எங்கே விழுகின்றன
ஒரு சொல் எல்லை என்பது ஓர் இடைவெளி, ஒரு நிறுத்தற்குறி, ஒரு கோடு, ஒரு குறியீடு, அல்லது ஒரு சொல்லுக்குள் சிறிய எழுத்திலிருந்து பெரிய எழுத்துக்கான படி. எனவே customer first name, customer-first-name, customer_first_name, customerFirstName அனைத்தும் customerFirstName ஆகின்றன. மாற்றம் கிட்டத்தட்ட எந்தத் தொடக்கப் புள்ளியையும் ஏற்கிறது, எப்போதும் அதே வடிவத்தை அடைகிறது, ஒரு பெயர் குறியீட்டுக்குள் செல்லும் முன் அதை ஒரு நம்பகமான இறுதிப் படியாக்குகிறது.
முடிவை நகலெடுத்தல்
முடிவின் அருகிலுள்ள ஒரு பொத்தான் அதைக் கிளிப்போர்டுக்கு நகலெடுக்கிறது. பெயர் தேவைப்படும் திருத்தியில் அல்லது கோப்பில் அதை ஒட்டுங்கள்.
மாற்றம் என்ன செய்யாது
அது நிறுத்தற்குறிகளை வைத்திருக்காது
காற்புள்ளிகளும் புள்ளிகளும் கோடுகளும் சொற்களுக்கு இடையிலான எல்லைகள், கொண்டு செல்ல வேண்டிய எழுத்துகள் அல்ல. ஒரு மாறிப் பெயருக்கு நீங்கள் விரும்புவது அதுவே, உரைநடைக்கு விரும்புவது அல்ல. இந்தப் பக்கத்தின் வழியாக ஓடிய ஒரு வாக்கியம் ஒரு பெயராகத் திரும்ப வருகிறது, அதன் நிறுத்தற்குறிகள் போய்விடுகின்றன.
அது உச்சரிப்புக் குறிகளை நீக்காது
வரி அதன் உச்சரிப்பு எழுத்துகளை வைத்திருக்கிறது: crèmeBrûlée. பல மொழிகள் பெயர்களில் அவற்றை அனுமதிக்கின்றன, ஆனால் ஏராளமான கருவிகளும் பாணி வழிகாட்டிகளும் அனுமதிப்பதில்லை. உங்களுக்குச் சாதாரண எழுத்துகள் தேவைப்பட்டால், முதலில் சொற்றொடரை, இலத்தீன் எழுத்துகளிலிருந்து குறிகளை அகற்றும் URL slug பக்கத்தின் வழியாக இயக்குங்கள், பிறகு உரையை camelCase ஆக மாற்றுங்கள்.
பெயர் சட்டபூர்வமானதா என்று அது சரிபார்க்காது
நிரலாக்க மொழிகளுக்குத் தங்களுக்கே உரிய விதிகள் உள்ளன. ஒரு பெயர் ஓர் இலக்கத்தில் தொடங்கக் கூடாது, அது ஒதுக்கப்பட்ட சொல்லாகவும் இருக்கக் கூடாது. 2 for 1 போன்ற ஒரு சொற்றொடர் 2For1 ஆகிறது, பெரும்பாலான மொழிகள் அதை முதல் எழுத்திலேயே நிராகரிக்கும். இந்தப் பக்கம் வடிவத்தை உருவாக்குகிறது; செல்லுபடியை நீங்கள் சரிபார்க்கிறீர்கள்.
camelCase, PascalCase
அதே எண்ணம், வேறுபட்ட முதல் எழுத்து
CustomerFirstName போல முதல் சொல்லும் ஒரு பெரிய எழுத்தில் தொடங்கும்போது, அந்தப் பாணி PascalCase, UpperCamelCase அல்லது StudlyCaps என்று அழைக்கப்படுகிறது. பெரும்பாலான மொழிகளில் மரபு, வகைகளுக்கும் வகுப்புகளுக்கும் PascalCase ஐயும் மாறிகள், செயல்கூறுகள், முறைகளுக்கு camelCase ஐயும் பயன்படுத்துவது. இந்தப் பக்கம் சிறிய எழுத்தில் தொடங்கும் வடிவத்தை உருவாக்குகிறது. PascalCase பெற, சொற்றொடரை மாற்றி முதல் எழுத்தைக் கையால் உயர்த்துங்கள்.
முதல் எழுத்து ஏன் முக்கியம்
தொடக்கத்திலுள்ள பெரிய எழுத்து ஒரு பெயர் ஒரு வகுப்பு என்றும், சிறிய எழுத்து அது ஒரு நிகழ்வு அல்லது ஒரு செயல்கூறு என்றும் வாசிப்பவருக்குச் சொல்கிறது. பெரிய எழுத்து பொதுவானது என்று பொருள்படும் Go போல, மரபு கருவிகளால் நடைமுறைப்படுத்தப்படும் மொழிகளில், வேறுபாடு பொருளின் ஒரு பகுதி.
மொழி முக்கியம்
இடைவெளிகள் இல்லாமல் எழுதப்படும் எழுத்து முறைகள்
சொற்களாக வெட்ட எல்லைகள் தேவை. சீனமும் ஜப்பானியமும் இடைவெளிகள் இல்லாமல் எழுதப்படுகின்றன, எனவே அந்த எழுத்து முறைகளிலுள்ள ஒரு வரி ஒரே சொல்லாகத் திரும்ப வருகிறது. இந்தப் பக்கம் ஊகித்த ஓர் இடத்தில் வெட்டுவதைவிட அப்படிச் சொல்வதையே விரும்புகிறது, ஏனெனில் ஒரு தவறான வெட்டு நம்பத்தகுந்ததாகத் தெரியும், ஆனால் தவறான பொருளைத் தரும் ஒரு பெயரை உருவாக்கும்.
துருக்கியமும் புள்ளியிட்ட i யும்
ஒவ்வொரு சொல்லின் முதல் எழுத்தை உயர்த்துவது பக்கத்தின் மொழியின் விதிகளைப் பின்பற்றுகிறது. துருக்கிய மொழியில், i இன் பெரிய எழுத்து İ, ı இன் பெரிய எழுத்து I. ஆங்கில விதிகளைப் பயன்படுத்தும் ஒரு மாற்றி சொற்களை மாற்றிவிடுகிறது. இந்தப் பக்கம் அது எழுதப்பட்டிருக்கும் மொழியைப் பின்பற்றுகிறது.
ஜெர்மனும் கூர்மையான s உம்
ஒரு சொல்லின் நடுவிலுள்ள ஜெர்மன் ß straße போல அப்படியே இருக்கிறது. பெரிய எழுத்து STRASSE, இரட்டை s உடன், strasse ஆகத் திரும்ப வருகிறது.
பெரிய எழுத்துகள் இல்லாத எழுத்து முறைகள்
அரபு, ஹீப்ரு, இந்திய எழுத்து முறைகளுக்குப் பெரிய எழுத்துகள் இல்லை, எனவே சொற்கள் வெறுமனே ஒன்றாக இணைக்கப்படுகின்றன. முடிவு அத்தகைய ஓர் எழுத்து முறையில் படிக்கத்தக்கதா என்பது அதை நீங்கள் பயன்படுத்தும் கருவியின் விஷயம்.
camelCase மரபாக உள்ள இடங்கள்
JavaScript, TypeScript
மாறிகள், செயல்கூறுகள், பொருள் பண்புகள் camelCase இல் எழுதப்படுகின்றன, பெரும்பாலான வலை இடைமுகங்களில் JSON பொருள்களின் பண்புகளும் அவ்வாறே. நீங்கள் camelCase ஆக மாற்றும் ஒரு சொற்றொடர் இவற்றில் ஒன்றுக்குச் செல்ல வாய்ப்பு அதிகம்.
Java, Kotlin, Swift, C#, Dart
உள்ளூர் மாறிகளுக்கும் முறைகளுக்கும் அதே பழக்கம் நிலைக்கிறது, வகுப்புகளுக்கு PascalCase பயன்படுத்தப்படுகிறது, C# இல் முறைகளுக்கும் பண்புகளுக்கும் கூட. ஒரு குழுவின் பாணி வழிகாட்டி விவரங்களைத் தீர்க்கிறது.
வலைச் சேவைகளிலிருந்து JSON
பல API கள் firstName, orderTotal போன்ற திறவுகோல்களை அனுப்புகின்றன. உங்கள் தரவு ஓர் அட்டவணையாகத் தொடங்கினால், CSV இலிருந்து JSON க்கு தலைப்பு வரிசையைத் திறவுகோல்களாக மாற்றுகிறது, camelCase ஆக மாற்றப்பட்ட தலைப்புகள் அடைப்புக்குறிகளும் மேற்கோள்களும் இன்றிக் குறியீடு படிக்கக்கூடிய திறவுகோல்களாகின்றன. மறு திசையில், JSON இலிருந்து CSV க்கு திறவுகோல்களை ஒரு தலைப்பாக மீண்டும் எழுதுகிறது.
ஹேஷ்டேக்குகளும் கைப்பிடிகளும்
நிரலாக்கத்துக்கு வெளியே, #SpringGardenTips போன்ற ஹேஷ்டேக்குகளுக்கு camel case பயன்படுத்தப்படுகிறது, ஏனெனில் பெரிய எழுத்துகள் கண்ணுக்குச் சொல் எல்லைகளைக் குறிக்கின்றன. அணுகல்தன்மைக்கும் இது சிறந்தது: திரை வாசிப்பான்கள் பெரிய எழுத்தாக்கப்பட்ட ஹேஷ்டேக்கைத் தனித்தனிச் சொற்களாகவும், சிறிய எழுத்துகளின் ஓட்டத்தை ஒரு விசித்திரமான ஒற்றைச் சொல்லாகவும் வாசிக்கின்றன.
அது மரபாக இல்லாத இடங்கள்
Python, Ruby, தரவுத்தளங்கள்
இவை அடிக்கோடுகளை விரும்புகின்றன. அவற்றுக்கு, snake_case தான் கருவி.
CSS, வலை முகவரிகள்
வகுப்புப் பெயர்கள், தனிப்பயன் பண்புகள், முகவரிகள் இணைப்புக்கோடுகளைப் பயன்படுத்துகின்றன. kebab-case ஐப் பாருங்கள்.
உரைநடையும் தலைப்புகளும்
camelCase பெயர்களுக்கு, வாசிப்புக்கு அல்ல. அதில் ஒரு தலைப்போ வாக்கியமோ கண்ணுக்குக் கடினமானது. ஒரு தலைப்புக்கு, Title Case ஐக் கருதுங்கள்.
இங்கே உரையை camelCase ஆக மாற்றுவது எப்படி
உங்கள் உரையை ஒட்டுங்கள் அல்லது தட்டச்சு செய்யுங்கள்
சொற்றொடரை முதல் புலத்தில் உள்ளிடுங்கள். முடிவு உடனே இரண்டாவதில் தோன்றுகிறது, எனவே நீங்கள் தட்டச்சு செய்யும்போதே அது மாறுவதைப் பார்க்கலாம்.
வெட்டுகளையும் சுருக்கெழுத்துச் சொற்களையும் சரிபாருங்கள்
சொற்கள் எங்கே பிரிக்கப்பட்டன என்றும், சுருக்கெழுத்துச் சொற்கள் எப்படிக் கையாளப்பட்டன என்றும் பாருங்கள். parseHtmlString போன்ற ஒரு பெயரும் parseHTMLString போன்ற ஒன்றும் வேறுபட்ட மரபுகள், இந்தப் பக்கம் முழுவதும் ஒரே விதியைப் பயன்படுத்துகிறது.
நகலெடுங்கள்
நகலெடுக்கும் பொத்தானை அழுத்தி முடிவை உங்களுக்குத் தேவையான இடத்தில் ஒட்டுங்கள். அதே வரியின் பிற வடிவங்களுக்குக் கீழே பாருங்கள்.
அதே வரி ஏழு எழுத்து வடிவங்களிலும்
வடிவங்களின் ஓர் அட்டவணை
மாற்றியின் கீழே, ஓர் அட்டவணை எடுத்துக்காட்டு வரியைத் தளம் வழங்கும் ஏழு வடிவங்களிலும் காட்டுகிறது: பெரிய எழுத்து, சிறிய எழுத்து, Title Case, snake_case, kebab-case, camelCase, ஒரு URL slug. ஒவ்வொன்றிலும் அதே சொற்கள் எப்படித் தெரிகின்றன என்று பார்க்க இது ஒரு விரைவு வழி.
இந்த வடிவங்கள் எங்கிருந்து வருகின்றன
இரு எழுத்துக்கள்
பெரிய, சிறிய எழுத்துகள் ஒரு காலத்தில் இரு வேறு எழுத்துக்களாக இருந்தன. பெரிய எழுத்துகள் ரோமானியவை, உளியால் கல்லில் செதுக்கப்பட்டவை; சிறிய எழுத்துகள் கரோலிங்கிய சிறுஎழுத்திலிருந்து வந்தவை, தோல் ஏட்டின் மீது வேகமாக நகரும் ஒரு பேனாவால் வடிவமைக்கப்பட்டவை. அச்சுக்கோப்பவர்கள் இரண்டையும் தனித்தனித் தட்டுகளில், மேல் பெட்டியிலும் கீழ் பெட்டியிலும், வைத்திருந்தார்கள், தட்டுகள் போன பிறகும் பெயர்கள் நிலைத்தன.
இடைவெளிகள் இல்லாத பெயர்கள்
நிரலாக்க வடிவங்கள் மிகவும் இளையவை, ஒரு சிக்கலைத் தீர்க்கக் கண்டுபிடிக்கப்பட்டவை: ஒரு பெயரில் இடைவெளி இருக்கக் கூடாது. snake_case ஆரம்பகால C இலிருந்து வந்தது, camelCase Smalltalk இலிருந்து, kebab-case Lisp இலிருந்து, URL slug இடைவெளிகளும் உச்சரிப்புகளும் அனுமதிக்கப்படாத ஒரு முகவரியில் ஒரு மனிதத் தலைப்பை இட வேண்டிய தேவையிலிருந்து. camelCase இல் பெரிய எழுத்துகள் வேறிடத்தில் அடிக்கோடோ இணைப்புக்கோடோ செய்யும் வேலையைச் செய்கின்றன, ஒரு சொல் எங்கே முடிகிறது அடுத்தது எங்கே தொடங்குகிறது என்பதைக் குறிக்கின்றன.
பரந்த பணிப்பாய்வில் camelCase
வரையறையிலிருந்து குறியீட்டுக்கு
தேவை ஆவணங்கள் வாக்கியங்களில் எழுதப்படுகின்றன, குறியீடு பெயர்களில் எழுதப்படுகிறது. அவற்றுக்கு இடையில், யாரோ ஒருவர் ஒவ்வொரு பெயர்ச்சொல்லையும் வினைச்சொல்லையும் ஓர் அடையாளப் பெயராக மொழிபெயர்க்க வேண்டும். அதைக் கையால் செய்வது மெதுவானது, முரண்பாட்டை அழைக்கிறது: ஒரு நிரலர் customerName என்று எழுதுகிறார், இன்னொருவர் அதே பொருளுக்கு clientName. குழு வரையறையின் சரியான சொற்களிலிருந்து உரையை camelCase ஆக மாற்ற ஒப்புக்கொண்டால், பெயர்கள் சொற்களைப் பின்பற்றுகின்றன, சொற்றொடரைத் தேடுவதன் மூலம் ஒரு தேவை குறிப்பிடும் குறியீட்டை யாரும் கண்டறியலாம்.
அட்டவணைத் தலைப்பிலிருந்து பொருள் திறவுகோலுக்கு
விரிதாள்களில் First Name, Order Total, Date Of Birth போன்ற தலைப்புகள் உள்ளன. தரவு ஒரு நிரலில் பதிவுகளானதும், அந்தத் தலைப்புகள் திறவுகோல்களாகின்றன. ஒவ்வொரு தலைப்பையும் camelCase ஆக மாற்றுவது firstName, orderTotal, dateOfBirth ஐத் தருகிறது, அவற்றை மேற்கோள்களோ அடைப்புக்குறிகளோ இன்றிக் குறியீடு பண்புகளாகப் படிக்க முடியும். தரவு பின்னர் ஒரு விரிதாளுக்குத் திரும்பிச் செல்ல வேண்டுமென்றால், JSON இலிருந்து XLSX க்கு திறவுகோல்களை முதல் வரிசையாக எழுதுகிறது, வட்டம் முடிகிறது.
வடிவமைப்புக் கோப்பிலிருந்து ஒரு கூறுக்கு
வடிவமைப்புக் கருவிகள் அடுக்குகளுக்குச் சாதாரணச் சொற்களில் பெயரிடுகின்றன: Primary Button, Card Title. உருவாக்குநர்கள் கூறுகளை உருவாக்கும்போது, அந்தப் பெயர்கள் primaryButton, cardTitle போன்ற அடையாளப் பெயர்களாகின்றன, அல்லது primary-button, card-title என்ற வகுப்புப் பெயர்களாகின்றன. இணைப்பை வெளிப்படையாக வைத்திருப்பது ஒப்படைப்பை மென்மையாக்குகிறது. அடுக்குகளுடன் வரும் அளவுகளுக்கும் நிறங்களுக்கும், px ஐ rem ஆக மாற்றுதல், HEX ஐ RGB ஆக மாற்றுதல் பெயர்களுக்குப் பின்னாலுள்ள மதிப்புகளை மாற்றுகின்றன.
நீங்கள் பெயரிட்டதைத் தேடுதல்
ஒரு சீரான பாணி தேடலைப் பயனுள்ளதாக்குகிறது. ஒவ்வொரு பண்பும் camelCase என்றால், orderTotal ஐத் தேடுவது எல்லாப் பயன்பாடுகளையும் கண்டறிகிறது, ordertotal அல்லது order_total ஐத் தேடுவது எதையும் கண்டறிவதில்லை, அதுவே ஒரு தகவல். கலப்புப் பாணிகள் அதே எண்ணத்தைப் பல எழுத்துக்கூட்டல்களில் சிதறடித்துத் தேடலிலிருந்து மறைக்கின்றன.
பாதுகாப்பாக மறுபெயரிடுதல்
ஒரு பெயர் மாறும்போது, உங்கள் திருத்தியிலுள்ள மறுபெயரிடும் கருவி வேலையைச் செய்ய வேண்டும், கண்டுபிடித்து மாற்றுவதல்ல. மறுபெயரிடும் முன், புதிய பெயருக்கு அதன் புதிய சொற்களிலிருந்து உரையை camelCase ஆக மாற்றுங்கள், அதனால் புதிய அடையாளப் பெயர் தொடக்கத்திலிருந்தே மரபைப் பின்பற்றுகிறது. பிறகு கருவி ஒவ்வொரு குறிப்பையும் புதுப்பிக்கட்டும்.
ஒரு சில பெயர்களை அவை வாழப்போகும் இடத்தில் சோதியுங்கள்
ஒரு தொகுதிப் பெயர்களை ஏற்கும் முன், அவை தோன்றப்போகும் குறியீட்டு வரிகளுக்குள், மூன்று அல்லது நான்கை திருத்தியில் முயன்று பாருங்கள். ஒவ்வொன்றும் மற்றவற்றின் அருகில் இயல்பாகப் படித்தால், தொகுதி நல்லது. ஒன்று உறுத்தினால், சொற்றொடரை மாற்றி எழுதி மீண்டும் உரையை camelCase ஆக மாற்றுங்கள். ஒரு குறுகிய சோதனை ஒரு நிமிடம் செலவாகிறது, முழுக் குறியீட்டுத் தளத்திலும் ஒரு மறுபெயரிடலைத் தவிர்க்கிறது.
நன்றாகப் படிக்கும் பெயர்கள்
செயல்கூறுகளுக்கு ஒரு வினையுடன் தொடங்குங்கள்
ஒரு செயல்கூறு ஒரு செயல், அதன் பெயர் அதைச் சொல்ல வேண்டும்: getUserName, calculateTotal, isValid. ஒரு செயல்கூறுக்காக உரையை camelCase ஆக மாற்றும்போது, சொற்றொடரை வினையுடன் தொடங்குங்கள்.
மதிப்புகளுக்குப் பெயர்ச்சொற்களைப் பயன்படுத்துங்கள்
ஒரு மாறி ஒரு பொருளைக் கொண்டிருக்கிறது: userName, totalPrice, orderList. ஆம்-இல்லை மதிப்புகள் கேள்விகளாகச் சிறப்பாகப் படிக்கின்றன: isActive, hasAccess, canEdit.
சுருக்கெழுத்துச் சொற்களில் சீராக இருங்கள்
சில குழுக்கள் parseHTML என்று எழுதுகின்றன, சில parseHtml. இரண்டும் சரி; கலப்புதான் சரியல்ல. ஒன்றைத் தேர்ந்தெடுத்து ஒவ்வொரு பெயருக்கும் பயன்படுத்துங்கள், உங்கள் குறியீட்டைத் தேடுவது எளிதாகும்.
பெயர்களை உச்சரிக்கத்தக்கவையாக வையுங்கள்
உரக்கப் படிக்கக்கூடிய ஒரு பெயர் நீங்கள் விவாதிக்கக்கூடிய ஒரு பெயர். custFnDt அப்படிப்பட்டதல்ல, customerFirstDate அப்படிப்பட்டது. நீங்கள் எழுதுவதை மாற்றம் அப்படியே பாதுகாக்கிறது, எனவே வைத்திருக்கத் தகுந்த ஒன்றை எழுதுங்கள்.
உரையை camelCase ஆக மாற்றும்போது பொறிகள்
ஓர் இலக்கத்தில் தொடங்கும் பெயர்
பெரும்பாலான மொழிகள் அதை மறுக்கின்றன. முன்னால் ஒரு சொல்லையோ எழுத்தையோ இடுங்கள்.
ஒதுக்கப்பட்ட சொற்கள்
class, new, default போன்ற ஒரு சொற்றொடர் பல மொழிகளில் ஒரு திறவுச்சொல். இந்தப் பக்கத்துக்கு எது என்று தெரியாது. பெயரைப் பயன்படுத்தும் முன் சரிபாருங்கள்.
சுருக்கெழுத்துச் சொற்களும் பெரிய எழுத்து ஓட்டங்களும்
பெரிய எழுத்துகளின் ஓர் ஓட்டத்தைச் சுற்றியுள்ள வெட்டுகள் உங்களை வியப்பிலாழ்த்தலாம். முடிவைப் படித்து உங்கள் மரபுடன் ஒப்பிடுங்கள்.
பெயர்களில் உச்சரிப்புக் குறிகள்
சில மொழிகளில் அனுமதிக்கப்படுகின்றன, சிலவற்றில் இல்லை. பெயர் பழைய கருவிகள் வழியாகப் பயணிக்க வேண்டுமென்றால், முதலில் உச்சரிப்புக் குறிகளை அகற்றுங்கள்.
மாற்றுவதற்கு முன் மக்கள் கேட்கும் கேள்விகள்
நிறுத்தற்குறிகளுக்கு என்ன நடக்கிறது?
அவை சொற்களுக்கு இடையிலான எல்லையாகக் கருதப்படுகின்றன, கொண்டு செல்லப்படுவதில்லை.
எண்கள் வைக்கப்படுகின்றனவா?
ஆம், தனிச் சொற்களாக, மற்றவற்றுடன் இணைக்கப்பட்டு.
ஏற்கெனவே snake_case அல்லது kebab-case இல் உள்ள உள்ளீட்டை இது கையாளுமா?
ஆம். அடிக்கோடுகளும் இணைப்புக்கோடுகளும் எல்லைகள், எனவே my_variable_name myVariableName ஆகிறது.
PascalCase ஐ எப்படிப் பெறுவது?
மாற்றி, பிறகு முதல் எழுத்தைக் கையால் உயர்த்துங்கள்.
என் உரை பதிவேற்றப்படுகிறதா?
இல்லை. நீங்கள் இங்கே தட்டச்சு செய்வது எங்கும் அனுப்பப்படுவதில்லை, எனவே ஒரு வரைவு, ஒரு கடவுச்சொல் அல்லது ஒரு வாடிக்கையாளரின் பெயர் ஒரு உரைத் திருத்தியில் இருப்பது போலவே இங்கும் பாதுகாப்பானது.
அடிக்கோடுகளையோ இணைப்புக்கோடுகளையோ எப்படிப் பெறுவது?
உரையை snake_case ஆக மாற்றுதல் அல்லது உரையை kebab-case ஆக மாற்றுதல் மூலம்.
ஒரு செய்முறை எடுத்துக்காட்டு
நீங்கள் ஒரு டெலிவரிக் கட்டணத்தைக் கணக்கிட ஒரு சிறிய நிரல் எழுதுகிறீர்கள் என்றும், வரையறை மதிப்புகளை delivery fee per kilometre, free delivery threshold, is express order என்று அழைக்கிறது என்றும் வைத்துக்கொள்ளுங்கள். நீங்கள் ஒவ்வொன்றையும் வரிசையாக மாற்றி deliveryFeePerKilometre, freeDeliveryThreshold, isExpressOrder ஐப் படிக்கிறீர்கள். முதலாவது ஒரு பெயர்ச்சொல்லுடன் தொடங்குகிறது, ஒரு மதிப்புக்கு அது சரி; கடைசியானது is உடன் தொடங்குகிறது, அது ஓர் ஆம்-இல்லைக் கொடியைக் குறிக்கிறது. மூன்றையும் நிரலில் மாறிப் பெயர்களாக ஒட்டுகிறீர்கள், வரையறையும் குறியீடும் இப்போது அதே சொற்களை அதே வரிசையில் பயன்படுத்துகின்றன, அது மறுஆய்வை எளிதாக்குகிறது.
ஒரு குறுகிய சரிபார்ப்புப் பட்டியல்
மாற்றுவதற்கு முன்
சொற்றொடரைச் சாதாரணச் சொற்களில் எழுதுங்கள். செயல்கூறுகளை ஒரு வினையுடனும் கொடிகளை is அல்லது has உடனும் தொடங்குங்கள். இலக்கு மொழியில் ஒதுக்கப்பட்ட சொற்களைச் சரிபாருங்கள்.
மாற்றும்போது
சொற்றொடரை ஒட்டி, வெட்டுகளைப் பார்த்து, பெயர் ஓர் எழுத்தில் தொடங்குகிறது என்று உறுதிசெய்யுங்கள்.
மாற்றிய பிறகு
நீளத்தையும் சுருக்கெழுத்துச் சொற்களையும் சரிபார்த்து, அது தேவைப்படும் ஒவ்வோர் இடத்திலும் அதே பெயரைப் பயன்படுத்துங்கள்.
பொதுவான தவறுகள்
மக்கள் படிக்கும் உரைக்கு camelCase ஐப் பயன்படுத்துதல்
அது பெயர்களுக்கு, உரைநடைக்கு அல்ல.
ஒரே திட்டத்தில் மரபுகளைக் கலத்தல்
ஒவ்வோர் அடுக்குக்கும் camelCase, snake_case அல்லது kebab-case ஐத் தேர்ந்தெடுத்து, அதில் நிலைத்திருங்கள்.
இலக்கு எதை அனுமதிக்கிறது என்பதை மறத்தல்
தொடக்கத்திலுள்ள இலக்கங்கள், உச்சரிப்புக் குறிகள், ஒதுக்கப்பட்ட சொற்கள் மொழிகளுக்கு இடையே வேறுபடுகின்றன.
உங்கள் உரை உங்கள் சாதனத்திலேயே இருக்கிறது
மாற்றம் உள்ளூரிலேயே நடக்கிறது. உங்கள் உரை உங்கள் சொந்த உலாவியால் கையாளப்படுகிறது, எதுவும் எங்கும் அனுப்பப்படுவதில்லை. பின்னர் நீக்க எதுவும் இல்லை, உருவாக்க எந்தக் கணக்கும் இல்லை. உரையை camelCase ஆக மாற்றும் எளிய வழி அதுவே.
சுருக்கம்
இங்கே உரையை camelCase ஆக மாற்ற, ஒரு வரியை ஒட்டி, சொற்கள் வெட்டப்பட்டு, முதல் சொல் சிறியதாக, பின்வரும் ஒவ்வொன்றின் முதல் எழுத்து உயர்த்தப்பட்டு, இடையில் எதுவுமின்றி எல்லாம் இணைக்கப்பட்டுத் திரும்பப் படியுங்கள். ஏற்கெனவே snake_case அல்லது kebab-case இல் எழுதப்பட்ட ஒரு வரி அதன் பிரிப்பான்களில் வெட்டப்படுகிறது. இந்தப் பக்கம் நிறுத்தற்குறிகளை வைத்திருக்காது: காற்புள்ளிகளும் புள்ளிகளும் கோடுகளும் சொற்களுக்கு இடையிலான எல்லைகள், கொண்டு செல்ல வேண்டிய எழுத்துகள் அல்ல, ஒரு மாறிப் பெயருக்கு நீங்கள் விரும்புவது அதுவே, உரைநடைக்கு அல்ல. சொற்களாக வெட்ட எல்லைகள் தேவை, எனவே இடைவெளிகள் இல்லாமல் எழுதப்படும் சீனமும் ஜப்பானியமும் ஒரே சொல்லாகத் திரும்ப வருகின்றன. முதல் எழுத்தை உயர்த்துவது பக்கத்தின் மொழியைப் பின்பற்றுகிறது, எனவே துருக்கிய i İ ஆகிறது. எதுவும் பதிவேற்றப்படுவதில்லை.