వచనాన్ని snake_case గా మార్చడం underscore_case ఉచితం ఆన్‌లైన్ సురక్షితం
ఒక పంక్తిని అతికిస్తే వెంటనే snake_case లో చదవవచ్చు. అంతా మీ బ్రౌజర్‌లోనే జరుగుతుంది — మీరు రాసేది ఎక్కడికీ పంపబడదు — నియమాలు ఇంగ్లీషువి కావు, ఈ పేజీ భాషవి.
దీన్ని వేరే విధంగా రాయండి
ఏదీ అప్‌లోడ్ కాదు
అదే పంక్తి, ఏడు రాతల్లోనూ
| రాత | అదే పంక్తి, ఆ విధంగా రాసినది |
|---|---|
| పెద్ద అక్షరాలు | 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 ను snake_case గా ఎందుకు మారుస్తారు
ప్రోగ్రామర్ వేరియబుల్‌కు annual report total అని పేరు పెట్టలేడు, ఎందుకంటే పేరులో ఖాళీ ఉండకూడదు. డేటాబేస్ నిలువు వరుసను Customer First Name అని పిలవలేము. Final Draft (2).docx అనే ఫైల్ ఏదో ఒక రోజు స్క్రిప్ట్‌కు ఇబ్బంది కలిగిస్తుంది. దారిలో ఎక్కడో మానవ వాక్యం ఒకే పదంగా మారాలి, చాలా సముదాయాలు స్థిరపడిన రూపం snake_case: అన్ని అక్షరాలు చిన్నవి, పదాలు అండర్‌స్కోర్‌లతో కలుపబడతాయి, annual_report_total, customer_first_name, final_draft_2. text ను snake_case గా మార్చడం అంటే ఏ స్థితిలో ఉన్న ఏ వాక్యాన్నైనా ఒకే అడుగులో ఆ రూపంలోకి మార్చడం.
ఒక వరుసను అతికించి snake_case లో తిరిగి చదవండి. మార్పిడి మీ బ్రౌజర్‌లో జరుగుతుంది, మీరు టైప్ చేసేదేదీ ఎక్కడికీ పంపబడదు, నియమాలు ఇంగ్లీష్‌ను కాక ఈ పేజీ భాషను అనుసరిస్తాయి. అది వరుసను పదాలుగా కోస్తుంది, చిన్న అక్షరాలకు మార్చి అండర్‌స్కోర్‌లతో కలుపుతుంది. ఇప్పటికే camelCase లో రాసిన వరుస దాని పెద్ద అక్షరాల వద్ద కూడా కోయబడుతుంది, కాబట్టి fooBar foo_bar అవుతుంది. కింద దాని అర్థం సరిగ్గా ఏమిటో, ఏది వదిలేయబడుతుందో, వేర్వేరు భాషల కష్టమైన అక్షరాలను పేజీ ఎలా చూస్తుందో, snake_case ఎక్కడ సంప్రదాయమో ఎక్కడ కాదో, హడావుడిగా text ను snake_case గా మార్చేవారిని పట్టుకునే ఉచ్చులు ఏమిటో కనిపిస్తాయి.
మార్పిడి ఏం చేస్తుంది
కోయి, చిన్న అక్షరాలకు మార్చి, కలుపు
పేజీ మొదట వరుసను పదాలుగా కోస్తుంది. తర్వాత ప్రతిదాన్ని చిన్న అక్షరాలకు మార్చి అండర్‌స్కోర్‌లతో కలుపుతుంది. Crème brûlée for 2 — straße 17, fooBar అనే వరుస crème_brûlée_for_2_straße_17_foo_bar గా తిరిగి వస్తుంది. యాక్సెంట్‌లు ఉంచబడతాయి, సంఖ్యలు సొంత పదాలుగా నిలుస్తాయి, డాష్, కామా పోతాయి, fooBar రెండుగా కోయబడింది, ఎందుకంటే దాని లోపలి పెద్ద అక్షరం సరిహద్దును సూచిస్తుంది.
కోతలు ఎక్కడ పడతాయి
పద సరిహద్దు అంటే ఖాళీ, విరామ చిహ్నం, డాష్, గుర్తు, లేదా పదం లోపల చిన్న అక్షరం నుంచి పెద్ద అక్షరానికి మార్పు. కాబట్టి customerFirstName వాక్యం, Customer First Name వాక్యం, customer-first-name వాక్యం అన్నీ customer_first_name అవుతాయి. మార్పిడి యొక్క ఆచరణాత్మక బలం అదే: అది దాదాపు ఏ ప్రారంభ బిందువునైనా అంగీకరించి ఎల్లప్పుడూ అదే చోటుకు చేరుతుంది.
ఫలితాన్ని కాపీ చేయడం
ఫలితం పక్కన ఉన్న బటన్ దాన్ని క్లిప్‌బోర్డ్‌కు కాపీ చేస్తుంది. పేరు అవసరమైన ఎడిటర్‌లో, స్కీమాలో లేదా ఫైల్ డైలాగ్‌లో అతికించండి.
మార్పిడి ఏం చేయదు
ఇది విరామ చిహ్నాలను ఉంచదు
కామాలు, చుక్కలు, డాష్‌లు పదాల మధ్య సరిహద్దులు, తీసుకెళ్లాల్సిన అక్షరాలు కాదు. ఫైల్ పేరుకు లేదా డేటాబేస్ నిలువు వరుసకు మీరు కోరేది అదే, వచనానికి కోరేది కాదు. మీరు వాక్యాన్ని పేజీ ద్వారా పంపితే, అది వాక్యంగా కాక పేరుగా తిరిగి వస్తుంది, అసలు విరామ చిహ్నాలు పోతాయి.
ఇది యాక్సెంట్‌లను తొలగించదు
వరుస తన యాక్సెంట్ అక్షరాలను ఉంచుకుంటుంది: crème_brûlée. చాలా వ్యవస్థలు వాటిని అంగీకరిస్తాయి, కానీ కొన్ని అంగీకరించవు, వాటిని కలిగిన పేరు పాత సాధనాలలో ఇబ్బంది కలిగించవచ్చు. మీకు సాదా అక్షరాలు కావాలంటే, లాటిన్ అక్షరాల నుంచి గుర్తులను తీసివేసే URL slug పేజీని వాడండి.
పేరు మీ భాషలో చెల్లుబాటవుతుందో ఇది తనిఖీ చేయదు
ప్రోగ్రామింగ్ భాషలకు సొంత నియమాలు ఉన్నాయి. కొన్ని అంకెతో మొదలయ్యే పేరును నిషేధిస్తాయి, కొన్ని class లేదా return వంటి పదాలను రిజర్వ్ చేస్తాయి. పేజీ వచనాన్ని సరైన ఆకారం గల పేరుగా మారుస్తుంది, మీరు వాడే చోట పేరు చట్టబద్ధమైనదో నిర్ధారించుకోవడం ఇంకా మీ పని. 2 for 1 offer వంటి వాక్యం 2_for_1_offer అవుతుంది, చాలా భాషలు ఆరంభంలోనే దాన్ని తిరస్కరిస్తాయి.
భాష ముఖ్యం
ఖాళీలు లేకుండా రాసే లిపులు
పదాలుగా కోయడానికి సరిహద్దులు కావాలి. చైనీస్, జపనీస్ ఖాళీలు లేకుండా రాస్తారు, కాబట్టి ఆ లిపులలోని వరుస ఒకే పదంగా తిరిగి వస్తుంది. తప్పు కోత నమ్మదగినట్లు కనిపించి తప్పు అర్థం ఇచ్చే పేరును తయారు చేస్తుంది కాబట్టి, ఊహించిన చోట కోయడం కంటే అలా చెప్పడమే పేజీకి ఇష్టం.
టర్కిష్, చుక్క ఉన్న i
చిన్న అక్షరాలకు మార్చడం పేజీ భాష నియమాలను అనుసరిస్తుంది. టర్కిష్‌లో I యొక్క చిన్న రూపం చుక్క లేని ı, İ యొక్క చిన్న రూపం i. ఇంగ్లీష్ నియమాలు వర్తింపజేసే కన్వర్టర్ పదాలను మారుస్తుంది. ఈ పేజీ అది రాయబడిన భాషను అనుసరిస్తుంది.
జర్మన్, పదునైన s
జర్మన్ ß ఇప్పటికే చిన్న అక్షరం, straße_17 లో లాగా ఉంచబడుతుంది. పెద్ద అక్షరాల STRASSE strasse గా తిరిగి వస్తుంది, ఎందుకంటే పెద్ద అక్షర రూపం అది ß నుంచి వచ్చిందా లేక రెండు అక్షరాల నుంచా అనేది గుర్తుంచుకోదు.
కుడి-నుంచి-ఎడమ, భారతీయ లిపులు
అరబిక్, హీబ్రూ, భారతీయ లిపులలో పదాల మధ్య ఖాళీలు ఉంటాయి, కేస్ ఉండదు, కాబట్టి పేజీ వాటి పదాలను అండర్‌స్కోర్‌లతో కలిపి అక్షరాలను అలాగే వదిలేస్తుంది. అలాంటి పేర్లను ఒక సాధనం అంగీకరిస్తుందా అనేది వేరే ప్రశ్న.
snake_case సంప్రదాయంగా ఉన్న చోట్లు
Python, Ruby
Python శైలి మార్గదర్శకం ఫంక్షన్‌లు, వేరియబుల్‌లు, మాడ్యూల్‌లకు snake_case ను సిఫార్సు చేస్తుంది, Ruby అదే అలవాటును అనుసరిస్తుంది. మీరు వాటిలో ఏ దానిలో కోడ్ రాసినా, మీ పేర్లు దాదాపు ఎల్లప్పుడూ ఈ రూపంలోనే ఉంటాయి.
డేటాబేస్‌లు
SQL లో పట్టిక, నిలువు వరుస పేర్లు సాధారణంగా snake_case: customer_id, created_at, order_total. ఇది పేర్లను కొటేషన్‌లలో ఉంచాల్సిన అవసరాన్ని తప్పిస్తుంది, డేటాబేస్ వ్యవస్థల అంతటా సురక్షితం, వాటిలో కొన్ని కొటేషన్ లేని పేర్లను ఒకే కేస్‌కు మడిచి camelCase ను చదవలేని అక్షరాల వరుసగా మారుస్తాయి.
డేటా ఫైళ్లు, API లు
చాలా వెబ్ సేవలు తమ JSON లో snake_case కీలను వాడతాయి, తదుపరి ప్రాసెసింగ్ కోసం ఎగుమతి చేసిన స్ప్రెడ్‌షీట్‌లు తరచూ snake_case శీర్షికలను కలిగి ఉంటాయి. మీ డేటా CSV ను JSON గా గుండా వెళ్తుంటే, శీర్షిక వరుస కీలు అవుతుంది, చక్కని snake_case శీర్షికలు ఫలితాన్ని వాడటం సులభం చేస్తాయి.
స్థిరాంకాలు, ఎన్విరాన్‌మెంట్ వేరియబుల్‌లు
స్థిరాంకాలు, ఎన్విరాన్‌మెంట్ వేరియబుల్‌లు సంప్రదాయంగా అండర్‌స్కోర్‌లతో పెద్ద అక్షరాలలో రాస్తారు: MAX_RETRIES, DATABASE_URL. వాటిని పొందే మార్గం ముందుగా text ను snake_case గా మార్చి, ఆపై ఫలితాన్ని text ను uppercase గా మార్చండి తో పెద్దదిగా చేయడం.
ఫైల్ పేర్లు
అండర్‌స్కోర్‌లతో చిన్న అక్షరాలు ప్రతి వ్యవస్థలోనూ సురక్షితమైన ఫైల్ పేరు, అది ఊహించదగిన విధంగా క్రమబద్ధీకరించబడుతుంది, శోధించబడుతుంది. చాలామంది ఫోటోగ్రాఫర్‌లు, పరిశోధకులు, నిర్వాహకులు సరిగ్గా అందుకే దాన్ని వాడతారు.
సంప్రదాయం కాని చోట్లు
JavaScript, Java
ఈ భాషలు వేరియబుల్‌లు, ఫంక్షన్‌లకు camelCase ను, క్లాస్‌లకు PascalCase ను ఇష్టపడతాయి. Python స్క్రిప్ట్‌లోని పేరు JavaScript ఫైల్‌లో కనిపించే ముందు మార్చాల్సి రావచ్చు. దాని కోసం camelCase చూడండి.
CSS, వెబ్ చిరునామాలు
CSS క్లాస్ పేర్లు, వెబ్ చిరునామాలు సాధారణంగా అండర్‌స్కోర్‌లు కాక హైఫన్‌లు వాడతాయి. దానికి సాధనం kebab-case. సెర్చ్ ఇంజిన్‌లు హైఫన్‌ను పద వేరుచేసేదిగా, అండర్‌స్కోర్‌ను కలిపేదిగా చూస్తాయి, హైఫన్ చిరునామాల అలవాటు వెనుక ఉన్నది ఈ చిన్న తేడా.
వచనం, శీర్షికలు
snake_case పేర్ల కోసం, చదవడానికి కాదు. దానిలో శీర్షిక లేదా వాక్యం కంటికి కష్టం. మానవ వచనానికి, పదాలను, ఖాళీలను ఉంచండి, శీర్షిక కోసం Title Case ను పరిశీలించండి.
ఇక్కడ text ను snake_case గా ఎలా మార్చాలి
మీ వచనాన్ని అతికించండి లేదా టైప్ చేయండి
వాక్యాన్ని మొదటి ఫీల్డ్‌లో నమోదు చేయండి. ఫలితం వెంటనే రెండో దానిలో కనిపిస్తుంది, కాబట్టి మీరు టైప్ చేస్తున్నప్పుడే అది మారడం చూడవచ్చు.
కోతలను తనిఖీ చేయండి
పదాలు ఎక్కడ విభజించబడ్డాయో చూడండి. iPhone లేదా eBay వంటి పదం పెద్ద అక్షరం వద్ద కోయబడుతుంది, HTTPServer వంటి సంక్షిప్తనామం మీరు ఉద్దేశించినట్లే వచ్చిందో చూడటానికి ఒక చూపు అవసరం.
కాపీ చేయండి
కాపీ బటన్ నొక్కి ఫలితాన్ని మీకు కావలసిన చోట అతికించండి. అదే వరుస ఇతర రూపాల కోసం, కింద చూడండి.
మొత్తం ప్రాజెక్ట్ అంతటా snake_case వాడటం
మొత్తం స్టాక్‌కు ఒకే సంప్రదాయం
పేరు పెట్టే శైలులను కలిపే ప్రాజెక్ట్ కొద్దిగా వికారంగా కానీ స్థిరంగా ఉన్నదాని కంటే చదవడం కష్టం. డేటాబేస్ snake_case వాడితే, దానితో మాట్లాడే కోడ్ కూడా తరచూ వాడుతుంది, వాటి మధ్య తరలే ఫైళ్లు అనుసరిస్తాయి. కొత్త నిలువు వరుస లేదా కొత్త ఫీల్డ్ కోసం text ను snake_case గా మార్చినప్పుడు, మిగతా ప్రతి పొర కలిసి బతకాల్సిన పేరును మీరు ఎంచుకుంటున్నారు, కాబట్టి ఒకసారి ఎంచుకుని అంతటా కొనసాగించండి.
సంప్రదాయాల మధ్య పేర్లను తరలించడం
ఒక సంప్రదాయంలోని పేరు మరొకదానిలో కనిపించాల్సిన సమయం ఎప్పుడో వస్తుంది. డేటాబేస్ నిలువు వరుస customer_first_name JavaScript ఆబ్జెక్ట్‌లో customerFirstName అవుతుంది, CSS క్లాస్‌లో లేదా URL లో customer-first-name అవుతుంది. ప్రతిదాన్ని చేత్తో మళ్లీ టైప్ చేయడానికి బదులు, మీకు కావలసిన రూపాన్ని తయారు చేసే పేజీలో అసలును అతికించండి: C, JavaScript కుటుంబాల కోడ్ కోసం camelCase, శైలులు, చిరునామాల కోసం kebab-case. ఒకే పేరు యొక్క మూడు రూపాలు ఒకదానికొకటి ఖచ్చితమైన అనువాదాలు, కన్వర్టర్ వాటిని స్థిరంగా చేస్తుంది.
కాన్ఫిగరేషన్ ఫైళ్లు
సెట్టింగ్‌ల ఫైళ్లు తరచూ snake_case కీలను వాడతాయి, ముఖ్యంగా చాలా సాధనాలు వాడే YAML లో. JSON గా ఉంచిన డేటా నుంచి అలాంటి ఫైల్‌ను సిద్ధం చేసేటప్పుడు, JSON ను YAML గా కీలను మీరు రాసినట్లే ఉంచుతుంది, YAML ను JSON గా దానికి వ్యతిరేకం చేస్తుంది. మొదలుపెట్టే ముందు కీలకు snake_case నిర్ణయించుకోండి, ఫార్మాట్‌ల మధ్య మార్పిడి వాటిని చెదరగొట్టదు.
పెద్ద ఎత్తున పేరు మార్చడం
మీకు వారసత్వంగా వచ్చిన డేటా ఫైల్ శీర్షికలు శైలుల మిశ్రమం అయితే, ప్రతి శీర్షికను ఈ పేజీతో మార్చి ఒకే పాస్‌లో వాటిని భర్తీ చేయండి. ముందుగా చిన్న నమూనాతో పరీక్షించండి, ఎందుకంటే శీర్షిక ద్వారా ఫైల్‌ను చదివే స్క్రిప్ట్ కొన్ని చోట్ల మాత్రమే పేరు మారితే విరిగిపోతుంది. సహోద్యోగి ఏం మారిందో చూడగలిగేలా ఫైల్ పక్కన పాత, కొత్త పేర్ల జాబితా ఉంచండి.
నిలిచే పేర్లను రాయడం
వస్తువు ఏమిటో చెప్పండి, ఎలా నిల్వ చేయబడిందో కాదు
మంచి పేరు కంటెంట్‌ను వర్ణిస్తుంది. order_total సంఖ్య అర్థం ఏమిటో చెబుతుంది; col7 చెప్పదు. text ను snake_case గా మార్చేటప్పుడు, మీరు మొదలుపెట్టే వాక్యం మీరు రాయగలిగిన స్పష్టమైనదని నిర్ధారించుకోండి, ఎందుకంటే కన్వర్టర్ దాని స్పష్టతను లేదా గందరగోళాన్ని నమ్మకంగా నిలుపుతుంది.
మీకు మాత్రమే అర్థమయ్యే సంక్షిప్తరూపాలను తప్పించండి
cust_fn_dt వంటి పేరు మరెవరికైనా, ఆరు నెలల్లో మీకు కూడా, పొడుపుకథ. అండర్‌స్కోర్‌లు చౌక, అదనపు పదాలు కూడా. వాక్యంలా చదివే పొడవైన పేరు, వివరణ అవసరమైన చిన్నదాని కంటే తర్వాతి వ్యక్తికి మంచి బహుమతి.
ఏకవచనం, బహువచనం స్థిరంగా ఉంచండి
పట్టికలకు ఏకవచనంలో, customer, లేదా బహువచనంలో, customers, పేరు పెట్టాలో నిర్ణయించి దానికి కట్టుబడి ఉండండి. సంప్రదాయం కంటే దాని ఏకరూపతే ముఖ్యం. snake_case గా మార్చిన వాక్యం మీరు ఇచ్చిన వచనాన్ని అలాగే ఉంచుతుంది.
సహాయపడినప్పుడు ప్రిఫిక్స్ వాడండి
పెద్ద స్కీమాలో, చిన్న ప్రిఫిక్స్ సంబంధిత పేర్లను సమూహపరుస్తుంది: billing_address, billing_city, billing_country. ప్రిఫిక్స్‌తో వాక్యాన్ని టైప్ చేసి మార్చడం స్థిరమైన ఫలితాలను ఇస్తుంది, అక్షర క్రమ జాబితా తనను తానే సమూహపరుస్తుంది.
పేర్లకు కట్టుబడే ముందు పరీక్షించండి
పేరు స్కీమాలోకి లేదా API లోకి వెళ్లే ముందు, అది కనిపించే చోట్ల ప్రయత్నించండి: క్వెరీ, వేరియబుల్, ఫైల్ జాబితా. మూడింటిలోనూ సహజంగా చదవబడితే, అది ఉపయోగపడుతుంది. ఎబ్బెట్టుగా అనిపిస్తే, వాక్యాన్ని కుదించండి లేదా తిరిగి రాసి text ను snake_case గా మళ్లీ మార్చండి. ప్రారంభంలో ఒక నిమిషం పరీక్ష తర్వాత వందల ఫైళ్లలో పేరు మార్చడాన్ని తప్పిస్తుంది.
ఏడు రచనా రూపాలలో అదే వరుస
రూపాల పట్టిక
కన్వర్టర్ కింద, ఒక పట్టిక ఉదాహరణ వరుసను సైట్ అందించే ఏడు రూపాలలో చూపుతుంది: పెద్ద అక్షరాలు, చిన్న అక్షరాలు, Title Case, snake_case, kebab-case, camelCase, URL slug. అవే పదాలు ప్రతిదానిలో ఎలా కనిపిస్తాయో చూడటానికి ఇది త్వరిత మార్గం.
ఈ రూపాలు ఎక్కడి నుంచి వచ్చాయి
రెండు వర్ణమాలలు
పెద్ద, చిన్న అక్షరాలు ఒకప్పుడు రెండు వేర్వేరు వర్ణమాలలు. పెద్ద అక్షరాలు రోమన్, ఉలితో రాతిలో చెక్కినవి; చిన్న అక్షరాలు చర్మపత్రంపై వేగంగా కదిలే కలం ఆకృతి ఇచ్చిన కరోలింగియన్ మినస్క్యూల్ నుంచి వచ్చాయి. ముద్రణకారులు రెండింటినీ వేర్వేరు ట్రేలలో ఉంచారు, అప్పర్ కేస్, లోయర్ కేస్, ట్రేలు పోయిన చాలా కాలానికి కూడా పేర్లు నిలిచిపోయాయి.
ఖాళీలు లేని పేర్లు
ప్రోగ్రామింగ్ రూపాలు చాలా కొత్తవి, ఒక సమస్యను పరిష్కరించడానికి కనుగొనబడ్డాయి: పేరులో ఖాళీ ఉండకూడదు. snake_case తొలి C నుంచి వచ్చింది, camelCase Smalltalk నుంచి, kebab-case Lisp నుంచి, URL slug ఖాళీలు, యాక్సెంట్‌లు అనుమతి లేని చిరునామాలో మానవ శీర్షికను ఉంచాల్సిన అవసరం నుంచి. అప్పటి కీబోర్డ్‌లపై అండర్‌స్కోర్ అనుకూలమైన అక్షరం, అది గీతపై కూర్చున్న ఖాళీలా కనిపిస్తుంది.
text ను snake_case గా మార్చేటప్పుడు ఉచ్చులు
పేరును అంకెతో మొదలుపెట్టడం
చాలా భాషలు, డేటాబేస్‌లు సంఖ్యతో మొదలయ్యే పేరును తిరస్కరిస్తాయి. వాక్యం ఒకదానితో మొదలైతే ముందు అక్షరాన్ని లేదా పదాన్ని చేర్చండి.
రిజర్వ్ చేసిన పదాలు నిర్వహించబడతాయని ఆశించడం
class లేదా order వంటి పదం మీ భాషలో లేదా SQL లో రిజర్వ్ చేసిన పదం కావచ్చు. పేజీకి తెలియదు, మీరు తనిఖీ చేయాలి.
సంక్షిప్తనామాలు
parseHTMLString వంటి camelCase పేరు లోపలి సంక్షిప్తనామం నియమాన్ని బట్టి parse_h_t_m_l_string లేదా parse_html_string గా కోయబడవచ్చు. ఫలితం మీకు కావలసినదేనని తనిఖీ చేయండి.
చాలా పొడవైన పేర్లు
డేటాబేస్‌లు, ఫైల్ వ్యవస్థలు పొడవు పరిమితులు విధిస్తాయి. పేరుగా మార్చిన పొడవైన వాక్యం ఒకదానిని తాకవచ్చు. మార్చే ముందు పదాలను కుదించండి.
మార్చే ముందు ప్రజలు అడిగే ప్రశ్నలు
విరామ చిహ్నాలకు ఏమవుతుంది?
అవి పదాల మధ్య సరిహద్దుగా చూడబడతాయి, తీసుకెళ్లబడవు.
సంఖ్యలు ఉంచబడతాయా?
అవును, సొంత పదాలుగా, అండర్‌స్కోర్‌లతో వేరు చేయబడి.
ఇది camelCase ఇన్‌పుట్‌ను నిర్వహిస్తుందా?
అవును. పదం లోపలి పెద్ద అక్షరం కోతను సూచిస్తుంది, కాబట్టి fooBar foo_bar అవుతుంది.
నేను దీన్ని ఇతర భాషలకు వాడవచ్చా?
అవును, పేజీ భాష నియమాలతో. చైనీస్, జపనీస్ వంటి ఖాళీలు లేని లిపులు ఒకే పదంగా తిరిగి వస్తాయి.
నా వచనం అప్‌లోడ్ అవుతుందా?
లేదు. మీరు ఇక్కడ టైప్ చేసేది ఎక్కడికీ పంపబడదు, కాబట్టి డ్రాఫ్ట్, పాస్‌వర్డ్ లేదా క్లయింట్ పేరు టెక్స్ట్ ఎడిటర్‌లో ఉన్నంత సురక్షితంగా ఇక్కడ ఉంటాయి.
బదులుగా హైఫన్‌లు ఎలా పొందాలి?
text ను kebab-case గా మార్చండి తో.
పరిష్కరించిన ఉదాహరణ
మీరు ఒక గ్రంథాలయం కోసం చిన్న డేటాబేస్ నిర్మిస్తున్నారు, సిబ్బంది తమ స్ప్రెడ్‌షీట్ నుంచి నిలువు వరుస శీర్షికలను పంపారనుకోండి: Book Title, Author's Last Name, Year Published (YYYY), ISBN-13. మీరు ప్రతిదాన్ని వరుసగా మార్చి book_title, author_s_last_name, year_published_yyyy, isbn_13 చదువుతారు. అపాస్ట్రఫీ రచయిత నిలువు వరుసను అపరిశుభ్రంగా మార్చింది, కాబట్టి అసలును Author Last Name కు కుదించి మళ్లీ మారుస్తారు: author_last_name. సంవత్సరం నిలువు వరుస ఫార్మాట్ గమనిక లేకుండా స్పష్టంగా ఉంది, కాబట్టి year_published ఉంచుతారు. నాలుగు చక్కని నిలువు వరుస పేర్లు, ఒక నిమిషంలో రాయబడ్డాయి, ప్రతిదీ డేటాబేస్ అంగీకరించే పేరు.
చిన్న చెక్‌లిస్ట్
మార్చే ముందు
వాక్యాన్ని బ్రాకెట్‌లలో గమనికలు లేకుండా సాదా పదాలలో రాయండి. లక్ష్యం అండర్‌స్కోర్‌లను, యాక్సెంట్‌లను అంగీకరిస్తుందో తనిఖీ చేయండి.
మార్చేటప్పుడు
వాక్యాన్ని అతికించి, కోతలను చూసి, పేరు అక్షరంతో మొదలవుతోందని నిర్ధారించుకోండి.
మార్చిన తర్వాత
పొడవును తనిఖీ చేయండి, రిజర్వ్ చేసిన పదాలతో సరిచూడండి, పేరును దాని అర్థానికి వెనక్కి గుర్తించగలిగేలా అసలు వాక్యం రికార్డును ఉంచండి.
సాధారణ పొరపాట్లు
ప్రజలు చదివే వచనానికి snake_case వాడటం
ఇది పేర్ల కోసం, వచనం కోసం కాదు.
లక్ష్యం ఏది అనుమతిస్తుందో మరచిపోవడం
ఆరంభంలో అంకెలు, యాక్సెంట్‌లు, పొడవు పరిమితులు వ్యవస్థల మధ్య భిన్నంగా ఉంటాయి.
చూడకుండా సంక్షిప్తనామాలను మార్చడం
వాటి చుట్టూ కోతలను తనిఖీ చేయండి.
మీ వచనం మీ పరికరంలోనే ఉంటుంది
మార్పిడి స్థానికంగా జరుగుతుంది. మీ వచనాన్ని మీ సొంత బ్రౌజర్ నిర్వహిస్తుంది, ఏదీ ఎక్కడికీ పంపబడదు. తర్వాత తొలగించాల్సినది ఏదీ లేదు, సృష్టించాల్సిన ఖాతా లేదు. text ను snake_case గా మార్చడానికి అదే సరళమైన మార్గం.
సారాంశం
ఇక్కడ text ను snake_case గా మార్చడానికి, ఒక వరుసను అతికించి పదాలు కోయబడి, చిన్న అక్షరాలకు మార్చబడి, అండర్‌స్కోర్‌లతో కలిపి తిరిగి చదవండి. ఇప్పటికే camelCase లో రాసిన వరుస అక్కడ కూడా కోయబడుతుంది, కాబట్టి fooBar foo_bar అవుతుంది. పేజీ విరామ చిహ్నాలను ఉంచదు: కామాలు, చుక్కలు, డాష్‌లు పదాల మధ్య సరిహద్దులు, తీసుకెళ్లాల్సిన అక్షరాలు కాదు, ఫైల్ పేరుకు లేదా డేటాబేస్ నిలువు వరుసకు మీరు కోరేది అదే, వచనానికి కాదు. పదాలుగా కోయడానికి సరిహద్దులు కావాలి, కాబట్టి ఖాళీలు లేకుండా రాసే చైనీస్, జపనీస్ ఒకే పదంగా తిరిగి వస్తాయి. చిన్న అక్షరాలకు మార్చడం పేజీ భాషను అనుసరిస్తుంది. ఏదీ అప్‌లోడ్ కాదు.