JavaScript语言基础实战教程＃Web前端起步技术
 收藏

    

 3464人加入学习

价格

限期免费

教学计划

默认计划

学习有效期

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中的事件添加方式，并通过实例详细对每个应用进行了功能的操作。

 第1关：JavaScript语法开始学习

 第2关：JavaScript的运算符和流程控制开始学习

 作业:JavaScript的运算符和流程控制通关作业 

 第3关：JavaScript的流程控制和函数开始学习

 第4关：JavaScript对象编程开始学习

 第5关：JavaScript数组和异常处理开始学习

 第6关：JavaScript字符串操作和正则表达式开始学习

 作业:JavaScript字符串操作和正则表达式通关作业 

 第7关：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";

//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;
}
})();