[ruby-core:100138] [Ruby master Feature#17056] Array#index: Allow specifying the position to start search as in String#index

Issue #17056 has been updated by fatkodima (Dima Fatko).



Eregon (Benoit Daloze) wrote in #note-7:
> What if a block is given, and one want to use a start index? (for efficiency and not run the block for the first `start` elements).
> 
> `ary.index(start) { |i| ... }` seems confusing.
> 
> Probably keyword arguments are better:
> `ary.index(from: start) { |i| ... }` or `ary.index(start: start) { |i| ... }`
ary.index(from: start) { |i| ... } or ary.index(start: start) { |i| ... }

Agreed.

Eregon (Benoit Daloze) wrote in #note-7:
> 
> It can also be done with `ary = 'abcabc'.chars; (2...ary.size).find { |i| ary[i] == 'a' }`.
> That's a little bit more complicated, but it's also usable in many more situations than just `index`.
> I would expect it's fairly rare to need a start offset, so I think there is no need for a shortcut.

Personally, I had a need for start index a couple of times. What I have seen most of the times, developers just slice an array (allocating a new array; is there a CoW here?) in needed range. And it will be convenient to have a start index argument. And it will be consistent with `String#index`. 

matz (Yukihiro Matsumoto) wrote in #note-6:
> Accepted. 
> 
> How do you think about end index? Do we need it? If so, should we add end index to `String#index` as well?
> 
> Matz.

As for end index, I think this is truly would be rarely needed and can be simulated with something like `...with_index ... { |..., index| ... break if index > end_index ... }`

As @marcandre pointed out, other methods would probably also benefit from such method arguments, but to avoid updating all of them, I would prefer just add start index argument to `Array#index`, for consistency with `String#index`, and it can be used in user code for emulating other methods, like
```ruby
# find with start index
index = array.index(start: 10) { |e| e % 10 == 0 }
item = array[index] if index
```

----------------------------------------
Feature #17056: Array#index: Allow specifying the position to start search as in String#index
https://bugs.ruby-lang.org/issues/17056#change-87709

* Author: TylerRick (Tyler Rick)
* Status: Open
* Priority: Normal
----------------------------------------
I have a use case of finding the first matching line within a given section in a file. After finding the line number of the start of the section, I want to find the first match after that line.

My workaround for now is to use `with_index`:

```ruby
lines = pathname.read.lines
section_start_line = lines.index {|line| line.start_with?(/#* #{section_name}/) }
lines.index.with_index {|line, i| i > section_start_line && line.include?(sought) }
```

I'd like to do it in a more concise way using a feature of `Array#index` that I propose here, which is analogous to `String#index`.

If the second parameter of `String#index` is present, it specifies the position in the string to begin the search:

```ruby
'abcabc'.index('a') # => 0
'abcabc'.index('a',2) # => 3
```

I would expect to also be able to do:

```ruby
'abcabc'.chars.index('a') # => 0
'abcabc'.chars.index('a', 2)
```

Using such feature, I would be able to do:

```ruby
lines.index(sought, section_start_line)
```

This would give Ruby better parity with other programming languages like Python:

```python
>>> list('abcabc')
['a', 'b', 'c', 'a', 'b', 'c']
>>> list('abcabc').index('a')
0
>>> list('abcabc').index('a', 2)
3
```

## End index

We can further think of an optional parameter to specify the position to end the search. The following languages allow specifying both start and end indexes:

- [Python](https://docs.python.org/3/tutorial/datastructures.html)
- [C#](https://docs.microsoft.com/en-us/dotnet/api/system.array.indexof?view=netcore-3.1)

Ruby's `String#index` does not have one, so we could make a separate proposal to add `end` to both methods at the same time.



-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>