js学习day02

深藏阁楼爱情的钟 2023-02-23 12:23 81阅读 0赞 
  1. <!DOCTYPE html>
  2. <html>
  3.  <head>
  4.   <meta charset="utf-8" />
  5.   <title></title>
  6.   <script type="text/javascript">
  8.    /* * 数据类型指的就是字面量的类型 * 在JS中一共有六种数据类型 * String 字符串 * Number 数值 * Boolean 布尔值 * Null 空值 * Undefined 未定义 * Object 对象 * * 其中String Number Boolean Null Undefined属于基本数据类型 * 而Object属于引用数据类型 */
  10.    /* * String字符串 * - 在JS中字符串需要使用引号引起来 * - 使用双引号或单引号都可以，但是不要混着用 * - 引号不能嵌套，双引号不能放双引号，单引号不能放单引号 */
  11.    var str = 'hello';
  13.    str = '我说:"今天天气真不错！"';
  15.    /* 在字符串中我们可以使用\作为转义字符， 当表示一些特殊符号时可以使用\进行转义 \" 表示 " \' 表示 ' \n 表示换行 \t 制表符 \\ 表示\ * */
  16.    str = "我说:\"今天\t天气真不错！\"";
  18.    str = "\\\\\\";
  20.    //输出字面量 字符串str
  21.    //alert("str");
  23.    //输出变量str
  24.    //alert(str);
  26.    var str2 = "hello";
  28.    str2 = "你好";
  30.    str2 = 3;
  33.    //alert("hello，你好");
  35.    //console.log("我就是不出来~~~");
  38.   </script>
  39.  </head>
  40.  <body>
  41.  </body>
  42. </html>
  46. <!DOCTYPE html>
  47. <html>
  48.     <head>
  49.         <meta charset="UTF-8">
  50.         <title></title>
  51.         <script type="text/javascript">
  53.             /* * 在JS中所有的数值都是Number类型， * 包括整数和浮点数（小数） * * JS中可以表示的数字的最大值 * Number.MAX_VALUE * 1.7976931348623157e+308 * * Number.MIN_VALUE 大于0的最小值 * 5e-324 * * 如果使用Number表示的数字超过了最大值，则会返回一个 * Infinity 表示正无穷 * -Infinity 表示负无穷 * 使用typeof检查Infinity也会返回number * NaN 是一个特殊的数字，表示Not A Number * 使用typeof检查一个NaN也会返回number */
  54.             //数字123
  55.             var a = 123;
  56.             //字符串123
  57.             var b = "123";
  58.             /* 可以使用一个运算符 typeof 来检查一个变量的类型 语法：typeof 变量 检查字符串时，会返回string 检查数值时，会返回number * */
  59.             //console.log(typeof b);
  61.             a = -Number.MAX_VALUE * Number.MAX_VALUE;
  63.             a = "abc" * "bcd";
  65.             a = NaN;
  67.             //console.log(typeof a);
  69.             a = Number.MIN_VALUE;
  71.             //console.log(a);
  73.             /* * 在JS中整数的运算基本可以保证精确 */
  74.             var c = 1865789 + 7654321;
  76.             /* * 如果使用JS进行浮点运算，可能得到一个不精确的结果 * 所以千万不要使用JS进行对精确度要求比较高的运算 */
  77.             var c = 0.1 + 0.2;
  79.             console.log(c);
  82.         </script>
  83.     </head>
  84.     <body>
  85.     </body>
  86. </html>
  90. <!DOCTYPE html>
  91. <html>
  92.     <head>
  93.         <meta charset="UTF-8">
  94.         <title></title>
  95.         <script type="text/javascript">
  97.             /* * Boolean 布尔值 * 布尔值只有两个，主要用来做逻辑判断 * true * - 表示真 * false * - 表示假 * * 使用typeof检查一个布尔值时，会返回boolean */
  99.             var bool = false;
  101.             console.log(typeof bool);
  102.             console.log(bool);
  105.         </script>
  106.     </head>
  107.     <body>
  108.     </body>
  109. </html>
  114. <!DOCTYPE html>
  115. <html>
  116.     <head>
  117.         <meta charset="UTF-8">
  118.         <title></title>
  119.         <script type="text/javascript">
  121.             /* * Null（空值）类型的值只有一个，就是null * null这个值专门用来表示一个为空的对象 * 使用typeof检查一个null值时，会返回object * * Undefined（未定义）类型的值只有一个，就undefind * 当声明一个变量，但是并不给变量赋值时，它的值就是undefined * 使用typeof检查一个undefined时也会返回undefined */
  122.             var a = null;
  124.             var b = undefined;
  126.             console.log(typeof b);
  128.         </script>
  129.     </head>
  130.     <body>
  131.     </body>
  132. </html>
  136. <!DOCTYPE html>
  137. <html>
  138.     <head>
  139.         <meta charset="UTF-8">
  140.         <title></title>
  141.         <script type="text/javascript">
  143.             /* * 将其他的数据类型转换为Number * 转换方式一： * 使用Number()函数 * - 字符串 --> 数字 * 1.如果是纯数字的字符串，则直接将其转换为数字 * 2.如果字符串中有非数字的内容，则转换为NaN * 3.如果字符串是一个空串或者是一个全是空格的字符串，则转换为0 * - 布尔 --> 数字 * true 转成 1 * false 转成 0 * * - null --> 数字 0 * * - undefined --> 数字 NaN * * 转换方式二： * - 这种方式专门用来对付字符串 * - parseInt() 把一个字符串转换为一个整数 * - parseFloat() 把一个字符串转换为一个浮点数 */
  145.             var a = "123";
  147.             //调用Number()函数来将a转换为Number类型
  148.             a = Number(a);
  150.             a = false;
  151.             a = Number(a);
  153.             a = null;
  154.             a = Number(a);
  156.             a = undefined;
  157.             a = Number(a);
  159.             a = "123567a567px";
  160.             //调用parseInt()函数将a转换为Number
  161.             /* * parseInt()可以将一个字符串中的有效的整数内容去出来， * 然后转换为Number */
  162.             a = parseInt(a);
  164.             /* * parseFloat()作用和parseInt()类似，不同的是它可以获得有效的小数 */
  165.             a = "123.456.789px";
  166.             a = parseFloat(a);
  168.             /* * 如果对非String使用parseInt()或parseFloat() * 它会先将其转换为String然后在操作 */
  169.             a = true;
  170.             a = parseInt(a);
  172.             a = 198.23;
  173.             a = parseInt(a);
  175.             console.log(typeof a);
  176.             console.log(a);
  180.         </script>
  181.     </head>
  182.     <body>
  183.     </body>
  184. </html>
  193. <!DOCTYPE html>
  194. <html>
  195.     <head>
  196.         <meta charset="UTF-8">
  197.         <title></title>
  198.         <script type="text/javascript">
  200.             var a = 123;
  202.             /* * 在js中，如果需要表示16进制的数字，则需要以0x开头 * 如果需要表示8进制的数字，则需要以0开头 * 如果要要表示2进制的数字，则需要以0b开头 * 但是不是所有的浏览器都支持 * */
  204.             //十六进制
  205.             a = 0x10;
  206.             a = 0xff;
  207.             a = 0xCafe;
  209.             //八进制数字
  210.             a = 070;
  212.             //二进制数字
  213.             //a = 0b10;
  215.             //向"070"这种字符串，有些浏览器会当成8进制解析，有些会当成10进制解析
  216.             a = "070";
  218.             //可以在parseInt()中传递一个第二个参数，来指定数字的进制
  219.             a = parseInt(a,10);
  221.             console.log(typeof a);
  222.             console.log(a);
  224.         </script>
  225.     </head>
  226.     <body>
  227.     </body>
  228. </html>
  232. !DOCTYPE html>
  233. <html>
  234.     <head>
  235.         <meta charset="UTF-8">
  236.         <title></title>
  237.         <script type="text/javascript">
  239.             /* * 将其他的数据类型转换为Boolean * - 使用Boolean()函数 * - 数字 ---> 布尔 * - 除了0和NaN，其余的都是true * * - 字符串 ---> 布尔 * - 除了空串，其余的都是true * * - null和undefined都会转换为false * * - 对象也会转换为true * */
  241.             var a = 123; //true
  242.             a = -123; //true
  243.             a = 0; //false
  244.             a = Infinity; //true
  245.             a = NaN; //false
  247.             //调用Boolean()函数来将a转换为布尔值
  248.             a = Boolean(a);
  250.             a = " ";
  252.             a = Boolean(a);
  254.             a = null; //false
  255.             a = Boolean(a);
  257.             a = undefined; //false
  258.             a = Boolean(a);
  260.             console.log(typeof a);
  261.             console.log(a);
  263.         </script>
  264.     </head>
  265.     <body>
  266.     </body>
  267. </html>
  272. <!DOCTYPE html>
  273. <html>
  274.     <head>
  275.         <meta charset="UTF-8">
  276.         <title></title>
  277.         <script type="text/javascript">
  279.             /* * 一元运算符，只需要一个操作数 * + 正号 * - 正号不会对数字产生任何影响 * - 负号 * - 负号可以对数字进行负号的取反 * * - 对于非Number类型的值， * 它会将先转换为Number，然后在运算 * 可以对一个其他的数据类型使用+,来将其转换为number * 它的原理和Number()函数一样 * 但是在這裏要小心的是，拼串的結果和前後的數據類型有著密切的關係 */
  281.             var a = 123;
  283.             a = -a;
  285.             a = true;
  287.             a = "18";
  289.             a = +a;
  291.             /*console.log("a = "+a); console.log(typeof a);*/
  293.             var result = 1 + +"2" + 3;
  295.             console.log("result = "+result);
  299.         </script>
  300.     </head>
  301.     <body>
  302.     </body>
  303. </html>
  307. <!DOCTYPE html>
  308. <html>
  309.     <head>
  310.         <meta charset="UTF-8">
  311.         <title></title>
  312.         <script type="text/javascript">
  314.             /* * 自增 ++ * - 通过自增可以使变量在自身的基础上增加1 * - 对于一个变量自增以后，原变量的值会立即自增1 * - 自增分成两种：后++(a++) 和 前++(++a) * 无论是a++ 还是 ++a，都会立即使原变量的值自增1 * 不同的是a++ 和 ++a的值不同 * a++的值等于原变量的值（自增前的值） * ++a的值等于新值 （自增后的值） * * 自减 -- * - 通过自减可以使变量在自身的基础上减1 * - 自减分成两种：后--(a--) 和 前--(--a) * 无论是a-- 还是 --a 都会立即使原变量的值自减1 * 不同的是a-- 和 --a的值不同 * a-- 是变量的原值 （自减前的值） * --a 是变量的新值 （自减以后的值） * * */
  316.             var num = 10;
  318.             //num--;
  319.             //--num;
  321.             //console.log(num--);
  322.             console.log(--num);
  324.             console.log("num = "+num);
  327.             var a = 1;
  329.             //使a自增1
  330.             //a++;
  331.             //++a;
  333.             //console.log(a++);
  335.             //console.log("++a = " + ++a);
  336.             /*console.log("a++ = " + a++); console.log("a = "+a);*/
  339.             var c = 10;
  341.             //第一次c++，是在10的基础上自增
  342.             //console.log(c++);
  344.             //第二次c++，是在11的基础上自增
  345.             c++;
  347.             var d = 20;
  349.             //console.log(++d);//21
  350.             //console.log(++d);//22
  352.             //20 + 22 + 22
  353.             //var result = d++ + ++d + d ;
  356.             //d = 20
  357.             d = d++;
  359.             /* * var e = d++; * d = e; */
  361.             //console.log("d = "+d);
  366.         </script>
  368.     </head>
  369.     <body>
  370.     </body>
  371. </html>
  376. <!DOCTYPE html>
  377. <html>
  378.     <head>
  379.         <meta charset="UTF-8">
  380.         <title></title>
  381.         <script type="text/javascript">
  383.             /* * 运算符也叫操作符 * 通过运算符可以对一个或多个值进行运算,并获取运算结果 * 比如：typeof就是运算符，可以来获得一个值的类型 * 它会将该值的类型以字符串的形式返回 * number string boolean undefined object * * 算数运算符 * 当对非Number类型的值进行运算时，会将这些值转换为Number然后在运算 * 任何值和NaN做运算都得NaN * * + * +可以对两个值进行加法运算，并将结果返回 * 如果对两个字符串进行加法运算，则会做拼串 * 会将两个字符串拼接为一个字符串，并返回 * 任何的值和字符串做加法运算，都会先转换为字符串，然后再和字符串做拼串的操作 * - * - 可以对两个值进行减法运算，并将结果返回 * * * * * 可以对两个值进行乘法运算 无限*0=nan * / * / 可以对两个值进行除法运算 * % * % 取模运算（取余数） */
  384.             var a = 123;
  386.             var result = typeof a;
  388.             //console.log(typeof result);
  390.             result = a + 1;
  392.             result = 456 + 789;
  394.             result = true + 1;
  396.             result = true + false;
  398.             result = 2 + null;
  400.             result = 2 + NaN;
  402.             result = "你好" + "大帅哥";
  404.             var str = "锄禾日当午，" +
  405.                       "汗滴禾下土，" +
  406.                       "谁知盘中餐，" +
  407.                       "粒粒皆辛苦";
  410.             result = 123 + "1";
  412.             result = true + "hello";
  414.             //任何值和字符串相加都会转换为字符串，并做拼串操作
  415.             /* * 我们可以利用这一特点，来将一个任意的数据类型转换为String * 我们只需要为任意的数据类型 + 一个 "" 即可将其转换为String * 这是一种隐式的类型转换，由浏览器自动完成，实际上它也是调用String()函数 */
  416.             var c = 123;
  418.             c = c + "";
  420.             //c = null;
  422.             //c = c + "";
  425.             //console.log(result);
  426.             //console.log(typeof c);
  427.             //console.log("c = "+c);
  429.             result = 1 + 2 + "3"; //33
  431.             result = "1" + 2 + 3; //123
  433.             result = 100 - 5;
  435.             result = 100 - true;
  437.             result = 100 - "1";
  439.             result = 2 * 2;
  441.             result = 2 * "8";
  443.             result = 2 * undefined;
  445.             result = 2 * null;
  447.             result = 4 / 2;
  449.             result = 3 / 2;
  451.             /* * 任何值做- * /运算时都会自动转换为Number * 我们可以利用这一特点做隐式的类型转换 * 可以通过为一个值 -0 *1 /1来将其转换为Number * 原理和Number()函数一样，使用起来更加简单 */
  453.             var d = "123";
  455.             //console.log("result = "+result);
  457.             d = d - 0;
  459.             /*console.log(typeof d); console.log(d);*/
  461.             result = 9 % 3;
  462.             result = 9 % 4;
  463.             result = 9 % 5;
  465.             console.log("result = "+result);
  467.         </script>
  468.     </head>
  469.     <body>
  470.     </body>
  471. </html>

发表评论

表情：
评论列表 （有 0 条评论，81人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java基础学习Day02

    知识点 1. Java命名规范 2. 常量和变量 3. 8个基本数据类型 4. 逻辑运算符 Java命名规范 标识符不能使用关键字和保留字 标

    悠悠悠悠/ 0 赞/ 443 阅读