Skip Navigation
14 comments

  • The author it trying to solve non-existing problem with the tool that does not meet requirements that he presented himself.

     
            $ ifconfig ens33 | grep inet | awk '{print $2}' | cut -d/ -f1 | head -n 1

    Yeah, it's awful. But wait… Could one achieve this a simpler way? Assume we never heard about ifconfig deprecation (how many years ago? 15 or so?). Let's see at ifconfig output on my machine:

     
        
ens33: flags=4163  mtu 1500
        inet 198.51.100.2  netmask 255.255.255.0  broadcast 255.255.255.255
        inet6 fe80::12:3456  prefixlen 64  scopeid 0x20
        ether c8:60:00:12:34:56  txqueuelen 1000  (Ethernet)
        RX packets 29756  bytes 13261938 (12.6 MiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 5657  bytes 725489 (708.4 KiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

    Seems that the cut part of pipeline is not needed because netmask is specified separately. The purpose of head part is likely to avoid printing IPv6 address, but this could be achieved by modifying a regular expression. So we get:

     
            $ ifconfig ens33 | grep '^\s*inet\s' | awk '{print $2}'

    If you know a bit more about awk than only print command, you change this to

     
            $ ifconfig ens33 | awk '/^\s*inet\s/{print $2}'

    But now remember that ifconfig has been replaced with the ip command (author knows about it, he uses it in the article, but not in this example that must show how weird are "traditional" pipelines). It allows to use format that is easier to parse and that is more predictable. It is also easy to ask it not to print information that we don't need:

     
            $ ip -brief -family inet address show dev ens33
    ens33            UP             198.51.100.2/24

    It has not only the advantage that we don't need to filter out any lines, but also that output format is unlikely to change in future versions of ip while ifconfig output is not so predictable. However we need to split a netmask:

     
        
$ ip -brief -family inet address show dev ens33 | awk '{ split($3, ip, "/"); print ip[1] }'
198.51.100.2

    The same without awk, in plain shell:

     
            $ ip -brief -family inet address show dev ens33 | while read _ _ ip _; do echo "${ip%/*}"; done

    Is it better than using JSON output and jq? It depends. If you need to obtain IP address in unpredictable environment (i. e. in end-user system that you know nothing about), you cannot rely on jq because it is never installed by default. On your own system or system that you administer the choice is between learning awk and learning jq because both are quite complex. If you already know one, just use it.

    Where is a place for the jc tool here? There's no. You don't need to parse ifconfig output, ifconfig is not even installed by default in most modern Linux distros. And jc has nothing common with UNIX philosophy because it is not a simple general purpose tool but an overcomplicated program with hardcoded parsers for texts, formats of which may vary breaking that parsers. Before parsing an output of command that is designed for better readability, you should ask yourself: how can I get the same information in parseable form? You almost always can.

  • And there is also Nushell and similar projects. Nushell has a concept with the same purpose as jc where you can install Nushell frontend functions for familiar commands such that the frontends parse output into a structured format, and you also get Nushell auto-completions as part of the package. Some of those frontends are included by default.

    As an example if you run ps you get output as a Nushell table where you can select columns, filter rows, etc. Or you can run ^ps to bypass the Nushell frontend and get the old output format.

    Of course the trade-off is that Nushell wants to be your whole shell while jc drops into an existing shell.

  • I rather like this idea.

    Basically take all of the "let's all write parsers now" work of handling the plain text output of *nix coreutils and bundle all of that work into a single tool. JSON is then the structured output data format, which should then replace all of the parsing work with querying work, which should be nicer and easier.

    Backwards compatible, kinda unix-y, optional and should play nice with existing tooling. I hope it works out!

14 comments