当前位置： 首页 > news >正文

URL时间戳参数深度解析：缓存破坏与前端优化的前世今生

news 2025/7/3 5:13:15

🔍 URL时间戳参数深度解析：缓存破坏与前端优化的前世今生

在日常的Web开发中，你是否注意到很多接口URL后面都会带有一个时间戳参数？比如 xxx/getMsg?_=1751413509056。这个看似简单的参数背后，却隐藏着前端缓存策略、性能优化等重要技术原理。今天，让我们跟随小李和小王的对话，深入探讨这个参数的前世今生。

小李的困惑：神秘的URL参数

小李：小王，我最近在工作中发现一个奇怪的现象，很多接口的URL后面都会加一串类似于时间戳的东西，比如：xxx/getMsg?_=1751413509056。我在后端代码中仔细检查过，根本没有处理这个参数的逻辑。这到底是怎么回事呢？

小王：哈哈，小李，你观察得很仔细！这个参数确实不是给后端用的，而是前端用来解决缓存问题的一个巧妙技巧。让我用3W法（What、Why、How）来给你详细解释一下。

What：什么是URL时间戳参数？

小李：那这个参数到底是什么呢？

小王：这个参数通常被称为"缓存破坏参数"（Cache Busting Parameter）或"版本戳"（Version Stamp）。它的主要作用是：

  1. 强制刷新缓存：让浏览器认为这是一个全新的请求
  2. 绕过浏览器缓存：确保获取最新的资源内容
  3. 版本控制：标识资源的不同版本

常见的参数形式

// 时间戳形式
/api/data?_=1751413509056// 随机数形式
/api/data?v=0.123456789// 版本号形式
/api/data?v=1.2.3// 哈希值形式
/api/data?v=a1b2c3d4

Why：为什么需要这个参数？

小李：既然有这个参数，那肯定是有原因的。为什么要这样做呢？

小王：很好的问题！这涉及到Web缓存机制和前端性能优化的核心问题。让我给你详细分析：

1. 浏览器缓存机制

小王：现代浏览器都有强大的缓存机制，包括：

  • HTTP缓存：基于HTTP头信息的缓存策略
  • 浏览器缓存：本地存储的静态资源
  • CDN缓存：分布式缓存网络

2. 缓存带来的问题

小李：缓存不是好事吗？能提高性能啊！

小王：缓存确实能提高性能，但也会带来一些问题：

// 问题场景示例
// 用户访问页面，获取数据
GET /api/userInfo
// 返回：{name: "张三", age: 25}// 数据更新后，用户再次访问
GET /api/userInfo  
// 浏览器返回缓存的旧数据：{name: "张三", age: 25}
// 而不是最新的：{name: "张三", age: 26}

3. 具体应用场景

小王：这个参数在以下场景中特别有用：

  1. API数据更新：后端数据发生变化，需要前端立即获取最新数据
  2. 静态资源更新：CSS、JS文件更新后，需要强制刷新
  3. 实时数据：股票、天气等需要实时更新的数据
  4. 开发调试：开发过程中避免缓存干扰

How：如何实现和使用？

小李：那具体是怎么实现的呢？前端是怎么添加这个参数的？

小王：实现方式有很多种，我来给你展示几种常见的做法：

1. JavaScript动态添加

// 方法1：使用时间戳
function addTimestamp(url) {const timestamp = new Date().getTime();const separator = url.includes('?') ? '&' : '?';return `${url}${separator}_=${timestamp}`;
}// 使用示例
const apiUrl = '/api/getMsg';
const urlWithTimestamp = addTimestamp(apiUrl);
// 结果：/api/getMsg?_=1751413509056

2. 使用随机数

// 方法2：使用随机数
function addRandomParam(url) {const random = Math.random();const separator = url.includes('?') ? '&' : '?';return `${url}${separator}v=${random}`;
}

3. 使用版本号

// 方法3：使用版本号（推荐用于生产环境）
const APP_VERSION = '1.2.3';function addVersionParam(url) {const separator = url.includes('?') ? '&' : '?';return `${url}${separator}v=${APP_VERSION}`;
}

4. 实际项目中的应用

小王：在实际项目中，通常会这样使用：

// 封装请求函数
class ApiClient {constructor() {this.baseUrl = '/api';}// 获取数据（带缓存破坏）async getData(endpoint, useCacheBusting = false) {let url = `${this.baseUrl}${endpoint}`;if (useCacheBusting) {url = this.addCacheBustingParam(url);}const response = await fetch(url);return response.json();}// 添加缓存破坏参数addCacheBustingParam(url) {const timestamp = Date.now();const separator = url.includes('?') ? '&' : '?';return `${url}${separator}_=${timestamp}`;}
}// 使用示例
const api = new ApiClient();// 普通请求（可能使用缓存）
api.getData('/userInfo');// 强制刷新请求
api.getData('/userInfo', true);

深入探讨：时间戳参数的添加时机与代码实现

小李：小王，你刚才说了很多实现方式，但我还是有点困惑。这些时间戳到底是谁添加进去的？什么时候添加进去的？我能在项目中看到相关的代码吗？

小王：很好的问题！这涉及到前端框架、库和开发工具链的工作机制。让我详细给你分析一下：

1. 时间戳参数的添加者

小王：时间戳参数通常由以下几个"角色"添加：

前端框架自动添加
// Vue.js 示例 - 在main.js中配置
import axios from 'axios';// 配置axios拦截器，自动添加时间戳
axios.interceptors.request.use(config => {// 为特定接口添加时间戳if (config.url.includes('/api/dynamic')) {config.url += (config.url.includes('?') ? '&' : '?') + '_=' + Date.now();}return config;
});
构建工具自动添加
// Webpack配置示例
module.exports = {output: {filename: '[name].[contenthash].js', // 基于内容哈希的文件名chunkFilename: '[name].[contenthash].js'},plugins: [new HtmlWebpackPlugin({template: './src/index.html',// 自动为静态资源添加版本号hash: true})]
};
第三方库自动添加
// jQuery Ajax示例
$.ajax({url: '/api/data',cache: false, // 自动添加时间戳参数success: function(data) {console.log(data);}
});// 实际发送的请求：/api/data?_=1751413509056

2. 添加时机分析

小李：那具体是在什么时候添加的呢？

小王：添加时机可以分为几个层次：

开发时添加
// 开发环境中的手动添加
class DevelopmentApiClient {constructor() {this.isDev = process.env.NODE_ENV === 'development';}async request(url, options = {}) {if (this.isDev && options.forceRefresh) {// 开发环境强制刷新url = this.addTimestamp(url);}return fetch(url, options);}
}
运行时添加
// 运行时根据业务逻辑添加
class BusinessApiClient {async getUserProfile(userId) {let url = `/api/users/${userId}`;// 根据业务需求决定是否添加时间戳if (this.shouldForceRefresh(userId)) {url = this.addTimestamp(url);}return this.request(url);}shouldForceRefresh(userId) {// 业务逻辑：用户信息更新后强制刷新const lastUpdate = this.getLastUpdateTime(userId);return Date.now() - lastUpdate > 5 * 60 * 1000; // 5分钟}
}
构建时添加
// 构建工具配置
// webpack.config.js
const HtmlWebpackPlugin = require('html-webpack-plugin');module.exports = {plugins: [new HtmlWebpackPlugin({template: './src/index.html',// 构建时自动添加版本号hash: true,// 或者使用时间戳inject: true,minify: {removeComments: true,collapseWhitespace: true}})]
};

3. 实际项目中的代码位置

小李：那我在项目中具体能在哪些地方看到这些代码呢？

小王：让我给你一个完整的项目结构示例：

project/
├── src/
│   ├── utils/
│   │   └── api.js          # API请求封装
│   ├── services/
│   │   └── userService.js  # 业务服务层
│   ├── config/
│   │   └── axios.js        # Axios配置
│   └── main.js             # 应用入口
├── webpack.config.js       # 构建配置
├── package.json
└── .env                    # 环境变量
具体代码示例

1. API工具类 (src/utils/api.js)

// 缓存破坏工具类
export class CacheBuster {static addTimestamp(url) {const timestamp = Date.now();const separator = url.includes('?') ? '&' : '?';return `${url}${separator}_=${timestamp}`;}static addVersion(url, version) {const separator = url.includes('?') ? '&' : '?';return `${url}${separator}v=${version}`;}static addHash(url, hash) {const separator = url.includes('?') ? '&' : '?';return `${url}${separator}h=${hash}`;}
}// 基础请求类
export class BaseApiClient {constructor(baseURL = '/api') {this.baseURL = baseURL;}async request(endpoint, options = {}) {const { useCacheBusting = false, cacheBustingType = 'timestamp' } = options;let url = `${this.baseURL}${endpoint}`;if (useCacheBusting) {switch (cacheBustingType) {case 'timestamp':url = CacheBuster.addTimestamp(url);break;case 'version':url = CacheBuster.addVersion(url, process.env.APP_VERSION);break;case 'hash':url = CacheBuster.addHash(url, this.generateHash());break;}}const response = await fetch(url, options);return response.json();}generateHash() {return Math.random().toString(36).substr(2, 9);}
}

2. Axios配置 (src/config/axios.js)

import axios from 'axios';// 创建axios实例
const api = axios.create({baseURL: process.env.REACT_APP_API_BASE_URL || '/api',timeout: 10000
});// 请求拦截器
api.interceptors.request.use(config => {// 开发环境自动添加时间戳if (process.env.NODE_ENV === 'development') {config.url = addTimestampIfNeeded(config.url);}// 特定接口强制刷新if (config.forceRefresh) {config.url = addTimestamp(config.url);}return config;},error => {return Promise.reject(error);}
);// 响应拦截器
api.interceptors.response.use(response => {return response;},error => {// 如果是缓存相关错误，重试时添加时间戳if (error.response?.status === 304) {const originalRequest = error.config;originalRequest.url = addTimestamp(originalRequest.url);return api(originalRequest);}return Promise.reject(error);}
);function addTimestamp(url) {const timestamp = Date.now();const separator = url.includes('?') ? '&' : '?';return `${url}${separator}_=${timestamp}`;
}function addTimestampIfNeeded(url) {// 只对特定接口添加时间戳const dynamicEndpoints = ['/user/profile', '/data/realtime', '/config/latest'];const shouldAdd = dynamicEndpoints.some(endpoint => url.includes(endpoint));if (shouldAdd) {return addTimestamp(url);}return url;
}export default api;

3. 业务服务层 (src/services/userService.js)

import api from '../config/axios';export class UserService {// 获取用户基本信息（使用缓存）async getUserInfo(userId) {return api.get(`/users/${userId}`);}// 获取用户实时数据（强制刷新）async getUserRealTimeData(userId) {return api.get(`/users/${userId}/realtime`, {forceRefresh: true});}// 更新用户信息后刷新async updateUserInfo(userId, userData) {await api.put(`/users/${userId}`, userData);// 更新后强制刷新用户信息return this.getUserInfo(userId, { forceRefresh: true });}// 获取用户配置（根据配置类型决定是否刷新）async getUserConfig(userId, configType) {const isDynamicConfig = ['preferences', 'settings'].includes(configType);return api.get(`/users/${userId}/config/${configType}`, {forceRefresh: isDynamicConfig});}
}

4. 参数名的选择与规范

小李：小王，我注意到你刚才的代码中参数名用的是 _，这个参数名有特殊要求吗？我看有些地方用的是 v、t 或者其他名字，有什么讲究吗？

小王：很好的观察！参数名的选择确实有一些历史原因和最佳实践，让我详细给你解释一下：

常见的参数名及其含义
// 1. 下划线 (_) - 最常用的选择
/api/data?_=1751413509056// 2. 版本号 (v) - 语义化版本控制
/api/data?v=1.2.3// 3. 时间戳 (t) - 明确表示时间
/api/data?t=1751413509056// 4. 哈希值 (h) - 内容哈希
/api/data?h=a1b2c3d4// 5. 随机数 (r) - 随机标识
/api/data?r=0.123456789// 6. 缓存破坏 (cb) - Cache Busting缩写
/api/data?cb=1751413509056
为什么选择下划线 (_)？

小王：下划线作为参数名有以下几个优势：

  1. 简洁性：单个字符，URL更短
  2. 通用性：几乎所有编程语言都支持
  3. 历史原因：早期Web开发中的约定俗成
  4. 避免冲突：不太可能与业务参数冲突
// 参数名对比示例
// ❌ 可能冲突的参数名
/api/user?name=张三&id=123&version=1.0  // version可能与业务参数冲突// ✅ 使用下划线避免冲突
/api/user?name=张三&id=123&_=1751413509056  // 下划线不会与业务参数冲突
不同场景的参数名选择

小王：根据不同的使用场景，可以选择不同的参数名：

// 1. 开发环境 - 使用时间戳
class DevelopmentCacheBuster {static addParam(url) {const timestamp = Date.now();const separator = url.includes('?') ? '&' : '?';return `${url}${separator}_=${timestamp}`;}
}// 2. 生产环境 - 使用版本号
class ProductionCacheBuster {static addParam(url) {const version = process.env.APP_VERSION || '1.0.0';const separator = url.includes('?') ? '&' : '?';return `${url}${separator}v=${version}`;}
}// 3. 内容哈希 - 用于静态资源
class ContentHashCacheBuster {static addParam(url, contentHash) {const separator = url.includes('?') ? '&' : '?';return `${url}${separator}h=${contentHash}`;}
}// 4. 语义化参数名 - 明确表达意图
class SemanticCacheBuster {static addParam(url, type = 'timestamp') {const separator = url.includes('?') ? '&' : '?';switch (type) {case 'timestamp':return `${url}${separator}t=${Date.now()}`;case 'version':return `${url}${separator}v=${process.env.APP_VERSION}`;case 'random':return `${url}${separator}r=${Math.random()}`;default:return `${url}${separator}_=${Date.now()}`;}}
}
参数名的最佳实践

小王：在实际项目中，建议遵循以下规范：

// 统一的缓存破坏工具类
class CacheBuster {// 配置参数名策略static config = {development: '_',    // 开发环境用下划线production: 'v',     // 生产环境用版本号static: 'h',         // 静态资源用哈希dynamic: 't'         // 动态数据用时间戳};static addParam(url, type = 'development') {const paramName = this.config[type];const separator = url.includes('?') ? '&' : '?';let paramValue;switch (type) {case 'development':paramValue = Date.now();break;case 'production':paramValue = process.env.APP_VERSION || '1.0.0';break;case 'static':paramValue = this.generateContentHash(url);break;case 'dynamic':paramValue = Date.now();break;default:paramValue = Date.now();}return `${url}${separator}${paramName}=${paramValue}`;}static generateContentHash(url) {// 简化的内容哈希生成return Math.random().toString(36).substr(2, 8);}
}// 使用示例
const api = {// 开发环境APIdev: (url) => CacheBuster.addParam(url, 'development'),// 生产环境APIprod: (url) => CacheBuster.addParam(url, 'production'),// 静态资源static: (url) => CacheBuster.addParam(url, 'static'),// 动态数据dynamic: (url) => CacheBuster.addParam(url, 'dynamic')
};
参数名的安全性考虑

小李：那参数名会不会有安全风险呢？

小王：确实需要考虑一些安全因素：

// 安全考虑示例
class SecureCacheBuster {static addParam(url, options = {}) {const {paramName = '_',sanitize = true,maxLength = 20} = options;// 参数名安全检查if (sanitize && !this.isValidParamName(paramName)) {throw new Error('Invalid parameter name');}const separator = url.includes('?') ? '&' : '?';const value = this.generateSecureValue(maxLength);return `${url}${separator}${paramName}=${value}`;}static isValidParamName(name) {// 只允许字母、数字、下划线return /^[a-zA-Z0-9_]+$/.test(name);}static generateSecureValue(maxLength) {// 生成安全的随机值return Math.random().toString(36).substr(2, maxLength);}
}
实际项目中的参数名规范

小王：在大型项目中，通常会制定统一的参数名规范：

// 项目配置文件
const CACHE_BUSTING_CONFIG = {// 开发环境development: {api: '_',           // API请求static: 'v',        // 静态资源dynamic: 't'        // 动态数据},// 生产环境production: {api: 'v',           // API请求用版本号static: 'h',        // 静态资源用哈希dynamic: 't'        // 动态数据用时间戳},// 测试环境testing: {api: 'cb',          // Cache Busting缩写static: 'v',dynamic: 't'}
};// 统一的缓存破坏服务
class CacheBustingService {constructor(environment = 'development') {this.config = CACHE_BUSTING_CONFIG[environment];}addParam(url, type = 'api') {const paramName = this.config[type];const separator = url.includes('?') ? '&' : '?';const value = this.generateValue(type);return `${url}${separator}${paramName}=${value}`;}generateValue(type) {switch (type) {case 'api':return Date.now();case 'static':return process.env.APP_VERSION || '1.0.0';case 'dynamic':return Date.now();default:return Date.now();}}
}

5. 调试和监控

小李：那我在开发时怎么调试这些参数呢？

小王：有几种方法可以调试和监控：

浏览器开发者工具
// 在控制台中监控请求
const originalFetch = window.fetch;
window.fetch = function(...args) {console.log('Fetch请求:', args[0]);return originalFetch.apply(this, args);
};// 监控XMLHttpRequest
const originalXHROpen = XMLHttpRequest.prototype.open;
XMLHttpRequest.prototype.open = function(method, url, ...args) {console.log('XHR请求:', url);return originalXHROpen.apply(this, [method, url, ...args]);
};
网络面板分析
// 在代码中添加调试信息
class DebugApiClient extends BaseApiClient {async request(endpoint, options = {}) {const originalUrl = `${this.baseURL}${endpoint}`;const finalUrl = options.useCacheBusting ? CacheBuster.addTimestamp(originalUrl) : originalUrl;console.log('API请求:', {original: originalUrl,final: finalUrl,hasCacheBusting: options.useCacheBusting});return super.request(endpoint, options);}
}

深入理解：缓存策略与HTTP头

小李：小王，你刚才提到了HTTP缓存，能详细说说吗？

小王：当然可以！这涉及到HTTP缓存控制机制，让我给你详细解释：

HTTP缓存控制头

# 服务器响应头示例
HTTP/1.1 200 OK
Cache-Control: max-age=3600
ETag: "abc123"
Last-Modified: Wed, 21 Oct 2023 07:28:00 GMT

缓存策略对比

策略优点缺点适用场景
时间戳参数简单直接，强制刷新每次都请求，浪费带宽数据更新频繁
HTTP缓存头智能缓存，节省带宽配置复杂，需要服务器支持静态资源，数据稳定
ETag机制精确控制，节省带宽需要服务器计算ETag大型应用

实际案例分析

小王：让我用一个实际的例子来说明：

// 场景：用户管理系统
class UserManager {constructor() {this.api = new ApiClient();}// 获取用户列表（使用缓存）async getUserList() {return await this.api.getData('/users');}// 获取用户详情（强制刷新）async getUserDetail(userId) {return await this.api.getData(`/users/${userId}`, true);}// 更新用户信息后，强制刷新列表async updateUser(userId, userData) {await this.api.postData(`/users/${userId}`, userData);// 更新后强制刷新用户列表return await this.getUserList(true);}
}

最佳实践与注意事项

小李：那在实际开发中，有什么最佳实践吗？

小王：确实有一些重要的最佳实践需要注意：

1. 合理使用缓存破坏

// ❌ 错误做法：所有请求都加时间戳
function badPractice() {// 每次都强制刷新，浪费带宽fetch('/api/staticData?_=' + Date.now());
}// ✅ 正确做法：根据数据特性决定
function goodPractice() {// 静态数据使用缓存fetch('/api/staticData');// 动态数据强制刷新fetch('/api/dynamicData?_=' + Date.now());
}

2. 版本号管理

// 生产环境推荐使用版本号而不是时间戳
const config = {development: {cacheBusting: 'timestamp'  // 开发环境用时间戳},production: {cacheBusting: 'version'    // 生产环境用版本号}
};

3. 性能考虑

小王：使用时间戳参数时要注意性能影响：

// 性能优化示例
class OptimizedApiClient {constructor() {this.cache = new Map();this.cacheTimeout = 5 * 60 * 1000; // 5分钟}async getData(url, useCacheBusting = false) {const cacheKey = `${url}_${useCacheBusting}`;// 检查内存缓存if (this.cache.has(cacheKey)) {const cached = this.cache.get(cacheKey);if (Date.now() - cached.timestamp < this.cacheTimeout) {return cached.data;}}// 发起请求let requestUrl = url;if (useCacheBusting) {requestUrl = this.addCacheBustingParam(url);}const response = await fetch(requestUrl);const data = await response.json();// 缓存结果this.cache.set(cacheKey, {data,timestamp: Date.now()});return data;}
}

常见问题与解决方案

小李：小王，我在使用过程中遇到了一些问题，能帮我解决吗？

小王：当然可以！让我总结一下常见问题和解决方案：

问题1：参数名冲突

// 问题：URL中已有同名参数
const url = '/api/data?param1=value1&_=123';// 解决方案：检查并处理
function addCacheBustingParam(url) {const timestamp = Date.now();if (url.includes('_=')) {// 替换现有的时间戳参数return url.replace(/_[^&]*/, `_=${timestamp}`);} else {const separator = url.includes('?') ? '&' : '?';return `${url}${separator}_=${timestamp}`;}
}

问题2：CDN缓存

// CDN缓存问题：即使加了时间戳，CDN可能仍然缓存
// 解决方案：使用更复杂的缓存破坏策略function advancedCacheBusting(url) {const timestamp = Date.now();const random = Math.random().toString(36).substr(2, 9);const separator = url.includes('?') ? '&' : '?';return `${url}${separator}_=${timestamp}&r=${random}`;
}

问题3：SEO影响

// SEO问题：搜索引擎可能将带时间戳的URL视为不同页面
// 解决方案：区分静态资源和动态数据// 静态资源使用版本号
const staticAssets = {css: '/assets/style.css?v=1.2.3',js: '/assets/app.js?v=1.2.3'
};// 动态数据使用时间戳
const apiEndpoints = {userData: '/api/user?_=' + Date.now()
};

总结与展望

小李：小王，今天学到了很多！让我总结一下：

  1. URL时间戳参数是前端用来破坏缓存的技术手段
  2. 主要作用是强制浏览器获取最新数据
  3. 实现方式包括时间戳、随机数、版本号等
  4. 需要合理使用，避免过度使用影响性能

小王：总结得很好！补充一点，随着技术的发展，现在有更多现代化的解决方案：

现代替代方案

  1. Service Worker：更精细的缓存控制
  2. HTTP/2 Server Push：服务器主动推送更新
  3. WebSocket：实时数据推送
  4. GraphQL：精确的数据查询和缓存

未来趋势

// 现代缓存策略示例
class ModernCacheStrategy {constructor() {this.serviceWorker = null;this.initServiceWorker();}async initServiceWorker() {if ('serviceWorker' in navigator) {this.serviceWorker = await navigator.serviceWorker.register('/sw.js');}}// 使用Service Worker进行缓存控制async getDataWithModernCache(url) {// 实现更智能的缓存策略}
}

结语

通过今天的对话，我们深入了解了URL时间戳参数的前世今生。这个看似简单的技术细节，实际上体现了Web开发中缓存策略、性能优化、用户体验等多个方面的考虑。

在实际开发中，我们需要根据具体场景选择合适的缓存策略，既要保证数据的实时性，又要兼顾性能和用户体验。希望今天的分享能帮助你在工作中更好地处理类似问题！

本文采用对话形式，通过小李和小王的问答，深入浅出地讲解了URL时间戳参数的技术原理和应用实践。如果你有更多问题或想法，欢迎继续探讨！

http://www.lqws.cn/news/603847.html

相关文章：

  • Linux缓存调优指南：提升服务器性能的关键策略
  • opencv基础的图像操作
  • 图像二值化方法及 Python OpenCV 实现
  • 【分明集合】特征函数、关系与运算
  • 【1.6 漫画数据库设计实战 - 从零开始设计高性能数据库】
  • 【格与代数系统】格与哈斯图
  • Instruct-GPT中强化学习（RL）训练部分详解
  • 电机控制的一些笔记
  • uniapp选择相册
  • 【读代码】百度开源大模型：ERNIE项目解析
  • web开发，旅游景点管理系统推荐算法版本demo，基于asp.net,mvc,c#,sql server
  • 【算法】动态规划 斐波那契类型： 740. 删除并获得点数
  • [面试] 手写题-防抖，节流
  • Vue 安装使用教程
  • 小白成长之路-Mysql数据库基础(二)
  • uniapp内置蓝牙打印
  • jQuery UI 安装使用教程
  • Leetcode力扣解题记录--第49题（map）
  • 电源芯片之DCDC初探索ING
  • 数据结构：递归：组合数（Combination formula）
  • 深度学习常见的激活函数
  • 2025年7月最新英雄联盟战绩自动查询工具
  • [创业之路-458]：企业经营层 - 蓝海战略 - 重构价值曲线、整合产业要素、创造新需求
  • 技术学习_人工智能_1_神经网络是如何实现的？
  • 设计模式精讲 Day 22：模板方法模式（Template Method Pattern）
  • 在 Docker 容器中使用内网穿透
  • 论文阅读：BLIPv1 2022.2
  • 使用 StatsD 向 TDengine 写入
  • Python应用指南：利用高德地图API获取公交+地铁可达圈（三）
  • 黑马python（二十三）