js六大数据类型及部分重要方法

六大数据类型

js中有六种数据类型，包括五种基本数据类型（Number,String,Boolean,Undefined,Null）,和一种复杂数据类型（Object）。

常用的重要方法

简单类型（基本数据类型）

Number数值类型

1.parseFloat()

parseFloat() 函数可解析一个字符串，并返回一个浮点数。
该函数指定字符串中的首个字符是否是数字。如果是，则对字符串进行解析，直到到达数字的末端为止，然后以数字返回该数字，而不是作为字符串。

语法：parseFloat(string)
@param string 必需。要被解析的字符串。

document.write(parseFloat("10"));  // output 10
document.write(parseFloat("10.00"));  // output 10
document.write(parseFloat("10.33"));  // output 10.33
document.write(parseFloat("34 45 66"));  // output 34
document.write(parseFloat(" 60 "));  // output 60
document.write(parseFloat("40 years"));  // output 40
document.write(parseFloat("He was 40"));  // output NaN

2.parseInt()

parseInt() 函数可解析一个字符串，并返回一个整数

语法：parseInt(string, radix)
@param string 必需。要被解析的字符串。
@param radix 可选。表示要解析的数字的基数。该值介于 2 ~ 36 之间。如果省略该参数或其值为 0，则数字将以 10 为基础来解析。如果它以 “0x” 或 “0X” 开头，将以 16 为基数。如果该参数小于 2 或者大于 36，则 parseInt() 将返回 NaN。

parseInt("10");			//返回 10
parseInt("19",10);		//返回 19 (10+9)
parseInt("11",2);		//返回 3 (2+1)
parseInt("17",8);		//返回 15 (8+7)
parseInt("1f",16);		//返回 31 (16+15)
parseInt("010");		//未定：返回 10 或 8

3.toString()

toString() 方法可把一个逻辑值转换为字符串，并返回结果。

语法：booleanObject.toString()

var a = new Boolean(true);
document.write(a.toString());  // output true
var b = 22;
document.write(b.toString());  // output "22"
let c = 38.907
document.write(c.toString()); // output "38.907"

4.toFixed()

toFixed() 方法可把 Number 四舍五入为指定小数位数的数字。

语法：NumberObject.toFixed(num)
@param Number 必须。规定小数的位数，是 0 ~ 20 之间的值，包括 0 和 20，有些实现可以支持更大的数值范围。如果省略了该参数，将用 0 代替。

var num = new Number(13.37);
document.write (num.toFixed(1)) // output 13.4

5.toPrecision()

toPrecision() 方法可在对象的值超出指定位数时将其转换为指数计数法。

语法：NumberObject.toPrecision(num)
param Number num 必需。规定必须被转换为指数计数法的最小位数。该参数是 1 ~ 21 之间（且包括 1 和 21）的值。有效实现允许有选择地支持更大或更小的 num。如果省略了该参数，则调用方法 toString()，而不是把数字转换成十进制的值。

var num1 = new Number(10000);
document.write (num1.toPrecision(4)) // output "1.000e+4"
document.write (num1.toPrecision(5)) // output "10000"
var num2 = new Number(35.68);
document.write (num2.toPrecision(4)) // output "35.68"
document.write (num1.toPrecision(6)) // output "35.6800"
document.write (num1.toPrecision(3)) // output "35.7"

String字符串类型

1.charAt()

charAt() 方法可返回指定位置的字符。

语法：stringObject.charAt(index)
@param Number index 必需。表示字符串中某个位置的数字，即字符在字符串中的下标。

var str="Hello world!"
document.write(str.charAt(1))  // output e

2.indexOf()

indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。

语法：stringObject.indexOf(searchvalue,fromindex)
param String searchvalue 必需。规定需检索的字符串值。
param Number fromindex 可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。

var str="Hello world!";
document.write(str.indexOf("Hello"));  // output 0
document.write(str.indexOf("World"));  // output -1
document.write(str.indexOf("world"));  // output 6
document.write(str.indexOf("Hello",3));  // output -1

3.lastIndexOf()

lastIndexOf() 方法可返回某个指定的字符串值在字符串中最后出现的位置。

语法：stringObject.lastIndexOf(searchvalue,fromindex)
param String searchvalue 必需。规定需检索的字符串值。
param Number fromindex 可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的最后一个字符处开始检索。

var str="Hello world!";
document.write(str.lastIndexOf("o"));  // output 7
document.write(str.lastIndexOf("World"));  // output -1
document.write(str.lastIndexOf("world"));  // output 6
document.write(str.lastIndexOf("d",6));  // output -1

4.slice()

slice() 方法可提取字符串的某个部分，并以新的字符串返回被提取的部分。

语法：stringObject.slice(start,end)
参数：
start [Number] 要抽取的片断的起始下标。如果是负数，则该参数规定的是从字符串的尾部开始算起的位置。也就是说，-1 指字符串的最后一个字符，-2 指倒数第二个字符，以此类推。
end [Number] 紧接着要抽取的片段的结尾的下标。若未指定此参数，则要提取的子串包括 start 到原字符串结尾的字符串。如果该参数是负数，那么它规定的是从字符串的尾部开始算起的位置。

var str="Hello happy world!";
console.log(str.slice(6));  // output "happy world!"
console.log(str.slice(6,10));  // output "happ"
console.log(str.slice(6,-3));  // output "happy wor"

5.substring()

substring() 方法用于提取字符串中介于两个指定下标之间的字符。

语法：stringObject.substring(start,stop)
参数：
start [Number] 必需。一个非负的整数，规定要提取的子串的第一个字符在 stringObject 中的位置。
stop [Number] 可选。一个非负的整数，比要提取的子串的最后一个字符在 stringObject 中的位置多 1。
如果省略该参数，那么返回的子串会一直到字符串的结尾。
== 区别于 slice() 方法，该方法的参数不支持负数 ==

var str="Hello world!";
console.log(str.substring(3)); // output  "lo world!"
console.log(str.substring(3,9)); // output  "lo wor"

6.substr()

substr() 方法可在字符串中抽取从 start 下标开始的指定数目的字符。

语法：stringObject.substr(start,length)
参数：
start [Number] 必需。要抽取的子串的起始下标。必须是数值。如果是负数，那么该参数声明从字符串的尾部开始算起的位置。也就是说，-1 指字符串中最后一个字符，-2 指倒数第二个字符，以此类推。
length [Number] 可选。子串中的字符数。必须是数值。如果省略了该参数，那么返回从 stringObject 的开始位置到结尾的字串。

var str="Hello world!";
console.log(str.substr(3)); // output  "lo world!"
console.log(str.substr(3,7)); // output  "lo worl"
console.log(str.substr(-3)); // output  "ld!"
console.log(str.substr(-3,2)); // output  "ld"

7.split()

split() 方法用于把一个字符串分割成字符串数组。

语法：stringObject.split(separator,howmany)
参数：
separator [String] 必需。字符串或正则表达式，从该参数指定的地方分割 stringObject。
howmany [Number] 可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。

var str="How are you doing today?";
console.log(str.split(" ")); // output ["How", "are", "you", "doing", "today?"]
console.log(str.split("")); // output ["H", "o", "w", " ", "a", "r", "e", " ", "y", "o", "u", " ", "d", "o", "i", "n", "g", " ", "t", "o", "d", "a", "y", "?"]
console.log(str.split(" ",3)); // output  ["How", "are", "you"]
console.log(str.split("",3)); // output ["H", "o", "w"]

8.replace()

replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。

语法：stringObject.replace(regexp/substr,replacement);
参数：
regexp/substr [String/RegExp] 必需。规定子字符串或要替换的模式的 RegExp 对象。
请注意，如果该值是一个字符串，则将它作为要检索的直接量文本模式，而不是首先被转换为 RegExp 对象。
replacement [String] 必需。一个字符串值。规定了替换文本或生成替换文本的函数。

var str="Visit Microsoft!";
console.log(str.replace(/Microsoft/, "W3School")); // output "Visit W3School!"
console.log(str.replace("Visit", "W3School")); // output "W3School Microsoft!"

// 在下例中，我们将把字符串中所有单词的首字母都转换为大写：
name = 'aaa bbb ccc';
uw=name.replace(/\b\w+\b/g, function(word){
	return word.substring(0,1).toUpperCase()+word.substring(1);
	});
// output "Aaa Bbb Ccc"

Boolean、Undefined、Null

** 这三个数据类型过于简单其方法不作详述。**

复杂类型（引用类型）

复杂类型主要介绍数组Array和对象Object常用的一些方法

Array 数组

Array 对象用于在单个的变量中存储多个值。

创建 Array 对象的语法：
new Array();
new Array(size);
new Array(element0, element1, …, elementn);

1.concat()

concat() 方法用于连接两个或多个数组。
该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。

语法:: arrayObject.concat(arrayX,arrayX,…,arrayX)
参数:
arrayX [Array] 必需。该参数可以是具体的值，也可以是数组对象。可以是任意多个。
返回值:
返回一个新的数组。该数组是通过把所有 arrayX 参数添加到 arrayObject 中生成的。如果要进行 concat() 操作的参数是数组，那么添加的>是数组中的元素，而不是数组。

var a = [1,2,3];
var b = ["a","abc"];
var c = [{name:"小明"}];
console.log(a.concat(4,5)); // output [1,2,3,4,5]
console.log(a.concat(b)); // output [1,2,3,"a","abc"]
console.log(a.concat(b,c)); // output [1,2,3,"a","abc",{name:"小明"}]
console.log(a.concat(4,5,b,c)); // output [1,2,3,4,5,"a","abc",{name:"小明"}]

2.join()()

join() 方法用于把数组中的所有元素放入一个字符串。
元素是通过指定的分隔符进行分隔的。

语法:: arrayObject.join(separator)
参数:
separator [String] 可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符。
返回值:
返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把这些字符串连接起来，在两个元素之间插入 separator 字符串而生成的。

var arr = ["George","John","Thomas"];
console.log(arr.join()); // output "George,John,Thomas"
console.log(arr.join("/")); // output "George/John/Thomas"

3.pop()

pop() 方法用于删除并返回数组的最后一个元素。

语法:: arrayObject.pop()
返回值:
arrayObject 的最后一个元素。

var arr = ["George","John","Thomas"];
console.log(arr.pop()); // output "Thomas"
console.log(arr); // output ["George", "John"]

4.push()

push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。
该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。

语法:: arrayObject.push(newelement1,newelement2,…,newelementX)
参数:
newelement1 必需。要添加到数组的第一个元素。
newelement2 可选。要添加到数组的第二个元素。
newelementX 可选。可添加多个元素。
返回值:
把指定的值添加到数组后的新长度。
push() 方法可把它的参数顺序添加到 arrayObject 的尾部。它直接修改 arrayObject，而不是创建一个新的数组。push() 方法和 pop() 方法使用数组提供的先进后出栈的功能。

var arr = ["George","John","Thomas"];
console.log(arr.push("James")); // output 4
console.log(arr); // output ["George","John","Thomas","James"]

5.reverse()

reverse() 方法用于颠倒数组中元素的顺序。

语法:: arrayObject.reverse()
返回值:
颠倒元素后的数组

var arr = ["George","John","Thomas"];
console.log(arr.reverse()); // output ["Thomas",John","George"]
console.log(arr); // output ["George","John","Thomas"]

6.shift()

shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。

语法:: arrayObject.shift()
返回值:
数组原来的第一个元素的值。
如果数组是空的，那么 shift() 方法将不进行任何操作，返回 undefined 值。请注意，该方法不创建新数组，而是直接修改原有的 arrayObject。

var arr = ["George","John","Thomas"];
console.log(arr.shift()); // "George"
console.log(arr); // output ["John","Thomas"]

7.slice()

slice() 方法可从已有的数组中返回选定的元素。

语法:: arrayObject.slice(start,end)
参数:
start [Number] 必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。
end [Number] 可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。
返回值:
返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素。
请注意，该方法并不会修改数组，而是返回一个子数组。如果想删除数组中的一段元素，应该使用方法 Array.splice()。

var arr = ["George","John","Thomas"];
console.log(arr.slice(1)); // output ["John","Thomas"]
console.log(arr.slice(1,2)); // output ["John"]
console.log(arr.slice(-2)); // output ["John","Thomas"]
console.log(arr.slice(-2,2)); // output ["John"]
console.log(arr); // output ["George","John","Thomas"]

8.sort()

sort() 方法用于对数组的元素进行排序。

语法:: arrayObject.sort(sortby)
参数:
sortby [Function] 可选。规定排序顺序。其规则为函数中返回结果为true的排序方式
返回值:
对数组的引用。请注意，数组在原数组上进行排序，不生成副本。

var arr1 = ["George","John","Thomas","James","Adrew","Martin"];
console.log(arr1); // output ["George","John","Thomas","James","Adrew","Martin"]
console.log(arr1.sort()); // output ["Adrew","George","James","John","Martin","Thomas"]
console.log(arr1); // output ["Adrew","George","James","John","Martin","Thomas"]

var arr2 = [10,5,40,25,1000,1];
console.log(arr2.sort()); // output [1, 10, 1000, 25, 40, 5]

var arr3 = [10,5,40,25,1000,1];
arr3.sort(function(a,b){ return a-b })
console.log(arr3.sort()); // output [1, 5, 10, 25, 40, 1000]

9.splice()

splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目。
该方法会改变原始数组。

语法:: arrayObject.splice(index,howmany,item1,…,itemX)
参数:
index [Number] 必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
howmany [Number] 必需。要删除的项目数量。如果设置为 0，则不会删除项目。
item1, …, itemX [*] 可选。向数组添加的新项目。
返回值:
包含被删除项目的新数组，如果有的话。

var arr = ["George","John","Thomas"];
var arr1 = ["George","John","Thomas"];
console.log(arr.splice(2，0，"James")); // output []
console.log(arr); // output ["George","John","James","Thomas"]
console.log(arr1.splice(2，1)); // output ["Thomas"]
console.log(arr1); // output ["George","John"]

10.unshift()

unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。

语法:: arrayObject.unshift(newelement1,newelement2,…,newelementX)
参数:
newelement1 必需。要添加到数组的第一个元素。
newelement2 可选。要添加到数组的第二个元素。
newelementX 可选。可添加多个元素。
返回值:
把指定的值添加到数组后的新长度。

var arr = ["George","John","Thomas"];
console.log(arr.push("James")); // output 4
console.log(arr); // output ["James","George","John","Thomas"]

11.filter()

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
filter() 不会改变原始数组。

语法:: arrayObject.filter(function(currentValue,index,arr), thisValue)
参数:
currentValue [*] 必须。当前元素的值。
index [Number] 可选。当前元素的索引值。
arr [Array] 可选。当前元素属于的数组对象。
thisValue [Function] 可选。对象作为该执行回调时使用，传递给函数，用作 “this” 的值。如果省略了 thisValue ，“this” 的值为 “undefined”
返回值:
返回数组，包含了符合条件的所有元素。如果没有符合条件的元素则返回空数组。

var arr = ["George","John","Thomas"];
console.log(arr.filter(function(x){ return x.length>4 }));  // output ["George","Thomas"]
console.log(arr.filter(function(x,index){ return index>0 }));  // output ["John","Thomas"]

Object对象

Object.keys()方法

Object.keys方法用于遍历对象属性的一个方法 。

语法:: Object.keys(object)；
参数:
object [Object] 必需。需要遍历的对象
返回值:
包含该对象所有属性名的数组

var obj= {a: 1, b: 2, c: 3, d: 4};
Object.keys(obj); // output ["a","b","c","d"]
Object.keys(obj).filter(function(x) { return obj[x]>2 ;}); // output ["c","d"]

Object.values()方法

Object.values方法返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（ enumerable ）属性的键值 。

语法:: Object.keys(object)；
参数:
object [Object] 必需。需要遍历的对象
返回值:
包含该对象所有可遍历属性的键值的数组

var obj= {a: 1, b: 2, c: 3, d: 4};
Object.values(obj); // output [1,2,3,4]
// 如果Object.values方法的参数是一个字符串，会返回各个字符组成的一个数组。
Object.values('hello'); // output ["h","e","l","l","o"]

Object.hasOwnProperty()方法

Object.hasOwnProperty方法判断对象自身属性中是否具有指定的属性。

var obj = {name:'fei'}
console.log(obj.hasOwnProperty('name'))//true
console.log(obj.hasOwnProperty('toString'))//false

Object.assign() (es6)

Object.assign方法用于对象的合并，将源对象（ source ）的所有可枚举属性，复制到目标对象（ target ）。

var target = { a: 1 };
var source1 = { b: 2 };
var source2 = { c: 3 };
Object.assign(target, source1, source2);
target // {a:1, b:2, c:3}

引用：
1.https://www.w3school.com.cn/index.html
2.12种最常见的JavaScript数字方法
3.Javascript Object常用方法总结