分类 前端 下的文章

  1. 安装 Axios
    首先,在项目下安装 Axios 依赖:

    npm install axios

    或者:

    yarn add axios
  2. 在组件中直接调用 Axios
    在 React 的函数组件中,你可以直接使用 Axios 进行数据请求。通常我们会结合 React 的 useStateuseEffect 实现数据的获取和管理,例如:

    import React, { useState, useEffect } from 'react';
    import axios from 'axios';
    
    const MyComponent = () => {
      const [data, setData] = useState(null);
      const [loading, setLoading] = useState(true);
      const [error, setError] = useState(null);
    
      useEffect(() => {
        axios.get('/api/data')
          .then(response => {
            setData(response.data);
            setLoading(false);
          })
          .catch(err => {
            setError(err);
            setLoading(false);
          });
      }, []);
    
      if (loading) return <div>加载中...</div>;
      if (error) return <div>发生错误...</div>;
    
      return (
        <div>
          <h1>数据展示</h1>
          <pre>{JSON.stringify(data, null, 2)}</pre>
        </div>
      );
    };
    
    export default MyComponent;

    这种方式简单直观,适用于单个组件内部的数据请求需求。

  3. 封装 Axios 实例
    为了在整个项目中统一管理和复用 Axios 的配置(如基础 URL、超时配置以及请求与响应拦截器),可以创建一个 Axios 实例。例如:

    // axiosInstance.js
    import axios from 'axios';
    
    const axiosInstance = axios.create({
      baseURL: '<https://api.example.com>',
      timeout: 5000,
    });
    
    // 请求拦截器:如添加认证 token
    axiosInstance.interceptors.request.use(
      config => {
        // Modify config before request is sent, e.g.,添加token
        // config.headers.Authorization = 'Bearer yourToken';
        return config;
      },
      error => Promise.reject(error)
    );
    
    // 响应拦截器:统一处理响应
    axiosInstance.interceptors.response.use(
      response => response,
      error => Promise.reject(error)
    );
    
    export default axiosInstance;

    然后在你的组件中引入这个实例,而不是直接使用 Axios,通过这种方式可以确保全局请求配置的一致性和便于维护。

  4. 结合 React Context 和 Provider
    如果你的应用中有很多组件都需要发起请求,并且希望在统一配置(例如统一注册请求拦截器)后进行调用,可以使用 React 的 Context 来组织 Axios 实例。通过 Provider 将配置好的 Axios 实例传递给整个组件树,以便在各个组件中通过 useContext 取得该实例,这也是符合 React Hooks 思想的一种方式。例如:

    // AxiosContext.js
    import React, { createContext } from 'react';
    import axiosInstance from './axiosInstance';
    
    export const AxiosContext = createContext(axiosInstance);
    
    export const AxiosProvider = ({ children }) => {
      return (
        <AxiosContext.Provider value={axiosInstance}>
          {children}
        </AxiosContext.Provider>
      );
    };

    然后在组件中使用:

    import React, { useContext, useEffect, useState } from 'react';
    import { AxiosContext } from './AxiosContext';
    
    const MyComponent = () => {
      const axios = useContext(AxiosContext);
      const [data, setData] = useState(null);
    
      useEffect(() => {
        axios.get('/api/data').then(response => {
          setData(response.data);
        });
      }, [axios]);
    
      return <div>{data ? JSON.stringify(data) : '加载中...'}</div>;
    };
    
    export default MyComponent;

    这种 Provider 模式可以有效地将拦截器和其他配置注册到整个应用中,方便管理和使用。

什么是异步操作?

异步操作(Asynchronous Operation)是指程序在执行某个操作时,不需要等待该操作完成就能继续执行后续代码的编程模式。与同步操作(必须等待操作完成才能继续)不同,异步操作允许程序在等待某些耗时操作(如I/O、网络请求等)完成的同时继续执行其他任务。

异步操作的核心特点

  1. 非阻塞:主线程不会被阻塞,可以继续执行其他任务
  2. 延迟处理:操作结果将在未来某个时间点可用
  3. 回调机制:通常通过回调函数、Promise或async/await来处理结果
  4. 提高效率:特别适合I/O密集型操作,能更好地利用系统资源

同步 vs 异步

同步操作示例(阻塞式)

// 同步读取文件(Node.js)
const fs = require('fs');
const data = fs.readFileSync('file.txt'); // 程序会停在这里直到文件读取完成
console.log(data);
console.log('这行代码会在文件读取完成后执行');

异步操作示例(非阻塞式)

// 异步读取文件(Node.js)
const fs = require('fs');
fs.readFile('file.txt', (err, data) => {
    // 这个回调函数会在文件读取完成后执行
    if (err) throw err;
    console.log(data);
});
console.log('这行代码会立即执行,不必等待文件读取完成');

异步操作的常见场景

  1. 网络请求

    fetch('<https://api.example.com/data>')
      .then(response => response.json())
      .then(data => console.log(data))
      .catch(error => console.error('Error:', error));
    
    console.log('这个日志会立即显示,不必等待请求完成');
  2. 定时操作

    setTimeout(() => {
      console.log('这条消息将在2秒后显示');
    }, 2000);
    console.log('这条消息会立即显示');
  3. 数据库操作

    // 伪代码示例
    database.query('SELECT * FROM users', (err, results) => {
      if (err) throw err;
      console.log(results);
    });
    console.log('查询已发起,继续执行其他代码');
  4. 用户交互

    document.getElementById('button').addEventListener('click', () => {
      console.log('按钮被点击了');
    });
    console.log('已设置点击监听器,继续执行其他代码');

异步编程的实现方式

  1. 回调函数(最基础的方式):

    function asyncOperation(callback) {
      setTimeout(() => {
        callback('操作完成');
      }, 1000);
    }
    
    asyncOperation((message) => {
      console.log(message); // 1秒后输出"操作完成"
    });
  2. Promise(ES6引入):

    function asyncOperation() {
      return new Promise((resolve) => {
        setTimeout(() => {
          resolve('操作完成');
        }, 1000);
      });
    }
    
    asyncOperation()
      .then(message => console.log(message));
  3. async/await(ES2017引入,语法糖):

    async function doWork() {
      const message = await asyncOperation();
      console.log(message);
    }
    
    doWork();

为什么需要异步操作?

  1. 性能优化:避免阻塞主线程,特别是在单线程环境(如浏览器中的JavaScript)
  2. 用户体验:保持UI响应流畅,避免"卡死"现象
  3. 资源利用:在等待I/O操作(如磁盘读写、网络请求)时,CPU可以处理其他任务
  4. 可扩展性:适合处理高并发场景(如服务器同时处理多个请求)

异步操作的挑战

  1. 代码复杂性:回调嵌套可能导致"回调地狱"
  2. 错误处理:异步错误不像同步错误那样可以通过try-catch直接捕获
  3. 调试困难:执行流程不如同步代码直观
  4. 状态管理:多个异步操作之间的协调可能变得复杂

实际应用示例

多个异步操作并行执行

// 使用Promise.all
const fetchUser = fetch('/user');
const fetchPosts = fetch('/posts');

Promise.all([fetchUser, fetchPosts])
  .then(responses => Promise.all(responses.map(r => r.json())))
  .then(([user, posts]) => {
    console.log('用户数据:', user);
    console.log('帖子数据:', posts);
  });

异步操作串行执行

// 使用async/await
async function getData() {
  const user = await fetch('/user').then(r => r.json());
  const posts = await fetch('/posts').then(r => r.json());

  console.log('用户数据:', user);
  console.log('帖子数据:', posts);
}

异步操作是现代编程中不可或缺的概念,特别是在Web开发、Node.js、移动应用开发等领域。理解异步编程是成为高效开发者的关键一步。

使用 white-space 的 CSS 样式

可以用 CSS 的 white-space 属性来实现换行符的显示。

具体代码:

export default function Display({ content }) {
  return (
    <div style={{ whiteSpace: "pre-wrap" }}>
      {content}
    </div>
  );
}
  • 解释

    • white-space: pre-wrap 是一种 CSS 样式,能够保留换行符和空格,并根据需要自动换行。
    • pre-wrap 的效果如下:

      1. 保留输入中的换行符。
      2. 允许长内容自动换行(减少水平滚动条)。

例如:
输入的内容 "12312\\n123132" 会渲染为:

12312
123132

什么是回调函数?

回调函数是一种编程模式,指的是将一个函数作为参数传递给另一个函数,并在特定条件或事件发生时由后者调用前者。回调函数允许异步操作和事件驱动的编程。

简单来说:回调函数是你定义好但由别人(通常是系统或其他函数)在适当时候调用的函数。

回调函数的主要特点

  1. 函数作为参数:回调函数通常作为参数传递给另一个函数
  2. 延迟执行:回调函数不会立即执行,而是在特定条件满足时执行
  3. 异步处理:常用于处理异步操作的结果
  4. 解耦:将调用者与被调用者分离,提高代码灵活性

回调函数的例子

1. JavaScript中的简单回调

// 定义一个回调函数
function greeting(name) {
    console.log('Hello ' + name);
}

// 定义一个接收回调的函数
function processUserInput(callback) {
    const name = prompt('Please enter your name.');
    callback(name); // 在适当时候调用回调
}

// 使用回调
processUserInput(greeting);

2. Node.js中的文件读取(异步I/O)

const fs = require('fs');

// 回调函数
function fileReadCallback(err, data) {
    if (err) {
        console.error('Error reading file:', err);
        return;
    }
    console.log('File content:', data);
}

// 异步读取文件,完成后调用回调
fs.readFile('example.txt', 'utf8', fileReadCallback);

3. 事件监听(浏览器DOM事件)

// 回调函数
function handleClick(event) {
    console.log('Button clicked!', event);
}

// 注册回调
document.getElementById('myButton').addEventListener('click', handleClick);

4. 排序中的比较回调

const numbers = [3, 1, 4, 1, 5, 9, 2, 6];

// 使用回调函数定义排序规则
numbers.sort(function(a, b) {
    return a - b; // 升序排序
});

console.log(numbers); // [1, 1, 2, 3, 4, 5, 6, 9]

回调函数的优缺点

优点

  • 实现异步编程
  • 提高代码复用性
  • 解耦调用者和被调用者
  • 适用于事件驱动编程

缺点

  • 回调地狱(Callback Hell):多层嵌套回调使代码难以阅读和维护
  • 错误处理复杂:需要在每个回调中单独处理错误
  • 控制流不直观

回调地狱示例

// 多层嵌套的回调,难以阅读和维护
doSomething(function(result) {
    doSomethingElse(result, function(newResult) {
        doThirdThing(newResult, function(finalResult) {
            console.log('Got the final result:', finalResult);
        }, failureCallback);
    }, failureCallback);
}, failureCallback);

现代JavaScript通常使用Promise或async/await来解决回调地狱问题。

回调函数是编程中非常重要的概念,特别是在JavaScript和Node.js中广泛使用。理解回调函数是掌握异步编程的基础。

安装

在vue ui中的插件处安装

使用

store 文件夹下面的 index.js

import { createStore } from 'vuex'

export default createStore({
  state: {
  },
  getters: {
  },
  mutations: {
  },
  actions: {
  },
  modules: {
  }
})

state 存放的是变量, getters 存放的是需要由 state 中的变量动态计算生成的变量, mutations 存放的是直接对 state 中变量进行修改的函数, actions 存放的是对 state 的各种更新方式(不能对state进行直接修改), modules 可以将 state 进行分割,避免代码过长。

在标签中使用变量
示例:

<ul class="navbar-nav" v-if="!$store.state.user.is_login">
    <li class="nav-item">
    <router-link class="nav-link" :to="{name: 'login', params: {}}">登录</router-link>
    </li>
    <li class="nav-item">
    <router-link class="nav-link" :to="{name: 'register', params: {}}">注册</router-link>
    </li>
</ul>
<ul class="navbar-nav" v-else>
    <li class="nav-item">{{ $store.state.user.username }}</li>
</ul>

使用 $store 访问store,user是一个module,所以通过这样的方式来访问user中的is_login变量

script 中使用
示例:

import { useStore } from 'vuex';
export default {
  name: 'UserListView',
  components: {
  },
  setup() {
    const store = useStore();
    console.log(store.state.user.username);
  }
}

在外部使用 actions 中的函数需要用到 useStore 这个组件
例如:

setup() {
    const store = useStore();
    const login = () => {
      store.dispatch("login", {
        username: username.value,
        password: password.value,
        succuss() {
          console.log("success");
        },
        error() {
          console.log("error");
        }
      })
    }
    return {
      login
    }
}

这里用 store 来接收 useStore() 返回的对象,使用 store.dispatch 来调用 login 函数, store.dispatch 传了两个参数,第一个是函数名,第二个是数据。

user.js:

import $ from 'jquery';
const ModuleUser = {
    state: {
        id: "",
        username: "",
        photo: "",
        followerCount: 0,
    },
    getters: {
    },
    mutations: {
    },
    actions: {
        login(context, data) {
            console.log(data);
            $.ajax({
                url: "xxx",
                type: "POST",
                data: {
                    username: data.username,
                    password: data.password,
                },
                success(resp) {
                    console.log(resp)
                }
            })
        }
    },
    modules: {

    }
};
export default ModuleUser;

actions中的login函数两个参数,第一个是上下文context,里面有很多自带的api,第二个是数据,可以通过外部使用这个函数时传入。

index.js:

import { createStore } from 'vuex'
import ModuleUser from './user'
export default createStore({
  state: {
  },
  getters: {
  },
  mutations: {
  },
  actions: {
  },
  modules: {
    user: ModuleUser,
  }
})

这里user单独写一个module独立出去,只要在index.js中引入并在modules中添加这个变量即可。

mutations 中的函数需要传两个参数一个是 state 用来访问state中的变量,另外一个是自定义的参数。

mutations: {
    updateUser(state, user) {
        state.id = user.id;
        state.username = user.username;
        state.photot = user.photo;
        state.followerCount = user.followerCount;
        state.access = user.access;
        state.refresh = user.refresh;
        state.is_login = user.is_login;
    },
},

actions 中使用 mutations 中的函数示例:

context.commit("updateUser", {
    ...resp,
    access: access,
    refresh: refresh,
    is_login: true,
})

使用 context 中的commit函数,传两个参数,一个是函数名称,另外一个是自定义参数。