158

How to get an "E" output rather than 69?

package main

import "fmt"

func main() {
    fmt.Print("HELLO"[1])
}

Does Golang have function to convert a char to byte and vice versa?

030
  • 10,842
  • 12
  • 78
  • 123
user977828
  • 7,259
  • 16
  • 66
  • 117

10 Answers10

226

Interpreted string literals are character sequences between double quotes "" using the (possibly multi-byte) UTF-8 encoding of individual characters. In UTF-8, ASCII characters are single-byte corresponding to the first 128 Unicode characters. Strings behave like slices of bytes. A rune is an integer value identifying a Unicode code point. Therefore,

package main

import "fmt"

func main() {
    fmt.Println(string("Hello"[1]))              // ASCII only
    fmt.Println(string([]rune("Hello, 世界")[1])) // UTF-8
    fmt.Println(string([]rune("Hello, 世界")[8])) // UTF-8
}

Output:

e
e
界

Read:

Go Programming Language Specification section on Conversions.

The Go Blog: Strings, bytes, runes and characters in Go

peterSO
  • 158,998
  • 31
  • 281
  • 276
28

How about this?

fmt.Printf("%c","HELLO"[1])

As Peter points out, to allow for more than just ASCII:

fmt.Printf("%c", []rune("HELLO")[1])
Rich Churcher
  • 7,361
  • 3
  • 37
  • 60
  • So is there no way to program this? For example if I convert 1000000 characters to runes I would need `1000000*4 = 4000000 bytes of memory`. utf-8 uses 1 byte for ascii characters. but the rune uses 4 bytes for each character. This means a huge memory savings. I'm guessing this requires in bit coding, but it's worth it for large text. – SeanTolstoyevski Jan 14 '22 at 13:01
17

Can be done via slicing too

package main

import "fmt"

func main() {
    fmt.Print("HELLO"[1:2])
}

NOTE: This solution only works for ASCII characters.

Samkit Jain
  • 1,560
  • 2
  • 16
  • 33
  • 3
    this works only with one-byte encodings, try `"हैलो"[:1]` it gives you � – vladkras Aug 25 '20 at 17:37
  • @vladkras You are correct. It only works with ASCII. For UTF-8, have a look at the approved answer. I will also edit the solution with this information. – Samkit Jain Aug 25 '20 at 18:23
16

You can also try typecasting it with string.

package main

import "fmt"

func main() {
    fmt.Println(string("Hello"[1]))
}
infiniteLearner
  • 3,555
  • 2
  • 23
  • 32
8

Go doesn't really have a character type as such. byte is often used for ASCII characters, and rune is used for Unicode characters, but they are both just aliases for integer types (uint8 and int32). So if you want to force them to be printed as characters instead of numbers, you need to use Printf("%c", x). The %c format specification works for any integer type.

andybalholm
  • 15,395
  • 3
  • 37
  • 41
6

The general solution to interpreting a char as a string is string("HELLO"[1]).

Rich's solution also works, of course.

Thomas Kappler
  • 3,795
  • 1
  • 22
  • 21
3

Try this to get the charecters by their index 

package main

import (
      "fmt"
      "strings"
)

func main() {
   str := strings.Split("HELLO","")
    fmt.Print(str[1])
}
Anshu
  • 1,277
  • 2
  • 13
  • 28
2

String characters are runes, so to print them, you have to turn them back into String.

fmt.Print(string("HELLO"[1]))

lemmer
  • 63
  • 1
  • 7
-2

Another Solution to isolate a character in a string 

package main
import "fmt"

   func main() {
        var word string = "ZbjTS"

       // P R I N T 
       fmt.Println(word)
       yo := string([]rune(word)[0])
       fmt.Println(yo)

       //I N D E X 
       x :=0
       for x < len(word){
           yo := string([]rune(word)[x])
           fmt.Println(yo)
           x+=1
       }

}

for string arrays also:

fmt.Println(string([]rune(sArray[0])[0]))

// = commented line

H...
  • 11
  • 2
  • 12
    *Really, really* bad code that will panic with Unicode input (`len("cafés")` > `len([]rune("cafés"))` and may reconvert the string on each iteration for, O(n²). Just do `for _, r := range word { fmt.Printf("%c", r) }`. If you really wanted to loop with an index `for x := 0; x < limit; x++`. *Please* learn the basics of a language before answering questions. – Dave C Apr 02 '15 at 20:15
-5

The solution will be :

 package main

 import "fmt"

func main() {
  str := "HELLO"
  string(str[0])//H
  string(str[1])//E
  string(str[2])//L
  string(str[3])//L
  string(str[4])//O
}
Logrhythm Engineering
  • 1
  • 1