Como cortar uma extensão de arquivo de uma String em JavaScript?

Por exemplo, supondo que x = filename.jpg, eu quero obter filename, onde filenamepoderia haver qualquer nome de arquivo (suponha que o nome do arquivo contenha apenas [a-zA-Z0-9-_] para simplificar).

Vi x.substring(0, x.indexOf('.jpg'))no DZone Snippets , mas não teria um x.substring(0, x.length-4)desempenho melhor? Porque, lengthé uma propriedade e não realiza a verificação de caracteres, enquanto indexOf()é uma função e realiza a verificação de caracteres.

Se você souber o comprimento da extensão, poderá usar x.slice(0, -4)(onde 4 são os três caracteres da extensão e o ponto).

Se você não souber o comprimento, a regex @John Hartsock seria a abordagem certa.

Se você preferir não usar expressões regulares, tente isso (menos desempenho):

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

Observe que ele falhará nos arquivos sem extensão.

Não tenho certeza do que teria um desempenho mais rápido, mas isso seria mais confiável quando se trata de extensões como .jpegou.html

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

No node.js , o nome do arquivo sem a extensão pode ser obtido da seguinte maneira.

const path = require('path');
const filename = 'hello.html';

path.parse(filename).name; // hello
path.parse(filename).ext;  // .html

Mais explicações na página de documentação do Node.js.

x.length-4representa apenas extensões de 3 caracteres. E se você tiver filename.jpegou filename.pl?

EDITAR:

Para responder ... claro, se você sempre tiver uma extensão de .jpg, x.length-4funcionaria muito bem.

No entanto, se você não souber o tamanho da sua extensão, qualquer uma de várias soluções será melhor / mais robusta.

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

OU

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

OU

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

OU (com o nome do arquivo suposto apenas com um ponto)

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

OU (também com apenas um ponto)

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

Talvez você possa usar a suposição de que o último ponto será o delimitador de extensão.

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

Se o arquivo não tiver extensão, ele retornará uma string vazia. Para corrigir isso, use esta função

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

Eu gosto deste porque é um liner que não é muito difícil de ler:

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

Nas versões do Node.js anteriores à 0.12.x:

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

Obviamente, isso também funciona em 0.12.xe posterior.

Isso funciona, mesmo quando o delimitador não está presente na 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"

Também pode ser usado como uma linha como esta:

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

EDIT: Esta é uma solução mais eficiente:

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

Não sei se é uma opção válida, mas uso isso:

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.

Não é apenas uma operação que eu conheço, mas pelo menos deve sempre funcionar!

ATUALIZAÇÃO: Se você deseja um oneliner, aqui está:

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

Outra linha:

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

Aqui está outra solução baseada em regex:

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

Isso deve cortar apenas o último segmento.

Simples:

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

A resposta aceita retira apenas a última parte da extensão ( .jpeg), que pode ser uma boa escolha na maioria dos casos.

Uma vez tive que remover todas as extensões ( .tar.gz) e os nomes dos arquivos foram restritos para não conter pontos (por 2015-01-01.backup.tarisso não seria um problema):

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

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

Se você precisar processar uma variável que contenha o caminho completo (ex .:) thePath = "http://stackoverflow.com/directory/subdirectory/filename.jpg"e desejar retornar apenas "nome do arquivo", poderá usar:

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

o resultado será theName == "filename" ;

Para tentar, escreva o seguinte comando na janela do console do seu depurador chrome: window.location.pathname.split("/").slice(-1).join().split(".").shift()

Se você precisar processar apenas o nome do arquivo e sua extensão (ex .:) theNameWithExt = "filename.jpg":

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

o resultado será theName == "filename" , o mesmo que acima;

Notas:

1. O primeiro é um pouco mais lento, porque realiza mais operações; mas funciona nos dois casos, ou seja, pode extrair o nome do arquivo sem extensão de uma determinada sequência que contém um caminho ou um nome de arquivo com ex. Enquanto o segundo funciona apenas se a variável especificada contém um nome de arquivo com ext como filename.ext, mas é um pouco mais rápido.
2. Ambas as soluções funcionam para arquivos locais e do servidor;

Mas não posso dizer nada sobre a comparação de desempenhos com outras respostas, nem sobre a compatibilidade do navegador ou do SO.

trecho de trabalho 1: o caminho completo

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

trecho de trabalho 2: o nome do arquivo com extensão

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

trecho de trabalho 2: o nome do arquivo com extensão dupla

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

Embora seja muito tarde, adicionarei outra abordagem para obter o nome do arquivo sem extensão, usando JS-

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

O Node.js remove a extensão do diretório de manutenção de caminho completo

https://stackoverflow.com/a/31615711/895245, por exemplo, fez path/hello.html-> hello, mas se você quiser path/hello.html-> path/hello, pode usar isso:

#!/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));

diretório de saídas também:

path/hello

https://stackoverflow.com/a/36099196/895245 também consegue isso, mas acho essa abordagem um pouco mais semanticamente agradável.

Testado no Node.js v10.15.2.

É aqui que as expressões regulares são úteis! O .replace()método do Javascript terá uma expressão regular, e você pode utilizá-lo para realizar o que deseja:

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

Outro liner - presumimos que nosso arquivo seja uma imagem jpg >> ex: var yourStr = 'test.jpg';

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

Você pode usar pathpara manobrar.

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

Resultado

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

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

Este é o código que eu uso para remover a extensão de um nome de arquivo, sem usar regex ou indexOf (indexOf não é suportado no IE8). Pressupõe que a extensão seja qualquer texto após o último '.' personagem.

Funciona para:

• arquivos sem extensão: "myletter"
• arquivos com '.' no nome: "my.letter.txt"
• comprimento desconhecido da extensão do arquivo: "my.letter.html"

Aqui está o código:

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;
}

Eu usaria algo como x.substring (0, x.lastIndexOf ('.')). Se você deseja desempenho, não use javascript :-p Não, mais uma declaração realmente não importa para 99,99999% de todos os propósitos.