nodejs入门学习第一天_node.exe-优快云博客

本文链接：https://blog.youkuaiyun.com/Depressione/article/details/107071070

这篇博客介绍了Node.js的基础知识，包括其概念、环境安装和运行程序的方法。同时，文章还深入讲解了ES6的新特性，如let、const关键字、解构赋值、箭头函数等，并通过实例展示了数组操作方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

nodejs入门

1.1-什么是nodejs

Node是一个构建于Chrome V8引擎上的一个JavaScript运行环境
1. Node是一个运行环境，作用是让js拥有开发服务端的功能
Node使用事件驱动，非阻塞IO模型（异步读写）使得它非常轻量级和高效
1. Node中绝大多数API都是异步（类似于Ajax），目的是提高性能
Node中的NPM是世界上最大的开源库生态系统（类似于gitHub）

1.2-Node.js环境安装

1.2.1-如何判断自己当前电脑是否已经安装了Node环境

在这里插入图片描述

打开终端，输入node - v
如果能看到版本号则说明当前电脑已经安装Node环境
一旦安装了node，则会自动一并安装npm

1.3-如果运行Node.js程序

REPL：交互解释器
1. Node运行环境的另一种叫法，作业是解析执行js代码（不推荐）
2. 用法：
  1. 第一种方式：直接双击打开node.exe然后写js代码
  2. 第二种方式：
    - 先在终端先执行node，进入node环境
    - 然后写js代码
使用终端命令node[js文件路径]开始运行js文件
1. 其实当我们在终端执行Node命令时，并不是我们终端去编译解释js代码，而是电脑会自动打开Node安装包中Node.exe应用程序来打开js文件
  - Node.exe是一个类似于终端的应用程序，没有界面
  - Node.exe工作环境称之为REPL环境，也就是交互式解释器
2. REPL才是珍重解释执行我们js代码的解释器

1.4- 服务器端js和浏览器端js

1.js都是运行在浏览器端的

ECMScript：js语法

Bom：浏览器对象模型，用js去操作浏览器窗口

Dom：文档对象模型，用js去操作页面上的Dom树

学了node.js之后，服务端也可以运行ECMScript
在node.js中不能写BOM和Dom语法

/**
 * 1.js都是运行在浏览器端的
 *  ECMScript：js语法
 *  Bom：浏览器对象模型，用js去操作浏览器窗口
 *  Dom：文档对象模型，用js去操作页面上的Dom树
 * 2. 学了node.js之后， 服务端也可以运行ECMScript
 * 3. 在node.js中不能写BOM和Dom语法
 */

// 正常的符合js语法的代码都是没问题的
var name = "aaa"
console.log(name)

//但是不能执行Bom和Dom语法
// console.log(document)//报错
alert(name) //报错

ES6新语法

1-let关键字和const关键字

var 关键字声明变量	let 关键字声明变量	const关键字声明常量
有变量提升	没有变量提升	没有变量提升
没有块级作用域，是函数作用域	有块级作用域	有块级作用域
可以重复声明	不能重复声明	不能重复声明
可以重新赋值	可以重新赋值	不能重新赋值，声明时必须要初始化值

/**
 * var 关键字声明变量
 *  1.有变量提升
 *  2.没有块级作用域，是函数作用域
 *  3.可以重复声明
 *  4.可以重新赋值
 * 
 * 
 * 
 * let 关键字声明变量
 *  1. 没有变量提升
 *  2. 有块级作用域 
 *  3. 不能重复声明 
 *  4. 可以重新赋值
 */

//1. 没有变量提升
// console.log(age)
// let age = 30 //报错
// var age = 30 // undefined

//2. 有块级作用域 
// for (var i = 0; i < 10; i++) {

// }//10
// for (let i = 0; i < 10; i++) {

// }//报错
// console.log(i)


// 3. 不能重复声明
// var a = 10
// var a = 20//没有报错，输出20
// let a = 10
// let a = 20//报错，Identifier 'a' has already been declared
// console.log(a)

// 4. 可以重新赋值
// var a = 1
// a = 2
// let q = 1
// q = 2
// console.log(a, q)

/**
 * const关键字声明常量的
 * 1. 没有变量提升
 * 2. 有块级作用域
 * 3. 不能重复声明
 * 4. 不能重新赋值，声明时必须要初始化值
 */

//  1. 没有变量提升
// console.log(a)
// const a = 10//报错

// 2. 有块级作用域
// {
//     const a = 10
// }
// console.log(a)//报错

//  3. 不能重复声明
// const a = 10
// const a = 20
// console.log(a)//报错

// 4. 不能重新赋值， 声明时必须要初始化值
// const a//报错
// const a = 10
// a = 20//报错

2-对象解构赋值

/**
 * 对象解构赋值
 * 取对象中属性的值，赋值给变量
 */

//声明一个对象
let obj = {
    name: "aaa",
    age: 30,
    gender: "男",
    score: 100
}
//es5:
// let name1 = obj.name
// let age1 = obj.age
// let gender1 = obj.gender
// let score1 = obj.score
// console.log(name1, age1, gender1, score1)

//es6
//a:
// let {
//     name: name1,
//     age: age1,
//     gender: gender1,
//     score: score1
// } = obj //解构赋值
// console.log(name1, age1, gender1, score1)

//b:
// let {
//     name: name,
//     age: age,
//     gender: gender,
//     score: score
// } = obj //解构赋值
// console.log(name, age, gender, score)

//c:如果声明的变量名和对象属性名一致，那就可以简写
let {
    name,
    age,
    gender,
    score
} = obj //解构赋值
console.log(name, age, gender, score)

3-数组解构

/**
 * 数组解构赋值
 * 就是把数组中每一个元素的值一次的赋值给变量
 */


//声明一个数组
let arr = [10, 20, 30, 40]


//es5
// let num1 = arr[0]
// let num2 = arr[1]
// let num3 = arr[2]
// let num4 = arr[3]
// console.log(num1, num2, num3, num4)

//es6
//a
// let [num1, num2, num3, num4] = arr
// console.log(num1, num2, num3, num4)

//b
// let [num1, num2, num3, num4, num5] = arr
// console.log(num1, num2, num3, num4, num5) //num5 为undefined

//c
// let [num1, num2, num3, num4, num5 = 50] = arr
// console.log(num1, num2, num3, num4, num5)

//d
// let [num1 = 100, num2, num3, num4, num5 = 50] = arr
// console.log(num1, num2, num3, num4, num5)

//e
let [num1, num2] = arr
console.log(num1, num2)
console.log(arr[3])

4-解构赋值结合函数声明

/**
 * 解构赋值结合函数声明
 * 
 */

//es5
// function text1(name, age, gender) {
//     console.log(name, age, gender)
// }

// text1("aaa", 30, "男")
//如果形参有多个，最好把形参写成一个对象
// function text1(obj) {
//     console.log(obj.name, obj.age, obj.gender)
// }
// text1({
//     name: "aaa",
//     age: 30,
//     gender: "男"
// })

//es6
//声明一个函数，形参有多个
function text2({
    name,
    age,
    gender
}) {
    console.log(name, age, gender)
}
text2({
    name: "aaa",
    age: 30,
    gender: "男"
})
//就相当于提前声明了那三个变量，后面根据obj里面的属性来赋值给那三个变量

5-箭头函数

/**
 * 箭头函数
 * 说白了就是匿名函数的简写
 */

/**
 * 简写规则
 * 1.function 改成 =>    =>可以读成goes to
 * 2.如果只有一个形参，可以省略小括号
 * 3.如果不是一个形参，0个或多个形参不能省略形参小括号
 * 4.如果函数体只有一句话，就可以省略函数体的大括号
 * 5.如果函数体只有一句话，并且这句话是return 那么return也要省略
 * 6.如果函数体不是一句话，那么不能省略大括号
 */

//普通的匿名函数
// let fn = function (name) {
//     console.log(name)
// }

// fn("小明")

//箭头函数
// let fn = name => console.log(name)
// fn("小明")

6-对象成员的简写

/**
 * 对象成员的简写
 * 
 */


//声名了些变量
let name = "小明"
let age = 18
let gender = "男"
let score = 100
//现在声名了个对象，对象里面也有name  age  gender  score，希望对象中的属性里面的值一样


//es5 
// var obj = {
//     name: name,
//     age: age,
//     gender: gender,
//     score: score,
//     sayHi: function () {
//         console.log("aaaa")
//     }
// }
// console.log(obj)
// obj.sayHi()

//es6:对象成员简写
let obj = {
    name,
    age,
    gender,
    score,
    // fenshu, //报错，相当于fenshu：fenshu，但是对象外面没有分数，那么报错
    sayHi() {
        console.log("哈哈哈哈")
    }
}
console.log(obj)
obj.sayHi()

7-对象展开

/**
 * 对象展开
 * 
 */

//声名一个对象
let chinese = {
    skin: "黄皮肤",
    hair: "黑色头发",
    sayHi() {
        console.log("你好")
    }
}

//声名一个对象
let zhuBo = {
    skill: "唱歌",
    song: "姬霓太美",
}

//声名一个对象
let linge = {
    // skin: "黄皮肤",
    // hair: "黑色头发",
    // sayHi() {
    //     console.log("你好")
    // },
    // skill: "唱歌",
    // song: "姬霓太美"
    //展开语法
    ...chinese,
    ...zhuBo
    //...chinese 相当于把chinese中的东西全部拿到linge里面了
}
console.log(linge)

8-数组展开

/**
 * ...展开运算符
 * 
 * 数组展开
 */

let arr1 = [1, 2, 3, 4]
let arr2 = [...arr1, 5, 6, 7, 8] //...arr1  就是相当于把arr1里面东西拿出来全部给arr2
console.log(arr2)

9-数据类型Set

/**
 * Set
 * 作用和数组类似，和数组不同的是不能存重复的元素
 * 应用场景：数组去重
 */

//1.基本使用
// let set1 = new Set([10, 10, 10, 20, 3, 4, 45, 655])
// console.log(set1) //Set { 10, 20, 3, 4, 45, 655 }
//得到一个Set对象，内容没有重复的

//2.数组去重
// let arr = [10, 20, 3, 3, 3, 225234, 25235, 24]
// let set = new Set(arr)
// console.log(set) //此时得到一个对象
// let arrNew = [...set] //用展开运算符在[]中展开得到的set对象就完成了去重
// console.log(arrNew)

//3.数组去重：把上面的变成一句话
let arr = [10, 20, 3, 3, 3, 225234, 25235, 24]
let arrNew = [...new Set(arr)]
console.log(arrNew)

10-模板字符串

/**
 * 模板字符串
 * 字符串都是在'' 和 ""中的
 * 模板字符串是在``中的
 * 会保留原样字符串格式，以及可以占位
 */

//es5
//字符串没有格式，里面也不能写变量
let auther = "aaa"
// let str1 = "静夜思
//     auther,
// "//报错

//es6:模板字符串
let str1 = `
    我是小明
    作者： $(auther)
`
console.log(str1)

11-补充数组的几个方法

//1.forEach()
// let arr = [10, 20, 30, 40]
// arr.forEach(function (item, index) {
//     //item为数组中的每个元素，index为每个元素的索引
//     console.log(item, index)
// })

//2.map() 遍历数组，用返回值
// let arr = [10, 20, 30, 40]
// let arrNew = arr.map(function (iten, index) {
//     //item为数组中的每个元素，index为每个元素的索引
//     console.log(item, index)
//     return item * item //返回值
// })
// console.log(arrNew)

//3.filter()过滤器
//filter()会返回一个新的数组，新的数组中的元素是通过检查后符合条件的元素
let arr = [10, 20, 30, 40, 40, 234, 10, 40]
let arrNew = arr.filter((item, index) => {
    //item为数组中的每个元素，index为每个元素的索引
    return item % 2 == 0
})
console.log(arrNew)

em, index)
// })

//2.map() 遍历数组，用返回值
// let arr = [10, 20, 30, 40]
// let arrNew = arr.map(function (iten, index) {
// //item为数组中的每个元素，index为每个元素的索引
// console.log(item, index)
// return item * item //返回值
// })
// console.log(arrNew)

//3.filter()过滤器
//filter()会返回一个新的数组，新的数组中的元素是通过检查后符合条件的元素
let arr = [10, 20, 30, 40, 40, 234, 10, 40]
let arrNew = arr.filter((item, index) => {
//item为数组中的每个元素，index为每个元素的索引
return item % 2 == 0
})
console.log(arrNew)