JavaScript基础

最新推荐文章于 2024-05-31 10:26:40 发布

cookie@

最新推荐文章于 2024-05-31 10:26:40 发布

阅读量170

点赞数 1

分类专栏：前端 html5 文章标签： javascript

本文链接：https://blog.csdn.net/qq_41435894/article/details/103798607

版权

前端 html5 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

引入JS的方式

<script type="text/javascript">
 // JS代码可以写在Scirpt元素中
 // 一个页面可以拥有多个script元素
 // 并且 script元素可以出现在页面的任意位置
 // script元素type属性默认是 text/javascript  一般可以省略

 // alert('我是在head中的script元素');

 // JavaScript中所有的符号都是英文符号。
 document.write('<h1>欢迎学习javascript</h1>'); // 页面输出语句
 console.log('hello world'); // 控制台 日志输出  用于代码调试

虽然以上方式都是允许的，但是不推荐在html结构的事件属性中书写JS代码。

## 也可以在header头部样式引入js

// 当一个script元素被用于引入外部文件时
    // 该元素内部的代码会被自动忽略

javascript的调试

<script>
    console.log(5);
    console.log(6);
</script>
那里有错就停止在哪里。仅限于当前Javascript代码块。多个script代码块是不受影响的
 // 代码一旦出现错误 JS解释器就会终止执行//

变量的声明

<script>
    // 在编程语言中 = 叫做 赋值符
    // 它的含义是将符号右边的值赋予给左边的变量
    // var a = 10;
    // var b = 8;

    // console.log(a);
    // console.log(b);
    // console.log(a + b);

    // var c; // 申明后没有赋值的变量 自动取值为  undefined (未定义)
    // console.log(c);

    // var name1, name2; // 使用一条语句 申明多个变量 多个变量名使用英文逗号','分开
    // var age1 = 20, // 20
    //     age2; // undefined

    var a = 10;
    var b = 8;
    // var c;
    // c = a;
    // a = b;
    // b = c;
    // console.log(a);
    // console.log(b);

    a = a + b; // a = 18 , b = 8
    b = a - b; // b = 10 , a = 18
    a = a - b; // a = 8 , b = 10
    console.log(a);
    console.log(b);
</script>

变量的命名规范

 <script>
        // 命名规范
        // 1. 可以使用 数字 字母 下划线(_) 美元符($) 进行变量命名
        // 2. 变量名不允许以数字开头
        // 3. 命名要有明确含义(语义)
        // 4. 命名采用驼峰命名法 （大驼峰 小驼峰）
        // 5. 不允许使用关键字和保留字进行命名

        // 驼峰命名法
        // 小驼峰指的是  首字母小写 后面 每一个单词的首字母大写
        // 驼峰指的是  首字母大写 后面 每一个单词的首字母大写
        // 变量和函数   使用小驼峰命名法
        // 类和构造函数 使用大驼峰命名法

        // var name1 = 'zhangsan';
        // console.log(name1);
        // var $name = 'lisi';
        // console.log($name);
        // var _name = 'wangwu';
        // console.log(_name);

        // var userNmae = 'admin';
        // var Users = function() {}
    </script>//
## Javascript基本数据类型

js关键字与保留字

JavaScript 保留关键字
break
case catch continue
debugger default delete do
else
false finally for function
if in instanceof
new null
return
switch
this throw true try typeof
var void
while with
JavaScript 将来可用的保留关键字
abstract
boolean byte
char class const
double
enum export extends
final float
goto
implements import int interface
long
native
package private protected public
short static super sychronized
throws transient
volatile

typeof操作符总结【检测数据类型】

<script>
    // typeof 
    // 由于我们的JavaScript是弱类型语言
    // 在申明变量时不需要指定数据类型
    // 所以需要数据类型的检测手段 
    // typeof就是用来满足该需求的

    // typeof返回的是 字符串
    // 检测数值 或 NaN   返回   'number'
    // 检测字符串        返回   'string'
    // 检测布尔类型      返回   'boolean'
    // 检测null         返回    'object'
    // 检测undefined     返回   'undefined'
    // 检测对象          返回   'object'
    // 检测函数          返回    'function'

    console.log(typeof isNaN);
</script>

初识对象

<script>
        // new关键字用于创建对象 new后面跟随是的构造函数
        // var o = new Object();
        // console.log(o);
        // console.log(typeof o); // 'object'

        // 为新创建的对象添加属性我们使用 '.' 操作符
        // 对象是由无序的名值对组成  属性是没有顺序的
        // 名值对  在编程中通常被称作为 键值对
        // key-value
        // o.name = 'zhansgan';
        // o.age = 18;
        // console.log(o);

        // 对象的属性可以直接通过key进行访问
        // 对象中可以保存多个键值对  
        // 键可以理解是变量名
        // console.log(o.name);


        // 需求：存储一个用户
        // 名字 性别 年龄 身高
        // 4条信息描述的是一个整体 一个个体
        // var userName = 'zhangsan';
        // var sex = '男';
        // var age = 21;
        // var height = '170cm';

        // 为对象赋值不存在的属性叫做添加属性
        // 为对象赋值已经存在的属性 叫做 修改属性值

        var user = new Object();
        user.name = '张三';
        user.sex = '男';
        user.age = 21;
        user.height = '170cm';

        user.age = 25;
        console.log(user);
        // console.log(user.height);
    </script>

算数运算

   <script>
        // % 取余运算符  读 模
        // console.log(3 % 2);
        // console.log(9 % 3);
        // 判断一个数是奇数还是偶数

        // console.log(5 % 2); // 任何整数模2 余数为1的是奇数 否则是偶数

        // 一元运算符 ++ / --
        // 自增/自减 运算符
        // 将值自身 +1 或 -1

        // var num = 3;
        // // num++; // num = num + 1;
        // // num++; // num = num + 1;

        // num--; // num = num - 1;
        // console.log(num);

        // var a = 5;
        // 使用 自增和自减 运算符时 
        // ++/-- 在前 先运算 后使用
        // ++/-- 在后 先使用 后运算

        // console.log(a++ - --a + a++ + a++ - --a + a - ++a - a); // 1
        // //          5   -  5  +  5  +  6  -  6  + 6 -  7  - 7
        // //          6      5     6     7     6    6    7    7
        // console.log(a); // 4 5


        // var i = 6;
        // console.log(i + ++i - i-- + --i + i - --i + i++); // 40 16 11 18 
        // //          6 + 7  - 7    +  5  + 5 -  4  + 4 
        // //          6   7    6       5    5    4    5
        // console.log(i); //

        var c = 3;
        console.log(c++ + c - ++c - c-- + ++c - c-- - --c); // -6 
        console.log(c); // 3
    </script>

关系运算符

 <script>
        // console.log(3 > 5);
        // console.log(5 < 7);
        // console.log(3 >= 3);
        // console.log(0 <= 0);

        // 正常比较数字的时候 比较的数值大小
        // 但是 在出现字符串比较的时候 情况不一样
        // 在2个字符串比较大小的时候 比较的是 字符串的Unicode编码
        // 当第一个字符的编码相同时 比较第二个字符的Unicode编码 
        // 数字的Unicode编码是 48-57


        // console.log('你' < '好');
        // console.log(1 >= true);
        // console.log("11" > "110");
        // console.log("22" > "23");
        // console.log("12" > "13");
        // console.log(1 < "3");
    </script>

相等比较

<script>
        // 相等操作符(==) 如果比较的两个值相等 则返回true 否则返回false
        // 不相等操作符(!=) 如果比较的两个值不相等 则返回true 否则返回false

        // 相等操作符和不相等操作符  在比较值之前 都会进行数据类型的转换(相同类型除外)

        // 如果有布尔值 先将布尔值转成数值进行比较
        // 如果有一个操作数是字符串  另一个操作数是数值  先将字符串转换成数值 再进行比较

        // console.log(123 == '123'); // 转换后是 123 == 123   true
        // console.log(25 != '25'); // 转换后是 25 != 25  false
        // console.log(1 == true); // 转换后是 1 == 1   true
        // console.log(23 == '23a'); // 转换后是 23 == NaN  false

        // 在JS中数值类型 小数点后面如果全是0 则被忽略
        // console.log(undefined == null); // true  特殊比较
        // console.log(22 == '22.00'); // 转换后是 22 == 22  true
        // console.log(22 == '22.01'); // 转换后是 22 == 22.01  false
        // console.log(22 == '22.00000000000000000000000000000000001'); // true 超出小数精度的会被忽略

        // console.log(1 + 2 == 3);
        // console.log(0.6 + 0.5 == 1.1);
        // console.log(0.1 + 0.2 == 0.3); // 0.3000000000000004  false

        // console.log(5 == true); // 5 == 1  false
        // console.log(Number(null)); // null 转 number结果是0
        // console.log(null == 0); // false  null在比较的时候不转换类型
        // console.log(null == 'null'); // false
        // console.log(undefined == 0); // false undefined不转换

        // console.log(Number('NaN'));
        // console.log(NaN == 'NaN');
        // console.log(NaN == NaN); // NaN和任何值比较相等 结果都是false
        // console.log(NaN != NaN); // true


        // 全等操作符(===) 恒等操作符   
        // 不全等操作符(!==) 不恒等操作符

        // 比较值之前 不会做数据类型转换
        // 而是直接比较值
        // 如果数据类型不相同 一定不相等
        console.log(123 === '123');
        console.log(null === undefined);
    </script>

逻辑运算

<script>
        // 逻辑非(!) 
        // 可以用于JS中的任意值(任意类型)
        // 逻辑非操作符 完成两个任务
        // 任务1 将操作的值转换成布尔值
        // 任务2 将转换后的结果进行求反

        // 任意非0数 转成布尔类型 结果都为true
        console.log(Boolean(-1));    //true
        console.log(!3);//false
        console.log(!0);//true
        console.log(!!0);//false

        // null undefined NaN 转换布尔类型 都为 false
        // console.log(!null);
        // console.log(!undefined);
        // console.log(!NaN);

        // 任意对象转成布尔类型都是true
        // var obj = new Object();
        // console.log(!obj);

        // 任意非空字符串转成布尔类型都是true
        // 空字符串转布尔类型是false
        // console.log(!'123'); // false
        // console.log(!'abc'); // false
        // console.log(!' '); // false
        // console.log(!''); // true

        // 快速将一个值转换为布尔类型  我们使用  (!!)
    </script>

逻辑与逻辑或

<script>
        // 逻辑与(&&) 
        // 逻辑与有两个表达式组成
        // 两个表达式都为布尔表达式
        // 当两个布尔表达式的结果同为true的时候  逻辑与的结果为true
        // 只要有一个结果为false  逻辑与的结果就为false

        // console.log(5 > 3 && 3 > 2);
        // console.log(3 + 3 == 5 && 2 + 2 == 4);
        // console.log(!123 && !false);

        // 短路逻辑(最小化求值)
        // 是计算机的一种求值策略
        // 当逻辑与 左右两边的值
        // 第一个值为true的时候 返回第二个值
        // 第一个值为false的时候 返回第一个值

        // console.log(2 && 3);
        // console.log(4 && 3);
        // console.log(0 && 3);
        // console.log(-1 && 3);
        // console.log(3 && -1);
        // console.log('35' && false);
        // console.log(-5 && NaN);
        // console.log(null && 123);
        // 逻辑或(||)
        // 两个布尔表达式
        // 当两个布尔表达式任意一个结果为true时  逻辑或结果为true
        // 两个布尔表达式结果都为false时  结果为false
        // console.log(3 > 5 || 5 > 3);
        // console.log(3 + 3 == 7 || 3 % 2 == 0);
        // 短路逻辑
        // 逻辑或 
        // 第一个值为true时 返回第一个值
        // 第一个值为false时 返回第二个值
        // console.log(3 || 5);
        // console.log(0 || 3);
        // console.log(null || undefined);
        // var obj = new Object();
        // console.log(obj || 123);
    </script>

运算优先级

要是在这里看的不是很清楚的话，可以点击此超链接观看，一目了然
|优先级运算类型关联性运算符
20 圆括号 n/a（不相关） ( … )
19 成员访问从左到右 … . …
需计算的成员访问从左到右 … [ … ]
new (带参数列表) n/a new … ( … )
函数调用从左到右 … ( … )
可选链（Optional chaining）从左到右 ?.
18 new (无参数列表) 从右到左 new …
17 后置递增(运算符在后) n/a
… ++
后置递减(运算符在后) … –
16 逻辑非从右到左 ! …
按位非 ~ …
一元加法 + …
一元减法 - …
前置递增 ++ …
前置递减 – …
typeof typeof …
void void …
delete delete …
await await …
15 幂从右到左 … ** …
14 乘法从左到右
… * …
除法 … / …
取模 … % …
13 加法从左到右
… + …
减法 … - …
12 按位左移从左到右 … << …
按位右移 … >> …
无符号右移 … >>> …
11 小于从左到右 … < …
小于等于 … <= …
大于 … > …
大于等于 … >= …
in … in …
instanceof … instanceof …
10 等号从左到右
… == …
非等号 … != …
全等号 … === …
非全等号 … !== …
9 按位与从左到右 … & …
8 按位异或从左到右 … ^ …
7 按位或从左到右 … | …
6 逻辑与从左到右 … && …
5 逻辑或从左到右 … || …
4 条件运算符从右到左 … ? … : …
3 赋值从右到左 … = …
… += …
… -= …
… = …
… /= …
… %= …
… <<= …
… >>= …
… >>>= …
… &= …
… ^= …
… |= …
2 yield 从右到左 yield …
yield yield* …
1 展开运算符 n/a … …
0 逗号从左到右 … , …

字符串连接

   <script>
        // 字符连接符(+)
        // 用于字符串的连接
        // 如果+左右都是字符串 直接连接
        // console.log('123' + '123');

        // 当+左右有任意一边是字符串时 会将另外一边自动转换成字符串 然后连接
        console.log(123 + '3'); // '123' + '3'

        console.log(undefined + '123'); //undefined 转字符串  'undefined'
        console.log(null + '123'); // null 转字符串 'null'
        console.log(NaN + 'a'); // NaN 转字符串  'NaN'
        console.log(true + 'abc'); // true转字符串  'true'
        console.log(false + '123'); //false 转字符串 'false'
        console.log(null + 5); // 5
        console.log(NaN + 3); // NaN和任何数值进行任何运算 结果都是NaN
    </script>

条件运算符

 <script>
        // 条件运算符(三元运算符 三目运算符)
        // ? :
        // 语法
        // 表达式1?表达式2:表达式3;
        // 条件运算符 共有三个表达式 也可以看作是三个操作数
        // 条件运算符 会先判断表达式1(布尔表达式)的值
        // 如果表达式1的结果为true 则执行表达式2(整个条件运算符的结果是表达式2)
        // 如果表达式1的结果为false 则执行表达式3(整个条件运算符的结果是表达式3)

        // 条件运算符可以配合赋值运算符使用

        // var age = 18;
        // // console.log(age >= 18 ? '成年' : '未成年');//输出成年
        // var result = age >= 18 ? '成年' : '未成年';//结果是成年
        // console.log(result);

        // 如果条件运算符的第一个表达式 不是 布尔表达式
        // 它会自动将其转换为布尔值 

        // var num = 67;
        // console.log(num % 2 ? "奇数" : "偶数");

        var num;
        console.log(num ? '1' : '2');
    </script>

隐式转换

<script>
        // JS是弱类型语言 不需要指定数据的类型
        // 数据类型是由赋值操作来决定的


        // 隐式转换
        // 数据类型在程序 运算过程中 进行的类型转换

        // console.log(3 + '5'); // '35'

        // // 算术运算符 结果一定是number类型
        // // 如果算术运算表达式不是number类型 会自动转换为number类型 进行运算
        // console.log(3 * '5'); // 15
        // console.log(32 + null); // 32
        // // undefined参数的任何算术运算 结果都是 NaN
        // console.log(2 + undefined); // NaN
        // console.log('3' * '2'); // 6
        // console.log(15 * '1.1a'); // NaN  // Number('1.1a')  NaN

        // 快速转换
        // 快速转number类型
        // 加号和减号可以进行快速转换
        // 如果是减号 转换结果是负数
        // console.log(+'35');//输出结果为35
        // console.log(3 + +'2');//输出结果为5
        // console.log(-'3');//输出结果为-3
        // console.log(+'-123');//输出结果为-123
        // console.log(-'-123');//输出结果为123

        // 快速转字符串
        // 拼接空字符串
        // console.log(354 + '');

        // 快速转布尔值
        // 使用双!!进行转换
        // console.log(!!'123');


        // console.log(true + '');
    </script>

强制类型转换

// Numebr()
        // 将一个字符串解析为number类型，如果有不可解析的部分则返回NaN
        // console.log(Number('123'));
        // console.log(Number('123.123'));
        // console.log(Number('123.12a')); // NaN

        // parseFloat()
        // 将一个字符串解析为number类型，保留浮点部分，若字符串不可解析则返回NaN
        // console.log(parseFloat('123.123'));
        // console.log(parseFloat('123.12a')); // 123.12
        // console.log(parseFloat('12a3.123')); // 12
        // console.log(parseFloat('a123.123')); // NaN
        // console.log(parseFloat('.123')); // 0.123
        // console.log(parseFloat('.12.3')); // 0.12//考点：只会解析一个小数点，后面的忽略不计，【等同于不可解析】

        // parseInt()
        // 将一个字符串解析为number类型，保留整数部分，若字符串不可解析则返回NaN
        // console.log(parseInt('123.12'));
        // console.log(parseInt('12a3')); // 12
        // console.log(parseInt('0.12a3')); // 0
        // console.log(parseInt('a13')); // NaN

        // Boolean()
        // 将操作数转为布尔类型
        // 任意非0数 true
        // 任意非空字符串  true
        // 任意对象 true
        以下操作数转换为布尔类型全部为
        // console.log(Boolean(null));
        // console.log(Boolean(NaN));
        // console.log(Boolean(undefined));
        // console.log(Boolean(0));
        // console.log(Boolean(0.0));
        // console.log(Boolean(""));

        // toString()
        // 将一个值转换字符串  JS中任何数据类型都能转字符串
        // true false undefined null NaN  原样转换
        // var PI = 3.14; // 常量命名规范全大写
        // console.log(PI.toString());
        // console.log(true.toString());
        // console.log(NaN.toString());

        // 二进制数
        // 3   11
        // 9   1001
        // 2147483647  2^31-1
        // var num = 2147483647;
        // console.log(num.toString(2));

        // 八进制
        // 在JS中以0开头的数为8进制数
        // var num = 13;
        // console.log(num.toString(8));
        // console.log(013);

        // 十六进制
        // 在JS中十六进制的数以0x开头
        // var num = 255;
        // console.log(num.toString(16));
        // console.log(0x16)

        var o = new Object();
        o.a = 123;//a为不可解析字符
        console.log(o.toString()); // 所有对象转字符串都是 '[object Obejct]'
// Numebr()
        // 将一个字符串解析为number类型，如果有不可解析的部分则返回NaN
        // console.log(Number('123'));
        // console.log(Number('123.123'));
        // console.log(Number('123.12a')); // NaN

        // parseFloat()
        // 将一个字符串解析为number类型，保留浮点部分，若字符串不可解析则返回NaN
        // console.log(parseFloat('123.123'));
        // console.log(parseFloat('123.12a')); // 123.12
        // console.log(parseFloat('12a3.123')); // 12
        // console.log(parseFloat('a123.123')); // NaN
        // console.log(parseFloat('.123')); // 0.123
        // console.log(parseFloat('.12.3')); // 0.12

        // parseInt()
        // 将一个字符串解析为number类型，保留整数部分，若字符串不可解析则返回NaN
        // console.log(parseInt('123.12'));
        // console.log(parseInt('12a3')); // 12
        // console.log(parseInt('0.12a3')); // 0
        // console.log(parseInt('a13')); // NaN

        // Boolean()
        // 将操作数转为布尔类型
        // 任意非0数 true
        // 任意非空字符串  true
        // 任意对象 true
        以下操作数转换为布尔类型全部为false
        // console.log(Boolean(null));
        // console.log(Boolean(NaN));
        // console.log(Boolean(undefined));
        // console.log(Boolean(0));
        // console.log(Boolean(0.0));
        // console.log(Boolean(""));

        // toString()
        // 将一个值转换字符串  JS中任何数据类型都能转字符串
        // true false undefined null NaN  原样转换
        // var PI = 3.14; // 常量命名规范全大写
        // console.log(PI.toString());
        // console.log(true.toString());
        // console.log(NaN.toString());

        // 二进制数
        // 3   11
        // 9   1001
        // 2147483647  2^31-1
        // var num = 2147483647;
        // console.log(num.toString(2));

        // 八进制
        // 在JS中以0开头的数为8进制数
        // var num = 13;
        // console.log(num.toString(8));
        // console.log(013);

        // 十六进制
        // 在JS中十六进制的数以0x开头
        // var num = 255;
        // console.log(num.toString(16));
        // console.log(0x16)

        var o = new Object();
        o.a = 123;
        console.log(o.toString()); // 所有对象转字符串都是 '[object Obejct]'

if-else语句语法

  <script>
        // if-else语句 语法
        // if(boolean表达式){
        //      代码段
        // }else{
        //      代码段
        // }

        // else关键字必须和if关键字配合使用 无法单独使用
        // 使用if-else可以实现基本的分支功能
        // if语句的布尔表达式 如果为true  执行if代码块
        // if语句的布尔表达式 如果未false 执行else代码块
        // var age = 17;
        // if (age >= 18) {
        //     console.log('成年人');
        // } else {
        //     console.log('未成年人 ');
        // }

        // var result = age >= 18 ? "成年人" : "未成年人";
        // console.log(result);

        // age >= 18 ? console.log('成年人') : console.log('未成年');
        // 所有的三目运算都可以使用if-else代替
        // 但是不是所有的if-else都能用三目运算代替


        // prompt() 用于接收用户输入的信息 接收到的输入内容是字符串类型
        // var num = prompt('请输入一个数字');
        // console.log(num);

        var age = parseInt(prompt('请输入年龄'));
        if (age >= 18) {
            alert('成年人，蹦迪');
        } else {
            alert('未成年，禁止入内');
        }
    </script>

if-else嵌套

<script>
        var age = parseInt(prompt('请输入年龄'));
        // if (isNaN(age)) {
        //     alert('年龄输入错误');
        // } else {
        //     // 在else中又写了一个if条件
        //     // 在第一个条件不满足的情况下 判断第二个条件是否满足情况
        //     // 照成了if-else的嵌套写法
        //     if (age >= 18) {
        //         alert('蹦迪');
        //     } else {
        //         alert('禁止入内');
        //     }
        // }


        // else-if 语句
        // 用于解决if-else的嵌套问题
        // else-if允许有多个  从上往下依次判断，只要有任意一个条件为true 则执行代码段 结束
        if (isNaN(age)) {
            alert('年龄输入错误');
        } else if (age >= 18) {
            alert('蹦迪');
        } else {
            alert('禁止入内');
        }
    </script>

天数判断【用户输入一个日期，判断该日期是第几天】

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script>
        // 用户输入一个 年月日
        // 判断该天是该年的第几天

        var y = parseInt(prompt('请输入年份'));
        var m = parseInt(prompt('请输入月份'));
        var d = parseInt(prompt('请输入日期'));
        // 假设 2019年 3月 22日
        // 31+28+22

        // 使用switch的穿透写法 进行数据累加
        var sum = 0; // 总天数
        //注意点；月份的从大到小的操作，也可以正序来判断
        switch (m) {
            case 12:
                sum += 30; //加的是11月的天数
            case 11:
                sum += 31; //10月
            case 10:
                sum += 30;
            case 9:
                sum += 31;
            case 8:
                sum += 31;
            case 7:
                sum += 30;
            case 6:
                sum += 31;
            case 5:
                sum += 30;
            case 4:
                sum += 31;
            case 3:
                if ((y % 4 == 0 && y % 100 != 0) || y % 400 == 0) {
                    sum += 29;
                } else {
                    sum += 28;
                }
            case 2:
                sum += 31;
            case 1:
                sum += d;
        }

        console.log(y + '年' + m + '月' + d + '日，是' + y + '年的第' + sum + '天');
    </script>
</head>

<body>

</body>

</html>

switch使用场景

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script>
        // switch(表达式 变量){
        //      case 常量:
        //         代码段
        //         [break;]
        //      case 常量:
        //         代码段
        //         [break;]
        //      [default:]
        //         代码段
        // }

        // switch 用于实现分支结构
        // switch-case 当case等于某个值的时候开始执行，程序往下继续执行直到遇到break关键字为止
        // 所有switch能完成的任务都可以使用if-else结构代替
        // siwtch-case 的结构更清晰 并且执行效率更高

        // 和if-else区别
        // if-else可以判断相等或不相等的情况 适用性广
        // switch-case 结构清晰,效率高。 通常用于判断某个指定范围内的特定值

        // 常量 值是恒定不可变的 命名规范全大写
        // 变量 存储信息的容器 值可以改变~~删除线格式~~ 

        var day = new Date().getDay(); // 获取系统中的星期 取值返回是0-6


        switch (day) {
            case 1:
                console.log('星期一');
                break;
            case 2:
                console.log('星期二');
                break;
            case 3:
                console.log('星期三');
                break;
            case 4:
                console.log('星期四');
                console.log('...');
                break;
            case 5:
                console.log('星期五');
                break;
            case 6:
                console.log('星期六');
                break;
            default:
                console.log('星期天');
        }
    </script>
</head>

<body>

</body>

</html>

cookie@

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaScript基础

1. JavaScript 保留关键字breakcase catch continuedebugger default delete doelsefalse finally for functionif in instanceofnew nullreturnswitchthis throw true try typeofvar voidwhile with2. JavaScript 将来可用的保留关键字abstractboolean bytechar class const
复制链接

扫一扫