NanoID, a modern alternative to UUID, offers significantly smaller IDs, up to 60% faster generation, stronger security via crypto APIs, customizable alphabets, and broad language support, making it a compelling choice for developers seeking efficient, compact, and secure unique identifiers across various platforms.
This article reviews recent TC39 proposals—including findLast, Symbol-as-WeakMap keys, JSON.parse source text access, String.dedent, RegExp modifiers, atomic operators, and faster Promise adoption—explaining their stage progress, technical details, and practical code examples for modern JavaScript development.
The article dissects VS Code’s JavaScript Debugger, explaining its DAP‑based architecture, breakpoint handling, CDP command translation, JavaScript Debug Terminal integration, automatic browser link handling, profiling support, and top‑level await feature, showing how these components deliver a unified debugging experience for Node and browsers.
This article provides a comprehensive 2022 survey of JavaScript development tools, examining compilers, bundlers, package managers, third‑party library creation, and modern web application frameworks, offering recommendations and performance insights to help developers choose the right tools for their projects.
This tutorial walks you through using Frida to hook Android applications, covering API basics, method interception, constructor and field manipulation, overload handling, dynamic class loading, and practical code snippets for both static and instance methods, all while emphasizing safe, educational use.
This article explains Redux’s core concepts, demonstrates how to implement a basic createStore function in JavaScript, and shows how to integrate it with React using a custom Provider and connect higher‑order component for state sharing across components.
This article traces jQuery’s meteoric rise during the Web 2.0 era, examines why major sites like GOV.UK, GitHub and Bootstrap have removed it, and explains how HTML5 standardization and modern MVVM frameworks have turned the once‑essential library into a legacy technical debt.
This article walks through the core concepts and implementation steps of a minimal JavaScript compiler, covering tokenization, parsing into an AST, traversing with a visitor, transforming the tree, and generating target code, while also explaining the visitor pattern and polyfills.
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.
Apache ECharts 5.3.3 has been released, introducing new stacking strategies for bar charts, tree focus support, boolean selectedMode for visualMap, and a series of bug fixes across line, tree, graph, radar, geo, tooltip, dataZoom, markLine, markArea, axis, graphic, decal, radialGradient, and type definitions.
This article traces jQuery’s emergence as the de‑facto library that simplified DOM manipulation and cross‑browser compatibility during the Web 2.0 era, examines its widespread adoption and subsequent performance gains from removal, and explains why modern standards, HTML5 and MVVM frameworks have reduced its relevance today.
This article traces jQuery’s rise as the go‑to library during Web 2.0, examines recent moves by major sites to drop it, explains its original technical advantages, and analyzes how HTML5, MVVM frameworks and modern frontend stacks have reduced its relevance while it still powers a large share of the web.
This article walks through static analysis and Frida hooking of an Android app’s login flow, dissecting the JsonRequest, RequestUtil, and encryption steps, then reproduces the MD5‑based sign generation and DES‑CBC encryption in JavaScript, providing full code snippets and explanations.
This article explains what gray (canary) release is, describes several practical front‑end gray‑release schemes—including simple Nginx weighting, Nginx + Lua + Redis, server‑side rendering routing, and a full Nginx + backend + Redis + frontend SDK solution—provides code snippets, Docker commands and operational tips for safely rolling out new features.
The article explores cross‑platform mobile development techniques, from simple WebView‑based app‑to‑web solutions to advanced virtual‑machine designs and interpreter optimizations, detailing WebView implementations, mini‑programs, React Native, Flutter, and various VM encoding strategies for efficient JavaScript execution.
This article provides a comprehensive overview of Lit, covering its core concepts, key features, decorators, templating, styling, slots, event communication, lifecycle, directives, mixins, controllers, SSR support, and the surrounding ecosystem, offering practical code examples for developers.
This tutorial explains how to install react-router-dom, create basic and nested routes, handle unmatched and index routes, pass parameters, use search parameters, customize link behavior, and navigate programmatically in a React application, providing complete code snippets for each concept.
This tutorial explains how to build a responsive, theme‑switchable real‑time data visualization dashboard using a Python Flask back‑end and ECharts front‑end, covering requirements, architecture, HTML/CSS grid layout, JavaScript chart logic, JSON data handling, and deployment steps.
This article examines the challenges of timer precision in front‑end scenarios such as e‑commerce flash sales, explains the limitations of native setInterval and setTimeout, and introduces a frame‑based timer using requestAnimationFrame, requestIdleCallback and compensation strategies to achieve high‑accuracy scheduling.
This article introduces Webpack 5's Module Federation feature, explains its business scenarios, configuration, underlying plugin architecture, and runtime mechanics, provides a practical Vue 3 demo with code snippets, and discusses usage patterns and benefits for micro‑frontend development.
This article introduces WebGL fundamentals for frontend developers, explaining GPU versus CPU, GLSL shaders, and how JavaScript prepares data, followed by step‑by‑step code examples of fragment and vertex shaders, custom primitives, and using the gl‑renderer library to render graphics.
This article introduces the Web Audio API, explains core audio DSP concepts such as signal processing, time and frequency domains, and details the main AudioContext and AudioNode components, followed by practical examples, code snippets, and references for building sophisticated web‑based audio applications.
The article explains V8 hidden classes and inline caches for faster property access, details Java’s logical versus bitwise operators and short‑circuit evaluation, and demonstrates Go’s first‑class function types such as type func() for flexible, reusable code patterns.
The article traces character encoding from early telegraph and Morse code through ASCII, ISO national sets and Chinese standards, explains Unicode’s unification and its UTF‑8/‑16/‑32 forms, and shows how modern languages—especially JavaScript—handle code points, highlighting the cultural and technical significance for developers.
This digest covers Flutter 3.0 release, the evolution of JavaScript frameworks, React concurrent rendering, WebComponents UI library insights, frontend build tool comparisons, Rust fundamentals, and Vite core principles, and includes external articles on GraphQL and software engineering best practices.
This article demonstrates how to recreate the “声生不息” program logo using only native CSS and a small amount of JavaScript, covering gradient stripes, clip‑path shaping, background‑clip text effects, CSS variables for color toggling, and detailed code snippets for each implementation step.
This tutorial walks you through automating article formatting, creating a VS Code extension with a reverse‑string command, binding a shortcut key, and publishing the plugin to the VS Code Marketplace, covering scaffold setup, code implementation, package configuration, token generation, and release steps.
This article walks through the implementation of Vue's reactive system step by step, starting with simple effect functions, then introducing dependency collection with Set, Map, and WeakMap, and finally using Proxy to automate tracking and triggering of updates for both primitive and object values.
This article explores how to implement smooth scrolling using CSS and JavaScript, compares native scroll APIs, demonstrates practical React examples, explains how to differentiate user‑initiated and script‑driven scrolling, and provides compatibility tips and workarounds for common pitfalls.
hyengine is a lightweight, high‑performance mobile execution engine that unifies WebAssembly, JavaScript, Python and Lua via a compiler and VM, offering JIT compilation, register allocation, inline‑cache optimizations, a custom allocator (hymalloc) and a concurrent three‑color garbage collector (hygc), achieving substantial speed‑ups on macOS and Android.
This article walks through creating a minimal JavaScript compiler—starting from tokenizing Lisp‑style input, building an abstract syntax tree, traversing and transforming it, and finally generating equivalent C‑style code, illustrating the core parse‑transform‑generate workflow used by tools like Babel.
This article demonstrates how to leverage the ES6 Proxy object to create a lightweight global state management solution for React, walking through a counter example, custom hooks, listener tracking, and a reusable store creator for seamless component updates.
This article provides an in‑depth tutorial on Abstract Syntax Trees (AST) and the Babel toolchain, covering AST fundamentals, its role in compilation, and practical examples of parsing, traversing, modifying, and generating JavaScript code using @babel/core, @babel/parser, @babel/traverse, @babel/generator, and @babel/types.
This article explains the ES2020 optional chaining (?.) and dynamic import() features, showing their syntax, practical code examples, compatibility notes, and how they simplify JavaScript code while improving web application performance.
The article walks through creating a lightweight, extensible Node.js command‑line utility without third‑party libraries, covering the command‑pattern design, implementation of split, upper, and word‑count commands, dynamic command loading, and best practices for modular, maintainable CLI development on Linux.
This article presents twenty practical ES6 tricks—including array shuffling, character filtering, string reversal, numeric base conversion, object merging, strict vs. loose equality, destructuring, variable swapping, palindrome checking, optional chaining, ternary operator, random selection, object freezing, duplicate removal, decimal precision, array clearing, color conversion, min‑max extraction, nullish coalescing, and false‑value filtering—each illustrated with concise code examples.
The article introduces the ShadowRealm API, a new JavaScript proposal that creates highly isolated execution realms, explains its type signatures, demonstrates .evaluate() and .importValue() methods with code examples, compares it to eval, Function, iframes, Web Workers, and Node.js vm, and outlines practical use cases such as plugin execution, testing, and web scraping.
This article introduces RxJS, explaining its roots in functional and reactive programming, detailing core concepts such as Observables, Observers, Subscriptions, Subjects, and operators, and demonstrates practical code examples that illustrate how to manage asynchronous event streams effectively in modern front‑end development.
This article explains how JavaScript's garbage collector works, outlines typical memory‑leak scenarios, and provides practical techniques—such as reducing global variables, cleaning DOM references, and managing event listeners—to improve performance and avoid UI jank.
The article reviews recent TC39 proposal updates—including decorators reaching Stage 3, type annotations entering Stage 1, the Change‑Array‑by‑Copy immutable methods, RegExp set notation, decorator metadata, and native once‑only functions—explaining their motivations, new syntax, stage‑gate criteria, and example implementations for JavaScript developers.
This comprehensive guide explains how RxJS brings functional reactive programming to web applications, showing real‑world examples such as online classrooms, autocomplete search, canvas drawing, and service‑layer design, while comparing it to Redux and offering debugging tools and best practices.
This article explains what a JavaScript Promise is, why it solves callback‑hell in asynchronous code, details its three states, and walks through a complete hand‑written implementation—including the constructor, then method, resolvePromise logic, and how to verify compliance with the Promises/A+ test suite.
This article surveys a range of front‑end topics—including alternative web‑framework solutions, the rise of pnpm, JavaScript stack memory, TypeScript overloads, integrating Golang with Node.js, innovative development approaches, and essential network security insights—providing concise technical overviews and references.
This article provides a comprehensive overview of Progressive Web Apps (PWA), covering their concepts, benefits, real-world case studies, implementation steps with Service Workers, App Shell, manifest files, and related JavaScript workers such as Web Workers, Service Workers, and Worklets, while also discussing their development challenges and future prospects.
This article explains how to create a basic HTML parser in JavaScript by using regular expressions and a stack to convert an HTML string into a tree of nodes, complete with code examples, initialization steps, and handling of opening, closing, and self‑closing tags.
This article reviews recent TC39 proposal progress—including decorators reaching Stage 3, type annotations advancing to Stage 1, new immutable array methods, RegExp set notation, decorator metadata, and function.once—detailing their syntax, semantics, migration considerations, and example implementations for modern JavaScript development.
This article explains free variables, defines closures in ECMAScript, shows why every function is a closure, and provides practical examples—including common interview pitfalls and solutions—illustrating how closures capture and preserve lexical scope in JavaScript.
This article introduces a set of ESLint rules that help developers write safer and more efficient asynchronous JavaScript by avoiding common pitfalls such as async promise executors, awaiting in loops, improper promise handling, and callback-related race conditions.
JavaScript’s upcoming “Change Array by copy” proposal introduces four non‑destructive array methods—.toReversed(), .toSorted(), .toSpliced(), and .with()—which provide immutable alternatives to existing destructive methods, and the article explains their behavior, usage examples, and polyfills while the proposal is in stage 3.
This guide shows how to transform an array of employee objects into a grouped structure by age using both a custom reduce‑based groupBy function and the modern Array.prototype.groupBy method, including examples of conditional grouping.
This article explores using IndexedDB for large‑scale client‑side data storage, covering database creation, CRUD wrappers, bulk inserts, performance testing, and multi‑tab coordination via BroadcastChannel and leader election, while providing practical code samples and optimization tips for robust offline logging.
SingleFile is an open‑source browser extension and command‑line utility that lets you capture any web page—including images and resources—into one self‑contained HTML file, with support for Chrome, Firefox, Edge, and other major browsers, plus Docker and manual installation options.
This article explains how JavaScript arrays are zero‑based, demonstrates traditional bracket indexing, introduces the new Array.prototype.at() method for both positive and negative indices, and shows concise code examples that make accessing the first, middle, and last elements easier and more readable.
This article explains the design and implementation of a minimal 40‑line Diff algorithm for React’s virtual DOM, covering node attribute changes, insertions, deletions, and moves, and provides a complete TypeScript demo that marks nodes with placement or deletion flags for efficient DOM updates.
This article introduces the ShadowRealm API, a new JavaScript proposal that creates independent, highly isolated realms for executing code, explains its type signatures, demonstrates .evaluate() and .importValue() methods with practical examples, and compares it with eval, Web Workers, iframes, and Node.js vm.
The article presents a series of JavaScript ES6 code‑review critiques, explaining why older ES5 patterns are problematic and demonstrating modern ES6 alternatives such as destructuring, spread operators, template literals, optional chaining, async/await, and array methods with clear code examples.
This article provides a comprehensive beginner-friendly guide to Babel, covering its definition as a JavaScript compiler, the parse‑transform‑generate workflow, AST concepts, core packages, plugin and preset classifications, configuration details, and step‑by‑step usage examples with code snippets.
Baidu’s new Live SSR approach adds a JavaScript computation function to the CSR directory, enabling seamless server‑side rendering without altering modules or pages, while leveraging end‑cloud collaboration, FaaS universal solutions, and component‑level reuse to boost SEO, user experience, scalability, and development efficiency.
This article presents a collection of ESLint rules for JavaScript asynchronous programming, explaining why patterns like async promise executors, awaiting in loops, returning values from Promise constructors, and others should be avoided, and provides correct code examples to improve readability, performance, and error handling.
The guide shows how to build a lightweight, browser‑based WebIDE using Monaco Editor by adding multi‑file support, preserving view state, integrating ESLint via a WebWorker, enabling Prettier formatting, and extending TypeScript definitions for rich code completion and navigation.
SingleFile is a cross‑browser extension and command‑line utility that lets users capture entire web pages—including images and resources—into a single HTML file, offering multiple installation methods, Docker support, detailed usage commands, and integration with custom user scripts.
The article explains how higher‑order functions such as every, map, and filter can replace repetitive loops over arrays or lists, reducing code duplication, improving readability, and lowering the chance of bugs while warning against over‑using functional style when it harms clarity.
This article explains Vue's error handling mechanisms—including global errorHandler, component-level errorCaptured, and the underlying source code functions handleError, invokeWithErrorHandling, globalHandleError, and logError—through detailed code examples, execution flow diagrams, and practical interview scenarios.
This article explains JavaScript's memory lifecycle, defines memory leaks, enumerates typical leak patterns such as accidental globals, timers, closures and DOM references, and describes the underlying garbage‑collection strategies (mark‑and‑sweep and reference counting) together with practical mitigation techniques.
This article examines NanoID as a modern alternative to UUID, detailing its smaller size, higher speed, stronger security, language support, custom alphabets, lack of dependencies, and compatibility, while also discussing its limitations and future prospects for unique identifier generation in JavaScript projects.
Integrating Rax with Huawei’s HarmonyOS leverages a driver‑adapter pattern to enable code‑share cross‑platform development, offering three strategies—syntax compilation, mini‑program runtime, and direct rendering—so developers can embed Rax output now while progressing toward a seamless full‑stack workflow and Harmony 3.0 release.
This article examines five active TC39 proposals—Pipeline Operator, Function Pipe/Flow, Partial Application, Call This, and Extensions—explaining their design goals, differences, and how they aim to improve function invocation readability, dataflow programming, method extension, and partial application in future ECMAScript versions.
This article explains how AntV S2 implements a wide range of interactions—such as click and hover highlights, brush selection, dynamic row/column resizing, column hiding, link jumps and custom events—by using canvas rendering, event delegation, state management and JavaScript code examples.
This article explains the fundamentals of compilation, compares compiled and interpreted languages, outlines the full compiler pipeline, and uses Babel as a concrete example to show how JavaScript code is parsed, transformed, and generated for broader browser compatibility.
This article explains how NanoID, a modern JavaScript identifier library, offers smaller size, higher security, faster generation, customizable alphabets, and broad language support compared to UUID, while also discussing its limitations and future outlook for developers choosing unique IDs.
This article demystifies JavaScript closures, explains how V8 builds scope chains and closure objects during compilation, and demonstrates why closures can cause memory leaks by retaining references, illustrated with multiple runnable code examples and practical debugging tips.
This article explains how NanoID, a compact and faster alternative to UUID, offers better security, smaller size, higher performance, and broad language support, while also discussing its limitations and future prospects for unique identifier generation in software development.
This article explains how to reverse‑engineer the Shumei slider captcha by retrieving its configuration API, extracting the obfuscated JavaScript, locating the decryption function, and using Python regex and execjs to capture dynamic parameters and DES keys for successful automated submissions.
This article compares NanoID and UUID, highlighting NanoID's smaller size, higher security, faster generation speed, language support, and flexibility, while also discussing its limitations and future prospects, to help developers decide when to choose NanoID over UUID.
This article provides a comprehensive overview of Vue 3—including its release details, performance gains, core architectural changes such as Proxy‑based reactivity, TypeScript support, the new Composition API (setup, ref, reactive, computed, watch, watchEffect), updated lifecycle hooks, new built‑in components like Fragment, Teleport and Suspense, project scaffolding with Vue‑CLI or Vite, and migration considerations from Vue 2.
This article explains what an Abstract Syntax Tree (AST) is, how the ESTree specification standardizes JavaScript syntax, and how Babel parses, traverses, and transforms code using AST nodes, providing practical examples, core packages, plugin creation, and real‑world application scenarios for developers.
This article explains why jQuery’s source uses a double assignment pattern, how assignment operators are right‑associative expressions, the impact of operator precedence on property access versus assignment, and demonstrates practical uses such as building linked structures in JavaScript.
This article traces the evolution of frontend development from server‑side rendering with PHP/JSP through AJAX and jQuery to modern MVVM frameworks, comparing React, Vue, and Angular in terms of syntax, data‑update mechanisms, performance optimizations, and code‑reuse strategies.
This article presents a detailed glossary of common JavaScript English keywords, objects, methods, and properties with their Chinese translations, organized into two comprehensive tables to help developers quickly understand and reference essential JavaScript terminology.
This article examines the single-spa micro‑frontend framework, explains its core mechanisms such as registerApplication, reroute, and lifecycle handling, demonstrates how it powers the qiankun solution, and provides practical code examples for integrating various front‑end stacks.
This article explains how JavaScript's single‑threaded engine uses the event loop to manage synchronous and asynchronous tasks, distinguishes macro‑tasks from micro‑tasks, and compares the implementations in browsers and Node.js, including version‑specific behavior and common pitfalls.
This article explains the core concepts of compilation and interpretation, compares static and dynamic languages, and walks through the V8 engine’s workflow—including parsing, bytecode generation, JIT compilation, and TurboFan optimizations—providing concrete code examples and command‑line tips.
Microsoft’s recent proposal to add optional type‑annotation syntax to JavaScript aims to let external tools like TypeScript perform static checks while keeping runtime behavior unchanged, sparking both excitement and debate among developers.
This article explains why B2B front‑end applications suffer from frequent API changes, introduces the anti‑corruption layer concept adapted from HAL and DDD, and demonstrates how to implement a robust, RxJS‑based layer that isolates UI code from evolving back‑end contracts while offering caching, fallback, and testing benefits.
This article explains the fundamental principles behind JavaScript execution, covering the distinction between interpreted and compiled languages, the architecture of JavaScript engines (including V8, SpiderMonkey, and JavaScriptCore), runtime environments, the single‑threaded event loop, call‑stack processing, lexical analysis, parsing, bytecode, JIT compilation, and the role of Web Workers in off‑loading CPU‑intensive tasks.
Formily is a data‑plus‑protocol driven form framework that leverages reactive programming to deliver O(1) performance for massive fields, supports multiple front‑end frameworks, offers a rich ecosystem of cross‑platform components, and provides design principles and extension strategies for building high‑efficiency enterprise forms.
This article walks through the evolution from simple SDK repositories to a full‑featured Yarn Berry monorepo, covering workspace setup, configuration, plugin integration, TypeScript settings, package scaffolding, release workflows, and practical tips for dependency management and linking.
This article reviews eight popular Node.js WebSocket libraries—SockJS, ws, Socket.IO, Faye WebSocket, SocketCluster, Sockette, and Feathers—detailing their features, popularity, installation commands, and typical use cases for building real‑time backend applications.
This curated list presents a range of frontend development resources—including articles on framework alternatives, defensive programming, low‑code H5 platforms, Engine.IO fundamentals, international web‑dev insights, monorepo strategies, Recoil internals, Vue/React debugging tips, JavaScript tricks, and Three.js 3D text effects—providing practical guidance and deeper technical understanding.
This article introduces the pinyin‑pro JavaScript library, explains its rich features such as tone handling, initials, finals, polyphone support, surname mode, non‑Chinese character filtering, custom pinyin definitions, and matching, and provides step‑by‑step installation and usage examples for both browser and Node environments.
This article explains the relationships among WebSocket, Engine.IO, and Socket.IO, details Engine.IO’s features, handshake, upgrade and disconnect mechanisms, and provides practical code examples for building real‑time communication in Node.js applications, including packet encoding, transport options, and debugging techniques.
This article explains how to master regular expressions by visualizing their abstract syntax trees (AST), covering basic patterns, character classes, repetitions, greedy vs. non‑greedy matching, groups, and look‑ahead/look‑behind assertions with clear examples and diagrams.
This article explains Alibaba's JavaScript Ahead‑of‑Time (AOT) technology, detailing the performance challenges of dynamic JS, the three compilation strategies evaluated, the chosen hybrid approach with profile‑guided and rule‑based optimizations, and the measurable speed gains achieved in production.
This article introduces the renowned "awesome" GitHub repository, highlights its extensive sub‑lists for various domains, focuses on the awesome‑web‑scraping collection, and presents a newly created Chinese version that aggregates Python, JavaScript, Go, and other language‑specific web‑scraping tools and libraries.
Building a Chrome extension that redirects network requests illustrates the complexities of message passing across isolated contexts, and the article shows how the browser‑extension‑kit framework abstracts routing, state management, and RxJS integration to streamline development, reduce boilerplate, and improve maintainability for React‑based popups and background scripts.
This tutorial explains how to create a Chrome browser extension that generates QR codes (optionally with protocol headers) and decodes them, covering the background motivation, directory layout, manifest and popup design, core JavaScript logic, installation steps, and a download link for the complete source.
The article explains how to overcome the limitation of browser ES Modules by creating inline‑import functionality with Blob URLs and dynamic import maps, providing both dynamic and static import capabilities for modular JavaScript in playground‑style environments.
This tutorial explains how to integrate the jSignature library with jQuery on the front end and PHP on the back end to provide a real‑time mobile signature feature, covering library download, HTML markup, JavaScript initialization, reset, AJAX submission, and server‑side base64 image handling.
This tutorial walks you through the entire process of creating a custom VSCode code‑completion extension, covering environment setup, the mechanics of suggestion panels, snippet configuration, core API usage, and advanced personalization techniques such as dictionary‑based word completion and automatic updates.
This article walks through practical ways to implement true dark mode on web pages—including manual toggles, system‑preference detection, CSS variables, stylesheet swapping, filter tricks, and common pitfalls—while providing complete code examples and explanations.
