File extension is in extensions list: Difference between revisions

{{trans|Python}}

 

R any(extensions.map(e -> @file_name.lowercase().ends_with(‘.’e.lowercase())))

 

 

test([‘MyData.a##’, ‘MyData.tar.Gz’, ‘MyData.gzip’, ‘MyData.7z.backup’, ‘MyData...’, ‘MyData’], [‘zip’, ‘rar’, ‘7z’, ‘gz’, ‘archive’, ‘A##’, ‘tar.bz2’])

 

{{out}}

MyData_v1.0.tar.bz2 1B

MyData_v1.0.bz2 0B

</pre>

 

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

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

OP LENGTH = ( STRING str )INT: ( UPB str - LWB str ) + 1;

# returns TRUE if str ends with ending FALSE otherwise #

# test the file names in the extra credit #

test has extension in list( "MyData_v1.0.tar.bz2", ec extensions, TRUE );

{{out}}

<pre>

MyData_v1.0.bz2 does not have an extension in the list</pre>

 

}

 

 

 

{{out}}

 

 

=={{header|AWK}}==

This solution meets the extended criteria stated in the problem.

 

# syntax: GAWK -f FILE_EXTENSION_IS_IN_EXTENSIONS_LIST.AWK

BEGIN {

}

exit(0)

{{out}}

<pre>

MyData_v1.0.bz2 extension is not in list

</pre>

 

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

This solution does '''not''' contain support for dots in extension names.

@echo off

setlocal enabledelayedexpansion

shift

goto loop

{{out}}

<pre>

===C: dots allowed ===

There is no magic in extensions: they are just trailing characters in names.

* File extension is in extensions list (dots allowed).

*

getchar();

return 0;

{{out}}

<pre>

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|C++}}==

This solution allows extensions to contain dots.

#include <cctype>

#include <iomanip>

test("MyData_v1.0.bz2", extensions);

return 0;

 

{{out}}

 

=={{header|Clojure}}==

(re-find (re-pattern (str "\\." ext "$"))

(clojure.string/lower-case s)))

 

(defn matches-extension-list [ext-list s]

 

It is assumed that when extensions are "added to the system", they will be "normalized" to the expected (lower) case.

 

 

{{out}}

=={{header|D}}==

===Variant 1===

import std.stdio;

import std.string;

 

 

 

{{out}}

 

===Variant 2===

import std.stdio;

import std.string;

}

 

 

{{out}}

MyData_v1.0.bz2 : false

 

</pre>

 

=={{header|Factor}}==

This solution allows dots in file extensions.

IN: rosetta-code.file-extension-list

 

filenames [

dup extensions ext-in-list? "%19s %u\n" printf

{{out}}

<pre>

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>

=={{header|Go}}==

This allows extensions to include a dot and, in the case of success, displays the extension matched (ignoring case) in the list. In the case of failure, the actual (minimum) file extension is displayed.

 

import (

fmt.Printf("%-20s => %-5t (extension = %s)\n", test, ok, ext)

}

 

{{out}}

MyData_v1.0.bz2 => false (extension = bz2)

</pre>

 

=={{header|Haskell}}==

 

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

 

Given definition handles composite extensions as well.

'''Testing:'''

 

where

files = [ "MyData.a##"

, "MyData_v1.0.tar.bz2"

, "MyData_v1.0.bz2" ]

{{Out}}

<pre>λ> main

We can also express this directly in terms of the '''isSuffix''' function, taking care not to reproduce the small glitch in the draft above, which shows a false positive for '''zip''' in '''.gzip''' (see task description bullet 2).

 

import Data.Maybe (fromMaybe)

 

 

extensionFound :: [String] -> String -> Maybe String

 

 

main :: IO ()

main =

(fromMaybe "n/a")

(extensionFound

[ "MyData.a##"

, "MyData.tar.Gz"

])

 

fTable :: String -> (a -> String) -> (b -> String) -> (a -> b) -> [a] -> String

fTable s xShow fxShow f xs =

 

{{Out}}

<pre>Any matching extensions found:

 

'''Solution:'''

 

'''Usage:'''

TestFiles=: <;._1 ' MyData.a## MyData.tar.Gz MyData.gzip MyData.7z.backup MyData... MyData MyData_v1.0.tar.bz2 MyData_v1.0.bz2'

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|Julia}}==

{{works with|Julia|0.6}}

 

 

# Test

for f in ["MyData.a##", "MyData.tar.Gz", "MyData.gzip", "MyData.7z.backup", "MyData...", "MyData", "MyData_v1.0.tar.bz2", "MyData_v1.0.bz2"]

@printf("%20s : %5s\n", f, isext(f, extensions))

 

{{out}}

 

=={{header|Kotlin}}==

 

/* implicitly allows for extensions containing dots */

println("${fileName.padEnd(19)} -> ${fileName.isFileExtensionListed(extensions)}")

}

 

{{out}}

 

=={{header|Lua}}==

local extentions = {"zip", "rar", "7z", "gz", "archive", "A##", "tar.bz2"}

local testCases = {

for _, case in pairs(testCases) do

print(case .. ": " .. tostring(extMatch(extentions, case)))

{{out}}

<pre>MyData.a##: true

MyData_v1.0.tar.bz2: true

MyData_v1.0.bz2: false</pre>

 

=={{header|Nim}}==

 

To build the extension list, we can use a compile time function:

 

let fileNameList = ["MyData.a##", "MyData.tar.Gz", "MyData.gzip",

 

for fileName in fileNameList:

 

Another way consists to use “mapIt” from standard module “sequtils”:

 

let fileNameList = ["MyData.a##", "MyData.tar.Gz", "MyData.gzip",

 

for fileName in fileNameList:

 

{{out}}

The “splitFile” procedure no longer works in this case. We have to use “endsWith” from the “strutils” module, which changes the logic:

 

 

let fileNameList = ["MyData.a##", "MyData.tar.Gz", "MyData.gzip",

 

for fileName in fileNameList:

 

{{out}}

 

=={{header|Objeck}}==

class FileExtension {

function : Main(args : String[]) ~ Nil {

IO.Console->Print(file)->PrintLine(" does not have an extension in the list");

}

 

{{out}}

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>

{{trans|Raku}}

 

my ($filename, @extensions) = @_;

my $extensions = join '|', map quotemeta, @extensions;

scalar $filename =~ / \. (?: $extensions ) $ /xi

 

Testing:

my @files= (

'MyData.a##', 'MyData.tar.Gz', 'MyData.gzip', 'MyData.7z.backup',

printf "%-19s - %s\n",

$_, check_extension($_, @extensions) ? 'true' : 'false'

 

{{out}}

</pre>

 

 

 

 

{{out}}

<pre>

=={{header|Python}}==

 

def isExt(fileName, extensions):

return True in map(fileName.lower().endswith, ("." + e.lower() for e in extensions))

 

and we could also enrich the return value to a Maybe option type, returning Nothing if no file extension match is found, or Just the particular extension, if a match is found:

 

 

 

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Check for a specific set of file extensions:

=={{header|Racket}}==

 

#lang racket

 

(for ((f (in-list filenames)))

(printf "~a ~a~%" (~a #:width 20 f) (file-extension-in-list? f extensions)))

{{out}}

<pre>

Does the extra credit requirement.

 

so $filename ~~ /:i '.' @extensions $/

}

MyData_v1.0.tar.bz2 MyData_v1.0.bz2

>;

 

{{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.*/

end /*k*/ /* [↓] display file, and a nay or yea.*/

say right(@.j, 40) ' ' right( word( "false true", 1 + (k<=#) ), 5)

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

=={{header|Ring}}==

# Project : File extension is in extensions list

 

ok

next

Output:

<pre>

 

=={{header|Ruby}}==

if filename.respond_to?(:each)

filename.each do |fn|

end

end

{{out}}

<pre>

=={{header|Rust}}==

Does extra credit.

let exts = ["zip", "rar", "7z", "gz", "archive", "A##", "tar.bz2"];

let filenames = [

}

}

{{out}}

<pre>

=={{header|Scala}}==

 

extensions.map { _.toLowerCase }.exists { fileName.toLowerCase endsWith "." + _ }

}

 

=={{header|Sidef}}==

{{trans|Perl}}

filename ~~ Regex('\.(' + extensions.map { .escape }.join('|') + ')\z', :i)

 

Testing:

 

var files = [

for file in files {

printf("%-19s - %s\n", file, check_extension(file, extensions))

{{out}}

<pre>

=={{header|Tcl}}==

 

 

# This example includes the extra credit.

}

 

{{out}}

<pre>

MyData_v1.0.tar.bz2 true

MyData_v1.0.bz2 false

 

</pre>

 

{{libheader|Wren-str}}

{{libheader|Wren-fmt}}

 

var exts = ["zip", "rar", "7z", "gz", "archive", "A##", "tar.bz2"]

}

if (!hasExt) Fmt.print("$-20s $-5s", test, hasExt)

 

{{out}}

MyData_v1.0.tar.bz2 true (extension: tar.bz2)

MyData_v1.0.bz2 false

</pre>

 

=={{header|zkl}}==

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

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

"MyData...","MyData",

"MyData_v1.0.tAr.bz2","MyData_v1.0.bz2");

{{out}}

<pre>