El problema con el código de OP era que el ejemplo que estaban siguiendo tenía algunas convenciones que permitían a los usuarios tener plantillas en el texto de su mensaje indicado por {} .

Por ejemplo, en 'Member Count: {guild.memberCount}' , {guild.memberCount} se reemplazaría para darnos 'Member Count: 123' o algo así.

Pero la función para reemplazar estos marcadores de posición faltaba en su origen.

Por lo tanto, una función de análisis como:

 const replacePlaceholder = (template, placeholders) => { //if there is no placeholder, return. if (template.indexOf('{') === -1) return template; //get the string inside the {} const toReplace = template.slice( template.indexOf('{'), template.indexOf('}') + 1 ); //keep replacing until { character is not found. return replacePlaceholder( template.replace(toReplace, placeholders[toReplace]), placeholders ); };

era necesario. En este contexto, también tiene sentido por qué OP estaba usando:

 const embed = new Discord.MessageEmbed() .setTitle(`${(cardTitle, placeholders)}`), .setDescription(`${(cardText, placeholders)}`), .setFooter(`${(cardSubtitle, placeholders)}`),

Originalmente eran llamadas a funciones como:

 const embed = new Discord.MessageEmbed() .setTitle(`${replacePlaceholder(cardTitle, placeholders)}`), .setDescription(`${replacePlaceholder(cardText, placeholders)}`), .setFooter(`${replacePlaceholder(cardSubtitle, placeholders)}`),

Usemos expresiones regulares para hacer la comparación por nosotros. Debido a que sus claves tienen caracteres que tienen un significado especial en las expresiones regulares ( { y } ), necesitaremos escaparlos.

Extraído de escape-string-regexp :

 const escapeRegex = (string) => string .replace(/[|\\{}()[\]^$+*?.]/g, '\\$&') .replace(/-/g, '\\x2d');

Luego, escribamos una función que tome una plantilla y los marcadores de posición. Deberíamos crear una expresión regular a partir del marcador de posición como esta:

 const regex = new RegExp("(" + Object.keys(placeholders).map(escapeRegex).join("|") + ")", "g");

Para cada clave en el objeto de marcadores de posición, escapamos de los caracteres especiales y lo unimos todo con | , envolviendo el resultado entre paréntesis. Luego le damos la bandera g (global) para que nos proporcione todas las coincidencias.

Para usted, esta expresión regular generada se vería así:

 /(\{client.avatar\}|\{client.username\}|...|\{guild.id\})/g

Por último, queremos usar esta expresión regular y reemplazar todas las apariciones de marcadores de posición con su valor correspondiente.

 return template.replace(regex, (_, match) => placeholders[match]);

Así que el código completo se ve así:

 const escapeRegex = (string) => string .replace(/[|\\{}()[\]^$+*?.]/g, '\\$&') .replace(/-/g, '\\x2d'); function fill(template, placeholders) { const regex = new RegExp("(" + Object.keys(placeholders).map(escapeRegex).join("|") + ")", "g"); return template.replace(regex, (_, match) => placeholders[match]); }

Ejemplo de uso:

 fill("My name is {name}!", { "{name}": "Kelly" }); // "My name is Kelly!"

Puede probarlo aquí , simplemente haga clic en el enlace y presione "Ejecutar". A la derecha verás la salida.

¿Por qué no usamos algo como esto?

 template .replaceAll("{client.avatar}", placeholders["{client.avatar}"]) .replaceAll("{client.username}", placeholders["{client.username}"]) .replaceAll(...) // ...

Bueno, antes que nada, eso no es realmente SECO, ¿verdad? Podrías ayudar con eso usando un bucle:

 for (const [place, value] of Object.entries(placeholders)) { template = template.replaceAll(place, value); }

¡Pero luego hay una trampa! ¿Qué pasa si el valor de un marcador de posición contiene otro marcador de posición? ¡Entonces reemplazaría el nuevo marcador de posición con un nuevo valor! Esto podría conducir a un comportamiento inesperado, por lo que sugerí usar esta solución en su lugar; reemplace todas las coincidencias a la vez, evitando que esto suceda.

Marcadores de posición:

 {bar} => i love {foo} {foo} => 42

Y entonces:

 say {bar} say i love {foo} say i love 42

¡UH oh!