Hey there! I’ve hit this exact VS Code warning a few times myself—super head-scratching when you can’t find official docs spelling out the deprecation right away. Let me break down what’s going on here and share the solid alternatives I’ve used in my projects.

First, a quick context check: btoa() and atob() aren’t officially removed from browsers yet, but VS Code’s warning (usually from TypeScript type definitions or ESLint rules) is flagging them because they have major limitations—most notably, they can’t handle Unicode characters (like Chinese, emojis, or accented letters) without extra work. Modern standards offer better, more reliable APIs, hence the nudge to switch.

Here are the best alternatives depending on your environment:

Browser Environments #

1. TextEncoder + TextDecoder (Unicode-Friendly, Synchronous) #

This is the modern standard way to handle base64 encoding/decoding for any string, including Unicode. It fixes the core limitation of btoa()/atob():

// Encode string to Base64
function encodeToBase64(str) {
  const encoder = new TextEncoder();
  const uint8Array = encoder.encode(str);
  return btoa(String.fromCharCode(...uint8Array));
}

// Decode Base64 back to string
function decodeFromBase64(base64Str) {
  const binaryStr = atob(base64Str);
  const uint8Array = new Uint8Array(binaryStr.length);
  for (let i = 0; i < binaryStr.length; i++) {
    uint8Array[i] = binaryStr.charCodeAt(i);
  }
  const decoder = new TextDecoder();
  return decoder.decode(uint8Array);
}

We still use btoa()/atob() here under the hood, but only to handle raw binary data from the encoder—so you avoid Unicode-related errors entirely.

2. Blob + FileReader (Asynchronous) #

If you don’t mind async operations, this is another robust browser-native option:

// Async encode
async function encodeToBase64Async(str) {
  const blob = new Blob([str], { type: 'text/plain' });
  return new Promise((resolve) => {
    const reader = new FileReader();
    reader.onload = () => resolve(reader.result.split(',')[1]);
    reader.readAsDataURL(blob);
  });
}

// Async decode
async function decodeFromBase64Async(base64Str) {
  const blob = await fetch(`data:text/plain;base64,${base64Str}`).then(res => res.blob());
  return new Promise((resolve) => {
    const reader = new FileReader();
    reader.onload = () => resolve(reader.result);
    reader.readAsText(blob);
  });
}

Node.js Environments #

Node has a built-in Buffer API that’s perfect for this—no extra dependencies needed, and it handles Unicode seamlessly:

// Encode
const encoded = Buffer.from('Your string (including Unicode!)', 'utf8').toString('base64');

// Decode
const decoded = Buffer.from(encoded, 'base64').toString('utf8');

Cross-Environment (Browser + Node) #

If your project runs in both environments, a lightweight library like base64-js can save you from writing compatibility code:

// Install first: npm install base64-js
import base64js from 'base64-js';

// Encode
const uint8Array = new TextEncoder().encode('Cross-environment string');
const encoded = base64js.fromByteArray(uint8Array);

// Decode
const uint8ArrayDecoded = base64js.toByteArray(encoded);
const decoded = new TextDecoder().decode(uint8ArrayDecoded);

To wrap up: The VS Code warning is less about the functions being removed immediately, and more about pushing you to use more reliable, standard APIs that handle all character types. Any of the above options will serve you better long-term than sticking with btoa()/atob().

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