Tagged articles
event handling
50 articles · Page 1 of 1
This article explains the core differences between debounce and throttle, provides hand-written implementations for both including immediate-execute and cancellable versions, compares timestamp vs timer-based throttling, maps each technique to common high-frequency scenarios like search suggestions and scroll loading, and demonstrates Vue 3 integration using VueUse or custom composables with cleanup.
JavaScriptVue 3VueUse
0 likes · 8 min read

This article explains the two core SpringBoot extension points—ApplicationContextInitializer for pre‑startup configuration and ApplicationListener for post‑event handling—detailing their purpose, execution timing, source code, registration methods, ordering control, common use cases, and a side‑by‑side comparison to help developers master SpringBoot's flexible extension mechanism.
ConfigurationJavaSpringBoot
0 likes · 31 min read

This guide explains what PHP callbacks are, shows how to define them using anonymous functions or function name strings, demonstrates their implementation as function parameters and class methods, and outlines common scenarios such as event handling, asynchronous processing, and array sorting or filtering.
CallbackClass MethodPHP
0 likes · 4 min read

This article explains how forgetting to remove event listeners can cause memory leaks, demonstrates proper listener cleanup, addresses closure pitfalls in loops, introduces event delegation, and provides practical debounce, throttle, naming conventions, and debugging techniques for robust frontend development.
Memory Leakdebounceevent delegation
0 likes · 16 min read

This article explains the fundamentals of DOM events, compares three ways to attach listeners, shows how to add and remove handlers, details event bubbling and capturing phases, and provides practical tips and common pitfalls for robust frontend interaction design.
DOMEvent PropagationFrontend Development
0 likes · 8 min read

This guide explains the purpose and naming rules of local variables, walks through creating a calculator page with named inputs and button click events, shows how to combine logical conditions using && and ||, and contrasts local variables with global variables for cross‑page data sharing.
event handlingfrontendglobal variables
0 likes · 3 min read

This guide explains how to create a login and success page in Axure, define global variables for username and password, bind them to input fields, configure button click events, and control action order so that variable assignment occurs before page navigation.
Axureevent handlingglobal variables
0 likes · 3 min read

This article explains PyQt5's event system, covering both high‑level signal‑slot mechanisms and low‑level event handling, lists common event types, demonstrates five event‑processing techniques, and provides step‑by‑step examples of implementing custom event filters and timers using QTimer and timerEvent.
PyQt5Python GUITimers
0 likes · 10 min read

This article provides a step‑by‑step guide to using PyQt5 for Python GUI development, covering installation, designer integration, converting .ui files to Python code, basic window structure, QObject concepts, event handling, signal‑slot mechanisms, common widget methods, and practical examples with full code snippets.
GUIPyQt5Qt
0 likes · 19 min read

This article dissects Linux’s inotify mechanism, detailing the kernel data structures, system‑call flow, and functions that generate and deliver file‑system event notifications, complete with code walkthroughs and diagrams. It explains how read/write operations trigger event creation, how events are queued in inotify_device, and how user‑space processes retrieve them via read and poll interfaces.
File MonitoringLinux kernelevent handling
0 likes · 14 min read

Chrome’s newly announced Observable API lets developers handle asynchronous UI events declaratively, offering built‑in filtering, mapping and composition that simplify code, improve readability, and may eventually replace third‑party libraries like RxJS as a native web standard.
ChromeWeb APIevent handling
0 likes · 8 min read

This article provides comprehensive examples of APScheduler's advanced features including database storage, multi-threading/multi-processing, event listeners, dynamic task management, external event triggers, priority settings, logging, advanced triggers, and timezone support.
APSchedulerCron TriggersDatabase Storage
0 likes · 6 min read

This article explains how to create an input element that sticks to the on‑screen keyboard by listening to visualViewport resize/scroll and focus events, calculating the keyboard’s top position, and dynamically adjusting the input’s CSS transform, with full TypeScript code examples.
JavaScriptKeyboardevent handling
0 likes · 9 min read

Learn how Spring Boot 2.7.16 leverages ApplicationEvent and ApplicationListener for synchronous event handling, then explore two asynchronous approaches—using @Async with @EventListener and custom thread pools with a bespoke ApplicationEventMulticaster—complete with code examples and configuration details.
JavaSpring Bootapplicationlistener
0 likes · 5 min read


政采云技术Jan 30, 2024 · Cloud Native
This article explains the internal workflow of the Kubernetes informer package in client-go, covering its architecture, key components such as Reflector, DeltaFIFO, and Indexer, and provides a step‑by‑step code example that demonstrates how informers are created, registered, started, and used to handle watch events efficiently.
ControllerDeltaFIFOGo
0 likes · 19 min read

This article explains Spring’s event mechanism, covering its observer‑based design, benefits such as decoupling and asynchronous handling, standard framework events, and advanced generic event techniques using subclassing or ResolvableTypeProvider to achieve type‑safe, flexible event publishing.
Generic TypesJavaObserver Pattern
0 likes · 7 min read

This article explains PHP closure functions, covering their definition, syntax, typical use cases such as event handling, asynchronous programming and functional programming, provides code examples, discusses advantages, cautions, and demonstrates how closures improve code clarity and flexibility.
PHPbackend developmentclosure
0 likes · 4 min read

This article explains PHP callback functions, covering their definition, types such as regular, anonymous, and static methods, typical use cases like event handling, asynchronous and functional programming, and provides clear code examples with important precautions and advantages.
BackendPHPevent handling
0 likes · 5 min read

This article explains PHP closure functions, covering their definition, typical use cases such as event handling, asynchronous and functional programming, detailed syntax examples, usage patterns, precautions, advantages, and a practical example of handling asynchronous results.
BackendPHPclosure
0 likes · 4 min read

This article analyses the LeaferJS canvas rendering engine, covering its lightweight node creation, core architecture, rendering pipeline, partial‑render optimization, and event‑picking mechanism, while providing code examples and performance insights for front‑end developers.
Canvas RenderingFrontend DevelopmentJavaScript
0 likes · 14 min read

This article explains the Observer and Publish‑Subscribe design patterns, compares their concepts and implementations, and provides ten practical Python code examples ranging from simple event notification to distributed messaging with libraries such as pubsub, redis, asyncio, Flask, threading, ZeroMQ, and PySide2.
Observer PatternPublish‑Subscribeevent handling
0 likes · 11 min read

To globally block all user interactions—including touches, motion, remote control, and press events—developers can subclass UIApplication and override its sendEvent: method, providing a disableUserInteraction: API with timed re‑enabling and a counter to safely manage concurrent disable requests.
Objective-C++SWIFTUIApplication
0 likes · 8 min read

This article details how to integrate Gaode (AMap) maps into a React frontend, covering script and npm imports, reusable map hooks, responsive marker info windows, event handling strategies, rendering abstractions for various map entities, and addressing common pitfalls such as marker overlap, bubble penetration, and memory leaks.
AmapMap HooksReact
0 likes · 18 min read

This article explains the concepts, differences, and implementation approaches of the Observer and Publish‑Subscribe design patterns, and provides ten practical Python code examples covering GUI, networking, asynchronous, and distributed scenarios.
Asynchronous ProgrammingObserver PatternPublish‑Subscribe
0 likes · 11 min read


ByteFEApr 12, 2023 · Frontend Development
This article details the background, problems, and comprehensive refactoring plan for the xGis web‑based 3D map library, covering event classification, API design, layer interaction proxy, CPU/GPU picking implementations, performance trade‑offs, and future optimization directions.
3D mappingCPUGPU
0 likes · 22 min read

This article explains the newly supported scrollend event, how it replaces unreliable timer‑based scroll‑stop detection, shows practical code examples, lists the conditions under which it fires, discusses browser support, and provides a polyfill for broader compatibility.
JavaScriptWeb APIevent handling
0 likes · 5 min read

This article explains Kraken’s three‑layer event channel, detailing how event registration on the JS side is translated into Flutter commands, how those commands travel through the C++ engine, and how pointer events are finally dispatched back to JavaScript callbacks.
FFIFlutterJavaScript
0 likes · 12 min read

This article explains the fundamental differences between JavaScript throttle and debounce techniques using an intuitive real-world analogy, provides clear code implementations, compares their execution behaviors, and demonstrates practical usage scenarios with the Lodash library for optimizing frontend event handling.
Frontend DevelopmentJavaScriptdebounce
0 likes · 7 min read

This article explains React's event system, covering how onClick events are delegated to the document, processed through synthetic events, and handled via the fiber architecture, plugin registry, and priority-based dispatching in React 16.13.1.
FiberJavaScriptReact
0 likes · 10 min read


政采云技术Oct 12, 2021 · Frontend Development
This article explains the concepts of debouncing and throttling in frontend development, their differences, practical applications, and provides detailed analysis of Lodash's implementation with code examples.
Frontend OptimizationUser Experiencedebouncing
0 likes · 15 min read

KonvaJS is a TypeScript‑based Canvas framework offering concise APIs and React/Vue bindings, built on a hierarchical Stage‑Layer‑Group‑Shape tree that manages DOM containers, batch rendering via requestAnimationFrame, off‑screen caching, color‑key hit detection, drag handling, filters, selectors, serialization, yet lacks dirty‑rectangle optimization for large‑scale shape updates.
Architecture DesignCanvas frameworkFilters
0 likes · 19 min read

Flutter determines which widget handles a pointer by converting raw data into PointerEvents, hit‑testing the widget tree, and routing events through a GestureArena where recognizers compete, as illustrated by an image viewer that resolves conflicts between pinch‑zoom and horizontal drag using custom recognizers and boundary‑aware scrolling.
FlutterGestureArenaconflict resolution
0 likes · 8 min read

This article explains the concepts of debounce and throttle in JavaScript, illustrates their principles and typical use cases such as button submissions, search suggestions, window resize, and drag‑and‑drop, and provides practical implementations with code examples and options for immediate execution, timestamps, and timers.
JavaScriptdebounceevent handling
0 likes · 7 min read

This tutorial walks you through installing pyglet, creating windows, adding text and images, handling keyboard and mouse events, processing input, and playing audio and video, providing a comprehensive guide to building lightweight Python games and multimedia applications.
Pythonaudioevent handling
0 likes · 15 min read


ByteFEApr 19, 2021 · Frontend Development
This guide covers the essential TypeScript knowledge for React development, demonstrating how to import React, declare functional components with React.FC, use core hooks such as useState, useRef, useEffect, useMemo, create custom hooks, handle defaultProps, choose between type and interface, type props, manage forms and events, work with operators, and apply generic patterns for reusable components.
PropsReactTypeScript
0 likes · 23 min read

This article walks through creating a Java Swing‑based exam application that displays driving‑license questions, handles timing, records answers, calculates scores, and shows result icons, providing complete code snippets and UI design guidance.
Exam SystemGUIJava
0 likes · 9 min read

The Android input subsystem, built on the Linux kernel, abstracts devices with input_dev structures, handlers with input_handler callbacks, and bridges them via input_handle, initializing core services, registering devices and handlers, matching them, transmitting events through buffers, and delivering them to user space via evdev and the InputFlinger framework.
AndroidInput Subsystemdevice drivers
0 likes · 10 min read


JavaEdgeSep 1, 2020 · Backend Development
This article explains how Redis implements a single‑threaded architecture by using a file event handler built on non‑blocking I/O multiplexing (select, epoll, evport, kqueue), detailing socket event abstraction, the I/O multiplexing program, event dispatcher, and the mapping of various socket operations to specific handlers.
I/O multiplexingRedisevent handling
0 likes · 7 min read

This article explains how to apply the Observer design pattern in a simple Java game to handle button clicks and hero movement, showing UML diagrams, code examples for subjects, observers, and a client that registers and triggers events.
JavaObserver Patterndesign patterns
0 likes · 6 min read

This article explains what a RunLoop is, why it exists, its internal structure and modes, how it interacts with threads, and common iOS development techniques such as keeping threads alive, image loading, timer handling, and performance monitoring.
Objective-C++RunLoopThread
0 likes · 11 min read

This article explains how to develop extensible Chimee H5 video player plugins using React, covering plugin specifications, code examples, integration of React components via Context, event handling, and strategies for managing asynchronous behavior and plugin ordering.
Context APIReactchimee
0 likes · 9 min read

This article reveals eight lesser‑known DOM and Web API features—such as addEventListener options, smooth scrollTo, optional timer arguments, defaultChecked, normalize/wholeText, insertAdjacent methods, event.detail, and scrollHeight/scrollWidth—explaining their purpose, browser support, and providing practical code examples.
DOMJavaScriptWeb API
0 likes · 17 min read

This article provides a comprehensive, step‑by‑step exploration of modern browsers—covering Chrome’s multi‑process architecture, the navigation pipeline from URL entry to page load, the rendering stages (HTML parsing, style calculation, layout, painting, compositing), and how user interactions are processed and optimized.
Browser architectureFrontend DevelopmentWeb Performance
0 likes · 23 min read


HomeTechNov 29, 2018 · Frontend Development
This article explains how to integrate TypeScript with React, covering type definitions, generic components, event handling, utility types, and best practices such as using declaration files, avoiding any, and leveraging TypeScript’s advanced type utilities to improve code safety and developer productivity.
GenericsReactTypeScript
0 likes · 17 min read


21CTOOct 22, 2018 · Frontend Development
This article explains how JavaScript reference equality for objects and functions affects React's shallow prop and state comparison, shows common pitfalls that cause needless re‑renders, and provides practical techniques—such as defining functions outside components and caching event listeners—to dramatically improve rendering performance.
JavaScriptReactReference Equality
0 likes · 9 min read

iQIYI’s mobile client progressed from server‑assembled JSON cards (Card 1.0) through reusable component cards (2.0), template‑driven blocks (3.0), to a big‑frontend XML‑flex architecture with scriptable logic and hot‑swap tools (Card 4.0), now replacing earlier versions and slated for broader rollout and open‑source release.
Dynamic UIFlex LayoutXML Layout
0 likes · 12 min read

The article records a Meituan‑Dianping Q&A on Domain‑Driven Design, where engineers discuss using domain events with transactions, designing RPC interfaces, separating domain and application layers, handling cross‑aggregate operations, and defining bounded contexts, illustrating how DDD guides microservice architecture and business modeling.
DDDbounded contextscqrs
0 likes · 6 min read

This article walks you through three approaches to implement drag-and-drop in JavaScript—plain code, a native object wrapper, and a jQuery extension—covering essential concepts like transform compatibility, event handling, position calculations, and object-oriented encapsulation, with detailed code examples and visual diagrams.
DOMDrag-and-Dropevent handling
0 likes · 12 min read

This article explains what JavaScript function throttling is, why it improves performance for high‑frequency events like scroll or resize, and provides step‑by‑step code examples—including basic and advanced implementations—to control execution timing and avoid excessive DOM or network calls.
JavaScriptevent handlingfunction throttling
0 likes · 5 min read

This article explains why the value of JavaScript’s this can be confusing, demonstrates typical mistakes with inline events, setTimeout/setInterval, DOM event handlers, and call/apply, and provides practical solutions such as using anonymous functions to control the binding correctly.
JavaScriptcall applyevent handling
0 likes · 4 min read
