<script>
        alert('1')
</script>

<h1 onclick="alert(1);">hello</h1>

javascriptCopy code// 在 Object.prototype 上添加一个名为 'isAdmin' 的属性

Object.prototype.isAdmin=true;// 现在所有的对象都有了 'isAdmin' 属性

var obj = {};console.log(obj.isAdmin);// 输出: true

// 但是如果我们从不可信的源加载了脚本

// 它可能会修改 Object.prototype 上的属性

var maliciousScript ="<script>Object.prototype.isAdmin = false;</script>";

document.write(maliciousScript);// 现在所有的对象都失去了 'isAdmin' 属性

console.log(obj.isAdmin);// 输出: false

// 创建一个对象
var person = {
  name: 'John',
  age: 30
};
// 访问对象的原型对象
console.log(person.__proto__); // 输出: {}
// 创建一个原型对象
var personProto = {
  greet: function() {
    console.log('Hello, my name is ' + this.name);
  }
};

// 将对象的原型对象设置为 personProto
Object.setPrototypeOf(person, personProto);

// 访问对象的原型对象
console.log(person.__proto__); // 输出: { greet: [Function: greet] }

// 调用对象的原型对象上的方法
person.greet(); // 输出: Hello, my name is John

fs.readFile(path[,options],callback)

参数1：必选参数，字符串，表示文件的路径
参数2：可选参数，表示以什么编码格式来读取文件
参数3：必选参数，文件读取完成后，通过回调函数拿到读取的结果。

// 1.导入fs模块,来操作文件
const fs = require('fs')
// 2.调用fs.readFile()方法读取文件
fs.readFile('./file/1.txt', 'utf8', function (err, dataStr) {
    // 打印失败的结果，如果读取成功，则err的值为null
    // 如果读取失败，则err的值为错误对象，dataStr的值为undefined
    if (err) {
        return console.log('读取文件失败' + err.message)
    }
    console.log('读取文件成功' + dataStr)

})

//导入fs文件系统模块
const fs = require('fs')
// 2.调用fs.writeFile() 方法，写入文件的内容
// 参数1:表示文件的存放路径
// 参数2:表示要写入的内容
// 参数3: 回调函数
fs.writeFile('f:/files/2. txt', ' abcd', function(err) {
// 2.1 如果文件写入成功，则err的值等于null
“2.2如果文件写入失败，则err的值等于一个错误对象
console. log(err)
})

const fs = require('fs') 
fs .writeFile( 'F:/files/2.txt', 'Hello Node.js!', function(err) {
  if (err) {
      return console.log( '文件写入失败! ' + err. message)
  }
  console. log '文件写入成功! ') 
})

fs.readFile(__dirname+'/files/1.txt','utf8',function(err,dataStr){
    if(err)
    return console.log('error!'+err.message)
    console.log(dataStr)
})

const path=require('path')

const path = require('path');

const fullPath = path.join('/Users/john', 'Desktop', 'file.txt');
console.log(fullPath); // 输出：/Users/john/Desktop/file.txt

const path = require('path');

const filename = path.basename('/Users/john/Desktop/file.txt');
console.log(filename); // 输出：file.txt

path.basename(path[,ext])

参数：path:必选参数，表示一个路径的字符串
ext可选参数，表示文件拓展名
返回：表示路径中的最后一部分

const path = require('path');

const extname = path.extname('/Users/john/Desktop/file.txt');
console.log(extname); // 输出：.txt

const path = require('path');

const extname1 = path.extname('/Users/john/Desktop/file.txt.jpg');
console.log(extname1); // 输出：.jpg

const extname2 = path.extname('/Users/john/Desktop/file');
console.log(extname2); // 输出：''

const http=require('http')

const http=require('http')

const server=http.createServer()

//使用服务器实例的.on()方法，为服务器绑定一个request事件
server.on('request',(req,res)=>{
//只要有客户端来请求我们自己的服务器，就会触发request事件，从而调用这个事件处理函数
console.log('someone visit our web server.')
})

//调用server.listen(端口号，cb回调）方法，即可启动web服务器
server.listen(80,()=>{
console.log('http server running at http://127.0.0.1')
})

server.on('request',(req,res)=>{

const str='Your request url is ${req.url},and request method is ${req.method}'
console.log(str)
}）

server.on('request',(req,res)=>{
//res是响应对象，它包含了与服务器相关的数据和属性，例如：
//要发送到客户端的字符串
const str='Your request url is ${req.url},and request method is ${req.method}'
//res.end()方法的调用：
//向客户端发送指定内容，并结束这次请求的处理过程
res.end(str)
}）

当调用res.end()方法，向客户端发送中文内容的时候，会出现乱码问题，此时，需要手动设置内容的编码格式

server.on('request',(req,res)=>{
//发送的内容包含中文
conststr='您请求的url地址是${req.url},请求的method类型是${req.method}'
//为了防止中文显示乱码的问题，需要设置响应头
res.setHeader('Content-Type','text/html;charset=utf-8')
//把包含中文的内容，响应给客户端
res.end(str)
})

server.on('request',function(req,res){
const url =req.url //1.获取请求的Url地址
let content ='<h1>404 Not found!</h1>'//2.设置默认的内容
if(url=='/'||url ==='/index.html'){
content='<h1>首页</h1>'//3.用户请求的是首页
}else if(url==='/about.html'){
content='<h1>关于页面</h1>'
}
//为了防止中文显示乱码的问题，需要设置响应头
res.setHeader('Content-Type','text/html;charset=utf-8')
//把包含中文的内容，响应给客户端
res.end(str)
})

const http = require('http');
const fs = require('fs');

//  myModule.js

function add(x, y) {
  return x + y;
}

module.exports = {
  add: add
//add: add 的意思是将 add 函数导出，并将它赋值给一个名为 add 的属性，
//这样在其他模块中引用该模块时，就可以通过 myModule.add 访问到这个函数。
//也就是说，我们将 add 函数打包成一个模块，使其可以在其他模块中复用。
};

const myModule = require('./myModule');

console.log(myModule.add(1, 2)); // 输出 3

const _ = require('lodash');

console.log(_.chunk([1, 2, 3, 4], 2)); // 输出 [[1, 2], [3, 4]]

app.get('/', function(req, res) {
  res.send('Hello, world!');
});

app.get('/users/:id', function(req, res) {
  const userId = req.params.id;
  res.send('User ID: ' + userId);
});

app.post('/login', function(req, res) {
  const username = req.body.username;
  const password = req.body.password;
  // TODO: check username and password
  //TODO: check username and password 是一种常见的注释格式，用于标识需要进行实现或修改的代码部分。它表示 "待办事项"（To Do），提示开发人员在未来的某个时候需要将该部分代码完善或修复。

通常，程序员在编写代码时，会遇到一些需要进一步思考或完善的问题，或者需要留下一些待处理的任务，此时可以使用 TODO 标记来记录这些问题或任务。这样可以使得代码更易于维护和管理。

在实际开发中，IDE（集成开发环境）或代码编辑器通常会提供特定的功能来识别和管理 TODO 标记，以便开发人员能够更方便地跟踪和处理这些标记。
  res.send('Welcome, ' + username + '!');
});

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



// 发送文本响应
app.get('/hello', function(req, res) {
  res.send('Hello, world!');
});




// 发送 JSON 响应
app.get('/data', function(req, res) {
  const data = { name: 'Alice', age: 18 };
  res.send(data);
});



// 发送二进制响应
app.get('/image', function(req, res) {
  const fs = require('fs');
  const path = require('path');
  const imagePath = path.join(__dirname, 'public', 'images', 'logo.png');
  fs.readFile(imagePath, function(err, data) {
    if (err) {
      res.status(500).send('Internal Server Error');
    } else {
      res.type('png').send(data);
    }
  });
});

app.listen(3000, function() {
  console.log('Server is running at http://localhost:3000');
});

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

app.get('/user', function(req, res) {
  const name = req.query.name;
  const age = req.query.age;
  res.send(`Hello, ${name}! You are ${age} years old.`);
});

app.listen(3000, function() {
  console.log('Server is running at http://localhost:3000');
});

app.get('/user/:id', function(req, res) {
  const userId = req.params.id;
  // ...
});

app.get('/user/:id/address/:city', function(req, res) {
  const userId = req.params.id;
  const city = req.params.city;
  // ...
});

app.use(express.static('public'))

app.use(express.static('public'))
app.use(express.static('image'))

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

app.use('/static', express.static('public'));

app.listen(3000, function() {
  console.log('Server is running at http://localhost:3000');
});

app.METHOD(PATH,HANDLER)li

//匹配GET请求，且请求URL为/
app.get('/',function(req,res){
res.send('Hello World!')
})
//匹配post请求，且请求URL为/
app.post('/',function(req,res){
res.send('Got a POST request')
})

const express=require('express')
//创建web服务器，命名为app
const app= express()
//挂载路由
app.get('/',(req,res)=>{
    res.send('hello world')
})
app.post('/',(req,res)=>{
    res.send('Post Request.')
})
//启动web服务器
app.listen(80,()=>{
    console.log('http://127.0.0.1')

})

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

const userrouter = require('./userrouter');

// 所有以 /api 开头的请求都会经过 userrouter 处理
app.use('/api', userrouter);

app.listen(3000, function() {
  console.log('Server is running at http://localhost:3000');
});

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

const userrouter = require('./userrouter');

// 所有以 /api 开头的请求都会经过 userrouter 处理
app.use('/api', userrouter);

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

// 应用级别的中间件
app.use((req, res, next) => {
  console.log('Time:', Date.now());
  next();
});

app.get('/', (req, res) => {
  res.send('Hello, world!');
});

app.listen(3000, () => {
  console.log('Server started on port 3000');
});

const express = require('express')
const router = express.Router()

router.use('/users', (req, res, next) => {
  // 对所有以 /users 开头的请求进行权限校验
  if (req.session.user) {
    next()
  } else {
    res.status(401).send('Unauthorized')
  }
})

router.get('/users', (req, res) => {
  // 只有经过权限校验的请求才能访问这个路由
  res.send('User list')
})

module.exports = router
//将自定义中间件封装为模块

const express = require('express');
const apiRouter = express.Router();

apiRouter.get('/get', (req, res) => {
  // 1. 获取到客户端通过查询字符串，发送到服务器的数据
  const query = req.query;

  // 2. 调用 res.send() 方法，把数据响应给客户端
  res.send({
    status: 0, // 状态，0 表示成功，1 表示失败
    msg: 'GET 请求成功!', // 状态描述
    data: query // 需要响应给客户端的具体数据，这行代码是将从客户端请求中获取的数据对象 query 作为响应数据发送给客户端。其中 query 是通过 req.query 获取的客户端通过查询字符串发送到服务器的数据。在这个例子中，响应数据中的 data 属性直接使用了从客户端获取的数据对象，因此客户端发起的请求参数会被原封不动地返回给客户端。在实际的应用中，通常会对请求参数进行处理，将处理后的数据作为响应数据返回给客户端。
  });
});

apiRouter.post('/post', (req, res) => {
  // 1.获取客户端提交的数据
  const body = req.body;

  // 2.在这里对客户端提交的数据进行处理，可以调用其他模块或者服务进行处理

  // 3.将处理后的数据响应给客户端
  res.send({
    status: 0,
    msg: 'POST 请求成功！',
    data: body
  });
});

Access-Control-Allow-Origin: <origin> | *
Access-Control-Allow-Methods: <method>[, <method>]*
Access-Control-Allow-Headers: <header-name>[, <header-name>]*
Access-Control-Allow-Credentials: true | false
Access-Control-Max-Age: <delta-seconds>

$.ajax({
  url: "http://example.com/api/data",
  dataType: "jsonp",
  jsonp: "callback",
  success: function(response) {
    // 处理响应数据
  },
  error: function(xhr, status, error) {
    // 处理错误
  }
});