CN111523290B - Code conversion method, equipment and storage medium - Google Patents
Code conversion method, equipment and storage medium Download PDFInfo
- Publication number
- CN111523290B CN111523290B CN202010273897.0A CN202010273897A CN111523290B CN 111523290 B CN111523290 B CN 111523290B CN 202010273897 A CN202010273897 A CN 202010273897A CN 111523290 B CN111523290 B CN 111523290B
- Authority
- CN
- China
- Prior art keywords
- node
- text
- code
- generate
- generating
- 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.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 28
- 238000006243 chemical reaction Methods 0.000 title description 4
- 238000007373 indentation Methods 0.000 claims abstract description 7
- 230000014509 gene expression Effects 0.000 claims description 12
- 238000004590 computer program Methods 0.000 claims description 8
- 238000010586 diagram Methods 0.000 description 8
- 230000006870 function Effects 0.000 description 5
- 238000004891 communication Methods 0.000 description 4
- 238000005516 engineering process Methods 0.000 description 2
- 230000007812 deficiency Effects 0.000 description 1
- 238000001914 filtration Methods 0.000 description 1
- 239000004973 liquid crystal related substance Substances 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000011218 segmentation Effects 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/10—Text processing
- G06F40/12—Use of codes for handling textual entities
- G06F40/151—Transformation
- G06F40/154—Tree transformation for tree-structured or markup documents, e.g. XSLT, XSL-FO or stylesheets
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/90—Details of database functions independent of the retrieved data types
- G06F16/903—Querying
- G06F16/90335—Query processing
- G06F16/90344—Query processing by using string matching techniques
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computational Linguistics (AREA)
- Databases & Information Systems (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Data Mining & Analysis (AREA)
- Health & Medical Sciences (AREA)
- Artificial Intelligence (AREA)
- Audiology, Speech & Language Pathology (AREA)
- General Health & Medical Sciences (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
- Document Processing Apparatus (AREA)
Abstract
The application provides a transcoding method, a device and a storage medium, comprising the following steps: deleting all codes beginning with double-slash "///" in the first source code and ending with line feed, and generating a first text; deleting all space characters in the first text to generate a second text; judging whether the number of left and right curly brackets in the first text is equal or not: if yes, traversing the second text sequentially, and executing corresponding operation according to the matched pattern bracket type to generate a node tree; and generating a second code according to the set hierarchy and the indentation rule according to the node tree. According to the application, different operations are performed according to different patterns and brackets types so as to construct a node tree, and a second code is quickly and directly generated according to the node tree and the corresponding rule.
Description
Technical Field
The present application relates to the field of computer technologies, and in particular, to a transcoding method, device, and storage medium.
Background
In the front-end domain, when standard CSS is used, patterns are defined for multiple layers of nested elements, or nesting definition from outside to inside of the descendant selector is used, or class names or ids are added to the element for definition. Such writing is simple but inconvenient to maintain because CSS syntax is scattered and the hierarchy and association between styles cannot be clearly understood. A language such as Less was created that is a CSS preprocessor that would allow you to define styles using nested grammars. In Less, the nesting rules make CSS grammar decentralized, and the problem of unclear hierarchy is solved. The nesting rule allows one selector to be nested into another selector, so that simplified codes are easier to design, relations among patterns are clear at a glance, and corresponding relations between a Less level and an html level in corresponding html codes are clear, so that the codes can be positioned more quickly when being maintained and modified.
However, when writing CSS codes or pass codes, corresponding html codes are also required to be written manually, and corresponding html codes can be automatically generated by utilizing the code rules of the pass, so that the workload is reduced. There is currently no way to convert the Less code into the corresponding html code.
Disclosure of Invention
In view of the foregoing drawbacks or deficiencies of the prior art, it is desirable to provide a simple and efficient transcoding method, apparatus and storage medium.
In a first aspect, the present application provides a transcoding method comprising:
deleting all codes beginning with double-slash "///" in the first source code and ending with line feed, and generating a first text;
deleting all space characters in the first text to generate a second text;
judging whether the number of left and right curly brackets in the first text is equal or not:
if yes, traversing the second text sequentially, and executing corresponding operation according to the matched pattern bracket type to generate a node tree;
and generating a second code according to the set hierarchy and the indentation rule according to the node tree.
Further, deleting all codes beginning with double-slash "///" in the first source code and ending with line feed and generating a first text, including:
identifying the beginning of all double diagonal strokes "///" in the first source code through a first regular expression///////, deleting codes at the end of line feed, and generating a first text; wherein, the/representation matches a left slash; representing an arbitrary character; * Representing the number of matches, 0 or n, i.e. representing any character matching an indefinite number; n represents the line feed character, i.e. the end of a line.
Further, deleting all space characters in the first text to generate a second text, including:
identifying the hollow lattice characters in the first text through a second regular expression/\s+/and deleting the hollow lattice characters to generate a second text; wherein s represents matching a space character; + represents the number of matches, one or more times, s+ represents matching consecutive spaces of arbitrary length.
Further, performing a corresponding operation according to the matched curly brace type to generate a node tree, including:
configuring a root node to be pressed into the bottom of the trestle; the root node comprises a node type, a node name, a node value and a child node list;
judging the matched curly brace type:
if the type is a left curly brace, generating a first node and pushing the first node into a stack;
if the type is a right curly brace, pushing out the current node in the stack to serve as a child node of the next node, and putting the current node into a child node list of the next node;
the second text is traversed until all curly brackets have been traversed.
Further, generating a second code according to the node tree according to the set hierarchy and the set retraction rule, including:
acquiring information of a root node of a node tree, and creating an html father tag according to the node type, the node name and the node value;
generating a plurality of corresponding html child tags according to the information of a plurality of child nodes of the child node list, and sequentially placing the html child tags in a parent tag;
and filling the tags of each html according to the set indentation rule according to each hierarchy to generate a second code, namely an html code.
Further, the first source code is a pass code and/or a pass code.
In a second aspect, the present application also provides an apparatus comprising one or more processors and a memory, wherein the memory contains instructions executable by the one or more processors to cause the one or more processors to perform a transcoding method provided in accordance with embodiments of the present application.
In a third aspect, the present application also provides a storage medium storing a computer program that causes a computer to execute the transcoding method provided according to the embodiments of the present application.
According to the code conversion method, the code conversion device and the storage medium provided by the embodiments of the application, after the first source code is converted into the code text without space characters, different operations are performed according to different curly brace types so as to construct a node tree, and the second code is quickly and directly generated according to the corresponding rules by the node tree.
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 is a flowchart of a transcoding method according to an embodiment of the present application.
FIG. 2 is a diagram of a node tree structure generated by a preferred embodiment of FIG. 1.
Fig. 3 is a schematic diagram of a scenario of step 13 in a preferred embodiment of the method shown in fig. 1.
Fig. 4 is a schematic structural diagram of an apparatus according to an embodiment of the present application.
Detailed Description
The application is described in further detail below with reference to the drawings and examples. It is to be understood that the specific embodiments described herein are merely illustrative of the application and are not limiting of the application. It should be noted that, for convenience of description, only the portions related to the application are shown in the drawings.
It should be noted that, without conflict, the embodiments of the present application and features of the embodiments may be combined with each other. The application will be described in detail below with reference to the drawings in connection with embodiments.
Fig. 1 is a flowchart of a transcoding method according to an embodiment of the present application.
As shown in fig. 1, in this embodiment, the present application provides a transcoding method, including:
s11, deleting all codes beginning with double diagonal strokes "//" in the first source code and ending with line feed, and generating a first text;
s12, deleting all space characters in the first text to generate a second text;
s13, judging whether the number of left and right brackets in the first text is equal or not:
if yes, traversing the second text sequentially, and executing corresponding operation according to the matched pattern bracket type to generate a node tree;
s14, generating a second code according to the set hierarchy and the indentation rule according to the node tree. Specifically, take the following less source code as an example:
deleting all codes beginning with double-slash "///" in the first source code and ending with line feed, and generating a first text; the following are provided:
deleting all space characters in the first text to generate a second text; the following are provided: common-select-write { position: relative; common-select-search { cursor: pointer; font-size 16px; position: absolute; top 50%; margin-top, -8px; }. common-select { cursor: initial; p { height:32px; line-height 31px; a font-size of 14px; }}
As shown in the second text, the number of left curly brackets (4) is consistent with the number of right curly brackets (4), and then the second text is traversed sequentially, and corresponding operations are executed according to the matched curly bracket types to generate a node tree, as shown in fig. 2.
And finally, generating a second code according to the set hierarchy and the retraction rule according to the node tree, namely:
it should be noted that, the first language code in the method is suitable for most program languages, such as JavaScript, less, css, scs, etc., according to the attribute of specific languages, so that some languages cannot well realize the required functions after being converted into html language, and the method is a better choice for less languages and Scss languages.
Further preferably, deleting all codes beginning with double-slash "//" in the first source code and ending with line feed and generating the first text includes:
identifying codes beginning with double slashes "///" and ending with line feed in the first source code through a first regular expression///////and deleting to generate a first text; wherein, the/representation matches a left slash; representing an arbitrary character; * Representing the number of matches, 0 or n, i.e. representing any character matching an indefinite number; n represents the line feed character, i.e. the end of a line.
And matching all codes beginning with double-slash "//" in the first source code through the first regular expression, and replacing codes at the end of line feed to generate the first text.
Further preferably, in step S11, deleting all space characters in the first text to generate the second text includes:
identifying the hollow lattice characters in the first text through a second regular expression/\s+/and deleting the hollow lattice characters to generate a second text; wherein s represents matching a space character; + represents the number of matches, one or more times, s+ represents the matching of consecutive spaces of arbitrary length. And generating a second text without space characters through the regular expression, and preparing for subsequent matching judgment.
In further embodiments, performing a corresponding operation according to the matched curly brace type in step S13 to generate a node tree includes:
s131, configuring a node to be pressed into the stack bottom; the root node comprises a node type, a node name, a node value and a child node list;
s132, judging the matched curly brace type:
if the type is a left curly brace, generating a first node and pushing the first node into a stack;
if the type is a right curly brace, pushing out the current node in the stack to serve as a child node of the next node, and putting the current node into a child node list of the next node;
the second text is traversed until all curly brackets have been traversed.
Specifically, taking the above second text as an example, first, a root node is configured, for example:
type:'id',
value:'root',
nodeName:'div',
child:[]
the root node information may include: node type, node name nodeName, node value, child node list child [ ], and pushing the object node to the stack.
In a preferred embodiment of the present application,
the judgment basis of the node type can be the following: 1. if the matched text starts with a "-" character, the node type is a default configuration item obtained from the environment (the configuration item is typically set to class or className); 2. if the matched text starts with the "#" character, the node type is id;3. if the matched text starts with the beginning, setting the node type as reverse;4. if none of the above rules apply, the node type is set to tag).
The configuration method of the node value comprises the following steps: the content before the left curly brace that is matched and the # & character is removed, e.g., to common-select-wrap {, then the node value is common-select-wrap).
The node name configuration method comprises the following steps: 1. judging whether the node type is tag or not, if so, judging that the node value is the content before a left curly brace, for example, p {, and judging that the node name is p;2. if the node type is not tag, then the node name is the default configuration item (typically set to div) obtained from the environment) matches the right curly brace using regular expressions.
As shown in fig. 3, the first curly brace traversing the second text is a left curly brace, at this time, a node a is generated and pushed onto the stack, the second text is continuously traversed, the next curly brace matched is still a left curly brace, and a node B is generated and pushed onto the stack; and continuously traversing the second text, wherein the next matched curly brace is a right curly brace, at the moment, pushing the node B out of the stack, after pushing the node B out of the stack, the latest node is the node A, adding the node B into a child node list of the node A, continuously traversing the second text, generating a node C when the next matched curly brace is still a left curly brace, pushing a stack … … until the last matched curly brace is the right curly brace, adding the node A (child nodes are B, C and D) into the child node list of the root node root, and finally generating the node tree shown in fig. 2.
In a preferred embodiment, the matched expression is:
"(# - \w: () @, [ { ]) | (& gt: wherein the regular expression has four branching conditions, each using a () wrap, and using |segmentation
1. [. # ] represents a match once;
[ - \w () @ ] + represents matching one or more times \w, (,), @, character
[ { ] stands for matched once {
2. The & representation starts with the & character,
is? Representing as few matching arbitrary characters as possible
[ { ] stands for matched once {
3. The [ a-z ] + identifier matches one or more arbitrary lowercase letters
[ { ] stands for matched once {
4. { represents matching once {
In further embodiments, the generating the second code according to the node tree in the step S14 according to the set hierarchy and the retraction rule includes:
s141, acquiring information of a root node of a node tree, and creating an html father tag according to the node type, the node name and the node value;
s142, generating a plurality of corresponding htmlL child tags according to the information of a plurality of child nodes of the child node list, and sequentially placing the htmlL child tags in a parent tag;
s143, filling the tags of each html according to the set indentation rule according to each hierarchy, and generating a second code, namely an html code.
Specifically, after the filtering node type is reverse, the tree is traversed in a recursion mode, each node generates an html node, then each node generates corresponding indents according to corresponding levels, the recursion traversal refers to traversing all sub-nodes of one node in a traversal mode, if the sub-nodes are still sub-nodes, the sub-nodes of the sub-nodes are traversed again until the sub-nodes are empty. The generation rule is as follows
1.`\n${″.repeat(level*4)}<${nodeName}${type！＝＝'tag'？`${type}＝'${value}'`:″}>\n${″.repeat(level*6)}\n${″.repeat(level*4)}</${nodeName}>`；
Wherein:
repeat (level 4) } means that a line feed is inserted before each line, then a space 4 times of the corresponding level is inserted, level is the level in the recursive traversal, and the number of spaces is 4 more for every one level;
2. the following rules generate a start tag for a node, the placeholder variable for $ { nodeName } would be replaced by a variable in the node;
<${nodeName}${type！＝＝'tag'？`${type}＝'${value}'`:″}>
note that $ { type-! = = 'tag'? The expression = '$ { type } = $ { value': ") means that if the node type is tag, nothing in the tag is filled, and if the node type is not tag, the node type = node value is filled in the tag;
taking the following nodes as examples, the above rule is applied:
the result is
<div class＝'common-select-search'>
Taking the following nodes as examples, apply the above rule,
generating a result
<p>
3. The following rules indicate that the corresponding level is filled with line feed first, then 6 times blank space is filled, line feed is filled, and 4 times blank space is filled
\n${″.repeat(level*6)}\n${″.repeat(level*4)}
4. The following rules generate end labels for nodes
</${nodeName}>`；
Generating html for each node according to the rule, the following result is obtained:
fig. 4 is a schematic structural diagram of an apparatus according to an embodiment of the present application.
As shown in fig. 4, as another aspect, the present application also provides an apparatus 400 including one or more Central Processing Units (CPUs) 401, which can perform various appropriate actions and processes according to a program stored in a Read Only Memory (ROM) 402 or a program loaded from a storage section 408 into a Random Access Memory (RAM) 403. In the RAM403, various programs and data required for the operation of the device 400 are also stored. The CPU401, ROM402, and RAM403 are connected to each other by a bus 404. An input/output (I/O) interface 405 is also connected to bus 404.
The following components are connected to the I/O interface 405: an input section 406 including a keyboard, a mouse, and the like; an output portion 407 including a Cathode Ray Tube (CRT), a Liquid Crystal Display (LCD), and the like, and a speaker, and the like; a storage section 408 including a hard disk or the like; and a communication section 409 including a network interface card such as a LAN card, a modem, or the like. The communication section 409 performs communication processing via a network such as the internet. The drive 410 is also connected to the I/O interface 405 as needed. A removable medium 411 such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, or the like is installed on the drive 410 as needed, so that a computer program read therefrom is installed into the storage section 408 as needed.
In particular, according to embodiments of the present disclosure, the transcoding method described in any of the above embodiments may be implemented as a computer software program. For example, embodiments of the present disclosure include a computer program product comprising a computer program tangibly embodied on a machine-readable medium, the computer program comprising program code for performing a transcoding method. In such an embodiment, the computer program may be downloaded and installed from a network via the communication portion 409 and/or installed from the removable medium 411.
As still another aspect, the present application also provides a computer-readable storage medium, which may be a computer-readable storage medium contained in the apparatus of the above-described embodiment; or may be a computer-readable storage medium, alone, that is not assembled into a device. The computer-readable storage medium stores one or more programs for use by one or more processors in performing the transcoding method described in the present application.
The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present application. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
The units or modules involved in the embodiments of the present application may be implemented in software or in hardware. The described units or modules may also be provided in a processor, for example, each of the units may be a software program provided in a computer or a mobile smart device, or may be separately configured hardware devices. Wherein the names of the units or modules do not in some cases constitute a limitation of the units or modules themselves.
The above description is only illustrative of the preferred embodiments of the present application and of the principles of the technology employed. It will be appreciated by persons skilled in the art that the scope of the application referred to in the present application is not limited to the specific combinations of the technical features described above, but also covers other technical features formed by any combination of the technical features described above or their equivalents without departing from the spirit of the application. Such as the above-mentioned features and the technical features disclosed in the present application (but not limited to) having similar functions are replaced with each other.
Claims (6)
1. A method of transcoding comprising
Deleting all codes beginning with double-slash "///" in the first source code and ending with line feed, and generating a first text; the first source code is a pass code and/or a pass code;
deleting all space characters in the first text to generate a second text;
judging whether the number of left and right curly brackets in the first text is equal or not:
if so, traversing the second text sequentially, and executing corresponding operations according to the matched curly brace type to generate a node tree, wherein executing corresponding operations according to the matched curly brace type to generate the node tree comprises: configuring a root node to be pressed into the bottom of the trestle; the root node comprises a node type, a node name, a node value and a child node list;
judging the matched curly brace type:
if the type is a left curly brace, generating a first node and pushing the first node into a stack;
if the type is a right curly brace, pushing out the current node in the stack to serve as a child node of the next node, and putting the current node into a child node list of the next node;
traversing the second text until all the curly brackets are traversed;
generating a second code according to the node tree according to the set hierarchy and the set retraction rule, wherein the second code is an html code.
2. The method of claim 1, wherein deleting all codes beginning with double-slash "///" in the first source code ending with a line feed and generating the first text comprises:
identifying the beginning of all double diagonal strokes "///" in the first source code through a first regular expression///////, and deleting codes at the end of line feed to generate a first text; wherein, the/representation matches a left slash; representing an arbitrary character; * Representing the number of matches, 0 or n, i.e. representing any character matching an indefinite number; n represents the line feed character, i.e. the end of a line.
3. The method of claim 2, wherein deleting all space characters in the first text to generate a second text comprises:
identifying the hollow lattice characters in the first text through a second regular expression/\s+/and deleting the hollow lattice characters to generate a second text; wherein s represents matching a space character; + represents the number of matches, one or more times, s+ represents the matching of consecutive spaces of arbitrary length.
4. The method of claim 1, wherein generating a second code according to the node tree according to a set hierarchy, indentation rule, comprises:
acquiring information of a root node of a node tree, and creating an html father tag according to the node type, the node name and the node value;
generating a plurality of corresponding html child tags according to the information of a plurality of child nodes of the child node list, and sequentially placing the html child tags in a parent tag;
and filling the tags of each html according to the set indentation rule according to each hierarchy to generate a second code, namely an html code.
5. An apparatus, the apparatus comprising:
one or more processors;
a memory for storing one or more programs,
the one or more programs, when executed by the one or more processors, cause the one or more processors to perform the method of any of claims 1-4.
6. A storage medium storing a computer program, characterized in that the program, when executed by a processor, implements the method according to any one of claims 1-4.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010273897.0A CN111523290B (en) | 2020-04-09 | 2020-04-09 | Code conversion method, equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010273897.0A CN111523290B (en) | 2020-04-09 | 2020-04-09 | Code conversion method, equipment and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111523290A CN111523290A (en) | 2020-08-11 |
| CN111523290B true CN111523290B (en) | 2023-11-14 |
Family
ID=71902515
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010273897.0A Active CN111523290B (en) | 2020-04-09 | 2020-04-09 | Code conversion method, equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111523290B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113791768B (en) * | 2021-09-22 | 2023-04-14 | 海通证券股份有限公司 | Code generation method and device, storage medium and terminal |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| AU2006264207A1 (en) * | 2005-06-27 | 2007-01-04 | Csc Technology Singapore Pte Ltd | Code transformation |
| CN103324731A (en) * | 2013-06-28 | 2013-09-25 | 中国农业银行股份有限公司 | Method and device for converting spreadsheet file into web format file |
| CN103970750A (en) * | 2013-01-25 | 2014-08-06 | 腾讯科技（深圳）有限公司 | Method and device for generating HTML (Hypertext Markup Language) web pages |
| US10169451B1 (en) * | 2018-04-20 | 2019-01-01 | International Business Machines Corporation | Rapid character substring searching |
| CN110705214A (en) * | 2019-08-27 | 2020-01-17 | 天津开心生活科技有限公司 | Automatic coding method and device |
| CN110765740A (en) * | 2019-10-11 | 2020-02-07 | 深圳市比一比网络科技有限公司 | DOM tree-based full-type text replacement method, system, device and storage medium |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8365147B2 (en) * | 2008-02-27 | 2013-01-29 | Accenture Global Services Limited | Test script transformation architecture |
-
2020
- 2020-04-09 CN CN202010273897.0A patent/CN111523290B/en active Active
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| AU2006264207A1 (en) * | 2005-06-27 | 2007-01-04 | Csc Technology Singapore Pte Ltd | Code transformation |
| CN103970750A (en) * | 2013-01-25 | 2014-08-06 | 腾讯科技（深圳）有限公司 | Method and device for generating HTML (Hypertext Markup Language) web pages |
| CN103324731A (en) * | 2013-06-28 | 2013-09-25 | 中国农业银行股份有限公司 | Method and device for converting spreadsheet file into web format file |
| US10169451B1 (en) * | 2018-04-20 | 2019-01-01 | International Business Machines Corporation | Rapid character substring searching |
| CN110705214A (en) * | 2019-08-27 | 2020-01-17 | 天津开心生活科技有限公司 | Automatic coding method and device |
| CN110765740A (en) * | 2019-10-11 | 2020-02-07 | 深圳市比一比网络科技有限公司 | DOM tree-based full-type text replacement method, system, device and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111523290A (en) | 2020-08-11 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US7237192B1 (en) | Methods and systems for naming and indexing children in a hierarchical nodal structure | |
| CN108415702B (en) | Dynamic rendering method and device for application interface of mobile terminal | |
| US8286132B2 (en) | Comparing and merging structured documents syntactically and semantically | |
| CN113051285B (en) | SQL sentence conversion method, system, equipment and storage medium | |
| US20040239674A1 (en) | Modeling graphs as XML information sets and describing graphs with XML schema | |
| US20100306207A1 (en) | Method and system for transforming xml data to rdf data | |
| US20030074636A1 (en) | Enabling easy generation of XML documents from XML specifications | |
| JPWO2005119516A1 (en) | Array generation method, information processing apparatus, and program | |
| US20070006179A1 (en) | Methods and systems for transforming a parse graph into an and/or command tree | |
| CA2501608A1 (en) | System and method for schemaless data mapping with nested tables | |
| CN108170435A (en) | A kind of source code conversion method, device and equipment | |
| CN106886398B (en) | Method and equipment for extracting cascading style sheet | |
| CN107239492A (en) | XML document is converted to the method and device that object, object are converted to XML document | |
| EP1828941B1 (en) | Device for processing formally defined data | |
| CN111523290B (en) | Code conversion method, equipment and storage medium | |
| CN103092973B (en) | information extraction method and device | |
| US9886424B2 (en) | Web application framework for extracting content | |
| CN111273903B (en) | Webpage making method and device, computer equipment and computer storage medium | |
| CN112883242A (en) | Tree-shaped machine learning model visualization method and device, electronic equipment and storage medium | |
| CN117008918A (en) | Domain-specific language processing method, device, medium and electronic equipment | |
| US20210397663A1 (en) | Data reduction in a tree data structure for a wireframe | |
| CN110019969B (en) | Method and system for processing semi-structured data | |
| US20150067475A1 (en) | Web Application Framework | |
| Kwietniewski et al. | Transforming XML documents as schemas evolve | |
| CN111061927A (en) | Data processing method and device and electronic equipment |
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 |