JavaScript语言基础实战教程#Web前端起步技术

收藏

3424人加入学习
价格
限期免费
教学计划
学习有效期
2020-03-29至2023-12-30
课程介绍

本教程是JavaScript基础部分, 内容包括JS语言的所有内容,从js语法, 语句, 变量、运算符、表达式, 流程控制,函数、对象、JSON、数组, 以及JavaScript的内置对象, 字符串对象操作、正则表达式, 数字对象,数学方法, 日期和时间的操作 并结合ES6的新特性,每一章节都结合的大量的实例进行讲解, 本部分是学习前端开发的基础, 所有内容都要求很好的掌握。

第一关:JavaScript语法 本关是学习JavaScript的开始, 介绍了JavaScript的语言特性和版本,以及发展过程, 重点介绍了JS语法,JS语句, 以及变量的声明和数据类型,以及数据类型之间的转换过程,涉及到ES6新的技术点也进行了详细介绍。

第二关:JavaScript的运算符和流程控制 本关主要学习了JavaScript的各种相关的运算符号和流程控制的分支结构,以及相关的ES6的语法部分, 并通过实例演示进行了全面的讲解。

第三关:JavaScript的流程控制和函数 本关详细讲解了循环结构, 并重点讲解函数,包括函数的声明,函数的使用,以及函数参数的变化,还有回调函数,匿名函数,以及ES6中的箭头函数,和常用的闭包函数的应用,并通过实例一个个演示说明。

第四关:JavaScript对象编程 本关是Java面向对象部分, 是JavaScript的核心内容, 主要讲解了JavaScript的对象声明和应用,以及对象的继承,和ES6的类的声明和继承,以有对象的遍历。同时也介绍了JSOn的应用和声明语法格式。

第五关:JavaScript数组和异常处理 本关重点介绍了数组的应用, 包括数组和对象的区别应用, 通过对象模拟数组, 数组的声明,以及数组中常用的操作方法,也介绍了一些和数组相关的算法,像排序算法等,也讲解了数组的迭代方式。本关也介绍了异常的处理机制,包括声明异常和处理异常。

第六关:JavaScript字符串操作和正则表达式 本关是JS字符串的操作, 包括字符串的声明和应用, 并使用字符串中的处理函数处理字符串, 同时重点讲解了正则表达式, 包括正则表达式的声明, 正则表达式方法的应用,以及正则表达式的编写思路,并通过实例演示每个知识点的详细应用。

第七关:JavaScript内置对象的应用 本关讲解了数字对象声明和方法的应用, 以及数学对象中方法的应用和随机数的使用, 并重点讲解了日期和时间的应用, 同时也介绍了JavaScript中的事件添加方式,并通过实例详细对每个应用进行了功能的操作。

      JavaScript语法笔记

      //变量就是一个容器;
      //如果要使用数据就一定先声明变量,将值放在变量中,再用这个变量
      //变量名 要有意义numberOne numberTwo
      //变量数值 使用=号,将右边的值,给左边的变量

      正则表达式笔记

      1.正则表达式声明

      //声明正则表达式的方法
      //一定要使用一些函数(字符串处理函数和正则特定的一些函数)
      //1./原子和元字符/模式修正符号(i,g,m) 直接使用的方式
      //i 大小写不敏感 g 全局 m 多行匹配

      //2.new RegExp('模式(原子和元字符)','m'); 字符串的方式 可以拼接变量
      
      var pat1 = /Imonkey/ig;
      var pat2 = new RegExp('Imonkey','igm');
      
      var text = "this is Imonkey,this is Imonkey,\n this is Imonkey,this is Imonkey"
      console.log(text);
      var ntext = text.replace(pat1,'eduwork');
      console.log(ntext);
      

      2.正则表达式的操作函数

      var text = "this is Imonkey,this is Imonkey,this is Imonkey,this is Imonkey"
      //test(): 匹配,返回bool 有匹配 返回true 否则返回false
      //exec():没有匹配成功返回null
      //匹配成功,返回数组
      //数组第一个元素是匹配到的字符串,第二个元素index 位置 第三个元素是原字符串;
      //test()和exec() 是正则对象方法
      //**
      /console.log(pat1.exec(text));
      console.log(text.search(pat1)); //搜索与正则表达式相匹配的值 返回位置
      //console.log(text.match(pat1)); //返回数组 匹配不上 返回空null
      console.log(text.match('Imonkey')); //返回结果同exec一样
      /
      console.log(text.split(',')); //返回数组
      console.log(text.split(pat1)); //用字符串分隔,分隔的字符串消失
      //search(查找), match(匹配),replace(替换) ,split(分隔)是string对象方法
      if (pat1.test(text)){
      console.log("成功");
      } else{
      console.log("失败");
      }
      //表单验证

      3.正则表达式的语法
      A.方括号

      //A.方括号
      //var patt1 = /1/ig;
      //[abc] 查找方括号之间的任意字符
      //var patt1 = /[abcl]monkey/ig;
      //[^abc] 查找任何不在方括号之间的字符
      var patt1 = /[^abcl]monkey/ig; //==>wmonkey
      var text = "this amonkey is bmonkey a cmonkey lmonkey wmonkey te1st";
      console.log(text.match(patt1)); //==>["amonkey", "bmonkey", "cmonkey", "lmonkey"]
      //[0-9] 0~9 [125-8] 1,2 5-8 分段
      //[1-9] 1,9 - 匹配这三种
      B.元字符

      //. 查找单个字符 除了换行和行结束符
      //var patt1 = /.monkey/ig;
      //var text = "this amonkey is bmonkey a cmonkey lmonkey wmonkey te1st";
      //console.log(text.match(patt1));
      //\w 元字符用于查找单词字符。 单词字符包括:a-z、A-Z、0-9,以及下划线, 包含 _ (下划线) 字符。
      //\W 跟\w 取反的作用
      / var patt1 = /\wmonkey/ig;
      var text = "this amonkey is 1monkey a 2monkey lmonkey wmonkey te1st";
      console.log(text.match(patt1));
      /
      //\d 代表数字 \D 代表非数字
      /var patt1 = /\dmonkey/ig;
      var text = "this amonkey is 1monkey a 2monkey lmonkey wmonkey monkey te1st";
      console.log(text.match(patt1));
      /
      //\s 查找空白字符 \S 非空白字符的都可以
      var patt1 = /\smonkey/ig;
      var text = "this amonkey is 1monkey a 2monkey lmonkey wmonkey monkey te1st";
      console.log(text.match(patt1));
      //\b 单词边界 \B 非边界
      var patt2 = /\bis/ig; //左边有边界 \bis\b 两边有边界
      var text2 = "this is a island";
      console.log(text2.match(patt2));
      C.量词

      //n+ 匹配至少一个原子
      var pat = /Imo+nkey/ig;
      pat = /Imonkey/ig;
      pat = /Imo?nkey/ig;
      pat = /Imo{3}nkey/ig;
      pat = /Imo{1,3}nkey/ig; //(1-3个)
      pat = /Imo{1,}nkey/ig;//(至少一个o)
      pat = /Imonkeyx$/ig; //以Imonkeyx$为结尾
      pat = /^this/ig; //以^this 开头
      var text = "this is a Imnkey Imoonkey Imooonkey Imonkeyx";
      console.log(text.match(pat));
      //n
      匹配0个或多个原子
      //n? 匹配0个或1个原子
      //n{3} 固定数量的原子
      常用正则

      //D.反相引用
      //()作用
      // 将任何小原子(单个)变成大原子
      //在括号中可以使用 | 当做或的关系
      //反向引用 与replace() 搭配使用
      //var pat = /I(mo)+nkey/ig;
      /!var pat = /I(mo|abc|hello)+nkey/ig;
      var text = "this is Imonkey Iabcnkey Ihellonkey";
      console.log(text.match(pat));
      !/
      //var pat = /www/ig;
      */
      var pat = /((www).(baidu).(com))/ig; //整个大括号是$1 之后依次类推
      var url = "http://www.baidu.com";
      //var newu = url.replace(pat,'......');
      //var newu = url.replace(pat,'$1...$2..$3..$4'); //第一个括号里面的内容
      var newu = url.replace(pat,'$3');
      console.log(url);
      document.write(newu);

      //正则的编写方法  需求 迭代 实现  http://   // ==> \/\/
      

      JavaScript字符串操作

      字符串
      1.转义字符
      \n 换行
      \t 制表符
      \b 空格
      \r 回车
      \f 换页符
      \ 反斜杠
      \' 单引号
      \'' 双引号

      注意:\ 可以让声明的字符串换行 ,换行的时候后面不能有任何字符
      2.使用反引号也可以声明字符串(1左面的按键)
      A.在反引号的字符串中,不需要使用\换行;
      模板字符串
      var host = 'www';
      var str = <i>${host}</i>;(斜点${host}斜点)

      3.搜索和截取字符串
      A.字符串的方法

      //以索引下标操作字符串时是只读的。
      var str = "Imonkey";
      console.log(str[0]); ==>I
      console.log(str[1]); ==>m
      console.log(str.indexOf('n',5)); //从左往右查找元素的索引位置,5代表从第5个字符开始找
      console.log(str.lastIndexOf('y')); //从右往左查找元素的索引位置
      //search 方法同indexOf 但是不能用第二个位置蚕食 能使用正则
      console.log(str.search('n'));

      var arr = 'this is a test';
      //截取  支持负值
      var arr1 = arr.slice(5,7);  //包括开始  一直到结束前一位
      var arr2 = arr.slice(-4,-1);  //从后往前
      //不能使用负值,如果是一个参数,从指定位置开始一直到结尾
      var arr3 = arr.substring(5);
      //第一个参数是位置,第二个是截取的长度,如果省略第二个参数,也是到结尾
      var arr4 = arr.substr(5,2);
      console.log(arr);
      console.log(arr1);
      console.log(arr2);
      console.log(arr3);
      console.log(arr4);
      
      var url1 = "http://www.baidu.com?username=xz&pw=123456";
      var url2 = "http://www.taobao.com?page=5&ser=hello";
      var url3 = "http://www.tianmao.com";
      

      function getdata(url) {
      var loc = url.indexOf('?');//找到问号 字符
      if(loc == -1){
      return "nofind";
      }else{
      loc= loc+1; //问号后面第一个字符的位置
      return url.substring(loc);
      }
      }
      console.log(getdata(url1));
      console.log(getdata(url2));
      console.log(getdata(url3));


      //replace() 替换
      //不会改变原字符串,返回一个新字符串
      //1.只替换首个匹配到的字符串
      //2.对大小写敏感
      var str1 = "this is a www.baidu.com";
      var str2 = str1.replace('com','cn');
      var str3 = str1.toUpperCase(); //全大写
      var str4 = str1.toLowerCase(); //全小写
      console.log(str1);
      console.log(str2);
      console.log(str3);

      var str5 = "  www.taobao.com  ";
      var str6 = str5.trim(); //删除两边的空格
      var str6 = str5.trimLeft();//删除左空格
      console.log(str5.length);
      console.log(str6.length);
      


      var str1= "aImonkey";
      console.log(str[0]);
      console.log(str.charAt(0)); //等同于 str[0];
      console.log(str.charCodeAt(1)); //返回Unicode 码

      var url4 = "www.baidu.com";
      var arrs = url4.split(".");
      console.log(arrs[0]);
      console.log(arrs[1]);
      console.log(arrs[2]);
      console.log(arrs[3]);
      
      url4.startsWith("http");//以http开头
      url4.endsWith("com");//以com结尾
      

      JavaScript数组和异常处理笔记

      1.数组是特殊对象,数组与对象的区别
      元素名为字符串则使用对象,元素名为数字则使用数组。

      //两种方法判断是数组还是对象 返回false 和true
      console.log(Array.isArray(arr));
      console.log(arr instanceof Array);

      var arr = new Array(1,2,3,4,5);
      arr[6] = "abc";//通过索引改变内容的值
      var str = arr.toString();//把arr数组转换成字符串
      console.log(arr.length);
      var obj = {"age":30 , "name":"zhangsan"};

      2.对象模拟数组
      //模拟数组
      function MyArray() {
      this.length = arguments.length; //arguments.length:所有数组的长度
      for (var i=0; i <arguments.length; i ++){
      this[i] = arguments[i]; //this[i] 取到数组的每一个内容
      }

          this.push = function (s) {  //在数组的后面添加内容的方法  this.push
              this[this.length] = s;  //知道下标长度在最后面添加内容
              this.length++;//数组长度增加
              return this.length;  // 返回数组的 长度
          };
      
          this.pop = function () {  //删除数组最后一位元素内容
              var popdata = this[this.length-1];//想要删除最后一位元素,就要先找到它
                                                  //this.length-1 :数组长度-1 找打最后一个元素
              delete this[this.length-1]; //删除最后一个元素
              this.length--;//数组长度减少
              return popdata;
          };
      
          this.toString = function () {
              var result =""; //数组里遍历的内容用字符串包裹
              var j = ',';  //数组里的内容用逗号,隔开
             for (var i =0; i<this.length-1;i++){
                 result += this[i];
                 result += j;
             }
              result+=this[i];
              return result;
          }
      }
      
      
      var arr = new Array(1,2,3,4,"asd");
      console.log(arr.length); //数组的长度
      console.log(typeof arr);
      /*console.log(arr.push("hello"));
      console.log(arr.push("world"));*/
      console.log(arr.toString());
      

      / console.log(arr.pop());
      console.log(arr.pop());
      /

      console.log(arr); //把数组所有元素打印出来
      /*console.log(arr[0]);
      console.log(arr[1]);
      console.log(arr[2]);
      console.log(arr[3]);*/
      

      3.数组的声明和使用
      arr.push();==>添加
      arr.pop();==>删除

      4.数组的常用方法
      //数组的常用方法
      //join()方法可将所有数组元素结合为一个字符串
      var colors = ["red","yellow","black","blue","green"];
      /var str = colors.join("#"); //每个内容之间用#连接
      //var val = colors.unshift("000000"); //在数组的最前面添加一个元素
      var vals = colors.shift();//在数组的最前面删除一个元素
      var val = colors.splice(2,0,"000000","#ffffff"); //splice(2,0,"000000","#ffffff"); 拼接数组
      //2=>下角标是2,0=>删除的个数 后面是添加的内容
      var vals = colors.splice(2,2); //删除 返回的结果是原来数组中删除的内容
      var colors2 = ["white","abe","zcx"];
      var colors3 = ["qwe","abe","zcx"];
      var a = colors.concat(colors2,colors3,one,two);//拼接数组,想先拼接的就放在前面 ,也可以直接放值
      console.log(colors);
      console.log(a);/*
      var val = colors.slice(1,3);//裁剪数组 从角标是1 到角标是3 的元素 被裁剪
      // 但是会返回一个新数组 不会破坏原数组 包含开始的元素,不包含结束的元素
      console.log(val);
      console.log(colors);

      5.冒泡排序
      /
      1、外层 for 循环控制循环次数
      2、内层 for 循环进行两数交换,找每次的最大数,排到最后
      3、设置一个标志位,减少不必要的循环
      /
      var arr = [9,8,7,6,5,4,3,2,1];
      function MyAdd(arr) {
      var max = arr.length-1;
      //重复arr.length - 1次 把最大的数放在最后一位
      for (var j = 0;j < max;j ++){
      // 声明一个变量,作为标志位
      var done = true;
      //这里要根据外层for循环的 j,逐渐减少内层 for循环的次数
      for (var i = 0; i < max- j; i++){
      if(arr[i]>arr[i+1]){
      var temp = arr[i];
      arr[i]= arr[i+1];
      arr[i+1] = temp;
      done = false;
      }if(done){
      break;
      }
      }
      }
      return arr;
      }
      console.log(MyAdd(arr));

      6.数组排序
      //数组排序

      var colors = ["red","yellow","black","blue","green"];
      colors.sort();
      colors.reverse(); //反转数组中的元素
      console.log(colors);
      
      var arr = [9,8,7,6,5,4,3,2,1];
      arr.sort(function (a,b) {
          //return a-b;  //正序
          return b-a; //倒序
      });
      arr.sort(function (a,b) {
          return 0.5-Math.random();  //随机数
      });
      var max = Math.max.apply(null,arr); //把Math.max最大值的数学方法用apply的方法放大数组里面取最大值
      var min = Math.min.apply(null,arr);
      //console.log(arr);
      console.log(max);
      console.log(min);
      

      7.数组的迭代

      //数组迭代
      //1.forEach() 方法为每个数组元素调用一次函数(回调函数)
      //var arr = [1,2,4,9,7,8,3,4,5];
      //value =值;
      // index = 索引;
      // array = 当前数组
      /arr.forEach(function (value, index, array) {
      console.log(index+"=>"+value+"=>"+array);
      })
      arr.forEach((v,i)=>{console.log(i+"=>"+v)});
      以上两种方法相同
      /

      //2.map(); 创建新数组
      /*var narr = arr.map(value => value**2);
      console.log(narr);*/
      
      //3.filter() 过滤
      //var narr = arr.filter(v=>v>2);
      //var narr = arr.filter(v=>v%2==0);
      //console.log(narr);
      
      //4.reduce() 在每个数组元素上运行函数,以生成(减少它)单个值。
      //var num = arr.reduce((t,v)=>t+v);  //总数与值相加
      //console.log(num);
      
      //5.every()检测所有数组元素是否通过测试 返回bool
      //var narr = arr.every(v=>v>2);
      //console.log(narr);
      
      //6.indexOf()  从左到右查找元素位置
      //var narr = arr.indexOf(4);
      //console.log(narr);
      
      //7.lastIndexOf()  从右到左查找元素位置
      //var narr = arr.lastIndexOf(4);
      //console.log(narr);
      
      //8.find()  查找符合条件的第一个值
      //var narr = arr.find(v=>v>4);
      //console.log(narr);
      
      //9.findIndex()  查找符合条件的第一个值的索引
      var narr = arr.findIndex(v=>v>4);
      console.log(narr);
      

      8.异常处理

      JavaScript对象编程笔记

      对象(创建对象要使用new关键字)
      1.对象的应用

      2.对象的声明和引用
      //构造一个人对象
      function Person(){
      var obj = new Object();
      obj.name = "肖战";
      obj.age = 28;
      obj.sex = "男";
      obj.say = function(){
      console.log("我是兔子");
      }
      return obj;
      }
      var p = Person();
      p.say();

      function demo(obj){
      obj.age = 30;
      }
      demo(p);
      console.log(p.age); ==》30

      js 对象引用传值
      1)当变量是一个对象(例如:{}或[]),使用 a = b = {} 这种形式传值的话,会变成引用传值,
      修改 a 时 b 会相应变化,修改 b 时 a 也一样会相应变化

      var a = b = {};
      a.test = '测试';

      console.log(a);test: "测试"

      console.log(b);test: "测试"

      2)当变量为数值型的话,则不会引用传值

      var a = b = 0;
      a = 1;

      console.log(a); a=1
      console.log(b);b=0

      3.this关键字(this =“我”)

      / function Person(){
      var obj = new Object();
      obj.name = "肖战";
      obj.age = 28;
      obj,sex = "男";
      obj.say = function(){
      console.log(this.name + "是兔子"); this =obj
      };
      return obj;
      }
      let xz = Person();
      xz.say();
      /

      function Person(name,age,sex){
      this.name = name;
      this.age =age;
      this.sex = sex;

         this.eat = function(){
             console.log(this.name + "在吃饭");
         };
         this.say= function(){
             console.log("我的名字" + this.name + "我的年龄" + this.age + this.sex);
         }
      

      }

      var p1 = new Person("肖战",28,"男");
      var p2 = new Person("王一博",22,"男");
      p1.say();
      p2.say();

      4.ES6中class的声明和使用(class不存在变量提升)
      //ES6中class
      class Person{
      //默认的构造方法 在使用new关键字时,自动调用 用来初始化成员
      constructor(name,age,sex){
      this.name = name;
      this.age =age;
      this.sex = sex;
      }
      //在class中声明的方法不使用 function
      say(){
      console.log(this.name+"说话的方法");
      }
      eat(){
      console.log("这是一个吃饭的方法");
      }

          //static 静态方法 不属于对象
          static hello(){
              console.log("这是一个测试");
          }
      }
      
      var p = new Person("肖战",28,"男");
      p.say();
      p.eat();
      Person.hello();
      

      5.对象中的属性,方法和运算符
      prototype属性:原型对象
      call()方法:把一个对象中的方法放到另外一个对象中去
      instanceof运算符

      //prototype对象属性
      function Person(name) { //name参数记得传过来
      this.name = name;
      this.age =10;
      this.say= function () {
      console.log("我是方法");
      }
      }

      Person.prototype.one = function () {
          console.log(this.name + "我是one方法");
      };
      
      var p1 = new Person("肖战");
      var p2 = new Person("王一博");
      
      p1.one();
      p2.one();
      

      //call()方法
      function Person1(){
      this.fullName = function(a,b){
      return this.firstName + "" + this.lastName+a+b;
      }
      }
      var p1 = new Person1();

      function Person2(){
          this.firstName = "one";
          this.lastName = "two";
      }
      var p2 = new Person2();
      
      function Person3(){
          this.firstName = "abc";
          this.lastName = "xyz";
      }
      
      var p3 = new Person3();
      
      console.log(p1.fullName.call(p2,'xxx','zzz'));//把p1 的fullName方法放到p2里面 并带有两个参数
      console.log(p1.fullName.call(p3,'yyy','bbb'));//把p1 的fullName方法放到p3里面 并带有两个参数
      

      console.log(p1 instanceof Person1);//判断哪个对象属于哪个类 返回true和false

      6.ES6对象的继承方法 extends super 两个关键字
      //ES6 继承

      class Person{
          constructor(name,age,sex){
              this.name = name;
              this.age = age;
              this.sex = sex;
          }
      
          say(){
              console.log(this.name+"说话方法");
          }
          eat(){
              console.log(this.name+"吃饭方法");
          }
      }
      
      class Student extends Person{
          constructor(name,age,sex,score){
              super(name,age,sex);
              this.score=score;
          }
          study(){
              console.log(this.name+"学习方法");
          }
      }
      
      var s = new Student("xiaozhan",28,"nan",100);
      s.study();
      console.log(s instanceof Student);
      

      7.for in遍历对象

      for(变量 in 对象){}
      //for in 遍历
      function Person(name,age,sex){
      this.name = name;
      this.age =age;
      this.sex = sex;

          this.eat = function(){
              console.log(this.name + "在吃饭");
          };
          this.say= function(){
              console.log("我的名字" + this.name + "我的年龄" + this.age + this.sex);
          }
      
      }
      
      var p = new Person("肖战",28,"男");
      
      //两种方式调用对象
      console.log(p.name);
      console.log(p['name']);
      
      var pro;
      for( pro in p ){
          console.log("p."+pro+"="+p[pro]);
      }
      

      8.json
      A.服务器和客户,服务器和服务器之间传递数据格式
      B.语言和语言之间交换数据
      //json
      var p ={"name":"王一博","age":"22","sex":"男"};
      console.log(p.name);
      console.log(p['age']);
      var pro;
      for(pro in p){
      console.log(p[pro]);
      }
      console.log(typeof p); //对象
      //数据上传到服务器都用字符串
      var s = JSON.stringify(p);//将p里面的数据转换成字符串
      var obj = JSON.parse(s); //将s转换成对象,用于访问里面的内容
      console.log(obj.name);
      console.log(s);
      console.log(typeof s);//string
      console.log(typeof obj);

      9.json的格式

      JavaScript运算符,流程结构,函数

      1.var 声明的变量可以提升,let和const声明变量不可以提升。
      2.算数运算符
      A.求幂
      var x = 3;
      var y = x星星2; ==>3的平方 = 9;
      B.求模%
      一是让一个数不超过另一个数 1001%10
      判断一个数被什么数整除 2000%4 == 0;
      只要第一个数是负的,所有的结果都是负的
      var a =89; var b = 10; a%b =9
      var a = -89; var b = 10; a% b = -9
      var a = -89; var b = -10; a%b = -9
      C.++ --
      ++(--)在前先加减在使用(赋值)
      ++(--)在后先赋值在加减
      3.逻辑运算符(判断闰年 闰年能被4整除且不能被100整除,或能被400整除)
      && 逻辑与(并且),所有条件true,结果为true,有一个是false结果就是false
      || 逻辑或 有一个为true,结果true
      ! 逻辑非 真的边false 假的的变true
      4.switch case
      A.如果条件是范围 使用if else
      B.如果条件是的单个值匹配 使用 switch case
      var num = 0;
      switch(num) {
      case 1:
      console.log();
      break;
      ....
      default:
      console.log();
      break;
      }
      计数用for循环,条件用while循环
      5.for循环
      for(初始化变量;条件;变量累加){
      循环体;
      }
      for(var i = 0; i <10;i++){
      循环体;
      }
      6.循环中的特殊语句
      continue; 退出本次循环
      break;退出循环

      outer:
      for(var i = 0; i < 5; i++){
      console.log("i循环++++++"+i);
      for(var j = 0; j < 5; j++){
      //此时跳出最外层的i循环
      break outer;
      console.log("j循环++++++"+j);
      }
      outer:标记位 ==》跳出循环

      7.function 函数需要调用才能执行 使用:函数名()
      8.函数的使用
      A.函数体中执行到return 就将后面数据返回到调用处,后面的代码就不执行了
      B.在一个函数里,只能执行到一个return
      9.作用域
      A.全局变量,在函数外面声明,在函数内部可以使用
      B.在函数内部声明的变量,只有在函数内部使用--局部变量
      10.函数参数
      arguments:所有参数
      arguments.lenght :有几个参数
      arguments[0]; ==>第几个参数
      11.回调函数:一个函数可以作为另外一个函数参数使用
      A.函数名,加上()括号就是调用函数
      B.不加()括号使用函数,就是函数的声明结构
      12.匿名函数:没有名字的函数 (函数只被使用一次时使用)
      A.自调用
      (funtion(a,b) {
      console.log(a+b);
      return a+b;
      })(1,2);
      function demo(a,b){return a星b} ==> var demo =function(a,b){return a*b}
      document.getElementById('btn').onclick=function () {}==》匿名函数
      13.箭头函数
      var demo =function(a,b){return a星b}==>
      A.两个参数
      var demo1 = (a,b) =>{return a星b}
      B.一个参数
      const demo2 = x = {return x星星2}; ==>25
      console.log(demo2(5))
      C.一个参数一个语句
      const demo3 = x = x星星2;==>25
      console.log(demo3(5));
      D.没有参数
      const demo4 =() = 2星2;==>4
      console.log(demo4());
      14.闭包函数
      (全局变量能够通过闭包实现局部私有)
      var add = ( function(){
      var counter = 0;
      return function(){
      return counter+=1;
      }
      })();

      老师讲的真的是非常详细了,声音好有磁性,大赞
      咱也不会评论呀, 总之吧非常非常非常非常非常非常好
      我爱死这种学习方法了!
      谢谢老师, 这个课程入门很好,谢谢。
      跟玩游戏一样,玩着玩着就通关了
      非常棒,整理了下最近新学习的知识,全部巩固,赞一个!
      推荐好课(试听)
      更新

      Java  实战   5751

      最新课程体验中
      限时免费

      升级

      前端  实战   3087

      最新课程体验中
      限时免费

      更新

      PHP  实战   3302

      最新课程体验中
      ¥9.9

      更新

      前端  中级   3273

      最新课程体验中
      限时免费

      更新

      前端  实战   3018

      最新课程体验中
      限时免费

      升级

      UI/UE  中级   1922

      最新课程体验中
      限时免费

      更新

      Linux  中级   3016

      最新课程体验中
      限时免费

      更新

      Python  实战   3850

      最新课程体验中
      限时免费

      辅导猿
      Sample avatar
      xxyd_python

      辅导猿

      Sample avatar
      xxyd_java

      辅导猿

      Sample avatar
      xxyd_ui

      辅导猿

      Sample avatar
      xxyd_php

      辅导猿

      Sample avatar
      xxyd_h5x

      辅导猿

      最新成员
      Sample avatar Sample avatar Sample avatar Sample avatar Sample avatar Sample avatar Sample avatar Sample avatar Sample avatar Sample avatar Sample avatar Sample avatar Sample avatar Sample avatar Sample avatar
      学习资料 内容数量
      任务数量 93 关
      视频教程 280 小时+
      教学案例 650 个+
      辅助资料 280 个+
      练习作业 370 个+
      阶段测评 1300 道+
      最新评价
      Image placeholder

      NULL_cDfHY8

      评价:老师讲的真的是非常详细了,声音好有磁性,大赞

      Image placeholder

      木子言上

      评价:咱也不会评论呀, 总之吧非常非常非常非常非常非常好

      Image placeholder

      jubal

      评价:我爱死这种学习方法了!

      Image placeholder

      小倪

      评价:谢谢老师, 这个课程入门很好,谢谢。

      Image placeholder

      评价:跟玩游戏一样,玩着玩着就通关了

      Image placeholder

      罗武侠

      评价:非常棒,整理了下最近新学习的知识,全部巩固,赞一个!