var, let, const... 或者 Javascript 中什么都没有

对于那些不想阅读整个解释的人的总结：

• const定义了常量，但如果我们不小心，它们可以被修改。它具有块作用域，例如let.
• var定义具有函数范围（当前上下文）的变量。
• let定义具有块作用域的变量，并从声明它们的行开始。
• 如果我们不声明标识符，它将被创建为全局变量，除非我们的代码声明为“严格”。

const identificador = ...

创建一个常量。和Java、C#等其他语言一样，如果常量是一个对象，它的属性是可以修改的，所以我们做事一定要小心：

function fallaVariableEntera() {
  const k1= 5;
  console.log(k1);
  k1=6;
  console.log(k1);
}
function fallaCreandoObjeto(){
  const k1 = {}
  k1.hola = 'mundo';
  k1 = {}
  console.log(k1);
}
function funciona() {
  const k1={};
  k1.hola='mundo';
  console.log(k1.hola);
}

funciona();
try{
  fallaVariableEntera();
}catch(err){
  console.error(`fallo cambio de valor const =>${err}`)

}
try{
  fallaCreandoObjeto()
}catch(err){
  console.error(`fallo creando un objeto const =>${err}`)

}

var identificador ...

Javascript 在某些事情上有点特殊，这是一个很好的例子来说明它的奇怪之处：变量可以在使用它时声明，在我们代码的开头或结尾；这并不重要，因为解释器会将声明“提升”到当前范围/上下文的开头（这称为提升，它也会影响函数声明）。范围始终是函数，而不是块：

function ejemplo() {
// la declaro abajo, pero el compilador pondrá la declaración aquí, manteniendo la asignación en el mismo sitio
   a='hola mundo';
   console.log(a);
   var a=6;
   console.log(a);
   
   if (a===6) {
    var b=4; 
   }
   console.log(b); //se declaró en un if, pero su alcance es toda la función
}

ejemplo();

此外，如果我们多次声明它也没关系，额外的声明将被忽略：

var a=4

var a=5;

console.log(a)

与闭包和异步回调一起使用的变量的值的行为常常使没有经验的程序员感到困惑，我举一个例子以及如何解决它：

function print(c) {
  console.log(c);
}

//generamos una función con un valor fijado de antemano
function generador(c) {
  return function () {
    print(c);
  }
}

for (var i=0;i<5;i++) {
  setTimeout(function () { print(i);});
}

for (var i=0;i<5;i++) {
  setTimeout(generador(i));
}

let identificador = ...

我们来到了最新的 Javascript 新奇事物，它的行为方式与其他语言（如 Java 或 C）中的变量声明类似：变量只能从其声明中使用，并且它的作用域是块本地的，不是功能：

function funciona() {
  let a='hola';
  console.log(a);
}

function falla() {
  a='hola';
  console.log(a);
  let a;
}

function fallariaTambien() {
  let a=1;
  if (a==1) {
    let b=2;
  }
  console.log(b);
}

funciona();

//se declara una nueva instancia de i para cada iteración!! el problema que teníamos con var desaparece :)
for (let i=0;i<5;i++) {
  setTimeout(()=>console.log(i));
}

try {
  falla();
} catch(e) {
  console.log('Capturado',e.toString());
}
try {
  fallariaTambien();
} catch(e) {
  console.log('Capturado',e.toString());
}

与 不同var，不允许重复：

let a=4;

let a=5;

console.log(a)

如果我们使用标识符而不声明它会发生什么？好吧，我们有两种情况：Javascript“正常”和Javascript“严格”

在第一种情况下，变量被创建为全局对象的属性，而在第二种情况下，存在编译错误，警告该变量尚未声明。

function normal() {
  hola='hola';
}

function estricta() {
  'use strict'; 
  // esto indica al intérprete que funcione en modo estricto: todo ha de estar definido o no funcionará
  fallo='esto falla';
}

normal();

console.log(window.hola);

estricta()

这个例子演示了这两种情况，也有助于回答“什么是Javascript中的全局？”这个问题。如果我们在浏览器中运行，全局对象总是window. 如果我们在 NodeJS 中运行代码，全局对象是global.

但请注意，window它不是整个浏览器窗口，而是当前选项卡。这是因为在 Firefox 出现之前没有标签，我们在浏览器中打开的每个页面都迫使我们打开一个新窗口。为了安全起见，我们不能在不同的选项卡之间共享变量。

var 将声明一个局部变量，即如果你声明

function miVar() {
  var x = 0;
}

x 将仅在 myVar 函数内部具有作用域，如果您在任何函数之外的所有 js 的开头声明var x = 0;它将在所有 js 中具有作用域。

如果你不放 var 你声明一个全局变量，那么现在声明一个全局变量和一个局部变量有什么区别但是在所有的 js 中？如果你把它var x = 0;放在 js 的开头，它只会在当前 js 中具有作用域，如果你将它声明为 global，它将在 html 中声明的所有 js 中具有作用域。也就是说，如果我在一个 js 中声明，我x = 0;可以在另一个 js 中使用该变量x，它的值为 0

const 可以像 一样作为全局变量x = 0，但最大的区别在于，因为它是一个常量，所以不能重新声明，也就是说，如果你放const x = 0;了它，你以后不能把 x = 2 放在一个函数中。

正如本页在 const 中解释的那样，它可以在数组的情况下进行更改，即填充或删除元素 https://mathiasbynens.be/notes/es6-const

Let 用于声明更多的局部变量，因为这个答案解释了 https://stackoverflow.com/questions/762011/whats-the-difference-between-using-let-and-var-to-declare-a-variable

实际上 var 可以说是父块，如果你在函数内部使用 let in a for

function varExp(){
  for( let i = 0; i < 5; i++ ) {

    }
}

let 只能在 for 中使用，如果你使用 var，它将在整个函数中

在 JavaScript 的早期，var是创建变量的唯一方法。很久以后let和const诞生于 EcmaScript 6 标准。

var 特性

它可以被重置。

var name = 'Andy'
var name = 'AndyGeek'

它可以重新分配。

var name = 'Andy'
    name = 'AndyGeek'
console.log(name)   // AndyGeek

它的影响力是全球性的。

if(true){
    var name = 'andy'
}
else{
    name = 'andygeek'
}
console.log(name)

这也将允许我们在多个if或其他嵌套结构中创建具有相同名称的var变量。即使按照它的范围，如果我们执行下面的代码，我们也不会得到任何错误。

console.log('My name is ' + name)
var name = 'Andy'
// My name is undefined

这一点都不直观，这可能会给我们在编程时带来问题。所以建议不要使用 var。

让的特点

无法重置。

let name = 'Andy'
let name = 'AndyGeek'
// Mostrará un error

它可以重新分配。

let name = 'Andy'
    name = 'AndyGeek'
console.log(name)   // AndyGeek

它的范围是块。

if(true){
    let name = 'andy'
}
else{
    name = 'andygeek'
    // El compilador no reconoce name
}
console.log(name)

施工特点

无法重置。

const name = 'Andy'
const name = 'Andygeek'
// Obtendremos error al ejecutarlo

它不能被重新分配。作为一个常数，这是它的主要特征。我们不能改变常量的整个元素。

const name = 'Andy'
      name = 'AndyGeek'
// Obtendremos error al ejecutarlo

它不是一成不变的。我们可以改变常量元素的属性，但不能改变整个元素。我们将通过一个对象来解释这一点。

const people = {
name: 'Andy'
}
console.log(people.name)    // Andy
people.name = 'AndyGeek'
console.log(people.name)    // AndyGeek

用于对函数的操作。

如果它们是仅用作参考的值，则应在函数内部使用const，如果此值不会在函数中更改，并且让您在需要更改值时使用它们。const和let都广泛用于函数中，无论是为了代码可读性还是使用计数器或累加器变量。

function myFunction() {
    const list = [0,10,2,3,5,7,14,2,7];//Referencia
    let count = 0;//contadora

    for (var i = list.length - 1; i >= 0; i--) {
        if (list[i] % 2 != 0){
            count++;
        }
    }

    return count;
}

用于出口

通常在导入命名空间（文件、库等）时，需要公开某些函数、变量或常量，这些在应用程序中不会更改，因此它们将是const。

//normalmente en el un archivo de constants.js
export const MAIN_COLOR = #ff0000;
//normalmente en el archivo de helpers.js o utils.js
export const deepCopy = (obj) => JSON.parse(JSON.stringify(obj));

注意：不要忘记将大写字母用于const引用，因为它们是用于任何应用程序的值。

要记住的事情

• 如果您使用纯 javascript，则必须使用var，因为旧版浏览器不能使用const和let。
• 全局变量或常量是可以从任何地方访问的变量。

这个答案是在 javascript 中使用 let 和 const 的一个更实际的例子。

对于那些不想阅读整个解释的人的总结：

• const定义了常量，但如果我们不小心，它们可以被修改。它有块作用域，比如 let。

• var定义具有函数范围（当前上下文）的变量。

• let定义具有块作用域的变量，并从声明它们的行开始。

• 如果我们不声明标识符，它将被创建为全局变量，除非我们的代码声明为“严格”。