js之数组知识,读书笔记

壹.数组的定义(来源于Array.prototype)

字符串String

字符串用' '" "括起来的字符表示
1经字符串内部既包括'又包含"怎么做?能够用转义字符\来标识
ES陆正式新扩展了一种多行字符串的代表方法,用 ` … `表示

console.log(`Hello,
world!`);

字符串的尺寸可以透过length本性获得

var s = 'Hello, world!';
s.length; // 13

ECMAScript的每一项能够保存任何类型的数码,且数组的轻重是足以动态调度的。

字符串, JavaScript 字符串正是用” 和””括起来的字符表示。
   字符字面量, \n 换行, \t 制表, \b 退格, \r 回车, \f 进纸,
\\ 斜杠,\’ 单引号(‘) ,\” 双号(“)
          \xnn 以十陆进制代码nn 代表的一个字符(其中n为0~F)
\unnnn以十6进制代码nnnn表示的一个Unicode字符。
    字符串的特色,字符换壹旦创制就无法退换,要变有些变量保存的字符串,首先要灭绝原来的字符串,然后在用另贰个含有字符
          串填充该变量。
   常见操作:

壹.构造函数方法:

字符串方法

toUpperCase
toUpperCase()把多少个字符串全体化为大写

"aBcD".toUpperCase(); // "ABCD"

toLowerCase
oLowerCase()把二个字符串全体制改善为小写

"aBcD".toLowerCase(); // "abcd"

indexOf
indexOf()获取字符地点

var s = 'hello, world';
s.indexOf('world'); // 返回7
s.indexOf('World'); // 没有找到指定的子串,返回-1

replace
replace()字符串替换

 "abc".replace('b', 'B'); // "aBc",找到'b'替换为'B'

split
split()分割字符串位数组

 "a,bc,d,e".split(','); // [a, bc, d, e]

substr
substr(start, length)获取子字符串

 "abcdef".substr(2,3); // 从索引2开始(后面的3个子串)"cde"
"abcdef".substr(2); // 从索引2开始到结束,返回"cdef"

substring
substring(start, end)获取子字符串,重返钦命索引区间的子串

var s = 'hello, world';
s.substring(0, 5); // 从索引0开始到5(不包括5),返回'hello'
s.substring(7); // 从索引7开始到结束,返回 'world'

      var s = ‘Hello world!’;
      s.length;
   要得到字符串有个别钦赐地方的字符,使用类似Array
的下标操作,索引号从0 起始。
      var s = ‘Hello world!’;
        s[0]; // ‘H’
        s[6] // ‘ ‘
        s[7] // ‘w’
        s[12] // ‘l’
        s[13] // ‘undefined
高出范围的目录不会报错,但壹律再次来到undefined’
   须要尤其注意的是,字符串是不可变的,假如对字符串的某些索引赋值,不会有其它错误,不过,也尚无别的意义:
        var s = ‘Test’;
        s[0] = ‘X’;
js之数组知识,读书笔记。        alert(s); // s仍然为’Test’
     toUpperCase
        toUpperCase() 把3个字符串全部变为大写“
        var s=’Hello’
        s.toUpperCase(); // 返回’HELLO’
     toLowerCase
        toLowerCase()把1个字符串全体制改进为小写:
        var s = ‘Hello’;
        var lower = s.toLowerCase(); //
再次来到’hello’并赋值给变量lower
        lower; // ‘hello’
     indexOf
        indexOf()会招来钦命字符串出现的任务:
        var s = ‘hello, world’;
        s.indexOf(‘world’); // 返回7
        s.indexOf(‘World’); // 未有找到钦命的子串,重回-一
    substring
        substring()再次来到钦赐索引区间的子串:
        var s = ‘hello, world’
        s.substring(0, 5); //
从索引0开始到5(不包括5),返回’hello’
        s.substring(七); // 从索引7初始到结束,再次回到’world’

  (一)var
arr = new Array();//未有参数等价于 var arr = [];

数组Array

Array能够涵盖自由数据类型,并透过索引来访问各样元素。
要获取Array的长短,直接待上访问length属性

var arr = [1, 2, 3.14, 'Hello', null, true];
arr.length; // 6

因而索引把相应的成分修改为新的值

var arr = ['A', 'B', 'C'];
arr[1] = 99;
arr; // arr现在变为['A', 99, 'C']

indexOf
与String类似,Array也得以因此indexOf()来查找3个钦点的成分的职位

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

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()传递任何参数,它就能持久截取全部因素。利用那或多或少,大家得以很轻便地复制3个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

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进行排序,它会一直改变当前Array的因素位置,间接调用时,根据私下认可顺序排序

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

reverse
reverse()把方方面面Array的要素给掉个个,也正是反转

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

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']```
**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]“`

join
join()方法是二个13分实用的措施,它把近日Array的各样成分都用钦赐的字符串连接起来,然后回来连接后的字符串

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

如果Array的元素不是字符串,将自动转换为字符串后再连接。多维数组如果数组的某个元素又是一个Array,则可以形成多维数组,例如:

var arr = [[1, 2, 3], [400, 500, 600], ‘-‘];
arr.join(‘#’); //’1,2,3#400,500,600#-‘

练习1:如何通过索引取到500这个值

var arr = [[1, 2, 3], [400, 500, 600]js之数组知识,读书笔记。, ‘-‘];
console.log(arr[1][1]);

练习2:在新生欢迎会上,你已经拿到了新同学的名单,请排序后显示:欢迎XXX,XXX,XXX和XXX同学!

var arr = [‘小明’, ‘小红’, ‘大军’, ‘阿黄’];
console.log(‘欢迎’+arr.slice(0,arr.length-1)+’和’+arr[arr.length-1]+’同学!’);“`

  • 成立数组的大旨办法
  • 采用Array构造函数
    var colors=new Array(“red”,”blue”,”black”);
    alert(colors);//red,blue,black
    var colors=new Array(3);
    alert(colors.length);//3
    能够透过为array构造函数增加任性数量的数组成分,当构造函数的参数只为3个时,那么是为了标明该数组的要素个数。
  • 利用数组字面量表示法
    var colors=[‘red’,’blue’,’black’];
  • Array的属性
    length该属性代表该数组壹共包括多少个数组成分,然则该属性却不是只读的,大家能够经过设置他的值来调治数组的深浅。当设置数组的长短小于当前长度时,则会暗中同意裁剪掉前面多余的因素。当设置的尺寸当先当前因素的数码时,那么多出去的成分则会自行被私下认可类型为undefined。
  • 检查评定数组对象
    以此在此之前就有写过,利用入眼字instanceof来质量评定某些对象实例是或不是是数组的实例。
    var colors=[‘red’,’blue’,’black’];
    alert(colors instanceof Array);//true
  • 转变方法
    已知全部目的都有着toLocaleString() toString()
    valueOf()方法,调用数组的toString()措施,会回来由数组中的各类值的字符串模式拼接而成的贰个已逗号分隔字的字符串。可是valueOf()办法还回来的是数组。
    当大家一向用alert去输出一个数组时,会被暗中认可的已toString的情势转化数组。
  • join
    能够选用分歧的相间符来营造那些字符串,然后回到包括全数项的字符串。
    var colors=[‘red’,’blue’,’black’];
    alert(colors.join(‘|’));//red||blue||black
  • 栈方法:LIFO(后进先出)
    • push()
      还行放肆数量的参数,并把他们1壹加多到数组末尾,并重临修改后数组的尺寸。
      var colors=[‘red’,’blue’,’black’];
      colors.push(‘yellow’,’pink’);
      alert(colors.push());//5
      alert(colors.join(‘|’));//red||blue||black||yellow||pink
    • pop()
      从数组的尾声移除最终一项,裁减数组的length,然后回到移除的项。
      var colors=[‘red’,’blue’,’black’];
      colors.push(‘yellow’,’pink’);
      colors.pop();
      alert(colors.pop());//yellow
      alert(colors.join(‘|’));//red||blue||black||yellow
  • 队列方法:FIFO(先进先出)
    区分于栈方法,队列方法是从队列的前端移除项。方法shift()是力所能致移除数组中的第三个项。
  • shift()重回移除项
    var colors=[‘red’,’blue’,’black’];
    colors.shift();
    alert(colors);//blue,black
  • unshift()那几个方法是从数组的前端增添项 ,再次来到数首席营业官度值。
    var colors=[‘red’,’blue’,’black’];
    colors.unshift(‘white’);//white,red,blue,black
  • 重排序
  • reverse()方法会反转数组项的相继
    var letter=[‘a’,’b’,’c’,’d’,’e’];
    letter.reverse();
    alert(letter);//e,d,v,b,a
  • sort()方法按升序排列数组项,即最想的值位于最前边,最大的值排在最后边,sort()方法相比较的是字符串。不过对于数组项为数值,那么排序也会先将数组转化为字符串,然后再排序,可是如此排序的结果会不适合逻辑。
    var letter=[‘d’,’b’,’e’,’a’,’c’];
    letter.sort();
    alert(letter);//a,b,c,d,e
    【问题】
    var letter=[0,1,5,10,15];
    letter.sort();
    alert(letter);//0,1,10,15,5
    【解决方案】
    sort方法会接受贰个相比较函数作为参数,这么些比较函数接收三个参数,并且钦命哪个值位于哪个值的眼下。
    var letter=[0,1,5,10,15];
    letter.sort(compare);
    alert(letter);//0,1,5,10,15
    function compare(value1,value2){
    if(value1<value2)
    return -1;
    else if(value1>value2)
    return 1;
    else
    return 0;
    }
  • 操作方法
  • concat()完结数组的拼凑
    var arr1=[‘big’,’small’];
    var arr2=[‘middle’];
    var arr3=arr1.concat(arr2,’lala’);
    alert(arr3);//big,small,middle,lala
  • slice()完毕数组截取,接受1个或三个参数,表示截取地方。第多少个参数表示开首截取的地点,第贰个参数表示结束地点,但不包蕴截至地方的项。
    alert(arr3.slice(1,2));//small
  • splice向数组的正中插入项
    • 删除:只需求钦点四个参数,要删减的首先项的地方与要去除的位数。
      var arr1=[‘big’,’small’,’susu’];
      alert(arr1.splice(0,2));//big,small
      alert(arr1);//susu
      回到删除项。
    • 插入:能够向钦点地点插入多项,接受八个参数,第三个为发端地方,首个为0要刨除的项数,第八个为要插入的项。当然插入的项可以为八个。
      var arr1=[‘big’,’small’,’susu’];
      alert(arr1.splice(1,0,’middle’,’lalal’));//
      alert(arr1);//big,middle,lala,small,susu
    • 轮换
      :能够向钦点地点插入自便数量的项,且同时删除任性数量的项,接受多少个参数,开头地方,要去除的项数,和要插入的放四数量的项。
      var arr1=[‘big’,’small’,’susu’];
      alert(arr1.splice(1,1,’middle’,’lalal’));//small
      alert(arr1);//big,middle,lala,susu
  • 任务方法
    .indexOf().lastIndexOf()那七个章程的应用与字符串同样。
  • 迭代情势
    各类方法都领受四个参数:2个是必选的:要在每一项上运营的函数。另一项是可选的:运作该函数的功效域。
  • every()对数组中的每壹项运营给定的函数,要是该函数对每一项都回去true,则赶回true。
  • filter()对数组中的每1项运转给定的函数,f重回该函数会回来true的项构成的数组。
  • foreach()对数组中的每一项运营给定的函数,那一个措施未有重临值。
  • map()对数组中的每一种运营给定的函数,再次回到每便调用的结果组成的数组。
  • some()对数组中的每一种运营给定的函数,假若该函数对任一项再次来到true,那么该措施再次回到true。
  • 归并发法
    迭代数组的全体项,然后营造3个尾声回到的值。
  • reduce():从数组的第叁项初步,各个遍历到最后。
  • reduceRight():从数组的末梢1项起始,向前遍历到第一项。
    那连个方法,都接受多个参数:三个在各样上都调用的函数(必选);
    和当作联合基础的开端值(可选)。
    那七个函数都领受多个参数:前3个值,当前值,项的目录,数组对象。
    只顾:那一个函数重返的任何值都会作为第一个参数字传送递给下壹项。
    先是次迭代是从第1个参数开首。即首先个参数是率先项,第三个参数是第二项。
    var num=[1,2,3,4,5,6,7,8,9];
    var newnum=num.reduce(function(pre,cur,index,array){
    return pre+cur;
    })
    alert(newnum);//45

数组
    JavaScript 的Array
能够分包自由数据类型,并通过索引来访问每一个成分。
    要拿走Array的长短,直接待上访问length属性:

  (二)var arr = new
Array(length);//创造钦定长度的数组;预分配3个数组空间;但数组中从未存款和储蓄值,乃至数组的索引属性’0′,’1’等还未定义

      var arr = [1, 2, 3.14, ‘Hello’, null, true];
      arr.length; // 6

  (3)var arr=new
Array(值1,值2,值3…)

   请注意,直接给Array的length赋叁个新的值会促成Array大小的生成:
      var arr = [1,2,3];
      arr.length; // 3
      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’]
  注意:若是通过索引赋值时,索引当先了限制,同样会唤起Array大小的扭转:
    var arr = [1, 2, 3];
    arr[5] = ‘x’;
    arr; // arr变为[1, 2, 3, undefined, undefined, ‘x’]

2.字面量:var arr = []; var
arr=[1,2,3]

indexOf() 和lastIndexOf()
    那一个四个格局都吸收七个参数,要寻找的项和表示查找源点地点的目录,当中indexOf
方法从数组的发端发轫向后查找
    lastIndexOf
方法则从数组的最终初始向前查找。四个措施在没又找到的情形下再次回到-一,供给寻找的像必须从严相等,
    就像是使用(===)同样。
    Array也得以通过indexOf()来探究八个点名的成分的地方:
      var arr = [10,20,’30’,’xyz’];
      arr.indexOf(十); // 成分拾 的索引为0
      arr.indexOf(20); // 成分20 的目录为一
      arr.indexOf(30); // 成分30从未有过找到,重临-1
      arr.indexOf(’30’); // 成分’30’的目录为二
    注意:数字30和字符串’30’是见仁见智的要素。

分歧:new
Array()唯有一个参数(无法为小数:违规!报错!)时,会被当成是长度,并成为3个松气数组;

slice
    slice()就是对应String的substring()
版本,它截取Array的一对因素,然后重回三个新的Array:
      var arr = [‘A’,’B’,’C’,’D’,’E’,’F’,’G’] ;
      arr.slice(0,3); // 从索引0初始,到目录三达成,但不包涵索引三:
[‘A’, ‘B’, ‘C’]
      arr.slice(叁); // 从索引三开首到甘休: [‘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 arr1 = new Array(4);
var arr2 = [4];
console.log(arr1);//[undefined*4]
console.log(arr2);//[4]
var arr = new Array(3.4);
console.log(arr);//Uncaught RangeError: Invalid array length

push 和pop
    push() 向Array 的结尾增添若干因素,pop则把Array
的尾声2个因素删除掉。
    push: 再次来到修改后数组的尺寸,pop():重回移除的项。
皇家赌场手机版,      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; //[]

贰.数组的读写(不可溢出读,结果为undefined;能够溢出写)

unshift 和shift
    假使要往Array 的头顶增多若干因素,使用unshift() 方法,shift()
方法把Array 的率先个要素删除。
      var arr = [1,2];
      arr.unshift(‘A’,’B’); // 再次回到Array 新的长短 肆
        arr: // [‘A’,’B’,1,2]
      arr.shift(); //’A’
        arr; //[‘B’,1,2]
      arr.shift(); arr.shift(); arr.shit(); //连续shift 3 次
        arr; // []
      arr.shift(); // 空数组一而再shift不会报错,而是重临undefined
        arr;// []

规律:数组索引仅仅是目的属性名的1种分外类型,那表示javascript数组没有’越界错误’的定义,.当试图询问其余对象不设有的属性依然,不会报错,只会赢得undefined值.

sort
    sort()能够对脚下Array实行排序,它会直接修改当前Array的元素地方,直接调用时,依据暗中同意顺序排序:
    相比较的是字符串。
      var arr = [‘B’,’C’,’A’];
      arr.sort();
      arr; //[‘A’,’B’,’C’]
    从小到大排列:(升序)
      function compare(value,value){
        if(value1 < value2){
            return -1;
        }else if(value1 >value2 ){
          return 1;
        }else{
          return 0;
        }
      }
    var values = [0,1,5,10,15];
    values.sort(compare);
    alert(values) // 0,1,5,10,15
  从大到小排列(降序)
    function compare(value1,value2){
      if(value1 < value2){
          return 1;
        }else if(value1 > value2){
          return -1;
      }else{
        return 0;
      }
    }
    var values = [0,1,5,10,15];
    values.sort(compare);
    alert(values); //15,10,5,1,0

var arr = [1,2];
console.log(arr[2]);//undefined
arr[4] = 5;//溢出写
console.log(arr);//[1,2,undefined,undefined,5];
console.log(arr[3]);//undefined--->实际上是arr['3']
var obj = {};
console.log(obj.age);//undefined
var arr = [];
console.log(arr['age']);//undefined

reverse
    reverse() 把全体Array 的因素去掉个个,也是反转。
      var arr = [‘one’,’two’,’three’];
      arr.reverse();
      arr; //[‘three’,’two’,’one’]

只顾:数组是目的的差别通常格局.使用方括号访问数组就好像方括号访问对象的性质一样,javascript将钦赐的数字索引值调换为字符串—索引1变为’壹’—然后将其作为品质名来使用.

splice
    splice() 方法是修改Array
的无所无法方法,首要用途是向数组的正中插入项。
      删除:能够去除放四数量的项,只需点名二 个参数。
        举个例子:splice(0,二)会删除数组中的前两项
      插入:能够向内定地方插入放肆数量的项,只需提供1个参数,其实地点,0(要去除的项数)
和要插入的项,假使
        插入八个项,能够在扩散第陆,第4,三个。比如:splice(贰,0,”red”,”green”)
      替换:能够向钦命地方插入任意数量的项。同时删除大4数量的项,只需点名二个项,开首地点,要去除的项数,
        插入的项不须求和删除的项相等,splice(2,一,”red”,”green”),会去除数组地点2的项,然后从贰的地点
        插入字符串”red”和green。
      var arr = [‘Microsoft’, ‘Apple’, ‘Yahoo’, ‘AOL’, ‘Excite’,
‘Oracle’];
          // 从索引二开首删除叁个因素,然后再增加多少个要素:
      arr.splice(二, 3, ‘谷歌(Google)’, ‘脸书’); // 重临删除的要素
[‘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’]

数组的尤其之处在于:当使用小于等于二^3二-二的非负整数作为属性名时,数组会自动爱抚其length属性值;

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’, 1, 2, 3];
      arr.concat(1, 2, [3, 4]); // [‘A’, ‘B’, ‘C’, 1, 2, 3, 4]

arr[Math.pow(2,32)-2] = 67;//索引
arr[Math.pow(2,32)-1] =22;// 属性名

join
  join()方法是一个这多少个实用的方法,它把当下Array的种种成分都用内定的字符串连接起来,然后再次回到连接后的字符串:
    var arr = [‘A’, ‘B’, ‘C’, 1, 2, 3];
  arr.join(‘-‘); // ‘A-B-C-1-2-3’
    若是Array的要素不是字符串,将电动调换为字符串后再连接。

arr[1]—>实际上是arr[‘1’];

多维数组
    要是数组的某部元素又是三个Array,则能够产生多维数组,比方:
    var arr = [[1, 2, 3], [400, 500, 600], ‘-‘];

 var arr = [1,2,3,4];
 console.log(arr);
//[1, 2, 3, 4]
//0:1
//1:2
//2:3
//3:4
//length:4
console.log(arr[1])//2,实际上是访问数组的'1'属性;

(1)可以用负数或非整数来索引数组.那种情状下,数值转变为字符串,字符串作为品质名来使用(即索引不是非负整数的情事下,只好当做常规的对象属性);

(2)一样,如果正好使用了非负整数(即0和正整数)的字符串,它就当做数组索引,而非对象属性.

(叁)当使用的一个浮点数和贰个整数相等时,也是作为数组索引

即除了(2)和(3)情况,[]内的值都真是对象属性名(转变为字符串)

var arr = [1,2,3,4];
arr[-2] = 'name';//-2当做属性-------(1)
arr[1.5] = 9;//1.5当做属性-----------(1)
arr['3'] = 15;//数组索引;等价于arr[3]------(2)
arr[1.00] = 23//数组索引;等价于arr[1]=23---(3)
arr['1.00']=4;//1.00当做属性1.00
arr['age'] = 6;//age:属性
console.log(arr);// [1, 23, 3, 15, -2: "name", 1.5: 9, 1.00: 4,age:6]
console.log(arr.length)//4 索引值为小于2^32的非负整数会自动维护其length值
var obj = {};//空对象或不空的
arr[obj] = '5';//属性名为[object Object]: "5"

叁.稀松数组:包罗从0开首的不三番五次索引的数组;length属性值大于成分的个数,能够用Array()构造函数或简捷地钦命数组的索引值大于当前的的数老板度来创制稀疏数组

1.var arr = new
Array(5);//
数组尚无成分,但a.length = 五

2. a =
[];//当前length为0;

 a[1000] =
0;//一千>0;稀疏数组,length变为十0一;

 肆.数组的常用方法

(1)退换原数组的:reverse,push,pop,unshift,shift,splice,sort;

(壹)reverse()—颠倒数组七月素的逐1并重临新的数组。

var arr=[1,2,3];
var a = arr.reverse();
console.log(arr);//[3,2,1]
console.log(a);//[3,2,1]

(2)push()—向数组的末尾增添3个或更加多因素,并回到新的长短。

var arr=[1,2,3];
var a = arr.push(4,5);
console.log(arr);//[]1,2,3,4,5]
console.log(a);//5

(3)pop()—删除并赶回数组的尾声贰个成分(未有形参,写了会被忽视)

var arr=[1,2,3];
var a = arr.pop(4,5);//自动忽略掉参数4,5
console.log(arr);//[1,2]
console.log(a);//3

(④)unshift()—向数组的初步加多3个或越多因素,并回到新的长短。

var arr=[1,2,3];
var a = arr.unshift(4,5);
console.log(arr);//[4,5,1,2,3]
console.log(a);//3

(5)shift()—删除并回到数组的第3个因素

var arr=[1,2,3];
var a = arr.shift();//没有形参,有的话会忽略
console.log(arr);//[2,3]
console.log(a);//3

(陆)splice()—删除成分,并向数组加多新因素,并回到删除的成分

它有七个参数,第二个参数时截取开首的职责,第四个参数是截取的长度,第多少个参数是1组数据,代表要在截取的地点增添的数码

var arr=[1,2,3];
var a = arr.splice(1,2,4,5)//从第一位开始截取两位数据2,3,并在当前位置添加数据4,5;
console.log(arr);//[1,4,5]
console.log(a);//[2,3]
var b = arr.splice(1,2,[7,8],9);//这里splice是插入数组本身,区别concat连接数组是数组的元素;
console.log(arr);//[1,[7,8],9];
console.log(b);//[4,5];

var arr=[1,2,3];
var a = arr.splice(-1,2,4,5)//从倒数第一位(第二位)(-1+arr.length=2)开始截取两位数据(这里只有一位数据了)3,并在当前位置添加数据4,5;
console.log(arr);//[1,2,4,5]
console.log(a);//[3]

若是不写要增进的数据的话,这几个措施就产生了在数组中去除数据的作用了。

比如截取的尺寸是0,然后添扩张少以来,那个办法就改为了在数额的一确定工作岗位位增多数据的效益了。

 (柒)sort()—从小到大排序—return最终排序后的数组(假设数组包蕴undefined成分,会被排到数组的尾部)

var arr = [1,2,,3,4];
var a=arr.sort();
console.log(a);//[1,2,3,4,undefined]

var arr=[1,5,3,9,-7,2];
var a = arr.sort();
console.log(arr);//[-7, 1, 2, 3, 5, 9]
console.log(a);//[-7, 1, 2, 3, 5, 9]

在sor后边增加reverse就一定于降序排序:

var arr=[1,5,3,9,-7,2];
var a = arr.sort().reverse();
console.log(arr);//[9, 5, 3, 2, 1, -7]
console.log(a);//[9, 5, 3, 2, 1, -7]

专注:这里的sort()是按ASCII码排序的,若要比较数的大大小小,供给在sort()内部增多函数

var arr=[1,3,10,2,5];
var a = arr.sort();
console.log(arr);//[1,10,2,3,5]

var arr = [1,2,undefined,null,3,4];
var a=arr.sort();
console.log(a);//[1,2,3,4,null,undefined]--根据ASCII码进行排序

sort()函数有个接口:

注意:

看重返值return:

(一)当再次回到值为负数时,后面包车型大巴数在头里

(2)当重返值为正数时,前面包车型地铁数在前边  

var arr=[1,3,10,2,5];
arr.sort(function(a,b){
    if(a>b){
        return 1;//a>b,b放在a前面,即小的数在前面
    }else{
        return -1;//a<b,a放在前面,即小的数在前面
    }
})
console.log(arr);//[1,2,3,5,10]

上面例子实际上就是a-b>0;重返正数,不然重临负数(升序排序)

将上边的算法进行简化:

var arr=[1,3,10,2,5];
arr.sort(function(a,b){
  return a-b;
})
console.log(arr);//[1,2,3,5,10]

 升序:return a – b;

 降序:return b – a

心想:假设有三个平稳数组,希望进行乱序,怎么写?

明白:当再次来到值为随机数(即只怕是正,恐怕是负的图景),进行比较的八个数的依次是不分明的;

var arr=[1,2,3,4,5];
arr.sort(function(){
  return Math.random()-0.5;//Math.random()--->[0,1);
})
console.log(arr);

sort()不止局限于对数字实行排序,也能够是依照某些属性对目标,字符串等开始展览排序

var deng = {
    name:'deng',
    age:12
};
var zao={
    name:'zao',
    age:34
};
var li={
    name:'li',
    age:10
}
var arr= [deng,zao,li];
arr.sort(function(a,b){
    return a.age-b.age;//1.按照年龄进行升序
 //return a.name.length - b.name.length;//2.按照名字长度升序

})
console.log(arr);

 遵照字节长度进行排序

//字节长度,汉字为2;字母为1;
function retBytes(str){
    var num = str.length;
    for(var i = 0 ; i< str.length;i++){
        if(str.charCodeAt(i) > 255){//返回指定位置的字符的 Unicode 编码;
            num += 1;
        }
    }
    return num;
}
var arr = ['Ming','李dang','王明','merheyka'];
arr.sort(function(a,b){
    return retBytes(a) - retBytes(b);
})
console.log(arr);//["Ming", "王明", "李dang", "merheyka"]

(二)不转移原数组的:concat,slice,join,toString,

(1)concat—-连接四个或越多的数组,并重返贰个新数组。

它的因素包蕴调用concat()的原始数组的要素和concat()的各样参数.若那个参数中的任何三个自身是数组,那连接的是数组的因素,而非数组本人;

但只顾:concat()不会递归扁平化数组的数组.concat()也不会修改调用的数组;

var arr1 = [1,2,3];
var arr2 = [4,5];
var arr=arr1.concat(arr2);//等价于var arr = [].concat(arr1,arr2);concat可以有一个或多个参数
console.log(arr);//[1,2,3,4,5]
console.log(arr1);//[1,2,3]
console.log(arr2);//[4,5]
var arr3 = [6,[7,8]];
arr = arr1.concat(arr3);
console.log(arr);//[1,2,3,6,[7,8]];

(2)slice—从某些已有的数组重返选定的成分

 slice能够有0个参数,1个参数恐怕三个参数(参数可感到负数(等价于
负数+数COO度)高出二个的参数会自行被忽略,感到唯有二个参数)

第1种情状:0个参数:截取整个数组(用于将类数组转化为数组)

var obj = {
    '0':'a',
    '1':'b',
    'length':2
}
var a=Array.prototype.slice.call(obj);
console.log(a);//['a','b']

第二种情况:3个参数:从第几个人开首,一直截取到终极一个人

var arr = [1,2,3,4,5,6]; 
var a=arr.slice(3);
console.log(a);//[4,5,6]

其二种情况:1个参数:slice(从该位先导截取,截取到该位);
例slice(二,四)从第3位开头截取到第1人(不包含该位),即第三人和第五位

var arr = [1,2,3,4,5,6]; 
var a=arr.slice(3,5);
console.log(a);//[4,5]

(3)
join—把数组的装有因素放入1个字符串。元素通过点名的标记实行一连。(可以用这么些方法来实行大气字符串的连接职业)

var arr = ['a', 'b', 'c'];
var str = arr.join('-');
console.log(str); // "a-b-c"

join–若不传参数(暗许为逗号连接) join()
等价于join(‘,’);

拼接字符串:使用arr.join(“”);

扩大;:split:字符串调换为数组的措施依照符号将字符串拆分为数组

var arr = ['a', 'b', 'c'];
var str = arr.join('-');
console.log(str); // "a-b-c"
var a = str.split('-');
console.log(a);//['a','b','c']

瞩目:3个数组通过join()方法和split()后获得的数组与原来的数组不必然是一样的;经过split重回的数组;每一种数都是字符串**

var arr = [1, 2, 3];
console.log(typeof arr[0]);//number
var str = arr.join('-');
console.log(str); // "a-b-c"
var a = str.split('-');
console.log(a);//['1','2','3']
console.log(typeof a[0]);//string

小题目:将上面包车型客车字符串拼到一齐

var str1 = 'tianmao';
var str2 = 'taobao';
var str3 = 'jindong';
var str4 = 'weipinghui';
var str5 = 'shuning';
var str6 = 'pingduoduo';

 一.用+运算符去连接字符串—由于字符串时存在栈里面包车型客车(先进后出),栈操作消耗品质大

var arr = [str1,str2,str3,str4,str5,str6];
var str = '';
for(var i = 0 ; i < arr.length;i++){
    str += arr[i];
}
console.log(str);//tianmaotaobaojindongweipinghuishuningpingduoduo

2.用join方法—-推荐

var arr = [str1,str2,str3,str4,str5,str6];
str = arr.join('');
console.log(str);//tianmaotaobaojindongweipinghuishuningpingduoduo

 (四)toString()—-把数组转变为逗号分隔的字符串列表.注意:输出不包蕴方括号或任何任何款式的包裹数组值的相间符.

var arr = [1,2,3,4];
var str = arr.toString();
console.log(str);//"1,2,3,4"

[1,[2,3]].toString();//'1,2,c' 这里与不适用任何参数的调用join()返回的结果一样

(五)toLocalString():toString的地方化版本.

它调用成分的toLocalString()的方法将每一个数组成分转化为字符串,并行使本地化(和自定义落成的)分隔符将那么些字符串连接起来.

(三)ES5中的数组方法

 

1.forEach()—–那些方法会更换原数组,它让数组中的成分原原本本遍历叁次,每三个都调用一下大家在forEach里面传递的方法,中间不会告1段落。

能够有多个参数(数组成分,元素索引,数组本身)

var arr = [1, 2, 3, 4];
arr.forEach(function (ele, index) {
  arr[index] += 1;
})
console.log(arr); // [2, 3, 4, 5]

**2.map()—–那一个法子和forEach很像,只是map不会退换原数组,而是重回1个新的数组,它也是让传递二个钦赐的法子,让数组中的每二个因素都调用3遍这么些主意。可是记得map方法最终有重临值。假诺是稀疏数组,再次来到的也是同一方法的疏散数组,它兼具同样的长度,同样的缺点和失误成分**

var arr = [1, 2, 3];
var test = arr.map(function (x) {
     return x * x;
 });
console.log(test); // 1 4 9
console.log(arr); // 1 2 3    

三.filter()———过滤的法力,它一样不会变动原数组,而是回到三个原数组的子集。大家1致会传递3个方法,每2个因素都会调用一下以此法子,可是唯有再次来到true的成分才会被增多到新数组里面,重返false的不会被增多到新数组里面。

var a = [1, 2, 3, 4, 5];
var b = a.filter(function (x) {
     return x > 2;
});
console.log(a);//[1,2,3,4,5]
console.log(b); // [3,4,5]

 同时,filter()会跳过稀疏数组里面缺少的成分,它的回到数组总是稠密的。

var arr = [1,,,,,,3,4];
var b = arr.filter(function () {
      return true;
})
console.log(arr); // [1,3,4]

4.every和some

那七个办法是数组的逻辑判定,他们对数组应用钦定的函数进行剖断,重返true可能false。

every是如若每多少个要素经过传递的不二等秘书技的论断之后都回到true,那么最后才回去true。

some是倘诺有2个因素重回true,那么就赶回true。

依照数学上的常规,在空数组上调用时,every()重返true,some()重回false

var arr = [1 ,2 ,3];
console.log(arr.some(function (x) {return x<3;})); //true
console.log(arr.every(function (x) {return x<3;})); //false

5.reduce()和reduceRight():**行使钦赐的函数将数组成分进行整合,最终产生一个值,reduce是从左向右,reduceRight是从右向左。有多少个参数,第二个是情势,第二个是可选参数,即大家最后的这几个值的开始值。**

当我们尚无安装初步值的时候,用数组的第三个成分的值作为开端值。可是当数组为空的时候,不带起头值就能够报错。

当大家的数组唯有二个成分并且未有点名初叶值,或许有三个空数组并且钦赐1个开端值的状态下,reduce只是轻易地赶回那些值,而不会调用函数。

var arr = [1, 2, 3];
var sum = a.reduce(function (x, y) { return x + y}, 0);// 6------0 + 1 + 2 + 3 = 6;
var temp = [1];
var temoOut = a.reduce(function (x, y) {return x * x * y}); // 1 不会调用这个函数,因为数组只有一个值,除非我们设置一个初始值

 六.indexOf()和lastIndexOf():搜索整个数组中实际给定值的要素,重返找到的率先个要素的目录或许只要未有找到就重回-一.indexOf()原原本本寻觅,而lastIndexOf()则反向找寻

var a = [0,1,2,1,0];
a.indexOf(1);//1-->a[1] = 1;
a.lastIndexOf(1);//3--->a[3] = 1;
a.indexOf(3);//-1;没有值

 注意:indexOf()和lastIndexOf()不接收1个函数作为其参数(不报错—再次来到-一);

indexOf()和lastIndexOf()可以有八个参数,第壹个是须要搜索的值,第二个是点名数组中的一个目录,从那边开头寻找 

 —以上文化参考了:javascript权威指南

Leave a Comment.