數組

重排

1.reverse（）：反轉數組項的順序

注：使用該方法會同時改變原來數組的順序，而不是返回一個副本

例：

let arr = [1,2,3,4,5];

console.log(arr.reverse());//[ 5, 4, 3, 2, 1 ]

console.log(arr);//[ 5, 4, 3, 2, 1 ]

2.sort()：按照升序順序排列數組每一項

例：

let arr = [0,12,3,7,-12,23];

console.log(arr.sort());

//[ -12, 0, 12, 23, 3, 7 ]

能夠看到，咱們調用sort（）方法後排序並無正確的按照升序來排序。

緣由是sort（）方法排序會先調用每個元素的toString（）轉型方法，而後比較獲得的字符串，即便每一項都是數值，sort（）方法比較的也是字符串

解決辦法：sort（）能夠接受一個比較函數做爲參數

例：

let arr = [0,12,3,7,-12,23];

console.log(arr.sort(function(a,b){

if(a < b){

return -1;

}else if(a > b){

return 1;

}else{

return 0;

}

}));

若是要進行降序排列只須要將返回值修改便可。

固然，還有一種更簡單的方法，

例：

let arr = [0,12,3,7,-12,23];

console.log(arr.sort(function(a,b){

return a - b;

//降序就返回 b - a

}));

注：reverse（）和sort（）返回值是通過排列後的數組

位置

1.indexOf（）：查找項目索引，他是從數組開頭開始找，若是沒找到就返回-1

例：

let arr = ["H","e","l","l","o"];

console.log(arr.indexOf("l"));//2

console.log(arr.indexOf("z"));//-1

2.lastIndexOf（）：查找起點位置索引，從數組末尾開始找，沒找到就返回-1

例：

let arr = ["H","e","l","l","o"];

console.log(arr.lastIndexOf("l"));//3

console.log(arr.indexOf("z"));//-1

3.includes（）：查看數組是否包含某個元素，是就返回true，不然返回false

例：

let arr = ["1","2","3"];

console.log(arr.includes(2));//flase

console.log(arr.includes("2"));//true

console.log(arr.includes(7));//false

集合

Set集合是一種無重複（重點！！！）元素的列表，這是這種數據結構最大的特色。

建立集合

let s1 = new Set();

let s2 = new Set([1,2,3]);

console.log(s1);//Set {}

console.log(s2);//Set { 1, 2, 3 }

注：JS中嚴格區分大小寫

添加

咱們能夠用add（）給集合添加值

例：

let s1 = new Set();

s1.add(1);

console.log(s1);//Set { 1 }

s1.add(2).add(3).add(4);

console.log(s1);

//Set { 1, 2, 3, 4 }

例2：

let s1 = new Set();

s1.add([1,2,3]);

console.log(s1);

//Set { [ 1, 2, 3 ] }

相關屬性和方法

1.size:

它能夠獲取元素的個數，和數組的length類似

例：

let s1 = new Set([1,2,3]);

console.log(s1.size);//3

2.has（）：

它能夠查看一個集合中是否包含某一個值

例：

let s1 = new Set([1,2,3]);

console.log(s1.has(1));//true

console.log(s1.has("1"));//false

3.delete：

它能夠刪除Set對象裏某一個元素

例：

let s1 = new Set([1,2,3]);

s1.delete(2);

console.log(s1);//Set { 1, 3 }

s1.delete("2");

console.log(s1);//Set { 1, 3 }

注：delete沒法刪除集合中的數組

4.clear（）：

它能夠刪除全部的元素

例：

let s1 = new Set([1,2,3]);

s1.clear()

console.log(s1);//Set {}

注：它將一次清空集合的全部內容，包括刪除數組

遍歷

1.for-of：

let s = new Set([1,2,3,4,5]);

for(let i of s){

console.log(i);

}// 1

// 2

// 3

// 4

// 5

2.forEach：

//使用forEach進行遍歷

let s = new Set([1,2,3,4,5]);

s.forEach(ele => console.log(ele));

// 1

// 2

// 3

// 4

// 5

3.keys（）：

它能夠遍歷集合的鍵：

let s = new Set(["Bill","Lucy","David"]);

for(let i of s.keys()){

console.log(i);

}

// Bill

// Lucy

// David

4.values（）：

它能夠遍歷集合的值：

let s = new Set(["Bill","Lucy","David"]);

for(let i of s.values()){

console.log(i);

}

// Bill

// Lucy

// David

5.entries（）：

它能夠遍歷集合的鍵和值：

let s = new Set(["Bill","Lucy","David"]);

for(let i of s.entries()){

console.log(i);

}

//由於未設定值，因此返回的是它自己

// [ 'Bill', 'Bill' ]

// [ 'Lucy', 'Lucy' ]

// [ 'David', 'David' ]

集合轉數組

let s1 = new Set([1,2,3]);

console.log(s1);//Set { 1, 2, 3 }

let arr = [...s1];

console.log(arr);//[ 1, 2, 3 ]

或者使用Array對象提供的from（）方法轉換：

let s1 = new Set([1,2,3]);

console.log(s1);//Set { 1, 2, 3 }

let arr = Array.from(s1);

console.log(arr);//[ 1, 2, 3 ]

注：由於集合不能存放相同的元素，因此能夠用這種方法給數組去重

弱集合

let arr = [1,2,3];

let s = new Set(arr);

arr = null;//刪除arr數組的指向

console.log(s);//Set { 1, 2, 3 }數組依然存在在集合中

console.log(arr);//null

注：這就是刪除數組，但沒法刪除

1.內存泄漏

也就是站着空間卻沒有用，形成內存浪費，瀏覽器使用變慢

例：

let arr = [1,2,3];

arr = null;

解決方法：在JS中採用的是動態內存管理技術，例如垃圾回收機制，會自動從內存中刪除再也不被程序須要的東西。

注：弱集合沒法在建立弱集合時傳入一個數組進行初始化，不過弱集合也有has(),add(),delete()等方法

映射

JS對象，本質上是鍵值對的集合，爲了解決這個問題，ES6提供了Map數據結構。

它相似對象，也是鍵值對的集合，它提供了「值-值」的對應，是一種更完善的Hash結構的實現

建立映射

let m = new Map();

m.set("name","xiejie");

m.set("age",18);

console.log(m);

//Map { 'name' => 'xiejie', 'age' => 18 }

console.log(m.get("name"));

//xiejie

注：JS中嚴格區分大小寫

在對象中沒法用對象最爲對象屬性的鍵名。而在Map映射中卻能夠這樣作，能夠說在Map映射裏面可使用任意數據類型做爲鍵：

let m = new Map();

m.set({},"xiejie");

m.set([1,2,3],18);

m.set(3581,18);

console.log(m);

//Map { {} => 'xiejie', [ 1, 2, 3 ] => 18, 3581 => 18 }

相關屬性和方法

在映射中一樣支持：

has(key)：檢查制定的鍵名在Map映射中是否存在

delete（key）：從Map映射中移除指定鍵名及對應的值

clear（）：移除Map映射中全部的鍵值

Map映射一樣支持size屬性，其表明當前集合中包含的鍵值對數量：

let arr = [["name","xiejie"],["age",18]];

let m = new Map(arr);

console.log(m);//Map { 'name' => 'xiejie', 'age' => 18 }

console.log(m.size);//2

console.log(m.has("name"));//true

console.log(m.get("name"));//xiejie

m.delete("name");

console.log(m);//Map { 'age' => 18 }

m.clear();

console.log(m);//Map {}

遍歷

1.for-of：

let m = new Map([["name","xiejie"],["age",18]]);

for(let i of m){

console.log(i);

}

// [ 'name', 'xiejie' ]

// [ 'age', 18 ]

2.keys（）：

遍歷映射的鍵

let m = new Map([["name","xiejie"],["age",18]]);

for(let i of m.keys()){

console.log(i);

}

// name

// age

3.values（）：

遍歷映射的值：

let m = new Map([["name","xiejie"],["age",18]]);

for(let i of m.values()){

console.log(i);

}

// xiejie

// 18

4.entries（）：

遍歷映射的鍵和值：

let m = new Map([["name","xiejie"],["age",18]]);

for(let i of m.entries()){

console.log(i);

}

// [ 'name', 'xiejie' ]

// [ 'age', 18 ]

映射轉數組

let arr = [["name","xiejie"],["age",18]];

let m = new Map(arr);

console.log([...m.keys()]);//[ 'name', 'age' ]

console.log([...m.values()]);//[ 'xiejie', 18 ]

console.log([...m.entries()]);//[ [ 'name', 'xiejie' ], [ 'age', 18 ] ]

console.log([...m]);//[ [ 'name', 'xiejie' ], [ 'age', 18 ] ]

或者使用Array對象的from（）方法：

let arr = [["name","xiejie"],["age",18]];

let m = new Map(arr);

console.log(Array.from(m));

//[ [ 'name', 'xiejie' ], [ 'age', 18 ] ]

弱映射

主要是解決存在映射內部的垃圾數據問題

let weakMap = new WeakMap();

注：弱映射和普通映射同樣，具備has()，get(),set(),delete()等方法

函數

函數能夠經過名稱來引用，像是自包含了一個微型程序的代碼塊。

利用函數，咱們能夠實現對代碼的重複使用。

聲明函數的方法

1.字面量聲明函數：

function 函數名(形式參數){

//函數體

}

函數名：咱們調用函數須要書寫的標識符

形式參數：簡稱形參，調用函數須要接收的函數

實際參數：簡稱實參，調用函數時實際傳遞過去的參數

注：函數和數據同樣，命名不可用關鍵字和保留字

例：

function test(name){

console.log("Hello,"+name);

}

test("xiejie");//Hello,xiejie

2.函數表達式聲明函數

let ݒ變量 = function(){

//函數體

}

例：

let test = function(name){

console.log("Hello,"+name);

}

test("xiejie");//Hello,xiejie

例2：

let test = function saySth(name){

console.log("Hello,"+name);

}test("xiejie");//Hello,xiejie

3.構造器聲明函數

let 變量 = new Function("參數","參數","函數體");

例：

let test = new Function("name","console.log('Hello,'+name)");

test("xiejie");//Hello,xiejie

注：雖然這種方法也能建立函數而且調用，但並不託件，由於這樣會致使JS解析器解析兩次代碼

調用

let test = function(){

console.log("Hello")

}let i = test;//沒有調用函數，而是將test函數賦值給了i

i();//Hello

返回值

函數的返回值關鍵字爲return

例：

let test = function(){

return "Hello";

}

let i = test();

console.log(i);//Hello

即便不寫return，函數自己也有返回值undefined

例：

let test = function(){

console.log("Hello")

}

let i = test();//Hello

console.log(i);//undefined

注：return關鍵字只返回一個值

函數參數

參數分兩種，一個是實際參數，一個是形式參數

參數聲明不須要添加關鍵字，添加反而會報錯

例：

function test(let i){

console.log(i);

}

test(5);

//SyntaxError: Unexpected identifier

形參：

1.參數能夠重名，重名取最後一個參數：

function test(x,x){

console.log(x);

}

test(3,5);//5

2.即便函數聲明瞭參數，調用時也能夠不傳遞參數值：

function test(x){

console.log(x);

}

test();//undefined

3.調用函數能夠傳遞若干個參數值給函數，而不是管函數聲明時有幾個參數：

function test(x){

console.log(x);//1

}

test(1,2,3);

當一個函數要執行時，系統會在執行函數體代碼前作一些初始化工做，例爲函數建立一個arguments的僞數組對象，它將包含調用函數時傳遞全部的實際參數

例：

function test(x){

for(let i=0;i<arguments.length;i++){

console.log(arguments[i]);

}

}

test(1,2,3);

// 1

// 2

// 3

不定參數

它是ES6新增的功能，在最後一個形參前面添加3個點，會將全部的實參放到一個數組內：

function test(a,...b){

console.log(a);//1

console.log(b);//[2,3]

}

test(1,2,3);

注：不定參數是放在形參最後，若否，則報錯

默認參數

從ES6開始，書寫函數給函數形參一個默認值，這樣調用函數沒有傳入相應的實參，就會使用默認值，若是傳入了實參，就會使用實參：

function test(name = "world"){

console.log("Hello,"+name);

}test("xiejie");//Hello,xiejie

test();//Hello,world

屬性和方法

1.name屬性：

表示函數的名字：

function test(){

console.log("Hello")

}

console.log(test.name);//test

2.length屬性

表示形參的個數：

let test = function(a,b,c){

console.log("Hello")

}

console.log(test.length);//3

3.caller屬性：

它不是arguments對象的，而是函數對象自己的屬性，他先是函數的調用者，若是函數是在全局執行環境中（瀏覽器中）被調用，它的值爲null，若是在另外一個函數被調用，它的值就是那個函數

全局執行環境中被調用：

瀏覽器中：

<body>

<script>

let test = function(){

console.log(test.caller) }

test();//null

</script>

</body>

node中：

let test = function(){

console.log(test.caller)

}

test();//[Function]

被另外一個函數調用：

let test = function(){

let test2 = function(){

console.log(test2.caller);

//[Function: test]

//由於這個函數的調用者就是test函數

}

test2();

}

test();

4.callee屬性：

它是arguents對象的一個屬性，它是一個指針，指向擁有arguments對象的函數：

let test = function(){

let test2 = function(){

let test3 = function(){

console.log(arguments.callee);

//[Function: test3]

}

test3();

}

test2();

}

test();

它可以找到arguments對象所屬的函數，不讓函數的執行和函數名僅僅的關聯在一塊兒：

//計算階乘的遞歸函數

let test = function(i){

if(i == 1){

return 1;

}else{

return i * test(i-1);//這裏就和函數名牢牢地關聯了起來

}

}console.log(test(3));