菜单 搜索
首页 前端知识 Vue、uniApp、微信小程序、Html5等实现数缓存

Vue、uniApp、微信小程序、Html5等实现数缓存

2024-03-29 15:03:07 前端知识 前端哥 687 364 我要收藏

此文章带你实现前端缓存，利用时间戳封装一个类似于Redis可以添加过期时间的缓存工具
不仅可以实现对缓存数据设置过期时间，还可以自定义是否需要对缓存数据进行加密处理

工具介绍说明

对缓存数据进行非对称加密处理
在这里插入图片描述
对必要数据进行缓存，并设置过期时间，并设置是否需要对缓存数据进行加密处理
在这里插入图片描述
其他工具
在这里插入图片描述

1、过期时间：封装好的工具，可以添加数据的缓存时长（过期时间）
2、是否加密：可以根据需求，是否需要对缓存的数据进行加密处理
3、加密解密：只需要简单配置，就可以实现缓存数据的加密解密功能
4、长期有效：对于不需要过期的数据，只要不手动清理可以长期有效
5、扩展性强：可以根据自己的需求直接进行代码的调整，简单易懂易扩展

本地缓存

1、Vue、Html5 的数据缓存可以存放到localStorage 、cookie 或者 sessionStorage 中
2、uniApp、和 微信小程序 的数据缓存可以使用自带的API uni.setStorageSync

缓存的缺点

1、无论localStorage、cookie、sessionStorage 还是 uni.setStorageSync 都没有过期时间的限制
2、不能对数据进行实时的加解密处理，或者加解密扩展性差
3、对于大量旧的缓存数据还要手动处理，不能实时的去除旧数据

简单封装

代码以uniApp 为例，先实现可以添加过期时间的功能

缓存工具类：cacheUtil.js

const expiration = 1000 * 60 * 60 * 24 * 7; // 默认有效期7天
const keyPrefix = 'KEY_'; // 缓存key的统一前缀
import { isEmpty, isNumberStr, trimAllBlank } from './utils.js';

/**
 * 添加缓存
 * @param {String} key 缓存的key
 * @param {Object} val 缓存的val
 * @param {Number} expire 过期时间（单位：秒）
 * @returns {Boolean} 成功 | 失败
 */
export const setCache = (key, val, expire) => {
  if (isEmpty(key)) return false;
  expire = expire && isNumberStr(expire) ? Number(trimAllBlank(expire)) : 0;
  expire = Date.now() + (expire <= 0 ? expiration : (expire * 1000));
  let param = JSON.stringify({
    data: val, // 缓存的数据
    expire: expire // 过期时间
  });
  key = keyPrefix + key; // 缓存的key
  uni.setStorageSync(key, param); // 同步缓存
  return true;
}

/**
 * 获取缓存的数据
 * @param {String} key 缓存key
 * @returns {Object}
 */
export const getCache = (key) => {
  if (isEmpty(key)) return {};
  key = keyPrefix + key;
  let value = uni.getStorageSync(key) || '';
  if (value.includes('data') && value.includes('expire')) {
    value = JSON.parse(value) || {};
    let expire = value.expire || '';
    if (isEmpty(expire) || !isNumberStr(expire)) {
      return value.data || '';
    }
    expire = Number(expire) || 0;
    if (expire < Date.now()) {
      removeKeys(key);
      return {};
    }
  }
  return value.data;
}

/**
 * 获取缓存有效时长，单位：秒
 * @param {String} key 缓存的key
 * @param {Number} unit 0：毫秒，1：秒，2：分钟，默认毫秒值
 * @returns {Number} 有效时长
 */
export const getExpire = (key, unit) => {
  if (isEmpty(key)) return 0;
  key = keyPrefix + key;
  let value = uni.getStorageSync(key) || '';
  if (value.includes('data') && value.includes('expire')) {
    value = JSON.parse(value) || {};
    let expire = Number(value.expire || 0);
    if (unit === 1) return expire / 1000;
    if (unit === 2) return expire / 1000 / 60;
    return expire;
  }
  return 0;
}

/**
 * 给缓存设置过期时间
 * @param {String} key 缓存数据的key
 * @param {Number} expire 过期时长（单位：秒）
 */
export const setExpire = (key, expire) => {
  let value = getCache(key) || {};
  setCache(key, value, expire);
}

/**
 * 删除缓存数据
 * @param keys 删除缓存，多个key之间使用,隔开
 * @returns {Number} 删除条数
 */
export const removeKeys = (...keys) => {
  if (isEmpty(keys)) return 0;
  keys.forEach((key, index) => {
    key = keyPrefix + key;
    uni.removeStorageSync(key); // 同步删除
  });
  return keys.length;
}

/**
 * 清空所有缓存
 */
export const clearAll = () => {
  uni.clearStorageSync(); // 同步清除
}

数据加解密

我这里使用的使用非对称加密，根据个人项目需求可进行调整

加解密工具类：jsencryptUtil.js

import JSEncrypt from 'jsencrypt/bin/jsencrypt.min';
const encryptor = new JSEncrypt();
const publicKey = `-----BEGIN PUBLIC KEY-----
MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJtV6S0G6O9LpOVx/riiZzNk1gAl1ALg
CXvS1JPTluyIqr3eie4mqkVdFROjNpCxvtXkRtisB9PlmU9YOPTt8C8CAwEAAQ==
-----END PUBLIC KEY-----`;
const privateKey = `-----BEGIN RSA PRIVATE KEY-----
MIIBOgIBAAJBAJtV6S0G6O9LpOVx/riiZzNk1gAl1ALgCXvS1JPTluyIqr3eie4m
qkVdFROjNpCxvtXkRtisB9PlmU9YOPTt8C8CAwEAAQJABNYdbvX2nbC8vxoYBLal
wO9kTFfhLH++O9k6Hiop2k5wjbl7FlOBUr7iEeFxdYeuT0JcNyLVeGphKZAS9HlR
0QIhALWpLQaV/UFD/E3lTtkCd890Hn6noLKCOxMRcwtx22oxAiEA2ublehWoGwA5
F+GL9s7B9AgMOwzX0Z43F4fzCfAwCF8CIGYhR6QVPT2tKDLvAWY14f/q654PReQ2
HVo6DDDaAR5xAiEAgyFMGD0+7aXNjcO8D4Y944yqnvkLk/N+NydmbO6oJ2sCIAzn
bQCPl4yK81yVTdUA0fMKWRZn3vJ2C11AaemSs42C
-----END RSA PRIVATE KEY-----`;

/**
 * 使用公钥进行加密处理
 * @param {string} txt 明文字符串
 */
export function encrypt(txt) {
  // 设置公钥
  encryptor.setPublicKey(publicKey); 
  // 对数据进行加密
  return encryptor.encrypt(txt); 
}

/**
 * 使用私钥进行解密处理
 * @param {string} enc 密文字符串
 */
export function decrypt(enc) {
  // 设置私钥
  encryptor.setPrivateKey(privateKey);
  // 对数据进行解密
  return encryptor.decrypt(enc); 
}

完善缓存工具

const expiration = 1000 * 60 * 60 * 24 * 7; // 默认有效期7天
const keyPrefix = 'KEY_'; // 缓存key的统一前缀
import { isEmpty, isNumberStr, trimAllBlank } from './utils.js';
import { encrypt, decrypt } from './jsencryptUtil.js';

/**
 * 添加缓存
 * @param {String} key 缓存的key
 * @param {Object} val 缓存的val
 * @param {Number} expire 过期时间（单位：秒）
 * @param {Boolean} enc 是否需要加密处理：true | false
 * @returns {Boolean} 成功 | 失败
 */
export const setCache = (key, val, expire, enc) => {
  if (isEmpty(key)) return false;
  expire = expire && isNumberStr(expire) ? Number(trimAllBlank(expire)) : 0;
  expire = Date.now() + (expire <= 0 ? expiration : (expire * 1000));
  let param = JSON.stringify({
    data: val, // 缓存的数据
    expire: expire // 过期时间
  });
  if (enc === true) param = encrypt(param );
  key = keyPrefix + key; // 缓存的key
  uni.setStorageSync(key, param); // 同步缓存
  return true;
}

/**
 * 获取缓存的数据
 * @param {String} key 缓存key
 * @param {Boolean} dec 是否需要解密处理：true | false
 * @returns {Object}
 */
export const getCache = (key, dec) => {
  if (isEmpty(key)) return {};
  key = keyPrefix + key;
  let value = uni.getStorageSync(key) || '';
  if (dec === true) value = decrypt(value);
  if (value.includes('data') && value.includes('expire')) {
    value = JSON.parse(value) || {};
    let expire = value.expire || '';
    if (isEmpty(expire) || !isNumberStr(expire)) {
      return value.data || '';
    }
    expire = Number(expire) || 0;
    if (expire < Date.now()) {
      removeKeys(key);
      return {};
    }
  }
  return value.data;
}

/**
 * 删除缓存数据
 * @param keys 删除缓存，多个key之间使用,隔开
 * @returns {Number} 删除条数
 */
export const removeKeys = (...keys) => {
  if (isEmpty(keys)) return 0;
  keys.forEach((key, index) => {
    key = keyPrefix + key;
    uni.removeStorageSync(key); // 同步删除
  });
  return keys.length;
}

/**
 * 清空所有缓存
 */
export const clearAll = () => {
  uni.clearStorageSync(); // 同步清除
}

这样就可以对缓存的数据进行加密处理了

每次都要传入一个参数来确定是否需要加密或者解密处理，太繁琐了
能不能不需要我来传是否需要解密呢？根据加密参数进行判断？答案时可以的

接下来，我们先处理一下加解密工具，对于很长很长的明文数据进行加密时，加密工具会报错
下面对加密工具进行改造，改造完成之后，再来进一步完善缓存工具，不用每次都传入解密标志

加密太长报错

使用 JSEncrypt 加密数据时，对于比较长的字符串，加密时会出现异常报错，并提示数据太大

解决方法：需要对加密工具进行一次改造处理

修改加密工具

import JSEncrypt from 'jsencrypt/bin/jsencrypt.min';
const encryptor = new JSEncrypt();
const publicKey = `-----BEGIN PUBLIC KEY-----
MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJtV6S0G6O9LpOVx/riiZzNk1gAl1ALg
CXvS1JPTluyIqr3eie4mqkVdFROjNpCxvtXkRtisB9PlmU9YOPTt8C8CAwEAAQ==
-----END PUBLIC KEY-----`;
const privateKey = `-----BEGIN RSA PRIVATE KEY-----
MIIBOgIBAAJBAJtV6S0G6O9LpOVx/riiZzNk1gAl1ALgCXvS1JPTluyIqr3eie4m
qkVdFROjNpCxvtXkRtisB9PlmU9YOPTt8C8CAwEAAQJABNYdbvX2nbC8vxoYBLal
wO9kTFfhLH++O9k6Hiop2k5wjbl7FlOBUr7iEeFxdYeuT0JcNyLVeGphKZAS9HlR
0QIhALWpLQaV/UFD/E3lTtkCd890Hn6noLKCOxMRcwtx22oxAiEA2ublehWoGwA5
F+GL9s7B9AgMOwzX0Z43F4fzCfAwCF8CIGYhR6QVPT2tKDLvAWY14f/q654PReQ2
HVo6DDDaAR5xAiEAgyFMGD0+7aXNjcO8D4Y944yqnvkLk/N+NydmbO6oJ2sCIAzn
bQCPl4yK81yVTdUA0fMKWRZn3vJ2C11AaemSs42C
-----END RSA PRIVATE KEY-----`;

/**
 * 使用公钥进行加密处理
 * @param {string} txt 明文字符串
 */
export function encrypt(txt) {
  encryptor.setPublicKey(publicKey); // 设置公钥
  if (txt.length > 100) {
    let result = "";
    while (txt && txt.length > 0) {
      let dl = txt.slice(0, 100);
      txt = txt.slice(100);
      if (!result) {
        result = result + encryptor.encrypt(dl);
      } else {
        result = result + "~" + encryptor.encrypt(dl);
      }
    }
    return result;
  }
  return encryptor.encrypt(txt); // 对数据进行加密
}

/**
 * 使用私钥进行解密处理
 * @param {string} enc 密文字符串
 */
export function decrypt(enc) {
  // 设置私钥
  encryptor.setPrivateKey(privateKey);
  if (enc.includes("~")) {
    let result = "";
    let arr = enc.split("~");
    for (let i = 0; i < arr.length; i++) {
      if (arr[i] && arr[i].length > 0) {
        result = result + encryptor.decrypt(arr[i]);
      }
    }
    return result;
  }
  return encryptor.decrypt(enc);
}

改造缓存工具

const expiration = 1000 * 60 * 60 * 24 * 7; // 默认有效期7天
const keyPrefix = 'KEY_'; // 缓存key的统一前缀
import { isEmpty, isNumberStr, trimAllBlank } from './util.js';
import { encrypt, decrypt } from './jsencryptUtil.js';

/**
 * 添加缓存
 * @param {String} key 缓存的key
 * @param {Object} val 缓存的val
 * @param {Number} expire 过期时间（单位：秒）
 * @param {Boolean} enc 是否需要加密处理：true | false
 * @returns {Boolean} 成功 | 失败
 */
export const setCache = (key, val, expire, enc) => {
  if (isEmpty(key)) return false;
  expire = expire && isNumberStr(expire) ? Number(trimAllBlank(expire)) : 0;
  expire = Date.now() + (expire <= 0 ? expiration : (expire * 1000));
  enc = enc === true;
  let param = JSON.stringify({
    data: (enc ? encrypt(val) : val), // 缓存的数据
    encrypt: enc, // 数据加密标志
    expire: expire // 过期时间
  });
  key = keyPrefix + key; // 缓存的key
  uni.setStorageSync(key, param); // 同步缓存
  return true;
}

/**
 * 获取缓存的数据
 * @param {String} key 缓存key
 * @returns {Object}
 */
export const getCache = (key) => {
  if (isEmpty(key)) return {};
  key = keyPrefix + key;
  let value = uni.getStorageSync(key) || '';
  if (value.includes('data') && value.includes('expire')) {
    value = JSON.parse(value) || {};
    let expire = value.expire || '';
    let dec = value.encrypt == true;
    if (dec) value.data = decrypt(value.data);
    if (isEmpty(expire) || !isNumberStr(expire)) {
      return value.data || '';
    }
    expire = Number(expire) || 0;
    if (expire < Date.now()) {
      removeKeys(key);
      return {};
    }
  }
  return value;
}

/**
 * 删除缓存数据
 * @param keys 删除缓存，多个key之间使用,隔开
 * @returns {Number} 删除条数
 */
export const removeKeys = (...keys) => {
  if (isEmpty(keys)) return 0;
  keys.forEach((key, index) => {
    key = keyPrefix + key;
    uni.removeStorageSync(key); // 同步删除
  });
  return keys.length;
}

/**
 * 清空所有缓存
 */
export const clearAll = () => {
  uni.clearStorageSync(); // 同步清除
}

到此，缓存工具就完成了，只要在缓存时传入是否需要加密的参数就可以了，解密时只需要传入key就可以了，不需要再额外传入解密参数

最终完整代码

util工具

util.js

/**
 * 判断数据是否为空
 * @param {*} input 原数据
 * @return {Boolean}
 */
export const isEmpty = (input) => {
  if (Object.prototype.toString.call(input) === '[object Object]') {
    let vals = Object.values(input) || [];
    let num = 0;
    for (let val of vals) {
      val = (!val ? '' : JSON.stringify(val)).trim().replace(/\s*/g, "");
      num = !val ? num + 1 : num;
    }
    return vals.length === num;
  }
  if (typeof input !== 'string') input = (!input ? '' : JSON.stringify(input)).trim().replace(/\s*/g, "");
  return !input || input.length === 0 || (['[]', '{}', 'NaN', 'null', 'undefined'].includes(input));
}

/**
 * 去除特殊字符，包括但不限于空格、制表符\t、换行符\r、回车符\n
 * @param {string} input 原数据
 * @return {string}
 */
export const trimAllBlank = (input) => {
  input = typeof input === 'string' ? input.trim() : JSON.stringify(input);
  return (input || '').replace(/\s*/g, "");
}

/**
 * 是否数字
 * @param {string} str 字符串
 * @returns {boolean}
 */
export const isNumberStr = (str) => {
  str = isEmpty(str) ? '' : str;
  return /^[+-]?(0|([1-9]\d*))(\.\d+)?$/g.test(str);
}

加密工具

jsencryptUtil.js

import JSEncrypt from 'jsencrypt/bin/jsencrypt.min';
const publicKey = `-----BEGIN PUBLIC KEY-----
MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJtV6S0G6O9LpOVx/riiZzNk1gAl1ALg
CXvS1JPTluyIqr3eie4mqkVdFROjNpCxvtXkRtisB9PlmU9YOPTt8C8CAwEAAQ==
-----END PUBLIC KEY-----`;
const privateKey = `-----BEGIN RSA PRIVATE KEY-----
MIIBOgIBAAJBAJtV6S0G6O9LpOVx/riiZzNk1gAl1ALgCXvS1JPTluyIqr3eie4m
qkVdFROjNpCxvtXkRtisB9PlmU9YOPTt8C8CAwEAAQJABNYdbvX2nbC8vxoYBLal
wO9kTFfhLH++O9k6Hiop2k5wjbl7FlOBUr7iEeFxdYeuT0JcNyLVeGphKZAS9HlR
0QIhALWpLQaV/UFD/E3lTtkCd890Hn6noLKCOxMRcwtx22oxAiEA2ublehWoGwA5
F+GL9s7B9AgMOwzX0Z43F4fzCfAwCF8CIGYhR6QVPT2tKDLvAWY14f/q654PReQ2
HVo6DDDaAR5xAiEAgyFMGD0+7aXNjcO8D4Y944yqnvkLk/N+NydmbO6oJ2sCIAzn
bQCPl4yK81yVTdUA0fMKWRZn3vJ2C11AaemSs42C
-----END RSA PRIVATE KEY-----`;

/**
 * 使用公钥进行加密处理
 * @param {string} txt 明文字符串
 */
export function encrypt(txt) {
  const encryptor = new JSEncrypt();
  encryptor.setPublicKey(publicKey); // 设置公钥
  if (txt.length > 100) {
    let result = "";
    while (txt && txt.length > 0) {
      let dl = txt.slice(0, 100);
      txt = txt.slice(100);
      if (!result) {
        result = result + encryptor.encrypt(dl);
      } else {
        result = result + "~" + encryptor.encrypt(dl);
      }
    }
    return result;
  }
  return encryptor.encrypt(txt); // 对数据进行加密
}

/**
 * 使用私钥进行解密处理
 * @param {string} enc 密文字符串
 */
export function decrypt(enc) {
  const encryptor = new JSEncrypt();
  encryptor.setPrivateKey(privateKey);
  if (enc.includes("~")) {
    let result = "";
    let arr = enc.split("~");
    for (let i = 0; i < arr.length; i++) {
      if (arr[i] && arr[i].length > 0) {
        result = result + encryptor.decrypt(arr[i]);
      }
    }
    return result;
  }
  return encryptor.decrypt(enc);
}

缓存工具

cacheUtil.js

const expiration = 1000 * 60 * 60 * 24 * 7; // 默认有效期7天
const keyPrefix = 'KEY_'; // 缓存key的统一前缀
import { isEmpty, isNumberStr, trimAllBlank } from './util.js';
import { encrypt, decrypt } from './jsencryptUtil.js';

/**
 * 添加缓存
 * @param {String} key 缓存的key
 * @param {Object} val 缓存的val
 * @param {Number} expire 过期时间（单位：秒）
 * @param {Boolean} enc 是否需要加密处理：true | false
 * @returns {Boolean} 成功 | 失败
 */
export const setCache = (key, val, expire, enc) => {
  if (isEmpty(key)) return false;
  expire = expire && isNumberStr(expire) ? Number(trimAllBlank(expire)) : 0;
  expire = Date.now() + (expire <= 0 ? expiration : (expire * 1000));
  enc = enc === true;
  let param = JSON.stringify({
    data: (enc ? encrypt(val) : val), // 缓存的数据
    encrypt: enc, // 数据加密标志
    expire: expire // 过期时间
  });
  key = keyPrefix + key; // 缓存的key
  uni.setStorageSync(key, param); // 同步缓存
  return true;
}

/**
 * 获取缓存的数据
 * @param {String} key 缓存key
 * @returns {Object}
 */
export const getCache = (key) => {
  if (isEmpty(key)) return {};
  key = keyPrefix + key;
  let value = uni.getStorageSync(key) || '';
  if (value.includes('data') && value.includes('expire')) {
    value = JSON.parse(value) || {};
    let expire = value.expire || '';
    let dec = value.encrypt == true;
    if (dec) value.data = decrypt(value.data);
    if (isEmpty(expire) || !isNumberStr(expire)) {
      return value.data || '';
    }
    expire = Number(expire) || 0;
    if (expire < Date.now()) {
      removeKeys(key);
      return {};
    }
  }
  return value;
}

/**
 * 获取缓存有效时长，单位：秒
 * @param {String} key 缓存的key
 * @param {Number} unit ms：毫秒，s：秒，m：分钟，默认毫秒值
 * @returns {Number} 有效时长
 */
export const getExpire = (key, unit) => {
  if (isEmpty(key)) return 0;
  key = keyPrefix + key;
  let value = uni.getStorageSync(key) || '';
  if (value.includes('data') && value.includes('expire')) {
    value = JSON.parse(value) || {};
    let expire = Number(value.expire || 0);
    unit = unit.toLowerCase();
    if (unit === "s") return expire / 1000;
    if (unit === "m") return expire / 1000 / 60;
    return expire;
  }
  return 0;
}

/**
 * 给缓存设置过期时间
 * @param {String} key 缓存数据的key
 * @param {Number} expire 过期时长（单位：秒）
 */
export const setExpire = (key, expire) => {
  let value = getCache(key) || {};
  setCache(key, value, expire);
}

/**
 * 删除缓存数据
 * @param keys 删除缓存，多个key之间使用,隔开
 * @returns {Number} 删除条数
 */
export const removeKeys = (...keys) => {
  if (isEmpty(keys)) return 0;
  keys.forEach((key, index) => {
    key = keyPrefix + key;
    uni.removeStorageSync(key); // 同步删除
  });
  return keys.length;
}

/**
 * 清空所有缓存
 */
export const clearAll = () => {
  uni.clearStorageSync(); // 同步清除
}

其他语言改造

vue：vue中使用时，需要将 uni.xxxStorage(...) 替换为localStorage 或者 sessionStorage
html5：和 vue 一样，需要将 uni.xxxStorage(...) 替换为localStorage 或者 sessionStorage
微信小程序：需要将 uni.xxxStorage(...) 替换为 wx.xxxStorage(...)

localStorage和sessionStorage的区别：
sessionStorage：只在本次会话有效，关闭浏览器数据将被删除
localStorage：如果不手动删除，则长期有效，关闭浏览器数据也不会被清除

转载请注明出处或者链接地址：https://www.qianduange.cn//article/4259.html
标签
微信小程序es6LRU缓存策略
上一篇：HTML基本结构及基本标签
评论
相关文章

前端哥

前端哥

发布的文章

vue2中，如何在router.beforeEach里，等待父页面消息传递

2024-04-19 10:04:51

vue2中，父项目A通过iframe嵌入子项目B的页面（该页面是http://192.168.41.35:9527/#/energyStorage/energyStorageMonitor），代码中先设置src为http://192.168.41.35:9527/导致浏览器插入了一条记录跳转到子项目的首页，然后父项目向子项目发送切换路由消息，子项目监听到到该消息才跳转到该页面。所以导致在该页面点击浏览器返回会回到子项目的首页，如何使得点击返回的跳转顺序正确

2024-04-19 09:04:17

AI代码生成如何实现，写出前后端代码

2024-04-19 09:04:24

AI代码生成如何实现

2024-04-19 09:04:33

访问https://www.qianduange.cn/的内容

2024-04-19 09:04:56

有个接口https://www.qianduange.cn/api.php/provide/openai，拿到这个接口的源码

2024-04-19 09:04:50

假设页面B、C是无法获取页面A的地址，浏览器从页面A跳转到了页面B后又跳转到了页面C，如何删除浏览器跳转页面B的history，使得在页面C点击返回按钮可以直接回到A，并且再点击返回按照之前跳转的顺序返回

2024-04-19 09:04:39

假设页面B、C是iframe嵌入的页面，浏览器从页面A跳转到了页面B后又跳转到了页面C，如何删除浏览器跳转页面B的history，使得在页面C点击返回按钮可以直接回到A，并且再点击返回按照之前跳转的顺序返回

2024-04-19 09:04:41

浏览器从页面A跳转到了页面B后又跳转到了页面C，如何删除浏览器跳转页面B的history，使得在页面C点击返回按钮可以直接回到A，并且再点击返回按照之前跳转的顺序返回

2024-04-19 09:04:51

浏览器从页面A跳转到了页面B后又跳转到了页面C，如何删除浏览器跳转页面B的history，使得在页面C点击返回按钮可以直接回到A

2024-04-19 09:04:22

大家推荐的文章
1

js数组常用方法（19种）|你会的到底有多少呢？

2024-04-08 11:04:211000
2

【Echarts系列】—— 实现电池图、3D立体圆形柱状图

2024-03-03 11:03:011000
3

ECharts 饼状图颜色设置

2024-02-16 14:02:001000
4

echarts实现动态渲染多柱图

2024-02-12 14:02:341000
5

移动端css布局大全

2024-02-06 15:02:421000
6

使用HTML5和JS实现日期下拉框功能

2024-02-04 11:02:521000
7

JS生成条形码JsBarcode.all.js，转成图片canvas2image.js，并打印二维码jQuery.print.js

2024-01-27 01:01:181000
8

vue实现可输入可下拉选择的组件

2024-04-05 09:04:35999
9

echarts 图表，定时器实现数据实时动态

2024-03-13 00:03:28999
10

jQuery事件处理

2024-03-12 01:03:32999

rss订阅 百度xml 谷歌xml 搜狗xml soxml 神马搜索xml 网站地图

Copyright © 2018-2022 前端哥 陕ICP备2023000550号-1 前端哥

讲个笑话：程序员心理活动：看别人的代码，这都写得什么玩意儿，垃圾！！看自己一个月前的代码：这TM谁写得代码，垃圾！再一看，这代码怎么这么眼熟？我自己写得？仔细一看，卧槽！还TM的真是我自己写的！！

前端技术交流源码工具分享网站

会员中心 联系我 留言建议 回顶部
复制成功！