JavaScript数组_引力节点Java大学整理,基础语法

JavaScript的Array能够涵盖自由数据类型,并因此索引来访问各种成分。

JS–数组

JavaScript的Array能够蕴含自由数据类型,并透过索引来访问每一种成分。
大多任何编程语言区别意直接退换数组的分寸,越界访问索引会报错。可是,JavaScript的Array却不会有其余不当。在编写代码时,不提议直接修改Array的深浅,访问索引时要力保索引不会越界。

  • 取得数组的因素个数(长度),直接访问数组的length属性

获取数组的元素个数(长度),直接访问数组的length属性
var arr = [122,'aaa', null, '1111'];
arr.length; // 4
  • 直接给Array的length赋二个新的值会促成Array大小的生成:

var arr = [122,'aaa', null, '1111'];
arr.length = 5;
arr; //  [122,'aaa', null, '1111', undefined]
arr.length = 2;
arr; //  [122,'aaa'];
  • Array能够经过索引把相应的元素修改为新的值

var arr = [122,'aaa', null, '1111'];
arr[1] = 'xx';
arr; //  [122,'xx', null, '1111'];
请注意,如果通过索引赋值时,索引超过了范围,同样会引起Array大小的变化:
arr[7] = '777'
arr; // [122,'aaa', null, '1111',undefined,undefined,undefined,'777'];
  • indexOf
    与String类似,Array也足以经过indexOf()来寻觅贰个点名的因素的岗位:

var arr = [122,'aaa', null, '1111'];
arr.indexOf(122); // 返回 0
  • slice()
    函数对应String的substring()版本,它截取Array的一对因素,然后回到二个新的Array:

var arr = [122,'aaa', null, '1111'];
arr.slice(0,2); // 返回一个数组 [122,'aaa']
arr.slice(1); // 从索引1开始到结束:['aaa', null, '1111']

如果不给slice()传递任何参数,它就会从头到尾截取所有元素。利用这一点,我们可以很容易地复制一个Array:
arr.slice() // 得到一个新的数组 和 arr 数组一样
  • push和pop
    push()向Array的结尾增多若干成分,pop()则把Array的尾声二个因素删除掉:

var arr = [1, 2];
arr.push('A', 'B'); // 返回Array新的长度: 4
arr; // [1, 2, 'A', 'B']
arr.pop(); // pop()返回'B'
arr; // [1, 2, 'A']
arr.pop(); arr.pop(); arr.pop(); // 连续pop 3次
arr; // []
arr.pop(); // 空数组继续pop不会报错,而是返回undefined
arr; // []
  • unshift()函数和shift()函数
    一经要往Array的底部加多若干元素,使用unshift()方法,shift()方法则把Array的首先个因素删掉:

var arr = [1, 2];
arr.unshift('A', 'B'); // 返回Array新的长度: 4
arr; // ['A', 'B', 1, 2]
arr.shift(); // 'A'
arr; // ['B', 1, 2]
arr.shift(); arr.shift(); arr.shift(); // 连续shift 3次
arr; // []
arr.shift(); // 空数组继续shift不会报错,而是返回undefined
arr; // []
  • sort()函数
    sort()能够对这几天Array进行排序

  • reverse
    reverse()把全路Array的因素给掉个个,也正是反转:

var arr = [1, 2];
arr.reverse(); // [2,1]
  • splice()函数
    splice()方法是修改Array的“万能格局”,它能够从钦点的目录开端删除若干元素,然后再从该地点增添若干因素:

var arr = ['a', 'b', 'c, 'd', 'e', 'f'];
// 从索引2开始删除3个元素,然后再添加两个元素:
arr.splice(2, 3, 'x', 'y'); // 返回删除的元素 ['c', 'd', 'e']
arr; // ['a', 'b', 'x', 'y', 'f']
// 只删除,不添加:
arr.splice(2, 2); // ['x', 'y']
arr; // ['a', 'b', 'f']
// 只添加,不删除:
arr.splice(2, 0, 'x', 'y'); // 返回[],因为没有删除任何元素
arr; // ['a', 'b', 'x', 'y', 'f']
  • concat()函数
    concat()方法把近些日子的Array和另一个Array连接起来,并赶回多少个新的Array:

var a = [1,2];
var b = [3,4];
var c = a.concat(b); // [1,2,3,4];
concat()方法并没有修改当前Array,而是返回了一个新的Array。
  • join()函数
    join()方法是三个十一分实用的章程,它把当下Array的每一种成分都用内定的字符串连接起来,然后重临连接后的字符串:

var arr = ['a','b','c'];
var string = arr.jion('-');
string; // a-b-c;
  • 多维数组
    假定数组的某部元素又是一个Array,则足以形成多维数组

JavaScript的Array能够涵盖自由数据类型,并由此索引来访问每一个成分。

要拿走Array的长度,直接待上访问length属性:

length属性

要博得Array的长度,直接待上访问length属性,直接给Array的length赋三个新的值会变成Array大小的变通:

var arr = [1, 2, 3];
arr.length; // 3
arr.length = 6;
arr; // arr变为[1, 2, 3, undefined, undefined, undefined]
arr.length = 2;
arr; // arr变为[1, 2]

Array可以因而索引把相应的因素修改为新的值(上一节的字符串不得以),因而,对Array的目录进行赋值会直接修改那些Array:

var arr = ['A', 'B', 'C'];
arr[1] = 99;
arr; // arr现在变为['A', 99, 'C']
var arr = [1, 2, 3];
arr[5] = 'x';
arr; // arr变为[1, 2, 3, undefined, undefined, 'x']
var arr = [1, 2, 3.14, 'Hello', null, true];
arr.length; // 6
indexOf

与String类似,Array也得以透过indexOf()来搜索叁个钦赐的成分的职位:

var arr = [10, 20, '30', 'xyz'];
arr.indexOf(10); // 元素10的索引为0
arr.indexOf(20); // 元素20的索引为1
arr.indexOf(30); // 元素30没有找到,返回-1
arr.indexOf('30'); // 元素'30'的索引为2
注意了,数字30和字符串'30'是不同的元素。

请留心,直接给Array的length赋叁个新的值会形成Array大小的扭转:

slice

slice()便是对应String的substring()版本

var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
arr.slice(0, 3); // 从索引0开始,到索引3结束,但不包括索引3: ['A', 'B', 'C']
arr.slice(3); // 从索引3开始到结束: ['D', 'E', 'F', 'G']

注意到slice()的起止参数包括开始索引,不包括结束索引。

如果不给slice()传递任何参数,它就社长久截取全数因素。利用那或多或少,大家得以很轻便地复制一个Array

var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
var aCopy = arr.slice();
aCopy; // ['A', 'B', 'C', 'D', 'E', 'F', 'G']
aCopy === arr; // false
var arr = [1, 2, 3];
arr.length; // 3
arr.length = 6;
arr; // arr变为[1, 2, 3, undefined, undefined, undefined]
arr.length = 2;
arr; // arr变为[1, 2]
Array可以通过索引把对应的元素修改为新的值,因此,对Array的索引进行赋值会直接修改这个Array:
var arr = ['A', 'B', 'C'];
arr[1] = 99;
arr; // arr现在变为['A', 99, 'C']
push和pop

push()向Array的尾声加多若干因素,pop()则把Array的最终八个要素删除掉:

var arr = [1, 2];
arr.push('A', 'B'); // 返回Array新的长度: 4
arr; // [1, 2, 'A', 'B']
arr.pop(); // pop()返回'B'
arr; // [1, 2, 'A']
arr.pop(); arr.pop(); arr.pop(); // 连续pop 3次
arr; // []
arr.pop(); // 空数组继续pop不会报错,而是返回undefined
arr; // []

请小心,倘若经过索引赋值时,索引超过了限制,一样会唤起Array大小的变化:

unshift和shift

假设要往Array的头顶增加若干要素,使用unshift()方法,shift()方法则把Array的第二个成分删掉:

var arr = [1, 2];
arr.unshift('A', 'B'); // 返回Array新的长度: 4
arr; // ['A', 'B', 1, 2]
arr.shift(); // 'A'
arr; // ['B', 1, 2]
arr.shift(); arr.shift(); arr.shift(); // 连续shift 3次
arr; // []
arr.shift(); // 空数组继续shift不会报错,而是返回undefined
arr; // []
var arr = [1, 2, 3];
arr[5] = 'x';
arr; // arr变为[1, 2, 3, undefined, undefined, 'x']
sort

sort()能够对现阶段Array进行排序,它会直接修改当前Array的要素地方,直接调用时,遵照私下认可顺序排序:

var arr = ['B', 'C', 'A'];
arr.sort();
arr; // ['A', 'B', 'C']

当先二分之一其余编制程序语言不允许直接退换数组的尺寸,越界访问索引会报错。不过,JavaScript的Array却不会有别的错误。在编制代码时,不提议直接修改Array的轻重,访问索引时要保管索引不会越界。

reverse

reverse()把全路Array的成分给掉个个,也正是反转:

var arr = ['one', 'two', 'three'];
arr.reverse(); 
arr; // ['three', 'two', 'one']

indexOf

splice

splice()方法是修改Array的“万能方法”,它能够从钦点的目录开始删除若干成分,然后再从该职责增加若干因素:

var arr = ['Microsoft', 'Apple', 'Yahoo', 'AOL', 'Excite', 'Oracle'];
// 从索引2开始删除3个元素,然后再添加两个元素:
arr.splice(2, 3, 'Google', 'Facebook'); // 返回删除的元素 ['Yahoo', 'AOL', 'Excite']
arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']
// 只删除,不添加:
arr.splice(2, 2); // ['Google', 'Facebook']
arr; // ['Microsoft', 'Apple', 'Oracle']
// 只添加,不删除:
arr.splice(2, 0, 'Google', 'Facebook'); // 返回[],因为没有删除任何元素
arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']

与String类似,Array也能够透过indexOf()来寻觅二个钦命的要素的职分:

concat

concat()方法把当前的Array和另一个Array连接起来,并回到一个新的Array:

var arr = ['A', 'B', 'C'];
var added = arr.concat([1, 2, 3]);
added; // ['A', 'B', 'C', 1, 2, 3]
arr; // ['A', 'B', 'C']
请注意,concat()方法并没有修改当前Array,而是返回了一个新的Array。

实则,concat()方法能够接过率性个成分和Array,并且自动把Array拆开,然后全体增加到新的Array里:

var arr = ['A', 'B', 'C'];
arr.concat(1, 2, [3, 4]); // ['A', 'B', 'C', 1, 2, 3, 4]
var arr = [10, 20, '30', 'xyz'];
arr.indexOf(10); // 元素10的索引为0
arr.indexOf(20); // 元素20的索引为1
arr.indexOf(30); // 元素30没有找到,返回-1
arr.indexOf('30'); // 元素'30'的索引为2
join

join()方法是一个可怜实用的章程,它把当下Array的各样成分都用钦点的字符串连接起来,然后重临连接后的字符串:

var arr = ['A', 'B', 'C', 1, 2, 3];
arr.join('-'); // 'A-B-C-1-2-3'

如果Array的元素不是字符串,将自动转换为字符串后再连接。

留神了,数字30和字符串’30’是见仁见智的要素。

多维数组

要是数组的某部成分又是二个Array,则能够造成多维数组,比如:

var arr = [[1, 2, 3], [400, 500, 600], ‘-‘];
上述Array包罗3个因素,在那之中头四个要素本人也是Array。

slice

slice()正是对应String的substring()版本,它截取Array的局地因素,然后重回二个新的Array:

var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
arr.slice(0, 3); // 从索引0开始,到索引3结束,但不包括索引3: ['A', 'B', 'C']
arr.slice(3); // 从索引3开始到结束: ['D', 'E', 'F', 'G']

专注到slice()的起止参数包涵开头索引,不包括甘休索引。

要是不给slice()传递任何参数,它就能持久截取全部因素。利用这点,大家得以很轻巧地复制贰个Array:

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图