js构造函数和原型对象，ES6中的class，四种继承方式

一、构造函数

1.构造函数是一种特殊的函数，主要用来初始化对象
2.使用场景

常见的{...}语法允许创建一个对象。可以通过构造函数来快速创建多个类似的对象。

 const Peppa = {name: '佩奇',age: 6,sex: '女'}const George = {name: '乔治',age: 3,sex: '男'}const Mum = {name: '佩奇妈妈',age: 30,sex: '女'}const Dad = {name: '佩奇爸爸',age: 32,sex: '男'}function Pig(name, age, sex) {this,name = name;this.age = age;this.sex = sex;}const Peppa1 = new Pig('佩奇', 6, '女')const George1 = new Pig('乔治', 3, '男')const Mum1 = new Pig('佩奇妈妈', 30, '女')const Dad1 = new Pig('佩奇爸爸', 32, '男')

构造函数在技术上是常规函数

命名以大写字母开头。

通过new关键字来执行。

3.创建构造

使用new关键字调用函数的行为被称为实例化

实例化构造函数时没有参数可以省略（）

构造函数内部无需写return，返回值即为新创建的对象

构造函数内部的return返回的值无效，所以不需要写return

new Object()和new Date()也是实例化的构造函数

4.实例化执行过程！

a.创建新空对象，

b.构造函数this指向新对象，

c.执行构造函数代码，修改this，添加新的属性，

d.返回新对象

5.实例成员和静态成员

实例成员：通过构造函数创建的对象称为实例对象，实例对象中的属性和方法称为实例成员（实例属性和实例方法）

为构造函数传入参数，创建结构相同但值不同的对象

构造函数创建的实例对象彼此独立互不影响

    //实例对象上的属性和方法属于实例成员function Pig(name) {this.name = name;}const peiqi = new Pig('佩奇')const qiaozhi = new Pig('乔治')peiqi.name = '小猪佩奇' //实例属性peiqi.sayHi = () => { //实例方法console.log('hi~');}console.log('peiqi', peiqi);console.log('qiaozhi', qiaozhi);

构造函数的属性和方法称为静态成员（静态属性和静态成员）

静态成员只能通过构造函数来访问

静态方法中的this指向构造函数

    //构造函数上的属性和方法称为静态成员function Pig(name) {this.name = name;}Pig.eyes = 2 //静态属性console.log('Pig.eyes', Pig.eyes);Pig.sayHi = function() { //静态方法console.log(this);}console.log('Pig.sayHi', Pig.sayHi);

6.内置构造函数

引用类型Object,Array,RegExp,Date等

包装类型String,Number,Boolean等

Object的静态方法Object.keys(),Object.values(),Object.assign()

    const o = {name: '佩奇',age: 6}//获取所有属性名，返回数组console.log(Object.keys(o));//获取所有属性值，返回数组console.log(Object.values(o));//拷贝对象const oo = {}Object.assign(oo, o)//给对象添加属性console.log(oo);Object.assign(o, {gender: '女'})console.log(o);

二、编程思想

1.面向过程

分析解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候再一个一个的依次调用。按照分析好了的步骤，按照步骤解决问题。

优点：性能比面向对象高，适合和硬件联系很紧密的东西

缺点：没有面向对象易维护、易复用、易扩展

2.面向对象

把食物分解成一个一个对象，然后由对象之间分工与工作。

以功能来划分问题，而不是步骤。

面向对象编程（oop）:在面向对象程序开发中，每一个对象都是功能中心，具有明确分工。面向对象编程具有灵活，代码可复用，容易维护和开发的优点，更适合多人合作的大型软件项目。

优点：封装性，继承性，多态性。可以使系统更加灵活，更加易于维护

缺点：性能比面向过程低

js实现面向对象需要借助构造函数来实现

构造函数实例创建的对象彼此独立，互不影响。

构造函数存在浪费性能的问题
    function Star(name, age, sex) {this.name = name;this.age = age;this.sing = function() {console.log('sing');};}const ldh = new Star('ldh', 55)const zxy = new Star('zxy', 58)console.log(ldh.sing === zxy.sing); //false

三、原型

原型可以解决构造函数里浪费内存的问题。

1.目的：能够利用原型对象实现方法共享

构造函数通过原型分配的函数是所有对象所共享的。

js规定：每一个构造函数都有一个prototype属性，指向另一个对象，我们也称为原型对象。

这个对象可以挂载函数，对象实例化不会多次创建原型上函数，节约内存。

我们可以把那些不变的方法，直接定义在prototype对象上，这样所有对象的实例就可以共享这些方法。

    function Star(name, age, sex) {//公共属性写到构造函数里this.name = name;this.age = age;}const ldh = new Star('ldh', 55)const zxy = new Star('zxy', 58)console.log('Star.prototype', Star.prototype)//构造函数有一个prototype属性，公共方法写到原型对象身上Star.prototype.sing = function() {console.log('唱歌');};ldh.sing()zxy.sing()console.log(ldh.sing === zxy.sing); //true

构造函数和原型对象中的this都指向实例化对象。

    let a;let b;function Star(name, age, sex) {a = this;this.name = name;this.age = age;}const ldh = new Star('ldh', 55)console.log(a === ldh);//true//构造函数里面的 this就是实例对象Star.prototype.sing = function() {b = this;console.log('唱歌');};ldh.sing()console.log(b === ldh);//true
    //自己定义数组扩展方法max,min,sumArray.prototype.max = function() {//原型函数里面的this指向实例化对象arrreturn Math.max(...this)}Array.prototype.min = function() {//原型函数里面的this指向实例化对象arrreturn Math.min(...this)}Array.prototype.sum = function() {//原型函数里面的this指向实例化对象arrreturn this.reduce((sum, item) => sum + item, 0)}const arr = [1, 2, 3]console.log(arr.max());console.log(arr.min());console.log(arr.sum());
2.constructor属性

每个原型对象里面都有一个constructor属性，该属性指向该原型对象的构造函数.

    function Star() {}const ldh = new Star()console.log(Star.prototype.constructor === Star);//true

 如果有多个对象的方法，我们可以给原型对象采取对象形式赋值。

但是这样就会覆盖构造函数原型对象原来的内容，修改后原型对象constructor就不再指向当前构造函数了，我们需要在修改后的原型对象中，添加一个constructor指向原来的构造函数。

    function Star() {}// Star.prototype.sing = function() {//     console.log('唱歌');// }// Star.prototype.dance = function() {//         console.log('跳');//     }Star.prototype = {//重新指回创造这个原型对象的构造函数constructor: Star,sing: function() {console.log('唱歌');},dance: function() {console.log('跳');}}console.log(Star.prototype);

 

3.原型

在每个对象都会有一个__proto_指向构造函数的prototype原型对象，之所以我们可以使用构造函数prototype原型对象的属性和方法，就是因为对象有__proto_原型存在。

__protp_是js非标准属性，[prototype]和__protp_意义相同

用来表明当前实例对象指向哪个原型对象prototype

__protp_对象原型里面也有一个constructor属性，指向创建该实例对象的构造函数。

    function Star() {}const ldh = new Star()//每一个构造函数都有一个prototype属性，指向另一个对象，我们也称为原型对象。console.log('Star.prototype', Star.prototype);//每个原型对象里面都有一个constructor属性，该属性指向该原型对象的构造函数.console.log(Star.prototype.constructor === Star);//true//ldh.__proto__ 指向该构造函数的原型对象console.log(ldh.__proto__ === Star.prototype); //true//对象原型里面也有constructor属性,指向创建该实例对象的构造函数。console.log(ldh.__proto__.constructor === Star); //true

总结

prototype是原型对象，构造函数都自动有原型对象

construvtor属性在原型对象（prototype）和对象原型(__proto__)上都有 ,指向创建实例对象/原型的构造函数。

__proto__属性在实例对象里面，指向原型对象。

4.原型继承

继承是面向对象编程的另一个特征，通过继承进一步提升代码封装的程度，js中大多是借助原型对象实现继承的特性。

    const Person = {head: 1,eyes: 2}function Woman() {}//Woman通过原型来继承PersonWoman.prototype = Person//指回原来的构造函数Woman.prototype.constructor = Womanconst red = new Woman()console.log('red', red);

问题：同时使用了同一个对象，根据引用类型的特点，他们指向同一个对象，修改一个都会改变。

const Person = {head: 1,eyes: 2}function Woman() {}Woman.prototype = PersonWoman.prototype.constructor = WomanWoman.prototype.sing = function() {console.log('唱歌');}const red = new Woman()console.log('red', red);function Man() {}Man.prototype = PersonMan.prototype.constructor = Manconst bob = new Man()console.log('bob', bob);

    function Person() {this.head = 1this.eyes = 2}function Woman() {}//父构造函数（父类）子构造函数（子类） 子类的原型=new父类Woman.prototype = new Person()Woman.prototype.constructor = WomanWoman.prototype.sing = function() {console.log('唱歌');}const red = new Woman()console.log('red', red);function Man() {}Man.prototype = new Person()Man.prototype.constructor = Manconst bob = new Man()console.log('bob', bob);

5.原型链

基于原型对象的继承使得不同的构造函数的原型对象关联在一起，并且这种关联的关系是一种链状结构，我们将原型对象的链状结构关系称为原型链。

    function Person() {}const ldh = new Person()console.log(ldh.__proto__);console.log(Person.prototype);console.log(ldh.__proto__ === Person.prototype); //trueconsole.log(Person.prototype.__proto__ === Object.prototype); //trueconsole.log(Object.prototype.__proto__); //nullconsole.log(ldh instanceof Person); //trueconsole.log(ldh instanceof Object); //true

原型链查找规则

a.当访问一个对象的属性时，首先查找这个对象自身有没有该属性。

b.如果没有就查找它的原型，也就是__proto__指向的prototype原型对象。

c.如果没有找到就查找原型对象的原型。

d.依次类推一直找到Object为之。

e.__proto__对象原型的意义就在于为对象成员查找机制提供一个方向。

f.可以使用instanceof运算符用于检测构造函数的prototype属性是否出现在某个实例对象的原型链上。

四、示例

1.封装模态框 

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title>
</head><body><button id="delete">删除</button><button id="login">登录</button>
</body>
</html><script>//构造函数封装模态框function Modal(title = '', message = '') {// 1.创建div标签// 2.给div标签添加类名modal// 3.modal盒子内部填充2个div并且修改文字内容this.modalBox = document.createElement('div')this.modalBox.className = "modal"this.modalBox.innerHTML = `<div class="header">${title}<i>x</i></div><div class="main">${message}</div>`}//挂载open方法Modal.prototype.open = function() {//准备open显示时先判断 页面中有没有modal,有就移除，没有就添加const box = document.querySelector('.modal')box && box.remove()document.body.append(this.modalBox)//等盒子显示出来,就可以绑定关闭事件this.modalBox.querySelector('i').addEventListener('click', () => {//需要用箭头函数，这个this指向实例对象this.close()})}Modal.prototype.close = function() {this.modalBox.remove()}document.querySelector('#delete').addEventListener('click', () => {const del = new Modal('温馨提示', '你没有权限删除')del.open()})document.querySelector('#login').addEventListener('click', () => {const login = new Modal('友情提示', '你没有注册')login.open()})
</script>
 2.选项卡（构造函数写法）

 

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title><style>#box div,#box1 div {width: 200px;height: 50px;background-color: palegreen;display: none;}.active {background-color: palevioletred;}#box .current,#box1 .current {display: block;background-color: palegreen;}</style>
</head><body><div id="box"><section><button class="active">娱乐</button><button>体育</button><button>教育</button></section><section><div class="current">娱乐</div><div>体育</div><div>教育</div></section></div><hr><div id="box1"><section><button class="active">娱乐</button><button>体育</button><button>教育</button></section><section><div class="current">娱乐</div><div>体育</div><div>教育</div></section></div>
</body>
<script>//构造函数function Tab(ele, type) {this.ele = document.querySelector(ele); // {ele:"元素"}this.btns = this.ele.children[0].childrenthis.divs = this.ele.children[1].childrenthis.changeColor(type); // 函数的调用  "click"}Tab.prototype.changeColor = function(type) {// this: 指向的是实例化对象的thisfor (let i = 0; i < this.btns.length; i++) {this.btns[i].addEventListener(type, () => {console.log(2);// this.btns[i]：i就可以用了，this.btns[i]代表具体点击的元素for (var j = 0; j < this.btns.length; j++) {this.btns[j].classList.remove("active")this.divs[j].classList.remove("current")}this.btns[i].classList.add("active")this.divs[i].classList.add("current")})}}// 创建对象let tab1 = new Tab("#box", "click")let tab2 = new Tab("#box1", "mouseover")</script></html>

 

五、class类

从ES6开始，JavaScript引入了类（class）的语法，可以用来创建构造函数。这种语法更加简洁和清晰。

    //写法一： 构造函数function Person(name, age) {this.name = name;   this.age = age;   }Person.prototype.say = function () {console.log("呵呵");}let p1 = new Person("zs", 10)let p2 = new Person("zs", 10)console.log(p1);console.log(p1 == p2); // false//写法二： class类的写法class Person {constructor(name, age) {this.name = name;this.age = age;}//相当于挂载在了构造函数的原型对象上， Person.prototype.say = function(){}say() {  console.log("呵呵");}}let p1 = new Person("zs", 10)let p2 = new Person("zs", 10)console.log(p1);console.log(p1 == p2); // false
选项卡（class类写法） 

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Document</title><style>#box div,#box1 div {width: 200px;height: 50px;background-color: palegreen;display: none;}.active {background-color: palevioletred;}#box .current,#box1 .current {display: block;background-color: palegreen;}</style>
</head><body><div id="box"><section><button class="active">娱乐</button><button>体育</button><button>教育</button></section><section><div class="current">娱乐</div><div>体育</div><div>教育</div></section></div><hr><div id="box1"><section><button class="active">娱乐</button><button>体育</button><button>教育</button></section><section><div class="current">娱乐</div><div>体育</div><div>教育</div></section></div>
</body>
<script>// class类class Tab {constructor(ele, type) {this.ele = document.querySelector(ele); // {ele:"元素"}this.btns = this.ele.children[0].childrenthis.divs = this.ele.children[1].childrenthis.changeColor(type); // 函数的调用  "click"}changeColor(type) {for (let i = 0; i < this.btns.length; i++) {this.btns[i].addEventListener(type, () => {console.log(2);// this.btns[i]：i就可以用了，this.btns[i]代表具体点击的元素for (var j = 0; j < this.btns.length; j++) {this.btns[j].classList.remove("active")this.divs[j].classList.remove("current")}this.btns[i].classList.add("active")this.divs[i].classList.add("current")})}}}let tab1 = new Tab("#box", "click")let tab2 = new Tab("#box1", "mouseover")
</script></html>

 六、继承

      发生在两个构造函数之间，如果说A构造函数使用了B构造函数中的属性或者方法，A继承自B，B就属于父类，A属于子类

      可以把构造函数当成一个类

1.借用父类构造函数继承

优点：可以继承父类构造函数内的属性和方法 ​ 缺点：不可以继承父类原型对象上的属性和方法

    // 定义父类构造函数function Father(name, age) {this.name = name;this.age = age;}// 父类原型方法Father.prototype.sayHello = function() {console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);};// 定义子类构造函数function Child(name, age, grade) {// 借用父类构造函数Father.call(this, name, age); // 通过call()借用父类构造函数this.grade = grade; // 子类特有的属性}// 使用示例const child = new Child('Alice', 10, 5); //{name: 'Alice', age: 10, grade: 5}child.sayHello(); //  child.sayHello is not a function
2.原型链继承

优点：可以继承父类原型对象上的属性和方法 ​ 缺点：不可以继承父类构造函数内的属性和方法

 

    // Father类function Father(money) {this.money = money}Father.prototype.smoke = function() {console.log("吸烟");}// Son类function Son(name, money) {this.name = name;}Son.prototype = new Father(); // 会覆盖掉Son构造函数原型对象的constructor属性Son.prototype.constructor = Son; // 手动加上Son.prototype.study = function() {console.log("study");}var f = new Father(10000)var s = new Son("小张")console.log(s);s.smoke();
 3.组合继承

优点：实现函数复用，保证每个实例之间的属性不会相互影响。 ​

缺点：使用了两次继承，代码书写繁琐，还出现了constructor的覆盖

    // Father类function Father(money) {this.money = money}Father.prototype.smoke = function() {console.log("吸烟");}// Son类function Son(name, money) {this.name = name;Father.call(this, money); // 继承父类属性的关键}Son.prototype = new Father(); // 继承父类原型对象方法的关键Son.prototype.study = function() {console.log("study");}var s = new Son("小张", 1000); // 即继承了属性console.log(s);s.smoke(); // 又继承了父类原型对象上的方法
4.es6继承：extends super

优点：1.既可以继承父类的属性，也可以继承父类原型对象上的方法 ​ 2.写法简单

 

    class Father {constructor(money) {this.money = money;}smoke() {console.log('抽大烟');}}class Son extends Father {constructor(name, money) {super(money);this.name = name;}}// extends来继承父类的属性和方法，必须还需要使用 super()访问父类的构造器（构造器的代码走一遍）var son = new Son("小明", 10000)console.log(son);son.smoke()// 既可以继承父类的属性，也可以继承父类原型对象上的方法

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/458078.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

利用 Puppeteer-Extra 插件提升自动化测试和网页抓取的效率与隐蔽性

利用 Puppeteer-Extra 插件提升自动化测试和网页抓取的效率与隐蔽性

在当今的互联网环境中&#xff0c;自动化测试和网页抓取已经成为许多开发者和数据分析师的日常工作之一。Puppeteer 是一个广泛使用的 Node 库&#xff0c;它提供了一个高级 API 来通过 DevTools 协议控制 Chrome 或 Chromium。然而&#xff0c;在某些场景下&#xff0c;我们可…
阅读更多...
获取微博排行榜PHP

获取微博排行榜PHP

获取微博排行榜是获取微博html页面的数据&#xff0c;而非直接调用微博后端接口获取 PHP实现 class WeiBoHotSearchService extends BaseService {/*** 微博热搜缓存过期时间* var int*/protected int $expireTime 600;/*** 微博热搜URL* var string*/protected string $doma…
阅读更多...
centos-LAMP搭建与配置（论坛网站）

centos-LAMP搭建与配置（论坛网站）

文章目录 LAMP简介搭建LAMP环境安装apache&#xff08;httpd&#xff09;安装mysql安装PHP安装php-mysql安装phpwind LAMP简介 LAMP是指一组通常一起使用来运行动态网站或者服务器的自由软件名称首字母缩写&#xff1a;Linux操作系统&#xff0c;网页服务器Apache&#xff0c;…
阅读更多...
HTML+CSS实现超酷超炫的3D立方体相册

HTML+CSS实现超酷超炫的3D立方体相册

效果演示 HTML和CSS实现一个简单的3D立方体加载动画的相册。它使用了HTML来构建立方体的结构&#xff0c;并通过CSS来添加样式和动画效果。 HTML <div class"loader3d"><div class"cube"><div class"face"><img src&qu…
阅读更多...
多线程——线程安全的集合类

多线程——线程安全的集合类

目录 前言 一、多线程环境使用 ArrayList 1.进行加锁 2.使用 SynchronizedList 类 3.使用 CopyOnWriteArrayList 类 二、多线程环境使用队列 1.进行加锁 2.使用阻塞队列 三、多线程环境使用哈希表 1.Hashtable 2.ConcurrentHashMap &#xff08;1&#xff09;缩小锁…
阅读更多...
计算机毕业设计 | springboot+vue凌云在线阅读平台 线上读书系统(附源码)

计算机毕业设计 | springboot+vue凌云在线阅读平台 线上读书系统(附源码)

1&#xff0c;绪论 随着社会和网络技术的发展&#xff0c;网络小说成为人们茶钱饭后的休闲方式&#xff0c;但是现在很多网络小说的网站都是收费的&#xff0c;高额的收费制度是很多人接受不了的&#xff0c;另外就是很多小说网站都会有大量的弹窗和广告&#xff0c;这极大的影…
阅读更多...
医学数据分析中的偏特征图可视化

医学数据分析中的偏特征图可视化

在医学领域&#xff0c;我们经常需要处理复杂的数据模型&#xff0c;探索特征与目标变量之间的关系。偏特征图(Partial Dependence Plot, PDP)是一种强大的可视化技术&#xff0c;可以帮助我们更好地理解模型的行为。通过这种图形&#xff0c;我们可以直观地观察每个特征对模型…
阅读更多...
零一万物新模型Yi-Lightning：超越GPT-4o

零一万物新模型Yi-Lightning：超越GPT-4o

10月16日&#xff0c;零一万物发布了最新的旗舰模型Yi-Lightning&#xff08;闪电&#xff09;&#xff0c;在中国大模型中首度超越 GPT-4o。它在国际权威盲测榜单 LMSYS 上取得了显著成绩&#xff0c;超越了硅谷知名 OpenAI 的 GPT-4o-2024-05-13 和 Anthropic Claude 3.5 Son…
阅读更多...
关于iPhone 16 Pro评测视频评论区特征的多维度分析

关于iPhone 16 Pro评测视频评论区特征的多维度分析

1.项目背景 随着智能手机的迅速发展&#xff0c;消费者在选择新设备时越来越依赖于网络评价和用户反馈&#xff0c;B站作为中国领先的视频分享平台&#xff0c;聚集了大量科技评测内容&#xff0c;其中UP主的评论区成为用户讨论和交流的重要场所&#xff0c;特别是在iPhone 16…
阅读更多...
基于SSM的汽车客运站管理系统【附源码】

基于SSM的汽车客运站管理系统【附源码】

基于SSM的汽车客运站管理系统&#xff08;源码L文说明文档&#xff09; 目录 4 系统设计 4.1 设计原则 4.2 功能结构设计 4.3 数据库设计 4.3.1 数据库概念设计 4.3.2 数据库物理设计 5 系统实现 5.1 管理员功能实现 5.1.1 管理员信息 5.1.2 车…
阅读更多...
【程序员的逆袭】：在失业的阴影下寻找光明

【程序员的逆袭】：在失业的阴影下寻找光明

故事摘要 在失业的阴霾中&#xff0c;一位程序员如何通过外包项目重燃希望之火&#xff1f;这个故事讲述了他的谋生手段&#xff0c;如何在压力之下&#xff0c;通过信息差赚取生活所需。 要点 信息的力量&#xff1a;赚钱的关键在于信息差&#xff0c;而非单纯的体力或脑力…
阅读更多...
【轻量级聊天应用】Vocechat本地服务器部署结合cpolar异地即时通讯

【轻量级聊天应用】Vocechat本地服务器部署结合cpolar异地即时通讯

文章目录 前言1. 拉取Vocechat2. 运行Vocechat3. 本地局域网访问4. 群晖安装Cpolar5. 配置公网地址6. 公网访问小结 7. 固定公网地址 前言 本文主要介绍如何在本地群晖NAS搭建一个自己的聊天服务Vocechat&#xff0c;并结合内网穿透工具实现使用任意浏览器远程访问进行智能聊天…
阅读更多...
iTerm2 保持SSH远程连接

iTerm2 保持SSH远程连接

1、保持SSH远程连接的稳定&#xff0c;防止因闲置时间过长而断开连接 When idle, send ASCII code 35 every 60 seconds每60秒 输入# 2、客户端设置保持活动 设置客户端每隔60秒发送一次保活信号&#xff0c;总共尝试3次。 vim ~/.ssh/configHost *ServerAliveInterval 60…
阅读更多...
python csv库

python csv库

python csv库 水一水又是一篇&#xff0c;乐 读取 import csv # 打开 CSV 文件 with open(example.csv, moder, newline) as file: csv_reader csv.reader(file) # 读取文件头&#xff08;可选&#xff09; headers next(csv_reader) print(f"Headers: {heade…
阅读更多...
w001基于SpringBoot的在线拍卖系统

w001基于SpringBoot的在线拍卖系统

&#x1f64a;作者简介&#xff1a;多年一线开发工作经验&#xff0c;原创团队&#xff0c;分享技术代码帮助学生学习&#xff0c;独立完成自己的网站项目。 代码可以查看文章末尾⬇️联系方式获取&#xff0c;记得注明来意哦~&#x1f339;赠送计算机毕业设计600个选题excel文…
阅读更多...
gateway 整合 spring security oauth2

gateway 整合 spring security oauth2

微服务分布式认证授权方案 在分布式授权系统中&#xff0c;授权服务要独立成一个模块做统一授权&#xff0c;无论客户端是浏览器&#xff0c;app或者第三方&#xff0c;都会在授权服务中获取权限&#xff0c;并通过网关访问资源 OAuth2的四种授权模式 授权码模式 授权服务器将授…
阅读更多...
【密码学】全同态加密张量运算库解读 —— TenSEAL

【密码学】全同态加密张量运算库解读 —— TenSEAL

项目地址&#xff1a;https://github.com/OpenMined/TenSEAL 论文地址&#xff1a;https://arxiv.org/pdf/2104.03152v2 TenSEAL 是一个在微软 SEAL 基础上构建的用于对张量进行同态加密操作的开源Python库&#xff0c;用于在保持数据加密的状态下进行机器学习和数据分析。 Ten…
阅读更多...
CSS基础—网页布局（重点！）

CSS基础—网页布局（重点！）

1、两列布局 &#xff08;1&#xff09;概念 经典两列布局是指一种网页布局方式&#xff0c;其中一列宽度固定&#xff0c;另一列宽度自适应。‌ 这种布局方式在网页设计中非常常见&#xff0c;因为它能够提供良好的视觉效果和用户体验。 如图所示&#xff1a; 页面顶部放置一…
阅读更多...
网络搜索引擎Shodan（4）

网络搜索引擎Shodan（4）

声明&#xff1a;学习视频来自b站up主 泷羽sec&#xff0c;如涉及侵权马上删除文章 声明&#xff1a;本文主要用作技术分享&#xff0c;所有内容仅供参考。任何使用或依赖于本文信息所造成的法律后果均与本人无关。请读者自行判断风险&#xff0c;并遵循相关法律法规。 感谢泷…
阅读更多...
【JavaEE】【多线程】volatile,wait/notify

【JavaEE】【多线程】volatile,wait/notify

目录 一、volatile关键字1.1 内存可见性1.2 volatile解决内存可见性问题 二、wait和notify2.1 wait2.2 notify2.3 使用例子2.3.1 例子12.3.2 例子二 一、volatile关键字 volatile可以保证内存可见性&#xff0c;只能修饰变量。 1.1 内存可见性 在前面介绍线程不安全原因时介…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023