Google ChromeãNode.jsã§å©çšå¯èœãªAPIã§ããFirefoxçã«ã¯æèŒãããŠããŸãããïŒãŸãŒãããŸã䜿ãå Žé¢ãªãããã§ããã©ãïŒ
以äžã翻蚳ã§ãã
All internal errors thrown in V8 capture a stack trace when they are created that can be accessed from JavaScript through the error.stack property. V8 also has various hooks for controlling how stack traces are collected and formatted, and for allowing custom errors to also collect stack traces. This document outlines V8’s JavaScript stack trace API.
V8ã§æããããããããå
éšãšã©ãŒã¯ãçææã®ã¹ã¿ãã¯ããŒã¬ã¹ãç²åŸããŸããããã¯JavaScriptã®error.stack
ããããã£ãéããŠã¢ã¯ã»ã¹å¯èœã§ããV8ã«ã¯ä»ã«ããã¹ã¿ãã¯ãã¬ãŒã¹ã®åéãæžåŒåãå¶åŸ¡ããè€æ°ã®ããã¯ããã«ã¹ã¿ã ãšã©ãŒã§ã¹ã¿ãã¯ãã¬ãŒã¹ãåŸãããã¯ããããŸããæ¬ææžã¯V8ã®JavaScriptã¹ã¿ãã¯ãã¬ãŒã¹APIã®æŠèŠã§ãã
Basic stack traces – åºæ¬çãªã¹ã¿ãã¯ãã¬ãŒã¹
By default, almost all errors thrown by V8 have a stack property that holds the topmost 10 stack frames, formatted as a string. Here’s an example of a fully formatted stack trace:
ReferenceError: FAIL is not defined at Constraint.execute (deltablue.js:525:2) at Constraint.recalculate (deltablue.js:424:21) at Planner.addPropagate (deltablue.js:701:6) at Constraint.satisfy (deltablue.js:184:15) at Planner.incrementalAdd (deltablue.js:591:21) at Constraint.addConstraint (deltablue.js:162:10) at Constraint.BinaryConstraint (deltablue.js:346:7) at Constraint.EqualityConstraint (deltablue.js:515:38) at chainTest (deltablue.js:807:6) at deltaBlue (deltablue.js:879:2)
ããã©ã«ãã§ã¯ãV8ããæããããã»ãŒå
šãŠã®ãšã©ãŒã¯stack
ããããã£ãæã¡ãäžäœ10ã®ã¹ã¿ãã¯ãã¬ãŒã ãæžåŒä»ãæååã®ç¶æ
ã§æ ŒçŽããŠããŸãããã¡ããæžåŒä»ãã®ã¹ã¿ãã¯ãã¬ãŒã¹ã®äŸã§ã:
ReferenceError: FAIL is not defined at Constraint.execute (deltablue.js:525:2) at Constraint.recalculate (deltablue.js:424:21) at Planner.addPropagate (deltablue.js:701:6) at Constraint.satisfy (deltablue.js:184:15) at Planner.incrementalAdd (deltablue.js:591:21) at Constraint.addConstraint (deltablue.js:162:10) at Constraint.BinaryConstraint (deltablue.js:346:7) at Constraint.EqualityConstraint (deltablue.js:515:38) at chainTest (deltablue.js:807:6) at deltaBlue (deltablue.js:879:2)
The stack trace is collected when the error is created and is the same regardless of where or how many times the error is thrown. We collect 10 frames because it is usually enough to be useful but not so many that it has a noticeable performance impact. You can control how many stack frames are collected by setting the variable
Error.stackTraceLimit
ãã®ã¹ã¿ãã¯ãã¬ãŒã¹ã¯ããšã©ãŒãã©ãã§äœåºŠæãããããšããŠãããã®ãšã©ãŒçææã«åéãããŸããåéã10ãã¬ãŒã ã«å¶éãããŠããã®ã¯ãäžè¬ã«ããã§ååã§ããããã€ç¥èŠã§ããã»ã©ããã©ãŒãã³ã¹ã«åœ±é¿ãäžããªãããã§ããããã¹ã¿ãã¯ãã¬ãŒã ã®åéæ°ãå¶åŸ¡ããå¿ èŠãããã°ããã®å€ãèšå®ããŠãã ãã:
Error.stackTraceLimit
Setting it to 0 will disable stack trace collection. Any finite integer value will be used as the maximum number of frames to collect. Setting it to Infinity means that all frames will be collected. This variable only affects the current context, it has to be set explicitly for each context that needs a different value. (Note that what is known as a “context” in V8 terminology corresponds to a page or iframe in Google Chrome). To set a different default value that affects all contexts use the
--stack-trace-limit <value>command-line flag to V8. To pass this flag to V8 when running Google Chrome use
--js-flags="--stack-trace-limit <value>"
ãã®å€ã0ã«ãããšãã¹ã¿ãã¯ãã¬ãŒã¹ã®åéãç¡å¹åããäºãã§ããŸããæéæŽæ°ã§ããã°äœã§ããã¬ãŒã åéæ°ã®äžéå€ãšããŠèšå®å¯èœã§ããInfinity
ãèšå®ãããšå
šãŠã®ãã¬ãŒã ãåéããããã«ãªããŸãããã®èšå®ã¯ãèšå®æã®ã³ã³ããã¹ãã§ã®ã¿æå¹ã§ããå¿
èŠã«å¿ããŠåã³ã³ããã¹ãããšã«ç°ãªãå€ãèšå®ããŠãã ãããïŒãªãV8ã«ããããã³ã³ããã¹ãããšããçšèªã¯ãGoogle Chromeã®ããŒãžãiframeãšåèŽããŸããïŒãå
šãŠã®ã³ã³ããã¹ãã§åæå€ãšç°ãªãå€ãçšããå Žåã¯ããã¡ãã®V8ã³ãã³ãã©ã€ã³ãã©ã°ãå©çšããŠãã ãã:
--stack-trace-limit <value>
Google Chromeäžã®V8ãžèšå®ããå Žåã¯ãã¡ãã®ãã©ã°ã§ã:
--js-flags="--stack-trace-limit <value>"
Stack trace collection for custom exceptions – ã«ã¹ã¿ã ãšã©ãŒçšã«ã¹ã¿ãã¯ãã¬ãŒã¹ãåéãã
The stack trace mechanism used for built-in errors is implemented using a general stack trace collection API that is also available to user scripts. The function
Error.captureStackTrace(error, constructorOpt)adds a stack property to the given error object that will yield the stack trace at the time captureStackTrace was called. The reason for not just returning the formatted stack trace directly is that this way we can postpone the formatting of the stack trace until the stack property is accessed and avoid formatting completely if it never is.
çµã¿èŸŒã¿ãšã©ãŒåãã®ã¹ã¿ãã¯ãã¬ãŒã¹ã®ä»çµã¿ã¯ããŠãŒã¶ãŒã¹ã¯ãªããã§ãæå¹ãªæ±çšã¹ã¿ãã¯ãã¬ãŒã¹åéAPIãçšããŠå®è£
ãããŠããŸãã以äžã®é¢æ°ã¯ãerror
ãªããžã§ã¯ããžstack
ããããã£ã远å ããŸã:
Error.captureStackTrace(error, constructorOpt)
ãªããã¹ã¿ãã¯ãã¬ãŒã¹ã¯captureStackTrace
ãåŒã°ããæç¹ã®ãã®ã«ãªããŸããæžåŒåæžã¿ã®ã¹ã¿ãã¯ãã¬ãŒã¹ãçŽæ¥è¿ããªãçç±ã¯ãã¹ã¿ãã¯ãã¬ãŒã¹ã®æžåŒåãstack
ããããã£ãžã®ã¢ã¯ã»ã¹ãŸã§åŸ
ã¡ãäžå¿
èŠãªãæžåŒåã®åŠçãçãããã§ããïŒèš³è
èš»:ã€ãŸãcaptureStackTrace
ããç¬éã«ã¹ã¿ãã¯ãã¬ãŒã¹ã¯èšé²ããããã®ã®ãããã人ãèªããç¶æ
ã«å€æããåŠçã³ã¹ããçããããæžåŒåãgetterã§é
å»¶å®è¡ããŠãã¿ããã§ããïŒ
The optional constructorOpt parameter allows you to pass in a function value. When collecting the stack trace all frames above the topmost call to this function, including that call, will be left out of the stack trace. This can be useful to hide implementation details that won’t be useful to the user. The usual way of defining a custom error that captures a stack trace would be:
function MyError() { Error.captureStackTrace(this, MyError); // any other initialization }
çç¥å¯èœãªconstructorOpt
åŒæ°ã«ã¯é¢æ°ãäžããäºãã§ããŸããã¹ã¿ãã¯ãã¬ãŒã¹åéã®éãããã§æå®ãã颿°ãšãããäžäœã«ããå
šãŠã®ãã¬ãŒã ã¯ã¹ã¿ãã¯ãã¬ãŒã¹ããé€å€ãããŸããããã¯å©çšè
ã«ãšã£ãŠã¯ããŸãæå³ã®ãªãå®è£
ã®çްããéšåãé èœããã®ã«åœ¹ç«ã¡ãŸããã¹ã¿ãã¯ãã¬ãŒã¹ãååŸãããããªã«ã¹ã¿ã ãšã©ãŒã®äžè¬çãªå®çŸ©ã¯ããã®ããã«ãªãã§ããã:
function MyError() { Error.captureStackTrace(this, MyError); // ä»ã®åæååŠç }
Passing in MyError as a second argument means that the constructor call to MyError won’t show up in the stack trace.
MyError
ã第2åŒæ°ã«æå®ããäºã§ãã¹ã¿ãã¯ãã¬ãŒã¹ã«MyErrorã®åŒã³åºããèŠããªãããã«ããäºãã§ããŸãã
Customizing stack traces – ã¹ã¿ãã¯ãã¬ãŒã¹ã®ã«ã¹ã¿ãã€ãº
Unlike Java where the stack trace of an exception is a structured value that allows inspection of the stack state, the stack property in V8 just holds a flat string containing the formatted stack trace. This is for no other reason than compatibility with other browsers. However, this is not hardcoded but only the default behavior and can be overridden by user scripts.
äŸå€ã®ã¹ã¿ãã¯ãã¬ãŒã¹ãstask stateãinspectionã§ããstructured valueïŒèš³èš»:ããã蟺ïŸïŸïŒã§ããJavaãšã¯ç°ãªããV8ã«ãããstack
ããããã£ã¯æžåŒåæžã¿ã¹ã¿ãã¯ãã¬ãŒã¹ã®åçŽãªæååãä¿æããŠããã ãã§ããããã¯ä»ã®ãã©ãŠã¶ãŒãšã®äºææ§ã®ããã§ããããŸããããããããã¯ããŒãã³ãŒãã£ã³ã°ãããŠããªãåæåäœã§ããããŠãŒã¶ãŒã¹ã¯ãªããã§äžæžãããäºãã§ããŸãã
For efficiency stack traces are not formatted when they are captured but on demand, the first time the stack property is accessed. A stack trace is formatted by calling
Error.prepareStackTrace(error, structuredStackTrace)and using whatever this call returns as the value of the stack property. If you assign a different function value to Error.prepareStackTrace that function will be used to format stack traces. It will be passed the error object that it is preparing a stack trace for and a structured representation of the stack. User stack trace formatters are free to format the stack trace however they want and even return non-string values. It is safe to retain references to the structured stack trace object after a call to prepareStackTrace completes so that it is also a valid return value. Note that the custom prepareStackTrace function is immediately called at the point when the error object is created (e.g. with new Error()).
å¹çåã®ããã¹ã¿ãã¯ãã¬ãŒã¹ã¯ååŸãããéã¯æžåŒåãããŠããããå¿
èŠã«å¿ããŠãã€ãŸãstack
ããããã£ãžã®ååã¢ã¯ã»ã¹æã«æžåŒåãããŸããã¹ã¿ãã¯ãã¬ãŒã¹ã¯æ¬¡ã®ã³ãŒããè¿ããstack
ããããã£ã®å€ã䜿çšããããšãæžåŒåãããŸã:
Error.prepareStackTrace(error, structuredStackTrace)
Error.prepareStackTrace
ãžç°ãªã颿°å€ãäžããå Žåããã®é¢æ°ãã¹ã¿ãã¯ãã¬ãŒã¹ãæžåŒåããã®ã«çšããããŸãã It will be passed the error object that it is preparing a stack trace for and a structured representation of the stack. ïŒèš³èš»:ãã®äžæããããããã”and”ãã©ãã«ããã£ãŠããã®ãããïŒããŠãŒã¶ãŒç¬èªã®ã¹ã¿ãã¯ãã¬ãŒã¹æžåŒååŠçã¯èªç±ã«æžåŒãèšå®ããäºãã§ããæåå以å€ã®å€ãè¿ãäºãå¯èœã§ããæå¹ãªå€ãè¿ãprepareStackTrace
ã®åŒã³åºãã®åŸã«æ§é åãããã¹ã¿ãã¯ãã¬ãŒã¹ãªããžã§ã¯ããžã®åç
§ãä¿æããŠãå®å
šã§ããç¬èªã®prepareStackTrace
颿°ã¯ãšã©ãŒãªããžã§ã¯ããçæãããéã峿åŒã³åºãããäºã«æ³šæããŠãã ãããïŒäŸ: new Error()
ïŒ
The structured stack trace is an Array of CallSite objects, each of which represents a stack frame. A CallSite object defines the following methods
- getThis: returns the value of this
- getTypeName: returns the type of this as a string. This is the name of the function stored in the constructor field of this, if available, otherwise the object’s [[Class]] internal property.
- getFunction: returns the current function
- getFunctionName: returns the name of the current function, typically its name property. If a name property is not available an attempt will be made to try to infer a name from the function’s context.
- getMethodName: returns the name of the property of this or one of its prototypes that holds the current function
- getFileName: if this function was defined in a script returns the name of the script
- getLineNumber: if this function was defined in a script returns the current line number
- getColumnNumber: if this function was defined in a script returns the current column number
- getEvalOrigin: if this function was created using a call to eval returns a CallSite object representing the location where eval was called
- isToplevel: is this a toplevel invocation, that is, is this the global object?
- isEval: does this call take place in code defined by a call to eval?
- isNative: is this call in native V8 code?
isConstructor
: is this a constructor call?
æ§ç¯æžã¿ã¹ã¿ãã¯ãã¬ãŒã¹ã¯CallSiteãªããžã§ã¯ãã®é åã§ããããããåã¹ã¿ãã¯ãã¬ãŒã ãæå³ããŸããCallSiteãªããžã§ã¯ãã¯ä»¥äžã®ã¡ãœãããå®çŸ©ãããŠããŸã:
getThis
:this
ã®å€ãè¿ããŸããïŒè𳿳š:å®è¡ã³ã³ããã¹ãã®this
ã®äºãïŒgetTypeName
:this
ã®åãæååã§è¿ããŸããããã¯this
ã®ã³ã³ã¹ãã©ã¯ã¿ãŒã®ç¯å²ã§èšå®ããã颿°ã®ååã§ãããªãå Žåã¯ãªããžã§ã¯ãã®å éšããããã£[[Class]]
ã«ãªããŸããgetFunction
: çŸåšã®é¢æ°ãè¿ããŸããgetFunctionName
: çŸåšã®é¢æ°ã®ååãè¿ããŸããäžè¬çã«ã¯name
ããããã£ã«ãªããŸããname
ããããã£ããªãå Žåã颿°ã®æèããæšè«ããŸãã ïŒèš³è èš»:äŸãã°ç¡å颿°ãfn
ãšãã倿°ãžä»£å ¥ããŠå©çšããŠããå Žåã颿°èªäœã®ååïŒname
ããããã£ïŒã¯ãããŸããããããã§ã¯"fn"
ãåŸãããŸãããªãã¡ãœããåã¯åŸè¿°ã®getMethodName
ã§ååŸããŸããïŒgetMethodName
: çŸåšã®é¢æ°ãä¿æããŠããthis
ãªããprototypeã®ããããã£åãè¿ããŸããgetFileName
: ã¹ã¯ãªãããã¡ã€ã«äžã«ãã®é¢æ°ãå®çŸ©ãããŠããå Žåãã¹ã¯ãªãããã¡ã€ã«ã®ååãè¿ããŸããgetLineNumber
: ã¹ã¯ãªãããã¡ã€ã«äžã«ãã®é¢æ°ãå®çŸ©ãããŠããå ŽåãçŸåšã®è¡çªå·ãè¿ããŸããgetColumnNumber
: ã¹ã¯ãªãããã¡ã€ã«äžã«ãã®é¢æ°ãå®çŸ©ãããŠããå ŽåãçŸåšã®åçªå·ãè¿ããŸããgetEvalOrigin
:eval
åŒã³åºãã«ãããã®é¢æ°ãçæãããå Žåãeval
ãåŒã°ããå ŽæãæãCallSiteãªããžã§ã¯ããè¿ããŸããisToplevel
: ãããã¬ãã«ã§å®è¡ãããthis
ãã°ããŒãã«ãªããžã§ã¯ããïŒisEval
: ãã®åŒã³åºãã¯eval
åŒã³åºãã«ããå®çŸ©ãããã³ãŒãã§å®è¡ããããïŒisNative
: ãã®åŒã³åºãã¯V8ã®ãã€ãã£ãã³ãŒããïŒisConstructor
: ããã¯ã³ã³ã¹ãã©ã¯ã¿ãŒåŒã³åºããïŒ
The default stack trace is created using the CallSite API so any information that is available there is also available through this API.
ããã©ã«ãã®ã¹ã¿ãã¯ãã¬ãŒã¹ã¯ãCallSite APIãçšããŠçæãããŸããããã§åŸãããå€ãã®æ å ±ã¯ãã®APIãçšããŠãååŸå¯èœã§ãã
To maintain restrictions imposed on strict mode functions, frames that have a strict mode function and all frames below (its caller etc.) are not allow to access their receiver and function objects. For those frames, getFunction() and getThis() will return undefined.
strictã¢ãŒãã®é¢æ°ã«èª²ããããå¶éïŒèš³è
èš»:颿°ããåŒã³åºãå
ãåç
§ã§ããªãããã«ãªã£ãŠããŸãïŒãéµå®ãããããstrictã¢ãŒãã®é¢æ°ãæã€ãã¬ãŒã ãšäžäœã®å
šãã¬ãŒã ïŒcallerçïŒã¯ããã®receiverïŒèš³è
èš»:å®è¡æã³ã³ããã¹ãã®äºïŒãšé¢æ°ãªããžã§ã¯ããžã®ã¢ã¯ã»ã¹ã¯çŠããããŠããŸãããããã®ãã¬ãŒã ã§ã¯ãgetFunction()
ãšgetThis()
ã¯undefined
ãè¿ããŸãã
Compatibility – äºææ§
The API described here is specific to V8 and is not supported by any other JavaScript implementations. Most implementations do provide an error.stack property but the format of the stack trace is likely to be different from the format described here. The recommended use of this API is
- Only rely on the layout of the formatted stack trace if you know your code is running in v8.
- It is safe to set Error.stackTraceLimit and Error.prepareStackTrace regardless of which implementation is running your code but be aware that it will only have an effect if your code is running in V8.
ããã§ç޹ä»ãããAPIã¯V8ã®ä»æ§ã§ãããä»ã®JavaScriptå®è£
ç³»ã§ã¯ãµããŒããããŠããŸãããå€ãã®å®è£
ç³»ã¯error.stack
ãæäŸããŠããŸãããã¹ã¿ãã¯ãã¬ãŒã¹ã®æžåŒã¯ããã§ç޹ä»ãããã®ãšã¯ç°ãªãå¯èœæ§ãé«ãã§ãããããã®APIã®æšå¥šãããäœ¿ãæ¹ã¯ã以äžã®éãã§ã:
- V8ã§ã®ã¿å®è¡ãããäºãåãã£ãŠããå ŽåãæžåŒåæžã¿ã¹ã¿ãã¯ãã¬ãŒã¹ã®ã¿ã«äŸåãã
- ã©ã®å®è£
ç³»ã§ã³ãŒããå®è¡ãããŠããããèæ
®ããã«
Error.stackTraceLimit
ãšError.prepareStackTrace
ãèšå®ããŠãå®å šã§ããV8ã§ã®ã¿å®è¡ãããŠããå Žåã«ã®ã¿ãæå³ãæã¡ãŸãã
Appendix: Stack trace format – ä»é²: ã¹ã¿ãã¯ãã¬ãŒã¹ã®æžåŒ
The default stack trace format used by V8 can for each stack frame give the following information:
- Whether the call is a construct call.
- The type of the this value (Type).
- The name of the function called (functionName).
- The name of the property of this or one of its prototypes that holds the function (methodName).
- The current location within the source (location)
V8ã§å©çšãããããã©ã«ãã®ã¹ã¿ãã¯ãã¬ãŒã¹ã®æžåŒã¯ãåã¹ã¿ãã¯ãã¬ãŒã ã«ä»¥äžã®æ å ±ãäžããŸã:
- ã³ã³ã¹ãã©ã¯ã¿ãŒåŒã³åºãã§ãããã
this
ã®åã(Type)- 颿°ã®ååã(functionName)
- 颿°ãä¿æããŠãã
this
ãªãã該åœãªããžã§ã¯ãã«ãããããããã£åã(methodName) - ãœãŒã¹ã³ãŒãäžã®æ£ç¢ºãªäœçœ®ã(location)
Any of these may be unavailable and different formats for stack frames are used depending on how much of this information is available. If all the above information is available a formatted stack frame will look like this:
at Type.functionName [as methodName] (location)
åžžã«å šãŠã®æ å ±ããããšã¯éããŸãããåã¹ã¿ãã¯ãã¬ãŒã ããšã«æžåŒãç°ãªãã®ã¯ã©ãã ãã®æ å ±ãæå¹ã§ãããã«ãããŸããåè¿°ã®æ å ±ãå šãŠæå¹ã§ããå Žåã¯ã以äžã®æžåŒã§ã¹ã¿ãã¯ãã¬ãŒã ãåºåãããŸã:
at Type.functionName [as methodName] (location)
or, in the case of a construct call
at new functionName (location)
ã³ã³ã¹ãã©ã¯ã¿ãŒåŒã³åºãã®å Žåã¯ä»¥äžã§ã:
at new functionName (location)
If only one of functionName and methodName is available, or if they are both available but the same, the format will be:
at Type.name (location)If neither is available
will be used as the name.
functionNameãšmethodNameã®ãããããããå Žåããããã¯äž¡æ¹ãããã®ã®åãã§ããå Žåã¯ã以äžã®ããã«æžåŒåãããŸã:
at Type.name (location)
ã©ã¡ãããªãå Žåã¯ååãšããŠ
The Type value is the name of the function stored in the constructor field of this. In v8 all constructor calls set this property to the constructor function so unless this field has been actively changed after the object was created it it will hold the name of the function it was created by. If it is unavailable the [[Class]] property of the object will be used.
Typeã¯this
ã®ã³ã³ã¹ãã©ã¯ã¿ãŒã®ç¯å²ã§ä¿æããã颿°ã®ååã§ããV8ã§ã¯ãããããã³ã³ã¹ãã©ã¯ã¿ãŒåŒã³åºãã¯ãã®ããããã£ïŒèš³èš»:name
ã®äºãïŒãã³ã³ã¹ãã©ã¯ã¿ãŒé¢æ°ãžèšå®ããŸãããªããžã§ã¯ãçæåŸã«åçã«å€æŽããããšããŠãã颿°åã¯çææã®ãã®ãä¿æãããŸãããã®å€ãç¡å¹ãªå Žåã¯å
éšããããã£[[Class]]
ãå©çšãããŸãã
One special case is the global object where the Type is not shown. In that case the stack frame will be formatted as
at functionName [as methodName] (location)
ç¹æ®ã±ãŒã¹ãšããŠãã°ããŒãã«ãªããžã§ã¯ãã«ãããŠã¯Typeã衚瀺ãããŸããããã®å Žåã以äžã®æžåŒã«ãªããŸã:
at functionName [as methodName] (location)
The location itself has several possible formats. Most common is the file name, line and column number within the script that defined the current function
fileName:lineNumber:columnNumber
locationã¯è€æ°ã®æžåŒãååšããŸããæãäžè¬çãªãã®ã¯é¢æ°ãå®çŸ©ããã¹ã¯ãªããã®ãã¡ã€ã«åãšè¡ãåã®çªå·ã§ã:
fileName:lineNumber:columnNumber
If the current function was created using eval the format will be
eval at position
çŸåšã®é¢æ°ãeval
ã§çæãããå Žåã¯ãã®æžåŒã«ãªããŸã:
eval at position
where position is the full position where the call to eval occurred. Note that this means that positions can be nested if there are nested calls to eval, for instance:
eval at Foo.a (eval at Bar.z (myscript.js:10:3))
positionã¯eval
ãå®è¡ãããå Žæã§ããããã¯eval
ãå
¥ãåã§ããã°ãpositionãå
¥ãåã«ãªãåŸããšããäºã«ããªããŸããå®äŸãæããŸã:
eval at Foo.a (eval at Bar.z (myscript.js:10:3))
If a stack frame is within V8’s libraries the location will be
native
ã¹ã¿ãã¯ãã¬ãŒã ãV8ã®ã©ã€ãã©ãªãŒå ã§ããå Žåã¯ãlocationã¯ãããªããŸã:
native
and if is unavailable it will be
unknown location
ç¡å¹ãªå Žåã¯ããã§ã:
unknown location
以äžã翻蚳çµããã