BestHub
Sign in
Tagged articles
167 articles
Page 2 of 2
DaTaobao Tech
DaTaobao Tech
Aug 17, 2022 · Frontend Development

Understanding and Using the useReducer Hook in React

React’s useReducer hook, introduced in version 16.8, lets a component manage complex state by supplying a reducer function and an initial value, returning [state, dispatch] where dispatch triggers actions; it supports lazy initialization, centralizes updates, works with useContext for shared state, and is preferable to useState for non‑trivial logic but less suited than full Redux for large‑scale state needs.

JavaScriptReactState Management
0 likes · 19 min read
Understanding and Using the useReducer Hook in React
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
May 5, 2022 · Frontend Development

React 18 New Features, Upgrade Guide, and API Changes

This article provides a comprehensive overview of React 18, covering its release timeline, migration steps, new APIs such as the root API, useId, useSyncExternalStore and useInsertionEffect, automatic state batching, flushSync, updated Strict Mode and Suspense behavior, concurrent mode concepts, and practical code examples for developers upgrading from React 17.

Concurrent ModeReactReact 18
0 likes · 22 min read
React 18 New Features, Upgrade Guide, and API Changes
KooFE Frontend Team
KooFE Frontend Team
Apr 17, 2022 · Frontend Development

Master Global State Management in React with Custom Hooks

Learn how to build a simple global state management solution in React using custom hooks, starting from a basic counter component, extending it with initialization props, synchronizing multiple counters, and finally creating a reusable createGlobalState utility for shared state across components.

Custom HookReactfrontend development
0 likes · 9 min read
Master Global State Management in React with Custom Hooks
LOFTER Tech Team
LOFTER Tech Team
Apr 6, 2022 · Frontend Development

State Management in React: From Redux to Unstated‑Next, Constate, Zustand, Jotai and Valtio

This article reviews the evolution of React state‑management solutions, comparing classic Redux with modern Hook‑based libraries such as Unstated‑Next, Constate, Zustand, Jotai and Valtio, explains core concepts like algebraic effects, context duplication, and provides practical code examples and performance tips.

Context APIReactRedux
0 likes · 21 min read
State Management in React: From Redux to Unstated‑Next, Constate, Zustand, Jotai and Valtio
BaiPing Technology
BaiPing Technology
Mar 28, 2022 · Backend Development

From Zero to Automation: Mastering API Testing with HttpRunner and Apifox

This article shares a small team's journey from scratch to advanced API testing, detailing how they adopted HttpRunner, upgraded to its pytest‑compatible v3.x, and later integrated Apifox for streamlined documentation, mocking, and automated tests, while highlighting practical setup, hooks, and lessons learned.

API testingApifoxHttpRunner
0 likes · 8 min read
From Zero to Automation: Mastering API Testing with HttpRunner and Apifox
ByteDance ADFE Team
ByteDance ADFE Team
Mar 24, 2022 · Frontend Development

Understanding SWR: Stale‑While‑Revalidate Data Fetching in React

This article explains the SWR library—a lightweight React hook that implements the stale‑while‑revalidate caching strategy—covering its core concepts, basic usage, advanced features like global configuration and middleware, and an overview of its internal implementation.

Data FetchingReactSWR
0 likes · 15 min read
Understanding SWR: Stale‑While‑Revalidate Data Fetching in React
Xianyu Technology
Xianyu Technology
Mar 9, 2022 · Frontend Development

Standardizing Interactive Tasks and Lottery Features on the Xianyu Platform

Xianyu standardized its interactive tasks and lottery features by abstracting capabilities into a reusable SDK, providing self‑diagnosis tools, and unifying configuration workflows, which cut front‑end development time by about half, enable operators to troubleshoot without developers, and lower launch and testing costs across large‑scale marketing events.

LotterySDKfrontend
0 likes · 10 min read
Standardizing Interactive Tasks and Lottery Features on the Xianyu Platform
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Feb 18, 2022 · Frontend Development

Evolution of React State Management: From Local Hooks to Unstated‑Next, Hox, and Zustand

The article traces React’s state‑management evolution from basic useState hooks through unstated‑next and hox to the minimalist zustand library, showing how each step reduces boilerplate, eliminates prop‑drilling and deep providers, and enables precise, hook‑based updates for modern functional components.

HoxJavaScriptReact
0 likes · 13 min read
Evolution of React State Management: From Local Hooks to Unstated‑Next, Hox, and Zustand
Tencent Cloud Developer
Tencent Cloud Developer
Jan 18, 2022 · Frontend Development

Writing Reusable Code: Principles and Practices for Front-End Development

Writing reusable front‑end code means identifying and extracting repeatable UI components, centralized API request/response handling, common business‑flow logic, shared state management, and utility functions into separate, modular files or libraries, which reduces duplication, eases maintenance, and improves scalability across similar scenarios.

ReactVuecode quality
0 likes · 7 min read
Writing Reusable Code: Principles and Practices for Front-End Development
Beike Product & Technology
Beike Product & Technology
Jan 7, 2022 · Frontend Development

Understanding React Hooks: Principles, Implementation, and Usage

This article explains why React introduced Hooks, how they solve state‑reuse and component‑complexity problems, details the internal fiber architecture behind useState, useReducer, useEffect, useLayoutEffect, useCallback and useMemo, and provides practical code examples for each.

JavaScriptReacthooks
0 likes · 18 min read
Understanding React Hooks: Principles, Implementation, and Usage
KooFE Frontend Team
KooFE Frontend Team
Oct 17, 2021 · Frontend Development

Why React Hooks Were Created and How to Choose Between ahooks and react-use

This article explains why React introduced Hooks, compares the official Hooks with popular third‑party libraries ahooks and react‑use, lists their most useful Hooks, shows how to install them, and provides a custom Hook example for displaying error modals, helping developers write cleaner, more reusable functional components.

JavaScriptReactahooks
0 likes · 16 min read
Why React Hooks Were Created and How to Choose Between ahooks and react-use
TikTok Frontend Technology Team
TikTok Frontend Technology Team
Oct 15, 2021 · Frontend Development

React Runtime Optimization: From React 15 to 18 – Architecture, Scheduling, and New Features

This article provides a comprehensive overview of React's runtime optimization strategies across versions 15 to 18, explaining the evolution of its architecture, the introduction of Fiber, concurrent rendering, scheduling, priority lanes, and new APIs such as Suspense, startTransition, and useDeferredValue, while including detailed code excerpts and practical insights for developers.

Concurrent ModeFiberReact
0 likes · 35 min read
React Runtime Optimization: From React 15 to 18 – Architecture, Scheduling, and New Features
政采云技术
政采云技术
Sep 15, 2021 · Frontend Development

Using React Profiler for Performance Analysis and Optimization

This article explains how to install and use the React Profiler tool to identify performance bottlenecks in React applications, demonstrates analysis of render phases with example code, and discusses optimization techniques such as React.memo, PureComponent, shouldComponentUpdate, and hooks to reduce unnecessary re‑renders.

Reacthooksmemoization
0 likes · 12 min read
Using React Profiler for Performance Analysis and Optimization
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 30, 2021 · Frontend Development

Can Design Patterns Make Your React Hooks More Elegant?

This article explores how classic design patterns and solid principles can be applied to React Hooks development, demonstrating with Context, custom global state, useState vs useReducer, and custom hook composition to improve code maintainability and reduce unnecessary re‑renders.

Custom HookState Managementhooks
0 likes · 16 min read
Can Design Patterns Make Your React Hooks More Elegant?
Taobao Frontend Technology
Taobao Frontend Technology
Aug 12, 2021 · Backend Development

Midway 2.0 Unveiled: Key Features and Performance Boosts for Node.js Developers

Midway 2.0 introduces a runtime‑based Hook system, removes compiler constraints, enables faster startup under 2 seconds, supports code reuse, new middleware models, flexible configuration via midway.config.ts, enhanced testing utilities, and broader deployment scenarios including web servers, all backed by open‑source Vite and Prisma integrations.

Backend DevelopmentConfigurationMidway
0 likes · 12 min read
Midway 2.0 Unveiled: Key Features and Performance Boosts for Node.js Developers
ByteDance ADFE Team
ByteDance ADFE Team
Jul 28, 2021 · Frontend Development

Why Use TypeScript? Benefits, Setup, and Type Definitions for React Development

This article explains the drawbacks of weakly‑typed JavaScript, outlines the advantages of adopting TypeScript, and provides practical guidance on configuring ESLint, Prettier, tsconfig, and React component typings—including hooks, event handling, and generic utilities—to improve code quality and developer productivity.

ESLintGenericsPrettier
0 likes · 14 min read
Why Use TypeScript? Benefits, Setup, and Type Definitions for React Development
ByteDance Web Infra
ByteDance Web Infra
Jul 12, 2021 · Frontend Development

Dan’s Live Interview on React Core: State Management, Hooks, Concurrent Mode, and Future Directions

In this extensive live interview, React core maintainer Dan discusses his programming origins, the philosophy behind React state management and Hooks, practical advice for newcomers, the challenges of Concurrent Mode and Server Components, and his vision for React’s evolution and competitiveness.

Concurrent ModeReactServer Components
0 likes · 44 min read
Dan’s Live Interview on React Core: State Management, Hooks, Concurrent Mode, and Future Directions
KooFE Frontend Team
KooFE Frontend Team
Jul 7, 2021 · Frontend Development

How React 18’s Automatic Batching Reduces Renders and Boosts Performance

React 18 introduces automatic batching that merges multiple state updates into a single render across all contexts—including promises, timeouts, and native events—improving performance while offering opt‑out mechanisms like flushSync for rare cases where immediate DOM updates are required.

Automatic BatchingReactReact 18
0 likes · 13 min read
How React 18’s Automatic Batching Reduces Renders and Boosts Performance
Taobao Frontend Technology
Taobao Frontend Technology
Jun 24, 2021 · Frontend Development

Rethinking React Hooks: Functional Programming, TypeScript, and Cross‑Framework Insights

This article explores why React moved from class components to the Hooks API, explains its functional‑programming roots, compares Hooks with Redux, Mixins, HOCs, Vue's Composition API, and demonstrates how TypeScript type inference and codata concepts can deepen understanding while providing practical code examples.

Composition APIReactVue
0 likes · 21 min read
Rethinking React Hooks: Functional Programming, TypeScript, and Cross‑Framework Insights
政采云技术
政采云技术
Jun 1, 2021 · Frontend Development

Hands‑On Introduction to Writing a Webpack Plugin

This article provides a step‑by‑step guide to understanding Webpack fundamentals, the role of plugins, hook mechanisms, and a complete example of creating a custom plugin that merges route files into a unified router configuration for a large React project.

Build ToolTapablehooks
0 likes · 18 min read
Hands‑On Introduction to Writing a Webpack Plugin
Alibaba Terminal Technology
Alibaba Terminal Technology
May 11, 2021 · Frontend Development

How Hook-Based Request Libraries Simplify Data Fetching in Modern Frontend Apps

This article examines the evolution of frontend request libraries—from jQuery Ajax to modern hook-based solutions like useRequest, SWR, and react-query—highlighting their simplified loading state handling, cache mechanisms, refetching, and mutate features, and comparing their design differences with class components.

Data FetchingReactSWR
0 likes · 10 min read
How Hook-Based Request Libraries Simplify Data Fetching in Modern Frontend Apps
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Apr 27, 2021 · Frontend Development

Mastering React Error Boundaries: Build a Flexible Error‑Handling Wheel

This tutorial walks through why catching front‑end component errors is essential, demonstrates how to implement a custom React ErrorBoundary with flexible fallback options, reset logic, higher‑order component wrappers, and hooks, and provides complete TypeScript examples and best‑practice summaries.

Error HandlingErrorBoundaryHigher-Order Component
0 likes · 19 min read
Mastering React Error Boundaries: Build a Flexible Error‑Handling Wheel
ByteFE
ByteFE
Apr 19, 2021 · Frontend Development

Advanced TypeScript and React Patterns: Importing React, Functional Components, Hooks, Props, and Types

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

PropsReactTypeScript
0 likes · 23 min read
Advanced TypeScript and React Patterns: Importing React, Functional Components, Hooks, Props, and Types
ELab Team
ELab Team
Apr 14, 2021 · Frontend Development

Recoil vs Redux & MobX: Modern React State Management Explained

Recoil, Facebook’s experimental state‑management library for React, offers a hook‑based, orthogonal approach that reduces overhead compared to Redux and MobX, supports both synchronous and asynchronous selectors, provides utilities like atomFamily and selectorFamily, and integrates seamlessly with React’s concurrent features, making it a promising frontend solution.

ReactState Managementfrontend
0 likes · 11 min read
Recoil vs Redux & MobX: Modern React State Management Explained
Taobao Frontend Technology
Taobao Frontend Technology
Apr 13, 2021 · Frontend Development

Why React Hooks? Uncover Functional Patterns Beyond Class Components

This article explores the motivations behind React's Hooks API, contrasts it with the traditional Class API, delves into functional programming concepts, demonstrates practical implementations with Redux, Mixins, HOCs, custom Hooks, TypeScript type inference, codata theory, and compares React Hooks to Vue's Composition API, providing code examples and visual diagrams throughout.

Reactfrontendhooks
0 likes · 21 min read
Why React Hooks? Uncover Functional Patterns Beyond Class Components
Liangxu Linux
Liangxu Linux
Apr 11, 2021 · Fundamentals

Master Git Workflows: From Flow Models to Advanced Commands

This guide walks through common enterprise Git workflows, daily best‑practice tips, essential commands, configuration options, merge vs. rebase decisions, history rewriting, reflog recovery, batch editing, hook scripts, shallow cloning for large projects, and stash techniques for handling interruptions.

GitVersion Controlhooks
0 likes · 18 min read
Master Git Workflows: From Flow Models to Advanced Commands
Alibaba Terminal Technology
Alibaba Terminal Technology
Apr 7, 2021 · Frontend Development

Why Hooks? Uncovering the Functional Foundations of React and Beyond

This article explores the motivations behind React's Hooks API, contrasts it with the Class API, delves into functional programming concepts, demonstrates implementations via Mixins, HOCs, and custom hooks, and compares React Hooks to Vue's Composition API, offering deep insights for front‑end developers.

Composition APIReactTypeScript
0 likes · 22 min read
Why Hooks? Uncovering the Functional Foundations of React and Beyond
KooFE Frontend Team
KooFE Frontend Team
Apr 5, 2021 · Frontend Development

How to Write Clean, Maintainable React Components: Proven Tips

This article reviews practical techniques for writing cleaner React components, covering anti‑patterns like prop spreading, using object parameters, curried event handlers, preferring map over if/else, leveraging custom hooks, and splitting components with wrappers, separation of concerns, and dedicated files to improve readability and scalability.

Code CleanlinessComponent DesignReact
0 likes · 11 min read
How to Write Clean, Maintainable React Components: Proven Tips
Sohu Tech Products
Sohu Tech Products
Mar 10, 2021 · Mobile Development

SwiftUI Hooks: Bringing React‑style Hook Architecture to SwiftUI

SwiftUI Hooks is an open‑source library that adapts React Hooks concepts for SwiftUI, providing state‑and‑lifecycle hooks such as useState, useEffect, useMemo, and custom hooks, along with usage rules, testing utilities, context handling, and installation instructions for iOS development.

React HooksState ManagementSwiftUI
0 likes · 11 min read
SwiftUI Hooks: Bringing React‑style Hook Architecture to SwiftUI
vivo Internet Technology
vivo Internet Technology
Mar 3, 2021 · Frontend Development

Understanding Tapable: Architecture, Hook Types, and Practical Applications

Tapable powers Webpack’s extensible workflow by providing a dynamic function generator and a suite of over ten hook classes—such as SyncHook, AsyncSeriesWaterfallHook, and AsyncParallelHook—that let developers compose synchronous, asynchronous, bail‑out, waterfall, and looping pipelines, illustrated by a jQuery.ajax‑style service where each request phase is modularly plugged in.

JavaScriptTapablehooks
0 likes · 18 min read
Understanding Tapable: Architecture, Hook Types, and Practical Applications
ELab Team
ELab Team
Feb 26, 2021 · Frontend Development

Mastering React Hooks: Best Practices and Streamlined Patterns

This article reviews React Hooks, compares them with class components, demonstrates change‑driven coding with practical examples, introduces marble diagrams for visualizing state flows, and explores advanced patterns like custom hooks, immutable data handling, and global state management for more maintainable frontend development.

ReactState Managementfrontend
0 likes · 18 min read
Mastering React Hooks: Best Practices and Streamlined Patterns
DeWu Technology
DeWu Technology
Nov 30, 2020 · Frontend Development

Understanding Vue.js Lifecycle Hooks

Vue.js lifecycle hooks guide developers through a component’s creation, mounting, updating, and destruction phases, providing automatic callbacks such as beforeCreate, created, beforeMount, mounted, beforeUpdate, updated, beforeDestroy, and destroyed, which enable proper data fetching, DOM manipulation, reactive updates, and resource cleanup at the appropriate moments.

LifecycleVue.jsWeb Development
0 likes · 8 min read
Understanding Vue.js Lifecycle Hooks
政采云技术
政采云技术
Nov 24, 2020 · Frontend Development

Blending React Hooks with Class Components: Practical Patterns and Code

This article explains why mixing React Hooks with existing Class Components is often necessary, compares three integration techniques—Render Props, Higher‑Order Components, and Ref forwarding with useImperativeHandle—provides complete code examples for each, and discusses current Hook limitations and future support.

Class ComponentHigher-Order ComponentReact
0 likes · 11 min read
Blending React Hooks with Class Components: Practical Patterns and Code
Architects Research Society
Architects Research Society
Nov 4, 2020 · Frontend Development

React as a State Management Library: Best Practices and Patterns

This article explains how React can serve as a complete state‑management solution by using hooks, lifting state, component composition, the Context API, and optional libraries, while also covering performance tips, server‑cached versus UI state, and when to adopt external tools.

Context APIReactState Management
0 likes · 15 min read
React as a State Management Library: Best Practices and Patterns
Taobao Frontend Technology
Taobao Frontend Technology
Oct 15, 2020 · Cloud Native

How Midway Serverless Redefines Cloud‑Native Development with React‑Style Hooks

This article introduces Midway Serverless, a new cloud‑native Node.js framework that brings React‑like Hooks to serverless development, explains Alibaba's Serverless landscape, details the framework’s toolchain, architecture and standards, showcases its functional R&D, API‑free calls, progressive development features, and shares performance results and future plans.

Functional DevelopmentMidwayNode.js
0 likes · 16 min read
How Midway Serverless Redefines Cloud‑Native Development with React‑Style Hooks
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Aug 11, 2020 · Frontend Development

Understanding React Fiber Architecture: Reconciliation, Scheduling, and Commit Phases

React Fiber replaces the old Stack Reconciler with a linked‑list of Fiber nodes that enable incremental, pause‑and‑resume rendering, priority scheduling, and a three‑step commit phase, allowing smoother asynchronous updates, better performance, and the foundation for Concurrent Mode and Suspense.

Concurrent ModeFiberJavaScript
0 likes · 23 min read
Understanding React Fiber Architecture: Reconciliation, Scheduling, and Commit Phases
360 Tech Engineering
360 Tech Engineering
Aug 3, 2020 · Frontend Development

Implementing React useState Hook from Scratch: Detailed Explanation and Code

This article explains how to recreate the React useState hook by following the React source execution flow, describing the update mechanism, circular linked‑list queue, fiber storage, scheduling simulation, and differences from the official implementation, all illustrated with complete JavaScript code examples.

ReactState Managementhooks
0 likes · 10 min read
Implementing React useState Hook from Scratch: Detailed Explanation and Code
21CTO
21CTO
Jul 4, 2020 · Fundamentals

Master Git: Essential Commands, Workflows, and Best Practices

This comprehensive guide covers Git fundamentals, including workspace concepts, configuration, common commands for adding, committing, branching, merging, rebasing, stashing, submodules, hook setup, branch management strategies, and solutions to frequent Git issues, providing developers with a complete reference for effective version control.

Version Controlbest practicesbranching
0 likes · 35 min read
Master Git: Essential Commands, Workflows, and Best Practices
ITPUB
ITPUB
Jul 3, 2020 · Fundamentals

Master Git: Essential Commands, Workflows, and Best Practices

This comprehensive guide explains Git's core concepts, configuration, common commands, branching strategies, hooks, submodules, and troubleshooting tips, providing clear examples and code snippets to help developers efficiently manage version control in any project.

command-linehookssubmodule
0 likes · 37 min read
Master Git: Essential Commands, Workflows, and Best Practices
Youzan Coder
Youzan Coder
May 22, 2020 · Frontend Development

Why Does React Hooks Show Stale State? Unraveling Closures and Dependency Arrays

This article explores why React Hooks can display stale state values, comparing functional and class components, explaining closure behavior, dependency‑array mechanics, proper data‑fetching patterns, and when to replace useState with useReducer to avoid common pitfalls.

ReactState Managementfunctional components
0 likes · 13 min read
Why Does React Hooks Show Stale State? Unraveling Closures and Dependency Arrays
360 Quality & Efficiency
360 Quality & Efficiency
Mar 20, 2020 · Fundamentals

Common pytest Hooks and Their Usage

This article introduces the most frequently used pytest hooks, categorizing them into guiding, initialization, test execution, collection, reporting, and debug hooks, and explains how to implement custom behavior in conftest.py or plugins for advanced test automation.

hookspytesttest framework
0 likes · 8 min read
Common pytest Hooks and Their Usage
360 Tech Engineering
360 Tech Engineering
Dec 30, 2019 · Frontend Development

Designing Reusable React Components for Content Lists with Integrated Advertisements

This article explains how to abstract and reuse React component logic for inserting advertisements into content lists by comparing several design patterns—including composition, inheritance, container‑presentational, render props, and higher‑order components—and then demonstrates a modern solution using React Hooks to simplify data fetching and event tracking.

Ad IntegrationComponent DesignReact
0 likes · 15 min read
Designing Reusable React Components for Content Lists with Integrated Advertisements
QQ Music Frontend Team
QQ Music Frontend Team
Nov 9, 2019 · Frontend Development

5 Ways to Reuse and Extend React Component State Logic

This article explains five approaches—Mixins, Class Inheritance, Higher‑Order Components, Render Props, and Hooks—for reusing and extending state logic in React components, comparing their advantages, drawbacks, and providing code examples to illustrate each method.

Higher-Order ComponentReactRender Props
0 likes · 11 min read
5 Ways to Reuse and Extend React Component State Logic
GF Securities FinTech
GF Securities FinTech
Aug 1, 2019 · Mobile Development

How to Upgrade React Native to 0.59.10 for 64‑Bit Support

This guide explains why Google’s 64‑bit requirement forces a React Native upgrade, outlines the benefits of moving to version 0.59.10, and provides step‑by‑step instructions for updating iOS, Android, Babel configuration, native modules, and handling deprecated components and API changes.

64-bitAndroidXReact Native
0 likes · 10 min read
How to Upgrade React Native to 0.59.10 for 64‑Bit Support
Ctrip Technology
Ctrip Technology
Jul 18, 2019 · Frontend Development

React Hooks: From Mixins and HOCs to Custom Hook Implementations and Production Practices

This article explains the evolution of React component reuse—from legacy mixins and higher‑order components to modern React Hooks—provides step‑by‑step implementations of custom hooks such as useLogTime, useFetchHook, useInterval and useImgLazy, and demonstrates how to apply them in real‑world production code for better performance and maintainability.

CustomHookHOCReact
0 likes · 22 min read
React Hooks: From Mixins and HOCs to Custom Hook Implementations and Production Practices
Didi Tech
Didi Tech
Jul 13, 2019 · Frontend Development

Unlocking Webpack’s Tapable: How Hooks Power Efficient Builds

This article explains the inner workings of Tapable—the hook library behind Webpack—by detailing its synchronous and asynchronous hook types, registration and invocation methods, the lazy‑compilation code‑generation process, and how these mechanisms give Webpack a performance edge over naïve event loops.

Code GenerationJavaScriptTapable
0 likes · 17 min read
Unlocking Webpack’s Tapable: How Hooks Power Efficient Builds
MaoDou Frontend Team
MaoDou Frontend Team
May 20, 2019 · Frontend Development

Mastering React Hooks: Practical Guide, Patterns, and Performance Tips

This article explains React Hooks introduced in version 16.8, their backward‑compatible design, how they replace class components, and provides detailed guidance on using useState, useEffect, custom hooks, useReducer, useRef, useMemo, useCallback, and related linting rules with performance‑focused examples.

JavaScriptReacthooks
0 likes · 16 min read
Mastering React Hooks: Practical Guide, Patterns, and Performance Tips
UC Tech Team
UC Tech Team
Feb 18, 2019 · Frontend Development

React Hooks – Introduction, Usage, Tooling, and Changelog

This article introduces React Hooks, explains how they enable state and other React features without classes, provides official resources, outlines migration advice, details supported packages, tooling integrations, testing APIs, installation methods, and summarizes the changelog and post‑alpha updates for the stable 16.8 release.

ESLintInstallationJavaScript
0 likes · 12 min read
React Hooks – Introduction, Usage, Tooling, and Changelog
UC Tech Team
UC Tech Team
Dec 26, 2018 · Frontend Development

Reflections on the Design, Implementation, and Future of React Hooks

The article provides a comprehensive analysis of React Hooks, covering their injection model, persistent call ordering, debugging and testing strategies, API design considerations such as useReducer, Context Provider, useEffect, missing APIs, type handling, compilation optimizations, safety concerns, and the overall motivation behind moving from class components to hooks.

DebuggingReactapi-design
0 likes · 21 min read
Reflections on the Design, Implementation, and Future of React Hooks
UC Tech Team
UC Tech Team
Nov 28, 2018 · Frontend Development

React 16 Roadmap: Upcoming Features and Release Timeline

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.

Concurrent ModeJavaScriptReact
0 likes · 13 min read
React 16 Roadmap: Upcoming Features and Release Timeline
37 Interactive Technology Team
37 Interactive Technology Team
Nov 28, 2018 · Game Development

Business System Architecture Design: An Engineer's Guide to Game Event Systems

The article explains how engineers can design robust game special‑event systems by abstracting features into reusable components, applying hook‑based extensibility, and using asynchronous message middleware to handle diverse, time‑critical, high‑risk operations, illustrated with the 37 Platform’s event architecture and configuration‑driven flexibility.

Message MiddlewareSystem Architecturehooks
0 likes · 9 min read
Business System Architecture Design: An Engineer's Guide to Game Event Systems
Xianyu Technology
Xianyu Technology
Jul 20, 2018 · R&D Management

Linking Code Commits with Work Items Using Git Hooks and CLI Tools

The article describes a low‑cost solution that uses Git hooks and a custom CLI tool to automatically embed work‑item IDs from branch names or interactive selection into commit messages, enabling seamless traceability between code commits and requirements or defects and simplifying automated testing and team collaboration.

AutomationCLIGit
0 likes · 13 min read
Linking Code Commits with Work Items Using Git Hooks and CLI Tools
Qunar Tech Salon
Qunar Tech Salon
Mar 28, 2018 · Frontend Development

Key New Features and Architectural Changes in React 16

This article reviews the major additions and deprecations introduced in React 16, including component array returns, portals, error boundaries, fragments, strict mode, the new context API, createRef/forwardRef, fiber architecture, and async rendering utilities, illustrated with code examples.

Context APIJavaScriptReact
0 likes · 9 min read
Key New Features and Architectural Changes in React 16
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Jul 11, 2017 · Frontend Development

Master Angular Component Lifecycle: Hooks, Order, and Best Practices

This article explains Angular’s component lifecycle, detailing each hook—from ngOnChanges and ngOnInit to ngAfterViewChecked and ngOnDestroy—their execution order, purposes, and how constructors differ, supplemented with diagrams and console output examples to help developers effectively manage component initialization, change detection, and cleanup.

Angularcomponent lifecyclefrontend development
0 likes · 4 min read
Master Angular Component Lifecycle: Hooks, Order, and Best Practices
Aotu Lab
Aotu Lab
Apr 14, 2017 · Operations

Automate Blog Deployment with Git Hooks: A Step‑by‑Step Guide

This tutorial explains what Git hooks are, how to install and configure them, and provides a complete example of using a post‑update hook on a bare repository to automatically deploy a blog whenever code is pushed.

AutomationBare RepositoryDeployment
0 likes · 7 min read
Automate Blog Deployment with Git Hooks: A Step‑by‑Step Guide
21CTO
21CTO
Mar 11, 2016 · Backend Development

How WordPress Achieves Extensibility with Meta Tables and Hook System

This article explains how WordPress uses the wp_postmeta table for flexible metadata storage and the hook (action) system for dynamic code insertion, illustrating both the benefits and trade‑offs of these extensibility techniques for plugin development.

MetaPlugin DevelopmentWordPress
0 likes · 8 min read
How WordPress Achieves Extensibility with Meta Tables and Hook System