How might I get the script filename from within that script?

I'm aware this is old but I have developed a better solution because all of the above didn't work for Async scripts. With some tweaking the following script can cover almost all use cases. Heres what worked for me:

function getScriptName() {
    var error = new Error()
      , source
      , lastStackFrameRegex = new RegExp(/.+\/(.*?):\d+(:\d+)*$/)
      , currentStackFrameRegex = new RegExp(/getScriptName \(.+\/(.*):\d+:\d+\)/);

    if((source = lastStackFrameRegex.exec(error.stack.trim())) && source[1] != "")
        return source[1];
    else if((source = currentStackFrameRegex.exec(error.stack.trim())))
        return source[1];
    else if(error.fileName != undefined)
        return error.fileName;
}

Not sure about support on Internet Explorer, but works fine in every other browser I tested on.

You can use...

var scripts = document.getElementsByTagName("script"),
  currentScriptUrl = (document.currentScript || scripts[scripts.length - 1]).src;

currentScript() is supported by all browsers except IE.

Make sure it's ran as the file is parsed and executed, not on DOM ready or window load.

If it's an empty string, your script block has no or an empty src attribute.

In Node.js:

var abc = __filename.split(__dirname+"/").pop();

Shog9's suggestion more shorter:

alert("loading: " + document.scripts[document.scripts.length-1].src);

You can return a list of script elements in the page:

var scripts = document.getElementsByTagName("script");

And then evaluate each one and retrieve its location:

var location;

for(var i=0; i<scripts.length;++i) {
   location = scripts[i].src;

   //Do stuff with the script location here
}

As the "src" attribute holds the full path to the script file you can add a substring call to get the file name only.

var path = document.scripts[document.scripts.length-1].src;

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

I had issues with the above code while extracting the script name when the calling code is included inside a .html file. Hence I developed this solution:

var scripts = document.getElementsByTagName( "script" ) ;
var currentScriptUrl = ( document.currentScript || scripts[scripts.length - 1] ).src ;
var scriptName = currentScriptUrl.length > 0 ? currentScriptUrl : scripts[scripts.length-1].baseURI.split( "/" ).pop() ; 

You can try putting this at the top of your JavaScript file:

window.myJSFilename = "";
window.onerror = function(message, url, line) {
    if (window.myJSFilename != "") return;
    window.myJSFilename =  url;
}
throw 1;

Make sure you have only functions below this. The myJSFilename variable will contain the full path of the JavaScript file, the filename can be parsed from that. Tested in IE11, but it should work elsewhere.

If you did't want use jQuery:

function getCurrentFile() {
    var filename = document.location.href;
    var tail = (filename.indexOf(".", (filename.indexOf(".org") + 1)) == -1) ? filename.length : filename.lastIndexOf(".");
    return (filename.lastIndexOf("/") >= (filename.length - 1)) ? (filename.substring(filename.substring(0, filename.length - 2).lastIndexOf("/") + 1, filename.lastIndexOf("/"))).toLowerCase() : (filename.substring(filename.lastIndexOf("/") + 1, tail)).toLowerCase();
}

What will happen if the jQuery script isn't there? Are you just going to output a message? I guess it is slightly better for debugging if something goes wrong, but it's not very helpful for users.

I'd say just design your pages such that this occurrence will not happen, and in the rare event it does, just let the script fail.

The only way that is waterproof:

var code = this.__proto__.constructor.toString();
$("script").each(function (index, element) {
    var src = $(element).attr("src");
    if (src !== undefined) {
        $.get(src, function (data) {
            if (data.trim() === code) {
                scriptdir = src.substring(0, src.lastIndexOf("/"));
            }
        });
    }
});

"var code" can also be the function name, but with the prototype constructor you don't have to modify anything. This code compares its own content against all present scripts. No hard coded filenames needed anymore. Korporal Nobbs was in the right direction, but not complete with the comparison.

Using the javascript stack trace from Error object, you can extract the line 2 and do some substring and splits like below. The output will be the filename where the code is executed. This sample code assumes that you are executing on the same javascript. To determine the script that calls your script, you can try change the level to 2 like so. split('\n')[2]

let stack1 = new Error().stack.trim().split('\n')[1].trim()
console.log(stack1.substring(stack1.lastIndexOf('/')+1).split('?')[0])

I have found this method, which works pretty well. Let's say your js script filename is myScript.js. You can call this script from anywhere in your JS script, within or out of a function, e.g.

function anyfunction()
{
    const jsFilename = getCurrentScriptFileName();
    console.log("This JS filename is " + jsFilename);
}

function getCurrentScriptFileName()
{
    try{
        throw new Error();
    }
    catch(e){
        var stack = e.stack || e.stacktrace;
        var stackLines = stack.split("\n");
        var currentFile = stackLines[1].match(/(http[s]?:\/\/[^\s]+)/);
        
        if(currentFile){
            var currScript = currentFile[0];
        
            // currScript is now e.g.
            // "https://example.com/folder/myScript.js:82:35"
    
            const startIndex = currScript.lastIndexOf('/');
            const endIndex = currScript.indexOf(':', startIndex);
            const filename = currScript.slice(startIndex + 1, endIndex);
    
            // filename is now "myScript.js"
    
            return filename;
        }
        else return null;
    }
}

Then you'll get "myScript.js"