Переглянути код:

var file1 = "50.xsl";
var file2 = "30.doc";
getFileExtension(file1); //returns xsl
getFileExtension(file2); //returns doc

function getFileExtension(filename) {
    /*TODO*/
}

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

Правка: Просто тому, що це прийнята відповідь; Відповідь Wallacer дійсно набагато краща:

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

Моя стара відповідь:

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

Повинен це робити.

Редагувати: У відповідь на коментар PhiLho використовуйте щось на кшталт:

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

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

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

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 getExt(filename)
{
    var ext = filename.split('.').pop();
    if(ext == filename) return "";
    return ext;
}

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

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

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

Код

/**
 * 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 Попередження.

Швидко і правильно працює з доріжками

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

Деякі крайні корпуси

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

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

Я просто хотів цим поділитися.

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

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

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

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

Для підтвердження відвідайте: https://projects.jamesandersonjr.com/web/js_projects/get_file_extension_test.php

Ось JSFiddle: https://jsfiddle.net/JamesAndersonJr/ffcdd5z3/

Щоб не бути самовпевненим або не дути мою власну трубу, але я не бачив жодного блоку коду для цієї задачі (знаходження «правильного» розширення файлу, серед батареї різних functionвхідних аргументів), який би добре працював.

Примітка. Якщо розширення файлу для даного вхідного рядка не існує, воно просто повертає порожній рядок "", а не помилку чи повідомлення про помилку.

Це бере два аргументи:

• Рядок: fileNameOrURL (сам пояснення)

• Boolean: showUnixDotFiles (Не показувати чи ні файли, які починаються з крапки ".")

Примітка (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/

Спробуйте це:

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

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

редагувати: Дивно (або, можливо, це не так), $1у другому аргументі методу заміни, здається, не працює ... Вибачте.

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

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

Для більшості програм простий сценарій, такий як

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

працювало б чудово (як надав Том). Однак це не дурне доказ. Не працює, якщо вказано таке ім’я файлу:

image.jpg?foo=bar

Це може бути трохи зайвим, але я б запропонував використовувати URL-аналізатор, такий як цей щоб уникнути помилки через непередбачувані назви файлів.

Використовуючи цю особливу функцію, ви можете отримати ім'я файлу таким чином:

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

Це виведе "image.jpg" без URL-адрес. Тоді ви можете безкоштовно схопити розширення файлу.

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 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')

завжди повертає нижню лічильник розширення, щоб ви могли перевірити це, чи працює зміна поля для:

file.JpEg

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

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

Якщо ви шукаєте певне розширення і знаєте його довжину, ви можете використовувати 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>

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

import path from 'path';

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

Вихід:

.txt

Отже, якщо ви хочете лише формат:

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

Якщо розширення немає, функція поверне порожній рядок:

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

Якщо ви використовуєте Node, то pathвбудований. Якщо ви орієнтуєтесь на браузер, то Webpack приєднає pathдля вас реалізацію. Якщо ви орієнтуєтесь на браузер без Webpack, ви можете включити перегляд маршрутів вручну.

Немає підстав робити розбивання рядків або регулярний вираз.

"one-liner", щоб отримати ім'я файлу та розширення, використовуючи 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.log({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.log({filename, extension});

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

Рішення в одному рядку, яке також враховуватиме параметри запитів та будь-які символи в URL-адресі.

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

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

Це просте рішення

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

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

Відповідь Валласера ​​приємна, але потрібна ще одна перевірка.

Якщо файл не має розширення, він буде використовувати ім'я файлу як розширення, що не є добре.

Спробуйте це:

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

Не забувайте, що деякі файли не можуть мати розширення, тому:

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

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

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