CN116841890A - Method and system for debugging front-end project - Google Patents

Method and system for debugging front-end project Download PDF

Info

Publication number
CN116841890A
CN116841890A CN202310816249.9A CN202310816249A CN116841890A CN 116841890 A CN116841890 A CN 116841890A CN 202310816249 A CN202310816249 A CN 202310816249A CN 116841890 A CN116841890 A CN 116841890A
Authority
CN
China
Prior art keywords
weback
path
plugin
current
compiler
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Pending
Application number
CN202310816249.9A
Other languages
Chinese (zh)
Inventor
梁青
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Shanghai Yunzhou Information Technology Co ltd
Original Assignee
Shanghai Yunzhou Information Technology Co ltd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Shanghai Yunzhou Information Technology Co ltd filed Critical Shanghai Yunzhou Information Technology Co ltd
Priority to CN202310816249.9A priority Critical patent/CN116841890A/en
Publication of CN116841890A publication Critical patent/CN116841890A/en
Pending legal-status Critical Current

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/36—Preventing errors by testing or debugging software
    • G06F11/362—Software debugging
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44—Arrangements for executing specific programs
    • G06F9/445—Program loading or initiating
    • G06F9/44505—Configuring for program initiating, e.g. using registry, configuration files
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44—Arrangements for executing specific programs
    • G06F9/445—Program loading or initiating
    • G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
    • G06F9/44526—Plug-ins; Add-ons

Landscapes

  • Engineering & Computer Science (AREA)
  • Software Systems (AREA)
  • Theoretical Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Computer Hardware Design (AREA)
  • Quality & Reliability (AREA)
  • Stored Programmes (AREA)

Abstract

The application provides a method and a system for debugging a front-end project. The method comprises the following steps: constructing a weback plug-in, and configuring paths needing interception in the weback plug-in; adding the weback plugin to a weback configuration file, so that when the weback runs, the weback plugin is executed after a current compiler generates a compatibility object; before the weback executes the weback plugin, judging whether the current compiler is a main compiler or not, if yes, executing the weback plugin to acquire the current compatibility object and a path to be intercepted; judging whether the path to be intercepted comprises the path of the target file of the analysis request or not according to the compatibility object and the path to be intercepted, if so, modifying the path of the target file into the current path for sending the analysis request command so as to realize the debugging of the front-end project. By the method, in front-end project debugging, when files with the same names as the dependent projects exist, correct analysis of the dependent projects can be ensured, so that the projects cannot fail to run.

Description

Method and system for debugging front-end project
Technical Field
The application relates to the technical field of computer data processing, in particular to a technology for debugging front-end projects.
Background
In browser application development, for front-end projects, a plurality of projects with dependency relationships are frequently subjected to synchronous development, wherein some projects are used as a base library or a component library and are dependent on other projects.
Since npm library release cannot be revoked, the release code is production code, and the release process requires time, the method is generally implemented by firstly completing the npm library to be relied on in a development mode and then importing the npm library in a npm library release mode in a production mode for use. In the development mode, however, the project content also typically requires modification and debugging, which is not applicable.
In the existing development and debugging of multiple front-end projects, a yarn link is generally used to connect a dependency project npm library needing to be debugged and developed to the front-end projects needing to be used. Because only a soft connection is made at the file system level, after the front-end items are run, weback analysis is used in the front-end items, and when the npm library of the dependent items is used, the actual path of the npm library of the dependent items is found according to the path of the soft connection. If the npm library of the dependent item is complex and the npm library of the dependent item is also installed with node_modules as a front-end item at run-time, then the path of the import or request dependent module is sought from the node_modules under the actual path of the nmp library of the dependent item when the weback parses the code file of the npm library of the dependent item. If there is exactly one dependent name at this time that is the same as the dependent name using this dependent item (it is common that the same file name exists in different front-end items), but they do not depend on the same file. Since some variables in the file are global variables, the front-end project may fail to run and may even have unexpected problems when running because it runs a code that is not a piece of code.
Disclosure of Invention
The application aims to provide a method and a system for debugging front-end projects, which are used for solving the technical problem that in some multi-front-end project debugging, when files with the same names as the dependent projects exist, conflicts are generated and operation failure is possibly caused.
According to one aspect of the present application, there is provided a method for front-end project debugging, wherein the method comprises:
constructing a weback plug-in, and configuring paths needing interception in the weback plug-in;
adding the weback plugin to a weback configuration file, so that when the weback runs, the weback plugin is executed after a current compiler generates a compatibility object;
before the weback executes the weback plugin, judging whether the current compiler is a main compiler or not, if yes, executing the weback plugin to acquire a current compatibility object and the path to be intercepted;
judging whether the path to be intercepted comprises a path of a target file of an analysis request or not according to the compatibility object and the path to be intercepted, and if so, modifying the path of the target file into a current path for sending out an analysis request command so as to realize front-end project debugging.
Optionally, the execution priority of the weback plugin is lower than that of a default plugin of the weback.
Optionally, if the current compiler is not the master compiler, the weback plugin is not executed.
According to another aspect of the present application, there is provided a system for front-end project debugging, wherein the system comprises:
the first module is used for constructing a weback plugin, and a path needing interception is configured in the weback plugin;
the second module is used for adding the weback plugin to a weback configuration file so that when the weback runs, the weback plugin is executed after a current compiler generates a compatibility object;
a third module, configured to determine, before the weback executes the weback plugin, whether the current compiler is a master compiler, and if yes, execute the weback plugin to obtain a current compatibility object and the path to be intercepted;
and a fourth module, configured to determine, according to the accounting object and the path to be intercepted, whether the path to be intercepted includes a path where a target file of an analysis request is located, and if yes, modify the path where the target file is located into a current path where an analysis request command is sent, so as to implement front-end project debugging.
Compared with the prior art, the application provides a method and a system for debugging a front-end project. The method comprises the following steps: constructing a weback plug-in, and configuring paths needing interception in the weback plug-in; adding the weback plugin to a weback configuration file, so that when the weback runs, the weback plugin is executed after a current compiler generates a compatibility object; before the weback executes the weback plugin, judging whether the current compiler is a main compiler or not, if yes, executing the weback plugin to acquire a current compatibility object and the path to be intercepted; judging whether the path to be intercepted comprises a path of a target file of an analysis request or not according to the compatibility object and the path to be intercepted, and if so, modifying the path of the target file into a current path for sending out an analysis request command so as to realize front-end project debugging. By the method, in front-end project debugging, when files with the same names as the dependent projects exist, correct analysis of the dependent projects can be guaranteed, so that the projects cannot fail to run.
Drawings
Other features, objects and advantages of the present application will become more apparent upon reading of the detailed description of non-limiting embodiments, made with reference to the accompanying drawings in which:
FIG. 1 illustrates a method flow diagram for front-end project debugging in accordance with an aspect of the present application;
FIG. 2 illustrates a system diagram for front-end project debugging in accordance with another aspect of the present application in which like or similar reference numbers represent like or similar components.
Detailed Description
The application is described in further detail below with reference to the accompanying drawings.
In one typical configuration of embodiments of the application, the units and/or modules of the apparatus, system and/or device may include one or more processors (CPUs), input/output interfaces, network interfaces and memory.
The memory may include volatile memory in a computer-readable medium, random Access Memory (RAM) and/or nonvolatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of computer-readable media.
Computer readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of storage media for a computer include, but are not limited to, phase change memory (PRAM), static Random Access Memory (SRAM), dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), read Only Memory (ROM), electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), digital Versatile Discs (DVD) or other optical storage, magnetic cassettes, magnetic tape disk storage or other magnetic storage devices, or any other non-transmission medium, which can be used to store information that can be accessed by a computing device. Computer readable media, as defined herein, does not include non-transitory computer readable media (transmission media), such as modulated data signals and carrier waves.
In multiple front-end project development, developers typically use a yarn link to connect different projects that have dependencies. For example, two front-end projects a and B are developed simultaneously, where project a relies on project B, if the content of project B is modified, if in development mode project B has not been reissued yet, and at this time it is desired to check in project a if the modification of project B does not affect project a, then usually a yarn link is available: the method comprises the steps of firstly executing the yan link in the item B, then carrying out required modification on the content of the item B, then executing the modified item B, then executing the yan link item B in the item A, executing yan and clearing a browser cache, and then viewing the effect of the modified item B in the item A. After the end, the yarn unlink item B should also be executed in item a to cancel the connection.
However, the above method is not applicable to the case where two items include the same file and global parameters are included in the file. In front-end project development, open source component libraries such as React.js (also called as React. Js or React), react-router, apollo-client and the like are often adopted.
If both front-end projects a and B are installed a reactijs open source component library, where project a relies on project B, specifically, the fun method is imported from project B and the reacti.js file is imported at the time of the parsing of the a.js file of project a, while the fun method is exported for the b.js file of project B and the reacti.js file is imported at the time of the parsing. If item B is connected in item A using a yarn link in the above method, then the action.js file imported in the b.js file is the action js code obtained under the node_modules folder in the path of item B, and the action.js file imported in the a.js file is the action js code obtained under the node_modules folder in the path of item A, as can be seen, the acquired Reactojs codes are different in source, and because the Reactojs will perform some global variable initialization operations when importing files, if the Reactojs codes are not the same source, the initialized global variables will be different, so that the contents are different, and in this case, the project running will report errors. For the same reason, if an open source component library such as a act-router, apollo-client which needs to initialize global parameters is adopted in the interdependent projects, project operation failure can also be caused by adopting a yarn link method.
Thus, for front-end items that are interdependent, if files with global variables are employed, it should be ensured that the imported files come from the same source.
The application provides a technical scheme for debugging a front-end project, which can solve the problems, when the front-end project is debugged, a weback is adopted to start the project, a parser of the weback is used for parsing a file path, in the parsing process, a custom weback plug-in is inserted, the priority of the custom weback plug-in is lower than that of a default plug-in of the weback, when the file path needing to be intercepted is parsed, the path is replaced by a current folder path, the incoming file can be ensured to be the file in the current project, the project operation is ensured to be successful, and the project debugging is completed.
In order to further illustrate the technical means and the effects adopted by the present application, the technical solution of the present application will be clearly and completely described below with reference to the accompanying drawings and preferred embodiments.
FIG. 1 illustrates a method flow diagram for front end page display testing, in accordance with an aspect of the present application, wherein a method of one embodiment includes:
s101, constructing a weback plugin, and configuring a path to be intercepted in the weback plugin;
s102, adding the weback plugin into a weback configuration file, so that when the weback runs, the weback plugin is executed after a current compiler generates a compatibility object;
s103, before the weback executes the weback plugin, judging whether the current compiler is a main compiler or not, if yes, executing the weback plugin to acquire the current compatibility object and the path to be intercepted;
s104, judging whether the path to be intercepted comprises a path of a target file of an analysis request according to the compatibility object and the path to be intercepted, and if so, modifying the path of the target file into a current path for sending out an analysis request command so as to realize front-end project debugging.
The method embodiments/alternative embodiments of the present application may be implemented or performed by the apparatus 100, where the apparatus 100 may be a computer apparatus in which related software and hardware environments satisfying front-end project debugging of the present application are deployed, for example, an operating system (windows, linux or macOS, etc.) is installed, a computer language such as javascript, and related software such as npm, weback. Wherein the computer device includes, but is not limited to, a personal computer, a notebook computer, an industrial computer, a server, a network host, a single network server, or a network server cluster. The computer device is only exemplary, and other devices and/or resource platforms that may be present or hereafter presented as suitable for use with the present application are intended to be within the scope of the present application, as herein incorporated by reference.
In an application scenario where the present application is applicable, front-end project debugging that needs to rely on other projects (such as a base library, a component library, or other front-end projects that are relied on) is performed in the device 100, where a file with the same name as the front-end project exists in a relevant path of the relied on project, and the file with the same name should not be imported by the front-end project, otherwise, the front-end project fails to run and cannot pass debugging.
In this embodiment, in step S101, a custom weback plugin is built in the device 100, in which the relevant paths of the dependent items that need to be intercepted are configured as parameters.
Wherein, the construction of a weback plugin generally comprises: defining a JavaScript naming function; defining an apply method on the prototype of the function; designating an event hook (hook) bound to the weback itself; processing specific data of the weback internal instance; and calling the callback provided by the weback after the function is completed.
Continuing in this embodiment, in step S102, the weback plugin is added to the weback configuration file, so that when the weback runs, the weback plugin is executed after the current compiler generates the compatibility object.
In this embodiment, when the front-end item is debugged, the front-end item may be started by using the weback, and in step S103, before the weback executes the weback plugin, whether the current compiler is a master compiler is first determined, if yes, the weback plugin is executed, so as to obtain the current compatibility object and the path to be intercepted.
In this embodiment, when the module requests the resolution request and determines the resolution request, in step S104, whether the path to be intercepted includes the path of the target file of the resolution request is determined according to the obtained compatibility object and the path to be intercepted, if yes, the path of the target file is modified to be the current path of the resolution request command, so as to implement front-end project debugging.
In this embodiment, in the customized weback plugin, a compiler (compiler) may be received as a parameter by an apply method, a hook is bound on the returned compiler, if the weback is not currently compiled in the main compiler module but in the sub-module, the customized weback plugin is not executed, and the customized weback plugin is directly returned to the main compiler, otherwise, an compare object is generated in the weback main compiler by adding an event hook (hook), and a default plugin (normModulef) is initialized. Wherein the composition object is a tool and a collection of attributes, and there are a plurality of attributes in the interior, wherein one attribute can be used for continuing to subscribe to the process and step executed in the composition, i.e. the composition object can execute a custom weback plug-in when executing in the interior to a certain step. By adding a hook, when analyzing the file, judging whether the path of the target file of the analysis request and the request type are a module request, if the path is the module request and the path of the target file is the path which is configured in the self-defined weback plug-in and needs to be intercepted, modifying the path of the target file into the current path for sending out the analysis request command so as to smoothly complete the operation of the front-end project, and debugging.
An exemplary, adding hook code to a compiler (compiler) may be as follows:
compiler.hooks.compilation.tap("compilationtap",(compilation,params)＝>fun1)
to start running at weback, a compatibility object may be generated to execute fun1. Wherein, fun1 can be processed according to the following logic:
if weback is currently in the main compiler, after completion of the accounting object initialization, analyzing the file, judging whether the path of the target file of the analysis request and the request type are a module request, if the path of the target file is a module request, and if the path of the target file is included in the path to be intercepted configured in the custom weback plugin, the target file cannot be acquired from the path, but the target file is acquired from the current path sending the analysis request, so as to realize the agency of the target file in the intercepted path, namely, the path of the target file is modified into the current path sending the analysis request command, so that the operation of the front-end project is successfully completed, and the debugging is performed.
An exemplary custom weback plug-in code is as follows:
……
class ProxyLinkedModuleRequest{
/**
*@param{Object}options options object
* Package full path of @ param { string } options. LinedpackagePath lined
*/
constructor({linkedPackagePath}){
this.linkedPackagePath＝linkedPackagePath
}
apply(compiler){
compiler.hooks.compilation.tap("compilationtap",(compilation,params)＝>fun1
}
}
……
An exemplary Fun1 code is as follows:
……
{
if(compilation.compiler.isChild()){
//html plugin
return
}
params.normalModuleFactory.resolverFactory.hooks.resolver.for("normal")
.tap("resolverFactoryresolver",(resolver,resolveOptions,userResolveOptions)＝>fun2
}
……
an exemplary fun2 code is as follows:
……
{
resolver.hooks.resolve.tapAsync(
{
name:"ResolverNodeModulesPluginPlugin",
stage:-50,
},
(request,resolveContext,callback)＝>{
if(request.path&&
request.path.indexOf(this.linkedPackagePath)>-1&&
resolver.isModule(request.request)
){
setting context
request.path＝process.cwd()
}
callback()
)
}
……
Optionally, the execution priority of the weback plugin is lower than that of a default plugin of the weback.
In order not to affect the normal operation of the weback, the execution priority of the built custom weback plugin should be lower than that of the default plugin of the weback, and the custom weback plugin is executed in the main compiler after the compatibility object is generated and initialization is completed.
Optionally, if the current compiler is not the master compiler, the weback plugin is not executed.
If the current compiler is not the main compiler but is under a sub-module compiler, the file analysis of weback is not the file analysis performed under the node_modules of the front-end project, and the current compiler should be returned directly to the main compiler of the front-end project without processing, so as to ensure that the dependent file can be accurately analyzed and ensure that the front-end project operates normally.
An exemplary correlation code is as follows:
……
if(compilation.compiler.isChild()){
//html plugin
return
}
……
FIG. 2 illustrates a system for front-end project debugging in accordance with another aspect of the present application, wherein the system of one embodiment comprises:
a first module 210, configured to construct a weback plugin, where a path to be intercepted is configured in the weback plugin;
a second module 220, configured to add the weback plugin to a weback configuration file, so that when the weback runs, the weback plugin is executed after the current compiler generates a compatibility object;
a third module 230, configured to determine whether the current compiler is a master compiler before the weback executes the weback plugin, if yes, execute the weback plugin to obtain the current compatibility object and the path to be intercepted;
and a fourth module 240, configured to determine, according to the accounting object and the path to be intercepted, whether the path to be intercepted includes a path where a target file of the resolution request is located, and if yes, modify the path where the target file is located into a current path where the resolution request command is sent, so as to implement front-end project debugging.
In this embodiment, the system is deployed or integrated in a device 100 that performs the foregoing method embodiments and/or alternative embodiments.
In this embodiment, a custom weback plugin is constructed by the first module 210 of the system, in which the relevant paths of the dependent items that need to be intercepted are configured as parameters.
Continuing in this embodiment, the weback plugin is added to the weback configuration file by the second module 220 of the system, so that when the weback runs, the weback plugin is executed after the current compiler generates the compatibility object.
In this embodiment, when the front-end item is debugged, the front-end item may be started by using the weback, and before the weback executes the weback plugin, whether the current compiler is the master compiler is first judged by the third module 230 of the system, if yes, the weback plugin is executed, so as to obtain the current compatibility object and the path to be intercepted.
In this embodiment, when an analysis request is received and a module request is determined during the analysis request, through the fourth module 240 of the system, according to the obtained accounting object and the path to be intercepted, it is determined whether the path to be intercepted includes a path in which a target file of the analysis request is located, if yes, the path in which the target file is located is modified into a current path in which an analysis request command is sent, so as to implement front-end project debugging.
According to yet another aspect of the present application, there is also provided a computer readable medium storing computer readable instructions executable by a processor to implement the foregoing method embodiments.
It should be noted that, the method embodiments and/or the optional embodiments in the present application do not strictly limit the order of execution of the steps, so long as the method embodiments and/or the optional embodiments can solve the defects existing in the prior art, achieve the purposes of the present application, and obtain the beneficial effects. The method embodiments and/or alternative embodiments of the application may be implemented in software and/or a combination of software and hardware. The software program involved in the present application can be executed by a processor to realize the steps or functions of the above-described embodiments. Likewise, the software program of the present application (including the related data structures) may be stored in a computer-readable recording medium.
Furthermore, some or all of the present application may be implemented as a computer program product, such as computer program instructions, which when executed by a computer, may invoke or provide methods and/or solutions in accordance with the present application by way of operation of the computer. Program instructions for invoking the inventive methods may be stored in fixed or removable recording media and/or transmitted via a data stream in a broadcast or other signal bearing medium and/or stored within a working memory of a computer device operating according to the program instructions.
According to still another aspect of the present application, there is also provided an apparatus for front-end project debugging, the apparatus comprising: a memory storing computer program instructions and a processor for executing the program instructions, wherein the computer program instructions, when executed by the processor, may trigger the device to perform the methods and/or aspects of the foregoing embodiments.
It will be evident to those skilled in the art that the application is not limited to the details of the foregoing illustrative embodiments, and that the present application may be embodied in other specific forms without departing from the spirit or essential characteristics thereof. The present embodiments are, therefore, to be considered in all respects as illustrative and not restrictive, the scope of the application being indicated by the appended claims rather than by the foregoing description, and all changes which come within the meaning and range of equivalency of the claims are therefore intended to be embraced therein. Any reference sign in a claim should not be construed as limiting the claim concerned. Furthermore, it is evident that the word "comprising" does not exclude other elements or steps, and that the singular does not exclude a plurality. The units or means recited in the apparatus claims may also be implemented by means of software and/or hardware. The terms first, second, etc. are used to denote a name, but not any particular order.

Claims (6)

1. A method for front-end project debugging, the method comprising:
constructing a weback plug-in, and configuring paths needing interception in the weback plug-in;
adding the weback plugin to a weback configuration file, so that when the weback runs, the weback plugin is executed after a current compiler generates a compatibility object;
before the weback executes the weback plugin, judging whether the current compiler is a main compiler or not, if yes, executing the weback plugin to acquire a current compatibility object and the path to be intercepted;
judging whether the path to be intercepted comprises a path of a target file of an analysis request or not according to the compatibility object and the path to be intercepted, and if so, modifying the path of the target file into a current path for sending out an analysis request command so as to realize front-end project debugging.
2. The method of claim 1, wherein the weback plugin has an execution priority that is lower than a default plugin of weback.
3. The method of claim 1, wherein the weback plugin is not executed if the current compiler is not a master compiler.
4. A system for front-end project debugging, the system comprising:
the first module is used for constructing a weback plugin, and a path needing interception is configured in the weback plugin;
the second module is used for adding the weback plugin to a weback configuration file so that when the weback runs, the weback plugin is executed after a current compiler generates a compatibility object;
a third module, configured to determine, before the weback executes the weback plugin, whether the current compiler is a master compiler, and if yes, execute the weback plugin to obtain a current compatibility object and the path to be intercepted;
and a fourth module, configured to determine, according to the accounting object and the path to be intercepted, whether the path to be intercepted includes a path where a target file of an analysis request is located, and if yes, modify the path where the target file is located into a current path where an analysis request command is sent, so as to implement front-end project debugging.
5. A computer-readable medium comprising,
having stored thereon computer readable instructions to be executed by a processor to implement the method of any of claims 1 to 3.
6. An apparatus for front-end project debugging, the apparatus comprising:
one or more processors; and
a memory storing computer readable instructions that, when executed, cause the processor to perform the operations of the method of any one of claims 1 to 3.
CN202310816249.9A 2023-07-04 2023-07-04 Method and system for debugging front-end project Pending CN116841890A (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CN202310816249.9A CN116841890A (en) 2023-07-04 2023-07-04 Method and system for debugging front-end project

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
CN202310816249.9A CN116841890A (en) 2023-07-04 2023-07-04 Method and system for debugging front-end project

Publications (1)

Publication Number Publication Date
CN116841890A true CN116841890A (en) 2023-10-03

Family

ID=88166621

Family Applications (1)

Application Number Title Priority Date Filing Date
CN202310816249.9A Pending CN116841890A (en) 2023-07-04 2023-07-04 Method and system for debugging front-end project

Country Status (1)

Country Link
CN (1) CN116841890A (en)

Similar Documents

Publication Publication Date Title
US9274768B2 (en) Runtime code hooking for print driver and functionality testing
JP5415557B2 (en) User script code conversion for debugging
US9471282B2 (en) System and method for using annotations to automatically generate a framework for a custom javaserver faces (JSF) component
US8156473B2 (en) Model oriented debugging
US8458681B1 (en) Method and system for optimizing the object code of a program
US8429632B1 (en) Method and system for debugging merged functions within a program
US9104804B2 (en) Method and system for invoking just-in-time debugger
CN110069259B (en) ID L file-based parsing method and device, electronic equipment and storage medium
US9047100B2 (en) Abstract syntax tree transformation
US20150339219A1 (en) Resilient mock object creation for unit testing
CN111240987B (en) Method and device for detecting migration program, electronic equipment and computer readable storage medium
CN116048731A (en) Code processing method, device, electronic equipment and storage medium
CN111258802A (en) Method for capturing application program crash information and related equipment
CN117931219A (en) Front-end project implementation method and device, electronic equipment and storage medium
CN117850780A (en) Front-end query page generation method, query method, electronic device and storage medium
US10606569B2 (en) Declarative configuration elements
CN113282487A (en) Programming language debugging method and device and terminal equipment
WO2023207973A1 (en) Compiler test method and apparatus, case generation method and apparatus, and instruction storage structure
CN110334031B (en) Memory allocation code detection method and device, computer equipment and storage medium
CN111694729B (en) Application testing method, device, electronic equipment and computer readable medium
CN116841890A (en) Method and system for debugging front-end project
CN113778451B (en) File loading method, file loading device, computer system and computer readable storage medium
CN111399932A (en) Method and system for calling D LL, browser processing method and browser
CN114780952B (en) Detection method, system and storage medium for sensitive application call scene
CN115857900B (en) Automatic code generation method and device, electronic equipment and storage medium

Legal Events

Date Code Title Description
PB01 Publication
PB01 Publication
SE01 Entry into force of request for substantive examination
SE01 Entry into force of request for substantive examination