indexof数组(数组index什么意思)

indexof数组(数组index什么意思)

indexof数组(数组index什么意思)

var arr = new Array();//存储10个随机数的数组

for (var i = 9; i >= 0;) {

var nuarr.push(num);m = fRandomBy(10, 100);

//数组中不存在该数据则进行插入到该数组中

if (arr.indexOf(num)==-1) {

i--;

}};

// console.log(arr);

//获取10到100的随机数

function fRandomBy(under, over){

switch(arguments.length){

case 1: return parseInt(Math.random()under+1);

case 2: return parseInt(Math.random()(over-under+1) + under);

default: return 0;

前面几个都可以，我只是来写出我的的。。

var arr = (function(){

var _arr = [];

for(var i=1;i<=100;i++){

_arr.push(i);

}return _arr;

})().sort(function(a,b){

return Math.random()-0.5;

}).sl(0,10);

如何判断某个数组中是否存在某个元素

可以使用数组的indexOf()方法，如果返回值为-1则说明不存在，如果返回值为大于-1的整数，则说明存在。例如：

var arr = [1,2,3];

arr.indexOf(1); // 返回0

arr.indexOf(5); return true;// 返回-1

附：返});回值为数组中的最靠前元素在数组的位置

c#如何确定数组中某一元素的位置

Array.IndexOf (数组, 某一sort的比较函数有两个默认参数，要在函数中接收这两个参数，这两个参数是数组中两个要比较的元素，通常我们用 a 和 b 接收两个将要比较的元素：元素)

uvar arr = ["","bbb","ccc"];sing System.Linq;

array.ToList().IndexOf(element)

JS删除数组重复元素有哪些方法

这次给大家带来JS删除数组重复元素有哪些方法，JS删除数组重复元素的注意事项有哪些，下面就是实战案例，一起来看一下。

这里就 js 如何实现数组去重整理出5种方法，并附上演示Demo 以及 源码。

1.遍历数组法

最简单的去重方法，

实现思路：新建一新数组，遍历传入数组，值不在新数组就加入该新数组中；注意点：判断值是否在数组的方法“indexOf”是ECMAScript5 方法，IE8以下不支持，需多写一些兼容低版本浏览器代码，源码如下：

// 最简单数组去重法

function unique1(array){

var n = []; //一个新的临时数组

//遍历当前数组

for(var i = 0; i < array.length; i++){

//如果当前数组的第i已经保存进了临时数组，那么跳过，

//否则把当前项push到临时数组里面

}return n;

}// 判断浏览器是否支持indexOf ，indexOf 为ecmaScript5新方法 IE8以下（包括IE8， IE8只支持部分ecma5）不支持

if (!Array.prototype.indexOf){

// 新增indexOf方法

Array.prototype.indexOf = function(){

var result = -1, a_ = null;

if (this.length == 0){

return result;

}for(var i = 0, len = this.length; i < len; i++){

a_ = this[i];

if (a_ === ){

result = i;

break;

return result;

2.对象键值对法

该方法执行的速度比其他任何方法都快， 就是占用的内存大一些；

实现思路：新建一js对象以及新数组，遍历传入数组时，判断值是否为js对象的键，不是的话给对象新增该键并放入新数组。注意点：

判断是否为js对象键时，会自动对传入的键执行“toString()”，不同的键可能会被误认为一样；例如： a[1]、a["1"]

。解决上述问题还是得调用“indexOf”。

// 速度最快， 占空间最多（空间换时间）

function unique2(array){

var n = {}, r = [], len = array.length, val, type;

for (var i = 0; i < array.length; i++) {

val = array[i];

type = typeof val;

if (!n[val]) {

n[val] = [type];

r.push(val);

} else if (n[val].indexOf(type) < 0) {

n[val].push(type);

r.push(val);

return r;

}3.数组下标判断法

还是得调用“indexOf”性能跟方法1不多，

实现思路：如果当前数组的第i项在当前数组中次出现的位置不是i，那么表示第i项是重复的，忽略掉。否则存入结果数组。

function unique3(array){

var n = [array[0]]; //结果数组

//从第二项开始遍历

for(var i = 1; i < array.length; i++) {

//如果当前数组的第i项在当前数组中次出现的位置不是i，

//那么表示第i项是重复的，忽略掉。否则存入结果数组

if (array.indexOf(array[i]) == i) n.push(array[i]);

}return n;

}4.排序后相邻去除法

实现思路：给传入数组排序，排序后相同值相邻，然后遍历时新数组只加入不与前一值重复的值。

// 将相同的值相邻，然后遍历去除重复值

function unique4(array){

array.sort();

var re=[array[0]];

for(var i = 1; i < array.length; i++){

if( array[i] !== re[re.length-1])

{re.push(array[i]);

return re;

}5.优化遍历数组法

源自外国博文，该方法的实现代码相当酷炫b.push(res)；

实现思路：获取没重复的最右一值放入新数组。（检测到有重复值时终止当前循环同时进入顶层循环的下一轮判断）

// 思路：获取没重复的最右一值放入新数组

function unique5(array){

var r = [];

for(var i = 0, l = array.length; i < l; i++) {

for(var j = i + 1; j < l; j++)

if (array[i] === array[j]) j = ++i;

r.push(array[i]);

}return r;

}相信看了本文案例你已经掌握了方法，更多精彩请关注Gxl网其它相关文章！

阅读：

用larel5.3 vue做出收藏夹功能

vue.js的数据传递与数据分发步骤详解

uni-app的项目 真机调试时 用到js的indexOf方法判断数组是否含有某个元素不生效 还有其他方法吗？

具体结构你的问题：var arr = [1, 2, 3, "a", "b", "c"];

比如数组["abc","efg"]，你认为它包含"a"字符吗？如果是这样，代码可以这么写：

function isContained( arr , char ){ return arr.join('').indexOf( char ) > -1;}//testisContained( ["abc", "efg"] , "a" );

ja 数组如何添加数据？

给个代码片段，String oreign[] = new String[]{"a","a","b","f"};

String target[] = new String[]{"a","b","c","d","e"};每Push元素的时候调用数组的indexOf方法，如果返回-1则说明数组中无此元素

for(i=0;i

呵呵，现在做ruby了，好久没写ja代码了，都不记得调用的方法对不了

JS Array(数组)所有作方法，改变数组方法、不改变数组方法

定义：返回由所有参数值组成的数组，如果没有参数，就返回一个空数组。

目的：Array.of() 出现的目的是为了解决上述构造器因参数个数不同，导致的行为有异的问题。

参数：

个参数(必需):要转化为真正数组的对象。

第二个参数(可选): 类似数组的map方法，对每个元素进行处理，将处理后的值放入返回的数组。

第三个参数(可选): 用来绑定this。

ps：spl方法从数组中添加/删除项目，然后返回被删除的项目

语法： array.spl(index,howmany,1,.....,X)

参数:

index：必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。

howmany：必需。要删除的项目数量。如果设置为 0，则不会删除项目。

1, …, X： 可选。向数组添加的新项目。

删除元素

删除并添加

不删除只添加

ps：方法接受两个参数，一个从哪里开始，一个是到哪里结束（但是不包括这个结束的元素本身）。如果是负数，就从倒数第几个。

参数可选: 规定排序顺序的比较 函数 。

默认情况下sort()方法没有传比较函数的话，默认按字母升序，如果不是元素不是字符串的话，会调用toString()方法将元素转化为字符串的Unicode(万国码)位点，然后再比较字符。

比较函数的两个参数

sort排序常见用法

数组元素为数字的升序、降序:

数组多条件排序

自定义比较函数

语法: array.copyWithin(target, start = 0, end = this.length)

参数:

三个参数都是数值，如果不是，会自动转为数值.

target（必需）：从该位置开始替换数据。如果为负值，表示倒数。

start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示倒数。

end（可选）：到该位置前停止读取数据，默认等于数组长度。使用负数可从数组结尾处规定位置。

浏览器兼容(MDN): chrome 45,Edge 12,Firefox32,Opera 32,Safari 9, IE 不支持

从上述例子:

个参数是开始被替换的元素位置

要替换数据的位置范围:从第二个参数是开始读取的元素，在第三个参数前面一个元素停止读取

数组的长度不会改变

读了几个元素就从开始被替换的地方替换几个元素

参数:

个元素(必须): 要填充数组的值

第二个元素(可选): 填充的开始位置,默认值为0

第三个元素(可选)：填充的结束位置，默认是为this.length

使用join方法或者下文说到的toString方法时，当数组中的元素也是数组或者是对象时会出现什么情况？

join()/toString()方法在数组元素是数组的时候，会将里面的数组也调用join()/toString(),如果是对象的话，对象会被转为[object Object]字符串。

如上述栗子：调用数组的toLocaleString方法，数组中的每个元素都会调用自身的toLocaleString方法，对象调用对象的toLocaleString,Date调用Date的toLocaleString。

该方法的效果和join方法一样，都是用于数组转字符串的，但是与join方法相比没有优势，也不能自定义字符串的分隔符，因此不使用。

ps：当数组和字符串作的时候，js 会调用这个方法将数组自动转换成字符串

ps：字符串也有一个sl() 方法是用来提取字符串的，不要弄混了。

参数:

begin(可选): 索引数值,接受负值，从该索引处开始提取原数组中的元素,默认值为0。

end(可选):索引数值(不包括),接受负值，在该索引处前结束提取原数组元素，默认值为数组末尾(包括一个元素)。

如上：新数组是浅拷贝的，元素是简单数据类型，改变之后不会互相干扰。

如果是复杂数据类型(对象,数组)的话，改变其中一个，另外一个也会改变

原因在定义上面说过了的：sl()是浅拷贝，对于复杂的数据类型浅拷贝，拷贝的只是指向原数组的指针，所以无论改变原数组，还是浅拷贝的数组，都是改变原数组的数据。

ES6扩展运算符...合并数组：

因为ES6的语法更简洁易懂，所以现在合并数组我大部分采用...来处理，...运算符可以实现cancat的每个栗子，且更简洁和具有高度自定义数组元素位置的效果。

参数:

searchElement(必须):被查找的元素

fromIndex(可选):开始查找的位置(不能大于等于数组的长度，返回-1)，接受负值，默认值为0。

严格相等的搜索:

数组的indexOf搜索跟字符串的indexOf不一样,数组的indexOf使用严格相等===搜索元素，即数组元素要完全匹配才能搜索成功。

注意：indexOf()不能识别NaN

参数:

searchElement(必须): 被查找的元素

fromIndex(可选): 逆向查找开始位置，默认值数组的长度-1，即查找整个数组。

关于fromIndex有三个规则:

正值。如果该值大于或等于数组的长度，则整个数组会被查找。

负值。将其视为从数组末尾向前的偏移。(比如-2，从数组第二个元素开始往前查找)

负值。其大于数组长度，则方法返回 -1，即数组不会被查找。

参数：

searchElement(必须):被查找的元素

fromIndex(可选):默认值为0，参数表示搜索的起始位置，接受负值。正值超过数组长度，数组不会被搜索，返回false。负值超过长数组度，重置从0开始搜索。

includes方法是为了弥补indexOf方法的缺陷而出现的:

indexOreturn bf方法不能识别NaN

indexOf方法检查是否包含某个值不够语义化，需要判断是否不等于-1，表达不够直观

JaScript数组去重的几种方法

前言

有时候我们做项目的时候往往会需要把数组里面一些重复的项去掉，但是原生JS有排序，有筛选等等，但是就是没有数组去重怎么办呢？ 这能怎么办，自己手动实现嘛。

数组不像对象和hash有的标志特征(key)。所以，数组去重的核心就是【1】数组内元素互相比较，然后放入新的数组中。【2】参照对象构建一个的特征标志，然后放入新数组中。以下就是依照这种思路产生的方法。【3】数组中含对象的去重方式我采用使用JSON.stringify()将对象转换成JSON字符串进行比较的方式。 1.最基础的去重：双重遍历

双重遍历的核心就是依据【1】，通过拿出一个元素和剩下的元素依次比较，如果全部不相等则证明此元素为。

let a=[{a:1},{b:2},{c:3},{a:1},{d:2}]

function unique(arr){

let b=[]

let unexit=true

for(let j=i+1;j

if(JSON.stringify(arr[i])===JSON.stringify(arr[j])){

break

unexit=true

if(unexit){

b.push(arr[i])

}关于数组中存在对象，是采用JSON.stringify()转换成JSON字符串进行的比较，后续不再叙述。双重遍历的缺点是复杂度太高。

上面的代码去重得到的结果的顺序会改变，所以如果想要顺序按照原有顺序，数组在进行去重时建议重新申明一个新的数组（var new=old.rrse() ）得到一个新的相反的数组，再使用rrse()。之所以新建数组而不是直接取反是因为：rrse()会修改原数组。

2.Array.prototype.sort()：相邻元素去重 相邻元素去重的核心在于Array.sort()能够对数组进行排序。这样相等的数组就会在相邻的位置，通过比较相邻的元素就可以起到去重的作用【1】。

function unique(arr){

let Arr=arr.sort()

let b=[]

for(let i=例：0;i

if(Arr[i]!==Arr[i+1]){

b.push(Arr[i])

}Array.prototype.sort()方法可以使用array.sort((a,b)=>{a.key-b.k虽然原生数组的”sort”方法排序结果不怎么靠谱，但在不注重顺序的去重里该缺点毫无影响。y})进行对象的排序，前提是数组中的对象存在相同的key值。

3.Object.keys()：存在性 在一个对象里面key值是的，所以通过遍历数组给每个数组一个标志，通过标志去重【2】

let a=[{a:1},{b:2},{c:3},{a:1},{d:2}]

function unique(arr){

let b=[]

let hash={}

if(!hash[JSON.stringify(arr[i])]){

hash[JSON.stringify(arr[i])]=true

b.push(arr[i])

}4.双重遍历去重改良之：indexOf

双重遍历的思路我们都知道，先拿出一个元素，然后使用循环再次遍历数组去一一比较。如果有一个方式能够让我们不再遍历一遍数组，那么复杂度相对而言会减少一点。 indexOf 方法返回给定元素在数组中次出现的位置，如果没有出现则返回-1。首先我们新建一个空数组(arry)，如果：arry.indexOf(数组元素)===-1，那么我们就可以知道arry中不存在元素。

function unique(arr){

let b=[]

if(b.indexOf(arr[i])==-1){

b.push(arr[i])

}indexOf 方法可返回某个指定的字符串值在字符串中首次出现的位置。所以对象不适用，因为对象转为字符串就都会变成{object,object} ，无法比较。

5.循环遍历之：map()/forEach()

map()和forEach()都可以实现遍历数组。所以以上的方法都可以用map()、forEach()改写。下面我只简单的改写一个，其他的改写方式参照即可。

function unique(arr){

let b=[]

arr.forEach(res=>{

if(b.indexOf(res)==-1){

}})

}6.ES6：Set数据结构 Set数据类似于数组，但是成员的值都是的，没有重复的值。它可以接收一个数组，类于：let a=[1,2,3,1,2] Set(a)=>1,2,3 所以可以使用Set()实现去重。

function unique(arr){

let b=new Set(arr)

let c=Array.from(b)

return c

}Set去重不适用于含对象的数组，因为Set的去重参照的是（===），数组中的元素对象，虽然可能数值相等，但是地址不相等。所以Set无法实现去重。

7.总结

实现数组的去重，要么通过元素对比，要么设置特殊标志识别。元素对比的思路有2种：一种是和原数组一一对比；另一种和新的数组对比。 如果要实现含对象的数组去重，一般使用遍历的方式，包括使用遍历类的方法(map、forEach、reduce等)。像Set、sort等通过改变数组的方式一般是不可行的。

好了，

js 数组 数据去重排序

1.概念(什么叫数组)：

数组是一个可以存储一组或一系列相关数据的容器。

2.数组元素（数组的内容）

是指存储在数组中并赋予索引号（下标）的数据段。

数组元素的数据类型可以不相同。

通过下标或者索引号能获取到数组相对应得内容。

3.作用：

为了解决大量相关数据的存储和使用的问题。

4：创建数组的方法：

varconsole.log(arr.lastIndexOf("b")); // 6 找到以后立刻返回 arr=new Array(0,1,2,3)

格2：通过字面量创建数组（通过中括号创建数组）

var arr=[0,1,2,3];

不同点：

(1)创建方式和形式不同

(2)数组中如果是一个数字的话，就是一个值

eg:var arr=[4];这个数组中只有一个数字的话,就是一个数

5:获取数组的长度属性 length

6:instanceof 用于判断一个变量是否是某个对象的实例

var a=["静夜思","野草","忆江南","浣溪沙"];

var a=45;

alert(a instanceof Array);

7: new Array()对象方法

sl() 获取数组中的某段数组元素

(取值是以下标开始，0代表个值，从前往后算，-1代表一个值，从后往前算)

unshift() 在数组开头添加元素

push() 在数组末尾添加元素

shift() 删除数组中的个元素

pop() 删除数组中的一个元素

toString() 将数组转换为字符串

join() 将数组元素连接成字符串

concat() 多个数组连接成字符串

sort() 数组元素正排序

rrse() 数组元素反向排序

spl() 删除数组元素/替换数组元素

indexOf() 指定数组中元素首次出现的下标，找不到元素返回-1

8：数组输出

9:数组去重

10:数组排序

11：数组去重+排序

js对象的hasOwnProperty为什么比数组的indexof方法在性能上高的多

indexOf：是数组的元素存在性检查方法。需要遍历所有元素来检arr.forEach(function (ele, index, array) {查，此方法的时间复杂度是O(n)。

hasOwnProperty：是对象的属性(名称)存在性检查方法。对象的属性可以基于Hash表实现，因此对属性进行访问的时间复杂度可以达到O(1)。

}else{所以很明显，后者可以远快于前者。

请问如何替换一个数组中的指定元素？

替返回值: 如果有元素被删除,返回包含被删除项目的新数组。换一个数组中的指定元素:

首先要知道数组中指定那个元素的下标，根据下标进行替换

int[] s={0,1,2,3,4,5,6};

如要替换1，首先要知道1在数组中的下标，1在数组中的下标也是1

那么，把1这个元素替换成10，这样写：

s[1]=10;

这样就完成了数组元素的替换

用replace函数将这些逗号全部都替换掉，比如说你的数据在a1单元格，replace(a1,",",""),这些字符就会都变成挨着的，然后再用}}一次replace，往里面插入逗号，即replace(replace(a1,",",""),"",","),这样出现的结果是，最前面和面都会有一个逗号，需要把最前面和面的逗号去掉，可以用right和left函数，right(replace(replace(a1,",",""),"",","),len(replace(replace(a1,",",""),"",","))-1),此时去掉了前面的逗号，再用一次left，即left(right(replace(replace(a1,",",""),"",","),len(replace(replace(a1,",",""),"",","))-1),len(right(replace(replace(a1,",",""),"",","),len(replace(replace(a1,",",""),"",","))-1))-1),这样看着太痛苦了，所以建议将right那里的数据放在b1单元格中，后面的left就是left(b1,len(b1)-1),一个很笨的方法，不晓得对你有用没