fish shell: Is it possible to conveniently strip extensions?

Question

Is there any convenient way to strip an arbitrary extension from a file name, something à la bash ${i%%.*}? Do I stick to my friend sed?

Answer 1

If you know the extension (eg _bak, a common usecase) this is possibly more convenient:

    for f in (ls *_bak)
        mv $f (basename $f _bak)
    end

Answer 2

--- Update 2022-08-02 ---

As of fish 3.5+, there is a path command (docs) which was designed to handle stripping extensions:

$ touch test.txt.bak
$ path change-extension '' ./test.txt.bak
test.txt

You can also strip a set number of extensions:

set --local file ./test.txt.1.2.3
for i in (seq 3)
   set file (path change-extension '' $file)
end
echo $file
# ./test.txt

Or strip all extensions:

set --local file ./test.txt.1.2.3
while path extension $file
    set file (path change-extension '' $file)
end
echo $file
# ./test

---

--- Original answer ---

The fish string command is still the canonical way to handle this. It has some really nice sub commands that haven't been shown in other answers yet.

split lets you split from the right with a max of 1, so that you just get the last extension.

for f in *
    echo (string split -m1 -r '.' "$f")[1]
end

replace lets you use a regex to lop off the extension, defined as the final dot to the end of the string

for f in *
    string replace -r '\.[^\.]*$' '' "$f"
end

man string for more info and some great examples.

Update:

If your system has proper basename and dirname utilities, you can use something like this:

function stripext \
    --description "strip file extension"
    
    for arg in $argv
        echo (dirname $arg)/(string replace -r '\.[^\.]+$' '' (basename $arg))
    end
end

Answer 3

Nope. fish has a much smaller feature set than bash, relying on external commands:

$ set filename foo.bar.baz
$ set rootname (echo $filename | sed 's/\.[^.]*$//')
$ echo $rootname
foo.bar

Answer 4

You can strip off the extension from a filename using the string command:

echo (string split -r -m1 . $filename)[1]

This will split filename at the right-most dot and print the first element of the resulting list. If there is no dot, that list will contain a single element with filename.

If you also need to strip off leading directories, combine it with basename:

echo (basename $filename | string split -r -m1 .)[1]

In this example, string reads its input from stdin rather than being passed the filename as a command line argument.

Answer 5

With the string match function built into fish you can do

set rootname (string match -r "(.*)\.[^\.]*\$" $filename)[2]

The string match returns a list of 2 items. The first is the whole string, and the second one is the first regexp match (the stuff inside the parentheses in the regex). So, we grab the second one with the [2].

Answer 6

I too need a function to split random files root and extension. Rather than re-implementing naively the feature at the risk of meeting caveats (ex: dot before separator), I am forwarding the task to Python's built-in POSIX path libraries and inherit from their expertise.

Here is an humble example of what one may prefer:

function splitext --description "Print filepath(s) root, stem or extension"

    argparse 'e/ext' 's/stem' -- $argv

    for arg in $argv
        if set -q _flag_ext
            set cmd 'import os' \
                    "_, ext = os.path.splitext('$arg')" \
                    'print(ext)'
        else if set -q _flag_stem
            set cmd 'from pathlib import Path' \
                    "p = Path('$arg')" \
                    'print(p.stem)'
        else
            set cmd 'import os' \
                    "root, _ = os.path.splitext('$arg')" \
                    'print(root)'
        end
        python3 -c (string join ';' $cmd)
    end

end

Examples:

$ splitext /this/is.a/test.path
/this/is.a/test
$ splitext --ext /this/is.a/test.path
.path
$ splitext --stem /this/is.a/test.path
test
$ splitext /this/is.another/test
/this/is.another/test