js学习day03

我就是我 2023-02-23 12:25 100阅读 0赞 
  1. <!DOCTYPE html>
  2. <html>
  3.  <head>
  4.   <meta charset="UTF-8">
  5.   <title></title>
  6.   <script type="text/javascript">
  8.    /* * JS中为我们提供了三种逻辑运算符 * ! 非 * - !可以用来对一个值进行非运算 * - 所谓非运算就是值对一个布尔值进行取反操作， * true变false，false变true * - 如果对一个值进行两次取反，它不会变化 * - 如果对非布尔值进行元素，则会将其转换为布尔值，然后再取反 * 所以我们可以利用该特点，来将一个其他的数据类型转换为布尔值 * 可以为一个任意数据类型取两次反，来将其转换为布尔值， * 原理和Boolean()函数一样 * * && 与 * - &&可以对符号两侧的值进行与运算并返回结果 * - 运算规则 * - 两个值中只要有一个值为false就返回false， * 只有两个值都为true时，才会返回true * - JS中的“与”属于短路的与， * 如果第一个值为false，则不会看第二个值 * * || 或 * - ||可以对符号两侧的值进行或运算并返回结果 * - 运算规则： * - 两个值中只要有一个true，就返回true * 如果两个值都为false，才返回false * - JS中的“或”属于短路的或 * 如果第一个值为true，则不会检查第二个值 */
  10.    //如果两个值都是true则返回true
  11.    var result = true && true;
  13.    //只要有一个false，就返回false
  14.    result = true && false;
  15.    result = false && true;
  16.    result = false && false;
  18.    //console.log("result = "+result);
  20.    //第一个值为true，会检查第二个值
  21.    //true && alert("看我出不出来！！");
  23.    //第一个值为false，不会检查第二个值
  24.    //false && alert("看我出不出来！！");
  26.    //两个都是false，则返回false
  27.    result = false || false;
  29.    //只有有一个true，就返回true
  30.    result = true || false;
  31.    result = false || true ;
  32.    result = true || true ;
  34.    //console.log("result = "+result);
  36.    //第一个值为false，则会检查第二个值
  37.    //false || alert("123");
  39.    //第一个值为true，则不再检查第二个值
  40.    //true || alert("123");
  44.    var a = false;
  46.    //对a进行非运算
  47.    a = !a;
  49.    //console.log("a = "+a);
  51.    var b = 10;
  52.    b = !!b;
  54.    //console.log("b = "+b);
  55.    //console.log(typeof b);
  57.   </script>
  58.  </head>
  59.  <body>
  60.  </body>
  61. </html>
  66. <!DOCTYPE html>
  67. <html>
  68.     <head>
  69.         <meta charset="UTF-8">
  70.         <title></title>
  72.         <script type="text/javascript">
  74.             /* * && || 非布尔值的情况 * - 对于非布尔值进行与或运算时， * 会先将其转换为布尔值，然后再运算，并且返回原值 * - 与运算： * - 如果第一个值为true，则必然返回第二个值 * - 如果第一个值为false，则直接返回第一个值 * * - 或运算 * - 如果第一个值为true，则直接返回第一个值 * - 如果第一个值为false，则返回第二个值 * */
  76.             //true && true
  77.             //与运算：如果两个值都为true，则返回后边的
  78.             var result = 5 && 6;
  81.             //与运算：如果两个值中有false，则返回靠前的false
  82.             //false && true
  83.             result = 0 && 2;
  84.             result = 2 && 0;
  85.             //false &&　false
  86.             result = NaN && 0;
  87.             result = 0 && NaN;
  90.             //true || true
  91.             //如果第一个值为true，则直接返回第一个值
  92.             result = 2 || 1;
  93.             result = 2 || NaN;
  94.             result = 2 || 0;
  96.             //如果第一个值为false，则直接返回第二个值
  97.             result = NaN || 1;
  98.             result = NaN || 0;
  100.             result = "" || "hello";
  102.             result = -1 || "你好";
  105.             console.log("result = "+result);
  107.         </script>
  109.     </head>
  110.     <body>
  111.     </body>
  112. </html>
  118. <!DOCTYPE html>
  119. <html>
  120.     <head>
  121.         <meta charset="UTF-8">
  122.         <title></title>
  123.         <script type="text/javascript">
  125.             /* * 通过关系运算符可以比较两个值之间的大小关系， * 如果关系成立它会返回true，如果关系不成立则返回false * * > 大于号 * - 判断符号左侧的值是否大于右侧的值 * - 如果关系成立，返回true，如果关系不成立则返回false * * >= 大于等于 * - 判断符号左侧的值是否大于或等于右侧的值 * * < 小于号 * <= 小于等于 * * 非数值的情况 * - 对于非数值进行比较时，会将其转换为数字然后在比较 * - 如果符号两侧的值都是字符串时，不会将其转换为数字进行比较 * 而会分别比较字符串中字符的Unicode编码 */
  127.             var result = 5 > 10;//false
  129.             result = 5 > 4; //true
  131.             result = 5 > 5; //false
  133.             result = 5 >= 5; //true
  135.             result = 5 >= 4; //true
  137.             result = 5 < 4; //false
  139.             result = 4 <= 4; //true
  141.             //console.log("result = "+result);
  143.             //console.log(1 > true); //false
  144.             //console.log(1 >= true); //true
  145.             //console.log(1 > "0"); //true
  146.             //console.log(10 > null); //true
  147.             //任何值和NaN做任何比较都是false
  148.             //console.log(10 <= "hello"); //false
  149.             //console.log(true > false); //true
  151.             //console.log("1" < "5"); //true
  152.             //console.log("11" < "5"); //true
  154.             //比较两个字符串时，比较的是字符串的字符编码
  155.             //console.log("a" < "b");//true
  156.             //比较字符编码时是一位一位进行比较
  157.             //如果两位一样，则比较下一位，所以借用它来对英文进行排序
  158.             //console.log("abc" < "bcd");//true
  159.             //比较中文时没有意义
  160.             //console.log("戒" > "我"); //true
  162.             //如果比较的两个字符串型的数字，可能会得到不可预期的结果
  163.             //注意：在比较两个字符串型的数字时，一定一定一定要转型
  164.             console.log("11123123123123123123" < +"5"); //true
  166.         </script>
  167.     </head>
  168.     <body>
  169.     </body>
  170. </html>
  178. <!DOCTYPE html>
  179. <html>
  180.     <head>
  181.         <meta charset="UTF-8">
  182.         <title></title>
  183.         <script type="text/javascript">
  185.             /* * 在字符串中使用转义字符输入Unicode编码 * \u四位编码 */
  186.             console.log("\u2620");
  188.         </script>
  189.     </head>
  190.     <body>
  192.         <!--在网页中使用Unicode编码
  193.             &#编码; 这里的编码需要的是10进制
  194.         -->
  195.         <h1 style="font-size: 200px;">☠</h1>
  196.         <h1 style="font-size: 200px;">⚀</h1>
  198.     </body>
  199. </html>
  207. <!DOCTYPE html>
  208. <html>
  209.     <head>
  210.         <meta charset="UTF-8">
  211.         <title></title>
  212.         <script type="text/javascript">
  214.             /* * 相等运算符用来比较两个值是否相等， * 如果相等会返回true，否则返回false * * 使用 == 来做相等运算 * - 当使用==来比较两个值时，如果值的类型不同， * 则会自动进行类型转换，将其转换为相同的类型 * 然后在比较 * 不相等 * 不相等用来判断两个值是否不相等，如果不相等返回true，否则返回false * - 使用 != 来做不相等运算 * - 不相等也会对变量进行自动的类型转换，如果转换后相等它也会返回false * * * === * 全等 * - 用来判断两个值是否全等，它和相等类似，不同的是它不会做自动的类型转换 * 如果两个值的类型不同，直接返回false * !== * 不全等 * - 用来判断两个值是否不全等，和不等类似，不同的是它不会做自动的类型转换 * 如果两个值的类型不同，直接返回true */
  216.             //console.log(1 == 1); //true
  218.             var a = 10;
  220.             //console.log(a == 4); //false
  222.             //console.log("1" == 1); //true
  224.             //console.log(true == "1"); //true
  226.             //console.log(null == 0); //false
  228.             /* * undefined 衍生自 null * 所以这两个值做相等判断时，会返回true */
  229.             //console.log(undefined == null);
  231.             /* * NaN不和任何值相等，包括他本身 */
  232.             //console.log(NaN == NaN); //false
  234.             var b = NaN;
  236.             //判断b的值是否是NaN
  237.             //console.log(b == NaN);
  238.             /* * 可以通过isNaN()函数来判断一个值是否是NaN * 如果该值是NaN则返回true，否则返回false */
  239.             //console.log(isNaN(b));
  241.             //console.log(10 != 5); //true
  242.             //console.log(10 != 10); //false
  243.             //console.log("abcd" != "abcd"); //false
  244.             //console.log("1" != 1);//false
  246.             //console.log("123" === 123);//false
  247.             //console.log(null === undefined);//false
  249.             console.log(1 !== "1"); //true
  252.         </script>
  253.     </head>
  254.     <body>
  255.     </body>
  256. </html>
  262. <!DOCTYPE html>
  263. <html>
  264.     <head>
  265.         <meta charset="UTF-8">
  266.         <title></title>
  267.         <script type="text/javascript">
  268.             /* * 条件运算符也叫三元运算符 * 语法： * 条件表达式?语句1:语句2; * - 执行的流程： * 条件运算符在执行时，首先对条件表达式进行求值， * 如果该值为true，则执行语句1，并返回执行结果 * 如果该值为false，则执行语句2，并返回执行结果 * 如果条件的表达式的求值结果是一个非布尔值， * 会将其转换为布尔值然后在运算 */
  270.             //false?alert("语句1"):alert("语句2");
  272.             var a = 300;
  273.             var b = 143;
  274.             var c = 50;
  276.             //a > b ? alert("a大"):alert("b大");
  278.             //获取a和b中的最大值
  279.             //var max = a > b ? a : b;
  280.             //获取a b c 中的大值
  281.             //max = max > c ? max : c;
  283.             //这种写法不推荐使用，不方便阅读
  284.             var max = a > b ? (a > c ? a :c) : (b > c ? b : c);
  286.             //console.log("max = "+max);
  288.             //"hello"?alert("语句1"):alert("语句2");
  291.         </script>
  292.     </head>
  293.     <body>
  294.     </body>
  295. </html>
  300. <!DOCTYPE html>
  301. <html>
  302.     <head>
  303.         <meta charset="UTF-8">
  304.         <title></title>
  305.         <script type="text/javascript">
  307.             /* * , 运算符 * 使用,可以分割多个语句，一般可以在声明多个变量时使用, */
  308.             //使用,运算符同时声明多个变量
  309.             //var a , b , c;
  311.             //可以同时声明多个变量并赋值
  312.             //var a=1 , b=2 , c=3;
  313.             //alert(b);
  315.             /* * 就和数学中一样，在JS中运算符也有优先级， * 比如：先乘除 后加减 * 在JS中有一个运算符优先级的表， * 在表中越靠上优先级越高，优先级越高越优先计算， * 如果优先级一样，则从左往右计算。 * 但是这个表我们并不需要记忆，如果遇到优先级不清楚 * 可以使用()来改变优先级 */
  317.             //var result = 1 + 2 * 3;
  319.             /* * 如果||的优先级高，或者两个一样高，则应该返回3 * 如果与的优先级高，则应该返回1 * */
  320.             var result = 1 || 2 && 3;
  322.             console.log("result = "+result);    
  324.         </script>
  325.     </head>
  326.     <body>
  327.     </body>
  328. </html>
  333. <!DOCTYPE html>
  334. <html>
  335.     <head>
  336.         <meta charset="UTF-8">
  337.         <title></title>
  338.         <script type="text/javascript">
  340.             /* * 我们的程序是由一条一条语句构成的 * 语句是按照自上向下的顺序一条一条执行的 * 在JS中可以使用{}来为语句进行分组, * 同一个{}中的语句我们称为是一组语句， * 它们要么都执行，要么都不执行， * 一个{}中的语句我们也称为叫一个代码块 * 在代码块的后边就不用再编写;了 * 但是要注意一个点 * JS中的代码块，只具有分组的的作用，没有其他的用途 * 代码块内容的内容，在外部是完全可见的 所以在es6里面要改进了 有了let */
  341.             { 
  342.                 var a = 10;    
  343.                 alert("hello");
  344.                 console.log("你好");
  345.                 document.write("语句");
  346.             }
  349.             console.log("a = "+a);
  354.         </script>
  355.     </head>
  356.     <body>
  357.     </body>
  358. </html>
  364. <!DOCTYPE html>
  365. <html>
  366.     <head>
  367.         <meta charset="UTF-8">
  368.         <title></title>
  369.         <script type="text/javascript">
  371.             /* * 流程控制语句 * - JS中的程序是从上到下一行一行执行的 * - 通过流程控制语句可以控制程序执行流程， * 使程序可以根据一定的条件来选择执行 * - 语句的分类： * 1.条件判断语句 * 2.条件分支语句 * 3.循环语句 * * * 条件判断语句： * - 使用条件判断语句可以在执行某个语句之前进行判断， * 如果条件成立才会执行语句，条件不成立则语句不执行。 * - if语句 * - 语法一： * if(条件表达式){ * 语句... * } * * if语句在执行时，会先对条件表达式进行求值判断， * 如果条件表达式的值为true，则执行if后的语句， * 如果条件表达式的值为false，则不会执行if后的语句。 * if语句只能控制紧随其后的那个语句, * 如果希望if语句可以控制多条语句， * 可以将这些语句统一放到代码块中 * if语句后的代码块不是必须的，但是在开发中尽量写上代码块，即使if后只有一条语句 * */
  373.             var a = 25; if(a > 10 && a <= 20){ 
  374.                 alert("a大于10，并且 a小于等于20");
  375.             }    
  378.         </script>
  379.     </head>
  380.     <body>
  381.     </body>
  382. </html>
  384. <!DOCTYPE html>
  385. <html>
  386.     <head>
  387.         <meta charset="UTF-8">
  388.         <title></title>
  389.         <script type="text/javascript">
  391.             /* if语句需要注意一下执行的顺序 每个条件之间的关系 正常的应该是 在第一个条件进不去的条件之下进入第二个条件 * if语句 * 语法二: * if(条件表达式){ * 语句... * }else{ * 语句... * } * * if...else...语句 * 当该语句执行时，会先对if后的条件表达式进行求值判断， * 如果该值为true，则执行if后的语句 * 如果该值为false，则执行else后的语句 * * 语法三： * if(条件表达式){ * 语句... * }else if(条件表达式){ * 语句... * }else if(条件表达式){ * 语句... * }else{ * 语句... * } * * if...else if...else * 当该语句执行时，会从上到下依次对条件表达式进行求值判断 * 如果值为true，则执行当前语句。 * 如果值为false，则继续向下判断。 * 如果所有的条件都不满足，则执行最后一个else后的语句 * 该语句中，只会有一个代码块被执行，一旦代码块执行了，则直接结束语句 */
  393.             var age = 50;
  395.             /*if(age >= 60){ alert("你已经退休了~~"); }else{ alert("你还没退休~~~"); }*/
  397.             age = 200;
  399.             /*if(age > 100){ alert("活着挺没意思的~~"); }else if(age > 80){ alert("你也老大不小的了~~"); }else if(age > 60){ alert("你也退休了~~"); }else if(age > 30){ alert("你已经中年了~~"); }else if(age > 17){ alert("你已经成年了"); }else{ alert("你还是个小孩子~~"); }*/
  401.             age = 90; if(age > 17 && age <= 30){ 
  402.                 alert("你已经成年了");
  403.             }else if(age > 30 && age <= 60){ 
  404.                 alert("你已经中年了");
  405.             }else if(age > 60 && age <= 80){ 
  406.                 alert("你已经退休了");
  407.             }else{ 
  408.                 alert("你岁数挺大的了~~");
  409.             }
  412.         </script>
  413.     </head>
  414.     <body>
  415.     </body>
  416. </html>

关于if的练习

  1. <!DOCTYPE html>
  2. <html>
  3.     <head>
  4.         <meta charset="utf-8" />
  5.         <title>if练习1</title>
  6.         <script type="text/javascript">
  7.             /* * 从键盘输入小明的期末成绩: * 当成绩为100时，'奖励一辆BMW' * 当成绩为[80-99]时，'奖励一台iphone15s' * 当成绩为[60-80]时，'奖励一本参考书' * 其他时，什么奖励也没有 */
  9.             /* * prompt()可以弹出一个提示框，该提示框中会带有一个文本框， * 用户可以在文本框中输入一段内容，该函数需要一个字符串作为参数， * 该字符串将会作为提示框的提示文字 * * 用户输入的内容将会作为函数的返回值返回，可以定义一个变量来接收该内容 */
  10.             //score就是小明的期末成绩
  11.             var score = prompt("请输入小明的期末成绩(0-100):"); //判断值是否合法 if(score > 100 || score < 0 || isNaN(score)){ 
  12.                 alert("拉出去毙了~~~");
  13.             }else{ 
  14.                 //根据score的值来决定给小明什么奖励 if(score == 100){ 
  15.                     //奖励一台宝马
  16.                     alert("宝马，拿去~~~");
  17.                 }else if(score >= 80){ 
  18.                     //奖励一个手机
  19.                     alert("手机，拿去玩~~~");
  20.                 }else if(score >= 60){ 
  21.                     //奖励一本参考书
  22.                     alert("参考书，拿去看~~~");
  23.                 }else{ 
  24.                     alert("棍子一根~~");
  25.                 }
  26.             }
  33.         </script>
  34.     </head>
  35.     <body>
  37.     </body>
  38. </html>
  43. <!DOCTYPE html>
  44. <html>
  45.     <head>
  46.         <meta charset="utf-8" />
  47.         <title>if练习2</title>
  48.         <script type="text/javascript">
  49.             /* * 大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件： * 高：180cm以上; 富:1000万以上; 帅:500以上; * 如果这三个条件同时满足，则:'我一定要嫁给他' * 如果三个条件有为真的情况，则:'嫁吧，比上不足，比下有余。' * 如果三个条件都不满足，则:'不嫁！' */
  51.             var height = prompt("请输入你的身高(CM):");
  52.             var money = prompt("请输入你的财富(万):");
  53.             var face = prompt("请输入你的颜值(PX):"); //如果这三个条件同时满足，则:'我一定要嫁给他' if(height > 180 && money > 1000 && face > 500){ 
  54.                 alert("我一定要嫁给他~~");
  55.             }else if(height > 180 || money > 1000 || face > 500){ 
  56.                 //如果三个条件有为真的情况，则:'嫁吧，比上不足，比下有余。' 
  57.                 alert("嫁吧，比上不足，比下有余。");
  58.             }else{ 
  59.                 //如果三个条件都不满足，则:'不嫁！' 
  60.                 alert("不嫁。");
  61.             }
  65.         </script>
  66.     </head>
  67.     <body>
  69.     </body>
  70. </html>
  78. <!DOCTYPE html>
  79. <html>
  80.     <head>
  81.         <meta charset="utf-8" />
  82.         <title>if练习3</title>
  83.         <script type="text/javascript">
  84.             /* * 编写程序，由键盘输入三个整数分别存入变量num1、num2、num3， * 对他们进行排序，并且从小到大输出。 */
  86.             //获取用户输入的三个数
  87.             /* * prompt()函数的返回值是String类型的 */
  88.             var num1 = +prompt("请输入第一个数:");
  89.             var num2 = +prompt("请输入第二个数:");
  90.             var num3 = +prompt("请输入第三个数:"); //找到三个数中最小的数 if(num1 < num2 && num1 < num3){ 
  91.                 //num1最小，比较num2和num3 if(num2 < num3){ 
  92.                     //num1 num2 num3
  93.                     alert(num1 +","+num2 + ","+num3);
  94.                 }else{ 
  95.                     //num1 num3 num2
  96.                     alert(num1 +","+num3 + ","+num2);
  97.                 }
  99.             }else if(num2 < num1 && num2 < num3){ 
  100.                 //num2最小，比较num1和num3 if(num1 < num3){ 
  101.                     //num2 num1 num3
  102.                     alert(num2 +","+num1 + ","+num3);
  103.                 }else{ 
  104.                     //num2 num3 num1
  105.                     alert(num2 +","+num3 + ","+num1);
  106.                 }
  108.             }else{ 
  109.                 //num3最小,比较num1和num2 if(num1 < num2){ 
  110.                     // num3 num1 num2
  111.                     alert(num3 +","+num1 + ","+num2);
  112.                 }else{ 
  113.                     //num3 num2 num1
  114.                     alert(num3 +","+num2 + ","+num1);
  115.                 }
  117.             }
  120.         </script>
  121.     </head>
  122.     <body>
  124.     </body>
  125. </html>

补充

关于js的位运算

  1. 位运算符是在数字底层（即表示数字的 32 个数位）进行操作的。
  3. 重温整数
  4. ECMAScript 整数有两种类型，即有符号整数（允许用正数和负数）和无符号整数（只允许用正数）。在 ECMAScript 中，所有整数字面量默认都是有符号整数，这意味着什么呢？
  6. 有符号整数使用 31 位表示整数的数值，用第 32 位表示整数的符号，0 表示正数，1 表示负数。数值范围从 -2147483648 到 2147483647。
  8. 可以以两种不同的方式存储二进制形式的有符号整数，一种用于存储正数，一种用于存储负数。正数是以真二进制形式存储的，前 31 位中的每一位都表示 2 的幂，从第 1 位（位 0）开始，表示 20，第 2 位（位 1）表示 21。没用到的位用 0 填充，即忽略不计。例如，下图展示的是数 18 的表示法。
  11. 18 的二进制版本只用了前 5 位，它们是这个数字的有效位。把数字转换成二进制字符串，就能看到有效位：
  13. var iNum = 18;
  14. alert(iNum.toString(2));    //输出 "10010"
  15. 这段代码只输出 "10010"，而不是 18 的 32 位表示。其他的数位并不重要，因为仅使用前 5 位即可确定这个十进制数值。如下图所示：
  18. 负数也存储为二进制代码，不过采用的形式是二进制补码。计算数字二进制补码的步骤有三步：
  20. 确定该数字的非负版本的二进制表示（例如，要计算 -18的二进制补码，首先要确定 18 的二进制表示）
  21. 求得二进制反码，即要把 0 替换为 1，把 1 替换为 0
  22. 在二进制反码上加 1
  23. 要确定 -18 的二进制表示，首先必须得到 18 的二进制表示，如下所示：
  25. 0000 0000 0000 0000 0000 0000 0001 0010
  26. 接下来，计算二进制反码，如下所示：
  28. 1111 1111 1111 1111 1111 1111 1110 1101
  29. 最后，在二进制反码上加 1，如下所示：
  31. 1111 1111 1111 1111 1111 1111 1110 1101
  32.                                       1
  33. ---------------------------------------
  34. 1111 1111 1111 1111 1111 1111 1110 1110
  35. 因此，-18 的二进制表示即 1111 1111 1111 1111 1111 1111 1110 1110。记住，在处理有符号整数时，开发者不能访问 31 位。
  37. 有趣的是，把负整数转换成二进制字符串后，ECMAScript 并不以二进制补码的形式显示，而是用数字绝对值的标准二进制代码前面加负号的形式输出。例如：
  39. var iNum = -18;
  40. alert(iNum.toString(2));    //输出 "-10010"
  41. 这段代码输出的是 "-10010"，而非二进制补码，这是为避免访问位 31。为了简便，ECMAScript 用一种简单的方式处理整数，使得开发者不必关心它们的用法。
  43. 另一方面，无符号整数把最后一位作为另一个数位处理。在这种模式中，第 32 位不表示数字的符号，而是值 231。由于这个额外的位，无符号整数的数值范围为 0 到 4294967295。对于小于 2147483647 的整数来说，无符号整数看来与有符号整数一样，而大于 2147483647 的整数则要使用位 31（在有符号整数中，这一位总是 0）。
  45. 把无符号整数转换成字符串后，只返回它们的有效位。
  47. 注意：所有整数字面量都默认存储为有符号整数。只有 ECMAScript 的位运算符才能创建无符号整数。
  49. 位运算 NOT
  50. 位运算 NOT 由否定号（~）表示，它是 ECMAScript 中为数不多的与二进制算术有关的运算符之一。
  52. 位运算 NOT 是三步的处理过程：
  54. 把运算数转换成 32 位数字
  55. 把二进制数转换成它的二进制反码
  56. 把二进制数转换成浮点数
  57. 例如：
  59. var iNum1 = 25;        //25 等于 00000000000000000000000000011001
  60. var iNum2 = ~iNum1;
  61.     //转换为 11111111111111111111111111100110
  62. alert(iNum2);        //输出 "-26"
  63. 位运算 NOT 实质上是对数字求负，然后减 1，因此 25 变 -26。用下面的方法也可以得到同样的方法：
  65. var iNum1 = 25;
  66. var iNum2 = -iNum1 -1;
  67. alert(iNum2);    //输出 -26
  68. 位运算 AND
  69. 位运算 AND 由和号（&）表示，直接对数字的二进制形式进行运算。它把每个数字中的数位对齐，然后用下面的规则对同一位置上的两个数位进行 AND 运算：
  71. 第一个数字中的数位    第二个数字中的数位    结果
  72. 1    1    1
  73. 1    0    0
  74. 0    1    0
  75. 0    0    0
  76. 例如，要对数字 25 和 3 进行 AND 运算，代码如下所示：
  78. var iResult = 25 & 3;
  79. alert(iResult);    //输出 "1"
  80. 25 和 3 进行 AND 运算的结果是 1。为什么？分析如下：
  82.  25 = 0000 0000 0000 0000 0000 0000 0001 1001
  83.   3 = 0000 0000 0000 0000 0000 0000 0000 0011
  84. ---------------------------------------------
  85. AND = 0000 0000 0000 0000 0000 0000 0000 0001
  86. 可以看出，在 25 和 3 中，只有一个数位（位 0）存放的都是 1，因此，其他数位生成的都是 0，所以结果为 1。
  88. 位运算 OR
  89. 位运算 OR 由符号（|）表示，也是直接对数字的二进制形式进行运算。在计算每位时，OR 运算符采用下列规则：
  91. 第一个数字中的数位    第二个数字中的数位    结果
  92. 1    1    1
  93. 1    0    1
  94. 0    1    1
  95. 0    0    0
  96. 仍然使用 AND 运算符所用的例子，对 25 和 3 进行 OR 运算，代码如下：
  98. var iResult = 25 | 3;
  99. alert(iResult);    //输出 "27"
  100. 25 和 3 进行 OR 运算的结果是 27：
  102. 25 = 0000 0000 0000 0000 0000 0000 0001 1001
  103.  3 = 0000 0000 0000 0000 0000 0000 0000 0011
  104. --------------------------------------------
  105. OR = 0000 0000 0000 0000 0000 0000 0001 1011
  106. 可以看出，在两个数字中，共有 4 个数位存放的是 1，这些数位被传递给结果。二进制代码 11011 等于 27。
  108. 位运算 XOR
  109. 位运算 XOR 由符号（^）表示，当然，也是直接对二进制形式进行运算。XOR 不同于 OR，当只有一个数位存放的是 1 时，它才返回 1。真值表如下：
  111. 第一个数字中的数位    第二个数字中的数位    结果
  112. 1    1    0
  113. 1    0    1
  114. 0    1    1
  115. 0    0    0
  116. 对 25 和 3 进行 XOR 运算，代码如下：
  118. var iResult = 25 ^ 3;
  119. alert(iResult);    //输出 "26"
  120. 25 和 3 进行 XOR 运算的结果是 26：
  122.  25 = 0000 0000 0000 0000 0000 0000 0001 1001
  123.   3 = 0000 0000 0000 0000 0000 0000 0000 0011
  124. ---------------------------------------------
  125. XOR = 0000 0000 0000 0000 0000 0000 0001 1010
  126. 可以看出，在两个数字中，共有 4 个数位存放的是 1，这些数位被传递给结果。二进制代码 11010 等于 26。
  128. 左移运算
  129. 左移运算由两个小于号表示（<<）。它把数字中的所有数位向左移动指定的数量。例如，把数字 2（等于二进制中的 10）左移 5 位，结果为 64（等于二进制中的 1000000）：
  131. var iOld = 2;        //等于二进制 10
  132. var iNew = iOld << 5;    //等于二进制 1000000 十进制 64
  133. 注意：在左移数位时，数字右边多出 5 个空位。左移运算用 0 填充这些空位，使结果成为完整的 32 位数字。
  136. 注意：左移运算保留数字的符号位。例如，如果把 -2 左移 5 位，得到的是 -64，而不是 64。“符号仍然存储在第 32 位中吗？”是的，不过这在 ECMAScript 后台进行，开发者不能直接访问第 32 个数位。即使输出二进制字符串形式的负数，显示的也是负号形式（例如，-2 将显示 -10。）
  138. 有符号右移运算
  139. 有符号右移运算符由两个大于号表示（>>）。它把 32 位数字中的所有数位整体右移，同时保留该数的符号（正号或负号）。有符号右移运算符恰好与左移运算相反。例如，把 64 右移 5 位，将变为 2：
  141. var iOld = 64;        //等于二进制 1000000
  142. var iNew = iOld >> 5;    //等于二进制 10 十进制 2
  143. 同样，移动数位后会造成空位。这次，空位位于数字的左侧，但位于符号位之后。ECMAScript 用符号位的值填充这些空位，创建完整的数字，如下图所示：
  146. 无符号右移运算
  147. 无符号右移运算符由三个大于号（>>>）表示，它将无符号 32 位数的所有数位整体右移。对于正数，无符号右移运算的结果与有符号右移运算一样。
  149. 用有符号右移运算中的例子，把 64 右移 5 位，将变为 2：
  151. var iOld = 64;        //等于二进制 1000000
  152. var iNew = iOld >>> 5;    //等于二进制 10 十进制 2
  153. 对于负数，情况就不同了。
  155. 无符号右移运算用 0 填充所有空位。对于正数，这与有符号右移运算的操作一样，而负数则被作为正数来处理。
  157. 由于无符号右移运算的结果是一个 32 位的正数，所以负数的无符号右移运算得到的总是一个非常大的数字。例如，如果把 -64 右移 5 位，将得到 134217726。如何得到这种结果的呢？
  159. 要实现这一点，需要把这个数字转换成无符号的等价形式（尽管该数字本身还是有符号的），可以通过以下代码获得这种形式：
  161. var iUnsigned64 = -64 >>> 0;
  162. 然后，用 Number 类型的 toString() 获取它的真正的位表示，采用的基为 2：
  164. alert(iUnsigned64.toString(2));
  165. 这将生成 11111111111111111111111111000000，即有符号整数 -64 的二进制补码表示，不过它等于无符号整数 4294967232。
  167. 出于这种原因，使用无符号右移运算符要小心。
  168. ————————————————
  169. 版权声明：本文为CSDN博主「csdn--------------」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
  170. 原文链接：https://blog.csdn.net/bianyali/article/details/20945455

发表评论

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

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

相关阅读