interpolación de cadenas

En programación informática , la interpolación de cadenas (o interpolación de variables , sustitución de variables o expansión de variables ) es el proceso de evaluar una cadena literal que contiene uno o más marcadores de posición , obteniendo un resultado en el que los marcadores de posición se reemplazan con sus valores correspondientes. Es una forma de procesamiento de plantillas simple ^{[ 1 ]} o, en términos formales, una forma de cuasi-citación (o interpretación de sustitución lógica ). El marcador de posición puede ser un nombre de variable o, en algunos lenguajes, una expresión arbitraria; en ambos casos, se evalúa en el contexto actual .

La interpolación de cadenas es una alternativa a la construcción de una cadena mediante concatenación , que requiere entrecomillar y descomillar repetidamente; ^{[ 2 ]} o sustituir en una cadena de formato printf , donde la variable está lejos de donde se usa. Considere este ejemplo en Ruby :

manzanas = 4 puts "Tengo #{ manzanas } manzanas." # interpolación de cadena puts "Tengo " + String ( manzanas ) + " manzanas." # concatenación de cadena puts "Tengo %d manzanas." % manzanas # formato de cadena

Normalmente se ofrecen dos tipos de expresiones literales: una con interpolación habilitada y otra sin ella. Las cadenas no interpoladas también pueden escapar secuencias , en cuyo caso se denominan cadenas sin formato , aunque en otros casos esto es independiente, lo que da lugar a tres clases de cadenas sin formato, cadenas no interpoladas (pero con escape) y cadenas interpoladas (y con escape). Por ejemplo, en los shells de Unix, las cadenas entre comillas simples son sin formato, mientras que las cadenas entre comillas dobles están interpoladas. Los marcadores de posición suelen representarse mediante un símbolo simple o con nombre (normalmente $o %), por ejemplo $appleso %apples, o con llaves, por ejemplo {apples}, a veces ambos, por ejemplo ${apples}. En algunos casos, se pueden usar especificadores de formato adicionales (como en printf), por ejemplo {apples:3}, y en algunos casos los propios especificadores de formato pueden interpolarse, por ejemplo {apples:width}. La expansión de la cadena suele ocurrir en tiempo de ejecución .

La compatibilidad de los lenguajes con la interpolación de cadenas varía considerablemente. Algunos lenguajes no ofrecen interpolación de cadenas, sino que utilizan concatenación, funciones de formato simples o bibliotecas de plantillas. La interpolación de cadenas es común en muchos lenguajes de programación que utilizan intensivamente representaciones de datos en formato de cadena , como Apache Groovy , Julia , Kotlin , Perl , PHP , Python , Ruby , Scala , Swift , Tcl y la mayoría de los intérpretes de comandos de Unix .

Algoritmos

Existen dos tipos principales de algoritmos de expansión de variables para la interpolación de variables : ^{[ 3 ]}

Reemplazar y expandir marcadores de posición : crear una nueva cadena a partir de la original mediante operaciones de búsqueda y reemplazo. Buscar la referencia a la variable (marcador de posición) y reemplazarla con su valor. Este algoritmo no ofrece ninguna estrategia de caché.
Dividir y unir cadenas : divide la cadena en un array, lo fusiona con el array de valores correspondiente y, a continuación, une los elementos mediante concatenación. La cadena dividida se puede almacenar en caché para su posterior reutilización.

Problemas de seguridad

La interpolación de cadenas, al igual que la concatenación de cadenas, puede generar problemas de seguridad. Si los datos de entrada del usuario no se escapan o filtran correctamente, el sistema quedará expuesto a ataques de inyección SQL , inyección de scripts , inyección de entidades externas XML (XXE) y secuencias de comandos entre sitios (XSS). ^{[ 4 ]}

Un ejemplo de inyección SQL:

consulta = " "SELECTx,y,zFROMTableWHEREid='$id'

Si $idse reemplaza con " "'; DELETEFROMTable;SELECT*FROMTableWHEREid=' , ejecutar esta consulta borrará todos los datos en Table.

Ejemplos

ABAP

DATOS ( manzanas ) = 4. ESCRIBIR | Tengo { manzanas } manzanas | .

El resultado será:

Tengo 4 manzanas

Intento

manzanas = 4 echo "Tengo $manzanas manzanas" # o echo "Tengo ${ manzanas } manzanas"

El resultado será:

Tengo 4 manzanas

Abucheo

manzanas = 4 print ( "Tengo $(manzanas) manzanas" ) # o print ( "Tengo {0} manzanas" % manzanas )

El resultado será:

Tengo 4 manzanas

do

C no tiene cadenas interpoladas, pero se pueden aproximar usando sprintf()from <stdio.h>.

#include <stdio.h>#define BUFFER_SIZE 100int main () { char sentence [ BUFFER_SIZE ];int edad = 20 ; float altura = 5.9 ; char nombre [] = "Alicia" ;sprintf ( sentencia , "Mi nombre es %s y tengo %d años, y mido %.1f pies de altura." , nombre , edad , altura ); printf ( sentencia ); // imprime: // Mi nombre es Alice, tengo 20 años y mido 5.9 pies de altura. }

C++

Aunque las cadenas interpoladas no existen en C++, se pueden aproximar utilizando std::formatfunciones std::print.

importar std ;usando std :: string ;int main () { int manzanas = 4 ; int plátanos = 3 ;std :: println ( "Tengo {} manzanas" , manzanas ); // especificadores de formato std :: println ( "Tengo {0} frutas, de las cuales hay {1} manzanas y {2} plátanos" , manzanas + plátanos , manzanas , plátanos ); // especificar la posición explícitamente// usando std::format(): string name = "John Doe" ; int age = 20 ; string greeting = std :: format ( "Hola, {}! Tienes {} años." , name , age ); }

Se han propuesto cadenas interpoladas para su inclusión en C++, basadas en las f-cadenas de Python. La propuesta incorpora características previamente incluidas de std::format, basadas en {fmt} . ^{[ 5 ]} En esta propuesta, cada f-cadena se transforma en una llamada a una nueva función, std::make_formatted_string().

importar std ;using std :: string ; using std :: string_view ;int calcular ( int x ) { // ... }string represent ( string_view prefix , int bits ) { return f "{prefix}-{__LINE__}: se obtuvo {calculate(bits)} para {bits:#06x}" ; }void display ( string_view prefix , int bits ) { std :: print ( f "{prefix}-{__LINE__}: se obtuvo {calculate(bits)} para {bits:#06x}" ); }

DO#

entero manzanas = 4 ; entero plátanos = 3 ;Console.WriteLine ( $ "Tengo {apples} manzanas" ) ; Console.WriteLine ( $ "Tengo {apples + bananas} frutas" ) ;

^{[ 6 ]}

El resultado será:

Tengo 4 manzanas. Tengo 7 frutas.

Esto también se puede hacer usando String.Format().

entero manzanas = 4 ; entero plátanos = 3 ;Console.WriteLine ( String.Format ( " Tengo {0} manzanas y {1} plátanos. " , manzanas , plátanos ) ) ;

Lenguaje de marcado ColdFusion

Sintaxis de scripts del lenguaje de marcado ColdFusion (CFML):

manzanas = 4 ; writeOutput ( "Tengo #manzanas# manzanas" );

Sintaxis de etiquetas:

<cfset apples = 4 > <cfoutput> Tengo # manzanas # manzanas </cfoutput>

El resultado será:

Tengo 4 manzanas

CoffeeScript

manzanas = 4 console.log "Tengo # { manzanas } manzanas "

El resultado será:

Tengo 4 manzanas

Dardo

int manzanas = 4 , plátanos = 3 ; print ( 'Tengo $ manzanas manzanas .' ); print ( 'Tengo ${ manzanas + plátanos } frutas.' );

El resultado será:

Tengo 4 manzanas. Tengo 7 frutas.

Ir

Si bien ha habido algunas propuestas para la interpolación de cadenas (que han sido rechazadas), ^{[ 7 ]}^{[ 8 ]}^{[ 9 ]} A partir de 2025Go no tiene cadenas interpoladas.

Sin embargo, se pueden aproximar utilizando fmt.Sprintf().

importar "fmt"func main ( ) { // El mensaje es de tipo cadena mensaje := fmt.Sprintf ( " Mi nombre es %s y tengo %d años." , "John Doe " , 20 ) fmt.Println ( mensaje ) }

Genial

En Groovy, las cadenas interpoladas se conocen como GStrings: ^{[ 10 ]}

def calidad = "superhéroe" edad final = 52 def oración = "Un desarrollador es una $calidad si es ${edad <= 42 ? 'joven' : 'experimentado'}" println oración

El resultado será:

Un desarrollador es un superhéroe si tiene experiencia.

Haxe

var manzanas = 4 ; var plátanos = 3 ; trace ( 'Tengo $ manzanas manzanas.' ); trace ( 'Tengo ${ manzanas + plátanos } frutas.' );

La salida será: ^{[ 11 ]}

Tengo 4 manzanas. Tengo 7 frutas.

Java

Java incluyó la interpolación de cadenas como una función de vista previa en Java 21 y Java 22. Se podía usar directamente la constante STR de java.lang.StringTemplate .

paquete org.wikipedia.examples ;enum Etapa { PRUEBA , CONTROL DE CALIDAD , PRODUCCIÓN }Registro Despliegue ( UUID imagen , Etapa etapa ) {}public class Example { public static void main ( String [] args ) { Deploy deploy = new Deploy ( UUID . randomUUID (), Stage . TEST ) STR . "Instalando \{deploy.image()} en Stage \{deploy.stage()} ..." Deploy deploy = new Deploy ( UUID . randomUUID (), Stage . PRODUCTION ) STR . "Instalando \{deploy.image()} en Stage \{deploy.stage()} ..." } }

Fueron eliminados en Java 23 debido a problemas de diseño. ^{[ 12 ]}

De lo contrario, las cadenas interpoladas se pueden aproximar utilizando el String.format()método.

paquete org.wikipedia.examples ;public class Example { public static void main ( String [] args ) { int apples = 3 ; int bananas = 4 ;String sentence = String.format ( " Tengo %d frutas, de las cuales %d son manzanas y %d son plátanos . " , manzanas + plátanos , manzanas , plátanos ) ; System.out.println ( sentence ) ;String nombre = " John Doe" ; int edad = 20 ; System.out.printf ( " Mi nombre es %s y tengo %d años." , nombre , edad ) ; } }

JavaScript/TypeScript

JavaScript y TypeScript , a partir del estándar ECMAScript 2015 (ES6), admiten la interpolación de cadenas mediante comillas invertidas ``. Esta característica se denomina literales de plantilla . ^{[ 13 ]} Aquí hay un ejemplo:

const manzanas : número = 4 ; const plátanos : número = 3 ; console.log ( ` Tengo ${ manzanas } manzanas` ); console.log ( ` Tengo $ { manzanas + plátanos } frutas` ) ;

El resultado será:

Tengo 4 manzanas. Tengo 7 frutas.

Las plantillas literales también se pueden usar para cadenas de varias líneas:

console.log ( ` Esta es la primera línea de texto. Esta es la segunda línea de texto.` );

El resultado será:

Esta es la primera línea de texto. Esta es la segunda línea de texto.

Julia

manzanas = 4 plátanos = 3 print ( "Tengo $manzanas manzanas y $ plátanos plátanos, lo que hace un total de $ ( manzanas + plátanos ) piezas de fruta." )

El resultado será:

Tengo 4 manzanas y 3 plátanos, lo que hace un total de 7 piezas de fruta.

Kotlin

fun main () { val quality : String = "superhero" val apples : Int = 4 val bananas : Int = 3 val sentence : String = "Un desarrollador es $ quality . Tengo ${ apples + bananas } fruits" println ( sentence ) }

El resultado será:

Un desarrollador es un superhéroe. Tengo 7 frutas.

Nemerle

def manzanas = 4 ; def plátanos = 3 ; Console.WriteLine ( $ "Tengo $manzanas manzanas." ) ; Console.WriteLine ( $ "Tengo $(manzanas + plátanos) fruta . " ) ;

También admite funciones de formato avanzadas, como:

def fruta = [ "manzana" , "plátano" ]; Console . WriteLine ( $ < #Tengo ..$(fruta; "\n"; f => f + "s")#>);

El resultado será:

manzanas plátanos

Nim

Nim proporciona interpolación de cadenas mediante el módulo strutils. Las cadenas literales formateadas, inspiradas en las cadenas F de Python, se proporcionan mediante el módulo strformat. La macro strformat verifica que la cadena de formato esté bien formada y tenga el tipo correcto, y luego se expande al código fuente de Nim en tiempo de compilación.

import strutils , strformat var apples = 4 var bananas = 3 echo "Tengo $1 manzanas" .format ( apples ) echo fmt"Tengo {apples} manzanas" echo fmt"Tengo {apples + bananas} frutas "# Formato de eco multilínea " " Tengo { manzanas } manzanas" ""# Depurar el formato echo fmt"Tengo {apples=} manzanas"# Caracteres personalizados para abrir y cerrar echo fmt ( "Tengo (manzanas) {manzanas}" , '(' , ')' )# Barra invertida dentro de la cadena literal formateada echo fmt" "" { " sí \ no" } "" "

El resultado será:

Tengo 4 manzanas Tengo 4 manzanas Tengo 7 frutas Tengo 4 manzanas Tengo manzanas = 4 manzanas Tengo 4 {manzanas} sí abierto

Nada

let numberOfApples = "4" ; in "Tengo ${ numberOfApples } manzanas"

El resultado será:

Tengo 4 manzanas

Parasailing

const Manzanas := 4 const Plátanos := 3 Println ( "Tengo `(Manzanas) manzanas.\n" ) Println ( "Tengo `(Manzanas+Plátanos) frutas.\n" )

El resultado será:

Tengo 4 manzanas. Tengo 7 frutas.

Perl

mis $manzanas = 4 ; mis $plátanos = 3 ; print "Tengo $manzanas manzanas.\n" ; print "Tengo @{[$manzanas+$plátanos]} fruta.\n" ; # Utiliza la interpolación de matrices de Perl (@).

El resultado será:

Tengo 4 manzanas. Tengo 7 frutas.

PHP

<?php $apples = 5 ; $bananas = 3 ; echo "Hay $apples manzanas y $bananas plátanos. \n " ; echo "Tengo { $apples } manzanas y { $bananas } plátanos." ;

El resultado será:

Hay 5 manzanas y 3 plátanos. Tengo 5 manzanas y 3 plátanos.

Pitón

Python admite la interpolación de cadenas desde la versión 3.6, denominada "literales de cadena formateados" o "cadenas f". ^{[ 14 ]}^{[ 15 ]}^{[ 16 ]} Dicho literal comienza con un fo Fantes de la comilla de apertura y utiliza llaves para los marcadores de posición:

manzanas : int = 4 plátanos : int = 3print ( f "Tengo { manzanas } manzanas y { plátanos } plátanos" )

El resultado será:

Tengo 4 manzanas y 3 plátanos.

Rubí/Cristal

manzanas = 4 puts "Tengo #{ manzanas } manzanas" # Formato de cadena aplicaciones para comparación: puts "Tengo %s manzanas" % manzanas puts "Tengo %{a} manzanas" % { a : manzanas }

El resultado será:

Tengo 4 manzanas

Óxido

Rust no tiene interpolación de cadenas general, pero proporciona una funcionalidad similar a través de macros, denominadas "Identificadores capturados en cadenas de formato", introducidas en la versión 1.58.0, publicada el 13 de enero de 2022. ^{[ 17 ]}

Rust proporciona formato mediante el módulo std::fmt , con el que se interactúa a través de varias macros como format!, write ! y print!. Estas macros se convierten en código fuente de Rust en tiempo de compilación, donde cada argumento interactúa con un formateador . El formateador admite parámetros posicionales , parámetros con nombre , tipos de argumentos , la definición de diversas características de formato y la captura de identificadores del entorno.

fn main () { let ( manzanas , plátanos ): ( i32 , i32 ) = ( 4 , 3 ); // println! captura los identificadores al formatear: la cadena en sí no es interpolada por Rust. println! ( "Hay {manzanas} manzanas y {plátanos} plátanos." );// alternativamente, con format!(): let sentence : String = format! ( "Hay {0} manzanas y {1} plátanos." , manzanas , plátanos ); println! ( sentence ); }

El resultado será:

Hay 4 manzanas y 3 plátanos.

Scala

Scala 2.10+ proporciona una funcionalidad general para permitir el procesamiento arbitrario de literales de cadena y admite la interpolación de cadenas mediante los interpoladores incluidos s. fTambién es posible escribir interpoladores personalizados o sobrescribir los estándar.

El finterpolador es una macro del compilador que reescribe una cadena de formato con expresiones incrustadas como una invocación de String.format. Verifica que la cadena de formato esté bien formada y tenga el tipo correcto.

Los interpoladores estándar

La interpolación de cadenas de Scala 2.10+ permite incrustar referencias a variables directamente en literales de cadena procesados. Aquí hay un ejemplo:

val manzanas = 4 val plátanos = 3 //antes de Scala 2.10 printf ( "Tengo %d manzanas\n" , manzanas ) println ( "Tengo %d manzanas" format manzanas ) //Scala 2.10+ println ( s"Tengo $ manzanas manzanas" ) println ( s"Tengo ${ manzanas + plátanos } frutas" ) println ( f"Tengo $ manzanas %d manzanas" )

El resultado será:

Tengo 4 manzanas

Scitar (tiscript)

En Sciter, cualquier función cuyo nombre comience con $ se considera una función de interpolación, por lo que la interpolación es personalizable y sensible al contexto:

var manzanas = 4 var plátanos = 3 var domElement = ...;domElement . $content ( < p > Tengo { manzanas } manzanas < / p>); domElement . $append ( < p > Tengo { manzanas + plátanos } frutas < / p>);

Dónde

domElement . $content ( < p > Tengo { manzanas } manzanas < / p>);

se compila a esto:

domElement . html = "<p>Tengo " + apples . toHtmlString () + " manzanas</p>" ;

Snobol

manzanas = 4 ; plátanos = 3 Salida = "Tengo " manzanas " manzanas." Salida = "Tengo " ( manzanas + plátanos ) " frutas."

El resultado será:

Tengo 4 manzanas. Tengo 7 frutas.

Rápido

En Swift , se puede crear un nuevo valor de cadena a partir de una combinación de constantes, variables, literales y expresiones incluyendo sus valores dentro de un literal de cadena. ^{[ 18 ]} Cada elemento insertado en el literal de cadena se envuelve entre un par de paréntesis, precedidos por una barra invertida.

let manzanas = 4 print ( "Tengo \ (manzanas) manzanas" )

El resultado será:

Tengo 4 manzanas

Tcl

El lenguaje de comandos de herramientas siempre ha admitido la interpolación de cadenas en todas las cadenas delimitadas por comillas.

establecer manzanas 4 puts "Tengo $manzanas manzanas."

El resultado será:

Tengo 4 manzanas.

Para formatear realmente los valores, y no simplemente reemplazarlos, existe una función de formato.

establecer manzanas 4 puts [ formato "Tengo %d manzanas." $manzanas ]

Visual Basic .NET

A partir de Visual Basic 14, Visual Basic admite la interpolación de cadenas. ^{[ 19 ]}

nombre = " Tom " Console.WriteLine ( $ "Hola, {nombre}" )

El resultado será:

Hola, Tom

Véase también

Notas

↑ " Imponiendo una estricta separación modelo-vista en los motores de plantillas ", T. Parr (2004), conferencia WWW2004.
↑ "Interpolación en Perl" . perlmeme.org . Hardware Haven. 12 de diciembre de 2024. Consultado el 30 de junio de 2026. Esto es mucho más ordenado que el uso repetido del operador de concatenación..
↑ "smallest-template-system/Simplest algorithms" , un tutorial en línea para sistemas de plantillas de marcadores de posición.
↑ "Interpolación segura de cadenas" . google-caja.googlecode.com . Archivado del original el 19/10/2012.
↑ Bengt Gustafsson, Victor Zverovich (14 de octubre de 2024). "Interpolación de cadenas - p3412r0" (PDF) . open-std.org . Grupo de Trabajo 21.
↑ "Cadenas de caracteres - Guía de programación en C#" . 15 de marzo de 2024.
↑ "propuesta: Go 2: interpolación de cadenas #34174" . GitHub .
↑ "propuesta: Go 2: interpolación de cadenas que se evalúa a cadena y lista de expresiones #50554" . GitHub .
↑ "propuesta: especificación: agregar interpolación de cadena simple similar a Swift · Problema #57616 · golang/go" . GitHub . Recuperado el 19-05-2025 .
↑ "El lenguaje de programación Apache Groovy - Sintaxis" . groovy-lang.org . Consultado el 20 de junio de 2021 .
↑ "Haxe - Manual - Interpolación de cadenas" . Haxe - El kit de herramientas multiplataforma . Consultado el 12 de septiembre de 2017 .
↑ "Cambios significativos en el JDK" .
↑ "Literales de plantilla (cadenas de plantilla) - JavaScript | MDN" . 31 de mayo de 2024.
↑ "Tutorial de Python: 7.1.1. Literales de cadena formateados" .
↑ "Referencia del lenguaje Python: 2.4.3. Literales de cadena formateados" .
↑ "PEP 498 -- Interpolación de cadenas literales" .
↑ "Anuncio de Rust 1.58.0: Identificadores capturados en cadenas de formato" . 13 de enero de 2022.
↑ "Cadenas y caracteres: el lenguaje de programación Swift (Swift 5.5)" . docs.swift.org . Consultado el 20 de junio de 2021 .
↑ KathleenDollard. "Cadenas interpoladas - Visual Basic" . docs.microsoft.com . Consultado el 20 de junio de 2021 .

[1] " Imponiendo una estricta separación modelo-vista en los motores de plantillas ", T. Parr (2004), conferencia WWW2004.

[2] "Interpolación en Perl" . perlmeme.org . Hardware Haven. 12 de diciembre de 2024. Consultado el 30 de junio de 2026. Esto es mucho más ordenado que el uso repetido del operador de concatenación..

[3] "smallest-template-system/Simplest algorithms" , un tutorial en línea para sistemas de plantillas de marcadores de posición.

[4] "Interpolación segura de cadenas" . google-caja.googlecode.com . Archivado del original el 19/10/2012.

[5] Bengt Gustafsson, Victor Zverovich (14 de octubre de 2024). "Interpolación de cadenas - p3412r0" (PDF) . open-std.org . Grupo de Trabajo 21.

[6] "Cadenas de caracteres - Guía de programación en C#" . 15 de marzo de 2024.

[7] "propuesta: Go 2: interpolación de cadenas #34174" . GitHub .

[8] "propuesta: Go 2: interpolación de cadenas que se evalúa a cadena y lista de expresiones #50554" . GitHub .

[9] "propuesta: especificación: agregar interpolación de cadena simple similar a Swift · Problema #57616 · golang/go" . GitHub . Recuperado el 19-05-2025 .

[10] "El lenguaje de programación Apache Groovy - Sintaxis" . groovy-lang.org . Consultado el 20 de junio de 2021 .

[11] "Haxe - Manual - Interpolación de cadenas" . Haxe - El kit de herramientas multiplataforma . Consultado el 12 de septiembre de 2017 .

[12] "Cambios significativos en el JDK" .

[13] "Literales de plantilla (cadenas de plantilla) - JavaScript | MDN" . 31 de mayo de 2024.

[14] "Tutorial de Python: 7.1.1. Literales de cadena formateados" .

[15] "Referencia del lenguaje Python: 2.4.3. Literales de cadena formateados" .

[16] "PEP 498 -- Interpolación de cadenas literales" .

[17] "Anuncio de Rust 1.58.0: Identificadores capturados en cadenas de formato" . 13 de enero de 2022.

[18] "Cadenas y caracteres: el lenguaje de programación Swift (Swift 5.5)" . docs.swift.org . Consultado el 20 de junio de 2021 .

[19] KathleenDollard. "Cadenas interpoladas - Visual Basic" . docs.microsoft.com . Consultado el 20 de junio de 2021 .

[ 1 ]

[ 2 ]

[ 3 ]

[ 4 ]

[ 5 ]

[ 6 ]

[ 7 ]

[ 8 ]

[ 9 ]

[ 10 ]

[ 11 ]

[ 12 ]

[ 13 ]

[ 14 ]

[ 15 ]

[ 16 ]

[ 17 ]

[ 18 ]

[ 19 ]

Algoritmos

Problemas de seguridad

Ejemplos

ABAP

Intento

Abucheo

do

C++

DO#

Lenguaje de marcado ColdFusion

CoffeeScript

Dardo

Ir

Genial

Haxe

Java

JavaScript/TypeScript

Julia

Kotlin

Nemerle

Nim

Nada

Parasailing

Perl

PHP

Pitón

Rubí/Cristal

Óxido

Scala

Los interpoladores estándar

Scitar (tiscript)

Snobol

Rápido

Tcl

Visual Basic .NET

Véase también

Notas

Articulos relacionados