501

कोड देखें:

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

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

javascript file-extension

— सर्जियो डेल अमो
स्रोत

794

नया संपादित करें: इस प्रश्न को शुरू में पोस्ट किए जाने के बाद से बहुत सारी चीजें बदल गई हैं - वालर के संशोधित उत्तर के साथ-साथ विज़ियोएन के उत्कृष्ट ब्रेकडाउन में वास्तव में बहुत अच्छी जानकारी है

संपादित करें: सिर्फ इसलिए कि यह स्वीकृत उत्तर है; Wallacer का जवाब वास्तव में बहुत बेहतर है:

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

मेरा पुराना उत्तर:

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

करना चाहिए।

संपादित करें: PhiLho की टिप्पणी के जवाब में, कुछ इस तरह का उपयोग करें:

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

— चलता है
स्रोत

1

क्या रेगेक्स को दो बार क्रियान्वित करना महंगा नहीं है?

— एंड्रयू हेजेज

5

नीचे उच्च श्रेणी का उत्तर बेहतर है।

— fletom

2

दुर्भाग्य से दोनों समाधान फ़ाइल और .htaccess जैसे नामों के लिए विफल होते हैं ।

— VisioN

3

सभी संभावित मामलों को निम्नानुसार संसाधित किया जाता है: रिटर्न फाइलनाम। एसपीएलआईटी ("।")। स्लाइस (1) .pop () || "";

— JustAndrei

1

@JustAndrei अभी भी सभी :) शुद्ध फ़ाइल नाम (बेसनेम?) के लिए नहीं, व्यावहारिक कारणों से, मुझे लगता है कि यह होना चाहिए return filename.substring(0,1) === '.' ? '' : filename.split('.').slice(1).pop() || '';यह ध्यान रखता है .file(यूनिक्स छिपा हुआ है, मेरा मानना है) तरह की फाइलें भी। यदि आप इसे एक-लाइनर के रूप में रखना चाहते हैं, जो मेरे स्वाद के लिए थोड़ा गड़बड़ है।

— कूकर

832

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

आशा है कि यह थोड़ा और अधिक जटिल मामलों के साथ मुद्दों को स्पष्ट करने में मदद करता है। प्रदर्शन के संदर्भ में, मेरा मानना है कि यह समाधान अधिकांश ब्राउज़रों में रेगेक्स की तुलना में थोड़ा धीमा है । हालांकि, अधिकांश सामान्य उद्देश्यों के लिए यह कोड पूरी तरह से प्रयोग करने योग्य होना चाहिए।

— wallacer
स्रोत

4

मैं प्रदर्शन पर टिप्पणी नहीं कर सकता, लेकिन यह निश्चित रूप से साफ दिखता है! मैं इसका उपयोग कर रहा हूँ। +1

— PC1oad1etter

6

लेकिन इस मामले में फ़ाइल का नाम filname.tes.test.jpg जैसा दिखता है। कृपया उत्पादन पर विचार करें। मुझे उम्मीद है कि यह गलत होगा।

— फेरो

19

उस स्थिति में आउटपुट "jpg" है

— दीवार निर्माता

1

प्रतिभाशाली! बहुत बहुत धन्यवाद। रेगेक्स का उपयोग न करते हुए समाधान देखना अच्छा है; मैंने इसे PHP के साथ किया है और यह केवल कुछ फ़ंक्शन का उपयोग करता है। +1

— बंजेंगल्स

3

@ डेवलपर: यदि filenameवास्तव में एक्सटेंशन नहीं है तो क्या होगा ? क्या यह केवल आधार फाइलनाम नहीं लौटाएगा, जो थोड़े बुरा होगा?

— निकोल बोलस

287

निम्नलिखित समाधान तेज और काफी कम है जो बल्क ऑपरेशन में उपयोग करते हैं और अतिरिक्त बाइट्स को बचाने के लिए हैं:

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

यहाँ एक और एक गैर-रेगेक्सप सार्वभौमिक समाधान है:

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

दोनों बिना विस्तार वाले नामों (जैसे myfile ) या .डॉट (जैसे .htaccess ) से शुरू होने के साथ सही ढंग से काम करते हैं ।

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

यदि आप उस गति की परवाह करते हैं जो आप बेंचमार्क को चला सकते हैं और जांच सकते हैं कि प्रदान किए गए समाधान सबसे तेज़ हैं, जबकि छोटा एक बहुत तेज़ है:

गति तुलना

कैसे छोटा काम करता है:

String.lastIndexOfविधि "."दिए गए स्ट्रिंग (यानी fname) में विकल्प (यानी ) की अंतिम स्थिति लौटाता है । यदि सबस्ट्रिंग विधि रिटर्न नहीं मिली है -1।
फ़ाइल नाम में डॉट के "अस्वीकार्य" स्थान हैं -1 और 0जो क्रमश: कोई विस्तार (जैसे के साथ नाम का उल्लेख "name") और ऐसे नाम हैं जो डॉट (जैसे के साथ शुरू करने के लिए ".htaccess")।
शून्य को भरने सही पारी ऑपरेटर ( >>>) शून्य के साथ प्रयोग किया है, तो प्रभावित बदलने ऋणात्मक संख्याओं -1को 4294967295और-2 करने के लिए 4294967294है, जो फ़ाइल नाम बढ़त मामलों में कोई बदलाव नहीं (एक चाल की तरह यहाँ) शेष के लिए उपयोगी है।
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 कोड में भी इस्तेमाल किया जा सकता है।

— दृष्टि
स्रोत

5

काम नहीं करता। "anhome/user/.app/config" "ऐप / कॉन्फिगर" लौटाता है, जो पूरी तरह से गलत है।

— श्रीब्रांडो

33

@mrbrdo यह विधि केवल फ़ाइल नाम के साथ पूर्ण पथ के साथ काम करने के लिए नहीं है, जैसा कि प्रश्न द्वारा अनुरोध किया गया है। डाउनवोटिंग से पहले प्रश्न को ध्यान से पढ़ें।

— VisioN

8

कोड की ऐसी तुच्छ रेखा को अनुकूलित करने के लिए लंबाई क्यों जाएं? टिल्ड और बिटशिफ्ट ऑपरेटरों को शायद ही कभी जावास्क्रिप्ट में देखा जाता है कि मैं इस तरह के उत्तर का समर्थन नहीं कर सकता। यदि यह समझाने के लिए 5 बुलेट पॉइंट्स लेते हैं कि कोड की 1 लाइन कैसे काम करती है, तो कोड को फिर से लिखना बेहतर है ताकि यह वास्तव में समझ में आ सके।

— जैक्सन

6

इस एक पंक्ति की गति किसी भी अनुप्रयोग में कोई बोधगम्य अंतर नहीं करेगी। बिटवाइज़ का उपयोग शायद ही कभी किया जाता है, जैसे कि लोकप्रिय लिसलर्स जैसे JSLint और JSHint उनका उपयोग करने के खिलाफ चेतावनी देते हैं। इस तर्क के प्रदर्शन और कॉम्पैक्टनेस पर ध्यान देने से कोड की गुणवत्ता में गिरावट आई है; यदि कोड को "अतिरिक्त जांच" की आवश्यकता है, तो मैं इसे "बुरा" मानता हूं।

— जैक्सन

10

@ जैक्सन इस पर विचार करते हुए किसी समस्या के कई समाधान पेश करने के लिए एक साइट है, एक समाधान है जो प्रदर्शन का अनुकूलन करता है वह कभी भी खराब नहीं होता है। आप बयान कर रहे हैं "किसी भी आवेदन में कोई बोधगम्य अंतर नहीं होगा" पूरी तरह से संभव अनुप्रयोगों के आपके संकीर्ण दायरे पर आधारित है जिसमें इसका उपयोग किया जा सकता है। इसके अलावा, यह किसी को समस्या को सीखने के अनुभव को देखते हुए प्रदान कर सकता है जिसमें वे कुछ का अनुकूलन कर सकते हैं। अन्य कोड वे एक कंप्यूटिंग गहन अनुप्रयोग वे लिख रहे हैं के लिए बनाने की जरूरत है।

— nrylee

33

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

— PhiLho
स्रोत

इसे IE में काम करने के लिए: var pattern = "^ + + \\। ([^।] +) $"; var ext = new RegExp (पैटर्न);

— १

20

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

— दीमा
स्रोत

8

वापसी (ext === फ़ाइल नाम) '': ext;

— मिकिएल

13

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

— Pono
स्रोत

8

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

— रैंडी सुगियंटो 'युकू'
स्रोत

8

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

— जो स्काइला
स्रोत

8

कोड

/**
 * 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 चेतावनी।

— जैक
स्रोत

7

फास्ट और पथ के साथ सही ढंग से काम करता है

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

कुछ किनारे मामले

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

विभाजन का उपयोग करने वाले समाधान धीमे होते हैं और lastIndexOf के साथ समाधान किनारे के मामलों को संभालते नहीं हैं।

— mrbrdo
स्रोत

किन किन मामलों का मतलब है? कृपया यहां मेरे समाधान देखें: stackoverflow.com/a/12900504/1249581 । यह सभी मामलों में ठीक काम करता है और किसी भी रेगेक्स एक की तुलना में बहुत तेज है।

— VisioN

मैंने पहले ही किनारे के मामलों को सूचीबद्ध कर लिया है। और आपका समाधान उन्हें ठीक से नहीं संभालता है। जैसे मैंने पहले ही लिखा है, "/dir.with.dot/file" आज़माएँ। आपका कोड "डॉट / फाइल" लौटाता है जो हास्यास्पद है।

— श्रीब्रांडो

1

किसी ने मार्ग को पार्स करने का अनुरोध नहीं किया। सवाल फाइलनाम से एक्सटेंशन निकालने के बारे में था।

— विसिओएन

3

जैसा कि मैंने आपको पहले ही बताया था, यह स्पष्ट रूप से कभी नहीं कहा गया था, और एक समाधान जो पथों को संभालता है वह स्पष्ट रूप से बहुत अधिक उपयोगी है। SO पर एक प्रश्न का उत्तर प्रश्न पूछने वाले व्यक्ति के अलावा अन्य लोगों के लिए उपयोगी माना जाता है। मैं वास्तव में ऐसा समाधान नहीं सोचता हूं जो इनपुट का एक सुपरसेट संभालता है, उसे डाउनवोट किया जाना चाहिए।

— mrbrdo

3

चढ़ाव के साथ वैश्विक चर का उपयोग करने के लिए था .exec()। आपका कोड के रूप में बेहतर हो जाएगा (filename.match(/[^\\/]\.([^\\/.]+)$/) || [null]).pop()।

— VisioN

6

मैं बस इसे साझा करना चाहता था।

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

हालांकि इसमें एक गिरावट है कि बिना विस्तार वाली फाइलें अंतिम स्ट्रिंग पर लौट आएंगी। लेकिन अगर आप ऐसा करते हैं तो यह हर चीज़ को ठीक कर देगा:

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

— हुसैन नज्जल
स्रोत

जहाँ तक मुझे याद है कि sliceविधि तार के बजाय सरणियों को संदर्भित करती है। तार के लिए substrया substringकाम करेगा।

— VisioN

@VisioN, लेकिन मुझे लगता है कि आपको पता होना चाहिए कि यह भी है String.prototype.sliceऔर Array.prototype.sliceइसलिए यह दोनों ही काम करने के तरीके हैं

— हुसैन नाजल

1

आह येस। तुम सही हो। इस पद्धति के बारे में पूरी तरह से भूल गया। मेरी गलती।

— VisioN

5

मुझे यकीन है कि भविष्य में कोई मेरे कोड को वसीयत कर सकता है और कर सकता है, और / या अपने कोड को ऑप्टिमाइज़ कर सकता है। लेकिन, के रूप में अभी , मैं 200% विश्वास है कि मेरे कोड (जैसे हर अनोखी स्थिति में काम करता है बस के साथ कर रहा हूँ केवल फ़ाइल नाम के साथ, रिश्तेदार , जड़-रिश्तेदार , और निरपेक्ष , साथ यूआरएल टुकड़ा # टैग, साथ क्वेरी ? तार, और जो कुछ भी अन्यथा, आप इसे फेंकने का फैसला कर सकते हैं), निर्दोष रूप से, और पिन-पॉइंट परिशुद्धता के साथ।

प्रमाण के लिए, यहां जाएं: https://projects.jamesandersonjr.com/web/js_projects/get_file_extension_test.php

यहाँ JSFiddle: https://jsfiddle.net/JamesAndersonJr/ffcdd5z3/

ओवरकॉन्फिडेंट होने के लिए, या अपने स्वयं के तुरही को उड़ाने के लिए नहीं, लेकिन मैंने इस कार्य के लिए कोड का कोई ब्लॉक नहीं देखा है ( अलग-अलग बैटरी के बीच 'सही' फ़ाइल एक्सटेंशन ढूंढना है )function इनपुट तर्कों जो काम करता है।

नोट: डिज़ाइन के अनुसार, यदि कोई फ़ाइल एक्सटेंशन दिए गए इनपुट स्ट्रिंग के लिए मौजूद नहीं है, तो यह केवल एक रिक्त स्ट्रिंग "", एक त्रुटि और न ही एक त्रुटि संदेश देता है।

इसमें दो तर्क दिए गए हैं:

स्ट्रिंग: fileNameOrURL (स्व-व्याख्यात्मक)

बूलियन: 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;
    };

का आनंद लें! आपका बहुत - बहुत स्वागत है!:

— जेम्स एंडरसन जूनियर।
स्रोत

1

बहुत बढ़िया। धन्यवाद!

— गुल्लीझार

5

// 获取文件后缀名
function getFileExtension(file) {
  var regexp = /\.([0-9a-z]+)(?:[\?#]|$)/i;
  var extension = file.match(regexp);
  return extension && extension[1];
}

console.log(getFileExtension("https://www.example.com:8080/path/name/foo"));
console.log(getFileExtension("https://www.example.com:8080/path/name/foo.BAR"));
console.log(getFileExtension("https://www.example.com:8080/path/name/.quz/foo.bar?key=value#fragment"));
console.log(getFileExtension("https://www.example.com:8080/path/name/.quz.bar?key=value#fragment"));

स्निपेट का विस्तार करें

— 山茶树和葡萄树
स्रोत

5

यदि आप वेब यूआरएल के साथ काम कर रहे हैं, तो आप इसका उपयोग कर सकते हैं:

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/

— जकोब स्टर्नबर्ग
स्रोत

मुझे वास्तव में आपका समाधान पसंद है। यह बहुत कम के साथ इतना करता है। मैं इसका उपयोग करने वाला हूं।

— जूल्स मैनसन

4

इसे इस्तेमाल करे:

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

— एडवर्ड
स्रोत

3

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

संपादित करें: अजीब तरीके से (या शायद यह नहीं है) $1प्रतिस्थापित विधि के दूसरे तर्क में काम नहीं लगता ... क्षमा करें।

— p4bl0
स्रोत

1

यह सही काम करता है, लेकिन आप चूक गए हैं कि आपको स्ट्रिंग के अन्य सभी कंटेंट को हटाना होगा: रिटर्न फाइलनाम .replace (/^.*! \?) [[A-zA-Z0-9] +) $ /,। "$ 1");

— रोइंग

3

मुझे बस एहसास हुआ कि यह p4bl0 के उत्तर पर टिप्पणी करने के लिए पर्याप्त नहीं है, हालांकि टॉम का जवाब स्पष्ट रूप से समस्या का हल करता है:

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

— roenving
स्रोत

3

अधिकांश अनुप्रयोगों के लिए, एक सरल स्क्रिप्ट जैसे

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

बस ठीक काम करेगा (टॉम द्वारा प्रदान की गई)। हालांकि यह मूर्खतापूर्ण सबूत नहीं है। निम्न फ़ाइल नाम प्रदान किए जाने पर यह काम नहीं करता है:

image.jpg?foo=bar

यह थोड़ा overkill हो सकता है, लेकिन मैं इस तरह के रूप में एक यूआरएल पार्सर का उपयोग कर सुझाव है कि यह एक अप्रत्याशित फ़ाइल नामों की वजह से बचने के विफलता के लिए।

उस विशेष फ़ंक्शन का उपयोग करके, आप फ़ाइल का नाम इस तरह प्राप्त कर सकते हैं:

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

यह url var के बिना "image.jpg" आउटपुट करेगा। फिर आप फ़ाइल एक्सटेंशन को हथियाने के लिए स्वतंत्र हैं।

— जस्टिन बुल
स्रोत

3

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

— जिम ब्लैकलर
स्रोत

3

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

फ़ाइल (कोई एक्सटेंशन नहीं)

फ़ाइल। (Noextension)

— जिम ब्लैकलर
स्रोत

3

यदि आप एक विशिष्ट विस्तार की तलाश कर रहे हैं और इसकी लंबाई जानते हैं, तो आप रूट का उपयोग कर सकते हैं :

var file1 = "50.xsl";

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

जावास्क्रिप्ट संदर्भ: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr

— जेनी ओ'रेली
स्रोत

1

सुंदरता सरलता के साथ आती है। यह सभी का सबसे स्मार्ट, अधिक सुरुचिपूर्ण और अधिक कुशल उत्तर है। मैंने हमेशा Windows आधारित सिस्टम पर एक्सटेंशन हड़पने के लिए String.substr (-3) या String.substr (-4) का उपयोग किया। कोई क्यों उसके लिए नियमित अभिव्यक्ति और पागल छोरों का उपयोग करना चाहता है।

— asiby

13

@asiby इस तरह के समाधान लॉन्च के बाद अंतरिक्ष रॉकेट के दुर्घटनाग्रस्त होने का मुख्य कारण है।

— VisioN

3

मैं पार्टी में बहुत देर से आता हूं लेकिन सादगी के लिए मैं कुछ इस तरह का उपयोग करता हूं

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>

स्निपेट का विस्तार करें

— DzSoundNirvana
स्रोत

3

pathमॉड्यूल में इसके लिए एक मानक पुस्तकालय कार्य है :

import path from 'path';

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

आउटपुट:

।टेक्स्ट

इसलिए, यदि आप केवल प्रारूप चाहते हैं:

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

यदि कोई एक्सटेंशन नहीं है, तो फ़ंक्शन एक रिक्त स्ट्रिंग लौटाएगा:

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

यदि आप नोड का उपयोग कर रहे हैं, तो pathअंतर्निहित है। यदि आप ब्राउज़र को लक्षित कर रहे हैं, तो वेबपैक pathआपके लिए एक कार्यान्वयन बंडल करेगा । यदि आप वेबपैक के बिना ब्राउज़र को लक्षित कर रहे हैं, तो आप शामिल कर सकते हैं पथ- मैन्युअल रूप से ।

स्ट्रिंग विभाजन या रेगेक्स करने का कोई कारण नहीं है।

— sdgfsdh
स्रोत

नोड के बारे में कुछ भी किसने कहा?

— शैनन होकिन्स

बंटवारे या नियमित अभिव्यक्ति का उपयोग नहीं करने के लिए आपका तर्क प्लगइन को शामिल करना या नोड के साथ एप्लिकेशन को बंडल करना है, यह एक

— मासिक

— @ शॉनहॉन्किन्स

@AndreiDraganescu मैंने इसे कृपालु बनाने का इरादा नहीं किया, इसलिए इसे नीचे रख दिया है।

— sdgfsdh

3

"वन-लाइनर" का उपयोग करके फ़ाइल नाम और एक्सटेंशन प्राप्त करना 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"
// }

— boehm_s
स्रोत

यह IE 11 में काम नहीं कर रहा है

— गोकुल महापर

आप IE 11 के लापता ES7 + फीचर्स के लिए

— बैबल

2

एक पंक्ति समाधान जो क्वेरी params और url में किसी भी वर्ण के लिए भी खाता है।

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

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

— Labithiotis
स्रोत

(1) यदि किसी फ़ाइल का कोई एक्सटेंशन नहीं है, तो यह अभी भी फ़ाइल नाम वापस कर देगा। (2) यदि URL में एक टुकड़ा है, लेकिन कोई क्वेरी (जैसे page.html#fragment) नहीं है, तो यह फ़ाइल एक्सटेंशन और टुकड़ा वापस कर देगा।

— जैक

2

यह सरल उपाय है

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

स्निपेट का विस्तार करें

— Vitim.us
स्रोत

1

वालर का जवाब अच्छा है, लेकिन एक और जाँच की आवश्यकता है।

यदि फ़ाइल में कोई एक्सटेंशन नहीं है, तो यह फ़ाइल नाम को एक्सटेंशन के रूप में उपयोग करेगा जो अच्छा नहीं है।

इसको आजमाओ:

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

— केकड़ा
स्रोत

1

यह मत भूलो कि कुछ फाइलों का कोई विस्तार नहीं हो सकता है, इसलिए:

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

— तमसे पाप
स्रोत

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

— एनएसडी
स्रोत

1

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

— गौरांग उमर
स्रोत

2

हालांकि यह कोड स्निपेट प्रश्न को हल कर सकता है, जिसमें स्पष्टीकरण सहित वास्तव में आपकी पोस्ट की गुणवत्ता में सुधार करने में मदद करता है। याद रखें कि आप भविष्य में पाठकों के लिए प्रश्न का उत्तर दे रहे हैं, और उन लोगों को आपके कोड सुझाव के कारणों का पता नहीं चल सकता है।

— ब्रेट डेवुडी

मैं जावास्क्रिप्ट के साथ फ़ाइल एक्सटेंशन कैसे प्राप्त कर सकता हूं?

यह सरल उपाय है

टेस्ट