4425 字
22 分钟
JS-基础数据类型
目录
变量
- 变量是动态类型的,它们可以存储任何值:
标识符
- 字母和数字,但是第一个字符不能是数字。
- 字符
$和_是允许的,用法同字母。 - 非拉丁字母和象形文字也是允许的,但通常不会使用。
声明变量
letconst(不变的,不能被改变)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 definedconsole.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用于任何类型的数字:整数或浮点数,在 范围内的整数。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结尾总结:
- typeof 可以判断的类型有: number、string、boolean、object、function、undefined、symbol、bigint
- typeof 不能判断的类型有:NaN、Infinity、null
- null自成类型, 但是typeof会返回 object, 这是js中的错误
- 数组、map、set, 因为这些类型的底层都是 object
- function底层也是object, 但是typeof会返回 function
数学运算
- 除了加法运算是拼接, 其他运算都会先转换为数字再运算
// NaN 除了 NaN ** 0 运算结果为1,其他运算结果都是NaNconsole.log(NaN ** 0); // 1
// Infinity 除了 Infinity ** 0 运算结果为1,其他运算结果都是Infinityconsole.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为0console.log(true + 1); // 2console.log(false + 1); // 1// null为0console.log(null + 1); // 1
console.log(undefined + 1); // NaNconsole.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总结:
- 只有
null或undefined时, 返回最后一个 - 否则返回第一个 不为
null或undefined的值 ??运算符的优先级与||相同, 比&&低
|| 逻辑或运算符
- 除了普通的逻辑或运算,还可以返回第一个真值
- 一个或运算
||的链,将返回第一个真值,如果不存在真值,就返回该链的最后一个值。 - 相比
??,??更严格,只有是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&& 逻辑与运算符
- 有假值时, 返回第一个假值
- 无假值时, 返回最后一个值
- 注意:
||和&&都不会将值转为布尔返回, 而是直接返回原值
// 有假值时, 返回第一个假值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 GEMfun({}); // undefined 邓紫棋// fun(); //Cannot destructure property 'name' of 'undefined' as it is undefined.类型转换
一. 其他类型转数字
1. 字符串类型转数字
- 只有
parseInt方法会将123abc456转为里面的第一个数字, 其他方式都是NaN
console.log(parseInt("123abc456")); // 123console.log(parseInt('a')); // NaNconsole.log(Number("123")); // 123console.log(Number("123abc456")); // NaNconsole.log( +true ); // 1console.log( +"" ); // 0console.log(+null); // 0console.log(+undefined); // NaNconsole.log(+"123abc456"); // NaN+prompt("tips:",100)100prompt("tips:",100)"100"2. 布尔类型转数字
true转为1false转为0
3. 其他
null转为0undefined转为NaN
二. 其他类型转字符串
1. 数字转字符串
console.log(String(123));console.log(123 + "");let a = 123;console.log(a.toString()); // 只能跟在变量后面三. 其他类型转布尔类型
只有以下5种情况会转为false,其他都为true
- 数字类型中的
0和NaN - 字符串类型中的空字符串
"" nullundefined
console.log(Boolean(0)); // falseconsole.log(Boolean("")); // falseconsole.log(Boolean(null)); // falseconsole.log(Boolean(undefined)); // falseconsole.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,oconsole.log([...str]); // H,e,l,l,osymbol
- 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);/*nameage*/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); // falseconsole.log(id1.description); // idconsole.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");
// 相同的 symbolconsole.log( id === idAgain ); // true获取全局注册表中的描述
let id = Symbol.for("id"); console.log(id.description); // id console.log(Symbol.keyFor(id)); // idSymbol.for()形式创建的,具有全局性,也就是描述能区分两个Symbol是否相同- 而
Symbol()形式创建的,是局部的,任意两个Symbol都不会相同。
数字类型和BigInt
- 常规整数不能安全地超过 或小于
- 溢出 64 位存储,变成一个特殊的数值
Infinity BigInt可以存储任意长度的数字
表示方法
let a = 7300000000;let b = 7_300_000_000;let c = 7.3e9;
console.log(a,b,c); // 7300000000 7300000000 7300000000console.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 255toString方法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.4isNaN | isFinite
值 “NaN” 是独一无二的,它不等于任何东西,包括它自身。
console.log( NaN === NaN ); // falseisFinite(value)将其参数转换为数字,如果是常规数字而不是NaN/Infinity/-Infinity,则返回trueisNaN判断一个值是否为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,因为是一个特殊的值:InfinityparseInt | parseFloat
- 使用加号
+或Number()的数字转换是严格的。如果一个值不完全是一个数字,就会失败. - 但是
parseInt和parseFloat并不是, 它们可以从字符串中“读取”数字,直到无法读取为止.
console.log(+"100px"); // NaNconsole.log(Number("100px")); // NaNconsole.log(parseInt("100px")); // 100
console.log(parseInt("ff", 16)); // 255console.log(parseInt("a123")); // NaN字符串类型
字符串特性:
- 字符串无法修改,但是重新赋值一个新字符串
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 =`mathenglishchinese`;// 效果相同, 但是显然使用反引号的方式更加直观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)); // 16let str = "Widget";// ~(-1) 等于 0, 0的布尔值是 falseif (~str.indexOf("Widget")) { consolelog( 'Found it!' ); // 正常运行}// includeslet str = "Widget";
if (str.includes("Widget")) { consolelog( 'Found it!' ); // 正常运行}获取子串
JavaScript 中有三种获取字符串的方法:substring、substr 和 slice
substring(startIndex, [endIndex])当endIndex省略时, 默认截取到最后一位, 参数允许start大于end,但是结果与相反写相同。eg:substring(2,4)与substring(4,2)结果相同,参数中的负数会被转为0slice与substring作用相同,参数要求方面有些不同,当start大于end时,会返回空字符串,当参数为负数时,从字符串最后一位开始计算(最后一位索引为-1)。eg:"stringify".slice(-4,-1)结果是gifsubstr(startIndex, [length])不是指定末位索引,而是直接指定截取的子串长度。省略默认截取到字符串最后。start允许为负数,从字符串末位开始计算。- 推荐
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转为1false转为0