← Back to context

Comment by tkocmathla

13 hours ago

I love this, from a comment on the article:

  He had in his path a script called `\#` that he used to comment out pipe elements like `mycmd1 | \# mycmd2 | mycmd3`. This was how the script was written:
 
  ```
  #!/bin/sh
  cat
  ```

13 comments

tkocmathla

Reply
rgrau  12 hours ago

A similar trick:

    #!/bin/sh
    $*

that's my `~/bin/noglob` file, so when I call a zsh script from bash that uses `noglob`, it doesn't blow up.

mzs  5 hours ago

Wow I hate* that. I use bracket comments. They're cool cause they are bracket comments, so I use it in scripts to document pipelines. They are annoying cause they are bracket comments, in an interactive shell I have to type more and in TWO places. It's fun to reason-out how it works ;)

  $ echo foo | tr fo FO | sed 's/FOO/BAR/'
  BAR
  $ echo foo | ${IFS# tr fo FO | } sed 's/FOO/BAR/'
  foo

It's nice to have a way to both /* ... */ and // ... in shell scripts though:

  foo \
  | bar ${IFS Do the bar. Do it. } \
  | baz

* in the best possible way, like it's awful - I hate I didn't think of that

  • rgrau  5 hours ago

    for multiline pipes, it's WAY better to format like

        foo   |
      bar |
      baz

    You don't have to use backquotes, AND, it allows you to comment line by line, because there's no backslash messing with the parser.

    I also use a last `|\ncat` so you can delete any line and you don't have to worry about the last line being a bit different than the rest

    I created a list of similar tricks in https://github.com/kidd/scripting-field-guide in case anyone wants to take a look

    • mzs  3 hours ago

      You'll probably dislike this too:

        $ {
  >     echo foo \
  >     && echo bar \
  >     || echo baz ;
  > }
  foo
  bar
  <^P><^A>$<^F>IFS
  ${IFS#   echo foo   && echo bar   || echo baz ; }
  $ _

      There's good and bad to both approaches. I like how I can use () and {} to bracket things and otherwise every line that end in \ is continued. I line-up on the left with the operator, you with indentation. When you use a # style comment, you have to look up and back and forward to see what the operator is you are continuing over to the next line:

        $ foo |
    bar | # ?Do? *the* $bar$ && [do] {it!}
    baz

      Which only takes an extra neuron or so, but then history...

        <^P>
  $ foo |   bar | # ?Do? *the* $bar$ && [do] {it!}
  baz

      1 reply →

000ooo000  12 hours ago

What does it provide over

mycmd1 #| mycmd2

  • chriswarbo  11 hours ago

    Theirs "turns off" one element of a pipeline; yours turns off everything after a certain point.

    This will output the stdout of mycmd1:

        mycmd1 #| mycmd2 | mycmd3

    This will output the stdout of mycmd3:

        mycmd1 | \# mycmd2 | mycmd3

    • mkoryak  10 hours ago

      Can you explain to me why either of these is useful?

      I've somehow gotten by never really needing to pipe any commands in the terminal, probably because I mostly do frontend dev and use the term for starting the server and running prodaccess

      3 replies →