I'm using ksh here...

I can set the shell parameters in numerical order

$ set {1..100}

then sort them _lexicographically_

$ set -s

Or do both in one

$ set -s {1..100}

I haven't found anything to sort them _numerically_ in shell.

What I'm trying to do is iterating over files, say,
P1.HTM P10.HTM P11.HTM P2.HTM P3.HTM P4.HTM P5.HTM P6.HTM P7.HTM
P8.HTM P9.HTM
in numerical order.

Setting the files as shell arguments with P*.HTM will also produce
lexicographical order.

The preceding files are just samples. It should work also if the
numbers are non-consecutive (say, 2, 10, 10000, 3333333) so that
iterating using a for-loop and building the list is not an option.

(Ideally I'd also like to handle names with two numbers "A35P56.txt"
and irregular string components (lowercase, say, "page310ch1.txt"),
but that's just a nice-to-have. - I might make use of 'sort'?)

But the primary question is; how to organize/iterate the arguments
*numerically* _in shell_? (If that's possible in some simple way.)

N.B.: I prefer not to use external commands like 'sort' because of
the negative side effects and bulky code to handle newlines and
blanks in filenames, and messing around with quotes.

Janis

Janis Papanagnou <janis_papanagnou+ng@hotmail.com> writes:

> What I'm trying to do is iterating over files, say,
> P1.HTM P10.HTM P11.HTM P2.HTM P3.HTM P4.HTM P5.HTM P6.HTM P7.HTM
> P8.HTM P9.HTM
> in numerical order.

Could you employ printf to add leading zeros, sort lexicogpaphically and
then remove the zeros?

> (Ideally I'd also like to handle names with two numbers "A35P56.txt"
> and irregular string components (lowercase, say, "page310ch1.txt"),
> but that's just a nice-to-have. - I might make use of 'sort'?)

You did not yet mention what your final goal is with the numerically
sorted list.

In case this is in the end a renaming task, for this level of complexity
I would use the "wdired" mode of Emacs ("write directory edits") and use
regexes for search and replace. Or some other "multi-rename" tools from
the command line.

Best regards

Axel

On 15.06.2024 15:56, Axel Reichert wrote:
> Janis Papanagnou <janis_papanagnou+ng@hotmail.com> writes:
>
>> What I'm trying to do is iterating over files, say,
>> P1.HTM P10.HTM P11.HTM P2.HTM P3.HTM P4.HTM P5.HTM P6.HTM P7.HTM
>> P8.HTM P9.HTM
>> in numerical order.
>
> Could you employ printf to add leading zeros, sort lexicogpaphically and
> then remove the zeros?

Something like this (not using printf but a more elementary method) is
actually what I'm currently doing. (It's not really complex but quite
some data fiddling I wanted to avoid. I have that in a script and it's
not a general solution but handles just simple cases like the sample
data above, which is 95% of my usages so it's okay for that but not
really satisfying for other or more general cases.)

To get the original name back I think I'd have to store the original
names along with the new names. (Which is something I've not yet done.)

>
>> (Ideally I'd also like to handle names with two numbers "A35P56.txt"
>> and irregular string components (lowercase, say, "page310ch1.txt"),
>> but that's just a nice-to-have. - I might make use of 'sort'?)
>
> You did not yet mention what your final goal is with the numerically
> sorted list.

The original application was that I simply wanted to sequentially skim
through a number of files.[*] In the past (where possible) I've just
renamed the files to let them have numbers of equal length (as noted
above). But the general task I envision is that I don't want to change
any name of data files but just be able to iterate over these files,
or list them numerically sorted (and without the known issues of \n
and blank handling).

I thought that a contemporary shell would probably support that but I
was astonished that (at least in ksh) it wasn't supported (as far as
I saw).[**]

>
> In case this is in the end a renaming task, for this level of complexity
> I would use the "wdired" mode of Emacs ("write directory edits") and use
> regexes for search and replace. Or some other "multi-rename" tools from
> the command line.

I've my own script to adjust numbers in files. But as said, I'd rather
want to iterate or sort, like the lexicographic ordering in ksh

set -s page*.gif

(which in that example is anyway the default for wildcard patterns)
something similar for numeric argument setting (or pattern expansion)

set --numerical page*.gif

To use that features more widely it would be nice if the wild-card
expansion could be controlled, say by

set -o numerical

Well, maybe that all makes no sense and should be tackled differently?
But it's how it appears to me at the moment. (Feel free to enlighten
me. :-)

Janis

[*] I occasionally have this task; the last time was when I wanted to
read old typewriter documents that had been scanned page-wise as GIF
files.

[**] Yet I haven't checked Zsh; that shell supports some non-standard
modifiers in certain zsh-specific constructs, so it might possible it
has support for this requirement as well. (But Zsh is not the shell
I'm using so I'm primarily seeking for a Ksh solution or POSIX shell
workaround.)

On Fri, 14 Jun 2024 09:31:18 +0200, Janis Papanagnou wrote:

> I'm using ksh here...

At some point, you have to accept that trying to do everything in a shell
language is not the best way to go, and that it is time to switch to a
“real” programming language.

For example, Perl or Python could do this much more easily.

On 16.06.2024 00:49, Lawrence D'Oliveiro wrote:
> On Fri, 14 Jun 2024 09:31:18 +0200, Janis Papanagnou wrote:
>
>> I'm using ksh here...
>
> At some point, you have to accept that trying to do everything in a shell
> language is not the best way to go, and that it is time to switch to a
> “real” programming language.

What argument are you trying to make up? What makes you think
I'm doing "everything in a shell"?

(My approach is to take the appropriate tools and language from
the set of (a dozen, or so) "real" languages I know, plus from
the set of a handful of scripting languages that I know.)

> For example, Perl or Python could do this much more easily.

I don't know of this feature in Perl or Python; please provide
some hint if there is a feature like the one I need. Some code
samples for demonstration of your point are also welcome.

(Only in case you missed it; I'm not [primarily] looking for a
program; for the described task I'm fine with what I have done.
Rather I'm looking for an inherent feature that supports what I
described elsethread. And I like to have this feature in shell
since a shell is my standard interface to my Unix system. HTH.)

Janis

On Sun, 16 Jun 2024 05:11:29 +0200, Janis Papanagnou wrote:

> I don't know of this feature in Perl or Python; please provide some hint
> if there is a feature like the one I need. Some code samples for
> demonstration of your point are also welcome.

Python solution:

import re

items = \
[
"P1.HTM", "P10.HTM", "P11.HTM", "P2.HTM", "P3.HTM",
"P4.HTM", "P5.HTM", "P6.HTM", "P7.HTM", "P8.HTM", "P9.HTM",
]

print(items)

print \
(
sorted
(
items,
key = lambda f :
tuple
(
(lambda : p, lambda : int(p))[i % 2 != 0]()
for i, p in enumerate(re.split("([0-9]+)", f))
)
)
)

output:

['P1.HTM', 'P10.HTM', 'P11.HTM', 'P2.HTM', 'P3.HTM', 'P4.HTM', 'P5.HTM', 'P6.HTM', 'P7.HTM', 'P8.HTM', 'P9.HTM']
['P1.HTM', 'P2.HTM', 'P3.HTM', 'P4.HTM', 'P5.HTM', 'P6.HTM', 'P7.HTM', 'P8.HTM', 'P9.HTM', 'P10.HTM', 'P11.HTM']

On 16.06.2024 06:56, Lawrence D'Oliveiro wrote:
> On Sun, 16 Jun 2024 05:11:29 +0200, Janis Papanagnou wrote:
>
>> I don't know of this feature in Perl or Python; please provide some hint
>> if there is a feature like the one I need. Some code samples for
>> demonstration of your point are also welcome.
>
> Python solution:
>
> import re
>
> items = \
> [
> "P1.HTM", "P10.HTM", "P11.HTM", "P2.HTM", "P3.HTM",
> "P4.HTM", "P5.HTM", "P6.HTM", "P7.HTM", "P8.HTM", "P9.HTM",
> ]
>
> print(items)
>
> print \
> (
> sorted
> (
> items,
> key = lambda f :
> tuple
> (
> (lambda : p, lambda : int(p))[i % 2 != 0]()
> for i, p in enumerate(re.split("([0-9]+)", f))
> )
> )
> )
>
> output:
>
> ['P1.HTM', 'P10.HTM', 'P11.HTM', 'P2.HTM', 'P3.HTM', 'P4.HTM', 'P5.HTM', 'P6.HTM', 'P7.HTM', 'P8.HTM', 'P9.HTM']
> ['P1.HTM', 'P2.HTM', 'P3.HTM', 'P4.HTM', 'P5.HTM', 'P6.HTM', 'P7.HTM', 'P8.HTM', 'P9.HTM', 'P10.HTM', 'P11.HTM']
>

Thanks. Though I'm not familiar with Python to understand that code;
it's too far from any language I've been using.

The (for me) interesting question, though, is; how does it solve the
task I had been addressing? - For convenience I reiterate one main
application...

I want from my shell command line interface call a viewer (or any
other application) with a list of files. If in shell I do, e.g.,

viewer P*.HTM

the list gets sorted lexicographically. How would the main function
look like that I could embed in my call to make a numerically sorted
list. Say, something like, for example,

viewer $( p_sort P*.HTM )

where p_sort would be the Python code. - Note: this is no appropriate
solution since it would anyway not work correctly for file names with
embedded blanks and newlines. I just want to get a closer understanding
how you think this would be usable in shell (or from shell). Thanks.

Janis

Janis Papanagnou <janis_papanagnou+ng@hotmail.com>:
> How would the main function look like that I could embed in my
> call to make a numerically sorted list. Say, something like, for
> example,
>
>
> viewer $( p_sort P*.HTM )
>
> where p_sort would be the Python code. - Note: this is no
> appropriate solution since it would anyway not work correctly
> for file names with embedded blanks and newlines. I just want to
> get a closer understanding how you think this would be usable in
> shell (or from shell). Thanks.
>

If ‘p_sort’ is designed to output the sorted file names separated
by an ASCII NUL character rather than a newline then, using the
GNU version of ‘xargs’, one can feed that output into ‘xargs’:

{
p_sort P*.HTM 3<&- |
xargs --null --no-run-if-empty -- sh -c \
'exec 0<&3 3<&- "$@"' sh \
viewer
} 3<&0

This will avoid the problems with funny characters (including
blanks and linefeeds) in filenames processed by the shell.

with <v4ll54$3sd11$1@dont-email.me> Janis Papanagnou wrote:
> On 16.06.2024 00:49, Lawrence D'Oliveiro wrote:
>> On Fri, 14 Jun 2024 09:31:18 +0200, Janis Papanagnou wrote:

>>> I'm using ksh here...
*SKIP* [ 8 lines 2 levels deep] # borderly ad hominem
> (My approach is to take the appropriate tools and language from the
> set of (a dozen, or so) "real" languages I know, plus from the set of
> a handful of scripting languages that I know.)

(Disclaimer: I'm ksh-ignorant) Speaking of features.

{14439:44} [0:0]% print -cC6 *
bar-20.baz bar-3.baz foo-10.bar foo-23.bar foo-5.bar
bar-21.baz bar-6.baz foo-13.bar foo-29.bar foo-6.bar
bar-24.baz bar-8.baz foo-1.bar foo-3.bar foo-7.bar
bar-26.baz foo-0.bar foo-22.bar foo-4.bar foo-8.bar
{14445:45} [0:0]% print -cC6 *(n)
bar-3.baz bar-21.baz foo-1.bar foo-6.bar foo-13.bar
bar-6.baz bar-24.baz foo-3.bar foo-7.bar foo-22.bar
bar-8.baz bar-26.baz foo-4.bar foo-8.bar foo-23.bar
bar-20.baz foo-0.bar foo-5.bar foo-10.bar foo-29.bar

That nymph between weapon and tool is 'glob qualifier' (acts at
'filename generation' phase). But! It's zsh. That being said, as a
result of cross-pollination, something similar might be in ksh too. I
can't say where to dig through ksh-documentation.

>> For example, Perl or Python could do this much more easily.
> I don't know of this feature in Perl or Python; please provide some
> hint if there is a feature like the one I need. Some code samples for
> demonstration of your point are also welcome.

Well, here's a hint:

Rule#34: If you can imagine sex, there's a module for this.

*CUT* [ 10 lines 1 level deep]

--
Torvalds' goal for Linux is very simple: World Domination
Stallman's goal for GNU is even simpler: Freedom

On Sun, 16 Jun 2024 11:48:25 +0200, Janis Papanagnou wrote:

> How would the main function look like that I could embed in my call to
> make a numerically sorted list.

That’s what the code I posted does.

On 16.06.2024 20:00, Eric Pozharski wrote:
> with <v4ll54$3sd11$1@dont-email.me> Janis Papanagnou wrote:
>> [sorting file names numerically]
>
> (Disclaimer: I'm ksh-ignorant) Speaking of features.
>
> {14439:44} [0:0]% print -cC6 *
> bar-20.baz bar-3.baz foo-10.bar foo-23.bar foo-5.bar
> bar-21.baz bar-6.baz foo-13.bar foo-29.bar foo-6.bar
> bar-24.baz bar-8.baz foo-1.bar foo-3.bar foo-7.bar
> bar-26.baz foo-0.bar foo-22.bar foo-4.bar foo-8.bar
> {14445:45} [0:0]% print -cC6 *(n)
> bar-3.baz bar-21.baz foo-1.bar foo-6.bar foo-13.bar
> bar-6.baz bar-24.baz foo-3.bar foo-7.bar foo-22.bar
> bar-8.baz bar-26.baz foo-4.bar foo-8.bar foo-23.bar
> bar-20.baz foo-0.bar foo-5.bar foo-10.bar foo-29.bar
>
> That nymph between weapon and tool is 'glob qualifier' (acts at
> 'filename generation' phase). But! It's zsh.

Yeah, I was positive that Zsh supports such a qualifier.

> That being said, as a
> result of cross-pollination, something similar might be in ksh too. I
> can't say where to dig through ksh-documentation.

Well, I don't know of any in Ksh. (That's my problem.)

Janis

On 16.06.2024 21:52, Helmut Waitzmann wrote:
> Janis Papanagnou <janis_papanagnou+ng@hotmail.com>:
>> How would the main function look like that I could embed in my call to
>> make a numerically sorted list. Say, something like, for example,
>>
>> viewer $( p_sort P*.HTM )
>>
>> where p_sort would be the Python code. - Note: this is no appropriate
>> solution since it would anyway not work correctly for file names with
>> embedded blanks and newlines. I just want to get a closer
>> understanding how you think this would be usable in shell (or from
>> shell). Thanks.
>
> If ‘p_sort’ is designed to output the sorted file names separated by an
> ASCII NUL character rather than a newline then, using the GNU version of
> ‘xargs’, one can feed that output into ‘xargs’:
>
> {
> p_sort P*.HTM 3<&- |
> xargs --null --no-run-if-empty -- sh -c \
> 'exec 0<&3 3<&- "$@"' sh \
> viewer
> } 3<&0
>
>
> This will avoid the problems with funny characters (including blanks and
> linefeeds) in filenames processed by the shell.

I'm sure it does. You've actually shown a way to circumvent all the
issues with $( ... ) . So I'd probably write a wrapper to make that
code usable in a simpler way. Thanks.

And for the 'p_sort' function I'll resort to some standard tools...

Janis

On 17.06.2024 07:42, Lawrence D'Oliveiro wrote:
> On Sun, 16 Jun 2024 11:48:25 +0200, Janis Papanagnou wrote:
>
>> How would the main function look like that I could embed in my call to
>> make a numerically sorted list.
>
> That’s what the code I posted does.

Erm, really? - I've got the impression that it rather sorts only
the _hard-coded data_, and not to work with arbitrary arguments.
Anyway. Don't bother.

Janis

On Mon, 17 Jun 2024 08:32:21 +0200, Janis Papanagnou wrote:

> ... I've got the impression that it rather sorts only the
> _hard-coded data_ ...

So get the data from the usual sources, e.g. os.listdir().

> Anyway. Don't bother.

I can only lead the horse to water, I cannot make you drink.

On 17.06.2024 09:16, Lawrence D'Oliveiro wrote:
> On Mon, 17 Jun 2024 08:32:21 +0200, Janis Papanagnou wrote:
>
>> ... I've got the impression that it rather sorts only the
>> _hard-coded data_ ...
>
> So get the data from the usual sources, e.g. os.listdir().
>
>> Anyway. Don't bother.
>
> I can only lead the horse to water, I cannot make you drink.

I wouldn't drink from a poisoned spring. IOW; I'd have to learn
Python completely to understand your code and get the details
properly. If it's as simple as you suggested, and since we're
not in a Python NG, I thought you'd have been able to address
the original question with your code (as a black box). In the
present form it's just useless and off-topic here. But as said,
don't bother.

Janis

On Mon, 17 Jun 2024 09:44:55 +0200, Janis Papanagnou wrote:

> IOW; I'd have to learn Python completely to understand your code and get
> the details properly.

I give you a fish, you eat for a day. You learn to fish, you eat for a
lifetime.

> In the present form it's just useless and off-topic here. But as said,
> don't bother.

Have you received a better offer yet?

In article <v4rgc5$18eq9$7@dont-email.me>,
Lawrence D'Oliveiro <ldo@nz.invalid> wrote:
>On Mon, 17 Jun 2024 09:44:55 +0200, Janis Papanagnou wrote:
>
>> IOW; I'd have to learn Python completely to understand your code and get
>> the details properly.
>
>I give you a fish, you eat for a day. You learn to fish, you eat for a
>lifetime.
>
>> In the present form it's just useless and off-topic here. But as said,
>> don't bother.
>
>Have you received a better offer yet?

Sounds like somebody's fee-fees got hurt here.

--
"Only a genius could lose a billion dollars running a casino."
"You know what they say: the house always loses."
"When life gives you lemons, don't pay taxes."
"Grab 'em by the p***y!"

Helmut Waitzmann wrote:

> If ‘p_sort’ is designed to output the sorted file names separated
> by an ASCII NUL character rather than a newline then, using the
> GNU version of ‘xargs’, one can feed that output into ‘xargs’:
>
> {
> p_sort P*.HTM 3<&- |
> xargs --null --no-run-if-empty -- sh -c \
> 'exec 0<&3 3<&- "$@"' sh \
> viewer
> } 3<&0

NUL as a record separator is also supported by several other versions
of xargs, and it is in the recently released POSIX.1-2024 standard.
In all of those it is specified with -0, so using -0 is more
portable than the GNU-specific --null.

POSIX.1-2024 also has -r although I think that's not as widely
supported in current xargs implementations as -0. It should become
better supported over time, though, so again I would suggest using -r
rather than --no-run-if-empty for better future portability.

--
Geoff Clare <netnews@gclare.org.uk>

On 14/06/2024 at 08:31, Janis Papanagnou wrote:
> I'm using ksh here...
>
> I can set the shell parameters in numerical order
>
> $ set {1..100}
>
> then sort them _lexicographically_
>
> $ set -s
>
> Or do both in one
>
> $ set -s {1..100}
>
> I haven't found anything to sort them _numerically_ in shell.
>
> What I'm trying to do is iterating over files, say,
> P1.HTM P10.HTM P11.HTM P2.HTM P3.HTM P4.HTM P5.HTM P6.HTM P7.HTM
> P8.HTM P9.HTM
> in numerical order.
>
> Setting the files as shell arguments with P*.HTM will also produce
> lexicographical order.
>
> The preceding files are just samples. It should work also if the
> numbers are non-consecutive (say, 2, 10, 10000, 3333333) so that
> iterating using a for-loop and building the list is not an option.
>
> (Ideally I'd also like to handle names with two numbers "A35P56.txt"
> and irregular string components (lowercase, say, "page310ch1.txt"),
> but that's just a nice-to-have. - I might make use of 'sort'?)
>
>
> But the primary question is; how to organize/iterate the arguments
> *numerically* _in shell_? (If that's possible in some simple way.)
>
>
> N.B.: I prefer not to use external commands like 'sort' because of
> the negative side effects and bulky code to handle newlines and
> blanks in filenames, and messing around with quotes.
>
> Janis
>

Can you use an array? E.g. (bash, I don't know ksh, but could be similar)

for i in P1.HTM P10.HTM P11.HTM P2.HTM P3.HTM P4.HTM P5.HTM P6.HTM
P7.HTM P8.HTM P9.HTM; do
j=${i//[![:digit:]]}
files[j]="$i"
done
printf '%s\n' "${files[@]}"
P1.HTM
P2.HTM
P3.HTM
P4.HTM
P5.HTM
P6.HTM
P7.HTM
P8.HTM
P9.HTM
P10.HTM
P11.HTM

I'll have to work on names with two (or more?) numbers.

--
Chris Elvidge, England
BART BUCKS, ARE NOT LEGAL TENDER

On 18.06.2024 10:26, Lawrence D'Oliveiro wrote:
>
>> In the present form it's just useless and off-topic here. But as said,
>> don't bother.
>
> Have you received a better offer yet?

Better than /dev/random ? - No, not yet. But thanks for trying.

(You gave the impression that using python would be "better".
Obviously it isn't. - Why buy a non-standard tool/solution if
I can solve the task with standard Unix tools myself. So don't
bother.)

Janis

On 18.06.2024 15:32, Chris Elvidge wrote:
> On 14/06/2024 at 08:31, Janis Papanagnou wrote:
>> I'm using ksh here...
>>
>> I can set the shell parameters in numerical order
>>
>> $ set {1..100}
>>
>> then sort them _lexicographically_
>>
>> $ set -s
>>
>> Or do both in one
>>
>> $ set -s {1..100}
>>
>> I haven't found anything to sort them _numerically_ in shell.
>>
>> What I'm trying to do is iterating over files, say,
>> P1.HTM P10.HTM P11.HTM P2.HTM P3.HTM P4.HTM P5.HTM P6.HTM P7.HTM
>> P8.HTM P9.HTM
>> in numerical order.
>>
>> Setting the files as shell arguments with P*.HTM will also produce
>> lexicographical order.
>>
>> The preceding files are just samples. It should work also if the
>> numbers are non-consecutive (say, 2, 10, 10000, 3333333) so that
>> iterating using a for-loop and building the list is not an option.
>>
>> (Ideally I'd also like to handle names with two numbers "A35P56.txt"
>> and irregular string components (lowercase, say, "page310ch1.txt"),
>> but that's just a nice-to-have. - I might make use of 'sort'?)
>>
>>
>> But the primary question is; how to organize/iterate the arguments
>> *numerically* _in shell_? (If that's possible in some simple way.)
>>
>>
>> N.B.: I prefer not to use external commands like 'sort' because of
>> the negative side effects and bulky code to handle newlines and
>> blanks in filenames, and messing around with quotes.
>>
>> Janis
>>
>
> Can you use an array? E.g. (bash, I don't know ksh, but could be similar)

Yes, Ksh supports both, indexed and associative arrays.

>
> for i in P1.HTM P10.HTM P11.HTM P2.HTM P3.HTM P4.HTM P5.HTM P6.HTM
> P7.HTM P8.HTM P9.HTM; do
> j=${i//[![:digit:]]}
> files[j]="$i"
> done
> printf '%s\n' "${files[@]}"
> P1.HTM
> P2.HTM
> P3.HTM
> P4.HTM
> P5.HTM
> P6.HTM
> P7.HTM
> P8.HTM
> P9.HTM
> P10.HTM
> P11.HTM
>
> I'll have to work on names with two (or more?) numbers.

One thing that concerns me with arrays is that I seem to recall that
there was a limit in the number of array elements (which might be an
issue on lengthy lists of files). But some ad hoc tests seem to show
that if there's a limit it's not any more in the 1k/4k elements range
as it had been. (Bolski/Korn says their arrays support at least 4k.)

Janis

On 18/06/2024 at 15:38, Janis Papanagnou wrote:
> On 18.06.2024 15:32, Chris Elvidge wrote:
>> On 14/06/2024 at 08:31, Janis Papanagnou wrote:
>>> I'm using ksh here...
>>>
>>> I can set the shell parameters in numerical order
>>>
>>> $ set {1..100}
>>>
>>> then sort them _lexicographically_
>>>
>>> $ set -s
>>>
>>> Or do both in one
>>>
>>> $ set -s {1..100}
>>>
>>> I haven't found anything to sort them _numerically_ in shell.
>>>
>>> What I'm trying to do is iterating over files, say,
>>> P1.HTM P10.HTM P11.HTM P2.HTM P3.HTM P4.HTM P5.HTM P6.HTM P7.HTM
>>> P8.HTM P9.HTM
>>> in numerical order.
>>>
>>> Setting the files as shell arguments with P*.HTM will also produce
>>> lexicographical order.
>>>
>>> The preceding files are just samples. It should work also if the
>>> numbers are non-consecutive (say, 2, 10, 10000, 3333333) so that
>>> iterating using a for-loop and building the list is not an option.
>>>
>>> (Ideally I'd also like to handle names with two numbers "A35P56.txt"
>>> and irregular string components (lowercase, say, "page310ch1.txt"),
>>> but that's just a nice-to-have. - I might make use of 'sort'?)
>>>
>>>
>>> But the primary question is; how to organize/iterate the arguments
>>> *numerically* _in shell_? (If that's possible in some simple way.)
>>>
>>>
>>> N.B.: I prefer not to use external commands like 'sort' because of
>>> the negative side effects and bulky code to handle newlines and
>>> blanks in filenames, and messing around with quotes.
>>>
>>> Janis
>>>
>>
>> Can you use an array? E.g. (bash, I don't know ksh, but could be similar)
>
> Yes, Ksh supports both, indexed and associative arrays.
>
>>
>> for i in P1.HTM P10.HTM P11.HTM P2.HTM P3.HTM P4.HTM P5.HTM P6.HTM
>> P7.HTM P8.HTM P9.HTM; do
>> j=${i//[![:digit:]]}
>> files[j]="$i"
>> done
>> printf '%s\n' "${files[@]}"
>> P1.HTM
>> P2.HTM
>> P3.HTM
>> P4.HTM
>> P5.HTM
>> P6.HTM
>> P7.HTM
>> P8.HTM
>> P9.HTM
>> P10.HTM
>> P11.HTM
>>
>> I'll have to work on names with two (or more?) numbers.
>
> One thing that concerns me with arrays is that I seem to recall that
> there was a limit in the number of array elements (which might be an
> issue on lengthy lists of files). But some ad hoc tests seem to show
> that if there's a limit it's not any more in the 1k/4k elements range
> as it had been. (Bolski/Korn says their arrays support at least 4k.)
>
> Janis
>

I tested in ksh - works as written.

From here:
https://unix.stackexchange.com/questions/195191/ksh-bash-maximum-size-of-an-array

<quote>

This simple script shows on my systems (Gnu/Linux and Solaris):

ksh88 limits the size to 2^12-1 (4095). (subscript out of range ).
Some older releases like the one on HP-UX limit the size to 1023.

ksh93 limits the size of a array to 2^22-1 (4194303), your mileage
may vary.

bash doesn't look to impose any hard-coded limit outside the one
dictated by the underlying memory resources available. For example bash
uses 1.3 GB of virtual memory for an array size of 18074340.

</quote>

--
Chris Elvidge, England
BART BUCKS, ARE NOT LEGAL TENDER

I've just tried a Unix tools based solution (with sed, sort, cut).

Up to and including the line containing 'shuf' is data generation,
the rest (starting with 'sed') extracts and sorts the data. I've
written it for TWO numeric sort keys (see printf format specifier)

for (( i=1; i<=50; i++ ))
do
for (( j=2; j<=120; j+=3 ))
do
printf "a%db%dc.txt\n" i j
done
done |
shuf |

sed 's/[^0-9]*\([0-9]\+\)[^0-9]*\([0-9]\+\)[^0-9]*/\1\t\2\t&/' |
sort -t$'\t' -k1n -k2n |
cut -f3-

For just one numeric argument this can be simplified (shorter sed
pattern, simpler sort -n command), and for more than two numeric
fields it can be modified to dynamically construct the sed pattern,
the sort option list, and the cut parameter, once at the beginning;
that way we could have a tool for arbitrary amounts of numeric keys
in the file name.

Note: this program doesn't handle pathological filenames (newlines).

Janis

On 14.06.2024 09:31, Janis Papanagnou wrote:
> I'm using ksh here...
>
> I can set the shell parameters in numerical order
>
> $ set {1..100}
>
> then sort them _lexicographically_
>
> $ set -s
>
> Or do both in one
>
> $ set -s {1..100}
>
> I haven't found anything to sort them _numerically_ in shell.
>
> What I'm trying to do is iterating over files, say,
> P1.HTM P10.HTM P11.HTM P2.HTM P3.HTM P4.HTM P5.HTM P6.HTM P7.HTM
> P8.HTM P9.HTM
> in numerical order.
>
> Setting the files as shell arguments with P*.HTM will also produce
> lexicographical order.
>
> The preceding files are just samples. It should work also if the
> numbers are non-consecutive (say, 2, 10, 10000, 3333333) so that
> iterating using a for-loop and building the list is not an option.
>
> (Ideally I'd also like to handle names with two numbers "A35P56.txt"
> and irregular string components (lowercase, say, "page310ch1.txt"),
> but that's just a nice-to-have. - I might make use of 'sort'?)
>
>
> But the primary question is; how to organize/iterate the arguments
> *numerically* _in shell_? (If that's possible in some simple way.)
>
>
> N.B.: I prefer not to use external commands like 'sort' because of
> the negative side effects and bulky code to handle newlines and
> blanks in filenames, and messing around with quotes.
>
> Janis
>

On 18.06.2024 17:19, Chris Elvidge wrote:
> On 18/06/2024 at 15:38, Janis Papanagnou wrote:
[...]
>> One thing that concerns me with arrays is that I seem to recall that
>> there was a limit in the number of array elements (which might be an
>> issue on lengthy lists of files). But some ad hoc tests seem to show
>> that if there's a limit it's not any more in the 1k/4k elements range
>> as it had been. (Bolski/Korn says their arrays support at least 4k.)
>
> I tested in ksh - works as written.
>
> From here:
> https://unix.stackexchange.com/questions/195191/ksh-bash-maximum-size-of-an-array
>
>
> <quote>
>
> This simple script shows on my systems (Gnu/Linux and Solaris):
>
> ksh88 limits the size to 2^12-1 (4095). (subscript out of range ).
> Some older releases like the one on HP-UX limit the size to 1023.

Yeah, I recall these limits from ksh88 on AIX and HP-UX.

>
> ksh93 limits the size of a array to 2^22-1 (4194303), your mileage
> may vary.

I've tried on my system just with a million names (yet more
filenames than we want to have in our directories in one place).

>
> bash doesn't look to impose any hard-coded limit outside the one
> dictated by the underlying memory resources available. For example bash
> uses 1.3 GB of virtual memory for an array size of 18074340.

I didn't notice a limit for my old Bash or Ksh on my system.

So your array approach looks promising for one numeric key, and
it's a nice and terse solution.

Janis

>
> </quote>
>

On 18.06.2024 19:12, Janis Papanagnou wrote:
>
> So your array approach looks promising for one numeric key, and
> it's a nice and terse solution.

Forgot to praise its nice property to also handle newlines in the
filenames.

> Janis