数组排序（续）
reverse：将数组元素逆序
/* reverse:将数组元素逆序
返回值:逆序后的数组
是否影响原数组:是 */
var arr = [4, 2, 100, 3, 5]
var res = arr.reverse()
console.log(arr) //[5,3,100,2,4]
console.log(res) //[5,3,100,2,4]
sort：将数组元素按照字符串的编码进行从小到大的排列
/* sort:将数组元素按照字符串的编码进行从小到大的排列
返回值:排序后的数组
是否影响原数组:是 */
var arr = [4, 3, true, 100, 5]
var res = arr.sort()
console.log(arr) // [100,3,4,5,true]
console.log(res) // [100,3,4,5,true]
- 扩展（数字的大小排列）
sort(function (a, b) { return a - b }) //按数字从小到大排列
sort(function (a, b) { return b - a }) //按数字从大到小排列
var arr1 = [23, 4, 5, 1, 3, 51, 43, 23]
var res1 = arr1.sort(function (a, b) { return a - b })
console.log(arr) // [1,3,4,5,23,23,43,51]
console.log(res) // [1,3,4,5,23,23,43,51]
toString()：将数组转换为字符串；
/* toString()：将数组转换为字符串
返回值:转换后的字符串（以逗号分隔）
是否影响原数组:否 */
var arr = [2, 3, 45, 7, true]
var res = arr.toString()
console.log(arr) // [2,3,45,7,true] 是个数组
console.log(res) //2,3,45,7,true 转换后的字符串
- toString() 还可以用于简单的变量转成指定进制的字符串
// toString(进制数)
var iNum = 48;
console.log(iNum.toString(2)) //1011000
console.log(iNum.toString(8)) //130
console.log(iNum.toString(16)) //58
join(连接符)：将数组转为以指定连接符连接的字符串
/* join(连接符):将数组转为以指定连接符连接的字符串,连接符要用引号包起来
返回值:转换后的字符串
是否影响原数组:否 */
var arr1 = [4, 2, 36, 5, 4]
var res1 = arr1.join('*')
console.log(arr1) // [4, 2, 36, 5, 4]
console.log(res1) // 4*2*36*5*4
-----------------------------
//不要连接符用空引号
var arr1 = [4, 2, 36, 5, 4]
var res1 = arr1.join('')
console.log(arr1) // [4, 2, 36, 5, 4]
console.log(res1) // 423654
for-in 循环
可以遍历数组，也可以遍历对象
遍历对象只能用for-in，不能用for循环
语法：
for(变量 in 数组/对象){
//js语句
}
//遍历数组
var arr = [1, 2, 4, 5, 63, 32, 22]
for (var i in arr) {
console.log(i + "=>" + arr[i]) //i是下标
}
-----------------------
//遍历对象
var obj = {
name: '李四',
age: 18,
sex: '男',
}
for (var key in obj) {
console.log(key + "=>" + obj[key]) //key是对象的属性名，这里只能使用对象名['属性']的方式读取对象里的内容，不能用对象名.属性，否则会认为key是对象里的属性，永远是undefined
}
排序算法
冒泡排序，选择排序，插入排序…
冒泡排序
把相邻的两个数组元素做个比较，符合条件就交换位置
var arr = [9, 6, 15, 4, 2]
for (var i = 1; i < arr.length; i++) { //外层循环是遍历的次数
for (var j = 0; j < arr.length; j++) { //内层循环是比较的次数
if (arr[j] > arr[j + 1]) {
//交换位置，借助第三方
var t = arr[j]
arr[j] = arr[j + 1]
arr[j + 1] = t
}
}
}
------------------------------------
var arr = [9, 6, 15, 4, 2]
for (var i = 1; i < arr.length; i++) {
for (var j = arr.length - 1; j >= i; j--) {
if (arr[j] < arr[j - 1]) {
var t = arr[j - 1]
arr[j - 1] = arr[j]
arr[j] = t
}
}
}
选择排序
依次取出第一个元素，和后面所有元素比较，符合条件就交换位置
var arr = [9, 6, 15, 4, 2]
for (var i = 0; i < arr.length - 1; i++) { //外层是比较的轮数
for (var j = i + 1; j < arr.length; j++) {
//内层是每一轮比较的次数
if (arr[i] > arr[j]) {
var t = arr[i]
arr[i] = arr[j]
arr[j] = t
}
}
}
插入排序
从第二个数开始往前比，比它大就往后排，以此类推进行到最后一个数
let arr = [2, 1, 5, 4, 8, 6];
function insert(arr) {
//定义一个新数组，用来存储抓在手里的牌，开始先抓一张牌进来。
let handle = [];
handle.push(arr[0]); //将原数组的第一项放进来，当做是手里的牌
//从第二项开始依次抓牌，一直把台面上的牌抓光
for (let i = 1; i < arr.length; i++) {
//A是新抓的牌
let A = arr[i];
//用新抓的牌和手里的牌依次比较（从后往前比较）
for (let j = handle.length - 1; j >= 0; j--) {
//B是手里的牌
let B = handle[j];
//如果新牌比旧牌大，就放在旧牌的后面，停止循环
if (A > B) {
handle.splice(j + 1, 0, A);
break; //插入之后，比较结束，进行下一次比较
}
//如果已经比到第一项，就直接把手里的牌放到最前面
if (j == 0) {
handle.unshift(A);
}
}
}
return handle;
}
arr = insert(arr);
console.log(arr);
值传递和引用传递
简单数据类型（属于值传递）：字符串，数值，boolean布尔，undefined，null
复杂数值类型（属于引用传递）：function，array，object（主要）
简单数据类型在栈里存放的是值；复杂数值类型在栈里存放的是二进制的地址，地址指向堆（可以有不同的堆），堆里存放的才是具体的值
//简单变量的值传递
var a = 3;
var b = a;
a = 4;
console.log(a, b) //4,3
//复杂变量的引用传递：修改内容会一起变
var arr = [1, 2, 3]
var list = arr //传递的是地址
arr[0] = 5
console.log(arr, list) //[5,2,3],[5,2,3], arr修改list也会得到新的修改的内容
var obj = { name: '张三', age: 18, }
var obj1 = obj
obj.name = '李四'
console.log(obj, obj1) //{ name: '李四', age: 18, },{ name: '李四', age: 18, }
删除数组中的所有元素
var arr = [0, 2, 3, 5, 6, 7, 11]
while(arr.length){
arr.shift()
}
console.log(arr) //[]
ES5扩展
严格模式：在严格的条件下运行代码
启动严格模式：”use strict”
注意：只能加在作用域开头部分，如果是函数，就加在函数作用域的开头部分
有两种模式
1、全局开启
"use strict"
function test() { }
2、针对某个函数开启
function test() {
"use strict"
} */
特点：
1、严格模式下全局变量必须先声明才能使用
n = 10
console.log(n) // 10
'use strict'
n = 10
console.log(n) // n is not defined
2、函数参数不能重名
function test(x, x, y) {
console.log(arguments)
console.log(x)
console.log(y)
}
test(10, 20, 30) //10,20,30 20 30
'use strict'
function test(x, x, y) {
console.log(arguments)
console.log(x)
console.log(y)
}
test(10, 20, 30) //会报错
var b = null
function fn() {
a = 3
}
fn()
alert(a) //3
var b = null
function fn() {
'use strict' //函数内定义的变量就只能是局部变量了
a = 3
}
fn()
alert(a) //报错
数组的扩展方法
都不改变原数组
indexOf, lastIndexOf, forEach, map, filter, reduce
indexOf(元素,start的位置)
// indexOf(元素,start的位置)
// 作用：查找元素在数组中第一次出现时下标的位置，如果没有返回-1
// 返回值：下标
var arr = [1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 2, 3, 4, 5]
var res=arr.indexOf(2,3)
console.log(res) //5
lastIndexOf(元素)
/* lastIndexOf(元素)
作用：查找元素在数组中最后一次出现时下标的位置，如果没有返回-1
返回值：下标 */
var arr = [1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 2, 3, 4, 5]
var res=arr.lastIndexOf(2)
console.log(res) //11
// 如果指定第二个参数start,则在指定位置从后向前搜索
//lastIndexOf(元素,start)
var arr = [1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 2, 3, 4, 5]
var res=arr.lastIndexOf(2,6)
console.log(res) //5
forEach
/* 遍历数组,和for循环是一样的
arr.forEach(function (value, index, array) {
})
*/
var arr = [1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 2, 3, 4, 5]
arr.forEach(function (value, index, array) {
console.log(value, index, array)
})
map
/* 映射 遍历数组返回一个新数组
map(function (value, index, array) {
return ... //返回一个新数组
}) */
var arr = [1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 2, 3, 4, 5]
var newArr = arr.map(function (value, index, array) {
return value * 2
//return的值是新数组的数组元素
})
console.log(newArr) // [2,4,6,8,10,,4,6,8,10...]
filter
/* 过滤
filter(function (value, index, array){
return 过滤条件
}) */
var arr = [1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 2, 3, 4, 5]
//过滤数组中值大于4的数组元素,返回过滤后的数组
var newArr = arr.filter(function (value, index, array) {
return value >= 4
})
console.log(newArr) //[4,5,4,5,6,4,5]
reduce
/* 累计求和
reduce(function (累加器, 当前值, 索引, 数组) ,累加器的初始值{
return... //返回的是累加器的值
}) */
var arr = [1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 2, 3, 4, 5]
//reduce有两个参数
var sum = arr.reduce(function (s, value, index, array) {
return s + value
}, 0)
console.log(sum) //51
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/279418.html