求推荐Angular内存视图工具/插件：调试时探索内存对象排查泄漏

Hey there! Let me walk you through some excellent tools and plugins that mirror IntelliJ's Memory View functionality—perfect for digging into in-memory objects during debug sessions, tracking down memory leaks like undestroyed service instances, or forgotten subscriptions that are clogging up your app.

These tools integrate directly into your IDE, just like IntelliJ's Memory View, so you can switch between debugging and memory analysis without leaving your workspace.

Visual Studio & VS Code #

• Visual Studio Memory Usage Tool: Built right into Visual Studio, you can capture memory snapshots mid-debug, browse object hierarchies, filter by type, and trace retention paths. It’s fantastic for spotting uncollected service instances—just look for objects that should’ve been disposed but still show up in the snapshot.
• VS Code Debugger Memory Inspector: For VS Code users, the built-in debugger includes a memory inspector tab (supported for JavaScript/TypeScript, .NET, and more). You can load heap snapshots, search for specific objects, and dig into reference chains to figure out why a subscription or service isn’t getting cleaned up.

Eclipse #

• Memory Analyzer Tool (MAT) Integration: Eclipse works tightly with MAT, letting you capture heap dumps during debugging then drill into object instances. Use the Dominator Tree to find memory hogs, and the Path to GC Roots feature to trace exactly what’s keeping your service instance or subscription alive.

If you need flexibility across IDEs or are working with a tech stack that doesn’t have tight IDE integration, these standalone tools have you covered:

Java (Matching IntelliJ’s Common Use Case) #

• jmap & jhat: These are built-in JDK utilities. Run jmap -dump:format=b,file=heapdump.hprof <pid> to capture a heap dump, then load it into jhat to browse the object graph. It’s low-level but super handy when you don’t have an IDE open.
• VisualVM: Another JDK-included tool that connects to running processes, takes memory snapshots, and analyzes object retention. Its user-friendly interface mirrors IntelliJ’s view, with features to track live objects and their reference chains.

JavaScript/TypeScript (Frontend & Node.js) #

• Chrome DevTools Memory Tab: If you’re working on frontend apps or Node.js, this is a must-have. Take heap snapshots, compare before/after states (perfect for verifying if subscriptions were unsubscribed), and use the Retainers view to see exactly what’s holding onto your objects.

.NET #

• dotMemory: A dedicated tool from JetBrains (the creators of IntelliJ) that integrates with Visual Studio and Rider. You can take memory snapshots during debugging, analyze object graphs, and set up leak detection sessions that highlight objects that should’ve been garbage collected but aren’t—ideal for hunting down undestroyed service instances.

• Capture before/after snapshots: Trigger an action that should clean up a service/subscription, then compare the two snapshots to check if the object count didn’t drop as expected.
• Use "Path to GC Roots" or Retainers: This feature will show you the exact chain of objects keeping your target instance alive—often it’s an event listener or subscription that was never unsubscribed.
• Filter by object type: If you know the class name of your service, filter the object list to only show those instances—cuts through the noise and speeds up your investigation.

内容的提问来源于stack exchange，提问作者Abdennacer Lachiheb