对象内存结构
- 栈：主要存储基本数据类型的内容
- 堆：主要存储复杂数据类型的内容
4. 基本类型数据和复杂类型数据的区别：
因为复杂数据类型，变量存储的是地址，真实内容在堆空间内存储，所以赋值的时候相当于把obj存储的那个地址复制了一份给到了obj2变量，现在obj和obj2两个变量存储的地址一样，指向一个内存空间，所以使用obj2这个变量修改空间内的内容，obj指向的空间也会跟着改变了。
数组的常用方法
-
push：用来在数组的末尾追加一个元素
vararr=[1,2,3] //使用push方法追加一个元素在末尾 arr.push(4) console.log(arr) // [1, 2, 3，4] -
pop：用来删除数组末尾的一个元素
vararr=[1，2,3] //使用pop方法删除末尾的一个元素 arr . pop() console.log(arr) // [1，2] -
unshift ：在数组前面添加一个元素
vararr=[1,2,3] //使用unshift 方法想数组的最前面添加一个元素 arr . unshift(4) console.log(arr) // [4，1, 2, 3] -
shift ：删除数组最前面的一个元素
vararr=[1,2,3] //使用shift方法删除数组最前面的一个元素 arr .shift() console.1og(arr) // [2，3] -
splice：截取数组中的某些内容，按照数组的索引来截取 语法: splice(从哪一个索引位置开始，截取多少个，替换的新元素)(第三个参数可以不写)
var arr = [1,2,3,4,5] //使用splice方法截取数组 arr.splice(1, 2, '我是新内容') console.1og(arr) // [1，'我是新内容'，4, 5] //arr.splice(1, 2, '我是新内容')表示从索引1开始截取2个内容 //然后用第三个参数把截取完空出来的位置填充 -
reverse：用来反转数组使用的
vararr=[1,2,3] //使用reverse 方法来反转数组 arr.reverse( ) console.log(arr) // [3, 2, 1] -
sort：用来给数组排序的
vararr=[2,3,1] //使用sort方法给数组排序 arr.sort() console.log(arr) // [1, 2, 3] //按字典顺序排序 arr.sort(function(a,b){ return a - b }) -
concat：把多个数组进行拼接 和之前的方法有一些不一样的地方,就是concat 不会改变原始数组,而是返回一个新的数组
vararr=[1,2,3] //使用concat 方法拼接数组 var newArr = arr.concat([4, 5，6]) console.log(arr) // [1, 2, 3] console.log(newArr) // [1, 2, 3, 4, 5，6] -
join：把数组里面的每一项内容链接起来，变成一个字符串 可以自己定义每一项之间链接的内容join(要以什么内容链接)不会改变原始数组, 而是把链接好的字符串返回
vararr=[1,2,3] //使用join 链接数组 var str = arr.join('-') console.log(arr) // [1，2, 3] console.1og(str) // 1-2-3注意: join方法不会改变原始数组，而是返回链接好的字符串
-
slice： slice()方法返回一个新的数组对象， 这一对象是一个由begin 和end，决定的原数组的浅拷贝(包括begin ,不包括end )。原始数组不会被改变。
var arr = ['html','css','javascript','vue','react'] // 0 1 2 3 4 // -4 -3 -2 -1 var newArr = arr.slice(3) var newArr = arr.slice(1,3) var newArr = arr.slice(-4,2) console.log(newArr) -
indexOf： indexOf用来找到数组中某一项的索引
vararr=[1,2,3,4,5] //使用indexOf 超找数组中的某一项 var index = arr.index0f(3) console.log(index) // 3在数组中的索引：2 //如果要找的内容在数组中没有，则返回-1 -
includes： 判断数组是否有某个元素
//检测数组site是否含有runoob let site = ['runoob', 'google'， 'taobao']; site.includes('runoob'); // true site.includes('baidu'); // false
常用数组遍历方法
- forEach
和for循环一个作用,就是用来遍历数组的
语法：arr.forEach(function(item, index, arr) )
vararr=[1,2,3]
// 使用forEach 遍历数组
arr.forEach(function (item, index, arr) {
// item 是数组中的每一项
// index 就是数组的索引
// arr 就是原始数组
console.log('数组的第' + index + '项的值是'+ item + '原始数组是' + arr)
})
forEach(的时候传递的那个函数，会根据数组的长度执行
数组的长度是多少，这个函数就会执行多少回
- map
和forEach类似，只不过可以对数组中的每一项进行操作 ,返回一个新的数组
var arr = [1,2,3]
//使用map遍历数组
var newArr = arr.map(function (item, index, arr) {
// item 就是数组中的每一项
// index 就是数组的索引
// arr就是原始数组
return item + 10
})
console.log(newArr) // [11, 12, 13]
- filter
和map的使用方式类似，按照我们的条件来筛选数组，把原始数组中满足条件的筛选出来, 组成一个新的数组返回
var arr = [1，2,3]
//使用filter 过滤数组
var newArr = arr.filter(function (item, index, arr) {
// item就是数组中的每一项
// index 就是数组的索引
// arr就是原始数组
return item > 1
})
console. log(newArr) // [2, 3]
我们设置的条件就是 >1，返回的新数组就会是原始数组中所有 >1 的项
- find
返回数组中第个满足条件的项
var arr = [10, 11, 12, 13, 14, 15]
//find()遍历数组返回数组中第个满足条件的项
var newItem = arr.find( function( item, index ){
return item > 13
})
console.log(newItem)
- every
数组中是否每个元素都满足指定的条件，全部满足返回true
function testEvery() {
var isOk = arr.every(function(item) { // 98 67 78
return item > 60
})
console.log('isOk ',isOk)
}
- some
数组中是否有元素满足指定的条件，只要有一个满足返回true
function testSome() {
var isOk = arr.some(function(item) {
return item < 60
})
console.log('isOk ',isOk);
}
testSome()
- reduce
reduce()方法接收一个方法作为累加器，数组中的每个值(从左至右)开始合并，最终为一个值。
语法：
/*
reduct(callFun, [initValue])
callFun: function(previousValue,currentValue,currentIndex,arr){ }
forEach(function(currentValue,currentindex,arr){ })
*/
var arr = [98, 57, 78, 95, 89, 99]
function test1() {
arr.reduce(function(previousValue,currentValue,currrntIndex,arr) {
//previousValue上一个值，如果initValue存在，第一遍历时previousValue就是initValue
//currentvalue 当前数组元素
//currentIndex当前数组下标
// arr原数组
console.log('previousValue', previousValue, 'currentvalue', currentValue, 'currentIndex', currentIndex);
return 100
},0)
}
function test2() {
arr.reduce(function(previousValue,curreentValue,currentIndex,arr) {
//previousValue上一个值，如果initValue存在，第一遍历时previousValue就是initValue
//currentValue 当前数组元素
//currentIndex 当前数组下标
// arr原数组
console.1og('previousValue', previousVelue,'currentValue', currentValue, 'currentIndex', currentIndex);
return 10
})
}
// test2()
冒泡排序
相邻两个数，两两比较，如果前面的数大于后面的数，交换位置, 第一轮比较完，最大数到最后面 第二轮重复上述操作，找到第2大数，以此类推直到全部排完
var arr = [89, 98, 78, 68, 76]
// 外层循环冒泡轮数
for (var j = 0; j < arr.length - 1; j++) {
//内层循环,两两比较交换位置
for (var i = 0; i < arr.length - 1 - j; i++) {
//相邻两个数，两两比较
if (arr[i] > arr[i + 1]) {
// 交换位置
var temp = arr[i]
arr[i] = arr[i + 1]
arr[i + 1] = temp
}
}
}
console.log('排序后 ：', arr)
选择排序
基本思想：
首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置(交换位置)再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。重复第二步,直到所有元素均排序完毕。
var minIndex, temp; //记录每次循环最小数位置
for(var i = 0; i < n - 1; i++){
minIndex = i;
//找最小数并记录最小数位置
for (var j = i + 1; j < n; j++) {
if (a[j] < a[minIndex]) {
minIndex = j
}
temp = a[i]
a[i] = a[minIndex];
a[minIndex] = temp;
}
数组去重
- 方法一：
利用indexOf或includes实现 思路: 1. 定义一个空数组 [] 存储去重后元素 2. 遍历原数组 3. 判断新数组中是否有原数组当前元素，如果没有，存储到新数组中
var arr = [9, 2, 5, 2, 8, 2, 5]
var newArr = [] //1.存储去重后元素
// 2. 遍历原数组
for (var i = 0; i < arr.length; i++) {
// 3. 判断新数组中是否有原数组当前元素，如果没有，存储到新数组中
/*
if(newArr.indexOf(arr[i]) == -1){
newArr.push(arr[i])
}
if(newArr.includes(arr[i]) == false){
*/
if (!newArr.includes(arr[i])) {
newArr.push(arr[i])
}
}
- 方法二：
利用双重for循环+splice实现，外层循环遍历数组所有元素，内层循环依次判断后面元素是否与外层循环元素相同，如果相同，截取掉
var arr = [2, 2, 2, 5, 2, 8, 2, 5]
// 0 1 2 3 4 5
// [2, 2, 5, 2, 8, 2, 5]
// 2
for (var i = 0; i < arr.length; i++) {
var item = arr[i] // 外层循环元素
for (var j = i + 1; j < arr.length; j++) {
if(item == arr[j]){
arr.splice(j,1)
j--
}
}
}
