qué - obtener extension de archivo javascript

¿Cómo puedo obtener extensiones de archivos con JavaScript? (30)

Ver codigo

var file1 = "50.xsl"; var file2 = "30.doc"; getFileExtension(file1); //returns xsl getFileExtension(file2); //returns doc function getFileExtension(filename) { /*TODO*/ }

Esta simple solucion

function extension(filename) { var r = /.+/.(.+)$/.exec(filename); return r ? r[1] : null; }

Pruebas

/* tests */ test(''cat.gif'', ''gif''); test(''main.c'', ''c''); test(''file.with.multiple.dots.zip'', ''zip''); test(''.htaccess'', null); test(''noextension.'', null); test(''noextension'', null); test('''', null); // test utility function function test(input, expect) { var result = extension(input); if (result === expect) console.log(result, input); else console.error(result, input); } function extension(filename) { var r = /.+/.(.+)$/.exec(filename); return r ? r[1] : null; }

Acabo de darme cuenta de que no basta con poner un comentario en la respuesta de p4bl0, aunque la respuesta de Tom resuelve claramente el problema:

return filename.replace(/^.*?/.([a-zA-Z0-9]+)$/, "$1");

En node.js, esto puede lograrse mediante el siguiente código:

var file1 ="50.xsl"; var path = require(''path''); console.log(path.parse(file1).name);

Estoy seguro de que alguien puede, y lo hará, minimizar y / u optimizar mi código en el futuro. Pero, a partir de ahora , estoy seguro al 200% de que mi código funciona en cada situación única (p. Ej., Solo con el nombre del archivo , con URL relativa , relativa , relativa y absoluta , con etiquetas de fragmentos # , con cadenas de consulta , y cualquier otra cosa que usted decida lanzarle, sin fallas, y con precisión de punta.

Para ver la prueba, visite: https://projects.jamesandersonjr.com/web/js_projects/get_file_extension_test.php

Aquí está el JSFiddle: https://jsfiddle.net/JamesAndersonJr/ffcdd5z3/

No estoy demasiado seguro, ni toco mi propia trompeta, pero no he visto ningún bloque de código para esta tarea (encontrar la extensión de archivo ''correcta'' , en medio de una batería de diferentes argumentos de entrada de function ) que funciona igual de bien.

Nota: Por diseño, si no existe una extensión de archivo para la cadena de entrada dada, simplemente devuelve una cadena en blanco "" , no un error, ni un mensaje de error.

Se necesitan dos argumentos:
Cadena: fileNameOrURL (autoexplicativo)
Boolean: showUnixDotFiles (para mostrar o no archivos que comienzan con un punto ".")

Nota (2): Si te gusta mi código, asegúrate de agregarlo a la biblioteca y / o el repositorio de js, porque trabajé duro para perfeccionarlo, y sería una lástima perderlo. Así que sin más preámbulos, aquí está:

¡Disfrutar! ¡Eres muy bienvenido!:

La respuesta de Wallacer es agradable, pero se necesita una comprobación más.

Si el archivo no tiene extensión, usará el nombre de archivo como extensión, lo cual no es bueno.

Prueba este:

return ( filename.indexOf(''.'') > 0 ) ? filename.split(''.'').pop().toLowerCase() : ''undefined'';

La siguiente solución es rápida y lo suficientemente corta como para usarla en operaciones masivas y guardar bytes adicionales:

return fname.slice((fname.lastIndexOf(".") - 1 >>> 0) + 2);

Aquí hay otra solución universal de una línea sin regexp:

return fname.slice((Math.max(0, fname.lastIndexOf(".")) || Infinity) + 1);

Ambos funcionan correctamente con nombres que no tienen extensión (por ejemplo, myfile ) o que comienzan con . punto (ej. .htaccess ):

"" --> "" "name" --> "" "name.txt" --> "txt" ".htpasswd" --> "" "name.with.many.dots.myext" --> "myext"

Si le importa la velocidad, puede ejecutar el benchmark y verificar que las soluciones proporcionadas sean las más rápidas, mientras que la breve es tremendamente rápida:

Cómo funciona el corto:

String.lastIndexOf método String.lastIndexOf devuelve la última posición de la subcadena (es decir, "." ) En la cadena dada (es decir, fname ). Si no se encuentra la subcadena, el método devuelve -1 .
Las posiciones "inaceptables" del punto en el nombre de archivo son -1 y 0 , que se refieren respectivamente a nombres sin extensión (por ejemplo, "name" ) y nombres que comienzan con punto (por ejemplo, ".htaccess" ).
El operador de desplazamiento a la derecha con relleno cero ( >>> ) si se usa con cero afecta a los números negativos que transforman -1 a 4294967295 y -2 a 4294967294 , lo cual es útil para mantener el nombre de archivo sin cambios en los casos de borde (aquí hay una especie de truco).
String.prototype.slice extrae la parte del nombre de archivo de la posición que se calculó como se describe. Si el número de posición es mayor que la longitud del método de cadena, devuelve "" .

Si desea una solución más clara que funcione de la misma manera (más con soporte adicional de ruta completa), verifique la siguiente versión extendida. Esta solución será más lenta que las anteriores, pero es mucho más fácil de entender.

function getExtension(path) { var basename = path.split(/[///]/).pop(), // extract file name from full path ... // (supports `//` and `/` separators) pos = basename.lastIndexOf("."); // get last position of `.` if (basename === "" || pos < 1) // if file name is empty or ... return ""; // `.` not found (-1) or comes first (0) return basename.slice(pos + 1); // extract extension ignoring `.` } console.log( getExtension("/path/to/file.ext") ); // >> "ext"

Las tres variantes deben funcionar en cualquier navegador web en el lado del cliente y también pueden usarse en el código NodeJS del lado del servidor.

Llego tarde a la fiesta con muchas lunas, pero por simplicidad uso algo como esto

var fileName = "I.Am.FileName.docx"; var nameLen = fileName.length; var lastDotPos = fileName.lastIndexOf("."); var fileNameSub = false; if(lastDotPos === -1) { fileNameSub = false; } else { //Remove +1 if you want the "." left too fileNameSub = fileName.substr(lastDotPos + 1, nameLen); } document.getElementById("showInMe").innerHTML = fileNameSub;

<div id="showInMe"></div>

No olvides que algunos archivos no pueden tener extensión, así que:

var parts = filename.split(''.''); return (parts.length > 1) ? parts.pop() : '''';

Para la mayoría de las aplicaciones, un script simple como

return /[^.]+$/.exec(filename);

funcionaría bien (según lo proporcionado por Tom). Sin embargo, esto no es infalible. No funciona si se proporciona el siguiente nombre de archivo:

image.jpg?foo=bar

Puede ser un poco excesivo, pero sugeriría usar un analizador de URL como este para evitar fallos debido a nombres de archivos impredecibles.

Usando esa función en particular, podría obtener el nombre de archivo así:

var trueFileName = parse_url(''image.jpg?foo=bar'').file;

Esto dará salida a "image.jpg" sin las vars de url. Entonces usted es libre de agarrar la extensión de archivo.

Prefiero usar lodash para la mayoría de las cosas, así que aquí hay una solución:

function getExtensionFromFilename(filename) { let extension = ''''; if (filename > '''') { let parts = _.split(filename, ''.''); if (parts.length >= 2) { extension = _.last(parts); } return extension; }

Prueba esto:

function getFileExtension(filename) { var fileinput = document.getElementById(filename); if (!fileinput) return ""; var filename = fileinput.value; if (filename.length == 0) return ""; var dot = filename.lastIndexOf("."); if (dot == -1) return ""; var extension = filename.substr(dot, filename.length); return extension; }

Rápido y funciona correctamente con caminos.

(filename.match(/[^////]/.([^.////]+)$/) || [null]).pop()

Algunos casos de borde

/path/.htaccess => null /dir.with.dot/file => null

Las soluciones que usan split son lentas y las soluciones con lastIndexOf no manejan casos de borde.

Sólo quería compartir esto.

fileName.slice(fileName.lastIndexOf(''.''))

aunque esto tiene el inconveniente de que los archivos sin extensión devolverán la última cadena. pero si lo haces esto arreglará cada cosa:

function getExtention(fileName){ var i = fileName.lastIndexOf(''.''); if(i === -1 ) return false; return fileName.slice(i) }

Si está buscando una extensión específica y conoce su longitud, puede usar substr :

var file1 = "50.xsl"; if (file1.substr(-4) == ''.xsl'') { // do something }

Referencia de JavaScript: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr

Si estás tratando con urls web, puedes usar:

function getExt(filename){ return filename.split(''.'').pop().split("?")[0].split("#")[0]; } getExt("logic.v2.min.js") // js getExt("http://example.net/site/page.php?id=16548") // php getExt("http://example.net/site/page.html#welcome") // html

Demostración: https://jsfiddle.net/squadjot/q5ard4fj/

Una solución de una línea que también tendrá en cuenta los parámetros de consulta y cualquier carácter en la url.

string.match(/(.*)/??/i).shift().replace(//?.*/, '''').split(''.'').pop() // Example // some.url.com/with.in/&ot.s/files/file.jpg?spec=1&.ext=jpg // jpg

Código

/** * Extract file extension from URL. * @param {String} url * @returns {String} File extension or empty string if no extension is present. */ var getFileExtension = function (url) { "use strict"; if (url === null) { return ""; } var index = url.lastIndexOf("/"); if (index !== -1) { url = url.substring(index + 1); // Keep path without its segments } index = url.indexOf("?"); if (index !== -1) { url = url.substring(0, index); // Remove query } index = url.indexOf("#"); if (index !== -1) { url = url.substring(0, index); // Remove fragment } index = url.lastIndexOf("."); return index !== -1 ? url.substring(index + 1) // Only keep file extension : ""; // No extension found };

Prueba

Tenga en cuenta que en ausencia de una consulta, el fragmento podría estar presente.

"https://www.example.com:8080/segment1/segment2/page.html?foo=bar#fragment" --> "html" "https://www.example.com:8080/segment1/segment2/page.html#fragment" --> "html" "https://www.example.com:8080/segment1/segment2/.htaccess?foo=bar#fragment" --> "htaccess" "https://www.example.com:8080/segment1/segment2/page?foo=bar#fragment" --> "" "https://www.example.com:8080/segment1/segment2/?foo=bar#fragment" --> "" "" --> "" null --> "" "a.b.c.d" --> "d" ".a.b" --> "b" ".a.b." --> "" "a...b" --> "b" "..." --> ""

JSLint

0 Advertencias.

Edición más reciente: muchas cosas han cambiado desde que esta pregunta se publicó inicialmente: hay mucha información realmente buena en la respuesta revisada de Wallacer, así como también el excelente desglose de VisioN.

Edición: Solo porque esta es la respuesta aceptada; La respuesta de Wallacer es mucho mejor:

return filename.split(''.'').pop();

Mi vieja respuesta:

return /[^.]+$/.exec(filename);

Deberías hacerlo.

Edición: En respuesta al comentario de PhiLho, use algo como:

return (/[.]/.exec(filename)) ? /[^.]+$/.exec(filename) : undefined;

fetchFileExtention(fileName) { return fileName.slice((fileName.lastIndexOf(".") - 1 >>> 0) + 2); }

function extension(fname) { var pos = fname.lastIndexOf("."); var strlen = fname.length; if (pos != -1 && strlen != pos + 1) { var ext = fname.split("."); var len = ext.length; var extension = ext[len - 1].toLowerCase(); } else { extension = "No extension found"; } return extension; }

//uso

extensión (''archivo.jpeg'')

siempre devuelve la extensión inferior cas para que pueda verificar si el cambio de campo funciona para:

archivo.JpEg

archivo (sin extensión)

expediente. (no hay extensión)

function file_get_ext(filename) { return typeof filename != "undefined" ? filename.substring(filename.lastIndexOf(".")+1, filename.length).toLowerCase() : false; }

function func() { var val = document.frm.filename.value; var arr = val.split("."); alert(arr[arr.length - 1]); var arr1 = val.split("//"); alert(arr1[arr1.length - 2]); if (arr[1] == "gif" || arr[1] == "bmp" || arr[1] == "jpeg") { alert("this is an image file "); } else { alert("this is not an image file"); } }

function getExt(filename) { var ext = filename.split(''.'').pop(); if(ext == filename) return ""; return ext; }

function getFileExtension(filename) { var ext = /^.+/.([^.]+)$/.exec(filename); return ext == null ? "" : ext[1]; }

Probado con

"a.b" (=> "b") "a" (=> "") ".hidden" (=> "") "" (=> "") null (=> "")

también

"a.b.c.d" (=> "d") ".a.b" (=> "b") "a..b" (=> "b")

return filename.replace(//.([a-zA-Z0-9]+)$/, "$1");

Edición: Extrañamente (o quizás no lo sea), el $1 en el segundo argumento del método de reemplazo parece no funcionar ... Lo siento.

return filename.split(''.'').pop();

Mantenlo simple :)

Editar:

Esta es otra solución no regex que creo que es más eficiente:

return filename.substring(filename.lastIndexOf(''.'')+1, filename.length) || filename;

Hay algunos casos de esquina que se manejan mejor con la respuesta de VisioN a continuación, particularmente los archivos sin extensión ( .htaccess etc. incluidos).

Es muy eficaz y maneja los casos de esquina de una manera posiblemente mejor al devolver "" lugar de la cadena completa cuando no hay un punto o ninguna cadena antes del punto. Es una solución muy bien diseñada, aunque difícil de leer. Pégalo en la libreta de tus ayudantes y solo úsalo.

Edición antigua:

Una implementación más segura si se va a ejecutar en archivos sin extensión, o archivos ocultos sin extensión (vea el comentario de VisioN a la respuesta de Tom arriba) sería algo como esto

var a = filename.split("."); if( a.length === 1 || ( a[0] === "" && a.length === 2 ) ) { return ""; } return a.pop(); // feel free to tack .toLowerCase() here if you want

Si a.length es uno, es un archivo visible sin extensión, es decir. expediente

Si a[0] === "" y a.length === 2 es un archivo oculto sin extensión, es decir. .htaccess

Espero que esto ayude a aclarar los problemas con los casos un poco más complejos. En términos de rendimiento, creo que esta solución es un poco más lenta que las expresiones regulares en la mayoría de los navegadores. Sin embargo, para los propósitos más comunes, este código debe ser perfectamente utilizable.

var extension = fileName.substring(fileName.lastIndexOf(''.'')+1);

var file = "hello.txt"; var ext = (function(file, lio) { return lio === -1 ? undefined : file.substring(lio+1); })(file, file.lastIndexOf(".")); // hello.txt -> txt // hello.dolly.txt -> txt // hello -> undefined // .hello -> hello

var filetypeArray = (file.type).split("/"); var filetype = filetypeArray[1];

Este es un mejor enfoque imo.

var parts = filename.split(''.''); return parts[parts.length-1];