{"id":13554203,"url":"https://github.com/paolocarrasco/javascript-style-guide","last_synced_at":"2026-01-10T17:15:35.451Z","repository":{"id":11540338,"uuid":"14025275","full_name":"paolocarrasco/javascript-style-guide","owner":"paolocarrasco","description":"Guía de Estilo para programar con JavaScript, en español. Apoyo es bienvenido :)","archived":false,"fork":false,"pushed_at":"2020-03-21T02:56:16.000Z","size":168,"stargazers_count":575,"open_issues_count":0,"forks_count":148,"subscribers_count":45,"default_branch":"master","last_synced_at":"2024-11-04T02:32:50.272Z","etag":null,"topics":["es5","es6","javascript","styleguide"],"latest_commit_sha":null,"homepage":"https://paolocarrasco.github.io/javascript-style-guide/","language":null,"has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/paolocarrasco.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2013-10-31T18:36:46.000Z","updated_at":"2024-11-01T23:46:11.000Z","dependencies_parsed_at":"2022-09-05T19:41:12.682Z","dependency_job_id":null,"html_url":"https://github.com/paolocarrasco/javascript-style-guide","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/paolocarrasco%2Fjavascript-style-guide","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/paolocarrasco%2Fjavascript-style-guide/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/paolocarrasco%2Fjavascript-style-guide/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/paolocarrasco%2Fjavascript-style-guide/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/paolocarrasco","download_url":"https://codeload.github.com/paolocarrasco/javascript-style-guide/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":246947967,"owners_count":20859351,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["es5","es6","javascript","styleguide"],"created_at":"2024-08-01T12:02:42.037Z","updated_at":"2026-01-10T17:15:35.392Z","avatar_url":"https://github.com/paolocarrasco.png","language":null,"readme":"# Airbnb JavaScript Style Guide() {\n\n*Un enfoque altamente razonable para JavaScript*\n\n\u003e **Nota**: Esta guía asume que usas [Babel](https://babeljs.io), adicionalmente de tener instalado [babel-preset-airbnb](https://npmjs.com/babel-preset-airbnb) o su equivalente. También asume que tienes instalado shims/pollyfills en tu aplicación, con \n[airbnb-browser-shims](https://npmjs.com/airbnb-browser-shims) o su equivalente.\n\n[![Downloads](https://img.shields.io/npm/dm/eslint-config-airbnb.svg)](https://www.npmjs.com/package/eslint-config-airbnb)\n[![Downloads](https://img.shields.io/npm/dm/eslint-config-airbnb-base.svg)](https://www.npmjs.com/package/eslint-config-airbnb-base)\n[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/airbnb/javascript?utm_source=badge\u0026utm_medium=badge\u0026utm_campaign=pr-badge)\n\nOtras Guías de Estilos\n- [ES5](es5/) (Obsoleto)\n- [React](https://github.com/agrcrobles/javascript/tree/master/react)\n- [CSS-in-JavaScript](https://github.com/airbnb/javascript/tree/master/css-in-javascript/)\n- [CSS \u0026 SASS](https://github.com/ismamz/css)\n- [Ruby](https://github.com/airbnb/ruby)\n\n## Tabla de Contenido\n\n  1. [Tipos](#tipos)\n  1. [Referencias](#referencias)\n  1. [Objetos](#objetos)\n  1. [Arreglos](#arreglos)\n  1. [Destructuring](#destructuring)\n  1. [Cadenas de Texto](#cadenas-de-texto)\n  1. [Funciones](#funciones)\n  1. [Notación de Funciones de Flecha](#notación-de-funciones-de-flecha)\n  1. [Clases y Constructores](#clases-y-constructores)\n  1. [Módulos](#módulos)\n  1. [Iteradores y Generadores](#iteradores-y-generadores)\n  1. [Propiedades](#propiedades)\n  1. [Variables](#variables)\n  1. [Hoisting](#hoisting)\n  1. [Expresiones de comparación e igualdad](#expresiones-de-comparación-e-igualdad)\n  1. [Bloques](#bloques)\n  1. [Comentarios](#comentarios)\n  1. [Espacios en blanco](#espacios-en-blanco)\n  1. [Comas](#comas)\n  1. [Puntos y Comas](#puntos-y-comas)\n  1. [Casting de Tipos y Coerción](#casting-de-tipos-y-coerción)\n  1. [Convenciones de nomenclatura](#convenciones-de-nomenclatura)\n  1. [Funciones de Acceso](#funciones-de-acceso)\n  1. [Eventos](#eventos)\n  1. [jQuery](#jquery)\n  1. [Compatibilidad con EcmaScript 5](#compatibilidad-con-ecmascript-5)\n  1. [Estilos de EcmaScript6+ (ES2015+)](#estilos-de-ecmascript6-es-2015)\n  1. [Pruebas](#pruebas)\n  1. [Desempeño](#desempeño)\n  1. [Recursos](#recursos)\n  1. [En la cancha](#en-la-cancha)\n  1. [Traducciones](#traducciones)\n  1. [La guía de la Guía de Estilos JavaScript](#la-guía-de-la-guía-de-estilos-de-javascript)\n  1. [Charla con nosotros sobre Javascript](#charla-con-nosotros-sobre-javascript)\n  1. [Colaboradores](#colaboradores)\n  1. [Licencia](#licencia)\n\n## Tipos\n\n  - **Primitivos**: Cuando accedes a un tipo primitivo, manejas directamente su valor\n\n    + `string`\n    + `number`\n    + `boolean`\n    + `null`\n    + `undefined`\n\n    ```javascript\n    const foo = 1;\n    let bar = foo;\n\n    bar = 9;\n\n    console.log(foo, bar); // =\u003e 1, 9\n    ```\n  - **Complejo**: Cuando accedes a un tipo complejo, manejas la referencia a su valor.\n\n    + `object`\n    + `array`\n    + `function`\n\n    ```javascript\n    const foo = [1, 2];\n    const bar = foo;\n\n    bar[0] = 9;\n\n    console.log(foo[0], bar[0]); // =\u003e 9, 9\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n## Referencias\n  - Usa `const` para todas tus referencias; evita usar `var`.\n  \u003e ¿Por qué? Esto asegura que no reasignes tus referencias, lo\n  que puede llevar a bugs y dificultad para comprender el código.\n\n  ```javascript\n  // mal\n  var a = 1;\n  var b = 2;\n\n  // bien\n  const a = 1;\n  const b = 2;\n  ```\n\n  - Si vas a reasignar referencias, usa `let` en vez de `var`.\n  \u003e ¿Por qué? El bloque `let` es de alcance a nivel de bloque a\n  diferencia del alcance a nivel de función de `var`.\n\n  ```javascript\n  // mal\n  var count = 1;\n  if (true) {\n    count += 1;\n  }\n\n  // bien, usa el let\n  let count = 1;\n  if (true) {\n    count += 1;\n  }\n  ```\n\n  - Nota que tanto `let` como `const` tienen alcance a nivel de bloque.\n\n  ```javascript\n  // const y let solo existen en los bloques donde\n  // estan definidos\n  {\n    let a = 1;\n    const b = 1;\n  }\n  console.log(a); // ReferenceError\n  console.log(b); // ReferenceError\n  ```\n\n## Objetos\n\n  - Usa la sintaxis literal para la creación de un objeto.\n\n    ```javascript\n    // mal\n    const item = new Object();\n\n    // bien\n    const item = {};\n    ```\n\n  - No uses [palabras reservadas](http://es5.github.io/#x7.6.1) para nombres de propiedades. No funciona en IE8 [Más información](https://github.com/airbnb/javascript/issues/61). No hay problema de usarlo en módulos de ES6 y en código de servidor.\n\n    ```javascript\n    // mal\n    const superman = {\n      default: { clark: 'kent' },\n      private: true\n    };\n\n    // bien\n    const superman = {\n      defaults: { clark: 'kent' },\n      hidden: true\n    };\n    ```\n\n  - Usa sinónimos legibles en lugar de palabras reservadas.\n\n    ```javascript\n    // mal\n    const superman = {\n      class: 'alien'\n    };\n\n    // mal\n    const superman = {\n      klass: 'alien'\n    };\n\n    // bien\n    const superman = {\n      type: 'alien'\n    };\n    ```\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n## Arreglos\n\n  - Usa la sintaxis literal para la creación de arreglos\n\n    ```javascript\n    // mal\n    const items = new Array();\n\n    // bien\n    const items = [];\n    ```\n\n  - Usa Array#push, en vez de asignación directa, para agregar elementos a un arreglo.\n\n    ```javascript\n    const someStack = [];\n\n    // mal\n    someStack[someStack.length] = 'abracadabra';\n\n    // bien\n    someStack.push('abracadabra');\n    ```\n\n  - Usa [spread de arrays](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Operadores/Spread_operator) para copiar arreglos.\n\n    ```javascript\n    const len = items.length;\n    const itemsCopy = [];\n    let i;\n\n    // mal\n    for (i = 0; i \u003c len; i++) {\n      itemsCopy[i] = items[i];\n    }\n\n    // bien\n    const itemsCopy = [...items];\n    ```\n\n  - Para convertir un objeto [\"array-like\" (similar a un arreglo)](https://www.inkling.com/read/javascript-definitive-guide-david-flanagan-6th/chapter-7/array-like-objects) a un arreglo, usa Array#from.\n\n    ```javascript\n    const foo = document.querySelectorAll('.foo');\n    const nodes = Array.from(foo);\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n## Destructuring\n\n  - Usa object destructuring cuando accedas y uses múltiples propiedades de un objeto.\n\n    \u003e ¿Por qué? Destructuring te ahorra crear referencias temporales para esas propiedades.\n\n    ```javascript\n    // mal\n    function getFullName(user) {\n      const firstName = user.firstName;\n      const lastName = user.lastName;\n\n      return `${firstName} ${lastName}`;\n    }\n\n    // bien\n    function getFullName(user) {\n      const { firstName, lastName } = user;\n      return `${firstName} ${lastName}`;\n    }\n\n    // mejor\n    function getFullName({ firstName, lastName }) {\n      return `${firstName} ${lastName}`;\n    }\n    ```\n\n  - Usa array destructuring.\n\n    ```javascript\n    const arr = [1, 2, 3, 4];\n\n    // mal\n    const first = arr[0];\n    const second = arr[1];\n\n    // bien\n    const [first, second] = arr;\n    ```\n\n  - Usa object destructuring para múltiple valores de retorno, no array destructuring.\n\n    \u003e ¿Por qué? Puedes agregar nuevas propiedades en el tiempo o cambiar el orden de las cosas sin afectar la forma en que se llama.\n\n    ```javascript\n    // mal\n    function processInput(input) {\n      // then a miracle occurs\n      return [left, right, top, bottom];\n    }\n\n    // el que llama necesita pensar en el orden de la data de retorno\n    const [left, __, top] = processInput(input);\n\n    // bien\n    function processInput(input) {\n      // then a miracle occurs\n      return { left, right, top, bottom };\n    }\n\n    // el que llama elige solo la data que necesita\n    const { left, top } = processInput(input);\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n\n## Cadenas de Texto\n\n  - Usa comillas simples `''` para las cadenas de texto\n\n    ```javascript\n    // mal\n    const name = \"Bob Parr\";\n\n    // bien\n    const name = 'Bob Parr';\n    ```\n\n  - Las cadenas de texto con una longitud mayor a 100 caracteres deben ser escritas en múltiples líneas usando concatenación.\n\n  \u003e **Nota:** Cuando se usa sin criterio, las cadenas de texto largas pueden impactar en el desempeño. [jsPerf](http://jsperf.com/ya-string-concat) \u0026 [Discusión](https://github.com/airbnb/javascript/issues/40)\n\n  ```javascript\n  // mal\n  var errorMessage = 'This is a super long error that was thrown because of Batman. When you stop to think about how Batman had anything to do with this, you would get nowhere fast.';\n\n  // bien\n  var errorMessage = 'This is a super long error that was thrown because\\\n  of Batman. When you stop to think about how Batman had anything to do \\\n  with this, you would get nowhere fast.';\n\n  // bien\n  var errorMessage = 'This is a super long error that was thrown because' +\n    'of Batman. When you stop to think about how Batman had anything to do ' +\n    'with this, you would get nowhere fast.';\n  ```\n\n  - Cuando se crean cadenas de texto de forma programática, usa template strings (cadena de plantillas) en vez de concatenación.\n\n  \u003e ¿Por qué? Los template strings te dan mayor legibilidad, sintaxis concisa con nuevas líneas apropiadas y capacidades de interpolación.\n\n  ```javascript\n  // mal\n  function sayHi(name) {\n    return 'How are you, ' + name + '?';\n  }\n\n  // mal\n  function sayHi(name) {\n    return ['How are you, ', name, '?'].join();\n  }\n\n  // bien\n  function sayHi(name) {\n    return `How are you, ${name}?`;\n  }\n  ```\n\n  - Nunca uses `eval()` en una cadena de texto, abre una caja de Pandora de vulnerabilidades.\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n\n## Funciones\n\n  - Usa declaración de función en vez de expresiones de función.\n\n  \u003e ¿Por qué? Las declaraciones de función son nombradas, por lo que son más sencillas de identificar en las pilas de llamadas. Además todo el contenido de una declaración de función es *hoisted*, mientras que solo la referencia de una expresión de función es *hoisted*. Esta regla hace posible que siempre se usen [Arrow Functions](#notación-de-funciones-de-flecha) en vez de las funciones de expresión.\n\n  ```javascript\n   // mal\n   const foo = function () {\n   };\n\n   // bien\n   function foo() {\n   }\n   ```\n\n  - Nunca declares una función en un bloque que no sea de función (if, while, etc). En vez de ello, asigna la función a una variable. Los navegadores te permitirán hacerlo pero todos ellos lo interpretarán de modo diferente, lo que es lamentable.\n\n  \u003e **Nota:** ECMA-262 define un bloque como una lista de sentencias. Una declaración de función no es una sentencia. [Lee la nota de ECMA-262 sobre este inconveniente](http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf#page=97).\n\n  ```javascript\n  // mal\n  if (currentUser) {\n    function test() {\n      console.log('Nope.');\n    }\n  }\n\n  // bien\n  let test;\n  if (currentUser) {\n    test = () =\u003e {\n      console.log('Yup.');\n    };\n  }\n  ```\n\n  - Nunca nombres a un parámetro como `arguments`, esto tendrá precedencia sobre el objeto `arguments` que es brindado en cada ámbito de función.\n\n    ```javascript\n    // mal\n    function nope(name, options, arguments) {\n      // ...algo...\n    }\n\n    // bien\n    function yup(name, options, args) {\n      // ...algo...\n    }\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n## Notación de Funciones de Flecha\n\n  - Cuando debas usar funciones anónimas (como cuando pasas un callback inline), usa la notación de funciones de flecha.\n\n    \u003e ¿Por qué? Crea una versión de la función que ejecuta en el contexto de `this`, lo que usualmente es lo que deseas, además que tiene una sintaxis más concisa.\n\n    \u003e ¿Por qué no? Si tienes una función complicada, debes mover esa lógica fuera de su expresión de función nombrada.\n\n    ```javascript\n    // mal\n    [1, 2, 3].map(function (x) {\n      const y = x + 1;\n      return x * y;\n    });\n\n    // bien\n    [1, 2, 3].map((x) =\u003e {\n      const y = x + 1;\n      return x * y;\n    });\n    ```\n\n  - Si el cuerpo de la función consiste en una sola sentencia retornando una [expresión](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Expressions) sin efectos colaterales, omite las llaves y usa el retorno implícito.\n  De otro modo, mantén las llaves y usa una sentencia de retorno.\n\n    \u003e ¿Por qué? Un edulcorante sintáctico. Se lee bien cuando múltiples funciones están encadenadas entre sí.\n\n    ```javascript\n    // mal\n    [1, 2, 3].map(number =\u003e {\n      const nextNumber = number + 1;\n      `A string containing the ${nextNumber}.`;\n    });\n\n    // bien\n    [1, 2, 3].map(number =\u003e `A string containing the ${number}.`);\n\n    // bien\n    [1, 2, 3].map((number) =\u003e {\n      const nextNumber = number + 1;\n      return `A string containing the ${nextNumber}.`;\n    });\n\n    // bien\n    [1, 2, 3].map((number, index) =\u003e ({\n      [index]: number,\n    }));\n\n    // Sin efectos colaterales para retorno implícito\n    function foo(callback) {\n      const val = callback();\n      if (val === true) {\n        // Do something if callback returns true\n      }\n    }\n\n    let bool = false;\n\n    // mal\n    foo(() =\u003e bool = true);\n\n    // bien\n    foo(() =\u003e {\n      bool = true;\n    });\n    ```\n\n  - En caso que la expresión se expanda en varias líneas, envuélvela en paréntesis para una mejor legibilidad.\n\n    \u003e ¿Por qué? Se observa claramente dónde empieza y termina la función.\n\n    ```javascript\n    // mal\n    ['get', 'post', 'put'].map(httpMethod =\u003e Object.prototype.hasOwnProperty.call(\n        httpMagicObjectWithAVeryLongName,\n        httpMethod,\n      )\n    );\n\n    // bien\n    ['get', 'post', 'put'].map(httpMethod =\u003e (\n      Object.prototype.hasOwnProperty.call(\n        httpMagicObjectWithAVeryLongName,\n        httpMethod,\n      )\n    ));\n    ```\n\n  - Si tu función tiene un solo argumento y no usa llaves, omite los paréntesis. De otra forma, siempre incluye paréntesis alrededor de los argumentos por claridad y consistencia.\n  Nota: es también aceptable siempre usar paréntesis, en cuyo caso usa la [opción de \"always\"](https://eslint.org/docs/rules/arrow-parens#always) para eslint o no incluyas [`disallowParenthesesAroundArrowParam`](http://jscs.info/rule/disallowParenthesesAroundArrowParam) para jscs.\n\n    \u003e ¿Por qué? Menos basura visual.\n\n    ```javascript\n    // mal\n    [1, 2, 3].map((x) =\u003e x * x);\n\n    // bien\n    [1, 2, 3].map(x =\u003e x * x);\n\n    // bien\n    [1, 2, 3].map(number =\u003e (\n      `A long string with the ${number}. It’s so long that we don’t want it to take up space on the .map line!`\n    ));\n\n    // mal\n    [1, 2, 3].map(x =\u003e {\n      const y = x + 1;\n      return x * y;\n    });\n\n    // bien\n    [1, 2, 3].map((x) =\u003e {\n      const y = x + 1;\n      return x * y;\n    });\n    ```\n\n  - Evita confundir la sintaxis de función de flecha (`=\u003e`) con los operadores de comparación (`\u003c=`, `\u003e=`).\n\n    ```javascript\n    // mal\n    const itemHeight = item =\u003e item.height \u003e 256 ? item.largeSize : item.smallSize;\n\n    // mal\n    const itemHeight = (item) =\u003e item.height \u003e 256 ? item.largeSize : item.smallSize;\n\n    // bien\n    const itemHeight = item =\u003e (item.height \u003e 256 ? item.largeSize : item.smallSize);\n\n    // bien\n    const itemHeight = (item) =\u003e {\n      const { height, largeSize, smallSize } = item;\n      return height \u003e 256 ? largeSize : smallSize;\n    };\n    ```\n\n**[⬆ regresar a la Tabla de Contenido](#tabla-de-contenido)**\n\n## Clases y Constructores\n\n  - Siempre usa `class`. Evita manipular `prototype` directamente.\n\n    \u003e ¿Por qué? La sintaxis `class` es más concisa y fácil con la cual lidiar.\n\n    ```javascript\n    // mal\n    function Queue(contents = []) {\n      this._queue = [...contents];\n    }\n    Queue.prototype.pop = function () {\n      const value = this._queue[0];\n      this._queue.splice(0, 1);\n      return value;\n    }\n\n    // bien\n    class Queue {\n      constructor(contents = []) {\n        this._queue = [...contents];\n      }\n      pop() {\n        const value = this._queue[0];\n        this._queue.splice(0, 1);\n        return value;\n      }\n    }\n    ```\n\n  - Métodos pueden retornar `this` para ayudar con el encadenamiento de métodos (*chaining*).\n\n    ```javascript\n    // mal\n    Jedi.prototype.jump = function () {\n      this.jumping = true;\n      return true;\n    };\n\n    Jedi.prototype.setHeight = function (height) {\n      this.height = height;\n    };\n\n    const luke = new Jedi();\n    luke.jump(); // =\u003e true\n    luke.setHeight(20); // =\u003e undefined\n\n    // bien\n    class Jedi {\n      jump() {\n        this.jumping = true;\n        return this;\n      }\n\n      setHeight(height) {\n        this.height = height;\n        return this;\n      }\n    }\n\n    const luke = new Jedi();\n\n    luke.jump()\n      .setHeight(20);\n    ```\n\n  - Está bien escribir un método `toString()` personalizado, solo asegúrate que funcione correctamente y no cause efectos colaterales.\n\n    ```javascript\n    class Jedi {\n      constructor(options = {}) {\n        this.name = options.name || 'no name';\n      }\n\n      getName() {\n        return this.name;\n      }\n\n      toString() {\n        return `Jedi - ${this.getName()}`;\n      }\n    }\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n## Módulos\n\n  - Siempre usa módulos (`import`/`export`) antes que un sistema de módulos no estándar. Siempre puedes transpilar a tu sistema de módulos preferido.\n\n    \u003e ¿Por qué? Los módulos son el futuro, comencemos a usar el futuro en el presente.\n\n    ```javascript\n    // mal\n    const AirbnbStyleGuide = require('./AirbnbStyleGuide');\n    module.exports = AirbnbStyleGuide.es6;\n\n    // ok\n    import AirbnbStyleGuide from './AirbnbStyleGuide';\n    export default AirbnbStyleGuide.es6;\n\n    // mejor\n    import { es6 } from './AirbnbStyleGuide';\n    export default es6;\n    ```\n\n  - No uses imports con comodines (asterisco).\n\n    \u003e ¿Por qué? Esto te asegura de tener una única exportación por defecto.\n\n    ```javascript\n    // mal\n    import * as AirbnbStyleGuide from './AirbnbStyleGuide';\n\n    // bien\n    import AirbnbStyleGuide from './AirbnbStyleGuide';\n    ```\n\n  - Y no exportes directamente lo que traigas de un import.\n\n    \u003e ¿Por qué? A pesar que hacer las cosas en una línea es conciso, tener un modo claro de importar y un modo claro de exportar, hace las cosas consistentes.\n\n    ```javascript\n    // mal\n    // filename es6.js\n    export { es6 as default } from './AirbnbStyleGuide';\n\n    // bien\n    // filename es6.js\n    import { es6 } from './AirbnbStyleGuide';\n    export default es6;\n    ```\n\n  - Solo importa de una ruta en un mismo lugar.\n\n    \u003e ¿Por qué? Tener varias líneas que importan de una misma ruta hace al código difícil de mantener.\n\n    ```javascript\n    // mal\n    import foo from 'foo';\n    // … some other imports … //\n    import { named1, named2 } from 'foo';\n\n    // bien\n    import foo, { named1, named2 } from 'foo';\n\n    // bien\n    import foo, {\n      named1,\n      named2,\n    } from 'foo';\n    ```\n\n  - No exportes las asociaciones (bindings) mutables.\n\n    \u003e ¿Por qué? La mutación debe ser evitada en general, pero en particular cuando se exportan asociaciones (bindings) mutables. Mientras esta técnica puede ser necesaria para algunos casos especiales, en general solo referencias constantes deben ser exportadas.\n\n    ```javascript\n    // mal\n    let foo = 3;\n    export { foo };\n\n    // bien\n    const foo = 3;\n    export { foo };\n    ```\n\n  - En módulos con una única exportación, prefiere la exportación por defecto sobre la exportación nombrada.\n\n    \u003e ¿Por qué? Para forzar a que más archivos solo exporten una sola cosa, lo que es mejor para la legibilidad y mantenibilidad.\n\n    ```javascript\n    // mal\n    export function foo() {}\n\n    // bien\n    export default function foo() {}\n    ```\n\n  - Pon todos los `import`s encima de las sentencias de no importación.\n\n    \u003e ¿Por qué? Desde que los `import`s son elevados (hoisted), mantenerlos en el inicio previene comportamientos sorpresivos.\n\n    ```javascript\n    // mal\n    import foo from 'foo';\n    foo.init();\n\n    import bar from 'bar';\n\n    // bien\n    import foo from 'foo';\n    import bar from 'bar';\n\n    foo.init();\n    ```\n\n  - Imports de multi-línea deben ser indentados como los arreglos multi-línea y literales de objeto.\n\n    \u003e ¿Por qué? Las llaves deben seguir las mismas reglas de indentación como en otros bloques de llaves en la guía de estilos, así como las comas finales.\n\n    ```javascript\n    // mal\n    import {longNameA, longNameB, longNameC, longNameD, longNameE} from 'path';\n\n    // bien\n    import {\n      longNameA,\n      longNameB,\n      longNameC,\n      longNameD,\n      longNameE,\n    } from 'path';\n    ```\n\n  - No permitas la sintaxis de carga de Webpack en las sentencias de importación de módulos.\n\n    \u003e ¿Por qué? Debido a que usar la sintaxis de Webpack en los imports acopla el código a un ensamblador de módulos. Prefiere usar aquella sintaxis de carga en el archivo de `webpack.config.js`.\n\n    ```javascript\n    // mal\n    import fooSass from 'css!sass!foo.scss';\n    import barCss from 'style!css!bar.css';\n\n    // bien\n    import fooSass from 'foo.scss';\n    import barCss from 'bar.css';\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n\n## Propiedades\n\n  - Usa la notación de punto `.` cuando accedas a las propiedades.\n\n    ```javascript\n    const luke = {\n      jedi: true,\n      age: 28\n    };\n\n    // mal\n    const isJedi = luke['jedi'];\n\n    // bien\n    const isJedi = luke.jedi;\n    ```\n\n  - Usa la notación subscript `[]` cuando accedas a las propiedades con una variable.\n\n    ```javascript\n    const luke = {\n      jedi: true,\n      age: 28\n    };\n\n    function getProp(prop) {\n      return luke[prop];\n    }\n\n    const isJedi = getProp('jedi');\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n## Variables\n\n  - Siempre usa `const` para declarar constantes o `let` para declarar variables. No hacerlo resultará en variables globales. Debemos evitar contaminar el espacio global (global namespace). El [Capitán Planeta](https://es.wikipedia.org/wiki/Capit%C3%A1n_Planeta_y_los_planetarios) nos advirtió de eso.\n\n    ```javascript\n    // mal\n    superPower = new SuperPower();\n\n    // bien\n    const superPower = new SuperPower();\n\n    o\n\n    // bien\n    let aPower;\n    aPower = new SuperPower(); // esto puede cambiar a otro poder posteriormente\n    ```\n\n  - Usa una declaración `const` o `let` por variable.\n\n    \u003e ¿Por qué? Es más fácil agregar nuevas declaraciones de variables de este modo, y no tendrás que preocuparte por reemplazar `;` por `,` o introducir diffs de sólo puntuación .\n\n    ```javascript\n    // mal\n    const items = getItems(),\n        goSportsTeam = true,\n        dragonball = 'z';\n\n    // mal\n    // (compara con lo de arriba y encuentra el error)\n    const items = getItems(),\n        goSportsTeam = true;\n        dragonball = 'z';\n\n    // bien\n    const items = getItems();\n    const goSportsTeam = true;\n    const dragonball = 'z';\n    ```\n\n  - Agrupa tus `const`s y luego agrupa tus `let`s.\n    \u003e ¿Por qué? Esto es útil cuando necesites asignar una variable luego dependiendo de una de las variables asignadas previamente.\n\n   ```javascript\n   // mal\n   let i, len, dragonball,\n       items = getItems(),\n       goSportsTeam = true;\n\n   // mal\n   let i;\n   const items = getItems();\n   let dragonball;\n   const goSportsTeam = true;\n   let len;\n\n   // bien\n   const goSportsTeam = true;\n   const items = getItems();\n   let dragonball;\n   let i;\n   let length;\n   ```\n\n  - Asigna las variables cuando las necesites, pero ponlas en un lugar razonable.\n    \u003e ¿Por qué? `let` y `const` están a nivel de bloque, no a  nivel de función.\n\n   ```javascript\n   // mal - llamada a funcion innecesaria\n   function checkName(hasName) {\n     const name = getName();\n\n     if (hasName === 'test') {\n       return false;\n     }\n\n     if (name === 'test') {\n       this.setName('');\n       return false;\n     }\n\n     return name;\n   }\n\n   // bien\n   function checkName(hasName) {\n     if (hasName === 'test') {\n       return false;\n     }\n\n     const name = getName();\n\n     if (name === 'test') {\n       this.setName('');\n       return false;\n     }\n\n     return name;\n   }\n   ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n\n## Hoisting\n\n  - Las declaraciones de variables son movidas a la parte superior de su ámbito, sin embargo su asignación no.\n\n    ```javascript\n    // sabemos que esto no funcionara (asumiendo\n    // que no hay una variable global notDefined)\n    function example() {\n      console.log(notDefined); // =\u003e lanza un ReferenceError\n    }\n\n    // crear una declaracion de variable luego\n    // que referencies a la variable funcionara\n    // por el hoisting. Nota: A la asignacion\n    // del valor `true` no se le aplico hoisting.\n    function example() {\n      console.log(declaredButNotAssigned); // =\u003e undefined\n      var declaredButNotAssigned = true;\n    }\n\n    // El interprete lleva la declaracion de la\n    // variable a la parte superior de la funcion.\n    // Eso significa que nuestro ejemplo\n    // podria ser reescrito como:\n    function example() {\n      var declaredButNotAssigned;\n      console.log(declaredButNotAssigned); // =\u003e undefined\n      declaredButNotAssigned = true;\n    }\n    ```\n\n  - Expresiones de función anónimas hacen hoisting de su nombre de variable, pero no de la asignación de la función.\n\n    ```javascript\n    function example() {\n      console.log(anonymous); // =\u003e undefined\n\n      anonymous(); // =\u003e TypeError anonymous is not a function\n\n      var anonymous = function() {\n        console.log('anonymous function expression');\n      };\n    }\n    ```\n\n  - Expresiones de función nombradas hacen hoisting de su nombre de variable, pero no del nombre de la función ni del contenido de la función.\n\n    ```javascript\n    function example() {\n      console.log(named); // =\u003e undefined\n\n      named(); // =\u003e TypeError named is not a function\n\n      superPower(); // =\u003e ReferenceError superPower is not defined\n\n      var named = function superPower() {\n        console.log('Flying');\n      };\n    }\n\n    // lo mismo es cierto cuando el nombre\n    // de la funcion es igual al nombre de\n    // la variable.\n    function example() {\n      console.log(named); // =\u003e undefined\n\n      named(); // =\u003e TypeError named is not a function\n\n      var named = function named() {\n        console.log('named');\n      }\n    }\n    ```\n\n  - Las declaraciones de función hacen hoist de su nombre y del contenido de la función.\n\n    ```javascript\n    function example() {\n      superPower(); // =\u003e Flying\n\n      function superPower() {\n        console.log('Flying');\n      }\n    }\n    ```\n\n  - Para más información lee [JavaScript Scoping \u0026 Hoisting](http://www.adequatelygood.com/2010/2/JavaScript-Scoping-and-Hoisting) por [Ben Cherry](http://www.adequatelygood.com/)\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n\n\n## Expresiones de comparación e igualdad\n\n  - Usa `===` y `!==` en vez de `==` y `!=` respectivamente.\n  - Las expresiones condicionales son evaluadas usando coerción con el método `ToBoolean` y siempre obedecen a estas reglas sencillas:\n\n    + **Objects** son evaluados como **true** (se considera así al objeto vacío `{}` y arreglos sin contenido `[]`)\n    + **Undefined** es evaluado como **false**\n    + **Null** es evaluado como **false**\n    + **Booleans** son evaluados como **el valor del booleano**\n    + **Numbers** son evaluados como **false** si su valor es **+0**, **-0**, o **NaN**, de otro modo **true**\n    + **Strings** son evaluados como **false** si es una cadena de texto vacía `''`, de otro modo son **true**\n\n    ```javascript\n    if ([0] \u0026\u0026 []) {\n      // true\n      // un arreglo es un objeto (incluso uno vacío), los objetos son evaluados como true\n    }\n    ```\n\n  - Usa atajos.\n\n    ```javascript\n    // mal\n    if (name !== '') {\n      // ...cosas...\n    }\n\n    // bien\n    if (name) {\n      // ...cosas...\n    }\n\n    // mal\n    if (collection.length \u003e 0) {\n      // ...cosas...\n    }\n\n    // bien\n    if (collection.length) {\n      // ...cosas...\n    }\n    ```\n\n  - Para más información revisa [Truth Equality and JavaScript](http://javascriptweblog.wordpress.com/2011/02/07/truth-equality-and-javascript/#more-2108) por Angus Croll\n\n  - Usa llaves para crear bloques en cláusulas `case` y `default` que contengan\n  declaraciones léxicas (e.g. `let`, `const`, `function` y `class`).\n\n    \u003e ¿Por qué? La declaración léxica es visible en todo el bloque `switch`\n    pero solo se inicializa al ser asignado, lo que solo ocurre cuando el bloque\n    `case` donde es declarado es alcanzado. Esto causa problemas cuando\n    múltiples bloques `case` intentan definir la misma variable.\n\n\n    ```javascript\n    // mal\n    switch (foo) {\n      case 1:\n        let x = 1;\n        break;\n      case 2:\n        const y = 2;\n        break;\n      case 3:\n        function f() {}\n        break;\n      default:\n        class C {}\n    }\n\n    // bien\n    switch (foo) {\n      case 1: {\n        let x = 1;\n        break;\n      }\n      case 2: {\n        const y = 2;\n        break;\n      }\n      case 3: {\n        function f() {}\n        break;\n      }\n      case 4:\n        bar();\n        break;\n      default: {\n        class C {}\n      }\n    }\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n\n## Bloques\n\n  - Usa llaves con todos los bloques de múltiples líneas.\n\n    ```javascript\n    // mal\n    if (test)\n      return false;\n\n    // bien\n    if (test) return false;\n\n    // bien\n    if (test) {\n      return false;\n    }\n\n    // mal\n    function() { return false; }\n\n    // bien\n    function() {\n      return false;\n    }\n    ```\n\n  - Si estás usando bloques de muchas líneas con ```if``` y ```else```, pon el ```else``` en la misma línea que el ```if```.\n\n    ```javascript\n    // mal\n    if (test) {\n      thing1();\n      thing2();\n    }\n    else {\n      thing3();\n    }\n\n    // bien\n    if (test) {\n      thing1();\n      thing2();\n    } else {\n      thing3();\n    }\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n\n## Comentarios\n\n  - Usa `/** ... */` para comentarios de múltiples líneas. Incluye una descripción, especificación de tipos y valores para todos los parámetros y valores de retorno.\n\n    ```javascript\n    // mal\n    // make() returns a new element\n    // based on the passed in tag name\n    //\n    // @param {String} tag\n    // @return {Element} element\n    function make(tag) {\n\n      // ...stuff...\n\n      return element;\n    }\n\n    // bien\n    /**\n     * make() returns a new element\n     * based on the passed in tag name\n     *\n     * @param {String} tag\n     * @return {Element} element\n     */\n    function make(tag) {\n\n      // ...stuff...\n\n      return element;\n    }\n    ```\n\n  - Usa `//` para comentarios de una sola línea. Ubica los comentarios de una sola línea encima de la sentencia comentada. Deja una línea en blanco antes del comentario, a menos que sea la primera línea de un bloque.\n\n    ```javascript\n    // mal\n    const active = true;  // is current tab\n\n    // bien\n    // is current tab\n    const active = true;\n\n    // mal\n    function getType() {\n      console.log('fetching type...');\n      // set the default type to 'no type'\n      const type = this._type || 'no type';\n\n      return type;\n    }\n\n    // bien\n    function getType() {\n      console.log('fetching type...');\n\n      // set the default type to 'no type'\n      const type = this._type || 'no type';\n\n      return type;\n    }\n    ```\n\n  - Agregando a tus comentarios los prefijos `FIXME` o `TODO`, ayudará a otros desarrolladores a entender rápidamente si estás apuntando a un problema que precisa ser revisado o si estás sugiriendo una solución al problema que debería ser implementado. Estos son diferentes a comentarios regulares en el sentido que requieren alguna acción. Las acciones son `FIXME -- necesito resolver esto` o `TODO -- necesita implementarse`.\n\n  - Usa `// FIXME:` para anotar problemas.\n\n    ```javascript\n    class Calculator extends Abacus {\n      constructor() {\n        super();\n\n        // FIXME: shouldn't use a global here\n        total = 0;\n      }\n    }\n    ```\n\n  - Usa `// TODO:` para anotar soluciones a los problemas.\n\n    ```javascript\n    class Calculator extends Abacus {\n      constructor() {\n        super();\n\n        // TODO: total should be configurable by an options param\n        this.total = 0;\n      }\n    }\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n\n## Espacios en blanco\n\n  - Usa indentaciones blandas (sin TAB)  establecidas en dos espacios.\n\n    ```javascript\n    // mal\n    function foo() {\n    ∙∙∙∙const name;\n    }\n\n    // mal\n    function bar() {\n    ∙const name;\n    }\n\n    // bien\n    function baz() {\n    ∙∙const name;\n    }\n    ```\n  - Deja un espacio antes de la llave de apertura.\n\n    ```javascript\n    // mal\n    function test(){\n      console.log('test');\n    }\n\n    // bien\n    function test() {\n      console.log('test');\n    }\n\n    // mal\n    dog.set('attr',{\n      age: '1 year',\n      breed: 'Bernese Mountain Dog'\n    });\n\n    // bien\n    dog.set('attr', {\n      age: '1 year',\n      breed: 'Bernese Mountain Dog'\n    });\n    ```\n\n  - Deja un espacio antes del paréntesis de apertura en las sentencias de control (```if```, ```while```, etc.). No dejes espacios antes de la lista de argumentos en las invocaciones y declaraciones de funciones.\n    ```javascript\n    // mal\n    if(isJedi) {\n      fight ();\n    }\n\n    // bien\n    if (isJedi) {\n      fight();\n    }\n\n    // mal\n    function fight () {\n      console.log ('Swooosh!');\n    }\n\n    // bien\n    function fight() {\n      console.log('Swooosh!');\n    }\n    ```\n\n  - Separa a los operadores con espacios.\n    ```javascript\n    // mal\n    const x=y+5;\n\n    // bien\n    const x = y + 5;\n    ```\n\n  - Deja una línea en blanco al final del archivo.\n\n    ```javascript\n    // mal\n    (function(global) {\n      // ...algo...\n    })(this);\n    ```\n\n    ```javascript\n    // mal\n    (function(global) {\n      // ...algo...\n    })(this);↵\n    ↵\n\n    ```\n\n    ```javascript\n    // bien\n    (function(global) {\n      // ...algo...\n    })(this);↵\n\n    ```\n\n  - Usa indentación cuando uses métodos largos con 'chaining' (más de dos métodos encadenados). Emplea un punto adelante en cada nueva línea, lo que enfatiza que es un método llamado no una nueva sentencia.\n\n    ```javascript\n    // mal\n    $('#items').find('.selected').highlight().end().find('.open').updateCount();\n\n    // mal\n    $('#items').\n      find('.selected').\n        highlight().\n        end().\n      find('.open').\n        updateCount();\n\n    // bien\n    $('#items')\n      .find('.selected')\n        .highlight()\n        .end()\n      .find('.open')\n        .updateCount();\n\n    // mal\n    const leds = stage.selectAll('.led').data(data).enter().append('svg:svg').class('led', true)\n        .attr('width',  (radius + margin) * 2).append('svg:g')\n        .attr('transform', 'translate(' + (radius + margin) + ',' + (radius + margin) + ')')\n        .call(tron.led);\n\n    // bien\n    const leds = stage.selectAll('.led')\n        .data(data)\n      .enter().append('svg:svg')\n        .class('led', true)\n        .attr('width',  (radius + margin) * 2)\n      .append('svg:g')\n        .attr('transform', 'translate(' + (radius + margin) + ',' + (radius + margin) + ')')\n        .call(tron.led);\n    ```\n\n  - Deja una línea en blanco luego de los bloques y antes de la siguiente sentencia.\n\n    ```javascript\n    // mal\n    if (foo) {\n      return bar;\n    }\n    return baz;\n\n    // bien\n    if (foo) {\n      return bar;\n    }\n\n    return baz;\n\n    // mal\n    const obj = {\n      foo() {\n      },\n      bar() {\n      }\n    };\n    return obj;\n\n    // bien\n    const obj = {\n      foo() {\n      },\n\n      bar() {\n      }\n    };\n\n    return obj;\n\n    // mal\n    const arr = [\n      function foo() {\n      },\n      function bar() {\n      },\n    ];\n    return arr;\n\n    // bien\n    const arr = [\n      function foo() {\n      },\n\n      function bar() {\n      },\n    ];\n\n    return arr;\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n## Comas\n\n  - Comas al inicio de línea: **Nop.**\n\n    ```javascript\n    // mal\n    const story = [\n        once\n      , upon\n      , aTime\n    ];\n\n    // bien\n    const story = [\n      once,\n      upon,\n      aTime,\n    ];\n\n    // mal\n    const hero = {\n        firstName: 'Ada'\n      , lastName: 'Lovelace'\n      , birthYear: 1815\n      , superPower: 'strength'\n    };\n\n    // bien\n    const hero = {\n      firstName: 'Ada',\n      lastName: 'Lovelace',\n      birthYear: 1815,\n      superPower: 'computers',\n    };\n    ```\n\n  - Coma adicional al final: **Sip.**\n  \u003e ¿Por qué? Esto lleva a diferenciales en git más claros. Además los transpiladores como Babel removerán la coma del final en el código transpilado lo que significa que no te tendrás que preocupar del [problema de la coma adicional al final](es5/README.md#commas) en navegadores antiguos.\n\n  ```javascript\n  // mal - git diff sin coma adicional al final\n  const hero = {\n       firstName: 'Florence',\n  -    lastName: 'Nightingale'\n  +    lastName: 'Nightingale',\n  +    inventorOf: ['coxcomb chart', 'modern nursing']\n  };\n\n  // bien - git diff con coma adicional al final\n  const hero = {\n       firstName: 'Florence',\n       lastName: 'Nightingale',\n  +    inventorOf: ['coxcomb chart', 'modern nursing'],\n  };\n\n  // mal\n  const hero = {\n    firstName: 'Dana',\n    lastName: 'Scully'\n  };\n\n  const heroes = [\n    'Batman',\n    'Superman'\n  ];\n\n  // bien\n  const hero = {\n    firstName: 'Dana',\n    lastName: 'Scully',\n  };\n\n  const heroes = [\n    'Batman',\n    'Superman',\n  ];\n  ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n\n## Puntos y Comas\n\n  - **Sip.**\n\n    ```javascript\n    // mal\n    (function () {\n      const name = 'Skywalker'\n      return name\n    })()\n\n    // bien\n    (() =\u003e {\n      const name = 'Skywalker';\n      return name;\n    }());\n\n    // bien, pero arcaico (evita que la funcion se vuelva un argumento\n    // cuando dos archivos con IIFEs sean concatenados)\n    ;(() =\u003e {\n      const name = 'Skywalker';\n      return name;\n    }());\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n\n## Casting de Tipos y Coerción\n\n  - Ejecuta coerción al inicio de una sentencia.\n  - Strings:\n\n    ```javascript\n    //  =\u003e this.reviewScore = 9;\n\n    // mal\n    const totalScore = this.reviewScore + ''; // invoca a this.reviewScore.valueOf()\n\n    // mal\n    const totalScore = this.reviewScore.toString(); // no se garantiza que retorne una cadena de texto\n\n    // bien\n    const totalScore = String(this.reviewScore);\n    ```\n\n  - Números: Usa `Number` para el casting de tipo y `parseInt` siempre con la base numérica para el casting de textos.\n\n    ```javascript\n    const inputValue = '4';\n\n    // mal\n    const val = new Number(inputValue);\n\n    // mal\n    const val = +inputValue;\n\n    // mal\n    const val = inputValue \u003e\u003e 0;\n\n    // mal\n    const val = parseInt(inputValue);\n\n    // bien\n    const val = Number(inputValue);\n\n    // bien\n    const val = parseInt(inputValue, 10);\n    ```\n\n  - Si por alguna razón estás haciendo algo salvaje y `parseInt` es un cuello de botella por lo que necesitaste usar Bitshift por [razones de desempeño](http://jsperf.com/coercion-vs-casting/3), deja un comentario explicando la razón y resumen de lo que estás haciendo.\n\n    ```javascript\n    // bien\n    /**\n     * parseInt was the reason my code was slow.\n     * Bitshifting the String to coerce it to a\n     * Number made it a lot faster.\n     */\n    const val = inputValue \u003e\u003e 0;\n    ```\n\n  \u003e **Nota:** Ten mucho cuidado al hacer operaciones de Bitshift. En Javascript los números son representados como [valores de 64-bit](http://es5.github.io/#x4.3.19), sin embargo las operaciones de Bitshift siempre retornan un entero de 32-bits ([fuente](http://es5.github.io/#x11.7)). Bitshift puede presentarnos un comportamiento inesperado para valores enteros mayores a 32 bits. [Discusión](https://github.com/airbnb/javascript/issues/109). El mayor entero con signo de 32 bits es 2,147,483,647:\n  ```javascript\n  2147483647 \u003e\u003e 0 //=\u003e 2147483647\n  2147483648 \u003e\u003e 0 //=\u003e -2147483648\n  2147483649 \u003e\u003e 0 //=\u003e -2147483647\n  ```\n\n  - Booleans:\n\n    ```javascript\n    const age = 0;\n\n    // mal\n    const hasAge = new Boolean(age);\n\n    // bien\n    const hasAge = Boolean(age);\n\n    // bien\n    const hasAge = !!age;\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n\n## Convenciones de nomenclatura\n\n  - Evita nombres de una sola letra. Sé descriptivo con tus nombres.\n\n    ```javascript\n    // mal\n    function q() {\n      // ...algo...\n    }\n\n    // bien\n    function query() {\n      // ...algo...\n    }\n    ```\n\n  - Usa camelCase cuando nombres tus objetos, funciones e instancias.\n\n    ```javascript\n    // mal\n    const OBJEcttsssss = {};\n    const this_is_my_object = {};\n    const o = {};\n    function c() {}\n\n    // bien\n    var thisIsMyObject = {};\n    function thisIsMyFunction() {}\n    ```\n\n  - Usa PascalCase cuando nombres constructores o clases.\n\n    ```javascript\n    // mal\n    function user(options) {\n      this.name = options.name;\n    }\n\n    const bad = new user({\n      name: 'nope'\n    });\n\n    // bien\n    class User {\n      constructor(options) {\n        this.name = options.name;\n      }\n    }\n\n    const good = new User({\n      name: 'yup',\n    });\n    ```\n\n  - No uses prefijos ni sufijos de guiones bajo.\n  \u003e ¿Por qué? JavaScript no tiene el concepto de privacidad en términos de propiedades o métodos. A pesar que un guión bajo como prefijo es una convención común para indicar que son \"privados\", la realidad es que estas propiedades son absolutamente públicas, y por ello, parte de tu contrato público de API. La convención del prefijo de guión bajo podría orientar a los desarrolladores a pensar erróneamente que un cambio a aquellos no será de impacto o que los tests no son necesarios.\n\n  ```javascript\n  // mal\n  this.__firstName__ = 'Panda';\n  this.firstName_ = 'Panda';\n  this._firstName = 'Panda';\n\n\n  // bien\n  this.firstName = 'Panda';\n  ```\n\n  - Nunca guardes referencias a `this`. Usa funciones arrow o la función [#bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind)\n\n    ```javascript\n    // mal\n    function() {\n      const self = this;\n      return function() {\n        console.log(self);\n      };\n    }\n\n    // mal\n    function() {\n      const that = this;\n      return function() {\n        console.log(that);\n      };\n    }\n\n    // bien\n    function foo() {\n      return () =\u003e {\n        console.log(this);\n      };\n    }\n    ```\n\n  - El nombre del archivo base debe corresponder exactamente con el nombre de su export por defecto.\n\n  ```javascript\n   // contenido archivo 1\n   class CheckBox {\n     // ...\n   }\n   export default CheckBox;\n\n   // contenido archivo 2\n   export default function fortyTwo() { return 42; }\n\n   // contenido archivo 3\n   export default function insideDirectory() {}\n\n   // en algún otro archivo\n   // mal\n   import CheckBox from './checkBox'; // importacion/exportacion PascalCase, nombre de archivo camelCase\n   import FortyTwo from './FortyTwo'; // importacion/nombre de archivo PascalCase, exportacion camelCase\n   import InsideDirectory from './InsideDirectory'; // importacion/nombre de archivo PascalCase, exportacion camelCase\n\n   // mal\n   import CheckBox from './check_box'; // importacion/exportacion PascalCase, nombre de archivo snake_case\n   import forty_two from './forty_two'; // importacion/nombre de archivo snake_case, exportacion camelCase\n   import inside_directory from './inside_directory'; // importacion snake_case, exportacion camelCase\n   import index from './inside_directory/index'; // requiere el archivo de index explicitamente\n   import insideDirectory from './insideDirectory/index'; // requiere el archivo de index explicitamente\n\n   // bien\n   import CheckBox from './CheckBox'; // importacion/exportacion/nombre de archivo PascalCase\n   import fortyTwo from './fortyTwo'; // importacion/exportacion/nombre de archivo camelCase\n   import insideDirectory from './insideDirectory'; // importacion/exportacion/nombre directorio/archivo \"index\" implícito\n   // ^ soporta tanto insideDirectory.js e insideDirectory/index.js\n\n   ```\n\n  - Usa camelCase cuando exportes por defecto una función. Tu nombre de archivo debe ser idéntico al nombre de tu función.\n\n  ```javascript\n  function makeStyleGuide() {\n  }\n\n  export default makeStyleGuide;\n  ```\n\n  - Usa camelCase cuando exportes un objeto constructor / clase / singleton / librería de función / esqueleto.\n  ```javascript\n  const AirbnbStyleGuide = {\n    es6: {\n    }\n  };\n\n  export default AirbnbStyleGuide;\n  ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n\n## Funciones de Acceso\n\n  - Funciones de acceso para las propiedades no son requeridas.\n  - No uses getters/setters de JavaScript ya que causan efectos colaterales no esperados y son difíciles de probar, mantener y razonar. En vez de ello, si creas funciones de acceso usa  ```getVal()``` y ```setVal('hello')```.\n\n     ```javascript\n     // Maintainable-JavaScript-Nicholas-C-Zakas\n     class Dragon {\n       get age() {\n         // ...\n       }\n\n       set age(value) {\n         // ...\n       }\n     }\n\n     // bien\n     class Dragon {\n       getAge() {\n         // ...\n       }\n\n       setAge(value) {\n         // ...\n       }\n     }\n     ```\n\n  - Si la propiedad es un booleano, usa ```isVal()``` o ```hasVal()```.\n\n    ```javascript\n    // mal\n    if (!dragon.age()) {\n      return false;\n    }\n\n    // bien\n    if (!dragon.hasAge()) {\n      return false;\n    }\n    ```\n\n  - Está bien crear funciones ```get()``` y ```set()```, pero sé consistente.\n\n    ```javascript\n    class Jedi {\n      constructor(options = {}) {\n        const lightsaber = options.lightsaber || 'blue';\n        this.set('lightsaber', lightsaber);\n      }\n\n      set(key, val) {\n        this[key] = val;\n      }\n\n      get(key) {\n        return this[key];\n      }\n    }\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n\n## Eventos\n\n  - Cuando envíes paquetes de datos a los eventos (ya sea con eventos del DOM o algo propietario como los eventos de Backbone), pasa un mapa en vez de un valor directo. Esto permitirá a un próximo colaborador a agregar más datos al paquete de datos sin que tenga que encontrar o actualizar un handler para cada evento. Por ejemplo, en vez de:\n\n    ```js\n    // mal\n    $(this).trigger('listingUpdated', listing.id);\n\n    ...\n\n    $(this).on('listingUpdated', (e, listingId) =\u003e {\n      // hacer algo con listingId\n    });\n    ```\n\n    prefiere:\n\n    ```js\n    // bien\n    $(this).trigger('listingUpdated', { listingId : listing.id });\n\n    ...\n\n    $(this).on('listingUpdated', (e, data) =\u003e {\n      // hacer algo con data.listingId\n    });\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n## jQuery\n\n  - Nombre las variables de objetos jQuery con un prefijo `$`.\n\n    ```javascript\n    // mal\n    const sidebar = $('.sidebar');\n\n    // bien\n    const $sidebar = $('.sidebar');\n    ```\n\n  - Guarde en variables los lookups de jQuery que se necesiten posteriormente.\n\n    ```javascript\n    // mal\n    function setSidebar() {\n      $('.sidebar').hide();\n\n      // ...algo...\n\n      $('.sidebar').css({\n        'background-color': 'pink'\n      });\n    }\n\n    // bien\n    function setSidebar() {\n      const $sidebar = $('.sidebar');\n      $sidebar.hide();\n\n      // ...algo...\n\n      $sidebar.css({\n        'background-color': 'pink'\n      });\n    }\n    ```\n\n  - Para consultas de elementos DOM usa el modo Cascada `$('.sidebar ul')` o parent \u003e child `$('.sidebar \u003e ul')`. [jsPerf](http://jsperf.com/jquery-find-vs-context-sel/16)\n  - Usa `find` solo con consultas guardadas en variables previamente.\n\n    ```javascript\n    // mal\n    $('ul', '.sidebar').hide();\n\n    // mal\n    $('.sidebar').find('ul').hide();\n\n    // bien\n    $('.sidebar ul').hide();\n\n    // bien\n    $('.sidebar \u003e ul').hide();\n\n    // bien\n    $sidebar.find('ul');\n    ```\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n\n## Compatibilidad con ECMAScript 5\n\n  - Revisa la [tabla de compatibilidad](http://kangax.github.com/es5-compat-table/) de ES5 de [Kangax](https://twitter.com/kangax/).\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n## Estilos de EcmaScript6+ (ES 2015+)\n\n    - A continuación, un conjunto de enlaces hacia los estilos para las nuevas características de ES6:\n\n  1. [Notación Funciones de Flecha](#arrow-functions)\n  1. [Clases](#classes--constructors)\n  1. [Declaración abreviada para objeto](#es6-object-shorthand)\n  1. [Declaración de objeto concisa](#es6-object-concise)\n  1. [Propiedades computadas de objeto](#es6-computed-properties)\n  1. [Plantillas de texto](#es6-template-literals)\n  1. [Destructuring](#destructuring)\n  1. [Parámetros por defecto](#es6-default-parameters)\n  1. [Rest](#es6-rest)\n  1. [Spreads de arreglos](#es6-array-spreads)\n  1. [Let y Const](#references)\n  1. [Iteradores y Generadores](#iterators-and-generators)\n  1. [Módulos](#modules)\n\n    - No uses [las propuestas de TC39](https://github.com/tc39/proposals) puesto que aún no han llegado a la tercera etapa.\n\n      \u003e ¿Por qué? [No están finalizadas](https://tc39.github.io/process-document/), y están sujetas a cambios o reescritas completamente. Vamos a usar JavaScript y las propuestas aún no son JavaScript.\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n## Pruebas\n\n  - **Sip**.\n\n    ```javascript\n    function foo() {\n      return true;\n    }\n    ```\n\n  - **No, but seriously**:\n   - Cualquiera que sea el framework de testing que emplees, ¡deberías escribir tests!\n   - Esfuérzate por escribir funciones pequeñas y puras, además de minimizar las posibles mutaciones que pudiesen ocurrir.\n   - Sé cuidados con los stubs y los mocks - pueden hacer tus tests más frágiles.\n   - Usamos principalmente [`mocha`](https://www.npmjs.com/package/mocha) en Airbnb. [`tape`](https://www.npmjs.com/package/tape) es también usado ocasionalmente para módulos pequeños y separados.\n   - 100% de cobertura de pruebas es una buena meta a perseguir, a pesar que no es siempre práctico conseguirlo.\n   - Cuando corrijas una incidencia (bug), _escribe una prueba de regresión_. Una incidencia sin una prueba de regresión es casi seguro que volverá a ocurrir en el futuro.\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n## Desempeño\n\n  - [On Layout \u0026 Web Performance](http://kellegous.com/j/2013/01/26/layout-performance/)\n  - [String vs Array Concat](http://jsperf.com/string-vs-array-concat/2)\n  - [Try/Catch Cost In a Loop](http://jsperf.com/try-catch-in-loop-cost)\n  - [Bang Function](http://jsperf.com/bang-function)\n  - [jQuery Find vs Context, Selector](http://jsperf.com/jquery-find-vs-context-sel/13)\n  - [innerHTML vs textContent for script text](http://jsperf.com/innerhtml-vs-textcontent-for-script-text)\n  - [Long String Concatenation](http://jsperf.com/ya-string-concat)\n  - [Are Javascript functions like `map()`, `reduce()`, and `filter()` optimized for traversing arrays?](https://www.quora.com/JavaScript-programming-language-Are-Javascript-functions-like-map-reduce-and-filter-already-optimized-for-traversing-array/answer/Quildreen-Motta)\n  - Loading...\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n\n## Recursos\n\n**Learning ES6**\n\n  - [Draft ECMA 2015 (ES6) Spec](https://people.mozilla.org/~jorendorff/es6-draft.html)\n  - [ExploringJS](http://exploringjs.com/)\n  - [Tabla de compatibilidad de ES6](https://kangax.github.io/compat-table/es6/)\n  - [Vistazo comprensivo de las nuevas características de ES6](http://es6-features.org/)\n\n**Lee esto**\n\n  - [Standard ECMA-262](http://www.ecma-international.org/ecma-262/6.0/index.html)\n\n**Tools**\n\n  Code Style Linters\n  - [JSHint](http://www.jshint.com/) - [Airbnb Style .jshintrc](https://github.com/airbnb/javascript/blob/master/linters/.jshintrc)\n  - [JSCS](https://github.com/jscs-dev/node-jscs) - [Airbnb Style Preset](https://github.com/jscs-dev/node-jscs/blob/master/presets/airbnb.json)\n\n**Otras guías de estilo**\n\n  - [Google JavaScript Style Guide](http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml) (Guía de Estilo de Javascript de Google)\n  - [jQuery Core Style Guidelines](http://docs.jquery.com/JQuery_Core_Style_Guidelines) (Lineamientos de Estilo con el núcleo de jQuery)\n  - [Principles of Writing Consistent, Idiomatic JavaScript](https://github.com/rwldrn/idiomatic.js/) (Idiomatic Javascript: Principios de Escritura Consistente)\n\n**Otros estilos**\n\n  - [Naming this in nested functions](https://gist.github.com/4135065) - Christian Johansen (Nomenclatura en funciones anidadas)\n  - [Conditional Callbacks](https://github.com/airbnb/javascript/issues/52) (Callbacks condicionales)\n  - [Popular JavaScript Coding Conventions on Github](http://sideeffect.kr/popularconvention/#javascript) (Convenciones Populares de Programación con Javascript en Github)\n  - [Multiple var statements in JavaScript, not superfluous](http://benalman.com/news/2012/05/multiple-var-statements-javascript/) - Ben Alman (Múltiples sentencias var en JavaScript, no superfluas)\n\n**Lecturas más profundas**\n\n  - [Understanding JavaScript Closures](http://javascriptweblog.wordpress.com/2010/10/25/understanding-javascript-closures/) - Angus Croll (Entendiendo los Closures de JavaScript)\n  - [Basic JavaScript for the impatient programmer](http://www.2ality.com/2013/06/basic-javascript.html) - Dr. Axel Rauschmayer (JavaScript Básico para el programador impaciente)\n  - [You Might Not Need jQuery](http://youmightnotneedjquery.com/) - Zack Bloom \u0026 Adam Schwartz (Podrías no necesitar jQuery)\n  - [ES6 Features](https://github.com/lukehoban/es6features) - Luke Hoban (Características de ES6)\n  - [Frontend Guidelines](https://github.com/bendc/frontend-guidelines) - Benjamin De Cock (Lineamientos para el Frontend)\n\n**Libros**\n\n  - [JavaScript: The Good Parts](http://www.amazon.com/JavaScript-Good-Parts-Douglas-Crockford/dp/0596517742) - Douglas Crockford (JavaScript: Las Buenas Partes)\n  - [JavaScript Patterns](http://www.amazon.com/JavaScript-Patterns-Stoyan-Stefanov/dp/0596806752) - Stoyan Stefanov (Patrones JavaScript)\n  - [Pro JavaScript Design Patterns](http://www.amazon.com/JavaScript-Design-Patterns-Recipes-Problem-Solution/dp/159059908X)  - Ross Harmes and Dustin Diaz (Patrones de Diseño Avanzados en Javascript)\n  - [High Performance Web Sites: Essential Knowledge for Front-End Engineers](http://www.amazon.com/High-Performance-Web-Sites-Essential/dp/0596529309) - Steve Souders (Sitios Web de Alto Desempeño: Conocimiento Esencial para los Ingenieros de Capa de Presentación)\n  - [Maintainable JavaScript](http://www.amazon.com/Maintainable-JavaScript-Nicholas-C-Zakas/dp/1449327680) - Nicholas C. Zakas (JavaScript Mantenible)\n  - [JavaScript Web Applications](http://www.amazon.com/JavaScript-Web-Applications-Alex-MacCaw/dp/144930351X) - Alex MacCaw (Aplicaciones Web JavaScript)\n  - [Pro JavaScript Techniques](http://www.amazon.com/Pro-JavaScript-Techniques-John-Resig/dp/1590597273) - John Resig (Técnicas Avanzadas JavaScript)\n  - [Smashing Node.js: JavaScript Everywhere](http://www.amazon.com/Smashing-Node-js-JavaScript-Everywhere-Magazine/dp/1119962595) - Guillermo Rauch (Increíble Node.js: JavaScript en todas partes)\n  - [Secrets of the JavaScript Ninja](http://www.amazon.com/Secrets-JavaScript-Ninja-John-Resig/dp/193398869X) - John Resig and Bear Bibeault (Secretos del JavaScript Ninja)\n  - [Human JavaScript](http://humanjavascript.com/) - Henrik Joreteg (JavaScript Humano)\n  - [Superhero.js](http://superherojs.com/) - Kim Joar Bekkelund, Mads Mobæk, \u0026 Olav Bjorkoy (Superhéroe.js)\n  - [JSBooks](http://jsbooks.revolunet.com/) - Julien Bouquillon\n  - [Third Party JavaScript](http://manning.com/vinegar/) - Ben Vinegar and Anton Kovalyov (JavaScript de Terceros)\n  - [Effective JavaScript: 68 Specific Ways to Harness the Power of JavaScript](http://amzn.com/0321812182) - David Herman (JavaScript Efectivo: 68 modos específicos para elevar el poder de JavaScript)\n  - [Eloquent JavaScript](http://eloquentjavascript.net/) - Marijn Haverbeke (JavaScript Elocuente)\n  - [You Don't Know JS: ES6 \u0026 Beyond](http://shop.oreilly.com/product/0636920033769.do) - Kyle Simpson (No sabes JS: ES6 y más allá)\n\n**Blogs**\n\n  - [DailyJS](http://dailyjs.com/)\n  - [JavaScript Weekly](http://javascriptweekly.com/)\n  - [JavaScript, JavaScript...](http://javascriptweblog.wordpress.com/)\n  - [Bocoup Weblog](http://weblog.bocoup.com/)\n  - [Adequately Good](http://www.adequatelygood.com/)\n  - [NCZOnline](http://www.nczonline.net/)\n  - [Perfection Kills](http://perfectionkills.com/)\n  - [Ben Alman](http://benalman.com/)\n  - [Dmitry Baranovskiy](http://dmitry.baranovskiy.com/)\n  - [Dustin Diaz](http://dustindiaz.com/)\n  - [nettuts](http://net.tutsplus.com/?s=javascript)\n\n**Podcasts**\n\n  - [JavaScript Air](https://javascriptair.com/)\n  - [JavaScript Jabber](http://devchat.tv/js-jabber/)\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n## En la cancha\n\n  Esta es una lista de las organizaciones que están usando esta guía de estilo. Envíanos un pull request o abre un issue y te agregaremos a la lista.\n\n  - **Airbnb**: [airbnb/javascript](https://github.com/airbnb/javascript)\n  - **Aan Zee**: [AanZee/javascript](https://github.com/AanZee/javascript)\n  - **American Insitutes for Research**: [AIRAST/javascript](https://github.com/AIRAST/javascript)\n  - **Compass Learning**: [compasslearning/javascript-style-guide](https://github.com/compasslearning/javascript-style-guide)\n  - **DailyMotion**: [dailymotion/javascript](https://github.com/dailymotion/javascript)\n  - **Evernote**: [evernote/javascript-style-guide](https://github.com/evernote/javascript-style-guide)\n  - **ExactTarget**: [ExactTarget/javascript](https://github.com/ExactTarget/javascript)\n  - **Gawker Media**: [gawkermedia/javascript](https://github.com/gawkermedia/javascript)\n  - **GeneralElectric**: [GeneralElectric/javascript](https://github.com/GeneralElectric/javascript)\n  - **GoodData**: [gooddata/gdc-js-style](https://github.com/gooddata/gdc-js-style)\n  - **Grooveshark**: [grooveshark/javascript](https://github.com/grooveshark/javascript)\n  - **How About We**: [howaboutwe/javascript](https://github.com/howaboutwe/javascript)\n  - **Mighty Spring**: [mightyspring/javascript](https://github.com/mightyspring/javascript)\n  - **MinnPost**: [MinnPost/javascript](https://github.com/MinnPost/javascript)\n  - **ModCloth**: [modcloth/javascript](https://github.com/modcloth/javascript)\n  - **National Geographic**: [natgeo/javascript](https://github.com/natgeo/javascript)\n  - **National Park Service**: [nationalparkservice/javascript](https://github.com/nationalparkservice/javascript)\n  - **reddit**: [reddit/styleguide/javascript](https://github.com/reddit/styleguide/tree/master/javascript)\n  - **REI**: [reidev/js-style-guide](https://github.com/reidev/js-style-guide)\n  - **Razorfish**: [razorfish/javascript-style-guide](https://github.com/razorfish/javascript-style-guide)\n  - **Shutterfly**: [shutterfly/javascript](https://github.com/shutterfly/javascript)\n  - **Userify**: [userify/javascript](https://github.com/userify/javascript)\n  - **Zillow**: [zillow/javascript](https://github.com/zillow/javascript)\n  - **ZocDoc**: [ZocDoc/javascript](https://github.com/ZocDoc/javascript)\n\n## Traducciones\n\n  Esta guía de estilo es también disponible en otros lenguajes:\n\n  - ![us](https://raw.githubusercontent.com/gosquared/flags/master/flags/flags/shiny/24/United-States.png) **Inglés (original)**: [airbnb/javascript](https://github.com/airbnb/javascript)\n  - ![br](https://raw.githubusercontent.com/gosquared/flags/master/flags/flags/shiny/24/Brazil.png) **Portugués Brasileño**: [armoucar/javascript-style-guide](https://github.com/armoucar/javascript-style-guide)\n  - ![bg](https://raw.githubusercontent.com/gosquared/flags/master/flags/flags/shiny/24/Bulgaria.png) **Búlgaro**: [borislavvv/javascript](https://github.com/borislavvv/javascript)\n  - ![ca](https://raw.githubusercontent.com/fpmweb/javascript-style-guide/master/img/catala.png) **Catalán**: [fpmweb/javascript-style-guide](https://github.com/fpmweb/javascript-style-guide)\n  - ![tw](https://raw.githubusercontent.com/gosquared/flags/master/flags/flags/shiny/24/Taiwan.png) **Chino (Tradicional)**: [jigsawye/javascript](https://github.com/jigsawye/javascript)\n  - ![cn](https://raw.githubusercontent.com/gosquared/flags/master/flags/flags/shiny/24/China.png) **Chino (Simplificado)**: [sivan/javascript-style-guide](https://github.com/sivan/javascript-style-guide)\n  - ![fr](https://raw.githubusercontent.com/gosquared/flags/master/flags/flags/shiny/24/France.png) **Francés**: [nmussy/javascript-style-guide](https://github.com/nmussy/javascript-style-guide)\n  - ![de](https://raw.githubusercontent.com/gosquared/flags/master/flags/flags/shiny/24/Germany.png) **Alemán**: [timofurrer/javascript-style-guide](https://github.com/timofurrer/javascript-style-guide)\n  - ![it](https://raw.githubusercontent.com/gosquared/flags/master/flags/flags/shiny/24/Italy.png) **Italiano**: [sinkswim/javascript-style-guide](https://github.com/sinkswim/javascript-style-guide)\n  - ![jp](https://raw.githubusercontent.com/gosquared/flags/master/flags/flags/shiny/24/Japan.png) **Japonés**: [mitsuruog/javacript-style-guide](https://github.com/mitsuruog/javacript-style-guide)\n  - ![kr](https://raw.githubusercontent.com/gosquared/flags/master/flags/flags/shiny/24/South-Korea.png) **Coreano**: [tipjs/javascript-style-guide](https://github.com/tipjs/javascript-style-guide)\n  - ![pl](https://raw.githubusercontent.com/gosquared/flags/master/flags/flags/shiny/24/Poland.png) **Polaco**: [mjurczyk/javascript](https://github.com/mjurczyk/javascript)\n  - ![ru](https://raw.githubusercontent.com/gosquared/flags/master/flags/flags/shiny/24/Russia.png) **Ruso**: [uprock/javascript](https://github.com/uprock/javascript)\n  - ![th](https://raw.githubusercontent.com/gosquared/flags/master/flags/flags/shiny/24/Thailand.png) **Tailandés**: [lvarayut/javascript-style-guide](https://github.com/lvarayut/javascript-style-guide)\n  - ![vn](https://raw.githubusercontent.com/gosquared/flags/master/flags/flags/shiny/24/Vietnam.png) **Vietnamita**: [giangpii/javascript-style-guide](https://github.com/giangpii/javascript-style-guide)\n## La guía de la Guía de Estilos de Javascript\n\n  - [Referencia](https://github.com/airbnb/javascript/wiki/The-JavaScript-Style-Guide-Guide)\n\n## Charla con nosotros sobre Javascript\n  - Encuéntranos en [gitter](https://gitter.im/airbnb/javascript).\n\n## Colaboradores\n\n  - [Vea a los colaboradores](https://github.com/airbnb/javascript/graphs/contributors)\n\n\n## Licencia\n\n(The MIT License)\n\nCopyright (c) 2014-2016 Airbnb\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n'Software'), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n**[[⬆ regresar a la Tabla de Contenido]](#tabla-de-contenido)**\n\n## Enmiendas\n\nTe recomendamos hacer fork de esta guía y cambiar las reglas para que se adecúen a la guía de estilos de tu equipo. Abajo podrás encontrar algunas enmiendas a la guía de estilos. Esto te permitirá actualizar periódicamente tu guía de estilos sin tener que lidiar con conflictos al hacer merge.\n\n# };\n","funding_links":[],"categories":["Others"],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpaolocarrasco%2Fjavascript-style-guide","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fpaolocarrasco%2Fjavascript-style-guide","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpaolocarrasco%2Fjavascript-style-guide/lists"}