Literales de cadenas sin formato
Escriba texto multilínea y con muchas comillas de forma clara.
Literales de cadenas sin formato es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.
Literales de cadena sin formato
Un literal de cadena sin formato está delimitado por al menos tres comillas dobles. En su interior, los caracteres se interpretan literalmente y no se procesan secuencias de escape.
using System;
class Program {
static void Main() {
string s = """Hello "World"!""";
Console.WriteLine(s);
}
}Sin secuencias de escape
Las barras diagonales inversas son simples barras diagonales inversas dentro de una cadena sin formato, lo que resulta perfecto para rutas de archivos y patrones de expresiones regulares.
using System;
class Program {
static void Main() {
string path = """C:\Users\Ada\file.txt""";
Console.WriteLine(path);
}
}Inclusión de comillas
Como el delimitador consta de tres comillas o más, las comillas simples y dobles del interior no necesitan escaparse.
using System;
class Program {
static void Main() {
string json = """{"name": "Ada", "age": 30}""";
Console.WriteLine(json);
}
}Cadenas sin formato multilínea
Para contenido multilínea, coloque las comillas de apertura y cierre en líneas independientes. El texto que queda entre ellas se conserva.
using System;
class Program {
static void Main() {
string text = """
Line one
Line two
""";
Console.WriteLine(text);
}
}La sangría se elimina
En las cadenas sin formato multilínea, los espacios en blanco anteriores a las comillas de cierre establecen la sangría de referencia, que se elimina de todas las líneas.
using System;
class Program {
static void Main() {
string s = """
indented in source
but flush in output
""";
Console.WriteLine(s);
}
}Más comillas para evitar conflictos
Si el contenido contiene tres comillas, use cuatro o más en el delimitador para que la cadena no resulte ambigua.
using System;
class Program {
static void Main() {
string s = """"He said """quote""" today."""";
Console.WriteLine(s);
}
}Interpolación sin formato
Añada un signo de dólar como prefijo para usar cadenas interpoladas sin formato. El número de signos de dólar determina cuántas llaves deben iniciar una expresión.
using System;
class Program {
static void Main() {
string name = "Ada";
string s = $"""Hello, {name}!""";
Console.WriteLine(s);
}
}Dos signos de dólar para usar llaves literales
Con dos signos de dólar, las llaves simples son literales y las llaves dobles inician una expresión, algo práctico para las plantillas JSON.
using System;
class Program {
static void Main() {
string id = "42";
string s = $$"""{ "id": {{id}} }""";
Console.WriteLine(s);
}
}Más limpias que las cadenas verbatim
Las cadenas sin formato sustituyen muchos usos de la forma verbatim anterior y ofrecen un tratamiento más claro de las comillas y la sangría.
using System;
class Program {
static void Main() {
string sql = """
SELECT *
FROM Users
WHERE Active = 1
""";
Console.WriteLine(sql);
}
}Ideales para plantillas
Las cadenas sin formato permiten incluir JSON, XML, HTML o SQL de forma legible, porque no es necesario escapar nada de su contenido.
using System;
class Program {
static void Main() {
string html = """<a href="/home">Home</a>""";
Console.WriteLine(html);
}
}Cuándo usarlas
Use cadenas sin formato siempre que el texto contenga muchas comillas o barras diagonales inversas, o abarque varias líneas.
using System;
class Program {
static void Main() {
string regex = """\d{3}-\d{4}""";
Console.WriteLine(regex);
}
}Comprobación rápida
Compruebe cuánto entiende sobre los literales de cadena sin formato.
Resumen
Los literales de cadena sin formato usan tres comillas dobles o más e interpretan literalmente su contenido, sin secuencias de escape, por lo que son ideales para rutas, expresiones regulares, JSON y HTML. Las versiones multilínea conservan la disposición y eliminan la sangría de las comillas de cierre.
Añada más comillas cuando el contenido entre en conflicto con el delimitador y use signos de dólar como prefijo para la interpolación; los signos de dólar adicionales cambian la forma en que se interpretan las llaves.
Preguntas frecuentes
¿La lección «Literales de cadenas sin formato» es gratis?
Sí — el texto completo de «Literales de cadenas sin formato» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Literales de cadenas sin formato»?
Escriba texto multilínea y con muchas comillas de forma clara. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C# Academy?
No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Literales de cadenas sin formato»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C# Academy?
Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Conceptos básicos de interpolación de cadenas
- Formato compuesto con string.Format
- Especificadores de formato numérico y de fechas
- Literales de cadenas sin formato