All posts by 龙生

浅谈编程范式

| 前言 相信绝大部分开发人员、DBA都听过范式这个词，在MySQL中有第一范式、第二范式、第三范式、BCNF范式等，在开发中也有相应的范式，专业词汇叫编程范式(ProgrammingParadigm)。由于笔者能力、精力都有限，本篇主要通过针对同一业务场景，基于编程范式的概念，核心原理以及用例实现来对比不同范式及其实现业务功能的差异。 范式分类 如图1所示，范式可以简单分为三类: 图1: 范式的简单分类   范式和语言的关系 图2: 范式和语言的关系   与成百种编程语言相比，编程范式要少得多，如图2所示，共有27种范式。多数范式之间仅相差一个或几个概念，比如图中的函数编程范式，在加入了状态（state）之后就变成了面向对象编程范式。   | 编程范式 图3: 华山派剑气之争 过程式编程的核心在于模块化，在实现过程中使用了状态，依赖了外部变量，导致很容易影响附近的代码，可读性较少，后期的维护成本也较高。 函数式编程的核心在于“避免副作用”，不改变也不依赖当前函数外的数据。结合不可变数据、函数是第一等公民等特性，使函数带有自描述性，可读性较高。 面向对象编程的核心在于抽象，提供清晰的对象边界。结合封装、集成、多态特性，降低了代码的耦合度，提升了系统的可维护性。 不同的范式的出现，目的就是为了应对不同的场景，但最终的目标都是提高生产力。就如华山派的剑宗、气宗之别，剑宗认为“剑为主，气为辅”，而气宗则反之。每个范式都会有自己的”心法”，但最终殊途同归，达到至高境界后则是剑气双修。   | 小结 阅读完之前内容后，相信各位读者对编程范式有了初步的理解，那么接下来就和笔者一起来实现业务的真实需求。   | 需求  1.解析并收集shannon, fio 两种 flash卡的温度、寿命等信息。  2.对实现代码进行单元测试 在用过程式实现之前，笔者先给大家介绍下什么叫过程式编程。   | 过程式编程(Procedural) 过程式编程和面向对象编程的区别并不在于是否使用函数或者类，也就是说用到类或对象的可能是过程式编程，只用函数而没有类的也可能是面向对象编程。那么他们的区别又在哪儿呢？ 面向过程其实是最为实际的一种思考方式，可以说面向过程是一种基础的方法，它考虑的是实际地实现。一般的面向过程是从上往下步步求精，所以面向过程最重要的是模块化的思想方法。当程序规模不是很大时，面向过程的方法还会体现出一种优势。因为程序的流程很清楚，按着模块与函数的方法可以很好的组织。 关键部分实现代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
def get_shannon_info(output):
    """获取shannon类型flash卡信息
    """
    def check_health():
        time_left = float(sub_info["life_left"])
        if time_left < DISK_ALARM_LIFETIME:
            message = "time left is less than {}%".format(DISK_ALARM_LIFETIME)
            return message
        temperature = float(sub_info["temperature"].split()[0])
        if temperature > DISK_ALARM_TEMPERATURE:
            message = "temperature is over than {} C".format(DISK_ALARM_TEMPERATURE)
            return message
        return "healthy"
    result = {}
    all_info = _get_shannon_info(output)
    for info in all_info:
        sub_info = {}
        sub_info["available_capacity"] = info.get("disk_capacity", "")
        sub_info["device_name"] = info.get("block_device_node", "")
        sub_info["firmware_version"] = info.get("firmware_version", "")
        sub_info["interface"] = "PCIe"
        sub_info["life_left"] = str(info.get("estimated_life_left", "").replace("%", ""))
        sub_info["pcie_id"] = info.get("pci_deviceid", "")
        sub_info["pcie_length"] = ""
        sub_info["pcie_type"] = ""
        sub_info["physical_read"] = info.get("host_read_data", "")
        sub_info["physical_write"] = info.get("total_write_data", "")
        sub_info["serial_number"] = info.get("serial_number")
        sub_info["temperature"] = info.get("controller_temperature")
        sub_info["type"] = info["type"]
        sub_info["error_msg"] = check_health()
        sub_info["status"] = "ok" if sub_info["error_msg"] == "healthy" else "error"
        if sub_info["serial_number"]:
            result[sub_info["serial_number"]] = sub_info
        else:
            result[sub_info["device_name"]] = sub_info
    return result

代码问题 1.逻辑冗长，局部修改必须阅读整段代码 2.对外部变量有依赖 3.内部存在共享变量 4.函数内部存在临时变量 测试代码 过程式的测试代码效果远不如函数式有效，过程式的实现逻辑过于冗长，导致测试效果并不够好。   | 函数式编程(Functional) 当谈论函数式编程，会提到非常多的“函数式”特性。提到不可变数据，第一类对象以及尾调用优化，这些是帮助函数式编程的语言特征。提到mapping（映射），reducing（归纳），piplining（管道），recursing（递归），currying（科里化），以及高阶函数的使用，这些是用来写函数式代码的编程技术。提到并行，惰性计算以及确定性，这些是有利于函数式编程的属性。 最主要的原则是避免副作用，它不会依赖也不会改变当前函数以外的数据。 声明式的函数，让开发者只需要表达 “想要做什么”，而不需要表达 “怎么去做”，这样就极大地简化了开发者的工作。至于具体 “怎么去做”，让专门的任务协调框架去实现，这个框架可以灵活地分配工作给不同的核、不同的计算机，而开发者不必关心框架背后发生了什么。 关键部分实现代码

1
2
3
4
5
6
7
8
9
10
11
12
def get_shannon_info(output):
    """查询shannon类型flash卡信息
    """
    lines = checks_string_split_by_function(output, is_shannon_flash_device)
    info = map(parser_shannon_info, lines)
    # map(lambda x: x.setdefault("type", "shannon"), info)
    for item in info:
        item["type"] = "shannon"
    data = map(modify_the_properties, info)
    return reduce(combining_data, map(convert_data_format, data))

  以上代码带有自描述性，通过函数名就可知在做什么，这也是函数式的一个特性: 代码是在描述要干什么，而不是怎么干。 测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
@pytest.mark.parametrize("line, result", [
("Found Shannon PCIE", False),
("Found Shannon PCIE Flash car", False),
("Found Shannon PCIE Flash card a", True),
("Found Shannon PCIE Flash card", True),
("Found Shannon PCIE Flash card.", True),
])
def test_is_shannon_flash_device(line, result):
    assert functional.is_shannon_flash_device(line) == result
@pytest.mark.parametrize("line, result", [
("a=1", True),
("b=2", True),
("c=2333", True),
("d x=abcde", True),
("Found Shannon PCIE=1", True),
("abcdedfew=", False),
("Found Shannon PCIE", False),
(" =Found Shannon PCIE", False),
("=Found Shannon PCIE", False),
("Found Shannon PCIE=", False),
("Found Shannon PCIE= ", False),
])
def test_is_effective_value(line, result):
    assert functional.is_effective_value(line) == result
@pytest.mark.parametrize("line, result", [
("a=1", {"a": "1"}),
("b=2", {"b": "2"}),
("a=a", {"a": "a"}),
("abc=a", {"abc": "a"}),
("abc=abcde", {"abc": "abcde"}),
])
def test_gets_the_index_name_and_value(line, result):
    assert functional.gets_the_index_name_and_value(line) == result
@pytest.mark.parametrize("output, filter_func, result", [
("abcd\nbcd\nabcd\nbcd\naa\naa", lambda x: "a" in x, ["abcd\nbcd", "abcd\nbcd", "aa", "aa"]),
(open(os.path.join(project_path, "fixtures", "shannon-status.txt")).read(), functional.is_shannon_flash_device, [
    open(os.path.join(project_path, "fixtures", "shannon-sctb.txt")).read(),
    open(os.path.join(project_path, "fixtures", "shannon-scta.txt")).read()
])
])
def test_checks_string_split_by_function(output, filter_func, result):
    assert functional.checks_string_split_by_function(output, filter_func) == result

  | 面向对象编程(Object-Oriented) 并不是使用类才是面向对象编程。如果你专注于状态改变和密封抽象，你就是在用面向对象编程。类只是帮助简化面向对象编程的工具，并不是面向对象编程的要求或指示器。封装是一个过程，它分隔构成抽象的结构和行为的元素。封装的作用是分离抽象的概念接口及其实现。类只是帮助简化面向对象编程的工具，并不是面向对象编程的要求或指示器。 随着系统越来越复杂，系统就会变得越来越容易崩溃，分而治之，解决复杂性的技巧。面对对象思想的产生是为了让你能更方便的理解代码。有了那些封装，多态，继承，能让你专注于部分功能，而不需要了解全局。 关键部分实现代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
class IFlash(six.with_metaclass(abc.ABCMeta)):
    def __init__(self):
        pass
    @abc.abstractmethod
    def collect(self):
        """收集flash卡物理信息
        """
        pass
class FlashShannon(IFlash):
    """宝存的Flash卡
    """
    def __init__(self, txt_path, command, printer):
        super(FlashShannon, self).__init__()
        self.txt_path = txt_path
        self.command = command
        self.printer = printer
    def collect(self):
        result = {}
        for info in self._get_shannon_info():
            life_left = str(info.get("estimated_life_left", "")).replace("%", "")
            temperature = info.get("controller_temperature", "")
            error_msg = self._get_health_message(life_left, temperature)
            sub_info = {
                "available_capacity": info.get("disk_capacity", ""),
                "device_name": info.get("block_device_node", ""),
                "firmware_version": info.get("firmware_version", ""),
                "interface": "PCIe",
                "life_left": life_left,
                "pcie_id": info.get("pci_deviceid", ""),
                "pcie_length": "",
                "pcie_type": "",
                "physical_read": info.get("host_read_data", ""),
                "physical_write": info.get("total_write_data", ""),
                "serial_number": info.get("serial_number", ""),
                "temperature": temperature,
                "type": info["type"],
                "error_msg": error_msg,
                "status": "ok" if error_msg == "healthy" else "error"
            }
            if sub_info["serial_number"]:
                result[sub_info["serial_number"]] = sub_info
            else:
                result[sub_info["device_name"]] = sub_info
        return result
class FlashFio(IFlash):
    """fio的Flash卡
    """
    def __init__(self, txt_path):
        super(FlashFio, self).__init__()
        self.txt_path = txt_path
    def collect(self):
        disk_info = {}
        adapter_info = self._get_adapter_info()
        for info in adapter_info:
            serial_number = info["fio_serial_number"]
            for io in info["iomemory"]:
                data = self._combining_io_memory(io)
                data["serial_number"] = serial_number
                disk_info[serial_number] = data
        return disk_info

  | 编程范式带来的好处 范式就像武功心法，可以更快的练成绝世神功，但还是离不开基础功。代码也一样，通过遵循相关范式和良好的设计后，会带来可读性、扩展性和可维护性更好的代码，进而提升软件的质量。   | 总结 命令式编程、面向对象编程、函数式编程，虽然受人追捧的时间点各不相同，但是本质上并没有优劣之分。 面向对象和函数式、过程式编程也不是完成独立和有严格的界限，在抽象出各个独立的对象后，每个对象的具体行为实现还是有函数式和过程式完成。 现代的程序员应该很少有门派之见了，应该集百家之所长，学习其它范式(语言)的优秀设计理念，集成到自己的代码(产品、语言)中，提升工作效率。   | 致谢 简述编程范式：https://ginqi7.github.io/posts/brief-description-of-programming-paradigm.html 编程范型：https://zh.wikipedia.org/wiki/%E7%BC%96%E7%A8%8B%E8%8C%83%E5%9E%8B 学习编程之概述—从编程范式开始：http://dataunion.org/23223.html 面向对象编程 VS 函数式编程：http://blog.swanspace.org/oo_vs_fp/   […]

龙生   06 Apr 2021
View Details

泛型编程

泛型编程（Generic Programming）最初提出时的动机很简单直接：发明一种语言机制，能够帮助实现一个通用的标准容器库。 所谓通用的标准容器库，就是要能够做到，比如用一个List类存放所有可能类型的对象这样的事；泛型编程让你编写完全一般化并可重复使用的算法，其效率与针对某特定数据类型而设计的算法相同。泛型即是指具有在多种数据类型上皆可操作的含义，与模板有些相似。 STL巨大，而且可以扩充，它包含很多计算机基本算法和数据结构，而且将算法与数据结构完全分离，其中算法是泛型的，不与任何特定数据结构或对象类型系在一起。   from:https://baike.baidu.com/item/%E6%B3%9B%E5%9E%8B%E7%BC%96%E7%A8%8B/6787248?fr=aladdin

龙生   06 Apr 2021
View Details

指令式编程

命令式编程（英语：Imperative programming），是一种描述计算机所需作出的行为的编程典范。 几乎所有计算机的硬件工作都是命令式的；几乎所有计算机的硬件都是设计来运行机器码，使用命令式的风格来写的。 较高阶的命令式编程语言使用变量和更复杂的语句，但仍依从相同的典范。 虽非计算机程序，但与命令式编程有相似的风格：每步都是指令，有形的世界控制情况。 因为命令式编程的基础观念，不但概念上比较熟悉，而且较容易具体表现于硬件，所以大部分的编程语言都是命令式的。   from:https://baike.baidu.com/item/%E6%8C%87%E4%BB%A4%E5%BC%8F%E7%BC%96%E7%A8%8B/22934771?fr=aladdin

龙生   06 Apr 2021
View Details

函数式编程

函数式编程是种编程方式，它将电脑运算视为函数的计算。 函数编程语言最重要的基础是λ演算（lambda calculus），而且λ演算的函数可以接受函数当作输入（参数）和输出（返回值）。  和指令式编程相比，函数式编程强调函数的计算比指令的执行重要。 和过程化编程相比，函数式编程里函数的计算可随时调用。 from:https://baike.baidu.com/item/%E5%87%BD%E6%95%B0%E5%BC%8F%E7%BC%96%E7%A8%8B/4035031?fr=aladdin

龙生   06 Apr 2021
View Details

CSS 单位 2

CSS 有几个不同的单位用于表示长度。 一些设置 CSS 长度的属性有 width, margin, padding, font-size, border-width, 等。 长度有一个数字和单位组成如 10px, 2em, 等。 数字与单位之间不能出现空格。如果长度值为 0，则可以省略单位。 对于一些 CSS 属性，长度可以是负数。 有两种类型的长度单位：相对和绝对。 浏览器支持 下表中的数字表示支持该长度单位的最低浏览器版本。 长度单位 Chrome IE Firefox Safari Opera em, ex, %, px, cm, mm, in, pt, pc 1.0 3.0 1.0 1.0 3.5 ch 27.0 9.0 1.0 7.0 20.0 rem 4.0 9.0 3.6 4.1 11.6 vh, vw 20.0 9.0 19.0 6.0 20.0 vmin 20.0 9.0* 19.0 6.0 20.0 vmax 26.0 不支持 19.0 不支持 20.0 注意: Internet Explorer 9 通过不标准的名称 vm 来支持 vmin 。 相对长度 相对长度单位指定了一个长度相对于另一个长度的属性。对于不同的设备相对长度更适用。   单位 描述 在线实例 […]

龙生   02 Apr 2021
View Details

CSS cubic-bezier() 函数

实例 从开始到结束的不同速度过渡效果：

1
2
3
4
5
6
7
div {
  width: 100px;
  height: 100px;
  background: red;
  transition: width 2s;
  transition-timing-function: cubic-bezier(0.1, 0.7, 1.0, 0.1);
}

定义与用法 cubic-bezier() 函数定义了一个贝塞尔曲线(Cubic Bezier)。 贝塞尔曲线曲线由四个点 P0，P1，P2 和 P3 定义。P0 和 P3 是曲线的起点和终点。P0是（0,0）并且表示初始时间和初始状态，P3是（1,1）并且表示最终时间和最终状态。 从上图我们需要知道的是 cubic-bezier 的取值范围:

1
2
3
4
<span class="pln">P0</span><span class="pun">：默认值</span> <span class="pun">(</span><span class="lit">0</span><span class="pun">,</span> <span class="lit">0</span><span class="pun">)</span><span class="pln">
P1</span><span class="pun">：动态取值</span> <span class="pun">(</span><span class="pln">x1</span><span class="pun">,</span><span class="pln"> y1</span><span class="pun">)</span><span class="pln">
P2</span><span class="pun">：动态取值</span> <span class="pun">(</span><span class="pln">x2</span><span class="pun">,</span><span class="pln"> y2</span><span class="pun">)</span><span class="pln">
P3</span><span class="pun">：默认值</span> <span class="pun">(</span><span class="lit">1</span><span class="pun">,</span> <span class="lit">1</span><span class="pun">)</span>

我们需要关注的是 P1 和 P2 两点的取值，而其中 X 轴的取值范围是 0 到 1，当取值超出范围时 cubic-bezier 将失效；Y 轴的取值没有规定，当然也毋须过大。 最直接的理解是，将以一条直线放在范围只有 1 的坐标轴中，并从中间拿出两个点来拉扯（X 轴的取值区间是 [0, 1]，Y 轴任意），最后形成的曲线就是动画的速度曲线。 cubic-bezier() 可用于 animation-timing-function 和 transition-timing-function 属性。 支持版本：CSS3 浏览器支持 表格中的数字表示支持该函数的第一个浏览器版本号。 函数 cubic-bezier() 4.0 10.0 4.0 3.1 10.5 CSS 语法

1
<span class="pln">cubic</span><span class="pun">-</span><span class="pln">bezier</span><span class="pun">(</span><span class="pln">x1</span><span class="pun">,</span><span class="pln">y1</span><span class="pun">,</span><span class="pln">x2</span><span class="pun">,</span><span class="pln">y2</span><span class="pun">)</span>

值 描述 x1,y1,x2,y2 必需。数字值，x1 和 x2 需要是 0 到 1 的数字。   实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>菜鸟教程(runoob.com)</title>
<style>
div {
  width: 100px;
  height: 100px;
  background: red;
  transition: width 2s;
  transition-timing-function: cubic-bezier(0.1, 0.7, 1.0, 0.1);
}
 
div:hover {
  width:300px;
}
</style>
</head>
<body>
 
<h1>cubic-bezier() 函数</h1>
 
<p>鼠标移动到 div 元素上，查看效果。</p>
 
<div></div>
 
<p><b>注意:</b> Internet Explorer 9 及其更早版本的浏览器不支持该效果。</p>
 
</body>
</html>

  from:https://www.runoob.com/cssref/func-cubic-bezier.html

龙生   02 Apr 2021
View Details

CSS calc() 函数

实例 使用 calc() 函数计算 <div> 元素的宽度:

1
2
3
4
5
6
7
8
9
#div1 {
    position: absolute;
    left: 50px;
    width: calc(100% - 100px);
    border: 1px solid black;
    background-color: yellow;
    padding: 5px;
    text-align: center;
}

定义与用法 calc() 函数用于动态计算长度值。 需要注意的是，运算符前后都需要保留一个空格，例如：width: calc(100% – 10px)； 任何长度值都可以使用calc()函数进行计算； calc()函数支持 "+", "-", "*", "/" 运算； calc()函数使用标准的数学运算优先级规则； 支持版本：CSS3 浏览器支持 表格中的数字表示支持该函数的第一个浏览器版本号。 "webkit" 或 "moz" 或 "o" 指定的数字为支持该函数的第一个版本号前缀。 函数 calc() 26.0 19.0 -webkit- 9.0 16.0 4.0 -moz- 7.0 6.0 -webkit- 15.0 CSS 语法

1
<span class="pln">calc</span><span class="pun">(</span><span class="pln">expression</span><span class="pun">)</span>

值 描述 expression 必须，一个数学表达式，结果将采用运算后的返回值。   from:https://www.runoob.com/cssref/func-calc.html

龙生   02 Apr 2021
View Details

三种JS截取字符串方法

转载: https://www.cnblogs.com/zccfun/p/6054533.html JS提供三个截取字符串的方法,分别是:slice(),substring()和substr(),它们都可以接受一个或两个参数: var stmp = "rcinn.cn"; 使用一个参数 alert(stmp.slice(3));//从第4个字符开始,截取到最后个字符;返回"nn.cn" alert(stmp.substring(3));//从第4个字符开始,截取到最后个字符;返回"nn.cn" 使用两个参数 alert(stmp.slice(1,5))//从第2个字符开始，到第5个字符；返回"cinn" alert(stmp.substring(1,5));//从第2个字符开始，到第5个字符；返回"cinn" 如果只用一个参数并且为0的话，那么返回整个参数 alert(stmp.slice(0));//返回整个字符串 alert(stmp.substring(0));//返回整个字符串 返回第一个字符 // 1.位位截取 alert(stmp.slice(0,1));//返回"r" alert(stmp.substring(0,1));//返回"r" //上面的例子中我们可以看出slice()和substring()的用法是相同的，返回的值也一样， //但当参数为负数时，他们的返回值却不一样，看下面的例子 alert(stmp.slice(2,-5));//返回"i"；实际上是slice(2,3)，负数加上字符串长度转换成正3，(若第一位 >= 第二位, 则返回空字符串); alert(stmp.substring(2,-5));//返回"rc"； 实际上是substring(2,0),负数都转换为0,  substring总是把较小的数作为起始位置。 // 2. 位位截取 和 位数截取 alert(stmp.substring(1,5))//从第1位开始，截取到第5位；返回"cinn" alert(stmp.substr(1,5));   //从第1位开始，截取5个字符；返回"cinn." var phone = 15989012100; phone.slice(-6) 取倒数后6位(第二个参数不用写0)，return ‘012100 ’； phone.slice(-6，-4) 取倒数后4位到倒数6位，（-6+11，-4+11）=（5,7）；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 日期比较大小 当日期每个月都小1时
var nowdate = new Date();
item = 2016-7-16;
temp = item.split('-');
if (temp[0] != curYear || temp[1] != curMonth) {
    return;
}
temp[1] = parseInt(temp[1]) + 1;
date = new Date(temp.join('-'));
if(date>=nowdate){
执行A；
}else{
执行B；
}

替换指定字符串后的字母

1
2
3
var abc = 'adadada=ss';
var j = abc.substring(abc.indexOf('=')+1,abc.length);
var dsd =abc.replace(j,'haha');  -->   dsd = 'adadada=haha'

  frm:https://blog.csdn.net/qq_38719039/article/details/82219912

龙生   01 Apr 2021
View Details

html直接引用vue和element-ui的方法

代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <link rel="stylesheet" href="https://unpkg.com/element-ui/lib/theme-chalk/index.css">
    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script src="https://unpkg.com/element-ui/lib/index.js"></script>
</head>
<body>
    <div id="app">
        <el-button round @click="visible = true">圆角按钮</el-button>
        <br>
        <el-dialog :visible.sync="visible" title="Hello world">
            <p>Try Element</p>
        </el-dialog>
        <br>
        <el-switch v-model="value1" active-text="按月付费" inactive-text="按年付费">
        </el-switch>
        <el-switch style="display: block" v-model="value2" active-color="#13ce66" inactive-color="#ff4949"
            active-text="按月付费" inactive-text="按年付费">
        </el-switch>
        <br>
        <el-time-picker is-range v-model="value1" range-separator="至" start-placeholder="开始时间" end-placeholder="结束时间"
            placeholder="选择时间范围">
        </el-time-picker>
        <el-time-picker is-range arrow-control v-model="value2" range-separator="至" start-placeholder="开始时间"
            end-placeholder="结束时间" placeholder="选择时间范围">
        </el-time-picker>
        <br>
        <el-progress type="circle" :percentage="0"></el-progress>
        <el-progress type="circle" :percentage="25"></el-progress>
        <el-progress type="circle" :percentage="100" status="success"></el-progress>
        <el-progress type="circle" :percentage="70" status="warning"></el-progress>
        <el-progress type="circle" :percentage="50" status="exception"></el-progress>
        <br>
        <el-row>
            <el-button icon="el-icon-search" circle></el-button>
            <el-button type="primary" icon="el-icon-edit" circle></el-button>
            <el-button type="success" icon="el-icon-check" circle></el-button>
            <el-button type="info" icon="el-icon-message" circle></el-button>
            <el-button type="warning" icon="el-icon-star-off" circle></el-button>
            <el-button type="danger" icon="el-icon-delete" circle></el-button>
        </el-row>
        <br>
        <el-steps :active="1" finish-status="success">
            <el-step title="已付款"></el-step>
            <el-step title="退款中"></el-step>
            <el-step title="已退款"></el-step>
            <el-step title="待结算"></el-step>
            <el-step title="已结算"></el-step>
        </el-steps>
    </div>
</body>
<script>
    new Vue({
        el: '#app',
        data: function () {
            return { visible: false }
        }
    })
</script>
</html>

效果如图： 总结 到此这篇关于html直接引用vue和element-ui的方法的文章就介绍到这了,更多相关html引用vue和element-ui内容请搜索脚本之家以前的文章或继续浏览下面的相关文章，希望大家以后多多支持脚本之家！   from:https://www.jb51.net/web/743299.html

龙生   24 Mar 2021
View Details

Kafka、RocketMQ、RabbitMQ的优劣势比较

最全MQ消息队列有哪些？ 目前在业界有哪些比较知名的消息引擎呢？如下图所示 这里面几乎完全列举了当下比较知名的消息引擎，包括： ZeroMQ 推特的Distributedlog ActiveMQ：Apache旗下的老牌消息引擎 RabbitMQ、Kafka：AMQP的默认实现。 RocketMQ Artemis：Apache的ActiveMQ下的子项目 Apollo：同样为Apache的ActiveMQ的子项目的号称下一代消息引擎 商业化的消息引擎IronMQ 以及实现了JMS(Java Message Service)标准的OpenMQ。   MQ消息队列的技术应用 1.解耦 解耦是消息队列要解决的最本质问题。 2.最终一致性 最终一致性指的是两个系统的状态保持一致，要么都成功，要么都失败。 最终一致性不是消息队列的必备特性，但确实可以依靠消息队列来做最终一致性的事情。 2.广播 消息队列的基本功能之一是进行广播。 有了消息队列，我们只需要关心消息是否送达了队列，至于谁希望订阅，是下游的事情，无疑极大地减少了开发和联调的工作量。 3.错峰与流控 典型的使用场景就是秒杀业务用于流量削峰场景。 Kafka、RocketMQ、RabbitMQ比较   1.ActiveMQ 优点 单机吞吐量：万级 topic数量都吞吐量的影响： 时效性：ms级 可用性：高，基于主从架构实现高可用性 消息可靠性：有较低的概率丢失数据 功能支持：MQ领域的功能极其完备 缺点: 官方社区现在对ActiveMQ 5.x维护越来越少，较少在大规模吞吐的场景中使用。   2.Kafka 号称大数据的杀手锏，谈到大数据领域内的消息传输，则绕不开Kafka，这款为大数据而生的消息中间件，以其百万级TPS的吞吐量名声大噪，迅速成为大数据领域的宠儿，在数据采集、传输、存储的过程中发挥着举足轻重的作用。 Apache Kafka它最初由LinkedIn公司基于独特的设计实现为一个分布式的提交日志系统( a distributed commit log)，之后成为Apache项目的一部分。 目前已经被LinkedIn，Uber, Twitter, Netflix等大公司所采纳。 优点 性能卓越，单机写入TPS约在百万条/秒，最大的优点，就是吞吐量高。 时效性：ms级 可用性：非常高，kafka是分布式的，一个数据多个副本，少数机器宕机，不会丢失数据，不会导致不可用 消费者采用Pull方式获取消息, 消息有序, 通过控制能够保证所有消息被消费且仅被消费一次; 有优秀的第三方Kafka Web管理界面Kafka-Manager； 在日志领域比较成熟，被多家公司和多个开源项目使用； 功能支持：功能较为简单，主要支持简单的MQ功能，在大数据领域的实时计算以及日志采集被大规模使用 缺点： Kafka单机超过64个队列/分区，Load会发生明显的飙高现象，队列越多，load越高，发送消息响应时间变长 使用短轮询方式，实时性取决于轮询间隔时间； 消费失败不支持重试； 支持消息顺序，但是一台代理宕机后，就会产生消息乱序； 社区更新较慢；   3.RabbitMQ RabbitMQ 2007年发布，是一个在AMQP(高级消息队列协议)基础上完成的，可复用的企业消息系统，是当前最主流的消息中间件之一。 RabbitMQ优点： 由于erlang语言的特性，mq 性能较好，高并发； 吞吐量到万级，MQ功能比较完备 健壮、稳定、易用、跨平台、支持多种语言、文档齐全； 开源提供的管理界面非常棒，用起来很好用 社区活跃度高； RabbitMQ缺点： erlang开发，很难去看懂源码，基本职能依赖于开源社区的快速维护和修复bug，不利于做二次开发和维护。 RabbitMQ确实吞吐量会低一些，这是因为他做的实现机制比较重。 需要学习比较复杂的接口和协议，学习和维护成本较高。 4.RocketMQ RocketMQ出自 阿里公司的开源产品，用 Java 语言实现，在设计时参考了 […]

龙生   19 Mar 2021
View Details
1 … 91 92 93 … 410