Venus::String - String Class
String Class for Perl 5
package main; use Venus::String; my $string = Venus::String->new('hello world'); # $string->camelcase;
This package provides methods for manipulating string data.
This package inherits behaviors from:
Venus::Kind::Value
This package provides the following methods:
append(Str @parts) (Str)
The append method appends arugments to the string using spaces.
Since 0.01
0.01
# given: synopsis; my $append = $string->append('welcome'); # "hello world welcome"
append_with(Str $delimiter, Str @parts) (Str)
The append_with method appends arugments to the string using the delimiter provided.
# given: synopsis; my $append = $string->append_with(', ', 'welcome'); # "hello world, welcome"
camelcase() (Str)
The camelcase method converts the string to camelcase.
# given: synopsis; my $camelcase = $string->camelcase; # "helloWorld"
cast(Str $kind) (Object | Undef)
The cast method converts "value" objects between different "value" object types, based on the name of the type provided. This method will return undef if the invocant is not a Venus::Kind::Value.
undef
Since 0.08
0.08
package main; use Venus::String; my $string = Venus::String->new; my $cast = $string->cast('array'); # bless({ value => [""] }, "Venus::Array")
package main; use Venus::String; my $string = Venus::String->new; my $cast = $string->cast('boolean'); # bless({ value => 0 }, "Venus::Boolean")
package main; use Venus::String; my $string = Venus::String->new; my $cast = $string->cast('code'); # bless({ value => sub { ... } }, "Venus::Code")
package main; use Venus::String; my $string = Venus::String->new; my $cast = $string->cast('float'); # bless({ value => "0.0" }, "Venus::Float")
package main; use Venus::String; my $string = Venus::String->new; my $cast = $string->cast('hash'); # bless({ value => { "" => "" } }, "Venus::Hash")
package main; use Venus::String; my $string = Venus::String->new; my $cast = $string->cast('number'); # bless({ value => 0 }, "Venus::Float")
package main; use Venus::String; my $string = Venus::String->new; my $cast = $string->cast('regexp'); # bless({ value => qr/(?^u:)/ }, "Venus::Regexp")
package main; use Venus::String; my $string = Venus::String->new; my $cast = $string->cast('scalar'); # bless({ value => \"" }, "Venus::Scalar")
package main; use Venus::String; my $string = Venus::String->new; my $cast = $string->cast('string'); # bless({ value => "" }, "Venus::String")
package main; use Venus::String; my $string = Venus::String->new; my $cast = $string->cast('undef'); # bless({ value => undef }, "Venus::Undef")
chomp() (Str)
The chomp method removes the newline (or the current value of $/) from the end of the string.
package main; use Venus::String; my $string = Venus::String->new("name, age, dob, email\n"); my $chomp = $string->chomp; # "name, age, dob, email"
package main; use Venus::String; my $string = Venus::String->new("name, age, dob, email\n\n"); my $chomp = $string->chomp; # "name, age, dob, email\n"
chop() (Str)
The chop method removes and returns the last character of the string.
package main; use Venus::String; my $string = Venus::String->new("this is just a test."); my $chop = $string->chop; # "this is just a test"
concat(Str @parts) (Str)
The concat method returns the string with the argument list appended to it.
package main; use Venus::String; my $string = Venus::String->new('ABC'); my $concat = $string->concat('DEF', 'GHI'); # "ABCDEFGHI"
contains(Str $expr) (Bool)
The contains method searches the string for a substring or expression returns true or false if found.
package main; use Venus::String; my $string = Venus::String->new('Nullam ultrices placerat.'); my $contains = $string->contains('trices'); # 1
package main; use Venus::String; my $string = Venus::String->new('Nullam ultrices placerat.'); my $contains = $string->contains('itrices'); # 0
package main; use Venus::String; my $string = Venus::String->new('Nullam ultrices placerat.'); my $contains = $string->contains(qr/trices/); # 1
default() (Str)
The default method returns the default value, i.e. ''.
''
# given: synopsis; my $default = $string->default; # ""
eq(Any $arg) (Bool)
The eq method performs an "equals" operation using the argument provided.
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Array->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Code->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Float; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Float->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Number->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Regexp; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Scalar; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::String->new; my $result = $lvalue->eq($rvalue); # 1
package main; use Venus::String; use Venus::Undef; my $lvalue = Venus::String->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->eq($rvalue); # 1
ge(Any $arg) (Bool)
The ge method performs a "greater-than-or-equal-to" operation using the argument provided.
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Array->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Code->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Float; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Float->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Number->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Regexp; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Scalar; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::String->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::String; use Venus::Undef; my $lvalue = Venus::String->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->ge($rvalue); # 1
gele(Any $arg1, Any $arg2) (Bool)
The gele method performs a "greater-than-or-equal-to" operation on the 1st argument, and "lesser-than-or-equal-to" operation on the 2nd argument.
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Array->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Code->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Float; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Float->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Number->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Regexp; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Scalar; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::String->new; my $result = $lvalue->gele($rvalue); # 1
package main; use Venus::String; use Venus::Undef; my $lvalue = Venus::String->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->gele($rvalue); # 1
gt(Any $arg) (Bool)
The gt method performs a "greater-than" operation using the argument provided.
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Array->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Code->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Float; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Float->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Number->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Regexp; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Scalar; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::String->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::String; use Venus::Undef; my $lvalue = Venus::String->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->gt($rvalue); # 0
gtlt(Any $arg1, Any $arg2) (Bool)
The gtlt method performs a "greater-than" operation on the 1st argument, and "lesser-than" operation on the 2nd argument.
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Array->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Code->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Float; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Float->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Number->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Regexp; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Scalar; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::String->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::String; use Venus::Undef; my $lvalue = Venus::String->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->gtlt($rvalue); # 0
hex() (Str)
The hex method returns the value resulting from interpreting the string as a hex string.
package main; use Venus::String; my $string = Venus::String->new('0xaf'); my $hex = $string->hex; # 175
index(Str $substr, Int $start) (Num)
The index method searches for the argument within the string and returns the position of the first occurrence of the argument.
package main; use Venus::String; my $string = Venus::String->new('unexplainable'); my $index = $string->index('explain'); # 2
package main; use Venus::String; my $string = Venus::String->new('unexplainable'); my $index = $string->index('explain', 1); # 2
package main; use Venus::String; my $string = Venus::String->new('unexplainable'); my $index = $string->index('explained'); # -1
kebabcase() (Str)
The kebabcase method converts the string to kebabcase.
Since 0.09
0.09
# given: synopsis; my $kebabcase = $string->kebabcase; # "hello-world"
lc() (Str)
The lc method returns a lowercased version of the string.
package main; use Venus::String; my $string = Venus::String->new('Hello World'); my $lc = $string->lc; # "hello world"
lcfirst() (Str)
The lcfirst method returns a the string with the first character lowercased.
package main; use Venus::String; my $string = Venus::String->new('Hello World'); my $lcfirst = $string->lcfirst; # "hello World"
le(Any $arg) (Bool)
The le method performs a "lesser-than-or-equal-to" operation using the argument provided.
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Array->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Code->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Float; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Float->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Number->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Regexp; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Scalar; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::String->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::String; use Venus::Undef; my $lvalue = Venus::String->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->le($rvalue); # 1
length() (Int)
The length method returns the number of characters within the string.
# given: synopsis; my $length = $string->length; # 11
lines() (ArrayRef[Str])
The lines method returns an arrayref of parts by splitting on 1 or more newline characters.
# given: synopsis; my $lines = $string->lines; # ["hello world"]
package main; use Venus::String; my $string = Venus::String->new("who am i?\nwhere am i?\nhow did I get here"); my $lines = $string->lines; # ["who am i?", "where am i?", "how did I get here"]
lowercase() (Str)
The lowercase method is an alias to the lc method.
package main; use Venus::String; my $string = Venus::String->new('Hello World'); my $lowercase = $string->lowercase; # "hello world"
lt(Any $arg) (Bool)
The lt method performs a "lesser-than" operation using the argument provided.
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Array->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Code->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::Float; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Float->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Number->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::Regexp; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::Scalar; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::String->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::String; use Venus::Undef; my $lvalue = Venus::String->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->lt($rvalue); # 0
ne(Any $arg) (Bool)
The ne method performs a "not-equal-to" operation using the argument provided.
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Array->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Code->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Float; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Float->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Number->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Regexp; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Scalar; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::String->new; my $result = $lvalue->ne($rvalue); # 0
package main; use Venus::String; use Venus::Undef; my $lvalue = Venus::String->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->ne($rvalue); # 0
numified() (Int)
The numified method returns the numerical representation of the object. For string objects this method returns the underlying value, if that value looks like a number, or 0.
0
# given: synopsis; my $numified = $string->numified; # 11
package main; use Venus::String; my $string = Venus::String->new(1_000_000); my $numified = $string->numified; # 1000000
pascalcase() (Str)
The pascalcase method converts the string to pascalcase.
# given: synopsis; my $pascalcase = $string->pascalcase; # "HelloWorld"
prepend(Str @parts) (Str)
The prepend method prepends arugments to the string using spaces.
# given: synopsis; my $prepend = $string->prepend('welcome'); # "welcome hello world"
prepend_with(Str $delimiter, Str @parts) (Str)
The prepend_with method prepends arugments to the string using the delimiter provided.
# given: synopsis; my $prepend = $string->prepend_with(', ', 'welcome'); # "welcome, hello world"
render(HashRef $tokens) (Str)
The render method treats the string as a template and performs a simple token replacement using the argument provided.
package main; use Venus::String; my $string = Venus::String->new('Hi, {{name}}!'); my $render = $string->render({name => 'Friend'}); # "Hi, Friend!"
repeat(Num $number, Str $delimiter) (Str)
The repeat method repeats the string value N times based on the number provided and returns a new concatenated string. Optionally, a delimiter can be provided and be place between the occurences.
package main; use Venus::String; my $string = Venus::String->new('999'); my $repeat = $string->repeat(2); # "999999"
package main; use Venus::String; my $string = Venus::String->new('999'); my $repeat = $string->repeat(2, ','); # "999,999"
replace(Regexp $regexp, Str $replace, Str $flags) (Replace)
The replace method performs a search and replace operation and returns the Venus::Replace object.
# given: synopsis; my $replace = $string->replace('world', 'universe'); # bless({ # ..., # "flags" => "", # "regexp" => "world", # "string" => "hello world", # "substr" => "universe", # }, "Venus::Replace")
reverse() (Str)
The reverse method returns a string where the characters in the string are in the opposite order.
# given: synopsis; my $reverse = $string->reverse; # "dlrow olleh"
rindex(Str $substr, Int $start) (Str)
The rindex method searches for the argument within the string and returns the position of the last occurrence of the argument.
package main; use Venus::String; my $string = Venus::String->new('explain the unexplainable'); my $rindex = $string->rindex('explain'); # 14
package main; use Venus::String; my $string = Venus::String->new('explain the unexplainable'); my $rindex = $string->rindex('explained'); # -1
package main; use Venus::String; my $string = Venus::String->new('explain the unexplainable'); my $rindex = $string->rindex('explain', 21); # 14
search(Regexp $regexp) (Search)
The search method performs a search operation and returns the Venus::Search object.
# given: synopsis; my $search = $string->search('world'); # bless({ # ..., # "flags" => "", # "regexp" => "world", # "string" => "hello world", # }, "Venus::Search")
snakecase() (Str)
The snakecase method converts the string to snakecase.
# given: synopsis; my $snakecase = $string->snakecase; # "hello_world"
split(Str | Regexp $expr, Maybe[Int] $limit) (ArrayRef)
The split method returns an arrayref by splitting the string on the argument.
package main; use Venus::String; my $string = Venus::String->new('name, age, dob, email'); my $split = $string->split(', '); # ["name", "age", "dob", "email"]
package main; use Venus::String; my $string = Venus::String->new('name, age, dob, email'); my $split = $string->split(', ', 2); # ["name", "age, dob, email"]
package main; use Venus::String; my $string = Venus::String->new('name, age, dob, email'); my $split = $string->split(qr/\,\s*/); # ["name", "age", "dob", "email"]
stringified() (Str)
The stringified method returns the object, stringified (i.e. a dump of the object's value).
# given: synopsis; my $stringified = $string->stringified; # "hello world"
package main; use Venus::String; my $string = Venus::String->new("hello\nworld"); my $stringified = $string->stringified; # "hello\\nworld"
# given: synopsis; my $stringified = $self->stringified; # ...
strip() (Str)
The strip method returns the string replacing occurences of 2 or more whitespaces with a single whitespace.
package main; use Venus::String; my $string = Venus::String->new('one, two, three'); my $strip = $string->strip; # "one, two, three"
substr(Num $offset, Num $length, Str $replace) (Str)
The substr method calls the core "substr" function with the object's string value. In list context returns the result and the subject.
package main; use Venus::String; my $string = Venus::String->new('hello world'); my $substr = $string->substr(0, 5); # "hello"
package main; use Venus::String; my $string = Venus::String->new('hello world'); my $substr = $string->substr(6, 5); # "world"
package main; use Venus::String; my $string = Venus::String->new('hello world'); my $substr = $string->substr(6, 5, 'universe'); # "hello universe"
package main; use Venus::String; my $string = Venus::String->new('hello world'); my ($result, $subject) = $string->substr(6, 5, 'universe'); # ("world", "hello universe")
titlecase() (Str)
The titlecase method returns the string capitalizing the first character of each word.
# given: synopsis; my $titlecase = $string->titlecase; # "Hello World"
trim() (Str)
The trim method removes one or more consecutive leading and/or trailing spaces from the string.
package main; use Venus::String; my $string = Venus::String->new(' system is ready '); my $trim = $string->trim; # "system is ready"
tv(Any $arg) (Bool)
The tv method performs a "type-and-value-equal-to" operation using argument provided.
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Array->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Code->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Float; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Float->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Number; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Number->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Regexp; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Scalar; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::String; my $lvalue = Venus::String->new; my $rvalue = Venus::String->new; my $result = $lvalue->tv($rvalue); # 1
package main; use Venus::String; use Venus::Undef; my $lvalue = Venus::String->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->tv($rvalue); # 0
uc() (Str)
The uc method returns an uppercased version of the string.
# given: synopsis; my $uc = $string->uc; # "HELLO WORLD"
ucfirst() (Str)
The ucfirst method returns a the string with the first character uppercased.
# given: synopsis; my $ucfirst = $string->ucfirst; # "Hello world"
uppercase() (Str)
The uppercase method is an alias to the uc method.
# given: synopsis; my $uppercase = $string->uppercase; # "HELLO WORLD"
words() (ArrayRef[Str])
The words method returns an arrayref by splitting on 1 or more consecutive spaces.
package main; use Venus::String; my $string = Venus::String->new( 'is this a bug we\'re experiencing' ); my $words = $string->words; # ["is", "this", "a", "bug", "we're", "experiencing"]
This package overloads the following operators:
("")
This package overloads the "" operator.
""
example 1
# given: synopsis; my $result = "$string"; # "hello world"
example 2
# given: synopsis; my $result = "$string, $string"; # "hello world, hello world"
(eq)
This package overloads the eq operator.
eq
# given: synopsis; my $result = $string eq 'hello world'; # 1
package main; use Venus::String; my $string1 = Venus::String->new('hello world'); my $string2 = Venus::String->new('hello world'); my $result = $string1 eq $string2; # 1
(ne)
This package overloads the ne operator.
ne
# given: synopsis; my $result = $string ne 'Hello world'; 1;
package main; use Venus::String; my $string1 = Venus::String->new('hello world'); my $string2 = Venus::String->new('Hello world'); my $result = $string1 ne $string2; # 1
(qr)
This package overloads the qr operator.
qr
# given: synopsis; my $test = 'hello world' =~ qr/$string/; # 1
To install Venus, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Venus
CPAN shell
perl -MCPAN -e shell install Venus
For more information on module installation, please visit the detailed CPAN module installation guide.