/*P32-arguments*/
//arguments是参数，类似于数组。
//函数可以接受不固定个数的参数，这时利用arguments
/*arguments每次只能指定一个索引。
function log(){
console.log(arguments[0]);
}
log('abc','def','ghi');
//输出 abc【2022-08-29】
//这里能看到参数不一定要提前指定哈。【2022-08-29】
*/
/*使用循环遍历arguments里面每个参数
function log(){
for(let i =0; i< arguments.length; i++){
console.log(arguments[i]);
}
}
log('abc','def','ghi');
/**
* abc
* def
* ghi
*/
/** */
/*P33-作用域 */
//我们定义的变量的可用范围：全局和局部
//1.在最外层定义的变量都是全局的，即除了函数内定义的之外，其他都是全局。
//VH：循环结构里面的也是吧-记得国外一位教程里面是这么讲的。只有{}好像不行，有测试，参考P26-函数-额外的测试
//2.局部作用域，就是定义在函数内部的，只能在函数内部使用。
//其他的大括号里面的变量，作用域有所区别。下节讲到。
//3.局部作用域的代码，可以访问全局作用域的变量。
/*例子1
var x = 5;//全局作用域的变量
function add(a){
return a+x;
}
console.log(add(8));//13
x=20;
console.log(add(8));//28
*/
/*例子2：外部访问内部变量
var x = 5;//全局作用域的变量
function add(a){
var y =10;
console.log('y='+y);
return a+x;
}
console.log(add(8));//第一行 y= 10,第二行 13
x=20;
console.log(add(8));//第一行 y= 10,第二行 28
//外面访问函数内函数
console.log(y);//ReferenceError: y is not defined
/** */
/*例子3：局部作用域和全局作用域变量重名
//全局的就会被局部的覆盖
var num = 100;
function multiply(num){
return 10*num;
}
console.log(multiply(4));//40
/** */
/*P34-var/let*/
//相同点：
//1.都是定义变量;2.函数内外使用是一样的，let=var，域内定义域内使用。
//不同点：
//1.函数外的{}或()里面定义的变量（比如ifelse，for循环），外面是否可以访问。
//var是全局，let是局部。
/*例子1：if中的var：外界可以访问
var z= 6;
if(z >2){
console.log(z);//6
var innerZ = 17;
}
console.log('外面访问到innerZ的值：'+innerZ);//外面访问到innerZ的值：17
/** */
/*例子2：if中的let（或者const）：外界访问不到
var z= 6;
if(z >2){
console.log(z);//6
let innerZ = 17;
}
console.log('外面访问到innerZ的值：'+innerZ);//innerZ is not defined
/** */
/*例子3：for条件里面的i：用var，外界可以访问
for(var i = 0; i< 10; i++){
console.log(i);//0-9
}
console.log(i);//10,表明：循环的i到10的时候，经过i<10判断不符合就跳出，顺序执行到下面这句。
/** */
/*例子4：for条件里面的i：用let，外界不可以访问
for(let i = 0; i< 10; i++){
console.log(i);//0-9
}
console.log(i);//Uncaught ReferenceError: i is not defined
/** */
/*例子5：for循环语句里面的变量：用var，外界可以访问
for(let i = 0; i< 10; i++){
var innerI=33;
}
console.log(innerI);//33
/** */
/*例子6：for循环语句里面的变量：用let，外界不可以访问
for(let i = 0; i< 10; i++){
let innerI=33;
}
console.log(innerI);//Uncaught ReferenceError: innerI is not defined
/** */
/*P35-函数-箭头函数*/
//和普通的函数是一一对应的，但是没有自己的名字
//赋值给greeting的
/*例子1：没有参数的
var greeting = ()=>{
console.log('hello');//hello
};//这里为啥有个分号呢？因为是赋值语句么？
greeting();
/** */
/*例子2：有1个参数的
var greeting = myName =>{
console.log('hello'+myName);
};//这里为啥有个分号呢？因为是赋值语句么？
greeting('峰华');//使用的时候，参数和正常函数一样的位置
/** */
/*例子3：有2个及以上参数的
//和普通的函数是一样的格式，只是把名字换成了箭头，调到{}前面去了。
var greeting = (myName,weather) =>{
console.log('hello'+myName+'今天是：'+weather);//hello峰华今天是：晴天
};//这里为啥有个分号呢？因为是赋值语句么？
greeting('峰华','晴天');
/** */
/*例子4：一行代码的箭头函数
//如果是有返回值且一行代码，可以省略{}和return。
var increament = x => x+1;
console.log(increament(6));//7
/*例子5：VH增加例子：一行代码的箭头函数
//如果使用console.log呢？
var increament = x => console.log(x+1);
increament(9);//10
/** */
/*P36-闭包*/
//函数里面再定义函数形成了闭包
//老师描述：子函数可以访问父函数作用域的变量，
//而且，如果父函数不暴露这个子函数的话，外界不知道子函数的存在，形成私有函数
//通过下面的例子，我觉得好神奇啊。
/*例子1：闭包
function squareSum(a,b){
function square(x){
return x*x;
}
return square(a)+square(b);
}
console.log(squareSum(2,3));//13
/*例子2：高阶函数
//内部函数也可以作为父级函数的返回值，返回出去
//父函数整体形成高阶函数：higher-order function，返回值可以是函数的函数。
//子函数里面的return后面可以接父函数定义的变量。厉害！因为可以访问上一级吧。
//下面这个例子的操作，可以使外界只能访问myName的值，而不能修改它。
//哦，是的。一般能访问就是获取和修改。这样的做法只能访问，不能改。
//？但是，如果直接在父函数下return这个私有的myName不是一样的么？
function person(){
let myName ='峰华';
function getName(){
return myName;
}
return getName;
}
var getName = person();
console.log(getName);
console.log(getName());
/* //把子函数的定义打印出来了。
ƒ getName(){
return myName;
}
//正式执行函数，
峰华
*/
/** */
/*例子2.1：高阶函数-VH增加例子
//增加例子是因为子函数名字是getName，最外面把父函数赋值给getName变量，一定一重名么？
//经过测试，不是的。这样的操作估计是为了方便相认。
//？怎么感觉有点和我之前做的测试有点相似之处。有机会再比较。
function person(){
let myName ='峰华';
function getName(){
return myName;
}
return getName;
}
var getName2 = person();
console.log(getName2);
console.log(getName2());
/* //把子函数的定义打印出来了。
ƒ getName(){
return myName;
}
//正式执行函数，
峰华
*/
/*P37-函数-柯里化（curry)*/
//把一个能接收多个参数的函数变成多个接收一个参数的函数并组合成闭包的样式。
//？大概知道是怎么用，不知道原理，不知道具体的应用场景。
/*例子1：
function addThreenums(a,b,c){
return a+b+c;
}
console.log(addThreenums(1,2,3));//6
//柯里化开始
function addThreenumsCurry(a){
return function(b){
return function (c){
return a+b+c;
};//老师的这里为啥要加分号呢？
};//老师这里为啥加分号呢？
}
console.log(addThreenumsCurry(1)(2)(3));//6
var fixedTwo=addThreenumsCurry(1)(2);
console.log(fixedTwo);//f(c)的函数体
console.log(fixedTwo());//Nan,这里怎么是?
//因为1,2已经在内部保留，所以后来c的值就可以加在一起。
console.log(fixedTwo(4));//7，3+4
console.log(fixedTwo(5));//8，3+5
console.log(fixedTwo(6));//9，3+6
/** */
/*P38-自执行函数
//函数在调用后，直接调用自己。
//优点：
//1.函数内部代码，外部绝对访问不到，防止被篡改。
//2.形成自己的作用域，防止和外部变量重名时冲突。
//如下例中，一般函数会改变外部的num1的值，但是例子中不会。
var num1=10;
(function() {
var num1=20;
console.log(num1);//20
})();
console.log(num1);//10
/** */
/*P39-回调函数
//回调函数是一段代码执行完之后，再执行的函数。
//一般作为某个函数的参数，再在这个函数中调用它。
//VH：宿主函数和回调函数。这样来称呼会不会好一些。
//VH：回调函数做参数时不加()，定义时正常函数的定义方式。
//request()的回调函数callback()不带参数的情况
function request(cd){
console.log('请求数据');
cd();
console.log('请求结束');
}
function callback(){
console.log('来到回调函数内部打印');
}
request(callback);
//request()的回调函数callback(result)不带参数的情况
//request(中调用callback()的时候，就要带参数
function request(cd){
console.log('请求数据');
cd('success');
console.log('请求结束');
}
function callback(result){
console.log('来到回调函数内部打印');
console.log('打印回调函数的参数：'+result);
}
request(callback);
/* index.js:24 请求数据
index.js:30 来到回调函数内部打印
index.js:31 打印回调函数的参数：success
index.js:26 请求结束
*/
/** */
/*回调函数的简化写法：使用箭头函数写法
//缺点是其他地方无法复用。
//VH：主函数声明的时候，参数就是函数但是不带().也没有=>这样的箭头函数。但是在{}调用的时候需要().
//复制必要代码
function request(cd){
console.log('请求数据');
cd('success');
console.log('请求结束');
}
//使用箭头函数简化，相当于调用request()函数时，把下面这个函数整体当做request的参数
// function callback(result){
// console.log('来到回调函数内部打印');
// console.log('打印回调函数的参数：'+result);
// }
request(result =>{//省略掉函数名，直接按箭头函数的语法，参数=>{}
console.log('来到回调函数内部打印');
console.log('打印回调函数的参数：'+result);
});//这里分号加不加都可以，毕竟全部不加一般都可以。这里老师应该是为了明确。
/* index.js:43 请求数据
index.js:53 来到回调函数内部打印
index.js:54 打印回调函数的参数：success
index.js:45 请求结束
*/
/** */
扫一扫 手机查看