在终端中的 Go 应用程序中使用多行输入。

huangapple
go评论120阅读模式
英文:

multiline input in a terminal Go application

问题

我需要让用户在控制台输入多行文本。

以下是我的代码：

  1. package main
  3. import (
  4. 	"bufio"
  5. 	"fmt"
  6. 	"os"
  7. )
  9. func main() {
  10. 	for {
  11. 		fmt.Println("如何在此处读取所有行？")
  12. 		in := bufio.NewReader(os.Stdin)
  13. 		result, err := in.ReadString('\n')
  14. 		if err != nil {
  15. 			fmt.Println(err)
  16. 		}
  17. 		fmt.Println("\nresult")
  18. 		fmt.Println(result)
  20. 	}
  21. }

我在控制台中粘贴了：

  1. Hello
  2. World

它的输出是：

  1. 如何在此处读取所有行？
  3. 		Hello
  4. 		World
  7. result
  10. 如何在此处读取所有行？
  12. result
  13. 		Hello
  15. 如何在此处读取所有行？
  17. result
  18. 		World
  20. 如何在此处读取所有行？
  22. result
  25. 如何在此处读取所有行？
  28. 但我希望输出是：

如何在此处读取所有行？

  1. 	Hello
  2. 	World

result

如何在此处读取所有行？

result
Hello
World

如何在此处读取所有行？

  2. 我猜我需要使用`EOF`而不是`'\n'`。但具体如何操作呢？
  4. # 更新
  6. peterSo的答案有效，除非我尝试从剪贴板粘贴包含一个或多个空行的文本，例如：

Hello

World

  2. 它会打印：

输入行：
Hello

World结果：
Hello

输入行：

  2. # 更新2
  3. 伟大的更新后的peterSO的答案现在可以处理包含空行的文本。
  5. <details>
  6. <summary>英文:</summary>
  8. I need to let a user input multiline text to the console.
  10. Here is my code:
  12.     package main
  13.     
  14.     import (
  15.     	&quot;bufio&quot;
  16.     	&quot;fmt&quot;
  17.     	&quot;os&quot;
  18.     )
  19.     
  20.     func main() {
  21.     	for {
  22.     		fmt.Println(&quot;How to read all lines here?&quot;)
  23.     		in := bufio.NewReader(os.Stdin)
  24.     		result, err := in.ReadString(&#39;\n&#39;)
  25.     		if err != nil {
  26.     			fmt.Println(err)
  27.     		}
  28.     		fmt.Println(&quot;\nresult&quot;)
  29.     		fmt.Println(result)		
  30.         		
  31.     	}
  32.     }
  35. I pasted in the console:
  38. 		Hello
  39. 		World
  42. It outputs:
  43.     
  45.     How to read all lines here?
  47. 			Hello
  48. 			World
  51. 	result
  54. 	How to read all lines here?
  56. 	result
  57. 			Hello
  59. 	How to read all lines here?
  61. 	result
  62. 			World
  64. 	How to read all lines here?
  66. 	result
  69. 	How to read all lines here?
  72. But I expect it to be:
  74.              How to read all lines here?
  75.     
  76.     				Hello
  77.     				World
  78.     
  79.     
  80.     		result
  81.     
  82.     
  83.     		How to read all lines here?
  84.     
  85.     		result
  86.     				Hello
  87.     				World
  88.     
  89.     		How to read all lines here?
  92. I guess I need to use something like `EOF` instead of `&#39;\n&#39;`
  93.  But how to do it exactly?
  95. #Update
  97. peterSo&#39;s answer works except in case when I am trying to paste from clipboard a text with one or more empty lines in-between, like:
  99.     Hello
  100.     
  101.     World
  104. It prints
  106.     Enter Lines:
  107.     Hello
  108.     
  109.     WorldResult:
  110.     Hello
  111.     
  112.     Enter Lines:
  115. #Update 2
  116. The great updated peterSO&#39;s answer now works even for text with empty lines.
  118. </details>
  121. # 答案1
  122. **得分**: 8
  124. 缓冲一组行并检测一组行的结束。例如，
  126.     package main
  127.     
  128.     import (
  129.     	"bufio"
  130.     	"fmt"
  131.     	"os"
  132.     )
  133.     
  134.     func main() {
  135.     	scn := bufio.NewScanner(os.Stdin)
  136.     	for {
  137.     		fmt.Println("输入行：")
  138.     		var lines []string
  139.     		for scn.Scan() {
  140.     			line := scn.Text()
  141.     			if len(line) == 1 {
  142.     				// 分组分隔符（GS ^]）：ctrl-]
  143.     				if line[0] == '\x1D' {
  144.     					break
  145.     				}
  146.     			}
  147.     			lines = append(lines, line)
  148.     		}
  149.     
  150.     		if len(lines) > 0 {
  151.     			fmt.Println()
  152.     			fmt.Println("结果：")
  153.     			for _, line := range lines {
  154.     				fmt.Println(line)
  155.     			}
  156.     			fmt.Println()
  157.     		}
  158.     
  159.     		if err := scn.Err(); err != nil {
  160.     			fmt.Fprintln(os.Stderr, err)
  161.     			break
  162.     		}
  163.     		if len(lines) == 0 {
  164.     			break
  165.     		}
  166.     	}
  167.     }
  169. 控制台：
  171. <pre>
  172. 输入行：
  173. Hello
  174. World
  175. ^]
  177. 结果：
  178. Hello
  179. World
  181. 输入行：
  182. Farewell
  184. World
  186. ^]
  188. 结果：
  189. Farewell
  191. World
  194. 输入行：
  195. ^]
  196. </pre>
  198. 要终止一组行，请在空行上输入：`ctrl+`][Enter]。要终止输入，请输入一行：`ctrl+`][Enter]。
  200. <details>
  201. <summary>英文:</summary>
  203. Buffer a set of lines and detect the end of a set of lines. For example,
  205.     package main
  206.     
  207.     import (
  208.     	&quot;bufio&quot;
  209.     	&quot;fmt&quot;
  210.     	&quot;os&quot;
  211.     )
  212.     
  213.     func main() {
  214.     	scn := bufio.NewScanner(os.Stdin)
  215.     	for {
  216.     		fmt.Println(&quot;Enter Lines:&quot;)
  217.     		var lines []string
  218.     		for scn.Scan() {
  219.     			line := scn.Text()
  220.     			if len(line) == 1 {
  221.     				// Group Separator (GS ^]): ctrl-]
  222.     				if line[0] == &#39;\x1D&#39; {
  223.     					break
  224.     				}
  225.     			}
  226.     			lines = append(lines, line)
  227.     		}
  228.     
  229.     		if len(lines) &gt; 0 {
  230.     			fmt.Println()
  231.     			fmt.Println(&quot;Result:&quot;)
  232.     			for _, line := range lines {
  233.     				fmt.Println(line)
  234.     			}
  235.     			fmt.Println()
  236.     		}
  237.     
  238.     		if err := scn.Err(); err != nil {
  239.     			fmt.Fprintln(os.Stderr, err)
  240.     			break
  241.     		}
  242.     		if len(lines) == 0 {
  243.     			break
  244.     		}
  245.     	}
  246.     }
  248. Console:
  250. &lt;pre&gt;
  251. Enter Lines:
  252. Hello
  253. World
  254. ^]
  256. Result:
  257. Hello
  258. World
  260. Enter Lines:
  261. Farewell
  263. World
  265. ^]
  267. Result:
  268. Farewell
  270. World
  273. Enter Lines:
  274. ^]
  275. &lt;/pre&gt;
  277. To terminate a set of lines, on an empty line, enter: &lt;`ctrl+`]&gt;&lt;`Enter`&gt;. To terminate input, enter a single line: &lt;`ctrl+`]&gt;&lt;`Enter`&gt;.
  279. </details>
  283. # 答案2
  284. **得分**: 1
  286. 请查看[bufio.ReadString][1]的文档，它指出你传递给它的字符将导致函数停止读取并返回。如果你想接受多行输入，你需要想出一些方案来区分继续语句的换行符（'\n'）和终止语句的字符。
  288. **编辑：**下面是一个简单的示例，通过扩展你的代码来识别多行输入。它通过将语句的“终止”定义为空字符串（只包含“\n”）来实现。你可以看到它只是将多个读取缓冲到一个“块”中。你可以更聪明地直接读取键盘，但无论如何，你都必须定义一些方案，以便在程序中可以识别多行和单行。
  290. ```go
  291. package main
  293. import (
  294. 	"bufio"
  295. 	"fmt"
  296. 	"os"
  297. )
  299. func main() {
  300. 	cnt := false
  301. 	var txt []byte
  302. 	for {
  303. 		result := make([]byte, 1024)
  304. 		if cnt == false {
  305. 			fmt.Println("How to read all lines here?")
  306. 		}
  307. 		in := bufio.NewReader(os.Stdin)
  308. 		_, err := in.Read(result)
  310. 		if err != nil {
  311. 			fmt.Println(err)
  312. 		}
  313. 		if result[0] == '\n' {
  314. 			cnt = false
  315. 			fmt.Printf("<----\n%s---->\n", string(txt))
  316. 			txt = txt[:0]
  317. 		} else {
  318. 			txt = append(txt, result...)
  319. 			cnt = true
  320. 		}
  321. 	}
  322. }
英文:

Look at the documentation for bufio.ReadString, it states that the character you pass to it will cause the function to stop reading and return. If you want to accept multi-line input, you'll need to come up with some scheme to differentiate newlines ('\n') that continue a statement, and whatever terminates a statement.

edit: Here is a bad quick hacky example that extends your code to recognize multi-line input. It does this by defining the "termination" of a statement to be the empty string containing only "\n". You can see it's just buffering multiple reads into one "block". You can get more clever and read the keyboard directly, but regardless you'll have to define some scheme that you can programmatically recognize as being multi-line vs. single line.

  1. package main
  3. import (
  4. 	&quot;bufio&quot;
  5. 	&quot;fmt&quot;
  6. 	&quot;os&quot;
  7. )
  9. func main() {
  10. 	cnt := false
  11. 	var txt []byte
  12. 	for {
  13. 		result := make([]byte, 1024)
  14. 		if cnt == false {
  15. 			fmt.Println(&quot;How to read all lines here?&quot;)
  16. 		}
  17. 		in := bufio.NewReader(os.Stdin)
  18. 		_, err := in.Read(result)
  20. 		if err != nil {
  21. 			fmt.Println(err)
  22. 		}
  23. 		if result[0] == &#39;\n&#39; {
  24. 			cnt = false
  25. 			fmt.Printf(&quot;&lt;----\n%s----&gt;\n&quot;, string(txt))
  26. 			txt = txt[:0]
  27. 		} else {
  28. 			txt = append(txt, result...)
  29. 			cnt = true
  30. 		}
  31. 	}
  32. }

答案3

得分: 0

EOF无法帮助你，因为io.EOF的类型是'error'，但in.ReadString期望的是一个字节（序列'\n'是一个字节）。但无论如何，如果我理解你的目标，你需要一种停止从stdin读取的方法。例如，一个特定的字符串。就像mysql客户端期望"exit;"字符串来结束你的会话。

看一下扫描行的示例http://golang.org/pkg/bufio/#example_Scanner_lines，并改进它，将

  1. fmt.Println(scanner.Text()) // Println will add back the final '\n'

替换为类似以下的内容：

  1. allInput += scanner.Text() + "\n"
  2. if scanner.Text() == "exit;" {
  3.     //退出时的操作...
  4.     //...    
  5.     fmt.Println("Exiting. Bye")
  6.     return
  7. }

或者，如果你希望你的程序在管道中工作，并从其他程序的输出中接收多行输入，你可以使用io.ReadFull或PipeReader函数。

英文:

EOF can not help you, because io.EOF has type of 'error', but in.ReadString expects a byte (the sequence &#39;\n&#39; - is a byte). But anyway, if I understand your goals, you need some way to stop reading from stdin. For example, a specific string. Like mysql client expects "exit;" string to end your session.

Take a look at scanning lines example
http://golang.org/pkg/bufio/#example_Scanner_lines
and improve it replacing

  1. fmt.Println(scanner.Text()) // Println will add back the final &#39;\n&#39;

with something like:

  1. allInput += scanner.Text() + &quot;\n&quot;
  2. if scanner.Text() == &quot;exit;&quot; {
  3.     //your actions on exit...
  4.     //...    
  5.     fmt.Println(&quot;Exiting. By&quot;)
  6.     return
  7. }

Or if you want you program to work in pipes and take multiline input from other program output, you can use io.ReadFull or PipeReader functions

huangapple
  • 本文由 发表于 2015年6月14日 12:40:54
  • 转载请务必保留本文链接：https://go.coder-hub.com/30825996.html
  • go
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定