[函数参数校验]的搜索结果

...sdecimal()函数外，Python引入了zoneinfo模块以支持国际化时间处理，这使得在处理包含日期、时间戳等混合型数字格式的用户输入时更为精准。 同时，在大型项目中，为确保代码健壮性，推荐使用类型注解（Type Annotations）配合库如typeguard进行更严格的输入校验。Python 3.8及以上版本强化了类型提示功能，可以有效预防因类型错误导致的运行时异常，尤其对于涉及复杂数字结构如numpy数组或pandas DataFrame的数据验证具有重要意义。 此外，针对Web开发场景下的用户输入验证，框架Django和Flask提供了内置的表单验证机制，能够自动检查并转换用户提交的数字信息，极大地提升了开发效率和用户体验。 总的来说，Python在数字处理与验证方面持续优化和发展，开发者应紧跟社区动态，充分利用新特性与最佳实践，以提升应用程序的安全性和稳定性。

..._numeric()函数在进行数据类型转换时，提供了更灵活且严谨的参数校验，有助于减少因误操作导致的数据类型不匹配错误。 此外，在实际应用中，为避免InvalidColumnTypeCastError等类似问题的发生，开发者不仅需要熟悉数据库系统提供的转换工具与方法，还要强化对业务逻辑的理解，确保数据模型设计合理。近期，一篇发表在《ACM Transactions on Database Systems》的研究文章深入探讨了数据类型转换中的潜在陷阱与最佳实践，通过对大量实例分析，作者强调了在设计阶段充分考虑数据完整性和一致性的重要性，并提倡在编程实践中采用防御性编程策略以应对未知的数据类型转换异常。 与此同时，随着大数据和云计算技术的发展，跨平台、多环境下的数据迁移与同步也日益频繁，这也对数据类型的兼容性及转换机制提出了更高要求。因此，无论是数据库管理员还是软件开发者，都需要紧跟技术潮流，不断学习和完善自身的数据库知识体系，从而有效预防和解决由数据类型转换引发的各种问题。

...并不知道sqrt函数需要传入什么类型的参数以及返回什么类型的值，因此会出现类型安全警告。为了消除这种不明确性，我们可以创建一个对应的声明文件mathUtils.d.ts： typescript // mathUtils.d.ts declare function sqrt(number: number): number; export default sqrt; 这样，当TypeScript编译器遇到对mathUtils.js的引用时，就会依据声明文件来推断和校验类型，使得整个项目能够在享受静态类型检查的同时，无缝兼容现有的JavaScript模块。 4. 如何编写和应用.d.ts声明文件？ 编写声明文件是一个细致且富有创造性的过程，它要求开发者深入理解所要声明的JavaScript模块的内部结构和接口行为。例如，对于上述的mathUtils.js模块，我们简单明了地指定了sqrt函数的输入输出类型。在实际项目中，复杂的库可能需要更为详尽的类型声明，包括类、接口、枚举等。 5. 结合实战，畅谈优势 将类型声明文件引入JavaScript项目后，不仅提高了代码的健壮性，还能借助IDE的强大智能提示和错误检测功能，显著提升开发效率。而且，声明文件这玩意儿，可以说让团队成员间的沟通效率嗖嗖地往上涨。你想啊，现在大伙儿都门儿清每个API接口想要的输入和输出类型，这样一来，因为搞错类型而可能带来的小bug们，就被我们悄无声息地扼杀在摇篮里了。 6. 总结 从混沌到有序 回顾整篇文章，我们揭示了JavaScript项目为何会关联TypeScript的类型声明文件，这背后是开发者们追求更高代码质量、更好开发体验的不懈努力。在咱们的JavaScript项目里，哪怕它是个JS的大本营，只要引入了.d.ts声明文件这个神器，就能蹭上TypeScript的静态类型检测福利。这样一来，咱就可以打造出更稳如老狗、扩展性更强的应用程序，让开发过程更加顺滑，代码质量更高。所以，不论你是位对TypeScript痴迷到不行的开发者，还是个铁了心扎根JavaScript阵营的忠实战士，拥抱类型声明文件这玩意儿，绝对是个既聪明又接地气的选择，没得商量！

...te 构造方法（构造函数）即可。 var box = new Date(); // 创建一个日期对象 在调用 Date 构造方法而不传递参数的情况下，新建的对象自动获取当前的时间和日期。 alert(box); // 不同浏览器显示不同 ECMAScript 提供了两个方法，Date.parse()和 Date.UTC()。Date.parse()方法接收一个表示日期的字符串参数，然后尝试根据这个字符串返回相应的毫秒数。ECMA-262 没有定义 Date.parse()应该支持哪种日期格式，因此方法的行为因实现而异，因地区而异。默认通常接收的日期格式如下： ‘月/日/年’，如 6/13/2011; ‘英文月名 日, 年’，如 May 25, 2004; ‘英文星期几 英文月名 日 年 时:分:秒 时区’，如 Tue May 25 2004 00:00:00 GMT-070 alert(Date.parse('6/13/2011')); // 1307894400000 如果 Date.parse()没有传入或者不是标准的日期格式，那么就会返回 NaN。 alert(Date.parse()); // NaN 如果想输出指定的日期，那么把 Date.parse()传入 Date 构造方法里。 var box = new Date(Date.parse('6/13/2011')); // Mon Jun 13 2011 00:00:00 GMT+0800var box = new Date('6/13/2011'); // 直接传入，Date.parse()后台被调用 Date 对象及其在不同浏览器中的实现有许多奇怪的行为。其中有一种倾向是将超出的范围的值替换成当前的值，以便生成输出。例如，在解析“January 32, 2007”时，有的浏览器会将其解释为“February 1, 2007”。而 Opera 则倾向与插入当前月份的当前日期。 Date.UTC()方法同样也返回表示日期的毫秒数，但它与 Date.parse()在构建值时使用不同的信息。（年份，基于 0 的月份[0 表示 1 月，1 表示 2 月]，月中的哪一天[1-31]，小时数[0-23] ，分钟，秒以及毫秒)。只有前两个参数是必须的。如果没有提供月数，则天数为 1；如果省略其他参数，则统统为 0。 alert(Date.UTC(2011,11)); // 1322697600000 如果 Date.UTC()参数传递错误，那么就会出现负值或者 NaN 等非法信息。 alert(Date.UTC()); // 负值或者 NaN 如果要输出指定日期，那么直接把 Date.UTC()传入 Date 构造方法里即可。 var box = new Date(Date.UTC(2011,11, 5, 15, 13, 16)); 通用的方法 与其他类型一样，Date 类型也重写了 toLocaleString()、toString()和 valueOf()方法；但这些方法返回值与其他类型中的方法不同。 var box = new Date(Date.UTC(2011,11, 5, 15, 13, 16));alert('toString:' + box.toString());alert('toLocaleString:' + box.toLocaleString()); // 按本地格式输出 这两个方法在不同浏览器显示的效果又不一样，但不用担心，这两个方法只是在调试比较有用，在显示时间和日期上，没什么价值。valueOf()方法显示毫秒数。 日期格式化方法 Date 类型还有一些专门用于将日期格式化为字符串的方法。 var box = new Date();alert(box.toDateString()); // 以特定的格式显示星期几、月、日和年alert(box.toTimeString()); // 以特定的格式显示时、分、秒和时区alert(box.toLocaleDateString()); // 以特定地区格式显示星期几、月、日和年alert(box.toLocaleTimeString()); // 以特定地区格式显示时、分、秒和时区alert(box.toUTCString()); // 以特定的格式显示完整的 UTC 日期 组件方法 组件方法，是为我们单独获取你想要的各种时间/日期而提供的方法。需要注意的时候 ，这些方法中，有带 UTC 的，有不带 UTC 的。UTC 日期指的是在没有时区偏差的情况下的日期值。 alert(box.getTime()); // 获取日期的毫秒数，和 valueOf()返回一致alert(box.setTime(100)); // 以毫秒数设置日期，会改变整个日期alert(box.getFullYear()); // 获取四位年份alert(box.setFullYear(2012)); // 设置四位年份，返回的是毫秒数alert(box.getMonth()); // 获取月份，没指定月份，从 0 开始算起alert(box.setMonth(11)); // 设置月份alert(box.getDate()); // 获取日期alert(box.setDate(8)); // 设置日期，返回毫秒数alert(box.getDay()); // 返回星期几，0 表示星期日，6 表示星期六alert(box.setDay(2)); // 设置星期几alert(box.getHours()); // 返回时alert(box.setHours(12)); // 设置时alert(box.getMinutes()); // 返回分钟alert(box.setMinutes(22)); // 设置分钟alert(box.getSeconds()); // 返回秒数alert(box.setSeconds(44)); // 设置秒数alert(box.getMilliseconds()); // 返回毫秒数alert(box.setMilliseconds()); // 设置毫秒数alert(box.getTimezoneOffset()); // 返回本地时间和 UTC 时间相差的分钟数 以上方法除了 getTimezoneOffset()，其他都具有 UTC 功能，例如 setDate()及 getDate()获取星期几，那么就会有 setUTCDate()及getUTCDate()，表示世界协调时间。 2、正则表达式 假设用户需要在 HTML 表单中填写姓名、地址、出生日期等。那么在将表单提交到服务器进一步处理前，JavaScript 程序会检查表单以确认用户确实输入了信息并且这些信息是符合要求的。 什么是正则表达式 正则表达式（regular expression）是一个描述字符模式的对象。ECMAScript 的 RegExp 类表示正则表达式，而 String 和 RegExp 都定义了使用正则表达式进行强大的模式匹配和文本检索与替换的函数。 正则表达式主要用来验证客户端的输入数据。用户填写完表单单击按钮之后，表单就会被发送到服务器，在服务器端通常会用 PHP、ASP.NET 等服务器脚本对其进行进一步处理 。因为客户端验证，可以节约大量的服务器端的系统资源，并且提供更好的用户体验。 创建正则表达式 创建正则表达式和创建字符串类似，创建正则表达式提供了两种方法，一种是采用 new 运算符，另一个是采用字面量方式。 两种创建方式 var box = new RegExp('box'); // 第一个参数字符串var box = new RegExp('box', 'ig'); // 第二个参数可选模式修饰符 模式修饰符的可选参数 参数 含义 i 忽略大小写 g 全局匹配 m 多行匹配 var box = /box/; // 直接用两个反斜杠var box = /box/ig; // 在第二个斜杠后面加上模式修饰符 测试正则表达式 RegExp 对象包含两个方法：test()和 exec()，功能基本相似，用于测试字符串匹配。test()方法在字符串中查找是否存在指定的正则表达式并返回布尔值，如果存在则返回 true，不存在则返回 false。exec()方法也用于在字符串中查找指定正则表达式，如果 exec()方法执行成功，则返回包含该查找字符串的相关信息数组。如果执行失败，则返回 null。 RegExp 对象的方法 方法 功能 test 在字符串中测试模式匹配，返回 true 或 false exec 在字符串中执行匹配搜索，返回结果数组 // 使用 new 运算符的 test 方法示例var pattern = new RegExp('box', 'i'); // 创建正则模式，不区分大小写var str = 'This is a Box!'; // 创建要比对的字符串alert(pattern.test(str)); // 通过 test()方法验证是否匹配// 使用字面量方式的 test 方法示例var pattern = /box/i; // 创建正则模式，不区分大小写var str = 'This is a Box!';alert(pattern.test(str));// 使用一条语句实现正则匹配alert(/box/i.test('This is a Box!')); // 模式和字符串替换掉了两个变量// 使用 exec 返回匹配数组var pattern = /box/i;var str = 'This is a Box!';alert(pattern.exec(str)); // 匹配了返回数组，否则返回 null 使用字符串的正则表达式方法 除了 test()和 exec()方法，String 对象也提供了 4 个使用正则表达式的方法。 String 对象中的正则表达式方法 方法 含义 match(pattern) 返回 pattern 中的子串或 null replace(pattern, replacement) 用 replacement 替换 pattern search(pattern) 返回字符串中 pattern 开始位置 split(pattern) 返回字符串按指定 pattern 拆分的数组 // 使用 match 方法获取获取匹配数组var pattern = /box/ig; // 全局搜索var str = 'This is a Box!，That is a Box too';alert(str.match(pattern)); // 匹配到两个 Box,Boxalert(str.match(pattern).length); // 获取数组的长度// 使用 search 来查找匹配数据var pattern = /box/ig;var str = 'This is a Box!，That is a Box too';alert(str.search(pattern)); // 查找到返回位置，否则返回-1 因为 search 方法查找到即返回，也就是说无需 g 全局。 // 使用 replace 替换匹配到的数据var pattern = /box/ig;var str = 'This is a Box!，That is a Box too';alert(str.replace(pattern, 'Tom')); // 将 Box 替换成了 Tom// 使用 split 拆分成字符串数组var pattern = / /ig;var str = 'This is a Box!，That is a Box too';alert(str.split(pattern)); // 将空格拆开分组成数组 RegExp 对象的静态属性 属性 短名 含义 input $_ 当前被匹配的字符串 lastMatch $& 最后一个匹配字符串 lastParen $+ 最后一对圆括号内的匹配子串 leftContext $ 最后一次匹配前的子串 multiline $ 用于指定是否所有的表达式都用于多行的布尔值 rightContext $’ 在上次匹配之后的子串 // 使用静态属性var pattern = /(g)oogle/;var str = 'This is google！';pattern.test(str); // 执行一下alert(RegExp.input); // This is google！alert(RegExp.leftContext); // This isalert(RegExp.rightContext); // ！alert(RegExp.lastMatch); // googlealert(RegExp.lastParen); // galert(RegExp.multiline); // false Opera 不支持 input、lastMatch、lastParen 和 multiline 属性。IE 不支持 multiline 属性。所有的属性可以使用短名来操作。RegExp.input 可以改写成 RegExp['$_']，依次类推。但 RegExp.input 比较特殊，它还可以写成 RegExp.$_。 RegExp 对象的实例属性 属性 含义 global Boolean 值，表示 g 是否已设置 ignoreCase Boolean 值，表示 i 是否已设置 lastIndex 整数，代表下次匹配将从哪里字符位置开始 multiline Boolean 值，表示 m 是否已设置 Source 正则表达式的源字符串形式 // 使用实例属性var pattern = /google/ig;alert(pattern.global); // true，是否全局了alert(pattern.ignoreCase); // true，是否忽略大小写alert(pattern.multiline); // false，是否支持换行alert(pattern.lastIndex); // 0，下次的匹配位置alert(pattern.source); // google，正则表达式的源字符串var pattern = /google/g;var str = 'google google google';pattern.test(str); // google，匹配第一次alert(pattern.lastIndex); // 6，第二次匹配的位 以上基本没什么用。并且 lastIndex 在获取下次匹配位置上 IE 和其他浏览器有偏差 ，主要表现在非全局匹配上。lastIndex 还支持手动设置，直接赋值操作。 获取控制 正则表达式元字符是包含特殊含义的字符。它们有一些特殊功能，可以控制匹配模式的方式。反斜杠后的元字符将失去其特殊含义。 字符类：单个字符和数字 元字符/元符号 匹配情况 . 匹配除换行符外的任意字符 [a-z0-9] 匹配括号中的字符集中的任意字符 [^a-z0-9] 匹配任意不在括号中的字符集中的字符 \d 匹配数字 \D 匹配非数字，同[^0-9]相同 \w 匹配字母和数字及_ \W 匹配非字母和数字及_ 字符类：空白字符 元字符/元符号 匹配情况 \0 匹配 null 字符 \b 匹配空格字符 \f 匹配进纸字符 \n 匹配换行符 \r 匹配回车字符 \t 匹配制表符 \s 匹配空白字符、空格、制表符和换行符 \S 匹配非空白字符 字符类：锚字符 元字符/元符号 匹配情况 ^ 行首匹配 $ 行尾匹配 \A 只有匹配字符串开始处 \b 匹配单词边界，词在[]内时无效 \B 匹配非单词边界 \G 匹配当前搜索的开始位置 \Z 匹配字符串结束处或行尾 \z 只匹配字符串结束处 字符类：重复字符 元字符/元符号 匹配情况 x? 匹配 0 个或 1 个 x x 匹配 0 个或任意多个 x x+ 匹配至少一个 x (xyz)+ 匹配至少一个(xyz) x{m,n} 匹配最少 m 个、最多 n 个 x 字符类：替代字符 元字符/元符号 匹配情况 this where 字符类：记录字符 元字符/元符号 匹配情况 (string) 用于反向引用的分组 \1 或$1 匹配第一个分组中的内容 \2 或$2 匹配第二个分组中的内容 \3 或$3 匹配第三个分组中的内容 // 使用点元字符var pattern = /g..gle/; // .匹配一个任意字符var str = 'google';alert(pattern.test(str));// 重复匹配var pattern = /g.gle/; // .匹配 0 个一个或多个var str = 'google'; //,?,+,{n,m}alert(pattern.test(str));// 使用字符类匹配var pattern = /g[a-zA-Z_]gle/; // [a-z]表示任意个 a-z 中的字符var str = 'google';alert(pattern.test(str));var pattern = /g[^0-9]gle/; // [^0-9]表示任意个非 0-9 的字符var str = 'google';alert(pattern.test(str));var pattern = /[a-z][A-Z]+/; // [A-Z]+表示 A-Z 一次或多次var str = 'gOOGLE';alert(pattern.test(str));// 使用元符号匹配var pattern = /g\wgle/; // \w匹配任意多个所有字母数字_var str = 'google';alert(pattern.test(str));var pattern = /google\d/; // \d匹配任意多个数字var str = 'google444';alert(pattern.test(str));var pattern = /\D{7,}/; // \D{7,}匹配至少 7 个非数字var str = 'google8';alert(pattern.test(str));// 使用锚元字符匹配var pattern = /^google$/; // ^从开头匹配，$从结尾开始匹配var str = 'google';alert(pattern.test(str));var pattern = /goo\sgle/; // \s 可以匹配到空格var str = 'goo gle';alert(pattern.test(str));var pattern = /google\b/; // \b 可以匹配是否到了边界var str = 'google';alert(pattern.test(str));// 使用或模式匹配var pattern = /google|baidu|bing/; // 匹配三种其中一种字符串var str = 'google';alert(pattern.test(str));// 使用分组模式匹配var pattern = /(google){4,8}/; // 匹配分组里的字符串 4-8 次var str = 'googlegoogle';alert(pattern.test(str));var pattern = /8(.)8/; // 获取 8..8 之间的任意字符var str = 'This is 8google8';str.match(pattern);alert(RegExp.$1); // 得到第一个分组里的字符串内容var pattern = /8(.)8/;var str = 'This is 8google8';var result = str.replace(pattern,'<strong>$1</strong>'); // 得到替换的字符串输出document.write(result);var pattern = /(.)\s(.)/;var str = 'google baidu';var result = str.replace(pattern, '$2 $1'); // 将两个分组的值替换输出document.write(result); 贪婪 惰性 + +? ? ?? ? {n} {n}? {n,} {n,}? {n,m} {n,m}? // 关于贪婪和惰性var pattern = /[a-z]+?/; // ?号关闭了贪婪匹配，只替换了第一个var str = 'abcdefjhijklmnopqrstuvwxyz';var result = str.replace(pattern, 'xxx');alert(result);var pattern = /8(.+?)8/g; // 禁止了贪婪，开启的全局var str = 'This is 8google8, That is 8google8, There is 8google8';var result = str.replace(pattern,'<strong>$1</strong>');document.write(result);var pattern = /8([^8])8/g; // 另一种禁止贪婪var str = 'This is 8google8, That is 8google8, There is 8google8';var result = str.replace(pattern,'<strong>$1</strong>');document.write(result);// 使用 exec 返回数组var pattern = /^[a-z]+\s[0-9]{4}$/i;var str = 'google 2012';alert(pattern.exec(str)); // 返回整个字符串var pattern = /^[a-z]+/i; // 只匹配字母var str = 'google 2012';alert(pattern.exec(str)); // 返回 googlevar pattern = /^([a-z]+)\s([0-9]{4})$/i; // 使用分组var str = 'google 2012';alert(pattern.exec(str)[0]); // google 2012alert(pattern.exec(str)[1]); // googlealert(pattern.exec(str)[2]); // 2012// 捕获性分组和非捕获性分组var pattern = /(\d+)([a-z])/; // 捕获性分组var str = '123abc';alert(pattern.exec(str));var pattern = /(\d+)(?:[a-z])/; // 非捕获性分组var str = '123abc';alert(pattern.exec(str));// 使用分组嵌套var pattern = /(A?(B?(C?)))/; // 从外往内获取var str = 'ABC';alert(pattern.exec(str));// 使用前瞻捕获var pattern = /(goo(?=gle))/; // goo 后面必须跟着 gle 才能捕获var str = 'google';alert(pattern.exec(str));// 使用特殊字符匹配var pattern = /\.\[\/b\]/; // 特殊字符，用\符号转义即可var str = '.[/b]';alert(pattern.test(str));// 使用换行模式var pattern = /^\d+/mg; // 启用了换行模式var str = '1.baidu\n2.google\n3.bing';var result = str.replace(pattern, '');alert(result); 常用的正则 检查邮政编码 var pattern = /[1-9][0-9]{5}/; // 共 6 位数字，第一位不能为 0var str = '224000';alert(pattern.test(str)); 检查文件压缩包 var pattern = /[\w]+\.zip|rar|gz/; // \w 表示所有数字和字母加下划线var str = '123.zip'; // \.表示匹配.，后面是一个选择alert(pattern.test(str)); 删除多余空格 var pattern = /\s/g; // g 必须全局，才能全部匹配var str = '111 222 333';var result = str.replace(pattern,''); // 把空格匹配成无空格alert(result); 删除首尾空格 var pattern = /^\s+/; // 强制首var str = ' goo gle ';var result = str.replace(pattern, '');pattern = /\s+$/; // 强制尾result = result.replace(pattern, '');alert('|' + result + '|');var pattern = /^\s(.+?)\s$/; // 使用了非贪婪捕获var str = ' google ';alert('|' + pattern.exec(str)[1] + '|');var pattern = /^\s(.+?)\s$/;var str = ' google ';alert('|' + str.replace(pattern, '$1') + '|'); // 使用了分组获取 简单的电子邮件验证 var pattern = /^([a-zA-Z0-9_\.\-]+)@([a-zA-Z0-9_\.\-]+)\.([a-zA-Z]{2,4})$/;var str = 'yc60.com@gmail.com';alert(pattern.test(str));var pattern = /^([\w\.\-]+)@([\w\.\-]+)\.([\w]{2,4})$/;var str = 'yc60.com@gmail.com';alert(pattern.test(str)); 3、Function类型 在 ECMAScript 中，Function（函数）类型实际上是对象。每个函数都是 Function 类型的实例，而且都与其他引用类型一样具有属性和方法。由于函数是对象，因此函数名实际上也是一个指向函数对象的指针。 函数的声明方式 普通的函数声明 function box(num1, num2) {return num1+ num2;} 使用变量初始化函数 var box= function(num1, num2) {return num1 + num2;}; 使用 Function 构造函数 var box= new Function('num1', 'num2' ,'return num1 + num2'); 第三种方式我们不推荐，因为这种语法会导致解析两次代码（第一次解析常规 ECMAScript 代码，第二次是解析传入构造函数中的字符串），从而影响性能。但我们可以通过这种语法来理解"函数是对象，函数名是指针"的概念。 作为值的函数 ECMAScript 中的函数名本身就是变量，所以函数也可以作为值来使用。也就是说，不仅可以像传递参数一样把一个函数传递给另一个函数，而且可以将一个函数作为另一个函数的结果返回。 function box(sumFunction, num) {return sumFunction(num); // someFunction}function sum(num) {return num + 10;}var result = box(sum, 10); // 传递函数到另一个函数里 函数内部属性 在函数内部，有两个特殊的对象：arguments 和 this。arguments 是一个类数组对象，包含着传入函数中的所有参数，主要用途是保存函数参数。但这个对象还有一个名叫 callee 的属性，该属性是一个指针，指向拥有这个 arguments 对象的函数。 function box(num) {if (num <= 1) {return 1;} else {return num box(num-1); // 一个简单的的递归} } 对于阶乘函数一般要用到递归算法，所以函数内部一定会调用自身；如果函数名不改变是没有问题的，但一旦改变函数名，内部的自身调用需要逐一修改。为了解决这个问题，我们可以使用 arguments.callee 来代替。 function box(num) {if (num <= 1) {return 1;} else {return num arguments.callee(num-1); // 使用 callee 来执行自身} } 函数内部另一个特殊对象是 this，其行为与 Java 和 C中的 this 大致相似。换句话说 ，this 引用的是函数据以执行操作的对象，或者说函数调用语句所处的那个作用域。当在全局作用域中调用函数时，this 对象引用的就是 window。 // 便于理解的改写例子window.color = '红色的'; // 全局的，或者 var color = '红色的';也行alert(this.color); // 打印全局的 colorvar box = {color : '蓝色的', // 局部的 colorsayColor : function () {alert(this.color); // 此时的 this 只能 box 里的 color} };box.sayColor(); // 打印局部的 coloralert(this.color); // 还是全局的// 引用教材的原版例子window.color = '红色的'; // 或者 var color = '红色的';也行var box = {color : '蓝色的'};function sayColor() {alert(this.color); // 这里第一次在外面，第二次在 box 里面}getColor();box.sayColor = sayColor; // 把函数复制到 box 对象里，成为了方法box.sayColor(); 函数属性和方法 ECMAScript 中的函数是对象，因此函数也有属性和方法。每个函数都包含两个属性 ：length 和 prototype。其中，length 属性表示函数希望接收的命名参数的个数。 function box(name, age) {alert(name + age);}alert(box.length); // 2 对于 prototype 属性，它是保存所有实例方法的真正所在，也就是原型。这个属性 ，我们将在面向对象一章详细介绍。而 prototype 下有两个方法：apply()和 call()，每个函数都包含这两个非继承而来的方法。这两个方法的用途都在特定的作用域中调用函数，实际上等于设置函数体内 this 对象的值。 function box(num1, num2) {return num1 + num2; // 原函数}function sayBox(num1, num2) {return box.apply(this, [num1, num2]); // this 表示作用域，这里是 window} // []表示 box 所需要的参数function sayBox2(num1, num2) {return box.apply(this, arguments); // arguments 对象表示 box 所需要的参数}alert(sayBox(10,10)); // 20alert(sayBox2(10,10)); // 20 call()方法于 apply()方法相同，他们的区别仅仅在于接收参数的方式不同。对于 call()方法而言，第一个参数是作用域，没有变化，变化只是其余的参数都是直接传递给函数的。 function box(num1, num2) {return num1 + num2;}function callBox(num1, num2) {return box.call(this, num1, num2); // 和 apply 区别在于后面的传参}alert(callBox(10,10)); 事实上，传递参数并不是 apply()和 call()方法真正的用武之地；它们经常使用的地方是能够扩展函数赖以运行的作用域。 var color = '红色的'; // 或者 window.color = '红色的';也行var box = {color : '蓝色的'};function sayColor() {alert(this.color);}sayColor(); // 作用域在 windowsayColor.call(this); // 作用域在 windowsayColor.call(window); // 作用域在 windowsayColor.call(box); // 作用域在 box，对象冒充 这个例子是之前作用域理解的例子修改而成，我们可以发现当我们使用 call(box)方法的时候，sayColor()方法的运行环境已经变成了 box 对象里了。 使用 call()或者 apply()来扩充作用域的最大好处，就是对象不需要与方法发生任何耦合关系（耦合，就是互相关联的意思，扩展和维护会发生连锁反应）。也就是说，box 对象和 sayColor()方法之间不会有多余的关联操作，比如 box.sayColor = sayColor;。 本篇文章为转载内容。原文链接：https://blog.csdn.net/gongxifacai_believe/article/details/108286196。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...外内存 C和C++有函数可以用 java现在也提供了Unsafe类可以操作堆外内存，具体请参考上一篇博客，总之，JDK1.8只能通过反射来用，JDK1.9以上可以通过new Unsafe对象来用 Unsafe类的方法有： copyMemory():直接访问内存 allocateMemory():直接分配内存，这就必须手动回收内存了 freeMemory():回收内存 下面是一个虚引用例子，自己看吧，懂得自然懂，现在看不懂的，先收藏或者保存上，以后回来看 / 一个对象是否有虚引用的存在，完全不会对其生存时间构成影响， 也无法通过虚引用来获取一个对象的实例。 为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。 虚引用和弱引用对关联对象的回收都不会产生影响，如果只有虚引用活着弱引用关联着对象， 那么这个对象就会被回收。它们的不同之处在于弱引用的get方法，虚引用的get方法始终返回null, 弱引用可以使用ReferenceQueue,虚引用必须配合ReferenceQueue使用。 jdk中直接内存的回收就用到虚引用，由于jvm自动内存管理的范围是堆内存， 而直接内存是在堆内存之外（其实是内存映射文件，自行去理解虚拟内存空间的相关概念）， 所以直接内存的分配和回收都是有Unsafe类去操作，java在申请一块直接内存之后， 会在堆内存分配一个对象保存这个堆外内存的引用， 这个对象被垃圾收集器管理，一旦这个对象被回收， 相应的用户线程会收到通知并对直接内存进行清理工作。 事实上，虚引用有一个很重要的用途就是用来做堆外内存的释放， DirectByteBuffer就是通过虚引用来实现堆外内存的释放的。/import java.lang.ref.PhantomReference;import java.lang.ref.Reference;import java.lang.ref.ReferenceQueue;import java.util.LinkedList;import java.util.List;public class T04_PhantomReference {private static final List<Object> LIST = new LinkedList<>();private static final ReferenceQueue<M> QUEUE = new ReferenceQueue<>();public static void main(String[] args) {PhantomReference<M> phantomReference = new PhantomReference<>(new M(), QUEUE);new Thread(() -> {while (true) {LIST.add(new byte[1024 1024]);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();Thread.currentThread().interrupt();}System.out.println(phantomReference.get());} }).start();new Thread(() -> {while (true) {Reference<? extends M> poll = QUEUE.poll();if (poll != null) {System.out.println("--- 虚引用对象被jvm回收了 ---- " + poll);} }}).start();try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();} }} 2、容器 1、发展历史(一定要了解) map容器你需要了解的历史 JDK早期，java提供了Vector和Hashtable两个容器，这两个容器，很多操作都加了锁Synchronized，对于某些不需要用锁的情况下，就显得十分影响性能，所以现在基本没人用这两个容器，但是面试经常问这两个容器里面的数据结构等内容 后来，出现了HashMap，此容器完全不加锁，是用的最多的容器 但是完全不加锁未免不完善，所以java提供了如下方式，将HashMap变为加锁的 //通过Collections.synchronizedMap(HashMap)方法，将其变为加锁Map集合，其中泛型随意，UUID只是举例。static Map<UUID, UUID> m = Collections.synchronizedMap(new HashMap<UUID, UUID>()); 通过阅读源码发现，上面方法将HashMap变为加锁，也是使用Synchronized，只是锁的内容更细，但并不比HashTable效率高多少 所以衍生除了新的容器ConcurrentHashMap ConcurrentHashMap 此容器，插入效率不如上面的，因为它做了各种判断和CAS，但是差距不是特别大 读取效率很高，100个线程同时访问，每个线程读取一百万次实测 Hashtable 39s ，SynchronizedHashMap 38s ，ConcurrentHashMap 1.7s 前两个将近40秒，ConcurrentHashMap只需要不到2s，由此可见此容器读取效率极高 2、为什么推荐使用Queue来做高并发 为什么推荐Queue（队列） Queue接口提供了很多针对多线程非常友好的API（offer ，peek和poll，其中BlockingQueue还添加了put和take可以阻塞），可以说专门为多线程高并发而创造的接口，所以一般我们使用Queue而不用List 以下代码分别使用链表LinkList和ConcurrentQueue，对比一下速度 LinkList用了5s多，ConcurrentQueue几乎瞬间完成 Concurrent接口就是专为多线程设计，多线程设计要多考虑Queue(高并发用)的使用，少使用List / 有N张火车票，每张票都有一个编号 同时有10个窗口对外售票 请写一个模拟程序 分析下面的程序可能会产生哪些问题？ 重复销售？超量销售？ 使用Vector或者Collections.synchronizedXXX 分析一下，这样能解决问题吗？ 就算操作A和B都是同步的，但A和B组成的复合操作也未必是同步的，仍然需要自己进行同步 就像这个程序，判断size和进行remove必须是一整个的原子操作 @author 马士兵/import java.util.LinkedList;import java.util.List;import java.util.concurrent.TimeUnit;public class TicketSeller3 {static List<String> tickets = new LinkedList<>();static {for(int i=0; i<1000; i++) tickets.add("票 编号：" + i);}public static void main(String[] args) {for(int i=0; i<10; i++) {new Thread(()->{while(true) {synchronized(tickets) {if(tickets.size() <= 0) break;try {TimeUnit.MILLISECONDS.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("销售了--" + tickets.remove(0));} }}).start();} }} 队列 import java.util.Queue;import java.util.concurrent.ConcurrentLinkedQueue;public class TicketSeller4 {static Queue<String> tickets = new ConcurrentLinkedQueue<>();static {for(int i=0; i<1000; i++) tickets.add("票 编号：" + i);}public static void main(String[] args) {for(int i=0; i<10; i++) {new Thread(()->{while(true) {String s = tickets.poll();if(s == null) break;else System.out.println("销售了--" + s);} }).start();} }} 3、多线程常用容器 1、ConcurrentHashMap(无序)和ConcurrentSkipListMap(有序，链表，使用跳表数据结构，让查询更快) 跳表：http://blog.csdn.net/sunxianghuang/article/details/52221913 import java.util.;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ConcurrentSkipListMap;import java.util.concurrent.CountDownLatch;public class T01_ConcurrentMap {public static void main(String[] args) {Map<String, String> map = new ConcurrentHashMap<>();//Map<String, String> map = new ConcurrentSkipListMap<>(); //高并发并且排序//Map<String, String> map = new Hashtable<>();//Map<String, String> map = new HashMap<>(); //Collections.synchronizedXXX//TreeMapRandom r = new Random();Thread[] ths = new Thread[100];CountDownLatch latch = new CountDownLatch(ths.length);long start = System.currentTimeMillis();for(int i=0; i<ths.length; i++) {ths[i] = new Thread(()->{for(int j=0; j<10000; j++) map.put("a" + r.nextInt(100000), "a" + r.nextInt(100000));latch.countDown();});}Arrays.asList(ths).forEach(t->t.start());try {latch.await();} catch (InterruptedException e) {e.printStackTrace();}long end = System.currentTimeMillis();System.out.println(end - start);System.out.println(map.size());} } 2、CopyOnWriteList（写时复制）和CopyOnWriteSet 适用于，高并发是，读的多，写的少的情况 当我们写的时候，将容器复制，让写线程去复制的线程写（写的时候加锁） 而读线程依旧去读旧的(读的时候不加锁) 当写完，将对象指向复制后的已经写完的容器，原来容器销毁 大大提高读的效率 / 写时复制容器 copy on write 多线程环境下，写时效率低，读时效率高 适合写少读多的环境 @author 马士兵/import java.util.ArrayList;import java.util.Arrays;import java.util.List;import java.util.Random;import java.util.Vector;import java.util.concurrent.CopyOnWriteArrayList;public class T02_CopyOnWriteList {public static void main(String[] args) {List<String> lists = //new ArrayList<>(); //这个会出并发问题！//new Vector();new CopyOnWriteArrayList<>();Random r = new Random();Thread[] ths = new Thread[100];for(int i=0; i<ths.length; i++) {Runnable task = new Runnable() {@Overridepublic void run() {for(int i=0; i<1000; i++) lists.add("a" + r.nextInt(10000));} };ths[i] = new Thread(task);}runAndComputeTime(ths);System.out.println(lists.size());}static void runAndComputeTime(Thread[] ths) {long s1 = System.currentTimeMillis();Arrays.asList(ths).forEach(t->t.start());Arrays.asList(ths).forEach(t->{try {t.join();} catch (InterruptedException e) {e.printStackTrace();} });long s2 = System.currentTimeMillis();System.out.println(s2 - s1);} } 3、synchronizedList和ConcurrentLinkedQueue package com.mashibing.juc.c_025;import java.util.ArrayList;import java.util.Collections;import java.util.List;import java.util.Queue;import java.util.concurrent.ConcurrentLinkedQueue;public class T04_ConcurrentQueue {public static void main(String[] args) {List<String> strsList = new ArrayList<>();List<String> strsSync = Collections.synchronizedList(strsList);//加锁ListQueue<String> strs = new ConcurrentLinkedQueue<>();//Concurrent链表队列，就是读快for(int i=0; i<10; i++) {strs.offer("a" + i); //add添加，但是不同点是，此方法会返回一个布尔值}System.out.println(strs);System.out.println(strs.size());System.out.println(strs.poll());//取出，取完后将元素去除System.out.println(strs.size());System.out.println(strs.peek());//取出，但是不会将元素从队列删除System.out.println(strs.size());//双端队列Deque} } 4、LinkedBlockingQueue 链表阻塞队列（无界链表，可以一直装东西，直到内存满（其实，也不是无限，其长度Integer.MaxValue就是上限，毕竟最大就这么大）） 主要体现在put和take方法，put添加的时候，如果队列满了，就阻塞当前线程，直到队列有空位，继续插入。take方法取的时候，如果没有值，就阻塞，等有值了，立马去取 import java.util.Random;import java.util.concurrent.BlockingQueue;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.TimeUnit;public class T05_LinkedBlockingQueue {static BlockingQueue<String> strs = new LinkedBlockingQueue<>();static Random r = new Random();public static void main(String[] args) {new Thread(() -> {for (int i = 0; i < 100; i++) {try {strs.put("a" + i); //如果满了，当前线程就会等待（实现阻塞），等多会有空位，将值插入TimeUnit.MILLISECONDS.sleep(r.nextInt(1000));} catch (InterruptedException e) {e.printStackTrace();} }}, "p1").start();for (int i = 0; i < 5; i++) {new Thread(() -> {for (;;) {try {System.out.println(Thread.currentThread().getName() + " take -" + strs.take()); //取内容，如果空了，当前线程就会等待（实现阻塞）} catch (InterruptedException e) {e.printStackTrace();} }}, "c" + i).start();} }} 5、ArrayBlockingQueue 有界阻塞队列（因为Array需要指定长度） import java.util.Random;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.BlockingQueue;import java.util.concurrent.TimeUnit;public class T06_ArrayBlockingQueue {static BlockingQueue<String> strs = new ArrayBlockingQueue<>(10);static Random r = new Random();public static void main(String[] args) throws InterruptedException {for (int i = 0; i < 10; i++) {strs.put("a" + i);}//strs.put("aaa"); //满了就会等待，程序阻塞//strs.add("aaa");//strs.offer("aaa");strs.offer("aaa", 1, TimeUnit.SECONDS);System.out.println(strs);} } 6、特殊的阻塞队列1：DelayQueue 延时队列（按时间进行调度，就是隔多长时间运行，谁隔的少，谁先） 以下例子中，我们添加线程到队列顺序为t12345，正常情况下，会按照顺序运行，但是这里有了延时时间，也就是时间越短，越先执行 步骤很简单，拿到延时队列 指定构造方法 继承 implements Delayed 重写 compareTo和getDelay import java.util.Calendar;import java.util.Random;import java.util.concurrent.BlockingQueue;import java.util.concurrent.DelayQueue;import java.util.concurrent.Delayed;import java.util.concurrent.TimeUnit;public class T07_DelayQueue {static BlockingQueue<MyTask> tasks = new DelayQueue<>();static Random r = new Random();static class MyTask implements Delayed {String name;long runningTime;MyTask(String name, long rt) {this.name = name;this.runningTime = rt;}@Overridepublic int compareTo(Delayed o) {if(this.getDelay(TimeUnit.MILLISECONDS) < o.getDelay(TimeUnit.MILLISECONDS))return -1;else if(this.getDelay(TimeUnit.MILLISECONDS) > o.getDelay(TimeUnit.MILLISECONDS)) return 1;else return 0;}@Overridepublic long getDelay(TimeUnit unit) {return unit.convert(runningTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);}@Overridepublic String toString() {return name + " " + runningTime;} }public static void main(String[] args) throws InterruptedException {long now = System.currentTimeMillis();MyTask t1 = new MyTask("t1", now + 1000);MyTask t2 = new MyTask("t2", now + 2000);MyTask t3 = new MyTask("t3", now + 1500);MyTask t4 = new MyTask("t4", now + 2500);MyTask t5 = new MyTask("t5", now + 500);tasks.put(t1);tasks.put(t2);tasks.put(t3);tasks.put(t4);tasks.put(t5);System.out.println(tasks);for(int i=0; i<5; i++) {System.out.println(tasks.take());//获取的是toString方法返回值} }} 7、特殊的阻塞队列2：PriorityQueque 优先队列（二叉树算法，就是排序） import java.util.PriorityQueue;public class T07_01_PriorityQueque {public static void main(String[] args) {PriorityQueue<String> q = new PriorityQueue<>();q.add("c");q.add("e");q.add("a");q.add("d");q.add("z");for (int i = 0; i < 5; i++) {System.out.println(q.poll());} }} 8、特殊的阻塞队列3：SynchronusQueue 同步队列(线程池用处非常大) 此队列容量为0，当插入元素时，必须同时有个线程往外取 就是说，当你往这个队列里面插入一个元素，它就拿着这个元素站着(阻塞)，直到有个取元素的线程来，它就把元素交给它 就是用来同步数据的，也就是线程间交互数据用的一个特殊队列 package com.mashibing.juc.c_025;import java.util.concurrent.BlockingQueue;import java.util.concurrent.SynchronousQueue;public class T08_SynchronusQueue { //容量为0public static void main(String[] args) throws InterruptedException {BlockingQueue<String> strs = new SynchronousQueue<>();new Thread(()->{//这个线程就是消费者，来取值try {System.out.println(strs.take());//和同步队列要值} catch (InterruptedException e) {e.printStackTrace();} }).start();strs.put("aaa"); //阻塞等待消费者消费，就拿着aaa站着，等线程来取//strs.put("bbb");//strs.add("aaa");System.out.println(strs.size());} } 9、特殊的阻塞队列4：TransferQueue 传递队列 此队列加入了一个方法transfer()用来向队列添加元素 但是和put()方法不同的是，put添加完元素就走了 而这个方法，添加完自己就阻塞了，直到有人将这个元素取走，它才继续工作(省去我们手动阻塞) import java.util.concurrent.LinkedTransferQueue;public class T09_TransferQueue {public static void main(String[] args) throws InterruptedException {LinkedTransferQueue<String> strs = new LinkedTransferQueue<>();new Thread(() -> {try {System.out.println(strs.take());} catch (InterruptedException e) {e.printStackTrace();} }).start();strs.transfer("aaa");//放东西到队列，同时阻塞等待消费者线程，取走元素//strs.put("aaa");//如果用put就和普通队列一样，放完东西就走了/new Thread(() -> {try {System.out.println(strs.take());} catch (InterruptedException e) {e.printStackTrace();} }).start();/} } 3、线程池 线程池 由于单独创建线程，十分影响效率，而且无法对线程集中管理，一旦疏落，可能线程无限执行，浪费资源 线程池就是一个存储线程的游泳池，而每个线程就是池子里面的赛道 池子里的线程不执行任何任务，只是提供一个资源 而谁提交了任务，比如我想来游泳，那么池子就给你一个赛道，让你游泳 比如它想练憋气，那么给它一个赛道练憋气 当他们用完，走了，那么后面其它人再过来继续用 这就是线程池，始终只有这几个线程，不做实现，而是借用这几个线程的用户，自己掌控用这些线程资源做什么（提交任务给线程,线程空闲就帮他们完成任务） 线程池的两种类型（两类，不是两个） ThreadPoolExecutor（简称TPE） ForkJoinPool（分解汇总任务(将任务细化，最后汇总结果)，少量线程执行多个任务（子任务，TPE做不到先执行子任务），CPU密集型） Executors（注意这后面有s） 它可以说是线程池工厂类，我们一般通过它创建线程池，并且它为我们封装了线程 1、常用类 Executor ExecutorService 扩展了execute方法，具有一个返回值 规定了异步执行机制，提供了一些执行器方法，比如shutdown()关闭等 但是它不知道执行器中的线程何时执行完 Callable 对Runnable进行了扩展,实现Callable的调用，可以有返回值，表示线程的状态 但是无法返回线程执行结果 Future 获得未来线程执行结果 由此，我们可以得知线程池基本的一个使用步骤 其中service.submit（）:为异步提交，也就是说，主线程该干嘛干嘛，我是异步执行的，和同步不一样（当前线程执行完，主线程才能继续执行，叫同步） futuer.get():获取结果集结果，此时因为异步，主线程执行到这里，结果集可能还没封装好，所以此时如果没有值，就阻塞，直到结果集出来 public static void main(String[] args) throws ExecutionException, InterruptedException {Callable<String> c = new Callable() {@Overridepublic String call() throws Exception {return "Hello Callable";} };ExecutorService service = Executors.newCachedThreadPool();Future<String> future = service.submit(c); //异步System.out.println(future.get());//阻塞service.shutdown();} 2、FutureTask 可充当任务的结果集 上面我们介绍Future是用来得到任务的执行结果的 而FutureTask，可以当做一个任务用，并且返回任务的结果，也就是可以跑线程，然后还可以得到线程结果 public static void main(String[] args) throws InterruptedException, ExecutionException {FutureTask<Integer> task = new FutureTask<>(()->{TimeUnit.MILLISECONDS.sleep(500);return 1000;}); //new Callable () { Integer call();}new Thread(task).start();System.out.println(task.get()); //阻塞} 3、CompletableFuture 非常灵活的任务结果集 一个非常灵活的结果集 他可以将很多执行不同任务的线程的结果进行汇总 比如一个网站，它可以启动多个线程去各大电商网站，比如淘宝，京东，收集某些或某一个商品的价格 最后，将获取的数据进行整合封装 最终，客户就可以通过此网站，获取某类商品在各网站的价格信息 / 假设你能够提供一个服务 这个服务查询各大电商网站同一类产品的价格并汇总展示 @author 马士兵 http://mashibing.com/import java.io.IOException;import java.util.Random;import java.util.concurrent.CompletableFuture;import java.util.concurrent.ExecutionException;import java.util.concurrent.TimeUnit;public class T06_01_CompletableFuture {public static void main(String[] args) throws ExecutionException, InterruptedException {long start, end;/start = System.currentTimeMillis();priceOfTM();priceOfTB();priceOfJD();end = System.currentTimeMillis();System.out.println("use serial method call! " + (end - start));/start = System.currentTimeMillis();CompletableFuture<Double> futureTM = CompletableFuture.supplyAsync(()->priceOfTM());CompletableFuture<Double> futureTB = CompletableFuture.supplyAsync(()->priceOfTB());CompletableFuture<Double> futureJD = CompletableFuture.supplyAsync(()->priceOfJD());CompletableFuture.allOf(futureTM, futureTB, futureJD).join();//当所有结果集都获取到，才汇总阻塞CompletableFuture.supplyAsync(()->priceOfTM()).thenApply(String::valueOf).thenApply(str-> "price " + str).thenAccept(System.out::println);end = System.currentTimeMillis();System.out.println("use completable future! " + (end - start));try {System.in.read();} catch (IOException e) {e.printStackTrace();} }private static double priceOfTM() {delay();return 1.00;}private static double priceOfTB() {delay();return 2.00;}private static double priceOfJD() {delay();return 3.00;}/private static double priceOfAmazon() {delay();throw new RuntimeException("product not exist!");}/private static void delay() {int time = new Random().nextInt(500);try {TimeUnit.MILLISECONDS.sleep(time);} catch (InterruptedException e) {e.printStackTrace();}System.out.printf("After %s sleep!\n", time);} } 4、TPE型线程池1：ThreadPoolExecutor 原理及其参数 线程池由两个集合组成，一个集合存储线程，一个集合存储任务 存储线程：可以规定大小，最多可以有多少个，以及指定核心线程数量（不会被回收） 任务队列：存储任务 细节：初始线程池没有线程，当有一个任务来，线程池起一个线程，又有一个任务来，再起一个线程，直到达到核心线程数量 核心线程数量达到时，新来的任务将存储到任务队列中等待核心线程处理完成，直到任务队列也满了 当任务队列满了，此时再次启动一个线程（非核心线程，一旦空闲，达到指定时间将会消失），直到达到线程最大数量 当线程容器和任务容器都满了，又来了线程，将会执行拒绝策略 上面的细节涉及的所有步骤内容，均由创建线程池的参数执行 下面是ThreadPoolExecutor构造方法参数的源码注释 / 用给定的初始值，创建一个新的线程池 @param corePoolSize 核心线程数量 @param maximumPoolSize 最大线程数量 @param keepAliveTime 当线程数大于核心线程数量时，空闲的线程可生存的时间 @param unit 时间单位 @param workQueue 任务队列，只能包含由execute提交的Runnable任务 @param threadFactory 工厂，用于创建线程给线程池调度的工厂，可以自定义 @param handler 拒绝策略(可以自定义，JDK默认提供4种)，当线程边界和队列容量已经满了，新来线程被阻塞时使用的处理程序/public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) JDK提供的4种拒绝策略，不常用，一般都是自己定义拒绝策略 Abort：抛异常 Discard：扔掉，不抛异常 DiscardOldest：扔掉排队时间最久的（将队列中排队时间最久的扔掉，然后让新来的进来） CallerRuns：调用者处理任务（谁通过execute方法提交任务，谁处理） ThreadPoolExecutor继承关系 继承关系：ThreadPoolExecutor->AbstractExectorService类->ExectorService接口->Exector接口 Executors（注意这后面有s） 它可以说是线程池工厂类，我们一般通过它创建线程池，并且它为我们封装了线程 看看下面创建线程池，哪里用到了它 使用实例 import java.io.IOException;import java.util.concurrent.;public class T05_00_HelloThreadPool {static class Task implements Runnable {private int i;public Task(int i) {this.i = i;}@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + " Task " + i);try {System.in.read();} catch (IOException e) {e.printStackTrace();} }@Overridepublic String toString() {return "Task{" +"i=" + i +'}';} }public static void main(String[] args) {ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 4,60, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(4),Executors.defaultThreadFactory(),new ThreadPoolExecutor.CallerRunsPolicy());//创建线程池，核心2个，最大4个，空闲线程存活时间60s，任务队列容量4，使用默认线程工程，创建线程。拒绝策略是JDK提供的for (int i = 0; i < 8; i++) {tpe.execute(new Task(i));//供提交8次任务}System.out.println(tpe.getQueue());//查看任务队列tpe.execute(new Task(100));//提交新的任务System.out.println(tpe.getQueue());tpe.shutdown();//关闭线程池} } 5、TPE型线程池2：SingleThreadPool 单例线程池(只有一个线程) 为什么有单例线程池 有任务队列，有线程池管理机制 Executors（注意这后面有s） 它可以说是线程池工厂类，我们一般通过它创建线程池，并且它为我们封装了线程 看看下面哪里用到了它 /创建单例线程池，扔5个任务进去，查看输出结果，看看有几个线程执行任务/import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class T07_SingleThreadPool {public static void main(String[] args) {ExecutorService service = Executors.newSingleThreadExecutor();for(int i=0; i<5; i++) {final int j = i;service.execute(()->{System.out.println(j + " " + Thread.currentThread().getName());});} }} 6、TPE型线程池3：CachedPool 缓存，存储线程池 此线程池没有核心线程，来一个任务启动一个线程（最多Integer.MaxValue，不会放在任务队列，因为任务队列容量为0），每个线程空闲后，只能活60s 实例 import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class T07_SingleThreadPool {public static void main(String[] args) {ExecutorService service = Executors.newSingleThreadExecutor();//通过Executors获取池子for(int i=0; i<5; i++) {final int j = i;service.execute(()->{//提交任务System.out.println(j + " " + Thread.currentThread().getName());});}service.shutdown();} } 7、TPE型线程池4：FixedThreadPool 固定线程池 此线次池，用于创建一个固定线程数量的线程池，不会回收 实例 import java.util.ArrayList;import java.util.List;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;public class T09_FixedThreadPool {public static void main(String[] args) throws InterruptedException, ExecutionException {//并发执行long start = System.currentTimeMillis();getPrime(1, 200000); long end = System.currentTimeMillis();System.out.println(end - start);//输出并发执行耗费时间final int cpuCoreNum = 4;//并行执行ExecutorService service = Executors.newFixedThreadPool(cpuCoreNum);MyTask t1 = new MyTask(1, 80000); //1-5 5-10 10-15 15-20MyTask t2 = new MyTask(80001, 130000);MyTask t3 = new MyTask(130001, 170000);MyTask t4 = new MyTask(170001, 200000);Future<List<Integer>> f1 = service.submit(t1);Future<List<Integer>> f2 = service.submit(t2);Future<List<Integer>> f3 = service.submit(t3);Future<List<Integer>> f4 = service.submit(t4);start = System.currentTimeMillis();f1.get();f2.get();f3.get();f4.get();end = System.currentTimeMillis();System.out.println(end - start);//输出并行耗费时间}static class MyTask implements Callable<List<Integer>> {int startPos, endPos;MyTask(int s, int e) {this.startPos = s;this.endPos = e;}@Overridepublic List<Integer> call() throws Exception {List<Integer> r = getPrime(startPos, endPos);return r;} }static boolean isPrime(int num) {for(int i=2; i<=num/2; i++) {if(num % i == 0) return false;}return true;}static List<Integer> getPrime(int start, int end) {List<Integer> results = new ArrayList<>();for(int i=start; i<=end; i++) {if(isPrime(i)) results.add(i);}return results;} } 8、TPE型线程池5：ScheduledPool 预定，延时线程池 根据延时时间（隔多长时间后运行），排序，哪个线程先执行,用户只需要指定核心线程数量 此线程池返回的池对象，和提交任务方法都不一样，比较涉及到时间 import java.util.Random;import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.TimeUnit;public class T10_ScheduledPool {public static void main(String[] args) {ScheduledExecutorService service = Executors.newScheduledThreadPool(4);service.scheduleAtFixedRate(()->{//提交延时任务try {TimeUnit.MILLISECONDS.sleep(new Random().nextInt(1000));} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName());}, 0, 500, TimeUnit.MILLISECONDS);//指定延时时间和单位，第一个任务延时0毫秒，之后的任务，延时500毫秒} } 9、手写拒绝策略小例子 import java.util.concurrent.;public class T14_MyRejectedHandler {public static void main(String[] args) {ExecutorService service = new ThreadPoolExecutor(4, 4,0, TimeUnit.SECONDS, new ArrayBlockingQueue<>(6),Executors.defaultThreadFactory(),new MyHandler());//将手写拒绝策略传入}static class MyHandler implements RejectedExecutionHandler {//1、继承RejectedExecutionHandler@Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {//2、重写方法//log("r rejected")//伪代码，表示通过log4j.log()报一下日志，拒绝的时间，线程名//save r kafka mysql redis//可以尝试保存队列//try 3 times //可以尝试几次，比如3次，重新去抢队列，3次还不行就丢弃if(executor.getQueue().size() < 10000) {//尝试条件，如果size>10000了,就执行拒绝策略//try put again();//如果小于10000，尝试将其放到队列中} }} } 10、ForkJoinPool线程池1：ForkJoinPool 前面我们讲过线程分为两大类，TPE和FJP ForkJoinPool（分解汇总任务(将任务细化，最后汇总结果)，少量线程执行多个任务（子任务，TPE做不到先执行子任务），CPU密集型） 适合将大任务切分成多个小任务运行 两个方法，fork()：分子任务，将子任务分配到线程池中 join()：当前任务的计算结果，如果有子任务，等子任务结果返回后再汇总 下面实例实现，一百万个随机数求和，由两种方法实现，一种ForkJoinPool分任务并行，一种使用单线程做 import java.io.IOException;import java.util.Arrays;import java.util.Random;import java.util.concurrent.ForkJoinPool;import java.util.concurrent.RecursiveAction;import java.util.concurrent.RecursiveTask;public class T12_ForkJoinPool {//1000000个随机数求和static int[] nums = new int[1000000];//一堆数static final int MAX_NUM = 50000;//分任务时，每个任务的操作量不能多于50000个，否则就继续细分static Random r = new Random();//使用随机数将数组初始化static {for(int i=0; i<nums.length; i++) {nums[i] = r.nextInt(100);}System.out.println("---" + Arrays.stream(nums).sum()); //stream api 单线程就这么做，一个一个加}//分任务，需要继承，可以继承RecursiveAction(不需要返回值，一般用在不需要返回值的场景)或//RecursiveTask(需要返回值，我们用这个，因为我们需要最后获取求和结果)两个更好实现的类，//他俩继承与ForkJoinTaskstatic class AddTaskRet extends RecursiveTask<Long> {private static final long serialVersionUID = 1L;int start, end;AddTaskRet(int s, int e) {start = s;end = e;}@Overrideprotected Long compute() {if(end-start <= MAX_NUM) {//如果任务操作数小于规定的最大操作数，就进行运算，long sum = 0L;for(int i=start; i<end; i++) sum += nums[i];return sum;//返回结果} //如果分配的操作数大于规定，就继续细分（简单的重中点分，两半）int middle = start + (end-start)/2;//获取中间值AddTaskRet subTask1 = new AddTaskRet(start, middle);//传入起始值和中间值，表示一个子任务AddTaskRet subTask2 = new AddTaskRet(middle, end);//中间值和结尾值，表示一个子任务subTask1.fork();//分任务subTask2.fork();//分任务return subTask1.join() + subTask2.join();//最后返回结果汇总} }public static void main(String[] args) throws IOException {/ForkJoinPool fjp = new ForkJoinPool();AddTask task = new AddTask(0, nums.length);fjp.execute(task);/ForkJoinPool fjp = new ForkJoinPool();//创建线程池AddTaskRet task = new AddTaskRet(0, nums.length);//创建任务fjp.execute(task);//传入任务long result = task.join();//返回汇总结果System.out.println(result);//System.in.read();} } 11、ForkJoinPool线程池2：WorkStealingPool 任务偷取线程池 原来的线程池，都是有一个任务队列，而这个不同，它给每个线程都分配了一个任务队列 当某一个线程的任务队列没有任务，并且自己空闲，它就去其它线程的任务队列中偷任务，所以叫任务偷取线程池 细节：当线程自己从自己的任务队列拿任务时，不需要加锁，但是偷任务时，因为有两个线程，可能发生同步问题，需要加锁 此线程继承FJP 实例 import java.io.IOException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;public class T11_WorkStealingPool {public static void main(String[] args) throws IOException {ExecutorService service = Executors.newWorkStealingPool();System.out.println(Runtime.getRuntime().availableProcessors());service.execute(new R(1000));service.execute(new R(2000));service.execute(new R(2000));service.execute(new R(2000)); //daemonservice.execute(new R(2000));//由于产生的是精灵线程（守护线程、后台线程），主线程不阻塞的话，看不到输出System.in.read(); }static class R implements Runnable {int time;R(int t) {this.time = t;}@Overridepublic void run() {try {TimeUnit.MILLISECONDS.sleep(time);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(time + " " + Thread.currentThread().getName());} }} 12、流式API：ParallelStreamAPI 不懂的请参考：https://blog.csdn.net/grd_java/article/details/110265219 实例 import java.util.ArrayList;import java.util.List;import java.util.Random;public class T13_ParallelStreamAPI {public static void main(String[] args) {List<Integer> nums = new ArrayList<>();Random r = new Random();for(int i=0; i<10000; i++) nums.add(1000000 + r.nextInt(1000000));//System.out.println(nums);long start = System.currentTimeMillis();nums.forEach(v->isPrime(v));long end = System.currentTimeMillis();System.out.println(end - start);//使用parallel stream apistart = System.currentTimeMillis();nums.parallelStream().forEach(T13_ParallelStreamAPI::isPrime);//并行流，将任务切分成子任务执行end = System.currentTimeMillis();System.out.println(end - start);}static boolean isPrime(int num) {for(int i=2; i<=num/2; i++) {if(num % i == 0) return false;}return true;} } 13、总结 总结 Callable相当于一Runnable但是它有返回值 Future：存储执行完产生的结果 FutureTask 相当于Future+Runnable，既可以执行任务，又能获取任务执行的Future结果 CompletableFuture 可以多任务异步，并对多任务控制，整合任务结果，细化完美，比如可以一个任务完成就可以整合结果，也可以所有任务完成才整合结果 4、ThreadPoolExecutor源码解析 依然只讲重点，实际还需要大家按照上篇博客中看源码的方式来看 1、常用变量的解释 // 1. ctl，可以看做一个int类型的数字，高3位表示线程池状态，低29位表示worker数量private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));// 2. COUNT_BITS，Integer.SIZE为32，所以COUNT_BITS为29private static final int COUNT_BITS = Integer.SIZE - 3;// 3. CAPACITY，线程池允许的最大线程数。1左移29位，然后减1，即为 2^29 - 1private static final int CAPACITY = (1 << COUNT_BITS) - 1;// runState is stored in the high-order bits// 4. 线程池有5种状态，按大小排序如下：RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATEDprivate static final int RUNNING = -1 << COUNT_BITS;private static final int SHUTDOWN = 0 << COUNT_BITS;private static final int STOP = 1 << COUNT_BITS;private static final int TIDYING = 2 << COUNT_BITS;private static final int TERMINATED = 3 << COUNT_BITS;// Packing and unpacking ctl// 5. runStateOf()，获取线程池状态，通过按位与操作，低29位将全部变成0private static int runStateOf(int c) { return c & ~CAPACITY; }// 6. workerCountOf()，获取线程池worker数量，通过按位与操作，高3位将全部变成0private static int workerCountOf(int c) { return c & CAPACITY; }// 7. ctlOf()，根据线程池状态和线程池worker数量，生成ctl值private static int ctlOf(int rs, int wc) { return rs | wc; }/ Bit field accessors that don't require unpacking ctl. These depend on the bit layout and on workerCount being never negative./// 8. runStateLessThan()，线程池状态小于xxprivate static boolean runStateLessThan(int c, int s) {return c < s;}// 9. runStateAtLeast()，线程池状态大于等于xxprivate static boolean runStateAtLeast(int c, int s) {return c >= s;} 2、构造方法 public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) {// 基本类型参数校验if (corePoolSize < 0 ||maximumPoolSize <= 0 ||maximumPoolSize < corePoolSize ||keepAliveTime < 0)throw new IllegalArgumentException();// 空指针校验if (workQueue == null || threadFactory == null || handler == null)throw new NullPointerException();this.corePoolSize = corePoolSize;this.maximumPoolSize = maximumPoolSize;this.workQueue = workQueue;// 根据传入参数unit和keepAliveTime，将存活时间转换为纳秒存到变量keepAliveTime 中this.keepAliveTime = unit.toNanos(keepAliveTime);this.threadFactory = threadFactory;this.handler = handler;} 3、提交执行task的过程 public void execute(Runnable command) {if (command == null)throw new NullPointerException();/ Proceed in 3 steps: 1. If fewer than corePoolSize threads are running, try to start a new thread with the given command as its first task. The call to addWorker atomically checks runState and workerCount, and so prevents false alarms that would add threads when it shouldn't, by returning false. 2. If a task can be successfully queued, then we still need to double-check whether we should have added a thread (because existing ones died since last checking) or that the pool shut down since entry into this method. So we recheck state and if necessary roll back the enqueuing if stopped, or start a new thread if there are none. 3. If we cannot queue task, then we try to add a new thread. If it fails, we know we are shut down or saturated and so reject the task./int c = ctl.get();// worker数量比核心线程数小，直接创建worker执行任务if (workerCountOf(c) < corePoolSize) {if (addWorker(command, true))return;c = ctl.get();}// worker数量超过核心线程数，任务直接进入队列if (isRunning(c) && workQueue.offer(command)) {int recheck = ctl.get();// 线程池状态不是RUNNING状态，说明执行过shutdown命令，需要对新加入的任务执行reject()操作。// 这儿为什么需要recheck，是因为任务入队列前后，线程池的状态可能会发生变化。if (! isRunning(recheck) && remove(command))reject(command);// 这儿为什么需要判断0值，主要是在线程池构造方法中，核心线程数允许为0else if (workerCountOf(recheck) == 0)addWorker(null, false);}// 如果线程池不是运行状态，或者任务进入队列失败，则尝试创建worker执行任务。// 这儿有3点需要注意：// 1. 线程池不是运行状态时，addWorker内部会判断线程池状态// 2. addWorker第2个参数表示是否创建核心线程// 3. addWorker返回false，则说明任务执行失败，需要执行reject操作else if (!addWorker(command, false))reject(command);} 4、addworker源码解析 private boolean addWorker(Runnable firstTask, boolean core) {retry:// 外层自旋for (;;) {int c = ctl.get();int rs = runStateOf(c);// 这个条件写得比较难懂，我对其进行了调整，和下面的条件等价// (rs > SHUTDOWN) || // (rs == SHUTDOWN && firstTask != null) || // (rs == SHUTDOWN && workQueue.isEmpty())// 1. 线程池状态大于SHUTDOWN时，直接返回false// 2. 线程池状态等于SHUTDOWN，且firstTask不为null，直接返回false// 3. 线程池状态等于SHUTDOWN，且队列为空，直接返回false// Check if queue empty only if necessary.if (rs >= SHUTDOWN &&! (rs == SHUTDOWN &&firstTask == null &&! workQueue.isEmpty()))return false;// 内层自旋for (;;) {int wc = workerCountOf(c);// worker数量超过容量，直接返回falseif (wc >= CAPACITY ||wc >= (core ? corePoolSize : maximumPoolSize))return false;// 使用CAS的方式增加worker数量。// 若增加成功，则直接跳出外层循环进入到第二部分if (compareAndIncrementWorkerCount(c))break retry;c = ctl.get(); // Re-read ctl// 线程池状态发生变化，对外层循环进行自旋if (runStateOf(c) != rs)continue retry;// 其他情况，直接内层循环进行自旋即可// else CAS failed due to workerCount change; retry inner loop} }boolean workerStarted = false;boolean workerAdded = false;Worker w = null;try {w = new Worker(firstTask);final Thread t = w.thread;if (t != null) {final ReentrantLock mainLock = this.mainLock;// worker的添加必须是串行的，因此需要加锁mainLock.lock();try {// Recheck while holding lock.// Back out on ThreadFactory failure or if// shut down before lock acquired.// 这儿需要重新检查线程池状态int rs = runStateOf(ctl.get());if (rs < SHUTDOWN ||(rs == SHUTDOWN && firstTask == null)) {// worker已经调用过了start()方法，则不再创建workerif (t.isAlive()) // precheck that t is startablethrow new IllegalThreadStateException();// worker创建并添加到workers成功workers.add(w);// 更新largestPoolSize变量int s = workers.size();if (s > largestPoolSize)largestPoolSize = s;workerAdded = true;} } finally {mainLock.unlock();}// 启动worker线程if (workerAdded) {t.start();workerStarted = true;} }} finally {// worker线程启动失败，说明线程池状态发生了变化（关闭操作被执行），需要进行shutdown相关操作if (! workerStarted)addWorkerFailed(w);}return workerStarted;} 5、线程池worker任务单元 private final class Workerextends AbstractQueuedSynchronizerimplements Runnable{/ This class will never be serialized, but we provide a serialVersionUID to suppress a javac warning./private static final long serialVersionUID = 6138294804551838833L;/ Thread this worker is running in. Null if factory fails. /final Thread thread;/ Initial task to run. Possibly null. /Runnable firstTask;/ Per-thread task counter /volatile long completedTasks;/ Creates with given first task and thread from ThreadFactory. @param firstTask the first task (null if none)/Worker(Runnable firstTask) {setState(-1); // inhibit interrupts until runWorkerthis.firstTask = firstTask;// 这儿是Worker的关键所在，使用了线程工厂创建了一个线程。传入的参数为当前workerthis.thread = getThreadFactory().newThread(this);}/ Delegates main run loop to outer runWorker /public void run() {runWorker(this);}// 省略代码...} 6、核心线程执行逻辑-runworker final void runWorker(Worker w) {Thread wt = Thread.currentThread();Runnable task = w.firstTask;w.firstTask = null;// 调用unlock()是为了让外部可以中断w.unlock(); // allow interrupts// 这个变量用于判断是否进入过自旋（while循环）boolean completedAbruptly = true;try {// 这儿是自旋// 1. 如果firstTask不为null，则执行firstTask；// 2. 如果firstTask为null，则调用getTask()从队列获取任务。// 3. 阻塞队列的特性就是：当队列为空时，当前线程会被阻塞等待while (task != null || (task = getTask()) != null) {// 这儿对worker进行加锁，是为了达到下面的目的// 1. 降低锁范围，提升性能// 2. 保证每个worker执行的任务是串行的w.lock();// If pool is stopping, ensure thread is interrupted;// if not, ensure thread is not interrupted. This// requires a recheck in second case to deal with// shutdownNow race while clearing interrupt// 如果线程池正在停止，则对当前线程进行中断操作if ((runStateAtLeast(ctl.get(), STOP) ||(Thread.interrupted() &&runStateAtLeast(ctl.get(), STOP))) &&!wt.isInterrupted())wt.interrupt();// 执行任务，且在执行前后通过beforeExecute()和afterExecute()来扩展其功能。// 这两个方法在当前类里面为空实现。try {beforeExecute(wt, task);Throwable thrown = null;try {task.run();} catch (RuntimeException x) {thrown = x; throw x;} catch (Error x) {thrown = x; throw x;} catch (Throwable x) {thrown = x; throw new Error(x);} finally {afterExecute(task, thrown);} } finally {// 帮助gctask = null;// 已完成任务数加一 w.completedTasks++;w.unlock();} }completedAbruptly = false;} finally {// 自旋操作被退出，说明线程池正在结束processWorkerExit(w, completedAbruptly);} } 本篇文章为转载内容。原文链接：https://blog.csdn.net/grd_java/article/details/113116244。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...（libssh服务端校验绕过）兼谈软件供应链真实威胁》）。 以上这些，抛开体系化的设想，只看案例，可能会得到这样的印象：这种威胁，都是由蓄意的上游或第三方参与者造成的；即便在最极端情况下，假使一个大型软件商或开源组织，被发现存在广泛、恶意的上游代码污染，那它顶多也不过相当于“奥创”一样的邪恶寡头，与其划清界限、清除历史包袱即可，虽然可能有阵痛。 可惜，并非如此。 在我们组织比赛的后半程中，对我们面临的这种威胁类型，不断有孤立的事例看似随机地发生，对此我以随笔的方式对它们做了分析和记录，以下与大家分享。 Ⅰ. 从感染到遗传：LibVNC与TightVNC系列漏洞 2018年12月10日晚9:03，OSS漏洞预警平台弹出的一封漏洞披露邮件，引起了我的注意。披露者是卡巴斯基工控系统漏洞研究组的Pavel Cheremushkin。 一些必要背景 VNC是一套屏幕图像分享和远程操作软件，底层通信为RFB协议，由剑桥某实验室开发，后1999年并入AT&T，2002年关停实验室与项目，VNC开源发布。 VNC本被设计用在局域网环境，且诞生背景决定其更倾向研究性质，商用级安全的缺失始终是个问题。后续有若干新的实现软件，如TightVNC、RealVNC，在公众认知中，AT&T版本已死，后起之秀一定程度上修正了问题。 目前各种更优秀的远程控制和分享协议取代了VNC的位置，尽管例如苹果仍然系统內建VNC作为远程方式。但在非桌面领域，VNC还有我们想不到的重要性，比如工控领域需要远程屏幕传输的场景，这也是为什么这系列漏洞作者会关注这一块。 漏洞技术概况 Pavel总结到，在阶段漏洞挖掘中共上报11个漏洞。在披露邮件中描述了其中4个的技术细节，均在协议数据包处理代码中，漏洞类型古典，分别是全局缓冲区溢出、堆溢出和空指针解引用。其中缓冲区溢出类型漏洞可方便构造PoC，实现远程任意代码执行的漏洞利用。 漏洞本身原理简单，也并不是关键。以其中一个为例，Pavel在发现时负责任地向LibVNC作者提交了issue，并跟进漏洞修复过程；在第一次修复之后，复核并指出修复代码无效，给出了有效patch。这个过程是常规操作。 漏洞疑点 有意思的是，在漏洞披露邮件中，Pavel重点谈了自己对这系列漏洞的一些周边发现，也是这里提到的原因。其中，关于存在漏洞的代码，作者表述： 我最初认为，这些问题是libvnc开发者自己代码中的错误，但看起来并非如此。其中有一些（如CoRRE数据处理函数中的堆缓冲区溢出），出现在AT&T实验室1999年的代码中，而后被很多软件开发者原样复制（在Github上搜索一下HandleCoRREBPP函数，你就知道），LibVNC和TightVNC也是如此。 为了证实，翻阅了这部分代码，确实在其中数据处理相关代码文件看到了剑桥和AT&T实验室的文件头GPL声明注释，中国菜刀 这证实这些文件是直接从最初剑桥实验室版本VNC移植过来的，且使用方式是 直接代码包含，而非独立库引用方式。在官方开源发布并停止更新后，LibVNC使用的这部分代码基本没有改动——除了少数变量命名方式的统一，以及本次漏洞修复。通过搜索，我找到了2000年发布的相关代码文件，确认这些文件与LibVNC中引入的原始版本一致。 另外，Pavel同时反馈了TightVNC中相同的问题。TightVNC与LibVNC没有继承和直接引用关系，但上述VNC代码同样被TightVNC使用，问题的模式不约而同。Pavel测试发现在Ubuntu最新版本TightVNC套件（1.3.10版本）中同样存在该问题，上报给当前软件所有者GlavSoft公司，但对方声称目前精力放在不受GPL限制的TightVNC 2.x版本开发中，对开源的1.x版本漏洞代码“可能会进行修复”。看起来，这个问题被踢给了各大Linux发行版社区来焦虑了——如果他们愿意接锅。 问题思考 在披露邮件中，Pavel认为，这些代码bug“如此明显，让人无法相信之前没被人发现过……也许是因为某些特殊理由才始终没得到修复”。 事实上，我们都知道目前存在一些对开源基础软件进行安全扫描的大型项目，例如Google的OSS；同时，仍然存活的开源项目也越来越注重自身代码发布前的安全扫描，Fortify、Coverity的扫描也成为很多项目和平台的标配。在这样一些眼睛注视下，为什么还有这样的问题？我认为就这个具体事例来说，可能有如下两个因素： ·上游已死。仍然在被维护的代码，存在版本更迭，也存在外界的持续关注、漏洞报告和修复、开发的迭代，对于负责人的开发者，持续跟进、评估、同步代码的改动是可能的。但是一旦一份代码走完了生命周期，就像一段史实一样会很少再被改动。 ·对第三方上游代码的无条件信任。我们很多人都有过基础组件、中间件的开发经历，不乏有人使用Coverity开启全部规则进行代码扫描、严格修复所有提示的问题甚至编程规范warning；报告往往很长，其中也包括有源码形式包含的第三方代码中的问题。但是，我们一方面倾向于认为这些被广泛使用的代码不应存在问题（不然早就被人挖过了），一方面考虑这些引用的代码往往是组件或库的形式被使用，应该有其上下文才能认定是否确实有可被利用的漏洞条件，现在单独扫描这部分代码一般出来的都是误报。所以这些代码的问题都容易被忽视。 但是透过这个具体例子，再延伸思考相关的实践，这里最根本的问题可以总结为一个模式： 复制粘贴风险。复制粘贴并不简单意味着剽窃，实际是当前软件领域、互联网行业发展的基础模式，但其中有一些没人能尝试解决的问题： ·在传统代码领域，如C代码中，对第三方代码功能的复用依赖，往往通过直接进行库的引入实现，第三方代码独立而完整，也较容易进行整体更新；这是最简单的情况，只需要所有下游使用者保证仅使用官方版本，跟进官方更新即可；但在实践中很难如此贯彻，这是下节讨论的问题。 ·有些第三方发布的代码，模式就是需要被源码形式包含到其他项目中进行统一编译使用（例如腾讯的开源Json解析库RapidJSON，就是纯C++头文件形式）。在开源领域有如GPL等规约对此进行规范，下游开发者遵循协议，引用代码，强制或可选地显式保留其GPL声明，可以进行使用和更改。这样的源码依赖关系，结合规范化的changelog声明代码改动，侧面也是为开发过程中跟进考虑。但是一个成型的产品，比如企业自有的服务端底层产品、中间件，新版本的发版更新是复杂的过程，开发者在旧版本仍然“功能正常”的情况下往往倾向于不跟进新版本；而上游代码如果进行安全漏洞修复，通常也都只在其最新版本代码中改动，安全修复与功能迭代并存，如果没有类似Linux发行版社区的努力，旧版本代码完全没有干净的安全更新patch可用。 ·在特定场景下，有些开发实践可能不严格遵循开源代码协议限定，引入了GPL等协议保护的代码而不做声明（以规避相关责任），丢失了引入和版本的信息跟踪；在另一些场景下，可能存在对开源代码进行大刀阔斧的修改、剪裁、定制，以符合自身业务的极端需求，但是过多的修改、人员的迭代造成与官方代码严重的失同步，丧失可维护性。 ·更一般的情况是，在开发中，开发者个体往往心照不宣的存在对网上代码文件、代码片段的复制-粘贴操作。被参考的代码，可能有上述的开源代码，也可能有各种Github作者练手项目、技术博客分享的代码片段、正式开源项目仅用来说明用法的不完备示例代码。这些代码的引入完全无迹可寻，即便是作者自己也很难解释用了什么。这种情况下，上面两条认定的那些与官方安全更新失同步的问题同样存在，且引入了独特的风险：被借鉴的代码可能只是原作者随手写的、仅仅是功能成立的片段，甚至可能是恶意作者随意散布的有安全问题的代码。由此，问题进入了最大的发散空间。 在Synopsys下BLACKDUCK软件之前发布的《2018 Open Source Security and Risk Analysis Report》中分析，96%的应用中包含有开源组件和代码，开源代码在应用全部代码中的占比约为57%，78%的应用中在引用的三方开源代码中存在历史漏洞。也就是说，现在互联网上所有厂商开发的软件、应用，其开发人员自己写的代码都是一少部分，多数都是借鉴来的。而这还只是可统计、可追溯的；至于上面提到的非规范的代码引用，如果也纳入进来考虑，三方代码占应用中的比例会上升到多少？曾经有分析认为至少占80%，我们只期望不会更高。 Ⅱ. 从碎片到乱刃：OpenSSH在野后门一览 在进行基础软件梳理时，回忆到反病毒安全软件提供商ESET在2018年十月发布的一份白皮书《THE DARK SIDE OF THE FORSSHE: A landscape of OpenSSH backdoors》。其站在一个具有广泛用户基础的软件提供商角度，给出了一份分析报告，数据和结论超出我们对于当前基础软件使用全景的估量。以下以我的角度对其中一方面进行解读。 一些必要背景 SSH的作用和重要性无需赘言；虽然我们站在传统互联网公司角度，可以认为SSH是通往生产服务器的生命通道，但当前多样化的产业环境已经不止于此（如之前libssh事件中，不幸被我言中的，SSH在网络设备、IoT设备上（如f5）的广泛使用）。 OpenSSH是目前绝大多数SSH服务端的基础软件，有完备的开发团队、发布规范、维护机制，本身是靠谱的。如同绝大多数基础软件开源项目的做法，OpenSSH对漏洞有及时的响应，针对最新版本代码发出安全补丁，但是各大Linux发行版使用的有各种版本的OpenSSH，这些社区自行负责将官方开发者的安全补丁移植到自己系统搭载的低版本代码上。天空彩 白皮书披露的现状 如果你是一个企业的运维管理人员，需要向企业生产服务器安装OpenSSH或者其它基础软件，最简单的方式当然是使用系统的软件管理安装即可。但是有时候，出于迁移成本考虑，可能企业需要在一个旧版本系统上，使用较新版本的OpenSSL、OpenSSH等基础软件，这些系统不提供，需要自行安装；或者需要一个某有种特殊特性的定制版本。这时，可能会选择从某些rpm包集中站下载某些不具名第三方提供的现成的安装包，或者下载非官方的定制化源码本地编译后安装，总之从这里引入了不确定性。 这种不确定性有多大？我们粗估一下，似乎不应成为问题。但这份白皮书给我们看到了鲜活的数据。 ESET研究人员从OpenSSH的一次历史大规模Linux服务端恶意软件Windigo中获得启示，采用某种巧妙的方式，面向在野的服务器进行数据采集，主要是系统与版本、安装的OpenSSH版本信息以及服务端程序文件的一个特殊签名。整理一个签名白名单，包含有所有能搜索到的官方发布二进制版本、各大Linux发行版本各个版本所带的程序文件版本，将这些标定为正常样本进行去除。最终结论是： ·共发现了几百个非白名单版本的OpenSSH服务端程序文件ssh和sshd； ·分析这些样本，将代码部分完全相同，仅仅是数据和配置不同的合并为一类，且分析判定确认有恶意代码的，共归纳为 21个各异的恶意OpenSSH家族； ·在21个恶意家族中，有12个家族在10月份时完全没有被公开发现分析过；而剩余的有一部分使用了历史上披露的恶意代码样本，甚至有源代码； ·所有恶意样本的实现，从实现复杂度、代码混淆和自我保护程度到代码特征有很大跨度的不同，但整体看，目的以偷取用户凭证等敏感信息、回连外传到攻击者为主，其中有的攻击者回连地址已经存在并活跃数年之久； ·这些后门的操控者，既有传统恶意软件黑产人员，也有APT组织； ·所有恶意软件或多或少都在被害主机上有未抹除的痕迹。ESET研究者尝试使用蜜罐引诱出攻击者，但仍有许多未解之谜。这场对抗，仍未取胜。 白皮书用了大篇幅做技术分析报告，此处供细节分析，不展开分析，以下为根据恶意程序复杂度描绘的21个家族图谱： 问题思考 问题引入的可能渠道，我在开头进行了一点推测，主要是由人的原因切入的，除此以外，最可能的是恶意攻击者在利用各种方法入侵目标主机后，主动替换了目标OpenSSH为恶意版本，从而达成攻击持久化操作。但是这些都是止血的安全运维人员该考虑的事情；关键问题是，透过表象，这显露了什么威胁形式？ 这个问题很好回答，之前也曾经反复说过：基础软件碎片化。 如上一章节简单提到，在开发过程中有各种可能的渠道引入开发者不完全了解和信任的代码；在运维过程中也是如此。二者互相作用，造成了软件碎片化的庞杂现状。在企业内部，同一份基础软件库，可能不同的业务线各自定制一份，放到企业私有软件仓库源中，有些会有人持续更新供自己产品使用，有些由系统软件基础设施维护人员单独维护，有些则可能是开发人员临时想起来上传的，他们自己都不记得；后续用到的这个基础软件的开发和团队，在这个源上搜索到已有的库，很大概率会倾向于直接使用，不管来源、是否有质量背书等。长此以往问题会持续发酵。而我们开最坏的脑洞，是否可能有黑产人员入职到内部，提交个恶意基础库之后就走人的可能？现行企业安全开发流程中审核机制的普遍缺失给这留下了空位。 将源码来源碎片化与二进制使用碎片化并起来考虑，我们不难看到一个远远超过OpenSSH事件威胁程度的图景。但这个问题不是仅仅靠开发阶段规约、运维阶段规范、企业内部管控、行业自查、政府监管就可以根除的，最大的问题归根结底两句话： 不可能用一场战役对抗持续威胁；不可能用有限分析对抗无限未知。 Ⅲ. 从自信到自省：RHEL、CentOS backport版本BIND漏洞 2018年12月20日凌晨，在备战冬至的软件供应链安全大赛决赛时，我注意到漏洞预警平台捕获的一封邮件。但这不是一个漏洞初始披露邮件，而是对一个稍早已披露的BIND在RedHat、CentOS发行版上特定版本的1day漏洞CVE-2018-5742，由BIND的官方开发者进行额外信息澄(shuǎi)清(guō)的邮件。 一些必要背景 关于BIND 互联网的一个古老而基础的设施是DNS，这个概念在读者不应陌生。而BIND“是现今互联网上最常使用的DNS软件，使用BIND作为服务器软件的DNS服务器约占所有DNS服务器的九成。BIND现在由互联网系统协会负责开发与维护参考。”所以BIND的基础地位即是如此，因此也一向被大量白帽黑帽反复测试、挖掘漏洞，其开发者大概也一直处在紧绷着应对的处境。 关于ISC和RedHat 说到开发者，上面提到BIND的官方开发者是互联网系统协会（ISC）。ISC是一个老牌非营利组织，目前主要就是BIND和DHCP基础设施的维护者。而BIND本身如同大多数历史悠久的互联网基础开源软件，是4个UCB在校生在DARPA资助下于1984年的实验室产物，直到2012年由ISC接管。 那么RedHat在此中是什么角色呢？这又要提到我之前提到的Linux发行版和自带软件维护策略。Red Hat Enterprise Linux（RHEL）及其社区版CentOS秉持着稳健的软件策略，每个大的发行版本的软件仓库，都只选用最必要且质量久经时间考验的软件版本，哪怕那些版本实在是老掉牙。这不是一种过分的保守，事实证明这种策略往往给RedHat用户在最新漏洞面前提供了保障——代码总是跑得越少，潜在漏洞越多。 但是这有两个关键问题。一方面，如果开源基础软件被发现一例有历史沿革的代码漏洞，那么官方开发者基本都只为其最新代码负责，在当前代码上推出修复补丁。另一方面，互联网基础设施虽然不像其上的应用那样爆发性迭代，但依然持续有一些新特性涌现，其中一些是必不可少的，但同样只在最新代码中提供。两个刚需推动下，各Linux发行版对长期支持版本系统的软件都采用一致的策略，即保持其基础软件在一个固定的版本，但对于这些版本软件的最新漏洞、必要的最新软件特性，由发行版维护者将官方开发者最新代码改动“向后移植”到旧版本代码中，即backport。这就是基础软件的“官宣”碎片化的源头。 讲道理，Linux发行版维护者与社区具有比较靠谱的开发能力和监督机制，backport又基本就是一些复制粘贴工作，应当是很稳当的……但真是如此吗？ CVE-2018-5742漏洞概况 CVE-2018-5742是一个简单的缓冲区溢出类型漏洞，官方评定其漏洞等级moderate，认为危害不大，漏洞修复不积极，披露信息不多，也没有积极给出代码修复patch和新版本rpm包。因为该漏洞仅在设置DEBUG_LEVEL为10以上才会触发，由远程攻击者构造畸形请求造成BIND服务崩溃，在正常的生产环境几乎不可能具有危害，RedHat官方也只是给出了用户自查建议。 这个漏洞只出现在RHEL和CentOS版本7中搭载的BIND 9.9.4-65及之后版本。RedHat同ISC的声明中都证实，这个漏洞的引入原因，是RedHat在尝试将BIND 9.11版本2016年新增的NTA机制向后移植到RedHat 7系中固定搭载的BIND 9.9版本代码时，偶然的代码错误。NTA是DNS安全扩展（DNSSEC）中，用于在特定域关闭DNSSEC校验以避免不必要的校验失败的机制；但这个漏洞不需要对NTA本身有进一步了解。 漏洞具体分析 官方没有给出具体分析，但根据CentOS社区里先前有用户反馈的bug，我得以很容易还原漏洞链路并定位到根本原因。 若干用户共同反馈，其使用的BIND 9.9.4-RedHat-9.9.4-72.el7发生崩溃（coredump），并给出如下的崩溃时调用栈backtrace： 这个调用过程的逻辑为，在9 dns_message_logfmtpacket函数判断当前软件设置是否DEBUG_LEVEL大于10，若是，对用户请求数据包做日志记录，先后调用8 dns_message_totext、7 dns_message_sectiontotext、6 dns_master_rdatasettotext、5 rdataset_totext将请求进行按协议分解分段后写出。 由以上关键调用环节，联动RedHat在9.9.4版本BIND源码包中关于引入NTA特性的源码patch，进行代码分析，很快定位到问题产生的位置，在上述backtrace中的5，masterdump.c文件rdataset_totext函数。漏洞相关代码片段中，RedHat进行backport后，这里引入的代码为： 这里判断对于请求中的注释类型数据，直接通过isc_buffer_putstr宏对缓存进行操作，在BIND工程中自定义维护的缓冲区结构对象target上，附加一字节字符串（一个分号）。而漏洞就是由此产生：isc_buffer_putstr中不做缓冲区边界检查保证，这里在缓冲区已满情况下将造成off-by-one溢出，并触发了缓冲区实现代码中的assertion。 而ISC上游官方版本的代码在这里是怎么写的呢？找到ISC版本BIND 9.11代码，这里是这样的： 这里可以看到，官方代码在做同样的“附加一个分号”这个操作时，审慎的使用了做缓冲区剩余空间校验的str_totext函数，并额外做返回值成功校验。而上述提到的str_totext函数与RETERR宏，在移植版本的masterdump.c中，RedHat开发者也都做了保留。但是，查看代码上下文发现，在RedHat开发者进行代码移植过程中，对官方代码进行了功能上的若干剪裁，包括一些细分数据类型记录的支持；而这里对缓冲区写入一字节，也许开发者完全没想到溢出的可能，所以自作主张地简化了代码调用过程。 问题思考 这个漏洞本身几乎没什么危害，但是背后足以引起思考。 没有人在“借”别人代码时能不出错 不同于之前章节提到的那种场景——将代码文件或片段复制到自己类似的代码上下文借用——backport作为一种官方且成熟的做法，借用的代码来源、粘贴到的代码上下文，是具有同源属性的，而且开发者一般是追求稳定性优先的社区开发人员，似乎质量应该有足够保障。但是这里的关键问题是：代码总要有一手、充分的语义理解，才能有可信的使用保障；因此，只要是处理他人的代码，因为不够理解而错误使用的风险，只可能减小，没办法消除。 如上分析，本次漏洞的产生看似只是做代码移植的开发者“自作主张”之下“改错了”。但是更广泛且可能的情况是，原始开发者在版本迭代中引入或更新大量基础数据结构、API的定义，并用在新的特性实现代码中；而后向移植开发人员仅需要最小规模的功能代码，所以会对增量代码进行一定规模的修改、剪裁、还原，以此适应旧版本基本代码。这些过程同样伴随着第三方开发人员不可避免的“望文生义”，以及随之而来的风险。后向移植操作也同样助长了软件碎片化过程，其中每一个碎片都存在这样的问题；每一个碎片在自身生命周期也将有持续性影响。 多级复制粘贴无异于雪上加霜 这里简单探讨的是企业通行的系统和基础软件建设实践。一些国内外厂商和社区发布的定制化Linux发行版，本身是有其它发行版，如CentOS特定版本渊源的，在基础软件上即便同其上游发行版最新版本间也存在断层滞后。RedHat相对于基础软件开发者之间已经隔了一层backport，而我们则人为制造了二级风险。 在很多基础而关键的软件上，企业系统基础设施的维护者出于与RedHat类似的初衷，往往会决定自行backport一份拷贝；通过早年心脏滴血事件的洗礼，即暴露出来OpenSSL一个例子。无论是需要RHEL还没来得及移植的新版本功能特性，还是出于对特殊使用上下文场景中更高执行效率的追求，企业都可能自行对RHEL上基础软件源码包进行修改定制重打包。这个过程除了将风险幂次放大外，也进一步加深了代码的不可解释性（包括基础软件开发人员流动性带来的不可解释）。 Ⅳ. 从武功到死穴：从systemd-journald信息泄露一窥API误用 1月10日凌晨两点，漏洞预警平台爬收取一封漏洞披露邮件。披露者是Qualys，那就铁定是重型发布了。最后看披露漏洞的目标，systemd？这就非常有意思了。 一些必要背景 systemd是什么，不好简单回答。Linux上面软件命名，习惯以某软件名后带个‘d’表示后台守护管理程序；所以systemd就可以说是整个系统的看守吧。而即便现在描述了systemd是什么，可能也很快会落伍，因为其初始及核心开发者Lennart Poettering（供职于Red Hat）描述它是“永无开发完结完整、始终跟进技术进展的、统一所有发行版无止境的差异”的一种底层软件。笼统讲有三个作用：中央化系统及设置管理；其它软件开发的基础框架；应用程序和系统内核之间的胶水。如今几乎所有Linux发行版已经默认提供systemd，包括RHEL/CentOS 7及后续版本。总之很基础、很底层、很重要就对了。systemd本体是个主要实现init系统的框架，但还有若干关键组件完成其它工作；这次被爆漏洞的是其journald组件，是负责系统事件日志记录的看守程序。 额外地还想简单提一句Qualys这个公司。该公司创立于1999年，官方介绍为信息安全与云安全解决方案企业，to B的安全业务非常全面，有些也是国内企业很少有布局的方面；例如上面提到的涉及碎片化和代码移植过程的历史漏洞移动，也在其漏洞管理解决方案中有所体现。但是我们对这家公司粗浅的了解来源于其安全研究团队近几年的发声，这两年间发布过的，包括有『stack clash』、『sudo get_tty_name提权』、『OpenSSH信息泄露与堆溢出』、『GHOST：glibc gethostbyname缓冲区溢出』等大新闻（仅截至2017年年中）。从中可见，这个研究团队专门啃硬骨头，而且还总能开拓出来新的啃食方式，往往爆出来一些别人没想到的新漏洞类型。从这个角度，再联想之前刷爆朋友圈的《安全研究者的自我修养》所倡导的“通过看历史漏洞、看别人的最新成果去举一反三”的理念，可见差距。 CVE-2018-16866漏洞详情 这次漏洞披露，打包了三个漏洞： ·16864和16865是内存破坏类型 ·16866是信息泄露 ·而16865和16866两个漏洞组和利用可以拿到root shell。 漏洞分析已经在披露中写的很详细了，这里不复述；而针对16866的漏洞成因来龙去脉，Qualys跟踪的结果留下了一点想象和反思空间，我们来看一下。 漏洞相关代码片段是这样的（漏洞修复前）： 读者可以先肉眼过一遍这段代码有什么问题。实际上我一开始也没看出来，向下读才恍然大悟。 这段代码中，外部信息输入通过buf传入做记录处理。输入数据一般包含有空白字符间隔，需要分隔开逐个记录，有效的分隔符包括空格、制表符、回车、换行，代码中将其写入常量字符串；在逐字符扫描输入数据字符串时，将当前字符使用strchr在上述间隔符字符串中检索是否匹配，以此判断是否为间隔符；在240行，通过这样的判断，跳过记录单元字符串的头部连续空白字符。 但是问题在于，strchr这个极其基础的字符串处理函数，对于C字符串终止字符'\0'的处理上有个坑：'\0'也被认为是被检索字符串当中的一个有效字符。所以在240行，当当前扫描到的字符为字符串末尾的NULL时，strchr返回的是WHITESPACE常量字符串的终止位置而非NULL，这导致了越界。 看起来，这是一个典型的问题：API误用（API mis-use），只不过这个被误用的库函数有点太基础，让我忍不住想是不是还会有大量的类似漏洞……当然也反思我自己写的代码是不是也有同样情况，然而略一思考就释然了——我那么笨的代码都用for循环加if判断了:) 漏洞引入和消除历史 有意思的是，Qualys研究人员很贴心地替我做了一步漏洞成因溯源，这才是单独提这个漏洞的原因。漏洞的引入是在2015年的一个commit中： 在GitHub中，定位到上述2015年的commit信息，这里commit的备注信息为： journald: do not strip leading whitespace from messages. Keep leading whitespace for compatibility with older syslog implementations. Also useful when piping formatted output to the logger command. Keep removing trailing whitespace. OK，看起来是一个兼容性调整，对记录信息不再跳过开头所有连续空白字符，只不过用strchr的简洁写法比较突出开发者精炼的开发风格（并不），说得过去。 之后在2018年八月的一个当时尚未推正式版的另一次commit中被修复了，先是还原成了ec5ff4那次commit之前的写法，然后改成了加校验的方式： 虽然Qualys研究者认为上述的修改是“无心插柳”的改动，但是在GitHub可以看到，a6aadf这次commit是因为有外部用户反馈了输入数据为单个冒号情况下journald堆溢出崩溃的issue，才由开发者有目的性地修复的；而之后在859510这个commit再次改动回来，理由是待记录的消息都是使用单个空格作为间隔符的，而上一个commit粗暴地去掉了这种协议兼容性特性。 如果没有以上纠结的修改和改回历史，也许我会倾向于怀疑，在最开始漏洞引入的那个commit，既然改动代码没有新增功能特性、没有解决什么问题（毕竟其后三年，这个改动的代码也没有被反映issue），也并非出于代码规范等考虑，那么这么轻描淡写的一次提交，难免有人为蓄意引入漏洞的嫌疑。当然，看到几次修复的原因，这种可能性就不大了，虽然大家仍可以保留意见。但是抛开是否人为这个因素，单纯从代码的漏洞成因看，一个传统但躲不开的问题仍值得探讨：API误用。 API误用：程序员何苦为难程序员 如果之前的章节给读者留下了我反对代码模块化和复用的印象，那么这里需要正名一下，我们认可这是当下开发实践不可避免的趋势，也增进了社会开发速度。而API的设计决定了写代码和用代码的双方“舒适度”的问题，由此而来的API误用问题，也是一直被当做单纯的软件工程课题讨论。在此方面个人并没有什么研究，自然也没办法系统地给出分类和学术方案，只是谈一下自己的经验和想法。 一篇比较新的学术文章总结了API误用的研究，其中一个独立章节专门分析Java密码学组件API误用的实际，当中引述之前论文认为，密码学API是非常容易被误用的，比如对期望输入数据（数据类型，数据来源，编码形式）要求的混淆，API的必需调用次序和依赖缺失（比如缺少或冗余多次调用了初始化函数、主动资源回收函数）等。凑巧在此方面我有一点体会：曾经因为业务方需要，需要使用C++对一个Java的密码基础中间件做移植。Java对密码学组件支持，有原生的JDK模块和权威的BouncyCastle包可用；而C/C++只能使用第三方库，考虑到系统平台最大兼容和最小代码量，使用Linux平台默认自带的OpenSSL的密码套件。但在开发过程中感受到了OpenSSL满满的恶意：其中的API设计不可谓不反人类，很多参数没有明确的说明（比如同样是表示长度的函数参数，可能在不同地方分别以字节/比特/分组数为计数单位）；函数的线程安全没有任何解释标注，需要自行试验；不清楚函数执行之后，是其自行做了资源释放还是需要有另外API做gc，不知道资源释放操作时是否规规矩矩地先擦除后释放……此类问题不一而足，导致经过了漫长的测试之后，这份中间件才提供出来供使用。而在业务场景中，还会存在比如其它语言调用的情形，这些又暴露出来OpenSSL API误用的一些完全无从参考的问题。这一切都成为了噩梦；当然这无法为我自己开解是个不称职开发的指责，但仅就OpenSSL而言其API设计之恶劣也是始终被人诟病的问题，也是之后其他替代者宣称改进的地方。 当然，问题是上下游都脱不了干系的。我们自己作为高速迭代中的开发人员，对于二方、三方提供的中间件、API，又有多少人能自信地说自己仔细、认真地阅读过开发指南和API、规范说明呢？做过通用产品技术运营的朋友可能很容易理解，自己产品的直接用户日常抛出不看文档的愚蠢问题带来的困扰。对于密码学套件，这个问题还好办一些，毕竟如果在没有背景知识的情况下对API望文生义地一通调用，绝大多数情况下都会以抛异常形式告终；但还是有很多情况，API误用埋下的是长期隐患。 不是所有API误用情形最终都有机会发展成为可利用的安全漏洞，但作为一个由人的因素引入的风险，这将长期存在并困扰软件供应链（虽然对安全研究者、黑客与白帽子是很欣慰的事情）。可惜，传统的白盒代码扫描能力，基于对代码语义的理解和构建，但是涉及到API则需要预先的抽象，这一点目前似乎仍然是需要人工干预的事情；或者轻量级一点的方案，可以case by case地分析，为所有可能被误用的API建模并单独扫描，这自然也有很强局限性。在一个很底层可信的开发者还对C标准库API存在误用的现实内，我们需要更多的思考才能说接下来的解法。 Ⅴ. 从规则到陷阱：NASA JIRA误配置致信息泄露血案 软件的定义包括了代码组成的程序，以及相关的配置、文档等。当我们说软件的漏洞、风险时，往往只聚焦在其中的代码中；关于软件供应链安全风险，我们的比赛、前面分析的例子也都聚焦在了代码的问题；但是真正的威胁都来源于不可思议之处，那么代码之外有没有可能存在来源于上游的威胁呢？这里就借助实例来探讨一下，在“配置”当中可能栽倒的坑。 引子：发不到500英里以外的邮件？ 让我们先从一个轻松愉快的小例子引入。这个例子初见于Linux中国的一篇译文。 简单说，作者描述了这么一个让人啼笑皆非的问题：单位的邮件服务器发送邮件，发送目标距离本地500英里范围之外的一律失败，邮件就像悠悠球一样只能飞出一定距离。这个问题本身让描述者感到尴尬，就像一个技术人员被老板问到“为什么从家里笔记本上Ctrl-C后不能在公司台式机上Ctrl-V”一样。 经过令人窒息的分析操作后，笔者定位到了问题原因：笔者作为负责的系统管理员，把SunOS默认安装的Senmail从老旧的版本5升级到了成熟的版本8，且对应于新版本诸多的新特性进行了对应配置，写入配置文件sendmail.cf；但第三方服务顾问在对单位系统进行打补丁升级维护时，将系统软件“升级”到了系统提供的最新版本，因此将Sendmail实际回退到了版本5，却为了软件行为一致性，原样保留了高版本使用的配置文件。但Sendmail并没有在大版本间保证配置文件兼容性，这导致很多版本5所需的配置项不存在于保留下来的sendmail.cf文件中，程序按默认值0处理；最终引起问题的就是，邮件服务器与接收端通信的超时时间配置项，当取默认配置值0时，邮件服务器在1个单位时间（约3毫秒）内没有收到网络回包即认为超时，而这3毫秒仅够电信号打来回飞出500英里。 这个“故事”可能会给技术人员一点警醒，错误的配置会导致预期之外的软件行为，但是配置如何会引入软件供应链方向的安全风险呢？这就引出了下一个重磅实例。 JIRA配置错误致NASA敏感信息泄露案例 我们都听过一个事情，马云在带队考察美国公司期间问Google CEO Larry Page自视谁为竞争对手，Larry的回答是NASA，因为最优秀的工程师都被NASA的梦想吸引过去了。由此我们显然能窥见NASA的技术水位之高，这样的人才团队大概至少是不会犯什么低级错误的。 但也许需要重新定义“低级错误”……1月11日一篇技术文章披露，NASA某官网部署使用的缺陷跟踪管理系统JIRA存在错误的配置，可分别泄漏内部员工（JIRA系统用户）的全部用户名和邮件地址，以及内部项目和团队名称到公众，如下： 问题的原因解释起来也非常简单：JIRA系统的过滤器和配置面板中，对于数据可见性的配置选项分别选定为All users和Everyone时，系统管理人员想当然地认为这意味着将数据对所有“系统用户”开放查看，但是JIRA的这两个选项的真实效果逆天，是面向“任意人”开放，即不限于系统登录用户，而是任何查看页面的人员。看到这里，我不厚道地笑了……“All users”并不意味着“All ‘users’”，意不意外，惊不惊喜？ 但是这种字面上把戏，为什么没有引起NASA工程师的注意呢，难道这样逆天的配置项没有在产品手册文档中加粗标红提示吗？本着为JIRA产品设计找回尊严的态度，我深入挖掘了一下官方说明，果然在Atlassian官方的一份confluence文档（看起来更像是一份增补的FAQ）中找到了相关说明： 所有未登录访客访问时，系统默认认定他们是匿名anonymous用户，所以各种权限配置中的all users或anyone显然应该将匿名用户包括在内。在7.2及之后版本中，则提供了“所有登录用户”的选项。 可以说是非常严谨且贴心了。比较讽刺的是，在我们的软件供应链安全大赛·C源代码赛季期间，我们设计圈定的恶意代码攻击目标还包括JIRA相关的敏感信息的窃取，但是却想不到有这么简单方便的方式，不动一行代码就可以从JIRA中偷走数据。 软件的使用，你“配”吗？ 无论是开放的代码还是成型的产品，我们在使用外部软件的时候，都是处于软件供应链下游的消费者角色，为了要充分理解上游开发和产品的真实细节意图，需要我们付出多大的努力才够“资格”？ 上一章节我们讨论过源码使用中必要细节信息缺失造成的“API误用”问题，而软件配置上的“误用”问题则复杂多样得多。从可控程度上讨论，至少有这几种因素定义了这个问题： ·软件用户对必要配置的现有文档缺少了解。这是最简单的场景，但又是完全不可避免的，这一点上我们所有有开发、产品或运营角色经验的应该都曾经体会过向不管不顾用户答疑的痛苦，而所有软件使用者也可以反省一下对所有软件的使用是否都以完整细致的文档阅读作为上手的准备工作，所以不必多说。 ·软件拥有者对配置条目缺少必要明确说明文档。就JIRA的例子而言，将NASA工程师归为上一条错误有些冤枉，而将JIRA归为这条更加合适。在边角但重要问题上的说明通过社区而非官方文档形式发布是一种不负责任的做法，但未引发安全事件的情况下还有多少这样的问题被默默隐藏呢？我们没办法要求在使用软件之前所有用户将软件相关所有文档、社区问答实现全部覆盖。这个问题范围内一个代表性例子是对配置项的默认值以及对应效果的说明缺失。 ·配置文件版本兼容性带来的误配置和安全问题。实际上，上面的SunOS Sendmail案例足以点出这个问题的存在性，但是在真实场景下，很可能不会以这么戏剧性形式出现。在企业的系统运维中，系统的版本迭代常见，但为软件行为一致性，配置的跨版本迁移是不可避免的操作；而且软件的更新迭代也不只会由系统更新推动，还有大量出于业务性能要求而主动进行的定制化升级，对于中小企业基础设施建设似乎是一个没怎么被提及过的问题。 ·配置项组合冲突问题。尽管对于单个配置项可能明确行为与影响，但是特定的配置项搭配可能造成不可预知的效果。这完全有可能是由于开发者与用户在信息不对等的情况下产生：开发者认为用户应该具有必需的背景知识，做了用户应当具备规避配置冲突能力的假设。一个例子是，对称密码算法在使用ECB、CBC分组工作模式时，从密码算法上要求输入数据长度必须是分组大小的整倍数，但如果用户搭配配置了秘钥对数据不做补齐（nopadding），则引入了非确定性行为：如果密码算法库对这种组合配置按某种默认补齐方式操作数据则会引起歧义，但如果在算法库代码层面对这种组合抛出错误则直接影响业务。 ·程序对配置项处理过程的潜在暗箱操作。这区别于简单的未文档化配置项行为，仅特指可能存在的蓄意、恶意行为。从某种意义上，上述“All users”也可以认为是这样的一种陷阱，通过浅层次暗示，引导用户做出错误且可能引起问题的配置。另一种情况是特定配置组合情况下触发恶意代码的行为，这种触发条件将使恶意代码具有规避检测的能力，且在用户基数上具有一定概率的用户命中率。当然这种情况由官方开发者直接引入的可能性很低，但是在众包开发的情况下如果存在，那么扫描方案是很难检测的。 Ⅵ. 从逆流到暗流：恶意代码溯源后的挑战 如果说前面所说的种种威胁都是面向关键目标和核心系统应该思考的问题，那么最后要抛出一个会把所有人拉进赛场的理由。除了前面所有那些在软件供应链下游被动污染受害的情况，还有一种情形：你有迹可循的代码，也许在不经意间会“反哺”到黑色产业链甚至特殊武器中；而现在研究用于对程序进行分析和溯源的技术，则会让你陷入百口莫辩的境地。 案例：黑产代码模块溯源疑云 1月29日，猎豹安全团队发布技术分析通报文章《电信、百度客户端源码疑遭泄漏，驱魔家族窃取隐私再起波澜》，矛头直指黑产上游的恶意信息窃取代码模块，认定其代码与两方产品存在微妙的关联：中国电信旗下“桌面3D动态天气”等多款软件，以及百度旗下“百度杀毒”等软件（已不可访问）。 文章中举证有三个关键点。 首先最直观的，是三者使用了相同的特征字符串、私有文件路径、自定义内部数据字段格式； 其次，在关键代码位置，三者在二进制程序汇编代码层面具有高度相似性； 最终，在一定范围的非通用程序逻辑上，三者在经过反汇编后的代码语义上显示出明显的雷同，并提供了如下两图佐证（图片来源）： 文章指出的涉事相关软件已经下线，对于上述样本文件的相似度试验暂不做复现，且无法求证存在相似、疑似同源的代码在三者中占比数据。对于上述指出的代码雷同现象，猎豹安全团队认为： 我们怀疑该病毒模块的作者通过某种渠道(比如“曾经就职”)，掌握有中国电信旗下部分客户端/服务端源码，并加以改造用于制作窃取用户隐私的病毒，另外在该病毒模块的代码中，我们还发现“百度”旗下部分客户端的基础调试日志函数库代码痕迹，整个“驱魔”病毒家族疑点重重，其制作传播背景愈发扑朔迷离。 这样的推断，固然有过于直接的依据（例如三款代码中均使用含有“baidu”字样的特征注册表项）；但更进一步地，需要注意到，三个样本在所指出的代码位置，具有直观可见的二进制汇编代码结构的相同，考虑到如果仅仅是恶意代码开发者先逆向另外两份代码后借鉴了代码逻辑，那么在面临反编译、代码上下文适配重构、跨编译器和选项的编译结果差异等诸多不确定环节，仍能保持二进制代码的雷同，似乎确实是只有从根本上的源代码泄漏（抄袭）且保持相同的开发编译环境才能成立。 但是我们却又无法做出更明确的推断。这一方面当然是出于严谨避免过度解读；而从另一方面考虑，黑产代码的一个关键出发点就是“隐藏自己”，而这里居然如此堂而皇之地照搬了代码，不但没有进行任何代码混淆、变形，甚至没有抹除疑似来源的关键字符串，如果将黑产视为智商在线的对手，那这里背后是否有其它考量，就值得琢磨了。 代码的比对、分析、溯源技术水准 上文中的安全团队基于大量样本和粗粒度比对方法，给出了一个初步的判断和疑点。那么是否有可能获得更确凿的分析结果，来证实或证伪同源猜想呢？ 无论是源代码还是二进制，代码比对技术作为一种基础手段，在软件供应链安全分析上都注定仍然有效。在我们的软件供应链安全大赛期间，针对PE二进制程序类型的题目，参赛队伍就纷纷采用了相关技术手段用于目标分析，包括：同源性分析，用于判定与目标软件相似度最高的同软件官方版本；细粒度的差异分析，用于尝试在忽略编译差异和特意引入的混淆之外，定位特意引入的恶意代码位置。当然，作为比赛中针对性的应对方案，受目标和环境引导约束，这些方法证明了可行性，却难以保证集成有最新技术方案。那么做一下预言，在不计入情报辅助条件下，下一代的代码比对将能够到达什么水准？ 这里结合近一年和今年内，已发表和未发表的学术领域顶级会议的相关文章来简单展望： ·针对海量甚至全量已知源码，将可以实现准确精细化的“作者归属”判定。在ACM CCS‘18会议上曾发表的一篇文章《Large-Scale and Language-Oblivious Code Authorship Identification》，描述了使用RNN进行大规模代码识别的方案，在圈定目标开发者，并预先提供每个开发者的5-7份已知的代码文件后，该技术方案可以很有效地识别大规模匿名代码仓库中隶属于每个开发者的代码：针对1600个Google Code Jam开发者8年间的所有代码可以实现96%的成功识别率，而针对745个C代码开发者于1987年之后在GitHub上面的全部公开代码仓库，识别率也高达94.38%。这样的结果在当下的场景中，已经足以实现对特定人的代码识别和跟踪（例如，考虑到特定开发人员可能由于编码习惯和规范意识，在时间和项目跨度上犯同样的错误）；可以预见，在该技术方向上，完全可以期望摆脱特定已知目标人的现有数据集学习的过程，并实现更细粒度的归属分析，例如代码段、代码行、提交历史。 ·针对二进制代码，更准确、更大规模、更快速的代码主程序分析和同源性匹配。近年来作为一项程序分析基础技术研究，二进制代码相似性分析又重新获得了学术界和工业界的关注。在2018年和2019（已录用）的安全领域四大顶级会议上，每次都会有该方向最新成果的展示，如S&P‘2019上录用的《Asm2Vec: Boosting Static Representation Robustness for Binary Clone Search against Code Obfuscation and Compiler Optimization》，实现无先验知识的条件下的最优汇编代码级别克隆检测，针对漏洞库的漏洞代码检测可实现0误报、100%召回。而2018年北京HITB会议上，Google Project Zero成员、二进制比对工具BinDiff原始作者Thomas Dullien，探讨了他借用改造Google自家SimHash算法思想，用于针对二进制代码控制流图做相似性检测的尝试和阶段结果；这种引入规模数据处理的思路，也可期望能够在目前其他技术方案大多精细化而低效的情况下，为高效、快速、大规模甚至全量代码克隆检测勾出未来方案。 ·代码比对方案对编辑、优化、变形、混淆的对抗。近年所有技术方案都以对代码“变种”的检测有效性作为关键衡量标准，并一定程度上予以保证。上文CCS‘18论文工作，针对典型源代码混淆（如Tigress）处理后的代码，大规模数据集上可有93.42%的准确识别率；S&P‘19论文针对跨编译器和编译选项、业界常用的OLLVM编译时混淆方案进行试验，在全部可用的混淆方案保护之下的代码仍然可以完成81%以上的克隆检测。值得注意的是以上方案都并非针对特定混淆方案单独优化的，方法具有通用价值；而除此以外还有很多针对性的的反混淆研究成果可用；因此，可以认为在采用常规商用代码混淆方案下，即便存在隐藏内部业务逻辑不被逆向的能力，但仍然可以被有效定位代码复用和开发者自然人。 代码溯源技术面前的“挑战” 作为软件供应链安全的独立分析方，健壮的代码比对技术是决定性的基石；而当脑洞大开，考虑到行业的发展，也许以下两种假设的情景，将把每一个“正当”的产品、开发者置于尴尬的境地。 代码仿制 在本章节引述的“驱魔家族”代码疑云案例中，黑产方面通过某种方式获得了正常代码中，功能逻辑可以被自身复用的片段，并以某种方法将其在保持原样的情况下拼接形成了恶意程序。即便在此例中并非如此，但这却暴露了隐忧：将来是不是有这种可能，我的正常代码被泄漏或逆向后出现在恶意软件中，被溯源后扣上黑锅？ 这种担忧可能以多种渠道和形式成为现实。 从上游看，内部源码被人为泄漏是最简单的形式（实际上，考虑到代码的完整生命周期似乎并没有作为企业核心数据资产得到保护，目前实质上有没有这样的代码在野泄漏还是个未知数），而通过程序逆向还原代码逻辑也在一定程度上可获取原始代码关键特征。 从下游看，则可能有多种方式将恶意代码伪造得像正常代码并实现“碰瓷”。最简单地，可以大量复用关键代码特征（如字符串，自定义数据结构，关键分支条件，数据记录和交换私有格式等）。考虑到在进行溯源时，分析者实际上不需要100%的匹配度才会怀疑，因此仅仅是仿造原始程序对于第三方公开库代码的特殊定制改动，也足以将公众的疑点转移。而近年来类似自动补丁代码搜索生成的方案也可能被用来在一份最终代码中包含有二方甚至多方原始代码的特征和片段。 基于开发者溯源的定点渗透 既然在未来可能存在准确将代码与自然人对应的技术，那么这种技术也完全可能被黑色产业利用。可能的忧患包括强针对性的社会工程，结合特定开发者历史代码缺陷的漏洞挖掘利用，联动第三方泄漏人员信息的深层渗透，等等。这方面暂不做联想展开。 〇. 没有总结 作为一场旨在定义“软件供应链安全”威胁的宣言，阿里安全“功守道”大赛将在后续给出详细的分解和总结，其意义价值也许会在一段时间之后才能被挖掘。 但是威胁的现状不容乐观，威胁的发展不会静待；这一篇随笔仅仅挑选六个侧面做摘录分析，可即将到来的趋势一定只会进入更加发散的境地，因此这里，没有总结。 本篇文章为转载内容。原文链接：https://blog.csdn.net/systemino/article/details/90114743。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...vaScript中的函数参数和实参的关系。 2. 函数参数和实参的概念 函数参数是在函数声明中列出的变量名称，它们是函数的形式参数。实参是在函数调用时传递给函数的值。这两个词经常搭伴出现，比如我们平常聊天可能会说：“这个函数运行需要两个小帮手”，这里的小帮手其实就是指函数的形式参数。而当我们提到“我们把两个数字塞给函数当小帮手”时，这里的“小帮手”实际就是函数的实参啦。 3. 函数参数和实参的关系 函数参数和实参之间的关系非常简单。当你调用一个函数时，你需要向函数传递一些值。这些值被称为实参，它们会被分配给函数的形参。换句话说，实参就像是函数在干活儿时需要的原料，它是实实在在要喂给函数的东西；而形参呢，你可以把它理解成一个篮子或者箱子，它的任务就是用来装这些原料，等待函数来取用。 例如，考虑下面的函数： javascript function addNumbers(num1, num2) { return num1 + num2; } 在这个函数中，num1和num2是我们定义的两个形参。当我们调用这个函数时，我们需要向它传递两个值。这些值被称为实参。例如： javascript var result = addNumbers(5, 10); 在这个例子中，5和10是我们传递给addNumbers()函数的两个实参。这两个实参分别被分配给了num1和num2形参。然后，函数返回了这两个形参的和。 4. 默认参数 默认参数是JavaScript中一种非常有用的特性。在我们声明函数并给参数排排坐的时候，完全可以给每个小参数都安排一个默认值，这样它们就不用担心没被“喂饱”啦。这样，如果我们在函数调用时不提供该参数的值，那么函数将使用默认值。 例如，让我们修改我们的addNumbers()函数，使其接受可选的第三个参数： javascript function addNumbers(num1, num2, thirdNum = 0) { return num1 + num2 + thirdNum; } 在这个版本的函数中，thirdNum是一个形参，它有一个默认值0。如果咱们在调用addNumbers()这个函数的时候，忘记给thirdNum赋个值的话，那这个函数就相当机智地，默认把thirdNum当作是零来用。 例如： javascript var result = addNumbers(5, 10); // 返回15 var result2 = addNumbers(5, 10, 20); // 返回45 在这个例子中，我们首先调用了addNumbers()函数两次，但只提供了两个实参。因此，函数使用其形参的默认值。然后，我们再次调用了addNumbers()函数，这次提供了三个实参。所以，函数使用提供的值。 5. 总结 函数参数和实参是JavaScript中的重要概念。他们之间的关系其实特简单，就像这样：当你在呼唤一个函数的时候，得给它带上一些小礼物，这些小礼物我们就叫它们“实参”。实参被分配给函数的形参。在编写JavaScript代码时，理解函数参数和实参的关系是非常重要的。要是你能正确地理解和运用这两个小概念，那你就能够编写出更加灵活、更加强劲的函数啦，就像给你的编程技能插上翅膀一样。

...引用类型如其他对象和函数。在JSON中，JavaScript对象通过键（字符串）和对应的值进行表示，且遵循特定的语法规则。 JSON.parse()方法 , 这是JavaScript内置的一个全局函数，用于将一个JSON格式的字符串转换为等效的JavaScript值或对象。例如，当接收到从服务器返回的JSON格式的数据时，可以通过调用JSON.parse()方法将其解析成JavaScript对象，以便进一步操作和处理数据。 JSON.stringify()方法 , 同为JavaScript内置的方法，它的功能与JSON.parse()相反，用于将JavaScript对象或值转换为JSON格式的字符串。开发者通常在需要将JavaScript对象发送到服务器或其他环境，或者保存为本地存储时使用此方法。JSON.stringify()还可以接受可选参数，用于控制序列化过程中如何处理对象属性及函数等内容。

正态分布校验 , 在统计学中，正态分布校验是一种用于检验一组数据是否符合正态分布（即高斯分布）的假设检验方法。在文章的上下文中，通过Python中的Scipy库提供的normaltest函数，可以计算出给定样本数据集的统计量和p值，从而依据预设的显著性水平判断该数据集是否服从正态分布。如果p值小于0.5，则拒绝原假设（数据来自正态分布），认为数据不符合正态分布；反之，则不能拒绝原假设，可能推断数据接近或符合正态分布。 正态分布 , 正态分布是一种连续概率分布，其特征是所有数据集中在均值附近，呈对称形态，且通过均值左右两侧的数据点以相同的方式递减。在自然界和社会现象中，许多随机变量的概率分布都呈现出或近似于正态分布。在本文的具体情境中，正态分布校验的目的就是为了验证实际观测到的数据点集合是否遵循这种分布规律。 p值 , 在统计学中，p值是假设检验中的一个重要指标，表示在零假设成立的前提下，观察到现有样本结果或更极端结果的概率。在正态分布校验中，p值代表了数据实际上由正态分布产生的可能性大小。当p值小于某个预先设定的阈值（例如0.05），根据统计学上的显著性水平标准，通常会拒绝零假设（数据来自于正态分布），并得出结论认为数据不符合正态分布。相反，若p值大于等于这个阈值，则不拒绝零假设，认为数据有可能或者大致上符合正态分布。

...饰器的methods参数用于指定该路由能够响应哪些HTTP请求方法。这里的 methods= POST 表示只有当客户端发起POST请求时， /submit-form 这个URL路径下的函数才会被调用处理请求数据。 request.form , 在Flask框架中，request对象封装了来自客户端的所有HTTP请求信息。request.form是其中的一个属性，它提供了对请求体中编码为 application/x-www-form-urlencoded 或 multipart/form-data 格式数据的访问。在处理表单提交时，可以通过request.form field_name 来获取表单中特定字段（如username和password）的用户输入值。

...ua中处理可变数量的参数？ Lua，这个小巧而又功能强大的脚本语言，在游戏开发、网络应用等领域得到了广泛应用。说起来，Lua在处理函数参数这块儿可是相当灵活的，尤其是它那个对可变数量参数的支持，简直是让开发者们的编程生活轻松不少。这样一来，大伙儿就能写出更加简洁利落、效率更高的代码，而且适用性也贼强，真是开发者的福音啊！那么，今天我们就一起深入探讨一下如何在Lua中优雅地处理可变数量的参数。 1. Lua中的...语法 在Lua中，处理可变数量参数的关键在于“...”（三个点）语法。当你在函数定义时使用"..."作为参数列表的一部分，它将捕获并打包所有额外传入的参数到一个table中。 lua function printMany(...) for i, value in ipairs(arg) do print(value) end end printMany("Hello", "World", "from", "Lua") 上述代码中，printMany函数通过“...”接收任意数量的参数，并通过内置的arg表进行访问和遍历。当调用printMany函数时，实际传入的所有额外参数都会被收集到arg表中。 然而，从Lua 5.2版本开始，arg不再推荐使用，而是建议直接在函数内部声明一个局部变量来代替，如： lua function printMany(...) local arguments = {...} for i, value in ipairs(arguments) do print(value) end end 这里，{...}会创建一个新的table，包含所有传递给函数的额外参数。 2. 使用select()函数 除了直接访问“...”收集到的参数表外，Lua还提供了一个名为select()的内建函数，它可以用来根据索引或'（''表示参数个数）获取可变参数的信息。 lua function sum(...) local total = 0 local count = select('', ...) for i = 1, count do total = total + select(i, ...) end return total end print(sum(1, 2, 3, 4)) -- 输出：10 在这个例子中，select('', ...)返回了传递给sum函数的参数总数，然后我们通过循环遍历并累加这些参数值。 3. 可变参数与固定参数结合 Lua允许你在函数参数列表中同时指定固定参数和可变参数。固定参数需放在可变参数之前。 lua function greet(firstName, lastName, ...) print("Hello, " .. firstName .. " " .. lastName) -- 处理可能存在的附加消息 local messages = {...} if messages > 0 then print("You have additional messages:") for _, message in ipairs(messages) do print("- " .. message) end end end greet("John", "Doe", "Welcome!", "Have a nice day!") 此例中，greet函数首先接受两个固定的姓名参数，然后用“...”捕获任何额外的消息。 总结起来，Lua对可变数量参数的支持为我们的编程提供了极大的便利性和灵活性。掌握并灵活运用这个特性，绝对能让我们在Lua的天地里如鱼得水，轻松应对各种烧脑的需求。甭管是设计函数还是日常敲代码，咱们都能用更贴近人类思维方式的方式来解决问题，而不是被编程语言那些死板的规则给框住手脚。希望以上的讨论和示例代码能够帮助你更好地掌握Lua处理可变参数的方法，从而在你的项目中发挥更大的作用。

...析器在识别代码时发现函数参数列表后缺少闭合大括号（}）而抛出的。本文将通过实例解析、错误原因探讨和解决策略三个方面来帮助你理解和克服这个问题。 1. 错误实例分析 首先，让我们通过几个具体的代码示例来直观感受一下这个错误： javascript // 示例一：忘记在函数体结束时添加闭合大括号 function greet(name) { console.log("Hello, " + name); // 这里遗漏了闭合大括号 } greet("World"); // 运行这段代码将会抛出"SyntaxError: missing '}' after argument list" // 正确的写法应该是： function greet(name) { console.log("Hello, " + name); } // 注意这里加上了闭合的大括号 // 示例二：在匿名函数表达式中同样适用 let sayGoodbye = function(name) { console.log("Goodbye, " + name; }; sayGoodbye("Universe"); // 同样会抛出"SyntaxError: missing '}' after argument list" // 正确的写法应该是： let sayGoodbye = function(name) { console.log("Goodbye, " + name); }; // 匿名函数表达式结束后也需要闭合大括号 2. 错误原因深度解读 这个错误的核心在于JavaScript语法结构的要求。在JavaScript中，函数定义需要遵循特定的语法规则——每个函数声明或函数表达式都必须包含一个参数列表（可能为空）、一个表示函数体开始的左大括号({})以及一个表示函数体结束的右大括号(})。当解析器在扫描到函数参数列表后，如果没有找到预期的右大括号以启动函数体，就会抛出“SyntaxError: missing '}' after argument list”的错误。 3. 解决策略与预防措施 面对这种错误，我们的解决策略主要包括以下几点： 策略一：检查并补全缺失的大括号 仔细审查错误提示所在的函数定义区域，确保函数体已正确地用大括号包裹起来。 策略二：使用IDE或文本编辑器的自动格式化功能 现代IDE如VS Code、WebStorm等通常具备自动格式化代码的功能，它们能在很大程度上避免这类由于疏忽引起的语法错误。 策略三：提升编码规范意识 良好的编程习惯是避免此类错误的重要手段。例如，在定义完函数参数后立即输入左大括号开启函数体，并且在编写完函数体内容后及时补全右大括号。 策略四：利用linting工具进行静态代码检查 诸如ESLint这样的linting工具可以在开发过程中实时检测代码中的潜在问题，包括但不限于未闭合的大括号，从而帮助我们在早期阶段发现问题并修正。 总之，理解并掌握JavaScript的基础语法是避免“SyntaxError: missing '}' after argument list”这类错误的关键。当遇到这个问题时，咱们得稳住心态，像侦探一样抽丝剥茧地去查找原因。同时，千万不能忘了编码规范的重要性，它可是让咱们的代码变得更强壮、更易读、更好维护的大功臣啊！就像是给代码做保养，让它始终活力四溢，易于别人理解和接手。毕竟，无论多么复杂的程序，都是由一个个基础元素构建而成，只有根基稳固，才能高楼万丈。

...该方法期望接收到两个参数：一个是表（table），另一个是要插入到表中的元素。当错误信息提示"bad argument 2 to 'insert'"时，意味着函数接收到的第二个参数存在问题。这里的"2"实际上是指第二个实参，"table expected, got nil"则明确告诉我们，原本应该是一个table类型的参数，但实际获取的是nil。 2. 代码示例与分析 示例一： lua -- 创建一个空表 local myTable = {} -- 尝试向表中插入一个元素，但没有指定要插入哪个表 table.insert(nil, "I am supposed to be in a table!") -- 运行这段代码将会抛出错误：bad argument 1 to 'insert' (table expected, got nil) 在这段代码中，我们试图调用table.insert函数，但作为第一个参数传入了nil而非table，因此出现了上述错误。错误信息中的“1”是因为在Lua中，函数参数是从1开始计数的。 示例二： lua -- 正确创建并初始化一个table local myTable = {"Element 1", "Element 2"} -- 试图插入一个新的元素，但是新元素的引用丢失 local newElement = "New Element" newElement = nil -- 这里将newElement设为nil table.insert(myTable, newElement) -- 运行这段代码将会抛出错误：bad argument 2 to 'insert' (value expected, got nil) 在这个例子中，尽管我们正确提供了table作为table.insert的第一个参数，但第二个参数newElement被设置为了nil，导致插入操作失败。 3. 解决方案与思考过程 理解了错误来源后，解决问题的关键在于确保传递给table.insert的两个参数都是有效的。关于第一个参数，你可得把它搞清楚了，必须是个实实在在的table，不能是nil空空如也；而第二个参数呢，也得瞪大眼睛瞧仔细了，确保它是你真正想塞进那个表里的“良民”，也就是个有效的值。 lua -- 正确的插入操作演示 local myTable = {"Element 1", "Element 2"} -- 确保新元素存在且非nil local newElement = "New Element" table.insert(myTable, newElement) -- 此时不会出现错误 print(table.concat(myTable, ", ")) -- 输出: "Element 1, Element 2, New Element" 在实际编程过程中，我们需要时刻保持警惕，确保对变量的管理和引用是准确无误的，尤其是在进行数据结构操作如插入、删除或更新时。这种精细到每根汗毛的编程习惯，可不只是能帮我们躲开“参数错误”这类小坑，更能给咱们的程序打上一层强心针，让它的稳定性和坚固程度蹭蹭上涨。 总之，面对"bad argument 2 to 'insert' table expected, got nil"这类错误，记住一点：在执行任何修改table的操作前，请先确认所有相关变量都已正确初始化并且指向有效的值。这样一来，你就能把Lua这门超级灵活的语言玩得溜溜的，让它变成你的趁手神器，而不是绊你前进步伐的小石头。

...用泛型，我们可以确保函数能够接受任何类型的列表，而不用担心类型错误。这种灵活性使得我们的代码更加健壮和可重用。 4. 使用case类进行模式匹配 在Scala中，case类是一个非常强大的工具，可以用来创建不可变的数据结构，并且支持模式匹配。利用case类，你可以写出更加清晰和安全的代码。 示例代码 scala sealed trait Result case class Success(value: Int) extends Result case class Failure(message: String) extends Result def processResult(result: Result): Unit = result match { case Success(value) => println(s"Success with value $value") case Failure(message) => println(s"Failure: $message") } processResult(Success(10)) // 输出：Success with value 10 processResult(Failure("Something went wrong")) // 输出：Failure: Something went wrong 在这个例子中，我们定义了一个密封特质Result及其两个子类Success和Failure。通过模式匹配，我们可以安全地处理不同类型的Result对象，而不用担心类型错误。 5. 重视类型别名 有时候，为了提高代码的可读性和可维护性，我们可能会给某些复杂的类型起一个新的名字。这就是类型别名的作用。通过类型别名，我们可以让代码更加简洁明了。 示例代码 scala type UserMap = Map[String, User] def getUserById(id: String)(users: UserMap): Option[User] = users.get(id) val users: UserMap = Map( "1" -> User("Alice"), "2" -> User("Bob") ) getUserById("1")(users) // 返回 Some(User("Alice")) 在这个例子中，我们为Map[String, User]定义了一个类型别名UserMap。这样一来，当我们声明变量或函数参数时，就可以用一个更易读的名字，而不用每次都打那串复杂的 Map[String, User] 了。 6. 结语 好了，今天的分享就到这里啦！希望这些关于Scala类型安全的技巧能对你有所帮助。记住，良好的编码习惯和对类型系统的深入理解，可以帮助我们写出更加健壮和可靠的代码。最后，编程之路漫漫，让我们一起继续探索吧！ --- 以上就是关于Scala中的类型安全的代码审查技巧的全部内容了。如果你有任何疑问或者想了解更多细节，欢迎随时留言交流。希望这篇分享对你有所帮助，也期待你在实际开发中能运用这些技巧写出更好的代码！

...、字段过滤或业务规则校验等，以提升数据质量并满足特定的业务分析需求。 DataRecord , 在SeaTunnel的数据处理过程中，DataRecord是一个基本的数据结构，代表单条记录或事件。它封装了原始数据中的各个字段，并提供了读取、更新字段值的方法。在实现Transform插件时，transform()方法接收一个DataRecord对象作为参数，通过对这个对象的操作来实现对数据流中每一条记录的定制化转换逻辑。

...输出内容、编码转换、参数校验等操作。过滤器通常按照一定的顺序组成过滤器链，每个过滤器负责执行特定的任务，并可以选择是否将请求传递给链中的下一个过滤器。 MVC框架 , MVC是Model-View-Controller（模型-视图-控制器）的缩写，是一种广泛应用于软件工程中，尤其是Web应用程序开发的设计模式。在Struts2这样的MVC框架中，Model代表数据模型，负责存储和管理应用程序的核心数据；View代表视图层，负责渲染和展示用户界面；Controller则是控制器部分，用于接收用户的输入请求，协调Model和View之间的交互，执行相应的业务逻辑并返回结果。通过这种模式，开发者能够更好地组织代码结构，降低各部分间的耦合度，提升程序的灵活性和扩展性。

...，我们使用map函数将这些元组转换为Person对象。因为Person这个对象在创建的时候，它的构造函数需要我们提供两个参数，所以呢，我们就得用上case语句这把“解包神器”，来把元组里的信息给巧妙地提取出来。这个过程中，我们就用到了隐式转换。 六、总结 通过本文，我们了解了什么是隐式转换，以及为什么要使用隐式转换。我们也实实在在地学了几个接地气的例子，这下子可是真真切切地感受到了隐式转换在编程世界里的大显身手和关键作用。在未来的学习和工作中，咱们真该好好地跟“隐式转换”这位大拿交朋友，把它摸得门儿清，用得溜溜的。 总的来说，使用隐式转换可以极大地提高API的易用性，使我们的编程工作更加轻松愉快。作为一名码农，咱可不能停下脚步，得时刻保持对新鲜技术和工具的好奇心，不断磨练自己的编程技艺，让技术水平蹭蹭往上涨。因为编程不仅仅是一门技术，更是一种艺术。

...efined。此外，函数的参数在调用函数之前也是undefined。 3. 代码示例 理解错误原因 假设我们有一个函数getInfo，用于获取用户信息： javascript function getInfo(userId) { return users[userId]; } const users = {}; console.log(getInfo(1)); // undefined, 因为users中没有id为1的用户 这里，由于users对象中不存在userId对应的键，因此getInfo返回的是undefined。如果我们在使用这个函数时直接使用getInfo()（即传入null或undefined），会发生什么呢？ javascript console.log(getInfo(null)); // TypeError: Cannot read properties of null (reading 'userId') 4. 避免错误的策略 4.1 使用条件判断 在调用可能返回null或undefined的方法前，先检查是否为null或undefined： javascript function safeGetInfo(userId) { if (userId !== null && userId !== undefined) { return users[userId]; } else { console.log("User ID not found."); return null; // 或者抛出异常，取决于你的应用需求 } } console.log(safeGetInfo(1)); // 正常返回用户信息 console.log(safeGetInfo(null)); // 输出警告信息并返回null 4.2 使用默认值 在访问属性时，可以使用?.操作符（三元点）或.()（括号访问）来避免错误： javascript const user = users[1] ?? "User not found"; // 使用三元点操作符 // 或者 const user = users[1] || "User not found"; // 使用逻辑或运算符 // 或者使用括号访问 const user = users[(userId === null || userId === undefined) ? "User not found" : userId]; 4.3 使用try...catch块 对于更复杂的逻辑，可以使用try...catch结构来捕获并处理错误： javascript try { const user = users[userId]; } catch (error) { console.error("An error occurred:", error); } 5. 结语 面对“TypeError: null 或 undefined 不能作为对象使用”这样的错误，关键在于理解null和undefined的本质以及它们在JavaScript中的作用。嘿，兄弟！要想避免那些烦人的错误，咱们就得在代码上下点功夫了。比如说，咱们可以用条件判断来分清楚啥时候该做啥，啥时候不该动。再比如，设置个默认值，让程序知道如果啥都没给，就用这个值顶替，免得因为参数没填出问题。还有，咱们别忘了加个错误处理机制，万一程序遇到啥意外，咱就能及时捕捉到，不让它胡乱操作，把事儿搞砸了。这样，咱们的代码就更稳健，更不容易出岔子了！嘿，兄弟！每次你碰到点小错误，那可不就是一次大大的学习机会嘛！就像是在玩游戏时不小心踩了个坑，结果发现了一个新宝藏！你得动手实践，多想想为什么会这样，下次怎么避免。就像你做菜时，多试几次，找到那个完美的味道一样。这样一步步走来，你编程的路就会越走越稳，越来越自信！

...其后添加一个错误处理函数作为第二个参数，可以捕获并处理这些由于语法错误导致的异常。 JSON Schema , 一种用于描述JSON数据结构和验证JSON文档的有效性的标准模式语言。在实际开发中，JSON Schema为JSON数据提供了一种形式化的约束方式，开发者可以根据预先定义好的Schema对JSON数据进行严格的校验，确保数据满足特定格式要求。例如，GitHub在其API中采用JSON Schema，这样当开发者提交或接收数据时，系统可以通过Schema自动检查JSON数据的有效性和完整性，从而降低因数据格式不匹配引发的问题，并提高API接口的健壮性与数据交互质量。 JSON Web Tokens（JWT） , 这是一种开放的标准（RFC 7519），用于在网络应用环境间安全地传输声明信息。JWT通常用于用户身份验证和授权，由服务器生成并通过HTTP头部发送给客户端，然后客户端在后续请求中携带此Token以便服务器进行验证。JWT本质上是一个经过数字签名的JSON对象，包含了header（头部）、payload（载荷）和signature（签名）三部分，确保了传输过程中的数据不可篡改且具有一定的时效性。任何不符合JWT规范的Token都将被拒绝，这一机制在一定程度上也体现了对JSON异常处理技术的应用和扩展。

...通过配置文件或命令行参数指定要备份的具体数据库或表。 1.2 恢复备份 当发生数据丢失时，可以利用备份文件进行恢复： bash clickhouse-backup restore backup_name 执行上述命令后，ClickHouse将会从备份中恢复所有数据。千万要注意啊，伙计，在你动手进行恢复操作之前，得先瞧瞧目标集群是不是空空如也，或者你是否能接受数据被覆盖这个可能的结果。 2. 使用Replication（复制）机制 2.1 配置Replicated表 ClickHouse支持ZooKeeper或Raft协议实现的多副本复制功能。例如，创建一个分布式且具有复制特性的表： sql CREATE TABLE replicated_table ( ... ) ENGINE = ReplicatedMergeTree('/clickhouse/tables/{database}/{table}', 'replica1') PARTITION BY ... ORDER BY ... 这里，/clickhouse/tables/{database}/{table}是一个 ZooKeeper 路径，用于协调多个副本之间的数据同步；'replica1'则是当前副本标识符。 2.2 数据自动同步与容灾 一旦某台服务器上的数据出现异常，其他拥有相同Replicated表的服务器仍保留完整的数据。当有新的服务器小弟加入集群大家庭，或者主节点大哥不幸挂掉的时候，Replication机制这个超级替补队员就会立马出动，自动把数据同步得妥妥的，确保所有数据都能保持一致性、完整性，一个字都不会少。 3. 数据一致性检查与修复 3.1 使用checksum函数 ClickHouse提供checksum函数来计算表数据的校验和，可用于验证数据是否完整： sql SELECT checksum() FROM table_name; 定期执行此操作并记录结果，以便在后续时间点对比校验和的变化，从而发现可能的数据丢失问题。 3.2 表维护及修复 若发现数据不一致，可以尝试使用OPTIMIZE TABLE命令进行表维护和修复： sql OPTIMIZE TABLE table_name FINAL; 该命令会重新整理表数据，并尝试修复任何可能存在的数据损坏问题。 4. 实践思考与探讨 尽管我们可以通过上述方法来减少和应对ClickHouse中的数据丢失风险，但防患于未然总是最优策略。在搭建和运用ClickHouse系统的时候，千万记得要考虑让它“坚如磐石”，也就是要设计出高可用性方案。比如说，我们可以采用多副本这种方式，就像备份多个小帮手一样，让数据安全无忧；再者，跨地域冗余存储也是一招妙计，想象一下，即使地球另一边的机房挂了，这边的数据也能照常运作，这样就大大提升了系统的稳健性和可靠性啦！同时，建立一个完善、接地气的数据监控系统，能够灵敏捕捉并及时解决那些可能冒头的小问题，这绝对是一个无比关键的步骤。 总结起来，面对ClickHouse数据丢失问题，我们需采取主动防御和被动恢复相结合的方式，既要做好日常的数据备份和Replication配置，也要学会在问题发生后如何快速有效地恢复数据，同时结合数据一致性检查以及表维护等手段，全面提升数据的安全性和稳定性。在实践中不断优化和完善，才能真正发挥出ClickHouse在海量数据分析领域的强大威力。

... 实例三 类型转换与函数参数 考虑这样一个场景，你需要将不同的类型作为函数的参数传递，而这些类型之间可能存在转换的需求： cpp include template auto add(T a, U b) -> decltype(a + b) { return a + b; } int main() { int a = 5; float b = 3.14; auto result = add(a, b); std::cout << "a + b = " << result << std::endl; return 0; } 这里我们定义了一个模板函数add，它可以接受任意类型的参数，并且通过decltype确保了返回类型的一致性，即使输入类型不同。 6. 结论 从困惑到精通 通过以上的示例和讨论，我们可以看到类型不匹配在C++编程中的常见性和解决方法。哎呀，这事儿关键啊，就是得搞懂不同类型的转换规则，还有怎么在编程的时候机智地用上类型转换，这样子才能避免踩坑！就像是在玩变形金刚的游戏，知道怎么变形成不同的形态，才能在战斗中游刃有余，对吧？所以，这事儿可得仔细琢磨，别让小错误给你整得满头大汗的。随着实践的增多，你会逐渐习惯于处理这类问题，从而在编程过程中更加游刃有余。 编程是一门艺术，也是一门需要不断学习和实践的技能。哎呀，遇到C++这种语言的类型不匹配问题了？别急，咱得有点好奇心，敢想敢干才行！就像在探险一样，每次遇到难题都是新发现的机会。别怕动手尝试，多实践几次，你会发现，驾驭这门强大的语言其实挺有趣的。就像解开一个又一个谜题，每一次成功都让你成就感满满。别忘了，创作精彩代码，就跟做艺术品一样，需要点想象力和创意。加油，你肯定能做出让人眼前一亮的作品！

...ick点击事件，绑定函数2.在函数中，进行表单校验(非空校验、 合法性校验等)3.如果校验通过，则手动提交表单表单对象.submit();二、使用提交按钮type="submit"1.给按钮绑定click点击事件，绑定函数2.函数需要有返回值，返回true或false (如果return false, 则表单不会提交:如果return true，则提交表单）onclick="return 函数名()"3.在函数中，进行表单校验(非空校验、 合法性校验等)4.如果校验通过，返回true;如果校验不通过，则返回false, 则表单不会提交:如果return true，则提交表单）三、使用提交按钮type="submit"1.给表单form元素绑定submit提交事件，绑定函数2.函数需要有返回值，返回true或false (如果return false, 则表单不会提交;如果return trueonsubmit="return函数名()" 3.在函数中，进行表单校验(非空校验、 合法性校验等)4.如果校验通过，返回true;如果校验不通过，则返回false <!--使用普逍按钮 type= "button"--><form id= 'myform' name= "myform" action="http://www.baidu.com" method="get" >姓名: <input name= "uname" id="uname"/>  <span id = "msg" style="font-s1ze: 12px; color: red;"></span><br /><button type="button" onclick="submitForm1()">提交</button></form><!--使用提交按钮 type= "submit"--><form id= 'myform2' name= "myform2" action="http://www.baidu.com" method="get" >姓名: <input name= "uname2" id="uname2"/>  <span id = "msg2" style="font-s1ze: 12px; color: red;"></span><br /><button type="submit" onclick="return submitForm2()">提交</button></form><!--使用提交按钮 type= "submit"--><form id= 'myform3' name= "myform3" action="http://www.baidu.com" method="get" onsubmit="return submitForm3()">姓名: <input name= "uname3" id="uname3"/>  <span id = "msg3" style="font-s1ze: 12px; color: red;"></span><br /><button type="submit">提交</button></form><script type="text/javascript">// 表单校验// 提交表单function submitForm1() {//得到文本框的值var uname = document.getElementById("uname").value;//判断是否为空if (isEmpty(uname)) { //为空//设置提示信息(设置span元素的值)document.getElementById("msg").innerHTML="性名不能为空!" ;//阻止表单提交return;}//手动提交表单document.getElementById("myform").submit(); }function submitForm2() {//得到文本框的值var uname2 = document.getElementById("uname2").value;//判断是否为空if (isEmpty(uname2)) { //为空//设置提示信息(设置span元素的值)document.getElementById("msg2").innerHTML="性名不能为空!" ;//阻止表单提交return false;}return true;}function submitForm3() {//得到文本框的值var uname3 = document.getElementById("uname3").value;//判断是否为空if (isEmpty(uname3)) { //为空//设置提示信息(设置span元素的值)document.getElementById("msg3").innerHTML="性名不能为空!" ;//阻止表单提交return false;}return true;}/ 判断字符串是否为空如果为空，返回true如果非空，返回falsetrim() :字符串方法， 去除字符串前后空格@param {Object} str/function isEmpty(str) {//判断是否为空if (str == null || str.trim() == "") {return true;}return false;}</script> 运行效果截图： 四、原生Ajax实现流程 <!-- Ajax 异步无刷新技术原生Ajax的实现流程1.得到XMLHttpRequest对象var xhr = new XMLHttpRequest();2.打开请求xhr.open(method, uri, async) ;method:请求方式，通常是GEI|POSTurl:请求地址async:是否异步。如果是true表示异步，false表示同步3.发送请求xhr.send(params);params:请求时需要传递的参数如果是GET请求，设置nu11。 (GET请求的参数设置在url后面)如果是POST请求，无参数设置为null，有参数则设置参数4.接收响应xhr.status响应状态(200=响应成功， 404=资源末找到，500=服务器异常)xhr.responseText 得到响应结果 --> <script type="text/javascript">// 同步请求function text01() {// 1.得到XMLHttpRequest对象var xhr = new XMLHttpRequest();// 2.打开请求xhr.open("get", "js/date.json", false);// 3.发送请求xhr.send(null);// 4.判断响应状态if (xhr.status == 200) {console.log("响应成功");} else {console.log("状态码：" + xhr.status + "，原因：" + xhr.responseText)}console.log("同步请求...");}text01();// 异步请求function text02() {// 1.得到XMLHttpRequest对象var xhr = new XMLHttpRequest();// 2.打开请求xhr.open("get", "js/date.json", true);// 3.发送请求xhr.send(null);// 由于是异步请求，所以需要知道后台已经将请求处理完毕，才能获取响应结果// 遇过监听readyState的变化来得知后面的处理状态 4=完全处理xhr.onreadystatechange = function(){if(xhr.readyState == 4){// 4.判断响应状态if (xhr.status == 200) {// 得到响应结果 console.log(xhr.responseText);} else {console.log("状态码：" + xhr.status + "，原因：" + xhr.responseText)} }}console.log("异步请求...");}text02();</script> 运行效果截图： 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_61507413/article/details/122895643。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。