😰 🧙🏿 👩🏽‍⚖️ एक उदाहरण के साथ Go में कोड का पुन: उपयोग करना ™️ ⏩ 👩‍💻

"मैं Google पर एक टर्नकी समाधान के लिए जाऊंगा"

किसी भी सॉफ़्टवेयर उत्पाद पर काम करने की प्रक्रिया में, डेवलपर को किसी और के कोड को उधार लेने की समस्या का सामना करना पड़ सकता है। यह हर समय होता है। हर साल, डेवलपर्स के लिए सामाजिक नेटवर्क के विकास के साथ, प्रक्रिया अधिक से अधिक प्राकृतिक और चिकनी हो जाती है। भूल गए कि एक फाइल से सभी शब्द कैसे निकाले? कोई बात नहीं, स्टैक ओवरफ्लो पर जाएं और एक तैयार स्निपेट प्राप्त करें। विशेष रूप से उन्नत मामलों के लिए, यहां तक कि उदात्त पाठ के लिए एक प्लगइन भी है, जो हॉटकी द्वारा, SO पर चयनित पाठ की खोज करता है और प्राप्त उत्तर से कोड का एक टुकड़ा सीधे संपादक में सम्मिलित करता है। यह दृष्टिकोण कई समस्याओं की ओर जाता है ...

यद्यपि ऊपर दिया गया उदाहरण चरम है और एक अच्छे मजाक के लिए एक अवसर भी है, वास्तव में एक समस्या है। चित्र ध्यान आकर्षित करने के लिए जावास्क्रिप्ट का उपयोग करके फ्लोट64 सरणी को छाँटने का परिणाम दिखाता है। मैं यह नहीं सोचना चाहता कि इसे स्ट्रिंग्स के एक सरणी के रूप में क्यों क्रमबद्ध किया गया है; हम इस सवाल को जावास्क्रिप्ट प्रेमियों पर छोड़ देंगे। मुझे गो पर प्रोजेक्ट में मानव छंटाई की आवश्यकता थी, इसलिए ऊपर के नायक की तरह, मेरा रास्ता Google के माध्यम से चला गया।

डिस्क्लेमर: यह पोस्ट विकास संस्कृति को समर्पित है और गो दृष्टिकोण के कुछ लाभों को प्रदर्शित करता है। यदि आप पक्षपाती दृष्टिकोणों के बारे में नकारात्मक हैं, तो आपको आगे नहीं पढ़ना चाहिए।

अप्रत्याशित यात्रा

"मानव सॉर्ट स्ट्रिंग्स" क्वेरी का पहला लिंक 2007 के लेख @CodingHorror (जेफ एटवुड) से आया था। एक सम्मानित व्यक्ति, वह बुरे की सलाह नहीं देगा। दिए गए लिंक अभी भी प्रासंगिक हैं, उदाहरण के लिए, किसी भी भाषा के लिए कार्यान्वयन का एक पूरा गुच्छा है।

पायथन के तहत जेफ की पसंद इस तरह है:

import re def sort_nicely( l ): """ Sort the given list in the way that humans expect. """ convert = lambda text: int(text) if text.isdigit() else text alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9]+)', key) ] l.sort( key=alphanum_key )

ठीक है इसके साथ क्या करना है? लोग आमतौर पर क्या करते हैं? बस कोई विकल्प नहीं है - आप कोड के इस टुकड़े को अपनी परियोजना में ले जाएं, और सही जगह पर कॉपी करें। 10 परियोजनाएं - 10 स्थान। थोड़ा और अधिक तर्कसंगत लोगों ने फ़ाइल लाइब्रेरी में अलग-अलग उपयोगी चीजें रखीं, प्रत्येक की अपनी लाइब्रेरी है।
आपका अगला डेवलपर आपके कोड से निपटने के लिए इस साइट पर ठोकर खाता है क्योंकि:

"जिस तरह से मनुष्य उम्मीद करते हैं" , और वे कैसे उम्मीद करते हैं?
alphanum_key द्वारा छँटाई कैसे काम करती है? आपको सोचना होगा ...
(प्रलेखन के 2 घंटे प्रयोग करने और पढ़ने के बाद ) लानत है, लेकिन आखिरकार ['01', '001', '01', '001'] nifiga पर काम नहीं होता है, क्योंकि विनिर्देशन के अनुसार sort स्थिर है और इन टुकड़ों की key समान है;
प्रदर्शन के बारे में कैसे? और अगर 10,000 तत्व और प्रत्येक re.split ;
बंद करो, लेकिन मैं आम तौर पर गो पर लिखता हूं, मुझे आपके वन-लाइनर्स की आवश्यकता नहीं है, वैसे भी एल्गोरिदम काम नहीं कर रहा है।

C # कोड भी RegExp का उपयोग करता है, C ++ कोड में आमतौर पर यूरेनियम भालू और MFC का उपयोग किया जाता है (टिप्पणियों से पता चलता है कि यह एक अन्य संस्करण का संशोधित MFC संस्करण है जिसे पर्ल स्क्रिप्ट से C ++ में पोर्ट किया गया था)। मुझे यकीन है कि कई पाठकों को एक ही कहानी मिलेगी कि वे अलग-अलग भाषाओं के लिए कोड स्निपेट के साथ कचरा डंप के माध्यम से कैसे अफवाह करते हैं, समाधानों की नकल करते हैं, लेखकों की कल्पना को सुलझाते हैं, त्रुटियों को पकड़ते हैं ...

“निकटतम अस्पताल के लिए एक यात्रा ले लो। आमतौर पर उनमें से किसी के आसपास में एक अविस्मरणीय डंप है जहां आप कुछ भी पा सकते हैं। आपके प्राइमरी जार - सीरिंज का उपयोग किया जाता है। जल्दी से अपने सभी सामग्रियों को अपने शरीर में डालें और प्रभाव की प्रतीक्षा करें। ” - विधि नंबर 2, दनिया शेपोवालोव।

दृष्टिकोण जाओ

कुछ घंटों में, गो पर समारोह को सफलतापूर्वक लागू किया गया। फिर मैंने परीक्षण, बेंचमार्क, फ़ंक्शन को फिर से लिखा।

अंतिम संस्करण

 // StringLess compares two alphanumeric strings correctly. func StringLess(s1, s2 string) (less bool) { // uint64 = max 19 digits n1, n2 := make([]rune, 0, 18), make([]rune, 0, 18) for i, j := 0, 0; i < len(s1) || j < len(s2); { var r1, r2 rune var w1, w2 int var d1, d2 bool // read rune from former string available if i < len(s1) { r1, w1 = utf8.DecodeRuneInString(s1[i:]) i += w1 // if digit, accumulate if d1 = ('0' <= r1 && r1 <= '9'); d1 { n1 = append(n1, r1) } } // read rune from latter string if available if j < len(s2) { r2, w2 = utf8.DecodeRuneInString(s2[j:]) j += w2 // if digit, accumulate if d2 = ('0' <= r2 && r2 <= '9'); d2 { n2 = append(n2, r2) } } // if have rune and other non-digit rune if (!d1 || !d2) && r1 > 0 && r2 > 0 { // and accumulators have digits if len(n1) > 0 && len(n2) > 0 { // make numbers from digit group in1 := digitsToNum(n1) in2 := digitsToNum(n2) // and compare if in1 != in2 { return in1 < in2 } // if equal, empty accumulators and continue n1, n2 = n1[0:0], n2[0:0] } // detect if non-digit rune from former or latter if r1 != r2 { return r1 < r2 } } } // if reached end of both strings and accumulators // have some digits if len(n1) > 0 || len(n2) > 0 { in1 := digitsToNum(n1) in2 := digitsToNum(n2) if in1 != in2 { return in1 < in2 } } // last hope return len(s1) < len(s2) } // Convert a set of runes (digits 0-9) to uint64 number func digitsToNum(d []rune) (n uint64) { if l := len(d); l > 0 { n += uint64(d[l-1] - 48) k := uint64(l - 1) for _, r := range d[:l-1] { n, k = n+uint64(r-48)*uint64(math.Pow10(k)), k-1 } } return }

(वास्तव में, यह अंतिम एक नहीं है, टिप्पणियों में मेयरोवप हबल्यूज़र ने संख्या क्षेत्रों की तुलना करने का एक और भी अधिक इष्टतम तरीका सुझाया और मैंने इसे लागू किया , नए परीक्षण मामले जोड़े गए) ।

यह कोड वर्णों की चौड़ाई को ध्यान में रखते हुए एक स्ट्रिंग में बाइट्स पर पुनरावृति करने के लिए केवल "unicode/utf8" पैकेज का उपयोग करता है (गो में उन्हें रन कहा जाता है)। इसलिए, एक चक्र में हम दो पंक्तियों में रन को छांटते हैं (यदि वे अभी भी वहां बने हुए हैं), जब तक हम दोनों लाइनों के छोर तक नहीं पहुंच जाते। जिस तरह से, हम डिजिटल ASCII रेंज ('0' ≤ R) '9') में जाने के लिए पढ़े जाने वाले प्रत्येक रन की जांच करते हैं, और यदि यह इसमें मिल जाता है, तो हम इसे रनर बफर में जमा कर देते हैं। प्रत्येक पंक्ति s1, s2 का अपना वर्तमान rune r1, r2 और अपना स्वयं का बफ़र n1, n2 है । रन 1 की चौड़ाई w1, w2 का उपयोग केवल पर्दाफाश के लिए किया जाता है।

यदि एन्यूमरेशन के समय यह पता चला है कि रन में से एक अंक नहीं है, तो दोनों मौजूदा बफ़र दो uint64 नंबर in1, in2 और तुलना में परिवर्तित हो जाते हैं। मैं तुरंत ध्यान दूंगा कि स्व-निर्मित फंक्शन digitsToNum इस मामले में strconv.ParseUint से अधिक कुशलता से काम करता है। यदि बफ़र में संख्याएँ समान हैं, तो वर्तमान रन की तुलना की जाती है (जाहिर है, '0' <'a', लेकिन यहां यह सुनिश्चित करना हमारे लिए महत्वपूर्ण है कि r1! = R2 , उदाहरण के लिए 'a' और 'a')।

जैसे ही हम दोनों पंक्तियों के अंत में पहुँच गए (जिसका अर्थ है कि लाइनें अभी भी सशर्त बराबर हैं) और इस क्षण तक संख्या बफ़र्स में कुछ निकला, तो हम परिणामी संख्याओं की तुलना करते हैं (उदाहरण के लिए, लाइनों के अंत में "hello123" और "hello124")। यदि इस बार, तार सशर्त रूप से समान होते हैं, तो हम अंतिम चाल का उपयोग करते हैं - हम लंबाई की एक केले की तुलना का परिणाम लौटाते हैं, केवल इसलिए "a001" < "a00001"।

परीक्षण

"परीक्षण और कोड बेहतर कोड प्राप्त करने के लिए एक साथ काम करते हैं।"

मैंने स्ट्रिंग्स.गो फ़ाइल में मुख्य कोड रखा, इसलिए हमने टेस्ट को स्ट्रिंग्स_स्टेस्ट.गो फ़ाइल में डाल दिया।
पहला परीक्षण StringLess फ़ंक्शन के लिए होगा:

 func TestStringLess(t *testing.T) { //       //  table driven test testset := []struct { s1, s2 string //    less bool //   }{ {"aa", "ab", true}, {"ab", "abc", true}, {"abc", "ad", true}, {"ab1", "ab2", true}, {"ab1c", "ab1c", false}, {"ab12", "abc", true}, {"ab2a", "ab10", true}, {"a0001", "a0000001", true}, {"a10", "abcdefgh2", true}, {"2", "10", true}, {"2", "3", true}, {"a01b001", "a001b01", true}, {"082", "83", true}, } for _, v := range test set { if res := StringLess(v.s1, v.s2); res != v.less { t.Errorf("Compared %s to %s: expected %v, got %v", v.s1, v.s2, v.less, res) } } }

दूसरा परीक्षण यह जांच करेगा कि क्या सरणी को सही ढंग से हल किया गया है, बस मामले में, यह सॉर्ट, Swap , sort.Interface के कार्यान्वयन के Less कार्यों को कवर करेगा। sort.Interface इंटरफ़ेस।

TestStringSort

 func TestStringSort(t *testing.T) { a := []string{ "abc1", "abc2", "abc5", "abc10", } b := []string{ "abc5", "abc1", "abc10", "abc2", } sort.Sort(Strings(b)) if !reflect.DeepEqual(a, b) { t.Errorf("Error: sort failed, expected: %v, got: %v", a, b) } }

आधे घंटे के बाद, हमारे स्निपेट को परीक्षणों में शामिल किया गया है।
अब जो भी इसका उपयोग करने जा रहा है वह व्यक्तिगत रूप से गुणवत्ता का सत्यापन कर सकेगा:

 $ go test -v -cover === RUN TestStringSort --- PASS: TestStringSort (0.00 seconds) === RUN TestStringLess --- PASS: TestStringLess (0.00 seconds) PASS coverage: 100.0% of statements ok github.com/Xlab/handysort 0.019s

हालांकि, सरल इकाई परीक्षण पर्याप्त नहीं है जब यह दिखाने की इच्छा होती है कि समाधान काफी प्रभावी है। सबसे पहले, यह मेरे लिए उपयोगी है, क्योंकि बेंचमार्क के बाद मैंने कई बार कोड को तेज किया। उदाहरण के लिए, मैंने regexp का उपयोग करते हुए वैकल्पिक संस्करण को अस्वीकार कर दिया - हालांकि इसमें 6 लाइनें regexp , बेंचमार्क परिणामों में नुकसान बहुत बड़ा था। strconv और unicode.IsDigit का उपयोग करने से प्रदर्शन को लाभ नहीं हुआ। गो के नियमित साधनों द्वारा एक साधारण बेंचमार्क, एक ही फाइल में strings_test.go :

 func BenchmarkStringSort(b *testing.B) { //  1000   10000    : // *    3-8 ; // *    1-3 ; // *      . // 300    random seed,     //      ; //  func testSet     . set := testSet(300) // [][]string b.ResetTimer() //      // bN   for i := 0; i < bN; i++ { //       sort.Strings(set[bN%1000]) } } func BenchmarkHandyStringSort(b *testing.B) { set := testSet(300) b.ResetTimer() for i := 0; i < bN; i++ { //       sort.Sort(handysort.Strings(set[bN%1000])) } }

दो परीक्षणों और दो बेंचमार्क के साथ फ़ाइल का पूर्ण संस्करण:

strings_test.go

 package handysort import ( "math/rand" "reflect" "sort" "strconv" "testing" ) func TestStringSort(t *testing.T) { a := []string{ "abc1", "abc2", "abc5", "abc10", } b := []string{ "abc5", "abc1", "abc10", "abc2", } sort.Sort(Strings(b)) if !reflect.DeepEqual(a, b) { t.Errorf("Error: sort failed, expected: %v, got: %v", a, b) } } func TestStringLess(t *testing.T) { testset := []struct { s1, s2 string less bool }{ {"aa", "ab", true}, {"ab", "abc", true}, {"abc", "ad", true}, {"ab1", "ab2", true}, {"ab1c", "ab1c", false}, {"ab12", "abc", true}, {"ab2a", "ab10", true}, {"a0001", "a0000001", true}, {"a10", "abcdefgh2", true}, {"2", "10", true}, {"2", "3", true}, } for _, v := range testset { if res := StringLess(v.s1, v.s2); res != v.less { t.Errorf("Compared %s to %s: expected %v, got %v", v.s1, v.s2, v.less, res) } } } func BenchmarkStringSort(b *testing.B) { set := testSet(300) b.ResetTimer() for i := 0; i < bN; i++ { sort.Strings(set[bN%1000]) } } func BenchmarkHandyStringSort(b *testing.B) { set := testSet(300) b.ResetTimer() for i := 0; i < bN; i++ { sort.Sort(Strings(set[bN%1000])) } } // Get 1000 arrays of 10000-string-arrays. func testSet(seed int) [][]string { gen := &generator{ src: rand.New(rand.NewSource( int64(seed), )), } set := make([][]string, 1000) for i := range set { strings := make([]string, 10000) for idx := range strings { // random length strings[idx] = gen.NextString() } set[i] = strings } return set } type generator struct { src *rand.Rand } func (g *generator) NextInt(max int) int { return g.src.Intn(max) } // Gets random random-length alphanumeric string. func (g *generator) NextString() (str string) { // random-length 3-8 chars part strlen := g.src.Intn(6) + 3 // random-length 1-3 num numlen := g.src.Intn(3) + 1 // random position for num in string numpos := g.src.Intn(strlen + 1) var num string for i := 0; i < numlen; i++ { num += strconv.Itoa(g.src.Intn(10)) } for i := 0; i < strlen+1; i++ { if i == numpos { str += num } else { str += string('a' + g.src.Intn(16)) } } return str }

पैकेज के सभी बेंचमार्क को चलाना परीक्षणों को चलाना जितना आसान है: केवल फ्लैग और मास्क के साथ रन go test करें। उदाहरण के लिए, आप केवल BenchmarkHandyStringSort को चला सकते हैं, Handy को मास्क के रूप में निर्दिष्ट कर सकते हैं। हम दोनों में रुचि रखते हैं:

 $ go test -bench=. PASS BenchmarkStringSort 500 4694244 ns/op BenchmarkHandyStringSort 100 15452136 ns/op ok github.com/Xlab/handysort 91.389s

यहां, विभिन्न लंबाई की 10,000 पंक्तियों की यादृच्छिक सरणियों के उदाहरण पर, मानव छँटाई विकल्प नियमित संस्करण की तुलना में 3.3 गुना धीमा साबित हुआ। Intel i5 1.7GHz पर 15.6ms के लिए 10,000 लाइनों की छंटनी एक स्वीकार्य परिणाम है, मुझे लगता है कि एल्गोरिथ्म को काम करने पर विचार किया जा सकता है। यदि कोई समान के साथ आता है और उसके बेंचमार्क 5ms (4.7ms मानक छँटाई के बराबर) का परिणाम दिखाएंगे - हर कोई केवल खुश होगा, क्योंकि लाभ मापा जाएगा।

गो में परीक्षण के विभिन्न पहलुओं पर आधिकारिक सामग्री के लिए महत्वपूर्ण लिंक:

विस्तार

जब हमने अपने स्निपेट को कंघी किया, तो इसे परीक्षणों के साथ कवर किया और प्रदर्शन को मापा, इसे समाज के साथ साझा करने का समय था। पैकेज का नाम handysort द्वारा सोचा गया था, होस्टिंग निश्चित रूप से GitHub है, इसलिए मुझे पूरा पैकेज नाम github.com/Xlab/handysort मिला - रिकॉर्डिंग का यह तरीका पैकेज नामों के किसी भी टकराव को रोकता है, स्रोतों की प्रामाणिकता की गारंटी देता है और पैकेज के साथ आगे के काम के लिए वास्तव में बहुत अच्छी संभावनाएं खोलता है।

 . ├── LICENSE ├── README.md ├── strings.go └── strings_test.go 0 directories, 4 files

एक पूर्ण घटक के हिस्से के रूप में of फाइलें। कोशिश करो, शायद किसी तरह के जावा घटक के कोड को देखें:
telegram-api> src> main> java> org> telegram> api> engine> file> UploadListi.ava
- और वह सब है! ठीक है, अब वापस क्लिक करें।

दृष्टिकोण मैं
इस प्रकार, कोई अतिरिक्त पैकेज डिजाइन की आवश्यकता नहीं है: आप अपना कोड लेते हैं, टिप्पणी करते हैं, परीक्षण के साथ कवर करते हैं और गिटहब पर अपलोड करते हैं। अब कोई भी इस पैकेज का उपयोग दूसरों के बीच include अनुभाग से जोड़कर कर सकता है:

 import ( "bufio" "bytes" "errors" "fmt" "github.com/Xlab/handysort" "io" )

असेंबली के दौरान, स्थानीय प्रतिलिपि नहीं होने पर या पुराना होने पर पैकेज स्वतः ही कस जाएगा। लेखक पैकेज में सुधार कर सकता है, बग को ठीक कर सकता है, आपके उत्पाद को प्रभावी रूप से पैकेज के नए संस्करणों के साथ प्रदान किया जाएगा।

यदि आपने निर्यात किए गए कार्यों पर टिप्पणी नहीं की है (पूंजीगत कार्य, गैर-सार्वजनिक टिप्पणी अंदर) और पैकेज का संक्षिप्त विवरण लिखना न भूलें, जैसा कि उदाहरण के लिए handysort साथ:

strings.do

 // Copyright 2014 Maxim Kouprianov. All rights reserved. // Use of this source code is governed by the MIT license // that can be found in the LICENSE file. /* Package handysort implements an alphanumeric string comparison function in order to sort alphanumeric strings correctly. Default sort (incorrect): abc1 abc10 abc12 abc2 Handysort: abc1 abc2 abc10 abc12 Please note, that handysort is about 5x-8x times slower than a simple sort, so use it wisely. */ package handysort import ( "unicode/utf8" ) // Strings implements the sort interface, sorts an array // of the alphanumeric strings in decreasing order. type Strings []string func (a Strings) Len() int { return len(a) } func (a Strings) Swap(i, j int) { a[i], a[j] = a[j], a[i] } func (a Strings) Less(i, j int) bool { return StringLess(a[i], a[j]) } // StringLess compares two alphanumeric strings correctly. func StringLess(s1, s2 string) (less bool) { // uint64 = max 19 digits n1, n2 := make([]rune, 0, 18), make([]rune, 0, 18) for i, j := 0, 0; i < len(s1) || j < len(s2); { var r1, r2 rune var w1, w2 int var d1, d2 bool // read rune from former string available if i < len(s1) { r1, w1 = utf8.DecodeRuneInString(s1[i:]) i += w1 // if digit, accumulate if d1 = ('0' <= r1 && r1 <= '9'); d1 { n1 = append(n1, r1) } } // read rune from latter string if available if j < len(s2) { r2, w2 = utf8.DecodeRuneInString(s2[j:]) j += w2 // if digit, accumulate if d2 = ('0' <= r2 && r2 <= '9'); d2 { n2 = append(n2, r2) } } // if have rune and other non-digit rune if (!d1 || !d2) && r1 > 0 && r2 > 0 { // and accumulators have digits if len(n1) > 0 && len(n2) > 0 { // make numbers from digit group in1 := digitsToNum(n1) in2 := digitsToNum(n2) // and compare if in1 != in2 { return in1 < in2 } // if equal, empty accumulators and continue n1, n2 = n1[0:0], n2[0:0] } // detect if non-digit rune from former or latter if r1 != r2 { return r1 < r2 } } } // if reached end of both strings and accumulators // have some digits if len(n1) > 0 || len(n2) > 0 { in1 := digitsToNum(n1) in2 := digitsToNum(n2) if in1 != in2 { return in1 < in2 } } // last hope return len(s1) < len(s2) } // Convert a set of runes (digits 0-9) to uint64 number func digitsToNum(d []rune) (n uint64) { if l := len(d); l > 0 { n += uint64(d[l-1] - 48) k := uint64(l - 1) for _, r := range d[:l-1] { n, k = n+uint64(r-48)*uint64(10)*k, k-1 } } return }

इस तरह की टिप्पणियों को गोडॉक प्रलेखन प्रणाली द्वारा स्वचालित रूप से मान्यता प्राप्त है। आप कई प्रकार से पैकेज प्रलेखन देख सकते हैं, उदाहरण के लिए कंसोल में: godoc < > । एक वेब सेवा है godoc.org जो आपको किसी भी पैकेज के प्रलेखन को जल्दी से देखने की अनुमति देती है, अगर यह प्रसिद्ध कोड होस्टिंग साइटों में से एक पर स्थित है। इसका मतलब यह है कि यदि सार्वजनिक कार्यों को आपके कोड में सही ढंग से टिप्पणी की गई है और परियोजना जीथब पर स्थित है, उदाहरण के लिए, पैकेज प्रलेखन Godoc.org/github.com/Xlab/handysort पर उपलब्ध है (आप किसी भी पूर्ण पैकेज का नाम बदल सकते हैं)। पूरे मानक पुस्तकालय को आदर्श रूप से टिप्पणी की जाती है (उदाहरण के लिए, godoc.org/fmt ), जब पैकेजों का अध्ययन किया जाता है, तो यह न केवल गोदाम-दस्तावेजों को देखने के लिए उपयोगी होता है, बल्कि स्रोत कोड भी पढ़ता है, मैं इसे सुझाता हूं।

गो कोड डिजाइन के विभिन्न पहलुओं पर आधिकारिक सामग्री के लिए महत्वपूर्ण लिंक:

दृष्टिकोण II
यदि आप "GitHub पर यादृच्छिक दोस्त" पर भरोसा नहीं करते हैं या यदि आपको पैकेज के एक विशिष्ट संस्करण को ठीक करने की आवश्यकता है, तो आप रिपॉजिटरी को कांटा कर सकते हैं और पैकेज को github.com/VasyaPupkin/handysort रूप में कनेक्ट कर सकते हैं, इस का सार नहीं बदलेगा। उसी समय, आप मानवता को बचा सकते हैं यदि, एक ठीक दिन, मूल रिपॉजिटरी का लेखक पहियों / मशरूम को पूरा करता है और अपने पैकेज के साथ रिपॉजिटरी को व्यवस्थित रूप से हटाना शुरू कर देता है, जिससे कई लोगों के स्रोत में सीधे लिंक होते हैं।

दृष्टिकोण III
अंत में, यदि परियोजना की निर्भरता किसी और के पैकेज और strings_test.go लिंक की जरूरत नहीं है, तो अपने पैकेज में कार्यक्षमता को स्थानांतरित करने की सलाह दी जाती है - दो फाइलों strings.go और strings_test.go अपने आप को handysort.go और handysort_test.go । इस प्रकार, कार्यक्षमता मुख्य भाग को नहीं छूती है, और परीक्षण और बेंचमार्क सामान्य हो जाते हैं। वैसे, गो में कोड स्वचालित रूप से स्वरूपित है और इसलिए किसी भी विदेशी पुस्तकालय को एक समझ और सही शैली में डिज़ाइन किया जाएगा।

एक निष्कर्ष के बजाय

पोस्ट को Sublime Text के लिए GoSublime प्लगइन के समर्थन से तैयार किया गया था।
सभी मैच रैंडम हैं।

एक उदाहरण के साथ Go में कोड का पुन: उपयोग करना

अप्रत्याशित यात्रा

दृष्टिकोण जाओ

परीक्षण

विस्तार

एक निष्कर्ष के बजाय

More articles: