基礎(chǔ)一

JavaScript基礎(chǔ)

歷史

JavaScript：一門運(yùn)行在(客戶端)瀏覽器端的腳本 編程 語言

創(chuàng)造者 布蘭登 艾奇
1995年利用10天完成JavaScript設(shè)計(jì)
腳本：戲劇的劇本杠纵。只要按照固定的流程走一遍枣购，就可以把整部戲演完了。但是如果中間有演員出事了焙贷，戲就暫停了。這個(gè)腳本指的是JavaScript的一個(gè)特點(diǎn)：如果執(zhí)行到某一行出錯(cuò)了重归，后面的就不會再繼續(xù)執(zhí)行了

JavaScript的組成

1. ECMASCRIPT: 定義了javascript的語法規(guī)范,描述了語言的基本語法和數(shù)據(jù)類型
2. BOM (Browser Object Model): 瀏覽器對象模型

• 有一套成熟的可以操作瀏覽器的 API挚冤，通過 BOM 可以操作瀏覽器。比如： 彈出框涌哲、瀏覽器跳轉(zhuǎn)、獲取分辨率等

3. DOM (Document Object Model): 文檔對象模型

• 有一套成熟的可以操作頁面元素的 API尚镰，通過 DOM 可以操作頁面中的元素阀圾。比如： 增加個(gè) div，減少個(gè) div狗唉，給div 換個(gè)位置等
  總結(jié)： JS 就是通過固定的語法去操作 瀏覽器 和 標(biāo)簽結(jié)構(gòu) 來實(shí)現(xiàn)網(wǎng)頁上的各種效果

引入方式

• 內(nèi)嵌式：demo學(xué)習(xí)階段的主要寫法

<script>
  alert('hello world');
</script>

• 外鏈?zhǔn)剑盒陆ㄒ粋€(gè)JS文件初烘，文件里JS的代碼，引入HTML頁面內(nèi)分俯；作為個(gè)文件可以重復(fù)使用账月，項(xiàng)目開發(fā)階段使用；

   <script src="./01-demo.js"></script>
  

  • 行內(nèi)式：了解澳迫，一般不用

  <input type="button" value="點(diǎn)我" onclick="alert('helloworld')">
  

JS 注釋

• 語法：注釋更好的屢清楚你的業(yè)務(wù)邏輯局齿；不會執(zhí)行

// alert('hello world');  單行注釋，一般就是簡單的做個(gè)說明

/*
* 多行注釋
* 一般把想要注釋的內(nèi)容寫到這里面來橄登，大段內(nèi)容抓歼；不能 嵌套使用；
*/

輸入輸出

• 作用：交互的簡單入口拢锹，可以給頁面輸入我們想要輸入的信息谣妻，頁面輸出一定的信息；為了與你寫的代碼更好交流和調(diào)試卒稳；

• 輸入：頁面中彈出 輸入框蹋半，需要輸入內(nèi)容后才能繼續(xù)；開發(fā)不常用充坑，我們只是為了配合學(xué)習(xí)减江；

// 彈框
        alert('彈框');
        // 帶輸入框的彈框
        prompt('帶輸入框的彈框');
        // 控制臺輸出(打印)
        console.log('控制臺輸出');
        // 逗號隔開可以輸出多個(gè)內(nèi)容
        console.log('西游記', '三國演義');
        // 在頁面輸出標(biāo)簽文字
        document.write('在頁面上輸出');
        document.write('<strong>哈哈哈來點(diǎn)字</strong>');

變量

注意：

1. 一個(gè)變量名只能存儲一個(gè)值
2. 當(dāng)再次給一個(gè)變量賦值的時(shí)候，前面一次的值就沒有了
3. 變量名稱區(qū)分大小寫（JS 區(qū)分大小寫）

  // 聲明變量  變量的作用是存儲數(shù)據(jù)
        // var a;
        // 變量賦值 = 賦值運(yùn)算符 把右邊的數(shù)據(jù)存儲到左邊的變量里面去
        // a = 10;
        // 變量聲明并賦值 變量的初始化
        // 弱數(shù)據(jù)類型
        // var a = 10;
        // var b = '哈哈哈';
        // var n1 = 100;
        // var n2 = 200;
        // console.log(n1 + n2);
        // 把用戶輸入的信息存儲到變量里邊去
        // var age = prompt('請告訴我您的芳齡');
        // console.log(age);
        //  變量可以多次賦值
        // var name = '孫悟空';
        // var name = '豬八戒';
        // console.log(name);
        // var num3 = 50;
        // 把右側(cè)的結(jié)果賦值給左邊的num3
        // num3 = num3 + 1;
        // console.log(num3);

交換變量的兩種方法

   // 需求a=6;b=5;
        // 思路 定義一個(gè)第三方變量c 先把a(bǔ)變量的值賦給c,再把b的值賦值給a,把c的值賦值給b
        var a = '老孫';
        var b = '老豬';
        var c = a;
        a = b;
        b = c;
        console.log(a);
        // 交換數(shù)字變量
        // 思路2 求和 a=a+b 已知a+b的和11還有b是6
        var a = 5;
        var b = 6;
        a = b + a;
        b = a - b;
        a = a - b;
        console.log(a);

同時(shí)聲明多個(gè)變量

//1 變量可以一次性聲明多個(gè)
var a,b,c,d;

// 2 還可以聲明多個(gè)的同時(shí)進(jìn)行賦值捻爷；
var a = 10;
var a = 10,b = 20,c = 30;


//3 變量也可以作為另一個(gè)變量的值
var a = 10;
// 賦值給b（復(fù)制了一份）,a再次變化時(shí)辈灼，b不受影響；
var b = a;

命名

• 范圍：字母也榄、數(shù)字巡莹、下劃線、$符號；
• 不能：變量名字不能用數(shù)字作為開頭

// 變量不能使用數(shù)字開頭
var 15a = 10;

// 會在控制臺中報(bào)錯(cuò)：Uncaught SyntaxError: Unexpected 
// Uncaught - 未捕獲的
// SyntaxError - 語法錯(cuò)誤

// Unexpected - 意料之外的
// number - 數(shù)字
// 翻譯過來就是： 這行有一個(gè)語法錯(cuò)誤降宅，你的數(shù)字不符合語法要求

• 變量名字不能使用JavaScript語法中的關(guān)鍵字和保留字
• 關(guān)鍵字：在JavaScript語法中骂远，具有特殊意義的單詞，比如我們學(xué)習(xí)過的用于聲明變量的var腰根；后面要學(xué)習(xí)的if else for wihle case break....

// 變量名字不能使用關(guān)鍵字
var var = 20;
// 會在控制臺中報(bào)錯(cuò)： Uncaught SyntaxError: Unexpected token var
// token - 標(biāo)記激才，記號，在編程中我們翻譯成 '標(biāo)識符'
// 意思是這行有一個(gè)語法錯(cuò)誤唠雕，出現(xiàn)了一個(gè)意料之外的標(biāo)識符 var

• 保留字：JavaScript是不斷發(fā)展的，以前的功能用了以前的關(guān)鍵字吨述，將來要加入新的功能的時(shí)候岩睁，可能要用到新的關(guān)鍵字，所有JavaScript在一開始的時(shí)候就保留了部分單詞揣云，以便將來把保留的單詞作為關(guān)鍵字

• 變量名字是區(qū)分大小寫的捕儒；

// 變量名字是區(qū)分大小寫的
var a = 10;
console.log(a);// 正常輸出

console.log(A);// 在控制臺中報(bào)錯(cuò)：Uncaught ReferenceError: A is not defined
// ReferenceError - 引用錯(cuò)誤
// not defined - 未定義
// 意思是 A 這個(gè)變量我們沒有定義就使用了，可見a和A是不一樣的邓夕，不是同一個(gè)變量

• 如何定義呢刘莹？
  • 設(shè)置和你公司業(yè)務(wù)有關(guān)系的變量，取英文的翻譯
  • 使用駝峰（第一個(gè)單詞的第一個(gè)字母小寫焚刚，第二個(gè)單詞的首字母大寫）点弯；getData
  • 個(gè)人習(xí)慣：get_data

// 駝峰 getData
var userName = '張三';
var password = '123456';

// 個(gè)人習(xí)慣 get_data

字符串轉(zhuǎn)義符

    類似HTML里面的特殊字符，字符串中也有特殊字符矿咕，我們稱之為轉(zhuǎn)義符抢肛。

    轉(zhuǎn)義符都是 \ 開頭的，常用的轉(zhuǎn)義符及其說明如下：

• 特殊的字符："" '' \

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

• 是指我們存儲在內(nèi)存中的數(shù)據(jù)的類型
• 我們通常分為兩大類 基本數(shù)據(jù)類型 和 復(fù)雜數(shù)據(jù)類型

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

//八進(jìn)制 八進(jìn)1  0開頭
        // var h = 011;
        // console.log(h);
        // 十六進(jìn)制 由0-9，a-f組成  0x開頭
        // var f = 0x10;

1. 數(shù)值類型（number）
   • 一切數(shù)字都是數(shù)值類型（包括二進(jìn)制莲镣，十進(jìn)制福稳，十六進(jìn)制等）
   • NaN（not a number），一個(gè)非數(shù)字
2. 字符串類型（string）
   • 被引號包裹的所有內(nèi)容（可以是單引號也可以是雙引號）
3. 布爾類型（boolean）
   • 只有兩個(gè)（true 或者 false）
4. null類型（null）
   • 只有一個(gè)瑞侮，就是 null的圆，表示空的意思
5. undefined類型（undefined）
   • 只有一個(gè)，就是 undefined半火，表示沒有值的意思

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

• 數(shù)據(jù)類型之間的轉(zhuǎn)換略板，比如數(shù)字轉(zhuǎn)成字符串，字符串轉(zhuǎn)成布爾慈缔，布爾轉(zhuǎn)成數(shù)字等

其他數(shù)據(jù)類型轉(zhuǎn)成數(shù)值

1. Number(變量)

   • 可以把一個(gè)變量強(qiáng)制轉(zhuǎn)換成數(shù)值類型
   • 可以轉(zhuǎn)換小數(shù)叮称，會保留小數(shù)
   • 可以轉(zhuǎn)換布爾值
   • 遇到不可轉(zhuǎn)換的都會返回 NaN

2. parseInt(變量)

   • 從第一位開始檢查，是數(shù)字就轉(zhuǎn)換，直到一個(gè)不是數(shù)字的內(nèi)容
   • 開頭就不是數(shù)字瓤檐，那么直接返回 NaN
   • 不認(rèn)識小數(shù)點(diǎn)赂韵，只能保留整數(shù)

3. parseFloat(變量)

• 從第一位開始檢查，是數(shù)字就轉(zhuǎn)換挠蛉，直到一個(gè)不是數(shù)字的內(nèi)容

• 開頭就不是數(shù)字祭示，那么直接返回 NaN

• 認(rèn)識一次小數(shù)點(diǎn)

4. 除了加法以外的數(shù)學(xué)運(yùn)算

   • 運(yùn)算符兩邊都是可運(yùn)算數(shù)字才行
   • 如果運(yùn)算符任何一遍不是一個(gè)可運(yùn)算數(shù)字，那么就會返回 NaN
   • 加法不可以用

轉(zhuǎn)換為數(shù)字類型

number方法

 var age = prompt('請輸入您的年齡');
        console.log(typeof age);
        console.log(age + 10);
        // 其他類型轉(zhuǎn)數(shù)值類型 Number()
        var a = '15.32';
        // 非數(shù)字字符串轉(zhuǎn)成數(shù)字類型是NaN not number NaN 是數(shù)字類型
        var b = '89.9孫悟空';
        // 字符串的空  false true 轉(zhuǎn)數(shù)字類型是0
        var x = '';
        var c = true;
        var d = false;
        var e;
        var f=null;
        var h=Number(b);
        console.log(h,typeof h);

取整parseInt

// parseInt()取整 數(shù)字開頭的非純數(shù)字字符串也可以取整
        // ''字符串的空 true false null 轉(zhuǎn)數(shù)字類型是NaN
        var h = parseInt(b);
        console.log(h, typeof h);

取小數(shù)parseFloat

 // parseFloat()取整 數(shù)字開頭的非純數(shù)字字符串也可以取小數(shù)
        // ''字符串的空 true false null 轉(zhuǎn)數(shù)字類型是NaN
        var h = parseFloat(b);
        console.log(h, typeof h);

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

// 隱式數(shù)據(jù)轉(zhuǎn)化 - * /   如果用+號會直接用數(shù)字加字符串   特殊的true false等除外
        var a = 10;
        var b = '20';
        var c = true;
        console.log(a + b);
        console.log(a - b);
        console.log(a * b);

其他類型轉(zhuǎn)換字符串類型

var a = '15';
        var b = '89.25';
        var c = true;
        var d = false;
        var e = null;
        var h = undefined;
        String()
        var x = String(h);
        console.log(x, typeof x);
        變量.toString() 這種方法不能轉(zhuǎn)undefined和null
        var x = h.toString();
        console.log(x, typeof x);
        +號拼接  加號兩邊只要有一個(gè)字符串 加號就是拼接符
        h = '' + h;
        console.log(h, typeof h);

其他類型轉(zhuǎn)換為布爾類型

// 其他類型轉(zhuǎn)布爾類型
        // false ,'' , undefined , null NaN 0轉(zhuǎn)換之后是false  其他轉(zhuǎn)換都是true
        var f = false;
        var h = '';
        var i = undefined;
        var j = null;
        var k = NaN;
        var z = 0;
        var y = Boolean(z);
        console.log(y, typeof y);

操作符

數(shù)據(jù)運(yùn)算：數(shù)據(jù)參加比較谴古、運(yùn)算
字符串+：與字符串臨近的類型质涛，轉(zhuǎn)為字符串；里面存在一個(gè)隱式轉(zhuǎn)化掰担；看不到的轉(zhuǎn)化汇陆；隱式轉(zhuǎn)化：在字符串+情況下，數(shù)字隱轉(zhuǎn)為字符串带饱；

• 情況：
  • 字符串 + 毡代；
  • +字符串；

// 字符串 +
// 從左到右執(zhí)行勺疼，數(shù)字相加教寂，字符串拼接
var res3 = 10+10+"abc"+"def";
console.log(res3);  //輸出 20abcdef
 // 算術(shù)運(yùn)算符+ - * / %
        // + 只要兩邊有一個(gè)字符類型  +就是拼接符 2邊都是數(shù)字類型  就是加運(yùn)算
        // - * / 會有隱式類型轉(zhuǎn)換
        // %取余(模)

字符串 其他

• 字符串遇見 * / - %；
• 隱式轉(zhuǎn)化：字符串會隱式轉(zhuǎn)化轉(zhuǎn)為Number执庐，再次參加運(yùn)算酪耕；

var res3 = '456' - 123; 
console.log(res3); // 輸出 數(shù)字 333

// 'abc' 隱式轉(zhuǎn)化為NaN，所有輸出NaN轨淌；
var res4 = 'abc' - 123;
console.log(res4); // 輸出NaN

• 其實(shí)字符串遇見 * / % 一樣的結(jié)果因妇；
  • 最終都是參與了隱式轉(zhuǎn)化（只是我們看不見這個(gè)轉(zhuǎn)化過程，但是實(shí)質(zhì)還是這些數(shù)據(jù)被Number()猿诸；

自增自減

        // ++i i++ 只操作一個(gè) 數(shù)據(jù)的叫一元運(yùn)算符  2+3操作2個(gè)數(shù)據(jù)就叫二院操作符
        // 自增++i i++不參與運(yùn)算的情況下 是一樣的  都是自身加1
        var i = 10;
        // 自增參與運(yùn)算  ++i前置自增  先自身加1 再參與運(yùn)算
        var a = ++i;
        // i++后置自增  先參與運(yùn)算 再自身加1
        // 注意后置自增 到了運(yùn)算符另一邊 已經(jīng)自身加1
        var a = i++;

數(shù)學(xué)運(yùn)算符

1. +

   • 只有符號兩邊都是數(shù)字的時(shí)候才會進(jìn)行加法運(yùn)算
   • 只要符號任意一邊是字符串類型婚被，就會進(jìn)行字符串拼接

2. -

• 會執(zhí)行減法運(yùn)算

• 會自動把兩邊都轉(zhuǎn)換成數(shù)字進(jìn)行運(yùn)算

3. *

   • 會執(zhí)行乘法運(yùn)算
   • 會自動把兩邊都轉(zhuǎn)換成數(shù)字進(jìn)行運(yùn)算

4. /

   • 會執(zhí)行除法運(yùn)算
   • 會自動把兩邊都轉(zhuǎn)換成數(shù)字進(jìn)行運(yùn)算

5. %

   • 會執(zhí)行取余運(yùn)算
   • 會自動把兩邊都轉(zhuǎn)換成數(shù)字進(jìn)行運(yùn)算

賦值運(yùn)算符

1. =

   • 就是把 = 右邊的賦值給等號左邊的變量名
   • var num = 100
   • 就是把 100 賦值給 num 變量
   • 那么 num 變量的值就是 100

2. +=

   var a = 10;
   a += 10;
   console.log(a); //=> 20
   

   • a += 10 等價(jià)于 a = a + 10

3. -=

   var a = 10;
   a -= 10;
   console.log(a); //=> 0
   

   • a -= 10 等價(jià)于 a = a - 10

4. *=

   var a = 10;
   a *= 10;
   console.log(a); //=> 100
   

   • a *= 10 等價(jià)于 a = a * 10

5. /+

   var a = 10;
   a /= 10;
   console.log(a); //=> 1
   

   • a /= 10 等價(jià)于 a = a / 10

6. %=

   var a = 10;
   a %= 10;
   console.log(a); //=> 0
   

   • a %= 10 等價(jià)于 a = a % 10

比較運(yùn)算符

1. ==
   • 比較符號兩邊的值是否相等，不管數(shù)據(jù)類型
   • 1 == '1'
   • 兩個(gè)的值是一樣的梳虽，所以得到 true
2. ===
   • 比較符號兩邊的值和數(shù)據(jù)類型是否都相等
   • 1 === '1'
   • 兩個(gè)值雖然一樣址芯，但是因?yàn)閿?shù)據(jù)類型不一樣，所以得到 false
3. !=
   • 比較符號兩邊的值是否不等
   • 1 != '1'
   • 因?yàn)閮蛇叺闹凳窍嗟鹊拇芫酰员容^他們不等的時(shí)候得到 false
4. !==
   • 比較符號兩邊的數(shù)據(jù)類型和值是否不等
   • 1 !== '1'
   • 因?yàn)閮蛇叺臄?shù)據(jù)類型確實(shí)不一樣谷炸，所以得到 true
5. >=
   • 比較左邊的值是否 大于或等于 右邊的值
   • 1 >= 1 true
   • 1 >= 0 true
   • 1 >= 2 false
6. <=
   • 比較左邊的值是否 小于或等于 右邊的值
   • 1 <= 2 true
   • 1 <= 1 true
   • 1 <= 0 false
7. >
   • 比較左邊的值是否 大于 右邊的值
   • 1 > 0 true
   • 1 > 1 false
   • 1 > 2 false
8. <
   • 比較左邊的值是否 小于 右邊的值
   • 1 < 2 true
   • 1 < 1 false
   • 1 < 0 false

        // >< >= <= ==(等于) === != !==  比較運(yùn)算符返回的結(jié)果都是true或者false
        var a = 5;
        var b = '5';
        var c = '7';
        var d = 5;
 // == 等于 對數(shù)據(jù)類型沒有要求  只要是值相等  就返回true 值不相同  返回false
        var res5 = b == c;
// != 不等于  只比較值是否不等  不等返回true 不管數(shù)據(jù)類型 只要值相等就返回false
        var res6 = a != b;
 // === 全等嚴(yán)格的判斷  必須數(shù)據(jù)類型和值完全相等,返回true  否則就返回false
        var res5 = a === b;
 // !== 全不等  值和數(shù)據(jù)類型有一個(gè)不相等 返回true 數(shù)據(jù)類型和值完全相等返回false 
        var res7 = a !== b;

// 不同類型：特別的null 、undefined
// undefined和null與其他Number類型在進(jìn)行相等判斷時(shí)不進(jìn)行類型轉(zhuǎn)換禀挫。
console.log(null==0)         //false
console.log(0 == undefined); //false

// ECMAScript認(rèn)為undefined是從null派生出來的旬陡，所以把它們定義為相等的;
console.log(null==undefined)  // true


// 輸出 false ,比較兩個(gè)數(shù)據(jù)的值是否不相等, 此時(shí)兩個(gè)數(shù)據(jù)的 值 都 4 ，相等语婴，結(jié)果是 false
console.log('4'!= 4); 

// 輸出 true 描孟，比較兩個(gè)數(shù)據(jù)的類型和值是否不相等驶睦，此時(shí)兩個(gè)數(shù)據(jù)的類型不相等，結(jié)果是 true
console.log('4'!== 4); 

邏輯運(yùn)算符

1. &&
   • 進(jìn)行 且 的運(yùn)算
   • 符號左邊必須為 true 并且右邊也是 true匿醒，才會返回 true
   • 只要有一邊不是 true场航，那么就會返回 false
   • true && true true
   • true && false false
   • false && true false
   • false && false false
2. ||
   • 進(jìn)行 或 的運(yùn)算
   • 符號的左邊為 true 或者右邊為 true，都會返回 true
   • 只有兩邊都是 false 的時(shí)候才會返回 false
   • true || true true
   • true || false true
   • false || true true
   • false || false false
3. !
   • 進(jìn)行 取反 運(yùn)算
   • 本身是 true 的廉羔，會變成 false
   • 本身是 false 的溉痢，會變成 true
   • !true false
   • !false true

 // 邏輯運(yùn)算符正常情況下返回true或者false
        // 邏輯與&& 兩邊都是true  返回true 只要有一邊是false 返回false 見假為假
        var res = true && true;
        var res = false && false;
        // 邏輯或||兩邊只要有一個(gè)true 返回 true 兩邊都是false 返回false 見真即真
        var res = true || true;
        var res = 3 < 2 || 5 < 3;
        // 邏輯!取反
        var res = !true;
        var res = !false;

自增自減運(yùn)算符（一元運(yùn)算符）

1. ++

   • 進(jìn)行自增運(yùn)算

   • 分成兩種，前置++ 和 后置++

   • 前置++憋他，會先把值自動 +1孩饼，在返回

     var a = 10;
     console.log(++a);
     // 會返回 11，并且把 a 的值變成 11
     

   • 后置++竹挡，會先把值返回镀娶，在自動+1

     var a = 10;
     console.log(a++);
     // 會返回 10，然后把 a 的值變成 11
     

2. --

   • 進(jìn)行自減運(yùn)算
   • 分成兩種此迅，前置-- 和 后置--
   • 和 ++ 運(yùn)算符道理一樣

優(yōu)先級

• 大致優(yōu)先級：

  • 括號先算
  • 其次算算術(shù)：++a優(yōu)先;
  • 再次算比較 > ==
  • 然后算邏輯 && ||
  • 最后算賦值 =

• 觀察代碼

var a = 200 === (10 + 10) * 10 > 1;

// 先算括號
200===20*10>1

// 在算計(jì)算
200===200>1

// 算右側(cè)汽畴；
200===true;

// false
console.log(a); 

• 具體計(jì)算優(yōu)先級

1. 第一優(yōu)先級： [] . ()
2. 第二優(yōu)先級： ++ -- !
3. 第三優(yōu)先級： *  /  %
4. 第四優(yōu)先級： +  -
5. 第五優(yōu)先級： >   >=   <   <=
6. 第六優(yōu)先級： ==   !=    ===    !==  
7. 第七優(yōu)先級： &&
8. 第八優(yōu)先級： || 
9. 第九優(yōu)先級： = += -= *= /= %=  

基礎(chǔ)二

程序：來源生活旧巾，高于生活耸序；

分支結(jié)構(gòu)判斷

if

// if單分支
        // if (條件表達(dá)式) {
        //     // 當(dāng)條件表達(dá)式為true的時(shí)候 執(zhí)行該處代碼
        // }
        // 需求  判斷一個(gè)男孩,如果年齡大于等于18 彈出提示框就可以進(jìn)網(wǎng)吧了
        // if(條件表達(dá)式){
        //     如果條件表達(dá)式為true, 執(zhí)行該處代碼
        // }else{
        //     如果條件為false 執(zhí)行該處代碼
        // }
        var boy = prompt('請輸入您的年齡');
        boy = Number(boy);
        if (boy > 18) {
            alert('請進(jìn)吧')
        } else {
            alert('小屁孩,回家洗洗睡吧')
        }

  // 請用戶輸入一個(gè)數(shù)字,判斷是不是偶數(shù)
        var num = Number(prompt('請輸入一個(gè)數(shù)字'));
        if (num % 2 == 0) {
            console.log('這是一個(gè)偶數(shù)');
        } else {
            console.log('這是一個(gè)奇數(shù)');
        }

 if(條件表達(dá)式1){
                如果條件表達(dá)式1的結(jié)果為ture 執(zhí)行該處代碼
            }else if(條件表達(dá)式2){
                如果條件表達(dá)式2的結(jié)果為ture 執(zhí)行該處代碼
            }else if(條件表達(dá)式n){
                如果條件表達(dá)式n的結(jié)果為ture 執(zhí)行該處代碼
            }else{
                如果上面的條件表達(dá)式都為false 執(zhí)行該處代碼
            }

// 輸入學(xué)生成績 90-100A 80-90B 70-80C 60-70D <60E
        var num = Number(prompt('輸入您的成績'));
        if (90 < num && num <= 100) {
            console.log('A');
        } else if (80 < num && num <= 90) {
            console.log('B');
        } else if (70 < num && num <= 80) {
            console.log('C');
        } else if (60 < num && num <= 70) {
            console.log('D');
        } else {
            console.log('E');
        }
//第二種方法
   var num = Number(prompt('輸入您的成績'));
        if (num >= 90) {
            alert('A')
        } else if (num >= 80) {
            alert('B')
        } else if (num >= 70) {
            alert('C')
        } else if (num >= 60) {
            alert('D')
        } else {
            alert('E')
        }
//第三種
var a = Number(prompt('輸入成績'));
        var b = parseInt(Number(a / 10));
        switch (b) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                alert('e')
                break;
            case 6:
                alert('d')
                break;
            case 7:
                alert('c')
                break;
            case 8:
                alert('b')
                break;
            case 9:
                alert('a')
                break;
            case 10:
                alert('恭喜滿分')
                break;
            default:
                alert('輸入錯(cuò)誤')

        }

switch

 switch (變量) {
            case 值1:
                當(dāng)變量和case后邊的值1全等 === 數(shù)據(jù)類型和值完全相等
                執(zhí)行該代碼
                break的作用是阻斷代碼向下執(zhí)行
                break;
            case 值2:
                當(dāng)變量和case后邊的值2全等 === 數(shù)據(jù)類型和值完全相等
                執(zhí)行該代碼
                break的作用是阻斷代碼向下執(zhí)行
                break;
                case 值n:
                當(dāng)變量和case后邊的值n全等 === 數(shù)據(jù)類型和值完全相等
                執(zhí)行該代碼
                break的作用是阻斷代碼向下執(zhí)行
                break;
                default:
                    當(dāng)變量和case后邊的值都不相等 執(zhí)行該處代碼
                    break;

        }

        var week = Number(prompt('親 請輸入周幾  我會告訴你菜譜'));
        switch (week) {
            case 1:
                alert('紅燒肉')
                break;
            case 2:
                alert('宮保雞丁')
                break;
            case 3:
                alert('糖醋鯉魚')
                break;
            case 4:
                alert('燒烤')
                break;
            case 5:
                alert('火鍋')
                break;
            case 6:
                alert('滿漢全席')
                break;
            case 7:
                alert('宮廷盛宴')
                break;
            // default:
            //     alert('宮廷盛宴')

        }

三元表達(dá)式

• 表達(dá)式：有值會返回；

• 語法：if else 的簡寫鲁猩；有返回值坎怪；

  // 表達(dá)式1 ? 表達(dá)式2 : 表達(dá)式3;
  
  // 首先 要知道 表達(dá)式 會返回結(jié)果；
  // 過程：先執(zhí)行表達(dá)式1廓握，判斷其結(jié)果是true還是false搅窿，
  // 如果是true，則執(zhí)行表達(dá)式2隙券，然后將 表達(dá)式2的執(zhí)行結(jié)果 作為整個(gè)三元表達(dá)式的結(jié)果進(jìn)行返回男应，
  // 如果是false，則執(zhí)行表達(dá)式3娱仔，并將 表達(dá)式3的結(jié)果 作為整個(gè)三元表達(dá)式的結(jié)果
  
  //例如： 求二個(gè)數(shù)字中誰更大
  var a = 10; var b = 20;
  var max = a > b ? a : b;
  console.log(max);
  

     // 三元表達(dá)式
          // 表達(dá)式1? 表達(dá)式2: 表達(dá)式3
          // 如果表達(dá)式1位true 執(zhí)行表達(dá)式2 如果為false執(zhí)行表達(dá)式3
          var a = 10;
          var b = 50;
          // a和b的最大值
          a > b ? alert(a + '大') : alert(b + '大');
  

   var i = 0;
          // 三元表達(dá)式? 前邊的表達(dá)式也會隱式類型轉(zhuǎn)換為布爾值
          var num = i++ ? i++ : ++i;
          console.log(num);
  
  

循環(huán)結(jié)構(gòu)

for循環(huán)

• 執(zhí)行過程：

1. 執(zhí)行初始化表達(dá)式(只執(zhí)行一次)
2. 執(zhí)行條件表達(dá)式
3. 如果條件表達(dá)式的結(jié)果為false, 結(jié)束循環(huán)沐飘；
4. 如果條件表達(dá)式的結(jié)果為true，執(zhí)行循環(huán)體
5. 執(zhí)行自增表達(dá)式
6. 重復(fù)2~5的步驟牲迫，直到條件表達(dá)式的結(jié)果為false耐朴，結(jié)束循環(huán)

for(初始化表達(dá)式; 條件表達(dá)式; 自增表達(dá)式){
  // 循環(huán)體
}
// 在頁面上打印1-100
        for (var i = 1; i <= 100; i++) {
            console.log(i);
        }

 // 求1 - 10的和 1 + 2 + 3...
        var sum = 0;
        for (i = 1; i <= 10; i++) {
            sum += i;
        }
        console.log(sum);

 // 求1-100之間所有的偶數(shù)的和
        var sum = 0;
        for (i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                sum += i;
            }
        }
        console.log(sum);

 // 求1-4的乘積
        var sum = 1;
        for (i = 1; i <= 4; i++) {
            sum *= i;
        }
        console.log(sum);

雙層for循環(huán)

  // 打印10行 每一行都是5課星
        // 循環(huán)是重復(fù)做一件事 條件不滿足的時(shí)候循環(huán)結(jié)束
        // 外層for循環(huán)控制的是行數(shù)
        for (var j = 1; j <= 10; j++) {
            for (var i = 1; i <= 5; i++) {
                document.write("★");
            }
            document.write("<br>")
        }

   // 直角三角形
        for (var j = 1; j <= 9; j++) {
            for (var i = 1; i <= j; i++) {
                document.write("★");
            }
            document.write("<br>")
        }

  // 倒三角
        for (var j = 1; j <= 9; j++) {
            for (var i = 1; i <= 10 - j; i++) {
                document.write("★");
            }
            document.write("<br>")
        }

 <!-- 等腰三角形 -->
    <style>
        body {
            text-align: center;
        }
    </style>
    <script>
        for (var j = 1; j <= 9; j++) {
            for (var i = 1; i <= j; i++) {
                document.write("<span>★</span>");
            }
            document.write("<br>")
        }
    </script>

    <!-- 九九乘法表 -->
    <style>
        span {
            display: inline-block;
            width: 100px;
            height: 30px;
            line-height: 30px;
            text-align: center;
            border: 1px solid #000000;
            margin-left: -1px;
            margin-bottom: -1px;
        }
    </style>
    <script>
        for (var j = 1; j <= 9; j++) {
            for (var i = 1; i <= j; i++) {
                document.write("<span>" + i + 'x' + j + '=' + i * j + "</span>");
            }
            document.write('<br>')
        }
    </script>

while循環(huán)

當(dāng)循環(huán)次數(shù)已知的時(shí)候用for循環(huán) 當(dāng)循環(huán)次數(shù)未知的時(shí)候用while和do while

    
        while (條件表達(dá)式) {
            // 當(dāng)條件表達(dá)是為true的時(shí)候  執(zhí)行循環(huán)體的代碼  條件表達(dá)式為false的時(shí)候  循環(huán)體代碼不執(zhí)行
        }
        // 求1-100的和
        var i = 1, sum = 0;
        while (i <= 100) {
            sum += i;
            i++;
        }
        console.log(sum);

 // 用戶名和密碼只要有一個(gè)輸入錯(cuò)誤 用戶就需要一直輸入
        var userName = prompt('用戶名')
        var passWord = prompt('密碼')
        while (userName != 'admin' || passWord != '123456') {
            userName = prompt('用戶名')
            passWord = prompt('密碼')
        }
        alert('登錄成功')

do while

  // do{
        //     循環(huán)體
        //     循環(huán)體首先執(zhí)行一次 再去看條件表達(dá)式 如果條件表達(dá)式為true 循環(huán)體繼續(xù)循環(huán) 如果為false 循環(huán)結(jié)束
        // }while(條件表達(dá)式)
        do {
            var userName = prompt('用戶名')
            var passWord = prompt('密碼')
        } while (userName != 'admin' || passWord != '123456') {
            alert('登錄成功');
        }

break和continue

• 循環(huán)退出：
  • 滿足條件退出
  • 關(guān)鍵字退出：某些情況下，我們不一定要循環(huán)從頭到尾執(zhí)行盹憎，這個(gè)時(shí)候就要使用break和continue控制循環(huán)的次數(shù)筛峭；

// break 結(jié)束的是當(dāng)前循環(huán)
/* 例子：電梯一共有6層，現(xiàn)在我們要上電梯陪每，我們的教室在3樓影晓，電梯只要到3樓就可以了镰吵。*/
for(var i = 1; i <= 6 ; i++ ){
    console.log('現(xiàn)在是'+i+'樓');
    if(i == 3){
        console.log('3樓到了，電梯停了俯艰，請下電梯捡遍。');
        // 程序 執(zhí)行到 3，執(zhí)行了四次就結(jié)束了竹握；
        break;
    }
}
// 這里案例用的是for循環(huán)演示画株，while 和do-while一樣；

// continue
// 電梯一共有6層啦辐，除了3樓沒人下去谓传，其他樓層都有人下去(3樓不停，其他樓層都要停)
for(var i = 1; i <= 6; i++){
    if(i == 3){
        // 執(zhí)行到 3 時(shí)芹关。當(dāng)前次的程序后面的全部跳過续挟；繼續(xù)執(zhí)行后面的次數(shù)；
        continiue;
    }
    console.log(i+'樓到了侥衬，電梯停了诗祸，請下電梯。');      
}

總結(jié)：這個(gè)地方只是用for做終止

• break用于結(jié)束整個(gè)循環(huán)

• continue用于結(jié)束整個(gè)循環(huán)中的一次轴总，結(jié)束當(dāng)前這次循環(huán)直颅；

• break和continue后面的代碼都不會執(zhí)行，執(zhí)行前面的代碼怀樟；

邏輯中斷 短路

// &&與操作(中斷)短路 找假 如果找不到就返回最后一個(gè)的值
        // var res = null && 3 && true;
        // console.log(res);
        // || 或操作(中斷)短路 找真 如果找不到到就返回最后一個(gè)的值
        var res = 0 || 3 || NaN;
        console.log(res);

習(xí)題練習(xí)

1- 判斷時(shí)間階段功偿。

?

• 題目描述：

  用戶輸入幾點(diǎn)彈出問候信息；

    如用戶輸入12點(diǎn)中午好往堡；
    
    用戶輸入18點(diǎn) 彈出傍晚好械荷；
  
    用戶輸入23點(diǎn)彈出深夜好；
  

• 題目提示：

  通過比較運(yùn)算符判定輸入的時(shí)間的范圍虑灰，彈出相應(yīng)的問候信息

     var i;
          var j = Number(prompt(i));
          if (j == 12) {
              alert('中午好');
          } else if (j == 18) {
              alert('傍晚好');
  
          } else if (j == 23) {
              alert('深夜好');
          } else {
              alert('輸入錯(cuò)誤');
          }
  

2 - 比較兩個(gè)數(shù)的最大值

• 題目描述：

  用戶依次輸入2個(gè)值吨瞎，最后彈出最大的那個(gè)值

• 題目提示：

  通過比較運(yùn)算符彈出最大值

       var i = Number(prompt('請輸入i的值'));
          var j = Number(prompt('請輸入j的值'));
          if (i > j) {
              alert('i' + '大')
          } else {
              alert('j' + '大')
  
          }
  

3 - 判斷奇偶性

• 題目描述：

  用戶輸入一個(gè)數(shù)，判斷是奇數(shù)還是偶數(shù)

• 題目提示：

  通過%運(yùn)算符可以得出數(shù)字的奇偶性

     var i = Number(prompt('請輸入數(shù)字判斷奇數(shù)還是偶數(shù)'))
          if (i % 2 == 0) {
              alert('偶數(shù)')
          } else {
              alert('奇數(shù)')
          }
  
  

4 - 判斷星期

• 題目描述：

• 周三 周四 周五 周六 周日 周一 周二 周三 周四 周五 周六 周日 周一

• 1 2 3 4 5 6 7 8 9 10 11 12 13

•   假設(shè)這個(gè)月1號是星期三穆咐，提示用戶輸入本月的日期（即1日-31日）颤诀，返回用戶輸入的那一天是星期幾
  

• 題目提示：

  利用%和7取余，再判定是星期幾

   var i = Number(prompt('請輸入日期'));
          if (i % 7 == 0) {
              alert('今天是周二')
          } else if (i % 7 == 1) {
              alert('今天是周三')
          } else if (i % 7 == 2) {
              alert('今天是周四')
          } else if (i % 7 == 3) {
              alert('今天是周五')
          } else if (i % 7 == 4) {
              alert('今天是周六')
          } else if (i % 7 == 5) {
              alert('今天是周日')
          } else if (i % 7 == 6) {
              alert('今天是周一')
          }
  

  //第二種解法 
  var day = Number(prompt('請輸入幾號'));
          day = (day + 2) % 7;
          if (day == 0) {
              alert('這一天是周日')
          } else {
              alert('這一天是周' + day);
          }
  

5 - 請客吃飯

• 題目描述：

  接收班長口袋里的錢數(shù)庸娱？

    若大于等于2000着绊，請大家吃西餐。                       2000<=j
  
    若小于2000熟尉，大于等于1500归露，請大家吃快餐。1500<=j<2000
  
    若小于1500斤儿，大于等于1000剧包，請大家喝飲料恐锦。 1000<=j<1500
  
    若小于1000，大于等于500疆液，請大家吃棒棒糖一铅。 500<=j<1000
  
    否則提醒班長下次把錢帶夠
  

• 題目提示：

  使用switch或者if else if 來進(jìn)行邏輯書寫

     var i = Number(prompt('班長口袋里面的錢數(shù)'));
          if (i >= 2000) {
              alert('請大家吃西餐')
          } else if (i < 2000 && i >= 1500) {
              alert('請大家吃快餐')
          } else if (i < 1500 && i >= 1000) {
              alert('請大家喝飲料')
          } else if (i < 1000 && i >= 500) {
              alert('請大家吃棒棒糖')
          } else {
              alert('班長下次把錢帶夠')
          }
  

  
          var i = Number(prompt('班長口袋里面的錢數(shù)'));
          var j = parseInt(i / 500);
          switch (j) {
              case 0:
                  alert('班長下次把錢帶夠')
                  break;
              case 1:
                  alert('請大家吃棒棒糖');
                  break;
              case 2:
                  alert('請大家喝飲料');
                  break;
              case 3:
                  alert('請大家吃快餐');
                  break;
              case 4:
                  alert('請大家吃西餐');
                  break;
          }
  

6 - 成績表

• 題目描述：

  分?jǐn)?shù)轉(zhuǎn)換,給一個(gè)分?jǐn)?shù)，判定等級堕油。大于等于90 A潘飘，大于等于80小于90 B，大于等于70小于80 C 掉缺，大于等于60小于70 D卜录，小于60 E

• 題目提示：

  使用if else if 來進(jìn)行邏輯書寫，當(dāng)使用if else if 時(shí)注意判定大小順序

    思考：是否可以使用switch完成本題目
  

var i = Number(prompt('請輸入你的成績'));
        var j = parseInt(i / 10);
        switch (j) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                alert('E')
                break;
            case 6:
                alert('D')
                break;
            case 7:
                alert('C')
                break;
            case 8:
                alert('B')
                break;
            default:
                alert('A')
        }

    var i = Number(prompt('請輸入你的成績'));
        if (i >= 90) {
            alert('A');
        } else if (i >= 80) {
            alert('B');
        } else if (i >= 80) {
            alert('C');
        } else if (i >= 70) {
            alert('D');
        } else {
            alert('E');
        }

 var score = Number(prompt('請輸入成績'));
        switch (true) {
            case score >= 90:
                alert('A')
                break;
            case score >= 80:
                alert('B')
                break;
            case score >= 70:
                alert('C')
                break;
            case score >= 60:
                alert('D')
                break;
            case score < 60:
                alert('E')
                break;
            default:
                alert('輸入錯(cuò)誤');
                break;

        }

?

1.1 求100以內(nèi)所有能被3和7整除的數(shù)的和

• 題目描述：

  • 把1-100之間所有能夠被3和7同時(shí)整除的數(shù)找出來眶明，計(jì)算累加和

• 題目提示：

  • 在算入累加和之前艰毒，使用%判定遍歷到的數(shù)字是不是可以被3和7整除
  • ``

  var sum = 0;
          for (i = 1; i <= 100; i++) {
              if (i % 3 == 0 && i % 7 == 0) {
                  sum += i;
              }
          }
          console.log(sum);
  

1.2 使用for循環(huán)打印三角形

• 題目描述：

  • 在控制臺一次性打印形狀如下：

    ☆
    ☆☆
    ☆☆☆
    ☆☆☆☆
    ☆☆☆☆☆

        var x = '';
            for (i = 1; i <= 5; i++) {
                for (j = 1; j <= i; j++) {
                    // console.log('★');
                    x = x + '★';
                    // document.write('★')
                }
                // document.write('<br>')
                console.log(x)
                x = '';
            }
    

            for (i = 1; i <= 5; i++) {
                for (j = 1; j <= i; j++) {
                    // console.log('★');
                    // x = x + '★';
                    document.write('★')
                }
                document.write('<br>')
                // console.log(x)
                // x = '';
            }
    

• 題目提示：

  • 利用雙重for循環(huán)

1.3 使用for循環(huán)打印99乘法表

• 題目描述：

  • 使用for循環(huán)，打印99乘法表

  • 在控制臺打印具體效果如下：

    1×1=1
    1×2=2 2×2=4
    1×3=3 2×3=6 3×3=9
    1×4=4 2×4=8 3×4=12 4×4=16
    1×5=5 2×5=10 3×5=15 4×5=20 5×5=25
    1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36
    1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49
    1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64
    1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81

• 題目提示：

  • 利用雙重for循環(huán)

    <style>
        span {
            display: inline-block;
            width: 100px;
            height: 50px;
            line-height: 50px;
            text-align: center;
            border: 1px solid #000000;
            margin-bottom: -1px;
            margin-left: -1px;
        }
    </style>
    <script>

        for (i = 1; i <= 9; i++) {
            for (j = 1; j <= i; j++) {
                document.write("<span>" + i + 'x' + j + '=' + i * j + "</span>");
            }
            document.write('<br>');

        }
    </script>

1.4 用戶登錄驗(yàn)證

• 題目描述：
  • 接收用戶輸入的用戶名和密碼搜囱，若用戶名為 “admin” ,且密碼為 “123456” ,則提示用戶登錄成功! 否則丑瞧，讓用戶一直輸入。
• 題目提示：
  • 利用while循環(huán)或者do while 循環(huán)

var userName = prompt('請輸入用戶名');
        var passWord = prompt('請輸入密碼');
        while (userName != 'admin' && passWord != '123456') {
            var userName = prompt('請輸入用戶名');
            var passWord = prompt('請輸入密碼');

        }
        alert('密碼輸入正確');

   do {
            var userName = prompt('請輸入用戶名');
            var passWord = prompt('請輸入密碼');
        } while (userName != 'admin' && passWord != '123456') {
            alert('密碼輸入正確');
        }

1.5 求1-100之間個(gè)位數(shù)不為3的數(shù)的累加和蜀肘。

• 題目描述：

  • 求整數(shù)1～100的累加值绊汹，但要求跳過所有個(gè)位為3的數(shù)。

• 題目提示：

  • 使用%判個(gè)位數(shù)是否為3
  • 用continue實(shí)現(xiàn)

      var sum = 0;
          for (var i = 1; i <= 100; i++) {
              //如果能被3整除幌缝，跳過continue
              if (i % 3 == 0) {
                  continue;
              }
              sum += i;
          }
          console.log(sum);
  
  

  var a = 0, sum = 0;
          for ( var i = 1; i <= 100; i++) {
              a += i;
              if (i % 10 == 3) {
                  sum += i;
              }
          }
          console.log(a - sum);
  

  var sum = 0;
          for (i = 1; i <= 100; i++) {
              if (i % 10 != 3) {
                  sum += i;
              }
  
          }
          console.log(sum);
  

2.1 簡易ATM

• 題目描述：

  • 里面現(xiàn)存有 100 塊錢灸促。

  • 如果存錢诫欠，就用輸入錢數(shù)加上先存的錢數(shù), 之后彈出顯示余額提示框

  • 如果取錢涵卵，就減去取的錢數(shù)，之后彈出顯示余額提示框

  • 如果顯示余額荒叼，就輸出余額

  • 如果退出轿偎，彈出退出信息提示框

    操作界面如下

    
    
    a.gif

圖片1.png

• 題目提示：

  • 通過輸入的數(shù)值判斷用戶操作
  • 定義一個(gè)變量，保存錢數(shù)
  • 先接收一下用戶輸入的數(shù)字 存到變量里邊
  • 用while循環(huán)
  • whilie循環(huán)里邊被廓，switch case 比較簡單

 var money = 100
        for (let i = 0; i < 5; i++) {
            var work = parseFloat(prompt("請輸入你要進(jìn)行的操作" + "\n" + "1.存錢" + "\n" + "2.取錢" + "\n" + "3.顯示金額" + "\n" + "4.退出"))
            switch (work) {
                case 1:
                    var cun = parseFloat(prompt('請輸入你要存的金額'));
                    money += cun;
                    alert("你的剩余金額是" + money);
                    break;
                case 2:
                    var qu = parseFloat(prompt('請輸入你要取出的金額'));
                    money = money - qu;
                    alert("你的剩余金額是" + money);
                    break;
                case 3:
                    alert("你的剩余金額是" + money);
                default:
                    break;
            }
        }

//開關(guān)閥atm
 var flag = true;
        var money = 100;
        while (flag) {
            var mes = Number(prompt('請輸入你的操作:\n1.存錢\n2.取錢\n3.顯示余額\n4.退出'));
            switch (mes) {
                case 1:
                    var pay = Number(prompt('請輸入您的存款金額'));
                    money += pay;
                    alert('您的余額是' + money);
                    break;
                case 2:
                    var get = Number(prompt('請輸入您的取款金額'));
                    money -= get;
                    alert('您的余額是' + money);
                    break;
                case 3:
                    alert('您的余額是' + money);
                    break;
                case 4:
                    flag = false;
            }
        }

2.2 求從1 開始第35個(gè)能被7和3整除的整數(shù)

• 題目描述：

  • 求從1開始第35個(gè)能被7和3整除的整數(shù)

• 題目提示：

  • 通過變量記錄是第幾個(gè)可以被3和7整除的數(shù)

 var num = 1, count = 0, result = 0;
        for (var i = 1; i <= num; i++) {
            num++;
            if (i % 3 == 0 && i % 7 == 0) {
                // 使用result把i的值取出來
                result = i;
                // 取出一個(gè)i count自增一次
                count++;
                // 到第35個(gè)i的時(shí)候循環(huán)終止
            } else if (count == 35) {
                break;
            }
        }
        console.log(result);

 var i = 1, count = 0, result = 0;
        while (count < 35) { //當(dāng)count等于35的時(shí)候就會停止執(zhí)行
            i++; //i的自增bai
            if (i % 3 == 0 && i % 7 == 0) {
                result = i; //把能整除3和7的數(shù)字保存下來
                count++; //一旦發(fā)現(xiàn)一次能整除3和7的數(shù)字坏晦，就加1
            }
        }
        console.log(result);

     var a = 1; b = 0; //b 是計(jì)數(shù)器
        // b不等于35循環(huán)一直進(jìn)行下去 等于35的條件表達(dá)式為false 循環(huán)結(jié)束
        while (b != 35) {
            if (a % 7 == 0 && a % 3 == 0) {
                b++;
                if (b == 35) {
                    alert(a)
                }
            }
            a++;
        }

//開關(guān)法
   var a = 1, b = 0, flag = true; //b 是計(jì)數(shù)器
        // flag為true的時(shí)候 循環(huán)一直執(zhí)行  flag為false的時(shí)候 循環(huán)終止
        while (b != 35) {
            if (a % 7 == 0 && a % 3 == 0) {
                b++;
                if (b == 35) {
                    alert(a)
                    // 循環(huán)停止
                    flag = false;

                }
            }
            a++;
        }

2.3 斐波那契數(shù)列

“兔子數(shù)列”，指的是這樣一個(gè)數(shù)列：0嫁乘、1昆婿、1、2蜓斧、3仓蛆、5、8挎春、13看疙、21豆拨、34 ，55能庆， 89

特點(diǎn)是： 后一個(gè)月是前2個(gè)月的和

求第12個(gè)月的兔子數(shù)施禾？

提示：

 var a = 0, b = 1;
        for (i = 3; i <= 12; i++) {
            var c = a + b;
            a = b;
            b = c;
        }
        alert(c);

2.4 質(zhì)數(shù)

質(zhì)數(shù)是只能被1和他自身整除的數(shù)

比如7 1 2 3 4 5 6 7 是質(zhì)數(shù) 9不是質(zhì)數(shù) 1 2 3 4 5 6 7 8 9 因?yàn)?能被3整除

n 2, 3, 4 ,5 ,6 ...n - 1 , n

提示：

  開關(guān)法
// 用戶任意輸入一個(gè)數(shù) 如果是質(zhì)數(shù)彈框提示  如果不是質(zhì)數(shù) 彈出提示不是質(zhì)數(shù)
        var num = Number(prompt('請輸入一個(gè)數(shù) 我會告訴你他是不是質(zhì)數(shù)'));
        var flag = true;
        if (num == 2) {
            alert('質(zhì)數(shù)');
        }
        for (var i = 2; i < num; i++) {
            if (num % i == 0) {
                flag = false;
                alert('不是質(zhì)數(shù)');
                break;
            }
        }
        if (flag) {
            alert('質(zhì)數(shù)');
        } 

   var num = Number(prompt('請輸入一個(gè)數(shù)  我會告訴你他是不是質(zhì)數(shù)'));
        //num%2.......num-1 !=0是質(zhì)數(shù) num%2......num-1==0 說明不是質(zhì)數(shù)
        for (var i = 2; i < num; i++) {
            //比如num是6 這時(shí)候6%i==0 i是2 循環(huán)結(jié)束
            //比如num7 這時(shí)候7%(2.....6) !==0 然后循環(huán)結(jié)束  循環(huán)結(jié)束的時(shí)候 i應(yīng)該是num 這個(gè)數(shù)是質(zhì)數(shù)
            if (num % i == 0) {
                alert('不是質(zhì)數(shù)');
                break;
            }
        }
        //  當(dāng)num從2一直到num-1取余不等于0 這時(shí)候上邊的循環(huán)結(jié)束 循環(huán)結(jié)束的時(shí)候i++最后變成了num
        if (num == i) {
            alert('質(zhì)數(shù)');
        }

var num = Number(prompt('請輸入數(shù)字 判斷是否為質(zhì)數(shù)'));
        var con = 0;
        for (i = 1; i <= num; i++) {
            if (num % i == 0) {
                con++;
            }
        }
        // 循環(huán)結(jié)束之后 con的次數(shù)確定了 再進(jìn)行判斷  如果 num%(1...num)2次等于0  是質(zhì)數(shù) 否則不是質(zhì)數(shù)
        if (con == 2) {
            alert('質(zhì)數(shù)');
        } else {
            alert('不是質(zhì)數(shù)');
        }

   var count = 0;
        var num = Number(prompt('請輸入數(shù)字 判斷是否為質(zhì)數(shù)'));
        for (i = 2; i <= num; i++) {
            if (num % i == 0) {
                count++;
            }
        }
        if (count == 1) {
            alert('質(zhì)數(shù)');
        } else {
            alert('不是質(zhì)數(shù)')
        }

基礎(chǔ)三

介紹

• 數(shù)組是一個(gè)有順序、有長度的數(shù)據(jù)集合搁胆；
• 數(shù)組：類型Object弥搞；
• 特點(diǎn)：
  • 把數(shù)據(jù)放在一起；
  • 有先后位置上的順序渠旁；
  • 有數(shù)據(jù)的長度拓巧；

// 數(shù)組一組有序的有長度的數(shù)據(jù)集合 數(shù)組里面可以存儲任意的數(shù)據(jù)類型
        // 聲明數(shù)組
        // 1字面量聲明數(shù)組
        // 數(shù)組元素順序是靠索引來控制的 索引(下標(biāo))從0開始
        //創(chuàng)建一個(gè)空數(shù)組
        var arr = [];
        arr[0] = 89;
        arr[1] = 'www';
        arr[2] = true;
        console.log(arr);
        //創(chuàng)建一個(gè)有內(nèi)容的數(shù)組
        var arr1 = [12, 39, 'hahahha', 78];
        console.log(arr1);
        //拿到索引為0 順序上第一個(gè)位置上的數(shù)據(jù)
        //把數(shù)組[索引]格式當(dāng)成一個(gè)變量使用就行了
        console.log(arr1[0])

存值

• 數(shù)組中的數(shù)據(jù)使用索引管理。
• 索引 下標(biāo)：位置：方便放入存值和尋找一死；
• 索引 規(guī)則：用數(shù)字表示肛度，從0開始

//把成績存儲到數(shù)組中
arr[0] = 91;
arr[1] = 88;
arr[2] = 72;
arr[3] = 45;
arr[4] = 63;
console.log(arr); // 輸出 [91,88,72,45,63] 就是一個(gè)數(shù)據(jù)集合

• 把 數(shù)組[索引]格式當(dāng)成一個(gè)變量使用就行，

// 初始化賦值完成后投慈，也可以再次改變值承耿，把前面的值覆蓋掉；
arr[0] = 100;

• 如果一開始就知道數(shù)組了伪煤，可以直接使用一個(gè)簡單的語法存儲數(shù)據(jù)

var arr = [91,88,72,45,63];
console.log(arr); // 輸出的結(jié)果是一樣的

• 上面每個(gè)位置上存的都是數(shù)字類型加袋，可以為其他類型；

取值

• 把數(shù)據(jù)取出來抱既，得知道你要取哪個(gè)位置上的數(shù)據(jù)把职烧。
• 數(shù)據(jù)取值同樣使用索引取。

// 拿到索引為0防泵，順序上第一個(gè)位置上的數(shù)據(jù)蚀之；
// 把 數(shù)組[索引] 格式當(dāng)成一個(gè)變量使用就行；
console.log(arr[0]);

// 數(shù)組求和：班里的成績總和
var sum = arr[0] + arr[1] + arr[2] + arr[3] + arr[4];
console.log(sum); // 輸出370

遍歷

• 求成績總和：一個(gè)一個(gè)地把數(shù)組里面的數(shù)組取出來了捷泞，從索引 0 到最后一個(gè)索引足删，
• 索引從0開始到結(jié)束的過程，有重復(fù)的思想锁右，需要用到循環(huán)失受；

// 最初的寫法
var sum = arr[0] + arr[1] + arr[2] + arr[3] + arr[4];


// 循環(huán) 這個(gè)從0~最后一個(gè)索引，有重復(fù)的思想在里面咏瑟，使用循環(huán)拂到。
var sum = 0;
for(var i = 0; i <= 4; i++){
  sum += arr[i];
}
console.log(sum); // 輸出 370，和我們一個(gè)一個(gè)相加是一樣的

• 使用循環(huán)來遍歷數(shù)組码泞，當(dāng)數(shù)組中的數(shù)據(jù)比較多的時(shí)候兄旬，會比較方便。一般是使用for循環(huán)浦夷；

數(shù)組長度

語法

• 存取數(shù)據(jù)：涉及到就是數(shù)組的順序問題辖试，通過索引去存裙纪酢；

• 數(shù)組長度：數(shù)組中一共存放了多少個(gè)數(shù)據(jù)罐孝；

console.log(arr.length); // 數(shù)組.length 就是數(shù)組的長度

• 如果數(shù)組的長度是5呐馆，最后一個(gè)元素的索引就是4；
• 我們發(fā)現(xiàn)最大索引總是比長度少 1 莲兢，所以遍歷還可以這么寫

數(shù)組的索引

• 索引汹来，也叫做下標(biāo)，是指一個(gè)數(shù)據(jù)在數(shù)組里面排在第幾個(gè)的位置

• 注意： 在所有的語言里面改艇，索引都是從 0 開始的

• 在 js 里面也一樣收班，數(shù)組的索引從 0 開始

for(var i = 0; i <= arr.length - 1; i++){
  console.log(arr[i]);
}

// 簡化一下 
for(var i = 0; i < arr.length; i++){
  console.log(arr[i]);
}

 // i是索引值 從0開始
        // 數(shù)組里邊的最大索引值是數(shù)組名.length - 1
        var arr = [22, 5, 6, 7, 8, 98];
        for (i = 0; i < arr.length; i++) {
            console.log(arr[i]);
        }

  var arr = [22, 5, 6, 7, 8, 98];
        /*   數(shù)組長度小于數(shù)組的實(shí)際長度 后邊的元素會刪除掉
          arr.length=2;
          數(shù)組長度大于數(shù)組的實(shí)際長度 后邊的元素會顯示empty 就是undefined */
        arr.length = 9;
        //輸出數(shù)組內(nèi)的所有元素
        console.log(arr);
        //輸出數(shù)組的長度
        console.log(arr.length);
        //輸出索引值的第七位
        console.log(arr[7]);

數(shù)組后面追加元素

```js

// 數(shù)組后邊追加新元素 數(shù)組名[數(shù)組名.length]=值
// 0 1 2 3 4 n
// 數(shù)組長度1 2 3 4 5 n+1
var arr = [22, 5, 6, 98];
arr[arr.length]=32;
arr[arr.length]=50;
```

習(xí)題練習(xí)

        ### 求數(shù)組中所有數(shù)字的和以及平均值

• 分析：
  • 總和：循環(huán)遍歷，加在一個(gè)變量上得到谒兄；
  • 均值：總和 / 個(gè)數(shù)摔桦；（arr.length）

 var sum = 0;
        var arr = [2, 3, 4, 5];
        for (i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        console.log(sum, sum / arr.length);

求數(shù)組中的最大值

• 分析：生活中，一堆人最高的（人很多承疲，多到你一下看不出來）邻耕；
  • 最大值：最起碼得兩個(gè)數(shù)比較下，得到最大值燕鸽；
  • 假設(shè)：其中隨便一個(gè)是最大值MAX兄世，每個(gè)元素和max比較，
    • 若有比MAX大的啊研，那該元素代替MAX御滩；
    • 若都沒有MAX大，恭喜党远，你一開始就猜對了削解；

  var arr = [22, 5, 6, 98];
        var max = arr[0];
        for (var i = 1; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        console.log(max);

把老數(shù)組里面大于10的選出來 追加到新的空數(shù)組里面

  // 把老數(shù)組里面大于10的選出來 追加到新的空數(shù)組里面
            // 結(jié)果newArr=[12, 5, 6, 23, 32, 48]
            // 把老數(shù)組里面大于等于10的選項(xiàng)挑出來
            // for 遍歷 因?yàn)橐蠑?shù)組里面的每一項(xiàng)去和10比較
            // if(arr[i]>=10) 條件大于等于10
            // newArr[newArr.length]向新數(shù)組追加元素
        var arr1 = [12, 5, 6, 23, 32, 48];
        var newArr = [];
        for (i = 0; i < arr1.length; i++) {
            if (arr1[i] >= 10) {
                newArr[newArr.length] = arr1[i];
            }
        }
        console.log(newArr);

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

// 翻轉(zhuǎn)數(shù)組
        var arr = ['張三', '李四', '王五', '趙六', '陸奇'];
        // 結(jié)果是arr 陸奇 趙六   王五     李四    張三
        // 交換位置 交換次數(shù)
        // 交換位置 arr[i]和arr[arr.length-1-i]  交換變量的值
        // 交換需要用到數(shù)組的每一項(xiàng) 遍歷
        for (i = 0; i < (arr.length - 1) / 2; i++) {
            var temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
        console.log(arr);

冒泡排序

   // 冒泡排序數(shù)字?jǐn)?shù)組從小到大(從大到小排列)
        var arr = [5, 3, 8, 7];
        // 比較  數(shù)組里面第一個(gè)元素 第一個(gè)元素比后邊大的,交換位置
        // 外邊的循環(huán)控制的是交換的次數(shù)
        for (var j = 0; j < arr.length - 1; j++) {
            // 里面的循環(huán)控制是每一輪交換
            for (var i = 0; i < arr.length - 1 - j; i++) {
                if (arr[i] < arr[i + 1]) {
                    var temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
        console.log(arr);

js去重

        // 去重將數(shù)組里面重復(fù)的項(xiàng)去掉 只保留一個(gè) 寫到新數(shù)組里面
        /* 思路  拿老數(shù)組里面的某一項(xiàng)和新數(shù)組中的每一項(xiàng)比較  只要有一個(gè)相等 不用追加 除非都不相等 把老數(shù)組中的這一項(xiàng) 追加到新數(shù)組里面去
        雙層for循環(huán) */
        // 遍歷老數(shù)組
        var arr = [1, 2, 3, 3, 2, 7, 8]
        var newArr = [];
        for (var i = 0; i < arr.length; i++) {
            // 考慮開關(guān)的位置
            var flag = true;
            // 遍歷新數(shù)組
            for (var j = 0; j < newArr.length; j++) {
                // 老數(shù)組里邊的某一項(xiàng)和新數(shù)組中的任意一項(xiàng)比較相等 不用追加到新數(shù)組里面
                if (arr[i] == newArr[j]) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                newArr[newArr.length] = arr[i];
            }
        }
        console.log(newArr);

    var arr = [1, 2, 3, 3, 2, 7, 8]
        var newArr = [];
        for (var i = 0; i < arr.length; i++) {
            for (var j = 0; j < newArr.length; j++) {
                if (arr[i] == newArr[j]) {
                    break;
                }
            }
             // 如果老數(shù)組中的某一項(xiàng)和新數(shù)組里面全部元素比較完之后 都不相等 追加到新數(shù)組里面去
            // 老數(shù)組循環(huán)一遍 都不相等 老數(shù)組循環(huán)結(jié)束 最后一次i++變成了newArr.length
            if (j == newArr.length) {
                newArr[newArr.length] = arr[i];

            }
        }
        console.log(newArr);

數(shù)組的構(gòu)造函數(shù)

• 數(shù)組在JS中還可以使用另一種方式創(chuàng)建，這個(gè)方式我們稱為 ： 構(gòu)造函數(shù)
• 構(gòu)造函數(shù)：能構(gòu)造一個(gè)你需要的東西（對象）麸锉；

// 使用 構(gòu)造函數(shù) 創(chuàng)建數(shù)組
var arr = new Array();
// 存儲數(shù)據(jù)
arr[0] = 10;
arr[1] = 20;
console.log(arr);

var arr = new Array(10,20);
console.log(arr);

• 注意：一個(gè)數(shù)據(jù)钠绍，不要使用這個(gè)方式存儲數(shù)據(jù)舆声；它會認(rèn)為你想要設(shè)置數(shù)組的長度花沉，而不是要把數(shù)據(jù)存儲在數(shù)組中。

var arr = new Array(10);
console.log(arr); // 輸出 [empty × 10]

• arr.length = 0;

字面量創(chuàng)建一個(gè)數(shù)組

• 直接使用 [] 的方式創(chuàng)建一個(gè)數(shù)組

  // 創(chuàng)建一個(gè)空數(shù)組
  var arr1 = []
  
  // 創(chuàng)建一個(gè)有內(nèi)容的數(shù)組
  var arr2 = [1, 2, 3]
  

?

?