Share
En esta serie, analizamos los lenguajes de tipo dinámico (o de tipo débil) y cómo su falta de tipificación fuerte puede tener un impacto positivo y negativo en nuestra programación..
Como se mencionó en la primera publicación, esta serie está dirigida específicamente a los principiantes o para aquellos que no tienen mucha experiencia con los lenguajes de tipificación débil. Es decir, si ha programado en lenguajes de tipo fuerte o de tipo débil y está familiarizado con el tipo de coerción y los inconvenientes que pueden ocurrir al realizar ciertas operaciones, es posible que esta serie no sea de su interés..
Por otro lado, si eres alguien que acaba de comenzar a escribir código o eres alguien que está ingresando a un lenguaje tipificado dinámicamente desde otro idioma, entonces esta serie está orientada específicamente hacia ti. En última instancia, el objetivo es definir el tipo de coerción, mostrar cómo funciona y luego examinar las trampas de la misma..
Según Wikipedia, la coacción se define de la siguiente manera:
En ciencias de la computación, la conversión de tipos, la conversión de tipos y la coerción son formas diferentes de, implícita o explícitamente, cambiar una entidad de un tipo de datos a otro.
O, quizás de una manera más simple, puede definir esto como la forma en que toma un tipo de datos y lo convierte en otro. La cosa es que hay una línea muy fina entre la conversión y la coacción..
Como regla general, tiendo a pensar en coerción cómo un intérprete o compilador trabaja para determinar qué tipo de comparación se está haciendo, mientras que conversión es un cambio explícito en el tipo que nosotros, como programadores, escribimos en nuestro código.
Veamos esto con más detalle..
Digamos, por ejemplo, que tienes una cadena llamada ejemplo y su valor es '5'. En los idiomas escritos de forma estática, puede escribir cast esto, tomar el valor de la cadena y convertirlo en un En t a través de una serie de métodos diferentes.
Supongamos que tenemos un Entero objeto con un parseInt método. El método acepta una cadena y devuelve el valor de la cadena en el tipo de datos enteros. El código para hacerlo puede verse algo como esto:
string ejemplo = '5'; Integer myInt = new Integer (); int intExample = myInt.parseInt (ejemplo); / * intExample ahora tiene el valor de 5 (no '5') * y el ejemplo aún se refiere a la cadena '5' * /
Por supuesto, la sintaxis variará de un idioma a otro, y habrá son otras formas de convertir un valor, pero esto le da una idea de cómo convertir explícitamente un tipo en otro.
Otra forma de hacer esto es usar un operador de conversión de tipo. Aunque la implementación de la operación varía de un idioma a otro, la mayoría de los programadores que han trabajado con lenguajes de estilo C probablemente lo reconocerán como algo similar a esto:
int myInt = (int) ejemplo;
En general, el tipo de conversión se realiza colocando el tipo al que desea convertir la variable entre paréntesis antes de la variable en sí. En el ejemplo anterior, myInt ahora contendrá 5, más bien que '5' y ejemplo todavía mantendrá '5'.
Como se dijo, esto es algo que normalmente se hace dentro del contexto de los lenguajes compilados.
Esto todavía deja la pregunta de cómo la coacción de tipo difiere de la conversión de tipo. Aunque coercion puede ocurre dentro de los lenguajes compilados, es más probable que lo veas dentro de los idiomas interpretados o en lenguajes de tipo dinámico.
Además, es más que probable que se produzca una coacción de tipo siempre que se realice una comparación entre objetos de diferentes tipos o cuando se realice una operación o evaluación con variables que tienen diferentes tipos..
Como ejemplo simple, digamos que en JavaScript tenemos dos variables - nombre de, iAge - dónde nombre de se refiere al nombre de una persona y iAge se refiere a la edad de una persona. Las variables, a modo de ejemplo, utilizan la notación húngara simplemente para indicar que una está almacenando una cadena y la otra está almacenando un número entero..
Tenga en cuenta que esto es no un argumento a favor o en contra de la notación húngara: es un tema para otra publicación. Se usa aquí para aclarar qué tipo de valor se almacena cada variable para que sea más fácil seguir el código.
Entonces vamos a seguir adelante y definiremos nuestras variables y sus valores:
var sName = 'John Doe'; var iAge = 32;
Ahora podemos ver algunos ejemplos de cómo funciona la coacción de tipos dentro del contexto de un lenguaje interpretado. Dos ejemplos de cómo funciona la coacción de tipo son los siguientes:
Echemos un vistazo a un ejemplo de cada uno:
/ ** * La comparación de un número con un valor booleano * dará como resultado el valor booleano * de 'falso'. * / var result = iAge == true; / ** * Las cadenas y números de concatenación * obligarán al número a una cadena. * * "John Doe tiene 32 años". * / var bio = sName + 'is' + iAge + 'years old.';
Estos ejemplos son relativamente simples. El primero tiene sentido ya que no hay forma de que un número pueda compararse con un valor booleano.
En el segundo ejemplo, observe que estamos tomando una cadena, concatenándola con otro conjunto de cadenas y también usamos el número en la operación de concatenación. En este caso, el número se convierte en una cadena y luego se concatena junto con el resto de las palabras.
Este es un tipo de coerción: cuando toma una variable de un tipo y convierte su valor en otro tipo cuando realiza una operación o evaluación.
La cosa es que ambos ejemplos son muy simplistas. Veamos algunos más para demostrar cómo funciona la coacción, al menos en JavaScript, al realizar operaciones de concatenación:
var uno, dos, resultado; // uno y dos se refieren a valores de cadena de '1' y '2' uno = '1'; dos = '2'; // el resultado contendrá la cadena '12'; resultado = uno + dos; // redefinir dos para igualar el número '2' dos = 2; // concatenar una cadena y un número da como resultado una cadena // el resultado contendrá '12'; resultado = uno + dos; // redefinir uno como un número uno = 1; // luego concatene (o suma) los dos valores // el resultado será 3 resultado = uno + dos;
Hay dos cosas importantes a tener en cuenta:
Accentsconagua
+ El operador está sobrecargado. Eso significa que cuando se trabaja con cadenas, se concatenan, pero cuando se trabaja con números, se suman.Para llevar el ejemplo un paso más allá, agreguemos una variable más, un conjunto de operaciones priorizadas y luego examinemos el resultado:
var uno, dos, arbol, resultado; uno = '1'; dos = 2; tres = 3; // el resultado es '123' resultado = uno + dos + tres; // el resultado es '15' resultado = uno + (dos + tres);
Aviso en el segundo ejemplo., dos y Tres son adicional juntos porque ambos son números y luego el resultado es concatenado con uno porque es una cuerda.
Anteriormente, mencionamos que hay un caso especial para números y valores booleanos, al menos en JavaScript. Y dado que ese es el lenguaje que hemos estado usando para examinar la coacción de tipos y como es un lenguaje que se usa con frecuencia en el desarrollo web moderno, echemos un vistazo.
En el caso de JavaScript, tenga en cuenta que 1 Se considera un valor "veraz" y 0 Se preocupa por ser un valor "falsey". Estas palabras se eligen como tales porque los valores pueden servir como números, pero también se evaluarán para cierto o falso al realizar una comparación.
Echemos un vistazo a algunos ejemplos básicos:
var bTrue, bFalse, iZero, iOne, resultado; bTrue = true; bFalse = falso; iZero = 0; iOne = 1; // el resultado mantiene el valor booleano del resultado falso = bTrue == iZero; // el resultado mantiene el valor booleano de verdadero resultado = bTrue == iOne; // el resultado mantiene el valor booleano del resultado falso = bFalse == iOne; // el resultado mantiene el valor booleano de true result = bFalse == iZero;
Observe que en los ejemplos anteriores, los valores numéricos son coaccionado en valores enteros por naturaleza de la comparación que se está realizando.
Pero, ¿qué pasa si vamos a comparar un valor booleano de cierto o falso a un valor de cadena de uno o cero?
var bTrue, bFalse, sTrue, sFalse, resultado; bTrue = true; bFalse = falso; sTrue = '1'; sFalse = '0'; // el resultado mantiene el resultado verdadero = bTrue == sTrue; // el resultado contiene el resultado falso = bTrue == sFalse; // el resultado es falso; result = bFalse == sTrue; // el resultado es verdadero resultado = bFalse == sFalse;
En este punto, las cosas pueden comenzar a ser realmente confusas porque estamos comparando un valor de cadena de un número que es 1 a un valor booleano de cierto y estamos obteniendo un resultado booleano, y el booleano es cierto.
¿Tener sentido? Vamos a echar un vistazo a esto con un poco más de detalle en el siguiente artículo, pero quería seguir adelante y presentar los conceptos básicos de esto primero..
Esto es cuando los idiomas escritos dinámicamente pueden comenzar a causar dolores de cabeza a los desarrolladores. Afortunadamente, hay formas en las que podemos escribir código que sea más estricto que lo que tenemos arriba y que produce resultados precisos.
Además, algunos lenguajes de tipo dinámico también contienen valores para indefinido y para nulo. Estos también mantienen valores "de verdad" y "falsey" que, a su vez, afectan la forma en que manejamos las comparaciones..
En el artículo final de la serie, vamos a echar un vistazo a cómo valores como indefinido y nulo compare con otros valores, así como entre sí, y eche un vistazo a algunas estrategias que podemos implementar que harán que nuestro código sea más resistente frente a la coacción de tipo incorrecto, y que lo haga más legible.
Si esta es su primera incursión en idiomas tipificados dinámicamente o coacción de tipo y tiene preguntas, comentarios o comentarios, no dude en dejar un comentario en el siguiente canal.!
