¿Cómo recortar una extensión de archivo de una cadena en JavaScript?

Por ejemplo, suponiendo que x = filename.jpg, quiero llegar filename, dónde filenamepodría estar cualquier nombre de archivo (Supongamos que el nombre del archivo solo contiene [a-zA-Z0-9-_] para simplificar).

Vi x.substring(0, x.indexOf('.jpg'))en DZone Snippets , pero ¿no x.substring(0, x.length-4)funcionaría mejor? Porque, lengthes una propiedad y no realiza la comprobación de caracteres, mientras que indexOf()es una función y realiza la comprobación de caracteres.

Si conoce la longitud de la extensión, puede usarla x.slice(0, -4)(donde 4 son los tres caracteres de la extensión y el punto).

Si no conoce la longitud, la expresión regular de @John Hartsock sería el enfoque correcto.

Si prefiere no usar expresiones regulares, puede intentar esto (menos rendimiento):

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

Tenga en cuenta que fallará en archivos sin extensión.

No estoy seguro de qué funcionaría más rápido, pero esto sería más confiable cuando se trata de extensiones como .jpego.html

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

En node.js , el nombre del archivo sin la extensión se puede obtener de la siguiente manera.

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

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

Explicación adicional en la página de documentación de Node.js.

x.length-4solo representa extensiones de 3 caracteres. ¿Qué pasa si tienes filename.jpego filename.pl?

EDITAR:

Para responder ... seguro, si siempre tiene una extensión de .jpg, x.length-4funcionaría bien.

Sin embargo, si no conoce la longitud de su extensión, cualquiera de varias soluciones es mejor / más sólida.

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

O

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

O

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

O (con el supuesto nombre de archivo solo tiene un punto)

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

O (también con un solo punto)

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

Quizás pueda usar la suposición de que el último punto será el delimitador de extensión.

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

Si el archivo no tiene extensión, devolverá una cadena vacía. Para arreglar eso use esta función

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

Me gusta este porque es un trazador de líneas que no es demasiado difícil de leer:

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

En las versiones de Node.js anteriores a 0.12.x:

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

Por supuesto, esto también funciona en 0.12.xy posteriores.

Esto funciona, incluso cuando el delimitador no está presente en la cadena.

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"

También se puede usar como una línea como esta:

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

EDITAR: Esta es una solución más eficiente:

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

No sé si es una opción válida, pero uso esto:

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.

No solo conozco una operación, sino que al menos siempre debería funcionar.

ACTUALIZACIÓN: Si quieres un oneliner, aquí estás:

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

Otra frase:

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

Aquí hay otra solución basada en expresiones regulares:

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

Esto solo debería cortar el último segmento.

Uno simple:

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

La respuesta aceptada elimina solo la última parte de la extensión ( .jpeg), que podría ser una buena opción en la mayoría de los casos.

Una vez tuve que quitar todas las extensiones ( .tar.gz) y los nombres de los archivos estaban restringidos para no contener puntos (por 2015-01-01.backup.tarlo que no sería un problema):

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

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

Si tiene que procesar una variable que contiene la ruta completa (ej .:) thePath = "http://stackoverflow.com/directory/subdirectory/filename.jpg"y desea devolver solo "nombre de archivo", puede usar:

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

el resultado será theName == "filename" ;

Para probarlo escriba el siguiente comando en la ventana de la consola de su depurador de Chrome window.location.pathname.split("/").slice(-1).join().split(".").shift()

Si tiene que procesar solo el nombre del archivo y su extensión (ej .:) theNameWithExt = "filename.jpg":

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

el resultado será theName == "filename" , el mismo que el anterior;

Notas:

1. El primero es un poco más lento porque realiza más operaciones; pero funciona en ambos casos, en otras palabras, puede extraer el nombre del archivo sin extensión de una cadena dada que contiene una ruta o un nombre de archivo con ex. Mientras que el segundo funciona solo si la variable dada contiene un nombre de archivo con ext como filename.ext pero es un poco más rápido.
2. Ambas soluciones funcionan para archivos locales y de servidor;

Pero no puedo decir nada sobre la comparación de rendimiento con otras respuestas ni sobre la compatibilidad del navegador o el sistema operativo.

fragmento de trabajo 1: la ruta completa

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

fragmento de trabajo 2: el nombre del archivo con extensión

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

fragmento de trabajo 2: el nombre del archivo con doble extensión

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

Aunque es bastante tarde, agregaré otro enfoque para obtener el nombre de archivo sin extensión usando JS-

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

Node.js elimina la extensión del directorio completo de mantenimiento de rutas

https://stackoverflow.com/a/31615711/895245 por ejemplo did path/hello.html-> hello, pero si quieres path/hello.html-> path/hello, puedes usar esto:

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

directorio de salidas también:

path/hello

https://stackoverflow.com/a/36099196/895245 también logra esto, pero este enfoque me parece un poco más semántico.

Probado en Node.js v10.15.2.

¡Aquí es donde las expresiones regulares son útiles! El .replace()método de Javascript tomará una expresión regular, y puede utilizarlo para lograr lo que desea:

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

Otro revestimiento: suponemos que nuestro archivo es una imagen jpg >> ex: var yourStr = 'test.jpg';

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

Puedes usar pathpara maniobrar.

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

Salida

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

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

Este es el código que uso para eliminar la extensión de un nombre de archivo, sin usar regex o indexOf (indexOf no es compatible con IE8). Se supone que la extensión es cualquier texto después del último '.' personaje.

Funciona para:

• archivos sin extensión: "myletter"
• archivos con '.' en el nombre: "my.letter.txt"
• longitud desconocida de la extensión de archivo: "my.letter.html"

Aquí está el 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;
}

Usaría algo como x.substring (0, x.lastIndexOf ('.')). Si va por el rendimiento, no use javascript en absoluto :-p No, una declaración más realmente no importa para el 99.99999% de todos los propósitos.