数组补充及冒泡排序

一、数组的一些补充函数

• splice(起始位置,删除个数,新增元素)

通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容，此方法会改变原数组。

//通过删除或替换达到删除或增加元素的效果
var months = ['Jan', 'March', 'April', 'June'];
months.splice(1, 0, 'Feb','Fir'); // 在下标为1的位置删除0个元素，增加'Feb','Fir'
months.splice(1, 2, 'Feb','Fir');  // 在下标为1的位置删除2个元素，增加'Feb','Fir'
console.log(months);//["Jan","Feb","Fir","March","April","June"]

//直接删除指定位置之后所有元素
var months = ['Jan', 'March', 'April', 'June'];
months.splice(1);// 找到位置为1的元素，删除1以后所有元素，包括1位置的元素
console.log(months);// ['Jan']

// 指定删除个数 
var months = ['Jan', 'March', 'April', 'June'];  
months.splice(1,2); //找到1的位置删除2个
console.log(months);// ['Jan', 'June']

• includes():

includes() 方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。

var arr = [1, 2, 3];
console.log(arr.includes(2));// true

• concat()

连接两个或更多的数组，并返回结果。

var a=[1,2,3,4,5];
var b=[6,7,8,9];
var c = a.concat(b);
console.log(c); // [1,2,3,4,5,6,7,8,9]

• every()

检测数组元素的每个元素是否都符合条件,返回的是一个Boolean类型的值。

//指定函数 判定元素是否都小于40；
//  、、、   
var arr1 = [1, 30, 39, 29, 10, 13];
console.log(arr1.every(指定函数));// true

• some()

检测数组元素中是否有元素符合指定条件,返回的是一个Boolean类型的值。

//指定函数 判定元素是否都是偶数；
//  、、、   
var arr1 = [1, 30, 39, 29, 10, 13];
console.log(arr1.some(指定函数));// true

• filter()

检测数组元素，并返回符合条件所有元素组成的数组。

//指定函数 判定元素是否偶数；
//  、、、   
var arr1 = [1, 30, 39, 29, 10, 13];
var result = arr1.filter(指定函数);
console.log(result);// 返回符合条件组成的新数组

• indexOf()

返回在数组中给定元素的第一次出现时的索引，如果不存在，则返回-1。

var beasts = ['ant', 'bison', 'camel', 'duck', 'bison'];
console.log(beasts.indexOf('bison'));// 1

• toString()

把数组转换为字符串，并返回结果。

var array1 = [1, 2, 'a', '1a'];
console.log(array1.toString());//  "1,2,a,1a"

• lastIndexOf()

返回一个指定的字符串值最后出现的位置，在一个字符串中的指定位置从后向前搜索。

"Blue Whale, Killer Whale".lastIndexOf("blue"); // -1

• map()

通过指定函数处理数组的每个元素，并返回处理后的数组。

//指定函数 元素都+2；
//  、、、   
var arr1 = [1, 30, 39, 29, 10, 13];
var result = arr1.map(指定函数);
console.log(result);// [3,32,41,31,12,15]

• slice()

选取数组的的一部分，并返回一个新数组。begin开始，end结束，包括begin,不包括end。

//只有一个值，则返回从指定位置之后所有元素
var animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];
console.log(animals.slice(2)); // ["camel", "duck", "elephant"]

//有两个值，左闭右开
var animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];
console.log(animals.slice(2, 4)); // ["camel", "duck"]

• valueOf()

返回数组对象的原始值。

// 返回数组对象本身
var array = ["ABC", true, 12, -5];
console.log(array.valueOf() === array);  // true

二、值类型和引用类型

• 基本数据类型：值类型

var a = 10; // 在内存中开辟空间，存入10。空间的名称叫a
var b = 20;

var x = 10;
var y = x;
y = 20;
     
console.log(x);// 10
console.log(y);//20

• 复杂数据类型：引用数据类型
  存储的是地址值

var arr = [12,34,56,67];  // arr存储的是一个地址
var arr1 = arr; // 将arr的地址复制给arr1 

arr1[0] = '新增的';

console.log(arr); // ["新增的",34,56,67]
console.log(arr1); // ["新增的",34,56,67]

三、值类型和引用类型作为参数

// 值类型作为参数
var n = 10;
function fn(n){
      n = 20;
      console.log(n); // 20
}
fn(n)
console.log(n); // 10

// 引用类型作为参数
var n = [12,34,5];
function fn(n) {
      n[0] = 0;
      console.log(n[0]); // 0
}
fn(n); 
console.log(n[0]); // 0

四、严格模式

• 严格模式：‘use strict’

1. 声明变量必须有var关键字

'use strict'
var a = 90;
b = 30;
console.log(window);// window对象保存着全局作用域下面属性和方法  

2. 函数的形参不可以重复

'use strict'
 function fn(y,y){
      console.log(y);
      console.log(y);
}
fn(2,3) //

3. 声明函数调用时，内部没有this

'use strict'
 function fn(){
 console.log(this); // 函数里面的this指向的是window
 // console.log(arguments);
}
fn()

五、字符串的方法

• concat()

将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回。

// str.concat(str2, [, ...strN])
var str = 'Hello, '
console.log(str.concat('Kevin', '. Have a nice day.'))
// Hello, Kevin. Have a nice day.

• charAt()

从一个字符串中返回指定的字符。

//字符串下标同样从0开始
var anyString = "Brave new world";
console.log(anyString.charAt(0));// B
console.log(anyString.charAt(1));// r
console.log(anyString.charAt(2));// a

• split(参数)

将字符串按照参数来进行分割 ， 如果没有参数，会分割成一个一个的字符，参数为空，则输出单个字符。

// 将字符串按照指定符号分割
var str = '张三-李四-王五-赵六';
var newStr = str.split('-');
console.log(newStr); // ["张三", "李四", "王五", "赵六"];

六、冒泡排序

排序原理：将两个相邻元素进行比较，大的往后排。

• 定义数组

var arr = [34, 23, 13, 9];
console.log(arr);

• 第一轮排序

//   第一轮
if (arr[0] > arr[1]) {
     var temp = arr[0];
     arr[0] = arr[1];
     arr[1] = temp;
}

console.log(arr);
if (arr[1] > arr[2]) {
      var temp = arr[2];
      arr[2] = arr[1];
      arr[1] = temp;
}
console.log(arr);

if (arr[2] > arr[3]) {
     var temp = arr[2];
     arr[2] = arr[3];
     arr[3] = temp;
}
      
console.log(arr);
for (var i = 0; i < arr.length - 1 - 0; i++) {
    if (arr[i] > arr[i + 1]) {
            var temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
    }
    console.log(arr);
}

• 第二轮排序

// 前面元素>后面元素，交换元素
if (arr[0] > arr[1]) {
     var temp = arr[1];
     arr[1] = arr[0];
     arr[0] = temp;
}
console.log(arr);
if (arr[1] > arr[2]) {
     var temp = arr[1];
     arr[1] = arr[2];
     arr[2] = temp;
}

console.log(arr);
for (var i = 0; i < arr.length - 1 - 1; i++) {
     if (arr[i] > arr[i + 1]) {
           var temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
      }
console.log(arr);
}

var temp;
//外层循环代表走了几轮，每走一轮就能比较出来一个最大值
for (var i = 0; i < arr.length - 1; i++) {
      // 内层循环代表每一轮进行了多少次的比较
      for (var j = 0; j < arr.length - 1 - i; j++) {
           // 两个相邻的元素进行比较，如果发现前面元素比后面元素大，就将前后元素进行交换
           if (arr[j] > arr[j + 1]) {
                 temp = arr[j];
                 arr[j] = arr[j + 1];
                 arr[j + 1] = temp;
            }
     }
}
console.log(arr);

经典案例

• 随机验证码

function getYanZheng(str,num){
    if(str.length <1){
        alert('长度有误！')
    }else{
        var new_str = '';
        var str_len = parseInt(str.length);
        for(var i=0;i<num;i++){
            //循环几次就是输出几位验证码
            var num_len = parseInt(Math.random()*str_len);
            new_str += str.charAt(num_len);
        }        
    }
    return new_str;
}

var ans = getYanZheng('zxcvbnmasdfghjklqwertyuiop1234567890',4)
console.log(ans);

• 字符串内容去重

function strQuChong(str){
	//空数组用来存储经过去重的字符
    var new_arr = [];
    var str_arr = str.split('');
    // console.log(str_arr);
    for(var i=0;i<str_arr.length;i++){
        if(new_arr.indexOf(str_arr[i])==-1){
            new_arr.push(str_arr[i]);
        }
    }
    console.log(new_arr.join(''));
    
}

strQuChong('asfsdfgcvsdfcvasdcvasdxcasdxcdxc');

• 数组是否包含60

function arrInclude60(arr,num){
	//初始为false
    var fa = false;
    for(var i=0;i<arr.length;i++){
        if(arr[i]==num){
            fa = true;
        }
    }
    return fa
}

alert(arrInclude60([34,56,21,2,6,60,5,13,124,356],60));