ClashX advanced tips - ClashX | बेहतर उपयोग गाइड

परिचय: उन्नत सुझावों का अवलोकन

ClashX के बुनियादी उपयोग में महारत हासिल करने के बाद अगला कदम यह सीखना है कि इस शक्तिशाली टूल की क्षमता का पूरा उपयोग कैसे किया जाए। उन्नत तकनीकें न केवल प्रॉक्सी प्रदर्शन बेहतर बनाती हैं, बल्कि अधिक लचीले और बुद्धिमान नेटवर्क रूटिंग समाधान भी तैयार करती हैं।

यह लेख व्यवस्थित रूप से ClashX के उन्नत उपयोग के तरीके प्रस्तुत करता है, जिनमें स्मार्ट रूटिंग, ऑटोमेशन स्क्रिप्ट्स, प्रदर्शन ट्यूनिंग, नियम अनुकूलन और अन्य पेशेवर तकनीकें शामिल हैं। ये सुझाव उन उन्नत उपयोगकर्ताओं के लिए उपयुक्त हैं जिन्हें पहले से ClashX के उपयोग का कुछ अनुभव है।

💡

उन्नत उपयोगकर्ताओं के लिए अनिवार्य पठन

इन तकनीकों में महारत हासिल करने के बाद आप पूरी तरह अनुकूलित प्रॉक्सी समाधान बना सकेंगे, नेटवर्क प्रदर्शन सुधार सकेंगे और विभिन्न जटिल नेटवर्क परिदृश्यों को संभाल सकेंगे।

स्मार्ट रूटिंग रणनीतियाँ

स्मार्ट रूटिंग का मूल यह है कि अलग-अलग ट्रैफ़िक विशेषताओं (डोमेन नाम, IP, भौगोलिक स्थान आदि) के आधार पर ट्रैफ़िक को अलग-अलग प्रॉक्सी नोड या direct connection पर भेजा जाए। इससे प्रदर्शन बेहतर होता है, latency कम होती है और क्षेत्रीय प्रतिबंधों को पार किया जा सकता है।

जटिल डोमेन-आधारित रूटिंग

रूटिंग

rules:
  # 第一级：白名单直连（最高优先级）
  - DOMAIN,localhost,DIRECT
  - DOMAIN-SUFFIX,local,DIRECT
  - DOMAIN-SUFFIX,lan,DIRECT

  # 第二级：国内服务直连
  - DOMAIN-SUFFIX,alipay.com,DIRECT
  - DOMAIN-SUFFIX,baidu.com,DIRECT
  - DOMAIN-SUFFIX,taobao.com,DIRECT
  - DOMAIN-SUFFIX,qq.com,DIRECT

  # 第三级：国外流媒体
  - DOMAIN-SUFFIX,netflix.com,🎬 流媒体
  - DOMAIN-SUFFIX,youtube.com,🎬 流媒体
  - DOMAIN-SUFFIX,twitch.tv,🎬 流媒体
  - DOMAIN-KEYWORD,spotify,🎬 流媒体

  # 第四级：游戏加速
  - DOMAIN-SUFFIX,epicgames.com,🎮 游戏加速
  - DOMAIN-SUFFIX,steampowered.com,🎮 游戏加速

  # 第五级：特殊应用
  - DOMAIN-SUFFIX,telegram.org,💬 即时通讯
  - DOMAIN-SUFFIX,whatsapp.com,💬 即时通讯

  # 最终规则
  - GEOIP,CN,DIRECT
  - MATCH,🚀 智能选择

सूक्ष्म IP-आधारित रूटिंग

IP CIDR नियम

rules:
  # 优先级最高：局域网 IP 直连
  - IP-CIDR,192.168.0.0/16,DIRECT,no-resolve
  - IP-CIDR,10.0.0.0/8,DIRECT,no-resolve
  - IP-CIDR,172.16.0.0/12,DIRECT,no-resolve
  - IP-CIDR,127.0.0.0/8,DIRECT,no-resolve

  # 中国 IP 直连
  - IP-CIDR,1.0.1.0/24,DIRECT,no-resolve
  - IP-CIDR,1.1.1.0/24,DIRECT,no-resolve

  # 特定 IP 段代理
  - IP-CIDR,8.8.8.0/24,🚀 智能选择,no-resolve
  - IP-CIDR,1.1.1.0/24,🚀 智能选择,no-resolve

  # 最终规则
  - MATCH,🚀 智能选择

GeoIP-आधारित भौगोलिक रूटिंग

GeoIP नियम

rules:
  # 中国 IP 直连
  - GEOIP,CN,DIRECT

  # 美国流量用美国节点
  - GEOIP,US,🇺🇸 美国节点

  # 日本流量用日本节点
  - GEOIP,JP,🇯🇵 日本节点

  # 欧洲流量用欧洲节点
  - GEOIP,DE,🇩🇪 欧洲节点
  - GEOIP,FR,🇫🇷 欧洲节点
  - GEOIP,GB,🇬🇧 欧洲节点

  # 默认代理
  - MATCH,🚀 智能选择

⚠️

रूटिंग नियम

Rule का सही क्रम बहुत महत्वपूर्ण है। पहले विशिष्ट Rule रखें, फिर सामान्य Rule। गलत Rule क्रम से routing error हो सकते हैं।

उन्नत पॉलिसी ग्रुप कॉन्फ़िगरेशन

पॉलिसी ग्रुप न केवल नोड्स को संयोजित करते हैं, बल्कि जटिल ट्रैफ़िक नियंत्रण और स्वचालित चयन लॉजिक भी लागू करते हैं। उन्नत पॉलिसी ग्रुप कॉन्फ़िगरेशन में महारत प्रॉक्सी प्रदर्शन को अनुकूलित करने की कुंजी है।

उन्नत Fallback उपयोग

article14.advanced-groups.auto.h3_1

proxy-groups:
  # 主节点层：自动测速
  - name: "🇭🇰 香港主节点"
    type: url-test
    proxies:
      - "HK-001"
      - "HK-002"
      - "HK-003"
    url: "http://www.gstatic.com/generate_204"
    interval: 300
    tolerance: 50

  # 故障转移层：监测主节点的健康状态
  - name: "🚀 智能选择"
    type: fallback
    proxies:
      - "🇭🇰 香港主节点"
      - "🇯🇵 日本备用节点"
      - "🇸🇬 新加坡备用节点"
      - "DIRECT"
    url: "http://www.gstatic.com/generate_204"
    interval: 300

Load Balance अनुकूलन

article14.advanced-groups.auto.h3_2

proxy-groups:
  # 一致性哈希负载均衡：同一连接使用同一节点
  - name: "⚖️ 一致性哈希"
    type: load-balance
    proxies:
      - "HK-001"
      - "HK-002"
      - "HK-003"
      - "JP-001"
      - "JP-002"
    url: "http://www.gstatic.com/generate_204"
    interval: 300
    strategy: consistent-hashing

  # 轮询负载均衡：依次切换节点
  - name: "⚖️ 轮询"
    type: load-balance
    proxies:
      - "HK-001"
      - "HK-002"
      - "HK-003"
    url: "http://www.gstatic.com/generate_204"
    interval: 300
    strategy: round-robin

URL Test पैरामीटर ट्यूनिंग

article14.advanced-groups.auto.h3_3

proxy-groups:
  # 链式代理：流量经过两个代理节点
  - name: "🔗 双层加密"
    type: relay
    proxies:
      - "HK-001"
      - "JP-001"

  # 应用场景：高风险网络环境下使用链式代理
  - name: "🔐 超级安全"
    type: relay
    proxies:
      - "HK-001"
      - "SG-001"
      - "JP-001"

rules:
  - DOMAIN-SUFFIX,sensitive.com,🔗 双层加密

Relay Chain प्रॉक्सी

policy groups

proxy-groups:
  # 区域节点组
  - name: "🇭🇰 香港"
    type: url-test
    proxies:
      - "HK-001"
      - "HK-002"
      - "HK-003"
    url: "http://www.gstatic.com/generate_204"
    interval: 300

  - name: "🇯🇵 日本"
    type: url-test
    proxies:
      - "JP-001"
      - "JP-002"
    url: "http://www.gstatic.com/generate_204"
    interval: 300

  # 目的组（流媒体、游戏等）
  - name: "🎬 流媒体"
    type: select
    proxies:
      - "🇭🇰 香港"
      - "🇯🇵 日本"
      - "🇺🇸 美国"

  # 总选择组
  - name: "🚀 总选择"
    type: select
    proxies:
      - "🎬 流媒体"
      - "🇭🇰 香港"
      - "🇯🇵 日本"
      - "DIRECT"

ऑटोमेशन और स्क्रिप्ट्स

ऑटोमेशन स्क्रिप्ट्स के माध्यम से आप कॉन्फ़िगरेशन स्वचालित रूप से बदल सकते हैं, सदस्यताएँ अपडेट कर सकते हैं और रखरखाव कार्य चला सकते हैं, जिससे उपयोग दक्षता बहुत बढ़ जाती है।

स्वचालित कॉन्फ़िगरेशन स्विचिंग

article14.automation.auto.h3_1

#!/bin/bash

# ClashX 配置备份和恢复脚本

CLASH_CONFIG_DIR="$HOME/.config/clash"
BACKUP_DIR="$HOME/.clash_backup"
BACKUP_DATE=$(date +%Y%m%d_%H%M%S)

# 创建备份
backup_config() {
    mkdir -p "$BACKUP_DIR"
    cp "$CLASH_CONFIG_DIR/config.yaml" "$BACKUP_DIR/config_$BACKUP_DATE.yaml"
    echo "配置已备份到: $BACKUP_DIR/config_$BACKUP_DATE.yaml"
}

# 恢复配置
restore_config() {
    local latest_backup=$(ls -t "$BACKUP_DIR"/config_*.yaml | head -1)
    if [ -z "$latest_backup" ]; then
        echo "未找到备份文件"
        return 1
    fi
    cp "$latest_backup" "$CLASH_CONFIG_DIR/config.yaml"
    echo "配置已恢复"
}

# 重新加载配置
reload_config() {
    curl -X PUT http://127.0.0.1:9090/configs -H "Content-Type: application/json" \
        -d "{\"path\": \"$CLASH_CONFIG_DIR/config.yaml\"}"
    echo "配置已重新加载"
}

case "$1" in
    backup) backup_config ;;
    restore) restore_config ;;
    reload) reload_config ;;
    *) echo "用法: $0 {backup|restore|reload}" ;;
esac

निर्धारित कार्य ऑटोमेशन

                                Cron
                                #!/bin/bash

# 定时更新 ClashX 规则提供者

CLASH_HOME="$HOME/.config/clash"
API_URL="http://127.0.0.1:9090"
SECRET="your-secret-key"

# 更新规则提供者
update_rule_providers() {
    local providers=("reject" "proxy" "direct" "streaming")

    for provider in "${providers[@]}"; do
        echo "更新规则提供者: $provider"
        curl -X PUT "$API_URL/providers/rules/$provider" \
            -H "Authorization: Bearer $SECRET"
        sleep 2
    done

    echo "所有规则提供者已更新"
}

# 检查 ClashX 状态
check_clash_status() {
    local response=$(curl -s -w "\n%{http_code}" "$API_URL/version")
    local http_code=$(echo "$response" | tail -n 1)

    if [ "$http_code" == "200" ]; then
        echo "ClashX 运行正常"
        return 0
    else
        echo "ClashX 状态异常，尝试重启"
        killall -9 ClashX 2>/dev/null || true
        sleep 2
        open /Applications/ClashX.app
        return 1
    fi
}

# 主函数
main() {
    check_clash_status
    if [ $? -eq 0 ]; then
        update_rule_providers
    fi
}

main
                            

💡

Crontab

crontab उदाहरण: crontab -e 2 Rule: 0 2 * * * /path/to/update-rules.sh : 0 * * * * /path/to/check-status.sh

सदस्यता अपडेट ऑटोमेशन

Python API

#!/usr/bin/env python3

import requests
import json
import yaml
from datetime import datetime

class ClashXManager:
    def __init__(self, api_url="http://127.0.0.1:9090", secret=None):
        self.api_url = api_url
        self.headers = {}
        if secret:
            self.headers["Authorization"] = f"Bearer {secret}"

    def get_proxies(self):
        """获取所有代理节点"""
        response = requests.get(f"{self.api_url}/proxies", headers=self.headers)
        return response.json() if response.status_code == 200 else None

    def get_traffic_stats(self):
        """获取流量统计"""
        response = requests.get(f"{self.api_url}/traffic", headers=self.headers)
        return response.json() if response.status_code == 200 else None

    def test_proxy_speed(self, proxy_name, url="http://www.gstatic.com/generate_204"):
        """测试代理速度"""
        test_url = f"{self.api_url}/proxies/{proxy_name}/delay?url={url}"
        response = requests.get(test_url, headers=self.headers)
        return response.json() if response.status_code == 200 else None

    def switch_proxy(self, group_name, proxy_name):
        """切换策略组使用的代理"""
        data = json.dumps({"name": proxy_name})
        response = requests.put(
            f"{self.api_url}/proxies/{group_name}",
            data=data,
            headers={**self.headers, "Content-Type": "application/json"}
        )
        return response.status_code == 204

    def get_logs(self, level="info"):
        """获取日志"""
        response = requests.get(f"{self.api_url}/logs?level={level}", headers=self.headers)
        return response.json() if response.status_code == 200 else None

    def batch_test_proxies(self, proxy_names):
        """批量测试代理速度"""
        results = {}
        for proxy in proxy_names:
            result = self.test_proxy_speed(proxy)
            if result:
                results[proxy] = result.get("delay", -1)
        return results

# 使用示例
if __name__ == "__main__":
    manager = ClashXManager(secret="your-secret-key")

    # 获取代理信息
    proxies = manager.get_proxies()
    if proxies:
        print(json.dumps(proxies, indent=2, ensure_ascii=False))

    # 获取流量统计
    stats = manager.get_traffic_stats()
    print(f"上行: {stats['up']} B/s, 下行: {stats['down']} B/s")

    # 批量测试代理
    proxy_names = ["HK-001", "JP-001", "US-001"]
    speeds = manager.batch_test_proxies(proxy_names)
    print("代理速度测试结果:")
    for proxy, speed in sorted(speeds.items(), key=lambda x: x[1]):
        print(f"  {proxy}: {speed}ms")

प्रदर्शन अनुकूलन सुझाव

बुनियादी कॉन्फ़िगरेशन से आगे भी कई तकनीकें हैं जो ClashX के प्रदर्शन को और बेहतर बना सकती हैं और संसाधन उपयोग कम कर सकती हैं।

DNS resolution अनुकूलन

performance DNS configuration

dns:
  enable: true
  listen: 0.0.0.0:53
  enhanced-mode: fake-ip  # 性能更优，但兼容性略低

  # Fake-IP 地址池配置
  fake-ip-range: 198.18.0.1/16

  # 使用 Fake-IP 时应该排除的域名
  fake-ip-filter:
    - "*.lan"
    - "*.local"
    - "*.internal"
    - localhost.ptlogin2.qq.com
    - "*.qq.com"
    - "*.tencent.com"

  # 主 DNS 服务器（国内解析快速）
  nameserver:
    - 119.29.29.29  # DNSPod 国内
    - 223.5.5.5     # 阿里 DNS 国内
    - https://doh.pub/dns-query  # DoH 协议更安全

  # 回落 DNS（当主 DNS 失败时使用）
  fallback:
    - https://1.1.1.1/dns-query    # Cloudflare DoH
    - https://dns.google/dns-query  # Google DoH
    - https://9.9.9.9/dns-query     # Quad9 DoH

  # 域名策略性 DNS 选择（关键优化点）
  nameserver-policy:
    # 国内域名使用国内 DNS
    "geosite:cn":
      - 119.29.29.29
      - 223.5.5.5

    # 国外域名使用国外 DNS
    "geosite:geolocation-!cn":
      - https://1.1.1.1/dns-query
      - https://dns.google/dns-query

    # 特定域名的 DNS
    "domain:example.com":
      - 119.29.29.29

    "domain:google.com":
      - https://8.8.8.8/dns-query

कनेक्शन अनुकूलन

                                article14.performance.auto.h3_2
                                general:
  # 出站接口
  interface-name: en0

  # TCP 连接池大小
  tcp-concurrent: true

  # UDP 连接超时（毫秒）
  udp-timeout: 300

  # 连接空闲超时时间
  keep-alive-interval: 15

  # SOCKS5 UDP 支持
  socks-version: 5

# 高级性能调优参数
experimental:
  # 启用接口检测
  interface-name: en0

  # 忽略解析失败的域名（减少重试）
  ignore-resolve-fail: true
                            

संसाधन उपयोग अनुकूलन

Rule performance

规则类型性能对比（从快到慢）：
1. IP-CIDR/IP6-CIDR（最快，O(1) 查询）
   时间: ~0.1ms

2. DOMAIN-SUFFIX（快速，前缀树查询）
   时间: ~0.2-0.5ms

3. DOMAIN（中等，精确匹配）
   时间: ~0.3-0.8ms

4. DOMAIN-KEYWORD（较慢，包含匹配）
   时间: ~1-2ms

5. GEOIP（较慢，需要 IP 库查询）
   时间: ~2-5ms

6. RULE-SET（取决于规则集大小）
   时间: ~0.5-5ms

💡

performance optimization

• IP-CIDR Rule को प्राथमिकता दें， GEOIP बाद में रखें • कम Rule रखें • Rule का क्रम अनुकूलित करें • Rule providers का उपयोग करें

नियम अनुकूलन और रखरखाव

अच्छी तरह व्यवस्थित और अनुरक्षित नियम ClashX की दीर्घकालिक स्थिरता सुनिश्चित करने की कुंजी हैं। यहाँ पेशेवर नियम प्रबंधन तकनीकें दी गई हैं।

Rule Providers का उपयोग

Rule

rule-providers:
  # 广告拦截规则
  reject:
    type: http
    behavior: domain
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/reject.txt"
    path: ./ruleset/reject.yaml
    interval: 86400  # 24小时更新一次

  # 代理规则
  proxy:
    type: http
    behavior: domain
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/proxy.txt"
    path: ./ruleset/proxy.yaml
    interval: 86400

  # 直连规则
  direct:
    type: http
    behavior: domain
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/direct.txt"
    path: ./ruleset/direct.yaml
    interval: 86400

  # 流媒体规则
  streaming:
    type: http
    behavior: domain
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/streaming.txt"
    path: ./ruleset/streaming.yaml
    interval: 86400

  # Apple 规则
  apple:
    type: http
    behavior: domain
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/apple.txt"
    path: ./ruleset/apple.yaml
    interval: 86400

  # Google 规则
  google:
    type: http
    behavior: domain
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/google.txt"
    path: ./ruleset/google.yaml
    interval: 86400

  # 国内 IP 规则
  cncidr:
    type: http
    behavior: ip
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/cncidr.txt"
    path: ./ruleset/cncidr.yaml
    interval: 86400

  # 国外 IP 规则
  lancidr:
    type: http
    behavior: ip
    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/lancidr.txt"
    path: ./ruleset/lancidr.yaml
    interval: 86400

# 使用规则提供者
rules:
  # 局域网直连
  - RULE-SET,lancidr,DIRECT

  # 广告拦截
  - RULE-SET,reject,REJECT

  # 直连规则
  - RULE-SET,direct,DIRECT

  # 流媒体
  - RULE-SET,streaming,🎬 流媒体

  # Apple
  - RULE-SET,apple,🍎 Apple 服务

  # Google
  - RULE-SET,google,🔍 Google 服务

  # 国内 IP
  - RULE-SET,cncidr,DIRECT

  # 代理规则
  - RULE-SET,proxy,🚀 智能选择

  # 最终规则
  - MATCH,🚀 智能选择

नियम रखरखाव की सर्वोत्तम प्रथाएँ

                                Rule
                                #!/usr/bin/env python3

import requests
import yaml
from pathlib import Path

class RuleManager:
    """动态规则管理工具"""

    def __init__(self, config_path):
        self.config_path = Path(config_path)
        self.config = self._load_config()

    def _load_config(self):
        """加载配置文件"""
        with open(self.config_path, 'r', encoding='utf-8') as f:
            return yaml.safe_load(f)

    def _save_config(self):
        """保存配置文件"""
        with open(self.config_path, 'w', encoding='utf-8') as f:
            yaml.dump(self.config, f, allow_unicode=True, default_flow_style=False)

    def add_rule(self, rule_text, position=None):
        """添加新规则"""
        if 'rules' not in self.config:
            self.config['rules'] = []

        if position is None:
            # 在末尾添加（MATCH 规则前）
            position = len(self.config['rules']) - 1

        self.config['rules'].insert(position, rule_text)
        self._save_config()
        print(f"规则已添加: {rule_text}")

    def remove_rule(self, keyword):
        """根据关键字移除规则"""
        if 'rules' not in self.config:
            return

        original_count = len(self.config['rules'])
        self.config['rules'] = [
            r for r in self.config['rules']
            if keyword not in r
        ]
        removed_count = original_count - len(self.config['rules'])
        self._save_config()
        print(f"已移除 {removed_count} 条规则")

    def update_rule_provider(self, provider_name, new_url):
        """更新规则提供者 URL"""
        if 'rule-providers' not in self.config:
            self.config['rule-providers'] = {}

        if provider_name in self.config['rule-providers']:
            self.config['rule-providers'][provider_name]['url'] = new_url
            self._save_config()
            print(f"规则提供者 {provider_name} 已更新")
        else:
            print(f"规则提供者 {provider_name} 不存在")

    def list_rules(self, limit=20):
        """列出规则"""
        if 'rules' not in self.config:
            return

        rules = self.config['rules'][-limit:]
        for i, rule in enumerate(rules, 1):
            print(f"{i}. {rule}")

# 使用示例
manager = RuleManager(Path.home() / '.config/clash/config.yaml')

# 添加新规则
manager.add_rule("DOMAIN-SUFFIX,example.com,DIRECT")

# 列出规则
manager.list_rules(10)

# 更新规则提供者
manager.update_rule_provider("proxy", "https://new-url.com/proxy.yaml")
                            

व्यावहारिक परिदृश्य कॉन्फ़िगरेशन

अलग-अलग उपयोग परिदृश्यों के आधार पर यहाँ कुछ पूर्ण कॉन्फ़िगरेशन समाधान दिए गए हैं जिन्हें आप सीधे संदर्भित कर सकते हैं और उपयोग कर सकते हैं।

Development environment कॉन्फ़िगरेशन

                                article14.scenarios.auto.h3_1
                                proxy-groups:
  # 流媒体专用策略组
  - name: "🎬 流媒体"
    type: select
    proxies:
      - "🇭🇰 香港节点"  # 节目丰富
      - "🇯🇵 日本节点"  # 低延迟
      - "🇺🇸 美国节点"  # 最新内容
      - DIRECT

  # Netflix 专用
  - name: "🍿 Netflix"
    type: url-test
    proxies:
      - "HK-Netflix-01"
      - "US-Netflix-01"
    url: "https://www.netflix.com/nrdp/v6/www/user"
    interval: 300
    tolerance: 100

rules:
  # 流媒体平台分流
  - DOMAIN-SUFFIX,netflix.com,🍿 Netflix
  - DOMAIN-SUFFIX,nflxso.net,🍿 Netflix
  - DOMAIN-SUFFIX,youtube.com,🎬 流媒体
  - DOMAIN-SUFFIX,youtu.be,🎬 流媒体
  - DOMAIN-SUFFIX,hulu.com,🎬 流媒体
  - DOMAIN-SUFFIX,disneyplus.com,🎬 流媒体
  - DOMAIN-KEYWORD,spotify,🎬 流媒体
                            

Gaming अनुकूलन कॉन्फ़िगरेशन

                                games
                                proxy-groups:
  # 游戏加速组：低延迟优先
  - name: "🎮 游戏加速"
    type: url-test
    proxies:
      - "HK-Game-01"
      - "SG-Game-01"
      - "JP-Game-01"
    url: "http://www.gstatic.com/generate_204"
    interval: 300
    tolerance: 30  # 游戏对延迟敏感，容差设置小

rules:
  # Steam
  - DOMAIN-SUFFIX,steampowered.com,🎮 游戏加速
  - DOMAIN-SUFFIX,steamcommunity.com,🎮 游戏加速

  # Epic Games
  - DOMAIN-SUFFIX,epicgames.com,🎮 游戏加速
  - DOMAIN-SUFFIX,unrealengine.com,🎮 游戏加速

  # 其他游戏平台
  - DOMAIN-SUFFIX,battlenet.com,🎮 游戏加速
  - DOMAIN-SUFFIX,playstation.com,🎮 游戏加速
                            

Streaming media अनुकूलन

                                article14.scenarios.auto.h3_3
                                proxy-groups:
  # 下载专用：带宽优先
  - name: "📥 下载加速"
    type: load-balance
    proxies:
      - "HK-Download-01"
      - "HK-Download-02"
      - "US-Download-01"
    url: "http://www.gstatic.com/generate_204"
    interval: 300
    strategy: round-robin  # 轮询实现负载均衡

rules:
  # 常见下载站点
  - DOMAIN-SUFFIX,github.com,📥 下载加速
  - DOMAIN-SUFFIX,githubusercontent.com,📥 下载加速
  - DOMAIN-SUFFIX,releases.ubuntu.com,📥 下载加速
                            

उन्नत सुविधाओं की पड़ताल

ClashX में कई छिपी हुई उन्नत सुविधाएँ हैं, जिनका सही उपयोग अप्रत्याशित सुविधा ला सकता है।

External Control API

                                TUN mode
                                tun:
  enable: true
  stack: system  # 或 gvisor（性能更好但兼容性略低）

  # DNS 劫持
  dns-hijack:
    - any:53
    - tcp://any:53

  # 自动路由
  auto-route: true

  # 自动检测接口
  auto-detect-interface: true

  # 指定特定网卡（可选）
  interface-name: en0

  # MTU 大小优化
  mtu: 9000
                            

TUN mode के उन्नत अनुप्रयोग

                                API
                                #!/usr/bin/env python3

import requests
import json
import asyncio
from datetime import datetime

class ClashXDashboard:
    """ClashX Dashboard API 高级应用"""

    def __init__(self, base_url="http://127.0.0.1:9090", secret=None):
        self.base_url = base_url
        self.headers = {"Content-Type": "application/json"}
        if secret:
            self.headers["Authorization"] = f"Bearer {secret}"

    def get_system_info(self):
        """获取系统信息"""
        response = requests.get(f"{self.base_url}/version", headers=self.headers)
        return response.json() if response.status_code == 200 else None

    def get_connections(self):
        """获取当前连接"""
        response = requests.get(f"{self.base_url}/connections", headers=self.headers)
        return response.json() if response.status_code == 200 else None

    def get_traffic_stats(self):
        """获取流量统计"""
        response = requests.get(f"{self.base_url}/traffic", headers=self.headers)
        if response.status_code == 200:
            data = response.json()
            return {
                "upload": data["up"],
                "download": data["down"],
                "timestamp": datetime.now()
            }
        return None

    def change_mode(self, mode):
        """切换模式: rule, global, direct"""
        valid_modes = ["rule", "global", "direct"]
        if mode not in valid_modes:
            return False

        data = json.dumps({"mode": mode})
        response = requests.put(
            f"{self.base_url}/configs",
            data=data,
            headers=self.headers
        )
        return response.status_code == 200

    def get_rules_info(self):
        """获取规则信息"""
        response = requests.get(f"{self.base_url}/rules", headers=self.headers)
        return response.json() if response.status_code == 200 else None

    def test_url_latency(self, url, timeout=5000):
        """测试 URL 延迟"""
        response = requests.get(
            f"{self.base_url}/configs/latency?url={url}&timeout={timeout}",
            headers=self.headers
        )
        return response.json() if response.status_code == 200 else None

    def get_proxy_latency(self, proxy_name, url="http://www.gstatic.com/generate_204"):
        """测试单个代理延迟"""
        response = requests.get(
            f"{self.base_url}/proxies/{proxy_name}/delay?url={url}",
            headers=self.headers
        )
        return response.json() if response.status_code == 200 else None

# 使用示例：实时流量监控
async def monitor_traffic():
    dashboard = ClashXDashboard(secret="your-secret")

    print("开始监控流量...")
    while True:
        stats = dashboard.get_traffic_stats()
        if stats:
            print(f"[{stats['timestamp']}] 上行: {stats['upload']:.2f} B/s, "
                  f"下行: {stats['download']:.2f} B/s")
        await asyncio.sleep(2)

# 运行监控
# asyncio.run(monitor_traffic())
                            

कस्टम rule sets

                                article14.advanced-features.auto.h3_3
                                general:
  # 启用外部控制器
  external-controller: 0.0.0.0:9090

  # API 访问密钥（强烈建议设置）
  secret: "your-very-secure-secret-key-here"

  # CORS 支持
  external-ui: true

  # 外部 UI 路径
  external-ui-url: "https://clash.razord.top/"
                            

⚠️

article14.advanced-features.auto.strong1

• API एक्सेस • ClashX API एकीकरण • ClashX नियंत्रण • API ऑटोमेशन

performance

DNS 优化前

DNS 查询: 80ms

DNS 优化后

DNS 查询: 15ms

规则优化前

平均延迟: 120ms

规则优化后

平均延迟: 45ms

                            ClashX
                            Rule: Rule > Rule रखें，विशिष्ट Rule को पहले रखें
DNS configuration: Fake-IP performance बेहतर कर सकता है， nameserver-policy का उपयोग करें
policy groups: उचित चयन और स्वचालित स्विचिंग सेट करें
Rule: Rule और Rule providers को नियमित रूप से अपडेट करें，
performance: CPU और memory usage की निगरानी करें，Rule providers को अनुकूलित करें
: लॉग की जाँच करें，समस्या का विश्लेषण करें
: API को सुरक्षित रखें，अनधिकृत एक्सेस से बचें

                        

常见问题与解决方案

Q: Rule से routing error क्यों होता है？

A: Rule का क्रम या मिलान शर्तें गलत हो सकती हैं। DEBUG लॉग देखें और Rule मिलान की जाँच करें।

Q: कनेक्शन क्यों विफल होता है？

A: TUN mode, system proxy और DNS सेटिंग्स की जाँच करें； Fake-IP सक्षम करें；Rule रूटिंग सत्यापित करें।

Q: ClashX का CPU उपयोग अधिक है？

A: DNS configuration को अनुकूलित करें， GeoIP Rule का उपयोग करें；Rule providers सक्षम करें；अनावश्यक Rule कम करें।

क्या यह लेख सहायक था?

✓ ✓ आपकी प्रतिक्रिया के लिए धन्यवाद!

टैग: ClashX एडवांस्ड performance optimization article14.sec.auto.span2 article14.sec.auto.span3

परिचय: उन्नत सुझावों का अवलोकन

स्मार्ट रूटिंग रणनीतियाँ

जटिल डोमेन-आधारित रूटिंग

रूटिंग

सूक्ष्म IP-आधारित रूटिंग

IP CIDR नियम

GeoIP-आधारित भौगोलिक रूटिंग

GeoIP नियम

उन्नत पॉलिसी ग्रुप कॉन्फ़िगरेशन

उन्नत Fallback उपयोग

article14.advanced-groups.auto.h3_1

Load Balance अनुकूलन

article14.advanced-groups.auto.h3_2

URL Test पैरामीटर ट्यूनिंग

article14.advanced-groups.auto.h3_3

Relay Chain प्रॉक्सी

policy groups

ऑटोमेशन और स्क्रिप्ट्स

स्वचालित कॉन्फ़िगरेशन स्विचिंग

article14.automation.auto.h3_1

निर्धारित कार्य ऑटोमेशन

Cron

सदस्यता अपडेट ऑटोमेशन

Python API

प्रदर्शन अनुकूलन सुझाव

DNS resolution अनुकूलन

performance DNS configuration

कनेक्शन अनुकूलन

article14.performance.auto.h3_2

संसाधन उपयोग अनुकूलन

Rule performance

नियम अनुकूलन और रखरखाव

Rule Providers का उपयोग

Rule

नियम रखरखाव की सर्वोत्तम प्रथाएँ

Rule

व्यावहारिक परिदृश्य कॉन्फ़िगरेशन

Development environment कॉन्फ़िगरेशन

article14.scenarios.auto.h3_1

Gaming अनुकूलन कॉन्फ़िगरेशन

games

Streaming media अनुकूलन

article14.scenarios.auto.h3_3

उन्नत सुविधाओं की पड़ताल

External Control API

TUN mode

TUN mode के उन्नत अनुप्रयोग

API

कस्टम rule sets

article14.advanced-features.auto.h3_3

performance

ClashX

常见问题与解决方案

क्या यह लेख सहायक था?

संबंधित लेख

ClashX कॉन्फ़िगरेशन फ़ाइलों की संपूर्ण गाइड

ClashX नियम लिखने की पूरी गाइड

उन्नत ClashX कॉन्फ़िगरेशन सुझाव