打印字符串的底线被剪掉

Question

我有一个打印多行字符串的程序，它切断了 bottom.Output:

[   ]
[██████╗  ██╗  ██╗ ██████╗  ██████╗ ]
[╚════██╗ ██║  ██║ ╚════██╗ ╚════██╗]
[ █████╔╝ ███████║  █████╔╝  █████╔╝]
[██╔═══╝  ╚════██║ ██╔═══╝   ╚═══██╗]

用于生成它的程序：

package main

import (
        "fmt"
        "strconv"
        "strings"
)

const one = `
 ██╗
███║
╚██║
 ██║
 ██║
 ╚═╝
`
const two = `
██████╗ 
╚════██╗
 █████╔╝
██╔═══╝ 
███████╗
╚══════╝    
`
const three = `
██████╗ 
╚════██╗
 █████╔╝
 ╚═══██╗
██████╔╝
╚═════╝ 
`
const four = `
██╗  ██╗
██║  ██║
███████║
╚════██║
     ██║
     ╚═╝
`
const five = `
███████╗
██╔════╝
███████╗
╚════██║
███████║
╚══════╝
`
const six = `
 ██████╗ 
██╔════╝ 
███████╗ 
██╔═══██╗
╚██████╔╝
 ╚═════╝ 
`
const seven = `
███████╗
╚════██║
    ██╔╝
   ██╔╝ 
   ██║  
   ╚═╝ 
`
const eight = `
 █████╗ 
██╔══██╗
╚█████╔╝
██╔══██╗
╚█████╔╝
 ╚════╝ 
`
const nine = `
 █████╗ 
██╔══██╗
╚██████║
 ╚═══██║
 █████╔╝
 ╚════╝ 
`
const zero = `
 ██████╗ 
██╔═████╗
██║██╔██║
████╔╝██║
╚██████╔╝
 ╚═════╝ 
`

var numbers = []string{zero, one, two, three, four, five, six, seven, eight, nine}

func getAscii(number int) [][]string {
        listOfNumbers := strings.Split(strconv.Itoa(number), "")
        var ascii [][]string
        for _, num := range listOfNumbers {
                intnum, _ := strconv.Atoi(num)
                ascii = append(ascii, strings.Split(numbers[intnum], "\n"))
        }
        return ascii
}
func LongestSlice(slices [][]string) int {
        var longest int = 0
        for _, slice := range slices {
                if len(slice) > longest {
                        longest = len(slice)
                }
        }
        return longest
}

func joinStrings(stuff [][]string) [][]string {
        var joined [][]string
        for lineNumber := 0; lineNumber <= LongestSlice(joined); lineNumber++ {
                var Oneline []string
                for _, item := range stuff {
                        //err := item[lineNumber]
                        //if err != nil {
                        //      panic(err)
                        //}
                        Oneline = append(Oneline, item[lineNumber])

                }
                joined = append(joined, Oneline)
        }
        return joined
}
func main() {
        stuff := joinStrings(getAscii(2423))
        for _, line := range stuff {
                fmt.Println(line)
        }
}

这是为什么？我很困惑在哪里看。我怎样才能解决这个问题，以免它切断底部？对不起，我把整个程序都包含进来了，我不知道问题出在哪里。

Answer 1

只是在循环条件下过度设计。尝试

for lineNumber := 0; lineNumber <= LongestSlice(stuff)-1; lineNumber++ {

在 func joinStrings 的外循环中。看看效果如何 https://play.golang.org/p/eR4JJtY4T1

Answer 2

您的解决方案对于您要实现的目标而言似乎过于复杂。一种简单的方法是采纳 evanmcdonnal 的建议并使用映射来定义整数如何转换为相应的字符串常量，它看起来像这样：

var integerToStr = map[int]string{
  0: zero,
  1: one,
  2: two,
  3: three,
  4: four,
  5: five,
  6: six,
  7: seven,
  8: eight,
  9: nine,
}

...在这种情况下，您可以像这样转换整数：

if str, present := integerToStr[i]; present {
  // do something with the string
} else {
  // default to something else?
}

如果您不喜欢包范围内的变量，您也可以使用 switch 语句在函数内部做同样的事情：

var glyph string
switch num {
    case "1":
        glyph = one
    case "2":
        glyph = two
    case "3":
        glyph = three
    case "4":
        glyph = four
    case "5":
        glyph = five
    case "6":
        glyph = six
    case "7":
        glyph = seven
    case "8":
        glyph = eight
    case "9":
        glyph = nine
    case "0":
        fallthrough
    default:
        glyph = zero
    }

我还建议为您的字母制定一个标准高度，并使其与字符串本身保持一致。这允许您通过创建一个固定长度的数组来相当容易地水平连接它们，将每个字符串的相应行附加到该数组的每个成员，然后将其转换为一个切片并使用 "strings.Join" 来完成工作加入最后的字符串：

var out [glyphHeight]string

for _, glyph := range glyphs {
    for i, line := range strings.Split(glyph, "\n") {
        out[i] += " " + line
    }
}

return strings.Join(out[:numGlyphLines], "\n")

我认为值得一提的另一件有点迂腐的事情是您错误地将字符串称为 ASCII。 Go 实际上对其字符串使用 UTF。在这个例子中这并不重要，但你应该记住这一点。

打印字符串的底线被剪掉

Bottom line trimmed off printing string

printing

go

slice