వచనాన్ని 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 గుర్తులనూ విరామ చిహ్నాలనూ ఎందుకు తీసేస్తుంది?
ఎందుకంటే ఒక చిరునామా సందేశంలోకి కాపీ కావడాన్ని, కాగితంపై ముద్రణను, చేత్తో మళ్ళీ టైపు చేయడాన్ని తట్టుకోవాలి. గుర్తులున్న అక్షరాలు నేటి చిరునామాల్లో చెల్లుతాయి, కానీ కాపీ చేసేటప్పుడు శాతపు సంకేతాలుగా మారి, చదవగల చిరునామా ఒక గుర్తుల వరుసగా మారిపోతుంది. వాటిని సాధారణ అక్షరాలకు, అంకెలకు, హైఫన్లకు తగ్గించడం వల్ల చిరునామా చదవగలిగేదిగా, పంచుకోగలిగేదిగా, ఎక్కడ కనిపించినా ఒకేలాగా ఉంటుంది.
సమాధానం ఖచ్చితమేనా?
రెండు ప్రమాణాలూ పూర్ణ సంఖ్యలతో ఒకదానినొకటి నిర్వచించే చోట అవును — పేజీ దాన్ని సంఖ్య పైనే చెబుతుంది, గుండ్రీకరణ అనేది ఎన్ని అంకెలు చూపాలి అన్నదానిలోనే ఉంటుంది. నిష్పత్తికి పరిమిత దశాంశం లేని చోట, పేజీ పన్నెండు సార్థక అంకెలు చూపి సంబంధం సుమారైనదని చెబుతుంది — వేరేలా నటించదు.
నేను టైప్ చేసేది నా పరికరం నుండి బయటకు వెళ్తుందా?
లేదు. లెక్క మీ బ్రౌజర్‌లోనే జరుగుతుంది; ఏదీ అప్‌లోడ్ కాదు, అప్‌లోడ్ చేయడానికి సర్వరే లేదు. పేజీని ఒకసారి తెరిస్తే, నెట్‌వర్క్ ఆపేసినా పనిచేస్తుంది.
మీరు text ను camelCase గా ఎందుకు మారుస్తారు
దాదాపు ఏ JavaScript ఫైల్‌ను, ఏ Java క్లాస్‌ను, ఏ Swift లేదా Kotlin సోర్స్‌ను తెరిచినా పేర్లు ఒకేలా కనిపిస్తాయి: userName, totalPrice, getCustomerById, isLoggedIn. పదాలు ఖాళీ లేకుండా, వేరుచేసే చిహ్నం లేకుండా కలిపి రాయబడతాయి, మొదటిది చిన్న అక్షరాలతో, తర్వాతి ప్రతిదీ పెద్ద అక్షరంతో మొదలవుతుంది, పదం మధ్యలోని ఆ గుబ్బలే ఈ శైలికి పేరు ఇచ్చాయి. ఇదే camelCase, C-కుటుంబ భాషలు వేరియబుల్‌లు, ఫంక్షన్‌ల కోసం స్థిరపడిన రూపం ఇదే. text ను camelCase గా మార్చడం అంటే మనిషి రాసే విధంగా ఉన్న వాక్యాన్ని ప్రోగ్రామ్ అంగీకరించే, ప్రోగ్రామర్ గుర్తించే పేరుగా మార్చడం.
ఒక వరుసను అతికించి camelCase లో తిరిగి చదవండి. మార్పిడి మీ బ్రౌజర్‌లో జరుగుతుంది, మీరు టైప్ చేసేదేదీ ఎక్కడికీ పంపబడదు, నియమాలు ఇంగ్లీష్‌ను కాక ఈ పేజీ భాషను అనుసరిస్తాయి. అది వరుసను పదాలుగా కోస్తుంది, మొదటిదాన్ని చిన్న అక్షరాలతో ఉంచుతుంది, తర్వాతి ప్రతిదాని మొదటి అక్షరాన్ని పెద్దది చేసి, వాటి మధ్య ఏమీ లేకుండా కలుపుతుంది. కింద పేజీ సరిగ్గా ఏం చేస్తుందో, ఏం చేయదో, వేర్వేరు భాషల కష్టమైన అక్షరాలను ఎలా చూస్తుందో, camelCase దాని పెద్ద తోబుట్టువుకు ఎలా భిన్నమో, ఈ రూపం ఎక్కడ సంప్రదాయమో ఎక్కడ కాదో, హడావుడిగా text ను 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 పేజీ ద్వారా పంపి, ఆపై text ను 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 ఆబ్జెక్ట్‌ల ప్రాపర్టీలు కూడా. మీరు text ను 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 ను పరిశీలించండి.
ఇక్కడ text ను 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. స్పెక్ యొక్క ఖచ్చితమైన పదాల నుంచి text ను 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 కోసం శోధన ఏదీ కనుగొనదు, అది కూడా సమాచారమే. మిశ్రమ శైలులు అదే ఆలోచనను స్పెల్లింగ్‌ల అంతటా చెదరగొట్టి శోధన నుంచి దాచేస్తాయి.
సురక్షితంగా పేరు మార్చడం
పేరు మారినప్పుడు, వెతికి మార్చడం కాక మీ ఎడిటర్‌లోని రీనేమ్ సాధనం పని చేయాలి. పేరు మార్చే ముందు, కొత్త పదాల నుంచి కొత్త పేరు కోసం text ను camelCase గా మార్చండి, తద్వారా కొత్త ఐడెంటిఫైయర్ మొదటి నుంచే సంప్రదాయాన్ని అనుసరిస్తుంది. తర్వాత ప్రతి సూచనను సాధనం నవీకరించనివ్వండి.
కొన్ని పేర్లను అవి ఉండే చోటే పరీక్షించండి
పేర్ల బ్యాచ్‌ను స్వీకరించే ముందు, ఎడిటర్‌లో అవి కనిపించే కోడ్ వరుసల లోపల మూడు లేదా నాలుగింటిని ప్రయత్నించండి. ప్రతి ఒక్కటి మిగతా వాటి పక్కన సహజంగా చదవబడితే, బ్యాచ్ మంచిది. ఒకటి ఎబ్బెట్టుగా ఉంటే, వాక్యాన్ని తిరిగి రాసి text ను camelCase గా మళ్లీ మార్చండి. చిన్న ప్రయత్నానికి ఒక నిమిషం ఖర్చవుతుంది, కోడ్‌బేస్ అంతటా పేరు మార్చడాన్ని తప్పిస్తుంది.
బాగా చదివే పేర్లు
ఫంక్షన్‌లకు క్రియతో మొదలుపెట్టండి
ఫంక్షన్ ఒక చర్య, దాని పేరు అలా చెప్పాలి: getUserName, calculateTotal, isValid. ఫంక్షన్ కోసం text ను camelCase గా మార్చినప్పుడు, వాక్యాన్ని క్రియతో మొదలుపెట్టండి.
విలువలకు నామవాచకాలు వాడండి
వేరియబుల్ ఒక వస్తువును పట్టుకుంటుంది: userName, totalPrice, orderList. బూలియన్‌లు ప్రశ్నలుగా ఉత్తమంగా చదవబడతాయి: isActive, hasAccess, canEdit.
సంక్షిప్తనామాలపై స్థిరంగా ఉండండి
కొన్ని బృందాలు parseHTML రాస్తాయి, కొన్ని parseHtml. రెండూ సరే; కలపడం కాదు. ఒకటి ఎంచుకుని ప్రతి పేరుకు వర్తింపజేయండి, మీ కోడ్ శోధించడం సులభమవుతుంది.
పేర్లను ఉచ్చరించగలిగేలా ఉంచండి
బిగ్గరగా చదవగలిగే పేరు మీరు చర్చించగలిగే పేరు. custFnDt అలాంటిది కాదు, customerFirstDate అలాంటిది. మార్పిడి మీరు రాసినదాన్ని అలాగే ఉంచుతుంది, కాబట్టి ఉంచదగినది రాయండి.
text ను camelCase గా మార్చేటప్పుడు ఉచ్చులు
అంకెతో మొదలయ్యే పేరు
చాలా భాషలు దాన్ని తిరస్కరిస్తాయి. ముందు ఒక పదాన్ని లేదా అక్షరాన్ని ఉంచండి.
రిజర్వ్ చేసిన పదాలు
class, new లేదా default వంటి పదం చాలా భాషలలో కీవర్డ్. పేజీకి ఏది కీవర్డ్ అనేది తెలియదు. పేరును వాడే ముందు తనిఖీ చేయండి.
సంక్షిప్తనామాలు, పెద్ద అక్షరాల వరుసలు
పెద్ద అక్షరాల వరుస చుట్టూ కోతలు మిమ్మల్ని ఆశ్చర్యపరచవచ్చు. ఫలితాన్ని చదివి మీ సంప్రదాయంతో పోల్చండి.
పేర్లలో యాక్సెంట్‌లు
కొన్ని భాషలలో అనుమతి, మరికొన్నిటిలో లేదు. పేరు పాత సాధనాల గుండా ప్రయాణించాల్సి ఉంటే, ముందుగా యాక్సెంట్‌లను తీసివేయండి.
మార్చే ముందు ప్రజలు అడిగే ప్రశ్నలు
విరామ చిహ్నాలకు ఏమవుతుంది?
అవి పదాల మధ్య సరిహద్దుగా చూడబడతాయి, తీసుకెళ్లబడవు.
సంఖ్యలు ఉంచబడతాయా?
అవును, సొంత పదాలుగా, మిగతా వాటికి కలిపి.
ఇది ఇప్పటికే snake_case లేదా kebab-case లో ఉన్న ఇన్‌పుట్‌ను నిర్వహిస్తుందా?
అవును. అండర్‌స్కోర్‌లు, హైఫన్‌లు సరిహద్దులు, కాబట్టి my_variable_name myVariableName అవుతుంది.
PascalCase ఎలా పొందాలి?
మార్చి, ఆపై మొదటి అక్షరాన్ని చేత్తో పెద్దది చేయండి.
నా వచనం అప్‌లోడ్ అవుతుందా?
లేదు. మీరు ఇక్కడ టైప్ చేసేది ఎక్కడికీ పంపబడదు, కాబట్టి డ్రాఫ్ట్, పాస్‌వర్డ్ లేదా క్లయింట్ పేరు టెక్స్ట్ ఎడిటర్‌లో ఉన్నంత సురక్షితంగా ఇక్కడ ఉంటాయి.
బదులుగా అండర్‌స్కోర్‌లు లేదా హైఫన్‌లు ఎలా పొందాలి?
text ను snake_case గా మార్చండి లేదా text ను kebab-case గా మార్చండి తో.
పరిష్కరించిన ఉదాహరణ
మీరు డెలివరీ రుసుమును లెక్కించే చిన్న స్క్రిప్ట్ రాస్తున్నారు, స్పెక్ విలువలను delivery fee per kilometre, free delivery threshold, is express order అని పిలుస్తుందనుకోండి. మీరు ప్రతిదాన్ని వరుసగా మార్చి deliveryFeePerKilometre, freeDeliveryThreshold, isExpressOrder చదువుతారు. మొదటిది నామవాచకంతో మొదలవుతుంది, విలువకు అది సరైనది; చివరిది is తో మొదలవుతుంది, అది అవును-కాదు ఫ్లాగ్‌ను సూచిస్తుంది. మీరు ఆ మూడింటినీ స్క్రిప్ట్‌లో వేరియబుల్ పేర్లుగా అతికిస్తారు, స్పెక్, కోడ్ ఇప్పుడు అదే పదాలను అదే క్రమంలో వాడతాయి, సమీక్ష సులభమవుతుంది.
చిన్న చెక్‌లిస్ట్
మార్చే ముందు
వాక్యాన్ని సాదా పదాలలో రాయండి. ఫంక్షన్‌లను క్రియతో, ఫ్లాగ్‌లను is లేదా has తో మొదలుపెట్టండి. రిజర్వ్ చేసిన పదాల కోసం లక్ష్య భాషను తనిఖీ చేయండి.
మార్చేటప్పుడు
వాక్యాన్ని అతికించి, కోతలను చూసి, పేరు అక్షరంతో మొదలవుతోందని నిర్ధారించుకోండి.
మార్చిన తర్వాత
పొడవును, సంక్షిప్తనామాలను తనిఖీ చేసి, పేరు అవసరమైన ప్రతిచోటా అదే పేరును వాడండి.
సాధారణ పొరపాట్లు
ప్రజలు చదివే వచనానికి camelCase వాడటం
ఇది పేర్ల కోసం, వచనం కోసం కాదు.
ఒక ప్రాజెక్ట్‌లో సంప్రదాయాలను కలపడం
ప్రతి పొరకు camelCase, snake_case లేదా kebab-case ఎంచుకుని, దానికి కట్టుబడి ఉండండి.
లక్ష్యం ఏది అనుమతిస్తుందో మరచిపోవడం
ఆరంభంలో అంకెలు, యాక్సెంట్‌లు, రిజర్వ్ చేసిన పదాలు భాషల మధ్య భిన్నంగా ఉంటాయి.
మీ వచనం మీ పరికరంలోనే ఉంటుంది
మార్పిడి స్థానికంగా జరుగుతుంది. మీ వచనాన్ని మీ సొంత బ్రౌజర్ నిర్వహిస్తుంది, ఏదీ ఎక్కడికీ పంపబడదు. తర్వాత తొలగించాల్సినది ఏదీ లేదు, సృష్టించాల్సిన ఖాతా లేదు. text ను camelCase గా మార్చడానికి అదే సరళమైన మార్గం.
సారాంశం
ఇక్కడ text ను camelCase గా మార్చడానికి, ఒక వరుసను అతికించి పదాలు కోయబడి, మొదటిది చిన్నదిగా, తర్వాతి ప్రతిదాని మొదటి అక్షరం పెద్దదిగా, అన్నీ మధ్య ఏమీ లేకుండా కలిపి తిరిగి చదవండి. ఇప్పటికే snake_case లేదా kebab-case లో రాసిన వరుస దాని వేరుచేసే చిహ్నాల వద్ద కోయబడుతుంది. పేజీ విరామ చిహ్నాలను ఉంచదు: కామాలు, చుక్కలు, డాష్‌లు పదాల మధ్య సరిహద్దులు, తీసుకెళ్లాల్సిన అక్షరాలు కాదు, వేరియబుల్ పేరుకు మీరు కోరేది అదే, వచనానికి కాదు. పదాలుగా కోయడానికి సరిహద్దులు కావాలి, కాబట్టి ఖాళీలు లేకుండా రాసే చైనీస్, జపనీస్ ఒకే పదంగా తిరిగి వస్తాయి. మొదటి అక్షరాన్ని పెద్దది చేయడం పేజీ భాషను అనుసరిస్తుంది, కాబట్టి టర్కిష్ i, İ అవుతుంది. ఏదీ అప్‌లోడ్ కాదు.