基础一

JavaScript基础

历史

JavaScript：一门运行在(客户端)浏览器端的脚本 编程 语言

创造者 布兰登 艾奇
1995年利用10天完成JavaScript设计
脚本：戏剧的剧本。只要按照固定的流程走一遍，就可以把整部戏演完了。但是如果中间有演员出事了，戏就暂停了。这个脚本指的是JavaScript的一个特点：如果执行到某一行出错了，后面的就不会再继续执行了

JavaScript的组成

1. ECMASCRIPT: 定义了javascript的语法规范,描述了语言的基本语法和数据类型
2. BOM (Browser Object Model): 浏览器对象模型

• 有一套成熟的可以操作浏览器的 API，通过 BOM 可以操作浏览器。比如： 弹出框、浏览器跳转、获取分辨率等

3. DOM (Document Object Model): 文档对象模型

• 有一套成熟的可以操作页面元素的 API，通过 DOM 可以操作页面中的元素。比如： 增加个 div，减少个 div，给div 换个位置等
  总结： JS 就是通过固定的语法去操作 浏览器 和 标签结构 来实现网页上的各种效果

引入方式

• 内嵌式：demo学习阶段的主要写法

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

• 外链式：新建一个JS文件，文件里JS的代码，引入HTML页面内；作为个文件可以重复使用，项目开发阶段使用；

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

  • 行内式：了解，一般不用

  <input type="button" value="点我" onclick="alert('helloworld')">
  

JS 注释

• 语法：注释更好的屡清楚你的业务逻辑；不会执行

// alert('hello world');  单行注释，一般就是简单的做个说明

/*
* 多行注释
* 一般把想要注释的内容写到这里面来，大段内容；不能 嵌套使用；
*/

输入输出

• 作用：交互的简单入口，可以给页面输入我们想要输入的信息，页面输出一定的信息；为了与你写的代码更好交流和调试；

• 输入：页面中弹出 输入框，需要输入内容后才能继续；开发不常用，我们只是为了配合学习；

// 弹框
        alert('弹框');
        // 带输入框的弹框
        prompt('带输入框的弹框');
        // 控制台输出(打印)
        console.log('控制台输出');
        // 逗号隔开可以输出多个内容
        console.log('西游记', '三国演义');
        // 在页面输出标签文字
        document.write('在页面上输出');
        document.write('<strong>哈哈哈来点字</strong>');

变量

注意：

1. 一个变量名只能存储一个值
2. 当再次给一个变量赋值的时候，前面一次的值就没有了
3. 变量名称区分大小写（JS 区分大小写）

  // 声明变量  变量的作用是存储数据
        // var a;
        // 变量赋值 = 赋值运算符 把右边的数据存储到左边的变量里面去
        // a = 10;
        // 变量声明并赋值 变量的初始化
        // 弱数据类型
        // 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;
        // 把右侧的结果赋值给左边的num3
        // num3 = num3 + 1;
        // console.log(num3);

交换变量的两种方法

   // 需求a=6;b=5;
        // 思路 定义一个第三方变量c 先把a变量的值赋给c,再把b的值赋值给a,把c的值赋值给b
        var a = '老孙';
        var b = '老猪';
        var c = a;
        a = b;
        b = c;
        console.log(a);
        // 交换数字变量
        // 思路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);

同时声明多个变量

//1 变量可以一次性声明多个
var a,b,c,d;

// 2 还可以声明多个的同时进行赋值；
var a = 10;
var a = 10,b = 20,c = 30;


//3 变量也可以作为另一个变量的值
var a = 10;
// 赋值给b（复制了一份）,a再次变化时，b不受影响；
var b = a;

命名

• 范围：字母、数字、下划线、$符号；
• 不能：变量名字不能用数字作为开头

// 变量不能使用数字开头
var 15a = 10;

// 会在控制台中报错：Uncaught SyntaxError: Unexpected 
// Uncaught - 未捕获的
// SyntaxError - 语法错误

// Unexpected - 意料之外的
// number - 数字
// 翻译过来就是： 这行有一个语法错误，你的数字不符合语法要求

• 变量名字不能使用JavaScript语法中的关键字和保留字
• 关键字：在JavaScript语法中，具有特殊意义的单词，比如我们学习过的用于声明变量的var；后面要学习的if else for wihle case break....

// 变量名字不能使用关键字
var var = 20;
// 会在控制台中报错： Uncaught SyntaxError: Unexpected token var
// token - 标记，记号，在编程中我们翻译成 '标识符'
// 意思是这行有一个语法错误，出现了一个意料之外的标识符 var

• 保留字：JavaScript是不断发展的，以前的功能用了以前的关键字，将来要加入新的功能的时候，可能要用到新的关键字，所有JavaScript在一开始的时候就保留了部分单词，以便将来把保留的单词作为关键字

• 变量名字是区分大小写的；

// 变量名字是区分大小写的
var a = 10;
console.log(a);// 正常输出

console.log(A);// 在控制台中报错：Uncaught ReferenceError: A is not defined
// ReferenceError - 引用错误
// not defined - 未定义
// 意思是 A 这个变量我们没有定义就使用了，可见a和A是不一样的，不是同一个变量

• 如何定义呢？
  • 设置和你公司业务有关系的变量，取英文的翻译
  • 使用驼峰（第一个单词的第一个字母小写，第二个单词的首字母大写）；getData
  • 个人习惯：get_data

// 驼峰 getData
var userName = '张三';
var password = '123456';

// 个人习惯 get_data

字符串转义符

    类似HTML里面的特殊字符，字符串中也有特殊字符，我们称之为转义符。

    转义符都是 \ 开头的，常用的转义符及其说明如下：

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

数据类型

• 是指我们存储在内存中的数据的类型
• 我们通常分为两大类 基本数据类型 和 复杂数据类型

基本数据类型

//八进制 八进1  0开头
        // var h = 011;
        // console.log(h);
        // 十六进制 由0-9，a-f组成  0x开头
        // var f = 0x10;

1. 数值类型（number）
   • 一切数字都是数值类型（包括二进制，十进制，十六进制等）
   • NaN（not a number），一个非数字
2. 字符串类型（string）
   • 被引号包裹的所有内容（可以是单引号也可以是双引号）
3. 布尔类型（boolean）
   • 只有两个（true 或者 false）
4. null类型（null）
   • 只有一个，就是 null，表示空的意思
5. undefined类型（undefined）
   • 只有一个，就是 undefined，表示没有值的意思

数据类型转换

• 数据类型之间的转换，比如数字转成字符串，字符串转成布尔，布尔转成数字等

其他数据类型转成数值

1. Number(变量)

   • 可以把一个变量强制转换成数值类型
   • 可以转换小数，会保留小数
   • 可以转换布尔值
   • 遇到不可转换的都会返回 NaN

2. parseInt(变量)

   • 从第一位开始检查，是数字就转换，直到一个不是数字的内容
   • 开头就不是数字，那么直接返回 NaN
   • 不认识小数点，只能保留整数

3. parseFloat(变量)

• 从第一位开始检查，是数字就转换，直到一个不是数字的内容

• 开头就不是数字，那么直接返回 NaN

• 认识一次小数点

4. 除了加法以外的数学运算

   • 运算符两边都是可运算数字才行
   • 如果运算符任何一遍不是一个可运算数字，那么就会返回 NaN
   • 加法不可以用

转换为数字类型

number方法

 var age = prompt('请输入您的年龄');
        console.log(typeof age);
        console.log(age + 10);
        // 其他类型转数值类型 Number()
        var a = '15.32';
        // 非数字字符串转成数字类型是NaN not number NaN 是数字类型
        var b = '89.9孙悟空';
        // 字符串的空  false true 转数字类型是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()取整 数字开头的非纯数字字符串也可以取整
        // ''字符串的空 true false null 转数字类型是NaN
        var h = parseInt(b);
        console.log(h, typeof h);

取小数parseFloat

 // parseFloat()取整 数字开头的非纯数字字符串也可以取小数
        // ''字符串的空 true false null 转数字类型是NaN
        var h = parseFloat(b);
        console.log(h, typeof h);

隐式数据类型转换

// 隐式数据转化 - * /   如果用+号会直接用数字加字符串   特殊的true false等除外
        var a = 10;
        var b = '20';
        var c = true;
        console.log(a + b);
        console.log(a - b);
        console.log(a * b);

其他类型转换字符串类型

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() 这种方法不能转undefined和null
        var x = h.toString();
        console.log(x, typeof x);
        +号拼接  加号两边只要有一个字符串 加号就是拼接符
        h = '' + h;
        console.log(h, typeof h);

其他类型转换为布尔类型

// 其他类型转布尔类型
        // false ,'' , undefined , null NaN 0转换之后是false  其他转换都是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);

操作符

数据运算：数据参加比较、运算
字符串+：与字符串临近的类型，转为字符串；里面存在一个隐式转化；看不到的转化；隐式转化：在字符串+情况下，数字隐转为字符串；

• 情况：
  • 字符串 + ；
  • +字符串；

// 字符串 +
// 从左到右执行，数字相加，字符串拼接
var res3 = 10+10+"abc"+"def";
console.log(res3);  //输出 20abcdef
 // 算术运算符+ - * / %
        // + 只要两边有一个字符类型  +就是拼接符 2边都是数字类型  就是加运算
        // - * / 会有隐式类型转换
        // %取余(模)

字符串 其他

• 字符串遇见 * / - %；
• 隐式转化：字符串会隐式转化转为Number，再次参加运算；

var res3 = '456' - 123; 
console.log(res3); // 输出 数字 333

// 'abc' 隐式转化为NaN，所有输出NaN；
var res4 = 'abc' - 123;
console.log(res4); // 输出NaN

• 其实字符串遇见 * / % 一样的结果；
  • 最终都是参与了隐式转化（只是我们看不见这个转化过程，但是实质还是这些数据被Number()；

自增自减

        // ++i i++ 只操作一个 数据的叫一元运算符  2+3操作2个数据就叫二院操作符
        // 自增++i i++不参与运算的情况下 是一样的  都是自身加1
        var i = 10;
        // 自增参与运算  ++i前置自增  先自身加1 再参与运算
        var a = ++i;
        // i++后置自增  先参与运算 再自身加1
        // 注意后置自增 到了运算符另一边 已经自身加1
        var a = i++;

数学运算符

1. +

   • 只有符号两边都是数字的时候才会进行加法运算
   • 只要符号任意一边是字符串类型，就会进行字符串拼接

2. -

• 会执行减法运算

• 会自动把两边都转换成数字进行运算

3. *

   • 会执行乘法运算
   • 会自动把两边都转换成数字进行运算

4. /

   • 会执行除法运算
   • 会自动把两边都转换成数字进行运算

5. %

   • 会执行取余运算
   • 会自动把两边都转换成数字进行运算

赋值运算符

1. =

   • 就是把 = 右边的赋值给等号左边的变量名
   • var num = 100
   • 就是把 100 赋值给 num 变量
   • 那么 num 变量的值就是 100

2. +=

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

   • a += 10 等价于 a = a + 10

3. -=

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

   • a -= 10 等价于 a = a - 10

4. *=

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

   • a *= 10 等价于 a = a * 10

5. /+

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

   • a /= 10 等价于 a = a / 10

6. %=

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

   • a %= 10 等价于 a = a % 10

比较运算符

1. ==
   • 比较符号两边的值是否相等，不管数据类型
   • 1 == '1'
   • 两个的值是一样的，所以得到 true
2. ===
   • 比较符号两边的值和数据类型是否都相等
   • 1 === '1'
   • 两个值虽然一样，但是因为数据类型不一样，所以得到 false
3. !=
   • 比较符号两边的值是否不等
   • 1 != '1'
   • 因为两边的值是相等的，所以比较他们不等的时候得到 false
4. !==
   • 比较符号两边的数据类型和值是否不等
   • 1 !== '1'
   • 因为两边的数据类型确实不一样，所以得到 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

        // >< >= <= ==(等于) === != !==  比较运算符返回的结果都是true或者false
        var a = 5;
        var b = '5';
        var c = '7';
        var d = 5;
 // == 等于 对数据类型没有要求  只要是值相等  就返回true 值不相同  返回false
        var res5 = b == c;
// != 不等于  只比较值是否不等  不等返回true 不管数据类型 只要值相等就返回false
        var res6 = a != b;
 // === 全等严格的判断  必须数据类型和值完全相等,返回true  否则就返回false
        var res5 = a === b;
 // !== 全不等  值和数据类型有一个不相等 返回true 数据类型和值完全相等返回false 
        var res7 = a !== b;

// 不同类型：特别的null 、undefined
// undefined和null与其他Number类型在进行相等判断时不进行类型转换。
console.log(null==0)         //false
console.log(0 == undefined); //false

// ECMAScript认为undefined是从null派生出来的，所以把它们定义为相等的;
console.log(null==undefined)  // true


// 输出 false ,比较两个数据的值是否不相等, 此时两个数据的 值 都 4 ，相等，结果是 false
console.log('4'!= 4); 

// 输出 true ，比较两个数据的类型和值是否不相等，此时两个数据的类型不相等，结果是 true
console.log('4'!== 4); 

逻辑运算符

1. &&
   • 进行 且 的运算
   • 符号左边必须为 true 并且右边也是 true，才会返回 true
   • 只要有一边不是 true，那么就会返回 false
   • true && true true
   • true && false false
   • false && true false
   • false && false false
2. ||
   • 进行 或 的运算
   • 符号的左边为 true 或者右边为 true，都会返回 true
   • 只有两边都是 false 的时候才会返回 false
   • true || true true
   • true || false true
   • false || true true
   • false || false false
3. !
   • 进行 取反 运算
   • 本身是 true 的，会变成 false
   • 本身是 false 的，会变成 true
   • !true false
   • !false true

 // 逻辑运算符正常情况下返回true或者false
        // 逻辑与&& 两边都是true  返回true 只要有一边是false 返回false 见假为假
        var res = true && true;
        var res = false && false;
        // 逻辑或||两边只要有一个true 返回 true 两边都是false 返回false 见真即真
        var res = true || true;
        var res = 3 < 2 || 5 < 3;
        // 逻辑!取反
        var res = !true;
        var res = !false;

自增自减运算符（一元运算符）

1. ++

   • 进行自增运算

   • 分成两种，前置++ 和 后置++

   • 前置++，会先把值自动 +1，在返回

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

   • 后置++，会先把值返回，在自动+1

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

2. --

   • 进行自减运算
   • 分成两种，前置-- 和 后置--
   • 和 ++ 运算符道理一样

优先级

• 大致优先级：

  • 括号先算
  • 其次算算术：++a优先;
  • 再次算比较 > ==
  • 然后算逻辑 && ||
  • 最后算赋值 =

• 观察代码

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

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

// 在算计算
200===200>1

// 算右侧；
200===true;

// false
console.log(a); 

• 具体计算优先级

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

基础二

程序：来源生活，高于生活；

分支结构判断

if

// if单分支
        // if (条件表达式) {
        //     // 当条件表达式为true的时候 执行该处代码
        // }
        // 需求  判断一个男孩,如果年龄大于等于18 弹出提示框就可以进网吧了
        // if(条件表达式){
        //     如果条件表达式为true, 执行该处代码
        // }else{
        //     如果条件为false 执行该处代码
        // }
        var boy = prompt('请输入您的年龄');
        boy = Number(boy);
        if (boy > 18) {
            alert('请进吧')
        } else {
            alert('小屁孩,回家洗洗睡吧')
        }

  // 请用户输入一个数字,判断是不是偶数
        var num = Number(prompt('请输入一个数字'));
        if (num % 2 == 0) {
            console.log('这是一个偶数');
        } else {
            console.log('这是一个奇数');
        }

 if(条件表达式1){
                如果条件表达式1的结果为ture 执行该处代码
            }else if(条件表达式2){
                如果条件表达式2的结果为ture 执行该处代码
            }else if(条件表达式n){
                如果条件表达式n的结果为ture 执行该处代码
            }else{
                如果上面的条件表达式都为false 执行该处代码
            }

// 输入学生成绩 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('输入错误')

        }

switch

 switch (变量) {
            case 值1:
                当变量和case后边的值1全等 === 数据类型和值完全相等
                执行该代码
                break的作用是阻断代码向下执行
                break;
            case 值2:
                当变量和case后边的值2全等 === 数据类型和值完全相等
                执行该代码
                break的作用是阻断代码向下执行
                break;
                case 值n:
                当变量和case后边的值n全等 === 数据类型和值完全相等
                执行该代码
                break的作用是阻断代码向下执行
                break;
                default:
                    当变量和case后边的值都不相等 执行该处代码
                    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('宫廷盛宴')

        }

三元表达式

• 表达式：有值会返回；

• 语法：if else 的简写；有返回值；

  // 表达式1 ? 表达式2 : 表达式3;
  
  // 首先 要知道 表达式 会返回结果；
  // 过程：先执行表达式1，判断其结果是true还是false，
  // 如果是true，则执行表达式2，然后将 表达式2的执行结果 作为整个三元表达式的结果进行返回，
  // 如果是false，则执行表达式3，并将 表达式3的结果 作为整个三元表达式的结果
  
  //例如： 求二个数字中谁更大
  var a = 10; var b = 20;
  var max = a > b ? a : b;
  console.log(max);
  

     // 三元表达式
          // 表达式1? 表达式2: 表达式3
          // 如果表达式1位true 执行表达式2 如果为false执行表达式3
          var a = 10;
          var b = 50;
          // a和b的最大值
          a > b ? alert(a + '大') : alert(b + '大');
  

   var i = 0;
          // 三元表达式? 前边的表达式也会隐式类型转换为布尔值
          var num = i++ ? i++ : ++i;
          console.log(num);
  
  

循环结构

for循环

• 执行过程：

1. 执行初始化表达式(只执行一次)
2. 执行条件表达式
3. 如果条件表达式的结果为false, 结束循环；
4. 如果条件表达式的结果为true，执行循环体
5. 执行自增表达式
6. 重复2~5的步骤，直到条件表达式的结果为false，结束循环

for(初始化表达式; 条件表达式; 自增表达式){
  // 循环体
}
// 在页面上打印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之间所有的偶数的和
        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循环

  // 打印10行 每一行都是5课星
        // 循环是重复做一件事 条件不满足的时候循环结束
        // 外层for循环控制的是行数
        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循环

当循环次数已知的时候用for循环 当循环次数未知的时候用while和do while

    
        while (条件表达式) {
            // 当条件表达是为true的时候  执行循环体的代码  条件表达式为false的时候  循环体代码不执行
        }
        // 求1-100的和
        var i = 1, sum = 0;
        while (i <= 100) {
            sum += i;
            i++;
        }
        console.log(sum);

 // 用户名和密码只要有一个输入错误 用户就需要一直输入
        var userName = prompt('用户名')
        var passWord = prompt('密码')
        while (userName != 'admin' || passWord != '123456') {
            userName = prompt('用户名')
            passWord = prompt('密码')
        }
        alert('登录成功')

do while

  // do{
        //     循环体
        //     循环体首先执行一次 再去看条件表达式 如果条件表达式为true 循环体继续循环 如果为false 循环结束
        // }while(条件表达式)
        do {
            var userName = prompt('用户名')
            var passWord = prompt('密码')
        } while (userName != 'admin' || passWord != '123456') {
            alert('登录成功');
        }

break和continue

• 循环退出：
  • 满足条件退出
  • 关键字退出：某些情况下，我们不一定要循环从头到尾执行，这个时候就要使用break和continue控制循环的次数；

// break 结束的是当前循环
/* 例子：电梯一共有6层，现在我们要上电梯，我们的教室在3楼，电梯只要到3楼就可以了。*/
for(var i = 1; i <= 6 ; i++ ){
    console.log('现在是'+i+'楼');
    if(i == 3){
        console.log('3楼到了，电梯停了，请下电梯。');
        // 程序 执行到 3，执行了四次就结束了；
        break;
    }
}
// 这里案例用的是for循环演示，while 和do-while一样；

// continue
// 电梯一共有6层，除了3楼没人下去，其他楼层都有人下去(3楼不停，其他楼层都要停)
for(var i = 1; i <= 6; i++){
    if(i == 3){
        // 执行到 3 时。当前次的程序后面的全部跳过；继续执行后面的次数；
        continiue;
    }
    console.log(i+'楼到了，电梯停了，请下电梯。');      
}

总结：这个地方只是用for做终止

• break用于结束整个循环

• continue用于结束整个循环中的一次，结束当前这次循环；

• break和continue后面的代码都不会执行，执行前面的代码；

逻辑中断 短路

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

习题练习

1- 判断时间阶段。

​

• 题目描述：

  用户输入几点弹出问候信息；

    如用户输入12点中午好；
    
    用户输入18点 弹出傍晚好；
  
    用户输入23点弹出深夜好；
  

• 题目提示：

  通过比较运算符判定输入的时间的范围，弹出相应的问候信息

     var i;
          var j = Number(prompt(i));
          if (j == 12) {
              alert('中午好');
          } else if (j == 18) {
              alert('傍晚好');
  
          } else if (j == 23) {
              alert('深夜好');
          } else {
              alert('输入错误');
          }
  

2 - 比较两个数的最大值

• 题目描述：

  用户依次输入2个值，最后弹出最大的那个值

• 题目提示：

  通过比较运算符弹出最大值

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

3 - 判断奇偶性

• 题目描述：

  用户输入一个数，判断是奇数还是偶数

• 题目提示：

  通过%运算符可以得出数字的奇偶性

     var i = Number(prompt('请输入数字判断奇数还是偶数'))
          if (i % 2 == 0) {
              alert('偶数')
          } else {
              alert('奇数')
          }
  
  

4 - 判断星期

• 题目描述：

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

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

•   假设这个月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 - 请客吃饭

• 题目描述：

  接收班长口袋里的钱数？

    若大于等于2000，请大家吃西餐。                       2000<=j
  
    若小于2000，大于等于1500，请大家吃快餐。1500<=j<2000
  
    若小于1500，大于等于1000，请大家喝饮料。 1000<=j<1500
  
    若小于1000，大于等于500，请大家吃棒棒糖。 500<=j<1000
  
    否则提醒班长下次把钱带够
  

• 题目提示：

  使用switch或者if else if 来进行逻辑书写

     var i = Number(prompt('班长口袋里面的钱数'));
          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('班长口袋里面的钱数'));
          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 - 成绩表

• 题目描述：

  分数转换,给一个分数，判定等级。大于等于90 A，大于等于80小于90 B，大于等于70小于80 C ，大于等于60小于70 D，小于60 E

• 题目提示：

  使用if else if 来进行逻辑书写，当使用if else if 时注意判定大小顺序

    思考：是否可以使用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('输入错误');
                break;

        }

​

1.1 求100以内所有能被3和7整除的数的和

• 题目描述：

  • 把1-100之间所有能够被3和7同时整除的数找出来，计算累加和

• 题目提示：

  • 在算入累加和之前，使用%判定遍历到的数字是不是可以被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循环打印三角形

• 题目描述：

  • 在控制台一次性打印形状如下：

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

        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循环

1.3 使用for循环打印99乘法表

• 题目描述：

  • 使用for循环，打印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循环

    <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 用户登录验证

• 题目描述：
  • 接收用户输入的用户名和密码，若用户名为 “admin” ,且密码为 “123456” ,则提示用户登录成功! 否则，让用户一直输入。
• 题目提示：
  • 利用while循环或者do while 循环

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之间个位数不为3的数的累加和。

• 题目描述：

  • 求整数1～100的累加值，但要求跳过所有个位为3的数。

• 题目提示：

  • 使用%判个位数是否为3
  • 用continue实现

      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

• 题目描述：

  • 里面现存有 100 块钱。

  • 如果存钱，就用输入钱数加上先存的钱数, 之后弹出显示余额提示框

  • 如果取钱，就减去取的钱数，之后弹出显示余额提示框

  • 如果显示余额，就输出余额

  • 如果退出，弹出退出信息提示框

    操作界面如下

    
    
    a.gif

图片1.png

• 题目提示：

  • 通过输入的数值判断用户操作
  • 定义一个变量，保存钱数
  • 先接收一下用户输入的数字 存到变量里边
  • 用while循环
  • whilie循环里边，switch case 比较简单

 var money = 100
        for (let i = 0; i < 5; i++) {
            var work = parseFloat(prompt("请输入你要进行的操作" + "\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;
            }
        }

//开关阀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个能被7和3整除的整数

• 题目描述：

  • 求从1开始第35个能被7和3整除的整数

• 题目提示：

  • 通过变量记录是第几个可以被3和7整除的数

 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;
                // 取出一个i count自增一次
                count++;
                // 到第35个i的时候循环终止
            } else if (count == 35) {
                break;
            }
        }
        console.log(result);

 var i = 1, count = 0, result = 0;
        while (count < 35) { //当count等于35的时候就会停止执行
            i++; //i的自增bai
            if (i % 3 == 0 && i % 7 == 0) {
                result = i; //把能整除3和7的数字保存下来
                count++; //一旦发现一次能整除3和7的数字，就加1
            }
        }
        console.log(result);

     var a = 1; b = 0; //b 是计数器
        // b不等于35循环一直进行下去 等于35的条件表达式为false 循环结束
        while (b != 35) {
            if (a % 7 == 0 && a % 3 == 0) {
                b++;
                if (b == 35) {
                    alert(a)
                }
            }
            a++;
        }

//开关法
   var a = 1, b = 0, flag = true; //b 是计数器
        // flag为true的时候 循环一直执行  flag为false的时候 循环终止
        while (b != 35) {
            if (a % 7 == 0 && a % 3 == 0) {
                b++;
                if (b == 35) {
                    alert(a)
                    // 循环停止
                    flag = false;

                }
            }
            a++;
        }

2.3 斐波那契数列

“兔子数列”，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34 ，55， 89

特点是： 后一个月是前2个月的和

求第12个月的兔子数？

提示：

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

2.4 质数

质数是只能被1和他自身整除的数

比如7 1 2 3 4 5 6 7 是质数 9不是质数 1 2 3 4 5 6 7 8 9 因为9能被3整除

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

提示：

  开关法
// 用户任意输入一个数 如果是质数弹框提示  如果不是质数 弹出提示不是质数
        var num = Number(prompt('请输入一个数 我会告诉你他是不是质数'));
        var flag = true;
        if (num == 2) {
            alert('质数');
        }
        for (var i = 2; i < num; i++) {
            if (num % i == 0) {
                flag = false;
                alert('不是质数');
                break;
            }
        }
        if (flag) {
            alert('质数');
        } 

   var num = Number(prompt('请输入一个数  我会告诉你他是不是质数'));
        //num%2.......num-1 !=0是质数 num%2......num-1==0 说明不是质数
        for (var i = 2; i < num; i++) {
            //比如num是6 这时候6%i==0 i是2 循环结束
            //比如num7 这时候7%(2.....6) !==0 然后循环结束  循环结束的时候 i应该是num 这个数是质数
            if (num % i == 0) {
                alert('不是质数');
                break;
            }
        }
        //  当num从2一直到num-1取余不等于0 这时候上边的循环结束 循环结束的时候i++最后变成了num
        if (num == i) {
            alert('质数');
        }

var num = Number(prompt('请输入数字 判断是否为质数'));
        var con = 0;
        for (i = 1; i <= num; i++) {
            if (num % i == 0) {
                con++;
            }
        }
        // 循环结束之后 con的次数确定了 再进行判断  如果 num%(1...num)2次等于0  是质数 否则不是质数
        if (con == 2) {
            alert('质数');
        } else {
            alert('不是质数');
        }

   var count = 0;
        var num = Number(prompt('请输入数字 判断是否为质数'));
        for (i = 2; i <= num; i++) {
            if (num % i == 0) {
                count++;
            }
        }
        if (count == 1) {
            alert('质数');
        } else {
            alert('不是质数')
        }

基础三

介绍

• 数组是一个有顺序、有长度的数据集合；
• 数组：类型Object；
• 特点：
  • 把数据放在一起；
  • 有先后位置上的顺序；
  • 有数据的长度；

// 数组一组有序的有长度的数据集合 数组里面可以存储任意的数据类型
        // 声明数组
        // 1字面量声明数组
        // 数组元素顺序是靠索引来控制的 索引(下标)从0开始
        //创建一个空数组
        var arr = [];
        arr[0] = 89;
        arr[1] = 'www';
        arr[2] = true;
        console.log(arr);
        //创建一个有内容的数组
        var arr1 = [12, 39, 'hahahha', 78];
        console.log(arr1);
        //拿到索引为0 顺序上第一个位置上的数据
        //把数组[索引]格式当成一个变量使用就行了
        console.log(arr1[0])

存值

• 数组中的数据使用索引管理。
• 索引 下标：位置：方便放入存值和寻找；
• 索引 规则：用数字表示，从0开始

//把成绩存储到数组中
arr[0] = 91;
arr[1] = 88;
arr[2] = 72;
arr[3] = 45;
arr[4] = 63;
console.log(arr); // 输出 [91,88,72,45,63] 就是一个数据集合

• 把 数组[索引]格式当成一个变量使用就行，

// 初始化赋值完成后，也可以再次改变值，把前面的值覆盖掉；
arr[0] = 100;

• 如果一开始就知道数组了，可以直接使用一个简单的语法存储数据

var arr = [91,88,72,45,63];
console.log(arr); // 输出的结果是一样的

• 上面每个位置上存的都是数字类型，可以为其他类型；

取值

• 把数据取出来，得知道你要取哪个位置上的数据把。
• 数据取值同样使用索引取。

// 拿到索引为0，顺序上第一个位置上的数据；
// 把 数组[索引] 格式当成一个变量使用就行；
console.log(arr[0]);

// 数组求和：班里的成绩总和
var sum = arr[0] + arr[1] + arr[2] + arr[3] + arr[4];
console.log(sum); // 输出370

遍历

• 求成绩总和：一个一个地把数组里面的数组取出来了，从索引 0 到最后一个索引，
• 索引从0开始到结束的过程，有重复的思想，需要用到循环；

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


// 循环 这个从0~最后一个索引，有重复的思想在里面，使用循环。
var sum = 0;
for(var i = 0; i <= 4; i++){
  sum += arr[i];
}
console.log(sum); // 输出 370，和我们一个一个相加是一样的

• 使用循环来遍历数组，当数组中的数据比较多的时候，会比较方便。一般是使用for循环；

数组长度

语法

• 存取数据：涉及到就是数组的顺序问题，通过索引去存取；

• 数组长度：数组中一共存放了多少个数据；

console.log(arr.length); // 数组.length 就是数组的长度

• 如果数组的长度是5，最后一个元素的索引就是4；
• 我们发现最大索引总是比长度少 1 ，所以遍历还可以这么写

数组的索引

• 索引，也叫做下标，是指一个数据在数组里面排在第几个的位置

• 注意： 在所有的语言里面，索引都是从 0 开始的

• 在 js 里面也一样，数组的索引从 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开始
        // 数组里边的最大索引值是数组名.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];
        /*   数组长度小于数组的实际长度 后边的元素会删除掉
          arr.length=2;
          数组长度大于数组的实际长度 后边的元素会显示empty 就是undefined */
        arr.length = 9;
        //输出数组内的所有元素
        console.log(arr);
        //输出数组的长度
        console.log(arr.length);
        //输出索引值的第七位
        console.log(arr[7]);

数组后面追加元素

```js

// 数组后边追加新元素 数组名[数组名.length]=值
// 0 1 2 3 4 n
// 数组长度1 2 3 4 5 n+1
var arr = [22, 5, 6, 98];
arr[arr.length]=32;
arr[arr.length]=50;
```

习题练习

        ### 求数组中所有数字的和以及平均值

• 分析：
  • 总和：循环遍历，加在一个变量上得到；
  • 均值：总和 / 个数；（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);

求数组中的最大值

• 分析：生活中，一堆人最高的（人很多，多到你一下看不出来）；
  • 最大值：最起码得两个数比较下，得到最大值；
  • 假设：其中随便一个是最大值MAX，每个元素和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);

把老数组里面大于10的选出来 追加到新的空数组里面

  // 把老数组里面大于10的选出来 追加到新的空数组里面
            // 结果newArr=[12, 5, 6, 23, 32, 48]
            // 把老数组里面大于等于10的选项挑出来
            // for 遍历 因为要老数组里面的每一项去和10比较
            // if(arr[i]>=10) 条件大于等于10
            // newArr[newArr.length]向新数组追加元素
        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);

翻转数组

// 翻转数组
        var arr = ['张三', '李四', '王五', '赵六', '陆奇'];
        // 结果是arr 陆奇 赵六   王五     李四    张三
        // 交换位置 交换次数
        // 交换位置 arr[i]和arr[arr.length-1-i]  交换变量的值
        // 交换需要用到数组的每一项 遍历
        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);

冒泡排序

   // 冒泡排序数字数组从小到大(从大到小排列)
        var arr = [5, 3, 8, 7];
        // 比较  数组里面第一个元素 第一个元素比后边大的,交换位置
        // 外边的循环控制的是交换的次数
        for (var j = 0; j < arr.length - 1; j++) {
            // 里面的循环控制是每一轮交换
            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去重

        // 去重将数组里面重复的项去掉 只保留一个 写到新数组里面
        /* 思路  拿老数组里面的某一项和新数组中的每一项比较  只要有一个相等 不用追加 除非都不相等 把老数组中的这一项 追加到新数组里面去
        双层for循环 */
        // 遍历老数组
        var arr = [1, 2, 3, 3, 2, 7, 8]
        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;
                    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;
                }
            }
             // 如果老数组中的某一项和新数组里面全部元素比较完之后 都不相等 追加到新数组里面去
            // 老数组循环一遍 都不相等 老数组循环结束 最后一次i++变成了newArr.length
            if (j == newArr.length) {
                newArr[newArr.length] = arr[i];

            }
        }
        console.log(newArr);

数组的构造函数

• 数组在JS中还可以使用另一种方式创建，这个方式我们称为 ： 构造函数
• 构造函数：能构造一个你需要的东西（对象）；

// 使用 构造函数 创建数组
var arr = new Array();
// 存储数据
arr[0] = 10;
arr[1] = 20;
console.log(arr);

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

• 注意：一个数据，不要使用这个方式存储数据；它会认为你想要设置数组的长度，而不是要把数据存储在数组中。

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

• arr.length = 0;

字面量创建一个数组

• 直接使用 [] 的方式创建一个数组

  // 创建一个空数组
  var arr1 = []
  
  // 创建一个有内容的数组
  var arr2 = [1, 2, 3]
  

​

​