数组

int i,j,l,a[50],n=0,k;for(i=2;i<=100;i++){l=1;for(j=2;j<i;j++){if(i%j==0){l=0;break;}}if(l==1)a[n++]=i; }for(k=0;k<n;k++){if(k%5==0)printf(" ");printf("%4d ",a[k]);}

int num;int.TryParse("12334",num);

你搞错了一点：Unicode字符规定，每个字符占用两个字节，包括英文和数字，所以你只需将：<MarshalAs(UnmanagedType.ByValTStr, sizeconst:=3)> Public s As String改成：<MarshalAs(UnmanagedType.ByValTStr, sizeconst:=6)> Public s As String即可！

应该是定义一个下标从1到n的数组

$arr = array("name"=>1111,"pass"=>222222);$key = "pass";foreach($arr as $k=>$v){if($k==$key){unset($arr[$k]); }}print_r($arr);

JavaScript中创建数组有两种方式（一）使用 Array 构造函数：var arr1 = new Array(); //创建一个空数组var arr2 = new Array(20); // 创建一个包含20项的数组var arr3 = new Array(“lily”,“lucy”,“Tom”); // 创建一个包含3个字符串的数组（二）var 创建数组var arr4 = []; //创建一个空数组var arr5 = [20]; // 创建一个包含1项的数组var arr6 = [“lily”,“lucy”,“Tom”]; // 创建一个包含3个字符串的数组1、join()通过join()方法可以实现重复字符串，只需传入字符串以及重复的次数，就能返回重复后的字符串，函数如下：function repeatString(str, n) {return new Array(n + 1).join(str);}console.log(repeatString(“abc”, 3)); // abcabcabcconsole.log(repeatString(“Hi”, 5)); // HiHiHiHiHi2、push()和pop()push(): 可以接收任意数量的参数，把它们逐个添加到数组末尾，并返回修改后数组的长度。pop()：数组末尾移除最后一项，减少数组的 length 值，然后返回移除的项。var arr = [“Lily”,“lucy”,“Tom”];var count = arr.push(“Jack”,“Sean”);console.log(count); // 5console.log(arr); // [“Lily”, “lucy”, “Tom”, “Jack”, “Sean”]var item = arr.pop();console.log(item); // Seanconsole.log(arr); // [“Lily”, “lucy”, “Tom”, “Jack”]3、shift() 和 unshift()shift()：删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined 。unshift:将参数添加到原数组开头，并返回数组的长度 。这组方法和上面的push()和pop()方法正好对应，一个是操作数组的开头，一个是操作数组的结尾。var arr = [“Lily”,“lucy”,“Tom”];var count = arr.unshift(“Jack”,“Sean”);console.log(count); // 5console.log(arr); //[“Jack”, “Sean”, “Lily”, “lucy”, “Tom”]var item = arr.shift();console.log(item); // Jackconsole.log(arr); // [“Sean”, “Lily”, “lucy”, “Tom”]4、sort()sort()：按升序排列数组项——即最小的值位于最前面，最大的值排在最后面。在排序时，sort()方法会调用每个数组项的 toString()转型方法，然后比较得到的字符串，以确定如何排序。即使数组中的每一项都是数值， sort()方法比较的也是字符串，因此会出现以下的这种情况：var arr1 = [“a”, “d”, “c”, “b”];console.log(arr1.sort()); // [“a”, “b”, “c”, “d”]arr2 = [13, 24, 51, 3];console.log(arr2.sort()); // [13, 24, 3, 51]console.log(arr2); // 13, 24, 3, 51为了解决上述问题，sort()方法可以接收一个比较函数作为参数，以便我们指定哪个值位于哪个值的前面。比较函数接收两个参数，如果第一个参数应该位于第二个之前则返回一个负数，如果两个参数相等则返回 0，如果第一个参数应该位于第二个之后则返回一个正数。以下就是一个简单的比较函数：function compare(value1, value2) {if (value1 < value2) {return -1;} else if (value1 > value2) {return 1;} else {return 0;}}arr2 = [13, 24, 51, 3];console.log(arr2.sort(compare)); // [3, 13, 24, 51]如果需要通过比较函数产生降序排序的结果，只要交换比较函数返回的值即可：function compare(value1, value2) {if (value1 < value2) {return 1;} else if (value1 > value2) {return -1;} else {return 0;}}arr2 = [13, 24, 51, 3];console.log(arr2.sort(compare)); // [51, 24, 13, 3]5、reverse()reverse()：反转数组项的顺序。var arr = [13, 24, 51, 3];console.log(arr.reverse()); //[3, 51, 24, 13]console.log(arr); //3, 51, 24, 136、concat()concat() ：将参数添加到原数组中。这个方法会先创建当前数组一个副本，然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组。在没有给 concat()方法传递参数的情况下，它只是复制当前数组并返回副本。var arr = [1,3,5,7];var arrCopy = arr.concat(9,[11,13]);console.log(arrCopy); //[1, 3, 5, 7, 9, 11, 13]console.log(arr); // 1, 3, 5, 7从上面测试结果可以发现：传入的不是数组，则直接把参数添加到数组后面，如果传入的是数组，则将数组中的各个项添加到数组中。但是如果传入的是一个二维数组呢？var arrCopy2 = arr.concat([9,[11,13]]);console.log(arrCopy2); //[1, 3, 5, 7, 9, Array[2]]console.log(arrCopy2[5]); //[11, 13]上述代码中，arrCopy2数组的第五项是一个包含两项的数组，也就是说concat方法只能将传入数组中的每一项添加到数组中，如果传入数组中有些项是数组，那么也会把这一数组项当作一项添加到arrCopy2中。7、slice()slice()：返回从原数组中指定开始下标到结束下标之间的项组成的新数组。slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。在只有一个参数的情况下， slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。如果有两个参数，该方法返回起始和结束位置之间的项——但不包括结束位置的项。var arr = [1,3,5,7,9,11];var arrCopy = arr.slice(1);var arrCopy2 = arr.slice(1,4);var arrCopy3 = arr.slice(1,-2);var arrCopy4 = arr.slice(-4,-1);console.log(arr); //1, 3, 5, 7, 9, 11console.log(arrCopy); //[3, 5, 7, 9, 11]console.log(arrCopy2); //[3, 5, 7]console.log(arrCopy3); //[3, 5, 7]console.log(arrCopy4); //[5, 7, 9]arrCopy只设置了一个参数，也就是起始下标为1，所以返回的数组为下标1（包括下标1）开始到数组最后。arrCopy2设置了两个参数，返回起始下标（包括1）开始到终止下标（不包括4）的子数组。arrCopy3设置了两个参数，终止下标为负数，当出现负数时，将负数加上数组长度的值（6）来替换该位置的数，因此就是从1开始到4（不包括）的子数组。arrCopy4中两个参数都是负数，所以都加上数组长度6转换成正数，因此相当于slice(2,5)。8、splice()splice()：很强大的数组方法，它有很多种用法，可以实现删除、插入和替换。删除：可以删除任意数量的项，只需指定 2 个参数：要删除的第一项的位置和要删除的项数。例如， splice(0,2)会删除数组中的前两项。插入：可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、 0（要删除的项数）和要插入的项。例如，splice(2,0,4,6)会从当前数组的位置 2 开始插入4和6。替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。例如，splice (2,1,4,6)会删除当前数组位置 2 的项，然后再从位置 2 开始插入4和6。splice()方法始终都会返回一个数组，该数组中包含从原始数组中删除的项，如果没有删除任何项，则返回一个空数组。var arr = [1,3,5,7,9,11];var arrRemoved = arr.splice(0,2);console.log(arr); //[5, 7, 9, 11]console.log(arrRemoved); //[1, 3]var arrRemoved2 = arr.splice(2,0,4,6);console.log(arr); // [5, 7, 4, 6, 9, 11]console.log(arrRemoved2); // []var arrRemoved3 = arr.splice(1,1,2,4);console.log(arr); // [5, 2, 4, 4, 6, 9, 11]console.log(arrRemoved3); //[7]9、indexOf()和 lastIndexOf()indexOf()：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的开头（位置 0）开始向后查找。lastIndexOf：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的末尾开始向前查找。这两个方法都返回要查找的项在数组中的位置，或者在没找到的情况下返回uf02d1。在比较第一个参数与数组中的每一项时，会使用全等操作符。var arr = [1,3,5,7,7,5,3,1];console.log(arr.indexOf(5)); //2console.log(arr.lastIndexOf(5)); //5console.log(arr.indexOf(5,2)); //2console.log(arr.lastIndexOf(5,4)); //2console.log(arr.indexOf(“5”)); //-110、forEach()forEach()：对数组进行遍历循环，对数组中的每一项运行给定函数。这个方法没有返回值。参数都是function类型，默认有传参，参数分别为：遍历的数组内容；第对应的数组索引，数组本身。var arr = [1, 2, 3, 4, 5];arr.forEach(function(x, index, a){console.log(x + ‘|" + index + ‘|" + (a === arr));});// 输出为：// 1|0|true// 2|1|true// 3|2|true// 4|3|true// 5|4|true11、map()map()：指“映射”，对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。下面代码利用map方法实现数组中每个数求平方。var arr = [1, 2, 3, 4, 5];var arr2 = arr.map(function(item){return item*item;});console.log(arr2); //[1, 4, 9, 16, 25]12、filter()filter()：“过滤”功能，数组中的每一项运行给定函数，返回满足过滤条件组成的数组。var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];var arr2 = arr.filter(function(x, index) {return index % 3 === 0 || x >= 8;});console.log(arr2); //[1, 4, 7, 8, 9, 10]13、every()every()：判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回true。var arr = [1, 2, 3, 4, 5];var arr2 = arr.every(function(x) {return x < 10;});console.log(arr2); //truevar arr3 = arr.every(function(x) {return x < 3;});console.log(arr3); // false14、some()some()：判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回true。var arr = [1, 2, 3, 4, 5];var arr2 = arr.some(function(x) {return x < 3;});console.log(arr2); //truevar arr3 = arr.some(function(x) {return x < 1;});console.log(arr3); // false15、reduce()和 reduceRight()这两个方法都会实现迭代数组的所有项，然后构建一个最终返回的值。reduce()方法从数组的第一项开始，逐个遍历到最后。而 reduceRight()则从数组的最后一项开始，向前遍历到第一项。这两个方法都接收两个参数：一个在每一项上调用的函数和（可选的）作为归并基础的初始值。传给 reduce()和 reduceRight()的函数接收 4 个参数：前一个值、当前值、项的索引和数组对象。这个函数返回的任何值都会作为第一个参数自动传给下一项。第一次迭代发生在数组的第二项上，因此第一个参数是数组的第一项，第二个参数就是数组的第二项。下面代码用reduce()实现数组求和，数组一开始加了一个初始值10。var values = [1,2,3,4,5];var sum = values.reduceRight(function(prev, cur, index, array){return prev + cur;},10);console.log(sum); //25

my @a = "a" .. "e";my $del_index = 3;splice @a, $del_index, 1;print @a;================abce

在阅读vue官网的时候，偶然间看到了一个观察数组变异的方法，变异方法？Are you kidding me? ...什么东西？guide就给了这么一堆东西： Vue 包含一组观察数组的变异方法，所以它们也将会触发视图更新。这些方法如下： * 1.push( ) * 2.pop( ) * 3.unshift( ) * 4.shift( ) * 5.splice() * 6.sort() * 7.reverse() 看完这里才恍然大悟，其实数组变异方法都是JavaScript操作数组的方法，那么接下来就一一解释这些方法是干嘛用的 push（）往数组最后面添加一个元素，成功返回当前数组的长度 pop（）删除数组的最后一个元素，成功返回删除元素的值 shift（）删除数组的第一个元素，返回该元素。 unshift（）在数组的开头添加一个或者多个元素，返回原数组的长度，改变原来的数组 splice（）有三个参数，第一个是删除index位置的元素（必选），第二个是想要删除的个数（必选），第三个是删除后想要在原位置替换的值（可选） splice(index，num，5)表示从index下标位置开始向后截取num个元素，截取的这些元素组成一个新数组返回，并且从index位置开始，插入后面的所有参数。（插入到原数组里去） sort（）使数组按照字符编码默认从小到大排序,成功返回排序后的数组 reverse（） 将数组倒序，成功返回倒序后的数组 既然有变异方法那么也自然有非变异方法（操作数组不改变原数组的） filter（）、concat（）和 slice（） 他们不会改变原始数组，他们只会生成一个新的数组 slice（）将原数组copy slice（startindex，endindex）从startindex下标开始向后截取到endindex位置（不包含）的元素，截取的这些元素组成新的数组返回，原数组不变 concat（）将一个或多个数组组合到原数组中，组成新的数组返回 与push的区别 filter（）可以对数组元素进行过滤 逆战

var arr1 = [{id: 2, title: "xxxx"},{id: 3, title: "xxxx"}];var arr2 = [{id: 2, title: "xxxx"},{id: 3, title: "xxxx"},{id: 4, title: "xxxx"},{id: 5, title: "xxxx"}];L:for(var i=0;i<arr2.length;i++){ for(var j=0;j<arr1.length;j++){ if(arr2[i].id==arr1[j].id){ arr2.splice(i,1); i--; continue L; } }}console.log(arr2);

数组中常用的方法有：给数组末尾添加新内容的push方法，删除数组最后一项的pop方法，删除数组第一项的shift方法，向数组首位添加新内容unshift方法等等数组常用的一些方法【推荐课程：JavaScript教程】1、push()向数组的末尾添加新内容参数：要添加的项。传递多个用逗号隔开，任何数据类型都可以返回值：新增后数组的长度是否改变原数组：改变let ary1 = [12,34,26];ary1.push(100); //返回一个新的长度 length=4console.log(ary1)//结果为 [12,34,26,100]2、pop()删除数组的最后一项参数：无返回值：被删除的项是否改变原数组：改变let ary2 = [108,112,39,10];ary2.pop();//删除的最后一项为10console.log(ary2);//[108, 112, 39]3、shift()删除数组的第一项参数：无返回值：被删除的项是否改变原数组：改变let ary3 = [0,108,112,39];ary3.shift();//删除的第一项为0console.log(ary3);//[108, 112, 39] 4、unshift()向数组首位添加新内容参数：要添加的项，多项用","隔开返回值：新数组的长度是否改变原数组：改变let ary4 = ["c","d"];ary4.unshift("a","b");console.log(ary4);//["a", "b", "c", "d"] 5、slice()按照条件查找出其中的部分内容参数：array.slice(n, m)，从索引n开始查找到m处（不包含m）array.slice(n) 第二个参数省略，则一直查找到末尾array.slice(0)原样输出内容，可以实现数组克隆array.slice(-n,-m) slice支持负参数，从最后一项开始算起，-1为最后一项，-2为倒数第二项返回值：返回一个新数组是否改变原数组：不改变let ary5 = [1,2,3,4,5,6,7,8,9]; //console.log(ary5.slice(2,8));//从索引2开始查找到索引为8的内容，结果为[3, 4, 5, 6, 7, 8] //console.log(ary5.slice(0)); console.log(ary5.slice(-2,-1));//[8]6、splice()对数组进行增删改增加：ary.splice(n,0,m)从索引n开始删除0项，把m或者更多的内容插入到索引n的前面返回空数组修改：ary.splice(n,x,m)从索引n开始删除x个，m替换删除的部分把原有内容删除掉，然后用新内容替换掉删除：ary.splice(n,m) 从索引n开始删除m个内容（如果第二个参数省略，则从n删除到末尾）返回删除的新数组，原有数组改变//增加 let ary6_z = [33,44,55,66,77,88]; ary6_z.splice(2,0,"a","b") console.log(ary6_z);// [33, 44, "a", "b", 55, 66, 77, 88] //修改 let ary6_x = [33,44,55,66,77,88]; ary6_x.splice(1,2,"x","y") console.log(ary6_x);// [33, "x", "y", 66, 77, 88] //删除 let ary6_s = [33,44,55,66,77,88]; //console.log(ary6.splice(3,2))//[66, 77] console.log(ary6_s.splice(3));//[66, 77, 88]7、join()用指定的分隔符将数组每一项拼接为字符串参数：指定的分隔符（如果省略该参数，则使用逗号作为分隔符）返回值：拼接好的字符串是否改变原数组：不改变let ary7 = [1,2,3];console.log(ary7.join("、"));//1、2、38、concat()用于连接两个或多个数组参数：参数可以是具体的值，也可以是数组对象。可以是任意多个返回值：返回连接后的新数组是否改变原数组：不改变let ary8 = ["你"];let ary80 = ary8.concat("好");console.log(ary80);//["你", "好"]9、indexOf()检测当前值在数组中第一次出现的位置索引参数：array.indexOf(item,start) item:查找的元素 start:字符串中开始检索的位置返回值：第一次查到的索引，未找到返回-1是否改变原数组：不改变let ary9 = ["a","b","c","d","e","a","f"]; console.log(ary9.indexOf("c"));//2console.log(ary9.indexOf("a",3))//510、lastIndexOf()检测当前值在数组中最后一次出现的位置索引参数：array.lastIndexOf(item,start) item:查找的元素 start:字符串中开始检索的位置返回值：第一次查到的索引，未找到返回-1是否改变原数组：不改变let ary10 = ["a","b","c","d","e","a","f"]; console.log(ary10.lastIndexOf("c"));//2console.log(ary10.lastIndexOf("f",1))//-111、includes()判断一个数组是否包含一个指定的值参数：指定的内容返回值：布尔值是否改变原数组：不改变let ary13 = ["a","b","c","d"]; console.log(ary13.includes("c"));//trueconsole.log(ary13.includes(2));//false12、sort()对数组的元素进行排序（默认是从小到大来排序 并且是根据字符串来排序的）参数：可选(函数) 规定排序规则 默认排序顺序为按字母升序返回值：排序后新数组是否改变原数组：改变sort在不传递参数情况下，只能处理10以内（个位数）数字排序 let ary11 = [32,44,23,54,90,12,9]; ary11.sort(function(a,b){ // return a-b; // 结果[9, 12, 23, 32, 44, 54, 90] // return b-a; // 结果[90, 54, 44, 32, 23, 12, 9] }) console.log(ary11);13、reverse()把数组倒过来排列参数：无返回值：倒序后新数组是否改变原数组：改变let ary12 = [6,8,10,12]; console.log(ary12.reverse());//[12, 10, 8, 6]14、forEach()循环遍历数组每一项参数：函数 ary.forEach(function(item,index,ary){}) item:每一项 index:索引 ary:当前数组返回值：无是否改变原数组：不改变forEach中不能使用continue和break，forEach中不能跳出，只能跳过(return跳过) let ary14 = ["a","b","c","d"]; let item = ary14.forEach(function(item,index,ary){ console.log(item,index,ary); })

js如何删除数组里的某个元素，本文主要和大家分享js删除数组里的某个元素的方法实例。首先可以给js的数组对象定义一个函数，用于查找指定的元素在数组中的位置，即索引，代码为：Array.prototype.indexOf = function(val) {for (var i = 0; i < this.length; i++) {if (this[i] == val) return i;}return -1;};然后使用通过得到这个元素的索引，使用js数组自己固有的函数去删除这个元素： 代码为：Array.prototype.remove = function(val) {var index = this.indexOf(val);if (index > -1) {this.splice(index, 1);}};这样就构造了这样一个函数，比如我有有一个数组：var emp = ["abs","dsf","sdf","fd"]假如我们要删除其中的 "fd" ,就可以使用：//code from http://caibaojian.com/js-splice-element.htmlemp.remove("fd");删除的数组的某一项splice(index,len,[item]) 注释：该方法会改变原始数组。splice有3个参数，它也可以用来替换/删除/添加数组内某一个或者几个值·index:数组开始下标 len: 替换/删除的长度 item:替换的值，删除操作的话 item为空如：arr = ["a","b","c","d"]删除//删除起始下标为1，长度为1的一个值(len设置1，如果为0，则数组不变)var arr = ["a","b","c","d"];arr.splice(1,1);console.log(arr); //["a","c","d"]; //删除起始下标为1，长度为2的一个值(len设置2)var arr2 = ["a","b","c","d"]arr2.splice(1,2);console.log(arr2); //["a","d"]替换//替换起始下标为1，长度为1的一个值为‘ttt"，len设置的1var arr = ["a","b","c","d"];arr.splice(1,1,"ttt");console.log(arr); //["a","ttt","c","d"] var arr2 = ["a","b","c","d"];arr2.splice(1,2,"ttt");console.log(arr2); //["a","ttt","d"] 替换起始下标为1，长度为2的两个值为‘ttt"，len设置的1添加 ---- len设置为0，item为添加的值var arr = ["a","b","c","d"];arr.splice(1,0,"ttt");console.log(arr); //["a","ttt","b","c","d"] 表示在下标为1处添加一项"ttt"2：delete delete删除掉数组中的元素后，会把该下标出的值置为undefined,数组的长度不会变var arr = ["a","b","c","d"];delete arr[1];arr; //["a", undefined × 1, "c", "d"] 中间出现两个逗号，数组长度不变，有一项为undefined更多相关推荐：javascript数组的方法javascript数组去重javascript常用代码大全更新2016-11-17：在stackoverflow高分回答上看到jquery之父John Resig曾经的文章写过的一个代码：// Array Remove - By John Resig (MIT Licensed)Array.prototype.remove = function(from, to) { var rest = this.slice((to || from) + 1 || this.length); this.length = from < 0 ? this.length + from : from; return this.push.apply(this, rest);};下面给出一些实际的用例：// 移除数组中的第二项array.remove(1);// 移除数组中的倒数第二项array.remove(-2);// 移除数组中的第二项和第三项（从第二项开始，删除2个元素）array.remove(1,2);// 移除数组中的最后一项和倒数第二项（数组中的最后两项）array.remove(-2,-1);这个例子跟上面第一个的还是挺相似的，不过没有检查元素的具体项目，而是通过元素在数组的下标位置来定位删除。

一、如何创建一个数组？ 创建数组的方法常见的有三种： 第一种： 第二种： 第三种： 二、数组的一些操作方法 1.数组的length属性：用来计算数组的长度，也就是数组元素的个数 2.数组的push方法：用来向数组的尾部添加新的元素 3.数组的unshift方法：用来向数组元素的前面添加元素 4.数组的pop方法：用来删除数组里面的最后一个元素 5.数组的shift方法：用来删除数组里面的第一个元素 6.数组的splice方法：用来对数组元素进行切割，并且可以增删改的操作 6.数组元素的排序方法：sort（从小到大）、reverse（从大到小） 7.数组的join方法：将数组转化为字符串 8.数组的slice方法：同样是数组的切分方法，但是它不作用在原数组，而是产生了一个新的数组

u2003数组的类型是一个对象，是特殊的对象。 1.方法的作用和含义 2.方法的实参（类型和含义） 3.方法的返回值 4.原来的数组是否发生改变 1.array.push()//从最后添加元素 2.array.unshift()//从头添加 3.array.shift()//删除首部第一个 4.array.pop()从尾部删除一个 5.array.sort()//元素是按ascill码从小到大排列 6.array.reverse()//将数组反序排列 7.array.concat(另一个数组)//将两个数组拼接在一起 8.array.join("字符")//将元素间添加字符，再以字符串的方式返回 9.array.toString()//将数组转化为字符串并用逗号隔开 10.array.slice(开始位置，结束位置)//从哪个位置开始，不包含结束位置，截取个数 11.array.splice(开始位置，要删除几项，要替换的内容) （1）删除：array.splice(0,2):从第0项开始删除2项 （2）添加：array.splice(0,0,"icey"):从第0项开始，删除0项，添加一个内容 （3）替换：array.splice(0,2,"icey"，"rain"):从第0项开始，删除2项，替换成后面的两项内容 12.array.indexof(元素)：从头查找元素第一次出现位置下标，元素不存在反回-1； 13.array.lastIndexOf(元素)：从尾查找元素第一次出现位置下标，元素不存在反回-1； 14.array.forEach(function(item,index){})遍历数组 15.array.every(function(item,index){})//循环数组，只有数组里每一个都满足返回的判断条件才返回true,否则返回false 16.array.some(function(item,index){})//遍历数组，只要数组里有一个元素满足条件就返回true,就不在执行遍历后面的，全都不满足则返回false 17.array.filter(function(item.index){})//过滤筛选符合判断条件的元素，只有为true才会返回 18.array.find(function(item,index){})//筛选符合判断条件的元素，找到返回第一个元素下标，找不到返回-1 19.array.includes(元素)：判断数组中是否含这个元素，返回的是布尔值 20.array.map(function(item,index){})//对数组的每一个元素都进行改变，并生成一个新的数组，原数组不变 21.array.findindex(function(v,i){ //判断函数体});//筛选符合判断条件的元素，找到返回第一个元素下标，找不到返回-1 1.在首部、尾部添加或删除元素 （2）排序，反序排列，数组拼接，转化为字符串 (3)slice截取和splice：删除，添加，替换 (4)查询元素对应的下标，以及是否包含这个元素 (5)循环数组的方法以及区别

str.charAt(index) str.charCodeAt(index) 小写a是大于大写A的 str.indexOf(searchValue [, fromIndex]) str.lastIndexOf(searchValue [, fromIndex]) string.slice(beginSlice[, endSlice]) string.substring(indexStart [, indexEnd]) string.substr(start [, length]) start: 截取的起始位置，默认为0，负数从右往左数截取长度值，不能超过长度 length: 截取的字符串长度，默认为起始位置到最后一个字符的字符长度，默认为length，不支持负数 返回值： 返回截取后的字符串，没有为空 str.toLowerCase() str.toUpperCase() str.trim() str.split([separtor,limit]) arr.push(element1, ..., elementN) arr.unshift(element1, ..., elementN) arr.pop() arr.shift() arr.splice([start, count, data1...]) arr.slice(start, end) arr.join([separator = ","]) 返回值： 拼接后的字符串 arr.reverse() array.concat(value1, value2, ..., valueN) arr.sort([compareFunction])

下面我就为大家分享一篇JS删除数组里的某个元素方法，具有很好的参考价值，希望对大家有所帮助。删除数组指定的某个元素首先可以给JS的数组对象定义一个函数，用于查找指定的元素在数组中的位置，即索引，代码为：Array.prototype.indexOf = function(val) { for (var i = 0; i < this.length; i++) { if (this[i] == val) return i; } return -1; };然后使用通过得到这个元素的索引，使用js数组自己固有的函数去删除这个元素：代码为：Array.prototype.remove = function(val) { var index = this.indexOf(val); if (index > -1) { this.splice(index, 1); } };这样就构造了这样一个函数，比如我有有一个数组：var emp = ["abs","dsf","sdf","fd"]假如我们要删除其中的 "fd" ,就可以使用：emp.remove("fd");删除的数组的某一项splice(index,len,[item]) 注释：该方法会改变原始数组。splice有3个参数，它也可以用来替换/删除/添加数组内某一个或者几个值index:数组开始下标 len: 替换/删除的长度 item:替换的值，删除操作的话 item为空如：arr = ["a","b","c","d"]删除//删除起始下标为1，长度为1的一个值(len设置1，如果为0，则数组不变) var arr = ["a","b","c","d"]; arr.splice(1,1); console.log(arr); //["a","c","d"]; //删除起始下标为1，长度为2的一个值(len设置2) var arr2 = ["a","b","c","d"] arr2.splice(1,2); console.log(arr2); //["a","d"]替换//替换起始下标为1，长度为1的一个值为‘ttt"，len设置的1 var arr = ["a","b","c","d"]; arr.splice(1,1,"ttt"); console.log(arr); //["a","ttt","c","d"] var arr2 = ["a","b","c","d"]; arr2.splice(1,2,"ttt"); console.log(arr2); //["a","ttt","d"] 替换起始下标为1，长度为2的两个值为‘ttt"，len设置的1添加 ---- len设置为0，item为添加的值var arr = ["a","b","c","d"]; arr.splice(1,0,"ttt"); console.log(arr); //["a","ttt","b","c","d"] 表示在下标为1处添加一项"ttt"<span style="font-size:14px;font-family:Arial, Helvetica, sans-serif;background-color:rgb(255,255,255);"> </span>delete方法删除掉数组中的元素后，会把该下标出的值置为undefined,数组的长度不会变var arr = ["a","b","c","d"]; delete arr[1]; arr; //["a", undefined × 1, "c", "d"] 中间出现两个逗号，数组长度不变，有一项为undefined上面是我整理给大家的，希望今后会对大家有帮助。相关文章：关于vue2.0中datepicker使用方法JavaScript调停者模式（详细教程）在jQuery中有关Dom元素使用方法？

1:js中的splice方法splice(index,len,[item]) 注释：该方法会改变原始数组。splice有3个参数，它也可以用来替换/删除/添加数组内某一个或者几个值index:数组开始下标 len: 替换/删除的长度 item:替换的值，删除操作的话 item为空如：arr = ["a","b","c","d"]删除 ---- item不设置arr.splice(1,1) //["a","c","d"] 删除起始下标为1，长度为1的一个值，len设置的1，如果为0，则数组不变arr.splice(1,2) //["a","d"] 删除起始下标为1，长度为2的一个值，len设置的2替换 ---- item为替换的值arr.splice(1,1,"ttt") //["a","ttt","c","d"] 替换起始下标为1，长度为1的一个值为‘ttt"，len设置的1arr.splice(1,2,"ttt") //["a","ttt","d"] 替换起始下标为1，长度为2的两个值为‘ttt"，len设置的1添加 ---- len设置为0，item为添加的值arr.splice(1,0,"ttt") //["a","ttt","b","c","d"] 表示在下标为1处添加一项‘ttt"看来还是splice最方便啦2：delete delete删除掉数组中的元素后，会把该下标出的值置为undefined,数组的长度不会变如：delete arr[1] //["a", ,"c","d"] 中间出现两个逗号，数组长度不变，有一项为undefinedjs 删除数组几种方法var arr=["a","b","c"];若要删除其中的"b",有两种方法：1.delete方法:delete arr[1]这种方式数组长度不变,此时arr[1]变为undefined了,但是也有好处原来数组的索引也保持不变,此时要遍历数组元素可以才用for(index in arr){ document.write("arr["+index+"]="+arr[index]);}这种遍历方式跳过其中undefined的元素* 该方式IE4.o以后都支持了2.数组对象splice方法:arr.splice(1,1);这种方式数组长度相应改变,但是原来的数组索引也相应改变splice参数中第一个1,是删除的起始索引(从0算起),在此是数组第二个元素第二个1,是删除元素的个数,在此只删除一个元素,即"b";此时遍历数组元素可以用普通遍历数组的方式,比如for,因为删除的元素在数组中并不保留* 该方法IE5.5以后才支持值得一提的是splice方法在删除数组元素的同时,还可以新增入数组元素比如arr.splice(1,1,"d","e"),d,e两个元素就被加入数组arr了结果数组变成arr:"a","d","e","c"<big>外一篇：</big>JavaScript通过设置数组的length属性来截断数组是惟一一种缩短数组长度的方法.如果使用delete运算符来删除数组中元素,虽然那个元素变成未定义的,但是数组的length属性并不改变两种删除元素,数组长度也改变的方法. /* *方法:Array.remove(dx) *功能:删除数组元素. *参数:dx删除元素的下标. *返回:在原数组上修改数组 *///经常用的是通过遍历,重构数组.Array.prototype.remove=function(dx){if(isNaN(dx)||dx>this.length){return false;}for(var i=0,n=0;i<this.length;i++){if(this[i]!=this[dx]){this[n++]=this[i]}}this.length-=1}a = ["1","2","3","4","5"];alert("elements: "+a+"nLength: "+a.length);a.remove(0); //删除下标为0的元素alert("elements: "+a+"nLength: "+a.length);/* *方法:Array.baoremove(dx) *功能:删除数组元素. *参数:dx删除元素的下标. *返回:在原数组上修改数组. *///我们也可以用splice来实现.Array.prototype.baoremove = function(dx){if(isNaN(dx)||dx>this.length){return false;}this.splice(dx,1);}b = ["1","2","3","4","5"];alert("elements: "+b+"nLength: "+b.length);b.baoremove(1); //删除下标为1的元素alert("elements: "+b+"nLength: "+b.length);我们知道，在IE5或更低的版本中，JavaScript的Array（数组）对象并未提供现成的删除数组元素的方法。在IE5.5+的版本中，虽然有splice方法，但是并不是删除某一项（或几项），而仅仅是将某一项（或几项）的值清除，也就是说该项仍然存在，数组的长度并没有改变。事实上，我们可以自己为数组增加一个删除方法（注意，这里指的是将数组的某一项真正的从数组成员中移除）。或许你会想到用循环来为数组重新赋值，这样做当然可以，但效率很低。下面我们介绍利用Array对象的两个方法slice、concat来自定义删除数组的方法。具体代码如下，请注意里面的注释。Array.prototype.del=function(n) {//n表示第几项，从0开始算起。//prototype为对象原型，注意这里为对象增加自定义方法的方法。if(n<0)//如果n<0，则不进行任何操作。return this;elsereturn this.slice(0,n).concat(this.slice(n+1,this.length));/*concat方法：返回一个新数组，这个新数组是由两个或更多数组组合而成的。这里就是返回this.slice(0,n)/this.slice(n+1,this.length) 组成的新数组，这中间，刚好少了第n项。slice方法： 返回一个数组的一段，两个参数，分别指定开始和结束的位置。*/}//我们来试一试这个自己增加的方法var test=new Array(0,1,2,3,4,5);test=test.del(3);//从0算起，这里也就是删除第4项。alert(test);

例如有一个数组是 ：var textArr = ["a","b","c","d"];这时我想删除这个数组中的b元素：方法一：delete 删除数组delete textArr[1] 结果为： ["a",undefined,"c","d"] 只是被删除的元素变成了 undefined 其他的元素的键值还是不变。方法二：aplice 删除数组splice(index,len,[item]) 注释：该方法会改变原始数组。index:数组开始下标 len: 替换/删除的长度 item:替换的值，删除操作的话 item为空textArr.splice(1,1); 结果为：["a","c","d"] 直接删除了数组 改变了数组的值。更具体的区别可以查看这里http://www.php.cn/code/927.html，希望对你有帮助

替换0开始的长度为1的范围内的内容吧。后面还需要第3个参数，如果没有第3个参数那就表示把 0,1 的内容替换成没有，自然也就是相当于删除了第0个元素。

这里有详细的解释网页链接

array_splice() 函数从数组中可实现对数据中元素的添加、修改、删除操作，方便对数组中的值进行处理。 语法：array_splice(array,start,length,array) ，start是从0开始标记，千万不要忘记。注意添加和修改时参数是4个，删除是3个参。 添加元素： 删除元素： 修改元素：

因为数组应该是for(let i=0;i<list.length;i++){console.log(list.item(i))才能删除。解决步骤如下：1、首先第一步就是要进行getElementsByTagName 得到的是 HTMLCollections类注意的是有一个ID为"test"的元素，可以直接取得。2、接着就是这时候进行querySelector 得到的是 NodeList注意的是document.querySelectorAll("div").forEach((a,b,c)=>{console.log("第一个参数:" + a + "值");console.log。3、然后就是通过控制台观察发现，两者都具备iterator接口，都可以支持for ... of语相比来讲，援引Arguments来。4、最后一步就是进行ie8中使用Array.prototype.splice.call对伪数组的删除，这时候就可以删除成功了会有提示的，如下图所示。

数组操作函数有：push，pop，join，shift，unshift，slice，splice，concat（1）push 和 pop这两个函数都是对数组从尾部进行压入或弹出操作。push(arg1,arg2,...)可以每次压入一个或多个元素，并返回更新后的数组长度。注意如果参数也是数组的话，则是将全部数组当做一个元素压入到原本的数组里面去。pop() 函数则每次只会弹出结尾的元素，并返回弹出的元素，若是是对空组数调用 pop() 则返回undefined。示例：var oldArr=[1,2,3];alert(oldArr.push(4,[5,6]))//这里只会将[5,6]当做一个元素来策画，返回更新后的数组长度5此时 oldArr = [1,2,3,4,[5,6]]oldArr.pop()//这里弹出最后一个元素[5,6]，而不是6此时 oldArr = [1,2,3,4]oldArr.pop()-->4oldArr.pop()-->3oldArr.pop()-->2oldArr.pop()-->1alert(oldArr.pop())-->undefined(空数组弹出)（2）unshift 和 shiftunshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。unshift() 方法将把它的参数插入 arrayObject 的头部，并将已经存在的元素顺次地移到较高的下标处，以便留出空间。该方法的第一个参数将成为数组的新元素 0，如果还有第二个参数，它将成为新的元素 1，以此类推。请注意，unshift() 方法不创建新的创建，而是直接修改原有的数组。另外在 Internet Explorer 浏览器中 unshift() 无法执行！

该函数的作用是给数组增加以及删除元素，会修改原数组内容splice(startIndex:Number,deleteCount:Number,value:Object):Array第一个参数是必要的，就是删除或者插入元素的位置，第二、三个参数可有可无第二个参数的意思是要删除的元素数量第三个参数的意思是要插入的元素

var arr=["a","b","c"];若要删除其中的"b",有两种方法：1.delete方法:delete arr[1]这种方式数组长度不变,此时arr[1]变为undefined了,但是也有好处原来数组的索引也保持不变,此时要遍历数组元素可以才用for(index in arr){ document.write("arr["+index+"]="+arr[index]);}这种遍历方式跳过其中undefined的元素* 该方式IE4.o以后都支持了2.数组对象splice方法:arr.splice(1,1);这种方式数组长度相应改变,但是原来的数组索引也相应改变splice参数中第一个1,是删除的起始索引(从0算起),在此是数组第二个元素第二个1,是删除元素的个数,在此只删除一个元素,即"b";此时遍历数组元素可以用普通遍历数组的方式,比如for,因为删除的元素在数组中并不保留* 该方法IE5.5以后才支持值得一提的是splice方法在删除数组元素的同时,还可以新增入数组元素比如arr.splice(1,1,"d","e"),d,e两个元素就被加入数组arr了结果数组变成arr:"a","d","e","c"JavaScript通过设置数组的length属性来截断数组是惟一一种缩短数组长度的方法.如果使用delete运算符来删除数组中元素,虽然那个元素变成未定义的,但是数组的length属性并不改变两种删除元素,数组长度也改变的方法. /* *方法:Array.remove(dx) *功能:删除数组元素. *参数:dx删除元素的下标. *返回:在原数组上修改数组 *///经常用的是通过遍历,重构数组.Array.prototype.remove=function(dx){if(isNaN(dx)||dx>this.length){return false;}for(var i=0,n=0;i<this.length;i++){if(this[i]!=this[dx]){this[n++]=this[i]}}this.length-=1}a = ["1","2","3","4","5"];alert("elements: "+a+"nLength: "+a.length);a.remove(0); //删除下标为0的元素alert("elements: "+a+"nLength: "+a.length);/* *方法:Array.baoremove(dx) *功能:删除数组元素. *参数:dx删除元素的下标. *返回:在原数组上修改数组. *///我们也可以用splice来实现.Array.prototype.baoremove = function(dx){if(isNaN(dx)||dx>this.length){return false;}this.splice(dx,1);}b = ["1","2","3","4","5"];alert("elements: "+b+"nLength: "+b.length);b.baoremove(1); //删除下标为1的元素alert("elements: "+b+"nLength: "+b.length);我们知道，在IE5或更低的版本中，JavaScript的Array（数组）对象并未提供现成的删除数组元素的方法。在IE5.5+的版本中，虽然有splice方法，但是并不是删除某一项（或几项），而仅仅是将某一项（或几项）的值清除，也就是说该项仍然存在，数组的长度并没有改变。事实上，我们可以自己为数组增加一个删除方法（注意，这里指的是将数组的某一项真正的从数组成员中移除）。或许你会想到用循环来为数组重新赋值，这样做当然可以，但效率很低。下面我们介绍利用Array对象的两个方法slice、concat来自定义删除数组的方法。具体代码如下，请注意里面的注释。Array.prototype.del=function(n) {//n表示第几项，从0开始算起。//prototype为对象原型，注意这里为对象增加自定义方法的方法。if(n<0)//如果n<0，则不进行任何操作。return this;elsereturn this.slice(0,n).concat(this.slice(n+1,this.length));/*concat方法：返回一个新数组，这个新数组是由两个或更多数组组合而成的。这里就是返回this.slice(0,n)/this.slice(n+1,this.length) 组成的新数组，这中间，刚好少了第n项。slice方法： 返回一个数组的一段，两个参数，分别指定开始和结束的位置。*/}//我们来试一试这个自己增加的方法var test=new Array(0,1,2,3,4,5);test=test.del(3);//从0算起，这里也就是删除第4项。alert(test);这样，仅仅灵活运用了Array对象的两个方法，就实现了我们的要求。更多js 删除数组的几种方法小结相关文章请关注PHP中文网！

收藏 498133191

这两个方法不一样的，slice是从数组中取值，splice是修改数组，要看看方法的定义方法：splice("开始位置","删除数组个数","从删除后的位置开始插入的数组")<script>var e = ["a","b","c","d","e"]a = e.splice(0,2) //这里其实是删除的数组，这里表示从数组e的0位置开始一共删除2个项目alert (a); //所以这里 显示的是 a,balert (e); 数组删除了a,b 剩下的就是c,d,e 所以显示的就是c,d,e</script>

替换0开始的长度为1的范围内的内容吧.后面还需要第3个参数,如果没有第3个参数那就表示把 0,1 的内容替换成没有,自然也就是相当于删除了第0个元素. 再问： 这是在flash里的代码，请朋友给出详细点的解答 再答： 你先确认那是不是 JavaScript? flash 编程也应该支持 javascript 吧。 var fruits = ["Banana", "Orange", "Apple", "Mango"]; var last = fruits.splice(2,0,"Lemon","Kiwi"); 结果 last = Banana,Orange,Lemon,Kiwi,Apple,Mango. 它把从 2 开始的 0 个数据替换成 "Lemon", "Kiwi"。如果你的是 splice(0,1) 那就是把从0开始的1个数据去掉，但没有替换任何东西，只是直接删除。

1、splice splice(index,len,[item]) 注释：该方法会改变原始数组。 splice有3个参数，它也可以用来替换/删除/添加数组内某一个或者几个值 index:数组开始下标 len: 替换/删除的长度 item:替换的值，删除操作的话 item为空 如：arr = ["a","b","c","d"] 删除 ---- item不设置 arr.splice(1,1) //["a","c","d"] 删除起始下标为1，长度为1的一个值，len设置的1，如果为0，则数组不变 arr.splice(1,2) //["a","d"] 删除起始下标为1，长度为2的一个值，len设置的2 替换 ---- item为替换的值 arr.splice(1,1,"ttt") //["a","ttt","c","d"] 替换起始下标为1，长度为1的一个值为‘ttt"，len设置的1 arr.splice(1,2,"ttt") //["a","ttt","d"] 替换起始下标为1，长度为2的两个值为‘ttt"，len设置的1 添加 ---- len设置为0，item为添加的值 arr.splice(1,0,"ttt") //["a","ttt","b","c","d"] 表示在下标为1处添加一项‘ttt" 看来还是splice最方便啦 2、delete delete删除掉数组中的元素后，会把该下标出的值置为undefined,数组的长度不会变 如：delete arr[1] //["a", ,"c","d"] 中间出现两个逗号，数组长度不变，有一项为undefined

delete和splice都可以删除数组中的元素，但是有些区别的。例如有一个数组是 ：var textArr = ["a","b","c","d"];这时想删除这个数组中的b元素：方法一：delete 删除数组delete textArr[1] 结果为： [ "a",undefined,"c","d"]只是被删除的元素变成了 undefined 其他的元素的键值还是不变。方法二：aplice 删除数组splice(index,len,[item]) 注释：该方法会改变原始数组。index:数组开始下标 len: 替换/删除的长度 item:替换的值，删除操作的话 item为空textArr.splice(1,1); 结果为： [ "a","c","d"] 直接删除了数组 改变了数组的值。

输出： 改变前的数组：1,2,3,4,5,6 splice给数组增加一个值888，位于2和3之间：1,2,888,3,4,5,6-----this.list.splice(2, 0, 888) splice删除数组的第2个元素：1,888,3,4,5,6-------this.list.splice(1, 1) splice替换数组中的元素5为555：1,888,3,4,555,5,6------this.list.splice(4, 0, 555)

应当声明为指针，再动态分配：int *s; // 声明 s 是指针s= new int[3]; // 要求 动态分配 整型量 3个元素。（实际可能分配了 4 个）。每个元素 占内存单元 是 sizeof(int), 即 4个字节，或叫 4个单元。要求的 整型量 3个元素，编译器考虑“内存对齐”，实际可能分配了 4 个。若 要求的 整型量 4个元素 s= new int[4]; 编译器 只 分配4 个。到底分配几个元素，要用 sizeof(s) 计算。例如：cout << sizeof(s) << endl; 显示共分配了 sizeof(s) * sizeof(int) 字节的单元。常用对齐数是 4，8。

#include<<a href="https://www.baidu.com/s?wd=stdio.h&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1Yvuym1PyczPHmYn101nh7h0AP8IA3qPjfsn1bkrjKxmLKz0ZNzUjdCIZwsrBtEXh9GuA7EQhF9pywdQhPEUiqkIyN1IA-EUBtdPjTznj6YPjc" target="_blank" class="baidu-highlight">stdio.h</a>>#define MAX 50int insert(int a[],int n,int i,int x){ int j; if(n+1>MAX) printf("无插入空间 "); //数组只能存MAX个数 else if(i<1||i>n+1) printf("插入位置非法 "); //插入位置的范围为1..n+1 else { for(j=n-1;j>i-2;j--) a[j+1]=a[j]; //将数组中i位置及其后面的数，依次向后移动一格 a[<a href="https://www.baidu.com/s?wd=i-1&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1Yvuym1PyczPHmYn101nh7h0AP8IA3qPjfsn1bkrjKxmLKz0ZNzUjdCIZwsrBtEXh9GuA7EQhF9pywdQhPEUiqkIyN1IA-EUBtdPjTznj6YPjc" target="_blank" class="baidu-highlight">i-1</a>]=x; //在i位置插入x n++; } return n; //返回当前数组大小}int del(int a[],int n,int i){ int j; if(i<1||i>n) printf("删除位置非法 "); else { for(j=<a href="https://www.baidu.com/s?wd=i-1&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1Yvuym1PyczPHmYn101nh7h0AP8IA3qPjfsn1bkrjKxmLKz0ZNzUjdCIZwsrBtEXh9GuA7EQhF9pywdQhPEUiqkIyN1IA-EUBtdPjTznj6YPjc" target="_blank" class="baidu-highlight">i-1</a>;j<n-1;j++) a[j] = a[j+1]; n--; } return n;}int search(int a[],int n,int x){ int i; for(i=0;i<n;i++) { if(a[i]==x) return i+1; } return -1;}void printArray(int a[],int n){ int i; for(i=0;;i++) { if(i==n-1) { printf("%d ",a[i]); break; } printf("%d ",a[i]); }}void main(){ int n,i,a[MAX]; int index,x; printf("输入数组中的元素个数 "); scanf("%d",&n); for(i=0;i<n;i++) scanf("%d",&a[i]); printf("请输入要插入的位置和插入的数 "); scanf("%d %d",&index,&x); n = insert(a,n,index,x); printArray(a,n); printf("请输入要删除元素的位置 "); scanf("%d",&index); n = del(a,n,index); printArray(a,n); printf("请输入要查询的元素 "); scanf("%d",&x); i = search(a,n,x); if(i!=-1) printf("%d的位置：%d ",x,i); else printf("未找到%d ",x);}

#include<<a href="https://www.baidu.com/s?wd=stdio.h&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1YkuhnLuHFWPHndn1TsPWD30AP8IA3qPjfsn1bkrjKxmLKz0ZNzUjdCIZwsrBtEXh9GuA7EQhF9pywdQhPEUiqkIyN1IA-EUBtkPjfLnW04nH6kn1RznHnsP10s" target="_blank" class="baidu-highlight">stdio.h</a>>int main(){ int a[6]; int i; double sum=0,avg; for(i = 0;i < 6;i++){ scanf("%d",&a[i]); sum += a[i]; } avg = sum/6; printf("sum = %.0lf average = %.1lf ",sum,avg); return 0;}

1、将字符串数组定义为全局数组;2、线程A:pthread_mutex_lock(mutex);接收输入；写入数组；pthread_mutex_unlock(mutex);3、线程B：pthread_mutex_lock(mutex);显示数组内容；清空数组；pthread_mutex_unlock(mutex);

Private Sub Command1_Click(Index As Integer)"属性窗口中需要设置Command1.Style = 1Command1(Index).BackColor = vbRedEnd Sub

不要放在端口定义里面，最好把端口定义，输入输出，端口类型分开定义。你这看着太乱了，虽然省地方，但是要养成标准的写法。还有就是你的for语句用错了，你在看看for是怎么用的，少一个函数。

数组可以给到list然后扔到View抛出来。也可以扔给ViewBag、ViewData、ViewTemp都可以啊。@foreach(var item in 你抛出来的那个东西){<li>@item<li/>}

来源于 https://blog.csdn.net/u014568921/article/details/51324448?locationNum=10&fps=1 img = np.asarray(image) 或 img=np.array(image) 需要注意的是，如果出现read-only错误，并不是转换的错误，一般是你读取的图片的时候，默认选择的是"r","rb"模式有关。 修正的办法:　手动修改图片的读取状态 img.flags.writeable = True # 将数组改为读写模式 或者 或者 im = np.array(pil_im) 方法1 from PIL import Image Image.fromarray(np.uint8(img)) 注意img如果是uint16的矩阵而不转为uint8的话，Image.fromarray这句会报错 File "/usr/local/lib/python2.7/site-packages/PIL/Image.py", line 1884, in fromarray raise TypeError("Cannot handle this data type") TypeError: Cannot handle this data type 类似这个问题 PIL weird error after resizing image in skimage 方法2 import cv2 cv2.imwrite("output.png", out) out可以是uint16类型数据 16位深度图像转8位灰度 matlab img=imread("output.png") img1=im2uint8(img) imwrite(img1,"result.jpg") 或者python from PIL import Image import numpy as np import math img=Image.fromarray(np.uint8(img_array/float(math.pow(2,16)-1)*255)) img.save("22.png")

var a = [1,2,3,4]; var b = [3,4,5,6]; function haveSameNum(arrA,x){ for(var i in arrA){ if(arrA[i] == x) return true; } } function combine(a,b){ for(var i in a){ if(haveSameNum(b,a[i])) continue; b.push(a[i]); } return b; }

b[b.["state"]=="ohio"].index

Private Sub Command1_Click()Dim s(1 To x) As String "x就是你数组的大小了Dim st As String"假定 这个数组里 已经有值了For i = 1 To x st = st & Space(1) & s(i) & Chr(10) & Chr(13) "chr(10)与chr(13)为换行 space(1)为1个空格 如需要则写上Next iMsgBox stEnd Sub

mysql中要获得存储过程的返回值，可以增加一个out参数，用来返回。mysql中存储过程的例子：CREATEPROCEDUREaddvoucher(INuseridINT,INvoucheridINT,OUT resultINT)BEGINSELECT@endate_a:=endate,@batch_a:=batch,@c_count_a:=c_count,@isdead_a:=isdeadFROMt_voucherWHEREid=voucherid;SETautocommit=0;IFEXISTS(SELECT*FROMt_user_vouchertuv,t_vouchertvWHEREtv.id=tuv.voucheridANDtv.batch=@batch_a)THENSETresult=1;--已存在SELECTresult;ELSEIF@c_count_a>0THENIF(TO_DAYS(@endate_a)-TO_DAYS(NOW()))>0THENIF@isdead_a=1THENINSERTINTOt_user_voucher(userid,voucherid,isdead)VALUES(userid,voucherid,1);UPDATEt_voucherSETc_count=c_count-1whereid=voucherid;SETresult=0;--成功END;下面是调用并返回结果：

在foreach中循环查询数据代码量比较少，但是性能比较低，好点的解决办法是将id收集起来，用in一次性查询，但是这引发了数据结构不是我们用PHP自带的函数可以合并的，今天测试了一下：使用下面的字节写的函数可以解决从数据库中取出来的数据总是或多或少不符合我们心目中的数据结构，类似于下面的俩个数组，要形成SQL中类似于left join后两个数组合并：代码如下:$test1 = Array(0 = Array("id" = 9478137,"create_time" = 1394760724),1 = Array("id" = 9478138,"create_time" = 1394760725),2 = Array("id" = 9478138,"create_time" = 1394760725));$test2 = array(0 = array("id" = 9478137,"message" = "love you"),1 = array("id" = 9478138,"message" = "miss you"));如果要将这两个数组，类似于sql中的left join 关联起来我们用什么函数呢?额我没有找见就自己写了刚开始的时候，用的是嵌套循环：效率低下代码如下:function _mergerArray($array1, $array2, $field1, $field2 = "") {$ret = array();foreach($array1 as $key1 = $value1 ) {foreach ($array2 as $key2 = $value2) {if($value1[$field1] == $value2[$field2]) {$ret[$key1] = array_merge($value1, $value2);}}}return $ret;}改进后的办法，使用数组下标，使用两次循环：形成类似于left join的方式代码如下:$test1 = Array(0 = Array("id" = 9478137,"create_time" = 1394760724),1 = Array("id" = 9478138,"create_time" = 1394760725),2 = Array("id" = 9478138,"create_time" = 1394760725));$test2 = array(0 = array("id" = 9478137,"message" = "love you"),1 = array("id" = 9478138,"message" = "miss you"));function _mergerArray($array1, $array2, $field1, $field2 = "") {$ret = array();//使用数组下标的办法foreach ($array2 as $key = $value) {$array3[$value[$field1]] = $value;}foreach ($array1 as $key = $value) {$ret[] = array_merge($array3[$value[$field1]], $value);}return $ret;}$ret = _mergerArray($test1, $test2, "id", "id");print_r($ret);exit;打印出来结果如下：代码如下:Array([0] = Array([id] = 9478137[message] = love you[create_time] = 1394760724)[1] = Array([id] = 9478138[message] = miss you[create_time] = 1394760725)[2] = Array([id] = 9478138[message] = miss you[create_time] = 1394760725))相当于left join了吧?

你没有规定sort()用什么排序方式，我用的冒泡。没有什么注释先道个歉。不知道你要这个程序是做什么的，计算机专业还是随便玩玩，如果是专业的这种基础算法一定要掌握。#include<stdio.h>void arrayio(int a[], int n,char io);void sort(int a[],int n);void merger(int a[], int n, int b[], int m, int c[]);int main(){ int a[5],b[10],c[15]; printf("Input Array a[5]: "); arrayio(a,5,"i"); printf("Input Array b[10]: "); arrayio(b,10,"i"); sort(a,5); sort(b,10); merger(a,5,b,10,c); printf("Output Array c[15]: "); arrayio(c,15,"o"); //system("PAUSE"); return 0;}void arrayio(int a[], int n,char io){ int i; switch(io) { case "i": for(i=0;i<n;++i) scanf("%d",&a[i]); break; case "o": for(i=0;i<n;++i) printf("%d ",a[i]); printf(" "); break; default: printf("Wrong parameter. "); }}void sort(int a[],int n){ int i,j,temp; //Bubble for(i=0;i<n-1;i++) for(j=i+1;j<n;j++) { if(a[i]>a[j]) { temp=a[i]; a[i]=a[j]; a[j]=temp; } }}void merger(int a[], int n, int b[], int m, int c[]){ int i,j,k; i=j=0; for(k=0;k<m+n;k++) { if(i<n && j<m) { if(a[i]>b[j]) { c[k]=b[j]; j++; } else { c[k]=a[i]; i++; } } else if(i==n) { for(;j<m;j++) { c[k]=b[j]; k++; } } else //j==m { for(;i<n;i++) { c[k]=a[i]; k++; } } } }输入输出：Input Array a[5]:9 1 4 2 5Input Array b[10]:8 3 6 4 7 2 9 8 5 3 4Output Array c[15]:1 2 2 3 3 4 4 5 5 6 7 8 8 9 9

加个v-key试试每一个v-for循环渲染都建议绑定一个v-key，key在你这里可以是数组索引，比如说(item,index) in list ,v-key就是 :key="index",key的目的是给当前数据一个唯一标识，这样数据更新时vue就知道是哪条数据更新了移除当前行就是在每一行加个按钮，绑定上删除方法，比如说deleteData(index)，传入的参数是当前的数组索引index，然后在这个方法里获取index,再把对应数据删掉就行

Verilog 最常用的 2 种数据类型就是线网（wire）与寄存器（reg），其余类型可以理解为这两种数据类型的扩展或辅助。线网（wire）wire 类型表示硬件单元之间的物理连线，由其连接的器件输出端连续驱动。如果没有驱动元件连接到 wire 型变量，缺省值一般为 "Z"。举例如下：实例wire interrupt ;wire flag1, flag2 ;wire gnd = 1"b0 ; 线网型还有其他数据类型，包括 wand，wor，wri，triand，trior，trireg 等。这些数据类型用的频率不是很高，这里不做介绍。寄存器（reg）寄存器（reg）用来表示存储单元，它会保持数据原有的值，直到被改写。声明举例如下：实例reg clk_temp;reg flag1, flag2 ;例如在 always 块中，寄存器可能被综合成边沿触发器，在组合逻辑中可能被综合成 wire 型变量。寄存器不需要驱动源，也不一定需要时钟信号。在仿真时，寄存器的值可在任意时刻通过赋值操作进行改写。例如：实例reg rstn ;initial begin rstn = 1"b0 ; #100 ; rstn = 1"b1 ;end向量当位宽大于 1 时，wire 或 reg 即可声明为向量的形式。例如：实例reg [3:0] counter ; //声明4bit位宽的寄存器counterwire [32-1:0] gpio_data; //声明32bit位宽的线型变量gpio_datawire [8:2] addr ; //声明7bit位宽的线型变量addr，位宽范围为8:2reg [0:31] data ; //声明32bit位宽的寄存器变量data, 最高有效位为0对于上面的向量，我们可以指定某一位或若干相邻位，作为其他逻辑使用。例如：

#include<iostream>#include<string>using namespace std;struct student { int num; string name; float score[3];};void main(){ student stu[20]; char ch; ch="y"; int i=0; while(ch=="Y"||ch=="y") { cout<<" 第"<<i+1<<"个学生的信息 "; cout<<" 学号:";cin>>stu[i].num; cout<<" 姓名:";cin>>stu[i].name; int j; for(j=0;j<3;j++) { cout<<" 第"<<j+1<<"科成绩:"; cin>>stu[i].score[j]; } cout<<"继续输入(y/n) :";cin>>ch; }}

这个简单，我有现成的，私信

为什么除以四啊

推荐用qsort，4、对结构体一级排序struct stud{double data;int other;}s[100]//按照data的值从小到大将结构体排序,关于结构体内的排序关键数据data的类型可以很多种，参考上面的例子写int cmp( const void *a ,const void *b){return (*(struct stud *)a)->data > (*(struct stud *)b)->data ? 1 : -1;}qsort(s,100,sizeof(s[0]),cmp);,,直接调用好啦，qsort（stdio.h）会帮你排好

例如 s[i]（左箭头）n

　　中位数（又称中值，英语：Median），统计学中的专有名词，代表一个样本、种群或概率分布中的一个数值，其可将数值集合划分为相等的上下两部分。对于有限的数集，可以通过把所有观察值高低排序后找出正中间的一个作为中位数。如果观察值有偶数个，通常取最中间的两个数值的平均数作为中位数。　　当变量值的项数N为奇数时，处于中间位置的变量值即为中位数；当N为偶数时，中位数则为处于中间位置的2个变量值的平均数。（注意：中位数和众数不同，众数指最多的数，众数有时不止一个，而中位数只能有一个。）　　特点编辑　　1、中位数是以它在所有标志值中所处的位置确定的全体单位标志值的代表值，不受分布数列的极大或极小值影响，从而在一定程度上提高了中位数对分布数列的代表性。　　2、有些离散型变量的单项式数列，当次数分布偏态时，中位数的代表性会受到影响。　　3、趋于一串数的中间位置　　　　特点编辑　　1、中位数是以它在所有标志值中所处的位置确定的全体单位标志值的代表值，不受分布数列的极大或极小值影响，从而在一定程度上提高了中位数对分布数列的代表性。　　2、有些离散型变量的单项式数列，当次数分布偏态时，中位数的代表性会受到影响。　　3、趋于一串数的中间位置　　计算编辑　　一个数集中最多有一半的数值小于中位数，也最多有一半的数值大于中位数。如果大于和小于中位数的数值个数均少于一半，那麽数集中必有若干值等同于中位数。　　设连续随机变量X的分布函数为F(X)，那么满足条P(X≤m)=F(m)=1/2的数称为X或分布F的中位数。　　对于一组有限个数的数据来说，它们的中位数是这样的一种数：这群数据里的一半的数据比它大，而另外一半数据比它小。 计算有限个数的数据的中位数的方法是：把所有的同类数据按照大小的顺序排列。如果数据的个数是奇数，则中间那个数据就是这群数据的中位数；如果数据的个数是偶数，则中间那2个数据的算术平均值就是这群数据的中位数。　　中位数：也就是选取中间的数。一种衡量集中趋势的方法。　　要找中位数，首先需要从小到大排序，例如这组数据：23、29、20、32、23、21、33、25；　　我们将数据排序20、21、23、23、25、29、32、33；排序后发现有8个数怎么办？　　若有n个数，n为奇数，则选择第（n+1）/2个为中位数，若n为偶数，则中位数是（n/2以及n/2+1）的平均数　　此例中选择24为中位数

#include <stdio.h>#include <malloc.h>int *input(int &n){int *array;printf("input n: ");scanf("%d", &n);printf("input %d numbers: ", n);array = (int*)malloc(n * sizeof(int));int i, flag, temp;for(i = 0, flag = 0; i < n; i++, flag++){ scanf("%d", &temp); if(flag == 0) array[i] = temp; else { for(int j = 0; j < flag; j++) { if(temp < array[j]) { int t = temp; temp = array[j]; array[j] = t; } } array[flag] = temp; } }return array;}void output(int *array, int n){ for(int i = 0; i < n; i++) printf("%d ", array[i]); printf(" ");}int main(){ int size = 0; int *array = input(size); output(array, size); free(array); return 0;}

目前，面向对象开发方法的研究已日趋成熟，国际上已有不少面向对象产品出现。面向对象开发方法有Coad方法、Booch方法和OMT方法等。(1).Booch方法Booch最先描述了面向对象的软件开发方法的基础问题，指出面向对象开发是一种根本不同于传统的功能分解的设计方法。面向对象的软件分解更接近人对客观事务的理解，而功能分解只通过问题空间的转换来获得。(2).Coad方法Coad方法是1989年Coad和Yourdon提出的面向对象开发方法。该方法的主要优点是通过多年来大系统开发的经验与面向对象概念的有机结合，在对象、结构、属性和操作的认定方面，提出了一套系统的原则。该方法完成了从需求角度进一步进行类和类层次结构的认定。尽管Coad方法没有引入类和类层次结构的术语，但事实上已经在分类结构、属性、操作、消息关联等概念中体现了类和类层次结构的特征。(3).OMT方法OMT方法是1991年由James Rumbaugh等5人提出来的，其经典著作为“面向对象的建模与设计”。该方法是一种新兴的面向对象的开发方法，开发工作的基础是对真实世界的对象建模，然后围绕这些对象使用分析模型来进行独立于语言的设计，面向对象的建模和设计促进了对需求的理解，有利于开发得更清晰、更容易维护的软件系统。该方法为大多数应用领域的软件开发提供了一种实际的、高效的保证，努力寻求一种问题求解的实际方法。(4).UML(Unified Modeling Language)语言软件工程领域在1995年～1997年取得了前所未有的进展，其成果超过软件工程领域过去15年的成就总和，其中最重要的成果之一就是统一建模语言（UML)的出现。UML将是面向对象技术领域内占主导地位的标准建模语言。UML不仅统一了Booch方法、OMT方法、OOSE方法的表示方法，而且对其作了进一步的发展，最终统一为大众接受的标准建模语言。UML是一种定义良好、易于表达、功能强大且普遍适用的建模语言。它融入了软件工程领域的新思想、新方法和新技术。它的作用域不限于支持面向对象的分析与设计，还支持从需求分析开始的软件开发全过程。

IsLittleEndian;BitConverterTester BitConverterTester$ 这两次运行的结果都在预料之中,BitConverter类的 GetBytes方法以 Little-Endian顺序返回字节数组; Console: 4; + Environm...

print_r(array_count_values($arr));

程序运行后，最大、最小值，都保存到指定的存储单元了。没有显示结果，是因为，这程序里面，并没有编写显示数据的程序段。

用冒泡算法来实现，你搜一下“冒泡 java”就有很多类似的实现了。

不会吧，看什么书啊?Long[],请向自己解释为什么使用 简单类型的包装类型，而不是简单类型的本身？int[]不好吗？还有，为什么使用array？而不是其他的集合？其他的集合基本比较齐全，就算不满足需要，还有google collections, gs-collections,common.trove4j,fastutil,javolution等等当然，你非要如此，不是不能，1，你需要保证正确长度的问题，不能越界。2，每次变化长度的数组这个对象本身是不同的指针，你需要保证正确更新这个引用，以及可能还有同步问题。建议JLS和java tutorials。

我用的时候还不知道用mashalas有个笨方法，写32个int32变量进去。。。我以前是这么用的。。。

你应该写在方法里

byte short int long 这几种类型都是java中的整数类型你肯定对int比较了解，byte和int的区别是int是32位，byte是8位，表示的数字范围为：-128到+127所以第一个byte中元素都没超过范围，都以数字显示。第二个byte数组中的元素都是char类型，char类型是占16位的，一般转换为byte是由大到小，需要强制转换，但这些char并没有超出byte的范围，所以不用在打印时会将char元素转换成对应的ascii码，具体你可以去查toString的确是输出字母，但"a"是字符，不是字符串，两个完全不同的概念 字符串+primitive类型就是转换为字符型的最简单方法，例：4+"" 将数字4转换为字符串4 现在的4不再是数字，而是字符串，懂？

比如“12、34、56、78、90”。没有重复的数。

遍历遍历还是遍历

类型不匹配，方差和平均数都是float型，你两个函数的返回值都是int类型，且输出也是用的%d

最简单的方法就是先把歌手名（汉字）用php转换成拼音，然后orderby排序就可以了，有一个pinyin类，可以去网上找找看，帝国CMS里面也有，可以拷出来用。

人工产生的随机数，通常叫伪随机数。你可以自己写程序，可以网上找程序。但最方便的是用编译器自带的函数产生。c/c++ 可用函数 int rand (void); 产生一个 0 到 RAND_MAX 之间的 整数随机数，RAND_MAX 定义在 <cstdlib> 头文件中。例如：v1 = rand() % 100; // v1 范围 0 到 99v2 = rand() % 100 + 1;// v2 范围 1 到 100v3 = rand() % 30 + 1985;// v3 范围 1985 到 2014v4 = rand() % 1001 - 500; // v4 范围 -500 到 + 500为使产生的随机数系列 时时不同，可用当地时间产生一个随机数种子： srand (time(NULL));#include <stdio.h> #include <stdlib.h> #include <time.h>int main (){ int a[20],i;srand (time(NULL)); //种子for (i=0;i<20;i++) a[i] = rand() % 1001 - 500; //产生20个for (i=0;i<20;i++) printf("%d ", a[i]); // 输出这20个随机数return 0;}c++ 与 c 一样，多加一句 #include <iostream>在前头，其它一字不变即可。

也就姓钱的猪才会想到这样的题目.晕/* 完成下面的程序。该程序生成有10个整数的安全数组。 要把值放入数组中，使用put()函数，然后取出该值， 使用get()函数，put()和get()中若遇下标越界则立刻终止程序运行。 其运行结果为后面所示，请完成两个未写出的函数定义。 */ #include<iostream.h> #include <conio.h>#include <stdlib.h>int& put(int n);//put value into the array int get(int n);//obtain a value from the array int vals[10]; int error=-1; void main(){ put(0)=10;//put values into the array put(1)=20; put(9)=30; cout<<get(0)<<endl; cout<<get(1)<<endl; cout<<get(9)<<endl; put(12)=1;//out of range } int& put(int n){ if(n<0||n>9) { cout<<"range error "<<endl; exit(0); } return vals[n];//... } int get(int n){ if(n<0||n>9) { cout<<"range error "<<endl; exit(0); } return vals[n];//... } /* 运行结果要求为： 10 20 30 range error */

在vb中什么函式可以计算一个数组的下标 Lbound(a)：最小下标 Ubound(a)：最大下标 a是阵列 Ubound(a)-Lbound(a)+1为阵列的长度 vb用自定义函式求一个数组的和 Private Sub Command1_Click() Dim a(10) As Integer For i = 0 To 10 a(i) = i Next Print sum(a) End Sub Function sum(a() As Integer) As Integer Dim i As Integer Dim s As Integer s = 0 For i = LBound(a) To UBound(a) s = s + a(i) Next sum = s End Function vb怎么计算一个数组元素的和 Private Function Qsum(ByRef a() As Integer) As Double Dim n As Double n = 0 For i = LBound(a) To UBound(a) n = n + a(i) Next i Qsum = nEnd Function C语言中计算一个数组中某个值出现次数的函式? 个人觉得还是需要遍历吧，除非你先把该阵列排序，那样的话统计起来就不需要遍历整个阵列了，对于一个无规则的阵列，我想不遍历是不可能统计出来的吧。其实像这类问题，单个的计算而已的话，就没什么好担心了，主要是函式呼叫的话才会比较耽误时间，是程式炮得慢，对于这样的情况，一般可以先对其归类分组，再去统计，也就是说先对它处理好，把结果储存起来，呼叫的时候直接呼叫储存的资料而不用每次都重新去统计。设计函式，统计一个数组中下标和阵列元素值都是偶数的元素个数 #include<stdio.h> int main() {int n,i,s=0,a[100]; printf("资料个数："); scanf("%d",&n); for(i=0;i<n;i++) {scanf(("%d",&a[i]); if(a[i]%2==0)s+=a[i]; } printf("其中所有偶数的和=%d ",s); return 0; } VB函式中,如何返回一个数组 函式定义时返回型别后面加个括号，跟阵列的定义类似 PS:用你的问题百度一下就有现成的答案，以后不要这么懒 Excel中sum函式中镶嵌vlookup函式，计算阵列时，为什么只显示第一个阵列的值，而不显示求和的值。 vlookup函式返回的不是阵列型结果, 所以就算是用了阵列公式,也只能返回第一个运算结果. Excel 一个数组的最大下标可以定义为多少 查询，排序。这是演算法问题，这个max函式只是简单比较两个数的大小，不能达到你说的那种效果 asp初始化一个数组的函式是什么 q 微控制器中如何打到一个数组的下标？ unsigned char code Valcode[18] = {0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x50,0x52,0x45,0x43,0x48,0x49,0x4E}; int GetVal(unsigned int vals) { unsigned char n; for(n=0;n<18;n++); { if ( Valcode[n] - vals == 0 ) { return n; } } return 19; }

static double Average(params double[] vals) { double sum = 0; int num = vals.Length; foreach (double val in vals) { sum += val;} return sum / num; }

楼上说的对，是你属性名字弄错了，应该是timers才对这里我不明白了，直接JsonConvert.DeserializeObject<T>(json)不就行了？中间写的代码什么意思？还有，序列化不用JsonConvert.SerializeObject吗？为什么又用JavaScriptSerializer呢？Json的module不必手动输入，你用编辑→选择性粘贴→将JSON粘贴为类这样还可以保证你的对象正确，不会有null的问题具体可以看我之前的回答：c#如何获得返回json数组中的数组

常见的勾股数及几种通式有：（1)（3,4,5），（6,8,10）。3n,4n,5n (n是正整数）。（2)（5,12,13），（7,24,25），（9,40,41）。2n＋1,2n^2＋2n,2n^2＋2n＋1 (n是正整数）。（3) (8,15,17),(12,35,37)。2^2*(n＋1),^2－1,^2＋1 (n是正整数）。（4)m^2－n^2,2mn,m^2＋n^2 (m、n均是正整数，m>n)。青朱出入图：青朱出入图，是东汉末年数学家刘徽根据“割补术”运用数形关系证明勾股定理的几何证明法，特色鲜明、通俗易懂。刘徽描述此图，“勾自乘为朱方，股自乘为青方，令出入相补，各从其类，因就其余不动也，合成弦方之幂。开方除之，即弦也。”其大意为，一个任意直角三角形，以勾宽作红色正方形即朱方，以股长作青色正方形即青方。

Object[][] arr = new Object[2][2];上面定义了一个Object类型的2维数组，其中第一维长度是2，第二维定义的长度也是2。补充：Object[][]：Object表示数组中类型是Object，两个[]表示是二维数组arr:表示变量，该变量是二维数组new:分配二维数组对象Object[2][2]:表示第一维长度是2，第二维定义的长度是2

理论上绝对是可以的。不过要加上新的属性可能增加存储空间（如多维数组，或者像JAVA那样的类数组）。 就像树可以线索化（而且有多种线索化都是用链表实现的），也可以按层输出这个可以看成数组，但是为了进行确定可能需要额外的空间来实现你的结

用的是JAVA，但是C语言和JAVA相似度很高，思路是一致的。这种要利用锚定法，简要来说就是先定好两个数，然后再从头数累加到尾数就可以int k=0,anchor=0; int a[]= {1,4,5,6}; int b[]=new int [a.length*(a.length-1)/2];/*对于n个数按题目方式求和，容易知道是n-1+n-2+...1个，即等差数列求和**/ for(int i=0;i<b.length;i++)b[i]=0;/*先将b全部初始化为0，这样才能后续累加**/ for(int i=0;i<a.length-1;i++) { for(int j=i+1;j<a.length;j++,k++)/*定好a[i]和a[j]两个数，然后利用anchor初始从i出发累加到j即可**/ { anchor=i;/*每次j移动，anchor都必须回到原i值**/ while(anchor!=j+1) { b[k]+=a[anchor++]; } } }

$scope.thead应该也是个数组吧var table_head = new Array("服务商", "开户","写卡","续期","激活","入库","挂失","解挂","补卡","售卡","激活比例");for(var i=0;len=$scope.thead.length,i<len;i++){ $scope.thead[i]=table_head[i];}

你这编程也是牛逼了，类名直接上中文

ind = find(X)ind = find(X, k)ind = find(X, k, "first")ind = find(X, k, "last")[row,col] = find(X, ...)————用了这个[row,col,v] = find(X, ...)Descriptionind = find(X) locates allnonzero elements of array X, and returns the ofthose elements in vector ind. If X isa row vector, then ind is a row vector; otherwise, ind isa column vector. If X contains no nonzero elementsor is an empty array, then ind is an empty array.ind = find(X, k) or ind = find(X, k, "first") returns at mostthe first k indices corresponding to the nonzeroentries of X. k must be a positiveinteger, but it can be of any numeric data type.ind = find(X, k, "last") returnsat most the last k indices corresponding to thenonzero entries of X.[row,col] = find(X, ...) returnsthe row and column indices of the nonzero entries in the matrix X.This syntax is especially useful when working with sparse matrices.If X is an N-dimensional array with N > 2, col containslinear indices for the columns. For example, for a 5-by-7-by-3 array X witha nonzero element at X(4,2,3), find returns4 in row and 16 in col. Thatis, (7 columns in page 1) + (7 columns in page 2) + (2 columns inpage 3) = 16.[row,col,v] = find(X, ...) returnsa column or row vector v of the nonzero entriesin X, as well as row and column indices. If X isa logical expression, then v is a logical array.Output v contains the non-zero elements of thelogical array obtained by evaluating the expression X

用记事本编辑*.vbs 写入以下代码，可双击文件运行。dim arr(3)arr(0)="a"arr(1)="b"arr(2)="c"arr(3)="d"for each i in arrmsgbox""&i&""next

JS中的数组是弱类型的可以放任何类型（对象、基本类型），但是如果数组中放的是对象类型，传递到后台是显示的只能是对象字符串--[object Object],原因如下： 在后台接收的时候，只能用request来接收，request.getParameterValues()方法返回的是一个String[],所以，应该是在前台传输的时候调用了对象的toString()方法,那么如果依然想传递对象怎么办？但是可以使用JSON字符串来实现，在后台把JSON字符串解析成JAVA对象。 也许，你要说如果是复合对象怎么办，比如如下： public class Person { private String username; private String password; private Address addr; }Person对象里有个Address类型的addr属性，没关系，任何对象最终用到的属性值都是基本数据类型，只需要使用对应的包装类型parseInt、或者parseXXX解析即可。 实现： OK，原理就是这么个。先看JS如何写： var as = []; var temp = []; for ( var int = 0; int < 5; int++) { temp.push("{"k":"); temp.push(int); temp.push(","v":"); temp.push(int); temp.push("}"); as.push(temp.join("")); } //Jquery中的方法，具体参考Jquery API $.post( "servlet/AjaxServlet?m=putWarningRule",{"aa":as} );最终拼成的串就是如下样式，（只作举例） {"k":0,"v":0}后台接收，不讨论任何框架，只需要HttpServletRequest即可 String[] jsonArr = request.getParameterValues("aa[]");有一点需要注意，在js中传参的时候参数名叫"aa"，而在后台接收的时候却是"aa[]"，这里应该是Jquery做了转换，所以最好的方式就是在JS中就改为"aa[]"，之所以这里没有写"[]"是为了说明问题。可以使用如下方式打印request中的所有参数 Enumeration<String> names = request.getParameterNames(); while (names.hasMoreElements()) { String string = (String) names.nextElement(); System.out.println(string); }OK，至此为止，已经接收完毕，剩下的就是如何将一个JSON字符串转成一个POJO了。/** * 将对象转换为JSON格式的字符串 * @param obj * @return 返回JSON字符串 */ public static String toJSONAsString(Object obj){ try { return JSONMapper.toJSON(obj).render(false); } catch (MapperException e) { e.printStackTrace(); } return null; } @SuppressWarnings("unchecked") public static <T> T jsonToObject(String jsonStr, Class<T> targetClass) throws TokenStreamException, RecognitionException, MapperException{ JSONValue jv = new JSONParser(new StringReader(jsonStr)).nextValue(); return (T) JSONMapper.toJava(jv,targetClass); } //test public static void main(String[] args) throws Exception { Person p = new Person(); p.setK("a"); p.setV("v"); String json = toJSONAsString(p); Person np = jsonToObject(json,Person.class); System.out.println(np.getK()+"=="+np.getV()); }request取到值后，遍历数组，挨个转换 Person p = JSONUtils.jsonToObject(jsonArr[0], Person.class);Person类如下： public class Person { private String k; private String v; public String getK() { return k; } public void setK(String k) { this.k = k; } public String getV() { return v; } public void setV(String v) { this.v = v; } }有时候会出现问题，后台接收不到该值。解决办法： 设置jQuery.ajax的tradional属性$.ajax({ url: "/xxx", type: "GET", data: { "boxIds": boxIds, "boxType": 0, "time": new Date().getTime() }, traditional: true,//这里设置为true success: function(data) { //do sth... }});请求参数2这次参数不带”[]”了，并且后台可以成功接收到该数组。