File extension is in extensions list: Difference between revisions
Walterpachl (talk | contribs) m (→{{header|REXX}}: typos) |
(→{{header|Perl 6}}: handle extensions the Unix Way, agnostically) |
||
Line 83: | Line 83: | ||
a/b/c\d/foo: true</pre> |
a/b/c\d/foo: true</pre> |
||
=={{header|Perl 6}}== |
=={{header|Perl 6}}== |
||
<lang perl6> |
<lang perl6>sub ext-in-list(@ext,@files) { |
||
for @files { |
|||
⚫ | |||
⚫ | |||
⚫ | |||
} |
|||
} |
|||
ext-in-list |
|||
for < foo.C foo.zkl foo foo. > { |
|||
« |
|||
⚫ | |||
.c |
|||
⚫ | |||
.C# |
|||
⚫ | |||
.o |
|||
⚫ | |||
.yup |
|||
.½xy |
|||
'. embedded blanks ' |
|||
», |
|||
« |
|||
foo.c |
|||
foo.C |
|||
foo.C++ |
|||
foo.c# |
|||
foo.zkl |
|||
somefile |
|||
'holy smoke' |
|||
afile. |
|||
/a/path/to/glory.yup/or_not |
|||
funny... |
|||
unusual.½xy |
|||
'fly_in_the_ointment. embedded blanks ' |
|||
⚫ | |||
{{out}} |
{{out}} |
||
<pre>foo. |
<pre>True foo.c |
||
True foo.C |
|||
foo.zkl .zkl is not in the list |
|||
False foo.C++ |
|||
foo (has no extension) |
|||
True foo.c# |
|||
foo. . is not in the list</pre> |
|||
False foo.zkl |
|||
---- somefile |
|||
---- holy smoke |
|||
---- afile. |
|||
---- /a/path/to/glory.yup/or_not |
|||
---- funny... |
|||
True unusual.½xy |
|||
True fly_in_the_ointment. embedded blanks |
|||
</pre> |
|||
=={{header|Python}}== |
=={{header|Python}}== |
Revision as of 00:20, 13 August 2014
Given a file name and a list of extensions (including the dot), tell whether the file's extension is in the extensions list. The check should be case insensitive. The file might not have an extension.
Haskell
<lang Haskell> import Data.List import qualified Data.Char as Ch
toLower :: String -> String toLower = map Ch.toLower
isExt :: String -> [String] -> Bool isExt filename extensions = any (`elem` (tails . toLower $ filename)) $ map toLower extensions </lang>
The code defining isExt could be done point free: <lang Haskell> isExt filename = any (`elem` (tails . toLower $ filename)) . map toLower </lang>
Overcoming the one-liner urge on behalf of being more comprehensible would give: <lang Haskell> isExt filename extensions = any (`elem` allTails) lowerExtensions
where allTails = tails . toLower $ filename
lowerExtensions = map toLower extensions </lang>
J
Solution: <lang j>getExt=: }.~ i:&'.' isExt=: e.~&:(tolower&.>) getExt&.>@boxopen</lang> Usage: <lang j> Exts=: <;._1 ' .o .ijs .ij .p'
TestFiles=: <;._1 ' foo.o blab.iJ dram. lat.P win.dll foo' Exts isExt TestFiles
1 1 0 1 0 0</lang>
Java
<lang java5>import java.util.Arrays; import java.util.Comparator;
public class FileExt{ public static void main(String[] args){ String[] tests = {"text.txt", "text.TXT", "test.tar.gz", "test/test2.exe", "test\\test2.exe", "test", "a/b/c\\d/foo"}; String[] exts = {".txt",".gz","",".bat"};
System.out.println("Extensions: " + Arrays.toString(exts) + "\n");
for(String test:tests){ System.out.println(test +": " + extIsIn(test, exts)); } }
public static boolean extIsIn(String test, String... exts){ int lastSlash = Math.max(test.lastIndexOf('/'), test.lastIndexOf('\\')); //whichever one they decide to use today String filename = test.substring(lastSlash + 1);//+1 to get rid of the slash or move to index 0 if there's no slash
//end of the name if no dot, last dot index otherwise int lastDot = filename.lastIndexOf('.') == -1 ? filename.length() : filename.lastIndexOf('.'); String ext = filename.substring(lastDot);//everything at the last dot and after is the extension
Arrays.sort(exts);//sort for the binary search
return Arrays.binarySearch(exts, ext, new Comparator<String>() { //just use the built-in binary search method @Override //it will let us specify a Comparator and it's fast enough public int compare(String o1, String o2) { return o1.compareToIgnoreCase(o2); } }) >= 0;//binarySearch returns negative numbers when it's not found } } </lang>
- Output:
Extensions: [.txt, .gz, , .bat] text.txt: true text.TXT: true test.tar.gz: true test/test2.exe: false test\test2.exe: false test: true a/b/c\d/foo: true
Perl 6
<lang perl6>sub ext-in-list(@ext,@files) {
for @files { when / :i @ext $ / { say "True\t$_" } when / '.' <-[/.]>+ $ / { say "False\t$_" } default { say "----\t$_" } }
}
ext-in-list
« .c .C# .o .yup .½xy '. embedded blanks ' », « foo.c foo.C foo.C++ foo.c# foo.zkl somefile 'holy smoke' afile. /a/path/to/glory.yup/or_not funny... unusual.½xy 'fly_in_the_ointment. embedded blanks ' »;</lang>
- Output:
True foo.c True foo.C False foo.C++ True foo.c# False foo.zkl ---- somefile ---- holy smoke ---- afile. ---- /a/path/to/glory.yup/or_not ---- funny... True unusual.½xy True fly_in_the_ointment. embedded blanks
Python
<lang Python> import os
def isExt(filename, extensions):
return os.path.splitext(filename.lower())[-1] in [e.lower() for e in extensions]
</lang>
REXX
Programming note: extra code was added to:
- display some error/warning messages
- handle the case of the filename having a path
- handle the case of different types of path separators
- handle the case of the filename having no file extension
- handle cases of the filename ending in a period
- handle cases of the filename ending in multiple periods
- handle cases of blanks in the filename and/or extension
<lang rexx>/*REXX program displays if a filename has a known extension (per a list)*/ /*╔════════════════════════════════════════════════════════════════════╗
║ The list of extensions below have blanks encoded as 'ff'x. ║ ║ The extension pointed to has a 'ff'x after the period──────────┐ ║ ║ (which is used to indicate a true blank, due to │ ║ ║ REXX's use of blanks in lists as delimiters). │ ║ ╚══════════════════════════════════════════════════════════════════↓═╝*/
extensions='.bat .cmd .com .dat .dll .exe .ini .jpg .jpeg .log .txt . ys'
/* [↑] above would be some EXTs.*/
parse arg fn /*get the filename from the C.L. */ if fn== then exit /*No fn specified? Then exit.*/ afn=translate( fn, '/', "\") /*handle both versions of pathSep*/ afn=translate(afn, 'ff'x, " ") /*··· and also handle true blanks*/ afn=substr(afn,lastpos('/',afn)+1) /*pick off the filename from path*/ p=lastpos('.',afn) /*find the last position of a dot*/ if p==0 | p==length(afn) then do /*no dot or dot is at end of name*/
say 'Filename ' fn " has no extension." exit end
ft=substr(afn,p) /*pickoff the fileType (fileExt).*/ say 'ft=' ft upper ft extensions /*uppercase a couple of REXX vars*/ if wordpos(ft,extensions)==0 then _='an unknown'
else _= 'a known'
say 'Filename ' fn "has" _ 'extension.'</lang>
Ruby
<lang ruby>extensions = [".c",".o",""] ["foo.C","foo.zkl","foo","foo."].each{|f| p extensions.include?( File.extname(f).downcase )} </lang>
- Output:
true false true true
Scala
<lang Scala> def isExt(fileName: String, extensions: List[String]): Boolean = {
extensions.map { _.toLowerCase }.exists { fileName.toLowerCase endsWith _ }
} </lang>
zkl
<lang zkl>var exts=T(".c",".o",""); fcn hasExtension(fname){ exts.holds(File.splitFileName(fname)[3].toLower()) } T("foo.C","foo.zkl","foo","foo.").apply(hasExtension).println();</lang>
- Output:
L(True,False,True,True)