技術架構

Python端：subprocess模塊

使用subprocess.run()執行Node.js進程：

import subprocess

# 基本調用語法
result = subprocess.run(['node', 'script.js', 'arg1', 'arg2'], 
                       capture_output=True, text=True)

JavaScript端：process.argv參數接收

Node.js通過process.argv數組接收命令行參數：

// process.argv結構
[
  '/usr/local/bin/node',           // argv[0] - Node.js絕對路徑
  '/absolute/path/to/script.js',   // argv[1] - 腳本文件絕對路徑
  'arg1',                          // argv[2] - 第一個用户參數
  'arg2'                           // argv[3] - 第二個用户參數
]

參數獲取的兩種方法

方法1：slice(2) - 適合可變參數

var args = process.argv.slice(2);  // ['arg1', 'arg2']
var param1 = args[0];
var param2 = args[1];

// 優勢：便於遍歷處理多個參數
args.forEach((arg, index) => {
    console.log(`參數${index + 1}: ${arg}`);
});

方法2：直接索引 - 適合固定參數

var param1 = process.argv[2];  // 'arg1'
var param2 = process.argv[3];  // 'arg2'

// 優勢：代碼簡潔，性能略好

CompletedProcess返回對象詳解

subprocess.run()返回CompletedProcess對象（非元組，不能用數字索引）：

result = subprocess.run(['node', 'script.js', '10', '20'], 
                       capture_output=True, text=True)

# 對象屬性訪問
print(result.args)        # ['node', 'script.js', '10', '20'] - Python傳遞的命令（相對路徑）
print(result.returncode)  # 0(成功) 或 非0(失敗)
print(result.stdout)      # JavaScript的console.log輸出
print(result.stderr)      # JavaScript的錯誤信息

# ❌ 錯誤用法
# print(result[0])  # 報錯！不能用索引

關鍵區別對比

完整實踐示例

Python調用腳本

import subprocess

def call_js_calculator(num1, num2):
    """調用JavaScript進行計算"""
    result = subprocess.run(
        ['node', 'calculator.js', str(num1), str(num2)], 
        capture_output=True, 
        text=True
    )
    
    if result.returncode == 0:
        return result.stdout.strip()
    else:
        raise RuntimeError(f"JavaScript執行失敗: {result.stderr}")

# 使用示例
try:
    output = call_js_calculator(10, 20)
    print(f"計算結果: {output}")
except RuntimeError as e:
    print(f"錯誤: {e}")

JavaScript被調用腳本（calculator.js）

// 參數處理
var args = process.argv.slice(2);
var num1 = parseInt(args[0]);
var num2 = parseInt(args[1]);

// 業務邏輯
function calculate(a, b) {
    return a + b;
}

// 輸出結果（供Python捕獲）
var result = calculate(num1, num2);
console.log(result);  // 輸出到stdout，被Python接收

終端直接運行驗證

可行性確認

# 前提條件
node --version  # 確認Node.js已安裝

# 直接運行（在腳本目錄下）
node script.js 10 20  # ✅ 可以運行

# 其他目錄運行
node /完整路徑/script.js 10 20  # ✅ 也可以運行

常見問題排查

# 1. 檢查Node.js安裝
node --version

# 2. 檢查文件權限
ls -la script.js

# 3. 查看腳本內容
cat script.js

# 4. 測試運行
node script.js test args

數據類型處理

JavaScript端類型轉換

var args = process.argv.slice(2);

// 各種數據類型轉換
var intValue = parseInt(args[0]);        // 整數
var floatValue = parseFloat(args[1]);    // 浮點數
var stringValue = args[2];               // 字符串
var boolValue = args[3] === 'true';      // 布爾值

// 數組處理（傳遞JSON字符串）
var arrayValue = JSON.parse(args[4]);    // 解析數組

Python端數據準備

import json

# 準備不同類型的參數
params = [
    'node', 'script.js',
    '42',                          # 整數
    '3.14',                        # 浮點數
    'hello world',                 # 字符串
    'true',                        # 布爾值
    json.dumps([1, 2, 3, 4])      # 數組（JSON字符串）
]

result = subprocess.run(params, capture_output=True, text=True)

參數傳遞的重要限制 ⚠️

直接運行JS文件的問題

當使用process.argv.slice(2)獲取參數時，不能直接運行JavaScript文件，必須通過命令行傳參：

// 這種寫法在IDE中直接運行會出問題
var args = process.argv.slice(2);  // 直接運行時結果是空數組 []
var number_1 = parseInt(args[0]);  // parseInt(undefined) = NaN
var number_2 = parseInt(args[1]);  // parseInt(undefined) = NaN

console.log(number_1 + number_2);  // NaN + NaN = NaN ❌

為什麼會這樣？

// 直接運行時的 process.argv 只有兩個元素
[
  '/usr/local/bin/node',     // argv[0] - Node.js路徑
  '/path/to/script.js'       // argv[1] - 腳本路徑
  // 沒有用户參數！
]

// slice(2) 的結果是空數組
var args = process.argv.slice(2);  // [] 空數組

解決方案

方案1：添加默認值（推薦）

var args = process.argv.slice(2);
var number_1 = parseInt(args[0]) || 10;  // 默認值10
var number_2 = parseInt(args[1]) || 20;  // 默認值20

console.log(`參數1: ${number_1}`);
console.log(`參數2: ${number_2}`);
console.log(`結果: ${number_1 + number_2}`);

方案2：參數檢查

var args = process.argv.slice(2);

if (args.length < 2) {
    console.log("用法: node script.js <number1> <number2>");
    console.log("示例: node script.js 10 20");
    process.exit(1);  // 退出程序
}

var number_1 = parseInt(args[0]);
var number_2 = parseInt(args[1]);

方案3：混合模式（開發友好）

var args = process.argv.slice(2);

// 如果沒有參數，使用測試數據
if (args.length === 0) {
    console.log("⚠️  未提供參數，使用測試數據");
    var number_1 = 15;  // 測試數據
    var number_2 = 25;  // 測試數據
} else {
    var number_1 = parseInt(args[0]);
    var number_2 = parseInt(args[1]);
}

console.log(`計算: ${number_1} + ${number_2} = ${number_1 + number_2}`);

運行方式對比

✅ 正確的運行方式

# 終端命令行運行
node script.js 10 20

# Python調用
subprocess.run(['node', 'script.js', '10', '20'])

❌ 問題運行方式

# 直接運行（無參數）- 會導致NaN
node script.js

# 在IDE中直接運行 - 同樣會導致NaN
# 結果：args = [], number_1 = NaN, number_2 = NaN

健壯的參數處理模板

// 推薦的生產級寫法
function main() {
    var args = process.argv.slice(2);
    
    // 參數驗證和默認值處理
    var number_1 = args[0] ? parseInt(args[0]) : 10;
    var number_2 = args[1] ? parseInt(args[1]) : 20;
    
    // 檢查數值轉換是否成功
    if (isNaN(number_1) || isNaN(number_2)) {
        console.error("❌ 錯誤：參數必須是數字");
        console.log("📖 用法: node script.js <number1> <number2>");
        console.log("📝 示例: node script.js 10 20");
        return;
    }
    
    // 執行業務邏輯
    var result = number_1 + number_2;
    console.log(`✅ 計算結果: ${number_1} + ${number_2} = ${result}`);
    
    return result;
}

// 運行主函數
main();

最佳實踐

錯誤處理策略

def safe_js_call(script_path, *args):
    """安全的JavaScript調用封裝"""
    try:
        cmd = ['node', script_path] + [str(arg) for arg in args]
        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
        
        if result.returncode == 0:
            return {
                'success': True,
                'data': result.stdout.strip(),
                'error': None
            }
        else:
            return {
                'success': False,
                'data': None,
                'error': result.stderr
            }
    except subprocess.TimeoutExpired:
        return {
            'success': False,
            'data': None,
            'error': 'JavaScript執行超時'
        }
    except Exception as e:
        return {
            'success': False,
            'data': None,
            'error': str(e)
        }

選擇建議

• 固定參數場景：使用直接索引process.argv[2]，簡潔高效
• 可變參數場景：使用slice處理process.argv.slice(2)，便於遍歷
• 團隊協作：統一使用一種方式，保持代碼風格一致

應用價值

動態調用優勢

1. 靈活性：無需修改JavaScript源碼即可測試不同參數
2. 可重用性：同一腳本處理不同數據集
3. 便於測試：快速驗證各種輸入組合
4. 語言互補：結合Python的數據處理和JavaScript的特定功能

適用場景

• 需要調用Node.js特定庫的Python項目
• Web爬蟲中需要執行JavaScript渲染
• 數據處理中利用JavaScript的異步特性
• 微服務架構中的語言混合使用

核心要點回顧

1. Python通過subprocess.run()調用Node.js進程
2. JavaScript通過process.argv接收參數（絕對路徑）
3. CompletedProcess對象記錄調用信息（相對路徑）
4. 兩者結構相似但路徑表示不同
5. 支持終端直接運行驗證功能