This guide shows how to import the HarmonyOS storage module, use its get and set methods, and integrate them into a todo‑list app’s lifecycle so that tasks are saved across sessions, with full code examples and screenshots of the result.
This tutorial walks through creating a full-featured Todo List app in HarmonyOS, covering page navigation, HML layout, data binding with for-loops, switch components, computed properties, event handling in JavaScript, and the accompanying CSS styling.
This article demonstrates three Vue decorators that use async/await to transparently manage component initialization status, add debounce and loading indicators to button clicks, and control the visibility of the component before the mounted hook finishes, with full TypeScript examples.
This article explains how to use Webpack's code splitting techniques—including multiple entry points, the SplitChunksPlugin, dynamic imports, and magic comments—to break large bundles into smaller chunks, reduce duplicate dependencies, and improve loading performance in modern frontend applications.
This article explains what an Abstract Syntax Tree (AST) is, demonstrates how JavaScript code is transformed into an AST, describes the tokenization and parsing steps used by PostCSS to generate a CSS AST, and shows how plugin mechanisms like AutoPrefixer can extend the toolchain.
This article explains what JSBridge is, details its implementation using URL interception and iframe tricks, and walks through the full communication flow between a WebView and native code on iOS, including code examples for registration, message handling, and callbacks.
The article proposes a unified cross‑platform front‑end API specification and SDK that abstracts differences among WebView, mini‑programs, React Native, Flutter, and other containers, consolidating 55+ APIs for 30+ apps, reducing duplicated code, maintenance, and testing while enabling extensible, reusable functionality across Alibaba’s ecosystem.
This article explains the complete lifecycle of JavaScript execution in the V8 engine, covering language fundamentals, AST generation, bytecode compilation, interpretation, just‑in‑time optimization, hidden classes, inline caches, and other performance strategies used by both browsers and Node.js.
This article compares the tree‑shaking mechanisms of Rollup and Webpack, explains the three stages Webpack uses (UglifyJS, BabelMinify, Terser), details side‑effects handling, configuration tips, and performance benchmarks, providing practical guidance for optimizing bundle size in modern JavaScript projects.
After creating a Hello World app with JavaScript on HarmonyOS, this guide details the project’s directory layout, configuration files, lifecycle hooks, path conventions, and demonstrates how to load i18n resources and render a data list with concrete code examples.
This guide explains how Zabbix 4.4+ lets you use custom JavaScript in webhook media types to send alert notifications, details the built‑in Zabbix objects, shows configuration steps, data validation, logging rules, and provides a complete DingTalk webhook script with testing instructions.
This article explains why React Hooks were introduced, walks through the fundamentals of useState and useEffect with clear code examples, and demonstrates how Hooks simplify state management, side‑effects, and component logic compared to traditional class components, enabling more maintainable frontend development.
This article reviews Google’s CSS fundamentals course, dives into React 18’s automatic batching, the new Suspense SSR architecture, the startTransition API, suggests a lightweight VS Code API client, and explains the basics of building user profiles for recommendation systems.
The article explains how to design and implement ESLint and StyleLint plugins for the San‑Native framework, detailing AST generation, processor creation, rule definitions for JavaScript and CSS, configuration sharing, and how these tools provide real‑time linting feedback for developers.
This article explains practical JavaScript naming conventions—covering camelCase, constant capitalization, acronym handling, meaningful and expressive names, verb consistency, boolean naming, and class naming—while providing numerous code examples to illustrate good and bad practices for clearer, maintainable code.
This article reviews the 2021 top five frontend JavaScript frameworks—React, Vue, Angular, Ember, and Preact—based on Stack Overflow surveys, State of JS, and NPM trends, explaining their origins, features, and adoption by major companies.
This article chronicles the ten‑year evolution from Emscripten’s C++‑to‑JavaScript compiler through asm.js to the modern WebAssembly standard, highlighting key milestones, performance challenges, and real‑world applications that have reshaped what browsers can achieve.
This article dissects Node.js Readable streams, explaining their initialization, internal state management, the distinction between flowing and paused modes, and how back‑pressure is handled, all illustrated with real source‑code examples and diagrams.
This article explains how Webpack loaders work, outlines development guidelines, demonstrates synchronous, asynchronous, raw, and pitching loaders with code examples, and then guides you through creating and configuring custom plugins, covering hooks, async handling, and a practical build‑info plugin.
This article explains how React synthetic events emulate native DOM events, details the event system architecture, provides core registration and execution code, demonstrates mixing with native events, and discusses the benefits and known issues of the synthetic event model.
This step‑by‑step tutorial shows how to create a dark‑mode toggle for a web page using HTML structure, CSS styling (including dark‑mode rules), and a small JavaScript script that adds or removes the dark class on user interaction.
This article explains the complete workflow for implementing SourceMap‑based exception monitoring across web and cross‑platform systems, covering transformer, bundler, minifier, runtime support, log collection, error deobfuscation, and the limitations of SourceMap in debugging and performance contexts.
The Node.js 14.17.1 LTS release introduces updated ICU to version 69.1, aligns source‑map stack traces, refactors several core modules for safety, improves benchmark performance, and fixes numerous build and runtime issues, providing a more stable and efficient JavaScript runtime for server‑side applications.
This article explores the historical reasons behind JavaScript's event loop, explains the task and microtask queues, compares browser and Node.js implementations, and provides concrete code examples to illustrate how tasks are scheduled and executed across environments.
This article explains Vue’s reactive system, compares Vue 2.6’s Object.defineProperty approach with Vue 3’s Proxy implementation, details how observers are defined, collected, and triggered, and shows why the asynchronous update queue improves performance and maintainability.
This article explains the evolution of JavaScript asynchronous programming, details the Promise/A+ specification, provides step‑by‑step custom Promise implementations with full code examples, covers additional Promise methods, and offers interview questions and best‑practice tips for frontend developers.
This article explains functional programming as a paradigm focused on pure functions and data‑to‑data mapping, contrasts it with imperative programming, introduces lambda calculus, pure functions, higher‑order functions, functors, monads, and provides JavaScript examples that show how to write composable, side‑effect‑free code for front‑end development.
This article explains the background, basic concepts, workflow, configuration, server‑client communication, runtime mechanics, and manual implementation of Hot Module Replacement (HMR) in Webpack, helping developers preserve application state while developing with live updates.
This guide compiles a comprehensive collection of regular expressions for validating numeric formats, character sets, special inputs like emails and URLs, as well as IP addresses, dates, and other common data patterns, providing clear examples and explanations for developers.
This article compares five widely used programming languages—JavaScript, Haskell, Go, PHP, and Elixir—by outlining each language’s major advantages such as rapid prototyping, strong type systems, performance, and ecosystem support, as well as notable drawbacks including dynamic typing quirks, steep learning curves, and limited language features.
This article explains the background, concepts, workflow, and hands‑on setup of Webpack’s Hot Module Replacement (HMR), detailing server‑client communication, runtime mechanics, and how to manually implement module hot‑updates without a framework, complete with code examples and configuration tips.
This guide shows how to create a simple HTML page with a button that copies paragraph text to the system clipboard using the modern Clipboard API, including full code examples and explanations for both copy and cut operations.
This tutorial walks you through creating a multi‑platform “Merge Big Watermelon” mini‑game using Cocos Creator, covering game rules, engine architecture, project structure, component‑based scripting, physics and collision handling, asset management, build configuration, and publishing to various platforms.
This article explains why browsers enforce a minimum 4 ms delay for nested setTimeout calls, demonstrates how to bypass it using window.postMessage to create a true zero‑delay timer, and compares the performance of both approaches with detailed experiments and visualizations.
This article explains the concept of a virtual tree, why it is needed for rendering massive data sets, and provides a step‑by‑step implementation—including flattening the tree, calculating visible nodes, simulating scroll, and decorating the list—demonstrating a speedup from 26 seconds to 0.19 seconds.
This article explains the design, configuration, and usage of the JD Logistics gateway frontend plugin built on Axios, detailing how it enables zero‑cost integration across multiple environments and account types while providing extensible request/response handling and customizable login redirects.
This article reviews the most recent TC39 proposals—including Realms, RegExp match indices, top‑level await, accessible hasOwnProperty, resizable ArrayBuffers, Intl.DisplayNames V2, extended time‑zone names, and RegExp set notation—explaining their key changes, current stage status, and practical code examples for developers.
This article explains the concept of unit testing, introduces the Jest framework and its configuration, demonstrates common APIs, matchers, asynchronous testing, mocking, coverage reporting, and shows how to test React components using React Testing Library with practical code examples.
This article walks through the complete refactoring of a JavaScript Caesar cipher implementation, explaining the cipher basics, the importance of clean code, and eight incremental refactoring steps that replace magic numbers, extract duplicated logic, simplify conditionals, and improve naming for maintainable, readable code.
This article chronicles the evolution of a web‑based live‑streaming platform from its initial Web 1.0 prototype through successive versions, detailing AI speech detection, RTC integration, extensive refactoring, and the resulting framework that proves web technologies can effectively support live‑streaming scenarios.
This article explains the historical concept of activation objects in ECMAScript 1/3, why they disappeared after ES5 in favor of lexical environments, how the idea persists as a generalized abstraction similar to stack frames, and how it relates to closures.
This article explains how top‑level await, introduced in V8 from version 9.1 and enabled by default in modern browsers, allows developers to use await directly at a module’s top level, simplifying asynchronous code patterns with examples, execution order details, and practical use cases.
This article explores when plugins are truly necessary, outlines design principles and SOLID guidelines for building robust plugin architectures, demonstrates a step‑by‑step implementation of a calculator plugin system, and examines JavaScript and CSS sandboxing techniques to ensure plugin security in web applications.
This article examines the puzzling condition if(a==1 && a==12) and demonstrates how JavaScript and Java can be coaxed to satisfy it using clever language tricks such as property getters, reflection, and cache manipulation, revealing deeper insights into language internals.
This article explains essential clean‑code techniques for naming variables in JavaScript/TypeScript, covering self‑descriptive, pronounceable identifiers, avoiding type prefixes, using consistent terminology, eliminating unnecessary context, and replacing magic numbers and strings with meaningful constants.
Vue.nextTick schedules callbacks using a graceful‑degradation chain (Promise, MutationObserver, setImmediate, setTimeout) that leverages the JavaScript event‑loop’s micro‑task queue, ensuring DOM mutations are applied instantly but rendered after microtasks and before macrotasks, while the browser’s multi‑threaded architecture coordinates rendering, timers, and network work.
This article describes how to integrate and extend the open‑source HanziWriter library for Android, iOS and web, extracting TrueType glyph data, segmenting strokes with corner detection and neural‑network scoring, generating stroke medians via Voronoi diagrams, and determining correct stroke order using a Hungarian‑algorithm match.
This article explains the fundamentals and implementation details of Rollup's tree‑shaking feature, showing how unused JavaScript code is identified and removed through static ES6 module analysis, with practical code examples and visual demonstrations of variable, function, and class elimination.
Google’s new Sparkplug compiler for the V8 engine, introduced in Chrome 91, claims to cut CPU usage by the equivalent of 17 years per day and deliver a 23% speed boost, promising faster web experiences for all Chromium‑based browsers.
This article reviews common web animation techniques for mobile projects—including GIF/APNG, CSS3, JavaScript, Lottie, SVG, and Canvas—offering practical tips, performance considerations, Vue and React implementations, and reusable code patterns to help developers confidently meet designers' animation requirements.
This guide explains how to implement QQ login using the official OAuth2.0 flow, covering developer registration, creating a website application, obtaining the authorization code, access token, and OpenID, and finally calling the get_user_info API to retrieve user details.
iMove, a reusable, function‑oriented JavaScript library, adds right‑click online code execution to its visual workflow, eliminating installation, simplifying testing with mock inputs, handling ES module imports via native browser support, CDN transforms, dynamic imports, and custom events to deliver instant, visual results.
This article traces the evolution of web technologies from Tim Berners‑Lee's first static page and the birth of HTML, through the rise of JavaScript, CSS, AJAX, SPA, SSR, and NodeJS, to recent innovations like React Server Components and future trends in web rendering.
This article explains why proper exception handling is essential for high‑quality JavaScript, contrasts using return codes with real exceptions, shows clean versus dirty code examples, and offers practical guidelines such as defining custom exception hierarchies, handling Promise rejections, and providing contextual error information.
This article explores five powerful JavaScript 2021 enhancements—including logical assignment operators, replaceAll, numeric separators, Promise.any, and WeakRef/Finalizers—explaining their syntax, behavior, and practical code examples to help developers write cleaner, more efficient code.
This guide walks you through creating a VSCode code‑snippets extension from environment setup, Azure DevOps publisher registration, project scaffolding with Yeoman, configuring package.json and snippet JSON, debugging inside the extension host, packaging with vsce, and finally publishing the extension to the marketplace, while highlighting common pitfalls to avoid.
TypeScript’s rapid rise stems from its incremental type system, strategic collaborations, and tooling ecosystem—including DefinitelyTyped, JSX support, and integration with Babel and modern build tools—while its future may involve native type annotations in JavaScript and continued community‑driven evolution.
This article explains the historical concept of Activation (or Variable) Objects in ECMAScript 1/3, why they disappeared after ES5, how modern JavaScript uses Lexical Environments as their successor, and how this relates to closures and function execution.
This article explains ECMAScript's cover grammars and finite lookahead mechanisms for resolving ambiguous syntax, focusing on arrow function parameter lists versus parenthesized expressions.
This article explains how JavaScript’s Math.max function works, covering typical usage, single‑argument behavior, the surprising -Infinity result when called without arguments, and practical techniques for finding maximum values in arrays, including handling empty arrays.
React Fiber rewrites React’s core algorithm by breaking the diff phase into small, interruptible fiber units, scheduling them during browser idle time with requestIdleCallback, using double‑buffered trees and effect lists to pause, resume, and efficiently commit DOM updates, thereby improving UI responsiveness in large applications.
Bootstrap 5 has officially launched with its first stable 5.0.0 release, introducing a redesigned logo, dropping support for older browsers, removing jQuery, updating to Popper V2, enhancing dropdowns, modals, tooltips, adding new components like offcanvas, accordion, tables, RTL support, a revamped utility API, and numerous performance and grid layout improvements.
This article provides a comprehensive analysis of Webpack's core architecture, explaining its three-phase workflow (initialization, building, and generation), plugin system, and module handling mechanisms to help developers understand the underlying principles of this static module bundler.
This article traces the evolution of web technologies from Tim Berners‑Lee's first static page in 1991 through the rise of HTML, CSS, JavaScript, dynamic server‑side solutions like PHP and AJAX, the emergence of SPAs, and modern innovations such as SSR, React Server Components, and Web Components, highlighting key milestones, challenges, and future directions.
This article explains the ESModule standard, compares its server‑side (Node.js) and browser implementations, discusses compatibility issues with CommonJS, examines the difficulties of using third‑party dependencies in browsers, and outlines emerging tools such as Snowpack and Vite that leverage native ESModules.
The article explains how JavaScript handles binary data by using ArrayBuffer as raw memory, TypedArray and DataView as typed views for reading and writing with endianness control, and Blob for file‑like binary objects, detailing their constructors, methods, and typical use cases such as WebGL, file upload, and image display.
This article examines the ongoing debate over code comments, explains when comments add value or cause noise, and outlines three practical guidelines—commenting only complex business logic, avoiding log‑type and positional markers—to improve JavaScript code readability.
This article explains how to implement parallel downloading of large files in the browser by leveraging HTTP Range requests, the asyncPool concurrency‑control library, and auxiliary functions such as getContentLength, getBinaryContent, concatenate, and saveAs, complete with code examples and usage guidance.
Spanning three decades, this article traces the evolution of web development from Tim Berners‑Lee’s 1991 static page through the rise of HTML, CSS, JavaScript, PHP, AJAX, SPA frameworks, server‑side rendering, Node.js, and emerging trends like React Server Components, illustrating how each breakthrough addressed the limitations of its predecessors.
The article explains how using functions that were not intended as callbacks—such as library utilities, Web APIs, or option objects—can break when array.map or other higher‑order functions pass extra arguments, and it shows safer patterns, TypeScript behavior, and linting hints to prevent these bugs.
This article explains how the Laravel PHP framework and the Vue.js progressive JavaScript library complement each other, highlighting their popularity, ease of integration, event‑driven architecture, virtual DOM performance, and faster learning curve, making them an ideal stack for new web projects.
This guide explains what ECMAScript (ES) modules are, how to enable them in Node.js using .mjs extensions or a package.json "type":"module" setting, and provides practical code examples for importing, exporting, and running ES modules from the command line.
This tutorial walks developers through the complete process of creating a simple Visual Studio Code extension—from installing Node.js, Git, and Yeoman, to generating project scaffolding, configuring package.json, writing activation code, adding commands and menu items, and testing the extension—while highlighting VS Code's multi‑process architecture and extension limitations.
This article curates 23 open‑source game projects hosted on GitHub—ranging from Vim plugins and JavaScript Tetris clones to Python, Go, and web‑based multiplayer titles—providing installation steps, feature highlights, code snippets, and live demo links so developers can learn, experiment, and have fun during breaks.
A React component that works locally threw a minified "#31" error only on Vivo X7 Android 5.1 devices because a Symbol polyfill loaded after React caused a mismatch in REACT_ELEMENT_TYPE, and adjusting the build order or JSX runtime resolved the illegal return‑value bug.
The article reviews the recent TC39 meeting where the Class Fields proposal advanced to Stage 4, outlines the criteria for moving between proposal stages, and summarizes several other ECMAScript proposals—including Intl.LocaleInfo, Object.hasOwn, Symbol as WeakMap keys, extended timezone options, copy‑based array methods, and readonly ArrayBuffer—detailing their goals, status, and example code.
Eva.js, an open‑source interactive game engine developed by Alibaba, combines a lightweight ECS architecture, PixiJS rendering, and performance‑focused loading strategies to let front‑end developers create engaging web games with just a few lines of code, while supporting accessibility and state management.
This tutorial explains how to integrate AJAX fetch calls with Django views for both GET and POST requests, covering header configuration, CSRF handling, JSON data exchange, and the updated method for detecting AJAX requests in Django 3.1 and later.
This tutorial demonstrates how to integrate Layui with ThinkPHP 5.1 to dynamically load hierarchical city category data, covering HTML setup, JavaScript tree rendering, PHP backend data retrieval, and a recursive method for obtaining parent IDs, enabling interactive navigation of multi‑level locations.
This article explores JavaScript and TypeScript data types, explains how TypeScript enhances code robustness with interfaces and generics, examines common JavaScript pitfalls, and demonstrates how V8’s TurboFan compiler and type‑consistent code can dramatically improve performance, complemented by practical TypeScript tips and advanced type utilities.
This article explains JavaScript’s parseInt function, demonstrates how it parses integer strings and binary numbers, reveals its unexpected behavior with small floating‑point values due to automatic string conversion and exponential notation, and recommends using Math.floor for reliable integer extraction.
This article explains what an Abstract Syntax Tree (AST) is, how it’s generated during lexical and syntax analysis, outlines its core structure, and demonstrates practical applications such as code transformation, linting, formatting, and custom Babel plugins with detailed code examples.
This article explains how to use the async‑pool library together with HTTP Range headers to control concurrency and achieve parallel downloading of large files in the browser, covering the underlying HTTP concepts, helper functions, and a complete example implementation.
This article explains JavaScript’s scope types, execution context, activation objects, and the lifecycle of functions, illustrating how closures retain memory, how garbage collection works, and provides practical solutions for common closure pitfalls in React functional components.
This article investigates why the api‑monitor library's for‑in traversal fails to enumerate certain XMLHttpRequest properties on iOS 14.5 beta and PC Chrome, explains the underlying prototype‑property interaction, and provides code examples and cross‑platform comparison results.
This article explains how React registers event listeners on the root, extracts events from the fiber tree, synthesizes cross‑browser synthetic events, accumulates callbacks, and finally dispatches them, illustrating each step with code examples and diagrams.
This article walks through the step‑by‑step reverse‑engineering process used to identify and replicate the MD5‑based sign generation in a web API request, detailing parameter extraction, code inspection, and cookie handling to recreate the required authentication logic.
This article explains JavaScript memory leaks, covering their definition, how JS manages stack and heap memory, automatic garbage collection, Chrome DevTools profiling techniques, and common leak patterns such as improper closures, global variables, detached DOM nodes, console logging, and forgotten timers, with detection and mitigation strategies.
This article walks through building a basic front‑end router with vanilla JavaScript, then dissects React Router’s source code—including BrowserRouter, HashRouter, Router, Route, and matchPath—explaining their implementations, the history library, and how they improve routing compared to native approaches.
This article explains how the ECMAScript specification defines property access through the [[Get]] internal method, walks the prototype chain, and uses the Receiver value, illustrating each step with concrete code examples and the relevant abstract operations such as OrdinaryGet and GetValue.
In this extensive interview, dexteryy, a senior Web front‑end engineer at ByteDance, shares his personal journey, reflects on the historical stages of Web development, discusses current challenges of mobile and immersive experiences, and outlines the vision for next‑generation application development tools and ecosystems.
This curated guide presents concise technical deep‑dives into JavaScript protection, pagination techniques, Babel async/await transformation, Web Worker sandboxing, V8 engine tuning, React Native launch optimization, collaborative editing algorithms, Windows defragmentation, CLS metric evolution, accessible UI components, and future‑proof CSS strategies.
This article walks through how the ECMAScript specification defines prototype chain property lookup, detailing the [[Get]] internal method, OrdinaryGet algorithm, the role of the Receiver parameter, and how these mechanisms are invoked during member expression evaluation and function calls.
This article explains how to implement a rectangular treemap for outpatient disease data using JavaScript, covering layout algorithms such as Slice‑and‑Dice and Squarified, color filling, and canvas event handling with detailed code examples and performance evaluation metrics.
This article walks through creating a simple native Node.js HTTP server, applying the Strategy pattern to decouple routes, enforcing the DRY principle with Promises, and then dives deep into Koa’s core source—including its constructor, use, listen, compose, and router modules—to reveal how the framework orchestrates middleware and request handling.
This article introduces a Promise‑based JavaScript animation library, explains how to create sequential animations using async/await, provides polyfills for requestAnimationFrame and es6‑promise, details the Animator class implementation, and demonstrates usage with code examples and easing extensions.
NativeScript 8.0 expands the mature cross‑platform framework with Apple Silicon (M1) support, Webpack 5 integration, enhanced accessibility, new ESLint rules, a RootLayout container, updated documentation, and streamlined core features for building iOS and Android apps using JavaScript or TypeScript.
This article traces the evolution of web development from the first static HTML page through the rise of JavaScript, CSS, dynamic server‑side technologies, SPA and SSR, up to recent trends like React Server Components and micro‑frontends, highlighting why each breakthrough occurred.
This article explains why front‑end performance optimization is crucial for user retention and conversion, outlines loading‑time and runtime optimization categories, and provides practical techniques such as DNS prefetching, HTTP/2 adoption, resource compression, lazy loading, virtual lists, event delegation, and code‑level best practices with concrete code examples.
This article explains why strings containing emojis report different lengths in JavaScript, covering Unicode fundamentals, code points, UTF‑8 and UTF‑16 encodings, surrogate pairs, grapheme clusters, zero‑width joiners, and modern ES2015‑ESNext features that help handle Unicode correctly.
