提示 Visual Studio 学习版（如 Visual C# 速成版）不支持调试非托管代码， 只有完整的 Visual Studio 产品才支持此操作。 位于**“项目设计器”的“调试”页上的“非托管代码调试”**属性确定是否支持本机代码调试。 如果要调用 COM 对象，或启动调用您的项目的、以本机代码编写的自定义程序，并且需要调试本机代码，请选定此选项。 启用对非托管代码的调试 在**“解决方案资源管理器”中选定一个项目，然后在“项目”菜单中单击“属性”**。 单击**“调试”**选项卡。 选中**“启用非托管代码调试”**复选框。 禁用对非托管代码的调试 在**“解决方案资源管理器”中选定一个项目，然后在“项目”菜单中单击“属性”**。 单击**“调试”**选项卡。 单击以清除**“启用非托管代码调试”**复选框。 from:https://docs.microsoft.com/zh-cn/previous-versions/visualstudio/visual-studio-2010/tdw0c6sf(v=vs.100)
View Details|
1 2 3 4 5 6 |
var uuid = Guid.NewGuid().ToString(); // 9af7f46a-ea52-4aa3-b8c3-9fd484c2af12 var uuidN = Guid.NewGuid().ToString("N"); // e0a953c3ee6040eaa9fae2b667060e09 var uuidD = Guid.NewGuid().ToString("D"); // 9af7f46a-ea52-4aa3-b8c3-9fd484c2af12 var uuidB = Guid.NewGuid().ToString("B"); // {734fd453-a4f8-4c5d-9c98-3fe2d7079760} var uuidP = Guid.NewGuid().ToString("P"); // (ade24d16-db0f-40af-8794-1e08e2040df3) var uuidX = Guid.NewGuid().ToString("X"); // {0x3fa412e3,0x8356,0x428f,{0xaa,0x34,0xb7,0x40,0xda,0xaf,0x45,0x6f}} |
from:https://www.cnblogs.com/shiyh/p/10966059.html
View Detailseclipse已安装lombok插件，ide提示均正常，但gradle中编译报错cannot find symbol 经过排查发现是build.gradle中少了annotationProcessor配置导致，补充第二行配置后刷新项目搞定 implementation 'org.projectlombok:lombok:1.18.10' annotationProcessor 'org.projectlombok:lombok:1.18.10' ———————————————— 版权声明：本文为CSDN博主「chandtler」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/chandtler/article/details/103287550
View Details简单来说就是，多台机器同时安装jmeter，选择一台机器作为调度机，其他作为压力机。进行相应的配置后，就可以用调度机操控压力机发起请求。 分布式执行原理 负载机配置 安装JAVA 下载并解压JDK
|
1 2 3 4 |
mkdir /usr/lib/jvm/ cd /usr/lib/jvm/ tar -zxvf jdk1.8.0_121.tar.gz |
配置jdk的环境变量
|
1 2 3 4 5 6 7 |
#vi /etc/profile export JAVA_HOME=/usr/lib/jvm/jdk1.8.0_121 export JRE_HOME=/usr/lib/jvm/jdk1.8.0_121/jre export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib export PATH=$PATH:$JAVA_HOME/bin |
再执行source /etc/profile刷新配置文件 通过java -version查看是否设置成功 安装Jmeter 下载jmeter.tgz文件，并将文件上传至/data/
|
1 2 3 4 5 6 7 8 9 |
#将jmeter文件解压,并将解压后的文件拷贝至指定路径/data/ tar xvf apache-jmeter-4.0.tgz 配置jmeter的环境变量，将下述内容复制粘贴 #vi /etc/profile export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib/rt.jar:$JMETER_HOME/lib/ext/ApacheJMeter_core.jar:$JMETER_HOME/lib/jorphan.jar:$JMETER_HOME/lib/logkit-2.0.jar: export PATH=$PATH:$JAVA_HOME/bin:$JMETER_HOME/bin: export JMETER_HOME=/data/apache-jmeter-4.0 |
再执行source /etc/profile刷新配置文件 通过jmeter -v查看是否设置成功 在jmeter目录创建testplan testresult子目录 , 将测试脚本login.jmx上传至testplan，进入bin文件下执行测试输出测试结果命令
|
1 2 3 |
cd /data/apache-jmeter-4.0/bin jmeter -n -t ./testplan/login.jmx -l ./result/test.jtl -e -o ./testresult/ |
分布式配置 调度机Controller 在多台机器中按照上述步骤配置jmeter，选择其中一台为调度机，其他为执行机 在调度机上修改bin/jmeter.properties, 添加执行机的IP及端口 , 1099是默认的rmi通信端口
|
1 2 |
remote_hosts=192.168.174.130:1000,192.168.3.148:1888 |
案例中 , 192.168.174.130:1000即是执行机IP和端口号 取消server.rmi.ssl.disable=false的中注释并将false改为ture
|
1 2 3 4 5 6 |
# Remote Hosts - comma delimited remote_hosts=192.168.5.95:1099,192.168.5.103:1099 server.rmi.ssl.disable=true |
开启执行脚本机器上的server服务，bin/jmeter-server 在控制机执行分布式命令
|
1 2 3 4 5 6 |
#使用 -r 启动所有从机执行脚本 jmeter -n -t testplan/comic.jmx -r -l testResult/result1.jtl #指定从机IP jmeter -n -t testplan/comic.jmx -R 10.15.243.53,10.15.230.78 -l testResult/result1.jtl |
执行机Agent 修改jmeter.properties
|
1 2 3 4 |
server_port=1000 server.rmi.localport=1000 server.rmi.ssl.disable=true |
然后执行命令 , 启动服务
|
1 2 |
sudo jmeter-server -Djava.rmi.server.hostname=192.168.174.130 #从机自身IP |
遇到的问题及解决 An error occurred: Cannot start. localhost is a loopback address In latest version, you can run your script with:指定本地IP 解决方案:
|
1 2 |
sudo jmeter-server -Djava.rmi.server.hostname=192.168.174.130 #从机自身IP |
java.io.FileNotFoundException: rmi_keystore.jks 1、Jmeter4.0，启动slave报错java.io.FileNotFoundException: rmi_keystore.jks image 解决方法一：slave的jmeter.properties中，设置server.rmi.ssl.disable=true 原因：jmeter4.0以上的版本，默认启用RMI连接的安全通信，需要创建密钥库。所以将SSL禁用即可。 解决方法二：手动生成秘钥和证书。执行create-rmi-keystore.bat（Windows适用）或create-rmi-keystore.sh（Linux适用） Neither the JAVA_HOME nor the JRE_HOME environment variable is defined 在使用java远程启动linux服务器上的jmeter服务是报Neither […]
View Details一、数组声明 两种形式（方括号位置放变量前后都可以）： int arr[ ]; int[ ] arr2; 二、数组初始化 数组初始化也有两种形式，如下（使用new或不使用new）： int arr[] = new int[]{1, 3, 5, 7, 9}; int[] arr2 = {2, 4, 6, 8, 10}; 三、遍历数组 遍历数组可用for/foreach，如下： for循环略 int arr[] = new int[]{1, 3, 5, 7 ,9}; for (int x: arr) { System.out.print(x + "\t"); } 四、Arraysfill填充数组（修改数组） 使用Arrays类的静态方法，需要import包java.util.Arrays，定义了许多重载方法。 void fill(int[] a, int val)全部填充 void fill(int[] a, int fromIndex, int toIndex, int val)填充指定索引的元素 左闭右开
|
1 2 3 |
int[] arr = new int[]｛6，6，6，6，6，6｝; Arrays.fill(arr, 8); //8,8,8,8,8,8 Arrays.fill(arr3, 1, 3, 9); //6,9,9,8,8,8 |
五、Arrayssort对数组排序（使用Arrays.调用） void sort(int[] a)全部排序 默认升序 void sort(int[] a, int fromIndex, int toIndex)排序指定索引的元素
|
1 2 3 |
int [] array=new int[]{3,7,8,2,1,9}; Arrays.sort(array); //全排序 Arrays.sort(array,2,5); //2到5排序 |
六、ArrayscopyOf复制数组 int[] copyOf(int[] original, int newLength)复制数组，指定新数组长度 int[] copyOfRange(int[] original, int from, int to)复制数组，指定所复制的原数组的索引
|
1 2 3 |
int [] array=new int[]{3,7,8,2,1,9}; array2=Arrays.copyOf(array,3); //新数组的长度为3 array3=Arrays.copyOfRange(array,3,5); //复制第三到五个元素 |
七、检查数组中是否包含某一个值 先使用Arrays.asList()将Array转换成List<String>，这样就可以用动态链表的contains函数来判断元素是否包含在链表中 […]
View Details简述 方法其实有很多种的。我先放一些，之后有再遇到对应代码再放上来。 最简单的当然是一个个找进行对比的方法啦~ 当然还是有一些有趣的操作的 实例一：
|
1 2 3 4 5 6 |
import java.util.Arrays; public static int MAX(int[] arr) { Arrays.sort(arr); return arr[arr.length-1]; } |
就是先排序再来得到结果 实例二 这个是菜鸟教程上的一份代码
|
1 2 3 4 5 6 7 8 9 10 11 12 |
import java.util.Arrays; import java.util.Collections; public class Main { public static void main(String[] args) { Integer[] numbers = { 8, 2, 7, 1, 4, 9, 5}; int min = (int) Collections.min(Arrays.asList(numbers)); int max = (int) Collections.max(Arrays.asList(numbers)); System.out.println("最小值: " + min); System.out.println("最大值: " + max); } } |
实例三：
|
1 2 3 4 |
import java.util.Arrays public static int MAX(int[] arr) { return Arrays.stream(arr).max().getAsInt(); } |
from:https://blog.csdn.net/a19990412/article/details/81296234
View DetailsString[]与List的相互转换 1.0 String[]与List的相互转换
|
1 2 |
String[] arr = new String[]{"s1","s2","s3"}; List<String> list = Arrays.asList(arr); |
1.2 List转String[]
|
1 2 3 4 5 |
List<String> list = new ArrayList<String>(); list.add("s1"); list.add("s2"); list.add("s3"); String[] arr = list.toArray(new String[list.size()]); |
字符数组char[]和字符串String之间的转换 2.0 使用String.valueOf()将字符数组转换成字符串
|
1 2 3 4 5 6 7 |
void (){ char[] s={'A','G','C','T'}; String st=String.valueOf(s); System.out.println("This is : "+st); } >> This is : AGCT |
2.1使用.toCharArray()将字符串转换成字符数组
|
1 2 3 4 5 6 7 8 9 10 |
String str="AGCT"; char[] s=str.toCharArray(); for (int i=0;i<str.length();i++){ System.out.println("This s[i] "+i+s[i]); } This s[i] 0 A This s[i] 1 G This s[i] 2 C This s[i] 3 T |
from:https://blog.csdn.net/qq_41076577/article/details/106909006
View Details前言（废话） 昨天抽了点时间在网上搜列了一个开源项目，项目挺完整的，前后台分离还带有微信小程序，我Clone下代码，经过一番倒腾，嘿~还真就跑起来了。在这个过程中，体验了一把VUE项目工程细节，因为之前没有接触过这一块，所以还是花费了点时间，好在开源项目的QQ群里楼主帮忙看了一下，才得以顺利往后进行。后来也有很多网友向楼主提问，也抛出了一些问题，其中有个问题到引起了我的注意。 有个小伙伴执行SQL的时候报错了，以为项目中给的SQL脚本不全，但是在群里他并没有给出报错细节的截图，楼主后来也就提示了他一句MySQL版本需要在5.7以上，但是后面就没有更多消息了。 今天早上我还在上班路上，群里的小伙伴就私信我，说能否帮他看下数据库的问题。等我到了公司再回复他的时候，他告诉我说数据库问题已经解决了，我追问了一下细节，原来是开源项目中的数据库建表语句中包含JSON类型字段，导致了他批量执行SQL脚本不成功。其实这样的问题，在执行脚本的时候遇到错误是有日志的，详细看下日志应该明了。 我其实是没有注意到这个细节的，因为我前天安装的数据库就直接上了8.0，屏蔽了这个问题，但是，MySQL数据库现在支持JSON类型，挺新奇的，因为之前没有用过，并不熟悉，所以这一次，让我逮到个了解它的机会。 关于MySQL的JSON类型 JSON估计大家伙都熟悉了，我就不再介绍这方面内容。其实在MySQL数据库中，也直到5.7这个版本，才开始引入JSON数据类型，在此之前如果想在表中保存JSON格式类型的数据，则需要依靠varchar或者text之类的数据类型，如果在低于5.7版本的数据库中使用了JSON类型来建表，显然是不会成功的。 （截图为MySQL官网文档） 如何使用JSON类型 建表 在MySQL中创建具有JSON数据列的表，其实和数据类型没有太大区别，具体举例如下：
|
1 2 3 4 |
CREATE TABLE tab_base_info ( id BIGINT NOT NULL PRIMARY KEY auto_increment, content json ); |
新增数据 插入一条语句，注意看JSON数据列的内容：
|
1 2 3 4 5 |
INSERT INTO tab_base_info (content) VALUES ( '{"author": "Captain&D", "blog": "https://www.cnblogs.com/captainad"}' ); |
这里需要提醒的是： JSON列存储的数据要么是NULL，要么必须是JSON格式数据，否则会报错。 JSON数据类型是没有默认值的（声明时"DEFAULT NULL"）。 JSON数据类型意义 其实，没有JSON数据类型的支持，我们一样可以通过varchar类型或者text等类型来保存这一格式的数据，但是，为什么还要专门增加这一数据格式的支持呢？其中肯定有较varchar或者text来存储此类型更优越的地方。 保证了JSON数据类型的强校验，JSON数据列会自动校验存入此列的内容是否符合JSON格式，非正常格式则报错，而varchar类型和text等类型本身是不存在这种机制的。 MySQL同时提供了一组操作JSON类型数据的内置函数。 更优化的存储格式，存储在JSON列中的JSON数据会被转成内部特定的存储格式，允许快速读取。 可以基于JSON格式的特征支持修改特定的键值。（即不需要把整条内容拿出来放到程序中遍历然后寻找替换再塞回去，MySQL内置的函数允许你通过一条SQL语句就能搞定） MySQL关于JSON的内置函数 MySQL关于JSON数据格式的操作提供了很多高效率的内置函数，我们可以从MySQL官网上找到很详细的介绍和使用说明，下面贴一张JSON函数的指南： （截图为MySQL官方文档） 其实我们从JSON功能介绍的主页也可以看到，这些内置函数支持我们创建、查找、替换和返回值等相关的操作，像我们替换指定内容的操作就可以使用JSON_REPLACE()这个函数，不过最后实现通过纯SQL语句执行最终的内容替换，你还需要通过执行UPDATE语句，比如：
|
1 2 3 |
UPDATE tab_base_info SET content = json_replace(content, '$.author', "tom") WHERE id = 1; |
其中“$.***”表示找到JSON内容中匹配的修改字段。 更多关于这些内置函数的用法，大家都可以到官网（链接请查看本文参考资料）的文档上去查阅，写的十分详细而且还有举例。 参考资料： 1、https://zhuanlan.zhihu.com/p/31823258 2、https://dev.mysql.com/doc/refman/5.7/en/json-functions.html from:https://www.cnblogs.com/captainad/p/11176127.html
View DetailsDB-Engines 4 月份流行度排行已更新（基于 3 月份的整体数据变化）。 从总榜来看，前十数据库的排名和上个月保持一致。虽然排名没有变动，但单个数据库的分数却变化不少。稳居前三的 Oracle、MySQL 和 Microsoft SQL Server 分数出现了较大幅度的下跌，分别减少 46.82、34.14 和 7.33 分。其中 SQL Server 分数已经连续下跌了两个月。若与去年同期的数据相比，三者下跌的分数平均已达到 64 分。 后起之秀 PostgreSQL 和 MongoDB 依旧保持着稳步上升的趋势，分数与上个月相比有小幅度增加，与去年同期相比也平均增加了 40 分左右。 ▲ 前十数据库的分数变化走向 对于排名 20 之后的数据库，以年为维度，排名显著上升的数据库有 Snowflake 和 Clickhouse，Snowflake 由去年同时期的第 100 名上升到现在的第 29 名，后者也从第 71 名上升至第 50 名。两者都属于云数据仓库，Snowflake 的母公司去年上市后更是获得巴菲特青睐，股价飙升。相信这也是它排名上升的主要原因。 最后看看各类型数据库的排名情况。 关系数据库前 10 名 Key-Value 数据库前 10 名 文档数据库前 10 名 时序数据库前 10 名 图数据库前 10 名 DB-Engines 根据流行度对数据库管理系统进行排名，排名每月更新一次。排名的数据依据 5 个不同的指标： Google 以及 Bing 搜索引擎的关键字搜索数量 Google Trends 的搜索数量 Indeed 网站中的职位搜索量 LinkedIn 中提到关键字的个人资料数 Stackoverflow 上相关的问题和关注者数量 这份榜单分析旨在为数据库相关从业人员提供一个技术方向的参考，其中涉及到的排名情况并非基于产品的技术先进程度或市场占有率等因素。无论排名先后，选择适合与企业业务需求相比配的技术才是最重要的。 from:https://www.oschina.net/news/135658/db-engines-ranking-202104
View Details| 前言 相信绝大部分开发人员、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/ […]
View Details