Public

Console.log

Console.error

Promise.then

Promise.catch

Array.push

JSON.stringify

Array.length

Array.map

String.indexOf

fetch

Window.location

Window.addEventListener

ObjectConstructor.keys

Array.forEach

Location.reload

Response.status

Navigator.serviceWorker

ServiceWorkerContainer.register

ServiceWorkerRegistration.installing

ServiceWorkerContainer.controller

object

bool

strict

array

argv

optionalBool

skipPrintf

length

isError

slice

string

equal

apply

parseConstructorArguments

/**
 * Normalized forms, producing an object with the following properties.
 * @private
 * @typedef {Object} ParsedOptions parsed Options
 * @param {Object} options e- quivalent to "options" in third form. This will
 *              never
 *    			be a direct reference to what the caller passed in
 *    			(i.e., it may be a shallow copy), so it can be freely
 *    			modified.
 * @param {String} shortmessage - result of sprintf(sprintf_args), taking
 *              `options.strict` into account as described in README.md.
 */

/**
 * Common function used to parse constructor arguments for VError, WError, and
 * SError.  Named arguments to this function:
 *
 *     strict		force strict interpretation of sprintf arguments, even
 *     			if the options in "argv" don't say so
 *
 *     argv		error's constructor arguments, which are to be
 *     			interpreted as described in README.md.  For quick
 *     			reference, "argv" has one of the following forms:
 *
 *          [ sprintf_args... ]           (argv[0] is a string)
 *          [ cause, sprintf_args... ]    (argv[0] is an Error)
 *          [ options, sprintf_args... ]  (argv[0] is an object)
 *

 * @private
 * @param {Array} args - arguments
 * @returns {ParsedOptions} parsed options
 */

/*
     * First, figure out which form of invocation we've been given.
     */

'first argument to VError, PError, SError, or WError '

'constructor must be a string, object, or Error'

/*
     * Now construct the error's message.
     *
     * extsprintf (which we invoke here with our caller's arguments in order
     * to construct this Error's message) is strict in its interpretation of
     * values to be processed by the "%s" specifier.  The value passed to
     * extsprintf must actually be a string or something convertible to a
     * String using .toString().  Passing other values (notably "null" and
     * "undefined") is considered a programmer error.  The assumption is
     * that if you actually want to print the string "null" or "undefined",
     * then that's easy to do that when you're calling extsprintf; on the
     * other hand, if you did NOT want that (i.e., there's actually a bug
     * where the program assumes some variable is non-null and tries to
     * print it, which might happen when constructing a packet or file in
     * some specific format), then it's better to stop immediately than
     * produce bogus output.
     *
     * However, sometimes the bug is only in the code calling VError, and a
     * programmer might prefer to have the error message contain "null" or
     * "undefined" rather than have the bug in the error path crash the
     * program (making the first bug harder to identify).  For that reason,
     * by default VError converts "null" or "undefined" arguments to their
     * string representations and passes those to extsprintf.  Programmers
     * desiring the strict behavior can use the SError class or pass the
     * "strict" option to the VError constructor.
     */

'only one argument is allowed with options.skipPrintf'

How to use skipPrintffunctionin Array

Best JavaScript code snippets using builtins.Array.skipPrintf(Showing top 1 results out of 315)

How to use
skipPrintf
function
in
Array