Przejdź do głównej treści
Polski— Wybierz język
Menu

Integracja z przeglądarką i najlepsze praktyki

Lekcja 14 z 14 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Wdrażanie TTS w aplikacji internetowej
  2. Obsługa kodeków w przeglądarce
  3. Problem z AudioContext w Safari
  4. Adresy URL obiektów Blob i wycieki pamięci
  5. Najlepsze praktyki produkcyjne
  6. Kluczowe wnioski
  7. Sprawdź swoją wiedzę

Zaktualizowano 3 listopada 2026 r. na podstawie strony Text to Speech od xAI: walidacja po stronie serwera wykorzystuje obecny limit 60 000 znaków na żądanie. Źródło: Text to Speech.

Wdrażanie TTS w aplikacji internetowej

Integracja TTS w przeglądarce wiąże się ze specyficznymi wyzwaniami: obsługą kodeków, zarządzaniem pamięcią, osobliwościami Safari i wydajnością. Ta ostatnia lekcja dostarczy Ci wszystkiego, czego potrzebujesz do solidnej integracji produkcyjnej.

Obsługa kodeków w przeglądarce

Nie każda przeglądarka obsługuje każdy format audio. Wybierz odpowiedni kodek dla swojej grupy odbiorców:

KodekChromeFirefoxSafariEdgeZalecany
MP3TakTakTakTakTak
WAVTakTakTakTakTak
Surowy PCMNieNieNieNieNie
mulaw/alawNieNieNieNieNie

Prosta zasada: używaj w przeglądarce MP3 lub WAV. PCM, mulaw i alaw są przeznaczone dla aplikacji serwerowych i telefonii, a nie do odtwarzania w sieci.

// Żądanie MP3 z API (poprzez Twój backend)
const response = await fetch("/api/tts", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    text: "Hello from the browser.",
    voice_id: "eve",
    language: "en"
    // Nie trzeba ustawiać output_format: MP3 jest domyślny
  })
});

Problem z AudioContext w Safari

Safari nakłada ograniczenie bezpieczeństwa: AudioContext można utworzyć tylko wewnątrz obsługi zdarzenia wywołanego przez użytkownika (kliknięcie, naciśnięcie klawisza, dotknięcie). Jeśli spróbujesz utworzyć AudioContext podczas ładowania strony, Safari po cichu to zablokuje.

Błędne podejście

// NIE działa w Safari
const audioContext = new AudioContext(); // Zablokowane!

async function playTTS() {
  const audio = await fetchTTS("Hello");
  // audioContext jest zawieszony w Safari...
}

Właściwe podejście

let audioContext = null;

// Utwórz AudioContext przy pierwszym kliknięciu użytkownika
document.getElementById("play-btn").addEventListener("click", async () => {
  if (!audioContext) {
    audioContext = new AudioContext();
  }

  // Wznów, jeśli zawieszony
  if (audioContext.state === "suspended") {
    await audioContext.resume();
  }

  const response = await fetch("/api/tts", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      text: "Hello from Safari.",
      voice_id: "eve",
      language: "en"
    })
  });

  const arrayBuffer = await response.arrayBuffer();
  const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);

  const source = audioContext.createBufferSource();
  source.buffer = audioBuffer;
  source.connect(audioContext.destination);
  source.start(0);
});

To podejście działa w każdej przeglądarce, nie tylko w Safari. Jest to dobra, uniwersalna praktyka.

Adresy URL obiektów Blob i wycieki pamięci

Gdy tworzysz adresy URL obiektów Blob do odtwarzania dźwięku, każdy URL zużywa pamięć, dopóki jej jawnie nie zwolnisz. Bez czyszczenia Twoja aplikacja będzie cierpieć na wycieki pamięci.

Problem

// Każde wywołanie tworzy URL obiektu Blob, który nigdy nie jest zwalniany
async function playTTS(text) {
  const response = await fetch("/api/tts", { ... });
  const blob = await response.blob();
  const url = URL.createObjectURL(blob); // Wyciek pamięci!
  const audio = new Audio(url);
  audio.play();
}

Rozwiązanie

async function playTTS(text) {
  const response = await fetch("/api/tts", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ text, voice_id: "eve", language: "en" })
  });

  const blob = await response.blob();
  const url = URL.createObjectURL(blob);
  const audio = new Audio(url);

  // Zwolnij pamięć po zakończeniu odtwarzania
  audio.addEventListener("ended", () => {
    URL.revokeObjectURL(url);
  });

  // Zwolnij również w przypadku błędu
  audio.addEventListener("error", () => {
    URL.revokeObjectURL(url);
  });

  audio.play();
}

W aplikacjach generujących dużo dźwięku przechowuj listę aktywnych adresów URL i czyść ją okresowo:

class AudioManager {
  constructor() {
    this.activeUrls = new Set();
  }

  async play(text) {
    const response = await fetch("/api/tts", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ text, voice_id: "eve", language: "en" })
    });

    const blob = await response.blob();
    const url = URL.createObjectURL(blob);
    this.activeUrls.add(url);

    const audio = new Audio(url);
    audio.addEventListener("ended", () => this.release(url));
    audio.addEventListener("error", () => this.release(url));
    audio.play();
    return audio;
  }

  release(url) {
    URL.revokeObjectURL(url);
    this.activeUrls.delete(url);
  }

  cleanup() {
    // Zwolnij każdy aktywny URL
    for (const url of this.activeUrls) {
      URL.revokeObjectURL(url);
    }
    this.activeUrls.clear();
  }
}

Najlepsze praktyki produkcyjne

Limitowanie częstotliwości żądań (Rate limiting) po stronie backendu

Chroń swój backend przed nadużyciami, limitując liczbę żądań na użytkownika:

const rateLimit = require("express-rate-limit");

const ttsLimiter = rateLimit({
  windowMs: 60 * 1000, // 1 minuta
  max: 10, // 10 żądań na minutę na adres IP
  message: { error: "Too many TTS requests" }
});

app.post("/api/tts", ttsLimiter, async (req, res) => {
  // ... proxy do API xAI
});

Walidacja tekstu

Zweryfikuj i oczyść tekst przed wysłaniem go do API:

function validateTTSInput(text) {
  if (!text || typeof text !== "string") {
    throw new Error("Text is required");
  }
  if (text.length > 60000) {
    throw new Error("Text too long (60,000 characters max)");
  }
  // Usuń znaki kontrolne
  return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
}

Buforowanie audio

Dla powtarzających się tekstów (powitania, standardowe instrukcje) buforuj wygenerowane audio:

const audioCache = new Map();

async function getTTS(text, voice, language) {
  const cacheKey = `${text}:${voice}:${language}`;

  if (audioCache.has(cacheKey)) {
    return audioCache.get(cacheKey);
  }

  const audio = await fetchTTSFromAPI(text, voice, language);
  audioCache.set(cacheKey, audio);
  return audio;
}

Wstępne generowanie

Dla treści znanych z góry (e-learning, IVR) generuj pliki audio z wyprzedzeniem podczas budowania aplikacji, a nie w locie.

Kluczowe wnioski

  • Używaj w przeglądarce MP3 lub WAV, nigdy PCM/mulaw/alaw
  • W Safari twórz AudioContext wewnątrz obsługi zdarzenia wywołanego przez użytkownika
  • Zawsze zwalniaj adresy URL obiektów Blob za pomocą URL.revokeObjectURL() po użyciu
  • Dodaj limitowanie częstotliwości żądań do swojego proxy backendowego
  • Waliduj i czyść tekst przed wysłaniem go do API
  • Buforuj audio dla powtarzających się tekstów, aby oszczędzać wywołania API
  • Generuj audio z wyprzedzeniem dla treści znanych z góry

Sprawdź swoją wiedzę

Synteza mowy xAI: od pierwszego wywołania po potok strumieniowania.

1. Jak działa podstawowe wywołanie TTS?

Odpowiedź: Jest to żądanie POST do /v1/tts z tekstem, wybranym głosem (który możesz列出 poprzez API) i parametrami. Odpowiedzią jest audio, rozliczane według объема zsyntetyzowanego materiału.

2. Co pozwalają robić tagi ekspresyjne?

Odpowiedź: Kontrolować mowę bezpośrednio w tekście: tagi inline i otaczające dla intonacji, pauz i akcentów, które można łączyć, aby uzyskać naturalne, ukierunkowane czytanie.

3. Kiedy należy przejść na TTS WebSocket?

Odpowiedź: W czasie rzeczywistym: tekst wychodzi jako strumień, a audio wraca ciągle. Jest to fundament potoków LLM → TTS, gdzie głos zaczyna się, zanim generowanie zostanie zakończone.

4. Jak zabezpieczyć integrację z przeglądarką?

Odpowiedź: Nigdy nie umieszczaj klucza API po stronie klienta: przeglądarka komunikuje się przez Twój serwer lub używa krótkotrwałych poświadczeń, a Ty prawidłowo obsługujesz błędy HTTP.

5. Jak wygląda kompletny potok produkcyjny?

Odpowiedź: Strumieniowy LLM → segmenty tekstu → TTS WebSocket → odtwarzanie audio. Każde ogniwo działa strumieniowo, więc postrzegane opóźnienie znika, a najlepsze praktyki z tego kursu domykają całość.

Tagi dla ekspresji, WebSocket dla czasu rzeczywistego, Twój serwer dla sekretów: Twoje aplikacje są gotowe, by przemówić.