react-native-storage(數據持久化存儲)文檔介紹

中文doc:僅供參考 import Storage from 'react-native-storage'; import {AsyncStorage} from 'react-native';

var storage = new Storage({
    // 最大容量，默認值1000條數據循環存儲
    size: 1000,

    // 存儲引擎：對於RN使用AsyncStorage，對於web使用window.localStorage
    // 若是不指定則數據只會保存在內存中，重啓後即丟失
    storageBackend: AsyncStorage,

    // 數據過時時間，默認一成天（1000 * 3600 * 24 毫秒），設爲null則永不過時
    defaultExpires: 1000 * 3600 * 24,

    // 讀寫時在內存中緩存數據。默認啓用。
    enableCache: true,

    // 若是storage中沒有相應數據，或數據已過時，
    // 則會調用相應的sync方法，無縫返回最新數據。
    // sync方法的具體說明會在後文提到
    // 你能夠在構造函數這裏就寫好sync的方法
    // 或是在任什麼時候候，直接對storage.sync進行賦值修改
    // 或是寫到另外一個文件裏，這裏require引入
    // sync: require('你能夠另外寫一個文件專門處理sync')

})

// 最好在全局範圍內建立一個（且只有一個）storage實例，方便直接調用

// 對於web
// window.storage = storage;

// 對於react native
// global.storage = storage;

// 這樣，在此**以後**的任意位置便可以直接調用storage
// 注意：全局變量必定是先聲明，後使用
// 若是你在某處調用storage報錯未定義
// 請檢查global.storage = storage語句是否確實已經執行過了

// 使用key來保存數據。這些數據通常是全局獨有的，經常須要調用的。
// 除非你手動移除，這些數據會被永久保存，並且默認不會過時。
storage.save({
    key: 'loginState',  // 注意:請不要在key中使用_下劃線符號!
    data: {
        from: 'some other site',
        userid: 'some userid',
        token: 'some token'
    },

    // 若是不指定過時時間，則會使用defaultExpires參數
    // 若是設爲null，則永不過時
    expires: 1000 * 3600
});

// 讀取
storage.load({
    key: 'loginState',

    // autoSync(默認爲true)意味着在沒有找到數據或數據過時時自動調用相應的sync方法
    autoSync: true,

    // syncInBackground(默認爲true)意味着若是數據過時，
    // 在調用sync方法的同時先返回已通過期的數據。
    // 設置爲false的話，則等待sync方法提供的最新數據(固然會須要更多時間)。
    syncInBackground: true,

    // 你還能夠給sync方法傳遞額外的參數
    syncParams: {
        extraFetchOptions: {
            // 各類參數
        },
        someFlag: true,
    },
}).then(ret => {
    // 若是找到數據，則在then方法中返回
    // 注意：這是異步返回的結果（不瞭解異步請自行搜索學習）
    // 你只能在then這個方法內繼續處理ret數據
    // 而不能在then之外處理
    // 也沒有辦法「變成」同步返回
    // 你也可使用「看似」同步的async/await語法

    console.log(ret.userid);
    this.setState({user: ret});
}).catch(err => {
    //若是沒有找到數據且沒有sync方法，
    //或者有其餘異常，則在catch中返回
    console.warn(err.message);
    switch (err.name) {
        case 'NotFoundError':
            // TODO;
            break;
        case 'ExpiredError':
            // TODO
            break;
    }
})


// 使用key和id來保存數據，通常是保存同類別（key）的大量數據。
// 全部這些"key-id"數據共有一個保存上限（不管是否相同key）
// 即在初始化storage時傳入的size參數。
// 在默認上限參數下，第1001個數據會覆蓋第1個數據。
// 覆蓋以後，再讀取第1個數據，會返回catch或是相應的sync方法。
var userA = {
    name: 'A',
    age: 20,
    tags: [
        'geek',
        'nerd',
        'otaku'
    ]
};

storage.save({
    key: 'user',  // 注意:請不要在key中使用_下劃線符號!
    id: '1001',   // 注意:請不要在id中使用_下劃線符號!
    data: userA,
    expires: 1000 * 60
});

//load 讀取
storage.load({
    key: 'user',
    id: '1001'
}).then(ret => {
    // 若是找到數據，則在then方法中返回
    console.log(ret.userid);
}).catch(err => {
    // 若是沒有找到數據且沒有sync方法，
    // 或者有其餘異常，則在catch中返回
    console.warn(err.message);
    switch (err.name) {
        case 'NotFoundError':
            // TODO;
            break;
        case 'ExpiredError':
            // TODO
            break;
    }
})

// --------------------------------------------------

// 獲取某個key下的全部id
storage.getIdsForKey('user').then(ids => {
    console.log(ids);
});

// 獲取某個key下的全部數據
storage.getAllDataForKey('user').then(users => {
    console.log(users);
});

// !! 清除某個key下的全部數據
storage.clearMapForKey('user');

// --------------------------------------------------

// 刪除單個數據
storage.remove({
    key: 'lastPage'
});
storage.remove({
    key: 'user',
    id: '1001'
});

// !! 清空map，移除全部"key-id"數據（但會保留只有key的數據）
storage.clearMap();


//同步遠程數據（刷新）
storage.sync = {
    // sync方法的名字必須和所存數據的key徹底相同
    // 方法接受的參數爲一整個object，全部參數從object中解構取出
    // 這裏可使用promise。或是使用普通回調函數，但須要調用resolve或reject。
    user(params){
        let {id, resolve, reject, syncParams: {extraFetchOptions, someFlag}} = params;
        fetch('user/', {
            method: 'GET',
            body: 'id=' + id,
            ...extraFetchOptions,
        }).then(response => {
            return response.json();
        }).then(json => {
            //console.log(json);
            if (json && json.user) {
                storage.save({
                    key: 'user',
                    id,
                    data: json.user
                });

                if (someFlag) {
                    // 根據syncParams中的額外參數作對應處理
                }

                // 成功則調用resolve
                resolve && resolve(json.user);
            }
            else {
                // 失敗則調用reject
                reject && reject(new Error('data parse error'));
            }
        }).catch(err => {
            console.warn(err);
            reject && reject(err);
        });
    }


}


//有了上面這個sync方法，之後再調用storage.load時，若是本地並無存儲相應的user，那麼會自動觸發storage.sync.user去遠程取回數據並沒有縫返回。

storage.load({
    key: 'user',
    id: '1002'
}).then()

//讀取批量數據

// 使用和load方法同樣的參數讀取批量數據，可是參數是以數組的方式提供。
// 會在須要時分別調用相應的sync方法，最後統一返回一個有序數組。
storage.getBatchData([
    {key: 'loginState'},
    {key: 'checkPoint', syncInBackground: false},
    {key: 'balance'},
    {key: 'user', id: '1009'}
])
    .then(results => {
        results.forEach(result => {
            console.log(result);
        })
    })

//根據key和一個id數組來讀取批量數據
storage.getBatchDataWithIds({
    key: 'user',
    ids: ['1001', '1002', '1003']
})
    .then()


/*
 這兩個方法除了參數形式不一樣，還有個值得注意的差別。getBatchData會在數據缺失時挨個調用不一樣的sync方法(由於key不一樣)。
 可是getBatchDataWithIds卻會把缺失的數據統計起來，將它們的id收集到一個數組中，而後一次傳遞給對應的sync方法(避免挨個查詢致使同時發起大量請求)，
 因此你須要在服務端實現經過數組來查詢返回，還要注意對應的sync方法的參數處理（由於id參數多是一個字符串，也多是一個數組的字符串）。
 */
複製代碼