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

edit: Странно (или, может быть, это не так), во втором аргументе метода замены, похоже, не работает ... Извините.

Новое редактирование: Многое изменилось с тех пор, как этот вопрос был первоначально опубликован - в исправленный ответ Wallacer, а также в Отличный анализ VisioN есть много действительно хорошей информации

Редактировать: Просто потому, что это принятый ответ; ответ Wallacer действительно намного лучше:

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

Мой старый ответ:

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

Должен это сделать.

Редактировать: В ответ на комментарий PhiLho используйте что-то вроде:

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

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

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

Протестировано с

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

Также

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

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

Я просто понял, что недостаточно просто прокомментировать ответ p4bl0, хотя ответ Тома явно решает проблему:

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

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

//использование

расширение ('file.jpeg')

всегда возвращает расширение lower cas, чтобы вы могли проверить его при изменении поля работает на:

file.JpEg

файл (без расширения)

файл. (без расширения)

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

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

Будь проще :)

Редактировать:

Это еще одно решение без регулярных выражений, которое я считаю более эффективным:

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

Есть некоторые угловые случаи, которые лучше обрабатываются Ответ VisioN ниже, особенно файлы без расширения (включая .htaccess и т. д.).

Он очень производительный и обрабатывает угловые случаи, возможно, лучше, возвращая "" вместо полной строки, когда перед точкой нет точки или строки. Это очень хорошо продуманное решение, хотя и трудное для чтения. Вставьте его в свою библиотеку помощников и просто используйте.

Старое редактирование:

Более безопасная реализация, если вы собираетесь столкнуться с файлами без расширения или скрытыми файлами без расширения (см. Комментарий VisioN к ответу Тома выше), будет чем-то в этом роде

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

Если a.length один, это видимый файл без расширения, т.е. файл

Если a[0] === "" и a.length === 2, это скрытый файл без расширения, т.е. .htaccess

Надеюсь, это поможет прояснить проблемы с чуть более сложными случаями. Что касается производительности, я считаю, что это решение немного медленнее, чем регулярное выражение в большинстве браузеров. Однако для наиболее распространенных целей этот код должен идеально подходить для использования.

Для большинства приложений простой сценарий, например

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

будет работать нормально (как предусмотрено Томом). Однако это не доказательство от дурака. Это не сработает, если указано следующее имя файла:

image.jpg?foo=bar

Это может быть немного излишним, но я бы предложил использовать парсер URL-адресов, такой как Вот этот, чтобы избежать сбоя из-за непредсказуемых имен файлов.

Используя эту конкретную функцию, вы можете получить такое имя файла:

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

Это выведет "image.jpg" без переменных URL. Тогда вы можете получить расширение файла.

Попробуй это:

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

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

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

Следующее решение - быстрый и короткая, достаточное для использования в массовых операциях и экономии дополнительных байтов:

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

Вот еще одно однострочное универсальное решение без регулярных выражений:

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

Оба работают правильно с именами, не имеющими расширения (например, мой файл) или начинающимися с точки . (например, .htaccess):

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

Если вам важна скорость, вы можете запустить ориентир и проверить, что предоставленные решения являются самыми быстрыми, а короткое - чрезвычайно быстрым:

Как работает короткий:

1. Метод String.lastIndexOf возвращает последнюю позицию подстроки (т. Е. ".") в данной строке (т. Е. fname). Если подстрока не найдена, метод возвращает -1.
2. «Неприемлемыми» позициями точки в имени файла являются -1 и 0, которые соответственно относятся к именам без расширения (например, "name") и к именам, начинающимся с точки (например, ".htaccess").
3. Оператор сдвига вправо с заполнением нулями (>>>), если используется с нулем, влияет на отрицательные числа, преобразуя -1 в 4294967295 и -2 в 4294967294, что полезно для сохранения неизменного имени файла в крайних случаях (здесь вроде уловки).
4. String.prototype.slice извлекает часть имени файла из позиции, которая была рассчитана, как описано. Если номер позиции больше длины строки, метод возвращает "".

Если вам нужно более четкое решение, которое будет работать таким же образом (плюс с дополнительной поддержкой полного пути), проверьте следующую расширенную версию. Это решение будет помедленнее, чем предыдущие однострочные, но его гораздо легче понять.

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.info( getExtension("/path/to/file.ext") );
// >> "ext"

Все три варианта должны работать в любом веб-браузере на стороне клиента и могут также использоваться в коде NodeJS на стороне сервера.

Ответ Уоллесера хорош, но нужна еще одна проверка.

Если у файла нет расширения, он будет использовать имя файла как расширение, что нехорошо.

Попробуй это:

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

Не забывайте, что некоторые файлы не могут иметь расширения, поэтому:

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

Быстро и корректно работает с путями

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

Некоторые крайние случаи

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

Решения с использованием split работают медленно, а решения с lastIndexOf не обрабатывают крайние случаи.

я просто хотел поделиться этим.

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

хотя это имеет недостаток, что файлы без расширения будут возвращать последнюю строку. но если вы это сделаете, это исправит все:

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

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

Имо, это лучший подход.

Если вы ищете конкретное расширение и знаете его длину, вы можете использовать substr:

var file1 = "50.xsl";

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

Ссылка на JavaScript:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr

Я опаздываю на вечеринку на много лун, но для простоты использую что-то вроде этого

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>

В node.js этого можно добиться с помощью следующего кода:

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

Однострочное решение, которое также будет учитывать параметры запроса и любые символы в URL-адресе.

string.match(/(.*)\??/i).shift().replace(/\?.*/, '').split('.').pop()

// Example
// some.url.com/with.in/&ot.s/files/file.jpg?spec=1&.ext=jpg
// jpg

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

Код

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

Тестовое задание

Обратите внимание, что в отсутствие запроса фрагмент все еще может присутствовать.

"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 Предупреждения.

Это простое решение

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

Тесты

/* 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.info(result, input);
  else
    console.error(result, input);
}

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

Я уверен, что кто-то сможет и будет минимизировать и / или оптимизировать мой код в будущем. Но, что касается прямо сейчас, я на 200% уверен, что мой код работает в каждой уникальной ситуации (например, только с только имя файла, с URL относительный, коренной родственник и абсолютный, с тегами фрагмент#, со строками запрос? и другими решите бросить на него), безупречно и с высокой точностью.

Для подтверждения посетите: https://projects.jamesandersonjr.com/web/js_projects/get_file_extension_test.php

Вот JSFiddle: https://jsfiddle.net/JamesAndersonJr/ffcdd5z3/

Чтобы не быть самоуверенным или трубить в свою собственную трубу, но я не видел блок кода Любые для этой задачи (поиск расширения файла 'правильный' среди множества различных входных аргументов function), который работает так же хорошо, как это.

Примечание: По замыслу, если расширение файла не существует для данной входной строки, оно просто возвращает пустую строку "", а не ошибку или сообщение об ошибке.

It takes two arguments:

• String: fileNameOrURL(self-explanatory)

• Boolean: showUnixDotFiles (Whether or Not to show files that begin with a dot ".")

Заметка 2): Если вам нравится мой код, обязательно добавьте его в свою js-библиотеку и / или репозиторий, потому что я много работал над его совершенствованием, и было бы стыдно потратить впустую. Итак, без лишних слов, вот он:

function getFileExtension(fileNameOrURL, showUnixDotFiles)
    {
        /* First, let's declare some preliminary variables we'll need later on. */
        var fileName;
        var fileExt;
        
        /* Now we'll create a hidden anchor ('a') element (Note: No need to append this element to the document). */
        var hiddenLink = document.createElement('a');
        
        /* Just for fun, we'll add a CSS attribute of [ style.display = "none" ]. Remember: You can never be too sure! */
        hiddenLink.style.display = "none";
        
        /* Set the 'href' attribute of the hidden link we just created, to the 'fileNameOrURL' argument received by this function. */
        hiddenLink.setAttribute('href', fileNameOrURL);
        
        /* Now, let's take advantage of the browser's built-in parser, to remove elements from the original 'fileNameOrURL' argument received by this function, without actually modifying our newly created hidden 'anchor' element.*/ 
        fileNameOrURL = fileNameOrURL.replace(hiddenLink.protocol, ""); /* First, let's strip out the protocol, if there is one. */
        fileNameOrURL = fileNameOrURL.replace(hiddenLink.hostname, ""); /* Now, we'll strip out the host-name (i.e. domain-name) if there is one. */
        fileNameOrURL = fileNameOrURL.replace(":" + hiddenLink.port, ""); /* Now finally, we'll strip out the port number, if there is one (Kinda overkill though ;-)). */  
        
        /* Now, we're ready to finish processing the 'fileNameOrURL' variable by removing unnecessary parts, to isolate the file name. */
        
        /* Operations for working with [relative, root-relative, and absolute] URL's ONLY [BEGIN] */ 
        
        /* Break the possible URL at the [ '?' ] and take first part, to shave of the entire query string ( everything after the '?'), if it exist. */
        fileNameOrURL = fileNameOrURL.split('?')[0];

        /* Sometimes URL's don't have query's, but DO have a fragment [ # ](i.e 'reference anchor'), so we should also do the same for the fragment tag [ # ]. */
        fileNameOrURL = fileNameOrURL.split('#')[0];

        /* Now that we have just the URL 'ALONE', Let's remove everything to the last slash in URL, to isolate the file name. */
        fileNameOrURL = fileNameOrURL.substr(1 + fileNameOrURL.lastIndexOf("/"));

        /* Operations for working with [relative, root-relative, and absolute] URL's ONLY [END] */ 

        /* Now, 'fileNameOrURL' should just be 'fileName' */
        fileName = fileNameOrURL;
        
        /* Now, we check if we should show UNIX dot-files, or not. This should be either 'true' or 'false'. */  
        if ( showUnixDotFiles == false )
            {
                /* If not ('false'), we should check if the filename starts with a period (indicating it's a UNIX dot-file). */
                if ( fileName.startsWith(".") )
                    {
                        /* If so, we return a blank string to the function caller. Our job here, is done! */
                        return "";
                    };
            };
        
        /* Now, let's get everything after the period in the filename (i.e. the correct 'file extension'). */
        fileExt = fileName.substr(1 + fileName.lastIndexOf("."));

        /* Now that we've discovered the correct file extension, let's return it to the function caller. */
        return fileExt;
    };

Наслаждаться! Добро пожаловать !:

Если вы имеете дело с веб-адресами, вы можете использовать:

function getExt(filepath){
     return filepath.split("?")[0].split("#")[0].split('.').pop();
}

getExt("../js/logic.v2.min.js") // js
getExt("http://example.net/site/page.php?id=16548") // php
getExt("http://example.net/site/page.html#welcome.to.me") // html
getExt("c:\logs\yesterday.log"); // log

Демо: https://jsfiddle.net/squadjot/q5ard4fj/

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

Я предпочитаю использовать lodash для большинства вещей, поэтому вот решение:

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

Для этого в модуле path есть стандартная библиотечная функция:

import path from 'path';

console.info(path.extname('abc.txt'));

Выход:

.txt

Итак, если вам нужен только формат:

path.extname('abc.txt').slice(1) // 'txt'

Если расширения нет, функция вернет пустую строку:

path.extname('abc') // ''

Если вы используете Node, то path является встроенным. Если вы ориентируетесь на браузер, тогда Webpack объединит для вас реализацию path. Если вы настраиваете браузер без Webpack, вы можете включить просмотр пути вручную.

Нет причин делать разбиение строк или регулярное выражение.

"однострочный" для получения имени файла и расширения с использованием reduce и деструктуризация массива:

var str = "filename.with_dot.png";
var [filename, extension] = str.split('.').reduce((acc, val, i, arr) => (i == arr.length - 1) ? [acc[0].substring(1), val] : [[acc[0], val].join('.')], [])

console.info({filename, extension});

с лучшим отступом:

var str = "filename.with_dot.png";
var [filename, extension] = str.split('.')
   .reduce((acc, val, i, arr) => (i == arr.length - 1) 
       ? [acc[0].substring(1), val] 
       : [[acc[0], val].join('.')], [])


console.info({filename, extension});

// {
//   "filename": "filename.with_dot",
//   "extension": "png"
// }

Я знаю, что это старый вопрос, но я написал эту функцию с тестами для извлечения расширения файла, и она доступна с NPM, Yarn, Bit.
Может кому поможет. https://bit.dev/joshk/jotils/get-file-extension

function getFileExtension(path: string): string {
    var regexp = /\.([0-9a-z]+)(?:[\?#]|$)/i
    var extension = path.match(regexp)
    return extension && extension[1]
}

Вы можете увидеть тесты, которые я написал здесь.

Простой способ получить имя файла даже с несколькими точками в имени

var filename = "my.filehere.txt";

file_name =  filename.replace('.'+filename.split('.').pop(),'');

console.info("Filename =>"+file_name);

OutPut: my.filehere

extension = filename.split('.').pop();
console.info("Extension =>"+extension);

Вывод: txt

Попробуйте это однострочный код

Также существует простой подход с использованием деструктуризации ES6:

const path = 'hello.world.txt'
const [extension, ...nameParts] = path.split('.').reverse();
console.info('extension:', extension);