同一主机同用户下Python与JavaScript进程无网络通信方案咨询

1. 共享文件（最简单实现） #

原理：Python定期将数据写入本地文件，JavaScript进程轮询读取该文件，可通过文件修改时间或数据唯一标识避免重复处理。

Python 写入代码 #

import json
import time

# 定义共享文件路径，需确保同一用户有读写权限
SHARE_FILE = "/tmp/shared_data.json"

def send_periodic_data():
    while True:
        # 构造待发送数据
        data = {"timestamp": time.time(), "content": "来自Python的定期推送"}
        # 覆盖写入文件，保证数据为最新版本
        with open(SHARE_FILE, "w") as f:
            json.dump(data, f)
        # 每隔5秒发送一次
        time.sleep(5)

if __name__ == "__main__":
    send_periodic_data()

JavaScript 读取代码（Node.js环境） #

const fs = require('fs');

const SHARE_FILE = '/tmp/shared_data.json';
let lastUpdateTime = 0;

function checkForUpdates() {
    fs.stat(SHARE_FILE, (err, stats) => {
        if (err) {
            console.error('获取文件状态失败:', err);
            setTimeout(checkForUpdates, 1000);
            return;
        }
        // 仅处理文件更新后的内容
        if (stats.mtime.getTime() > lastUpdateTime) {
            lastUpdateTime = stats.mtime.getTime();
            fs.readFile(SHARE_FILE, 'utf8', (err, rawData) => {
                if (!err) {
                    const data = JSON.parse(rawData);
                    console.log('收到数据:', data);
                }
            });
        }
        // 每秒轮询一次
        setTimeout(checkForUpdates, 1000);
    });
}

checkForUpdates();

2. 命名管道（FIFO，单向高效） #

原理：利用操作系统提供的命名管道机制，Python作为写入端，JavaScript作为读取端，数据直接通过管道传输，无需磁盘存储。

Linux/macOS 实现 #

Python 写入端

import time
import os

# 定义管道路径
FIFO_PATH = "/tmp/python_js_fifo"

# 若管道不存在则创建
if not os.path.exists(FIFO_PATH):
    os.mkfifo(FIFO_PATH)

def send_via_fifo():
    # 以写入模式打开管道
    with open(FIFO_PATH, "w") as fifo:
        while True:
            data = f"Python推送数据: {time.time()}\n"
            fifo.write(data)
            fifo.flush()  # 强制写入管道，避免缓存
            time.sleep(5)

if __name__ == "__main__":
    send_via_fifo()

JavaScript 读取端（Node.js）

const fs = require('fs');

const FIFO_PATH = '/tmp/python_js_fifo';

// 以流模式读取管道内容
const fifoStream = fs.createReadStream(FIFO_PATH);

fifoStream.on('data', (chunk) => {
    const content = chunk.toString().trim();
    console.log('从管道收到:', content);
});

fifoStream.on('error', (err) => {
    console.error('管道读取错误:', err);
});

Windows 实现 #

只需将管道路径改为\\.\pipe\python_js_fifo，代码逻辑与上述一致。

3. 共享内存（大数据量场景首选） #

原理：两个进程直接访问同一块内存区域，无需中间存储，传输效率最高。

Python 写入代码（使用mmap模块） #

import mmap
import time
import json

SHARE_MEM_FILE = "/tmp/shared_memory"
MEM_SIZE = 4096  # 定义共享内存大小（4KB）

# 初始化共享内存文件
with open(SHARE_MEM_FILE, "wb") as f:
    f.write(b'\x00' * MEM_SIZE)

def send_via_shared_mem():
    with open(SHARE_MEM_FILE, "r+b") as f:
        # 映射内存区域
        mm = mmap.mmap(f.fileno(), MEM_SIZE, access=mmap.ACCESS_WRITE)
        while True:
            data = json.dumps({"time": time.time(), "msg": "共享内存数据"}).encode('utf8')
            # 清空内存区域
            mm.seek(0)
            mm.write(b'\x00' * MEM_SIZE)
            # 写入新数据
            mm.seek(0)
            mm.write(data)
            mm.flush()
            time.sleep(5)

if __name__ == "__main__":
    send_via_shared_mem()

JavaScript 读取代码（Node.js 使用mmap-io包） #

先安装依赖：npm install mmap-io

const mmap = require('mmap-io');
const fs = require('fs');

const SHARE_MEM_FILE = '/tmp/shared_memory';
const MEM_SIZE = 4096;

const fd = fs.openSync(SHARE_MEM_FILE, 'r+');
const buffer = mmap.map(MEM_SIZE, mmap.PROT_READ, mmap.MAP_SHARED, fd);

function readSharedMem() {
    // 读取内存直到遇到空字符
    let content = '';
    for (let i = 0; i < MEM_SIZE; i++) {
        if (buffer[i] === 0) break;
        content += String.fromCharCode(buffer[i]);
    }
    if (content) {
        const data = JSON.parse(content);
        console.log('共享内存收到:', data);
    }
    setTimeout(readSharedMem, 1000);
}

readSharedMem();

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