4425 字
22 分钟
JS-基础数据类型

目录#

变量#

  • 变量是动态类型的,它们可以存储任何值:

标识符#

  • 字母和数字,但是第一个字符不能是数字。
  • 字符 $ 和 _ 是允许的,用法同字母。
  • 非拉丁字母和象形文字也是允许的,但通常不会使用。

声明变量#

  • let
  • const(不变的,不能被改变)
  • var

使用优先级const >let > var

注意: const声明的对象,其属性可以随意更改(因为其引用始终未变),只有当其整体被赋值改变时,才会报错,无法更改。

const obj = {
name: "John",
}
obj.name = "Jack"; //这是可以的
obj = {} // Assignment to constant variable. 这是不可以的
console.log(obj);

区别1

  • 用 var 声明的变量,不是函数作用域就是全局作用域。它们在代码块外也是可见的
  • (译注:也就是说,var 声明的变量只有函数作用域和全局作用域,没有块级作用域)。
{
let a = 1;
var b = 2;
}
// console.log(a); // ReferenceError: a is not defined
console.log(b); // 2

区别2

  • 使用 var,我们可以重复声明一个变量,不管多少次都行
  • let 在同一作用域下将同一个变量声明两次,则会出现错误
let a = 1;
// let a = 2; // SyntaxError: Identifier 'a' has already been declared
var b = 1;
var b = 2; // 不会报错, b的值以最新声明的为准

区别3

  • 所有的 var 都被“提升”到了函数的顶部
  • 声明会被提升,但是赋值不会。
function fun1(){
a = 0;
console.log(a); // 0
var a;
}
fun1();
function fun1(){
a = 0;
console.log(a); // 0
var a = 1;
}
fun1();
function fun1(){
console.log(a); // undefined
var a = 1;
}
fun1();

区别四

// 以var定义的都会成为全局对象的属性, globalThis 当前环境下的全局对象
var gVar = '全局对象属性';
console.log(globalThis.gVar); // 全局对象属性
let va = '全局对象属性';
console.log(globalThis.va); // undefined

数据类型#

JavaScript 中有八种基本的数据类型(译注:前七种为基本数据类型,也称为原始数据类型,而 object 为复杂数据类型)。

  • 七种原始数据类型:

    • number 用于任何类型的数字:整数或浮点数,在±(253−1) ±(2^{53}-1) 范围内的整数。
    • bigint 用于任意长度的整数。
    • string 用于字符串:一个字符串可以包含 0 个或多个字符,所以没有单独的单字符类型。
    • boolean 用于 true 和 false。
    • null 用于未知的值 —— 只有一个 null 值的独立类型。
    • undefined 用于未定义的值 —— 只有一个 undefined 值的独立类型。
    • symbol 用于唯一的标识符。
  • 以及一种非原始数据类型:

    • object 用于更复杂的数据结构。
  • js中没有字符,只有字符串,单引号''也表示的是字符串

运算符#

运算符优先级表#

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#汇总表

typeof运算符#

let _NaN = NaN; // 非数字
console.log(typeof _NaN); // number
let _Infinity = Infinity; // 无穷大
console.log(typeof _Infinity); // number
let number = 0;
console.log(typeof number); // number
let string = "String";
console.log(typeof string); // string
let string1 = 'string1';
console.log(typeof string1); // string
let string2 = `string2`;
console.log(typeof string2); // string
let boolean = false;
console.log(typeof boolean); // boolean
let object = {};
console.log(typeof object); // object
let arr = [];
console.log(typeof arr); // object
// new 的都是对象, new String()也是对象, 而不是字符串
let array = new Array();
console.log(typeof array); // object
let map = new Map();
console.log(typeof map); // object
let set = new Set();
console.log(typeof set); // object
console.log(typeof null); // object
let func = function () {};
console.log(typeof func); // function
console.log(typeof $undefined); // undefined 未定义的变量
let symbol = Symbol();
console.log(typeof symbol); // symbol
console.log(typeof 1n); // bigint 用于表示大于2^53的整数, 用n结尾

总结:

  1. typeof 可以判断的类型有: number、string、boolean、object、function、undefined、symbol、bigint
  2. typeof 不能判断的类型有:NaN、Infinity、null
  3. null自成类型, 但是typeof会返回 object, 这是js中的错误
  4. 数组、map、set, 因为这些类型的底层都是 object
  5. function底层也是object, 但是typeof会返回 function

数学运算#

  • 除了加法运算是拼接, 其他运算都会先转换为数字再运算
// NaN 除了 NaN ** 0 运算结果为1,其他运算结果都是NaN
console.log(NaN ** 0); // 1
// Infinity 除了 Infinity ** 0 运算结果为1,其他运算结果都是Infinity
console.log(Infinity ** 0); // 1
// js中 1/0 为 Infinity, 0/0 为 NaN, 任何数字运算都不会报错, 最坏的结果是 NaN, 所以在js中数学运算很安全
console.log(1 / 0);
console.log(0 / 0);
// 字符串String与数字Number运算, 除了加法运算是拼接, 其他运算都会先转换为数字再运算
console.log("string" + 1);
console.log("string" - 1);
console.log("string" * 1);
console.log("string" / 1);
console.log("string" ** 1);
console.log("string" % 1);
// 布尔类型与数字运算, true为1, false为0
console.log(true + 1); // 2
console.log(false + 1); // 1
// null为0
console.log(null + 1); // 1
console.log(undefined + 1); // NaN
console.log({} + 1); // [object Object]1

?? 空值合并运算符#

let a = null ?? 1;
console.log(a); // 1
let b = undefined ?? 1;
console.log(b); // 1
// 多层使用
let c = null ?? undefined ?? 2;
console.log(c); // 2
// 只有null或undefined时, 返回最后一个
console.log(null ?? undefined ?? null); // null
// 否则返回第一个值不为null或undefined的值
console.log(null ?? undefined ?? false ?? 0); // false

总结:

  1. 只有null或undefined时, 返回最后一个
  2. 否则返回第一个 不为null或undefined的值
  3. ?? 运算符的优先级与 || 相同, 比 && 低

|| 逻辑或运算符#

  • 除了普通的逻辑或运算,还可以返回第一个真值
  • 一个或运算 || 的链,将返回第一个真值,如果不存在真值,就返回该链的最后一个值。
  • 相比??,??更严格,只有是null 或 undefined才返回右边的值
  • 而|| 除了null 和 undefined,还有0 、""、false值为false的都会返回右边的值
console.log(false || 1); // 1
// 有真值时, 返回第一个真值
console.log(false || 0 || 1 || true); // 1
// 无真值时, 返回最后一个值
console.log(false || 0 || "" || null || undefined); // undefined

&& 逻辑与运算符#

  1. 有假值时, 返回第一个假值
  2. 无假值时, 返回最后一个值
  3. 注意: || 和 && 都不会将值转为布尔返回, 而是直接返回原值
// 有假值时, 返回第一个假值
console.log(1 && 2 && 0 && false); // 0
// 无假值时, 返回最后一个值
console.log(1 && 2 && 3 && 4); // 4
  • 下面四种方式效果等同
// 方式一
if(true){
console.log("true");
}
// 方式二
!true || console.log("true");
// 方式三
true && console.log("true");
// 方式四
true ? console.log("true") : "";

注意:

// 不能在不使用括号的情况下混用 "&&" 和 "??" 操作。
// let x = 1 && 2 ?? 3; // 报错
let y = (1 && 2) ?? 3; // 2

解构赋值#

支持 任何可迭代对象

  • 对象
  • 数组
  • 字符串
  • Set
  • Map

解构数组#

// 数组中解构赋值, 按照顺序赋值
let arr = [1, 2, 3, 4, 5];
let [a, b, c, d, e] = arr;
console.log(a, b, c, d, e); // 1 2 3 4 5
// 只取前两个
let [f,g] = arr;
console.log(f, g); // 1 2
// 只取后两个
let [, , , h, i] = arr;
console.log(h, i); // 4 5

解构对象#

// 对象中结构赋值依照属性名
let obj = {
name: '多远都要在一起',
songer: '邓紫棋',
}
let { name, songer } = obj;
console.log(name, songer); // 多远都要在一起 邓紫棋
// 只取songer属性
{
let {songer} = obj;
console.log(songer); // 邓紫棋
}
// 取值出来不想叫之前的名字怎么办? 重新更名
let {name: song_name} = obj;
console.log(song_name); // 多远都要在一起
{
// 剩余所有属性都会在rest中
let {name, ...rest} = obj;
console.log(rest); // { songer: '邓紫棋' }
}
// 解构赋值 拷贝对象
let { ...obj1 } = obj;
console.log(obj1); // { name: '多远都要在一起', songer: '邓紫棋' }
// 扩展运算符(Spread语法) 拷贝对象
let obj2 = { ...obj };
console.log(obj2); // { name: '多远都要在一起', songer: '邓紫棋' }

解构 字符串/Set/Map#

// 字符串
{
let [a,b,c] = "abc";
console.log(a,b,c); // a b c
}
// Set
{
let [a,b,c] = new Set([1,2,3]);
console.log(a,b,c); // 1 2 3
}
// Map
{
let [a,b,c] = new Map([['a',1],['b',2],['c',3]]);
console.log(a,b,c); // [ 'a', 1 ] [ 'b', 2 ] [ 'c', 3 ]
}

遍历对象/Map键值对#

let user = {
name: "John",
age: 30,
};
// 使用循环遍历键—值对
for (let [key, value] of Object.entries(user)) {
console.log(`${key}: ${value}`); // name: John age: 30
}
let map = new Map([
["name", "John"],
["age", 30],
]);
for (let [key, value] of map) {
console.log(`${key}: ${value}`); // name: John age: 30
}

交换变量值#

let a = "javascript";
let b = "java";
[a, b] = [b, a];
console.log(a, b); // java javascript

解构默认值#

let [java = "java", javascript = "javascript"] = ["詹姆斯·高斯林"];
console.log(java, javascript); // 詹姆斯·高斯林 javascript
function default_() {
return "default";
}
let [java = "java", javascript = default_()] = ["詹姆斯·高斯林"];
console.log(java, javascript); // 詹姆斯·高斯林 default

无声明时#

let title, width, height;
// 现在就可以了, 需在外面加一个括号, 否则js引擎认为 {} 是一个代码块, 而不是解构赋值语法
({title, width, height} = {title: "Menu", width: 200, height: 100});
console.log( title ); // Menu

嵌套解构#

let obj = {
name: "多远都要在一起",
songer: "邓紫棋",
}
let {songer: [a, b, c]} = obj;
console.log(a,b,c); // 邓 紫 棋

可选函数参数#

// 智能函数参数
function fun({ name, songer = "邓紫棋" }) {
console.log(name, songer);
}
fun({ name: "光年之外" }); // 光年之外 邓紫棋
fun({ songer: "GEM" }); // undefined GEM
fun({}); // undefined 邓紫棋
// fun(); //Cannot destructure property 'name' of 'undefined' as it is undefined.

类型转换#

一. 其他类型转数字#

1. 字符串类型转数字#

  • 只有parseInt方法会将123abc456 转为里面的第一个数字, 其他方式都是NaN
console.log(parseInt("123abc456")); // 123
console.log(parseInt('a')); // NaN
console.log(Number("123")); // 123
console.log(Number("123abc456")); // NaN
console.log( +true ); // 1
console.log( +"" ); // 0
console.log(+null); // 0
console.log(+undefined); // NaN
console.log(+"123abc456"); // NaN
+prompt("tips:",100)
100
prompt("tips:",100)
"100"

2. 布尔类型转数字#

  • true 转为 1
  • false 转为 0

3. 其他#

  • null 转为0
  • undefined 转为 NaN

二. 其他类型转字符串#

1. 数字转字符串#

console.log(String(123));
console.log(123 + "");
let a = 123;
console.log(a.toString()); // 只能跟在变量后面

三. 其他类型转布尔类型#

只有以下5种情况会转为false,其他都为true

  1. 数字类型中的0 和NaN
  2. 字符串类型中的空字符串""
  3. null
  4. undefined
console.log(Boolean(0)); // false
console.log(Boolean("")); // false
console.log(Boolean(null)); // false
console.log(Boolean(undefined)); // false
console.log(Boolean(NaN)); // false
console.log(!!""); // false

四. 转为数组#

  • Spread 语法只适用于可迭代对象。
  • Array.from 适用于类数组对象也适用于可迭代对象,因此Array.from 往往更通用。
let str = "Hello";
// Array.from 将可迭代对象转换为数组
console.log(Array.from(str)); // H,e,l,l,o
console.log([...str]); // H,e,l,l,o

symbol #

  • symbol 是带有可选描述的“原始唯一值”。
  • 创建时,我们可以给 symbol 一个描述(也称为 symbol 名)
  • 即使 描述相同,symbol的值也不会相同
  • symbol不会被自动转换为字符串
  • symbol 属性不参与 for..in 循环。同样也不会在Object.keys(), Object.values()中遍历
  • 但是symbol属性会参与Object.assign的浅拷贝
let id = Symbol("id");
let user = {
name: "John",
age: 30,
[id]: 123
};
for (let key in user) console.log(key);
/*
name
age
*/
console.log(Object.keys(user)); // [ 'name', 'age' ]
console.log(Object.values(user)); // [ 'John', 30 ]
  • 用处1:避免被第三方库重写属性,因为symbol作为属性总是唯一的, 若本地有属性id,第三方库也有属性id,name本地的属性id将会被重写,引发错误
let id1 = Symbol("id");
let id2 = Symbol("id");
console.log(id1 == id2); // false
console.log(id1.description); // id
console.log(id1.toString()); // Symbol(id)
  • symbol作对象的键
let id = Symbol("id");
let user = {
// 属性为变量时, 需用方括号括起来
[id]: 123,
}
console.log(user); // { [Symbol(id)]: 123 }

全局注册表#

// 从全局注册表中读取
let id = Symbol.for("id"); // 如果该 symbol 不存在,则创建它
// 再次读取(可能是在代码中的另一个位置)
let idAgain = Symbol.for("id");
// 相同的 symbol
console.log( id === idAgain ); // true

获取全局注册表中的描述

let id = Symbol.for("id");
console.log(id.description); // id
console.log(Symbol.keyFor(id)); // id
  • Symbol.for() 形式创建的,具有全局性,也就是描述能区分两个Symbol是否相同
  • 而Symbol()形式创建的,是局部的,任意两个Symbol都不会相同。

数字类型和BigInt#

  • 常规整数不能安全地超过(253−1)(2^{53}-1) 或小于 −(253−1)-(2^{53}-1)
  • 溢出 64 位存储,变成一个特殊的数值 Infinity
  • BigInt可以存储任意长度的数字

表示方法#

let a = 7300000000;
let b = 7_300_000_000;
let c = 7.3e9;
console.log(a,b,c); // 7300000000 7300000000 7300000000
console.log(a===b && b===c); // true

进制#

// 十六进制
let a = 0xff;
let b = 0XFF;
console.log(a,b); // 255 255
// 八进制
let c = 0o377;
let d = 0O377;
let e = 0377; // 推荐, 以0开头
console.log(c,d,e); // 255 255
// 二进制
let f = 0b11111111;
let g = 0B11111111;
console.log(f,g); // 255 255
  • toString方法
  • base 的范围可以从 2 到 36。默认情况下是 10。
let num = 255;
console.log(num.toString(2)); // 11111111
console.log(num.toString(8)); // 377
console.log(num.toString(16)); // ff
// 36进制可用作转换url
let num1 = 1234567891011121314151617181920n;
console.log(num1.toString(36)); // 3boyk6ne1wmqhud5xvxc
// 直接使用字面量
// 255.toString(2) // 报错, 因为 JavaScript 语法隐含了第一个点之后的部分为小数部分
255..toString(2); // 11111111
(255).toString(2); // 11111111

舍入#

函数 toFixed(n) 将数字舍入到小数点后 n 位,并以字符串形式返回结果。

// 舍入
console.log(3.144.toFixed(2)); // 3.14
console.log(3.145.toFixed(2)); // 3.15
console.log(3.14.toFixed(5)); // 3.14000

精度问题#

  • 在处理小数时避免相等性检查
console.log(0.1 + 0.2 === 0.3); // false
console.log(6.35.toFixed(1) ); // 6.3 为什么不是6.4呢?
console.log(6.35.toFixed(20) ); // 6.34999999999999964473 , 所以并未"五入"
console.log(Math.round(6.35 * 10) / 10); // 6.4

isNaN | isFinite#

值 “NaN” 是独一无二的,它不等于任何东西,包括它自身。

console.log( NaN === NaN ); // false
  • isFinite(value) 将其参数转换为数字,如果是常规数字而不是 NaN/Infinity/-Infinity,则返回 true
  • isNaN判断一个值是否为NaN
console.log(isNaN(NaN)); // true
console.log(isNaN("str")); // true
console.log(isFinite("15")); // true
console.log(isFinite("str")); // false,因为是一个特殊的值:NaN
console.log(isFinite(Infinity)); // false,因为是一个特殊的值:Infinity

parseInt | parseFloat#

  • 使用加号 + 或 Number() 的数字转换是严格的。如果一个值不完全是一个数字,就会失败.
  • 但是parseInt和parseFloat并不是, 它们可以从字符串中“读取”数字,直到无法读取为止.
console.log(+"100px"); // NaN
console.log(Number("100px")); // NaN
console.log(parseInt("100px")); // 100
console.log(parseInt("ff", 16)); // 255
console.log(parseInt("a123")); // NaN

字符串类型#

String - JavaScript | MDN String 对象用于表示和操作字符序列。 https://developer.mozilla.org/zh/docs/Web/JavaScript/Reference/Global_Objects/String

字符串特性:

  • 字符串无法修改,但是重新赋值一个新字符串
let a = "abc";
a[0] = "A";
console.log(a); // abc

创建字符串#

let string1 = "abc";
let string2 = "abc";
let string3 = `abc`;
// 多行字符串, 双引号 单引号只能使用换行符\n实现多行字符串
let string4 = "math\nenglish\nchinese";
let string5 =
`math
english
chinese`;
// 效果相同, 但是显然使用反引号的方式更加直观
console.log(string4);
console.log(string5);
// 字符串中支持变量, 使用${}包裹
let string6 = `北京时间: ${new Date().toLocaleString()}`;
console.log(string6); // 北京时间: 2023/1/9 15:07:02
let string7 = "I'm a good boy"
let string8 = 'I\'m a good boy'
// 对于字符串中出现的单引号, 双引号不需要转义, 更加便捷
let string9 = `I'm a good boy`

字符串方法#

// 注意: length是一个属性, 不是一个方法, 所以 .length() 是错误的
// 调用方法时, 会创建一个临时的String对象, 然后调用该对象的方法
console.log("abc".length); // 3
// 如果没有找到字符,[] 返回 undefined,而 charAt 返回一个空字符串:
console.log("abc".charAt(0)); // a
console.log("abc"[0]); // a

查找子串#

indexOf:它从给定位置 pos 开始,在 str 中查找 substr,如果没有找到,则返回 -1,否则返回匹配成功的位置。

let string = "to be or not to be, that's a question";
console.log(string.indexOf("be")); // 3
// 从第4个位置开始寻找
console.log(string.indexOf("be",4)); // 16
let str = "Widget";
// ~(-1) 等于 0, 0的布尔值是 false
if (~str.indexOf("Widget")) {
consolelog( 'Found it!' ); // 正常运行
}
// includes
let str = "Widget";
if (str.includes("Widget")) {
consolelog( 'Found it!' ); // 正常运行
}

获取子串#

JavaScript 中有三种获取字符串的方法:substring、substr 和 slice

  1. substring(startIndex, [endIndex]) 当endIndex省略时, 默认截取到最后一位, 参数允许start大于end,但是结果与相反写相同。eg:substring(2,4)与substring(4,2) 结果相同,参数中的负数会被转为0
  2. slice与substring作用相同,参数要求方面有些不同,当start大于end时,会返回空字符串,当参数为负数时,从字符串最后一位开始计算(最后一位索引为-1)。eg:"stringify".slice(-4,-1)结果是gif
  3. substr(startIndex, [length])不是指定末位索引,而是直接指定截取的子串长度。省略默认截取到字符串最后。start允许为负数,从字符串末位开始计算。
  4. 推荐slice方法
方法选择方式……负值参数
slice(start, end)从 start 到 end(不含 end)允许
substring(start, end)从 start 到 end(不含 end)负值被视为 0
substr(start, length)从 start 开始获取长为 length 的字符串允许 start 为负数

比较字符串#

调用 str.localeCompare(str2) 会根据语言规则返回一个整数,这个整数能指示字符串 str 在排序顺序中排在字符串 str2 前面、后面、还是相同:

  • 如果 str 排在 str2 前面,则返回负数。
  • 如果 str 排在 str2 后面,则返回正数。
  • 如果它们在相同位置,则返回 0。
console.log('Österreich'.localeCompare('Zealand')); // -1

布尔类型#

  • 只有true和false

类型转换为数值时时

  • true 转为 1
  • false 转为 0
JS-基础数据类型
https://blog.tiamix.cn/posts/js-基础数据类型/
作者
Tiam
发布于
2023-01-13
许可协议
CC BY-NC-SA 4.0