精华内容
下载资源
问答
  • 关键字过滤实现

    2020-09-01 13:03:29
    高效过滤,有兴趣的可以看看《Java系统性能优化》性能优化这本书,以下是书中部分代码,做个笔记 package com.golconda.tree; import java.util.HashMap; import java.util.Map; public class Node { private ...

    高效过滤,有兴趣的可以看看《Java系统性能优化》性能优化这本书,以下是书中部分代码,做个笔记

    package com.golconda.tree;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class Node {
    
    	private Map<Character, Node> nextNodes = new HashMap<>();
    
    	public void addNextNode(Character key, Node node) {
    		nextNodes.put(key, node);
    	}
    
    	public Node getNextNode(Character key) {
    		return nextNodes.get(key);
    	}
    
    	public boolean isLastCharacter() {
    		return nextNodes.isEmpty();
    	}
    
    	public Map<Character, Node> getNextNodes() {
    		return nextNodes;
    	}
    
    	public void setNextNodes(Map<Character, Node> nextNodes) {
    		this.nextNodes = nextNodes;
    	}
    
    	@Override
    	public int hashCode() {
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + ((nextNodes == null) ? 0 : nextNodes.hashCode());
    		return result;
    	}
    
    	@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Node other = (Node) obj;
    		if (nextNodes == null) {
    			if (other.nextNodes != null)
    				return false;
    		} else if (!nextNodes.equals(other.nextNodes))
    			return false;
    		return true;
    	}
    }
    
    
    package com.golconda.tree;
    
    import com.alibaba.fastjson.JSON;
    
    public class KeywordSearch {
    	static Node root = new Node();
    	String sensitiveWords = "***";
    
    	public void addWord(String word) {
    
    		Node tempNode = root;
    		for (int i = 0; i < word.length(); i++) {
    			Character c = word.charAt(i);
    			Node node = tempNode.getNextNode(c);
    			if (node == null) {
    				node = new Node();
    				tempNode.addNextNode(c, node);
    			}
    			// 移动到下一个字
    			tempNode = node;
    
    
    		}
    	}
    
    	public String filter(String text) {
    		StringBuilder result = new StringBuilder(text.length());
    		Node tempNode = root;
    		int begin = 0;
    		int position = 0;
    		while (position < text.length()) {
    
    			Character c = text.charAt(position);
    			tempNode = tempNode.getNextNode(c);
    
    			if (tempNode == null) {
    				如果匹配失败,合法
    				result.append(text.charAt(begin));
    				begin = begin + 1;
    				position = begin;
    				//从新匹配
    				tempNode = root;
    				continue;
    			} else if (tempNode.isLastCharacter()) {
    				//匹配结束,替换敏感词
    				result.append(sensitiveWords);
    				position++;
    				begin = position;
    				tempNode = root;
    			} else {
    				position++;
    			}
    
    		}
    		//添加剩下的内容
    		result.append(text.substring(begin));
    		return result.toString();
    	}
    
    	public static void main(String[] args) {
    		KeywordSearch ts = new KeywordSearch();
    		ts.addWord("猪狗");
    		ts.addWord("小猫");
    		ts.addWord("天气预报");
    		
    		System.out.println(JSON.toJSONString(root.getNextNodes()));
    		String ret = ts.filter("你好,小猫");
    		System.out.println(ret);
    
    	}
    }
    
    
    展开全文
  • 为了防不法份子的各种非法信息的传播,网安对各种关键字实现过滤(枪zhi、六合cai、 公安bu等关键字),导致了你的整个网站被关闭在此背景下,为了方便广大合法网站的管理,非法关键字过滤器的这个软件诞生了主要功能:...
  • C# 撒列实现关键字过滤的实例,需要的朋友可以参考一下
  • 这个效果是直接筛选过滤 不是带有点击搜索按钮的那种撒 直接筛选 效果图 代码 !<template> <div class="main"> <input type="text" v-model="btnsearch" placeholder="请输入" /> <br />...

    参考链接哦
    这个效果是直接筛选过滤 不是带有点击搜索按钮的那种撒

    直接筛选

    效果图

    请添加图片描述

    代码

    !<template>
      <div class="main">
        <input type="text" v-model="btnsearch" placeholder="请输入" />
        <br />
        <div v-for="(item,index) in searlist" :key="index">
          <div>{{item.name}}</div>
        </div>
      </div>
    </template>
    
    <script>
    export default {
      data() {
        return {
          btnsearch: "",
          list: []
        };
      },
      created() {
        this.loadData()
      },
      computed:{
        searlist(){
          if(!this.btnsearch){
           return this.list
          }
          return this.list.filter(item=>{
            return item.name.includes(this.btnsearch)
          })
          return data
        }
      },
      methods: {
        loadData(){
          this.list = [
            { icon: 'el-icon-delete', name: 'el-icon-delete' },
            { icon: 'el-icon-setting', name: 'el-icon-setting' },
            { icon: 'el-icon-user', name: 'el-icon-user' },
            { icon: 'el-icon-star-off', name: 'el-icon-star-off' },
            { icon: 'el-icon-picture-outline', name: 'el-icon-picture-outline' },
            { icon: 'el-icon-s-custom', name: 'el-icon-s-custom' },
            { icon: 'el-icon-edit', name: 'el-icon-edit' },
            { icon: 'el-icon-folder-opened', name: 'el-icon-folder-opened' },
            { icon: 'el-icon-chat-dot-round', name: 'el-icon-chat-dot-round' },
            { icon: 'el-icon-upload', name: 'el-icon-upload' },
            { icon: 'el-icon-message-solid', name: 'el-icon-message-solid' }
          ]
        }
      }
    };
    </script>
    
    <style>
    </style>
    

    带搜索筛选

    !<template>
      <div>
        <div>
          <input type="text" placeholder="输入" v-model="search" />
          <span @click="btnclick">点击</span>
        </div>
        <div v-for="(item,index) in newListData" :key="index">{{item.orgName}}</div>
      </div>
    </template>
    <script>
    export default {
      data() {
        return {
          search: "",
          list: [
            {
              tenantId: 36045,
              orgId: 3604500002,
              orgName: "开发环境测试-1",
              type: null,
              activate: "1"
            },
            {
              tenantId: 36053,
              orgId: 3605300001,
              orgName: "52-测试账号(校区)",
              type: null,
              activate: "1"
            },
            {
              tenantId: 36053,
              orgId: 3605300008,
              orgName: "测试-",
              type: null,
              activate: "1"
            }
          ],
          newListData: []
        };
      },
      created() {
        this.newListData = this.list;
      },
      watch: {
        search(curr, old) {
          if (curr == "") {
            this.newListData = this.list;
          }
        }
      },
      methods: {
        btnclick() {
          if (this.search) {
            this.$nextTick(() => {
              this.newListData = this.list.filter(
                item => item.orgName.indexOf(this.search.toLowerCase()) !== -1
              );
            });
          }
        }
      }
    };
    </script>
    
    <style>
    </style>
    

    如果这样写在初始化的时候,数据不过来,在你定义过滤数组的重新接收一下你的接口
    在这里插入图片描述

    参考

    展开全文
  • asp实现过滤关键字的函数
  • JavaScript屏蔽关键字,大概的思路就是去用javascript去替换已有的文本,达到替换的目的
  • 在这篇文章里,我们来针对一些问题进行讨论。如果您觉得有哪些您感兴趣但是没有涉及到的问题则请在评论中补充,...一个较完整的关键字过滤解决方案(下) 转载于:https://my.oschina.net/abcijkxyz/blog/721249

    在这篇文章里,我们来针对一些问题进行讨论。如果您觉得有哪些您感兴趣但是没有涉及到的问题则请在评论中补充,我会修改文章添加一下内容。

    陷阱何在?

    首先,我们来分析上一篇文章最后谈到的“陷阱”。很可惜啊,过了两个星期还是没有朋友能够指出这个问题,其实很简单,运行一下就能发觉有异常抛出:

    public partial class Default : System.Web.UI.Page, IForbiddenWordFilter
    {
        ...
    
        FilterForbiddenWordType IForbiddenWordFilter.GetFilterType(string key)
        {
            if (key.EndsWith(this.txtPassword.ID)) return FilterForbiddenWordType.Ignored;
            return FilterForbiddenWordType.Normal;
        }
    }

    在运行至this.txtPassword.ID时会抛出NullReferenceException。其原因就是,我们的FilterForbiddenWordModule在OnPostMapRequestHandler过程中进行调用,而此时Handler对象已经生成(意味着IForbiddenWordFilter.GetFilterType方法已经可以调用),但是直到Handler被执行时this.txtPassword才被实例化(从现象得出的结论,是否确切有待考证),自然会抛出NullReferenceException了。可是我实在想不出一个办法可以在得到this.txtPassword.ID的值,甚至退一步讲,我无法在运行时得到this.txtPassword这个field的名称——即一个字符串“txtPassword”。我不可能直接使用这个字符串常量,这样就会使我们的改进效果付之东流。我们需要通过代码来访问,因为我们需要能够得到编译及重构的支持,不是吗?

    起初我很绝望,但是10分钟后忽然灵光一闪,想到了这种方式来获得field的名称:

    FilterForbiddenWordType IForbiddenWordFilter.GetFilterType(string key)
    {
        Expression<Func<object>> action = () => this.txtPassword;
        var name = (action.Body as MemberExpression).Member.Name;
    
        if (key.EndsWith(name)) return FilterForbiddenWordType.Ignored;
        return FilterForbiddenWordType.Normal;
    }

    这是一个非常实用的技巧:通过Lambda表达式来构造一个表达式树,然后通过这个表达式树的成员来获取field的名称。我们享受到了我们所需的便利,因为个中实现已经由编译器完成(或许我会另写文章来阐述一下我在关于这个方面的思维过程)。

    适用场合

    有的时候我觉得谈适用场合比较虚,因为其实关键是在“思考”。“官方”提出的适用场合并不一定完整和正确,了解了一个解决方案之后慢慢会有更好的体会,甚至更真实。如果一个解决方案是通过一个适用场合引发的,那么这个解决方案的适用场合“似乎”不言而喻。此外,如果一个解决方案是像我们现在的这样一样,从实际出发,再发散,慢慢将功能补充完整,最后几经权衡之后反而有些违背初衷,那么谈适用场合其实就是在谈“理解”,当你理解了这个解决方案的特性,适用场合和不适用场合都可以简单地判断出来。所以再虚还是要谈,至少要摆个样子思考一下。

    例如:我们是在输入的时候进行过滤,那么服务器端得到的数据已经是替换后的内容,因此如果你要用户原本输入的内容,肯定就不能采用这个方法。

    嗯?完了?当然没完,但是下面就要由您来进行思考了。:)

    输入过滤和输出过滤

    关于这个问题,讨论得纠结啊。我们现在整理一下输入过滤和输出过滤的优点和缺点(欢迎补充):

    输入过滤:

    • 优点:
      • 在输入时控制,需要替换的次数少,性能高。
      • 可控制的粒度小,方便地对于输入定制各种过滤方式。
    • 缺点:
      • 解决方案相对不够普适,有时需要为不同的Handler定制不同替换策略,虽然这点很简单。
      • 无法获得用户原始输入。

    输出过滤:

    • 优点:
      • 普适,Plug & Play,过滤一切输出。
      • 可以保留用户原始输入。
    • 缺点:
      • 每次输出都需要替换,性能低下。 

    可以发现,基本上输出缓存是在实用性能换取绝对透明、以及。有朋友说某些场景下只能使用输出缓存,不该把它一棒子打死——但是至少也要打个半死不活。原因就在于这个性能问题实在过于难以处理了。

    首先是输出过滤时在每次生成HTML时都要对完整的字符串进行替换,首先HTML中大部分的字符是不用替换的(因为是我们自定义的文字或HTML代码),其次每秒过滤数百次大字符串是一个很伤CPU运算的做法——无论在哪个平台下。而避免大量运算的常用手段就是将运算结果保留起来并多次使用。这就是所谓的缓存,可惜……

    输出过滤难以缓存。这一点不是因为实现困难而放弃,而是实在是没有好的办法进行缓存。输出过滤往往使用Response.Filter,它的最小单位是“一个Response”,因此我们传统缓存机制中唯一可用的可能只有整页静态化了(连局部内容缓存都无法生效)。现在的Web应用大都“变化多端”,整页静态的适用程度愈发有限,这是由于整页缓存难以设过期依赖,一是依赖项过多,页面所表现的业务中任何一个数据的变化都会造成整页修改,这种业务与页面之间多对多的关系使维度急剧增加,难以操作。再者就是这样的缓存依赖项往往要打通表现层和业务逻辑层甚至数据访问层,在一个设计良好的系统里不能出现这样的状况。

    当然输出缓存既然有优点,我们可能也就需要想一些办法来缓解一部分问题。思路就是使用比Response粒度低的输出过滤。例如在CRUD的R方法上做文章,这样内容缓存就变成了数据缓存(关于这两种缓存的优劣我在《输出缓存与CachePanel》一文中有过简单讨论)。如果页面中需要替换的内容部分变化不多,也可以使用一个简单的带有过滤功能的CachePanel来进行此部分工作。但我思考了很久,还是觉得不容易。不知哪位朋友会有更好的想法,只希望能有个确实的示例或说明,而不要简单的一句话思路,似乎有道理却让人无从考究。

    如果真要保留用户原始输入,其实我认为最恰当的方式是保留原始拷贝——当然这也很麻烦。弟兄们还是权衡为上。

    我们真的需要HttpModule吗?

    第一篇文章里我就说了,全站级别的操作,往往解决方案只有一个,那就是HttpModule——其实这句话补充完整应该是:在使用统一模型的解决方案中,可以使用横切的方式来为该模型的数据输入作统一处理。换句话说,假如我们整站都使用了一个统一的自定义模型,那么我们自然可以在这个模型上做文章。如果没有这样的(自定义)模型,那么我们能找到的唯一共同之处就只有“ASP.NET网站”这一点了。此时针对这一模型的横切方式,自然就是HttpModule。

    那么我们可能还会有哪些模型呢?至少我们现在已经有一个了:那就是ASP.NET MVC。ASP.NET MVC改变了之前开发ASP.NET站点的理念,它统一了服务器端对于客户端请求处理方式,将请求与方法进行了映射。如果说在使用ASP.NET WebForms时不可避免的需要编写Generic Handler(ashx)来进行非页面的请求处理,那么在ASP.NET MVC中也应该使用同样的Controller-Action方式——如果还出现ashx的话,您就要思考一下这么做的合理性了。好,既然我们将全站统一至ASP.NET MVC模型之上,则接下来要做的就是在它的数据输入方式上做文章了。ASP.NET MVC使用一个名为Model Binder的机制将Request中的数据转化为Action方法的参数。如果我们使用一个自定义的Model Binder,参数构造时进行文字过滤,自然也可以满足我们的要求。

    性能

    全站替换从感觉上似乎会影响性能,但是细想之下,并没有带来多大损害,因为“需要过滤的地方”它“总归要被过滤”嘛。但是一些措施可能还是需要的:例如在GET请求时不替换Form里的数据(其实本就应该没有数据)、对Handler做合适标记(尽可能减少需要过滤的内容)、在没有替换任何内容时不更新原有集合(减少折腾次数),亦或是Filter on Demand(只在读取某字段时替换内容)。

    最后,其实最影响性能的可能就是过滤算法了——这本不该在文章中出现,但是我还是想提一下。字符串操作往往是系统的命门,处理不好会因此大量字符串的产生,加大GC压力,因此StringBuilder自然是不可少的。还有关键的一点是String的Replace方法绝对不可以使用,因为需要过滤的关键字往往不在少数,使用Replace方法会在内存中出现大量的字符串。更进一步,假如有N个关键字,需要过滤一个长度为M的字符串,那么使用Replace方法的时间复杂度至少是O(M * N);而如果换种方式,例如使用前缀树构造一个索引,实现复杂度最多也就是O(M * H)了——H为树的高度,比N要小许许多多,而且与N的数量无关。

    关于这一点,第一篇文章一开始引用的两篇文章中方式大体是正确的,值得参考。

    相关文章

    转载于:https://my.oschina.net/abcijkxyz/blog/721249

    展开全文
  • 网络开始了新一轮的严打,为了防不法份子的各种非法信息的传播,网安对各种关键字实现过滤(枪zhi、六合cai、 公安bu等关键字),导致了你的整个网站被关闭,在此背景下,为了方便广大合法网站的管理,非法关键字过滤器...
  • 内容索引:VB源码,网络相关,关键字,网址过滤 关键字网址过滤工具,也就是可以自已定义需要过滤的网址中所包含的关键字,存为一个HTML格式的列表文件,打开程序时,读取此列表,若IE打开的窗口地址中包含了列表中禁止...
  • Flink SQL 实战 (4):使用自定义函数实现关键字过滤统计 在上一篇实战博客中使用POJO Schema解析来自 Kafka 的 JSON 数据源并且使用自定义函数处理。 现在我们使用更强大自定义函数处理数据 使用自定义函数实现...

    Flink SQL 实战 (5):使用自定义函数实现关键字过滤统计

    在上一篇实战博客中使用POJO Schema解析来自 Kafka 的 JSON 数据源并且使用自定义函数处理。

    现在我们使用更强大自定义函数处理数据

    使用自定义函数实现关键字过滤统计

    自定义表函数(UDTF)

    与自定义的标量函数相似,自定义表函数将零,一个或多个标量值作为输入参数。 但是,与标量函数相比,它可以返回任意数量的行作为输出,而不是单个值。

    为了定义表函数,必须扩展基类TableFunction并实现评估方法。 表函数的行为由其评估方法确定。 必须将评估方法声明为公开并命名为eval。 通过实现多个名为eval的方法,可以重载TableFunction。 评估方法的参数类型确定表函数的所有有效参数。 返回表的类型由TableFunction的通用类型确定。 评估方法使用 collect(T)方法发出输出行。

    定义一个过滤字符串 记下关键字 的自定义表函数

    KyeWordCount.java:

    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.table.functions.TableFunction;
    
    public class KyeWordCount extends TableFunction<Tuple2<String,Integer>> {
        private String[] keys;
        public KyeWordCount(String[] keys){
            this.keys=keys;
        }
        public void eval(String in){
            for (String key:keys){
                if (in.contains(key)){
                    collect(new Tuple2<String, Integer>(key,1));
                }
            }
        }
    }
    

    实现关键字过滤统计:

    public class UdtfJob {
        public static void main(String[] args) throws Exception {
            StreamExecutionEnvironment streamEnv = StreamExecutionEnvironment.getExecutionEnvironment();
            EnvironmentSettings streamSettings = EnvironmentSettings.newInstance().useBlinkPlanner().inStreamingMode().build();
            StreamTableEnvironment streamTabelEnv = StreamTableEnvironment.create(streamEnv, streamSettings);
            KafkaTabelSource kafkaTabelSource = new KafkaTabelSource();
            streamTabelEnv.registerTableSource("kafkaDataStream", kafkaTabelSource);//使用自定义TableSource
            //注册自定义函数定义三个关键字:"KeyWord","WARNING","illegal"
            streamTabelEnv.registerFunction("CountKEY", new KyeWordCount(new String[]{"KeyWord","WARNING","illegal"}));
            //编写SQL
            Table wordWithCount = streamTabelEnv.sqlQuery("SELECT key,COUNT(countv) AS countsum FROM kafkaDataStream LEFT JOIN LATERAL TABLE(CountKEY(response)) as T(key, countv) ON TRUE GROUP BY key");
            //直接输出Retract流
            streamTabelEnv.toRetractStream(wordWithCount, Row.class).print();
            streamTabelEnv.execute("BLINK STREAMING QUERY");
        }
    }
    

    测试用Python脚本如下

    # https://pypi.org/project/kafka-python/
    import pickle
    import time
    import json
    from kafka import KafkaProducer
    
    producer = KafkaProducer(bootstrap_servers=['127.0.0.1:9092'],
                             key_serializer=lambda k: pickle.dumps(k),
                             value_serializer=lambda v: pickle.dumps(v))
    start_time = time.time()
    for i in range(0, 10000):
        print('------{}---------'.format(i))
        producer = KafkaProducer(value_serializer=lambda v: json.dumps(v).encode('utf-8'),compression_type='gzip')
        producer.send('test',{"response":"resKeyWordWARNINGillegal","status":0,"protocol":"protocol","timestamp":0})
        producer.send('test',{"response":"resKeyWordWARNINGillegal","status":1,"protocol":"protocol","timestamp":0})
        producer.send('test',{"response":"resresKeyWordWARNING","status":2,"protocol":"protocol","timestamp":0})
        producer.send('test',{"response":"resKeyWord","status":3,"protocol":"protocol","timestamp":0})
        producer.send('test',{"response":"res","status":4,"protocol":"protocol","timestamp":0})
        producer.send('test',{"response":"res","status":5,"protocol":"protocol","timestamp":0})
    #    future = producer.send('test', key='num', value=i, partition=0)
    # 将缓冲区的全部消息push到broker当中
    producer.flush()
    producer.close()
    
    end_time = time.time()
    time_counts = end_time - start_time
    print(time_counts)
    

    控制台输出:

    ...
    6> (false,KeyWord,157)
    3> (false,WARNING,119)
    3> (true,WARNING,120)
    6> (true,KeyWord,158)
    7> (true,illegal,80)
    6> (false,KeyWord,158)
    6> (true,KeyWord,159)
    6> (false,KeyWord,159)
    6> (true,KeyWord,160)
    ...
    

    自定义聚合函数

    自定义聚合函数(UDAGGs)将一个表聚合为一个标量值。

    在这里插入图片描述

    聚合函数适合用于累计的工作,上面的图显示了聚合的一个示例。假设您有一个包含饮料数据的表。该表由三列组成:id、name和price,共计5行。想象一下,你需要找到所有饮料的最高价格。执行max()聚合。您需要检查5行中的每一行,结果将是单个数值。

    用户定义的聚合函数是通过扩展AggregateFunction类来实现的。AggregateFunction的工作原理如下。首先,它需要一个累加器,这个累加器是保存聚合中间结果的数据结构。通过调用AggregateFunction的createAccumulator()方法来创建一个空的累加器。随后,对每个输入行调用该函数的accumulator()方法来更新累加器。处理完所有行之后,将调用函数的getValue()方法来计算并返回最终结果。

    **每个AggregateFunction必须使用以下方法: **

    • createAccumulator()创建一个空的累加器
    • accumulate()更新累加器
    • getValue()计算并返回最终结果

    除了上述方法之外,还有一些可选方法。虽然其中一些方法允许系统更有效地执行查询,但是对于某些用例是必需的。例如,如果应该在会话组窗口的上下文中应用聚合函数,那么merge()方法是必需的(当观察到连接它们的行时,需要连接两个会话窗口的累加器。

    AggregateFunction可选方法

    • retract() 定义restract:减少Accumulator ,对于在有界窗口上的聚合是必需的。
    • merge() merge多个Accumulator , 对于许多批处理聚合和会话窗口聚合都是必需的。
    • resetAccumulator() 重置Accumulator ,对于许多批处理聚合都是必需的。
    使用聚合函数聚合最大的status值

    编写自定义聚合函数,用于聚合出最大的status

    public class MaxStatus extends AggregateFunction<Integer,MaxStatus.StatusACC> {
        @Override
        public Integer getValue(StatusACC statusACC) {
            return statusACC.maxStatus;
        }
    
        @Override
        public StatusACC createAccumulator() {
            return new StatusACC();
        }
        public void accumulate(StatusACC statusACC,int status){
            if (status>statusACC.maxStatus){
                statusACC.maxStatus=status;
            }
        }
        public static class StatusACC{
            public int maxStatus=0;
        }
    }
    

    mian函数修改注册和SQL就可以使用

    /**
     *聚合最大的status
     */
    streamTabelEnv.registerFunction("maxStatus",new MaxStatus());
    Table wordWithCount = streamTabelEnv.sqlQuery("SELECT maxStatus(status) AS maxStatus FROM kafkaDataStream");
    

    使用之前的python脚本测试

    控制台输出(全部):

    5> (false,1)
    8> (true,3)
    3> (false,0)
    4> (true,1)
    6> (true,2)
    2> (true,0)
    2> (true,4)
    1> (false,3)
    7> (false,2)
    3> (false,4)
    4> (true,5)
    

    除非输入更大的Status,否则控制台不会继续输出新结果

    表聚合函数

    用户定义的表聚合函数(UDTAGGs)将一个表(具有一个或多个属性的一个或多个行)聚合到具有多行和多列的结果表。

    和聚合函数几乎一致,有需求的朋友可以参考官方文档

    Table Aggregation Functions

    GitHub

    项目源码已上传至GitHub

    https://github.com/StarPlatinumStudio/Flink-SQL-Practice

    我的专栏:Flink SQL原理和实战

    To Be Continue=>

    展开全文
  • 为了考虑到区分不出哪些是正则表达式,哪些是过滤条件,先过滤一部分: 测试:echo '{"code":200,"message":"操作成功","data":' | sed 's/^.*code//g' | sed 's/message.*$//g' 执行上述语句,过滤结果是:":200," ...
  • 主要为大家详细介绍了angluarjs实现过滤并替换关键字小功能,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • <tbody> <!--之前,v-for中的数据,都是直接从data上的list中直接渲染过来的-->...--现在,我们自定义一个search方法,同时把所有关键字通过传参的形式,传递给了search方法--> <!--在search方...
  • JAVA 关键字、敏感字 屏蔽过滤功能实现

    万次阅读 多人点赞 2019-07-30 19:36:33
    文档内容格式: 直接上代码(检索敏感词算法是从网上搜集参考的,有想法的可以搜索DFA算法研究下): SensitiveFilterService.java /** * @Author : JCccc * @CreateTime : 2019/7/30 * @Description : 敏感词过滤器...
  • 可以通过选择文件目录 输入文件名关键字过滤文件 并移动到指定目录 实现批量的文件移动减少重复以及容易
  • java 关键字过滤

    千次阅读 2012-05-24 17:20:06
    以下实现关键字过滤: 两个个文件words.properties和KeyFilter.java; 1、words.properties配置关键字的配置文件;内容如下: name1 name2 name3 2、KeyFilter.java: import java.io.IOException; ...
  • <... 搜索名称关键字: <input type = "text" v-model = "keywords"> </label> <tbody> <tr v-for = "item in search(keywords)"> <td>{{item.id}}</td>...
  • 关键字过滤 效率够快

    2013-05-07 10:08:13
    通过关键字文本 构建关键字库 利用算法实现过滤 所有效率很快
  • 前面介绍了列表操作中的数据新增、删除的功能,本篇章来看看关键字查询的功能。 处理步骤 在VM实例中定义关键字参数searchName. var vm = new Vue({ el: '#app', data: { searchName:'', // 关键字 .....
  • 【方法】我们从技术的角度来看到这个问题,实现一个功能后者说实现一个需求,其方法是多种多样的,重点是找到适合我们当下产品的;比如:我们可以在后端进行数据处理之后,传递到前端;也可以在前端进行数据处理;...
  • 这是项目中用到的,可以实现LookUp的ComBox. 大家一起分享一下。
  • 最近做了一个日志搜索的需求,要在页面上实现海量日志的关键字搜索。为了搜索更清晰,我最终实现了多条件搜索,且搜索结果的记录中的关键字全部高亮。 一、实现思路 1 实时监控表格,实现关键字的定位; 2 点击搜索...
  • 敏感词、文字过滤是一个网站必不可少的功能,本篇文章主要介绍了Java实现敏感词过滤实例,具有一定的参考价值,有需要的可以了解一下。
  • 本篇文章主要介绍了PHP屏蔽关键字实现方法,具有一定的参考价值,有需要的可以了解一下。
  • 关键字过滤

    2013-08-27 15:18:27
    这个东西不难,简单的实现就可以很快的写出,比如基本的strstr,或者KMP算法。这类基本的方法都需要关键词的逐个比较。效率比较低,这里选用基于关键字hash的方法来加快查找的效率。 先建立关键字hash树,对每个...
  • jQuery实现网页关键字过滤效果,将需要过滤的文字定义在JavaScript中,可定义多个,不过要修改JS代码为数组,这样可过滤出多个不同的关键字,本例只是为你演示一个基本的功能,更多过滤功能请自己挖掘吧。...
  • 例如论坛中的关键字过滤,一般情况下需过滤的关键字数量及检测的文本长度都不大,所以这一瞬间的过程没有太多值得关注的地方。但若关键字数量不在是屈指可数,而是有成千上万, 并且待检测的文本也是一长篇大论,...
  • 数组过滤的方法最常用的就是filter,那首先先说一下filter语法:arr.filter((item,index,arr) => { return 条件});作用:遍历数组arr,返回满足条件的所有制,放到一个新的数组中参数:item 数组的每一项,index ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 116,684
精华内容 46,673
关键字:

关键字过滤如何实现