變量

• 會變化的量，是用來存儲數(shù)據(jù)的容器。

• 命名規(guī)范：

  • 可以由數(shù)字、字母、下劃線、$組成，不能以數(shù)字開頭;
  • 嚴格區(qū)分大小寫;
  • 變量名中不允許有空格；
  • 不能使用關(guān)鍵字、保留字命名，不確定變量名是否是關(guān)鍵字、保留字時可以用 alert 彈出查看；
  • 長度不能超過255個字符；
  • 漢字可以作為變量名，但是不建議使用。

• 練習：

  • 用戶輸入一個數(shù)a，然后向用戶彈出a的立方；
  • 用戶輸入兩個數(shù)，然后向用戶彈出這兩個數(shù)的和；
  • 交換兩個數(shù)字型變量的值（不使用第三個變量）。

• 在一行定義多個變量：var a=1,b=3,c;

數(shù)據(jù)類型

簡單數(shù)據(jù)類型(值類型)：

• number（數(shù)字類型）：包含小數(shù)、整數(shù);

  • 數(shù)字類型的表達方式：
    • 十進制；
    • 十六進制：從0-9，從a(A)-f(F)，以0x開頭;
    • 八進制：以0開頭。
  • 小數(shù)可以進行計算，但是千萬不要進行比較，小數(shù)會有精度丟失。

• 字符串：凡是用雙引號或者單引號表示的都是字符串。

• 布爾數(shù)據(jù)類型（boolean）：只有兩個取值true和false。運算時0代表false，1代表true。

• undefined（變量未初始化）：定義了一個變量，但是沒有初始化(沒有給變量賦值)。

• null：變量值為空，未引用，屬于復雜數(shù)據(jù)類型，是Object。

• 注：var n3="";，變量n3是存在的，值為空字符串。

• 判斷數(shù)據(jù)類型：typeof(a);或者typeof a;;

復雜數(shù)據(jù)類型(引用類型)：

• Object、function、array、date、regExp、error...

字面量

• 固定的值，讓你從“字面上”理解其含義；
• 數(shù)值字面量：var age = 18;，18為字面值。

算術(shù)運算符

• +：

  • 兩個數(shù)字類型的數(shù)相加得到的是數(shù)字類型；
  • 字符串和數(shù)字類型的數(shù)相加得到的是字符串類型。

• -：

  • 數(shù)字類型和數(shù)字字符串相減，得到的是一個數(shù)字類型；
  • 數(shù)字類型和包含非數(shù)字的字符串相減，得到的是NaN（NaN也是數(shù)字類型）。

• /：

  • 數(shù)字類型和數(shù)字字符串相除，得到的是一個數(shù)字類型；
  • 數(shù)字類型和包含非數(shù)字字符串相除，得到的是 NaN，是數(shù)字類型；
  • 如果除數(shù)為零，得到 Infinity，仍然是一個數(shù)字類型。

• %:取余。

• NaN:

  • undefined和任何數(shù)值計算結(jié)果為NaN；
  • NaN與任何值都不相等，包括NaN本身；
  • isNaN：是否符合一個標準，不是一個數(shù)字的標準。

• 練習：如果今天是星期天，500天后是星期幾（用一條語句完成）

• 比較運算符：

  • >、<、>=、<=、==、!=

Data對象

Math常用方法

數(shù)據(jù)類型轉(zhuǎn)換

• 數(shù)字類型轉(zhuǎn)字符串

  • String(數(shù)值);
  • 數(shù)值.toString();
  • 變量 + "";

• 字符串轉(zhuǎn)數(shù)字

  • Number(字符串)，如果包含非數(shù)字，返回NaN；
  • parseInt(數(shù)/字符串)：取整，從前往后讀到非數(shù)字位停止，讀到小數(shù)點時候也停止，如果以非數(shù)字開頭結(jié)果就為NaN；
  • parseFloat(數(shù)字/字符串)：取數(shù)，從前往后讀到非數(shù)字位停止，讀到小數(shù)位時不停止，如果以非數(shù)字開頭，結(jié)果就為NaN。

• Boolean轉(zhuǎn)數(shù)字類型

  • undefined、null、數(shù)字0、""、NaN轉(zhuǎn)完之后為false；
  • 所有的其它字符串轉(zhuǎn)完之后都為true，包括"0"。
  • 轉(zhuǎn)換為Boolean類型的方法：
    • Boolean(數(shù)字/字符串);
    • !!數(shù)字/字符串;

• 隱式數(shù)據(jù)類型轉(zhuǎn)換

  • 在運算過程中，程序自己進行的數(shù)據(jù)轉(zhuǎn)換(工程師沒有操作)；
  • 只在運算過程中進行轉(zhuǎn)換。

• NaN和undefined

• undefined == null為true；

• undefined === null為false；

• undefined + 10 = NaN；

• NaN + 10 = 10，此時NaN可以當作0。

• 練習：

• 用戶輸入一個三位數(shù)，輸出三個數(shù)字的值。如輸入123，輸出6；輸入987，輸出24。

邏輯運算符

• &&（與）；
• ||（或）；
• ！（非）；
• 結(jié)果只有兩個：true和false。

等號運算符

• =：賦值；
• ==：只判斷內(nèi)容是否相等；
• ===：判斷內(nèi)容和類型是否都相同；
• !=：判斷內(nèi)容是否不相等；
• !==:判斷內(nèi)容和類型是否都不相同。

判斷語句

• 練習：
• 當用戶點擊確定時，彈出消息“您已退出”；當點擊取消時，彈出消息“您已取消退出”。
• 用戶輸入一個數(shù)，如果是偶數(shù)，在控制臺輸出這個數(shù)；否則輸出這個數(shù)不是偶數(shù)。
• 用戶輸入一個數(shù)，判斷該數(shù)是否在20~70之間，如果在輸出該數(shù)，否則輸出該數(shù)不在范圍內(nèi)。
• 用戶輸入一個數(shù)字，該數(shù)和隨機產(chǎn)生的數(shù)（0~99，包含0和99）進行比較，如果用戶輸入的數(shù)大，就輸出您贏了，否則輸出你輸了。
• 用戶輸入一個年齡，判斷在哪個階段。比如0_{20為少年，20}30為青年，30_{50為中年，50}為晚年。
• 用戶輸入學生的成績和姓名。判斷學生成績在哪個階段（分為優(yōu)良中下），并在控制臺輸出學生的姓名及成績所在的階段。

三元表達式

• 寫法：表達式?結(jié)果1:結(jié)果2;，如果表達式為true就執(zhí)行表達式1，否則就執(zhí)行表達式2。

• 練習：

• 當用戶點擊確定時，彈出消息“您已退出”；當點擊取消時，彈出消息“您已取消退出”。

• 用戶輸入一個數(shù)，如果是偶數(shù)，在控制臺輸出這個數(shù)；否則輸出這個數(shù)不是偶數(shù)。

• 用戶輸入一個數(shù)字，該數(shù)和隨機產(chǎn)生的數(shù)（0~99，包含0和99）進行比較，如果用戶輸入的數(shù)大，就輸出您贏了，否則輸出你輸了。

• 代碼調(diào)試

• 總練習：

• 92號汽油每升6元，如果大于等于20升，那么每升5.9；97號汽油，每升7元，如果大于等于30升，那么每升6.95。用戶輸入自己的汽油編號，然后輸入自己加多少升，彈出所需支付的費用。

var a = prompt("請輸入汽油號");
var b = prompt("要加多少升");
if (a == 92){
    if (b >= 20){
        alert(b * 5.9 + "元");
    }else {
        alert(b * 6 + "元");
    }
}else if (a == 97){
    if (b >= 30){
        alert(b * 6.95 + "元");
    }else {
        alert(b * 7 + "元");
    }
}

• 用戶先輸入用戶名，如果不是admin，就停止程序，如果是就再讓用戶輸入密碼，如果密碼是88888，就提示登錄成功，否則提示登錄失敗。

var a = prompt("請輸入用戶名：");
if (a == "admin"){
    var b = prompt("請輸入密碼");
    if (b == 88888){
        alert("登錄成功");
    }else {
        alert("登錄失敗");
    }
}

• 讓用戶輸入三個數(shù)字，用三元運算符找出其中最大的一個。

var max = prompt("輸入第一個數(shù)");
var b = prompt("輸入第二個數(shù)");
var c = prompt("輸入第三個數(shù)");
max = max>b?max:b;
alert(max>c?max:c);

switch語句

• 練習：
• 用戶輸入一個成績（100，80，60，40），彈出對應(yīng)的評語（優(yōu)、良、中、下），如果輸入其它值就彈出未參加考試。switch底層用的是===比較。

var a = prompt("輸入成績");
switch (Number(a)){
    case 100:
        alert("優(yōu)");
        break;
    case 80:
        alert("良");
        break;
    case 60:
        alert("中");
        break;
    case 40:
        alert("下");
        break;
    default:
        alert("未參加考試");
        break;
}

• 輸入月份，彈出對應(yīng)的季節(jié)。（比如3，4，5為春季）

var a = prompt("輸入月份");
switch (Number(a)){
    case 3:
    case 4:
    case 5:
        alert("春季");
        break;
    case 6:
    case 7:
    case 8:
        alert("夏季");
        break;
    case 9:
    case 10:
    case 11:
        alert("秋季");
        break;
    case 12:
    case 1:
    case 2:
        alert("冬季");
        break;
    default:
        alert("輸錯啦");
        break;
}

while循環(huán)

• 練習：
• 將1-100中3的倍數(shù)打印到控制臺。
• 將1~100之間的數(shù)相加，將和打印在控制臺。
• 讓用戶輸入用戶名和密碼，如果用戶名不是admin或者密碼不是88888，就要求用戶重新輸入，否則提示登錄成功。
• 將1~50之間的所有奇數(shù)打印出來。

for循環(huán)

• 練習：換行用document.write("<br>");
• 計算1~100之間所有數(shù)之和并打印；
• 在頁面打印兩行十顆星；
• 打印一個直角三角形（由星組成，高10顆星，寬10顆星）;
• 打印乘法口訣。

<script>
    document.write("<table border='1'>");
    for(var i=1; i<=9; i++){
        document.write("<tr>");
        for(var j=1; j<=i; j++){
            document.write("<td>");
            document.write(j+"*"+i+"="+i*j);
            document.write("</td>")
        }
        document.write("</tr>")
    }
    document.write("</table>");
</script>

break

• 跳出當前這一層循環(huán)。
• 練習：
• 找出1~100之間所有的質(zhì)數(shù)；（提示：用flag標志位）

function getPrimes(num) {
        var primes = new Array();
        for(var i=2; i<=num; i++){
            var flag = true;
            for(var j=2; j<=Math.sqrt(i); j++){
                if (i%j==0){
                    flag = false;
                    break;  //break結(jié)束循環(huán)（只能結(jié)束一層循環(huán)），return結(jié)束本次函數(shù)
                }
            }
            if (flag == true){
                primes[primes.length] = i;
            }
        }
        console.log(primes);
}
getPrimes(100);

continue

• 跳出本次循環(huán)。
• 練習：
• 請輸出1~10之間所有的數(shù)，但是不輸出6；
• 打印出1~100之間所有的數(shù)，但是不包括3的倍數(shù)。

數(shù)組

• 數(shù)組的創(chuàng)建：
• 用new關(guān)鍵字來創(chuàng)建:var a = new Array();；
• 直接創(chuàng)建：var a = [];；定義并初始化：var a = [12,32,"我愛中國"];；
• 獲取數(shù)組的長度：a.length，可以通過for循環(huán)進行遍歷；
• 數(shù)組的合并：concat，數(shù)組3 = 數(shù)組1.concat(數(shù)組2);
• slice(start,end):從當前數(shù)組中截取一個新數(shù)組，不影響原來數(shù)組，參數(shù)start從0開始，end從1開始；
• splice(start,deleteCount,options)：刪除或替換當前數(shù)組的某些項目，參數(shù)start表示開始刪除的位置，deleteCount表示刪除的元素個數(shù)，options表示在刪除的地方要添加的元素（可以是單個元素也可以是數(shù)組）：

var arr1 = [2,3,4,5,6,7];
var arr2 = ["a","b","c"];
var arr3 = arr1.concat(arr2);
console.log(arr3);  //[2, 3, 4, 5, 6, 7, "a", "b", "c"]
for(var a in arr2){
    document.write(arr2[a]);    //a b c
}
var s1 = arr3.slice(4,8);
console.log(s1);     //[6, 7, "a", "b"]
var s2 = arr3.splice(0,5,"x","y","z");  //返回被刪除的元素：第一個數(shù)字為刪除開始位置，第二個數(shù)字為要刪除的元素的個數(shù)，之后的值為在刪除元素位置插入的新值
console.log(s2);    //[2, 3, 4, 5, 6]
console.log(arr3);  //["x", "y", "z", 7, "a", "b", "c"]

• 位置方法：indexOf()、lastindexOf()：如果沒有找到就返回-1；

var arr1 = [2,3,4,5,6,7,8,6];
var i1 = arr1.indexOf(8);
console.log(i1);    //6
var i2 = arr1.indexOf(12);
console.log(i2);    //-1
var i3 = arr1.lastIndexOf(6);   //返回元素最后出現(xiàn)的位置
console.log(i3);    //7

• 清空數(shù)組的方法：

var arr = [1,2,34,5];
//方法一：
arr.splice(0,arr.length);
//方法二：
arr.length = 0;
//方法三：
arr = [];
console.log(arr);   //[]

• 迭代方法，不會修改原來的數(shù)組：every()、filter()、forEach()、map()、some()
• every():對數(shù)組中每一項運行以下函數(shù)，如果都返回true，every返回true，如果有一項返回false，則停止遍歷every，返回false：

array.every(function(item,index,arr){
        //code
})

• 此類方法用的不多，在封裝時候可能會用到，用到時候再查也行，forEach()會用的多一些。

• 將數(shù)組用“|”連成一個字符串：join

var arr1 = [1,2,3,4];
var arr2 = arr1.join("|");
//此時arr2為1|2|3|4

• 數(shù)組的排序sort：
• sort排序是先根據(jù)第一位數(shù)字排，第一位排完之后再排第二位，以此類推

var arr = [1,2,3,11,21,23];
arr.sort();
console.log(arr);   //[1,11,2,21,23,3]

• 利用回調(diào)函數(shù)進行升序排序

var arr3 = new Array(2,4,6,1,11,23,43,32);
alert(arr3.sort(function (a,b) {
      return a-b;
}));
alert(arr3);    //1,2,4,6,11,23,32,43

• 利用回調(diào)函數(shù)進行降序排序

var arr3 = new Array(2,4,6,1,11,23,43,32);
alert(arr3.sort(function (a,b) {
      return b-a;
}));
alert(arr3);    //43,32,23,11,6,4,2,1

• 翻轉(zhuǎn)數(shù)組：

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

• 判斷一個對象是否是一個特定類的實例對象instanceof：

var arr1 = [1,2];
var arr2 = new Array(2,3);
var str1 = new String("aaa");
var str2 = "abc";
console.log(arr1 instanceof Array);     //true
console.log(arr2 instanceof Array);     //true
console.log(str1 instanceof String);    //true
console.log(str2 instanceof String);    //false

• 判斷是否是數(shù)組的方法：

var arr = [1,3,5];
document.write(Array.isArray(arr));

• 添加、刪除元素：

var arr = [2,3,4,5,6,7];
//push和pop從數(shù)組最后面操作
var p1 = arr.push(1);   //p1為數(shù)組的長度，7
console.log(arr);   //2,3,4,5,6,7,1
var p2 = arr.pop();     //p2為被刪除的元素的值
console.log(arr);   //2,3,4,5,6,7
//shift和unshift從數(shù)組最前面操作
var s1 = arr.shift();   //s1為被從前面刪除的元素
console.log(s1);    //2
var s2 = arr.unshift(9);    //6
console.log(arr);   //9,3,4,5,6,7

• 偽數(shù)組：不能修改長度的數(shù)組（可以修改元素，但是不能改變長短）：

function test(a,b,c,d) {
    //實參，arguments只在函數(shù)中使用
    console.log(arguments);  //偽數(shù)組[1,2]
    console.log(arguments instanceof Array);     //false
    console.log(Array.isArray(arguments));     //false
    console.log(arguments.length);      //2
//    arguments.push(1);    //報錯
    arguments[1] = 8;
    console.log(arguments);     //[1,8]

    //形參
    console.log(test.length);   //4

    console.log(arguments.callee);  //打印整個函數(shù)，和打印test結(jié)果一樣
}
test(1,2);

• 練習：
• 將1~100之間所有的奇數(shù)存放到數(shù)組arr1中：

<script>
    var arr1 = [];
    var j = 0;
    for(var i=1; i<=100; i++){
       if (i%2!=0){
           arr1[j++] = i;
       }
    }
    document.write(arr1);
</script>

• 將1~100之間所有能被3整除的數(shù)存放到數(shù)組arr2中：(第一題中定義了一個變量作為數(shù)組的下標；也可以使用數(shù)組的長度作為數(shù)組的下標，剛開始時數(shù)組的長度為0，數(shù)組的第一個元素下標也是0)

<script>
    var arr2 = new Array();
    for(var i=1; i<=100; i++){
        if (i%3==0){
            arr2[arr2.length] = i;
        }
    }
    document.write(arr2);
</script>

• 求一個數(shù)組中所有數(shù)的和和平均值：

var arr = [21,32,43,54,65];
var sum = 0;
for(var i=0; i<arr.length; i++){
      sum += arr[i];
}
document.writeln(sum);
document.write(sum/arr.length);

• 求一個數(shù)組中的最大值和最小值，并求出它們的索引：

var arr = [-21,-32,-43,-54,-65];
var maxP = 0;
var min = arr[0];
var minP = 0;
for(var i=1; i<arr.length; i++){
        if (max<arr[i]){
            max = arr[i];
            maxP = i;
        }
        if (min>arr[i]){
            min = arr[i];
            minP = i;
        }
}
document.writeln(max);
document.writeln(maxP);
document.writeln(min);
document.writeln(minP);

• 將數(shù)組中所有值不為0的數(shù)存入新數(shù)組中：

var arr = ["張飛",0,"關(guān)于",0,"趙云",0,"呂布",0];
var newArr = [];
for(var i=0; i<arr.length; i++){
        if (arr[i] != 0){
            newArr[newArr.length] = arr[i];
        }
}
console.log(newArr);

• 翻轉(zhuǎn)數(shù)組：使用三種方法

//翻轉(zhuǎn)數(shù)組，方法一
var arr = ["劉備","關(guān)羽","張飛"];
var newArr = [];
for(var i=arr.length-1; i>=0; i--){
    newArr[newArr.length] = arr[i];
}
console.log(newArr);

//翻轉(zhuǎn)數(shù)組二：將第一個和最后一個調(diào)換，將第二個和倒數(shù)第二個調(diào)換，以此類推，一直到中間一個調(diào)換完。
var arr = new Array();
arr = ["劉備","關(guān)羽","張飛","趙云","黃忠","張良"];
document.write(arr+"<br>");
for(var i=0; i<arr.length/2; i++){
    var temp = arr[i];
    arr[i] = arr[arr.length-1-i];
    arr[arr.length-1-i] = temp;
}
document.write(arr);

//使用API

• 冒泡排序：從頭開始，兩兩進行比較，把較大值放在后面，第一趟比較完可以將最大值挑選出來放到最后，第二趟將倒數(shù)第二大的值挑選出來放在倒數(shù)第二的位置...直到完成所有數(shù)的排序：

var arr = [2,1,3,5,3,9,6,8,7,4];
document.write(arr+"<br>");
for(var i=0; i<arr.length-1; i++){
        for(var j=1; j<arr.length-i; j++){
            if (arr[j-1]>arr[j]){
                var temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp;
            }
        }
}
document.write(arr);

//冒泡排序的高級寫法
var arr = [2,1,3,5,3,9];
document.write(arr+"<br>");
for(var i=0; i<arr.length-1; i++){
        for(var j=1; j<arr.length-i; j++){
            var flag = true;
            if (arr[j-1]>arr[j]){
                var temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp;
                flag = false;
            }
        }
        if (flag){
            break;
        }
}
document.write(arr);

如果沒有加flag判斷，執(zhí)行15次，加了之后執(zhí)行5次。

函數(shù)

• JS中沒有函數(shù)重載，同名函數(shù)最后一個會對前面的函數(shù)進行迭代：

• 如果實參個數(shù)大于形參個數(shù)，正常執(zhí)行，多余的實參會被忽略掉；

• 如果實參個數(shù)小于形式參數(shù)，要看程序具體情況，有可能會報錯、報NaN，或者報undefined。

• 練習：

• 求：1!+2!+3!+4!+···+n!

function getMult(m) {
        var multiple = 1;
        for(var i=1; i<=m; i++){
            multiple *= i;
        }
        return multiple;
}
function product(n) {
        var sum = 0;
        for(var i=1; i<=n; i++){
            sum += getMult(i);
        }
        return sum;
}

function product(n) {
        var sum = 0;
        for(var i=1; i<=n; i++){
            var multiple = 1;
            for(var j=1; j<=i; j++){
                multiple *= j;
            }
            sum += getMult(i);
        }
        return sum;
}

• 求200以內(nèi)的質(zhì)數(shù)（素數(shù)）：

function getPrimes(num) {
        var primes = new Array();
        for(var i=2; i<=num; i++){
            var flag = true;
            for(var j=2; j<=Math.sqrt(i); j++){
                if (i%j==0){
                    flag = false;
                    break;  //break結(jié)束循環(huán)（只能結(jié)束一層循環(huán)），return結(jié)束本次函數(shù)
                }
            }
            if (flag == true){
                primes[primes.length] = i;
            }
        }
        console.log(primes);
}
getPrimes(200);

• 求斐波那契數(shù)列第n項的數(shù)值（1，1，2，3，5，8，13，21...）：

function fb(n) {
        if (n==1){
            return 1;
        }
        if (n==2){
            return 1;
        }
        var n1 = 1;
        var n2 = 1
        for(var i=3; i<=n; i++){
            n3 = n1 + n2;
            n1 = n2;
            n2 = n3;
        }
        return n3;
}
alert(fb(7));

• 輸入某年某月某日，輸出這一天是這一年的第幾天（閏年：能被4整除是閏年，但能被100整除的年不是閏年，不過可以被400整除的年也是閏年）:

function getDay(year,month,day) {
        var days = new Array(31,28,31,30,31,30,31,31,30,31,30,31);
        //判斷是否是閏年
        var isLeap = false;
        if (year%4==0 && year%100!=0 || year%400==0){
            isLeap = true;
        }
        //如果現(xiàn)在是第三個月，先獲取前兩個月的天數(shù)
        var getDay = 0;
        for(var i=0; i<month-1; i++){
            getDay += days[i];
        }
        //如果月份大于2并且是閏年，就加一天
        if (month>2 && isLeap) getDay += 1;
        getDay += day;
        return getDay;
}
alert(getDay(2000,3,1));

對象

• 創(chuàng)建對象的兩種方法：
• var obj = new Object();
• var obj = {};
• 創(chuàng)建一個對象，并給他綁定屬性和方法：

var p = new Object();
p.name = "王五";
p["say"] = function () {
    console.log(this.name + "好好生活");
};
console.log(p);
p.say();

• 自定義一個構(gòu)造函數(shù)，并創(chuàng)建自定義對象

function Student(name) {
    this.name = name;
    this.sayHello = function () {
        console.log(this.name + "說話：你好！！！");
    }
}
var stu1 = new Student("張三");
console.log(stu1);
stu1.sayHello();
console.log(typeof stu1);   //Object

補充：進制轉(zhuǎn)換（了解）

• 任意類型的數(shù)值轉(zhuǎn)換為十進制parseInt:

document.writeln(parseInt(22,8));

• 十進制轉(zhuǎn)換為任意進制toString:

var num = 30;
document.write(num.toString(8));

創(chuàng)建一個JSON，并對其進行遍歷：

var json = {};
console.log(json);
for(var i=0; i<10; i++){
    json[i] = i * 10;
}
console.log(json);

for(var k in json){
    document.writeln(json[k]);
}

構(gòu)造函數(shù)原理(了解)

function  Num(aaa){
    this["[[PrimitiveValue]]"] = num/1;
    return  aaa/1;
}

• 練習：
• 找到數(shù)組["c","z","a","x","a","y","a","x","c","c","c"]中每一個元素出現(xiàn)的次數(shù)：
  • 利用對象來做。利用K:V相對比較方便，如果使用數(shù)組稍微復雜。思路：創(chuàng)建一個對象，判斷數(shù)組中的元素在對象中是否存在，如果存在，值+1，否則創(chuàng)建一個數(shù)組元素的屬性，然后給值賦值為1.

var arr = ["c","z","a","x","a","y","a","x","c","c","c"];
var obj = new Object();
for(var i=0; i<arr.length; i++){
        if (obj[arr[i]]){
            obj[arr[i]] += 1;
        }else {
            obj[arr[i]] = 1;
        }
}
console.log(obj);

• 去掉數(shù)組中的重復元素：

var arr = [2,3,4,5,6,7,8,5,5,4,3,5,2];
var newArr = [];
for(var i=0; i<arr.length; i++){
        var flag = true;
        for(var j=0; j<newArr.length; j++){
            if (arr[i] == newArr[j]){
                flag = false;
            }
        }
        if (flag == true) newArr[newArr.length] = arr[i];
}
console.log(newArr);