programación

Soporte para TypeScript en Vuejs

Este artículo es una traducción de la documentación oficial. Mis notas estarán debidamente identificadas.

Soporte para TypeScript

A partir de la versión de Vue 2.5.0 en adelante se ha mejorado significativamente las declaraciones de tipos para que operen con el API default basado en objectos. Al mismo tiempo se ha introducido algunos cambios que requieren se realice una debida actualización. Leer el siguiente artículo para más detalles.

Nota: Con esta introducción se reafirma el compromiso del equipo de Vue para mantener un ambiente saludable y ágil a la hora de trabajar con TypeScripte dentro de Vue.

Declaración oficial en los paquetes de NPM

Un sistema de tipado estático puede ayudar a prevenir muchos potenciales errores de runtime, especialmente cuando la aplicación continúa creciendo. Es por esto que Vue ofrece soporte oficial a las declaraciones para tipado estático en TypeScript – no solo para el core de Vue, sino también para las librerías vue-router y vuex.

Dado que estas están publicadas en NPM, y la versión más reciente de TypeScript sabe como resolver las declaraciones de tipo en los paquetes de NPM, esto significa que cuando se instala a través de NPM, no se necesita ninguna herramienta adicional para habilitar TypeScript en Vue.

Nota: Actualmente TypeScript cuenta con una rica colección de tipos gracias al esfuerzo del colectivo Definitely Typed y a la aceptación en general de la comunidad.

Configuración recomendada

// tsconfig.json
{
  "compilerOptions": {
    // esto se alinea con el soporte de Vue en el navegador 
    "target": "es5",
    // permite una inferencia más estricta para las propiedades de datos en `this`
    "strict": true,
    // si se usa webpack 2+ o rollup, para aprovechar el método tree shaking:
    "module": "es2015",
    "moduleResolution": "node"
  }
}

Tenga en cuenta que debe incluir strict: true (o al menos noImpllicitThis: true, que es parte del flag strict) para aprovechar la verificación de tipo para this en los métodos de los componentes, de lo contrario, siempre se tratará como tipo any.

Consulte la documentación de TypeScript para más detalles sobre las opciones del compilador.

Herramientas para desarrollo

Creación de proyectos

Vue CLI 3 puede generar proyectos compatibles con TypeScript. Para comenzar:

# 1. Instalar Vue CLI si aún no lo ha instalado
npm install --global @vue/cli

# 2. Crear un nuevo proyecto, luego seleccione la opción "Manually select features"
vue create mi-proyecto

Soporte en el editor

Para desarrollar aplicaciones usando Vue y TypeScript, se recomienda usar Visual Studio Code, el cual cuenta con soporte nativo para TypeScript. Si usas componentes en modo sigle-file (SFCs), instala la increíble extensión Vetur, que proporciona inferencia de TypeScript dentro del SFC y ofrece una gran cantidad de excelente opciones.

WebStorm también cuenta con soporte nativo para ambos, TypeScript y Vue.

Nota: Vetur es una estupenda herramienta para Vue. Aún si no deseas utilizar TypeScript es una extensión que deberías explorar y añadir al repertorio.

Uso básico

Para que TypeScript infiera adecuadamente los tipos dentro de un componente en Vue, necesitas definir los componentes usando Vue.component o Vue.extend:

import Vue from 'vue'

const Component = Vue.extend({
  // inferencia de tipo habilitada
})

const Component = {
  // aquí NO habrá inferencia de tipos,
  // porque TypeScript no puede inferir que esto son opciones para un componente Vue.
}

Componentes Vue utilizando el modelo Class-Style

Si prefieres una API basada en clases para declarar componentes, puedes usar el decorador oficial vue-class-component:

import Vue from 'vue'
import Component from 'vue-class-component'

// El decorador @Component le indica a la clase que es un componente Vue
@Component({
  // Todas las opciones del componente se definen aquí
  template: '<button @click="onClick">Click!</button>'
})
export default class MyComponent extends Vue {
  // La data inicial puede ser declarada como propiedades de la instancia
  message: string = 'Hello!'

  // Los métodos del componente pueden ser declarado como métodos de la instancia
  onClick (): void {
    window.alert(this.message)
  }
}

Nota: Los decoradores usan una sintaxis especial a través del símbolo @ y se colocan inmediatamente antes de que se decore el código. En la programación orientada a objetos, el patrón decorador (también conocido como Wrapper, nombre alternativo al patrón Adapter) es un patrón de diseño que permite agregar comportamiento a un objeto individual, ya sea estática o dinámicamente, sin afectar el comportamiento de otros objetos de la misma clase. Al momento de redactar este artículo, JavaScript no cuenta con apoyo nativo para decoradores. Existe la propuesta para añadirlo al spec y actualmente se encuentra en el borrador, “Stage 2 Draft / May 23, 2018”.

Aumento de tipos para uso en plug-ins

Los plug-ins pueden agregarse a las propiedades globales/instancia de Vue y a las opciones de los componentes. En estos casos, se necesitan declaraciones de tipo para hacer que los plug-ins se compilen en TypeScript. Afortunadamente, hay una característica de TypeScript para aumentar los tipos existentes llamada aumento de módulos (module augmentation.).

Por ejemplo, para añadir una propiedad a la instancia llamada $myProperty de tipo cadena:

// 1. Asegurate importar 'vue' antes de la declaración aumentada para los tipos
import Vue from 'vue'

// 2. Especifique el archivo con los tipos que desea aumentar 
//    Para el constructor Vue este se encuentra en types/vue.d.ts
declare module 'vue/types/vue' {
  // 3. Utilice la propiedad aumentada en Vue
  interface Vue {
    $myProperty: string
  }
}

Luego de incluir el código anterior como un archivo de declaraciones (algo parecido a my-property.d.ts) en tu proyecto, puedes usar myProperty en la instancia de Vue.

var vm = new Vue()
console.log(vm.$myProperty) // Esto debería compilar sin problema

También puedes declarar propiedades globales adicionales y opciones en los componentes:

import Vue from 'vue'

declare module 'vue/types/vue' {
  // Propiedades Globales pueden ser definidas
  // en la interface `VueConstructor`
  interface VueConstructor {
    $myGlobal: string
  }
}

// ComponentOptions se define en types/options.d.ts
declare module 'vue/types/options' {
  interface ComponentOptions<V extends Vue> {
    myOption?: string
  }
}

Las declaraciones anteriores permiten que el siguiente código pueda ser compilado:

// Propiedad Global
console.log(Vue.$myGlobal)

// Opción adicional
var vm = new Vue({
  myOption: 'Hello'
})

Anotación de tipos para resultados

Debido a la naturaleza circular de los archivos de declaración de Vue, TypeScript puede tener dificultades para inferir los tipos de ciertos métodos. Por esta razón, es posible que deba anotar el tipo del resultado en métodos como render y computed.

import Vue, { VNode } from 'vue'

const Component = Vue.extend({
  data () {
    return {
      msg: 'Hello'
    }
  },
  methods: {
    // necesita una anotación debido al uso de `this` en el resultado
    greet (): string {
      return this.msg + ' world'
    }
  },
  computed: {
    // necesita una anotación
    greeting(): string {
      return this.greet() + '!'
    }
  },
  // `createElement` es inferido pero `render` necesita la anotación
  render (createElement): VNode {
    return createElement('div', this.greeting)
  }
})

Si encuentra que la inferencia de tipo o la resolución del método no funciona, anotar ciertos métodos puede ayudar a resolver estos problemas. Usar la opción --noImplicitAny ayudará a encontrar muchos de estos métodos no anotados.

Nota: Es importante destacar que el uso de tipos no es un requisito para todos los proyectos. Utilizar TypeScript tampoco lo es. Las ventajas son inmensas pero la curva de aprendizaje puede ser atropellada si no se evalúa correctamente al momento de introducirlo en el proyecto o al equipo de trabajo. Tómese su tiempo y no tema en experimentar con esta tecnología.

programación

Funciones Arrow

A continuación les comparto un abstracto de uno de los capítulos que estoy trabajando para un manual sobre JavaScript. Sugerencias y comentarios son bienvenidos.

Funciones Arrow

Anteriormente habíamos mencionado que a través de las funciones anónimas podiamos ahorrarnos el nombre de la función al momento de la declaración. ¿Qué tal si también pudiéramos ahorrarnos utilizar las palabras function y return? ¿Pudiéramos crear algo como esto?:

let myFunction = (){}

Bueno, dicha expresión produce el siguiente error: Uncaught SyntaxError: Unexpected token. El mensaje de error nos proveer una breve idea de lo que necesitamos para que podamos declarar la función. Dicho token o identificador es el famoso fat arrow o función flecha: =>. Para propósitos de claridad le llamaremos función arrow.

let myFunction = () => {}

Las ventajas primordiales de las funciones arrow son las siguientes:

  • Usan menos keywords. Ejemplo:
const myArray = [1, 2, 3];
const squares = myArray.map(x => x * x);
// No necesita utilizar el keyword function ni return

Veamos que significa todo esto a través de ejemplos. De todas esas variables especiales nos concentraremos en this.

Si fuéramos a utilizar todos los keyword que nos ahorramos con el uso de funciones arrow tendríamos algo así.

const myArray = [1, 2, 3];
const squares = myArray.map(function (x) {
  return x * x
});

Veamos como luce finalmente. Lo primero que vamos hacer es remover las palabras innecesarias, function y return.

const squares = myArray.map((x) => {x * x});

Hay ciertas reglas que podemos seguir a la hora de construir funciones arrow. Si solamente tenemos un parámetro, x en este caso, no necesitamos de paréntesis.

const squares = myArray.map(x => {x * x});

Además, en este ejemplo estamos devolviendo una expresión. Por lo tanto otra regla que podemos aplicar es, si la función devuelve solo una expresión, no necesitamos las llaves o corchetes.

const myArray = [1, 2, 3];
const squares = myArray.map(x => x * x);
// resultado de squares es [1, 4, 9]

Hermoso ¿no? Ahora veamos como se afecta el binding usando funciones arrow. Primero repasemos que eso del binding y su importancia.

¿Qué es this?

En JavaScript existe la palabra reservada this, que a su vez es un objeto, y está estrictamente relacionado al uso de funciones. Si deseamos saber que es this solo es necesario ejecutar un console.log(this) para explorar su contenido. El resultado de esto es el objecto window el cual representa el contenido del documento DOM y otras cosas más (funciones, métodos, etc), y solo está disponible en el navegador; es básicamente la raíz por donde se propagan todas las propiedades y objetos. Veamos un ejemplo.

Nota: En node.js no existe el objeto window.

console.log(this === window) // True

El ejemplo anterior claramente muestra que ambas cosas son lo mismo. Si creamos la siguiente variable:

var myName = 'Jaime'

Hacer un console.log de window.myName debe imprimir ‘Jaime’. Te recomiendo hagas el experimento.

Nota: No es un despiste que haya declarado la variable usando var en vez de let o const. El asunto aquí es que las variables declaradas var van directamente al objeto global window pero en cambio let y const están restringidas a un entorno declarativo que no puedes acceder a través del objeto window.

Sigamos con this y las funciones arrow para entender como se afectar el binding. Ya que el valor de this puede cambiar según una función es invocada, o sea, dependiendo del contexto en el cual se llama la función, es posible que confundamos el contenido del objeto. Cuando quizás deseabas acceder ciertas propiedades te das cuenta que estas obteniendo el resultado de otro objeto que muy probablemente no tiene lo que estas buscando o esperando. Recuerda, this es un objecto que va a depender de quien, donde y como se invoque la función. Y esto es importante tenerlo claro para entender como se comporta en las funciones arrow (y en generar cuando programas en JavaScript). Hagamos un ejemplo Franquestein usando la función arrow para calcular cuadrados pero dentro de un objeto (patrón muy común).

A continuación tenemos un objecto que contiene la funcionalidad de crear números al cuadrado. Digamos que se añade un nuevo requisito para sumar 1 a cada cuadrado.

const squares = {
  arr: [1, 2, 3],
  num: function () {
    return this.arr.map(function (x) {
      return (x * x) + this.add()
    })
  },
  add: function () {
    return 1
  }
}

console.log(squares.num())

El código anterior reportara un error indicando que this.add no es una función. Realmente no existe en el contexto de la función o funciones definidas en num, no hay un puente que me pueda llevar de num a add ya que this esta apuntando al objecto window y la función add existe solo en el contexto del objeto squares. Es importante entender esto. Para resolver el problema sin usar funciones arrow solo necesitamos traernos o redirigir this y pegarlo donde lo necesitemos. Eso lo hacemos a través del método bind.

const squares = {
  arr: [1, 2, 3],
  num: function () {
    return this.arr.map(function (x) {
      return (x * x) + this.add()
    }.bind(this))
  },
  add: function () {
    return 1
  }
}

Ahora efectivamente podemos usar la función add dentro de num. Hemos creado el puente utilizando bind. Con el uso de funciones arrows no tenemos que preocuparnos por este binding ya que al usar funciones arrow estas no manejan el binding como tradicionalmente se hace usando function. Como estamos tan entusiasmados con las funciones arrow, vamos a cambiar toda la función num a funciones arrow.

num: () => {
    return this.arr.map((x) => {
      return (x * x) + this.add()
    })
  }

¡HEY, STOP! No todo es color violeta. La documentación oficial indica que las funciones arrow son más adecuadas para funciones no relacionadas a métodos.

const squares = {
  arr: [1, 2, 3],
  num: () => {
    // Error, uso no aduacuado para funciones arrow
    return this.arr.map((x) => {
      return (x * x) + this.add()
    })
  },
  add: () => {
    return 1
  }
}

Finalmente nuestro ejemplo quedaría así:

const squares = {
  arr: [1, 2, 3],
  num: function () {
    return this.arr.map(x => (x * x) + this.add())
  },
  add: () => {
    return 1
  }
}

Si te revienta la cabeza, relax, toma tiempo digerir todo esto. Lo más importante es recordar que el objeto this dependerá de donde, quien y como invoca x o y función y que las funciones arrow utilizan el contexto de this que le ofrece el marco en donde son ejecutadas. Esto nos lleva al próximo tena que tiene que ver mucho con el lexical scoping en JavaScript.

¡Hasta la próxima!

programación

Recordatorio a validar tu código

Respecto a escribir pruebas para tu código (TDD y otros) y validarlo (Integration Testing):

“Entonces, por supuesto, hazlo de otra manera si eso es lo que mantiene tu bote a flote. Pero sé honesto contigo mismo sobre tus razones [de no tener pruebas de validación]. Eventualmente, sea cual sea tu justificación, tu código revelará la historia real.”

Tomado del cierre del artículo Don’t Want to TDD? Don’t TDD. Just Be Honest About Your Reasons.

free topic

Puerto Rico y el Huracán María

Para información de todos aquellos que de alguna forma visitan esta publicación quiero informales que mi país ha sufrido y continua sufriendo la devastación producida por el poderoso huracán, María. A pesar de todo lo publicado en los medios noticiosos internacionales, les puedo notificar de primera mano que Puerto Rico se levanta pero no al ritmo que se espera. Son muchas las situaciones que estamos viviendo (basta con googlear Puerto Rico) y aunque poco a poco nos movemos hacia cierta normalidad el camino no luce muy alentador. Hemos tenido que, por momentos, dejar de escuchar las noticias para poder recibir un poco de descanso ante la ola de situaciones embarazosas que no aportan al bienestar de nuestro país (no abundaré para no entrar en fatiga). Pero dentro de todo lo negativo que surge de este tipo de situaciones, y que se complica debido a nuestra peculiar situación de país, también se confirma que nosotros los boricuas somos una nación con un gran corazón y de espíritu inquebrantable. Desde el que lleva agua a lo más recóndito de nuestra isla hasta aquel que ha tenido de abandonar su tierra en busca de mejores oportunidades en el extranjero, todos y cada uno de nosotros hemos tenido que ajustarnos a nuestro nuevo país. Siempre hay sus excepciones – y a todos esos que han sido estorbo – estoy seguro que su factura llegará. No será fácil reconstruir nuestra infraestructura, no será fácil enfrentar nuestra quebrantanda economía, no será fácil mantenerse en pie de lucha, pero de esta salimos airosos, cueste lo que cueste nos tome lo que nos tenga que tomar. La voluntad está presente. 

programación

Mejor manejo de paquetes en npm

npm es de esas herramientas que una vez usas te das cuenta que has creado una dependencia inmediata. Si eres un JavaScript developer el valor que provee es impresionante. Así mismo podemos perder el hilo de los paquetes que hayamos instalado o estén “fuera de moda”. Hay tres instrucciones que nos pueden proveer luz y control al proceso de manejo de paquetes.

  • list
  • outdated
  • prune

Consejo, nunca actualizes ciegamente las dependencias en tu proyecto. Para saber cuales son los paquetes que hemos instalado de forma global usamos npm list -g --depth=0. Si solo deseamos ver los paquetes de nuestro proyecto omitimos g.

Si deseas discriminar entre los paquetes en producción y development usas --prod y --dev respectivamente.

Ahora viene lo interesante. Para poder visualizar el estatus de las versiones de los paquetes, utilizas npm outdated. Esta opción generará un hermoso listado que indica el nombre de la dependencia, que versión está instalada, cual es la versión que se desea según la configuración de la versión semántica y cuál es la versión más reciente disponible.

Y por último npm prune para limpiar la carpeta de paquetes node_modules. Si le añades --production los paquetes que estén marcados como paquetes de desarrollo serán removidos.

¿Tienes algún consejo para el manejo de paquetes en npm? Déjamelo saber en la sección de comentarios.

programación

Los sabores de Vue.js – Standalone y Runtime-only

Anteriormente hemos hablado como instalar Vue.js para crear nuestras aplicaciones web. A continuación, me gustaría tocar el tema de como funcionan los dos sabores disponibles para crear nuestros componentes y por ende nuestra aplicación. En la documentación de Vue.js estos dos sabores son llamados Full distribution y Runtime-only distribution. Por conveniencia vamos a llamar de ahora en adelante a la versión Full, Standalone. Veamos que las hace especial y cómo podemos sacar mejor provecho a la hora de comenzar nuestro proyecto.

Standalone

Esta es la versión que comúnmente utilizamos cuando empezamos con Vue.js. Aquí encontraremos el compilador y el runtime para ejecutar toda la magia de Vue.js. El compilador es el encargado de transformar todo lo que tenemos en nuestro template a funciones render de JavaScript. Este señor se encarga de hacer “todo el trabajo pesado” por nosotros. Cuando utilizas Vue.js desde tu navegador a través de la etiqueta <script>, básicamente estas cargando el compilador y el runtime.

Aquí lo más importante es recordar que el compilador es el encargado de compilar el html o los templates para hacer el rendering al navegador.

Runtime-only

Esta versión no incluye la opción o la habilidad de compilar in-DOM templates como lo hace la versión Standalone. Para poder mostrar html en el navegador debes hacerlo a través de una función de render. A fin de cuentas así es como lo hace la versión Standalone. En realidad, la única tarea que no podemos realizar con el Runtime es la compilación de templates. Todo lo demás es posible – crear instancias, manejar el Virtual DOM, reactividad, ya sabes, todo menos compilar templates.

Hacer render más allá del navegador

Cuando usas la versión Standalone, esta usa los API disponibles a través del navegador para hacer el rendering. La versión Runtime-only no posee esta habilidad. Pero esta carencia le brinda la flexibilidad de poder hacer rendering en ambientes donde no existe la presencia de un navegador, por el ejemplo, en el servidor. No vayas a pensar que la versión Runtime-only es inferior, por el contrario, esto le permite a Vue.js poder ejecutarse en lugares antes no posible. Proyectos como Weex (similar a React Native) y Nuxt.js (Server-Side Rendering usando Vue.js) son posibles gracias al Runtime. Técnicamente el Runtime es el corazón de Vue.js.

Componentes en un archivo único

Continuando con el tema de fortalezas y desventajas, para proyectos pequeños o prototipos rápidos no hay mejor opción que usar la versión Standalone. Ya cuando el proyecto haya crecido suficiente o entiendas que es de una complejidad moderada lo mejor es usar directamente el Runtime. Ahora bien y como ya hemos mencionado, la única mejor manera de usar el Runtime es a través del Vue-cli y usar Single File Components. El problema con los templates es que terminas escribiendo CSS o HTML dentro de un archivo JavaScript, a lo JSX, para arreglar las cosas del HTML en el JavaScript. Aquí es donde Vue.js se destaca de los demás. Los componentes de un solo archivo de Vue es probablemente una gran solución, que te permite poner todo lo relacionado a un componente en un solo lugar resolviendo un gran número de decisiones en torno a la arquitectura de componentes.

Un asunto a considerar es si deseas moverte de usar la versión Standalone a usar solo el Runtime. Ir del código en versión Runtime-only a Standalone es un paseo, técnicamente le has hecho un favor al compilador. Ahora bien, para ir viceversa, de Standalone a Runtime-only tendrás que rescribir todos los componentes para usar funciones render.

Ejemplos

El artículo 7 Ways To Define A Component Template in Vue.js contiene excelentes ejemplos de como crear componentes en Vue.js. No los copiaré aquí pero en resumen los ejemplos de 1-4 usan la versión Standalone y los ejemplos 5-7 usan solo el Runtime.

De no tener claro las ventajas y desventajas de ambos sabores, no dudes en comentarlo.

diseño

Conectar Vue.js a una base de datos

Cuento largo corto es que no es posible ir directamente de Vue.js a la base de datos. Pero en este caso no debemos aceptar un simple “no es posible” como respuesta. Veamos el porque no es posible.

El manejo de la base de datos en una aplicación web no es un problema pertinente o relativo a las funciones de Vue.js, la creación de interfaces de usuario, por lo tanto es un problema que Vue.js no resuelve como framework. Simplemente no es para eso. Para comprender porque no es posible ir de Vue.js directamente a una base de datos vamos a definir que pasos necesitamos para llevar la data de x aplicación hasta la pantalla del usuario. Si usted ya conoce esta historia o está familiarizado con el proceso, no descubrirá nada nuevo aquí, así que le recomiendo continuar navegando por el blog.

Para poder conectarse a una base de datos usted necesita una aplicación del lado del servidor. Por ejemplo, para conectarse a su base de datos Mysql puede utilizar, PHP, Node.js o .Net Core. Todo esto puede estar instalado en un servidor o en varios. Con estas herramientas crearas los que se conoce como un API. El API se encargará de exponer la data. Ya que Vue.js es una aplicación del lado del cliente (vive en su navegador) y Mysql es una aplicación del lado del servidor usted necesitará de un mecanismo del lado del servidor para poderse conectar a su base de datos a través del API creado. Este mecanismo puede ser a través de llamadas REST usando como canal el protocolo HTTP. En Vue.js puedes manejar y/o consumir llamadas tipo REST pero lo que necesitas es poder crear estos recursos (API) para que Vue.js o cualquier herramienta pueda consumirlos.

En resumen, Vue.js se ejecuta en la parte del cliente, dentro del navegador (front-end). La parte de la base de datos se ejecuta en el servidor (back-end). Desde Vue.js puedes accesar los datos de la base de datos usando como mecanismo el protocolo HTTP. Para esto creas llamadas usando Ajax desde el cliente y así puedes consumir los datos de la base de datos a través de un API. Recuerda, estos datos se manejan en el servidor a través de un HTTP server que expone la data como un API al cliente. Este API se encarga de manejar la seguridad y todo lo necesario para mostrar la data de forma accesible al cliente en este caso Vue.js. Pero es lo mismo para React, Angular, Aurelia, etc.

tecnología

Git Bash vs Git CMD

Hablemos un poco sobre Git-Bash vs Git-CMD. En Windows cada instalación de Git añade tres elementos básicos:

  • Git Bash
  • Git CMD
  • Git GUI

Para aclarar la curiosidad repasemos que son cada una de estas opciones.

Git GUI

Git GUI es la más fácil, es el editor gráfico nativo que provee Git. Confieso que no uso esta herramienta ya que prefiero SourceTree y como segunda opción GitHub Desktop. Pero de vez en cuando juego con ella y no está nada mal.

Git CMD

El único propósito de Git CMD es podamos utilizar Git desde el terminal de Windows. Suena obvio pero para entender porque existe debemos acordarnos que las cosas funcionas diferente en Windows. Git es una herramienta que nace en el corazón del desarrollo de Linux. Para poder proveer la portabilidad de Git entre ambos sistemas, Git CMD provee un elegante wrapper que le permite a los desarrolladores de Windows seguir usando el CMD sin necesidad de brincar a otro Shell. Ahora, la próxima vez que tengas que instalar Git en Windows podrás entender un poco mejor la siguiente imagen:

Windows Git Setup

Si nunca has usado Git CMD no necesitaras de esta opción en la instalación.

Git Bash

Git Bash le permitirá usar herramientas MinGW/Linux Bash con Git en la línea de comandos. Todas esas cosas bonitas que se hacen en Linux también las podemos hacer en Windows a través de Git Bash.

Si usas VSCode hay manera de configurarlo para usarlo desde el editor.

diseño

Incorporar SASS en Vue.js

Comenzar un proyecto usando Vue.js es bien fácil. A través del vue-cli tenemos lo básico para arrancar de inmediato. Una de las opciones que incluye esta configuración es la habilidad de poder utilizar SASS o SCSS en tu proyecto. En resumen, SASS/SCSS es el siguiente paso, una vez nos sintamos cómodos con CSS, para poder construir hojas de estilo manejables y de fácil mantenimiento. Para poder aprovechar dicho funcionamiento debes añadir los módulos: npm install sass-loader node-sass –save-dev.

En el siguiente ejemplo, hemos incorporado elementos escritos en SASS de la librería Bulma a un componente de Vue.js.

<template>
  <div id="app">
    <a class="button is-active">Hello</a>
    <a class="button is-primary">Primary button</a>
  </div>
</template>

<script>
export default {
  name: 'app'
}
</script>

<style lang="scss" scope>
  @import '../node_modules/bulma/sass/utilities/_all.sass';
  @import '../node_modules/bulma/sass/elements/button.sass';
</style>

Utilizando el atributo lang le estamos indicando a Webpack que procese los archivos .sass y los compile a CSS. Si te preguntas cual es la diferencia entre SASS y SCSS… pues la primordial es la sintaxis como se escriben las reglas de estilo. SASS utiliza espacios e indentación para organizar las reglas (similar a HAML) y SCSS es más expresivo, la sintaxis es similar a vanilla CSS.

Recuerda, utilizar SASS en tu proyecto es opcional. Pero cualquier opción que ayude a mejorar la claridad de código y aporte al mantenimiento del mismo debe ser considerado.

tecnología

Cómo configurar Git Bash en VSCode

VSCode es una joya. Con la opción de poder levantar un terminal en el mismo editor mi corazón de developer se siente más que agradecido. Pero, la opción por default que ofrece es Powershell. No tengo nada en contra de Powershell pero mi corazón pertenece a Git Bash. Lo mejor de VSCode es que lo podemos adaptar a nuestro gusto y necesidad. Hagamos el cambio para usar poder disfrutar de Git Bash en VSCode.

Primero vamos al área de los settings. File > Preferences > Settings. Para facilitar la búsqueda entre los cientos de settings disponibles VSCode provee una barra de búsqueda en la parte superior donde se encuentran las distintas opciones, Search Settings. Con solo escribir Shell será suficiente. Ahora necesitamos modificar las siguientes dos opciones.

// The path of the shell that the terminal uses on Windows. When using shells shipped with Windows (cmd, PowerShell or Bash on Ubuntu), prefer C:\Windows\sysnative over C:\Windows\System32 to use the 64-bit versions.
 "terminal.integrated.shell.windows": "C:\\WINDOWS\\Sysnative\\WindowsPowerShell\\v1.0\\powershell.exe",

  // The command line arguments to use when on the Windows terminal.
  "terminal.integrated.shellArgs.windows": [],

Vamos a cambiar dichas propiedades de la siguiente manera:

  "terminal.integrated.shell.windows": "C:\\Program Files\\Git\\bin\\bash.exe",
  "terminal.integrated.shellArgs.windows": [
    "--init-file",
    "C:\\Program Files\\Git\\etc\\profile"
  ]

Recuerda que con tan solo hacer clic en el lápiz la propiedad se copia a tu archivo settings.json. Una vez hagas el cambio todo esta listo. Presionas Ctrl + ` y ya tienes Git Bash en la terminal de VSCode.