CN116028108A - Method, device, equipment and storage medium for analyzing dependent package installation time - Google Patents
Method, device, equipment and storage medium for analyzing dependent package installation time Download PDFInfo
- Publication number
- CN116028108A CN116028108A CN202310332222.2A CN202310332222A CN116028108A CN 116028108 A CN116028108 A CN 116028108A CN 202310332222 A CN202310332222 A CN 202310332222A CN 116028108 A CN116028108 A CN 116028108A
- Authority
- CN
- China
- Prior art keywords
- package
- dependency
- dependent
- installation
- item
- 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.)
- Granted
Links
Images
Classifications
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02P—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN THE PRODUCTION OR PROCESSING OF GOODS
- Y02P90/00—Enabling technologies with a potential contribution to greenhouse gas [GHG] emissions mitigation
- Y02P90/30—Computing systems specially adapted for manufacturing
Landscapes
- Stored Programmes (AREA)
Abstract
The application discloses a method, a device, equipment and a storage medium for analyzing the installation time of a dependent package, and relates to the technical field of software development. The method comprises the steps of creating a core logic code file and a dependency package configuration file, analyzing the dependency package configuration file through a first analysis function to obtain a dependency package object, analyzing the dependency package object through a second analysis function to obtain names and version numbers of all the dependency packages, and constructing a dependency item array based on the names and the version numbers of all the dependency packages, wherein each dependency package corresponds to one element item of the dependency item array, creating a blank folder for each element item in the dependency item array respectively, installing each dependency package into the corresponding blank folder, and calling a timing subprocess to calculate the installation time of each dependency package. The method and the device can rapidly analyze the time consumption of the installation of the dependent package, and are convenient for a developer to perform performance optimization.
Description
Technical Field
The application relates to the technical field of software development, in particular to a method, a device, equipment and a storage medium for analyzing the installation time of a dependent package.
Background
When setting up a project environment or switching different source code versions of a Web application, particularly when the project is very large, all dependencies need to be reinstalled due to dependency variation, and the installation progress is often blocked, so that the time consumed for installing which dependency packages needs to be the most.
Current tools for measuring when dependent packages are installed can analyze and display the weback generated bundle package and can help developers identify the largest modules and dependent items in the bundle package. However, the tool only can analyze the size of the introduced dependent package, and many dependencies used in actual project development are not introduced into the project, so that the tool cannot count the installation time of the type of dependent package, has a great relationship with the network environment when the dependent package is installed, has a large error when the size of the dependent package is simply counted, and is not actually installed.
Disclosure of Invention
The embodiment of the application aims to provide an analysis method, an analysis device, computer equipment and a storage medium for the installation of a dependent package, so as to solve the technical problems that the existing tool for the installation of the dependent package cannot count all types of the installation of the dependent package and the simple statistics of the size of the package leads to inaccurate installation of the counted dependent package.
In order to solve the above technical problems, the embodiments of the present application provide a method for analyzing a time for installing a dependency package, which adopts the following technical scheme:
a method of dependent package installation time analysis, comprising:
creating a target item to be tested, creating a core logic code file and a dependency package configuration file in the target item to be tested, and creating a timing subprocess based on the core logic code file;
analyzing the dependency package configuration file through a preset first analysis function to obtain a dependency package object;
resolving the dependent package object through a preset second resolving function to obtain names and version numbers of all the dependent packages in the target item to be tested;
constructing a dependency item array based on names and version numbers of all dependency packages in the target item to be tested, wherein each dependency package corresponds to one element item of the dependency item array;
traversing the dependency item array, and respectively creating a blank folder for each element item in the dependency item array;
executing a dependent package installation command, installing each dependent package into the corresponding blank folder, and calling the timing subprocess to calculate the installation time of each dependent package.
Further, the dependency package configuration file is a package. Json file, the first parsing function is a getDeps () function, and the parsing of the dependency package configuration file by a preset first parsing function is performed to obtain a dependency package object, which specifically includes:
calling a request command built in nodejs to read a package.json file, and calling a getDeps () function to analyze the package.json file to obtain the dependent item attribute of the dependent package, wherein the dependent item attribute of the dependent package comprises the dependence required by a production environment and the dependence required by a development environment;
and storing the dependent item attribute of the dependent package in an object to generate a dependent package object.
Further, the second parsing function is an object_key function, and the parsing of the dependent package object by the preset second parsing function obtains names and version numbers of all the dependent packages in the target item to be tested, which specifically includes:
and analyzing the dependent item attribute in the dependent package object through an object.key function to obtain the names and version numbers of all the dependent packages in the target item to be tested.
Further, the dependency package installation command is an npn install command, and the executing the dependency package installation command installs each dependency package in the corresponding blank folder, and when the timer subprocess is called to calculate the installation use of each dependency package, the method specifically includes:
Responding to an npm install command, and determining all the dependent packages to be installed of the target item to be tested in a dependent package tool library based on the dependent package configuration file;
installing each dependent package to be installed into the corresponding blank folder;
and in the installation process of each dependent package to be installed, calling the timing subprocess to calculate the installation time of each dependent package.
Further, the dependency package tool library is a child-process module, and each dependency package to be installed is installed in the corresponding blank folder, and specifically includes:
calling the request command to read a child-process module, and importing the child-process module into the target item to be tested;
reading an exec function from the child-process module by utilizing the object deconstructing grammar of JS;
and executing an npn install command through an exec function, and sequentially installing each dependency package to be installed into the corresponding blank folder.
Further, in the process of installing each dependent package to be installed, invoking the timing subprocess to calculate the installation use of each dependent package specifically includes:
responding to an npm install command, wherein the system time when the command is triggered is the installation starting time of each dependent packet to be installed;
Monitoring the installation process of each dependent package to be installed in real time, and recording the system time when the installation of the dependent package is completed as the installation completion time of each dependent package to be installed;
the installation time of each dependent package is calculated based on the installation start time of each dependent package to be installed and the installation completion time of each dependent package to be installed.
Further, after traversing the dependency term array, creating a blank folder for each element term in the dependency term array, the method further comprises:
creating a new dependency package configuration file for each blank folder respectively;
acquiring the name and version number of the dependent package corresponding to each blank folder;
and writing the name and version number of the dependent package corresponding to each blank folder into the dependent item configuration of the new dependent package configuration file.
In order to solve the above technical problems, the embodiment of the present application further provides an analysis device for installation of a dependent package, which adopts the following technical scheme:
a dependent package installation time analysis apparatus comprising:
the project creation module is used for creating a target project to be tested, creating a core logic code file and a dependency package configuration file in the target project to be tested, and creating a timing subprocess based on the core logic code file;
The first analysis module is used for analyzing the dependency package configuration file through a preset first analysis function to obtain a dependency package object;
the second analysis module is used for analyzing the dependent package object through a preset second analysis function to obtain names and version numbers of all the dependent packages in the target item to be tested;
the array construction module is used for constructing a dependency item array based on names and version numbers of all dependency packages in the target item to be tested, wherein each dependency package corresponds to one element item of the dependency item array;
the folder creation module is used for traversing the dependency item array and respectively creating a blank folder for each element item in the dependency item array;
and the installation timing module is used for executing the dependent package installation command, installing each dependent package into the corresponding blank folder, and calling the timing subprocess to calculate the installation time of each dependent package.
In order to solve the above technical problems, the embodiments of the present application further provide a computer device, which adopts the following technical schemes:
a computer device comprising a memory having stored therein computer readable instructions which when executed by a processor implement the steps of the dependency package installation time analysis method of any one of the preceding claims.
In order to solve the above technical problems, embodiments of the present application further provide a computer readable storage medium, which adopts the following technical solutions:
a computer readable storage medium having stored thereon computer readable instructions which when executed by a processor implement the steps of the dependent package install time analysis method of any of the preceding claims.
Compared with the prior art, the embodiment of the application has the following main beneficial effects:
the method comprises the steps of creating a core logic code file and a dependency package configuration file, analyzing the dependency package configuration file through a first analysis function to obtain a dependency package object, analyzing the dependency package object through a second analysis function to obtain names and version numbers of all the dependency packages, and constructing a dependency item array based on the names and the version numbers of all the dependency packages, wherein each dependency package corresponds to one element item of the dependency item array, creating a blank folder for each element item in the dependency item array respectively, installing each dependency package into the corresponding blank folder, and calling a timing subprocess to calculate the installation time of each dependency package. According to the method and the device, one folder is independently built for each dependency, only one dependency is configured in each folder, then the npn install dependency package is independently executed, after all dependencies such as the starting time and the ending time of each dependency installation are recorded, the time for installing each dependency of a statistics target project can be realized by calculating the starting time and the ending time, the time for installing the dependency package can be rapidly analyzed, and a developer can conveniently perform performance optimization.
Drawings
For a clearer description of the solution in the present application, a brief description will be given below of the drawings that are needed in the description of the embodiments of the present application, it being obvious that the drawings in the following description are some embodiments of the present application, and that other drawings may be obtained from these drawings without inventive effort for a person of ordinary skill in the art.
FIG. 1 illustrates an exemplary system architecture diagram in which the present application may be applied;
FIG. 2 illustrates a flow chart of one embodiment of a dependent package install time analysis method in accordance with the present application;
FIG. 3 illustrates a flow chart of one embodiment of step S206 in FIG. 2;
FIG. 4 shows a flow chart of another embodiment of step S206 in FIG. 2;
FIG. 5 illustrates a schematic diagram of one embodiment of a dependent package installation analysis device in accordance with the present application;
fig. 6 shows a schematic structural diagram of one embodiment of a computer device according to the present application.
Detailed Description
Unless defined otherwise, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this application belongs; the terminology used in the description of the applications herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the application; the terms "comprising" and "having" and any variations thereof in the description and claims of the present application and in the description of the figures above are intended to cover non-exclusive inclusions. The terms first, second and the like in the description and in the claims or in the above-described figures, are used for distinguishing between different objects and not necessarily for describing a sequential or chronological order.
Reference herein to "an embodiment" means that a particular feature, structure, or characteristic described in connection with the embodiment may be included in at least one embodiment of the present application. The appearances of such phrases in various places in the specification are not necessarily all referring to the same embodiment, nor are separate or alternative embodiments mutually exclusive of other embodiments. Those of skill in the art will explicitly and implicitly appreciate that the embodiments described herein may be combined with other embodiments.
In order to better understand the technical solutions of the present application, the following description will clearly and completely describe the technical solutions in the embodiments of the present application with reference to the accompanying drawings.
As shown in fig. 1, a system architecture 100 may include terminal devices 101, 102, 103, a network 104, and a server 105. The network 104 is used as a medium to provide communication links between the terminal devices 101, 102, 103 and the server 105. The network 104 may include various connection types, such as wired, wireless communication links, or fiber optic cables, among others.
The user may interact with the server 105 via the network 104 using the terminal devices 101, 102, 103 to receive or send messages or the like. Various communication client applications, such as a web browser application, a shopping class application, a search class application, an instant messaging tool, a mailbox client, social platform software, etc., may be installed on the terminal devices 101, 102, 103.
The terminal devices 101, 102, 103 may be various electronic devices having a display screen and supporting web browsing, including but not limited to smartphones, tablet computers, electronic book readers, MP3 players (Moving Picture Experts Group Audio Layer III, dynamic video expert compression standard audio plane 3), MP4 (Moving Picture Experts Group Audio Layer IV, dynamic video expert compression standard audio plane 4) players, laptop and desktop computers, and the like.
The server 105 may be a server that provides various services, such as a background server that provides support for pages displayed on the terminal devices 101, 102, 103, and may be a stand-alone server, or may be a cloud server that provides cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communications, middleware services, domain name services, security services, content delivery networks (Content Delivery Network, CDN), and basic cloud computing services such as big data and artificial intelligence platforms.
It should be noted that, the analysis method for the time of installation of the dependent package provided in the embodiments of the present application is generally executed by a server, and accordingly, the analysis device for the time of installation of the dependent package is generally disposed in the server.
It should be understood that the number of terminal devices, networks and servers in fig. 1 is merely illustrative. There may be any number of terminal devices, networks, and servers, as desired for implementation.
Current tools for measuring the time of dependency package installation are the weback-bundle-analyzer, which can analyze the weback generated bundle and display its size and composition, which can help the developer identify the largest modules and dependencies in the bundle. However, the weback-bundle-analyzer only can analyze the size of the introduced dependent packet, and many dependencies used in actual project development are not introduced into the project, so that the weback-bundle-analyzer cannot count the installation time of the type of dependent packet, and has a great relationship with the network environment when the dependency is installed, and a large error exists in simply counting the size of the packet, which is not the actual installation time.
Aiming at the technical problems, the application discloses a method, a device, equipment and a storage medium for analyzing the installation time of a dependent package, which relate to the technical field of software development, and can quickly analyze the time consumption of the installation of the dependent package by independently creating a folder for each dependence, only configuring one dependence in each folder, independently executing an npn install dependent package, recording the starting time and the ending time of each dependent installation, and after all the dependences are installed, calculating the starting time and the ending time, so that the time consumption of the installation of each dependence of a statistics target project can be realized, and a developer can conveniently perform performance optimization.
Currently, a Web project generally uses NodeJS to start a Web project development environment, uses npm to manage dependency packages, and one project depends on a large number of third-party dependencies. The scheme of the application is realized based on a NodeJS environment, and NodeJS needs to be installed in advance, and the NodeJS version is at least more than 10. The NodeJS is a JavaScript running environment based on a Chrome V8 engine, so that JavaScript runs on a development platform of a server.
With continued reference to FIG. 2, a flow chart of one embodiment of a dependent package install time analysis method in accordance with the present application is shown. The analysis method for the installation of the dependent package comprises the following steps:
s201, creating a target item to be tested, creating a core logic code file and a dependency package configuration file in the target item to be tested, and creating a timing subprocess based on the core logic code file.
In this embodiment, when the server receives the install time analysis instruction, and when responding to the time analysis instruction, a target item to be tested is created, a core logic code file and a dependency package configuration file are created in the target item to be tested, and a timer sub-process is created based on the core logic code file.
The core logic code file is an index. Js file, and the index. Js is the code file where the core logic is located, and is mainly used for creating a sub-process to count the installation time of each dependency. The dependency package configuration file is a package json file, and is used for defining information such as the name, description, version, dependency package and the like of the tool, and is mainly used for version updating.
Under the root directory of each item (npm downloaded package, or other nodejs item), there is typically a package json file, which defines the various modules needed for the item, and the configuration information of the item, such as name, version, license, metadata how to launch the item, running script, etc., and the npm install command can automatically download the needed modules according to the package json configuration file.
The package JSON file is a JSON object, and each member of the JSON object is a setting of the current item, for example, the name is the name of the item, the version is the version, and the JSON file plays multiple roles in the life cycle of the item, such as development, test, on-line version, etc. The package is used as a description file, the package on which the whole project depends is described, the package allows the version of the project-dependent package to be indicated by using a semantic version rule, and the package can be better shared with other developers and is convenient to reuse.
In this embodiment, the electronic device (for example, the server shown in fig. 1) on which the dependent package installation time analysis method operates may receive the installation time analysis instruction or execute the dependent package installation command through a wired connection manner or a wireless connection manner. It should be noted that the wireless connection may include, but is not limited to, 3G/4G connections, wiFi connections, bluetooth connections, wiMAX connections, zigbee connections, UWB (ultra wideband) connections, and other now known or later developed wireless connection means.
S202, analyzing the dependency package configuration file through a preset first analysis function to obtain a dependency package object.
In this embodiment, the first parsing function is a getDeps () function, and the server parses the package json file by calling the getDeps () function, reads the dependency item attribute of the dependency package, and generates a dependency package object (package object). The getDeps () function is used for analyzing the package json of the template item to be analyzed, and obtaining the attribute of the dependent item in the package json.
Further, analyzing the dependency package configuration file through a preset first analysis function to obtain a dependency package object, which specifically includes:
calling a request command built in nodejs to read a package.json file, and calling a getDeps () function to analyze the package.json file to obtain the dependent item attribute of the dependent package, wherein the dependent item attribute of the dependent package comprises the dependence required by a production environment and the dependence required by a development environment;
the dependency item attributes of the dependency package are stored in an object to generate a dependency package object.
In this embodiment, a request command built in a nodejs is called to read a package file, and a getDeps () function is called to parse the package file to obtain the dependency term attribute of the dependency package, and the dependency term attribute of the dependency package is stored in an object to generate a package object, named as deps and returned. Wherein the dependency item attributes of the dependency package include dependencies required by the production environment and dependencies required in the development environment, both types of dependencies being installed when npm install is executed.
In the above embodiment, the getdependences () function is used to obtain which dependent packets in the target item to be tested need to be measured separately, for example, there are two dependent packets A, B described in dependencies, and there are two dependent packets C, D described in dependencies, so that this scheme will combine them together during measurement, that is, when four dependent packets A, B, C, D are tested separately and installed.
And S203, analyzing the dependent package object through a preset second analysis function to obtain names and version numbers of all the dependent packages in the target item to be tested.
In this embodiment, the second parsing function is an object_key function, and the names and version numbers of all the dependent packages in the target item to be tested are obtained by parsing the returned package object named "deps" by the object_key function. The returned package object contains the dependency item attribute of the dependency package in the package json file, namely, the names and version numbers of all the dependency packages.
Further, resolving the dependent package object through a preset second resolving function to obtain names and version numbers of all the dependent packages in the target item to be tested, which specifically comprises:
and analyzing the attribute of the dependent item in the dependent package object through the object.key function to obtain the names and version numbers of all the dependent packages in the target item to be tested.
In this embodiment, the server obtains the names and version numbers of all the dependency packages in the target item to be tested by calling the dependency item attribute in the package object with the name "deps" of the object.
S204, constructing a dependency item array based on names and version numbers of all the dependency packages in the target item to be tested, wherein each dependency package corresponds to one element item of the dependency item array.
In this embodiment, after obtaining the names and version numbers of all the dependent packages in the target item to be tested, the server constructs a dependent item array based on the names and version numbers of all the dependent packages in the target item to be tested, stores all the dependent package information into an array, and facilitates the cyclic creation of folders in the subsequent steps and the installation of corresponding dependent packages in the created folders. Wherein each dependency package corresponds to an element item of the dependency item array.
S205, traversing the dependency item array, and respectively creating a blank folder for each element item in the dependency item array.
In this embodiment, the server loops through the dependency term array, where each element term is a dependency package information, including the name and version of the dependency package, and by obtaining the name and version of the dependency package, a package json specifying the name and version may be created. When an npm install command is executed, the system automatically installs the version of the dependency.
S206, executing a dependent package installation command, installing each dependent package into a corresponding blank folder, and calling a timing subprocess to calculate the installation time of each dependent package.
The dependency package installation command is an npn install command, which installs any dependency package in the node_modules directory, does not modify package json, and does not automatically install the dependency package when the npn install command is executed later.
In this embodiment, after creating a blank folder for each dependent package, the server waits for an npm install command, and when the npm install command is triggered, installs each dependent package in the corresponding blank folder, and starts a timer sub-process task, and marks the start time and the completion time of installation of each dependent package, so as to calculate the installation time of each dependent package.
Further, executing a dependent package installation command, installing each dependent package into a corresponding blank folder, and calling a timing subprocess to calculate the installation use of each dependent package, wherein the method specifically comprises the following steps:
responding to the npm install command, and determining all the dependent packages to be installed of the target item to be tested in a dependent package tool library based on the dependent package configuration file;
Installing each dependent package to be installed into a corresponding blank folder;
in the installation process of each dependent package to be installed, a timing subprocess is called to calculate the installation time of each dependent package.
In this embodiment, after receiving the npm install command, the server responds to the npm install command, determines all to-be-installed dependent packages of the target item to be tested from the preset dependent package tool library based on the dependent package configuration information recorded by the package json file, obtains all to-be-installed dependent packages, installs each to-be-installed dependent package into a corresponding blank folder, and simultaneously invokes a timing subprocess to calculate the installation time of each dependent package in the installation process of each to-be-installed dependent package.
In the above embodiment, all the dependent packages to be installed are searched from the dependent package tool library based on the package json file, and each dependent package to be installed is installed in the corresponding blank folder, wherein each blank folder only allows one dependent package to be installed, so that the installation of each dependent package is not affected by each other, and the statistical accuracy is ensured.
Further, the dependency package tool library is a child-process module, and each dependency package to be installed is installed in a corresponding blank folder, which specifically includes:
Calling a request command to read a child-process module, and importing the child-process module into a target item to be tested;
reading an exec function from the child-process module by utilizing the object deconstructing grammar of JS;
and executing an npn install command through the exec function, and installing each dependency package to be installed into a corresponding blank folder in sequence.
In this embodiment, the server reads the child-process module by calling the required command, imports the child-process module into the target item to be tested, reads the exec function from the child-process module by using the object deconstructing syntax of JS, executes the npm install command by the exec function, installs each dependent package to be installed in the corresponding blank folder in turn, returns the command execution result if the exec function executes the npm install command successfully, monitors the process of executing the npm install command by setting the timing task, and can obtain the installation time of the dependent package.
In the embodiment, the implementation of the scheme is based on the NodeJS environment, the exec method of the child-process module is relied on to asynchronously execute the npm installation command, a folder is independently built for each dependency, only one dependency is configured in each folder, then the npm installation dependency package is independently executed in a parallel mode, the starting time and the ending time of each dependency installation are recorded, and after all dependencies are installed, the installation time of each dependency of a target item can be counted by calculating the starting time and the ending time.
Further, referring to fig. 3, in the process of installing each dependency package to be installed, when the timer subprocess is called to calculate the installation use of each dependency package, the method specifically includes:
s301, responding to an npn install command, wherein the system time recorded when the command is triggered is the installation start time of each dependent packet to be installed;
s302, monitoring the installation process of each dependent package to be installed in real time, and recording the system time when the installation of the dependent package is completed as the installation completion time of each dependent package to be installed;
s303, calculating the installation time of each dependent package based on the installation start time of each dependent package to be installed and the installation completion time of each dependent package to be installed.
In this embodiment, the server correspondingly generates an npm install command for each to-be-installed dependency package, sends the npm install command to the exec function for execution, responds to the npm install command, calls the timing process to record the system time when the npm install command triggers as the installation start time start of the to-be-installed dependency package, and when the exec function executes the npm install command and returns an execution result, calls the timing process to record the system time when the execution result is returned as the installation completion time end of each to-be-installed dependency package, and obtains the installation time total time of the dependency package by subtracting the time of the installation start time start from the installation completion time end. The dependent package and the corresponding total time installation time are stored in a time array, and the time array is ordered from large to small according to the installation time, so that the time consumption of installing all the dependent items is obtained, the time consumption of installing the dependent package can be easily seen after the time consumption is ordered, and finally a time log list is output on a control console through a method of a con built in NodeJS, so that the time consumption of installing the dependent items can be known.
Further, referring to fig. 4, after traversing the dependency term array to create a blank folder for each element term in the dependency term array, the method further includes:
s401, creating a new dependent package configuration file for each blank folder respectively;
s402, acquiring the name and version number of the dependent package corresponding to each blank folder;
s403, the name and version number of the dependent package corresponding to each blank folder are written into the dependent item configuration of the new dependent package configuration file.
In this embodiment, a new package json file is created in each blank folder for dependency installation, and then the dependency package name and version corresponding to the folder are written in the dependency item configuration dependencies in the new package json file, so as to ensure that only one dependency is installed in the folder.
In the above embodiment, the application discloses a method for analyzing the time of package installation, and relates to the technical field of software development. The method comprises the steps of creating a core logic code file and a dependency package configuration file, analyzing the dependency package configuration file through a first analysis function to obtain a dependency package object, analyzing the dependency package object through a second analysis function to obtain names and version numbers of all the dependency packages, and constructing a dependency item array based on the names and the version numbers of all the dependency packages, wherein each dependency package corresponds to one element item of the dependency item array, creating a blank folder for each element item in the dependency item array respectively, installing each dependency package into the corresponding blank folder, and calling a timing subprocess to calculate the installation time of each dependency package. According to the method and the device, one folder is independently built for each dependency, only one dependency is configured in each folder, then the npn install dependency package is independently executed, after all dependencies such as the starting time and the ending time of each dependency installation are recorded, the time for installing each dependency of a statistics target project can be realized by calculating the starting time and the ending time, the time for installing the dependency package can be rapidly analyzed, and a developer can conveniently perform performance optimization.
Those skilled in the art will appreciate that implementing all or part of the processes of the methods of the embodiments described above may be accomplished by way of computer readable instructions, stored on a computer readable storage medium, which when executed may comprise processes of embodiments of the methods described above. The storage medium may be a nonvolatile storage medium such as a magnetic disk, an optical disk, a Read-Only Memory (ROM), or a random access Memory (Random Access Memory, RAM).
It should be understood that, although the steps in the flowcharts of the figures are shown in order as indicated by the arrows, these steps are not necessarily performed in order as indicated by the arrows. The steps are not strictly limited in order and may be performed in other orders, unless explicitly stated herein. Moreover, at least some of the steps in the flowcharts of the figures may include a plurality of sub-steps or stages that are not necessarily performed at the same time, but may be performed at different times, the order of their execution not necessarily being sequential, but may be performed in turn or alternately with other steps or at least a portion of the other steps or stages.
With further reference to fig. 5, as an implementation of the method shown in fig. 2 and described above, the present application provides an embodiment of an analysis apparatus for package installation, which corresponds to the method embodiment shown in fig. 2, and which is particularly applicable to various electronic devices.
As shown in fig. 5, the dependency package installation analysis apparatus 500 according to the present embodiment includes:
the project creation module 501 is configured to create a target project to be tested, create a core logic code file and a dependency package configuration file in the target project to be tested, and create a timing subprocess based on the core logic code file;
the first parsing module 502 is configured to parse the dependency package configuration file through a preset first parsing function to obtain a dependency package object;
a second parsing module 503, configured to parse the dependency package object through a preset second parsing function, so as to obtain names and version numbers of all the dependency packages in the target item to be tested;
an array construction module 504, configured to construct a dependency item array based on names and version numbers of all dependency packages in the target item to be tested, where each dependency package corresponds to an element item of the dependency item array;
The folder creation module 505 is configured to traverse the dependency item array, and create a blank folder for each element item in the dependency item array;
and the installation timing module 506 is configured to execute a dependency package installation command, install each dependency package into a corresponding blank folder, and invoke a timing sub-process to calculate an installation time of each dependency package.
Further, the package configuration file is a package. Json file, the first parsing function is a getDeps () function, and the first parsing module 502 specifically includes:
the first analysis unit is used for calling a request command built in a nodejs to read a package.json file, and calling a getDeps () function to analyze the package.json file to obtain the dependent item attribute of the dependent package, wherein the dependent item attribute of the dependent package comprises the dependence required by a production environment and the dependence required by a development environment;
and the package object generating unit is used for storing the dependent item attribute of the dependent package in one object and generating a dependent package object.
Further, the second parsing function is an object.
And the second analysis unit is used for analyzing the dependent item attribute in the dependent package object through the object.key function to obtain the names and version numbers of all the dependent packages in the target item to be tested.
Further, the dependent package install command is an npn install command, and the install timer module 506 specifically includes:
the dependency package determining unit is used for responding to the npn install command and determining all dependency packages to be installed of the target item to be tested in the dependency package tool library based on the dependency package configuration file;
the dependency package installation unit is used for installing each dependency package to be installed into a corresponding blank folder;
and the installation timing unit is used for calling the timing subprocess to calculate the installation time of each dependent package in the installation process of each dependent package to be installed.
Further, the dependency package tool library is a child-process module, and the dependency package installation unit specifically includes:
the tool library importing subunit is used for calling a request command to read the child-process module and importing the child-process module into a target item to be tested;
the exec function reading subunit is used for reading the exec function from the child-process module by utilizing the object deconstructing grammar of JS;
and the dependent package installation subunit is used for executing an npn instruction through the exec function and sequentially installing each dependent package to be installed into the corresponding blank folder.
Further, the installation timing unit specifically includes:
a start time recording subunit, configured to respond to an npn install command, and record a system time when the command is triggered as an installation start time of each to-be-installed dependent packet;
the completion time recording subunit is used for monitoring the installation process of each dependent package to be installed in real time, and recording the system time when the installation is completed as the installation completion time of each dependent package to be installed when the installation of the dependent package is completed;
an installation timing subunit for calculating an installation time of each dependent package based on an installation start time of each dependent package to be installed and an installation completion time of each dependent package to be installed.
Further, the dependent package installation time analysis apparatus 500 further includes:
the file creation module is used for creating a new dependency package configuration file for each blank folder respectively;
the information acquisition module is used for acquiring the name and version number of the dependent package corresponding to each blank folder;
and the information writing module is used for writing the name and version number of the dependent package corresponding to each blank folder into the dependent item configuration of the new dependent package configuration file.
In the above embodiments, the application discloses a device for analyzing the time of package installation, and relates to the technical field of software development. The method comprises the steps of creating a core logic code file and a dependency package configuration file, analyzing the dependency package configuration file through a first analysis function to obtain a dependency package object, analyzing the dependency package object through a second analysis function to obtain names and version numbers of all the dependency packages, and constructing a dependency item array based on the names and the version numbers of all the dependency packages, wherein each dependency package corresponds to one element item of the dependency item array, creating a blank folder for each element item in the dependency item array respectively, installing each dependency package into the corresponding blank folder, and calling a timing subprocess to calculate the installation time of each dependency package. According to the method and the device, one folder is independently built for each dependency, only one dependency is configured in each folder, then the npn install dependency package is independently executed, after all dependencies such as the starting time and the ending time of each dependency installation are recorded, the time for installing each dependency of a statistics target project can be realized by calculating the starting time and the ending time, the time for installing the dependency package can be rapidly analyzed, and a developer can conveniently perform performance optimization.
In order to solve the technical problems, the embodiment of the application also provides computer equipment. Referring specifically to fig. 6, fig. 6 is a basic structural block diagram of a computer device according to the present embodiment.
The computer device 6 comprises a memory 61, a processor 62, a network interface 63 communicatively connected to each other via a system bus. It is noted that only computer device 6 having components 61-63 is shown in the figures, but it should be understood that not all of the illustrated components are required to be implemented and that more or fewer components may be implemented instead. It will be appreciated by those skilled in the art that the computer device herein is a device capable of automatically performing numerical calculations and/or information processing in accordance with predetermined or stored instructions, the hardware of which includes, but is not limited to, microprocessors, application specific integrated circuits (Application Specific Integrated Circuit, ASICs), programmable gate arrays (fields-Programmable Gate Array, FPGAs), digital processors (Digital Signal Processor, DSPs), embedded devices, etc.
The computer equipment can be a desktop computer, a notebook computer, a palm computer, a cloud server and other computing equipment. The computer equipment can perform man-machine interaction with a user through a keyboard, a mouse, a remote controller, a touch pad or voice control equipment and the like.
The memory 61 includes at least one type of readable storage media including flash memory, hard disk, multimedia card, card memory (e.g., SD or DX memory, etc.), random Access Memory (RAM), static Random Access Memory (SRAM), read Only Memory (ROM), electrically Erasable Programmable Read Only Memory (EEPROM), programmable Read Only Memory (PROM), magnetic memory, magnetic disk, optical disk, etc. In some embodiments, the storage 61 may be an internal storage unit of the computer device 6, such as a hard disk or a memory of the computer device 6. In other embodiments, the memory 61 may also be an external storage device of the computer device 6, such as a plug-in hard disk, a Smart Media Card (SMC), a Secure Digital (SD) Card, a Flash Card (Flash Card) or the like, which are provided on the computer device 6. Of course, the memory 61 may also comprise both an internal memory unit of the computer device 6 and an external memory device. In this embodiment, the memory 61 is typically used to store an operating system and various application software installed on the computer device 6, such as computer readable instructions depending on the analysis method used in the package installation. Further, the memory 61 may be used to temporarily store various types of data that have been output or are to be output.
The processor 62 may be a central processing unit (Central Processing Unit, CPU), controller, microcontroller, microprocessor, or other data processing chip in some embodiments. The processor 62 is typically used to control the overall operation of the computer device 6. In this embodiment, the processor 62 is configured to execute computer readable instructions stored in the memory 61 or process data, such as computer readable instructions for executing the analysis method for packet installation.
The network interface 63 may comprise a wireless network interface or a wired network interface, which network interface 63 is typically used for establishing a communication connection between the computer device 6 and other electronic devices.
The application discloses computer equipment relates to the technical field of software development. The method comprises the steps of creating a core logic code file and a dependency package configuration file, analyzing the dependency package configuration file through a first analysis function to obtain a dependency package object, analyzing the dependency package object through a second analysis function to obtain names and version numbers of all the dependency packages, and constructing a dependency item array based on the names and the version numbers of all the dependency packages, wherein each dependency package corresponds to one element item of the dependency item array, creating a blank folder for each element item in the dependency item array respectively, installing each dependency package into the corresponding blank folder, and calling a timing subprocess to calculate the installation time of each dependency package. According to the method and the device, one folder is independently built for each dependency, only one dependency is configured in each folder, then the npn install dependency package is independently executed, after all dependencies such as the starting time and the ending time of each dependency installation are recorded, the time for installing each dependency of a statistics target project can be realized by calculating the starting time and the ending time, the time for installing the dependency package can be rapidly analyzed, and a developer can conveniently perform performance optimization.
The present application provides yet another embodiment, namely, a computer-readable storage medium, which may be either a non-volatile storage medium or a volatile storage medium. The computer readable storage medium stores computer readable instructions executable by at least one processor to cause the at least one processor to perform the steps of the dependency package installation time analysis method as described above.
The application discloses a storage medium, and relates to the technical field of software development. The method comprises the steps of creating a core logic code file and a dependency package configuration file, analyzing the dependency package configuration file through a first analysis function to obtain a dependency package object, analyzing the dependency package object through a second analysis function to obtain names and version numbers of all the dependency packages, and constructing a dependency item array based on the names and the version numbers of all the dependency packages, wherein each dependency package corresponds to one element item of the dependency item array, creating a blank folder for each element item in the dependency item array respectively, installing each dependency package into the corresponding blank folder, and calling a timing subprocess to calculate the installation time of each dependency package. According to the method and the device, one folder is independently built for each dependency, only one dependency is configured in each folder, then the npn install dependency package is independently executed, after all dependencies such as the starting time and the ending time of each dependency installation are recorded, the time for installing each dependency of a statistics target project can be realized by calculating the starting time and the ending time, the time for installing the dependency package can be rapidly analyzed, and a developer can conveniently perform performance optimization.
From the above description of the embodiments, it will be clear to those skilled in the art that the above-described embodiment method may be implemented by means of software plus a necessary general hardware platform, but of course may also be implemented by means of hardware, but in many cases the former is a preferred embodiment. Based on such understanding, the technical solution of the present application may be embodied essentially or in a part contributing to the prior art in the form of a software product stored in a storage medium (such as ROM/RAM, magnetic disk, optical disk), comprising several instructions for causing a terminal device (which may be a mobile phone, a computer, a server, an air conditioner, or a network device, etc.) to perform the method described in the embodiments of the present application.
The subject application is operational with numerous general purpose or special purpose computer system environments or configurations. For example: personal computers, server computers, hand-held or portable devices, tablet devices, multiprocessor systems, microprocessor-based systems, set top boxes, programmable consumer electronics, network PCs, minicomputers, mainframe computers, distributed computing environments that include any of the above systems or devices, and the like. The application may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The application may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices.
It is apparent that the embodiments described above are only some embodiments of the present application, but not all embodiments, the preferred embodiments of the present application are given in the drawings, but not limiting the patent scope of the present application. This application may be embodied in many different forms, but rather, embodiments are provided in order to provide a more thorough understanding of the present disclosure. Although the present application has been described in detail with reference to the foregoing embodiments, it will be apparent to those skilled in the art that modifications may be made to the embodiments described in the foregoing, or equivalents may be substituted for elements thereof. All equivalent structures made by the specification and the drawings of the application are directly or indirectly applied to other related technical fields, and are also within the protection scope of the application.
Claims (10)
1. A method of time-dependent package installation analysis, comprising:
creating a target item to be tested, creating a core logic code file and a dependency package configuration file in the target item to be tested, and creating a timing subprocess based on the core logic code file;
Analyzing the dependency package configuration file through a preset first analysis function to obtain a dependency package object;
resolving the dependent package object through a preset second resolving function to obtain names and version numbers of all the dependent packages in the target item to be tested;
constructing a dependency item array based on names and version numbers of all dependency packages in the target item to be tested, wherein each dependency package corresponds to one element item of the dependency item array;
traversing the dependency item array, and respectively creating a blank folder for each element item in the dependency item array;
executing a dependent package installation command, installing each dependent package into the corresponding blank folder, and calling the timing subprocess to calculate the installation time of each dependent package.
2. The method for analyzing the time required for installing the dependent package according to claim 1, wherein the dependent package configuration file is a package json file, the first analysis function is a getDeps () function, and the analyzing the dependent package configuration file by a preset first analysis function to obtain the dependent package object specifically includes:
calling a request command built in nodejs to read a package.json file, and calling a getDeps () function to analyze the package.json file to obtain the dependent item attribute of the dependent package, wherein the dependent item attribute of the dependent package comprises the dependence required by a production environment and the dependence required by a development environment;
And storing the dependent item attribute of the dependent package in an object to generate a dependent package object.
3. The method for analyzing the time required for installing the dependency package according to claim 1, wherein the second analysis function is an object function, and the analyzing the dependency package object by the preset second analysis function to obtain names and version numbers of all the dependency packages in the target item to be tested specifically includes:
and analyzing the dependent item attribute in the dependent package object through an object.key function to obtain the names and version numbers of all the dependent packages in the target item to be tested.
4. The method for analyzing the time for installing the dependent package according to claim 1, wherein the dependent package installation command is an npm install command, and the executing the dependent package installation command installs each dependent package in the corresponding blank folder, and the calling the timer subprocess to calculate the time for installing each dependent package specifically includes:
responding to an npm install command, and determining all the dependent packages to be installed of the target item to be tested in a dependent package tool library based on the dependent package configuration file;
installing each dependent package to be installed into the corresponding blank folder;
And in the installation process of each dependent package to be installed, calling the timing subprocess to calculate the installation time of each dependent package.
5. The method for analyzing the time for installing the dependency package according to claim 4, wherein the dependency package tool library is a child-process module, and each dependency package to be installed is installed in the corresponding blank folder, specifically comprising:
calling the request command to read a child-process module, and importing the child-process module into the target item to be tested;
reading an exec function from the child-process module by utilizing the object deconstructing grammar of JS;
and executing an npn install command through an exec function, and sequentially installing each dependency package to be installed into the corresponding blank folder.
6. The method for analyzing the installation time of the dependent package according to claim 4, wherein the step of calling the timer sub-process to calculate the installation time of each dependent package in the installation process of each dependent package to be installed specifically comprises the following steps:
responding to an npm install command, wherein the system time when the command is triggered is the installation starting time of each dependent packet to be installed;
Monitoring the installation process of each dependent package to be installed in real time, and recording the system time when the installation of the dependent package is completed as the installation completion time of each dependent package to be installed;
the installation time of each dependent package is calculated based on the installation start time of each dependent package to be installed and the installation completion time of each dependent package to be installed.
7. The dependency package installation time analysis method of any one of claims 1 to 6, further comprising, after said traversing the dependency term array to create a blank folder for each element term in the dependency term array, respectively:
creating a new dependency package configuration file for each blank folder respectively;
acquiring the name and version number of the dependent package corresponding to each blank folder;
and writing the name and version number of the dependent package corresponding to each blank folder into the dependent item configuration of the new dependent package configuration file.
8. A time-dependent package installation analysis device, comprising:
the project creation module is used for creating a target project to be tested, creating a core logic code file and a dependency package configuration file in the target project to be tested, and creating a timing subprocess based on the core logic code file;
The first analysis module is used for analyzing the dependency package configuration file through a preset first analysis function to obtain a dependency package object;
the second analysis module is used for analyzing the dependent package object through a preset second analysis function to obtain names and version numbers of all the dependent packages in the target item to be tested;
the array construction module is used for constructing a dependency item array based on names and version numbers of all dependency packages in the target item to be tested, wherein each dependency package corresponds to one element item of the dependency item array;
the folder creation module is used for traversing the dependency item array and respectively creating a blank folder for each element item in the dependency item array;
and the installation timing module is used for executing the dependent package installation command, installing each dependent package into the corresponding blank folder, and calling the timing subprocess to calculate the installation time of each dependent package.
9. A computer device comprising a memory having stored therein computer readable instructions which when executed by the processor implement the steps of the dependent package install time analysis method of any of claims 1 to 7.
10. A computer readable storage medium having stored thereon computer readable instructions which when executed by a processor implement the steps of the dependency package installation time analysis method of any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310332222.2A CN116028108B (en) | 2023-03-31 | 2023-03-31 | Method, device, equipment and storage medium for analyzing dependent package installation time |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310332222.2A CN116028108B (en) | 2023-03-31 | 2023-03-31 | Method, device, equipment and storage medium for analyzing dependent package installation time |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN116028108A true CN116028108A (en) | 2023-04-28 |
| CN116028108B CN116028108B (en) | 2023-06-06 |
Family
ID=86074531
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310332222.2A Active CN116028108B (en) | 2023-03-31 | 2023-03-31 | Method, device, equipment and storage medium for analyzing dependent package installation time |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116028108B (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN118113338A (en) * | 2024-03-08 | 2024-05-31 | 北京峥研软件有限责任公司 | Dependency package management method under cloud original ecology |
Citations (14)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5805898A (en) * | 1995-02-24 | 1998-09-08 | International Business Machines Corporation | Method and apparatus for estimating installation time in a data processing system |
| CN106325908A (en) * | 2015-06-30 | 2017-01-11 | 北京金山安全软件有限公司 | Application package installation method and application package installation device |
| CN107122205A (en) * | 2017-04-11 | 2017-09-01 | 上海众开信息科技有限公司 | The set-up time of installation procedure determines method and device |
| CN107741910A (en) * | 2017-10-18 | 2018-02-27 | 北京奇虎科技有限公司 | Application program installation capability method of testing, device, computing device and storage medium |
| CN108958753A (en) * | 2018-07-13 | 2018-12-07 | 中国银行股份有限公司 | A kind of code is packaged dispositions method and device |
| CN111176670A (en) * | 2019-12-31 | 2020-05-19 | 联想(北京)有限公司 | Method and device for determining installation time |
| CN111427558A (en) * | 2020-04-10 | 2020-07-17 | 创盛视联数码科技（北京）有限公司 | Method for customizing front-end automatic development environment based on webpack |
| CN112631621A (en) * | 2020-12-29 | 2021-04-09 | 微医云(杭州)控股有限公司 | Dependency package management method, device, server and storage medium |
| WO2021184728A1 (en) * | 2020-03-17 | 2021-09-23 | 平安科技（深圳）有限公司 | Automatic packaging construction method and device, and computer readable storage medium |
| CN113741951A (en) * | 2020-05-29 | 2021-12-03 | 北京沃东天骏信息技术有限公司 | Local packaging method and device |
| WO2021262054A1 (en) * | 2020-06-25 | 2021-12-30 | Telefonaktiebolaget Lm Ericsson (Publ) | Method for controlling deployment of cached dependencies on one or more selected nodes in a distributed computing system |
| CN114721672A (en) * | 2022-03-29 | 2022-07-08 | 统信软件技术有限公司 | Application installation method, computing device and storage medium |
| CN115543429A (en) * | 2022-10-31 | 2022-12-30 | 平安银行股份有限公司 | Project environment building method, electronic equipment and computer readable storage medium |
| CN115543360A (en) * | 2022-10-31 | 2022-12-30 | 浪潮通用软件有限公司 | Method, device, equipment and medium for rapidly deploying application |
-
2023
- 2023-03-31 CN CN202310332222.2A patent/CN116028108B/en active Active
Patent Citations (14)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5805898A (en) * | 1995-02-24 | 1998-09-08 | International Business Machines Corporation | Method and apparatus for estimating installation time in a data processing system |
| CN106325908A (en) * | 2015-06-30 | 2017-01-11 | 北京金山安全软件有限公司 | Application package installation method and application package installation device |
| CN107122205A (en) * | 2017-04-11 | 2017-09-01 | 上海众开信息科技有限公司 | The set-up time of installation procedure determines method and device |
| CN107741910A (en) * | 2017-10-18 | 2018-02-27 | 北京奇虎科技有限公司 | Application program installation capability method of testing, device, computing device and storage medium |
| CN108958753A (en) * | 2018-07-13 | 2018-12-07 | 中国银行股份有限公司 | A kind of code is packaged dispositions method and device |
| CN111176670A (en) * | 2019-12-31 | 2020-05-19 | 联想(北京)有限公司 | Method and device for determining installation time |
| WO2021184728A1 (en) * | 2020-03-17 | 2021-09-23 | 平安科技（深圳）有限公司 | Automatic packaging construction method and device, and computer readable storage medium |
| CN111427558A (en) * | 2020-04-10 | 2020-07-17 | 创盛视联数码科技（北京）有限公司 | Method for customizing front-end automatic development environment based on webpack |
| CN113741951A (en) * | 2020-05-29 | 2021-12-03 | 北京沃东天骏信息技术有限公司 | Local packaging method and device |
| WO2021262054A1 (en) * | 2020-06-25 | 2021-12-30 | Telefonaktiebolaget Lm Ericsson (Publ) | Method for controlling deployment of cached dependencies on one or more selected nodes in a distributed computing system |
| CN112631621A (en) * | 2020-12-29 | 2021-04-09 | 微医云(杭州)控股有限公司 | Dependency package management method, device, server and storage medium |
| CN114721672A (en) * | 2022-03-29 | 2022-07-08 | 统信软件技术有限公司 | Application installation method, computing device and storage medium |
| CN115543429A (en) * | 2022-10-31 | 2022-12-30 | 平安银行股份有限公司 | Project environment building method, electronic equipment and computer readable storage medium |
| CN115543360A (en) * | 2022-10-31 | 2022-12-30 | 浪潮通用软件有限公司 | Method, device, equipment and medium for rapidly deploying application |
Non-Patent Citations (2)
| Title |
|---|
| ALEXANDRE DECAN等: "On the Evolution of Technical Lag in the npm Package Dependency Network", 2018 IEEE INTERNATIONAL CONFERENCE ON SOFTWARE MAINTENANCE AND EVOLUTION (ICSME), pages 404 - 414 * |
| HYDRION-QLZ: "Nodejs中包的介绍及npm安装依赖包的多种方法", pages 1 - 5, Retrieved from the Internet <URL:https://blog.csdn.net/qq_46311811/article/details/128038708> * |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN118113338A (en) * | 2024-03-08 | 2024-05-31 | 北京峥研软件有限责任公司 | Dependency package management method under cloud original ecology |
Also Published As
| Publication number | Publication date |
|---|---|
| CN116028108B (en) | 2023-06-06 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| Hunt et al. | Java performance | |
| CN110737460A (en) | platform project management method and device | |
| CN117033249B (en) | Test case generation method and device, computer equipment and storage medium | |
| CN112099800A (en) | Code data processing method and device and server | |
| CN110515795A (en) | A kind of monitoring method of big data component, device, electronic equipment | |
| CN107391528B (en) | Front-end component dependent information searching method and equipment | |
| CN111177113A (en) | Data migration method and device, computer equipment and storage medium | |
| CN114297700B (en) | Dynamic and static combined mobile application privacy protocol extraction method and related equipment | |
| CN111666201A (en) | Regression testing method, device, medium and electronic equipment | |
| CN109947624A (en) | Method for monitoring state and device | |
| CN103186463B (en) | Determine the method and system of the test specification of software | |
| CN116028108B (en) | Method, device, equipment and storage medium for analyzing dependent package installation time | |
| CN112363814A (en) | Task scheduling method and device, computer equipment and storage medium | |
| CN116644213A (en) | XML file reading method, device, equipment and storage medium | |
| CN113419738A (en) | Interface document generation method and device and interface management equipment | |
| CN113032256A (en) | Automatic test method, device, computer system and readable storage medium | |
| CN110764745B (en) | Variable transmission and collection method, device and computer readable storage medium | |
| CN117931219A (en) | Front-end project implementation method and device, electronic equipment and storage medium | |
| CN113656044B (en) | Android installation package compression method and device, computer equipment and storage medium | |
| CN115509913A (en) | Software automation test method, device, machine readable medium and equipment | |
| CN116775034A (en) | Method, device and equipment for constructing kernel observation program | |
| CN111694729B (en) | Application testing method, device, electronic equipment and computer readable medium | |
| CN114328214B (en) | Efficiency improving method and device for interface test case of reporting software and computer equipment | |
| CN115878460A (en) | Regression testing method, device, computer equipment and storage medium | |
| CN117827624A (en) | Function test method, device 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 | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |