गोलांग

Question

में कीबोर्ड से इनपुट लिखने का प्रयास कर रहा हूं, मैं कीबोर्ड से इनपुट लेने की कोशिश कर रहा हूं और फिर उसे एक टेक्स्ट फ़ाइल में संग्रहीत करने की कोशिश कर रहा हूं लेकिन मैं वास्तव में इसे कैसे करना है इस पर थोड़ा उलझन में हूं।

मेरे वर्तमान कोड के रूप में इस समय का पालन करें:

// reads the file txt.txt 
bs, err := ioutil.ReadFile("text.txt") 
if err != nil { 
     panic(err) 
} 

// Prints out content 
textInFile := string(bs) 
fmt.Println(textInFile) 

// Standard input from keyboard 
var userInput string 
fmt.Scanln(&userInput) 

//Now I want to write input back to file text.txt 
//func WriteFile(filename string, data []byte, perm os.FileMode) error 

inputData := make([]byte, len(userInput)) 

err := ioutil.WriteFile("text.txt", inputData,) 

"ओएस" और "कब" संकुल में इतने सारे कार्यों रहे हैं। मैं इस बारे में बहुत उलझन में हूं कि इस उद्देश्य के लिए मुझे वास्तव में किस का उपयोग करना चाहिए।

मैं भी इस बारे में उलझन में हूं कि WriteFile फ़ंक्शन में तीसरा तर्क क्या होना चाहिए। प्रलेखन में "perm os.FileMode" प्रकार का कहना है, लेकिन चूंकि मैं प्रोग्रामिंग के लिए नया हूं और जाओ मैं थोड़ी अनजान हूं।

क्या किसी के पास प्रक्रिया करने के तरीके पर कोई सुझाव है? अग्रिम धन्यवाद, मारी

Answer 1

// reads the file txt.txt 
bs, err := ioutil.ReadFile("text.txt") 
if err != nil { //may want logic to create the file if it doesn't exist 
     panic(err) 
} 

var userInput []string 

var err error = nil 
var n int 
//read in multiple lines from user input 
//until user enters the EOF char 
for ln := ""; err == nil; n, err = fmt.Scanln(ln) { 
    if n > 0 { //we actually read something into the string 
     userInput = append(userInput, ln) 
    } //if we didn't read anything, err is probably set 
} 

//open the file to append to it 
//0666 corresponds to unix perms rw-rw-rw-, 
//which means anyone can read or write it 
out, err := os.OpenFile("text.txt", os.O_APPEND, 0666) 
defer out.Close() //we'll close this file as we leave scope, no matter what 

if err != nil { //assuming the file didn't somehow break 
    //write each of the user input lines followed by a newline 
    for _, outLn := range userInput { 
     io.WriteString(out, outLn+"\n") 
    } 
} 

मैं इस संकलित करता है तथा play.golang.org पर चलता है, लेकिन मैं अपने देव मशीन पर नहीं कर रहा हूँ यकीन है कि बनाया है, इसलिए मैं यह सत्यापित नहीं कर सकता कि यह स्टडीन और फ़ाइल के साथ पूरी तरह से सही तरीके से बातचीत कर रहा है। यह आपको शुरू करना चाहिए हालांकि।

Answer 2

उदाहरण के लिए,

package main 

import (
    "fmt" 
    "io/ioutil" 
    "os" 
) 

func main() { 
    fname := "text.txt" 

    // print text file 
    textin, err := ioutil.ReadFile(fname) 
    if err == nil { 
     fmt.Println(string(textin)) 
    } 

    // append text to file 
    f, err := os.OpenFile(fname, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0666) 
    if err != nil { 
     panic(err) 
    } 
    var textout string 
    fmt.Scanln(&textout) 
    _, err = f.Write([]byte(textout)) 
    if err != nil { 
     panic(err) 
    } 
    f.Close() 

    // print text file 
    textin, err = ioutil.ReadFile(fname) 
    if err != nil { 
     panic(err) 
    } 
    fmt.Println(string(textin)) 
} 

Answer 3

यदि आप बस टेक्स्ट फ़ाइल में उपयोगकर्ता के इनपुट को जोड़ना चाहते हैं, तो आप केवल इनपुट पढ़ सकते हैं जैसा कि आपने पहले से ही किया है और ioutil.WriteFile का उपयोग करें, जैसा कि आपने करने का प्रयास किया है। तो आपको पहले से ही सही विचार मिल गया है।

अपने रास्ते जाना बनाने के लिए, सरलीकृत समाधान इस होगा:

// Read old text 
current, err := ioutil.ReadFile("text.txt") 

// Standard input from keyboard 
var userInput string 
fmt.Scanln(&userInput) 

// Append the new input to the old using builtin `append` 
newContent := append(current, []byte(userInput)...) 

// Now write the input back to file text.txt 
err = ioutil.WriteFile("text.txt", newContent, 0666) 

WriteFile के अंतिम पैरामीटर एक ध्वज जो फ़ाइलों के लिए विभिन्न विकल्प निर्दिष्ट करता है। उच्च बिट्स फ़ाइल प्रकार (os.ModeDir, उदाहरण के लिए) जैसे विकल्प हैं और निचले बिट्स यूनिक्स अनुमतियों (0666, ऑक्टल प्रारूप में, उपयोगकर्ता आरडब्ल्यू, समूह आरडब्ल्यू, अन्य आरडब्ल्यू के लिए खड़े हैं) के रूप में अनुमतियों का प्रतिनिधित्व करते हैं। अधिक जानकारी के लिए the documentation देखें।

अब आपका कोड काम करता है, हम इसे बेहतर बना सकते हैं। फ़ाइल खुला रखने बजाय इसे दो बार खोलने के द्वारा उदाहरण के लिए:

// Open the file for read and write (O_RDRW), append to it if it has 
// content, create it if it does not exit, use 0666 for permissions 
// on creation. 
file, err := os.OpenFile("text.txt", os.O_RDWR|os.O_APPEND|os.O_CREATE, 0666) 

// Close the file when the surrounding function exists 
defer file.Close() 

// Read old content 
current, err := ioutil.ReadAll(file) 

// Do something with that old content, for example, print it 
fmt.Println(string(current)) 

// Standard input from keyboard 
var userInput string 
fmt.Scanln(&userInput) 

// Now write the input back to file text.txt 
_, err = file.WriteString(userInput) 

जादू यहाँ है, जिससे आप फ़ाइल, जो file.WriteString() संलग्न बनाता खोलने झंडा os.O_APPEND का उपयोग करें। ध्यान दें कि खोलने के बाद आपको फ़ाइल को बंद करने की आवश्यकता है, जो हम defer कीवर्ड का उपयोग कर फ़ंक्शन मौजूद होने के बाद करते हैं।