语法#

在Nodejs中，全局变量定义方法为

var PATH=...

局部变量则依旧使用 let xxx=...

全局变量#

模块#

模块引用方法：

const module = require('module-name');

使用npm安装包时默认安装在当前项目下的 node_modules文件夹中，若要安装在全局下则需要使用 npm install -g ...

要证明程序运行在函数内，就使用 console.log(arguments)，arguments参数只在函数体里面有，arguments.callee返回的是当前的函数是谁 arguments.callee+''把这个对象变为字符串，输出完整的函数内容

//module1.js
module.exports = {
    add: function (a, b) {
        return a + b;
    },
    substract: function (a, b) {
        return a - b;
    }
}
//这里使用匿名函数直接返回计算结果

var module1 = require('./module1.js');
console.log(module1.add(623,126));
console.log(module1.substract(623,126));
/* 输出
749
497

//module1.js
exports.add = function (a, b) {
    return a + b;
}

exports.substract = function (a, b) {
    return a - b;
}

function modifyValue(x) { x = 100; } let a = 10; modifyValue(a); console.log(a); // 输出: 10

function modifyObject(obj) { obj.name = 'Charlie'; } 
let person = { name: 'Alice' }; 
modifyObject(person); c
onsole.log(person.name); 
// 输出: 'Charlie'

exports = { name: 'Alice', sayHello: function() { console.log('Hello ' + this.name); } };
//这种不行🙅‍♂️

函数#

来自菜鸟教程

声明：

function greet(name) {
    console.log(`Hello, ${name}!`);
}

默认参数 在函数声明时为参数提供默认值。

function greet(name = 'Guest') {
    console.log(`Hello, ${name}!`);
}

greet(); // Hello, Guest!
greet('Alice'); // Hello, Alice!

剩余参数

function sum(...numbers) {  
    return numbers.reduce((acc, num) => acc + num, 0);  
}  
  
console.log(sum(1, 2, 3, 4)); // 10

解构参数 从对象或数组中提取数据并将其赋值给变量

function getUserInfo({ name, age }) {
    console.log(`Name: ${name}, Age: ${age}`);
}

const user = { name: 'Alice', age: 30 };
getUserInfo(user); // Name: Alice, Age: 30

箭头函数：

const greet = (name) => {
    console.log(`Hello, ${name}!`);
};

例子：

const users = [  
    { id: 1, name: 'Alice' },  
    { id: 2, name: 'Bob' }  
];  
  
const names = users.map(user => user.name);  
console.log(names); // ['Alice', 'Bob']

这里的 user => user.name相当于

function(user) {
    return user.name;
}

也就是说箭头左边的是输入的参数

Promises#

const myPromise = new Promise((resolve, reject) => {
  let success = true;

  if (success) {
    resolve("操作成功!");
  } else {
    reject("操作失败!");
  }
});

myPromise
  .then(result => {
    console.log(result);  // 如果 Promise 成功，输出: "操作成功!"
  })
  .catch(error => {
    console.error(error);  // 如果 Promise 失败，输出: "操作失败!"
  });

const myPromise = new Promise((resolve, reject) => {
  resolve("数据获取成功");
});

myPromise
  .then(result => {
    console.log(result); // 输出: "数据获取成功"
    return new Promise((resolve) => resolve("更多的数据"));
  })
  .then(result => {
    console.log(result); // 输出: "更多的数据"
  })
  .catch(error => {
    console.error("错误:", error);
  });

const promise1 = Promise.resolve(3);
const promise2 = 42;
const promise3 = new Promise((resolve, reject) => setTimeout(resolve, 100, "foo"));

Promise.all([promise1, promise2, promise3]).then((values) => {
  console.log(values);  // 输出: [3, 42, "foo"]
});

const promise1 = Promise.resolve(3);
const promise2 = Promise.reject("错误");

Promise.allSettled([promise1, promise2]).then((results) => {
  console.log(results);
  // 输出: 
  // [
  //   { status: "fulfilled", value: 3 },
  //   { status: "rejected", reason: "错误" }
  // ]
});

const promise1 = new Promise((resolve) => setTimeout(resolve, 500, "快速"));
const promise2 = new Promise((resolve) => setTimeout(resolve, 1000, "慢速"));

Promise.race([promise1, promise2]).then((value) => {
  console.log(value); // 输出: "快速"
});

Promise.resolve(42).then(value => console.log(value));  // 输出: 42
Promise.reject('错误').catch(error => console.log(error));  // 输出: "错误"

async/await#

async和await是 ES2017被引用的语法糖，底层依然是通过promises实现的，它可以使得异步函数看起来像同步函数一样编写

以下是异步请求API的一个例子：

function fetchdata(url) {
    return new Promise((resolve, reject) =>{
        fetch(url) //fetch会返回一个Promise
        .then(response => {
            if (!response.ok) {
                throw new Error(response.statusText);
            }
            return response.json();
        })
        .then(data => {
            resolve(data);
        })
        .catch(error => {
            error => reject(error);
        });
    });
}

async function getData() {
    try {
        console.log("Fetching data...");
        const data = await fetchdata("https://jsonplaceholder.typicode.com/todos/1");
        //这里的await用于等待fetchData的结果
        console.log("Data fetched:",data);

    }catch (error) {
        console.log("Error fetching data:", error);
    }
}

getData();

修改 getData()使用 Promise.all实现并行：

async function getData() {
    try {
        console.log("Fetching data...");
        const [data1, data2] = await Promise.all([
            fetchdata("https://jsonplaceholder.typicode.com/posts/1"),
            fetchdata("https://jsonplaceholder.typicode.com/posts/2")
        ])
        console.log("Data fetched:", data1, data2);

    }catch (error) {
        console.log("Error fetching data:", error);
    }
}

[[Media/3463ed5338e44aca89b591652c708bba_MD5.jpeg|Open: Pasted image 20250207165253.png]]

路由#

const http = require('http');

const server = http.createServer((req, res) => {
    const { url, method } = req;
    if (url === '/ping' && method === 'GET') {
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end('pong');
    } else if (url === '/hello' && method === 'GET') {
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end('Hello, World!');
    } else {
        res.writeHead(404, { 'Content-Type': 'text/plain' });
        res.end('Not Found');
    }
})

server.listen(8082, () => {
    console.log('Server is running on port 8082');
})

参数#

使用URL包

const myUrl = new URL("http://localhost:8888/start?foo=bar&hello=world");

// 提取路径名
console.log(myUrl.pathname); // 输出: /start

// 提取查询参数
console.log(myUrl.searchParams.get("foo"));   // 输出: bar
console.log(myUrl.searchParams.get("hello")); // 输出: world

RCE#

这里RCE一是获得JS命令执行，再是系统命令的执行

execFile('calc', [], (error, stdout, stderr) => {
  if (error) {
    console.error(`执行出错: ${error}`);
    return;
  }
  console.log(`输出:\n${stdout}`);
});

const { fork } = require('child_process'); 
const child = fork('path/to/childScript.js');

弱类型比较#

搬了直接

• 数字与数字字符串比较时：数字字符串会被强制转换为数字后进行比较。
• 字符串与字符串比较：基于字符的 ASCII 码顺序。
• 数组比较：空数组在与其他类型进行比较时，通常会被视为 false。数组会按第一个元素进行比较，且如果数组含有非数值型元素，会以字符串形式与其进行比较。
• 特殊值：
  • null 与 undefined 在 弱类型比较 下相等，但 严格比较 不相等。
  • NaN 在 弱类型比较 和 严格比较 下都不等于任何值，包括它自己。

其他#

字符"ı"、"ſ" 经过toUpperCase处理后结果为 "I"、"S"

字符"K"经过toLowerCase处理后结果为"k"(这个K不是K)

Node.Js原型链污染#

深入理解 JavaScript Prototype 污染攻击 | 离别歌 不再展开 ctfshow Nodejs的wp