本文深入解析JavaScript数组的概念、创建、操作及常见方法，如concat、join、slice等，并提供多个实战案例，助你掌握数组处理技巧。
第6章 数组Array
6.1 什么是数组
- 数组是值得有序集合，每个值叫做一个元素，而每个元素在数组中有一个位置，以数字表示，称为索引。
- js的数组是无类型的，数组元素可以是任意类型，同一个数组中的不同元素可能是对象或数组。
- 简单地说：数组就是用来存放数据的容器。
数组的属性：
| 属性 | 描述 |
|---|---|
| constructor | 返回对创建此对象的数组函数的引用。 |
| length | 设置或返回数组中元素的数目。 |
| prototype | 使您有能力向对象添加属性和方法。 |
6.2 数组的创建
1、通过字面量直接创建
var arr1 = []; //创建一个空数组
var arr2 = [1,2,3]; //创建一个有3个值的数值
var arr3 = [1,true,"hello"]; //创建元素类型不同的数组
2、通过构造函数Array创建
//a,调用时没有参数
var a = new Array();
//b,调用时有一个数值参数，它指定长度
var b = new Array(10);
//c,显式指定两个或多个数组元素或者数组的一个非数值元素
var c = new Array(1,2,3);
在js中，数组的元素类型可以是任意的，因此，有时数组中的某个元素值，也可以是一个数组，这样的数组被称为多维数组。
理论上可以嵌套N层，但是最常用的一般是二维数组。
6.3 获取数组元素
通过指定数组名以及索引号码，你可以访问某个特定的元素。
/*
格式： 数组名[下标];
下标又称为索引，从0开始，到数组长度-1。
功能：获取下标对应元素的值，如果下标不存在，则返回undefined。
*/
var arr = [2,3,4];
console.log(arr[0]);
console.log(arr[1]);
console.log(arr[2]);
console.log(arr[3]);
//输出结果为：2，3，4，undefined
6.4 遍历数组
js中常用的遍历数组方法有for，foreach等
1、for循环
var arr = ["a",1,2];
for(var i=0,len=arr.length;i<len;i++){
console.log(arr[i]);
}
// 输出结果为：a 1 2
2、foreach遍历
forEach() 方法用于调用数组的每个元素，并将元素传递给回调函数。
注意: forEach() 对于空数组是不会执行回调函数的。
基本语法
arr.forEach(function(currvalue,index,arr),thisValue);
- function(currvalue,index,arr)：必选。currvalue必需，index可选（当前索引），arr可选（当前元素数组对象）
- thisValue：可选，表示当前对象，this；如果为空，“undefined”会传递this值。
案例演示
var abc = ["范冰冰", "张钧甯", "张馨予", "蒋勤勤", "赵丽颖"];
abc.forEach(function(value, index){
console.log((index+1)+"号美女是:" + value);
})
//输出结果为：1号美女是:范冰冰 2号美女是:张钧甯 3号美女是:张馨予 4号美女是:蒋勤勤 5号美女是:赵丽颖
6.5 数组元素修改和添加
- 通过数组下标方式，可以修改和添加数组的元素。
- 由于js中数组的长度是动态的，如果添加的下标不存在，则在数组末尾新增一个元素。
var arr = ["hello","world"];
//可以将world，修改为javascript
arr[1] = "javascript";
//可以在数组最后添加一个新元素。so
arr[2] = "so";
//循环遍历数组，并在控制台中打印
for(var i=0,len=arr.length;i<len;i++){
console.log(arr[i]);
}
//输出结果为：hello javascript so
6.6 数组操作案例
案例1 求数组中的所有数的和
var arr = [22,33,44,5,5,66,77];
var sum=0;
for(var i=0,len=arr.length;i<len;i++){
sum+=arr[i];
}
console.log(sum); //输出结果为：252
案例2 找出下列数组中最大的数
var arr = [22,33,44,5,5,66,77];
//假定最大数为数组的第一个元素
var max=arr[0];
for(var i=1,len=arr.length;i<len;i++){
if(arr[i]>max){
max = arr[i];
}
}
console.log(max); //输出结果为：77
案例3 将数组转为字符串，并以“-”拼接。
var arr = [22,33,44,5,5,66,77];
//假定最大数为数组的第一个元素
var str="";
for(var i=1,len=arr.length;i<len;i++){
str+= arr[i]+"-"
}
//将最后一个-截取掉
str = str.substr(0,str.length-1);
console.log(str); //输出结果为：33-44-5-5-66-77
6.7 数组常用方法
| 序号 | 方法 | 描述 | 说明 |
|---|---|---|---|
| 1 | concat() | 连接两个或更多的数组，并返回结果。 | 不修改原数组 |
| 2 | join() | 把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。 | 不修改原数组 |
| 3 | pop() | 删除并返回数组的最后一个元素 | 修改原数组 |
| 4 | push() | 向数组的末尾添加一个或更多元素，并返回新的长度。 | 修改原数组 |
| 5 | reverse() | 颠倒数组中元素的顺序。 | 修改原数组 |
| 6 | shift() | 删除并返回数组的第一个元素 | 修改原数组 |
| 13 | unshift() | 向数组的开头添加一个或更多元素，并返回新的长度。 | 修改原数组 |
| 7 | slice() | 从某个已有的数组返回选定的元素 | 不修改原数组 |
| 8 | sort() | 对数组的元素进行排序 | 修改原数组 |
| 9 | splice() | 删除元素，并向数组添加新元素。 | 修改原数组 |
| 10 | toSource() | 返回该对象的源代码。 | - |
| 11 | toString() | 把数组转换为字符串，并返回结果。 | - |
| 12 | toLocaleString() | 把数组转换为本地数组，并返回结果。 | 不修改原数组 |
| 14 | valueOf() | 返回数组对象的原始值 | 不修改原数组 |
案例1 concat() 方法使用
- 说明： 该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。
- 语法： arrObject.concat(arrayX,arrayX,…,arrayX)
- 返回值： 返回一个新的数组。该数组是通过把所有 arrayX 参数添加到 arrayObject 中生成的。
// 案例1
var a=[1,2,3];
console.log(a.concat([4,5])); // [1, 2, 3, 4, 5]
console.log(a); // [1, 2, 3]
// 案例2
var a=[1,2,3];
var b=[4,5];
var c=[];
console.log(a.concat(b)); // [1, 2, 3, 4, 5]
console.log(c.concat(a,b)); // [1, 2, 3, 4, 5]
console.log(a); // [1, 2, 3]
console.log(b); // [4，5]
console.log(c); // []
案例2 join() 方法使用
- 说明： 用于把数组中的所有元素放入一个字符串。
- 语法： arrayObject.join(separator), separator，可是任意的字符。
- 返回值： 返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把这些字符串连接起来，在两个元素之间插入 separator 字符串而生成的。
// 案例1
var a=[1,2,3];
console.log(a.join()); // 1,2,3
console.log(a.join("=")) // 1=2=3
console.log(a); // [1, 2, 3]
案例3 pop() 方法使用
- 说明： 用于删除并返回数组的最后一个元素。此方法更改数组的长度。直接修改原数组。
- 语法： arrayObject.pop()
- 返回值： 从数组中删除的元素(当数组为空时返回undefined)。
// 案例1
var a=[1,2,3];
console.log(a.pop()); // 3--->删除的数组元素
console.log(a); // [1, 2]
案例4 push() 方法
- 说明： 将一个或多个元素添加到数组的末尾，并返回该数组的新长度。直接修改原数组。
- 语法： arrayObject.push()
- 返回值： 当调用该方法时，新的 length 属性值将被返回。
// 案例1
var a=[1,2,3];
console.log(a.push(4,5)); // 5---->为新数组的长度。
console.log(a); // [1, 2, 3, 4, 5]
案例5 reverse() 方法
- 说明： 用于颠倒数组中元素的顺序。直接修改原数组。
- 语法： arrayObject.reverse()
- 返回值： 返回逆序后的数组。
// 案例1
var a=[1,2,3];
console.log(a.reverse()); // [3, 2, 1]
console.log(a); // [3, 2, 1]
案例6 shift() 方法
- 说明： 用于把数组的第一个元素从其中删除。该方法会改变数组的长度。直接修改原数组。
- 语法： arrayObject.shift()
- 返回值： 返回数组第一个元素的值。如果数组是空的，那么 shift() 方法将不进行任何操作，返回 undefined 值
// 案例1
var a=[1,2,3];
console.log(a.shift()); // 1------> 返回数组的第一个元素
console.log(a); // [2,3] 原数组被修改
案例7 slice() 方法
- 说明： 从已有的数组中返回选定的元素。不会修改数组
- 语法： arrayObject.slice(start,end) ，start和end均为数组下标，为正值时下标从0开始，负值时下标从-1开始。
- 返回值： 返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素。
- 总结：
- start：必需，取值为：[0~arr.length)。如果是负数，从数组尾部开始算起的位置。-1 指最后一个元素，-2 倒数第二个元素。
- end：可选。从何处结束选取。如果没有指定该参数，则从start到数组结束的所有元素。如果是负数，那么从数组尾部开始算起的元素。
- 取值时，包括start位置元素，不包括end位置的元素值。也即是：[start,end)。
- start为正值：当end为正值，end>start时，均可取值；当end为负值时，(end+arr.length) > start，均可取值。
- start为负值：当end为正值，start+arr.length>end，均可取值；当end为负值，abs(start)>abs(end)时，才能取到元素。
- 终极总结： 谁为负值自加arr.length后，满足start>end，均可取值。
// 案例1
var a=[1,2,3,4,5,6,7,8];
console.log(a.slice(1)); // [2, 3, 4, 5, 6, 7, 8]
console.log(a.slice(1,7)); // [2, 3, 4, 5, 6, 7]
console.log(a.slice(1,-1)); // [2, 3, 4, 5, 6, 7]
console.log(a.slice(1,-3)); // 从下标1开始取到倒数第三位--->[2, 3, 4, 5]
console.log(a.slice(-3,a.length)); // 从倒数第三位开始取到末尾--->[6, 7, 8]
console.log(a.slice(-4,-1)); // 等价于a.slice(4,7)--->[5, 6, 7]
console.log(a.slice(-1,1)); // -1已经是最后一位了，end只能为length时才能取到值，所以返回--->[]
console.log(a.slice(-1,a.length)); // [8]
console.log(a); // [1, 2, 3, 4, 5, 6, 7, 8]
案例6 sort() 方法
- 说明： 用于对数组的元素进行排序。直接修改原数组。
- 语法： arrayObject.sort(sortby)，可选，必须是函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。
- 函数 sortby(a,b) 比较a、b两个值的大小，返回一个用于说明这两个值的相对顺序的数字。两个参数 a 和 b，其返回值如下：
- 若 a 小于 b，即 a - b 小于零，则返回一个小于零的值，数组将按照升序排列。
- 若 a 等于 b，则返回 0。
- 若 a 大于 b, 即 a - b 大于零，则返回一个大于零的值，数组将按照降序排列。
- 函数 sortby(a,b) 比较a、b两个值的大小，返回一个用于说明这两个值的相对顺序的数字。两个参数 a 和 b，其返回值如下：
- 返回值： 对数组的引用。请注意，数组在原数组上进行排序，不生成副本。
// 案例1
var a=[1,2,3,4,5,11,22,33,44,55];
console.log(a.sort()); // [1, 11, 2, 22, 3, 33, 4, 44, 5, 55]
console.log(a); // [1, 11, 2, 22, 3, 33, 4, 44, 5, 55]
//定义排序函数：
function sortby(a,b){ //默认按升序排列
return a-b;
}
console.log(a.sort(sortby)); // [1, 2, 3, 4, 5, 11, 22, 33, 44, 55]
console.log(a); // [1, 2, 3, 4, 5, 11, 22, 33, 44, 55]
// 案例2 纯数值数组排序，对案例1进行封装
var a=[99,1,2,3,3,4,5,11,22,44,33,44,55];
//自定义实现：升序或者降序功能
function sortAuto(arr,flag){
//将flag值转换
if(flag == undefined){
flag = 1; //默认为：升序
}else{
flag = Boolean(flag) ? 1 : -1; // 如果有值ture为1，flase为-1
}
// 判定Flag的值，自动实现升序或者降序排序
return arr.sort(function(a,b){
return a===b ? 0 : (flag > 0 ? a-b : b-a); // > 0 --> 升序 ； < 0 --> 降序
})
}
console.log(sortAuto(a,false)); // [99, 55, 44, 33, 22, 11, 5, 4, 3, 2, 1]
console.log(sortAuto(a)); // [99, 55, 44, 33, 22, 11, 5, 4, 3, 2, 1]
案例7 splice() 方法
-
说明： 向/从数组中添加/删除项目，然后返回被删除的项目。直接修改原数组。
-
语法： arrayObject.splice(index,howmany,item1,…,itemX)，index和howmany必选，item1,…,itemX为可选。
- splice() 方法可删除从index处开始的零个或多个元素，并且用参数列表中声明的一个或多个值来替换那些被删除的元素。
- 如果从 arrayObject 中删除了元素，则返回的是含有被删除的元素的数组。
-
返回值： 返回数组，包含被删除项目的新数组，如果有的话。
-
注意： splice()方法与slice()方法的作用是不同的，splice()方法会直接对数组进行修改。
//案例1 将指定位置的元素删除。最少删除一个。
var arr = [1,2,3,4,5,6,7,8,9];
console.log(arr); // [1,2,3,4,5,6,7,8,9];
console.log(arr.splice(2,1)); // 返回：[3]，arr变为：[1,2,4,5,6,7,8,9];
console.log(arr.splice(2,4)); // 返回：[4,5,6,7]
console.log(arr); // arr变这：[1,2,8,9];
//案例2 将指定位置的元素删除，并替换成指定的字符
var arr1 = [1,2,3,4,5,6,7,8,9];
console.log(arr1); // [1,2,3,4,5,6,7,8,9];
console.log(arr1.splice(2,1,0)); // [3]
console.log(arr1); // [1,2,0,4,5,6,7,8,9];
//案例3 在指定位置插入多个元素
var arr2 = [1,2,3,4,5,6,7,8,9];
console.log(arr2); // [1,2,3,4,5,6,7,8,9];
console.log(arr2.splice(2,0,22,33)); // []
console.log(arr2); // [1,2,22,33,3,4,5,6,7,8,9];
案例8 toSource() 方法
- 说明： toSource()方法表示对象的源代码。该原始值由Array对象派生的所有对象继承。
- 语法： object.toSource()
- 返回值： 返回一个对象源码
- 注意： 只有 Gecko核心的浏览器（比如Firefox）支持该方法，也就是说IE、Safari、Chrome、Opera 等浏览器均不支持该方法。
function employee(name,job,born)
{
this.name=name;
this.job=job;
this.born=born;
}
var bill=new employee("Bill Gates","Engineer",1985);
document.write(bill.toSource());
//在chrome下运行，返回错误：
// VM332:10 Uncaught TypeError: bill.toSource is not a function at <anonymous>:10:21
案例9 toString() 方法
- 说明： toString() 方法可把数组转换为字符串，并返回结果。
- 语法： arrayObject.toString()
- 返回值： arrayObject的字符串表示。返回值与没有参数的join()方法返回的字符串相同。数组中的元素之间用逗号分隔。
- 注意： 当数组用于字符串环境时，JavaScript会调用这一方法将数组自动转换成字符串。但是在某些情况下，需要显式地调用该方法。
var arr = ['a','b','c','d'];
console.log(arr.toString()); // a,b,c,d
案例10 toLocaleString() 方法
- 说明： 把数组转换为本地字符串。
- 语法： arrayObject.toLocaleString()
- 返回值： arrayObject 的本地字符串表示。
- 注意： 首先调用每个数组元素的toLocaleString()方法，然后使用地区特定的分隔符把生成的字符串连接起来，形成一个字符串。
//案例1 将数组转换为字符串
var arr = ['a','b','c','d'];
console.log(arr.toLocaleString()); // a,b,c,d
案例11 unshift() 方法
- 说明： 向数组的开头添加一个或更多元素，并返回新的长度。不修改原数组
- 语法： arrayObject.unshift(newelement1,newelement2,…,newelementX)
- newelement1，必选，可添加的第一个元素；
- newelement2,…,newelementX，可选，
- 返回值： arrayObject 的新长度。
- 注意： unshift()方法将把它的参数插入arrayObject的头部，并将已经存在的元素顺次地移到较高的下标处，以便留出空间。该方法的第一个参数将成为数组的新元素 0，如果还有第二个参数，它将成为新的元素 1，以此类推。
//案例1 将数组转换为字符串
var arr = ['a','b','c','d'];
console.log(arr); // ["a", "b", "c", "d"]
console.log(arr.unshift('o')); // 5
console.log(arr); //["a", "b", "c", "d"]
案例12 valueOf() 方法
- 说明： 该原始值由 Array 对象派生的所有对象继承。 不修改原数组
- 语法： arrayObject.valueOf()
- 返回值： arrayObject 的新长度。
- 注意： valueOf() 方法通常由 JavaScript在后台自动调用，并不显式地出现在代码中。
//案例1 将数组转换为字符串
var arr = ['a','b','c','d'];
console.log(arr); // ["a", "b", "c", "d"]
console.log(arr.valueOf()); // ["a", "b", "c", "d"]
console.log(arr); // ["a", "b", "c", "d"]
6.8 数组相关练习
更新于20200728
- 定义一个含有30个整型元素的数组，按顺序分别赋予从2开始的偶数；然后按顺序每五个数求出一个平均值，放在另一个数组中并输出。试编程。
var arr = [];
var i = 1;
// 循环存放从2开始的30个连续偶数
while (arr.length < 30) {
if (i % 2 == 0) {
arr.push(i);
}
i++;
}
// [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60]
var avg = [];
for (let j = 0; j < arr.length; j++) {
if ((j + 1) % 5 == 0) { // 当循环到5的倍数时，就截取相应的个数形成一个新的数组。
// 计算截取数组的上限和下限
// 计算截取坐标：((j+1)/5-1)*5,j+1 ===> j=4 -> 0,5; j=9 -> 5,10 ; ... j = 29 -> 25,30
let temp = arr.slice(((j + 1) / 5 - 1) * 5, j + 1);
// console.log(temp);
// let avg = 0;
let sum = 0;
let len = temp.length;
//循环计算所取的临时数组的平均值，并添加到新数组中
for (let k = 0; k < len; k++) {
sum += temp[k];
}
// 将5个数平均存入数组中。
avg.push(sum / len);
}
}
console.log(avg); // [6, 16, 26, 36, 46, 56]
- 通过循环按行顺序为一个5×5的二维数组a，赋1到25的自然数，然后输出该数组的左下半三角。试编程。
/*
1. 先打印一个5*5 的 * 矩阵
j j j j j
1, 2, 3, 4, 5 i=1 1 2 3 4 5 len*(i-1)+j
6, 7, 8, 9, 10 i=2
11,12,13,14,15 i=3
16,17,18,19,20 i=4
21,22,23,24,25 i=5
2. 将 * 用数字替换
*/
var arr = [];
// 自动打钱一个5x5的数组，并且从1到25 排列
for (let i = 1; i <= 5; i++) {
// 当arr为空时，len直接为0，否则为arr第一个元素的length值
if (arr.length == 0) {
len = 0;
} else {
len = arr[0].length
}
// 定义临时数组，用于存放arr的元素
let temp = [];
// 循环计算数组元素值。
for (let j = 1; j <= 5; j++) {
temp.push(len * (i - 1) + j);
}
// 将temp添加到arr中。
arr.push(temp);
}
// 循环打印,arr[0][0]
for (let k = 0; k < arr.length; k++) {
for (let n = 0; n <= k; n++) {
document.write(arr[k][n] < 10 ? '0' + arr[k][n] : arr[k][n], " ");
}
document.write("<br />");
}
/* 打印结果：
01
06 07
11 12 13
16 17 18 19
21 22 23 24 25
*/
- 冒泡排序(Bubble Sort)案例:
/*
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
本质：把小（大）的元素往前（后）调
1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
*/
var arr = [45, 89, 52, 78, 99];
/*分析：
第一轮：
第一步：89,45,52,78,99
第二步：89,52,45,78,99
第三步：89,52,78,45,99
第四步：89,52,78,99,45
第二轮：
第一步：89,52,78,99,45
第二步：89,78,52,99,45
第三步：89,78,99,52,45
第三轮：
第一步：89,78,99,52,45
第二步：89,99,78,52,45
第四轮：
第一步：99,89,78,52,45
分析：
比较轮数 = 数组长度 - 1;
每一轮比较的次数 = 数组长度 - 当前的轮数。
*/
// 封装成函数
function bubbleSort(arr) {
var len = arr.length;
let temp = '';
for (let k = len - 1; k > 0; k--) { // 定义要跑几轮,
for (let j = 0; j < k - 1; j++) { // 每轮要交换的次数
if (arr[j] > arr[j + 1]) { // 由小到大，用 > , 反之用 <
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
// 调用函数，
bubbleSort(arr);
console.log(arr); // 输出结果为：[45, 52, 78, 89, 99]
- 选择排序（Selection sort）是一种简单直观的排序算法。
/* 原理：
1. 在序列中找到最小（大）元素，存放到排序序列的起始位置，
2. 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
3. 以此类推，直到所有元素均排序完毕。
*/
var arr = [111, 78, 45, 89, 52, 99];
/**
* 分析
* 第一步：从下标i = 1开始，找到数组中最小值的坐标，将对应的值与i=0进行交换
* 45,78,111,89,52,99
* 第二步：从下标i = 2开始，找到从i=1开始数组中最小值，将对应的值与i=1进行交换
* 45,52,111,89,78,99
* 第三步：从下标i = 3开始，找到从i= 2开始数组中最小值，将对应的值与i=2进行交换
* 45,52,78,89,111,99
* 第四步：从下标i = 4开始，找到从i= 3开始数组中最小值，将对应的值与i=3进行交换
* 45,52,78,89,111,99
* 第五步：从下标i = 4开始，找到从i= 3开始数组中最小值，将对应的值与i=3进行交换
* 45,52,78,89,99,111
*
*/
var len = arr.length;
for (let i = 0; i < len - 1; i++) {
let smallest = i;
for (let j = i + 1; j < len; j++) { // j=5
//找到最小值对应的坐标，
if (arr[smallest] > arr[j]) {
smallest = j;
}
}
// 将最小值与当前第一个值交换。
let temp = '';
temp = arr[i];
arr[i] = arr[smallest];
arr[smallest] = temp;
// 页面显示交换后，数组序列
document.write(arr.toString());
document.write("<br />")
}
console.log(arr); //[45, 52, 78, 89, 99, 111]
- 有一个从小到大排好序的数组：[2,3,4,56,67,98] 。 现输入一个数，要求按原来的规律将它插入数组中。 //63
var arr = [2, 3, 4, 56, 67, 98];
var num = 63;
var len = arr.length;
for (let i = 0; i < len; i++) {
// console.log(arr[i])
//判断输入数字的大小位置
if (arr[i] < num && arr[i + 1] > num) {
// 通过splice方法添加数组元素
arr.splice(i, 0, num);
break;
}
}
console.log(arr); //[2, 3, 4, 63, 56, 67, 98]
- 编写函数map(arr) 把数组中的每一位数字都增加30%
var arr = [2, 3, 4, 56, 67, 98];
function growth(arr) {
let len = arr.length;
for (let i = 0; i < len; i++) {
arr[i] = arr[i] + arr[i] * 0.3;
}
return arr;
}
console.log(growth(arr)); // [2.6, 3.9, 5.2, 72.8, 87.1, 127.4]
- 编写函数has(arr , 60) 判断数组中是否存在60这个元素，返回布尔类型
var arr = [2, 3, 4, 56, 67, 98];
function has(arr, pram) {
let len = arr.length;
let flag = false; // 定义一个查找标志
for (let i = 0; i < len; i++) {
if (arr[i] == pram) { // 如果找到对应元素与pram一致，则设置为true
flag = true;
}
}
// 判断当前的flag值，返回对应的值。
return flag ? true : false;
}
console.log(has(arr, 60));
- 生成13位条形码(对之前的知识综合练习)
// Ean-13 码规则：第十三位数字是前十二位数字经过计算得到的校验码。
/* 例如：690123456789
第三位计算其校验码的过程为：
@前十二位的奇数位和6+0+2+4+6+8=26
@前十二位的偶数位和9+1+3+5+7+9=34
@将奇数和与偶数和的三倍相加26+34*3=128
@取结果的个位数：128的个位数为8
@用10减去这个个位数10-8=2
所以校验码为2
（注：如果取结果的个位数为0，那么校验码不是（10-0=10），而是0）
实现方法ean13（）计算验证码，输入12位条码，返回带验证码的条码。
例如：输入：692223361219输出：6922233612192
*/
var str = '690123456789';
// 将字符串转换为数组
function str2arr(str) {
let len = str.length;
let arr = [];
for (let i = 0; i < len; i++) {
arr.push(parseInt(str.substr(i, 1)));
}
return arr;
}
// console.log(str2arr(str));
// 获取校验码
function getCode(arr) {
console.log(arr);
let len = arr.length;
let evenSum = 0; //偶数和
let oddSum = 0; //奇数和
for (let i = 0; i < len; i++) {
if (i % 2 == 0) {
evenSum += arr[i]; //偶数和
} else {
oddSum += arr[i]; //奇数和
}
}
// 返回检验码
return 10 - (oddSum + evenSum * 3) % 10;
}
function ean13(str) {
let len = str.length;
let arr = [];
//将字符串转化为数组
for (let i = 0; i < len; i++) {
arr.push(parseInt(str.substr(i, 1)));
}
let evenSum = 0; //偶数和
let oddSum = 0; //奇数和
for (let i = 0; i < arr.length; i++) {
if (arr[i] % 2 == 0) {
evenSum += arr[i]; //偶数和
} else {
oddSum += arr[i]; //奇数和
}
}
// 校验码
let checkCode = ((oddSum + evenSum * 3) % 10) == 0 ? 0 : (10 - (oddSum + evenSum * 3) % 10);
// 返回条形码
return str + checkCode;
}
console.log(ean13('692723361219')); // 6922233612194
- 编写函数norepeat(arr) 将数组的重复元素去掉，并返回新的数组（拓展）
var arr = [2, 3, 56, 4, 56, 67, 3, 98];
function norepeat(arr) {
let len = arr.length;
let newArr = [];
for (let i = 0; i < len; i++) {
let flag = false;
for (let j = i+1; j < len; j++) {
if (arr[i] == arr[j]) {
flag = true;
}
}
flag ? '' : newArr.push(arr[i]);
}
return newArr;
}
console.log(norepeat(arr));
console.log(arr);
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
