stream: true как работает ?
- User
stream: true как работает ?
- Assistant
stream: true— это параметр, который часто используется в API и библиотеках для указания на то, что данные должны передаваться по частям (потоком), а не загружаться целиком.В контексте API, например, OpenAI, использование
stream: trueпозволяет получать ответы по частям, что полезно для обработки больших объемов данных или для создания приложений, которые требуют немедленного отображения информации по мере её получения.Как это работает?
-
Постепенная загрузка данных: Вместо того, чтобы получать весь ответ сразу, сервер начинает отправлять данные немедленно по мере их обработки. Это уменьшает задержку, так как клиент может начинать обрабатывать информацию сразу.
-
Поддержка асинхронного программирования: Клиенты, поддерживающие потоковую передачу, могут использовать асинхронные конструкции, такие как async/await, для обработки данных. Это позволяет эффективно реагировать на события и управлять ресурсами.
-
Использование веб-сокетов: Некоторые API используют веб-сокеты для поддержки потоковых соединений, что позволяет отправлять и получать данные в реальном времени.
Пример использования
При использовании API, поддерживающего потоковые ответы с
stream: true, вы можете начать слушать события или данные сразу после отправки запроса. Например:const response = await fetch('API_URL', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ prompt: 'Hello', stream: true }) }); const reader = response.body.getReader(); while (true) { const { done, value } = await reader.read(); if (done) break; // Обработка полученных данных console.log(new TextDecoder().decode(value)); }Преимущества использования потоков
- Снижение задержки: Данные обрабатываются и отображаются немедленно.
- Улучшение пользовательского опыта: Пользователи могут видеть результат раньше, чем он будет полностью загружен.
Если у вас есть конкретный контекст или технология, в которой вы хотите использовать
stream: true, дайте знать, и я могу предоставить более подробную информацию! -
- User
await можно использовать без aysnc ?
- Assistant
Нет, оператор
awaitнельзя использовать без функции, объявленной с помощьюasync. Чтобы использоватьawait, необходимо, чтобы он находился внутри асинхронной функции (async function). Попытка использоватьawaitвне асинхронной функции приведет к ошибке.Вот краткие объяснения и примеры:
Как это работает:
- Асинхронные функции:
- Функция, объявленная с ключевым словом
async, автоматически возвращаетPromise. - Внутри такой функции можно использовать оператор
awaitдля "ожидания" завершения промиса.
- Функция, объявленная с ключевым словом
Пример:
// Пример асинхронной функции async function fetchData() { const response = await fetch('https://api.example.com/data'); const data = await response.json(); console.log(data); } // Вызов асинхронной функции fetchData();Неправильное использование
await:// Ошибка: 'await' не может быть использован вне асинхронной функции const response = await fetch('https://api.example.com/data'); // Это вызовет ошибкуИспользование
awaitв IIFE:Если вы хотите использовать
awaitв глобальной области видимости (например, в модулях), вы можете обернуть ваш код в асинхронную самовыполняющуюся функцию (IIFE):(async () => { const response = await fetch('https://api.example.com/data'); const data = await response.json(); console.log(data); })();Резюме:
Поэтому всегда, когда вы хотите использовать
await, убедитесь, что вы находитесь внутри функции, объявленной сasync, или используйте обертку в самовыполняющуюся асинхронную функцию. - Асинхронные функции:
- User
вот мой пример что делает stream: true
fetch("https://dummyjson.com/products/") .then((response) => { if (!response.ok) { throw new Error("Ошибка:", response.status, response.statusText); } const data = response.body.getReader(); // Возвращает reader const decoder = new TextDecoder("utf-8"); let result = ""; // Переменная для накопления данных
function readPartly() { return data.read().then(({ done, value }) => { if (done) { console.log("Чтение завершено"); console.log(JSON.parse(result)); // парсим результат и выводим return; } else { const chunk = decoder.decode(value, { stream: true }); result += chunk; // Накопление данных return readPartly(); // Рекурсивно вызываем для следующего куска } }); } return readPartly();}) .catch((error) => { console.log("Ошибка:", error.message); });
- Assistant
Код, который вы привели, загружает данные с API (в данном случае, с
https://dummyjson.com/products/) и обрабатывает ответ в потоковом режиме, используя интерфейсReadableStream. Давайте разберем, что именно происходит в вашем коде и как используетсяstream: true(хотя в случае вашего примера, параметрstreamне указан, это важно учитываться, если сервер его поддерживает).Объяснение кода
-
Обращение к API:
fetch("https://dummyjson.com/products/")Здесь вы вызываете fetch для получения данных с указанного URL.
-
Проверка ответа:
if (!response.ok) { throw new Error("Ошибка:", response.status, response.statusText); }Проверяется, успешен ли ответ (статус 2xx). Если нет, выбрасывается ошибка.
-
Получение
ReadableStream:const data = response.body.getReader();Здесь вы получаете
ReadableStreamи используете методgetReader(), чтобы получить объектReadableStreamDefaultReader, который позволяет читать данные из потока. -
Декодирование данных:
const decoder = new TextDecoder("utf-8"); let result = "";Создается объект
TextDecoderдля декодирования данных в текстовом формате. -
Рекурсивное чтение данных:
function readPartly() { return data.read().then(({ done, value }) => { if (done) { console.log("Чтение завершено"); console.log(JSON.parse(result)); return; } else { const chunk = decoder.decode(value, { stream: true }); result += chunk; return readPartly(); } }); }Функция
readPartlyчитает данные из потока. Она:- Читает следующий "кусок" данных с помощью метода
read(). - Если чтение завершено (
doneравноtrue), выводит результат и останавливает выполнение. - Если данные еще есть, декодирует их, добавляет в переменную
resultи рекурсивно вызывает себя снова для чтения следующего кусочка.
- Читает следующий "кусок" данных с помощью метода
Использование
stream: trueв контекстеВ вашем коде явного параметра
stream: trueнет. Этот параметр мог бы быть добавлен, если бы вы делали запрос к API, который поддерживает этот параметр, например, в OpenAI API. Однако, если сервер возвращает данные в виде потока по умолчанию (как это делаетdummyjson.com), вы можете обрабатывать их так же, как в вашем примере.Когда использовать
stream: true?stream: trueиспользуется, когда вы хотите, чтобы сервер возвращал данные по частям (потоком). Это особенно полезно, когда:- Ожидается большой объем данных.
- Вы хотите сократить время до первой отрисовки данных (lower latency) и начать обработку сразу после получения первой части данных.
- Вам нужно обрабатывать данные по мере их поступления, например, для отображения live-транслируемой информации.
Таким образом, в вашем коде происходит потоковая обработка ответа, что помогает эффективно работать с большим объемом данных и улучшает пользовательский опыт.
-
- User
зачем тогда в моем примере ?ъ { stream: true });
- Assistant
При использовании
stream: true, параметр используется для указания серверу о том, что клиент желает получать данные в режиме потоковой передачи. Это означает, что сервер будет отправлять данные по частям (чаще всего с использованием технологии, такой как HTTP/2 или WebSockets) вместо того, чтобы дожидаться завершения всей обработки и отправлять всё сразу. Давайте разберемся, что это означает в контексте вашего примера и как его использовать правильно.Как это работает в вашем примере
В вашем коде текущая реализация не содержит параметра
stream: true, так как вы читаете поток, возвращаемый API, используяresponse.body.getReader(). Однако, если бы ваше API поддерживало потоковые ответы и вы добавили быstream: true, это значило бы следующее:-
Запрос на потоковую передачу данных: Когда вы отправляете запрос с
stream: true, вы говорите серверу, что хотите получать данные сразу по мере их готовности. Это уменьшает задержки, так как вы начинаете получать и обрабатывать данные, как только сервер отвечает, а не ждете завершения всего запроса. -
Чтение данных по частям: В вашем примере
response.body.getReader()позволяет извлекать данные по частям. Это означает, что клиент сможет начинать обрабатывать данные сразу после их поступления:const chunk = decoder.decode(value, { stream: true });Использование
{ stream: true }при декодировании говоритTextDecoder, что вы работаете с потоком данных, и позволяет правильно обрабатывать данные, которые могут быть не завершенными (например, если они разделены на отдельные части).
Пример с использованием
stream: trueКогда вы делаете запрос с
stream: true, это могло бы выглядеть следующим образом (например, для использования с каким-либо API, который это поддерживает):fetch("https://dummyjson.com/products/", { method: 'GET', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', }, // Предполагаем, что API поддерживает этот параметр body: JSON.stringify({ stream: true }) }) .then(response => { if (!response.ok) { throw new Error("Ошибка:", response.status, response.statusText); } const reader = response.body.getReader(); const decoder = new TextDecoder("utf-8"); let result = ""; function readPartly() { return reader.read().then(({ done, value }) => { if (done) { console.log("Чтение завершено"); console.log(JSON.parse(result)); return; } else { const chunk = decoder.decode(value, { stream: true }); result += chunk; return readPartly(); } }); } return readPartly(); }) .catch(error => { console.log("Ошибка:", error.message); });Заключение
Ваша реализация уже эффективно использует потоковую передачу данных, когда вы работаете с
response.body.getReader(). Параметрstream: trueважен на уровне API и указывает серверу, что клиент готов принимать данные в режиме реального времени.Когда этот параметр используется, это может улучшить общую производительность и отзывчивость приложения, особенно когда речь идет о больших объемах данных или о возможных длительных процессах.
Важно отметить, что если ваш API не требует явного указания
stream: true, это может быть и не обязательно. В случае вашего примера сdummyjson.com, API уже возвращает данные в виде потока, и вы можете просто читать их, как это делается в вашем коде. -
- User
т.е. если я сделаю так, то конец первой части данных и начало второй части может быть неправильно декодировано, верно ? const chunk = decoder.decode(value);
- Assistant
Да, вы абсолютно правы. Если использовать
decoder.decode(value)без указания{ stream: true }, вы рискуете неправильно декодировать данные, если они приходят частями.Почему это важно
-
Частичные данные: При потоковой передаче данных (streaming) это может быть особенно актуально, когда данные делятся на несколько частей (чанков). Если строка заканчивается не полностью на конце чанка, а продолжает передаваться в следующем чанке, без правильной обработки вы можете получить ошибку в декодировании.
-
Работа с текстом: Если вы декодируете данные как текст и не указываете
{ stream: true }, текстовый декодер будет считать, что переданная им строка завершена. Это может привести к тому, что последние символы предыдущего чанка и первые символы следующего чанка будут неправильно интерпретированы. Например, если часть данных кончается на utf-8 коде символа, который завершается в следующем чанке, это может вызвать ошибки при декодировании.
Пример
Если не использовать
{ stream: true }, и вы получили два чанка, которые являются частью одной строки:// Чанки: const chunk1 = new Uint8Array([72, 101, 108, 108, 111]); // "Hello" const chunk2 = new Uint8Array([32, 119, 111, 114, 108, 100, 33]); // " world!"При безусловном декодировании:
const result1 = decoder.decode(chunk1); // "Hello" const result2 = decoder.decode(chunk2); // " world!"Результаты будут корректны, но если они идут последовательно (и
chunk1заканчивается на неполном байте):const chunk1 = new Uint8Array([72, 101, 108, 108, 111, 0xe2, 0x9c]); // "Hello" + начало UTF-8 символа const chunk2 = new Uint8Array([0x94, 0x20]); // окончание UTF-8 символаВы получите неправильный результат при декодировании, поскольку
decoder.decode(chunk1)может вернуть вам неверный текстовый символ.Заключение
Поэтому при работе с потоковыми данными важно использовать
{ stream: true }в вызове методаdecode, чтобы декодер знал, что данные могут приходить частями и что он должен обрабатывать информацию корректно, в контексте возможных частичных символов.Таким образом, чтобы избежать ошибок декодирования при работе с потоковыми данными, рекомендуется всегда использовать
{ stream: true }при передаче чанков вTextDecoder.decode(). -
- User
а если я не укажу этот параметр здесь const chunk = decoder.decode(value);
но укажу э
- Assistant
Если вы не укажете
{ stream: true }в методеdecoder.decode(value)при декодировании значений из потока, тогда это может привести к потенциальным проблемам с декодированием, особенно если данные приходят частями и могут формировать неполные символы UTF-8.Что будет, если не указывать
{ stream: true }-
Ошибки при декодировании: Если данные приходят частями, и одна часть содержит неполный байт символа, то при вызове
decoder.decode(value)без{ stream: true }TextDecoderможет интерпретировать это как завершённый символ. В результате, вы можете получить некорректный текст или ошибку. Например, если вы получаете набор байтов, которые завершают символ UTF-8, но следующий поток данных начинается с начала нового символа, то это может привести к неверному декодированию. -
Проблемы с частичными символами: Например, если вы получаете текст, который включает символы, требующие более одного байта (например, эмодзи или некоторые специальные символы), и эти байты приходят в нескольких чанках, то при отсутствии параметра
{ stream: true }вы можете попытаться декодировать неполный символ, что, вероятно, приведет к ошибке или некорректному отображению.
Например
Вот упрощённый пример:
const decoder = new TextDecoder("utf-8"); // Первый чанк, содержащий начало многобайтового символа const chunk1 = new Uint8Array([0xe2, 0x98]); // Начало символа const part1 = decoder.decode(chunk1); // У вас будет что-то вроде "�" (замена) // Второй чанк, содержащий окончание символа const chunk2 = new Uint8Array([0x83]); // Окончание символа const part2 = decoder.decode(chunk2); // Вместо ожидаемого символа, опять получите "�" (замена)Если бы вы использовали
{ stream: true }, ваш код выглядел бы так:const part1 = decoder.decode(chunk1, { stream: true }); // Не завершённый символ const part2 = decoder.decode(chunk2, { stream: true }); // Завершённый символЗдесь метод
decoder.decode(chunk1, { stream: true })будет ожидать, что могут быть ещё данные, и корректно обработает их после того, как следующий чанк будет прочитан.Заключение
Если вы не укажете
{ stream: true }при декодировании, вы рискуете потерять корректную обработку многобайтовых символов, которые могли бы быть разделены между чанками. Поэтому, чтобы избежать этих могущих проблем, при работе с потоками и частично загружаемыми данными всегда рекомендуется использоватьdecode(value, { stream: true })для корректной работы с текстом. -
- User
если я не укажу этот параметр в decode, а укажу его в в теле fetch ? fetch("https://dummyjson.com/products/", { body: JSON.stringify({ stream: true }) })
- Assistant
Если вы укажете
stream: trueкак часть тела запроса в методеfetch, это не будет иметь никакого эффекта на то, как будут декодироваться данные при использованииTextDecoder. Давайте разберемся, что это означает:Важные моменты:
-
Параметр
streamв теле запроса:- Указание
stream: trueвbodyвашего запроса (например, в JSON) не является стандартным приемом и, скорее всего, не будет распознано сервером как указание на потоковую передачу данных. В большинстве API параметры запроса должны передаваться через заголовки, URL-параметры или другие подходы, зависящие от конкретного API.
- Указание
-
Функция
TextDecoder.decode():- При декодировании полученных данных с помощью
TextDecoder, важно использовать{ stream: true }при каждом вызовеdecode(value), если вы знаете, что данные будут поступать частями. Если вы не укажете этот параметр, это может привести к ошибкам декодирования, как уже обсуждалось.
- При декодировании полученных данных с помощью
Как это правильно использовать
Для получения потоковых данных, вам нужно убедиться, что сервер поддерживает потоковые ответы и что вы правильно указываете, как это должно быть реализовано — обычно через заголовки или параметры URL, а не через
body. Например, если ваш API поддерживает потоковые запросы, заголовок может выглядеть так:fetch("https://dummyjson.com/products/", { headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', 'X-Stream': 'true' // Пример заголовка (если API поддерживает) } })Более правильный подход
Если сервер поддерживает потоковую передачу данных и ожидает получения специального параметра, вы должны узнать, как именно это реализовано в документации API. Например, вместо отправки
{ stream: true }в теле запроса, вам может понадобиться или указать это в заголовках, или использовать другой подход.Заключение
Таким образом, указание
stream: trueв теле запроса не повлияет на способ декодирования данных. Для корректного декодирования потоковых данных следует использоватьdecoder.decode(value, { stream: true }), а для запроса необходимо знать, как именно API ожидает получение параметров для активации потокового режима. Всегда проверяйте документацию используемого API, чтобы убедиться в правильном использовании параметров и заголовков. -
- User
тогда к чему был этот пример ? fetch("https://dummyjson.com/products/", { method: 'GET', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', }, // Предполагаем, что API поддерживает этот параметр body: JSON.stringify({ stream: true }) }) .then(response => { if (!response.ok) { throw new Error("Ошибка:", response.status, response.statusText); } const reader = response.body.getReader(); const decoder = new TextDecoder("utf-8"); let result = "";
function readPartly() { return reader.read().then(({ done, value }) => { if (done) { console.log("Чтение завершено"); console.log(JSON.parse(result)); return; } else { const chunk = decoder.decode(value, { stream: true }); result += chunk; return readPartly(); } }); } return readPartly();}) .catch(error => { console.log("Ошибка:", error.message); });
- Assistant
Давайте разберем, как правильно использовать потоковую передачу данных и к чему был приведён этот пример.
Цель Примера
Пример, который вы привели, предназначен для демонстрации того, как можно читать данные из потокового ответа API с использованием интерфейса
ReadableStream. Однако использованиеbodyс параметром{ stream: true }в запросе к API может быть некорректным, в зависимости от того, как API ожидает получать параметры.-
Работа с потоками: Этот код читает данные, возвращаемые в ответе API, потоком, используя метод
getReader(), что является правильным подходом для работы с потоковой передачей данных. -
Декодирование частей: Декодирует полученные байты, используя
TextDecoder, и аккумулирует строку, чтобы в конечном итоге вывести весь полученный результат.
Что нужно уточнить
-
Передача параметров: В большинстве API параметр
streamне передается черезbodyдля запроса, а должно указываться в заголовках, либо в URL, в зависимости от конкретной реализации API. Следовательно, указание{ stream: true }в теле запроса не будет иметь эффекта (по крайней мере, в стандартной практике API). -
Стандартное использование: Обычно, если API поддерживает потоковую передачу, вам нужно будет обращаться с ним так, как требует конкретный сервер. Например, если API поддерживает потоковые ответы, это может быть реализовано через специальные заголовки или параметры.
Как это правильно использовать
Вот пример правильного использования потокового ответа с
fetch:fetch("https://dummyjson.com/products/", { method: 'GET', headers: { 'Content-Type': 'application/json', 'Accept': 'application/json', // Вставьте необходимые заголовки для активации потокового ответа, если требуется } }) .then(response => { if (!response.ok) { throw new Error("Ошибка:", response.status, response.statusText); } const reader = response.body.getReader(); const decoder = new TextDecoder("utf-8"); let result = ""; function readPartly() { return reader.read().then(({ done, value }) => { if (done) { console.log("Чтение завершено"); console.log(JSON.parse(result)); // Обрабатываем полученные данные return; } else { const chunk = decoder.decode(value, { stream: true }); result += chunk; // Накопление данных return readPartly(); // Чтение следующего чунка } }); } return readPartly(); }) .catch(error => { console.log("Ошибка:", error.message); });Заключение
Итог: пример является демонстрацией того, как правильно обрабатывать потоковые данные в JavaScript с использованием
fetch, а именно чтение потоков и декодирование данных. Однако важный момент заключается в том, что параметры для потокового режима (если они нужны) должны использоваться корректно, в зависимости от требований вашего API, и должны проверяться в документации API.Если API не поддерживает потоковую передачу данных через
body, просто уберите эту часть и используйте остальные части кода для чтения данных из потока, которые возвращаются непосредственно в ответе. -
- User
а почему мы не используем .json, вместо JSON.parse(), это же все еще обработка промиса, а промису доступен этот метод ?
- Assistant
Проблема заключается в том, что метод
.json()присоединен к объектуResponse, который возвращается от методаfetch(), и он ожидает, что тело ответа будет представлено в формате JSON. Однако, когда вы используете потоковую передачу сReadableStream, как в вашем примере, вы уже читаете и обрабатываете данные вручную с помощьюReadableStreamDefaultReaderиTextDecoder, и именно поэтому мы не используем метод.json().Разница между
response.json()иJSON.parse()-
response.json():- Этот метод читает тело ответа, декодирует его в текст и парсит как JSON.
- Он возвращает промис, который разрешается с объектом JavaScript, представляющим JSON-данные. Метод
response.json()неприемлем, если вы сначала обрабатываете поток данных вручную, как в вашем примере.
Пример использования
response.json():fetch("https://dummyjson.com/products/") .then(response => { if (!response.ok) throw new Error("Ошибка: " + response.status); return response.json(); // Читает и парсит JSON }) .then(data => { console.log(data); // Теперь это уже JavaScript-объект }) .catch(error => { console.log("Ошибка:", error.message); }); -
JSON.parse():- Это метод встроенного объекта JavaScript
JSON, который принимает строку JSON и представляет её как объект JavaScript. - Мы используем этот метод, когда получаем данные в виде строки и хотим преобразовать их в объект. В вашем примере данные уже были собраны в текстовый блок в переменной
result, поэтому нам нужно парсить её с помощьюJSON.parse(result).
Пример использования
JSON.parse():let result = '{"key": "value"}'; // это строка JSON let data = JSON.parse(result); // преобразуем в объект console.log(data.key); // "value" - Это метод встроенного объекта JavaScript
Почему мы не используем
.json()в вашем примере?В вашем примере вы используете потоки данных, читая их по частям с помощью
ReadableStream, а затем собираете всё в одну строкуresult. После завершения чтения вы используетеJSON.parse(result), чтобы преобразовать собранные данные из строки в объект JavaScript. Вы не используете.json(), потому что вы обрабатываете данные в потоке вручную, а не получаете целиком ответ с помощьюfetch().Если бы вы использовали только
fetch()и не работали с потоками, то можно было бы использоватьresponse.json().Пример корректного использования потокового ответа
Если бы вы читали потоковые данные, как и в вашем примере:
fetch("https://dummyjson.com/products/") .then(response => { if (!response.ok) { throw new Error("Ошибка:", response.status, response.statusText); } const reader = response.body.getReader(); const decoder = new TextDecoder("utf-8"); let result = ""; function readPartly() { return reader.read().then(({ done, value }) => { if (done) { console.log("Чтение завершено"); console.log(JSON.parse(result)); // Парсим результат после завершения чтения return; } else { const chunk = decoder.decode(value, { stream: true }); result += chunk; // Накопление данных return readPartly(); // Чтение следующего чунка } }); } return readPartly(); }) .catch(error => { console.log("Ошибка:", error.message); });Заключение
Таким образом, обе функции
response.json()иJSON.parse()выполняют схожие задачи, но в разных контекстах:- Используйте
response.json(), когда имеет дело с полным ответом JSON. - Используйте
JSON.parse(), когда у вас уже есть строка JSON, которую нужно преобразовать в объект.
В вашем случае вы выбрали правильный способ обработки потоковых данных.
-
- User
{ done, value } в наших примерах это был набор ?
- Assistant
Да, в контексте вашего примера
{ done, value }относится к объекту, который возвращается методомread()у объектаReadableStreamDefaultReader. Давайте подробнее разберем, что означаютdoneиvalue.Объект, возвращаемый методом
read()Метод
read()возвращает промис, который разрешается с объектом, содержащим два свойства:-
done:- Это булевый (boolean) флаг. Если он равен
true, это означает, что поток данных завершен, и больше данных не будет. - Если
doneравноfalse, это означает, что есть еще доступные данные в потоке.
- Это булевый (boolean) флаг. Если он равен
-
value:- Это часть данных, которая была прочитана из потока. Это может быть объект или массив, в зависимости от того, как вы настраиваете поток на сервере.
- В в случае работы с текстом, как в вашем коде,
valueбудет содержатьUint8Array, представляющий байты данных, которые были получены.
Пример
Вот пример, как это выглядит в вашем коде:
function readPartly() { return reader.read().then(({ done, value }) => { // Здесь done и value if (done) { console.log("Чтение завершено"); console.log(JSON.parse(result)); // Обрабатываем конечный результат return; // Завершаем выполнение функции } else { const chunk = decoder.decode(value, { stream: true }); result += chunk; // Накопление данных return readPartly(); // Рекурсивно продолжаем чтение } }); }Что это значит в вашем контексте
- Каждый раз, когда
readPartlyвызывается, он пытается прочитать следующую часть данных из потока. - Если данные еще доступны (
doneравноfalse), вы декодируете их с помощьюTextDecoderи добавляете к результату. - Если данные закончились (
doneравноtrue), вы выводите накопленные данные.
Таким образом, в вашем примере
{ done, value }— это действительно набор, который представляет собой состояние считывателя потока:doneпоказывает, закончились ли данные, аvalueсодержит данные, которые были прочитаны на текущем этапе. Это позволяет вам эффективно обрабатывать данные по частям без необходимости дожидаться загрузки всего ответа целиком. -