[前端开发中函数参数的使用]的搜索结果

...lin：一场关于无效参数的冒险 引子：一次突如其来的挑战 在编程的世界里，Kotlin以其简洁明了的语法、强大的类型安全机制以及对Java语言的兼容性，赢得了无数开发者的心。哎呀，兄弟，你这语言用得确实牛批，但就像开车一样，再溜的车也难免会碰上坑坑洼洼。在这堆问题里头，有一种特别让人头疼的家伙，叫 IllegalArgumentException。这家伙就像是突然冒出来的路障，让你措手不及，一不小心就踩中了，结果就是程序卡壳，半天解不开。这不就是我们在编程路上的“小麻烦”嘛！今天，我们就来一起探索一下这个“非法参数异常”背后的故事。 第一章：何为 IllegalArgumentException 在Kotlin中，当我们尝试调用一个方法时，如果传入的参数不符合该方法的要求或者类型不匹配，就会抛出 IllegalArgumentException。这事儿就像你去参加一个超级认真的补习班，老师布置了一道题目让你做，结果你交上去的答案全错了，那肯定得被老师好好点名批评一番了。 第二章：深入剖析 IllegalArgumentException 假设我们有一个简单的函数 calculateAge，它接受一个人的出生年份作为参数，并计算出当前年龄： kotlin fun calculateAge(birthYear: Int): Int { val currentYear = 2023 return currentYear - birthYear } 如果我们不小心传入了一个非整数类型的参数，比如一个字符串，Kotlin会立即察觉到这一点，并优雅地抛出 IllegalArgumentException： kotlin fun test() { val age = calculateAge("2000") println("Your age is $age.") } // 运行结果：编译错误，因为calculateAge接受的是Int类型参数，而"2000"是String类型。 第三章：如何避免 IllegalArgumentException 避免 IllegalArgumentException 的关键在于确保所有传入函数的参数都符合预期的类型和格式。我们可以利用Kotlin的静态类型系统来帮助我们进行这一工作： - 类型检查：确保所有输入的参数都是正确的类型。例如，可以使用 assert 函数在运行时验证类型： kotlin fun safeCalculateAge(birthYear: Any): Int { assert(birthYear is Int) { "Expected an Integer for birthYear" } val currentYear = 2023 return currentYear - birthYear.toInt() } // 使用示例： val age = safeCalculateAge(2000) println("Your age is $age.") - 函数参数验证：在定义函数时就加入类型检查逻辑： kotlin fun calculateAgeWithValidation(birthYear: Int): Int { if (birthYear < 0 || birthYear > 2023) { throw IllegalArgumentException("Birth year must be within the range of 0 to 2023.") } val currentYear = 2023 return currentYear - birthYear } 第四章：实战演练：创建一个更复杂的示例 假设我们要构建一个简单的日历应用，其中包含一个用于计算天数的函数。为了增加复杂性，我们添加了对月份和年份的验证： kotlin data class Date(val day: Int, val month: Int, val year: Int) fun calculateDaysSinceBirthday(dateOfBirth: Date): Int { val currentYear = Calendar.getInstance().get(Calendar.YEAR) val currentMonth = Calendar.getInstance().get(Calendar.MONTH) + 1 // 注意月份是从0开始的 val currentDay = Calendar.getInstance().get(Calendar.DAY_OF_MONTH) val birthday = dateOfBirth.day to dateOfBirth.month to dateOfBirth.year val birthDate = Date(birthday) val daysSinceBirthday = (currentYear - birthDate.year) 365 + (currentMonth - birthDate.month) 30 + (currentDay - birthDate.day) return daysSinceBirthday } fun main() { val birthDate = Date(day = 1, month = 1, year = 2000) val days = calculateDaysSinceBirthday(birthDate) println("Days since your birthday: $days") } 在上面的代码中，我们通过 Calendar 类获取当前日期，并与生日日期进行比较，计算出天数差值。嘿，兄弟！咱们就拿一年有365天，一个月有30天来打个比方，这可是咱们简化了一下，方便大家理解。实际上啊，生活里头可没这么简单，得分清闰年和普通年是怎么回事，这样日子才过得有模有样呢！ 结语：面对挑战，拥抱学习 每一次遇到 IllegalArgumentException 都是一次学习的机会。它们提醒我们，即使在看似完美的代码中，也可能隐藏着一些小错误。通过仔细检查和验证我们的参数，我们可以编写出更加健壮、可维护的代码。哎呀，你瞧这Kotlin，它可真是个能手呢！它那一大堆好用的工具和特性，就像是魔法一样，帮我们解决了好多麻烦事儿。比如说，静态类型这一招，就像是一道坚固的防线，能提前发现那些可能出错的地方。还有函数注解，就像是给代码贴上了标签，让我们一眼就能看出这是干啥的。而模式匹配嘛，简直就是解谜神器，轻轻松松就能解开那些复杂的逻辑难题。这些玩意儿合在一起，就形成了一个强大的武器库，帮我们防患于未然，解决问题更是不在话下。你说是不是，这Kotlin，简直就是程序员的好伙伴！让我们带着好奇心和探索精神，继续在编程的海洋中航行吧！ --- 在这篇文章中，我们不仅探讨了 IllegalArgumentException 的由来和解决方法，还通过一系列的代码示例展示了如何在实践中应用这些知识。嘿，兄弟！读完这篇文章后，希望你对Kotlin里的异常处理方式有了一番全新的领悟。别担心，这不像是AI在跟你说话，就像跟老朋友聊天一样轻松。你得尝试将这些小技巧应用到你的实际项目中，让代码不仅好看，而且超级稳定，就像是给你的程序穿上了一件坚固的盔甲。这样，无论遇到什么问题，它都能稳如泰山。所以，拿起你的键盘，动手实践吧！记住，编程是一场持续的学习之旅，每一次遇到困难都是成长的机会。加油！

...密码啥的）的服务。对开发者而言，安全这事得放首位，要是还用那种硬编码或者直接把密钥啥的写进配置文件的老办法，那简直就是在玩火自焚啊！Google Cloud Secret Manager 提供了加密存储、访问控制等功能，简直是保护秘钥的最佳选择之一。 所以，当我把这两者放在一起的时候，脑海里立刻浮现出一个画面：Tornado 快速响应前端请求，而 Secret Manager 在背后默默守护着那些珍贵的秘密。是不是很带感？接下来我们就一步步深入探索它们的合作方式吧！ --- 2. 初识Tornado 搭建一个简单的Web服务 既然要玩转 Tornado，咱们得先搭个基础框架才行。好嘞，接下来我就简单搞个小网页服务，就让它回一句暖心的问候就行啦！虽然看起来简单，但这可是后续一切的基础哦！ python import tornado.ioloop import tornado.web class MainHandler(tornado.web.RequestHandler): def get(self): self.write("Hello, Tornado!") def make_app(): return tornado.web.Application([ (r"/", MainHandler), ]) if __name__ == "__main__": app = make_app() app.listen(8888) print("Server started at http://localhost:8888") tornado.ioloop.IOLoop.current().start() 这段代码超级简单对不对？我们定义了一个 MainHandler 类继承自 tornado.web.RequestHandler，重写了它的 get 方法，当收到 GET 请求时就会执行这个方法，并向客户端返回 "Hello, Tornado!"。然后呢，就用 make_app 这个函数把路由和这个处理器绑在一起，最后再启动服务器，让它开始监听 8888 端口。 运行后打开浏览器输入 http://localhost:8888，就能看到页面显示 "Hello, Tornado!" 了。是不是特别爽？不过别急着高兴，这只是万里长征的第一步呢！ --- 3. 引入Google Cloud Secret Manager：让秘密不再裸奔 现在我们知道如何用 Tornado 做点事情了，但问题是，如果我们的应用程序需要用到一些敏感信息（例如数据库连接字符串），该怎么办呢？直接写在代码里吗？当然不行！这就是为什么我们要引入 Google Cloud Secret Manager。 3.1 安装依赖库 首先需要安装 Google Cloud 的官方 Python SDK： bash pip install google-cloud-secret-manager 3.2 获取Secret Manager中的值 假设我们在 Google Cloud Console 上已经创建了一个名为 my-secret 的密钥，并且它里面保存了我们的数据库密码。我们可以这样从 Secret Manager 中读取这个值： python from google.cloud import secretmanager def access_secret_version(project_id, secret_id, version_id): client = secretmanager.SecretManagerServiceClient() name = f"projects/{project_id}/secrets/{secret_id}/versions/{version_id}" response = client.access_secret_version(name=name) payload = response.payload.data.decode('UTF-8') return payload 使用示例 db_password = access_secret_version("your-project-id", "my-secret", "latest") print(f"Database Password: {db_password}") 这段代码做了什么呢？很简单，它实例化了一个 SecretManagerServiceClient 对象，然后根据提供的项目 ID、密钥名称以及版本号去访问对应的密钥内容。注意这里的 version_id 参数可以设置为 "latest" 来获取最新的版本。 --- 4. 将两者结合起来 构建更安全的应用 那么问题来了，怎么才能让 Tornado 和 Google Cloud Secret Manager 协同工作呢？其实答案很简单——我们可以将从 Secret Manager 获取到的敏感数据注入到 Tornado 的配置对象中，从而在整个应用范围内使用这些信息。 4.1 修改Tornado应用以支持从Secret Manager加载配置 让我们修改之前的 MainHandler 类，让它从 Secret Manager 中加载数据库密码并用于某种操作（比如查询数据库）。为了简化演示，这里我们假设有一个 get_db_password 函数负责完成这项任务： python from google.cloud import secretmanager def get_db_password(): client = secretmanager.SecretManagerServiceClient() name = f"projects/{YOUR_PROJECT_ID}/secrets/my-secret/versions/latest" response = client.access_secret_version(name=name) return response.payload.data.decode('UTF-8') class MainHandler(tornado.web.RequestHandler): def initialize(self, db_password): self.db_password = db_password def get(self): self.write(f"Connected to database with password: {self.db_password}") def make_app(): db_password = get_db_password() return tornado.web.Application([ (r"/", MainHandler, {"db_password": db_password}), ]) 在这个例子中，我们在 make_app 函数中调用了 get_db_password() 来获取数据库密码，并将其传递给 MainHandler 的构造函数作为参数。这样一来，每个 MainHandler 实例都会拥有自己的数据库密码属性。 --- 5. 总结与展望 好了朋友们，今天的分享就到这里啦！通过这篇文章，我们了解了如何利用 Tornado 和 Google Cloud Secret Manager 来构建更加安全可靠的 Web 应用。虽然过程中遇到了不少挑战，但最终的效果还是让我感到非常满意。 未来的话，我还想尝试更多有趣的功能组合，比如结合 Redis 缓存提高性能，或者利用 Pub/Sub 实现消息队列机制。如果你也有类似的想法或者遇到什么问题，欢迎随时跟我交流呀！ 最后祝大家 coding愉快，记得保护好自己的秘密哦~ 😊

...2. Proxy基本使用 2.1 Proxy 的 set 和 get 捕获器 2.2 Proxy 所有捕获器 (13个) 2.3 Proxy 的 construct 和 apply 3. Reflect 3.1 Reflect 的作用 3.2 Reflect 的常见方法 3.3 Reflect 的使用 3.4 Receiver的作用 3.5 Reflect 的 construct 4. 响应式 4.1 什么是响应式？ 4.2 响应式函数设计 4.3 响应式依赖的收集 4.4 监听对象的变化 4.5 对象的依赖管理 4.6 对 Depend 重构 4.7 创建响应式对象 4.8 Vue2 响应式原理 Proxy 、Relect、响应式 1. 监听对象的操作 需求：有一个对象，我们希望监听这个对象中的属性被设置或获取的过程 可以通过属性描述符中的存储属性描述符来做到 这段代码就利用了 Object.defineProperty 的存储属性描述符来对属性的操作进行监听 const obj = {name: 'why',age: 18}Object.keys(obj).forEach((key) => {let value = obj[key]Object.defineProperty(obj, key, {get: function () {console.log(监听到obj对象的${key}属性被访问了)return value},set: function (newValue) {console.log(监听到obj对象的${key}属性被设置值)value = newValue} })})obj.name = 'kobe'obj.age = 30console.log(obj.name)console.log(obj.age)/ 监听到obj对象的name属性被设置值监听到obj对象的age属性被设置值监听到obj对象的name属性被访问了kobe监听到obj对象的age属性被访问了30/ 属性描述符监听对象的缺点： 首先，Object.defineProperty 设计的初衷，不是为了去监听截止一个对象中所有的属性的 我们在定义某些属性的时候，初衷其实是定义普通的属性，但是后面我们强行将它变成了数据属性描述符 其次，如果我们想监听更加丰富的操作，比如新增属性、删除属性，那么 Object.defineProperty 是无能为力的 所以我们要知道，存储数据描述符设计的初衷并不是为了去监听一个完整的对象 Ps: 原来的对象是 数据属性描述符，通过 Object.defineProperty 变成了 访问属性描述符 2. Proxy基本使用 在ES6中，新增了一个Proxy类，这个类从名字就可以看出来，是用于帮助我们创建一个代理的： 也就是说，如果我们希望监听一个对象的相关操作，那么我们可以先创建一个代理对象（Proxy对象） 之后对该对象的所有操作，都通过代理对象来完成，代理对象可以监听我们想要对原对象进行哪些操作 将上面的案例用 Proxy 来实现一次： 首先，我们需要 new Proxy 对象，并且传入需要侦听的对象以及一个处理对象，可以称之为 handler； const p = new Proxy(target, handler) 其次，我们之后的操作都是直接对 Proxy 的操作，而不是原有的对象，因为我们需要在 handler 里面进行侦听 const obj = {name: 'why',age: 18}const objProxy = new Proxy(obj, {// 获取值时的捕获器get: function (target, key) {console.log(监听到obj对象的${key}属性被访问了)return target[key]},// 设置值时的捕获器set: function (target, key, newValue) {console.log(监听到obj对象的${key}属性被设置值)target[key] = newValue} })console.log(objProxy.name)console.log(objProxy.age)objProxy.name = 'kobe'objProxy.age = 30console.log(obj.name)console.log(obj.age)/ 监听到obj对象的name属性被访问了why监听到obj对象的age属性被访问了18监听到obj对象的name属性被设置值监听到obj对象的age属性被设置值kobe30/ 2.1 Proxy 的 set 和 get 捕获器 如果我们想要侦听某些具体的操作，那么就可以在 handler 中添加对应的捕捉器（Trap） set 和 get 分别对应的是函数类型 set 函数有四个参数： target：目标对象（侦听的对象） property：将被设置的属性 key value：新属性值 receiver：调用的代理对象 get 函数有三个参数 target：目标对象（侦听的对象） property：被获取的属性 key receiver：调用的代理对象 2.2 Proxy 所有捕获器 (13个) handler.getPrototypeOf() Object.getPrototypeOf 方法的捕捉器 handler.setPrototypeOf() Object.setPrototypeOf 方法的捕捉器 handler.isExtensible() Object.isExtensible 方法的捕捉器 handler.preventExtensions() Object.preventExtensions 方法的捕捉器 handler.getOwnPropertyDescriptor() Object.getOwnPropertyDescriptor 方法的捕捉器 handler.defineProperty() Object.defineProperty 方法的捕捉器 handler.ownKeys() Object.getOwnPropertyNames 方法和 Object.getOwnPropertySymbols 方法的捕捉器 handler.has() in 操作符的捕捉器 handler.get() 属性读取操作的捕捉器 handler.set() 属性设置操作的捕捉器 handler.deleteProperty() delete 操作符的捕捉器 handler.apply() 函数调用操作的捕捉器 handler.construct() new 操作符的捕捉器 const obj = {name: 'why',age: 18}const objProxy = new Proxy(obj, {// 获取值时的捕获器get: function (target, key) {console.log(监听到obj对象的${key}属性被访问了)return target[key]},// 设置值时的捕获器set: function (target, key, newValue) {console.log(监听到obj对象的${key}属性被设置值)target[key] = newValue},// 监听 in 的捕获器has: function (target, key) {console.log(监听到obj对象的${key}属性的in操作)return key in target},// 监听 delete 的捕获器deleteProperty: function (target, key) {console.log(监听到obj对象的${key}属性的delete操作)delete target[key]} })// in 操作符console.log('name' in objProxy)// delete 操作delete objProxy.name/ 监听到obj对象的name属性的in操作true监听到obj对象的name属性的delete操作/ 2.3 Proxy 的 construct 和 apply 到捕捉器中还有 construct 和 apply，它们是应用于函数对象的 function foo() {console.log('调用了 foo')}const fooProxy = new Proxy(foo, {apply: function (target, thisArg, argArray) {console.log(对 foo 函数进行了 apply 调用)target.apply(thisArg, argArray)},construct: function (target, argArray, newTarget) {console.log(对 foo 函数进行了 new 调用)return new target(...argArray)} })fooProxy.apply({}, ['abc', 'cba'])new fooProxy('abc', 'cba')/ 对 foo 函数进行了 apply 调用调用了 foo对 foo 函数进行了 new 调用调用了 foo/ 3. Reflect 3.1 Reflect 的作用 Reflect 也是 ES6 新增的一个 API，它是一个对象，字面的意思是反射 Reflect 的作用： 它主要提供了很多操作 JavaScript 对象的方法，有点像 Object 中操作对象的方法 比如 Reflect.getPrototypeOf(target) 类似于 Object.getPrototypeOf() 比如 Reflect.defineProperty(target, propertyKey, attributes) 类似于 Object.defineProperty() 如果我们有 Object 可以做这些操作，那么为什么还需要有Reflect这样的新增对象呢？ 这是因为在早期的 ECMA 规范中没有考虑到这种对 对象本身 的操作如何设计会更加规范，所以将这些 API 放到了 Object上面 但是 Object 作为一个构造函数，这些操作实际上放到它身上并不合适 另外还包含一些类似于 in、delete 操作符，让 JS 看起来是会有一些奇怪的 所以在 ES6 中新增了 Reflect，让我们这些操作都集中到了 Reflect 对象上 那么 Object 和 Reflect 对象之间的 API 关系，可以参考 MDN 文档： 比较 Reflect 和 Object 方法 3.2 Reflect 的常见方法 Reflect中有哪些常见的方法呢？它和Proxy是一一对应的，也是13个 Reflect.getPrototypeOf(target) 类似于 Object.getPrototypeOf() Reflect.setPrototypeOf(target, prototype) 设置对象原型的函数. 返回一个 Boolean， 如果更新成功，则返回 true Reflect.isExtensible(target) 类似于 Object.isExtensible() Reflect.preventExtensions(target) 类似于 Object.preventExtensions() , 返回一个 Boolean Reflect.getOwnPropertyDescriptor(target, propertyKey) 类似于 Object.getOwnPropertyDescriptor() , 如果对象中存在该属性，则返回对应的属性描述符, 否则返回 undefined Reflect.defineProperty(target, propertyKey, attributes) 和 Object.defineProperty() 类似, 如果设置成功就会返回 true Reflect.ownKeys(target) 返回一个包含所有自身属性（不包含继承属性）的数组 （类似于 Object.keys(), 但不会受 enumerable 影响） Reflect.has(target, propertyKey) 判断一个对象是否存在某个属性，和 in 运算符 的功能完全相同 Reflect.get(target, propertyKey[, receiver]) 获取对象身上某个属性的值，类似于 target[name] Reflect.set(target, propertyKey, value[, receiver]) 将值分配给属性的函数，返回一个 Boolean，如果更新成功，则返回 true Reflect.deleteProperty(target, propertyKey) 作为函数的 delete 操作符，相当于执行 delete target[name] Reflect.apply(target, thisArgument, argumentsList) 对一个函数进行调用操作，同时可以传入一个数组作为调用参数。和 Function.prototype.apply() 功能类似 Reflect.construct(target, argumentsList[, newTarget]) 对构造函数进行 new 操作，相当于执行 new target(...args) 3.3 Reflect 的使用 那么我们可以将之前Proxy案例中对原对象的操作，都修改为Reflect来操作 const obj = {name: 'why',age: 18}const objProxy = new Proxy(obj, {get: function (target, key) {console.log(监听到obj对象的${key}属性被访问了)return Reflect.get(target, key)// return target[key] // 对原来对象进行了直接操作},set: function (target, key, newValue) {console.log(监听到obj对象的${key}属性被设置值)Reflect.set(target, key, newValue)// target[key] = newValue // 对原来对象进行了直接操作} })objProxy.name = 'kobe'console.log(objProxy.name)/ 监听到obj对象的name属性被设置值监听到obj对象的name属性被访问了kobe/ 3.4 Receiver的作用 我们发现在使用getter、setter的时候有一个receiver的参数，它的作用是什么呢？ 如果我们的源对象（obj）有 setter 、getter 的访问器属性，那么可以通过 receiver 来改变里面的 this const obj = {_name: 'why',get name() {return this._name // 不使用receiver, _name属性的操作不会被objProxy代理，因为this指向obj},set name(newValue) {this._name = newValue} }const objProxy = new Proxy(obj, {get: function (target, key, receiver) {// receiver 是创建出来的代理对象console.log('get 方法被访问-------', key, receiver)console.log(objProxy === receiver) // truereturn Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)} })objProxy.name = 'kobe'console.log(objProxy.name) // kobe/ get 方法被访问------- name { _name: 'kobe', name: [Getter/Setter] }trueget 方法被访问------- _name { _name: 'kobe', name: [Getter/Setter] }truekobe/ 3.5 Reflect 的 construct function Student(name, age) {this.name = namethis.age = age}function Teacher() {}const stu = new Student('why', 18)console.log(stu)console.log(stu.__proto__ === Student.prototype)/ Student { name: 'why', age: 18 }true/// 执行 Student 函数中的内容，但是创建出来的对象是 Teacher 对象const teacher = Reflect.construct(Student, ['why', 18], Teacher)console.log(teacher)console.log(teacher.__proto__ === Teacher.prototype)/ Teacher { name: 'why', age: 18 }true/ 4. 响应式 4.1 什么是响应式？ 先来看一下响应式意味着什么？我们来看一段代码： m 有一个初始化的值，有一段代码使用了这个值； 那么在 m 有一个新的值时，这段代码可以自动重新执行 let m = 0// 一段代码console.log(m)console.log(m 2)console.log(m 2)m = 200 上面的这样一种可以自动响应数据变量的代码机制，我们就称之为是响应式的 对象的响应式 4.2 响应式函数设计 首先，执行的代码中可能不止一行代码，所以我们可以将这些代码放到一个函数中： 那么问题就变成了，当数据发生变化时，自动去执行某一个函数； 但是有一个问题：在开发中是有很多的函数的，如何区分一个函数需要响应式，还是不需要响应式呢？ 很明显，下面的函数中 foo 需要在 obj 的 name 发生变化时，重新执行，做出相应； bar 函数是一个完全独立于 obj 的函数，它不需要执行任何响应式的操作； // 对象的响应式const obj = {name: 'why',age: 18}function foo() {const newName = obj.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(obj.name)}function bar() {console.log('普通的其他函数')console.log('这个函数不需要有任何的响应式')}obj.name = 'kobe' // name 发生改变时候 foo 函数执行 响应式函数的实现 watchFn 如何区分响应式函数？ 这个时候我们封装一个新的函数 watchFn 凡是传入到 watchFn 的函数，就是需要响应式的 其他默认定义的函数都是不需要响应式的 / 封装一个响应式的函数 /let reactiveFns = []function watchFn(fn) {reactiveFns.push(fn)}// 对象的响应式const obj = {name: 'why',age: 18}watchFn(function foo() {const newName = obj.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(obj.name)})watchFn(function demo() {console.log(obj.name, 'demo function ---------')})function bar() {console.log('普通的其他函数')console.log('这个函数不需要有任何的响应式')}obj.name = 'kobe' // name 发生改变时候 foo 函数执行reactiveFns.forEach((fn) => {fn()}) 4.3 响应式依赖的收集 目前收集的依赖是放到一个数组中来保存的，但是这里会存在数据管理的问题： 在实际开发中需要监听很多对象的响应式 这些对象需要监听的不只是一个属性，它们很多属性的变化，都会有对应的响应式函数 不可能在全局维护一大堆的数组来保存这些响应函数 所以要设计一个类，这个类用于管理某一个对象的某一个属性的所有响应式函数： 相当于替代了原来的简单 reactiveFns 的数组； class Depend {constructor() {this.reactiveFns = []}addDepend(reactiveFn) {this.reactiveFns.push(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }const depend = new Depend()function watchFn(fn) {depend.addDepend(fn)}// 对象的响应式const obj = {name: 'why', // depend 对象age: 18 // depend 对象}watchFn(function foo() {const newName = obj.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(obj.name)})watchFn(function demo() {console.log(obj.name, 'demo function ---------')})function bar() {console.log('普通的其他函数')console.log('这个函数不需要有任何的响应式')}obj.name = 'kobe'depend.notify() 4.4 监听对象的变化 那么接下来就可以通过之前的方式来监听对象的变化： 方式一：通过 Object.defineProperty 的方式（vue2采用的方式）； 方式二：通过 new Proxy 的方式（vue3采用的方式）； 我们这里先以Proxy的方式来监听 class Depend {constructor() {this.reactiveFns = []}addDepend(reactiveFn) {this.reactiveFns.push(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }const depend = new Depend()function watchFn(fn) {depend.addDepend(fn)}// 对象的响应式const obj = {name: 'why', // depend 对象age: 18 // depend 对象}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)depend.notify()} })watchFn(function foo() {const newName = objProxy.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(objProxy.name)})watchFn(function demo() {console.log(objProxy.name, 'demo function ---------')})objProxy.name = 'kobe'objProxy.name = 'james'/ 你好啊，李银河Hello Worldkobekobe demo function ---------你好啊，李银河Hello Worldjamesjames demo function ---------/ 4.5 对象的依赖管理 目前是创建了一个 Depend 对象，用来管理对于 name 变化需要监听的响应函数： 但是实际开发中我们会有不同的对象，另外会有不同的属性需要管理； 如何可以使用一种数据结构来管理不同对象的不同依赖关系呢？ 在前面我们刚刚学习过 WeakMap，并且在学习 WeakMap 的时候我讲到了后面通过 WeakMap 如何管理这种响应式的数据依赖： 实现 可以写一个 getDepend 函数专门来管理这种依赖关系 / 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取mapconst map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象const depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} }) 正确的依赖收集 我们之前收集依赖的地方是在 watchFn 中： 但是这种收集依赖的方式我们根本不知道是哪一个 key 的哪一个 depend 需要收集依赖； 只能针对一个单独的 depend 对象来添加你的依赖对象； 那么正确的应该是在哪里收集呢？应该在我们调用了 Proxy 的 get 捕获器时 因为如果一个函数中使用了某个对象的 key，那么它应该被收集依赖 / 封装一个响应式函数 /let activeReactviceFn = nullfunction watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {// 根据 target key 获取对应的 depnedconst depend = getDepend(target, key)// 给 depend 对象中添加响应式函数activeReactviceFn && depend.addDepend(activeReactviceFn)return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} }) 4.6 对 Depend 重构 两个问题： 问题一：如果函数中有用到两次 key，比如 name，那么这个函数会被收集两次 问题二：我们并不希望将添加 reactiveFn 放到 get 中，因为它是属于 Depend 的行为 所以我们需要对 Depend 类进行重构： 解决问题一的方法：不使用数组，而是使用 Set 解决问题二的方法：添加一个新的方法，用于收集依赖 // 保存当前需要收集的响应式函数let activeReactviceFn = nullclass Depend {constructor() {this.reactiveFns = new Set()}depend() {if (activeReactviceFn) {this.reactiveFns.add(activeReactviceFn)} }addDepend(reactiveFn) {this.reactiveFns.add(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }// 对象的响应式const obj = {name: 'why', // depend 对象age: 18 // depend 对象}/ 封装一个响应式函数 /function watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {// 根据 target key 获取对应的 depnedconst depend = getDepend(target, key)// 给 depend 对象中添加响应式函数depend.depend()return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} })watchFn(function () {console.log(objProxy.name, '--------------')console.log(objProxy.name, '++++++++++++++')})objProxy.name = 'kobe'/ why --------------why ++++++++++++++kobe --------------kobe ++++++++++++++/ 4.7 创建响应式对象 目前的响应式是针对于obj一个对象的，我们可以创建出来一个函数，针对所有的对象都可以变成响应式对象 / 保存当前需要收集的响应式函数 /let activeReactviceFn = null/ 依赖收集类 /class Depend {constructor() {this.reactiveFns = new Set()}depend() {if (activeReactviceFn) {this.reactiveFns.add(activeReactviceFn)} }addDepend(reactiveFn) {this.reactiveFns.add(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }/ 封装一个响应式函数 /function watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}/ 创建响应式对象函数 /function reactive(obj) {// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)return new Proxy(obj, {get: function (target, key, receiver) {// 根据 target key 获取对应的 depnedconst depend = getDepend(target, key)// 给 depend 对象中添加响应式函数depend.depend()return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} })}const info = reactive({address: '广州市',height: 1.88})watchFn(() => {console.log(info.address, '---')})info.address = '北京市' 4.8 Vue2 响应式原理 前面所实现的响应式的代码，其实就是 Vue3 中的响应式原理： Vue3 主要是通过 Proxy 来监听数据的变化以及收集相关的依赖的 Vue2 中通过 Object.defineProerty的方式来实现对象属性的监听 可以将 reactive 函数进行如下的重构： 在传入对象时，我们可以遍历所有的 key，并且通过属性存储描述符来监听属性的获取和修改 在 setter 和 getter 方法中的逻辑和前面的 Proxy 是一致的 / 保存当前需要收集的响应式函数 /let activeReactviceFn = null/ 依赖收集类 /class Depend {constructor() {this.reactiveFns = new Set()}depend() {if (activeReactviceFn) {this.reactiveFns.add(activeReactviceFn)} }addDepend(reactiveFn) {this.reactiveFns.add(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }/ 封装一个响应式函数 /function watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}/ 创建响应式对象函数 /function reactive(obj) {Object.keys(obj).forEach((key) => {let value = obj[key]Object.defineProperty(obj, key, {get: function () {const dep = getDepend(obj, key)dep.depend()return value},set: function (newValue) {value = newValueconst dep = getDepend(obj, key)dep.notify()} })})return obj}const info = reactive({address: '广州市',height: 1.88})watchFn(() => {console.log(info.address, '---')})info.address = '北京市' 本篇文章为转载内容。原文链接：https://blog.csdn.net/wanghuan1020/article/details/126774033。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...安装与编译，以及如何使用vscode来配置tvm的远程连接调试环境。   所需软硬件环境： 环境 版本 local system windows 10 service system ubuntu 18.04 tvm latest(0.9.dev0) python(conda) python 3.8.13 local IDE vscode 1. 安装TVM 1.1 下载源码 从github上拉取源码git clone --recursive https://github.com/apache/tvm tvm --recursive指令：由于tvm依赖了很多第三方的开源库(子模块) 加入该参数之后也将相应的子模块一起进行clone 或者直接下载源码https://tvm.apache.org/download 1.2 创建虚拟环境及安装依赖库   使用conda创建tvm的虚拟python环境，python版本为3.8，虚拟环境名为tvmenv： conda create -n tvmenv python=3.8   编辑tvm目录下的conda/build-environment.yaml文件： conda/build-environment.yaml Build environment that can be used to build tvm.name: tvmenv The conda channels to lookup the dependencieschannels:- anaconda- conda-forge 将name的值改为刚刚创建的虚拟环境名tvmenv   执行下面的指令，将构建tvm所需的环境依赖更新到当前虚拟环境中： conda env update -f conda/build-environment.yaml conda env update -n tvmenv -f conda/build-environment.yaml 设置完之后需要重新deactivate/activate对环境进行激活 如果上述命令执行较慢，可以将conda换成国内源（建议使用北京外国语大学的开源镜像站）：参考连接 然后修改conda/build-environment.yaml文件： channels:- defaults - anaconda - conda-forge   安装python依赖库： pip install decorator tornado psutil 'xgboost<1.6.0' cloudpickle -i https://pypi.tuna.tsinghua.edu.cn/simple 如果使用onnx或者pytorch作为原始模型，则还需要安装相应的依赖库pip install onnx onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simplepip install torch==1.7.1 torchvision==0.8.2 torchaudio==0.7.2 -i https://pypi.tuna.tsinghua.edu.cn/simple   在当前虚拟环境中添加用于tvm debug的环境变量： conda env config vars set TVM_LOG_DEBUG="ir/transform.cc=1,relay/ir/transform.cc=1" conda env config vars set TVM_LOG_DEBUG="ir/transform.cc=1,relay/ir/transform.cc=1" -n tvmenv 设置完之后需要重新deactivate/activate对环境进行激活是环境变量生效   使用这种方式设置环境变量的好处是：只有当前环境被激活(conda activate)时，自定义设置的环境变量才起作用，当conda deactivate后自定义的环境变量会自动清除。   当然，也可以更简单粗暴一些： export TVM_LOG_DEBUG="ir/transform.cc=1,relay/ir/transform.cc=1"   在当前虚拟环境中添加用于tvm python的环境变量： export TVM_HOME=your tvm pathexport PYTHONPATH=$TVM_HOME/python:${PYTHONPATH} 1.3 编译TVM源码   如果linux上没有安装C/C++的编译环境，需要进行安装： 更新软件apt-get update 安装apt-get install build-essential 安装cmakeapt-get install cmake   在tvm目录下创建build文件夹，并将cmake/config.cmake文件复制到此文件夹中： mkdir buildcp cmake/config.cmake build/   编辑build/config.cmake进行相关配置： 本次是在cpu上进行测试，因此没有配置cudaset(USE_LLVM ON) line 136set(USE_RELAY_DEBUG ON) line 285(建议先 OFF) 在末尾添加一个cmake的编译宏，确保编译出来的是debug版本set(CMAKE_BUILD_TYPE Debug)   编译tvm，这里开启了16个线程： cd buildcmake ..make -j 16 建议开多个线程，否则编译速度很慢哦   大约5分钟，即可生成我们需要的两个共享链接库：libtvm.so 和 libtvm_runtime.so 1.4 验证安装是否成功   tvm版本验证： import tvmprint(tvm.__version__)   pytorch模型验证： from_pytorch.py https://tvm.apache.org/docs/how_to/compile_models/from_pytorch.html ps: TVM supports PyTorch 1.7 and 1.4. Other versions may be unstable.import tvmfrom tvm import relayfrom tvm.contrib.download import download_testdataimport numpy as np PyTorch importsimport torchimport torchvision Load a pretrained PyTorch model -------------------------------model_name = "resnet18"model = getattr(torchvision.models, model_name)(pretrained=True) or model = torchvision.models.resnet18(pretrained=True) or pth_file = 'resnet18-f37072fd.pth' model = torchvision.models.resnet18() ckpt = torch.load(pth_file) model.load_state_dict(ckpt)model = model.eval() We grab the TorchScripted model via tracinginput_shape = [1, 3, 224, 224]input_data = torch.randn(input_shape)scripted_model = torch.jit.trace(model, input_data).eval() Load a test image ----------------- Classic cat example!from PIL import Image img_url = "https://github.com/dmlc/mxnet.js/blob/main/data/cat.png?raw=true" img_path = download_testdata(img_url, "cat.png", module="data")img_path = 'cat.png'img = Image.open(img_path).resize((224, 224)) Preprocess the image and convert to tensorfrom torchvision import transformsmy_preprocess = transforms.Compose([transforms.Resize(256),transforms.CenterCrop(224),transforms.ToTensor(),transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),])img = my_preprocess(img)img = np.expand_dims(img, 0) Import the graph to Relay ------------------------- Convert PyTorch graph to Relay graph. The input name can be arbitrary.input_name = "input0"shape_list = [(input_name, img.shape)]mod, params = relay.frontend.from_pytorch(scripted_model, shape_list) Relay Build ----------- Compile the graph to llvm target with given input specification.target = tvm.target.Target("llvm", host="llvm")dev = tvm.cpu(0)with tvm.transform.PassContext(opt_level=3):lib = relay.build(mod, target=target, params=params) Execute the portable graph on TVM --------------------------------- Now we can try deploying the compiled model on target.from tvm.contrib import graph_executordtype = "float32"m = graph_executor.GraphModule(lib["default"](dev)) Set inputsm.set_input(input_name, tvm.nd.array(img.astype(dtype))) Executem.run() Get outputstvm_output = m.get_output(0) Look up synset name ------------------- Look up prediction top 1 index in 1000 class synset. synset_url = "".join( [ "https://raw.githubusercontent.com/Cadene/", "pretrained-models.pytorch/master/data/", "imagenet_synsets.txt", ] ) synset_name = "imagenet_synsets.txt" synset_path = download_testdata(synset_url, synset_name, module="data") https://raw.githubusercontent.com/Cadene/pretrained-models.pytorch/master/data/imagenet_synsets.txtsynset_path = 'imagenet_synsets.txt'with open(synset_path) as f:synsets = f.readlines()synsets = [x.strip() for x in synsets]splits = [line.split(" ") for line in synsets]key_to_classname = {spl[0]: " ".join(spl[1:]) for spl in splits} class_url = "".join( [ "https://raw.githubusercontent.com/Cadene/", "pretrained-models.pytorch/master/data/", "imagenet_classes.txt", ] ) class_name = "imagenet_classes.txt" class_path = download_testdata(class_url, class_name, module="data") https://raw.githubusercontent.com/Cadene/pretrained-models.pytorch/master/data/imagenet_classes.txtclass_path = 'imagenet_classes.txt'with open(class_path) as f:class_id_to_key = f.readlines()class_id_to_key = [x.strip() for x in class_id_to_key] Get top-1 result for TVMtop1_tvm = np.argmax(tvm_output.numpy()[0])tvm_class_key = class_id_to_key[top1_tvm] Convert input to PyTorch variable and get PyTorch result for comparisonwith torch.no_grad():torch_img = torch.from_numpy(img)output = model(torch_img) Get top-1 result for PyTorchtop1_torch = np.argmax(output.numpy())torch_class_key = class_id_to_key[top1_torch]print("Relay top-1 id: {}, class name: {}".format(top1_tvm, key_to_classname[tvm_class_key]))print("Torch top-1 id: {}, class name: {}".format(top1_torch, key_to_classname[torch_class_key])) 2. 配置vscode   安装两个vscode远程连接所需的两个插件，具体如下图所示：   安装完成之后，在左侧工具栏会出现一个图标，点击图标进行ssh配置： ssh yourname@yourip -A   然后右键选择在当前窗口进行连接：   除此之外，还可以设置免费登录，具体可参考这篇文章。   当然，也可以使用windows本地的WSL2，vscode连接WSL还需要安装WSL和Dev Containers这两个插件。   在服务器端执行code .会自动安装vscode server，安装位置在用户的根目录下： 3. 安装FFI Navigator   由于TVM是由Python和C++混合开发，且大多数的IDE仅支持在同一种语言中查找函数定义，因此对于跨语言的FFI 调用，即Python跳转到C++或者C++跳转到Python，vscode是做不到的。虽然解决这个问题在技术上可能非常具有挑战性，但我们可以通过构建一个与FFI注册码模式匹配并恢复必要信息的项目特定分析器来解决这个问题，FFI Navigator就这样诞生了，作者仍然是陈天奇博士。   安装方式如下： 建议使用源码安装git clone https://github.com/tqchen/ffi-navigator.git 安装python依赖cd ffi-navigator/pythonpython setyp.py install   vscode需要安装FFI Navigator插件，直接搜索安装即可(安装到服务器端)。   最后需要在.vscode/setting.json进行配置，内容如下： {"python.analysis.extraPaths": ["${workspaceFolder}/python"], // 添加额外导入路径, 告诉pylance自定义的python库在哪里"ffi_navigator.pythonpath": "/home/liyanpeng/anaconda3/envs/tvmenv/bin/python", // 配置FFI Navigator"python.defaultInterpreterPath": "/home/liyanpeng/anaconda3/envs/tvmenv/bin/python","files.associations": {"type_traits": "cpp","fstream": "cpp","thread": "cpp",".tcc": "cpp"} }   更详细内容可以参考项目链接。 结束语   对于vscode的使用技巧及C/C++相关的配置，这里不再详细的介绍了，感兴趣的小伙伴们可以了解下。 本篇文章为转载内容。原文链接：https://blog.csdn.net/qq_42730750/article/details/126723224。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...一个文档，DOM 中使用 document 表示 元素：页面中的所有标签都是元素，DOM 中使用 element 表示 节点：网页中的所有内容都是节点（标签、属性、文本、注释等），DOM 中使用 node 表示 文档树(Dom树)：以html为根节点，形成的一颗倒立的树状结构，我们成为DOM树；这个树上所有的东西都叫节点，节点有很多类，比如文本节点，元素节点等等，这些节点如果我们通过DOM方法去获取或者其他的操作去使用就叫做DOM对象，所有节点都是DOM对象 二.获取元素的方法 1.获取页面中的元素可以使用以下几种方式 根据ID获取 根据标签名获取 通过HTML5新增的方法获取 特殊元素获取 1.根据ID获取 使用getElementByld()方法可以获取带有ID的元素对象 getElementByld()，是document下的一个方法 代码演示 <body><div id="time">2020-11-26</div><script>// 1.因为我们文档页面从上往下加载，所以先得有标签 所以我们的script写在标签下面// 2. document文档 get 获得 element 元素 by 通过 驼峰命名法// 3.参数 id是大小写敏感的字符串// 4.返回的是一个对象var timer = document.getElementById('time');console.log(timer);// 5.console.dir 打印我们返回得的元素对象 更好的查看里面的属性和方法console.dir(timer);</script></body> 2.根据标签名获取 使用getElementsByTagName()方法可以返回带有指定标签名的对象的集合 语法如下 document.getElementsByTagName('标签名') 注意： 1.因为得到的是一个对象的集合，使用我们想要操作里面的元素就需要遍历 得到元素对象是动态的 代码演示 <body><ul><li>我们的征程是星辰大海</li><li>我们的征程是星辰大海</li><li>我们的征程是星辰大海</li><li>我们的征程是星辰大海</li><li>我们的征程是星辰大海</li></ul><ul id="nav"><li>心存感恩，所遇皆美好~</li><li>心存感恩，所遇皆美好~</li><li>心存感恩，所遇皆美好~</li><li>心存感恩，所遇皆美好~</li><li>心存感恩，所遇皆美好~</li></ul><script>// 1.返回的是 获取过来元素对象的集合 以伪数组的形式存储的var lis = document.getElementsByTagName('li')console.log(lis);// 2.如果想要依次打印里面的元素对象我们可以采取遍历方式for (var i = 0; i < lis.length; i++) {console.log(lis[i]);}// 3.这里可以是可以获取标签的.getElementsByTagName()可以得到这个元素里面的某些标签var nav1 = document.getElementById('nav') //这个获取nav元素var navli = nav.getElementsByTagName('li') //这里是获取nav 里面的li标签 要先获取 nav元素在获取里面的liconsole.log(navli);</script></body> 3.通过 HTML5 新增的方法获取(注意兼容) 1. document.getElementsByClassName(‘类名’)；// 根据类名返回元素对象集合 2. document.querySelector('选择器'); // 根据指定选择器返回第一个元素对象 3. document.querySelectorAll('选择器'); // 根据指定选择器返回所有元素对象集合 注意：querySelector 和 querySelectorAll里面的选择器需要加符号,比如:document.querySelector(’nav’); 代码演示 <body><div class="box">盒子1</div><div class="box">盒子2</div><div id="nav"><ul><li>首页</li><li>产品</li></ul></div><script>// 1. getElementsByClassName 根据类名获得某些元素集合var boxs = document.getElementsByClassName('box');console.log(boxs);// 2. querySelector 返回指定选择器的第一个元素对象 切记 里面的选择器需要加符号 .box navvar firstBox = document.querySelector('.box');console.log(firstBox);var nav = document.querySelector('nav');console.log(nav);var li = document.querySelector('li');console.log(li);// 3. querySelectorAll()返回指定选择器的所有元素对象集合var allBox = document.querySelectorAll('.box');console.log(allBox);var lis = document.querySelectorAll('li');console.log(lis);</script> 4.获取特殊元素(body,html) 获取body元素 - doucumnet.body // 返回body元素对象 获取html元素 . document.documentElement // 返回html元素对象 代码演示 <body><script>// 获取bdoy元素var bodyEle = document.bodyconsole.log(bodyEle); //返回body元素// 获取html元素var htmlEle = document.documentElementconsole.log(htmlEle); //返回html元素</script></body> 三.事件基础 1.事件概述 JavaScript 使我们有能力创建动态页面，而事件是可以被 JavaScript 侦测到的行为。 简单理解： 触发— 响应机制。 网页中的每个元素都可以产生某些可以触发 JavaScript 的事件，例如，我们可以在用户点击某按钮时产生一个 事件，然后去执行某些操作。 代码演示 <body><button id="btn">浩哥</button><script>// 点击一个按钮，弹出一个对话框// 1.事件是有三部分组成的 1.事件源 2.事件类型 3.事件处理程序 也称为事件三要素// (1).事件源 事件被触发的对象 var but = document.getElementById('btn')// (2).事件类型 如何触发 什么事件 比如鼠标点击(onclick) 还是鼠标经过还是？？？？// (3).事件处理程序 通过一个函数赋值的方式 完成 因为函数就是实现某种功能的but.onclick = function() {alert('浩哥爱编程')}</script></body> 2.执行事件的步骤 1. 获取事件源DOM对象(意思是你要获取那个元素) 2. 注册事件(绑定事件 意思是通过什么方式来处理比如是鼠标经过还是鼠标点击等等行为) 3. 添加事件处理程序(采取函数赋值形式 意思是你想做啥) 代码演示 <body><div>123</div><script>// 事件执行步骤 点击div 控制台输出我被选中了// 1.获取事件源var div = document.querySelector('div')// 2.绑定事件 注册事件// div.onclick// 3.添加事件处理程序div.onclick = function() {console.log('我被点击了');}</script></body> 3.常见的鼠标事件 onmouseenter鼠标移入事件 onmouseleave鼠标移出事件 四.操作元素 JS的DOM操作可以改变网页内容、结构和样式，利用DOM操作元素来改变元素里面的内容、属性等。注意以下都是属性 1.操作元素内容(改变元素内容) elemeny.innerText 从起始位置到终止位置的内容，但它去除html标签，同时空格和换行也会去掉 elemernt.innerHTML 起始位置到终止位置的全部内容，包括html标签，同时保留空格和换行 elemernt.Content可以获取隐藏元素的文本，包含换行和空白 代码演示 <title>Document</title><style>div,p {height: 30px;width: 300px;line-height: 30px;text-align: center;color: fff;background-color: pink;}</style></head><body><button>显示当前系统时间</button><div>某个时间</div><p>123</p><script>// 当我们点击了按钮，div里面的文字会发生变化// 1.获取元素 注意这里的按钮 和div都要获取到 因为 点击按钮div里面要发生变化所以都要获取var but = document.querySelector('button');var div = document.querySelector('div');// 2.绑定事件// but.onclick// 3.程序处理but.onclick = function() {// 改变元素内容 element(元素).innerTextdiv.innerText = '2020-11-27'}// 4.我们元素可以不用添加事件，就可以直接显示日期var p = document.querySelector('p');p.innerText = '2020-11-27';</script> elemeny.innerText和elemeny.innerHTML的区别 代码演示 <body><div></div><p></p><ul><li> 文字</li><li>123</li></ul><script>// innertText 和 innertHTML 的区别// 1. innerText 不识别html标签 非标准 去除空格和换行var div = document.querySelector('div');div.innerText = '<strong>今天是:</strong> 2020';// 2.innertHTML 识别html标签 W3C标准 保留空格和换行的 推荐尽量使用这个 因为这个是标准var p = document.querySelector('p')p.innerHTML = '<strong>今天是:</strong> 2020';// 3.这俩个属性是可读写的 意思是 除了改变内容还可以元素读取里面的内容的var ul = document.querySelector('ul')console.log(ul.innerText);console.log(ul.innerHTML);// .4innerHtml innerText 之间的区别：设置内容的时候，如果内容当中包含标签字符串 innerHtml会有标签的特性，也就是说标签会在页面上生效如果内容当中包含标签字符串 innerText会把标签原样展示在页面上，不会让标签生效读取内容的时候，如果标签内部还有其它标签，innerHtml会把标签内部带着其它的标签全部输出如果标签内部还有其它标签，innerText只会输出所有标签里面的内容或者文本，不会输出标签如果标签内部没有其它标签，他们两个一致；都是读取文本内容，innerHtml会带空白和换行</script></body> 2. 操作常见元素属性 innerText、innerHTML 改变元素内容 src、href id、alt、title 代码演示 <body><button id="ldh">刘德华</button><button id="zxy">张学友</button><br><img src="./images/ldh.jpg" alt="" width="200px" height="200px" title="刘德华" id="img"><script>// 修改属性 src// 我们可以操作元素得方法 来修改元素得属性 就是 元素的是什么属性 在重新给值就可以完成相应的赋值操作了// 1.获取元素var ldh = document.getElementById('ldh')var zxy = document.getElementById('zxy')var img = document.getElementById('img')// 2.注册事件 程序处理zxy.onclick = function() {// 当我们点击了图片的时候图片路径就发生变化 这里的.表示 的 得意思 img对象下的src属性img.src = './images/zxy.jpg';// 当我们变换图片得同时里面得title也要跟着变 所以前面要加上img.img.title = '张学友';}ldh.onclick = function() {img.src = './images/ldh.jpg';img.title = '刘德华';}</script> 3.操作表单元素属性 利用DOM可以操作如下表单元素的属性 type、value、checked、selected、disabled 代码演示： <body><button>按钮</button><input type="text" value="输入内容"><script>// 我想把value里面的输入内容改变为 被点击了// 1.获取元素var but = document.querySelector('button')var input = document.querySelector('input')// 2.注册事件 处理程序but.onclick = function() {// input.innerHTML = '被点击了'; 这个是 普通盒子 比如 div 标签里面的内容// 表单里面的值 文字内容是通过value来修改的input.value = '被点击了'// 如果需要某个表单被禁用 不能再点击了使用 disabled 我们想要这个按钮 button禁用// but.disabled = true// 还有一种写法// this指向的是事件函数的调用者 谁调用就指向谁 这里调用者是btnthis.disabled = true}</script></body> 4.操作元素样式属性 我们可以通过 JS 修改元素的大小、颜色、位置等样式。 1.element.style 行内样式操作 注意： JS 里面的样式采取驼峰命名法 比如 fontSize、 backgroundColor JS 修改 style 样式操作，产生的是行内样式，所以行内式比内嵌式高 代码演示 <style>div {width: 200px;height: 200px;background-color: red;}</style></head><body><div></div><script>// 要求点击div变成粉色 height变为250px// 1.获取元素var div = document.querySelector('div');// 2.注册事件 处理程序div.onclick = function() {// div.style里面的属性 采取的是驼峰命名法// this等于div this调用者 谁调用谁执行this.style.backgroundColor = 'pink'this.style.height = '250px'}</script> 2.element.className 类名样式操作 注意： 如果样式修改较多，可以采取操作类名方式更改元素样式。 class因为是个保留字，因此使用className来操作元素类名属性 className 会直接更改元素的类名，会覆盖原先的类名。 代码演示 <style>div {width: 100px;height: 100px;background-color: pink;}.change {background-color: purple;color: fff;font-size: 25px;margin-top: 100px;}</style></head><body><div class="first">文本</div><script>// 1. 使用 element.style 获得修改元素样式 如果样式比较少 或者 功能简单的情况下使用var test = document.querySelector('div');test.onclick = function() {// this.style.backgroundColor = 'purple';// this.style.color = 'fff';// this.style.fontSize = '25px';// this.style.marginTop = '100px';// 让我们当前元素的类名改为了 change// 2. 我们可以通过 修改元素的className更改元素的样式 适合于样式较多或者功能复杂的情况 如果想继续添加样式即在change添加即可// 3. 如果想要保留原先的类名，我们可以这么做 多类名选择器// this.className = 'change';this.className = 'first change';}</script> 5.自定义属性的操作 js给我们规定了可以自己添加属性 在操作元素属性的时候，元素.语法只能操作元素天生具有的属性,如果是自定义的属性，通过.语法是无法操作的只能通过getAttribute和setAttribute去操作，他俩是通用的方法，无论元素天生的还是自定义的都可以可以操作 1.获取属性值 element.属性 获取属性值。 element.getAttribute(‘属性’)； 区别: element.属性 获取内置属性值(元素本身自带的属性 如果是自定义属性不能被获取) element.getAttribute(‘属性’)；主要获得自定义的属性 (标准) 我们自定义的属性 2.设置属性值 element.属性 = ‘值’ 设置内置属性值 element.setAttribute(‘属性’，‘值’) 区别： element.属性 设置内置属性值 element.setAttribute(‘属性’)；主要设置自定义的属性(标准) 3.移除属性 element.removeAttribute(‘属性’)； 代码演示 <body><div id="demo" index="1" class="nav"></div><script>var div = document.querySelector('div');// 1.获取元素的属性值// (1) element.属性console.log(div.id);// (2) element.getAttribute('属性') get获取得到 attribute属性的意思 我们自己添加的属性称之为自定义属性console.log(div.getAttribute('id')); //democonsole.log(div.getAttribute('index')); // 1// 2.设置元素的属性值// (1) element.属性 = '值' div.id = 'test'div.className = 'navs'// (2) element.setAttribute('属性','值')div.setAttribute('index', 2);div.setAttribute('class', 'footer') //这里就是class 不是className 比较特殊// 3.移除属性 removeAttribute(属性)div.removeAttribute('index');</script></body> 只要是自定义属性最好都是用element.setAttribute(‘属性’，‘值’)来设置 如果是自带属性用element.属性来设置 6.H5自定义属性 自定义属性的目的：第一、是为了保存属性 第二、并且使用数据。有一些数据可以保存到页面中而不用保存到数据库中。 自定义属性获取是通过getAttribute(‘属性’) 获取的 但是有些自定义属性很容易引起歧义，不容易判断是元素还是自定义属性 H5给我们新增了自定义属性： 1.设置H5自定义属性 H5规定自定义属性data-开头做为属性名并且赋值 比如<div data-index:“1”> 或者使用JS设置element.setAttribute(‘deta-index’,2) 2.获取H5自定义属性 兼容性获取 element.getAttribute(‘data-index’) 推荐开发中使用这个 H5新增element.dataset.index 或者element.datase[‘index’] ie 11以上才支持 代码演示 <body><div getTime="10" data-index="20" data-name-list="40"></div><script>// 获取元素var div = document.querySelector('div');console.log(div.geTime); //undefined getTime是自定义属性不能直接通过元素的属性来获取 而是用自定义属性来获取的getAttribute(‘属性’)console.log(div.getAttribute('getTime')); //10// H5添加自定义属性的写法以data-开头div.setAttribute('data-time', 30)// 1.兼容性获取H5自定义属性console.log(div.getAttribute('data-time')); // 30// 2.H5新增的获取自定义属性的方法 它只能获取data-开头的// dataset 是一个集合的意思存放了所有以data开头的自定义属性 如果你想取其中的某一个只需要在dataset.的后面加上自定义属性名即可console.log(div.dataset);console.log(div.dataset.time); // 30// 还有一种方法dataset['属性']console.log(div.dataset['time']); // 30// 如果自定义属性里面有多个-链接的单词 我们获取的时候采取驼峰命名法 不用要-了console.log(div.dataset.nameList); // 40console.log(div.dataset['nameList']); // 40</script></body> 五.节点操作 1.为什么要学习节点操作 获取元素通常使用俩种方式 （1）利用DOM提供的方法获取元素 但是逻辑性不强 繁琐 （2）利用节点层级关系获取元素 如 利用父子，兄弟关系获取元素 逻辑性强，但是兼容性不怎么好 2.节点概述 网页中的所有内容都是节点(标签、属性、文本、注释等等) ，在DOM中，节点使用node表示。HTML DOM 树中的所有节点均可通过javascript进行访问，所有HTML元素(节点) 均可被修改，也可以创建或删除 一般地，节点至少拥有nade Type(节点类型)、nodeName(节点名称)和nodeValue(节点值) 这三个基本属性 元素节点 nodeType 为 1 属性节点 node Name为 2 文本节点 nodeValue为 3 (文本节点包含文字、空格、换行等等) 实际开发中，节点操作主要操作的是元素节点 3.节点层级 利用DOM树可以把节点划分为不同得层级关系，常见得是父子兄层级关系 1.父级节点 1.node.parentNode parenNode属性可以返回某节点得父节点，注意是最近的父节点哟！！！ 如果指定的节点没有父节点就返回null 代码演示 <body><div class="box"><div class="box1"></div></div><script>var box1 = document.querySelector('.box1')// 得到的是离元素最近的父节点(亲爸爸) 得不到就返回得是nullconsole.log(box1.parentNode); // parentNode 翻译过来就是父亲的节点</script></body> 2.子级节点操作 1.parentNode.children（非标准） parentNode.children 是一个只读属性，返回所有的子元素节点。它只返回子元素节点，其余节点不返回(重点记住这个就好，以后重点使用) 虽然children是一个非标准，但是得到了各个浏览器的支持，我们大胆使用即可！！！ 代码演示 <body><ul><li>1</li><li>1</li><li>1</li><li>1</li></ul><script>// DOM 提供的方法（APL）获取 这样获取比较麻烦var ul = document.querySelector('ul')var lis = ul.querySelectorAll('li')// children子节点获取 ul里面所有的小li 放心使用没有限制兼容性 实际开发中经常使用的console.log(ul.children);</script> 如何返回子节点的第一个和最后一个？ 2.parentNode.firstElementChild firstElementChild返回第一个子元素节点，找不到则返回unll 3.parentNode.lastElementChild lastElementChild返回最后一个子元素节点，找不到则返回null 注意：这俩个方法有兼容性问题，IE9以上才支持 谨慎使用 但是我们有解决方案 如果想要第一个子元素节点，可以使用 parentNode.chilren[0] 如果想要最后一个子元素节点，可以使用 parentNode.chilren[parentNode.chilren.length - 1] 代码演示 <body><ul><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ul><script>var ul = document.querySelector('ul')// 1.firstElementChild 返回第一个子元素节点 ie9 以上才支持注意兼容console.log(ul.firstElementChild);// 2.lastElementChild返回最后一个子元素节点console.log(ul.lastElementChild);// 3.实际开发中用到的既没有兼容性问题又可以返回子节点的第一个和最后一个console.log(ul.children[0]);console.log(ul.children[ul.children.length - 1]); //ul.children.length - 1获取的永远是子节点最后一个</script></body> 3.兄弟节点 1.node.nextSibling nextSibling 返回当前元素的下一个兄弟节点，找不到则返回null。注意包含所有的节点 2.node.previousSibling previousSibling 返回当前元素上一个兄弟节点，找不到则返回null。注意包含所以有的节点 代码演示 <body><div>我是div</div><span>我是span</span><script>var div = document.querySelector('div')// 返回当前元素的下一个兄弟节点nextSibling，找不到返回null。注意包含元素节点或者文本节点等等console.log(div.nextSibling); //这里返回的是text 因为它的下一个兄弟节点是换行// 返回的是当前元素的上一个节点previousSibling，找不到返回null。注意包含元素节点或者文本节点等等console.log(div.previousSibling); //这里返回的是text 因为它的上一个兄弟节点是换行</script></body> 3.node.nexElementSibling nexElementSibling 返回当前元素下一个兄弟元素节点，找不到返回null 4.node.previousElementSibling previousElementSibling返回当前元素上一个兄弟节点，找不到返回null 注意：这俩个方法有兼容性问题，IE9以上才支持 代码演示 <body><div>我是div</div><span>我是span</span><script>var div = document.querySelector('div')// nextElementSiblingd得到下一个兄弟元素节点console.log(div.nextElementSibling); // span // previousElementSibling 得到的是上一个兄弟元素节点console.log(div.previousElementSibling); // null 因为它上面没有兄弟元素了返回空的</script></body> 怎么解决兼容性问题呢？ 可以封装一个兼容性函数（简单了解即可 在实际开发中用的不多） function getNextElementSibling(element) {var el = element;while (el = el.nextSibling) {if (el.nodeType === 1) {return el;} }return null;} 4.创建节点 1.document.createElement('tagName') document.createElement( ) 方法创建由 tagName 指定的 HTML 元素。因为这些元素原先不存在的是根据我们的需求动态生成的，所有我们也称为动态创建元素节点 我们创建了节点要给添加到节点里面去 称为 添加节点 1.node.appendChild（child） node.appendChild（ ）方法将一个节点添加到指定父节点的子节点列表末尾 2.node.insertBefore(child，指定添加元素位置) node.insertBefore( ) 方法将一个节点添加到父节点的指定子节点前面 代码演示 <body><ul><li>1</li></ul><script>// 1.创建节点 createElementvar li = document.createElement('li')// 2.添加节点 创建了节点要添加到某一个元素身上去 叫添加节点 node.appendChild(child) done 父级 child 子级 如果前面有元素了则在后面追加元素类似数组中的push依次追加var ul = document.querySelector('ul')ul.appendChild(li)// 3.添加节点 node.insertBefore(child，指定元素) 在子节点前面添加子节点 child子级你要添加的元素var lili = document.createElement('li')ul.insertBefore(lili, ul.children[0]) //ul.children 这句话的意思是添加到ul父亲的子节点第一个// 总结 如果想在页面中添加元素分为俩步骤1.创建元素 2.添加元素</script></body> 5.删除节点 node.removeChild(child) node.removeChlid（）方法从DOM 中删除一个子节点，返回删除的节点 简单点就是从父元素中删除某一个孩子node就是父亲child就是孩子 删除的节点.remove(没有参数) 注意：ie不支持 代码演示 <body><button>按钮</button><ul><li>熊大</li><li>熊二</li><li>熊三</li></ul><script>// 1.获取元素var ul = document.querySelector('ul')var but = document.querySelector('button');// 2.删除元素// but.onclick = function() {// ul.removeChild(ul.children[0])// }// 3.点击按钮键依次删除，最后没有删除内容了 就禁用按钮 disabled = true 禁用按钮语法but.onclick = function() {if (ul.children.length == 0) {this.disabled = true} else {ul.removeChild(ul.children[0])} }</script></body> 6.复制节点(克隆节点) node.cloneNode() node.dloneNode()方法返回调用该方法节点得一个副本，也称为克隆节点/拷贝节点 注意 1.如果括号参数为空或者为false，则是浅拷贝，只复制里面得标签，不复制内容 2.如果括号参数为true，则是深度拷贝，会复制节点本身以及里面所有的内容 代码演示 <body><ul><li>1</li><li>2</li><li>3</li></ul><script>// 1.获取元素var ul = document.querySelector('ul');// 2.复制元素 node.cloneNode() 如果参数括号为空或者false则只会复制元素不会复制内容，如果待有参数true则内容和元素都会被复制var lis = ul.children[0].cloneNode(true);// 3.获取元素ul.appendChild(lis)</script></body> 7.替换(改)节点 node.replaceChild(新节点,替换到什么位置) 代码演示 <body><ul class="list"><li>1</li><li>2</li></ul><script>// 替换（改）节点 父节点.replaceChild(新元素, 替换到什么位置)// (1)获取父元素var ulNode = document.querySelector('.list');// (2)创建新的元素var liRead = document.createElement('li')// (3)给新元素添加内容liRead.innerHTML = '5';// (4)替换元素ulNode.replaceChild(liRead, ulNode.children[1])</script></body> 8.三种动态创建元素区别 document.write() element.innerHTML document.createElement() 区别 document.write()是直接将内容写入页面的内容流，但是文档流执行完毕，它则会导致页面全部重绘 element.innerHTML是将内容写入某个DOM节点，不会导致页面全部重绘 element.innerHTML 创建多个元素效率更高(不要拼接字符串，采取数组形式拼接)，结果有点复杂 createElement()创建多个元素效率低一点点，但是结果更加清晰 总结：不同浏览器下,innerHTML效率要比createElement()高 代码演示 <body><button>点击</button><p>abc</p><div class="inner"></div><div class="create"></div><script>// window.onload = function() {// document.write('<div>123</div>');// }// 三种创建元素方式区别 // 1. document.write() 创建元素 如果页面文档流加载完毕，再调用这句话会导致页面重绘// var btn = document.querySelector('button');// btn.onclick = function() {// document.write('<div>123</div>');// }// 2. innerHTML 创建元素var inner = document.querySelector('.inner');// for (var i = 0; i <= 100; i++) {// inner.innerHTML += '<a href="">百度</a>'// }var arr = [];for (var i = 0; i <= 100; i++) {arr.push('<a href="">百度</a>');}inner.innerHTML = arr.join('');// 3. document.createElement() 创建元素var create = document.querySelector('.create');for (var i = 0; i <= 100; i++) {var a = document.createElement('a');create.appendChild(a);}</script></body> 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_46978034/article/details/110190352。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...为此，Date 类型使用 UTC（Coordinated Universal Time，国际协调时间[又称世界统一时间]）1970 年 1 月 1 日午夜（零时）开始经过的毫秒来保存日期。在使用这种数据存储格式的条件下，Date 类型保存的日期能够精确到 1970 年 1 月 1 日之前或之后的 285616 年。 创建一个日期对象，使用 new 运算符和 Date 构造方法（构造函数）即可。 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。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...目录 前言 一、构造函数 1.对象的初始化 2.构造函数的作用 3.带形参数的构造函数 （1）含义 （2）【例3.2】 4.用参数初始化表对数据成员初始化 5.构造函数的重载 （1）含义 （2）【例3.3】 （3）说明 6.使用默认参数值的构造函数 （1）含义 （2）格式 （3）【例3.4】 （4）说明 二、析构函数 1.含义 2.执行析构函数的时机 3.特征 4.【例3.5】包含构造函数和析构函数的C++程序 三、调用构造函数和析构函数的顺序 1.同一类存储类别的对象 2.全局范围内定义的对象 3.局部自动对象 4.静态局部对象 5.例 四、对象数组 1.含义 2.【例3.6】 五、对象指针 1.指向对象的指针 2.指向对象成员的指针 （1）含义 （2）指向对象公有数据成员的指针 （3）指向对象成员函数的指针 （4）【例3.7】有关对象指针的使用方法 3.this指针 六、共用数据的保护 1.常对象 2.常对象成员 （1）常数据成员 （2）常成员函数 3.指向对象的常指针 4.指向常对象的指针变量 5.对象的常引用 （1）含义 （2）格式 （3）【例3.8】对象的引用 6.const型数据小结 编辑 七、对象的动态建立与释放——动态建立对象 八、对象的赋值和复制 1.对象的赋值 （1）含义 （2）【例3.9】对象的赋值 （3）说明 2.对象的复制 （1）含义 （2）【例】用复制对象的方法创建Box类的对象（用默认复制构造函数） （3）说明 九、静态成员 1.静态数据成员 （1）定义格式 （2）特性 （3）说明 （4）【例3.10】引用静态数据成员 2.静态成员函数 （1）含义 （2）【例3.11】关于引用非静态成员和静态成员的具体方法 （3）【例】具有静态数据成员的point类 （4）静态成员函数举例 （5）具有静态数据、函数成员的Point类 （6）静态成员函数、静态数组及其初始化 十、友元 1.友元函数 （1）含义 （2）格式 （3）【例3.12】将普通函数声明为友元函数 （4）友元成员函数 2.友元类 十一、类模板 1.含义 2.定义类模板的格式 3.在类模板外定义成员函数的语法 4.使用类模板时，定义对象的格式 5.【例3.14】声明类模板，实现两个整数、浮点数和字符的比较，求出大数和小数 前言 通过第二章的学习，已经对类和对象有了初步了解。本章将对类和对象进行进一步讨论。 一、构造函数 如果定义一个变量，而程序未对其进行初始化的话，这个变量的值是不确定的，因为C和C++不会自觉地去为它赋值。与此相似，如果定义一个对象，而程序未对其数据成员进行初始化的话，这个对象的值也是不确定的。 1.对象的初始化 在定义一个类时，不能对其数据成员赋初值，因为类是一种类型，系统不会为它分配内存空间。在建立一个对象时，需要对其数据成员赋初值。如果一个数据成员未被赋初值，则它的值是不确定的。因为系统为对象分配内存时，保持了内存单元的原状，它就成为数据成员的初值。这个值是随机的。 C++提供了构造函数机制，用来为对象的数据成员进行初始化。在前面的学习中一直未讲这个概念，其实如果你未设计构造函数，系统在创建对象时，会自动提供一个默认的构造函数，而它只为对象分配内存空间其他什么也不做。 如果类中的所有数据成员是公有的，可以在定义对象时对其数据成员初始化。例如： class Time{public:int hour;int minute;int sec;};Time t1{15,36,26}; 在一个打括号内顺序列出各个公有数据成员的值，在两个值之间用逗号分隔。注意这只能用于数据成员都是共有的情况。 在前面的例子里，是用成员函数对对象的数据成员赋初值，如果一个类定义了多个对象，对每个对象都要调用成员函数对数据成员赋初值，那么程序就会变得繁琐，所以用成员函数为数据成员赋初值不是一个好办法。 2.构造函数的作用 构造函数用于为对象分配空间和进行初始化，它属于某一个类，可以由系统自动生成。也可以由程序员编写，程序员根据初始化的要求设计构造函数及函数参数。 构造函数是一种特殊的成员函数，在程序中不需要写调用语句，在系统建立对象时由系统自觉调用执行。 构造函数的特点： 构造函数的名字与它的类名必须相同 它没有类型，也不返回值 它可以带参数，也可以不带参数 include <iostream>using namespace std;class Time {public:Time() {hour = 0;minute = 0;sec = 0;}void set_time();void show_time();private:int hour;int minute;int sec;};int main() {Time t1;t1.set_time();t1.show_time();Time t2;t2.show_time();return 0;}void Time::set_time() {cin >> hour;cin >> minute;cin >> sec;}void Time::show_time() {cout << hour << ":" << minute << ":" << sec << endl;} 在类Time中定义了构造函数Time，它与所在的类同名。在建立对象时自动执行构造函数，该函数的作用是为对象中的每个数据成员赋初值0。注意只有执行构造函数时才能为数据成员赋初值。 程序运行时首先建立对象t1，并对t1中的数据成员赋初值0，然后执行t1.set_time函数，从键盘输入新值给对象t1的数据成员，再输出t1的数据成员的值。接着建立对象t2，同时对t2中的数据成员赋初值0，最后输出t2的数据成员的初值。程序运行情况如下： 也可以在类内声明构造函数然后在类外定义构造函数。将程序修改为Time();然后在类外定义构造函数： Time::Time() {hour = 0;minute = 0;sec = 0;} 关于构造函数的使用，说明如下： 什么时候调用构造函数？当函数执行到对象定义语句时建立对象，此时就要调用构造函数，对象就有了自己的作用域，对象的生命周期开始了。 构造函数没有返回值，因此不需要在定义中声明类型。 构造函数不需要显式地调用，构造函数是在建立对象时由系统自动执行的，且只执行以此。构造函数一般定义为public。 在构造函数中除了可以对数据成员赋初值，还可以使用其他语句。 如果用户没有定义构造函数，C++系统会自动生成一个构造函数，而这个函数体是空的，不执行初始化操作。 3.带形参数的构造函数 （1）含义 可以采用带形参数的构造函数，在调用不同对象的构造函数时，从外边将不同的数据传递给构造函数，实现不同对象的初始化。 构造函数的首部的一般格式为：构造函数名（类型 形参1，类型 形参2，……）。在定义对象时指定实参，定义对象的格式为：类名 对象名（实参1，实参2，……）。 （2）【例3.2】 有两个长方柱，其长、宽、高分别为：（1）12，25，30（2）15，30，21编写程序，在类中用带参数的构造函数，计算它们的体积。 分析：可以在类中定义一个计算长方体体积的成员函数计算对象的体积。 include<iostream>using namespace std;class Box{public:Box(int,int,int); //声明int volume();private:int height;int width;int length;};Box::Box(int h,int w,int len) //长方体构造函数{height=h;width=w;length=len;}int Box::volume() //计算长方体体积{return(heightwidthlength);}int main(){Box box1(12,25,30); //定义对象box1cout<<"box1体积="<<box1.volume()<<endl;Box box2(15,30,21); //定义对象box2cout<<"box2体积="<<box2.volume()<<endl;return 0;} 【注】 带形参的构造函数在定义对象时必须指定实参 用这种方法可以实现不同对象的初始化 4.用参数初始化表对数据成员初始化 C++提供了参数初始化表的方法对数据成员初始化。这种方法不必再构造函数内对数据成员初始化，在函数的首部就能实现数据成员初始化。 函数名(类型1 形参1，类型2 形参2): 成员名1(形参1),成员名2(形参2){ } 功能：执行构造函数时，将形参1的值赋予成员1，将形参2的值赋予成员2，形参的值由定义对象时的实参值决定。此时定义对象的格式依然是带实参的形式：类名 对象名(实参1,实参2); 例：定义带形参初始化表的构造函数 Box::Box(int h,int w,int len):height(h),width(w),length(len){}//定义对象:Box box1(12,25,30);//……Box box2(15,30,21); 5.构造函数的重载 （1）含义 构造函数也可以重载。一个类可以有多个同名构造函数，函数参数的个数、参数的类型各不相同。 （2）【例3.3】 在【例3.2】的基础上定义两个构造函数，其中一个无参数，另一个有参数 include <iostream>using namespace std;class Box {public:Box();Box(int h, int w, int len): height(h), width(w), length(len) {}int volume();private:int height;int width;int length;};Box::Box() {height = 10;width = 10;length = 10;}int Box::volume() {return (height width length);}int main() {Box box1;cout << "box1 体积" << box1.volume() << endl;Box box2(15, 30, 25);cout << "box2 体积" << box2.volume() << endl;return 0;} （3）说明 不带形参的构造函数为默认构造函数，每个类只有一个默认构造函数，如果是系统自动给的默认构造函数，其函数体是空的 虽然每个类可以包含多个构造函数，但是创建对象时，系统仅执行其中一个 6.使用默认参数值的构造函数 （1）含义 C++允许在构造函数里为形参指定默认值，如果创建对象时，未给出相应的实参时，系统将用形参的默认值为形参赋值。 （2）格式 函数名（类型 形参1=常数，类型 形参2=常数，……）； （3）【例3.4】 将【例3.3】中的构造函数改用带默认值的参数，长、宽、高的默认值都是10 include <iostream>using namespace std;class Box {public:Box(int w = 10, int h = 10, int len = 10);int volume();private:int height;int width;int length;};Box::Box(int w, int h, int len) {height = h;width = w;length = len;}int Box::volume() {return (height width length);}int main() {Box box1;cout << "box1 体积" << box1.volume() << endl;Box box2(15);cout << "box2 体积" << box2.volume() << endl;Box box3(15, 30);cout << "box3 体积" << box3.volume() << endl;Box box4(15, 30, 20);cout << "box4 体积" << box4.volume() << endl;return 0;} （4）说明 如果在类外定义构造函数，应该在声明构造函数时指定默认参数值，再定以函数时不再指定默认参数值 在声明构造函数时，形参名可以省略。例如：Box(int 10,int 10,int 10); 如果构造函数的所有形参都指定了默认值，在定义对象时，可以指定实参也可不指定实参。由于不指定实参也可以调用构造函数，因此全部形参都指定了默认值的构造函数也属于默认构造函数。为了避免歧义，不允许同时定义不带形参的构造函数和全部形参都指定默认值的构造函数。 不能同时使用重载构造函数和带默认值的构造函数 二、析构函数 1.含义 析构函数也是个特殊的成员函数，它的作用与构造函数相反，当对象的生命周期结束时，系统自动调用析构函数，收回对象占用的内存空间。 2.执行析构函数的时机 在一个函数内定义的对象当这个函数结束时，自动执行析构函数释放对象 static局部对象要到main函数结束或执行exit命令时才自动执行析构函数释放对象 全局对象（在函数外定义的对象）当main函数结束或执行exit命令时自动执行析构函数释放对象 如果用new建立动态对象，用delete时自动执行析构函数释放对象 3.特征 以~符号开始后跟类名 析构函数没有数据类型、返回值、形参。由于没有形参所以析构函数不能重载。一个类只有一个析构函数 如果程序员没有定义析构函数，C++编译系统会自动生成一个析构函数 【注】析构函数除了释放对象（资源）外，还可以执行程序员在最后一次适用对象后希望执行的任何操作。例如输出有关的信息。 4.【例3.5】包含构造函数和析构函数的C++程序 include <iostream>include <string>using namespace std;class Student {public:Student(int n, string nam, char s) {num = n;name = nam;sex = s;cout << "Constructor called." << endl;}~Student() {cout << "Destructor called." << endl;}void display() {cout << "num:" << num << endl;cout << "name:" << name << endl;cout << "sex:" << sex << endl;}private:int num;string name;char sex;};int main() {Student stud1(10010, "wang_li", 'f');stud1.display();Student stud2(10011, "zhang_han", 'm');stud2.display();return 0;}//main函数前声明的类其作用域是全局的 三、调用构造函数和析构函数的顺序 1.同一类存储类别的对象 一般情况下，调用析构函数的次序与调用构造函数的次序恰好相反：最先调用构造函数的对象，最后调用析构函数；最后调用构造函数的对象，最先调用析构函数。可简记为：先构造的后析构，后构造的先析构。它相当于一个栈，后进先出。 2.全局范围内定义的对象 在全局范围内定义的对象（在所有函数之外定义的对象），在文件中的所有函数（包括主函数）执行前调用构造函数。当主函数结束或执行exit函数时，调用析构函数。 3.局部自动对象 如果定义局部自动对象（在函数内定义对象），在创建对象时调用构造函数。如多次调用对象所在的函数，则每次创建对象时都调用构造函数。在函数调用结束时调用析构函数。 4.静态局部对象 如果在函数中定义静态局部对象，则在第一次调用该函数建立对象时调用构造函数，但在主函数结束或调用exit函数时才调用析构函数。 5.例 void fun(){student st1; //定义局部自动对象static student st2; //定义静态局部对象...} 对象st1是每次调用函数fun时调用构造函数。在函数fun结束时调用析构函数。 对象st2是第一次调用函数fun时调用构造函数，在函数fun结束时并不调用析构函数，到主函数结束时才调用析构函数 四、对象数组 1.含义 类是一种特殊的数据类型，它当然是C++的合法类型，自然可以定义对象数组。在一个对象数组中各个元素都是同类对象。例如一个班级有50个同学，每个学生有学号、年龄、成绩等属性，可以为这个班级建立一个对象数组，数组包括了50个元素：student std[50];。 可以这样建立构造函数：student::student(int 1001,int 18,int 60);。 在建立数组时，同样要调用构造函数。上面的数组有50个元素，要调用50次构造函数。如果构造函数有多个参数，C++要求：在等号后的花括号中为每个对象分别写出构造函数并指定实参。格式为： student st[n]={ student(实参1,实参2,实参3); …… student(实参1,实参2,实参3); }； 假定对象有三个数据成员：学号、年龄、成绩。下面定义有三个学生的对象数组： student st[3]={ student(1001,18,87); student(1002,19,76); student(1003,18,80); }；//构造函数带实参 在建立对象数组时，分别调用构造函数，对每个对象初始化。每个元素的实参用括号括起来，实参的位置与构造函数形参的位置一一对应，不会混淆。 2.【例3.6】 include <iostream>using namespace std;class Box {public:Box(int h = 10, int w = 12, int len = 15): height(h), width(w), length(len) {} //int volume();private:int height;int width;int length;};int Box::volume() {return (height width length);}int main() {Box a[3] = {Box(10, 12, 15), Box(15, 18, 20), Box(16, 20, 26)};cout << "a[0]的体积是" << a[0].volume() << endl;cout << "a[1]的体积是" << a[1].volume() << endl;cout << "a[2]的体积是" << a[2].volume() << endl;return 0;}//每个数组元素是一个对象 五、对象指针 指针的含义是内存单元的地址，可以指向一般的变量，也可以指向对象。 1.指向对象的指针 对象要占据一片连续的内存空间，CPU实际都是按地址访问内存，所以对象在内存的其实地址是CPU确定对象在内存中位置的依据。这个起始地址称为对象指针。 C++的对象也可以参加取地址运算：&对象名。运算的结果是该对象的起始地址，也称对象的指针，要用与对象类型相同的指针变量保存运算的结果。 C++中定义对象的指针变量与定义其他的指针变量相似，格式如下：类名 变量名表。类名表示对象所属的类，变量名按标识符规则取名，两个变量名之间用逗号分隔。定义好指针变量后，必须先给赋予合法的地址后才能使用。 例如定义如下一个类： class Time {public:Time() {hour = 0;minute = 0;sec = 0;}void set_time();void show_time();private:int hour;int minute;int sec;};void Time::set_time() {cin >> hour;cin >> minute;cin >> sec;}void Time::show_time() {cout << hour << ":" << minute << ":" << sec << endl;} 在此基础上，有如下语句： Time pt; //定义pt是指向Time类对象的指针Time t1; //定义Time类对象t1pt=&t1; //将对象t1的地址赋予pt 程序在此基础上就可以用指针变量访问对象的成员。 (pt).hour;pt->hour;(pt).show_time();pt->show_time(); 2.指向对象成员的指针 （1）含义 对象由成员组成。对象占据的内存区是各个数据成员占据的内存区的总和。对象成员也有地址，即指针。这指针分指向数据成员的指针和指向成员函数的指针。 （2）指向对象公有数据成员的指针 定义数据成员的指针变量：数据类型 指针变量名（这里的数据类型是数据成员的数据类型） 计算公有数据成员的地址：&对象名.成员名 Time t1;int p1; //定义一个指向整型数据的指针变量p1=&t1.hour; //假定hour是公有成员cout<<p1<<endl; （3）指向对象成员函数的指针 定义指向成员函数的指针变量：数据类型(类名::变量名)(形参表); 数据类型是成员函数的类型；类名是对象所属的类；变量名按标识符取名；形参表：指定成员函数的形参表（形参个数、类型） 取成员函数的地址：&类名::成员函数名 给指针变量赋初值：指针变量名=&类名::成员函数名; 用指针变量调用成员函数：(对象名.指针变量名)([实参表]); 对象名：指定调用成员函数的对象；：明确其后的是一个指针变量；实参表：与成员函数的形参表对应，如无形参，可以省略实参表 （4）【例3.7】有关对象指针的使用方法 include <iostream>using namespace std;class Time {public:Time(int, int, int);int hour;int minute;int sec;void get_time();};Time::Time(int h, int m, int s) {hour = h;minute = m;sec = s;}void Time::get_time() {cout << hour << ":" << minute << ":" << sec << endl;}int main() {Time t1(10, 13, 56);int p1 = &t1.hour; //定义指向数据成员的指针p1cout << p1 << endl;t1.get_time(); //调用成员函数Time p2 = &t1; //定义指向对象t1的指针p2p2->get_time(); //用对象指针调用成员函数void(Time::p3)(); //定义指向成员函数的指针p3 = &Time::get_time; //给成员函数的指针赋初值(t1.p3)(); //用指向成员函数的指针调用成员函数return 0;} 【注】代码的34，35行可合并为：void(Time::p3)=&Time::get_time; 3.this指针 一个类的成员函数只有一个内存拷贝。类中不论哪个对象调用某个成员函数，调用的都是内存中同一个成员函数代码。例如Time类一个成员函数： void Time::get_time(){cout<<hour<<":"<<minute<<":"<<sec<<endl;}t1.get_time();t2.get_time(); 当不同对象的成员函数访问数据成员时，怎么保证访问的就是指定对象的数据成员？其实每个成员函数中都包含一个特殊的指针，他的名字是this指针。它是指向本类对象的指针。当对象调用成员函数时，它的值就是该对象的起始地址。所以为了区分不同对象访问成员函数，语法要求的调用成员函数的格式是：对象名.成员函数名(实参表)。从语法上明确是对象名所指的对象调用成员函数。This指针是隐式使用的，在调用成员函数时C++把对象的地址作为实参传递给this指针。例如成员函数定义如下： int Box::volume(){return(heightwidthlength);} C++编译成： int Box::volume(this){return(this->heightthis->widththis->length);} 对于计算长方体体积的成员函数volume，当对象调用它时，就把对象地址给this指针，编译程序将的地址作为实参调用成员函数：a.volume(&a);。实际上函数是计算(this->height)(this->width)(this->length)，这时就等价计算(a.height)(a.width)(a.length)。 可以用(this)表示调用成员函数的对象。(this)就是this所指的对象。如前面的计算长方体体积的函数中return语句可以写成：return((this).height(this).width(this).length);注意，this两侧的括号不能省略。 C++通过编译程序，在对象调用成员函数时，把对象的地址赋予this指针，用this指针指向对象，实现了用同一个成员函数访问不同对象的数据成员。 六、共用数据的保护 如果既希望数据在一定范围内共享，又不愿它被随意修改，从技术上可以把数据指定为只读型的。C++提供const手段，将数据、对象、成员函数指定为常量，从而实现了只读要求，达到保护数据的目的。 1.常对象 定义格式： const 类名 对象名（实参表）;或 类名 const 对象名（实参表）; 把对象定义为常对象，对象中的数据成员就是常变量，在定义时必须带实参作为数据成员的初值，在程序中不允许修改常对象的数据成员值。 如果一个常对象的成员函数未被定义为常成员函数（除构造函数和析构函数外），则对象不能调用这样的函数。 const Time t1(10,16,36);t1.get_time();//错误，不能调用 为了访问常对象中的数据成员，要定义常成员函数。 void get_time() const 如果在常对象中要修改某个数据成员，C++提供了指定可变的数据成员方法。 格式：mutable 类型 数据成员 在定义数据成员时加mutable后，将数据成员声明为可变的数据成员，就可以用声明为const的成员函数修改它的值。 2.常对象成员 可以在声明普通对象时将数据成员或成员函数声明为常数据成员或常成员函数。 （1）常数据成员 格式： const 类型 数据成员名 将类中的数据成员定义为具有只读的性质。注意只能通过带参数初始表的构造函数对常数据成员进行初始化。例如： const int hour;Time::Time(int h){hour=h;...//错误}Time::Time(int h):hour(h){}//正确 在类中声明了某个常数据成员后，该类中每个对象的这个数据成员的值都是只读的，而每个对象的这个数据成员的值可以不同，由定义对象时给出。 （2）常成员函数 定义格式：类型 函数名 （形参表）const const是函数类型的一部分，在声明函数原型和定义函数时都要用const关键字。 【注1】const是函数类型的一个组成部分，因此在函数的实现部分也要使用关键字const。常成员函数不能修改对象的数据成员，也不能调用该类中没有由关键字const修饰的成员函数，从而保证了在常成员函数中不会修改数据成员的值。如果一个对象被说明为常对象，则通过该对象只能调用它的常成员函数。 【注2】一般成员函数可以访问或修改本类中非const数据成员。而常成员函数只能读本类中的数据成员，而不能写他们。 数据成员 非const成员函数 const成员函数 非const的数据成员 可以引用，也可以改变值 可以引用，但不可以改变值 const数据成员 可以引用，但不可以改变值 可以引用，但不可以改变值 const对象的数据成员 不允许引用和改变值 可以引用，但不可以改变值 常成员函数的使用： 如果类中有部分数据成员的值要求为只读，可以将它们声明为const，这样成员函数只能读这些数据成员的值，但不能修改它们的值 如果所有数据成员的值为只读，可将对象声明为const，在类中必须声明const成员函数，常对象只能通过常成员函数读数据成员 常对象不能调用非const成员函数 【注】如果常对象的成员函数未加const，编译系统将其当作非const成员函数；常成员函数不能调用非const成员函数 3.指向对象的常指针 如果在定义指向对象的指针时，使用了关键字const，他就是一个常指针，必须在定义时对其初始化，并且在程序运行中不能再修改指针的值。 格式：const 指针变量名=对象地址 Time t1(10,12,15),t2;Time const p1=&t1;//在此后，不能修改p1Time const p1=&t2;//错误语句 指向对象的常指针，在程序运行中始终指向的是同一个对象。即指针变量的值始终不变，但它所指对象的数据成员值可以修改。当需要将一个指针变量固定地与一个对象相联系时，就可将指针变量指定为const。往往用常指针作为函数的形参，目的是不允许在函数中修改指针变量的值，让它始终指向原来的对象。 4.指向常对象的指针变量 5.对象的常引用 （1）含义 前面学过引用是传递参数的有效方法。用引用形参时，形参变量与实参变量是同一个变量，在函数内修改引用形参也就是修改实参变量。如果用引用形参又不想让函数修改实参，可以使用常引用机制。 （2）格式 const 类名 &形参变量名 （3）【例3.8】对象的引用 include <iostream>using namespace std;class Time {public:Time(int, int, int);int hour;int minute;int sec;};Time::Time(int h, int m, int s) {hour = h;minute = m;sec = s;}void fun(Time &t) {t.hour = 18;}int main() {Time t1(10, 13, 56);fun(t1);cout << t1.hour << endl;return 0;} //如果用引用形参又不想让函数修改实参，可以使用常引用机制include <iostream>using namespace std;class Time {public:Time(int, int, int);void fun(int &t) {hour = t;t = 18;}int hour;int minute;int sec;};Time::Time(int h, int m, int s) {hour = h;minute = m;sec = s;}int main(int argc, char argc[]) {int x = 15;Time t1(10, 13, 56);t1.fun(x);cout << t1.hour << endl;cout << x << endl;return 0;} 6.const型数据小结 七、对象的动态建立与释放——动态建立对象 C++提供了new和delete运算符，实现动态分配、回收内存。他们也可以用来动态建立对象和释放对象。 格式：new 类名; 功能：在堆里分配内存，建立指定类的一个对象。如果分配成功，将返回动态对象的起始地址（指针）；如不成功，返回0.为了保存这个指针，必须事先建立以类名为类型的指针变量。 格式：类名 指针变量名 Box pt;pt=new Box;//如果分配成功，就可以用指针变量pt访问动态对象的数据成员cout<<pt->height;cout<<pt->volume(); 当不再需要使用动态变量时，必须用delete运算符释放内存。 格式：delete 指针变量（存放的是用new运算返回的指针） 八、对象的赋值和复制 1.对象的赋值 （1）含义 如果一个类定义了两个或多个对象，则这些同类对象之间可以相互赋值。这里所指的对象的值含义是对象中所有数据成员的值。对象1、对象2都是已建立好的同类对象。 格式：对象1=对象2； （2）【例3.9】对象的赋值 include <iostream>using namespace std;class Box {public:Box(int = 10, int = 10, int = 10);int volume();private:int height;int width;int length;};Box::Box(int h, int w, int len) {height = h;width = w;length = len;}int Box::volume() {return (height width length);}int main() {Box box1(15, 30, 25), box2;cout << "box1 体积=" << box1.volume() << endl;box2 = box1;cout << "box2 体积=" << box2.volume() << endl;return 0;} （3）说明 对象的赋值只对数据成员操作 数据成员中不能含有动态分配的数据成员 2.对象的复制 （1）含义 对象赋值的前提是对象1和对象2是已经建立的对象。C++还可以按照一个对象克隆出另一个对象（从无到有），这就是复制对象。复制对象是创建对象的另一种方法（以前学过的是定义对象）。创建对象必须调用构造函数，复制对象要调用复制构造函数。以Box类为例，复制构造函数的形式是： Box::Box(const Box &b){height=b.height;width=b.width;length=b.length;} 复制构造函数只有一个参数，这个参数是本类的对象，且采用引用对象形式。为了防止修改数据，加const限制。构造函数的内容就是将实参对象的数据成员值赋予新对象对应的数据成员，如果程序中未定义复制构造函数，编译系统将提供默认的复制构造函数，复制类中的数据成员。 复制对象有两种格式： 类名 对象2（对象1）；按对象1复制对象2 类名 对象2=对象1，对象3=对象1，……按对象1复制对象2、对象3 （2）【例】用复制对象的方法创建Box类的对象（用默认复制构造函数） //include "stdafx.h"include <iostream>using namespace std;class Box {public:Box(int = 10, int = 10, int = 10);int volume();private:int height;int width;int length;};Box::Box(int h, int w, int len) {height = h;width = w;length = len;}int Box::volume() {return (height width length);}int main() {Box box1(15, 30, 25);cout << "box1 体积=" << box1.volume() << endl;//Box box2=box1,box3=box2;Box box2(box1), box3(box2);cout << "box2 体积=" << box2.volume() << endl;cout << "box3 体积=" << box3.volume() << endl;return 0;} （3）说明 在以下情况调用复制构造函数： 在程序里用复制对象格式创建对象 当函数的参数是对象。调用函数时，需要将实参对象复制给形参对象，在此系统将调用复制构造函数 void fun(Box b){...}int main(){Box box1(12,15,18);fun(box1);return 0;} 在函数返回值是类的对象时，需要将函数里的对象复制一个临时对象当作函数值返回 Box f(){Box box1(12,15,18);return box1;}int main(){Box box2;box2=f();} 九、静态成员 C++用const保护数据对象不被修改，在实际中还需要共享数据，C++怎样提供数据共享机制？C++静态成员、友元实现对象之间、类之间的数据共享。 1.静态数据成员 （1）定义格式 static 类型 数据成员名 class Box{public:Box(int=10,int=10,int=10);int volume();private:static int height;int width;int length;}; （2）特性 设Box有n个对象box1..boxn。这n个对象的height成员在内存中共享一个整型数据空间。如果某个对象修改了height成员的值，其他n-1个对象的height成员值也被改变，从而达到n个对象共享height成员值的目的。 （3）说明 由于一个类的所有对象共享静态数据成员，所以不能用构造函数为静态数据成员初始化，只能在类外专门对其初始化。如果程序未对静态数据成员赋初值，则编译系统自动用0为它赋初值 格式：数据类型 类名::静态数据成员名=初值； 即可已用对象名引用静态成员，也可以用类名引用静态成员 静态数据成员在对象外单独开辟内存空间，只要在类中定义了静态成员，即使不定义对象，系统也为静态成员分配内存空间，可以被引用 在程序开始时为静态成员分配内存空间，直到程序结束才释放内存空间 静态数据成员作用域是它的类的作用域（如果在一个函数内定义类，他的静态数据成员作用域就是这个函数）在此范围内可以用“类名::静态成员名”的形式访问静态数据成员 （4）【例3.10】引用静态数据成员 include <iostream>using namespace std;class Box {public:Box(int, int);int volume();static int height;int width;int length;};Box::Box(int w, int len) {width = w;length = len;}int Box::volume() {return (height width length);}int Box::height = 10;int main() {Box a(15, 20), b(25, 30);cout << a.height << endl;cout << b.height << endl;cout << Box::height << endl;cout << a.volume() << endl;cout << b.volume() << endl;return 0;} 2.静态成员函数 （1）含义 C++提供静态成员函数，用它访问静态数据成员，静态成员函数不属于某个对象而属于类。 类中的非静态成员函数可以访问类中所有数据成员；而静态成员函数可以直接访问类的静态成员，不能直接访问非静态成员。 静态成员函数定义格式： static 类型 成员函数（形参表）{……} 调用公有静态成员函数格式： 类名::成员函数（实参表） 引用方式 静态数据成员 非静态数据成员 静态成员函数 成员名 对象名.成员名 非静态成员函数 成员名 成员名 【注】静态成员函数不带this指针，所以必须用对象名和成员运算符.访问非静态成员；而普通成员函数有this指针，可以在函数中直接引用成员名。 （2）【例3.11】关于引用非静态成员和静态成员的具体方法 class Student {private:int num;int age;float score;static float sum;static int count;public:Student(int, int, int);void total();static float average();};Student::Student(int m, int a, int s) {num = m;age = a;score = s;}void Student::total() {sum += score;count++;}float Student::average() {return (sum / count);}float Student::sum = 0;int Student::count = 0;int main() {Student stud[3] = {Student(1001, 18, 70), Student(1002, 19, 79), Student(1005, 20, 98)};int n;cout << "请输入学生的人数：";cin >> n;for (int i = 1; i < n; i++)stud[i].total();cout << n << "个学生的平均成绩是："cout << Student::average() << endl;return 0;} （3）【例】具有静态数据成员的point类 include <iostream>using namespace std;class Point {private:int X, Y;static int countP;public:Point(int xx = 0, int yy = 0) {X = xx;Y = yy;countP++;}Point(Point &p); //复制构造函数int GetX() {return X;}int GetY() {return Y;}int GetC() {cout << "Object id=" << countP << endl;return 0;} };Point::Point(Point &p) {X = p.X;Y = p.Y;countP++;}int Point::countP = 0;int main() {Point A(4, 5);cout << "Point A," << A.GetC() << "," << A.GetY();A.GetC();Point B(A);cout << "Point B," << B.GetC() << "," << B.GetY();B.GetC();return 0;} （4）静态成员函数举例 include <iostream>using namespace std;class application {private:static int global;public:static void f();static void g();};int application::global = 0;void application::f() {global = 5;}void application::g() {cout << global << endl;}int main() {application::f();application::g();return 0;} class A{private:int x; //非静态成员public:static void f(A a);};void A::f(A a){cout<<x; //对x的引用是错误的cout<<a.x; //正确} （5）具有静态数据、函数成员的Point类 include <iostream>using namespace std;class Point { //point类声明private: //私有数据成员int X, Y;static int countP;public: //外部接口Point(int xx = 0, int yy = 0) {X = xx;Y = yy;countP++;}Point(Point &p); //复制构造函数int GetX() {return X;}int GetY() {return Y;}static int GetC() {cout << "Object id=" << countP << endl;return 0;} };Point::Point(Point &p) {X = p.X;Y = p.Y;countP++;}int Point::countP = 0;int main() //主函数实现{ Point A(4, 5); //声明对象Acout << "Point A," << A.GetC() << "," << A.GetY();A.GetC(); //输出对象号，对象名引用Point B(A); //声明对象Bcout << "Point B," << B.GetC() << "," << B.GetY();Point::GetC(); //输出对象号，类名引用return 0;} （6）静态成员函数、静态数组及其初始化 include <iostream>include <stdio.h>using namespace std;class A {static int a[20];int x;public:A(int xx = 0) {x = xx;}static void in();static void out();void show() {cout << "x=" << x << endl;} };int A::a[20] = {0, 0};void A::in() {cout << "input a[20]:" << endl;for (int i = 0; i < 20; ++i)cin >> a[i];}void A::out() {for (int i = 0; i < 20; ++i)cout << "a[" << i << "]=" << a[i] << endl;}int main() {A::in();A::out();A a;a.out();a.show();return 0;} 十、友元 除了在同类对象之间共享数据外，类和类之间也可以共享数据。类的私有成员只能被类的成员函数访问，但是有时需要在类的外部访问类的私有成员，C++通过友元的手段实现这一特殊要求。友元可以是不属于任何类的一般函数，也可以是另一个类的成员函数，还可以是整个的一个类（这个类中的所有成员函数都可以成为友元函数）。 友元是C++提供的一种破坏数据封装和数据隐藏的机制。为了保证数据的完整性及数据封装与隐藏的原则，建议尽量不使用或少使用友元。 1.友元函数 （1）含义 如果在A类外定义一个函数（它可以是另一个类的成员函数，也可以是一个普通函数），在A类中声明该函数是A的友元函数后，这个函数就能访问A类中的所有成员。 （2）格式 friend 类型 类1::成员函数x(类2 &对象); friend 类型 函数y(类2 &对象); //类1是另一个类的类名，类2是本类的类名 功能：第一种形式在类2中声明类1的成员函数x为友元函数。第二种形式在类2中声明一个普通函数y是友元函数。 友元函数内访问对象的格式： 对象名.成员名 因为友元不是成员函数，它不属于类，所以它访问对象时必须冠以对象名。定义友元函数时形参通过定义引用对象，这样在友元函数内就能访问实参对象了。 （3）【例3.12】将普通函数声明为友元函数 include <iostream>using namespace std;class Time {public:Time(int, int, int);friend void display(Time &);private:int hour;int minute;int sec;};Time::Time(int h, int m, int s) {hour = h;minute = m;sec = s;}void display(Time &t) {cout << t.hour << ":" << t.minute << ":" << t.sec << endl;}int main() {Time t1(10, 13, 56);display(t1);return 0;} 【例】使用友元函数计算两点距离 include <iostream>include <cmath>using namespace std;class Point {public:Point(int xx = 0, int yy = 0) {X = xx;Y = yy;}int GetX() {return X;}int GetY() {return Y;}friend double Distance(Point &a, Point &b);private:int X, Y;};double Distance(Point &a, Point &b) {double dx = a.X - b.X;double dy = b.Y - b.Y;return sqrt(dx dx + dy dy);}int main() {Point p1(3.0, 5.0), p2(4.0, 6.0);double d = Distance(p1, p2);cout << "The distance is " << d << endl;return 0;} include <iostream>include <math.h>using namespace std;class TPoint {private:double x, y;public:TPoint(double a, double b) {x = a;y = b;cout << "点：（" << x << "," << y << "）" << endl;}friend double distance(TPoint &a, TPoint &b) {return sqrt((a.x - b.x) (a.x - b.x) + (a.y - b.y) (a.y - b.y));} };int main(int argc, char argv[]) {TPoint myp1(2.1, 1.3), myp2(5.4, 6.5);cout << "两点之间的距离为：";cout << distance(myp1, myp2) << endl;return 0;} （4）友元成员函数 【例3.13】将成员函数声明为友元函数 例子中有两个类Time和Date。其中Time类里定义了成员函数void display(Date &)，他除了显示时间外还要显示日期，这个日期通过引用形参访问。在Date类中将Time类的display成员函数定义为友元函数，允许display访问Date类的所有私有数据成员。 include <iostream>using namespace std;class Date;class Time {private:int hour;int minute;int sec;public:Time(int, int, int);void display(const Date &);};class Date {private:int month;int day;int year;public:Date(int, int, int);friend void Time::display(const Date &);};Time::Time(int h, int m, int s) hour = h;minute = m;sec = s;}void Time::display(const Date &da) {cout << da.month << "/" << da.day << "/" << da.year << endl;cout << hour << ":" << minute << ":" << sec << endl;}Date::Date(int m, int d, int y) {month = m;day = d;year = y;}int main() {Time t1(10, 13, 56);Date d1(12, 25, 2004);t1.display(d1);return 0;} 【注1】友元是单向的，此例中声明Time的成员函数display是Date类的友元，允许它访问Date类的所有成员，但不等于说Date类的成员函数也是Time类的友元。 【注2】一个函数（包括普通函数和成员函数）可以被多个类声明为“朋友”，这样就可以引用多个类中的私有数据 【注3】例如可以将例3.13程序中的display函数作为类外的普通函数，分别在Time和Date类中将display声明为友元。Display就可以分别引用Time和Date类的对象的私有数据成员。输出年月日和时分秒。 2.友元类 C++允许将一个类声明为另一个类的友元。假定A类是B类的友元类，A类中所有的成员函数都是B类的友元函数，在B类中声明A类为友元类的格式：friend A; 【注1】友元关系是单向的，不是双向的 【注2】友元关系不能传递 【注3】实际中一般不把整个类声明友元类，而只是将确有需要的成员函数声明为友元函数 include <iostream>include <math.h>using namespace std;class B;class A {private:int x;public:A() {x = 3;}friend class B;};class B {public:void disp1(A temp) {temp.x++;cout << "disp1:x" << temp.x << endl;}void disp2(A temp) {temp.x--;cout << "disp2:x" << temp.x << endl;} };int main(int argc, char argv[]) {A a;B b;b.disp1(a);b.disp2(a);return 0;} class Student; //前向声明，类名声明class Teacher{privated:int noOfStudents;Student pList[100];public:void assignGrades(Student &s); //赋成绩void adjustHours(Student &s); //调整学时数};class Student{privated:int hours;float gpa;public:friend class Teacher;};void Teacher::assignGrades(Student &s){...};void Teacher::adjustHours(Student &s){...}; //函数定义必须在Student定义之后 十一、类模板 1.含义 对于功能相同而只是数据类型不同的函数，不必须定义出所有函数，我们定义一个可对任何类型变量操作的函数模板。对于功能相同的类而数据类型不同，不必定义出所有类，只要定义一个可对任何类进行操作的类模板。 例如定义比较两个整数的类和比较两个浮点数的类，这两个类做的工作是相似的，所以可以用类模板，减少工作量。 class Compare_int{private:int x,y;public:Compare_int(int a,int b){x=a;y=b;}int max(){return (x>y)?x:y;}int min(){return (x<y)?x:y;} };class Compare_float{private:float x,y;public:Compare_float(float a,float b){x=a;y=b;}float max(){return (x>y)?x:y;}float min(){return (x<y)?x:y;} }; 2.定义类模板的格式 template <class 类型参数名> class 类模板名 {……} 类型参数名：按标识符取名。如有多个类型参数，每个类型参数都要以class为前导，两个类型参数之间用逗号分隔 类模板名：按标识符取名 类模板{...}内定义数据成员和成员函数的规则：用类型参数作为数据类型，用类模板名作为类 template<class numtype>class Compare{private:numtype x,y;public:Compare(numtype a,numtype b){x=a,y=b;}numtype max(){return (x>y)?x:y;}numtype min(){return (x<y)?x:y;} }; 3.在类模板外定义成员函数的语法 类型参数 类模板名<类型参数>::成员函数名（形参表）{……} 例如在类模板外定义max和min成员函数 template<class numtype>class Compare{public:Compare(numtype a,numtype b){x=a,y=b;}numtype max();numtype min();private:numtype x,y;};numtype Compare<numtype>::max(){return(x>y)?x:y;}numtype Compare<numtype>::min(){return(x<y)?x:y;} 4.使用类模板时，定义对象的格式 类模板名 <实际类型名>对象名； 类模板名 <实际类型名>对象名（实参表）； 例如：Compare <int>cmp2(4,7) 在编译时， 编译系统用int取代类模板中的类型参数numtype，就把类模板具体化了。这时Compare<int>将相当于Compare_int类。 5.【例3.14】声明类模板，实现两个整数、浮点数和字符的比较，求出大数和小数 include <iostream>using namespace std;template<class numtype>class Compare {private:numtype x, y;public:Compare(numtype a, numtype b) {x = a;y = b;}numtype max() {return (x > y) ? x : y;}numtype min() {return (x < y) ? x : y;} };int main() {Compare<int>cmp1(3, 7);cout << cmp1.max() << "是两个整数中的大数." << endl;cout << cmp1.min() << "是两个整数中的小数." << endl;Compare<float>cmp2(45.78, 93.6);cout << cmp2.max() << "是两个浮点数中的大数." << endl;cout << cmp2.min() << "是两个浮点数中的小数." << endl;Compare<char>cmp3('a', 'A');cout << cmp3.max() << "是两个字符中的大者." << endl;cout << cmp3.min() << "是两个字符中的小者." << endl;return 0;} 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_72318954/article/details/127064376。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...、秒杀商品显示 1、使用生成器生成对应的表 记得在每个mapper类加入注解供spring扫描： @Repository 2、后端写得到秒杀商品的方法 ①、建实体类vo 用于连表查询，得到商品名字 package com.example.seckill.vo;import com.example.seckill.pojo.SeckillGoods;import lombok.Data;@Datapublic class SeckillGoodsVo extends SeckillGoods {private String goodsName;} ②、在SexkillGoodsMapper.xml文件中定义sql <?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.example.seckill.mapper.SeckillGoodsMapper"><select id="queryAll" resultType="com.example.seckill.vo.SeckillGoodsVo">select sg.,g.goods_namefrom t_seckill_goods sg,t_goods gwhere sg.goods_id = g.gid;</select></mapper> ③、在mapper中定义 package com.example.seckill.mapper;import com.example.seckill.pojo.SeckillGoods;import com.baomidou.mybatisplus.core.mapper.BaseMapper;import com.example.seckill.vo.SeckillGoodsVo;import org.springframework.stereotype.Repository;import java.util.List;/ <p> 秒杀商品信息表 Mapper 接口 </p> @author lv @since 2022-03-19/@Repositorypublic interface SeckillGoodsMapper extends BaseMapper<SeckillGoods> {List<SeckillGoodsVo> queryAll();} ④、service层与controller层 service: ISeckillGoodsService: package com.example.seckill.service;import com.example.seckill.pojo.SeckillGoods;import com.baomidou.mybatisplus.extension.service.IService;import com.example.seckill.util.response.ResponseResult;import com.example.seckill.vo.SeckillGoodsVo;import java.util.List;/ <p> 秒杀商品信息表 服务类 </p> @author lv @since 2022-03-19/public interface ISeckillGoodsService extends IService<SeckillGoods> {ResponseResult<List<SeckillGoodsVo>> queryAll();} SeckillGoodsServiceImpl: package com.example.seckill.service.impl;import com.example.seckill.pojo.SeckillGoods;import com.example.seckill.mapper.SeckillGoodsMapper;import com.example.seckill.service.ISeckillGoodsService;import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;import com.example.seckill.util.response.ResponseResult;import com.example.seckill.vo.SeckillGoodsVo;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import java.util.List;/ <p> 秒杀商品信息表 服务实现类 </p> @author lv @since 2022-03-19/@Servicepublic class SeckillGoodsServiceImpl extends ServiceImpl<SeckillGoodsMapper, SeckillGoods> implements ISeckillGoodsService {@Autowiredprivate SeckillGoodsMapper seckillGoodsMapper;@Overridepublic ResponseResult<List<SeckillGoodsVo>> queryAll() {List<SeckillGoodsVo> list= seckillGoodsMapper.queryAll();return ResponseResult.success(list);} } controller: SeckillGoodsController: package com.example.seckill.controller;import com.example.seckill.service.ISeckillGoodsService;import com.example.seckill.util.response.ResponseResult;import com.example.seckill.vo.SeckillGoodsVo;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;import java.util.List;/ <p> 秒杀商品信息表 前端控制器 </p> @author lv @since 2022-03-19/@RestController@RequestMapping("/seckillGoods")public class SeckillGoodsController {@Autowiredprivate ISeckillGoodsService seckillGoodsService;@RequestMapping("/queryAll")public ResponseResult<List<SeckillGoodsVo>> queryAll(){return seckillGoodsService.queryAll();} } 得到秒杀商品数据： 3、前端显示数据 ①、编辑跳转秒杀界面 goodList.ftl: <!DOCTYPE html><html lang="en"><head><include "../common/head.ftl"><style>.layui-this{background: deepskyblue !important;}</style></head><body class="layui-container layui-bg-orange"><div class="layui-tab"><ul class="layui-tab-title"><li class="layui-this">普通商品</li><li>秒杀商品</li></ul><-- 普通商品--><div class="layui-tab-content"><div class="layui-tab-item layui-show"><div class="layui-form-item"><label class="layui-form-label">搜索栏</label><div class="layui-input-inline"><input type="text" id="normal_name" name="text" placeholder="请输入搜索内容" class="layui-input"></div><div class="layui-input-inline"><button class="layui-btn layui-btn-primary" id="normal_search">🔍</button><button class="layui-btn layui-btn-primary" id="normal_add">增加</button></div></div><table id="normal_goods" lay-filter="normal_goods"></table><script type="text/html" id="button_1"><a class="layui-btn layui-btn-xs" lay-event="normal_del">删除</a><a class="layui-btn layui-btn-xs" lay-event="normal_edit">编辑</a></script></div><--秒杀界面--><div class="layui-tab-item"><div class="layui-form-item"><label class="layui-form-label">搜索栏</label><div class="layui-input-inline"><input type="text" id="seckill_name" name="text" placeholder="请输入搜索内容" class="layui-input"></div><div class="layui-input-inline"><button class="layui-btn layui-btn-primary" id="seckill_search">🔍</button><button class="layui-btn layui-btn-primary" id="seckill_add">增加</button></div></div><table id="seckill_goods" lay-filter="seckill_goods"></table></div></div></div></div><--引入js--><script src="/static/asset/js/project/goodsList.js"></script></body></html> ②、获取数据 goodList.js: // 秒杀商品let seckill_table=table.render({elem: 'seckill_goods',height: 500,url: '/seckillGoods/queryAll' //数据接口,parseData(res){ //res 即为原始返回的数据return {"code": res.code===200?0:1, //解析接口状态"msg": res.message, //解析提示文本"count": res.total, //解析数据长度"data": res.data //解析数据列表};},cols: [[ //表头{field: 'id', title: '秒杀商品编号', width:80, sort: true},{field: 'goodsId', title: '商品名字id'},{field: 'seckillPrice', title: '秒杀价格'},{field: 'stockCount', title: '秒杀库存'},{field: 'startDate', title: '活动开始时间'},{field: 'endDate', title: '活动结束时间'},{field: 'goodsName', title: '商品名称'}]]}); 呈现界面： 二、秒杀商品添加 1、后端：接收前端添加秒杀商品的数据 ①、实体类vo：SeckillGoodsVo private List<Map<String,Object>> goods; 修改实体类时间的类型：SeckillGoods @ApiModelProperty("秒杀开始时间")@TableField("start_date")@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")private Timestamp startDate;@ApiModelProperty("秒杀结束时间")@TableField("end_date")@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")private Timestamp endDate; ②、mapper层：SeckillGoodsMapper int addGoods(SeckillGoodsVo seckillGoodsVo); ③、mapper.xml层：SeckillGoodsMapper 批量插入秒杀商品的sql语句： <insert id="addGoods">insert into t_seckill_goods(goods_id, seckill_price, stock_count, start_date, end_date)values<foreach collection="goods" item="g" separator=",">({g.gid},{g.goodsPrice},{g.goodsStock},{startDate},{endDate})</foreach></insert> ④、service层 ISeckillGoodsService： ResponseResult<List<SeckillGoodsVo>> addGoods(SeckillGoodsVo seckillGoodsVo); SeckillGoodsServiceImpl： @Overridepublic ResponseResult<List<SeckillGoodsVo>> addGoods(SeckillGoodsVo seckillGoodsVo) {int goods=seckillGoodsMapper.addGoods(seckillGoodsVo);return ResponseResult.success(goods);} ⑤、controller层 @RequestMapping("/add")public ResponseResult<List<SeckillGoodsVo>> add(@RequestBody SeckillGoodsVo seckillGoodsVo){return seckillGoodsService.addGoods(seckillGoodsVo);} 2、前端 ①、定义数据与刷新、添加 goodsList.js： var layer,row,seckill_table// 添加秒杀商品$("seckill_add").click(()=>{layer.open({type:2,content: '/goods/SeckillGoodsOperate',area: ['800px','600px']})})// 秒杀商品刷新var seckill_reload = ()=> {seckill_table.reload({page:{curr:1 //current} });} var layer,row,seckill_tablelayui.define(()=>{let table=layui.tablelayer=layui.layerlet $=layui.jquerylet normal_table=table.render({elem: 'normal_goods',height: 500,url: '/goods/queryAll' //数据接口,page: true //开启分页,parseData(res){ //res 即为原始返回的数据return {"code": res.code===200?0:1, //解析接口状态"msg": res.message, //解析提示文本"count": res.total, //解析数据长度"data": res.data //解析数据列表};},//用于对分页请求的参数：page、limit重新设定名称request: {pageName: 'page' //页码的参数名称，默认：page,limitName: 'rows' //每页数据量的参数名，默认：limit},cols: [[ //表头{field: 'gid', title: '商品编号', width:80, sort: true, fixed: 'left'},{field: 'goodsName', title: '商品名字'},{field: 'goodsTitle', title: '商品标题'},{field: 'goodsImg',title: '商品图片',width:200,templet: (goods) => <b onmouseover='showImg("${goods.goodsImg}",this)'> + goods.goodsImg + </b> },{field: 'goodsDetail', title: '商品详情'},{field: 'goodsPrice', title: '商品价格', sort: true},{field: 'goodsStock', title: '商品库存', sort: true},{field: 'operate', title: '商品操作',toolbar: 'button_1'}]]});// 刷新表格let reloadTable=()=>{let goodsName=$("normal_value").val()// 【JS】自动化渲染的重载,重载表格normal_table.reload({where: {//设定异步数据接口的额外参数,height: 300goodsName},page:{curr:1 //current} });}// 搜索$("normal_search").click(reloadTable)// 增加$("normal_add").click(()=>{row = nullopenDialog()})//工具条事件table.on('tool(normal_goods)', function(obj) { //注：tool 是工具条事件名，test 是 table 原始容器的属性 lay-filter="对应的值"let data = obj.data; //获得当前行数据let layEvent = obj.event; //获得 lay-event 对应的值（也可以是表头的 event 参数对应的值）let tr = obj.tr; //获得当前行 tr 的 DOM 对象（如果有的话）if (layEvent === 'normal_del') { //删除row = data//获得当前行的数据let url="/goods/del/"+data.gidlayer.confirm('确定删除吗？',{title:'删除'}, function(index){//向服务端发送删除指令og$.getJSON(url,{gid:data.gid}, function(ret){layer.close(index);//关闭弹窗reloadTable()});layer.close(index);//关闭弹窗});}if (layEvent === 'normal_edit') { //编辑row = dataopenDialog()} })// 页面弹出let openDialog=()=>{// 如果是iframe层layer.open({type: 2,content: '/goods/goodsOperate', //这里content是一个URL，如果你不想让iframe出现滚动条，你还可以content: ['http://sentsin.com', 'no']area:['800px','600px'],btn: ['确定','取消'],yes(index,layero){let url="/goods/insert"// 拿到表格数据let data=$(layero).find("iframe")[0].contentWindow.getFormData()if(row) {url="/goods/edit"}$.ajax({url,data,datatype: "json",success(res){layer.closeAll()reloadTable()layer.msg(res.message)} })} });}// -------------------------秒杀商品-------------------------------------------seckill_table=table.render({elem: 'seckill_goods',height: 500,url: '/seckillGoods/queryAll' //数据接口,parseData(res){ //res 即为原始返回的数据return {"code": res.code===200?0:1, //解析接口状态"msg": res.message, //解析提示文本"count": res.total, //解析数据长度"data": res.data //解析数据列表};},cols: [[ //表头{field: 'id', title: '秒杀商品编号', width:80, sort: true},{field: 'goodsId', title: '商品名字id'},{field: 'seckillPrice', title: '秒杀价格'},{field: 'stockCount', title: '秒杀库存'},{field: 'startDate', title: '活动开始时间'},{field: 'endDate', title: '活动结束时间'},{field: 'goodsName', title: '商品名称'}]]});// 添加秒杀商品$("seckill_add").click(()=>{layer.open({type:2,content: '/goods/SeckillGoodsOperate',area: ['800px','600px']})})})// 图片显示let showImg = (src,obj)=> {layer.tips(<img src="${src}" width="100px">, obj);}// 秒杀商品刷新var seckill_reload = ()=> {seckill_table.reload({page:{curr:1 //current} });} ②、增加秒杀商品弹出页面样式 <!DOCTYPE html><html lang="en"><head><meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1"><link rel="stylesheet" href="/static/asset/js/layui/css/layui.css" media="all"></head><body><div style="padding:15px 0px;"><div class="layui-condition"><form id="fm" name="fm" action="/" method="post" class="layui-form"><div class="layui-form-item"><div class="layui-inline"><label class="layui-form-label" style="width: 100px;text-align: left;">秒杀活动时间:</label><div class="layui-input-inline" style="width:280px;"><input type="text" class="layui-input" id="dt"></div><div class="layui-input-inline"><button class="layui-btn" id="btn_save" type="button"><i class="fa fa-search fa-right"></i>保 存</button></div></div></div></form></div><div class="layui-fluid" style="margin-top:-18px;"><table id="tb_goods" class="layui-table" lay-filter="tb_goods" style="margin-top:-5px;"></table></div></div><script src="/static/asset/js/layui/layui.js"></script><script src="/static/asset/js/project/seckillGoodsOperate.js"></script></body></html> ③、实现增加秒杀商品 seckillGoodsOperate.js: layui.define(()=>{let table=layui.tablelet laydate = layui.laydatelet $=layui.jquerylet layer=layui.layer// 读取普通商品table.render({elem: 'tb_goods',height: 500,url: '/goods/queryAll' //数据接口,page: true //开启分页,parseData(res){ //res 即为原始返回的数据return {"code": res.code===200?0:1, //解析接口状态"msg": res.message, //解析提示文本"count": res.total, //解析数据长度"data": res.data //解析数据列表};},//用于对分页请求的参数：page、limit重新设定名称request: {pageName: 'page' //页码的参数名称，默认：page,limitName: 'rows' //每页数据量的参数名，默认：limit},cols: [[ //表头// 全选按钮{field: '', type:"checkbox"},{field: 'gid', title: '商品编号', width:80},{field: 'goodsName', title: '商品名字'},{field: 'goodsTitle', title: '商品标题'},{field: 'goodsDetail', title: '商品详情'},{field: 'goodsPrice', title: '商品价格', sort: true},{field: 'goodsStock', title: '商品库存', sort: true}]]});// 构建时间选择器//执行一个laydate实例laydate.render({elem: 'dt', //指定元素type: "datetime",range: "~"});$("btn_save").click(()=>{// 获取时间let val=$("dt").val()if(!val){layer.msg("请选择时间")return}// 解析时间2022-2-2 ~2022-5-2let startDate=new Date(val.split("~")[0]).getTime()let endDate=new Date(val.split("~")[1]).getTime()// 获得选中的普通商品,获取选中行的数据let rows= table.checkStatus('tb_goods').data; //idTest 即为基础参数 id 对应的值if(!rows||rows.length===0){layer.msg("请选择数据")return}layer.prompt(function(value, index, elem){// 修改每个商品的数量rows.forEach(e=>{e.goodsStock=value})let data={startDate,endDate,goods:rows}// 访问后台的秒杀商品的接口$.ajax({url: "/seckillGoods/add",contentType:'application/json',data: JSON.stringify(data),datatype:"json",//返回类型type:"post",success(res){parent.seckill_reload()layer.closeAll()parent.layer.closeAll()layer.msg(res.message)} })});})}) ④、展示结果 增加成功： 三、秒杀商品的操作 1、后端操作秒杀单个商品详情 ①、mapper层 SeckillGoodsMapper： Map<String,Object> querySeckillGoodsById(Long id); mapper.xml文件：SeckillGoodsMapper.xml <select id="querySeckillGoodsById" resultType="map">select sg.id,sg.goods_id,sg.seckill_price,sg.stock_count,sg.start_date,sg.end_date,g.goods_img,g.goods_title,g.goods_detail,g.goods_name,(casewhen current_timestamp < sg.start_date then 0when (current_timestamp between sg.start_date and sg.end_date) then 1when current_timestamp > sg.end_date then 2end) goods_statusfrom t_goods g,t_seckill_goods sgwhere g.gid = sg.goods_idand sg.id = {0}</select> ②、service层 ISeckillGoodsService： Map<String,Object> querySeckillGoodsById(Long id); SeckillGoodsServiceImpl： @Overridepublic Map<String, Object> querySeckillGoodsById(Long id) {return seckillGoodsMapper.querySeckillGoodsById(id);} ③、controller层：SeckillGoodsController package com.example.seckill.controller;import com.example.seckill.service.ISeckillGoodsService;import com.example.seckill.util.response.ResponseResult;import com.example.seckill.vo.SeckillGoodsVo;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.;import org.springframework.web.servlet.ModelAndView;import java.util.List;/ <p> 秒杀商品信息表 前端控制器 </p> @author lv @since 2022-03-19/@Controller@RequestMapping("/seckillGoods")public class SeckillGoodsController {@Autowiredprivate ISeckillGoodsService seckillGoodsService;// 返回json@ResponseBody@RequestMapping("/queryAll")public ResponseResult<List<SeckillGoodsVo>> queryAll(){return seckillGoodsService.queryAll();}@ResponseBody@RequestMapping("/add")public ResponseResult<List<SeckillGoodsVo>> add(@RequestBody SeckillGoodsVo seckillGoodsVo){return seckillGoodsService.addGoods(seckillGoodsVo);}// 正常跳转界面@RequestMapping("/query/{id}")public ModelAndView querySeckillGoodsById(@PathVariable("id") Long id) {ModelAndView mv = new ModelAndView("/goods/goodsSeckill");mv.addObject("goods", seckillGoodsService.querySeckillGoodsById(id));return mv;} } 2、前端展示 ①、在goodsList.js增加列的操作 {field: '', title: '操作', width: 140,templet: function (d) {return <div><a class="layui-btn layui-btn-xs layui-btn-danger">删除</a><a href="/seckillGoods/query/${d.id}" class="layui-btn layui-btn-xs layui-btn-normal">秒杀</a></div>;} } ②、添加秒杀详情界面 ：goodsSkill.ftl <!DOCTYPE html><html lang="en"><head><include "../common/head.ftl"/></head><body><table style="position: absolute;top:-10px;" class="layui-table" border="1" cellpadding="0" cellspacing="0"><tr><td style="width:120px;">商品图片</td><td><img src="${goods['goods_img']}" alt=""></td></tr><tr><td>商品名称</td><td>${goods['goods_name']}</td></tr><tr><td>商品标题</td><td>${goods['goods_title']}</td></tr><tr><td>商品价格</td><td>${goods['seckill_price']}</td></tr><tr><td>开始时间</td><td><div style="position: relative;${(goods['goods_status']==1)?string('top:10px;','')}">${goods['start_date']?string("yyyy-MM-dd HH:mm:ss")}-${goods['end_date']?string("yyyy-MM-dd HH:mm:ss")}<if goods['goods_status']==0>活动未开始<elseif goods['goods_status']==1>活动热卖中<div style="position:relative;top:-10px;float:right;"><input type="hidden" id="goodsId" value="${goods['goods_id']}" name="goodsId"/><button class="layui-btn" id="buy">立即抢购</button></div><else>活动已结束</if></div></td></tr></table><script src="/static/asset/js/project/goodsSeckill.js"></script></body></html> ③、实现：goodsSkill.js let layer, form, $;layui.define(() => {layer = layui.layerform = layui.form$ = layui.jquery$('buy').click(() => {$.ajax({url: '/seckillOrder/addOrder',data: {goodsId: $('goodsId').val()},dataType: 'json',type: 'post',async: false,success: function (rs) {if (rs.code === 200)layer.msg(rs.message)elselayer.msg(rs.message)} })});}) ④、展示效果 点击秒杀： 3、后端操作秒杀抢购功能 ①、导入雪花id工具包：SnowFlake package com.example.seckill.util;@SuppressWarnings("all")public class SnowFlake {/ 起始的时间戳/private final static long START_STMP = 1480166465631L;/ 每一部分占用的位数/private final static long SEQUENCE_BIT = 12; //序列号占用的位数private final static long MACHINE_BIT = 5; //机器标识占用的位数private final static long DATACENTER_BIT = 5;//数据中心占用的位数/ 每一部分的最大值/private final static long MAX_DATACENTER_NUM = -1L ^ (-1L << DATACENTER_BIT);private final static long MAX_MACHINE_NUM = -1L ^ (-1L << MACHINE_BIT);private final static long MAX_SEQUENCE = -1L ^ (-1L << SEQUENCE_BIT);/ 每一部分向左的位移/private final static long MACHINE_LEFT = SEQUENCE_BIT;private final static long DATACENTER_LEFT = SEQUENCE_BIT + MACHINE_BIT;private final static long TIMESTMP_LEFT = DATACENTER_LEFT + DATACENTER_BIT;private long datacenterId; //数据中心private long machineId; //机器标识private long sequence = 0L; //序列号private long lastStmp = -1L;//上一次时间戳public SnowFlake(long datacenterId, long machineId) {if (datacenterId > MAX_DATACENTER_NUM || datacenterId < 0) {throw new IllegalArgumentException("datacenterId can't be greater than MAX_DATACENTER_NUM or less than 0");}if (machineId > MAX_MACHINE_NUM || machineId < 0) {throw new IllegalArgumentException("machineId can't be greater than MAX_MACHINE_NUM or less than 0");}this.datacenterId = datacenterId;this.machineId = machineId;}public static void main(String[] args) {SnowFlake snowFlake = new SnowFlake(2, 3);long start = System.currentTimeMillis();for (int i = 0; i < 1000000; i++) {System.out.println(snowFlake.nextId());}System.out.println(System.currentTimeMillis() - start);}/ 产生下一个ID @return/public synchronized long nextId() {long currStmp = getNewstmp();if (currStmp < lastStmp) {throw new RuntimeException("Clock moved backwards. Refusing to generate id");}if (currStmp == lastStmp) {//相同毫秒内，序列号自增sequence = (sequence + 1) & MAX_SEQUENCE;//同一毫秒的序列数已经达到最大if (sequence == 0L) {currStmp = getNextMill();} } else {//不同毫秒内，序列号置为0sequence = 0L;}lastStmp = currStmp;return (currStmp - START_STMP) << TIMESTMP_LEFT //时间戳部分| datacenterId << DATACENTER_LEFT //数据中心部分| machineId << MACHINE_LEFT //机器标识部分| sequence; //序列号部分}private long getNextMill() {long mill = getNewstmp();while (mill <= lastStmp) {mill = getNewstmp();}return mill;}private long getNewstmp() {return System.currentTimeMillis();} } ②、service层 ISeckillOrderService ： package com.example.seckill.service;import com.example.seckill.pojo.SeckillOrder;import com.baomidou.mybatisplus.extension.service.IService;import com.example.seckill.pojo.User;import com.example.seckill.util.response.ResponseResult;/ <p> 秒杀订单信息表 服务类 </p> @author lv @since 2022-03-19/public interface ISeckillOrderService extends IService<SeckillOrder> {ResponseResult<?> addOrder(Long goodsId, User user);} SeckillOrderServiceImpl ： package com.example.seckill.service.impl;import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;import com.example.seckill.exception.BusinessException;import com.example.seckill.mapper.GoodsMapper;import com.example.seckill.mapper.OrderMapper;import com.example.seckill.mapper.SeckillGoodsMapper;import com.example.seckill.pojo.;import com.example.seckill.mapper.SeckillOrderMapper;import com.example.seckill.service.ISeckillOrderService;import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;import com.example.seckill.util.SnowFlake;import com.example.seckill.util.response.ResponseResult;import com.example.seckill.util.response.ResponseResultCode;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;/ <p> 秒杀订单信息表 服务实现类 </p> @author lv @since 2022-03-19/@Servicepublic class SeckillOrderServiceImpl extends ServiceImpl<SeckillOrderMapper, SeckillOrder> implements ISeckillOrderService {@Autowiredprivate SeckillGoodsMapper seckillGoodsMapper;@Autowiredprivate GoodsMapper goodsMapper;@Autowiredprivate OrderMapper orderMapper;@Transactional(rollbackFor = Exception.class)@Overridepublic ResponseResult<?> addOrder(Long goodsId, User user) {// 下单前判断库存数SeckillGoods goods = seckillGoodsMapper.selectOne(new QueryWrapper<SeckillGoods>().eq("goods_id", goodsId));if (goods == null) {throw new BusinessException(ResponseResultCode.SECKILL_ORDER_ERROR);}if (goods.getStockCount() < 1) {throw new BusinessException(ResponseResultCode.SECKILL_ORDER_ERROR);}// 限购SeckillOrder one = this.getOne(new QueryWrapper<SeckillOrder>().eq("user_id", user.getId()).eq("goods_id", goodsId));if (one != null) {throw new BusinessException(ResponseResultCode.SECKILL_ORDER_EXISTS_ERROR);}// 库存减一int i = seckillGoodsMapper.update(null, new UpdateWrapper<SeckillGoods>().eq("goods_id", goodsId).setSql("stock_count=stock_count-1"));// 根据商品编号查询对应的商品（拿名字）Goods goodsInfo = goodsMapper.selectOne(new QueryWrapper<Goods>().eq("gid", goodsId));// 生成订单//生成雪花idSnowFlake snowFlake = new SnowFlake(5, 9);long id = snowFlake.nextId();//生成对应的订单Order normalOrder = new Order();normalOrder.setOid(id);normalOrder.setUserId(user.getId());normalOrder.setGoodsId(goodsId);normalOrder.setGoodsName(goodsInfo.getGoodsName());normalOrder.setGoodsCount(1);normalOrder.setGoodsPrice(goods.getSeckillPrice());orderMapper.insert(normalOrder);//生成秒杀订单SeckillOrder seckillOrder = new SeckillOrder();seckillOrder.setUserId(user.getId());seckillOrder.setOrderId(normalOrder.getOid());seckillOrder.setGoodsId(goodsId);this.save(seckillOrder);return ResponseResult.success();} } ③、controller层 SeckillOrderController ： package com.example.seckill.controller;import com.example.seckill.pojo.User;import com.example.seckill.service.ISeckillOrderService;import com.example.seckill.util.response.ResponseResult;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;/ <p> 秒杀订单信息表 前端控制器 </p> @author lv @since 2022-03-19/@RestController@RequestMapping("/seckillOrder")public class SeckillOrderController {@Autowiredprivate ISeckillOrderService seckillOrderService;@RequestMapping("/addOrder")public ResponseResult<?> addOrder(Long goodsId, User user){return seckillOrderService.addOrder(goodsId,user);} } ④、呈现结果 限购次数： 本期内容结束，下期内容更完善！！！！！！！！！！！！！！！！！！！！！1 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_60389087/article/details/123601288。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...统简介 2.2 栅格参数 2.3 栅格系统使用 2.4 不同屏幕设置不同宽度 2.5 列偏移 2.6 列位置移动 3 排版 3.1 标题 3.2 突出显示 3.3 对齐 3.4 改变大小写 3.5 引用 3.6 列表 4 代码 4.1 内联代码 4.2 用户输入 4.3 代码块 4.3 变量 4.4 程序输出 5 表格 5.1 基本 5.2 条纹状表格 5.3 带边框的表格 5.4 鼠标悬停 5.5 紧缩表格 5.6 状态类 5.7 响应式表格 6 表单 6.1 基本实例 6.2 内联表单 6.3 水平排列的表单 6.4 表单控件 输入框 文本域 多选和单选框 下拉列表 静态内容 帮助文字 校验状态 添加额外的图标 控件尺寸 7 按钮 7.1 可作为按钮使用的标签或元素 7.2 预定义样式 7.3 尺寸 7.4 激活状态 7.5 禁用状态 8 图片 8.1 响应式图片 8.2 图片形状 9 辅助类 9.1 文本颜色 9.2 背景色 9.3 三角符号 9.4 浮动 9.5 让内容块居中 9.6 清除浮动 9.7 显示或隐藏内容 9.10 图片替换 10 响应式工具 10.1 不同视口下隐藏显示 10.2 打印类 1 BootStrap基础 1 什么是BootStrap 由Twitter的设计师Mark Otto和Jacob Thornton合作开发，是一个CSS/HTML框架简洁、直观、强悍的前端开发框架，让web开发更迅速、简单。 2 BootStrap的版本 BootStrap2 BootStrap3 BootStrap4 3 BootStrap 下载 用于生产环境的Bootstrap Bootstrap Less 源码Bootstrap Sass 源码 4 CDN服务 <!-- 新 Bootstrap 核心 CSS 文件 --><link rel="stylesheet" href="http://cdn.bootcss.com/bootstrap/3.3.5/css/bootstrap.min.css"><!-- 可选的Bootstrap主题文件（一般不用引入） --><link rel="stylesheet" href="http://cdn.bootcss.com/bootstrap/3.3.5/css/bootstrap-theme.min.css"><!-- jQuery文件。务必在bootstrap.min.js 之前引入 --><script src="http://cdn.bootcss.com/jquery/1.11.3/jquery.min.js"></script><!-- 最新的 Bootstrap 核心 JavaScript 文件 --><script src="http://cdn.bootcss.com/bootstrap/3.3.5/js/bootstrap.min.js"></script> 5 目录结构 生产环境版 bootstrap/├── css/│ ├── bootstrap.css│ ├── bootstrap.css.map│ ├── bootstrap.min.css│ ├── bootstrap-theme.css│ ├── bootstrap-theme.css.map│ └── bootstrap-theme.min.css├── js/│ ├── bootstrap.js│ └── bootstrap.min.js└── fonts/├── glyphicons-halflings-regular.eot├── glyphicons-halflings-regular.svg├── glyphicons-halflings-regular.ttf├── glyphicons-halflings-regular.woff└── glyphicons-halflings-regular.woff2 6 基本模板 <!DOCTYPE html><html lang="zh-CN"><head><!-- 上述3个meta标签必须放在最前面，任何其他内容都必须跟随其后！ --><title>Bootstrap 101 Template</title><!-- Bootstrap --><link href="css/bootstrap.min.css" rel="stylesheet"><!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries --><!-- WARNING: Respond.js doesn't work if you view the page via file:// --><!--[if lt IE 9]><script src="//cdn.bootcss.com/html5shiv/3.7.2/html5shiv.min.js"></script><script src="//cdn.bootcss.com/respond.js/1.4.2/respond.min.js"></script><![endif]--></head><body><h1>你好，世界！</h1><!-- jQuery (necessary for Bootstrap's JavaScript plugins) --><script src="//cdn.bootcss.com/jquery/1.11.3/jquery.min.js"></script><!-- Include all compiled plugins (below), or include individual files as needed --><script src="js/bootstrap.min.js"></script></body></html> 7 浏览器支持 手机浏览器 ——- Chrome Firefox Safari Android Supported Supported N/A iOS Supported Supported Supported 桌面浏览器 ——— Chrome Firefox Internet Explorer Opera Safari Mac Supported Supported N/A Supported Supported Windows Supported Supported Supported Supported Not supported 8 浏览器兼容 让 IE8 支持H5新标签 页面中引入respond.js <!-- 注意： 页面必须通过服务器访问 --><script src="https://cdn.bootcss.com/respond.js/1.4.2/respond.min.js"></script> IE兼容模式 页面中添加如下代码 <meta http-equiv="X-UA-Compatible" content="IE=edge"> 国产浏览器切换webkit内核 页面中添加如下代码 <meta name="renderer" content="webkit"> 2 BootStrap布局 1 概览 1.1 移动设备优先 为了确保适当的绘制和触屏缩放，需要在 <head> 之中添加 viewport 元数据标签。 在移动设备浏览器上，通过为视口（viewport）设置 meta 属性为 user-scalable=no 可以禁用其缩放（zooming）功能。这样禁用缩放功能后，用户只能滚动屏幕，就能让你的网站看上去更像原生应用的感觉。注意，这种方式我们并不推荐所有网站使用，还是要看你自己的情况而定！ 1.2 Normalize.css BootStrap内置了Normalize.css 1.3 布局容器 Bootstrap 需要为页面内容和栅格系统包裹一个 .container 容器。我们提供了两个作此用处的类。注意，由于 padding 等属性的原因，这两种 容器类不能互相嵌套。 .container 类用于固定宽度并支持响应式布局的容器。 <div class="container">...</div> .container-fluid 类用于 100% 宽度，占据全部视口（viewport）的容器。 <div class="container-fluid">...</div> 2 栅格系统 Bootstrap 提供了一套响应式、移动设备优先的流式栅格系统，随着屏幕或视口（viewport）尺寸的增加，系统会自动分为最多12列 2.1 栅格系统简介 栅格系统用于通过一系列的行（row）与列（column）的组合来创建页面布局，你的内容就可以放入这些创建好的布局中。下面就介绍一下 Bootstrap 栅格系统的工作原理： “行（row）”必须包含在 .container （固定宽度）或 .container-fluid （100% 宽度）中，以便为其赋予合适的排列（aligment）和内补（padding）。 通过“行（row）”在水平方向创建一组“列（column）”。 你的内容应当放置于“列（column）”内，并且，只有“列（column）”可以作为行（row）”的直接子元素。 类似 .row 和 .col-xs-4 这种预定义的类，可以用来快速创建栅格布局。Bootstrap 源码中定义的 mixin 也可以用来创建语义化的布局。 通过为“列（column）”设置 padding 属性，从而创建列与列之间的间隔（gutter）。通过为 .row 元素设置负值 margin 从而抵消掉为 .container 元素设置的 padding，也就间接为“行（row）”所包含的“列（column）”抵消掉了padding。 负值的 margin就是下面的示例为什么是向外突出的原因。在栅格列中的内容排成一行。 栅格系统中的列是通过指定1到12的值来表示其跨越的范围。例如，三个等宽的列可以使用三个 .col-xs-4 来创建。 如果一“行（row）”中包含了的“列（column）”大于 12，多余的“列（column）”所在的元素将被作为一个整体另起一行排列。 栅格类适用于与屏幕宽度大于或等于分界点大小的设备 ， 并且针对小屏幕设备覆盖栅格类。 因此，在元素上应用任何 .col-md-栅格类适用于与屏幕宽度大于或等于分界点大小的设备 ， 并且针对小屏幕设备覆盖栅格类。 因此，在元素上应用任何 .col-lg-不存在， 也影响大屏幕设备。 2.2 栅格参数 超小屏幕 手机 (<768px) 小屏幕 平板 (≥768px) 中等屏幕 桌面显示器 (≥992px) 大屏幕 大桌面显示器 (≥1200px) .container 最大宽度 None （自动） 750px 970px 1170px 类前缀 .col-xs- .col-sm- .col-md- .col-lg- 最大列（column）宽 自动 ~62px ~81px ~97px 2.3 栅格系统使用 使用单一的一组 .col-md- 栅格类，就可以创建一个基本的栅格系统，在手机和平板设备上一开始是堆叠在一起的（超小屏幕到小屏幕这一范围），在桌面（中等）屏幕设备上变为水平排列。所有“列（column）必须放在 ” .row 内。 <div class="row"><div class="col-md-1">.col-md-1</div><div class="col-md-1">.col-md-1</div><div class="col-md-1">.col-md-1</div><div class="col-md-1">.col-md-1</div><div class="col-md-1">.col-md-1</div><div class="col-md-1">.col-md-1</div><div class="col-md-1">.col-md-1</div><div class="col-md-1">.col-md-1</div><div class="col-md-1">.col-md-1</div><div class="col-md-1">.col-md-1</div><div class="col-md-1">.col-md-1</div><div class="col-md-1">.col-md-1</div></div><div class="row"><div class="col-md-8">.col-md-8</div><div class="col-md-4">.col-md-4</div></div><div class="row"><div class="col-md-4">.col-md-4</div><div class="col-md-4">.col-md-4</div><div class="col-md-4">.col-md-4</div></div><div class="row"><div class="col-md-6">.col-md-6</div><div class="col-md-6">.col-md-6</div></div> 2.4 不同屏幕设置不同宽度 <div class="row"><div class="col-xs-12 col-sm-6 col-md-8">.col-xs-12 .col-sm-6 .col-md-8</div><div class="col-xs-6 col-md-4">.col-xs-6 .col-md-4</div></div><div class="row"><div class="col-xs-6 col-sm-4">.col-xs-6 .col-sm-4</div><div class="col-xs-6 col-sm-4">.col-xs-6 .col-sm-4</div><!-- Optional: clear the XS cols if their content doesn't match in height --><div class="clearfix visible-xs-block"></div><div class="col-xs-6 col-sm-4">.col-xs-6 .col-sm-4</div></div> 2.5 列偏移 使用 .col-md-offset- 类可以将列向右侧偏移。这些类实际是通过使用 选择器为当前元素增加了左侧的边距（margin）。例如，.col-md-offset-4 类将 .col-md-4 元素向右侧偏移了4个列（column）的宽度。 <div class="row"><div class="col-md-4">.col-md-4</div><div class="col-md-4 col-md-offset-4">.col-md-4 .col-md-offset-4</div></div><div class="row"><div class="col-md-3 col-md-offset-3">.col-md-3 .col-md-offset-3</div><div class="col-md-3 col-md-offset-3">.col-md-3 .col-md-offset-3</div></div><div class="row"><div class="col-md-6 col-md-offset-3">.col-md-6 .col-md-offset-3</div></div> 2.6 列位置移动 通过使用 .col-md-push- 和 .col-md-pull- 类就可以很容易的改变列（column）的顺序。 <div class="row"><div class="col-md-9 col-md-push-3">.col-md-9 .col-md-push-3</div><div class="col-md-3 col-md-pull-9">.col-md-3 .col-md-pull-9</div></div> 3 排版 3.1 标题 HTML 中的所有标题标签，<h1> 到 <h6> 均可使用。另外，还提供了 .h1 到 .h6 类，为的是给内联（inline）属性的文本赋予标题的样式。 <h1>h1. Bootstrap heading</h1><h2>h2. Bootstrap heading</h2><h3>h3. Bootstrap heading</h3><h4>h4. Bootstrap heading</h4><h5>h5. Bootstrap heading</h5><h6>h6. Bootstrap heading</h6> 在标题内还可以包含 <small> 标签或赋予 .small 类的元素，可以用来标记副标题。 <h1>h1. Bootstrap heading <small>Secondary text</small></h1><h2>h2. Bootstrap heading <small>Secondary text</small></h2><h3>h3. Bootstrap heading <small>Secondary text</small></h3><h4>h4. Bootstrap heading <small>Secondary text</small></h4><h5>h5. Bootstrap heading <small>Secondary text</small></h5><h6>h6. Bootstrap heading <small>Secondary text</small></h6> 3.2 突出显示 通过添加 .lead 类可以让段落突出显示。 <p class="lead">...</p> 3.3 对齐 <p class="text-left">Left aligned text.</p><p class="text-center">Center aligned text.</p><p class="text-right">Right aligned text.</p><p class="text-justify">Justified text.</p><p class="text-nowrap">No wrap text.</p> 3.4 改变大小写 <p class="text-lowercase">Lowercased text.</p><p class="text-uppercase">Uppercased text.</p><p class="text-capitalize">Capitalized text.</p> 3.5 引用 <blockquote><p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer posuere erat a ante.</p></blockquote><blockquote><p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer posuere erat a ante.</p><footer>Someone famous in <cite title="Source Title">Source Title</cite></footer></blockquote><blockquote class="blockquote-reverse">...</blockquote> 3.6 列表 无样式列表 <ul class="list-unstyled"><li>...</li></ul> 内联列表 <ul class="list-inline"><li>...</li></ul> 水平排列的内联列表 <dl class="dl-horizontal"><dt>...</dt><dd>...</dd></dl> 4 代码 4.1 内联代码 通过 <code> 标签包裹内联样式的代码片段。 For example, <code><section></code> should be wrapped as inline. 4.2 用户输入 通过 <kbd> 标签标记用户通过键盘输入的内容。 To switch directories, type <kbd>cd</kbd> followed by the name of the directory.<br>To edit settings, press <kbd><kbd>ctrl</kbd> + <kbd>,</kbd></kbd> 4.3 代码块 多行代码可以使用 <pre> 标签。为了正确的展示代码，注意将尖括号做转义处理。 <pre><p>Sample text here...</p></pre> 还可以使用 .pre-scrollable 类，其作用是设置 max-height 为 350px ，并在垂直方向展示滚动条。 4.3 变量 通过 <var> 标签标记变量。 <var>y</var> = <var>m</var><var>x</var> + <var>b</var> 4.4 程序输出 通过 <samp> 标签来标记程序输出的内容。 <samp>This text is meant to be treated as sample output from a computer program.</samp> 5 表格 5.1 基本 为任意 <table> 标签添加 .table 类可以为其赋予基本的样式 <table class="table">...</table> 5.2 条纹状表格 <table class="table table-striped">...</table> 5.3 带边框的表格 <table class="table table-bordered">...</table> 5.4 鼠标悬停 <table class="table table-hover">...</table> 5.5 紧缩表格 <table class="table table-condensed">...</table> 5.6 状态类 通过这些状态类可以为行或单元格设置颜色。 Class 描述 .active 鼠标悬停在行或单元格上时所设置的颜色 .success 标识成功或积极的动作 .info 标识普通的提示信息或动作 .warning 标识警告或需要用户注意 .danger 标识危险或潜在的带来负面影响的动作 5.7 响应式表格 将任何 .table 元素包裹在 .table-responsive 元素内，即可创建响应式表格，其会在小屏幕设备上（小于768px）水平滚动。当屏幕大于 768px 宽度时，水平滚动条消失。 6 表单 6.1 基本实例 单独的表单控件会被自动赋予一些全局样式。所有设置了 .form-control 类的 <input>、<textarea> 和 <select> 元素都将被默认设置宽度属性为 width: 100%;。 将 label 元素和前面提到的控件包裹在 .form-group 中可以获得最好的排列。 <form><div class="form-group"><label for="exampleInputEmail1">Email address</label><input type="email" class="form-control" id="exampleInputEmail1" placeholder="Email"></div><div class="form-group"><label for="exampleInputPassword1">Password</label><input type="password" class="form-control" id="exampleInputPassword1" placeholder="Password"></div><div class="form-group"><label for="exampleInputFile">File input</label><input type="file" id="exampleInputFile"><p class="help-block">Example block-level help text here.</p></div><div class="checkbox"><label><input type="checkbox"> Check me out</label></div><button type="submit" class="btn btn-default">Submit</button></form> 6.2 内联表单 为 <form> 元素添加 .form-inline 类可使其内容左对齐并且表现为 inline-block 级别的控件。只适用于视口（viewport）至少在 768px 宽度时（视口宽度再小的话就会使表单折叠） 6.3 水平排列的表单 通过为表单添加 .form-horizontal 类，并联合使用 Bootstrap 预置的栅格类，可以将 label 标签和控件组水平并排布局。这样做将改变 .form-group 的行为，使其表现为栅格系统中的行（row），因此就无需再额外添加 .row 了 <form class="form-horizontal"><div class="form-group"><label for="inputEmail3" class="col-sm-2 control-label">Email</label><div class="col-sm-10"><input type="email" class="form-control" id="inputEmail3" placeholder="Email"></div></div><div class="form-group"><label for="inputPassword3" class="col-sm-2 control-label">Password</label><div class="col-sm-10"><input type="password" class="form-control" id="inputPassword3" placeholder="Password"></div></div><div class="form-group"><div class="col-sm-offset-2 col-sm-10"><div class="checkbox"><label><input type="checkbox"> Remember me</label></div></div></div><div class="form-group"><div class="col-sm-offset-2 col-sm-10"><button type="submit" class="btn btn-default">Sign in</button></div></div></form> 6.4 表单控件 输入框 包括大部分表单控件、文本输入域控件，还支持所有 HTML5 类型的输入控件： text、password、datetime、datetime-local、date、month、time、week、number、email、url、search、tel 和 color。 只有正确设置了 type 属性的输入控件才能被赋予正确的样式。 文本域 支持多行文本的表单控件。可根据需要改变 rows 属性。 多选和单选框 默认样式 <div class="checkbox"><label><input type="checkbox" value="">Option one is this and that—be sure to include why it's great</label></div><div class="checkbox disabled"><label><input type="checkbox" value="" disabled>Option two is disabled</label></div><div class="radio"><label><input type="radio" name="optionsRadios" id="optionsRadios1" value="option1" checked>Option one is this and that—be sure to include why it's great</label></div><div class="radio"><label><input type="radio" name="optionsRadios" id="optionsRadios2" value="option2">Option two can be something else and selecting it will deselect option one</label></div><div class="radio disabled"><label><input type="radio" name="optionsRadios" id="optionsRadios3" value="option3" disabled>Option three is disabled</label></div> 内联单选和多选框 <label class="checkbox-inline"><input type="checkbox" id="inlineCheckbox1" value="option1"> 1</label><label class="checkbox-inline"><input type="checkbox" id="inlineCheckbox2" value="option2"> 2</label><label class="checkbox-inline"><input type="checkbox" id="inlineCheckbox3" value="option3"> 3</label><label class="radio-inline"><input type="radio" name="inlineRadioOptions" id="inlineRadio1" value="option1"> 1</label><label class="radio-inline"><input type="radio" name="inlineRadioOptions" id="inlineRadio2" value="option2"> 2</label><label class="radio-inline"><input type="radio" name="inlineRadioOptions" id="inlineRadio3" value="option3"> 3</label> 不带文本的Checkbox 和 radio <label><input type="checkbox" id="blankCheckbox" value="option1" aria-label="..."></label></div><div class="radio"><label><input type="radio" name="blankRadio" id="blankRadio1" value="option1" aria-label="..."></label></div> 下拉列表 <select class="form-control"><option>1</option><option>2</option><option>3</option><option>4</option><option>5</option></select> 静态内容 如果需要在表单中将一行纯文本和 label 元素放置于同一行，为 <p> 元素添加 .form-control-static 类即可 <form class="form-horizontal"><div class="form-group"><label class="col-sm-2 control-label">Email</label><div class="col-sm-10"><p class="form-control-static">email@example.com</p></div></div><div class="form-group"><label for="inputPassword" class="col-sm-2 control-label">Password</label><div class="col-sm-10"><input type="password" class="form-control" id="inputPassword" placeholder="Password"></div></div></form> 帮助文字 <label class="sr-only" for="inputHelpBlock">Input with help text</label><input type="text" id="inputHelpBlock" class="form-control" aria-describedby="helpBlock">...<span id="helpBlock" class="help-block">A block of help text that breaks onto a new line and may extend beyond one line.</span> 校验状态 Bootstrap 对表单控件的校验状态，如 error、warning 和 success 状态，都定义了样式。使用时，添加 .has-warning、.has-error或 .has-success 类到这些控件的父元素即可。任何包含在此元素之内的 .control-label、.form-control 和 .help-block 元素都将接受这些校验状态的样式。 <div class="form-group has-success"><label class="control-label" for="inputSuccess1">Input with success</label><input type="text" class="form-control" id="inputSuccess1" aria-describedby="helpBlock2"><span id="helpBlock2" class="help-block">A block of help text that breaks onto a new line and may extend beyond one line.</span></div><div class="form-group has-warning"><label class="control-label" for="inputWarning1">Input with warning</label><input type="text" class="form-control" id="inputWarning1"></div><div class="form-group has-error"><label class="control-label" for="inputError1">Input with error</label><input type="text" class="form-control" id="inputError1"></div><div class="has-success"><div class="checkbox"><label><input type="checkbox" id="checkboxSuccess" value="option1">Checkbox with success</label></div></div><div class="has-warning"><div class="checkbox"><label><input type="checkbox" id="checkboxWarning" value="option1">Checkbox with warning</label></div></div><div class="has-error"><div class="checkbox"><label><input type="checkbox" id="checkboxError" value="option1">Checkbox with error</label></div></div> 添加额外的图标 你还可以针对校验状态为输入框添加额外的图标。只需设置相应的 .has-feedback 类并添加正确的图标即可 <div class="form-group has-success has-feedback"><label class="control-label" for="inputSuccess2">Input with success</label><input type="text" class="form-control" id="inputSuccess2" aria-describedby="inputSuccess2Status"><span class="glyphicon glyphicon-ok form-control-feedback" aria-hidden="true"></span><span id="inputSuccess2Status" class="sr-only">(success)</span></div> 控件尺寸 通过 .input-lg 类似的类可以为控件设置高度，通过 .col-lg- 类似的类可以为控件设置宽度。 高度尺寸 创建大一些或小一些的表单控件以匹配按钮尺寸 <input class="form-control input-lg" type="text" placeholder=".input-lg"><input class="form-control" type="text" placeholder="Default input"><input class="form-control input-sm" type="text" placeholder=".input-sm"><select class="form-control input-lg">...</select><select class="form-control">...</select><select class="form-control input-sm">...</select> 水平排列的表单组的尺寸 通过添加 .form-group-lg 或 .form-group-sm 类，为 .form-horizontal 包裹的 label 元素和表单控件快速设置尺寸。 <form class="form-horizontal"><div class="form-group form-group-lg"><label class="col-sm-2 control-label" for="formGroupInputLarge">Large label</label><div class="col-sm-10"><input class="form-control" type="text" id="formGroupInputLarge" placeholder="Large input"></div></div><div class="form-group form-group-sm"><label class="col-sm-2 control-label" for="formGroupInputSmall">Small label</label><div class="col-sm-10"><input class="form-control" type="text" id="formGroupInputSmall" placeholder="Small input"></div></div></form> 7 按钮 7.1 可作为按钮使用的标签或元素 为 <a>、<button> 或 <input> 元素添加按钮类（button class）即可使用 Bootstrap 提供的样式 <a class="btn btn-default" href="" role="button">Link</a><button class="btn btn-default" type="submit">Button</button><input class="btn btn-default" type="button" value="Input"><input class="btn btn-default" type="submit" value="Submit"> 7.2 预定义样式 <!-- Standard button --><button type="button" class="btn btn-default">（默认样式）Default</button><!-- Provides extra visual weight and identifies the primary action in a set of buttons --><button type="button" class="btn btn-primary">（首选项）Primary</button><!-- Indicates a successful or positive action --><button type="button" class="btn btn-success">（成功）Success</button><!-- Contextual button for informational alert messages --><button type="button" class="btn btn-info">（一般信息）Info</button><!-- Indicates caution should be taken with this action --><button type="button" class="btn btn-warning">（警告）Warning</button><!-- Indicates a dangerous or potentially negative action --><button type="button" class="btn btn-danger">（危险）Danger</button><!-- Deemphasize a button by making it look like a link while maintaining button behavior --><button type="button" class="btn btn-link">（链接）Link</button> 7.3 尺寸 需要让按钮具有不同尺寸吗？使用 .btn-lg、.btn-sm 或 .btn-xs 就可以获得不同尺寸的按钮。 通过给按钮添加 .btn-block 类可以将其拉伸至父元素100%的宽度，而且按钮也变为了块级（block）元素。 7.4 激活状态 添加 .active 类 7.5 禁用状态 为 <button> 元素添加 disabled 属性，使其表现出禁用状态。 为基于 <a> 元素创建的按钮添加 .disabled 类。 8 图片 8.1 响应式图片 在 Bootstrap 版本 3 中，通过为图片添加 .img-responsive 类可以让图片支持响应式布局。其实质是为图片设置了 max-width: 100%;、 height: auto; 和 display: block; 属性，从而让图片在其父元素中更好的缩放。 如果需要让使用了 .img-responsive 类的图片水平居中，请使用 .center-block 类，不要用 .text-center <img src="..." class="img-responsive" alt="Responsive image"> 8.2 图片形状 <img src="..." alt="..." class="img-rounded"><img src="..." alt="..." class="img-circle"><img src="..." alt="..." class="img-thumbnail"> 9 辅助类 9.1 文本颜色 <p class="text-muted">...</p><p class="text-primary">...</p><p class="text-success">...</p><p class="text-info">...</p><p class="text-warning">...</p><p class="text-danger">...</p> 9.2 背景色 <p class="bg-primary">...</p><p class="bg-success">...</p><p class="bg-info">...</p><p class="bg-warning">...</p><p class="bg-danger">...</p> 9.3 三角符号 <span class="caret"></span> 9.4 浮动 <div class="pull-left">...</div><div class="pull-right">...</div> 9.5 让内容块居中 <div class="center-block">...</div> 9.6 清除浮动 通过为父元素添加 .clearfix 类可以很容易地清除浮动（float） <!-- Usage as a class --><div class="clearfix">...</div> 9.7 显示或隐藏内容 <div class="show">...</div><div class="hidden">...</div> 9.10 图片替换 使用 .text-hide 类或对应的 mixin 可以用来将元素的文本内容替换为一张背景图。 <h1 class="text-hide">Custom heading</h1> 10 响应式工具 10.1 不同视口下隐藏显示 .visible-xs- .visible-sm- .visible-md- .visible-lg- .hidden-xs .hidden-sm .hidden-md .hidden-lg.visible--block .visible--inline .visible--inline-block 10.2 打印类 .visible-print-block.visible-print-inline.visible-print-inline-block.hidden-print 打印机下隐藏 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_67155975/article/details/123351126。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...联想，考虑恶意的上游开发者，如何巧妙（或者说，处心积虑）地将问题引入，并在当前的软件供应链生态体系中，造成远比表面上看起来要深远得多的影响（参见：《深挖CVE-2018-10933（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。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...保科技废弃物污染治理前端模板”是一款专注于环保科技领域的专业网站模板，设计风格大气且简洁，适用于废弃物污染治理、水体污染等相关企业或项目展示。模板以突出环保科技为核心，强调废弃物污染治理的前沿技术和实践成果。用户可便捷下载并应用于前端开发中，快速构建展现环保理念与科技成果的专业化网站平台。 点我下载 文件大小：15.19 MB 您将下载一个资源包，该资源包内部文件的目录结构如下： 本网站提供模板下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...置和大量的编程工作，开发者只需引用并调用该插件，即可快速为网站添加独特的背景滚动动画。无论是全屏背景还是局部容器背景，都能够运用这一特效实现仿佛三维空间般的视觉变换。同时，其兼容性和易用性也使得这款插件成为网页设计师和前端开发者的理想选择，以较低的成本打造出令人印象深刻的沉浸式网页浏览环境。 点我下载 文件大小：130.98 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...网页交互体验而设计的前端开发工具。它巧妙地结合了jQuery强大的JavaScript库与CSS3的先进动画特性，赋予超链接在鼠标悬停时丰富的动态效果。当用户将鼠标光标停留在超链接文字上时，该插件能够即时触发多达6种独特且炫酷的动画特效，从而吸引用户的注意力并增强页面的视觉吸引力。这些特效不仅限于简单的颜色变化或阴影处理，而是通过精妙的动画过渡实现深层次的视觉反馈，例如旋转、缩放、位移以及渐变等效果。开发者可以便捷地集成此插件到项目中，轻松定制符合网站风格的超链接悬停表现，为用户带来新颖且流畅的互动感受，同时也有助于提升整体网站的专业性和用户体验。 点我下载 文件大小：229.91 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...能。通过集成此插件，开发者能够轻松实现页面中任意DOM元素的动态旋转效果，只需简单配置即可赋予用户以鼠标拖拽操作自由调整元素角度的能力。无论是创建3D视图、图像编辑界面，还是提升UI/UX的创新互动体验，Propeller.js都能发挥关键作用。它将鼠标移动事件与DOM元素的旋转属性相结合，使得在网页上进行实时拖动旋转动画成为可能，大大增强了网页的动态表现力和用户参与度。这款插件适用于多种应用场景，简化了复杂动画效果的开发过程，并确保了良好的浏览器兼容性，让前端开发人员能够更专注于创意设计与用户体验优化。 点我下载 文件大小：150.40 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...s是一款轻量级且易于使用的JavaScriptDOM元素放大缩小特效插件。它专为前端开发者设计，无需依赖jQuery或其他外部库，仅凭纯JavaScript技术实现图片和其他HTML元素的动态放大和缩小功能。此插件的强大之处在于其灵活性，用户只需在目标元素上添加特定的类，如"zoomable"或"zoomerang-target"，即可激活其交互性。当用户点击这样的元素时，Zoomerang.js会让元素以中心对齐的方式放大，提供清晰的细节查看体验。放大后的视图可以在用户交互下保持聚焦，直到再次点击，这时元素会恢复到原始大小和位置，操作流畅自然。这种功能特别适合在产品展示、地图导航或者需要高精度查看的网页场景中使用，提升了用户体验和信息的可访问性。由于其简洁的实现方式，它对于性能影响较小，非常适合对性能有较高要求的现代Web应用。 点我下载 文件大小：22.78 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...er.js是一个专为开发者设计的jQuery插件，旨在以美观且易于理解的方式展示JSON格式的数据。这款插件不仅能够将复杂的、难以阅读的JSON数据进行格式化，使其变得整洁有序，还提供了强大的语法高亮功能，使得关键信息一目了然。用户可以通过简单的点击操作来展开或收起JSON中的各个节点，极大地提升了用户体验和工作效率。无论是用于调试API返回的数据，还是展示从服务器获取的复杂配置信息，jQuery.json-viewer.js都能提供清晰直观的视图。其轻量级的设计确保了加载速度的同时不会影响页面性能，非常适合在各种项目中集成使用。通过使用这款插件，开发者可以节省大量时间，专注于解决更核心的问题，而不是被繁琐的数据格式问题所困扰。无论你是前端开发者，还是需要处理JSON数据的专业人士，jQuery.json-viewer.js都是你不可或缺的好帮手。 点我下载 文件大小：44.64 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...是一款专门针对Web前端开发的动画工具，它基于jQuery库构建，设计灵感来源于Google提出的MaterialDesign设计理念。该插件的核心功能在于实现元素在页面上的分层与动态过渡效果，允许开发者轻松地为网页中的任何元素（如：卡片、菜单、列表项等）设置从起始点A平滑过渡到目标点B的动画效果。通过这款插件，可以增强用户界面的互动性和视觉吸引力，遵循MaterialDesign规范中强调的空间关系和运动规律，使元素在空间变换时具备自然且符合物理规则的动效。开发者只需简单配置，即可让页面元素的出现、消失或位置改变拥有如同原生MaterialDesign应用般的高质量动画表现，从而提升整体用户体验和UI的专业感。 点我下载 文件大小：229.86 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...egment.js，开发者可以轻松地将任何select控件转化为具有流畅切换效果和精美视觉表现的分段按钮，实现与iOS系统的无缝对接。这款插件极大地简化了跨平台UI统一化的工作流程，让网页设计师和前端开发人员能够专注于创造更佳的用户体验，同时保持页面风格与时俱进。只需简单的调用与配置，即使是非iOS平台的访问者也能享受到类似Apple设备的高端、一体化的界面交互效果。 点我下载 文件大小：42.88 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...emock是一款专为开发者和设计师打造的jQuery插件，它能够轻松在浏览器中模拟生成各种桌面设备和移动设备模型。通过这款插件，用户可以灵活模拟iPhone、iPad、Android手机和平板、桌面显示器等多种设备类型，并且可以根据实际需求精确设置每个设备模型的屏幕尺寸大小以及颜色模式，实现高度逼真的界面预览效果。在进行响应式网站或应用开发时，devicemock提供了一种便捷的方式来测试不同设备下的布局适应性和视觉表现，无需实际拥有所有类型的物理设备。只需简单调用该插件及其相关API，即可快速渲染出目标设备的框架结构，极大地提高了设计调试阶段的工作效率与准确性。总之，devicemock作为一个实用的jQuery工具，是前端开发过程中不可或缺的一部分，帮助开发者确保项目在多种设备环境下都能呈现出理想的用户体验。 点我下载 文件大小：156.16 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...类型的灵活选择功能。开发者可以根据实际应用场景，配置该插件以实现单向或双向的选择模式，满足不同业务需求。例如，在预订酒店或者机票场景下，用户可以选择入住和离店的日期范围；而在设置周期性任务时，则可以选定一周中的特定日期范围或者指定月份内的某段时间。凭借其丰富的定制选项和高度的灵活性，jQuery多类型范围选择器插件极大地简化了开发流程，提升了Web应用的数据录入效率与用户友好度，是前端开发者构建复杂筛选条件的理想选择之一。 点我下载 文件大小：55.75 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...pDown是一款专为前端开发者设计的jQuery插件，旨在提升网页表单中下拉菜单的视觉体验。这款插件的主要功能在于美化select元素，使其不仅在功能上更加完善，同时在视觉上也更具吸引力。通过ImageDropDown，你可以轻松地为select下拉菜单中的每一个选项添加小图标，这不仅能帮助用户更快地识别不同的选项，还能显著增强页面的整体美观度。此外，该插件提供了丰富的定制化选项，允许开发者调整下拉菜单的样式和布局，以适应不同网站的设计风格。无论是简洁现代的扁平化设计，还是复古经典的风格，ImageDropDown都能灵活应对，确保下拉菜单与整个页面和谐统一。使用此插件，你无需编写复杂的CSS代码或JavaScript脚本，即可实现专业的视觉效果，大大简化了前端开发的工作流程。总之，ImageDropDown是那些希望在不牺牲用户体验的前提下提升网页美观度的开发者的理想选择。无论是个人项目还是企业级应用，这款插件都能提供强大的支持，帮助你的网站脱颖而出。 点我下载 文件大小：176.16 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...用的API，能够帮助开发者在网页中快速创建出引人注目的数字或文字动画特效。它特别适用于那些需要展示实时更新数据（如网站访问量、销售额等）的场景，可以生动形象地模拟数据从初始值到目标值的累积过程，提升用户体验和页面视觉冲击力。开发者只需将该插件与jQuery库一同引入项目中，并对目标元素进行简单的配置调用，即可实现平滑且高度自定义的滚动动画效果。无论是整数递增、小数点后精确变化，还是带有缓动效果的动画过渡，jQuery.numscroll.js都能够轻松应对，大大简化了复杂动画效果的开发流程，是前端开发人员构建丰富互动体验的理想工具。 点我下载 文件大小：43.08 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。