# JavaScript教程 - 4 基础语法
# 4.1 注释
在学习基础语法之前先介绍一下注释。
我们在学习任何语言，都会有注释，注释的作用就是向别人解释我们编写的代码的含义和逻辑，使代码有更好的可读性。
注释不是程序，是不会被执行的。所以我们也可以使用注释，注释掉暂时不需要执行的代码。
注释一般分类两类，单行注释和多行注释。
# 1 单行注释
单行注释以 // 开头，井号右边为注释内容。
例如：
// 我是单行注释，打印Hello World
alert('Hello World!') // 这里是注释
2
注意：// 号和注释内容一般建议以一个空格隔开，这是代码规范，建议大家遵守。
单行注释一般用于对一行或一小部分代码进行解释。
# 2 多行注释
多行注释以 /**/ 括起来，中间的内容为注释内容，注释内容可以换行。
/*
我是多行注释，
我来哔哔两句
*/
alert('Hello World!')
2
3
4
5
多行注释适合对一段代码块、一个函数或者一个较大的功能模块进行详细的说明，关于函数，后面会讲。
# 4.2 代码格式
# 1 大小写
JS 代码是严格区分大小写的。
举个栗子：
// 语句1
alert('Hello!')
// 语句2
Alert('Hello!')
2
3
4
5
- 上面的两句代码是不一样的，
alert()是浏览器提供的功能，所以Alert在执行的时候，会报错，找不到。
可以在浏览器的控制台看到错误：
# 2 空格与换行
JS 代码中的空格和换行会被忽略。
举个栗子：
alert( 'Hello' );
alert(
'Hello'
);
2
3
4
5
- 上面的写法都是一样的，空格和换行会被忽略；
- 但你别傻乎乎的在
alert单词或'Hello'中间空格和换行。
# 3 语句结束符
JS 的每条语句应该以分号 ; 结束。
alert('Hello');
console.log('Hello');
2
但是不写分号也能正常运行，JS 解释器会自动添加分号（ASI机制），但是并不能在所有场景下都能准确无误的添加分号。
所以推荐手动加上。如果语句都添加分号，多条语句是可以写在一行的。没加是不行的，需要换行写，否则解释器不知道语句结束。
但是也有一些语法检查工具，推荐是不写分号的，所以根据自己喜好吧。
# 4.3 字面量
什么是字面量？
字面量就是在代码中，写下来的固定的值。
举个栗子：
alert(123)
alert(3.14)
alert('Hello')
alert(true)
2
3
4
- 上面的
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
2
3
- 定义变量使用
let关键字，上面定义了一个变量，变量名称是age，变量名称自定义； - 给变量赋值使用
=。 - 为变量赋值后，就可以使用变了，上面使用
console.log()打印变量的值。
也可以在定义变量的时候同时赋值：
let age = 18; // 定义变量并赋值
console.log(age); // 打印age的值
2
- 使用
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
2
3
4
5
6
7
8
9
10
11
上面定义了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, 变量的值可以修改为任意类型
2
3
4
5
6
7
8
9
可以看到变量的值可以被修改，而且可以参与运算。而且一个变量可以被赋予任意类型的数据，可以说是有一点放肆了。
通过在变量中存储数据，然后就可以在很多地方使用变量了，还可以改变变量的值。
# 3 旧的定义变量的方式
定义变量使用 let 关键字，以前 JS 中定义变量是使用 var 关键字的：
var age = 18;
现在也可以用，但是这两者有一些区别，var 没有块级作用域，有时候会有一些问题，作用域先不用了解。
在现代 JS 开发中，推荐使用 let 关键字来定义变量。
甚至你不使用关键字都可以：
age = 18;
console.log(age);
2
但是不推荐。
# 4.5 常量
变量是可以变的，常量就是不可以变的，定义了以后，值就不能修改了。有时候我们定义了一个值就不想它被修改，例如定义了一个圆周率，这个值就是固定的，不能在其他地方修改这个值。
常量使用 const 关键字定义。
举个栗子：
const PI = 3.1415926;
console.log(PI);
2
- 推荐常量的名称使用大写字母来定义（多个单词使用下划线分隔），这样一看到就知道是常量，无法修改。
如果修改常量的值，会发生错误：
# 4.6 标识符
什么是标识符？
标识符就是名字，例如变量的名字、方法的名字、类的名字，我们可以自定义名字的都。
起名字肯定会有限制，肯定不能 张Three 这样起名字，所以标识符也有限制。
# 1 标识符命名规则
标识符需要遵守一下规则：
- 只能是字母、数字、下划线_、
$； - 不能使用数字开头，可以英文、下划线、
$开头；
a // 可以
a_b // 可以
_a // 可以
a123 // 可以
a_b_a // 可以
a$ // 可以
$_a // 可以
123 // 错误
123_ // 错误
123_a // 错误
2
3
4
5
6
7
8
9
10
11
- 大小写敏感，大小写不同是不同的标识符；
name = "zhangsan"
Name = "lisi" // 和 name 是不同的标识符
2
- 不能使用关键字，关键字就是 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 |
这么多怎么记？不用记！不用记！不用记！后面每个关键字都会学到，自然知道每个关键字是做什么用的，另外你用了代码会报错。
- 不要使用内置的变量、函数或类名作为变量名
let alert = 123;
alert('Hello');
2
alert 是 JS 内置的用于在浏览器弹出提示框的，现在定义了一个变量叫 alert，会覆盖内置的变量、函数等。
# 2 变量命名规范
使用上面说的规则，我们可以定义变量名了。
但是为了优雅、统一、规范，我们在定义变量名时，还应该遵守以下规范，虽然你不遵守，没人开枪打死你，但是建议你遵守。
- 见名知意
看见一个变量名，就知道这个变量名是干嘛的。
let a = "zhangsan" // 看到a，鬼知道a是干嘛的
let name = "zhangsan" // 看到name，就知道这是个名字，简单明了
2
- 变量名使用首字母小写的驼峰命名规则：
let firstName = "Jim"
let studentNickname = "胖墩"
2
- 类名使用首字母大写的驼峰命名规则：
class Person {
}
2
类后面再讲，不着急。
- 常量使用全字母大写，多个单词使用下划线分隔
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
2
3
4
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，结果不准确
2
3
4
5
- 可以看到超过范围就不准确了，所以在 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
2
3
4
另外，计算机不能进行精确的小数运算，这个不是 JS 的问题。
举个栗子：
let num = 0.1 + 0.2;
console.log(num); // 输出：0.30000000000000004
2
如果数值太大，会使用 Infinity 来表示：
let num = 9999 ** 9999; // 9999的9999次方
console.log(num); // 输出：Infinity，结果不准确
2
如果一个计算结果得到的不是数值，会使用 NaN （Not a Number）来表示：
let num = 123 - 'abc'; // 数字减去字符串
console.log(num); // 输出：NaN
2
所以值 Infinity 和 NaN 都是数字类型的，但是我们在写代码的时候，尽量避免出现 Infinity 和 NaN 。
# 2 大整数bigint
上面说了 number 类型表示的数字有范围限制，如果要表示很大的数该怎么办呢？
在 ES11 中引入了 bigint，可以处理非常大的整数，只要有内存。大整数以 n 结尾。
举个例子：
let bigIntNum = 1234567890123456789012345678901234567890n;
console.log(bigIntNum); // 输出 1234567890123456789012345678901234567890n
2
需要注意 bigint 和 number 是不能直接进行运算的：
let a = 10n;
let b = 20;
console.log(a + b);
2
3
上面的代码会报错，不能进行运算，因为 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
2
3
4
# 5 空值null
null 是一个特殊的原始值，表示“空”或“无值”。
举个栗子：
let b = null;
console.log(b); // 输出 null
2
- 如果有一个变量不想再用了，可以将其设置为 null。
- 如果有一个变量需要初始化，但是不知道赋值多少，可以赋值为 null，表示它尚未获得有效值，等待后续赋值。
# 6 未定义undefined
undefined 是一种基本数据类型，表示变量声明了但未被赋值，所以一个变量未赋值的会自动被赋予 undefined 值。
举个栗子：
let a;
console.log(a); // 输出 undefined，因为 a 没有赋值
2
注意区分 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 都是唯一的
2
3
Symbol 可以用于定义对象的私有属性，防止属性被意外修改，后面再讲解。
# 4.8 字符串
# 4.8.1 字符串定义方式
字符串有3种不同的定义方式：
方式一：双引号定义法
let text1 = "我是一个字符串";
方式二：单引号定义法
let text2 = '我是一个字符串';
方式三：模板字符串定义法
模板字符串定义法使用反引号定义，反引号是 1 左边的那个键，反引号定义的字符串可以换行，其中的：
let text3 = `我是一个字符串，
我还可以换行`;
2
- 内容输出的时候，也会换行。
# 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'
2
3
4
5
同样，如果你想在字符串中输出 \t ，你可能会这样写：
let str = "Hello \t \"JavaScript\""
console.log(str); // Hello "JavaScript"
2
但运行完成结果却没有 \t ，因为 \t 是制表符；同样 \n 是换行符，如果想在字符串中输出 \t 或 \n 等特殊字符，也是需要对 斜杠 \ 进行转义：
let str = "Hello \\t \"JavaScript\""
console.log(str); // Hello \t "JavaScript"
2
同样，输出 \ 也需要转义，要输出两个 \\ ，都需要进行转义：
let str = "Hello \\\\ \"JavaScript\""
console.log(str); // Hello \\ "JavaScript"
2
# 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
3
# 2 使用模板字符串
反引号定义的模板字符串，可以通过 ${} 插入变量或表达式。
举个栗子：
let name = "张三";
let age = 10;
console.log(`Hello，我是${name}，我今年才${age}岁，我是法外狂徒`) // 输出:Hello，我是张三，我今年才10岁，我是法外狂徒
2
3
- 这种方式可以说是非常适合字符串拼接了。
# 3 使用concat()方法
使用字符串的 concat() 方法也可以用于拼接字符串。
let str1 = "Hello";
let str2 = "World";
let result = str1.concat(" ", str2, "!"); // 拼接三个字符" "、str、"!"
console.log(result); // "Hello World!"
2
3
4
- 需要注意
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"
2
3
4
5
6
7
8
9
10
11
typeof的结果是字符串。typeof null返回的是"object"，这是 JavaScript 的一个历史遗留问题，应该算一个设计缺陷，所以typeof无法判断一个变量是否为null。
需要注意， typeof 不是检查变量的类型，变量是没有类型的，检查的是变量中数据的类型。
let value = "foooor";
console.log(typeof value); // "string"
value = 123;
console.log(typeof value); // "number"
2
3
4
5
- 可以看到 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
2
3
4
5
- 调用方法，就是
.函数名()，函数主要就是实现某种功能，关于函数后面再讲。 console.log()可以接收多个参数，会将多个参数拼接起来。- 上面
age.toString();将age中的数值转换为字符串复制给str。
上面是通过变量调用 .toString() 函数来实现转换，还可以使用字面量来调用，但是数值的字面量需要添加 括号() 。
举个栗子：
let intStr = (18).toString(); // 需要添加括号
let boolStr = true.toString(); // boolean字面量不需要添加括号
2
上面 .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
2
3
4
5
6
7
8
9
10
11
- 其实在调用
String()函数的时候，实际还是调用toString()函数，null和undefined没有toString()函数，会直接转换为"null"和"undefined"。
# 2 转换为数值
下面介绍如何将其他类型的数据转换为数值类型。
首先是如何将字符串转换为数值，只用 Number() 函数即可。举个栗子：
let str = '123';
let num = Number(str);
console.log(num, typeof num); // 123 'number'
2
3
- 上面将字符串
'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'
2
3
4
5
6
7
parseInt()在解析字符串的时候，会从左到右读取字符进行解析，如果是123abc，会被读取并转换为123，但是如果是abc123则无法被解析，会被转换为NaN，如果是123.456，则会转换为123，只能解析整数。
# 3 转换为布尔值
将其他的数据类型转化为布尔类型，使用 Boolean() 函数即可。
举个栗子：
let num = 1;
let bool = Boolean(num);
console.log(bool, typeof bool); // true 'boolean'
2
3
- 对于数值转布尔值而言，
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"
2
- 需要注意
toFixed()方法返回的是字符串！需要用parseFloat()转换回数值。
# 4.10.2 toPrecision()
toPrecision() 方法用于将数字格式化为指定的总有效数字，并返回字符串表示。
举个栗子：
let num = 2.456789;
let precisionNum = num.toPrecision(4); // 结果是 "2.457"
2
它适用于需要控制整体有效数字的场景。
# 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
2
3
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
2
3
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
2
3
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
2
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
2
3
4
5
6
7
8
9
- 正常写的数字就是十进制；
- 二进制数字使用
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
3
4
# 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，将字符串以十六进制转换为十进制
2
3
4
5
6
7
← 03-HelloWorld 05-运算符 →