substring: to the end of the string

[KONTRA Gergely]

Hi!

Is there any easiest way to get the substring starting from the 3rd
character?

my solution:
str[3..-1] which seems quite odd :-/

What if, intuitive, we can write
str[3..]?

Any smarter solution?

Gergo

 

[Robert Klemme]

Hi!

Is there any easiest way to get the substring starting from the 3rd
character?

my solution:
str[3..-1] which seems quite odd :-/

What if, intuitive, we can write
str[3..]?

Any smarter solution?

Not as far as I know. You can do str[3,str.length-3] but this isn't
really an improvement unless you value the absence of negative integers in
this expression.

robert

 

[Bernard Delmée]

my solution:

str[3..-1] which seems quite odd :-/

The idiom in python is str[3:]
Conversely, str[:3] gives you the 3 1st chars.

Read the explanation of slicing operations here:
http://www.python.org/doc/current/lib/typesseq.html
(read note 4 & 5)

And beware, 'str' is a builtin, hence a poor choice as a variable name.

Have fun,

Bernard.

 

[Bernard Delmée]

Oops - wrong NG, my bad ;-)

 

[Gavin Sinclair]

Hi!

Is there any easiest way to get the substring starting from the 3rd
character?

my solution:
str[3..-1] which seems quite odd :-/

Seems quite even to me

Seriously, the ability to negative-index strings and arrays like that
is a breath of fresh air compared to traditional compiled languages.
I see no need to improve on it.

What if, intuitive, we can write
str[3..]?

I rather doubt that's going to happen. When you execute str[3..7],
the 3..7 isn'y arbitrary syntax, it's a Range object. If Range
objects were allowed to be unbounded, then fine. So the question
really becomes, should Range objects allow unbounded ranges?

Any smarter solution?

Write a String#substring method if you like.

Cheers,
Gavin

 

[Bermejo, Rodrigo]

class String

def substring

/(^...)(.*)\z/ =~ self

return $2

end

end

"123456".substring
= >"456"


Now......

I am just wondering how can I build dinamically the Regexp
I mean ...

"123456".substring(5)
= > "6"

"123456".substring(4)
= > "56"

ideas ?

-r.

Hi!

Is there any easiest way to get the substring starting from the 3rd
character?

my solution:
str[3..-1] which seems quite odd :-/

What if, intuitive, we can write
str[3..]?

Any smarter solution?

Gergo

--
General Electric - CIAT
Advanced Engineering Center
________________________________________
Rodrigo Bermejo
Information Technologies.
Special Applications
Dial-comm : *879-0644
Phone +52) 442-196-0644

 

[Dan Doel]

Some ways:

class String
def substring1(n)
reg = Regexp.compile("(^" + "."*n + ")(.*)\\z")
reg.match(self)[2]
end

def substring2(s, e=-1)
self[s..e]
end
end

p "12345".substring1 1
p "12345".substring1 2
p "12345".substring2 1
p "12345".substring2 2
p "12345".substring2 1, 3

 

[Gavin Sinclair]

class String
def substring
/(^...)(.*)\z/ =~ self
return $2
end
end

"123456".substring
= >"456"

I am just wondering how can I build dinamically the Regexp
I mean ...

"123456".substring(5)
= > "6"

"123456".substring(4)

= >> "56"

ideas ?

Regexen are overkill here.

class String
def substring(m, n=-1)
self[m..n]
end
end


Gavin

 

[Linus Sellberg]

On Saturday, November 15, 2003, 2:48:53 AM, KONTRA wrote:
Seriously, the ability to negative-index strings and arrays like that
is a breath of fresh air compared to traditional compiled languages.
I see no need to improve on it.

I do, but I have no good solution to the problem.

The problem being that positive indexes go from 0 to n-1, while negative
go from -1 to -n, which could introduce confusion.

But as I said, I know of no good solutions, since -0 is not a good way,
and making the first positive index a 1 is just as bad, for several reasons.

 

[Jon A. Lambert]

Hi!

Is there any easiest way to get the substring starting from the 3rd
character?

my solution:
str[3..-1] which seems quite odd :-/

What if, intuitive, we can write
str[3..]?

Any smarter solution?

Actually I find this behavior annoying:

irb(main):015:0> "hello"[3..-1]
=> "lo"
irb(main):016:0> "hello"[4..-1]
=> "o"
irb(main):017:0> "hello"[5..-1]
=> ""
irb(main):018:0> "hello"[6..-1]
=> nil

 

[Josef 'Jupp' SCHUGT]

Hi!

* KONTRA Gergely; 2003-11-14, 23:30 UTC:

Is there any easiest way to get the substring starting from the 3rd
character?

my solution:
str[3..-1] which seems quite odd :-/

What if, intuitive, we can write
str[3..]?

Any smarter solution?

Besids 'get used to -1'? Well, here's some extension to 'String'. I
did try my best to follow POLS. The intention is that left, right,
mid emulate BASIC's left$, right$ and mid$ while head and tail
without any arguments have the results they should have from a
functional programming point of view.

class String

# 'number' leftmost chars
def left(number = 1)
self[0..number-1]
end

# 'number' rightmost chars
def right(number = 1)
self[-number..-1]
end

# 'number' chars starting at position 'from'
def mid(from, number=1)
self[from..from+number]
end

# chars from beginning to 'position'
def head(position = 0)
self[0..position]
end

# chars following 'position'
def tail(position = 0)
self[position+1..-1]
end

end


Josef 'Jupp' Schugt

 

[Simon Strandgaard]

Besids 'get used to -1'? Well, here's some extension to 'String'. I
did try my best to follow POLS. The intention is that left, right,
mid emulate BASIC's left$, right$ and mid$ while head and tail
without any arguments have the results they should have from a
functional programming point of view.

[snip class String extension]

Useful.. I have added your snippet at rubygarden (StringSub):
http://www.rubygarden.org/ruby?StandardClassExtensions/String

 

[Simon Strandgaard]

class String
def left(number = 1)
self[0..number-1]
end
def right(number = 1)
self[-number..-1]
end
def mid(from, number=1)
self[from..from+number]
end
def head(position = 0)
self[0..position]
end
def tail(position = 0)
self[position+1..-1]
end
end

Maybe some destructive versions of the above methods could be useful?

input="diamonds are forever"
p input.right!(4) #-> "ever"
p input.left!(4) #-> "diam"
p input # -> "onds are for"

 

[nobu.nokada]

Hi,

At Sat, 15 Nov 2003 23:58:55 +0900,

As Gavin pointed out, regexen are overkill here. However, the
technique is worth noting:

Another syntax sugar,

class String
def substring(start, len = nil)
if len.nil? self[/\A.{#{start}}(.*)/m, 1]
else

self[/\A.{#{start}}(.{#{len}})/m, 1]

 

[Robert Klemme]

I do, but I have no good solution to the problem.

The problem being that positive indexes go from 0 to n-1, while negative
go from -1 to -n, which could introduce confusion.

But as I said, I know of no good solutions, since -0 is not a good way,

This reminds me of an old mathematician's joke: there was this professor
for math that found an epsilon so small, that half of it was already
negative... ;-)

and making the first positive index a 1 is just as bad, for several

reasons.

Yup

robert

 

[KONTRA Gergely]

I rather doubt that's going to happen. When you execute str[3..7],
the 3..7 isn'y arbitrary syntax, it's a Range object. If Range
objects were allowed to be unbounded, then fine. So the question
really becomes, should Range objects allow unbounded ranges?

Yes, it should What about 3..INF here?

 

[Jason DiCioccio]

--On Saturday, November 15, 2003 12:48 AM +0900 KONTRA Gergely

Hi!

Is there any easiest way to get the substring starting from the 3rd
character?

my solution:
str[3..-1] which seems quite odd :-/

I typically use str[3..str.length].. It's probably slower, but it looks a
bit cleaner in code..

Regards,
-JD-