JavaScript教程 - 4 基础语法

4.1 注释

在学习基础语法之前先介绍一下注释。

我们在学习任何语言，都会有注释，注释的作用就是向别人解释我们编写的代码的含义和逻辑，使代码有更好的可读性。

注释不是程序，是不会被执行的。所以我们也可以使用注释，注释掉暂时不需要执行的代码。

注释一般分类两类，单行注释和多行注释。

1 单行注释

单行注释以 // 开头，井号右边为注释内容。

例如：

// 我是单行注释，打印Hello World
alert('Hello World!')  // 这里是注释

注意：// 号和注释内容一般建议以一个空格隔开，这是代码规范，建议大家遵守。

单行注释一般用于对一行或一小部分代码进行解释。

2 多行注释

多行注释以 /**/ 括起来，中间的内容为注释内容，注释内容可以换行。

/*
我是多行注释，
我来哔哔两句
*/
alert('Hello World!')

多行注释适合对一段代码块、一个函数或者一个较大的功能模块进行详细的说明，关于函数，后面会讲。

4.2 代码格式

1 大小写

JS 代码是严格区分大小写的。

举个栗子：

// 语句1
alert('Hello!')

// 语句2
Alert('Hello!')

• 上面的两句代码是不一样的，alert() 是浏览器提供的功能，所以 Alert 在执行的时候，会报错，找不到。

可以在浏览器的控制台看到错误：

2 空格与换行

JS 代码中的空格和换行会被忽略。

举个栗子：

alert( 'Hello' );

alert( 
  'Hello' 
     );

• 上面的写法都是一样的，空格和换行会被忽略；
• 但你别傻乎乎的在 alert 单词或 'Hello' 中间空格和换行。

3 语句结束符

JS 的每条语句应该以分号 ; 结束。

alert('Hello');
console.log('Hello');

但是不写分号也能正常运行，JS 解释器会自动添加分号（ASI机制），但是并不能在所有场景下都能准确无误的添加分号。

所以推荐手动加上。如果语句都添加分号，多条语句是可以写在一行的。没加是不行的，需要换行写，否则解释器不知道语句结束。

但是也有一些语法检查工具，推荐是不写分号的，所以根据自己喜好吧。

4.3 字面量

什么是字面量？

字面量就是在代码中，写下来的固定的值。

举个栗子：

alert(123)
alert(3.14)
alert('Hello')
alert(true)

• 上面的 123 、3.14 、'Hello' 、true 就是 4 个字面量，它们的类型分别是 整数、浮点数（也就是小数）、字符串 、布尔类型（只有 true 和 false 两个值），还有一些类型字面量后面用到再说。

这种直接在代码中写的值就是字面量。但是如果我们要输出 100 次 Hello ，就要写 100 次 Hello 字面量，要修改 Hello，就要修改 100 次，那就要疯掉了，所以我们可以将字面量保存到变量中，然后直接输出变量就可以了。

4.4 变量

在代码中，数据是保存在哪里的呢？

在代码中，数据需要保存在变量中（在内存中），变量是在程序运行的时候存储数据用的，可以想象变量为一个盒子。

整数、浮点数（小数）、字符串（文本）、布尔等类型，都可以放在变量中。

1 变量的定义

举个栗子：

let age;  // 定义变量
age = 18;  // 为变量赋值
console.log(age);  // 打印age的值，18

• 定义变量使用 let 关键字，上面定义了一个变量，变量名称是 age ，变量名称自定义；
• 给变量赋值使用 = 。
• 为变量赋值后，就可以使用变了，上面使用 console.log() 打印变量的值。

也可以在定义变量的时候同时赋值：

let age = 18;  // 定义变量并赋值
console.log(age);  // 打印age的值

• 使用 let 变量名 = 值; 的方式，声明变量的时候同时赋值。

我们可以定义不同的变量，存储不同的数据：

// 定义变量
let name = 'foooor.com';  // 定义一个变量，存储姓名，字符串类型的数据
let age = 18;  // 定义一个变量，存储整形数据年龄
let height = 1.78;  // 定义一个变量，存储浮点数据身高
let isAdult = true;  // 定义一个变量，存储是否成年，数据类型是bool类型

// 定义完变量就可以使用变量了
console.log(name);  // foooor.com
console.log(age);  // 18
console.log(height);  // 1.78
console.log(isAdult);  // true

上面定义了4个变量，并赋值，值分别是字符串（string）、整数（int）、浮点型（float）、布尔型（bool）。

和 C 和 Java 语言不同，JS 是弱类型语言，不需要指定变量的类型。在 Java 中，定义变量需要指定变量的类型，整形的变量只能存储整形的数值。JS 随意，啥数据都能存。

2 变量的特征

变量变量，从名字中可以看出，表示“量”是可变的。所以，变量被定义后，可以在后面的代码中使用了，而且还可以重新修改变量的值。

例如：

let age = 18;
age = 16;  // 可以修改变量的值
console.log(age);  // 打印：16

age = age + 3;  // 还可以在当前值的基础上进行运算
console.log(age);  // 打印：19, 在前面16的基础上+3

age = "Hello";
console.log(age);  // 打印：Hello, 变量的值可以修改为任意类型

可以看到变量的值可以被修改，而且可以参与运算。而且一个变量可以被赋予任意类型的数据，可以说是有一点放肆了。

通过在变量中存储数据，然后就可以在很多地方使用变量了，还可以改变变量的值。

3 旧的定义变量的方式

定义变量使用 let 关键字，以前 JS 中定义变量是使用 var 关键字的：

var age = 18;

现在也可以用，但是这两者有一些区别，var 没有块级作用域，有时候会有一些问题，作用域先不用了解。

在现代 JS 开发中，推荐使用 let 关键字来定义变量。

甚至你不使用关键字都可以：

age = 18;
console.log(age);

但是不推荐。

4.5 常量

变量是可以变的，常量就是不可以变的，定义了以后，值就不能修改了。有时候我们定义了一个值就不想它被修改，例如定义了一个圆周率，这个值就是固定的，不能在其他地方修改这个值。

常量使用 const 关键字定义。

举个栗子：

const PI = 3.1415926;
console.log(PI);

• 推荐常量的名称使用大写字母来定义（多个单词使用下划线分隔），这样一看到就知道是常量，无法修改。

如果修改常量的值，会发生错误：

4.6 标识符

什么是标识符？

标识符就是名字，例如变量的名字、方法的名字、类的名字，我们可以自定义名字的都。

起名字肯定会有限制，肯定不能 张Three 这样起名字，所以标识符也有限制。

1 标识符命名规则

标识符需要遵守一下规则：

1. 只能是字母、数字、下划线_、$；
2. 不能使用数字开头，可以英文、下划线、$ 开头；

a					// 可以
a_b				// 可以
_a				// 可以
a123			// 可以
a_b_a			// 可以
a$				// 可以
$_a				// 可以

123					// 错误
123_				// 错误
123_a				// 错误

3. 大小写敏感，大小写不同是不同的标识符；

name = "zhangsan"   
Name = "lisi"				// 和 name 是不同的标识符

4. 不能使用关键字，关键字就是 JS 中保留的一些单词，有特殊的用途，不能被用作标识符，但是标识符中可以包含保留字。

JS 有如下关键字：

abstract	byte	char	double	final
arguments	case	catch	export	float
await	class	const	extends	goto
boolean	default	delete	false	implements
break	do	else	enum	import
continue	debugger	finally	in	instanceof
delete	export	int	interface	let
do	extends	long	native	new
else	false	null	package	private
eval	for	function	protected	public
if	implements	return	short	static
in	instanceof	super	synchronized	this
of	throw	throws	transient	true
try	typeof	var	void	volatile
while	with	yield

这么多怎么记？不用记！不用记！不用记！后面每个关键字都会学到，自然知道每个关键字是做什么用的，另外你用了代码会报错。

5. 不要使用内置的变量、函数或类名作为变量名

let alert = 123;
alert('Hello');

alert 是 JS 内置的用于在浏览器弹出提示框的，现在定义了一个变量叫 alert，会覆盖内置的变量、函数等。

2 变量命名规范

使用上面说的规则，我们可以定义变量名了。

但是为了优雅、统一、规范，我们在定义变量名时，还应该遵守以下规范，虽然你不遵守，没人开枪打死你，但是建议你遵守。

1. 见名知意

看见一个变量名，就知道这个变量名是干嘛的。

let a = "zhangsan"								// 看到a，鬼知道a是干嘛的
let name = "zhangsan"							// 看到name，就知道这是个名字，简单明了

2. 变量名使用首字母小写的驼峰命名规则：

let firstName = "Jim"
let studentNickname = "胖墩"

3. 类名使用首字母大写的驼峰命名规则：

class Person {
}

类后面再讲，不着急。

4. 常量使用全字母大写，多个单词使用下划线分隔

const MAX_USER_NAME_LENGTH = 24;

4.7 数据类型

刚才在定义变量的时候，我们使用了整数、浮点型、字符串、布尔型（bool）4个类型的数据。

JS 中的数据类型有很多，主要分为两类：原始数据类型（原始类型） 和 引用数据类型（对象类型）。上面说的四种类型都是原始数据类型。

JS 中一共有七种原始数据类型：

• 数值（number）
• 字符串（string）
• 布尔值（boolean）
• 大整数（bigint）
• 空值（null）
• 未定义（undefined）
• 符号（symbol）

JS 中，对象数据类型也是由原始数据类型构成的，下面介绍一下元素数据类型。

1 数值number

在 JavaScript 中 number 类型用于表示整数和浮点数。JS 中的数字没有区分整数和浮点数，所有的数字都被当作浮点数处理。

举个栗子：

let age = 30;
let price = 19.99;
console.log(age);  // 输出 30
console.log(price);  // 输出 19.99

JS 数值有很多特别的地方，让你意想不到。

number 类型是64位的，它可以表示的最大和最小值是有限制的，范围在 -(2^53 - 1)（即 -9007199254740991）~ 2^53 - 1（即 9007199254740991）之间。超过了范围，表示就不准确了。

举个栗子：

let largeNumber = 9007199254740992; // 2^53
let result = largeNumber + 1;
console.log(largeNumber);       // 输出: 9007199254740992
console.log(result);            // 输出: 9007199254740992，结果不准确
console.log(9999999999999999);  // 输出: 10000000000000000，结果不准确

• 可以看到超过范围就不准确了，所以在 JS 中进行一些精度比较高的运算一定要注意。

我们可以使用 Number.MAX_SAFE_INTEGER 和 Number.MIN_SAFE_INTEGER 表示最大的数值和最小的数值。

let num1 = Number.MAX_SAFE_INTEGER;
let num2 = Number.MIN_SAFE_INTEGER;
console.log(num1);  // 输出: 9007199254740991
console.log(num2);  // 输出: -9007199254740991

另外，计算机不能进行精确的小数运算，这个不是 JS 的问题。

举个栗子：

let num = 0.1 + 0.2;
console.log(num);  // 输出：0.30000000000000004

如果数值太大，会使用 Infinity 来表示：

let num = 9999 ** 9999;  // 9999的9999次方
console.log(num);  // 输出：Infinity，结果不准确

如果一个计算结果得到的不是数值，会使用 NaN （Not a Number）来表示：

let num = 123 - 'abc';  // 数字减去字符串
console.log(num);  // 输出：NaN

所以值 Infinity 和 NaN 都是数字类型的，但是我们在写代码的时候，尽量避免出现 Infinity 和 NaN 。

2 大整数bigint

上面说了 number 类型表示的数字有范围限制，如果要表示很大的数该怎么办呢？

在 ES11 中引入了 bigint，可以处理非常大的整数，只要有内存。大整数以 n 结尾。

举个例子：

let bigIntNum = 1234567890123456789012345678901234567890n;
console.log(bigIntNum);  // 输出 1234567890123456789012345678901234567890n

需要注意 bigint 和 number 是不能直接进行运算的：

let a = 10n;
let b = 20;
console.log(a  + b);

上面的代码会报错，不能进行运算，因为 10n 和 20 是不同的数据类型，如果要进行运算，需要转换为相同的数据类型，下面类型转换的时候再讲。

3 字符串string

下面单独介绍。

4 布尔值boolean

boolean 类型只有两个值：true 和 false，通常用于逻辑运算和控制流中，如条件判断，下一个章节再讲。

例如：用户名是否合法，true 表示合法，false 表示不合法。

let isValid = true;
let isExpired = false;
console.log(isValid);  // 输出 true
console.log(isExpired);  // 输出 false

5 空值null

null 是一个特殊的原始值，表示“空”或“无值”。

举个栗子：

let b = null;
console.log(b);  // 输出 null

• 如果有一个变量不想再用了，可以将其设置为 null。
• 如果有一个变量需要初始化，但是不知道赋值多少，可以赋值为 null，表示它尚未获得有效值，等待后续赋值。

6 未定义undefined

undefined 是一种基本数据类型，表示变量声明了但未被赋值，所以一个变量未赋值的会自动被赋予 undefined 值。

举个栗子：

let a;
console.log(a);  // 输出 undefined，因为 a 没有赋值

注意区分 null 和 undefined，null 是赋值了，赋的空值，undefined 是未赋值。

很多语言变量定义后未初始化，直接使用是会报错的，但是 JS 为了避免执行的过程中出现错误而中断执行，所以尽可能不报错。

7 符号symbol（ES6 引入）

symbol 是一种新的原始数据类型，表示唯一且不可变的值。通常用于对象的属性键。每个 symbol 值都是唯一的，不能与其他 symbol 值相等。

const sym1 = Symbol('description');
const sym2 = Symbol('description');
console.log(sym1 === sym2);  // 输出 false，因为每个 Symbol 都是唯一的

Symbol 可以用于定义对象的私有属性，防止属性被意外修改，后面再讲解。

4.8 字符串

4.8.1 字符串定义方式

字符串有3种不同的定义方式：

方式一：双引号定义法

let text1 = "我是一个字符串";

方式二：单引号定义法

let text2 = '我是一个字符串';

方式三：模板字符串定义法

模板字符串定义法使用反引号定义，反引号是 1 左边的那个键，反引号定义的字符串可以换行，其中的：

let text3 = `我是一个字符串，
我还可以换行`;

• 内容输出的时候，也会换行。

4.8.2 转义字符

如果我们的字符串中包含引号，该怎么处理呢？

如果字符串中包含单引号，可以使用双引号定义法：

let str = "Hello 'JavaScript'";

如果字符串中包含双引号，可以使用单引号定义法：

let str = 'Hello "JavaScript"';

还有一个通用的方法，就是使用转义符 \ ，在引号前面加上 \ 表示后面的字符是普通字符串：

let str1 = "Hello \"JavaScript\"";
let str2 = "Hello \'JavaScript\'";

console.log(str1);  // Hello "JavaScript"
console.log(str2);  // Hello 'JavaScript'

同样，如果你想在字符串中输出 \t ，你可能会这样写：

let str = "Hello \t \"JavaScript\""
console.log(str);  // Hello 	 "JavaScript"

但运行完成结果却没有 \t ，因为 \t 是制表符；同样 \n 是换行符，如果想在字符串中输出 \t 或 \n 等特殊字符，也是需要对 斜杠 \ 进行转义：

let str = "Hello \\t \"JavaScript\""
console.log(str);  // Hello \t "JavaScript"

同样，输出 \ 也需要转义，要输出两个 \\ ，都需要进行转义：

let str = "Hello \\\\ \"JavaScript\""
console.log(str);  // Hello \\ "JavaScript"

4.8.3 字符串拼接

1 使用加号拼接

两个字符串拼接，直接使用 加号+ 拼接即可，例如：

console.log("Hello " + "World")			// 输出：Hello World

但是上面的拼接纯属脱裤子放屁，直接写成 console.log("Hello World") 就完了，所以一般字符串拼接都是在字面量和变量、变量和变量之间拼接：

let name = "张三";
let age = 10;
console.log("Hello，我是" + name + "，我今年才" + age + "岁，我是法外狂徒")  // 输出:Hello，我是张三，我今年才10岁，我是法外狂徒

2 使用模板字符串

反引号定义的模板字符串，可以通过 ${} 插入变量或表达式。

举个栗子：

let name = "张三";
let age = 10;
console.log(`Hello，我是${name}，我今年才${age}岁，我是法外狂徒`)  // 输出:Hello，我是张三，我今年才10岁，我是法外狂徒

• 这种方式可以说是非常适合字符串拼接了。

3 使用concat()方法

使用字符串的 concat() 方法也可以用于拼接字符串。

let str1 = "Hello";
let str2 = "World";
let result = str1.concat(" ", str2, "!");  // 拼接三个字符" "、str、"!"
console.log(result); // "Hello World!"

• 需要注意 concat() 方法不会修改原字符串，而是返回一个新的字符串。
• concat() 方法在现代 JavaScript 中使用较少，因为 + 和模板字符串更简单。

4.9 类型转换

4.9.1 typeof

上面在将 数字 和 字符串 进行运算的时候，会返回 NaN ，所以我们在运算和转换之前，可以先对数据进行类型判断。

使用 typeof 运算符 ，可以得到数据的类型。

举个栗子：

let num = 123;
console.log(typeof num);			 // "number"

console.log(typeof 42);        // "number"
console.log(typeof 3.14);      // "number"
console.log(typeof 100n);      // "bigint"
console.log(typeof "hello");   // "string"
console.log(typeof true);      // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof null);      // "object" (这是 JavaScript 的一个历史遗留问题)
console.log(typeof Symbol());  // "symbol"

• typeof 的结果是字符串。
• typeof null 返回的是 "object"，这是 JavaScript 的一个历史遗留问题，应该算一个设计缺陷，所以 typeof 无法判断一个变量是否为 null 。

需要注意， typeof 不是检查变量的类型，变量是没有类型的，检查的是变量中数据的类型。

let value = "foooor";
console.log(typeof value);   // "string"

value = 123;
console.log(typeof value);   // "number"

• 可以看到 value 中存储的值不同， typeof value 的结果也不同。

4.9.2 数据类型转换

数据类型转换就是不同的数据类型之间是可以进行转换的，例如在某些时候，我们需要将数字转换为字符串，或者字符串转换为数字。

为什么需要进行类型转换呢？

例如我们从网页的文本框中读取的数字，默认是字符串类型的，我们读取以后需要转换为数字类型，例如：将字符串"100"转换为数字100。

1 转换为字符串

先介绍一下将其他数据类型转换为字符串，只需要调用 toString() 函数即可。

举个栗子：

let age = 18;
let str = age.toString();  // 将18转换为字符串复制给 str 变量

console.log("age=", str, ", type:", typeof str);  //输出:age= 18 , type: string
console.log("str=", str, ", type:", typeof str);  //输出:str= 18 , type: string

• 调用方法，就是 .函数名() ，函数主要就是实现某种功能，关于函数后面再讲。
• console.log() 可以接收多个参数，会将多个参数拼接起来。
• 上面 age.toString(); 将 age 中的数值转换为字符串复制给 str。

上面是通过变量调用 .toString() 函数来实现转换，还可以使用字面量来调用，但是数值的字面量需要添加 括号() 。

举个栗子：

let intStr = (18).toString();  // 需要添加括号
let boolStr = true.toString();  // boolean字面量不需要添加括号

上面 .toString() 函数有一个局限性，就是如果一个变量的值为 null 或 undefined，是无法调用 .toString() 方法的，会报错！值为 null 和 undefined 的变量是无法调用方法的。

我们还可以使用另外一种方法，就是使用 String() 函数，将变量作为 String() 的参数。

举个栗子：

let age = 18;
let value = null;

console.log("age=", age, ", type:", typeof age);  // age= 18 , type: number
console.log("value=", value, ", type:", typeof value);  // value= null , type: object

age = String(age);  // 将数值转换为字符串，重新赋值给age
value = String(value);

console.log("age=", age, ", type:", typeof age);  // age= 18 , type: string
console.log("value=", value, ", type:", typeof value);  // value= null , type: string

• 其实在调用 String() 函数的时候，实际还是调用 toString() 函数， null 和 undefined 没有 toString() 函数，会直接转换为 "null" 和 "undefined" 。

2 转换为数值

下面介绍如何将其他类型的数据转换为数值类型。

首先是如何将字符串转换为数值，只用 Number() 函数即可。举个栗子：

let str = '123';
let num = Number(str);
console.log(num, typeof num);  // 123 'number'

• 上面将字符串 '123' 转换为数值 123 ；
• 如果字符串无法转换为数值，例如 123abc ，则会转换为 NaN ；
• 如果是空字符串 '' 或空格字符串 ' ' ，则会被转换为 0 ；
• 如果是布尔值，则 true 转换为 1，false 转换为 0；
• 如果是 null 值，则被转换为 0，如果是 undefined，则会转换为 NaN 。

上面的 Number() 函数适用于所有的数据类型转换为数值类型，还有两个函数专门针对字符串转换为数值：

• parseInt() ：将字符串转换为一个整数；
• parseFloat() ：将字符转换为一个浮点数。

举个栗子：

let str1 = '123';
let str2 = '3.14159';

let num1 = parseInt(str1);
let num2 = parseFloat(str2);
console.log(num1, typeof num1);  // 123 'number'
console.log(num2, typeof num2);  // 3.14159 'number'

• parseInt() 在解析字符串的时候，会从左到右读取字符进行解析，如果是 123abc ，会被读取并转换为 123 ，但是如果是 abc123 则无法被解析，会被转换为 NaN ，如果是 123.456 ，则会转换为 123 ，只能解析整数。

3 转换为布尔值

将其他的数据类型转化为布尔类型，使用 Boolean() 函数即可。

举个栗子：

let num = 1;
let bool = Boolean(num);
console.log(bool, typeof bool);  // true 'boolean'

• 对于数值转布尔值而言，0 和 NaN 转换为 false，其余都转换为 true；
• 对于字符串而言，空字符串 '' 转换为 false，其余都是 true，包括空格字符串 ' ' 和 'false' 字符串；
• null 和 undefined 转换为 false
• 对象都转换为 true。

上面讲的转换的方式是显式转换的，也就是需要明确写出转换的代码，在后面学习运算符的时候，还会讲解如何使用隐式转换，也就是自动转换。

4.10 精度控制

在前面演示 0.1 + 0.2 的时候，结果是 0.30000000000000004，而不是预期的 0.3 ，我们可以如下的几种方式，来控制小数的精度。

4.10.1 toFixed()

toFixed() 方法可以将数字格式化为指定的小数位数，它会对数字进行四舍五入。

举个栗子：

let num = 3.14159;
let result = num.toFixed(2);  // 输出:"3.14"

• 需要注意 toFixed() 方法返回的是字符串！需要用 parseFloat() 转换回数值。

4.10.2 toPrecision()

toPrecision() 方法用于将数字格式化为指定的总有效数字，并返回字符串表示。

举个栗子：

let num = 2.456789;
let precisionNum = num.toPrecision(4); // 结果是 "2.457"

它适用于需要控制整体有效数字的场景。

4.10.3 使用Math对象

Math 对象提供了一些方法来辅助精度控制。例如： Math.round()、Math.floor() 、 Math.ceil() 、Math.trunc() 。

通过它们结合乘法和除法，可以控制小数位数。

下面依次介绍一下。

1 Math.round()

Math.round() 方法可以将数字四舍五入到最接近的整数。

举个栗子：

let num = 3.4275;
let result = Math.round(num * 100) / 100;  
console.log(result);  // 3.43

• Math.round(num * 100) 先将数字扩大 100 倍，变成 342.75 ，然后将小数位四舍五入，则变成了 343；
• 然后除以 100，得到 3.43，实现了小数位的控制。

这种方法返回的是数字类型，方便进一步的数学运算。

2 Math.floor()

Math.floor() 方法向下舍入。它们也可以通过乘法和除法来控制小数位数。

举个栗子：

let num = 3.4275;
let result = Math.floor(num * 100) / 100;
console.log(result);  // 3.42

• Math.floor(num * 100) 先将数字扩大 100 倍，变成 342.75 ，然后将小数位向下舍入，小数点后7大于5也不要了，则变成了 342；
• 然后除以 100，得到 3.42 ，实现了小数位的控制。

3 Math.ceil()

Math.ceil() 方法是向上舍入。

举个栗子：

let num = 3.4215;
let result = Math.ceil(num * 100) / 100;
console.log(result);  // 3.43

• Math.ceil(num * 100) 先将数字扩大 100 倍，变成 342.15 ，然后将小数位向上舍入，小数点后1不够5也进位，则变成了 343；
• 然后除以 100，得到 3.43 ，实现了小数位的控制。

4 Math.trunc()

Math.trunc() 是直接去除小数部分。

举个栗子：

let num = 3.4215;
let result = Math.trunc(num);
console.log(result);  // 3

• 直接去掉小数部分，变成整数，没什么好说的。

4.11 进制

JavaScript 支持多种进制，包括 二进制、八进制、十进制 和 十六进制，但是实际在开发中用的不多。

这里简单了解一下即可。

1 进制表示

let decimal = 123;  // 十进制
let binary = 0b101;  // 二进制表示 5
let octal = 0o10;  // 八进制表示 8
let hexadecimal = 0x1F;  // 十六进制表示 31

console.log(decimal);  // 输出 123
console.log(binary);  // 输出 5
console.log(octal);  // 输出 8
console.log(hexadecimal);  // 输出 31

• 正常写的数字就是十进制；
• 二进制数字使用 0b 或 0B 开头；
• 八进制数字使用 0o 或 0O 开头；
• 十六进制使用 0x 或 0X 开头。

但是在输出数字的时候，都是使用十进制输出的，如果想按指定进制输出，可以以字符串的形式输出：

let number = 255;
console.log(number.toString(2));  // 输出：11111111，将十进制转换为二进制字符串表示
console.log(number.toString(8));  // 输出：377，将十进制转换为八进制字符串表示
console.log(number.toString(16)); // 输出：ff，将十进制转换为十六进制字符串表示

2 进制转换

parseInt() 方法可以将字符串转换为整数，并指定进制。它接受两个参数：要转换的字符串和进制。

举个栗子：

let bin = "101";
let oct = "10";
let hex = "1F";

console.log(parseInt(bin, 2));  // 输出 5，将字符串以二进制转换为十进制
console.log(parseInt(oct, 8));  // 输出 8，将字符串以八进制转换为十进制
console.log(parseInt(hex, 16)); // 输出 31，将字符串以十六进制转换为十进制