原型链污染

news2024/9/22 23:30:56

目录

        前置知识

原型对象

prototype和__proto__的区别

原型链概念

原型链的继承

原型 链污染

原型链污染原理

javascript中可能会存在原型链污染的危险函数

原型链污染的实际应用

JavaScript中可以触发弹窗的函数

前置知识

原型对象

在JavaScript中，每个函数都有一个特殊的属性prototype，它指向一个对象，这个对象就是所谓的原型对象。原型对象是一个普通的JavaScript对象，它包含着一些属性和方法，这些属性和方法可以被该函数的所有实例共享。

当使用new操作符来创建一个实例对象时，实例对象会继承它所属的构造函数的原型对象中的属性和方法。实例对象可以通过原型链访问原型对象中的属性和方法。如果实例对象需要访问的属性或方法在自身上找不到，它就会沿着原型链向上查找，直到找到为止。

以下是一个简单的示例，演示了如何使用原型对象：

// 定义一个构造函数
function Person(name, age) {
  this.name = name;
  this.age = age;
}
​
// 在原型对象上定义一个方法
Person.prototype.sayHello = function() {
  console.log('Hello, my name is ' + this.name + ' and I am ' + this.age + ' years old.');
};
​
// 创建两个实例对象
var person1 = new Person('Alice', 25);
var person2 = new Person('Bob', 30);
​
// 调用实例对象上的方法
person1.sayHello(); // Hello, my name is Alice and I am 25 years old.
person2.sayHello(); // Hello, my name is Bob and I am 30 years old.
​
// 查看实例对象的原型
console.log(person1.__proto__ === Person.prototype); // true
console.log(person2.__proto__ === Person.prototype); // true
​
// 查看原型对象的构造函数
console.log(Person.prototype.constructor === Person); // true

prototype和__proto__的区别

在 JavaScript 中，每个对象都有一个 __proto__ 属性，它指向该对象的原型。原型是一个对象，也可以有自己的原型，这样就形成了一个原型链。同时，每个函数也有一个 prototype 属性，它是一个对象，当该函数作为构造函数创建实例时，实例对象的 __proto__ 属性会指向该构造函数的 prototype 属性，这样就可以实现属性和方法的继承。

下面是 prototype 和 __proto__ 的区别：

  1. prototype 属性是函数所独有的，而 __proto__ 属性是每个对象都有的。

  2. prototype 属性指向一个对象，它是用来存储属性和方法，这些属性和方法可以被该函数的实例对象所继承。而 __proto__ 属性指向该对象的原型，它是用来实现对象之间的继承。

下面是一些示例代码，可以帮助理解 prototype 和 __proto__：

// 定义一个构造函数
function Person(name, age) {
  this.name = name;
  this.age = age;
}
​
// 在 Person 的原型上定义一个方法
Person.prototype.sayHello = function() {
  console.log('Hello, my name is ' + this.name + '.');
}
​
// 创建一个 Person 实例对象
var person = new Person('Alice', 20);
​
// 输出实例对象的属性和方法
console.log(person.name);  // "Alice"
console.log(person.age);   // 20
person.sayHello();         // "Hello, my name is Alice."
​
// 输出 Person 和实例对象的 __proto__ 属性
console.log(Person.__proto__);     // [Function]
console.log(person.__proto__);    // Person { sayHello: [Function] }
​
// 输出 Person 和实例对象的 prototype 属性
console.log(Person.prototype);    // Person { sayHello: [Function] }
console.log(person.prototype);   // undefined

从上面的示例代码可以看出，prototype 属性被用于在函数的原型上定义方法和属性，而 __proto__ 属性被用于实现实例对象和构造函数之间的继承关系。

原型链概念

当创建一个 JavaScript 对象时，它都会有一个原型对象（也称为“proto”）。可以通过该对象来访问该对象的属性和方法。如果该对象本身没有定义某个属性或方法，那么 JavaScript 会在原型对象中查找，如果还没有找到，会继续查找原型对象的原型对象，直到找到 Object 的原型对象为止。

以下是一个简单的例子来演示原型链的概念：

// 定义一个构造函数
function Person(name, age) {
  this.name = name;
  this.age = age;
}
​
// 在构造函数的原型对象上定义一个方法
Person.prototype.sayHello = function() {
  console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
};
​
// 创建一个 Person 实例
const person1 = new Person('Alice', 25);
​
// 调用该实例的 sayHello 方法
person1.sayHello(); // 输出：Hello, my name is Alice and I am 25 years old.
​
// 查看该实例的原型对象
console.log(person1.__proto__); // 输出：{ sayHello: [Function] }
​
// 查看该实例的原型对象的原型对象
console.log(person1.__proto__.__proto__); // 输出：{ constructor: [Function: Object], ... }

在上面的例子中，定义了一个 Person 构造函数，该构造函数有两个属性 name 和 age，并在构造函数的原型对象上定义了一个方法 sayHello。然后，创建了一个 person1 实例，并调用了该实例的 sayHello 方法。当调用 person1.sayHello() 时，JavaScript 在该实例对象中查找该方法，但是它发现该对象本身没有定义该方法，因此它会查找该对象的原型对象，即 Person.prototype，在该原型对象中找到了该方法并执行。这就是原型链的概念。

原型链的继承

基于原型链的继承：

// 定义一个父类
function Animal(name) {
  this.name = name;
}
​
Animal.prototype.sayName = function() {
  console.log(this.name);
};
​
// 定义一个子类
function Dog(name, breed) {
  this.breed = breed;
  Animal.call(this, name); // 调用父类的构造函数来初始化属性
}
​
// 设置子类的原型继承自父类
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;
​
// 子类可以使用父类的方法和属性
var dog = new Dog('Tommy', 'Golden Retriever');
dog.sayName(); // "Tommy"
console.log(dog.breed); // "Golden Retriever"

基于对象的继承：

// 定义一个父对象
var animal = {
  name: '',
  sayName: function() {
    console.log(this.name);
  }
};
​
// 定义一个子对象
var dog = Object.create(animal);
dog.breed = '';
​
// 子对象可以使用父对象的方法和属性
dog.name = 'Tommy';
dog.breed = 'Golden Retriever';
dog.sayName(); // "Tommy"
console.log(dog.breed); // "Golden Retriever"

原型链污染

当在 JavaScript 中使用不可信的数据时，可能会导致原型链污染问题。以下是一个示例代码，演示了如何利用原型链污染来执行恶意代码：

// 从不受信任的数据创建一个 JavaScript 对象
const user = JSON.parse('{"__proto__": {"isAdmin": true}}');
​
// 恶意代码：修改所有对象的 toString 方法，以便执行任意的 JavaScript 代码
Object.prototype.toString = function() {
  if (this.isAdmin) {
    // 恶意代码：执行任意的 JavaScript 代码
    console.log('恶意代码：您的计算机已被攻陷！');
    // 恶意代码：发送您的敏感数据到黑客服务器
    console.log('恶意代码：正在发送您的银行卡信息和密码到黑客服务器！');
  }
  // 恶意代码：调用 toString 原始实现
  return '[object Object]';
};
​
// 在不知情的情况下，调用 toString 方法
console.log(user.toString()); // 输出：恶意代码：您的计算机已被攻陷！ 恶意代码：正在发送您的银行卡信息和密码到黑客服务器！ [object Object]

在上面的代码中，从一个不可信的数据源（例如一个恶意网站）解析出一个 JavaScript 对象 user，其中该对象的 __proto__ 属性被设置为一个新的原型对象，该原型对象有一个 isAdmin 属性，值为 true。接下来，在 Object.prototype 上修改了 toString 方法，以便执行任意的 JavaScript 代码。最后，调用 user.toString() 方法，JavaScript 沿着原型链查找该方法，并在 user 对象的原型对象中找到了它，导致恶意代码被执行。

因此，原型链污染是一种严重的安全问题，可能会导致代码执行任意的 JavaScript 代码。

原型链污染原理

在 JavaScript 中，每个对象都有一个原型对象，当访问一个对象的属性时，JavaScript 会沿着该对象的原型链向上查找，直到找到该属性或者到达原型链的顶端为止。原型链污染是指攻击者通过修改对象的原型链来实现对代码的攻击。

下面是一个简单的示例，演示了原型链污染的基本原理：

// 定义一个基础对象，包含一个 getName 方法
const baseObj = {
 getName: function() {
   return 'I am a base object';
  }
};
​
// 定义一个恶意对象，通过原型链污染修改了 getName 方法
const maliciousObj = {
 getName: function() {
   return 'I am a malicious object';
  }
};
maliciousObj.__proto__ = baseObj; // 修改原型对象为 baseObj
​
// 创建一个普通的对象，并访问 getName 方法
const normalObj = {};
console.log(normalObj.getName()); // 输出：Uncaught TypeError: normalObj.getName is not a function
​
// 修改 normalObj 对象的原型为 maliciousObj
Object.setPrototypeOf(normalObj, maliciousObj);
​
// 此时再次访问 getName 方法，输出被污染的内容
console.log(normalObj.getName()); // 输出：I am a malicious object

在上面的示例中，定义了一个基础对象 baseObj，它包含一个 getName 方法，该方法返回一个固定的字符串。接下来，定义了一个恶意对象 maliciousObj，该对象同样包含一个 getName 方法，但它返回的字符串不同，并且将 __proto__ 属性设置为 base

Obj 对象，从而使 maliciousObj 对象的原型指向了 baseObj。接下来，创建了一个普通的对象 normalObj，该对象在原型链上并没有定义 getName 方法。然后，使用 Object.setPrototypeOf 方法将 normalObj 的原型设置为 maliciousObj，从而在 normalObj 对象上成功实现了原型链污染。最后，调用 normalObj.getName() 方法时，JavaScript 沿着 normalObj 对象的原型链查找到了 maliciousObj 对象，并返回了被污染的 getName 方法的内容。

javascript中可能会存在原型链污染的危险函数

merge 函数：

当使用 merge 函数合并两个对象时，如果这两个对象都有相同的属性，那么 merge 函数会将目标对象中的属性值替换为源对象中的属性值。然而，如果这些属性的值是对象或者数组，那么 merge 函数并不会复制它们的值，而是将它们的引用复制给了目标对象。这样，如果修改目标对象中的这些属性，那么源对象中的这些属性也会被修改，进而污染了原型链。

下面是一个示例代码，它展示了如何使用 merge 函数修改全局作用域中的对象，从而污染了原型链：

// 定义一个全局变量
var globalObj = {};
​
// 在 globalObj 的原型上定义一个属性
Object.prototype.globalProp = 'global property';
​
// 合并一个带有属性的对象到全局变量中
_.merge(globalObj, {
  myProp: 'my property'
});
​
// 修改全局变量中的属性
globalObj.globalProp = 'modified global property';
​
// 输出全局变量中的属性和原型链上的属性
console.log(globalObj.myProp);      // "my property"
console.log(globalObj.globalProp);  // "modified global property"
​
// 创建一个对象并继承自全局变量
var obj = Object.create(globalObj);
​
// 输出继承自全局变量的对象的属性和原型链上的属性
console.log(obj.myProp);            // "my property"
console.log(obj.globalProp);        // "modified global property"

从上面的示例代码可以看出，由于 merge 函数修改了全局变量中的属性，因此继承自全局变量的对象也受到了污染。

clone函数：

在JavaScript中，对象可以被复制或克隆，有时候需要将一个对象的属性和方法复制到另一个对象中。通常会使用一些函数库提供的clone函数来实现对象的复制，但是有些clone函数实现方式可能会造成原型链污染的风险。

原型链污染的风险在于，攻击者可以通过污染原型对象，从而控制对象的行为并进行恶意操作。

下面是一个clone函数的示例，它使用了Object.assign函数来实现对象的复制：

function cloneObject(source) {
  return Object.assign({}, source);
}

这个cloneObject函数实现了对象的复制，它接受一个源对象source作为参数，然后返回一个新的对象，新对象的属性和方法与源对象相同。但是这个cloneObject函数存在原型链污染的风险，因为Object.assign函数会复制源对象的原型对象中的属性和方法。

下面是一个利用这个cloneObject函数进行原型链污染的示例代码：

// 定义一个原型对象
var myPrototype = {
  sayHello: function() {
    console.log('Hello!');
  }
};

// 创建一个空对象
var myObject = {};

// 使用cloneObject函数复制myPrototype对象到myObject中
cloneObject(myObject, myPrototype);

// 调用myObject上的sayHello方法
myObject.sayHello(); // Hello!

在这个示例代码中，定义了一个原型对象myPrototype，它包含一个方法sayHello。然后创建一个空对象myObject，并使用cloneObject函数将myPrototype对象复制到myObject中。由于cloneObject函数使用了Object.assign函数，因此myObject的原型对象被设置为了myPrototype，myObject现在可以访问原型对象中的方法sayHello。因此，调用myObject.sayHello()时，就会执行myPrototype中的sayHello方法。

Object.assign 函数：

Object.assign是一个常用的函数，用于将多个源对象的属性和方法合并到目标对象中。然而，Object.assign也可能会导致原型链污染的问题。

Object.assign的原理是遍历源对象的所有可枚举属性，然后将它们赋值给目标对象。如果源对象的属性是一个引用类型（如对象、数组等），则会将引用复制到目标对象中，这可能会造成原型链污染的风险。

// 定义一个全局变量
var globalObj = {};

// 在 globalObj 的原型上定义一个属性
Object.prototype.globalProp = 'global property';

// 使用 Object.assign 合并一个带有属性的对象到全局变量中
Object.assign(globalObj, {
  myProp: 'my property'
});

// 修改全局变量中的属性
globalObj.globalProp = 'modified global property';

// 输出全局变量中的属性和原型链上的属性
console.log(globalObj.myProp);      // "my property"
console.log(globalObj.globalProp);  // "modified global property"

// 创建一个对象并继承自全局变量
var obj = Object.create(globalObj);

// 输出继承自全局变量的对象的属性和原型链上的属性
console.log(obj.myProp);            // "my property"
console.log(obj.globalProp);        // "modified global property"·

下面是一个使用Object.assign函数导致原型链污染的示例代码：

// 定义一个原型对象
var myPrototype = {
  sayHello: function() {
    console.log('Hello!');
  }
};

// 创建一个空对象
var myObject = {};

// 使用Object.assign函数将myPrototype对象合并到myObject中
Object.assign(myObject, myPrototype);

// 调用myObject上的sayHello方法
myObject.sayHello(); // Hello!

在这个示例代码中，定义了一个原型对象myPrototype，它包含一个方法sayHello。然后创建一个空对象myObject，并使用Object.assign函数将myPrototype对象合并到myObject中。由于Object.assign函数会将myPrototype对象中的属性和方法复制到myObject中，因此myObject的原型对象被设置为了myPrototype，myObject现在可以访问原型对象中的方法sayHello。因此，调用myObject.sayHello()时，就会执行myPrototype中的sayHello方法。

Object.create函数：

Object.create是一个用于创建新对象的函数，它可以使用现有对象作为新对象的原型。

// 定义一个全局变量
var globalObj = {};

// 在 globalObj 的原型上定义一个属性
Object.prototype.globalProp = 'global property';

// 使用 Object.create 创建一个带有属性的对象并继承自全局变量
var obj = Object.create(globalObj, {
  myProp: {
    value: 'my property'
  }
});

// 修改全局变量中的属性
globalObj.globalProp = 'modified global property';

// 输出继承自全局变量的对象的属性和原型链上的属性
console.log(obj.myProp);            // "my property"
console.log(obj.globalProp);        // "modified global property"

如果原型对象存在恶意代码，那么新对象也会受到影响，从而导致原型链污染的问题。

下面是一个使用Object.create函数导致原型链污染的示例代码：

// 定义一个原型对象
var myPrototype = {
  sayHello: function() {
    console.log('Hello!');
  }
};

// 使用Object.create函数创建一个新对象，并将myPrototype作为它的原型
var myObject = Object.create(myPrototype);

// 调用myObject上的sayHello方法
myObject.sayHello(); // Hello!

在这个示例代码中，定义了一个原型对象myPrototype，它包含一个方法sayHello。然后使用Object.create函数创建了一个新对象myObject，并将myPrototype作为它的原型。由于myObject的原型对象被设置为了myPrototype，myObject现在可以访问原型对象中的方法sayHello。因此，调用myObject.sayHello()时，就会执行myPrototype中的sayHello方法。

eval函数：

eval函数是一个全局函数，它将传入的字符串作为 JavaScript 代码进行解析和执行。

// 定义一个全局变量
var globalVar = 'global variable';

// 使用 eval 函数创建一个函数并在其中访问全局变量
eval('function myFunc() { console.log(globalVar); }');

// 修改全局变量的值
globalVar = 'modified global variable';

// 调用刚才创建的函数
myFunc();  // "modified global variable"

由于eval函数具有执行任意代码的能力，因此它也可能导致原型链污染的问题。

在eval函数中，如果执行的代码中包含了对__proto__属性的操作，那么就会导致原型链污染。例如，下面的示例代码演示了如何使用eval函数向一个对象的原型对象中添加一个属性：

var myObject = {};
var code = "this.__proto__.myProperty = 'Hello World';"; // 向原型对象添加属性

eval(code); // 执行代码

console.log(myObject.myProperty); // Hello World

在这个示例代码中，定义了一个空对象myObject，然后使用字符串形式的代码向它的原型对象中添加了一个属性myProperty。将这个字符串代码传递给eval函数，并执行它。由于eval函数会将字符串代码作为 JavaScript 代码进行解析和执行，因此会向myObject的原型对象中添加一个属性myProperty。最后，输出myObject.myProperty的值，可以看到它已经被设置为了'Hello World'。

原型链污染的实际应用

示例代码：

// 定义一个常量对象
const MY_CONST = {
  name: "My Const"
};

// 定义一个 merge 函数，用于合并对象
function merge(target, source) {
  for (let key in source) {
    if (source.hasOwnProperty(key)) {
      target[key] = source[key];
    }
  }
}

// 使用 merge 函数合并对象
merge({}, JSON.parse('{"__proto__": {"isAdmin": true}}'));

// 检查 MY_CONST 是否被污染
console.log(MY_CONST.isAdmin); // true

在这个示例中，首先定义了一个常量对象MY_CONST，然后定义了一个merge函数，用于合并两个对象。接着，使用JSON.parse函数解析了一个包含__proto__属性的 JSON 字符串，并将它作为参数传递给merge函数。由于merge函数中没有对参数进行类型检查或者属性白名单过滤，因此这个函数可能会合并任意对象的属性，包括它们的原型对象中的属性。

在这个示例中，由于恶意 JSON 字符串中包含了__proto__属性，因此它会将一个具有isAdmin属性的对象添加到MY_CONST对象的原型对象中。这样，就可以通过MY_CONST.isAdmin属性访问到这个恶意对象中的属性值了，这就是原型链污染的问题。

JavaScript中可以触发弹窗的函数

  1. alert() 函数可以在浏览器中弹出一个警告框，用于向用户显示一条消息。示例代码如下：

    alert('Hello, world!');

  2. confirm() 函数可以在浏览器中弹出一个确认框，用于向用户显示一条消息并询问用户是否继续操作。示例代码如下：

    if (confirm('Are you sure you want to delete this item?')) {
  // 用户点击了确认按钮，执行删除操作
} else {
  // 用户点击了取消按钮，不执行删除操作
}

  3. prompt() 函数可以在浏览器中弹出一个对话框，用于向用户显示一条消息并询问用户输入内容。示例代码如下：

    let name = prompt('What is your name?');
if (name) {
  alert('Hello, ' + name + '!');
} else {
  alert('Please enter your name.');
}

加群交流

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

9-静态链表及其有关操作

9-静态链表及其有关操作

链表可以用malloc/new和结构体加指针的方式来实现，那种实现方式实现的链表又被称为动态链表。但是我们还可以利用数组的方式来实现一个链表，这种实现方式称为静态链表。 静态单链表 我们知道，一个链表节点主要由两大部分组成：数…
阅读更多...
黑马Spring学习笔记（一）——IOC/DI核心概念、入门案例

黑马Spring学习笔记（一）——IOC/DI核心概念、入门案例

目录 一、Spring系统架构和学习路线 二、Spring核心概念 2.1 IOC、IOC容器、Bean、DI 2.1.1 IOC（Inversion of Control）控制反转 2.1.2 DI（Dependency Injection）依赖注入 2.2 核心概念小结 三、入门案例 3.1 IOC入门…
阅读更多...
【C++入门】引用、内联函数、auto关键字、基于范围的for循环(C++11)、指针空值nullptr(C++11)

【C++入门】引用、内联函数、auto关键字、基于范围的for循环(C++11)、指针空值nullptr(C++11)

文章目录引用引用概念引用特性引用使用场景常引用内联函数宏的优缺点？C有哪些技术替代宏？auto关键字auto不能推导的场景基于范围的for循环(C11)指针空值nullptr(C11)引用 引用概念 引用不是新定义一个变量，而是给已存在变量取了一个别名&…
阅读更多...
一篇搞懂UnitTest

一篇搞懂UnitTest

unittest单元测试框架是受到 JUnit 的启发，与其他语言中的主流单元测试框架有着相似的风格。其支持测试自动化、支持将测试样例聚合到测试集中，并将测试与报告框架独立开来。unittest模块是Python标准库中的模块。在此之前需要先了解几个概念&#xff1a…
阅读更多...
linux高级命令之线程执行带有参数的任务

linux高级命令之线程执行带有参数的任务

线程执行带有参数的任务学习目标能够写出线程执行带有参数的任务1. 线程执行带有参数的任务的介绍前面我们使用线程执行的任务是没有参数的，假如我们使用线程执行的任务带有参数，如何给函数传参呢?Thread类执行任务并给任务传参数有两种方式:args 表示以…
阅读更多...
NTC热敏电阻

NTC热敏电阻

NTC热敏电阻： 负温度系数热敏电阻。 Negative Temperature Coefficient Thermistor 特性： 由锰 (Mn) 、镍 (Ni) 、钴 (Co) 等成分的氧化物烧制而成的陶瓷。阻值随温度上升而下降。 工作温度范围宽：一般的都可用于-40℃ to 125℃。有的高…
阅读更多...
[Pytorch] Linear层输出nan

[Pytorch] Linear层输出nan

参考链接： https://discuss.pytorch.org/t/well-formed-input-into-a-simple-linear-layer-output-nan/74720/11 总结原因： numpy需要更新 PS. 查看numpy版本号 打开Anaconda Prompt 进入环境 输入命令conda activate envname 然后输入pip show numpy…
阅读更多...
MongoDB 自动增长

MongoDB 自动增长

MongoDB 自动增长 MongoDB 没有像 SQL 一样有自动增长的功能， MongoDB 的 _id 是系统自动生成的12字节唯一标识。但在某些情况下，可能需要实现 ObjectId 自动增长功能。而MongoDB 并没有提供这个功能，那么可以通过编程的方式来实现_id字段自…
阅读更多...
Qt音视频开发14-音视频文件保存基类的设计

Qt音视频开发14-音视频文件保存基类的设计

一、前言 视频综合应用示例，包括了多种内核，在保存文件这个功能上，需要一个通用的文件保存基类AbstractSaveThread，这个基类定义了是否打印线程消息标志位、直接写入还是排队写入标志位、文件生成后是否调用转换合并标志位、是否…
阅读更多...
Linux下的Jenkins安装教程

Linux下的Jenkins安装教程

当前环境 CentOS 7.8Java 11（注意当前jenkins支持的Java版本最低为Java11）FinalShell 3.9（操作环境） 安装Jenkins PS：不建议使用Docker安装Jenkins，因为使用Jenkins的时候一般会调用外部程序，…
阅读更多...
【猜名次】-C语言-题解

【猜名次】-C语言-题解

1. 描述： 5位运动员参加了10米台跳水比赛，有人让他们预测比赛结果： A选手说：B第二，我第三； B选手说：我第二，E第四； C选手说：我第一，D第二&#x…
阅读更多...
【工作10年+的大厂资深架构师万字长文总结 精华收藏！】怎样设计高可用、高性能系统？关于高可用高性能系统架构和设计理论和经验总结...

【工作10年+的大厂资深架构师万字长文总结 精华收藏！】怎样设计高可用、高性能系统？关于高可用高性能系统架构和设计理论和经验总结...

本文从研发规范层面、应用服务层面、存储层面、产品层面、运维部署层面、异常应急层面这六大层面去剖析一个高可用的系统需要有哪些关键的设计和考虑.O、前言随着业务在线化互联网化的高速发展，企业对核心业务系统的稳定性、可靠性、有效性、业务连续性等有了更高的…
阅读更多...
openpnp - 普通航空插头和PCB的连接要使用线对板连接器

openpnp - 普通航空插头和PCB的连接要使用线对板连接器

文章目录openpnp - 普通航空插头和PCB的连接要使用线对板连接器概述改进实际效果总结ENDopenpnp - 普通航空插头和PCB的连接要使用线对板连接器 概述 和同学讨论问题, 准备将航空插头连接到PCB上. 航空插头选用GX12-4公头, 拧到开孔的铁板上. 然后航空插头公头再与PCB连接. 铁…
阅读更多...
【数据库】HNU数据库系统期末考试复习重点

【数据库】HNU数据库系统期末考试复习重点

前言 今天刚结束考试，考的范围基本没有超过这套重点内容，觉得整理的这份资料还算比较有用，遂睡前整理了下分享给大家，希望能帮到要准备数据库期末又时间紧张的学弟学妹~ 文章参考： 1.课程老师发《数据库期末考试复习…
阅读更多...
【项目精选】基于网络爬虫技术的网络新闻分析（论文+源码+视频）

【项目精选】基于网络爬虫技术的网络新闻分析（论文+源码+视频）

基于网络爬虫技术的网络新闻分析主要用于网络数据爬取。本系统结构如下： （1）网络爬虫模块。 （2）中文分词模块。 （3）中3文相似度判定模块。 （4）数据结构化存储模块。 &…
阅读更多...
120个IT冷知识，看完就不愁做选择题了

120个IT冷知识，看完就不愁做选择题了

目录 IT冷知识 01-10 1.冰淇淋馅料 2.蠕虫起源 3.Linux和红帽子 4."间谍软件"诞生 5.游戏主机的灵魂 6.Linux之父 7.NetBSD的口号 8.安卓起源 9.不是第七代的 Win 7 10.域名金字塔 11~20 11.神奇魔盒 12. 第一个Ubuntu 正式版本 13.巾帼英雄 14.密码…
阅读更多...
【高可用系统架构设计】SLA服务可用性4个9是什么意思？如何保证服务的高可用性 HA（High Availability）?...

【高可用系统架构设计】SLA服务可用性4个9是什么意思？如何保证服务的高可用性 HA（High Availability）?...

如何保证服务的高可用性 HA（High Availability）?高可用HA（High Availability）是分布式系统架构设计中必须考虑的因素之一，它通常是指，通过设计减少系统不能提供服务的时间。方法论上，高可用是通…
阅读更多...
springboot整合阿里云oss文件服务器

springboot整合阿里云oss文件服务器

springboot整合阿里云oss文件服务器一、申请Bucket二、 获取AccessKey ID、AccessKey Secret三、 springboot整合3.1 在application.yml 配置参数3.2 oss需要的pom3.3 配置 oss配置类3.4 oss的controller类3.5 oss的service类以及impl一、申请Bucket 进入该网址对象存储oss述 …
阅读更多...
18 二叉树

18 二叉树

文章目录1 为什么需要树这种数据结构2 树示意图3 二叉树的概念4 二叉树的遍历5 二叉树的遍历的代码实现6 二叉树的遍历查找的代码实现1 为什么需要树这种数据结构 1) 数组存储方式的分析 优点：通过下标方式访问元素，速度快。对于有序数组，还…
阅读更多...
【Linux】进程状态

【Linux】进程状态

文章目录1. 阻塞1. 举例2. 为什么要阻塞？3.操作系统层面上如何理解进程等待某种资源就绪呢？资源进程4. 总结2.挂起3.Linux进程状态1. R状态进程只要是R状态，就一定是在CPU运行吗？证明当前进程运行状态生成程序查看进程2. S休眠状态…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023