01-JavaScript-数据类型

js数据类型分为基本数据类型、引用数据类型两大类

一、基本数据类型

值存在栈中，赋值传值

1.1、数字类型Number

js中，数字是不区分整数还是小数的，当数字无限大时，用Infinity表示，计算的时候出现错误，用NaN表示非数。

let a = 123;
let b = 1.23;
let c = -29;
1
2
3

let a = 10;
let b = 'qwer';
console.log(a/c); // NaN
console.log(2/0); // Infinity
1
2
3
4

数字的常见操作

let a = 1 + 1;
let b = 2 - 1;
let c = 2 * 2;
let d = 4 / 2;
let e = 5 % 2; // 取余 1
1
2
3
4
5

使用Math对象中提供的方法进行数值操作:

• 向下取整，Math.floor()方法

let a = Math.floor(2.47); // 2
1

• 向上取整，Math.ceil()方法

let a = Math.ceil(2.47); // 3
1

• 四舍五入，Math.round()方法

let a = Math.ceil(2.47); // 2
let a = Math.ceil(2.57); // 3
1
2

• 格式化成特定位数小数的字符串，toFixed()方法

let a = 1.2345; 
let b = a.toFixed(2); // 1.23
1
2

• 随机数，Math.random()方法

let a = Math.random(); // 随机一个0-1的数，不包含1
let b = Math.floor(Math.random()*100); // 随机一个0-99的整数
1
2

• 数值判断，isNaN()方法来判断是否是数字，isFinite()方法来判断一个值是否为有限数值

let a = 'test';
let b = 12.34;
let c = isNaN(a); // true
let d = isFinite(b); // true
1
2
3
4

1.2、字符串String

定义方式

let str1 = 'test';
let str2 = "test";
let str3 = `test`
1
2
3

字符串操作方法:

• length 获取字符串长度

let str = 'abcdefg';
let len str.length; // 7
1
2

• charAt()、charCodeAt() 获取指定位置的值

let str = 'abcdefg';
let char = str.charAt(1); // b 指定位置的值
let charCode = str.charCodeAt(1); // 98 该字符code码
1
2
3

• indexOf()、lastIndexOf()、includes()、startsWith()、endsWith() 是否包含特定字符

let str = 'abcabc';
let v = str.indexOf('b');  // 1 包含第一个b的序号，不包含则返回-1
let vLast = str.lastIndexOf('b');  // 4 包含最后一个b的序号
let vFlag =  str.includes('b'); // true  是否包含b
let sFlag = str.startsWith('a'); // true 开始是否包含a
let eFlag = str.endsWith('a'); // false 结尾是否包含a
1
2
3
4
5
6

• concat 拼接字符串

let str1 = 'abc';
let str2 = 'def';
let str3 = str2.concat(str1); // defabc
1
2
3

• split 按照特定字符拆分成数组

let str = 'a,b,c,d,e,f';
let arr = str.split(',');    // ['a', 'b', 'c', 'd', 'e', 'f']
1
2

• slice(start,end)、substring(start,end)、substr(start,length) 截取字符串

let str = 'abcdefgh';
let sliceStr = str.slice(1,5);  // bcde
let substringStr = str.substring(1,5); // bcde
let substrStr = str.substr(1,5); // bcdef
1
2
3
4

• toLowerCase()、toUpperCase() 字符串大小写转换

• replace()、match()、search() 字符串模式匹配

• trim()、trimStart()、trimEnd() 移除字符串收尾空白符

• valueOf()、toString() 获取字符串

• padStart()、padEnd() 补齐字符串长度

• parseInt()、parseFloat() 字符串转为数字

1.3、undefined数据未定义

定义了一个变量，但没有给变量赋值

let str;
console.log(str); // undefined
1
2

1.4、null 空数据

let str = null;
console.log(str); // null
1
2

1.5、Boolean布尔类型

1.6、Symbol

基本数据类型，用来表示独一无二的值，避免同名属性被覆盖。

let str = Symbol('test');
console.log(str); // Symbol(test)
1
2

1.7、BigInt

BigInt不能用于Math对象中的方法

let n = 10n;
let m = BigInt(10)
1
2

二、引用数据类型

值存在堆中，赋值传址

2.1、object

2.1.1 对象object

2.1.2 时间Date

2.1.3 正则RegExp

2.1.4 数学Math

2.1.5 数组Array

数组操作:

• 赋值操作

let arr = [1, 2, 3]
arr.length = 5;
console.log(arr) //  [1, 2, 3, empty × 2]
1
2
3

• 索引查询indexOf

let arr = [1, 2, 3]
console.log(arr.indexOf(2)) // 1
console.log(arr.indexOf(5)) // -1
1
2
3

• slice
  截取数组部分元素，并返回一个新数组

   let arr = [1, 2, 3]
   let arrNew = arr.slice(0,2)
   console.log(arrNew) //[1, 2]   是一个左闭右开区间
1
2
3

• push和pop
  push末尾添加若干元素，pop把数组最后一个元素删除

   let arr = [1, 2, 3]
   let arrNew = arr.push(4)
   console.log(arrNew) //4
   console.log(arr) // [1, 2, 3, 4]
   let arrNewPop = arr.pop()
   console.log(arrNewPop) //4
   console.log(arr) //[1, 2, 3]
1
2
3
4
5
6
7

• unshift和shift
  unshift头部添加若干元素，shift把数组第一个元素删除
• sort
  数组排序，可传入一个函数，按照自定义规则进行排序

    let arr = [1, 2, 3, 11, 5, 44, 66, 15]
   arr.sort();
   console.log(arr) //[1, 11, 15, 2, 3, 44, 5, 66]
  
   function sortFun(a,b) {
       return a-b;
   }
   arr.sort(sortFun)
   console.log(arr) //  [1, 2, 3, 5, 11, 15, 44, 66]
1
2
3
4
5
6
7
8
9

• reverse
  arr.reverse() 数组元素反转
• splice
  从指定的索引开始删除若干元素，然后再从该位置添加若干元素

   let arr = ['诸葛亮', '刘备', '关羽', '张飞']
   // 只删除，不添加
   arr.splice(2,1)
   console.log(arr) //  ['诸葛亮', '刘备', '张飞']
   // 删除，再添加
   arr.splice(2,1, '孙悟空', '猪八戒')
   console.log(arr) // ['诸葛亮', '刘备', '孙悟空', '猪八戒']
   // 只添加，不删除
   arr.splice(2,0, '唐僧')
   console.log(arr) // ['诸葛亮', '刘备', '唐僧', '孙悟空', '猪八戒']
1
2
3
4
5
6
7
8
9
10

• concat
  把当前数据与另一个数组元素进行拼接，并返回一个新的数组

   let arr = ['诸葛亮', '刘备']
   let arr2 = ['关羽', '张飞']
   let arrNew = arr.concat(arr2);
   console.log(arrNew) //['诸葛亮', '刘备', '关羽', '张飞']
1
2
3
4

• join
  把当前Array的每个元素都用指定的字符串连接起来，然后返回连接后的字符串

   let arr = ['诸葛亮', '刘备', '关羽', '张飞']
   let str = arr.join(',')
   console.log(str) //诸葛亮,刘备,关羽,张飞
1
2
3

• Set数据结构类型

   let a = [1,1,2,3,3,2,3,4,5,6,7,3,2,3,4,5,3,2,2]
   let b = [...new Set(a)]
   console.log(b) //[1, 2, 3, 4, 5, 6, 7]
1
2
3

• forEach
  遍历数组全部元素，利用回调函数对数组进行操作，自动遍历数组.length次，且无法break中途跳出循环，不可控不支持return操作输出，return只用于控制循环是否跳出当前循环
• map
  不改变原数组，返回一个return操作后的新数组

   let a = [1,2,3,4]
   let b = a.map(item=>{
       return item * 2
   })
   console.log(a) //[1, 2, 3, 4]
   console.log(b) //[2, 4, 6, 8]
1
2
3
4
5
6

• filter
  不改变原数组，返回一个新数组，满足筛选条件后的新数组

 let a = [1,2,3,4]
 let b = a.filter(item=>{
     return item > 2
 })
 console.log(a) //[1, 2, 3, 4]
 console.log(b) //[3, 4]
1
2
3
4
5
6

• includes
  Array.includes() 是否包含某个元素，返回true或false
• find
  不改变原数组，返回的是满足条件的数组元素( 判断为true 则跳出循环输出符合条件的数组元素)

   let a = [1,2,3,4]
   let b = a.find(item=>{
       return item > 2
   })
   console.log(a) //[1, 2, 3, 4]
   console.log(b) //3
1
2
3
4
5
6

• findIndex
  和find相同，不改变原数组，返回的是满足条件的数组元素序号，

   let a = [1,2,3,4]
   let b = a.findIndex(item=>{
       return item > 2
   })
   console.log(a) //[1, 2, 3, 4]
   console.log(b) //2
1
2
3
4
5
6

• some
  不改变原数组，输出的是判断为true则马上跳出循环并return成true

   let a = [1,2,3,4]
   let b = a.some(item=>{
       return item > 2
   })
   console.log(a) //[1, 2, 3, 4]
   console.log(b) //true
1
2
3
4
5
6

• every
  用于检测数组中的元素是否都满足return的判断条件，只要有一个不符合就会返回false，都符合才返回true。

    let a = [1,2,3,4]
    let b = a.every(item=>{
        return item > 2
    })
    console.log(a) //[1, 2, 3, 4]
    console.log(b) //false
1
2
3
4
5
6

2.2、function

2.3、键值对(Map)

ES6 新增的数据类型，用于存储键值对的集合数据

let m = new Map();
m.set('诸葛亮', 58)
m.set('刘备', 38)
m.set('张飞', 35)
console.log(m.has('刘备')) // 是否存在key: true
console.log(m.get('诸葛亮')) // 58
console.log(m.delete('刘备')) // 删除key
console.log(m.get('刘备')) // undefined
1
2
3
4
5
6
7
8

2.4、集合(Set)

是 ES6 新增的数据类型，是一组key的集合，但不存储value，由于key不能重复，所以用于存储不重复的数据集合

let s = new Set()
let s1 = new Set([1,2,3,3,'3'])
console.log(s) //{size: 0}
console.log(s1) //{1, 2, 3, '3'}
s.add(1)
s1.add(1)
console.log(s) //{1}
console.log(s1) //{1, 2, 3, '3'}
s1.delete(1)//
console.log(s1) //{2, 3, '3'}
1
2
3
4
5
6
7
8
9
10