Como aparar uma extensão de arquivo de uma string no JavaScript?

Question

Por exemplo, assumindo que x = filename.jpg, Eu quero conseguir filename, Onde filename Pode ser qualquer nome de arquivo (vamos assumir que o nome do arquivo contém apenas [a-ZA-Z0-9-_] para simplificar.).

Eu vi x.substring(0, x.indexOf('.jpg')) sobre Trechos de dzone, mas não x.substring(0, x.length-4) Se apresentar melhor? Porque, length é uma propriedade e não faz verificação de personagens, enquanto indexOf() é uma função e faz verificação de caracteres.

Answer 1

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

Se você não souber o comprimento @john Hartsock Regex seria a abordagem certa.

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

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

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

Answer 2

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

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

Answer 3

Dentro Node.js, o nome do arquivo sem a extensão pode ser obtido da seguinte forma.

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

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

Explicação adicional em Node.js documentação página.

Answer 4

x.length-4 Apenas explica as 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-4 funcionaria muito bem.

No entanto, se você não conhece a duração da sua extensão, qualquer uma das várias soluções é melhor/mais robusta.

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

OU

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

OU

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

Ou (com o nome do pressuposto apenas tem um ponto)

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

Ou (também com apenas um ponto)

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

Answer 5

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á a string vazia. Para consertar esse uso desta função

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

Answer 6

Nas versões Node.js antes de 0.12.x:

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

É claro que isso também funciona em 0.12.x e posterior.

Answer 7

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 + "");

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

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

Answer 8

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

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

Answer 9

Isso também pode ser feito facilmente com o caminho usando os métodos de nome de base e extname.

const path = require('path')

path.basename('test.txt', path.extname('test.txt'))

Answer 10

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á você:

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

Answer 11

Outra frase:

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

Answer 12

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

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

Isso deve cortar apenas o último segmento.

Answer 13

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

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

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

Answer 14

Simples:

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

Answer 15

Se você precisar processar uma variável que contém o caminho completo (Ex.: thePath = "http://stackoverflow.com/directory/subdirectory/filename.jpg") e você deseja retornar apenas "nome do arquivo" que você pode usar:

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

O resultado será thename == "nome do arquivo";

Para tentar escrever 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 == "nome do arquivo", O mesmo que acima;

Notas:

1. O primeiro é um pouco mais lento, causa realiza mais operações; Mas funciona em ambos os casos, em outras palavras, ele pode extrair o nome do arquivo sem extensão de uma determinada string que contém um caminho ou um nome de arquivo com Ex. Enquanto o segundo funciona apenas se a variável fornecida contiver um nome de arquivo com ext como o nome do arquivo.ext, mas for um pouco mais rápido.
2. Ambas as soluções funcionam para arquivos locais e de servidor;

Mas não posso falar nada sobre a comparação de performances com outras respostas nem para a compatibilidade do navegador ou do sistema operacional.

Snippet 1: o caminho completo

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

Snippet 2: o nome do arquivo com extensão

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

Snippet 2: o nome do arquivo com extensão dupla

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

Answer 16

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

Answer 17

Embora esteja muito tarde, adicionarei outra abordagem para obter o nome do arquivo sem extensão usando o js antigo simples

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

Answer 18

É aqui que as expressões regulares são úteis! JavaScript .replace() O método adotará uma expressão regular e você pode utilizar isso para realizar o que deseja:

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

Answer 19

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

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

Answer 20

Você pode usar path para 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'

Answer 21

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

Answer 22

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

Funciona para:

• arquivos sem uma extensão: "myletter"
• arquivos com '.' em 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;
}

Answer 23

Eu usaria algo como x.substring (0, x.LastIndexof ('.')). Se você estiver indo para o desempenho, não vá para JavaScript: P não, mais uma declaração realmente não importa para 99,99999% de todos os propósitos.