【无标题】

最新推荐文章于 2024-07-12 09:36:48 发布

lyz1182177423

最新推荐文章于 2024-07-12 09:36:48 发布

阅读量134

点赞数

文章标签： javascript 前端 servlet

本文链接：https://blog.csdn.net/m0_71576623/article/details/126077070

版权

一、数组的操作方法
1、reverse()反转数组
var arr=[1,2,1,3,5,4,6,2,6,2,8]
console.log(arr);
console.log(arr.reverse());
2、join 指定分隔符,将数组转换为字符串

3、concat
连接数组将数据添加到数组的末位,不修改原数组生成新数组
只能打散一维数组,不会打散数组中包含的数组

4、slice 截取子数组
不修改原数组,生成新数组起始包含终止不包含
负数倒着截取

5、splice 增加和删除数组元素
splice(arg1,arg2,arg3...)
arg1 起始位置如只有一个参数表示从起始位置删除后面的所有元素,修改原数组返回被删除的元素
如第一个参数为负数,从右到左
arg2 表示被删除的元素个数第二个为负数按0
arg3即后边所有参数是要插入的元素

6、数组删除
splice()
delete 只删除元素本身,不删除空间

二、字符串拼接的操作效率
var s1="hello"
var sums1=[]
var b= new Date().getMilliseconds()
for(var i=0;i<1000000;i++){
sums1.push('hello')
}

// for(var i=0;i<1000000;i++){
// sums1.concat(s1)
// }
var a=new Date().getMilliseconds()
num=a-b

console.log( parseInt(num));
console.log(sums1);
三、数组的检测
typeof(a1)
1、Array.isArray(a1) true
2、if(a1 instanceof Array){}
3、a1.comstructor==Array

四、数组的toString()
所有的对象都有toStrring() valueof() toLocalstring()
toString() :每个值的字符串形式,然后以逗号分隔,进行拼接

五、数组下标
范围:大于0 小于2的23次幂-1

如下标为负数、浮点数、布尔型 js自动转换成字符串

下标是可以不断递增的表达式

六、排序
sort(比较函数)
比较函数有两个参数f1(a,b)
函数只判断返回值
返回值大于0 a排在b的后面
返回值小于0 a排在b的前面
返回值等于0 a,b不动

var arr1 = [23, 4, 5, 12, 78, 16]
function f1(a, b) {
// return a-b
if (a - b > 0) {
return 1
} else if (a - b < 0) {
return -1
} else if (a - b==0) {
return 0
}
}
console.log(arr1.sort(f1));

1、indexOf()
返回数组中第一个找到的元素的位置,不存在返回-1

2、forEach()
数组.forEach(function(当前元素的值,当前元素索引,数组对象){})

3、map
对数组每一项进行遍历
map与forEach 区别
1、forEach只是遍历,map生产新数组
2、map速度快
3、map可以链式操作

var a1=[1,2,3,4]
a1= a1.map(function(item,index,arr){
return item*2

}).map(function(item1){
return item1*10
})
console.log(a1);

a1=[3,4,5,6]
4、filter 数据过滤
arr.filter(function(当前元素的值,当前元素索引,数组对象{}))
(1)、返回新数组,不对原数组修改
(2)、对返回"true"的结果过滤,false结果忽略
5、reduce 接收一个函数作为累加器,数组中的每一个值从左到右开始缩减,最终计算成一个值
arr.reduce(function(初始值,当前元素的值,当前元素索引,数组对象{}),初始值(可省略))
a1=[1,2,3,4,5]
// a1=["a","b","c",4,5]
a2=a1.reduce(function(init,currentvalue,index,arr){
console.log(init,currentvalue,index,arr)
return init+currentvalue
})
console.log(a2)

6、some
判断数组是否右满足条件的元素
(1)、arr.
(2)、函数内部、返回true,找到了满足条件的元素,则循环结束
返回false循环继续
(3)、函数的执行次数不一定等于数组长度

判断是否存在大于20的元素
a1.some(function(item,index,arr){
return item>20
})

7、every 检测数组中所有元素是否都满足条件
一项不满足就返回false

一、浮点精度问题
1、产生原因
js数值型包含整数、浮点---Number 固定按64位算

最高位--符号位存储指数
1 11位

0.1
0.0001100 1100 1100......(1100循环)
0.2
0.0011001100110011.....(0011循环)

0.1+0.2 相加有多余部分被舍掉,产生误差

二、解决办法
0.1+0.2=0.3
(1)、乘以10 再计算
let x = (0.1 * 10 + 0.2 * 10) / 10
console.log(x);
(2)、toFixed()截取位数四舍五入
a=0.1+0.2
a.toFixed(1) 0.3

三、包装类型
Number Boolean String

1、(1)、包装类型中的String 需要new String()创建
(2)、typeof返回object 对象
(3)、当sring有多个参数,只处理第一个,
(4)、当sring有多个参数,只处理第一个,.但是js会将整个代码执行完

s1="hello" 后台操作 s1=new String("hello")
s2=s1.sunstring(2) s2=substring(2)
s1=nul 销毁

s3="hello"
s4=new String("hello")
typeof(s3) String
typeof(s4) object

var n=1
s1=new String(++n,n++,++n)
s2=new String(1,2,3,4)
console.log(n); 4
console.log(s1); {2}
2、包装类型Boolean
v1=false
v2=v1&&true false

v1=new Boolean(false)
v2=v1&&true true
任何object对象准换位Boolean都为true

v3=false
v4=new Boolean(false)
console.log(typeof(v3)); 基本数据类型
console.log(v4); object

instanceof 判断是否为对象实例
console.log(v3. instanceof Boolean); false
console.log(v4. instanceof Boolean) ;true

3、包装类型Number
v1=23
v2=new Number(23)

typeof(v1) Numb
typeof(v2) object

v1 instanceof Number false
v2 instanceof Number true

三、值类型与引用类型
1、值类型传递采用基础数据类型,String Number Boolean null undefined
存储在栈内存中,占据的空间是固定的
2、引用类型采用地址传递,array function object
堆内存中存储的一般都是object,通过一个地址编号(引用指针)
传递给栈内存变量,读取数据的时候,由引用指针到堆内存找数据块
占据的空间是不固定的
3、拆箱与装箱
装箱:将值类型包装为对应的引用类型对象
var a=12
b=new Number(12) 装箱

拆箱:引用类型-->值类型 valueof()
c=new Number(23)
var d=c.valueof()
typeof(d) Number

四、深拷贝与浅拷贝针对引用类型
1、浅拷贝:拷贝基本数据类型不会受影响
拷贝引用类型源对象会被修改
白话文:加入b复制a时当修改a时,b也跟着变化
仅拷贝对象地址
var arr=[1,2,3]
var arr2=arr
arr.push(4)
console.log(arr2);[1,2,3,4]
console.log(arr);[1,2,3,4]
2、深拷贝:拷贝一个基本数据对象之前,先给拷贝的对象创建一个
新地址,这样当拷贝的对象指向对象改变时,被拷贝的对象堆中数据不会改变
白话文:a复制b,当修改a时,b不变

(1) 、创建新数组,for循环复制
var a1=[1,2,3]
var a2=[]
for(var k in a1){
a2.push(a1[k])
}
a1.push(4)
console.log(a1);
console.log(a2);

(2)、数组方法slice
var arr = [1, 2, 3, 4, 5]
var arr2 = arr.slice(0)
arr.push(6)
console.log(arr)
console.log(arr2)

(3)、数组方法 concat
var arr = [1, 2, 3, 4, 5]
var arr2 = arr.concat()
arr.push(6,7)
console.log(arr)
console.log(arr2)
(4)、json.parse(JSON.Stringify)
var arr=[1,2,3,4];
var arr2=JSON.parse(JSON.stringify(arr))
arr.push(18)
console.log(arr, arr2)

(5)、ES6扩展运算符实现
var arr = [1, 2, 3, 4, 5]
var [...arr2] = arr
arr.push("李")
console.log(arr)
console.log(arr2)

3、手动封装深浅拷贝
copyfun(对象,true) true--深拷贝 false--浅拷贝
return 拷贝后的对象

a1 =[1,2,3]
a2=copyfun(a1,false) a1变,a2变
a3=copyfun(a1,true) a1变,a3不变

typeof(obj) --object
args instanceof Array
Array.isArray(args)

一、函数:
1、函数是完成某一功能的一组语句,它接受0或多个参数,执行函数体,完成某个功能,最后返回处理结果
2、function(参数){
函数体
return 结果
}
3、函数的定义方式
(1)、普通函数
关键字:var let const for while switch
function f1(){
var a=10
var b=10*2
return b
}
调用
var resultf1() 20
(2)、函数表达式
var f1=function(){
var a=10
var b=10*2
return b
}
var result=f1()

(3)、立即执行函数(匿名函数、立即执行函数)
(function(a){alert(Math.pow(a,2))})(3)

(4)、函数创建对象
var f1=new Function(前面为参数,最后一个是函数体和返回值)
var f1=new Function("a","alert(a*10)")
f1(3)

var f1=new Function("a","return (a*10)")
var c=f1(3)
console.log(c);

var f1=new Function("a","b","c","return a+b+c")
var c=f1(3,4,5)
console.log(c);

var f1=new Function("a","b"," c=a+b; return c")
var d=f1(3,4)
console.log(d);
4、函数的参数
(1)、普通参数
function f1(a,b){//形参
return a+b
}
f1(2,3)//实参
(2)、ES6 函数参数:默认参数可以有多个,但必须放在末尾
function f1(a,b){//形参
return a+b
}
f1(2,3)//实参

[2]不定长参数
function f1(...args){
log
}
f1(2,3,4)

[3]参数管理器 arguments
不是数组但可以按数组的方式用,可以用数组的形式调用实参值
for循环能用,

[4]形参长度--函数名.length
function f1(a,b){
arguments.length //实参的长度
f1.length //形参长度

//形参实参长度相同判断f1.length== arguments.length

}
f1(a,b)

5、返回值--只能有一个
(1)、如有多个返回值,可返回数组
function f1(){
c=a+b
d=a-b
return [c,d]
}
f1(2,3)
(2)、返回函数
function f1(a,b){
function f2(){
return a+b
}
return f2
}
f1(1,2)