nodejs编译后js文件名前缀

Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境。

Node与javaScript的区别在于，javaScript的顶层对象是window,而node是global

//这里使用的var声明的变量不是全局的，是当前模块下的，用global声明的表示是全局的

var s = 100

global.s = 200

//这里访问到的s是var生命的

console.log(s)//100

//这里访问到的才是全局变量

console.log(global.s)//200

模块：在node中，文件和模块是一一对应的，也就是一个文件就是一个模块；每个模块都有自己的作用域，我们通过var申明的变量并非全局而是该模块作用域下的。

（2）module模块

1、文件查找

1）首先按照加载的模块的文件名称进行查找，如果没有找到，则会带上 .js、.json 或 .node 拓展名在加载

2）以 '/' 为前缀的模块是文件的绝对路径。 例如，require('/home/marco/foo.js') 会加载 /home/marco/foo.js 文件。

3）以 './' 为前缀的模块是相对于调用 require() 的文件的。 也就是说，circle.js 必须和 foo.js 在同一目录下以便于 require('./circle') 找到它。

4）当没有以 '/'、'./' 或 '../' 开头来表示文件时，这个模块必须是一个核心模块或加载自 node_modules 目录。

5）如果给定的路径不存在，则 require() 会抛出一个 code 属性为 'MODULE_NOT_FOUND' 的 Error。

2、module 作用域

在一个模块中通过var定义的变量，其作用域范围是当前模块，外部不能够直接的访问，如果我们想一个模块能够访问另笑纳清外一个模块中定义的碰前变量，可以有一下两种方式：

1）把变量作为global对象的一个属性，但这样的做法是不推荐的

2）使用模块对象 module。module保存提供和当前模块有关的一些信息。

在这个module对象中有一个子对象exports对象，我们可以通过这个对象把一个模块中的局部变量对象进行提供访问。

//这个方法的返回值，其实就是被加载模块中的module.exports

require('./02.js')

3、__dirname：当前模块的目录名。

例子，在 /Users/mjr 目录下运行 node example.js：

console.log(__dirname)

// 输出: /Users/mjr

console.log(path.dirname(__filename))

// 输出: /Users/mjr

4、__filename：当前模块的文件名（处理后的绝对路径）。当前模块的目录名可以使用 __dirname 获取。

在 /Users/mjr 目录下运行 node example.js：

console.log(__filename)

// 输出: /Users/mjr/example.js

console.log(__dirname)

// 输出: /Users/mjr

（3）process（进程）

process 对象是一个全局变量，提供茄戚 Node.js 进程的有关信息以及控制进程。 因为是全局变量，所以无需使用 require()。

1、process.argv

返回进程启动时的命令行参数。第一个元素是process.execPath。第二个元素是当前执行的JavaScript文件的路径。剩余的元素都是额外的命令行参数。

console.log(process.argv)

打印结果：

2、process.execPath返回启动进程的可执行文件的绝对路径。

3、process.env 返回用户的环境信息。

在process.env中可以新增属性：

process.env.foo = 'bar'

console.log(process.env.foo)

可以通过delete删除属性：

delete process.env.foo

console.log(process.env)

在Windows上，环境变量不区分大小写

4、process.pid 属性返回进程的PID。

5、process.platform属性返回字符串，标识Node.js进程运行其上的 *** 作系统平台。

6、process.title 属性用于获取或设置当前进程在 ps 命令中显示的进程名字

7、process.uptime() 方法返回当前 Node.js 进程运行时间秒长

注意: 该返回值包含秒的分数。 使用 Math.floor() 来得到整秒钟。

8、process.versions属性返回一个对象，此对象列出了Node.js和其依赖的版本信息。

process.versions.modules表明了当前ABI版本，此版本会随着一个C++API变化而增加。 Node.js会拒绝加载模块，如果这些模块使用一个不同ABI版本的模块进行编译。

9、process对象-输入输出流

var a

var b

process.stdout.write('请输入a的值: ')

process.stdin.on('data', (chunk) =>{

if (!a) {

a = Number(chunk)

process.stdout.write('请输入b的值:')

}else{

b = Number(chunk)

process.stdout.write('a+b的值:'+(a+b))

process.exit()

}

})

（4）Buffer缓冲器

Buffer类，一个用于更好的 *** 作二进制数据的类，我们在 *** 作文件或者网络数据的时候，其实 *** 作的就是二进制数据流，Node为我们提供了一个更加方便的去 *** 作这种数据流的类Buffer,他是一个全局的类

1、如何创建使用buffer

Buffer.from(array) 返回一个 Buffer，包含传入的字节数组的拷贝。

Buffer.from(arrayBuffer[, byteOffset [, length]]) 返回一个 Buffer，与传入的 ArrayBuffer 共享内存。

Buffer.from(buffer) 返回一个 Buffer，包含传入的 Buffer 的内容的拷贝。

Buffer.from(string[, encoding]) 返回一个 Buffer，包含传入的字符串的拷贝。

Buffer.alloc(size[, fill[, encoding]]) 返回一个指定大小且已初始化的 Buffer。 该方法比 Buffer.allocUnsafe(size) 慢，但能确保新创建的 Buffer 不会包含旧数据。

Buffer.allocUnsafe(size) 与 Buffer.allocUnsafeSlow(size) 返回一个指定大小但未初始化的 Buffer。 因为 Buffer 是未初始化的，可能包含旧数据。

// 创建一个长度为 10、且用 01 填充的 Buffer。

const buf1 = Buffer.alloc(10,1)

// 创建一个长度为 10、且未初始化的 Buffer。

// 这个方法比调用 Buffer.alloc() 更快，但返回的 Buffer 实例可能包含旧数据，因此需要使用 fill() 或 write() 重写。

const buf2 = Buffer.allocUnsafe(10)

const buf3 = Buffer.from([1, 2, 3])

const buf4 = Buffer.from('tést')

console.log(buf1)//<Buffer 01 01 01 01 01 01 01 01 01 01>

console.log(buf2)//<Buffer 00 00 00 00 08 00 00 00 07 00>

console.log(buf3)//<Buffer 01 02 03>

console.log(buf4)//<Buffer 74 c3 a9 73 74>

2、Buffer对象提供的toString、JSON的使用

1）buf.toString(encoding，start，end)

var bf = Buffer.from('miaov')

console.log(bf.toString('utf-8',1,4))//iaov

console.log(bf.toString('utf-8',0,5))//miaov

console.log(bf.toString('utf-8',0,6))//miaov

2）buf.write(string，offset，length，encoding)

string 要写入 buf 的字符串。

offset 开始写入的偏移量。默认 0，这里指的是buffer对象的起始要写入的位置。

length 要写入的字节数。默认为 buf.length - offset。

encoding string 的字符编码。默认为 'utf8'。

返回: 已写入的字节数。

var str = "miaov hello"

var bf = Buffer.from(str)

var bf2 = Buffer.alloc(8)

//从0开始写入5个

bf2.write(str,0,5)

console.log(bf)

console.log(bf2)

3）buf.toJSON()

const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5])

const json = JSON.stringify(buf)

console.log(json)

// 输出: {"type":"Buffer","data":[1,2,3,4,5]}

3、Buffer中静态方法的使用

1）Buffer.isEncoding(encoding) ： 判断是否是Buffer支持的字符编码，是则返回true，不是则返回false

console.log(Buffer.isEncoding('utf-8'))//true

2）Buffer.isBuffer(obj) ：如果 obj 是一个 Buffer，则返回 true，否则返回 false。

（5）fs（文件系统）

该模块是核心模块，需要使用require('fs')导入后使用，该模块主要用来 *** 作文件

1、fs.open(path, flags, mode, callback)

path：要打开的文件的路径；

flags：打开文件的方式 读/写；

mode：设置文件的模式 读/写/执行

callback(err，fd)：文件打开以后，在回调函数中做相应的处理,回调函数的两个参数：

err：文件打开失败的错误保存在err里面，如果成功err为null

fd：被打开文件的标识

var fs = require('fs')

fs.open('./test.txt','r',function(err,fd){

if(err){

console.log("文件打开失败")

}else{

console.log("文件打开成功")

}

})

2、fs.openSync(path, flags, mode) ：返回文件描述符。

var fs = require('fs')

console.log(fs.openSync('./test.txt','r'))//3

3、fs.read(fd, buffer, offset, length, position, callback)

从 fd 指定的文件中读取数据；

buffer 指定要写入数据的 buffer；

offset 指定 buffer 中开始写入的偏移量；

length 指定要读取的字节数；

position 指定文件中开始读取的偏移量。 如果 position 为 null，则从文件的当前位置开始读取；

callback 有三个参数 (err, bytesRead, buffer)

示例：test.txt 中的值为123456789

fs.open('./test.txt','r',function(err,fd){

if(!err){

var bf = Buffer.alloc(5)

fs.read(fd,bf,0,5,0,function(){

console.log(bf.toString())//12345

})

}

})

4、fs.write(fd, buffer, offset, length, position, callback)

将 buffer 写入到 fd 指定的文件。

offset 指定 buffer 中要开始被写入的偏移量，length 指定要写入的字节数。

position 指定文件中要开始写入的偏移量。 如果 typeof position !== 'number'，则从当前位置开始写入。

callback 有三个参数 (err, bytesWritten, buffer)，其中 bytesWritten 指定 buffer 中已写入文件的字节数。

var fs = require('fs')

fs.open('./test.txt','r+',function(err,fd){

if(!err){

var bf = Buffer.alloc(5)

fs.read(fd,bf,0,5,0,function(){

console.log(bf.toString())//12345

})

var bf = Buffer.from('test数据')

fs.write(fd,bf,0,10,0)

fs.write(fd,'测试数据2',10,'utf-8')

}

})

fs.write(fd, string, position, encoding, callback)

将 string 写入到 fd 指定的文件。 如果 string 不是一个字符串，则会强制转换成字符串。

position 指定文件中要开始写入的偏移量。 如果 typeof position !== 'number'，则从当前位置开始写入。

encoding 指定字符串的编码。

callback 有三个参数 (err, written, string)，其中 written 指定字符串中已写入文件的字节数。 写入的字节数与字符串的字符数是不同的。

5、fs.exists(path,callback)检查指定路径的文件或者目录是否存在

fs.appendFile(path, data, callback)：将数据追加到文件，如果文件不存在则创建文件。

//检查文件是否存在

var fs = require('fs')

var filename = './test2.txt'

fs.exists(filename,function(isExists){

if(!isExists){

fs.writeFile(filename,'miaov',function(err){

if(err){

console.log("文件创建失败")

}else{

console.log("文件创建成功")

}

})

}else{

fs.appendFile(filename,'-leo',function(err){

if(err){

console.log("文件内容追加失败")

}else{

console.log("文件内容追加成功")

}

})

}

})

（6）前端项目自动化构建

1、创建myProject项目文件以及对应的文件夹

var projectData ={

'name':'myProject',

'fileData':[

{

'name':'css',

'type':'dir'

},{

'name':'js',

'type':'dir'

},{

'name':'images',

'type':'dir'

},{

'name':'index.html',

'type':'file',

'content' : '<html>\n\t<head>\n\t\t<title>title</title>\n\t</head>\n\t<body>\n\t\t<h1>Hello</h1>\n\t</body>\n</html>'

}

]

}

var fs = require('fs')

if(projectData.name){

// 创建项目文件夹

fs.mkdirSync(projectData.name)

var fileData = projectData.fileData

if(fileData &&fileData.length){

fileData.forEach(function(file){

//文件或文件夹路径

file.path = './'+projectData.name +'/'+ file.name

//根据type类型创建文件或文件夹

file.content = file.content || ''

switch(file.type){

case 'dir':

fs.mkdirSync(file.path)

break

case 'file':

fs.writeFileSync(file.path,file.content)

break

default:

break

}

})

}

}

2、自动打包多个文件

var fs = require('fs')

var filedir = './myProject/dist'

fs.exists(filedir,function(isExists){

if(!isExists){

fs.mkdirSync(filedir)

}

fs.watch(filedir,function(ev,file){

//只要有一个文件发生了变化，我们就需要对文件夹下的所有文件进行读取、合并

fs.readdir(filedir,function(err,dataList){

var arr = []

dataList.forEach(function(file){

if(file){

//statSync查看文件属性

var info = fs.statSync(filedir + '/' +file)

//mode文件权限

if(info.mode === 33206){

arr.push(filedir + '/' +file)

}

}

})

//读取数组中的文件内容

var content = ''

arr.forEach(function(file){

var c = fs.readFileSync(file)

content += c.toString()+'\n'

})

//合并文件中的内容

fs.writeFileSync('./myProject/js/index.js',content)

})

})

})

（7）使用node进行web开发

1、搭建一个http的服务器，用于处理用户发送的http请求

//加载一个http模块

var http = require('http')

//通过http模块下的createServer创建并返回一个web服务器对象

var server = http.createServer()

//开启 HTTP 服务器监听连接，只有调用了listen方法以后，服务器才开始工作

server.listen(8000,'localhost')

//服务器是否正在监听连接

server.on('listening',function(){

console.log("listening..........")

})

//每次接收到一个请求时触发，每个连接可能有多个请求（在 HTTP keep-alive 连接的情况下）。

server.on('request',function(){

res.write('<p>hello</p>')

res.end()

})

2、request方法有两个参数：request、response

1）request：http.IncomingMessage的一个实例，获取请求的一些信息，如头信息，数据等

httpVession：使用的http协议的版本

headers：请求头信息中的数据

url：请求的地址

method：请求的方式

2）response：http.ServerResponse的一个实例，可以向请求的客户端输出返回响应

write（chunk,encoding）：发送一个数据块到相应正文中

end（chunk,encoding）：当所有的正文和头信息发送完成以后调用该方法告诉服务器数据已经全部发送完成了，这个方法在每次完成信息发送以后必须调用，并且是最后调用。

statusCode：该属性用来设置返回的状态码

setHeader（name,value）：设置返回头信息

writeHead（statusCode,reasonPhrase,headers）这个方法只能在当前请求中使用一次，并且必须在response.end（）之前调用

3、使用fs模块实现行为表现分离

var http = require('http')

var url = require('url')

var fs = require('fs')

var server = http.createServer()

//html文件的路径

var htmlDir = __dirname + '/html/'

server.on('request',function(request,response){

var urlStr = url.parse(request.url)

//根据pathname匹配对应的html文件

switch(urlStr.pathname){

case '/':

sendData(htmlDir + 'index.html',request,response)

break

case '/user':

sendData(htmlDir + 'user.html',request,response)

break

case '/login':

sendData(htmlDir + 'login.html',request,response)

break

default:

//处理其他情况

sendData(htmlDir + 'err.html',request,response )

break

}

})

function sendData(file,request,response){

//读取文件，存在则返回对应读取的内容，不存在则返回错误信息

fs.readFile(file,function(err,data){

if(err){

response.writeHead(404,{

'content-type':'text/htmlcharset=utf-8'

})

response.end('<h1>页面不存在</h1>')

}else{

response.writeHead(200,{

'content-type':'text/htmlcharset=utf-8'

})

response.end(data)

}

})

}

server.listen(8000,'localhost')

在nodejs中，模块是用于使用一些指定功能的js文件，通过以模块为单位来划分所有的功能，每一个模块中定义的全局变量和函数的作用范围也被限定在这个模块之内；包是用于管理模块以及其依赖关系的，可以对多个模块进行封装。

本文 *** 作环境：Windows10系统、nodejs 12.19.0版、Dell G3电脑。

nodejs模块与包是干什么的

区分一下包与模块：合理的使用包和模块，会使你的程序变得低冗余，高可读，功能全面。

一、NodeJS中包

包用于管理多个模块及其依赖关系，可以对多个模块进行封装，包的根目录必须包含 package.json 文件。

符合 CommonJS 规范的 package.json 文件一般包含以下字段：

name：包名。包名是唯一的，只能包含小写字母、数字和下划线。

version：包版本号。

description：包说明。

keywords：关键字数组，用于搜索。

homepage：项目主页。

bugs：提交 bug 的地址。

license：许可证。

maintainers：维护者数组。

contributors：贡信并拦蔽蔽献者数组。

repositories：项目仓库托管地址数组。

dependencies：包依赖。

1.1 生成package.json文件

package.json 文件可以自己手动编辑，还可以通过 npm init 命令进行生成。

在终端中输入 npm init 命令来生成一个包含 package.json 文件的包。直接输入 npm init --yes 跳过回答问题步骤，直接生成默认值的 package.json 文件。

1.2 包 *** 作

通过命令 npm install xxx 来安装包。比如：

安装包：

npm install express

更新包：

npm update express

删除包：

npm uninstall express

在 npm 社区中去查找包，再通过命令 npm install 模块名字 就可以安装。每个模块的名字全球唯一。

二、NodeJS中模块

2.1 什么是模块

我们需要对比一下浏览器中的JS与Node.js中的JS：

在 JavaScript 中，我们通常把 JavaScript 代码分为几个 js 文件，然后在浏览器中将这些 js 文件合并运行。

Node.js 中，是通过以模块为单位来划分所有功能的。每一个模块为一个 js 文件，每一个模块中定义的全局变量和函数的作用范围也被限定在这个模块之内，只有使用 exports 对象才能传递到外部使用。

Node.js 官方提供了很多模块，这些模块分别实现了一种功能，如 *** 作文件及文件系统的模块 fs，构建 http 服务的模块 http，处理文件路径的模块 path 等。

2.2 模块的创建

我们创建一个模块，并使用module.exports进行导出。滑胡

myModule.js文件

function foo() {

console.log("hello syl")}module.exports.foo = foo

index.js文件

var hello = require("./myModule.js")hello.foo()

nodejs模块与包有什么作用

注意：核心模块定义在 Node.js 源代码的 lib/ 目录下。require() 总是会优先加载核心模块。

例如：require(‘http’) 始终返回内置的 HTTP 模块，即使有同名文件。

2.3 区分 module.exports 和 exports

Node.js 为了简化你的 *** 作，专门提供了一个变量：exports 等于 module.exports。

这两行代码效果是一样的：

module.exports.foo = fooexports.foo = foo

解释案例：

// module.jsconsole.log('module', module)console.log('module.exports', module.exports)console.log('exports', exports)console.log(module.exports === exports)console.log("=========================================")exports = {

a: 3,

}console.log(exports)console.log(module.exports)console.log(exports === module.exports)

nodejs模块与包有什么作用

require() 得到的是 module.exports 导出的值，导出多个成员可以用 module.exports 和 exports，导出单个成员只能用 module.exports。

以上就是“nodejs模块与包有什么作用”这篇文章的所有内容，感谢各位的阅读！相信大家阅读完这篇文章都有很大的收获，小编每天都会为大家更新不同的知识，如果还想学习更多的知识，请关注亿速云行业资讯频道。

---