[Mis experiencias con Javascript] Desestructuración y su equivalente Deconstruction en .NET (C#)


Si eres desarrollor de .NET (C#) y estas comenzando con Angular, Node, etc., Javascript al fin y al cabo. O, por el contrario, eres desarrollador de Javascript y estas comenzando con .NET (C#), quizás pueda interesarte este post. Sigue leyendo.

En el comienzo de mi recorrido por Angular y NodeJS hay algunas cosas del lenguaje Javascript que me han llamado mucho la atención, principalmente al tratar de comparalas con C#. Otro punto que me resulta un poco molesto (quizás debido a mi corta experiencia en Javascript), es el cambio constante entre ambos lenguajes. Esto me obliga a recurrir a Google para refrescar ciertas partes de las sintaxis.

En este post vamos a ver como a pesar de lo anterior, la sintaxis de ambos se parece y posiblemente sea únicamente una sensación mía. No pretendo profundizar en todos sus casos posibles, ni tampoco entrar en los pros y contras de cada una . La intención es simplemente compartir mi experiencia para tratar de acercar/acortar este camino.

Desestructuración/Deconstrucción

La desesctructuración, aparece en ECMAScript 6, y es la vía por la cual se pueden extraer valores de objetos y/o arrays en variables. En mi opinión, permite un código mas legible en muchos casos. Veamos el siguiente ejemplo de desestructuración de arrays.

const foo = ['one', 'two', 'three'];
const [red, yellow, green] = foo;
console.log(`${red}, ${yellow}, ${green}`);

Dado este código Javascript, ¿Cuál es el equivalente en C#? Pues, lo más parecido es la deconstrucción de arrays y objetos, que aparece a partir de la versión C# 7.0 (mediante el uso de tuplas). Por lo que tenemos un código equivalente como el siguiente:

var foo = ("one", "two", "three");
var (red, yellow, green) = foo;
Console.WriteLine($"{red}, {yellow}, {green}");

La primera sentencia, la obtenemos definiendo una tupla en lugar de un array. Si bien, para conseguir una sintaxis mas parecida haciendo uso de un array, necesitamos recurrir a la implementación de métodos “Deconstruct“.

public static class IEnumerableExtension
 {
     public static void Deconstruct(this IEnumerable seq,
         out T first,
         out IEnumerable rest)
     {
         first = seq.FirstOrDefault();
         rest = seq.Skip(1);
     }
 public static void Deconstruct<T>(this IEnumerable<T> seq,
     out T first,
     out T second,
     out IEnumerable<T> rest)
         => (first, (second, rest)) = seq;
 public static void Deconstruct<T>(this IEnumerable<T> seq,     
    out T first,     
    out T second,     
    out T third,     
    out IEnumerable<T> rest)         
        => (first, second, (third, rest)) = seq;
 }

Una vez implementada la clase anterior, logramos la sintaxis esperada, y ya sí, haciendo uso de un array.

var foo = new[] { "one", "two", "three" };
var (red, yellow, green) = foo;
Console.WriteLine($"{red}, {yellow}, {green}");

Por otro lado, la desestructuración de objetos en Javascript podemos verla con este ejemplo:

const foo= {
     id: 42,
     is_verified: true
 };
 const {id, is_verified} = foo;
 console.log(`${id} - ${is_verified}); // 42 - true

Para el caso de C#, (aunque podríamos usar tuplas directamente o incluso hacer uso de objetos anonímos), lo haremos, sin embargo, mediante un objeto tipado. Para ello implementaremos una clase Foo, con sus métodos “Deconstruct” pertinentes:

public class Foo
{
     public int Id { get; set; }
     public bool Is_Verified { get; set; }

     public void Deconstruct(out int id) {     id = Id; }
     public void Deconstruct(out int id, out bool is_verified) 
     { 
         id = Id;
         is_verified = Is_Verified; }
    }
}

Así, podemos escribir nuevamente el ejemplo, con la sintaxis que buscamos:

var foo = new Foo
 {
     Id = 42,
     Is_Verified = true
 };
 var (Id, Is_Verified) = foo;
 Console.WriteLine($"{Id} - {Is_Verified}");

Por último, durante la desestructuración/deconstrucción, se pueden omitir algunos valores, en concreto, para nuestro ejemplo, omitiremos la propiedad “is_verified”/”Is_Verified”:

var { id } = foo;
console.log(`${id}`); // 42

En C# lo resolvemos haciendo uso del guión bajo (“_”), que precisamente nos permitie optar por esta omisión o descarte:

var (Id, _) = foo;
Console.WriteLine($"{Id}");

Nota: Adicionalmente, como hemos visto en los ejemplos anteriores, y en particular para las sentencias “console.log(…) / Console.Writeline(…)“, la interpolación de cadenas, es otra característica muy interesante y util. ¡Tan parecidas en ambos lenguajes que tengo poco más que añadir 😀!

Como siempre, espero que esta entrada sea de utilidad.

Un saludo y happy Javascript & CSharp coding….

Referencias

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión /  Cambiar )

Google photo

Estás comentando usando tu cuenta de Google. Cerrar sesión /  Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión /  Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión /  Cambiar )

Conectando a %s

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios .