用Go如何实现精准统计文章字数

大家好，我是站长 polarisxu。

公司主营业务：成都网站设计、网站制作、移动网站开发等业务。帮助企业客户真正实现互联网宣传，提高企业的竞争能力。成都创新互联公司是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化，感谢他们对我们的高要求，感谢他们从不同领域给我们带来的挑战，让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。成都创新互联公司推出西安免费做网站回馈大家。

今天要聊的内容应该可以当做一道面试题，你可以先想想该怎么实现。

统计字数是一个很常见的需求，很多人印象最深的应该是微博早些时候限制 140 字，而且边输入会边统计剩余字数。现在很多社区文章也会有字数统计的功能，而且可以依据字数来预估阅读时间。比如 Go语言中文网就有这样的功能。

01 需求分析

下手之前先分析下这个需求。从我个人经验看，在实际面试中，针对一个面试题，你的分析过程，循序渐进的解决方案，可以很好的展示你的思考过程。正所谓分析问题、解决问题。这会给你加分的。

我们采用类似词法分析的思路分析这个需求。

一篇文章通常包含如下元素，我们也称之为 token：

  • 普通文字
  • 标点符号
  • 图片
  • 链接(包含各种协议的链接)
  • 代码

其中普通文字通常会分为欧美和中日韩(CJK)，因为 CJK 属于表意文字，和欧美字母的文字差异很大。同时这里还涉及到编码的问题。本文假设使用 UTF-8 编码。

对于标点符号，中文标点和英文标点也会很不一样。

此外还有全角和半角的问题。

根据以上分析，对于该需求作如下假定：

  • 空格(包括换行)不算字数;
  • HTML 标签需要剔除;
  • 编码方式：假定为 UTF-8 编码;
  • 标点符号算不算做字数。如果算，像括号这样的按 2 个字算;
  • 链接怎么算?一个链接约定为 1 个字可能更合适，大概阅读时只是把它当链接，而不太会关心链接由什么字母组成;
  • 图片不算做字数，但如果计算阅读时间，可能需要适当考虑图片的影响;
  • 对于技术文章，代码是最麻烦的。统计代码字数感觉是没多大意义的。统计代码行数可能更有意义;

本文的解决方案针对以上的假定进行。

02 Go 语言实现

先看最简单的。

纯英文

根据以上分析，如果文章只包含普通文本且是英文，也就是说，每个字(单词)根据空格分隔，统计是最简单的。

 
 
 
 
    
  
  
  
  
  1. func TotalWords(s string) int { 
    2. 
  
  
  
  
  2.  n := 0 
    3. 
  
  
  
  
  3.  inWord := false 
    4. 
  
  
  
  
  4.  for _, r := range s { 
    5. 
  
  
  
  
  5.   wasInWord := inWord 
    6. 
  
  
  
  
  6.   inWord = !unicode.IsSpace(r) 
    7. 
  
  
  
  
  7.   if inWord && !wasInWord { 
    8. 
  
  
  
  
  8.    n++ 
    9. 
  
  
  
  
  9.   } 
    10. 
  
  
  
  
  10.  } 
    11. 
  
  
  
  
  11.  return n 
    12. 
  
  
  
  
  12. } 
    13.

还有一种更简单的方式：

 
 
 
 
    
  
  
  
  
  1. len(strings.Fields(s)) 
    2.

不过看 strings.Fields 的实现，性能会不如第一种方式。

回顾上面的需求分析，会发现这个实现是有 Bug 的。比如下面的例子：

 
 
 
 
    
  
  
  
  
  1. s1 := "Hello,playground" 
    2. 
  
  
  
  
  2. s2 := "Hello, playground" 
    3.

用上面的实现，s1 的字数是 1，s2 的字数是 2。它们都忽略了标点符号。而且因为写法的多样性(不规范统一)，导致计算字数会有误差。所以我们需要对写法进行规范。

规范排版

其实和写代码要有规范一样，文章也是有规范的。比如出版社对于一本书的排版会有明确的规定。为了让我们的文章看起来更舒服，也应该遵循一定的规范。

这里推荐一个 GitHub 上的排版指南：《中文文案排版指北》，它的宗旨，统一中文文案、排版的相关用法，降低团队成员之间的沟通成本，增强网站气质。这个规范开头关于空格的一段话很有意思：

有研究显示，打字的时候不喜欢在中文和英文之间加空格的人，感情路都走得很辛苦，有七成的比例会在 34 岁的时候跟自己不爱的人结婚，而其余三成的人最后只能把遗产留给自己的猫。毕竟爱情跟书写都需要适时地留白。

建议大家可以看看这个指北，一些知名的网站就是按照这个做的。

因为 GCTT 的排版在这个规范做，但人为约束不是最好的方法，所以我开发了一个 Go 工具：https://github.com/studygolang/autocorrect，用于自动给中英文之间加入合理的空格并纠正专用名词大小写。

所以为了让字数统计更准确，我们假定文章是按一定的规范书写的。比如上面的例子，规范的写法是 s2 := "Hello, playground"。不过这里标点不算作字数。

刚去微博上试了一下，发现微博的字数计算方式有点诡异，竟然是 9 个字。

测试一下发现，它直接把两个英文字母算作一个字(两个字节算一个字)。而汉字是正常的。大家可以想想微博是怎么实现的。

中英文混合

中文不像英文，单词之间没有空格分隔，因此开始的那两种方式不适合。

如果是纯中文，我们怎么计算字数呢?

在 Go 语言中，字符串使用 UTF-8 编码，一个字符用 rune 表示。因此在标准库中查找相关计算方法。

 
 
 
 
    
  
  
  
  
  1. func RuneCountInString(s string) (n int) 
    2.

这个方法能计算字符串包含的 rune(字符)数，对于纯中文，就是汉字数。

 
 
 
 
    
  
  
  
  
  1. str := "你好世界" 
    2. 
  
  
  
  
  2. fmt.Println(utf8.RuneCountInString(str)) 
    3.

以上代码输出 4。

然而，因为很多时候文章会中英文混合，因此我们先采用上面的纯英文的处理方式，即：strings.Fields()，将文章用空格分隔，然后处理每一部分。

 
 
 
 
    
  
  
  
  
  1. func TotalWords(s string) int { 
    2. 
  
  
  
  
  2.  wordCount := 0 
    3. 
  
  
  
  
  3.    
    4. 
  
  
  
  
  4.  plainWords := strings.Fields(s) 
    5. 
  
  
  
  
  5.  for _, word := range plainWords { 
    6. 
  
  
  
  
  6.   runeCount := utf8.RuneCountInString(word) 
    7. 
  
  
  
  
  7.   if len(word) == runeCount { 
    8. 
  
  
  
  
  8.    wordCount++ 
    9. 
  
  
  
  
  9.   } else { 
    10. 
  
  
  
  
  10.    wordCount += runeCount 
    11. 
  
  
  
  
  11.   } 
    12. 
  
  
  
  
  12.  } 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14.  return wordCount 
    15. 
  
  
  
  
  15. } 
    16.

增加如下的测试用例：

 
 
 
 
    
  
  
  
  
  1. func TestTotalWords(t *testing.T) { 
    2. 
  
  
  
  
  2.  tests := []struct { 
    3. 
  
  
  
  
  3.   name  string 
    4. 
  
  
  
  
  4.   input string 
    5. 
  
  
  
  
  5.   want  int 
    6. 
  
  
  
  
  6.  }{ 
    7. 
  
  
  
  
  7.   {"en1", "hello,playground", 2}, 
    8. 
  
  
  
  
  8.   {"en2", "hello, playground", 2}, 
    9. 
  
  
  
  
  9.   {"cn1", "你好世界", 4}, 
    10. 
  
  
  
  
  10.   {"encn1", "Hello你好世界", 5}, 
    11. 
  
  
  
  
  11.   {"encn2", "Hello 你好世界", 5}, 
    12. 
  
  
  
  
  12.  } 
    13. 
  
  
  
  
  13.  for _, tt := range tests { 
    14. 
  
  
  
  
  14.   t.Run(tt.name, func(t *testing.T) { 
    15. 
  
  
  
  
  15.    if got := wordscount.TotalWords(tt.input); got != tt.want { 
    16. 
  
  
  
  
  16.     t.Errorf("TotalWords() = %v, want %v", got, tt.want) 
    17. 
  
  
  
  
  17.    } 
    18. 
  
  
  
  
  18.   }) 
    19. 
  
  
  
  
  19.  } 
    20. 
  
  
  
  
  20. } 
    21.

发现 en1 和 encn1 测试不通过，因为没有按照上面说的规范书写。因此我们通过程序增加必要的空格。

 
 
 
 
    
  
  
  
  
  1. // AutoSpace 自动给中英文之间加上空格 
    2. 
  
  
  
  
  2. func AutoSpace(str string) string { 
    3. 
  
  
  
  
  3.  out := "" 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.  for _, r := range str { 
    6. 
  
  
  
  
  6.   out = addSpaceAtBoundary(out, r) 
    7. 
  
  
  
  
  7.  } 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.  return out 
    10. 
  
  
  
  
  10. } 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12. func addSpaceAtBoundary(prefix string, nextChar rune) string { 
    13. 
  
  
  
  
  13.  if len(prefix) == 0 { 
    14. 
  
  
  
  
  14.   return string(nextChar) 
    15. 
  
  
  
  
  15.  } 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17.  r, size := utf8.DecodeLastRuneInString(prefix) 
    18. 
  
  
  
  
  18.  if isLatin(size) != isLatin(utf8.RuneLen(nextChar)) && 
    19. 
  
  
  
  
  19.   isAllowSpace(nextChar) && isAllowSpace(r) { 
    20. 
  
  
  
  
  20.   return prefix + " " + string(nextChar) 
    21. 
  
  
  
  
  21.  } 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23.  return prefix + string(nextChar) 
    24. 
  
  
  
  
  24. } 
    25. 
  
  
  
  
  25.  
    26. 
  
  
  
  
  26. func isLatin(size int) bool { 
    27. 
  
  
  
  
  27.  return size == 1 
    28. 
  
  
  
  
  28. } 
    29. 
  
  
  
  
  29.  
    30. 
  
  
  
  
  30. func isAllowSpace(r rune) bool { 
    31. 
  
  
  
  
  31.  return !unicode.IsSpace(r) && !unicode.IsPunct(r) 
    32. 
  
  
  
  
  32. } 
    33.

这样可以在 TotalWords 函数开头增加 AutoSpace 进行规范化。这时结果就正常了。

处理标点和其他类型

以上例子标点没计算在内，而且如果英文和中文标点混合在一起，情况又复杂了。

为了更好地实现开始的需求分析，重构以上代码，设计如下的结构：

 
 
 
 
    
  
  
  
  
  1. type Counter struct { 
    2. 
  
  
  
  
  2.  Total     int // 总字数 = Words + Puncts 
    3. 
  
  
  
  
  3.  Words     int // 只包含字符数 
    4. 
  
  
  
  
  4.  Puncts    int // 标点数 
    5. 
  
  
  
  
  5.  Links     int // 链接数 
    6. 
  
  
  
  
  6.  Pics      int // 图片数 
    7. 
  
  
  
  
  7.  CodeLines int // 代码行数 
    8. 
  
  
  
  
  8. } 
    9.

同时将 TotalWords 重构为 Counter 的 Stat 方法，同时记录标点数：

 
 
 
 
    
  
  
  
  
  1. func (wc *Counter) Stat(str string) { 
    2. 
  
  
  
  
  2.  wc.Links = len(rxStrict.FindAllString(str, -1)) 
    3. 
  
  
  
  
  3.  wc.Pics = len(imgReg.FindAllString(str, -1)) 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.  // 剔除 HTML 
    6. 
  
  
  
  
  6.  str = StripHTML(str) 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8.  str = AutoSpace(str) 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.  // 普通的链接去除（非 HTML 标签链接） 
    11. 
  
  
  
  
  11.  str = rxStrict.ReplaceAllString(str, " ") 
    12. 
  
  
  
  
  12.  plainWords := strings.Fields(str) 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14.  for _, plainWord := range plainWords { 
    15. 
  
  
  
  
  15.   words := strings.FieldsFunc(plainWord, func(r rune) bool { 
    16. 
  
  
  
  
  16.    if unicode.IsPunct(r) { 
    17. 
  
  
  
  
  17.     wc.Puncts++ 
    18. 
  
  
  
  
  18.     return true 
    19. 
  
  
  
  
  19.    } 
    20. 
  
  
  
  
  20.    return false 
    21. 
  
  
  
  
  21.   }) 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23.   for _, word := range words { 
    24. 
  
  
  
  
  24.    runeCount := utf8.RuneCountInString(word) 
    25. 
  
  
  
  
  25.    if len(word) == runeCount { 
    26. 
  
  
  
  
  26.     wc.Words++ 
    27. 
  
  
  
  
  27.    } else { 
    28. 
  
  
  
  
  28.     wc.Words += runeCount 
    29. 
  
  
  
  
  29.    } 
    30. 
  
  
  
  
  30.   } 
    31. 
  
  
  
  
  31.  } 
    32. 
  
  
  
  
  32.  
    33. 
  
  
  
  
  33.  wc.Total = wc.Words + wc.Puncts 
    34. 
  
  
  
  
  34. } 
    35. 
  
  
  
  
  35.  
    36. 
  
  
  
  
  36. var ( 
    37. 
  
  
  
  
  37.  rxStrict = xurls.Strict() 
    38. 
  
  
  
  
  38.  imgReg   = regexp.MustCompile(`]*>`) 
    39. 
  
  
  
  
  39.  stripHTMLReplacer = strings.NewReplacer("\n", " ", "
    ", "\n", "
    ", "\n", "", "\n") 
    40. 
  
  
  
  
  40. ) 
    41. 
  
  
  
  
  41.  
    42. 
  
  
  
  
  42. // StripHTML accepts a string, strips out all HTML tags and returns it. 
    43. 
  
  
  
  
  43. func StripHTML(s string) string { 
    44. 
  
  
  
  
  44.  // Shortcut strings with no tags in them 
    45. 
  
  
  
  
  45.  if !strings.ContainsAny(s, "<>") { 
    46. 
  
  
  
  
  46.   return s 
    47. 
  
  
  
  
  47.  } 
    48. 
  
  
  
  
  48.  s = stripHTMLReplacer.Replace(s) 
    49. 
  
  
  
  
  49.  
    50. 
  
  
  
  
  50.  // Walk through the string removing all tags 
    51. 
  
  
  
  
  51.  b := GetBuffer() 
    52. 
  
  
  
  
  52.  defer PutBuffer(b) 
    53. 
  
  
  
  
  53.  var inTag, isSpace, wasSpace bool 
    54. 
  
  
  
  
  54.  for _, r := range s { 
    55. 
  
  
  
  
  55.   if !inTag { 
    56. 
  
  
  
  
  56.    isSpace = false 
    57. 
  
  
  
  
  57.   } 
    58. 
  
  
  
  
  58.  
    59. 
  
  
  
  
  59.   switch { 
    60. 
  
  
  
  
  60.   case r == '<': 
    61. 
  
  
  
  
  61.    inTag = true 
    62. 
  
  
  
  
  62.   case r == '>': 
    63. 
  
  
  
  
  63.    inTag = false 
    64. 
  
  
  
  
  64.   case unicode.IsSpace(r): 
    65. 
  
  
  
  
  65.    isSpace = true 
    66. 
  
  
  
  
  66.    fallthrough 
    67. 
  
  
  
  
  67.   default: 
    68. 
  
  
  
  
  68.    if !inTag && (!isSpace || (isSpace && !wasSpace)) { 
    69. 
  
  
  
  
  69.     b.WriteRune(r) 
    70. 
  
  
  
  
  70.    } 
    71. 
  
  
  
  
  71.   } 
    72. 
  
  
  
  
  72.  
    73. 
  
  
  
  
  73.   wasSpace = isSpace 
    74. 
  
  
  
  
  74.  
    75. 
  
  
  
  
  75.  } 
    76. 
  
  
  
  
  76.  return b.String() 
    77. 
  
  
  
  
  77. } 
    78.

代码过多的细节不讨论。此外，关于文章内的代码行数统计未实现(目前没有想到特别好的方法，如果你有，欢迎交流)。

03 总结

通过本文的分析发现，精准统计字数没那么容易，这里涉及到很多的细节。

当然，实际应用中，字数不需要那么特别精准，而且对于非正常文字(比如链接、代码)怎么处理，会有不同的约定。

本文涉及到的完整代码放在 GitHub：https://github.com/polaris1119/wordscount。

本文转载自微信公众号「polarisxu」，可以通过以下二维码关注。转载本文请联系polarisxu公众号。

当前名称：用Go如何实现精准统计文章字数
分享网址：http://www.shufengxianlan.com/qtweb/news26/62326.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

外贸建站知识

同城分类信息

广安搬家公司　　 　高端品牌网站建设　　 　成都未宇聚　　 　成都服务器托管　　 　云服务器　　 　康明斯发电机　　 　成都展柜制作　　 　企业网站设计　　 　成都印刷厂　　 　企业网站建设公司　　 　眉山联通机房　　 　西云主机托管　　 　域名注册　　 　边坡柔性防护网　　 　抖音短视频　　 　乐山服务器托管　　 　网站设计　　 　服务器托管　　 　雕琢时光茶叶　　 　成都网站设计