node.js零基础学习笔记（二）

注释：写完了今天的笔记，今天主要学习了，不同js文件，如何获取其他js文件的方法，一个js方法的导出另外js文件对方法的接收（语言叙述可能不准确，就是想说我有一个苹果你想吃我也愿意给你吃，怎么搞？我要先把苹果拿出来的过程，和你伸手的过程，我就是一个比喻~可能不太准确，但是我是这么理解的），以上是第一个主要知识点，第二个知识点是ES6的一些简单的语法，以及注意事项。其他的都是零零碎碎的杂知识点。

一、全局成员

1、__filename：文件的完整路径（包含文件名称）

      __dirname：文件的完整路径（不包含文件名称）

//全局成员
//文件的完整路径(包含文件名称)
console.log(__filename);
//文件的完整路径(不包含文件名)
console.log(__dirname);

输出：

c:\xampp\htdocs\web-test\js\test1.js
c:\xampp\htdocs\web-test\js

2、定时器

//每隔一秒执行一次
var timer1=setInterval(function(){
    console.log("ok");
},1000);
//只执行一次
var timer2=setTimeout(function(){
    console.log("ok");
},1000);

3、global对象：node.js下没有window对象，但是有一个对象global，和window对象类似

global.console.log(123456);//console.log(123456);

4、进程对象

进程和线程：一个进程可以包含多个线程，线程是程序执行的路径 

进程的线程的区别：https://www.cnblogs.com/dreamroute/p/5207813.html

*对于完全不懂的人来说，这个博客中打比方，将进程和线程的区别和作用叙述了一下。

console.log(process.argv);//运行结果是一个数组，第一个参数是node.js的安装路径，第二个是当前文件的路径
console.log(process.arch);//当前操作系统的架构


//输出结果

[ 'C:\\Program Files\\nodejs\\node.exe',
  'c:\\xampp\\htdocs\\web-test\\js\\test1.js' ]
x64

二、模块化

1、前端标准的模块化规范：ES6

扫描二维码关注公众号，回复： 3997857 查看本文章

      服务端程序模块化规范

      Node.js实现模块化的标准是CommonJS

2、模块：一个或多个JS文件对外提供的功能，模块内部的成员都是独立的

      例如一个js提供一个功能，或者两个js文件提供了一个功能，那么这个功能就是一个模块

3、模块的导入导出（两种方法）

      方法一：exports.XXX=xxx

      方法二：module.exports

      两个方法不能同时使用，如果同时使用，以module.exports输出为准，因为require找的是module.exports对应的内容

      问题一：既然require找的是module.exports对应的，为什么exports.XXX也能将方法导出？？      

      解释：最开始每一个模块默认的module.exports === exports === {}，当exports.XXX=xxx时

                 实际上进行的操作是module.exports === exports === {XXX:xxx}，给对象赋值，则require可以加载

      问题二：实施以下操作时，输出什么？？为什么？？

      解释：当给exports =  函数时，module.exports 依然是{}，所以require获取的是空

//test.js文件
//第一步：module.exports === exports === {}
var sum =function(a,b){
    return a+b;
};
exports = sum;//exports = 函数，但是module.exports === {}


//app.js文件
var result=require("./test.js");
console.log(result);

//输出结果：
{}

导出方法一：

//test3.js文件
//定义了一个求和的函数
var sum1=function(a,b){
    return a+b;
};
//导出的模块成员-方法一,exports={}是默认的一个空对象
exports.sum=sum1;//{sum:function(a,b){return a+b;}}


//test4.js文件
// 想使用求和的函数，需要模块导出
//require()接收到的是test3.js中的exports的这个对象
var sum1=require("./test3.js");
console.log(sum1);//输出结果：{ sum: [Function: sum] }是一个对象
var res=sum1.sum(1,2);
console.log(res);

导出方法二：

//test3.js文件
var sum2=function(a,b){
    return a+b;
};
module.exports=sum2;

//test4.js文件
var sum2=require("./test3.js");
console.log(sum2);//输出结果：[Function: sum2] 是一个函数
var res=sum2(2,3);
console.log(res);

4、模块导出两个方法：

      用exports.xxx导出两个方法不会被覆盖，module.exports导出两个方法，后面的将前面的方法覆盖

      所以将需要暴露多个方法时，用前者，否则只需要暴露一个方法时，用后者

//test3.js文件
var sum=function(a,b){
    return a+b;
};
var fn=function(){
    console.log("ok");
};
//可以使用
exports.sum=sum;
exports.fn=fn;

//最好使用：
module.exports={
    sum:sum,
    fn:fn
}

//test4.js文件
var result=require("./test3.js");
console.log(result);

//输出结果:两个方法都有
{ sum: [Function: sum], fn: [Function: fn] }

//test3.js文件
//分别导出两个方法
var sum=function(a,b){
    return a+b;
};
module.exports=sum;
module.exports=function(){
    console.log("ok");
};

//test4.js文件
var result=require("./test3.js");
console.log(result());

//输出结果，第一个sum的方法被覆盖
ok
undefined//输出undefined原因是函数没有返回值

三、ES6简单的基本知识扩展

//ES6
//1:声明变量let和const,let定义的变量不会被生命提前
console.log(bool);//undefined
var bool=123;
console.log(bool);//报错
let bool=123;//let定义得变量，不会声明提前

//2:定义变量赋值，let不允许重复定义变量
var a=10;
var a=20;
console.log(a);//20
let a=10;
let a=20;
console.log(a);//报错

//3:块内部通过let定义的变量，通过外部不能访问
if(true){
    var a=20;
}
console.log(a);//20
if(true){
    let a=20;
}
console.log(a);//报错,a未定义

//4:const定义常量
const a=20;
//a=30; //报错
console.log(a);

//5:变量的结构赋值
let[a=100,b,c] = [1,2,3];
console.log(a,b,c);//1 2 3

//6:对象的结构赋值
let {foo,bar} = {foo:'hello',bar:'node js'};
let {foo='node',bar} = {bar:'Hello'};
let {foo:abc='node',bar} = {bar:'Hello'};//abc是foo的别名，有了别名之后原名称失效
console.log(abc);
console.log(foo);//undefined
console.log(bar);//node js

let{cos,sin,random} = Math;
console.log(typeof cos);

//7:字符串的结构赋值
let [a,b,c,d,e,length] = "hello";
console.log(a,b,c,d,e);
console.log("Hello".length);

//8:字符串相关的API
includes() 判断字符串是否含有指定的字符串，true/false 后面的数字参数是从第几个位置开始匹配
startsWith() 判断字符串是否是以..字符串开头
endsWith() 判断字符串是否是以..字符串结束
console.log("hello es6".includes("es6",6));//true
console.log("admin/index.jsp".startsWith("admin"));//true
console.log("admin/index.jsp".endsWith(".jsp"));//true

//9:模板字符串
let student = {
    sname:'张三',
    sage:'22',
    sex:'M'
};
let fun=function(str){
    return str;
};
let tag=`
    <div>
        <span>${student.sname}</span>
        <span>${student.sage}</span>
        <span>${student.sex}</span>
        <span>${2*2}</span>
        <span>${fun("hi")}</span>
    </div>
`;
console.log(tag);

四、ES6函数扩展

1、参数默认初始值

2、...的使用：接收多余参数，扩展运算符

//1:参数默认初始值
function foo(param){
    let p = param || "noParam";//初始值：如果传参数了p=参数值，如果没有传参数，p="noParam"
    console.log(p);
}
foo("param1");
foo();

function foo(param = "noParam"){//初始值：如果传参数了param=参数值，如果没有传参数，param="noParam"
    console.log(param);
}
foo("param1");
foo();

function fun({uname="nName",age=0}={}){//函数设置初始值
    console.log(uname);
    console.log(age);
}
fun({uname:"李四",age:20});//李四 20
fun();//nName 0

//2：...接收多余参数
function fun(a,b,...rest){
    console.log(a,b);
    console.log(rest);//多余的:数组
}
fun(10,20,30,40);//10 20 [30,40]

//3:... 扩展运算符
function fun(a,b,c,d,e,f){
    console.log(a+b+c+d+e+f);
}
fun(1,2,3,4,5,6);//21
let arr=[1,2,3,4,5,6];
fun(...arr);//21
fun(arr);//输出结果:1,2,3,4,5,6undefinedundefinedundefinedundefinedundefined

let arr1=[1,2,3];
let arr2=[4,5,6];
let arr=[...arr1,...arr2];
console.log(arr);

3、箭头函数 

function fn(){
    console.log("fn");
}
let fn=() => console.log("fn");//上面函数的简写
let fun =() => {//函数语句不是一条时，大括号不能省略
    console.log("fun1");
    console.log("fun2");
};
fun();

function fun(v){//带返回值的函数
    return v;
}
let fun=(v)=>v;//上面函数的简写
let returnV=fun("abc");
console.log(returnV);

let arr=[1,2,3,4,5];
arr.forEach(function(item,index,array){
    console.log(item,index,array);
});
arr.forEach((item,index,array) => {//上面函数的简写
    console.log(item,index,array);
});

4、箭头函数的注意事项

   1、箭头函数的this取决于函数的定义，而不是调用者，和以前的函数不一样

    2、不能使用new调用

    3、无法使用argument获取实参列表

//1:箭头函数的this取决于函数的定义，而不是调用者，和以前函数不一样
function fun(){
    console.log(this);//如果不用call绑定this指的是global，如果用call，此时的this是{ num: 1 }
    setTimeout(()=>{
        console.log(this.num);
    },1000)
}
fun();//undefined，原因是this指的是global,没有.num
fun.call({num:1});

//2:不能使用new调用
let foo = (res) => {
    console.log(res);
};
foo();
new foo();//报错:TypeError: foo is not a constructor

//3:箭头函数无法用argument获取实参列表
let foo = (...rest) => {
    console.log(arguments);//不可使用，无法获取实参列表
    console.log(rest);//[10,20]
};
foo(10,20);