利用ReadableStream.getReader实现前端动态流式渲染与中断控制

前端使用ReadableStream.getReader来处理流式渲染 阅读详情

1. 从“等全部”到“来一点”:为什么我们需要流式渲染?

不知道你有没有遇到过这种场景:你打开一个网页,页面中间有个大大的加载圈,转啊转,转了十几秒,内容才“唰”的一下全部显示出来。或者,你在使用一些AI对话工具,问了一个复杂的问题,然后你就盯着光标,等了半天,它才把一整段答案吐给你。这种体验,说实话,挺糟糕的。用户会焦虑,会怀疑是不是卡住了,甚至可能直接关掉页面。

这就是传统“一次性请求-一次性渲染”模式的痛点。前端一次性从后端拿到所有数据,然后一次性渲染到页面上。数据量小还好,一旦数据量大,或者生成速度慢(比如大语言模型生成长文本、实时日志流),用户就只能干等着。

而流式渲染,就是为了解决这个“等待焦虑”而生的。它的核心思想很简单:别等饭全做好了再上菜,厨师炒好一个菜,你就先吃一个。对应到技术上,就是服务器一边生成数据,一边通过网络流(Stream)一点点地发送给浏览器;浏览器收到一点,就解析一点,渲染一点。用户几乎在请求发出去的同时,就能看到内容开始“生长”出来。

这种体验的提升是巨大的。对于内容生成类应用(如AI写作、代码补全),用户能看到思考过程,更有掌控感;对于监控类应用(如服务器日志、实时数据看板),信息能近乎实时地更新,决策更及时。

那么,在前端,我们用什么技术来接住服务器“涓涓细流”般的数据呢?答案就是 ReadableStream API,而 getReader() 方法,就是我们握住这根“水管”,开始接水的关键动作。它能让我们以异步、非阻塞的方式,一块一块地读取流中的数据,并随时可以关上水龙头——这就是“中断控制”。接下来,我就带你一步步拆解,如何用这个强大的API,打造流畅可控的流式渲染体验。

2. 核心武器拆解:读懂ReadableStream与getReader

在动手写代码之前,我们得先搞清楚手里的工具到底是怎么回事。很多人一上来就复制代码,结果遇到问题一头雾水。我把我的理解掰开揉碎了讲给你听,保证你能听懂。

2.1 ReadableStream:它到底是什么?

你可以把 ReadableStream 想象成一条传送带。这条传送带连接了服务器和你的浏览器。服务器那边,有一个“生产者”在不断把数据块(比如一段文本、一行日志)放到传送带起点;浏览器这边,你这个“消费者”就站在传送带终点,准备把过来的数据块拿走处理。

这条传送带有几个关键特性:

  1. 异步的:数据什么时候来,来多少,你不知道,也不用一直等着。你只需要告诉传送带:“有货来了就叫我”。
  2. 有序的:数据块按照服务器放上去的顺序依次到达,不会乱序。
  3. 一次性的:通常,一条流的数据被读取完后,就不能再读第二次了(当然,你可以通过某些技术实现“重播”,但那不是标准用法)。

在Web开发中,最常见的 ReadableStream 来源就是 Fetch API 的 Response 对象。当你用 fetch() 请求一个支持流式传输的接口时,response.body 属性就是一个 ReadableStream 对象。这就是我们操作的入口。

2.2 getReader():如何从传送带上取货?

传送带有了,你怎么把上面的货拿下来呢?用手直接抓吗?不行,那样不标准,也可能出错。ReadableStream 提供了一个标准方法:getReader()。

调用 response.body.getReader() 会发生两件重要的事:

  1. 创建一个读取器(Reader):这个读取器就是你的“机械手”,专门用来从这条传送带上抓取数据块。
  2. 锁定这个流:这条传送带被你“独占”了。在你释放这个读取器(比如读取完成,或者主动取消)之前,其他任何代码都不能再从这个流里读取数据。这保证了数据消费的有序性和安全性,避免多个消费者抢数据导致混乱。

创建好读取器后,你就可以使用它的 read() 方法了。这个方法返回一个 Promise。当传送带上有新的数据块到达,或者到达了尽头(所有数据发送完毕),这个 Promise 就会完成,并返回一个结果对象。

这个结果对象长这样:{ done: boolean, value: Uint8Array }

  • done:一个布尔值。如果为 true,表示传送带已经走到头了,所有数据都传送完毕,流已经关闭。此时 value 是 undefined。
  • value:一个 Uint8Array 类型的值。这就是你抓取到的“数据块”。但注意,它通常是经过编码的字节数据,对于文本数据,我们需要解码才能看懂。

2.3 实战第一步:创建一个最简单的流式读取

光说不练假把式,我们直接看一段最基础的代码,感受一下这个过程。假设我们有一个返回流式文本的接口 /api/stream。

async function fetchStream() {
  // 1. 发起fetch请求
  const response = await fetch('/api/stream');
  
  // 2. 从response中获取ReadableStream并创建读取器
  const reader = response.body.getReader();
  
  // 3. 创建一个TextDecoder,用于将字节数据解码成字符串
  const decoder = new TextDecoder('utf-8');
  
  // 4. 定义一个递归函数来持续读取
  function read() {
    // reader.read() 返回一个Promise
    return reader.read().then(({ done, value }) => {
      // 情况A:流结束了
      if (done) {
        console.log('Stream finished.');
        return;
      }
      
      // 情况B:收到了数据块
      // value 是 Uint8Array,需要解码
      const chunk = decoder.decode(value);
      console.log('Received chunk:', chunk);
      
      // 在这里!你可以把chunk渲染到页面上
      // 例如:document.getElementById('output').innerHTML += chunk;
      
      // 递归调用read,继续读取下一个数据块
      return read();
    });
  }
  
  // 5. 开始读取
  read().catch(error => {
    console.error('Stream reading failed:', error);
  });
}

// 调用函数
fetchStream();

这段代码就是一个最核心的流式读取骨架。它做了以下几件事:发起请求、锁定流、创建解码器、然后进入一个“读取-处理-再读取”的循环,直到流结束。你现在可以尝试把注释掉的渲染行打开,就能看到文字一段一段出现的效果了。

3. 实现动态渲染:让数据在屏幕上“流”起来

掌握了基础的读取方法,我们现在要解决核心问题:如何把读取到的数据块,流畅地、动态地更新到网页上?这里面的门道,可不仅仅是 innerHTML += 那么简单。

3.1 基础渲染:拼接与展示

最直接的方法,就像上面代码注释里写的,找到一个DOM元素,然后不断把新的文本块(chunk)追加进去。

const outputEl = document.getElementById('output');
function renderChunk(chunkText) {
  outputEl.innerHTML += chunkText;
}

这种方法简单粗暴,在数据块是纯文本且顺序追加的场景下,勉强可用。但它有严重问题:每次 innerHTML += 操作都会导致整个元素的重排(Reflow)和重绘(Repaint)。如果数据流很快,频繁的DOM更新会严重消耗性能,页面可能会卡顿。而且,如果输出区域内容很多,频繁的全文替换也可能导致滚动位置跳动,体验很差。

3.2 进阶优化:使用文档片段与文本节点

为了提升性能,我们可以采用更精细的DOM操作方式。

方案一:使用 DocumentFragment(文档片段) 文档片段是一个存在于内存中的轻量级DOM容器。我们可以先把多次更新累积在片段里,最后一次性地插入到真实DOM中,从而减少重排次数。

const outputEl = document.getElementById('output');
const fragment = document.createDocumentFragment();
let buffer = ''; // 用于累积较小的数据块

function flushBufferToFragment() {
  if (buffer) {
    const textNode = document.createTextNode(buffer);
    fragment.appendChild(textNode);
    buffer = '';
  }
}

function renderChunkOptimized(chunkText) {
  buffer += chunkText;
  
  // 假设我们每累积100个字符,或者每收到5个数据块,刷新一次
  if (buffer.length > 100) {
    flushBufferToFragment();
    // 将文档片段一次性追加到页面
    outputEl.appendChild(fragment);
  }
}

// 在流读取结束时,确保清空缓冲区
function onStreamFinish() {
  flushBufferToFragment();
  outputEl.appendChild(fragment);
  console.log('渲染完毕。');
}

方案二:直接操作文本节点 如果我们只是追加纯文本,更高效的方法是直接找到最后一个文本节点进行修改,或者持续向同一个文本节点追加内容。

const outputEl = document.getElementById('output');
// 确保outputEl初始有一个空的文本节点
outputEl.textContent = '';
let textNode = outputEl.firstChild || document.createTextNode('');
if (!outputEl.firstChild) {
  outputEl.appendChild(textNode);
}

function renderChunkToTextNode(chunkText) {
  // 直接修改文本节点的内容
  textNode.nodeValue += chunkText;
}

这种方法性能极好,因为它只修改了单个节点的文本内容,触发的重排重绘范围最小。对于纯文本流式渲染,这是我个人最推荐的方法。

3.3 处理结构化数据:JSON序列与复杂UI

很多时候,服务器返回的不是纯文本,而是结构化的数据块,比如你提供的例子:一个包含 code 和 chunk 的JSON对象数组。我们需要先解析,再渲染。

async function readAndRenderStream() {
  const response = await fetch('/api/stream-json');
  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  const outputEl = document.getElementById('output');
  
  function read() {
    return reader.read().then(({ done, value }) => {
      if (done) {
        console.log('Stream finished.');
        return;
      }
      
      // 1. 解码字节流得到JSON字符串
      const jsonString = decoder.decode(value);
      
      try {
        // 2. 解析JSON字符串
        const dataChunk = JSON.parse(jsonString);
        
        // 3. 根据数据结构进行渲染
        // 假设 dataChunk 是 { "header": { "code": "200" }, "chunk": "一段文字" }
        if (dataChunk.header && dataChunk.header.code === '200') {
          const chunkText = dataChunk.chunk;
          // 使用优化的文本节点方式渲染
          renderChunkToTextNode(chunkText);
        } else {
          console.error('Received error chunk:', dataChunk);
          // 这里可以处理错误,比如显示错误信息,甚至中断流
        }
      } catch (e) {
        console.error('Failed to parse chunk JSON:', e, 'Raw string:', jsonString);
      }
      
      // 4. 继续读取
      return read();
    });
  }
  
  await read();
}

对于更复杂的UI,比如每个数据块要渲染成一个独立的列表项(<li>)或者消息气泡,思路也是一样的:解析数据 -> 创建对应的DOM元素 -> 插入到容器中。为了性能,同样可以考虑使用 DocumentFragment 进行批量插入。

4. 掌控流程:实现用户主动中断(cancel)

流式渲染的魅力不仅在于“流进来”,更在于可以“停下来”。想象一下,AI生成了你不想要的内容,或者日志刷得太快你想仔细看某一段,这时一个“停止生成”或“暂停”按钮就至关重要。这就是 ReadableStream 和 getReader() 带给我们的另一个强大能力:中断控制。

4.1 cancel()方法的工作原理

还记得我们通过 getReader() 获得的那个 reader 对象吗?它有一个 cancel(reason) 方法。调用这个方法,就等于你对着传送带喊:“停!后面的货我不要了!”

它的行为非常明确:

  1. 立即关闭流:流会被标记为已取消,之后 reader.read() 返回的 Promise 会立刻解决,且 done 为 true。
  2. 丢弃未读数据:传送带上还没被读取的数据块会被丢弃。浏览器也会通知服务器这边消费端已经关闭,服务器理论上应该停止生成和发送数据(这取决于后端实现)。
  3. 返回一个Promise:cancel() 方法本身返回一个 Promise,当流确认被取消后,这个 Promise 会兑现。

4.2 在前端实现中断按钮

结合一个简单的UI按钮,我们可以轻松实现中断功能。关键在于,我们需要让 reader 变量在渲染函数的作用域之外也能被访问到。

// 在组件或模块的顶层作用域声明reader变量
let currentStreamReader = null;

// 开始流式请求和渲染的函数
async function startStreaming() {
  const response = await fetch('/api/stream');
  const reader = response.body.getReader();
  currentStreamReader = reader; // 将reader赋值给外部变量
  
  const decoder = new TextDecoder();
  const outputEl = document.getElementById('output');
  outputEl.textContent = '';
  let textNode = document.createTextNode('');
  outputEl.appendChild(textNode);
  
  function read() {
    // 每次读取前,可以检查一个外部状态标志
    if (isStreamCancelled) {
      console.log('Stream was cancelled, stopping read loop.');
      return Promise.resolve(); // 直接返回一个已解决的Promise,跳出循环
    }
    
    return reader.read().then(({ done, value }) => {
      if (done) {
        console.log('Stream finished naturally.');
        currentStreamReader = null; // 清理引用
        return;
      }
      
      const chunkText = decoder.decode(value);
      textNode.nodeValue += chunkText;
      
      // 继续递归读取
      return read();
    });
  }
  
  try {
    await read();
  } catch (error) {
    console.error('Error during streaming:', error);
    currentStreamReader = null;
  }
}

// 中断流的函数
function cancelStreaming() {
  if (currentStreamReader) {
    console.log('User requested to cancel the stream.');
    // 调用cancel方法
    currentStreamReader.cancel('User cancelled').then(() => {
      console.log('Stream has been successfully cancelled.');
      currentStreamReader = null;
      // 可以在这里更新UI状态,比如把按钮文字从“停止”变回“开始”
      document.getElementById('stopBtn').disabled = true;
      document.getElementById('startBtn').disabled = false;
    }).catch(err => {
      console.error('Error cancelling stream:', err);
    });
  }
}

// 绑定按钮事件
document.getElementById('startBtn').addEventListener('click', startStreaming);
document.getElementById('stopBtn').addEventListener('click', cancelStreaming);

4.3 处理中断后的状态与清理

中断流不仅仅是调用一个方法。良好的用户体验需要我们处理好中断后的状态:

  1. UI状态同步:停止按钮应该变灰或消失,开始按钮恢复可用。可以显示“已停止”的提示。
  2. 清理工作:将 currentStreamReader 置为 null,防止内存泄漏。如果使用了辅助变量(如 isStreamCancelled 标志),也要重置。
  3. 错误处理:cancel() 也可能失败(比如网络突然断开)。我们需要在 .catch 中处理这种异常,并给用户适当的反馈。
  4. 与后端的协作:理想情况下,前端调用 cancel() 后,浏览器会向服务器发送一个信号。一个设计良好的后端接口应该在收到这个信号后,停止后续的计算和传输,节省服务器资源。但这需要前后端协议的支持。

5. 避坑指南与高级技巧

在实际项目中摸爬滚打几年,我踩过不少流式渲染的坑。这里分享几个关键点和进阶思路,希望能帮你绕开这些弯路。

5.1 常见问题与解决方案

问题一:流意外中断或网络错误 网络是不稳定的。流在传输过程中可能因为网络波动而断开。单纯的 reader.read() 循环在出错时会抛出异常,导致整个流程崩溃。 解决方案:用 try...catch 包裹整个读取逻辑,或者在 read().then().catch() 中处理错误。发生错误时,可以尝试重连(对于可重试的流),或者至少给用户一个友好的错误提示,而不是白屏或卡死。

function readWithRetry(reader, maxRetries = 3) {
  let retryCount = 0;
  
  function attemptRead() {
    return reader.read().then(({ done, value }) => {
      // 重置重试计数,因为本次读取成功了
      retryCount = 0;
      if (done) return;
      // ... 处理value ...
      return attemptRead(); // 继续读
    }).catch(error => {
      console.error('Read error:', error);
      if (retryCount < maxRetries) {
        retryCount++;
        console.log(`Retrying... (${retryCount}/${maxRetries})`);
        // 等待一段时间后重试
        return new Promise(resolve => setTimeout(resolve, 1000 * retryCount))
                 .then(() => attemptRead());
      } else {
        // 重试次数用尽,向上抛出错误或进行最终处理
        throw new Error(`Failed after ${maxRetries} retries: ${error.message}`);
      }
    });
  }
  return attemptRead();
}

问题二:数据解码乱码 TextDecoder 默认使用 UTF-8,但如果服务器返回的是其他编码(如 GBK),就会产生乱码。 解决方案:明确指定解码器的编码。你需要和后端确认数据流的编码格式。

// 如果后端明确使用GBK编码
const decoder = new TextDecoder('gbk');

问题三:内存增长 如果流非常长(比如一个巨大的文件),不断将数据块拼接成一个巨大的字符串可能会导致内存占用过高。 解决方案:采用“处理即丢弃”的策略。如果不需要保留完整的历史数据,可以在渲染后丢弃已处理的数据块引用。对于需要历史数据的场景,可以考虑分段存储或使用虚拟列表等技术,只渲染可视区域附近的内容。

5.2 性能优化:防抖、节流与渲染策略

即使使用了文本节点优化,极端高频的流(比如每毫秒一个数据块)仍然可能导致渲染线程过忙。

  • 防抖(Debounce):不适合流式渲染,因为它会延迟最终输出,失去“实时”感。
  • 节流(Throttle):一个更好的选择。我们可以设定一个最小时间间隔(比如50ms),在这个间隔内,累积收到的所有数据块,然后一次性渲染。这能在保持相对实时性的同时,大幅减少DOM操作频率。
let renderBuffer = '';
let renderScheduled = false;
const OUTPUT_EL = document.getElementById('output');
let outputTextNode = OUTPUT_EL.firstChild;

function scheduleRender(chunkText) {
  renderBuffer += chunkText;
  
  if (!renderScheduled) {
    renderScheduled = true;
    // 使用requestAnimationFrame在下一次浏览器绘制前渲染,效果更平滑
    requestAnimationFrame(() => {
      outputTextNode.nodeValue += renderBuffer;
      renderBuffer = '';
      renderScheduled = false;
    });
  }
  // 如果不用requestAnimationFrame,用setTimeout做节流也可以
  // if (!renderScheduled) {
  //   renderScheduled = true;
  //   setTimeout(() => {
  //     outputTextNode.nodeValue += renderBuffer;
  //     renderBuffer = '';
  //     renderScheduled = false;
  //   }, 50); // 每50ms渲染一次
  // }
}

5.3 结合现代前端框架(Vue/React)

在Vue或React中,原理完全一样,只是状态管理和DOM更新的方式需要遵循框架的规则。

Vue 3 示例(使用Composition API):

<template>
  <div>
    <div ref="outputEl">{{ displayedText }}</div>
    <button @click="startStream">开始</button>
    <button @click="cancelStream" :disabled="!reader">停止</button>
  </div>
</template>

<script setup>
import { ref, onUnmounted } from 'vue';

const displayedText = ref('');
const reader = ref(null); // 存储reader引用

async function startStream() {
  displayedText.value = '';
  const response = await fetch('/api/stream');
  const streamReader = response.body.getReader();
  reader.value = streamReader; // 存储起来以便取消
  const decoder = new TextDecoder();

  function read() {
    return streamReader.read().then(({ done, value }) => {
      if (done) {
        reader.value = null;
        return;
      }
      const chunk = decoder.decode(value);
      // 在Vue中,直接更新响应式变量即可
      displayedText.value += chunk;
      return read();
    }).catch(err => {
      console.error(err);
      reader.value = null;
    });
  }
  read();
}

function cancelStream() {
  if (reader.value) {
    reader.value.cancel();
    reader.value = null;
  }
}

// 组件卸载时,自动取消流,防止内存泄漏
onUnmounted(() => {
  cancelStream();
});
</script>

React 示例(使用函数组件与Hooks):

import { useState, useRef } from 'react';

function StreamRenderer() {
  const [text, setText] = useState('');
  const readerRef = useRef(null); // 使用ref存储reader,避免state更新导致丢失

  const startStream = async () => {
    setText('');
    const response = await fetch('/api/stream');
    const reader = response.body.getReader();
    readerRef.current = reader;
    const decoder = new TextDecoder();

    const read = () => {
      reader.read().then(({ done, value }) => {
        if (done) {
          readerRef.current = null;
          return;
        }
        const chunk = decoder.decode(value);
        // React中,使用函数式更新确保拿到最新状态
        setText(prevText => prevText + chunk);
        read(); // 继续读取
      }).catch(err => {
        console.error(err);
        readerRef.current = null;
      });
    };
    read();
  };

  const cancelStream = () => {
    if (readerRef.current) {
      readerRef.current.cancel();
      readerRef.current = null;
    }
  };

  return (
    <div>
      <div>{text}</div>
      <button onClick={startStream}>开始</button>
      <button onClick={cancelStream} disabled={!readerRef.current}>
        停止
      </button>
    </div>
  );
}

框架的核心思路是:将流读取的逻辑(包括 reader 的存储)与框架的响应式系统解耦。reader 通常用 ref(Vue)或 useRef(React)来存储,因为它本身不是需要触发视图更新的数据。而流的内容则通过更新响应式状态(ref/reactive 或 useState)来驱动UI变化。在组件销毁时,务必记得在生命周期钩子(如 onUnmounted、useEffect 的清理函数)中调用 cancel(),这是一个非常好的编程习惯,能有效避免潜在的内存泄漏和错误。

利用ReadableStream.getReader实现动态数据流式渲染与中断控制 本文深入解析了如何利用ReadableStream.getReader实现前端动态数据流式渲染与用户中断控制。通过对比传统渲染模式的弊端,详细阐述了流式渲染的核心优势,并提供了从Fetch获取流、实时DOM渲染到用户主动中断的完整实战代码。文章重点介绍了reader.read()、reader.cancel()等关键API的使用方法,以及如何处理JSON流、性能优化和常见避坑指南,为构建高性能、可交互的实时Web应用提供了专业解决方案。 阅读详情

相关推荐

大模型流式输出原理与前端实现全解析

流式输出是大语言模型推理过程的自然体现,源于其自回归生成机制——逐token预测、串行依赖、不可并行化。该机制决定了响应必须以增量方式传递,而非整块返回,从而催生了SSE与ReadableStream两类主流传输方案。前者基于HTTP协议扩展,具备自动重连与调试友好特性;后者依托Fetch API原生流能力,支持精细控制与中断操作。技术价值在于保障实时性、降低首字延迟、提升用户感知流畅度,并支撑客服机器人、IDE插件、实时翻译等强交互场景。本文深入剖析从模型推理、后端封装、协议适配到前端渲染的全链路实践。

weixin_34198881的博客 311

JS Web API: Stream API 解析

JS: Stream API 解析 文章目录JS: Stream API 解析正文1. Stream 概念 & 类型2. ReadableStream3. WritableStream4. pipeTo 传递数据4.1 自定义流对接4.2 pipeTo5. TransformStream & pipeThrough5.1 TransformStream 的创建5.2 自定义流通道5.3 TransformStream + pipeThrough6. 应用其他资源参考连接完整代码示例 正文 1

超悠閒的博客 3356

AI前端实战:流式处理、TypeScript类型安全与状态协同

AI前端并非简单调用大模型API,而是围绕流式响应(Streaming)与渐进式数据交付构建的新型前端范式。其核心原理在于打破传统HTTP‘请求-响应’单次闭环,转为持续的数据通道管理;技术价值体现在通过TypeScript类型守卫约束AI输出不确定性、借助状态机编排AI生命周期,从而保障UI响应性与逻辑鲁棒性;典型应用场景包括AI聊天界面、技术文档摘要助手、智能代码补全等需实时反馈的交互系统。本文聚焦AI前端三大交汇点——流式处理、TypeScript类型基建与AI感知型状态管理,提供可落地的工程实践路径

weixin_33834075的博客 368

【Javascript】解析ReadableStream保存为Excel

https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream

huiskai的博客 4197

to-readable-stream:将stringBufferUint8Array转换为可读流

可读流 将字符串/缓冲区/ Uint8Array转换为 如果您以Node.js 12或更高版本为目标,则可以改用 。 安装 $ npm install to-readable-stream 用法 import toReadableStream from 'to-readable-stream' ; toReadableStream ( ':unicorn::rainbow:' ) . pipe ( process . stdout ) ; 原料药 toReadableStream(值) 返回一个 。 价值 类型: string | Buffer | Uint8Array string | Buffer | Uint8Array 转换为流的值。 有关的 -此模块的更高级版本 Tidelift帮助维护人员实现开源的可持续发展,同时为公司提供帮助有关其依赖项的安全性,维护和许可的保证。

web-readable-stream:通用ReadableStream实现

图书馆 该库旨在提供可在节点,浏览器和电子运行时中使用的实现。 状态:暂无

javascript基础从小白到高手系列二百三十四:使用ReadableStream 主体

因为可以使用ReadableStream 创建Response 对象,所以就可以在读取流之后,将其通过管道。要将Uint8Array 转换为可读文本,可以将缓冲区传给TextDecoder,返回转换后的值。缓冲区的大小,以及浏览器是否等待缓冲区被填充后才将其推到流中,要根据JavaScript 运行时的。在这些例子中,当读取完Uint8Array 块之后,浏览器会将其标记为可以被垃圾回收。从TCP/IP 角度来看,传输的数据是以分块形式抵达端点的,而且速度受到网速的限制。此外,浏览器如果决定不等待网络,

wanmeijuhao的博客 1310

【AI Infra】Perfetto性能分析工具指南

Perfetto是一款开源性能分析工具,提供系统级和应用级的活动数据追踪功能。其界面分为四个区域:左侧操作区(包含Trace查看、SQL查询、预置分析等功能)、上方信息区、中间图形化展示区以及下方详细信息区。工具支持快捷键操作(w/s缩放、a/d移动、m标记等),并能高效处理大体积Trace文件。通过Timeline分析可发现性能瓶颈,如案例中update_actor耗时过高的问题,最终定位到CPU offloading导致的MemcpyH2D操作耗时过长,提出了优化方案。Perfetto相比Systrac

baiweizeng的博客 1511

大模型前端流式输出实战:SSE与ReadableStream双协议详解

流式输出是大模型应用的核心交互范式,本质是将模型逐token生成的语义流,通过HTTP长连接实时传递至浏览器。其技术原理依赖服务端持续推送能力与客户端流式解析机制,关键价值在于降低首字延迟、提升用户留存与对话深度。主流实现路径包括兼容性优先的SSE协议和现代灵活的ReadableStream API,二者分别解决自动重连、鉴权支持与精细中断控制等工程痛点。典型应用场景涵盖Chat UI、AI助手、本地Ollama集成及FastAPI后端流式封装。本文聚焦真实链路打通——从token生成、协议选型、前端渲染优

weixin_34174422的博客 271

CLASSB类移植(满足IEC 60730-1和60355-1标准)

针对软件认证需要满足IEC 60730-1和60335-1标准,ST公司专门提供的软件扩展包X-CUBE-CLASSB,它包含自测库和文档,支持多种STM32系列芯片,通过预集成测试库和标准化流程,帮助开发者快速满足国际安全标准,适用于家电、工业控制等高可靠性场景。ClassB软件包程序检测内容分为两个主要部分:启动时的自检和运行时的周期自检,MCU在上电的时候会进行复位启动,在启动完成以后会进行运行自检。

m0_61973119的博客 1402

深度强化学习训练结果曲线绘制教程

使用python语言,只调用matplotlib库,绘制训练过程中保存的强化学习训练曲线。模仿经典论文中的训练曲线,多次训练取平均,并绘制出阴影区域。

加斯顿工程师的博客 913

前端流式输出实战:SSE与ReadableStream构建AI实时响应

流式输出是大模型应用中实现低延迟、高沉浸感交互的基础技术能力,其核心在于将LLM生成的文本以连续数据流形式分块传输并即时渲染。它依托SSE协议建立轻量单向通道,配合前端ReadableStream接口完成字节级安全解码与消费,从而规避UTF-8截断、乱码及首屏卡顿等典型问题。该技术直接支撑实时对话、长文本渐进呈现、多模态混合输出等关键场景,已成为现代AI Web应用的标准交互范式。本文聚焦SSE配置、流式解码、光标动画与排障实践,系统拆解从协议层到UI层的全链路实现。

weixin_34262482的博客 254

MATLAB基础应用精讲-【图像处理】GNN图神经网络(附python代码实现)

图神经网络由于其在处理非欧空间数据和复杂特征方面的优势,受到广泛关注并应用于推荐系统、知识图谱、交通道路分析等场景。图结构可描述复杂关系,如基因结构、通信网络、交通路线、社交网络等。图计算挖掘结构信息,但无法学习节点特征。神经网络在欧氏空间数据上表现优越,但无法直接应用于非欧氏空间的图数据。图神经网络结合图计算和神经网络优势,处理非欧氏空间数据及其复杂特征,应用于网络链接预测、推荐系统和交通道路分析等场景。实际应用中,图数据规模庞大,如百亿级节点、千亿级边,存储开销超过10TB。

qq_36130719的博客 1143

大模型流式输出原理:SSE与ReadableStream实战解析

流式输出是现代AI应用的核心交互范式,本质是将语言模型逐token生成的特性,通过HTTP协议层(如SSE)和浏览器流API(ReadableStream)转化为实时、低延迟、可中断的文本呈现。其技术价值在于平衡实时性、内存效率与用户体验,广泛应用于AI聊天助手、代码补全、长文本生成等场景。实现中需深入理解SSE的单向广播机制、UTF-8分块解析规则,以及ReadableStream的背压控制与增量解码逻辑。本文聚焦于SSE与ReadableStream两大关键技术在大模型前端流式渲染中的协同落地,覆盖协议

weixin_34239592的博客 313

PyTorch 面试题及参考答案(精选100道)

模块是 PyTorch 中用于自动求导的核心模块。它为张量上的所有操作提供了自动求导的功能。在深度学习中,反向传播是一种用于计算损失函数相对于模型参数的梯度的算法。通过梯度,我们可以使用优化算法(如随机梯度下降)来更新模型的参数,从而最小化损失函数。模块的主要作用就是自动计算这些梯度。当我们创建一个张量时,如果将其属性设置为True,那么 PyTorch 会跟踪该张量上的所有操作。在完成前向传播计算出损失函数后,调用方法,模块会自动根据链式法则反向传播计算出所有需要求导的张量的梯度。

大模型大数据攻城狮的专栏 1681

FAST-LIVO2 源码精读(一):系统总览——从 LIO 到 LIVO 的多传感器融合架构

本文是「FAST-LIVO2 激光-惯性-视觉里程计源码精读」专栏的开篇。全专栏共 18 篇,锚定香港大学 MaRS 实验室 2025 年 1 月开源的官方代码,逐模块剖析这套登上 T-RO’24 的多传感器融合系统。开篇先建立全局认知:FAST-LIVO2 所要解决的问题、整体框架的构成,以及源码主线的数据流动。

PX4-SLAM-PNC 606

Vue2 AI问答实现:流式与非流式接口完整指南

HTTP流式传输与SSE(Server-Sent Events)是构建实时交互式AI应用的核心技术。流式接口允许模型边生成边推送内容,显著提升用户体验;非流式接口则简单稳定,适合后台任务。对于使用Vue2技术栈的开发者,理解如何通过Fetch API的ReadableStream处理流式数据,以及如何在Vue2响应式体系中高效更新消息,是落地AI问答功能的关键。本文从接口选型、参数构造到组件实现,系统梳理了流式与非流式两种方式的完整链路,涵盖AbortController中断请求、打字机效果、异常分类、跨域

weixin_33851177的博客 471

基于MATLAB的奇异谱分析(SSA)算法详解

本文详细介绍了基于MATLAB的奇异谱分析(SSA)算法。文章首先阐述了SSA的基本概念、历史发展及其与传统信号分析方法的对比优势,指出SSA作为一种非参数、非线性时间序列分析方法,特别适合处理非平稳信号。随后详细解析了SSA算法的核心原理与数学模型,包括轨迹矩阵构建、奇异值分解、分组与重构四个关键步骤。文章还提供了完整的MATLAB实现框架和代码解析,涵盖参数检查、轨迹矩阵构建、SVD分解、分组策略和重构过程。最后,通过信号分解、去噪和预测三个应用案例展示了SSA的实际效果。

qq_42212808的博客 170

大模型前端流式输出实战:SSE原理与防抖渲染

流式输出是大模型交互的核心技术基础,本质源于自回归生成的token-by-token特性,要求服务端边推理边推送。SSE(Server-Sent Events)凭借浏览器原生支持、HTTP兼容性高、单向低开销等优势,成为当前最主流的前端流式传输方案,显著优于WebSocket在纯下行场景中的冗余复杂度。其技术价值体现在提升用户心理预期、降低前端内存压力、实现毫秒级错误感知三大维度,广泛应用于AI对话、实时批改、智能客服等Web交互场景。本文深入解析SSE协议格式、EventSource封装、防抖渲染优化及N

weixin_34129696的博客 234

基于双目视觉的行车中障碍距离检测方法研究与目标跟踪

本文将介绍基于Python语言的双目视觉技术,以及如何使用该技术检测行车中的障碍物并跟踪目标。双目视觉利用两个摄像头模拟人眼的立体视觉,通过对两个摄像头所捕捉的图像进行比较和分析,可以得到物体的深度信息。首先,我们需要安装Python的OpenCV库,该库提供了丰富的图像处理和计算机视觉功能。接下来,我们进入一个循环中,不断读取左右图像,并将其转换为灰度图像。在视差图上,您可以实现目标检测和跟踪算法来识别和跟踪行车中的障碍物。请注意,上述代码只是一个简单示例,您可以根据具体需求和算法进行修改和扩展。

ZgnObjectivec的博客 279

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

AI原生前端实战指南:TypeScript流式渲染与状态管理

AI原生前端是当前前端工程范式迁移的核心方向,其本质在于将传统UI开发升级为面向LLM交互、流式响应和动态上下文的状态系统。它依托TypeScript强类型保障AI输出安全,依赖ReadableStream与AbortController实现可靠流式渲染,并需重构状态管理以承载多轮对话、工具调用与多模态生命周期。技术价值体现在提升AI交互的稳定性、可维护性与用户体验一致性,广泛应用于智能客服、编程助手、无登录聊天网页等低门槛生成式AI场景。本文聚焦‘ai无禁词聊天网页版不用登录’背后的工程实现,深入拆解Ty

weixin_34117211的博客 332

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

V1封装实战:SSE流式接口与axios二次封装的工程总结

封装是软件与硬件工程中共同的核心思想,通过隐藏内部复杂度、定义清晰对外接口来降低维护成本。在软件领域,axios二次封装统一拦截器与错误码处理,针对AI对话场景的SSE流式接口封装则解决了增量渲染与请求中断的难题;在硬件领域,芯片封装、PCB焊盘编号同样遵循边界明确原则。无论是前端H5多域名适配,还是组件化抽象,封装的目标都是让变化集中在可控范围。一次V1项目实践拆解了从请求层、组件层到工具层的封装思路,并分享SSE流式解析、abort资源释放等工程细节,为同类项目提供可直接落地的参考。

weixin_33755557的博客 561

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

全栈AI应用骨架:SSE流式对话与中断机制实战解析

在构建AI应用时,流式输出能力往往决定了用户体验的上限。实时数据推送技术是支撑打字机效果、多轮对话与多端同步的关键底座。Server-Sent Events(SSE)作为基于HTTP的轻量级推送协议,相比WebSocket更简单可靠,天然适合大模型响应场景。通过服务端流式转发、标准消息协议封装以及前端ReadableStream解析,开发者可以构建稳定可复用的对话链路。同时,用户主动中断是流式场景不可忽视的边界条件,需结合AbortController与Go context实现端到端取消,避免资源泄漏与状态

weixin_34121304的博客 438

9月8日启动AI前端面试:TypeScript流式状态三重实战

AI前端开发正从传统Web工程范式转向以不确定性应对、流式交互和概率化状态为核心的新阶段。TypeScript不再仅是类型标注工具,而是构建AI响应容错边界的防御体系;流式处理超越性能优化范畴,成为重塑用户认知节奏的关键体验层;状态管理则需升级为支持任务生命周期、依赖图与中断恢复的AI原生状态流。这些能力共同构成大模型时代前端工程师的核心技术栈,在智能UI、RAG应用、客户端LLM推理等真实场景中持续验证。本文聚焦9月秋招黄金启动窗口,系统拆解如何通过60天靶向训练,将理论认知转化为可交付的工程肌肉。

weixin_34413103的博客 216

DeepSeek前端架构解析:WASM与Web Worker如何优化AI流式响应

在现代Web应用中,处理计算密集型任务常面临主线程阻塞与性能瓶颈的挑战。WebAssembly(WASM)与Web Worker的结合提供了一种高效解决方案:WASM提供接近原生的计算性能,适合执行Token编解码等密集运算;Web Worker则实现线程隔离,确保UI流畅。这种架构特别适用于AI应用的流式响应场景,能够将耗时的数据处理任务移至后台线程,通过WASM加速,实现边接收、边解析、边渲染的高效流水线。例如,在DeepSeek的问答接口中,该技术组合被用于实时处理流式返回的Token序列,显著提升了

weixin_30363509的博客 435

Vue2老项目接入AI问答机器人:流式SSE与非流式接口完整实战

在传统前端技术栈中,Vue2仍是众多存量系统的基石,如何在不动摇既有架构的前提下引入人工智能交互能力,成为许多开发团队面临的现实挑战。流式接口与SSE(Server-Sent Events)是提升AI问答体验的关键机制,它通过长连接将大模型生成的token逐段推送,形成打字机效果,显著降低用户等待焦虑;而非流式接口则以其简单稳定适用于短回答或内部系统。理解两种HTTP交互模式的原理与差异,掌握文本解码、增量渲染、请求竞态控制以及Vue2响应式更新边界,是落地AI问答模块的技术前提。这类能力广泛应用于智能客服

weixin_34200628的博客 346
上一篇: 协同控制中的拉普拉斯矩阵:从特征值到一致性协议
下一篇: 从心理学到自动驾驶:拆解理想汽车快慢思考系统在DriveVLM中的真实应用
lambda
博客等级 码龄23年 49粉丝 1303原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值