Unicode里的抽象字符（Abstract
characters）有类似于LATIN SMALL LETTER A的名字，Code point是一个和抽象字符相关联的数字，比如U+0061，其中U表示Unicode。从U+n0000到U+nFFFF，65536个连续的code
points叫做一个plane，如下：
int nr = maybe.ToChecked(); EXPECT_EQ(nr, 10); EXPECT_EQ(maybe.FromJust(), 10);
Maybe<int> nothing = Nothing<int>(); int value = nothing.FromMaybe(22); EXPECT_EQ(value, 22); }
/* * I think the intention with a type Maybe<void> is that we don't really * care/want to have a value in the Maybe apart from that is is empty or * something. So instead of having a bool and setting it to true just * have void and return an empty. I think this signals the intent of a * function better as one might otherwise wonder what the value in the maybe * represents. */ Maybe<void> doit(int x){ if (x == -1) { returnNothing<void>(); } returnJustVoid(); }
classV8_EXPORT Array : public Object { public: uint32_tLength()const;
/** * Creates a JavaScript array with the given length. If the length * is negative the returned array will have length 0. */ static Local<Array> New(Isolate* isolate, int length = 0);
/** * Creates a JavaScript array out of a Local<Value> array in C++ * with a known length. */ static Local<Array> New(Isolate* isolate, Local<Value>* elements, size_t length); V8_INLINE static Array* Cast(Value* obj);
i::Handle<i::FixedArray> result = factory->NewFixedArray(len); for (int i = 0; i < len; i++) { i::Handle<i::Object> element = Utils::OpenHandle(*elements[i]); result->set(i, *element); }
class V8_EXPORT JSON { public: /** * Tries to parse the string |json_string| and returns it as value if * successful. * * \param the context in which to parse and create the value. * \param json_string The string to parse. * \return The corresponding value if successfully parsed. */ static V8_WARN_UNUSED_RESULT MaybeLocal<Value> Parse( Local<Context> context, Local<String> json_string);
/** * Tries to stringify the JSON-serializable object |json_object| and returns * it as string if successful. * * \param json_object The JSON-serializable object to stringify. * \return The corresponding string if successfully stringified. */ static V8_WARN_UNUSED_RESULT MaybeLocal<String> Stringify( Local<Context> context, Local<Value> json_object, Local<String> gap = Local<String>()); };
classV8_EXPORT TryCatch { public: /** * Creates a new try/catch block and registers it with v8. Note that * all TryCatch blocks should be stack allocated because the memory * location itself is compared against JavaScript try/catch blocks. */ explicitTryCatch(Isolate* isolate);
/** * Unregisters and deletes this try/catch block. */ ~TryCatch();
/** * Returns true if an exception has been caught by this try/catch block. */ boolHasCaught()const;
/** * For certain types of exceptions, it makes no sense to continue execution. * * If CanContinue returns false, the correct action is to perform any C++ * cleanup needed and then return. If CanContinue returns false and * HasTerminated returns true, it is possible to call * CancelTerminateExecution in order to continue calling into the engine. */ boolCanContinue()const;
/** * Returns true if an exception has been caught due to script execution * being terminated. * * There is no JavaScript representation of an execution termination * exception. Such exceptions are thrown when the TerminateExecution * methods are called to terminate a long-running script. * * If such an exception has been thrown, HasTerminated will return true, * indicating that it is possible to call CancelTerminateExecution in order * to continue calling into the engine. */ boolHasTerminated()const;
/** * Throws the exception caught by this TryCatch in a way that avoids * it being caught again by this same TryCatch. As with ThrowException * it is illegal to execute any JavaScript operations after calling * ReThrow; the caller must return immediately to where the exception * is caught. */ Local<Value> ReThrow();
/** * Returns the exception caught by this try/catch block. If no exception has * been caught an empty handle is returned. */ Local<Value> Exception()const;
/** * Returns the .stack property of an object. If no .stack * property is present an empty handle is returned. */ V8_WARN_UNUSED_RESULT static MaybeLocal<Value> StackTrace( Local<Context> context, Local<Value> exception);
/** * Returns the .stack property of the thrown object. If no .stack property is * present or if this try/catch block has not caught an exception, an empty * handle is returned. */ V8_WARN_UNUSED_RESULT MaybeLocal<Value> StackTrace( Local<Context> context)const;
/** * Returns the message associated with this exception. If there is * no message associated an empty handle is returned. */ Local<v8::Message> Message()const;
/** * Clears any exceptions that may have been caught by this try/catch block. * After this method has been called, HasCaught() will return false. Cancels * the scheduled exception if it is caught and ReThrow() is not called before. * * It is not necessary to clear a try/catch block before using it again; if * another exception is thrown the previously caught exception will just be * overwritten. However, it is often a good idea since it makes it easier * to determine which operation threw a given exception. */ voidReset();
/** * Set verbosity of the external exception handler. * * By default, exceptions that are caught by an external exception * handler are not reported. Call SetVerbose with true on an * external exception handler to have exceptions caught by the * handler reported as if they were not caught. */ voidSetVerbose(bool value);
/** * Returns true if verbosity is enabled. */ boolIsVerbose()const;
/** * Set whether or not this TryCatch should capture a Message object * which holds source information about where the exception * occurred. True by default. */ voidSetCaptureMessage(bool value);
/** * There are cases when the raw address of C++ TryCatch object cannot be * used for comparisons with addresses into the JS stack. The cases are: * 1) ARM, ARM64 and MIPS simulators which have separate JS stack. * 2) Address sanitizer allocates local C++ object in the heap when * UseAfterReturn mode is enabled. * This method returns address that can be used for comparisons with * addresses into the JS stack. When neither simulator nor ASAN's * UseAfterReturn is enabled, then the address returned will be the address * of the C++ try catch handler itself. */ staticvoid* JSStackComparableAddress(TryCatch* handler){ if (handler == nullptr) returnnullptr; return handler->js_stack_comparable_address_; }
private: // Declaring operator new and delete as deleted is not spec compliant. // Therefore declare them private instead to disable dynamic alloc void* operatornew(size_t size); void* operatornew[](size_t size); voidoperatordelete(void*, size_t); voidoperatordelete[](void*, size_t);
/** * Creates an error message for the given exception. * Will try to reconstruct the original stack trace from the exception value, * or capture the current stack trace if not available. */ static Local<Message> CreateMessage(Isolate* isolate, Local<Value> exception);
/** * Returns the original stack trace that was captured at the creation time * of a given exception, or an empty handle if not available. */ static Local<StackTrace> GetStackTrace(Local<Value> exception); };