𝗣𝗮𝗰𝗸𝗮𝗴𝗲.𝗷𝘀𝗼𝗻 vs 𝗚𝗼.𝗺𝗼𝗱: వెర్షన్ ఫీల్డ్ ఎక్కడికి పోయింది?
మీరు JavaScript నుండి Go కి మారితే, ఒక విషయం మిమ్మల్ని ఆశ్చర్యపరుస్తుంది.
package.json ఫైల్లో, వెర్షన్ సరిగ్గా పైన ఉంటుంది. మీరు దానిని చదవవచ్చు. మీరు pull request లో దానిని మార్చవచ్చు. మీరు దాని కోసం వెతకవచ్చు. అది మీ కోడ్లోనే ఉండే ఒక వాస్తవం.
ఇప్పుడు ఒక go.mod ఫైల్ను తెరవండి. అక్కడ వెర్షన్ ఉండదు.
ఇది పొరపాటు కాదు. ఇది ఒక ఎంపిక.
Go మీ స్వంత మాడ్యూల్ కోసం వెర్షన్ ఫీల్డ్ను ఉపయోగించదు. దానికి బదులుగా, Go git tags ఉపయోగిస్తుంది.
Goలో వెర్షన్ను సెట్ చేయడానికి, మీరు ఇలా చేయాలి:
- git tag v1.2.3
- git push origin v1.2.3
git tag అనేది ఏకైక నిజమైన మూలం (single source of truth). ఎవరైనా go get రన్ చేసినప్పుడు, సరైన commitని కనుగొనడానికి Go మీ రిపోజిటరీ ట్యాగ్లను చూస్తుంది.
ఈ డిజైన్కు ఒక ప్రధాన బలం ఉంది. వెర్షన్ ఎప్పుడూ తప్పు కోడ్ని సూచించదు. npmలో, పబ్లిష్ చేయబడిన కోడ్ మరియు ట్యాగ్ చేయబడిన సోర్స్ వేరువేరుగా ఉండే అవకాశం ఉంది. కానీ Goలో, అవి రెండూ ఒకటే, ఎందుకంటే వెర్షన్ అనేది ఒక commitకి పాయింటర్.
అయితే, ఇది మీ వర్క్ఫ్లోను (workflow) పలు విధాలుగా మారుస్తుంది:
- మీ వెర్షన్ను కనుగొనడానికి ఒక కమాండ్ అవసరం. ఫైల్ను చూడటానికి బదులుగా మీరు
git describe --tagsరన్ చేయాలి. - వెర్షన్ బంప్స్ (Version bumps) కోడ్ రివ్యూలలో కనిపించవు. ట్యాగ్ పుష్ అనేది కోడ్ మార్పు కాదు, కాబట్టి అది pull requestలో కనిపించదు.
- లోకల్ బిల్డ్స్ pseudo-versions ఉపయోగిస్తాయి. మీరు ఒక commitని ట్యాగ్ చేసే వరకు, v1.2.3 వంటి క్లీన్ వెర్షన్కు బదులుగా సంఖ్యలు మరియు హాష్ల (hashes) పొడవైన స్ట్రింగ్ను చూస్తారు.
- మేజర్ వెర్షన్లు మీ ఇంపోర్ట్ పాత్ను (import path) మారుస్తాయి. npmలో, మీరు వెర్షన్ నంబర్ను మారుస్తారు కానీ ప్యాకేజీ పేరును అలాగే ఉంచుతారు. Goలో, v2 మరియు అంతకంటే ఎక్కువ వెర్షన్లకు
/v2వంటి పాత్ మార్పు అవసరం. ఇది ఒక ప్రోగ్రామ్ ఒకే లైబ్రరీ యొక్క v1 మరియు v2 వెర్షన్లను ఎటువంటి ఘర్షణలు (clashes) లేకుండా ఒకే సమయంలో ఉపయోగించడానికి అనుమతిస్తుంది.
ఇతర చాలా ఎకోసిస్టమ్స్ వెర్షన్ను ఒక ఫైల్లో ఉంచుతాయి:
- Node: package.json
- Rust: Cargo.toml
- Python: pyproject.toml
- Java: pom.xml
- .NET: .csproj
Go భిన్నమైనది. ఇది కేవలం git tags పైనే ఆధారపడుతుంది.
మీ Go బైనరీ క్లీన్ వెర్షన్ను చూపించాలనుకుంటే, మీరు build ప్రాసెస్లో ldflags ఉపయోగించి దానిని ఇంజెక్ట్ చేయవచ్చు. చాలా మంది డెవలపర్లు ట్యాగ్ మరియు రిలీజ్ ప్రాసెస్ను ఆటోమేట్ చేయడానికి goreleaser వంటి సాధనాలను కూడా ఉపయోగిస్తారు.
ఈ రెండు మోడల్స్ వేర్వేరు ప్రాధాన్యతలను సూచిస్తాయి:
- ఫైల్-ఆధారిత వెర్షన్లు చదవడానికి మరియు రివ్యూ చేయడానికి సులభంగా ఉంటాయి. అయితే, ఆ ఫైల్ అసలు కోడ్ నుండి వేరుపడే ప్రమాదం ఉంది.
- ట్యాగ్-ఆధారిత వెర్షన్లను నకిలీ చేయడం అసాధ్యం. కానీ వాటిని చూడటం మరియు నిర్వహించడం కష్టం.
మానిఫెస్ట్ (manifest) ఎల్లప్పుడూ కోడ్తో సరిపోలేలా చూడటానికి Go ట్యాగ్ మోడల్ను ఎంచుకుంది.
Go కోడ్ను పంపిణీ చేసేవారికి: మీ రోజువారీ పనిలో tag-only మోడల్ ఎలా అనిపిస్తుంది? మీరు దానిని మారుస్తారా?
మూలం: https://dev.to/dalirnet/packagejson-vs-gomod-where-did-the-version-field-go-3301