本文主要介绍了Java开发入门到精通--java重要知识全解：变量和类型，通过具体的内容向大家展现，希望对大家Java开发的学习有所帮助。

变量和类型是学习JavaScript最先接触到的东西，但是往往看起来最简单的东西往往还隐藏着很多你不了解、或者容易犯错的知识，比如下面几个问题： 

JavaScript中的变量在内存中的具体存储形式是什么？

0.1+0.2为什么不等于0.3?发生小数计算错误的具体原因是什么？

Symbol的特点，以及实际应用场景是什么？

[] == ![]、[undefined] == false为什么等于true?代码中何时会发生隐式类型转换？转换的规则是什么？

如何精确的判断变量的类型？

如果你还不能很好的解答上面的问题，那说明你还没有完全掌握这部分的知识，那么请好好阅读下面的文章吧。

本文从底层原理到实际应用详细介绍了JavaScript中的变量和类型相关知识。

一、JavaScript数据类型

ECMAScript标准规定了7种数据类型，其把这7种数据类型又分为两种：原始类型和对象类型。

原始类型

Null：只包含一个值：null

Undefined：只包含一个值：undefined

Boolean：包含两个值：true和false

Number：整数或浮点数，还有一些特殊值（-Infinity、+Infinity、NaN）

String：一串表示文本值的字符序列

Symbol：一种实例是唯一且不可改变的数据类型

(在es10中加入了第七种原始类型BigInt，现已被最新Chrome支持)

对象类型

Object：自己分一类丝毫不过分，除了常用的Object，Array、Function等都属于特殊的对象

二、为什么区分原始类型和对象类型

2.1 不可变性

上面所提到的原始类型，在ECMAScript标准中，它们被定义为primitive values，即原始值，代表值本身是不可被改变的。

以字符串为例，我们在调用操作字符串的方法时，没有任何方法是可以直接改变字符串的：

var str = 'ConardLi';

str.slice(1);

str.substr(1);

str.trim(1);

str.toLowerCase(1);

str[0] = 1;

console.log(str);  // ConardLi

在上面的代码中我们对str调用了几个方法，无一例外，这些方法都在原字符串的基础上产生了一个新字符串，而非直接去改变str，这就印证了字符串的不可变性。

那么，当我们继续调用下面的代码：

str += '6'

console.log(str);  // ConardLi6

你会发现，str的值被改变了，这不就打脸了字符串的不可变性么？其实不然，我们从内存上来理解：

在JavaScript中，每一个变量在内存中都需要一个空间来存储。

内存空间又被分为两种，栈内存与堆内存。

栈内存：

存储的值大小固定

空间较小

可以直接操作其保存的变量，运行效率高

由系统自动分配存储空间

JavaScript中的原始类型的值被直接存储在栈中，在变量定义时，栈就为其分配好了内存空间。

由于栈中的内存空间的大小是固定的，那么注定了存储在栈中的变量就是不可变的。

在上面的代码中，我们执行了str += '6'的操作，实际上是在栈中又开辟了一块内存空间用于存储'ConardLi6'，然后将变量str指向这块空间，所以这并不违背不可变性的特点。

2.2 引用类型

堆内存：

存储的值大小不定，可动态调整

空间较大，运行效率低

无法直接操作其内部存储，使用引用地址读取

通过代码进行分配空间

相对于上面具有不可变性的原始类型，我习惯把对象称为引用类型，引用类型的值实际存储在堆内存中，它在栈中只存储了一个固定长度的地址，这个地址指向堆内存中的值。

var obj1 = {name:"ConardLi"}

var obj2 = {age:18}

var obj3 = function(){...}

var obj4 = [1,2,3,4,5,6,7,8,9]

由于内存是有限的，这些变量不可能一直在内存中占用资源，这里推荐下这篇文章JavaScript中的垃圾回收和内存泄漏，这里告诉你JavaScript是如何进行垃圾回收以及可能会发生内存泄漏的一些场景。

当然，引用类型就不再具有不可变性了，我们可以轻易的改变它们：

obj1.name = "ConardLi6";

obj2.age = 19;

obj4.length = 0;

console.log(obj1); //{name:"ConardLi6"}

console.log(obj2); // {age:19}

console.log(obj4); // []

以数组为例，它的很多方法都可以改变它自身。

pop() 删除数组最后一个元素，如果数组为空，则不改变数组，返回undefined，改变原数组，返回被删除的元素

push()向数组末尾添加一个或多个元素，改变原数组，返回新数组的长度

shift()把数组的第一个元素删除，若空数组，不进行任何操作，返回undefined,改变原数组，返回第一个元素的值

unshift()向数组的开头添加一个或多个元素，改变原数组，返回新数组的长度

reverse()颠倒数组中元素的顺序，改变原数组，返回该数组

sort()对数组元素进行排序，改变原数组，返回该数组

splice()从数组中添加/删除项目，改变原数组，返回被删除的元素

下面我们通过几个操作来对比一下原始类型和引用类型的区别：

2.3 复制

当我们把一个变量的值复制到另一个变量上时，原始类型和引用类型的表现是不一样的，先来看看原始类型：

var name = 'ConardLi';

var name2 = name;

name2 = 'code秘密花园';

console.log(name); // ConardLi;

内存中有一个变量name，值为ConardLi。我们从变量name复制出一个变量name2，此时在内存中创建了一个块新的空间用于存储ConardLi，虽然两者值是相同的，但是两者指向的内存空间完全不同，这两个变量参与任何操作都互不影响。

复制一个引用类型：

var obj = {name:'ConardLi'};

var obj2 = obj;

obj2.name = 'code秘密花园';

console.log(obj.name); // code秘密花园

当我们复制引用类型的变量时，实际上复制的是栈中存储的地址，所以复制出来的obj2实际上和obj指向的堆中同一个对象。因此，我们改变其中任何一个变量的值，另一个变量都会受到影响，这就是为什么会有深拷贝和浅拷贝的原因。

2.4 比较

当我们在对两个变量进行比较时，不同类型的变量的表现是不同的：

var name = 'ConardLi';

var name2 = 'ConardLi';

console.log(name === name2); // true

var obj = {name:'ConardLi'};

var obj2 = {name:'ConardLi'};

console.log(obj === obj2); // false

复制代码

对于原始类型，比较时会直接比较它们的值，如果值相等，即返回true。

对于引用类型，比较时会比较它们的引用地址，虽然两个变量在堆中存储的对象具有的属性值都是相等的，但是它们被存储在了不同的存储空间，因此比较值为false。

2.5 值传递和引用传递

借助下面的例子，我们先来看一看什么是值传递，什么是引用传递：

let name = 'ConardLi';

function changeValue(name){

  name = 'code秘密花园';

}

changeValue(name);

console.log(name);

复制代码

执行上面的代码，如果最终打印出来的name是'ConardLi'，没有改变，说明函数参数传递的是变量的值，即值传递。如果最终打印的是'code秘密花园'，函数内部的操作可以改变传入的变量，那么说明函数参数传递的是引用，即引用传递。

很明显，上面的执行结果是'ConardLi'，即函数参数仅仅是被传入变量复制给了的一个局部变量，改变这个局部变量不会对外部变量产生影响。

let obj = {name:'ConardLi'};

function changeValue(obj){

  obj.name = 'code秘密花园';

}

changeValue(obj);

console.log(obj.name); // code秘密花园

复制代码

上面的代码可能让你产生疑惑，是不是参数是引用类型就是引用传递呢？

首先明确一点，ECMAScript中所有的函数的参数都是按值传递的。

同样的，当函数参数是引用类型时，我们同样将参数复制了一个副本到局部变量，只不过复制的这个副本是指向堆内存中的地址而已，我们在函数内部对对象的属性进行操作，实际上和外部变量指向堆内存中的值相同，但是这并不代表着引用传递，下面我们再按一个例子：

let obj = {};

function changeValue(obj){

  obj.name = 'ConardLi';

  obj = {name:'code秘密花园'};

}

changeValue(obj);

console.log(obj.name); // ConardLi

复制代码

可见，函数参数传递的并不是变量的引用，而是变量拷贝的副本，当变量是原始类型时，这个副本就是值本身，当变量是引用类型时，这个副本是指向堆内存的地址。所以，再次记住：

ECMAScript中所有的函数的参数都是按值传递的。

三、分不清的null和undefined

在原始类型中，有两个类型Null和Undefined，他们都有且仅有一个值，null和undefined，并且他们都代表无和空，我一般这样区分它们：

null

表示被赋值过的对象，刻意把一个对象赋值为null，故意表示其为空，不应有值。

所以对象的某个属性值为null是正常的，null转换为数值时值为0。

undefined

表示“缺少值”，即此处应有一个值，但还没有定义，

如果一个对象的某个属性值为undefined，这是不正常的，如obj.name=undefined，我们不应该这样写，应该直接delete obj.name。

undefined转为数值时为NaN(非数字值的特殊值)

JavaScript是一门动态类型语言，成员除了表示存在的空值外，还有可能根本就不存在（因为存不存在只在运行期才知道），这就是undefined的意义所在。对于JAVA这种强类型语言，如果有"undefined"这种情况，就会直接编译失败，所以在它不需要一个这样的类型。

四、不太熟的Symbol类型

Symbol类型是ES6中新加入的一种原始类型。

每个从Symbol()返回的symbol值都是唯一的。一个symbol值能作为对象属性的标识符；这是该数据类型仅有的目的。

下面来看看Symbol类型具有哪些特性。

4.1 Symbol的特性

1.独一无二

直接使用Symbol()创建新的symbol变量，可选用一个字符串用于描述。当参数为对象时，将调用对象的toString()方法。

var sym1 = Symbol();  // Symbol() 

var sym2 = Symbol('ConardLi');  // Symbol(ConardLi)

var sym3 = Symbol('ConardLi');  // Symbol(ConardLi)

var sym4 = Symbol({name:'ConardLi'}); // Symbol([object Object])

console.log(sym2 === sym3);  // false

复制代码

我们用两个相同的字符串创建两个Symbol变量，它们是不相等的，可见每个Symbol变量都是独一无二的。

如果我们想创造两个相等的Symbol变量，可以使用Symbol.for(key)。

使用给定的key搜索现有的symbol，如果找到则返回该symbol。否则将使用给定的key在全局symbol注册表中创建一个新的symbol。

var sym1 = Symbol.for('ConardLi');

var sym2 = Symbol.for('ConardLi');

console.log(sym1 === sym2); // true

复制代码

2.原始类型

注意是使用Symbol()函数创建symbol变量，并非使用构造函数，使用new操作符会直接报错。

new Symbol(); // Uncaught TypeError: Symbol is not a constructor

复制代码

我们可以使用typeof运算符判断一个Symbol类型：

typeof Symbol() === 'symbol'

typeof Symbol('ConardLi') === 'symbol'

复制代码

3.不可枚举

当使用Symbol作为对象属性时，可以保证对象不会出现重名属性，调用for...in不能将其枚举出来，另外调用Object.getOwnPropertyNames、Object.keys()也不能获取Symbol属性。

可以调用Object.getOwnPropertySymbols()用于专门获取Symbol属性。

var obj = {

  name:'ConardLi',

  [Symbol('name2')]:'code秘密花园'

}

Object.getOwnPropertyNames(obj); // ["name"]

Object.keys(obj); // ["name"]

for (var i in obj) {

   console.log(i); // name

}

Object.getOwnPropertySymbols(obj) // [Symbol(name)]

复制代码

4.2 Symbol的应用场景

下面是几个Symbol在程序中的应用场景。

应用一：防止XSS

在React的ReactElement对象中，有一个?typeof属性，它是一个Symbol类型的变量：

var REACT_ELEMENT_TYPE =

  (typeof Symbol === 'function' && Symbol.for && Symbol.for('react.element')) ||

  0xeac7;

复制代码

ReactElement.isValidElement函数用来判断一个React组件是否是有效的，下面是它的具体实现。

ReactElement.isValidElement = function (object) {

  return typeof object === 'object' && object !== null && object.?typeof === REACT_ELEMENT_TYPE;

};

复制代码

可见React渲染时会把没有?typeof标识，以及规则校验不通过的组件过滤掉。

如果你的服务器有一个漏洞，允许用户存储任意JSON对象， 而客户端代码需要一个字符串，这可能会成为一个问题：

// JSON

let expectedTextButGotJSON = {

  type: 'div',

  props: {

    dangerouslySetInnerHTML: {

      __html: '/* put your exploit here */'

    },

  },

};

let message = { text: expectedTextButGotJSON };

<p>

  {message.text}

</p>

复制代码

而JSON中不能存储Symbol类型的变量，这就是防止XSS的一种手段。

应用二：私有属性

借助Symbol类型的不可枚举，我们可以在类中模拟私有属性，控制变量读写：

const privateField = Symbol();

class myClass {

  constructor(){

    this[privateField] = 'ConardLi';

  }

  getField(){

    return this[privateField];

  }

  setField(val){

    this[privateField] = val;

  }

}

复制代码

应用三：防止属性污染

在某些情况下，我们可能要为对象添加一个属性，此时就有可能造成属性覆盖，用Symbol作为对象属性可以保证永远不会出现同名属性。

例如下面的场景，我们模拟实现一个call方法：

    Function.prototype.myCall = function (context) {

      if (typeof this !== 'function') {

        return undefined; // 用于防止 Function.prototype.myCall() 直接调用

      }

      context = context || window;

      const fn = Symbol();

      context[fn] = this;

      const args = [...arguments].slice(1);

      const result = context[fn](...args);

      delete context[fn];

      return result;

    }

复制代码

我们需要在某个对象上临时调用一个方法，又不能造成属性污染，Symbol是一个很好的选择。

我是小职，记得找我

✅ 解锁高薪工作

✅ 免费获取基础课程·答疑解惑·职业测评