blocks|key|1906126|text|一个我认为可以在unicode上工作的版本。它是基于utf8.Rune函数构建的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1906127|func+Reverse(s+string)+string+{
++++b+:=+make([]byte,+len(s));
++++for+i,+j+:=+len(s)-1,+0;+i+>=+0;+i--+{
++++++++if+utf8.RuneStart(s[i])+{
++++++++++++rune,+size+:=+utf8.DecodeRuneInString(s[i:len(s)]);
++++++++++++utf8.EncodeRune(rune,+b[j:j%2Bsize]);
++++++++++++j+%2B=+size;
++++++++}
++++}
++++return+string(b);
}|code-block|syntax|javascript|1906128|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|$]]

A version which I think works on unicode. It is built on the utf8.Rune functions:

<pre><code>func Reverse(s string) string {
 b := make([]byte, len(s));
 for i, j := len(s)-1, 0; i &gt;= 0; i-- {
 if utf8.RuneStart(s[i]) {
 rune, size := utf8.DecodeRuneInString(s[i:len(s)]);
 utf8.EncodeRune(rune, b[j:j+size]);
 j += size;
 }
 }
 return string(b);
}
</code></pre>

blocks|key|1906151|text|Russ+Cox,+on+the+golang-nuts+mailing+list，建议|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1906152|package+main+
import+"fmt"
func+main()+{+
++++++++input+:=+"The+quick+brown+狐+jumped+over+the+lazy+犬"+
++++++++//+Get+Unicode+code+points.+
++++++++n+:=+0
++++++++rune+:=+make([]rune,+len(input))
++++++++for+_,+r+:=+range+input+{+
++++++++++++++++rune[n]+=+r
++++++++++++++++n%2B%2B
++++++++}+
++++++++rune+=+rune[0:n]
++++++++//+Reverse+
++++++++for+i+:=+0;+i+<+n/2;+i%2B%2B+{+
++++++++++++++++rune[i],+rune[n-1-i]+=+rune[n-1-i],+rune[i]+
++++++++}+
++++++++//+Convert+back+to+UTF-8.+
++++++++output+:=+string(rune)
++++++++fmt.Println(output)
}|code-block|syntax|javascript|1906153|entityMap|0|LINK|mutability|MUTABLE|url|http://groups.google.com/group/golang-nuts/browse_thread/thread/a0fb81698275eede^0|0|15|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]]]]

<a href="http://groups.google.com/group/golang-nuts/browse_thread/thread/a0fb81698275eede" rel="noreferrer">Russ Cox, on the golang-nuts mailing list</a>, suggests

<pre><code>package main 
import "fmt"
func main() { 
 input := "The quick brown 狐 jumped over the lazy 犬" 
 // Get Unicode code points. 
 n := 0
 rune := make([]rune, len(input))
 for _, r := range input { 
 rune[n] = r
 n++
 } 
 rune = rune[0:n]
 // Reverse 
 for i := 0; i &lt; n/2; i++ { 
 rune[i], rune[n-1-i] = rune[n-1-i], rune[i] 
 } 
 // Convert back to UTF-8. 
 output := string(rune)
 fmt.Println(output)
}
</code></pre>

blocks|key|1906179|text|注意：这个答案来自2009年，所以现在可能有更好的解决方案。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1906180|1906181|看起来有点“转弯抹角”，可能效率不是很高，但演示了如何使用Reader接口读取字符串。在处理utf8字符串时，IntVectors似乎也非常适合作为缓冲区。|1906182|如果去掉“size”部分，通过插入插入到向量中，那么它会更短，但我猜效率会更低，因为每次添加新的符文时，整个向量都需要向后推一次。|1906183|这个解决方案绝对适用于utf8字符。|1906184|package+main

import+"container/vector";
import+"fmt";
import+"utf8";
import+"bytes";
import+"bufio";


func
main()+{
++++toReverse+:=+"Smørrebrød";
++++fmt.Println(toReverse);
++++fmt.Println(reverse(toReverse));
}

func
reverse(str+string)+string+{
++++size+:=+utf8.RuneCountInString(str);
++++output+:=+vector.NewIntVector(size);
++++input+:=+bufio.NewReader(bytes.NewBufferString(str));
++++for+i+:=+1;+i+<=+size;+i%2B%2B+{
++++++++rune,+_,+_+:=+input.ReadRune();
++++++++output.Set(size+-+i,+rune);
++++}
++++return+string(output.Data());
}|code-block|syntax|javascript|1906185|entityMap^0|0|3|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|W|8|@]|D|@]|E|$]]|$1|G|3|H|5|6|7|X|8|@]|D|@]|E|$]]|$1|I|3|J|5|6|7|Y|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|Z|8|@]|D|@]|E|$]]|$1|M|3|N|5|O|7|10|8|@]|D|@]|E|$P|Q]]|$1|R|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|S|$]]

NOTE: This answer is from 2009, so there are probably better solutions out there by now.

<hr>

Looks a bit 'roundabout', and probably not very efficient, but illustrates how the Reader interface can be used to read from strings. IntVectors also seem very suitable as buffers when working with utf8 strings.

It would be even shorter when leaving out the 'size' part, and insertion into the vector by Insert, but I guess that would be less efficient, as the whole vector then needs to be pushed back by one each time a new rune is added.

This solution definitely works with utf8 characters.

<pre><code>package main

import "container/vector";
import "fmt";
import "utf8";
import "bytes";
import "bufio";


func
main() {
 toReverse := "Smørrebrød";
 fmt.Println(toReverse);
 fmt.Println(reverse(toReverse));
}

func
reverse(str string) string {
 size := utf8.RuneCountInString(str);
 output := vector.NewIntVector(size);
 input := bufio.NewReader(bytes.NewBufferString(str));
 for i := 1; i &lt;= size; i++ {
 rune, _, _ := input.ReadRune();
 output.Set(size - i, rune);
 }
 return string(output.Data());
}
</code></pre>

blocks|key|5435155|text|这是通过考虑两件事来处理unicode字符串的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5435156|5435157|range通过枚举unicode来处理字符串。characters|unordered-list-item|offset|length|style|BOLD|5435158|string可以从整数切片构造，其中每个元素都是unicode字符。|5435159|5435160|所以它是这样的：|5435161|func+reverse(s+string)+string+{
++++o+:=+make([]int,+utf8.RuneCountInString(s));
++++i+:=+len(o);
++++for+_,+c+:=+range+s+{
++++++++i--;
++++++++o[i]+=+c;
++++}
++++return+string(o);
}|code-block|syntax|javascript|5435162|entityMap^0|0|0|0|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|X|8|@$F|Y|G|Z|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|10|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|11|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|12|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|13|8|@]|9|@]|A|$R|S]]|$1|T|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|U|$]]

This works on unicode strings by considering 2 things:

<ul>
<li>range works on string by enumerating unicode characters</li>
<li>string can be constructed from int slices where each element is a unicode character.</li>
</ul>

So here it goes:

<pre><code>func reverse(s string) string {
 o := make([]int, utf8.RuneCountInString(s));
 i := len(o);
 for _, c := range s {
 i--;
 o[i] = c;
 }
 return string(o);
}
</code></pre>

blocks|key|5435185|text|这是可行的，而不需要对函数进行所有的修改：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5435186|func+Reverse(s+string)+(result+string)+{
++for+_,v+:=+range+s+{
++++result+=+string(v)+%2B+result
++}
++return+
}|code-block|syntax|javascript|5435187|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|$]]

This works, without all the mucking about with functions:

<pre><code>func Reverse(s string) (result string) {
 for _,v := range s {
 result = string(v) + result
 }
 return 
}
</code></pre>

blocks|key|5435243|text|当Simon发布his+solution时，我注意到了这个问题，因为字符串是不可变的，效率非常低。其他提出的解决方案也是有缺陷的；它们不起作用或效率低下。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5435244|这里有一个有效的解决方案，除了当字符串不是有效的UTF-8或字符串包含组合字符时。|5435245|package+main

import+"fmt"

func+Reverse(s+string)+string+{
++++n+:=+len(s)
++++runes+:=+make([]rune,+n)
++++for+_,+rune+:=+range+s+{
++++++++n--
++++++++runes[n]+=+rune
++++}
++++return+string(runes[n:])
}

func+main()+{
++++fmt.Println(Reverse(Reverse("Hello,+世界")))
++++fmt.Println(Reverse(Reverse("The+quick+brown+狐+jumped+over+the+lazy+犬")))
}|code-block|syntax|javascript|5435246|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/612511/simon|1|https://stackoverflow.com/questions/1752414/how-to-reverse-a-string-in-go/4965535#4965535^0|1|5|0|8|C|1|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]|$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|12|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

I noticed this question when <a href="https://stackoverflow.com/users/612511/simon">Simon</a> posted <a href="https://stackoverflow.com/questions/1752414/how-to-reverse-a-string-in-go/4965535#4965535">his solution</a> which, since strings are immutable, is very inefficient. The other proposed solutions are also flawed; they don't work or they are inefficient.

Here's an efficient solution that works, except when the string is not valid UTF-8 or the string contains combining characters.

<pre><code>package main

import "fmt"

func Reverse(s string) string {
 n := len(s)
 runes := make([]rune, n)
 for _, rune := range s {
 n--
 runes[n] = rune
 }
 return string(runes[n:])
}

func main() {
 fmt.Println(Reverse(Reverse("Hello, 世界")))
 fmt.Println(Reverse(Reverse("The quick brown 狐 jumped over the lazy 犬")))
}
</code></pre>

blocks|key|1574748|text|在Go1中，符文是一种内置类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1574749|func+Reverse(s+string)+string+{
++++runes+:=+[]rune(s)
++++for+i,+j+:=+0,+len(runes)-1;+i+<+j;+i,+j+=+i%2B1,+j-1+{
++++++++runes[i],+runes[j]+=+runes[j],+runes[i]
++++}
++++return+string(runes)
}|code-block|syntax|javascript|1574750|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|$]]

In Go1 rune is a builtin type.

<pre><code>func Reverse(s string) string {
 runes := []rune(s)
 for i, j := 0, len(runes)-1; i &lt; j; i, j = i+1, j-1 {
 runes[i], runes[j] = runes[j], runes[i]
 }
 return string(runes)
}
</code></pre>

blocks|key|1570863|text|rune是一种类型，所以请使用它。此外，Go不使用分号。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1570864|func+reverse(s+string)+string+{
++++l+:=+len(s)
++++m+:=+make([]rune,+l)

++++for+_,+c+:=+range+s+{
++++++++l--
++++++++m[l]+=+c
++++}
++++return+string(m)
}

func+main()+{
++++str+:=+"the+quick+brown+狐+jumped+over+the+lazy+犬"
++++fmt.Printf("reverse(%25s):+[%25s]\n",+str,+reverse(str))
}|code-block|syntax|javascript|1570865|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|$]]

rune is a type, so use it. Moreover, Go doesn't use semicolons.

<pre><code>func reverse(s string) string {
 l := len(s)
 m := make([]rune, l)

 for _, c := range s {
 l--
 m[l] = c
 }
 return string(m)
}

func main() {
 str := "the quick brown 狐 jumped over the lazy 犬"
 fmt.Printf("reverse(%s): [%s]\n", str, reverse(str))
}
</code></pre>

blocks|key|4016991|text|这是最快的实现|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4016992|func+Reverse(s+string)+string+{
++++size+:=+len(s)
++++buf+:=+make([]byte,+size)
++++for+start+:=+0;+start+<+size;+{
++++++++r,+n+:=+utf8.DecodeRuneInString(s[start:])
++++++++start+%2B=+n
++++++++utf8.EncodeRune(buf[size-start:],+r)
++++}
++++return+string(buf)
}

const+(
++++s+++++++=+"The+quick+brown+狐+jumped+over+the+lazy+犬"
++++reverse+=+"犬+yzal+eht+revo+depmuj+狐+nworb+kciuq+ehT"
)

func+TestReverse(t+*testing.T)+{
++++if+Reverse(s)+!=+reverse+{
++++++++t.Error(s)
++++}
}

func+BenchmarkReverse(b+*testing.B)+{
++++for+i+:=+0;+i+<+b.N;+i%2B%2B+{
++++++++Reverse(s)
++++}
}|code-block|syntax|javascript|4016993|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|$]]

This is the fastest implementation

<pre><code>func Reverse(s string) string {
 size := len(s)
 buf := make([]byte, size)
 for start := 0; start &lt; size; {
 r, n := utf8.DecodeRuneInString(s[start:])
 start += n
 utf8.EncodeRune(buf[size-start:], r)
 }
 return string(buf)
}

const (
 s = "The quick brown 狐 jumped over the lazy 犬"
 reverse = "犬 yzal eht revo depmuj 狐 nworb kciuq ehT"
)

func TestReverse(t *testing.T) {
 if Reverse(s) != reverse {
 t.Error(s)
 }
}

func BenchmarkReverse(b *testing.B) {
 for i := 0; i &lt; b.N; i++ {
 Reverse(s)
 }
}
</code></pre>

blocks|key|4017016|text|这是另一个解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4017017|func+ReverseStr(s+string)+string+{
++++chars+:=+[]rune(s)
++++rev+:=+make([]rune,+0,+len(chars))
++++for+i+:=+len(chars)+-+1;+i+>=+0;+i--+{
++++++++rev+=+append(rev,+chars[i])
++++}
++++return+string(rev)
}|code-block|syntax|javascript|4017018|然而，yazu上面的解决方案更优雅，因为他在适当的位置颠倒了[]rune切片。|offset|length|style|CODE|4017019|entityMap^0|0|0|U|6|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Here is yet another solution:

<pre><code>func ReverseStr(s string) string {
 chars := []rune(s)
 rev := make([]rune, 0, len(chars))
 for i := len(chars) - 1; i &gt;= 0; i-- {
 rev = append(rev, chars[i])
 }
 return string(rev)
}
</code></pre>

However, yazu's solution above is more elegant since he reverses the <code>[]rune</code> slice in place.

blocks|key|1906515|text|还有另一个解决方案(tm)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1906516|package+main+
import+"fmt"

type+Runes+[]rune

func+(s+Runes)+Reverse()+(cp+Runes)+{
++++l+:=+len(s);+cp+=+make(Runes,+l)
++++//+i+<=+1/2+otherwise+it+will+mess+up+with+odd+length+strings
++++for+i+:=+0;+i+<=+l/2;+i%2B%2B+{+
++++++++cp[i],+cp[l-1-i]+=+s[l-1-i],+s[i]+
++++}
++++return+cp
}

func+(s+Runes)+String()+string+{
++++return+string(s)
}

func+main()+{+
++++input+:=+"The+quick+brown+狐+jumped+over+the+lazy+犬+%2Bodd"+
++++r+:=+Runes(input)
++++output+:=+r.Reverse()
++++valid+:=+string(output.Reverse())+==+input
++++fmt.Println(len(r),+len(output),+r,+output.Reverse(),+valid)
}|code-block|syntax|javascript|1906517|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|$]]

Yet Another Solution (tm) :

<pre><code>package main 
import "fmt"

type Runes []rune

func (s Runes) Reverse() (cp Runes) {
 l := len(s); cp = make(Runes, l)
 // i &lt;= 1/2 otherwise it will mess up with odd length strings
 for i := 0; i &lt;= l/2; i++ { 
 cp[i], cp[l-1-i] = s[l-1-i], s[i] 
 }
 return cp
}

func (s Runes) String() string {
 return string(s)
}

func main() { 
 input := "The quick brown 狐 jumped over the lazy 犬 +odd" 
 r := Runes(input)
 output := r.Reverse()
 valid := string(output.Reverse()) == input
 fmt.Println(len(r), len(output), r, output.Reverse(), valid)
}
</code></pre>

blocks|key|1574818|text|如果需要处理字素集群，请使用unicode或regexp模块。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1574819|package+main

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

func+main()+{
++++str+:=+"\u0308"+%2B+"a\u0308"+%2B+"o\u0308"+%2B+"u\u0308"
++++println("u\u0308"+%2B+"o\u0308"+%2B+"a\u0308"+%2B+"\u0308"+==+ReverseGrapheme(str))
++++println("u\u0308"+%2B+"o\u0308"+%2B+"a\u0308"+%2B+"\u0308"+==+ReverseGrapheme2(str))
}

func+ReverseGrapheme(str+string)+string+{

++buf+:=+[]rune("")
++checked+:=+false
++index+:=+0
++ret+:=+""+

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

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

++++++++++++if+len(buf)+>+0+{
++++++++++++++++ret+=+string(buf)+%2B+ret
++++++++++++}

++++++++++++buf+=+buf[:0]
++++++++++++buf+=+append(buf,+c)

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

++++++++}+else+if+checked+==+false+{
++++++++++++ret+=+string(append([]rune(""),+c))+%2B+ret
++++++++}+else+{
++++++++++++buf+=+append(buf,+c)
++++++++}

++++++++index+%2B=+1
++++}

++++return+string(buf)+%2B+ret
}

func+ReverseGrapheme2(str+string)+string+{
++++re+:=+regexp.MustCompile("\\PM\\pM*%7C.")
++++slice+:=+re.FindAllString(str,+-1)
++++length+:=+len(slice)
++++ret+:=+""

++++for+i+:=+0;+i+<+length;+i+%2B=+1+{
++++++++ret+%2B=+slice[length-1-i]
++++}

++++return+ret
}|code-block|syntax|javascript|1574820|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|$]]

If you need to handle grapheme clusters, use unicode or regexp module.

<pre><code>package main

import (
 "unicode"
 "regexp"
)

func main() {
 str := "\u0308" + "a\u0308" + "o\u0308" + "u\u0308"
 println("u\u0308" + "o\u0308" + "a\u0308" + "\u0308" == ReverseGrapheme(str))
 println("u\u0308" + "o\u0308" + "a\u0308" + "\u0308" == ReverseGrapheme2(str))
}

func ReverseGrapheme(str string) string {

 buf := []rune("")
 checked := false
 index := 0
 ret := "" 

 for _, c := range str {

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

 if len(buf) &gt; 0 {
 ret = string(buf) + ret
 }

 buf = buf[:0]
 buf = append(buf, c)

 if checked == false {
 checked = true
 }

 } else if checked == false {
 ret = string(append([]rune(""), c)) + ret
 } else {
 buf = append(buf, c)
 }

 index += 1
 }

 return string(buf) + ret
}

func ReverseGrapheme2(str string) string {
 re := regexp.MustCompile("\\PM\\pM*|.")
 slice := re.FindAllString(str, -1)
 length := len(slice)
 ret := ""

 for i := 0; i &lt; length; i += 1 {
 ret += slice[length-1-i]
 }

 return ret
}
</code></pre>

blocks|key|4017309|text|这段代码完整地保留了组合字符的序列，也应该可以处理无效的UTF-8输入。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4017310|package+stringutil
import+"code.google.com/p/go.text/unicode/norm"

func+Reverse(s+string)+string+{
++++bound+:=+make([]int,+0,+len(s)+%2B+1)

++++var+iter+norm.Iter
++++iter.InitString(norm.NFD,+s)
++++bound+=+append(bound,+0)
++++for+!iter.Done()+{
++++++++iter.Next()
++++++++bound+=+append(bound,+iter.Pos())
++++}
++++bound+=+append(bound,+len(s))
++++out+:=+make([]byte,+0,+len(s))
++++for+i+:=+len(bound)+-+2;+i+>=+0;+i--+{
++++++++out+=+append(out,+s[bound[i]:bound[i%2B1]]...)
++++}
++++return+string(out)
}|code-block|syntax|javascript|4017311|如果unicode/norm原语允许在不分配的情况下遍历字符串的边界，那么效率会更高一些。另请参见https://code.google.com/p/go/issues/detail?id=9055。|offset|length|4017312|entityMap|0|LINK|mutability|MUTABLE|url|https://code.google.com/p/go/issues/detail?id=9055^0|0|0|1D|1E|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

This code preserves sequences of combining characters intact, and
should work with invalid UTF-8 input too.

<pre><code>package stringutil
import "code.google.com/p/go.text/unicode/norm"

func Reverse(s string) string {
 bound := make([]int, 0, len(s) + 1)

 var iter norm.Iter
 iter.InitString(norm.NFD, s)
 bound = append(bound, 0)
 for !iter.Done() {
 iter.Next()
 bound = append(bound, iter.Pos())
 }
 bound = append(bound, len(s))
 out := make([]byte, 0, len(s))
 for i := len(bound) - 2; i &gt;= 0; i-- {
 out = append(out, s[bound[i]:bound[i+1]]...)
 }
 return string(out)
}
</code></pre>

It could be a little more efficient if the unicode/norm primitives
allowed iterating through the boundaries of a string without
allocating. See also <a href="https://code.google.com/p/go/issues/detail?id=9055" rel="nofollow">https://code.google.com/p/go/issues/detail?id=9055</a> .

blocks|key|4017343|text|“来自Go+example+projects:+golang/example/stringutil/reverse.go”，安德鲁·格朗著|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4017344|/*
Copyright+2014+Google+Inc.
Licensed+under+the+Apache+License,+Version+2.0+(the+"License");
you+may+not+use+this+file+except+in+compliance+with+the+License.
You+may+obtain+a+copy+of+the+License+at
+++++http://www.apache.org/licenses/LICENSE-2.0
Unless+required+by+applicable+law+or+agreed+to+in+writing,+software
distributed+under+the+License+is+distributed+on+an+"AS+IS"+BASIS,
WITHOUT+WARRANTIES+OR+CONDITIONS+OF+ANY+KIND,+either+express+or+implied.
See+the+License+for+the+specific+language+governing+permissions+and
limitations+under+the+License.
*/

//+Reverse+returns+its+argument+string+reversed+rune-wise+left+to+right.
func+Reverse(s+string)+string+{
++++r+:=+[]rune(s)
++++for+i,+j+:=+0,+len(r)-1;+i+<+len(r)/2;+i,+j+=+i%2B1,+j-1+{
++++++++r[i],+r[j]+=+r[j],+r[i]
++++}
++++return+string(r)
}|code-block|syntax|javascript|4017345|Go+Playground+for+reverse+a+string|4017346|在颠倒字符串“brówn”之后，正确的结果应该是“nwórb”，而不是"nẁorb“。|4017347|注意字母o上方的坟墓。|4017348|4017349|为了保留Unicode组合字符，例如"+as⃝df̅“和相反的结果"f̅ds⃝a"，|4017350|请参考下面列出的其他代码：|4017351|http://rosettacode.org/wiki/Reverse_a_string#Go|4017352|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/golang/example/blob/master/stringutil/reverse.go|1|http://play.golang.org/p/Vq-TIHJCHE|2^0|3|1L|0|0|0|0|Y|1|0|0|0|0|0|0|0|1B|2|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]]|C|$]]|$1|D|3|E|5|F|7|1A|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1B|8|@]|9|@$A|1C|B|1D|1|1E]]|C|$]]|$1|K|3|L|5|6|7|1F|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|1G|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|1H|8|@]|9|@]|C|$]]|$1|P|3|Q|5|6|7|1I|8|@]|9|@]|C|$]]|$1|R|3|S|5|6|7|1J|8|@]|9|@]|C|$]]|$1|T|3|U|5|6|7|1K|8|@]|9|@$A|1L|B|1M|1|1N]]|C|$]]|$1|V|3|-4|5|6|7|1O|8|@]|9|@]|C|$]]]|W|$X|$5|Y|Z|10|C|$11|12]]|13|$5|Y|Z|10|C|$11|14]]|15|$5|Y|Z|10|C|$11|U]]]]

From <a href="https://github.com/golang/example/blob/master/stringutil/reverse.go" rel="noreferrer">Go example projects: golang/example/stringutil/reverse.go</a>, by Andrew Gerrand

<pre><code>/*
Copyright 2014 Google Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// Reverse returns its argument string reversed rune-wise left to right.
func Reverse(s string) string {
 r := []rune(s)
 for i, j := 0, len(r)-1; i &lt; len(r)/2; i, j = i+1, j-1 {
 r[i], r[j] = r[j], r[i]
 }
 return string(r)
}
</code></pre>

<a href="http://play.golang.org/p/Vq-TIHJCHE" rel="noreferrer">Go Playground for reverse a string</a>

After reversing string "bròwn", the correct result should be "nwòrb", not "nẁorb". 
Note the grave above the letter o.

<hr>

For preserving Unicode combining characters such as "as⃝df̅" with reverse result "f̅ds⃝a", 
please refer to another code listed below: 

<a href="http://rosettacode.org/wiki/Reverse_a_string#Go" rel="noreferrer">http://rosettacode.org/wiki/Reverse_a_string#Go</a>

blocks|key|5435525|text|package+reverseString

import+"strings"

//+ReverseString+-+output+the+reverse+string+of+a+given+string+s
func+ReverseString(s+string)+string+{

++++strLen+:=+len(s)

++++//+The+reverse+of+a+empty+string+is+a+empty+string
++++if+strLen+==+0+{
++++++++return+s
++++}

++++//+Same+above
++++if+strLen+==+1+{
++++++++return+s
++++}

++++//+Convert+s+into+unicode+points
++++r+:=+[]rune(s)

++++//+Last+index
++++rLen+:=+len(r)+-+1

++++//+String+new+home
++++rev+:=+[]string{}

++++for+i+:=+rLen;+i+>=+0;+i--+{
++++++++rev+=+append(rev,+string(r[i]))
++++}

++++return+strings.Join(rev,+"")
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5435526|测试|unstyled|5435527|package+reverseString

import+(
++++"fmt"
++++"strings"
++++"testing"
)

func+TestReverseString(t+*testing.T)+{

++++s+:=+"GO+je+úžasné!"
++++r+:=+ReverseString(s)

++++fmt.Printf("Input:+%25s\nOutput:+%25s",+s,+r)

++++revR+:=+ReverseString(r)

++++if+strings.Compare(s,+revR)+!=+0+{
++++++++t.Errorf("Expecting:+%25s\n.+Got:+%25s\n",+s,+revR)
++++}
}|5435528|输出|5435529|Input:+GO+je+úžasné!
Output:+!énsažú+ej+OG
PASS
ok++++++github.com/alesr/reverse-string+0.098s|5435530|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|M|3|-4|5|F|7|T|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>package reverseString

import "strings"

// ReverseString - output the reverse string of a given string s
func ReverseString(s string) string {

 strLen := len(s)

 // The reverse of a empty string is a empty string
 if strLen == 0 {
 return s
 }

 // Same above
 if strLen == 1 {
 return s
 }

 // Convert s into unicode points
 r := []rune(s)

 // Last index
 rLen := len(r) - 1

 // String new home
 rev := []string{}

 for i := rLen; i &gt;= 0; i-- {
 rev = append(rev, string(r[i]))
 }

 return strings.Join(rev, "")
}
</code></pre>

Test

<pre><code>package reverseString

import (
 "fmt"
 "strings"
 "testing"
)

func TestReverseString(t *testing.T) {

 s := "GO je úžasné!"
 r := ReverseString(s)

 fmt.Printf("Input: %s\nOutput: %s", s, r)

 revR := ReverseString(r)

 if strings.Compare(s, revR) != 0 {
 t.Errorf("Expecting: %s\n. Got: %s\n", s, revR)
 }
}
</code></pre>

Output

<pre><code>Input: GO je úžasné!
Output: !énsažú ej OG
PASS
ok github.com/alesr/reverse-string 0.098s
</code></pre>

blocks|key|5435556|text|这肯定不是最高效的内存解决方案，但对于一个“简单的”UTF-8安全解决方案来说，下面的方法将完成工作，而不会中断符文。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5435557|在我看来，它是页面上最易读和最容易理解的。|5435558|func+reverseStr(str+string)+(out+string)+{
++++for+_,+s+:=+range+str+{
++++++++out+=+string(s)+%2B+out
++++}

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

It's assuredly not the most memory efficient solution, but for a "simple" UTF-8 safe solution the following will get the job done and not break runes.

It's in my opinion the most readable and understandable on the page.

<pre><code>func reverseStr(str string) (out string) {
 for _, s := range str {
 out = string(s) + out
 }

 return
}
</code></pre>

blocks|key|1906675|text|这里是完全不同的，我会说更多的功能方法，不在其他答案中列出：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1906676|func+reverse(s+string)+(ret+string)+{
++++for+_,+v+:=+range+s+{
++++++++defer+func(r+rune)+{+ret+%2B=+string(r)+}(v)
++++}
++++return
}|code-block|syntax|javascript|1906677|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|$]]

Here is quite different, I would say more functional approach, not listed among other answers:

<pre><code>func reverse(s string) (ret string) {
 for _, v := range s {
 defer func(r rune) { ret += string(r) }(v)
 }
 return
}
</code></pre>

blocks|key|5435579|text|试试下面的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5435580|package+main

import+"fmt"

func+reverse(s+string)+string+{
++++chars+:=+[]rune(s)
++++for+i,+j+:=+0,+len(chars)-1;+i+<+j;+i,+j+=+i%2B1,+j-1+{
++++++++chars[i],+chars[j]+=+chars[j],+chars[i]
++++}
++++return+string(chars)
}

func+main()+{
++++fmt.Printf("%25v\n",+reverse("abcdefg"))
}|code-block|syntax|javascript|5435581|有关更多信息，请查看http://golangcookbook.com/chapters/strings/reverse/|offset|length|5435582|和http://www.dotnetperls.com/reverse-string-go|5435583|entityMap|0|LINK|mutability|MUTABLE|url|http://golangcookbook.com/chapters/strings/reverse/|1|http://www.dotnetperls.com/reverse-string-go^0|0|0|A|1F|0|0|1|18|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@$I|Z|J|10|1|11]]|A|$]]|$1|K|3|L|5|6|7|12|8|@]|9|@$I|13|J|14|1|15]]|A|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]|U|$5|P|Q|R|A|$S|V]]]]

try below code:

<pre><code>package main

import "fmt"

func reverse(s string) string {
 chars := []rune(s)
 for i, j := 0, len(chars)-1; i &lt; j; i, j = i+1, j-1 {
 chars[i], chars[j] = chars[j], chars[i]
 }
 return string(chars)
}

func main() {
 fmt.Printf("%v\n", reverse("abcdefg"))
}
</code></pre>

for more info check <a href="http://golangcookbook.com/chapters/strings/reverse/" rel="nofollow">http://golangcookbook.com/chapters/strings/reverse/</a> 
and <a href="http://www.dotnetperls.com/reverse-string-go" rel="nofollow">http://www.dotnetperls.com/reverse-string-go</a>

blocks|key|1574886|text|以下两种方法的运行速度比最快的solution+that+preserve+combining+characters更快，但这并不是说我的基准测试设置中缺少了什么。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1574887|//input+string+s
bs+:=+[]byte(s)
var+rs+string
for+len(bs)+>+0+{
++++r,+size+:=+utf8.DecodeLastRune(bs)
++++rs+%2B=+fmt.Sprintf("%25c",+r)
++++bs+=+bs[:len(bs)-size]
}+//+rs+has+reversed+string|code-block|syntax|javascript|1574888|受this启发的第二种方法|1574889|//input+string+s
bs+:=+[]byte(s)
cs+:=+make([]byte,+len(bs))
b1+:=+0
for+len(bs)+>+0+{
++++r,+size+:=+utf8.DecodeLastRune(bs)
++++d+:=+make([]byte,+size)
++++_+=+utf8.EncodeRune(d,+r)
++++b1+%2B=+copy(cs[b1:],+d)
++++bs+=+bs[:len(bs)+-+size]
}+//+cs+has+reversed+bytes|1574890|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/34521190/1093710|1|https://stackoverflow.com/a/23857998/1093710^0|F|17|0|0|0|1|4|1|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|K|3|L|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

The following two methods run faster than the fastest <a href="https://stackoverflow.com/a/34521190/1093710">solution that preserve combining characters</a>, though that's not to say I'm missing something in my benchmark setup. 

<pre><code>//input string s
bs := []byte(s)
var rs string
for len(bs) &gt; 0 {
 r, size := utf8.DecodeLastRune(bs)
 rs += fmt.Sprintf("%c", r)
 bs = bs[:len(bs)-size]
} // rs has reversed string
</code></pre>

Second method inspired by <a href="https://stackoverflow.com/a/23857998/1093710">this</a>

<pre><code>//input string s
bs := []byte(s)
cs := make([]byte, len(bs))
b1 := 0
for len(bs) &gt; 0 {
 r, size := utf8.DecodeLastRune(bs)
 d := make([]byte, size)
 _ = utf8.EncodeRune(d, r)
 b1 += copy(cs[b1:], d)
 bs = bs[:len(bs) - size]
} // cs has reversed bytes
</code></pre>

blocks|key|1906760|text|我编写了以下支持UTF8编码和组合字符的Reverse函数：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1906761|//+Reverse+reverses+the+input+while+respecting+UTF8+encoding+and+combined+characters
func+Reverse(text+string)+string+{
++++textRunes+:=+[]rune(text)
++++textRunesLength+:=+len(textRunes)
++++if+textRunesLength+<=+1+{
++++++++return+text
++++}

++++i,+j+:=+0,+0
++++for+i+<+textRunesLength+&&+j+<+textRunesLength+{
++++++++j+=+i+%2B+1
++++++++for+j+<+textRunesLength+&&+isMark(textRunes[j])+{
++++++++++++j%2B%2B
++++++++}

++++++++if+isMark(textRunes[j-1])+{
++++++++++++//+Reverses+Combined+Characters
++++++++++++reverse(textRunes[i:j],+j-i)
++++++++}+

++++++++i+=+j
++++}

++++//+Reverses+the+entire+array
++++reverse(textRunes,+textRunesLength)

++++return+string(textRunes)
}

func+reverse(runes+[]rune,+length+int)+{
++++for+i,+j+:=+0,+length-1;+i+<+length/2;+i,+j+=+i%2B1,+j-1+{
++++++++runes[i],+runes[j]+=+runes[j],+runes[i]
++++}
}

//+isMark+determines+whether+the+rune+is+a+marker
func+isMark(r+rune)+bool+{
++++return+unicode.Is(unicode.Mn,+r)+%7C%7C+unicode.Is(unicode.Me,+r)+%7C%7C+unicode.Is(unicode.Mc,+r)
}|code-block|syntax|javascript|1906762|我尽了最大的努力使它变得尽可能高效和易读。这个想法很简单，遍历符文寻找组合字符，然后就地反转组合字符的符文。一旦我们覆盖了它们，将整个字符串的符文也颠倒过来。|1906763|假设我们想要颠倒这个字符串bròwn。ò由两个rune表示，一个用于o，另一个用于表示“\u0301a”的unicode+runes。|1906764|为简单起见，让我们像这样的bro'wn来表示字符串。我们做的第一件事是查找组合字符并反转它们。现在我们有了字符串br'own。最后，我们反转整个字符串，最后得到nwo'rb。这将作为nwòrb返回给我们|1906765|如果你想使用它，你可以在这里找到https://github.com/shomali11/util。|1906766|下面是一些测试用例，展示了几种不同的场景：|1906767|func+TestReverse(t+*testing.T)+{
++++assert.Equal(t,+Reverse(""),+"")
++++assert.Equal(t,+Reverse("X"),+"X")
++++assert.Equal(t,+Reverse("b\u0301"),+"b\u0301")
++++assert.Equal(t,+Reverse("⚽"),+"⚽")
++++assert.Equal(t,+Reverse("Les+Mise\u0301rables"),+"selbare\u0301siM+seL")
++++assert.Equal(t,+Reverse("ab\u0301cde"),+"edcb\u0301a")
++++assert.Equal(t,+Reverse("This+`\xc5`+is+an+invalid+UTF8+character"),+"retcarahc+8FTU+dilavni+na+si+`�`+sihT")
++++assert.Equal(t,+Reverse("The+quick+bròwn+狐+jumped+over+the+lazy+犬"),+"犬+yzal+eht+revo+depmuj+狐+nwòrb+kciuq+ehT")
}|1906768|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/shomali11/util^0|K|7|0|0|0|D|5|J|1|Y|1|18|7|0|D|6|1K|6|28|6|2J|5|0|G|X|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1R|8|@]|D|@$9|1S|A|1T|1|1U]]|E|$]]|$1|S|3|T|5|6|7|1V|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|1W|8|@]|D|@]|E|$I|J]]|$1|W|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]]]

I wrote the following <code>Reverse</code> function which respects UTF8 encoding and combined characters:

<pre><code>// Reverse reverses the input while respecting UTF8 encoding and combined characters
func Reverse(text string) string {
 textRunes := []rune(text)
 textRunesLength := len(textRunes)
 if textRunesLength &lt;= 1 {
 return text
 }

 i, j := 0, 0
 for i &lt; textRunesLength &amp;&amp; j &lt; textRunesLength {
 j = i + 1
 for j &lt; textRunesLength &amp;&amp; isMark(textRunes[j]) {
 j++
 }

 if isMark(textRunes[j-1]) {
 // Reverses Combined Characters
 reverse(textRunes[i:j], j-i)
 } 

 i = j
 }

 // Reverses the entire array
 reverse(textRunes, textRunesLength)

 return string(textRunes)
}

func reverse(runes []rune, length int) {
 for i, j := 0, length-1; i &lt; length/2; i, j = i+1, j-1 {
 runes[i], runes[j] = runes[j], runes[i]
 }
}

// isMark determines whether the rune is a marker
func isMark(r rune) bool {
 return unicode.Is(unicode.Mn, r) || unicode.Is(unicode.Me, r) || unicode.Is(unicode.Mc, r)
}
</code></pre>

I did my best to make it as efficient and readable as possible. The idea is simple, traverse through the runes looking for combined characters then reverse the combined characters' runes in-place. Once we have covered them all, reverse the runes of the entire string also in-place.

Say we would like to reverse this string <code>bròwn</code>. The <code>ò</code> is represented by two runes, one for the <code>o</code> and one for this unicode <code>\u0301a</code> that represents the "grave".

For simplicity, let's represent the string like this <code>bro'wn</code>. The first thing we do is look for combined characters and reverse them. So now we have the string <code>br'own</code>. Finally, we reverse the entire string and end up with <code>nwo'rb</code>. This is returned to us as <code>nwòrb</code>

You can find it here <a href="https://github.com/shomali11/util" rel="noreferrer">https://github.com/shomali11/util</a> if you would like to use it.

Here are some test cases to show a couple of different scenarios:

<pre><code>func TestReverse(t *testing.T) {
 assert.Equal(t, Reverse(""), "")
 assert.Equal(t, Reverse("X"), "X")
 assert.Equal(t, Reverse("b\u0301"), "b\u0301")
 assert.Equal(t, Reverse("⚽"), "⚽")
 assert.Equal(t, Reverse("Les Mise\u0301rables"), "selbare\u0301siM seL")
 assert.Equal(t, Reverse("ab\u0301cde"), "edcb\u0301a")
 assert.Equal(t, Reverse("This `\xc5` is an invalid UTF8 character"), "retcarahc 8FTU dilavni na si `�` sihT")
 assert.Equal(t, Reverse("The quick bròwn 狐 jumped over the lazy 犬"), "犬 yzal eht revo depmuj 狐 nwòrb kciuq ehT")
}
</code></pre>

blocks|key|1906789|text|您还可以导入现有的实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1906790|import+"4d63.com/strrev"|code-block|syntax|javascript|1906791|然后：|1906792|strrev.Reverse("abåd")+//+returns+"dåba"|1906793|或者反转包含unicode组合字符的字符串：|1906794|strrev.ReverseCombining("abc\u0301\u031dd")+//+returns+"d\u0301\u031dcba"|1906795|这些实现在反转时支持unicode多字节和组合字符的正确排序。|1906796|注意:许多编程语言中的内置字符串反转函数不保留组合，并且识别组合字符需要更多的执行时间。|1906797|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

You could also import an existing implementation:

<pre><code>import "4d63.com/strrev"
</code></pre>

Then:

<pre><code>strrev.Reverse("abåd") // returns "dåba"
</code></pre>

Or to reverse a string including unicode combining characters:

<pre><code>strrev.ReverseCombining("abc\u0301\u031dd") // returns "d\u0301\u031dcba"
</code></pre>

These implementations supports correct ordering of unicode multibyte and combing characters when reversed.

Note: Built-in string reverse functions in many programming languages do not preserve combining, and identifying combining characters requires significantly more execution time.

blocks|key|5435732|text|对于简单的字符串，可以使用这样的结构：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5435733|func+Reverse(str+string)+string+{
++++if+str+!=+""+{
++++++++return+Reverse(str[1:])+%2B+str[:1]
++++}
++++return+""+++
}|code-block|syntax|javascript|5435734|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|$]]

For simple strings it possible to use such construction:

<pre><code>func Reverse(str string) string {
 if str != "" {
 return Reverse(str[1:]) + str[:1]
 }
 return "" 
}
</code></pre>

blocks|key|1574944|text|++++func+reverseString(someString+string)+string+{
++++++++runeString+:=+[]rune(someString)
++++++++var+reverseString+string
++++++++for+i+:=+len(runeString)-1;+i+>=+0;+i+--+{
++++++++++++reverseString+%2B=+string(runeString[i])
++++++++}
++++++++return+reverseString
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1574945|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> func reverseString(someString string) string {
 runeString := []rune(someString)
 var reverseString string
 for i := len(runeString)-1; i &gt;= 0; i -- {
 reverseString += string(runeString[i])
 }
 return reverseString
 }
</code></pre>

blocks|key|5435775|text|//Reverse+reverses+string+using+strings.Builder.+It's+about+3+times+faster
//than+the+one+with+using+a+string+concatenation
func+Reverse(in+string)+string+{
++++var+sb+strings.Builder
++++runes+:=+[]rune(in)
++++for+i+:=+len(runes)+-+1;+0+<=+i;+i--+{
++++++++sb.WriteRune(runes[i])
++++}
++++return+sb.String()
}


//Reverse+reverses+string+using+string
func+Reverse(in+string)+(out+string)+{
++++for+_,+r+:=+range+in+{
++++++++out+=+string(r)+%2B+out
++++}
++++return
}

BenchmarkReverseStringConcatenation-8+++1000000+1571+ns/op++176+B/op++++29+allocs/op
BenchmarkReverseStringsBuilder-8++++++++3000000+499+ns/op+++56+B/op+6+allocs/op|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5435776|使用strings.Builder大约比使用字符串连接快3倍|unstyled|5435777|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>//Reverse reverses string using strings.Builder. It's about 3 times faster
//than the one with using a string concatenation
func Reverse(in string) string {
 var sb strings.Builder
 runes := []rune(in)
 for i := len(runes) - 1; 0 &lt;= i; i-- {
 sb.WriteRune(runes[i])
 }
 return sb.String()
}


//Reverse reverses string using string
func Reverse(in string) (out string) {
 for _, r := range in {
 out = string(r) + out
 }
 return
}

BenchmarkReverseStringConcatenation-8 1000000 1571 ns/op 176 B/op 29 allocs/op
BenchmarkReverseStringsBuilder-8 3000000 499 ns/op 56 B/op 6 allocs/op
</code></pre>

Using strings.Builder is about 3 times faster than using string concatenation

blocks|key|4017623|text|使用rune实现简单的笔划|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4017624|func+ReverseString(s+string)+string+{
++++runes+:=+[]rune(s)
++++size+:=+len(runes)
++++for+i+:=+0;+i+<+size/2;+i%2B%2B+{
++++++++runes[size-i-1],+runes[i]+=+runes[i],++runes[size-i-1]
++++}
++++return+string(runes)
}

func+main()+{
++++fmt.Println(ReverseString("Abcdefg+汉语+The+God"))
}|code-block|syntax|javascript|4017625|:+doG+ehT+语汉+gfedcbA|4017626|entityMap^0|2|4|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|H|7|S|8|@]|D|@]|E|$I|J]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

A simple stroke with <code>rune</code>:
<pre class="lang-golang prettyprint-override"><code>func ReverseString(s string) string {
 runes := []rune(s)
 size := len(runes)
 for i := 0; i &lt; size/2; i++ {
 runes[size-i-1], runes[i] = runes[i], runes[size-i-1]
 }
 return string(runes)
}

func main() {
 fmt.Println(ReverseString(&quot;Abcdefg 汉语 The God&quot;))
}
</code></pre>
<pre><code>: doG ehT 语汉 gfedcbA
</code></pre>

blocks|key|1906974|text|func+Reverse(s+string)+string+{
++++r+:=+[]rune(s)
++++var+output+strings.Builder
++++for+i+:=+len(r)+-+1;+i+>=+0;+i--+{
++++++++output.WriteString(string(r[i]))
++++}

++++return+output.String()
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1906975|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>func Reverse(s string) string {
 r := []rune(s)
 var output strings.Builder
 for i := len(r) - 1; i &gt;= 0; i-- {
 output.WriteString(string(r[i]))
 }

 return output.String()
}
</code></pre>

blocks|key|1571128|text|func+reverseStr(b+string)+{
for+_,+v+:=+range+[]rune(b)+{
++++defer+fmt.Printf("%25c",+v)

}
+}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1571129|延迟对此很有用，因为它是后进先出|unstyled|1571130|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>func reverseStr(b string) {
for _, v := range []rune(b) {
 defer fmt.Printf(&quot;%c&quot;, v)

}
 }
</code></pre>
Defer is useful for this as it is LIFO - Last in First Out

blocks|key|5435840|text|func+ReverseString(str+string)+string+{
++output+:=""
++for+_,+char+:=+range+str+{
++++output+=+string(char)+%2B+output
++}
++return+output
}

//+"Luizpa"+->+"apziuL"
//+"123日本語"+->+"語本日321"
//+"⚽"+->+"⚽"
//+"´a´b´c´"+->+"´c´b´a´"|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5435841|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre class="lang-golang prettyprint-override"><code>func ReverseString(str string) string {
 output :=&quot;&quot;
 for _, char := range str {
 output = string(char) + output
 }
 return output
}

// &quot;Luizpa&quot; -&gt; &quot;apziuL&quot;
// &quot;123日本語&quot; -&gt; &quot;語本日321&quot;
// &quot;⚽&quot; -&gt; &quot;⚽&quot;
// &quot;´a´b´c´&quot; -&gt; &quot;´c´b´a´&quot;
</code></pre>

blocks|key|5435849|text|简单，甜美，富有表现力|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5435850|func+reverseStr(str+string)+string+{
++strSlice+:=+[]rune(str)++//converting+to+slice+of+runes
++length+:=+len(strSlice)

++for+i+:=+0;+i+<+(length+/+2);+i%2B%2B+{
++++++strSlice[i],+strSlice[length-i-1]+=+strSlice[length-i-1],+strSlice[i]
++}
++return+string(strSlice)++//converting+back+to+string
}|code-block|syntax|javascript|5435851|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|$]]

Simple, Sweet and Performant
<pre><code>func reverseStr(str string) string {
 strSlice := []rune(str) //converting to slice of runes
 length := len(strSlice)

 for i := 0; i &lt; (length / 2); i++ {
 strSlice[i], strSlice[length-i-1] = strSlice[length-i-1], strSlice[i]
 }
 return string(strSlice) //converting back to string
}
</code></pre>

blocks|key|1907018|text|逐字颠倒字符串也是一个类似的过程。首先，我们将字符串转换为字符串数组，其中每个条目都是一个单词。接下来，我们将正常的反向循环应用于该数组。最后，我们将结果重新组合到一个可以返回给调用者的字符串中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1907019|package+main

import+(
++++"fmt"
++++"strings"
)

func+reverse_words(s+string)+string+{
++++words+:=+strings.Fields(s)
++++for+i,+j+:=+0,+len(words)-1;+i+<+j;+i,+j+=+i%2B1,+j-1+{
++++++++words[i],+words[j]+=+words[j],+words[i]
++++}
++++return+strings.Join(words,+"+")
}

func+main()+{
++++fmt.Println(reverse_words("one+two+three"))
}|code-block|syntax|javascript|1907020|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|$]]

Reversing a string by word is a similar process. First, we convert the string into an array of strings where each entry is a word. Next, we apply the normal reverse loop to that array. Finally, we smush the results back together into a string that we can return to the caller.
<pre><code>package main

import (
 &quot;fmt&quot;
 &quot;strings&quot;
)

func reverse_words(s string) string {
 words := strings.Fields(s)
 for i, j := 0, len(words)-1; i &lt; j; i, j = i+1, j-1 {
 words[i], words[j] = words[j], words[i]
 }
 return strings.Join(words, &quot; &quot;)
}

func main() {
 fmt.Println(reverse_words(&quot;one two three&quot;))
}
</code></pre>

blocks|key|1575014|text|在golang中，字符串是不可变的对象，与C不同，在golang中不能进行反转。使用C，你可以这样做，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1575015|void+reverseString(char+*str)+{
++int+length+=+strlen(str)
++for(int+i+=+0,+j+=+length-1;+i+<+length/2;+i%2B%2B,+j--)
++{
++++char+tmp+=+str[i];
++++str[i]+=+str[j];
++++str[j]+=+tmp;
++}
}|code-block|syntax|javascript|1575016|但是对于golang，在后面的一步中，首先使用byte将输入转换为字节，一旦字节数组被反转，就将其反转，在返回之前转换回string。仅适用于非unicode类型的字符串。|1575017|package+main

import+"fmt"

func+main()+{
++++s+:=+"test123+4"
++++fmt.Println(reverseString(s))
}

func+reverseString(s+string)+string+{
++++a+:=+[]byte(s)
++++for+i,+j+:=+0,+len(s)-1;+i+<+j;+i%2B%2B+{
++++++++a[i],+a[j]+=+a[j],+a[i]
++++++++j--
++++}
++++return+string(a)
}|1575018|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Strings are immutable object in golang, unlike C inplace reverse is not possible with golang.
With C , you can do something like,
<pre><code>void reverseString(char *str) {
 int length = strlen(str)
 for(int i = 0, j = length-1; i &lt; length/2; i++, j--)
 {
 char tmp = str[i];
 str[i] = str[j];
 str[j] = tmp;
 }
}
</code></pre>
But with golang, following one, uses byte to convert the input into bytes first and then reverses the byte array once it is reversed, convert back to string before returning. works only with non unicode type string.
<pre><code>package main

import &quot;fmt&quot;

func main() {
 s := &quot;test123 4&quot;
 fmt.Println(reverseString(s))
}

func reverseString(s string) string {
 a := []byte(s)
 for i, j := 0, len(s)-1; i &lt; j; i++ {
 a[i], a[j] = a[j], a[i]
 j--
 }
 return string(a)
}
</code></pre>

blocks|key|5435935|text|另一个技巧是使用内置的语言特性，例如defer|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5435936|package+main

import+"fmt"

func+main()+{
++++var+name+string
++++fmt.Scanln(&name)

++++for+_,+char+:=+range+[]rune(name)+{
++++++++defer+fmt.Printf("%25c",+char)+//+<--+LIFO+does+it+all+for+you
++++}
}|code-block|syntax|javascript|5435937|entityMap^0|I|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Another hack is to use built-in language features, for example, <code>defer</code>:
<pre class="lang-golang prettyprint-override"><code>package main

import &quot;fmt&quot;

func main() {
 var name string
 fmt.Scanln(&amp;name)

 for _, char := range []rune(name) {
 defer fmt.Printf(&quot;%c&quot;, char) // &lt;-- LIFO does it all for you
 }
}
</code></pre>

How can we reverse a simple string in Go?

How to reverse a string in Go?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我们如何在Go中反转一个简单的字符串？

问如何在Go中反转字符串？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Go中反转字符串？EN