使用Node-API接口进行错误处理开发

// napi_get_last_error_info
static napi_value GetLastErrorInfo(napi_env env, napi_callback_info info)
{
    // 获取输入参数（这里以字符串message作为参数传入）
    size_t argc = 1;
    napi_value args[1] = {nullptr};
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    // 将传入的字符串参数以napi_get_value_int32取出，主动制造错误
    int32_t value = 0;
    napi_status status = napi_get_value_int32(env, args[0], &value);
    // 接口使用错误，故返回值不为napi_ok
    if (status != napi_ok) {
        OH_LOG_INFO(LOG_APP, "napi_get_value_int32 return status, status is not equal to napi_ok.");
    }
    // 调用接口napi_get_last_error_info获取最后一次错误信息
    const napi_extended_error_info *errorInfo;
    napi_get_last_error_info(env, &errorInfo);
    // 取出错误码与接口调用错误后其返回值作比较
    if (errorInfo->error_code == status) {
        OH_LOG_INFO(LOG_APP, "napi_get_last_error_info return errorInfo, error_code equal to status.");
    }
    // 取出错误消息作为返回值带出去打印
    napi_value result = nullptr;
    napi_create_string_utf8(env, errorInfo->error_message, NAPI_AUTO_LENGTH, &result);
    return result;
}

export const getLastErrorInfo: (str: string) => string; // napi_get_last_error_info

// napi_get_last_error_info
try {
  hilog.info(0x0000, 'testTag', 'Test Node-API napi_get_last_error_info: %{public}s',
    testNapi.getLastErrorInfo('message'));
  // ...
} catch (error) {
  hilog.error(0x0000, 'testTag', 'Test Node-API napi_get_last_error_info error: %{public}s', error);
  // ...
}

// napi_create_type_error
static napi_value CreateTypeError(napi_env env, napi_callback_info info)
{
    // 构造errorCode和errorMessage
    napi_value errorCode = nullptr;
    napi_create_string_utf8(env, "napi_create_error errorCode", NAPI_AUTO_LENGTH, &errorCode);
    napi_value errorMessage = nullptr;
    napi_create_string_utf8(env, "napi_create_error errorMessage", NAPI_AUTO_LENGTH, &errorMessage);
    napi_value error = nullptr;
    napi_create_type_error(env, errorCode, errorMessage, &error);
    return error;
}

export const createTypeError: () => Error; // napi_create_type_error

try {
  // ...
  throw testNapi.createTypeError();
} catch (error) { // napi_create_type_error
  hilog.error(0x0000, 'testTag',
    'Test Node-API napi_create_type_error errorCode: %{public}s, errorMessage %{public}s', error.code,
    error.message);
  // ...
}

// napi_create_range_error
static napi_value CreateRangeError(napi_env env, napi_callback_info info)
{
    // 构造errorCode和errorMessage
    napi_value errorCode = nullptr;
    napi_create_string_utf8(env, "napi_create_error errorCode", NAPI_AUTO_LENGTH, &errorCode);
    napi_value errorMessage = nullptr;
    napi_create_string_utf8(env, "napi_create_error errorMessage", NAPI_AUTO_LENGTH, &errorMessage);
    napi_value error = nullptr;
    napi_create_range_error(env, errorCode, errorMessage, &error);
    return error;
}

export const createRangeError: () => Error; // napi_create_range_error

// napi_create_range_error
try {
  // ...
  throw testNapi.createRangeError();
} catch (error) {
  hilog.error(0x0000, 'testTag',
    'Test Node-API napi_create_range_error errorCode: %{public}s, errorMessage: %{public}s',
    error.code,
    error.message);
  // ...
}

// napi_create_error and napi_throw
static napi_value NapiThrow(napi_env env, napi_callback_info info)
{
    // 代码中发生某些错误后，可执行以下操作抛出异常
    // 在Node-API环境中创建一个字符串，并将其存储在errorCode变量中
    napi_value errorCode = nullptr;
    napi_create_string_utf8(env, "throw errorCode", NAPI_AUTO_LENGTH, &errorCode);
    // 在Node-API环境中创建一个字符串，并将其存储在errorMessage变量中
    napi_value errorMessage = nullptr;
    napi_create_string_utf8(env, "throw errorMessage", NAPI_AUTO_LENGTH, &errorMessage);
    // 创建一个ArkTS对象error
    napi_value error = nullptr;
    napi_create_error(env, errorCode, errorMessage, &error);
    // 通过napi_throw接口将对象抛出
    napi_throw(env, error);
    return nullptr;
}

export const napiThrow: () => void; // napi_create_error and napi_throw

// napi_create_error and napi_throw
try {
  testNapi.napiThrow();
  // ...
} catch (error) {
  hilog.error(0x0000, 'testTag',
    'Test Node-API napi_throw errorCode: %{public}s, errorMessage: %{public}s',
    error.code, error.message);
  // ...
}

// napi_throw_error
// 这里直接抛出一个带有errorMessage的错误
static napi_value NapiThrowErrorMessage(napi_env env, napi_callback_info info)
{
    napi_throw_error(env, nullptr, "napi_throw_error throwing an error");
    return nullptr;
}

// 传入两个参数，在第二个参数，也就是除数为0的时候抛出一个错误
static napi_value NapiThrowError(napi_env env, napi_callback_info info)
{
    // ArkTS侧传入两个参数
    size_t argc = 2;
    napi_value argv[2] = {nullptr};
    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
    // 将其转换为double类型的值作为被除数和除数
    double dividend;
    double divisor;
    napi_get_value_double(env, argv[0], &dividend);
    napi_get_value_double(env, argv[1], &divisor);
    // 在这里判断除数如果为0则直接抛出一个错误，errorCode为：DIVIDE_BY_ZERO，errorMessage为：Cannot divide by zero
    if (divisor == 0) {
        napi_throw_error(env, "DIVIDE_BY_ZERO", "Cannot divide by zero");
    }
    return nullptr;
}

export const napiThrowErrorMessage: () => void; // napi_throw_error

export const napiThrowError: (dividend: number, divisor: number) => void; // napi_throw_error

// napi_throw_error
try {
  testNapi.napiThrowErrorMessage();
  // ...
} catch (error) {
  hilog.error(0x0000, 'testTag',
    'Test Node-API napi_throw_error error code: %{public}s , message: %{public}s', error.code,
    error.message);
  // ...
}
try {
  testNapi.napiThrowError(5, 0);
  // ...
} catch (error) {
  hilog.error(0x0000, 'testTag',
    'Test Node-API napi_throw_error errorCode: %{public}s , errorMessage: %{public}s', error.code,
    error.message);
  // ...
}

// napi_throw_type_error
// 这里直接抛出一个带有errorMessage的TypeError
static napi_value ThrowTypeErrorMessage(napi_env env, napi_callback_info info)
{
    napi_throw_type_error(env, nullptr, "napi_throw_type_error throwing an error");
    return nullptr;
}

// 传入一个类型不匹配的参数，判断类型不匹配之后抛出typeError
static napi_value ThrowTypeError(napi_env env, napi_callback_info info)
{
    // ArkTS侧传入一个参数
    size_t argc = 1;
    napi_value argv[1] = {nullptr};
    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
    // 将传入参数转换为napi_valuetype类型的值
    napi_valuetype valueType;
    napi_typeof(env, argv[0], &valueType);
    // 如果传入参数不为napi_number类型的值则抛出TypeError
    if (valueType != napi_number) {
        // 这里抛出一个既带有errorCode也带有errorMessage的TypeError
        napi_throw_type_error(env, "napi_throw_type_error", "Argument must be a number");
    }
    return nullptr;
}

export const throwTypeErrorMessage: () => void; // napi_throw_type_error

export const throwTypeError: (message: string) => void; // napi_throw_type_error

// napi_throw_type_error
try {
  testNapi.throwTypeErrorMessage();
  // ...
} catch (error) {
  hilog.error(0x0000, 'testTag',
    'Test Node-API napi_throw_type_error errorCode: %{public}s, errorMessage: %{public}s',
    error.code,
    error.message);
  // ...
}
try {
  testNapi.throwTypeError('str');
  // ...
} catch (error) {
  hilog.error(0x0000, 'testTag',
    'Test Node-API napi_throw_type_error errorCode: %{public}s, errorMessage: %{public}s',
    error.code,
    error.message);
  // ...
}

// napi_throw_range_error
// 这里直接抛出一个带有errorMessage的RangeError
static napi_value ThrowRangeErrorMessage(napi_env env, napi_callback_info info)
{
    napi_throw_range_error(env, nullptr, "napi_throw_range_error one");
    return nullptr;
}

// 传入不匹配的参数个数，判断不匹配之后抛出rangeError
static napi_value ThrowRangeError(napi_env env, napi_callback_info info)
{
    // ArkTS侧传入两个参数
    size_t argc = 2;
    napi_value argv[2] = {nullptr};
    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
    // 如果传入参数个数不为2
    if (argc != 2) {
        // 这里抛出一个RangeError
        napi_throw_range_error(env, "napi_throw_range_error", "Expected two numbers as arguments");
        return nullptr;
    }
    // 下面将传入的两值相加并传出去
    double numOne = 0;
    double numTwo = 0;
    napi_get_value_double(env, argv[0], &numOne);
    napi_get_value_double(env, argv[1], &numTwo);
    double result = numOne + numTwo;
    napi_value resultValue;
    napi_create_double(env, result, &resultValue);
    return resultValue;
}

export const throwRangeErrorMessage: () => void; // napi_throw_range_error

export const throwRangeError: (num: number) => number | undefined; // napi_throw_range_error

// napi_throw_range_error
try {
  testNapi.throwRangeErrorMessage();
  // ...
} catch (error) {
  hilog.error(0x0000, 'testTag',
    'Test Node-API napi_throw_range_error errorCode: %{public}s, errorMessage: %{public}s',
    error.code,
    error.message);
  // ...
}

try {
  testNapi.throwRangeError(1);
  // ...
} catch (error) {
  hilog.error(0x0000, 'testTag',
    'Test Node-API napi_throw_range_error errorCode: %{public}s, errorMessage: %{public}s',
    error.code,
    error.message);
  // ...
}

// napi_is_error
static napi_value NapiIsError(napi_env env, napi_callback_info info)
{
    // 接收一个入参
    size_t argc = 1;
    napi_value args[1] = {nullptr};
    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    // 调用接口napi_is_error判断入参是否为一个error对象
    bool result = false;
    // 如果napi_value为一个error对象，则设置result为true的布尔值，否则设置为false
    napi_is_error(env, args[0], &result);
    // 取出result通过napi_get_boolean接口将取出的bool值转换为napi_value类型的值返回出去
    napi_value returnValue = nullptr;
    napi_get_boolean(env, result, &returnValue);
    return returnValue;
}

export const napiIsError: <T>(obj: T) => boolean; // napi_is_error

// napi_is_error
try {
  // ...
  throw new Error("throwing an error");
} catch (error) {
  hilog.error(0x0000, 'testTag', 'Test Node-API napi_is_error error: %{public}s',
    testNapi.napiIsError(error)
      .toString());
  hilog.error(0x0000, 'testTag', 'Test Node-API napi_is_error error: %{public}s',
    testNapi.napiIsError(1)
      .toString());
  // ...
}

// napi_get_and_clear_last_exception
static napi_value GetAndClearLastException(napi_env env, napi_callback_info info)
{
    // 抛出异常，创造异常情况
    napi_throw_error(env, "napi_create_error errorCode", "napi_create_error errorMessage");
    // 调用napi_get_and_clear_last_exception接口获取并清除最后一个未处理的异常。即使存在挂起的ArkTS异常，也可以调用此API
    napi_value result = nullptr;
    napi_status status = napi_get_and_clear_last_exception(env, &result);
    if (status != napi_ok) {
        return nullptr;
    }
    return result;
}

export const getAndClearLastException: () => Error | undefined; // napi_get_and_clear_last_exception

// napi_get_and_clear_last_exception
// 这里获取到最后一个未处理的异常
let exception = testNapi.getAndClearLastException();
hilog.info(0x0000, 'testTag',
  'Test Node-API napi_get_and_clear_last_exception, error.message: %{public}s',
  exception ? exception.message : '');

// napi_is_exception_pending
static napi_value IsExceptionPending(napi_env env, napi_callback_info info)
{
    napi_status status;
    bool isExceptionPending = false;
    // 在执行一些可能引发异常的操作后
    napi_throw_error(env, "napi_create_error errorCode", "napi_create_error errorMessage");
    // 检查当前环境中是否有异常挂起
    status = napi_is_exception_pending(env, &isExceptionPending);
    if (status != napi_ok) {
        return nullptr;
    }
    if (isExceptionPending) {
        // 处理异常挂起的情况
        napi_value result = nullptr;
        status = napi_get_and_clear_last_exception(env, &result);
        if (status != napi_ok) {
            return nullptr;
        }
        // 将处理的异常返回出去
        return result;
    }
    return nullptr;
}

export const isExceptionPending: () => Object | undefined; // napi_is_exception_pending

// napi_is_exception_pending
interface MyObject {
  code: string;
  message: string;
}

try {
  let result = testNapi.isExceptionPending() as MyObject;
  hilog.info(0x0000, 'testTag',
    'Test Node-API napi_is_exception_pending, error.Code: %{public}s, error.message: %{public}s',
    result.code, result.message);
  // ...
} catch (error) {
  hilog.error(0x0000, 'testTag', 'Test Node-API napi_is_exception_pending error');
  // ...
}

// napi_fatal_error
static napi_value FatalError(napi_env env, napi_callback_info info)
{
    // 请注意，使用napi_fatal_error函数会导致应用进程直接终止，因此应该谨慎使用，仅在遇到无法恢复的严重错误时才应该调用该函数
    // 模拟一个致命错误条件
    bool errorCondition = true;
    if (errorCondition) {
        // 创建一个致命错误信息
        napi_fatal_error("napi_fatal_error test", NAPI_AUTO_LENGTH, "napi_create_error errorMessage", NAPI_AUTO_LENGTH);
    }
    return nullptr;
}

export const fatalError: () => void; // napi_fatal_error

// napi_fatal_error 请注意，使用napi_fatal_error函数会导致应用进程直接终止，因此应该谨慎使用，仅在遇到无法恢复的严重错误时才应该调用该函数
// 模拟一个致命错误条件
try {
  testNapi.fatalError();
  // ...
} catch (error) {
  hilog.error(0x0000, 'testTag', 'Test Node-API napi_fatal_error error');
  // ...
}

// napi_fatal_exception
static napi_value FatalException(napi_env env, napi_callback_info info)
{
    size_t argc = 1;
    napi_value args[1] = {nullptr};

    napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    if (status != napi_ok) {
        return nullptr;
    }
    // 请注意，使用napi_fatal_exception函数会导致应用进程直接终止，因此应该谨慎使用，仅在主线程遇到无法恢复的严重错误时才应该调用该函数
    // 模拟一个致命错误条件
    status = napi_fatal_exception(env, args[0]);
    if (status != napi_ok) {
        return nullptr;
    }
    return nullptr;
}

export const fatalException: (err: Error) => void; // napi_fatal_exception

const err = new Error("a fatal exception occurred");
testNapi.fatalException(err);