javascript中本地存储localStorage，sessionStorage，cookie，indexDB的用法与使用场景汇总_Javascript

在javascript中，本地存储是一种在用户的浏览器上存储数据的方式，它允许网页在不与服务器进行额外数据传输的情况下保留跨会话信息。主要有三种本地存储方式：sessionstorage、localstorage、cookie与indexdb。

javascript有4种数据存储方式，分别是：

sessionstorage
localstorage
cookier
indexdb

一. javascript本地存储之 sessionstorage

sessionstorage仅在当前会话下有效，关闭页面或浏览器后被清除，也就是说sessionstorage只存在于窗口(页面)活跃期，一旦窗口关闭，sessionstorage将会删除数据。

sessionstorage的方法有以下几个

setitem(key,value) 设置数据
getitem(key) 获取数据
removeitem(key) 移除数据
clear() 清除所有值

sessionstorage实例：

// 添加数据
window.sessionstorage.setitem("name","李四")
window.sessionstorage.setitem("age",18)

// 获取数据
console.log(window.sessionstorage.getitem("name")) // 李四

// 清除某个数据
window.sessionstorage.removeitem("gender")

// 清空所有数据
window.sessionstorage.clear()

二. javascript本地存储之 localstorage

localstorage是html5中引入的技术，用于在用户的浏览器上长期存储数据，直到用户手动删除。与sessionstorage类似，但localstorage存储的数据没有过期时间。它同样提供了setitem、getitem、removeitem和clear方法来操作数据。

localstorage的方法有以下几个

setitem(key,value) 设置数据
getitem(key) 获取数据
removeitem(key) 移除数据
clear() 清除所有值

// 存储数据
localstorage.setitem("name", "张三");
localstorage.setitem("age", 20);
localstorage.setitem("gender", "男");

// 获取数据
console.log(localstorage.getitem("name")); // 输出: 张三

// 删除数据
localstorage.removeitem("gender");

// 清除所有数据
localstorage.clear();

localstorage还可以通过添加时间戳和过期时间来手动设置数据的失效时间。由于localstorage只能存储字符串，因此在存储对象时需要将其转换为json字符串，并在读取时解析。

storage.prototype.setexpire = (key, value, expire) => {
	let obj = {
	data: value,
	time: date.now(),
	expire: expire
	};
	//localstorage 设置的值不能为对象,转为json字符串
	localstorage.setitem(key, json.stringify(obj));
}

storage.prototype.getexpire = key => {
    let val = localstorage.getitem(key);
    if (!val) {
        return val;
    }
    val = json.parse(val);
    if (date.now() - val.time > val.expire) {
        localstorage.removeitem(key);
        return null;
    }
    return val.data;
}

//使用方法
localstorage.setexpire('userid','zhangsan',5000);
window.setinterval(()=>{
    console.log(localstorage.getexpire("userid"));
},1000)

总结
持久化存储，就算窗口关闭也依然保留，除非手动删除
页面刷新数据不丢失
存储范围一般不超过5m
同一浏览器支持多窗口（多页面）共享
假设同一个浏览器打开同源的三个页面，.com/a.html;.com/b.html;**.com/c.html;那么这三个窗口是可以共享localstorage的
以键值对的形式保存
以localstorage.setitem(key,valuestr)保存值，valuestr必须是字符串,要存储对象必须先字符串序列化，通过json.stringify()，取值的时候在通过json.parse()还原
以键取值
以value=localstorage.getitem(key)获取值,如果不存在，返回null
受同源策略的限制
不同源的页面不能访问localstorage.比如在浏览器里面打开www.baidu.com/index.html存储了一个localstorage;同样在浏览器里面打开的www.ali.com/index.html就无法访问到。因为他两不同源
操作localstorage时，会触发非当前页面的storage事件
我们在a页面设置了localstorage,就会触发其他页面的storage事件，这样方便我们监听storage的状态，做出后续的响应。比如在登录页完成登录，把登录成功的标志logsuc存储在localstorage里面,localstorage.setitem(‘logsuc’,true);然后个人中心页面就可以通过storage事件判断出已经登录，并读取个人信息进行预加载
支持单个删除和全部删除，分别通过removeitem(key)和clear()方法实现

三. javascript本地存储之 cookie

cookie 是一些数据, 存储于你电脑上的文本文件中，用于存储 web 页面的用户信息
cookie 数据是以键值对的形式存在的，每个键值对都有过期时间。如果不设置时间，浏览器关闭，cookie就会消失，当然用户也可以手动清除cookie
cookie每次都会携带在http头中，如果使用cookie保存过多数据会带来性能问题
cookie内存大小受限，一般每个域名下是4k左右，每个域名大概能存储50个键值对

通过访问document.cookie可以对cookie进行创建，修改与获取。默认情况下，cookie 在浏览器关闭时删除，你还可以为 cookie的某个键值对添加一个过期时间，如果设置新的cookie时，某个key已经存在，则会更新这个key对应的值，否则他们会同时存在cookie中

// 设置cookie
document.cookie = "username=orochiz"
document.cookie = "age=20"

// 读取cookie
var msg = document.cookie
console.log(msg) // username=orochiz; age=20

// 添加过期时间（单位：天）
var d = new date() // 当前时间 2019-9-25
var days = 3       // 3天
d.setdate(d.getdate() + days)
document.cookie = "username=orochiz;"+"expires="+d

// 删除cookie （给某个键值对设置过期的时间）
d.setdate(d.getdate() - 1)
console.log(document.cookie)

四. javascript本地存储之 indexdb

前面讲的存储方式都是以字符串的形式在存储，假设我们现在的需求是要存储大量结构化的数据怎么办，那就用indexdb
这是一个正儿八经的数据库，做服务端的同学都了解数据库，这个跟数据库没啥的区别。只不过人家存在于客户端而已。
那既然这样，说明人家优点很多，包括以下几点
储存量理论上没有上限
所有操作都是异步的，相⽐ localstorage 同步操作性能更⾼，尤其是数据量较⼤时
原⽣⽀持储存 js 的对象
是个正经的数据库，意味着数据库能⼲的事它都能⼲-那他具体怎么操作呢，都说了人家是数据库，那就按数据库的一般操作流程来呗
建立连接打开数据库，操作数据库增删改查，只不过可能为了更好地使用客户端，可能某些步骤或者程序上做了一些微调，那我们就实地操作一个

class dbopration{
        constructor() {
            this.db = null
        }
        gettype(val) {
            let type = typeof val == 'object'
            return type
        }
        // 打开数据库
        open(parm) {
            return new promise((res, rej) => {
                let request = window.indexeddb.open(parm.dbname, parm.versions)
                request.onerror = function(event) {
                    console.log(event)
                    // 错误处理
                    rej()
                    console.log(' 打开数据库报错')
                }
                request.onsuccess = event => {
                    this.db = request.result
                    console.log('打开数据库成功')
                    res()
                    // 成功处理
                }
                // 数据库更新时的回调
                request.onupgradeneeded = event => {
                    this.db = event.target.result
                    this.createddb(parm)
                }
            })
        }
        // 创建库表
        createddb(parm) {
            console.log(parm)

            if (!this.db.objectstorenames.contains(parm.objname)) {
                this.db.createobjectstore(parm.objname, {
                    keypath: 'id'
                })
                // objectstore.createindex("data", "data", { unique: false });
                // unique name可能会重复
            }
        }
        // 新增（不需要使用）
        async add(parm = { dbname, objname, param, response }) {
            await this.open(parm)
            // await this.upgrade(dbname);
            return new promise((res, rej) => {
                let type = this.gettype(parm.param)
                let type1 = this.gettype(parm.response)
                let transaction = this.db.transaction([parm.objname], 'readwrite')
                let objectstore = transaction.objectstore(parm.objname)

                // 用户读取数据，参数是主键
                let request = objectstore.add({
                    id: type ? json.stringify(parm.param) : parm.param,
                    data: type1 ? json.stringify(parm.response) : parm.response
                })
                console.log(request)

                request.onsuccess = function(event) {
                    res(event)
                    console.log('数据写入成功')
                }

                request.onerror = function(event) {
                    rej()
                    console.log('数据写入失败')
                }
            })
        }
        // 读取库表数据
        async read(parm = { dbname, objname, param, response }) {
            await this.open(parm)

            return new promise((res, rej) => {
                let type = this.gettype(parm.param)

                var transaction = this.db.transaction([parm.objname])
                var objectstore = transaction.objectstore(parm.objname)
                // 用户读取数据，参数是主键
                var request = objectstore.get(type ? json.stringify(parm.param) : parm.param)

                request.onerror = function(event) {
                    console.log('事务失败')
                    rej()
                }

                request.onsuccess = function(event) {
                    if (request.result) {
                        let data = json.parse(request.result.data)
                        res(data)
                    } else {
                        res(request.result)
                        console.log('未获得数据记录')
                    }
                }
            })
        }
        // 修改库表数据,但是因为创建数据库时直接创建了库表,所以无论是添加还是修改都掉这个就可以了.
        async update(parm = { dbname, objname, param, response }) {
            await this.open(parm)

            return new promise((res, rej) => {
                let type = this.gettype(parm.param)
                let type1 = this.gettype(parm.response)

                console.log(parm)
                var request = this.db
                    .transaction([parm.objname], 'readwrite')
                    .objectstore(parm.objname)
                    .put({
                        id: type ? json.stringify(parm.param) : parm.param,
                        data: type1 ? json.stringify(parm.response) : parm.response
                    })

                request.onsuccess = function(event) {
                    res()
                    console.log('数据更新成功')
                }

                request.onerror = function(event) {
                    rej()
                    console.log('数据更新失败')
                }
            })
        }
        // 删除某个表的数据
        async remove(parm = { dbname, objname, param, response }) {
            await this.open(parm)

            return new promise((res, rej) => {
                let type = this.gettype(parm.param)

                var request = this.db
                    .transaction([parm.objname], 'readwrite')
                    .objectstore(parm.objname)
                    .delete(type ? json.stringify(parm.param) : parm.param)

                request.onsuccess = function(event) {
                    res()
                    console.log('数据删除成功')
                }
            })
        }
    }
let db=new dbopration()//创建数据库实例
//接下来增删改查调取对应的方法就行