添加登录页面

添加首页
2025-07-16 03:24:01 +00:00 · 2025-07-16 03:23:43 +00:00
5 changed files with 0 additions and 596 deletions
--- a/.gitea/workflows/build.yml
+++ b/.gitea/workflows/build.yml
@@ -1,8 +0,0 @@
 name: OpenAI Code Review
 uses: bhavik/gitea-code-review-action@v0.1
 with:
    PROGRAMMING_LANGUAGE: 'JavaScript'
    REVIEW_COMMENT_PREFIX: 'openai:'
    FULL_REVIEW_COMMENT: 'openai'
    OPENAI_TOKEN: ${{ secrets.OPENAI_TOKEN }}
    GITHUB_TOKEN: ${{ secrets.GH_TOKEN }}
--- a/css/styles.css
+++ b/css/styles.css
@@ -1,203 +0,0 @@
 /* 基本样式重置 */
 * {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
 }
 body {
    font-family: 'Microsoft YaHei', Arial, sans-serif;
    line-height: 1.6;
    color: #333;
    background-color: #f4f4f4;
 }
 .container {
    width: 90%;
    max-width: 1200px;
    margin: 0 auto;
    padding: 0 20px;
 }
 /* 头部样式 */
 header {
    background-color: #3498db;
    color: #fff;
    padding: 1rem 0;
    box-shadow: 0 2px 5px rgba(0,0,0,0.1);
 }
 header h1 {
    margin: 0;
    font-size: 1.8rem;
 }
 nav {
    margin-top: 1rem;
 }
 nav ul {
    list-style: none;
    display: flex;
 }
 nav ul li {
    margin-right: 20px;
 }
 nav ul li a {
    color: #fff;
    text-decoration: none;
    padding: 5px 10px;
    border-radius: 3px;
    transition: background-color 0.3s;
 }
 nav ul li a:hover,
 nav ul li a.active {
    background-color: rgba(255,255,255,0.2);
 }
 /* 页脚样式 */
 footer {
    background-color: #333;
    color: #fff;
    padding: 1rem 0;
    margin-top: 2rem;
    text-align: center;
 }
 /* 主内容区域 */
 main {
    padding: 2rem 0;
 }
 .welcome-section {
    background-color: #fff;
    padding: 2rem;
    border-radius: 5px;
    box-shadow: 0 2px 5px rgba(0,0,0,0.1);
    margin-top: 2rem;
 }
 /* 登录页面样式 */
 .login-page {
    background-color: #f9f9f9;
    height: 100vh;
    display: flex;
    align-items: center;
    justify-content: center;
 }
 .login-container {
    width: 100%;
    max-width: 400px;
    padding: 1rem;
 }
 .login-box {
    background-color: #fff;
    padding: 2rem;
    border-radius: 5px;
    box-shadow: 0 2px 15px rgba(0,0,0,0.1);
 }
 .login-box h1 {
    text-align: center;
    margin-bottom: 2rem;
    color: #3498db;
 }
 .form-group {
    margin-bottom: 1.5rem;
 }
 label {
    display: block;
    margin-bottom: 0.5rem;
    font-weight: bold;
 }
 input[type="text"],
 input[type="password"] {
    width: 100%;
    padding: 0.8rem;
    border: 1px solid #ddd;
    border-radius: 4px;
    font-size: 1rem;
    transition: border-color 0.3s;
 }
 input[type="text"]:focus,
 input[type="password"]:focus {
    border-color: #3498db;
    outline: none;
    box-shadow: 0 0 0 2px rgba(52, 152, 219, 0.2);
 }
 .btn-login {
    background-color: #3498db;
    color: #fff;
    border: none;
    padding: 0.8rem;
    width: 100%;
    font-size: 1rem;
    border-radius: 4px;
    cursor: pointer;
    transition: background-color 0.3s;
 }
 .btn-login:hover {
    background-color: #2980b9;
 }
 .error-message {
    color: #e74c3c;
    font-size: 0.85rem;
    margin-top: 5px;
    display: block;
 }
 .form-message {
    text-align: center;
    margin-top: 1rem;
    font-weight: bold;
 }
 .form-message.error {
    color: #e74c3c;
 }
 .form-message.success {
    color: #2ecc71;
 }
 /* 响应式设计 */
@media screen and (max-width: 768px) {
    header h1 {
        font-size: 1.5rem;
    }
    nav ul {
        flex-direction: column;
    }
    nav ul li {
        margin-right: 0;
        margin-bottom: 0.5rem;
    }
 }
@media screen and (max-width: 480px) {
    .login-container {
        padding: 0.5rem;
    }
    .login-box {
        padding: 1.5rem;
    }
    .login-box h1 {
        font-size: 1.5rem;
    }
 }
--- a/js/login.js
+++ b/js/login.js
@@ -1,121 +0,0 @@
 /**
 * 登录功能实现
 * 原生JavaScript，不依赖框架
 */
 document.addEventListener('DOMContentLoaded', function() {
    const loginForm = document.getElementById('loginForm');
    const usernameInput = document.getElementById('username');
    const passwordInput = document.getElementById('password');
    const usernameError = document.getElementById('username-error');
    const passwordError = document.getElementById('password-error');
    const formMessage = document.getElementById('form-message');
    // 用于演示的模拟用户数据
    const mockUsers = [
        { username: 'admin', password: 'admin123' },
        { username: 'user', password: 'user123' }
    ];
    /**
     * 表单提交处理
     */
    loginForm.addEventListener('submit', function(e) {
        e.preventDefault();
        // 重置错误信息
        resetErrors();
        // 获取输入值
        const username = usernameInput.value.trim();
        const password = passwordInput.value.trim();
        // 验证表单
        let isValid = validateForm(username, password);
        if (isValid) {
            // 模拟登录请求
            mockLogin(username, password);
        }
    });
    /**
     * 表单验证
     */
    function validateForm(username, password) {
        let isValid = true;
        // 验证用户名
        if (username === '') {
            displayError(usernameError, '请输入用户名');
            isValid = false;
        } else if (username.length < 3) {
            displayError(usernameError, '用户名长度必须至少为3个字符');
            isValid = false;
        }
        // 验证密码
        if (password === '') {
            displayError(passwordError, '请输入密码');
            isValid = false;
        } else if (password.length < 6) {
            displayError(passwordError, '密码长度必须至少为6个字符');
            isValid = false;
        }
        return isValid;
    }
    /**
     * 显示错误信息
     */
    function displayError(element, message) {
        element.textContent = message;
    }
    /**
     * 重置错误信息
     */
    function resetErrors() {
        usernameError.textContent = '';
        passwordError.textContent = '';
        formMessage.textContent = '';
        formMessage.className = 'form-message';
    }
    /**
     * 模拟登录
     */
    function mockLogin(username, password) {
        // 显示加载状态
        formMessage.textContent = '登录中...';
        formMessage.className = 'form-message';
        // 模拟网络延迟
        setTimeout(function() {
            // 检查用户是否存在
            const user = mockUsers.find(user => 
                user.username === username && user.password === password
            );
            if (user) {
                // 登录成功
                formMessage.textContent = '登录成功，即将跳转...';
                formMessage.className = 'form-message success';
                // 保存登录状态到本地存储
                localStorage.setItem('isLoggedIn', 'true');
                localStorage.setItem('username', username);
                // 重定向到首页
                setTimeout(function() {
                    window.location.href = 'index.html';
                }, 1000);
            } else {
                // 登录失败
                formMessage.textContent = '用户名或密码错误';
                formMessage.className = 'form-message error';
            }
        }, 1000);
    }
 });
--- a/js/main.js
+++ b/js/main.js
@@ -1,56 +0,0 @@
 /**
 * 主页JavaScript
 */
 document.addEventListener('DOMContentLoaded', function() {
    // 检查用户是否已登录
    checkLoginStatus();
    // 初始化页面事件
    initEvents();
 });
 /**
 * 检查用户登录状态
 */
 function checkLoginStatus() {
    const isLoggedIn = localStorage.getItem('isLoggedIn');
    if (!isLoggedIn) {
        // 如果未登录，重定向到登录页面
        window.location.href = 'login.html';
        return;
    }
    // 获取并显示用户名
    const username = localStorage.getItem('username');
    if (username) {
        document.getElementById('username').textContent = username;
    }
 }
 /**
 * 初始化页面事件
 */
 function initEvents() {
    // 退出登录
    const logoutBtn = document.getElementById('logout');
    if (logoutBtn) {
        logoutBtn.addEventListener('click', function(e) {
            e.preventDefault();
            logout();
        });
    }
 }
 /**
 * 退出登录
 */
 function logout() {
    // 清除本地存储中的登录信息
    localStorage.removeItem('isLoggedIn');
    localStorage.removeItem('username');
    // 重定向到登录页面
    window.location.href = 'login.html';
 }
--- a/js/quicksort.js
+++ b/js/quicksort.js
@@ -1,208 +0,0 @@
 /**
 * 快速排序算法实现
 * 时间复杂度: 平均 O(n log n), 最坏 O(n²)
 * 空间复杂度: O(log n)
 */
 // 基本快速排序实现
 function quickSort(arr) {
    // 基本情况：如果数组长度小于等于1，直接返回
    if (arr.length <= 1) {
        return arr;
    }
    // 选择基准值（这里选择最后一个元素）
    const pivot = arr[arr.length - 1];
    const left = [];
    const right = [];
    // 将数组分成两部分
    for (let i = 0; i < arr.length - 1; i++) {
        if (arr[i] <= pivot) {
            left.push(arr[i]);
        } else {
            right.push(arr[i]);
        }
    }
    // 递归排序左右两部分，然后合并
    return [...quickSort(left), pivot, ...quickSort(right)];
 }
 // 原地快速排序（更高效，不创建新数组）
 function quickSortInPlace(arr, left = 0, right = arr.length - 1) {
    if (left < right) {
        const pivotIndex = partition(arr, left, right);
        quickSortInPlace(arr, left, pivotIndex - 1);
        quickSortInPlace(arr, pivotIndex + 1, right);
    }
    return arr;
 }
 // 分区函数
 function partition(arr, left, right) {
    // 选择最右边的元素作为基准值
    const pivot = arr[right];
    let i = left - 1;
    // 将小于基准值的元素移到左边
    for (let j = left; j < right; j++) {
        if (arr[j] <= pivot) {
            i++;
            [arr[i], arr[j]] = [arr[j], arr[i]]; // 交换元素
        }
    }
    // 将基准值放到正确的位置
    [arr[i + 1], arr[right]] = [arr[right], arr[i + 1]];
    return i + 1;
 }
 // 优化的快速排序（三数取中法选择基准值）
 function quickSortOptimized(arr, left = 0, right = arr.length - 1) {
    if (left < right) {
        const pivotIndex = partitionOptimized(arr, left, right);
        quickSortOptimized(arr, left, pivotIndex - 1);
        quickSortOptimized(arr, pivotIndex + 1, right);
    }
    return arr;
 }
 // 优化的分区函数（三数取中法）
 function partitionOptimized(arr, left, right) {
    // 三数取中法选择基准值
    const mid = Math.floor((left + right) / 2);
    const pivot = medianOfThree(arr, left, mid, right);
    // 将基准值移到最右边
    [arr[pivot], arr[right]] = [arr[right], arr[pivot]];
    let i = left - 1;
    for (let j = left; j < right; j++) {
        if (arr[j] <= arr[right]) {
            i++;
            [arr[i], arr[j]] = [arr[j], arr[i]];
        }
    }
    [arr[i + 1], arr[right]] = [arr[right], arr[i + 1]];
    return i + 1;
 }
 // 三数取中法
 function medianOfThree(arr, left, mid, right) {
    const a = arr[left];
    const b = arr[mid];
    const c = arr[right];
    if (a < b) {
        if (b < c) return mid;
        else if (a < c) return right;
        else return left;
    } else {
        if (a < c) return left;
        else if (b < c) return right;
        else return mid;
    }
 }
 // 测试函数
 function testQuickSort() {
    console.log("=== 快速排序算法测试 ===");
    // 测试用例
    const testCases = [
        [64, 34, 25, 12, 22, 11, 90],
        [5, 2, 4, 6, 1, 3],
        [1],
        [],
        [3, 3, 3, 3],
        [9, 8, 7, 6, 5, 4, 3, 2, 1]
    ];
    testCases.forEach((testCase, index) => {
        console.log(`\n测试用例 ${index + 1}: [${testCase.join(', ')}]`);
        // 测试基本快速排序
        const arr1 = [...testCase];
        const result1 = quickSort(arr1);
        console.log(`基本快速排序: [${result1.join(', ')}]`);
        // 测试原地快速排序
        const arr2 = [...testCase];
        const result2 = quickSortInPlace(arr2);
        console.log(`原地快速排序: [${result2.join(', ')}]`);
        // 测试优化快速排序
        const arr3 = [...testCase];
        const result3 = quickSortOptimized(arr3);
        console.log(`优化快速排序: [${result3.join(', ')}]`);
    });
 }
 // 性能测试函数
 function performanceTest() {
    console.log("\n=== 性能测试 ===");
    // 生成随机数组
    const generateRandomArray = (size) => {
        return Array.from({length: size}, () => Math.floor(Math.random() * 1000));
    };
    const sizes = [100, 1000, 10000];
    sizes.forEach(size => {
        const arr = generateRandomArray(size);
        console.log(`\n数组大小: ${size}`);
        // 测试基本快速排序
        const arr1 = [...arr];
        const start1 = performance.now();
        quickSort(arr1);
        const end1 = performance.now();
        console.log(`基本快速排序: ${(end1 - start1).toFixed(2)}ms`);
        // 测试原地快速排序
        const arr2 = [...arr];
        const start2 = performance.now();
        quickSortInPlace(arr2);
        const end2 = performance.now();
        console.log(`原地快速排序: ${(end2 - start2).toFixed(2)}ms`);
        // 测试优化快速排序
        const arr3 = [...arr];
        const start3 = performance.now();
        quickSortOptimized(arr3);
        const end3 = performance.now();
        console.log(`优化快速排序: ${(end3 - start3).toFixed(2)}ms`);
    });
 }
 // 导出函数供其他模块使用
 if (typeof module !== 'undefined' && module.exports) {
    module.exports = {
        quickSort,
        quickSortInPlace,
        quickSortOptimized,
        testQuickSort,
        performanceTest
    };
 }
 // 如果直接在浏览器中运行，执行测试
 if (typeof window !== 'undefined') {
    // 将函数添加到全局作用域
    window.quickSort = quickSort;
    window.quickSortInPlace = quickSortInPlace;
    window.quickSortOptimized = quickSortOptimized;
    window.testQuickSort = testQuickSort;
    window.performanceTest = performanceTest;
    console.log("快速排序算法已加载，可以使用以下函数：");
    console.log("- quickSort(arr): 基本快速排序");
    console.log("- quickSortInPlace(arr): 原地快速排序");
    console.log("- quickSortOptimized(arr): 优化快速排序");
    console.log("- testQuickSort(): 运行测试用例");
    console.log("- performanceTest(): 运行性能测试");
 }
Author	SHA1	Message	Date
beppeb	333a31853d	添加登录页面	2025-07-16 03:24:01 +00:00
beppeb	13dd353ac4	添加首页	2025-07-16 03:23:43 +00:00