数组字符串常用方法

一、数组方法

1、创建数组

• new Array()

• 字面量 []

2、检测变量是否是数组

• instanceof

作用：检测变量是否是某个构造函数的实例

语法：变量 instanceof 构造函数名

返回值：true || false

• Array.isArray(变量)

返回值： true || false

• 例子：

var age = 100;
var arr = ['red','green','blue'];
​
console.log(age instanceof Array); // false
console.log(arr instanceof Array); // true

console.log(Array.isArray('123')); // false
console.log(Array.isArray(123));   // false
console.log(Array.isArray([1,2,3])); // true

3、添加数组元素

• 末尾添加

  语法： 数组.push(新元素1，新元素2, ...)

  返回值：数组最新的长度

• 前面添加

  语法： 数组.unshfit(新元素1，新元素2, ...)

  返回值：数组最新的长度

4、删除数组元素

• 删除最后一个元素

语法： 数组.pop();

返回值：被删除的元素

• 删除第一个元素

语法： 数组.shift()

返回值：被删除的元素

5、翻转数组

语法： 数组.reverse()

返回值：翻转后的数组

6、数组元素排序

• 从小到大排

  数组.sort(function(a,b){

  return a-b;

  })

• 从大到小排

  数组.sort(function(a,b){

  return b-a;

  })

7、查找元素位置

• 查找第一次出现的位置

  语法： 数组.indexof('给定的元素')

  返回值：元素的索引（数组中没有该元素，则返回-1）

• 查找最后一次出现的位置

  语法： 数组.lastIndexof('给定的元素')

  返回值：元素的索引（数组中没有该元素，则返回-1）

8、数组转为字符串

• 数组.toString()

• 数组.join('分隔符')

9、数组合并concat

语法：

数组.concat(元素1，元素2)

数组.concat(数组1，数组2)

返回值：返回合并后的新数组

10、删除插入替换splice

语法：数组.splice(开始位置,删除的个数，插入的元素)

返回值：删除的元素（数组形式返回）

11、拼接数组

const array1 = ['a', 'b', 'c']; ​ const array2 = ['d', 'e', 'f']; ​ const array3 = array1.concat(array2);

console.log(array3); ​ // expected output: Array ["a", "b", "c", "d", "e", "f"]

12、array.every();检查数组中的每一个元素是否能通过某个指定的函数的测试 返回一个布尔值

            const isBelowThreshold = (currentValue) => currentValue < 40;
            const array1 = [1, 30, 39, 29, 10, 13];
            console.log(array1.every(isBelowThreshold));
            // expected output: true

13、arry.fillter() 返回一个新数组包含的是通过所提供得函数测试得元素

          const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
          const result = words.filter(word => word.length > 6);
console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]    

14、array.find() 返回数组得中适合回调函数中得条件得第一个值 一般得配合循环

                    const array1 = [5, 12, 8, 130, 44];
                    const found = array1.find(element => element > 10);
                    console.log(found);
                    // expected output: 12

15、array.foreach(function(value,item){ })有三个参数最后一个参数可以改变this指向

                    const array1 = ['a', 'b', 'c'];
                    array1.forEach(element => console.log(element));    

16、array.form( 类数组，[mapfn [ , thisarg ] ]) 将类数组转换为数组

mapfn代表指定得类数组所有元素都得执行该回调函数

            console.log(Array.from('foo'));
            // expected output: Array ["f", "o", "o"]
            
            console.log(Array.from([1, 2, 3], x => x + x));
            // expected output: Array [2, 4, 6]     

17、array.includes( )判断数组是否包含一个指定的值 返回为布尔值

array.idnexof( )返回指定元素得下标 不存在则返回 -1

const array1 = [1, 2, 3];

console.log(array1.includes(2)); ​ // expected output: true

const pets = ['cat', 'dog', 'bat'];

console.log(pets.includes('cat')); ​ // expected output: true

console.log(pets.includes('at')); ​ // expected output: false

18、array.map() 将所有元素执行回调函数返回一个新的数组 语法：

                   var new_array = arr.map(function callback(currentValue[,                        index[, array]]) {
                        // Return element for new_array 
                   }[, thisArg])
                   
                    //例子1
                    const array1 = [1, 4, 9, 16];
                    // pass a function to map
                    const map1 = array1.map(x => x * 2);
​
                    console.log(map1);
                    // expected output: Array [2, 8, 18, 32]
                    //例子2
                    var kvArray = [{key: 1, value: 10},
                        {key: 2, value: 20},
                            {key: 3, value: 30}];
    
                     var reformattedArray = kvArray.map(function(obj) {
                     var rObj = {};
                     rObj[obj.key] = obj.value;
                     return rObj;
            });
​
                        // reformattedArray 数组为： [{1: 10}, {2: 20}, {3: 30}],
    
                        // kvArray 数组未被修改:
                        // [{key: 1, value: 10},
                        //  {key: 2, value: 20},
                        //  {key: 3, value: 30}]

19、arrray.slice()浅拷贝 返回新的数组 不改变原数组

**slice()** 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的 浅拷贝（包括 begin，不包括end）。原始数组不会被改变。

const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];

console.log(animals.slice(2)); // expected output: Array ["camel", "duck", "elephant"]

console.log(animals.slice(2, 4)); // expected output: Array ["camel", "duck"]

console.log(animals.slice(1, 5)); // expected output: Array ["bison", "camel", "duck", "elephant"]

console.log(animals.slice(-2)); // expected output: Array ["duck", "elephant"]

console.log(animals.slice(2, -1)); // expected output: Array ["camel", "duck"]

console.log(animals.slice()); // expected output: Array ["ant", "bison", "camel", "duck", "elephant"]

20、array.some( function( element,[,index [ ,array] ]){ },thisarg )返回值数组中至少有一个通过就是true

const array = [1, 2, 3, 4, 5];
// checks whether an element is even
const even = (element) => element % 2 === 0;
​
console.log(array.some(even));
// expected output: true

二、字符串方法

1、字符串长度 length

2、遍历字符串

for(var i=0;i 
  
3、查找字符出现的位置
 
  
 
   
 
第一次出现
 
语法：字符串.indexof('给定的字符'，开始查找的位置)
 
返回值：返回该字符串的索引值
 
 
   
 
最后一次出现
 
语法：字符串.lastIndexof('给定的字符'，开始查找的位置)
 
返回值：返回该字符串的索引值
 
 
  
 
  
4、根据位置返回字符
 
  
 
   
 
字符串[索引号]：返回字符
 
 
   
 
字符串.charAt(索引号)：返回字符
 
 
   
 
字符串.charCodeAt(索引号)：返回字符对应的ASCII码
 
 
  
 
  
5、合并字符串
 
  
语法：字符串.concat('拼接的字符串');
 
  
6、截取字符串
 
  
语法：字符串.substr(开始位置，截取长度)
 
  
返回值：截取到的新字符串
 
  
7、替换字符串
 
  
语法：字符串.replace('要替换的字符','替换成的字符')
 
  
作用：把字符串第一个指定的字符替换成新字符
 
  
返回值：返回替换后的新字符串
 
  
8、字符串转数组
 
  
语法：字符串.split('分隔符');
 
  
9、大小写转换
 
  
 
   
 
转为大写
 
字符串.toUpperCase()
 
 
   
 
转为小写
 
字符串.toLowerCase()
 
 
  
 
  
10、string.includes( ) -------str.includes(searchString[, position])
 
  
var str = 'To be, or not to be, that is the question.';
​
console.log(str.includes('To be'));       // true
console.log(str.includes('question'));    // true
console.log(str.includes('nonexistent')); // false
console.log(str.includes('To be', 1));    // false
console.log(str.includes('TO BE'));       // false
 
  
11、str.indexOf(searchValue [, fromIndex]) 表示从fromindex开始找
 
  
方法返回调用它的 String 对象中第一次出现的指定值的索引，从 fromIndex 处进行搜索。如果未找到该值，则返回 -1。
 
  
12、match() 方法检索返回一个字符串匹配正则表达式的结果。
 
  
const paragraph = 'The quick brown fox jumps over the lazy dog. It barked.';
const regex = /[A-Z]/g;
const found = paragraph.match(regex);
​
console.log(found);
// expected output: Array ["T", "I"]
 
  
13、string.replace（1，2） 把1替换为2
 
  
      const p = 'The quick brown fox jumps over the lazy dog. If the dog reacted, was it really lazy?';
      console.log(p.replace('dog', 'monkey'));
      // expected output: "The quick brown fox jumps over the lazy monkey. If the dog       reacted, was it really lazy?"
​
      const regex = /Dog/i;
      console.log(p.replace(regex, 'ferret'));
      // expected output: "The quick brown fox jumps over the lazy ferret. If the dog        reacted, was it really lazy?"
 
  
 
  
报错：
 
  
Assignment to constant variable. 是因为const声明的常量不能被赋值