尚硅谷day01

---恢复内容开始---

  1 <!DOCTYPE html>
  2 <html>
  3     <head>
  4         <meta charset="utf-8" />
  5         <title></title>
  6         <script type="text/javascript">
  7             
  8             /*
  9              * 数据类型指的就是字面量的类型
 10              *  在JS中一共有六种数据类型
 11              *         String 字符串
 12              *         Number 数值
 13              *         Boolean 布尔值
 14              *         Null 空值
 15              *         Undefined 未定义
 16              *         Object 对象
 17              * 
 18              * 其中String Number Boolean Null Undefined属于基本数据类型
 19              *     而Object属于引用数据类型
 20              */
 21             
 22             /*
 23              * String字符串
 24              *     - 在JS中字符串需要使用引号引起来
 25              *     - 使用双引号或单引号都可以,但是不要混着用
 26              *     - 引号不能嵌套,双引号不能放双引号,单引号不能放单引号
 27              */
 28             var str = 'hello';
 29             
 30             str = '我说:"今天天气真不错!"';
 31             
 32             /*
 33                  在字符串中我们可以使用\作为转义字符,
 34                      当表示一些特殊符号时可以使用\进行转义
 35                      
 36                      \" 表示 "
 37                      \' 表示 '
 38                      \n 表示换行
 39                      \t 制表符
 40                      \\ 表示\
 41              * */
 42             str = "我说:\"今天\t天气真不错!\"";
 43             
 44             str = "\\\\\\";
 45             
 46             //输出字面量 字符串str
 47             //alert("str");
 48             
 49             //输出变量str
 50             //alert(str);
 51             
 52             var str2 = "hello";
 53             
 54             str2 = "你好";
 55             
 56             str2 = 3;
 57 
 58 
 59             //alert("hello,你好");
 60             
 61             //console.log("我就是不出来~~~");
 62             
 63             
 64         </script>
 65     </head>
 66     <body>
 67     </body>
 68 </html>
 69 
 70 
 71 <!DOCTYPE html>
 72 <html>
 73     <head>
 74         <meta charset="UTF-8">
 75         <title></title>
 76         <script type="text/javascript">
 77             
 78             /*
 79              * 在JS中所有的数值都是Number类型,
 80              *     包括整数和浮点数(小数)
 81              * 
 82              * JS中可以表示的数字的最大值
 83              *     Number.MAX_VALUE
 84              *         1.7976931348623157e+308
 85              * 
 86              *     Number.MIN_VALUE 大于0的最小值
 87              *         5e-324
 88              * 
 89              *  如果使用Number表示的数字超过了最大值,则会返回一个
 90              *         Infinity 表示正无穷
 91              *         -Infinity 表示负无穷
 92              *         使用typeof检查Infinity也会返回number
 93              *  NaN 是一个特殊的数字,表示Not A Number
 94              *         使用typeof检查一个NaN也会返回number
 95              */
 96             //数字123
 97             var a = 123;
 98             //字符串123
 99             var b = "123";
100             /*
101                  可以使用一个运算符 typeof
102                      来检查一个变量的类型
103                  语法:typeof 变量    
104                  检查字符串时,会返回string
105                  检查数值时,会返回number
106              * */
107             //console.log(typeof b);
108             
109             a = -Number.MAX_VALUE * Number.MAX_VALUE;
110             
111             a = "abc" * "bcd";
112             
113             a = NaN;
114             
115             //console.log(typeof a);
116             
117             a = Number.MIN_VALUE;
118             
119             //console.log(a);
120             
121             /*
122              * 在JS中整数的运算基本可以保证精确
123              */
124             var c = 1865789 + 7654321;
125             
126             /*
127              * 如果使用JS进行浮点运算,可能得到一个不精确的结果
128              *     所以千万不要使用JS进行对精确度要求比较高的运算    
129              */
130             var c = 0.1 + 0.2;
131             
132             console.log(c);
133             
134             
135         </script>
136     </head>
137     <body>
138     </body>
139 </html>
140 
141 
142 <!DOCTYPE html>
143 <html>
144     <head>
145         <meta charset="UTF-8">
146         <title></title>
147         <script type="text/javascript">
148             
149             /*
150              * Boolean 布尔值
151              *     布尔值只有两个,主要用来做逻辑判断
152              *     true
153              *         - 表示真
154              *     false
155              *         - 表示假
156              * 
157              * 使用typeof检查一个布尔值时,会返回boolean
158              */
159             
160             var bool = false;
161             
162             console.log(typeof bool);
163             console.log(bool);
164             
165             
166         </script>
167     </head>
168     <body>
169     </body>
170 </html>
171 <!DOCTYPE html>
172 <html>
173     <head>
174         <meta charset="UTF-8">
175         <title></title>
176         <script type="text/javascript">
177             
178             /*
179              * Null(空值)类型的值只有一个,就是null
180              *     null这个值专门用来表示一个为空的对象
181              *     使用typeof检查一个null值时,会返回object
182              * 
183              * Undefined(未定义)类型的值只有一个,就undefind
184              *     当声明一个变量,但是并不给变量赋值时,它的值就是undefined
185              *     使用typeof检查一个undefined时也会返回undefined
186              */
187             var a = null;
188             
189             var b = undefined;
190             
191             console.log(typeof b);
192             
193         </script>
194     </head>
195     <body>
196     </body>
197 </html>
198 <!DOCTYPE html>
199 <html>
200     <head>
201         <meta charset="UTF-8">
202         <title></title>
203         <script type="text/javascript">
204             
205             /*
206              * 强制类型转换
207              *     - 指将一个数据类型强制转换为其他的数据类型
208              *     - 类型转换主要指,将其他的数据类型,转换为
209              *         String Number Boolean
210              *         
211              */
212             
213             /*
214              * 将其他的数据类型转换为String
215              *     方式一:
216              *         - 调用被转换数据类型的toString()方法
217              *         - 该方法不会影响到原变量,它会将转换的结果返回
218              *         - 但是注意:null和undefined这两个值没有toString()方法,
219              *             如果调用他们的方法,会报错
220              * 
221              *  方式二:
222              *         - 调用String()函数,并将被转换的数据作为参数传递给函数
223              *         - 使用String()函数做强制类型转换时,
224              *             对于Number和Boolean实际上就是调用的toString()方法
225              *             但是对于null和undefined,就不会调用toString()方法
226              *                 它会将 null 直接转换为 "null"
227              *                 将 undefined 直接转换为 "undefined"
228              * 
229              */
230             
231             var a = 123;
232             
233             //调用a的toString()方法
234             //调用xxx的yyy()方法,就是xxx.yyy()
235             a = a.toString();
236             
237             a = true;
238             a = a.toString();
239             
240             a = null;
241             //a = a.toString(); //报错
242             
243             a = undefined;
244             //a = a.toString(); //报错
245             
246             
247             a = 123;
248             
249             //调用String()函数,来将a转换为字符串
250             a = String(a);
251             
252             a = null;
253             a = String(a);
254             
255             a = undefined;
256             a = String(a);
257             
258             console.log(typeof a);
259             console.log(a);
260             
261             
262             
263             
264             
265         </script>
266     </head>
267     <body>
268     </body>
269 </html>
270 <!DOCTYPE html>
271 <html>
272     <head>
273         <meta charset="UTF-8">
274         <title></title>
275         <script type="text/javascript">
276         
277             /*
278              * 将其他的数据类型转换为Number
279              *      转换方式一:
280              *         使用Number()函数
281              *             - 字符串 --> 数字
282              *                 1.如果是纯数字的字符串,则直接将其转换为数字
283              *                 2.如果字符串中有非数字的内容,则转换为NaN
284              *                 3.如果字符串是一个空串或者是一个全是空格的字符串,则转换为0
285              *             - 布尔 --> 数字
286              *                 true 转成 1
287              *                 false 转成 0
288              * 
289              *             - null --> 数字     0
290              * 
291              *             - undefined --> 数字 NaN
292              * 
293              * 转换方式二:
294              *         - 这种方式专门用来对付字符串
295              *         - parseInt() 把一个字符串转换为一个整数
296              *         - parseFloat() 把一个字符串转换为一个浮点数
297              */
298             
299             var a = "123";
300             
301             //调用Number()函数来将a转换为Number类型
302             a = Number(a);
303             
304             a = false;
305             a = Number(a);
306             
307             a = null;
308             a = Number(a);
309             
310             a = undefined;
311             a = Number(a);
312             
313             a = "123567a567px";
314             //调用parseInt()函数将a转换为Number
315             /*
316              * parseInt()可以将一个字符串中的有效的整数内容去出来,
317              *     然后转换为Number
318              */
319             a = parseInt(a);
320             
321             /*
322              * parseFloat()作用和parseInt()类似,不同的是它可以获得有效的小数
323              */
324             a = "123.456.789px";
325             a = parseFloat(a);
326             
327             /*
328              * 如果对非String使用parseInt()或parseFloat()
329              *     它会先将其转换为String然后在操作
330              */
331             a = true;
332             a = parseInt(a);
333             
334             a = 198.23;
335             a = parseInt(a);
336             
337             console.log(typeof a);
338             console.log(a);
339             
340             
341             
342         </script>
343     </head>
344     <body>
345     </body>
346 </html>
347 <!DOCTYPE html>
348 <html>
349     <head>
350         <meta charset="UTF-8">
351         <title></title>
352         <script type="text/javascript">
353             
354             var a = 123;
355             
356             /*
357              * 在js中,如果需要表示16进制的数字,则需要以0x开头
358              *             如果需要表示8进制的数字,则需要以0开头
359              *             如果要要表示2进制的数字,则需要以0b开头
360              *                 但是不是所有的浏览器都支持
361              *     
362              */
363             
364             //十六进制
365             a = 0x10;
366             a = 0xff;
367             a = 0xCafe;
368             
369             //八进制数字
370             a = 070;
371             
372             //二进制数字
373             //a = 0b10;
374             
375             //向"070"这种字符串,有些浏览器会当成8进制解析,有些会当成10进制解析
376             a = "070";
377             
378             //可以在parseInt()中传递一个第二个参数,来指定数字的进制
379             a = parseInt(a,10);
380             
381             console.log(typeof a);
382             console.log(a);
383             
384         </script>
385     </head>
386     <body>
387     </body>
388 </html>
389 <!DOCTYPE html>
390 <html>
391     <head>
392         <meta charset="UTF-8">
393         <title></title>
394         <script type="text/javascript">
395             
396             /*
397              * 将其他的数据类型转换为Boolean
398              *     - 使用Boolean()函数
399              *         - 数字 ---> 布尔
400              *             - 除了0和NaN,其余的都是true
401              * 
402              *         - 字符串 ---> 布尔
403              *             - 除了空串,其余的都是true
404              * 
405              *         - null和undefined都会转换为false
406              * 
407              *         - 对象也会转换为true
408              *         
409              */
410             
411             var a = 123; //true
412             a = -123; //true
413             a = 0; //false
414             a = Infinity; //true
415             a = NaN; //false
416             
417             //调用Boolean()函数来将a转换为布尔值
418             a = Boolean(a);
419             
420             a = " ";
421             
422             a = Boolean(a);
423             
424             a = null; //false
425             a = Boolean(a);
426             
427             a = undefined; //false
428             a = Boolean(a);
429             
430             console.log(typeof a);
431             console.log(a);
432             
433         </script>
434     </head>
435     <body>
436     </body>
437 </html>
438 <!DOCTYPE html>
439 <html>
440     <head>
441         <meta charset="UTF-8">
442         <title></title>
443         <script type="text/javascript">
444             
445             /*
446              * 运算符也叫操作符
447              *     通过运算符可以对一个或多个值进行运算,并获取运算结果
448              *     比如:typeof就是运算符,可以来获得一个值的类型
449              *         它会将该值的类型以字符串的形式返回
450              *         number string boolean undefined object
451              * 
452              *     算数运算符
453              *         当对非Number类型的值进行运算时,会将这些值转换为Number然后在运算
454              *             任何值和NaN做运算都得NaN
455              * 
456              *         +
457              *             +可以对两个值进行加法运算,并将结果返回
458              *              如果对两个字符串进行加法运算,则会做拼串
459              *                 会将两个字符串拼接为一个字符串,并返回
460              *             任何的值和字符串做加法运算,都会先转换为字符串,然后再和字符串做拼串的操作
461              *         -
462              *             - 可以对两个值进行减法运算,并将结果返回
463              * 
464              *         *
465              *             * 可以对两个值进行乘法运算
466              *         /
467              *             / 可以对两个值进行除法运算
468              *         %
469              *             % 取模运算(取余数)
470              */
471             var a = 123;
472             
473             var result = typeof a;
474             
475             //console.log(typeof result);
476             
477             result = a + 1;
478             
479             result = 456 + 789;
480             
481             result = true + 1;
482             
483             result = true + false;
484             
485             result = 2 + null;
486             
487             result = 2 + NaN;
488             
489             result = "你好" + "大帅哥";
490             
491             var str = "锄禾日当午," +
492                       "汗滴禾下土," +
493                       "谁知盘中餐," +
494                       "粒粒皆辛苦";
495                       
496                       
497             result = 123 + "1";
498             
499             result = true + "hello";
500             
501             //任何值和字符串相加都会转换为字符串,并做拼串操作
502             /*
503              * 我们可以利用这一特点,来将一个任意的数据类型转换为String
504              *     我们只需要为任意的数据类型 + 一个 "" 即可将其转换为String
505              *     这是一种隐式的类型转换,由浏览器自动完成,实际上它也是调用String()函数
506              */
507             var c = 123;
508             
509             c = c + "";
510             
511             //c = null;
512             
513             //c = c + "";
514             
515             
516             //console.log(result);
517             //console.log(typeof c);
518             //console.log("c = "+c);
519             
520             result = 1 + 2 + "3"; //33
521             
522             result = "1" + 2 + 3; //123
523             
524             result = 100 - 5;
525             
526             result = 100 - true;
527             
528             result = 100 - "1";
529             
530             result = 2 * 2;
531             
532             result = 2 * "8";
533             
534             result = 2 * undefined;
535             
536             result = 2 * null;
537             
538             result = 4 / 2;
539             
540             result = 3 / 2;
541             
542             /*
543              * 任何值做- * /运算时都会自动转换为Number
544              *     我们可以利用这一特点做隐式的类型转换
545              *         可以通过为一个值 -0 *1 /1来将其转换为Number
546              *         原理和Number()函数一样,使用起来更加简单
547              */
548             
549             var d = "123";
550             
551             //console.log("result = "+result);
552             
553             d = d - 0;
554             
555             /*console.log(typeof d);
556             console.log(d);*/
557             
558             result = 9 % 3;
559             result = 9 % 4;
560             result = 9 % 5;
561             
562             console.log("result = "+result);
563             
564         </script>
565     </head>
566     <body>
567     </body>
568 </html>
569 <!DOCTYPE html>
570 <html>
571     <head>
572         <meta charset="UTF-8">
573         <title></title>
574         <script type="text/javascript">
575             
576             /*
577              * 一元运算符,只需要一个操作数
578              *     + 正号
579              *         - 正号不会对数字产生任何影响
580              *     - 负号
581              *         - 负号可以对数字进行负号的取反
582              * 
583              *     - 对于非Number类型的值,
584              *         它会将先转换为Number,然后在运算
585              *         可以对一个其他的数据类型使用+,来将其转换为number
586              *         它的原理和Number()函数一样
587              */
588             
589             var a = 123;
590             
591             a = -a;
592             
593             a = true;
594             
595             a = "18";
596             
597             a = +a;
598             
599             /*console.log("a = "+a);
600             console.log(typeof a);*/
601             
602             var result = 1 + +"2" + 3;
603             
604             console.log("result = "+result);
605             
606             
607             
608         </script>
609     </head>
610     <body>
611     </body>
612 </html>
613 <!DOCTYPE html>
614 <html>
615     <head>
616         <meta charset="UTF-8">
617         <title></title>
618         <script type="text/javascript">
619             
620             /*
621              * 自增 ++
622              *      - 通过自增可以使变量在自身的基础上增加1
623              *      - 对于一个变量自增以后,原变量的值会立即自增1
624              *      - 自增分成两种:后++(a++) 和 前++(++a)    
625              *         无论是a++ 还是 ++a,都会立即使原变量的值自增1
626              *             不同的是a++ 和 ++a的值不同
627              *         a++的值等于原变量的值(自增前的值)
628              *         ++a的值等于新值 (自增后的值)
629              * 
630              * 自减 --
631              *     - 通过自减可以使变量在自身的基础上减1
632              *     - 自减分成两种:后--(a--) 和 前--(--a)
633              *         无论是a-- 还是 --a 都会立即使原变量的值自减1
634              *             不同的是a-- 和 --a的值不同
635              *                 a-- 是变量的原值 (自减前的值)
636              *                 --a 是变量的新值 (自减以后的值)
637              *             
638              *     
639              */
640             
641             var num = 10;
642             
643             //num--;
644             //--num;
645             
646             //console.log(num--);
647             console.log(--num);
648             
649             console.log("num = "+num);
650             
651             
652             var a = 1;
653             
654             //使a自增1
655             //a++;
656             //++a;
657             
658             //console.log(a++);
659             
660             //console.log("++a = " + ++a);
661             /*console.log("a++ = " + a++);
662             
663             console.log("a = "+a);*/
664             
665             
666             var c = 10;
667             
668             //第一次c++,是在10的基础上自增
669             //console.log(c++);
670             
671             //第二次c++,是在11的基础上自增
672             c++;
673             
674             var d = 20;
675             
676             //console.log(++d);//21
677             //console.log(++d);//22
678             
679             //20 + 22 + 22
680             //var result = d++ + ++d + d ;
681             
682             
683             //d = 20
684             d = d++;
685             
686             /*
687              * var e = d++;
688              * d = e;
689              */
690             
691             //console.log("d = "+d);
692             
693             
694             
695             
696         </script>
697         
698     </head>
699     <body>
700     </body>
701 </html>

猜你喜欢

转载自www.cnblogs.com/liujun5319/p/9716633.html