package.json વિરુદ્ધ go.mod: વર્ઝન ફિલ્ડ ક્યાં ગયું?
જો તમે 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 રન કરે છે, ત્યારે Go યોગ્ય commit શોધવા માટે તમારા રિપોઝિટરી ટેગ્સ જુએ છે.
આ ડિઝાઇનની એક મોટી શક્તિ છે. વર્ઝન ક્યારેય ખોટા કોડ તરફ નિર્દેશ કરી શકતું નથી. npm માં, પ્રકાશિત (published) કોડ અને ટેગ કરેલ સોર્સ અલગ પડી શકે છે. Go માં, તેઓ એક જ વસ્તુ છે કારણ કે વર્ઝન એ commit માટેનું પોઇન્ટર છે.
જોકે, આ તમારા વર્કફ્લોને અનેક રીતે બદલે છે:
- તમારું વર્ઝન શોધવા માટે કમાન્ડની જરૂર પડે છે. તમારે ફાઇલ જોવાને બદલે
git describe --tagsરન કરવું પડશે. - વર્ઝન બમ્પ (Version bumps) કોડ રિવ્યુમાં દેખાતા નથી. ટેગ પુશ એ કોડ ફેરફાર નથી, તેથી તે pull request માં દેખાતું નથી.
- લોકલ બિલ્ડ્સ pseudo-versions નો ઉપયોગ કરે છે. જ્યાં સુધી તમે commit ને ટેગ ન કરો, ત્યાં સુધી તમને v1.2.3 જેવા સ્વચ્છ વર્ઝનને બદલે નંબરો અને hashes ની લાંબી સ્ટ્રિંગ દેખાશે.
- મેજર વર્ઝન તમારો import path બદલી નાખે છે. npm માં, તમે વર્ઝન નંબર બદલો છો પરંતુ પેકેજનું નામ તે જ રાખો છો. Go માં, v2 અને તેનાથી ઉપરના માટે
/v2જેવો પાથ બદલવો જરૂરી છે. આ એક પ્રોગ્રામને ક્લેશ (clashes) વગર એક જ લાઇબ્રેરીના v1 અને v2 ને એકસાથે વાપરવાની મંજૂરી આપે છે.
મોટાભાગની અન્ય ઇકોસિસ્ટમ્સ વર્ઝનને ફાઇલમાં રાખે છે:
- Node: package.json
- Rust: Cargo.toml
- Python: pyproject.toml
- Java: pom.xml
- .NET: .csproj
Go અલગ છે. તે ફક્ત git tags પર આધાર રાખે છે.
જો તમે ઈચ્છતા હોવ કે તમારું Go binary એક સ્વચ્છ વર્ઝન બતાવે, તો તમે build process દરમિયાન ldflags નો ઉપયોગ કરીને તેને ઇન્જેક્ટ કરી શકો છો. ઘણા ડેવલપર્સ ટેગ અને રિલીઝ પ્રક્રિયાને ઓટોમેટ કરવા માટે goreleaser જેવા સાધનોનો પણ ઉપયોગ કરે છે.
આ બંને મોડલ અલગ-અલગ પ્રાથમિકતાઓ દર્શાવે છે:
- ફાઇલ-આધારિત વર્ઝન વાંચવા અને રિવ્યુ કરવા માટે સરળ છે. જોખમ એ છે કે ફાઇલ વાસ્તવિક કોડથી અલગ પડી શકે છે.
- ટેગ-આધારિત વર્ઝન બનાવવું અશક્ય છે. તેની કિંમત એ છે કે તેને જોવું અને મેનેજ કરવું મુશ્કેલ છે.
Go એ ખાતરી કરવા માટે ટેગ મોડલ પસંદ કર્યું છે કે મેનિફેસ્ટ (manifest) હંમેશા કોડ સાથે મેળ ખાય.
જે લોકો Go કોડ શિપ કરે છે તેમના માટે: તમારા રોજિંદા કામમાં માત્ર ટેગ-આધારિત (tag-only) મોડેલ કેવું લાગે છે? શું તમે તેમાં કોઈ ફેરફાર કરશો?
સ્ત્રોત: https://dev.to/dalirnet/packagejson-vs-gomod-where-did-the-version-field-go-3301