Tagged articles
ESLint
72 articles · Page 1 of 1
This article evaluates mainstream 2026 code inspection tools—SonarQube, ESLint, CodeQL, Semgrep, Snyk, and pre-commit hooks—comparing their strengths, weaknesses, and integration strategies, then provides a step-by-step enterprise rollout plan for shift-left quality, including rule tiering, CI pipeline placement, quality gates, and an 8-week adoption timeline.
CodeQLESLintSemgrep
0 likes · 27 min read

A step-by-step guide to implementing consistent code formatting and quality checks in Vue2 projects using Prettier for style and ESLint for logic, with exact dependency versions, configuration files, VS Code integration, and husky pre-commit hooks.
ESLintPrettierVS Code
0 likes · 12 min read

This article explains how to use husky and lint-staged to automatically run ESLint and Prettier on staged files before each Git commit, preventing non-compliant code from entering the repository, with step-by-step setup for husky v9, configuration details, common pitfalls, and the complete commit workflow.
ESLintPrettiercode quality
0 likes · 8 min read

This guide clarifies the distinct roles of ESLint (code quality) and Prettier (code formatting), walks through minimal installation, configuration of .eslintrc and .prettierrc, resolves rule conflicts with eslint-config-prettier, adds npm scripts for linting and formatting, and lists common pitfalls with solutions.
ConfigurationESLintPrettier
0 likes · 8 min read

The article explains why Claude.md only obeys about 80% of instructions, introduces Claude Code Hooks as a deterministic alternative, and provides eight ready‑to‑copy hook configurations—including auto‑formatting, dangerous‑command blocking, file protection, test enforcement, linting, command logging, and automatic commits—to reliably enforce code‑quality policies.
ClaudeESLintGit
0 likes · 12 min read

This article presents a comprehensive frontend memory‑leak mitigation system that combines custom ESLint rules, layered testing, and production‑level monitoring to shift leak detection from runtime crashes to code‑commit time, cutting fix cost from days to minutes and achieving a 99% crash‑rate reduction.
ESLintMemory LeakVue
0 likes · 29 min read

Learn how a single ESLint rule can automatically block stray console.log statements from reaching production, improve code reviews, and enforce clean logging practices without changing your workflow, plus optional stricter settings and pre‑commit hooks for even tighter control.
ESLintFrontend DevelopmentLogging
0 likes · 3 min read

Evan You announced that the new OXC toolchain dramatically outperforms Prettier and ESLint—delivering 2‑3× faster formatting, up to 45× faster than Prettier, and 50‑100× faster linting—while staying compatible with existing configurations and offering zero‑migration upgrades for massive codebases.
ESLintOxcPrettier
0 likes · 5 min read

The article traces the evolution of front‑end linting and formatting tools—from JSLint to ESLint, Prettier, and Rust‑based Biome—then introduces Ultracite, a zero‑config, Rust‑fast, AI‑friendly assistant that consolidates linting, formatting, Git hooks and AI integration into a single command.
AI code assistanceBiomeESLint
0 likes · 7 min read

This article explains why chaotic import statements hurt development, outlines the three main pitfalls, and provides a step‑by‑step guide to refactor imports using ESLint plugins, automatic fixing, and Vue‑specific adjustments to achieve a clean, maintainable codebase.
ESLintVuecode quality
0 likes · 9 min read


大转转FEJan 23, 2025 · Frontend Development
This article explains cyclomatic complexity concepts, industry standards, calculation methods, and how a custom ESLint rule can be used to assess both single‑function and nested‑function complexity in front‑end projects, including scoring thresholds and practical implementation details.
ASTESLintcode quality
0 likes · 19 min read


大转转FEJan 17, 2025 · Frontend Development
This article traces the evolution of ESLint from its early role as a simple JavaScript linter to the introduction of the Flat Config system in ESLint 9, examines the challenges of extends, multi‑format support, plugins, and shared configurations, and explores new tools like Config Inspector, eslint‑flat‑config‑utils, ESLint Stylistic, and future multi‑language support.
ConfigurationESLintFlat Config
0 likes · 17 min read

This article explains the new features and breaking changes of ESLint v9, demonstrates how to use the @antfu/eslint-config preset with flat configuration, and shows how to set up Husky Git hooks to enforce linting and automatic fixing in JavaScript projects.
ConfigurationESLintJavaScript
0 likes · 11 min read

This comprehensive guide explains what code maintainability means, why it matters for long‑term project health, and how to measure and improve it using concrete metrics such as naming conventions, comment density, code volume, logical line count, cyclomatic complexity, similarity, redundancy, and module dependencies, with practical examples and tool recommendations for JavaScript front‑end development.
ESLintFrontend DevelopmentJavaScript
0 likes · 50 min read

This article recounts a date‑misalignment bug caused by an unintended Day.js locale change in a mini‑program, explains why the global locale must remain unique, and details a comprehensive static‑analysis solution using ESLint, custom Webpack loaders, and Babel plugins to intercept and block Day.js locale modifications at compile time.
DayjsESLintfrontend
0 likes · 22 min read

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.
ConfigurationESLintJavaScript
0 likes · 13 min read

This article explains why ESLint is essential for front‑end code quality, describes its core features, and provides a detailed five‑step process for integrating ESLint into Vue 3 projects, followed by deeper integration techniques for Vite, Webpack, CI/CD pipelines, Git hooks, and IDEs, complete with practical code examples and troubleshooting tips.
CI/CDESLintVite
0 likes · 18 min read

This article explains how to develop custom ESLint plugins—covering background concepts, Yeoman generator setup, rule implementation for typeof and instanceof checks, unit testing, local linking, and providing recommended configurations—to ensure consistent code style and best‑practice enforcement across a development team.
ESLintFrontend DevelopmentJavaScript
0 likes · 12 min read

The article introduces the newly open‑sourced React Compiler, explains its underlying concepts and automatic memo optimization, provides step‑by‑step usage instructions with health‑check, ESLint and Babel plugins, and shares performance results from Meta’s production apps.
BabelCompilerESLint
0 likes · 6 min read

This article critiques Element‑Plus’s API inconsistencies, debates Vue 3’s ref versus reactive usage, clarifies the v‑for versus v‑if priority question, introduces Volta as a superior Node version manager, examines ESLint versus Prettier decisions, and recounts Didi’s costly Kubernetes outage.
ESLintElement PlusInterview
0 likes · 4 min read

This article surveys recent frontend developments, including detailed SVG rendering techniques, best‑practice code standards with ESLint, Prettier and Husky, emerging trends such as Next.js‑embedded SQL, Vite’s roadmap and Node.js 21’s Stream API upgrades, plus practical UX guidance for legacy browsers and a glimpse of a leading frontend team.
ESLintNext.jsSVG
0 likes · 3 min read

The article traces ESLint’s evolution from a JSLint‑style checker to the dominant JavaScript linter, explains its long‑standing clash with the opinionated formatter Prettier over code‑style rules, and details the team’s decision in v8.53.0 to deprecate built‑in formatting rules in favor of external style plugins and market‑driven style guides.
ESLintFrontend DevelopmentJavaScript
0 likes · 10 min read

The article reports that jQuery version 4.0.0 is 99% complete according to its GitHub milestone, with only one remaining issue related to ESLint upgrades, and highlights the library’s impact on modern JavaScript development.
ESLintMilestonedevelopment
0 likes · 3 min read

This article explains the concepts of external and internal code beauty, introduces essential frontend tooling such as ESLint, Prettier, Stylelint, husky, lint‑staged, EditorConfig, and CSSComb, and shares practical habits on documentation, naming, and commenting to help developers produce elegant, maintainable code.
Clean CodeCode styleESLint
0 likes · 13 min read

The article debunks programmer stereotypes, explains code reproducibility, and recommends five VS Code extensions—ESLint, Prettier, GitLens, Tailwind CSS IntelliSense, and Live Server—to help developers write cleaner, faster, and more maintainable front‑end code.
ESLintGitLensLive Server
0 likes · 5 min read

This guide walks through automating frontend development tasks—using Husky for Git hooks, lint‑staged for staged file filtering, commitlint for standardized commit messages, ESLint and @typescript-eslint for code checking, and Prettier for formatting—providing installation commands, configuration snippets, and practical usage tips for React + TypeScript projects.
ESLintGitPrettier
0 likes · 10 min read


ByteFEFeb 13, 2023 · Frontend Development
This article explains the fundamentals of ESLint, including its purpose, configuration files, AST-based analysis, the SourceCode abstraction, rule template creation, key functions, and the overall linting and fixing workflow, enabling developers to build custom linting plugins for consistent code style.
ASTCode styleESLint
0 likes · 14 min read

This article explores the fundamentals of ESLint, explaining how it leverages abstract syntax trees (AST) to enforce code style, detect errors, and enable custom rule creation, while providing practical configuration examples, code snippets, and insights into the underlying processing pipeline.
ASTCode styleESLint
0 likes · 16 min read

This article describes how to build a tool that automatically extracts event tracking (埋点) information from Vue H5 projects by leveraging custom JSDoc tags, Webpack dependency analysis, and an ESLint plugin, enabling one‑click generation of comprehensive tracking documentation and route mapping.
ESLintJSDocVue
0 likes · 13 min read

This tutorial walks through configuring Stylelint, LS‑Lint, Husky Git hooks, Lint‑Staged, and Commitlint to enforce code style, file‑naming conventions, pre‑commit checks, and conventional commit messages, providing a comprehensive engineering setup for modern frontend projects.
ESLintcommitlintgit-hooks
0 likes · 24 min read

This tutorial explains why and how to create a custom ESLint rule that automatically replaces specified import paths, using AST traversal, rule configuration, and fixers, with a complete example including project scaffolding, implementation details, and unit testing.
ASTESLintJavaScript
0 likes · 8 min read

This tutorial walks you through creating a production‑ready front‑end project from an empty directory using Webpack 5, React 18 and TypeScript, covering project structure, dependencies, Babel and TypeScript setup, resource handling, development environment, performance optimizations, and full configuration files.
BabelConfigurationESLint
0 likes · 26 min read

This article explains why ESLint is essential for frontend development, details how its rule configuration works, walks through the CLI execution flow, and reveals the internal call stack that parses code into an AST, applies custom rules, and performs auto‑fixes.
ASTESLintcli
0 likes · 15 min read

This article explains how Umi 4 redesigns its ESLint setup to reduce rule overload, eliminate unstable dependencies, make configurations transparent, and boost linting performance by removing type‑aware checks, offering a stable, fast, and maintainable linting solution for frontend projects.
ESLintTypeScriptUMI
0 likes · 5 min read

This article chronicles the step‑by‑step optimization of a WeChat mini‑program, covering native stack choices, ES6+ adoption, modular architecture, versioning, code formatting, request abstraction, UI component migration, ESLint, unit testing, routing, environment handling, Gulp workflow, CSS variables, and sub‑package strategies.
ES6ESLintFrontend Optimization
0 likes · 34 min read

This article walks readers through the complete process of building a well‑structured npm package using TypeScript, covering project initialization, package.json configuration, essential tooling such as husky, lint‑staged, eslint, prettier, unit testing with Jest, and best practices for documentation and publishing.
ESLintJestLibrary
0 likes · 15 min read

This article introduces a set of ESLint rules that help developers write safer and more efficient asynchronous JavaScript by avoiding common pitfalls such as async promise executors, awaiting in loops, improper promise handling, and callback-related race conditions.
Best PracticesESLintJavaScript
0 likes · 8 min read

This article presents a collection of ESLint rules for JavaScript asynchronous programming, explaining why patterns like async promise executors, awaiting in loops, returning values from Promise constructors, and others should be avoided, and provides correct code examples to improve readability, performance, and error handling.
Best PracticesESLintJavaScript
0 likes · 8 min read

The guide shows how to build a lightweight, browser‑based WebIDE using Monaco Editor by adding multi‑file support, preserving view state, integrating ESLint via a WebWorker, enabling Prettier formatting, and extending TypeScript definitions for rich code completion and navigation.
ESLintJavaScriptMonaco editor
0 likes · 24 min read

This article examines the limitations of ESLint for error detection, the challenges of a non‑smooth coding experience, and how adopting TypeScript can improve productivity, type safety, and tooling while weighing its learning curve and ecosystem alternatives.
ESLintFrontend DevelopmentIDE
0 likes · 11 min read


ByteFEMar 18, 2022 · Frontend Development
This collection highlights recent technical articles and resources covering Vue 3.0, ESLint fundamentals, defensive CSS techniques, low‑code system design, React project setup, Nest.js with TypeORM, and an introduction to the LRU caching algorithm, offering practical insights for frontend developers.
CSSESLintLRU
0 likes · 4 min read

This comprehensive guide walks developers through creating, testing, and refining custom ESLint rules, covering rule scaffolding, meta configuration, AST traversal, scope analysis, handling various node types, code path analysis, autofix implementation, and extensions for React JSX and TypeScript.
ESLintcustom ruleslinting
0 likes · 19 min read

The article explains why readable code matters, shows a messy JavaScript example, lists common readability problems, and provides concrete guidelines—consistent style, meaningful naming, proper comments, small files, shallow nesting—along with tooling tips such as ESLint, Standard Style, husky and lint‑staged to enforce them.
Code ReadabilityESLintJavaScript
0 likes · 10 min read

This guide walks you through creating a demo-cli project, configuring package.json, setting up bin scripts, understanding Linux and Node bin execution, choosing global versus local installation, adding TypeScript, ESLint, Prettier, lint‑staged, and finally publishing the package to npm.
ESLintNode.jsPrettier
0 likes · 16 min read

This article explains what ESLint is, walks through its installation and basic configuration, dives into detailed rule, parser, and plugin settings, describes its AST‑based analysis process, and shows how to integrate it with tools like VSCode, Prettier, Husky and lint‑staged for robust JavaScript code quality enforcement.
ESLintJavaScriptPrettier
0 likes · 19 min read


政采云技术Oct 26, 2021 · Frontend Development
This article explains how to set up EditorConfig, ESLint, Stylelint, and Prettier in VSCode so that code style rules are automatically applied and fixed on save, covering installation, configuration files, and project‑specific settings for Vue and React.
ESLintPrettierVSCode
0 likes · 17 min read


WeChatFEAug 20, 2021 · Frontend Development
This article explains the roles, differences, and practical usage of Prettier and ESLint in JavaScript projects, demonstrates how to configure and run them, and connects linting to clean‑code principles and effective team workflows.
Clean CodeESLintJavaScript
0 likes · 14 min read

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

The article explains how to design and implement ESLint and StyleLint plugins for the San‑Native framework, detailing AST generation, processor creation, rule definitions for JavaScript and CSS, configuration sharing, and how these tools provide real‑time linting feedback for developers.
ASTESLintJavaScript
0 likes · 24 min read

This article explains how to analyze and reduce React Native bundle size using tools like react-native-bundle-visualizer and the custom CRN bundle analysis platform, covering library replacements, import optimizations, code splitting, static asset handling, and reporting a typical 50% size reduction.
BabelBundle OptimizationCode Splitting
0 likes · 19 min read

This article explains what an Abstract Syntax Tree (AST) is, outlines its parse‑transform‑generate workflow, and demonstrates practical AST‑based code transformations using Babel, custom ESLint rules, and a JSX‑to‑object Babel plugin, complete with example code and visual illustrations.
ASTBabelESLint
0 likes · 14 min read

This article compares Webpack and Rollup, explains why Rollup’s tree‑shaking and ES6 module support make it better for a lightweight JavaScript utility library, and provides a step‑by‑step guide to set up the project with TypeScript, ESLint, Prettier, Husky, Commitlint and Jest testing.
ESLintJavaScriptJest
0 likes · 14 min read

Angular 11.0.0 introduces major updates such as TypeScript 4.0 support, dropping legacy IE versions, automatic font inlining, enhanced test harnesses, faster builds, experimental Webpack 5 support, and a migration from TSLint to ESLint, all detailed with upgrade commands and practical tips.
AngularESLintHMR
0 likes · 5 min read

This guide traces ESLint’s evolution from early lint tools, shows how to install and configure it, run auto‑fixes, integrate with editors, enforce quality via Husky, lint‑staged and commit‑lint, and combine these practices into a defensive moat that keeps repositories clean and consistent.
ESLintFront-endautomation
0 likes · 21 min read

This article explains how to apply incremental thinking to ESLint code checks and webpack builds by using Git diff to detect changed files, running targeted linting and bundling, and demonstrates significant time savings in large front‑end projects.
CIESLintGit
0 likes · 14 min read

This article details the comprehensive redesign of JD VSP's PC platform, covering the motivations for the overhaul, the adoption of Vue, TypeScript, Gaea scaffolding, Legao component library, performance enhancements with icon fonts and PWA caching, and the implementation of robust development tooling such as ESLint and code‑generation workflows.
ESLintPWATypeScript
0 likes · 26 min read


政采云技术Jul 12, 2020 · Frontend Development
This comprehensive guide explores the principles of ESLint and abstract syntax trees, providing step-by-step instructions for developing custom linting rules and plugins to enforce coding standards, prevent hardcoded configurations, and maintain high-quality frontend codebases across collaborative development environments.
AST parsingCustom Linting RulesESLint
0 likes · 10 min read

This article introduces ESLint, explains why JavaScript linting is essential, walks through installation, demonstrates sample code with common errors, shows how to configure rules via .eslintrc.js, and outlines IDE integration to improve frontend development efficiency.
ConfigurationESLintIDE integration
0 likes · 4 min read


WecTeamNov 26, 2019 · Backend Development
This article walks you through converting an existing Node.js codebase to TypeScript, covering directory restructuring, TypeScript and ESLint setup, handling common import and type errors, configuring debugging in VSCode, and gradually strengthening type safety while preserving project functionality.
ESLintNode.jsTypeScript
0 likes · 20 min read

This article explains the purpose and installation of EditorConfig, Prettier, and ESLint, demonstrates how to combine them with TypeScript, Airbnb style guide, and React Hooks, and provides a complete pre‑commit workflow using Husky and lint‑staged for consistent code quality.
AirbnbESLintPrettier
0 likes · 9 min read

The article presents a scalable ESLint‑based framework for large front‑end teams that combines a layered, unified rule configuration, CI/CD and pre‑commit lint checks, a one‑click onboarding CLI, and automated metrics collection with dashboards, enabling consistent code standards across diverse projects while reducing maintenance overhead.
ESLintFront-endJavaScript
0 likes · 20 min read

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.
ESLintJavaScriptReact
0 likes · 12 min read

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.
ESLintJavaScriptlinting
0 likes · 6 min read

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.
ESLintJavaScriptcode quality
0 likes · 6 min read

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.
ESLintJavaScriptcode quality
0 likes · 6 min read

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.
ESLintJavaScripteqeqeq
0 likes · 6 min read

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.
ESLintJavaScriptcode quality
0 likes · 6 min read

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.
ESLintJavaScriptcode quality
0 likes · 6 min read

This guide explains how to install and use npm-check together with ESLint to identify outdated, incorrect, or unused dependencies in a Node.js project, remove unnecessary require statements, and ensure that only needed packages remain in the codebase.
ESLintUnused Dependenciesdependency-management
0 likes · 3 min read

This article explains why ESLint’s no‑return‑assign and no‑constant‑condition rules fire, shows concrete examples—including arrow functions and leftover debug code—and provides step‑by‑step fixes to make the intent of the JavaScript code clear and maintainable.
ESLintJavaScriptcode quality
0 likes · 7 min read

This article presents a comprehensive guide to writing clean, maintainable JavaScript by avoiding legacy pitfalls, applying Clean Code principles, leveraging ES6/ES7 features, and using tools like Babel, ESLint, and Prettier to improve code quality and development efficiency.
BabelClean CodeES6
0 likes · 10 min read

This article explains why rules like eqeqeq, no‑bitwise, and no‑implicit‑coercion should be avoided, shows concrete examples of problematic code, and provides clear manual fixes to improve JavaScript quality with ESLint.
ESLintJavaScriptcode quality
0 likes · 6 min read
