A cloud platform data analysis and processing system based on front-end segmentation

Abstract

This invention relates to the field of data processing technology, specifically to a cloud platform data analysis and processing system based on front-end segmentation. It includes synchronously displaying fields and pagination information to construct export parameters, cloning and rendering data to establish a running state, monitoring pagination changes to generate buffered content, segmenting and encapsulating cached data according to memory status, pushing data to the local machine and rolling back the page structure, and marking the end of the export process. This invention constructs export parameters by synchronously searching fields, table header structure, and pagination numbers; establishes a data clone structure by combining field mapping and pagination trajectory; monitors field changes to generate buffered content; splits paginated data according to memory usage and encapsulates it into a local cache; triggers pagination control and data merging operations; pushes data to the local machine and rolls back the display structure; and supports key aspects of the export process such as field tracking, memory control, data merging, and page recovery.

Description

Technical Field

[0001] This invention relates to the field of data processing technology, and in particular to a cloud platform data analysis and processing system based on front-end segmentation. Background Technology

[0002] In current business management systems, including e-commerce back-end systems, enterprise resource planning systems, and cloud service platforms, tabular data display is one of the core interaction methods. In these systems, after performing data retrieval, filtering, or statistical operations, users often need to export the complete results to Excel or CSV format for offline analysis, report generation, or archiving. Table export functionality has become an essential system capability. However, with the continuous growth of data volume, especially when dealing with datasets containing hundreds of thousands to millions of records, existing data export solutions have revealed significant shortcomings in terms of system performance, user interaction efficiency, and development and maintenance.

[0003] There are three main problems in the export of massive amounts of data. First, the backend export method generates complete data files uniformly on the server side, which suffers from high resource consumption, long processing time, and is prone to memory overflow. Furthermore, user waiting time is unpredictable, and the process lacks a feedback mechanism. Second, the frontend paginated export method relies on users manually copying and merging data for each page, which is cumbersome, inefficient, and cannot meet the requirement of "one-click export of all". Third, customized export solutions require writing export logic separately for each business table. While this can optimize the export experience, it leads to repetitive development, scattered logic, and high system maintenance complexity. Therefore, a general, loosely coupled frontend export mechanism needs to be built. Based on automatic frontend paginated data requests, this mechanism should complete the batch acquisition, caching, merging, and formatted export of massive amounts of data without requiring backend modifications. This would improve export efficiency and user experience, and reduce the overall development and maintenance costs of the system.

[0004] Existing technologies rely on centralized server-side processing when generating data files. When dealing with large multi-page tables, they suffer from problems such as concentrated export pressure and delayed resource release. Users are often unresponsive and lack interactive feedback. Front-end export methods rely on users copying and splicing pages one by one, resulting in cumbersome data processing workflows and low accuracy. Table export logic is mostly developed independently and lacks reusability standards. The system suffers from structural fragmentation and logical dispersion during export capability expansion and maintenance adjustments. In dynamic data scenarios, it exhibits problems such as unstable export efficiency and high operating costs. Summary of the Invention

[0005] The purpose of this invention is to address the shortcomings of existing technologies by proposing a cloud platform data analysis and processing system based on front-end segmentation.

[0006] To achieve the above objectives, the present invention adopts the following technical solution: a cloud platform data analysis and processing system based on front-end segmentation, the system comprising:

[0007] The export request initialization module receives the page export instruction and sequentially synchronizes the search condition fields, table header fields, pagination number, and data source path to the main thread rendering area. It then pushes the interface to the task processing flow to form the export parameter input set.

[0008] The data clone isolation module, based on the page number and field content in the exported parameter input set, writes the main area fields and entries into the buffer in sequence, pauses the page data transfer action, completes the synchronization of the page trajectory and field structure, and forms a clone data running status set;

[0009] The page-turning trigger listening module, referring to the page number and field number in the cloned data running status set, gradually triggers page turning, compares the fields after page turning with the data of the previous round, writes the changed content into the cache, and marks the status of the data entry to form a segmented data buffer content group;

[0010] The data storage splitting module receives the segmented data buffer content group and available memory information, confirms the relationship between the current cache and the capacity baseline, pauses page turning when it is close to the limit, encapsulates the data into a local cache unit and clears the cache, and obtains the export cache conversion process status.

[0011] As a further embodiment of the present invention, the set of exported parameters includes the content of search condition fields, table field structure information, page number identifier, and data source path marker; the set of cloned data running status includes field index mapping relationship, page trajectory sequence record, and field structure synchronization information; the set of segmented data buffer content includes field arrangement change record, page number index information, and cumulative entry statistics; and the export cache conversion process status includes local file cache unit, page turn recovery control identifier, and memory cleanup status signal.

[0012] As a further aspect of the present invention, the export request initialization module includes:

[0013] The export instruction receiving submodule extracts the instruction type, trigger timestamp, and page identifier from the browser event binding fields based on the export operation instruction triggered by the user on the page. It compares the correspondence between the instruction type and the page identifier, confirms the initial data range of the export request through the positioning operation, and passes the page identifier and instruction type into the subsequent process to obtain the export request trigger dataset.

[0014] The parameter field extraction submodule calls the export request to trigger the dataset, extracts the search condition field and table header field in the page rendering cache area according to the page identifier, retrieves the input content and number distribution in the search field, parses the index value and front-end rendering order of the header field, and reads the current page number. It then uses the field index order to locate each data position and match it with the number to obtain the set of fields displayed on the page.

[0015] The interface data sending submodule calls the page display field set, maps the search field, header field, pagination number and data source path in the display field set into the interface field template, performs field value alignment and position allocation according to the field sequence rules, organizes the numerical order and field positioning rules according to the interface specification format, and pushes the organized result into the front-end task processing channel to obtain the export request parameter set.

[0016] As a further aspect of the present invention, the data cloning isolation module includes:

[0017] The pagination parameter reading submodule obtains the pagination number and display field content from the exported parameter input set, reads the field index sequence and item sequence of the corresponding pagination from the page rendering area, parses the mapping position of the pagination number in the data source, extracts the field position information and item value range according to the number order, and performs a number comparison on the mapping relationship between the pagination number and the field index to obtain the pagination mapping index set.

[0018] The field data writing submodule, based on the pagination mapping index set, detects the field sequence and entry value of the current data area in the page data rendering thread, performs a writing action on the fields and entries in order of position, temporarily stores the written content in the local buffer area, compares the differences in field position and entry number according to the pagination order, merges the writing results in position and aligns the numbers to obtain the local buffer dataset.

[0019] The clone trajectory synchronization submodule calls the local buffer dataset, pauses the data transfer between the main area and the data layer in the page rendering thread, copies the pagination trajectory and field structure in the clone area according to the original numbering order, compares the pagination number and field index one by one, completes the pagination trajectory synchronization and field position arrangement, and obtains the cloned data running status set.

[0020] As a further aspect of the present invention, the page-turning trigger listening module includes:

[0021] The page turning action execution submodule, based on the page number order and field quantity in the cloned data running status set, triggers the page turning action in sequence according to the number order. After each round of page turning, it extracts the field name and position index in the field area of ​​the current page, and matches the field content with the number position in sequence to obtain the page turning field position sequence.

[0022] The field order verification submodule calls the pagination field position sequence to compare the current page field with the previous round field content in numerical order to check the position changes. When the position sequence is inconsistent, the current field name and corresponding index are written into the memory cache area, and the field content overwrite operation is completed in sequence to obtain the field cache mapping set.

[0023] The status number labeling submodule reads the current page index value and the last page number according to the field cache mapping set, locates the status number in order of page number and number of entries, and appends the status number to the specified position in the cache area to obtain the segmented data buffer content group.

[0024] As a further aspect of the present invention, the data storage splitting module includes:

[0025] The memory usage monitoring submodule obtains the write items of each page in the segmented data buffer content group and the current browser available memory information, performs a numerical comparison of the memory usage data after each page is written, determines the page turning sequence continuity based on the difference range between the current memory value and the processing capacity benchmark, and obtains a page turning stop trigger signal when the memory usage is close to the data interval value set before the processing capacity benchmark.

[0026] The data transfer triggering submodule terminates the page turning action according to the page turning stop trigger signal, extracts the data content and corresponding indexes written in the current segment, performs the field number repositioning action, writes the data items into the local file cache structure, clears the corresponding memory buffer data and releases the number occupied position, and obtains the local cache file index set.

[0027] The cache status update submodule calls the local cache file index set, restores the page turning instruction response channel, aligns the entry number for the page to continue receiving data with the last termination number, sets a new segment start position and cache status identifier, and synchronizes the status value to the control channel to obtain the export cache conversion process status.

[0028] As a further aspect of the present invention, the system further includes:

[0029] The export completion and return module, based on the last page pagination structure in the export cache conversion process status, pushes batch data to the local machine, synchronizes termination information to the page display layer, overwrites the main area with cloned data, closes the pop-up interface, and obtains the export process end identifier data.

[0030] The data indicating the end of the export process includes data write-back status, termination prompt, and closed interface interaction status.

[0031] As a further aspect of the present invention, the export and finalization return module includes:

[0032] The data batch push submodule calls the pagination structure content marked as the last page in the export cache conversion process status, extracts the data items and corresponding field indices of each page in the current batch, writes all fields and data to the local file area and releases the space occupied by the memory segment in the batch, and obtains the local data push result set.

[0033] The main area writeback processing submodule synchronizes the page turning termination information to the page display layer according to the local data push result set, replaces the currently displayed content in the main area, writes the cloned data content item by item into the original page structure area, overwrites the corresponding position of the original field index and the data mapping path, and obtains the page writeback structure status.

[0034] The export status output submodule, based on the page write-back structure status, performs the export pop-up interaction area closing operation, releases the page interaction resources bound to the export task, clears the status flags and interface response flag fields set during the export process, and obtains the export process end flag data.

[0035] Compared with the prior art, the advantages and positive effects of the present invention are as follows:

[0036] In this invention, an export parameter set is constructed by synchronizing the search fields, header structure, and pagination numbers in the display area. A data clone structure is established by combining field index mapping and pagination trajectory identifiers. Buffer content groups are dynamically generated based on a field change monitoring mechanism. Pagination data is dynamically split and encapsulated into local cache units based on memory usage differences. This triggers the pagination control process and data merging operation, completing the cache stacking and local push of continuous data segments. The page termination state is synchronized and the display structure is rolled back through the end page identifier. The above processing method supports multiple key steps in the export process, such as field tracking, memory segmentation control, data block merging, and page structure restoration. Attached Figure Description

[0037] Figure 1 This is a flowchart illustrating the overall system flow of the present invention.

[0038] Figure 2 This is a flowchart of the system modules of the present invention. Detailed Implementation

[0039] The technical solution of the present invention will now be described with reference to the accompanying drawings.

[0040] In embodiments of the present invention, words such as "exemplarily," "for example," etc., are used to indicate that something is an example, illustration, or description. Any embodiment or design described as "exemplary" in the present invention should not be construed as being more preferred or advantageous than other embodiments or designs. Specifically, the use of the word "exemplary" is intended to present the concept in a concrete manner. Furthermore, in embodiments of the present invention, the meaning expressed by "and / or" can be both, or either one.

[0041] In the embodiments of this invention, the terms "image" and "picture" may sometimes be used interchangeably. It should be noted that, without emphasizing the distinction between them, they convey the same meaning. Similarly, the terms "of," "corresponding (relevant)," and "corresponding" may sometimes be used interchangeably. It should be noted that, without emphasizing the distinction between them, they convey the same meaning.

[0042] In this embodiment of the invention, sometimes a subscript such as W1 may be written in a non-subscript form such as W1. When the difference is not emphasized, the meaning they express is the same.

[0043] To make the technical problems, technical solutions and advantages of the present invention clearer, a detailed description will be given below in conjunction with the accompanying drawings and specific embodiments.

[0044] Please see Figure 1 This invention provides a technical solution: a cloud platform data analysis and processing system based on front-end segmentation, the system comprising:

[0045] The export request initialization module receives the export operation command triggered by the user on the page, and synchronizes the search condition fields, table header fields, current pagination number and data source path in the current display area of ​​the page to the main thread rendering area in sequence. It pushes the request content to the front-end task processing flow through the interface channel to form the export parameter input set.

[0046] The data cloning isolation module, based on the pagination number and display field content in the exported parameter input set, writes the fields and entries in the current data rendering area into the local buffer area in the order of their positions. It pauses the data transfer between the main area and the data layer in the page rendering thread, and synchronizes the pagination trajectory and field structure in the clone area according to the original numbering order, forming a cloned data running status set.

[0047] The page turning trigger listening module, referring to the page number order and field arrangement quantity in the cloned data running status set, triggers page turning operation instructions in sequence, compares the field area after each round of page turning with the field content of the previous round, and synchronously writes the field content to the memory cache location when the field arrangement order changes. It also checks the index value of the current page with the last page number in sequence and marks the current data status based on the current cumulative number of entries, forming a segmented data buffer content group.

[0048] The data storage splitting module receives the items written to each page in the segmented data buffer content group and the current browser's available memory information, calculates the difference between the cumulative memory usage and the processing capacity benchmark, and when the memory usage is close to the processing capacity benchmark, stops the page turning instruction sequence, triggers the page prompt process, encapsulates the data in the current segment into a local file cache unit, clears the contents of the memory temporary storage area, resumes page turning reception and starts the next segment storage, and obtains the export cache conversion process status.

[0049] The export completion and feedback module calls the pagination structure content marked as the last page in the export cache conversion process status, pushes the current batch data to the local file area, synchronizes the pagination termination information to the page display layer, overwrites the cloned data content to the main data area, restores the page structure to the initial display level, closes all export pop-up interaction areas, and obtains the export process end marker data.

[0050] The set of parameters to be passed to the export includes the content of the search criteria fields, the table field structure information, the page number identifier, and the data source path marker. The set of cloned data running status includes the field index mapping relationship, the page trajectory sequence record, and the field structure synchronization information. The set of segmented data buffer content includes the field arrangement change record, the page number index information, and the cumulative entry statistics. The export cache conversion process status includes the local file cache unit, the page turn recovery control identifier, and the memory cleanup status signal. The export process end identifier data includes the data write-back status, the termination prompt identifier, and the interface interaction closed status.

[0051] Please see Figure 2 The export request initialization module includes:

[0052] The export instruction receiving submodule extracts the instruction type, trigger timestamp, and page identifier from the browser event binding fields based on the export operation instruction triggered by the user on the page. It compares the correspondence between the instruction type and the page identifier, confirms the initial data range of the export request through the positioning operation, and passes the page identifier and instruction type into the subsequent process to obtain the export request trigger dataset.

[0053] First, the structure of the bound fields is obtained from the event listener source. Based on the key-value pairs of the bound fields, the command type of the currently clicked export button is parsed. The page identifier and command trigger location information are extracted by combining the attribute values ​​of the bound object. Before obtaining subsequent operation parameters, the browser window interaction area where the triggering behavior occurs needs to be further read. The button number and page path address in the interaction area are extracted. The command location operation is completed by matching the number content with the path field. Then, a content comparison process is performed on the relationship between the obtained command type and page identifier. During the comparison, each command number and page path pairing entry in the command mapping table is extracted according to preset rules. An item-by-item comparison is used to determine whether the page path corresponding to the user's operation exists in the mapping item. If it exists, the corresponding page path value and bound command number are recorded; otherwise, they are not recorded. If the current operation is marked as an abnormal operation and the subsequent processing flow is terminated, the initial rendering index value needs to be extracted from the page cache based on the page identifier. Through the hierarchical numbering system set in the page rendering engine, the current page index value, rendering area positioning parameters and the key number of the user-triggered behavior are bound together. Then, based on the cache key-value correspondence of the browser page identifier, the last access location and page rendering index are extracted from the browser page storage container, and the two are compared. If the page path and page identifier are consistent, the page range triggered by the export request is confirmed to be the current rendering area. During this process, the system combines the page identifier and instruction type into a data entity and passes it to the next level execution channel as the parameter source for the export operation. After the execution is completed, the export request trigger dataset is obtained.

[0054] The parameter field extraction submodule calls the export request to trigger the dataset, extracts the search condition field and table header field from the page rendering cache area according to the page identifier, retrieves the input content and number distribution in the search field, parses the index value and front-end rendering order of the table header field, and reads the current page number. It then uses the field index order to locate each data position and match it with the number to obtain the set of fields displayed on the page.

[0055] Using the page identifier number recorded in the dataset triggered by the export request as the retrieval entry point, the system directly locates the corresponding display area cache field in the page rendering cache area. Within this cache field, it first extracts the user-input search criteria field set and the table header field set currently displayed on the page. For each field value in the search criteria field set, the input content needs to be decomposed into a text structure. By classifying and labeling the number and type of characters in the input string, and combining this with the field number range defined during page initialization, it determines the numbering partition to which each input field belongs. During this process, if the total character length exceeds the page's field setting limit of 20 characters, the field is marked as exceeding the limit; otherwise, the system continues to index and register the correspondence between the field's number value and the input content. Then, using the page identifier number as a basis, it extracts the table header field area associated with the page from the rendering cache. This area contains the name of the currently displayed field, the field binding index, and its rendering order number during front-end rendering. The fields are extracted in ascending order of their sequential numbers and compiled into a header sequence list. In this list, fields with rendering order values ​​less than or equal to 10 are categorized as primary display fields, while the remaining fields are categorized as extended display fields. Simultaneously, the pagination number is retrieved from the current page address. This pagination number typically represents the current page's position within the overall pagination sequence as a consecutive integer, ranging from 1 to N. For example, if the user is currently on page 5, the pagination number is 5. After obtaining the pagination number, it is mapped to the table structure index. The positions of each field on the current page are then determined according to the order of their index numbers. The order of the field index numbers follows the ascending order of the rendering order fields in the header sequence. For instance, if fields F3, F1, and F2 are rendered in order 2, 1, and 3, their positional order is F1, F3, and F2. Finally, all field names, field numbers, pagination numbers, and display orders are recombined according to their corresponding indices to obtain the set of fields displayed on the page.

[0056] The interface data sending submodule calls the page display field set, maps the search field, header field, pagination number and data source path in the display field set into the interface field template respectively, performs field value alignment and position allocation according to the field sequence rules, organizes the numerical order and field positioning rules according to the interface specification format, and pushes the organized result into the front-end task processing channel to obtain the export request parameter set;

[0057] The search field, header field, pagination number, and data source path are extracted sequentially from the field set. A corresponding field type identifier is assigned to each type of field: the search field is labeled as an input field, the header field as a display field, the pagination number as a sequence control field, and the data source path as a path reference field. Then, each field is written to its designated location in the interface field template according to its field type. The search field corresponds to the filter area in the interface template, the header field to the table structure area, the pagination number to the request parameter area, and the path field to the data index area. After writing the fields, the values ​​are sorted according to the field order rules defined in the interface field template. This sorting is performed based on the field structure number table within the template. If a field is a string, its alignment is... The method involves filling spaces to the left of characters up to a set number of digits. If the field is a numeric type, spaces are filled to the right to align it to the tens digit. After the field values ​​are arranged, the various field value sets are rearranged according to the order rules defined in the interface template. The rearrangement rules stipulate that the header field must be placed before the search field, the pagination number is placed at the end of the field value, and the data path is placed at the beginning of the entire field value set. Then, the task number and task transmission address in the front-end task processing channel are read. If the task channel is not occupied, the current field value set and field location information are bound as task data units and written to the task transmission channel queue. After writing, the task number is recorded in the task confirmation sequence. The task channel status confirmation indicates that the current data is ready to be sent. After completing the above steps, the export request parameter set is obtained.

[0058] The data clone isolation module includes:

[0059] The pagination parameter reading submodule obtains the pagination number and display field content from the exported parameter input set, reads the field index sequence and item sequence of the corresponding pagination from the page rendering area, parses the mapping position of the pagination number in the data source, extracts the field position information and item value range according to the number order, compares the numbering relationship between the pagination number and the field index, and obtains the pagination mapping index set.

[0060] After obtaining the pagination number and display field content from the input set of export parameters, the process reads the pagination number value and field list array. The pagination number value is used to locate the pagination position of the data source, while the field list records the unique number and field order information of all display fields in the current display page. Next, the process enters the page rendering area, retrieves the field rendering cache fragment under the current number, and extracts the field index sequence from the cache fragment. Each field in this sequence corresponds to a field number and its rendering position value on the current page. For example, if the field number is F104 and the rendering position is 7, it can be determined that the field should be located in column 7. Combined with the current pagination number (e.g., if the current number is 6), the process locates the data entry sequence corresponding to page 6. This sequence records the field number index and value range information for each data entry in order. The value range typically includes character length, data type, and the starting offset position of the field data. The process is then performed by extracting the field number from each data record item in the entry sequence. The page numbers are matched with the field numbers in the field index sequence to obtain the number pairing relationship between each entry and the field. Then, a data source mapping operation is performed on the page numbers. This mapping operation derives the index range of each page in the data source based on the index difference between the page number and the data start point. For example, if the page number is 6 and each page displays 10 data entries, the corresponding entry index range in the data source is 51 to 60. After matching this range with the field number index value, the position information of each field in the page can be extracted according to the number order. Then, the rendering order of all fields in the page is rearranged according to the field number order from smallest to largest. If the same number is repeated or the numbering is discontinuous during this operation, it is adjusted by inserting placeholders and deleting redundant numbers. Finally, a number comparison table is established for the mapping relationship between page numbers and field indexes. This table is arranged in ascending order of field number and marked with its page positioning range value. After completing the above comparison process, the page mapping index set is obtained.

[0061] The field data writing submodule, based on the pagination mapping index set, detects the field sequence and entry value of the current data area in the page data rendering thread, performs the writing action item by item according to the position order of the fields and entries, temporarily stores the written content in the local buffer area, compares the differences in field position and entry number according to the pagination order, merges the writing results into positions and aligns the numbers to obtain the local buffer dataset.

[0062] The mapping relationship between field numbers and pagination sequences is extracted from the pagination mapping index set. In the page data rendering thread, the list of field numbers loaded in the current data area and the data items associated with each field are read. The field position index and content value in each record are compared and verified. The field number is used as the primary key, and the corresponding value is used as the value item. They are stored sequentially into the write buffer pool. During the item-by-item writing process, the writing order is controlled by the ascending order of field numbers. For example, if the field numbers are F001, F002, F003, and F005, but the actual data rendering order is F003, F001, F005, and F002, then the writing order is adjusted to F001, F002, F003, and F005. After each record's field writing is completed, the current total writing amount and the field's occupied position index are recorded, and then the content is stored in the corresponding data block in the local buffer area. The region is set as a paginated structure, with each page corresponding to a data block. If the page number is 6, the data block number is BLOCK006. The pagination order comparison operation continues, and the field positions on the current page are numbered and reconfirmed. The position index is compared with the corresponding field number order in the previous page. If there is a jump in the field order, the position of the jump field number is recorded and added to the field order adjustment queue. The number of entries is compared, and the difference between the number of records on the current page and the number of records on the previous page is calculated. If the difference is not zero, the page is marked as a page with inconsistent record counts, and a jump line marker is added to the record. After all records are written, number alignment is performed. Missing number segments in the field numbers are filled with empty data bits, and overflow number segments are truncated. Then, all written fields and entry contents are remapped to the standard paginated record structure according to the page number, and finally the local buffer dataset is obtained.

[0063] The clone trajectory synchronization submodule calls the local buffer dataset, pauses the data transfer between the main area and the data layer in the page rendering thread, copies the pagination trajectory and field structure in the clone area according to the original numbering order, compares the pagination number and field index one by one, completes the pagination trajectory synchronization and field position arrangement, and obtains the cloned data running status set.

[0064] In the browser's execution thread, the data transmission process between the main page area and the data layer is paused, blocking the push of data rendering requests to the backend channel, thus fixing the frontend buffer state to the current page. Then, the page number list and field number list in the local buffer dataset are read, and a synchronization relationship between the field numbers and the pagination index is established. Before performing the copy operation, the pagination slots and field slots in the cloned area need to be initialized to an empty state. Then, each page number is read in the original order. For example, if the page number is P005 and the corresponding field number set is F01, F02, F03, and F04, a page node with page number P005 is generated in the cloned area, and the field number slots are filled sequentially. During field filling, the alignment is based on the original field display order in the source page; that is, if field F03 is in the second column in the source page, then F03 is also placed in the second slot in the cloned area. Simultaneously, the field value length information and data are extracted from the local buffer data. Based on the offset value, and after field alignment and number padding, the pagination trajectory comparison process is performed. The page node numbers of each page in the current clone area are extracted sequentially and compared with the page number order in the local buffer dataset. If the numbers are consecutive and the number is consistent, the original trajectory order is maintained. If there are skipped or missing numbers, such as skipping number P008, the page is padded by inserting empty page nodes and marked as a placeholder page. After all pagination structures are copied, the field number sorting information is read, and the index order of each field in the same page is confirmed to ensure that the field indexes are arranged in ascending order and there are no number conflicts or duplicate numbers. If there is a phenomenon of field numbers appearing repeatedly in the same page, such as field F04 appearing twice in the same page, the first number position is retained, and the duplicate field is moved to the end of the buffer queue to complete the field position correction. Finally, all pagination trajectories and field index order are written into the corresponding page nodes of the clone area to obtain the clone data running status set.

[0065] The page-turning trigger listening module includes:

[0066] The page turning action execution submodule, based on the page number order and field number in the cloned data running status set, triggers the page turning action in sequence according to the number order. After each round of page turning, it extracts the field name and position index in the field area of ​​the current page, and matches the field content with the corresponding number position to obtain the page turning field position sequence.

[0067] Extract all numbered items from the pagination number list and sort them in ascending order. For example, items numbered P001 to P010 are sorted numerically as P001, P002, P003, etc. Then, execute page turning actions according to each number order. This is triggered by sending a page turning request event to the browser rendering thread. After the event is triggered, the page loading interface completes the current page content replacement operation. After each round of pagination, immediately access the rendered field areas in the page display area. Retrieve all field names and their position indices by querying the DOM node list or cache area structure of the rendered area. Field names are usually front-end bound field identifiers, such as "userName" or "orderId". The field position index indicates the column position of the field in the page table. For example, if the field "userName" is in the third column, its position... With an index of 3, after field extraction is complete, a field position mapping table is constructed, using the field name as the key and the field index as the value, such as "orderId":1, "userName":3. The field quantity information is then read and compared with the field quantity recorded in the cloned data running status set. If the comparison results match, the current page field order is used as the valid order record; otherwise, it is marked as a structurally inconsistent page and appended to the abnormal page list. Under the field quantity matching state, the field names are reordered according to the number order, i.e., arranged by position index from smallest to largest. Then, each field is compared sequentially according to its original number position in the cloned status set to ensure that the order corresponds without offset. After all the above processing is completed, the field order and number sequence extracted after each round of pagination are summarized and written to the pagination field sequence cache, and the position source of each sequence segment is identified by the pagination number, ultimately obtaining the pagination field position sequence.

[0068] The field order verification submodule calls the pagination field position sequence to compare the current page field with the previous round field content in numerical order to check the position changes. When the position sequence is inconsistent, the current field name and corresponding index are written to the memory cache area, and the field content overwrite operation is completed in sequence to obtain the field cache mapping set.

[0069] Extract the field sequence arrays of the current page and the previous page. Create two corresponding index tables based on the ascending order of field numbers. Arrange the field names of the current page according to their original number sequence. For example, if the current page field number sequence is F002, F001, F003, it needs to be adjusted to F001, F002, F003. Compare the positions with the previous page field position sequence. If the previous page field sequence was F001, F002, F003 and the indices were 1, 2, and 3 respectively, the current page should have the same structure. If the current field F002 has an index of 1 but was 2 in the previous page, it indicates that the field position has changed. In this case, write the changed field name F002 and its current index value into a temporary field record table and register the change flag as "Y". Continue to perform the same number position comparison on all fields. If the field number sequence is the same but the position is different, even if the field name has not changed, mark it as "Y". This is referred to as the rearrangement field. After all fields have been checked, all marked fields and their corresponding position numbers are read from the temporary field record table and written into the field replacement segment in the memory cache area. The cache segment structure is built according to the field number in ascending order to create a list of corresponding fields for each page, and a replacement status flag is set for each field. The field names are sorted in numerical order and then the corresponding position values ​​in the original field structure are overwritten in turn. The overwriting method is to directly write the current field value to the memory address corresponding to the old position index without retaining the original value. After the field is written, the number alignment action is performed to check whether there is a missing number segment in the field number of the current page. For example, if the original page has F001 to F005, but the current page only contains F001, F002, and F004, then an empty field is inserted at position F003 and marked as a placeholder in memory. After the overwrite operation is completed, the cache pointer position is refreshed to ensure that the field list pointer points to the end of the last field of the current page, and finally the field cache mapping set is obtained.

[0070] The status number labeling submodule reads the current page index value and the last page number according to the field cache mapping set, locates the status number in order of page number and number of entries, and appends the status number to the specified position in the cache area to obtain the segmented data buffer content group.

[0071] The system reads the current page index, last page number, and field number index table from the cache set. The index value represents the page's position in the overall pagination sequence, and the last page number represents the range of the last page number for this batch of data. For example, if the current page index is 5 and the last page number is 12, then the pagination range corresponding to this operation is pages 5 to 12. Then, based on the page number order and the number of entries, a status number positioning process is performed. The number of records per page is extracted from the cache set. If the current page contains 20 entries, then the entry number range is 1 to 20. The page number and entry number are then combined to form a unique status number sequence. The format of this status number can be defined as the numerical value concatenated from the page number and the entry number. For example, the 10th entry on page 5 corresponds to status number 510. Based on this, a status number mapping table is established. The field cache index corresponding to each status number is recorded in the cache identifier area, and the field number and status number are registered one-to-one. During the registration process, if the same status number corresponds to multiple field numbers... In cases where the field number is repeated more than twice, the field with the smaller number is selected as the base field, and the field with the larger number is registered later. If the field number is repeated more than twice, an overflow flag is added to the cache identifier area and the flag is set to "O" for easy tracking and verification later. After the status number is located, the status number data is written to the specified storage location in the cache area. This location corresponds to the starting offset address of the current page in the cache space. For example, if the offset address of the 5th page is 5000, then the status number 510 corresponds to the contiguous storage units in the range of 5000 to 5020. The writing is done in a sequential append mode, and the field content is arranged in ascending order of status number to ensure that the data block number is continuous and without gaps. If the last page number is equal to the current page number, the last item of the current status number sequence is set as the segment end identifier, and the identifier is recorded as "E". This identifier is used to distinguish the data segment boundary in the next page read. At this point, all status numbers and their field position mappings have been written to the cache area, resulting in a segmented data buffer content group.

[0072] The data storage splitting module includes:

[0073] The memory usage monitoring submodule obtains the written items of each page in the segmented data buffer content group and the current available memory information of the browser. It performs a numerical comparison of the memory usage data after each page is written, and determines the continuous state of the page turning sequence based on the difference range between the current memory value and the processing capacity benchmark. When the memory usage is close to the data interval value set before the processing capacity benchmark, a page turning stop trigger signal is obtained.

[0074] Extract the page number, number of fields, and single-page write size for each page block in the buffered content group. The write size is the total number of bytes occupied by the field values ​​within that page. This number of bytes is obtained by multiplying the number of characters in all field contents by the character encoding length. For example, under UTF-8 encoding, each character is counted as 1 byte. If a page contains 20 records, and each record averages 100 characters, then the total write size for that page is 2000 bytes. Simultaneously, obtain the current available memory space capacity from the browser's memory management module. For example, if the current available memory capacity is 524288000 bytes, set this value as the memory limit reference. Then, perform cumulative memory value statistics after each page write. Calculate the cumulative write amount for each written page sequentially. The cumulative value of the first page is the current page write size, the second page is the first page's cumulative value plus the current page's write size, and so on, forming a cumulative value sequence. If the cumulative value of a page is 5... If the remaining capacity is 12,000,000 bytes, it is determined whether the difference between this value and the processing capacity baseline is less than the preset data interval threshold. The data interval threshold is set to 10,240,000 bytes based on the stable operating load that the browser can handle. That is, when the remaining capacity is less than this value, further page turning should be stopped. In the above judgment, the current accumulated memory value is compared with the upper limit of available memory. If the result value is lower than the threshold setting, the page turning stop judgment action is triggered. On this basis, it is further confirmed whether the current page number is the upper limit of the page tail number range. If the end page number has not been reached but memory is insufficient to continue paging, the current page number is recorded and written to the page turning control instruction area, the page turning status flag is updated to "pause", and this status instruction is bound to the task control channel flag. At the same time, the current status flag is added through the instruction buffer for subsequent reading of the recovery point. Finally, the result is output according to the judgment logic to obtain the page turning stop trigger signal.

[0075] The data transfer trigger submodule terminates the page turning action based on the page turning stop trigger signal, extracts the written data content and corresponding index in the current segment, performs the field number relocation action, writes the data item to the local file cache structure, clears the corresponding memory buffer data and releases the number occupied position, and obtains the local cache file index set.

[0076] Upon receiving the pagination abort trigger signal, an abort flag is immediately written to the task scheduling queue, terminating the current page pagination event and stopping the loading of the next page of data. Then, the completed pagination data segment is extracted, reading the page number index and field content block of each page in the current segment. The field item content recorded within the current page range is identified by the number index. The field name, field number, and field value content are then extracted sequentially from the field content block. Each record is located according to its number. During the field number relocation operation, the original field number sequence needs to be re-sorted in ascending order. For example, if the original number sequence is F003, F001, F004, F002, it is re-sorted to F001, F002, F003, F004. The old position index of each item in the original field content block after sorting is recorded. Then, the corresponding field value content is extracted sequentially according to the new sorting structure, organized into a reconstructed data record row according to the new field order, and written to the local file cache. In the storage structure, the local file cache structure uses a paginated directory method. Each page number corresponds to an independent data segment directory, named according to the rule cache_page_xx, where xx is the page number value. Data is written sequentially by appending, that is, the field name and field value are written sequentially from the starting position of the field record and separated by a uniform delimiter. After writing is completed, the current field content block is immediately released from the memory buffer. During the release process, the corresponding page field record entries in the field cache index table are cleared page by page, and the released number position is marked as free and added to the memory reclamation queue. If the field number still exists in other incomplete pages, the release is not performed, and only the current segment status table is updated. After all field blocks are cleared, the local cache file path is scanned to establish the correspondence between page numbers and file paths. Finally, all page numbers, file paths, and field range index positions are integrated and imported into the file cache index record table to obtain the local cache file index set.

[0077] The cache status update submodule calls the local cache file index set, restores the page turning instruction response channel, aligns the entry number for the page to continue receiving data with the last termination number, sets the new segment start position and cache status identifier, and synchronizes the status value to the control channel to obtain the export cache conversion process status.

[0078] Retrieve the previous segment's termination page number, corresponding data block path, and field range index table from the local cache file index set. Use this number as the starting reference point for page reversal recovery. Then, activate the instruction response queue in the page reversal control channel and insert a recovery flag into the queue. The recovery flag records the entry number as the termination page number plus one; that is, if the previous termination page number was P010, the current entry number is set to P011. Simultaneously, write a new entry status field to the task control channel and re-establish the page reversal baseline mapping table using the current entry number as the anchor point. In this mapping table, each page number corresponds to a cache segment identifier with the structure "segment_xx", where xx is the page number. Initialize the segment number for the next write process, setting it to the auto-incrementing value of the previous segment number. If the previous segment was S002, the current segment number is S003. Before page reversal recovery, the cache status flag needs to be set. The identifier, appended to the segment number structure, has the structure "status:pending", indicating that the current segment is not yet filled and is in a waiting state. This status value will be shared with the task response interface and passed to the front-end task processing queue for identification and labeling. To ensure the continuity of the pagination control logic, the segment number and the recovery page number must also be combined and written into the pagination control table. This control table is used for the continuous verification of data segments in subsequent export tasks. After writing, the next page request field of the pagination response channel is updated with a value of P011 and the segment identifier field is added as S003. After completing the above information settings, the task control signal channel is activated again, and the recovery status value "continue" is passed to the end of the channel, indicating that the pagination continuation process has started. Finally, the pagination entry number, segment number, and status identifier are registered together in the export scheduling status table to obtain the export cache conversion process status.

[0079] The export, finalization, and return module includes:

[0080] The data batch push submodule calls the pagination structure content marked as the last page in the export cache conversion process status, extracts the data items and corresponding field indices of each page in the current batch, writes all fields and data to the local file area and releases the space occupied by the memory segment in the batch, and obtains the local data push result set.

[0081] Identify the segment number and page number combination items marked as "Terminal Segment" or "Last Page" in the process status table. Set the push range of the current batch to all paginated data blocks within the segment pointed to by the last page number. Then, extract the field data and index values ​​of each page in the batch according to the segment index table. The field data is distributed across multiple cache segments by page, with each segment corresponding to multiple field names and corresponding number positions. For example, if the last page is P020 and the segment number is S006, the push batch range is all cached content with page numbers P011 to P020 under S006. Traverse the data structure of each page within this range, extracting the field numbers and corresponding values ​​from the field index table item by item. Each data entry needs to be bound to a field number to ensure that the original arrangement structure is maintained during the push process. After binding the data and fields, organize them into a data record set according to the number order. Each record is written to the local file area with the field number as the key and the data content as the value. The write action is set according to the total number of fields. The loop count is fixed. If each page has 12 fields and there are 10 pages, the total number of data entries pushed is 120. Each data record occupies a fixed length of space in the cache segment. After writing, it checks whether there is a duplicate write to the field number. If the field number is the same, the latest record overwrites the old value. After writing, the write success flag and field binding status are stored in the push record table for subsequent confirmation that all fields have been pushed. Then, a memory reclamation operation is performed on the segment number that has been pushed. All field numbers in the segment are traversed, their flags in the memory address mapping table are cleared, and the corresponding address space is released. For each memory block corresponding to a segment number that is released, the flag bit is set to "free" so that subsequent data segments can be reclaimed. Finally, an index value table is generated for the successfully written data blocks. Each index record contains the page number, field number, record offset address, and write status. All index records are integrated to form a local data push result set.

[0082] The main area write-back processing submodule pushes the result set based on local data, synchronizes the page turning termination information to the page display layer, replaces the currently displayed content in the main area, writes the cloned data content item by item into the original page structure area, overwrites the corresponding position of the original field index and the data mapping path, and obtains the page write-back structure status.

[0083] Extract the field numbers, field contents, and corresponding page numbers of successfully pushed data from the local data push result set. Pass the terminating page number identifier from each record in the result set to the page number control interface in the page display layer. Match the current page number value with the terminating identifier value to pause the automatic pagination logic of the current page. Then, clear the original data display structure in the main area of ​​the page. This operation iterates through all field indices and data binding paths in the structure, setting the existing binding status identifier to an undefined state. Using cloned data as the data source, read the field numbers and their corresponding data values ​​item by item from the generated cloned data cache. Match the field index positions in the main area according to the field number sorting rules corresponding to the data items. For example, if the field number is F005 and the corresponding index position is the 7th position, then the value of field F005 in the cloned data needs to be directly written into the main area. In the data display unit mapped by the 7th position of the regional index, during the writing process, it is checked whether the field has data path binding information in the original structure. If a path record exists, the path information is overwritten and matched with the current field value, the path item of the field in the page field index table is updated to the new path, and the path binding status is marked as overwritten. If the field path does not exist, the path item is added to the path mapping table and binding record generation is performed. After all fields are written, a current field status record set is generated in the main regional data structure. This record set records the position number, overwrite status flag and old and new value comparison information of each field in this writing process, and integrates them into a state array. Finally, this array is sent back to the data write-back status interface of the page display layer to update the current field status information of the main region. After the data overwrite action is completed, the page write-back structure status is formed.

[0084] The export status output submodule, based on the page write-back structure status, performs the operation of closing the export pop-up interactive area, releases the page interactive resources bound to the export task, clears the status flags and interface response flag fields set during the export process, and obtains the export process end flag data;

[0085] The system retrieves the identifier number corresponding to the current export task from the page data state control channel. This number points to the pop-up interaction area in the current export process. This number is then passed as a control parameter to the control command entry point of the page interaction container. When the pop-up closes, it iterates through all active interaction areas on the current page, searching for the bound task identifier field in each area. If the field value matches the export task number, the corresponding interaction container is set to invisible, and its interaction callback function with the main thread is terminated. The system registers the button elements, input box areas, progress bar status bars, and other layer markers bound to this number as recyclable in the page resource management channel. Elements registered with this number are removed from the resource occupancy queue according to the resource release order. The export process control flag field is reset, setting the "Exporting" status flag field to its initial state. The interface call flag field is set to null, and the "Processing" flag is deleted. The system displays intermediate status markers such as "In Progress," "Requesting," and "Waiting." It then locates the temporary status cache fields of the export task bound to the page status record area, matching the corresponding record using the export task number as the lookup key. All corresponding content is overwritten with the initial default field status, and the field values ​​corresponding to the field name, status description, and task progress are cleared. The system then iterates through the field response callback flags created during the export process, resetting the callback pointers of their corresponding response channels to null pointers, ensuring that subsequent operations do not trigger the original task interface logic. After all status fields are in place, the system outputs a process end flag through the export status control interface. This flag is a standard Boolean variable, and its value is determined by the page status flag monitoring area based on whether the current export process fields have been cleared. When the field status is the initial value, the flag is set to true. Finally, this true value is output as an indication signal that the export process has ended to the export process flag interface, forming the export process end flag data.

[0086] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in the present invention should be included within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. A cloud platform data analysis processing system based on front-end segmentation, characterized in that, The system comprises: The export request initialization module receives a page export instruction, synchronizes a search condition field, a table header field, a page number, and a data source path to a main thread rendering area in sequence, pushes them to a task processing process through an interface, and forms an export parameter input set; The data cloning isolation module writes the main area field and the entries in the buffer in order based on the page number and the field content in the export parameter input set, suspends the page data transmission action, completes the synchronization of the page track and the field structure, and forms a cloned data running state set; The page turning trigger listening module refers to the page number and the number of fields in the cloned data running state set, gradually triggers page turning, compares the fields after page turning with the previous round of data, writes the changed content into the cache, and marks the data entry state, forming a segmented data buffer content group; The data storage splitting module receives the segmented data buffer content group and available memory information, confirms the relationship between the current cache and the capacity benchmark, suspends page turning when approaching the limit, encapsulates the data as a local cache unit and clears the cache, and obtains an export cache conversion process state.

2. The front-end segmentation based cloud platform data analytics processing system of claim 1, wherein: The export parameter input set includes search condition field content, table field structure information, page number identification, and data source path markers. The cloned data running state set includes field index mapping relationships, page track sequence records, and field structure synchronization information. The segmented data buffer content group includes field arrangement change records, page index information, and cumulative entry statistics values. The export cache conversion process state includes local file cache units, page turning recovery control markers, and memory cleaning state signals.

3. The front-end segmentation based cloud platform data analytics processing system of claim 1, wherein, The export request initialization module comprises: The export instruction receiving submodule extracts the instruction type, trigger timestamp, and page identification number in the browser event binding field based on the export operation instruction triggered by the user in the page, compares the corresponding relationship between the instruction type and the page identification number, confirms the initial data range of the export request through positioning operations, transmits the page identification number and the instruction type to the subsequent process, and obtains an export request trigger data set; The parameter field extraction submodule calls the export request trigger data set, extracts the search condition field and the table header field in the page rendering cache area according to the page identification number, retrieves the input content and number distribution in the search field, analyzes the index value and front-end rendering order of the table header field, and reads the current page number, aligns each data position with the number corresponding to the field index order, and obtains a page display field set; The interface data sending submodule calls the page display field set, maps the search field, the table header field, the page number, and the data source path in the display field set into the interface field template, performs field value alignment and position allocation according to the field sequence rule, arranges the value order and field positioning rule according to the interface specification format, pushes the arrangement result into the front-end task processing channel, and obtains an export request parameter set.

4. The front-end segmentation based cloud platform data analytics processing system of claim 1, wherein, The data cloning isolation module comprises: The paging parameter reading submodule obtains the page number and the display field content in the export parameter input set, reads the field index sequence and the entry sequence under the corresponding page from the page rendering area, analyzes the mapping position of the page number in the data source, extracts the field position information and the entry value range according to the number order, performs number comparison on the mapping relationship between the page number and the field index, and obtains a page mapping index set; The field data writing submodule detects the field sequence and the entry value of the current data area in the page data rendering thread based on the page mapping index set, performs item-by-item writing action on the fields and the entries in position order, temporarily stores the writing content in the local buffer area, compares the field position and the entry quantity difference in page order, merges the positions and aligns the numbers of the writing results, and obtains a local buffer data set; The cloned track synchronization submodule calls the local buffer data set, suspends the data transmission action between the main area and the data layer in the page rendering thread, copies the page track and the field structure in the cloned area according to the original number order, performs one-to-one comparison on the page number and the field index, completes the page track synchronization and the field position arrangement action, and obtains a cloned data running state set.

5. The front-end segmentation based cloud platform data analytics processing system of claim 1, wherein, The page turning trigger listening module includes: The page turning action execution submodule triggers the page turning action in number order based on the page number order and the field quantity in the cloned data running state set, sequentially extracts the field name and the position index in the field area of the current page after each round of page turning, sequentially corresponds the field content according to the number position, and obtains a page turning field position sequence; The field order verification submodule calls the page turning field position sequence, compares the field content of the current page and the field content of the last round in number order, writes the current field name and the corresponding index into the memory cache area when the position sequence is inconsistent, completes the field content covering operation in order, and obtains a field cache mapping set; The state number labeling submodule reads the current page index value and the last page number according to the field cache mapping set, positions the state number according to the page number and the entry quantity order, appends the state number to the specified position of the cache area, and obtains a segmented data buffer content group.

6. The front-end segmentation based cloud platform data analytics processing system of claim 1, wherein, The data storage splitting module includes: The memory occupation monitoring submodule obtains each page writing item in the segmented data buffer content group and the available memory information of the current browser, performs numerical comparison on the memory usage data after each page data writing, judges the page turning sequence continuous state based on the difference interval between the current memory value and the processing capacity benchmark, obtains a page turning termination trigger signal when the memory usage is close to the processing capacity benchmark before the set data interval value, and The data transfer trigger submodule terminates the page turning action according to the page turning termination trigger signal, extracts the written data content and the corresponding index in the current segment, performs field number relocation action, writes the data item into the local file cache structure, clears the corresponding memory buffer data and releases the number occupied position, and obtains a local cache file index set; The cache state updating submodule calls the local cache file index set, recovers the page turning instruction response channel, aligns the entry number of the page continued receiving data with the last terminated number, sets a new segment starting position and a cache state identifier, synchronizes a state value to a control channel, and obtains an exported cache conversion process state.

7. The front-end segmentation based cloud platform data analytics processing system of claim 1, wherein: The system further comprises: The export ending return module pushes batch data to the local based on the last page turning structure in the exported cache conversion process state, synchronizes termination information to a page display layer, covers cloned data in a main area, closes a pop-up interface, and obtains export process end identifier data. The export process end identifier data comprises a data write-back state, a termination prompt identifier, and an interface interaction closing state.

8. The front-end segment-based cloud platform data analytics processing system of claim 7, wherein, The export ending return module comprises: A data batch pushing submodule calls the turning structure content marked as the last page in the exported cache conversion process state, extracts each page data item and a corresponding field index in the current batch, writes all fields and data into a local file area and releases the space occupied by the memory segment in the batch, and obtains a local data pushing result set. A main area write-back processing submodule synchronizes the page turning termination information to the page display layer based on the local data pushing result set, replaces the current display content in the main area, writes the cloned data content into the original page structure area item by item, covers the original field index corresponding position and the data mapping path, and obtains a page write-back structure state. An export state output submodule executes the export pop-up interface interaction area closing operation based on the page write-back structure state, releases the page interaction resources bound with the export task, clears the state identifier and interface response marker field set in the export process, and obtains the export process end identifier data.

Images