<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Marcos Alejandro on Medium]]></title>
        <description><![CDATA[Stories by Marcos Alejandro on Medium]]></description>
        <link>https://medium.com/@flutterman?source=rss-2abcfcac2310------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*-_ed_zKhyhksWvMu</url>
            <title>Stories by Marcos Alejandro on Medium</title>
            <link>https://medium.com/@flutterman?source=rss-2abcfcac2310------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 01:16:04 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@flutterman/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Widget de Layout: Container( );]]></title>
            <link>https://medium.com/@flutterman/widget-de-layout-container-440812251c62?source=rss-2abcfcac2310------2</link>
            <guid isPermaLink="false">https://medium.com/p/440812251c62</guid>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[dart]]></category>
            <dc:creator><![CDATA[Marcos Alejandro]]></dc:creator>
            <pubDate>Fri, 30 Nov 2018 16:02:13 GMT</pubDate>
            <atom:updated>2018-11-30T17:55:51.727Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong><em>Container</em></strong> es un widget básico, extremadamente útil para diseñar layouts. Permite contener (valga la redundancia) o envolver un widget hijo, asignado a su propiedad <strong>child</strong>.</blockquote><blockquote>Nos permite controlar numerosas propiedades como tamaño, color de fondo, padding, margin, border, etc. Y por supuesto la alineación de su widget hijo.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/569/1*5aHHW7p4msEVhHMWIhlIsg.png" /></figure><p>Cuando asignamos un widget a la propiedad <em>child </em>de nuestro Container, este lo envolverá ocupando el menor espacio posible. De lo contrario, ocupará todo el área disponible.</p><p>A continuación veamos a través de ejemplos, algunas de sus propiedades:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/431/1*jaEmKmfQnBb9Qr9pI59jNw.png" /><figcaption>Constructor</figcaption></figure><p><strong>Ejemplo 1: </strong>Un “caja” vacía. Aunque invisible, está ocupando la totalidad de su widget padre (en este caso, asignado al <em>body</em> de un <em>Scaffold</em>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dvu-WkYD7HDJuzDLgiuIkA.png" /></figure><p><strong>Ejemplo 2</strong>: Si le sumamos un color (azul intenso), ahora podemos apreciar el espacio que está ocupando nuestra “caja”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*EplTdoAvcJfE-mjUHiav0A.png" /></figure><p><strong>Ejemplo 3</strong>: Ahora es cuando las cosas se ponen más interesantes. Asignamos un widget a la propiedad <em>child</em>, y la “caja” lo envuelve ocupando el menor espacio posible en pantalla (Notar que el color cyan pertenece al <em>WidgetHijo</em>, tapando por completo el color <em>blue</em> de nuestro contenedor).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*Ugmy2Z5Z0qg9whdF6NN2nQ.png" /></figure><p><strong>Ejemplo 4</strong>: Agregamos un poco de margen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*Z24mNV11G1TU2KP1wjwUFA.png" /></figure><p><strong>Ejemplo 5</strong>: Y ya que estamos, le agregamos padding. Esto es, un espacio entre el borde del contenedor, y el borde del widget hijo. Ahora sí volvemos a ver el color azul de nuestra “caja”. A primera vista parecía un borde, pero no lo es.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*lXRCAevdG1kRTKFS0cgggg.png" /></figure><p><strong>Ejemplo 6:</strong> Algo fundamental es poder determinar cómo se alineará nuestro widget hijo dentro del contenedor. Los valores posibles son amplios y los analizaremos en detalle en otro artículo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*3vY0PLE2hRqKZsGufuiZmQ.png" /></figure><p><strong>Ejemplo 7</strong>: Necesitas que tenga una altura concreta?. Así de fácil:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*cEDsaQ7rtrnd563ep3BXhQ.png" /></figure><p><strong>Ejemplo 8</strong>: Y si necesitas especificar el ancho, es igual de fácil. Como te habrás dado cuenta, si solo asignamos un valor a <em>width, </em>el <em>height</em> será lo máximo posible, y viceversa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*NWiMftcAEgomAqolpGHPaw.png" /></figure><p><strong>Ejemplo 9</strong>: Probemos ahora asignando valores a ambas propiedades (ancho y alto). Ya podemos imaginar el resultado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*LYQ54aiP4j0bVFdzpFJSyQ.png" /></figure><p><strong>Ejemplo 10</strong>: Una propiedad interesante es <em>constraints</em>. Nos permite asignar valores mínimos y máximos, tanto para el ancho como para el alto del contenedor. Esto le dará algo más de flexibilidad, sin perder el control del espacio que ocupará. Así de fácil:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*M5Y8CNoUpAXR5XU7aJWf6w.png" /></figure><p><strong>Ejemplo 11</strong>: Llegamos así a la poderosa <em>decoration</em>. Esta propiedad merece un artículo a parte. Por lo pronto, nos conformaremos con saber que nos permitirá darle estilo a nuestra “caja”. Los posibilidades superarán rápidamente nuestra imaginación.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*ATawIgUzVduc-MIo0sZUSw.png" /></figure><p><strong>Ejemplo 12</strong>: Con<em> foregroundDecoration</em> podemos añadir una capa de estilos en primer plano a nuestro contenedor. Las posibilidades serán las mismas que con la propiedad <em>decoration</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*Sjp_ZyCgm41-n9h4StNs9w.png" /></figure><p>Ejemplo 13: Finalmente, la frutilla del postre. La propiedad transform será nuestra alidada a la hora de resolver complejos desafíos de diseño, o al implementar todo tipo de animaciones. Ampliaremos los valores posibles en otro artículo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*uIKE541vfNleTwQLnhmNww.png" /></figure><p><strong>Conclusión</strong>: <em>Container</em> es un widget lleno de posibilidades, y nos acompañará a todos lados. Y mientras más lo usemos, mejores amigos seremos de él.</p><p>Esto fue todo o casi todo por hoy, estimados flutternautas.</p><p><strong>Documentación oficial</strong>: <a href="https://docs.flutter.io/flutter/widgets/Container-class.html">https://docs.flutter.io/flutter/widgets/Container-class.html</a></p><h3>Cualquier duda, la comunidad es tu amiga:</h3><blockquote>Telegram: <a href="https://t.me/flutter_dart_spanish">https://t.me/flutter_dart_spanish</a> <br>Facebook: <a href="https://m.facebook.com/groups/flutter.dart.spanish">https://m.facebook.com/groups/flutter.dart.spanish</a><br>Slack: <a href="https://bit.ly/FlutterDevsEnEspanol">https://bit.ly/FlutterDevsEnEspanol</a><br>Twitter: <a href="https://twitter.com/esflutter">https://twitter.com/esflutter</a><br>Documentación: https://flutter-es.io</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=440812251c62" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dart 2: asincronía]]></title>
            <link>https://medium.com/@flutterman/dart-2-asincron%C3%ADa-b6ebf1faf2fa?source=rss-2abcfcac2310------2</link>
            <guid isPermaLink="false">https://medium.com/p/b6ebf1faf2fa</guid>
            <category><![CDATA[dart]]></category>
            <category><![CDATA[flutter]]></category>
            <dc:creator><![CDATA[Marcos Alejandro]]></dc:creator>
            <pubDate>Thu, 16 Aug 2018 22:28:12 GMT</pubDate>
            <atom:updated>2018-08-16T22:28:12.394Z</atom:updated>
            <content:encoded><![CDATA[<p>Las librerías de Dart están llenas de funciones que devuelven objetos <strong>Future</strong> o <strong>Stream</strong>. Estas funciones son asíncronas. Las keywords <strong>async</strong> y <strong>await</strong> nos permitirán escribir código asíncrono con un aspecto síncrono.</p><h4>Manejo de Futures</h4><p>Cuando necesitamos el resultado de un Future completado, tenemos dos opciones:</p><ul><li>Usar async / await.</li><li>Usar la Future API</li></ul><p>Para usar <strong>await</strong>, el código debe estar en una función <strong>async</strong>:</p><pre><strong>Future</strong> checkVersion() <strong>async</strong> {<br>  var version = <strong>await</strong> lookUpVersion();<br>  // Do something with version<br>}</pre><p>Utilizamos <strong>try</strong>, <strong>catch</strong> y <strong>finally</strong> para manejar errores y mantener un código limpio usando <strong>await</strong>.</p><pre><strong>try</strong> {<br>  version = <strong>await</strong> lookUpVersion();<br>} <strong>catch</strong> (e) {<br>  // React to inability to look up the version<br>}</pre><p>Podemos utilizar <strong>await</strong> múltiples veces en una función <strong>async</strong>. El siguiente código espera tres veces los resultados de las funciones:</p><pre>var entrypoint = <strong>await</strong> findEntrypoint();<br>var exitCode = <strong>await</strong> runExecutable(entrypoint, args);<br><strong>await</strong> flushThenExit(exitCode);</pre><p>En la expresión <strong>await</strong>, el valor de la expresión es usualmente un <strong>Future</strong>; si no lo es, es automáticamente envuelto en un <strong>Future</strong>. Este objeto <strong>Future</strong> indica una promesa de retornar un objeto. El valor de la expresión <strong>await</strong> es ese objeto envuelto. La expresión <strong>await</strong> hace que la ejecución se detenga hasta que ese objeto este disponible.</p><p>Si obtenemos un error en tiempo de compilación al usar <strong>await</strong>, verificar que <strong>await</strong> esté en una función <strong>async</strong>. Por ejemplo, para usar <strong>await</strong> en la función <strong>main()</strong>, el cuerpo debe estar marcado como <strong>async</strong>:</p><pre><strong>Future</strong> main() <strong>async</strong> {<br>  checkVersion();<br>  print(&#39;In main: version is ${await lookUpVersion()}&#39;);<br>}</pre><h4>Declaración de funciones async</h4><p>Una función async es una función cuyo cuerpo está marcado con el modificador async. Agregar esta keyword hace que devuelva un Future.</p><pre>// La siguiente función  sincrónica retorna un String<br>String lookUpVersion() =&gt; &#39;1.0.0&#39;;</pre><pre>// Si la hacemos async, retorna un Future<br>Future&lt;String&gt; lookUpVersion() async =&gt; &#39;1.0.0&#39;;</pre><p>Si la función no devuelve un valor útil, definamos el tipo de retorno <strong>Future&lt;void&gt;</strong>.</p><h4>Manejandro Streams</h4><p>Cuando necesitamos obtener valores de un Stream, podemos:</p><ul><li>Utilizar <strong>async</strong> y un bucle <strong>for</strong> con <strong>await</strong>.</li><li>Utilizar la API de Stream.</li></ul><p>Antes de usar <strong>await for</strong>, verificar que realmente mejore la claridad del código y que necesitemos esperar todos los resultados de la transmisión. Normalmente no deberíamos usa <strong>await for</strong> para escuchar eventos de la UI.</p><pre>await for (varOrType identifier in expression) {<br>  // Se ejecuta cada vez que el stream emite un valor.<br>}</pre><p>El valor de la expresión debe tener un tipo <strong>Stream</strong>. Para dejar de escuchar el stream podemos usar <strong>break</strong> o <strong>return</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b6ebf1faf2fa" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dart 2: enums]]></title>
            <link>https://medium.com/@flutterman/dart-2-enums-92e56d8c5edc?source=rss-2abcfcac2310------2</link>
            <guid isPermaLink="false">https://medium.com/p/92e56d8c5edc</guid>
            <category><![CDATA[dart]]></category>
            <category><![CDATA[flutter]]></category>
            <dc:creator><![CDATA[Marcos Alejandro]]></dc:creator>
            <pubDate>Thu, 16 Aug 2018 16:36:57 GMT</pubDate>
            <atom:updated>2018-08-16T16:36:57.561Z</atom:updated>
            <content:encoded><![CDATA[<h4>Tipos enumerados</h4><p>A menudo conocidos como enums, son un tipo especial de clase utilizada para representar un número fijo de valores constantes.</p><h4><strong>Uso de enums</strong></h4><p>Cada valor en un enum tiene un <strong>index getter</strong>, que devuelve la posición del valor en la declaración. El primer valor tiene indice 0.</p><pre>enum Color { red, green, blue }</pre><p>Para obtener una lista de todos los valores de un <strong>enum</strong>, usamos <strong>values</strong>.</p><pre>List&lt;Color&gt; <strong>colors</strong> = Color.values;<br>assert(colors[2] == Color.blue);</pre><p>Podemos usar enums en las sentencias <strong>switch</strong>:</p><pre>var aColor = Color.blue;<br><br><strong>switch</strong> (aColor) {<br>  <strong>case</strong> Color.red:<br>    print(&#39;Red as roses!&#39;);<br>    break;<br>  <strong>case</strong> Color.green:<br>    print(&#39;Green as grass!&#39;);<br>    break;<br>  <strong>default</strong>: // Without this, you see a WARNING.<br>    print(aColor); // &#39;Color.blue&#39;<br>}</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=92e56d8c5edc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dart 2: implementación de clases]]></title>
            <link>https://medium.com/@flutterman/dart-2-implementaci%C3%B3n-de-clases-a53360efa007?source=rss-2abcfcac2310------2</link>
            <guid isPermaLink="false">https://medium.com/p/a53360efa007</guid>
            <category><![CDATA[dart]]></category>
            <category><![CDATA[flutter]]></category>
            <dc:creator><![CDATA[Marcos Alejandro]]></dc:creator>
            <pubDate>Thu, 16 Aug 2018 16:24:18 GMT</pubDate>
            <atom:updated>2018-08-16T16:24:18.203Z</atom:updated>
            <content:encoded><![CDATA[<h4>Cómo implementar una clase</h4><h4>Variables de instancia</h4><pre><strong>class</strong> Point {<br>  num x; // Declarar la variable de instancia x, inicialmente null<br>  num y; // Declarar y, inicialmente null.<br>  num z = 0; // Declarar z, inicialmente 0.<br>}</pre><p>Todas las variables de instancia no inicializadas tiene valor <strong>null</strong>.</p><p>Todas las variables de instancia generan un método <strong>getter</strong> implícito. Las variables non-final también generan un método <strong>setter</strong> implícito.</p><pre><strong>class</strong> Point {<br>  num x;<br>  num y;<br>}<br><br><strong>void</strong> <strong>main</strong>() {<br>  var point = Point();<br>  point.x = 4; // Usa el método setter para x.<br>  assert(point.x == 4); // Usa el método getter para x.<br>  assert(point.y == null); // Valor por defecto es null.<br>}</pre><p>Si inicializa una variable de instancia donde se declara (en lugar de en un constructor o método), el valor se establece cuando se crea la instancia, es decir, antes de que se ejecuten el constructor y su lista de inicializadores.</p><h4>Constructores</h4><p>Declare un constructor creando una función con el mismo nombre que su clase.</p><pre><strong>class</strong> Point {<br>  num x, y;<br><br>  <strong>Point</strong>(num x, num y) {    <br>    this.x = x;   <br>    this.y = y;<br>  }<br>}</pre><pre>// Utilice &quot;this&quot; solo cuando haya un conflicto de nombres.</pre><p>Hay una forma más simple de hacer lo anterior:</p><pre>class Point {<br>  num x, y;<br><br>  Point(this.x, this.y);<br>}</pre><h4>Constructores predeterminados</h4><p>Si no declara un constructor, se le proporciona un constructor predeterminado. El constructor por defecto no tiene argumentos e invoca al constructor sin argumentos de la superclase.</p><h4>Los constructores no se heredan</h4><p>Las subclases no heredan constructores de su superclase. Una subclase que declara que no hay constructores sólo tiene el constructor por defecto (sin argumento, sin nombre).</p><h4>Constructores nombrados</h4><p>Utilice un constructor nombrado para implementar múltiples constructores para una clase o para proporcionar claridad adicional:</p><pre>class Point {<br>  num x, y;<br><br>  Point(this.x, this.y);<br><br>  // constructor nombrado<br>  Point.origin() {<br>    x = 0;<br>    y = 0;<br>  }<br>}</pre><p>Recuerda que los constructores no son heredados, lo que significa que el constructor nombrado de una superclase no es heredado por una subclase. Si desea que una subclase se cree con un constructor con nombre definido en la superclase, debe implementar ese constructor en la subclase.</p><h4>Invocar a un constructor de superclases que no esté por defecto</h4><p>Por defecto, un constructor en una subclase llama al constructor sin nombre de la superclase, sin argumentos. El constructor de la superclase es llamado al principio del cuerpo del constructor. Si también se está utilizando una<a href="https://www.dartlang.org/guides/language/language-tour#initializer-list"> lista de inicializadores</a>, se ejecuta antes de que se llame a la superclase. En resumen, el orden de ejecución es el siguiente:</p><ol><li>Lista de inicializadores</li><li>El constructor sin argumentos de la superclase</li><li>El constructor sin argumentos de la clase principal</li></ol><p>Si la superclase no tiene un constructor sin nombre y sin argumentos, entonces debe llamar manualmente a uno de los constructores de la superclase. Especifique el constructor de superclase después de dos puntos (:), justo antes del cuerpo del constructor (si lo hay).</p><p>En el siguiente ejemplo, el constructor de la clase Employee llama al constructor nombrado para su superclase, Person.</p><pre>class <strong>Person</strong> {<br>  String firstName;</pre><pre>  Person.fromJson(Map data) {<br>    print(&#39;in Person&#39;);<br>  }<br>}</pre><pre>class <strong>Employee</strong> extends <strong>Person</strong> {<br>  // Person does not have a default constructor;<br>  // you must call super.fromJson(data).<br>  Employee.fromJson(Map data) : super.fromJson(data) {<br>    print(&#39;in Employee&#39;);<br>  }<br>}</pre><pre>main() {<br>  var emp = new Employee.fromJson({});</pre><pre>// Prints:<br>  // in Person<br>  // in Employee<br>  if (emp is Person) {<br>    // Type check<br>    emp.firstName = &#39;Bob&#39;;<br>  }<br>  (emp as Person).firstName = &#39;Bob&#39;;<br>}</pre><p>Dado que los argumentos del constructor de la superclase se evalúan antes de invocar al constructor, un argumento puede ser una expresión como una llamada de función:</p><pre>class <strong>Employee</strong> extends <strong>Person</strong> {<br>  Employee() : super.fromJson(getDefaultData());<br>  // ···<br>}</pre><p>Los argumentos del constructor de la superclase no tienen acceso a “this”. Por tal motivo, los argumentos pueden llamar a métodos estáticos pero no a métodos de instancia.</p><h4>Lista de inicializadores</h4><p>Además de invocar a un constructor de superclases, también puede inicializar variables de instancia antes de que el cuerpo del constructor se ejecute. Separe los inicializadores con comas.</p><pre>Point.fromJson(Map&lt;String, num&gt; json)<br>    : x = json[&#39;x&#39;],<br>      y = json[&#39;y&#39;] {<br>  print(&#39;In Point.fromJson(): ($x, $y)&#39;);<br>}</pre><p>Durante el desarrollo, podemos validar los inputs usando assert en la lista de inicializadores.</p><pre>Point.withAssert(this.x, this.y) : assert(x &gt;= 0) {<br>  print(&#39;In Point.withAssert(): ($x, $y)&#39;);<br>}</pre><p>Las listas de inicializadores son útiles al setear los <strong>final fields.</strong></p><pre>import &#39;dart:math&#39;;</pre><pre>class <strong>Point</strong> {<br>  final num x;<br>  final num y;<br>  final num distanceFromOrigin;</pre><pre><strong>  Point</strong>(x, y): x=x, y=y,distanceFromOrigin = sqrt(x*x+y*y);<br>}</pre><pre><strong>main</strong>() {<br>  var p = new <strong>Point</strong>(2, 3);<br>  print(p.distanceFromOrigin);<br>}</pre><h4>Redirección de constructores</h4><p>A veces el único propósito de un constructor es redirigir a otro constructor en la misma clase. El cuerpo de un constructor que redirecciona está vacío, con la llamada del constructor apareciendo después de dos puntos (:).</p><pre>class <strong>Point</strong> {<br>  num x, y;<br><br>  // El constructor principal de esta clase.<br>  Point(this.x, this.y);<br><br>  // Delegados al constructor principal.<br>  Point.alongXAxis(num x) : this(x, 0);<br>}</pre><h4>Constructores constantes</h4><p>Si su clase produce objetos que nunca cambian, puede hacer que estos objetos constantes en tiempo de compilación. Para ello, defina un constructor de <strong>const</strong> y asegúrese de que todas las variables de instancia son <strong>final</strong>.</p><pre><strong>class</strong> ImmutablePoint {<br>  static final ImmutablePoint origin =<br>      const ImmutablePoint(0, 0);<br><br>  final num x, y;<br><br>  const ImmutablePoint(this.x, this.y);<br>}</pre><h4>Constructores Factory</h4><p>Utilice la palabra clave <strong>factory</strong> al implementar un constructor que no siempre crea una nueva instancia de su clase. Por ejemplo, un constructor factory puede devolver una instancia de una caché, o puede devolver una instancia de un subtipo. Los constructores factory no tienen acceso a “this”.</p><pre>class <strong>Logger</strong> {<br>  final String <strong>name</strong>;<br>  bool <strong>mute</strong> = false;<br><br>  // _cache es privado gracias al guion bajo.<br>  static final Map&lt;String, Logger&gt; <strong>_cache</strong> =<br>      &lt;String, Logger&gt;{};<br><br>  factory <strong>Logger</strong>(String <strong>name</strong>) {<br>    if (_cache.containsKey(<strong>name</strong>)) {<br>      return _cache[<strong>name</strong>];<br>    } else {<br>      final logger = Logger._internal(<strong>name</strong>);<br>      _cache[<strong>name</strong>] = logger;<br>      return <strong>logger</strong>;<br>    }<br>  }<br><br>  Logger._internal(this.name);<br><br>  void <strong>log</strong>(String <strong>msg</strong>) {<br>    if (!mute) print(<strong>msg</strong>);<br>  }<br>}</pre><p>Invoque a un constructor factory como lo haría con cualquier otro:</p><pre>var logger = Logger(&#39;UI&#39;);<br>logger.log(&#39;Button clicked&#39;);</pre><h4>METODOS</h4><p>Son funciones que proporcionan comportamiento a un objeto.</p><h4>Métodos de instancia</h4><p>Los métodos de instancia en objetos pueden acceder a las variables de instancia y a “this”.</p><pre>import &#39;dart:math&#39;;<br><br>class Point {<br>  num x, y;<br><br>  Point(this.x, this.y);<br><br>  num <strong>distanceTo</strong>(Point other) {<br>    var dx = x - other.x;<br>    var dy = y - other.y;<br>    return sqrt(dx * dx + dy * dy);<br>  }<br>}</pre><h4>Getters y setters</h4><p>Son métodos especiales que proporcionan acceso de lectura y escritura a las propiedades de un objeto. Recuerde que cada variable de instancia tiene un <strong>getter</strong> implícito, más un <strong>setter</strong> si es apropiado. Puede crear propiedades adicionales implementando getters y setters, usando las palabras clave <strong>get</strong> y <strong>set</strong>:</p><pre>class <strong>Rectangle</strong> {<br>  num <strong>left</strong>, <strong>top</strong>, <strong>width</strong>, <strong>height</strong>;<br><br>  <strong>Rectangle</strong>(this.left, this.top, this.width, this.height);<br><br>  // Definir dos propiedades calculadas: derecha e inferior.<br>  num <strong>get</strong> right =&gt; left + width;<br>  <strong>set</strong> right(num value) =&gt; left = value - width;<br>  num <strong>get</strong> bottom =&gt; top + height;<br>  <strong>set</strong> bottom(num value) =&gt; top = value - height;<br>}<br><br>void main() {<br>  var rect = Rectangle(3, 4, 20, 15);<br>  assert(rect.left == 3);<br>  rect.right = 12;<br>  assert(rect.left == -8);<br>}</pre><h4>Métodos abstractos</h4><p>Los métodos de instancia, getter y setter pueden ser abstractos, definiendo una interfaz pero dejando su implementación a otras clases. Los métodos abstractos sólo pueden existir en clases abstractas.</p><p>Para hacer un método abstracto, utilizamos un punto y coma (;) en lugar del cuerpo del método.</p><pre>abstract class Doer {<br>  // Definir variables y métodos de instancia...<br><br>  void doSomething(); // Definir un método abstracto.<br>}<br><br>class EffectiveDoer extends Doer {<br>  void doSomething() {<br>    // Proporcionar una implementación del método abstracto. <br>  }<br>}</pre><h4>Clases abstractas</h4><p>Utilice el modificador <strong>abstract</strong> para definir una clase abstracta, una clase que no puede ser instanciada. Son útiles para definir interfaces, a menudo con alguna implementación. Si quiere que su clase abstracta parezca instanciable, defina un constructor factory. Las clases abstractas a menudo tienen métodos abstractos.</p><pre>// Esta clase es declarada abstracta y no puede ser instanciada<br>abstract class AbstractContainer {<br>  // Definir constructores, campos y métodos...<br><br>  void updateChildren(); // método abstracto.<br>}</pre><h4>Interfaces implícitas</h4><p>Cada clase define implícitamente una interfaz que contiene todos los miembros de instancia de la clase y de cualquier interfaz que implemente. Si desea crear una clase A que soporte la API de la clase B sin heredar la implementación de B, la clase A debería implementar la interfaz B.</p><p>Una clase implementa una o más interfaces declarándolas en una cláusula <strong>implements</strong> y luego proporcionando las APIs requeridas por las interfaces. Por ejemplo:</p><pre>// Una persona. La interfaz implícita contiene <strong>greet()</strong>.<br>class <strong>Person</strong> {<br>  // En la interfaz, pero visible sólo en esta biblioteca.<br>  final <strong>_name</strong>;<br><br>  // No es la interfaz, ya que es un constructor.<br>  <strong>Person</strong>(this._name);<br><br>  // En la interface.<br>  String <strong>greet</strong>(String who) =&gt; &#39;Hello, $who. I am $_name.&#39;;<br>}<br><br>// Una implementación de la interfaz Person.<br>class <strong>Impostor</strong> implements <strong>Person</strong> {<br>  get _name =&gt; &#39;&#39;;<br><br>  String greet(String who) =&gt; &#39;Hi $who. Do you know who I am?&#39;;<br>}<br><br>String <strong>greetBob</strong>(Person person) =&gt; person.greet(&#39;Bob&#39;);<br><br>void main() {<br>  print(greetBob(Person(&#39;Kathy&#39;)));<br>  print(greetBob(Impostor()));<br>}</pre><p>Una clase puede implementar múltiples interfaces:</p><pre><strong>class</strong> Point <strong>implements</strong> Comparable, Location {...}</pre><h3>Extender una clase</h3><p>Utilice <strong>extends</strong> para crear una subclase y <strong>super</strong> para referirse a la superclase.</p><pre>class <strong>Television</strong> {<br>  void turnOn() {<br>    _illuminateDisplay();<br>    _activateIrSensor();<br>  }<br>  // ···<br>}<br><br>class <strong>SmartTelevision</strong> extends <strong>Television</strong> {<br>  void turnOn() {<br>    super.turnOn();<br>    _bootNetworkInterface();<br>    _initializeMemory();<br>    _upgradeApps();<br>  }<br>  // ···<br>}</pre><h4>Overriding de miembros</h4><p>Las subclases pueden anular métodos de instancia, getters y setters. Puede utilizar la anotación @override para indicar que está anulando intencionalmente a un miembro:</p><pre>class <strong>SmartTelevision</strong> extends <strong>Television</strong> {<br>  @override<br>  void turnOn() {...}<br>  // ···<br>}</pre><h4>Agregando características a una clase: mixins</h4><p>Los <strong>mixins</strong> son una forma de reutilizar el código de una clase en múltiples jerarquías de clases. Para utilizar un mixin utilice la keyword <strong>with</strong> seguida de uno o más nombres de mixin.</p><pre><strong>class</strong> Musician <strong>extends</strong> Performer <strong>with</strong> Musical {<br>  // ···<br>}<br><br><strong>class</strong> Maestro <strong>extends</strong> Person<br>    <strong>with</strong> Musical, Aggressive, Demented {<br>  Maestro(String maestroName) {<br>    name = maestroName;<br>    canConduct = true;<br>  }<br>}</pre><h4>Variables y métodos de clase</h4><p>Utilice la keyword <strong>static</strong> para implementar variables y métodos class-wide.</p><h4>Variables estáticas</h4><p>Son útiles para el estado y las constantes de toda la clase. No se inicializan hasta que se utilizan.</p><pre><strong>class</strong> Queue {<br>  static const initialCapacity = 16;<br>  // ···<br>}<br><br><strong>void</strong> main() {<br>  assert(Queue.initialCapacity == 16);<br>}</pre><h4>Métodos estáticos</h4><p>No funcionan es una instancia y, por lo tanto, no tienen acceso a “this”.</p><pre>import &#39;dart:math&#39;;<br><br>class Point {<br>  num x, y;<br>  Point(this.x, this.y);<br><br>  static num distanceBetween(Point a, Point b) {<br>    var dx = a.x - b.x;<br>    var dy = a.y - b.y;<br>    return sqrt(dx * dx + dy * dy);<br>  }<br>}<br><br>void main() {<br>  var a = Point(2, 2);<br>  var b = Point(4, 4);<br>  var distance = Point.distanceBetween(a, b);<br>  assert(2.8 &lt; distance &amp;&amp; distance &lt; 2.9);<br>  print(distance);<br>}</pre><p>Considere el uso de funciones de nivel superior, en lugar de métodos estáticos, para utilidades y funcionalidades comunes o ampliamente utilizadas.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a53360efa007" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dart 2: uso de clases]]></title>
            <link>https://medium.com/@flutterman/dart-2-uso-de-clases-65b21750e937?source=rss-2abcfcac2310------2</link>
            <guid isPermaLink="false">https://medium.com/p/65b21750e937</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[dart]]></category>
            <dc:creator><![CDATA[Marcos Alejandro]]></dc:creator>
            <pubDate>Wed, 15 Aug 2018 22:19:43 GMT</pubDate>
            <atom:updated>2018-08-15T22:19:43.133Z</atom:updated>
            <content:encoded><![CDATA[<p>Dart es un lenguaje orientado a objetos con clases y herencia basada en mixins. Cada objeto es una instancia de una clase, y todas las clases descienden de Object. La herencia basada en Mixins significa que aunque cada clase (excepto Object) tiene exactamente una superclase, el cuerpo de una clase puede ser reutilizado en múltiples jerarquías de clases.</p><h4>Uso de los miembros de la clase</h4><p>Los objetos tienen miembros que consisten en funciones y datos (métodos y variables de instancia). Cuando se llama a un método, se invoca a un objeto: el método tiene acceso a las funciones y datos de ese objeto:</p><p>Utilice un punto (.) para referirse a una variable o método de instancia:</p><pre>var p = Point(2, 2);<br><br>// Establece el valor de la variable y.<br>p.y = 3;<br><br>// Obtener el valor de y.<br>assert(p.y == 3);<br><br>// Invocar distanceTo() de p.<br>num distance = p.distanceTo(Point(4, 4));</pre><pre>// Utilice ?. en lugar de . para evitar una excepción cuando el <br>// operando del extremo izquierdo es null:<br>p?.y = 4;</pre><h4>Usando constructores</h4><p>Puede crear un objeto utilizando un constructor. Los nombres de los constructores pueden ser <strong><em>ClassName</em></strong> o <strong><em>ClassName.identifier</em></strong>. Por ejemplo, el siguiente código crea objetos Point usando los constructores <strong>Point()</strong> y <strong>Point.fromJson()</strong>.</p><pre>var p1 = Point(2, 2);<br>var p2 = Point.fromJson({&#39;x&#39;: 1, &#39;y&#39;: 2});</pre><h4>Obtención del tipo de objeto</h4><p>Para obtener el tipo de un objeto en tiempo de ejecución, puede utilizar la propiedad runtimeType:</p><pre>print(&#39;The type of a is ${a.runtimeType}&#39;);</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=65b21750e937" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dart 2: estructuras de control de flujo]]></title>
            <link>https://medium.com/@flutterman/dart-2-estructuras-de-control-de-flujo-9b62bc2e3754?source=rss-2abcfcac2310------2</link>
            <guid isPermaLink="false">https://medium.com/p/9b62bc2e3754</guid>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[dart]]></category>
            <category><![CDATA[flutter]]></category>
            <dc:creator><![CDATA[Marcos Alejandro]]></dc:creator>
            <pubDate>Wed, 15 Aug 2018 17:43:45 GMT</pubDate>
            <atom:updated>2018-08-15T17:43:45.203Z</atom:updated>
            <content:encoded><![CDATA[<h4>Las siguientes son las opciones disponibles:</h4><h4>IF and ELSE</h4><p>A diferencia de Javascript, las condiciones deben usar valores booleanos, nada más.</p><pre><strong>if</strong> (isRaining()) {<br>  you.bringRainCoat();<br>} <strong>else if</strong> (isSnowing()) {<br>  you.wearJacket();<br>} <strong>else</strong> {<br>  car.putTopDown();<br>}</pre><h4>Bucles FOR</h4><pre>var message = StringBuffer(&#39;Dart is fun&#39;);<br>for (var i = 0; i &lt; 5; i++) {<br>  message.write(&#39;!&#39;);<br>}</pre><p>Los <em>closures</em> dentro de los bucles de Dart capturan el valor del índice.</p><pre>var callbacks = [];<br>for (var i = 0; i &lt; 2; i++) {<br>  callbacks.add(() =&gt; print(i));<br>}<br>callbacks.forEach((c) =&gt; c());  // Esto imprime 0 y 1</pre><p>Si el objeto sobre el que está iterando es un Iterable, podemos usar el método <strong>forEach()</strong>, sobre todo si no necesitamos conocer el contador de iteración.</p><pre>candidates.<strong>forEach</strong>((candidate) =&gt; candidate.interview());</pre><p>Las clases iterables como <strong>List</strong> y <strong>Set</strong> también soportan la forma <strong>for-in</strong>.</p><pre>var collection = [0, 1, 2];<br><strong>for</strong> (<strong>var</strong> x <strong>in</strong> collection) {<br>  <strong>print</strong>(x); // 0 1 2<br>}</pre><h4>WHILE and DO-WHILE</h4><pre>// WHILE evalúa la condición antes del bucle:<br><strong>while</strong> (!isDone()) {<br>  doSomething();<br>}</pre><pre>// DO-WHILE evalúa la condición después del bucle:<br><strong>do</strong> {<br>  printLine();<br>} <strong>while</strong> (!atEndOfPage());</pre><h4>BREAK y CONTINUE</h4><pre>// Use BREAK para detener el bucle:<br><strong>while</strong> (true) {<br>  if (shutDownRequested()) <strong>break</strong>;<br>  processIncomingRequests();<br>}</pre><pre>// Use CONTINUE para saltar a la siguiente iteración del bucle<br><strong>for</strong> (int i = 0; i &lt; candidates.length; i++) {<br>  var candidate = candidates[i];<br>  if (candidate.yearsExperience &lt; 5) {<br>    <strong>continue</strong>;<br>  }<br>  candidate.interview();<br>}<br>// Si esta usando un Iterable puede escribir lo anterior así:<br>candidates<br>    .<strong>where</strong>((c) =&gt; c.yearsExperience &gt;= 5)<br>    .<strong>forEach</strong>((c) =&gt; c.interview());</pre><h4>SWITCH y CASE</h4><p>Las sentencias <strong>Switch</strong> comparan números enteros, cadenas o constantes de tiempo de compilación usando <strong>==</strong>. Los objetos comparados deben ser todas instancias de la misma clase (y no de sus subtipos). Cada “<strong>case</strong>” no vacío termina con un <strong>break</strong>. Otras formas válidas de terminar una cláusula son <strong>continue</strong>, <strong>throw</strong> o <strong>return</strong>. Utilice <strong>default</strong> para ejecutar código cuando no haya ninguna coincidencia.</p><pre>var command = &#39;OPEN&#39;;<br><strong>switch</strong> (command) {<br>  <strong>case</strong> &#39;CLOSED&#39;:<br>    executeClosed();<br>    <strong>break</strong>;<br>  <strong>case</strong> &#39;PENDING&#39;:<br>    executePending();<br>    <strong>break</strong>;<br>  <strong>case</strong> &#39;APPROVED&#39;:<br>    executeApproved();<br>    <strong>break</strong>;<br>  <strong>case</strong> &#39;DENIED&#39;:<br>    executeDenied();<br>    <strong>break</strong>;<br>  <strong>case</strong> &#39;OPEN&#39;:<br>    executeOpen();<br>    <strong>break</strong>;<br>  <strong>default</strong>:<br>    executeUnknown();<br>}</pre><p>Dart soporta cláusulas vacías, permitiendo una forma de caída:</p><pre>var command = &#39;CLOSED&#39;;<br><strong>switch</strong> (command) {<br>  <strong>case</strong> &#39;CLOSED&#39;: // Caso vacío.<br>  <strong>case</strong> &#39;NOW_CLOSED&#39;:<br>    // Se ejecuta tanto para CLOSED como para NOW_CLOSED.<br>    executeNowClosed();<br>    break;<br>}</pre><pre>// Una mejor forma sería:<br>var command = &#39;CLOSED&#39;;<br><strong>switch</strong> (command) {<br>  <strong>case</strong> &#39;CLOSED&#39;:<br>    executeClosed();<br>    <strong>continue</strong> nowClosed;<br>  // Continua ejecutandose en la etiqueta &quot;nowClosed&quot;.<br><br>  <strong>nowClosed</strong>:<br>  <strong>case</strong> &#39;NOW_CLOSED&#39;:<br>    // Se ejecuta tanto para CLOSED como para NOW_CLOSED.<br>    executeNowClosed();<br>    <strong>break</strong>;<br>}</pre><h4>ASSERT</h4><p>Se utiliza para interrumpir la ejecución normal si una condición booleana es false. Estas sentencias no tienen efecto en el código de producción, <strong>son solo para desarrollo.</strong></p><pre>// Asegúrese de que la variable tiene un valor no null.<br><strong>assert</strong>(text != null);<br><br>// Asegúrese de que el valor es inferior a 100.<br><strong>assert</strong>(number &lt; 100);<br><br>// Asegúrese de que se trata de una URL https. <br><strong>assert</strong>(urlString.startsWith(&#39;https&#39;));</pre><p>Para agregar un mensaje a un <strong>assert</strong>, pasarlo como segundo argumento. El primer argumento puede ser cualquier expresión que se resuelva a un valor booleano. Si el valor de la expresión es true, la ejecución continúa, si es false lanza una excepción.</p><pre>assert(urlString.startsWith(&#39;https&#39;),<br>    &#39;URL ($urlString) should start with &quot;https&quot;.&#39;);</pre><h4>EXCEPCIONES</h4><p>Las excepciones (<strong>throw</strong>) son errores que indican que algo inesperado sucedió. Si la excepción no es capturada (<strong>catch</strong>), el hilo de ejecución es suspendido, y por lo general el programa es finalizado.</p><p>Dart provee tipos de <strong>Exception</strong> y <strong>Error</strong>, así como numerosos subtipos predefinidos. Incluso podemos definir nuestras propias excepciones.</p><p><strong>Throw</strong></p><pre><strong>throw</strong> FormatException(&#39;Se esperaba al menos 1 sección&#39;);</pre><p>Dado que lanzar una exception es una expresión, podemos lanzarlas en sentencias =&gt;, así como en cualquier otro lugar que permita expresiones.</p><p><strong>Catch</strong></p><p>Capturar una exception detiene la propagación de la misma y nos da la oportunidad de manejarla.</p><pre><strong>try</strong> {<br>  breedMoreLlamas();<br>} <strong>on</strong> OutOfLlamasException {<br>  buyMoreLlamas();<br>}</pre><p>Para manejar código que puede lanzar más de un tipo de exception, podemos especificar múltiples cláusulas de captura. La primera que coincide con el tipo de objeto lanzado maneja la excepción. Si no especificamos un tipo, catch puede manejar cualquier tipo lanzado.</p><pre><strong>try</strong> {<br>  breedMoreLlamas();<br>} <strong>on</strong> OutOfLlamasException {<br>  // Una excepción específica<br>  buyMoreLlamas();<br>} <strong>on</strong> Exception catch (e) {<br>  // Cualquier otra cosa que sea una excepción<br>  print(&#39;Unknown exception: $e&#39;);<br>} <strong>catch</strong> (e) {<br>  // Tipo no especificado, manejará todo. <br>  print(&#39;Something really unknown: $e&#39;);<br>}</pre><p>Como se muestra en el código anterior, se puede usar <strong>on</strong> o <strong>catch</strong> o ambos. Usamos <strong>on</strong> cuando necesitamos especificar el tipo de excepción. Usamos <strong>catch</strong> cuando nuestro manejador de excepciones necesite el objeto exception.</p><h4>Finally</h4><p>Para asegurarse de que algún código se ejecuta independientemente de si se lanza o no una excepción, utilice una cláusula <strong>finally</strong>. Si ninguna cláusula de captura coincide con la excepción, la excepción se propaga después de que se ejecute la cláusula finally. La claúsula finally se ejecuta después de cualquier claúsula catch coincidente.</p><pre><strong>try</strong> {<br>  breedMoreLlamas();<br>} <strong>finally</strong> {<br>  // Always clean up, even if an exception is thrown.<br>  cleanLlamaStalls();<br>}</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9b62bc2e3754" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dart 2: operadores]]></title>
            <link>https://medium.com/@flutterman/dart-2-operadores-bd0b01008856?source=rss-2abcfcac2310------2</link>
            <guid isPermaLink="false">https://medium.com/p/bd0b01008856</guid>
            <category><![CDATA[dart]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[flutter]]></category>
            <dc:creator><![CDATA[Marcos Alejandro]]></dc:creator>
            <pubDate>Wed, 15 Aug 2018 15:03:07 GMT</pubDate>
            <atom:updated>2018-08-15T15:03:07.793Z</atom:updated>
            <content:encoded><![CDATA[<h4>A continuación los operadores más habituales</h4><h4>Operadores Aritméticos</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/836/1*KBr0SLpEFYKC6SyskpoUCw.png" /></figure><h4>Operadores de incremento y decremento</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/694/1*a1TmpzUakXnIvnVjVzJrpw.png" /></figure><pre>//EJEMPLOS:<br>var a, b;<br><br>a = 0;<br>b = ++a; // Incrementa a antes de que b obtenga su valor.<br>assert(a == b); // 1 == 1<br><br>a = 0;<br>b = a++; // Incrementa a DESPUÉS de que b obtenga su valor.<br>assert(a != b); // 1 != 0<br><br>a = 0;<br>b = --a; // Decrementa a antes de que b obtenga su valor.<br>assert(a == b); // -1 == -1<br><br>a = 0;<br>b = a--; // Decrementa a DESPUÉS de que b obtenga su valor.<br>assert(a != b); // -1 != 0</pre><h4>Operadores de igualdad y relacionales</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/413/1*Kiy0XrD5CdklBZTToVs-KA.png" /></figure><p>Para comprobar si dos objetos <strong><em>x</em></strong> e <strong><em>y</em></strong> representan la misma cosa, utilice el operador <strong>==</strong>. En el caso de que necesite saber si dos objetos son exactamente el mismo objeto, use la función <strong>identical()</strong>.</p><p>El operador <strong>==</strong> retorna <strong><em>true</em></strong> si ambos son <strong>null</strong>, y <strong><em>false</em></strong> si solo uno es <strong>null.</strong></p><h4>Operadores de test de tipos</h4><p>Los operadores <strong><em>as</em></strong>, <strong><em>is</em></strong> y <strong><em>is!</em></strong> sirven para verificar <strong>tipos</strong> en tiempo de ejecución. El resultado de “<strong>obj <em>is</em> T”</strong> es <strong>true</strong> si <strong>obj</strong> implementa la interfaz especificada por <strong>T</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/852/1*3P8dtotq_NotzkZagr89tQ.png" /></figure><pre><strong>// </strong>Si tenemos:<strong><br>if</strong> (emp <strong>is</strong> Person) {<br>  emp.firstName = &#39;Bob&#39;;<br>}</pre><pre>// Podemos acortar el código usando el operador &quot;as&quot;<br>(emp <strong>as</strong> Person).firstName = &#39;Bob&#39;;</pre><pre>Nota: <em>El código no es equivalente. Si emp es null o no es del tipo Person, el primer ejemplo no hace nada, mientras que en el segudno lanza una excepción.</em></pre><h4>Operadores de asignación</h4><p>Podemos asignar valores usando el operador <strong>=</strong>. Para asignar sólo si la variable asignada es <strong>null</strong>, utilizamos el operador <strong>??=</strong>.</p><pre>// Asigna valor a var1<br>var1 = value;<br>// Asigna valor a var2 si es null; de lo contrario, permanece igual.<br>var2 ??= value;</pre><p>Los operadores de asignación compuestos, combinan una operación con una asignación: “<strong>a <em>op</em>= b”</strong> equivale a “<strong>a = a <em>op</em> b”.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/330/1*_Q2rxvVuMojPp8RClrjvDg.png" /></figure><h4>Operadores lógicos</h4><p>Para invertir o combinar expresiones booleanas utilizamos operadores lógicos</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J5CyVCtxyXzRRM3C6p1Ncw.png" /></figure><h4>Expresiones condicionales</h4><p>Dart tiene dos operadores que nos permiten evaluar de manera concisa expresiones que de otra manera podrían requerir declaraciones <strong>if-else</strong>:</p><p><strong><em>condition</em></strong><strong> ? </strong><strong><em>expr1</em></strong><strong> : </strong><strong><em>expr2</em></strong><em> // Si la condición es true, evalúa expr1 y devuelve su valor, de lo contrario evalúa y devuelve el valor de expr2</em></p><p><strong><em>expr1</em></strong><strong> ?? </strong><strong><em>expr2 // </em></strong><em>Si expr1 no es null, evalúa y devuelve su valor, de lo contrario evalúa y devuelve el valor de expr2</em><strong><em>.</em></strong></p><pre>// Para asignar un valor en base a un expresión booleana usamos ?:<br>var visibility = isPublic ? &#39;public&#39; : &#39;private&#39;;</pre><pre>// Para la expresión verifica si es null usamos ??<br><strong>String</strong> playerName(<strong>String</strong> name) =&gt; name <strong>??</strong> &#39;Guest&#39;;</pre><h4>Notación en cascada (..)</h4><p>Las cascadas (..) permiten realizar una secuencia de operaciones sobre el mismo objeto. Además de las llamadas de función, también se puede acceder a los campos de ese mismo objeto. Esto a menudo le ahorra el paso de crear una variable temporal y le permite escribir un código más fluido.</p><pre>querySelector(&#39;#confirm&#39;) // Obtener un objeto.<br>  ..text = &#39;Confirm&#39; // Usar sus miembros.<br>  ..classes.add(&#39;important&#39;)<br>  ..onClick.listen((e) =&gt; window.alert(&#39;Confirmed!&#39;));</pre><pre><strong>// Esto es equivalente a:</strong><br>var button = querySelector(&#39;#confirm&#39;);<br>button.text = &#39;Confirm&#39;;<br>button.classes.add(&#39;important&#39;);<br>button.onClick.listen((e) =&gt; window.alert(&#39;Confirmed!&#39;));</pre><p>Las cascadas pueden anidarse:</p><pre>final <strong>addressBook</strong> = (AddressBookBuilder()<br>      ..name = &#39;jenny&#39;<br>      ..email = &#39;jenny@example.com&#39;<br>      ..phone = (PhoneNumberBuilder()<br>            ..number = &#39;415-555-0100&#39;<br>            ..label = &#39;home&#39;)<br>          .build())<br>    .build();</pre><p>Tener cuidado de construir una cascada sobre una función que devuelva un objeto real. Si devuelve <strong>void</strong>, dará error.</p><h4>Otros operadores</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L8v3Lgk4313CA6h_igu3LA.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bd0b01008856" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dart 2: la función main()]]></title>
            <link>https://medium.com/@flutterman/dart-2-la-funci%C3%B3n-main-e6c60b42bc7c?source=rss-2abcfcac2310------2</link>
            <guid isPermaLink="false">https://medium.com/p/e6c60b42bc7c</guid>
            <category><![CDATA[dart]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <dc:creator><![CDATA[Marcos Alejandro]]></dc:creator>
            <pubDate>Wed, 15 Aug 2018 01:22:11 GMT</pubDate>
            <atom:updated>2018-08-15T01:22:11.994Z</atom:updated>
            <content:encoded><![CDATA[<p>Cada aplicación debe tener una función <strong>main()</strong> de nivel superior, que sirve como punto de entrada a la aplicación. La función <strong>main()</strong> devuelve <strong>void</strong> y tiene un parámetro opcional <strong>List&lt;String&gt;</strong> para los argumentos.</p><pre>// Ejemplo para aplicación web<br>void <strong>main</strong>() {<br>  querySelector(&#39;#sample_text_id&#39;)<br>    ..text = &#39;Click me!&#39;<br>    ..onClick.listen(reverseText);<br>}</pre><pre>// Para una aplicación de línea de comandos<br>void <strong>main</strong>(List&lt;String&gt; arguments) {<br>  print(arguments);<br><br>  assert(arguments.length == 2);<br>  assert(int.parse(arguments[0]) == 1);<br>  assert(arguments[1] == &#39;test&#39;);<br>}</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e6c60b42bc7c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dart 2: funciones]]></title>
            <link>https://medium.com/@flutterman/dart-2-funciones-7f3cf5b50557?source=rss-2abcfcac2310------2</link>
            <guid isPermaLink="false">https://medium.com/p/7f3cf5b50557</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[dart]]></category>
            <dc:creator><![CDATA[Marcos Alejandro]]></dc:creator>
            <pubDate>Wed, 15 Aug 2018 00:55:11 GMT</pubDate>
            <atom:updated>2018-08-15T01:41:44.139Z</atom:updated>
            <content:encoded><![CDATA[<p>Dart es un verdadero lenguaje orientado a objetos, así que incluso las funciones son objetos y tienen un tipo,<a href="https://api.dartlang.org/stable/dart-core/Function-class.html"> <strong>Function</strong>.</a> Esto significa que las funciones se pueden asignar a variables o pasar como argumentos a otras funciones. También puede llamar a una instancia de una clase Dart como si fuera una función.</p><pre><strong>// </strong>Función con especificación de tipos<strong><br>bool</strong> isNoble(<strong>int</strong> atomicNumber) {<br>  <strong>return</strong> _nobleGases[atomicNumber] != null;<br>}</pre><pre>// La misma función sin tipos, funciona igual. <br>isNoble(atomicNumber) {<br>  <strong>return</strong> _nobleGases[atomicNumber] != null;<br>}</pre><pre>// Sintaxis abreviada para funciones de una sola expresión:<br><strong>bool</strong> isNoble(<strong>int</strong> atomicNumber) =&gt; _nobleGases[atomicNumber] != null;</pre><p>Una función puede tener dos tipos de parámetros: obligatorios y opcionales. Los parámetros requeridos se enumeran primero, seguido de los opcionales. Los opcionales nombrados se pueden marcar como <strong>@required</strong>.</p><h4>Parámetros opcionales</h4><p>Los opcionales pueden ser posicionales o nombrados, pero no ambos.</p><p><strong>Parámetros opciones nombrados</strong>: al llamar a la función, puede especificar parámetros con nombre utilizando <strong>paramName: value</strong></p><pre>// Sets the [bold] and [hidden] flags ...<br><strong>void</strong> enableFlags({<strong>bool</strong> bold, <strong>bool</strong> hidden}) {...}</pre><pre>enableFlags(<strong>bold</strong>: true, <strong>hidden</strong>: false);</pre><p>Las expresiones de creación de instancias pueden volverse complejas, por lo que los constructores de widgets utilizan exclusivamente parámetros con nombre. Esto las hace más fáciles de leer.</p><p>Puede anotar un parámetro con nombre con <em>@required</em> para indicar que es obligatorio:</p><pre><strong>const</strong> Scrollbar({<strong>Key</strong> key, <strong>@required</strong> <strong>Widget</strong> child})</pre><p><strong>Parámetros opcionales posicionales</strong>: al envolver un conjunto de parámetros en [] se marcan como opcionales de posición:</p><pre><strong>String</strong> say(<strong>String</strong> from, <strong>String</strong> msg, [<strong>String</strong> device]) {<br>  var result = &#39;<strong><em>$from</em></strong> says <strong><em>$msg</em></strong>&#39;;<br>  if (device != null) {<br>    result = &#39;<strong><em>$result</em></strong> with a <strong><em>$device</em></strong>&#39;;<br>  }<br>  <strong>return</strong> result;<br>}</pre><pre>say(&#39;Bob&#39;, &#39;Howdy&#39;); // Pasando dos argumentos<br>say(&#39;Bob&#39;, &#39;Howdy&#39;, &#39;smoke signal&#39;); // Pasando el tercero opcional</pre><p><strong>Valores por default de los parámetros: </strong>Puede utilizar = para definir valores por defecto tanto para parámetros con nombre como de posición. Deben ser constantes en tiempo de compilación. A menos que se especifique otro, el valor por default es null.</p><pre>/// Sets the [bold] and [hidden] flags ...<br><strong>void</strong> enableFlags({<strong>bool</strong> bold = false, <strong>bool</strong> hidden = false}) {...}</pre><pre>// bold will be true; hidden will be false.<br>enableFlags(<strong>bold</strong>: true);</pre><pre>// Valores por default para parámetros de posición:<br><strong>String</strong> say(<strong>String</strong> from, <strong>String</strong> msg,<br>    [<strong>String</strong> device = &#39;carrier pigeon&#39;, <strong>String</strong> mood]) {<br>  var result = &#39;<strong><em>$from</em></strong> says <strong><em>$msg</em></strong>&#39;;<br>  if (device != null) {<br>    result = &#39;<strong><em>$result</em></strong> with a <strong><em>$device</em></strong>&#39;;<br>  }<br>  if (mood != null) {<br>    result = &#39;<strong><em>$result</em></strong> (in a <strong><em>$mood</em></strong> mood)&#39;;<br>  }<br>  <strong>return</strong> result;<br>}</pre><pre><strong>assert</strong>(say(&#39;Bob&#39;, &#39;Howdy&#39;) <strong>==</strong><br>    &#39;Bob says Howdy with a carrier pigeon&#39;);</pre><p>También puede pasar lists o maps como valores predeterminados.</p><pre><strong>void</strong> doStuff(<br>    {<strong>List&lt;int&gt; </strong>list = <strong>const</strong> [1, 2, 3],<br>    <strong>Map&lt;String, String&gt;</strong> gifts = <strong>const</strong> {<br>      &#39;first&#39;: &#39;paper&#39;,<br>      &#39;second&#39;: &#39;cotton&#39;,<br>      &#39;third&#39;: &#39;leather&#39;<br>    }}) {<br>  <strong>print</strong>(&#39;list:  $list&#39;);<br>  <strong>print</strong>(&#39;gifts: $gifts&#39;);<br>}</pre><h4>Funciones como objetos de primera clase</h4><p>Podemos pasar una función como parámetro a otra función:</p><pre><strong>void</strong> printElement(<strong>int</strong> element) {<br>  <strong>print</strong>(element);<br>}<br><br><strong>var</strong> list = [1, 2, 3];<br><br>list.<strong>forEach</strong>(printElement);</pre><p>También podemos asignar una función a una variable:</p><pre><strong>var</strong> loudify = (msg) =&gt; &#39;${msg.toUpperCase()}&#39;;<br>assert(loudify(&#39;hello&#39;) == &#39;HELLO&#39;);</pre><h4>Funciones anónimas</h4><p>La mayoría de las funciones tienen nombre, como main() o printElement(). También puede crear una función sin nombre llamada función anónima, o a veces un <em>lambda</em> o <em>closure</em>. Puede asignar una función anónima a una variable para que, por ejemplo, pueda añadirla o eliminarla de una colección.</p><p>Una función anónima se parece a una función nombrada — cero o más parámetros, separados por comas y anotaciones de tipo opcional, entre paréntesis.</p><p>El bloque de código que sigue contiene el cuerpo de la función:</p><p>([[<em>Type</em>] <em>param1</em>[, …]]) { <br> <em>codeBlock</em>; <br>};</p><pre>var list = [&#39;apples&#39;, &#39;bananas&#39;, &#39;oranges&#39;];<br>list.<strong>forEach</strong>((item) {<br>  <strong>print</strong>(&#39;${list.indexOf(item)}: $item&#39;);<br>});</pre><pre>// Si la función contiene solo una expresión, puede abreviarla     // utilizando la notación de flecha:<br>list.<strong>forEach</strong>((item) =&gt; <strong>print</strong>(&#39;${list.indexOf(item)}: $item&#39;));</pre><h4>Scope léxico</h4><p>Dart es un lenguaje de alcance léxico, lo que significa que el alcance de las variables se determina estáticamente, simplemente por el diseño del código. Puede “seguir las llaves rizadas hacia afuera” para ver si hay una variable en el alcance.</p><p>A continuación se muestra un ejemplo de funciones anidadas con variables en cada nivel de alcance:</p><pre><strong>bool</strong> topLevel = true;<br><br><strong>void</strong> main() {<br>  <strong>var</strong> insideMain = true;<br><br>  <strong>void</strong> myFunction() {<br>    <strong>var</strong> insideFunction = true;<br><br>    <strong>void</strong> nestedFunction() {   <br>      <strong>var</strong> insideNestedFunction = true;<br><br>      assert(topLevel);<br>      assert(insideMain);<br>      assert(insideFunction);<br>      assert(insideNestedFunction);<br>    }<br>  }<br>}<br>// <strong>nestedFunction</strong>() podrá usar variables de todos los niveles</pre><h4>Closures lexicos</h4><p>Un closure es un objeto de función que tiene acceso a variables en su ámbito léxico, incluso cuando la función se utiliza fuera de su ámbito original.</p><p>Las funciones pueden cerrar sobre variables definidas en los alcances circundantes. En el siguiente ejemplo, <strong>makeAdder</strong>() captura la variable <strong>addBy</strong>. Donde quiera que vaya la función devuelta, recuerda <strong>addBy</strong>.</p><pre>/// Returns a function that adds [addBy] to the<br>/// function&#39;s argument.<br><strong>Function</strong> makeAdder(<strong>num</strong> addBy) {<br>  <strong>return</strong> (num i) =&gt; addBy + i;<br>}<br><br>void <strong>main</strong>() {<br>  // Create a function that adds 2.<br>  <strong>var</strong> add2 = makeAdder(2);<br><br>  // Create a function that adds 4.<br>  <strong>var</strong> add4 = makeAdder(4);<br><br>  <strong>assert</strong>(add2(3) == 5);<br>  <strong>assert</strong>(add4(3) == 7);<br>}</pre><h4>Funciones de prueba para la igualdad</h4><pre><strong>void</strong> foo() {} // Una función de alto nivel<br><br><strong>class</strong> A {<br>  <strong>static</strong> void bar() {} // Un método estático<br>  <strong>void</strong> baz() {} // Un método de instancia<br>}<br><br><strong>void</strong> main() {<br>  var x;<br><br>  // Comparación de funciones de nivel superior.<br>  x = foo;<br>  assert(foo == x);<br><br>  // Comparación de métodos estáticos.<br>  x = A.bar;<br>  assert(A.bar == x);<br><br>  // Comparación de métodos de instancia.<br>  var v = A(); // Instancia #1 de A<br>  var w = A(); // Instancia #2 de A<br>  var y = w;<br>  x = w.baz;<br><br>  // Estos closures se refieren a la misma instancia (#2),<br>  // así que son iguales.<br>  assert(y.baz == x);<br><br>  // Estos closures se refieren a casos diferentes,<br>  // así que no son iguales.<br>  assert(v.baz != w.baz);<br>}</pre><h4>Valores de retorno</h4><p>Todas las funciones devuelven un valor. Si no se especifica ningún valor de retorno, la sentencia<strong> return null</strong>; se añade implícitamente al cuerpo de la función.</p><pre>foo() {}<br><br>assert(foo() == null);</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7f3cf5b50557" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dart 2: tipos de datos]]></title>
            <link>https://medium.com/@flutterman/dart-2-tipos-de-datos-321b348749b9?source=rss-2abcfcac2310------2</link>
            <guid isPermaLink="false">https://medium.com/p/321b348749b9</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[dart]]></category>
            <dc:creator><![CDATA[Marcos Alejandro]]></dc:creator>
            <pubDate>Wed, 15 Aug 2018 00:54:15 GMT</pubDate>
            <atom:updated>2018-08-15T00:54:15.179Z</atom:updated>
            <content:encoded><![CDATA[<h4>Tipos de datos incluídos</h4><ul><li>numbers</li><li>strings</li><li>booleans</li><li>lists (tambień conocidas como arrays)</li><li>maps</li><li>runes (para expresar caracteres Unicode en un string)</li><li>symbols</li></ul><h4>NUMBERS</h4><p><strong>int</strong> y <strong>double</strong> son subtipos de <strong>num</strong>.</p><pre><strong>// </strong>Enteros sin punto decimal, no mayores de 64bits.<strong><br>int</strong> x = 1;<br><strong>int</strong> hex = 0xDEADBEEF;</pre><pre><strong>// </strong>Números decimales, de 64bits. <strong><br>double</strong> y = 1.1;<br><strong>double</strong> exponents = 1.42e5;</pre><p><strong>Convertir una cadena a un número, y viceversa.</strong></p><pre>var one = int.<strong>parse</strong>(&#39;1&#39;); // de <em>string</em> a <em>int</em></pre><pre>var <em>onePointOne</em> = double.<strong>parse</strong>(&#39;1.1&#39;); // de <em>string</em> a <em>double</em></pre><pre>String <em>oneAsString</em> = 1.<strong>toString</strong>(); // de <em>int</em> a <em>string</em></pre><pre>String <em>piAsString</em> = 3.14159.<strong>toStringAsFixed</strong>(2); // <em>double</em> a <em>string</em></pre><h4>STRINGS</h4><pre>var s1 = &#39;Las comillas simples funcionan bien para los literales&#39;;<br>var s2 = &quot;Las comillas dobles funcionan igual de bien&quot;;<br>var s3 = &#39;El fácil escapar del delimitador de cadena con \n&#39;;</pre><p>Puede poner el valor de una expresión dentro de una cadena usando <strong>${<em>expresión</em>}</strong>. Si la expresión es un identificador se pueden omitir los <strong>{}</strong>.</p><p>Puede concatenar cadenas utilizando literales de cadena adyacentes o el operador “+”.</p><p>Otra forma de crear una cadena multilíneas es utilizando comillas tripe con comillas simples o dobles:</p><pre>var s1 = &#39;&#39;&#39;<br>You can create<br>multi-line strings like this one.<br>&#39;&#39;&#39;;</pre><pre>var s2 = &quot;&quot;&quot;This is also a<br>multi-line string.&quot;&quot;&quot;;</pre><p><strong>Raw String:</strong> para crear una cadena “cruda” usamos el prefijo “r”.</p><pre>var s = r&#39;In a raw string, not even \n gets special treatment.&#39;;</pre><h4>BOOLEANS</h4><p>Solo dos objetos tiene el tipo <strong>bool</strong>: los literales <strong>true</strong> y <strong>false</strong>. Por este motivo para chequear si existe un valor usamos:</p><pre>// Chequear una cadena vacía.<br>var fullName = &#39;&#39;;<br>assert(fullName.<strong>isEmpty</strong>);</pre><pre>// Chequear cero.<br>var hitPoints = 0;<br>assert(hitPoints &lt;= 0);</pre><pre>// Chequear null.<br>var unicorn;<br>assert(unicorn == null);</pre><pre>// Chequear NaN.<br>var iMeantToDoThis = 0 / 0;<br>assert(iMeantToDoThis.<strong>isNaN</strong>);</pre><h4>LISTAS</h4><p>En Dart las <em>colecciones</em> o <em>arrays</em> son objetos <strong>List</strong>. El índice del primer elemento es cero. Puede obtener la longitud de una lista y referirse a los elementos tal como lo haría en Javascript.</p><pre><strong>var</strong> list = [1, 2, 3]; // lista simple que infiere el tipo List&lt;int&gt;</pre><pre><strong>assert</strong>(list.length == 3);<br><strong>assert</strong>(list[1] == 2);</pre><pre><strong>list</strong>[1] = 1;<br><strong>assert</strong>(list[1] == 1);</pre><pre>// Crea una lista constante en tiempo de compilación<br><strong>var</strong> constantList = <strong>const</strong> [1, 2, 3];</pre><h4>MAPAS</h4><p>Un map es un objeto que asocia claves y valores. Tanto las claves como los valores pueden ser cualquier tipo de objeto. Cada key es única.</p><pre>// Se infiere el tipo Map&lt;String,String&gt;<br>var gifts = {<br>  &#39;first&#39;: &#39;partridge&#39;,<br>  &#39;second&#39;: &#39;turtledoves&#39;,<br>  &#39;fifth&#39;: &#39;golden rings&#39;<br>};</pre><pre>// Se infiere el tipo Map&lt;int,String&gt;<br>var nobleGases = {<br>  2: &#39;helium&#39;,<br>  10: &#39;neon&#39;,<br>  18: &#39;argon&#39;,<br>};</pre><p>Puede crear los mismos objetos utilizando un constructor de maps.</p><pre>var gifts = <strong>Map</strong>();<br>gifts[&#39;first&#39;] = &#39;partridge&#39;;<br>gifts[&#39;second&#39;] = &#39;turtledoves&#39;;<br>gifts[&#39;fifth&#39;] = &#39;golden rings&#39;;</pre><pre>var nobleGases = <strong>Map</strong>();<br>nobleGases[2] = &#39;helium&#39;;<br>nobleGases[10] = &#39;neon&#39;;<br>nobleGases[18] = &#39;argon&#39;;</pre><p>Se puede añadir un nuevo par key-value, y recupere un valor tal y como lo haríamos en Javascript.</p><pre>gifts[&#39;fourth&#39;] = &#39;calling birds&#39;; // Agrega un par key-value<br>gifts[&#39;first&#39;] // recupera el valor para la clave &quot;first&quot;</pre><p>Si intentamos recuperar una clave que no existe en el <strong>map</strong>, devuelve <strong>null</strong>.</p><pre>// Crear un map que sea constante en tiempo de compilación. <br>final constantMap = <strong>const</strong> {<br>  2: &#39;helium&#39;,<br>  10: &#39;neon&#39;,<br>  18: &#39;argon&#39;,<br>};</pre><h4>RUNES</h4><p>Unicode define un valor numérico único para cada letra, dígito y símbolo utilizado en todos los sistemas de escritura del mundo. Debido a que un String en Dart es una secuencia de unidades de código de UTF16, la expresión de valores de 32bits dentro de una cadena requiere una sintaxis especial.</p><p>La forma habitual de expresar un punto de código Unicode es <strong>\uXXXX, </strong>donde XXXX es un valor haxadecimal de 4 dígitos. Por ejemplo, podemos usar <strong><em>\u2665</em></strong> para representar un corazón (♥). Para especificar más o menos de 4 dígitos hexadecimales, coloque el valor entre corchetes. Por ejemplo, el emoji (😆) is <strong>\u{1f600}</strong>.</p><h4>SYMBOLS</h4><p>Un objeto symbol representa un operador o identificador declarado en un programa Dart. Puede que nunca necesite utilizar símbolos, pero son de un valor incalculable para las API que se refieren a identificadores por nombre, ya que la minificación cambia los nombres de identificador pero no los símbolos del identificador.</p><p>Para obtener el símbolo de un identificador, utilice un símbolo literal, que es solo # seguido por el identificador:</p><pre>#radix<br>#bar</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=321b348749b9" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>