张三的博客项目总结

请问项目用到了哪些技术？
- Node.js
  - Modules:
    - CommonJS的模块化
    - ECMAScript Module
- Expresss()框架
- MongoDB数据库
- Mongoose库
  - Schema()
  - Model()
- MVC：APP的设计模式/思想
  - Model：模型(数据)
  - View：视图
  - Controller：控制器
- BootStrap：构建布局
- EJS：视图模版

NPM VS NPX

Npm : Node.js的软件包管理器（Node.js Package Manager ）

NPX: Node.js的软件包执行器 (Node.js Package Executor)

express Generator

定义

express Generator是快速生成Express APP的脚手架。

Node.js APP 的开发步骤

第1步：项目初始化

创建package.json文件(模块包，管理项目用到模板)

mkdir myApp 
cd myApp
npm init --yes
npm init -y

第2步. 创建项目目录结构

myApp
- models:存放数据模型模块 module.exports = Blog
- views: 存放ejs视图文件
- controllers: 存放控制器：处理请求的回调
- routes: 存放路由表
- public: 存放静态资源（图片、css、js、字体)
- app.js: 主文件（App入口）
- package.json: 描述App（app的名字、描述、关键字、版本、第三方依赖)

第3步：安装项目所需模块

一键安装npm i

express
mongoose
ejs
express-ejs-layouts

第4步：引入模块（注意顺序引入）

用户界面 node.js 内置模板

path：用于处理（拼接）路径段；
fs：用于处理文件系统；
http：用于创建服务器;

第三方模板

express: 构建node.js APP;
mongoose: 与mongoDB通信;
Ejs：创建视图;嵌入式Javasript的hitml模板 -<% %>:注入动态数据（变量、对象名、函数名、语句）
nodemon：开发?
express--ejs-layouts:用于构建视图的模板；
第一步：安装npm install ejs？？？

本地模块

Model：如: Blog数据模型

模块化 html没有模块的概念

css使用@import导入css模块
- 不要把所以的css都写在一个文件里
谨慎使用@import 规则（1.必须放在css文件首行 2.注意：不要引入字体）
@import会发起请求
ES 6使用 import 和export导入模块

第5步：创建app.js的基本结构

App.js

//引入模块
const express=require('express')

//实例化App
const app = express() 

//配置app实例
app.use('',callback) //为指定路径注册回调函数
app.set(key, value) //设置一个值，为以后调用

//连接数据库
const uri = ''
mongoose.connect(uri)
        .then()
        .catch()

//配置路由

网站的基本·原理

搭建一个网站，需要做的三件事：
买一个域名：域名是ip地址的别名。域名管理面板下设置
- 域名解析：把ip地址绑定到域名上；
买一个服务器：
- 每个服务器都是一个ip地址。
- ip地址绑定一个域名。
编写一套程序： -静态网页语言：HTMl css
- 动态网页语言：index.pjp 、 index.jsp、 index.asp、
默认页：index.html index.thm index.php

网站工作原理

网站分为两种： 静态网站：没有用到数据库，我的数据写死html页面里；
- html 不支持变量 动态网站：数据从数据里注入到页面里；

4月6日

张三的博客项目总结

请问项目用到了哪些技术？
- Node.js
  - Modules:
    - CommonJS的模块化
    - ECMAScript Module
- Expresss()框架
- MongoDB数据库
- Mongoose库
  - Schema()
  - Model()
- MVC：APP的设计模式/思想
  - Model：模型(数据)
  - View：视图
  - Controller：控制器
- BootStrap：构建布局
- EJS：视图模版

NPM VS NPX

Npm : Node.js的软件包管理器（Node.js Package Manager ）

NPX: Node.js的软件包执行器 (Node.js Package Executor)

express Generator

定义

express Generator是快速生成Express APP的脚手架。

Node.js APP 的开发步骤

第1步：项目初始化

创建package.json文件

mkdir myApp 
cd myApp
npm init -y

myApp
- models:存放数据模型模块 module.exports = Blog
- views: 存放ejs视图文件
- controllers: 存放控制器：处理请求的回调
- routes: 存放路由表
- public: 存放静态资源（图片、css、js、字体)
- app.js: 主文件（App入口）
- package.json: 描述App（app的名字、描述、关键字、版本、第三方依赖)

第2步：安装项目所需模块

第三方模块
- express: 构建node.js APP
- mongoose: 与mongoDB通信
- Ejs：创建视图
内置模块
- path
- fs
本地模块
- Model：如: Blog数据模型

第3步：创建app.js的基本结构

App.js

//引入模块

//实例化App
const app = express() 

//配置app实例
app.use('',callback) //为指定路径注册回调函数
app.set(key, value) //设置一个值，为以后调用

//连接数据库
const uri = ''
mongoose.connect(uri)
        .then()
        .catch()

//配置路由

4月5号

知识点

学会安装nodemon

npm install -g nodemon

4月4日

打印mongoose

const mongoose = require('mongoose') 引入mongoose模块会自动创建mongoose实例对象。

mongoose是一个对象
Mongoose.connections 属性
mongoose.Schema :构造函数
Mongoose.model：函数

Mongoose {
  connections: [
    NativeConnection {
      base: [Circular *1],
      collections: {},
      models: {},
      config: {},
      replica: false,
      options: null,
      otherDbs: [],
      relatedDbs: {},
      states: [Object: null prototype],
      _readyState: 0,
      _closeCalled: false,
      _hasOpened: false,
      plugins: [],
      id: 0,
      _queue: [],
      _listening: false
    }
  ],
  nextConnectionId: 1,
  models: {},
  events: EventEmitter {
    _events: [Object: null prototype] {},
    _eventsCount: 0,
    _maxListeners: undefined,
    [Symbol(kCapture)]: false
  },
  __driver: {
    Collection: [Function: NativeCollection],
    Connection: [Function: NativeConnection] { STATES: [Object: null prototype] }
  },
  options: {
    pluralization: true,
    autoIndex: true,
    autoCreate: true,
    [Symbol(mongoose:default)]: true
  },
  _pluralize: [Function: pluralize],
  Schema: [Function: Schema] {
    reserved: [Object: null prototype] {
      validate: 1,
      toObject: 1,
      save: 1,
      remove: 1,
      populated: 1,
      isNew: 1,
      isModified: 1,
      init: 1,
      get: 1,
      errors: 1,
      collection: 1,
      removeListener: 1,
      listeners: 1,
      emit: 1,
      prototype: 1
    },
    Types: {
      String: [Function],
      Number: [Function],
      Boolean: [Function],
      DocumentArray: [Function],
      Subdocument: [Function],
      Array: [Function],
      Buffer: [Function],
      Date: [Function],
      ObjectId: [Function],
      Mixed: [Function],
      Decimal: [Function],
      Decimal128: [Function],
      Map: [Function],
      UUID: [Function],
      Oid: [Function],
      Object: [Function],
      Bool: [Function],
      ObjectID: [Function]
    },
    ObjectId: [Function: ObjectId] {
      schemaName: 'ObjectId',
      defaultOptions: {},
      get: [Function (anonymous)],
      set: [Function: set],
      _checkRequired: [Function (anonymous)],
      _cast: [Function: castObjectId],
      cast: [Function: cast],
      _defaultCaster: [Function (anonymous)],
      checkRequired: [Function (anonymous)]
    }
  },
  model: [Function (anonymous)],
  plugins: [
    [ [Function: removeSubdocs], [Object] ],
    [ [Function: saveSubdocs], [Object] ],
    [ [Function], [Object] ],
    [ [Function: trackTransaction], [Object] ],
    [ [Function: validateBeforeSave], [Object] ]
  ],
  default: [Circular *1],
  mongoose: [Circular *1],
  cast: [Function: cast],
  STATES: [Object: null prototype] {
    '0': 'disconnected',
    '1': 'connected',
    '2': 'connecting',
    '3': 'disconnecting',
    '99': 'uninitialized',
    disconnected: 0,
    connected: 1,
    connecting: 2,
    disconnecting: 3,
    uninitialized: 99
  },
  setDriver: [Function: setDriver],
  set: [Function (anonymous)],
  get: [Function (anonymous)],
  createConnection: [Function (anonymous)],
  connect: [AsyncFunction: connect],
  disconnect: [AsyncFunction: disconnect],
  startSession: [Function (anonymous)],
  pluralize: [Function (anonymous)],
  deleteModel: [Function (anonymous)],
  modelNames: [Function (anonymous)],
  plugin: [Function (anonymous)],
  version: '7.0.3',
  Mongoose: [Function: Mongoose],
  SchemaType: [Function: SchemaType] {
    cast: [Function: cast],
    set: [Function: set],
    get: [Function (anonymous)],
    _isRef: [Function (anonymous)],
    checkRequired: [Function (anonymous)],
    CastError: [class CastError extends MongooseError],
    ValidatorError: [class ValidatorError extends MongooseError]
  },
  SchemaTypes: {
    String: [Function: SchemaString] {
      schemaName: 'String',
      defaultOptions: {},
      _cast: [Function: castString],
      cast: [Function: cast],
      _defaultCaster: [Function (anonymous)],
      get: [Function (anonymous)],
      set: [Function: set],
      _checkRequired: [Function (anonymous)],
      checkRequired: [Function (anonymous)]
    },
    Number: [Function: SchemaNumber] {
      get: [Function (anonymous)],
      set: [Function: set],
      _cast: [Function: castNumber],
      cast: [Function: cast],
      _defaultCaster: [Function (anonymous)],
      schemaName: 'Number',
      defaultOptions: {},
      _checkRequired: [Function (anonymous)],
      checkRequired: [Function (anonymous)]
    },
    Boolean: [Function: SchemaBoolean] {
      schemaName: 'Boolean',
      defaultOptions: {},
      _cast: [Function],
      set: [Function: set],
      cast: [Function: cast],
      _defaultCaster: [Function (anonymous)],
      _checkRequired: [Function (anonymous)],
      checkRequired: [Function (anonymous)],
      '$conditionalHandlers': [Object]
    },
    DocumentArray: [Function: DocumentArrayPath] {
      schemaName: 'DocumentArray',
      options: [Object],
      defaultOptions: {},
      set: [Function: set]
    },
    Subdocument: [Function: SubdocumentPath] {
      defaultOptions: {},
      set: [Function: set]
    },
    Array: [Function: SchemaArray] {
      schemaName: 'Array',
      options: [Object],
      defaultOptions: {},
      set: [Function: set],
      _checkRequired: [Function (anonymous)],
      checkRequired: [Function (anonymous)]
    },
    Buffer: [Function: SchemaBuffer] {
      schemaName: 'Buffer',
      defaultOptions: {},
      _checkRequired: [Function (anonymous)],
      set: [Function: set],
      checkRequired: [Function (anonymous)]
    },
    Date: [Function: SchemaDate] {
      schemaName: 'Date',
      defaultOptions: {},
      _cast: [Function: castDate],
      set: [Function: set],
      cast: [Function: cast],
      _defaultCaster: [Function (anonymous)],
      _checkRequired: [Function (anonymous)],
      checkRequired: [Function (anonymous)]
    },
    ObjectId: [Function: ObjectId] {
      schemaName: 'ObjectId',
      defaultOptions: {},
      get: [Function (anonymous)],
      set: [Function: set],
      _checkRequired: [Function (anonymous)],
      _cast: [Function: castObjectId],
      cast: [Function: cast],
      _defaultCaster: [Function (anonymous)],
      checkRequired: [Function (anonymous)]
    },
    Mixed: [Function: Mixed] {
      schemaName: 'Mixed',
      defaultOptions: {},
      get: [Function (anonymous)],
      set: [Function: set]
    },
    Decimal: [Function: Decimal128] {
      schemaName: 'Decimal128',
      defaultOptions: {},
      _cast: [Function: castDecimal128],
      set: [Function: set],
      cast: [Function: cast],
      _defaultCaster: [Function (anonymous)],
      _checkRequired: [Function (anonymous)],
      checkRequired: [Function (anonymous)]
    },
    Decimal128: [Function: Decimal128] {
      schemaName: 'Decimal128',
      defaultOptions: {},
      _cast: [Function: castDecimal128],
      set: [Function: set],
      cast: [Function: cast],
      _defaultCaster: [Function (anonymous)],
      _checkRequired: [Function (anonymous)],
      checkRequired: [Function (anonymous)]
    },
    Map: [class Map extends SchemaType] {
      schemaName: 'Map',
      defaultOptions: {}
    },
    UUID: [Function: SchemaUUID] {
      schemaName: 'UUID',
      defaultOptions: {},
      _cast: [Function (anonymous)],
      set: [Function: set],
      cast: [Function: cast],
      _checkRequired: [Function (anonymous)],
      checkRequired: [Function (anonymous)]
    },
    Oid: [Function: ObjectId] {
      schemaName: 'ObjectId',
      defaultOptions: {},
      get: [Function (anonymous)],
      set: [Function: set],
      _checkRequired: [Function (anonymous)],
      _cast: [Function: castObjectId],
      cast: [Function: cast],
      _defaultCaster: [Function (anonymous)],
      checkRequired: [Function (anonymous)]
    },
    Object: [Function: Mixed] {
      schemaName: 'Mixed',
      defaultOptions: {},
      get: [Function (anonymous)],
      set: [Function: set]
    },
    Bool: [Function: SchemaBoolean] {
      schemaName: 'Boolean',
      defaultOptions: {},
      _cast: [Function],
      set: [Function: set],
      cast: [Function: cast],
      _defaultCaster: [Function (anonymous)],
      _checkRequired: [Function (anonymous)],
      checkRequired: [Function (anonymous)],
      '$conditionalHandlers': [Object]
    },
    ObjectID: [Function: ObjectId] {
      schemaName: 'ObjectId',
      defaultOptions: {},
      get: [Function (anonymous)],
      set: [Function: set],
      _checkRequired: [Function (anonymous)],
      _cast: [Function: castObjectId],
      cast: [Function: cast],
      _defaultCaster: [Function (anonymous)],
      checkRequired: [Function (anonymous)]
    }
  },
  VirtualType: [Function: VirtualType],
  Types: {
    Array: [Function: MongooseArray],
    Buffer: [Function: MongooseBuffer] {
      pathSymbol: Symbol(mongoose#Buffer#_path),
      mixin: [Object],
      Binary: [Function]
    },
    Embedded: [Function: ArraySubdocument] {
      _events: undefined,
      _eventsCount: 0,
      _maxListeners: undefined,
      setMaxListeners: [Function: setMaxListeners],
      getMaxListeners: [Function: getMaxListeners],
      emit: [Function: emit],
      addListener: [Function: addListener],
      on: [Function: addListener],
      prependListener: [Function: prependListener],
      once: [Function: once],
      prependOnceListener: [Function: prependOnceListener],
      removeListener: [Function: removeListener],
      off: [Function: removeListener],
      removeAllListeners: [Function: removeAllListeners],
      listeners: [Function: listeners],
      rawListeners: [Function: rawListeners],
      listenerCount: [Function: listenerCount],
      eventNames: [Function: eventNames]
    },
    Document: [Function: ArraySubdocument] {
      _events: undefined,
      _eventsCount: 0,
      _maxListeners: undefined,
      setMaxListeners: [Function: setMaxListeners],
      getMaxListeners: [Function: getMaxListeners],
      emit: [Function: emit],
      addListener: [Function: addListener],
      on: [Function: addListener],
      prependListener: [Function: prependListener],
      once: [Function: once],
      prependOnceListener: [Function: prependOnceListener],
      removeListener: [Function: removeListener],
      off: [Function: removeListener],
      removeAllListeners: [Function: removeAllListeners],
      listeners: [Function: listeners],
      rawListeners: [Function: rawListeners],
      listenerCount: [Function: listenerCount],
      eventNames: [Function: eventNames]
    },
    DocumentArray: [Function: MongooseDocumentArray],
    Decimal128: [class Decimal128 extends BSONValue],
    ObjectId: [class ObjectId extends BSONValue] { index: 7107676 },
    Map: [class MongooseMap extends Map],
    Subdocument: [Function: Subdocument]
  },
  Query: [Function: Query] {
    base: {
      toConstructor: [Function: toConstructor],
      setOptions: [Function (anonymous)],
      collection: [Function: collection],
      collation: [Function (anonymous)],
      '$where': [Function (anonymous)],
      where: [Function (anonymous)],
      equals: [Function: equals],
      eq: [Function: eq],
      or: [Function: or],
      nor: [Function: nor],
      and: [Function: and],
      gt: [Function (anonymous)],
      gte: [Function (anonymous)],
      lt: [Function (anonymous)],
      lte: [Function (anonymous)],
      ne: [Function (anonymous)],
      in: [Function (anonymous)],
      nin: [Function (anonymous)],
      all: [Function (anonymous)],
      regex: [Function (anonymous)],
      size: [Function (anonymous)],
      maxDistance: [Function (anonymous)],
      minDistance: [Function (anonymous)],
      mod: [Function (anonymous)],
      exists: [Function (anonymous)],
      elemMatch: [Function (anonymous)],
      within: [Function: within],
      box: [Function (anonymous)],
      polygon: [Function (anonymous)],
      circle: [Function (anonymous)],
      near: [Function: near],
      intersects: [Function: intersects],
      geometry: [Function: geometry],
      select: [Function: select],
      slice: [Function (anonymous)],
      sort: [Function (anonymous)],
      limit: [Function (anonymous)],
      skip: [Function (anonymous)],
      batchSize: [Function (anonymous)],
      comment: [Function (anonymous)],
      maxTimeMS: [Function (anonymous)],
      maxTime: [Function (anonymous)],
      hint: [Function (anonymous)],
      j: [Function: j],
      slaveOk: [Function (anonymous)],
      setReadPreference: [Function (anonymous)],
      read: [Function (anonymous)],
      r: [Function (anonymous)],
      readConcern: [Function (anonymous)],
      tailable: [Function (anonymous)],
      w: [Function: writeConcern],
      writeConcern: [Function: writeConcern],
      wTimeout: [Function: wtimeout],
      wtimeout: [Function: wtimeout],
      merge: [Function (anonymous)],
      find: [Function (anonymous)],
      _find: [AsyncFunction: _find],
      cursor: [Function (anonymous)],
      findOne: [Function (anonymous)],
      _findOne: [AsyncFunction: _findOne],
      count: [Function (anonymous)],
      _count: [AsyncFunction: _count],
      distinct: [Function (anonymous)],
      _distinct: [AsyncFunction: _distinct],
      updateMany: [Function: updateMany],
      _updateMany: [AsyncFunction (anonymous)],
      updateOne: [Function: updateOne],
      _updateOne: [AsyncFunction (anonymous)],
      replaceOne: [Function: replaceOne],
      _replaceOne: [AsyncFunction (anonymous)],
      deleteOne: [Function (anonymous)],
      _deleteOne: [AsyncFunction (anonymous)],
      deleteMany: [Function (anonymous)],
      _deleteMany: [AsyncFunction (anonymous)],
      findOneAndUpdate: [Function (anonymous)],
      _findOneAndUpdate: [AsyncFunction (anonymous)],
      findOneAndDelete: [Function (anonymous)],
      findOneAndRemove: [Function (anonymous)],
      _findOneAndRemove: [AsyncFunction (anonymous)],
      setTraceFunction: [Function (anonymous)],
      exec: [AsyncFunction: exec],
      then: [AsyncFunction (anonymous)],
      selected: [Function: selected],
      selectedInclusively: [Function: selectedInclusively],
      selectedExclusively: [Function: selectedExclusively],
      _mergeUpdate: [Function (anonymous)],
      _optionsForExec: [Function (anonymous)],
      _fieldsForExec: [Function (anonymous)],
      _updateForExec: [Function (anonymous)],
      _ensurePath: [Function (anonymous)],
      _validate: [Function (anonymous)]
    },
    'use$geoWithin': true
  },
  Model: Model { undefined },
  Document: [Function: Document] {
    _events: undefined,
    _eventsCount: 0,
    _maxListeners: undefined,
    setMaxListeners: [Function: setMaxListeners],
    getMaxListeners: [Function: getMaxListeners],
    emit: [Function: emit],
    addListener: [Function: addListener],
    on: [Function: addListener],
    prependListener: [Function: prependListener],
    once: [Function: once],
    prependOnceListener: [Function: prependOnceListener],
    removeListener: [Function: removeListener],
    off: [Function: removeListener],
    removeAllListeners: [Function: removeAllListeners],
    listeners: [Function: listeners],
    rawListeners: [Function: rawListeners],
    listenerCount: [Function: listenerCount],
    eventNames: [Function: eventNames],
    ValidationError: [class ValidationError extends MongooseError]
  },
  ObjectId: [Function: ObjectId] {
    schemaName: 'ObjectId',
    defaultOptions: {},
    get: [Function (anonymous)],
    set: [Function: set],
    _checkRequired: [Function (anonymous)],
    _cast: [Function: castObjectId],
    cast: [Function: cast],
    _defaultCaster: [Function (anonymous)],
    checkRequired: [Function (anonymous)]
  },
  isValidObjectId: [Function (anonymous)],
  isObjectIdOrHexString: [Function (anonymous)],
  syncIndexes: [Function (anonymous)],
  Decimal128: [Function: Decimal128] {
    schemaName: 'Decimal128',
    defaultOptions: {},
    _cast: [Function: castDecimal128],
    set: [Function: set],
    cast: [Function: cast],
    _defaultCaster: [Function (anonymous)],
    _checkRequired: [Function (anonymous)],
    checkRequired: [Function (anonymous)]
  },
  Mixed: [Function: Mixed] {
    schemaName: 'Mixed',
    defaultOptions: {},
    get: [Function (anonymous)],
    set: [Function: set]
  },
  Date: [Function: SchemaDate] {
    schemaName: 'Date',
    defaultOptions: {},
    _cast: [Function: castDate],
    set: [Function: set],
    cast: [Function: cast],
    _defaultCaster: [Function (anonymous)],
    _checkRequired: [Function (anonymous)],
    checkRequired: [Function (anonymous)]
  },
  Number: [Function: SchemaNumber] {
    get: [Function (anonymous)],
    set: [Function: set],
    _cast: [Function: castNumber],
    cast: [Function: cast],
    _defaultCaster: [Function (anonymous)],
    schemaName: 'Number',
    defaultOptions: {},
    _checkRequired: [Function (anonymous)],
    checkRequired: [Function (anonymous)]
  },
  Error: [class MongooseError extends Error] {
    messages: {
      DocumentNotFoundError: null,
      general: [Object],
      Number: [Object],
      Date: [Object],
      String: [Object]
    },
    Messages: {
      DocumentNotFoundError: null,
      general: [Object],
      Number: [Object],
      Date: [Object],
      String: [Object]
    },
    DocumentNotFoundError: [class DocumentNotFoundError extends MongooseError],
    CastError: [class CastError extends MongooseError],
    ValidationError: [class ValidationError extends MongooseError],
    ValidatorError: [class ValidatorError extends MongooseError],
    VersionError: [class VersionError extends MongooseError],
    ParallelSaveError: [class ParallelSaveError extends MongooseError],
    OverwriteModelError: [class OverwriteModelError extends MongooseError],
    MissingSchemaError: [class MissingSchemaError extends MongooseError],
    MongooseServerSelectionError: [class MongooseServerSelectionError extends MongooseError],
    DivergentArrayError: [class DivergentArrayError extends MongooseError],
    StrictModeError: [class StrictModeError extends MongooseError],
    StrictPopulateError: [class StrictPopulateError extends MongooseError]
  },
  now: [Function: now],
  CastError: [class CastError extends MongooseError],
  SchemaTypeOptions: [class SchemaTypeOptions],
  mongo: {
    BSON: [Getter],
    Binary: [Getter],
    BSONRegExp: [Getter],
    BSONSymbol: [Getter],
    BSONType: [Getter],
    Code: [Getter],
    DBRef: [Getter],
    Decimal128: [Getter],
    Double: [Getter],
    Int32: [Getter],
    Long: [Getter],
    MaxKey: [Getter],
    MinKey: [Getter],
    ObjectId: [Getter],
    Timestamp: [Getter],
    MongoBulkWriteError: [Getter],
    ChangeStreamCursor: [Getter],
    MongoAPIError: [Getter],
    MongoAWSError: [Getter],
    MongoBatchReExecutionError: [Getter],
    MongoChangeStreamError: [Getter],
    MongoCompatibilityError: [Getter],
    MongoCursorExhaustedError: [Getter],
    MongoCursorInUseError: [Getter],
    MongoDecompressionError: [Getter],
    MongoDriverError: [Getter],
    MongoError: [Getter],
    MongoExpiredSessionError: [Getter],
    MongoGridFSChunkError: [Getter],
    MongoGridFSStreamError: [Getter],
    MongoInvalidArgumentError: [Getter],
    MongoKerberosError: [Getter],
    MongoMissingCredentialsError: [Getter],
    MongoMissingDependencyError: [Getter],
    MongoNetworkError: [Getter],
    MongoNetworkTimeoutError: [Getter],
    MongoNotConnectedError: [Getter],
    MongoParseError: [Getter],
    MongoRuntimeError: [Getter],
    MongoServerClosedError: [Getter],
    MongoServerError: [Getter],
    MongoServerSelectionError: [Getter],
    MongoSystemError: [Getter],
    MongoTailableCursorError: [Getter],
    MongoTopologyClosedError: [Getter],
    MongoTransactionError: [Getter],
    MongoUnexpectedServerResponseError: [Getter],
    MongoWriteConcernError: [Getter],
    AbstractCursor: [Getter],
    Admin: [Getter],
    AggregationCursor: [Getter],
    CancellationToken: [Getter],
    ChangeStream: [Getter],
    ClientSession: [Getter],
    Collection: [Getter],
    Db: [Getter],
    FindCursor: [Getter],
    GridFSBucket: [Getter],
    GridFSBucketReadStream: [Getter],
    GridFSBucketWriteStream: [Getter],
    ListCollectionsCursor: [Getter],
    ListIndexesCursor: [Getter],
    MongoClient: [Getter],
    OrderedBulkOperation: [Getter],
    UnorderedBulkOperation: [Getter],
    BatchType: [Getter],
    GSSAPICanonicalizationValue: [Getter],
    AuthMechanism: [Getter],
    Compressor: [Getter],
    CURSOR_FLAGS: [Getter],
    AutoEncryptionLoggerLevel: [Getter],
    MongoErrorLabel: [Getter],
    ExplainVerbosity: [Getter],
    ServerApiVersion: [Getter],
    ReturnDocument: [Getter],
    ProfilingLevel: [Getter],
    ReadConcernLevel: [Getter],
    ReadPreferenceMode: [Getter],
    ServerType: [Getter],
    TopologyType: [Getter],
    ReadConcern: [Getter],
    ReadPreference: [Getter],
    WriteConcern: [Getter],
    CommandFailedEvent: [Getter],
    CommandStartedEvent: [Getter],
    CommandSucceededEvent: [Getter],
    ConnectionCheckedInEvent: [Getter],
    ConnectionCheckedOutEvent: [Getter],
    ConnectionCheckOutFailedEvent: [Getter],
    ConnectionCheckOutStartedEvent: [Getter],
    ConnectionClosedEvent: [Getter],
    ConnectionCreatedEvent: [Getter],
    ConnectionPoolClearedEvent: [Getter],
    ConnectionPoolClosedEvent: [Getter],
    ConnectionPoolCreatedEvent: [Getter],
    ConnectionPoolMonitoringEvent: [Getter],
    ConnectionPoolReadyEvent: [Getter],
    ConnectionReadyEvent: [Getter],
    ServerClosedEvent: [Getter],
    ServerDescriptionChangedEvent: [Getter],
    ServerHeartbeatFailedEvent: [Getter],
    ServerHeartbeatStartedEvent: [Getter],
    ServerHeartbeatSucceededEvent: [Getter],
    ServerOpeningEvent: [Getter],
    TopologyClosedEvent: [Getter],
    TopologyDescriptionChangedEvent: [Getter],
    TopologyOpeningEvent: [Getter],
    SrvPollingEvent: [Getter]
  },
  mquery: [Function: Query] {
    permissions: {
      distinct: [Function],
      findOneAndRemove: [Function],
      findOneAndUpdate: [Function],
      count: [Function]
    },
    _isPermitted: [Function (anonymous)],
    canMerge: [Function (anonymous)],
    setGlobalTraceFunction: [Function (anonymous)],
    utils: {
      clone: [Function: clone],
      cloneObject: [Function: cloneObject],
      cloneArray: [Function: cloneArray],
      merge: [Function: merge],
      mergeClone: [Function: mergeClone],
      readPref: [Function: readPref],
      readConcern: [Function: readConcern],
      toString: [Function (anonymous)],
      isObject: [Function (anonymous)],
      keys: [Function: keys],
      create: [Function: create],
      inherits: [Function (anonymous)],
      isArgumentsObject: [Function (anonymous)]
    },
    env: { isNode: [Array], isMongo: false, isBrowser: false, type: 'node' },
    Collection: [class NodeCollection extends Collection],
    BaseCollection: [Function: Collection] { methods: [Array] }
  },
  sanitizeFilter: [Function: sanitizeFilter],
  trusted: [Function: trusted],
  skipMiddlewareFunction: [Function: skipWrappedFunction],
  overwriteMiddlewareResult: [Function: overwriteResult]
}

mongoose是什么

Mongoose 是 MongoDB 的对象建模工具。

Mongoose 用于和MongoDB 通信(增删改查)。

Mongoose运行在Node.js 平台。

Mongoose()是一个构造函数
引入mongoose模块会自动创建一个mongoose实例对象。

mongoose.connect()

定义

mongoose.connect()用于连接MongoDB数据库。

它是一个异步函数。

语法

mongoose.connect(uri)
mongoose.connect(数据库连接字符串)

返回值

返回一个Promise对象

示例

promise.then()

定义

then()方法为promise绑定回调函数。

语法

promise.then(resolved,rejected)
promise.then((data) => {
  //在异步操作成功时，处理异步操作的结果
},(error) => {
  //在异步操作失败时，输出错误的原因
})

//一个参数：大多时候我们更加关注异步操作成功
promise.then((resolved) => {
  //在异步操作成功时，处理异步操作的结果
})

//then()方法可以链式调用
promise.then((resolved) => {
  //在异步操作成功时，处理异步操作的结果
})
  .then((resolved) => {})
	.then((resolved) => {})
	.catch(error => {//捕获错误信息})

then() 方法最多接受两个参数：

resolved :Promise 已完成的回调函数。
rejected: Promise已拒绝的回调函数。

返回值

返回一个等效的prmose对象。

示例

promise.catch()

定义

catch()方法用于为promise对象绑定请求失败时的回调函数。

catch()方法用于捕获错误信息。

语法

promise.catch((err) => {})

返回值

返回一个promise对象。

示例

mongoose.model()

定义

用于创建与MongoDB数据库通信的工具。

该工具在这里意思就是：指一个构造函数。

构造函数可以实例化一个对象。

通过实例对象的方法与数据库进行通信。

语法

const Blog = mongoose.model('模型名称',模型原型)
const Blog = mongoose.model('模型名称',blogSchema)

返回值

返回大写的构造函数（Model()）

示例

Schema()

定义

Schema()是一个构造函数/类。

Schema()用于描述数据表的结构。

数据库：由多个数据库表构成
数据库表：由多个document(记录)构成。
Document: 由字段和值构成。

语法

 new Schema({定义表结构},{选项对象})

const blogSchema = new Schema({
  //定义title字段
  title: {
    //字段类型：字符串
    type: String,
    //字段是否必写: true
    required: true
  },
  body: {
    type: String,
    required: true
  }
}, {})

定义表结构：定义有哪些字段、每个字段的数据类型、是否必填等
选项对象：提供了一些参数，用来配置第一个参数

返回值

返回schema实例对象,表示数据结构。

示例

4月3日

使用Node.js开发App的步骤

创建项目目录

mkdir myapp
cd myapp
# 合并以上两步骤
mkdir myapp && cd myapp

初始化

npm init --yes //目的：创建package.json文件，该文件记录了项目项目信息及项目中所有使用的模块。

创建项目结构

myapp
- views 
- public
- routes
- package.json
- package-lock.json
- app.js

安装模块
```
npm install express
```
引入模块
```
const express = require('express')
```
写需求
```
.....
```

网站根目录

\ ~

查看当前位置： pwd
项目根目录：访问权限设置为公开的、任何人都可以访问的。

public目录

定义

Public 目录是Node.js中存放网站静态文件的目录。静态文件包括：

图片
css文件
js文件
字体文件

mkdir public && cd public
mkdir css js images

Public : 公共的、共同的、公开

express框架

框架的核心是构造函数express()
Express() 构造函数用于创建一个APP实例（服务器类型的app）
express是基于Node.js平台
Node.js平台是运行js文件的。
Node.js项目目录
- index.js app.js server.js
- views
  - html视图模版
    - ejs视图引擎
- public
  - 引入静态资源
普通项目目录
- index.html
- css
  - style.css
- js
  - Script.js

知识点1：express.static()

定义

语法

返回值

示例

知识点2：创建数据库

方案1：创建本地mongodb数据库

启动mongodb数据库

# window系统
服务 => 右键 => 启动
# Mac OS
brew services start mongodb/brew/mongodb-community

连接数据库（怎么和数据库通信？）
1. 可以使用可视化软件Compass
2. 非可视化软件：mongosh

mongosh "mongodb://localhost:27017"

创建数据库: zhangsanblog
1. 使用compass手动创建
2. 使用mongosh手动创建
```
use zhangsanblog
```

创建数据库用户

语法

Db.createUser({
	user: 'zhangsan',
	pwd: '123456',
	roles: [{ role:"readWrite",db:"config"},"clusterAdmin"],
	roles: ["readWrite"]
})

方案2：创建云数据库

登录Atlas账户
创建数据库： zhangsanblog
创建用户: zhangsan Zxcvbn123456

知识点3：连接字符串

定义

连接字符串特指在App开发过程中连接数据库的地址。

语法

"协议://用户名:密码@数据库地址/数据库名"

云数据库的连接字符串

从云数据库复制的连接字符串：
'mongodb+srv://<username>:<password>@zhangsanblog.4t6hj0s.mongodb.net/?retryWrites=true&w=majority'
用你的用户名和密码替换<username>和<password>
'mongodb+srv://zhangsan:Zxcvbn123456@zhangsanblog.4t6hj0s.mongodb.net/?retryWrites=true&w=majority'

本地数据库的连接字符串

"mongodb://zhangsan:123456@127.0.0.1:27107/zhangsanblog"
"mongodb://zhangsan:123456@localhost:27107/zhangsanblog"

知识点4：Node和MongoDB的通信

通信方式有两种：

Mongodb模块:
- mongodb模块是Node.js原生提供的与mongoDB数据库通信的API。
Mongoose模块:
- 是第三方提供的在Node平台与MongoDB数据库通信的方式。
- Mongoose是一个库。
- 库：就是函数的集合。
- Mongoose库包裹Node API。

知识点5：使用Mongoose模块连接数据库

const mongoose = require('mongoose')

mongoose.connect(uri)
    .then((result) => {
        console.log('数据库已经连接')
    })
    .catch( err => console.log(err))

mongoose是什么

mongoose的核心是mongoose()构造函数
mongoose是一个ODM(对象数据模型)。（Object Data Model)
- 使用JS对象的语法来映射MongoDB数据库中的表和document
  - collection：数据库中的表。
  - Document: 表中的一条记录

Schema()

Schema()是一个构造函数。
Schema()构造函数用于创建实例对象。
每一个schema实例对象映射一个MongoDB数据库表。
- 定义表中的document结构

语法

new Schema(obj,options)
new Schema({定义数据库表结构},{选项对象:描述前面的表})

返回值

返回schema对象

示例：创建一个blogSchema表，用来存储博客的文章

const blogSchema = new Schema({
  title:{
    type: String,
    required: true
  },
  author:{
    type: String,
    required: true
  },
  snippet: {
    type: String,
    required: true
  },
  body:{
    type: String,
    required: true
  }
},{})

连接数据库

打开app.js文件

4月1日总结

Node.js是什么？

Node.js是基于V8引擎的JS运行环境。
Node.js和Express的关系
- Node.js用于构建服务器
- Express是一个Node框架：基于Node平台开发APP这件事变得更容易。同时对Node开发进行了扩展。

Express框架构建App的步骤

第一步：使用npm init进行初始化

mkdir myapp
cd myapp
npm init --yes

第二步：安装express

npm install express  //局部安装
npm install -g express //全局安装

第三步：导入express

New-item app.js
# 打开app.js 输入
const express = require('express')

第四步：构建APP实例

const app = express() //返回运行在node服务器上的app实例对象。

第五步：监听服务器端口3000

app.listen(3000,() => {
  '服务器已运行在: http://localhost:3000'
})

第6步：配置路由

//get请求 200成功
app.get('/',(req,res) => {
  //res.send()//发送 text/plain||text/html
  //res.sendFile() //发送文件内容  application/json
  res.render()//渲染视图模版
})
//get请求 301转向
app.get('./about-us',(req,res) => {
  res.redirect('./about')//重定向到'./about'请求
})
//get请求 404页面未找到  必须放最后
app.use((req,res) => {
  res.status(404).render('404')
})

0331

express是什么

express是Nodejs服务器的框架
express是一个Node.js的模块

express()

定义

Express()是该框架的核心函数
express()用于创建一个APP(Node.js + Express)
exrpess()函数是一个顶级函数

语法

const express = require('express')

express()的方法

express.json()
express.static()
express.Router()
express.urlencoded()

返回值

示例

app.get()

定义

app.get()方法通过回调函数处理GET请求。

官方：通过回调函数把请求路由到指定路径。

语法

app.get(path,callback)
app.get('请求地址',回调函数) //=> 中间件函数(勾子函数)
app.get('/', (req, res) => {
  console.log(req) //req就是Node.js的request对象
  console.log(res)//res就是Node.js的response对象
})

返回值

示例

app.use()

定义

app.use()在指定路径上挂载中间件函数。

语法

app.use([path,] callback [, callback...])
app.use('路径', 回调函数)

app.use('/about',() => {})
app.use(() => {}) //不写路径，那意味着所有路径都会执行回调

返回值

示例

app.listen()

定义

app.listen() 用于为app绑定监听，监听主机端口是否有请求进来。此方法与 Node 的 http.Server.listen() 相同。

语法

app.listen([port[, host[, backlog]]][, callback])
app.listen(端口号,主机名,回调函数)

返回值

示例

res.sendFile()

定义

按照指定路径发送响应数据(作为响应数据)。

根据文件扩展名设置 Content-Type 响应 HTTP 标头字段。
除非在选项对象中设置了根选项，否则路径必须是文件的绝对路径。

语法

res.sendFile(path [, options] [, fn])
res.sendFile('路径' {选项对象},回调函数)

path必须是一个绝对路径
path如果是一个相对路径，那么你必须在选项对象中设置根选项。

返回值

示例

options

定义

options 就是选项对象。

它是一个对象
对象里存储的是一些属性参数。

{
  path:'',
  chaset: 'utf-8'
}

res.status()

定义

设置响应的 HTTP 状态码。支持链式调用

语法

res.status(403).end()
res.status(400).send('Bad Request')
res.status(400).sendFile('/absolute/path/404.png')

返回值

返回响应对象。

示例

ejs是什么

ejs是 Embedded JavaScript templating的缩写，
ejs的意思：嵌入js的HTML模版(不是嵌入到<script>里)。
ejs是面向服务端的
- ejs是在服务端把js嵌入到html页面里
- 服务端解析ejs语法 => 翻译成html
- 把编译后的html返给浏览器端
- ejs实现的功能类似于php实现的功能：动态渲染数据到HTML页面里。
JS是面向浏览器端的脚本语言。
PHP是面向服务端的脚本语言。
- 为什么能够解析PHP，因为服务端安装了PHP软件

//ejs代码
<ul>
  <% users.forEach(function(user){ %>
    <%- include('user/show', {user: user}); %>
  <% }); %>
</ul>

app.set()

定义

app.set()方法用于：1.存储自定义值 2.配置服务器行为。

服务器行为有些特殊的字段，用于配置服务器行为：

res.render()

定义

render()方法用于编译ejs模版，把编译后的html代码发送给客户端。

语法

res.render(view [, locals] [, callback])
res.render(视图,{选项},回调函数)

选项对象：向视图传递变量

EJS的语法

<% 嵌入脚本的开始控制代码流
%> 嵌入脚本的结束
<%= 出计算值
<%- 直接输出

0330

http模块

http模块是Node的内置模块。
http模块用于构建服务器。

1.http.createServer()

定义

用于创建一个Node服务器。主要做了两件事：

处理请求
处理响应

语法

http.createServer({选项对象},监听函数)

选项对象：可选。是一个object,通过选项对象，传入一些参数。

监听函数：是一个回调函数。当用户请求从端口进来后，该函数立刻被调用。

Request对象：请求对象
- 请求对象：包含与请求有关信息。
Response对象:响应对象
- 响应对象：包含与响应有关的信息。

返回值

createServer() 方法返回一个Server对象。

示例：

2.server.listen()

定义

用于监听服务器端口。

语法

server.listen()
server.listen([port[,host][,callback])
server.listen(端口,主机名,回调函数)

端口：数值
主机名：字符串
连接数：数值(最大511)
回调函数：function

返回值

返回服务器对象

示例

3.res.setHeader()

定义

用于设置响应头信息。特点：

只能设置一个值
多次执行
优先级低于res.writeHead()

语法

res.setHeader(name, value)
res.setHeader(响应头属性名, 对应的值)

返回值

无

示例

res.setHeader("Content-Type","text/html")
res.setHeader("Content-Type","text/plain")
res.setHeader("Content-Type", "application/json")

4.res.write()

定义

write()方法用于设置响应数据。

语法

response.write(chunk[, encoding][, callback]);
response.write(数据[,字符编码][, 回调函数]);

返回值

布尔值

示例

5.res.writeHead()

定义

用于设置响应头信息。特点：

设置多个值
只能执行一次
优先级高于res.setHeader()

语法

res.writeHead(statusCode[, statusMessage][, headers]);
res.writeHead(状态码,'状态信息',{响应头});

返回值

返回一个响应对象。以便进行链式调用。

示例

6.res.end()

定义

end()用于通知服务器响应结束。该方法在响应时必须调用。

语法

response.end([data[, encoding]][, callback])
res.end('数据','字符编码',回调函数)

返回值

返回this

示例

读取文件内容

const http = require('node:http')
const fs = require('fs')

const server = http.createServer((req,res) => {
    // console.log(res);//响应对象[ServerResponse]
    // console.log(req);//请求对象[inComingMessage]
    console.log(req.url);
    //设置响应头的数据类型
    // res.setHeader('Content-Type', 'text/html;charset=utf-8')
    // res.write('<h1>你好世界</h1>')
    // res.write('<h2>你好中国</h2>')
    // res.end()

    //读取index.html内容作为响应数据
    res.setHeader('Content-Type', 'text/html;charset=utf-8')
    fs.readFile('./views/index.html',(err,data) => {  
        if(err){
            console.log(err);
            res.end()
        } else {
            res.end(data)//把数据写在这里
        }
    })
    
})

server.listen(3000,'localhost',511,() => {
    console.log('服务器已经运行在http://localhost:3000');
})

添加路由

const http = require('node:http')
const fs = require('fs')

const server = http.createServer((req,res) => {
    console.log(req.url);
    res.setHeader('Content-Type', 'text/html;charset=utf-8')
  //添加路由
    //条件判断 path  = './views/index.html'
     
    // fs.readFile('./views/index.html',(err,data) => {
    // fs.readFile('./views/about.html',(err,data) => {
    fs.readFile('./views/404.html',(err,data) => {
        if(err){
            console.log(err);
            res.end()
        } else {
            res.end(data)//把数据写在这里
        }
    })
    
})

server.listen(3000,'localhost',511,() => {
    console.log('服务器已经运行在http://localhost:3000');
})

3月30日下午

熟练掌握node.js路由的原生写法

const http = require('node:http')
const fs = require('fs')

const server = http.createServer((req, res) => {
    console.log(req.url);
    res.setHeader('Content-Type', 'text/html;charset=utf-8')
    //////////////添加路由:router/////////////////
    //条件判断 path  = './views/index.html'
    let path = './views/'
    switch (req.url) {
        case '/':
            path += 'index.html'
            res.statusCode = 200
            break
        case '/about':
            path += 'about.html'
            res.statusCode = 200
            break
        case '/about-me':
            res.setHeader('Location', '/about')
            res.statusCode = 301
            break
        default:
            path += '404.html'
            res.statusCode = 404
    }
    // fs.readFile('./views/index.html',(err,data) => {
    // fs.readFile('./views/about.html',(err,data) => {
    fs.readFile(path, (err, data) => {
        if (err) {
            console.log(err);
            res.end()
        } else {
            res.end(data)//把数据写在这里
        }
    })

})

server.listen(3000, 'localhost', 511, () => {
    console.log('服务器已经运行在http://localhost:3000');
})

Npm install

语法

npm install module-name
npm install -g module-name # -g：全局安装
npm i module-name  # npm i是npm install的别名
npm install module-name --save
npm install module-name --not--save
npm install module-name --save-dev

express写路由

const express = require('express')
const app = express()

app.get('/', function (req, res) {
    // res.send('Hello World')
    res.sendFile('./views/index.html',{root:__dirname})
})
app.get('/about', function (req, res) {
    res.sendFile('./views/about.html',{root:__dirname})
})
app.get('/about-me', function (req, res) {
    res.redirect('/about')
})

//404 page
app.use((req,res) => {
    res.status(404).sendFile('./views/404.html',{root:__dirname})
})

app.listen(3000)

0329

明日日考

__dirname是什么

表示当前文件(模块)所在的目录名称
__filename是什么

表示当前文件(模块)的名称
path模块的用途是什么?

提供了处理路径的API，路径分为文件路径、文件夹路径
如何把一个字符串路径转成对象?

path.parse()
如何提取当前Js文件的文件名?

path.basename('路径','删除的后缀名')

path.basename(__filename,'.js')
path.join('/fold1'，//folder2'，../index.html') 的结果是什么?

\fold1\index.html
path.resolve('/fold1'，/folder2'，../hello.html') 的结果是什么?

当前根目录:\hello.html

写出读取同级文件data.txt内容的代码 Data.txt

Hello

index.js

const fs = require("node:fs")
1.const content = fs.readFileSync('./data.text','utf-8')
  console.log(content);

2.const content = fs.readFile('./data.text','utf-8',(err,data)=>{
    if(err){
        console.log(err);
    }else{
        console.log(data)
    }
})
//Hello

NPM是什么?
- NPM 是"Node Package Manager"的缩写，Node软件包管理工具
package.json 文件的用途是什么?

用于描述和配置模块文件
如果说使用第三方模块一共有四步，你认为有哪四步?

第一步：查找模块，登录npm查询一个你要的第三方模块

第二步：安装模块

第三步：引入模块

第四步：使用模块

__dirname

定义

__dirname表示当前文件(模块)所在的目录名称

Dir: directory 文件夹、目录
Name: 名字

语法

console.log(__dirname);//全局变量

示例

console.log(__dirname);

输出

D:\wxy3\js\作业\2023\2023.3.29

绝对路径 vs 相对路径

#绝对路径
\wxy3\js\作业\2023\2023.3.29
\js\作业\2023\2023.3.29
作业\2023\2023.3.29
#相对路径
./wxy3/js/作业
wxy3/js/作业

__filename

定义

__filename表示当前文件(模块)的名称

file: 文件
Name: 名字

语法

console.log(__filename)

示例

console.log(__filename)

输出

D:\wxy3\js\作业、课堂\2023\3月\2023.3.29\global.js

内置模块 path

定义

node:path 是一个内置模块。它提供了处理路径的API。路径分为：

文件路径
文件夹路径

使用path模块，第一步做什么？

语法

require("node:path")

示例

const path = require("node:path")

console.log(__filename);
console.log(path.basename(__filename));
console.log(path.basename(__filename,'.js'));
console.log(path.basename(__dirname));

输出

D:\wxy3\js\作业、课堂\2023\3月\2023.3.29\path.js
path.js  
path     
2023.3.29

1.path.basename()

定义

语法

path.basename('路径','删除的后缀名')

返回值

返回 path 的最后一部分

示例

console.log(__filename);
console.log(path.basename(__filename));
console.log(path.basename(__filename,'.js'));
console.log(path.basename(__dirname));

输出

D:\wxy3\js\作业、课堂\2023\3月\2023.3.29\path.js
path.js
path
2023.3.29

2.path.dirname(path)

定义

dirname()用于返回当前目录的路径

语法

path.basename('路径','删除的后缀名')

返回值

无

示例

console.log(__dirname);
console.log(path.dirname(__dirname));

输出

D:\wxy3\js\作业、课堂\2023\3月\2023.3.29
D:\wxy3\js\作业、课堂\2023\3月

3.path.extname(path)

定义

返回的是当前文件的扩展名

语法

返回值

无

示例

输出

4.path.parse()

定义

parse() 方法：从路径字符串返回一个对象

语法

path.parse('路径')

返回值

返回一个表示路径的对象

示例

console.log(__filename);
console.log(path.parse(__filename));

输出

{
  root: 'D:\\',
  dir: 'D:\\wxy3\\js\\作业、课堂\\2023\\3月\\2023.3.29',
  base: 'path.js',
  ext: '.js',
  name: 'path'
}

5.path.format()

定义

format()方法：从路径对象转路径字符串

语法

path.format(路径)

返回值

返回路径字符串

示例

const obj = path.parse(__filename);
console.log(path.format(obj));
输出//D:\wxy3\js\作业、课堂\2023\3月\2023.3.29\path.js

6.path.join

定义

join()方法用于把路径片段连接为规范路径

简言之：连接路径片段

语法

path.join()
path.join('路径片段1','路径片段2'...)

返回值

返回一个拼接好的规范的路径

示例

const p = path.join('f1','f2','i.html')
console.log(p);
const p2 = path.join('/f1','f2','i.html')
console.log(p2);
const p3 = path.join('/f1','//f2','i.html')
console.log(p3);
const p4 = path.join('/f1','//f2','./i.html')
console.log(p4);
const p5 = path.join('/f1','//f2','../i.html')
console.log(p5);

示例

f1\f2\i.html
\f1\f2\i.html
\f1\f2\i.html
\f1\f2\i.html
\f1\i.html

7.path.isAbsolute

定义

isAbsolute()方法用于检测一个路径是否是绝对路径。

语法

path.isAbsolute(path)

返回值

返回布尔值true、false

示例

console.log(path.isAbsolute(__filename));//true
console.log(path.isAbsolute('./data.json'));//false

8.path.resolve()

定义

resolve()方法用于解析为绝对路径

语法

path.resolve([...paths])//路径片段

返回值

返回绝对路径字符串

示例

const p = path.resolve('f1','f2','i.html')
console.log(p);
const p2 = path.resolve('/f1','f2','i.html')
console.log(p2);
const p3 = path.resolve('/f1','//f2','i.html')
console.log(p3);
const p4 = path.resolve('/f1','//f2','./i.html')
console.log(p4);
const p5 = path.resolve('/f1','//f2','../i.html')
console.log(p5);

输出

D:\wxy3\js\作业、课堂\2023\3月\2023.3.29\f1\f2\i.html
D:\f1\f2\i.html
D:\f2\i.html
D:\f2\i.html
D:\i.html

FS模块(FS系统)

定义

FS 文件系统模块允许操作计算机系统上的的文件。具体操作如下：

读取
创建
修改
删除

引入FS模块系统

要使用fs文件系统，请先引入fs模块

语法：基于promise API（标准）

语法：基于回调函数（默认）

const fs = require("node:fs")

fs.readFile()

定义

readFile()方法用于(异步)读取文件内容。

语法

fs.readFile('文件路径',callback)
fs.readFile('文件路径',(err,data) => {
 if(err) console.log(err)
 console.log(data)
})

返回值

返回读取成功的内容。

数据类型：buffer

示例

const fs = require("node:fs")
const content = fs.readFile('./data.text','utf-8',(err,data)=>{
    if(err){
        console.log(err);
    }else{
        console.log(data)
    }
})
输出//hello

fs.writeFile()

定义

writeFile() 用于异步的写入文件数据。

语法

fs.writeFile(file, data[, options], callback)

返回值

示例

const fs = require("node:fs")

fs.writeFile('./data.md','hello',(err)=>{
    if(err){
        console.log(err);
    }else{
        console.log('成功')
    }
})
输出//成功

NPM是什么

NPM 是"Node Package Manager"的缩写，意思：Node软件包管理工具
NPM的主要内容
- 安装软件包
- 删除软件包
- 分享你自己写的软件包(npmjs.com)
NPM是世界上最大软件包平台。
NPM的构成：
- 官网(npmjs.com): 查询软件包
- CLI(Command Line Interface):命令行交互工具
- 软件注册表：JS软件包的仓库

package是什么

意思：软件包
一个package由1个或多个module组成。

package.json是什么

用于描述你的模块文件。
用于配置你的模块文件。
package.json描述了如何使用模块文件。
一个pacakge(软件包)必须包含一个package.json文件。
package.json文件的创建方法：
- 手动创建
- 半自动：npm init命令创建
- 自动：npm init --yes命令创建

node_modules

用于存储第三方模块的文件
打包项目发给别人之前，可删除node_modules文件夹，以减少文件体积。
注意：package.json和package-lock.json不能删
可使用 npm install 重新安装模块

module

模块就是一个js文件或文件夹
模块必须拥有package.json文件

第三方模块的使用方法

使用模块必须使用双引号！！！

第一步：创建文件夹

mkdir my-package

第二步：创建index.js

cd my-package
New-item index.js

第三步：安装upper-case模块

npm install upper-case

第四步：修改index.js内容

const upperCase = require('upper-case').upperCase
function hello(name){
    console.log(upperCase(`hello${name},welcome to you
    ！`));
}
hello('zs')
module.exports = hello

第五步：运行index.js

node index

输出结果

HELLOZS,WELCOME TO YOU！

版本号

NPM采用的是Sementic Version Controls系统

语法

X.Y.Z

1.1.3
初始版本号一般默认：0.1.0
正式发布：1.0.0

X : Major Version 主版本号：较大变化

Y: Minor Version 副版本号：增加了一个函数

Z: patch Version Bug版本号：修复bug

0328

项目介绍

【问候】：同学们好！老师好！我是xxx。

【项目介绍】

第一部分：介绍项目名称：图库APP

第二部分：效果展示

导航效果展示：什么时候显示? 什么时候隐藏？

屏幕变宽的时候显示导航，屏幕变窄的时候隐藏导航
图片效果展示：无限加载
1. 第一组图片默认加载20张
2. 滚动条滑动到底，加载第二组图片
3. 再次滑动到底，加载第三组图片

第三部分：项目技术介绍

这个项目一共用到了几种技术：

导航菜单使用的boostrap框架实现的。
图片数据使用的免费数据接口
加载图片使用了三种技术
- AJAX /Fetch API
  - fetch是基于ajax请求
- 懒加载
  - 懒加载就是按需加载。需要就加载，不需要就不加载，针对多图片的页面，只有当该图片出现在页面视区中，再加载该图片。可以防止页面一次性加载完所有的图片，用户等待时间长，影响用户体验。懒加载主要运用了滚动事件，这时候我遇到了一个问题：滚动的时候它会无限调用。在这里我用了一个开关控制，一组数据加载完就关闭，下一组数据加载时打开
- 瀑布流（图片排列）
  - 瀑布流是一种流式布局，它把内容分成多个模块从左到右依次排列，这些模块的宽度通常是相同的，但高度却不相同。当第二组内容被添加到页面上时，它会寻找各列之中所有元素高度之和的最小者，并将新的元素添加到该列上，然后继续寻找所有列的各元素之和的最小者，继续添加至该列上，如此循环下去，直至所有元素均能够按要求排列为止

http内置模块

http是node的内置模块

http.createServer()

读：亏诶特设我

定义

createServer()用于创建Node服务器

创建
res(Response)对象：响应对象
- 响应头：用于通知浏览器
  - 状态码
  - 数据类型是什么
  - 数据
  - 其他参数
req(Reqponse)对象：请求对象，使用请求对象解析请求头
- 请求头：包含了请求的具体信息
  - 请求方法：get post put delete
  - 请求数据
  - 请求的地址
  - 浏览器的信息

语法

http.createServer((请求，响应)=> {})
http.createServer((req,res)=> {
    res.writeHead()
    res.end()
})

返回值

createServer()返回一个server对象

示例

http.createServer((req,res)=>{
// res.writeHead(200)
res.writeHead(200,{"Content-Type":"text/plain"})
// res.end('这是服务器发了的响应结果')
res.end('Server is running on http://127.0.0.1:3000')
})

res.writeHead()

定义

用于设置响应头信息

语法

res.writeHead(状态码,{"Content-Type":"数据类型"})

参数
参数1：必选，三位数的http状态码
参数2：可选，可有可无
参数3：可选，告诉浏览器我发给你的数据是什么类型的

示例

res.writeHead(200,{"Content-Type":"text/plain"})

res.end()

定义

用于通知客户端响应结束。结束的时候可以携带一些数据

语法

res.end('字符串')

参数
只接受服务器响应数据,如果是中文则会乱码

返回值

无

示例

res.end('Server is running on http://127.0.0.1:3000')

server.listen()

定义

用于设置服务器的监听端口

语法

server.listen()
server.listen([port[, host[, backlog]]][, callback])
server.listen(端口,主机名,[连接数],回调函数)

端口：数值
主机名：字符串
连接数：数值
回调函数：function

server.listen(port, function(){ // the first argument is *not* a potential error /第一个参数*not*是一个潜在的错误});
参数1：端口号

返回值

该方法除了回调函数外没有其他要返回的内容

示例

server.listen(3000,()=>{
    console.log('服务器已经运行在：http://127.0.0.1:3000');
})

Node监听

定义

Node监听就是在不重启服务器的情况下，自动刷新页面

语法

node --wath 文件地址

示例

node --wath 'index.js'

Conten-Type

定义

Content-Type用于指定响应头的数据类型。

语法

{"Content-Type": 属性值}

属性值

text/plain：返回普通文本
text/html：返回html文本
application/json：返回json文本

写服务器的步骤

const server = 引入http模块
用方法createServer创建一个服务器
服务器监听请求server.listen()
设置服务器的运行端口号

服务器
// http模块：用于构建服务器的内置模块
const http = module.require("node:http")

// http.createServer(((请求，响应)=> {}))
const server = http.createServer((req,res)=>{
    // res.writeHead(200)
    res.writeHead(200,{"Content-Type":"text/plain"})
    // res.end('这是服务器发了的响应结果')
    res.end('Server is running on http://127.0.0.1:3000')
})
server.listen(3000,'localhost',()=>{
    console.log('服务器已经运行在：http://127.0.0.1:3000');
})

0327

知识点

习惯使用搜索打开APP
5个命令。每人创建一个命令笔记，专门整理命令
学会使用环境变量(全局变量)
命令行使用技巧
Node.js中的module是什么？

是一个内置的全局对象、用于表示模块
NodeJS中的module系统分为几种？

两种：CommonJS模块系统、ECMAScript模块系统
NodeJS中的module分为几种？

本地模块、内置模块、第三方模块

命令行使用技巧

打开命令行
- 全局打开：搜索框=>输入power
- 定位文件夹打开：按住shift+右键
快速补全：输入一个字母+tab键可以补充全名
快速查询上一条录入：使用上方向键

cd命令

定义

cd命令用于改变目录。cd即：change die

示例

#bash

#返回上一级
cd ..

cd images
#进入当前目录下的images目录
cd ./images
#进入上一级目录下的aaa目录
cd ../aaa
#进入当前硬盘的根目录
cd /
#进入当前用户的根目录
cd ~

pwd

定义

pwd用于显示当前目录

ls

定义

ls用于查看当前目录下的内容（文件和文件夹）

mkdir

定义

用于创建文件夹 “make directory”

示例

#在当前目录下创建一个aaa的文件夹
mkdir aaa
#在当前用户桌面上创建一个bbb文件夹
mkdir ~/desktop/bbb
##在根目录下创建一个ccc的文件夹
mkdir /ccc

rm

定义

用于删除指定的目录或文件 “remove”的缩写

参数

-r 递归删除

-f 强制删除 f：force ：强制、暴力、武力

示例

- users
	- projectA (删除projectA)
		- index.html
		- css
			- style.css

clear清屏

new-item

创建文件

new-item index.html

Node.js

Node是什么

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

- v8引擎：JS的渲染器

Node.js是一个服务器平台。

Node.js底层使用C++编写的。

Node.js是安装在操作系统上的一个程序，这个程序的工作的时候是跟操作系统在对话。(交互)

Node执行js的方式

在Node.js中，运行js代码的方式有两种

直接运行js文件：node app.js
使用REPL模式运行js代码
- R：Read读取js代码
- E: Execute执行JS代码
- P：Print打印js代码
- L: Loop 循环js代码

NodeJS VS 浏览器

	Node.js	浏览器
语法相同	支持ECMAScript	支持ECMAScript
API不同	Global、module、buffer、domain等	BOM、DOM
老大不同	Global	window
交互对象	在node.js运行js，是和操作系统对话	在浏览器中运行js，是和浏览器对话

module API是什么

module是一个内置的全局对象
module用于表示模块
模块：模块就是封装在一个js文件中的代码（在Node的模块系统中，每一个js文件都是一个模块）

const sum = (a,b) =>{
    return a + b
}
const minus = (a,b) =>{
    return a - b
}

module对象

> module
Module {
  id: '<repl>',
  path: '.',
  exports: {},
  filename: null,
  loaded: false,
  children: [],
  paths: [
    '/Users/zj/Desktop/7/0327/repl/node_modules',
    '/Users/zj/Desktop/7/0327/node_modules',
    '/Users/zj/Desktop/7/node_modules',
    '/Users/zj/Desktop/node_modules',
    '/Users/zj/node_modules',
    '/Users/node_modules',
    '/node_modules',
    '/Users/zj/.node_modules',
    '/Users/zj/.node_libraries',
    '/usr/local/lib/node'
  ]
}

NodeJS中的module系统分为几种？

模块系统的背景

JS缺点1：没有模块

JS缺点2：存在命名冲突（set map 模块）

<head>
  <script src='./jquery.js'></script>
  <script scr='./tquery.js'></script>
  <script scr='./script.js'></script>
</head>

CommonJS : 面向服务器通过Require()
RequireJS: 基于CommonJS的一个包装。
AMD: Asynchrouns Module D? ：面向浏览器

Node.js的模块系统分为两种

CommonJS: Node.js的默认模块系统。采用第三方的模块系统。
ECMAScript: 是Node.js的标准模块系统。(向原生语言看齐)

NodeJS中的module分为几种？

本地模块：在项目中，由开发者创建的模块。
内置模块：由Node.js提供的预设模块。
- 内置模块是全局模块。
- 内置模块是Node.js的核心模块。
第三方模块: 在项目中，由其他开发者创建的模块。

NPM是什么

NPM: Node Package Manager Node软件包管理器
NPM就是Node.js平台的商店。

CommonJS模块系统

module对象

定义

module对象表示一个模块。
一个JS文件就是一个模块。
模块是封装在js文件中代码块，拥有独立的作用域，Node会把任何一个js文件看成一个模块。
module对象是一个全局对象

module.prototype.require()

读：瑞快儿

定义

require()方法用于加载外部模块。

require()是node的一个内置函数。
require()在工作的时候，它用于包裹(读取+执行)模块文件中的代码块。

语法

module.require(id)
require(id) //module是全局对象，可省略

Id: 表示加载的模块的文件名

返回值

返回从模块文件中导出的模块

module.exports

读：一颗屎不适

定义

module.exports 用于暴露/导出/分享模块。（暴露作用域）

module.exports是一个对象。
Module.exports 用于包裹要导出的模块。

语法

//语法1：导出单个变量(变量名、函数名、类名)
const sum = (a,b) => {
    return a + b
}
module.exports = sum //单个变量名

//语法2：导出单个直接量
module.exports = (a,b) => {
    return a + b
}

//语法3：导出多个变量
const sum = (a,b) => {
    return a + b
}
const minus = (a,b) => {
    return a - b
}
module.exports = {
    // sum:sum,
    // minus: minus
    sum,
    minus
}

//语法4：导出多个变量
module.exports.sum = (a,b) => {
    return a + b
}
module.exports.minus = (a,b) => {
    return a - b
}

//语法5：导出多个变量
module.exports = {
    sum : (a,b) => {
        return a + b
    },
    minus : (a,b) => {
        return a - b
    }
}
//语法6：导出多个变量
const obj = {
    sum : (a,b) => {
        return a + b
    },
    minus : (a,b) => {
        return a - b
    }
}
module.exports = obj

App1.js

const math = module.require('./lib1')
// math = {sum,minus}
const {sum,minus} = math
console.log(sum(2,3));
console.log(minus(2,3));

4.3

使用Node.js开发App的步骤

创建项目目录

mkdir myapp
cd myapp
# 合并以上两步骤
mkdir myapp && cd myapp

初始化

npm init --yes //目的：创建package.json文件，该文件记录了项目项目信息及项目中所有使用的模块。

创建项目结构

myapp
- views 
- public
- routes
- package.json
- package-lock.json
- app.js

安装模块
```
npm install express
```
引入模块
```
const express = require('express')
```
写需求
```
.....
```

网站根目录

\ ~

查看当前位置： pwd
项目根目录：访问权限设置为公开的、任何人都可以访问的。

public目录

定义

Public 目录是Node.js中存放网站静态文件的目录。静态文件包括：

图片
css文件
js文件
字体文件

mkdir public && cd public
mkdir css js images

Public : 公共的、共同的、公开

express框架

框架的核心是构造函数express()
Express() 构造函数用于创建一个APP实例（服务器类型的app）
express是基于Node.js平台
Node.js平台是运行js文件的。
Node.js项目目录
- index.js app.js server.js
- views
  - html视图模版
    - ejs视图引擎
- public
  - 引入静态资源
普通项目目录
- index.html
- css
  - style.css
- js
  - Script.js

知识点1：express.static()

定义

语法

返回值

示例

知识点2：创建数据库

方案1：创建本地mongodb数据库

启动mongodb数据库

# window系统
服务 => 右键 => 启动
# Mac OS
brew services start mongodb/brew/mongodb-community

连接数据库（怎么和数据库通信？）
1. 可以使用可视化软件Compass
2. 非可视化软件：mongosh

mongosh "mongodb://localhost:27017"

创建数据库: zhangsanblog
1. 使用compass手动创建
2. 使用mongosh手动创建
```
use zhangsanblog
```

创建数据库用户

语法

Db.createUser({
	user: 'zhangsan',
	pwd: '123456',
	roles: [{ role:"readWrite",db:"config"},"clusterAdmin"],
	roles: ["readWrite"]
})

方案2：创建云数据库

登录Atlas账户
创建数据库： zhangsanblog
创建用户: zhangsan Zxcvbn123456

知识点3：连接字符串

定义

连接字符串特指在App开发过程中连接数据库的地址。

语法

"协议://用户名:密码@数据库地址/数据库名"

云数据库的连接字符串

从云数据库复制的连接字符串：
'mongodb+srv://<username>:<password>@zhangsanblog.4t6hj0s.mongodb.net/?retryWrites=true&w=majority'
用你的用户名和密码替换<username>和<password>
'mongodb+srv://zhangsan:Zxcvbn123456@zhangsanblog.4t6hj0s.mongodb.net/?retryWrites=true&w=majority'

本地数据库的连接字符串

"mongodb://zhangsan:123456@127.0.0.1:27107/zhangsanblog"
"mongodb://zhangsan:123456@localhost:27107/zhangsanblog"

知识点4：Node和MongoDB的通信

通信方式有两种：

Mongodb模块:
- mongodb模块是Node.js原生提供的与mongoDB数据库通信的API。
Mongoose模块:
- 是第三方提供的在Node平台与MongoDB数据库通信的方式。
- Mongoose是一个库。
- 库：就是函数的集合。
- Mongoose库包裹Node API。

知识点5：使用Mongoose模块连接数据库

const mongoose = require('mongoose')

mongoose.connect(uri)
    .then((result) => {
        console.log('数据库已经连接')
    })
    .catch( err => console.log(err))

连接数据库

打开app.js文件

4月1日总结

Node.js是什么？

Node.js是基于V8引擎的JS运行环境。
Node.js和Express的关系
- Node.js用于构建服务器
- Express是一个Node框架：基于Node平台开发APP这件事变得更容易。同时对Node开发进行了扩展。

Express框架构建App的步骤

第一步：使用npm init进行初始化

mkdir myapp
cd myapp
npm init --yes

第二步：安装express

npm install express  //局部安装
npm install -g express //全局安装

第三步：导入express

New-item app.js
# 打开app.js 输入
const express = require('express')

第四步：构建APP实例

const app = express() //返回运行在node服务器上的app实例对象。

第五步：监听服务器端口3000

app.listen(3000,() => {
  '服务器已运行在: http://localhost:3000'
})

第6步：配置路由

//get请求 200成功
app.get('/',(req,res) => {
  //res.send()//发送 text/plain||text/html
  //res.sendFile() //发送文件内容  application/json
  res.render()//渲染视图模版
})
//get请求 301转向
app.get('./about-us',(req,res) => {
  res.redirect('./about')//重定向到'./about'请求
})
//get请求 404页面未找到  必须放最后
app.use((req,res) => {
  res.status(404).render('404')
})

0331

express是什么

express是Nodejs服务器的框架
express是一个Node.js的模块

express()

定义

Express()是该框架的核心函数
express()用于创建一个APP(Node.js + Express)
exrpess()函数是一个顶级函数

语法

const express = require('express')

express()的方法

express.json()
express.static()
express.Router()
express.urlencoded()

返回值

示例

app.get()

定义

app.get()方法通过回调函数处理GET请求。

官方：通过回调函数把请求路由到指定路径。

语法

app.get(path,callback)
app.get('请求地址',回调函数) //=> 中间件函数(勾子函数)
app.get('/', (req, res) => {
  console.log(req) //req就是Node.js的request对象
  console.log(res)//res就是Node.js的response对象
})

返回值

示例

app.use()

定义

app.use()在指定路径上挂载中间件函数。

语法

app.use([path,] callback [, callback...])
app.use('路径', 回调函数)

app.use('/about',() => {})
app.use(() => {}) //不写路径，那意味着所有路径都会执行回调

返回值

示例

app.listen()

定义

app.listen() 用于为app绑定监听，监听主机端口是否有请求进来。此方法与 Node 的 http.Server.listen() 相同。

语法

app.listen([port[, host[, backlog]]][, callback])
app.listen(端口号,主机名,回调函数)

返回值

示例

res.sendFile()

定义

按照指定路径发送响应数据(作为响应数据)。

根据文件扩展名设置 Content-Type 响应 HTTP 标头字段。
除非在选项对象中设置了根选项，否则路径必须是文件的绝对路径。

语法

res.sendFile(path [, options] [, fn])
res.sendFile('路径' {选项对象},回调函数)

path必须是一个绝对路径
path如果是一个相对路径，那么你必须在选项对象中设置根选项。

返回值

示例

options

定义

options 就是选项对象。

它是一个对象
对象里存储的是一些属性参数。

{
  path:'',
  chaset: 'utf-8'
}

res.status()

定义

设置响应的 HTTP 状态码。支持链式调用

语法

res.status(403).end()
res.status(400).send('Bad Request')
res.status(400).sendFile('/absolute/path/404.png')

返回值

返回响应对象。

示例

ejs是什么

ejs是 Embedded JavaScript templating的缩写，
ejs的意思：嵌入js的HTML模版(不是嵌入到<script>里)。
ejs是面向服务端的
- ejs是在服务端把js嵌入到html页面里
- 服务端解析ejs语法 => 翻译成html
- 把编译后的html返给浏览器端
- ejs实现的功能类似于php实现的功能：动态渲染数据到HTML页面里。
JS是面向浏览器端的脚本语言。
PHP是面向服务端的脚本语言。
- 为什么能够解析PHP，因为服务端安装了PHP软件

//ejs代码
<ul>
  <% users.forEach(function(user){ %>
    <%- include('user/show', {user: user}); %>
  <% }); %>
</ul>

app.set()

定义

app.set()方法用于：1.存储自定义值 2.配置服务器行为。

服务器行为有些特殊的字段，用于配置服务器行为：

res.render()

定义

render()方法用于编译ejs模版，把编译后的html代码发送给客户端。

语法

res.render(view [, locals] [, callback])
res.render(视图,{选项},回调函数)

选项对象：向视图传递变量

EJS的语法

<% 嵌入脚本的开始控制代码流
%> 嵌入脚本的结束
<%= 出计算值
<%- 直接输出

0330

http模块

http模块是Node的内置模块。
http模块用于构建服务器。

1.http.createServer()

定义

用于创建一个Node服务器。主要做了两件事：

处理请求
处理响应

语法

http.createServer({选项对象},监听函数)

选项对象：可选。是一个object,通过选项对象，传入一些参数。

监听函数：是一个回调函数。当用户请求从端口进来后，该函数立刻被调用。

Request对象：请求对象
- 请求对象：包含与请求有关信息。
Response对象:响应对象
- 响应对象：包含与响应有关的信息。

返回值

createServer() 方法返回一个Server对象。

示例：

2.server.listen()

定义

用于监听服务器端口。

语法

server.listen()
server.listen([port[,host][,callback])
server.listen(端口,主机名,回调函数)

端口：数值
主机名：字符串
连接数：数值(最大511)
回调函数：function

返回值

返回服务器对象

示例

3.res.setHeader()

定义

用于设置响应头信息。特点：

只能设置一个值
多次执行
优先级低于res.writeHead()

语法

res.setHeader(name, value)
res.setHeader(响应头属性名, 对应的值)

返回值

无

示例

res.setHeader("Content-Type","text/html")
res.setHeader("Content-Type","text/plain")
res.setHeader("Content-Type", "application/json")

4.res.write()

定义

write()方法用于设置响应数据。

语法

response.write(chunk[, encoding][, callback]);
response.write(数据[,字符编码][, 回调函数]);

返回值

布尔值

示例

5.res.writeHead()

定义

用于设置响应头信息。特点：

设置多个值
只能执行一次
优先级高于res.setHeader()

语法

res.writeHead(statusCode[, statusMessage][, headers]);
res.writeHead(状态码,'状态信息',{响应头});

返回值

返回一个响应对象。以便进行链式调用。

示例

6.res.end()

定义

end()用于通知服务器响应结束。该方法在响应时必须调用。

语法

response.end([data[, encoding]][, callback])
res.end('数据','字符编码',回调函数)

返回值

返回this

示例

读取文件内容

const http = require('node:http')
const fs = require('fs')

const server = http.createServer((req,res) => {
    // console.log(res);//响应对象[ServerResponse]
    // console.log(req);//请求对象[inComingMessage]
    console.log(req.url);
    //设置响应头的数据类型
    // res.setHeader('Content-Type', 'text/html;charset=utf-8')
    // res.write('<h1>你好世界</h1>')
    // res.write('<h2>你好中国</h2>')
    // res.end()

    //读取index.html内容作为响应数据
    res.setHeader('Content-Type', 'text/html;charset=utf-8')
    fs.readFile('./views/index.html',(err,data) => {  
        if(err){
            console.log(err);
            res.end()
        } else {
            res.end(data)//把数据写在这里
        }
    })
    
})

server.listen(3000,'localhost',511,() => {
    console.log('服务器已经运行在http://localhost:3000');
})

添加路由

const http = require('node:http')
const fs = require('fs')

const server = http.createServer((req,res) => {
    console.log(req.url);
    res.setHeader('Content-Type', 'text/html;charset=utf-8')
  //添加路由
    //条件判断 path  = './views/index.html'
     
    // fs.readFile('./views/index.html',(err,data) => {
    // fs.readFile('./views/about.html',(err,data) => {
    fs.readFile('./views/404.html',(err,data) => {
        if(err){
            console.log(err);
            res.end()
        } else {
            res.end(data)//把数据写在这里
        }
    })
    
})

server.listen(3000,'localhost',511,() => {
    console.log('服务器已经运行在http://localhost:3000');
})

3月30日下午

熟练掌握node.js路由的原生写法

const http = require('node:http')
const fs = require('fs')

const server = http.createServer((req, res) => {
    console.log(req.url);
    res.setHeader('Content-Type', 'text/html;charset=utf-8')
    //////////////添加路由:router/////////////////
    //条件判断 path  = './views/index.html'
    let path = './views/'
    switch (req.url) {
        case '/':
            path += 'index.html'
            res.statusCode = 200
            break
        case '/about':
            path += 'about.html'
            res.statusCode = 200
            break
        case '/about-me':
            res.setHeader('Location', '/about')
            res.statusCode = 301
            break
        default:
            path += '404.html'
            res.statusCode = 404
    }
    // fs.readFile('./views/index.html',(err,data) => {
    // fs.readFile('./views/about.html',(err,data) => {
    fs.readFile(path, (err, data) => {
        if (err) {
            console.log(err);
            res.end()
        } else {
            res.end(data)//把数据写在这里
        }
    })

})

server.listen(3000, 'localhost', 511, () => {
    console.log('服务器已经运行在http://localhost:3000');
})

Npm install

语法

npm install module-name
npm install -g module-name # -g：全局安装
npm i module-name  # npm i是npm install的别名
npm install module-name --save
npm install module-name --not--save
npm install module-name --save-dev

express写路由

const express = require('express')
const app = express()

app.get('/', function (req, res) {
    // res.send('Hello World')
    res.sendFile('./views/index.html',{root:__dirname})
})
app.get('/about', function (req, res) {
    res.sendFile('./views/about.html',{root:__dirname})
})
app.get('/about-me', function (req, res) {
    res.redirect('/about')
})

//404 page
app.use((req,res) => {
    res.status(404).sendFile('./views/404.html',{root:__dirname})
})

app.listen(3000)

0329

明日日考

__dirname是什么

表示当前文件(模块)所在的目录名称
__filename是什么

表示当前文件(模块)的名称
path模块的用途是什么?

提供了处理路径的API，路径分为文件路径、文件夹路径
如何把一个字符串路径转成对象?

path.parse()
如何提取当前Js文件的文件名?

path.basename('路径','删除的后缀名')

path.basename(__filename,'.js')
path.join('/fold1'，//folder2'，../index.html') 的结果是什么?

\fold1\index.html
path.resolve('/fold1'，/folder2'，../hello.html') 的结果是什么?

当前根目录:\hello.html

写出读取同级文件data.txt内容的代码 Data.txt

Hello

index.js

const fs = require("node:fs")
1.const content = fs.readFileSync('./data.text','utf-8')
  console.log(content);

2.const content = fs.readFile('./data.text','utf-8',(err,data)=>{
    if(err){
        console.log(err);
    }else{
        console.log(data)
    }
})
//Hello

NPM是什么?
- NPM 是"Node Package Manager"的缩写，Node软件包管理工具
package.json 文件的用途是什么?

用于描述和配置模块文件
如果说使用第三方模块一共有四步，你认为有哪四步?

第一步：查找模块，登录npm查询一个你要的第三方模块

第二步：安装模块

第三步：引入模块

第四步：使用模块

__dirname

定义

__dirname表示当前文件(模块)所在的目录名称

Dir: directory 文件夹、目录
Name: 名字

语法

console.log(__dirname);//全局变量

示例

console.log(__dirname);

输出

D:\wxy3\js\作业\2023\2023.3.29

绝对路径 vs 相对路径

#绝对路径
\wxy3\js\作业\2023\2023.3.29
\js\作业\2023\2023.3.29
作业\2023\2023.3.29
#相对路径
./wxy3/js/作业
wxy3/js/作业

__filename

定义

__filename表示当前文件(模块)的名称

file: 文件
Name: 名字

语法

console.log(__filename)

示例

console.log(__filename)

输出

D:\wxy3\js\作业、课堂\2023\3月\2023.3.29\global.js

内置模块 path

定义

node:path 是一个内置模块。它提供了处理路径的API。路径分为：

文件路径
文件夹路径

使用path模块，第一步做什么？

语法

require("node:path")

示例

const path = require("node:path")

console.log(__filename);
console.log(path.basename(__filename));
console.log(path.basename(__filename,'.js'));
console.log(path.basename(__dirname));

输出

D:\wxy3\js\作业、课堂\2023\3月\2023.3.29\path.js
path.js  
path     
2023.3.29

1.path.basename()

定义

语法

path.basename('路径','删除的后缀名')

返回值

返回 path 的最后一部分

示例

console.log(__filename);
console.log(path.basename(__filename));
console.log(path.basename(__filename,'.js'));
console.log(path.basename(__dirname));

输出

D:\wxy3\js\作业、课堂\2023\3月\2023.3.29\path.js
path.js
path
2023.3.29

2.path.dirname(path)

定义

dirname()用于返回当前目录的路径

语法

path.basename('路径','删除的后缀名')

返回值

无

示例

console.log(__dirname);
console.log(path.dirname(__dirname));

输出

D:\wxy3\js\作业、课堂\2023\3月\2023.3.29
D:\wxy3\js\作业、课堂\2023\3月

3.path.extname(path)

定义

返回的是当前文件的扩展名

语法

返回值

无

示例

输出

4.path.parse()

定义

parse() 方法：从路径字符串返回一个对象

语法

path.parse('路径')

返回值

返回一个表示路径的对象

示例

console.log(__filename);
console.log(path.parse(__filename));

输出

{
  root: 'D:\\',
  dir: 'D:\\wxy3\\js\\作业、课堂\\2023\\3月\\2023.3.29',
  base: 'path.js',
  ext: '.js',
  name: 'path'
}

5.path.format()

定义

format()方法：从路径对象转路径字符串

语法

path.format(路径)

返回值

返回路径字符串

示例

const obj = path.parse(__filename);
console.log(path.format(obj));
输出//D:\wxy3\js\作业、课堂\2023\3月\2023.3.29\path.js

6.path.join

定义

join()方法用于把路径片段连接为规范路径

简言之：连接路径片段

语法

path.join()
path.join('路径片段1','路径片段2'...)

返回值

返回一个拼接好的规范的路径

示例

const p = path.join('f1','f2','i.html')
console.log(p);
const p2 = path.join('/f1','f2','i.html')
console.log(p2);
const p3 = path.join('/f1','//f2','i.html')
console.log(p3);
const p4 = path.join('/f1','//f2','./i.html')
console.log(p4);
const p5 = path.join('/f1','//f2','../i.html')
console.log(p5);

示例

f1\f2\i.html
\f1\f2\i.html
\f1\f2\i.html
\f1\f2\i.html
\f1\i.html

7.path.isAbsolute

定义

isAbsolute()方法用于检测一个路径是否是绝对路径。

语法

path.isAbsolute(path)

返回值

返回布尔值true、false

示例

console.log(path.isAbsolute(__filename));//true
console.log(path.isAbsolute('./data.json'));//false

8.path.resolve()

定义

resolve()方法用于解析为绝对路径

语法

path.resolve([...paths])//路径片段

返回值

返回绝对路径字符串

示例

const p = path.resolve('f1','f2','i.html')
console.log(p);
const p2 = path.resolve('/f1','f2','i.html')
console.log(p2);
const p3 = path.resolve('/f1','//f2','i.html')
console.log(p3);
const p4 = path.resolve('/f1','//f2','./i.html')
console.log(p4);
const p5 = path.resolve('/f1','//f2','../i.html')
console.log(p5);

输出

D:\wxy3\js\作业、课堂\2023\3月\2023.3.29\f1\f2\i.html
D:\f1\f2\i.html
D:\f2\i.html
D:\f2\i.html
D:\i.html

FS模块(FS系统)

定义

FS 文件系统模块允许操作计算机系统上的的文件。具体操作如下：

读取
创建
修改
删除

引入FS模块系统

要使用fs文件系统，请先引入fs模块

语法：基于promise API（标准）

语法：基于回调函数（默认）

const fs = require("node:fs")

fs.readFile()

定义

readFile()方法用于(异步)读取文件内容。

语法

fs.readFile('文件路径',callback)
fs.readFile('文件路径',(err,data) => {
 if(err) console.log(err)
 console.log(data)
})

返回值

返回读取成功的内容。

数据类型：buffer

示例

const fs = require("node:fs")
const content = fs.readFile('./data.text','utf-8',(err,data)=>{
    if(err){
        console.log(err);
    }else{
        console.log(data)
    }
})
输出//hello

fs.writeFile()

定义

writeFile() 用于异步的写入文件数据。

语法

fs.writeFile(file, data[, options], callback)

返回值

示例

const fs = require("node:fs")

fs.writeFile('./data.md','hello',(err)=>{
    if(err){
        console.log(err);
    }else{
        console.log('成功')
    }
})
输出//成功

NPM是什么

NPM 是"Node Package Manager"的缩写，意思：Node软件包管理工具
NPM的主要内容
- 安装软件包
- 删除软件包
- 分享你自己写的软件包(npmjs.com)
NPM是世界上最大软件包平台。
NPM的构成：
- 官网(npmjs.com): 查询软件包
- CLI(Command Line Interface):命令行交互工具
- 软件注册表：JS软件包的仓库

package是什么

意思：软件包
一个package由1个或多个module组成。

package.json是什么

用于描述你的模块文件。
用于配置你的模块文件。
package.json描述了如何使用模块文件。
一个pacakge(软件包)必须包含一个package.json文件。
package.json文件的创建方法：
- 手动创建
- 半自动：npm init命令创建
- 自动：npm init --yes命令创建

node_modules

用于存储第三方模块的文件
打包项目发给别人之前，可删除node_modules文件夹，以减少文件体积。
注意：package.json和package-lock.json不能删
可使用 npm install 重新安装模块

module

模块就是一个js文件或文件夹
模块必须拥有package.json文件

第三方模块的使用方法

使用模块必须使用双引号！！！

第一步：创建文件夹

mkdir my-package

第二步：创建index.js

cd my-package
New-item index.js

第三步：安装upper-case模块

npm install upper-case

第四步：修改index.js内容

const upperCase = require('upper-case').upperCase
function hello(name){
    console.log(upperCase(`hello${name},welcome to you
    ！`));
}
hello('zs')
module.exports = hello

第五步：运行index.js

node index

输出结果

HELLOZS,WELCOME TO YOU！

版本号

NPM采用的是Sementic Version Controls系统

语法

X.Y.Z

1.1.3
初始版本号一般默认：0.1.0
正式发布：1.0.0

X : Major Version 主版本号：较大变化

Y: Minor Version 副版本号：增加了一个函数

Z: patch Version Bug版本号：修复bug

0328

项目介绍

【问候】：同学们好！老师好！我是xxx。

【项目介绍】

第一部分：介绍项目名称：图库APP

第二部分：效果展示

导航效果展示：什么时候显示? 什么时候隐藏？

屏幕变宽的时候显示导航，屏幕变窄的时候隐藏导航
图片效果展示：无限加载
1. 第一组图片默认加载20张
2. 滚动条滑动到底，加载第二组图片
3. 再次滑动到底，加载第三组图片

第三部分：项目技术介绍

这个项目一共用到了几种技术：

导航菜单使用的boostrap框架实现的。
图片数据使用的免费数据接口
加载图片使用了三种技术
- AJAX /Fetch API
  - fetch是基于ajax请求
- 懒加载
  - 懒加载就是按需加载。需要就加载，不需要就不加载，针对多图片的页面，只有当该图片出现在页面视区中，再加载该图片。可以防止页面一次性加载完所有的图片，用户等待时间长，影响用户体验。懒加载主要运用了滚动事件，这时候我遇到了一个问题：滚动的时候它会无限调用。在这里我用了一个开关控制，一组数据加载完就关闭，下一组数据加载时打开
- 瀑布流（图片排列）
  - 瀑布流是一种流式布局，它把内容分成多个模块从左到右依次排列，这些模块的宽度通常是相同的，但高度却不相同。当第二组内容被添加到页面上时，它会寻找各列之中所有元素高度之和的最小者，并将新的元素添加到该列上，然后继续寻找所有列的各元素之和的最小者，继续添加至该列上，如此循环下去，直至所有元素均能够按要求排列为止

http内置模块

http是node的内置模块

http.createServer()

读：亏诶特设我

定义

createServer()用于创建Node服务器

创建
res(Response)对象：响应对象
- 响应头：用于通知浏览器
  - 状态码
  - 数据类型是什么
  - 数据
  - 其他参数
req(Reqponse)对象：请求对象，使用请求对象解析请求头
- 请求头：包含了请求的具体信息
  - 请求方法：get post put delete
  - 请求数据
  - 请求的地址
  - 浏览器的信息

语法

http.createServer((请求，响应)=> {})
http.createServer((req,res)=> {
    res.writeHead()
    res.end()
})

返回值

createServer()返回一个server对象

示例

http.createServer((req,res)=>{
// res.writeHead(200)
res.writeHead(200,{"Content-Type":"text/plain"})
// res.end('这是服务器发了的响应结果')
res.end('Server is running on http://127.0.0.1:3000')
})

res.writeHead()

定义

用于设置响应头信息

语法

res.writeHead(状态码,{"Content-Type":"数据类型"})

参数
参数1：必选，三位数的http状态码
参数2：可选，可有可无
参数3：可选，告诉浏览器我发给你的数据是什么类型的

示例

res.writeHead(200,{"Content-Type":"text/plain"})

res.end()

定义

用于通知客户端响应结束。结束的时候可以携带一些数据

语法

res.end('字符串')

参数
只接受服务器响应数据,如果是中文则会乱码

返回值

无

示例

res.end('Server is running on http://127.0.0.1:3000')

server.listen()

定义

用于设置服务器的监听端口

语法

server.listen()
server.listen([port[, host[, backlog]]][, callback])
server.listen(端口,主机名,[连接数],回调函数)

端口：数值
主机名：字符串
连接数：数值
回调函数：function

server.listen(port, function(){ // the first argument is *not* a potential error /第一个参数*not*是一个潜在的错误});
参数1：端口号

返回值

该方法除了回调函数外没有其他要返回的内容

示例

server.listen(3000,()=>{
    console.log('服务器已经运行在：http://127.0.0.1:3000');
})

Node监听

定义

Node监听就是在不重启服务器的情况下，自动刷新页面

语法

node --wath 文件地址

示例

node --wath 'index.js'

Conten-Type

定义

Content-Type用于指定响应头的数据类型。

语法

{"Content-Type": 属性值}

属性值

text/plain：返回普通文本
text/html：返回html文本
application/json：返回json文本

写服务器的步骤

const server = 引入http模块
用方法createServer创建一个服务器
服务器监听请求server.listen()
设置服务器的运行端口号

服务器
// http模块：用于构建服务器的内置模块
const http = module.require("node:http")

// http.createServer(((请求，响应)=> {}))
const server = http.createServer((req,res)=>{
    // res.writeHead(200)
    res.writeHead(200,{"Content-Type":"text/plain"})
    // res.end('这是服务器发了的响应结果')
    res.end('Server is running on http://127.0.0.1:3000')
})
server.listen(3000,'localhost',()=>{
    console.log('服务器已经运行在：http://127.0.0.1:3000');
})

0327

知识点

习惯使用搜索打开APP
5个命令。每人创建一个命令笔记，专门整理命令
学会使用环境变量(全局变量)
命令行使用技巧
Node.js中的module是什么？

是一个内置的全局对象、用于表示模块
NodeJS中的module系统分为几种？

两种：CommonJS模块系统、ECMAScript模块系统
NodeJS中的module分为几种？

本地模块、内置模块、第三方模块

命令行使用技巧

打开命令行
- 全局打开：搜索框=>输入power
- 定位文件夹打开：按住shift+右键
快速补全：输入一个字母+tab键可以补充全名
快速查询上一条录入：使用上方向键

cd命令

定义

cd命令用于改变目录。cd即：change die

示例

#bash

#返回上一级
cd ..

cd images
#进入当前目录下的images目录
cd ./images
#进入上一级目录下的aaa目录
cd ../aaa
#进入当前硬盘的根目录
cd /
#进入当前用户的根目录
cd ~

pwd

定义

pwd用于显示当前目录

ls

定义

ls用于查看当前目录下的内容（文件和文件夹）

mkdir

定义

用于创建文件夹 “make directory”

示例

#在当前目录下创建一个aaa的文件夹
mkdir aaa
#在当前用户桌面上创建一个bbb文件夹
mkdir ~/desktop/bbb
##在根目录下创建一个ccc的文件夹
mkdir /ccc

rm

定义

用于删除指定的目录或文件 “remove”的缩写

参数

-r 递归删除

-f 强制删除 f：force ：强制、暴力、武力

示例

- users
	- projectA (删除projectA)
		- index.html
		- css
			- style.css

clear清屏

new-item

创建文件

new-item index.html

Node.js

Node是什么

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

- v8引擎：JS的渲染器

Node.js是一个服务器平台。

Node.js底层使用C++编写的。

Node.js是安装在操作系统上的一个程序，这个程序的工作的时候是跟操作系统在对话。(交互)

Node执行js的方式

在Node.js中，运行js代码的方式有两种

直接运行js文件：node app.js
使用REPL模式运行js代码
- R：Read读取js代码
- E: Execute执行JS代码
- P：Print打印js代码
- L: Loop 循环js代码

NodeJS VS 浏览器

	Node.js	浏览器
语法相同	支持ECMAScript	支持ECMAScript
API不同	Global、module、buffer、domain等	BOM、DOM
老大不同	Global	window
交互对象	在node.js运行js，是和操作系统对话	在浏览器中运行js，是和浏览器对话

module API是什么

module是一个内置的全局对象
module用于表示模块
模块：模块就是封装在一个js文件中的代码（在Node的模块系统中，每一个js文件都是一个模块）

const sum = (a,b) =>{
    return a + b
}
const minus = (a,b) =>{
    return a - b
}

module对象

> module
Module {
  id: '<repl>',
  path: '.',
  exports: {},
  filename: null,
  loaded: false,
  children: [],
  paths: [
    '/Users/zj/Desktop/7/0327/repl/node_modules',
    '/Users/zj/Desktop/7/0327/node_modules',
    '/Users/zj/Desktop/7/node_modules',
    '/Users/zj/Desktop/node_modules',
    '/Users/zj/node_modules',
    '/Users/node_modules',
    '/node_modules',
    '/Users/zj/.node_modules',
    '/Users/zj/.node_libraries',
    '/usr/local/lib/node'
  ]
}

NodeJS中的module系统分为几种？

模块系统的背景

JS缺点1：没有模块

JS缺点2：存在命名冲突（set map 模块）

<head>
  <script src='./jquery.js'></script>
  <script scr='./tquery.js'></script>
  <script scr='./script.js'></script>
</head>

CommonJS : 面向服务器通过Require()
RequireJS: 基于CommonJS的一个包装。
AMD: Asynchrouns Module D? ：面向浏览器

Node.js的模块系统分为两种

CommonJS: Node.js的默认模块系统。采用第三方的模块系统。
ECMAScript: 是Node.js的标准模块系统。(向原生语言看齐)

NodeJS中的module分为几种？

本地模块：在项目中，由开发者创建的模块。
内置模块：由Node.js提供的预设模块。
- 内置模块是全局模块。
- 内置模块是Node.js的核心模块。
第三方模块: 在项目中，由其他开发者创建的模块。

NPM是什么

NPM: Node Package Manager Node软件包管理器
NPM就是Node.js平台的商店。

CommonJS模块系统

module对象

定义

module对象表示一个模块。
一个JS文件就是一个模块。
模块是封装在js文件中代码块，拥有独立的作用域，Node会把任何一个js文件看成一个模块。
module对象是一个全局对象

module.prototype.require()

读：瑞快儿

定义

require()方法用于加载外部模块。

require()是node的一个内置函数。
require()在工作的时候，它用于包裹(读取+执行)模块文件中的代码块。

语法

module.require(id)
require(id) //module是全局对象，可省略

Id: 表示加载的模块的文件名

返回值

返回从模块文件中导出的模块

module.exports

读：一颗屎不适

定义

module.exports 用于暴露/导出/分享模块。（暴露作用域）

module.exports是一个对象。
Module.exports 用于包裹要导出的模块。

语法

//语法1：导出单个变量(变量名、函数名、类名)
const sum = (a,b) => {
    return a + b
}
module.exports = sum //单个变量名

//语法2：导出单个直接量
module.exports = (a,b) => {
    return a + b
}

//语法3：导出多个变量
const sum = (a,b) => {
    return a + b
}
const minus = (a,b) => {
    return a - b
}
module.exports = {
    // sum:sum,
    // minus: minus
    sum,
    minus
}

//语法4：导出多个变量
module.exports.sum = (a,b) => {
    return a + b
}
module.exports.minus = (a,b) => {
    return a - b
}

//语法5：导出多个变量
module.exports = {
    sum : (a,b) => {
        return a + b
    },
    minus : (a,b) => {
        return a - b
    }
}
//语法6：导出多个变量
const obj = {
    sum : (a,b) => {
        return a + b
    },
    minus : (a,b) => {
        return a - b
    }
}
module.exports = obj

App1.js

const math = module.require('./lib1')
// math = {sum,minus}
const {sum,minus} = math
console.log(sum(2,3));
console.log(minus(2,3));

nodejs +mongodb + post

张三的博客项目总结

NPM VS NPX

express Generator

Node.js APP 的开发步骤

第1步：项目初始化

第2步. 创建项目目录结构

第3步：安装项目所需模块

第4步：引入模块（注意顺序引入）

第5步：创建app.js的基本结构

网站的基本·原理

网站工作原理

4月6日

张三的博客项目总结

NPM VS NPX

express Generator

Node.js APP 的开发步骤

4月5号

知识点

学会安装nodemon

4月4日

打印mongoose

mongoose是什么

mongoose.connect()

promise.then()

promise.catch()

mongoose.model()

Schema()

4月3日

使用Node.js开发App的步骤

网站根目录

public目录

express框架

知识点1：express.static()

知识点2：创建数据库

方案1：创建本地mongodb数据库

方案2：创建云数据库

知识点3：连接字符串

知识点4：Node和MongoDB的通信

知识点5：使用Mongoose模块连接数据库

mongoose是什么

Schema()

连接数据库

4月1日总结

Express框架构建App的步骤

0331

express是什么

express()

app.get()

app.use()

app.listen()

res.sendFile()

options

res.status()

ejs是什么

app.set()

res.render()

EJS的语法

0330

http模块

1.http.createServer()

2.server.listen()

3.res.setHeader()

4.res.write()

5.res.writeHead()

6.res.end()

读取文件内容

添加路由

3月30日下午

熟练掌握node.js路由的原生写法

Npm install

express写路由

0329

明日日考

__dirname

__filename

内置模块 path

1.path.basename()

2.path.dirname(path)

3.path.extname(path)