JavaScript arayan işlevi satır numarası nasıl alınır? JavaScript arayan kaynak URL'si nasıl alınır?

JavaScript arayan işlev adını almak için aşağıdakileri kullanıyorum:

var callerFunc = arguments.callee.caller.toString();
callerFuncName = (callerFunc.substring(callerFunc.indexOf("function") + 8, callerFunc.indexOf("(")) || "anoynmous")

Yöntemin çağrıldığı satır numarasını keşfetmenin bir yolu var mı?

Ayrıca, yöntemin çağrıldığı JavaScript dosyasının adını almanın bir yolu var mı? Veya kaynak URL?

Bu benim için chrome / QtWebView'da çalışıyor

function getErrorObject(){
    try { throw Error('') } catch(err) { return err; }
}

var err = getErrorObject();
var caller_line = err.stack.split("\n")[4];
var index = caller_line.indexOf("at ");
var clean = caller_line.slice(index+2, caller_line.length);

kangax'ın çözümü gereksiz try..catch kapsamı getiriyor. JavaScript'teki bir şeyin satır numarasına erişmeniz gerekiyorsa (Firefox veya Opera kullandığınız sürece), sadece erişin (new Error).lineNumber.

Bu yanıtların çoğunun, yalnızca normal durumlar için yararlı hata ayıklama izleri çıkarmak yerine bir hatayı ele almak istediğinizi varsaymasına şaşırdım.

Örneğin, bunun gibi bir console.logsarmalayıcı kullanmayı seviyorum:

consoleLog = function(msg) {//See https://stackoverflow.com/a/27074218/470749
    var e = new Error();
    if (!e.stack)
        try {
            // IE requires the Error to actually be thrown or else the 
            // Error's 'stack' property is undefined.
            throw e;
        } catch (e) {
            if (!e.stack) {
                //return 0; // IE < 10, likely
            }
        }
    var stack = e.stack.toString().split(/\r\n|\n/);
    if (msg === '') {
        msg = '""';
    }
    console.log(msg, '          [' + stack[1] + ']');        
}

Bu, konsoluma aşağıdaki gibi bir çıktı yazdırmakla sonuçlanır:

1462567104174 [getAllPosts@http://me.com/helper.js:362:9]

Bkz https://stackoverflow.com/a/27074218/ ve doğru hat numarası ile console.log için düzgün bir sargı?

Bu genellikle mevcut bağlamdan bir hata atılarak elde edilir; sonra lineNumberve gibi özellikler için hata nesnesini analiz etmek fileName(bazı tarayıcılarda var)

function getErrorObject(){
  try { throw Error('') } catch(err) { return err; }
}

var err = getErrorObject();

err.fileName;
err.lineNumber; // or `err.line` in WebKit

callee.callerMülkün kullanımdan kaldırıldığını (ve ilk etapta ECMA 3. baskıda hiçbir zaman gerçekten bulunmadığını) unutmayın .

Ayrıca derleme işlevinin uygulamaya bağlı olarak belirtildiğini ve bu nedenle oldukça beklenmedik sonuçlar verebileceğini unutmayın. Bunun hakkında burada ve burada yazdım .

Görünüşe göre biraz geç kaldım :), ama tartışma oldukça ilginç, bu yüzden .. işte başlıyor ... Bir hata işleyici oluşturmak istediğinizi ve kendi istisna giderici sınıfınızı aşağıdaki gibi kullandığınızı varsayarsak:

function  errorHandler(error){
    this.errorMessage = error;
}
errorHandler.prototype. displayErrors = function(){
    throw new Error(this.errorMessage);
}

Ve kodunuzu şu şekilde sarmalıyorsunuz:

try{
if(condition){
    //whatever...
}else{
    throw new errorHandler('Some Error Message');
}
}catch(e){
    e.displayErrors();
}

Hata işleyiciyi büyük olasılıkla ayrı bir .js dosyasında bulacaksınız.

Firefox veya chrome'un hata konsolunda gösterilen kod satırı numarasının (ve dosya adının), hata ayıklama yapmak için gerçekten istediğiniz 'errorHandler' istisnasını değil, 'Error' istisnasını atan satır (dosya) olduğunu fark edeceksiniz. kolay. Kendi istisnalarınızı atmak harikadır, ancak büyük projelerde bunları bulmak, özellikle de benzer mesajlar varsa, oldukça sorun olabilir. Yani, yapabileceğiniz şey, hata işleyicinize gerçek bir boş Error nesnesine bir referans iletmektir ve bu referans istediğiniz tüm bilgileri tutacaktır (örneğin firefox'ta dosya adını ve satır numarasını vb. Alabilirsiniz. ; chrome'da, Error örneğinin 'stack' özelliğini okursanız benzer bir şey elde edersiniz). Uzun lafın kısası, şöyle bir şey yapabilirsiniz:

function  errorHandler(error, errorInstance){
    this.errorMessage = error;
    this. errorInstance = errorInstance;
}
errorHandler.prototype. displayErrors = function(){
    //add the empty error trace to your message
    this.errorMessage += '  stack trace: '+ this. errorInstance.stack;
    throw new Error(this.errorMessage);
}

try{
if(condition){
    //whatever...
}else{
    throw new errorHandler('Some Error Message', new Error());
}
}catch(e){
    e.displayErrors();
}

Artık size özel istisna atan gerçek dosya ve satır numarasını alabilirsiniz.

Satır numarası aslında statik bir şeydir, bu yüzden sadece günlük kaydı için istiyorsanız, o zaman yudum gibi bir şeyle önceden işlenebilir. Tam olarak bunu yapan küçük bir yudum eklentisi yazdım :

var gulp = require('gulp');
var logLine = require('gulp-log-line');
gulp.task('log-line', function() {
    return gulp.src("file.js", {buffer : true})
    //Write here the loggers you use.
        .pipe(logLine(['console.log']))
        .pipe(gulp.dest('./build'))

})

gulp.task('default', ['log-line'])

Bu console.log tüm günlükleri dosya adını ve satır ekler, böylece console.log(something)hale gelecektir console.log('filePath:fileNumber', something). Avantajı artık dosyalarınızı birleştirebilir, aktarabilirsiniz ... ve yine de satırı alacaksınız

Bunun eski bir soru olduğunu anlıyorum, ancak şimdi console.trace("Message")size ilettiğiniz mesajla birlikte günlüğe götüren satır numarasını ve yöntem çağrıları zincirini gösterecek bir yöntem var. Javascript günlüğe kaydetme püf noktaları hakkında daha fazla bilgi burada freecodecamp'ta ve bu ortam blog yazısında bulunabilir.

Satır numarasını hata ayıklama amacıyla veya yalnızca geliştirme sırasında (bir nedenle veya başka bir nedenle) bilmek istiyorsanız, Firebug'ı (bir Firefox uzantısı) kullanabilir ve bir istisna atabilirsiniz .

Düzenle :

Bunu herhangi bir nedenle üretimde gerçekten yapmanız gerekiyorsa, her işlevin üzerinde bulunduğu satırı takip etmesi için javascript dosyalarınızı önceden işleyebilirsiniz. Kod kapsamını bulan bazı çerçevelerin bunu kullandığını biliyorum ( JSCoverage gibi ).

Örneğin, orijinal aramanızın şöyle olduğunu varsayalım:

function x() {
  1 + 1;
  2 + 2;
  y();
}

Bunu yapmak için bir önişlemci yazabilirsiniz:

function x() {
  var me = arguments.callee;
  me.line = 1;
  1 + 1;
  me.line = 2;
  2 + 2;
  me.line = 3;
  y();
}

Ardından içinde y(), arguments.callee.caller.lineçağrıldığı satırı bilmek için kullanabilirsiniz , örneğin:

function y() {
  alert(arguments.callee.caller.line);
}

Ben de böyle yaptım, hem Firefox hem de Chrome'da test ettim. Bu, işlevin çağrıldığı yerin dosya adını ve satır numarasını kontrol etmeyi mümkün kılar.

logFileAndLineNumber(new Error());

function logFileAndLineNumber(newErr)
{
   if(navigator.userAgent.indexOf("Firefox") != -1)
   {
      var originPath = newErr.stack.split('\n')[0].split("/");
      var fileNameAndLineNumber = originPath[originPath.length - 1].split(">")[0];
      console.log(fileNameAndLineNumber);
   }else if(navigator.userAgent.indexOf("Chrome") != -1)
   {
      var originFile = newErr.stack.split('\n')[1].split('/');
      var fileName = originFile[originFile.length - 1].split(':')[0];
      var lineNumber = originFile[originFile.length - 1].split(':')[1];
      console.log(fileName+" line "+lineNumber);
    }
}

İşte bu forumda bulunan bilgilere dayanarak yazdıklarım:

Bu, MyDebugNamespace'in bir parçasıdır, Debug görünüşe göre ayrılmış ve ad alanı adı olarak kullanılmayacak.

    var DEBUG = true;

...

    if (true == DEBUG && !test)
    {
        var sAlert = "Assertion failed! ";
        if (null != message)
            sAlert += "\n" + message;
        if (null != err)
            sAlert += "\n" + "File: " + err.fileName + "\n" + "Line: " + err.lineNumber;
        alert(sAlert);
    }

...

Nasıl aranır:

    MyDebugNamespace.Assert(new Error(""), (null != someVar), "Something is wrong!")

Çağrılarda isteğe bağlı olarak mesaj veya hatayı atlamak için bu temel kodu çağıran değişken sayıda argümana sahip iki işlev ekledim.

Bu, Firefox, IE6 ve Chrome ile iyi çalışır, fileName ve lineNumber öğelerini tanımsız olarak bildirir.

Aşağıdaki kod Mozilla ve Chrome'da benim için çalışıyor.

Dosyanın adını ve arayanın satırını gösteren günlük işlevi.

log: function (arg) {
    var toPrint = [];
    for (var i = 0; i < arguments.length; ++i) {
        toPrint.push(arguments[i]);
    }

    function getErrorObject(){
        try { throw Error('') } catch(err) { return err; }
    }

    var err = getErrorObject(),
        caller;

    if ($.browser.mozilla) {
        caller = err.stack.split("\n")[2];
    } else {
        caller = err.stack.split("\n")[4];
    }

    var index = caller.indexOf('.js');

    var str = caller.substr(0, index + 3);
    index = str.lastIndexOf('/');
    str = str.substr(index + 1, str.length);

    var info = "\t\tFile: " + str;

    if ($.browser.mozilla) {
        str = caller;
    } else {
        index = caller.lastIndexOf(':');
        str = caller.substr(0, index);
    }
    index = str.lastIndexOf(':');
    str = str.substr(index + 1, str.length);
    info += " Line: " + str;
    toPrint.push(info);

    console.log.apply(console, toPrint);
}

JavaScript'teki özel hatalara katkım:

1. İlk olarak, Hata nesnesinden Devralma konusunda bu @BT adamına katılıyorum - mesaj özelliği nerede? , onu doğru bir şekilde oluşturmalıyız (aslında bir js nesne kitaplığı kullanmanız gerekiyor, benim favorim: https://github.com/jiem/my-class ):

   window.g3 = window.g3 || {};
   g3.Error = function (message, name, original) {
        this.original = original;
        this.name = name || 'Error.g3';
        this.message = message || 'A g3.Error was thrown!';
        (original)? this.stack = this.original.stack: this.stack = null;
        this.message += '<br>---STACK---<br>' + this.stack;
    };
   
    var ClassEmpty = function() {};
    ClassEmpty.prototype = Error.prototype;
    g3.Error.prototype = new ClassEmpty();
    g3.Error.prototype.constructor = g3.Error;

2. daha sonra, genel bir hata işleme işlevi (isteğe bağlı) tanımlamalıyız, aksi takdirde bunlar motora ulaşır:

   window.onerror = printError; 
   function printError(msg, url, line){
       document.getElementById('test').innerHTML = msg+'<br>at: '+url+'<br>line: '+line;
       return true;
   }

3. son olarak, özel hatalarımızı dikkatlice atmalıyız:

   //hit it!
   //throw new g3.Error('Hey, this is an error message!', 'Error.Factory.g3');
   throw new g3.Error('Hey, this is an error message!', 'Error.Factory.g3', new Error());

Yalnızca, üçüncü parametreyi geçerken, new Error()işlevi ve satır numaralarını içeren yığını görebiliriz!

2'de, işlev aynı zamanda motor tarafından atılan hatayı da ele alabilir.

Tabii ki asıl soru, buna gerçekten ihtiyacımız olup olmadığı ve ne zaman olacağıdır; Zarif bir dönüşün falseyeterli olduğu ve sadece bir hata atılarak gösterilecek bazı kritik noktaları bıraktığı durumlar (bence% 99) var .

Örnek: http://jsfiddle.net/centurianii/m2sQ3/1/

console.log(new Error);

Size tüm parçayı gösterecek.

Bir şeyin hangi satırda olduğunu belirlemek için, belirli ilgilenilen satırı işgal eden kod için tüm kodu aramanız ve ilgilendiğiniz yere kadar "\ n" karakterlerini saymanız ve 1 eklemeniz gerekir.

Aslında bunu yazdığım bir uygulamada yapıyorum. HTML için bir en iyi uygulama doğrulayıcıdır ve hala büyük ölçüde geliştirilme aşamasındadır, ancak ilgilenebileceğiniz hata çıktı süreci tamamlanmıştır.

http://mailmarkup.org/htmlint/htmlint.html

Cevaplar basit. Hayır ve Hayır (Hayır).

Javascript, gelenin gittiği kaynak dosyalar / url'ler kavramını çalıştırdığı zaman.

Bir satır numarasını belirlemenin de bir yolu yoktur, çünkü yürütme sırasında kod "satırlar" kavramı artık Javascript'te anlamlı değildir.

Belirli uygulamalar, hata ayıklama amacıyla bu tür ayrıntılara ayrıcalıklı kod erişimine izin vermek için API kancaları sağlayabilir, ancak bu API'ler sıradan standart Javascript koduna maruz kalmaz.