堆内存和栈内存
1、基本数据类型变量都存储在栈区域 string number Blean undefined null
2、引用变量存储在栈区域
3、复杂数据类型（对象，数组）存储在堆区域，复制时将地址给栈区域
数据类型之间的比较
基本数据类型是 值 之间的比较
复杂数据类型是 地址 之间的比较
3.函数参数传递
基本数据类型和复杂数据类型的区别
- 因为复杂数据类型，变量存储的是地址，真实内容在 堆空间内 存储
- 所以赋值的时候相当于把 obj 存储的那个地址复制了一份给到了 obj2 变量
- 现在 obj 和 obj2 两个变量存储的地址一样，指向一个内存空间
- 所以使用 obj2 这个变量修改空间内的内容，obj 指向的空间也会跟着改变了
- 例子展示：
数组创建
var arr=new Arry(); //利用构造函数创建
var arr=[ , , , ]; //利用字面量创建数组【】
数组里可以存放任意数据类型，字符串，数字，布尔值等
数组使用
注：不能直接给数组名赋值，不然数组元素全没了
- 获取数组 arr[ i ];
- 遍历数组
for(var i=0;i<arr.lenght;i++){
console.log(arr[i]);
}
- 数组转换成字符串
<script>
var arr=['red','blue','yellow','pink']
//空字符串
var str='';
var sep='*'
for(var i=0;i<arr.length;i++){
str+=arr[i]+sep;
}
console.log(str);//red*blue*yellow*pink
</script>
- 修改数组长度和追加元素，修改元素，
var arr=['red','blue','yellow']
arr.length=5
arr[3]='pink';
arr[0]='abd'
- 数组妙用
- 数组的长度是自动检测的
- 数组长度=数据个数
- 更方便将满足条件的元素追加到新数组
var newArr=[];
for(var i=0;i<arr.length;i++){
//新数组索引号从0开始依次递增
newArr[newArr.length]=arr[i];//0 1...
// 数组长度能自动检测,即当新数据传给数组时，数组就检测了长度
}
}
案例：去掉数组中的0
var arr=[2,4,55,0,32,0,43]
var newArr=[];
console.log(newArr.length);
for(var i=0;i<arr.length;i++){
if(arr[i]!=0){
newArr[newArr.length]=arr[i];
}
}
console.log(newArr);
- 筛选数组：方法一
思路：申明新数组存放新数据，遍历原数组，判断数据；依次追加到新数组，将满足条件的给新数组第一个位置，满足条件的数据自加加
var arr=[2,4,55,32,43]
var newArr=[];
var j=0;
for(var i=0;i<arr.length;i++){
if(arr[i]>10){
newArr[j]=arr[i];
j++
}
}
console.log(newArr);
- 筛选数组：方法二
var arr=[2,4,55,32,43]
var newArr=[];
console.log(newArr.length);//0 1...
//刚开始数组长度为0
for(var i=0;i<arr.length;i++){
if(arr[i]>10){
//新数组索引号从0开始依次递增
newArr[newArr.length]=arr[i];//0 1...
// 数组长度能自动检测,即当新数据传给数组时，数组就检测了长度
}
}
console.log(newArr);
翻转数组 将数组内容反过来存放
- 声明新数组
- 将旧数组最后一个取出（arr.length-1）给新数组第一个(newArr.length)元素
- 采取递减方式遍历，从后往前遍历
var arr=[2,4,55,0,32,0,43]
var newArr=[];
for(var i=arr.length;i>=0;i--){
newArr[newArr.length]=arr[i];
}
console.log(newArr);
数组常用方法
1、push 向数组追加元素
arr.push(1,2)
2、pop 删除数组最后面的一个元素
arr.pop()
3、unshift 数组最前面添加元素
arr.unshift(1,3)
4、shift 删除数组最前面的元素
arr.unshift()
5、splice 截取数组中某些内容，按照索引裁剪掉指定内容
arr.splice(1,2) 截1和2，索引号。
arr.splice(1,1,3) 截1并用3代替
arr.splice(3,1）截取一个元素，即删除数组中某个元素
6、arr.reverse() 反转，数组倒序
7、arr.sort() 排序默认由低到高，规则是先转成字符串，用字符编码Unicode由低到高
**排序函数** ????
arr=[1,5,4,2]
var fun=function(a,b){
// 负数升序排列 正数降序
if(a<b){
return 1
}if(a>b){
return -1
}
if(a==b){
return 0
}
}
arr.sort(fun)
console.log(arr);//1,2,4,5
8、concat 是把多个数组进行拼接
-和之前的方法有一些不一样的地方，就是 concat 不会改变原始数组，而是返回一个新的数组，相同的数据也会拼接
9、join 是把数组里面的每一项内容链接起来，变成一个字符串，不改变原始数组，而是返回连接好的字符串
10、slice() 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变
11、indexOf() 用来找数组中某值的索引
如果找的内容在数组中没有，就返回index为负1
12、includes 检测数组中是否包含某值
ES5常用数组遍历方法
forEach
- 和 for 循环一个作用，就是用来遍历数组的
- 语法：arr.forEach(function (item, index, arr) {})
map
- 和 forEach 类似，只不过可以对数组中的每一项进行操作， 返回新数组
filter 查找数组满足条件的元素，返回新数组
- 和 map 的使用方式类似，按照我们的条件来筛选数组
- 把原始数组中满足条件的筛选出来，组成一个新的数组返回
find 查找第一个满足条件的元素
every 是否每个元素都满足指定的条件
数组中是否每个元素都满足指定的条件, 全部满足返回true
some是否有元素满足指定的条件
只要有一个满足返回true
reduce 相当于一个累加器
// 应用累加求和
var arr = [98, 57, 78, 95, 89, 99]
function test3(){
// [98, 57, 78, 95, 89, 99]
//previousValue 上一个值,如果initValue存在，第一遍历时previousValue就是initValue
// currentValue 当前数组元素
// currentIndex 当前数组下标
// arr 原数组
var sum = arr.reduce(function(previousValue,currentValue){ //previousValue: 0, 98 (98 + 57)
return previousValue + currentValue//previousValue: 0 + 98 + 57 +78+...
},0)
console.log('sum ',sum)
}
test3()
练习
冒泡排序
依次比较两个元素，交换位置
var arr = [89, 98, 78, 68, 76]
// 1、外层循环冒泡轮数
for (var j = 0; j < arr.length - 1; j++) {
//2、内层循环,两两比较交换位置
for (var i = 0; i < arr.length - 1 - j; i++) {
//3、相邻两个数，两两比较，并交换位置
if (arr[i] > arr[i + 1]) {
// 交换位置
var temp = arr[i]
arr[i] = arr[i + 1]
arr[i + 1] = temp
}
}
console.log(arr)
}
console.log('排序后 ：', arr)```
var arr = [89, 98, 78, 68, 76]
// 1. n个数进行n-1轮冒泡排序
var n = arr.length
// 外层循环
for (var i = 0; i < n - 1; i++) {
//内层循环
for (var j = 0; j < n - 1 - i; j++) {
// 2.相邻两个数，两两比较，前一个比后一个大，交换位置
if(arr[j] > arr[j+1]){
var temp = arr[j]
arr[j] = arr[j+1]
arr[j+1] = temp
}
}
}
## 选择排序
选择排序思想
1. n 个数 进行n-1次选择
2. 每次选择
未排序数中找最小数下标，与前面的数交换位置
```javascript
<script>
var arr = [89, 98, 78, 68, 76]
// 0 1 2 3 4
var n = arr.length
//外层循环
for (var i = 0; i < n - 1; i++) {
//找最小数下标
var minIndex = i //假设最小数下标是第一个数
for (var j = i+1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j
}
}
//交换位置
var temp = arr[i]
arr[i] = arr[minIndex]
arr[minIndex] = temp
console.log('第'+(i+1)+'次选择 ',arr)
}
console.log(arr)
</script>
数组去重
<!--
数组去重
[9,2,5,2,8,2,5] -> [9,2,5,8]
方法一: 利用indexOf或includes实现
思路:
1. 定义一个空数组 [] 存储去重后元素
2. 遍历原数组
3. 判断新数组中是否有原数组当前元素，如果没有，存储到新数组中
方法二: 双重for循环+splice
for(var i = 0; i < arr.length; i++){
var item = arr[i]
//依次让后面的元素与外层循环元素比较，如果重复，截取
for(var j = i+1; j<arr.length; j++){
if(arr[j] == item){
arr.splice(j,1)
j--
}
}
}
-->
</head>
<body>
<script>
/*
利用indexOf -1
includes false
*/
function testIndexOf() {
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])
}
}
console.log(newArr)
}
function test2() {
var arr = [9, 2, 5, 2, 8, 2, 5]
var newArr = [] //存储去重后数组
arr.forEach(function (item) {
if (newArr.indexOf(item) == -1) {
newArr.push(item)
}
})
console.log(newArr)
}
// test2()
/*
利用双重for循环+splice实现
外层循环遍历数组所有元素
内层循环依次判断后面元素是否与外层循环元素相同，如果相同，截取掉
*/
function test3() {
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--
}
}
}
console.log(arr)
}
test3()
</script>
作业
<!--
已经学生数组如下:
var students = [
{number:1001, name:'jack', score:98,gender:'男'},
{number:1002, name:'rose', score:95,gender:'女'},
{number:1003, name:'小丽', score:85,gender:'女'},
]
-->
</head>
<body>
<script>
/*
1. 找成绩大于平均分的所有学生
2. 找姓名是rose的学生并且性别是女的学生
var stu = students.find(function(item){
return item.name == 'rose' && item.gender == '女'
})
3. 所有学生成绩减十分，返回到新数组中
var newArr = students.map(function(item){
return item.score-10
})
4. 所有学生中是否有女生
var isOk = students.some(function(item){
return item.gender == '女'
})
5. 所有学生中是否有不及格的学生
var isOk = students.some(function(item){
return item.score < 60
})
6. 所有学生的总成绩,使用reduce方法
var total = students.reduce(function (previouValue, currentValue) {
return previouValue + currentValue.score
}, 0)
*/
var students = [
{ number: 1001, name: 'jack', score: 98, gender: '男' },
{ number: 1002, name: 'rose', score: 95, gender: '女' },
{ number: 1003, name: '小丽', score: 85, gender: '女' },
]
/*
1. 找成绩大于平均分的所有学生
*/
function findStudentsByAvg() {
// 找平均分
var total = 0
for (var i = 0; i < students.length; i++) {
var stu = students[i] //学生对象
var score = stu.score //学生成绩
total += score
}
console.log('总成绩 ', total)
var avg = total / students.length
console.log('平均分 ', avg.toFixed(2))
for (var j = 0; j < students.length; j++) {
var stu = students[j] //学生对象
if (stu.score > avg) {
console.log(stu)
}
}
}
// findStudentsByAvg()
function findStudentsByAvg2() {
//总成绩
var total = students.reduce(function (previouValue, currentValue) {
return previouValue + currentValue.score
}, 0)
console.log('总成绩 ', total)
var avg = total / students.length
avg = parseInt(avg)
// 查找大于平均分学生
var newStudents = students.filter(function (item) {
return item.score > avg
})
console.log(newStudents)
}
// findStudentsByAvg2()
/*
对一组学生的百分制成绩[98,78,89,77,69,59,85,100,93,81]，
分别统计出100分、90~99分、80~89分、…0~9分的人数。
分数段 人数
100 1
90-99 2
80-89 3
70-79 2
60-69 1
50-59 1
40-49 0
30-39 0
20-29 0
10-19 0
0-9 0
11变量
var num = [0,0,0,0,0,0,0,0,0,0,0]
0 1 2 3 4 5 6 7 8 9,10
num[0] 0-9 / 10 0
num[1] 10-19 /10 1
num[2] 20-29 /10 2
num[3] 30-39
num[4] 40-49
num[5] 50-59
....
num[9] 90-99
num[10] 100
*/
function getNumberByScore() {
var stuScores = [98, 78, 89, 77, 69, 59, 85, 100, 93, 81]
//定义一个存储各分数段人数的数组长度为11,初始值为0
var num = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
for (var i = 0; i < stuScores.length; i++) {
var score = parseInt(stuScores[i] / 10) // 9
num[score]++
// switch (score) {
// case 10:
// num[10]++
// break
// case 9:
// num[9]++
// break
// case 8:
// num[8]++
// break
// case 7:
// num[7]++
// break
// case 6:
// num[6]++
// break
// case 5:
// num[5]++
// break
// case 4:
// num[4]++
// break
// case 3:
// num[3]++
// break
// case 2:
// num[2]++
// break
// case 1:
// num[1]++
// break
// case 0:
// num[0]++
// break
// }
}
for (var j = 0; j < num.length; j++) {
if (j == 10) {
console.log('100分人数 ' + num[j])
} else {
console.log(j * 10 + '-' + ((j + 1) * 10 - 1) + '分人数 ' + num[j])
}
}
}
getNumberByScore()
//法二：
var stu=[98,78,89,77,69,59,85,100,93,81]
function test(){
for(var i=1;i<stu.length;i++){
var newname1=stu.filter(function(item){
return item>100-i*10 && item<=109-i*10
})
// console.log(newname1.length);
console.log((100-i*10)+'~'+(109-i*10)+'分的有'+newname1.length+'人');
}
newname1=stu.filter(function(item){
return item==100
})
console.log('100分的人数为'+newname1.length);
}
test()
</script>
扫一扫
4869
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
