鸿蒙开发时，如何管理应用的本地存储，如保存和读取数据？

import { BusinessError } from '@ohos.base';
import { preferences } from '@ohos.data.preferences';

// 定义存储文件名和模式
const PREFERENCES_NAME = 'myAppSettings';
const MODE = preferences.Preferences.MODE_PRIVATE;

// 获取 Preferences 实例
let pref: preferences.Preferences | null = null;
try {
  preferences.getPreferences(this.context, PREFERENCES_NAME, MODE)
    .then((result: preferences.Preferences) => {
      pref = result;
      console.log('Preferences initialized');
    }).catch((err: BusinessError) => {
      console.error(`Failed to init preferences: ${err.code}, ${err.message}`);
    });
} catch (err) {
  console.error(`Exception: ${err.code}, ${err.message}`);
}

async function saveData(key: string, value: preferences.ValueType) {
  if (!pref) return;
  try {
    await pref.put(key, value);  // 支持 string | number | boolean
    await pref.flush();          // 确保数据持久化
    console.log('Data saved');
  } catch (err) {
    console.error(`Save failed: ${err.code}, ${err.message}`);
  }
}

// 示例：保存用户主题偏好
saveData('theme_mode', 'dark');

async function loadData(key: string, defaultValue: preferences.ValueType) {
  if (!pref) return defaultValue;
  try {
    const value = await pref.get(key, defaultValue);
    console.log(`Loaded data: ${value}`);
    return value;
  } catch (err) {
    console.error(`Load failed: ${err.code}, ${err.message}`);
    return defaultValue;
  }
}

// 示例：读取主题设置
const theme = await loadData('theme_mode', 'light');

import { relationalStore } from '@ohos.data.relationalStore';

// 定义表结构
const SQL_CREATE_TABLE = `
  CREATE TABLE IF NOT EXISTS user (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    age INTEGER,
    email TEXT UNIQUE
  )`;

// 配置数据库参数
const config: relationalStore.StoreConfig = {
  name: 'myAppDB',  // 数据库名
  securityLevel: relationalStore.SecurityLevel.S1  // 安全级别
};

let rdbStore: relationalStore.RdbStore | null = null;

async function initRDB() {
  try {
    rdbStore = await relationalStore.getRdbStore(this.context, config);
    await rdbStore.executeSql(SQL_CREATE_TABLE);
    console.log('RDB initialized');
  } catch (err) {
    console.error(`RDB init failed: ${err.code}, ${err.message}`);
  }
}

async function insertUser(user: { name: string, age: number, email: string }) {
  if (!rdbStore) return;
  const valueBucket: relationalStore.ValuesBucket = {
    'name': user.name,
    'age': user.age,
    'email': user.email
  };
  try {
    const rowId = await rdbStore.insert('user', valueBucket);
    console.log(`Inserted row ID: ${rowId}`);
  } catch (err) {
    console.error(`Insert failed: ${err.code}, ${err.message}`);
  }
}

import { ResultSet } from '@ohos.data.resultSet';

async function queryUsers() {
  if (!rdbStore) return [];
  const columns = ['id', 'name', 'age', 'email'];
  const predicates = new relationalStore.RdbPredicates('user');
  predicates.orderByAsc('age');  // 按年龄升序

  try {
    const resultSet: ResultSet = await rdbStore.query(predicates, columns);
    const users = [];
    while (resultSet.goToNextRow()) {
      users.push({
        id: resultSet.getLong(resultSet.getColumnIndex('id')),
        name: resultSet.getString(resultSet.getColumnIndex('name')),
        age: resultSet.getLong(resultSet.getColumnIndex('age')),
        email: resultSet.getString(resultSet.getColumnIndex('email'))
      });
    }
    resultSet.close();
    return users;
  } catch (err) {
    console.error(`Query failed: ${err.code}, ${err.message}`);
    return [];
  }
}

import { fileio } from '@ohos.fileio';
import { BusinessError } from '@ohos.base';

async function writeFile(content: string) {
  const dir = this.context.filesDir;  // 应用沙箱目录
  const path = `${dir}/user_data.txt`;
  try {
    const fd = await fileio.open(path, fileio.O_RDWR | fileio.O_CREAT);
    await fileio.write(fd, content);
    await fileio.close(fd);
    console.log('File saved');
  } catch (err) {
    console.error(`File write error: ${(err as BusinessError).code}`);
  }
}

async function readFile() {
  const path = `${this.context.filesDir}/user_data.txt`;
  try {
    const fd = await fileio.open(path, fileio.O_RDONLY);
    const stat = await fileio.stat(path);
    const buffer = new ArrayBuffer(stat.size);
    await fileio.read(fd, buffer);
    await fileio.close(fd);
    const content = String.fromCharCode.apply(null, new Uint8Array(buffer));
    return content;
  } catch (err) {
    console.error(`File read error: ${(err as BusinessError).code}`);
    return '';
  }
}

import { distributedData } from '@ohos.data.distributedData';

// 创建分布式数据库
const options: distributedData.KvManagerConfig = {
  bundleName: 'com.example.myapp',
  kvStoreType: distributedData.KvStoreType.SINGLE_VERSION
};

const kvManager = distributedData.createKvManager(options);

// 获取 KVStore 实例
kvManager.getKvStore('myStore')
  .then((store: distributedData.KvStore) => {
    // 写入数据
    store.put('key', 'value', (err) => {
      if (!err) console.log('Distributed data saved');
    });
  });