Bkz. Kod:

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

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

Daha Yeni Düzenleme: Bu soru başlangıçta yayınlandığından beri pek çok şey değişti - wallacer'in gözden geçirilmiş cevabında ve VisioN'un mükemmel dökümünde çok iyi bilgiler var

Düzenleme: Sadece bu kabul edilen cevap olduğu için; wallacer'in cevabı gerçekten çok daha iyi:

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

Eski cevabım:

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

Yapmalı.

Düzenleme: PhiLho'nun yorumuna yanıt olarak, şöyle bir şey kullanın:

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

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

Basit tutun :)

Düzenle:

Bu daha verimli olduğuna inanıyorum regex olmayan bir başka çözümdür:

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

VisioN'un aşağıdaki cevabı ile daha iyi ele alınan bazı köşe vakaları , özellikle uzantısız dosyalar ( .htaccessvb.) Vardır .

Çok performanslıdır ve ""noktadan önce nokta yoksa ya da dize olmadığında, tam dize yerine geri dönerek köşe vakalarını tartışmasız daha iyi bir şekilde işler . Okuması zor olsa da çok iyi hazırlanmış bir çözümdür. Yardımcılarınızın lib'sine yapıştırın ve kullanın.

Eski Düzenleme:

Uzantısı olmayan dosyalarda veya uzantısı olmayan gizli dosyalarda çalışacaksanız daha güvenli bir uygulama (VisioN'un Tom'un yukarıdaki cevabı hakkındaki yorumuna bakın) bu satırlar boyunca bir şey olurdu

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

Biriyse a.length, uzantısı olmayan görünür bir dosyadır. dosya

Eğer a[0] === ""ve a.length === 2uzantısı olmayan gizli bir dosya yani. .htaccess

Umarım bu biraz daha karmaşık vakalarla ilgili sorunları gidermeye yardımcı olur. Performans açısından, bu çözümün çoğu tarayıcıda normal ifadeden biraz daha yavaş olduğuna inanıyorum . Bununla birlikte, en yaygın amaçlar için bu kod mükemmel şekilde kullanılabilir olmalıdır.

Aşağıdaki çözüm, toplu işlemlerde kullanmak ve ekstra bayt tasarrufu yapmak için yeterince hızlı ve kısadır :

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

İşte bir tek satırlık normal ifade dışı evrensel çözüm:

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

Her ikisi de uzantısı olmayan (örn. Dosyam ) veya .nokta (ör. .Htaccess ) ile başlayan adlarla düzgün çalışır :

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

Hızı önemsiyorsanız, karşılaştırmayı çalıştırabilir ve sağlanan çözümlerin en hızlı olup olmadığını, kısa olanın muazzam hızlı olduğunu kontrol edebilirsiniz:

Kısa olan nasıl çalışır:

1. String.lastIndexOfyöntemi, verilen dizgideki (ie ".") alt dizenin (yani ) son konumunu döndürür fname. Alt dize bulunmazsa yöntem döndürür -1.
2. Dosya adındaki "kabul edilemez" nokta konumları -1ve 0sırasıyla uzantısız isimler (örn. "name") Ve nokta (örn. ".htaccess") İle başlayan isimlerdir .
3. Sıfır dolgu sağa kaydırma operatörü ( >>>sıfır ile kullanıldığı takdirde) negatif sayılar transforme etki -1için 4294967295ve -2üzere 4294967294(çeşit bir numara burada) kenar durumlarda değişmeden dosya kalan için yararlı olan.
4. String.prototype.slicedosya adının bir kısmını açıklandığı gibi hesaplanan konumdan çıkarır. Konum numarası string yönteminin uzunluğundan fazlaysa geri döner "".

Aynı şekilde çalışacak daha net bir çözüm istiyorsanız (artı tam yol desteği ile), aşağıdaki genişletilmiş sürümü kontrol edin. Bu çözüm önceki tek astarlardan daha yavaş olacaktır , ancak anlaşılması çok daha kolaydır.

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"

Her üç değişken de istemci tarafındaki herhangi bir web tarayıcısında çalışmalı ve sunucu tarafı NodeJS kodunda da kullanılabilir.

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

İle test edildi

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

Ayrıca

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

kod

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

Ölçek

Bir sorgu olmadığında, parçanın hala mevcut olabileceğine dikkat edin.

"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 Uyarılar.

Hızlıdır ve yollarla düzgün çalışır

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

Bazı kenar durumlarda

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

Split kullanan çözümler yavaştır ve lastIndexOf ile yapılan çözümler uç durumları ele almaz.

sadece bunu paylaşmak istedim.

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

bunun uzantısı olmayan dosyaların son dizgiyi döndüreceği konusunda bir çöküşü olsa da. ancak bunu yaparsanız her şey düzeltilecektir:

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

Eminim birisi gelecekte kodumu küçültebilir ve / veya optimize edebilir ve olacaktır. Ancak, şu an itibariyle, kodumun her benzersiz durumda çalıştığından% 200 eminim (örneğin, yalnızca dosya adıyla , göreli , kök göreli ve mutlak URL'lerle, parça # etiketleriyle, sorgu ? dizeleriyle ve her neyse aksi takdirde, atmaya karar verebilirsiniz), kusursuz ve hassas nokta hassasiyetiyle.

Kanıt için şu adresi ziyaret edin: https://projects.jamesandersonjr.com/web/js_projects/get_file_extension_test.php

İşte JSFiddle: https://jsfiddle.net/JamesAndersonJr/ffcdd5z3/

Kendine fazla güvenmemek ya da kendi trompetimi üflemek değil, ama bu görev için herhangi bir kod bloğu görmedim ( bu da işe yaradığı gibi (farklı giriş argümanlarının bir pili ortasında 'doğru' dosya uzantısını bulma function).

Not: Tasarım gereği, belirtilen giriş dizesi için bir dosya uzantısı yoksa, boş bir dize döndürür "", hata veya hata iletisi döndürmez .

İki argüman alır:

• Dize: fileNameOrURL (açıklayıcı)

• Boolean: showUnixDotFiles (Nokta "." İle başlayan dosyaların gösterilip gösterilmeyeceği)

Not (2): Kodumu beğendiyseniz, js kütüphanenize ve / veya repo'larınıza eklediğinizden emin olun, çünkü mükemmelleştirmek için çok çalıştım ve boşa gitmek utanç verici olurdu. Yani, daha fazla uzatmadan, işte burada:

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

Zevk almak! Hiç önemli değil!:

Web URL'leriyle ilgileniyorsanız şunları kullanabilirsiniz:

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

Demo: https://jsfiddle.net/squadjot/q5ard4fj/

Bunu dene:

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

edit: Garip bir şekilde (ya da belki de değil) $1replace yönteminin ikinci argümanında çalışmıyor gibi görünüyor ... Üzgünüm.

Tom'un cevabı sorunu açıkça çözmesine rağmen, p4bl0'ın cevabına yorum yapmanın yeterli olmadığını fark ettim:

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

Çoğu uygulama için basit bir komut dosyası gibi

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

(Tom tarafından sağlanan) iyi çalışır. Ancak bu aptalca bir kanıt değildir. Aşağıdaki dosya adı belirtilmişse çalışmaz:

image.jpg?foo=bar

Biraz overkill olabilir ama gibi bir url ayrıştırıcı kullanarak öneririm bu bir nedeni öngörülemeyen dosya için önlemek başarısızlığa.

Bu özel işlevi kullanarak, dosya adını şu şekilde alabilirsiniz:

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

URL değişmeden "image.jpg" çıktısı alınır. O zaman dosya uzantısını almakta özgürsünüz.

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

// kullanım

uzantı ( 'file.jpeg')

her zaman uzantı alt casunu döndürür, böylece alan değişikliği çalışmalarında kontrol edebilirsiniz:

file.JpEg

dosya (uzantı yok)

dosya. (Noextension)

Belirli bir uzantı arıyorsanız ve uzunluğunu biliyorsanız, substr'yi kullanabilirsiniz :

var file1 = "50.xsl";

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

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

Partiye geç aylarım ama basitlik için böyle bir şey kullanıyorum

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>

Modülde bunun için standart bir kütüphane işlevi vardır path:

import path from 'path';

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

Çıktı:

.Txt

Yani, yalnızca biçimi istiyorsanız:

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

Herhangi bir uzantı yoksa, işlev boş bir dize döndürür:

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

Düğüm kullanıyorsanız path, yerleşiktir. Tarayıcıyı hedefliyorsanız, Webpack pathsizin için bir uygulama paketleyecektir . Tarayıcıyı Web paketi olmadan hedefliyorsanız, el ile yol tarayıcısı ekleyebilirsiniz .

Dize bölme veya normal ifade yapmak için bir neden yoktur.

Dosya adı ve uzantıyı kullanarak reduceve dizi yıkımını almak için "tek satırlı" :

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

daha iyi girinti ile:

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"
// }

Ayrıca sorgu parametrelerini ve url'deki karakterleri de hesaba katacak tek satırlık bir çözüm.

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

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

Bu basit çözüm

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

Testler

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

Wallacer'ın cevabı güzel, ama bir tane daha kontrol gerekiyor.

Dosyanın uzantısı yoksa, uzantı olarak dosya adını iyi olmayan bir dosya kullanır.

Bunu dene:

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

Bazı dosyaların uzantısının olmayabileceğini unutmayın, bu nedenle:

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