JP2001125855A - Dynamic web page generation program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a dynamic Web page generation program that a program work can be separated from a design work in the developing stage of a dynamic Web page in order to improve the efficiency and quality of the developing and maintaining work of the dynamic Web page. SOLUTION: A CGI program 7 and an HTML template 8 that a common replacement identifier is added to dynamic changing parts are prepared. At the time of generating a dynamic Web page, a dynamic Web page generation program 9 generates dynamic Web page by replacing the contents of the dynamic changing part of the HTML template 8 with contents decided by the CGI program 7 by using the displacement identifier.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a dynamic Web system including a dynamic changing unit whose display content changes according to an input operation of an operator.
A dynamic Web page generation program for generating pages.

[0002]

2. Description of the Related Art In recent years, with the rapid spread of the Internet, information transmission, distribution, and collection using electronic mails and homepages (Web pages) have been actively performed. Regarding web pages, a wide variety of web pages are established and their functions are also various, but in general, the functions can be broadly classified into static web pages and dynamic web pages.

[0003] A static Web page is a fixed page in which the content of information to be provided to a viewer (hereinafter, referred to as an operator) is prepared in advance, and is created using HTML (Hyper Text Markup L).
Anguage) and other markup languages make it relatively easy. On the other hand, a dynamic Web page is a portion where the content of information to be provided (displayed) changes in real time in accordance with an operator's customized input data (custom data) (hereinafter, referred to as a dynamic change portion). ) And requires some programming work to create it.

FIG. 9 is a diagram showing an example of a conventional system configuration for distributing a static Web page and a processing flow thereof. The general processing flow is as follows. First, on the client system 2 such as a personal computer at the site of the operator 1, an instruction to display a web page that the operator 1 wants to browse is issued by using the browser 3 (FIG. 9). The browser 3 transmits a Web page transmission request instructed via the Internet to the Web server program 5 of the server system 4 (FIG. 9). Received transmission request
Web server program 5 corresponds to the requested Web page
The HTML document 11 (for example, a in the figure) is searched (FIG. 9) and sent back to the browser 3 (FIG. 9). Browser 3 sends the sent HTML document a
Is interpreted and displayed as a Web page on the screen of the client system 2 (FIG. 9).

As described above, when distributing a static Web page, the page to be distributed is prepared in advance as a document (file) described in a markup language such as HTML (a, b, c,...), and they are merely replaced by the instruction of the operator 1. Therefore, the Web
The only page creation (development) operation is to create a document in a markup language such as HTML, but does not have the function of performing the above-described interactive processing.

[0006] Therefore, in order to enable interactive processing on a Web page and provide more flexible information, the aforementioned dynamic Web page has been desired. Conventionally, two methods have been mainly used as a method of generating and distributing this dynamic Web page on the server system side. One such method is to use a CGI program. CGI programs are CGs, which are interfaces provided for Web server programs to communicate with other applications.
It is an application program that executes an interactive process for an operator's request via I (Common Gateway Interface) and generates a dynamic Web page.

FIG. 10 is a diagram showing an example of a system configuration when a conventional CGI program is used and a processing flow thereof. First, when an interactive processing request (input of custom data) is received from the operator 1 (input of custom data) (FIG. 10), the request is transmitted from the browser 3 to the CGI program 7 via the Web server program 5 and the interface (CGI) 6. Conveyed (Figure 10 and).

[0008] When the request is transmitted, the CGI program 7 executes a process according to the custom data input by the operator 1 and determines the display contents (hereinafter, referred to as display values) of the dynamic change unit. For example, in response to a processing request from the operator 1, necessary information is stored in an externally located database 1.
Processing such as searching from 0 is performed (FIG. 10).
Further, the CGI program 7 generates a return HTML document 11 (for example, a1 in the figure) in which the determined display value is inserted into the dynamic change part, and returns it to the Web server program 5 as a response to the request. (Of FIG. 10). The return HTML document a1 is returned to the client system 2 and displayed on the browser 3 (FIG. 10).
And).

As described above, a single CGI program 7 generates a plurality of HTML documents 11 (a1, a2,... In the figure) having different display values of the dynamically changing parts for various input custom data. It is possible to realize a dynamic Web page. As shown in FIG. 10, the development of a dynamic Web page by this method involves programming a CGI program 7 including both a processing part for determining a display value of a dynamic change part and a design generation part d of an HTML document. Work.

FIG. 11 is a diagram showing a configuration example and a processing flow when a server-side script, which is another method often used for generating a dynamic Web page, is used. In this method, an HTML template (A, B,...) In which a processing program (server-side script) for determining a display value is inserted in a dynamically changing portion of an HTML document to be displayed is prepared, and an operator 1 When a request is received, the processing program is executed, and the display value after processing is embedded in the inserted position (dynamic change part) to generate a return HTML document.

As in the case of FIG. 10, first, the Web server program 5 receives the request from the operator 1 via the browser 3 (and in FIG. 11), and
To the dynamic Web page generation program 9 provided in the server. The dynamic Web page generation program 9 executes a processing program embedded in a dynamic change section of the corresponding HTML template 8 (for example, A in the figure). For example, processing such as searching for predetermined data from the database 10 is executed (FIG. 11). Dynamic Web page generation program 9
In the HTML template A, the response HTML document 11 (for example, a1 in the figure) is inserted by inserting a display value obtained as a processing result into the dynamic change part in which the processing program has been inserted. Generated and returned to Web server program 5 (FIG. 11). Hereinafter, FIG.
As in the case of (1), the return HTML document a1 is returned and displayed on the browser 3 (and in FIG. 11).

As described above, according to the custom data of the operator, a plurality of HTML documents (such as a1 and a2 in the figure) having different values of the dynamically changing part from one HTML template (A in the figure) Can be generated, realizing a dynamic Web page. The task of developing a dynamic Web page in this method is to create the above-described HTML template, which is a task of performing programming in a dynamically changing part in an HTML document. In other words, as shown in the lower part of FIG. 11, an HTML document (A, B,...) Including the program p is created.

As described above, in the conventional dynamic Web page, one of the above-described methods is generally used.

[0014]

However, in any of the conventional methods described above, an object to be created at the stage of developing a dynamic Web page includes a program section for executing a dynamic change, and a Web page. There is a problem that a so-called design generation unit that defines a configuration and a static part is mixed. As described above, in the method using the CGI program shown in FIG. 10, it is necessary to create a CGI program in which the design generation unit (part d in FIG. 10) is inserted into the program unit. In the case of using a server-side script, a program part (p in FIG. 11) is included in an HTML document as a design generation part.
Part) was required to create an HTML template.

Usually, when such a dynamic Web page is developed, a program section and a design section are often created by division of work by a programmer and a designer. Therefore, as described above, it is not preferable that the creation target is composed of one program or document, and the program part and the design part are mixed in terms of both creation efficiency and finished quality. For example, when using a CGI program, the designer cannot check the design section until the entire program is completed,
If there is a change in the design department, it is inefficient that the programmer must change the program. Furthermore, there is a risk that a change in only the design section affects the entire program, and there is a quality problem. This situation is the same when maintaining the completed Web page.

Therefore, an object of the present invention is to separate the program work and the design work in the development stage of the dynamic Web page in order to improve the efficiency and quality of the development and maintenance work of the dynamic Web page. To provide a dynamic Web page generation program.

[0017]

In order to achieve the above object, one aspect of the present invention is to provide a CGI program using a common replacement identifier for a dynamic change part and a template described in a markup language. Are prepared separately, and dynamic We
In generating the b-page, a dynamic Web page is generated by replacing the content of the dynamic change part of the template with the content determined by the CGI program using the replacement identifier. Therefore, according to the present invention, in the development stage of a dynamic Web page, a programming operation for creating a CGI program for determining the contents of the dynamic change portion and a design operation for creating a template for defining the structure of the dynamic Web page And can be separated.

In order to achieve the above object, another aspect of the present invention provides a dynamic Web page having a dynamic change section whose display content changes in response to an input operation by an operator. A storage medium storing a dynamic Web page generation program for determining display contents by a CGI program, wherein a configuration of the dynamic Web page is described in a markup language, and the dynamic change unit is embedded in the CGI program. For a template created in advance, to which the same replacement identifier is assigned, the content of the dynamic change unit in the template is determined by the CGI program based on the replacement identifier. Causing the computer to execute a step of generating a document described in a markup language of the dynamic Web page for a reply by replacing the display content of the dynamic change section with the display content of the dynamic change section And it features.

In a preferred aspect of the present invention, the replacement identifier attached to the dynamic change portion of the template is described in a tag of the dynamic change portion.

Further, in the above invention, another aspect is as follows.
Having a function of determining the display content of the dynamic change unit, and causing a computer to execute a program module group registered in advance as a library based on an instruction of the CGI program when the dynamic Web page is generated. It is characterized by.

In order to achieve the above object, still another aspect of the present invention relates to a method for generating a dynamic Web page having a dynamic change section whose display content changes according to an input operation of an operator. A first step of determining display contents of the dynamic change unit according to the input operation of the operator by the created CGI program; and a configuration of the dynamic Web page is described in a markup language, and the dynamic In the dynamic change unit, the content of the dynamic change unit of a pre-created template to which the same replacement identifier as the replacement identifier embedded in the CGI program is attached, based on the replacement identifier, the first step Replacing the display content with the display content determined in step 2 to generate a document described in the markup language of the dynamic web page for reply.

In a preferred aspect of the present invention, the determination of the display content of the dynamic change unit in the first step is based on an instruction of the CGI program.
This is performed by calling and executing a program module group that has been developed in advance and registered as a library to determine the display content of the dynamic change unit.

In order to achieve the above object, still another aspect of the present invention is a method for developing a dynamic Web page having a dynamic change section whose display content changes according to an input operation of an operator. Programming a CGI program to determine the display content of the dynamic change unit according to the input operation of the operator, and the CGI program is a separate template, defining the configuration of the dynamic Web page,
The dynamic change unit includes a step of describing, in a markup language, a template to which the same replacement identifier as the replacement identifier embedded in the CGI program is attached.

Further, in the above-mentioned invention, in a preferred aspect, the step of programming the CGI program is a program module group which is developed for determining display contents of the dynamic change unit and is registered in advance as a library. It is characterized by being performed using

Further objects and features of the present invention will become apparent from the embodiments of the present invention described below.

[0026]

Embodiments of the present invention will be described below with reference to the drawings. However, such embodiments do not limit the technical scope of the present invention.
In the drawings, the same or similar components are denoted by the same reference numerals or reference symbols.

FIG. 1 is a diagram showing an embodiment of a dynamic Web page distribution system using a dynamic Web page generation program to which the present invention is applied. The dynamic Web page generation program 9 in this embodiment is mainly a Web
An HTML template 8 that defines the page design and has a common replacement identifier embedded in the dynamic change part, and generates the change content of the dynamic change part mainly without the design part, and uses the common replacement identifier to generate the HTML. A dynamic Web page corresponding to the request of the operator 1 is generated from the CGI program 7 linked to the template 8.

FIG. 2 is a diagram showing a processing flow of the embodiment shown in FIG. FIGS. 3 to 6 are diagrams related to an example of a dynamic Web page distributed using the present embodiment. The examples shown in FIGS. 3 to 6 show the usage details (charged amount) of the utility for the operator in accordance with the instruction of the operator. Specifically, for the identification number of the operator (custom data) and the like, the data corresponding to the operator is searched from the data of the billing amount stored in the database, We
This is an example of a simple dynamic Web page in which the data is displayed and returned in the amount display section (dynamic change section) X on page b. FIG.
Represents an initial screen (Web page) designed by the template 8, and an X part in the figure is a dynamic change part. On the initial screen of the template designed by the designer, a dummy value (x0 in the figure) is displayed in the dynamic change part X. FIG. 4 is an example of a web page that is dynamically customized and responded to the operator's instruction, and the display value of the dynamically changing part X changes to a value retrieved from the database (x1 in the figure). are doing.

Hereinafter, the contents of each part at the time of development and generation of the dynamic Web page according to the present embodiment will be described with reference to FIGS.

First, at the time of development, the CGI shown in FIG.
A program 7 and an HTML template 8 are created in advance. CG
The I program 7 is connected via the interface (CGI) 6
Although it is the same as that described in the related art in cooperating with the Web server program 5, there is a difference in the programmed contents. The CGI program 7 in the case of the present embodiment is mainly composed of a function of giving an instruction to a dynamic Web page generation program 9 to be described later and a function of determining a display value of a dynamic change unit. It does not include the aforementioned so-called design generation unit. Further, the same replacement identifier as the HTML template 8 described below is used as a name that substitutes the display value of the dynamic change unit.

FIG. 5 shows a CGI program 7 created for the usage statement page, and shows an example described in Perl language. The program code shown in (b) in the figure is a part for extracting the corresponding amount data from the database, and is a program part having a function of determining the display value of the dynamic change part. Also, "Charge shown in the y part of the figure
List "is a replacement identifier that substitutes for the display value of the dynamically changing part (the X part in FIG. 3). Therefore, in the example of FIG. 5, the identification number given by the operator 1 by the program code of the part B Is extracted from the database 10 and the replacement identifier "Charg" is
The extraction result is passed to eList ".

On the other hand, the HTML template 8 created at the time of development is a normal HTML document that defines the design of a dynamic Web page. It is characterized in that the above-mentioned replacement identifier is added as a name attribute using a so-called meaningless tag other than the standard tag, and dummy data is inserted.

FIG. 6 shows an example of the HTML template 8 created for the usage statement page. As shown in the figure, here, the standardized tags such as <HEAD>, <BODY>, and <p> that define the structure (design) of the Web page by making rules in HTML are used to display the Web shown in FIGS. The screen of the page is designed. X part is the dynamic change part, x
The 0 part is the dummy data, and the X part and the
Corresponds to x0 part. Also, as shown in the y section, the dynamic change section X uses the SPAN tag, which is a meaningless tag that does not affect the design of the web page, unlike the above-described standard tag, and is the same as the CGI program 7. Replacement identifier for "Charge
List "is embedded as a name attribute. As described above, the HTML template 8 defines the structure of the dynamic Web page and the static part, and it can be said that the whole has a design generation function. In this example, the SPAN tag is used for the dynamic change unit, but any other tag may be used as long as it is the above-mentioned meaningless tag.
A standard tag may be used as long as the attribute can be embedded.

As described above, in the present embodiment, the object created in the development stage is a so-called program unit linked by the same replacement identifier.
It is separated into a program 7 and an HTML template 8 which is a so-called design generation unit, which enables division of work between a programmer and a designer. By displaying the dummy data x0 in the HTML template 8, the designer can check the screen actually reproduced independently of the CGI program 7, and can pursue a satisfactory design. On the other hand, the programmer does not need to change the CGI program 7 even if the design is changed without worrying about the design of the Web page.

Next, a description will be given of the contents at the time of generating a dynamic Web page in this embodiment. At the time of generation, first, a request (custom data) is input by the operator 1 as shown in FIGS. 1 and 2 (S in FIG. 1 and FIG. 2).
1). In the above-described example of the usage statement page, the input of the identification number and the like by the operator 1 corresponds to this. Next, the request is transmitted to the CGI program 7 via the browser 3, the Web server program 5, and the interface (CGI) 6.
(S2 in FIGS. 1 and 2). Up to this point, the method is the same as the method using the CGI program described in the related art.

CGI program 7 that received the request
Instructs the dynamic Web page generation program 9 to read an HTML template 8 (for example, A in FIG. 1) defining a page design for responding to a request (FIG. 1).
And S3 in FIG. 2). In the example of the usage details page, in the CGI program 7 shown in FIG. 5, the program code of part A corresponds to this, and in this example, "Result.
html ". That is, the HTML template 8 shown in FIG. 6, which is displayed as shown in FIG. 3 when displayed on the screen, is read.

Next, the dynamic Web page generation program 9 reads the HTML template A according to the above-mentioned instruction (FIG. 1).
And S4 in FIG. 2 and execute the syntax interpretation (S5 in FIGS. 1 and 2). The syntax interpretation performed here is an operation for quickly detecting the position of the dynamic change unit to which the replacement identifier is added when replacing the value of the dynamic change unit described later.

After instructing the reading of the HTML template A, the CGI program 7 performs a process of determining a display value (a value to be replied to) of the dynamic change unit according to the request of the operator 1. The processing of the program section is executed in a sense as compared with a so-called design generation section. For example, external database 1
Processing such as extracting the corresponding data from the data stored in 0 according to the custom data of the operator 1 is performed. When the display value of the dynamic change part is determined as a result of the processing,
The dynamic change part of the HTML template A is replaced with the display value, and the HTML document 11 for reply (for example,
An instruction to generate 1) is issued to the dynamic Web page generation program 9. That is, assuming that the same replacement identifier value as the HTML template A attached to the dynamic change unit is the determined display value, an instruction is given to generate a return HTML document a1 (see FIGS. 1 and 2). S6).

In this example, in the example of the usage details page, the charge amount corresponding to the custom data such as the identification number input by the operator 1 is extracted from the database 10, and the charge amount data is stored in the value of the dynamic change unit. It corresponds to. In the CGI program 7 of FIG. 5, the program code in section B executes extraction of the corresponding amount data from the database 10, and the program code in section C extracts the value of the replacement identifier "ChargeList" of the dynamic change section. Replace with the value of the corresponding amount data (x1 in FIG. 4). And the program code of the second part is HTML template "Result.html"
Is a generation instructing unit of the return HTML document 11 in which the dynamic change unit ("ChargeList") of the is replaced with the corresponding amount data x1. The display contents (amount data) of the dynamic change part X are as follows.
As shown by x0 and x1 in FIG. 3 and FIG. 4, both the charge item and the amount are included, and the charge item itself may change depending on (the identification number of) the operator 1.

Next, in the dynamic Web page generation program 9, according to the above-mentioned instruction, the already read HT
In the ML template A, a place (dynamic change part X) to which the replacement identifier instructed to be replaced is attached is detected,
Replace the value from the original dummy data x0 with the display value x1 determined by the CGI program 7, and return the HTML document
a1 is generated (S7 in FIGS. 1 and 2). In the example of the usage statement page, the HTML template "Result.html" shown in FIG.
In, the replacement identifier "ChargeLis instructed to be replaced
The content of the dynamic change part X marked with "t" is the dummy data x
HTML for reply, replaced from 0 to display value (x1 in Fig. 4)
Document 11 is generated.

The generated response HTML document a1 is
As a response to the request of the operator 1, a reply is sent to the Web server program 5 in accordance with the instruction of the CGI program 7 (S8 in FIGS. 1 and 2). In the CGI program 7 in FIG. 7, the program code in the section E corresponds thereto. HTML document a1 uses the same interface (CG
I) It is sent to the client system 2 of the operator 1 via the Web server program 5 and the browser 3, and the dynamically changed web page of the response is displayed on the screen. (S9 in FIGS. 1 and 2). In the example of the usage details page, FIG. 4 is an example of the page returned as described above, and money amount data (x1 in the figure) according to the request of the operator 1 is displayed.

The above-described processing is executed every time a request is made from the operator 1, so that the value displayed in the dynamically changing portion of the page having the same design changes interactively. Dynamic web page is realized.

FIGS. 7 and 8 show examples of the CGI program and the HTML template when the above-mentioned usage details page is created by using the CGI program or the server-side script described in the related art, respectively. In the example of the CGI program shown in FIG. 7, a so-called design generation unit (part d in the figure) of a reply page is embedded in a program for extracting the corresponding amount data from the database. In the example of the HTML template shown in FIG. 8, on the contrary, a reply page is defined.
In the HTML document, a so-called program section (p section in the figure) for extracting the corresponding amount data from the database is embedded. Therefore, in either case,
It can be seen that the program part and the design generation part are mixed in the development object.

As described above, in the present embodiment, at the time of development, the CGI program 7 in which the replacement identifier is added to the dynamic change unit without including the design generation unit, and the CGI program without the program unit HTML template 8 with the same replacement identifier embedded in so-called meaningless tag 7
Is created. Then, at the time of generating a Web page, the dynamic Web page generation program 9 sets the value of the dynamic change part of the HTML template 8 based on the replacement identifier in the CGI format.
A dynamic Web page is realized by replacing the display value determined by the program 7 with the display value. Thus, in the present embodiment, unlike the conventional method, the dynamic Web
Because the development target of the page is separated into the program section and the design section, the programmer and the designer can be efficiently divided.

The function of the program for deciding the display contents of the dynamic change section included in the CGI program 7 is general-purpose, and is used for other dynamic Web pages (applications).
May be used frequently. In such a case, the part of the general-purpose program may be registered as a library 91 in the dynamic Web page generation program 9 so that the CGI program 7 can use the part when developing another application.

For example, when the function of extracting the charge data from the database on the usage statement page is frequently used in other applications, the code (program) of that part is transferred to the library of the dynamic Web page generation program 9. The program module 91 is registered as one program module. If you want to use that function when developing other applications,
Includes only a code for instructing the dynamic Web page generation program 9 to call and execute the program module. When a dynamic Web page is generated, the dynamic Web page generation program 9 calls the library-ized program module based on an instruction of the CGI program 7, and the program module is executed to display the dynamic change unit. Is determined. In this way, by diverting the registered program modules, it is not necessary to repeatedly perform programming for executing the same function.

In the above example of the usage details page, the code of the program module to be registered is short, but it has more complicated functions and if the amount of coding is large, it should be made into a library as described above so that it can be used. And dynamic web
The efficiency and quality of page development work can be further improved. As an example of a program module to be made into a library, one having a calendar function, a payment function, and the like,
It is considered versatile and useful.

In this embodiment, HTML is used as a markup language for defining a Web page, but another markup language may be used. Also, CGI
Although the display content of the dynamic change unit determined by the program 7 is expressed as a display value, the display content is not limited to numbers or characters, and may be, for example, an image. The protection scope of the present invention is not limited to the above embodiments, but extends to the inventions described in the claims and their equivalents.

[0049]

As described above, according to the present invention, a CGI program for determining the display content of a dynamically changing portion on a Web page and a template described in a markup language for defining the design of the Web page are separately prepared. In addition, at the time of generation of the dynamic Web page, the content of the dynamically changing part of the template is replaced with the content determined by the CGI program using the replacement identifier linking the two, so that the dynamic Web page is replaced.
Generate b page. Therefore, in the development stage of the dynamic Web page, it is possible to separately develop a CGI program that determines the contents of the dynamic change part and a template that defines the structure of the dynamic Web page separately from the CGI program. Separate the work of the designer. Therefore, it is possible to improve the efficiency and quality of the maintenance work such as the development work of the dynamic Web page and the subsequent change / update.

Furthermore, by registering a group of program modules for determining the display contents of the dynamic change section as a library so that they can be used in other dynamic Web page applications, a dynamic Web page can be used. Efficiency and quality can be further improved.

[Brief description of the drawings]

FIG. 1 is a diagram showing an embodiment of a dynamic Web page distribution system using a dynamic Web page generation program to which the present invention is applied.

FIG. 2 is a diagram showing a processing flow of the embodiment shown in FIG. 1;

FIG. 3 is an initial screen (We
b).

FIG. 4 is an example of a screen (Web page) that is dynamically customized and returned on a usage statement page.

FIG. 5 is an example of a CGI program 7 created for a usage statement page.

FIG. 6 is an example of an HTML template 8 created for a usage statement page.

FIG. 7 is a CG when a usage statement page is created by a conventional technique.
This is an example of an I program.

FIG. 8 is an HT when a usage statement page is created by a conventional technique.
It is an example of an ML template.

FIG. 9 is a diagram showing an example of a system configuration when a conventional static Web page is distributed and a processing flow thereof.

FIG. 10 is a diagram showing an example of a system configuration when a conventional CGI program is used and a processing flow thereof.

FIG. 11 is a diagram showing a system configuration example and a processing flow when a conventional server-side script is used.

[Explanation of symbols]

 1 Operator 2 Client System 3 Browser 4 Server System 5 Web Server Program 6 CGI 7 CGI Program 8 HTML Template 9 Dynamic Web Page Generator 10 Database 11 HTML Document 91 Library

 ──────────────────────────────────────────────────続 き Continuing on the front page (72) Inventor Tomonori Matsuba 4-6-10 Nihonbashi Honmachi, Chuo-ku, Tokyo Inside Twin Communication Co., Ltd. (72) Inventor Yuji 2-6-8 Chuo-cho, Meguro-ku, Tokyo Centra Le Chateau Room 203 F-term (reference) 5B082 EA07 GA02 GA16 HA08 5B089 GB03 JA23 JB02 KA10

Claims (7)

[Claims] 1. A dynamic Web page generating program for determining a display content of a dynamic change section of a dynamic Web page having a dynamic change section whose display content changes according to an input operation of an operator by a CGI program. A storage medium in which the structure of the dynamic Web page is described in a markup language, and the dynamic change unit has the same replacement identifier as the replacement identifier embedded in the CGI program. For the created template, based on the replacement identifier, replace the content of the dynamic change portion in the template with the display content of the dynamic change portion determined by the CGI program,
A storage medium storing a dynamic Web page generation program, which causes a computer to execute a step of generating a document described in a markup language of the dynamic Web page for a reply. 2. The dynamic Web page generation program according to claim 1, wherein a replacement identifier attached to the dynamic change part of the template is described in a tag of the dynamic change part. Storage medium on which is recorded. 3. The dynamic Web page according to claim 1, further comprising a function of deciding display contents of said dynamic change unit, wherein said program module group is registered in advance as a library. A storage medium storing a dynamic Web page generation program, which is executed by a computer at the time of generation based on an instruction of the CGI program. 4. A method for generating a dynamic Web page having a dynamic change part whose display content changes in response to an input operation by an operator, the method comprising the steps of: A first step of determining the display content of the dynamic change unit; and a configuration of the dynamic Web page is described in a markup language, and the dynamic change unit has the same replacement identifier embedded in the CGI program. By replacing the content of the dynamic change portion of the pre-created template with the replacement identifier with the display content determined in the first step based on the replacement identifier, the A method for generating a dynamic Web page, comprising a second step of generating a document described in a dynamic Web page markup language. 5. The method according to claim 4, wherein the determination of the display content of the dynamic change unit in the first step is performed based on an instruction of the CGI program. A method of generating a dynamic Web page, which is performed by calling and executing a group of program modules developed and registered as a library. 6. A method for developing a dynamic Web page having a dynamic change section whose display content changes in response to an input operation of an operator, the display content of the dynamic change section in response to an input operation of the operator Programming a CGI program that determines the configuration of the dynamic Web page, wherein the template is separate from the CGI program and defines the structure of the dynamic Web page.
A method for developing a dynamic Web page, comprising a step of describing, in a markup language, a template to which the same replacement identifier as a replacement identifier embedded in a program is attached. 7. The method of claim 6, wherein the step of programming the CGI program is developed to determine display content of the dynamic changer,
A method for developing a dynamic Web page, wherein the method is performed by using a group of program modules registered as a library in advance.