HarmonyOS 修改变量值

下列方法中data的值始终为{}，该怎么修改：

getUserInfo(): string {
  let data = '{}'
  PreferenceUtil.readBoolean(PreferenceKey.Key_Login, false).then((isLogin: boolean) => {
    if (isLogin) {
      PreferenceUtil.readModel<UserInfo>(PreferenceKey.Key_User_Info).then((userInfo) => {
        if (userInfo != null) {
          data = JSON.stringify(userInfo)
        }
      })
    } else {
      data = '{}'
    }
  })
  return data
}

PreferenceUtil代码如下：

import dataPreferences from '@ohos.data.preferences'
import common from '@ohos.app.ability.common'
import { Constant } from '../constant/Constant'
import { Logger, StrUtil } from '@yunkss/eftool'

let preference: dataPreferences.Preferences
const context = getContext(this) as common.UIAbilityContext
let TAG: string = 'PreferenceUtil'

/**
 * 持久化存储数据
 * 使用方式1：PreferenceUtil.readModel<UserLoginDTO>(PreferenceKey.USER_INFO).then((userInfo: UserLoginDTO) => {
 Logger.d('userId:'+userInfo.userId)
 })
 *使用方式2：let userInfo = await PreferenceUtil.readModel<UserLoginDTO>(PreferenceKey.USER_INFO)
 *         Logger.d('userId:'+userInfo.userId)
 */
export class PreferenceUtil {
  static async writeString(key: string, value?: string) {
    if (preference == null) {
      await PreferenceUtil.getPreferences()
    }
    try {
      await preference.put(key, value)
    } catch (e) {
      Logger.error(TAG, 'Failed to write value, cause:' + e)
    }
    await preference.flush()
  }

  static async readString(key: string, defaultValue?: string) {
    if (preference == null) {
      await PreferenceUtil.getPreferences()
    }
    let value: string = ''
    try {
      value = await preference.get(key, defaultValue).then()
    } catch (e) {
      Logger.error(TAG, 'Failed to read value, cause:' + e)
    }
    return value
  }

  static async writeNumber(key: string, value?: number) {
    if (preference == null) {
      await PreferenceUtil.getPreferences()
    }
    try {
      await preference.put(key, value)
    } catch (e) {
      Logger.error(TAG, 'Failed to write value, cause:' + e)
    }
    await preference.flush()
  }

  static async readNumber(key: string, defaultValue?: number) {
    if (preference == null) {
      await PreferenceUtil.getPreferences()
    }
    let value: number = 0
    try {
      value = await preference.get(key, defaultValue).then()
    } catch (e) {
      Logger.error(TAG, 'Failed to read value, cause:' + e)
    }
    return value
  }

  static async writeBoolean(key: string, value?: boolean) {
    if (preference == null) {
      await PreferenceUtil.getPreferences()
    }
    try {
      await preference.put(key, value)
    } catch (e) {
      Logger.error(TAG, 'Failed to write value, cause:' + e)
    }
    await preference.flush()
  }

  static async readBoolean(key: string, defaultValue?: boolean) {
    if (preference == null) {
      await PreferenceUtil.getPreferences()
    }
    let value: boolean = false
    try {
      value = await preference.get(key, defaultValue).then()
    } catch (e) {
      Logger.error(TAG, 'Failed to read value, cause:' + e)
    }
    return value
  }

  static async writeModel<T>(key: string, value?: T) {
    if (preference == null) {
      await PreferenceUtil.getPreferences()
    }
    try {
      await preference.put(key, JSON.stringify(value))
    } catch (e) {
      Logger.error(TAG, 'Failed to write value, cause:' + e)
    }
    await preference.flush()
  }

  static async readModel<T>(key: string) {
    if (preference == null) {
      await PreferenceUtil.getPreferences()
    }
    let value: string = ''
    try {
      value = await preference.get(key, '').then()
    } catch (e) {
      Logger.error(TAG, 'Failed to read value, cause:' + e)
    }
    if (StrUtil.isEmpty(value)) {
      return null
    } else {
      return JSON.parse(value) as T
    }
  }

  static async delete(key: string) {
    if (preference == null) {
      await PreferenceUtil.getPreferences()
    }
    try {
      await preference.delete(key).then()
    } catch (e) {
      Logger.error(TAG, 'Failed to delete, cause:' + e)
    }
  }

  static async clear() {
    if (preference == null) {
      await PreferenceUtil.getPreferences()
    }
    try {
      await preference.clear().then()
    } catch (e) {
      Logger.error(TAG, 'Failed to clear, cause:' + e)
    }
  }

  static async flush() {
    if (preference == null) {
      await PreferenceUtil.getPreferences()
    }
    try {
      await preference.flush().then()
    } catch (e) {
      Logger.error(TAG, 'Failed to flush, cause:' + e)
    }
  }

  private static async getPreferences() {
    try {
      preference = await dataPreferences.getPreferences(context, Constant.Preference_Name)
    } catch (e) {
      Logger.error(TAG, 'Failed to get preferences, cause:' + e)
    }
  }

  /* private static async deletePreferences() {
     try {
       await dataPreferences.deletePreferences(context, Constant.Preference_Name)
     } catch (e) {
     }
     preference=null
   }*/
}