@ohos.util (util)

The util module provides common utility functions, such as TextEncoder and TextDecoder for string encoding and decoding, RationalNumber⁸⁺ for rational number operations, LRUCache⁹⁺ for cache management, ScopeHelper⁹⁺ for range determination, Base64Helper⁹⁺ for Base64 encoding and decoding, types⁸⁺ for built-in object type check, and Aspect¹¹⁺ for instrumentation and replacement on methods.

NOTE

The initial APIs of this module are supported since API version 7. Newly added APIs will be marked with a superscript to indicate their earliest API version.

Modules to Import

import { util } from '@kit.ArkTS';

util.format⁹⁺

format(format: string, ...args: Object[]): string

Formats a string by replacing the placeholders in it.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
format	string	Yes	Format string. This string contains zero or more placeholders, which specify the position and format of the arguments to be inserted.
...args	Object[]	No	Data used to replace the placeholders in format. If null is passed in, the first argument is returned by default.

Return value

Type	Description
string	Formatted string.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Format Specifiers

Specifier	Description
%s	Converts a parameter into a string for all values except Object, BigInt, and -0.
%d	Converts a parameter into a decimal integer for all values except Symbol and BigInt.
%i	Converts a string into a decimal integer for all values except Symbol and BigInt.
%f	Converts a string into a floating point number for all values except BigInt and Symbol.
%j	Converts a JavaScript object into a JSON string.
%o	Converts a JavaScript object into a string, without containing the prototype chain information of the object.
%O	Converts a JavaScript object into a string.
%c	Valid only in the browser. It is ignored in other environments.
%%	Placeholder for escaping the percent sign.

Example

import { util } from '@kit.ArkTS';

interface utilAddressType {
  city: string;
  country: string;
}
interface utilPersonType {
  name: string;
  age: number;
  address: utilAddressType;
}

let name = 'John';
let age = 20;
let formattedString = util.format('My name is %s and I am %s years old', name, age);
console.info(formattedString);
// Output: My name is John and I am 20 years old
let num = 10.5;
formattedString = util.format('The number is %d', num);
console.info(formattedString);
// Output: The number is 10.5.
num = 100.5;
formattedString = util.format('The number is %i', num);
console.info(formattedString);
// Output: The number is 100.
const pi = 3.141592653;
formattedString = util.format('The value of pi is %f', pi);
console.info(formattedString);
// Output: The value of pi is 3.141592653
const obj: Record<string,number | string> = { "name": 'John', "age": 20 };
formattedString = util.format('The object is %j', obj);
console.info(formattedString);
// Output: The object is {"name":"John","age":20}.
const person: utilPersonType = {
  name: 'John',
  age: 20,
  address: {
    city: 'New York',
    country: 'USA'
  }
};
console.info(util.format('Formatted object using %%O: %O', person));
console.info(util.format('Formatted object using %%o: %o', person));
/*
Output:
Formatted object using %O: { name: 'John',
  age: 20,
  address:
  { city: 'New York',
    country: 'USA' } }
Formatted object using %o: { name: 'John',
  age: 20,
  address:
  { city: 'New York',
    country: 'USA' } }
*/
const percentage = 80;
let arg = 'homework';
formattedString = util.format('John finished %d%% of the %s', percentage, arg);
console.info(formattedString);
// Output: John finished 80% of the homework

util.errnoToString⁹⁺

errnoToString(errno: number): string

Obtains detailed information about a system error code.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
errno	number	Yes	Error code generated.

Return value

Type	Description
string	Detailed information about the error code.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let errnum = -1; // -1 is a system error code.
let result = util.errnoToString(errnum);
console.info("result = " + result);
// Output: result = operation not permitted

Some error code and message examples

Error Code	Message
-1	operation not permitted
-2	no such file or directory
-3	no such process
-4	interrupted system call
-5	i/o error
-11	resource temporarily unavailable
-12	not enough memory
-13	permission denied
-100	network is down

util.callbackWrapper

callbackWrapper(original: Function): (err: Object, value: Object)=>void

Calls back an asynchronous function. In the callback, the first parameter indicates the cause of the rejection (the value is null if the promise has been resolved), and the second parameter indicates the resolved value.

NOTE

• original must be an asynchronous function. If a non-asynchronous function is passed in, the function is not intercepted, but the error message "callbackWrapper: The type of Parameter must be AsyncFunction" is displayed.

• This API converts an async function that returns a promise into an error-first callback function. The function returned by this API accepts a callback as its second input parameter. When this method is called, the original function is executed first. When the promise of original returns resolve, the first parameter of the callback function is null, and the second parameter is the value of resolve. When the promise of original returns reject, the first parameter of the callback function is an error object, and the second parameter is null. When original is a function without input parameters, the first input parameter of the function returned by this API must be an invalid placeholder parameter.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
original	Function	Yes	Asynchronous function.

Return value

Type	Description
(err: Object, value: Object)=>void	Callback function, in which the first parameter err indicates the cause of the rejection (the value is null if the promise has been resolved) and the second parameter value indicates the resolved value.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

async function fn(input: string) {
  return input;
}
let cb = util.callbackWrapper(fn);
cb('hello world', (err : Object, ret : string) => {
  if (err) throw new Error;
  console.info(ret);
});
// Output: hello world

util.promisify⁹⁺

promisify(original: (err: Object, value: Object) => void): Function

Receives a function that uses the error-first callback mode, that is, uses (err, value) => callback as the last parameter, and uses a promise to return the result.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
original	(err: Object, value: Object) => void	Yes	Function, in which the first parameter err indicates the cause of the rejection (the value is null if the promise has been resolved) and the second parameter value indicates the resolved value.

Return value

Type	Description
Function	Promise function.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

async function fn() {
  return 'hello world';
}
const addCall = util.promisify(util.callbackWrapper(fn));
(async () => {
  try {
    let res: string = await addCall();
    console.info(res);
    // Output: hello world
  } catch (err) {
    console.info(err);
  }
})();

util.generateRandomUUID⁹⁺

generateRandomUUID(entropyCache?: boolean): string

Uses a secure random number generator to generate a random universally unique identifier (UUID) of the string type in RFC 4122 version 4. To improve performance, this API uses cached UUIDs by default, in which entropyCache is set to true. A maximum of 128 random UUIDs can be cached. After all the 128 UUIDs in the cache are used, a new set of UUIDs is generated to maintain their random distribution. If you do not need to use the cached UUID, set entropyCache to false.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
entropyCache	boolean	No	Whether to use a cached UUID. The value true means to use a cached UUID, and false means the opposite. The default value is true.

Return value

Type	Description
string	A string representing the UUID generated.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Incorrect parameter types.

Example

let uuid = util.generateRandomUUID(true);
console.info("RFC 4122 Version 4 UUID:" + uuid);
// Output a random UUID.

util.generateRandomBinaryUUID⁹⁺

generateRandomBinaryUUID(entropyCache?: boolean): Uint8Array

Uses a secure random number generator to generate a random universally unique identifier (UUID) of RFC 4122 version 4.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
entropyCache	boolean	No	Whether to use a cached UUID. The value true means to use a cached UUID, and false means the opposite. The default value is true.

Return value

Type	Description
Uint8Array	A Uint8Array value representing the UUID generated.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Incorrect parameter types.

Example

let uuid = util.generateRandomBinaryUUID(true);
console.info(JSON.stringify(uuid));
// Output a random UUID.

util.parseUUID⁹⁺

parseUUID(uuid: string): Uint8Array

Converts a UUID of the string type generated by generateRandomUUID to a UUID generated by generateRandomBinaryUUID, as described in RFC 4122.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
uuid	string	Yes	A string representing the UUID.

Return value

Type	Description
Uint8Array	A Uint8Array value representing the UUID parsed. If the parsing fails, SyntaxError is thrown.

Error codes

For details about the error codes, see Universal Error Codes and Utils Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Incorrect parameter types.
10200002	Invalid uuid string.

Example

let uuid = util.parseUUID("84bdf796-66cc-4655-9b89-d6218d100f9c");
console.info("uuid = " + uuid);
// Output: uuid = 132,189,247,150,102,204,70,85,155,137,214,33,141,16,15,156

util.printf^(deprecated)

printf(format: string, ...args: Object[]): string

Formats a string by replacing the placeholders in it.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use util.format⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
format	string	Yes	Format string.
...args	Object[]	No	Data used to replace the placeholders in format. If null is passed in, the first argument is returned by default.

Return value

Type	Description
string	String containing the formatted values.

Example

let res = util.printf("%s", "hello world!");
console.info(res);
// Output: hello world!

util.getErrorString^(deprecated)

getErrorString(errno: number): string

Obtains detailed information about a system error code.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use util.errnoToString⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
errno	number	Yes	Error code generated.

Return value

Type	Description
string	Detailed information about the error code.

Example

let errnum = -1; // -1 is a system error code.
let result = util.getErrorString(errnum);
console.info("result = " + result);
// Output: result = operation not permitted

util.promiseWrapper^(deprecated)

promiseWrapper(original: (err: Object, value: Object) => void): Object

Receives a function that uses the error-first callback mode, that is, uses (err, value) => callback as the last parameter, and uses a promise to return the result.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use util.promisify⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
original	(err: Object, value: Object) => void	Yes	Asynchronous function.

Return value

Type	Description
Object	Promise in the error-first style (that is, (err, value) => ... is called as the last parameter).

util.getHash¹²⁺

getHash(object: object): number

Obtains the hash value of an object.

If no hash value has been obtained, a random hash value is generated, saved to the hash field of the object, and returned. If a hash value has been obtained, the hash value saved in the hash field is returned (the same value is returned for the same object).

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
object	object	Yes	Object whose hash value is to be obtained.

Return value

Type	Description
number	Hash value.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

interface Person {
  name: string,
  age: number
}
let obj: Person = { name: 'Jack', age: 20 };
let result1 = util.getHash(obj);
console.info('result1 is ' + result1);
let result2 = util.getHash(obj);
console.info('result2 is ' + result2);
// Output: The values of result1 and result2 are the same and are a random hash value.

util.getMainThreadStackTrace²⁰⁺

getMainThreadStackTrace(): string

Obtains the stack trace information of the main thread. A maximum of 64 call frames can be returned.

This API may affect the performance of the main thread. You are advised to use this API only when necessary, such as in log recording, error analysis, or debugging scenarios.

Atomic service API: This API can be used in atomic services since API version 20.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
string	Stack trace information of the main thread. If the main thread is not executing JavaScript code, an empty string is returned.

Example

let stack = util.getMainThreadStackTrace();
console.info(stack);
// Obtain the stack trace information of the main thread.

ArkTSVM²³⁺

A class that provides VM maintenance and test capabilities for developers.

setMultithreadingDetectionEnabled²³⁺

static setMultithreadingDetectionEnabled(enabled: boolean): void

Sets whether to enable multithreading detection. When enabled is set to true, the detection is turned on, and multithreading-related details will be included in the cppcrash files generated for multithreading issues. When enabled is set to false, the detection is turned off, and no such details will be present in the corresponding cppcrash files.

Model restriction: This API can be used only in the stage model.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
enabled	boolean	Yes	Controls whether to enable multithreading detection. true means enabling the detection, and false means disabling it.

Example

import { util } from '@kit.ArkTS';

// Enable multithreading detection.
util.ArkTSVM.setMultithreadingDetectionEnabled(true);
// Disable multithreading detection.
util.ArkTSVM.setMultithreadingDetectionEnabled(false);

TextDecoderOptions¹¹⁺

Describes decoding-related options, which include fatal and ignoreBOM.

Atomic service API: This API can be used in atomic services since API version 11.

System capability: SystemCapability.Utils.Lang

Name	Type	Read-Only	Optional	Description
fatal	boolean	No	Yes	Whether to display fatal errors. The value true means to display fatal errors, and false means the opposite. The default value is false.
ignoreBOM	boolean	No	Yes	Whether to ignore the BOM. The value true means to ignore the BOM, and false means the opposite. The default value is false.

DecodeToStringOptions¹²⁺

Describes the behavioral parameters for the decodeToString method when decoding byte streams.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Name	Type	Read-Only	Optional	Description
stream	boolean	No	Yes	Whether the incomplete byte sequence at the end of the input needs to be appended to the parameter for the next call of decodeToString. The value true means that the incomplete byte sequence is stored in the internal buffer until the function is called next time. If the value is false, the byte sequence is directly decoded when the function is called currently. The default value is false.

DecodeWithStreamOptions¹¹⁺

Defines whether decoding follows data blocks.

Atomic service API: This API can be used in atomic services since API version 11.

System capability: SystemCapability.Utils.Lang

Name	Type	Read-Only	Optional	Description
stream	boolean	No	Yes	Whether to allow data blocks in subsequent decodeWithStream(). If data is processed in blocks, set this parameter to true. If this is the last data block to process or data is not divided into blocks, set this parameter to false. The default value is false.

Aspect¹¹⁺

Provides APIs that support Aspect Oriented Programming (AOP). These APIs can be used to perform instrumentation or replacement on class methods.

addBefore¹¹⁺

static addBefore(targetClass: Object, methodName: string, isStatic: boolean, before: Function): void

Inserts a function before a method of a class object. The inserted function is executed in prior to the original method of the class object.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
targetClass	Object	Yes	Target class object.
methodName	string	Yes	Name of the method. Read-only methods are not supported.
isStatic	boolean	Yes	Whether the method is a static method. The value true means a static method, and false means an instance method.
before	Function	Yes	Function to insert. If the function carries parameters, then the first parameter is the this object, which is the target class object (specified by targetClass) if isStatic is true or the instance object of the method if isStatic is false; other parameters are the parameters carried in the original method. If the function does not carry any parameter, no processing is performed.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

class MyClass {
  msg: string = 'msg000';
  foo(arg: string): string {
    console.info('foo arg is ' + arg);
    return this.msg;
  }

  static data: string = 'data000';
  static bar(arg: string): string {
    console.info('bar arg is ' + arg);
    return MyClass.data;
  }
}

let asp = new MyClass();
let result = asp.foo('123');
// Output: foo arg is 123
console.info('result is ' + result);
// Output: result is msg000
console.info('asp.msg is ' + asp.msg);
// Output: asp.msg is msg000

util.Aspect.addBefore(MyClass, 'foo', false, (instance: MyClass, arg: string) => {
  console.info('arg is ' + arg);
  instance.msg = 'msg111';
  console.info('msg is changed to ' + instance.msg);
});

result = asp.foo('123');
// Output: arg is 123
// Output: msg is changed to msg111
// Output: foo arg is 123
console.info('result is ' + result);
// Output: result is msg111
console.info('asp.msg is ' + asp.msg);
// Output: asp.msg is msg111


let res = MyClass.bar('456');
// Output: bar arg is 456
console.info('res is ' + res);
// Output: res is data000
console.info('MyClass.data is ' + MyClass.data);
// Output: MyClass.data is data000

util.Aspect.addBefore(MyClass, 'bar', true, (target: Object, arg: string) => {
  console.info('arg is ' + arg);
  let newVal = 'data111';
  Reflect.set(target, 'data', newVal);
  console.info('data is changed to ' + newVal);
});

res = MyClass.bar('456');
// Output: arg is 456
// Output: data is changed to data111
// Output: bar arg is 456
console.info('res is ' + res);
//Output: res is data111
console.info('MyClass.data is ' + MyClass.data);
// Output: MyClass.data is data111

addAfter¹¹⁺

static addAfter(targetClass: Object, methodName: string, isStatic: boolean, after: Function): void

Inserts a function after a method of a class object. The final return value is the return value of the function inserted.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
targetClass	Object	Yes	Target class object.
methodName	string	Yes	Name of the method. Read-only methods are not supported.
isStatic	boolean	Yes	Whether the method is a static method. The value true means a static method, and false means an instance method.
after	Function	Yes	Function to insert. If the function carries parameters, then the first parameter is the this object, which is the target class object (specified by targetClass) if isStatic is true or the instance object of the method if isStatic is false; the second parameter is the return value of the original method (undefined if the original method does not have a return value); other parameters are the parameters carried by the original method. If the function does not carry any parameter, no processing is performed.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

class MyClass {
  msg: string = 'msg000';
  foo(arg: string): string {
    console.info('foo arg is ' + arg);
    return this.msg;
  }
}

let asp = new MyClass();
let result = asp.foo('123');
// Output: foo arg is 123
console.info('result is ' + result);
// Output: result is msg000
console.info('asp.msg is ' + asp.msg);
// Output: asp.msg is msg000

util.Aspect.addAfter(MyClass, 'foo', false, (instance: MyClass, ret: string, arg: string): string => {
  console.info('arg is ' + arg);
  console.info('ret is ' + ret);
  instance.msg = 'msg111';
  console.info('msg is changed to ' + instance.msg);
  return 'msg222';
});

result = asp.foo('123');
// Output: foo arg is 123
// Output: arg is 123
// Output: ret is msg000
// Output: msg is changed to msg111
console.info('result is ' + result);
// Output: result is msg222
console.info('asp.msg is ' + asp.msg);
// Output: asp.msg is msg111

// Examples of addBefore() and addAfter()
class AroundTest {
  foo(arg: string) {
    console.info('execute foo with arg ' + arg);
  }
}
util.Aspect.addBefore(AroundTest, 'foo', false, () => {
  console.info('execute before');
});
util.Aspect.addAfter(AroundTest, 'foo', false, () => {
  console.info('execute after');
});

(new AroundTest()).foo('hello');
// Output: execute before
// Output: execute foo with arg hello
// Output: execute after

replace¹¹⁺

static replace(targetClass: Object, methodName: string, isStatic: boolean, instead: Function) : void

Replaces a method of a class object with another function. After the replacement, only the new function logic is executed. The final return value is the return value of the new function.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
targetClass	Object	Yes	Target class object.
methodName	string	Yes	Name of the method. Read-only methods are not supported.
isStatic	boolean	Yes	Whether the method is a static method. The value true means a static method, and false means an instance method.
instead	Function	Yes	Function to be used replacement. If the function carries parameters, then the first parameter is the this object, which is the target class object (specified by targetClass) if isStatic is true or the instance object of the method if isStatic is false; other parameters are the parameters carried in the original method. If the function does not carry any parameter, no processing is performed.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

class MyClass {
  msg: string = 'msg000';
  foo(arg: string): string {
    console.info('foo arg is ' + arg);
    return this.msg;
  }
}

let asp = new MyClass();
let result = asp.foo('123');
// Output: foo arg is 123
console.info('result is ' + result);
// Output: result is msg000
console.info('asp.msg is ' + asp.msg);
// Output: asp.msg is msg000

util.Aspect.replace(MyClass, 'foo', false, (instance: MyClass, arg: string): string => {
  console.info('execute instead');
  console.info('arg is ' + arg);
  instance.msg = 'msg111';
  console.info('msg is changed to ' + instance.msg);
  return 'msg222';
});

result = asp.foo('123');
// Output: execute instead
// Output: arg is 123
// Output: msg is changed to msg111
console.info('result is ' + result);
// Output: result is msg222
console.info('asp.msg is ' + asp.msg);
// Output: asp.msg is msg111

TextDecoder

Provides APIs to decode byte arrays into strings. It supports multiple formats, including UTF-8, UTF-16LE, UTF-16BE, ISO-8859, and Windows-1251.

Properties

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Name	Type	Read-Only	Optional	Description
encoding	string	Yes	No	Encoding format. The following formats are supported: utf-8, ibm866, iso-8859-2, iso-8859-3, iso-8859-4, iso-8859-5, iso-8859-6, iso-8859-7, iso-8859-8, iso-8859-8-i, iso-8859-10, iso-8859-13, iso-8859-14, iso-8859-15, koi8-r, koi8-u, macintosh, windows-874, windows-1250, windows-1251, windows-1252, windows-1253, windows-1254, windows-1255, windows-1256, windows-1257, windows-1258, x-mac-cyrillic, gbk, gb18030, big5, euc-jp, iso-2022-jp, shift_jis, euc-kr, utf-16be, utf-16le, gb2312, and iso-8859-1.
fatal	boolean	Yes	No	Whether to display fatal errors. The value true means to display fatal errors, and false means the opposite.
ignoreBOM	boolean	Yes	No	Whether to ignore the byte order marker (BOM). The default value is false, which indicates that the result contains the BOM.

constructor⁹⁺

constructor()

A constructor used to create a TextDecoder object.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Example

let textDecoder = new util.TextDecoder();
let retStr = textDecoder.encoding;
console.info('retStr = ' + retStr);
// Output: retStr = utf-8

create⁹⁺

static create(encoding?: string, options?: TextDecoderOptions): TextDecoder

Creates a TextDecoder object. It provides the same function as the deprecated argument constructor.

Atomic service API: This API can be used in atomic services since API version 11.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
encoding	string	No	Encoding format. The default format is 'utf-8'.
options	TextDecoderOptions	No	Decoding-related options, which include fatal and ignoreBOM.

Return value

Type	Description
TextDecoder	TextDecoder object created.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Incorrect parameter types.

Example

let textDecoderOptions: util.TextDecoderOptions = {
  fatal: false,
  ignoreBOM : true
}
let textDecoder = util.TextDecoder.create('utf-8', textDecoderOptions);
let retStr = textDecoder.encoding;
console.info('retStr = ' + retStr);
// Output: retStr = utf-8

decodeToString¹²⁺

decodeToString(input: Uint8Array, options?: DecodeToStringOptions): string

Decodes the input content into a string.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
input	Uint8Array	Yes	Uint8Array object to decode.
options	DecodeToStringOptions	No	Decoding-related options. The default value is undefined.

Return value

Type	Description
string	String obtained.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let textDecoderOptions: util.TextDecoderOptions = {
  fatal: false,
  ignoreBOM : true
}
let decodeToStringOptions: util.DecodeToStringOptions = {
  stream: false
}
let textDecoder = util.TextDecoder.create('utf-8', textDecoderOptions);
let uint8 = new Uint8Array([0xEF, 0xBB, 0xBF, 0x61, 0x62, 0x63]);
let retStr = textDecoder.decodeToString(uint8, decodeToStringOptions);
console.info("retStr = " + retStr);
// Output: retStr = abc

decodeWithStream^(deprecated)

decodeWithStream(input: Uint8Array, options?: DecodeWithStreamOptions): string

Decodes the input content into a string. If input is an empty array, undefined is returned.

NOTE

This API is supported since API version 9 and deprecated since API version 12. You are advised to use decodeToString¹²⁺ instead.

Atomic service API: This API can be used in atomic services since API version 11.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
input	Uint8Array	Yes	Uint8Array object to decode.
options	DecodeWithStreamOptions	No	Decoding-related options.

Return value

Type	Description
string	String obtained.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let textDecoderOptions: util.TextDecoderOptions = {
  fatal: false,
  ignoreBOM : true
}
let decodeWithStreamOptions: util.DecodeWithStreamOptions = {
  stream: false
}
let textDecoder = util.TextDecoder.create('utf-8', textDecoderOptions);
let uint8 = new Uint8Array(6);
uint8[0] = 0xEF;
uint8[1] = 0xBB;
uint8[2] = 0xBF;
uint8[3] = 0x61;
uint8[4] = 0x62;
uint8[5] = 0x63;
console.info("input num:");
let retStr = textDecoder.decodeWithStream(uint8, decodeWithStreamOptions);
console.info("retStr = " + retStr);
// Output: retStr = abc

constructor^(deprecated)

constructor(encoding?: string, options?: { fatal?: boolean; ignoreBOM?: boolean })

A constructor used to create a TextDecoder object.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use create⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
encoding	string	No	Encoding format. The default format is 'utf-8'.
options	{ fatal?: boolean; ignoreBOM?: boolean }	No	Decoding-related options, which include fatal and ignoreBOM.

Table 1 options

Name	Type	Mandatory	Description
fatal	boolean	No	Whether to display fatal errors. The value true means to display fatal errors, and false means the opposite. The default value is false.
ignoreBOM	boolean	No	Whether to ignore the BOM. The value true means to ignore the BOM, and false means the opposite. The default value is false.

Example

let textDecoder = new util.TextDecoder("utf-8",{ignoreBOM: true});

decode^(deprecated)

decode(input: Uint8Array, options?: { stream?: false }): string

Decodes the input content into a string.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use decodeToString¹²⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
input	Uint8Array	Yes	Uint8Array object to decode.
options	{ stream?: false }	No	Decoding-related options.

Table 2 options

Name	Type	Mandatory	Description
stream	boolean	No	Whether to allow data blocks in subsequent decode(). If data is processed in blocks, set this parameter to true. If data is not divided into blocks, set this parameter to false. The default value is false.

Return value

Type	Description
string	String obtained.

Example

let textDecoder = new util.TextDecoder("utf-8",{ignoreBOM: true});
let uint8 = new Uint8Array(6);
uint8[0] = 0xEF;
uint8[1] = 0xBB;
uint8[2] = 0xBF;
uint8[3] = 0x61;
uint8[4] = 0x62;
uint8[5] = 0x63;
console.info("input num:");
let retStr = textDecoder.decode(uint8, {stream: false});
console.info("retStr = " + retStr);
// Output: retStr = abc

EncodeIntoUint8ArrayInfo¹¹⁺

Encrypted information, including the number of read characters and the number of written bytes.

Properties

Atomic service API: This API can be used in atomic services since API version 11.

System capability: SystemCapability.Utils.Lang

Name	Type	Read-Only	Optional	Description
read	number	Yes	No	Number of characters that have been read.
written	number	Yes	No	Number of bytes that have been written.

TextEncoder

Provides APIs to encode strings into byte arrays. Multiple encoding formats are supported.

When TextEncoder is used for encoding, the number of bytes occupied by a character varies according to the encoding format. You must explicitly specify the encoding format to obtain the required encoding result.

Properties

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Name	Type	Read-Only	Optional	Description
encoding	string	Yes	No	Encoding format. The following formats are supported: utf-8, gb2312, gb18030, ibm866, iso-8859-1, iso-8859-2, iso-8859-3, iso-8859-4, iso-8859-5, iso-8859-6, iso-8859-7, iso-8859-8, iso-8859-8-i, iso-8859-10, iso-8859-13, iso-8859-14, iso-8859-15, koi8-r, koi8-u, macintosh, windows-874, windows-1250, windows-1251, windows-1252, windows-1253, windows-1254, windows-1255, windows-1256, windows-1257, windows-1258, gbk, big5, euc-jp, iso-2022-jp, shift_jis, euc-kr, x-mac-cyrillic, utf-16be, and utf-16le. The default value is 'utf-8'.

constructor

constructor()

A constructor used to create a TextEncoder object.

Atomic service API: This API can be used in atomic services since API version 11.

System capability: SystemCapability.Utils.Lang

Example

let textEncoder = new util.TextEncoder();

constructor⁹⁺

constructor(encoding?: string)

A constructor used to create a TextEncoder object.

Atomic service API: This API can be used in atomic services since API version 11.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
encoding	string	No	Encoding format. The default format is 'utf-8'.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Incorrect parameter types.

Example

let textEncoder = new util.TextEncoder("utf-8");

create¹²⁺

static create(encoding?: string): TextEncoder

Creates a TextEncoder object.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
encoding	string	No	Encoding format. The default format is 'utf-8'.

Return value

Type	Description
TextEncoder	TextEncoder object.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Incorrect parameter types.

Example

let textEncoder = util.TextEncoder.create("utf-8");

encodeInto⁹⁺

encodeInto(input?: string): Uint8Array

Encodes the input content into a Uint8Array object.

Atomic service API: This API can be used in atomic services since API version 11.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
input	string	No	String to encode. The default value is an empty string. If the input parameter is an empty string, the return value is undefined.

Return value

Type	Description
Uint8Array	Uint8Array object obtained.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Incorrect parameter types.

Example

let textEncoder = new util.TextEncoder();
let result = textEncoder.encodeInto("\uD800¥¥");
console.info("result = " + result);
// Output: result = 237,160,128,194,165,194,165

encodeIntoUint8Array⁹⁺

encodeIntoUint8Array(input: string, dest: Uint8Array): EncodeIntoUint8ArrayInfo

Encodes the input content and stores the result into a Uint8Array object.

Atomic service API: This API can be used in atomic services since API version 11.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
input	string	Yes	String to encode.
dest	Uint8Array	Yes	Uint8Array object used to store the UTF-8 encoded text.

Return value

Type	Description
EncodeIntoUint8ArrayInfo	Object obtained. read indicates the number of encoded characters, and written indicates the number of bytes in the encoded characters.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let textEncoder = new util.TextEncoder();
let buffer = new ArrayBuffer(4);
let uint8 = new Uint8Array(buffer);
let result = textEncoder.encodeIntoUint8Array('abcd', uint8);
console.info("uint8 = " + uint8);
// Output: uint8 = 97,98,99,100
console.info("result.read = " + result.read);
// Output: result.read = 4
console.info("result.written = " + result.written);
// Output: result.written = 4

encodeInto^(deprecated)

encodeInto(input: string, dest: Uint8Array): { read: number; written: number }

Writes the generated UTF-8 encoded text to an array.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use encodeIntoUint8Array⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
input	string	Yes	String to encode.
dest	Uint8Array	Yes	Uint8Array object used to store the UTF-8 encoded text.

Return value

Type	Description
{ read: number; written: number }	Object obtained. read indicates the number of encoded characters, and written indicates the number of bytes in the encoded characters.

Example

let textEncoder = new util.TextEncoder();
let buffer = new ArrayBuffer(4);
let uint8 = new Uint8Array(buffer);
let result = textEncoder.encodeInto('abcd', uint8);
console.info("uint8 = " + uint8);
// Output: uint8 = 97,98,99,100

encode^(deprecated)

encode(input?: string): Uint8Array

Encodes the input content in to a Uint8Array object.

NOTE

This API is supported since API version 7 and deprecated since API version 9. You are advised to use encodeInto⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
input	string	No	String to encode. The default value is an empty string.

Return value

Type	Description
Uint8Array	Uint8Array object obtained.

Example

let textEncoder = new util.TextEncoder();
let result = textEncoder.encode("\uD800¥¥");
console.info("result = " + result);
// Output: result = 237,160,128,194,165,194,165

RationalNumber⁸⁺

Provides APIs to compare rational numbers and obtain numerators and denominators. For example, the toString() API can be used to convert a rational number into a string.

constructor⁹⁺

constructor()

A constructor used to create a RationalNumber object.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Example

let rationalNumber = new util.RationalNumber();

parseRationalNumber⁹⁺

static parseRationalNumber(numerator: number,denominator: number): RationalNumber

Creates a RationalNumber instance with a given numerator and denominator.

NOTE

The numerator and denominator parameters must be integers. If a decimal number is passed in, the function is not intercepted, but the error message "parseRationalNumber: The type of Parameter must be integer" is displayed.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
numerator	number	Yes	Numerator, which is an integer. Value range: -Number.MAX_VALUE <= numerator <= Number.MAX_VALUE.
denominator	number	Yes	Denominator, which is an integer. Value range: -Number.MAX_VALUE <= denominator <= Number.MAX_VALUE.

Return value

Type	Description
RationalNumber	RationalNumber object obtained.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let rationalNumber = util.RationalNumber.parseRationalNumber(1,2);

createRationalFromString⁸⁺

static createRationalFromString(rationalString: string): RationalNumber

Creates a RationalNumber object based on the given string.

NOTE

The rationalString parameter must be a string. If a decimal string is passed in, the function is not intercepted, but the error message "createRationalFromString: The type of Parameter must be integer string" is displayed.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
rationalString	string	Yes	String used to create the RationalNumber object.

Return value

Type	Description
RationalNumber​	RationalNumber object obtained.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	The type of rationalString must be string.

Example

let rational = util.RationalNumber.createRationalFromString("3/4");

compare⁹⁺

compare(another: RationalNumber): number​

Compares this RationalNumber object with another RationalNumber object.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
another	RationalNumber	Yes	Object used to compare with this RationalNumber object.

Return value

Type	Description
number	Returns 0 if the two objects are equal; returns 1 if the given object is less than this object; return -1 if the given object is greater than this object.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let rationalNumber = util.RationalNumber.parseRationalNumber(1,2);
let rational = util.RationalNumber.createRationalFromString("3/4");
let result = rationalNumber.compare(rational);
console.info("result = " + result);
// Output: result = -1

valueOf⁸⁺

valueOf(): number

Obtains the integer or floating-point value of this RationalNumber object.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
number	An integer or a floating-point number.

Example

let rationalNumber = new util.RationalNumber(1,2);
let result = rationalNumber.valueOf();
console.info("result = " + result);
// Output: result = 0.5

You are advised to use the following code snippet for API version 9 and later versions:

let rationalNumber = util.RationalNumber.parseRationalNumber(1,2);
let result = rationalNumber.valueOf();
console.info("result = " + result);
// Output: result = 0.5

equals⁸⁺

equals(obj: Object): boolean

Checks whether this RationalNumber object equals the given object.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
obj	Object	Yes	Object used to compare with this RationalNumber object.

Return value

Type	Description
boolean	Check result. The value true is returned if the two objects are equal; otherwise, false is returned.

Example

let rationalNumber = new util.RationalNumber(1,2);
let rational = util.RationalNumber.createRationalFromString("3/4");
let result = rationalNumber.equals(rational);
console.info("result = " + result);
// Output: result = false

You are advised to use the following code snippet for API version 9 and later versions:

let rationalNumber = util.RationalNumber.parseRationalNumber(1,2);
let rational = util.RationalNumber.createRationalFromString("3/4");
let result = rationalNumber.equals(rational);
console.info("result = " + result);
// Output: result = false

getCommonFactor⁹⁺

static getCommonFactor(number1: number, number2: number): number

Obtains the greatest common divisor of two specified integers.

NOTE

The number1 and number2 parameters must be integers. If a decimal number is passed in, the function is not intercepted, but the error message "getCommonFactor: The type of Parameter must be integer" is displayed.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
number1	number	Yes	The first integer used to get the greatest common divisor. Value range: -Number.MAX_VALUE <= number1 <= Number.MAX_VALUE.
number2	number	Yes	The second integer used to get the greatest common divisor. Value range: -Number.MAX_VALUE <= number2 <= Number.MAX_VALUE.

Return value

Type	Description
number	Greatest common divisor obtained.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let result = util.RationalNumber.getCommonFactor(4,6);
console.info("result = " + result);
// Output: result = 2

getNumerator⁸⁺

getNumerator(): number

Obtains the numerator of this RationalNumber object.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
number	Numerator of this RationalNumber object.

Example

let rationalNumber = new util.RationalNumber(1,2);
let result = rationalNumber.getNumerator();
console.info("result = " + result);
// Output: result = 1

You are advised to use the following code snippet for API version 9 and later versions:

let rationalNumber = util.RationalNumber.parseRationalNumber(1,2);
let result = rationalNumber.getNumerator();
console.info("result = " + result);
// Output: result = 1

getDenominator⁸⁺

getDenominator(): number

Obtains the denominator of this RationalNumber object.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
number	Denominator of this RationalNumber object.

Example

let rationalNumber = new util.RationalNumber(1,2);
let result = rationalNumber.getDenominator();
console.info("result = " + result);
// Output: result = 2

You are advised to use the following code snippet for API version 9 and later versions:

let rationalNumber = util.RationalNumber.parseRationalNumber(1,2)
let result = rationalNumber.getDenominator();
console.info("result = " + result);
// Output: result = 2

isZero⁸⁺

isZero():boolean

Checks whether this RationalNumber object is 0.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
boolean	Check result. The value true is returned if the value of this RationalNumber object is 0; otherwise, false is returned.

Example

let rationalNumber = new util.RationalNumber(1,2);
let result = rationalNumber.isZero();
console.info("result = " + result);
// Output: result = false

You are advised to use the following code snippet for API version 9 and later versions:

let rationalNumber = util.RationalNumber.parseRationalNumber(1,2);
let result = rationalNumber.isZero();
console.info("result = " + result);
// Output: result = false

isNaN⁸⁺

isNaN(): boolean

Checks whether this RationalNumber object is a Not a Number (NaN).

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
boolean	Check result. The value true is returned if this RationalNumber object is a NaN (the denominator and numerator are both 0); otherwise, false is returned.

Example

let rationalNumber = new util.RationalNumber(1,2);
let result = rationalNumber.isNaN();
console.info("result = " + result);
// Output: result = false

You are advised to use the following code snippet for API version 9 and later versions:

let rationalNumber = util.RationalNumber.parseRationalNumber(1,2);
let result = rationalNumber.isNaN();
console.info("result = " + result);
// Output: result = false

isFinite⁸⁺

isFinite():boolean

Checks whether this RationalNumber object represents a finite value.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
boolean	Check result. The value true is returned if this RationalNumber object represents a finite value (the denominator is not 0); otherwise, false is returned.

Example

let rationalNumber = new util.RationalNumber(1,2);
let result = rationalNumber.isFinite();
console.info("result = " + result);
// Output: result = true

You are advised to use the following code snippet for API version 9 and later versions:

let rationalNumber = util.RationalNumber.parseRationalNumber(1,2);
let result = rationalNumber.isFinite();
console.info("result = " + result);
// Output: result = true

toString⁸⁺

toString(): string

Obtains the string representation of this RationalNumber object.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
string	Returns a string in Numerator/Denominator format in normal cases, for example, 3/5; returns 0/1 if the numerator of this object is 0; returns Infinity if the denominator is 0; returns NaN if the numerator and denominator are both 0.

Example

let rationalNumber = new util.RationalNumber(1,2);
let result = rationalNumber.toString();
console.info("result = " + result);
// Output: result = 1/2

You are advised to use the following code snippet for API version 9 and later versions:

let rationalNumber = util.RationalNumber.parseRationalNumber(1,2);
let result = rationalNumber.toString();
console.info("result = " + result);
// Output: result = 1/2

constructor^(deprecated)

constructor(numerator: number,denominator: number)

A constructor used to create a RationalNumber object.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use parseRationalNumber⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
numerator	number	Yes	Numerator, which is an integer.
denominator	number	Yes	Denominator, which is an integer.

Example

let rationalNumber = new util.RationalNumber(1,2);

compareTo^(deprecated)

compareTo(another: RationalNumber): number​

Compares this RationalNumber object with a given object.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use compare⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
another	RationalNumber	Yes	Object used to compare with this RationalNumber object.

Return value

Type	Description
number	Returns 0 if the two objects are equal; returns 1 if the given object is less than this object; return -1 if the given object is greater than this object.

Example

let rationalNumber = new util.RationalNumber(1,2);
let rational = util.RationalNumber.createRationalFromString("3/4");
let result = rationalNumber.compareTo(rational);
console.info("result = " + result);
// Output: result = -1

getCommonDivisor^(deprecated)

static getCommonDivisor(number1: number,number2: number): number

Obtains the greatest common divisor of two specified integers.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use getCommonFactor⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
number1	number	Yes	The first integer used to get the greatest common divisor.
number2	number	Yes	The second integer used to get the greatest common divisor.

Return value

Type	Description
number	Greatest common divisor obtained.

LRUCache⁹⁺

Provides APIs to discard the least recently used data to make rooms for new elements when the cache is full. This class uses the Least Recently Used (LRU) algorithm, which believes that the recently used data may be accessed again in the near future and the least accessed data is the least valuable data and should be removed from the cache.

Properties

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Name	Type	Read-Only	Optional	Description
length	number	Yes	No	Total number of values in this cache.

Example

let pro = new util.LRUCache<number, number>();
pro.put(2, 10);
pro.put(1, 8);
let result = pro.length;
console.info('result = ' + result);
// Output: result = 2

constructor⁹⁺

constructor(capacity?: number)

A constructor used to create a LRUCache instance. The default capacity of the cache is 64.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
capacity	number	No	Capacity of the cache to create. The default value is 64, and the maximum value is 2147483647.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1.Incorrect parameter types.

Example

let pro = new util.LRUCache<number, number>();

updateCapacity⁹⁺

updateCapacity(newCapacity: number): void

Changes the cache capacity. If the new capacity is less than or equal to 0, an exception will be thrown. If the total number of values in the cache is greater than the specified capacity, the deletion operation is performed.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
newCapacity	number	Yes	New capacity of the cache. The maximum value is 2147483647.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified.

Example

let pro = new util.LRUCache<number, number>();
pro.updateCapacity(100);

toString⁹⁺

toString(): string

Obtains the string representation of this cache.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
string	String representation of this cache.

Example

let pro = new util.LRUCache<number, number>();
pro.put(2, 10);
pro.get(2);
pro.get(3);
console.info(pro.toString());
// Output: LRUCache[ maxSize = 64, hits = 1, misses = 1, hitRate = 50% ]
// maxSize: maximum size of the cache. hits: number of matched queries. misses: number of mismatched queries. hitRate: matching rate.

getCapacity⁹⁺

getCapacity(): number

Obtains the capacity of this cache.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
number	Capacity of the cache.

Example

let pro = new util.LRUCache<number, number>();
let result = pro.getCapacity();
console.info('result = ' + result);
// Output: result = 64

clear⁹⁺

clear(): void

Clears key-value pairs from this cache.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Example

let pro = new util.LRUCache<number, number>();
pro.put(2, 10);
let result = pro.length;
pro.clear();
let res = pro.length;
console.info('result = ' + result);
console.info('res = ' + res);
// Output: result = 1
// Output: res = 0

getCreateCount⁹⁺

getCreateCount(): number

Obtains the number of times that an object is created.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
number	Number of times that objects are created.

Example

// Create the ChildLRUCache class that inherits LRUCache, and override createDefault() to return a non-undefined value.
class ChildLRUCache extends util.LRUCache<number, number> {
  constructor() {
    super();
  }

  createDefault(key: number): number {
    return key;
  }
}
let lru = new ChildLRUCache();
lru.put(2, 10);
lru.get(3);
lru.get(5);
let res = lru.getCreateCount();
console.info('res = ' + res);
// Output: res = 2

getMissCount⁹⁺

getMissCount(): number

Obtains the number of times that the queried values are mismatched.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
number	Number of times that the queried values are mismatched.

Example

let pro = new util.LRUCache<number, number>();
pro.put(2, 10);
pro.get(2);
let result = pro.getMissCount();
console.info('result = ' + result);
// Output: result = 0

getRemovalCount⁹⁺

getRemovalCount(): number

Obtains the number of times that key-value pairs in the cache are recycled.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
number	Number of times that key-value pairs in the cache are recycled.

Example

let pro = new util.LRUCache<number, number>();
pro.put(2, 10);
pro.updateCapacity(2);
pro.put(50, 22);
let result = pro.getRemovalCount();
console.info('result = ' + result);
// Output: result = 0

getMatchCount⁹⁺

getMatchCount(): number

Obtains the number of times that the queried values are matched.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
number	Number of times that the queried values are matched.

Example

let pro = new util.LRUCache<number, number>();
pro.put(2, 10);
pro.get(2);
let result = pro.getMatchCount();
console.info('result = ' + result);
// Output: result = 1

getPutCount⁹⁺

getPutCount(): number

Obtains the number of additions to this cache.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
number	Number of additions to the cache.

Example

let pro = new util.LRUCache<number, number>();
pro.put(2, 10);
let result = pro.getPutCount();
console.info('result = ' + result);
// Output: result = 1

isEmpty⁹⁺

isEmpty(): boolean

Checks whether this cache is empty.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
boolean	Returns true if the cache does not contain any value.

Example

let pro = new util.LRUCache<number, number>();
pro.put(2, 10);
let result = pro.isEmpty();
console.info('result = ' + result);
// Output: result = false

get⁹⁺

get(key: K): V | undefined

Obtains the value of a key. If the key is not in the cache, createDefault⁹⁺ is called to create the key. If the value specified in createDefault is not undefined, afterRemoval⁹⁺ is called to return the value specified in createDefault.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
key	K	Yes	Key based on which the value is queried.

Return value

Type	Description
V | undefined	Value of the key. If no match is found, the value specified in createDefault is returned.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let pro = new util.LRUCache<number, number>();
pro.put(2, 10);
let result  = pro.get(2);
console.info('result = ' + result);
// Output: result = 10

put⁹⁺

put(key: K,value: V): V

Adds a key-value pair to this cache and returns the value associated with the key. If the total number of values in the cache is greater than the specified capacity, the deletion operation is performed.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
key	K	Yes	Key of the key-value pair to add.
value	V	Yes	Value of the key-value pair to add.

Return value

Type	Description
V	Value of the key-value pair added. If the key or value is empty, an exception is thrown.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let pro = new util.LRUCache<number, number>();
let result = pro.put(2, 10);
console.info('result = ' + result);
// Output: result = 10

values⁹⁺

values(): V[]

Obtains all values in this cache, listed from the least to the most recently accessed.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
V[]	The list of all values in this cache, listed from the least to the most recently accessed.

Example

let pro = new util.LRUCache<number, string>();
pro.put(1, 'A');
pro.put(2, "B");
pro.put(3, 'C');
pro.put(4, 'D')
pro.put(5, 'E')
pro.put(6, 'F')
let result = pro.values();
console.info('result = ' + result);
// Output: result = A,B,C,D,E,F
pro.get(1);
pro.get(2);
result = pro.values();
console.info('result = ' + result);
// Output: result = C,D,E,F,A,B

keys⁹⁺

keys(): K[]

Obtains all keys in this cache, listed from the least to the most recently accessed.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
K[]	The list of all keys in this cache, listed from the least to the most recently accessed.

Example

let pro = new util.LRUCache<number, string>();
pro.put(1, 'A');
pro.put(2, "B");
pro.put(3, 'C');
pro.put(4, 'D')
pro.put(5, 'E')
pro.put(6, 'F')
let result = pro.keys();
console.info('result = ' + result);
// Output: result = 1,2,3,4,5,6
pro.get(5);
pro.get(3);
result = pro.keys();
console.info('result = ' + result);
// Output: result = 1,2,4,6,5,3

remove⁹⁺

remove(key: K): V | undefined

Removes a key and its associated value from this cache and returns the value associated with the key. If the key does not exist, undefined is returned.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
key	K	Yes	Key to remove.

Return value

Type	Description
V | undefined	Returns an Optional object containing the removed key-value pair if the key exists in the cache; returns undefined if the key does not exist; throws an error if null is passed in for key.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let pro = new util.LRUCache<number, number>();
pro.put(2, 10);
let result = pro.remove(20);
console.info('result = ' + result);
// Output: result = undefined

afterRemoval⁹⁺

afterRemoval(isEvict: boolean, key: K, value: V, newValue: V): void

Performs subsequent operations after a value is removed. The subsequent operations must be implemented by developers. This API is called during deletion operations, such as get⁹⁺, put⁹⁺, remove⁹⁺, clear⁹⁺, and updateCapacity⁹⁺.

NOTE

If the callback method is executed after clear⁹⁺ and updateCapacity⁹⁺ are called and the input key and value parameters are of the MapIterator type, perform subsequent operations by referring to example 2.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
isEvict	boolean	Yes	Whether the capacity is insufficient. If the value is true, this API is called due to insufficient capacity.
key	K	Yes	Key removed.
value	V	Yes	Value removed.
newValue	V	Yes	New value for the key if the put() method is called and the key to be added already exists. In other cases, this parameter is left blank.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example 1

class ChildLRUCache<K, V> extends util.LRUCache<K, V> {
  constructor(capacity?: number) {
    super(capacity);
  }

  afterRemoval(isEvict: boolean, key: K, value: V, newValue: V): void {
    if (isEvict === true) {
      console.info('key = ' + key);
      // Output: key = 1
      console.info('value = ' + value);
      // Output: value = 1
      console.info('newValue = ' + newValue);
      // Output: newValue = null
    }
  }
}
let lru = new ChildLRUCache<number, number>(2);
lru.put(1, 1);
lru.put(2, 2);
lru.put(3, 3);

Example 2

class TestClass {
  str:string = '';
  constructor(input: string) {
    this.str = input;
  }
}

class ChildLRUCache extends util.LRUCache<string, TestClass> {
  constructor(capacity?: number) {
    super(capacity);
  }

  afterRemoval(isEvict: boolean, key: string, value: TestClass, newValue: TestClass): void {
    if(value.toString().indexOf('[object Map Iterator]') >= 0) {
      console.info('Entered via clear');
      console.info('isEvict = ' + isEvict);
      const keysIterator = (key as ESObject as IterableIterator<string>);
      const valuesIterator = (value as ESObject as IterableIterator<TestClass>);

      let keyEntry = keysIterator.next();
      let valueEntry = valuesIterator.next();
      while (!keyEntry.done && !valueEntry.done) {
        console.info(`key = ${keyEntry.value}, valueStr = ${valueEntry.value.str}`);
        keyEntry = keysIterator.next();
        valueEntry = valuesIterator.next();
      }
    } else {
      console.info('Entered via put');
      console.info('isEvict = ' + isEvict);
      console.info('key = ' + key + '  valueStr = ' + value.str);
    }
  }
}
let test1 = new TestClass('testA');
let test2 = new TestClass('testB');
let test3 = new TestClass('testC');
let lru = new ChildLRUCache(2);
lru.put('aa', test1);
lru.put('bb', test2);
lru.put('cc', test3);    // Remove the key-value pair for 'aa'.
lru.clear();             // Clear the entire cache buffer.
/*
Output: Entered via put.
         isEvict = true
         key = aa  valueStr = testA
         Entered via clear.
         isEvict = false
         key = bb, valueStr = testB
         key = cc, valueStr = testC
*/

contains⁹⁺

contains(key: K): boolean

Checks whether this cache contains the specified key.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
key	K	Yes	Key to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the cache contains the specified key; otherwise, false is returned.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let pro = new util.LRUCache<number, number>();
pro.put(2, 10);
let result = pro.contains(2);
console.info('result = ' + result);
// Output: result = true

createDefault⁹⁺

createDefault(key: K): V

Performs subsequent operations if no key is matched in the cache and returns the value (undefined by default) associated with the key.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
key	K	Yes	Key.

Return value

Type	Description
V	Value of the key.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let pro = new util.LRUCache<number, number>();
let result = pro.createDefault(50);
console.info('result = ' + result);
// Output: result = undefined

entries⁹⁺

entries(): IterableIterator<[K, V]>

Returns an iterator object that traverses all key-value pairs ([key, value]) in this object in the insertion order.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
IterableIterator<[K, V]>	Iterable array.

Example

let pro = new util.LRUCache<number, number>();
pro.put(2, 10);
pro.put(3, 15);
let pair = pro.entries();
for (let value of pair) {
  console.info(value[0]+ ', '+ value[1]);
}
// Output:
// 2, 10
// 3, 15

[Symbol.iterator]⁹⁺

[Symbol.iterator](): IterableIterator<[K, V]>

Obtains a two-dimensional array in key-value pairs.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
IterableIterator<[K, V]>	Two-dimensional array in key-value pairs.

Example

let pro = new util.LRUCache<number, number>();
pro.put(2, 10);
pro.put(3, 15);

for (let value of pro) {
  console.info(value[0]+ ', '+ value[1]);
}
// Output:
// 2, 10
// 3, 15

ScopeComparable⁸⁺

The values of the ScopeComparable type are used to implement the compareTo method. Therefore, ensure that the input parameters are comparable.

System capability: SystemCapability.Utils.Lang

compareTo⁸⁺

compareTo(other: ScopeComparable): boolean

Compares two values and returns a Boolean value.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
other	ScopeComparable	Yes	The other value to be compared with the current value.

Return value

Type	Description
boolean	Check result. The value true is returned if the current value is greater than or equal to the input value; otherwise, false is returned.

Example

Create a class to implement the compareTo method. The Temperature class is used as an example in the following sample code.

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

ScopeType⁸⁺

type ScopeType = ScopeComparable | number

Defines the type of values in a Scope object.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Type	Description
number	The value type is a number.
ScopeComparable	The value type is ScopeComparable.

ScopeHelper⁹⁺

Provides APIs to define the valid range of a field. The constructor of this class creates comparable objects with lower and upper limits.

constructor⁹⁺

constructor(lowerObj: ScopeType, upperObj: ScopeType)

A constructor used to create a ScopeHelper object with the specified upper and lower limits.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
lowerObj	ScopeType	Yes	Lower limit of the Scope object.
upperObj	ScopeType	Yes	Upper limit of the Scope object.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}
let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let range = new util.ScopeHelper(tempLower, tempUpper);
console.info("range = " + range);
// Output: range = [30, 40]

toString⁹⁺

toString(): string

Obtains a string representation that contains this Scope.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
string	String representation containing the Scope.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let range = new util.ScopeHelper(tempLower, tempUpper);
let result = range.toString();
console.info("result = " + result);
// Output: result = [30, 40]

intersect⁹⁺

intersect(range: ScopeHelper): ScopeHelper

Obtains the intersection of this Scope and the given Scope. If the intersection is empty, an exception is thrown.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
range	ScopeHelper	Yes	Scope specified.

Return value

Type	Description
ScopeHelper	Intersection of this Scope and the given Scope.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let range = new util.ScopeHelper(tempLower, tempUpper);
let tempMiDF = new Temperature(35);
let tempMidS = new Temperature(39);
let rangeFir = new util.ScopeHelper(tempMiDF, tempMidS);
let result = range.intersect(rangeFir);
console.info("result = " + result);
// Output: result = [35, 39]

intersect⁹⁺

intersect(lowerObj:ScopeType,upperObj:ScopeType):ScopeHelper

Obtains the intersection of this Scope and the given lower and upper limits. If the intersection is empty, an exception is thrown.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
lowerObj	ScopeType	Yes	Lower limit.
upperObj	ScopeType	Yes	Upper limit.

Return value

Type	Description
ScopeHelper	Intersection of this Scope and the given lower and upper limits.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let tempMiDF = new Temperature(35);
let tempMidS = new Temperature(39);
let range = new util.ScopeHelper(tempLower, tempUpper);
let result = range.intersect(tempMiDF, tempMidS);
console.info("result = " + result);
// Output: result = [35, 39]

getUpper⁹⁺

getUpper(): ScopeType

Obtains the upper limit of this Scope.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
ScopeType	Upper limit of this Scope.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let range = new util.ScopeHelper(tempLower, tempUpper);
let result = range.getUpper();
console.info("result = " + result);
// Output: result = 40

getLower⁹⁺

getLower(): ScopeType

Obtains the lower limit of this Scope.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
ScopeType	Lower limit of this Scope.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let range = new util.ScopeHelper(tempLower, tempUpper);
let result = range.getLower();
console.info("result = " + result);
// Output: result = 30

expand⁹⁺

expand(lowerObj: ScopeType,upperObj: ScopeType): ScopeHelper

Obtains the union set of this Scope and the given lower and upper limits.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
lowerObj	ScopeType	Yes	Lower limit.
upperObj	ScopeType	Yes	Upper limit.

Return value

Type	Description
ScopeHelper	Union set of this Scope and the given lower and upper limits.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let tempMiDF = new Temperature(35);
let tempMidS = new Temperature(39);
let range = new util.ScopeHelper(tempLower, tempUpper);
let result = range.expand(tempMiDF, tempMidS);
console.info("result = " + result);
// Output: result = [30, 40]

expand⁹⁺

expand(range: ScopeHelper): ScopeHelper

Obtains the union set of this Scope and the given Scope.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
range	ScopeHelper	Yes	Scope specified.

Return value

Type	Description
ScopeHelper	Union set of this Scope and the given Scope.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let tempMiDF = new Temperature(35);
let tempMidS = new Temperature(39);
let range = new util.ScopeHelper(tempLower, tempUpper);
let rangeFir = new util.ScopeHelper(tempMiDF, tempMidS);
let result = range.expand(rangeFir);
console.info("result = " + result);
// Output: result = [30, 40]

expand⁹⁺

expand(value: ScopeType): ScopeHelper

Obtains the union set of this Scope and the given value.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	ScopeType	Yes	Value specified.

Return value

Type	Description
ScopeHelper	Union set of this Scope and the given value.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let tempMiDF = new Temperature(35);
let range = new util.ScopeHelper(tempLower, tempUpper);
let result = range.expand(tempMiDF);
console.info("result = " + result);
// Output: result = [30, 40]

contains⁹⁺

contains(value: ScopeType): boolean

Checks whether a range is within this Scope.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	ScopeType	Yes	Value specified.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is within this Scope; otherwise, false is returned.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let tempMiDF = new Temperature(35);
let range = new util.ScopeHelper(tempLower, tempUpper);
let result = range.contains(tempMiDF);
console.info("result = " + result);
// Output: result = true

contains⁹⁺

contains(range: ScopeHelper): boolean

Checks whether a range is within this Scope.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
range	ScopeHelper	Yes	Scope specified.

Return value

Type	Description
boolean	Check result. The value true is returned if the range is within this Scope; otherwise, false is returned.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let range = new util.ScopeHelper(tempLower, tempUpper);
let tempLess = new Temperature(20);
let tempMore = new Temperature(45);
let rangeSec = new util.ScopeHelper(tempLess, tempMore);
let result = range.contains(rangeSec);
console.info("result = " + result);
// Output: result = false

clamp⁹⁺

clamp(value: ScopeType): ScopeType

Limits a value to this Scope.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	ScopeType	Yes	Value specified.

Return value

Type	Description
ScopeType	Returns lowerObj if the specified value is less than the lower limit; returns upperObj if the specified value is greater than the upper limit; returns the specified value if it is within this Scope.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let tempMiDF = new Temperature(35);
let range = new util.ScopeHelper(tempLower, tempUpper);
let result = range.clamp(tempMiDF);
console.info("result = " + result);
// Output: result = 35

Base64Helper⁹⁺

Provides encoding and decoding for Base64 and Base64URL. The Base64 encoding table contains 64 characters, which are the uppercase letters (A-Z), lowercase letters (a-z), digits (0-9), and the special characters plus sign (+) and slash (/). During encoding, the original data is divided into groups of three bytes, and each group contains a 6-bit number. Then, the corresponding characters in the Base64 encoding table are used to represent these numbers. If the last group contains only one or two bytes, the equal sign (=) is used for padding. The Base64URL encoding table contains 64 characters, which are the uppercase letters (A-Z), lowercase letters (a-z), digits (0-9), and the special characters plus sign (+) and slash (/). The Base64URL encoding result does not contain equal signs (=).

constructor⁹⁺

constructor()

A constructor used to create a Base64Helper instance.

System capability: SystemCapability.Utils.Lang

Atomic service API: This API can be used in atomic services since API version 11.

Example

let base64 = new util.Base64Helper();

encodeSync⁹⁺

encodeSync(src: Uint8Array, options?: Type): Uint8Array

Encodes the input content into a Uint8Array object.

Atomic service API: This API can be used in atomic services since API version 11.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
src	Uint8Array	Yes	Uint8Array object to encode.
options12+	Type	No	Encoding format. The following values are available: - util.Type.BASIC (default): Base64 encoding. - util.Type.BASIC_URL_SAFE: Base64URL encoding.

Return value

Type	Description
Uint8Array	Uint8Array object obtained.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let base64Helper = new util.Base64Helper();
let array = new Uint8Array([115,49,51]);
let result = base64Helper.encodeSync(array);
console.info("result = " + result);
// Output: result = 99,122,69,122

encodeToStringSync⁹⁺

encodeToStringSync(src: Uint8Array, options?: Type): string

Performs Base64 encoding on the input Uint8Array byte array and returns a string. This method supports multiple encoding formats, including standard Base64 encoding, MIME-compliant Base64 encoding (with line breaks), and URL-safe Base64 encoding.

Atomic service API: This API can be used in atomic services since API version 11.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
src	Uint8Array	Yes	Uint8Array object to encode.
options10+	Type	No	Encoding format. The following values are available: - util.Type.BASIC (default): Base64 encoding. The return value does not contain carriage return characters or newline characters. - util.Type.MIME: Base64 encoding. If the return value exceeds 76 characters, a line break is inserted every 76 characters, and each line ends with '\r\n'. If the return value is fewer than 76 characters, an exception is thrown. - util.Type.BASIC_URL_SAFE: Base64URL encoding. The return value does not contain carriage return characters or newline characters. - util.Type.MIME_URL_SAFE: Base64URL encoding. Each line in the return value contains a maximum of 76 characters and ends with '\r\n'.

Return value

Type	Description
string	String obtained.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

// MIME encoding
let base64Helper = new util.Base64Helper();
let array =
  new Uint8Array([77, 97, 110, 105, 115, 100, 105, 115, 116, 105, 110, 103, 117, 105, 115, 104, 101, 100, 110, 111, 116,
    111, 110, 108, 121, 98, 121, 104, 105, 115, 114, 101, 97, 115, 111, 110, 98, 117, 116, 98, 121, 116, 104, 105, 115,
    115, 105, 110, 103, 117, 108, 97, 114, 112, 97, 115, 115, 105, 111, 110, 102, 114, 111, 109, 111, 116, 104, 101,
    114, 97, 110, 105, 109, 97, 108, 115, 119, 104, 105, 99, 104, 105, 115, 97, 108, 117, 115, 116, 111, 102, 116, 104,
    101, 109, 105, 110, 100, 101, 120, 99, 101, 101, 100, 115, 116, 104, 101, 115, 104, 111, 114, 116, 118, 101, 104,
    101, 109, 101, 110, 99, 101, 111, 102, 97, 110, 121, 99, 97, 114, 110, 97, 108, 112, 108, 101, 97, 115, 117, 114,
    101]);
let result = base64Helper.encodeToStringSync(array, util.Type.MIME);
console.info("result = " + result);
/*
// Output: result = TWFuaXNkaXN0aW5ndWlzaGVkbm90b25seWJ5aGlzcmVhc29uYnV0Ynl0aGlzc2luZ3VsYXJwYXNz
aW9uZnJvbW90aGVyYW5pbWFsc3doaWNoaXNhbHVzdG9mdGhlbWluZGV4Y2VlZHN0aGVzaG9ydHZl
aGVtZW5jZW9mYW55Y2FybmFscGxlYXN1cmU=
*/

// BASIC encoding
let base64Helper = new util.Base64Helper();
let array =
  new Uint8Array([77, 97, 110, 105, 115, 100, 105, 115, 116, 105, 110, 103, 117, 105, 115, 104, 101, 100, 110, 111, 116,
    111, 110, 108, 121, 98, 121, 104, 105, 115, 114, 101, 97, 115, 111, 110, 98, 117, 116, 98, 121, 116, 104, 105, 115,
    115, 105, 110, 103, 117, 108, 97, 114, 112, 97, 115, 115, 105, 111, 110, 102, 114, 111, 109, 111, 116, 104, 101,
    114, 97, 110, 105, 109, 97, 108, 115, 119, 104, 105, 99, 104, 105, 115, 97, 108, 117, 115, 116, 111, 102, 116, 104,
    101, 109, 105, 110, 100, 101, 120, 99, 101, 101, 100, 115, 116, 104, 101, 115, 104, 111, 114, 116, 118, 101, 104,
    101, 109, 101, 110, 99, 101, 111, 102, 97, 110, 121, 99, 97, 114, 110, 97, 108, 112, 108, 101, 97, 115, 117, 114,
    101]);
let result = base64Helper.encodeToStringSync(array, util.Type.BASIC);
console.info("result = " + result);
/*
Output: result = TWFuaXNkaXN0aW5ndWlzaGVkbm90b25seWJ5aGlzcmVhc29uYnV0Ynl0aGlzc2luZ3VsYXJwYXNzaW9uZnJvbW90aGVyYW5pbWFsc3doaWNoaXNhbHVzdG9mdGhlbWluZGV4Y2VlZHN0aGVzaG9ydHZlaGVtZW5jZW9mYW55Y2FybmFscGxlYXN1cmU=
*/

// MIME_URL_SAFE encoding
let base64Helper = new util.Base64Helper();
let array =
  new Uint8Array([77, 97, 110, 105, 115, 100, 105, 115, 116, 105, 110, 103, 117, 105, 115, 104, 101, 100, 110, 111, 116,
    111, 110, 108, 121, 98, 121, 104, 105, 115, 114, 101, 97, 115, 111, 110, 98, 117, 116, 98, 121, 116, 104, 105, 115,
    115, 105, 110, 103, 117, 108, 97, 114, 112, 97, 115, 115, 105, 111, 110, 102, 114, 111, 109, 111, 116, 104, 101,
    114, 97, 110, 105, 109, 97, 108, 115, 119, 104, 105, 99, 104, 105, 115, 97, 108, 117, 115, 116, 111, 102, 116, 104,
    101, 109, 105, 110, 100, 101, 120, 99, 101, 101, 100, 115, 116, 104, 101, 115, 104, 111, 114, 116, 118, 101, 104,
    101, 109, 101, 110, 99, 101, 111, 102, 97, 110, 121, 99, 97, 114, 110, 97, 108, 112, 108, 101, 97, 115, 117, 114,
    101]);
let result = base64Helper.encodeToStringSync(array, util.Type.BASIC_URL_SAFE);
console.info("result = " + result);
/*
Output: result = TWFuaXNkaXN0aW5ndWlzaGVkbm90b25seWJ5aGlzcmVhc29uYnV0Ynl0aGlzc2luZ3VsYXJwYXNzaW9uZnJvbW90aGVyYW5pbWFsc3doaWNoaXNhbHVzdG9mdGhlbWluZGV4Y2VlZHN0aGVzaG9ydHZlaGVtZW5jZW9mYW55Y2FybmFscGxlYXN1cmU
*/
// MIME_URL_SAFE encoding
let base64Helper = new util.Base64Helper();
let array =
  new Uint8Array([77, 97, 110, 105, 115, 100, 105, 115, 116, 105, 110, 103, 117, 105, 115, 104, 101, 100, 110, 111, 116,
    111, 110, 108, 121, 98, 121, 104, 105, 115, 114, 101, 97, 115, 111, 110, 98, 117, 116, 98, 121, 116, 104, 105, 115,
    115, 105, 110, 103, 117, 108, 97, 114, 112, 97, 115, 115, 105, 111, 110, 102, 114, 111, 109, 111, 116, 104, 101,
    114, 97, 110, 105, 109, 97, 108, 115, 119, 104, 105, 99, 104, 105, 115, 97, 108, 117, 115, 116, 111, 102, 116, 104,
    101, 109, 105, 110, 100, 101, 120, 99, 101, 101, 100, 115, 116, 104, 101, 115, 104, 111, 114, 116, 118, 101, 104,
    101, 109, 101, 110, 99, 101, 111, 102, 97, 110, 121, 99, 97, 114, 110, 97, 108, 112, 108, 101, 97, 115, 117, 114,
    101]);
let result = base64Helper.encodeToStringSync(array, util.Type.MIME_URL_SAFE);
console.info("result = " + result);
/*
// Output: result = TWFuaXNkaXN0aW5ndWlzaGVkbm90b25seWJ5aGlzcmVhc29uYnV0Ynl0aGlzc2luZ3VsYXJwYXNz
aW9uZnJvbW90aGVyYW5pbWFsc3doaWNoaXNhbHVzdG9mdGhlbWluZGV4Y2VlZHN0aGVzaG9ydHZl
aGVtZW5jZW9mYW55Y2FybmFscGxlYXN1cmU
*/

decodeSync⁹⁺

decodeSync(src: Uint8Array | string, options?: Type): Uint8Array

Decodes a string into a Uint8Array object. This API returns the result synchronously.

Atomic service API: This API can be used in atomic services since API version 11.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
src	Uint8Array | string	Yes	Uint8Array object or string to decode.
options10+	Type	No	Decoding format. The following values are available: - util.Type.BASIC (default): Base64 decoding. - util.Type.MIME: Base64 decoding. The input parameter src contains carriage return characters and newline characters. - util.Type.BASIC_URL_SAFE: Base64URL decoding. - util.Type.MIME_URL_SAFE: Base64 URL decoding. The input parameter src contains carriage return characters and newline characters.

Return value

Type	Description
Uint8Array	Uint8Array object obtained.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let base64Helper = new util.Base64Helper();
let buff = 'TWFuaXNkaXN0aW5ndWlzaGVkbm90b25seWJ5aGlzcmVhc29uYnV0Ynl0aGlzc2luZ3VsYXJwYXNz\r\naW9uZnJvbW90aGVyYW5pbWFsc3doaWNoaXNhbHVzdG9mdGhlbWluZGV4Y2VlZHN0aGVzaG9ydHZl\r\naGVtZW5jZW9mYW55Y2FybmFscGxlYXN1cmU=\r\n';
let result = base64Helper.decodeSync(buff, util.Type.MIME);
console.info("result = " + result);
/*
Output: result = 77,97,110,105,115,100,105,115,116,105,110,103,117,105,115,104,101,100,110,111,116,111,110,108,121,98,121,104,105,115,114,101,97,115,111,110,98,117,116,98,121,116,104,105,115,115,105,110,103,117,108,97,114,112,97,115,115,105,111,110,102,114,111,109,111,116,104,101,114,97,110,105,109,97,108,115,119,104,105,99,104,105,115,97,108,117,115,116,111,102,116,104,101,109,105,110,100,101,120,99,101,101,100,115,116,104,101,115,104,111,114,116,118,101,104,101,109,101,110,99,101,111,102,97,110,121,99,97,114,110,97,108,112,108,101,97,115,117,114,101
*/

encode⁹⁺

encode(src: Uint8Array, options?: Type): Promise<Uint8Array>

Encodes the input content into a Uint8Array object. This API uses a promise to return the result.

Atomic service API: This API can be used in atomic services since API version 11.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
src	Uint8Array	Yes	Uint8Array object to encode.
options12+	Type	No	Encoding format. The following values are available: - util.Type.BASIC (default): Base64 encoding. - util.Type.BASIC_URL_SAFE: Base64URL encoding.

Return value

Type	Description
Promise<Uint8Array>	Promise used to return the Uint8Array object obtained.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let base64Helper = new util.Base64Helper();
let array = new Uint8Array([115,49,51]);
base64Helper.encode(array).then((val) => {
  console.info(val.toString());
  // Output: 99,122,69,122
})

encodeToString⁹⁺

encodeToString(src: Uint8Array, options?: Type): Promise<string>

Encodes the input content into a string. This API uses a promise to return the result.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
src	Uint8Array	Yes	Uint8Array object to encode.
options10+	Type	No	Encoding format. The following values are available: - util.Type.BASIC (default): Base64 encoding. The return value does not contain carriage return characters or newline characters. - util.Type.MIME: Base64 encoding. Each line of the return value contains a maximum of 76 characters and ends with '\r\n'. - util.Type.BASIC_URL_SAFE: Base64URL encoding. The return value does not contain carriage return characters or newline characters. - util.Type.MIME_URL_SAFE: Base64URL encoding. Each line in the return value contains a maximum of 76 characters and ends with '\r\n'.

Return value

Type	Description
Promise<string>	Promise used to return the string obtained.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let base64Helper = new util.Base64Helper();
let array = new Uint8Array([77,97,110,105,115,100,105,115,116,105,110,103,117,105,115,104,101,100,110,111,116,111,110,108,121,98,121,104,105,115,114,101,97,115,111,110,98,117,116,98,121,116,104,105,115,115,105,110,103,117,108,97,114,112,97,115,115,105,111,110,102,114,111,109,111,116,104,101,114,97,110,105,109,97,108,115,119,104,105,99,104,105,115,97,108,117,115,116,111,102,116,104,101,109,105,110,100,101,120,99,101,101,100,115,116,104,101,115,104,111,114,116,118,101,104,101,109,101,110,99,101,111,102,97,110,121,99,97,114,110,97,108,112,108,101,97,115,117,114,101]);
base64Helper.encodeToString(array, util.Type.MIME).then((val) => {
  console.info(val);
  /*
  Output: TWFuaXNkaXN0aW5ndWlzaGVkbm90b25seWJ5aGlzcmVhc29uYnV0Ynl0aGlzc2luZ3VsYXJwYXNz
  aW9uZnJvbW90aGVyYW5pbWFsc3doaWNoaXNhbHVzdG9mdGhlbWluZGV4Y2VlZHN0aGVzaG9ydHZl
  aGVtZW5jZW9mYW55Y2FybmFscGxlYXN1cmU=
  */

})

decode⁹⁺

decode(src: Uint8Array | string, options?: Type): Promise<Uint8Array>

Decodes the input content into a Uint8Array object. This API uses a promise to return the result.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
src	Uint8Array | string	Yes	Uint8Array object or string to decode.
options10+	Type	No	Decoding format. The following values are available: - util.Type.BASIC (default): Base64 decoding. - util.Type.MIME: Base64 decoding. The input parameter src contains carriage return characters and newline characters. - util.Type.BASIC_URL_SAFE: Base64URL decoding. - util.Type.MIME_URL_SAFE: Base64 URL decoding. The input parameter src contains carriage return characters and newline characters.

Return value

Type	Description
Promise<Uint8Array>	Promise used to return the Uint8Array object obtained.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let base64Helper = new util.Base64Helper();
let array = 'TWFuaXNkaXN0aW5ndWlzaGVkbm90b25seWJ5aGlzcmVhc29uYnV0Ynl0aGlzc2luZ3VsYXJwYXNz\r\naW9uZnJvbW90aGVyYW5pbWFsc3doaWNoaXNhbHVzdG9mdGhlbWluZGV4Y2VlZHN0aGVzaG9ydHZl\r\naGVtZW5jZW9mYW55Y2FybmFscGxlYXN1cmU=\r\n';
base64Helper.decode(array, util.Type.MIME).then((val) => {
  console.info(val.toString());
  /*
  Output: 77,97,110,105,115,100,105,115,116,105,110,103,117,105,115,104,101,100,110,111,116,111,110,108,121,98,121,104,105,115,114,101,97,115,111,110,98,117,116,98,121,116,104,105,115,115,105,110,103,117,108,97,114,112,97,115,115,105,111,110,102,114,111,109,111,116,104,101,114,97,110,105,109,97,108,115,119,104,105,99,104,105,115,97,108,117,115,116,111,102,116,104,101,109,105,110,100,101,120,99,101,101,100,115,116,104,101,115,104,111,114,116,118,101,104,101,109,101,110,99,101,111,102,97,110,121,99,97,114,110,97,108,112,108,101,97,115,117,114,101
  */
})

StringDecoder¹²⁺

Provides the capability of decoding binary streams into strings. The following encoding types are supported: utf-8, iso-8859-2, koi8-r, macintosh, windows-1250, windows-1251, gbk, gb18030, big5, utf-16be, and UTF-16le.

constructor¹²⁺

constructor(encoding?: string)

Constructor used to create a StringDecoder instance.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
encoding	string	No	Encoding type of the input data. The default value is utf-8.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let decoder = new util.StringDecoder();

write¹²⁺

write(chunk: string | Uint8Array): string

Decodes a string. Any incomplete multi-byte characters at the end of Uint8Array are filtered out from the returned string and stored in an internal buffer for the next call.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
chunk	string | Uint8Array	Yes	String to decode. Decoding is performed based on the input encoding type. If the input is of the Uint8Array type, decoding is performed normally. If the input is of the string type, the parameter is directly returned.

Return value

Type	Description
string	String decoded.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let decoder = new util.StringDecoder('utf-8');
let input =  new Uint8Array([0xE4, 0xBD, 0xA0, 0xE5, 0xA5, 0xBD]);
const decoded = decoder.write(input);
console.info("decoded:", decoded);
// Output: decoded: Hello, World

end¹²⁺

end(chunk?: string | Uint8Array): string

Ends the decoding process and returns any remaining input stored in the internal buffer as a string.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
chunk	string | Uint8Array	No	String to decode. The default value is undefined.

Return value

Type	Description
string	String decoded.

Error codes

For details about the error codes, see Universal Error Codes.

ID	Error Message
401	Parameter error. Possible causes: 1. Mandatory parameters are left unspecified; 2. Incorrect parameter types.

Example

let decoder = new util.StringDecoder('utf-8');
let input = new Uint8Array([0xE4, 0xBD, 0xA0, 0xE5, 0xA5, 0xBD]);
const writeString = decoder.write(input.slice(0, 5));
const endString = decoder.end(input.slice(5));
console.info("writeString:", writeString);
// Output: writeString: Hello
console.info("endString:", endString);
// Output: endString: World

Type¹⁰⁺

Enumerates the Base64 encoding formats.

System capability: SystemCapability.Utils.Lang

Name	Value	Description
BASIC	0	Basic format. Atomic service API: This API can be used in atomic services since API version 11.
MIME	1	MIME format. Atomic service API: This API can be used in atomic services since API version 11.
BASIC_URL_SAFE12+	2	BASIC_URL_SAFE format. This value is supported since API version 12. Atomic service API: This API can be used in atomic services since API version 12.
MIME_URL_SAFE12+	3	MIME_URL_SAFE format. This value is supported since API version 12. Atomic service API: This API can be used in atomic services since API version 12.

types⁸⁺

Provides APIs to check different types of built-in objects, such as ArrayBuffer, Map, and Set, so as to avoid exceptions caused by type errors.

constructor⁸⁺

constructor()

A constructor used to create a Types object.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Example

let type = new util.types();

isAnyArrayBuffer⁸⁺

isAnyArrayBuffer(value: Object): boolean

Checks whether the value is of the ArrayBuffer or SharedArrayBuffer type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the ArrayBuffer or SharedArrayBuffer type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isAnyArrayBuffer(new ArrayBuffer(0));
console.info("result = " + result);
// Output: result = true

isArrayBufferView⁸⁺

isArrayBufferView(value: Object): boolean

Checks whether the value is of the ArrayBufferView type.

ArrayBufferView is a type representing any of the following: Int8Array, Int16Array, Int32Array, Uint8Array, Uint8ClampedArray, Uint32Array, Float32Array, Float64Array, and DataView.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the ArrayBufferView type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isArrayBufferView(new Int8Array([]));
console.info("result = " + result);
// Output: result = true

isArgumentsObject⁸⁺

isArgumentsObject(value: Object): boolean

Checks whether the value is an arguments object.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is an arguments object; otherwise, false is returned.

Example

let type = new util.types();
function foo() {
    let result = type.isArgumentsObject(arguments);
    console.info("result = " + result);
}
let f = foo();
// Output: result = true

isArrayBuffer⁸⁺

isArrayBuffer(value: Object): boolean

Checks whether the value is of the ArrayBuffer type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the ArrayBuffer type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isArrayBuffer(new ArrayBuffer(0));
console.info("result = " + result);
// Output: result = true

isAsyncFunction⁸⁺

isAsyncFunction(value: Object): boolean

Checks whether the value is an asynchronous function.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is an asynchronous function; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isAsyncFunction(async () => {});
console.info("result = " + result);
// Output: result = true

isBooleanObject^(deprecated)

isBooleanObject(value: Object): boolean

Checks whether the value is of the Boolean type.

NOTE

This API is supported since API version 8 and deprecated since API version 14. No substitute is provided.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Boolean type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isBooleanObject(new Boolean(true));
console.info("result = " + result);
// Output: result = true

isBoxedPrimitive^(deprecated)

isBoxedPrimitive(value: Object): boolean

Checks whether the value is of the Boolean, Number, String, or Symbol type.

NOTE

This API is supported since API version 8 and deprecated since API version 14. No substitute is provided.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Boolean, Number, String, or Symbol type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isBoxedPrimitive(new Boolean(false));
console.info("result = " + result);
// Output: result = true

isDataView⁸⁺

isDataView(value: Object): boolean

Checks whether the value is of the DataView type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the DataView type; otherwise, false is returned.

Example

let type = new util.types();
const ab = new ArrayBuffer(20);
let result = type.isDataView(new DataView(ab));
console.info("result = " + result);
// Output: result = true

isDate⁸⁺

isDate(value: Object): boolean

Checks whether the value is of the Date type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Date type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isDate(new Date());
console.info("result = " + result);
// Output: result = true

isExternal⁸⁺

isExternal(value: Object): boolean

Checks whether the value is of the native external type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the native external type; otherwise, false is returned.

Example

// /entry/src/main/cpp/napi_init.cpp
#include "napi/native_api.h"
#include <js_native_api.h>
#include <stdlib.h>

napi_value result;
static napi_value Testexternal(napi_env env, napi_callback_info info) {
    int* raw = (int*) malloc(1024);
    napi_status status = napi_create_external(env, (void*) raw, NULL, NULL, &result);
    if (status != napi_ok) {
        napi_throw_error(env, NULL, "create external failed");
        return NULL;
    }
    return result;
}

EXTERN_C_START
static napi_value Init(napi_env env, napi_value exports)
{
    napi_property_descriptor desc[] = {
        {"testexternal", nullptr, Testexternal, nullptr, nullptr, nullptr, napi_default, nullptr},
    };
    napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
    return exports;
}
EXTERN_C_END
// The code for module registration is omitted here. You may need to register the Testexternal method.
...

import testNapi from 'libentry.so';

let type = new util.types();
const data = testNapi.testexternal();
let result = type.isExternal(data);

let result01 = type.isExternal(true);
console.info("result = " + result);
console.info("result01 = " + result01);
// Output: result = true
// Output: result01 = false

isFloat32Array⁸⁺

isFloat32Array(value: Object): boolean

Checks whether the value is of the Float32Array type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Float32Array type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isFloat32Array(new Float32Array());
console.info("result = " + result);
// Output: result = true

isFloat64Array⁸⁺

isFloat64Array(value: Object): boolean

Checks whether the value is of the Float64Array type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Float64Array type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isFloat64Array(new Float64Array());
console.info("result = " + result);
// Output: result = true

isGeneratorFunction⁸⁺

isGeneratorFunction(value: Object): boolean

Checks whether the value is a generator function.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is a generator function; otherwise, false is returned.

Example

// /entry/src/main/ets/pages/test.ts
export function* foo() {}

import { foo } from './test'

let type = new util.types();
let result = type.isGeneratorFunction(foo);
console.info("result = " + result);
// Output: result = true

isGeneratorObject⁸⁺

isGeneratorObject(value: Object): boolean

Checks whether the value is a generator object.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is a generator object; otherwise, false is returned.

Example

// /entry/src/main/ets/pages/test.ts
function* foo() {}
export const generator = foo();

import { generator } from './test'

let type = new util.types();
let result = type.isGeneratorObject(generator);
console.info("result = " + result);
// Output: result = true

isInt8Array⁸⁺

isInt8Array(value: Object): boolean

Checks whether the value is of the Int8Array type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Int8Array type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isInt8Array(new Int8Array([]));
console.info("result = " + result);
// Output: result = true

isInt16Array⁸⁺

isInt16Array(value: Object): boolean

Checks whether the value is of the Int16Array type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Int16Array type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isInt16Array(new Int16Array([]));
console.info("result = " + result);
// Output: result = true

isInt32Array⁸⁺

isInt32Array(value: Object): boolean

Checks whether the value is of the Int32Array type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Int32Array type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isInt32Array(new Int32Array([]));
console.info("result = " + result);
// Output: result = true

isMap⁸⁺

isMap(value: Object): boolean

Checks whether the value is of the Map type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Map type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isMap(new Map());
console.info("result = " + result);
// Output: result = true

isMapIterator⁸⁺

isMapIterator(value: Object): boolean

Checks whether the value is of the MapIterator type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the MapIterator type; otherwise, false is returned.

Example

let type = new util.types();
const map : Map<number,number> = new Map();
let result = type.isMapIterator(map.keys());
console.info("result = " + result);
// Output: result = true

isNativeError⁸⁺

isNativeError(value: Object): boolean

Checks whether the value is of the Error type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Error type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isNativeError(new TypeError());
console.info("result = " + result);
// Output: result = true

isNumberObject^(deprecated)

isNumberObject(value: Object): boolean

Checks whether the value is of the Number type.

NOTE

This API is supported since API version 8 and deprecated since API version 14. No substitute is provided.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Number type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isNumberObject(new Number(0));
console.info("result = " + result);
// Output: result = true

isPromise⁸⁺

isPromise(value: Object): boolean

Checks whether the value is a promise.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is a promise; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isPromise(Promise.resolve(1));
console.info("result = " + result);
// Output: result = true

isProxy⁸⁺

isProxy(value: Object): boolean

Checks whether the value is a proxy.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is a proxy; otherwise, false is returned.

Example

class Target{
}
let type = new util.types();
const target : Target = {};
const proxy = new Proxy(target, target);
let result = type.isProxy(proxy);
console.info("result = " + result);
// Output: result = true

isRegExp⁸⁺

isRegExp(value: Object): boolean

Checks whether the value is of the RegExp type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the RegExp type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isRegExp(new RegExp('abc'));
console.info("result = " + result);
// Output: result = true

isSet⁸⁺

isSet(value: Object): boolean

Checks whether the value is of the Set type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Set type; otherwise, false is returned.

Example

let type = new util.types();
let set : Set<number> = new Set();
let result = type.isSet(set);
console.info("result = " + result);
// Output: result = true

isSetIterator⁸⁺

isSetIterator(value: Object): boolean

Checks whether the value is of the SetIterator type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the SetIterator type; otherwise, false is returned.

Example

let type = new util.types();
const set : Set<number> = new Set();
let result = type.isSetIterator(set.keys());
console.info("result = " + result);
// Output: result = true

isStringObject^(deprecated)

isStringObject(value: Object): boolean

Checks whether the value is a string object.

NOTE

This API is supported since API version 8 and deprecated since API version 14. No substitute is provided.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is a string object; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isStringObject(new String('foo'));
console.info("result = " + result);
// Output: result = true

isSymbolObject^(deprecated)

isSymbolObject(value: Object): boolean

Checks whether the value is a symbol object.

NOTE

This API is supported since API version 8 and deprecated since API version 14. No substitute is provided.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is a symbol object; otherwise, false is returned.

Example

// /entry/src/main/ets/pages/test.ts
export const symbols = Symbol('foo');

import { symbols } from './test'

let type = new util.types();
let result = type.isSymbolObject(Object(symbols));
console.info("result = " + result);
// Output: result = true

isTypedArray⁸⁺

isTypedArray(value: Object): boolean

Checks whether the value is of the TypedArray type.

TypedArray is a type representing any of the following: Int8Array, Int16Array, Int32Array, Uint8Array, Uint8ClampedArray, Uint16Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, and BigUint64Array.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the TypedArray type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isTypedArray(new Float64Array([]));
console.info("result = " + result);
// Output: result = true

isUint8Array⁸⁺

isUint8Array(value: Object): boolean

Checks whether the value is of the Uint8Array type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Uint8Array type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isUint8Array(new Uint8Array([]));
console.info("result = " + result);
// Output: result = true

isUint8ClampedArray⁸⁺

isUint8ClampedArray(value: Object): boolean

Checks whether the value is of the Uint8ClampedArray type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Uint8ClampedArray type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isUint8ClampedArray(new Uint8ClampedArray([]));
console.info("result = " + result);
// Output: result = true

isUint16Array⁸⁺

isUint16Array(value: Object): boolean

Checks whether the value is of the Uint16Array type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Uint16Array type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isUint16Array(new Uint16Array([]));
console.info("result = " + result);
// Output: result = true

isUint32Array⁸⁺

isUint32Array(value: Object): boolean

Checks whether the value is of the Uint32Array type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the Uint32Array type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isUint32Array(new Uint32Array([]));
console.info("result = " + result);
// Output: result = true

isWeakMap⁸⁺

isWeakMap(value: Object): boolean

Checks whether the value is of the WeakMap type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the WeakMap type; otherwise, false is returned.

Example

let type = new util.types();
let value : WeakMap<object, number> = new WeakMap();
let result = type.isWeakMap(value);
console.info("result = " + result);
// Output: result = true

isWeakSet⁸⁺

isWeakSet(value: Object): boolean

Checks whether the value is of the WeakSet type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the WeakSet type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isWeakSet(new WeakSet());
console.info("result = " + result);
// Output: result = true

isBigInt64Array⁸⁺

isBigInt64Array(value: Object): boolean

Checks whether the value is of the BigInt64Array type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the BigInt64Array type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isBigInt64Array(new BigInt64Array([]));
console.info("result = " + result);
// Output: result = true

isBigUint64Array⁸⁺

isBigUint64Array(value: Object): boolean

Checks whether the value is of the BigUint64Array type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the BigUint64Array type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isBigUint64Array(new BigUint64Array([]));
console.info("result = " + result);
// Output: result = true

isModuleNamespaceObject⁸⁺

isModuleNamespaceObject(value: Object): boolean

Checks whether the value is a module namespace object.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is a module namespace object; otherwise, false is returned.

Example

// /entry/src/main/ets/pages/test.ts
export function func() {
  console.info("hello world");
}

import * as nameSpace from './test';

let type = new util.types();
let result = type.isModuleNamespaceObject(nameSpace);
console.info("result = " + result);
// Output: result = true

isSharedArrayBuffer⁸⁺

isSharedArrayBuffer(value: Object): boolean

Checks whether the value is of the SharedArrayBuffer type.

Atomic service API: This API can be used in atomic services since API version 12.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	Object	Yes	Object to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is of the SharedArrayBuffer type; otherwise, false is returned.

Example

let type = new util.types();
let result = type.isSharedArrayBuffer(new SharedArrayBuffer(0));
console.info("result = " + result);
// Output: result = true

AutoFinalizer<T>²²⁺

AutoFinalizer is a class that provides callback APIs when an ArkTS object is released. By implementing it, you can customize the resource cleanup logic that triggers automatically when an object is reclaimed.

NOTE

AutoFinalizer<T> must be used together with AutoFinalizerCleaner<T>. Implementing AutoFinalizer<T> alone will yield no functionality.

onFinalization²²⁺

onFinalization(heldValue: T): void

Defines the resource cleanup callback that triggers automatically when an object is reclaimed.

Atomic service API: This API can be used in atomic services since API version 22.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
heldValue	T	Yes	When the listened object is reclaimed, this value is passed to the onFinalization callback method.

AutoFinalizerCleaner<T>²²⁺

AutoFinalizerCleaner is a utility class that associates an object's lifecycle with resource cleanup logic. Its primary role is to bind an object implementing AutoFinalizer<T> to a specific value, and automatically trigger the resource cleanup callback when the object is reclaimed.

register<T>²²⁺

static register<T>(obj: AutoFinalizer<T>, heldValue: T): void

Associates an object implementing AutoFinalizer with an input value, and triggers the resource cleanup callback when the object is reclaimed.

Atomic service API: This API can be used in atomic services since API version 22.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
obj	AutoFinalizer<T>	Yes	Object that implements AutoFinalizer. The onFinalization method is called when the object is reclaimed.
heldValue	T	Yes	When the listened object is reclaimed, this value is passed to the obj.onFinalization method.

Example

class DeviceManageViewModel implements util.AutoFinalizer<string> {
  constructor(heldValue: string) {
    util.AutoFinalizerCleaner.register(this, heldValue);
  }

  onFinalization(heldValue: string) {
    console.info("onFinalization: ", heldValue);
    // Wait for the garbage collection to be triggered. Once it is triggered, the following result is displayed: onFinalization: test
  }
}

const device = new DeviceManageViewModel("test");

LruBuffer^(deprecated)

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache⁹⁺ instead.

Properties

System capability: SystemCapability.Utils.Lang

Name	Type	Read-Only	Optional	Description
length	number	Yes	No	Total number of values in this cache.

Example

let pro : util.LruBuffer<number,number>= new util.LruBuffer();
pro.put(2,10);
pro.put(1,8);
let result = pro.length;
console.info("result = " + result);
// Output: result = 2

constructor^(deprecated)

constructor(capacity?: number)

A constructor used to create a LruBuffer instance. The default capacity of the cache is 64.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.constructor⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
capacity	number	No	Capacity of the cache to create. The default value is 64.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();

updateCapacity^(deprecated)

updateCapacity(newCapacity: number): void

Changes the cache capacity. If the new capacity is less than or equal to 0, an exception will be thrown.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.updateCapacity⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
newCapacity	number	Yes	New capacity of the cache.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
pro.updateCapacity(100);

toString^(deprecated)

toString(): string

Obtains the string representation of this cache.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.toString⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
string	String representation of this cache.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
pro.put(2,10);
pro.get(2);
pro.remove(20);
let result = pro.toString();
console.info("result = " + result);
// Output: result = Lrubuffer[ maxSize = 64, hits = 1, misses = 0, hitRate = 100% ]

getCapacity^(deprecated)

getCapacity(): number

Obtains the capacity of this cache.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.getCapacity⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
number	Capacity of the cache.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
let result = pro.getCapacity();
console.info("result = " + result);
// Output: result = 64

clear^(deprecated)

clear(): void

Clears key-value pairs from this cache. The afterRemoval() API will be called to perform subsequent operations.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.clear⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
pro.put(2,10);
let result = pro.length;
pro.clear();

getCreateCount^(deprecated)

getCreateCount(): number

Obtains the number of return values for createDefault().

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.getCreateCount⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
number	Number of return values for createDefault().

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
pro.put(1,8);
let result = pro.getCreateCount();
console.info("result = " + result);
// Output: result = 0

getMissCount^(deprecated)

getMissCount(): number

Obtains the number of times that the queried values are mismatched.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.getMissCount⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
number	Number of times that the queried values are mismatched.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
pro.put(2,10);
pro.get(2);
let result = pro.getMissCount();
console.info("result = " + result);
// Output: result = 0

getRemovalCount^(deprecated)

getRemovalCount(): number

Obtains the number of removals from this cache.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.getRemovalCount⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
number	Number of removals from the cache.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
pro.put(2,10);
pro.updateCapacity(2);
pro.put(50,22);
let result = pro.getRemovalCount();
console.info("result = " + result);
// Output: result = 0

getMatchCount^(deprecated)

getMatchCount(): number

Obtains the number of times that the queried values are matched.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.getMatchCount⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
number	Number of times that the queried values are matched.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
pro.put(2,10);
pro.get(2);
let result = pro.getMatchCount();
console.info("result = " + result);
// Output: result = 1

getPutCount^(deprecated)

getPutCount(): number

Obtains the number of additions to this cache.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.getPutCount⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
number	Number of additions to the cache.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
pro.put(2,10);
let result = pro.getPutCount();
console.info("result = " + result);
// Output: result = 1

isEmpty^(deprecated)

isEmpty(): boolean

Checks whether this cache is empty.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.isEmpty⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
boolean	Returns true if the cache does not contain any value.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
pro.put(2,10);
let result = pro.isEmpty();
console.info("result = " + result);
// Output: result = false

get^(deprecated)

get(key: K): V | undefined

Obtains the value of the specified key.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.get⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
key	K	Yes	Key based on which the value is queried.

Return value

Type	Description
V | undefined	Value of the key. If no match is found, undefined is returned.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
pro.put(2,10);
let result  = pro.get(2);
console.info("result = " + result);
// Output: result = 10

put^(deprecated)

put(key: K,value: V): V

Adds a key-value pair to this cache.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.put⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
key	K	Yes	Key of the key-value pair to add.
value	V	Yes	Value of the key-value pair to add.

Return value

Type	Description
V	Value added. If the key already exists, the existing value is returned; if null is passed in for key or value, an error is thrown.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
let result = pro.put(2,10);
console.info("result = " + result);
// Output: result = 10

values^(deprecated)

values(): V[]

Obtains all values in this cache, listed from the most to the least recently accessed.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.values⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
V []	All values in the cache, listed from the most to the least recently accessed.

Example

let pro : util.LruBuffer<number|string,number|string> = new util.LruBuffer();
pro.put(2,10);
pro.put(2,"anhu");
pro.put("afaf","grfb");
let result = pro.values();
console.info("result = " + result);
// Output: result = anhu,grfb

keys^(deprecated)

keys(): K[]

Obtains all keys in this cache, listed from the most to the least recently accessed.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.keys⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
K []	All keys in the cache, listed from the most to the least recently accessed.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
pro.put(2,10);
let result = pro.keys();
console.info("result = " + result);
// Output: result = 2

remove^(deprecated)

remove(key: K): V | undefined

Removes the specified key and its value from this cache.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.remove⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
key	K	Yes	Key to remove.

Return value

Type	Description
V | undefined	Optional object containing the removed key-value pair. If the key does not exist, an empty Optional object is returned; if null is passed in for key, an error is thrown.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
pro.put(2,10);
let result = pro.remove(20);
console.info("result = " + result);
// Output: result = undefined

afterRemoval^(deprecated)

afterRemoval(isEvict: boolean,key: K,value: V,newValue: V): void

Performs subsequent operations after a value is removed.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.afterRemoval⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
isEvict	boolean	Yes	Whether the capacity is insufficient. If the value is true, this API is called due to insufficient capacity.
key	K	Yes	Key removed.
value	V	Yes	Value removed.
newValue	V	Yes	New value for the key if the put() method is called and the key to be added already exists. In other cases, this parameter is left blank.

Example

class ChildLruBuffer<K, V> extends util.LruBuffer<K, V> {
  constructor(capacity?: number) {
    super(capacity);
  }

  afterRemoval(isEvict: boolean, key: K, value: V, newValue: V): void {
    if (isEvict === true) {
      console.info('key: ' + key);
      // Output: key: 11
      console.info('value: ' + value);
      // Output: value: 1
      console.info('newValue: ' + newValue);
      // Output: newValue: null
    }
  }
}
let lru: ChildLruBuffer<number, number> = new ChildLruBuffer(2);
lru.put(11, 1);
lru.put(22, 2);
lru.put(33, 3);

contains^(deprecated)

contains(key: K): boolean

Checks whether this cache contains the specified key.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.contains⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
key	K	Yes	Key to check.

Return value

Type	Description
boolean	Check result. The value true is returned if the cache contains the specified key; otherwise, false is returned.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
pro.put(2,10);
let result = pro.contains(20);
console.info('result = ' + result);
// Output: result = false

createDefault^(deprecated)

createDefault(key: K): V

Creates a value if the value of the specified key is not available.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.createDefault⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
key	K	Yes	Key of which the value is missing.

Return value

Type	Description
V	Value of the key.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
let result = pro.createDefault(50);

entries^(deprecated)

entries(): IterableIterator<[K, V]>

Obtains a new iterator object that contains all key-value pairs in this object.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.entries⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
IterableIterator<[K, V]>	Iterable array.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
pro.put(2,10);
let result = pro.entries();

[Symbol.iterator]^(deprecated)

[Symbol.iterator](): IterableIterator<[K, V]>

Obtains a two-dimensional array in key-value pairs.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use LRUCache.[Symbol.iterator]⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
IterableIterator<[K, V]>	Two-dimensional array in key-value pairs.

Example

let pro : util.LruBuffer<number,number> = new util.LruBuffer();
pro.put(2,10);
let result = pro[Symbol.iterator]();

Scope^(deprecated)

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use ScopeHelper⁹⁺ instead.

constructor^(deprecated)

constructor(lowerObj: ScopeType, upperObj: ScopeType)

A constructor used to create a Scope object with the specified upper and lower limits.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use ScopeHelper.constructor⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
lowerObj	ScopeType	Yes	Lower limit of the Scope object.
upperObj	ScopeType	Yes	Upper limit of the Scope object.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let range = new util.Scope(tempLower, tempUpper);
console.info("range = " + range);
// Output: range = [30, 40]

toString^(deprecated)

toString(): string

Obtains a string representation that contains this Scope.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use ScopeHelper.toString⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
string	String representation containing the Scope.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let range = new util.Scope(tempLower, tempUpper);
let result = range.toString();
console.info("result = " + result);
// Output: result = [30, 40]

intersect^(deprecated)

intersect(range: Scope): Scope

Obtains the intersection of this Scope and the given Scope.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use ScopeHelper.intersect⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
range	Scope	Yes	Scope specified.

Return value

Type	Description
Scope	Intersection of this Scope and the given Scope.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let range = new util.Scope(tempLower, tempUpper);
let tempMiDF = new Temperature(35);
let tempMidS = new Temperature(39);
let rangeFir = new util.Scope(tempMiDF, tempMidS);
let result = range.intersect(rangeFir );
console.info("result = " + result);
  // Output: result = [35, 39]

intersect^(deprecated)

intersect(lowerObj:ScopeType,upperObj:ScopeType):Scope

Obtains the intersection of this Scope and the given lower and upper limits.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use ScopeHelper.intersect⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
lowerObj	ScopeType	Yes	Lower limit.
upperObj	ScopeType	Yes	Upper limit.

Return value

Type	Description
Scope	Intersection of this Scope and the given lower and upper limits.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let tempMiDF = new Temperature(35);
let tempMidS = new Temperature(39);
let range = new util.Scope(tempLower, tempUpper);
let result = range.intersect(tempMiDF, tempMidS);
console.info("result = " + result);
// Output: result = [35, 39]

getUpper^(deprecated)

getUpper(): ScopeType

Obtains the upper limit of this Scope.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use ScopeHelper.getUpper⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
ScopeType	Upper limit of this Scope.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let range = new util.Scope(tempLower, tempUpper);
let result = range.getUpper();
console.info("result = " + result);
// Output: result = 40

getLower^(deprecated)

getLower(): ScopeType

Obtains the lower limit of this Scope.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use ScopeHelper.getLower⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Return value

Type	Description
ScopeType	Lower limit of this Scope.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let range = new util.Scope(tempLower, tempUpper);
let result = range.getLower();
console.info("result = " + result);
// Output: result = 30

expand^(deprecated)

expand(lowerObj: ScopeType,upperObj: ScopeType): Scope

Obtains the union set of this Scope and the given lower and upper limits.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use ScopeHelper.expand⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
lowerObj	ScopeType	Yes	Lower limit.
upperObj	ScopeType	Yes	Upper limit.

Return value

Type	Description
Scope	Union set of this Scope and the given lower and upper limits.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let tempMiDF = new Temperature(35);
let tempMidS = new Temperature(39);
let range = new util.Scope(tempLower, tempUpper);
let result = range.expand(tempMiDF, tempMidS);
console.info("result = " + result);
// Output: result = [30, 40]

expand^(deprecated)

expand(range: Scope): Scope

Obtains the union set of this Scope and the given Scope.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use ScopeHelper.expand⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
range	Scope	Yes	Scope specified.

Return value

Type	Description
Scope	Union set of this Scope and the given Scope.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let tempMiDF = new Temperature(35);
let tempMidS = new Temperature(39);
let range = new util.Scope(tempLower, tempUpper);
let rangeFir = new util.Scope(tempMiDF, tempMidS);
let result = range.expand(rangeFir);
console.info("result = " + result);
// Output: result = [30, 40]

expand^(deprecated)

expand(value: ScopeType): Scope

Obtains the union set of this Scope and the given value.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use ScopeHelper.expand⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	ScopeType	Yes	Value specified.

Return value

Type	Description
Scope	Union set of this Scope and the given value.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let tempMiDF = new Temperature(35);
let range = new util.Scope(tempLower, tempUpper);
let result = range.expand(tempMiDF);
console.info("result = " + result);
// Output: result = [30, 40]

contains^(deprecated)

contains(value: ScopeType): boolean

Checks whether a value is within this Scope.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use ScopeHelper.contains⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	ScopeType	Yes	Value specified.

Return value

Type	Description
boolean	Check result. The value true is returned if the value is within this Scope; otherwise, false is returned.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let tempMiDF = new Temperature(35);
let range = new util.Scope(tempLower, tempUpper);
let result = range.contains(tempMiDF);
console.info("result = " + result);
// Output: result = true

contains^(deprecated)

contains(range: Scope): boolean

Checks whether a range is within this Scope.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use ScopeHelper.contains⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
range	Scope	Yes	Scope specified.

Return value

Type	Description
boolean	Check result. The value true is returned if the range is within this Scope; otherwise, false is returned.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let range = new util.Scope(tempLower, tempUpper);
let tempLess = new Temperature(20);
let tempMore = new Temperature(45);
let rangeSec = new util.Scope(tempLess, tempMore);
let result = range.contains(rangeSec);
console.info("result = " + result);
// Output: result = false

clamp^(deprecated)

clamp(value: ScopeType): ScopeType

Limits a value to this Scope.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use ScopeHelper.clamp⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
value	ScopeType	Yes	Value specified.

Return value

Type	Description
ScopeType	Returns lowerObj if the specified value is less than the lower limit; returns upperObj if the specified value is greater than the upper limit; returns the specified value if it is within this Scope.

Example

class Temperature implements util.ScopeComparable {
  private readonly _temp: number;

  constructor(value: number) {
    this._temp = value;
  }

  compareTo(value: Temperature) {
    return this._temp >= value.getTemp();
  }

  getTemp() {
    return this._temp;
  }

  toString(): string {
    return this._temp.toString();
  }
}

let tempLower = new Temperature(30);
let tempUpper = new Temperature(40);
let tempMiDF = new Temperature(35);
let range = new util.Scope(tempLower, tempUpper);
let result = range.clamp(tempMiDF);
console.info("result = " + result);
// Output: result = 35

Base64^(deprecated)

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use Base64Helper⁹⁺ instead.

constructor^(deprecated)

constructor()

A constructor used to create a Base64 object.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use Base64Helper.constructor⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Example

let base64 = new  util.Base64();

encodeSync^(deprecated)

encodeSync(src: Uint8Array): Uint8Array

Performs Base64 encoding on the input Uint8Array byte array and returns the encoded Uint8Array.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use Base64Helper.encodeSync⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
src	Uint8Array	Yes	Uint8Array object to encode.

Return value

Type	Description
Uint8Array	Uint8Array object obtained.

Example

let base64 = new util.Base64();
let array = new Uint8Array([115,49,51]);
let result = base64.encodeSync(array);
console.info("result = " + result);
// Output: result = 99,122,69,122

encodeToStringSync^(deprecated)

encodeToStringSync(src: Uint8Array): string

Performs Base64 encoding on the input Uint8Array byte array and returns the encoded string.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use Base64Helper.encodeToStringSync⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
src	Uint8Array	Yes	Uint8Array object to encode.

Return value

Type	Description
string	String obtained.

Example

let base64 = new util.Base64();
let array = new Uint8Array([115,49,51]);
let result = base64.encodeToStringSync(array);
console.info("result = " + result);
// Output: result = czEz

decodeSync^(deprecated)

decodeSync(src: Uint8Array | string): Uint8Array

Decodes the input content into a Uint8Array object.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use Base64Helper.decodeSync⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
src	Uint8Array | string	Yes	Uint8Array object or string to decode.

Return value

Type	Description
Uint8Array	Uint8Array object obtained.

Example

let base64 = new util.Base64();
let buff = 'czEz';
let result = base64.decodeSync(buff);
console.info("result = " + result);
// Output: result = 115,49,51

encode^(deprecated)

encode(src: Uint8Array): Promise<Uint8Array>

Encodes the input content into a Uint8Array object. This API uses a promise to return the result.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use Base64Helper.encode⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
src	Uint8Array	Yes	Uint8Array object to encode.

Return value

Type	Description
Promise<Uint8Array>	Promise used to return the Uint8Array object obtained.

Example

let base64 = new util.Base64();
let array = new Uint8Array([115,49,51]);
base64.encode(array).then((val) => {
  console.info(val.toString());
  // Output: 99,122,69,122
})

encodeToString^(deprecated)

encodeToString(src: Uint8Array): Promise<string>

Encodes the input content into a string. This API uses a promise to return the result.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use Base64Helper.encodeToString⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
src	Uint8Array	Yes	Uint8Array object to encode.

Return value

Type	Description
Promise<string>	Promise used to return the string obtained.

Example

let base64 = new util.Base64();
let array = new Uint8Array([115,49,51]);
base64.encodeToString(array).then((val) => {
    console.info(val);
    // Output: czEz
})

decode^(deprecated)

decode(src: Uint8Array | string): Promise<Uint8Array>

Decodes the input content into a Uint8Array object. This API uses a promise to return the result.

NOTE

This API is supported since API version 8 and deprecated since API version 9. You are advised to use Base64Helper.decode⁹⁺ instead.

System capability: SystemCapability.Utils.Lang

Parameters

Name	Type	Mandatory	Description
src	Uint8Array | string	Yes	Uint8Array object or string to decode.

Return value

Type	Description
Promise<Uint8Array>	Promise used to return the Uint8Array object obtained.

Example

let base64 = new util.Base64();
let array = new Uint8Array([99,122,69,122]);
base64.decode(array).then((val) => {
  console.info(val.toString());
  // Output: 115,49,51
})