JavaScript的Array对象、冒泡排序、定义函数

一、Array对象

Array对象用于在变量中存储多个值

1、创建数组对象的两种方式

• new Array
• 字面量方式

  <script>
      // 声明数组
      // 第一种方式：使用Array对象创建
      var arr_1 = new Array();
      console.log(arr_1.length);
      var arr_2 = new Array('张三','李四','王五');
      console.log(arr_2.length);
      // 获取数组中的元素:数字名[下标(索引)]
      console.log(arr_2[1]);
      // 数组的下标是从0开始，最大值可以取到数组的长度减1
      // 第二种方式：使用字面量的方式(直接赋值)
      var arr_3 = [12,54,85,65];
      console.log(arr_3.length);
  </script>

 2、遍历数组

1. for()
2. for...in...

<script>
    // 打印出数组中的所有元素
    // 第一种方式：for...
    for(var i=1;i<arr_3.length;i++){
        console.log(arr_3[i]);
    }
    // 第二种方式：for..in...
    for(var i in arr_3){
        // console.log(i);//打印的下标
        console.log(i,arr_3[i]);
    }
</script>

案例1：请输出学生成绩中及格的成绩>59

var scores = [90,56,78,23,9,57,65];
for(var i=0;i<scores.length;i++){
    // 判断是否大于59
    if(scores[i]>59){
        console.log(i,scores[i]);
    }
}

案例2：打印出一个数组中的所有奇数之和

var arr1 = [5,62,45,23,48,19,14,27];
var result = 0;
for(var i=0;i<arr1.length;i++){
    if(arr1[i]%2 != 0){
        result += arr1[i]
    }
}
console.log(result);

3、数组中常用的函数

3.1 向数组中添加元素

①push() 向数组末尾添加元素

var arr1 = [90,56,78,23,9,57,65];
var result = arr1.push(100);

②unshift() 向数组前面添加元素

var arr1 = [90,56,78,23,9,57,65];
result = arr1.unshift(60);

3.2 删除数组中的元素

①pop() 删除数组中的最后一个元素并返回

var arr1 = [90,56,78,23,9,57,65];
var res_1 = arr1.pop();
console.log(res_1,arr1);

②shift() 删除数组中的第一个元素并返回 

var arr1 = [90,56,78,23,9,57,65];
res_1 = arr1.shift();
console.log(res_1,arr1);

3.3 排序和反转

①sort() 进行升序排列

1.字符串

// sort()进行升序，先将数组中的元素转换成字符串之后再进行升序
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var res_2 = fruits.sort();
console.log(res_2);

2.数字

// 定义一个数值比较函数：当a小于b是，a在b的前面，返回一个小于0的数，当a大于b时，a在b的后面，返回一个大于0的数，当a等于b时，返回0
function compare(a,b){
    if(a<b){
        return -1
    }else if(a>b){
        return 1
    }else{
        return 0
    }
    // return a-b//升序
    // return b-a//降序
}
// 利用比较函数实现数值的升序排列
console.log(arr4.sort(compare));

②reverse() 颠倒元素顺序

var arr2 = ['jeason1','mary1','lily1']
var res_3 = arr2.reverse();
console.log(res_3);

3.4 拼接元素

①concat() 将某个元素添加到数组的末尾(可以拼接数组和字符串)

var fruits = ["Banana", "Orange", "Apple", "Mango"];
var arr = ['aa','bb']
console.log(fruits.concat(arr));

②join() 将数组以某个符号进行拼接，返回一个字符串

var fruits = ["Banana", "Orange", "Apple", "Mango"];
console.log(fruits.join(','));

3.5 从指定位置删除指定长度的元素：splice()

var arr4 = [12,48,95,65,48,36,48]
console.log(arr4.splice(2,1),arr4);

3.6 复制从指定位置到结束位置的元素：slice()

var arr4 = [12,48,95,65,48,36,48]
// 复制从指定位置到结束位置的元素:slice()取不到结束位置的值
console.log(arr4.slice(1,3),arr4);

3.7 获取指定元素的索引：indexOf()

var arr4 = [12,48,95,65,48,36,48]
console.log(arr4.indexOf(48));

3.8 数组的去重

// 数组的去重问题
var arr5 = [90,100,78,65,100,78,66,30,65]
// 先定义一个空数组，用来存放重复的元素
var newArr = [];
for(var i=0;i<arr5.length;i++){
    // 判断一下将要添加的元素是否存在于新数组newArr中，如果存在，不添加，反之，则将该元素添加到新的数组newArr中
    if(newArr.indexOf(arr5[i])==-1){
        // 将不重复的元素放到新数组newArr中
        newArr.push(arr5[i])
    }
    // newArr.push(arr5[0])
    // newArr.push(arr5[1])
}
console.log(newArr);

二、冒泡排序

// 冒泡排序
var arr = [10,50,30,15,80];
    // 比较了几轮
    for(var i=0;i<arr.length-1;i++){
        for(var j=0;j<arr.length-i-1;j++){
            // 当前面的元素值大于后面相邻元素的值时，两者的值进行交换
            if(arr[j]>arr[j+1]){
                var temp = arr[j]
                arr[j] = arr[j+1]
                arr[j+1] = temp
            }
        }
    }
console.log(arr);

使用函数解决代码重复的问题

// 使用函数解决代码重复的问题
function text(arr){
    for(var i=0;i<arr.length-1;i++){
        for(var j=0;j<arr.length-i-1;j++){
            // 当前面的元素值大于后面相邻元素的值时，两者的值进行交换
            if(arr[j]>arr[j+1]){
                var temp = arr[j]
                arr[j] = arr[j+1]
                arr[j+1] = temp
            }
        }
     }
     console.log(arr);
}
var arr1 = [32,45,12,66,24];
text(arr1)
var arr2 = [58,28,38,78,96];
text(arr2)

三、定义函数

• 声明式

  // 定义一个函数，用来打招呼
  // 声明式
  function sayHello(){
      console.log('Hello!');
  }
  // 调用函数:函数名(参数列表)
  sayHello()

• 赋值式

  // 赋值式
  var eat = function(){
      console.log('喜欢吃');
  }
  // 调用函数
  eat()

区别：

1. 声明式：可以先调用，在声明
2. 赋值式：必须先定义，后调用

案例1：求1-100之间的所有偶数之和

// 求1-100之间的所有偶数之和
var result = 0;//用来存储和
function test(n){
    for(var i=1;i<=n;i++){
        // 判断是否为偶数
        if(i%2==0){
            result+=i
        }
    }
    console.log("和："+result);
}
// 求1-100的偶数之和
test(100)

案例2：打印出九九乘法表和六六乘法表 

// 打印出九九乘法表和六六乘法表
function nineTable(n){
    for (var i = 1;i<=n;i++){
        for (var j = 1;j<=i;j++){
            document.write(i+'*'+j+'='+(i*j)+'&nbsp');
        }
        document.write('<br>');//换行
    }
}
// 九九乘法表
nineTable(9)
// 六六乘法表
nineTable(6)

 案例3：利用函数的返回值来解决：将函数中的某一个结果在函数外获取到

// 修改成带有返回值的函数
// 求一个长方形的面积
function test3(h,w){
    return h*w
}
var res =  test3(6,3);
// 判断长方形的面积是否是偶数
if(res%2==0){
    console.log("是偶数");
}else{
    console.log("是奇数数");
}
// 判断长方形的面积是否能被5整除
if(res%5==0){
    console.log("能被5整除");
}else{
    console.log("不能被5整除");
}