Array

array.push(item…)

作用：往數(shù)組添加元素，尾部添加

array.unshift(item…)

作用：往數(shù)組添加元素，頭部添加

array.concat(item…)

作用：把 元素 插入數(shù)組，和push不同的點在于，concat可以指定元素是數(shù)組，即把一個數(shù)組在尾部插入。

// 和刪除相對應，增加也有從頭部增加和尾部增加// 插入單個元素 // 1. 從頭部插入 arr.unshift(item...) let arr = [1,2,3]; arr.unshift(0); console.log(arr); //[0,1,2,3]// 2. 從尾部插入 arr.push(item...) arr = [1,2,3]; arr.push(4); console.log(arr); //[1,2,3,4]// 3. 插入多個元素 // 顯然如果插入多個元素，我們一個個去push是很麻煩的，所以提供了一個方法 // arr.concat(item...) concat 這個單詞的含義是合并數(shù)組; arr1 = [1,2]; arr2 = [3,4]; arr = arr1.concat(arr2); console.log(arr); //[1,2,3,4] & arr1 沒有改變 還是[1,2]

array.pop()

作用：刪除元素，從尾部刪除

array.shift()

作用：刪除元素，從頭部刪除

//arr.shift() 刪除第一個元素并返回 let arr = [1,2,3]; let element = arr.shift(); //element 是 1 console.log(element);//arr.pop() 刪除最后一個元素并返回 arr = [1,2,3]; element = arr.pop(); //element 是 3 console.log(element);

array.reverse()

作用: 反轉(zhuǎn)數(shù)組的順序，并返回array本身

/*** 使用arr.reverse()反轉(zhuǎn)數(shù)組*/ let arr = [1,2,3]; arr.reverse() // 直接改變原數(shù)組 console.log(arr); // [3,2,1]

arry.slice(start,end)

作用:復制array里的一段內(nèi)容

/*** 有的時候我們想復制數(shù)組中的一段元素，但是我們不想改變原數(shù)組* 就用 arr.slice(start,end)* 參數(shù) start 開始索引* end 結(jié)束索引* 實際獲取的元素是 [start,end) 左閉,右開 ！！！* 基本上所有語言，（start,end）都是這樣的規(guī)定*/let arr = [1,2,3]; let temp = arr.slice(0,2); console.log(temp); //[1,2]

array.join(separator)

作用：數(shù)組轉(zhuǎn)字符串，將數(shù)組里面的元素拿出來用separator（分隔符）串聯(lián)在一起，變成字符串

/*** arr.join(separator)* 數(shù)組轉(zhuǎn)字符串 把數(shù)組的每個元素拿出來，用separator將他們分隔開來* 參數(shù) separator 分隔符*/ let arr = [1,2,3]; let c = arr.join(','); //1,2,3 將arr數(shù)組中的元素用逗號分割，并轉(zhuǎn)換成字符串 console.log(c);//其實等價于 let str = ""; for (item of arr){str += (item+','); } str = str.substr(0,str.length-1); //去除掉最后一個逗號 console.log(str);

array.sort(comparefn)

作用：數(shù)組排序（并不一定可靠）

var arr1 = [3,2,1]; console.log(arr1.sort()); // 輸出 [1,2,3] var arr2 = [4,8,15,23]; console.log(arr2.sort()); // 輸出 [15, 23, 4, 8] ？？？ /*** 也許聰明的你，已經(jīng)看出規(guī)律了，* arr.sort() 它只排序了比對了數(shù)據(jù)第一位。* arr2,它將8和15做比較大小的時候，是將8和1比較的，* 所以，15才會在8前面。*///arr.sort(comparefn) 可以通過接受一個compare參數(shù)來進行更加精準排序 arr2.sort(function(a,b){return a-b; }); console.log(arr2); // [4, 8, 15, 23] 此時結(jié)果正確了 // 你的比較函數(shù)應該接受兩個參數(shù)，并且如果兩個參數(shù)相等則返回0 // 如果兩個參數(shù)不等，且第一個參數(shù)排在前面，則返回一個負數(shù) // 如果兩個參數(shù)不等，且第二個參數(shù)排在前面，則返回一個正數(shù)

array.splice(start,deleteCount,item…)

作用：全能王，能同時實現(xiàn)刪除和插入。

// arr.splice(start,deleteCount,item...) /** * 參數(shù) start:開始的索引 * deleteCount : 刪除元素的個數(shù) * item: 要插入的元素值 * 返回值 被刪除的元素數(shù)組 */let arr = [1,2,3]; let a = arr.splice(0,1,'test'); //從0開始刪除一個元素，并在這個位置插入元素'test' console.log(arr); //["test",1,2] console.log(a); // [1]

Array.isArray(item)

作用：判定一個元素是否是數(shù)組

Array.isArray([1, 2, 3]); // true Array.isArray({foo: 123}); // false Array.isArray("foobar"); // false Array.isArray(undefined); // false

自此，關于數(shù)組的常用方法（API) 就學習完了。

Number

number.toString()

作用：數(shù)字類型轉(zhuǎn)字符串

Number.parseInt(item)

作用：將字符串，轉(zhuǎn)換成整數(shù)，當item不是字符串時，會調(diào)用tostring方法，把它變成string

Number.parseFloat(item)

作用：將字符串，轉(zhuǎn)換成浮點數(shù)，當item不是字符串時，會調(diào)用tostring方法，把它變成string

// 1. var num = 3.14; console.log(num.toString(),typeof num,typeof num.toString()); // 輸出 3.14 number string // 2. console.log(Number.parseInt(num)); //3 console.log(Number.parseInt("3.14")); //3 // 3. console.log(Number.parseFloat("3.14"),typeof Number.parseFloat("3.14")); // 輸出 3.14 "number"

Number.isNaN(item)

作用：判定一個數(shù)值是否NaN

/*** NaN的數(shù)據(jù)類型是number,它不等于任何值，也不等于它自己* console.log(NaN === NaN); //false */Number.isNaN(NaN); // true Number.isNaN(Number.NaN); // true Number.isNaN(0 / 0) // true// 下面這幾個如果使用全局的 isNaN() 時，會返回 true。(一定要使用Number.isNaN,而不是 isNaN,會引起如下錯誤) Number.isNaN("NaN"); // false，字符串 "NaN" 不會被隱式轉(zhuǎn)換成數(shù)字 NaN。 Number.isNaN(undefined); // false Number.isNaN({}); // false Number.isNaN("blabla"); // false

Number.isInteger(item)

作用：判定一個數(shù)是否是整數(shù)

console.log(Number.isInteger(3)); //true console.log(Number.isInteger(3.14)); //false console.log(Number.isInteger(undefined));//false

Object

object.hasOwnProperty(item)

作用：判定對象是否擁有某屬性

var obj = {name:"tom",age:18 } console.log(obj.hasOwnProperty("name")); // true console.log(obj.hasOwnProperty("weigth")); // false

object.keys()

作用：返回對象所有的屬性，作為數(shù)組

var obj = {name:"tom",age:18 } console.log(Object.keys(obj)); //["name", "age"]

object.values()

作用: 返回對象所有的值，作為數(shù)組

var obj = {name:"tom",age:18 } console.log(Object.values(obj)); // ["tom", 18]

補充：object的子集JSON

JSON只有兩個方法

JSON.stringify()

作用：返回與指定值對應的JSON字符串。即對象類型轉(zhuǎn)字符串，常用于數(shù)據(jù)傳輸。

JSON.parse()

作用：解析JSON字符串并返回對應的值。即字符串轉(zhuǎn)對象類型，常用于數(shù)據(jù)傳輸。

這倆在JSON格式的數(shù)據(jù)傳輸中必不可少。前后端交互少不了它們。

var obj = {name: "tom",age: 18 }console.log(JSON.stringify(obj),typeof JSON.stringify(obj)); // {"name":"tom","age":18} 數(shù)據(jù)類型：stringvar str = '{"name":"tom","age":18}'; console.log(JSON.parse(str),typeof JSON.parse(str)); // {name: "tom", age: 18} 數(shù)據(jù)類型 object

String

string.charAt(pos)

作用：返回字符串在對應索引處的值

var str = "hello"; console.log(str.charAt(0)); // h console.log(str[0]); // h // 這兩種結(jié)果是一樣的，都是返回字符串在對應索引處的值

string.concat(string…)

作用：把字符串連接起來構(gòu)成一個新的字符串（常用+運算符把它替代）

var str1 = "hello"; var str2 = " world!"; var str = str1.concat(str2); console.log(str); //hello world! console.log(str1+str2); //hello world! // 建議使用+運算符進行字符串拼接 // 現(xiàn)階段瀏覽器引擎都對+運算符做過優(yōu)化，它的性能并不低

string.indexof(searchString,position)

作用：查找searchString在string 中第一次出現(xiàn)的位置，返回值如果是-1，說明沒找到

string.lastIndexOf(searchString,position)

作用：從末尾開始查找searchString在string 中第一次出現(xiàn)的位置，返回值如果是-1，說明沒找到

var str = "hello world"; console.log(str.indexOf("h")); //0 // 不指定postion,默認postion=0 console.log(str.indexOf("o")); // 4 console.log(str.indexOf("o",5)); // 7// 從末尾查找 console.log(str.lastIndexOf("o")); //7// 沒找到返回-1 console.log(str.indexOf("s")); // -1

string.search(regexp)

作用：search方法和indexof方法類似，但是只能接受一個正則表達式作為參數(shù)

var str = "hey JudE"; var re = /[A-Z]/g; var re2 = /[.]/g; console.log(str.search(re)); // returns 4, 對應的是 "J" console.log(str.search(re2)); // returns -1，沒能找到 '.'

string.substring(start,end)

作用：截取字符串（缺點參數(shù)start,end不能是負數(shù)）

string.slice(start,end)

作用：和substring功能類似，但是它的參數(shù)start,end 可以接受負數(shù)（請盡量使用slice，而不是substring，slice比substring更加強大)

var str = "hello world"; console.log(str.substring(6,str.length)); //world console.log(str.slice(6,str.length));//world// 但是substring 不支持 負數(shù) console.log(str.substring(-5,str.length)); // 它會輸出一個不合理的值 console.log(str.slice(-5,str.length)); // world/*** 當時用str.slice 時，-1對應的就是最后一個字符* 上例中 * -1 對應的是 字母d* -2 對應的是倒數(shù)第二個 也就是 字母l* 請盡量用slice 取代 substring*/

string.split(separator,limit)

作用：字符串轉(zhuǎn)數(shù)組

/*** string.split * 參數(shù)介紹：* separator:分隔符* limit: 生成數(shù)組元素個數(shù) */ var str = "1,2,3"; var arr = str.split(",",2); console.log(arr); // ["1", "2"]

string.toLowerCase()

作用：字符串全部轉(zhuǎn)小寫

string.toUpperCase()

作用：字符串全部轉(zhuǎn)大寫

var str = "Hello WORLD"; console.log(str.toLowerCase()); //hello world console.log(str.toUpperCase()); //HELLO WORLD

Date

date.toLocaleString()

作用：轉(zhuǎn)化成本地時間，包含完成的年月日和時分秒。

date.toLocaleDateString()

作用：轉(zhuǎn)化成本地時間，包含完成的年月日。

date.toLocaleTimeString()

作用：轉(zhuǎn)化成本地時間，包含完成的時分秒。

var date = new Date();console.log(date.toLocaleDateString());// 日期 2020/7/23console.log(date.getFullYear()); // 2020 console.log(date.getMonth()); //6 console.log(date.getDate()); // 23console.log(date.toLocaleTimeString()); //上午10:44:26console.log(date.getHours()); // 10 console.log(date.getMinutes()); // 44 console.log(date.getSeconds()); // 26console.log(date.toLocaleString()); // 2020/7/23 上午10:47:45var date = new Date(2020,01,02,11,11,11); // 依次為 年，月，日，時，分，秒 // 2020/2/2 上午11:11:11 實際月份 = 設置的+1 console.log(date.toLocaleString());

好了，這就是全部內(nèi)容了，如果覺得對你有所幫助的話就點個贊吧。

么么噠

總結(jié)

以上是生活随笔為你收集整理的【必备知识点】JavaScript里面那些天天使用的API的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。