Selector()

Selector用于根据条件查找对象的选择器。

new Selector()
thing/src/selector/Selector.js, line 144

Members

active :boolean
thing/src/selector/Selector.js, line 1575

设置所有对象及其子对象的激活状态。
Example
// 将选择器中所有对象及其子对象的激活状态设置为true
selector.active = true;

length :number
thing/src/selector/Selector.js, line 1411

获取/设置对象的数量。
Example
let length = selector.length;

pickable :boolean
thing/src/selector/Selector.js, line 1561

设置所有对象及其子对象的可选状态。
Example
// 将选择器中所有对象及其子对象的可选属性设置为true
selector.pickable = true;

visible :boolean
thing/src/selector/Selector.js, line 1547

设置所有对象及其子对象的可见状态。
Example
// 将选择器中所有对象及其子对象的可见属性设置为true
selector.visible = true;

Methods

add(selector) → {THING.Selector}
thing/src/selector/Selector.js, line 877

根据选择器添加对象，并返回包含结果的新选择器。
Parameters:
Name Type Description
selector THING.Selector | Array.<THING.BaseObject> | THING.BaseObject 要添加的选择器或对象。
Returns:
THING.Selector - 返回包含结果的选择器实例。
Example
let objects = app.query('.Entity');
let selector = new THING.Selector(objects);
let count1 = selector.length;
let object1 = new THING.BaseObject();
let object2 = new THING.BaseObject();
let newSelector = selector.add([object1,object2]);
let count2 = newSelector.length;
let ret = count2 - count1 == 2;
// @expect(ret == true)

clear()
thing/src/selector/Selector.js, line 957

清空对象。
Example
let objects = app.query('.Entity');
let selector = new THING.Selector(objects);
selector.clear();
let ret = count == 0;
// @expect(ret == true)

concat(selector) → {THING.Selector}
thing/src/selector/Selector.js, line 1342

合并数组。
Parameters:
Name Type Description
selector THING.Selector | Array.<THING.BaseObject> 对象数组或选择器。
Returns:
THING.Selector - 返回一个新的选择器实例，包含合并后的对象。
Example
// 将其他对象/选择器与当前选择器合并并创建新的选择器。
let newSelector = selector.concat([obj1, obj2]);

destroy()
thing/src/selector/Selector.js, line 1637

销毁所有对象。
Example
selector.destroy();

equals(objects) → {boolean}
thing/src/selector/Selector.js, line 1390

检查是否为相同的选择器。
Parameters:
Name Type Description
objects Array.<object> | THING.Selector 对象数组或选择器。
Returns:
boolean - 如果当前选择器与传入的对象数组或选择器相同，则返回true，否则返回false。
Example
let isSame = selector.equals([obj1, obj2]);

every(callback) → {boolean}
thing/src/selector/Selector.js, line 777

遍历所有对象并执行回调函数。
Parameters:
Name Type Description
callback function 回调函数。
Returns:
boolean - 如果所有对象都满足条件，则返回true，否则返回false。
Example
selector.every(object => {
    return object.isVisible; // 检查每个对象是否可见
});

filter(callback) → {THING.Selector}
thing/src/selector/Selector.js, line 1190

筛选对象。
Parameters:
Name Type Description
callback OnFilterObjectsInSelector 回调函数。
Returns:
THING.Selector - 返回一个新的选择器，包含通过回调函数筛选后的对象。
Example
// 根据名称筛选对象
let objects = selector.filter((object) => {
	return !!object.name;
});

find(condition, objects) → {THING.BaseObject}
thing/src/selector/Selector.js, line 686

根据条件查找对象并返回第一个对象。
Parameters:
Name Type Description
condition string 条件。
objects Array.<THING.BaseObject> 要查询的对象。
Returns:
THING.BaseObject - 返回第一个对象。
Example
let objects = app.query('.BaseObject');
let selector = new THING.Selector(objects);
let entity = selector.find('.Entity')
let ret = entity instanceof THING.Entity;;
// @expect(ret == true)

findIndex(condition, objects) → {number}
thing/src/selector/Selector.js, line 727

根据条件查找对象并返回第一个对象的索引。
Parameters:
Name Type Description
condition string | RegExp | function 条件。
objects Array.<THING.BaseObject> 要查询的对象。
Returns:
number - 返回找到的对象的索引，如果未找到则返回 -1。
Example
let objects = app.query('.BaseObject');
let selector = new THING.Selector(objects);
let index = selector.findIndex('.Entity');
// @expect(index >= 0);

flat(depth) → {THING.Selector}
thing/src/selector/Selector.js, line 792

使用flat将对象数组扁平化。
Parameters:
Name Type Default Description
depth number 1 深度，默认为1。
Returns:
THING.Selector - 扁平化后的新选择器。
Example
let flatSelector = selector.flat();
console.log(flatSelector);

flatMap(callback) → {THING.Selector}
thing/src/selector/Selector.js, line 806

使用flatMap遍历对象并返回一个新选择器。
Parameters:
Name Type Description
callback function 回调函数。
Returns:
THING.Selector - 新选择器，包含回调函数返回的结果。
Example
let results = selector.flatMap(object => {
    return object.children; // 返回每个对象的子对象
});

forEach(callback)
thing/src/selector/Selector.js, line 979

遍历对象。
Parameters:
Name Type Description
callback OnTraverseObjectsInSelector 回调函数（返回false表示中断遍历，否则继续处理）。
Example
// 遍历选择器中的所有对象
selector.forEach((object) => {
	console.log(object);
});

forEachAsync(callback)
thing/src/selector/Selector.js, line 1004

异步模式下遍历对象。
Parameters:
Name Type Description
callback OnTraverseObjectsInSelector 回调函数（返回false表示中断遍历，否则继续处理）。
Example
// 对象逐个飞行（会等待前一个对象飞行完成后再开始）
selector.forEachAsync(object => {
	return THING.App.current.camera.flyToAsync({
		target: object,
		duration: 1 * 1000,
		distance: 10,
		delayTime: THING.Math.randomFloat(0, 1000),
		complete: function (ev) {
		}
	});
});

getBoundingBox() → {BASE.THING.Box3}
thing/src/selector/Selector.js, line 1983

获取轴对齐的边界框（AABB）。
Returns:
BASE.THING.Box3 - 当前选择器内所有对象合并后的 AABB。
Example
let selector = new THING.Selector();
let box = selector.getBoundingBox();
let ret = box.size[0] == 0;
// @expect(ret == true);

getInstancedDrawingObjects() → {Array.<THING.BaseObject>}
thing/src/selector/Selector.js, line 1515

获取启用实例化绘制的对象。
Returns:
Array.<THING.BaseObject> - 启用实例化绘制的对象数组。
Example
// 获取启用实例化绘制的对象
let instancedDrawingObjects = selector.getInstancedDrawingObjects();

has(object) → {boolean}
thing/src/selector/Selector.js, line 1378

检查是否包含指定对象。
Parameters:
Name Type Description
object object 对象。
Returns:
boolean - 如果选择器包含指定对象，则返回true，否则返回false。
Example
// 检查选择器是否包含指定对象。
let exists = selector.has(object);

includes(object) → {boolean}
thing/src/selector/Selector.js, line 1255

检查是否包含指定元素。
Parameters:
Name Type Description
object object 对象。
Returns:
boolean - 如果选择器包含指定对象，则返回true，否则返回false。
Example
// 检查是否包含指定对象
let exists = selector.includes(object);

indexOf(object) → {number}
thing/src/selector/Selector.js, line 1268

获取对象在数组中的索引。
Parameters:
Name Type Description
object object 对象。
Returns:
number - 对象在选择器中的索引，如果对象不存在，则返回-1。
Example
// 获取对象在选择器中的索引
let index = selector.indexOf(object);

insert(index, object) → {THING.Selector}
thing/src/selector/Selector.js, line 1296

按索引插入对象。
Parameters:
Name Type Description
index number 要插入的索引。
object THING.BaseObject 要插入的对象。
Returns:
THING.Selector - 返回当前选择器实例，用于链式调用。
Example
// 在选择器的开头插入对象
selector.insert(0, [obj1, obj2]);

invoke(type, ev, options) → {Promise.<any>}
thing/src/selector/Selector.js, line 1879

触发所有对象的事件。
Parameters:
Name Type Description
type string 事件类型。
ev object 事件信息。
options object 选项。
Properties
Name Type Description
tag string 标签名称。
Returns:
Promise.<any> - 返回一个Promise对象，包含所有对象的事件触发结果。
Example
let entity = new THING.Entity();
let selector = new THING.Selector([entity]);
let mark = 0;
selector.on('testInvoke', function(ev) {
	mark = ev.value;
});
selector.invoke('testInvoke', { value: 5 });
// @expect(mark == 5);

loadResource(options)
thing/src/selector/Selector.js, line 1662

加载资源。
Parameters:
Name Type Description
options object 加载选项。
Example
selector.loadResource();

makeInstancedDrawing(value, options)
thing/src/selector/Selector.js, line 1497

将对象设置为实例化绘制模式。
Parameters:
Name Type Description
value boolean 如果为true，则启用实例化绘制模式。
options object 选项。
Example
// 启用对象的实例化绘制
selector.makeInstancedDrawing(true);

// 禁用对象的实例化绘制
selector.makeInstancedDrawing(false);

map(callback) → {THING.Selector}
thing/src/selector/Selector.js, line 1089

遍历对象并返回一个新的选择器。
Parameters:
Name Type Description
callback OnMapObjectsInSelector 回调函数。
Returns:
THING.Selector - 返回包含结果的选择器实例。
Example
// 返回每个对象的第一个子对象
let objects = selector.map((object) => {
	return object.children[0];
});

not(condition) → {THING.Selector}
thing/src/selector/Selector.js, line 943

根据条件删除对象，并返回包含结果的新选择器。
Parameters:
Name Type Description
condition string 条件。
Returns:
THING.Selector - 返回包含结果的选择器实例。
Example
// 通过删除选择器/对象返回新的选择器
let objects = selector.not([obj1, obj2, obj3]);
console.log(objects);

off(type, condition, tag)
thing/src/selector/Selector.js, line 1770

注销所有对象事件。
Parameters:
Name Type Description
type string 事件类型。
condition string 选择对象的条件。
tag string 事件标签。
Example
// 通过标签名注销所有具有'click'事件监听器的实体
let mark = 0;
let entity = new THING.Entity();
entity.on('test', ()=> {
   mark = 1;
})
let selector = new THING.Selector([entity]);
let markOff = 0;
selector.on('testOff', function(ev) {
		markOff = 1;
});
selector.trigger('testOff');
// @expect(markOff == 1 && mark == 1);
markOff = 0;
mark = 0;
selector.off('testOff');
selector.trigger('testOff');
// @expect(markOff == 0 && mark == 0);

on(type, condition, callback, tag, priority, options)
thing/src/selector/Selector.js, line 1708

注册所有对象事件。
Parameters:
Name Type Description
type string 事件类型。
condition string 选择对象的条件。
callback function 回调函数。
tag string 事件标签。
priority number 优先级值（默认为0，值越高越先处理）。
options ObjectEventOptions 选项。
Example
// 注册所有实体的'click'事件监听器
let mark = 0;
let entity = new THING.Entity();
entity.on('test', ()=> {
   mark = 1;
})
let selector = new THING.Selector([entity]);
let markOn = 0;
selector.on('testOn', function(ev) {
		markOn = 1;
});
selector.trigger('testOn');
// @expect(markOn == 1 && mark == 1);

once(type, condition, callback, tag, priority, options)
thing/src/selector/Selector.js, line 1740

注册所有对象事件，只触发一次。
Parameters:
Name Type Description
type string 事件类型。
condition string 选择对象的条件。
callback function 回调函数。
tag string 事件标签。
priority number 优先级值（默认为0，值越高越先处理）。
options ObjectEventOptions 选项。
Example
// 注册所有实体的'click'事件监听器
let mark = 0;
let entity = new THING.Entity();
entity.on('test', ()=> {
   mark = 1;
})
let selector = new THING.Selector([entity]);
let markOnce = 0;
selector.once('testOnce', function(ev) {
		markOnce = 1;
});
selector.trigger('testOnce');
// @expect(markOnce == 1 && mark == 1);
markOnce = 0;
mark = 0;
selector.trigger('testOnce');
// @expect(markOnce == 0 && mark == 0);

pauseEvent(type, condition, tag)
thing/src/selector/Selector.js, line 1800

暂停所有对象的事件。
Parameters:
Name Type Description
type string 事件类型。
condition string 选择对象的条件。
tag string 事件标签。
Example
// 通过标签名暂停所有具有'click'事件监听器的实体
let mark = 0;
let entity = new THING.Entity();
entity.on('test', ()=> {
   mark = 1;
})
let selector = new THING.Selector([entity]);
let markPause = 0;
selector.on('testPause', function(ev) {
		markPause = 1;
});
selector.trigger('testPause');
// @expect(markPause == 1 && mark == 1);
markPause = 0;
mark = 0;
selector.PauseEvent('testPause');
selector.trigger('testPause');
// @expect(markPause == 0 && mark == 0);

push(…args) → {number}
thing/src/selector/Selector.js, line 839

将对象推入数组。
Parameters:
Name Type Attributes Description
args THING.BaseObject | Array.<THING.BaseObject> | THING.Selector <repeatable>
 要推入的对象。
Returns:
number - 推入对象后的数组长度。
Example
let objects = app.query('.Entity');
let selector = new THING.Selector(objects);
let count1 = selector.length;
let object = new THING.BaseObject();
let count2 = selector.push(object);
let ret = count2 - count1 == 1;
// @expect(ret == true)

queryByDTType(condition, objects, target) → {THING.Selector}
thing/src/selector/Selector.js, line 595

根据孪生体类型查询子对象。
Parameters:
Name Type Description
condition string 选择对象的条件。
objects Array.<THING.BaseObject> 要查询的对象数组。
target THING.Selector 目标选择器。
Returns:
THING.Selector - 返回包含查询结果的选择器实例。
Example
let objects = app.query('.BaseObject');
let selector = new THING.Selector(objects);
let equipment = selector.queryByDTType('Equipment');
let ret = equipment.length != 0 && equipment[0].dtType == 'Equipment';
// @expect(ret == true)

queryById(condition, objects, target) → {THING.Selector}
thing/src/selector/Selector.js, line 552

根据id查询子对象。
Parameters:
Name Type Description
condition string 选择对象的条件。
objects Array.<THING.BaseObject> 要查询的对象数组。
target THING.Selector 目标选择器。
Returns:
THING.Selector - 返回包含查询结果的选择器实例。
Example
let objects = app.query('.BaseObject');
let selector = new THING.Selector(objects);
let car = selector.queryById('car01');
let ret = car.length != 0 && car[0].id == 'car01';
// @expect(ret == true)

queryByName(condition, objects, target) → {THING.Selector}
thing/src/selector/Selector.js, line 510

根据名称查询子对象。
Parameters:
Name Type Description
condition string 选择对象的条件。
objects Array.<THING.BaseObject> 要查询的对象数组。
target THING.Selector 目标选择器。
Returns:
THING.Selector - 返回包含查询结果的选择器实例。
Example
let objects = app.query('.BaseObject');
let selector = new THING.Selector(objects);
let car = selector.queryByName('car1');
let ret = car.length != 0 && car[0].name == 'car1';
// @expect(ret == true)

queryByRegExp(condition, objects, target) → {THING.Selector}
thing/src/selector/Selector.js, line 448

使用正则表达式查询子对象。
Parameters:
Name Type Description
condition RegExp 选择对象的条件，作为正则表达式。
objects Array.<THING.BaseObject> 要查询的对象数组。
target THING.Selector 目标选择器。
Returns:
THING.Selector - 返回包含查询结果的选择器实例。
Example
let objects = app.query('.BaseObject');
let selector = new THING.Selector(objects);
let car = selector.queryByRegExp(/car/);
let ret = car.length != 0;
// @expect(ret == true)

queryByTags(condition, objects, target) → {THING.Selector}
thing/src/selector/Selector.js, line 488

根据标签查询子对象。
Parameters:
Name Type Description
condition string 选择对象的条件。
objects Array.<THING.BaseObject> 要查询的对象数组。
target THING.Selector 目标选择器。
Returns:
THING.Selector - 返回包含查询结果的选择器实例。
Example
let objects = app.query('.BaseObject');
let selector = new THING.Selector(objects);
let car = selector.queryByTags('Entity');
let ret = car.length != 0;
// @expect(ret == true)

queryByType(condition, objects, target) → {THING.Selector}
thing/src/selector/Selector.js, line 573

根据类型查询子对象。
Parameters:
Name Type Description
condition string 选择对象的条件。
objects Array.<THING.BaseObject> 要查询的对象数组。
target THING.Selector 目标选择器。
Returns:
THING.Selector - 返回包含查询结果的选择器实例。
Example
let objects = app.query('.BaseObject');
let selector = new THING.Selector(objects);
let entitys = selector.queryByType('Entity');
let ret = entitys.length != 0 && entitys[0].type == 'Entity';
// @expect(ret == true)

queryByUUID(condition, objects, target) → {THING.Selector}
thing/src/selector/Selector.js, line 531

根据UUID查询子对象。
Parameters:
Name Type Description
condition string 选择对象的条件。
objects Array.<THING.BaseObject> 要查询的对象数组。
target THING.Selector 目标选择器。
Returns:
THING.Selector - 返回包含查询结果的选择器实例。
Example
let objects = app.query('.BaseObject');
let selector = new THING.Selector(objects);
let car = selector.queryByUUID('1605');
let ret = car.length != 0 && car[0].uuid == '1605';
// @expect(ret == true)

queryByUserData(condition, objects, target) → {THING.Selector}
thing/src/selector/Selector.js, line 616

根据userData查询子对象。
Parameters:
Name Type Description
condition string 选择对象的条件。
objects Array.<THING.BaseObject> 要查询的对象数组。
target THING.Selector 目标选择器。
Returns:
THING.Selector - 返回包含查询结果的选择器实例。
Example
let objects = app.query('.BaseObject');
let selector = new THING.Selector(objects);
let car = selector.queryByUserData('id="666"')
let ret = car.length != 0 && car[0].userData.id == '666';
// @expect(ret == true)

reduce(callback, initialValue) → {number}
thing/src/selector/Selector.js, line 1142

在选择器中执行用户提供的"reducer"回调函数，按顺序对数组的每个元素进行计算，并传入前一个元素的计算结果。在数组的所有元素上运行reducer的最终结果是一个单一的值。
Parameters:
Name Type Default Description
callback OnReduceObjectsInSelector 回调函数。
initialValue number 0 初始值。
Returns:
number - 返回计算结果。
Example
// 获取实体的平均高度
let entities = app.query('.Entity');
let height = entities.reduce((value, entity) => {
	return value + entity.position[1];
}, 0) / entities.length;

remove(condition) → {THING.Selector}
thing/src/selector/Selector.js, line 915

根据条件删除对象，并返回包含结果的新选择器。
Parameters:
Name Type Description
condition string 条件。
Returns:
THING.Selector - 返回包含结果的选择器实例。
Example
let objects = app.query('.Entity');
let selector = new THING.Selector(objects);
selector.remove('.Entity');
let count = selector.length;
let ret = count == 0;
// @expect(ret == true)

removeAt(index) → {THING.Selector}
thing/src/selector/Selector.js, line 1311

移除指定索引处的对象。
Parameters:
Name Type Description
index number 要移除的对象的索引。
Returns:
THING.Selector - 返回当前选择器实例，用于链式调用。
Example
// 移除选择器中的第一个对象。
selector.removeAt(0);

resumeEvent(type, condition, tag)
thing/src/selector/Selector.js, line 1833

恢复所有对象的事件。
Parameters:
Name Type Description
type string 事件类型。
condition string 选择对象的条件。
tag string 事件标签。
Example
// 通过标签名恢复所有具有'click'事件监听器的实体
let mark = 0;
let entity = new THING.Entity();
entity.on('test', ()=> {
   mark = 1;
})
let selector = new THING.Selector([entity]);
let markResume = 0;
selector.on('testPause', function(ev) {
		markResume = 1;
});
selector.trigger('testPause');
// @expect(markResume == 1 && mark == 1);
markResume = 0;
mark = 0;
selector.PauseEvent('testPause');
selector.trigger('testPause');
// @expect(markResume == 0 && mark == 0);
selector.resumeEvent('testPause');
selector.trigger('testPause');
// @expect(markResume == 1 && mark == 1);

reverse() → {THING.Selector}
thing/src/selector/Selector.js, line 1363

反转对象。
Returns:
THING.Selector - 返回当前选择器实例，用于链式调用。
Example
// 反转选择器中的对象。
selector.reverse();

setVisible(value, recursiveopt)
thing/src/selector/Selector.js, line 1533

设置可见状态。
Parameters:
Name Type Attributes Default Description
value boolean 如果为true，则显示，否则隐藏。
recursive boolean <optional>
 false 如果为true，则对所有子对象进行处理。
Example
// 将选择器中所有对象的可见属性设置为true
selector.setVisible(true);

// 将选择器中所有对象及其子对象的可见属性设置为true
selector.setVisible(true, true);

slice(start, end) → {THING.Selector}
thing/src/selector/Selector.js, line 1165

返回指定范围内的元素。
Parameters:
Name Type Description
start number 起始索引。
end number 结束索引。
Returns:
THING.Selector - 返回一个新的选择器，包含指定范围内的元素。
Example
// 返回 [1, 4] 范围内的对象
let objects1 = selector.slice(1, 4);

// 返回 [1, ...] 范围内的对象
let objects2 = selector.slice(1);

some(callback) → {boolean}
thing/src/selector/Selector.js, line 1113

some 检查是否至少有一个对象满足提供的条件。
Parameters:
Name Type Description
callback function 回调函数。
Returns:
boolean - 如果至少有一个对象满足条件，则返回true，否则返回false。
Example
selector.some(object => {
    return object.isVisible; // 检查是否至少有一个对象可见
});

sort(callback) → {THING.Selector}
thing/src/selector/Selector.js, line 1225

按照回调函数的结果，从低到高对对象进行排序。
Parameters:
Name Type Description
callback OnSortObjectsInSelector 用于排序的回调函数。
Returns:
THING.Selector - 返回排序后的选择器实例。
Example
// 按照名称对对象进行排序
selector.sort((obj1, obj2) => {
	return obj1.name.localeCompare(obj2.name);
})

splice(index, number) → {THING.Selector}
thing/src/selector/Selector.js, line 1282

删除对象。
Parameters:
Name Type Description
index number 起始索引。
number number 要删除的对象数量。
Returns:
THING.Selector - 被删除的对象。
Example
// 删除 [1, 4] 范围内的对象
let removeObjects = selector.splice(1, 4);

swap(index0, index1) → {THING.Selector}
thing/src/selector/Selector.js, line 1327

交换指定索引处的对象。
Parameters:
Name Type Description
index0 number 第一个对象的索引。
index1 number 第二个对象的索引。
Returns:
THING.Selector - 返回当前选择器实例，用于链式调用。
Example
// 交换选择器中索引为0和索引为3的对象。
selector.swap(0, 3);

toArray() → {Array.<THING.BaseObject>}
thing/src/selector/Selector.js, line 1242

转换为数组（返回一个新的数组）。
Returns:
Array.<THING.BaseObject> - 返回一个包含选择器中所有对象的新数组。
Example
// 获取/转换为数组模式的对象
let objects = selector.objects;
console.log(objects);

trigger(type, ev, options)
thing/src/selector/Selector.js, line 1855

触发所有对象的事件。
Parameters:
Name Type Description
type string 事件类型。
ev object 事件信息。
options object 选项。
Properties
Name Type Description
tag string 标签名称。
Example
// 通过标签名触发所有具有'click'事件监听器的实体
let mark = 0;
let entity = new THING.Entity();
entity.on('test', ()=> {
   mark = 1;
})
let selector = new THING.Selector([entity]);
selector.trigger('test');
// @expect(mark == 1)

unloadResource()
thing/src/selector/Selector.js, line 1674

卸载资源。
Example
selector.unloadResource();

waitForComplete() → {Promise.<any>}
thing/src/selector/Selector.js, line 1596

等待所有对象加载完成。
Returns:
Promise.<any> - 返回一个Promise，resolve时传入已加载完成的对象数组。
Example
// 等待所有对象加载完成，然后打印它们的名称
selector.waitForComplete().then((objects) => {
	objects.forEach(object => {
		console.log(object.name);
	});
});