精华内容
下载资源
问答
  • 多级评论

    2019-09-22 03:47:38
    多级评论之博客园结构版 思路 1、评论区和评论展示区域 < form action ="/comment/" method ="post" novalidate > {% csrf_token %} {{ obj.content }} < span id ="errors" > span > 评论展示...
    # data=[
    #     [11,22,33],
    #     [44,55,66]
    # ]
    # data[0].append(data[1])
    # print(data)
    # data[1].append(77)
    #
    # 由于[11, 22, 33, [44, 55, 66, 77]]和[[11, 22, 33, [44, 55, 66, 77]], [44, 55, 66, 77]]
    #
    # 引用的是同一块内存地址,所以谁添加了内容对应的也跟随添加
    
    
    # data=[
    #       {'k1':'v1'},
    #       {'k2':'v2'}
    #       ]
    #
    # for item in data:
    #     item['kk']='vv'
    #
    #
    # # python里面列表和字典引用的是引用类型,当我们拿到地址被操作了,会发生级联变化;如果想要再独立一份就需要copy()
    #
    # msg_list = [
    #    {'id':1,'content':'xxx','parent_id':None},
    #    {'id':2,'content':'xxx','parent_id':None},
    #    {'id':3,'content':'xxx','parent_id':None},
    #    {'id':4,'content':'xxx','parent_id':1},
    #    {'id':5,'content':'xxx','parent_id':4},
    #    {'id':6,'content':'xxx','parent_id':2},
    #    {'id':7,'content':'xxx','parent_id':5},
    #    {'id':8,'content':'xxx','parent_id':3},
    # ]
    # # v=[row.setdefault('child')  for row in msg_list]
    # #
    # # #注意列表生成公式里面 不能出现=等赋值操作,可以使用方法
    # # print(msg_list)
    #
    # #方式2
    #
    # msg_list_dict={}
    # # msg_list_dict={
    # # 1, {'id':1,'content':'xxx','parent_id':None},
    # # 2, {'id':2,'content':'xxx','parent_id':None},
    # #               }
    # #字典的在存储的时候,键会转换成一个hashs值,这个hash值和内存地址相关,# 无论字典里的键值对有多大,都可以一次的寻找到key对应的value
    # #字典查询就是数据库里的hansh 索引,直接拿到key就可以快得惊人的获取到value
    # #无需向列表那样 查询 是 一个个顺序 遍历
    #
    # #所以定义一个字典 方便我们查找 评论信息,而且因为Python是数据引用类型,相同数据引用一块内存,也不会占用内存
    # for item in msg_list:
    #     item['child']=[]
    #     msg_list[item['id']]=item
    #
    # #程序运行到此处,会有两个msg_list   msg_list_dict
    # ret=[]
    # for item in  msg_list:
    #     pid=item['parent_id']
    #     if pid:
    #         msg_list[pid]['child'].apend(item)
    #     else:
    #         ret.append(item)
    
    msg_list = [
        {'id':1,'content':'xxx','parent_id':None},
        {'id':2,'content':'xxx','parent_id':None},
        {'id':3,'content':'xxx','parent_id':None},
        {'id':4,'content':'xxx','parent_id':1},
        {'id':5,'content':'xxx','parent_id':4},
        {'id':6,'content':'xxx','parent_id':2},
        {'id':7,'content':'xxx','parent_id':5},
        {'id':8,'content':'xxx','parent_id':3},
    ]
    msg_dict={}
    
    #1、给所以 评论设置一个 child键=[空列表的值] [row.setdefault('child',[]) for row in msg_list] 列表生成器方法
    
    #3、定义一个查询用的字典
    for item in msg_list:
        item['child']=[]
        msg_dict[item['id']]=item
    
    
    
    #2、把带有'parent_id'的键的字典,添加到对应的父字典里(你会想到再次遍历msg_list,但是多层循环效率低下,于是重新定义一个字典)
    for item in msg_list:
        pid=item['parent_id']
        if pid:
            msg_dict[pid]['child'].append(item)
    
    
    # 4、找出根评论·
    root_coment=[]
    for item in msg_list:
        if not item['parent_id']:
            root_coment.append(item)
    
    for item in  root_coment:
        print(item)

     

    模板

        '''   
        <div class="cooment">
            <div class="content"></div>  根评论
                <div class="cooment">
                    <div class="content"></div> 子评论
                    <div class="content"></div> 子评论
                    <div class="content"></div> 子评论
                 </div>  
            <div class="content"></div> 根评论
                <div class="cooment">
                    <div class="content"></div> 子评论
                    <div class="content"></div> 子评论
                    <div class="content"></div> 子评论
                 </div>  
            <div class="content"></div>  根评论
            <div class="content"></div>
        </div>    
        '''
        #----------------------------------------------
        comment_str=''
        comment_str += '<div class="comment">'
        for row in result:
            tp1='<div class="content">%s</div>'% (row['content'])
            comment_str+=tp1
    
            if row['child']:
                for chil in row['child']:
                    comment_str += '<div class="comment">'
                    tp1 = '<div class="content">%s</div>' % (chil['content'])
                    comment_str += tp1
                comment_str += '</div>'
    
    
        comment_str += '</div>'
        return render(request,'comment.html',locals())

     

    多级评论之博客园结构版

    思路

    1、评论区和评论展示区域

      <form action="/comment/" method="post" novalidate>
            {% csrf_token %}
            {{ obj.content }} <span id="errors"></span>                                                  评论展示区域
            <p>
                <input type="button" value="发表" class="btn btn-primary ajax_comment">                   评论发表区域
            </p>
        </form>

    2、评论在评论发表区域属于之后使用ajax提交到server存储数据库

    <script>
            $('.ajax_comment').click(function () {
                {#           由于评论内容前缀携带@父评论\n,所以需要 找到'\n'的字符串索引进行截断#}
                var $index = $('[name="content"]').val().indexOf('\n')
                var $content = $('[name="content"]').val().substr($index + 1)
                var $csrf = $("[name='csrfmiddlewaretoken']").val();
                var $article_id = {{ artic.nid }};
    
                var formdata = new FormData();
                formdata.append('csrfmiddlewaretoken', $csrf)
                formdata.append('content', $content)
                formdata.append('article_id', $article_id)
                formdata.append('parent_id_id', $prant_comment_id)
                {% if request.user.is_authenticated %}
                    $.ajax({
                        url: '/comment/',
                        type: 'post',
                        data: formdata,
                        processData: false,
                        contentType: false,
                        success: function (data) {

     

    3、server存储完成后,把成功消息回传浏览器

    def comment(request):
        responses={'flag':True,'msg':None}
        obj=Commenform(request.POST)
        if obj.is_valid():
            content=obj.cleaned_data['content']
            article_id=request.POST.get('article_id')
            user_id=request.user.nid
            parent_id_id=request.POST.get('parent_id_id',)
            comment_obj=models.Comment.objects.create(article_id=article_id,
                                          content=content,
                                          parent_id_id=parent_id_id,
                                          user_id=user_id,
                                          )
            responses['create_time']=str(comment_obj.create_time)[:16]
            models.Article.objects.filter(nid=article_id).update(
                                    comment_count=F('comment_count')+1)
        else:
            responses['flag']=False
            responses['msg']=obj.errors
        return HttpResponse(json.dumps(responses))

     

    4、此时数据库中已有数据,通过页面刷新即可获得最新评论,可是体验不佳,于是浏览器可以通过 server端回传的信号,使用JavaScript或jQuery动态添加评论标签,制造显示效果;

    if (data['flag']) {
                                var $create_time = data['create_time'];
                                var $content = $('[name="content"]').val();
                                s = '<li class="list-group-item comment_item"><a href="">{0}</a><a href="">{1}</a><a href="" ' +
                                    'class="pull-right">&nbsp;支持</a> <a href="#comment_content" class="pull-right reply_btn">' +
                                    '回复</a><span class="{2}"></span> <div> <span>{3}</span> <p>{4}</p></div> </li>'
                                s = s.format(
                                    '{{ request.user.username }}',
                                    $create_time,
                                    $prant_comment_id,
                                    $fathercomment_username,
                                    $content
                                );
    
                                $('.comment_list').append(s)
                                $('[name="content"]').val(' ');
                                $prant_comment_id = '';
                                $fathercomment_username = '';
    
    
                            }
                            else {
                                $.each(data['msg'], function (i, j) {
                                    $('#errors').text(j[0]).css('color', 'red')
                                    setTimeout(function () {
                                        $("#errors").text("")
                                    }, 1000)
    
    
                                })
                            }
                        }
    
                    })
    View Code

     

    5、根评论搞定(对文章的评论),可是如果涉及对评论进行评论呢?利用A标签的锚特效, 当用户点击回复的A标签,同样锚定到评论区域‘’

     

     

     6、于此同时 给回复A标签绑定其他事件,携带 父级评论的ID、内容

     <script>
            var $prant_comment_id = '';
            var $fathercomment_username = '';
            $(".comment_list").on("click", "#reply_btn", function () {
                var $fathercomment_username = $(this).siblings().eq(0).text()
                $('#comment_content').val('@' + $fathercomment_username + '\n')
                $prant_comment_id = $(this).siblings().eq(3).attr('name')
    
    
            })
        </script>

     

     

     

     

     

     

    转载于:https://www.cnblogs.com/sss4/p/7501978.html

    展开全文
  • Django多级评论

    2017-07-17 22:31:00
    #多级评论原理简单原理,弄完之后发现基础白学了 msg_list = [ {'id':1,'content':'xxx','parent_id':None}, {'id':2,'content':'xxx','parent_id':None}, {'id':3,'content':'xxx','parent_id':None}, ...

    一、原理

    #多级评论原理简单原理,弄完之后发现基础白学了
    msg_list = [
        {'id':1,'content':'xxx','parent_id':None},
        {'id':2,'content':'xxx','parent_id':None},
        {'id':3,'content':'xxx','parent_id':None},
        {'id':4,'content':'xxx','parent_id':1},
        {'id':5,'content':'xxx','parent_id':4},
        {'id':6,'content':'xxx','parent_id':2},
        {'id':7,'content':'xxx','parent_id':5},
        {'id':8,'content':'xxx','parent_id':3},
    ]
    #python里面的apend之类的东西都是引用的原来数据的内从地址,对原数据进行操作的话
    #我们引用的数据也会发生一样的变化(字典列表之类的)
    
    #骗子的方法
    # for i in msg_list:
    #     i['child']=[]
    # for i in range(len(msg_list)-1,-1,-1):
    #     if msg_list[i]['parent_id']:
    #         msg_list[msg_list[i]['parent_id'] - 1]['child'].append(msg_list[i])
    # new_msg_list = [i for i in msg_list if i['parent_id'] is None]
    # print(new_msg_list)
    
    #老师讲的方法
    # v=[row.setdefault('child',[]) for row in msg_list] #这和地下的第一个for循环的作用是一样的,给每一个元素加一个'child':[]
    # print(msg_list)
    #如果我们想加快索引(快点找到数据的话)就建一个字典的数据结构
    msg_list_dict={} #加快索引,节省时间
    for item in msg_list:
        item['child']=[]
        msg_list_dict[item['id']]=item #字典中key为item['id'],value为item
        #把字典数据结构填上数据,能够加快索引,而且我们数据还是占得原来的内从空间
        #我们只是引用了数据的内容空间,所以不存在新的数据结构浪费空间一说
    result=[]
    for item in msg_list:
        pid=item['parent_id']
        if pid: #如果parent_id不为空,说明它是子级,要把自己加入对应的父级
            msg_list_dict[pid]['child'].append(item)
        else: #如果为空,说明他是父级,要把它单独领出来用
            result.append(item)
    #result就是我们最终要的结果,因为这里面全是引用,所有数据的内存地址都没有变
    #只不过被多个数据结构引用了而已
    print(result)

    二、精简版

    views代码

    def comments(request,nid):
        res={'status':True,'data':None,'msg':None}
        try:
            comment_list = models.Comment.objects.filter(article_id=nid).values()
            com_list = list(comment_list)  # 所有的评论,列表套字典
            com_list_dict = {}  # 建立一个方便查找的数据结构字典
            for item in com_list:  # 循环评论列表,给每一条评论加一个child:[]就是让他装对他回复的内容
                item['create_time'] = str(item['create_time'])
                item['child'] = []
                com_list_dict[item['nid']] = item
            result = []
            for item in com_list:
                rid = item['reply_id']
                if rid:  # 如果reply_id不为空的话,那么就是说明他是子评论,我们要把他加入对应的评论后面
                    com_list_dict[rid]['child'].append(item)
                else:
                    result.append(item)
            print(result)
            # comment_str = comment_tree(result)
            # 这是在服务器上递归完之后,然后在传到前端,但是这样会增加服务器压力
            #所以这种方式我们直接就不用了
            res['data']=result
        except Exception as e:
            res['status']=False
            res['mag']=str(e)
        return HttpResponse(json.dumps(res))

    HTML代码

    <style>
        .comment{
            margin-left:20px;
            }
    </style>
    
    <body>
        <div id="commentArea">
    
        </div>
    </body>
    <script src="/static/jquery-3.2.1.js"></script>
    <script>
            //自定义JS中字符串格式化方法
            String.prototype.Format=function (arg) {
                //console.log(this,arg); //this,当前调用方法的字符串,arg为Format方法传入的参数
                //return '666'; //return,格式化之后获取的新内容,return啥就替换为啥
                var temp = this.replace(/\{(\w+)\}/g,function (k,kk) {
                    // k相当于{(\w+)},kk相当于(\w+)要替换的东西,arg一般是一个字典
                    return arg[kk];
                });
                return temp;
            };
            
            $(function () {
                //发送Ajax请求,获取所有评论的信息
                //列表
                //JS生成结构
                 var token=$.cookie('csrftoken');
                 $.ajax({
                     url:"/comments-{{ article_obj.nid }}.html",
                     type:"GET",
                     dataType:"JSON",
                     success:function (arg) {
                         if (arg.status){
                             var comment=commentTree(arg.data);
                             $('#commentArea').append(comment);
                         }else{
                             alert(arg.msg);
                         }
                     }
                 })
            });
    
            //多级评论递归函数,js函数里面也有return,自己写js字符串格式化
            //pyhton中字符串的方法都是str下的,js中是String.prototype下找的
            function commentTree(commentList) {
                var comment_str="<div class='comment'>";
                $.each(commentList,function (k,row) {
                    var temp="<div class='content'>{content}</div>".Format({content:row.content});
                    comment_str += temp;
                    if (row.child.length>0){
                        comment_str += commentTree(row.child);
                    }
                });
                comment_str += '</div>';
                return comment_str
            }
    </script>
    

      

     

    转载于:https://www.cnblogs.com/wuyongqiang/p/7197851.html

    展开全文
  • 最近在模仿简书来自己写接口,简单的CRUD就不说了,直到碰到了文章的多级评论,发现怎么设计SQL都只能实现二级评论,就是在在实体类里面加上下一级评论的属性。 解决方案 多级评论其实就是一个评论下可以再被评论,...

    记录

    最近在模仿简书来自己写接口,简单的CRUD就不说了,直到碰到了文章的多级评论,发现怎么设计SQL都只能实现二级评论,就是在在实体类里面加上下一级评论的属性。

    解决方案

    多级评论其实就是一个评论下可以再被评论,那么找所有评论不就是找到最上级评论,然后遍历最上级的评论,找到每一个上级评论的下级评论,整个过程其实就是一个简单的递归。

    实现

    这是我的数据库表
    在这里插入图片描述
    comment_status是标记这个评论是不是最上级评论(0:是,1:不是),parent_id是该评论的上级评论的id。

    这是DTO对象

    /**
     * @Author: Ember
     * @Date: 2021/4/13 20:18
     * @Description: 评论
     */
    @AllArgsConstructor
    @NoArgsConstructor
    @Getter
    @Setter
    public class CommentDto {
        /**
         * 主键
         */
        private Integer id;
    
        /**
         * 评论者
         */
        private Integer accountId;
    
        /**
         * 上级评论
         */
        private Integer parentId;
    
        /**
         * 文章
         */
        private Integer blogId;
    
        /**
         * 评论内容
         */
        private String content;
    
        /**
         * 下级评论
         */
        private List<CommentDto> sons;
    
        /**
         * 发生日期
         */
        private String date;
    }
    

    设计两条SQL,一条是找最上级评论的,一条是根据上级评论来找下级评论的

        <select id="getCommentByBlogId" resultType="CommentDto" parameterType="Integer">
            SELECT bc.`blog_id` as blogId,bc.`parent_id` as parentId,bc.`id`,
            bc.`account_id` as accountId,bc.`content` as content,bc.`create_time` as date
            FROM blog_comment bc
            WHERE bc.`blog_id` = #{blogId}
            AND bc.`comment_status` = 0;
        </select>
    
        <select id="getCommentByParentId" resultType="CommentDto" parameterType="Integer">
            SELECT bc.`blog_id` as blogId,bc.`id`,bc.`account_id` AS accountId,
            bc.`content` AS content,
            bc.`create_time` AS DATE,
            bc.`parent_id` AS parentId
            FROM blog_comment bc
            WHERE bc.`parent_id` = #{parentId} AND bc.`comment_status` != 0;
        </select>
    

    Service层的递归实现

    /**
     * @Author: Ember
     * @Date: 2021/4/13 20:37
     * @Description:
     */
    @Service
    public class CommentServiceImpl implements CommentService {
    
        private CommentMapper commentMapper;
    
        @Autowired
        public void setCommentMapper(CommentMapper commentMapper) {
            this.commentMapper = commentMapper;
        }
    
        @Override
        public List<CommentDto> getAllCommentByBlogId(Integer blogId) {
            List<CommentDto> commentVos = this.commentMapper.getCommentByBlogId(blogId);
            List<CommentDto> sons = getSons(commentVos);
            return sons;
        }
    
        private List<CommentDto> getSons(Integer parentId){
            return this.commentMapper.getCommentByParentId(parentId);
        }
    
    
        private List<CommentDto> getSons(List<CommentDto> parents){
            if(parents == null || parents.size() == 0){
                return null;
            }
            for (CommentDto parent : parents) {
                int parentId = parent.getId();
                List<CommentDto> sonCommentVos = getSons(parentId);
                //递归找子评论
                parent.setSons(getSons(sonCommentVos));
            }
            return parents;
        }
    
    

    此时只要前端传回文章的唯一标识blogId即可,下面是Controller层的代码

        @GetMapping("/{blogId}")
        public BaseResult getBlogById(@PathVariable("blogId") Integer blogId){
            return DataResult.success(this.commentService.getAllCommentByBlogId(blogId));
        }
    

    使用Postman测试的结果

    {
        "code": "0",
        "msg": "success",
        "data": [
            {
                "id": 1,
                "accountId": 2,
                "parentId": 0,
                "blogId": 1,
                "content": "这是一级评论",
                "sons": [
                    {
                        "id": 2,
                        "accountId": 2,
                        "parentId": 1,
                        "blogId": 1,
                        "content": "这是二级评论",
                        "sons": [
                            {
                                "id": 5,
                                "accountId": 2,
                                "parentId": 2,
                                "blogId": 1,
                                "content": "这是三级评论",
                                "sons": [
                                    {
                                        "id": 6,
                                        "accountId": 2,
                                        "parentId": 5,
                                        "blogId": 1,
                                        "content": "这是四级评论",
                                        "sons": null,
                                        "date": "2021-04-14 16:15:21"
                                    }
                                ],
                                "date": "2021-04-14 16:14:36"
                            }
                        ],
                        "date": "2021-04-14 15:58:21"
                    },
                    {
                        "id": 3,
                        "accountId": 2,
                        "parentId": 1,
                        "blogId": 1,
                        "content": "这是二级评论",
                        "sons": null,
                        "date": "2021-04-14 16:14:02"
                    },
                    {
                        "id": 4,
                        "accountId": 2,
                        "parentId": 1,
                        "blogId": 1,
                        "content": "这是二级评论",
                        "sons": null,
                        "date": "2021-04-14 16:14:12"
                    }
                ],
                "date": "2021-04-14 15:51:48"
            }
        ]
    }
    

    反思

    思考需求如何实现时,不要只想着依靠SQL一步完成,结合算法和数据结构往往可以解决很多难以解决的问题。

    展开全文
  • 多级评论系统的设计

    2019-12-30 19:38:45
    在设计多级评论系统时,查看了很多平台和别人的设计,基本是一样: 两级评论,第一级评论“文章”、“微博”等主题Topic,第二级评论这是回复reply,针对的主体时comment。reply无限次循环。 例如简书: 例如...

    在设计多级评论系统时,查看了很多平台和别人的设计,基本是一样:

    两级评论,第一级评论“文章”、“微博”等主题Topic,第二级评论这是回复reply,针对的主体时comment。reply无限次循环。

    例如简书:

    例如头条:

    也有一种简单的灌贴逻辑。不在这里讨论。

    设计思路

    一级二级评论存放一张表,通过标记pid来区分。如果有需要提炼精选评论,可以额外扩展表结构。

    客户端/前端获取评论内容时,先查询一级评论(分页提取),然后再查询多级回复。

    【拒绝递归遍历多级评论】

    表结构

    CREATE TABLE `comment` (
      `cid` int(11) unsigned NOT NULL AUTO_INCREMENT,
      `tid` int(11) unsigned NOT NULL DEFAULT '0' COMMENT '帖子或文章ID,topic_id',
      `uid` int(11) unsigned NOT NULL DEFAULT '0' COMMENT '回复人的UID',
      `replytime` int(11) unsigned NOT NULL DEFAULT '0' COMMENT '回复时间戳',
      `content` longtext NOT NULL COMMENT '回复内容',
      `pid` int(11) DEFAULT NULL COMMENT '父节点评论,0为根节点',
      `top_id` int(11) DEFAULT '0' COMMENT '一级评论ID,0为根节点',
      PRIMARY KEY (`cid`),
      KEY `uid` (`uid`),
      KEY `tid` (`tid`)
    ) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=utf8

    数据展示

    解释

    pid : 找上级评论,二级及以下评论查询时非常有价值。

    top_id : 记录一级评论信息。用于筛选一级和非一级,并且快速查询二级及以下评论的筛选条件。

    示例

    查询一篇文章(tid=3)的第一页评论信息。

    # 一级评论
    SELECT
    	*
    FROM
    	`comment`
    WHERE
    	tid = 3
    AND pid = 0
    ORDER BY
    	replytime DESC
    limit 0, 10
    # 二级及以下评论
    SELECT
    	c.cid ,
    	c.uid ,
    	c.content ,
    	c.replytime ,
    	c.pid ,
    	c1.content AS p_content ,
    	c1.uid AS p_uid ,
    	c.top_id
    FROM
    	`comment` AS c
    LEFT JOIN `comment` AS c1 ON c.pid = c1.cid
    WHERE
    	c.tid = 3 # 帖子/文章ID
    AND c.top_id <> 0
    AND c.top_id IN(5 , 6 , 7 , 9 , 12 , 17) # 一级评论的ID
    ORDER BY
    	c.replytime

    其他

    1. 如果想要支持emoji表情,编码设置为utf8mb4,确保字段的编码格式。

    2. id 根据需求可以设置为自增 或者 uuid,不过最好设置为uuid或者其他的全局唯一ID,后面会专门补充一篇全局唯一ID的Server设计。

    3. 如果需要展示username信息,简单的可以联合user表。一级评论联合一次,二级评论需要联合两次。不过不建议这样设计。最好做数据冗余,把username放在comment表里(这里会衍生一个修改问题)。

    4. 补充衍生的用户名修改问题,对有当前用户来说,除了自己的username,谁会关心和了解别人的username是否正确。所以当前用户浏览到自己的评论信息时,只要做更新就可以了。其他的不必要换成最新的。另一个解决方案是,username更新时,异步批量更新某一个时间范围内的就行(一般行业内不会这么做)。

    实现效果

    展开全文
  • 编写多级评论思路Django-MPTT的使用安装和文档使用方法简述在项目中添加django-mptt应用编写视图、路由和前端页面添加测试数据,查看效果评论提交和其他说明Django-MPTT扩展内容参考资料编写多级评论思路多级评论...
  • Django自定义标签实现多级评论

    千次阅读 2017-10-19 22:28:35
    Django自定义标签实现多级评论
  • 三个表:users(用户表),comment(评论表),title(文章表),想要做出可以多级评论文章的效果,类似于qq空间评论,求大神指点?
  • now_add=True,verbose_name='评论时间') """多级评论需要 自关联""" parent = models.ForeignKey("Comment",related_name="pid",null=True,blank=True) def __str__(self): return self.content class Like(models....
  • Python or JavaScript 实现多级评论 Python 实现 Js 实现 转载于:https://www.cnblogs.com/hellojesson/p/6223062.html
  • Title.comment-box{margin-...}评论评论评论$(function () {bindCommentEvent();});function bindCommentEvent() {$('.com').click(function () {var news_id= $(this).attr('news_id');var _this=$(this);$.ajax(...
  • 〖Demo〗-- 多级评论

    2019-09-30 02:41:22
    多级评论】 一、 前戏: 列表添加: v1 = [1,2,3,4] v1.append(123) print(v1) data = [ [11,22,33], [44,55,66] ] data[0].append(data[1]) print(data) # data = [ # [11,22,33, ...
  • 因此最好是有某种方法可以将相关的评论聚集到一起,这时候多级评论就非常的有用了。多级评论意味着你需要将模型重新组织为树形结构。“树根”是一级评论,而众多“树叶”则是次级评论。本教程会以第三方库django-...
  • 多级评论(day86)

    2017-07-20 20:00:00
    多级评论脚本实现 # 评论列表 msg_list = [ {'id':1,'content':'xxx','parent_id':None}, {'id':2,'content':'xxx','parent_id':None}, {'id':3,'content':'xxx','parent_id':None}, {'id':4,'content':'xx...
  • 树形递归遍历实现多级评论

    千次阅读 2015-11-20 18:38:32
    最近参加了学校的网页设计大赛,做了一个论坛网站,期间后台的多级评论用了我很多时间,什么是多级评论呢,也就是针对某一条评论,其他用户都可以在该评论基础上回复对方,这样也就形成了一条树形结构,我用了递归来...
  • 因此最好是有某种方法可以将相关的评论聚集到一起,这时候多级评论就非常的有用了。 多级评论意味着你需要将模型重新组织为树形结构。“树根”是一级评论,而众多“树叶”则是次级评论。本教程会以第三方库django-...
  • 1. 建表,思路关键字段:comment_id自增id,comment_date评论时间,comment_content评论内容,t_user_id用户id,t_reply_id回复对象的用户id,t_post_id帖子id(也就是你要评价的这个信息的id,上一级主表的id),type(可能...
  • 多级评论单表结构设计

    千次阅读 多人点赞 2019-07-25 14:10:55
    这里的多级,本质上其实也就二级,例如微博的评论, 一级评论: 对微博的评论 二级评论: 对微博下的评论的回复评论 ,这里包括二种 1. 回复的是一级评论, 2, 回复的是二级评论 效果如下: 表数据: ...
  • 因此最好是有某种方法可以将相关的评论聚集到一起,这时候多级评论就非常的有用了。多级评论意味着你需要将模型重新组织为树形结构。“树根”是一级评论,而众多“树叶”则是次级评论。本教程会以第三方库django-...
  • 因此最好是有某种方法可以将相关的评论聚集到一起,这时候多级评论就非常的有用了。多级评论意味着你需要将模型重新组织为树形结构。“树根”是一级评论,而众多“树叶”则是次级评论。本教程会以第三方库django-...
  • 多级评论算法

    千次阅读 2018-02-20 18:21:51
    comment_list=models.Comment.objects.filter(news_id=new_id)ret=[] # 最终拿到的数据comment_list_dict={} # 构建的中间字典for row in comment_list: # 通过查到的数据中的id作为key,每一行数据作为value...
  • 在项目当中,碰到了使用PulltoRefreshListView来展示新闻和多级评论,在评论那里碰到了难题,如何解决多级评论的显示呢? 为了方面起见,我直接使用ListView来代替PulltoRefreshListView做示例。 废话不多说,直接...
  • 在线文档截图和链接在线文档:http://api.okayapi.com/docs.php?api=App.Market_Message主要是有两个接口,一个是发布评论接口,一个是获取评论的接口评论接口发布评论接口发布评论很简单,调用这个接口:...
  • django之评论系统及多级评论

    千次阅读 2019-05-21 08:50:54
    创建评论应用 相对来说,评论其实是另外一个比较独立的功能。Django 提倡,如果功能相对比较独立的话,最好是创建一个应用,把相应的功能代码写到这个应用里。我们的第一个应用叫 blog,它里面放了展示博客文章列表...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 457
精华内容 182
关键字:

多级评论