diff --git a/interfaces/js/kits/include/error_util.h b/interfaces/js/kits/include/error_util.h
index 50338f94fade4888dfb648c7338c4488cc97a78b..b095a089bf3fe53571ec47d5ac1a9a79471b0b9f 100644
--- a/interfaces/js/kits/include/error_util.h
+++ b/interfaces/js/kits/include/error_util.h
@@ -35,10 +35,23 @@ const size_t FUNC_ARGS_COUNT = 2;    // Function input parameter count
 
 class ErrorUtil {
 public:
-    static void NapiThrow(napi_env env, int32_t errCode, const std::string& valueName,
-        const std::string& valueContent, bool throwError);
-    static void NapiNotFoundError(napi_env env, int32_t errCode, const std::string& valueName,
-        bool throwError);
+    static void NapiEmptyError(napi_env env, const std::string& valueName);
+    static void NapiTypeError(napi_env env, const std::string& valueName, const std::string& valueType);
+    static void NapiInvalidError(napi_env env, const std::string& valueName, const std::string& valueContent);
+    static void NapiPermissionError(napi_env env);
+    static void NapiSyetemError(napi_env env);
+
+private:
+    static void NapiThrowError(napi_env env, int32_t errCode, const std::string& errMessage);
+    static std::string FormatMessage(const std::string& pattern, const std::string& valueName,
+        const std::string& valueContent);
+
+    static const std::string PARAMETER_EMPTY_MESSAGE;
+    static const std::string PARAMETER_TYPE_MESSAGE;
+    static const std::string INVALID_VALUE_MESSAGE;
+    static const std::string NO_PERMISSION_MESSAGE;
+    static const std::string NOT_SYSTEM_APP_MESSAGE;
+    static constexpr uint32_t MSG_BUFFER_LEN = 100;
 };
 } // namespace I18n
 } // namespace Global
diff --git a/interfaces/js/kits/src/entity_recognizer_addon.cpp b/interfaces/js/kits/src/entity_recognizer_addon.cpp
index 5c7506c0e50720a62729a81f27762ad9b06ec9ff..72b0b34d1969506288e09572ffc56168314b4d59 100644
--- a/interfaces/js/kits/src/entity_recognizer_addon.cpp
+++ b/interfaces/js/kits/src/entity_recognizer_addon.cpp
@@ -80,7 +80,7 @@ napi_value EntityRecognizerAddon::constructor(napi_env env, napi_callback_info i
             return nullptr;
         }
         if (valueType != napi_valuetype::napi_string) {
-            ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "locale", "string", true);
+            ErrorUtil::NapiTypeError(env, "locale", "string");
             return nullptr;
         }
         int32_t code = 0;
@@ -95,7 +95,7 @@ napi_value EntityRecognizerAddon::constructor(napi_env env, napi_callback_info i
         HILOG_ERROR_I18N("EntityRecognizerAddon::constructor: Create icu::Locale failed.");
         return nullptr;
     } else if (!IsValidLocaleTag(locale)) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "locale", "a valid locale", true);
+        ErrorUtil::NapiInvalidError(env, "locale", "a valid locale");
         return nullptr;
     }
     std::unique_ptr<EntityRecognizerAddon> obj = std::make_unique<EntityRecognizerAddon>();
@@ -122,7 +122,7 @@ napi_value EntityRecognizerAddon::FindEntityInfo(napi_env env, napi_callback_inf
     if (status != napi_ok) {
         return nullptr;
     } else if (argc < 1) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "text", true);
+        ErrorUtil::NapiEmptyError(env, "text");
         return nullptr;
     }
     napi_valuetype valueType = napi_valuetype::napi_undefined;
@@ -131,7 +131,7 @@ napi_value EntityRecognizerAddon::FindEntityInfo(napi_env env, napi_callback_inf
         return nullptr;
     }
     if (valueType != napi_valuetype::napi_string) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "text", "string", true);
+        ErrorUtil::NapiTypeError(env, "text", "string");
         return nullptr;
     }
     int32_t code = 0;
diff --git a/interfaces/js/kits/src/error_util.cpp b/interfaces/js/kits/src/error_util.cpp
index 54348679fb0fa73e4713614387309fd91d4e8557..40881ea3282cc7dfe34b379879fb4dd8a52f69c2 100644
--- a/interfaces/js/kits/src/error_util.cpp
+++ b/interfaces/js/kits/src/error_util.cpp
@@ -14,6 +14,7 @@
  */
 #include "error_util.h"
 
+#include <securec.h>
 #include <string>
 #include <unordered_map>
 #include "i18n_hilog.h"
@@ -21,61 +22,72 @@
 namespace OHOS {
 namespace Global {
 namespace I18n {
-static const std::unordered_map<int32_t, std::string> ErrorCodeToMsg {
-    {I18N_NO_PERMISSION,
-        "Permission verification failed. The application does not have the permission required to call the API."},
-    {I18N_NOT_SYSTEM_APP,
-        "Permission verification failed. A non-system application calls a system API."},
-    {I18N_NOT_VALID, "Invalid parameter"},
-    {I18N_NOT_FOUND, "Parameter error"},
-    {I18N_OPTION_NOT_VALID, "Invalid option name"}
-};
+const std::string ErrorUtil::PARAMETER_EMPTY_MESSAGE = "Parameter error, the %s cannot be %s.";
+const std::string ErrorUtil::PARAMETER_TYPE_MESSAGE = "Parameter error, the type of %s must be %s.";
+const std::string ErrorUtil::INVALID_VALUE_MESSAGE = "Invalid parameter, the %s must be %s.";
+const std::string ErrorUtil::NO_PERMISSION_MESSAGE =
+    "Permission verification failed. The application does not have the permission required to call the API.";
+const std::string ErrorUtil::NOT_SYSTEM_APP_MESSAGE =
+    "Permission verification failed. A non-system application calls a system API.";
 
-void ErrorUtil::NapiThrow(napi_env env, int32_t errCode, const std::string& valueName,
-    const std::string& valueContent, bool throwError)
+void ErrorUtil::NapiEmptyError(napi_env env, const std::string& valueName)
 {
-    if (!throwError) {
-        return;
-    }
-    napi_value code = nullptr;
-    napi_status status = napi_create_string_latin1(env, std::to_string(errCode).c_str(), NAPI_AUTO_LENGTH, &code);
-    if (status != napi_ok) {
-        HILOG_ERROR_I18N("ErrorUtil::NapiThrow: create string %{public}d failed", errCode);
-        return;
-    }
-    napi_value message = nullptr;
-    auto iter = ErrorCodeToMsg.find(errCode);
-    std::string errMsg = iter != ErrorCodeToMsg.end() ? iter->second : "";
-    std::string allErrMsg;
+    std::string errMessage = ErrorUtil::FormatMessage(PARAMETER_EMPTY_MESSAGE, valueName, "empty");
+    ErrorUtil::NapiThrowError(env, I18N_NOT_FOUND, errMessage);
+}
 
-    if (errCode == I18N_NO_PERMISSION || errCode == I18N_NOT_SYSTEM_APP) {
-        allErrMsg = errMsg;
-    } else if (errCode == I18N_NOT_VALID) {
-        allErrMsg = errMsg + ", the " + valueName + " must be " + valueContent + ".";
-    } else if (valueContent.length() == 0) {
-        allErrMsg = errMsg + ", the " + valueName + " cannot be empty.";
-    } else {
-        allErrMsg = errMsg + ", the type of " + valueName + " must be " + valueContent + ".";
-    }
+void ErrorUtil::NapiTypeError(napi_env env, const std::string& valueName, const std::string& valueType)
+{
+    std::string errMessage = ErrorUtil::FormatMessage(PARAMETER_TYPE_MESSAGE, valueName, valueType);
+    ErrorUtil::NapiThrowError(env, I18N_NOT_FOUND, errMessage);
+}
 
-    status = napi_create_string_latin1(env, allErrMsg.c_str(), NAPI_AUTO_LENGTH, &message);
-    if (status != napi_ok) {
-        HILOG_ERROR_I18N("ErrorUtil::NapiThrow: create string %{public}s failed", allErrMsg.c_str());
+void ErrorUtil::NapiInvalidError(napi_env env, const std::string& valueName, const std::string& valueContent)
+{
+    std::string errMessage = ErrorUtil::FormatMessage(INVALID_VALUE_MESSAGE, valueName, valueContent);
+    ErrorUtil::NapiThrowError(env, I18N_NOT_VALID, errMessage);
+}
+
+void ErrorUtil::NapiPermissionError(napi_env env)
+{
+    ErrorUtil::NapiThrowError(env, I18N_NO_PERMISSION, NO_PERMISSION_MESSAGE);
+}
+
+void ErrorUtil::NapiSyetemError(napi_env env)
+{
+    ErrorUtil::NapiThrowError(env, I18N_NOT_SYSTEM_APP, NOT_SYSTEM_APP_MESSAGE);
+}
+
+void ErrorUtil::NapiThrowError(napi_env env, int32_t errCode, const std::string& errMessage)
+{
+    if (errMessage.empty()) {
+        HILOG_ERROR_I18N("ErrorUtil::NapiThrowError: errMessage is empty.");
         return;
     }
-    napi_value error = nullptr;
-    status = napi_create_error(env, code, message, &error);
+    napi_status status = napi_throw_error(env, std::to_string(errCode).c_str(), errMessage.c_str());
     if (status != napi_ok) {
-        HILOG_ERROR_I18N("ErrorUtil::NapiThrow: create error failed");
-        return;
+        HILOG_ERROR_I18N("ErrorUtil::NapiThrowError: Throw error failed.");
     }
-    napi_throw(env, error);
 }
 
-void ErrorUtil::NapiNotFoundError(napi_env env, int32_t errCode, const std::string& valueName,
-    bool throwError)
+std::string ErrorUtil::FormatMessage(const std::string& pattern, const std::string& valueName,
+    const std::string& valueContent)
 {
-    NapiThrow(env, errCode, valueName, "", throwError);
+    std::string message;
+    if (pattern.empty() || valueName.empty() || valueContent.empty()) {
+        HILOG_ERROR_I18N("ErrorUtil::FormatMessage: Parameter check failed, pattern %{public}s, valueName %{public}s, "
+            "valueContent %{public}s.", pattern.c_str(), valueName.c_str(), valueContent.c_str());
+        return message;
+    }
+
+    char buffer[MSG_BUFFER_LEN];
+    int32_t len = sprintf_s(buffer, sizeof(buffer), pattern.c_str(), valueName.c_str(), valueContent.c_str());
+    if (len <= 0) {
+        HILOG_ERROR_I18N("ErrorUtil::FormatMessage: Snprintf failed, errCode %{public}s.", pattern.c_str());
+        return message;
+    }
+    message = buffer;
+    return message;
 }
 } // namespace I18n
 } // namespace Global
diff --git a/interfaces/js/kits/src/holiday_manager_addon.cpp b/interfaces/js/kits/src/holiday_manager_addon.cpp
index 90d7413046465ae46d1270b17225b04d83f7df48..2183d1601467ab4d5488e897d7cde220a6d56dc4 100644
--- a/interfaces/js/kits/src/holiday_manager_addon.cpp
+++ b/interfaces/js/kits/src/holiday_manager_addon.cpp
@@ -71,7 +71,7 @@ napi_value HolidayManagerAddon::HolidayManagerConstructor(napi_env env, napi_cal
     if (status != napi_ok) {
         return nullptr;
     } else if (argc < 1) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "icsPath", true);
+        ErrorUtil::NapiEmptyError(env, "icsPath");
         return nullptr;
     }
     napi_valuetype valueType = napi_valuetype::napi_undefined;
@@ -80,7 +80,7 @@ napi_value HolidayManagerAddon::HolidayManagerConstructor(napi_env env, napi_cal
         return nullptr;
     }
     if (valueType != napi_valuetype::napi_string) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "icsPath", "string", true);
+        ErrorUtil::NapiTypeError(env, "icsPath", "string");
         return nullptr;
     }
     std::unique_ptr<HolidayManagerAddon> obj = std::make_unique<HolidayManagerAddon>();
@@ -204,7 +204,7 @@ std::vector<int> HolidayManagerAddon::ValidateParamDate(napi_env &env, napi_valu
         return list;
     }
     if (valueType != napi_valuetype::napi_object) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "date", "Date object", true);
+        ErrorUtil::NapiTypeError(env, "date", "Date object");
         return list;
     }
     list.push_back(GetDateValue(env, argv, "getFullYear"));
@@ -248,7 +248,7 @@ int32_t HolidayManagerAddon::ValidateParamNumber(napi_env &env, napi_value &argv
         return -1;
     }
     if (valueType != napi_valuetype::napi_number) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "year", "number", true);
+        ErrorUtil::NapiTypeError(env, "year", "number");
         return -1;
     }
     int32_t val = 0;
@@ -258,7 +258,7 @@ int32_t HolidayManagerAddon::ValidateParamNumber(napi_env &env, napi_value &argv
         return -1;
     }
     if (val < 0) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "year", "a non-negative number", true);
+        ErrorUtil::NapiInvalidError(env, "year", "a non-negative number");
         return -1;
     }
     return val;
diff --git a/interfaces/js/kits/src/i18n_addon.cpp b/interfaces/js/kits/src/i18n_addon.cpp
index 8fd470b198f5c095167f812f003b168e5461b281..69a88d386b2c555d86fc4c5f39d4ffc8b00d3e91 100644
--- a/interfaces/js/kits/src/i18n_addon.cpp
+++ b/interfaces/js/kits/src/i18n_addon.cpp
@@ -262,7 +262,7 @@ napi_value I18nAddon::GetTimePeriodName(napi_env env, napi_callback_info info)
     UErrorCode icuStatus = U_ZERO_ERROR;
     icu::Locale locale = icu::Locale::forLanguageTag(localeTag.data(), icuStatus);
     if (U_FAILURE(icuStatus) || !IsValidLocaleTag(locale)) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "locale", "a valid locale", true);
+        ErrorUtil::NapiInvalidError(env, "locale", "a valid locale");
         return nullptr;
     }
     icu::SimpleDateFormat* formatter = dynamic_cast<icu::SimpleDateFormat*>
@@ -299,7 +299,7 @@ int I18nAddon::GetParamOfGetTimePeriodName(napi_env env, napi_callback_info info
         HILOG_ERROR_I18N("GetTimePeriodName can't get parameters from getTimePerioudName.");
         return -1;
     } else if (argc < 1) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "hour", true);
+        ErrorUtil::NapiEmptyError(env, "hour");
         return -1;
     }
 
@@ -309,7 +309,7 @@ int I18nAddon::GetParamOfGetTimePeriodName(napi_env env, napi_callback_info info
         return -1;
     }
     if (valueType != napi_valuetype::napi_number) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "hour", "number", true);
+        ErrorUtil::NapiTypeError(env, "hour", "number");
         return -1;
     }
     status = napi_get_value_int32(env, argv[0], &hour);
@@ -333,7 +333,7 @@ int I18nAddon::GetParamOfGetTimePeriodName(napi_env env, napi_callback_info info
             return -1;
         }
     } else {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "locale", "string", true);
+        ErrorUtil::NapiTypeError(env, "locale", "string");
         return -1;
     }
     return 0;
@@ -350,7 +350,7 @@ LocaleInfo* ProcessJsParamLocale(napi_env env, napi_value argv)
     UErrorCode icuStatus = U_ZERO_ERROR;
     icu::Locale locale = icu::Locale::forLanguageTag(localeTag.data(), icuStatus);
     if (U_FAILURE(icuStatus) || !IsValidLocaleTag(locale)) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "locale", "a valid locale", true);
+        ErrorUtil::NapiInvalidError(env, "locale", "a valid locale");
         return nullptr;
     }
     return new LocaleInfo(localeTag);
@@ -372,7 +372,7 @@ bool ProcessJsParamLocaleList(napi_env env, napi_value argv, std::vector<LocaleI
         icu::Locale locale = icu::Locale::forLanguageTag(it->data(), icuStatus);
         if (U_FAILURE(icuStatus) || !IsValidLocaleTag(locale)) {
             HILOG_ERROR_I18N("GetBestMatchLocale param localeList Invalid: %{public}s.", it->data());
-            ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "locale of localeList", "a valid locale", true);
+            ErrorUtil::NapiInvalidError(env, "locale of localeList", "a valid locale");
             return false;
         }
         LocaleInfo *temp = new LocaleInfo(*it);
@@ -401,7 +401,7 @@ napi_value I18nAddon::GetBestMatchLocale(napi_env env, napi_callback_info info)
     void *data = nullptr;
     napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
     if (status != napi_ok || argc < 2) { // 2 is the request param num.
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "locale or localeList", true);
+        ErrorUtil::NapiEmptyError(env, "locale or localeList");
         return nullptr;
     }
     LocaleInfo *requestLocale = ProcessJsParamLocale(env, argv[0]);
@@ -445,7 +445,7 @@ napi_value I18nAddon::GetThreeLetterLanguage(napi_env env, napi_callback_info in
         HILOG_ERROR_I18N("GetThreeLetterLanguage napi get param error.");
         return nullptr;
     } else if (argc < 1) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "locale", true);
+        ErrorUtil::NapiEmptyError(env, "locale");
         return nullptr;
     }
 
@@ -455,7 +455,7 @@ napi_value I18nAddon::GetThreeLetterLanguage(napi_env env, napi_callback_info in
         return nullptr;
     }
     if (valueType != napi_valuetype::napi_string) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "locale", "string", true);
+        ErrorUtil::NapiTypeError(env, "locale", "string");
         return nullptr;
     }
 
@@ -472,7 +472,7 @@ napi_value I18nAddon::GetThreeLetterLanguage(napi_env env, napi_callback_info in
     status = napi_create_string_utf8(env, language.c_str(), NAPI_AUTO_LENGTH, &result);
     if (status != napi_ok || language.empty()) {
         HILOG_ERROR_I18N("GetThreeLetterLanguage create string fail or empty");
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "locale", "a valid locale", true);
+        ErrorUtil::NapiInvalidError(env, "locale", "a valid locale");
         return nullptr;
     }
     return result;
@@ -489,7 +489,7 @@ napi_value I18nAddon::GetThreeLetterRegion(napi_env env, napi_callback_info info
         HILOG_ERROR_I18N("GetThreeLetterRegion: Failed to obtain the parameter.");
         return nullptr;
     } else if (argc < 1) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "locale", true);
+        ErrorUtil::NapiEmptyError(env, "locale");
         return nullptr;
     }
 
@@ -499,7 +499,7 @@ napi_value I18nAddon::GetThreeLetterRegion(napi_env env, napi_callback_info info
         return nullptr;
     }
     if (valueType != napi_valuetype::napi_string) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "locale", "string", true);
+        ErrorUtil::NapiTypeError(env, "locale", "string");
         return nullptr;
     }
 
@@ -516,7 +516,7 @@ napi_value I18nAddon::GetThreeLetterRegion(napi_env env, napi_callback_info info
     status = napi_create_string_utf8(env, country.c_str(), NAPI_AUTO_LENGTH, &result);
     if (status != napi_ok || country.empty()) {
         HILOG_ERROR_I18N("GetThreeLetterRegion create string fail or empty");
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "locale", "a valid locale", true);
+        ErrorUtil::NapiInvalidError(env, "locale", "a valid locale");
         return nullptr;
     }
     return result;
@@ -778,7 +778,7 @@ napi_value I18nAddon::GetUnicodeWrappedFilePath(napi_env env, napi_callback_info
         return nullptr;
     }
     if (argc < 1) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "path", true);
+        ErrorUtil::NapiEmptyError(env, "path");
         return nullptr;
     }
     VariableConvertor::VerifyType(env, "path", napi_valuetype::napi_string, argv[0]);
@@ -806,12 +806,12 @@ napi_value I18nAddon::GetUnicodeWrappedFilePath(napi_env env, napi_callback_info
             return nullptr;
         }
     }
-    std::string errorCode;
+    std::string invalidField;
     std::shared_ptr<LocaleInfo> localeInfoPtr = obj == nullptr ? nullptr : obj->GetLocaleInfo();
     std::string result = LocaleConfig::GetUnicodeWrappedFilePath(path, delimiter,
-        localeInfoPtr, errorCode);
-    if (!errorCode.empty()) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, errorCode, "valid", true);
+        localeInfoPtr, invalidField);
+    if (!invalidField.empty()) {
+        ErrorUtil::NapiInvalidError(env, invalidField, "valid");
         return nullptr;
     }
     return VariableConvertor::CreateString(env, result);
@@ -826,7 +826,7 @@ char I18nAddon::GetDelimiter(napi_env env, napi_value argVal)
         return '\0';
     }
     if (result.length() != 1) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "delimiter", "a valid delimiter", true);
+        ErrorUtil::NapiInvalidError(env, "delimiter", "a valid delimiter");
         return '\0';
     }
     return result.at(0);
diff --git a/interfaces/js/kits/src/i18n_calendar_addon.cpp b/interfaces/js/kits/src/i18n_calendar_addon.cpp
index 35bbb79f9db5fd0a60dba2767c319e49ea0f6a00..1882bc58ac5fba0bebeaceb74155a00392cda665 100644
--- a/interfaces/js/kits/src/i18n_calendar_addon.cpp
+++ b/interfaces/js/kits/src/i18n_calendar_addon.cpp
@@ -562,7 +562,7 @@ napi_value I18nCalendarAddon::Add(napi_env env, napi_callback_info info)
     }
     if (valueType != napi_valuetype::napi_string) {
         HILOG_ERROR_I18N("Parameter type does not match argv[0]");
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "field", "string", true);
+        ErrorUtil::NapiTypeError(env, "field", "string");
         return nullptr;
     }
     int32_t code = 0;
@@ -576,7 +576,7 @@ napi_value I18nCalendarAddon::Add(napi_env env, napi_callback_info info)
     }
     if (valueType != napi_valuetype::napi_number) {
         HILOG_ERROR_I18N("Parameter type does not match argv[1]");
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "amount", "number", true);
+        ErrorUtil::NapiTypeError(env, "amount", "number");
         return nullptr;
     }
     int32_t amount;
@@ -827,7 +827,7 @@ std::string I18nCalendarAddon::GetAddField(napi_env &env, napi_value &value, int
     if (g_fieldsInFunctionAdd.find(field) == g_fieldsInFunctionAdd.end()) {
         code = 1;
         HILOG_ERROR_I18N("Parameter rangs do not match");
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "field", "a valid field", true);
+        ErrorUtil::NapiInvalidError(env, "field", "a valid field");
         return field;
     }
     return field;
diff --git a/interfaces/js/kits/src/i18n_normalizer_addon.cpp b/interfaces/js/kits/src/i18n_normalizer_addon.cpp
index 51cf63076bdbe1608ff1715887f054ab3f7a224d..6cdb809a78123d5ffa290950b28ff6654f31b9c3 100644
--- a/interfaces/js/kits/src/i18n_normalizer_addon.cpp
+++ b/interfaces/js/kits/src/i18n_normalizer_addon.cpp
@@ -101,7 +101,7 @@ napi_value I18nNormalizerAddon::I18nNormalizerConstructor(napi_env env, napi_cal
         return nullptr;
     }
     if (argc < 1) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "mode", true);
+        ErrorUtil::NapiEmptyError(env, "mode");
         return nullptr;
     }
     napi_valuetype valueType = napi_valuetype::napi_undefined;
@@ -110,7 +110,7 @@ napi_value I18nNormalizerAddon::I18nNormalizerConstructor(napi_env env, napi_cal
         return nullptr;
     }
     if (valueType != napi_valuetype::napi_number) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "mode", "number", true);
+        ErrorUtil::NapiTypeError(env, "mode", "number");
         return nullptr;
     }
     int32_t normalizerMode;
@@ -120,7 +120,7 @@ napi_value I18nNormalizerAddon::I18nNormalizerConstructor(napi_env env, napi_cal
     }
     if (normalizerMode != NORMALIZER_MODE_NFC && normalizerMode != NORMALIZER_MODE_NFD &&
         normalizerMode != NORMALIZER_MODE_NFKC && normalizerMode != NORMALIZER_MODE_NFKD) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "mode", "a valid mode", true);
+        ErrorUtil::NapiTypeError(env, "mode", "a valid mode");
         return nullptr;
     }
 
@@ -154,7 +154,7 @@ napi_value I18nNormalizerAddon::Normalize(napi_env env, napi_callback_info info)
         return nullptr;
     }
     if (argc < 1) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "text", true);
+        ErrorUtil::NapiEmptyError(env, "text");
         return nullptr;
     }
     napi_valuetype valueType = napi_valuetype::napi_undefined;
@@ -164,7 +164,7 @@ napi_value I18nNormalizerAddon::Normalize(napi_env env, napi_callback_info info)
     }
     if (valueType != napi_valuetype::napi_string) {
         HILOG_ERROR_I18N("Invalid parameter type");
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "text", "string", true);
+        ErrorUtil::NapiTypeError(env, "text", "string");
         return nullptr;
     }
     int32_t code = 0;
diff --git a/interfaces/js/kits/src/i18n_system_addon.cpp b/interfaces/js/kits/src/i18n_system_addon.cpp
index 56b5b17cfe5143f4026283b105c405c6520b7c34..4ca8e5c7fdb5bc98232920ed3507732320e01832 100644
--- a/interfaces/js/kits/src/i18n_system_addon.cpp
+++ b/interfaces/js/kits/src/i18n_system_addon.cpp
@@ -323,7 +323,7 @@ napi_value I18nSystemAddon::SetAppPreferredLanguage(napi_env env, napi_callback_
     }
     if (valueType != napi_valuetype::napi_string) {
         HILOG_ERROR_I18N("SetAppPreferredLanguage Parameter type is not string");
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "language", "string", true);
+        ErrorUtil::NapiTypeError(env, "language", "string");
         return nullptr;
     }
     int code = 0;
@@ -336,7 +336,7 @@ napi_value I18nSystemAddon::SetAppPreferredLanguage(napi_env env, napi_callback_
     icu::Locale locale = icu::Locale::forLanguageTag(localeTag.data(), icuStatus);
     if (U_FAILURE(icuStatus) || !(IsValidLocaleTag(locale) || localeTag.compare("default") == 0)) {
         HILOG_ERROR_I18N("SetAppPreferredLanguage does not support this locale");
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "language", "a valid language", true);
+        ErrorUtil::NapiInvalidError(env, "language", "a valid language");
         return nullptr;
     }
 #ifdef SUPPORT_APP_PREFERRED_LANGUAGE
@@ -397,7 +397,9 @@ napi_value I18nSystemAddon::GetDisplayCountryImpl(napi_env env, napi_callback_in
     if (status != napi_ok) {
         return VariableConvertor::CreateString(env, "");
     } else if (argc < FUNC_ARGS_COUNT) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "country or locale", throwError);
+        if (throwError) {
+            ErrorUtil::NapiEmptyError(env, "country or locale");
+        }
         return VariableConvertor::CreateString(env, "");
     }
     VariableConvertor::VerifyType(env, "country", napi_valuetype::napi_string, argv[0]);
@@ -413,10 +415,14 @@ napi_value I18nSystemAddon::GetDisplayCountryImpl(napi_env env, napi_callback_in
     }
     LocaleInfo localeInfo(localeBuf.data());
     if (!LocaleConfig::IsValidRegion(localeBuf.data()) && localeInfo.GetRegion().empty()) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "country", "a valid region", throwError);
+        if (throwError) {
+            ErrorUtil::NapiInvalidError(env, "country", "a valid region");
+        }
         return VariableConvertor::CreateString(env, "");
     } else if (!LocaleConfig::IsValidTag(displayLocaleBuf.data())) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "locale", "a valid locale", throwError);
+        if (throwError) {
+            ErrorUtil::NapiInvalidError(env, "locale", "a valid locale");
+        }
         return VariableConvertor::CreateString(env, "");
     }
     bool sentenceCase = true;
@@ -427,9 +433,8 @@ napi_value I18nSystemAddon::GetDisplayCountryImpl(napi_env env, napi_callback_in
         }
     }
     std::string value = LocaleConfig::GetDisplayRegion(localeBuf.data(), displayLocaleBuf.data(), sentenceCase);
-    if (value.length() == 0) {
+    if (value.empty()) {
         HILOG_ERROR_I18N("GetDisplayCountryImpl: result is empty.");
-        return VariableConvertor::CreateString(env, "");
     }
     return VariableConvertor::CreateString(env, value);
 }
@@ -445,7 +450,9 @@ napi_value I18nSystemAddon::GetDisplayLanguageImpl(napi_env env, napi_callback_i
     if (status != napi_ok) {
         return nullptr;
     } else if (argc < FUNC_ARGS_COUNT) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "language or locale", throwError);
+        if (throwError) {
+            ErrorUtil::NapiEmptyError(env, "language or locale");
+        }
         return nullptr;
     }
     VariableConvertor::VerifyType(env, "language", napi_valuetype::napi_string, argv[0]);
@@ -460,7 +467,9 @@ napi_value I18nSystemAddon::GetDisplayLanguageImpl(napi_env env, napi_callback_i
         return VariableConvertor::CreateString(env, "");
     }
     if (!LocaleConfig::IsValidTag(displayLocaleBuf.data())) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "locale", "a valid locale", throwError);
+        if (throwError) {
+            ErrorUtil::NapiInvalidError(env, "locale", "a valid locale");
+        }
         return nullptr;
     }
     bool sentenceCase = true;
@@ -471,17 +480,11 @@ napi_value I18nSystemAddon::GetDisplayLanguageImpl(napi_env env, napi_callback_i
         }
     }
     std::string value = LocaleConfig::GetDisplayLanguage(localeBuf.data(), displayLocaleBuf.data(), sentenceCase);
-    if (value.length() == 0) {
+    if (value.empty()) {
         HILOG_ERROR_I18N("GetDisplayLanguageImpl: result is empty.");
         return nullptr;
     }
-    napi_value result = nullptr;
-    status = napi_create_string_utf8(env, value.c_str(), NAPI_AUTO_LENGTH, &result);
-    if (status != napi_ok) {
-        HILOG_ERROR_I18N("GetDisplayLanguageImpl: Failed to create string item");
-        return nullptr;
-    }
-    return result;
+    return VariableConvertor::CreateString(env, value);
 }
 
 napi_value I18nSystemAddon::GetSystemCountriesImpl(napi_env env, napi_callback_info info, bool throwError)
@@ -494,7 +497,9 @@ napi_value I18nSystemAddon::GetSystemCountriesImpl(napi_env env, napi_callback_i
     if (status != napi_ok) {
         return nullptr;
     } else if (argc < 1) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "language", throwError);
+        if (throwError) {
+            ErrorUtil::NapiEmptyError(env, "language");
+        }
         return nullptr;
     }
     VariableConvertor::VerifyType(env, "language", napi_valuetype::napi_string, argv[0]);
@@ -546,7 +551,9 @@ napi_value I18nSystemAddon::IsSuggestedImpl(napi_env env, napi_callback_info inf
     if (status != napi_ok) {
         return nullptr;
     } else if (argc < 1) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "language", throwError);
+        if (throwError) {
+            ErrorUtil::NapiEmptyError(env, "language");
+        }
         return nullptr;
     }
     VariableConvertor::VerifyType(env, "language", napi_valuetype::napi_string, argv[0]);
@@ -605,7 +612,9 @@ napi_value I18nSystemAddon::SetSystemLanguageImpl(napi_env env, napi_callback_in
     }
     if (argc < 1) {
         HILOG_ERROR_I18N("SetSystemLanguageImpl: Missing parameter");
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "language", throwError);
+        if (throwError) {
+            ErrorUtil::NapiEmptyError(env, "language");
+        }
         return nullptr;
     }
     size_t len = 0;
@@ -625,7 +634,7 @@ napi_value I18nSystemAddon::SetSystemLanguageImpl(napi_env env, napi_callback_in
     bool success = err == I18nErrorCode::SUCCESS;
     if (throwError) {
         if (!success) {
-            ErrorUtil::NapiThrow(env, I18N_NO_PERMISSION, "", "", throwError);
+            ErrorUtil::NapiPermissionError(env);
         }
         return nullptr;
     }
@@ -650,7 +659,9 @@ napi_value I18nSystemAddon::SetSystemRegionImpl(napi_env env, napi_callback_info
     }
     if (argc < 1) {
         HILOG_ERROR_I18N("SetSystemRegionImpl: Missing parameter");
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "region", throwError);
+        if (throwError) {
+            ErrorUtil::NapiEmptyError(env, "region");
+        }
         return nullptr;
     }
     int32_t code = 0;
@@ -664,7 +675,7 @@ napi_value I18nSystemAddon::SetSystemRegionImpl(napi_env env, napi_callback_info
     bool success = err == I18nErrorCode::SUCCESS;
     if (throwError) {
         if (!success) {
-            ErrorUtil::NapiThrow(env, I18N_NO_PERMISSION, "", "", throwError);
+            ErrorUtil::NapiPermissionError(env);
         }
         return nullptr;
     }
@@ -689,7 +700,9 @@ napi_value I18nSystemAddon::SetSystemLocaleImpl(napi_env env, napi_callback_info
     }
     if (argc < 1) {
         HILOG_ERROR_I18N("SetSystemLocaleImpl: Missing parameter");
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "locale", throwError);
+        if (throwError) {
+            ErrorUtil::NapiEmptyError(env, "locale");
+        }
         return nullptr;
     }
     int32_t code = 0;
@@ -703,7 +716,7 @@ napi_value I18nSystemAddon::SetSystemLocaleImpl(napi_env env, napi_callback_info
     bool success = err == I18nErrorCode::SUCCESS;
     if (throwError) {
         if (!success) {
-            ErrorUtil::NapiThrow(env, I18N_NO_PERMISSION, "", "", throwError);
+            ErrorUtil::NapiPermissionError(env);
         }
         return nullptr;
     }
@@ -728,7 +741,9 @@ napi_value I18nSystemAddon::Set24HourClockImpl(napi_env env, napi_callback_info
     }
     if (argc < 1) {
         HILOG_ERROR_I18N("Set24HourClockImpl: Missing parameter");
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "option", throwError);
+        if (throwError) {
+            ErrorUtil::NapiEmptyError(env, "option");
+        }
         return nullptr;
     }
 
@@ -744,7 +759,7 @@ napi_value I18nSystemAddon::Set24HourClockImpl(napi_env env, napi_callback_info
     bool success = err == I18nErrorCode::SUCCESS;
     if (throwError) {
         if (!success) {
-            ErrorUtil::NapiThrow(env, I18N_NO_PERMISSION, "", "", throwError);
+            ErrorUtil::NapiPermissionError(env);
         }
         return nullptr;
     }
@@ -785,10 +800,10 @@ napi_value I18nSystemAddon::AddPreferredLanguageImpl(napi_env env, napi_callback
     HILOG_INFO_I18N("I18nSystemAddon::AddPreferredLanguageImpl with code %{public}d", static_cast<int32_t>(err));
     if (throwError) {
         if (err == I18nErrorCode::NO_PERMISSION || err == I18nErrorCode::NOT_SYSTEM_APP) {
-            ErrorUtil::NapiThrow(env, I18N_NO_PERMISSION, "", "", throwError);
+            ErrorUtil::NapiPermissionError(env);
         }
         if (err != I18nErrorCode::SUCCESS) {
-            ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "language", "a valid language", throwError);
+            ErrorUtil::NapiInvalidError(env, "language", "a valid language");
         }
         return nullptr;
     }
@@ -809,16 +824,14 @@ napi_value I18nSystemAddon::RemovePreferredLanguageImpl(napi_env env, napi_callb
 {
     size_t argc = 1;
     napi_value argv[1] = { nullptr };
-    napi_value thisVar = nullptr;
-    void *data = nullptr;
-    int len = 0;
-    napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
+    napi_status status = napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
     if (status != napi_ok) {
         return nullptr;
-    }
-    if (argc < 1) {
+    } else if (argc < 1) {
         HILOG_ERROR_I18N("RemovePreferredLanguageImpl: Missing parameter");
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "index", throwError);
+        if (throwError) {
+            ErrorUtil::NapiEmptyError(env, "index");
+        }
         return nullptr;
     }
 
@@ -827,7 +840,9 @@ napi_value I18nSystemAddon::RemovePreferredLanguageImpl(napi_env env, napi_callb
     if (status != napi_ok) {
         return nullptr;
     } else if (valueType != napi_valuetype::napi_number) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "index", "number", throwError);
+        if (throwError) {
+            ErrorUtil::NapiTypeError(env, "index", "number");
+        }
         return nullptr;
     }
     int index = 1000000;
@@ -836,9 +851,9 @@ napi_value I18nSystemAddon::RemovePreferredLanguageImpl(napi_env env, napi_callb
         HILOG_ERROR_I18N("removePreferrdLanguage: get index failed");
         return nullptr;
     }
-    len = static_cast<int>(PreferredLanguage::GetPreferredLanguageList().size());
+    int len = static_cast<int>(PreferredLanguage::GetPreferredLanguageList().size());
     if ((index < 0 || index > len - 1) && throwError) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "index", "within the valid range", throwError);
+        ErrorUtil::NapiInvalidError(env, "index", "within the valid range");
         return nullptr;
     }
     I18nErrorCode err = I18nServiceAbilityClient::RemovePreferredLanguage(index);
@@ -846,7 +861,7 @@ napi_value I18nSystemAddon::RemovePreferredLanguageImpl(napi_env env, napi_callb
 
     if (throwError) {
         if (!success) {
-            ErrorUtil::NapiThrow(env, I18N_NO_PERMISSION, "", "", throwError);
+            ErrorUtil::NapiPermissionError(env);
         }
         return nullptr;
     }
@@ -868,20 +883,22 @@ napi_value I18nSystemAddon::SetUsingLocalDigitAddonImpl(napi_env env, napi_callb
     napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
     if (status != napi_ok) {
         return nullptr;
-    }
-    if (argc < 1) {
+    } else if (argc < 1) {
         HILOG_ERROR_I18N("Invalid parameter nullptr");
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "flag", throwError);
+        if (throwError) {
+            ErrorUtil::NapiEmptyError(env, "flag");
+        }
         return nullptr;
     }
     napi_valuetype valueType = napi_valuetype::napi_undefined;
     status = napi_typeof(env, argv[0], &valueType);
     if (status != napi_ok) {
         return nullptr;
-    }
-    if (valueType != napi_valuetype::napi_boolean) {
+    } else if (valueType != napi_valuetype::napi_boolean) {
         HILOG_ERROR_I18N("Invalid parameter type");
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "flag", "boolean", throwError);
+        if (throwError) {
+            ErrorUtil::NapiTypeError(env, "flag", "boolean");
+        }
         return nullptr;
     }
     bool flag = false;
@@ -896,7 +913,7 @@ napi_value I18nSystemAddon::SetUsingLocalDigitAddonImpl(napi_env env, napi_callb
     bool res = err == I18nErrorCode::SUCCESS;
     if (throwError) {
         if (!res) {
-            ErrorUtil::NapiThrow(env, I18N_NO_PERMISSION, "", "", throwError);
+            ErrorUtil::NapiPermissionError(env);
         }
         return nullptr;
     }
@@ -913,7 +930,9 @@ bool I18nSystemAddon::ParseStringParam(napi_env env, napi_value argv, bool throw
 {
     if (argv == nullptr) {
         HILOG_ERROR_I18N("ParseStringParam: Missing parameter");
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "language", throwError);
+        if (throwError) {
+            ErrorUtil::NapiEmptyError(env, "language");
+        }
         return false;
     }
     napi_valuetype valueType = napi_valuetype::napi_undefined;
@@ -922,7 +941,9 @@ bool I18nSystemAddon::ParseStringParam(napi_env env, napi_value argv, bool throw
         return false;
     }
     if (valueType != napi_valuetype::napi_string) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "language", "string", throwError);
+        if (throwError) {
+            ErrorUtil::NapiTypeError(env, "language", "string");
+        }
         return false;
     }
     size_t len = 0;
@@ -954,13 +975,13 @@ napi_value I18nSystemAddon::SetTemperatureType(napi_env env, napi_callback_info
     }
     switch (err) {
         case I18nErrorCode::NOT_SYSTEM_APP:
-            ErrorUtil::NapiThrow(env, I18N_NOT_SYSTEM_APP, "", "", true);
+            ErrorUtil::NapiSyetemError(env);
             break;
         case I18nErrorCode::NO_PERMISSION:
-            ErrorUtil::NapiThrow(env, I18N_NO_PERMISSION, "", "", true);
+            ErrorUtil::NapiPermissionError(env);
             break;
         case I18nErrorCode::INVALID_TEMPERATURE_TYPE:
-            ErrorUtil::NapiThrow(env, I18N_NOT_VALID, NAME_OF_TEMPERATURE, TYPE_OF_TEMPERATURE, true);
+            ErrorUtil::NapiInvalidError(env, NAME_OF_TEMPERATURE, TYPE_OF_TEMPERATURE);
             break;
         default:
             HILOG_ERROR_I18N("I18nSystemAddon::SetTemperatureType: set temperature type failed.");
@@ -984,7 +1005,7 @@ napi_value I18nSystemAddon::GetTemperatureName(napi_env env, napi_callback_info
     }
     std::string temperatureName = LocaleConfig::GetTemperatureName(type);
     if (temperatureName.empty()) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, NAME_OF_TEMPERATURE, TYPE_OF_TEMPERATURE, true);
+        ErrorUtil::NapiInvalidError(env, NAME_OF_TEMPERATURE, TYPE_OF_TEMPERATURE);
         return VariableConvertor::CreateString(env, "");
     }
     return VariableConvertor::CreateString(env, temperatureName);
@@ -1002,7 +1023,7 @@ bool I18nSystemAddon::ParseTemperatureType(napi_env env, napi_callback_info info
         return false;
     }
     if (argc < 1) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, NAME_OF_TEMPERATURE, "", true);
+        ErrorUtil::NapiEmptyError(env, NAME_OF_TEMPERATURE);
         return false;
     }
     napi_valuetype valueType = napi_valuetype::napi_undefined;
@@ -1012,7 +1033,7 @@ bool I18nSystemAddon::ParseTemperatureType(napi_env env, napi_callback_info info
         return false;
     }
     if (valueType != napi_valuetype::napi_number) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, NAME_OF_TEMPERATURE, TYPE_OF_TEMPERATURE, true);
+        ErrorUtil::NapiTypeError(env, NAME_OF_TEMPERATURE, TYPE_OF_TEMPERATURE);
         return false;
     }
     int32_t temperatureType = 0;
@@ -1037,7 +1058,7 @@ napi_value I18nSystemAddon::SetFirstDayOfWeek(napi_env env, napi_callback_info i
         return nullptr;
     }
     if (argc < 1) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, NAME_OF_WEEKDAY, "", true);
+        ErrorUtil::NapiEmptyError(env, NAME_OF_WEEKDAY);
         return nullptr;
     }
     napi_valuetype valueType = napi_valuetype::napi_undefined;
@@ -1047,7 +1068,7 @@ napi_value I18nSystemAddon::SetFirstDayOfWeek(napi_env env, napi_callback_info i
         return nullptr;
     }
     if (valueType != napi_valuetype::napi_number) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, NAME_OF_WEEKDAY, TYPE_OF_WEEKDAY, true);
+        ErrorUtil::NapiTypeError(env, NAME_OF_WEEKDAY, TYPE_OF_WEEKDAY);
         return nullptr;
     }
     int32_t weekDay = 0;
@@ -1063,13 +1084,13 @@ napi_value I18nSystemAddon::SetFirstDayOfWeek(napi_env env, napi_callback_info i
     }
     switch (err) {
         case I18nErrorCode::NOT_SYSTEM_APP:
-            ErrorUtil::NapiThrow(env, I18N_NOT_SYSTEM_APP, "", "", true);
+            ErrorUtil::NapiSyetemError(env);
             break;
         case I18nErrorCode::NO_PERMISSION:
-            ErrorUtil::NapiThrow(env, I18N_NO_PERMISSION, "", "", true);
+            ErrorUtil::NapiPermissionError(env);
             break;
         case I18nErrorCode::INVALID_WEEK_DAY:
-            ErrorUtil::NapiThrow(env, I18N_NOT_VALID, NAME_OF_WEEKDAY, TYPE_OF_WEEKDAY, true);
+            ErrorUtil::NapiInvalidError(env, NAME_OF_WEEKDAY, TYPE_OF_WEEKDAY);
             break;
         default:
             HILOG_ERROR_I18N("I18nSystemAddon::SetFirstDayOfWeek: set first day of week failed.");
@@ -1106,7 +1127,7 @@ napi_value I18nSystemAddon::GetSimplifiedLanguage(napi_env env, napi_callback_in
         }
         if (valueType != napi_valuetype::napi_string) {
             HILOG_ERROR_I18N("GetSimplifiedLanguage Parameter type is not string");
-            ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "language", "string", true);
+            ErrorUtil::NapiTypeError(env, "language", "string");
             return nullptr;
         }
         int code = 0;
@@ -1119,7 +1140,7 @@ napi_value I18nSystemAddon::GetSimplifiedLanguage(napi_env env, napi_callback_in
         simplifiedLanguage = LocaleConfig::GetSimplifiedLanguage(language, code);
         if (code != 0) {
             HILOG_ERROR_I18N("GetSimplifiedLanguage: language is not valid");
-            ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "language", "a valid language", true);
+            ErrorUtil::NapiInvalidError(env, "language", "a valid language");
             return nullptr;
         }
     } else {
diff --git a/interfaces/js/kits/src/i18n_timezone_addon.cpp b/interfaces/js/kits/src/i18n_timezone_addon.cpp
index c99de0f995618254ae8f8e4770fa52fcd454c0ab..40f31ec610ba9b94c6897f299d8a66c3faecd239 100644
--- a/interfaces/js/kits/src/i18n_timezone_addon.cpp
+++ b/interfaces/js/kits/src/i18n_timezone_addon.cpp
@@ -285,7 +285,7 @@ napi_value I18nTimeZoneAddon::GetTimezonesByLocation(napi_env env, napi_callback
     }
     if (argc < FUNC_ARGS_COUNT) {
         HILOG_ERROR_I18N("GetTimezonesByLocation: Missing parameter");
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "longitude or latitude", true);
+        ErrorUtil::NapiEmptyError(env, "longitude or latitude");
         return nullptr;
     }
     double x;
@@ -294,7 +294,7 @@ napi_value I18nTimeZoneAddon::GetTimezonesByLocation(napi_env env, napi_callback
     VariableConvertor::VerifyType(env, "latitude", napi_valuetype::napi_number, argv[1]);
     if (!CheckLongitudeTypeAndScope(env, argv[0], x) ||
         !CheckLatitudeTypeAndScope(env, argv[1], y)) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "longitude or latitude", "a valid value", true);
+        ErrorUtil::NapiInvalidError(env, "longitude or latitude", "a valid value");
         return nullptr;
     }
     napi_value timezoneList = nullptr;
diff --git a/interfaces/js/kits/src/simple_date_time_format_addon.cpp b/interfaces/js/kits/src/simple_date_time_format_addon.cpp
index f10e2b9431b884973e9fbcb4de6c7e57cbbe4cd6..ebf666b11dd6bf6aef51c8ead9fc040b16c0f84c 100644
--- a/interfaces/js/kits/src/simple_date_time_format_addon.cpp
+++ b/interfaces/js/kits/src/simple_date_time_format_addon.cpp
@@ -141,7 +141,7 @@ napi_value SimpleDateTimeFormatAddon::Format(napi_env env, napi_callback_info in
         return VariableConvertor::CreateString(env, "");
     }
     if (argc < 1) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "date", "", true);
+        ErrorUtil::NapiEmptyError(env, "date");
         return VariableConvertor::CreateString(env, "");
     }
     int64_t milliseconds = 0;
@@ -178,7 +178,7 @@ std::vector<napi_value> SimpleDateTimeFormatAddon::GenerateParameter(napi_env en
     }
     std::string type = isBestPattern ? "pattern" : "skeleton";
     if (argc < 1) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, type, "", true);
+        ErrorUtil::NapiEmptyError(env, type);
         return result;
     }
 
@@ -188,7 +188,7 @@ std::vector<napi_value> SimpleDateTimeFormatAddon::GenerateParameter(napi_env en
         HILOG_ERROR_I18N("GenerateParameter: Failed to get type of argv[0].");
         return result;
     } else if (valueType != napi_valuetype::napi_string) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, type, "string", true);
+        ErrorUtil::NapiTypeError(env, type, "string");
         return result;
     }
 
@@ -248,10 +248,10 @@ napi_value SimpleDateTimeFormatAddon::SimpleDateTimeFormatConstructor(napi_env e
     I18nErrorCode errCode = I18nErrorCode::SUCCESS;
     obj->simpleDateTimeFormat_ = std::make_unique<SimpleDateTimeFormat>(skeleton, localeInfo, isBestPattern, errCode);
     if (errCode == I18nErrorCode::INVALID_DATE_TIME_FORMAT_SKELETON) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "skeleton", "a valid date time format skeleton", true);
+        ErrorUtil::NapiInvalidError(env, "skeleton", "a valid date time format skeleton");
         return nullptr;
     } else if (errCode == I18nErrorCode::INVALID_DATE_TIME_FORMAT_PATTERN) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "pattern", "a valid date time format pattern", true);
+        ErrorUtil::NapiInvalidError(env, "pattern", "a valid date time format pattern");
         return nullptr;
     } else if (!obj->simpleDateTimeFormat_ || errCode != I18nErrorCode::SUCCESS) {
         HILOG_ERROR_I18N("SimpleDateTimeFormatConstructor: Construct SimpleDateTimeFormat failed.");
@@ -269,7 +269,7 @@ bool SimpleDateTimeFormatAddon::GetDateTime(napi_env env, napi_value date, int64
         HILOG_ERROR_I18N("SimpleDateTimeFormatAddon: Failed to call napi_is_date.");
         return false;
     } else if (!isDate) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "date", "Date", true);
+        ErrorUtil::NapiTypeError(env, "date", "Date");
         return false;
     }
 
diff --git a/interfaces/js/kits/src/simple_number_format_addon.cpp b/interfaces/js/kits/src/simple_number_format_addon.cpp
index 72a6749ce20e6db410a41a1e77e47b9cf430fb05..b138937e357c823c33e46a42c44b5b126545aa08 100644
--- a/interfaces/js/kits/src/simple_number_format_addon.cpp
+++ b/interfaces/js/kits/src/simple_number_format_addon.cpp
@@ -111,7 +111,7 @@ napi_value SimpleNumberFormatAddon::Format(napi_env env, napi_callback_info info
         HILOG_ERROR_I18N("SimpleNumberFormatAddon::Format: Get cb info failed.");
         return VariableConvertor::CreateString(env, "");
     } else if (argc < 1) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "value", "", true);
+        ErrorUtil::NapiEmptyError(env, "value");
         return VariableConvertor::CreateString(env, "");
     }
 
@@ -121,7 +121,7 @@ napi_value SimpleNumberFormatAddon::Format(napi_env env, napi_callback_info info
         HILOG_ERROR_I18N("SimpleNumberFormatAddon::Format: Failed to get type of argv[0].");
         return VariableConvertor::CreateString(env, "");
     } else if (valueType != napi_valuetype::napi_number) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "value", "number", true);
+        ErrorUtil::NapiTypeError(env, "value", "number");
         return VariableConvertor::CreateString(env, "");
     }
 
@@ -157,7 +157,7 @@ napi_value SimpleNumberFormatAddon::SimpleNumberFormatConstructor(napi_env env,
         HILOG_ERROR_I18N("SimpleNumberFormatConstructor: Get cb info failed.");
         return nullptr;
     } else if (argc < 1) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "skeleton", "", true);
+        ErrorUtil::NapiEmptyError(env, "skeleton");
         return nullptr;
     }
 
@@ -187,7 +187,7 @@ napi_value SimpleNumberFormatAddon::SimpleNumberFormatConstructor(napi_env env,
     I18nErrorCode errCode = I18nErrorCode::SUCCESS;
     obj->simpleNumberFormat_ = std::make_shared<SimpleNumberFormat>(skeleton, localeInfo, errCode);
     if (errCode == I18nErrorCode::INVALID_NUMBER_FORMAT_SKELETON) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "skeleton", "a valid number format skeleton", true);
+        ErrorUtil::NapiInvalidError(env, "skeleton", "a valid number format skeleton");
         return nullptr;
     } else if (!obj->simpleNumberFormat_ || errCode != I18nErrorCode::SUCCESS) {
         HILOG_ERROR_I18N("SimpleNumberFormatConstructor: Construct SimpleNumberFormat failed.");
diff --git a/interfaces/js/kits/src/styled_number_format_addon.cpp b/interfaces/js/kits/src/styled_number_format_addon.cpp
index dc68f155e58f4b73cbe4c316a6da2b71c998ecad..c89ac550155c1e4ab737c979e9e1c4d5d3769dd1 100644
--- a/interfaces/js/kits/src/styled_number_format_addon.cpp
+++ b/interfaces/js/kits/src/styled_number_format_addon.cpp
@@ -75,7 +75,7 @@ napi_value StyledNumberFormatAddon::constructor(napi_env env, napi_callback_info
     }
 
     if (argc < 1) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "numberFormat", true);
+        ErrorUtil::NapiEmptyError(env, "numberFormat");
         return nullptr;
     }
 
@@ -85,7 +85,7 @@ napi_value StyledNumberFormatAddon::constructor(napi_env env, napi_callback_info
     GetNumberFmtOrSimpleNumberFmt(env, argv[0], &numberFormatAddon, &simpleNumberFormatAddon);
 
     if (!numberFormatAddon && !simpleNumberFormatAddon) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "numberFormat", "intl.NumberFormat or SimpleNumberFormat", true);
+        ErrorUtil::NapiTypeError(env, "numberFormat", "intl.NumberFormat or SimpleNumberFormat");
         return nullptr;
     }
 
@@ -117,7 +117,7 @@ napi_value StyledNumberFormatAddon::Format(napi_env env, napi_callback_info info
         HILOG_ERROR_I18N("StyledNumberFormatAddon::Format: Get cb info failed.");
         return VariableConvertor::CreateString(env, "");
     } else if (argc < 1) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "value", true);
+        ErrorUtil::NapiEmptyError(env, "value");
         return VariableConvertor::CreateString(env, "");
     }
 
@@ -127,7 +127,7 @@ napi_value StyledNumberFormatAddon::Format(napi_env env, napi_callback_info info
         HILOG_ERROR_I18N("StyledNumberFormatAddon::Format: Failed to get type of argv[0].");
         return VariableConvertor::CreateString(env, "");
     } else if (valueType != napi_valuetype::napi_number) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "value", "number", true);
+        ErrorUtil::NapiTypeError(env, "value", "number");
         return VariableConvertor::CreateString(env, "");
     }
 
@@ -328,7 +328,7 @@ void StyledNumberFormatAddon::GetNumberFmtOrSimpleNumberFmt(napi_env env, napi_v
         HILOG_ERROR_I18N("StyledNumberFormatAddon::constructor Failed to get type.");
         return;
     } else if (valueType != napi_valuetype::napi_object) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "intl.NumberFormat or SimpleNumberFormat", "", true);
+        ErrorUtil::NapiEmptyError(env, "intl.NumberFormat or SimpleNumberFormat");
         return;
     }
 
diff --git a/interfaces/js/kits/src/system_locale_manager_addon.cpp b/interfaces/js/kits/src/system_locale_manager_addon.cpp
index fade8db2c42b6e9fb9e297ffdf4caaef397ebfa6..66bd143084e3483775dfa6c765c05676dc3546da 100644
--- a/interfaces/js/kits/src/system_locale_manager_addon.cpp
+++ b/interfaces/js/kits/src/system_locale_manager_addon.cpp
@@ -119,7 +119,7 @@ napi_value SystemLocaleManagerAddon::GetLanguageInfoArray(napi_env env, napi_cal
         return nullptr;
     }
     if (argc < 1) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "languages", true);
+        ErrorUtil::NapiEmptyError(env, "languages");
         return nullptr;
     }
     std::vector<std::string> languageList;
@@ -139,7 +139,7 @@ napi_value SystemLocaleManagerAddon::GetLanguageInfoArray(napi_env env, napi_cal
     std::vector<LocaleItem> localeItemList =
         obj->systemLocaleManager_->GetLanguageInfoArray(languageList, options, err);
     if (err == I18nErrorCode::NOT_SYSTEM_APP) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_SYSTEM_APP, "", "", true);
+        ErrorUtil::NapiSyetemError(env);
         return nullptr;
     }
     napi_value result = CreateLocaleItemArray(env, localeItemList);
@@ -158,7 +158,7 @@ napi_value SystemLocaleManagerAddon::GetCountryInfoArray(napi_env env, napi_call
         return nullptr;
     }
     if (argc < 1) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, "regions", true);
+        ErrorUtil::NapiEmptyError(env, "regions");
         return nullptr;
     }
     std::vector<std::string> countryList;
@@ -177,7 +177,7 @@ napi_value SystemLocaleManagerAddon::GetCountryInfoArray(napi_env env, napi_call
     I18nErrorCode err;
     std::vector<LocaleItem> localeItemList = obj->systemLocaleManager_->GetCountryInfoArray(countryList, options, err);
     if (err == I18nErrorCode::NOT_SYSTEM_APP) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_SYSTEM_APP, "", "", true);
+        ErrorUtil::NapiSyetemError(env);
         return nullptr;
     }
     napi_value result = CreateLocaleItemArray(env, localeItemList);
@@ -189,7 +189,7 @@ napi_value SystemLocaleManagerAddon::GetTimeZoneCityInfoArray(napi_env env, napi
     I18nErrorCode err;
     std::vector<TimeZoneCityItem> timezoneCityItemList = SystemLocaleManager::GetTimezoneCityInfoArray(err);
     if (err == I18nErrorCode::NOT_SYSTEM_APP) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_SYSTEM_APP, "", "", true);
+        ErrorUtil::NapiSyetemError(env);
         return nullptr;
     }
     napi_value result = nullptr;
diff --git a/interfaces/js/kits/src/variable_convertor.cpp b/interfaces/js/kits/src/variable_convertor.cpp
index dd9ae2870cb8088eecc5e133298c573105ccd4bb..5903a950b36d46f7b86c98033ae33c3e643a7574 100644
--- a/interfaces/js/kits/src/variable_convertor.cpp
+++ b/interfaces/js/kits/src/variable_convertor.cpp
@@ -85,7 +85,7 @@ bool VariableConvertor::GetBoolOptionValue(napi_env env, napi_value &options, co
     napi_status status = napi_typeof(env, options, &type);
     if (status != napi_ok && type != napi_object) {
         HILOG_ERROR_I18N("option is not an object");
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, optionName, "a valid object", true);
+        ErrorUtil::NapiInvalidError(env, optionName, "a valid object");
         return false;
     }
     bool hasProperty = false;
@@ -131,7 +131,7 @@ bool VariableConvertor::GetStringArrayFromJsParam(napi_env env, napi_value &jsAr
     std::vector<std::string> &strArray)
 {
     if (jsArray == nullptr) {
-        ErrorUtil::NapiNotFoundError(env, I18N_NOT_FOUND, valueName, true);
+        ErrorUtil::NapiEmptyError(env, valueName);
         return false;
     }
     bool isArray = false;
@@ -139,7 +139,7 @@ bool VariableConvertor::GetStringArrayFromJsParam(napi_env env, napi_value &jsAr
     if (status != napi_ok) {
         return false;
     } else if (!isArray) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, valueName, "an Array", true);
+        ErrorUtil::NapiTypeError(env, valueName, "an Array");
         return false;
     }
     uint32_t arrayLength = 0;
@@ -194,7 +194,7 @@ void VariableConvertor::VerifyType(napi_env env, const std::string& valueName, n
     if (status != napi_ok || valueType != napiType) {
         auto iter = NAPI_TYPE_MAP.find(napiType);
         std::string type = iter != NAPI_TYPE_MAP.end() ? iter->second : "";
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, valueName, type, true);
+        ErrorUtil::NapiTypeError(env, valueName, type);
     }
 }
 
@@ -234,7 +234,7 @@ std::shared_ptr<LocaleInfo> VariableConvertor::ParseIntlLocale(napi_env env, nap
         HILOG_ERROR_I18N("ParseIntlLocale: Failed to get type of intlLocale.");
         return nullptr;
     } else if (valueType != napi_valuetype::napi_object) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "locale", "intl.Locale", true);
+        ErrorUtil::NapiTypeError(env, "locale", "intl.Locale");
         return nullptr;
     }
 
@@ -244,10 +244,10 @@ std::shared_ptr<LocaleInfo> VariableConvertor::ParseIntlLocale(napi_env env, nap
         HILOG_ERROR_I18N("ParseIntlLocale: Failed to unwrap intlLocale.");
         return nullptr;
     } else if (!localeInfoAddon) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_FOUND, "locale", "intl.Locale", true);
+        ErrorUtil::NapiTypeError(env, "locale", "intl.Locale");
         return nullptr;
     } else if (!localeInfoAddon->GetLocaleInfo()) {
-        ErrorUtil::NapiThrow(env, I18N_NOT_VALID, "locale", "a valid intl.Locale", true);
+        ErrorUtil::NapiInvalidError(env, "locale", "a valid intl.Locale");
         return nullptr;
     }
     return localeInfoAddon->GetLocaleInfo();