On Saturday, 4 September 2021 at 15:41:51 UTC, eXodiquas wrote:
Hello everyone,
I created a small little D program that reads in a string from
the command line and shuffles the letters of the nouns a bit
around. This is pretty straight forward, but what I see now
happening is a bit strange, at least for me.
I am reading the args out of the main function arguments.
```d
void main(string[] args) {
args.writeln();
}
```
this works fine whenever I call the program like
`./nounscramble "Hello, my name is Earl!"` the string shows up
in `args[1]`. But when I call `echo "Hello, my name is Earl!" |
./nounscramble` it does not show up in the args array, the only
thing showing up is the name of the executable (which is
expected).
My question is now, can someone explain what I am doing wrong?
Maybe I misunderstood the pipe in Linux systems and it is
obvious for someone who knows how this works exactly, or maybe
D works differently with pipes and I havn't found the correct
documentation.
Thanks in advance. :)
eXodiquas
to extend on Brian Tiffin's reply, you can read from the standard
input stream (the data piped to your program) using std.stdio's
`stdin`
Example:
```d
import std.stdio;
foreach (line; stdin.byLine)
writeln("got input line: ", line);
// IMPORTANT: the line buffer is reused (it's a char[], not a
string), so if you want to store it in a variable outside the
foreach, use .idup to make it a string (that is not changed when
leaving the loop)
```
or
```d
import std.stdio;
foreach (chunk; stdin.byChunk(1024))
writeln("got input chunk: ", cast(char[])chunk);
// same warning as above, don't case to string (that's unsafe and
wouldn't be allowed in @safe code, but casting to char[] is safe,
as it explicitly says it can be changed)
```
or
```d
import std.stdio;
ubyte[1024] buffer;
auto part = cast(char[])stdin.rawRead(buffer[]);
writeln("got part: ", part);
// this is the lower level equivalent of the byChunk above, it's
just doing a single step instead of multiple chunks, so you
control when it is changed.
// a slice of this buffer (which is what the return value is)
needs to be .idup'd to be persisted outside the lifetime of the
`buffer` variable
```
