strings - get characters before a digit

I have some strings such E2 9NZ, N29DZ, EW29DZ . I need to extract the chars before the first digit, given the above example : E, N, EW.
Am I supposed to use regex ? The strings package looks really nice but just doesn't seem to handle this case (extract everything before a specific type).

Edit:

To clarify the "question" I'm wondering what method is more idiomatic to go and perhaps likely to provide better performance.

For example,

package main

import (
	"fmt"
	"unicode"
)

func DigitPrefix(s string) string {
	for i, r := range s {
		if unicode.IsDigit(r) {
			return s[:i]
		}
	}
	return s
}

func main() {
	fmt.Println(DigitPrefix("E2 9NZ"))
	fmt.Println(DigitPrefix("N29DZ"))
	fmt.Println(DigitPrefix("EW29DZ"))
	fmt.Println(DigitPrefix("WXYZ"))
}

Output:

E
N
EW
WXYZ

If there is no digit, example "WXYZ", and you don't want anything returned, change return s to return "".

We don't need regex for this problem. You can easily walk through on a slice of rune and check the current character with unicode.IsDigit(), if it's a digit: return. If it isn't: continue the loop. If there are no numbers: return the argument

Code

package main

import (
"fmt"
"unicode"
)

func UntilDigit(r []rune) []rune {
   var i int
   for _, v := range r {
 	if unicode.IsDigit(v) {
		return r[0:i]
	}
	i++
   }
   return r
}

func main() {
fmt.Println(string(UntilDigit([]rune("E2 9NZ"))))
fmt.Println(string(UntilDigit([]rune("N29DZ"))))
fmt.Println(string(UntilDigit([]rune("EW29DZ"))))
}

Playground link

Not sure why almost everyone provided answers in everything but Go. Here is regex-based Go version:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    pattern, err := regexp.Compile("^[^\\d]*")
    if err != nil {
        panic(err)
    }

    part := pattern.Find([]byte("EW29DZ"))
    if part != nil {
        fmt.Printf("Found: %s\n", string(part))
    } else {
        fmt.Println("Not found")
    }
}

Running:

<!-- language: lang-none -->

% go run main.go 
Found: EW

Go playground

I think the best option is to use the index returned from strings.IndexAny which will return the first index of any character in a string.

func BeforeNumbers(str string) string { 
    value := strings.IndexAny(str,"0123456789")
    if value >= 0 && value <= len(str) {
        return str[:value]
    }

    return str
}

Will slice the string and return the subslice up to (but not including) the first character that's in the string "0123456789" which is any number.

Way later edit:

It would probably be better to use IndexFunc rather than IndexAny:

func BeforeNumbers(str string) string { 
    indexFunc := func(r rune) bool {
       return r >= '0' && r <= '9'
    }
    value := strings.IndexFunc(str,indexFunc)
    if value >= 0 && value <= len(str) {
        return str[:value]
    }

    return str
}

This is more or less equivalent to the loop version, and eliminates a search over a long string to check for a match every character from my previous answer. But I think it looks cleaner than the loop version, which is obviously a manner of taste.

The code below will continue grabbing characters until it reaches a digit.

int i = 0;
String string2test = "EW29DZ";
String stringOutput = "";

while (!Character.isDigit(string2test.charAt(i))) 
   {
   stringOutput = stringOutput + string2test.charAt(i);
   i++;
   }