Go
एटम के प्रयोग से जाना शुरू करना

परिचय

जाओ, स्थापित करें और सेटअप एटम और गल्प

1. एटम स्थापित करें। आप यहां से परमाणु प्राप्त कर सकते हैं
2. एटम सेटिंग्स (ctrl +,) पर जाएं। पैकेज -> स्थापित गो-प्लस पैकेज ( गो-प्लस )

परमाणु में गो-प्लस स्थापित करने के बाद:

3. जाओ या किसी अन्य निर्भरता प्रबंधक का उपयोग करके इन निर्भरताओं को प्राप्त करें: (एक कंसोल खोलें और इन कमांड्स को चलाएं)

go get -u golang.org/x/tools/cmd/goimports

go get -u golang.org/x/tools/cmd/gorename

go get -u github.com/sqs/goreturns

go get -u github.com/nsf/gocode

go get -u github.com/alecthomas/gometalinter

go get -u github.com/zmb3/gogetdoc

go get -u github.com/rogpeppe/godef

go get -u golang.org/x/tools/cmd/guru

4. एनपीएम या किसी अन्य पैकेज मैनेजर ( गुलप- गेटिंग-स्टार्ट-डॉक ) का उपयोग करके गुलप ( गुलपज ) स्थापित करें:

$ npm स्थापित - global gulp

$ GO_PATH / gulpfile.js बनाएं

var gulp = require('gulp');
var path = require('path');
var shell = require('gulp-shell');

var goPath = 'src/mypackage/**/*.go';


gulp.task('compilepkg', function() {
  return gulp.src(goPath, {read: false})
    .pipe(shell(['go install <%= stripPath(file.path) %>'],
      {
          templateData: {
            stripPath: function(filePath) {
              var subPath = filePath.substring(process.cwd().length + 5);
              var pkg = subPath.substring(0, subPath.lastIndexOf(path.sep));
              return pkg;
            }
          }
      })
    );
});

gulp.task('watch', function() {
  gulp.watch(goPath, ['compilepkg']);
});

ऊपर दिए गए कोड में हमने एक कॉम्प्लीकैप कार्य को परिभाषित किया है जो हर बार किसी भी गो फाइल में गोपाथ (src / mypackage /) या उपनिर्देशिका परिवर्तन को ट्रिगर करेगा। कार्य शेल कमांड को इंस्टॉल किया जाएगा change_file.go स्थापित करें

गो पथ में गल फ़ाइल बनाने और कार्य को परिभाषित करने के बाद एक कमांड लाइन खोलें और चलाएं:

गुल की घड़ी

आप हर बार किसी भी फ़ाइल परिवर्तन की तरह कुछ देख लेंगे:

$ GO_PATH / mypackage / source.go बनाएँ

package mypackage

var PublicVar string = "Hello, dear reader!"

//Calculates the factorial of given number recursively!
func Factorial(x uint) uint {
    if x == 0 {
        return 1
    }
    return x * Factorial(x-1)
}

$ GO_PATH / main.go बनाना

अब आप Atom और Gulp का उपयोग करते हुए ऑटो-पूर्ति के साथ अपना स्वयं का कोड लिखना शुरू कर सकते हैं:

package main

import (
    "fmt"
    "mypackage"
)

func main() {

    println("4! = ", mypackage.Factorial(4))

}