File extension is in extensions list: Difference between revisions

 

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

 

 

Given an arbitrary filename and a list of extensions, tell whether the filename has one of those extensions.

 

Notes:

 

;''Extra credit:''

: Please state clearly whether or not your solution does this.

 

The following test cases all assume this list of extensions: &nbsp; <code>zip</code>, <code>rar</code>, <code>7z</code>, <code>gz</code>, <code>archive</code>, <code>A##</code>

 

|-

! Filename

If your solution does the extra credit requirement, add <code>tar.bz2</code> to the list of extensions, and check the following additional test cases:

 

|-

! Filename

{{task heading|Motivation}}

 

 

It also requires less assumptions about the format of an extension, because the calling code can decide what extensions are valid.

For these reasons, this task exists in addition to the [[Extract file extension]] task.

 

 

* [[Extract file extension]]

* [[String matching]]

 

 

=={{header|AWK}}==

 

 

# syntax: GAWK -f FILE_EXTENSION_IS_IN_EXTENSIONS_LIST.AWK

BEGIN {

for (i=1; i<=n; i++) {

ext_arr[tolower(arr[i])] = ""

}

for (i=1; i<=n; i++) {

}

}

}

exit(0)

{{out}}

<pre>

</pre>

 

=={{header|C}}==

 

 

According to this, an extension is whatever comes after the '''last''' dot. Dotless filename won't match anything.

 

#include <string.h>

#include <stdbool.h>

return 0;

}

 

=={{header|D}}==

 

 

 

 

 

{{out}}

 

=={{header|Fortran}}==

 

When the task was revised to include a # as a possible character in the file name extension part, the scan in FEXT that allowed only certain characters via GOODEXT required changing. One possibility was to increase the size of GOODEXT so as to encompass the three characters in ODDITIES, that includes a #. But it also includes a : (all this is from a different context) and in file names, under DOS, this character is special. So, all-in-all, it seemed better to retreat from exclusions and simply allow all characters, as per the original specification. This done, the function EXTIN that checked that the extension was one of a specified set seemed no longer restricted to file name extensions, so instead it became FOUND(TEXT,LIST) and the period, the only special character now, is used as the delimiter in LIST.

Petty details include the list employing capitals only, as the match is to not distinguish capital from lower case letters, so in the usual way the candidate extension's text is converted to capitals. The list could be subjected to UPCASE, but it is bad form to damage what might be a constant, and one possibly in read-only storage at that. An internal working copy could be made which would then be fed to UPCASE, except that this would be a waste on every invocation. A further trick involves appending a period to the candidate text so that for example ".JP" becomes ".JP." - otherwise a ".JP" would be found in the sequence ".JPG" which would be wrong, so as a result, the list of texts must have a period appended to its last entry, otherwise it would not be findable. Again, this could be done internally, via <code>INDEX(LIST//".",EXT(1:L)//".")</code> at a run-time cost.

 

 

A final annoyance is the presence of trailing spaces because character variables are of fixed size and so must be made "surely long enough" for the longest expectation. This may not cause trouble on output as spaces look just as blank as blank space, but they may well cause trouble in the internal tests. Thus integer function LSTNB reports the last non-blank, and so a test text can be presented with no trailing spaces, as in TEST(I)(1:LSTNB(TEST(I))) or similar. With Fortran 2003, there is a facility for redefining the sizes of character variables on-the-fly so that this problem can be evaded.

 

CHARACTER*10 DIGITS !Integer only.

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

END DO !On to the next.

END

The previous results were when only "image" style files were approved. The approval is no longer so restrictive.

<pre>

Similarly, the scan of a file name to find the extension part relies on no extension containing a period. If the caller were to determine the text of the extension (rather than using FEXT, which stops with the rightmost period) then whatever results could be presented to function FOUND without difficulty.

 

 

 

import qualified Data.Char as Ch

 

 

isExt :: String -> [String] -> Bool

 

The code defining isExt could be done point free:

 

Overcoming the one-liner urge on behalf of being more comprehensible would give:

where allTails = tails . toLower $ filename

 

 

 

'''Solution:'''

'''Usage:'''

Exts isExt TestFiles

 

=={{header|Java}}==

 

 

{{works with|Java|1.5+}}

import java.util.Comparator;

 

}

}

{{out}}

<pre>Extensions: [.txt, .gz, , .bat]

{{works with|Java|6+}}

This version is the same as the main version only replace the definition for <code>extIsIn</code> with:

for(int i = 0; i < exts.length; i++){

exts[i] = exts[i].replaceAll("\\.", "");

}

return (new FileNameExtensionFilter("extension test", exts)).accept(new File(test));

It would be one line if not for the dot requirement. <code>FileNameExtensionFilter</code> requires that the extensions have no dots. It also requires that the extensions contain characters (i.e. not the empty string) so that test would need to be removed.

 

=={{header|jq}}==

 

{{works with|jq|1.4}}

# Output: if the filename ends with one of the extensions (ignoring case), output that extension; else output null.

# Assume that the list of file extensions consists of lower-case strings, including a leading period.

| if list | index($ext) then $ext else null end

else null

'''Examples:'''

| has_extension([".txt", ".c"]) as $ext

| if $ext then "\(.) has extension \($ext)"

else "\"\(.)\" does not have an admissible file extension"

 

{{out}}

"c:" does not have an admissible file extension

"txt" does not have an admissible file extension

foo.c has extension .c

"foo.C++" does not have an admissible file extension

 

=={{header|PARI/GP}}==

The examples were taken from the [[#AWK|AWK]] code.

 

{

my(v=Vecsmall(s));

ext=["txt","gz","bat","c","c++","exe","pdf"];

filenames=["c:","txt","text.txt","text.TXT","test.tar.gz","test/test2.exe","test","foo.c","foo.C","foo.C++","foo.c#","foo.zkl","document.pdf"];

{{out}}

<pre>%1 = ["text.txt", "text.TXT", "test.tar.gz", "test/test2.exe", "foo.c", "foo.C", "foo.C++", "document.pdf"]</pre>

 

 

Does the extra credit requirement.

 

 

Testing:

 

{{out}}

<pre>

</pre>

 

=={{header|Python}}==

 

 

 

 

=={{header|Racket}}==

 

 

 

 

 

{{out}}

 

=={{header|REXX}}==

This REXX version handles the extra credit requirement.

$= 'zip rar 7z gz archive A## tar.bz2'; upper $ /*a list of "allowable" file extensions*/

parse arg fn /*obtain optional argument from the CL.*/

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

@.2 = "MyData.tar.Gz"

@.3 = "MyData.gzip"

@.8 = "MyData_v1.0.bz2"

end

<pre>

</pre>

 

=={{header|Ruby}}==

 

 

{{out}}

<pre>

</pre>

 

=={{header|Scala}}==

 

 

 

=={{header|Tcl}}==

 

 

}

 

} else {

}

{{out}}

<pre>

</pre>

 

=={{header|zkl}}==

var [const] extensions=T(".zip",".rar",".7z",".gz",".archive",".a##");

nm,ext:=File.splitFileName(fnm)[-2,*].apply("toLower");

else False

}

{{out}}

<pre>