Both Deno 2 and Bun, the newly released JavaScript runtimes, can function as independent package managers, offering compatibility with Node.js and npm, support for various dependency sources, performance optimizations, and unique commands such as deno install, add, remove, and Bun’s workspace and caching features.
This tutorial demonstrates how to integrate the ECharts JavaScript library with a PHP backend to generate interactive statistical charts featuring labels and legends, covering resource inclusion, data preparation, HTML container setup, and JavaScript configuration with code examples.
This article explains how to create a complete map drill‑down feature in ECharts, covering data preparation, chart initialization, event handling, dynamic rendering, navigation controls, custom tooltips, and best‑practice tips for interactive geographic visualizations.
Alova.JS is a lightweight HTTP request library that supports multiple adapters, cross‑framework usage, and TypeScript, offering a smaller bundle size (≈30% of axios), a concise API, and high‑performance request strategies, making it a compelling replacement for axios in modern web projects.
Discover ten practical JavaScript SEO strategies—from server‑side rendering and canonical tags to lazy loading, pre‑rendering, dynamic meta tags, and clean URLs—that help frontend developers ensure their dynamic sites remain crawlable, indexable, and rank higher in search results.
Recent TC39 Stage‑1 proposals introduce iterator deduplication, enhanced template literals, function and object literal decorators, concurrency controls for async iterators, unordered async helpers, immutable ArrayBuffers, a measurement API, Array.zip utilities, reactive Signals, and stricter resource‑management using enforcement, each aiming to extend JavaScript’s core capabilities.
This guide explains how to embed SQLite in browser‑based applications using sql.js, covering npm and CDN loading methods, configuration for bundlers, database creation, query execution, import/export techniques, persistent storage, and Node/Electron usage with detailed code examples.
This article reviews several Stage 2 ECMAScript proposals—including discard bindings using the void operator, iterator chunking for sliding windows and non‑overlapping sequences, phase‑based ESM imports for static worker initialization, extractors for custom destructuring, and structs with shared memory, mutexes, and unsafe blocks.
This article explains the five SOLID design principles, shows how they are often violated in React and Angular code, and provides concrete refactorings—including custom hooks, separate services, validator classes, and interface segregation—to make frontend applications more maintainable, testable, and extensible.
Several Stage‑3 TC39 proposals—including Error.isError for reliable error type checks, RegExp.escape for safe regex construction, Uint8Array methods for base64/hex conversion, and Temporal.TimeZone.prototype.equals for canonical time‑zone comparison—aim to enhance JavaScript’s core capabilities across browsers and Node.js.
This article reviews several upcoming JavaScript proposals—including the Stage 2.7 Error.isError method, the sandboxing ShadowRealm API, the import‑defer syntax for lazy module loading, as well as Iterator.zip, Iterator.concat, and Math.sumPrecise—detailing their motivations, usage examples, and potential impact on web and Node.js development.
These recent ECMAScript proposals—Error.isError for reliable error type checking, RegExp.escape to safely escape user‑provided strings, Uint8Array methods for seamless Base64 and hex conversions, and Temporal.TimeZone.prototype.equals for robust time‑zone comparison—aim to simplify development across browsers and Node.js by addressing long‑standing inconsistencies.
WebAssembly (Wasm) is a portable binary format that runs near native speed in browsers, providing sandboxed security and modular deployment, though its ecosystem is still maturing; it shines in compute‑intensive tasks like scientific computing, gaming, and porting native code, and can be integrated with Rust via wasm‑bindgen and wasm‑pack to create npm‑compatible modules that outperform JavaScript on larger workloads, while requiring higher development effort.
This article reviews the latest Stage 4 ECMAScript proposals—including ArrayBuffer transfer, iterator helpers, RegExp modifiers, import attributes, Promise.try, duplicate named capture groups, and Set methods—explaining their purpose, syntax, and example usage for modern JavaScript development.
This article summarizes TC39’s 2024 JavaScript proposal workflow, detailing each stage from initial concept (Stage 0) through final adoption (Stage 4) and outlining upcoming articles that will track progress across the different stages.
This tutorial walks through setting up a Vue2 front‑end environment, installing Node.js, Vue‑CLI, Element UI, and Axios, then creates a reusable hot‑search board component, integrates it into the main app, and even shows a Java‑based Zhihu crawler for data collection.
This article explains how to create a highly customized table composed of three synchronized Element UI tables in Vue, covering coordinated scrolling, dynamic info‑bar positioning, floating operation columns, style overriding, and performance considerations with code examples.
This article explains how to build a canvas‑based calendar widget using Konva, covering the design of date cells, task‑range rendering, drag‑and‑drop interaction, event handling, and the public API, and provides the full source code for reference.
QuickJS manages memory using reference counting for each object combined with a cycle‑collector that periodically scans roots, decrements child references, and frees objects whose counts drop to zero, while also supporting traditional reachability‑based garbage‑collection techniques such as mark‑sweep, copying, and generational collection.
This guide explains how to set up a Rust toolchain, compile Rust code to WebAssembly, use wasm‑bindgen and wasm‑pack, write the necessary Rust and JavaScript glue code, and run the resulting Wasm module in a web page with a Web Worker, providing a complete workflow for front‑end developers.
This guide walks you through the complete workflow of writing Rust code, compiling it to WebAssembly, and integrating the resulting module with JavaScript and HTML to create a browser‑based demo that checks whether a number is even, while covering setup, tooling, and best‑practice tips.
This article introduces Fuse.js, a dependency‑free JavaScript library for client‑side fuzzy searching, explains its core concepts, installation methods, basic usage with code examples, and advanced configuration options for customizing search behavior.
This article explains JavaScript's Blob and File objects, their creation syntax, properties, methods such as slice, text, arrayBuffer, and stream, and demonstrates common scenarios like file download, upload, image reading, and Base64 conversion with clear code examples.
This guide explains why Playwright is a leading tool for frontend automated testing, walks through installing Node.js, Playwright and browsers, shows project configuration, provides runnable demo code, and demonstrates common GET and POST API requests, helping developers boost test efficiency and reliability.
This article explains why stale JavaScript can break functionality, outlines the risks of caching such as outdated bugs, security flaws, and debugging difficulties, and provides practical Java‑side solutions—including versioned URLs, cache‑control headers, static‑resource policies, and ETag/Last‑Modified handling—to ensure browsers always load the latest scripts.
Chrome 129’s new scheduler.yield() lets developers pause long‑running JavaScript loops without the 4 ms minimum delay or queue‑end placement of setTimeout(), cutting execution time from ~17 s to ~5.6 s while keeping the page responsive and preserving task priority.
This article systematically introduces the many ways to write Vue components—including the classic Options API, the modern Composition API with setup syntax sugar, hand‑written render functions using h or createVNode, and various JSX techniques—explaining their principles, code examples, and when to choose each approach.
This article explains why the native storage event only works across different tabs, evaluates traditional polling and proxy approaches, and presents four efficient solutions—including custom StorageEvent, CustomEvent, MessageChannel, and BroadcastChannel—along with practical React and Vue examples for real‑time localStorage monitoring.
This tutorial walks readers through installing Node.js and pnpm, configuring .npmrc, initializing a package.json, installing Electron, creating a simple main.js and index.html, and launching the first Electron window while providing tips on version management and common network issues.
Deno 2.0, the latest production release of the open‑source Deno runtime, brings major updates for JavaScript, TypeScript and WebAssembly, offers full backward compatibility with Node.js and npm, stabilizes its standard library, introduces private NPM registry support, workspace/monorepo features, and adds enhanced formatting, linting, and coverage tools.
The article shows how to replace the taxi‑hailing app’s deeply nested driver‑assignment if‑statements with early‑exit guard clauses, data‑driven decision tables, and composable functions, thereby flattening the logic, enhancing readability, simplifying testing, and making future extensions easier to implement.
This article introduces the Astro static‑site framework, explains its island architecture and performance advantages, compares Core Web Vitals with other frameworks, and provides detailed code examples and best‑practice guidelines for integrating Astro with React and Vue in real‑world projects.
JavaScript’s single‑threaded nature makes asynchronous programming essential, and this guide explains callbacks, promises (including states and chaining), and async/await syntax with clear examples, illustrating how each technique avoids blocking the main thread and improves code readability and error handling.
This tutorial demonstrates how to enhance console.log messages with CSS colors, create ASCII art, embed base64‑encoded images, and render SVG or HTML content using the browser console, providing practical code examples and visual illustrations for developers.
This article provides a comprehensive overview of the dynamic cross‑platform (Roma) solution, detailing its JavaScript‑based architecture, integration with Android, iOS, HarmonyOS and Web, the SDK workflow, code examples, and the complete view creation, rendering, and update processes across multiple language environments.
This article explains the architecture and implementation of the Roma dynamic cross‑platform solution, covering its JavaScript‑VM based rendering pipeline, HarmonyOS integration challenges, resource packaging, view creation across JS, C++, and ArkTS layers, and the diff‑based update mechanism that enables seamless UI updates on multiple platforms.
This article explores Goja, a pure‑Go JavaScript engine, detailing its features, integration with the K6 load‑testing tool, and practical code examples for embedding scripts, passing values, handling structs, invoking Go functions, error handling, and VM pooling to achieve high performance in Go applications.
JavaScript’s upcoming safe‑assignment operator ( ?= ) lets developers handle errors without traditional try‑catch blocks, reducing nesting, improving readability, and enabling seamless integration with async/await, Symbol.result, and recursive error handling, as demonstrated through multiple code examples and a polyfill link.
This article presents comprehensive Vue.js and Element‑plus coding standards, covering enum naming, directory and file naming conventions, component file structure, attribute and directive usage, boolean, function, class, constant, and enum naming rules, emphasizing consistency to improve readability and maintainability.
This article explains the Inversion of Control (IoC) principle, why it matters for growing front‑end applications, and demonstrates how to refactor a simple App component using dependency injection and a module registration system, turning the App into a container that manages its dependencies rather than directly instantiating them.
This article introduces the six SOLID principles, categorizes the 23 classic design patterns into creational, structural, and behavioral groups, and provides JavaScript code examples for nine essential frontend patterns to help developers understand and apply them effectively.
Evan You, the creator of Vue.js, announced his new company VoidZero, which plans to build a unified, high‑performance JavaScript toolchain that addresses Vite’s limitations, introduces shared ASTs, common parsers, and faster bundlers like Rolldown, while already securing significant seed funding and industry adoption.
This article reviews the six key ECMAScript 2024 proposals—including well‑formed Unicode strings, asynchronous atomic wait, the new RegExp v flag, ArrayBuffer transfer, array grouping, and Promise.withResolvers—explaining their purpose, API changes, and providing runnable code examples.
This article explains what Hooks are, demonstrates how to use them in Vue 3, and guides readers through building reusable custom Hook functions such as useMouse and useTable, covering pagination, parameter handling, and best practices for clean, maintainable frontend code.
This article walks through building a 3D automotive radar effect using three.js, covering background image loading, fog integration, car model import, radar sector creation with CircleGeometry and Line2, dynamic tween animations, and road texture scrolling to simulate vehicle motion.
The article shows that the standard AbortController API can do far more than just cancel fetch requests—it can cleanly remove event listeners, combine multiple abort signals, control streams, and even make database transactions cancelable, with concrete code examples and compatibility notes.
This article introduces the drag-kit library, explains why it is a good choice for high‑performance, cross‑iframe, responsive drag‑and‑drop interactions, provides quick‑start code examples, details its core features and advanced options, and shows how to integrate it with Vue, React and vanilla JavaScript.
This tutorial shows how to collect, configure, and customize reusable VSCode code snippets for JavaScript, TypeScript, Vue, Java and other languages, enabling developers to replace repetitive boiler‑plate with a single click and tailor placeholder behavior to their workflow.
Learn how to create a custom Chrome extension that generates QR codes for any webpage, covering plugin architecture, manifest configuration, background and popup scripts, testing, and publishing steps, while highlighting benefits like personalization, security, and cost savings for developers.
This article explains why writing a custom Chrome extension is beneficial and provides step‑by‑step instructions, including directory structure, manifest, background script, popup UI, testing, and publishing, to create a QR code generator that works directly from the browser.
The article explains V8’s compiler pipeline from parsing to TurboFan optimization, details tagged pointers, hidden‑class object models and inline caches, and offers practical performance tips such as keeping functions short, preserving monomorphic call sites, stabilizing property order, and avoiding deletes to maintain fast property access.
Discover 20 practical JavaScript techniques—from using let/const and destructuring to async/await and debouncing—that help you write more concise, efficient, and maintainable code while improving overall development workflow.
To simplify large‑scale Vue upgrades such as Vue 2→Vue 3, Webpack 4→Webpack 5, or migration to Vite, the author presents an automated AST‑based migration scaffold that parses JavaScript, Vue, and style files, applies transformation rules with GoGoCode and PostCSS, and rewrites code, reducing manual effort and error risk.
Explore how Yargs middleware enhances command-line tools by allowing pre- and post-validation processing, global and command-specific hooks, and flexible implementation details, with practical code examples, API insights, and strategies for managing, freezing, and resetting middleware chains.
RedMonk’s Q3 2024 language ranking shows a stable top‑20 list with JavaScript, Python and Java leading, highlights TypeScript’s surge, notes the decline of C and Objective‑C, and introduces emerging languages such as Ballerina, Bicep, Zig, Grain and Moonbit.
This article explains JavaScript's pre‑compilation process, including variable and function declaration hoisting, the creation of execution contexts, and the differences between var, let, and const, using several illustrative code examples to clarify how the engine resolves identifiers at runtime.
This article explains the need to adapt the Roma framework for HarmonyOS by selecting and analyzing the V8 JavaScript engine, describes its internal components such as the parser, Ignition interpreter, TurboFan JIT compiler and Orinoco garbage collector, and provides a step‑by‑step guide for cross‑compiling V8 with CMake, GN, Ninja and tool‑chain files to produce a usable library for HarmonyOS native projects.
The JavaScript community, backed by over 2,500 developers and key language creators, is urging Oracle to abandon its unused JavaScript trademark to free the language from legal constraints and restore open use for projects, conferences, and education.
This article explains how to apply Simon Sinek's Golden Circle framework to migrate a large‑scale Webpack‑based frontend project to Vite, detailing the motivations, the faster development experience, step‑by‑step migration procedures, configuration adjustments, and the resulting performance improvements.
The ECMAScript proposal‑safe‑assignment‑operator introduces the ?= operator, which returns an [error, result] tuple, allowing developers to replace verbose try‑catch blocks with concise, readable error handling that works with async functions, Promises, and any object implementing Symbol.result, while also improving code consistency and safety.
This article explains the surprising result of the JavaScript expression [] == ![], detailing how empty arrays are truthy, how they are coerced to strings and numbers during loose equality comparison, and why using strict equality (===) or TypeScript avoids such confusing behavior.
This tutorial explains how to integrate the open‑source ECharts library with a PHP backend to produce interactive statistical charts that include custom labels and legends, providing step‑by‑step code examples for data preparation, HTML markup, and JavaScript configuration.
This tutorial guides beginners through creating a complete user registration and login system using PHP for the backend, MySQL for data storage, and HTML, CSS, and vanilla JavaScript for the frontend, covering environment setup, database creation, form design, server‑side logic, and basic client‑side validation.
This article provides a comprehensive guide to using Vue Flow—a lightweight Vue 3 component library—for building dynamic flowcharts, covering installation, core concepts such as nodes, edges and handles, theme customization, composables, controlled flow demos, and detailed code examples.
This article explores how to make text color automatically adapt to background brightness and how to let users freely customize theme colors while ensuring sufficient contrast, using JavaScript libraries, CSS blend modes, relative color functions, and contrast‑adjustment algorithms.
This article demonstrates how to build a web page that leverages AMap's Arrival Range API and Turf.js to calculate reachable areas, compute their intersection, and search for residential communities within the overlap, providing a practical GIS solution for locating optimal rental locations.
Babel is a micro‑kernel JavaScript transpiler that parses source code into an AST, lets plugins and presets transform it, and generates backward‑compatible code with optional source maps, while its runtime helpers, polyfills, and close alignment with the evolving ECMAScript specification ensure modern syntax works across legacy environments.
The ECMAScript 2024 specification, approved on June 26, introduces six major proposals—including well‑formed Unicode strings, asynchronous atomic wait, a powerful RegExp v flag, ArrayBuffer transfer, native array grouping, and Promise.withResolvers—each illustrated with code examples and practical implications for JavaScript developers.
This article explains how to create a picture‑fragment animation by dividing an image into a grid of small blocks, using CSS background‑size and background‑position together with JavaScript to generate the blocks, apply delays, rotations, scaling, and performance‑optimising techniques.
This article explains the decorator pattern and how Aspect‑Oriented Programming (AOP) can be used in JavaScript to dynamically extend object behavior, provides classic and Vue‑based code examples, discusses advantages and drawbacks, and outlines practical scenarios for applying decorators in front‑end development.
This article examines why storing a string's length in a variable can improve loop performance in JavaScript, explains primitive data types and their wrapper objects, and demonstrates the underlying mechanisms with code examples and timing tests.
This article explains how Google’s Gemini Nano can run directly in the browser via the Prompt API, guides you through enabling the feature in Chrome Canary, checking model readiness, and provides JavaScript code examples for creating text sessions, streaming responses, and building a simple translation demo.
The ZhuanZhuan Frontend Weekly curates five recent technical articles—including a Rust‑based JavaScript bundler, Airbnb’s seamless React upgrade, HarmonyOS ArkUI framework, a JavaScript Super Mario game, and the Interface Segregation Principle in React—providing concise English summaries and links for developers.
A growing movement among web developers, highlighted by Pieter Levels and Alex Russell, argues that relying on basic HTML, PHP, lightweight jQuery, and progressive‑enhancement principles can outperform heavyweight JavaScript frameworks in speed, maintainability, and accessibility.
The article explains how Bilibili leveraged Chrome’s Document Picture‑in‑Picture API to create a cross‑page playback queue displayed in a small always‑on‑top window, detailing style synchronization, independent lifecycle handling via a helper class, and real‑time updates using BroadcastChannel‑plus‑iframe messaging while relying solely on native web features.
Node.js now includes native TypeScript support, letting developers run .ts files directly without extra tools, which simplifies development, removes additional dependencies, and provides a more seamless experience for JavaScript back‑end projects.
Rspack 1.0, the Rust‑implemented next‑generation JavaScript bundler compatible with webpack APIs, launches with major performance gains, broader plugin compatibility, smaller bundle sizes, Module Federation 2.0 support, and a roadmap that includes faster HMR, portable caches, and deeper TypeScript integration.
The article examines the technology behind the Chinese AAA title “Black Myth: Wukong”, revealing its use of Unreal Engine 5 with C++ as the core language, additional JavaScript integration via Unreal.js, and discusses community speculation about tools like PuerTS while also containing promotional material for development tools.
This guide walks through creating a macOS desktop application using Tauri 2.0, demonstrating how to combine any web front‑end framework with Rust for a secure, lightweight, cross‑platform executable, complete with code samples and build steps.
This article explains how Vue2 and Vue3 rewrite array methods to achieve reactivity, compares Object.defineProperty with Proxy, demonstrates common pitfalls such as includes and push causing infinite loops, and provides practical code examples for both versions.
This article explains how to combine duplicate API calls, ensure only the latest request result is displayed, and control concurrent request limits in JavaScript/React applications, providing practical code examples and execution flow analysis.
This article explains how to develop a VSCode extension that injects a video element into the editor’s workbench, allowing users to set a dynamic background video (such as the Wukong promotional clip), with configurable opacity, video selection, installation, and uninstallation instructions.
This article explains why using a JavaScript framework isn’t always necessary, outlining five practical scenarios—simple projects, pure HTML/CSS solutions, modern ES6 features, creative freedom, and HTMX—that allow developers to build efficient web applications without added complexity.
This article explains how to build a lightweight mobile UI inspector for iOS and Android by using a Flask backend to serve screenshots and XML UI trees, converting them to interactive HTML with jQuery, and adding synchronized hover highlighting through randomly generated identifiers.
This article explains ESLint's highly configurable static analysis architecture, clarifies the roles of parsers, processors, configs and plugins, explores the intricacies of its configuration system, and provides practical debugging methods—including performance profiling and a real‑world import/no-cycle case study.
This article explains how to create Apple‑style scroll‑driven line and list‑item animations in a Vue3 website by using a normalized scroll formula, adjusting it for specific sections, and applying a throttle algorithm to keep the animations smooth and performant.
This article explores the classic “Hello World” program across five popular programming languages—Python, C#, C++, JavaScript, and PHP—detailing each language’s syntax, key functions, and code snippets, while reflecting on the significance of this introductory example for beginners.
When a new ChatGPT web release triggers a "Oops, an error occurred! (Try again)" message on older browsers, the article explains how the missing Array.prototype.toSorted() method causes the failure and guides readers through creating a Tampermonkey user script that injects a polyfill to restore functionality.
Node.js v22.6.0 introduces the experimental --experimental-strip-types flag, enabling developers to execute TypeScript files directly, but it only strips type annotations at runtime and imposes several usage constraints such as mandatory type‑only imports and explicit file extensions.
This article explains the JavaScript prototype chain in depth, covering the definitions of prototype and __proto__, their relationships, how objects inherit properties, the role of constructors, and includes practical code examples and visual diagrams to illustrate each concept.
This article explains the challenges of reading and writing deeply nested data in JavaScript, introduces native optional‑chaining and TypeScript solutions, and walks through the design and implementation of a reusable anypath library that supports objects, arrays, Maps and Sets.
The article introduces Rslib, the latest addition to ByteDance’s Rspack family, and reviews its features, roadmap, and how it complements Rspack, Rsbuild, Rspress, and Rsdoctor—highlighting performance, compatibility with Webpack ecosystems, and built‑in tooling for modern JavaScript libraries.
This tutorial walks you through installing Node.js and npm, initializing a project, adding Express, creating routes, handling static files, processing POST requests with body‑parser, implementing simple in‑memory storage, adding error handling, and rendering HTML with EJS, all illustrated with complete code examples.
This article explores why Large Contentful Paint (LCP) often lags behind overall performance scores, explains how to measure LCP using ProductionObserver and web‑vitals, and presents a detailed case study with code snippets and actionable strategies to reduce LCP below 2.5 seconds.
This tutorial demonstrates how to build a realistic snowfall animation on a web page by using CSS radial gradients for snowflakes and a JavaScript class that generates, styles, and animates thousands of snow particles with requestAnimationFrame, including advanced enhancements like speed variation, swing motion, 3D perspective, and rain integration.
This article compares three popular Node.js version managers—fnm, nvm, and Volta—detailing their speed, size, features, ease of use, and community support, and provides guidance on which tool best fits developers’ needs for efficient JavaScript environment management.
This article examines JavaScript’s implicit type conversion mechanisms, illustrating a quirky yet functional code example, detailing conversion rules for symbols, objects, arrays, numbers, booleans, and undefined/null, and highlighting common pitfalls and practical coding tricks.
This article analyzes how JavaScript’s rich functionality, expanding ecosystem, and single‑language workflow have reshaped web development, outlines the essential front‑end and back‑end skills for full‑stack developers, and explores the career advantages and future trends such as WebAssembly.
This tutorial demonstrates how to set up a Vue 3 project, install the Leaflet.TrackPlayer plugin, define a simulated path, create a custom moving marker, and control playback on a Leaflet map, while also covering optional configurations such as disabling marker rotation.
ES8 (ECMAScript 2017) adds trailing commas, async/await syntax, native Object.values/entries methods, padStart/padEnd string padding, and Object.getOwnPropertyDescriptors, enabling cleaner, more concise, and maintainable JavaScript code while simplifying asynchronous handling and object manipulation for developers.
