How to index characters in a Golang string?

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])

You can also try typecasting it with string.

package main

import "fmt"

func main() {
    fmt.Println(string("Hello"[1]))
}

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.

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.

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

Rich's solution also works, of course.

Try this to get the charecters by their index

package main

import (
      "fmt"
      "strings"
)

func main() {
   str := strings.Split("HELLO","")
    fmt.Print(str[1])
}

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

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

The right answer depends on the context.

The simplest solution is to convert the string to a rune slice. A rune is a single UTF-8 character. Keep in mind that this conversion is costly for your CPU as well as memory-wise.

package main

import "fmt"

func main() {
    str := "Hello, 世界"
    runeSlice := []rune(str)
    fmt.Printf("'%c'\n", runeSlice[8])
}

This could be a good solution if you frequently need to get the ith character of the same string, over and over again. In this case you'd make the conversion once, and use the same rune slice multiple times.

Normal strings are arrays of bytes. When you convert it to a rune slice, in the worst case it will take up 4 times as much memory, because a single rune is 4 bytes. This conversion also takes time. So using this solution to create a general utility function that returns the ith character of a string would be absolutely terrible. The code below works but is not a good idea.

package main

import (
    "fmt"
)

func RuneAt(s string, i int) (rune, bool) {
    runeSlice := []rune(s)
    if i >= len(runeSlice) || i < 0 {
        return 0, false
    }
    return runeSlice[i], true
}

func main() {
    str := "Hello, 世界"
    char, ok := RuneAt(str, 8)
    fmt.Printf("char: '%c', ok: %#v\n", char, ok)
}

A better solution in this case would be to use a for loop and utf8.DecodeRuneInString to iterate over the existing string to find the ith unicode character. This would not waste memory and your CPU's time to create a 4 times larger copy of the entire string. You only iterate up to the index you specified and you don't allocate any memory.

package main

import (
    "fmt"
    "unicode/utf8"
)

// Get the ith rune in s
func RuneAt(s string, i int) (rune, bool) {
    if i < 0 {
        // the index cannot be negative
        return 0, false
    }

    leftStr := s
    var j int
    for {
        result, size := utf8.DecodeRuneInString(leftStr)
        if size == 0 {
            // we've reached the end of the string
            return 0, false
        }
        if j == i {
            // we've found the character!
            return result, true
        }
        leftStr = leftStr[size:]
        j++
    }
}

func main() {
    str := "Hello, 世界"
    char, ok := RuneAt(str, 8)
    fmt.Printf("char: '%c', ok: %#v\n", char, ok)
}

package main
import "main"

func main(){
    str := "hello"
    fmt.Printf("%d\n", []byte(str))

    for i := 0; i < len(str); i++ {
        fmt.Printf("%v %[1]T\n", str[i])
    }
}

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