分类前端技术下的文章

2024-08-20

报错解释：

这个警告是由Vue Router在导航时发出的，它表示当尝试导航到一个路由时，提供了无效的参数“id”。这通常发生在路由参数不符合预期的类型或格式时。

解决方法：

检查触发导航的代码部分，确保传递给路由的“id”参数是有效的。
检查路由配置中对应的“id”参数的正则表达式或类型定义，确保它符合预期的格式。
如果“id”是可选的，确保路由配置允许它为空。
如果报错发生在从一个路由导航到另一个路由时，确保你没有在导航守卫中错误地修改了参数。

示例：

假设你有一个路由定义如下：




{
  path: '/user/:id',
  component: User,
  props: true
}

确保在导航时，提供的“id”参数是存在的，并且符合路由配置中的要求。例如：




// 正确的导航，假设有一个用户的ID是123
this.$router.push({ name: 'User', params: { id: '123' } });

如果“id”是一个数字，确保它不是由于字符串和数字的比较而被丢弃。如果需要，可以在路由配置中使用更严格的验证规则或者在导航前转换参数类型。

js实现自动播放视频

2024-08-20

在JavaScript中，要实现自动播放视频，可以设置视频元素的autoplay属性。但是，大多数现代浏览器由于用户体验的原因默认不支持自动播放视频。在一些浏览器中，你可能需要用户进行某种形式的交互（例如点击）才能开始播放视频。

以下是一个简单的示例，演示如何在用户点击视频后自动播放视频：




<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Auto Play Video</title>
</head>
<body>
 
<video id="myVideo" width="320" height="240" controls>
  <source src="movie.mp4" type="video/mp4">
  Your browser does not support the video tag.
</video>
 
<button id="playButton">Play Video</button>
 
<script>
  const video = document.getElementById('myVideo');
  const playButton = document.getElementById('playButton');
 
  playButton.addEventListener('click', function() {
    video.play();
    playButton.style.display = 'none';
  });
</script>
 
</body>
</html>

在这个例子中，当用户点击按钮时，视频会自动播放，同时按钮将被隐藏。请注意，在某些移动浏览器中，即使视频是通过点击事件开始播放的，如果用户之后停止视频（比如通过用户交互），那么下次要想自动播放视频可能还需要用户的进一步交互，因为浏览器可能阻止了视频的自动播放。

十个JS装逼技巧，高逼格代码，让你惊叹不已

2024-08-20

以下是10个JavaScript的装逼技巧，这些技巧可以让你的代码看起来更高级，更有趣味。

使用!运算符进行类型转换




let truthyValue = !!"test"; // truthyValue 为 true
let falsyValue = !!""; // falsyValue 为 false

使用||和&&运算符进行简写赋值




let a = 10;
let b = 20;
 
// 如果 a 为真值，则使用 a，否则使用 b
let value = a || b; // value 为 10
 
// 如果 a 为假值，则使用 b，否则使用 a
let value2 = a && b; // value2 为 20

使用+运算符进行字符串连接




let string1 = "Hello";
let string2 = "World";
let concatenatedString = string1 + string2; // "HelloWorld"

使用+运算符进行数字转换




let stringValue = "123";
let numberValue = +stringValue; // 123

使用[]运算符进行动态属性访问




let propertyName = "name";
let object = { name: "John" };
let value = object[propertyName]; // "John"

使用!运算符进行否定逻辑判断




let value = null;
if (!value) {
  // 如果 value 是 undefined, null, 0, NaN, "" 或 false，这里的代码会执行
}

使用+运算符进行一体化数据类型转换




let value = "123";
let number = +value; // 123
 
value = "test";
number = +value; // NaN

使用!运算符进行类型检查




function isNumber(value) {
  return !isNaN(value);
}

使用+运算符进行字符串和数字的加法操作




let num1 = 10;
let num2 = 20;
let sum = +num1 + +num2; // 30

使用!运算符进行布尔取反




let value = true;
let negatedValue = !value; // false

这些技巧可以提高你的代码精简度，看起来更专业。不过，记住：过分使用这些技巧可能会降低代码的可读性，应当合理使用。

使用Nodejs + express连接数据库mongoose

2024-08-20

首先，确保你已经安装了Mongoose。如果没有安装，可以通过以下命令安装：




npm install mongoose

以下是一个简单的示例，展示了如何使用Node.js和Express连接到MongoDB数据库，并创建一个简单的RESTful API：




const express = require('express');
const mongoose = require('mongoose');
const app = express();
 
// 连接到MongoDB数据库
mongoose.connect('mongodb://localhost:27017/mydatabase', { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log('MongoDB Connected'))
  .catch(err => console.log(err));
 
// 创建一个Schema
const Schema = mongoose.Schema;
const userSchema = new Schema({
  name: String,
  email: String
});
 
// 创建模型
const User = mongoose.model('User', userSchema);
 
// 创建路由
app.get('/users', async (req, res) => {
  try {
    const users = await User.find();
    res.json(users);
  } catch (err) {
    res.status(500).send('Error fetching users.');
  }
});
 
app.post('/users', async (req, res) => {
  const user = new User(req.body);
  try {
    const newUser = await user.save();
    res.status(201).send(newUser);
  } catch (err) {
    res.status(400).send('Error creating user.');
  }
});
 
// 监听端口
const port = 3000;
app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

在这个示例中，我们首先导入了express和mongoose。然后，我们使用mongoose.connect()连接到本地的MongoDB数据库。接着，我们定义了一个用户的Schema，并基于这个Schema创建了一个模型。之后，我们创建了两个路由，一个用于获取所有用户，另一个用于创建新用户。最后，我们启动服务器监听3000端口。

从 NextJS SSRF 漏洞看 Host 头滥用所带来的危害

2024-08-20




import { NextResponse } from 'next/server';
 
async function handleRequest(req) {
  const { nextStart } = $nextStart;
  const { host } = req.headers;
 
  // 如果 Host 头部不是以 localhost 或 127.0.0.1 开头，则认为是不安全的用法
  if (!/^localhost|^127\.0\.0\.1/.test(host)) {
    return NextResponse.redirect('https://example.com'); // 重定向到安全的地址
  }
 
  // 以下是正常的服务器端渲染逻辑
  const result = await nextStart(req, {
    // ... 其他配置 ...
  });
 
  return result;
}

在这个示例中，我们检查了 Host 头是否以 localhost 或 127.0.0.1 开头。如果不是，我们将用户重定向到一个安全的地址，以防止可能的服务器端请求伪造（SSRF）攻击。这是一个防御措施，用于保护服务器免受不安全的请求影响。

2024-08-20

在LangChain中，Text Splitter是一种工具，用于将大段的文本内容分割成更小的、易于处理的部分。LangChain支持多种文本格式，包括HTML、JSON、Markdown和代码。

以下是一个使用LangChain中的Text Splitter来处理Markdown文件的例子：




from langchain import TextSplitter, MarkdownDocument
 
# 创建一个MarkdownSplitter对象
splitter = TextSplitter(MarkdownDocument)
 
# 需要处理的Markdown文本
text = """
# 标题一
这是第一部分的内容。
 
## 标题二
这是第二部分的内容。
"""
 
# 使用split方法分割文本
splitted_texts = splitter.split(text)
 
# 输出分割后的各个部分
for part in splitted_texts:
    print(part)

在这个例子中，MarkdownDocument 类被用来指定文本应该被当作Markdown处理。TextSplitter 会根据Markdown的标题级别来分割文本，将每个标题及其下的内容作为一个独立的部分输出。

对于其他格式，如HTML或代码，你可以使用对应的Document类，如HTMLDocument或CodeDocument。例如，对于代码，你可以这样做：




from langchain import TextSplitter, CodeDocument
 
code = """
def hello_world():
    print("Hello, world!")
 
class MyClass:
    def my_method(self):
        print("Hello, LangChain!")
"""
 
splitter = TextSplitter(CodeDocument)
splitted_code = splitter.split(code)
 
for part in splitted_code:
    print(part)

在这个例子中，CodeDocument 被用来分割Python代码。TextSplitter 会根据代码块（如函数定义或类定义）来分割代码。

js Class的概念及其应用场景

2024-08-20

JavaScript 中的 Class 是 ES6 引入的一个新特性，它允许开发者使用更接近传统面向对象编程的方式来创建和管理对象。

定义一个类：




class MyClass {
    constructor(name) {
        this.name = name;
    }
 
    greet() {
        console.log(`Hello, my name is ${this.name}!`);
    }
}

创建类的实例并调用方法：




const myInstance = new MyClass('Alice');
myInstance.greet(); // 输出: Hello, my name is Alice!

Class 的主要优点是它提供了一种更清晰、更简洁的方式来创建和维护对象和其行为。它也有助于代码的模块化和重用。

应用场景：

创建复杂对象，它们具有多个属性和方法。
实现继承和多态，可以定义基础类，然后从中派生出其他类。
代码组织和维护，Class 可以作为封装和模块化的方式，将相关的数据和方法组织在一起。
工程化应用，Class 是现代 JavaScript 开发的核心概念，被广泛应用于构建大型应用。

利用Cesium和JS实现地点点聚合功能

2024-08-20

在Cesium中实现地点点聚合功能，可以使用ClusteredBillboardCollection。以下是一个简单的实现示例：




// 假设你已经创建了Cesium.Viewer实例
var viewer = new Cesium.Viewer('cesiumContainer');
 
// 创建一个点聚合集合
var billboards = new Cesium.ClusteredBillboardCollection(viewer.scene);
 
// 模拟一些原始位置数据
var positions = [
  Cesium.Cartesian3.fromDegrees(-75.59777, 40.03883),
  // ... 更多点
];
 
// 创建一个随机的图标集合，用于点聚合后的展示
var images = [
  'url_to_image_1.png',
  'url_to_image_2.png',
  // ... 更多图片
];
 
// 将位置和图片对应起来
for (var i = 0; i < positions.length; i++) {
  var image = images[Math.floor(Math.random() * images.length)];
  billboards.add({
    position: positions[i],
    image: image,
    // 你还可以设置其他属性，如下面的scale和clusterText
    scale: 1.0,
    clusterText: `${positions.length}`
  });
}
 
// 将点聚合集合添加到场景中
viewer.scene.primitives.add(billboards);
 
// 调整点聚合的参数（可选）
billboards.clusterState.clusterLabels = true; // 显示聚合计数
billboards.clusterState.enabled = true; // 开启聚合
billboards.clusterState.minimumClusterSize = 5; // 最小聚合数目
billboards.defaultClusterShowBoundingVolume = false; // 不显示聚合体积

这段代码创建了一个ClusteredBillboardCollection，并将模拟的原始点位置和随机图标添加到集合中。然后将集合添加到Cesium的场景中，并可以通过调整集合的参数来控制点聚合的行为。

2024-08-20

以下是实现这些排序算法的JavaScript代码示例：

冒泡排序：




function bubbleSort(arr) {
    let swapped;
    do {
        swapped = false;
        for (let i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                let temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
                swapped = true;
            }
        }
    } while (swapped);
    return arr;
}

选择排序：




function selectionSort(arr) {
    let min;
    for (let i = 0; i < arr.length - 1; i++) {
        min = i;
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[min]) {
                min = j;
            }
        }
        let temp = arr[i];
        arr[i] = arr[min];
        arr[min] = temp;
    }
    return arr;
}

快速排序：




function quickSort(arr) {
    if (arr.length <= 1) {
        return arr;
    }
    let pivot = arr[Math.floor((arr.length - 1) / 2)];
    let left = [], right = [];
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] < pivot) {
            left.push(arr[i]);
        } else if (arr[i] > pivot) {
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat([pivot], quickSort(right));
}

插入排序：




function insertionSort(arr) {
    let key, j;
    for (let i = 1; i < arr.length; i++) {
        key = arr[i];
        j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
    return arr;
}

二分插入排序：




function binaryInsertionSort(arr) {
    for (let i = 1; i < arr.length; i++) {
        let key = arr[i], left = 0, right = i - 1;
        while (left <= right) {
            let mid = Math.floor((left + right) / 2);
            if (arr[mid] > key) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        for (let j = i - 1; j >= left; j--) {
            arr[j + 1] = arr[j];
        }
        if (left !== i) {
            arr[left] = key;
        }
    }
    return arr;
}

希尔排序：




function shellSort(arr) {
    let gap = arr.length / 2;
    while (gap > 0) {
        for (let i = gap; i < arr.length; i++) {
            let temp = arr[i];
            let j = i;
            while ((j >= gap) && (arr[j - gap] > temp)) {