码迷,mamicode.com
首页 > Web开发 > 详细

JS(1)

时间:2018-10-17 22:19:07      阅读:389      评论:0      收藏:0      [点我收藏+]

标签:解释执行   次方   mod   警告   object   自定义对象   引号   标识   code   

1、Javascript 概述
   1、简称JS,是一种浏览器解释型语言(是一种运行于JS解释器或执行引擎中的脚本代码),代码嵌套在HTML页面中,交由浏览器解释执行
      作用:主要用来实现页面的动态效果,实现用户交互,实现网页中的网络请求
   2、JS 组成:
      1、ECMAScript:包含JS的核心语法(规范了JS的基本语法)
      2、内置对象:BOM DOM 其他内置对象
       BOM :Browser Object Model 浏览器对象模型,主要提供一组操作浏览器的方法
       DOM :Document Object Model 文档对象模型,提供一组操作文档的方法
      3、JS 自定义对象
 
2、JS引入(使用方式)
   1、元素绑定
     给具体的元素绑定JS的事件,将JS代码以事的形式绑定在元素上
     事件:由用户行为触发的操作,(鼠标操作,键盘操作)
     语法:
       <标签 事件函数名="JS代码">
       et:
     onclick : 单击事件
     alert(‘‘); : 网页弹框显示提示信息
     <h1 onclick="alert(‘弹窗显示文本‘);">点击</h1>
   2、文档内嵌
     使用<script></script>标签,在文档中嵌入JS代码
     特点:网页加载到标签时就会执行内部的JS代码
     注意:脚本标签可以书写在任意位置,出现任意多次,但是位置会影响执行效果  
      et:
         <script>
        alert (‘文档内嵌‘);
         </script>   
   3、外部JS文件
     1、创建外部.js文件,在文件中书写JS代码
     2、使用<script src="JS路径"></script>标签引入外部的JS文件,
        如果脚本标签用来做引入外部文件操作时,那么标签中不能再书写JS代码
     3、注意:           
         src 引入的外部资源是网页加载所必须的一部分,网页在加载src文件时,会等待文件加载完毕再执行后面的代码
     href 网页在加载href文件时,不会等待加载完毕,边加载边向后执行               
   4、常用JS语句
     1、alert("警告消息框");
       以警告框的形式提示信息
     2、prompt();
       接收用户输入的弹框,输入结果会以函数返回值的形式给出
     3、console.log("在控制台输出一句话");
       在控制台输出,常用于调试
     4、document.write("<h1>Hello</h1>");   在网页中输出
       注意 :
     1. document.write()方法会根据当前的书写位置在网页中插入内容
     2. 如果以元素绑定事件的方式在网页中写入内容,onclick="document.write();",会清空当前页,只显示写入的内容。
     3. 使用document.write()方法写入内容,可以识别HTML标签

3、JS 基础语法
   1、JS代码是由语句组成的,每一条语句以分号结尾;
       语句是由关键字,运算符,表达式组成的;
   2、JS代码严格区分大小写
      et:
       console.log();  正确
       Console.log();  错误
   3、所有的标点符号,都是英文的
   4、JS中的注释
     1、单行注释: //
     2、多行注释: /* 注释内容 */

4、JS中的变量与常量
   1、变量
     1、创建变量
        1、先声明,后赋值,使用关键字 var 进行变量的声明
       声明 :var 变量名;
       赋值 :变量名 = 值;
       使用=进行变量的赋值
       自定义变量名
       et:
         var a;
         a = 10;
         var b,c,d;
         b = 100;
        2、声明的同时赋值
       var 变量名 = 值;
        et:
         var age = 20;
             var uname="zhangsan",height=180;
     2、命名规范
       1、自定义的变量名可以由数字,字母,下划线和$组成,禁止以数字开头
       2、避免与JS中的关键字,保留字冲突(name var new for if do while function class break switch... )
       3、命名尽量有意义一些,做到见名知意
       4、变量名称严格区分大小写
       5、多个单词组成的变量名,采用小驼峰标识
        et:
     goodsCount
     goodsPrice
     userName
     3、使用注意:
         1、变量声明可以省略关键字var,直接使用变量名赋值,不推荐省略关键字,涉及到变量作用域。容易出问题
         2、变量如果只声明,未赋值,变量默认值为undefined
         3、赋值符号表示将右边的值赋给左边变量,要求左边必须是变量。
       et:
        var a = 10;
        a = 10 + 10;
   2、常量
     变量可以在程序任何地方修改
     常量一经定义就不能更改
     1. 创建
     使用 const 关键字创建常量,声明的同时必须赋值
     2. 语法规范
        为了区分变量与常量,一般变量名采用小写或驼峰标识,常量采用全大写的形式(常量在声明的同时必须赋值)
        语法:const 常量名 = 值;
       et:
        const PI = 3.14;
        练习 :
     1. 定义常量PI,3.14
     2. 定义变量 r ,表示半径
     3. 计算圆的周长与面积并进行输出
     3. 小数位的操作                   
       1、小数位在计算机的存储中是不精确的,存在误差
       2、指定保留小数位
         1、方法:toFixed(n);  n 表示要保留的位数
     2、使用:
          var num = 1.23456;
          var res = num.toFixed(2); //返回最终的结果

5、JS 中的数据类型
   1、简单数据类型(基础)
     1、number 类型
        数值类型,包含整数和小数
        整数在内存中占4个字节(32位),小数(浮点数)占8个字节(64)位   
       1、整数
         可以使用十进制,八进制,十六进制表示整数
     常用的:十进制表示方法
     八进制:以0开头,8为基数,取值0-7,逢8进1
         et:
           0 * 8(0) + 1 * 8(1) = 8
         var num = 010;
             var num2 = 011;
            八进制转十进制,逢8进1
        十进制转八进制,需要首先将十进制转为二进制,从右向左,每三位为一组,转换数值,就是八进制
     十六进制 :以0x为前缀,取值0-9,a-f
         et:
           var c = 0x25;  //37
        十六进制转十进制,参考八进制
        十进制转十六进制,先将十进制转换二进制,从右向左,每四位为一组,不足为补0,计算数值
           1111 -> 15 -> f               
         注意:
        不管是哪一种进制表示的整数,在使用控制台输出时,都会转换为10进制输出显示
       2、小数(浮点数)
         1、使用小数点,给出小数位
        var a = 3.14;
         2、使用科学计数法
        var b = 1.5e3;
        e 表示以 10 为底
        e 后面的数值,表示 10 的次方数
       计算方式:1.5e3 = 1.5 * 10(3)                               
     2、string 类型
       1、JS中字符串使用引号引起来,单双引号都可以
     et:
       var a = 10;
       var b = ‘10‘;
       2、字符串中每个字符都有对应的Unicode码值
     1、查看字符的Unicode码
           var s1 = ‘张‘;
       方法 :charCodeAt(index)
        字符串中每个字符都对应有一个下标,从0开始,这个方法根据给定下标获取该字符的Unicode码
           var s = "hello";
           s.charCodeAt(2);
     2、Unicode码
       Unicode码值中前128位与ASC码对应一致
       中文字符的范围:"\u4e00" - "\u9fa5" (十六进制表示)
     3、将汉字的Unicode码转换为汉字字符
        1. Unicode码转换为十六进制
             toString(16):将十进制数字转换为十六进制,返回字符串
         et:
               var s = "张";
           var r = s.charCodeAt(0);
           r = r.toString(16);
        2. 在十六进制字符串前添加\u转义,转换为汉字
             "5f20"添加\u转义
         var s = "\u5f20";
         注意:
            不能写 var s = "\u"+"5f20";  语法错误
     4、转义字符
        \n 换行
        \t 制表符
        \\ 表示 \
        \" 表示 "
        \‘ 表示 ‘
     3、boolean 布尔类型
        只有真和假 true false,表达式进行关系运算的结果一定是布尔类型
         true,false 可以转换为number数值,是可以参与数学运算的   
         true = 1
         false = 0
         任何非零值都为真
     4、undefined
     1. 变量声明未赋值时,默认为undefined
     2. 访问对象不存在的属性时,也为undefined
     5、null
     空类型,一般用来解除对象的引用
   2、复杂数据类型(引用)
       对象 函数 数组
   3、判断数据类型
      操作符 typeof 或 typeof()
      使用 :
     var n = "asda";
     console.log(typeof n);
     console.log(typeof(n));


6、JS 中的数据类型转换
    相同数据类型的变量进行运算时,保持数据类型一致
    1、自动类型转换(隐式)
     1、number + string
         字符串使用+参与运算,都视为字符串的拼接,不再是数学运算
         转换规则 :将参与运算的非字符串类型,自动转换为string类型,再进行字符串拼接,返回最终字符串
               et:
         var num = 15;
         var str = "18";
         var r1 = num + str;  // "1518"
         var r2 = 15 + 18 + "18"; // "3318"
         var r3 = "18" + 15 + 18; //"181518"
         var r4 = 15 + "18" + 15; //"151815"
     2、boolean + string
         涉及字符串的+操作,都为字符串拼接
         true + "10"  // true10
          var n = true;
          var r = n + "你好"; // "true你好"
     3、number + boolean
         将布尔值转换为number类型,再进行相加运算
         true = 1;
         false = 0;
           et:
         var n = true + 15; // 16
         var n1 = false + 20; //20
    2、强制类型转换
     1、字符串转换number类型
         1. Number(value)
         可以将非数字类型转换为number
         1. 数字字符串 "100" 可以使用该方法转换类型
         2. 包含非数字的字符串 ‘100a‘,转换结果为NaN(not a number),表示转换失败
         3. 布尔类型转换number,对应 1和0
              et:
             var r = Number("35.5"); //35.5
             var r2 = Number(true); // 1
             var r3 = Number("18a"); //NaN
         2、从字符串中解析数字
         1、parseInt(str)
             1. 用来解析字符串中的整数,参数如果不是字符串,会自动先使用toString()转换为字符串再进行解析
                 2. 只对字符串开头部分进行解析,如果首个字符不是数字,直接返回NaN
             3. 参数为数字可以用作取整
               et:
             var r = parseInt("18.2a"); //18
             var r2 = parseInt("a18");  //NaN
             var r3 = parseInt(35.5);   //35
         2、parseFloat(str)
             作用:用来解析字符串中的整数和小数部分,作用等同于parseInt()
              et:
             var r = parseFloat("35.5"); //35.5
             注意 :如果字符串中出现指数计数法表示的小数
                 "1.5e3",都视为是小数
         2、将非字符串类型转换为string类型
         作用:将任意非字符串类型的数据转换为字符串类型,并返回转换后的结果
         方法:toString();
         使用:
            var a = 100;
            var r = a.toString();
            console.log(typeof n,typeof r);
        
7、运算符
   1、赋值运算符
     =
      将右边的值赋给左边变量
   2、算术运算符
      + - * / %
      ++ -- 自增和自减运算
      1、+ - * / %     -》 加 减 乘 除 取余
     1. 字符串 “+”,表示拼接
             var a = 10 + 10;          //20
             var a1 = 10 + "10";       //"1010"
             var a2 = 10 + true;       //11
             var a3 = "10" + false;    //"10fasle"
             var a4 = 10 + undefined;    //NaN
             var a5 = 10 + NaN;          //NaN
             var a6 = 10 + null;         //10
        减法:将数字字符串自动转换为number,再进行数学运算
     2. 数字字符串参与数学运算(- * / %),会自动转换数据类型,转成number后参与运算,非数字字符串,转换number结果都为NaN,参与数学运算结果也为NaN
     3. 布尔类型的数据会自动转换为number 1或0,参与数学运算   
      2、++  --
     1. 自增运算符,自减运算符,表示在自身基础上进行+1或-1的操作
     2. 只有变量能使用++ --,常量不能自增或自减
     3. 单独使用++ / --与变量结合,做前缀或后缀没有区别,都是对变量进行+1 或 -1操作
          et1:
         var a = 10;
         ++a;
         a++;
          et2:
         var n = 5;
         n ++; // n = n + 1;
         console.log(n); // 6
         ++ n;
         console.log(n); // 7
     4. 如果与其他运算符结合,前缀和后缀会影响结果
          et1:
         var num = 5;
         var res = num ++;
         console.log(num,res); // 6 5
         -----------------------
         如果是 var res = num ++;
             1. 先找变量
             2. 从变量位置从右向左结合运算符
         --------------------------
         var num = 5;
         var res = ++ num;
         console.log(num,res); // 6 6
          et2:
         与赋值符号结合
         var a = 10;
         var r = a++; //做前缀,先赋值,后自增
         var r1 = ++a;//做后缀,先自增,后赋值
         练习 :
             var n = 5;
         var res = n++ + ++n + n++ + ++n + n;
           解:
         var r = n++;  //r = 5, n = 6
         var r1 = ++n; //r1 = 7, n = 7
         var r2 = n++; //r2 = 7, n = 8
         var r3 = ++n; //r3 = 9, n = 9
         var r4 = n;   //r4 = 9
   3、关系运算符(比较运算符)
         >        大于
     >=     大于等于
     <     小于
     <=     小于等于
     ==     相等
     !=     不等
     ===     恒等
     !==      不恒等
        注意 :关系运算的结果为布尔类型
      1、数字与数字之间的比较
     et:
           var r = 10 > 5; //true
      2、字符串之间的比较
     1. string 与 number 之间进行关系运算:
         自动将string转换为number,再进行比较;
         如果string无法转换为number,则进行NaN与number的比较,结果永远为false
              et :
             "10" > 5; // true
             "10a" > 5; //false
             "你好" > 5; //fasle
     2. string 与 string 之间进行关系运算
         进行每一位字符Unicode码值得比较,从前往后,
         如果第一位字符可以比较出结果,就直接获取结果,
         如果无法出结果,依次进行后一位字符的比较
              et :
             "10" > "5"; // false
             "ab" > "ac"; //false
             "张三丰" > "张无忌"; //false
      3. 判断相等于恒等
         ==  判断相等,只进行值得比较,包含数据类型转换
              et:
             "10" == 10; //true
         === 判断恒等,不允许数据类型转换,比较类型与值
              et:
             "10" === 10; //false
             "10" === "10" //true
         判断相等时,会发生自动类型转换,最终结果相等,即为 true
         判断恒等,要求操作数数据类型一致,值相等,才返回true
      4. 判断不等和不恒等
         != 判断不等,两个操作数的值不相等时返回true
         !== 判断不恒等,两个操作数类型与值之间只要有一项不同,都返回true
              et:
             "10" != 10; //false
             "10" != "10"; //false
             "10" !== 10; //true
             "10" !== "10"; //false
   4、逻辑运算符
     逻辑与 :&&
     逻辑或 :||
     逻辑非 :!
     逻辑运算与关系运算的结果都为布尔类型
     1. 逻辑与
         两个表达式同时为真,逻辑与运算的结果才为真。
                         条件1    条件2   结果
                       true            true    true
                       false            true    false
                         true            false   false
                 &&  false            false   false
     2. 逻辑或
         两个条件,只要有一个为真,逻辑或的结果就为真
     3. 逻辑非
         非真即假 。对表达式的结果进行取非操作
         1
         "1"
                
3. 逻辑运算
         进行多项比较,并将结果组合为单一的布尔值
     && :逻辑与 等同于 python and,左右为表达式,只有两个表达式的结果都为真,逻辑与的结果才为真
     || :逻辑或 等同于 python or ,只要有一个条件为真,结果就为真
     ! :逻辑非 等同于 python not ,对现有条件的结果进行取反操作

        1. 条件1 && 条件2
             条件1        条件2        结果
                 ---------------------------------------
         取值    true         true            true
             true         false           false
             false         true         false
             false         false         false
                 ---------------------------------------
         2. 条件1 || 条件2

            条件1        条件2        结果
                     ---------------------------------------
          取值    true         true            true
             true         false           true
             false         true         true
             false         false         false
                 ---------------------------------------
         3. !条件
             直接取反
             非真即假,非假即真


练习 :
  1. 用户输入年份 prompt()
     var year = prompt(); //字符串
  2. 判断是否为闰年
     不能被100整除,但是可以被4整除
     可以被400整除
     除法 使用 / 表示 使用取模 % (取余)
     Number(year);
     逻辑或 ||
     逻辑与 &&
     if(条件表达式){
         //条件成立时执行
     }

JS(1)

标签:解释执行   次方   mod   警告   object   自定义对象   引号   标识   code   

原文地址:https://www.cnblogs.com/py321/p/9807191.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!