本文主要是介绍807笔记（for-in,排序算法,数组扩展方法），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

数组排序（续）

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

这篇关于807笔记（for-in,排序算法,数组扩展方法）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！