Um problema relativamente comum é remover os acentos de um texto, e como todo problema comum, basta uma busca rápida pela Internet para encontrar soluções como esta (por exemplo, em JavaScript):

var semAcentos = string.normalize('NFD').replace(/[\u0300-\u036f]/g, "");

Entre outras variações. Mas vc já parou pra pensar como e por que isso funciona?

Formas de Normalização Unicode

O Unicode define várias formas de normalização, e o NFD do código acima é uma delas (as outras são NFC, NFKC e NFKD). Para uma descrição mais detalhada, sugiro que leia aqui (e siga também os links indicados para se aprofundar ainda mais). Inclusive, os próximos parágrafos abaixo foram retirados/adaptados da resposta contida no link, com a devida permissão do autor, que no caso sou eu mesmo :-)

De forma bem resumida, alguns caracteres possuem mais de uma forma de serem representados. Por exemplo, o á (letra a com acento agudo), segundo o Unicode, pode ser representado de duas maneiras:

composta - como o code point U+00E1 (LATIN SMALL LETTER A WITH ACUTE) (á)
decomposta - como uma combinação de dois code points (nesta ordem):
- a letra "a" (sem acento): U+0061 (LATIN SMALL LETTER A)
- o acento agudo: U+0301 (COMBINING ACUTE ACCENT)

Code point é o valor numérico associado a cada caractere definido pelo Unicode - leia aqui para mais detalhes.

A primeira forma é chamada NFC (Canonical Composition), e a segunda, NFD (Canonical Decomposition). As duas formas acima são consideradas "canonicamente equivalentes", quando se trata de representar a letra a com acento agudo. Ou seja, são duas formas de se representar a mesma coisa.

O acento agudo (U+0301), neste caso, é um dos chamados combining diacritical marks (ou combining characters): caracteres que podem ser combinados com outros (como os acentos do português, por exemplo). Eles sempre aparecem depois do caractere ao qual se aplicam (no exemplo acima, ele aparece depois do a).

Visualmente, não há diferença, e tanto a forma NFC quanto a NFD são mostradas como "á". Somente ao "escovar os bits" e verificar os code points um a um é que podemos saber em qual forma está:

// transformar string em array de code points, mostrar o valor em hexadecimal
function codepoints(s) {
    return Array.from(s).map(c => c.codePointAt(0).toString(16));
}

// NFC, apenas um code point
console.log(codepoints('á')); // [ 'e1' ]

// NFD, dois code points
console.log(codepoints('á')); // [ '61', '301' ]

Ao testar o código acima, faça copy-paste de tudo. Se vc digitar na mão o á, provavelmente não vai funcionar porque - pela minha percepção - os editores de texto costumam dar preferência à forma NFC.

Enfim, por isso a forma ingênua e mais trabalhosa de remover acentos (fazer uma série de replace(/á/g, 'a'), replace(/é/g, 'e'), etc) nem sempre pode funcionar, pois se o primeiro argumento do replace está em uma forma e a string está em outra, nada será substituído:

function removeAcento(str) {
    // remove somente o acento do "a"
    return str.replace(/á/g, 'a');
}

// string em NFC, remove
console.log(removeAcento('á')); // a

// string em NFD, não remove
console.log(removeAcento('á')); // á

Quando normalizamos para NFD, o caractere acentuado é "separado" do acento. Depois, o replace remove os acentos, e o que sobra são as letras sem acentuação.

No caso, o intervalo [\u0300-\u036f] cobre vários caracteres, inclusive acentos que não são usados em português.

Se quiser ser mais específico e considerar apenas os acentos agudo, circunflexo, til e grave, poderia trocar para /[\u0300-\u0303]/g. Ou ainda /[\u0300-\u0303\u0327]/g para que remova também a cedilha (ou seja, ç seria trocado por c). E também daria para ser mais abrangente e considerar qualquer tipo de acento de qualquer idioma, usando /\p{M}/gu - o Unicode Property Escape \p{M} considera qualquer caractere que esteja nas categorias "Mark" (todas que começam com "M" desta lista), nos quais os acentos estão inclusos.

Se vc está mexendo somente com textos em português, não fará tanta diferença usar um ou outro, mas se tiverem outros idiomas envolvidos, verifique as diferentes opções para que incluam os acentos desejados.

Por fim, vale lembrar que as formas de normalização são definidas pelo Unicode e não são exclusividade do JavaScript. Muitas linguagens também possuem formas similares de obter o mesmo resultado. Por exemplo, em Python seria:

from unicodedata import normalize, combining

def remove_acentos(string):
    return ''.join(c for c in normalize('NFD', string) if not combining(c))

print(remove_acentos('sabiá')) # sabia

Em Java:

import java.text.Normalizer;

public class Exemplo {
    public static String removeAcentos(String str) {
        return Normalizer.normalize(str, Normalizer.Form.NFD).replaceAll("\\p{M}", "");
    }
}

E muitas outras também possuem suporte à normalização e formas de verificar se um caractere é combining e pode ser removido.

Removendo acentos (não só) em JavaScript (ou: Unicode e suas bizarrices)

Formas de Normalização Unicode