ultimo - manejo de cadenas en javascript

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

Question

Por ejemplo, suponiendo que x = filename.jpg , quiero obtener el filename , donde filename podría ser 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 funcionaría mejor x.substring(0, x.length-4) ? Porque, la length es una propiedad y no realiza la comprobación de caracteres, mientras que indexOf() es una función y realiza la comprobación de caracteres.

Answer 1

¡Aquí es donde las expresiones regulares son útiles! El método .replace() 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");

Answer 2

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

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

Esto solo debería cortar el último segmento.

Answer 3

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

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

Answer 4

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

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

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

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

Answer 5

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.

Answer 6

Este es el código que uso para eliminar la extensión de un nombre de archivo, sin usar regex o indexOf (indexOf no se admite en 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;
}

Answer 7

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 utilizar como una sola 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 + ""
}

Answer 8

Esto también se puede hacer fácilmente con la ruta utilizando los métodos basename y extname.

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

Answer 9

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

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

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

Answer 10

Me gusta esta porque es una sola línea que no es muy difícil de leer:

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

Answer 11

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

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

Answer 12

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(''''); // empty string since default separator is '', ''

No es solo una operación, pero al menos siempre debería funcionar.

Answer 13

Otro de una sola línea:

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

Answer 14

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

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

Answer 15

Puedes usar el path para 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''

Answer 16

Quizás pueda asumir el supuesto 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 usa esta función.

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

Answer 17

Si conoce la longitud de la extensión, puede usar 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 prefieres no usar expresiones regulares, puedes probar esto (con menos rendimiento):

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

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

Answer 18

Si tiene que procesar una variable que contiene la ruta completa (ej .: thePath = "http://.com/directory/subdirectory/filename.jpg" ) y desea devolver solo el "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 acerca de la comparación de los rendimientos con otras respuestas ni de la compatibilidad del navegador o sistema operativo.

Fragmento de trabajo 1: la ruta completa

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

Fragmento de trabajo 2: el nombre del archivo con la 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);

Answer 19

Uno simple:

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

Answer 20

Yo 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.

Answer 21

x.length-4 solo cuenta con extensiones de 3 caracteres. ¿Qué pasa si tienes filename.jpeg o filename.pl ?

EDITAR:

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

Sin embargo, si no sabe la longitud de su extensión, cualquiera de las 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 nombre de archivo de suposición solo tiene un punto)

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

O (también con un solo punto)

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

Answer 22

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

Answer 23

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