《JavaScript高级程序设计》读书笔记 23

🕗 发布于 2024-12-09 00:33 javascript 前端 开发语言

感谢点赞、关注和收藏！

艰难地看完了前 5 章，来不及回忆了，接下来是第 6 章 - 集合引用类型！

这一篇我们简单介绍Object，重点看Array。

Object

到目前为止，大多数引用值的示例使用的是 Object 类型。Object 是 ECMAScript 中最常用的类型之一。虽然 Object 的实例没有多少功能，但很适合存储和在应用程序间交换数据。

显式地创建 Object 的实例有两种方式。

let person = new Object(); 
person.name = "Nicholas"; 
person.age = 29;

// 或者下面这种直接使用字面量
let person = { 
 name: "Nicholas", 
 age: 29 
};

// 又或者这样
let person = {}; // 与 new Object()相同
person.name = "Nicholas"; 
person.age = 29;

虽然属性一般是通过点语法来存取的，这也是面向对象语言的惯例，但也可以使用中括号来存取属性。在使用中括号时，要在括号内使用属性名的字符串形式，比如：

console.log(person["name"]); // "Nicholas" 
console.log(person.name); // "Nicholas"

使用中括号的主要优势就是可以通过变量访问属性，比如：

let propertyName = "name"; 
console.log(person[propertyName]); // "Nicholas"

在书的第 8 章会更详细的介绍Object，这里点到为止。下面是Array。

Array

ECMAScript 数组跟其他编程语言的数组有很大区别。跟其他语言中的数组一样，ECMAScript 数组也是一组有序的数据，但跟其他语言不同的是，数组中每个槽位可以存储任意类型的数据。ECMAScript 数组也是动态大小的，会随着数据添加而自动增长。

创建数组

有几种基本的方式可以创建数组。下面直接用例子来说明。

// Array构造函数
let colors = new Array();

// 构造函数传值，设定length
let colors2 = new Array(20);

// 构造函数传值，指定内容
let colors3 = new Array("red", "blue", "green");

// 字面量创建
let colors4 = ["red", "blue", "green"]; // 创建一个包含 3 个元素的数组
let names = [];                         // 创建一个空数组
let values = [1,2,];                    // 创建一个包含 2 个元素的数组

//  ***ES6新方法 - Array.from()

// 字符串会被拆分为单字符数组
console.log(Array.from("Matt")); // ["M", "a", "t", "t"] 

// 可以使用 from()将集合和映射转换为一个新数组
const m = new Map().set(1, 2) 
 .set(3, 4); 
const s = new Set().add(1) 
 .add(2) 
 .add(3) 
 .add(4); 
console.log(Array.from(m)); // [[1, 2], [3, 4]] 
console.log(Array.from(s)); // [1, 2, 3, 4] 

// Array.from()对现有数组执行浅复制
const a1 = [1, 2, 3, 4]; 
const a2 = Array.from(a1); 
console.log(a1); // [1, 2, 3, 4] 
alert(a1 === a2); // false 

// 可以使用任何可迭代对象
const iter = { 
 *[Symbol.iterator]() { 
 yield 1; 
 yield 2; 
 yield 3; 
 yield 4; 
 } 
}; 
console.log(Array.from(iter)); // [1, 2, 3, 4]

// arguments 对象可以被轻松地转换为数组
function getArgsArray() { 
 return Array.from(arguments); 
} 
console.log(getArgsArray(1, 2, 3, 4)); // [1, 2, 3, 4] 

// from()也能转换带有必要属性的自定义对象
const arrayLikeObject = { 
 0: 1, 
 1: 2, 
 2: 3, 
 3: 4, 
 length: 4 
}; 
console.log(Array.from(arrayLikeObject)); // [1, 2, 3, 4]

// Array.from()可以有两个或三个参数，第二个是映射函数，相当于map，第三个是映射函数的this指向
const b1 = [1, 2, 3, 4]; 
const b2 = Array.from(b1, x => x**2); 
const b3 = Array.from(b1, function(x) {return x**this.exponent}, {exponent: 2}); 
console.log(b2); // [1, 4, 9, 16] 
console.log(b3); // [1, 4, 9, 16]

// ***ES6新方法 - Array.of()
console.log(Array.of(1, 2, 3, 4)); // [1, 2, 3, 4] 
console.log(Array.of(undefined)); // [undefined]

数组空位

使用数组字面量初始化数组时，可以使用一串逗号来创建空位（hole）。

ECMAScript 会将逗号之间相应索引位置的值当成空位，ES6 规范重新定义了该如何处理这些空位

，然而这些空位的表现并不稳定，建议显式的去给空位定义值。

const options = [1,,,,5];             // 创建包含 5 个元素的数组
console.log(options.length);          // 5 
console.log(options);                 // [1,,,,5]
for (const option of options) { 
 console.log(option === undefined); 
} 
// false 
// true 
// true 
// true 
// false

// ES6之前的方法可能会忽略这些空位
// map()会跳过空位置
console.log(options.map(() => 6)); // [6, undefined, undefined, undefined, 6] 
// join()视空位置为空字符串
console.log(options.join('-')); // "1----5"

数组索引

索引本身都很熟了，这里不介绍了，来看一下length这个属性。数组 length 属性的独特之处在于，它不是只读的。通过修改 length 属性，可以从数组末尾删除或添加元素。来看下面的例子：

let colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
colors.length = 2; 
alert(colors[2]); // undefined

// 同样的，伸长一个数组
let colors2 = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
colors2.length = 4; 
alert(colors2[3]); // undefined

如果直接使用索引插入到一个很深的位置，比如99，length会变成100，但是中间3～98都是undefined。

检测数组

一个经典的 ECMAScript 问题是判断一个对象是不是数组。使用 instanceof 的问题是假定只有一个全局执行上下文。如果网页里有多个框架，则可能涉及两个不同的全局执行上下文，因此就会有两个不同版本的 Array 构造函数。如果要把数组从一个框架传给另一个框架，则这个数组的构造函数将有别于在第二个框架内本地创建的数组。

为解决这个问题，ECMAScript 提供了 Array.isArray()方法。这个方法的目的就是确定一个值是否为数组，而不用管它是在哪个全局执行上下文中创建的。

迭代器方法

在 ES6 中， Array 的原型上暴露了 3 个用于检索数组内容的方法： keys() 、 values() 和 entries()。 keys() 返回数组索引的迭代器， values() 返回数组元素的迭代器，而 entries() 返回索引/ 值对的迭代器：

const a = ["foo", "bar", "baz", "qux"]; 
// 因为这些方法都返回迭代器，所以可以将它们的内容
// 通过 Array.from()直接转换为数组实例
const aKeys = Array.from(a.keys()); 
const aValues = Array.from(a.values()); 
const aEntries = Array.from(a.entries()); 
console.log(aKeys); // [0, 1, 2, 3] 
console.log(aValues); // ["foo", "bar", "baz", "qux"] 
console.log(aEntries); // [[0, "foo"], [1, "bar"], [2, "baz"], [3, "qux"]] 
// 使用 ES6 的解构可以非常容易地在循环中拆分键/值对：
const a = ["foo", "bar", "baz", "qux"]; 
for (const [idx, element] of a.entries()) { 
 alert(idx); 
 alert(element); 
} 
// 0 
// foo 
// 1 
// bar 
// 2 
// baz 
// 3 
// qux

复制和填充方法

ES6 新增了两个方法：批量复制方法 copyWithin()，以及填充数组方法 fill()。这两个方法的函数签名类似，都需要指定既有数组实例上的一个范围，包含开始索引，不包含结束索引。使用这个方法不会改变数组的大小。下面举一些例子：

const zeroes = [0, 0, 0, 0, 0]; 
// 用 5 填充整个数组
zeroes.fill(5); 
console.log(zeroes); // [5, 5, 5, 5, 5] 
zeroes.fill(0); // 重置
// 用 6 填充索引大于等于 3 的元素
zeroes.fill(6, 3); 
console.log(zeroes); // [0, 0, 0, 6, 6] 
zeroes.fill(0); // 重置
// 用 7 填充索引大于等于 1 且小于 3 的元素
zeroes.fill(7, 1, 3); 
console.log(zeroes); // [0, 7, 7, 0, 0]; 
zeroes.fill(0); // 重置
// 用 8 填充索引大于等于 1 且小于 4 的元素
// (-4 + zeroes.length = 1) 
// (-1 + zeroes.length = 4) 
zeroes.fill(8, -4, -1); 
console.log(zeroes); // [0, 8, 8, 8, 0]; 
fill()静默忽略超出数组边界、零长度及方向相反的索引范围：
const zeroes = [0, 0, 0, 0, 0]; 
// 索引过低，忽略
zeroes.fill(1, -10, -6); 
console.log(zeroes); // [0, 0, 0, 0, 0] 
// 索引过高，忽略
zeroes.fill(1, 10, 15); 
console.log(zeroes); // [0, 0, 0, 0, 0] 
// 索引反向，忽略
zeroes.fill(2, 4, 2); 
console.log(zeroes); // [0, 0, 0, 0, 0] 
// 索引部分可用，填充可用部分
zeroes.fill(4, 3, 10) 
console.log(zeroes); // [0, 0, 0, 4, 4]

与 fill()不同，copyWithin()会按照指定范围浅复制数组中的部分内容，然后将它们插入到指

定索引开始的位置。开始索引和结束索引则与 fill()使用同样的计算方法：

let ints, 
 reset = () => ints = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; 
reset(); 
// 从 ints 中复制索引 0 开始的内容，插入到索引 5 开始的位置
// 在源索引或目标索引到达数组边界时停止
ints.copyWithin(5); 
console.log(ints); // [0, 1, 2, 3, 4, 0, 1, 2, 3, 4] 
reset(); 
// 从 ints 中复制索引 5 开始的内容，插入到索引 0 开始的位置
ints.copyWithin(0, 5); 
console.log(ints); // [5, 6, 7, 8, 9, 5, 6, 7, 8, 9]
reset(); 
// 从 ints 中复制索引 0 开始到索引 3 结束的内容
// 插入到索引 4 开始的位置
ints.copyWithin(4, 0, 3); 
alert(ints); // [0, 1, 2, 3, 0, 1, 2, 7, 8, 9] 
reset(); 
// JavaScript 引擎在插值前会完整复制范围内的值
// 因此复制期间不存在重写的风险
ints.copyWithin(2, 0, 6); 
alert(ints); // [0, 1, 0, 1, 2, 3, 4, 5, 8, 9] 
reset(); 
// 支持负索引值，与 fill()相对于数组末尾计算正向索引的过程是一样的
ints.copyWithin(-4, -7, -3); 
alert(ints); // [0, 1, 2, 3, 4, 5, 3, 4, 5, 6] 
copyWithin()静默忽略超出数组边界、零长度及方向相反的索引范围：
let ints, 
 reset = () => ints = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; 
reset(); 
// 索引过低，忽略
ints.copyWithin(1, -15, -12); 
alert(ints); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; 
reset() 
// 索引过高，忽略
ints.copyWithin(1, 12, 15); 
alert(ints); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; 
reset(); 
// 索引反向，忽略
ints.copyWithin(2, 4, 2); 
alert(ints); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; 
reset(); 
// 索引部分可用，复制、填充可用部分
ints.copyWithin(4, 7, 10) 
alert(ints); // [0, 1, 2, 3, 7, 8, 9, 7, 8, 9];

转换方法

前面提到过，所有对象都有 toLocaleString()、toString()和 valueOf()方法。那我们来看看Array的这些方法都有什么效果：

let colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
alert(colors.toString()); // red,blue,green 
alert(colors.valueOf()); // red,blue,green 
alert(colors); // red,blue,green

另外，toLocaleString() 可能和其他两个方法返回同样的内容，也可能不一样，注意一下即可。

栈方法

ECMAScript 给数组提供几个方法，让它看起来像是另外一种数据结构。数组对象可以像栈一样，也就是一种限制插入和删除项的数据结构。栈是一种后进先出（LIFO，Last-In-First-Out）的结构，也就是最近添加的项先被删除。数据项的插入（称为推入，push）和删除（称为弹出，pop）只在栈的一个地方发生，即栈顶。ECMAScript 数组提供了 push()和 pop()方法，以实现类似栈的行为。

let colors = new Array(); // 创建一个数组
let count = colors.push("red", "green"); // 推入两项
alert(count); // 2 
count = colors.push("black"); // 再推入一项
alert(count); // 3 
let item = colors.pop(); // 取得最后一项
alert(item); // black 
alert(colors.length); // 2

发现了吗？push() 和 pop() 都会改变原数组。

队列方法

就像栈是以 LIFO 形式限制访问的数据结构一样，队列以先进先出（FIFO，First-In-First-Out）形式限制访问。队列在列表末尾添加数据，但从列表开头获取数据。因为有了在数据末尾添加数据的 push()方法，所以要模拟队列就差一个从数组开头取得数据的方法了。这个数组方法叫 shift()，它会删除数组的第一项并返回它，然后数组长度减 1。使用 shift()和 push()，可以把数组当成队列来使用：

let colors = new Array();                 // 创建一个数组
let count = colors.push("red", "green");  // 推入两项
alert(count);                             // 2 
count = colors.push("black");             // 再推入一项
alert(count);                             // 3 
let item = colors.shift();                // 取得第一项
alert(item);                              // red 
alert(colors.length);                     // 2

ECMAScript 也为数组提供了 unshift()方法。顾名思义，unshift()就是执行跟 shift()相反的操作：在数组开头添加任意多个值，然后返回新的数组长度。通过使用 unshift()和 pop()，可以在相反方向上模拟队列，即在数组开头添加新数据，在数组末尾取得数据，如下例所示：

let colors = new Array();                     // 创建一个数组
let count = colors.unshift("red", "green");   // 从数组开头推入两项
alert(count);                                 // 2 
count = colors.unshift("black");              // 再推入一项
alert(count);                                 // 3 
let item = colors.pop();                      // 取得最后一项
alert(item);                                  // green 
alert(colors.length);                         // 2

排序方法

数组有两个方法可以用来对元素重新排序：reverse()和 sort()。顾名思义，reverse()方法就是将数组元素反向排列。默认情况下，sort()会按照升序重新排列数组元素，即最小的值在前面，最大的值在后面。为此，sort()会在每一项上调用 String()转型函数，然后比较字符串来决定顺序。即使数组的元素都是数值，也会先把数组转换为字符串再比较、排序。比如：

let values = [0, 1, 5, 10, 15]; 
values.sort(); 
alert(values); // 0,1,10,15,5

sort()方法可以接收一个比较函数，用于判断哪个值应该排在前面。这个比较函数接收两个参数，如果第一个参数应该排在第二个参数前面，就返回负值；如果两个参数相等，就返回 0；如果第一个参数应该排在第二个参数后面，就返回正值。

function compare(value1, value2) { 
 if (value1 < value2) { 
     return -1; 
 } else if (value1 > value2) { 
     return 1; 
 } else { 
     return 0; 
 } 
}

// 这个比较函数可以适用于大多数数据类型，可以把它当作参数传给 sort()方法
let values = [0, 1, 5, 10, 15]; 
values.sort(compare); 
alert(values); // 0,1,5,10,15

操作方法

对于数组中的元素，我们有很多操作方法，包括 concat()，slice()，splice()，下面举例来看一下这三个方法。

首先是concat()，以及影响打平的符号Symbol.isConcatSpreadable，这个在之前的文章中有提到过。

let colors = ["red", "green", "blue"]; 
let newColors = ["black", "brown"]; 
let moreNewColors = { 
 [Symbol.isConcatSpreadable]: true, 
 length: 2, 
 0: "pink", 
 1: "cyan" 
}; 
newColors[Symbol.isConcatSpreadable] = false; 
// 强制不打平数组
let colors2 = colors.concat("yellow", newColors); 
// 强制打平类数组对象
let colors3 = colors.concat(moreNewColors); 
console.log(colors); // ["red", "green", "blue"] 
console.log(colors2); // ["red", "green", "blue", "yellow", ["black", "brown"]] 
console.log(colors3); // ["red", "green", "blue", "pink", "cyan"]

接下来，方法 slice()用于创建一个包含原有数组中一个或多个元素的新数组。slice()方法可以接收一个或两个参数：返回元素的开始索引和结束索引。

let colors = ["red", "green", "blue", "yellow", "purple"]; 
let colors2 = colors.slice(1); 
let colors3 = colors.slice(1, 4); 
alert(colors2); // green,blue,yellow,purple 
alert(colors3); // green,blue,yellow

最后一个是splice()。splice()的主要目的是在数组中间插入元素，但有 3 种不同的方式使用这个方法：

删除。需要给 splice()传 2 个参数：要删除的第一个元素的位置和要删除的元素数量。可以从数组中删除任意多个元素，比如 splice(0, 2)会删除前两个元素。
插入。需要给 splice()传 3 个参数：开始位置、0（要删除的元素数量）和要插入的元素，可以在数组中指定的位置插入元素。第三个参数之后还可以传第四个、第五个参数，乃至任意多个要插入的元素。比如，splice(2, 0, "red", "green")会从数组位置 2 开始插入字符串"red"和"green"。
替换。splice()在删除元素的同时可以在指定位置插入新元素，同样要传入 3 个参数：开始位置、要删除元素的数量和要插入的任意多个元素。要插入的元素数量不一定跟删除的元素数量一致。比如，splice(2, 1, "red", "green")会在位置 2 删除一个元素，然后从该位置开始向数组中插入"red"和"green"。

let colors = ["red", "green", "blue"]; 
let removed = colors.splice(0,1); // 删除第一项
alert(colors); // green,blue 
alert(removed); // red，只有一个元素的数组
removed = colors.splice(1, 0, "yellow", "orange"); // 在位置 1 插入两个元素
alert(colors); // green,yellow,orange,blue 
alert(removed); // 空数组
removed = colors.splice(1, 1, "red", "purple"); // 插入两个值，删除一个元素
alert(colors); // green,red,purple,orange,blue 
alert(removed); // yellow，只有一个元素的数组

搜索和位置方法

ECMAScript 提供两类搜索数组的方法：按严格相等搜索和按断言函数搜索。

1. 严格相等

ECMAScript 提供了 3 个严格相等的搜索方法：indexOf()、lastIndexOf()和 includes()。其

中，前两个方法在所有版本中都可用，而第三个方法是 ECMAScript 7 新增的。

let numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1]; 
alert(numbers.indexOf(4)); // 3 
alert(numbers.lastIndexOf(4)); // 5 
alert(numbers.includes(4)); // true 
alert(numbers.indexOf(4, 4)); // 5 
alert(numbers.lastIndexOf(4, 4)); // 3 
alert(numbers.includes(4, 7)); // false 
let person = { name: "Nicholas" }; 
let people = [{ name: "Nicholas" }]; 
let morePeople = [person]; 
alert(people.indexOf(person)); // -1 
alert(morePeople.indexOf(person)); // 0 
alert(people.includes(person)); // false 
alert(morePeople.includes(person)); // true

2. 断言函数

断言函数接收 3 个参数：元素、索引和数组本身。其中元素是数组中当前搜索的元素，索引是当前元素的索引，而数组就是正在搜索的数组。断言函数返回真值，表示是否匹配。

find()和 findIndex()方法使用了断言函数。这两个方法都从数组的最小索引开始。find()返回第一个匹配的元素，findIndex()返回第一个匹配元素的索引。这两个方法也都接收第二个可选的参数，用于指定断言函数内部 this 的值。

const people = [ 
 { 
 name: "Matt", 
 age: 27 
 }, 
 { 
 name: "Nicholas", 
 age: 29 
 } 
]; 
alert(people.find((element, index, array) => element.age < 28)); 
// {name: "Matt", age: 27} 
alert(people.findIndex((element, index, array) => element.age < 28)); 
// 0
const evens = [2, 4, 6]; 
// 找到匹配后，永远不会检查数组的最后一个元素
evens.find((element, index, array) => { 
 console.log(element); 
 console.log(index); 
 console.log(array); 
 return element === 4; 
}); 
// 2 
// 0 
// [2, 4, 6] 
// 4 
// 1 
// [2, 4, 6]

迭代方法

ECMAScript 为数组定义了 5 个迭代方法。每个方法接收两个参数：以每一项为参数运行的函数，以及可选的作为函数运行上下文的作用域对象（影响函数中 this 的值）。传给每个方法的函数接收 3 个参数：数组元素、元素索引和数组本身。因具体方法而异，这个函数的执行结果可能会也可能不会影响方法的返回值。数组的 5 个迭代方法如下。

every()：对数组每一项都运行传入的函数，如果对每一项函数都返回 true，则这个方法返回 true。
filter()：对数组每一项都运行传入的函数，函数返回 true 的项会组成数组之后返回。
forEach()：对数组每一项都运行传入的函数，没有返回值。
map()：对数组每一项都运行传入的函数，返回由每次函数调用的结果构成的数组。
some()：对数组每一项都运行传入的函数，如果有一项函数返回 true，则这个方法返回 true。

都是很常用的方法，下面直接举例：

let numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1]; 

let everyResult = numbers.every((item, index, array) => item > 2); 
alert(everyResult); // false 

let someResult = numbers.some((item, index, array) => item > 2); 
alert(someResult); // true

let filterResult = numbers.filter((item, index, array) => item > 2); 
alert(filterResult); // 3,4,5,4,3

let mapResult = numbers.map((item, index, array) => item * 2); 
alert(mapResult); // 2,4,6,8,10,8,6,4,2

numbers.forEach((item, index, array) => { 
 // 执行某些操作 
});

归并方法

ECMAScript 为数组提供了两个归并方法：reduce()和 reduceRight()。这两个方法都会迭代数组的所有项，并在此基础上构建一个最终返回值。reduce()方法从数组第一项开始遍历到最后一项。而 reduceRight()从最后一项开始遍历至第一项。

这两个方法都接收两个参数：对每一项都会运行的归并函数，以及可选的以之为归并起点的初始值。归并函数可以接收四个参数，分别是上一个归并值、当前项、当前项的索引和数组本身。

// 可以使用 reduce()函数执行累加数组中所有数值的操作
let values = [1, 2, 3, 4, 5]; 
let sum = values.reduce((prev, cur, index, array) => prev + cur); 
alert(sum); // 15

// reduceRight()类似
let sumRight = values.reduceRight(function(prev, cur, index, array){ 
 return prev + cur; 
}); 
alert(sumRight); // 15

这一篇太长了，到这里就把Array的方法都说完了，下一篇说说定型数组（typed array），它和Array是不一样的哦。

原文地址：https://blog.csdn.net/qq_34911907/article/details/144271213

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Linux其二设置端口号，静态ip以及命令
下一篇：Git操作-2.高级操作

太空探索的未来掌握在人工智能和机器人手中
NASA 还在规划未来更先进的深空探索任务，计划设计更多具有自主能力的航天器和着陆器，以便能够在现场做出决策，消除通信中继的延迟时间。机器人则通过行星漫游车的机械设计、太空操纵器的机械设计、太空机器人
阅读更多2024-12-26
fpgafor循环语句使用
genvar i;//循环变量名称generate for(i=0;i<4;i=i+1)begin:tx//自己定义名称//循环内容endendgenerate
阅读更多2024-12-26
GitPuk安装配置指南
GitPuk支持各种自定义配置，配置文件默认位置：系统默认位置Windows默认在安装目录下的conf目录下，编辑application.yaml文件Mac默认在app下的Contents -->
阅读更多2024-12-26
Zookeeper常见面试题解析
通过对这些常见 Zookeeper 面试题的深入剖析，我们全方位了解了 Zookeeper 从基础概念、核心特性到应用实践、性能优化以及运维排查的知识要点。在面试中，面对此类问题，不仅要精准回答理论知
阅读更多2024-12-26
Vue.js组件开发-使用vue-pdf显示PDF
<pdf></pdf>pdf},data() {return {rotate: 0},methods: {},},
阅读更多2024-12-26
SpringBoot从入门到实战：动态解析MyBatis SQL字符串获取可执行的SQL
工作中有时需要手动调用SqlSession或者SqlTemplate去执行SQL字符串，而SQL字符串可能是动态的，可能包括if、foreach等标签，所以需要解析mybatis语法生成最终可以执行的
阅读更多2024-12-26
java版Spring Cloud+Mybatis+Oauth2+分布式+微服务+实现工程管理系统
二、企业通过数字化转型，不仅有利于优化业务流程、提升经营管理能力和风险控制能力，还可强有力地促进企业体制机制的全面创新。四、在企业里建立一个管过程、提效率、降风险、控成本的工程项目管理环境，科学化、规
阅读更多2024-12-26
分布式通信，微服务协调组件，zookeeper
远程调用，跨进程的调用方法。跨进程，跨同一台计算机的多个进程，多个jvm，多台计算机之间的进程。rpc，remote procedure call，远程过程调用，指通过网络从远程计算机上获取服务，而不
阅读更多2024-12-26
Spring如何处理循环依赖
Spring通过三级缓存和依赖检查机制有效地解决了大部分由setter注入或字段注入导致的循环依赖问题。然而，对于构造器注入的情况，由于其实现原理的不同，Spring默认不支持这种类型的循环依赖，除非
阅读更多2024-12-26
选择排序：简单算法的实现与优化探索
选择排序是一种简单直观的排序算法。它的基本思想是每次从未排序的部分中选择最小（或最大）元素，将其放到已排序部分的末尾。尽管选择排序的时间复杂度较高，但其实现简洁，适合小规模数据的排序。
阅读更多2024-12-26