Siete cosas que deberías dejar de hacer con Node.js

Inspirándome en 5 cosas que deberías dejar de hacer con jQuery de Burke Holland, decidí abrir una discusión y resaltar siete cosas que deberías dejar de hacer inmediatamente con Node.js:

1. Dejar de usar devoluciones de llamada
2. Dejar de usar * para versiones
3. Dejar de usar console.log para la depuración
4. Dejar de usar GET y POST para todo
5. Dejar de usar punto y coma
6. Deje de usar el estilo coma primero
7. Deje de limitar sus conexiones con el maxSockets predeterminado valor

Deje de usar devoluciones de llamada en Node.js

Las devoluciones de llamada son el pan y la mantequilla (o la carne y las verduras para los lectores de estilo de vida paleo) del lenguaje JavaScript/Node.js y el patrón principal. Sin embargo, debe dejar de usar las devoluciones de llamada para anidar el código de varios métodos, a menos que desee terminar con Callback Hell.

Async es para ganar. Particularmente su series() y waterfall() métodos.

Para ilustrar la diferencia drástica, aquí hay un ejemplo en el que realizamos múltiples operaciones con devoluciones de llamada para encontrar un usuario, luego busque publicaciones que pertenezcan al usuario:

codeA(function(a){
  codeB(function(b){
    codeC(function(c){
      codeD(function(d){
        // Final callback code        
      })
    })
  })
})

El series ejemplo:

async.series([
  function(callback){
    // code a
    callback(null, 'a')
  },
  function(callback){
    // code b
    callback(null, 'b')
  },
  function(callback){
    // code c
    callback(null, 'c')
  },
  function(callback){
    // code d
    callback(null, 'd')
  }],
  // optional callback
  function(err, results){
    // results is ['a', 'b', 'c', 'd']
    // final callback code
  }
)

El waterfall ejemplo:

async.waterfall([
  function(callback){
    // code a
    callback(null, 'a', 'b')
  },
  function(arg1, arg2, callback){
    // arg1 is equals 'a' and arg2 is 'b'
    // Code c
    callback(null, 'c')
  },
  function(arg1, callback){      
    // arg1 is 'c'
    // code d
    callback(null, 'd');
  }], function (err, result) {
   // result is 'd'    
  }
)

Dejar de usar comodines * para Versiones con Node.js

El comodín * en lugar del número de versión en package.json parece una buena idea:una actualización automática en un futuro próximo. ¡Equivocado! Debe usar números de versión exactos para evitar que los cambios de módulos de terceros rompan su aplicación y lo despierten en medio de la noche preguntándose qué salió mal.

Esto es especialmente cierto si no confirma su node_modules carpeta o no utilice el envoltorio.

Un mal ejemplo de HackHall package.json alrededor del verano de 2013:

{
    "name": "hackhall",
    "version": "0.0.1",
    "private": true,
    "main": "server",
    "scripts": {
        "start": "node server"
    },
    "dependencies": {
        "express": ">=2.2.0",
        "jade": "*",
        "mongodb": "*",
        "mongoose":"",
        "oauth":"*"
    },
    "devDependencies":{
        "mocha": "",
        "superagent":""
    },
    "engines": {
      "node": ">=0.6"
    }
}

Un buen ejemplo del libro Practical Node.js [2014, Apress]:

{
  "name": "blog-express",
  "version": "0.0.1",
  "private": true,
  "scripts": {
    "start": "node app.js",
    "test": "mocha test"
  },
  "dependencies": {
    "express": "3.4.5",
    "jade": "0.35.0",
    "mongoskin": "~0.6.1",
    "stylus": "~0.40.3",
    "mocha": "1.16.2",
    "superagent": "0.15.7",
    "expect.js": "0.2.0"
  }
}

Si no quiere ir al sitio web de NPM cada vez para verificar la versión, puede usar $ npm install package_name --save que guardará el número de versión en el paquete.json.

Si el módulo ya está instalado, puede:

• Escriba $ npm ls
• Abra la carpeta del paquete y copie el formulario de número de versión package.json

Dejar de usar console.log para depurar aplicaciones de Node.js

¿Cuál es el mejor depurador? Correcto, es console.log ! Es rápido, no interrumpe y nos brinda cualquier información que solicitemos (como el valor de una variable molesta). Entonces, ¿por qué deberías dejar de usarlo? Porque los depuradores reales como Node Inspector brindan no solo el valor de una variable que acaba de codificar, sino que también le brindan una capacidad dinámica para mirar alrededor, dentro del proceso.

[Nota al margen]

Leer publicaciones de blog es bueno, pero ver cursos en video es aún mejor porque son más atractivos.

Muchos desarrolladores se quejaron de la falta de material de video de calidad asequible en Node. Es una distracción ver videos de YouTube y una locura pagar $ 500 por un curso de video de Node.

Visite Node University, que tiene cursos de video GRATUITOS en Node:node.university.

[Fin de la nota al margen]

Por ejemplo, podría tener una condición (donde reenviar es un valor booleano) que no funciona correctamente:

if (resubmit && post.published && user.plan.paid && post.isVisible) {
  // code A
} else {
 // code B
}

Con console.log Solo puedo escribir console.log(resubmit) o console.log(resubmit, ...) algunas otras variables. Pero, con el depurador, puedo hurgar e imprimir cualquier cosa a la que tenga acceso en ese ámbito. Si eso no es suficiente, pasaré por alto o ingresaré el Código A o B como se muestra en el ejemplo.

Dejar de usar GET y POST para Todo en servidores Node.js

Deja de usar GET y POST para todas sus solicitudes HTTP entrantes. La metodología de interfaz de programación de aplicaciones de transferencia de estado representacional (API RESTful) tiene PUT y DELETE así que utilícelos para actualizaciones y eliminaciones (wiki).

Por ejemplo, en esta ruta Express.js, en lugar de usar POST para actualizar un registro, puede usar PUT:

app.post('/comments/update/:id', routes.comments.update)

app.put('/comments/:id', routes.comments.update)

Para obtener más información, consulte el Tutorial de la API REST.

Dejar de usar punto y coma con Node.js

Los puntos y comas son en realidad opcionales, porque ECMAScript (el estándar para Node.js y las implementaciones de JavaScript del navegador) tiene una función de inserción automática de punto y coma (ASI). Aquí está el borrador de la documentación de ECMAScript 6 (ES6) sobre ASI.

La esencia es que los puntos y comas son opcionales y salvo dos casos:frente al IIFE y dentro del for bucle.

El problema con el uso de punto y coma:

• Caracteres adicionales para escribir: En un archivo de 1000 líneas habrá al menos 1000 símbolos adicionales
• Incoherencia: Cuando se pierden los puntos y comas debido a negligencia, el código base aún funciona pero se vuelve inconsistente (se puede solucionar con pelusa, pero ese es un paso de compilación adicional)

Algunos proyectos populares de Node.js se han escrito con un estilo sin punto y coma:

• NPM:el administrador de paquetes de Node.js
• Solicitud:un módulo para realizar solicitudes HTTP

¿Sigues dudando porque Doug Crockford te dijo que tenías que usar punto y coma? Entonces tal vez deberías leer Una carta abierta a los líderes de JavaScript con respecto a los puntos y comas.

Deje de usar el estilo coma primero

De acuerdo, este tema es muy subjetivo y probablemente no sea tan importante, pero quiero expresar mi disgusto por el estilo de coma primero. ¡Por favor, detén la locura!

El estilo en cuestión se ve a menudo cuando se pueden escribir matrices y objetos con una coma al principio de las líneas en lugar de al final. Por ejemplo, podemos definir una matriz:

var arr = [ 'nodejs'
  , 'python'
  , 'ruby'
  , 'php'
  , 'java'
]

O en un estilo más tradicional se vería así:

var arr = [ 'nodejs', 
  'python', 
  'ruby', 
  'php',
  'java'
]

Por favor, no hagas lo primero. No me importa cuánto mejor podría ser para detectar las comas que faltan. El estilo de coma primero parece ridículo, porque nunca usaríamos este estilo en nuestro lenguaje normal de escritura. Nadie escribe así:

Paleo lifestyle is good for ,adult men ,adult women ,children ,and elderly people.

En mi humilde opinión, el estilo de coma primero es difícil de adaptar para el cerebro y simplemente tonto.

Deje de limitar sus conexiones con el valor predeterminado de MaxSockets

El maxSockets predeterminado el valor es 5 y determina el límite en el número de sockets por host (documentos oficiales).

Para evitar cuellos de botella en su sistema, simplemente use algo como esto:

var http = require('http')
http.globalAgent.maxSockets = 10

O, si quieres que sea ilimitado:

require('http').globalAgent.maxSockets = Infinity

Aquí hay un buen artículo de comparación Node.js Connection Pooling.

Otro enfoque es deshabilitar la agrupación todos juntos (agent: false ) como lo hizo LinkedIn o Substack recomienda en su módulo de hiperbúsqueda.

Conclusión sobre las cosas que debe dejar de hacer con Node.js

Por supuesto, esta lista de siete cosas que debe dejar de hacer de inmediato con Node.js es subjetiva, pero nació de una observación cuidadosa y continua, así como de algunas experiencias dolorosas del mundo real (es decir, * en package.json ). ¿Qué hay en tu lista de cosas que no debes hacer con Node.js?