मेरी फ़ाइल कहाँ है? Go में अपना रास्ता खोजना सीखें

परिचय: "मैं कहाँ हूँ?" — प्रोग्राम पूछता है

कल्पना करें: आप Go में एक उपयोगिता लिख रहे हैं जिसे अपनी निष्पादन योग्य फ़ाइल के पास वाले फ़ोल्डर से कॉन्फ़िग पढ़ना चाहिए। या, उदाहरण के लिए, आप उसी निर्देशिका में एक लॉग-फ़ाइल बना रहे हैं जहाँ प्रोग्राम स्थित है। यह आसान लगता है, है ना? लेकिन यहाँ सबसे दिलचस्प शुरू होता है: Go एक संकलित भाषा है, और जब अपना स्थान जानने की बात आती है तो इसके अपने "रहस्य" हैं।

प्रश्न "How to get the directory of the currently running file?" Go में शुरुआती लोगों के बीच Stack Overflow पर सबसे लोकप्रिय प्रश्नों में से एक है। और यह आकस्मिक नहीं है। स्क्रिप्टिंग भाषाओं के विपरीत, जहाँ __file__ (Python) या __dirname__ (Node.js) सब कुछ आसानी से हल कर देते हैं, Go में आपको सोचना होगा: हमें वास्तव में किस फ़ाइल में दिलचस्पी है? स्रोत कोड (संकलन के दौरान) या निष्पादन योग्य बाइनरी (निष्पादन के दौरान)?

इस लेख में, हम दोनों दृष्टिकोणों पर चर्चा करेंगे, सामान्य नुकसान से बचना सीखेंगे, और Go में कोड के कई उदाहरण लिखेंगे जिनका उपयोग वास्तविक परियोजनाओं में किया जा सकता है। चलिए शुरू करते हैं!

दो दुनियाएँ, दो बचपन: स्रोत बनाम बाइनरी

कोड लिखने से पहले, आइए मुख्य दुविधा को समझें। Go में, प्रोग्राम पहले एक स्थिर बाइनरी में संकलित होता है। जब आप go run main.go चलाते हैं, Go एक अस्थायी निष्पादन योग्य फ़ाइल बनाता है और उसे चलाता है। जब आप go build करते हैं — आपको एक तैयार फ़ाइल मिलती है जिसे दूसरे कंप्यूटर पर ले जाया जा सकता है।

इसलिए प्रश्न "मैं कहाँ हूँ?" के दो उत्तर हैं:

\n
• स्रोत फ़ाइल का पथ — विकास के दौरान, लॉगिंग या परीक्षण के लिए आवश्यक।
\n
• निष्पादन योग्य फ़ाइल का पथ — उत्पादन में आवश्यक, पास के संसाधनों (कॉन्फ़िग, डेटाबेस आदि) को खोजने के लिए।
\n

Stack Overflow पर अधिकांश उत्तर दूसरे विकल्प से संबंधित हैं, लेकिन हम दोनों पर विचार करेंगे ताकि आप पूरी तरह से तैयार रहें।

विधि संख्या 1: चल रहे बाइनरी की निर्देशिका जानना

यह सबसे सामान्य परिदृश्य है। आपका प्रोग्राम पहले ही संकलित और चलाया जा चुका है, और उसे यह समझने की आवश्यकता है कि इसे किस फ़ोल्डर से कॉल किया गया था। Go इसके लिए एक सुंदर तरीका प्रदान करता है — पैकेज os और फ़ंक्शन os.Executable()।

कोड उदाहरण: मूल संस्करण

package main\n\nimport (\n    "fmt"\n    "os"\n    "path/filepath"\n)\n\nfunc main() {\n    // निष्पादन योग्य फ़ाइल का पूरा पथ प्राप्त करें\n    exePath, err := os.Executable()\n    if err != nil {\n        fmt.Println("पथ प्राप्त करने में त्रुटि:", err)\n        return\n    }\n    fmt.Println("बाइनरी का पूरा पथ:", exePath)\n\n    // निर्देशिका निकालें\n    exeDir := filepath.Dir(exePath)\n    fmt.Println("निष्पादन योग्य फ़ाइल की निर्देशिका:", exeDir)\n}

इस कोड को go run main.go के माध्यम से चलाएँ — आपको /tmp/go-build123456/b001/exe/main जैसा पथ दिखाई देगा। यह एक अस्थायी निर्देशिका है। और यदि आप संकलित करते हैं (go build -o myapp) और ./myapp चलाते हैं — तो आपको वर्तमान फ़ोल्डर मिलेगा।

संभावित समस्याएँ: सिमलिंक और chdir

फ़ंक्शन os.Executable() वह पथ लौटाता है जिससे प्रोग्राम चलाया गया था। लेकिन कुछ बारीकियाँ हैं:

\n
• प्रतीकात्मक लिंक (सिमलिंक)। यदि आपने प्रोग्राम को सिमलिंक के माध्यम से चलाया है (/usr/local/bin/myapp -> /opt/myapp_v2/myapp), os.Executable() वास्तविक फ़ाइल के बजाय लिंक का पथ लौटाएगा। "असली" पथ प्राप्त करने के लिए, filepath.EvalSymlinks() का उपयोग करें।
\n
• कार्यशील निर्देशिका बदलना। यदि प्रोग्राम ने आंतरिक रूप से os.Chdir() कॉल किया है, तो इसका os.Executable() पर कोई प्रभाव नहीं पड़ता — यह अभी भी बाइनरी का पथ लौटाएगा।
\n

सिमलिंक प्रबंधन के साथ बेहतर संस्करण

package main\n\nimport (\n    "fmt"\n    "os"\n    "path/filepath"\n)\n\nfunc main() {\n    exePath, err := os.Executable()\n    if err != nil {\n        panic(err)\n    }\n\n    //