node 订阅
node(结点):网络连接的端点,或两条(或多条)线路的连接点。结点可以是处理器、控制器或工作站。结点随其功能不同而各不相同,它们可以通过链路互联在一起,在网络中用作控制点。 展开全文
node(结点):网络连接的端点,或两条(或多条)线路的连接点。结点可以是处理器、控制器或工作站。结点随其功能不同而各不相同,它们可以通过链路互联在一起,在网络中用作控制点。
信息
词    性
名词
中文名
结点
外文名
node
含    义
网络连接的端点
释    义
结;节;瘤;茎节
node基本信息
node 英音:[nəud]美音:[nod]名词 n.1. 结;节;瘤;茎节2. 中心点;交叉点3.波节
收起全文
精华内容
参与话题
问答
  • 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方法的参数,必须是符合小驼峰命名的字符串,或者以  . 或 .. 开头的相对路径,或者绝对路径。

    展开全文
  • node-基础 (二)

    千次阅读 2020-06-04 17:50:13
    本文完整介绍 node 对文件的操作 首先我们通过 const fs=require('fs') 引入 fs 操作模块 文件操作 对应于标题中的操作,如下: fs.stat 检测是文件还是目录 fs.stat("./html", (err, data) => { if (err) { ...

    原文博客地址

    藤原拓鞋的博客

    开始

    本文完整介绍 node 对文件的操作

    首先我们通过 const fs=require('fs') 引入 fs 操作模块

    文件操作

    对应于标题中的操作,如下:

    • fs.stat 检测是文件还是目录
    fs.stat("./html", (err, data) => {
      if (err) {
        console.log(err);
        return;
      }
    
      console.log(`是文件:${data.isFile()}`);
      console.log(`是目录:${data.isDirectory()}`);
    });
    
    • fs.writeFile 创建写入文件
    fs.writeFile("./html/index.html", "hello", (err) => {
      if (err) {
        console.log(err);
        return;
      }
      console.log("创建写入文件成功");
    });
    
    • fs.mkdir 创建目录
    fs.mkdir("./css", (err) => {
      if (err) {
        console.log(err);
        return;
      } else {
        console.log("success");
      }
    });
    
    • fs.appendFile 加文件
    fs.appendFile("./html/index.html", "wait wait wait\n", (err) => {
      if (err) {
        console.log(err);
        return;
      }
      console.log("appendFile成功");
    });
    
    • fs.readFile 读取文件
    fs.readFile("./html/index.html", (err, data) => {
      if (err) {
        console.log(err);
        return;
      }
      console.log(data); //data是Buffer类型数据
      console.log(data.toString()); //通过toString()转换成字符串
    });
    
    • fs.readdir 读取目录
    fs.readdir("./html", (err, data) => {
      if (err) {
        console.log(err);
        return;
      }
      console.log(data); //文件信息
    });
    
    • fs.rename 重命名
    // fs.rename 重命名  功能:1 表示重命名  2 移动文件
    fs.rename("./html/style.css", "./html/jjj.css", (err) => {
      if (err) {
        console.log(err);
        return;
      }
      console.log("重命名成功");
    });
    
    fs.rename("./html/jjj.css", "./style.css", (err) => {
      if (err) {
        console.log(err);
        return;
      }
      console.log("移动并且修改文件名成功");
    });
    
    • fs.rmdir 删除目录
    fs.rmdir("./delete", (err) => {
      if (err) {
        console.log(err);
        return;
      }
      //如果目录下有文件,则无法删除,需要先删除文件,再删除目录
      console.log("删除目录成功");
    });
    
    • fs.unlink 删除文件
    fs.unlink("./delete/delete.html", (err) => {
      if (err) {
        console.log(err);
        return;
      }
      console.log("删除文件成功");
    });
    
    • fs.createReadStream 以文件流方式读取数据
    var readStream = fs.createReadStream("./html/index.html");
    var count = 0;
    var str = "";
    readStream.on("data", (data) => {
      str += data;
      count++;
    });
    readStream.on("end", () => {
      console.log(str);
      console.log(count);
    });
    readStream.on("error", (err) => {
      console.log(err);
    });
    
    • fs.createWriteStream 以流的方式写入文件
    var str = "";
    var data = "ashdjhdaksjdhakdaskjdkasdaajsdka\n";
    for (var i = 0; i < 500; i++) {
      str += data;
    }
    var writeStream = fs.createWriteStream("./html/write.txt");
    writeStream.write(str);
    writeStream.end();
    writeStream.on("finish", () => {
      console.log("写入完成");
    });
    
    • 管道流 用于复制大文件
    var readStream = fs.createReadStream("./html/write.txt");
    var writeStream = fs.createWriteStream("./root/write.txt");
    readStream.pipe(writeStream);
    

    结语

    以上
    有帮助的打个赏哦亲~~

    展开全文
  • 简单的说 Node.js 就是运行在服务端的 JavaScript。 Node.js 是一个基于Chrome JavaScript 运行时建立的一个平台。 Node.js是一个事件驱动I/O服务端JavaScript环境,基于Google的V8引擎,V8引擎执行Javascript...
  • 前端面试题(Node

    千次阅读 2019-05-16 15:12:49
    Node **1. 为什么要用node? ** 特点:简单强大,轻量可扩展.简单体现在node使用的是javascript,json来进行编码,人人都会; 强大体现在非阻塞IO,可以适应分块传输数据,较慢的网络环境,尤其擅长高并发访问;轻量...

    Node

    **1. 为什么要用node? **
    特点:简单强大,轻量可扩展.简单体现在node使用的是javascript,json来进行编码,人人都会;
    强大体现在非阻塞IO,可以适应分块传输数据,较慢的网络环境,尤其擅长高并发访问;轻量体现在node本身既是代码,又是服务器,前后端使用统一语言;可扩展体现在可以轻松应对多实例,多服务器架构,同时有海量的第三方应用组件

    2. node的构架是什么样子的?
    主要分为三层,应用app >> V8及node内置架构 >> 操作系统.
    V8是node运行的环境,可以理解为node虚拟机.node内置架构又可分为三层: 核心模块(javascript实现) >> c++绑定 >> libuv + CAes + http.

    3. node有哪些核心模块?

    EventEmitter, Stream, FS, Net和全局对象
    

    4、node有哪些全局对象?

    process, console, Buffer和exports
    

    5、 process有哪些常用方法?

    process.stdin, process.stdout, process.stderr, process.on, process.env, process.argv, process.arch, process.platform, process.exit
    

    6、console有哪些常用方法?

    console.log/console.info, console.error/console.warning, console.time/console.timeEnd, console.trace, console.table
    

    7、node有哪些定时功能?

    setTimeout/clearTimeout, setInterval/clearInterval, setImmediate/clearImmediate, process.nextTick
    

    8、node中的事件循环是什么样子的?

    总体上执行顺序是:process.nextTick >> setImmidate >> setTimeout/SetInterval
    链接

    9、node中的Buffer如何应用?
    Buffer是用来处理二进制数据的,比如图片,mp3,数据库文件等.Buffer支持各种编码解码,二进制字符串互转.

    **10、什么是EventEmitter? **
    EventEmitternode中一个实现观察者模式的类,主要功能是监听和发射消息,用于处理多模块交互问题.

    11、如何实现一个EventEmitter?
    主要分三步:定义一个子类,调用构造函数,继承EventEmitter
    代码演示

    var util = require(‘util’);
    var EventEmitter = require(‘events’).EventEmitter;

    function MyEmitter() { 
        EventEmitter.call(this); 
    } // 构造函数 
    
    util.inherits(MyEmitter, EventEmitter); // 继承 
    
    var em = new MyEmitter(); 
    em.on('hello', function(data) { 
        console.log('收到事件hello的数据:', data); 
    }); // 接收事件,并打印到控制台 
    em.emit('hello', 'EventEmitter传递消息真方便!');
    

    12、EventEmitter有哪些典型应用?
    1) 模块间传递消息
    2) 回调函数内外传递消息
    3) 处理流数据,因为流是在EventEmitter基础上实现的.
    4) 观察者模式发射触发机制相关应用

    13、怎么捕获EventEmitter的错误事件?
    监听error事件即可.如果有多个EventEmitter,也可以用domain来统一处理错误事件.

    代码演示

    var domain = require('domain'); 
    var myDomain = domain.create(); 
    myDomain.on('error', function(err){ 
        console.log('domain接收到的错误事件:', err); 
    }); // 接收事件并打印 
    myDomain.run(function(){ 
        var emitter1 = new MyEmitter(); 
        emitter1.emit('error', '错误事件来自emitter1'); 
        emitter2 = new MyEmitter(); 
        emitter2.emit('error', '错误事件来自emitter2'); 
    }); 
    

    14、EventEmitter中的newListenser事件有什么用处?
    newListener可以用来做事件机制的反射,特殊应用,事件管理等.当任何on事件添加到EventEmitter时,就会触发newListener事件,基于这种模式,我们可以做很多自定义处理.

    代码演示

    var emitter3 = new MyEmitter();
    emitter3.on('newListener', function(name, listener) {
        console.log("新事件的名字:", name); 
        console.log("新事件的代码:", listener); 
        setTimeout(function(){ console.log("我是自定义延时处理机制"); }, 1000); 
    });
    emitter3.on('hello', function(){
        console.log('hello node'); 
    });
    

    **15、什么是Stream? **
    stream是基于事件EventEmitter的数据管理模式.由各种不同的抽象接口组成,主要包括可写,可读,可读写,可转换等几种类型.

    16、Stream有什么好处?
    非阻塞式数据处理提升效率,片断处理节省内存,管道处理方便可扩展等.

    17、Stream有哪些典型应用?
    文件,网络,数据转换,音频视频等

    18、怎么捕获Stream的错误事件?
    监听error事件,方法同EventEmitter

    **19、有哪些常用Stream,分别什么时候使用? **
    Readable为可被读流,在作为输入数据源时使用;Writable为可被写流,在作为输出源时使用;Duplex为可读写流,它作为输出源接受被写入,同时又作为输入源被后面的流读出.Transform机制和Duplex一样,都是双向流,区别时Transfrom只需要实现一个函数_transfrom(chunk, encoding, callback);Duplex需要分别实现_read(size)函数和_write(chunk, encoding, callback)函数.

    **20、实现一个Writable Stream? **
    三步走:1)构造函数call Writable
    2) 继承Writable 在这里插入代码片
    3) 实现_write(chunk, encoding, callback)函数

    代码演示

    var Writable = require('stream').Writable;
    var util = require('util');
     
    function MyWritable(options) {
        Writable.call(this, options); 
    } // 构造函数 
    util.inherits(MyWritable, Writable); // 继承自Writable 
    MyWritable.prototype._write = function(chunk, encoding, callback) {
        console.log("被写入的数据是:", chunk.toString()); // 此处可对写入的数据进行处理 
        callback(); 
    };
     
    process.stdin.pipe(new MyWritable()); // stdin作为输入源,MyWritable作为输出源
    

    21、内置的fs模块架构是什么样子的?
    fs模块主要由下面几部分组成:
    1) POSIX文件Wrapper,对应于操作系统的原生文件操作
    2) 文件流 fs.createReadStreamfs.createWriteStream
    3) 同步文件读写,fs.readFileSyncfs.writeFileSync
    4) 异步文件读写, fs.readFilefs.writeFile

    **22、读写一个文件有多少种方法? **
    1) POSIX式低层读写
    2) 流式读写
    3) 同步文件读写
    4) 异步文件读写

    23、怎么读取json配置文件?
    第一种是利用node内置的require('data.json')机制,直接得到js对象;
    第二种是读入文件入内容,然后用JSON.parse(content)转换成js对象.二者的区别是require机制情况下,如果多个模块都加载了同一个json文件,那么其中一个改变了js对象,其它跟着改变,这是由node模块的缓存机制造成的,只有一个js模块对象; 第二种方式则可以随意改变加载后的js变量,而且各模块互不影响,因为他们都是独立的,是多个js对象.

    24、fs.watch和fs.watchFile有什么区别,怎么应用?
    fs.watch利用操作系统原生机制来监听,可能不适用网络文件系统; fs.watchFile则是定期检查文件状态变更,适用于网络文件系统,但是相比fs.watch有些慢,因为不是实时机制.

    25、node的网络模块架构是什么样子的?
    node全面支持各种网络服务器和客户端,包括tcp, http/https, tcp, udp, dns, tls/ssl等.

    26、node是怎样支持https,tls的?
    1) openssl生成公钥私钥
    2) 服务器或客户端使用https替代http
    3) 服务器或客户端加载公钥私钥证书

    27、实现一个简单的http服务器?
    思路是加载http模块,创建服务器,监听端口.

    代码演示

    var http = require('http'); // 加载http模块 
    
    http.createServer(function(req, res) { 
        res.writeHead(200, {'Content-Type': 'text/html'}); // 200代表状态成功, 文档类型是给浏览器识别用的 
        res.write('<meta charset="UTF-8"><h1>我是标题啊!</h1><font color="red">这么原生,初级的服务器,下辈子能用着吗?!</font>'); // 返回给客户端的html数据 
        res.end(); // 结束输出流 
    }).listen(3000); // 绑定3ooo, 查看效果请访问 http://localhost:3000 
    

    **28、为什么需要child-process? **
    node是异步非阻塞的,这对高并发非常有效.可是我们还有其它一些常用需求,比如和操作系统shell命令交互,调用可执行文件,创建子进程进行阻塞式访问或高CPU计算等,child-process就是为满足这些需求而生的.child-process顾名思义,就是把node阻塞的工作交给子进程去做.

    29、exec,execFile,spawn和fork都是做什么用的?
    exec可以用操作系统原生的方式执行各种命令,如管道 cat ab.txt | grep hello;
    execFile是执行一个文件;
    spawn是流式和操作系统进行交互;
    fork是两个node程序(javascript)之间时行交互.

    30、实现一个简单的命令行交互程序?
    spawn

    代码演示

    var cp = require('child_process'); 
    
    var child = cp.spawn('echo', ['你好', "钩子"]); // 执行命令 
    child.stdout.pipe(process.stdout); // child.stdout是输入流,process.stdout是输出流 
    // 这句的意思是将子进程的输出作为当前程序的输入流,然后重定向到当前程序的标准输出,即控制台 
    

    **31、两个node程序之间怎样交互? **
    用fork嘛,上面讲过了.原理是子程序用process.on, process.send,父程序里用child.on,child.send进行交互.
    代码演示

    1) fork-parent.js 
    var cp = require('child_process'); 
    var child = cp.fork('./fork-child.js'); 
    child.on('message', function(msg){ 
        console.log('老爸从儿子接受到数据:', msg); 
    }); 
    child.send('我是你爸爸,送关怀来了!'); 
    
    2) fork-child.js 
    process.on('message', function(msg){ 
        console.log("儿子从老爸接收到的数据:", msg); 
        process.send("我不要关怀,我要银民币!"); 
    }); 
    

    **32、怎样让一个js文件变得像linux命令一样可执行? **
    1) 在myCommand.js文件头部加入#!/usr/bin/env node
    2) chmod命令把js文件改为可执行即可
    3) 进入文件目录,命令行输入myComand就是相当于node myComand.js

    33、child-process和process的stdin,stdout,stderror是一样的吗?
    概念都是一样的,输入,输出,错误,都是流.区别是在父程序眼里,子程序的stdout是输入流,stdin是输出流

    34、node中的异步和同步怎么理解
    node是单线程的,异步是通过一次次的循环事件队列来实现的.同步则是说阻塞式的IO,这在高并发环境会是一个很大的性能问题,所以同步一般只在基础框架的启动时使用,用来加载配置文件,初始化程序什么的

    **35、有哪些方法可以进行异步流程的控制? **
    1) 多层嵌套回调
    2) 为每一个回调写单独的函数,函数里边再回调
    3) 用第三方框架比方async, q, promise

    36、怎样绑定node程序到80端口?
    1) sudo
    2) apache/nginx代理
    3) 用操作系统的firewall iptables进行端口重定向

    37、有哪些方法可以让node程序遇到错误后自动重启?
    1) runit
    2) forever
    3) nohup npm start &

    38、怎样充分利用多个CPU?
    一个CPU运行一个node实例

    39、怎样调节node执行单元的内存大小?
    --max-old-space-size--max-new-space-size 来设置 v8 使用内存的上限

    **40、程序总是崩溃,怎样找出问题在哪里? **
    1) node --prof 查看哪些函数调用次数多
    2) memwatchheapdump获得内存快照进行对比,查找内存溢出

    **41、有哪些常用方法可以防止程序崩溃? **
    1) try-catch-finally
    2) EventEmitter/Stream error事件处理
    3) domain统一控制
    4) jshint静态检查
    5) jasmine/mocha进行单元测试

    42、怎样调试node程序?
    node --debug app.jsnode-inspector

    43、async都有哪些常用方法,分别是怎么用?
    async是一个js类库,它的目的是解决js中异常流程难以控制的问题.async不仅适用在node.js里,浏览器中也可以使用.
    1) async.parallel并行执行完多个函数后,调用结束函数

    async.parallel([ 
        function(){ ... }, 
        function(){ ... } 
    ], callback); 
    
    1. async.series串行执行完多个函数后,调用结束函数
    async.series([ 
        function(){ ... }, 
        function(){ ... } 
     ]); 
    
    1. async.waterfall依次执行多个函数,后一个函数以前面函数的结果作为输入参数
    async.waterfall([ 
       function(callback) { 
           callback(null, 'one', 'two'); 
       }, 
       function(arg1, arg2, callback) { 
         // arg1 now equals 'one' and arg2 now equals 'two' 
           callback(null, 'three'); 
       }, 
       function(arg1, callback) { 
           // arg1 now equals 'three' 
           callback(null, 'done'); 
       } 
    ], function (err, result) { 
       // result now equals 'done' 
    }); 
    
    1. async.map异步执行多个数组,返回结果数组
    async.map(['file1','file2','file3'], fs.stat, function(err, results){ 
      // results is now an array of stats for each file 
    }); 
    
    1. async.filter异步过滤多个数组,返回结果数组
    async.filter(['file1','file2','file3'], fs.exists, function(results){ 
      // results now equals an array of the existing files 
    });
    

    44、express项目的目录大致是什么样子的

    app.js, package.json, bin/www, public, routes, views.
    

    45、express常用函数
    express.Router路由组件,app.get路由定向,app.configure配置,app.set设定参数,app.use使用中间件

    46、express中如何获取路由的参数
    /users/:name使用req.params.name来获取;
    req.body.username则是获得表单传入参数username;
    express路由支持常用通配符 ?, +, *, and ()

    47、express response有哪些常用方法
    res.download() 弹出文件下载
    res.end() 结束response
    res.json() 返回json 在这里插入代码片
    res.jsonp() 返回jsonp
    res.redirect() 重定向请求
    res.render() 渲染模板
    res.send() 返回多种形式数据
    res.sendFile 返回文件
    res.sendStatus() 返回状态

    48、mongodb有哪些常用优化措施
    类似传统数据库,索引和分区

    49、mongoose是什么?有支持哪些特性?
    mongoosemongodb的文档映射模型.主要由Schema, ModelInstance三个方面组成.
    Schema就是定义数据类型,
    Model就是把Schemajs类绑定到一起,
    Instance就是一个对象实例.
    常见mongoose操作有,save, update, find. findOne, findById, static方法等

    50、redis支持哪些功能

    set/get, mset/hset/hmset/hmget/hgetall/hkeys, sadd/smembers, publish/subscribe, expire
    

    51、redis最简单的应用

    var redis = require("redis"), 
       client = redis.createClient(); 
    
    client.set("foo_rand000000000000", "some fantastic value"); 
    client.get("foo_rand000000000000", function (err, reply) { 
       console.log(reply.toString()); 
    }); 
    client.end(); 
    

    52、apache,nginx有什么区别?
    二者都是代理服务器,功能类似.
    apache应用简单,相当广泛.
    nginx在分布式,静态转发方面比较有优势

    展开全文
  • 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>`
    		}
    
    展开全文
  • 1 安装node环境 下载Node.js 打开官网下载链接:https://nodejs.org/en/download/我这里下载的是node-v6.9.2-x64.msi,安装即可 node -v # 安装好node之后 $ npm install -g cnpm --registry=...
  • vue项目的安装与启动

    2018-10-09 09:35:00
    第一步:安装Node 检测Node是否安装成功 node -v 第二步:安装vue-cli 命令:npm install vue-cli -g 第三步:搭建项目命令vue init webpack '你的项目名称' 一路回车 遇到eslint选择no 第四步:安装依赖包 进去你...
  • vue项目搭建记录

    2020-09-03 14:58:29
    安装完成后输入node -v 查看是否安装成功 下面所安装的东西如果是Mac系统,有些是因为权限的原因需要在前面加上 sudo,回车后输入密码即可 安装Vue CLI脚手架 npm install -g @vue/cli mac版请用 sudo npm install...
  • 2.windows+R打开命令行窗口,分别执行 node -v npm -v命令 3.解决问题:npm(node)不是内部或外部命令 该链接下的步骤8忽略 再走该链接里的步骤9 紧接着再次执行 node -v和npm -v 看是否出来版本号 4.windows+R...
  • Node.js最新最详细安装教程(2020)

    千次阅读 2020-03-19 15:26:26
    2020最新-Node.js详细安装教程(2020)
  • node -v v12.18.3 C:\Users\llrachel>npm -v 6.14.6 C:\Users\llrachel>npm config set prefix "F:\1program\nodejs\node_global" C:\Users\llrachel>npm config set cache "F:\1program\nodejs\node_...
  • NodeJS入门(一)---nodejs详细安装步骤

    万次阅读 多人点赞 2018-05-29 11:37:21
    初学NodeJS,就是要弄清楚什么是nodejs,能做什么,怎么用。。什么是nodejs?...而对于需要独立运行的JS,nodejs就是一个解析器。 每一种解析器都是一个运行环境,不但允许js定义各种数据结构,进行各种计算,还允许js...
  • npm ERR! code ELIFECYCLE

    千次阅读 2020-03-31 10:17:55
    “E:\Program Files\JetBrains\WebStorm 2018.1.4\bin\runnerw.exe” G:\node\nodejs\node.exe G:\node\nodejs\node_modules\npm\bin\npm-cli.js run dev –scripts-prepend-node-path=auto hrvue@1.0.0 dev G:\...
  • 首先是下载adb. ...提取码:12wq 手机要打开开发者模式,不会百度(USB连接) 然后就是下载到c盘,把路径添加到环境变量中 如果不添加就会报错,如 成功的是这样的  在cmd中输入查询命令,就可以查到当前连接的手机...
  • 在通过vs code 运行webpack进行打包时,报错webpack : 无法加载文件 D:\nodejs\node_global\...
  • Node初学者入门 , 一本全面的NodeJS 教程,Manuel Kiessling著
  • Node.js的卸载

    万次阅读 多人点赞 2019-06-21 09:17:02
    VUE项目使用iView组件在控制面板-...确保node.js没有在后台运行的情况下,进行卸载,可做重启操作后,在到控制面板中找到node.js进行卸载 卸载后 到文件夹中进行进一步的删除 C:\Program Files (x86)\Nodejs C:\Pr...
  • Nodejs 定时执行(node-cron)

    万次阅读 热门讨论 2018-11-08 15:37:17
    搜索一下schedule,出现一个node-cron模块。看起来有很多人用,嗯….就用这个了。 Npm 文档:https://www.npmjs.com/package/cron 1 安装 npm install cron 测试code: var CronJob = require...
  • nodejs模块 node-schedule使用,定时任务

    万次阅读 热门讨论 2016-07-13 17:06:38
    一. 安装 npm install node-schedule 二. 使用 例子通过定时访问url展示 1.确定的时间
  • Node.js非常适用于Web开发,但是现在无论是一个网站,还是Web App都已经成为包括很多不同部分,如前端、数据库、业务模块、功能模块等等的大型项目,...nodejs-web前端软件工程师月薪多少? 如果你把node.js学好,...
  • node版本如何升级

    万次阅读 多人点赞 2018-08-15 22:01:54
    You are using Node v8.4.0, but this version of vue-cli requires Node &amp;amp;amp;amp;gt;=8.9. Please upgrade your Node version. 然后再用node -v,发现在本地的node版本是v8.4.0,有点老了,要升级了...
  • node-websocket-client, NodeJS的Web Socket客户端 一个 Prototype Web Socket 客户端实现 node.js 。测试 miksago/node-websocket-server v1.2.00.需要 nodejs 0.1.98或者更高版本。安装按如下方式使用 np
  • 自学nodejs以后,一直考虑写一个Nodejs项目,但苦于没有找到合适的类型,而且后台系统无法直观的感受到,需要有一个前台项目配合。刚好前一段时间准备在公司推vue,用vue重构了后台系统的一部分业务,vue前端项目,...
  • NodeJS简介-node.js是什么?

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

    万次阅读 2019-07-11 15:14:08
    node.js的下载、安装及运行 1.下载 官网下载地址:https://nodejs.org/en/download/ 中文下载地址:http://nodejs.cn/download/ LTS:Long Term Support,长效版,长期支持的版本,通常是3年。 2.安装 以windows...
  • nodejs 调度 node-schedule 使用

    千次阅读 2015-07-17 17:00:21
    最近在玩这个nodejs node-schedule 蛮好玩的 做了个系统调度服务 也和node-schedule 作者交流了几次  看成果把 支持post 和 get 请求 我想要它在每个月的17号 15:42:2 发请求给天气预报 让它返回数据 结果它就...
  • NodeJs入门(一)--Node安装、版本管理

    千次阅读 2018-03-23 17:39:52
    Node.js是一个事件驱动I/O服务端JavaScript环境,基于Google的V8引擎,V8引擎执行Javascript的速度非常快,性能非常好。 1.可以解析JS代码(没有浏览器安全级别的限制) 2.提供系统级别的API: 文件的读写 ...
  • 使用nodejs本地创建服务器。 2.本地请求数据,服务器根据请求内容返回响应数据。 3.用户请求地址 127.0.0.1:3000/index.html,服务器获得请求内容后,找到服务器中index.html页面,并将内容读取出来,作为响应数据...
  • 测试条件:
  • 前言 入门前端的坑也很久了,以前很多大小项目,前端都是传统式开发,一直在重复造轮子;...但是对webpack\npm\node\nodejs这几个在前端模块化中的高频词总是傻傻分不清,不知道他们之间的具体关系,今天花了...

空空如也

1 2 3 4 5 ... 20
收藏数 1,981,962
精华内容 792,784
关键字:

node