如何定义@提到的是否是订阅者？ TMI.js（是否订阅啵乐）

25-02-05 15

本文将分享如何定义@提到的是否是订阅者？TMI.js的详细内容，并且还将对是否订阅啵乐进行详尽解释，此外，我们还将为大家带来关于07RabbitMQ_发布订阅者模式、android–Rxjava,如何

本文将分享如何定义@提到的是否是订阅者？ TMI.js的详细内容，并且还将对是否订阅啵乐进行详尽解释，此外，我们还将为大家带来关于07RabbitMQ_发布订阅者模式、android – Rxjava,如何推迟排放,直到一些订阅者订阅？、django – TypeError：*之后的add()参数必须是序列,而不是订阅者、ember.js – EmberJs是否支持发布/订阅者事件模式？的相关知识，希望对你有所帮助。

本文目录一览：

如何定义@提到的是否是订阅者？ TMI.js（是否订阅啵乐）
07RabbitMQ_发布订阅者模式
android – Rxjava,如何推迟排放,直到一些订阅者订阅？
django – TypeError：*之后的add()参数必须是序列,而不是订阅者
ember.js – EmberJs是否支持发布/订阅者事件模式？

如何定义@提到的是否是订阅者？ TMI.js（是否订阅啵乐）

user.mod

仅可用于消息处理程序返回的用户对象。如果您想检查提到的用户是否是模组，您必须请求聊天列表

function getAllChatters(channel,_attempts) {
  return rp({
    uri: `https://tmi.twitch.tv/group/user/${channel.replace('#','')}/chatters`,json: true
  })
  .then(data =>  {
    return Object.entries(data.chatters)
    .reduce((p,[ type,list ]) => p.concat(list.map(name => {
      return {name,type};
    })),[]);
  })
  .catch(err => {
    if(_attempts < 3) {
      return getChatters(channel,_attempts + 1);
    }
    throw err;
  })
}

然后只过滤它的模组

function getModsOnline(channel) {
  return getAllChatters(channel)
  .then(data => {
    var mods = data.filter(chatter => chatter.type == 'moderators' || chatter.type == 'broadcaster').map(chatter => chatter.name);
    return mods;
  })
}

然后查看用户是否在列表中

function isModOnline(channel,username) {
  // This will only return true if the mod is online in chat aka in the chat list
  return getMods(channel)
  .then(mods => {
    return mods.includes(username);
  })
}

记住这一点

这是为了获取模组，而不是订阅者
它仅适用于当前处于聊天状态的模组，该列表往往更新缓慢
你需要在这里使用 Promise

const rp = require('request-promise');

并使用该值

```
  isModOnline(channel,username)
  .then(value => {
    // Code to work with the value here 
    console.log(`User is mod: ${value}`);
  })

07RabbitMQ_发布订阅者模式

import pika

''''''
    1.发布者不需要创建队列去存储要发布的信息.
    2.发布者将消息发送到RabbitMQ的转换器exchange中,并定义了exchange处理message的方式.
    3.发布订阅模式,如果在发布者发布消息的时候订阅者还未订阅,那么订阅者将接收不到消息
''''''

# 1.创建一个socket
connection = pika.BlockingConnection(pika.ConnectionParameters(host="localhost"))
# 2.获取链接的管道
channel=connection.channel()
# 3.定义一个exchange转换器,将需要发布的消息发送的转换器上,将管道连接到定义的转换器上
# 4.设置类型为fanout: 所有bind到此exchange的queue都可以接收消息
channel.exchange_declare(
    exchange=''logs'',
    exchange_type=''fanout''
)
# 5.创建需要发布的消息
message = ''发布者要发布的消息1''
# 6.发布者开始发布消息
channel.basic_publish(
    exchange=''logs'',
    routing_key='''',#这里必须为空
    body=message
)
print("发布者发布了消息:%s" % message)
# 7.关闭socket连接
connection.close()

import pika

''''''
    1.订阅者必须声明一个queue类绑定到exchange(转换器)上
    2.exchange会遍历已经绑定到他身上的Queue,将消息存入queue中,消费者只会访问Queue
''''''

# 1.定义连接RabbitMQ的socket
connection = pika.BlockingConnection(pika.ConnectionParameters(host=''localhost''))
# 2.获取连接RabbitMQ的管道
channel = connection.channel()
# 3.定义要连接的exchange转换器,并设置类型
channel.exchange_declare(
    exchange=''logs'',
    exchange_type=''fanout''
)

# 4.定义一个队列存储转换器存储的消息
# 不指定queue名字,rabbit会随机分配一个名字,
# exclusive(唯一的)=True会在使用此queue的消费者断开后,自动将queue删除
result = channel.queue_declare(exclusive=True)

# 5.获取队列的名称
queue_name = result.method.queue
# 6.为exchange转换器绑定队列.
channel.queue_bind(
    exchange=''logs'',
    queue=queue_name
)
print("订阅者开始等到消息:")


# 7.定义一个函数来处理消息
def callback(ch, method, properties, body):
    print(''消息是:%s'' % body.decode())
# 8.设置接收消息后的处理方法
channel.basic_consume(
    callback,
    queue=queue_name,
    no_ack=True
)
#9.开始接收消息
channel.start_consuming()

android – Rxjava,如何推迟排放,直到一些订阅者订阅？

我正在制作Android应用,有一个初学者的问题：
有没有办法推迟Observables排放,直到2个订阅者订阅？因为我不希望第二个错过数据.
谢谢

解决方法:

是的,使用ConnectableObservable类型进行确定性多播支持此用例.

有两种方法可以使用它.

第一个也是最简单的是使用这样的发布重载：

    Observable<Long> sourcetoShare = Observable.interval(10, TimeUnit.MILLISECONDS);

    // multiple subscriptions deterministically subscribed to using publish()
    sourcetoShare.publish(l -> {
        Observable<String> a = l.map(t -> "first subscriber " + t);
        Observable<String> b = l.buffer(4).map(t -> "second subscriber " + t);
        return Observable.merge(a, b);
    }).take(20).toBlocking().forEach(System.out::println);

或者,如果您需要在连接所有订户后手动控制源何时启动和停止,您可以直接使用ConnectableObservable,如下所示：

    Observable<Long> sourcetoShare = Observable.interval(10, TimeUnit.MILLISECONDS);


    // multiple subscriptions deterministically subscribed to using ConnectableObservable
    ConnectableObservable<Long> published = sourcetoShare.publish();

    Observable<String> a = published.map(t -> "first subscriber " + t);
    Observable<String> b = published.buffer(4).map(t -> "second subscriber " + t);
    Observable.merge(a, b).take(20).forEach(s -> System.out.println("published => " + s));

    // Now that everything is wired up, connect the source
    published.connect();

    // since we are connecting asynchronously and need to 'connect' after subscribing
    // we have to manually give it time to execute
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        // Todo Auto-generated catch block
        e.printstacktrace();
    }

以下是文档的链接：

> http://reactivex.io/RxJava/javadoc/rx/Observable.html#publish(rx.functions.Func1)
> http://reactivex.io/RxJava/javadoc/rx/observables/ConnectableObservable.html
> http://reactivex.io/documentation/operators.html#connectable

django – TypeError：*之后的add()参数必须是序列,而不是订阅者

class Subscribers(User):
    date = models.DateField()
    user = models.OnetoOneField(User)

class Tour(models.Model):
    owner_id = models.ForeignKey(User)
    name = models.CharField(max_length=50)
    location = models.ManyToManyField(Location)
    subscribers = models.ManyToManyField(Subscribers,related_name="sub")

我试图在另一个文件中执行此操作：

user1 = User.objects.create_user(''John'',''j@j.com'',''j1'')
user2= User.objects.create_user(''Mike'',''m@m.com'',''m1'')
user3= User.objects.create_user(''kokoko'',''m1'')
user4= User.objects.create_user(''lalal'',''m1'')
sub = Subscribers()
tour = Tour()
tour.id = "1"
tour.name = "hello"
tour.owner_id = user1
tour.subscribers = sub

但我有这个错误：
TypeError：*之后的add()参数必须是序列,而不是订阅者

解决方法

ManyToMany经理假设您这样做

tour.subscribers = sub

sub是订阅者的序列(元组,列表,查询集),而不是单个对象.然后这样做与完成相同：

tour.subscribers.add(*sub)

由于sub不是一个序列,它会抛出这样的错误.我建议先保存然后再添加.我认为它也更具可读性,但可能只是我的观点：

sub = Subscribers()
tour = Tour()
tour.id = "1"
tour.name = "hello"
tour.owner_id = user1
tour.save()
tour.subscribers.add(sub)

希望这可以帮助：)

ember.js – EmberJs是否支持发布/订阅者事件模式？

我最近正在评估一个 JavaScript框架,用于我们的下一个项目.我真的很喜欢Ember.但是在我们的应用程序中,我们需要一个来自数据层的事件机制来通知控制器层有些事情发生了变化.例如,我知道可以在Ember中使用obersevers：

person.addobserver('fullName',function() {
  // deal with the change
});

但是我更喜欢Backbone.Events,您可以订阅或发布活动,具体来说：

var object = {};

_.extend(object,Backbone.Events);

object.on("alert",function(msg) {
  alert("Triggered " + msg);
});

object.trigger("alert","an event");

任何人都有一个想法,是否可以在EmberJS？

为了给我一些关于我的问题的背景,我们的应用程序是一个实时应用程序.因此,后端RESTful服务会不时地将一个事件触发到客户端(JavaScript端).我想要一个封装对后端RESTful服务的访问的数据层,但也保留缓存.我希望EmberJS.Data可以帮助我(这是一个单独的问题,我想找到答案).这样,当我们从后端RESTful服务发生变化时,我也希望更新缓存.一旦缓存对象被更新,我希望通知控制器层.这基本上是为什么我需要JavaScript方面的一些事件机制.

请注意,我不想使用观察者的原因是有时,一个事件可能意味着我必须执行一个动作,即加载一个消息,或者指示语音通话来了.骨干的方式对我来说似乎更自然.

谢谢

解决方法

自从提交 2326580 – 从v0.9.6可用 – 有一个Ember.Evented Mixin,请参阅 http://jsfiddle.net/qJqzm/.

var handler = Ember.Object.create({
    otherEvent: function() {
        console.log(arguments);
    }
});

var myObject = Ember.Object.create(Ember.Evented,{
    init: function() {
        this._super();
        this.on('alert',this,'alert');
    },alert: function() {
        console.log(arguments);
    }
});
myObject.on('otherEvent',handler,'otherEvent');

myObject.fire('alert',{
    eventObject: true
});
myObject.fire('otherEvent',{
    first: true
},{
    second: true
});

今天的关于如何定义@提到的是否是订阅者？ TMI.js和是否订阅啵乐的分享已经结束，谢谢您的关注，如果想了解更多关于07RabbitMQ_发布订阅者模式、android – Rxjava,如何推迟排放,直到一些订阅者订阅？、django – TypeError：*之后的add()参数必须是序列,而不是订阅者、ember.js – EmberJs是否支持发布/订阅者事件模式？的相关知识，请在本站进行查询。

本文标签：