When should I use var, let and const in ECMA Script 6?

To answer the question:

What would be the recommendation to choose which type of variable definition should be used?

First, you must know each type of statement and clarify its scope within the javascript execution:

The statement letdeclares a variable of local scope, which can optionally be initialized with some value.

That is, example:

(function(){
  let foo = 'bar'; // Se crea y se le da un valor
  let bar = 'foo'; // Se crea y se le da un valor
  
  console.log('foo: ' + foo); 
  console.log('bar: ' + bar);
  
  foo = 'foo'; // Se le asigna un nuevo valor
  bar = 'bar'; // Se le asigna un nuevo valor
  
  console.log('foo: ' + foo);
  console.log('bar: ' + bar);
})()

console.log('foo: ' + foo); // foo is not defined
console.log('bar: ' + bar); // bar is not defined

In the previous example it can be clearly seen how the variables fooand barcan only be initialized, accessed and changed only within the closurebut they cannot be accessed and/or changed outside of it...

NOTE: in the previous example if you replace a letwith varthe same results will be obtained, I only put it as an example, a better example would be to say that a variable letdefined in archivo_1.jscould not be accessed in archivo_2.jswhile a variable varin archivo_1.jsitself could be accessed and changed inarchivo_2.js

In addition, it should be clarified that type variables, letunlike type variables, CANNOT be accessed through the global object and cannot be re-declared , unlike type variables , for example:var windowvar

var bar = 'foo';
let foo = 'bar';

console.log('bar: ' + bar);
console.log('window bar: ' + window.bar);
console.log('foo: ' + foo);
console.log('window foo: ' + window.foo); // undefined

var bar = 'new foo'; // bar puede ser RE DECLARADA
// let foo = 'new bar'; // foo NO PUEDE ser RE DECLARADA

console.log('bar: ' + bar);
console.log('window bar: ' + window.bar);
console.log('foo: ' + foo);
console.log('window foo: ' + window.foo); // undefined

The var statement is a simple declaration of a variable, optionally initialized to a value.

Namely:

var foo = 'bar';
console.log(foo);
console.log(window.foo);
foo = 'foo';
console.log(foo);
console.log(window.foo);

(function(){
  console.log('closure foo: ' + foo);
  console.log('closure window foo: ' + window.foo);
})()

The statement constis a constant that occurs in block scope like type variables do letbut cannot be changed*( properties of objects assigned to constants are not protected ) or redeclared

When acting as type variables, letit must be taken into account that they cannot be accessed through the global object window, nor can they be re-declared and/or re-assigned with a new value.

const KEY = '0123456780';
console.log(KEY);
console.log(window.KEY); // undefined
// KEY = '0876543210'; // KEY' has already been declared
// const KEY = '0876543210'; // KEY' has already been declared
console.log(KEY);
console.log(window.KEY); // undefined

const data = {
           id : 1, 
           name : "top secret"
           }
 console.log(data) 
 
 data.id = 9 //the reference does not change it
 data.name = "Nine";
 console.log(data)

Finally and as a conclusion there would be some recommendations such as:

1. Use type variables letwithin functions , cycles and other code blocks whose execution is local, does not depend on other code and where said variables do not have to be accessed globally through the objectwindow

2. Use type variables varwhere said variable has to be accessed in other blocks of code and globally through the object window, that is:var jq = $;

3. Use CONSTANTS ( const) for information such as an API KEY , a TOKEN , a value that ALWAYS HAS TO BE THE SAME, that is:const my_credit_card_number = 1234567890;

NOTE: only do the example above if you're in nodejs, haha

The difference between letand varmost important is scope (or scope). var will cause variables inside the nearest function to be defined. let will only be defined in the closest closed block. A part var declares the variables at the top of the closest function no matter where we declare it, which is known as hoisting ( +info ).

letit also does not allow us to create a variable with the same name, although it does allow it to be modified (unlike const). Let's say it consthas the same effect as letexcept that we can't modify the primitive value it stores. Yes, we could modify the properties of an object with const.

//console.log(letvariable); //--> esto da error
console.log(varvariable);  // undefined -> Esto no ya que var hace que estén visibles en su función más próxima 

let letvariable = '';
var varvariable = '';

// De igual forma
(function(){
  //console.log(x); // -> error
  console.log(y); // undefined
  let x = 'x';
  var y = 'y'
})()


for(let a = 0; a < 9; a++){
}
//console.log(a); // a no esta definida
for(var b = 0; b < 9; b++){
}

console.log(b);

{
  let c = 'hello';
  var d = 'hello';
}
//console.log(c) // error

console.log(d);

let xx = '';
//let xx = 'xx'; //-> error

var yy = '';
var yy = 'aaaa';

console.log(yy);

const zz = 'aa';
//zz = 'bb'; // error

const objeto = {};

objeto.a = 'aa';
console.log(objeto);

Taking this into account, the use of one or the other depends on the functionality that you want to have in your program.