How to make the first character in a string lowercase?

[Nikolai]

Hi!

What is the easiest way to make a string "LikeThis" --> "likeThis"?

[Nikolai]

I came up with this thingie, but I don't really like it:

http://play.golang.org/p/ic5dxOKdcU

[Dan Kortschak]

If it's all ASCII, this works http://play.golang.org/p/4GaLA5vbqM but you might want to use unicode.ToLower in the loop

On 24/11/2012, at 9:21 PM, "Nikolai" <niko...@gmail.com> wrote:

Hi!

What is the easiest way to make a string "LikeThis" --> "likeThis"?

--
 
 

[Dan Kortschak]

Sorry mis-read second string.

--
 
 

[Dan Kortschak]

http://play.golang.org/p/tu9Cum4EmP

On 24/11/2012, at 9:41 PM, "Dan Kortschak" <dan.ko...@adelaide.edu.au> wrote:

> Sorry mis-read second string.

[Nikolai]

This one looks good! Thanks!

[DisposaBoy]

You may also consider getting the first rune and then concatting it with the rest of the string which may slightly more efficient

http://play.golang.org/p/D8cYDgfZr8

 

[steve wang]

import "unicode"

func UpcaseInitial(str string) string {

    for i, v := range str {

        return string(unicode.ToUpper(v)) + str[i+1:]

    }

    return ""

[steve wang]

import "unicode"

func LowerInitial(str string) string {

    for i, v := range str {

        return string(unicode.ToLower(v)) + str[i+1:]

[steve wang]

Sorry, this doesn't work for multi-character string.

DisposaBoy's does.

[Dan Kortschak]

Why is that?

[ujjwalt]

Because unicode points(runes) can consist of multiple bytes. steve's implementation exits on encountering the first rune without any consideration for its width while DisposaBoy's implementation takes that into account  I am not sure since am new to this language and not familiar with its intricacies but this my thought.

[DisposaBoy]

Was this meant to be a reply to me, or steve wang? If to me, I'm not sure what you're asking

 

[ujjwalt]

No it was aimed at kortschak

[Dan Kortschak]

Sorry, thought that was clear: Why is appending the remainder of the string to the modified first rune more efficient that converting to a []rune and then converting back the modified slice.

ujjwalt's explanation that, in your example, only the first rune needed to be decoded and the remainder can then be appended without decoding makes sense.

--
 
 

[DisposaBoy]

On Saturday, November 24, 2012 9:29:34 PM UTC, kortschak wrote:

Sorry, thought that was clear: Why is appending the remainder of the string to the modified first rune more efficient that converting to a []rune and then converting back the modified slice.

ujjwalt's explanation that, in your example, only the first rune needed to be decoded and the remainder can then be appended without decoding makes sense.

Without checking, that'd be my assumption as well

I did some benchmarks http://play.golang.org/p/xrF3JhxnOa

[ 9 play | done: 12.037936s ]

lF likeThis

lA likeThis

benchLfStrA  5000000       722 ns/op

benchLaStrA  2000000       906 ns/op

benchLfStrB  2000000       828 ns/op

benchLaStrB   500000      4812 ns/op

[narena...@gmail.com]

On Saturday, November 24, 2012 at 4:21:23 PM UTC+5:30, Nikolai wrote:

Hi!

What is the easiest way to make a string "LikeThis" --> "likeThis"?

Here is my answer

    bytestr := []byte(str)
    for index, character := range bytestr {
        char := string(character)
        if char == strings.ToUpper(char) {
            // Is lowercase
            bytestr[index] = []byte(strings.ToLower(char))[0]
        } else {
            bytestr[index] = []byte(strings.ToUpper(char))[0]
        }
    }

Small hack of converting byte to string. Applying method re-converting to byte array. But we know it consists on ly one element. So index 0 will return you the modified byte.

Hope it is useful. Ugly but does the job for me.

[Tamás Gulácsi]

But this works only for ASCII input!

[Viktor Kojouharov]

https://play.golang.org/p/miLAFSDjrS

For unicode

[John Souvestre]

What if the first character is a combined code point?

 

John

    John Souvestre - New Orleans LA

--
You received this message because you are subscribed to the Google Groups "golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[Viktor Kojouharov]

Did you test it with combined code points?

[John Souvestre]

Yes, I initially started the string with “A\u0312a”.  The combining code point appears over the second “a” rather than the first.  Hence my question.

 

But after thinking about it and doing some additional testing, this appears to be a problem with my setup (Chrome on Windows 7).  For example, when I use “A\u0313a” instead, it works as expected.

 

I tried about a dozen different combining points, and I found the same problem for 2 others (\u0321 and \u0322), but all the rest are OK.

 

Very strange.  J

[dhana...@gmail.com]

https://play.golang.org/p/vFW8NxzL_hv

this will work fine

[Nikolai]

dude, you should test your code before posting ;)

[messju mohr]

I don't know if that is "the easiest", but I would do something like this:
https://play.golang.org/p/DOhP5kc8rO4

[dhananjay Verma]

thank you

--
You received this message because you are subscribed to a topic in the Google Groups "golang-nuts" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/golang-nuts/WfpmVDQFecU/unsubscribe.
To unsubscribe from this group and all its topics, send an email to golang-nuts...@googlegroups.com.

[peterGo]

Nikolai,

"What is the easiest way to make a string "LikeThis" --> "likeThis"?"

Te easiest is not always the best.

The code should be correct and reasonably efficient. For example,

func firstToLower(s string) string {
    if len(s) > 0 {
        r, size := utf8.DecodeRuneInString(s)
        if r != utf8.RuneError || size > 1 {
            lo := unicode.ToLower(r)
            if lo != r {
                s = string(lo) + s[size:]
            }
        }
    }
    return s
}

$ go test tolow_test.go -bench=.
BenchmarkToLow-4    30000000    41.3 ns/op     8 B/op    1 allocs/op
BenchmarkLow-4     200000000     6.96 ns/op    0 B/op    0 allocs/op
$

Playground: https://play.golang.org/p/z6CLIS7LaHo

Peter

[robert engels]

Huh? Isn’t your code calling the exact same method ?

--

You received this message because you are subscribed to the Google Groups "golang-nuts" group.

To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts...@googlegroups.com.

[jake...@gmail.com]

I believe he is demostrating an optimization for strings that are already in the correct form.

[robert engels]

yes, my bad, too cursory of a read of the code

[jyoti...@gmail.com]

I came up with this:

package main

import (

"fmt"

"strings"

)

func main() {

fmt.Println(MakeFirstLowerCase("LikeThis"))

}

func MakeFirstLowerCase(s string) string {

    

s=strings.ToLower(string(s[0]))+s[1:]

return s

[peterGo]

Your code only works when the first character is ASCII. For example, it does not work for the Greek alphabet, it does not work for an empty string.

https://play.golang.org/p/FQgnWfZqnrO

Peter

[naren.y...@tradebyte.com]

I think all other solutions works fine, but String Builder struct exists for the same reason.

package main

import (
    "fmt"
    "strings"    

)

func ToLowerCase(str string) string {

    var b strings.Builder    

    b.WriteString(strings.ToLower(string(str[0])))    
    b.WriteString(str[1:])
       
    return b.String()

}

func main() {
    var str string = "GoLang"
    fmt.Println(ToLowerCase(str))
}

Playground here: https://play.golang.org/p/aAyBGnM5p2x

[leo]

package main

import (
"fmt"

"unicode"

)

func main() {
fmt.Println(MakeFirstLowerCase("LikeThis"))

}

func MakeFirstLowerCase(s string) string {

    if len(s)==0 {
       return s
    }  
   
    r := []rune(s)    
    r[0] = unicode.ToLower(r[0])
    return string(r)  
}

--

You received this message because you are subscribed to the Google Groups "golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts...@googlegroups.com.

To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/59ede7f8-bfb9-44a0-9fa7-cef1d7288983o%40googlegroups.com.

[Prithu Adhikary]

May be this?

func main() {

    myString := "LikeThis"
    print(strings.ToLower(myString[:1]) + myString[1:])

}

[peterGo]

Prithu Adhikary,

As I pointed out earlier, your code only works when the first character is ASCII. For example, it does not work for the Greek alphabet, it does not work for an empty string.

https://groups.google.com/g/golang-nuts/c/WfpmVDQFecU/m/CQiT04mRAQAJ

Peter