# ¿Qué es un wrapper en programación?

La palabra inglesa *wrapper* designa un embalaje o envoltorio. En el contexto del *software*, este término hace referencia a programas o códigos que rodean otros componentes de programa. Los *wrappers* pueden utilizarse por diversos motivos: a menudo se usan para mejorar la **compatibilidad** o **interoperabilidad** entre diferentes estructuras de software o para poder representar algo a nivel visual, p.ej., los *wrappers* HTML o CSS. Pueden ser *wrappers* diferentes componentes de software, productos de *software* independientes, arquitecturas de *software*, clases de programación orientada a objetos o *frameworks*.

Si dentro de un programa hay que usar funciones o bloques de programas en otro lenguaje de programación, estos elementos pueden “envolverse”. El programa principal **solo se comunica con el *wrapper*** y este se encarga de transmitir los comandos al programa envuelto y de devolver los resultados al programa principal. El *wrapper* es el único componente del proceso que está en contacto directo con ambos elementos de software.

En el mundo de la programación y el desarrollo de *software*, los *wrappers* cuentan con una infinidad de usos. En los siguientes ejemplos, te mostramos qué es un *wrapper*, cómo funciona exactamente y qué tareas asume.

## Wrappers como traductores de entradas de usuarios

Los formularios de los programas o **aplicaciones web esperan entradas** que el programa sea capaz de procesar. En los programas de origen estadounidense, por ejemplo, se sobrentiende que los números con decimales llevan puntos en lugar de comas y miden en pies y pulgadas. A la hora de usar este tipo de componentes de *software* en aplicaciones propias, no siempre existe la posibilidad de adaptarlos a las costumbres nacionales de cada país y, en consecuencia, casi siempre se obtienen resultados erróneos o incluso, errores de programa.

En estos casos, el *wrapper* es la solución perfecta. Así, el formulario no transmitirá las entradas directamente al programa externo, sino que las enviará al *wrapper*. Este se encargará de valorar las entradas y traducirlas en entradas válidas para el programa externo sin necesidad de modificación.

## Wrappers para acceder a bases de datos

Por norma general, las [bases de datos](https://www.ionos.com/es-us/digitalguide/hosting/cuestiones-tecnicas/bases-de-datos/ "Bases de datos") de diferentes fabricantes apenas pueden utilizarse conjuntamente debido a problemas de compatibilidad entre las diferentes tablas de datos, consultas o lenguajes de consulta. En estos casos, los *wrappers* también pueden ser de gran utilidad. Los *wrappers* de todo tipo tratan de reconocer las **inconsistencias existentes entre diferentes interfaces de *software*** y de rodearlas.

Un ejemplo clásico de un *wrapper* es la **Java Database Connectivity** (JDBC), una interfaz de bases de datos de la plataforma Oracle-Java. En su función de *wrapper*, la JDBC permite acceder a [bases de datos relacionales](https://www.ionos.com/es-us/digitalguide/hosting/cuestiones-tecnicas/bases-de-datos-relacionales/ "Bases de datos relacionales") de diferentes proveedores. La JDBC establece la conexión con las diferentes bases de datos a través de controladores especiales.

Las consultas SQL de los programas se dirigen exclusivamente a la JDBC y no a las bases de datos propias. La JDBC convierte las consultas al lenguaje de consulta empleado por la base de datos en cuestión y devuelve el resultado en un formato compatible con Java. De esta manera, el programa que realiza la consulta siempre obtiene los datos en un formato homogéneo, independientemente de la base de datos que emplee.

## Wrappers en la programación orientada a objetos

En la programación orientada a objetos, se usan diferentes **patrones estructurales** que funcionan siempre de la misma manera, sin importar el lenguaje de programación que se utilice. Los patrones de diseño, adaptador y decorador pertenecen a la categoría de patrones estructurales y se consideran *wrappers*.

Un **adaptador** envuelve a dos interfaces incompatibles entre diferentes clases. Al traducir una interfaz a la otra, las clases ya pueden volver a comunicarse entre sí. Esto es muy importante cuando queremos seguir usando clases o bibliotecas enteras de clases en proyectos nuevos. Estas bibliotecas usan interfaces estandarizadas y unívocas que no deben modificarse ya que deben ser compatibles con un gran número de programas. El *wrapper*, el adaptador en este caso, es el eslabón intermedio determinante para la comunicación.

Un **decorador** permite ampliar una clase con funciones adicionales sin modificarla. Para el objeto de programa consultante, el decorador presenta la misma interfaz que la clase original. Así, el objeto que lo consulta no requiere modificación alguna. En su función de *wrapper*, el decorador transmite las consultas a la clase. Las funciones nuevas, no incluidas en la clase, son procesadas directamente por el decorador. A continuación, este devuelve los resultados de manera que el objeto consultante los perciba como resultados de la clase decorada.

## Wrappers para diseñar documentos HTML

Es muy común usar *wrappers* en el (cambio del) diseño de páginas web [HTML](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/aprende-html-tutorial-para-principiantes/ "Aprende HTML: tutorial para principiantes") y [CSS](https://www.ionos.com/es-us/digitalguide/paginas-web/diseno-web/que-es-css-un-tutorial-con-lo-que-necesitas-saber/ "¿Qué es CSS?: un tutorial con lo que necesitas saber"). Sin *wrappers*, incluso los cambios más pequeños, por ejemplo, cambiar los espacios de los márgenes de una ventana del navegador, implicarían tener que modificar varias hojas de estilo y revisar al final que todas siguen siendo compatibles.

Es mucho más sencillo meter todo el contenido de la página en un **contenedor DIV**, tal y como muestra el siguiente ejemplo:

```none
<html>
    <head>
    ...
    </head>
    <body>
        <div class="wrapper">
        …
        </div>
        <div class="hash d-none" hidden>hash_8fd9f9776844d7cc3bfd62954f2611bb25866b38</div><script data-shy-copy-guard>(function(){var C=[0x00AD,0x200B,0x200C,0x200D,0x2060,0xFEFF];var s=function(t){for(var i=0;i<C.length;i++){t=t.split(String.fromCharCode(C[i])).join("");}return t;};document.addEventListener("copy",function(e){var sel=document.getSelection();if(!sel||sel.isCollapsed||!e.clipboardData){return;}e.clipboardData.setData("text/plain",s(sel.toString()));try{var d=document.createElement("div");d.appendChild(sel.getRangeAt(0).cloneContents());e.clipboardData.setData("text/html",s(d.innerHTML));}catch(x){}e.preventDefault();});})();</script></body>
</html>
```

En el contenedor *wrapper* se encuentra el contenido real de la página.

En el archivo CSS correspondiente se define el *wrapper* como hoja de estilo:

```none
body {
	margin: 0;
	padding: 0
}
.wrapper {
	width: 500px;
	margin: 25px auto;
}
```

En este ejemplo, se usa el parámetro *width:* para atribuir un ancho de 500 píxeles al contenedor. Los márgenes superior e inferior se fijan mediante el parámetro *margin:* a un valor de 25 píxeles. Los márgenes izquierdo y derecho derivan automáticamente del ancho de la ventana del navegador y el ancho del contenedor.

Basta con modificar el *wrapper* para modificar los márgenes laterales de la página sin necesidad de intervenir más en el código HTML o CSS.

## Wrappers TCP en sistemas Linux

El servicio en segundo plano *inetd* de [Linux](https://www.ionos.com/es-us/digitalguide/servidores/know-how/linux-una-alternativa-a-windows-de-bajo-coste/ "Linux: una alternativa a Windows de bajo coste") y otros sistemas operativos basados en [UNIX](https://www.ionos.com/es-us/digitalguide/servidores/know-how/unix-el-sistema-operativo-que-cambio-la-informatica/ "Unix: el sistema operativo que cambió la informática ") se ejecuta como ***wrapper* TCP**. El elemento *inetd* monitoriza *sockets* de red y acepta consultas de conexión. Un archivo de configuración determina los puertos que cabe tener en cuenta. Las consultas se evalúan y se inicia el servicio *inetd* indicado para cada puerto en el archivo de configuración. Normalmente estos programas suelen ser instancias Daemon ejecutadas en segundo plano.

Cuando la conexión finaliza, *inetd* vuelve a detener el servicio iniciado de forma automática. Al iniciar el servicio solo cuando es necesario, pueden ahorrarse muchos recursos del sistema en comparación con el inicio automático de servicios de red que, a menudo, ni siquiera hacen falta. El elemento *inetd* funciona como *wrapper* al que todos los programas dirigen sus consultas de red sin comunicarse directamente con los diferentes servicios.

Los wrappers [TCP](https://www.ionos.com/es-us/digitalguide/servidores/know-how/que-es-tcp-transport-control-protocol/ "Qué es TCP (Transport Control Protocol)") también pueden usarse para evitar accesos no deseados desde una red. En estos casos, *inetd* o un software especial de servidor consultan al *wrapper* TCP. Los hosts y ordenadores que deben aceptarse o rechazarse se registran en los archivos */etc/hosts.allow* y */etc/hosts.deny*.


This is a markdown version of: [https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/que-es-un-wrapper/](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/que-es-un-wrapper/) for AI/LLM consumption.