Extract file extension: Difference between revisions

 

=={{header|ALGOL 68}}==

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

<lang algol68># extracts a file-extension from the end of a pathname. The file extension is #

 

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

<lang algolw>begin

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

 

=={{header|AWK}}==

<lang AWK>

# syntax: GAWK -f EXTRACT_FILE_EXTENSION.AWK

file.odd_one ''

</pre>

=={{header|C}}==

<lang C>

#include <assert.h>

 

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

<lang cpp>#include <string>

#include <algorithm>

 

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

<lang [[C sharp|C#]]>public static string FindExtension(string filename) {

int indexOfDot = filename.Length;

 

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

<lang Lisp>(file-name-extension "foo.txt")

=>

 

=={{header|Forth}}==

<lang forth>: invalid? ( c -- f )

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

 

=={{header|Fortran}}==

The plan is to scan backwards from the end of the text until a non-extensionish character is encountered. If it is a period, then a valid file extension has been spanned. Otherwise, no extension. Yet again the "no specification" on the possibility of shortcut evaluation of compound logical expressions prevents the structured use of a DO WHILE(L1 > 0 & etc) loop because the possible evaluation of both parts of the expression means that the second part may attempt to access character zero of a text. So, the compound expression has to be broken into two separate parts.

 

 

=={{header|Go}}==

<lang go>package main

 

)

 

func Ext(path string) string {

for i := len(path) - 1; i >= 0 && path[i] != '/'; i-- {

 

=={{header|Haskell}}==

<lang Haskell>module FileExtension

where

 

=={{header|J}}==

 

'''Implementation:'''

 

=={{header|Java}}==

<lang java>public class Test {

 

 

=={{header|jq}}==

 

Pending resolution of the inconsistency in the task description as of this writing, the following

 

=={{header|Lua}}==

<lang Lua>-- Lua pattern docs at http://www.lua.org/manual/5.1/manual.html#5.4.1

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

 

=={{header|Oforth}}==

If extension is not valid, returns null, not "".

Easy to change if "" is required.

s extract(i, s size)

} </lang>

 

{{out}}

 

=={{header|Phix}}==

<lang Phix>function getExtension(string filename)

for i=length(filename) to 1 by -1 do

 

=={{header|PowerShell}}==

<lang PowerShell>

function extension($file){

 

=={{header|Python}}==

Uses [https://docs.python.org/3/library/os.path.html#os.path.splitext os.path.splitext] and the extended tests from the Go example above.

 

 

=={{header|Racket}}==

<lang Racket>#lang racket

 

 

=={{header|REXX}}==

Using this paraphrased Rosetta Code task's definition that:

 

 

=={{header|sed}}==

<lang sed>s:.*\.:.:

s:\(^[^.]\|.*[/_]\).*::</lang> or <lang bash>sed -re 's:.*\.:.:' -e 's:(^[^.]|.*[/_]).*::'</lang>

 

=={{header|Sidef}}==

<lang ruby>func extension (filename) {

given(filename.split('.').last) {

 

=={{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.

 

=={{header|VBScript}}==

<lang vb>

Function GetExtension(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).

<lang zkl>valid:=Walker.chain(".",["a".."z"],["A".."Z"],["0".."9")).sink(String).walk();