This article explains why and how to use the prop-types package in React for runtime prop validation, covering installation, basic usage, required fields, shape checking, and advanced validators such as arrayOf and objectOf, helping teams catch type errors early.
Bootstrap 3.4.0 has been released after a long delay, bringing new classes, Algolia search, multiple XSS fixes, documentation improvements, upgrade instructions, and a new Open Collective funding project, while also previewing upcoming work on v4.2 and v5.
This guide demonstrates how to configure Node.js stdin for UTF-8, read incoming Chinese text, remove question particles and punctuation, replace question marks with exclamation marks, and output the transformed strings, with clear code examples and expected results.
This article explains Redux’s role in managing complex React state, covering its core concepts such as the single store, immutable state tree, actions, action creators, reducers, middleware, and integration with React via Provider and connect, illustrated with diagrams and practical examples.
This article introduces Babel as a popular JavaScript compiler, explains its origin, demonstrates basic installation and configuration, shows how arrow functions are transformed, and guides readers through creating a simple custom Babel plugin using visitors and AST manipulation.
This article reviews five widely used JavaScript HTTP request libraries—Axios, Superagent, Request, Fetch, and Supertest—detailing their advantages, drawbacks, and typical use cases to help developers choose the most suitable tool for their projects.
This tutorial demonstrates how to configure Spring MVC in a Java web project by modifying web.xml, creating DispatcherServlet, implementing controllers and DTOs, setting up JSP pages with Bootstrap, handling JSTL date formatting using custom tags for Java 8 LocalDateTime, and integrating modular JavaScript for a seckill (flash sale) application.
The Binary AST proposal introduces a three‑layer binary encoding for JavaScript abstract syntax trees, aiming to reduce parsing time by up to 90 % and improve web application startup performance, with early prototypes showing promising results and growing community interest.
This guide walks you through installing ECharts, creating a basic chart in a web page, and using the Python ECharts API, providing step‑by‑step instructions, code snippets, and visual examples for effective data visualization.
This article explains why JavaScript’s Number type suffers from floating‑point precision errors, describes the IEEE‑754 double‑precision storage format, clarifies key Number properties, shows why 0.1 + 0.2 is not exactly 0.3, and provides practical code‑based solutions.
The article examines the popularity of five open‑source programming languages—PHP, Python, JavaScript, Ruby, and Go—by evaluating their community size, typical use cases, dominant frameworks, and career prospects, helping developers choose the most suitable language for web, backend, or emerging applications.
This guide walks through using vue-awesome-swiper in Vue projects, covering version differences, required CSS imports, component setup, and key configuration options such as slidesPerView, centeredSlides, and the coverflow effect, plus progress callbacks and code snippets for dynamic flash‑sale carousels.
This article explains how to use the %c placeholder and CSS strings with console.log to create colorful, formatted debug messages that stand out in large JavaScript log outputs, boosting development efficiency.
This article explains how V8 and Node.js have optimized asynchronous JavaScript—moving from callbacks to promises to async/await—detailing performance gains, engine internals, task/microtask handling, zero‑cost async stack traces, and practical recommendations for developers.
This article outlines the React 16 roadmap, detailing the planned release schedule for Suspense code‑splitting, Hooks, Concurrent Mode, data‑fetching Suspense, and related experimental projects, while explaining their current status across React DOM, server rendering, and React Native.
Using the cloud‑development model, the author built a mini‑program that lets users publish posts with optional images, browse a list of posts, view details, and add comments, leveraging cloud functions for CRUD operations, cloud database for storage, and cloud storage for images, while noting the rapid prototyping advantage and the modest 2 GB database and 5 GB storage limits.
This article walks you through creating a lightweight Koa 2 framework by explaining its core modules—application, request, response, and context—showing how to implement the HTTP server wrapper, the onion‑style middleware composition, and robust error handling with code examples for each step.
The article discusses how type mismatches cause runtime errors in JavaScript projects, explains why static typing with TypeScript can catch these issues at compile time, and argues that rigorous type declarations are essential for building and maintaining large‑scale frontend applications.
The 2018 State of JavaScript survey, answered by over 20,000 developers worldwide, reveals current preferences in languages, frameworks, tools, testing libraries, and emerging trends such as GraphQL and React Hooks, offering valuable insights for front‑end engineers.
Based on the 2018 State of JS survey of over 20,000 developers, this article highlights the rise of ES6 and TypeScript, the dominance of React and Vue, the popularity of Redux and GraphQL, the steady use of Node frameworks, and emerging tools for testing, mobile, and desktop development.
The 2018 State of JavaScript report, based on responses from over 20,000 developers worldwide, reveals the most popular JavaScript flavors, front‑end frameworks, data‑layer tools, backend frameworks, testing libraries, and mobile/desktop runtimes, highlighting shifting preferences, satisfaction levels, and emerging technologies in the ecosystem.
This article presents five useful JavaScript techniques—using Array.includes, early returns, default parameters with destructuring, object literals or Map instead of switch, and Array.every/Array.some—to simplify and make conditional statements more readable and maintainable.
This article explains what higher‑order functions are, why JavaScript supports functional programming, demonstrates built‑in methods like map, filter and reduce with code examples, and shows how to create your own higher‑order function for clearer, more concise code.
This article explains the Virtual DOM concept, outlines a state‑driven rendering approach, implements a minimal Virtual DOM (VD) structure, creates a diff algorithm to generate patch objects, applies those patches to the real DOM, and compares its performance with full re‑rendering.
This article introduces Electron Fiddle, explains how to install and run it, and demonstrates its key features such as template creation, code sharing via GitHub Gist, Monaco editor integration, and packaging apps for Windows, macOS, and Linux.
This article explains why loading all images in a long list hurts performance, presents step‑by‑step lazy‑loading techniques—including placeholder images, scroll calculations, getBoundingClientRect, and the modern IntersectionObserver API—provides full code samples, and discusses optimization tips for smoother front‑end experiences.
The article explains why traditional image‑based log reporting can interfere with critical front‑end tasks, introduces the Beacon API as an asynchronous, low‑priority solution, and provides practical code examples and usage guidelines to ensure reliable data delivery without impacting user experience.
This article explains how to use the new Picture-in-Picture Web API to enable floating video playback on web pages, covering setup of video and button elements, request handling, error management, event listeners, window‑size tracking, feature detection, and best‑practice UI considerations.
Learn how to create reusable, encapsulated UI components using Web Components by building a simple counter element with Custom Elements, Templates, Shadow DOM, properties, events, and attributes, and see how to integrate it into any framework, handle data binding, and dispatch custom events.
The article details a production‑ready Hybrid app bridge built with a custom bridge.js that enables bidirectional communication between Native code and H5 pages, outlines its four‑step nativeCall flow, Android compatibility tricks, protocol categories, event hub, proxy requests, and a suite of reusable functional APIs.
The article explains how to use a custom URL schema together with a WebSocket channel to let a web page detect whether a mobile app is installed, attempt to launch it, and fall back to downloading the app when the launch fails, including practical blur‑event tricks.
This article introduces the most frequently used encryption techniques in frontend development—including Base64 encoding, hash functions, salting, slow hash algorithms, key‑hashing, XOR, symmetric and asymmetric encryption, digital signatures, and practical CryptoJS usage—explaining their principles, appropriate scenarios, and providing ready‑to‑use code examples.
On October 23, React 16.6.0 was released, introducing React.memo for function components, React.lazy with Suspense for code‑splitting, a simpler static contextType API, new error‑boundary methods, and deprecations in StrictMode, along with installation instructions and a detailed changelog.
This guide explains how to calculate viewport dimensions for different operating systems and browsers, use CSS viewport units and media queries to create a single-page design that adapts smoothly across desktop and mobile screens, and provides Sass functions and JavaScript logic for robust implementation.
This article explains the differences between macrotasks and microtasks in the JavaScript event loop, shows how they affect Promise execution, provides practical code examples, and discusses how frameworks like Vue implement task scheduling, helping developers avoid dead‑loops and improve performance.
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.
This article explains how Lighthouse can measure JavaScript execution time, reveal unused code through coverage, and offers practical steps—such as sending only needed scripts, minifying, and removing dead code—to reduce JavaScript overhead and improve user experience on web pages.
This article examines why console.log may produce surprising results in different Chrome DevTools states, explains the underlying asynchronous I/O handling, and offers practical debugging advice for developers working with JavaScript in the browser.
JavaScript’s NaN represents undefined numeric results, appears when operations like Math.sqrt(-1) occur, has multiple binary forms, and is distinguished as Quiet or Signaling; because NaN !== NaN, comparisons rely on special checks such as isnan, with implementations varying across environments like V8 and Apple’s C library.
This article provides a comprehensive guide to using Jest for front‑end unit testing, covering the lack of tests, benefits, installation, basic assertions, matchers, asynchronous testing, lifecycle hooks, mock functions, module mocking, snapshot testing, and best practices to improve code quality and development efficiency.
V8 7.0, released on October 15, introduces memory‑saving Embedded built‑ins across platforms, preview support for WebAssembly threads via chrome://flags, new JavaScript features such as Symbol.prototype.description and a stable Array.prototype.sort using TimSort, plus API changes accessible through git logs and checkout commands.
This article introduces the "wave fluctuation equal distribution" algorithm that splits a value into N parts within a bounded range with random variation, explains its characteristics, and provides two JavaScript implementations—an exhaustive enumeration method and a fast random allocation method—along with performance analysis and validation techniques.
This article provides a comprehensive walkthrough of React‑Router's internal architecture, detailing the implementation of key components such as Router, Route, Switch, Redirect, Prompt, Link, and withRouter, while explaining how history, matchPath, and path‑to‑regexp work together to enable client‑side routing in modern React applications.
This article explains how Mozilla optimized the Firefox engine to dramatically speed up function calls between JavaScript and WebAssembly by reducing bookkeeping, eliminating trampolines, merging activations, applying monomorphic call optimizations, and improving built‑in function handling, resulting in call performance that now exceeds native JavaScript‑to‑JavaScript calls.
The article explains the Virtual DOM as a lightweight JavaScript object with tag, props, and children, shows how JSX compiles to VD using a custom pragma, provides helper functions to create real DOM from VD, and outlines how batching updates reduces reflows, previewing a future diff algorithm.
This article compiles a series of practical solutions for frequent WeChat mini‑program challenges, covering iOS date parsing, live‑stream message throttling, storage sharing, navigation depth limits, floating‑point precision, QR‑code scene length, image preloading, and server‑client time synchronization, with code snippets and explanations.
The article examines WebAssembly as an emerging web development paradigm that offers a compiled, language‑agnostic alternative to JavaScript, discusses its integration with .NET via Mono and Blazor, compares tooling like NuGet to npm/WebPack, and highlights both the benefits and the continued need for JavaScript in modern web applications.
This tutorial walks you through creating a fully functional progressive web app (PWA) game using Preact, covering functional requirements, UI design, routing, component implementation, game logic, offline support, and deployment in a clear, step‑by‑step manner.
The article explains that compiling experimental JavaScript features like JSX or class properties inside node_modules tightly couples libraries to build tools, leading to breaking changes, coordination overhead, and prolonged upgrade pain, which is why Create React App avoids such compilation.
The article explains how Node.js now supports native V8 code‑coverage via the NODE_V8_COVERAGE environment variable, describes the limitations of traditional tools like Istanbul, outlines the benefits and challenges of using V8’s built‑in coverage, and provides practical steps and tools (c8, v8-to-istanbul) to generate readable coverage reports.
This article explains how JavaScript’s single‑threaded model achieves asynchronous behavior through macro‑tasks and micro‑tasks, compares the browser and Node.js event‑loop implementations, and demonstrates the timing differences between setTimeout, setImmediate, and process.nextTick with practical code examples.
This article explains ES6 JavaScript generators, covering their syntax, how they differ from regular iterators, the role of the yield keyword, available generator methods, and practical examples such as custom generators, random number streams, throttling, Fibonacci sequences, and integrating generators with HTML to simplify iterative tasks.
This article explains how to dissect a WeChat mini‑program .wxapkg package, examines the structure and purpose of compiled files such as app‑config.json, app‑service.js, page‑frame.html and resource assets, and provides step‑by‑step Node.js scripts to automatically restore the original source files for further development and debugging.
This article explains JavaScript date and time concepts—including GMT, UTC, ISO 8601, RFC2822, timestamps, parsing, formatting, timezone offsets, localization, and practical internationalization strategies—providing developers with the knowledge to correctly manage time across different regions and platforms.
This article explains the JavaScript Event Loop mechanism in depth, covering the call stack, heap memory, macro‑ and micro‑tasks, and their queues, and demonstrates the execution order through detailed examples and step‑by‑step visualizations of multiple event‑loop cycles.
This article introduces ten indispensable JavaScript array methods—including forEach, includes, filter, map, reduce, some, every, sort, Array.from, and Array.of—explaining their purpose, usage, and providing visual examples to help developers efficiently manipulate arrays in web development.
The article explains Haskell‑style lazy lists, shows why lazy evaluation is useful, and walks through implementing lazy lists in JavaScript using custom classes, the ES6 iterable protocol, and generator functions, providing examples such as repeat, cycle, iterate, range and lazy operators like map, filter, take, and zip.
This article explains why the ESLint no-fallthrough and no-undef rules exist, shows how switch case fall‑through can cause bugs, and provides practical ways—using comments or local variables—to silence warnings while keeping code clean and maintainable.
This article explains ESLint’s no‑empty and no‑empty-function rules, showing how to fix empty blocks by inverting conditions, adding comments, handling silent failures, and using intentional no‑op functions or proper callbacks to keep JavaScript code clean and readable.
This article explains the ESLint rules no‑return‑assign and no‑constant‑condition, shows why they trigger, provides clear examples of problematic code, and offers practical refactoring techniques to resolve the warnings while keeping JavaScript code clean and intention‑clear.
This article explains why ESLint’s eqeqeq, no‑bitwise, and no‑implicit‑coercion rules require manual fixes, demonstrates the pitfalls of using ==, !=, and bitwise operators, and provides clear code examples showing how to replace them with safer, more readable alternatives.
This article introduces the ANU mini‑program framework, explains why WeChat mini‑programs need transpilation tools, compares existing solutions, details ANU's features and limitations, and provides step‑by‑step instructions with code examples for building and running a React‑like mini‑program project.
This guide walks developers through creating a WeChat Mini Program using Tencent Cloud's Serverless Cloud Functions, covering IDE installation, project configuration, cloud environment setup, file upload, cloud‑function development, and invoking functions from the Mini Program, enabling a fully serverless backend without traditional servers.
This article explains why a unified Generic Sensor API is needed, lists the sensors it supports, and provides step‑by‑step JavaScript examples for creating, configuring, and using sensors such as gyroscope, accelerometer, ambient light, magnetometer, and composite orientation sensors, while also covering privacy considerations and future extensions.
This article explains how the render props pattern solves the flexibility and prop‑passing limitations of earlier React design approaches, illustrating the concept with JSX examples, Babel compilation details, and comparisons to props.children for creating highly reusable and readable components.
This comprehensive guide walks experienced front‑end developers through the browser's multi‑process model, internal threading, rendering pipeline, JavaScript single‑threaded execution, event loop mechanics, Web Workers, and performance‑related concepts like macrotasks, microtasks, and hardware‑accelerated compositing.
WeChat Mini Program Cloud Development offers a serverless backend—cloud functions, database, and file storage—exclusively for Mini Programs, providing simple login, generous free tiers, and easy JavaScript integration, while developers must handle promises for async calls and supplement its limited permission model with custom logic.
This article introduces WeChat Mini Program Cloud Development, explains its serverless architecture, compares it with PaaS and BaaS solutions, outlines suitable scenarios, highlights advantages such as built‑in login and free storage, warns of common misconceptions, and shares practical tips and a GitHub demo project.
This article explains how to create smooth, multi‑path paper‑plane flight animations for a mini‑program using CSS3 keyframes, transform versus position, canvas drawing, a reusable Game class, Bezier curve calculations, and inverse‑trigonometric rotation to achieve realistic motion and design flexibility.
This article explains how to handle the ESLint "no-fallthrough" and "no-undef" rules, showing when to add explicit comments, convert globals to locals, and why the comment‑based fix is often the most efficient for legacy JavaScript code.
This comprehensive guide walks you through browser multi‑process architecture, the relationship between processes and threads, the rendering pipeline, Web Workers, and the intricacies of JavaScript's single‑threaded execution and event‑loop mechanisms, providing a solid knowledge framework for front‑end developers.
Chrome extensions are small HTML‑CSS‑JS programs whose functionality is defined in a manifest.json that lists permissions, icons, and components such as background scripts, content scripts, options pages, and UI actions, with communication via runtime messaging, storage via web or Chrome APIs, and updates managed through an update_url.
This article explains React higher‑order components, defining the pattern, distinguishing between props‑proxy and reverse‑inheritance implementations, and illustrating each with practical examples such as Ant Design’s Form.create and a loading wrapper, while discussing lifecycle handling and the advantages of reverse inheritance.
This article provides a comprehensive guide for mobile developers on JavaScript fundamentals such as callback hell, Promises, async/await, the arguments object, call and apply methods, mixins, and prototype inheritance, illustrating each concept with clear explanations and practical code examples to improve React Native coding practices.
This article explains when React's setState behaves synchronously or asynchronously, how batch updates are merged into a single render, and the proper way to retrieve the updated state using the callback parameter, illustrated with clear diagrams and code examples.
This article explains how to resolve the ESLint "no‑empty" and "no‑empty‑function" warnings by refactoring empty blocks, adding explanatory comments, using noop helpers, and validating callbacks, providing concrete code examples and step‑by‑step reasoning.
This article explains the distinction between ECMAScript and JavaScript decorators, walks through the TC39 proposal stages, demonstrates how to work with property descriptors, Object.defineProperty, Object.defineProperties, Object.create, and shows practical examples of method, class‑field, and class decorators using Babel.
This article explains how to transform React class components into WeChat Mini‑Program Component({}) calls by building a custom Babel plugin that extracts class inheritance, methods, state handling, and replaces import/export statements, while also mapping React lifecycle patterns to Mini‑App equivalents.
This article examines the challenges of using WeChat Mini Programs, proposes a React‑style component architecture by mapping Mini Program concepts such as Component, Page, and App to React's state, lifecycle, and JSX, and provides concrete code examples for definition, lifecycle handling, styling, templating, and configuration.
This tutorial walks you through creating a configurable lottery wheel using Canvas in a WeChat Mini Program, covering the overall concept, required WXML layout, animation setup, interactive button handling, and how to display prize rules, with a complete code example.
The G2 3.2 release from AntV introduces a richer visual cognition system with tail‑legend support, region‑filter color guides, new data marker guides, more flexible component configurations, and chart‑level theme customization, while providing installation options via npm or CDN for developers to try the latest features.
RxJS brings the Observable pattern to JavaScript, enabling asynchronous multiple-value streams that combine observer, iterator, and functional concepts, and the article shows how to use it in React and Redux for clean subscription management, data aggregation, advanced async handling, and time‑based operations.
This article demonstrates how to use Selenium WebDriver with JavaScript to automate the Geetest sliding captcha, covering installation, element interaction, image capture, pixel analysis, and human‑like sliding trajectory generation to illustrate both the challenges and techniques involved.
A former communications engineering graduate shares a detailed chronicle of ten front‑end interview experiences across startups, small firms, mid‑size companies, and a pre‑IPO e‑commerce firm in Shanghai, highlighting interview questions, personal reflections, and actionable lessons for aspiring developers.
This article examines WebAssembly’s core features—loading speed, execution performance, memory model, garbage collection, API access, multithreading, and portability—comparing them to JavaScript, and discusses suitable use cases such as high‑CPU tasks, gaming, and image processing, while noting current limitations and future prospects.
This article explains the performance characteristics and implementation details of common linear data structures such as arrays, hash maps, sets, lists, linked lists, stacks, and queues, showing their time complexities, code examples, and how to choose the right structure for efficient programming.
This article explains Node.js's internal architecture—including the standard library, bindings, V8 engine, libuv I/O library, code structure, event loop, and concurrency model—providing a comprehensive overview for developers who want to master backend development with Node.
This article introduces JavaScript’s Proxy object, explains its core concepts—targets, handlers, and traps—and demonstrates practical uses such as property validation, data binding, and wrapping RESTful API calls with code examples, highlighting its versatility for developers.
This article provides a detailed overview of ReactJS, covering its origins, virtual DOM mechanism, component‑based architecture, common misconceptions, setup steps, JSX syntax, component properties, state management, lifecycle methods, and practical code examples for building interactive web interfaces.
This article introduces SpriteJS, a cross‑platform canvas library from 360 Qiwang Team, showing how to create structured UI, draw shapes, apply transitions, use the Web Animation API, work with textures, paths, groups, events, D3 integration, physics engines and particle systems, all with practical JavaScript code examples.
SpriteJS is an open‑source, cross‑platform JavaScript library that simplifies canvas drawing by providing a DOM‑like API for creating sprites, paths, groups, and animations, integrating seamlessly with tools such as D3, Matter‑JS, Proton, and CurveJS for rich interactive visualizations.
SpriteJS is an open‑source, cross‑terminal canvas library from 360 Qiyou that provides a DOM‑like API for drawing shapes, creating sprites, animating with transitions or the Web Animation API, handling textures, vectors, groups, events, and integrating with D3, physics engines and particle systems.
Yu Guo’s talk surveys future‑oriented full‑stack trends—rising languages like Python, mobile‑first Swift, shifting frameworks from jQuery to React/Vue, evolving build tools, and practical learning strategies such as deliberate practice, skill‑model mapping, and algorithmic optimizations—emphasizing continual adaptability for developers.
This article explains how to protect data exchanged between front‑end and back‑end services by using HTTPS, request signing, SSL pinning, and a Spring Boot starter that transparently encrypts/decrypts all API traffic with AES, complemented by JavaScript AES utilities and Axios interceptors for front‑end encryption.
This article introduces a lightweight easing algorithm that moves an element by half the remaining distance each frame, provides a requestAnimationFrame polyfill, a reusable Math.easeout function, and shows real‑world usage in Qidian's scroll‑to‑top and other UI effects.
This article explains how React 16 rewrote its server‑side rendering layer to support four rendering modes—including string and streaming approaches—by introducing the ReactPartialRenderer and ReactMarkupReadableStream classes, and details the process of converting virtual DOM trees into HTML strings.
This weekly newsletter curates nine insightful articles covering Google’s Guess.js toolkit, I/O 2018 web highlights, front‑end AR techniques, Chrome’s autoplay restrictions, a deep dive into Redux, WebAssembly versus JavaScript performance, comprehensive CSS line‑break methods, ten common software architecture patterns, and guidance on front‑end engineer career advancement.
This article explores extracting dominant theme colors from images directly in the browser using Canvas, compares the median‑cut and octree algorithms, provides full JavaScript implementations, and evaluates performance and accuracy against server‑side CGI results.
The article advises beginners that the specific programming language matters less than learning core concepts, recommending Python, Java, Ruby, and JavaScript as strong entry points while emphasizing flexibility, job prospects, and the importance of not getting stuck on a single language.
This article explains the WebSocket protocol, compares it with traditional Ajax polling, shows client‑side JavaScript and server‑side Python implementations, details the handshake, frame parsing, and message framing, and highlights its suitability for real‑time applications.
