摘要：函數(shù)可以沒(méi)有返回值，會(huì)在最后面返回一個(gè)。事物的行為在對(duì)象中用方法來(lái)表示。

為什么會(huì)有函數(shù)？

在寫(xiě)代碼的時(shí)候，有一些常用的代碼需要書(shū)寫(xiě)很多次，如果直接復(fù)制粘貼的話，會(huì)造成大量的代碼冗余；
函數(shù)可以封裝一段重復(fù)的javascript代碼，它只需要聲明一次，就可以多次調(diào)用；

冗余代碼：

冗余：多余的重復(fù)或啰嗦內(nèi)容

缺點(diǎn)：

代碼重復(fù)，可閱讀性差

不易維護(hù)，如果代碼邏輯變了，所有地方的代碼都要跟著改，效率太低了

函數(shù)聲明的語(yǔ)法：

var 是用來(lái)聲明變量的， 函數(shù)是用function來(lái)聲明的，一個(gè)函數(shù)一般是用來(lái)做一件事情的。

function 函數(shù)名 (){
    //函數(shù)體
}

函數(shù)聲明的時(shí)候，函數(shù)體并不會(huì)執(zhí)行，只要當(dāng)函數(shù)被調(diào)用的時(shí)候才會(huì)執(zhí)行。

調(diào)用函數(shù)的語(yǔ)法：

函數(shù)名();

函數(shù)體只有在調(diào)用的時(shí)候才會(huì)執(zhí)行，調(diào)用需要()進(jìn)行調(diào)用。可以調(diào)用多次

示例代碼：

// 聲明函數(shù)
function sayHi (){
    // 函數(shù)體
    console.log("Hi!!");
}
// 調(diào)用這個(gè)函數(shù)
sayHi();  // console.log("Hi!!");

// 注意
console.log(sayHi);  // 打印的是整個(gè)函數(shù) 
// sayHi:指的就是這個(gè)函數(shù)
// ():指的是調(diào)用
// sayHi():這個(gè)函數(shù)的調(diào)用結(jié)果

1、函數(shù)聲明(命名函數(shù))：

// 聲明一個(gè)函數(shù)并且命名了
function 函數(shù)名(){
    函數(shù)體;
}
函數(shù)名();  // 調(diào)用函數(shù)

/********示例代碼***********/
function fn(){
    console.log("哈哈哈");
}
fn();

2、函數(shù)表達(dá)式(匿名函數(shù))：

// 必須先聲明才能調(diào)用
var 函數(shù)名 = function(){
    函數(shù)體;
}
函數(shù)名(); // 調(diào)用函數(shù)

/********示例代碼***********/
var fn = function(){
    console.log("哈哈哈");
}
fn();

這兩種函數(shù)的區(qū)別：

命名函數(shù)可以先調(diào)用，再聲明，因?yàn)轭A(yù)解析

函數(shù)表達(dá)式必須先聲明，再調(diào)用（在DOM中注冊(cè)事件的時(shí)候用的非常的多）

匿名函數(shù)：

沒(méi)有名字的函數(shù)，叫做匿名函數(shù)。匿名函數(shù)沒(méi)有辦法直接用，需要賦值給變量或者自調(diào)用

自調(diào)用函數(shù)也叫自執(zhí)行函數(shù)，聲明和調(diào)用一起

可以防止變量全局污染

匿名函數(shù)自調(diào)用示例代碼：

(function(n1,n2){
    console.log(n1);        // 1
    console.log(n2);        // 2
    var name = "張三"
    var age = 18;
    function sayHello() {
      console.log(age);     // 18
      console.log(name);    // "張三"
    }
    sayHello();
})(1,2)

形式參數(shù)： 在聲明一個(gè)函數(shù)的時(shí)候，為了函數(shù)的功能更加靈活，有些值是固定不了的，對(duì)于這些固定不了的值。我們可以給函數(shù)設(shè)置參數(shù)。這個(gè)參數(shù)沒(méi)有具體的值，僅僅起到一個(gè)占位置的作用，我們通常稱之為形式參數(shù)，也叫形參。
實(shí)際參數(shù)： 如果函數(shù)在聲明時(shí)，設(shè)置了行參，那么在函數(shù)調(diào)用的時(shí)候就需要傳入對(duì)應(yīng)的參數(shù)，我們把傳入的參數(shù)叫做實(shí)際參數(shù)，也叫實(shí)參。

語(yǔ)法：

//帶參數(shù)的函數(shù)聲明
function 函數(shù)名(形參1, 形參2, 形參...){
  //函數(shù)體
}

//帶參數(shù)的函數(shù)調(diào)用
函數(shù)名(實(shí)參1, 實(shí)參2, 實(shí)參3);

特點(diǎn)：

在函數(shù)調(diào)用的時(shí)候，需要傳遞對(duì)應(yīng)的參數(shù)，把實(shí)參的值賦值給形參。

實(shí)參如果多于形參的個(gè)數(shù)：多傳的參數(shù)就丟棄了

實(shí)參如果少于形參的個(gè)數(shù)：沒(méi)有傳的參數(shù)，值就是undefined。（容易出問(wèn)題）

示例代碼：

// 設(shè)置兩個(gè)形參
function getSum(num1,num2){
    console.log(num1+num2);
}
// 調(diào)用的時(shí)候傳兩個(gè)值進(jìn)去
getSum(10,20);   // 打印出來(lái)就是 30

計(jì)算n1-n2之間所有數(shù)的乘積：

function getProduct(n1, n2) {
    var product = 1;
    for (var i = n1; i <= n2; i++) {
        product *= i;
    }
    console.log(product);
}
getProduct(1, 5);  // 120

當(dāng)函數(shù)執(zhí)行完的時(shí)候，我們期望函數(shù)給我一些反饋（比如計(jì)算的結(jié)果），這個(gè)時(shí)候可以讓函數(shù)返回一些東西。也就是返回值。函數(shù)通過(guò)return返回一個(gè)返回值

返回值語(yǔ)法：

//聲明一個(gè)帶返回值的函數(shù)
function 函數(shù)名(形參1, 形參2, 形參...){
  //函數(shù)體
  return 返回值;
}

//可以通過(guò)變量來(lái)接收這個(gè)返回值
var 變量 = 函數(shù)名(實(shí)參1, 實(shí)參2, 實(shí)參3);

函數(shù)的調(diào)用結(jié)果就是返回值，因此我們可以直接對(duì)函數(shù)調(diào)用結(jié)果進(jìn)行操作。

示例代碼：

// 計(jì)算 n1- n2之間所有數(shù)的乘積
function getProduct(n1, n2) {
    var product = 1;
    for (var i = n1; i <= n2; i++) {
        product *= i;
    }
    return product; // 返回計(jì)算的值
}
var pro = getProduct(1, 5); // 用變量pro接收一下返回的值
console.log(pro);   // 120

注意：

函數(shù)一碰到return，就代表函數(shù)結(jié)束了。return后面的代碼不會(huì)執(zhí)行了。

函數(shù)可以沒(méi)有返回值， 會(huì)在最后面返回一個(gè)undefined。

函數(shù)三要素包括：

函數(shù)名

參數(shù)

返回值

關(guān)于文檔注釋，javascript中還有一種注釋叫做文檔注釋，經(jīng)常用在函數(shù)聲明處，用來(lái)解釋這個(gè)函數(shù)的作用。

文檔注釋： /** 這是文檔注釋 */

以后寫(xiě)的函數(shù)的聲明，都應(yīng)該加上文檔注釋，方便閱讀

示例代碼：

/**
 * 求圓的面積
 * @param r {number} 圓的半徑
 * @returns {number} 圓的面積
 */
function getArea (r) {
    return Math.PI * r * r;
}

1、對(duì)任意數(shù)組從小到大排序

// 封裝一個(gè)從小到大冒泡排序的函數(shù)
function bubbleSort(arr){
    for(var i = 0; i < arr.length - 1; i++){
        var flag = true;
        for(var j = 0; j < arr.length -1 -i; j++){
            if(arr[j] >arr[j+1]){
                flag =false;
                var temp = arr[j];
                arr[j] = arr[j+1];
                arr[j + 1] = temp;
            }
        }
        if(flag){
            break;
        }
    }
    return arr;
}
console.log(bubbleSort([12, 56, 14, 68, 45, 25, 17, 33]));
console.log(bubbleSort([25, 65, 48, 11, 15, 54, 24, 63]));

2、求任意數(shù)的階乘(從1到n的積)

function getProduct (n){
    var product = 1; 
    for(var i = 1; i <= n; i++){
       product *= i; 
    }
    return product;
}
console.log(getProduct(5));  // 120
console.log(getProduct(3));  // 6   

3、求任意數(shù)組中的最大值與最小值

function getMaxAndMin(arr) {
    var max = arr[0];
    var min = arr[0];
    for (var i = 0; i < arr.length; i++) {
        if (max < arr[i]) {
            max = arr[i];
        }
        if (min > arr[i]) {
            min = arr[i];
        }
    }
    return [max, min]; // 返回一個(gè)數(shù)組
}
console.log(getMaxAndMin([11, 45, 59, 12, 8, 36, 14, 25]));  // [59 8]

在函數(shù)中，只有全局作用域和函數(shù)作用域，因?yàn)樵?b>if、while、for等語(yǔ)句中定義的變量都是全局變量。

全局變量： 在最外層聲明的變量就是全局變量，全局變量在任何地方都能訪問(wèn)的到。

局部變量： 在函數(shù)中聲明的變量，就是局部變量，局部變量只有在當(dāng)前函數(shù)體內(nèi)能夠訪問(wèn)。

隱式全局變量： 沒(méi)有使用var定義的變量也是全局變量。

作用域： 變量可以發(fā)揮作用的區(qū)域

全局作用域： 在script標(biāo)簽內(nèi)，函數(shù)外定義的作用域就是全局作用域。在全局作用域中定義的變量都是全局變量。

函數(shù)作用域： 在函數(shù)中的區(qū)域叫做函數(shù)作用域，在函數(shù)作用域中定義的變量就是局部變量，只能在當(dāng)前函數(shù)內(nèi)訪問(wèn)。

js解析器執(zhí)行js代碼的時(shí)候，分為兩個(gè)過(guò)程：預(yù)解析過(guò)程和代碼執(zhí)行過(guò)程

預(yù)解析過(guò)程：

把變量的聲明提升到當(dāng)前作用域的最前面，只會(huì)提升聲明，不會(huì)提升賦值。

把函數(shù)的聲明提升到當(dāng)前作用域的最前面，只會(huì)提升聲明，不會(huì)提升調(diào)用。

先提升var，再提升function

預(yù)解析例題：

第一題：

console.log(a);    // 打印a這個(gè)函數(shù)整體
var a = 1;
function a(){
console.log("呵呵");
}
console.log(a);    // 1

// 預(yù)解析后為
/**
var a;
function a(){
    console.log("呵呵");
}
console.log(a);    // 打印a這個(gè)函數(shù)整體
a = 1;
console.log(a);    // 1
*/

第二題：

var num = 10;
fn1();
function fn1() {
    //在函數(shù)調(diào)用的時(shí)候，這個(gè)函數(shù)也會(huì)做預(yù)解析操作。
    console.log(num);   // undefined
    var num = 20;
    console.log(num);   // 20
}
console.log(num);       // 10


// 預(yù)解析后為
/**
var num ;
function fn1() {
    var num;
    console.log(num);   // undefined
    num = 20;
    console.log(num);   // 20
}
num = 10;
fn1();
console.log(num);       // 10
*/

第三題：

var a = 18;
var b = 30;
fn();
function fn() {
    var b = 9;
    console.log(a); // undefined
    console.log(b); // 9
    var a = 20;
}


// 預(yù)解析后為
/**
var a;
var b;
function fn() {
    var b;
    b = 9;
    var a;
    console.log(a);     // 自己作用域里有的就不要出去找
    console.log(b);     // 9
    a = 20;
}
a = 18;
b = 30;
fn();
*/

第四題：

fn();
var b = 10;
console.log(c); // 9
console.log(b); // 10
console.log(a); // 報(bào)錯(cuò)

function fn() {
    var a = 9;
    b = 9;
    c = 9;
    console.log(a); // 9
    console.log(b); // 9 
    console.log(c); // 9
}


// 預(yù)解析之后
/**
var b;
function fn() {
    var a;
    a = 9;
    b = 9;
    c = 9;
    console.log(a); // 9
    console.log(b); // 9
    console.log(c); // 9
}
fn();
b = 10;
console.log(c); // 9
console.log(b); // 10
console.log(a); // 報(bào)錯(cuò)
*/

第五題：

function fn() { 
    console.log(num1);  // undefined
    console.log(num2);  // undefined
    console.log(num3);  // 30
    var num1 = 10;
    var num2 = 20;
    num3 = 40;
    console.log(num1);  // 10
    console.log(num2);  // 20
    console.log(num3);  // 40
}
var num1 = 20;
var num3 = 30;
fn();
console.log(num1);      // 20
console.log(num3);      // 40
console.log(num2);      // 報(bào)錯(cuò)


// 預(yù)解析之后
/**
var num1;
var num3;

function fn() {
    var num1;
    var num2;
    console.log(num1); // undefined
    console.log(num2); // undefined
    console.log(num3); // 30
    num1 = 10;
    num2 = 20;
    num3 = 40;
    console.log(num1); // 10
    console.log(num2); // 20
    console.log(num3); // 40
}
num1 = 20;
num3 = 30;
fn();
console.log(num1); // 20
console.log(num3); // 40
console.log(num2); // 報(bào)錯(cuò)
*/

函數(shù)直接或者間接調(diào)用自己，必須要留出口，不然就調(diào)死了

示例代碼：

// 用遞歸求1-100的和
/* 
    之前封裝過(guò)一個(gè)getSum的函數(shù)比如getSum(100)，就是求的1-100的和
    現(xiàn)在我們可以這樣理解：
    1-100的和我們可以看做是 100 + getSum(99)
    getSum(99) 可以看成 99 + getSum(98)。。。
    依次這樣推下去，但是要注意，到getSum(1)的時(shí)候,要留出口，否則會(huì)一直死循環(huán)下去
 */
function getSum(n) {
    if (n == 1) {       // 一定要留出口
        return 1;
    }
    return n + getSum(n - 1);
}
console.log(getSum(100));

回調(diào)函數(shù)：把函數(shù)當(dāng)成參數(shù)來(lái)使用，那么這個(gè)函數(shù)就叫回調(diào)函數(shù)。函數(shù)也是一種數(shù)據(jù)類型

示例代碼：

/*
思考，之前封裝了一個(gè)bubbleSort排序的函數(shù)，但是只能排元素是數(shù)字的數(shù)組
現(xiàn)在想要判斷字符串的長(zhǎng)度，或者對(duì)象的屬性的時(shí)候就很麻煩，就需要重新寫(xiě)一個(gè)函數(shù)
比如字符串長(zhǎng)度，就需要是arr[j].length - arr[i+1].length
*/
function bubbleSort(arr, fn) {
    for (var i = 0; i < arr.length; i++) {
        var flag = true;
        for (var j = 0; j < arr.length - 1 - i; j++) {
        
            // 傳一個(gè)函數(shù)進(jìn)來(lái)，并且將arr[j], arr[j + 1]作為兩個(gè)參數(shù)傳進(jìn)去
            if (fn(arr[j], arr[j + 1]) > 0) {
                flag = false;
                var temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        if (flag) {
            break;
        }
    }
}
// 純數(shù)字?jǐn)?shù)組
var arr = [4, 3, 1, 6, 22, 21, 41, 4];
// 調(diào)用的時(shí)候，我們需要將fn函數(shù)的兩個(gè)參數(shù)也傳進(jìn)去
// 這種把一個(gè)函數(shù)作為參數(shù)傳進(jìn)另一個(gè)函數(shù)的方式就叫回調(diào)函數(shù)
bubbleSort(arr, function(a, b) { // a b 就相當(dāng)于 arr[j] 和 arr[j+1]
    return a - b;
    // 如果是 return b - a 就相當(dāng)于，上面的 arr[j+1] - arr[j]>0 那么就是從大到小排序 
});
console.log(arr);

// 封裝后的排序函數(shù)也可以直接根據(jù)字符串的長(zhǎng)度進(jìn)行排序了
var arrStr = ["aaa", "bb", "cccc", "d"];
bubbleSort(arrStr, function(a, b) {
    // 因?yàn)閭鬟M(jìn)去的是一個(gè)函數(shù)，arr[j] 和 arr[j+1]是以兩個(gè)參數(shù)的形式傳進(jìn)去的
    // 當(dāng)數(shù)組元素是字符串的時(shí)候，就可以進(jìn)行.length操作了
    return a.length - b.length;
});
console.log(arrStr);

無(wú)序的鍵值對(duì)集合

為什么要有對(duì)象？

在javascript中：對(duì)象跟數(shù)組、函數(shù)一樣，都是一種復(fù)雜數(shù)據(jù)類型，是一系列相關(guān)的屬性的集合，可以很方便對(duì)變量和函數(shù)進(jìn)行管理。

什么是對(duì)象？

現(xiàn)實(shí)生活中: 萬(wàn)物皆對(duì)象，對(duì)象是一個(gè)具體的事物，一個(gè)具體的事物就會(huì)有行為和特征。
javascript: javascript中的對(duì)象其實(shí)就是生活中對(duì)象的一個(gè)抽象。

事物的特征在對(duì)象中用屬性來(lái)表示。

事物的行為在對(duì)象中用方法來(lái)表示。

對(duì)象中的方法，其實(shí)就是對(duì)象里面的函數(shù)。

舉個(gè)例子：

特征：名字、性別、年齡、身高、體重、愛(ài)好、星座、血型    (屬性)
行為：罰錢、吃肉、打招呼                             (方法: 對(duì)象里面的函數(shù))

通過(guò)var 對(duì)象名 = new Object();的方式創(chuàng)建一個(gè)對(duì)象，通過(guò)對(duì)象名.的語(yǔ)法，給這個(gè)對(duì)象添加屬性；通過(guò)通對(duì)象名.方法名 = function(){} 給這個(gè)對(duì)象加上一個(gè)方法。

示例代碼：

// 創(chuàng)建一個(gè)英雄對(duì)象，并且給他加上屬性和方法
var hero = new Object(); // 創(chuàng)建一個(gè)空的英雄對(duì)象

// 通過(guò)"."語(yǔ)法給這個(gè)hero加上一些屬性
hero.name = "蓋倫";         // 給對(duì)象添加了一個(gè)name的屬性
hero.skill = "正義審判";    // 給對(duì)象添加一個(gè)技能屬性

// 通過(guò) 對(duì)象名.方法名 = function(){} 給hero加上一個(gè)方法
hero.attack = function() {
  console.log("蓋倫攻擊了小怪物");
}
attack();

通過(guò)var 對(duì)象名 = {}的方式創(chuàng)建一個(gè)對(duì)象，通過(guò)鍵值對(duì)的方式，給這個(gè)對(duì)象加上屬性和方法。
字面量：11 "abc" true [] {}等   {}就相當(dāng)于 new Object();

示例代碼：

// 創(chuàng)建一個(gè)英雄對(duì)象，并且給他加上屬性和方法
var hero = {
    name  : "蓋倫",          // 鍵值對(duì)的形式給hero加上屬性
    skill : "正義審判",
    
    attcck : function(){    // 鍵值對(duì)的形式給hero加上方法
        console.log("蓋倫攻擊了小怪物");
    }
}

注意： 鍵值對(duì)之間用,號(hào)隔開(kāi)

示例代碼：

var hero = {
    name  : "蓋倫", 
    skill : "正義審判",
    
    attcck : function(){    
        // 這里的this指向的是當(dāng)前的對(duì)象，表示當(dāng)前對(duì)象下的skill屬性，如果直接寫(xiě)skill 是報(bào)錯(cuò)的
        console.log("蓋倫使用了"+this.skill+"攻擊了敵人");
    }
}

注意：

this一定要出現(xiàn)在方法中才有意義，不在方法中的this沒(méi)有意義。

在方法中出現(xiàn)的this，指的是當(dāng)前對(duì)象，即調(diào)用這個(gè)方法的對(duì)象

操作對(duì)象的屬性分為存值和取值

存值：

對(duì)象名.屬性名 = "值";

存值-示例代碼：

var obj = {
    age:18,
    name:"蓋倫"
};

// 存值
obj.hobby = "K人";
obj.age = 20;
console.log(obj); // {age:20,name:"蓋倫",hobby:"K人"}

存值-注意：

如果對(duì)象原來(lái)就有這個(gè)屬性，會(huì)覆蓋原來(lái)的值。

如果對(duì)象沒(méi)有這個(gè)屬性，就會(huì)新增加這個(gè)屬性。(屬性在對(duì)象中是獨(dú)一無(wú)二的)

取值：

對(duì)象名.屬性名

取值-示例代碼：

var obj = {
    age:18,
    name:"蓋倫"
};

// 取值
console.log(obj.age);  // 18
console.log(obj.name); // "蓋倫"

取值-注意：

如果對(duì)象有這個(gè)屬性，就會(huì)返回對(duì)應(yīng)的值

如果對(duì)象沒(méi)有這個(gè)屬性，就會(huì)返回undefined。

關(guān)聯(lián)數(shù)組的語(yǔ)法,把對(duì)象當(dāng)成數(shù)組來(lái)看待

存值：

對(duì)象名[屬性名(下標(biāo))] = "值"; 數(shù)組的下標(biāo)是數(shù)字，對(duì)象的下標(biāo)是字符串

存值-示例代碼：

var obj = {
    age:18,
    name:"蓋倫"
};

// 存值
obj["hobby"] = "K人";
obj["age"] = 20;
console.log(obj); // {age:20,name:"蓋倫",hobby:"K人"}

取值：

對(duì)象名[屬性名(下標(biāo))]

取值-示例代碼：

var obj = {
    age:18,
    name:"蓋倫"
};

// 取值
console.log(obj["age"]);  // 18
console.log(obj["name"]]); // "蓋倫"

注意： []語(yǔ)法是將對(duì)象當(dāng)數(shù)組看，數(shù)組的下標(biāo)是數(shù)字，對(duì)象的下標(biāo)是字符串，取值的時(shí)候一定要注意

當(dāng)屬性名是一個(gè)字符串存儲(chǔ)在變量中的時(shí)候，只能使用關(guān)聯(lián)數(shù)組的方式。

示例代碼：

var obj = {
    age:18,
    name:"蓋倫"
};
var temp = "age";
console.log(obj[temp]); // 打印 18 ==> obj["age"]
console.log(obj.temp);  //  點(diǎn)語(yǔ)法就不行，undefined 點(diǎn)語(yǔ)法會(huì)去對(duì)象中找temp的屬性

大部分情況，都用.語(yǔ)法，比較簡(jiǎn)單，如果屬性的名字存在一個(gè)變量中，只能用[]語(yǔ)法

通過(guò)for..in語(yǔ)法可以遍歷一個(gè)對(duì)象：for(var 鍵 in 對(duì)象)

示例代碼：

var hero = {
    name : "蓋倫",
    skill: "正義審判",

    attcck: function() {
        console.log("蓋倫使用了" + this.skill + "攻擊了敵人");
    }
}

for(var key in hero){      // key表示的是對(duì)象的屬性名
    console.log(key);      // 遍歷了所有的屬性名
    console.log(hero[key]); // 遍歷所有的值
    
    console.log(hero.key);  // undefined 這樣寫(xiě)是錯(cuò)的，找的是hero的key屬性
}

遍歷對(duì)象案例：

var datas = [
    {name:"露娜", age:18, score:100, gender:"男"},
    {name:"妲己", age:1000, score:101, gender:"女"},
    {name:"甄姬", age:888, score:102, gender:"女"},
    {name:"大喬", age:21, score:103, gender:"女"},
    {name:"小喬", age:22, score:104, gender:"女"}
];

document.write("");
for (var i = 0; i < datas.length; i++) {
    document.write("");
    var data = datas[i];
    for (var key in data) {
        document.write("");
    }
    document.write("");
}
document.write("
");
        document.write(data[key]);
        document.write("
");

效果圖：

注意：遍歷的時(shí)候for后面是鍵(屬性名)，in后面是對(duì)象

判斷一個(gè)對(duì)象中是否有某一屬性：

in關(guān)鍵字可以查看對(duì)象是否擁有某個(gè)屬性。

var obj = {
    name:"zs",
    age:18,
    score:100
}
//in關(guān)鍵字可以查看對(duì)象是否擁有某個(gè)屬性。
console.log( "sex" in obj );  // false
console.log( "name" in obj ); // true

1、typeof 查看對(duì)象類型

所有的復(fù)雜類型，使用typeof關(guān)鍵字的話，都是object

示例代碼：

var arr = new Array();
console.log(typeof arr);     // Object

var obj = new Object();
console.log(typeof obj);     // Object

var student = new Object();
console.log(typeof student); // Object

function fn(){
    
}
console.log(typeof student); // Function

注意：

typeof只能區(qū)分出來(lái)是復(fù)雜類型，并不能區(qū)分出具體類型

函數(shù)比較特殊，在js里面的地位比較高，typeof可以查看到它的類型

2、instanceof 查看對(duì)象類型

instance: 實(shí)例 這種方法也不能直接獲得對(duì)象的具體類型

示例代碼：

var arr = new Array();
console.log(arr instanceof Array);   // true 說(shuō)明arr的實(shí)例是Array

這種方法還是比較麻煩，看下面這種方法

3、.constructor.name 查看對(duì)象類型

借助于js原型里的constructor關(guān)鍵字，可以直接獲取到對(duì)象的具體類型

示例代碼：

var arr = new Array();
console.log(arr.constructor.name);   // Array

var obj = new Object();
console.log(obj.constructor.name);   // Object

1、使用普通函數(shù)批量創(chuàng)建對(duì)象

將創(chuàng)建對(duì)象封裝在一個(gè)函數(shù)里，需要批量創(chuàng)建對(duì)象的時(shí)候，只需調(diào)用這個(gè)函數(shù)即可

示例代碼：

// 封裝
function createObj(name,age,gender){
    var heros = new Object();
    student.name = name;
    student.age  = age;
    student.gender = gender;
    student.sayHello = function () {
        console.log("大家好,我是"+this.name);
    }
    return heros;
}

// 調(diào)用
var stu1 = createObj("露娜",15,"女");
console.log(stu1);  // 打印這個(gè)對(duì)象
stu1.sayHello();    // "大家好我是露娜"


var stu2 = createObj("小喬",800,"女");
console.log(stu2);  // 打印這個(gè)對(duì)象
stu2.sayHello();    // "大家好我是小喬"

優(yōu)點(diǎn)：可以同時(shí)創(chuàng)建多個(gè)對(duì)象
缺點(diǎn)：創(chuàng)建出來(lái)的沒(méi)有具體的類型，都是object類型的

2、構(gòu)造函數(shù)批量創(chuàng)建對(duì)象

構(gòu)造函數(shù) ，是一種特殊的函數(shù)。主要用來(lái)在創(chuàng)建對(duì)象時(shí)初始化對(duì)象(給對(duì)象加屬性和方法)，即為對(duì)象成員變量賦初始值，總與new運(yùn)算符一起使用在創(chuàng)建對(duì)象的語(yǔ)句中。
一般創(chuàng)建一個(gè)對(duì)象的時(shí)候直接new object出來(lái)的沒(méi)有具體的類型，都是object類型的，要想分類的更清楚就需要用到構(gòu)造函數(shù)創(chuàng)建對(duì)象
首字母需要大寫(xiě)，通常是名詞，表示一類對(duì)象。

語(yǔ)法：

// 首字母需要大寫(xiě)，通常是名詞，表示一類對(duì)象。
function Teacher(){
    // 函數(shù)體
}
var cjk = new Teacher();            // 如果沒(méi)有new, cjk就是一個(gè)普通的函數(shù)
console.log(cjk.constructor.name);  // 輸出的對(duì)象類型為 Teacher

示例代碼：

// 構(gòu)造函數(shù) this指向new出來(lái)的新對(duì)象
function Teacher(name, age){
    this.name = name;
    this.age = age;
    this.sayHello = function () {
        console.log("大家好，我是"+this.name+"，今天晚上我給大家唱首歌");
    }
}

// new 創(chuàng)建了一個(gè)空對(duì)象 類型為Teacher
var cjk = new Teacher("蒼井空", 18);
console.log(cjk);   // 對(duì)象的類型為Teacher {name:"蒼井空",age:18}

var bdyjy = new Teacher("波多野結(jié)衣", 19);
console.log(bdyjy); //  對(duì)象的類型為Teacher {name:"波多野結(jié)衣",age:19,sayHello:function(){}}
bdyjy.sayHello();   //  大家好，我是波多野結(jié)衣，今天晚上我給大家唱首歌

new做了四件事情：

new 會(huì)創(chuàng)建一個(gè)空的對(duì)象，并且對(duì)象的類型是new 后面跟的名字;

讓函數(shù)內(nèi)部的this指向這個(gè)空對(duì)象，操作this就相當(dāng)于操作了這個(gè)對(duì)象;

執(zhí)行構(gòu)造函數(shù)

返回這個(gè)對(duì)象

優(yōu)點(diǎn)：

創(chuàng)建出來(lái)的對(duì)象，類型是可變的

寫(xiě)法更加簡(jiǎn)潔

案例-批量創(chuàng)建一個(gè)英雄對(duì)象：

//屬性：名字、性別、技能、口號(hào)、等級(jí)、金錢
//行為：打怪獸

function Hero(name, gender, skill, slogan, level, money){
//給this加屬性和方法
    this.name = name;
    this.gender =gender;
    this.skill = skill;
    this.slogan = slogan;
    this.level = level;
    this.money = money;
    
    this.attack = function (n) {
      console.log(this.name + "使用了" + this.skill + "攻擊了" + n);
    }
}

var atm = new Hero("奧特曼", "不詳", "激光", "呵呵", 100, 0);
console.log(atm);      // 返回了一個(gè)Hero類型的對(duì)象
atm.attack("小怪獸");  // 奧特曼使用了激光攻擊了小怪獸

var dm = new Hero("蓋倫", "男", "大寶劍", "人在塔在", 18, 3150);
console.log(dm);       // 返回了一個(gè)Hero類型的對(duì)象
dm.attack("防御塔");   // 蓋倫使用了大寶劍攻擊了防御塔

1、值類型(簡(jiǎn)單數(shù)據(jù)類型)

值類型 : 又叫簡(jiǎn)單數(shù)據(jù)類型，例如：number、string、boolean、undefined、null
變量?jī)?chǔ)存數(shù)據(jù)的時(shí)候，存儲(chǔ)的直接就是這個(gè)值本身

示例代碼：

var num = 12;
var num1 = num;
num1 = 20;
console.log(num);   // 12
console.log(num1);  // 20

2、引用類型(復(fù)雜數(shù)據(jù)類型)

引用類型 ：又叫復(fù)雜數(shù)據(jù)類型，例如：Object、Function、Array和自定義類型

變量在儲(chǔ)存數(shù)據(jù)的時(shí)候，不會(huì)直接存儲(chǔ)這對(duì)象，存儲(chǔ)的是這個(gè)對(duì)象的地址

示例代碼：

var obj = {             // 在內(nèi)存中存儲(chǔ)了一個(gè)地址
    name: "凹凸曼",
    age: 100
}
    
var obj1 = obj;     // 把這個(gè)地址賦值給了obj1，obj1就有了obj的所有屬性
obj1.name = "奧特曼";   // 因?yàn)閛bj1 和 obj 用的是同一個(gè)地址，所以當(dāng)obj1的屬性值改變的時(shí)候，obj也會(huì)改變
console.log(obj.name);  // "奧特曼"
console.log(obj1.name); // "奧特曼"    

引用類型詳解：

//復(fù)雜類型變量不會(huì)存這個(gè)對(duì)象，只會(huì)存這個(gè)對(duì)象的地址。
var hero = {
    name: "大黃蜂",
    age: 100,
    car: {
        name: "科邁羅",
        price: 400000
    },
    brothers: ["擎天柱", "鐵皮", "救護(hù)車"]
};

console.log(hero.car.name);     // "科邁羅"
console.log(hero.brothers[0]);  // "擎天柱"

面試題(一)：

var num1 = 55;
var num2 = 66;
function f1(num, num1) {
    num = 100;
    num1 = 100;
    num2 = 100;
    console.log(num);   //100
    console.log(num1);  //100
    console.log(num2);  //100
}

f1(num1, num2);
console.log(num1);      //55
console.log(num2);      //100
console.log(num);       //報(bào)錯(cuò)

面試題(二)：

function Person(name, age) {
    this.name = name;
    this.age = age;
}
var p1 = new Person("zs", 18);
var p2 = p1;

p2 = new Person("ls", 20);

p2.name = "ww";

console.log(p1.name); // zs
console.log(p2.name); // ww

3、棧內(nèi)存與堆內(nèi)存

棧內(nèi)存: 空間比較小，但運(yùn)算速度非常的快
堆內(nèi)存：空間非常大，但運(yùn)算速度相對(duì)而言比較慢

簡(jiǎn)單類型有沒(méi)有屬性和方法？JS為了我們操作方便，內(nèi)置了對(duì)應(yīng)的復(fù)雜類型(String、Number、Boolean)

我們使用簡(jiǎn)單類型的時(shí)候，可以直接使用復(fù)雜類型的屬性和方法。(js會(huì)自動(dòng)幫我們把簡(jiǎn)單類型轉(zhuǎn)換成復(fù)雜類型。用完之后，又自動(dòng)的給我們轉(zhuǎn)成了簡(jiǎn)單類型)

簡(jiǎn)單類型： number string boolean undefined null

復(fù)雜類型： Object Function Array String Number Boolean

基本包裝類型：

對(duì)于string number boolean基本類型來(lái)說(shuō)，可以直接使用屬性和方法。

自動(dòng)把簡(jiǎn)單類型轉(zhuǎn)換成對(duì)應(yīng)的復(fù)雜類型

調(diào)用復(fù)雜類型的屬性或者方法得到結(jié)果

自動(dòng)的把復(fù)雜類型轉(zhuǎn)換成簡(jiǎn)單類型

不是數(shù)組，是對(duì)象， 叫偽數(shù)組（可以跟數(shù)組一樣的使用下標(biāo)，也可以遍歷）

var obj = {
    0:"呵呵",
    1:"哈哈",
    2:"嘻嘻",
    3:"嘿嘿嘿",
    4:"嗚嗚",
    length:5
}

for(var k in obj){
    console.log(obj[k]);
}

JavaScript中，arguments對(duì)象是比較特別的一個(gè)對(duì)象，實(shí)際上是當(dāng)前函數(shù)的一個(gè)內(nèi)置屬性。也就是說(shuō)所有函數(shù)都內(nèi)置了一個(gè)arguments對(duì)象，arguments對(duì)象中存儲(chǔ)了傳遞的所有的實(shí)參。arguments是一個(gè)偽數(shù)組，因此及可以進(jìn)行遍歷

示例代碼：

// Math.max 的原理是什么？
// 不知道形參個(gè)數(shù)的時(shí)候，怎么判別一個(gè)最大值或者最小值呢？
// arguments對(duì)象中 存儲(chǔ)的是所有的實(shí)參 是以一個(gè)偽數(shù)組的形式存在的
function max(){
    var m = arguments[0];
    // 所以不管你傳多少參數(shù)進(jìn)來(lái)，arguments就儲(chǔ)存多少參數(shù)
    for(var i = 0; i < arguments.length; i++) {
        if(m < arguments[i]){
            m = arguments[i];
        }
    }
    return m;
  }
}
console.log(max(1, 2, -1));     // 2
console.log(max(1, 2, 4, 10));  // 10

JSON(JavaScript Object Notation)是一種輕量級(jí)的數(shù)據(jù)交換格式，采用完全獨(dú)立于語(yǔ)言的文本格式，是理想的數(shù)據(jù)交換格式。同時(shí)，JSON是 JavaScript原生格式，這意味著在JavaScript中處理JSON數(shù)據(jù)跟處理對(duì)象是一樣的。

JSON的屬性必須用雙引號(hào)引起來(lái)，對(duì)象字面量可以省略

示例代碼：

// js里面，屬性名可以用雙引號(hào)引起來(lái)，也可以不引起來(lái)。
var obj = {
    name:"張三",
    age:18
}

// JSON屬性名必須用雙引號(hào)引起來(lái)
var json = {
    "name":"張三",
    "age":18
 }


//json是js對(duì)象    js對(duì)象不一定是json
console.log(json.name);     // "張三"
console.log(json["name"]);  // "張三"

json對(duì)象的兩個(gè)方法：

對(duì)象轉(zhuǎn)換為JSON格式使用：JSON.stringify；

JSON裝換為對(duì)象格式：JSONparse()；

JS內(nèi)置對(duì)象就是指Javascript自帶的一些對(duì)象，供開(kāi)發(fā)者使用，這些對(duì)象提供了一些常用的的功能。

常見(jiàn)的內(nèi)置對(duì)象有Math、String、Array、Date等

Math對(duì)象中封裝很多與數(shù)學(xué)相關(guān)的屬性和方法。Math對(duì)象比較特殊，不需要new。

1、屬性 PI

Math.PI 表示的就是圓周率，通常計(jì)算圓的周長(zhǎng)或者面積的時(shí)候會(huì)用到。也可以用作表示角度、弧度(π= 180°)

console.log(Math.PI);  // 3.141592653589793

2、最大值/最小值

Math.max(x,y) 表示求出兩者之間的最大值

console.log(Math.max(10,99)); // 返回99

Math.min(x,y) 表示求出兩者之間的最小值

console.log(Math.min(10,99)); // 返回10

3、取整

Math.ceil() 天花板函數(shù)(向上取整)

整數(shù)向上取整還是整數(shù)；

正小數(shù)向上取整，整數(shù)部分加1，小數(shù)部分舍去；

負(fù)小數(shù)向上取整，整數(shù)部分不變，小數(shù)部分舍去；

示例代碼：

console.log(Math.ceil(2));    // 2
console.log(Math.ceil(1.2));  // 2
console.log(Math.ceil(1.8));  // 2
console.log(Math.ceil(-1.2)); // -1
console.log(Math.ceil(-1.8)); // -1

Math.floor() 地板函數(shù)(向下取整)

整數(shù)向下取整還是整數(shù)；

正小數(shù)向下取整，整數(shù)部分不變，小數(shù)部分舍去；

負(fù)小數(shù)向下取整，整數(shù)部分減1，小數(shù)部分舍去；

示例代碼：

console.log(Math.floor(2));    // 2
console.log(Math.floor(1.2));  // 1
console.log(Math.floor(1.8));  // 1
console.log(Math.floor(-1.2)); // -2
console.log(Math.floor(-1.8)); // -2

Math.round() 四舍五入(如果是.5，則取更大的那個(gè)數(shù))

正小數(shù)四舍五入，對(duì)小數(shù)點(diǎn)后面一位數(shù)進(jìn)行判斷，大于等于5整數(shù)部分加1，小數(shù)舍去;小于5,整數(shù)部分不變，小數(shù)部分舍去

負(fù)小數(shù)四舍五入，對(duì)小數(shù)點(diǎn)后面一位進(jìn)數(shù)行判斷：

小于5的時(shí)候，小數(shù)舍去，整數(shù)部分不變；

大于5的時(shí)候，小數(shù)舍去，整數(shù)部分減 1；

等于5的時(shí)候要再判斷，如果后面沒(méi)有數(shù)了，小數(shù)舍去，整數(shù)部分不變；如果后面還有數(shù)，小數(shù)舍去，整數(shù)部分減 1；

示例代碼：

console.log(Math.round(1.2));    // 1
console.log(Math.round(1.5));    // 2
console.log(Math.round(1.56));   // 2
console.log(Math.round(1.6));    // 2

console.log(Math.round(-0.3));   // 0
console.log(Math.round(-0.6));   // -1
console.log(Math.round(-1.5));   // -1
console.log(Math.round(-1.6));   // -2
console.log(Math.round(-1.56));  // -2

4、隨機(jī)數(shù)

Math.random() 返回一個(gè)[0,1)之間的數(shù)，能取到0，取不到1

示例代碼：

// 獲得0-5的隨機(jī)數(shù)，包括0-5
// parseInt：取整
console.log(parseInt(Math.random() * 6)); // 因?yàn)殡S機(jī)數(shù) 能取到0，取不到1，要想返回5 就需要乘以6 


// 獲得3-5之間的隨機(jī)數(shù)
// 3-5？可以先取到隨機(jī)數(shù)0-2，然后再加3 獲得的就是3-5
console.log(parseInt(Math.random() * 3) + 3);  

5、絕對(duì)值

Math.abs() 對(duì)一個(gè)數(shù)進(jìn)行絕對(duì)值操作,純數(shù)字字符串也可以轉(zhuǎn)換

示例代碼：

console.log(Math.abs(-11));   // 11
console.log(Math.abs(11));    // 11
console.log(Math.abs("-11")); // 11
console.log(Math.abs("aaa")); // NaN

6、次冪和開(kāi)平方

Math.pow(num, power) 求 num 的 power 的次方

示例代碼：

console.log(Math.pow(2,4));   // 2的4次方 16

Math.sqrt(num) 為 num 開(kāi)平方根

示例代碼：

console.log(Math.sqrt(9));   // 為9開(kāi)平方根  3

Data 對(duì)象是用來(lái)處理日期和時(shí)間的

使用構(gòu)造函數(shù)創(chuàng)建一個(gè)當(dāng)前時(shí)間對(duì)象 var date = new Date();

var date = new Date();
console.log(date); // Fri Nov 17 2017 11:59:19 GMT+0800 (中國(guó)標(biāo)準(zhǔn)時(shí)間)

創(chuàng)建一個(gè)指定時(shí)間的日期對(duì)象 var date = new Date(指定時(shí)間);

var date = new Date("2017-03-22");          //創(chuàng)建一個(gè)指定時(shí)間的日期對(duì)象 Wed Mar 22 2017 08:00:00 GMT+0800 (中國(guó)標(biāo)準(zhǔn)時(shí)間)
var date = new Date("2017-03-22 00:52:34"); //創(chuàng)建一個(gè)指定時(shí)間的日期對(duì)象 Wed Mar 22 2017 00:52:34 GMT+0800 (中國(guó)標(biāo)準(zhǔn)時(shí)間)

日期格式化，一般用到的不多，通過(guò)格式化可以獲得當(dāng)前日期的日期部分或者時(shí)間部分

var date = new Date();
date.toString();            // 默認(rèn)的日期格式
date.toLocalString();       // 本地風(fēng)格的日期格式(存在兼容性)
date.toDateString();        // 獲得當(dāng)前日期時(shí)間的，日期部分 Fri Nov 17 2017
date.toLocalDateString();   // 本地風(fēng)格的日期部分(存在兼容性)
date.toTimeString();        // 獲得當(dāng)前日期時(shí)間的，時(shí)間部分 13:23:42 GMT+0800 (中國(guó)標(biāo)準(zhǔn)時(shí)間)
date.toLocalTimeString();   // 本地風(fēng)格的時(shí)間部分(存在兼容性)

getMilliseconds(); 獲取毫秒值

getSeconds(); 獲取秒

getMinutes(); 獲取分鐘

getHours(); 獲取小時(shí)

getDay(); 獲取星期，0-6 0：星期天

getDate(); 獲取日，即當(dāng)月的第幾天

getMonth(); 返回月份，注意從0開(kāi)始計(jì)算，這個(gè)地方坑爹，0-11

getFullYear(); 返回4位的年份 如 2016

示例代碼：封裝一個(gè)格式 xxxx-xx-xx xx:xx:xx 的日期函數(shù)

var date = new Date();
var year = date.getFullYear();     // 獲取當(dāng)前時(shí)間的年份

var month = date.getMonth() + 1;   // 獲取當(dāng)前時(shí)間的月份，注意月份是從0開(kāi)始的0-11，所以加1
addZore(month);                    // 獲得的月份有可能是一位數(shù)，此時(shí)需要給他再拼接一位

var d = date.getDate();            // 獲得當(dāng)前時(shí)間的日期天數(shù)
addZore(d);

var h = date.getHours();           // 獲取當(dāng)前時(shí)間的小時(shí)
addZore(h);

var m = date.getMinutes();         // 獲取當(dāng)前時(shí)間的分鐘
addZore(m);

var s = date.getSeconds();         // 獲取當(dāng)前時(shí)間的秒
addZore(s);

function addZore(n) {
    return n > 10 ? n : "0" + n;   // 判斷獲取到的數(shù)字大于10的時(shí)候 返回本身，小于的時(shí)候需要拼串
}

var dateStr = year + "-" + month + "-" + d + " " + h + ":" + m + ":" + s;
console.log(dateStr); // 2017-11-17 13:58:53

1970年01月01日00時(shí)00分00秒起至現(xiàn)在的總毫秒數(shù)叫做時(shí)間戳

獲取時(shí)間戳：

var date = new Date();
// 方法一
console.log(date.getTime()); // getTime的方法獲得毫秒數(shù)

// 方法二
console.log(+date);    // 直接通過(guò)計(jì)算的方式轉(zhuǎn)換成毫秒數(shù)

示例代碼：計(jì)算代碼執(zhí)行的時(shí)間

var start = new Date();
var sum = 0;
// 電腦性能不好的小伙伴 不要這么搞  循環(huán)的次數(shù)少一點(diǎn)
for (var index = 0; index < 1000000000; index++) {
    sum += index;
}
console.log(sum);  // 499999999067109000
var end = new Date();
console.log(end - start);  // 17899

數(shù)組對(duì)象在javascript中非常的常用

將數(shù)組的值拼接成字符串

語(yǔ)法：array.join(separator)

數(shù)組的每一項(xiàng)默認(rèn)的拼接符是逗號(hào)

想要改變拼接符就在join()方法的括號(hào)里傳入其他的拼接字符

示例代碼：

var arr = ["大喬","小喬","甄姬","妲己","露娜"];
var str = arr.join();
console.log(str);  // "大喬,小喬,甄姬,妲己,露娜"

// 用“-”拼接符
var arr2 = ["大喬","小喬","甄姬","妲己","露娜"];
var str2 = arr2.join("-");
console.log(str2);  // "大喬-小喬-甄姬-妲己-露娜"

1、arr.push() 在數(shù)組最后面 添加元素，返回新數(shù)組的長(zhǎng)度

var arr = ["大喬","小喬","甄姬"];
console.log(arr.push("妲己", "露娜"));  // 返回 5
console.log(arr);                       // ["大喬","小喬","甄姬","妲己","露娜"]

2、arr.pop() 在數(shù)組最后面刪除一個(gè)元素，返回刪除的那個(gè)元素

var arr = ["大喬","小喬","甄姬","妲己", "露娜"];
console.log(arr.pop());   // 返回 "露娜"
console.log(arr);         // ["大喬","小喬","甄姬","妲己"]

3、arr.unshift() 在數(shù)組前面添加元素，返回新數(shù)組的長(zhǎng)度

var arr = ["甄姬","妲己", "露娜"];
console.log(arr.unshift("大喬","小喬"));   // 返回 5
console.log(arr);                          // ["大喬","小喬","甄姬","妲己", "露娜"];

4、arr.shift() 在數(shù)組最前面刪除一個(gè)元素，返回刪除的那個(gè)元素

var arr = ["大喬","小喬","甄姬","妲己", "露娜"];
console.log(arr.shift());   // 返回 "大喬"
console.log(arr);           // [小喬","甄姬","妲己", "露娜"];

示例代碼(一)：

var arr = ["劉備"];
//添加數(shù)據(jù)后變成：["趙云","馬超","劉備","關(guān)羽","張飛"]
arr.push("關(guān)羽","張飛");
arr.unshift("趙云","馬超");
console.log(arr);   //  ["趙云","馬超","劉備","關(guān)羽","張飛"]

//刪除數(shù)據(jù)后變成：["關(guān)羽","張飛"]
arr.shift();
arr.shift();
arr.shift();
console.log(arr);   // ["關(guān)羽","張飛"]

示例代碼(二)：

var arr = ["趙云","馬超","劉備","關(guān)羽","張飛"];

//把數(shù)組的最后一個(gè)元素變成數(shù)組的第一個(gè)元素
arr.unshift(arr.pop());
console.log(arr);        // ["張飛","趙云","馬超","劉備","關(guān)羽"]

1、arr.reverse() 翻轉(zhuǎn)數(shù)組

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

2、arr.sort() 數(shù)組排序

默認(rèn)按照字母順序排序

sort方法可以傳遞一個(gè)函數(shù)作為參數(shù)，這個(gè)參數(shù)用來(lái)控制數(shù)組如何進(jìn)行排序

a-b 從小到大排序，b-a 從大到小排序

var arr = [1,3,5,7,9,2,4,6,8,10];
var newArr = arr.sort(function(a,b){
    // 如果返回值>0,則交換位置
    return a - b;
});
console.log(newArr);  // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
console.log(arr);     // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

示例代碼(一)：

// 將字符串?dāng)?shù)組按照字符長(zhǎng)度從大到小排列
var arr = ["ccc", "bb", "a", "ffffdd"];
arr.sort(function (a, b) {
    return b.length - a.length;
});
console.log(arr);       // ["ffffdd", "ccc", "bb", "a"]

示例代碼(二)：

//將學(xué)生數(shù)組按照年齡從小到大排列
var arr = [
    {name:"張三", age: 18, score: 50},
    {name:"李四", age: 70, score: 95},
    {name:"王五", age: 9, score: 33},
    {name:"趙六", age: 38, score: 100},
    {name:"田七", age: 6, score: 8},
    {name:"王八", age: 22, score: 66}
];

arr.sort(function(a, b) {
    return a.age - b.age;
});
console.log(arr);  

1、concat 數(shù)組的合并

var arr1 = [1, 3, 5, 7, 9];
var arr2 = [2, 4, 6, 8, 10];

// concat: 合并兩個(gè)數(shù)組
var newArr = arr1.concat(arr2);
console.log(newArr);        //  [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

不會(huì)影響原來(lái)的數(shù)組，會(huì)返回一個(gè)新的數(shù)組

2、slice 數(shù)組切分

復(fù)制數(shù)組的一部分(淺拷貝)到一個(gè)新數(shù)組，并返回這個(gè)數(shù)組，原來(lái)的數(shù)組不受影響

slice有兩個(gè)屬性，分別是開(kāi)始的下標(biāo)和結(jié)束的下標(biāo)，截取的時(shí)候包含begin，不包含end

var arr = [1, 3, 5, 7, 9];


// slice: 截取數(shù)組的一部分
var newArr = arr.slice(0,3);
console.log(newArr);        //  [1, 3, 5]

3、splice 數(shù)組拼接

splice:數(shù)組拼接，以新元素來(lái)替換舊元素，以此來(lái)修改數(shù)組的內(nèi)容，常用于刪除數(shù)組的某些項(xiàng)

array.splice(start, deleteCount, [items]); start:開(kāi)始下標(biāo) deleteCount:刪除的個(gè)數(shù) items:替換的內(nèi)容

splice 能實(shí)現(xiàn)多種用法：

找到開(kāi)始下標(biāo)，刪除個(gè)數(shù)為0，再輸入替換的內(nèi)容，此時(shí)就可以在數(shù)組中任意位置添加元素

找到開(kāi)始下標(biāo)，需要?jiǎng)h除的個(gè)數(shù)，再輸入替換的內(nèi)容，此時(shí)就可以在數(shù)組任意位置替換元素

找到開(kāi)始下標(biāo)，需要?jiǎng)h除的個(gè)數(shù)，不輸入替換內(nèi)容，此時(shí)就可以在數(shù)組任意位置，刪除任意個(gè)數(shù)的元素

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// 從下標(biāo)是2的位置開(kāi)始，刪除0個(gè)，把 100 101 添加進(jìn)去
var newArr = arr.splice(2, 0, 100, 101);
console.log(newArr); // 操作的是原數(shù)組，不會(huì)返回這個(gè)新數(shù)組
console.log(arr); // [1, 2,100,101,3, 4, 5, 6, 7, 8, 9, 10]     


// 也可以替換元素 (此時(shí)arr = [1, 2,100, 101, 3, 4, 5, 6, 7, 8, 9, 10] )
arr.splice(0, 2, 98, 99);
console.log(arr); // [98, 99, 100, 101, 3, 4, 5, 6, 7, 8, 9, 10]


// 也可以用于刪除數(shù)組里的多個(gè)元素 (此時(shí)arr = [98, 99, 100, 101, 3, 4, 5, 6, 7, 8, 9, 10] )
arr.splice(0, 4);
console.log(arr); // [3, 4, 5, 6, 7, 8, 9, 10]

indexOf()方法，是用來(lái)查找數(shù)組中，某個(gè)元素首次出現(xiàn)的位置，下標(biāo)從0開(kāi)始，找到的話返回位置信息，當(dāng)找不到的時(shí)候返回-1

arr.indexOf(search,[fromIndex]);search:需要搜索的元素，fromIndex:規(guī)定在字符串中開(kāi)始檢索的位置。

示例代碼：

var arr = [1, 5, 8, 11, 1, 2, 9];
arr.indexOf(8);  // 返回2
arr.indexOf(8,1) // 從下標(biāo)1，往后查找 返回 2 
arr.indexOf(10); // 返回-1 說(shuō)明找不到

與之對(duì)應(yīng)的還有一個(gè)lastIndexOf(),從后往前找

var arr = [1, 5, 8, 11, 1, 2, 9];
arr.lastIndexOf(1);  // 返回4
arr.lastIndexOf(1,3) // 從下標(biāo)3，往前查找 返回0 
arr.lastIndexOf(10); // 返回-1 說(shuō)明找不到

1、刪除數(shù)組中的所有元素

var arr = [1,2,3,4,5];
arr.splice(0,arr.length);
console.log(arr);  // []

2、直接修改數(shù)組的長(zhǎng)度

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

3、將數(shù)組賦值為一個(gè)空的數(shù)組

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

var arr = ["c", "a", "z", "a", "x", "a", "a", "z", "c", "x", "a", "x"];
//1. 找到數(shù)組中第一個(gè)a出現(xiàn)的位置
console.log(arr.indexOf("a"));          // 1

//2. 找到數(shù)組中最后一個(gè)a出現(xiàn)的位置
console.log(arr.lastIndexOf("a"));      // 10

//3. 找到數(shù)組中每一個(gè)a出現(xiàn)的位置
for (var i = 0; i < arr.length; i++) {
    if (arr[i] == "a") {
        console.log(i);                 // 1 3 5 6 10
    }
}

//4. 數(shù)組去重，返回一個(gè)新數(shù)組
var newArr = [];
for (var i = 0; i < arr.length; i++) {
    if (newArr.indexOf(arr[i]) == -1) {   // 判斷當(dāng)newArr的數(shù)組里沒(méi)有arr[i]的時(shí)候
        newArr.push(arr[i]);              // 將arr[i] 添加到newArr中 ["c", "a", "z", "x"]
    }
}
console.log(newArr);

//5. 獲取數(shù)組中每個(gè)元素出現(xiàn)的次數(shù)
//　首先需要知道 如何判斷一個(gè)對(duì)象中是否存在某屬性
/*
    var obj = {
        name:"zs",
        age:18,
        score:100
    }
    //in關(guān)鍵字可以查看對(duì)象是否擁有某個(gè)屬性。
    console.log( "sex" in obj );  // false
*/
var obj = {};
for(var i = 0; i < arr.length; i++){
    // 遍歷數(shù)組，判斷對(duì)象有沒(méi)有這個(gè)屬性， 
    if(arr[i] in obj){
        // 如果有這個(gè)屬性，讓這個(gè)屬性的值+1 
        obj[arr[i]] ++;
    }else{
        // 如果沒(méi)有這個(gè)屬性，讓這個(gè)屬性等于1                    
        obj[arr[i]] = 1;
    }
}
console.log(obj);

字符串可以看成是一個(gè)字符數(shù)組（偽數(shù)組）。因此字符串也有長(zhǎng)度，也可以進(jìn)行遍歷。String對(duì)象很多方法的名字和和Array的一樣。

// 遍歷一段字符串
var str = "abcdefghijk";
for(var i = 0; i < str.length; i++){
    console.log(str[i]);  // "a" "b" "c" "d"...
}

小寫(xiě)轉(zhuǎn)換成大寫(xiě)

toUpperCase(),toLocaleUpperCase()是將英文小寫(xiě)的字符串轉(zhuǎn)換為大寫(xiě),其中toLocaleUpperCase()方法則是針對(duì)特定地區(qū)的實(shí)現(xiàn)(如土耳其語(yǔ)會(huì)為Unicode大小寫(xiě)轉(zhuǎn)換應(yīng)用特殊的規(guī)則)。

var str = "hello world";
str.toUpperCase(); // "HELLO WORLD"
str.toLocaleUpperCase();

大寫(xiě)轉(zhuǎn)換成小寫(xiě)

toLowerCase(),toLocaleLowerCase()是將英文小寫(xiě)的字符串轉(zhuǎn)換為大寫(xiě)

var str = "HELLO WORLD";
str.toUpperCase(); // "hello world"
str.toLocaleUpperCase();

注意: 因?yàn)槭欠椒ǎ砸欢ú灰浖由?b>()

indexOf()方法，是用來(lái)判斷指定字符，在當(dāng)前字符串中首次出現(xiàn)的位置，下標(biāo)從0開(kāi)始，找到的話返回位置信息，當(dāng)找不到的時(shí)候返回-1

示例代碼：

var str= "good good study , day day up!";
str.indexOf("day");  // 返回18
str.indexOf("good"); // 返回0
str.indexOf("GOOD"); // 返回-1 說(shuō)明找不到

與之對(duì)應(yīng)的還有一個(gè)lastIndexOf(),是用來(lái)從后面開(kāi)始查找字符第一次出現(xiàn)的位置

var str= "good good study , day day up!";
str.lastIndexOf("good");  // 返回 5

trim();方法，是用來(lái)去除字符串兩邊的空格，內(nèi)部空格不會(huì)去除

var str = " A B C ";
console.log(str.trim());  // "A B C"

slice()方法是用來(lái)截取一段字符串的，str.slice(start,end);它的兩個(gè)參數(shù)都是表示下標(biāo)的，一個(gè)表示開(kāi)始，一個(gè)表示結(jié)束(截取時(shí)不包括結(jié)束下標(biāo))

說(shuō)明：

start下標(biāo)從0開(kāi)始的str指定部分起始索引。如果start為負(fù)，將它作為length+start處理，此處length為字符串的長(zhǎng)度。

end下標(biāo)從0開(kāi)始的str指定部分結(jié)束索引。如果end為負(fù)，將它作為length+end處理，此處length為字符串的長(zhǎng)度。

示例代碼：

// 起始位置結(jié)束位置都是正數(shù)
var str = "ABCDEFGHIJK";
str.slice(2,6);  // "CDEF"

// 當(dāng)起始位置為負(fù)數(shù)的時(shí)候
var str = "ABCDEFGHIJK";
str.slice(-6, 10); // "FGHIJ"
// str的length為11，所以起始位置是-6+11=5，就是F結(jié)束是10(不包括10)，那么就是J；

// 特殊情況 當(dāng)起始位置在結(jié)束位置后面的時(shí)候，是截取不了的，返回空
var str = "ABCDEFGHIJK";
str.slice(-6, 2); // 空
// str的length為11，所以起始位置是-6+11=5，就是F，結(jié)束位置在2，這個(gè)時(shí)候是截取不了的

注意：

end為結(jié)束下標(biāo)，截取的時(shí)候不包括end那一位

截取是有順序的，開(kāi)始到結(jié)束的順序必須是從左向右，否則是截取不了的,為空

substring()方法返回位于String對(duì)象中指定位置的子字符串,str.substring(start,end);它的兩個(gè)參數(shù)都是表示下標(biāo)的，一個(gè)表示開(kāi)始，一個(gè)表示結(jié)束(截取時(shí)不包括結(jié)束下標(biāo))

說(shuō)明：

start指明子字符串的起始位置，該索引從0開(kāi)始起算。

end指明子字符串的結(jié)束位置，該索引從0開(kāi)始起算。

substring方法使用start和end兩者中的較小值作為子字符串的起始點(diǎn)。如果start或end為NaN或者為負(fù)數(shù)，那么將其替換為0。

示例代碼：

// 當(dāng)起始位置，結(jié)束位置都是正數(shù)的時(shí)候
var str = "ABCDEFGHIJK";
str.substring(2,6); // "CDEF"
// 同樣的，substring方法結(jié)束位置也不包括自己

// 當(dāng)起始位置為負(fù)數(shù)的時(shí)候，直接轉(zhuǎn)換成下標(biāo)0
var str = "ABCDEFGHIJK";
str.substring(-2,6); // "ABCDEF" 下標(biāo)轉(zhuǎn)換成了0 

// 當(dāng)開(kāi)始的位置大于結(jié)束位置的時(shí)候，自動(dòng)轉(zhuǎn)換較小的值作為起點(diǎn)
var str = "ABCDEFGHIJK";
str.substring(6,2); // "CDEF"

利用substring方法，實(shí)現(xiàn)打字效果

/*樣式部分*/
#box {
    width: 300px;
    height: 150px;
    border: 2px dashed fuchsia;
    margin: 100px auto;
    text-align: left;
    padding: 10px;
}

注意：

substring方法，end為結(jié)束下標(biāo)，截取的時(shí)候同樣不包括end那一位

當(dāng)start的值大于end的時(shí)候，兩者中較小的值作為起始下標(biāo)

substr()方法返回一個(gè)從指定位置開(kāi)始,指定長(zhǎng)度的子字符串。str.substr(start,length),start為開(kāi)始的下標(biāo),length為需要返回字符串的長(zhǎng)度

說(shuō)明：

start所需的子字符串的起始位置。字符串中的第一個(gè)字符的索引為0。

length在返回的子字符串中應(yīng)包括的字符個(gè)數(shù)。

示例代碼：

var str = "ABCDEFGHIJK";
str.substr(1,5); // BCDEF

match() 來(lái)查找字符串中特定的字符，并且如果找到的話，則返回這個(gè)字符,找不到的話返回null。

示例代碼:

var str= "good good study , day day up!";
str1.match("good");  // good
str1.match("Good");  // null

replace() 方法在字符串中用某些字符替換另一些字符。

示例代碼：

var str2 = "hello world";
str2.replace("world", "china"); // "hello china"

將一個(gè)字符串分割為子字符串，然后將結(jié)果作為字符串?dāng)?shù)組返回。str.split(separator,num),帶一個(gè)參數(shù)separator表示切割的條件，第二個(gè)參數(shù)num表示需要切割的位數(shù)

說(shuō)明：

separator(分隔符)字符串或正則表達(dá)式對(duì)象，它標(biāo)識(shí)了分隔字符串時(shí)使用的是一個(gè)還是多個(gè)字符。如果忽略該選項(xiàng)，返回包含整個(gè)字符串的單一元素?cái)?shù)組。

num該值用來(lái)限制返回?cái)?shù)組中的元素個(gè)數(shù)。

示例代碼：

var str = "ABCDEFGHIJK";
str.split("",6); // ["A", "B", "C", "D", "E", "F"]

1、翻轉(zhuǎn)一個(gè)字符串

var str = "abcdefg";
var strArr = str.split(""); // 將字符串轉(zhuǎn)換為數(shù)組 ["a","b","c","d","e","f","g"]
strArr.reverse();           // 翻轉(zhuǎn)這個(gè)數(shù)組       ["g","f","e","d","c","b","a"]
var newStr = strArr.join("");
console.log(newArr);        // "gfedcba"

2、將一串字符轉(zhuǎn)化成對(duì)象

/*
有一個(gè)鏈接：http://www.baidu.com?name=cc&id=100&desc=很帥 
將鏈接的參數(shù)部分轉(zhuǎn)換成一個(gè)對(duì)象
即{name:"cc", id=100 , desc: "很帥"}
*/
var str = "http://www.baidu.com?name=cc&id=100&desc=很帥";
var obj = {};
var strArr = str.split("?");          // ["http://www.baidu.com", "name=cc&id=100&desc=很帥"]
var strArr2 = strArr[1].split("=");   // ["name=cc", "id=100", "desc=很帥"]
for(var i = 0; i < strArr2.length; i++){
    console.log(strArr2[i]);          // "name=cc" "id=100" "desc=很帥"
    var key = strArr2[i].split("=")[0];     // name  id  desc
    var value = strArr2[i].split("=")[1];   // cc 100 很帥
    obj[key] = value;
}
console.log(obj);     // {name:"cc", id=100 , desc: "很帥"}

3、將對(duì)象轉(zhuǎn)換成字符串

/*
有一個(gè)對(duì)象{name:"cc", id:100,desc:"很帥"}
和一個(gè)鏈接http://www.baidu.com,
拼接成鏈接http://www.baidu.com?name=cc&id=100&desc=很帥
*/
var prefix = "http://www.baidu.com";
var obj = {name:"cc", id:100,desc:"很帥"};
var arr = [];
for (var key in obj) {
    // console.log(key);            name id desc
    // console.log(obj[key]);       "cc" 100 "很帥"
    var str = key + "=" + obj[key];
    console.log(str);               // name=cc id=100 desc=很帥
    arr.push(str);  
    console.log(arr);               // ["name=cc", "id=100", "desc=很帥"]
}
var arrStr = arr.join("&");         
console.log(arrStr);                // name=cc&id=100&desc=很帥
var result = prefix + "?" + arrStr;
console.log(result);                // http://www.baidu.com?name=cc&id=100&desc=很帥

上一篇：JavaScript 基礎(chǔ)知識(shí) - 入門篇(一)
下一篇：JavaScript 基礎(chǔ)知識(shí) - DOM篇(一)