js数组字符串对象基础知识

weixin_45620731

已于 2024-05-07 17:04:54 修改

阅读量1.6k

点赞数

分类专栏： js 文章标签： js

于 2022-03-25 09:42:53 首次发布

本文链接：https://blog.csdn.net/weixin_45620731/article/details/123727544

版权

js 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

自用小技巧

ES6

类
模块化
箭头函数
函数参数默认值
模板字符串
解构赋值
延展操作符
对象属性简写
Promise
Let与Const

强制转换

Number（）  强制转换为数值型
  Number('2')  //2
  Number('2a') //NaN
  Number(true) //1
  Number(undefined)//NaN
  Number(null) //0

parseInt（）强制转换为整形

  parseInt(3.14) //3
  parseInt('3.14a')//3
  parseInt('a3.14')//NaN
  parseInt(true) //NaN

常用于将小数和字符串转为整型，如果要转换的数据中开头含有非数字，则返回NaN
parseFloat（） 强制转换为浮点型
和parseInt用法基本一样，只是转的数据为浮点型

toString()  将数值和布尔型强制转换为字符串

编码

encodeURI()  对一个URI进行编码
 decodeURI()  对已编码的URI进行解码
 isNaN()  检测一个值转数值后是否为NaN，如果是NaN返回true，不是返回false
 isFinite()  检测一个值是否为有限值，如果是返回true，不是返回false
  3/0   0做除数返回的无限值  Infinity

对象

使用内置构造函数创建对象
new Object()  创建一个空对象
需要通过访问对象属性来添加每个属性

for-in 遍历
for(var key in 对象){
 key 对象中每个属性名
对象[key]  每个属性名对应的属性值
}

访问对象中的方法
	var person={
	name:'tom',
	say: function(){
	 this.name  //this指代当前所在的对象
  }
}
person.say();

检测对象中属性是否存在

对象.属性名===undefined   true不存在  false存在
 对象.hasOwnProperty('属性名')  true存在  false不存在
'属性名'  in  对象   true存在  false不存在

数组

（1）数组字面量
arr=[ 元素1,元素2... ]
（2）访问数组中的元素
 数组[下标]  下标是0开始
（3）使用构造函数创建数组
 new Array()   空数组
 new Array(元素1,元素2..)
new Array(3)  初始化数组的元素个数为3，可以添加更多个元素
 数组.length   获取元素的个数
 可以在末尾添加元素   数组[数组.length]=值;
数组的分类
	索引数组: 以0及以上的整数做下标
	关联数组：以字符串做下标，只能单独添加每个元素

注意

js对象底层中都是关联数组
都可用  对象[属性名] 访问到

数组API

toString()  将数组中元素转为字符串，默认按照逗号分隔
join('-')  将数组中的元素按照指定的字符转为字符串
concat(arr1,arr2...)  拼接多个数组
slice(start,end)  截取数组中的元素，start开始的下标，end结束的下标，不      包含end，如果是负数表示倒数，如果end为空截取到最后；返回截取数组
splice(start,count,value...)  删除数组中的作用，start开始的下标，count删 除的数量，value删除后替换的元素，返回删除后的元素，原数组会发生变化。    start为负数表示倒数，count为空表示删除到最后
reverse()  翻转数组元素
sort()  对数组中元素进行排序，默认是按照Unicode码从小到大排序 
push()  在数组的末尾添加元素，返回数组长度  
pop()  删除数组末尾的元素，返回删除的元素
unshift() 在数组的开头添加元素，返回数组长度
shift()  删除数组开头的元素，返回删除的元素

字符串

将任意数据转为字符串
new String() 返回对象，和普通字符串使用没有区别
String()  返回字符串
转义字符\
\'  将引号转成普通字符
\n  将字符n转成换行符
\t  将字符t转成制表符(tab键效果)

字符串API

 length  获取字符串的长度
 charAt()  获取下标对应的字符，也可以使用数组形式  字符串[下标]
 charCodeAt()  获取某个字符的Unicode码

indexOf()  查找某个字符的下标
lastIndexOf()  查找某个字符最后一次出现的下标
 以上两个找不到都会返回-1

trim() 方法用于删除字符串的头尾空格。trim() 方法不会改变原始字符串。


toUpperCase()  英文字母转大写
toLowerCase()  英文字母转小写
slice(start,end)  截取字符串，start开始的下标，end结束的下标，不包含end本身；如果end为空截取到最后，如果是负数表示倒数 返回截取的字符
substr(start,count)  截取字符串，start开始的下标，count截取的长度，count为空截取到最后，start为负数表示倒数 返回截取的字符
substring(start,end)  截取字符串，start开始的下标，end结束的下标，end为空截取到最后，如果是负数转为0，如果start大于end，则位置自动交换。 返回截取的字符
split( sep )  将字符串按照指定的字符分隔为数组，sep表示指定的字符

字符串匹配模式
search()  查找满足条件的第一个，并返回下标，如果找不到返回-1  /china/i
match()  可以查找满足条件的所有的字符串，返回数组 /china/ig
replace()  查找并替换   /china/ig
i-ignore 忽略大小写   g-global 全局

switch-case语句

switch(表达式){
 case 值1: //如果表达式的值为 值1
  语句1;
  break;
  ...
 default:
   语句n+1; //如果表达式和case后的值比较都是false才会执行
}

while

while(循环条件){
循环体;
}

break和continue

break: 结束循环
 continue: 跳过本次循环，继续下一次循环

for-in

for(var key in 数组){
key  下标
数组[key]  下标对应的元素
}

 for(var i=0;i<数组.length;i++){
  i 下标
 数组[i]  下标对应的元素
 } 
 只能遍历索引数组

math对象

 不需要创建，可以直接使用
 PI  圆周率
 abs()  取绝对值
round()  四舍五入取整
ceil()  向上取整
 floor()  向下取整
max()  取一组数字最大
 min()  取一组数字最小
random()  取随机  >=0  <1

date对象

创建Date对象
 new Date('2019/11/18 10:20:30')
 new Date(2019,10,18,10,20,30)  月份范围0~11
 new Date(1000*60)  存储距离计算机元年毫秒数对应的日期时间
new Date()  存储当前操作系统的日期时间

获取Date对象中存储的日期时间

getFullYear/getMonth/getDate/getHours/
 getMinutes/getSeconds/getMilliseconds/
 getDay  星期日到星期六，范围0~6
 getTime  获取距离计算机元年的毫秒数

本地日期时间格式

 toLocaleString
 toLocaleDateString
 toLocaleTimeString

设置日期时间

setFullYear/setMonth (范围0~11)/setDate
setHours/setMinutes/setSeconds/setMilliseconds
setTime  设置距离计算机元年毫秒数，可能所有的日期时间都会发生变化

Number对象

new Number()  转为数值，同时返回对象
Number()  转为数值，返回数值型
toFixed(n)  获取小数点后n位
toString(n)  转字符串的同时，设置进制，n是进制

Boolean对象

new Boolean()  转为布尔型，返回对象
Boolean()  转为布尔型，返回布尔型
!!值  转为布尔型

ES7

1.Array.prototype.includes

Includes 方法用来检测数组中是否包含某个元素，返回布尔类型值

const name = ['Tom','Jerry','Bob']

console.log(name.includes("Tom")); //true

console.log(name.includes("Jack")); //false

2.指数操作符

在 ES7 中引入指数运算符「 ** 」，用来实现幂运算，功能与 Math.pow 结果相同

console.log(2 ** 10); //1024

console.log(Math.pow(2,10)); //1024

ES8

1.async 和 await

async 和 await 两种语法结合可以让异步代码像同步代码一样

await 必须写在 async 函数中
await 右侧的表达式一般为 promise 对象
await 返回的是 promise 成功的值
await 的 promise 失败了, 就会抛出异常, 需要通过 try…catch 捕获处理
async 函数的返回值为 promise 对象，
promise 对象的结果由 async 函数执行的返回值决定
2.Object.values 和Object.entries
1.Object.values() 方法返回一个给定对象的所有可枚举属性值的数组
2. Object.entries() 方法返回一个给定对象自身可遍历属性 [key,value] 的数组
3. Object.getOwnPropertyDescriptors 该方法返回指定对象所有自身属性的描述对象

ES9

1.Rest/Spread 属性
Rest 参数与 spread 扩展运算符在 ES6 中已经引入，不过 ES6 中只针对于数组，在 ES9 中为对象提供了像数组一样的 rest 参数和扩展运算符

const one = {
a:"aa"
}
const two = {
b:"bb"
}
const three = {
c:"cc"
}
const all = {...one,...two,...three}
console.log(all);

2.正则表达式命名捕获组

ES9 允许命名捕获组使用符号『 ? 』 , 这样获取捕获结果可读性更强

一般方式：

let str = "<a href='百度http://www.baidu.com'>百度</a>"
//提取url与【标签文本】
const reg = /<a href='(.*)'>(.*)<\/a>/;
//执行
const result = reg.exec(str)
console.log(result.groups); // undefined

命名捕获组：

let str = "<a href='百度http://www.baidu.com'>百度</a>"
const reg = /<a href='(?<url>.*)'>(?<text>.*)<\/a>/;
const result = reg.exec(str)
console.log(result);
console.log(result.groups.url); // http://www.baidu.com
console.log(result.groups.text); // 百度

3.正则表达式反向断言

ES9 支持反向断言，通过对匹配结果前面的内容进行判断，对匹配进行筛选。

let str = "js234566酷酷酷222啦啦啦" //正向断言

const reg = /\d+(?=啦)/

console.log(reg.exec(str));
let str = "js234566酷酷酷222啦啦啦"//反向断言

const reg = /(?<=酷)\d+/

console.log(reg.exec(str));

正则表达式 dotAll 模式

正则表达式中点 . 匹配除回车外的任何单字符，标记『s』改变这种行为，允许行终止符出现

ES10

1.Object.fromEntries
在ES8中使用Object.entries将对象转化为数组，在ES10中，使用Object.fromEntries将数组转换为对象。

2.trimStart 和 trimEnd

trimStart清除字符串左侧空白；trimEnd清除字符串右侧空白

3.Array.prototype.flat 与 flatMap

Array.prototype.flat将多维数组转化为低维数组，参数为深度，是一个数字

示例：

const arr = [1,2,[3,4,5]]
console.log(arr.flat());

const arr1 = [1,2,[3,4,[5,6]]]
console.log(arr1.flat(2));

//flatMap
const arr2 = [1,2,3,4]
const result = arr2.flatMap(item => [item*10])
console.log(result);

4.Symbol.prototype.description

获取Symbol的字符串描述

let s = Symbol("Tom")

console.log(s.description); //Tom

ES11

1.String.prototype.matchAll
String.prototype.matchAll得到正则批量匹配的结果

2.类的私有属性

3.Promise.allSettled

接收一个Promise数组，返回一个Promise对象，返回结果永远是成功的状态

4.可选链操作符

?. 在对象层级较深时，不用做层级判断的简便写法

5.动态 import 导入实现按需加载

6.globalThis 对象

不管在任何环境下，globalThis始终指向全局对象

7.BigInt

大整型，应用于大数值运算

JavaScript基础用法（ES5）

string字符串

string.length
返回字符串的长度

'abcd'.length // 4

string.charAt(index)
返回字符串指定下标的字符

'abcd'.charAt(2) // 'c'
'abcd'[3] // 'd'

string.concat(newString)
⽤于将⼀个或多个字符串拼接起来，返回拼接后的新字符串

'aaaa'.concat('bbbb') // 'aaaabbbb'
'aaaa'.concat('bbbb','cccc','dddd','eeee') // 'aaaabbbbccccddddeeee'

string.includes(searchString)
判断字符串中是否包含了想要查询的字符，包含返回true,不包含返回false

'a1a2a3'.includes('a') // true
'a1a2a3'.includes('a2a3') // true
'a1a2a3'.includes('d') // false

string.endsWidth(searchString)
确定字符串是否以某个字符结尾

'a1a2a3'.endsWith('a1a2a3') // true
'a1a2a3'.endsWith('a3') // true
'a1a2a3'.endsWith('a') // false

string.startsWidth(searchString)
确定字符串是否以某个字符开始，和endsWidth方法相对应
string.indexOf(searchString) 查找字符串中第一次出现指定字符的索引（也可用于判断是否包含指定字符串，包含返回下标，不包含返回-1）

'aaaa'.indexOf('a') // 0
'aaaa'.indexOf('b') // -1
'aaaac'.indexOf('c') // 4

string.lastIndexOf(searchString)
查找字符串中最后一次出现指定字符的索引（也可用于判断是否包含指定字符串，包含返回下标，不包含返回-1）

'aaaa'.lastIndexOf('a') // 3
'aaaa'.lastIndexOf('aa') // 2
'aaaa'.lastIndexOf('c') // -1

string.slice(startIndex，endIndex)
截取字符串并返回一个新的字符串,包含开始下标字符,不包含结束下标字符

'aabbaabbcc'.slice(1,-1) // abbaabbc
'aabbaabbcc'.slice(-3,-1) // bc
'aabbaabbcc'.slice(1) // abbaabbcc
'aabbaabbcc'.slice(3,8) // baabb

string.substring(startIndex, endIndex)
截取字符串并返回一个新的字符串，包含开始下标字符，不包含结束下标字符，不支持负值

'012345'.substring(1,4) // '123'
'012345'.substring(1) // 12345

string.split()
可以使⽤⼀个指定的分隔符来将字符串拆分成数组，返回⼀个数组

'aa bb cc'.split('') // [ 'a', 'a', ' ', 'b', 'b', ' ', 'c', 'c' ]
'aa bb cc'.split(' ') // [ 'aa', 'bb', 'cc' ]
'aa bb cc'.split('a b') // [ 'a', 'b cc' ]

string.trim()
删除字符串两端空白字符串
string.trimStart()
删除字符串开头空白字符串
string.trimEnd()
删除字符串末尾空白字符串
string.toLowerCase()
将英文字符串转为小写
string.toUpperCase()
将英文字符串转为大写
string.replace()
可替换字符串的部分内容

'aabbccaaddaa'.replace('aa','gg') // ggbbccaaddaa
'aabbccaaddaa'.replaceAll('aa','gg') // ggbbccggddgg

string.toString() / string.valueOf()
常常配合new String()使用

new String('aaa') // [String: 'aaa']
new String('aaa').toString() //  'aaa'
new String('vvvv').valueOf() // 'vvvv'

string.search()
使⽤正则表达式(也可以是目标字符串)查找指定字符串，如果找到则返回⾸次匹配成功的索引，没有找到则返回-1

var str = "hey JudE";
var re = /[A-Z]/g;
var re2 = /[.]/g;
console.log(str.search(re)); // returns 4, which is the index of the first capital letter "J"
console.log(str.search(re2)); // returns -1 cannot find '.' dot punctuation
'aabbcc'.serach('bb') // 2

string.repeat(count)
将字符串重复指定次数（非负数的整数）并返回新的字符串

"abc".repeat(-1)     // RangeError: repeat count must be positive and less than inifinity
"abc".repeat(0)      // ""
"abc".repeat(1)      // "abc"
"abc".repeat(2)      // "abcabc"
"abc".repeat(3.5)    // "abcabcabc" 参数 count 将会被自动转换成整数。
"abc".repeat(1/0)    // RangeError: repeat count must be positive and less than inifinity

({toString : () => "abc", repeat : String.prototype.repeat}).repeat(2)
//"abcabc",repeat 是一个通用方法，也就是它的调用者可以不是一个字符串对象。

string.padEnd()
用给定字符串从末尾填充当前字符串并返回长度为目标长度的新字符串。

'abc'.padEnd(10);          // "abc       "
'abc'.padEnd(10, "foo");   // "abcfoofoof"
'abc'.padEnd(6, "123456"); // "abc123"
'abc'.padEnd(1);           // "abc"

string.padStart()
用给定字符串从开头填充当前字符串并返回长度为目标长度的新字符串。

'abc'.padStart(10);         // "       abc"
'abc'.padStart(10, "foo");  // "foofoofabc"
'abc'.padStart(6,"123465"); // "123abc"
'abc'.padStart(8, "0");     // "00000abc"
'abc'.padStart(1);          // "abc"

string.match()
返回⼀个字符串匹配正则表达式的结果,如果未设置全局匹配，则会返回第⼀个完整匹配及其相关的捕获组，捕获组中包含有groups、index、input等属性。

不常用的一些方法

string.charCodeAt(index) 返回字符串指定下标处字符的utf-16码元值
string.localeCompare(compareString) 返回一个数字，用于指示一个参考字符串 compareString 是否在排序顺序前面或之后或与给定字符串相同。

// 返回值大于0：说明当前字符串string大于对比字符串targetString
// 返回值小于0：说明当前字符串string小于对比字符串targetString
// 返回值等于0：说明当前字符串string等于对比字符串targetString
// 返回值是一个数字，目前的主流浏览器都返回的是1、0、-1三个值，但是也有其他情况，所以不可以用绝对的值等于1、-1这种去判断返回的结果
var str = 'aaa',
	strCom = 'bbb',
	strCom2 = 'aaa';
str.localeCompare(strCom); //-1
strCom.localeCompare(str); //1
str.localeCompare(strCom2); //0

array数组

array.concat(arr0,…arrX)
拼接或拷贝数组，当传入新数组为拼接，不传为拷贝，可传多个参数

[1,2,3].concat([0,1,2]) // [ 1, 2, 3, 0, 1, 2 ]
[1,2,3].concat() // [ 1, 2, 3 ]
[1,2,3].concat([0,1,2],[4],[9]) // [ 1, 2, 3, 0, 1, 2, 4, 9 ]

array.every()
遍历查询满足条件的值每一项满足即返回true

const arr = [1,2,3]
const res = arr.every((item,index,arr)=>{
  console.log(item,index,arr)
  /* 
	1 0 [ 1, 2, 3 ]
	2 1 [ 1, 2, 3 ]
	3 2 [ 1, 2, 3 ]
  */
  return item
})
console.log(res) // true

array.filter()
过滤数组,返回符合条件的新数组

const arr = [7,1,2,3]
const res = arr.filter((item,index,arr)=>{
  console.log(item,index,arr)
  /* 7 0 [ 7, 1, 2, 3 ]
	1 1 [ 7, 1, 2, 3 ]
	2 2 [ 7, 1, 2, 3 ]
	3 3 [ 7, 1, 2, 3 ]
	*/
  return item >2
})
console.log(res) // [ 7, 3 ]

array.flat()
按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。

var arr1 = [1, 2, [3, 4]];
arr1.flat(); // [1, 2, 3, 4]

var arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat(); // [1, 2, 3, 4, [5, 6]]

var arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2); // [1, 2, 3, 4, 5, 6]

//使用 Infinity，可展开任意深度的嵌套数组
var arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat(Infinity); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// 方法会移除数组中的空项
var arr4 = [1, 2, , 4, 5];
arr4.flat(); // [1, 2, 4, 5]

array.forEach()
遍历数组无返回值
array.indexOf(value, startIndex) / array.lastIndexOf(value, startIndex)
从前往后查找元素，value查找的值也是必传值，没找到情况下返回-1
lastIndexOf()从后往前找

const array = [2, 9, 9, 5];
array.indexOf(9) // 1
console.log(array.indexOf(2,-2)); // -1 相当于从[9, 5]中查找2
console.log(array.indexOf(9,-2)); // 2 相当于从[9,9,5]中找9 返回的下标是对应值在原数组[2,9,9,5]中的下标
console.log(array.indexOf(9,-3)); // 1 相当于从[2,9,9,5]中找9 返回的下标是对应值在原数组[2,9,9,5]中的下标且只查找第一个对应值的下标
console.log(array.indexOf(9,2)); // 2 相当于从[9,5]中找9 返回的下标是对应值在原数组[2,9,9,5]中的下标
console.log(array.indexOf(9,1)); // 1 相当于从[9,9,5]中找9 返回的下标是对应值在原数组[2,9,9,5]中的下标且只查找第一个对应值的下标

array.map()
遍历数组有返回值,常用作列表数据遍历循环
array.reduce() / array.reduceRight()
数组值求和,reduceRight()表示从右往左依次计算

const arr = [1, 2, 3]
arr.reduce((pre,cur,index)=>{
console.log(index) // 0 1 2
return pre+=cur
},0) // 初始值为0，总和为6 初始值为n,则为n+每项值总和

array.reverse()
翻转数组

const a = [1, 2, 3];
console.log(a); // [1, 2, 3]
a.reverse();
console.log(a); // [3, 2, 1]

array.slice(startIndex，endIndex)
数组截取,包含开始下标，不包含结束下标

const arr = [1, 2, 3]
console.log(arr.slice(0,2)) // [1,2]
console.log(arr.slice(-2,-1)) // [2]
console.log(arr.slice(-1)) // [3]

array.some()
遍历查询满足条件的值有一项满足即返回true

const arr = [1, 2, 3]
const res = arr.some((value,index,arr)=>{
  console.log(value,index,arr)
  /* 1 0 [ 1, 2, 3 ]
2 1 [ 1, 2, 3 ]
3 2 [ 1, 2, 3 ]*/
  return value>2
})

console.log(res) // true

array.sort()
对数组进行排序，注：具体为升序还是降序需要通过函数返回来确定

const arr = [1, 2, 3]
const res = arr.sort((a,b)=>{
  console.log(a,b)
  /* 2 1
3 2*/
  return b-a
})

console.log(res) // [ 3, 2, 1 ]

array.splice(index, number, item1…itemX)
数组更新、截取、添加、删除，index为必传值，会改变原数组，返回删除的元素

var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
var removed = myFish.splice(2, 0, 'drum', 'guitar');
// 从索引 2 的位置开始删除 0 个元素，插入“drum”和 "guitar"
// 运算后的 myFish: ["angel", "clown", "drum", "guitar", "mandarin", "sturgeon"]
// 被删除的元素：[], 没有元素被删除


var myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon'];
var removed = myFish.splice(3, 1);
// 从索引 3 的位置开始删除 1 个元素
// 运算后的 myFish: ["angel", "clown", "drum", "sturgeon"]
// 被删除的元素：["mandarin"]

array.entries()
对数值键值对遍历, 空槽用undefined补齐

const arr = [1, 2, 3, 2, ,]
console.log(...arr.entries()) // [ 0, 1 ] [ 1, 2 ] [ 2, 3 ] [ 3, 2 ] [ 4, undefined ]

array.fill(value, start, end)
数组填充,不包括终止索引

const arr = [{num: 1}, {num: 2}, {num: 3},{num: 2}]
console.log([...arr.fill({num: 0}, 1, 3)]) // [ { num: 1 }, { num: 0 }, { num: 0 }, { num: 2 } ]
console.log([...arr.fill({num: 0}, 1, 10)]) // [ { num: 1 }, { num: 0 }, { num: 0 }, { num: 0 } ]

array.find() / array.findLast()
筛选数组中第一个符合条件的值,没有返回undefined
findLast()筛选数组中最后一个符合条件的值，没有返回undefined

const arr = [{num: 1}, {num: 2}, {num: 3},{num: 2}]
const res = arr.find((item,index,arr)=>{
  console.log(item,index,arr)
  return item.num > 1 // item.num > 8 则res值为undefined
})
console.log(res) // { num: 2 }

array.findIndex() / array.findLastIndex()
查找元素在数组中第一次出现的下标，没有返回-1
查找元素在数组中第一次出现的下标，没有返回-1

const arr = [{num: 1}, {num: 2}, {num: 3},{num: 2}]
const res = arr.findIndex((item,index,arr)=>{
  console.log(item,index,arr)
  return item.num >2
})
console.log(res) // 2

array.includes(value, index)
判断一个数组是否包含一个指定的值,对象类型值（引用类型）的数组不能查找到对应的值
index可选，表示从第几个索引开始查找

const arr = [1,2,3,4,5,4,4,3,3,3]
arr.includes(4,6) // true
arr.includes(4,7) // false

array.join()
数组转字符串,可指定链接符号

const elements = ['Fire', 'Air', 'Water'];
console.log(elements.join()); // "Fire,Air,Water"
console.log(elements.join('')); // "FireAirWater"
console.log(elements.join('-')); // "Fire-Air-Water"

array.keys()
对数组键名遍历

var arr = ["a", , "c"];
console.log(denseKeys);  // [0, 1, 2]

array.values()
对数组键值遍历

const arr = [{a:1},{b:2}]
const arrq = [1,2]
console.log(...arr.values()) // { a: 1 } { b: 2 }
console.log(...arrq.values()) // 1 2

array.pop()
删除数组最后一个元素并返回删除元素值,数组为空返回undefined

const arr = [{a:1},{b:2}]
const arrq = [1,2,3,4,5,6]
console.log(arr.pop(1,11),arr) // { b: 2 } [ { a: 1 } ]
console.log(arrq.pop(1,11),arrq) // 6 [1,2,3,4,5]

array.push()
向数组末尾添加一个或多个元素

[1,2].push(2,3,5) // [1,2,2,3,5]

array.shift()
把数组的第一个元素删除并返回删除元素,如果数组为空则返回undefined ,改变原数组

[1,2,3,4].shift() // 1

array.unshift()
向数组开头添加一个或多个元素
array.copyWithin(target, start, end)
从数组指定位置拷贝元素到另一个指定位置，会覆盖原有成员

Array.from()将类数组对象转数组

console.log(Array.from({0:1,2:3,'length': 3})) // [ 1, undefined, 3 ]

Array.of()将一组值转为数组
Array() // []
Array(3) // [, , ,]
Array(3, 11, 8) // [3, 11, 8]

Array.isArray()
判断是否为数组类型,返回值为布尔类型

object对象

Object.assign()
浅拷贝,通过复制一个或多个对象来创建一个新的对象。

let obj1 = { a: 0 , b: { c: 0}};
  let obj2 = Object.assign({}, obj1);
  console.log(JSON.stringify(obj2)); // { "a": 0, "b": { "c": 0}}

  obj1.a = 1;
  console.log(JSON.stringify(obj1)); // { "a": 1, "b": { "c": 0}}
  console.log(JSON.stringify(obj2)); // { "a": 0, "b": { "c": 0}}

  obj2.a = 2;
  console.log(JSON.stringify(obj1)); // { "a": 1, "b": { "c": 0}}
  console.log(JSON.stringify(obj2)); // { "a": 2, "b": { "c": 0}}

  obj2.b.c = 3;
  console.log(JSON.stringify(obj1)); // { "a": 1, "b": { "c": 3}}
  console.log(JSON.stringify(obj2)); // { "a": 2, "b": { "c": 3}}

  // Deep Clone
  obj1 = { a: 0 , b: { c: 0}};
  let obj3 = JSON.parse(JSON.stringify(obj1));
  obj1.a = 4;
  obj1.b.c = 4;
  console.log(JSON.stringify(obj3)); // { "a": 0, "b": { "c": 0}}

Object.entries()
对象转键值对数组

const obj = { foo: 'bar', baz: 42 };
console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]

// array like object
const obj = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]

// array like object with random key ordering
const anObj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.entries(anObj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ]

Object.keys() 对象键名转数组

Object.values()对象键值转数组
Object.is()判断两值是否相同

Object.fromEntries()把数组转为对象

Object.defineProperty()定义对象属性
Object.defineProperties()定义多个对象属性
Object.create() 使用指定的原型对象和属性创建一个新的对象
Object.getOwnPropertyName()获取对象所有属性名数组

Object.getOwnPropertySymbols()获取symbol对象所有属性名数组

Object.getOwnPropertyDescriptor()获取对象所有属性名数组

Object.hasOwn(obj,key) / obj.hasOwnProperty(key) 判断对象是否包含某个属性名

Object.getPrototypeOf() 获取对象原型链

Object.setPrototypeOf() 设置对象原型链

JavaScript内置函数
eval() 用于计算字符串表达式的值

eval('2+3') // 5
eval(new String('2+3')) // '2+3' 这是因为new String（)生成的是一个对象类型的字符串[String: '2+3']
eval(new String('2+3').valueOf()) // 5

toLocaleString() 数值千位分割符

const num = 187878788787
console.log(num.toLocaleString()) // 187,878,788,787

判断是否是字符串

typeof( str2 ) == “string” && str2.constructor === String && Object.prototype.toString.call(str2) === "[object String]

注:部分为转载,只为自己学习记录

weixin_45620731

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
js数组字符串对象基础知识

自用小技巧强制转换Number（）强制转换为数值型 Number('2') //2 Number('2a') //NaN Number(true) //1 Number(undefined)//NaN Number(null) //0parseInt（）强制转换为整形 parseInt(3.14) //3 parseInt('3.14a')//3 parseInt('a3.14')//NaN parseInt(true) //NaN常用于将小数和字符
复制链接

扫一扫