blocks|key|3067598|text|您可以尝试使用utf8包中的RuneCountInString。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3067599|3067600|返回p中的符号数|blockquote|3067601|3067602|3067603|这一点，如this+script中所示："World“的长度可能是6(当中文写成”世界“时)，但它的符文计数是2：|3067604|package+main
++++
import+"fmt"
import+"unicode/utf8"
++++
func+main()+{
++++fmt.Println("Hello,+世界",+len("世界"),+utf8.RuneCountInString("世界"))
}|code-block|syntax|javascript|3067605|Phrozen增加了in+the+comments|3067606|实际上，您可以通过类型转换在符文上执行len()。|3067607|len([]rune("世界"))将打印2。至少在Go+1.3中。|3067608|3067609|通过CL+108985+(2018年5月，针对Go+1.11)，len([]rune(string))现在得到了优化。(修复issue+24923)|3067610|编译器自动检测len([]rune(string))模式，并将其替换为for+r+:=+range的调用。|3067611|3067612|添加了一个新的运行时函数来计算字符串中的符号数。修改编译器以检测模式len([]rune(string))，并将其替换为新的符文计数运行时函数。|3067613|3067614|RuneCount/lenruneslice/ASCII+27.8+ns±2%2514.5+ns±3%25+-47.70%25RuneCount/lenruneslice/日语126+ns±2%2560+ns±2%25+-52.03%25RuneCount/lenruneslice/MixedLength+104+ns±2%25+50+ns±1%25+-51.71%25|3067615|3067616|3067617|Stefan+Steiger指向博客文章"Text+normalization+in+Go“|3067618|3067619|什么是字符？正如在strings+blog+post中提到的，字符可以跨越多个符文。|BOLD|3067620|3067621|例如，'e‘和'◌́◌́’(急性的"\u0301")可以组合形成“é”(NFD中的“e\u0301”)。这两个符文加在一起就是一个字符。|3067622|字符的定义可能因应用程序的不同而不同。|3067623|对于，我们将其定义为：|3067624|3067625|3067626|一个以起始符文开头的符文序列，|unordered-list-item|3067627|一个不修改或向后组合任何其他符文的符文序列，|3067628|后跟可能为空的非启始符文序列，即有空符的符文序列(通常是重音符号)。|3067629|3067630|规范化算法一次处理一个字符。|3067631|使用该软件包及其Iter+type，实际“字符”数量将为：|3067632|package+main
++++
import+"fmt"
import+"golang.org/x/text/unicode/norm"
++++
func+main()+{
++++var+ia+norm.Iter
++++ia.InitString(norm.NFKD,+"école")
++++nc+:=+0
++++for+!ia.Done()+{
++++++++nc+=+nc+%2B+1
++++++++ia.Next()
++++}
++++fmt.Printf("Number+of+chars:+%25d\n",+nc)
}|3067633|这里，这使用了Unicode+Normalization+form+NFKD“兼容性分解”|3067634|3067635|Oliver的answer指出，是可靠地确定某些重要文本元素(用户感知的字符、单词和句子)之间默认边界的唯一方法。|3067636|为此，您需要一个像这样的外部库，它执行Unicode文本分割。|3067637|这实际上将计算"+集群“，其中多个代码点可以组合成一个用户感知的字符。|3067638|package+uniseg
++++
import+(
++++"fmt"
++++
++++"github.com/rivo/uniseg"
)
++++
func+main()+{
++++gr+:=+uniseg.NewGraphemes("!")
++++for+gr.Next()+{
++++++++fmt.Printf("%25x+",+gr.Runes())
++++}
++++//+Output:+[1f44d+1f3fc]+[21]
}|3067639|两个字素，即使有三个符文(Unicode代码点)。|3067640|您可以在"How+to+manipulate+strings+in+GO+to+reverse+them?“中看到其他示例。|3067641|‍本身是一个字素，但从unicode+to+code+points+converter中，有4个符文：|3067642|women+(1f469)|3067643|dark+skin+(1f3fe)|3067644|
|3067645|ZERO+WIDTH+JOINER+(200d)|3067646|3067647|red+hair+(1f9b0)|3067648|
：|3067649|3067650|3067651|entityMap|0|LINK|mutability|MUTABLE|url|http://golang.org/pkg/unicode/utf8/#RuneCountInString|1|http://play.golang.org/p/zzB1VrwdER|2|https://stackoverflow.com/users/383848/phrozen|3|https://stackoverflow.com/questions/12668681/go-language-string-length/12668840#comment39875126_12668840|4|https://go-review.googlesource.com/c/go/%2B/108985|5|https://github.com/golang/go/issues/24923|6|https://stackoverflow.com/users/155077/stefan-steiger|7|https://blog.golang.org/normalization|8|http://blog.golang.org/strings|9|https://godoc.org/golang.org/x/text/unicode/norm#Iter|10|http://unicode.org/reports/tr15/#Norm_Forms|11|https://stackoverflow.com/users/2046109/oliver|12|https://stackoverflow.com/a/55151396/6309|13|https://stackoverflow.com/a/62743214/6309|14|https://onlineunicodetools.com/convert-unicode-to-code-points|15|https://apps.timwhitlock.info/unicode/inspect/hex/1F469|16|https://apps.timwhitlock.info/unicode/inspect/hex/1f3fe|17|https://apps.timwhitlock.info/unicode/inspect/hex/200d|18|https://apps.timwhitlock.info/unicode/inspect/hex/1f9b0^0|E|H|E|H|0|0|0|0|0|0|5|B|1|0|0|0|7|2|A|F|3|0|J|5|0|0|H|K|1|0|0|W|J|2|9|4|1Q|B|5|0|7|J|0|0|Y|J|0|0|0|0|0|0|E|6|L|O|7|0|0|V|A|9|H|8|0|0|4|1|16|7|0|0|0|0|0|0|0|0|0|0|8|4|8|9|9|0|0|7|Q|A|0|0|0|6|B|7|6|C|0|J|B|0|9|2|0|0|0|5|1C|D|0|B|W|E|0|0|D|F|0|0|H|G|0|0|0|O|H|0|0|0|G|I|0|0|0|0^^$0|@$1|2|3|4|5|6|7|48|8|@$9|49|A|4A|B|C]]|D|@$9|4B|A|4C|1|4D]]|E|$]]|$1|F|3|-4|5|6|7|4E|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|4F|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|4G|8|@]|D|@]|E|$]]|$1|K|3|-4|5|6|7|4H|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|4I|8|@]|D|@$9|4J|A|4K|1|4L]]|E|$]]|$1|N|3|O|5|P|7|4M|8|@]|D|@]|E|$Q|R]]|$1|S|3|T|5|6|7|4N|8|@]|D|@$9|4O|A|4P|1|4Q]|$9|4R|A|4S|1|4T]]|E|$]]|$1|U|3|V|5|6|7|4U|8|@$9|4V|A|4W|B|C]]|D|@]|E|$]]|$1|W|3|X|5|6|7|4X|8|@$9|4Y|A|4Z|B|C]|$9|50|A|51|B|C]]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|52|8|@]|D|@]|E|$]]|$1|Z|3|10|5|6|7|53|8|@$9|54|A|55|B|C]]|D|@$9|56|A|57|1|58]|$9|59|A|5A|1|5B]]|E|$]]|$1|11|3|12|5|6|7|5C|8|@$9|5D|A|5E|B|C]]|D|@]|E|$]]|$1|13|3|-4|5|6|7|5F|8|@]|D|@]|E|$]]|$1|14|3|15|5|I|7|5G|8|@$9|5H|A|5I|B|C]]|D|@]|E|$]]|$1|16|3|-4|5|6|7|5J|8|@]|D|@]|E|$]]|$1|17|3|18|5|6|7|5K|8|@]|D|@]|E|$]]|$1|19|3|-4|5|6|7|5L|8|@]|D|@]|E|$]]|$1|1A|3|-4|5|6|7|5M|8|@]|D|@]|E|$]]|$1|1B|3|1C|5|6|7|5N|8|@]|D|@$9|5O|A|5P|1|5Q]|$9|5R|A|5S|1|5T]]|E|$]]|$1|1D|3|-4|5|6|7|5U|8|@]|D|@]|E|$]]|$1|1E|3|1F|5|I|7|5V|8|@$9|5W|A|5X|B|1G]]|D|@$9|5Y|A|5Z|1|60]]|E|$]]|$1|1H|3|-4|5|6|7|61|8|@]|D|@]|E|$]]|$1|1I|3|1J|5|6|7|62|8|@$9|63|A|64|B|C]|$9|65|A|66|B|C]]|D|@]|E|$]]|$1|1K|3|1L|5|6|7|67|8|@]|D|@]|E|$]]|$1|1M|3|1N|5|6|7|68|8|@]|D|@]|E|$]]|$1|1O|3|-4|5|6|7|69|8|@]|D|@]|E|$]]|$1|1P|3|-4|5|6|7|6A|8|@]|D|@]|E|$]]|$1|1Q|3|1R|5|1S|7|6B|8|@]|D|@]|E|$]]|$1|1T|3|1U|5|1S|7|6C|8|@]|D|@]|E|$]]|$1|1V|3|1W|5|1S|7|6D|8|@]|D|@]|E|$]]|$1|1X|3|-4|5|6|7|6E|8|@]|D|@]|E|$]]|$1|1Y|3|1Z|5|6|7|6F|8|@]|D|@]|E|$]]|$1|20|3|21|5|6|7|6G|8|@$9|6H|A|6I|B|C]]|D|@$9|6J|A|6K|1|6L]]|E|$]]|$1|22|3|23|5|P|7|6M|8|@]|D|@]|E|$Q|R]]|$1|24|3|25|5|6|7|6N|8|@]|D|@$9|6O|A|6P|1|6Q]]|E|$]]|$1|26|3|-4|5|6|7|6R|8|@]|D|@]|E|$]]|$1|27|3|28|5|6|7|6S|8|@]|D|@$9|6T|A|6U|1|6V]|$9|6W|A|6X|1|6Y]]|E|$]]|$1|29|3|2A|5|6|7|6Z|8|@$9|70|A|71|B|1G]]|D|@]|E|$]]|$1|2B|3|2C|5|6|7|72|8|@$9|73|A|74|B|1G]]|D|@]|E|$]]|$1|2D|3|2E|5|P|7|75|8|@]|D|@]|E|$Q|R]]|$1|2F|3|2G|5|6|7|76|8|@]|D|@]|E|$]]|$1|2H|3|2I|5|6|7|77|8|@]|D|@$9|78|A|79|1|7A]]|E|$]]|$1|2J|3|2K|5|6|7|7B|8|@]|D|@$9|7C|A|7D|1|7E]]|E|$]]|$1|2L|3|2M|5|6|7|7F|8|@]|D|@$9|7G|A|7H|1|7I]]|E|$]]|$1|2N|3|2O|5|1S|7|7J|8|@]|D|@$9|7K|A|7L|1|7M]]|E|$]]|$1|2P|3|2Q|5|6|7|7N|8|@]|D|@]|E|$]]|$1|2R|3|2S|5|1S|7|7O|8|@]|D|@$9|7P|A|7Q|1|7R]]|E|$]]|$1|2T|3|2Q|5|6|7|7S|8|@]|D|@]|E|$]]|$1|2U|3|2V|5|1S|7|7T|8|@]|D|@$9|7U|A|7V|1|7W]]|E|$]]|$1|2W|3|2X|5|6|7|7X|8|@]|D|@]|E|$]]|$1|2Y|3|-4|5|1S|7|7Y|8|@]|D|@]|E|$]]|$1|2Z|3|-4|5|6|7|7Z|8|@]|D|@]|E|$]]|$1|30|3|-4|5|6|7|80|8|@]|D|@]|E|$]]]|31|$32|$5|33|34|35|E|$36|37]]|38|$5|33|34|35|E|$36|39]]|3A|$5|33|34|35|E|$36|3B]]|3C|$5|33|34|35|E|$36|3D]]|3E|$5|33|34|35|E|$36|3F]]|3G|$5|33|34|35|E|$36|3H]]|3I|$5|33|34|35|E|$36|3J]]|3K|$5|33|34|35|E|$36|3L]]|3M|$5|33|34|35|E|$36|3N]]|3O|$5|33|34|35|E|$36|3P]]|3Q|$5|33|34|35|E|$36|3R]]|3S|$5|33|34|35|E|$36|3T]]|3U|$5|33|34|35|E|$36|3V]]|3W|$5|33|34|35|E|$36|3X]]|3Y|$5|33|34|35|E|$36|3Z]]|40|$5|33|34|35|E|$36|41]]|42|$5|33|34|35|E|$36|43]]|44|$5|33|34|35|E|$36|45]]|46|$5|33|34|35|E|$36|47]]]]

You can try <a href="http://golang.org/pkg/unicode/utf8/#RuneCountInString" rel="noreferrer"><code>RuneCountInString</code></a> from the utf8 package.
<blockquote>
returns the number of runes in p
</blockquote>
that, as illustrated in <a href="http://play.golang.org/p/zzB1VrwdER" rel="noreferrer">this script</a>: the length of &quot;World&quot; might be 6 (when written in Chinese: &quot;世界&quot;), but its rune count is 2:
<pre class="lang-golang prettyprint-override"><code>package main
 
import &quot;fmt&quot;
import &quot;unicode/utf8&quot;
 
func main() {
 fmt.Println(&quot;Hello, 世界&quot;, len(&quot;世界&quot;), utf8.RuneCountInString(&quot;世界&quot;))
}
</code></pre>
<a href="https://stackoverflow.com/users/383848/phrozen">Phrozen</a> adds <a href="https://stackoverflow.com/questions/12668681/go-language-string-length/12668840#comment39875126_12668840">in the comments</a>:
Actually you can do <code>len()</code> over runes by just type casting. 
<code>len([]rune(&quot;世界&quot;))</code> will print <code>2</code>. At leats in Go 1.3.
<hr />
And with <a href="https://go-review.googlesource.com/c/go/+/108985" rel="noreferrer">CL 108985</a> (May 2018, for Go 1.11), <code>len([]rune(string))</code> is now optimized. (Fixes <a href="https://github.com/golang/go/issues/24923" rel="noreferrer">issue 24923</a>)
The compiler detects <code>len([]rune(string))</code> pattern automatically, and replaces it with for r := range s call.
<blockquote>
Adds a new runtime function to count runes in a string.
Modifies the compiler to detect the pattern <code>len([]rune(string))</code>
and replaces it with the new rune counting runtime function.
<pre><code>RuneCount/lenruneslice/ASCII 27.8ns ± 2% 14.5ns ± 3% -47.70%
RuneCount/lenruneslice/Japanese 126ns ± 2% 60 ns ± 2% -52.03%
RuneCount/lenruneslice/MixedLength 104ns ± 2% 50 ns ± 1% -51.71%
</code></pre>
</blockquote>
<hr />
<a href="https://stackoverflow.com/users/155077/stefan-steiger">Stefan Steiger</a> points to the blog post &quot;<a href="https://blog.golang.org/normalization" rel="noreferrer">Text normalization in Go</a>&quot;
<blockquote>
<h2>What is a character?</h2>
</blockquote>
<blockquote>
As was mentioned in the <a href="http://blog.golang.org/strings" rel="noreferrer">strings blog post</a>, characters can span multiple runes. 
For example, an '<code>e</code>' and '◌́◌́' (acute &quot;\u0301&quot;) can combine to form 'é' (&quot;<code>e\u0301</code>&quot; in NFD). Together these two runes are one character.
The definition of a character may vary depending on the application. 
For <a href="https://godoc.org/golang.org/x/text/unicode/norm" rel="noreferrer">normalization</a> we will define it as:
<ul>
<li>a sequence of runes that starts with a starter,</li>
<li>a rune that does not modify or combine backwards with any other rune,</li>
<li>followed by possibly empty sequence of non-starters, that is, runes that do (typically accents).</li>
</ul>
The normalization algorithm processes one character at at time.
</blockquote>
Using that package and its <a href="https://godoc.org/golang.org/x/text/unicode/norm#Iter" rel="noreferrer"><code>Iter</code> type</a>, the actual number of &quot;character&quot; would be:
<pre class="lang-golang prettyprint-override"><code>package main
 
import &quot;fmt&quot;
import &quot;golang.org/x/text/unicode/norm&quot;
 
func main() {
 var ia norm.Iter
 ia.InitString(norm.NFKD, &quot;école&quot;)
 nc := 0
 for !ia.Done() {
 nc = nc + 1
 ia.Next()
 }
 fmt.Printf(&quot;Number of chars: %d\n&quot;, nc)
}
</code></pre>
Here, this uses the <a href="http://unicode.org/reports/tr15/#Norm_Forms" rel="noreferrer">Unicode Normalization form</a> NFKD &quot;Compatibility Decomposition&quot;
<hr />
<a href="https://stackoverflow.com/users/2046109/oliver">Oliver</a>'s <a href="https://stackoverflow.com/a/55151396/6309">answer</a> points to <a href="http://unicode.org/reports/tr29/" rel="noreferrer">UNICODE TEXT SEGMENTATION</a> as the only way to reliably determining default boundaries between certain significant text elements: user-perceived characters, words, and sentences.
For that, you need an external library like <a href="https://github.com/rivo/uniseg" rel="noreferrer">rivo/uniseg</a>, which does Unicode Text Segmentation.
That will actually count &quot;<a href="https://en.wikipedia.org/wiki/Grapheme" rel="noreferrer">grapheme</a> cluster&quot;, where multiple code points may be combined into one user-perceived character.
<pre class="lang-golang prettyprint-override"><code>package uniseg
 
import (
 &quot;fmt&quot;
 
 &quot;github.com/rivo/uniseg&quot;
)
 
func main() {
 gr := uniseg.NewGraphemes(&quot;!&quot;)
 for gr.Next() {
 fmt.Printf(&quot;%x &quot;, gr.Runes())
 }
 // Output: [1f44d 1f3fc] [21]
}
</code></pre>
Two graphemes, even though there are three runes (Unicode code points).
You can see other examples in &quot;<a href="https://stackoverflow.com/a/62743214/6309">How to manipulate strings in GO to reverse them?</a>&quot;
‍ alone is one grapheme, but, from <a href="https://onlineunicodetools.com/convert-unicode-to-code-points" rel="noreferrer">unicode to code points converter</a>, 4 runes:
<ul>
<li>: <a href="https://apps.timwhitlock.info/unicode/inspect/hex/1F469" rel="noreferrer">women (1f469)</a></li>
<li><a href="https://apps.timwhitlock.info/unicode/inspect/hex/1f3fe" rel="noreferrer">dark skin (1f3fe)</a></li>
<li><a href="https://apps.timwhitlock.info/unicode/inspect/hex/200d" rel="noreferrer">ZERO WIDTH JOINER (200d)</a></li>
<li><a href="https://apps.timwhitlock.info/unicode/inspect/hex/1f9b0" rel="noreferrer">red hair (1f9b0)</a></li>
</ul>

blocks|key|212282|text|这在很大程度上取决于你对“性格”的定义。如果“符文等于一个字符”对你的任务来说是可以的(通常不是)，那么VonC的答案对你来说是完美的。否则，可能应该注意到，Unicode字符串中的符号数是一个有趣的值的情况很少。即使在这些情况下，如果可能的话，最好是在处理符文时在“遍历”字符串时推断计数，以避免加倍的UTF-8解码工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|212283|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Depends a lot on your definition of what a "character" is. If "rune equals a character " is OK for your task (generally it isn't) then the answer by VonC is perfect for you. Otherwise, it should be probably noted, that there are few situations where the number of runes in a Unicode string is an interesting value. And even in those situations it's better, if possible, to infer the count while "traversing" the string as the runes are processed to avoid doubling the UTF-8 decode effort.

blocks|key|212788|text|如果您需要考虑字素集群，请使用regexp或unicode模块。由于字素簇的长度是无限的，因此还需要计算代码点(符文)或字节的数量以进行验证。如果您想要消除极长的序列，请检查序列是否符合stream-safe+text+format。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|212789|package+main

import+(
++++"regexp"
++++"unicode"
++++"strings"
)

func+main()+{

++++str+:=+"\u0308"+%2B+"a\u0308"+%2B+"o\u0308"+%2B+"u\u0308"
++++str2+:=+"a"+%2B+strings.Repeat("\u0308",+1000)

++++println(4+==+GraphemeCountInString(str))
++++println(4+==+GraphemeCountInString2(str))

++++println(1+==+GraphemeCountInString(str2))
++++println(1+==+GraphemeCountInString2(str2))

++++println(true+==+IsStreamSafeString(str))
++++println(false+==+IsStreamSafeString(str2))
}


func+GraphemeCountInString(str+string)+int+{
++++re+:=+regexp.MustCompile("\\PM\\pM*%7C.")
++++return+len(re.FindAllString(str,+-1))
}

func+GraphemeCountInString2(str+string)+int+{

++++length+:=+0
++++checked+:=+false
++++index+:=+0

++++for+_,+c+:=+range+str+{

++++++++if+!unicode.Is(unicode.M,+c)+{
++++++++++++length%2B%2B

++++++++++++if+checked+==+false+{
++++++++++++++++checked+=+true
++++++++++++}

++++++++}+else+if+checked+==+false+{
++++++++++++length%2B%2B
++++++++}

++++++++index%2B%2B
++++}

++++return+length
}

func+IsStreamSafeString(str+string)+bool+{
++++re+:=+regexp.MustCompile("\\PM\\pM{30,}")+
++++return+!re.MatchString(str)+
}|code-block|syntax|javascript|212790|entityMap|0|LINK|mutability|MUTABLE|url|http://www.unicode.org/reports/tr15/#Stream_Safe_Text_Format^0|2L|N|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

If you need to take grapheme clusters into account, use regexp or unicode module. Counting the number of code points(runes) or bytes also is needed for validaiton since the length of grapheme cluster is unlimited. If you want to eliminate extremely long sequences, check if the sequences conform to <a href="http://www.unicode.org/reports/tr15/#Stream_Safe_Text_Format" rel="noreferrer">stream-safe text format</a>.

<pre><code>package main

import (
 "regexp"
 "unicode"
 "strings"
)

func main() {

 str := "\u0308" + "a\u0308" + "o\u0308" + "u\u0308"
 str2 := "a" + strings.Repeat("\u0308", 1000)

 println(4 == GraphemeCountInString(str))
 println(4 == GraphemeCountInString2(str))

 println(1 == GraphemeCountInString(str2))
 println(1 == GraphemeCountInString2(str2))

 println(true == IsStreamSafeString(str))
 println(false == IsStreamSafeString(str2))
}


func GraphemeCountInString(str string) int {
 re := regexp.MustCompile("\\PM\\pM*|.")
 return len(re.FindAllString(str, -1))
}

func GraphemeCountInString2(str string) int {

 length := 0
 checked := false
 index := 0

 for _, c := range str {

 if !unicode.Is(unicode.M, c) {
 length++

 if checked == false {
 checked = true
 }

 } else if checked == false {
 length++
 }

 index++
 }

 return length
}

func IsStreamSafeString(str string) bool {
 re := regexp.MustCompile("\\PM\\pM{30,}") 
 return !re.MatchString(str) 
}
</code></pre>

blocks|key|212299|text|有一种方法可以在没有任何包的情况下获得符文计数，方法是将字符串转换为[]符文作为len([]rune(YOUR_STRING))|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|212300|package+main

import+"fmt"

func+main()+{
++++russian+:=+"Спутник+и+погром"
++++english+:=+"Sputnik+&+pogrom"

++++fmt.Println("count+of+bytes:",
++++++++len(russian),
++++++++len(english))

++++fmt.Println("count+of+runes:",
++++++++len([]rune(russian)),
++++++++len([]rune(english)))

}|code-block|syntax|javascript|212301|字节的|212302|计数30+16|blockquote|212303|212304|符文计数16+16|212305|entityMap^0|14|O|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|O|7|Z|8|@]|D|@]|E|$]]|$1|P|3|-4|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|11|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|T|$]]

There is a way to get count of runes without any packages by converting string to []rune as <code>len([]rune(YOUR_STRING))</code>:

<pre><code>package main

import "fmt"

func main() {
 russian := "Спутник и погром"
 english := "Sputnik &amp; pogrom"

 fmt.Println("count of bytes:",
 len(russian),
 len(english))

 fmt.Println("count of runes:",
 len([]rune(russian)),
 len([]rune(english)))

}
</code></pre>

<blockquote>
 count of bytes 30 16
 
 count of runes 16 16
</blockquote>

blocks|key|2854059|text|我试着让标准化做得更快一点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2854060|++++en,+_+=+glyphSmart(data)

++++func+glyphSmart(text+string)+(int,+int)+{
++++++++gc+:=+0
++++++++dummy+:=+0
++++++++for+ind,+_+:=+range+text+{
++++++++++++gc%2B%2B
++++++++++++dummy+=+ind
++++++++}
++++++++dummy+=+0
++++++++return+gc,+dummy
++++}|code-block|syntax|javascript|2854061|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I tried to make to do the normalization a bit faster:

<pre><code> en, _ = glyphSmart(data)

 func glyphSmart(text string) (int, int) {
 gc := 0
 dummy := 0
 for ind, _ := range text {
 gc++
 dummy = ind
 }
 dummy = 0
 return gc, dummy
 }
</code></pre>

blocks|key|3067755|text|我应该指出的是，到目前为止，提供的答案都没有给出您期望的字符数，特别是当您处理表情符号时(但也有一些语言，如泰语、韩语或阿拉伯语)。VonC's+suggestions将输出以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3067756|fmt.Println(utf8.RuneCountInString("️‍"))+//+Outputs+"6".
fmt.Println(len([]rune("️‍")))+//+Outputs+"6".|code-block|syntax|javascript|3067757|这是因为这些方法只计算Unicode代码点。有许多字符，可以由多个码点组成。|3067758|与使用Normalization+package相同|3067759|var+ia+norm.Iter
ia.InitString(norm.NFKD,+"️‍")
nc+:=+0
for+!ia.Done()+{
++++nc+=+nc+%2B+1
++++ia.Next()
}
fmt.Println(nc)+//+Outputs+"6".|3067760|归一化并不等同于计算字符，许多字符无法归一化为一个码点的等价物。|3067761|masakielastic's+answer很接近，但只处理修饰符(彩虹标志包含一个修饰符，因此不会被算作它自己的代码点)：|3067762|fmt.Println(GraphemeCountInString("️‍"))++//+Outputs+"5".
fmt.Println(GraphemeCountInString2("️‍"))+//+Outputs+"5".|3067763|在Unicode+Standard+Annex+#29中定义了将Unicode字符串拆分成(用户可感知的)字符的正确方法，即字素簇。规则可以在Section+3.1.1中找到。github.com/rivo/uniseg包实现了这些规则，因此您可以确定字符串中的正确字符数：|3067764|fmt.Println(uniseg.GraphemeClusterCount("️‍"))+//+Outputs+"2".|3067765|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/12668840/2046109|1|https://godoc.org/golang.org/x/text/unicode/norm|2|https://stackoverflow.com/a/26728555/2046109|3|http://unicode.org/reports/tr29/|4|http://unicode.org/reports/tr29/#Grapheme_Cluster_Boundary_Rules|5|https://github.com/rivo/uniseg^0|1U|I|0|0|0|0|3|L|1|0|0|0|0|M|2|0|0|1|Q|3|1Z|D|4|2G|M|5|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@$A|1H|B|1I|1|1J]]|C|$]]|$1|D|3|E|5|F|7|1K|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1L|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|1M|8|@]|9|@$A|1N|B|1O|1|1P]]|C|$]]|$1|M|3|N|5|F|7|1Q|8|@]|9|@]|C|$G|H]]|$1|O|3|P|5|6|7|1R|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1S|8|@]|9|@$A|1T|B|1U|1|1V]]|C|$]]|$1|S|3|T|5|F|7|1W|8|@]|9|@]|C|$G|H]]|$1|U|3|V|5|6|7|1X|8|@]|9|@$A|1Y|B|1Z|1|20]|$A|21|B|22|1|23]|$A|24|B|25|1|26]]|C|$]]|$1|W|3|X|5|F|7|27|8|@]|9|@]|C|$G|H]]|$1|Y|3|-4|5|6|7|28|8|@]|9|@]|C|$]]]|Z|$10|$5|11|12|13|C|$14|15]]|16|$5|11|12|13|C|$14|17]]|18|$5|11|12|13|C|$14|19]]|1A|$5|11|12|13|C|$14|1B]]|1C|$5|11|12|13|C|$14|1D]]|1E|$5|11|12|13|C|$14|1F]]]]

I should point out that none of the answers provided so far give you the number of characters as you would expect, especially when you're dealing with emojis (but also some languages like Thai, Korean, or Arabic). <a href="https://stackoverflow.com/a/12668840/2046109">VonC's suggestions</a> will output the following:

<pre class="lang-golang prettyprint-override"><code>fmt.Println(utf8.RuneCountInString("️‍")) // Outputs "6".
fmt.Println(len([]rune("️‍"))) // Outputs "6".
</code></pre>

That's because these methods only count Unicode code points. There are many characters which can be composed of multiple code points.

Same for using the <a href="https://godoc.org/golang.org/x/text/unicode/norm" rel="noreferrer">Normalization package</a>:

<pre class="lang-golang prettyprint-override"><code>var ia norm.Iter
ia.InitString(norm.NFKD, "️‍")
nc := 0
for !ia.Done() {
 nc = nc + 1
 ia.Next()
}
fmt.Println(nc) // Outputs "6".
</code></pre>

Normalization is not really the same as counting characters and many characters cannot be normalized into a one-code-point equivalent.

<a href="https://stackoverflow.com/a/26728555/2046109">masakielastic's answer</a> comes close but only handles modifiers (the rainbow flag contains a modifier which is thus not counted as its own code point):

<pre class="lang-golang prettyprint-override"><code>fmt.Println(GraphemeCountInString("️‍")) // Outputs "5".
fmt.Println(GraphemeCountInString2("️‍")) // Outputs "5".
</code></pre>

The correct way to split Unicode strings into (user-perceived) characters, i.e. grapheme clusters, is defined in the <a href="http://unicode.org/reports/tr29/" rel="noreferrer">Unicode Standard Annex #29</a>. The rules can be found in <a href="http://unicode.org/reports/tr29/#Grapheme_Cluster_Boundary_Rules" rel="noreferrer">Section 3.1.1</a>. The <a href="https://github.com/rivo/uniseg" rel="noreferrer">github.com/rivo/uniseg</a> package implements these rules so you can determine the correct number of characters in a string:

<pre class="lang-golang prettyprint-override"><code>fmt.Println(uniseg.GraphemeClusterCount("️‍")) // Outputs "2".
</code></pre>

blocks|key|2854096|text|有几种方法可以获取字符串长度：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2854097|package+main

import+(
++++"bytes"
++++"fmt"
++++"strings"
++++"unicode/utf8"
)

func+main()+{
++++b+:=+"这是个测试"
++++len1+:=+len([]rune(b))
++++len2+:=+bytes.Count([]byte(b),+nil)+-1
++++len3+:=+strings.Count(b,+"")+-+1
++++len4+:=+utf8.RuneCountInString(b)
++++fmt.Println(len1)
++++fmt.Println(len2)
++++fmt.Println(len3)
++++fmt.Println(len4)

}|code-block|syntax|javascript|2854098|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

There are several ways to get a string length:

<pre><code>package main

import (
 "bytes"
 "fmt"
 "strings"
 "unicode/utf8"
)

func main() {
 b := "这是个测试"
 len1 := len([]rune(b))
 len2 := bytes.Count([]byte(b), nil) -1
 len3 := strings.Count(b, "") - 1
 len4 := utf8.RuneCountInString(b)
 fmt.Println(len1)
 fmt.Println(len2)
 fmt.Println(len3)
 fmt.Println(len4)

}

</code></pre>

How can I get the number of characters of a string in Go?

For example, if I have a string <code>"hello"</code> the method should return <code>5</code>. I saw that <code>len(str)</code> returns the number of bytes and not the number of characters so <code>len("£")</code> returns 2 instead of 1 because £ is encoded with two bytes in UTF-8.

How to get the number of characters in a string

编译器

如何在Go中获取字符串的字符数？例如，如果我有一个字符串"hello"，该方法应该返回5。我看到len(str)返回字节数，而不是字符数，所以len("£")返回2而不是1，因为in在UTF8中是用两个字节编码的。

问如何获取字符串中的字符数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何获取字符串中的字符数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何获取字符串中的字符数
EN