Extract file extension: Difference between revisions

{{draft task}}

[[wp:Filename extension|Filename extensions]] are a rudimentary but commonly used way of identifying files types.

 

 

Write a function or program that

* takes one string argument representing the path/URL to a file

 

 

 

 

* occurs at the very end of the filename

* consists of a period, followed solely by one or more ASCII letters or digits (A-Z, a-z, 0-9)

 

 

|-

! Input

|}

 

 

=={{header|11l}}==

 

{{trans|Python}}

V m = re:‘\.[A-Za-z0-9]+$’.search(path)

R I m {m.group(0)} E ‘’

 

L(path) paths

{{out}}

<pre>

document.txt_backup ->

/etc/pam.d/login ->

</pre>

 

 

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

# defined as a dot followed by one or more letters or digits #

OP EXTENSION = ( STRING pathname )STRING:

; test extension( "document.txt_backup", "" )

; test extension( "/etc/pam.d/login", "" )

{{out}}

<pre>

=={{header|ALGOL W}}==

 

% extracts a file-extension from the end of a pathname. %

% The file extension is defined as a dot followed by one or more letters %

testExtension( "/etc/pam.d/login", "" );

 

{{out}}

<pre>

 

===Vanilla===

set astid to AppleScript's text item delimiters

-- Extract the file or bundle name from the path.

end repeat

 

 

{{output}}

AppleScriptObjectiveC makes the task a little easier, but not necessarily more efficient.

 

use framework "Foundation"

 

end repeat

 

 

{{output}}

<pre>{{"http://example.com/download.tar.gz", ".gz"}, {"CharacterModel.3DS", ".3DS"}, {".desktop", ".desktop"}, {"document", ""}, {"document.txt_backup", ""}, {"/etc/pam.d/login", ""}}</pre>

 

 

{{out}}

 

=={{header|AWK}}==

The first one was provided by an earlier contributor and shows a little more awk syntax and builtins (albeit with a bug fixed: it was testing for underscores in the extension but not other characters such as hyphens). It can be adjusted to allow any character in the extension other than /, \, : or . by replacing <code>[^a-zA-Z0-9]</code> with <code>[\\/\\\\:\\.]</code>.

 

BEGIN {

arr[++i] = "picture.jpg"

return(fn)

}

 

The second method is shorter and dispenses with the need to search for and remove the path components first. It too can be modified to allow all valid extensions (not just those described in the specification), by replacing <code>\\.[A-Za-z0-9]+$</code> with <code>\\.[^\\/\\\\:\\.]+$</code>.

 

BEGIN {

arr[++i] = "picture.jpg"

}

}

<p>Both examples give the output:</p>

<pre>

 

=={{header|Batch File}}==

 

:loop

echo File Path: "%~1" ^| File Extension "%~x1"

shift

{{out}}

<pre>File Path: "http://example.com/download.tar.gz" | File Extension ".gz"

File Path: "document.txt_backup" | File Extension ".txt_backup"

File Path: "/etc/pam.d/login" | File Extension ""</pre>

 

=={{header|C}}==

 

#include <ctype.h>

#include <string.h>

}

return exitcode;

 

=={{header|C sharp|C#}}==

 

int indexOfDot = filename.Length;

for (int i = filename.Length - 1; i >= 0; i--) {

//so if the last character is a dot, return the empty string

return indexOfDot + 1 == filename.Length ? "" : filename.Substring(indexOfDot);

 

'''Using regular expressions (C# 6)'''

 

=={{header|C++}}==

 

 

{{out}}

 

=={{header|Clojure}}==

(defn file-extension [s]

(second (re-find #"(\.[a-zA-Z0-9]+)$" s)))

 

{{out}}

(".gz" ".3DS" ".desktop" nil nil nil)

</pre>

 

=={{header|Common Lisp}}==

 

=>

 

=={{header|D}}==

=== Variant 1===

import std.stdio;

import std.path;

}

 

{{out}}

 

=== Variant 2===

import std.stdio;

import std.string;

}

 

{{out}}

<pre>

/etc/pam.d/login ->

</pre>

 

=={{header|Emacs Lisp}}==

 

=>

 

No extension is distinguished from empty extension but an <code>(or ... "")</code> can give <code>""</code> for both if desired

 

 

An Emacs backup <code>~</code> or <code>.~NUM~</code> are not part of the extension, but otherwise any characters are allowed.

 

 

=={{header|Factor}}==

Factor's <tt>file-extension</tt> word allows symbols to be in the extension and omits the dot from its output.

sequences ;

IN: rosetta-code.file-extension

"Path" "| Extension" "%-35s%s\n" printf

47 [ "-" write ] times nl

{{out}}

<pre>

=={{header|Forth}}==

 

toupper dup [char] A [char] Z 1+ within

swap [char] 0 [char] 9 1+ within or 0= ;

s" document" test

s" document.txt_backup" test

{{out}}

<pre>cr tests

The source incorporates a collection of character characterisations via suitable spans of a single sequence of characters. Unfortunately, the PARAMETER statement does not allow its constants to appear in EQUIVALENCE statements, so the text is initialised by DATA statements, and thus loses the protection of read-only given to constants defined via PARAMETER statements. The statements are from a rather more complex text scanning scheme, as all that are needed here are the symbols of GOODEXT.

 

CHARACTER*10 DIGITS !Integer only.

CHARACTER*11 DDIGITS !With a full stop masquerading as a decimal point.

WRITE (6,*) FEXT("/etc/pam.d/login")

WRITE (6,*) "Approved characters: ",GOODEXT

The output cheats a little, in that trailing spaces appear just as blankly as no spaces. The result of FEXT could be presented to TRIM (if that function is available), or the last non-blank could be found. With F2003, a scheme to enable character variables to be redefined to take on a current length is available, and so trailing spaces could no longer appear. This facility would also solve the endlessly annoying question of "how long is long enough", manifested in parameter MEXT being what might be a perfect solution. Once, three was the maximum extension length (not counting the period), then perhaps six, but now, what?

<pre>

 

=={{header|FreeBASIC}}==

 

Function isAlphaNum(s As String) As Boolean

Print

Print "Press any key to quit"

 

{{out}}

document.txt_backup (empty string)

/etc/pam.d/login (empty string)

</pre>

 

'''[https://gambas-playground.proko.eu/?gist=d52464fe8c05c857311d49184299814a Click this link to run this code]'''

Dim sDir As String = "/sbin"

Dim sFileList As String[] = Dir(sDir)

Next

 

Output:

<pre>

=={{header|Go}}==

 

 

import "fmt"

}

}

 

=={{header|Haskell}}==

 

where

 

where

extension = reverse ( takeWhile ( /= '.' ) $ reverse s )

{{out}}

<pre>map myextension ["http://example.com/download.tar.gz", "CharacterModel.3DS", ".desktop", "document", "document.txt_backup", "/etc/pam.d/login"]

On Unix systems, the penultimate file extension would be recognised, so using the Haskell library function '''takeExtension''':

 

 

fps :: [FilePath]

fps =

]

main :: IO ()

{{Out}}

<pre>".gz"

'''Implementation:'''

 

 

Obviously most of the work here is done by the regex implementation ([[wp:Perl Compatible Regular Expressions|pcre]], if that matters - and this particular kind of expression tends to be a bit more concise expressed in [[Perl|perl]] than in J...).

 

'''Alternative non-regex Implementation'''

 

 

'''Task examples:'''

.gz

ext 'CharacterModel.3DS'

┌───┬────┬────────┬┬┬┐

│.gz│.3DS│.desktop││││

 

=={{header|Java}}==

 

}

{{Out}}

 

=={{header|javascript}}==

let r = /\.[a-zA-Z0-9]+$/;

{{Out}}

<pre>http://example.com/download.tar.gz -> .gz

One approach is to define a more general curried function, from which we can obtain various simpler and OS-specific functions by specialisation:

 

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>

 

{{works with|jq| 1.4}}

def alphanumeric: explode | unique

| reduce .[] as $i

end

else ""

 

{{works with|jq|1.5}}

(match( "(\\.[a-zA-Z0-9]*$)" ) | .captures[0].string)

 

'''Examples''':

 

Using either version above gives the same results.

"CharacterModel.3DS",

".desktop",

"document.txt_backup",

"/etc/pam.d/login"

 

{{out}}

<pre>http://example.com/download.tar.gz has extension: .gz

 

=={{header|Jsish}}==

/* Extract filename extension (for a limited subset of possible extensions) in Jsish */

function extractExtension(filename) {

/etc/pam.d/login ""

=!EXPECTEND!=

 

{{out}}

 

=={{header|Julia}}==

 

@show extension("http://example.com/download.tar.gz")

@show extension("document")

@show extension("document.txt_backup")

 

{{out}}

 

=={{header|Kotlin}}==

 

val r = Regex("[^a-zA-Z0-9]") // matches any non-alphanumeric character

println("${path.padEnd(37)} -> ${if (ext.isEmpty()) "(empty string)" else ext}")

}

 

{{out}}

 

=={{header|Lua}}==

function fileExt (filename) return filename:match("(%.%w+)$") or "" end

for _, example in pairs(testCases) do

print(example .. ' -> "' .. fileExt(example) .. '"')

{{out}}

<pre>http://example.com/download.tar.gz -> ".gz"

/etc/pam.d/login -> ""</pre>

 

FileExtension is a built-in function:

{{out}}

{"gz", "3DS", "", "", "txt_backup", ""}

=={{header|Nanoquery}}==

The File object type in Nanoquery has a built-in method to extract the file extension from a filename, but it treats all characters as potentially valid in an extension and URLs as not being. As a result, the .txt_backup extension is included in the output.

 

filenames = {"http://example.com/download.tar.gz", "CharacterModel.3DS"}

for fname in filenames

println new(File, fname).getExtension()

{{out}}

<pre>.gz

.txt_backup

</pre>

 

=={{header|Objeck}}==

 

class FindExtension {

return ext;

}

 

{{output}}

=={{header|OCaml}}==

Since OCaml 4.04 there is a function '''[http://caml.inria.fr/pub/docs/manual-ocaml/libref/Filename.html#VALextension Filename.extension]''':

let filenames = [

"http://example.com/download.tar.gz";

List.iter (fun filename ->

Printf.printf " '%s' => '%s'\n" filename (Filename.extension filename)

differs a little bit from the specification of this task.

{{out}}

Easy to change if "" is required.

 

| i |

s lastIndexOf('.') dup ->i ifNull: [ null return ]

s extract(i 1+, s size) conform(#isAlpha) ifFalse: [ null return ]

s extract(i, s size)

 

{{out}}

null ok

></pre>

 

=={{header|Perl}}==

 

{{trans|Raku}}

my $path = shift;

$path =~ / \. [a-z0-9]+ $ /xi;

$& // '';

 

Testing:

for qw[

http://example.com/download.tar.gz

document.txt_backup

/etc/pam.d/login

 

{{out}}

 

=={{header|Phix}}==

{{out}}

<pre>

</pre>

The builtin get_file_extension() could also be used, however that routine differs from the task description in that "libglfw.so.3.1" => "so", and all results are lowercase even if the input is not.

 

=={{header|PicoLisp}}==

(and

(fully

(println (extension "document"))

(println (extension "document.txt_backup"))

{{out}}

<pre>

NIL

NIL

</pre>

 

=={{header|PowerShell}}==

$ext = [System.IO.Path]::GetExtension($file)

if (-not [String]::IsNullOrEmpty($ext)) {

extension "document"

extension "document.txt_backup"

<b>Output:</b>

<pre>.gz

Uses [https://docs.python.org/3/library/re.html#re.search re.search].

 

def extractExt(url):

m = re.search(r'\.[A-Za-z0-9]+$', url)

return m.group(0) if m else ""

 

and one way of allowing for OS-specific variations in the character sets permitted in file extensions is to write a general and reusable curried function, from which we can obtain simpler OS-specific functions by specialisation:

 

 

import os

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>takePosixExtension :: FilePath -> String:

document.txt_backup ->

/etc/pam.d/login -> </pre>

 

=={{header|Racket}}==

 

#lang racket

 

(for ([x (in-list examples)])

(printf "~a | ~a\n" (~a x #:width 34) (string-extension x)))

 

{{out}}

The built-in <code>IO::Path</code> class has an <code>.extension</code> method:

 

Contrary to this task's specification, it

* doesn't include the dot in the output

Here's a custom implementation which does satisfy the task requirements:

 

$path.match(/:i ['.' <[a..z0..9]>+]? $ /).Str

}

document.txt_backup

/etc/pam.d/login

 

{{out}}

 

a legal file extension &nbsp; ''only'' &nbsp; consists of mixed-case Latin letters and/or decimal digits.

@.= /*define default value for the @ array.*/

parse arg fID /*obtain any optional arguments from CL*/

else x= . || x /*prefix the extension with a period. */

say 'file extension=' left(x, 20) "for file name=" @.j

'''output''' &nbsp; when using the default (internal) inputs:

<pre>

 

=={{header|Ring}}==

# Project : Extract file extension

 

next

return cStr2

Output:

<pre>

 

=={{header|Ruby}}==

%w(http://example.com/download.tar.gz

CharacterModel.3DS

/etc/pam.d/login)

names.each{|name| p File.extname(name)}

'''output'''

<pre>

 

=={{header|Rust}}==

 

fn main() {

.filter(|ext| ext.chars().skip(1).all(|c| c.is_ascii_alphanumeric()))

.unwrap_or("")

The built-in method requires a filename before the extension, allows any non-period character to appear in the extension, and returns <code>None</code> if no extension is found.

{{out}}

 

=={{header|Scala}}==

 

object FileExt {

println("Url: " + url + " -> Extension: " + FileExt.extractExt(url))

}

'''output'''

<pre>

=={{header|sed}}==

 

 

Example of use:

do

echo "$F: $EXT"

done

{{out}}

<pre>

 

=={{header|Sidef}}==

filename.match(/(\.[a-z0-9]+)\z/i).to_s

}

files.each {|f|

printf("%-36s -> %-11s\n", f.dump, extension(f).dump)

{{out}}

<pre>

"/etc/pam.d/login" -> ""

</pre>

 

=={{header|Tcl}}==

Tcl's built in [http://wiki.tcl.tk/10072 file extension] command already almost knows how to do this, except it accepts any character after the dot. Just for fun, we'll enhance the builtin with a new subcommand with the limitation specified for this problem.

 

if {![uplevel 1 [list expr $expr]]} {

set msg "{$expr}"

set res ""

assert {[file ext $file] eq $ext}

 

=={{header|TUSCRIPT}}==

$$ MODE DATA

$$ testcases=*

PRINT testcase, " has extension ", extension

ENDLOOP

Output:

<pre>

 

=={{header|VBScript}}==

Set fso = CreateObject("Scripting.FileSystemObject")

Set regex = new regExp

Wscript.Echo "NAME:",name

Wscript.Echo " EXT:","<" & fileExt(name) & ">"

 

{{Out}}

=={{header|Visual Basic}}==

{{works with|Visual Basic|6}}

'-----------------------------------------------------------------

Function ExtractFileExtension(ByVal Filename As String) As String

s = "a.b.1~2"

Debug.Assert ExtractFileExtension(s) = ""

 

=={{header|zkl}}==

 

The File object has a method splitFileName that does just that, returning a list of the parts. The method knows about the OS it was compiled on (Unix, Windows).

var [const] valid=Walker.chain(".",["a".."z"],["A".."Z"],["0".."9")).pump(String);

ext:=File.splitFileName(name)[-1];

if(ext - valid) ext="";

ext

".desktop","document",

"document.txt_backup","/etc/pam.d/login")){

println("%35s : %s".fmt(nm,extractFileExtension(nm)));

{{out}}

Note: on Unix, .desktop is a hidden file, not an extension.