参考 http://www.cnblogs.com/kenkofox/p/3910462.HTML
参考 http://www.tairan.com/archives/4902
参考 http://cn.cocos2d-x.org/tutorial/show?ID=1317
-----------------------------------------------------------------------------------------------------
iOS/Mac中使用Js调用Objective-C函数pandamicro2014-08-12 19:33:131290 次阅读
在Cocos2d-Js v3.0 RC2中，我们将介绍Js到Objective-C的反射特性。这就像在Java中我们可以使用Js调用Java本地函数一样，你也可以使用Js调用Objective-C的静态方法。
| 1 | varojb=Jsb.reflection.callStaticmethod(classname,methodNmae,arg1,arg2,.....); |
可以通过传递classname methodname 和 parmeters来使用Jsb.reflection.callStaticmethod调用本地的OC方法。
Objective-C中的类
你需要像下面的例子一样，在OC的类中提供你的方法。下例中参数classname应该是NativeOcclass。
| 1 2 3 4 | import<Foundation/Foundation.h> @interfaceNativeOcclass:NSObject +( BOol )callNativeUIWithTitle:(Nsstring*)TitleandContent:(Nsstring*)content; @end |
Objective-C中的方法
Js到OC的反射只支持OC类中的静态方法。
在之前的例子中，methodname 参数是类的OC方法名，如我们将一个方法命名为NativeOcclass。
| 1 | +( BOol )callNativeUIWithTitle:(Nsstring*)TitleandContent:(Nsstring*)content; |
因此，这个methodname应该由callNativeUIWithTitle:addContent: 来定义（注意不要忘记"："）。更多详情请查看Objective-C编程指南。
在下面的例子中，methodname应该为callNativeWithReturnString。
| 1 | +(Nsstring*)callNativeWithReturnString; |
用法
在Js代码中，可使用如下的Jsb.reflection.callStaticmethod API来调用NativeOcclass的本地方法callNativeUIWithTitle:andContent:：
| 1 | varret=Jsb.reflection.callStaticmethod( "NativeOcclass" , "callNativeUIWithTitle:andContent:" , "cocos2d-Js" , "Yes!youcallaNativeUIfromreflection" ); |
此方法将会显示一个警告框，并返回一个布尔类状态。下面是它的实现方法，Title和content参数将会接收从Js中传来的字符串。
| 1 2 3 4 | varret=Jsb.reflection.callStaticmethod("NativeOcclass", "callNativeUIWithTitle:andContent:", "cocos2d-Js", "Yes!youcallaNativeUIfromreflection" ); |
注意事项
在Cocos2d-Js反射中，支持的参数类型以及返回值是受限制的。
如果需要在本地方法中使用float、int、和double类型的参数，那么你需要使用NSNumber替代。
如果需要使用bool类型的参数，那么用BOol替代。
下面有个例子，使用NSNumber代替int,float以及double。
| 1 | +( float )addTwoNumber:(NSNumber*)num1and:(NSNumber*)num2{ float result=[num1floatValue]+[num2floatValue]; return result;} |
当前版本仅支持int,float,bool和string的返回值类型。
如何实现c++中调用Js呢，参照一下文章，
测试了下，如果是单独从c++调用Js的话
<strong>Jsval ret; Scriptingcore::getInstance()->evalString("cpp_callback(2,3)",&ret); </strong> 第一个参数是声明函数，全局函数。 也可以是类静态函数: MyClass.method(1,2).
# import "cocosbuilder/Js_bindings_ccbreader.h"
上面的Js调cpp应该是封装过了，如果自己实现的话要参照下面,注册函数等。这样才可以在Js中直接调用
1 Js调用C++
3.0中写这个绑定比较简单，跟ANE调用java如出一辙，一个jscontext，一个Jsval，使用cocos2d提供的c++和Js变量转换的函数做好转换即可。
cocos2d-Js原来就定义好了代码风格：
@H_869_403@sc->addRegisterCallback(MinXmlhttpRequest::_Js_register); sc->addRegisterCallback(register_Jsb_websocket); sc->addRegisterCallback(register_Jsb_socketio); #if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID) sc->addRegisterCallback(JavaScriptJavaBrIDge::_Js_register); #endif sc->addRegisterCallback(register_Jsb_kenko_all); sc->start();@H_869_403@
我们也顺着这个风格，添加一个函数：register_Jsb_kenko_all，这是一个全局函数。
@H_869_403@Jsb_kenko_auto.h#ifndef Jsb_Jsb_kenko_auto_h #define Jsb_Jsb_kenko_auto_h#include "cocos2d.h"std::string os_info(); bool Jsb_os_info(jscontext *cx,uint32_t argc,Js::Value *vp); bool Jsb_callback(jscontext *cx,Js::Value *vp); voID register_Jsb_kenko_all(jscontext* cx,JsObject* obj);#endif@H_869_403@ @H_869_403@Jsb_kenko_auto.cpp#include "Jsb_kenko_auto.h" #include "cocos2d_specifics.hpp"std::string os_info() { cclOG("it's c++ os_info here"); return "os_info"; } bool Jsb_os_info(jscontext *cx,Js::Value *vp) { Jsval ret = std_string_to_Jsval(cx,os_info()); Js_SET_RVAL(cx,vp,ret); return true; } voID register_Jsb_kenko_all(jscontext *cx,JsObject *obj) { Js_defineFunction(cx,obj,"osInfo",Jsb_os_info,0,0); //生成名为osInfo的Js全局函数}@H_869_403@
把h和cpp文件都放到AppDelegate.cpp同一个地方。上述的c++代码会在spIDermonkey运行环境中生成相应的Js接口，所以，我们不需要自己额外写对应的Js接口。
然后就可以写Js代码试试了。从运行结果可以看到，Js调用成功，并获取到返回值。
@H_869_403@cc.game.onStart = function(){ cc.vIEw.setDesignResolutionSize(800,450,cc.ResolutionPolicy.SHOW_ALL); cc.vIEw.resizeWithbrowserSize(true); cc.director.runScene(new MainScene()); cc.log("Js get from c++: " + osInfo()); }; cc.game.run();@H_869_403@
2 C++回调
关键在于使用Scriptingcore提供的方法，调用Js。首先来看看Scriptingcore的源代码，都有些什么方法可以用。
executeFunctionWithOwner可以实现类似cc.sprite之类的c++对象和Js对象的调用，没有深究。这里演示的是如何做全局调用。
evalString对任何一个前端开发来说都不会太陌生，毕竟这里不是浏览器，排除各种乱七八糟的安全问题，我们直接用这个函数。
@H_869_403@
/** @brIEf Execute a scripted global function. @brIEf The function should not take any parameters and should return an integer. @param functionname String object holding the name of the function,in the global script environment,that is to be executed. @return The integer value returned from the script function. */ virtual int executeGlobalFunction(const char* functionname) { return 0; } virtual int sendEvent(cocos2d::ScriptEvent* message) overrIDe; virtual bool parseConfig(ConfigType type,const std::string& str) overrIDe; virtual bool handleAssert(const char *msg) { return false; } virtual voID setCalledFromScript(bool callFromScript) { _callFromScript = callFromScript; }; virtual bool isCalledFromScript() { return _callFromScript; }; bool executeFunctionWithObjectData(voID* nativeObj,const char *name,JsObject *obj); bool executeFunctionWithOwner(Jsval owner,uint32_t argc = 0,Jsval* vp = NulL,Jsval* retVal = NulL); voID executeJsFunctionWithThisObj(Jsval thisObj,Jsval callback,Jsval* retVal = NulL); /** * will eval the specifIEd string * @param string The string with the JavaScript code to be evaluated * @param outVal The Jsval that will hold the return value of the evaluation. * Can be NulL. */ bool evalString(const char *string,Jsval *outVal,const char *filename = NulL,jscontext* cx = NulL,JsObject* global = NulL);@H_869_403@
修改Jsb_kenko_auto.cpp：
@H_869_403@#include "Jsb_kenko_auto.h" #include "cocos2d_specifics.hpp"std::string os_info() { cclOG("it's c++ os_info here"); return "os_info"; }bool Jsb_callback(jscontext *cx,Js::Value *vp) { cclOG("it's c++ testCallback here"); jscontext* jc = Scriptingcore::getInstance()->getGlobalContext(); // 注释部分适合有对象化的调用 // 参考：http://www.tairan.com/archives/4902 //Jsval v[2]; //v[0] = int32_to_Jsval(jc,32); //v[1] = int32_to_Jsval(jc,12); // 通过 Scriptingcore 封装好的方法实现回调，可以帮助我们节省很多细节上的研究 //Js_proxy_t * p = Jsb_get_native_proxy(); //return Scriptingcore::getInstance()->executeFunctionWithOwner(OBJECT_TO_JsVAL(p->obj),"cpp_callback",2,v); //2是参数个数，v是参数列表 //找到一个更适合全局函数的方法 Jsval ret; return Scriptingcore::getInstance()->evalString("cpp_callback(2,3)",&ret); } bool Jsb_os_info(jscontext *cx,0); Js_defineFunction(cx,"test_cpp_callback",Jsb_callback,0); }@H_869_403@相应在Js侧添加一个全局函数，给c++调用。
@H_869_403@cc.game.onStart = function(){ cc.vIEw.setDesignResolutionSize(800,cc.ResolutionPolicy.SHOW_ALL); cc.vIEw.resizeWithbrowserSize(true); cc.director.runScene(new MainScene()); cc.log("Js get from c++: " + osInfo()); test_cpp_callback(); }; cc.game.run();function cpp_callback(a,b) { cc.log("cpp return two integer: " + a + " " + b); }@H_869_403@
看输出结果：
3 各种变量转换函数
----------------------------http://www.tairan.com/archives/4902------------------------------------------------------------------------------------------------------------------------------------ Cocos2d-x Js Binding 的手动绑定实现 A- A+ 一叶 2013 年 8 月 13 日 13条评论 238 次浏览 Cocos2d-x cocos2d-x 文章目录 JSB 手动绑定的实现步骤 怎样实现 C++ 回调 JS JSB 的内存管理都在Js_manual_conversions.h这里了，真是应有尽有。下边只列出一部分。
@H_869_403@bool Jsval_to_ushort( jscontext *cx,Jsval vp,unsigned short *ret ); bool Jsval_to_int32( jscontext *cx,int32_t *ret ); bool Jsval_to_uint32( jscontext *cx,uint32_t *ret ); bool Jsval_to_uint16( jscontext *cx,uint16_t *ret ); bool Jsval_to_long( jscontext *cx,long *out); bool Jsval_to_ulong( jscontext *cx,unsigned long *out); bool Jsval_to_long_long(jscontext *cx,Jsval v,long long* ret); bool Jsval_to_std_string(jscontext *cx,std::string* ret);Jsval int32_to_Jsval( jscontext *cx,int32_t l); Jsval uint32_to_Jsval( jscontext *cx,uint32_t number ); Jsval ushort_to_Jsval( jscontext *cx,unsigned short number ); Jsval long_to_Jsval( jscontext *cx,long number ); Jsval ulong_to_Jsval(jscontext* cx,unsigned long v); Jsval long_long_to_Jsval(jscontext* cx,long long v); Jsval std_string_to_Jsval(jscontext* cx,const std::string& v);@H_869_403@
随着 Cocos2d-x 的发展，Cocos2d-HTML5 也日益完善，相比纯 C++ 的开发方式，它开发效率更为高效，而另一个显而易见的好处便是 Js 端的 API 可以作为 Cocos2d-x JavaScript Bindings (JsB) 的接口封装。一套 API，两种解决方案，这让用 Js 快速开发游戏，通过 JsB 以接近原生代码的速度来运行游戏成为可能。
这里使用当前稳定版 Cocos2d-x-2.1.4，Xcode JsB 项目模板创建项目，如果是用其它 IDE ，注意配置好不同环境的依赖关系，本文的示例源码可以在【这里】看到。
JsB 手动绑定的实现步骤要实现 C++ 到 Js 的手动绑定，首先我们需要定义一个待绑定的类，为了这里的解说简单，创建了一个非常简单的类，也只定义了些简单的方法，如下：
// Leafsoar.h 文件定义namespace ls { class Leafsoar: public cocos2d::CCObject { public: static cocos2d::CCScene* scene(); virtual bool init(); CREATE_FUNC(Leafsoar); voID functionTest(); };}// Leafsoar.cpp 实现bool ls::Leafsoar::init(){ bool bRef = false; do { cocos2d::cclog("leafsoar init ..."); bRef = true; } while (0); return bRef;}voID ls::Leafsoar::functionTest(){ cocos2d::cclog("function Test");}
以上是我们定义的一个类，在ls命名空间里面，它很简单，继承自 CCObject，定义实现了functionTest方法，我们下面要做的就是将它绑定到 Js ，最终达到通过 Js 来创建对象，并且调用方法。如果不知道从何下手，那么下面是一种实现思路。
为了使代码风格统一 （这样的好处是任何人都能相对容易的读懂代码并修改之），我们将参照 Cocos2d-x 现有的 JsB 实现，如从AppDelegate的applicationDIDFinishLaunching方法开始，里面实现了 JsB 环境的初始化等 *** 作，其中我们看到类似sc->addRegisterCallback(register_all_cocos2dx);这样的代码，而我们将创建register_all_ls方法，来完成我们自有ls命名空间下需要绑定的代码。
编写Jsb_ls_auto.h文件，定义如下：
#include "JsAPI.h"#include "JsfrIEndAPI.h"#include "Scriptingcore.h"voID register_all_ls(jscontext* cx, JsObject* obj);
完成了以上register_all_ls方法定义，它作为自定义 JsB 手动绑定函数的入口，内中实现绑定我么的命名空间，我们的类和方法等 ~ 所以Js_ls_auto.cpp的实现需要根据自己的需要实现，以下是当前的实现步骤，：
#include "Jsb_ls_auto.h"#include "cocos2d.h"#include "Leafsoar.h"#include "cocos2d_specifics.hpp"// 定义 Js 端的类型JsClass *Jsb_LsLeafsoar_class;JsObject *Jsb_LsLeafsoar_prototype;// 实现 ls 命名空间下的类绑定voID register_all_ls(jscontext* cx, JsObject* obj) { Jsval nsval; JsObject *ns; Js_GetProperty(cx, obj, "ls", &nsval); if (nsval == JsVAL_VOID) { ns = Js_NewObject(cx, NulL, NulL); nsval = OBJECT_TO_JsVAL(ns); Js_SetProperty(cx, &nsval); } else { Js_ValuetoObject(cx, nsval, &ns); } obj = ns; // 实现绑定 Leafsoar 类，它的定义后文给出 Js_register_ls_Leafsoar(cx, obj);}
为了实现思路的清晰，所以文章内容以register_all_ls为入口，一步步实现，需要什么，我们就去实现什么，看到上面绑定了命名空间（在 Js 中并没有明确的命名空间的机制，但 Js 能实现类似命名空间的效果），并调用了Js_register_ls_Leafsoar(cx,obj);方法来实现具体的绑定，下面是它的实现：
// 绑定 Leafsoar 类的实现voID Js_register_ls_Leafsoar(jscontext *cx, JsObject *global) { // 创建一个 Js 类型的对象 Jsb_LsLeafsoar_class = (JsClass *)calloc(1, sizeof(JsClass)); // 类型名称为 **Leafsoar** 正式绑定到 Js 由 Js 调用的名称 Jsb_LsLeafsoar_class->name = "Leafsoar"; Jsb_LsLeafsoar_class->addProperty = Js_PropertyStub; Jsb_LsLeafsoar_class->delProperty = Js_PropertyStub; Jsb_LsLeafsoar_class->getProperty = Js_PropertyStub; Jsb_LsLeafsoar_class->setProperty = Js_StrictPropertyStub; Jsb_LsLeafsoar_class->enumerate = Js_EnumerateStub; Jsb_LsLeafsoar_class->resolve = Js_ResolveStub; Jsb_LsLeafsoar_class->convert = Js_ConvertStub; // Leafsoar 类型的析构函数绑定 Jsb_LsLeafsoar_class->finalize = Js_ls_Leafsoar_finalize; Jsb_LsLeafsoar_class->flags = JsCLASS_HAS_RESERVED_SLOTS(2); static JsPropertySpec propertIEs[] = { {0, 0, JsOP_NulLWRAPPER, JsOP_NulLWRAPPER} }; // 为 Leafsoar 设定绑定函数，函数名 "functionTest"，绑定函数 "Js_ls_Leafsoar_functionTest" // 后面可以添加其它函数绑定，如果需要，之后以 "Js_FS_END" 结尾 static JsFunctionspec funcs[] = { Js_FN("functionTest", Js_ls_Leafsoar_functionTest, 1, JsPROP_PERMANENT | JsPROP_ENUMERATE), Js_FS_END }; // 这里定义并且绑定了静态函数(static)，包括方法名 "create" 和对应的绑定实现 "Js_ls_Leafsoar_create" static JsFunctionspec st_funcs[] = { Js_FN("create", Js_ls_Leafsoar_create, Js_FS_END }; // 初始化类型属性 Jsb_LsLeafsoar_prototype = Js_InitClass( cx, global, NulL, // parent proto Jsb_LsLeafsoar_class, Js_ls_Leafsoar_constructor, // 这里绑定的是构造函数的实现，也就是用 Js new *** 作符创建的对象 propertIEs, funcs, // 函数绑定 NulL, // no static propertIEs st_funcs); // 静态函数绑定 JsBool found; Js_SetPropertyAttributes(cx, "Leafsoar", JsPROP_ENUMERATE | JsPROP_Readonly, &found); TypeTest<ls::Leafsoar> t; Js_type_class_t *p; uint32_t typeID = t.s_ID(); HASH_FIND_INT(_Js_global_type_ht, &typeID, p); if (!p) { p = (Js_type_class_t *)malloc(sizeof(Js_type_class_t)); p->type = typeID; p->Jsclass = Jsb_LsLeafsoar_class; p->proto = Jsb_LsLeafsoar_prototype; p->parentProto = NulL; HASH_ADD_INT(_Js_global_type_ht, type, p); }}
写到这里，类型的绑定已经基本完成，但是可以看见，其中所用到的如Js_ls_Leafsoar_functionTest、Js_ls_Leafsoar_finalize、Js_ls_Leafsoar_create和Js_ls_Leafsoar_constructor并没有实现，它们是在绑定 Leafosar 类型的时候去绑定了，所以需要在调用前去实现它们，下面是它们的实现：
// Js 端 functionTest 所绑定的方法调用JsBool Js_ls_Leafsoar_functionTest(jscontext *cx, uint32_t argc, Jsval *vp){ JsBool ok = Js_TRUE; JsObject *obj = NulL; ls::Leafsoar* cobj = NulL; // 定义以获取真实类型 obj = Js_THIS_OBJECT(cx, vp); Js_proxy_t *proxy = Jsb_get_Js_proxy(obj); // 获取 Js 绑定的实际对象 通过 proxy->ptr cobj = (ls::Leafsoar *)(proxy ? proxy->ptr : NulL); JsB_PRECONDITION2( cobj, cx, Js_FALSE, "InvalID Native Object"); if (argc == 0) { // 调用实际的方法 cobj->functionTest(); Js_SET_RVAL(cx, vp, JsVAL_VOID); return ok; } Js_ReportError(cx, "wrong number of arguments"); return Js_FALSE;}// Js 构造函数实现JsBool Js_ls_Leafsoar_constructor(jscontext *cx, Jsval *vp){ cocos2d::cclog("Js ls lsleafsoar constructor .."); if (argc == 0) { // 调用 C++ 构造函数 ls::Leafsoar* cobj = new ls::Leafsoar(); cocos2d::CCObject* _ccobj = dynamic_cast<cocos2d::CCObject*>(cobj); // 默认使用原有的内存管理方式 if (_ccobj){ _ccobj->autorelease(); } TypeTest<ls::Leafsoar> t; Js_type_class_t *typeClass; uint32_t typeID = t.s_ID(); HASH_FIND_INT(_Js_global_type_ht, typeClass); assert(typeClass); JsObject *obj = Js_NewObject(cx, typeClass->Jsclass, typeClass->proto, typeClass->parentProto); Js_SET_RVAL(cx, OBJECT_TO_JsVAL(obj)); // 构造 Js 端对象，将 cobj 实际对象存入 Js_proxy_t* p = Jsb_new_proxy(cobj, obj); Js_AddnamedobjectRoot(cx, &p->obj, "ls::Leafsoar"); return Js_TRUE; } Js_ReportError(cx, "wrong number of arguments: %d,was expecting %d", argc, 0); return Js_FALSE;}// 静态函数 create 的具体实现JsBool Js_ls_Leafsoar_create(jscontext *cx, Jsval *vp){ cocos2d::cclog("Js ls lsleafsoar create .."); if (argc == 0) { // 创建 Leafsoar 对象 ls::Leafsoar* ret = ls::Leafsoar::create(); Jsval Jsret; do { if (ret) { Js_proxy_t *proxy = Js_get_or_create_proxy<ls::Leafsoar>(cx, ret); Jsret = OBJECT_TO_JsVAL(proxy->obj); } else { Jsret = JsVAL_NulL; } } while (0); Js_SET_RVAL(cx, Jsret); return Js_TRUE; } Js_ReportError(cx, "wrong number of arguments"); return Js_FALSE;}voID Js_ls_Leafsoar_finalize(JsFreeOp *fop, JsObject *obj) { // 析构函数实现，如果在构造函数做了什么，如开辟内存空间，那么需要在这里做些收尾工作 // cclOGINFO("Jsbindings: finalizing Js object %p (LsLeafsoar)",obj);}
通过以上的步骤，我们实现了 C++ 类 Leafosar 到 Js 端的绑定。在 Js 中我们可以通过以下调试测试：
// var ls = new ls.Leafsoar();// 或者var ls = ls.Leafsoar.create();// 之后调用ls.functionTest();怎样实现 C++ 回调 Js
在上文，完成了 C++ 到 Js 的手动绑定，但有时我们还需要其它一些功能，比如想在 C++ 开一个多线程以加载资源，或者一个网络异步请求，再如要实现一个 delegate 以实现接口回调，然这些都归为同一个问题，实现 C++ 到 Js 的回调。我们在 Js 端定义了一个 Leafsoar 对象，并且新实现了一个方法，等待 C++ 端的回调，如下：
var ls = new ls.Leafsoar(); // 创建一个对象// 定义回调函数 callbackls.callback = function(i, j){ log("ls.callback " + i + j);};ls.functionTest();
我们想通过调用functionTest之后回调在 Js 端定义的 callback 方法。那么我们需要重新实现 C++ 端的 functionTest 方法：
voID ls::Leafsoar::functionTest(){ cocos2d::cclog("function Test"); Js_proxy_t * p = Jsb_get_native_proxy(this); Jsval retval; jscontext* jc = Scriptingcore::getInstance()->getGlobalContext(); // 定义参数，由两个参数 Jsval v[] = { v[0] = int32_to_Jsval(jc, 32), v[1] =UINT_TO_JsVAL(88) }; // 通过 Scriptingcore 封装好的方法实现回调，可以帮助我们节省很多细节上的研究 Scriptingcore::getInstance()->executeFunctionWithOwner(OBJECT_TO_JsVAL(p->obj), "callback", 2, v, &retval);}JsB 的内存管理
了解 Cocos2d-x 的朋友知道，它的内存管理方式，如果对此有疑问，可以参见Cocos2d-x 内存管理浅说和深入理解 Cocos2d-x 内存管理这两篇文章，那么在 JsB 我们如何来管理内存呢？在 C++ 需要通过retain和release来实现引用计数的管理（源码示例也给出它的绑定实现，但仅仅作为参考），在绑定 Js 时，如果不做相应处理，那么可能会出现 Js 正在运行着的代码，所绑定的实际 C++ 对象已经释放。虽然我们能通过 绑定实现 retain 和 release 方法，来实现 Js 端的此方法调用，但这显然不符合 Js 代码边的习惯，它是自动回收的，所以这里推荐始终由 SpIDerMonkey 来保持一份对象引用，以使它更像 Js 的使用方式，当 Js 垃圾回收自动执行时，在去释放 SpIDerMonkey 对对象的引用。
要做到这一点，我们需要只要修改上文的代码实现，在 构造函数，create 静态方法，实现对 C++ 类型对象的引用，在 析构绑定的析构函数中解除对其的引用以完成 C++ 到 Js 端绑定的内存管理方案。
总结以上是内存溢出为你收集整理的cocos2d-js 3.0 RC0 手动绑定 C++调用js，js调用C++ jsbinding全部内容，希望文章能够帮你解决cocos2d-js 3.0 RC0 手动绑定 C++调用js，js调用C++ jsbinding所遇到的程序开发问题。
如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）