Transaction processing method, apparatus, device, storage medium, and product
By determining the type when the browser loads and adding a custom event listener for property value changes, the incompatibility issue between the browser and the onpropertychange event was resolved, ensuring the normal operation of the transaction system.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- INDUSTRIAL AND COMMERCIAL BANK OF CHINA
- Filing Date
- 2023-04-19
- Publication Date
- 2026-05-19
AI Technical Summary
Some browsers are incompatible with the onpropertychange event, causing core transaction linkage scenarios in the trading system to malfunction.
When the browser finishes loading the transaction page, determine the browser type. If it is not the default type, add a listener event for the page element. Use the listener event to determine whether a node has been added, and add a preset custom event listener attribute value change for the target node to trigger the corresponding object array linkage.
This resolves the incompatibility issue between the browser and the onpropertychange event, compensates for the missing page logic in the reverse assignment, and ensures the normal use of linked scenarios.
Smart Images
Figure CN116541625B_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of computer technology, and in particular to a transaction processing method, apparatus, device, storage medium, and product. Background Technology
[0002] Common browsers include Internet Explorer, Google Chrome, Sogou Browser, and Baidu Browser. The most important part of a browser is its kernel, which is the core of the browser. Currently, developing a new browser kernel is not only difficult but also costly. Many domestic browser vendors have not developed their own browser kernels. Since Google's Chromium kernel is open source, most domestic browsers use Google's Chromium kernel.
[0003] Currently, when users log in to certain trading systems using a browser to enter trading orders, the browser recognizes and receives user clicks on input boxes on the trading order page. For example, when a user selects "buy" as the trading direction in the input box, the browser listens for changes in page elements and triggers the "onpropertychange" event to display the trading order. For instance, three input boxes are added to the trading order page: "buy account," "buy number," and "bank information," allowing users to continue entering information.
[0004] However, the onpropertychange event is currently supported by Internet Explorer, which has limitations. This makes it incompatible with domestic browsers based on the Chromium kernel, resulting in missing page logic such as transaction order display assignment, and making the core transaction linkage scenarios in the transaction system unusable. Summary of the Invention
[0005] This application provides a transaction processing method, apparatus, device, storage medium, and product to solve the problem that some browsers are incompatible with the onpropertychange event, making it impossible to use the linked scenarios normally.
[0006] Firstly, this application provides a method for processing transactions, comprising:
[0007] When the browser finishes loading the transaction page, the browser type is determined;
[0008] If it is determined that the browser type is not the default type, then add a listener event for the page element to determine whether the node of the page element has been added.
[0009] If it is determined that a node has been added to the page element, then a target node related to the attribute change is identified among the nodes of the page element, and a preset custom event is added to the target node to listen for whether the attribute value of the target node has changed.
[0010] If a change in the attribute value is detected, the corresponding object array of the target node whose attribute value has changed will be triggered.
[0011] Optionally, adding a listener event for a page element to determine whether a node of the page element has been added includes:
[0012] Add the listener event to the Document Object Model (DOM) node tree corresponding to the page element;
[0013] The listener event is used to monitor whether the number of nodes corresponding to the DOM node tree has changed;
[0014] If a change in the number of nodes is detected, it is determined that the number of nodes for the page element has increased.
[0015] If the number of nodes is not detected to have changed, it is determined that the number of nodes for the page element has not increased.
[0016] Optionally, determining the target node related to the attribute change among the nodes of the page element includes:
[0017] The nodes of the DOM node tree corresponding to the page element are recursively traversed using a depth-first search algorithm.
[0018] Nodes in the DOM node tree that are elements and have an onpropertychange event are identified as target nodes related to property changes.
[0019] Optionally, the array of objects corresponding to the target node that triggers the change in the attribute value includes:
[0020] Obtain the attribute value corresponding to the target node whose attribute value has changed;
[0021] The corresponding attribute value is destructured, and an array of Function objects that trigger the onpropertychange event are extracted from the corresponding attribute value.
[0022] Optionally, it also includes:
[0023] If the browser type is determined to be the default type, then the onpropertychange event is triggered, along with the array of Function objects corresponding to the onpropertychange event.
[0024] Optionally, determining the browser type includes:
[0025] Obtain the browser's kernel version;
[0026] The browser type is determined based on the browser's kernel version.
[0027] Optionally, determining the browser type based on the browser's kernel version includes:
[0028] If it is determined that the browser's kernel is not an IE kernel and is a Chromium kernel, then it is determined that the browser's type is not the default type.
[0029] If the browser's kernel is determined to be the IE kernel, then the browser's type is determined to be the default type.
[0030] Secondly, this application provides a transaction processing apparatus, comprising:
[0031] The determining unit is used to determine the type of the browser when the browser finishes loading the transaction page;
[0032] An add unit is used to add a listener event for a page element if it is determined that the browser type is not the default type, so as to use the listener event to determine whether the node of the page element has been added;
[0033] The determining unit is further configured to, if it is determined that an additional node has been added to the page element, determine a target node among the nodes of the page element that is related to the attribute change;
[0034] The addition unit is also used to add a preset custom event to the target node, so as to use the preset custom event to listen for whether the attribute value of the target node has changed;
[0035] The processing unit is used to trigger the object array corresponding to the target node whose attribute value has changed if a change in the attribute value is detected.
[0036] Thirdly, this application provides an electronic device, including: a processor, a memory, and a transceiver;
[0037] Interconnection of processor, memory, and transceiver circuits;
[0038] The memory stores the instructions that the computer executes;
[0039] A transceiver is used to send and receive data.
[0040] The processor executes computer execution instructions stored in memory, causing the processor to perform the method described in the first aspect.
[0041] Fourthly, this application provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, are used to implement the method described in the first aspect.
[0042] Fifthly, this application provides a computer program product, including a computer program that, when executed by a processor, implements the method described in the first aspect.
[0043] The transaction processing method, apparatus, device, storage medium, and product provided in this application determine the browser type when the browser finishes loading the transaction page. If the browser type is not the default type, a listener event is added to the page element to determine whether a node of the page element has been added. If a node of the page element has been added, a target node related to the attribute change is identified among the nodes of the page element, and a preset custom event is added to the target node to listen for changes in the attribute value of the target node. If a change in the attribute value is detected, the corresponding object array of the target node with the changed attribute value is triggered. By using the listener event and the preset custom event to link the corresponding object array, the incompatibility between the browser and the onpropertychange event is effectively solved, the lack of page logic for reverse assignment is compensated, and the normal use of linked scenarios is ensured. Attached Figure Description
[0044] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.
[0045] Figure 1 A schematic diagram of the network architecture for the transaction processing method provided in this application;
[0046] Figure 2 A flowchart illustrating a transaction processing method provided in this application;
[0047] Figure 3 A flowchart illustrating another transaction processing method provided in this application;
[0048] Figure 4 A schematic diagram of the structure of a transaction processing device provided in this application;
[0049] Figure 5 A first block diagram of an electronic device used to implement the transaction processing method of this application;
[0050] Figure 6 This is a second block diagram of an electronic device used to implement the transaction processing method of this application.
[0051] The accompanying drawings illustrate specific embodiments of this application, which will be described in more detail below. These drawings and descriptions are not intended to limit the scope of the concept in any way, but rather to illustrate the concept of this application to those skilled in the art through reference to particular embodiments. Detailed Implementation
[0052] Exemplary embodiments will now be described in detail, examples of which are illustrated in the accompanying drawings. When the following description relates to the drawings, unless otherwise indicated, the same numbers in different drawings denote the same or similar elements. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with this application. Rather, they are merely examples of apparatuses and methods consistent with some aspects of this application as detailed in the appended claims.
[0053] It should be noted that the processing methods, apparatus, equipment, storage media, and products described in this application can be used in the financial field, and also in any field other than finance. The application areas of the processing methods, apparatus, equipment, storage media, and products described in this application are not limited.
[0054] To clearly understand the technical solution of this application, the solutions of the prior art will be described in detail first.
[0055] Currently, developing a new browser kernel is not only difficult but also costly. Many domestic browser manufacturers have not developed their own browser kernels, while Google's Chromium kernel is open source, and most domestic browsers use Google's Chromium kernel.
[0056] Currently, when users log into certain trading systems using a browser to enter trading orders, clicking on an input box on the trading order page (e.g., selecting "buy") triggers the `onpropertychange` event, which in turn displays the trade order value. For example, the trading order page might have three input boxes: "buy account," "buy number," and "bank information." However, the `onpropertychange` event is currently only supported by Internet Explorer, which has limitations. This makes it incompatible with domestically developed Chromium-based browsers, resulting in missing page logic such as trade order value display and rendering core trading-related scenarios unusable.
[0057] Therefore, addressing the issue of incompatibility between some browsers and the `onpropertychange` event in existing technologies, which prevents the proper use of linked scenarios, the inventors discovered in their research that when the browser completes the loading of the transaction page, the browser type is determined. If the browser type is not the default type, a listener event is added to the page element. This listener event is used to determine whether a node of the page element has been added. If a node has been added, the target node related to the property change is identified within the page element's nodes, and a preset custom event is added to the target node. This custom event listens for changes in the target node's property value. If a change in property value is detected, the corresponding object array of the target node with the changed property value is triggered. By using the listener event and the preset custom event, the corresponding object array is linked, effectively solving the incompatibility problem between the browser and the `onpropertychange` event, compensating for the missing page logic of the reverse assignment, and ensuring the normal use of linked scenarios.
[0058] Therefore, based on the above-mentioned inventive discovery, the inventors proposed the technical solution of the embodiments of this application. The network architecture and application scenarios of the transaction processing method provided in the embodiments of this application are described below.
[0059] like Figure 1 As shown, the network architecture corresponding to the transaction processing method provided in this application embodiment includes: Terminal 1. If the page loads completely, Terminal 1 determines the browser type. If the browser type is determined to be Internet Explorer, the onpropertychange event is triggered, linking the corresponding Function object array. If the browser type is determined to be a Chromium-based browser, a listener event for the page element is added to determine whether a node of the page element has been added. If a node of the page element is added, a target node related to the attribute change is determined among the nodes of the page element, and a preset custom event is added to the target node to listen for changes in the attribute value of the target node. If a change in the attribute value is detected, the object array corresponding to the target node whose attribute value has changed is triggered. By using listener events and preset custom events to link the corresponding object array, the incompatibility problem between the browser and the onpropertychange event is effectively solved, the lack of page logic for reverse assignment is compensated, and the normal use of the linked scenario is ensured.
[0060] The embodiments of this application will now be described in detail with reference to the accompanying drawings.
[0061] Figure 2This application provides a flowchart illustrating a transaction processing method applied to an electronic device. The electronic device can be a digital computer of various forms, such as a cellular phone, smartphone, laptop computer, desktop computer, workstation, personal digital assistant, server, blade server, mainframe computer, and other suitable computers. Figure 2 As shown, the method includes:
[0062] Step 201: When the browser finishes loading the transaction page, determine the browser type.
[0063] In this embodiment, when the browser finishes loading the transaction page, the browser type is determined. The browser type is divided into default type and non-default type. The default type is a browser that uses the IE kernel, such as Internet Explorer. The non-default type is a browser that does not use the IE kernel, such as a browser that uses the Chromium kernel.
[0064] Step 202: If it is determined that the browser type is not the default type, add a listener event for the page element to determine whether the page element node has been added.
[0065] In this embodiment, if it is determined that the browser type is not the default type, a listener event is added to the page element, such as the DOMNodeInserted event. This DOMNodeInserted event is used to listen for node insertion in the Document Object Model (DOM) node tree to determine if a node has been added to the page element. For example, if a user selects "buy" as the trading direction in an input box on the page, it triggers a change in the page element.
[0066] Step 203: If it is determined that a node of a page element has been added, then the target node related to the attribute change is identified in the node of the page element, and a preset custom event is added to the target node to listen for whether the attribute value of the target node has changed.
[0067] In this embodiment, if it is determined that a node of a page element has been added, the target node related to the attribute change is identified among the nodes of the page element. The nodes of the page element are the nodes in the DOM node tree corresponding to the page element. The nodes in the DOM node tree are recursively traversed to find the target node related to the attribute change. A preset custom event is added to the target node, such as adding a DOMAttrModified event. The DOMAttrModified event is used to listen for whether the attribute value of the target node has changed. The DOMAttrModified event is used instead of the onpropertychange event.
[0068] Step 204: If a change in attribute value is detected, trigger the object array corresponding to the target node whose attribute value has changed.
[0069] In this embodiment, if a change in attribute value is detected, the object array corresponding to the target node whose attribute value has changed is triggered to initiate corresponding actions, such as showing / hiding, value change, or pop-up. The object array is determined by the array of Function objects corresponding to the onpropertychange event of the target node. The onpropertychange event is specific to Internet Explorer and is used to listen for changes in attribute values. As the name suggests, the onpropertychange event is triggered when the property (attribute) changes. The array of Function objects corresponding to the onpropertychange event is then extracted.
[0070] This application determines the browser type when the browser finishes loading the transaction page. If the browser type is not the default type, it adds a listener event for the page element. The listener event is used to determine if a node has been added to the page element. If a node has been added, the target node related to the attribute change is identified within the page element's nodes, and a preset custom event is added to the target node. The custom event is used to listen for changes in the target node's attribute value. If a change in the attribute value is detected, the corresponding object array of the target node with the changed attribute value is triggered. By using the listener event and the preset custom event to trigger the corresponding object array, this effectively solves the incompatibility problem between the browser and the onpropertychange event, compensates for the lack of page logic for reverse assignment, and ensures the normal use of the linked scenarios.
[0071] Figure 3 A flowchart illustrating another transaction processing method provided in this application, which is applied to electronic devices, such as... Figure 3 As shown, the method includes:
[0072] Step 301: When the browser finishes loading the transaction page, determine the browser type.
[0073] In one possible implementation, determining the browser type includes:
[0074] Obtain the browser's kernel version; determine the browser type based on the browser's kernel version.
[0075] In this embodiment, when the browser finishes loading the transaction page, the browser's kernel version is obtained. The kernel version is divided into non-IE kernel and IE kernel. The browser type is determined based on the browser's kernel version, and the appropriate events are determined based on the browser type, thereby triggering the corresponding linked object array.
[0076] Optionally, the browser type can be determined based on the browser's kernel version, including:
[0077] If it is determined that the browser's kernel is not the IE kernel and is the Chromium kernel, then the browser's type is not the default type; if it is determined that the browser's kernel is the IE kernel, then the browser's type is the default type.
[0078] In this embodiment, if it is determined that the browser's kernel is not an IE kernel and is a Chromium kernel, it means the user is not using an IE browser. Therefore, the browser type is determined to be not the default type. Further, if a property change is detected, the corresponding object array of the target node whose property value has changed is triggered. If it is determined that the browser's kernel version is an IE kernel, it means the user is using an IE browser. The browser type is determined to be the default type. Further, if a property change is detected, the onpropertychange event is triggered, triggering the corresponding Function object array of the onpropertychange event.
[0079] Step 302: If it is determined that the browser type is the default type, then the onpropertychange event is triggered, along with the array of Function objects corresponding to the onpropertychange event.
[0080] In this embodiment, if it is determined that the browser type is the default type, indicating that the user is using Internet Explorer, then the onpropertychange event is triggered, along with the array of Function objects corresponding to the onpropertychange event.
[0081] Step 303: If it is determined that the browser type is not the default type, add a listener event for the page element to determine whether the page element node has been added.
[0082] In one possible implementation, listener events for page elements are added to determine whether a node of a page element has been added, including:
[0083] Add event listeners to the Document Object Model (DOM) node tree corresponding to the page element; use these event listeners to monitor whether the number of nodes in the DOM node tree changes; if a change in the number of nodes is detected, then the page element's nodes have been added; if no change in the number of nodes is detected, then the page element's nodes have not been added.
[0084] In this embodiment, if it is determined that the browser type is not the default type, for example, if it is determined that the browser is not a browser using the IE kernel but a browser using the Chromium kernel, then a listener event is added to the DOM node tree corresponding to the page element. The listener event is used to listen for whether the number of nodes corresponding to the DOM node tree has changed. If a change in the number of nodes is detected, such as the insertion of new nodes that causes the number of nodes to change, then it is determined that the number of nodes of the page element has increased; if no change in the number of nodes is detected, then it is determined that the number of nodes of the page element has not increased.
[0085] Step 304: If it is determined that a node of a page element has been added, then the target node related to the attribute change is identified in the node of the page element, and a preset custom event is added to the target node to listen for whether the attribute value of the target node has changed.
[0086] In one possible implementation, the target node related to the attribute change is identified within the nodes of the page element, including:
[0087] A depth-first search algorithm is used to recursively traverse the nodes of the DOM node tree corresponding to the page elements; nodes in the DOM node tree that are elements and have an onpropertychange event are identified as target nodes related to property changes.
[0088] In this embodiment, a depth-first search algorithm is used to recursively traverse the nodes of the DOM node tree corresponding to the page elements. During the traversal, nodes that are elements and have an `onpropertychange` event are selected from the nodes of the DOM node tree. These nodes are identified as target nodes related to property changes. A preset custom event is added to the target nodes, such as a `DOMAttrModified` event. The `DOMAttrModified` event is used to listen for changes in the corresponding property value of the target node, replacing the `onpropertychange` event.
[0089] Step 305: If a change in attribute value is detected, trigger the object array corresponding to the target node whose attribute value has changed.
[0090] In this embodiment, if a change in an attribute value is detected, the object array corresponding to the target node whose attribute value has changed is triggered to initiate corresponding actions, such as showing / hiding, value change, or pop-up. The object array is determined by the array of Function objects corresponding to the onpropertychange event of the target node. The onpropertychange event is specific to Internet Explorer and is used to listen for changes in attribute values. As the name suggests, the onpropertychange event is triggered when the property (attribute) changes.
[0091] Optionally, the array of objects corresponding to the target node that triggered the change in the linked attribute value includes:
[0092] Get the attribute value corresponding to the target node whose attribute value has changed; destructure the corresponding attribute value, extract the array of Function objects that trigger the onpropertychange event from the corresponding attribute value.
[0093] In this embodiment, if a change in attribute value is detected, the attribute value corresponding to the target node whose attribute value has changed is further obtained, the corresponding attribute value is destructured according to the semicolon, and an array of Function objects that trigger the onpropertychange event is extracted from the corresponding attribute value.
[0094] This application employs event listeners and preset custom events to link corresponding object arrays, providing a replacement solution for the onpropertychange event. This effectively solves the incompatibility issue between the browser and the onpropertychange event, compensates for the lack of page logic in the reverse assignment, and ensures the normal use of linked scenarios.
[0095] Figure 4 A schematic diagram of a transaction processing apparatus provided in this application is shown below. Figure 4 As shown, the browser processing device 400 provided in this embodiment includes a determining unit 401, an adding unit 402, and a processing unit 403.
[0096] The determination unit 401 is used to determine the browser type when the browser completes the loading of the transaction page. The addition unit is used to add a listener event for the page element if the browser type is not the default type, so as to use the listener event to determine whether a node of the page element has been added. The determination unit 401 is also used to identify the target node related to the attribute change among the nodes of the page element if an addition of a page element node is detected. The addition unit 402 is also used to add a preset custom event to the target node, so as to use the preset custom event to listen for whether the attribute value of the target node has changed. The processing unit 403 is used to trigger the array of objects corresponding to the target node whose attribute value has changed if a change in attribute value is detected.
[0097] Optionally, the addition unit 402 is also used to add listener events to the Document Object Model (DOM) node tree corresponding to the page element; listen for changes in the number of nodes in the DOM node tree; if a change in the number of nodes is detected, it is determined that the page element has added nodes; if no change in the number of nodes is detected, it is determined that the page element has not added nodes.
[0098] Optionally, the determining unit 403 is further configured to recursively traverse the nodes of the DOM node tree corresponding to the page element using a depth-first algorithm; and determine the nodes in the DOM node tree that are elements and have an onpropertychange event as the target nodes related to the property change.
[0099] Optionally, the processing unit 403 is also used to obtain the attribute value corresponding to the target node whose attribute value has changed; deconstruct the corresponding attribute value, and extract and trigger the array of Function objects linked by the onpropertychange event from the corresponding attribute value.
[0100] Optionally, the processing unit 403 is also configured to, if it is determined that the browser type is the default type, trigger the onpropertychange event and link the array of Function objects corresponding to the onpropertychange event.
[0101] Optionally, the determining unit 403 is also used to obtain the browser's kernel version; and to determine the browser type based on the browser's kernel version.
[0102] Optionally, the determining unit 403 is further configured to determine that the browser type is not the default type if it is determined that the browser's kernel is not an IE kernel and is a Chromium kernel; and to determine that the browser's type is the default type if it is determined that the browser's kernel is an IE kernel.
[0103] Figure 5 A first block diagram of an electronic device for implementing the transaction processing method of this application, as shown below. Figure 5 As shown, the electronic device 500 includes: a memory 501, a processor 502, and a transceiver 503.
[0104] The processor 502, memory 501, and transceiver 503 are interconnected;
[0105] Transceiver 503 is used for sending and receiving data;
[0106] Memory 501 stores computer-executed instructions;
[0107] The processor 502 executes computer execution instructions stored in the memory 501, causing the processor 502 to perform the method provided in any of the above embodiments.
[0108] Figure 6 A second block diagram of an electronic device used to implement the transaction processing method of this application, as shown below. Figure 6 As shown, the electronic device can be a computer, digital broadcasting terminal, messaging device, tablet device, personal digital assistant, server, server cluster, etc.
[0109] Electronic device 800 may include one or more of the following components: processing component 802, memory 804, power supply component 806, multimedia component 808, audio component 810, input / output (I / O) interface 812, sensor component 814, and communication component 816.
[0110] Processing component 802 typically controls the overall operation of electronic device 800, such as operations associated with display, telephone calls, data communication, camera operation, and recording operations. Processing component 802 may include one or more processors 820 to execute instructions to complete all or part of the steps of the methods described above. Furthermore, processing component 802 may include one or more modules to facilitate interaction between processing component 802 and other components. For example, processing component 802 may include a multimedia module to facilitate interaction between multimedia component 808 and processing component 802.
[0111] Memory 804 is configured to store various types of data to support the operation of electronic device 800. Examples of this data include instructions for any application or method operating on electronic device 800, contact data, phonebook data, messages, pictures, videos, etc. Memory 804 can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk.
[0112] Power supply component 806 provides power to various components of electronic device 800. Power supply component 806 may include a power management system, one or more power supplies, and other components associated with generating, managing, and distributing power to electronic device 800.
[0113] Multimedia component 808 includes a screen that provides an output interface between electronic device 800 and user. In some embodiments, the screen may include a liquid crystal display (LCD) and a touch panel (TP). If the screen includes a touch panel, the screen may be implemented as a touchscreen to receive input signals from the user. The touch panel includes one or more touch sensors to sense touches, swipes, and gestures on the touch panel. The touch sensors may sense not only the boundaries of touch or swipe actions but also the duration and pressure associated with the touch or swipe operation. In some embodiments, multimedia component 808 includes a front-facing camera and / or a rear-facing camera. When electronic device 800 is in an operating mode, such as a shooting mode or video mode, the front-facing camera and / or rear-facing camera may receive external multimedia data. Each front-facing camera and rear-facing camera may be a fixed optical lens system or have focal length and optical zoom capabilities.
[0114] Audio component 810 is configured to output and / or input audio signals. For example, audio component 810 includes a microphone (MIC) configured to receive external audio signals when electronic device 800 is in an operating mode, such as call mode, recording mode, and voice recognition mode. The received audio signals may be further stored in memory 804 or transmitted via communication component 816. In some embodiments, audio component 810 also includes a speaker for outputting audio signals.
[0115] I / O interface 812 provides an interface between processing component 802 and peripheral interface modules, such as keyboards, click wheels, buttons, etc. These buttons may include, but are not limited to, home buttons, volume buttons, power buttons, and lock buttons.
[0116] Sensor assembly 814 includes one or more sensors for providing state assessments of various aspects of electronic device 800. For example, sensor assembly 814 can detect the on / off state of electronic device 800, the relative positioning of components such as the display and keypad of electronic device 800, changes in position of electronic device 800 or a component of electronic device 800, the presence or absence of user contact with electronic device 800, orientation or acceleration / deceleration of electronic device 800, and temperature changes of electronic device 800. Sensor assembly 814 may include a proximity sensor configured to detect the presence of nearby objects without any physical contact. Sensor assembly 814 may also include a light sensor, such as a CMOS or CCD image sensor, for use in imaging applications. In some embodiments, sensor assembly 814 may also include an accelerometer, gyroscope, magnetometer, pressure sensor, or temperature sensor.
[0117] Communication component 816 is configured to facilitate wired or wireless communication between electronic device 800 and other devices. Electronic device 800 can access wireless networks based on communication standards, such as WiFi, 2G, or 3G, or combinations thereof. In one exemplary embodiment, communication component 816 receives broadcast signals or broadcast-related information from an external broadcast management system via a broadcast channel. In one exemplary embodiment, communication component 816 also includes a near-field communication (NFC) module to facilitate short-range communication. For example, the NFC module may be implemented based on radio frequency identification (RFID) technology, Infrared Data Association (IrDA) technology, ultra-wideband (UWB) technology, Bluetooth (BT) technology, and other technologies.
[0118] In an exemplary embodiment, the electronic device 800 may be implemented by one or more application-specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field-programmable gate arrays (FPGAs), controllers, microcontrollers, microprocessors, or other electronic components to perform the methods described above.
[0119] In an exemplary embodiment, a non-transitory computer-readable storage medium including instructions is also provided, such as a memory 804 including instructions, which can be executed by a processor 820 of an electronic device 800 to perform the above-described method. For example, the non-transitory computer-readable storage medium may be a ROM, random access memory (RAM), CD-ROM, magnetic tape, floppy disk, and optical data storage device, etc.
[0120] In an exemplary embodiment, a computer-readable storage medium is also provided, which stores computer-executable instructions that are executed by a processor using the methods in any of the above embodiments.
[0121] In an exemplary embodiment, a computer program product is also provided, including a computer program that is executed by a processor using the methods of any of the above embodiments.
[0122] Other embodiments of this application will readily occur to those skilled in the art upon consideration of the specification and practice of the invention disclosed herein. This application is intended to cover any variations, uses, or adaptations of this application that follow the general principles of this application and include common knowledge or customary techniques in the art not disclosed herein. The specification and examples are to be considered exemplary only, and the true scope and spirit of this application are indicated by the following claims.
[0123] It should be understood that this application is not limited to the precise structure described above and shown in the accompanying drawings, and various modifications and changes can be made without departing from its scope. The scope of this application is limited only by the appended claims.
Claims
1. A method for processing transactions, characterized in that, The method includes: When the browser finishes loading the transaction page, the browser type is determined; If it is determined that the browser type is not the default type, then add a listener event for the page element to determine whether the node of the page element has been added. If it is determined that a node has been added to the page element, then a depth-first search algorithm is used to recursively traverse the nodes of the DOM node tree corresponding to the page element. Nodes in the DOM node tree that are elements and have an onpropertychange event are identified as target nodes related to property changes; And add a preset custom event to the target node, so as to use the preset custom event to listen for whether the attribute value of the target node changes; If a change in the attribute value is detected, then obtain the attribute value corresponding to the target node whose attribute value has changed; The corresponding property value is destructured based on the semicolon, and an array of Function objects that trigger the onpropertychange event are extracted from the corresponding property value.
2. The method according to claim 1, characterized in that, The method of adding a page element listener event, used to determine whether a node of the page element has been added, includes: Add the listener event to the Document Object Model (DOM) node tree corresponding to the page element; The listener event is used to monitor whether the number of nodes corresponding to the DOM node tree has changed; If a change in the number of nodes is detected, it is determined that the number of nodes for the page element has increased. If the number of nodes is not detected to have changed, it is determined that the number of nodes for the page element has not increased.
3. The method according to claim 1, characterized in that, Also includes: If the browser type is determined to be the default type, the onpropertychange event is triggered, along with the array of Function objects corresponding to the onpropertychange event.
4. The method according to any one of claims 1 to 3, characterized in that, Determining the browser type includes: Obtain the browser's kernel version; The browser type is determined based on the browser's kernel version.
5. The method according to claim 4, characterized in that, Determining the browser type based on the browser's kernel version includes: If it is determined that the browser's kernel is not an IE kernel and is a Chromium kernel, then it is determined that the browser's type is not the default type. If the browser's kernel is determined to be the IE kernel, then the browser's type is determined to be the default type.
6. A transaction processing apparatus, characterized in that, The device includes: The determining unit is used to determine the type of the browser when the browser finishes loading the transaction page; An add unit is used to add a listener event for a page element if it is determined that the browser type is not the default type, so as to use the listener event to determine whether the node of the page element has been added; The determining unit is further configured to, if it is determined that an additional node has been added to the page element, determine a target node among the nodes of the page element that is related to the attribute change; The addition unit is also used to add a preset custom event to the target node, so as to use the preset custom event to listen for whether the attribute value of the target node has changed; The processing unit is used to trigger the object array corresponding to the target node whose attribute value has changed if a change in the attribute value is detected. The determining unit is specifically used to recursively traverse the nodes of the DOM node tree corresponding to the page element using a depth-first algorithm; Nodes in the DOM node tree that are elements and have an onpropertychange event are identified as target nodes related to property changes; The processing unit is specifically used to obtain the attribute value corresponding to the target node whose attribute value has changed. The corresponding property value is destructured based on the semicolon, and an array of Function objects that trigger the onpropertychange event are extracted from the corresponding property value.
7. An electronic device, comprising: Processor, memory, and transceiver; Interconnection of processor, memory, and transceiver circuits; A transceiver is used to send and receive data. The memory stores computer-executed instructions; The processor executes computer execution instructions stored in the memory, causing the processor to perform the method as described in any one of claims 1 to 5.
8. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-executable instructions, which, when executed by a processor, are used to implement the method as described in any one of claims 1 to 5.
9. A computer program product comprising a computer program that, when executed by a processor, implements the method of any one of claims 1 to 5.