replace - How to trim a file extension from a String in JavaScript? - Stack Overflow

admin管理员组

文章数量:1125950

For example, assuming that x = filename.jpg, I want to get filename, where filename could be any file name (Let's assume the file name only contains [a-zA-Z0-9-_] to simplify.).

I saw x.substring(0, x.indexOf('.jpg')) on DZone Snippets, but wouldn't x.substring(0, x.length-4) perform better? Because, length is a property and doesn't do character checking whereas indexOf() is a function and does character checking.

For example, assuming that x = filename.jpg, I want to get filename, where filename could be any file name (Let's assume the file name only contains [a-zA-Z0-9-_] to simplify.).

I saw x.substring(0, x.indexOf('.jpg')) on DZone Snippets, but wouldn't x.substring(0, x.length-4) perform better? Because, length is a property and doesn't do character checking whereas indexOf() is a function and does character checking.

• javascript
• replace
• substring
• substr
• indexof

Share Improve this question Follow edited Feb 11, 2016 at 16:11 T J 43.1k1313 gold badges8686 silver badges142142 bronze badges asked Nov 22, 2010 at 21:24 ma11hew28ma11hew28 126k122122 gold badges459459 silver badges657657 bronze badges 3

• See: Regular expression to remove a file's extension and see also: How can i get file extensions with javascript? – Shog9 Commented Nov 22, 2010 at 21:28
• Pretty much the same as stackoverflow.com/questions/1991608/…. And unless you do one heck of a lot of these, worrying about efficiency is Premature Optimisation. – The Archetypal Paul Commented Nov 22, 2010 at 21:28
• In the age of ES6, also see the Path module – in case you are using nodejs or a proper transpilation – Frank N Commented Jul 2, 2017 at 19:04

Add a comment  | 

30 Answers 30

Sorted by: Reset to default 665

Not sure what would perform faster but this would be more reliable when it comes to extension like .jpeg or .html

x.replace(/\.[^/.]+$/, "")

In node.js, the name of the file without the extension can be obtained as follows.

const path = require('path');
const filename = 'hello.html';
    
path.parse(filename).name;     //=> "hello"
path.parse(filename).ext;      //=> ".html"
path.parse(filename).base; //=> "hello.html"

Further explanation at Node.js documentation page.

If you know the length of the extension, you can use x.slice(0, -4) (where 4 is the three characters of the extension and the dot).

If you don't know the length @John Hartsock regex would be the right approach.

If you'd rather not use regular expressions, you can try this (less performant):

filename.split('.').slice(0, -1).join('.')

Note that it will fail on files without extension.

x.length-4 only accounts for extensions of 3 characters. What if you have filename.jpegor filename.pl?

EDIT:

To answer... sure, if you always have an extension of .jpg, x.length-4 would work just fine.

However, if you don't know the length of your extension, any of a number of solutions are better/more robust.

x = x.replace(/\..+$/, '');

OR

x = x.substring(0, x.lastIndexOf('.'));

OR

x = x.replace(/(.*)\.(.*?)$/, "$1");

OR (with the assumption filename only has one dot)

parts = x.match(/[^\.]+/);
x = parts[0];

OR (also with only one dot)

parts = x.split(".");
x = parts[0];

I like this one because it is a one liner which isn't too hard to read:

filename.substring(0, filename.lastIndexOf('.')) || filename

You can perhaps use the assumption that the last dot will be the extension delimiter.

var x = 'filename.jpg';
var f = x.substr(0, x.lastIndexOf('.'));

If file has no extension, it will return empty string. To fix that use this function

function removeExtension(filename){
    var lastDotPosition = filename.lastIndexOf(".");
    if (lastDotPosition === -1) return filename;
    else return filename.substr(0, lastDotPosition);
}

In Node.js versions prior to 0.12.x:

path.basename(filename, path.extname(filename))

Of course this also works in 0.12.x and later.

I don't know if it's a valid option but I use this:

name = filename.split(".");
// trimming with pop()
name.pop();
// getting the name with join()
name.join('.'); // we split by '.' and we join by '.' to restore other eventual points.

It's not just one operation I know, but at least it should always work!

UPDATE: If you want a oneliner, here you are:

(name.split('.').slice(0, -1)).join('.')

This works, even when the delimiter is not present in the string.

String.prototype.beforeLastIndex = function (delimiter) {
    return this.split(delimiter).slice(0,-1).join(delimiter) || this + ""
}

"image".beforeLastIndex(".") // "image"
"image.jpeg".beforeLastIndex(".") // "image"
"image.second.jpeg".beforeLastIndex(".") // "image.second"
"image.second.third.jpeg".beforeLastIndex(".") // "image.second.third"

Can also be used as a one-liner like this:

var filename = "this.is.a.filename.txt";
console.log(filename.split(".").slice(0,-1).join(".") || filename + "");

EDIT: This is a more efficient solution:

String.prototype.beforeLastIndex = function (delimiter) {
    return this.substr(0,this.lastIndexOf(delimiter)) || this + ""
}

Another one-liner:

x.split(".").slice(0, -1).join(".")

If you have to process a variable that contains the complete path (ex.: thePath = "http://stackoverflow.com/directory/subdirectory/filename.jpg") and you want to return just "filename" you can use:

theName = thePath.split("/").slice(-1).join().split(".").shift();

the result will be theName == "filename";

To try it write the following command into the console window of your chrome debugger: window.location.pathname.split("/").slice(-1).join().split(".").shift()

If you have to process just the file name and its extension (ex.: theNameWithExt = "filename.jpg"):

theName = theNameWithExt.split(".").shift();

the result will be theName == "filename", the same as above;

Notes:

1. The first one is a little bit slower cause performes more operations; but works in both cases, in other words it can extract the file name without extension from a given string that contains a path or a file name with ex. While the second works only if the given variable contains a filename with ext like filename.ext but is a little bit quicker.
2. Both solutions work for both local and server files;

But I can't say nothing about neither performances comparison with other answers nor for browser or OS compatibility.

working snippet 1: the complete path

var thePath = "http://stackoverflow.com/directory/subdirectory/filename.jpg";
theName = thePath.split("/").slice(-1).join().split(".").shift();
alert(theName);

working snippet 2: the file name with extension

var theNameWithExt = "filename.jpg";
theName = theNameWithExt.split("/").slice(-1).join().split(".").shift();
alert(theName);

working snippet 2: the file name with double extension

var theNameWithExt = "filename.tar.gz";
theName = theNameWithExt.split("/").slice(-1).join().split(".").shift();
alert(theName);

Here's another regex-based solution:

filename.replace(/\.[^.$]+$/, '');

This should only chop off the last segment.

Simple one:

var n = str.lastIndexOf(".");
return n > -1 ? str.substr(0, n) : str;

The accepted answer strips the last extension part only (.jpeg), which might be a good choice in most cases.

I once had to strip all extensions (.tar.gz) and the file names were restricted to not contain dots (so 2015-01-01.backup.tar would not be a problem):

var name = "2015-01-01_backup.tar.gz";
name.replace(/(\.[^/.]+)+$/, "");

var fileName = "something.extension";
fileName.slice(0, -path.extname(fileName).length) // === "something"

• A straightforward answer, if you are using Node.js, is the one in the first comment.
• My task was I need to delete an image in Cloudinary from the Node server and I just need to get the image name only. Example:

const path = require("path")
const image=xyz.jpg;
const img= path.parse(image).name
console.log(img) // xyz

Node.js remove extension from full path keeping directory

https://stackoverflow.com/a/31615711/895245 for example did path/hello.html -> hello, but if you want path/hello.html -> path/hello, you can use this:

#!/usr/bin/env node
const path = require('path');
const filename = 'path/hello.html';
const filename_parsed = path.parse(filename);
console.log(path.join(filename_parsed.dir, filename_parsed.name));

outputs directory as well:

path/hello

https://stackoverflow.com/a/36099196/895245 also achieves this, but I find this approach a bit more semantically pleasing.

Tested in Node.js v10.15.2.

Though it's pretty late, I will add another approach to get the filename without extension using plain old JS-

path.replace(path.substr(path.lastIndexOf('.')), '')

We might come across filename or file path with multiple extension suffix. Consider the following to trim them.

text = "/dir/path/filename.tar.gz"    
output = text.replace(/(\.\w+)+$/,"")

result of output: "/dir/path/filename"

It solves the file extension problem especially when the input has multiple extensions.

This might help...

const splitNameAndExtension = (fileName) => {
  const dotIndex = fileName.lastIndexOf(".");

  if (dotIndex === -1) {
    return { name: fileName, extension: "" };
  }

  const name = fileName.substring(0, dotIndex);
  const extension = fileName.substring(dotIndex + 1);

  return { name, extension };
};

const result = splitNameAndExtension("File A (1).txt");
console.log("result: ", result) // { name: "File A (1)", extension: "txt" }

This is where regular expressions come in handy! Javascript's .replace() method will take a regular expression, and you can utilize that to accomplish what you want:

// assuming var x = filename.jpg or some extension
x = x.replace(/(.*)\.[^.]+$/, "$1");

You can use path to maneuver.

var MYPATH = '/User/HELLO/WORLD/FILENAME.js';
var MYEXT = '.js';
var fileName = path.basename(MYPATH, MYEXT);
var filePath = path.dirname(MYPATH) + '/' + fileName;

Output

> filePath
'/User/HELLO/WORLD/FILENAME'
> fileName
'FILENAME'
> MYPATH
'/User/HELLO/WORLD/FILENAME.js'

This is the code I use to remove the extension from a filename, without using either regex or indexOf (indexOf is not supported in IE8). It assumes that the extension is any text after the last '.' character.

It works for:

• files without an extension: "myletter"
• files with '.' in the name: "my.letter.txt"
• unknown length of file extension: "my.letter.html"

Here's the code:

var filename = "my.letter.txt" // some filename

var substrings = filename.split('.'); // split the string at '.'
if (substrings.length == 1)
{
  return filename; // there was no file extension, file was something like 'myfile'
}
else
{
  var ext = substrings.pop(); // remove the last element
  var name = substrings.join(""); // rejoin the remaining elements without separator
  name = ([name, ext]).join("."); // readd the extension
  return name;
}

I like to use the regex to do that. It's short and easy to understand.

for (const regexPattern of [
  /\..+$/,  // Find the first dot and all the content after it.
  /\.[^/.]+$/ // Get the last dot and all the content after it.
  ]) {
  console.log("myFont.ttf".replace(regexPattern, ""))
  console.log("myFont.ttf.log".replace(regexPattern, ""))
}

/* output
myFont
myFont
myFont
myFont.ttf
*/

The above explanation may not be very rigorous. If you want to get a more accurate explanation can go to regex101 to check

• \..+$
• \.[^/.]+$

In node:

const path = require('path');
path.join(path.dirname(filename), path.parse(filename).name)

or if you want to make sure that you remove a specific extension (but only if present)

const path = require('path');
path.join(path.dirname(filename), path.basename(filename, '.ext'))

why the above:

• The full file path is kept
• it is os-independent (you don't need to explicitly provide the separator)
• both forms are safe when directories have dots but filename does not
• the second form is also safe for cases where filename may have dots but the actual extension is for some reason missing

e.g.

let filename='path/to/my.file'

path.join(path.dirname(filename), path.basename(filename, '.doc'))
//Result:   path/to/my.file  (and not path/to/my)

Another one liner - we presume our file is a jpg picture >> ex: var yourStr = 'test.jpg';

    yourStr = yourStr.slice(0, -4); // 'test'

x.slice(0, -(x.split('.').pop().length + 1));

name.split('.').slice(0, -1).join('.')

that's all enjoy your coding...

Try this one .split('.')[0]

it worked for me

I would use something like x.substring(0, x.lastIndexOf('.')). If you're going for performance, don't go for javascript at all :-p No, one more statement really doesn't matter for 99.99999% of all purposes.

本文标签： replaceHow to trim a file extension from a String in JavaScriptStack Overflow