extract fileName using Regex - regex

If I want to match only fileName, i.e,
in C://Directory/FileName.cs, somehow ignore everything before FileName.cs using Regex.
How can I do it?
I need this for a Compiled UI I am working on ... can't use programming language as it only accepts Regex.
Any ideas?

Something like this might work:
[^/]*$
It matches all characters to the end of the line that are not "/"..
If you want to match paths that use the "\" path separator you would change the regex to:
[^\]*$
But do make sure to escape the "\" character if your programming language or environment requires it. For instance you might have to write something like this:
[^\\]*$
EDIT
I removed the leading "/" and trailing "/" as they may be confusing since they are not really part of the regEx but they are very common of representing a regular expression.
And of course, depending on the features that the regEx engine supports you may be able to use look-ahead/look-behind and capturing to craft a better regEx.

What language are you using? Why are you not using the standard path mechanisms of that language?
How about http://msdn.microsoft.com/en-us/library/system.io.path.aspx ?

Based on your comment of needing to exclude paths that do not match 'abc', try this:
^.+/(?:(?!abc)[^/])+$
Completely split out in regex comment mode, that is:
(?x) # flag to enable comments
^ # start of line
.+ # match any character (except newline)
# greedily one or more times
/ # a literal slash character
(?: # begin non-capturing group
(?! # begin negative lookahead
# (contents must not appear after the current position)
abc # literal text abc
) # end negative lookahead
[^/] # any character that is not a slash
) # end non-capturing group
+ # repeat the above nc group one or more times
# (essentially, we keep looking for non-backspaces that are not 'abc')
$ # end of line

The regex expression that did it for me was
[^\/]*$

I'm way late to the party and I'm also ignoring the requirement of regex because, as J-16 SDiZ pointed out, sometimes there is a better solution. Even though the question is 4 years old, people looking for a simple solution deserve choices.
Try using the following:
public string ConvertFileName(string filename)
{
string[] temparray = filename.Split('\\');
filename = temparray[temparray.Length - 1];
return filename;
}
This method splits the string on the "\" character, stores the resulting strings in an array and returns the last element of the array (the filename).
Though the OP seems to be writing for UNIX, it doesn't take much to figure out how to tailor it to your particular need.

Seeing as filename can be interpreted as the basename by some. Then, this example can extract the filename/basename for any files that may not have an extension for some reason. It can also get the last directory in the same fashion.
You can see how it works and test it here.
https://regexr.com/4ht5v
The regexp is:
.+?\\(?=\w+)|\.\w+$|\\$
Before:
C:\Directory\BaseFileName.ext
C:\Directory\BaseFileName
C:\This is a Directory\Last Directory With trailing backslash\
C:\This is a Directory\Last Directory Without trailing backslash
After:
BaseFileName
BaseFileName
Last Directory With trailing backslash
Last Directory Without trailing backslash
For the sake of completion, this is how it would work with JavaScript should anyone require it.
// Example of getting a BaseFileName from a path
var path = "C:\\Directory\\FileName.cs";
var result = path.replace(/.+?\\(?=\w+)|\.\w+$|\\$/gm,"");
console.log(result);

Try this (working with / and \):
[^\/|\\]*$

I would use: ./(.$)
The parenthesis mark a group wich is the file name.
The regular expression you use may vary dependig on the regex syntax(PCRE, POSIX)
I sugest you use a regex tool, there are several for windows and linux:
Windows - http://sourceforge.net/projects/regexcreator/
Windows - http://weitz.de/regex-coach/
Linux - kodos
Hope it helps

just a variation on miky's that works for both filesystem path characters:
[^\\/]*\s

Suppose the file name has special characters, specially when supporting MAC where special characters are allowing in filenames, server side Path.GetFileName(fileName) fails and throws error because of illegal characters in path. The following code using regex come for the rescue.
The following regex take care of 2 things
In IE, when file is uploaded, the file path contains folders aswell (i.e. c:\samplefolder\subfolder\sample.xls). Expression below will replace all folders with empty string and retain the file name
When used in Mac, filename is the only thing supplied as its safari browser and allows special chars in file name.
var regExpDir = #"(^[\w]:\\)([\w].+\w\\)";
var fileName = Regex.Replace(fileName, regExpDir, string.Empty);

I did this without RegEx in Powershell:
Put the link in a variable
$Link = "http://some.url/some/path/file.name"
Split the link on the "/" character
$split = $Link.Split("/")
Count the splits
$SplitCount = $Split.Count
Target the filename
$Split[$SplitCount -1]
Full code :
$Link = "http://some.url/some/path/file.name"
$Split = $Link.Split("/")
$SplitCount = $Split.Count
$Split[$SplitCount -1]

A rather elegant solution with lookahead and lookbehind wasn't mentioned:
(?<=.+)(?=.cs)

Related

Regex to replace whitespace in Markdown URLs

I've a bunch of Markdown links with whitespace, and I need to replace the whitespace with %20. So far I've hacked a few solutions, but none that work in VSCode, or do exactly what I'm looking for.
This is the URL format conversion I need:
[My link](../../_resources/my resource.jpg)
[My link](../../_resources/my%20resource.jpg)
\s+(?=[^(\)]*\)) will work on any whitespace inside brackets - but gives false positives as it works on anything with brackets.
(?:\]\(|(?!^)\G)[^]\s]*\K\h+ does the job, but I'm getting some "Invalid Escape Character" messages in VSCode, so I assume the language isn't compatible.
I've been trying to identify the link on the characters ]( but as I'm relatively new to regex, struggling a bit.
I tried with this regex: (?<=\]\()s\+ as this (?<=\]\().+ correctly identifies the url, but it doesn't work.
Where am I going wrong here? Thanks in advance!
EDIT: VSCode find in files doesn't support variable length lookbehind, even though find/replace in the open file does support this. Open to any other solutions before I dive into writing a script!
VSCode regex does not support \K, \G, or \h, but it does support Lookbehinds with non-fixed width. So, you may use something like the following:
(?<=\]\([^\]\r\n]*)[^\S\r\n]+
Online demo.
You can use
(?<=\]\([^\]]*)\s+(?=[^()]*\))
Replace with %20. See the demo screenshot:
Details:
(?<=\]\([^\]]*) - a positive lookbehind that matches a location that is immediately preceded with ]( and then any zero or more chars other than ]
\s+ - any one or more whitespace chars (other than line break chars in Visual Studio Code, if there is no \n or \r in the regex, \sdoes not match line break chars)
(?=[^()]*\)) - a positive lookahead that matches a location that is immediately followed with zero or more chars other than ( and ) and then a ) char.
Since you are using it in Find/Replace in Files, this lookbehind solution won't work.
You can use Notepad++ with
(\G(?!\A)|\[[^][]*]\()([^()\s]*)\s+(?=[^()]*\))
and $1$2%20 replacement pattern. In Notepad++, press CTRL+SHIFT+F and after filling out the necessary fields, hit Replace in Files.
See the sample settings:
In the end, as I'm on a Mac and didn't want to fire up a virtual PC to run Notepad++ (Sublime uses the same engine and Atom doesn't allow you exclude files), I used a combination of a Python script with #Wiktor Stribizew's answer for individual files that weren't picked up by the pattern for whatever reason.
md_url_pattern = r'(\[(.+)\])\(([^\)]+)\)'
def remove_spacing(match_obj):
if match_obj.group(3) is not None:
print("Match Object: " + match_obj.group(1) + "(" + re.sub(r"\s+", "%20", match_obj.group(3)) + ")")
return match_obj.group(1) + "(" + re.sub(r"\s+", "%20", match_obj.group(3)) + ")"
# THIS_FOLDER = os.path.dirname(os.path.abspath(__file__))
this_folder = '<my_document_folder>' # fixed folder path
note_path = '<note_folder>' # change this
full_path = os.path.join(this_folder, note_path)
directory = os.listdir(full_path)
os.chdir(full_path)
for file in directory:
open_file = open(file, 'r')
read_file = open_file.read()
read_file = re.sub(md_url_pattern, remove_spacing, read_file)
if not read_file:
print("Empty file!")
else:
write_file = open(file,'w')
write_file.write(read_file)
This script could do with a bit of tidying up and debugging (the odd weird empty file and no subfolder compatibility) but it was the best I could do.

Regex to match(extract) string between dot(.)

I want to select some string combination (with dots(.)) from a very long string (sql). The full string could be a single line or multiple line with new line separator, and this combination could be in start (at first line) or a next line (new line) or at both place.
I need help in writing a regex for it.
Examples:
String s = I am testing something like test.test.test in sentence.
Expected output: test.test.test
Example2 (real usecase):
UPDATE test.table
SET access = 01
WHERE access IN (
SELECT name FROM project.dataset.tablename WHERE name = 'test' GROUP BY 1 )
Expected output: test.table and project.dataset.tablename
, can I also add some prefix or suffix words or space which should be present where ever this logic gets checked. In above case if its update regex should pick test.table, but if the statement is like select test.table regex should not pick it up this combinations and same applies for suffix.
Example3: This is to illustrate the above theory.
INS INTO test.table
SEL 'abcscsc', wu_id.Item_Nbr ,1
FROM test.table as_t
WHERE as_t.old <> 0 AND as_t.date = 11
AND (as_t.numb IN ('11') )
Expected Output: test.table, test.table (Key words are INTO and FROM)
Things Not Needed in selection:as_t.numb, as_t.old, as_t.date
If I get the regex I can use in program to extract this word.
Note: Before and after string words to the combination could be anything like update, select { or(, so we have to find the occurrence of words which are joined together with .(dot) and all the number of such occurrence.
I tried something like this:
(?<=.)(.?)(?=.)(.?) -: This only selected the word between two .dot and not all.
.(?<=.)(.?)(?=.)(.?). - This everything before and after.
To solve your initial problem, we can just use some negation. Here's the pattern I came up with:
[^\s]+\.[^\s]+
[^ ... ] Means to make a character class including everything except for what's between the brackets. In this case, I put \s in there, which matches any whitespace. So [^\s] matches anything that isn't whitespace.
+ Is a quantifier. It means to find as many of the preceding construct as you can without breaking the match. This would happily match everything that's not whitespace, but I follow it with a \., which matches a literal .. The \ is necessary because . means to match any character in regex, so we need to escape it so it only has its literal meaning. This means there has to be a . in this group of non-whitespace characters.
I end the pattern with another [^\s]+, which matches everything after the . until the next whitespace.
Now, to solve your secondary problem, you want to make this match only work if it is preceded by a given keyword. Luckily, regex has a construct almost specifically for this case. It's called a lookbehind. The syntax is (?<= ... ) where the ... is the pattern you want to look for. Using your example, this will only match after the keywords INTO and FROM:
(?<=(?:INTO|FROM)\s)[^\s]+\.[^\s]+
Here (?:INTO|FROM) means to match either the text INTO or the text FROM. I then specify that it should be followed by a whitespace character with \s. One possible problem here is that it will only match if the keywords are written in all upper case. You can change this behavior by specifying the case insensitive flag i to your regex parser. If your regex parser doesn't have a way to specify flags, you can usually still specify it inline by putting (?i) in front of the pattern, like so:
(?i)(?<=(?:INTO|FROM)\s)[^\s]+\.[^\s]+
If you are new to regex, I highly recommend using the www.regex101.com website to generate regex and learn how it works. Don't forget to check out the code generator part for getting the regex code based on the programming language you are using, that's a cool feature.
For your question, you need a regex that understands any word character \w that matches between 0 and unlimited times, followed by a dot, followed by another series of word character that repeats between 0 and unlimited times.
So here is my solution to your question:
Your regex in JavaScript:
const regex = /([\w][.][\w])+/gm;
in Java:
final String regex = "([\w][.][\w])+";
in Python:
regex = r"([\w][.][\w])+"
in PHP:
$re = '/([\w][.][\w])+/m';
Note that: this solution is written for your use case (to be used for SQL strings), because now if you have something like '.word' or 'word..word', it will still catch it which I assume you don't have a string like that.
See this screenshot for more details

REGEX: Extract paths from string

I would like to extract paths in the form of:
$/Server/First Level Folder/Second_Level_Folder/My File.extension
The challenge here is that the paths are embedded in a "free form" email like so:
Hello,
You can download the file here:
$/Server/First Level Folder/Second_Level_Folder/My File.extension <- Click me!
Given a string, I would like to extract all paths from it using RegEx. Is this even possible?
Thanks!
Yes, this is possible (\$/.*?\.\S*) should do the job just fine.
\$/ matches the start of the path
.*? matches everything till the next part of the regex
\.\S* matches the dot and anything but a whitespace (space, tab)
And the ( ) around it make it capture all that is matched.
EDIT:
For further use
Just the path
(\$/.*?/)[^/]*?\.\S*
Just the filename
\$/.*?/([^/]*?\.\S*)
If the filename contains [escaped forward slashes / or no period symbol] AND the filepath spaces are escaped with a backslash '\ ' you can still do it with this (i've escaped the forward and back slashes)
(\/.*?\/)((?:[^\/]|\\\/)+?)(?:(?<!\\)\s|$)
Debuggex Demo
This creates two capture groups - one for the path and one for the file basename. If your test strings contains filenames with unescaped spaces (as shown) then you would have to use the period in the filename as an anchor as per B8vrede's answer.

Regular expression get filename without extention from full filepath

How can I extract the filename without extention from the following file path:
D:\Projects\Extract\downtown - second.pdf
The following regular expression gives me the filename with extention: [^\\]*$
e.g. downtown - second.pdf
The following regular expression gives me the filename without extention: (.+)(?=(\.))
e.g. D:\Projects\Extract\downtown - second
I'm struggling to combine the two into one regular expression to give me the results I want: downtown - second
I suspect that your 2nd regex would not give you the output you have shown. It will give you the complete string till the first period (.).
To get just the file name without extension, you can use this regex: -
[^\\]*(?=[.][a-zA-Z]+$)
I have just replaced (.+) in your 2nd regex with the [^\\]* from your first regex, and added pattern to match pdf till the end.
Now this pattern will match 0 or more repetition of any character but backslash(\), followed by a . and then 1 or more repetition of alphabets making up extension.
I made up this one, which allows to capture most of the possibilities:
/[^\\\/]+(?=\.[\w]+$)|[^\\\/]+$/
/path/to/file
/path/to/file.txt
/path.with/dots.to/file.txt
/path/to/file.with.dots.txt
file.txt
C:\path\to\file.txt
and so on...
I captured file from /path/to/file.pdf by using following regex:
[^/]*(?=\.[^.]+($|\?))
Hope this helps you
I had to use an extra backslash before the first ']' to make this work
[^\\\]*(?=[.][a-zA-Z]+$)
I use this pattern
[^\/]+[.+\.].*$ for / path separator
[^\\]+[.+\.].*$ for \ path separator
hich matches the filename at the end of the string without worrying about characters. There is one exception that if the path for some reason has a folder with a period in it this will get upset. Linux hidden directories that are preceded with a . like .rvm are unaffected.
Hope this helps.
http://rubular.com/r/LNrI4inMU1

Regex for extracting filename from path

I need to extract just the filename (no file extension) from the following path....
\\my-local-server\path\to\this_file may_contain-any&character.pdf
I've tried several things, most based off of something like http://regexr.com?302m5 but can't quite get there
^\\(.+\\)*(.+)\.(.+)$
This regex has been tested on these two examples:
\var\www\www.example.com\index.php
\index.php
First block "(.+\)*" matches directory path.
Second block "(.+)" matches file name without extension.
Third block "(.+)$" matches extension.
This will get the filename but will also get the dot. You might want to truncate the last digit from it in your code.
[\w-]+\.
Update
#Geoman if you have spaces in file name then use the modified pattern below
[ \w-]+\. (space added in brackets)
Demo
This is just a slight variation on #hmd's so you don't have to truncate the .
[ \w-]+?(?=\.)
Demo
Really, thanks goes to #hmd. I've only slightly improved on it.
Try this:
[^\\]+(?=\.pdf$)
It matches everything except back-slash followed by .pdf at the end of the string.
You can also (and maybe it's even better) take the part you want into the capturing group like that:
([^\\]+)\.pdf$
But how you refer to this group (the part in parenthesis) depends on the language or regexp flavor you're using. In most cases it'll be smth like $1, or \1, or the library will provide some method for getting capturing group by its number after regexp match.
I use #"[^\\]+$"
That gives the filename including the extension.
I'm using this regex to replace the filename of the file with index. It matches a contiguous string of characters that doesn't contain a slash and is followed by a . and a string of word characters at the end of the string. It will retrieve the filename including spaces and dots but will ignore the full file extension.
const regex = /[^\\/]+?(?=\.\w+$)/
console.log('/path/to/file.png'.match(regex))
console.log('/path/to/video.webm'.match(regex))
console.log('/path/to/weird.file.gif'.match(regex))
console.log('/path with/spaces/and file.with.spaces'.match(regex))
If anyone is looking for a windows absolute path (and relative path) javascript regular expression in javascript for files:
var path = "c:\\my-long\\path_directory\\file.html";
((/(\w?\:?\\?[\w\-_\\]*\\+)([\w-_]+)(\.[\w-_]+)/gi).exec(path);
Output is:
[
"c:\my-long\path_directory\file.html",
"c:\my-long\path_directory\",
"file",
".html"
]
Here's a slight modification to Angelo's excellent answer that allows for spaces in the path, filename and extension as well as missing parts:
function parsePath (path) {
var parts = (/(\w?\:?\\?[\w\-_ \\]*\\+)?([\w-_ ]+)?(\.[\w-_ ]+)?/gi).exec(path);
return {
path: parts[0] || "",
folder: parts[1] || "",
name: parts[2] || "",
extension: parts[3] || "",
};
}
If you want to return the file name with its extension, Regex should be as below:
[A-Za-z0-9_\-\.]+\.[A-Za-z0-9]+$
works for
path/to/your/filename.some
path/to/your/filename.some.other
path\to\your\filename.some
path\to\your\filename.some.other
http://path/to/your/filename.some
http://path/to/your/filename.some.other
And so on
Which returns full file name with extension(eg: filename.some or filename.some.other)
If you want to return file name without the last extension Regex should be as below:
[A-Za-z0-9_\-\.]+(?=\.[A-Za-z0-9]+$)
Which returns full file name without last extension(eg: "filename" for "filename.some" and "filename.some" for "filename.some.other")
Click the Explain button on these links shown TEST to see how they work.
This is specific to the pdf extension.
TEST ^.+\\([^.]+)\.pdf$
This is specific to any extension, not just pdf.
TEST ^.+\\([^.]+)\.[^\.]+$
([^.]+)
This is the $1 capture group to extract the filename without the extension.
\\my-local-server\path\to\this_file may_contain-any&character.pdf
will return
this_file may_contain-any&character
TEST ^(.*[\\\/])?(.*?)(\.[^.]*?|)$
example:
/^(.*[\\\/])?(.*?)(\.[^.]*?|)$/.exec("C:\\folder1\\folder2\\foo.ext1.ext")
result:
0: "C:\folder1\folder2\foo.ext1.ext"
1: "C:\folder1\folder2\"
2: "foo.ext1"
3: ".ext"
the $1 capture group is the folder
the $2 capture group is the name without extension
the $3 capture group is the extension (only the last)
works for:
C:\folder1\folder2\foo.ext
C:\folder1\folder2\foo.ext1.ext
C:\folder1\folder2\name-without extension
only name
name.ext
C:\folder1\folder2\foo.ext
/folder1/folder2/foo.ext
C:\folder1\folder2\foo
C:\folder1\folder2\
C:\special&chars\folder2\f [oo].ext1.e-x-t
Answer with:
File name and directory space support
Named capture group
Gets unlimited file extensions (captures file.tar.gz, not just file.tar)
*NIX and Win support
^.+(\\|\/)(?<file_name>([^\\\/\n]+)(\.)?[^\n\.]+)$
Explanation:
^.+(\\|\/) Gets anything up to the final / or \ in a file path
(?<file_name> Begin named capture group
([^\\\/\n]+) get anything except for a newline or new file
(\.)?[^\n\.]+ Not really needed but it works well for issues with odd characters in file names
)$ End named capture group and end line
Note that if you're putting this in a string and you need to escape backslashes (such as with C) you'll be using this string:
"^.+(\\\\|\/)(?<file_name>([^\\\/\n]+)(\.)?[^\n\.]+)$"
Here is an alternative that works on windows/unix:
"^(([A-Z]:)?[\.]?[\\{1,2}/]?.*[\\{1,2}/])*(.+)\.(.+)"
First block: path
Second block: dummy
Third block: file name
Fourth block: extension
Tested on:
".\var\www\www.example.com\index.php"
"\var\www\www.example.com\index.php"
"/var/www/www.example.com/index.php"
"./var/www/www.example.com/index.php"
"C:/var/www/www.example.com/index.php"
"D:/var/www/www.example.com/index.php"
"D:\\var\\www\\www.example.com\\index.php"
"\index.php"
"./index.php"
This regular expression extract the file extension, if group 3 isn't null it's the extension.
.*\\(.*\.(.+)|.*$)
also one more for file in dir and root
^(.*\\)?(.*)(\..*)$
for file in dir
Full match 0-17 `\path\to\file.ext`
Group 1. 0-9 `\path\to\`
Group 2. 9-13 `file`
Group 3. 13-17 `.ext`
for file in root
Full match 0-8 `file.ext`
Group 2. 0-4 `file`
Group 3. 4-8 `.ext`
For most of the cases ( that is some win , unx path , separator , bare file name , dot , file extension ) the following one is enough:
// grap the dir part (1), the dir sep(2) , the bare file name (3)
path.replaceAll("""^(.*)[\\|\/](.*)([.]{1}.*)""","$3")
Direct approach:
To answer your question as it's written, this will provide the most exact match:
^\\\\my-local-server\\path\\to\\(.+)\.pdf$
General approach:
This regex is short and simple, matches any filename in any folder (with or without extension) on both windows and *NIX:
.*[\\/]([^.]+)
If a file has multiple dots in its name, the above regex will capture the filename up to the first dot. This can easily be modified to match until the last dot if you know that you will not have files without extensions or that you will not have a path with dots in it.
If you know that the folder will only contain .pdf files or you are only interested in .pdf files and also know that the extension will never be misspelled, I would use this regex:
.*[\\/](.+)\.pdf$
Explanation:
. matches anything except line terminators.
* repeats the previous match from zero to as many times as possible.
[\\/] matches a the last backslash or forward slash (previous ones are consumed by .*). It is possible to omit either the backslash or the forward slash if you know that only one type of environment will be used.
If you want to capture the path, surround .* or .*[\\/] in parenthesis.
Parenthesis will capture what is matched inside them.
[^.] matches anything that is not a literal dot.
+ repeats the previous match one or more times, as many as possible.
\. matches a literal dot.
pdf matches the string pdf.
$ asserts the end of the string.
If you want to match files with zero, one or multiple dots in their names placed in a variable path which also may contain dots, it will start to get ugly. I have not provided an answer for this scenario as I think it is unlikely.
Edit: To also capture filenames without a path, replace the first part with (?:.*[\\/])?, which is an optional non-capturing group.
Does this work...
.*\/(.+)$
Posting here so I can get feedback
Here a solution to extract the file name without the dot of the extension.
I begin with the answer from #Hammad Khan and add the dot in the search character. So, dots can be part of the file name:
[ \w-.]+\.
Then use the regex look ahead(?= ) for a dot, so it will stop the search at the last dot (the dot before the extension), and the dot will not appears in the result:
[ \w-.]+(?=[.])
reorder, it's not necessary but look better:
[\w-. ]+(?=[.])
try this
[^\\]+$
you can also add extension for specificity
[^\\]+pdf$