JS 数字 字符串 数组

一、number 对象（数字对象）

1. 当数字字符串在进行数字运算 ( -、*、/ ) 时，字符串会转换成数字参加运算。

var x = "100", y = "10";

var z = x / y;       // z 将是 10

var z = x * y;       // z 将是 1000

var z = x - y;       // z 将是 90

var z = x + y;       // z 是 10010

总结： 数字字符串进行“+”运算时，表示级联；进行“ - * / ”运算时，会转换成数字，进行算术运算。
2. NaN 非数值

var x = 100 / "Apple";              // x 将是 NaN
isNaN(x);                          // 返回 true，因为 x 不是数   

var x = NaN, y = 5;
var z = x + y;                     // z 将是 NaN

var x = NaN, y = "5";
var z = x + y;                    // z 将是 NaN5

总结：

1. NaN 是数，typeof NaN 返回 number；
2. 使用函数 isNaN() 来判断某个值是不是数字；
3. 假如在数学运算中使用了 NaN，则结果也将是 NaN。

3. Infinity

var x =  2 / 0;               // x 将是 Infinity
var y = -2 / 0;               // y 将是 -Infinity

注意： Infinity 是数，typeOf Infinity 返回 number。
4. 使用 toString() 方法转换成进制字符串

var myNumber = 128;
myNumber.toString(16);         // 转换成 16进制字符串，返回 80
myNumber.toString(8);          // 转换成 8进制字符串，返回 200
myNumber.toString(2);          // 转换成 2进制字符串，返回 10000000
myNumber.toString();          // 转换成字符串，返回 128

5. 使用 toFixed() 方法转换成固定小数部分位数的小数字符串

var x = 9.656;
x.toFixed(0);                  // 返回 10
x.toFixed(2);                 // 返回 9.66
x.toFixed(4);                 // 返回 9.6560
x.toFixed(6);                  // 返回 9.656000

6. 使用 valueOf () 方法求对象的数值，返回值是数字

var x = 123;
x.valueOf();                // 返回123，数据类型是number

在 JS 内部使用 valueOf() 方法，可将 Number 对象转换为原始值。
7. JS 全局方法

方法	含义
Number()	转换成数字
parseFloat()	转换成浮点数
parseInt()	转换成整数

全局方法适用于所有的数据类型：

// 1. Number() 不允许空格
x = "10 20";
Number(x);        // 返回 NaN。不允许空格
Number(new Date("2019-04-15"));  //返回1506729600000。Number()方法返回1970年1月1日至今的毫秒数

// 2. parseInt() 返回整数。允许空格。只返回第一个数字：
parseInt("10 20 30");   // 返回 10
parseInt("10 years");   // 返回 10
parseInt("years 10");   // 返回 NaN

// 3. parseFloat() 返回浮点数。允许空格。只返回首个数字：
parseFloat("10 20 30");  // 返回 10
parseFloat("10 years");  // 返回 10
parseFloat("years 10");  // 返回 NaN

二、string 字符串

1. 转义字符：用在字符串当中

字符	含义
\’	单引号
\"	双引号
\\	反斜杠
\b	退格键
\f	换页
\n	换行
\r	回车
\t	水平制表符
\v	垂直制表符

2. 字符串的方法
注意： 字符串执行以下操作后，原字符串都不变。

方法	含义
str [ 0]	通过索引获取字符串中的元素，返回获取的元素。如果不存在，则返回undefined。 它是只读的，不能通过给它赋值修改字符串的值
str. length	返回字符串长度。 长代码换行： 最佳换行位置是某个运算符之后
str. indexOf ( " bd")	返回字符串首次出现的索引，如果没有返回 -1
str. lastIndexOf( " bd")	倒着往前看返回字符串首次出现的索引，如果没有返回 -1
str. indexOf( " China"，18)	返回起始索引开始往后字符串首次出现的索引，如果没有返回 -1。 第二个参数是查找字符串起始索引
str. lastIndexOf ( " China"，50);	返回起始索引开始倒着往前看字符串首次出现的索引，如果没有返回 -1。 第二个参数是查找字符串起始索引
str. search( " bd")	返回字符串首次出现的索引，如果没有返回 -1 区别： search() 没有第二个设置搜索位置的参数，但可以使用正则； indexOf() 可以设置第二个设置位置的参数，但不能使用正则。
str. slice( start 索引，end 索引)	返回截取的字符串，包头不包尾。如果省略第二个参数，将截取起始位置后的所有字符串 ，索引可以是负值
str. substring( start 索引，end 索引)	类似于 slice()，索引不能是负值
str. substr( start 索引，length 长度)	返回截取的字符串。如果省略第二个参数，将截取起始位置后的所有字符串 ，索引可以是负值
str. replace( " 旧内容 “,” 新内容 ")	替换首次出现的字符串，返回新的字符串。
str. toUpperCase()	全部转换成大写，返回新的大写的字符串
str. toLowerCase()	全部转换成小写，返回新的小写的字符串
str. concat( " sdfjs", " jkn") str.concat(k).concat(h)	拼接多个字符串，返回拼接的新的字符串。多个参数用逗号隔开
str. trim()	去除字符串两端空白， 返回新的字符串，
str. charAt( n 索引)	返回索引位置处的字符
str. charCodeAt( n 索引)	返回索引位置处的字符的编码
str. split( " 分隔符")	把字符串转换成数组，返回数组。 如果分隔符是 “”，数组是间隔单个字符的数组 如果省略分隔符，数组只包含一个元素，元素是整个字符串。
String. fromCharCode( 编码)	把字符编码转换成字符，并返回字符。
str. match( " bd")	查找字符串，返回查找的字符串，没有返回 null

3. 字符串的遍历

// 方法 1：for 循环
 var s1="abcdefa";
     for(var i=0;i<s1.length;i++){
         console.log(s1[i]);
     }
          
//方法 2：for in
    for(var index in s1){             // in 前面定义索引变量，后面写字符串名称
        console.log(s1[index]);
    }

三、数组

1. 数组的声明

// 方法 1：常规声明，通过索引赋值
var arr=new Array();                 //声明
arr[0]=1;                           //赋值
arr[1]="a";
arr[2]=null;
arr[3]={};
arr[4]=true;
arr[5]=undefined;
arr[6]=function(){};

// 方法 2：常规声明，直接在内置对象Array()中赋值
var arr=new Array(5);         //赋一个数字，该数字表示数组长度，不是数组中的元素
var brr=new Array(1,2);       //赋多个数字就表示赋值
var crr=new Array("1");       //给数组赋了一个字符串，表示赋值               

// 方法 3： 简化声明 
 var d=[1,2,3,4];     // 1.括号内赋值
     d[7]=10;      // 2.通过索引赋值：可以给任意索引处赋值，没有赋值的地方位置留着，值为empty。
 console.log(d);    // 输出结果：[1, 2, 3, 4, empty × 3, 10]          

2. 数组的方法
数组：是一种特殊的变量，能够存放多个值。数组的值可以改变。

方法	含义
cars [ 0]	通过索引获取数组中的元素，返回获取的元素。如果不存在，则返回undefined。 可以通过给它赋值修改数组中的元素
cars. length	返回数组的长度。
cars. push ( " bmw")	给数组末尾添加一个元素，返回新数组的长度。原数组改变
cars. pop ( )	删除数组的最后一个元素，返回删除的元素。原数组改变
cars. shift ( )	删除数组的第一个元素，返回删除的元素。原数组改变
cars. unshift ( " bmw" )	向数组开头添加新元素，返回新数组的长度。原数组改变
cars. toString( )	把数组转换成字符 串，返回字符串，原数组不变。
cars. join ( " * ")	把数组转换成字符串，返回字符串，原数组不变。可以设置分隔符。
cars. splice( 2，1，" ddg"，" dk")	插入、删除或替换数组的元素，返回一个包含删除项的数组。原数组改变。 第一个参数定义了添加新元素的位置，第二个参数定义了删除元素的个数。其余参数定义了要添加的新元素。
cars. fill( " ddg"，1，3)	替换数组的元素，返回替换后的数组。原数组改变。 第一个参数是替换的新元素，第二个参数是替换的起始索引，第三个是结束的索引，取小不取大。后两个参数不写则全部替换。
cars. concat( b)	拼接数组，返回拼接的新数组。原数组不变
cars. slice( start 索引，end 索引)	截取数组，返回截取的数组，包头不包尾。如果省略第二个参数，将截取起始位置后的所有元素 ，原数组不变
cars. sort( )	按字母顺序对数组进行排序，返回排序后的新数组。原数组改变
cars. reverse( )	反转数组元素，返回反转后的新数组。原数组改变
cars. indexOf( " China"，3)	返回起始索引开始往后元素首次出现的索引，如果没有返回 -1。 第二个参数是查找字符串起始索引
cars. lastIndexOf ( " China"，2);	返回起始索引开始倒着往前看元素首次出现的索引，如果没有返回 -1。 第二个参数是查找字符串起始索引

数组的其他方法：

var a=[1,2,3];
var b=[4,5,6];
var m=a.concat(b);
    
// 1.every 返回值是 true/false。 检测数组里面的元素是否都符合条件。
 var boo=m.every(function (val, index){    //every 里面的参数是回调函数，回调函数的形参是值和索引
        return val>1;                      //判断是否满足条件               
    });
 console.log(boo);        //结果是：false  如果每个值都满足条件返回true，有一个不满足则返回false.

// 2.some  返回值是 true/false。判断数组中的元素是否是否有满足条件的，如果有满足条件的返回true,如果没有返回false.
 var isboo=k1.some(function (val,index,arr){
     if(val%5==0)
       {
         return val;
       }
     });
 console.log(isboo);
 
// 3.filter 返回值是过滤出的元素形成的数组。  过滤出满足条件的元素，并形成新数组返回。
 var fil=m.filter(function (val,index,arr){    //filter里面的参数是回调函数，回调函数的形参是值、索引和数组
    if(val>4)                        //判断是否满足条件  
    {
       return val;                  //满足条件则过滤出来
    }
   });
 console.log(fil);               // 结果是：[5, 6]。  原数组不变

// 4.find  查找数组里面满足条件的第一个值，并返回该值
 var mm=m.find(function (val,index,arr){  //find里面的参数是回调函数
     return val>4;                       //判断是否满足条件  
   });
 console.log(mm);            // 结果是：5。  原数组不变
  
// 5.map 映射产生新数组，返回值是新数组。原数组不变
  var k1=[1,2,3,4];
  var newarr=k1.map(function (val,index,arr){
      return val*2;
  });
  console.log(newarr);    // 结果是：[2,4,6,8]

// 6.reduce  累加器，数组中的元素进行运算后返回运算结果。原数组不变
 var k1=[1,2,3,4];
 var all=k1.reduce(function (val1,val2){
      return val1*val2;
  });
 console.log(all);   // 结果是：24

3. 数组的遍历：

// 方法 1：for 循环
 var s1=[2,4,6,2,3];
     for(var i=0;i<s1.length;i++){
         console.log(s1[i]);
     }
          
// 方法 2：forEach   无返回值
 s1.forEach(function (val,index,arr){
    console.log(value);               // 把对元素要进行的操作写在回调函数里
  });