𝗣𝗮𝗰𝗸𝗮𝗴𝗲.𝗷𝘀𝗼𝗻 𝘃𝘀 𝗴𝗼.𝗺𝗼𝗱: 𝗪𝗵𝗲𝗿𝗲 𝗗𝗶𝗱 𝘁𝗵𝗲 𝗩𝗲𝗿𝘀𝗶𝗼𝗻 𝗙𝗶𝗲𝗹𝗱 𝗚𝗼?
మీరు JavaScript నుండి Go కి మారితే, ఒక విషయం మిమ్మల్ని ఆశ్చర్యపరుస్తుంది.
ఒక package.json ఫైల్ను తెరవండి. పైన చూడగానే మీకు ఒక వెర్షన్ ఫీల్డ్ కనిపిస్తుంది. ఇది చదవడానికి సులభంగా ఉంటుంది. మీరు ఒక pull request ద్వారా దానిని మార్చవచ్చు. ఇది మీ కోడ్లోనే ఉంటుంది.
ఇప్పుడు ఒక go.mod ఫైల్ను తెరవండి.
అక్కడ వెర్షన్ ఉండదు. ఇది పొరపాటు కాదు. ఇది ఒక ఎంపిక.
Go మీ స్వంత మాడ్యూల్ కోసం వెర్షన్ ఫీల్డ్ను ఉపయోగించదు. దానికి బదులుగా ఇది git tags ఉపయోగిస్తుంది.
ఇది ఎలా పనిచేస్తుంది:
• మీరు git tag v1.2.3 రన్ చేస్తారు
• మీరు ఆ ట్యాగ్ను మీ రిపోజిటరీకి పుష్ చేస్తారు
• ఆ ట్యాగ్ మీ వెర్షన్గా మారుతుంది
ఎవరైనా go get రన్ చేసినప్పుడు, సరైన కమిట్ను కనుగొనడానికి Go మీ git tags ను చూస్తుంది. ఆ ట్యాగ్ మాత్రమే ఏకైక సత్య మూలం (single source of truth).
ఈ డిజైన్కు ఒక ప్రధాన బలం ఉంది. వెర్షన్ ఎప్పుడూ తప్పు కోడ్ను సూచించదు. npmలో, పబ్లిష్ చేయబడిన కోడ్ మరియు వెర్షన్ ఫీల్డ్ వేరువేరుగా ఉండే అవకాశం ఉంది. కానీ Goలో, అవి రెండూ ఒకటే. వెర్షన్ అంటేనే కమిట్.
అయితే, ఇది మీ వర్క్ఫ్లోను మారుస్తుంది:
- విజిబిలిటీ (Visibility): మీరు కేవలం ఒక ఫైల్ను చూసి మీ వెర్షన్ను తెలుసుకోలేరు. దానిని కనుగొనడానికి మీరు ఒక git కమాండ్ను రన్ చేయాలి.
- కోడ్ రివ్యూలు (Code Reviews): వెర్షన్ పెంచడం (version bump) అనేది కోడ్ డిఫ్ (code diff)లో కనిపించదు. ఇది ఒక ట్యాగ్ పుష్ మాత్రమే, కోడ్ మార్పు కాదు.
- లోకల్ బిల్డ్స్ (Local Builds): ట్యాగ్ లేని కమిట్ ఒక గందరగోళమైన pseudo-versionను చూపిస్తుంది. మీరు కమిట్కు ట్యాగ్ చేసిన తర్వాతే మీకు స్పష్టమైన వెర్షన్ లభిస్తుంది.
- మేజర్ వెర్షన్లు (Major Versions): ఇది అతిపెద్ద మార్పు. Goలో, v2 మరియు అంతకంటే పై వెర్షన్లు ఇంపోర్ట్ పాత్లో (import path) వెర్షన్ను కలిగి ఉండాలి.
ఉదాహరణ:
v1 github.com/you/my-app ఉపయోగిస్తుంది
v2 github.com/you/my-app/v2 ఉపయోగిస్తుంది
దీనివల్ల ఒకే ప్రోగ్రామ్ ఎటువంటి ఘర్షణ (conflict) లేకుండా ఒకే లైబ్రరీ యొక్క రెండు వేర్వేరు మేజర్ వెర్షన్లను ఉపయోగించుకోవచ్చు.
మిగిలిన చాలా భాషలు వెర్షన్ను ఒక ఫైల్లో ఉంచుతాయి: • Node: package.json • Rust: Cargo.toml • Python: pyproject.toml • Java: pom.xml
Go ఇక్కడ భిన్నంగా ఉంటుంది. ఇది పూర్తిగా git tags పైనే ఆధారపడుతుంది.
మీకు npm అనుభవం కావాలనుకుంటే, ldflags ఉపయోగించి బిల్డ్ సమయంలో మీ బైనరీలోకి వెర్షన్ను ఇంజెక్ట్ చేయవచ్చు. దీనివల్ల మీ యాప్ వెర్షన్ కమాండ్కు స్పందించగలదు.
దీని లాభనష్టాల (trade-off) మధ్య తేడా సరళమైనది: వెర్షన్ ఫీల్డ్ చదవడానికి మరియు రివ్యూ చేయడానికి సులభంగా ఉంటుంది, కానీ అది తప్పు సమాచారాన్ని ఇవ్వవచ్చు. git tag చూడటం కష్టం, కానీ అది ఎప్పుడూ నిజం.
Go సౌలభ్యం కంటే సత్యాన్ని ఎంచుకుంది.
Go డెవలపర్లకు: ఇది ఉత్తమ మోడలా? ఒకవేళ టూల్స్ git tag తో వెర్షన్ను సరిచూస్తే, మీరు go.modలో వెర్షన్ ఫీల్డ్ను కోరుకుంటారా?
Source: https://dev.to/dalirnet/packagejson-vs-gomod-where-did-the-version-field-go-3301