n8n节点配置指南：操作感知与渐进式披露最佳实践 | SkillsMD

n8n节点配置指南：操作感知与渐进式披露最佳实践

n8n-node-configuration by czlonkowski/n8n-skills

1,700 周安装量

3,700 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/czlonkowski/n8n-skills --skill n8n-node-configuration

开发开发运维生产力

🇨🇳中文介绍

n8n 节点配置

面向操作感知的节点配置专家指南，涵盖属性依赖关系。

配置理念

渐进式披露：从最小配置开始，按需增加复杂性

配置最佳实践：

使用 get_node 并设置 detail: "standard" 是最常用的发现模式
配置编辑之间的平均间隔为 56 秒
使用 1-2K token 的响应覆盖 95% 的用例

关键洞察：大多数配置只需要标准详情，而非完整模式！

核心概念

1. 操作感知配置

并非所有字段都始终必需 - 这取决于操作！

示例：Slack 节点

// 对于 operation='post'
{
  "resource": "message",
  "operation": "post",
  "channel": "#general",  // post 操作必需
  "text": "Hello!"        // post 操作必需
}

// 对于 operation='update'
{
  "resource": "message",
  "operation": "update",
  "messageId": "123",     // update 操作必需（不同！）
  "text": "Updated!"      // update 操作必需
  // channel 对于 update 操作不是必需的
}

：资源 + 操作决定了哪些字段是必需的！

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

相关 Skills

find-skills 技能搜索工具 - Vercel Labs 开源智能体技能包管理器

685,800 周安装

Vercel React 最佳实践指南 | 58条Next.js性能优化规则与代码重构

240,900 周安装

Vercel Web界面规范检查工具 - 自动检测代码是否符合Web设计指南

193,000 周安装

agent-browser 浏览器自动化工具 - Vercel Labs 命令行网页操作与测试

125,300 周安装

React 组合模式指南：Vercel 组件架构最佳实践，提升代码可维护性

// 当 method='GET' 时
{
  "method": "GET",
  "url": "https://api.example.com"
  // sendBody 不显示（GET 没有请求体）
}

// 当 method='POST' 时
{
  "method": "POST",
  "url": "https://api.example.com",
  "sendBody": true,       // 现在可见！
  "body": {               // 当 sendBody=true 时必需
    "contentType": "json",
    "content": {...}
  }
}

1. 识别节点类型和操作
   ↓
2. 使用 get_node（标准详情是默认值）
   ↓
3. 配置必需字段
   ↓
4. 验证配置
   ↓
5. 如果字段不明确 → get_node({mode: "search_properties"})
   ↓
6. 根据需要添加可选字段
   ↓
7. 再次验证
   ↓
8. 部署

// 目标：向 API 发送 POST JSON 请求

const info = get_node({
  nodeType: "nodes-base.httpRequest"
});

// 返回：method, url, sendBody, body, authentication 必需/可选信息

{
  "method": "POST",
  "url": "https://api.example.com/create",
  "authentication": "none"
}

validate_node({
  nodeType: "nodes-base.httpRequest",
  config,
  profile: "runtime"
});
// → 错误："POST 需要 sendBody"

{
  "method": "POST",
  "url": "https://api.example.com/create",
  "authentication": "none",
  "sendBody": true
}

validate_node({...});
// → 错误："当 sendBody=true 时需要 body"

{
  "method": "POST",
  "url": "https://api.example.com/create",
  "authentication": "none",
  "sendBody": true,
  "body": {
    "contentType": "json",
    "content": {
      "name": "={{$json.name}}",
      "email": "={{$json.email}}"
    }
  }
}

validate_node({...});
// → 有效！ ✅

get_node({
  nodeType: "nodes-base.slack"
});
// detail="standard" 是默认值

get_node({
  nodeType: "nodes-base.slack",
  detail: "full"
});

get_node({
  nodeType: "nodes-base.httpRequest",
  mode: "search_properties",
  propertyQuery: "auth"
});

┌─────────────────────────────────┐
│ 开始新的节点配置？               │
├─────────────────────────────────┤
│ 是 → get_node（标准详情）       │
└─────────────────────────────────┘
         ↓
┌─────────────────────────────────┐
│ 标准详情包含所需内容？           │
├─────────────────────────────────┤
│ 是 → 使用它进行配置             │
│ 否 → 继续                       │
└─────────────────────────────────┘
         ↓
┌─────────────────────────────────┐
│ 查找特定字段？                   │
├─────────────────────────────────┤
│ 是 → search_properties 模式     │
│ 否 → 继续                       │
└─────────────────────────────────┘
         ↓
┌─────────────────────────────────┐
│ 仍需要更多详情？                 │
├─────────────────────────────────┤
│ 是 → get_node({detail: "full"}) │
└─────────────────────────────────┘

{
  "name": "body",
  "displayOptions": {
    "show": {
      "sendBody": [true],
      "method": ["POST", "PUT", "PATCH"]
    }
  }
}

// sendBody 控制 body 的可见性
{
  "sendBody": true   // → body 字段出现
}

// 不同的操作 → 不同的字段
{
  "resource": "message",
  "operation": "post"
  // → 显示：channel, text, attachments 等
}

{
  "resource": "message",
  "operation": "update"
  // → 显示：messageId, text（不同的字段！）
}

{
  "type": "string",
  "operation": "contains"
  // → 显示：value1, value2
}

{
  "type": "boolean",
  "operation": "equals"
  // → 显示：value1, value2, 不同的操作符
}

get_node({
  nodeType: "nodes-base.httpRequest",
  mode: "search_properties",
  propertyQuery: "body"
});

// 返回匹配 "body" 的属性路径及其描述

get_node({
  nodeType: "nodes-base.httpRequest",
  detail: "full"
});

// 返回包含 displayOptions 规则的完整模式

{
  "resource": "<entity>",      // 操作对象类型
  "operation": "<action>",     // 对其执行的操作
  // ... 操作特定字段
}

{
  "method": "<HTTP_METHOD>",
  "url": "<endpoint>",
  "authentication": "<type>",
  // ... 方法特定字段
}

{
  "operation": "<query|insert|update|delete>",
  // ... 操作特定字段
}

{
  "conditions": {
    "<type>": [
      {
        "operation": "<operator>",
        "value1": "...",
        "value2": "..."  // 仅用于二元操作符
      }
    ]
  }
}

{
  "resource": "message",
  "operation": "post",
  "channel": "#general",      // 必需
  "text": "Hello!",           // 必需
  "attachments": [],          // 可选
  "blocks": []                // 可选
}

{
  "resource": "message",
  "operation": "update",
  "messageId": "1234567890",  // 必需（与 post 不同！）
  "text": "Updated!",         // 必需
  "channel": "#general"       // 可选（可以推断）
}

{
  "resource": "channel",
  "operation": "create",
  "name": "new-channel",      // 必需
  "isPrivate": false          // 可选
  // 注意：此操作不需要 text
}

{
  "method": "GET",
  "url": "https://api.example.com/users",
  "authentication": "predefinedCredentialType",
  "nodeCredentialType": "httpHeaderAuth",
  "sendQuery": true,                    // 可选
  "queryParameters": {                  // 当 sendQuery=true 时显示
    "parameters": [
      {
        "name": "limit",
        "value": "100"
      }
    ]
  }
}

{
  "method": "POST",
  "url": "https://api.example.com/users",
  "authentication": "none",
  "sendBody": true,                     // POST 必需
  "body": {                             // 当 sendBody=true 时必需
    "contentType": "json",
    "content": {
      "name": "John Doe",
      "email": "john@example.com"
    }
  }
}

{
  "conditions": {
    "string": [
      {
        "value1": "={{$json.status}}",
        "operation": "equals",
        "value2": "active"              // 二元：需要 value2
      }
    ]
  }
}

{
  "conditions": {
    "string": [
      {
        "value1": "={{$json.email}}",
        "operation": "isEmpty",
        // 没有 value2 - 一元操作符
        "singleValue": true             // 由清理功能自动添加
      }
    ]
  }
}

body 在以下情况必需：
  - sendBody = true 并且
  - method 属于 (POST, PUT, PATCH, DELETE)

// 选项 1：读取验证错误
validate_node({...});
// 错误："当 sendBody=true 时需要 body"

// 选项 2：搜索属性
get_node({
  nodeType: "nodes-base.httpRequest",
  mode: "search_properties",
  propertyQuery: "body"
});
// 显示：body 属性及其 displayOptions 规则

// 选项 3：尝试最小配置并迭代
// 开始时没有 body，验证会告知是否需要

singleValue 在以下情况应为 true：
  - operation 属于 (isEmpty, isNotEmpty, true, false)

get_node({
  nodeType: "nodes-base.if",
  detail: "full"
});
// 显示包含操作符特定规则的完整模式

// 添加所有可能的字段
{
  "method": "GET",
  "url": "...",
  "sendQuery": false,
  "sendHeaders": false,
  "sendBody": false,
  "timeout": 10000,
  "ignoreResponseCode": false,
  // ... 还有 20 多个可选字段
}

// 从最小配置开始
{
  "method": "GET",
  "url": "...",
  "authentication": "none"
}
// 仅在需要时添加字段

// 配置并部署而不验证
const config = {...};
n8n_update_partial_workflow({...});  // 冒险操作

// 部署前验证
const config = {...};
const result = validate_node({...});
if (result.valid) {
  n8n_update_partial_workflow({...});
}

// 所有 Slack 操作使用相同配置
{
  "resource": "message",
  "operation": "post",
  "channel": "#general",
  "text": "..."
}

// 然后切换操作而不更新配置
{
  "resource": "message",
  "operation": "update",  // 已更改
  "channel": "#general",  // update 的错误字段！
  "text": "..."
}

// 更改操作时检查要求
get_node({
  nodeType: "nodes-base.slack"
});
// 查看 update 操作需要什么（messageId，而不是 channel）

🇺🇸English

n8n Node Configuration

Expert guidance for operation-aware node configuration with property dependencies.

Configuration Philosophy

Progressive disclosure : Start minimal, add complexity as needed

Configuration best practices:

get_node with detail: "standard" is the most used discovery pattern
56 seconds average between configuration edits
Covers 95% of use cases with 1-2K tokens response

Key insight : Most configurations need only standard detail, not full schema!

Core Concepts

1. Operation-Aware Configuration

Not all fields are always required - it depends on operation!

Example : Slack node

// For operation='post'
{
  "resource": "message",
  "operation": "post",
  "channel": "#general",  // Required for post
  "text": "Hello!"        // Required for post
}

// For operation='update'
{
  "resource": "message",
  "operation": "update",
  "messageId": "123",     // Required for update (different!)
  "text": "Updated!"      // Required for update
  // channel NOT required for update
}

Key : Resource + operation determine which fields are required!

2. Property Dependencies

Fields appear/disappear based on other field values

Example : HTTP Request node

// When method='GET'
{
  "method": "GET",
  "url": "https://api.example.com"
  // sendBody not shown (GET doesn't have body)
}

// When method='POST'
{
  "method": "POST",
  "url": "https://api.example.com",
  "sendBody": true,       // Now visible!
  "body": {               // Required when sendBody=true
    "contentType": "json",
    "content": {...}
  }
}

Mechanism : displayOptions control field visibility

3. Progressive Discovery

Use the right detail level :

get_node({detail: "standard"}) - DEFAULT
- Quick overview (~1-2K tokens)
- Required fields + common options
- Use first - covers 95% of needs
get_node({mode: "search_properties", propertyQuery: "..."}) (for finding specific fields)
- Find properties by name
- Use when looking for auth, body, headers, etc.
get_node({detail: "full"}) (complete schema)
- All properties (~3-8K tokens)
- Use only when standard detail is insufficient

Configuration Workflow

Standard Process

1. Identify node type and operation
   ↓
2. Use get_node (standard detail is default)
   ↓
3. Configure required fields
   ↓
4. Validate configuration
   ↓
5. If field unclear → get_node({mode: "search_properties"})
   ↓
6. Add optional fields as needed
   ↓
7. Validate again
   ↓
8. Deploy

Example: Configuring HTTP Request

Step 1 : Identify what you need

// Goal: POST JSON to API

Step 2 : Get node info

const info = get_node({
  nodeType: "nodes-base.httpRequest"
});

// Returns: method, url, sendBody, body, authentication required/optional

Step 3 : Minimal config

{
  "method": "POST",
  "url": "https://api.example.com/create",
  "authentication": "none"
}

Step 4 : Validate

validate_node({
  nodeType: "nodes-base.httpRequest",
  config,
  profile: "runtime"
});
// → Error: "sendBody required for POST"

Step 5 : Add required field

{
  "method": "POST",
  "url": "https://api.example.com/create",
  "authentication": "none",
  "sendBody": true
}

Step 6 : Validate again

validate_node({...});
// → Error: "body required when sendBody=true"

Step 7 : Complete configuration

{
  "method": "POST",
  "url": "https://api.example.com/create",
  "authentication": "none",
  "sendBody": true,
  "body": {
    "contentType": "json",
    "content": {
      "name": "={{$json.name}}",
      "email": "={{$json.email}}"
    }
  }
}

Step 8 : Final validation

validate_node({...});
// → Valid! ✅

get_node Detail Levels

Standard Detail (DEFAULT - Use This!)

✅ Starting configuration

get_node({
  nodeType: "nodes-base.slack"
});
// detail="standard" is the default

Returns (~1-2K tokens):

Required fields
Common options
Operation list
Metadata

Use : 95% of configuration needs

Full Detail (Use Sparingly)

✅ When standard isn't enough

get_node({
  nodeType: "nodes-base.slack",
  detail: "full"
});

Returns (~3-8K tokens):

Complete schema
All properties
All nested options

Warning : Large response, use only when standard insufficient

Search Properties Mode

✅ Looking for specific field

get_node({
  nodeType: "nodes-base.httpRequest",
  mode: "search_properties",
  propertyQuery: "auth"
});

Use : Find authentication, headers, body fields, etc.

Decision Tree

┌─────────────────────────────────┐
│ Starting new node config?       │
├─────────────────────────────────┤
│ YES → get_node (standard)       │
└─────────────────────────────────┘
         ↓
┌─────────────────────────────────┐
│ Standard has what you need?     │
├─────────────────────────────────┤
│ YES → Configure with it         │
│ NO  → Continue                  │
└─────────────────────────────────┘
         ↓
┌─────────────────────────────────┐
│ Looking for specific field?     │
├─────────────────────────────────┤
│ YES → search_properties mode    │
│ NO  → Continue                  │
└─────────────────────────────────┘
         ↓
┌─────────────────────────────────┐
│ Still need more details?        │
├─────────────────────────────────┤
│ YES → get_node({detail: "full"})│
└─────────────────────────────────┘

Property Dependencies Deep Dive

displayOptions Mechanism

Fields have visibility rules :

{
  "name": "body",
  "displayOptions": {
    "show": {
      "sendBody": [true],
      "method": ["POST", "PUT", "PATCH"]
    }
  }
}

Translation : "body" field shows when:

sendBody = true AND
method = POST, PUT, or PATCH

Common Dependency Patterns

Pattern 1: Boolean Toggle

Example : HTTP Request sendBody

// sendBody controls body visibility
{
  "sendBody": true   // → body field appears
}

Pattern 2: Operation Switch

Example : Slack resource/operation

// Different operations → different fields
{
  "resource": "message",
  "operation": "post"
  // → Shows: channel, text, attachments, etc.
}

{
  "resource": "message",
  "operation": "update"
  // → Shows: messageId, text (different fields!)
}

Pattern 3: Type Selection

Example : IF node conditions

{
  "type": "string",
  "operation": "contains"
  // → Shows: value1, value2
}

{
  "type": "boolean",
  "operation": "equals"
  // → Shows: value1, value2, different operators
}

Finding Property Dependencies

Use get_node with search_properties mode :

get_node({
  nodeType: "nodes-base.httpRequest",
  mode: "search_properties",
  propertyQuery: "body"
});

// Returns property paths matching "body" with descriptions

Or use full detail for complete schema :

get_node({
  nodeType: "nodes-base.httpRequest",
  detail: "full"
});

// Returns complete schema with displayOptions rules

Use this when : Validation fails and you don't understand why field is missing/required

Common Node Patterns

Pattern 1: Resource/Operation Nodes

Examples : Slack, Google Sheets, Airtable

Structure :

{
  "resource": "<entity>",      // What type of thing
  "operation": "<action>",     // What to do with it
  // ... operation-specific fields
}

How to configure :

Choose resource
Choose operation
Use get_node to see operation-specific requirements
Configure required fields

Pattern 2: HTTP-Based Nodes

Examples : HTTP Request, Webhook

Structure :

{
  "method": "<HTTP_METHOD>",
  "url": "<endpoint>",
  "authentication": "<type>",
  // ... method-specific fields
}

Dependencies :

POST/PUT/PATCH → sendBody available
sendBody=true → body required
authentication != "none" → credentials required

Pattern 3: Database Nodes

Examples : Postgres, MySQL, MongoDB

Structure :

{
  "operation": "<query|insert|update|delete>",
  // ... operation-specific fields
}

Dependencies :

operation="executeQuery" → query required
operation="insert" → table + values required
operation="update" → table + values + where required

Pattern 4: Conditional Logic Nodes

Examples : IF, Switch, Merge

Structure :

{
  "conditions": {
    "<type>": [
      {
        "operation": "<operator>",
        "value1": "...",
        "value2": "..."  // Only for binary operators
      }
    ]
  }
}

Dependencies :

Binary operators (equals, contains, etc.) → value1 + value2
Unary operators (isEmpty, isNotEmpty) → value1 only + singleValue: true

Operation-Specific Configuration

Slack Node Examples

Post Message

{
  "resource": "message",
  "operation": "post",
  "channel": "#general",      // Required
  "text": "Hello!",           // Required
  "attachments": [],          // Optional
  "blocks": []                // Optional
}

Update Message

{
  "resource": "message",
  "operation": "update",
  "messageId": "1234567890",  // Required (different from post!)
  "text": "Updated!",         // Required
  "channel": "#general"       // Optional (can be inferred)
}

Create Channel

{
  "resource": "channel",
  "operation": "create",
  "name": "new-channel",      // Required
  "isPrivate": false          // Optional
  // Note: text NOT required for this operation
}

HTTP Request Node Examples

GET Request

{
  "method": "GET",
  "url": "https://api.example.com/users",
  "authentication": "predefinedCredentialType",
  "nodeCredentialType": "httpHeaderAuth",
  "sendQuery": true,                    // Optional
  "queryParameters": {                  // Shows when sendQuery=true
    "parameters": [
      {
        "name": "limit",
        "value": "100"
      }
    ]
  }
}

POST with JSON

{
  "method": "POST",
  "url": "https://api.example.com/users",
  "authentication": "none",
  "sendBody": true,                     // Required for POST
  "body": {                             // Required when sendBody=true
    "contentType": "json",
    "content": {
      "name": "John Doe",
      "email": "john@example.com"
    }
  }
}

IF Node Examples

String Comparison (Binary)

{
  "conditions": {
    "string": [
      {
        "value1": "={{$json.status}}",
        "operation": "equals",
        "value2": "active"              // Binary: needs value2
      }
    ]
  }
}

Empty Check (Unary)

{
  "conditions": {
    "string": [
      {
        "value1": "={{$json.email}}",
        "operation": "isEmpty",
        // No value2 - unary operator
        "singleValue": true             // Auto-added by sanitization
      }
    ]
  }
}

Handling Conditional Requirements

Example: HTTP Request Body

Scenario : body field required, but only sometimes

Rule :

body is required when:
  - sendBody = true AND
  - method IN (POST, PUT, PATCH, DELETE)

How to discover :

// Option 1: Read validation error
validate_node({...});
// Error: "body required when sendBody=true"

// Option 2: Search for the property
get_node({
  nodeType: "nodes-base.httpRequest",
  mode: "search_properties",
  propertyQuery: "body"
});
// Shows: body property with displayOptions rules

// Option 3: Try minimal config and iterate
// Start without body, validation will tell you if needed

Example: IF Node singleValue

Scenario : singleValue property appears for unary operators

Rule :

singleValue should be true when:
  - operation IN (isEmpty, isNotEmpty, true, false)

Good news : Auto-sanitization fixes this!

Manual check :

get_node({
  nodeType: "nodes-base.if",
  detail: "full"
});
// Shows complete schema with operator-specific rules

Configuration Anti-Patterns

❌ Don't: Over-configure Upfront

Bad :

// Adding every possible field
{
  "method": "GET",
  "url": "...",
  "sendQuery": false,
  "sendHeaders": false,
  "sendBody": false,
  "timeout": 10000,
  "ignoreResponseCode": false,
  // ... 20 more optional fields
}

Good :

// Start minimal
{
  "method": "GET",
  "url": "...",
  "authentication": "none"
}
// Add fields only when needed

❌ Don't: Skip Validation

Bad :

// Configure and deploy without validating
const config = {...};
n8n_update_partial_workflow({...});  // YOLO

Good :

// Validate before deploying
const config = {...};
const result = validate_node({...});
if (result.valid) {
  n8n_update_partial_workflow({...});
}

❌ Don't: Ignore Operation Context

Bad :

// Same config for all Slack operations
{
  "resource": "message",
  "operation": "post",
  "channel": "#general",
  "text": "..."
}

// Then switching operation without updating config
{
  "resource": "message",
  "operation": "update",  // Changed
  "channel": "#general",  // Wrong field for update!
  "text": "..."
}

Good :

// Check requirements when changing operation
get_node({
  nodeType: "nodes-base.slack"
});
// See what update operation needs (messageId, not channel)

Best Practices

✅ Do

Start with get_node (standard detail)
- ~1-2K tokens response
- Covers 95% of configuration needs
- Default detail level
Validate iteratively
- Configure → Validate → Fix → Repeat
- Average 2-3 iterations is normal
- Read validation errors carefully
Use search_properties mode when stuck
- If field seems missing, search for it
- Understand what controls field visibility
- get_node({mode: "search_properties", propertyQuery: "..."})
Respect operation context
- Different operations = different requirements
- Always check get_node when changing operation
- Don't assume configs are transferable
Trust auto-sanitization
- Operator structure fixed automatically
- Don't manually add/remove singleValue
- IF/Switch metadata added on save

❌ Don't

Jump to detail="full" immediately
- Try standard detail first
- Only escalate if needed
- Full schema is 3-8K tokens
Configure blindly
- Always validate before deploying
- Understand why fields are required
- Use search_properties for conditional fields
Copy configs without understanding
- Different operations need different fields
- Validate after copying
- Adjust for new context
Manually fix auto-sanitization issues
- Let auto-sanitization handle operator structure
- Focus on business logic
- Save and let system fix structure

Detailed References

For comprehensive guides on specific topics:

DEPENDENCIES.md - Deep dive into property dependencies and displayOptions
OPERATION_PATTERNS.md - Common configuration patterns by node type

Summary

Configuration Strategy :

Start with get_node (standard detail is default)
Configure required fields for operation
Validate configuration
Search properties if stuck
Iterate until valid (avg 2-3 cycles)
Deploy with confidence

Key Principles :

Operation-aware : Different operations = different requirements
Progressive disclosure : Start minimal, add as needed
Dependency-aware : Understand field visibility rules
Validation-driven : Let validation guide configuration

Related Skills :

n8n MCP Tools Expert - How to use discovery tools correctly
n8n Validation Expert - Interpret validation errors
n8n Expression Syntax - Configure expression fields
n8n Workflow Patterns - Apply patterns with proper configuration

Weekly Installs

1.2K

Repository

czlonkowski/n8n-skills

GitHub Stars

3.3K

First Seen

Jan 20, 2026

Security Audits

Gen Agent Trust HubPass SocketPass SnykPass

Installed on

opencode1.0K

gemini-cli986

codex956

github-copilot865

cursor789

claude-code785

n8n节点配置指南：操作感知与渐进式披露最佳实践

🇨🇳中文介绍

n8n 节点配置

配置理念

核心概念

1. 操作感知配置

相关 Skills

2. 属性依赖

3. 渐进式发现

配置工作流

标准流程

示例：配置 HTTP 请求

get_node 详情级别

标准详情（默认 - 使用这个！）

完整详情（谨慎使用）

搜索属性模式

决策树

属性依赖深入探讨

displayOptions 机制

常见依赖模式

模式 1：布尔切换

模式 2：操作切换

模式 3：类型选择

查找属性依赖

常见节点模式

模式 1：资源/操作节点

模式 2：基于 HTTP 的节点

模式 3：数据库节点

模式 4：条件逻辑节点

操作特定配置

Slack 节点示例

发布消息

更新消息

创建频道

HTTP 请求节点示例

GET 请求

带 JSON 的 POST 请求

IF 节点示例

字符串比较（二元）

空值检查（一元）

处理条件性要求

示例：HTTP 请求体

示例：IF 节点 singleValue

配置反模式

❌ 不要：预先过度配置

❌ 不要：跳过验证

❌ 不要：忽略操作上下文

最佳实践

✅ 应该做

❌ 不应该做

详细参考

总结

🇺🇸English

n8n Node Configuration

Configuration Philosophy

Core Concepts

1. Operation-Aware Configuration

2. Property Dependencies

3. Progressive Discovery

Configuration Workflow

Standard Process

Example: Configuring HTTP Request

get_node Detail Levels

Standard Detail (DEFAULT - Use This!)

Full Detail (Use Sparingly)

Search Properties Mode

Decision Tree

Property Dependencies Deep Dive

displayOptions Mechanism

Common Dependency Patterns

Pattern 1: Boolean Toggle

Pattern 2: Operation Switch

Pattern 3: Type Selection

Finding Property Dependencies

Common Node Patterns

Pattern 1: Resource/Operation Nodes

Pattern 2: HTTP-Based Nodes

Pattern 3: Database Nodes

Pattern 4: Conditional Logic Nodes

Operation-Specific Configuration