huandu / xstrings Goto Github PK

Just like str_word_count in php.

Shouldn't the ToCamelCase handle spaces?

When you use hello world as the input to ToCamelCase you get Hello world. I was expecting to see HelloWorld instead. Looking at ToKebab and ToSnakeCase I did get the expected results: hello-world and hello_world .

One way I can get the behaviour I want is to do ToCamelCase(toSnakeCase("hello world")).

It's the way to support sentence case and hyphen connected string.

xstrings currently imports the testing package: https://godoc.org/github.com/huandu/xstrings?import-graph

This is kind of a bummer for consumers further downstream, because it causes the inclusion of all sorts of stuff like runtime/pprof, which will bloat the final binaries for any user of the library.

It looks like this is just because testing is imported in test.go... which look like is just providing helper functions for testing, so moving it into the testing namespaces by moving the file to e.g. util_test.go should fix this.

when v1.3.3 will be released?

Thanks very much.

See String#rpartition in ruby.

See String#swapcase in ruby.

See mb_strwidth in PHP.

A KebabCase functions. I think it should behave exactly like snakecase accept that _ becomes -.

It's also requested on Masterminds/sprig#113.

When using ToCamelCase on a string that is already camel case all but the first rune are lower cased.

i.e., ToCamelCase('OneTwoThree') ==> Onetwothree

I expected this to yield OneTwoThree.

Ruby:

"hello     world".squeeze(" ")
=> "hello world"

xstrings:

xstrings.Squeeze("hello    world", " ")
=> hello    world

Can there be a new version released that includes the kebab strings feature?

It's used here: https://github.com/Masterminds/sprig/blob/9f8fceff796fb9f4e992cd2bece016be0121ab74/functions.go#L132

And I'm seeing some cases where Go Modules users get install failures because v1.0.0 of this repo is being installed.

See String#count in ruby.

There is a RuneCountInString to do the same thing, but it's far too wordy.

See str.expandtabs in Python.

Write a table in README file to map functions in strings/xstrings and other language's std library.

Go uses a very different naming style. People who have experience in other language may have difficulties to find their favorite string function by name. For example, one can hardly realize that EqualFold is the stricmp in C or strcasecmp in PHP.

Is there any plan to add functions to operate on string slice, instead of one string?

Shuffle a string randomly.

See String#scrub in ruby.

See String#partition in ruby.

Just like standard Go slice, but work with rune rather than byte.

LastPartition/Partition always slices original string to three strings. With this change, both functions can avoid unnecessary memory allocation.

Hyphen case is similar to snake case. All alphabets are lower case and words are connected with hyphens.

See String#next in ruby.

Ruby document doesn't define the algorithm in String#next clearly. Here is my version (may not be 100% same as ruby).

Alphanumeric runes are following.

• a - z
• A - Z
• 0 - 9

If there is one alphanumeric rune is found in string, increase the rune by 1. If increment generates a "carry", the rune to the left of it is incremented. This process repeats until there is no carry, adding an additional rune if necessary.

If there is no alphanumeric rune, the rightmost rune will be increased by 1 regardless whether the result is a valid rune or not.

See String#delete in ruby.

See String#squeeze in ruby.

The idea is from C# (String.Join)

Just like ucfirst and lcfirst in php.

Hi,

func TestToCamelCase(t *testing.T) {
	runTestCases(t, ToCamelCase, _M{
		"GOLANG":             "Golang",
	})
}

The following test should succeed instead it returns "GOLANG".

--- FAIL: TestToCamelCase (0.00s)
        util_test.go:22: case fails. [case:GOLANG]
                should => "Golang"
                actual => "GOLANG"

Is it a wanted behavior?

Cheers,

Expect both ToSnakeCase("http2xx") and ToSnakeCase("HTTP2XX") to generate http_2xx.

Currently, the former (lowercase) returns http2xx and the latter htt_p2_xx 😕

See String#tr in ruby.

Function signature will be func Translate(str, from, to string) string. In this function, from and to are a pattern defined as following.

• Special characters:
  • - means a range of runes, e.g. "a-z" means all characters from 'a' to 'z' inclusive.
  • ^ as first character means a set of all runes excepted listed, e.g. "^a-z" means all characters except 'a' to 'z' inclusive.
  • \ escapes special characters.
• Normal character represents itself, e.g. "abc" is a set including 'a', 'b' and 'c'.

Translate will try to find a 1:1 mapping from from to to. If to is smaller than from, last rune in to will be used to map "out of range" characters.

There should be a set of functions to "compile" translate from and to string to a rune set for better performance.

Go string is immutable and encoded in utf8 internally. It's a bit more challenge than reversing an ascii string.

Test case (https://play.golang.org/p/0c_RiL_p3av):

package main                                                                                                                                             

import (
  "fmt"
  "github.com/huandu/xstrings"
)

func main() {
  fmt.Printf(">> %+q\n", xstrings.ToCamelCase("a"))
  fmt.Printf(">> %+q\n", xstrings.ToCamelCase("ab"))
}

Which will output

>> ""
>> "Ab"

go version: go1.13 linux/amd64
xstrings version: 1.2.0

See String#insert in ruby. Implementation in Go will be a bit different. Index is counted by rune instead of byte.

See str.ljust in Python or String#ljust in Ruby.

:)

See str.center in Python.

As camel case of "_c" is "_C", snake case of "_C" should be "_c".

See Snake case.

Hello and thanks for package!

Please consider semantic versioning tags in this project (https://semver.org). That'd make life of dependency management tools users easier.

Thanks!

See str.rjust in Python and String#rjust in Ruby.

Camel case to underscore.

• SomeWords => some_words
• HTTPServer => http_server
• NoHTTPS => no_https

Underscore to camel case.

• some_words => SomeWords
• http_server => HttpServer
• no_https => NoHttps
• _complex__case_ => _Complex_Case_