js字符串/数组方法汇总

js字符串方法汇总

//slice(start,end)
      //substring(start,end)
      //substr(start,length)
      var str = "1234567890";
      var res = str.slice(4, 6); //前闭后开,从前往后,索引为0开始---//56
      var res = str.slice(-8, -6); //前闭后开,从后往前,索引为1开始---//34
      var res = str.slice(7); //省略第二个参数，将裁剪字符串的剩余部分---//890
      var res = str.slice(-7); //从后往前截取,保留后方---//4567890

      // substring同slice,但是不接受负参数

      //substr类似于slice,不同之处在于第二个参数规定被提取部分的长度
      var res = str.substr(3, 6); //---//456789
      var res = str.substr(-5); //如果首个参数为负,则从字符串的结尾计算位置,第二个参数不能为负//---67890
      // console.log(res);

      // replace
      // replace()方法不会改变调用它的字符串,它返回的是新字符串

      str = "Please visit Baidu and Baidu!";
      var n = str.replace("Baidu", "Microsoft"); // 默认只替换首个匹配//---Please visit Microsoft and Baidu!
      var n = str.replace(/Baidu/g, "Microsoft"); //替换所有使用正则表达式 /g //Please visit Microsoft and Microsoft!
      var n = str.replace("BAIDU", "Microsoft"); // 默认区分大小写//---Please visit Baidu and Baidu!
      var n = str.replace(/BAIDU/i, "Microsoft"); //不区分大小写使用正则表达式 /i //Please visit Microsoft and Baidu!
      // console.log(n);

      var str = "a,b,c,d,e,f";
      var arr = str.split(","); //['a', 'b', 'c', 'd', 'e', 'f']
      var arr = str.split(""); //['a', ',', 'b', ',', 'c', ',', 'd', ',', 'e', ',', 'f']
      var arr = str.split("|"); //['a,b,c,d,e,f']
      console.log(arr);

      

数组方法汇总

//push:在数组末位添加新元素,返回新数组的长度
      //pop:在数组末位删除元素,返回被删除的元素
      //shift:在数组首位删除元素,返回被删除的元素
      //unshift:在数组首位添加新元素,返回新数组的长度
      //splice:用于数组拼接,返回一个包含已删除项的数组
        var fruits = ["Banana", "Orange", "Apple", "Mango"];
        fruits.splice(2, 0, "Lemon", "Kiwi");
        console.log(fruits);//Banana,Orange,Lemon,Kiwi,Apple,Mango
        //第一个参数（2）定义了在哪个元素之前添加,2为索引。
        // 第二个参数（0）定义应删除多少元素。
        // 其余参数（“Lemon”，“Kiwi”）定义要添加的新元素。
        var fruits = ["Banana", "Orange", "Apple", "Mango"];
        fruits.splice(0, 1);// 删除 fruits 中的第一个元素---//Orange,Apple,Mango

      //concat:方法通过合并（连接）现有数组来创建一个新数组,可以使用任意数量的数组参数
      var arr1 = ["Cecilie", "Lone"];
      var arr2 = ["Emil", "Tobias", "Linus"];
      var arr3 = ["Robin", "Morgan"];
      var myChildren = arr1.concat(arr2, arr3);   // 将arr1、arr2 与 arr3 连接在一起

      //slice剪切后创建新数组,它不会改变源数组
      var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
      var citrus = fruits.slice(3);//从对应索引开始截取到最后//---Apple,Mango
      var citrus = fruits.slice(1, 3);//接收两个参数,前闭后开//---Orange,Lemon

      //toString以逗号分隔的字符串返回数组
      var fruits = ["Banana", "Orange", "Apple", "Mango"];
      var citrus = fruits.toString();//---Banana,Orange,Apple,Mango

      //sort以字母顺序对数组进行排序
      fruits.sort();//---Apple,Banana,Mango,Orange
      //reverse以字母顺序反转排序
      fruits.reverse(); //---Orange,Mango,Banana,Apple
      //数字排序直接使用sort和reverse会出现问题,可以通过一个比值函数解决问题
      var points = [40, 100, 1, 5, 25, 10];
      points.sort(function(a, b){return a - b}); //升序排序//---1,5,10,25,40,100
      points.sort(function(a, b){return b - a});//降序排序//---100,40,25,10,5,1

      //对数组对象进行排序
      var cars = [
      {type:"Volvo", year:2016},
      {type:"Saab", year:2001},
      {type:"BMW", year:2010}];
      cars.sort(function(a, b){return a.year - b.year});//根据对象中的属性进行排序--数字
      cars.sort(function(a, b){
          var x = a.type.toLowerCase();
          var y = b.type.toLowerCase();
          if (x < y) {return -1;}
          if (x > y) {return 1;}
          return 0;
      });//根据对象的属性排序---字符串

      //map通过对每个数组元素执行函数来创建新数组
      var numbers1 = [45, 4, 9, 16, 25];
      function myFunction(value, index, array) {
        return value * 2;
      }
      var numbers2 = numbers1.map(myFunction);//90,8,18,32,50

      //比值函数,比较函数应该返回一个负，零或正值
      function(a, b){return a-b}
      //但是使用sort函数比较两个值时,会将值发送到比较函数，并根据所返回的值（负、零或正值）对这些值进行排序。

      //查找数组中的最大值和最小值
      var maxPoint = Math.max.apply(null, arr);//查找最大值
      var maxPoint = Math.min.apply(null, arr);//查找最小值

var fruits = ["Banana", "Orange","Apple", "Mango"];
      //  join() 方法也可将所有数组元素结合为一个字符串。
      //  它的行为类似 toString()，但是还可以规定分隔符：
      let fruitAll = fruits.join(' % ');
      console.log(fruitAll)//-----Banana % Orange % Apple % Mango

      //Array.map()
      //包含三个参数:项目值,项目索引,数组本身;当回调函数仅使用 value 参数时，可以省略索引和数组参数
      //map() 方法通过对每个数组元素执行函数来创建新数组。
      //map() 方法不会对没有值的数组元素执行函数。
      var ages = ['0','2','3','5','10']
      let ageDouble = ages.map(this.func)
      console.log(ageDouble)//-----[0, 4, 6, 10, 20]

      // Array.filter()
      //包含三个参数:项目值,项目索引,数组本身;当回调函数仅使用 value 参数时，可以省略索引和数组参数
      // filter() 方法创建一个包含通过测试的数组元素的新数组
      let ageLarge = ages.filter(this.func2);
      console.log(ageLarge);//-----['5', '10']

      // Array.every()
      //包含三个参数:项目值,项目索引,数组本身;当回调函数仅使用 value 参数时，可以省略索引和数组参数
      // every() 方法检查所有数组值是否通过测试。
      // every()方法返回true或false
      var nums = [0,2,3,5,10];
      let numsOver3 = nums.every(this.func4);
      console.log(numsOver3);//----- false

      // Array.some()
      //包含三个参数:项目值,项目索引,数组本身;当回调函数仅使用 value 参数时，可以省略索引和数组参数
      // some() 方法检查某些数组值是否通过了测试。
      // some()方法返回true或false
      let numsIsOver3 = nums.some(this.func4);
      console.log(numsIsOver3);//-----true

      // Array.reduce()
      //包含四个参数:总数,项目值,项目索引,数组本身;当回调函数仅使用 value 参数时，可以省略索引和数组参数
      // reduce() 方法在每个数组元素上运行函数，以生成（减少它）单个值,reduce在数组中从左到右工作并创建一个新数组
      // 求和
      var sum = nums.reduce(this.func3);
      console.log(sum);//-----20

      // 接受一个初始值total
      var sum2 = nums.reduce(this.func3,100);
      console.log(sum2);//-----120
      // Array.reduceRight(),相对于reduce,它从右向左工作

      // Array.indexOf()
      // indexOf() 方法在数组中搜索元素值并返回其位置(索引值)
      // 如果未找到项目，Array.indexOf() 返回 -1。如果项目多次出现，则返回第一次出现的位置。
      var a = fruits.indexOf("Apple");
      console.log(a);//-----2

      // Array.lastIndexOf()
      // Array.lastIndexOf() 与 Array.indexOf() 类似，但是从数组结尾开始搜索。

	func(value, index, array){
      return value*2;
    },
    func2(value,index,array){
      return value > 4;
    },
    func3(total,value,index,array){
      return total + value;
    },
    func4(value,index,array){
      return value > 3;
    },

日期获取方法

获取方法用于获取日期的某个部分（来自日期对象的信息）。下面是最常用的方法（以字母顺序排序）：

1. getDate() 以数值返回天（1-31）
2. getDay() 以数值获取周名（0-6）
3. getFullYear() 获取四位的年（yyyy）
4. getHours() 获取小时（0-23）
5. getMilliseconds() 获取毫秒（0-999）
6. getMinutes() 获取分（0-59）
7. getMonth() 获取月（0-11）
8. getSeconds() 获取秒（0-59）
9. getTime() 获取时间（从 1970 年 1 月 1 日至今）

例:
var d = new Date();
let day = d.getDay();//获取当前周名数字(Sunday=0, Monday=1, Tuesday=2 ..)

日期比较

//例:把今日与 2049 年 1 月 16 日进行比较：
var today, someday, text;
today = new Date();
someday = new Date();
someday.setFullYear(2049, 0, 16);
if (someday > today) {
  text = "今天在 2049 年 1 月 16 日之前";
} else {
  text = "今天在 2049 年 1 月 16 日之后";
}