Boost C++ 库

包含 basic_regex<> 类模板及其相关辅助函数的定义。

namespace boost {
  namespace xpressive {
    template<typename BidiIter> 
      void swap(basic_regex< BidiIter > &, basic_regex< BidiIter > &);
  }
}

包含 match_results 类型及其相关辅助函数的定义。match_results 类型保存 regex_match() 或 regex_search() 操作的结果。

定义了 xpressive 的 action 表达式的语法元素。

namespace boost {
  namespace xpressive {
    template<typename PolymorphicFunctionObject> struct function;

    function< op::at >::type const at;    // at is a lazy PolymorphicFunctionObject for indexing into a sequence in an xpressive semantic action. 
    function< op::push >::type const push;    // push is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action. 
    function< op::push_back >::type const push_back;    // push_back is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action. 
    function< op::push_front >::type const push_front;    // push_front is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action. 
    function< op::pop >::type const pop;    // pop is a lazy PolymorphicFunctionObject for popping the top element from a sequence in an xpressive semantic action. 
    function< op::pop_back >::type const pop_back;    // pop_back is a lazy PolymorphicFunctionObject for popping the back element from a sequence in an xpressive semantic action. 
    function< op::pop_front >::type const pop_front;    // pop_front is a lazy PolymorphicFunctionObject for popping the front element from a sequence in an xpressive semantic action. 
    function< op::top >::type const top;    // top is a lazy PolymorphicFunctionObject for accessing the top element from a stack in an xpressive semantic action. 
    function< op::back >::type const back;    // back is a lazy PolymorphicFunctionObject for fetching the back element of a sequence in an xpressive semantic action. 
    function< op::front >::type const front;    // front is a lazy PolymorphicFunctionObject for fetching the front element of a sequence in an xpressive semantic action. 
    function< op::first >::type const first;    // first is a lazy PolymorphicFunctionObject for accessing the first element of a std::pair<> in an xpressive semantic action. 
    function< op::second >::type const second;    // second is a lazy PolymorphicFunctionObject for accessing the second element of a std::pair<> in an xpressive semantic action. 
    function< op::matched >::type const matched;    // matched is a lazy PolymorphicFunctionObject for accessing the matched member of a xpressive::sub_match<> in an xpressive semantic action. 
    function< op::length >::type const length;    // length is a lazy PolymorphicFunctionObject for computing the length of a xpressive::sub_match<> in an xpressive semantic action. 
    function< op::str >::type const str;    // str is a lazy PolymorphicFunctionObject for converting a xpressive::sub_match<> to a std::basic_string<> in an xpressive semantic action. 
    function< op::insert >::type const insert;    // insert is a lazy PolymorphicFunctionObject for inserting a value or a range of values into a sequence in an xpressive semantic action. 
    function< op::make_pair >::type const make_pair;    // make_pair is a lazy PolymorphicFunctionObject for making a std::pair<> in an xpressive semantic action. 
    function< op::unwrap_reference >::type const unwrap_reference;    // unwrap_reference is a lazy PolymorphicFunctionObject for unwrapping a boost::reference_wrapper<> in an xpressive semantic action. 
    template<typename T, typename A> unspecified as(A const &);
    template<typename T, typename A> unspecified static_cast_(A const &);
    template<typename T, typename A> unspecified dynamic_cast_(A const &);
    template<typename T, typename A> unspecified const_cast_(A const &);
    template<typename T> value< T > const val(T const &);
    template<typename T> reference< T > const ref(T &);
    template<typename T> reference< T const > const cref(T const &);
    template<typename T> unspecified check(T const &);
    template<typename... ArgBindings> unspecified let(ArgBindings const &...);
    template<typename T, typename ... Args> 
      unspecified construct(Args const &...);
    namespace op {
      struct at;
      struct back;
      struct first;
      struct front;
      struct insert;
      struct length;
      struct make_pair;
      struct matched;
      struct pop;
      struct pop_back;
      struct pop_front;
      struct push;
      struct push_back;
      struct push_front;
      struct second;
      struct str;
      struct top;
      struct unwrap_reference;
    }
  }
}

包含 regex_match()、regex_search() 和 regex_replace() 算法。

namespace boost {
  namespace xpressive {
    template<typename BidiIter> 
      bool regex_match(BidiIter, BidiIter, match_results< BidiIter > &, 
                       basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiIter> 
      bool regex_match(BidiIter, BidiIter, basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default);
    template<typename Char> 
      bool regex_match(Char *, match_results< Char * > &, 
                       basic_regex< Char * > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiRange, typename BidiIter> 
      bool regex_match(BidiRange &, match_results< BidiIter > &, 
                       basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default, 
                       unspecified = 0);
    template<typename BidiRange, typename BidiIter> 
      bool regex_match(BidiRange const &, match_results< BidiIter > &, 
                       basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default, 
                       unspecified = 0);
    template<typename Char> 
      bool regex_match(Char *, basic_regex< Char * > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiRange, typename BidiIter> 
      bool regex_match(BidiRange &, basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default, 
                       unspecified = 0);
    template<typename BidiRange, typename BidiIter> 
      bool regex_match(BidiRange const &, basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default, 
                       unspecified = 0);
    template<typename BidiIter> 
      bool regex_search(BidiIter, BidiIter, match_results< BidiIter > &, 
                        basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiIter> 
      bool regex_search(BidiIter, BidiIter, basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default);
    template<typename Char> 
      bool regex_search(Char *, match_results< Char * > &, 
                        basic_regex< Char * > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiRange, typename BidiIter> 
      bool regex_search(BidiRange &, match_results< BidiIter > &, 
                        basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default, 
                        unspecified = 0);
    template<typename BidiRange, typename BidiIter> 
      bool regex_search(BidiRange const &, match_results< BidiIter > &, 
                        basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default, 
                        unspecified = 0);
    template<typename Char> 
      bool regex_search(Char *, basic_regex< Char * > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiRange, typename BidiIter> 
      bool regex_search(BidiRange &, basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default, 
                        unspecified = 0);
    template<typename BidiRange, typename BidiIter> 
      bool regex_search(BidiRange const &, basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default, 
                        unspecified = 0);
    template<typename OutIter, typename BidiIter, typename Formatter> 
      OutIter regex_replace(OutIter, BidiIter, BidiIter, 
                            basic_regex< BidiIter > const &, 
                            Formatter const &, 
                            regex_constants::match_flag_type = regex_constants::match_default, 
                            unspecified = 0);
    template<typename OutIter, typename BidiIter> 
      OutIter regex_replace(OutIter, BidiIter, BidiIter, 
                            basic_regex< BidiIter > const &, 
                            typename iterator_value< BidiIter >::type const *, 
                            regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiContainer, typename BidiIter, typename Formatter> 
      BidiContainer 
      regex_replace(BidiContainer &, basic_regex< BidiIter > const &, 
                    Formatter const &, 
                    regex_constants::match_flag_type = regex_constants::match_default, 
                    unspecified = 0);
    template<typename BidiContainer, typename BidiIter, typename Formatter> 
      BidiContainer 
      regex_replace(BidiContainer const &, basic_regex< BidiIter > const &, 
                    Formatter const &, 
                    regex_constants::match_flag_type = regex_constants::match_default, 
                    unspecified = 0);
    template<typename Char, typename Formatter> 
      std::basic_string< typename remove_const< Char >::type > 
      regex_replace(Char *, basic_regex< Char * > const &, Formatter const &, 
                    regex_constants::match_flag_type = regex_constants::match_default, 
                    unspecified = 0);
    template<typename BidiContainer, typename BidiIter> 
      BidiContainer 
      regex_replace(BidiContainer &, basic_regex< BidiIter > const &, 
                    typename iterator_value< BidiIter >::type const *, 
                    regex_constants::match_flag_type = regex_constants::match_default, 
                    unspecified = 0);
    template<typename BidiContainer, typename BidiIter> 
      BidiContainer 
      regex_replace(BidiContainer const &, basic_regex< BidiIter > const &, 
                    typename iterator_value< BidiIter >::type const *, 
                    regex_constants::match_flag_type = regex_constants::match_default, 
                    unspecified = 0);
    template<typename Char> 
      std::basic_string< typename remove_const< Char >::type > 
      regex_replace(Char *, basic_regex< Char * > const &, 
                    typename add_const< Char >::type *, 
                    regex_constants::match_flag_type = regex_constants::match_default);
  }
}

包含 regex_compiler 的定义，这是一个用于从字符串构建 regex 对象的工厂。

包含 syntax_option_type、match_flag_type 和 error_type 枚举的定义。

namespace boost {
  namespace xpressive {
    namespace regex_constants {
      enum syntax_option_type;
      enum match_flag_type;
      enum error_type;
    }
  }
}

包含 regex_error 异常类的定义。

BOOST_XPR_ENSURE_(pred, code, msg)

namespace boost {
  namespace xpressive {
    struct regex_error;
  }
}

包含 regex_iterator 类型的定义，这是一个 STL 兼容的迭代器，用于遍历序列中的所有匹配项。

包含用于编写静态正则表达式的语法元素。

namespace boost {
  namespace xpressive {
    struct mark_tag;

    unsigned int const inf;    // For infinite repetition of a sub-expression. 
    unspecified nil;    // Successfully matches nothing. 
    unspecified alnum;    // Matches an alpha-numeric character. 
    unspecified alpha;    // Matches an alphabetic character. 
    unspecified blank;    // Matches a blank (horizonal white-space) character. 
    unspecified cntrl;    // Matches a control character. 
    unspecified digit;    // Matches a digit character. 
    unspecified graph;    // Matches a graph character. 
    unspecified lower;    // Matches a lower-case character. 
    unspecified print;    // Matches a printable character. 
    unspecified punct;    // Matches a punctuation character. 
    unspecified space;    // Matches a space character. 
    unspecified upper;    // Matches an upper-case character. 
    unspecified xdigit;    // Matches a hexadecimal digit character. 
    unspecified bos;    // Beginning of sequence assertion. 
    unspecified eos;    // End of sequence assertion. 
    unspecified bol;    // Beginning of line assertion. 
    unspecified eol;    // End of line assertion. 
    unspecified bow;    // Beginning of word assertion. 
    unspecified eow;    // End of word assertion. 
    unspecified _b;    // Word boundary assertion. 
    unspecified _w;    // Matches a word character. 
    unspecified _d;    // Matches a digit character. 
    unspecified _s;    // Matches a space character. 
    proto::terminal< char >::type const _n;    // Matches a literal newline character, '\n'. 
    unspecified _ln;    // Matches a logical newline sequence. 
    unspecified _;    // Matches any one character. 
    unspecified self;    // Reference to the current regex object. 
    unspecified set;    // Used to create character sets. 
    mark_tag const s0;    // Sub-match placeholder, like $& in Perl. 
    mark_tag const s1;    // Sub-match placeholder, like $1 in perl. 
    mark_tag const s2;
    mark_tag const s3;
    mark_tag const s4;
    mark_tag const s5;
    mark_tag const s6;
    mark_tag const s7;
    mark_tag const s8;
    mark_tag const s9;
    unspecified a1;
    unspecified a2;
    unspecified a3;
    unspecified a4;
    unspecified a5;
    unspecified a6;
    unspecified a7;
    unspecified a8;
    unspecified a9;
    template<typename Expr> unspecified icase(Expr const &);
    template<typename Literal> unspecified as_xpr(Literal const &);
    template<typename BidiIter> 
      proto::terminal< reference_wrapper< basic_regex< BidiIter >const > >::type const 
      by_ref(basic_regex< BidiIter > const &);
    template<typename Char> unspecified range(Char, Char);
    template<typename Expr> 
      proto::result_of::make_expr< proto::tag::logical_not, proto::default_domain, Exprconst & >::type const 
      optional(Expr const &);
    template<unsigned int Min, unsigned int Max, typename Expr> 
      unspecified repeat(Expr const &);
    template<unsigned int Count, typename Expr2> 
      unspecified repeat(Expr2 const &);
    template<typename Expr> unspecified keep(Expr const &);
    template<typename Expr> unspecified before(Expr const &);
    template<typename Expr> unspecified after(Expr const &);
    template<typename Locale> unspecified imbue(Locale const &);
    template<typename Skip> unspecified skip(Skip const &);
  }
}

包含 regex_token_iterator 的定义，这是一个 STL 兼容的迭代器，用于使用正则表达式对字符串进行分词。

根据 BOOST_XPRESSIVE_USE_C_TRAITS 宏，包含 C locale traits 或 CPP locale traits 头文件。

namespace boost {
  namespace xpressive {
    struct regex_traits_version_1_tag;
    struct regex_traits_version_2_tag;
  }
}

包含 sub_match<> 类模板及其相关辅助函数的定义。

namespace boost {
  namespace xpressive {
    template<typename BidiIter> BidiIter range_begin(sub_match< BidiIter > &);
    template<typename BidiIter> 
      BidiIter range_begin(sub_match< BidiIter > const &);
    template<typename BidiIter> BidiIter range_end(sub_match< BidiIter > &);
    template<typename BidiIter> 
      BidiIter range_end(sub_match< BidiIter > const &);
    template<typename BidiIter, typename Char, typename Traits> 
      std::basic_ostream< Char, Traits > & 
      operator<<(std::basic_ostream< Char, Traits > &, 
                 sub_match< BidiIter > const &);
    template<typename BidiIter> 
      bool operator==(sub_match< BidiIter > const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator!=(sub_match< BidiIter > const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator<(sub_match< BidiIter > const & lhs, 
                     sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator<=(sub_match< BidiIter > const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator>=(sub_match< BidiIter > const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator>(sub_match< BidiIter > const & lhs, 
                     sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator==(typename iterator_value< BidiIter >::type const * lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator!=(typename iterator_value< BidiIter >::type const * lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator<(typename iterator_value< BidiIter >::type const * lhs, 
                     sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator>(typename iterator_value< BidiIter >::type const * lhs, 
                     sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator>=(typename iterator_value< BidiIter >::type const * lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator<=(typename iterator_value< BidiIter >::type const * lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator==(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const * rhs);
    template<typename BidiIter> 
      bool operator!=(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const * rhs);
    template<typename BidiIter> 
      bool operator<(sub_match< BidiIter > const & lhs, 
                     typename iterator_value< BidiIter >::type const * rhs);
    template<typename BidiIter> 
      bool operator>(sub_match< BidiIter > const & lhs, 
                     typename iterator_value< BidiIter >::type const * rhs);
    template<typename BidiIter> 
      bool operator>=(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const * rhs);
    template<typename BidiIter> 
      bool operator<=(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const * rhs);
    template<typename BidiIter> 
      bool operator==(typename iterator_value< BidiIter >::type const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator!=(typename iterator_value< BidiIter >::type const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator<(typename iterator_value< BidiIter >::type const & lhs, 
                     sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator>(typename iterator_value< BidiIter >::type const & lhs, 
                     sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator>=(typename iterator_value< BidiIter >::type const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator<=(typename iterator_value< BidiIter >::type const & lhs, 
                      sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      bool operator==(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const & rhs);
    template<typename BidiIter> 
      bool operator!=(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const & rhs);
    template<typename BidiIter> 
      bool operator<(sub_match< BidiIter > const & lhs, 
                     typename iterator_value< BidiIter >::type const & rhs);
    template<typename BidiIter> 
      bool operator>(sub_match< BidiIter > const & lhs, 
                     typename iterator_value< BidiIter >::type const & rhs);
    template<typename BidiIter> 
      bool operator>=(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const & rhs);
    template<typename BidiIter> 
      bool operator<=(sub_match< BidiIter > const & lhs, 
                      typename iterator_value< BidiIter >::type const & rhs);
    template<typename BidiIter> 
      sub_match< BidiIter >::string_type 
      operator+(sub_match< BidiIter > const & lhs, 
                sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      sub_match< BidiIter >::string_type 
      operator+(sub_match< BidiIter > const & lhs, 
                typename iterator_value< BidiIter >::type const & rhs);
    template<typename BidiIter> 
      sub_match< BidiIter >::string_type 
      operator+(typename iterator_value< BidiIter >::type const & lhs, 
                sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      sub_match< BidiIter >::string_type 
      operator+(sub_match< BidiIter > const & lhs, 
                typename iterator_value< BidiIter >::type const * rhs);
    template<typename BidiIter> 
      sub_match< BidiIter >::string_type 
      operator+(typename iterator_value< BidiIter >::type const * lhs, 
                sub_match< BidiIter > const & rhs);
    template<typename BidiIter> 
      sub_match< BidiIter >::string_type 
      operator+(sub_match< BidiIter > const & lhs, 
                typename sub_match< BidiIter >::string_type const & rhs);
    template<typename BidiIter> 
      sub_match< BidiIter >::string_type 
      operator+(typename sub_match< BidiIter >::string_type const & lhs, 
                sub_match< BidiIter > const & rhs);
  }
}

包含 c_regex_traits<> 模板的定义，这是一个 C locale 函数的包装器，可用于自定义静态和动态 regex 的行为。

包含 cpp_regex_traits<> 模板的定义，这是一个 std::locale 的包装器，可用于自定义静态和动态 regex 的行为。

包含 null_regex_traits<> 模板的定义，这是一个存根 regex traits 实现，可供静态和动态 regex 用于搜索非字符数据。

包含 xpressive 的所有内容，包括对静态和动态正则表达式的支持。

包含编写和使用动态正则表达式所需的所有内容。

xpressive 所有公共数据类型的前向声明。

BOOST_XPRESSIVE_HAS_MS_STACK_GUARD

namespace boost {
  namespace xpressive {
    template<typename BidiIter> struct basic_regex;
    template<typename Char> struct c_regex_traits;
    template<typename RegexTraits> struct compiler_traits;
    template<typename Char> struct cpp_regex_traits;
    template<typename Traits> struct has_fold_case;
    template<typename T> struct local;
    template<typename BidiIter> struct match_results;
    template<typename Elem> struct null_regex_traits;
    template<typename T, int I = 0> struct placeholder;
    template<typename T> struct reference;
    template<typename BidiIter, typename RegexTraits, typename CompilerTraits> 
      struct regex_compiler;
    template<typename BidiIter> struct regex_id_filter_predicate;
    template<typename BidiIter> struct regex_iterator;
    template<typename BidiIter> struct regex_token_iterator;
    template<typename Char, typename Impl> struct regex_traits;
    template<typename BidiIter> struct sub_match;
    template<typename T> struct value;

    typedef void const * regex_id_type;
    typedef basic_regex< std::string::const_iterator > sregex;
    typedef basic_regex< char const * > cregex;
    typedef basic_regex< std::wstring::const_iterator > wsregex;
    typedef basic_regex< wchar_t const * > wcregex;
    typedef sub_match< std::string::const_iterator > ssub_match;
    typedef sub_match< char const * > csub_match;
    typedef sub_match< std::wstring::const_iterator > wssub_match;
    typedef sub_match< wchar_t const * > wcsub_match;
    typedef regex_compiler< std::string::const_iterator > sregex_compiler;
    typedef regex_compiler< char const * > cregex_compiler;
    typedef regex_compiler< std::wstring::const_iterator > wsregex_compiler;
    typedef regex_compiler< wchar_t const * > wcregex_compiler;
    typedef regex_iterator< std::string::const_iterator > sregex_iterator;
    typedef regex_iterator< char const * > cregex_iterator;
    typedef regex_iterator< std::wstring::const_iterator > wsregex_iterator;
    typedef regex_iterator< wchar_t const * > wcregex_iterator;
    typedef regex_token_iterator< std::string::const_iterator > sregex_token_iterator;
    typedef regex_token_iterator< char const * > cregex_token_iterator;
    typedef regex_token_iterator< std::wstring::const_iterator > wsregex_token_iterator;
    typedef regex_token_iterator< wchar_t const * > wcregex_token_iterator;
    typedef match_results< std::string::const_iterator > smatch;
    typedef match_results< char const * > cmatch;
    typedef match_results< std::wstring::const_iterator > wsmatch;
    typedef match_results< wchar_t const * > wcmatch;
    typedef regex_id_filter_predicate< std::string::const_iterator > sregex_id_filter_predicate;
    typedef regex_id_filter_predicate< char const * > cregex_id_filter_predicate;
    typedef regex_id_filter_predicate< std::wstring::const_iterator > wsregex_id_filter_predicate;
    typedef regex_id_filter_predicate< wchar_t const * > wcregex_id_filter_predicate;
    namespace op {
      template<typename T> struct as;
      template<typename T> struct const_cast_;
      template<typename T> struct construct;
      template<typename T> struct dynamic_cast_;
      template<typename T> struct static_cast_;
      template<typename Except> struct throw_;
    }
  }
}

包含编写静态正则表达式并使用它们所需的所有内容。

类型注册，以便 xpressive 可以与 Boost.Typeof 库一起使用。