JavaScript四 - 数组

4.1数组基础

4.1.1数组的概念

• 数组可以把一组相关的数据一起存放，并提供方便的访问(获取）方式。
• 数组是指一组数据的集合，其中的每个数据被称作元素，在数组中可以存放任意类型的元素。数组是一种将一组数据存储在单个变量名下的优雅方式。

4.1.2创建数组

JS 中创建数组有两种方式：

• 利用 new 创建数组

  var 数组名 = new Array() ；
  var arr = new Array();   // 创建一个新的空数组
  

  注意 Array () ，A 要大写

• 利用数组字面量创建数组

  //1. 使用数组字面量方式创建空的数组
  var  数组名 = []；
  //2. 使用数组字面量方式创建带初始值的数组
  var  数组名 = ['小白','小黑','大黄','瑞奇'];
  

  • 数组的字面量是方括号 [ ]
  • 声明数组并赋值称为数组的初始化
  • 这种字面量方式也是我们以后最多使用的方式

• 数组元素的类型

  数组中可以存放任意类型的数据，例如字符串，数字，布尔值等。

  var arrStus = ['小白',12,true,28.9];
  

4.1.3获取数组中的元素

索引 (下标) ：用来访问数组元素的序号（数组下标从 0 开始）。

图片1.png

数组可以通过索引来访问、设置、修改对应的数组元素，可以通过“数组名[索引]”的形式来获取数组中的元素。

// 定义数组
var arrStus = [1,2,3];
// 获取数组中的第2个元素
alert(arrStus[1]);    

注意：如果访问时数组没有和索引值对应的元素，则得到的值是undefined

4.1.4遍历数组

• 数组遍历

  把数组中的每个元素从头到尾都访问一次（类似学生的点名），可以通过 for 循环索引遍历数组中的每一项

  var arr = ['red','green', 'blue'];
  for(var i = 0; i < arr.length; i++){
      console.log(arrStus[i]);
  }
  

4.1.5数组长度

• 数组的长度

  数组的长度：默认情况下表示数组中元素的个数

  使用“数组名.length”可以访问数组元素的数量（数组长度）。

  var arrStus = [1,2,3];
  alert(arrStus.length);  // 3
  

  注意：

  • 此处数组的长度是数组元素的个数 ，不要和数组的索引号混淆。
  • 当我们数组里面的元素个数发生了变化，这个 length 属性跟着一起变化
  • 数组的length属性可以被修改：
  • 如果设置的length属性值大于数组的元素个数，则会在数组末尾出现空白元素；
  • 如果设置的length属性值小于数组的元素个数，则会把超过该值的数组元素删除

4.1.6数组求和计算平均值

// 1. 求数组 [2,6,1,7, 4] 里面所有元素的和以及平均值。
// (1)声明一个求和变量 sum。
// (2)遍历这个数组，把里面每个数组元素加到 sum 里面。
// (3)用求和变量 sum 除以数组的长度就可以得到数组的平均值。
var arr = [2, 6, 1, 7, 4];
var sum = 0;
var average = 0;
for (var i = 0; i < arr.length; i++) {
  sum += arr[i]; // 我们加的是数组元素 arr[i] 不是计数器 i
}
average = sum / arr.length;
console.log(sum, average); // 想要输出多个变量，用逗号分隔即可

4.1.7数组转字符串

join()方法：省略分隔符时把元素用逗号隔开

// 将数组 ['red', 'green', 'blue', 'pink'] 转换为字符串，并且用 | 或其他符号分割
// 1.需要一个新变量用于存放转换完的字符串 str。
// 2.遍历原来的数组，分别把里面数据取出来，加到字符串里面。
// 3.同时在后面多加一个分隔符
var arr = ['red', 'green', 'blue', 'pink'];
var str = '';
var sep = '*';
for (var i = 0; i < arr.length; i++) {
  str += arr[i] + sep;
}
console.log(str);

4.1.8数组中新增元素

// 1. 新增数组元素 修改length长度 
var arr = ['red', 'green', 'blue'];
console.log(arr.length);
arr.length = 5; // 把我们数组的长度修改为了 5  里面应该有5个元素 
console.log(arr);
console.log(arr[3]); // undefined
console.log(arr[4]); // undefined

// 2. 新增数组元素 修改索引号 追加数组元素
var arr1 = ['red', 'green', 'blue'];
arr1[3] = 'pink';
console.log(arr1);
arr1[4] = 'hotpink';
console.log(arr1);
arr1[0] = 'yellow'; // 这里是替换原来的数组元素
console.log(arr1);
arr1 = '有点意思';
console.log(arr1); // 不要直接给 数组名赋值 否则里面的数组元素都没有了

4.1.9筛选数组

// 将数组 [2, 0, 6, 1, 77, 0, 52, 0, 25, 7] 中大于等于 10 的元素选出来，放入新数组。
// 1、声明一个新的数组用于存放新数据newArr。
// 2、遍历原来的旧数组， 找出大于等于 10 的元素。
// 3、依次追加给新数组 newArr。
// 方法1
var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
var newArr = [];
var j = 0;
for (var i = 0; i < arr.length; i++) {
  if (arr[i] >= 10) {
    // 新数组索引号应该从0开始 依次递增
    newArr[j] = arr[i];
    j++;
  }
}
console.log(newArr);
// 方法2 
var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
var newArr = [];
// 刚开始 newArr.length 就是 0
for (var i = 0; i < arr.length; i++) {
  if (arr[i] >= 10) {
    // 新数组索引号应该从0开始 依次递增
    newArr[newArr.length] = arr[i];
  }
}
console.log(newArr);

4.1.10数组去重

// 将数组[2, 0, 6, 1, 77, 0, 52, 0, 25, 7]中的 0 去掉后，形成一个不包含 0 的新数组。
// 1、需要一个新数组用于存放筛选之后的数据。
// 2、遍历原来的数组， 把不是 0 的数据添加到新数组里面(此时要注意采用数组名 + 索引的格式接收数据)。
// 3、新数组里面的个数， 用 length 不断累加。
var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
var newArr = [];
for (var i = 0; i < arr.length; i++) {
  if (arr[i] != 0) {
    newArr[newArr.length] = arr[i];
  }
}
console.log(newArr);

4.1.11翻转数组

// 将数组 ['red', 'green', 'blue', 'pink', 'purple'] 的内容反过来存放
// 1、声明一个新数组 newArr
// 2、把旧数组索引号第4个取过来（arr.length - 1)，给新数组索引号第0个元素 (newArr.length)
// 3、我们采取 递减的方式  i--
var arr = ['red', 'green', 'blue', 'pink', 'purple', 'hotpink'];
var newArr = [];
for (var i = arr.length - 1; i >= 0; i--) {
  newArr[newArr.length] = arr[i]
}
console.log(newArr);

4.1.12数组排序

// 冒泡排序
// var arr = [5, 4, 3, 2, 1];
var arr = [4, 1, 2, 3, 5];
for (var i = 0; i <= arr.length - 1; i++) { // 外层循环管趟数 
  for (var j = 0; j <= arr.length - i - 1; j++) { // 里面的循环管 每一趟的交换次数
    // 内部交换2个变量的值 前一个和后面一个数组元素相比较
    if (arr[j] < arr[j + 1]) {
      var temp = arr[j];
      arr[j] = arr[j + 1];
      arr[j + 1] = temp;
    }
  }
}
console.log(arr);

4.2数组常见算法

4.2.1get-element-by-id转驼峰

var str='get-element-by-id'; 
function strToupper(str) { 
  //利用split将字符串分割成数组
  var arr= str.split('-');
  for (var i = 1; i<arr.length; i++) {
    //1.利用for循环获取数组的每个元素
    //2.用charAt(0)获取每个元素的第一个字符
    //3.用substr方法获取除第一个字符以外的其它字符并拼接；
    arr[i]=arr[i].charAt(0).toUpperCase()+arr[i].substr(1,arr[i].length-1) 
  }
  //利用join方法将数组转换成字符串； 
  return arr.join(''); 
} 
console.log(strToupper(str))

4.2.2字符串中出现次数最多的字符

var str = 'asdfssaaasasasasaa';
var obj = {};
for (var i = 0; i < str.length; i++) {
  if (!obj[str.charAt(i)]) {
    obj[str.charAt(i)] = 1;
  } else {
    obj[str.charAt(i)]++
  }
}

4.2.3回文

var input = "ab\n2\n0 2\n1 3";  
function reverscon (input) {  
  input_array = input.split("\n");  
  var nLine = 0;  

  while(nLine < input_array.length){  
    var line = input_array[nLine++].trim();  
    if(line === ''){  
      continue;  
    }  
    var s = line;  
    var n = +input_array[nLine++];  
    while(n--){  
      var input_arrays = input_array[nLine++].trim().split(' ');  
      var p = +input_arrays[0];  
      var l = +input_arrays[1];  

      //你的代码  
      var substring = s.substring(p,p+l);  
      substring = substring.split('').reverse().join('');  
      var arrs = s.split('');     //这一步需要一个变量保存结果，因为splice返回的是  
      arrs.splice(p+l,0,substring);    //被删除的字符，所以连写的话会返回空  
      s = arrs.join('');    //abbaabb  
    }  

  }  
  console.log(s);  
} 
reverscon(input);