node介绍_node.js介绍 - CSDN
精华内容
参与话题
  • Node介绍——什么是Node?

    千次阅读 2018-09-20 20:50:40
    简单的说 Node.js 就是运行在服务端的 JavaScript。 Node.js 是一个基于Chrome JavaScript 运行时建立的一个平台。 Node.js是一个事件驱动I/O服务端JavaScript环境,基于Google的V8引擎,V8引擎执行Javascript的...

    简单的说 Node.js 就是运行在服务端的 JavaScript。

    Node.js 是一个基于Chrome JavaScript 运行时建立的一个平台。

    Node.js是一个事件驱动I/O服务端JavaScript环境,基于Google的V8引擎,V8引擎执行Javascript的速度非常快,性能非常好。

    1.编写高性能网络服务器的javascript工具包(用js开发服务端程序)

    2.单线程、异步、事件驱动

    单线程:01.php不支持多线程,但是php的服务apache支持多线程,启动时会初始化150个线程供php使用。在线程池中,线程工作将内容提供到客户端之后继续回到线程池中等待被调用;02.node.js单线程,多个线程对库操作,每个线程对应一个块内存;03.PHP高并发、大数据量如何处理?让线程快速结束(线程优化、主键)

    异步和事件驱动:异步访问完数据库之后就去进行其他操作,访问过程速度特别快,当下一步需要数据时会报错,所以需要将下一步操作放到上面的函数中,作为回调函数使用。node.js中有asyac方法让程序顺序执行

    3.特点:快、耗内存多
        

    4.node.js vs php 
    优点:
    01.性能高
    02.开发效率高(优化的量少)
    03.应用范围广(可以开发桌面系统:electorn框架)

    缺点:
    01.新、人少
    02.中间件少
    03.IDE不完善

    5.node请求静态服务器

    var http=require("http");//http是node中自带的对象,利用require导入
    	http.createServer(function(request,response){
    		response.writeHead(200,{"Content-Type":"text/html;charset=utf-8"});
    		console.log("访问");
    		response.write("hello world");
    		response.end("你好,世界!");
    	}).listen(8000);
    	console.log("Server running at http://127.0.0.1:8000/");

    6.node模块化开发和commonJS规范
    01模块引用
        exports.add=function (num1,num2){
            alert(num1+num2);
        }//模块对外提供的接口,假设存放在add.js中

        var obj=require("./add.js");//模块引用
        // 赋值的意义在于,js中将仅能识别obj,因为这是已经定义的变量,并不能识别./add.js

        obj.add(3,5);//正确的调用方法

    02模块定义
    module对象:在每一个模块中,module对象代表该模块自身。
    export属性:module对象的一个属性,它向外提供接口。

    03模块标识
    模块标识指的是传递给require方法的参数,必须是符合小驼峰命名的字符串,或者以  . 或 .. 开头的相对路径,或者绝对路径。

    展开全文
  • nodejs简介

    万次阅读 多人点赞 2018-11-28 15:32:36
    nodejs ES6常用新语法 前言 是时候学点新的JS了! 为了在学习NodeJs之前,能及时用上语言的新特性,我们打算从一开始先学习一下JavaScript语言的最基本最常用新语法。本课程的内容,是已经假设你有过一些JavaScript...

    nodejs

    ES6常用新语法

    前言

    是时候学点新的JS了!

    为了在学习NodeJs之前,能及时用上语言的新特性,我们打算从一开始先学习一下JavaScript语言的最基本最常用新语法。本课程的内容,是已经假设你有过一些JavaScript的使用经验的,并不是纯粹的零基础。

    ES6新语法

    什么是ES6?

    由于JavaScript是上个世纪90年代,由Brendan Eich在用了10天左右的时间发明的;虽然语言的设计者很牛逼,但是也扛不住"时间紧,任务重"。因此,JavaScript在早期有很多的设计缺陷;而它的管理组织为了修复这些缺陷,会定期的给JS添加一些新的语法特性。JavaScript前后更新了很多个版本,我们要学的是ES6这个版本。

    ES6是JS管理组织在2015年发布的一个版本,这个版本和之前的版本大不一样,包含了大量实用的,拥有现代化编程语言特色的内容,比如:Promise, async/await, class继承等。因此,我们可以认为这是一个革命性的版本。

    环境搭建

    • 官网:

    • 下载nodejs, 并安装

    定义变量

    • 使用const来定义一个常量,常量也就是不能被修改,不能被重新赋值的变量。

    • 使用let来定义一个变量,而不要再使用var了,因为var有很多坑;可以认为let就是修复了bug的var。比如,var允许重复声明变量而且不报错;var的作用域让人感觉疑惑。

    • 最佳实践:优先用const,如果变量需要被修改才用let;要理解目前很多早期写的项目中仍然是用var。​

       	// 定义常量
          	const index = 1
          	// 定义变量
          	let num = 5
          	num = 6
    
       	let age = 18
       	//100 行代码
       	// 下面的代码,执行的时候会报错,不允许同一个变量重复声明
       	// 如果是var就不会报错
       	// let age=20
       	
       // 如果使用var声明i,在for循环的外面可以访问到i
       // 如果使用let声明i,在for循环的外面访问不到i
       for (let i = 0; i < 10; i++) {
           console.log(i)
       }
       
       console.log("for循环外部的值:" + i)
    

    解构赋值

    ES6 允许我们按照一定模式,从数组和对象中提取值,对变量进行赋值,这被称为解构(Destructuring)

    • 数组的解构赋值

      	const arr = [1, 2, 3] //我们得到了一个数组
      	  let [a, b, c] = arr //可以这样同时定义变量和赋值
      	  console.log(a, b, c); // 1 2 3	
      
    • 对象的解构赋值(常用)

    		  const obj = { name: '俊哥',address:'深圳', age: '100'} //我们得到了一个对象
    		  let {name, age} = obj //可以这样定义变量并赋值
    		  console.log(name, age); //俊哥 100
    
    • 函数参数的解构赋值(常用)
    		  const person = { name: '小明', age: 11}
    		  function printPerson({name, age}) { // 函数参数可以解构一个对象
    		      console.log(`姓名:${name} 年龄:${age}`);
    		  }
    		  printPerson(person) // 姓名:小明 年龄:11
    
    

    函数扩展

    ES6 对函数增加了很多实用的扩展功能。

    • 参数默认值,从ES6开始,我们可以为一个函数的参数设置默认值

      function foo(name, address = '深圳') {
      	      console.log(name, address);
      	  }
      	  foo("小明") // address将使用默认值
      
      
    • 箭头函数,将function换成=>定义的函数,就是箭头函数

    		function getSum(x, y) {
    		    return x + y;
    		}
    		
    		// 箭头函数
    		// let getSum2=(x, y)=> {
    		//     return x + y;
    		// }
    		// 箭头函数简写,只能用在函数体只有一行代码的情况
    		let getSum2=(x, y)=> x + y;let result = getSum(1, 2);
    		// 自执行函数,定义函数以后,立刻调用函数,代码可读性比较差,不推荐这种写法
    		console.log(
    		    ((x, y)=> x + y)(1,2)
    		)
    

    Class继承

    由于js一开始被设计为函数式语言,万物皆函数。所有对象都是从函数原型继承而来,通过继承某个函数的原型来实现对象的继承。但是这种写法会让新学者产生疑惑,并且和传统的OOP语言差别很大。ES6 封装了class语法来大大简化了对象的继承。

    		class Person {
    		    constructor(name, age){
    		        this.name = name
    		        this.age = age
    		    }
    		    // 注意:没有function关键字
    		    sayHello(){
    		        console.log(`大家好,我叫${this.name}`);
    		    }
    		}
    		class Man extends Person{
    		    constructor(name, age){
    		        super(name, age)
    		    }
    		    //重写父类的方法
    		    sayHello(){
    		        console.log('我重写了父类的方法!');
    		    }
    		}
    		let p = new Person("小明", 33) //创建对象
    		p.sayHello() // 调用对象p的方法,打印 大家好,我叫小明
    		let m = new Man("小五", 33)
    		m.sayHello() // 我重写了父类的方法!
    
    

    总结

    ES6 的新语法有很多,有人将它总结为了一本书。当然,ES6提出的只是标准,各大浏览器和node基本实现了90%以上的新特性,极其个别还没有实现。我们目前讲的是最基本的一些语法,由于你们还未了解同步和异步的概念;Promise和async/await的内容将会在后面的课程中讲解。

    学习资源

    ES6 入门教程http://es6.ruanyifeng.com/

    各大浏览器的支持程度http://kangax.github.io/compat-table/es6/

    Node的发展历史和异步IO机制

    浏览器之战

    随着互联网的不断普及和Web的迅速发展,几家巨头公司开始了浏览器之战。微软推出了IE系列浏览器,Mozilla推出了Firefox浏览器,苹果推出了Safari浏览器,谷歌推出了Chrome浏览器。其中,微软的IE6由于推出的早,并和Windows系统绑定,在早期成为了浏览器市场的霸主。没有竞争就没有发展。微软认为IE6已经非常完善,几乎没有可改进之处,就解散了IE6的开发团队。而Google却认为支持现代Web应用的新一代浏览器才刚刚起步,尤其是浏览器负责运行JavaScript的引擎性能还可提升10倍,于是自己偷偷开发了一个高性能的Javascript解析引擎,取名V8,并且开源。在浏览器大战中,微软由于解散了最有经验、战斗力最强的浏览器团队,被Chrome远远的抛在身后。。。

    ![]

    Node的诞生

    浏览器大战和Node有何关系?

    话说有个叫Ryan Dahl的歪果仁,他的工作是用C/C++写高性能Web服务。对于高性能,异步IO、事件驱动是基本原则,但是用C/C++写就太痛苦了。于是这位仁兄开始设想用高级语言开发Web服务。他评估了很多种高级语言,发现很多语言虽然同时提供了同步IO和异步IO,但是开发人员一旦用了同步IO,他们就再也懒得写异步IO了,所以,最终,Ryan瞄向了JS。因为JavaScript是单线程执行,根本不能进行同步IO操作,只能使用异步IO。

    另一方面,因为V8是开源的高性能JavaScript引擎。Google投资去优化V8,而他只需拿来改造一下。

    于是在2009年,Ryan正式推出了基于JavaScript语言和V8引擎的开源Web服务器项目,命名为Node.js。虽然名字很土,但是,Node第一次把JavaScript带入到后端服务器开发,加上世界上已经有无数的JavaScript开发人员,所以Node一下子就火了起来。

    浏览器端JS和Node端JS的区别

    相同点就是都使用了Javascript这门语言来开发。

    浏览器端的JS,受制于浏览器提供的接口。比如浏览器提供一个弹对话框的Api,那么JS就能弹出对话框。浏览器为了安全考虑,对文件操作,网络操作,操作系统交互等功能有严格的限制,所以在浏览器端的JS功能无法强大,就像是压在五行山下的孙猴子。

    NodeJs完全没有了浏览器端的限制,让Js拥有了文件操作,网络操作,进程操作等功能,和Java,Python,Php等语言已经没有什么区别了。而且由于底层使用性能超高的V8引擎来解析执行,和天然的异步IO机制,让我们编写高性能的Web服务器变得轻而易举。Node端的JS就像是被唐僧解救出来的齐天大圣一样,法力无边。

    理解NodeJS的事件驱动和异步IO

    NodeJS在用户代码层,只启动一个线程来运行用户的代码。每当遇到耗时的IO操作,比如文件读写,网络请求,则将耗时操作丢给底层的事件循环去执行,而自己则不会等待,继续执行下面的代码。当底层的事件循环执行完耗时IO时,会执行我们的回调函数来作为通知。

    同步就是你去银行排队办业务,排队的时候啥也不能干(阻塞);异步就是你去银行用取号机取了一个号,此时你可以自由的做其他事情,到你的时候会用大喇叭对你进行事件通知。而银行系统相当于底层的事件循环,不断的处理耗时的业务(IO)。

    但是NodeJs只有一个线程用来执行用户代码,如果耗时的是CPU计算操作,比如for循环100000000次,那么在循环的过程中,下面的代码将会无法执行,阻塞了唯一的一个线程。所以,Node适合大并发的IO处理,不适合CPU密集型的计算操作。Web开发大部分都是耗时IO操作,所以Node非常适合进行Web开发。如果真的遇到了CPU密集的计算,比如从1亿个用户中计算出哪些人和你兴趣相投的这个功能,就非常耗CPU,那这个功能就交由C++,C,Go,Java这些语言实现。像淘宝,京东这种大型网站绝对不是一种语言就可以实现的。

    语言只是工具,让每一种语言做它最擅长的事,才能构建出稳定,强大的系统。

    NodeJs能做什么?

    NodeJs常用模块

    前言

    在浏览器端写JS,其实就是使用浏览器给我们提供的功能和方法来写代码。

    在Node端写JS,就是用Node封装好的一系列功能模块来写代码。NodeJS封装了网络,文件,安全加密,压缩等等很多功能模块,我们只需要学会常用的一些,然后在需要的时候去查询文档即可。

    API:

    npm介绍

    官网

    npm是Nodejs自带的包管理器,当你安装Node的时候就自动安装了npm。通俗的讲,当我们想使用一个功能的时候,而Node本身没有提供,那么我们就可以从npm上去搜索并下载这个模块。每个开发语言都有自己的包管理器,比如,java有maven,python有pip。而npm是目前世界上生态最丰富,可用模块最多的一个社区,没有之一。基本上,你所能想到的功能都不用自己手写了,它已经在npm上等着你下载使用了。

    npm的海量模块,使得我们开发复杂的NodeJs的程序变得更为简单。

    学习2个知识点:

    • 怎么生成package.json
    • 怎么从npm安装包,并保存到package.json文件中?

    全局变量

    全局变量是指我们在任何js文件的任何地方都可以使用的变量。

    • __dirname:当前文件的目录
    • __filename:当前文件的绝对路径
    • console:控制台对象,可以输出信息
    • process:进程对象,可以获取进程的相关信息,环境变量等
    • setTimeout/clearTimeout:延时执行
    • setInterval/clearInterval:定时器

    示例代码

    		// 获取进程信息
    		// console.log(global.process)
    		// 获取当前文件夹路径
    		console.log(__dirname)
    		// 获取当前文件的绝对路径
    		console.log(__filename)
    		// 开始标记
    		// console.time("timer")
    		// setTimeout(()=>{
    		//     console.log("一秒后开始执行")
    		// },1000)
    		// 结束标记
    		// console.timeEnd("timer")
    		
    		// setInterval(()=>{
    		//     console.log("执行")
    		// },1000)
    

    path模块

    path模块供了一些工具函数,用于处理文件与目录的路径

    • path.basename:返回一个路径的最后一部分
    • path.dirname:返回一个路径的目录名
    • path.extname:返回一个路径的扩展名
    • path.join:用于拼接给定的路径片段
    • path.normalize:将一个路径正常化

    示例代码

    	let path = require("path");
    	
    	// 获取路径当中的最后一部分
    	let basename = path.basename(__dirname);
    	
    	console.log(basename)
    	
    	// 获取上一级目录的路径
    	let dirname = path.dirname(__filename);
    	console.log(dirname)
    	
    	// 获取后缀名
    	let extname = path.extname("a.jpg");
    	console.log(extname)
    	// 拼接路径
    	let join = path.join("D:", "aa", "bb", "c.txt");
    	console.log(join)
    	// 标准化路径
    	let normalize = path.normalize("D:/aa//bb/c.txt");
    	console.log(normalize)
    
    

    fs模块

    文件操作相关的模块

    • fs.stat/fs.statSync:访问文件的元数据,比如文件大小,文件的修改时间

    示例代码

    	let fs = require("fs");
    	// 获取文件的属性
    	fs.stat("a.txt", (err, stats) => {
    	
    	    if (err) {
    	        console.log(err)
    	        return
    	    }
    	
    	    console.log(stats.birthtime)
    	    console.log(stats.isFile())
    	    console.log(stats.isDirectory())
    	
    	})
    
    - `fs.readFile/fs.readFileSync`:异步/同步读取文件
    
    - `fs.writeFile/fs.writeFileSync`:异步/同步写入文件
    

    示例代码

    	let fs = require("fs");
    	
    	// 读取文件
    	// fs.readFile("a.txt", (err, data) => {
    	//     if (err) {
    	//         throw err;
    	//     }
    	//
    	//     console.log(data.toString())
    	// })
    	// 写入文件
    	fs.writeFile("b.txt", "这是我使用API生成的文件内容", (err) => {
    	    if (err) {
    	        throw err;
    	    }
    	})
    
    - `fs.readdir/fs.readdirSync`:读取文件夹内容
    
    > 示例代码
    
    	let fs = require("fs");
    	let path = require("path");
    	let dirName = "aa";
    	// 读取文件夹中的内容(获取到的是文件夹中文件的名字)
    	fs.readdir(dirName, (err, files) => {
    	    if (err) {
    	        throw err
    	    }
    	    // 遍历文件夹中的内容,
    	    files.forEach((fileName) => {
    	        // 拼接文件路径
    	        let absPath = path.join(dirName, fileName);
    	        // 获取文件属性
    	        fs.stat(absPath, (err, stats) => {
    	            if (err) {
    	                throw err
    	            }
    	            console.log(fileName + "是否是文件夹:" + stats.isDirectory())
    	        })
    	    })
    	})
    
    - `fs.unlink/fs.unlinkSync`:删除文件
    
    - `fs.rmdir/fs.rmdirSync`:只能删除空文件夹,思考:如何删除非空文件夹?
    
      > 使用`fs-extra` 第三方模块来删除。
    
    
    > 示例代码
    
    	let fs = require("fs");
    	let fs2 = require("fs-extra");
    	// 删除文件
    	// fs.unlink("aa/a.txt", (err) => {
    	
    	//     console.log(err)
    	// })
    	// 删除文件夹
    	// fs.rmdir("aa", (err) => {
    	//     if (err) {
    	//         console.log(err)
    	//     }
    	// })
    	// 使用第三方模块删除文件
    	// fs2.remove("aa", (err) => {
    	//     if (err) {
    	//         throw err
    	//     } else {
    	//         console.log("success")
    	//     }
    	// })
    	// 同步方式读取文件
    	let readFileSync = fs.readFileSync("demo10_read_dir.js");
    	console.log(readFileSync.toString())
    
    - `fs.watchFile`:监视文件的变化
    
    > 示例代码
    
    	let fs = require("fs");
    	fs.watchFile("a.txt", {interval: 100}, (current, previous) => {
    	    console.log("current:" + current.mtime)
    	    console.log("previous:" + previous.mtime)
    	})
    

    stream操作大文件

    传统的fs.readFile在读取小文件时很方便,因为它是一次把文件全部读取到内存中;假如我们要读取一个3G大小的电影文件,那么内存不就爆了么?node提供了流对象来读取大文件。

    流的方式其实就是把所有的数据分成一个个的小数据块(chunk),一次读取一个chunk,分很多次就能读取特别大的文件,写入也是同理。这种读取方式就像水龙头里的水流一样,一点一点的流出来,而不是一下子涌出来,所以称为流。

    	let fs = require("fs");
    	// fs.readFile("ideaIU-2018.1.5.win.zip", (err, data) => {
    	//     if (err) {
    	//         throw err
    	//     }
    	//
    	//     console.log(data.toString())
    	// })
    	
    	// 读取大文件
    	let readStream = fs.createReadStream("ideaIU-2018.1.5.win.zip");
    	// 写入大文件
    	let writeStream = fs.createWriteStream("a.zip");
    	// let len = 0;
    	// readStream.on("data", (chunk) => {
    	//     len += chunk.length
    	//     // console.log(chunk.length)
    	//     writeStream.write(chunk)
    	// })
    	//
    	// readStream.on("end", () => {
    	//     console.log("文件读取完成," + len)
    	// })
    	
    	readStream.pipe(writeStream)		
    
    

    任务:用以下知识点完成大文件的拷贝。

    • fs.createReadStream/fs.createWriteStream
    • reader.pipe(writer)

    Promise和asnyc/await

    我们知道,如果我们以同步的方式编写耗时的代码,那么就会阻塞JS的单线程,造成CPU一直等待IO完成才去执行后面的代码;而CPU的执行速度是远远大于硬盘IO速度的,这样等待只会造成资源的浪费。异步IO就是为了解决这个问题的,异步能尽可能不让CPU闲着,它不会在那等着IO完成;而是传递给底层的事件循环一个函数,自己去执行下面的代码。等磁盘IO完成后,函数就会被执行来作为通知。

    虽然异步和回调的编程方式能充分利用CPU,但是当代码逻辑变的越来越复杂后,新的问题出现了。请尝试用异步的方式编写以下逻辑代码:

    先判断一个文件是文件还是目录,如果是目录就读取这个目录下的文件,找出结尾是txt的文件,然后获取它的文件大小。

    示例代码

    	function withoutpromise() {
    	    // 获取文件属性
    	    fs.stat(dirName, (err, stats) => {
    	        if (err) {
    	            throw err
    	        }
    	        // 如果是文件夹
    	        if (stats.isDirectory) {
    	            // 读取文件夹
    	            fs.readdir(dirName, (err, files) => {
    	
    	                if (err) {
    	                    throw err
    	                }
    	                // 遍历文件
    	                files.forEach((fileName) => {
    	                    // 获取后缀名
    	                    let extname = path.extname(fileName);
    	                    // 如果是txt文件
    	                    if (extname === ".txt") {
    	                        // 获取文件属性
    	                        fs.stat(path.join(dirName, fileName), (err, stats) => {
    	                            if (err) {
    	                                throw err
    	                            }
    	                            // 获取文件大小
    	                            console.log(fileName + "  =  " + stats.size)
    	                        })
    	                    }
    	
    	                })
    	            })
    	        }
    	    })
    	}
    

    恭喜你,当你完成上面的任务时,你已经进入了终极关卡:Callback hell回调地狱!

    为了解决Callback hell的问题,Promiseasync/await诞生。

    • promise的作用是对异步回调代码包装一下,把原来的一个回调函数拆成2个回调函数,这样的好处是可读性更好。语法如下:

      语法注意:Promise内部的resolve和reject方法只能调用一次,调用了这个就不能再调用了那个;如果调用,则无效。

    	let promise = new Promise((resolve, reject) => {
    	    //resolve: 代码执行过程中没有发生异常,正常执行的时候,会调用的方法
    	    //reject: 代码执行过程中发生了异常的时候,会调用的方法
    	    fs.readFile("aa/a1.txt", (err, data) => {
    	        if (err) {
    	            reject(err)
    	        } else {
    	            resolve(data)
    	        }
    	    })
    	});
    	
    	promise.then((data) => {
    	    console.log("代码正常执行了," + data)
    	}).catch((err) => {
    	    console.log("代码执行过程中发生了异常,"+err)
    	})
    • async/await的作用是直接将Promise异步代码变为同步的写法,注意,代码仍然是异步的。这项革新,具有革命性的意义。

      语法要求:

      • await只能用在async修饰的方法中,但是有async不要求一定有await
      • await后面只能跟async方法和promise

      假设拥有了一个promise对象,现在使用async/await可以这样写:

      	async function asyncDemo() {
      	
      	    try {
      	        // 当promise的then方法执行的时候
      	        let data = await promise;
      	        console.log(data.toString())
      	    } catch (e) {
      	        console.log("捕获到的异常:" + e)
      	    }
      	
      	}
      	
      	asyncDemo()
      
      
    **小任务**
    

    使用promise和async/await来重写上面的逻辑代码,来感受一下强大的力量吧!。

    • 示例代码
    
       async function withPromise() {// 把fs.stat方法转换为一个可以返回promise对象的方法let pStat = util.promisify(fs.stat);// 获取文件属性let stats = await pStat(dirName);// 如果是文件夹if (stats.isDirectory) {// 把fs.readdir方法转换为一个可以返回promise对象的方法let pReaddir = util.promisify(fs.readdir);// 读取文件夹let files = await  pReaddir(dirName)// 遍历文件
       ​	        files.forEach(async (fileName) => {// 获取后缀名let extname = path.extname(fileName);
       ​	
       ​	            if (extname === ".txt") {let statsFile = await  pStat(path.join(dirName, fileName));// 获取文件大小
       ​	                console.log(fileName + "  =  " + statsFile.size)}
       ​	
       ​	        })}}withPromise()
    

    异步代码的终极写法:

    1. 先使用promise包装异步回调代码,可使用node提供的util.promisify方法;
    2. 使用async/await编写异步代码。

    http 模块

    封装了http server 和 client的功能,就是说可以充当server处理请求,也可以发出请求。

    • http.createServer:创建server对象
      let http = require("http");let fs = require("fs");let server = http.createServer((request, response) => {
      ​	
      ​	    let url = request.url;
      
      
      ​	
      	    response.writeHead(200, {'Content-Type': 'text/html;charset=utf-8'});
      	    console.log("收到了请求")
      	    // 返回普通字符串
      	    // response.end("你好")
      	
      	    let person = {
      	        name: "zhangsan",
      	        age: 20
      	    }
      	    // 输出json字符串
      	    //  response.end(JSON.stringify(person))
      	
      	    if (url == "/a") {
      	        let readFileSync = fs.readFileSync("a.html");
      	        response.end(readFileSync)
      	    } else if (url == "/b") {
      	        let readFileSync = fs.readFileSync("b.html");
      	        response.end(readFileSync)
      	    }})
      
      server.listen(8000)
      
    • http.get:执行http get请求
    		let http = require("http");
    	​	
    	​	http.get("http://www.baidu.com", (response) => {
    	​	
    	​	    let data;
    	​	    response.on("data", (chunk) => {
    	​	        data += chunk.toString();})
    	​	
    		    response.on("end", () => {
    		        console.log(data)
    		    })
    		})
    
    

    【案例】文件浏览服务器

    功能需求:启动一个服务,当用户访问服务时,给用户展示指定目录下的所有文件;如果子文件是目录,则能继续点进去浏览。

    ​		
    ​		let http = require("http");let fs = require("fs");let path = require("path");
    
    
    ​		
    ​		let server = http.createServer((request, response) => {
    ​		
    ​		    showDir(request, response)})// 绑定端口
    ​		server.listen(8000)// 显示文件夹中的内容
    		function showDir(request, response) {
    		    // 获取请求路径
    		    let url = request.url;
    		
    		    let dirPath = "aa";
    		    // 如果请求的不是根目录,获取用户的请求路径
    		    if (request.url != "/") {
    		        dirPath = request.url
    		        dirPath = dirPath.substring(1, dirPath.length)
    		    }
    		    // 读取文件夹
    		    fs.readdir(dirPath, (err, files) => {
    		        // 有异常,向外抛出
    		        if (err) {
    		            throw err
    		        }
    		        // 拼接数据
    		        let data = "";
    		        files.forEach(fileName => {
    		            // 拼接路径
    		            let joinPath = path.join(dirPath, fileName);
    		            // 获取属性
    		            let stats = fs.statSync(joinPath);
    		            // 如果是文件夹,拼接a标签
    		            if (stats.isDirectory()) {
    		                data += `<li><a href="${joinPath}"> ${fileName}</a></li>`
    		            } else {
    		                // 不是文件夹,不拼a标签
    		                data += `<li>${fileName}</li>`
    		            }
    		        })
    		        response.end(buildHTML(data))
    		    })
    		}
    		
    		// 用于生成html页面
    		function buildHTML(data) {
    		    return `<!DOCTYPE html>
    		<html lang="en">
    		<head>
    		    <meta charset="UTF-8">
    		    <title>Title</title>
    		    <style>
    		    *{
    		    padding: 0;
    		    margin: 0;
    		    }
    		    
    		    li{
    		    list-style: none;
    		    padding: 0.5em 1em;
    		    background-color:#ddd;
    		    border-top: 1px solid #eee;
    		    }
    		    
    		    li:hover{
    		    background-color:#aaa;
    		    }
    		</style>
    		</head>
    		<body>
    		<ul>
    		${data}
    		</ul>
    		</body>
    		</html>`
    		}
    
    展开全文
  • Node.js介绍、优势、用途

    万次阅读 2018-11-07 11:21:50
    一、Node.js介绍 Node.js是一个javascript运行环境。它让javascript可以开发后端程序,实现几乎其他后端语言实现的所有功能,可以与PHP、Java、Python、.NET、Ruby等后端语言平起平坐。 Nodejs是基于V8引擎,V8是...

    一、Node.js介绍

    Node.js是一个javascript运行环境。它让javascript可以开发后端程序,实现几乎其他后端语言实现的所有功能,可以与PHP、Java、Python、.NET、Ruby等后端语言平起平坐。

    Nodejs是基于V8引擎,V8是Google发布的开源JavaScript引擎,本身就是用于Chrome浏览器的js解释部分,但是Ryan Dahl 这哥们,鬼才般的,把这个V8搬到了服务器上,用于做服务器的软件。

    二、node.js的优势

    1、Nodejs语法完全是js语法,只要你懂js基础就可以学会Nodejs后端开发

    Node打破了过去JavaScript只能在浏览器中运行的局面。前后端编程环境统一,可以大大降低开发成本。

    2、NodeJs超强的高并发能力

    NodeJs的首要目标是提供一种简单的、用于创建高性能服务器及可在该服务器中运行的各种应用程序的开发工具。

    首先让我们来看一下现在的服务器端语言中存在着什么问题。在Java、PHP或者.NET等服务器语言中,会为每一个客户端连接创建一个新的线程。而每个线程需要耗费大约2MB内存。也就是说,理论上,一个8GB内存的服务器可以同时连接的最大用户数为4000个左右。要让web应用程序支持更多的用户,就需要增加服务器的数量,而web应用程序的硬件成本当然就上升了。

    NodeJs不为每个客户连接创建一个新的线程,而仅仅使用一个线程。当有用户连接了,就触发一个内部事件,通过非阻塞I/O、事件驱动机制,让Node.js程序宏观上也是并行的。使用Node.js,一个8GB内存的服务器,可以同时处理超过4万用户的连接。

    3、实现高性能服务器

    严格地说,Node.js是一个用于开发各种web服务器的开发工具。在Node.js服务器中,运行的是高性能V8 JavaScript脚本语言,该语言是一种可以运行在服务器端的脚本语言。

    那么,什么是V8 JavaScript脚本语言呢?该语言是一种被V8 JavaScript引擎所解析并执行的脚本语言。V8 JavaScript引擎是由Google公司使用C++语言开发的一种高性能JavaScript引擎,该引擎并不局限于在浏览器中运行。Node.js将其转用在了服务器中,并且为其提供了许多附加的具有各种不同用途的API。例如,在一个服务器中,经常需要处理各种二进制数据。在JavaScript脚本语言中,只具有非常有限的对二进制数据的处理能力,而Node.js所提供的Buffer类则提供了丰富的对二进制数据的处理能力。

    另外,在V8 JavaScript引擎内部使用一种全新的编译技术。这意味着开发者编写的高端的 JavaScript 脚本代码与开发者编写的低端的C语言具有非常相近的执行效率,这也是Node.js服务器可以提供的一个重要特性。

    4、开发周期短、开发成本低、学习成本低

    Node.js自身哲学,是话最小的硬件成本,追求更高的并发,更高的处理性能。

    三、Node.js能干什么

    看图:

     

     

    展开全文
  • NODE介绍

    2020-09-27 21:43:51
    文章目录一.NODE二.NODE的简单操作三.NODE的文件操作 一.NODE node中文网 什么是node? 1.Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境,一个后端语言,没有DOM和BOM 2.Node就是用 javascript 语言写 ...

    一.NODE

    • 学习目标 node + mongodb + vue + element-ui 后台管理系统
    • node中文网
    • 什么是node?
      • 1.Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境,一个后端语言,没有DOM和BOM
      • 2.Node就是用 javascript 语言写 后端,有了它,js不仅是前端语言,更是后端语言
      • 3.Node的核心是ECMAScript,操作后端代码及数据库,不用考虑兼容,只关注业务逻辑
      • 4.Node的特点是一个异步编程,合理分配资源,合理处理高并发,很少后台全部用nodejs

    二.执行NODE的方式

    • 1.推荐的是 普通使用cmd方式
      • 在搜索中 输入cmd
      • 按window + r 弹出命令行
    • 2.项目上是 在编辑器中运行cmd,执行node.js程序
      • ctrl + 反引号 在vscode中
    • 3.使用window自带的模拟cmd的程序 powerShell
      • 在文件夹中,按住shift,鼠标点击空白处,点击powerShell选项

    三.NODE的简单操作

    • 运行node:node 文件名
    • 查看node版本:node -vnode --version
    • 进入目录:cd cd 文件名
    • 切换盘符:c: 直接盘符+:
    • 查看目录: linux系统ls,windows系统dir
    • 返回上一层:cd..
    • 退出:两次ctrl + c

    四.NODE的简单操作(其它)

    • 把当前屏幕的所有内容都清除cls
    • 查看当前电脑的 IP 信息ipconfigipconfig/all
    • 测试某一个链接地址的网速ping www.baidu.com
    • 查看当前电脑的信息systeminfo
    • 以结构树/树状结构 形式输出文件夹内容 tree
    • 查看所有的操作指令:npm -help
      npm中的具体操作见:npm、cnpm、gulp、nrm的应用

    五.NODE的文件操作

    • 1.新建文件夹 md + 文件夹名称
    • 2.移除文件夹:rd 文件夹名称或强行删除文件rd/s/q
    • 3.复制文件夹: 表示复制一份 test 文件夹起名为 test2
      • $ xcopy test test2
    • 4.创建文件:表示在当前目录下创建一个叫做 index.js 的文件
      • $ type nul> index.js
    • 5.拷贝一份文件:表示复制一份 index.js 文件起名为 ceshi.js
      • $ copy index.js ceshi.js
    • 6.向文本中写入内容:表示向 index.js 中写入一段文本 console.log(‘hello world’)
      • $ echo console.log("hello world") > index.js
    • 7.查看文件内的文本内容:表示查看 index.js 文件中的文本内容是什么
      • $ type index.js
    • 8.给文件或者目录重命名:表示把 index.js 更名为 abc.js
      • $ ren index.js abc.js
    • 9.删除文件:表示把当前目录下的 index.js 删除
      • $ del index.js
    • 10.移动文件或文件夹:表示把当前目录下的 index.js 文件移动到当前目录下的 a 文件夹下
      • $ move index.js a

    六.NODE的学习核心

    • 1.核心模块,
    • 2.commonjs规范,
    • 3.引入规则,
    • 4.express ,
    • 5.跨域 ,
    • 6.请求区别,
    • 7.toiken cookie
    • 8.上传文件 上传图片,
    • 9.express + 数据库 (mysql or mongodb),
    • 10.聊天网站 (实时通讯) (聊天室)

    七.创建package.json

    • 创建package.json:npm init -y

    八.NODE 的导入导出

    导入(加载)

    • 在 node 里面,我们使用 require 来导入一个文件
    • 直接加载模块名字 require(“模块名字”)
    • 相对路径加载 有加 ./
    • 绝对路径加载 __dirname (获取绝对路径的当前目录) 盘符 : //
    # 创建一个index.js文件,在里面也写写内容
    const  a = require('./a.js')
    console.log(a)
    

    导出

    • 在node里面,我们用module.exports来导出一个文件
    # 每一个 js 文件都会有一个对象叫做 module
    # 在 module 里面有一个成员,叫做 exports
    # 每一个 js 文件会默认把 module.exports 导出,我们向 module.exports中添加内容
    //创建一个文件a.js
    module.exports.name = 'Jack'
    module.exports.age = 18
    # 将来这个文件被导入的时候,接受到的内容就是一个对象,里面有两个成员
    // 我是 index.js
    const a = require('./a.js')
    console.log(a) // { name: 'Jack', age: 18 }
    

    九.模块化

    • 模块分为三种
      • 1.内置模块 (node 天生就带有的模块,也是核心的模块)
      • 2.自定义模块 (我们自己写的文件)
      • 3.第三方模块 (从网上下载的别人写好的模块)

    9.1内置模块

    9.1.1 FS 模块

    • fs 是 node 的一个内置模块,专门用来操作文件的,使用的时候直接导入就可以使用了

    9.1.1.2FS 模块的创建

    • 建立一个fs模块对象/导入执行fs模块的功能const fs = require('fs')

    9.1.1.3FS 模块的读取

    • 语法: fs对象.readFile( 文件路径 , 编码格式(选填) , 回调函数 )
      • 文件路径 : 是相对路径,从当前js文件开始的相对路径

      • 编码格式 : 是读取文件的编码格式,一般是 utf8

        • 如果不需要编码格式,输出时,在cmd中会显示默认的buffer格式
        • 只是影响cmd中显示的格式,不影响读取内容的编码格式
      • 回调函数 : 读取完成时,执行的回调函数,一般没有什么用,但是必须设定

        • 参数1,存储报错信息,读取成功,报错信息是null
        • 参数2,存储读取信息,读取失败,读取信息是undefined
      • fs.readFile(’./demo.js’ , ‘utf8’ , function(参数1,参数2){})

    9.1.1.4 FS 模块的写入

    • 语法: fs.writeFile(写入文件的路径 , 写入的内容 , 写入成功的回调函数)
      • 说明: 写入的内容,是全覆盖写入,会覆盖文件中的原始内容

        • 如果写入目标文件存在,会向目标文件中,写入内容
        • 如果写入目标文件不存在,会自己建立一个目标文件,写入内容
      • 写入文件内容,程序的执行,一定是成功的

      • fs.writeFile(’./text1.txt’ , ‘我是写入的内容’ , function(){})

    9.1.1.5 FS 模块同步的写入操作
    • node.js都是异步操作 同步写入操作
    • fs.writeFileSync(‘你要写入的文件’ , 你要写入的内容 , 回调函数)
    • 实际项目中一般都是 向文件中 追加内容
    • 读取原始内容,拼接要写入的内容,再将最终的结果,写入到文件中

    9.1.1.6异步读取文件内容

    const fs = require('fs')
    
    // 因为是异步读取,所以要在回调函数里面获取结果
    fs.readFile('./text.txt', 'utf8', function (err, data) {
        // err 表示读取的时候出现的错误
        // data 表示读取到的内容,如果出现错误,那么是 data 是没有内容的
    })
    

    9.1.1.7同步读取文件内容

    const fs = require('fs')
    // 因为是同步读取,所以直接以返回值的形式接收读取的内容就可以
    const res = fs.readFileSync('./text.txt', 'utf8')
    // 同步读取的时候,如果出错会直接在控制台报错,并中断程序继续执行
    // 如果没有错误,res 就会得到文件中的内容
    

    9.1.1.8异步写入文件

    const fs = require('fs')
    // 写入内容的时候,一般不会出现错误
    // 因为如果没有这个文件的话,会创建一个这个文件在向里面写入内容
    // 所以回调函数一般没什么用处,只不过是在写入文件结束后做些事情而已
    // 虽然没有用处,但是必须要写
    fs.writeFile('./text.txt', '我是要写入的内容', function () {
        console.log('写入完成')
    })
    

    9.1.1.9同步写入文件

    const fs = require('fs')
    // 因为是写入文件
    // 没有返回值,因为一般都会写入成功
    fs.writeFileSync('./text.txt', '我是要写入的内容')
    

    9.1.2HTTP 模块

    • 因为 node 是一个服务端语言,需要用http来开启一个服务,直接使用就可以
    • 作用:专门用于搭建服务器的内置模块

    9.1.2.1HTTP 模块的写法解释

    # 导入一个http内置模块
    const http = require('http')
    # 创建一个服务
    //这个服务默认监听 http 协议,这个服务默认监听 localhost 域名
    const server = http.createServer(funtion(request, response){
    	 // request  包含着每次的请求信息,也就是地址栏输入的信息
    	 // response 是每次的响应信息, 也就是是每次请求返回的响应内容
    	// 前端发来的每一个请求都会触发这个回调函数
        // 接受到请求以后给出一个响应,
        response.end('hello world')
        //获取请求的地址,也就是要访问的页面
        response.url== '要访问的路径地址'
    })
    # 监听端口
    server.listen(8080,funtion(){
    	// 这个函数会在服务开启成功以后执行
    	console.log('监听端口成功')
    })
    

    9.1.2.2HTTP 模块的简单案例

    • 创建 一个 node.js 简易服务器步骤
    # 1.导入内置模块 http
    const http = require('http');
    # 导入fs模块,用于读取文件
    const fs = require('fs');
    #2.创建服务,并且设定监听端口
    # 创建服务
    const server = http.createServer(function(req , res){
        console.log(req.url);
        // 设定服务器功能
        // 调用方式 -- node.js提供的方式  
        // req.url  获取请求的地址,也就是要访问的页面
        // url是一个属性,不需要()来执行
        // 调用方式 res.end()  表示返回的本次请求的内容
        // end()是一个方法,也就是一个函数,需要()来执行
        // 根据不同的请求地址,返回不同的请求内容
        // 如果要访问的是index.html页面,就返回这个页面的地址
        // 也就是需要有这个页面的地址
        if( req.url == '/index.html' ){
            // 如果需要访问的是index.html文件,那么就获取index.html文件的内容
            fs.readFile('./index.html' , 'utf-8' , function(err,data){
                // 如果报错信息存在,就return 这个报错信息,不执行之后的程序
                // 一般是路径输入错误,要访问的页面不存在
                // 报错信息不是null,证明报错信息存在,返回报错信息
                if(err != null){
                    return console.log(err);
                }
                // 如果没有报错,返回读取到的页面的信息内容
                res.end(data);
            })
        }
    	//----------
        if( req.url == '/cart.html' ){
            fs.readFile('./cart.html' , 'utf8' , function(err,data){
                if(err != null){
                    return console.log(err);
                }
                res.end(data);
            })
        }
        // 还可以有其他的页面
        // cart.html 等
        // 到了3阶段,会在这个基础上,通过框架,来完善服务器的功能
        // 目前就基本了解简单原理即可
    });
    
    # 3.监听端口
    server.listen(8080,function(){
        console.log('监听端口成功');
    })
    

    9.1.3 url 模块

    cosnt url = require("url")
    url.parse(地址,true/false)  // 地址栏转成对象    true表示将query字符串转对象
    url.toString()        // 讲对象转成字符串
    

    9.1.4 path 模块

    path.resolve('资源路径','资源路径')   会拼接绝对路径  会自带 当前跟目录
    path.join() 路径合并  不会携带根目录
    __dirname  获取当前根目录的绝对路径
    
    

    9.1.5 querystring 转换查询字符串

    qs.parse()  //将查询字符串转成对象      name=zzzz&age=20
    qs.stringify()  //将字对象转字符串     
    

    9.2 commonjs规范(模块化规范)

    1 创建模块   创建一个js文件   每一个属性和方法都是私有的
    2 暴露模块   module.exports 
    3 加载模块	 require  
    4 使用模块   使用
    对着 记录  export    default     export 
    		  import    from        import {} from 
    

    9.1.3 自定义模块

    • 就是采用8的导入导出来实现的
    展开全文
  • node介绍

    2020-03-12 09:27:05
    ndoe 是什么? 是一个运行JS的环境。
  • Node介绍

    2020-02-24 20:25:40
    Node是javascript运行环境 Node不是一门语言 Node不是库,不是框架 Node是一个JavaScript运行环境,可以解析和执行JavaScript代码,以前只有浏览器可以解析执行JavaScript代码,现在有了Node,JavaScript可以完全...
  • NodeJS简介-node.js是什么?

    万次阅读 2019-04-05 15:14:34
    node.js是什么本来应该是放在学习之后做的总结,但是在学习一门新语言或新的知识之前,还是应该对其有个大体上的了解,知道她是什么?她适用于哪些应用场景?她的优点及缺点?大体上弄清楚这些之后可以对其有个整体...
  • Nodejs极速入门

    万人学习 2018-10-22 21:38:10
    由King老师精心打造的Nodejs极速入门课程,从Nodejs介绍到环境下载安装,到Express框架的基础使用,用短的时间帮你入门Nodejs! 山哥出品,必属精品!
  • 深入kubernetes调度之NodeSelector

    万次阅读 2017-06-23 17:11:52
    Kubernetes的调度有简单,有复杂,指定NodeName和使用NodeSelector调度是最简单的,可以将Pod调度到期望...本文主要介绍kubernetes调度框架中的NodeName和NodeSelector。1 NodeNamePod.spec.nodeName用于强制约束将Pod
  • CentOS7安装node.js

    万次阅读 2019-08-21 15:42:32
    一、环境介绍 二、安装node.js 一、环境介绍 系统版本:CentOS Linux 7 (Core) 内核版本:Linux version 4.16.13-1.el7.elrepo.x86_64 二、安装node.js 1、确认依赖环境 确认服务器有nodejs编译及依赖相关...
  • Node.js进阶教程第一步(基础篇)

    万人学习 2016-10-08 11:16:55
    本课程从Node.js的安装配置开始,包括函数调用,模块调用,路由,文件操作,异常处理,参数接收,正则表达式,连接数据库,事件等内容,使学员通过十六课时,学习Node.js的基础知识,掌握JS开发服务端的编写方法,...
  • Mac上的Node安装及npm的使用

    万次阅读 2015-08-10 12:34:56
    前文已经介绍了Homebrew,Homebrew传送门 使用Homebrew可以轻松安装nodebrew install node node安装后,会附带npm工具。 npm即node package manager,用来搜索、下载、管理node.js相关的套件。简单介绍下npm使用,在...
  • 介绍Jackson JsonNode和ObjectNode

    万次阅读 2019-09-09 17:51:44
    介绍Jackson JsonNode和ObjectNode Jackson JsonNode类,完整路径为com.fasterxml.jackson.databind.JsonNode,是Jackson的json树模型(对象图模型)。Jackson能读JSON至JsonNode实例,写JsonNode到JSON。本文不涉及...
  • nodejs读取FTP服务器--node-ftp

    万次阅读 2017-01-04 10:47:38
    参考1:http://www.open-open.com/lib/view/open1408006289661.html 简单介绍node-ftp 参考2:http://www.cnblogs.com/meteoric_cry/p/3975176.html 详细用法
  • 前面介绍过基于DFS邻域的DeepWalk和基于BFS邻域的LINE。node2vec则是一种综合考虑dfs邻域和bfs邻域的graph embedding方法。 DeepWalk:算法原理,实现和应用 LINE:算法原理,实现和应用 简单来说,node2vec是...
  • Mac 下安装node.js

    万次阅读 2016-08-30 14:09:32
    Node.js 简介Node.js 是一个用Chrome's V8 JavaScript engine 构建的 JavaScript 运行时框架。Node.js 使用事件驱动、非阻塞式 I/O 模块使得它非常的轻量级和非常的高效。Node.js 生态系统,npm 是世界上最大的开源...
  • NodeMCU针脚说明

    万次阅读 2017-10-25 08:59:13
    NodeMCU DEVKIT V1.0 A development kit for NodeMCU firmware. It will make NodeMCU more easy. With a micro USB cable, you can connect NodeMCU devkit to your laptop and flash it without any trouble
  • nodejs 如何使用 fetch

    万次阅读 2019-02-20 09:42:04
    node 中没有实现 fetch,你可以使用 node-fetch,使得在 node 中也可以使用 fetch. 安装 node-fetch: npm install node-fetch 使用 fetch 之前先加载: const fetch = require('node-fetch') 简单使用方法: fetch...
  • 全面学习vue.js配置,es6命令,解构赋值,symbol类型,set,weakSet,Map,WeakMap,Iterator遍历器,Generator函数结构,Promise对象,async函数,箭头函数,class类,proxy代理,Decorator修饰器,model模块,二进制...
  • 右侧办理会员卡。办会员卡可咨询 QQ 1405491181 。 会员可免费学习已发布的全部课程,和在会员有效期内讲师...【课程介绍】这套课程采用 Node.js / Express.js / React.js / FLUX / mongoosejs 技术开发真实社区项目。
1 2 3 4 5 ... 20
收藏数 277,640
精华内容 111,056
关键字:

node介绍