어레이 요소를 한 어레이 위치에서 다른 어레이 위치로 이동합니다.
배열 요소를 이동하는 방법을 찾는 데 어려움을 겪고 있습니다.예를 들어 다음과 같습니다.
var array = [ 'a', 'b', 'c', 'd', 'e'];
하기 위한 해야 하나요?'d'의 'b'
★★★'a'의의의 'c'
요소를 이동한 후에는 나머지 요소의 인덱스를 업데이트해야 합니다.결과 어레이는 다음과 같습니다.
array = ['a', 'd', 'b', 'c', 'e']
이것은 꽤 간단해 보이지만, 나는 그것에 대해 이해할 수 없다.
npm 버전을 원하는 경우 동일한 구현은 아니지만 어레이 이동이 이 답변에 가장 가깝습니다.자세한 내용은 사용 방법을 참조하십시오.이 답변의 이전 버전(Array.protype.move 변경)은 npm의 array.protype.move에서 찾을 수 있습니다.
이 기능은 꽤 성공적이었습니다.
function array_move(arr, old_index, new_index) {
if (new_index >= arr.length) {
var k = new_index - arr.length + 1;
while (k--) {
arr.push(undefined);
}
}
arr.splice(new_index, 0, arr.splice(old_index, 1)[0]);
return arr; // for testing
};
// returns [2, 1, 3]
console.log(array_move([1, 2, 3], 0, 1)); ''는return는 단순한 테스트용입니다.는 어레이에 대한 조작을 임플레이스하기 때문에 반품할 필요가 없습니다.내선번호로 이건move는 임플레이스 조작입니다.이를 피하고 복사본을 반환하려면 를 사용하십시오.
코드 단계:
- if
new_index에 (으로는) 에 새로운 패드를 채우는이 좋습니다.undefined이 작은 은 s.를 이 를 처리합니다.undefined적절한 길이가 될 때까지 어레이에 배치됩니다. - ㅇㅇㅇㅇ에서는요.
arr.splice(old_index, 1)[0]오래된 요소를 분리합니다.splice스플라이스된 요소를 반환하지만 배열에 있습니다.예에서는 이 「」입니다.[1]이의 첫 인덱스를1contract.discontracts. - ''는 '우리'를 씁니다.
splice_ new_index ___ 。이 되어 있기 에, 「 」의 경우는,new_index > arr.length음수 통과 같은 이상한 행동을 하지 않았다면 아마 올바른 위치에 나타날 것입니다.
마이너스 인덱스를 고려하는 고급 버전:
function array_move(arr, old_index, new_index) {
while (old_index < 0) {
old_index += arr.length;
}
while (new_index < 0) {
new_index += arr.length;
}
if (new_index >= arr.length) {
var k = new_index - arr.length + 1;
while (k--) {
arr.push(undefined);
}
}
arr.splice(new_index, 0, arr.splice(old_index, 1)[0]);
return arr; // for testing purposes
};
// returns [1, 3, 2]
console.log(array_move([1, 2, 3], -1, -2)); 이런 되겠죠?array_move([1, 2, 3], -1, -2)는 음음음음음음 ( ( 。[1, 3, 2]
이든 원래에서는 '어느 쪽이든', '어느 쪽이든', '어느 쪽이든 좋다' 이렇게 할 예요.array_move(arr, 0, 2)★★★★★★에a 후에c ★★★★의 d 전에b , , , , 을.array_move(arr, 3, 1).
난 이런 방식이 좋아.그것은 간결하고 효과가 있다.
function arraymove(arr, fromIndex, toIndex) {
var element = arr[fromIndex];
arr.splice(fromIndex, 1);
arr.splice(toIndex, 0, element);
}
주의: 항상 어레이 경계를 확인해야 합니다.
여기 JSPerf에서 찾은 라이너가 있습니다.
Array.prototype.move = function(from, to) {
this.splice(to, 0, this.splice(from, 1)[0]);
};
읽기에도 좋지만, 퍼포먼스(작은 데이터 세트)를 원한다면...
Array.prototype.move2 = function(pos1, pos2) {
// local variables
var i, tmp;
// cast input parameters to integers
pos1 = parseInt(pos1, 10);
pos2 = parseInt(pos2, 10);
// if positions are different and inside array
if (pos1 !== pos2 && 0 <= pos1 && pos1 <= this.length && 0 <= pos2 && pos2 <= this.length) {
// save element from position 1
tmp = this[pos1];
// move element down and shift other elements up
if (pos1 < pos2) {
for (i = pos1; i < pos2; i++) {
this[i] = this[i + 1];
}
}
// move element up and shift other elements down
else {
for (i = pos1; i > pos2; i--) {
this[i] = this[i - 1];
}
}
// put element from position 1 to destination
this[pos2] = tmp;
}
}
난 아무것도 못 믿겠어 모든 게 리처드 스카롯에게 돌아가야 해이 성능 테스트에서는 작은 데이터 세트에 대한 스플라이스 기반 방법을 능가합니다.그러나 Darwayne이 지적한 것처럼 큰 데이터 세트에서는 현저하게 느려집니다.
splice() 메서드는 배열에서 항목을 추가/제거하고 삭제된 항목을 반환합니다.
주의: 이 방법은 원래 어레이를 변경합니다./w3g/
Array.prototype.move = function(from,to){
this.splice(to,0,this.splice(from,1)[0]);
return this;
};
var arr = [ 'a', 'b', 'c', 'd', 'e'];
arr.move(3,1);//["a", "d", "b", "c", "e"]
var arr = [ 'a', 'b', 'c', 'd', 'e'];
arr.move(0,2);//["b", "c", "a", "d", "e"]
이 기능은 체인(chainable)이 가능하기 때문에 다음과 같이 동작합니다.
alert(arr.move(0,2).join(','));
2c. 읽기 쉽고, 동작도 빠르고, 새로운 어레이를 작성하지 않습니다.
function move(array, from, to) {
if( to === from ) return array;
var target = array[from];
var increment = to < from ? -1 : 1;
for(var k = from; k != to; k += increment){
array[k] = array[k + increment];
}
array[to] = target;
return array;
}
어레이 크기를 일정하게 유지하기 위해 이동하는 아이템 대신 무언가를 푸시하는 @Reid에서 아이디어를 얻었습니다.그러면 계산이 간단해집니다.또한 빈 개체를 푸시하면 나중에 고유하게 검색할 수 있다는 이점이 있습니다.이것은 두 개체가 동일한 개체를 참조할 때까지 동일하지 않기 때문에 작동합니다.
({}) == ({}); // false
여기 소스 어레이와 소스 대상 인덱스를 가져오는 함수가 있습니다.필요에 따라 Array.protype에 추가할 수 있습니다.
function moveObjectAtIndex(array, sourceIndex, destIndex) {
var placeholder = {};
// remove the object from its initial position and
// plant the placeholder object in its place to
// keep the array length constant
var objectToMove = array.splice(sourceIndex, 1, placeholder)[0];
// place the object in the desired position
array.splice(destIndex, 0, objectToMove);
// take out the temporary object
array.splice(array.indexOf(placeholder), 1);
}
여기 옵션 파라미터가 있는 하나의 라이너 ES6 솔루션이 있습니다.on.
if (typeof Array.prototype.move === "undefined") {
Array.prototype.move = function(from, to, on = 1) {
this.splice(to, 0, ...this.splice(from, on))
}
}
proposed by가 제안한 첫 번째 digiguru
'''on 、 。from이사하고 싶겠지
다음은 체인 가능한 변형입니다.
if (typeof Array.prototype.move === "undefined") {
Array.prototype.move = function(from, to, on = 1) {
return this.splice(to, 0, ...this.splice(from, on)), this
}
}
[3, 4, 5, 1, 2].move(3, 0, 2) // => [1, 2, 3, 4, 5]
시제품 오염을 피하고 싶다면 다음과 같은 기능이 있습니다.
function move(array, from, to, on = 1) {
return array.splice(to, 0, ...array.splice(from, on)), array
}
move([3, 4, 5, 1, 2], 3, 0, 2) // => [1, 2, 3, 4, 5]
마지막으로, 원래의 어레이를 변환하지 않는 순수한 함수를 다음에 나타냅니다.
function moved(array, from, to, on = 1) {
return array = array.slice(), array.splice(to, 0, ...array.splice(from, on)), array
}
이는 기본적으로 다른 모든 답변에서 볼 수 있는 모든 변형을 포함해야 합니다.
이것은 @Reid의 솔루션에 근거하고 있습니다.제외:
- 는 ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
Array프로토타입입니다. - 을 범위를 해도 항목이 생성되지 .
undefined항목을 맨 오른쪽 위치로 이동합니다.
기능:
function move(array, oldIndex, newIndex) {
if (newIndex >= array.length) {
newIndex = array.length - 1;
}
array.splice(newIndex, 0, array.splice(oldIndex, 1)[0]);
return array;
}
유닛 테스트:
describe('ArrayHelper', function () {
it('Move right', function () {
let array = [1, 2, 3];
arrayHelper.move(array, 0, 1);
assert.equal(array[0], 2);
assert.equal(array[1], 1);
assert.equal(array[2], 3);
})
it('Move left', function () {
let array = [1, 2, 3];
arrayHelper.move(array, 1, 0);
assert.equal(array[0], 2);
assert.equal(array[1], 1);
assert.equal(array[2], 3);
});
it('Move out of bounds to the left', function () {
let array = [1, 2, 3];
arrayHelper.move(array, 1, -2);
assert.equal(array[0], 2);
assert.equal(array[1], 1);
assert.equal(array[2], 3);
});
it('Move out of bounds to the right', function () {
let array = [1, 2, 3];
arrayHelper.move(array, 1, 4);
assert.equal(array[0], 1);
assert.equal(array[1], 3);
assert.equal(array[2], 2);
});
});
몇 가지 기본적인 미적분을 구현하고 배열 요소를 한 위치에서 다른 위치로 이동하기 위한 범용 함수를 만들 수 있습니다.
JavaScript의 경우 다음과 같습니다.
function magicFunction (targetArray, indexFrom, indexTo) {
targetElement = targetArray[indexFrom];
magicIncrement = (indexTo - indexFrom) / Math.abs (indexTo - indexFrom);
for (Element = indexFrom; Element != indexTo; Element += magicIncrement){
targetArray[Element] = targetArray[Element + magicIncrement];
}
targetArray[indexTo] = targetElement;
}
자세한 내용은 "Gloommatter"에서 "이동 어레이 요소"를 참조하십시오.
의 '불변'을 ECMAScript 6 으로 한 @Merc님의 답변은 다음과 같습니다.
const moveItemInArrayFromIndexToIndex = (array, fromIndex, toIndex) => {
if (fromIndex === toIndex) return array;
const newArray = [...array];
const target = newArray[fromIndex];
const inc = toIndex < fromIndex ? -1 : 1;
for (let i = fromIndex; i !== toIndex; i += inc) {
newArray[i] = newArray[i + inc];
}
newArray[toIndex] = target;
return newArray;
};
변수 이름은 코드 자체를 설명할 수 있도록 긴 이름을 사용하여 단축할 수 있습니다.
슬라이스 방식을 사용하여 원하는 순서대로 조각을 사용하여 새 배열을 작성하는 방법이 있습니다.
예
var arr = [ 'a', 'b', 'c', 'd', 'e'];
var arr2 = arr.slice(0,1).concat( ['d'] ).concat( arr.slice(2,4) ).concat( arr.slice(4) );
- arr.syslog(0,1)는 [a']를 표시합니다.
- arr.disc(2,4)는 ['b', 'c']를 표시합니다.
- arr.filename(4)은 [e]를 제공합니다.
splice의 of의 Array도움이 될 수 있습니다.https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice
어레이를 적극적으로 재인덱스화해야 하므로 상대적으로 비용이 많이 들 수 있습니다.
ES6 어레이 확산 연산자를 사용한 다른 순수 JS 변종(변환 없음)
const reorder = (array, sourceIndex, destinationIndex) => {
const smallerIndex = Math.min(sourceIndex, destinationIndex);
const largerIndex = Math.max(sourceIndex, destinationIndex);
return [
...array.slice(0, smallerIndex),
...(sourceIndex < destinationIndex
? array.slice(smallerIndex + 1, largerIndex + 1)
: []),
array[sourceIndex],
...(sourceIndex > destinationIndex
? array.slice(smallerIndex, largerIndex)
: []),
...array.slice(largerIndex + 1),
];
}
// returns ['a', 'c', 'd', 'e', 'b', 'f']
console.log(reorder(['a', 'b', 'c', 'd', 'e', 'f'], 1, 4))
원래 어레이를 변경하지 않은 불변의 이동 방법이 필요했기 때문에 스플라이스를 실행하기 전에 Object.assign을 사용하여 어레이의 복사본을 작성하도록 @Reid의 수락된 답변을 수정했습니다.
Array.prototype.immutableMove = function (old_index, new_index) {
var copy = Object.assign([], this);
if (new_index >= copy.length) {
var k = new_index - copy.length;
while ((k--) + 1) {
copy.push(undefined);
}
}
copy.splice(new_index, 0, copy.splice(old_index, 1)[0]);
return copy;
};
여기 jsfiddle이 동작하고 있는 것을 나타내고 있습니다.
여기 불변의 방법으로 그것을 하는 한 가지 방법이 있다.음수뿐만 아니라 추가 보너스도 처리합니다.이것에 의해, 원래의 어레이를 편집하는 것에 비해, 퍼포먼스를 희생해 버그의 발생을 줄일 수 있습니다.
const numbers = [1, 2, 3];
const moveElement = (array, from, to) => {
const copy = [...array];
const valueToMove = copy.splice(from, 1)[0];
copy.splice(to, 0, valueToMove);
return copy;
};
console.log(moveElement(numbers, 0, 2))
// > [2, 3, 1]
console.log(moveElement(numbers, -1, -3))
// > [3, 1, 2]
Array.prototype.moveUp = function (value, by) {
var index = this.indexOf(value),
newPos = index - (by || 1);
if (index === -1)
throw new Error("Element not found in array");
if (newPos < 0)
newPos = 0;
this.splice(index, 1);
this.splice(newPos, 0, value);
};
Array.prototype.moveDown = function (value, by) {
var index = this.indexOf(value),
newPos = index + (by || 1);
if (index === -1)
throw new Error("Element not found in array");
if (newPos >= this.length)
newPos = this.length;
this.splice(index, 1);
this.splice(newPos, 0, value);
};
var arr = ['banana', 'curyWurst', 'pc', 'remembaHaruMembaru'];
alert('withiout changes= '+arr[0]+' ||| '+arr[1]+' ||| '+arr[2]+' ||| '+arr[3]);
arr.moveDown(arr[2]);
alert('third word moved down= '+arr[0] + ' ||| ' + arr[1] + ' ||| ' + arr[2] + ' ||| ' + arr[3]);
arr.moveUp(arr[2]);
alert('third word moved up= '+arr[0] + ' ||| ' + arr[1] + ' ||| ' + arr[2] + ' ||| ' + arr[3]);
http://plnkr.co/edit/JaiAaO7FQcdPGPY6G337?p=preview
저는 불변의 기능적인 라이너를 좋아합니다:) ...
const swapIndex = (array, from, to) => (
from < to
? [...array.slice(0, from), ...array.slice(from + 1, to + 1), array[from], ...array.slice(to + 1)]
: [...array.slice(0, to), array[from], ...array.slice(to, from), ...array.slice(from + 1)]
);
Array 프로토타입에서 사용자 지정 기능을 추가하는 것은 좋지 않을 수 있습니다.어쨌든 여러 게시물의 최고 기능을 조합하여 최신 Javascript를 사용하여 다음과 같이 제공했습니다.
Object.defineProperty(Array.prototype, 'immutableMove', {
enumerable: false,
value: function (old_index, new_index) {
var copy = Object.assign([], this)
if (new_index >= copy.length) {
var k = new_index - copy.length;
while ((k--) + 1) { copy.push(undefined); }
}
copy.splice(new_index, 0, copy.splice(old_index, 1)[0]);
return copy
}
});
//how to use it
myArray=[0, 1, 2, 3, 4];
myArray=myArray.immutableMove(2, 4);
console.log(myArray);
//result: 0, 1, 3, 4, 2
희망은 누구에게나 도움이 될 수 있다.
이 버전이 모든 목적에 이상적인 것은 아니며, 모든 사람이 콤마 표현을 좋아하는 것은 아니지만, 여기에 새로운 복사본을 만드는 순수한 표현인 한 줄의 단어가 있습니다.
const move = (from, to, ...a) => (a.splice(to, 0, ...a.splice(from, 1)), a)
성능이 약간 향상된 버전은 이동할 필요가 없는 경우 입력 어레이를 반환합니다. 어레이는 변경되지 않고 순수한 표현이기 때문에 불변의 사용이 가능합니다.
const move = (from, to, ...a) =>
from === to
? a
: (a.splice(to, 0, ...a.splice(from, 1)), a)
어느 쪽인가의 호출은
const shuffled = move(fromIndex, toIndex, ...list)
즉, 새로운 복사본을 생성하기 위해 확산에 의존합니다. 3 정 using3move 합니다.splice다시 말씀드리지만, 실제 가동 환경에 대한 제안이라기보다는 몇 가지 기준을 충족하는 예에 가깝습니다.
const move = (from, to, ...a) =>from === to ? a : (a.splice(to, 0, ...a.splice(from, 1)), a);
const moved = move(0, 2, ...['a', 'b', 'c']);
console.log(moved)나는 이것이 교환의 문제라고 생각했지만 그렇지 않다.한 가지 솔루션을 소개합니다.
const move = (arr, from, to) => arr.map((item, i) => i === to ? arr[from] : (i >= Math.min(from, to) && i <= Math.max(from, to) ? arr[i + Math.sign(to - from)] : item));
다음은 간단한 테스트입니다.
let test = ['a', 'b', 'c', 'd', 'e'];
console.log(move(test, 0, 2)); // [ 'b', 'c', 'a', 'd', 'e' ]
console.log(move(test, 1, 3)); // [ 'a', 'c', 'd', 'b', 'e' ]
console.log(move(test, 2, 4)); // [ 'a', 'b', 'd', 'e', 'c' ]
console.log(move(test, 2, 0)); // [ 'c', 'a', 'b', 'd', 'e' ]
console.log(move(test, 3, 1)); // [ 'a', 'd', 'b', 'c', 'e' ]
console.log(move(test, 4, 2)); // [ 'a', 'b', 'e', 'c', 'd' ]
console.log(move(test, 4, 0)); // [ 'e', 'a', 'b', 'c', 'd' ]
이것은 스플라이스를 사용하는 매우 간단한 방법입니다.
Array.prototype.moveToStart = function(index) {
this.splice(0, 0, this.splice(index, 1)[0]);
return this;
};
저는 이 두 가지를 조합하여 작은 거리와 먼 거리를 이동할 때 조금 더 잘 작동하게 되었습니다.꽤 일관된 결과를 얻을 수 있지만, 저보다 똑똑한 사람이 크기를 달리해서 작업하도록 약간 조정할 수도 있습니다.
물체를 작은 거리로 이동할 때 다른 방법을 사용하는 것이 스플라이스를 사용하는 것보다 훨씬 더 빨랐다(x10).이는 어레이 길이에 따라 달라질 수 있지만 대규모 어레이의 경우에는 해당됩니다.
function ArrayMove(array, from, to) {
if ( Math.abs(from - to) > 60) {
array.splice(to, 0, array.splice(from, 1)[0]);
} else {
// works better when we are not moving things very far
var target = array[from];
var inc = (to - from) / Math.abs(to - from);
var current = from;
for (; current != to; current += inc) {
array[current] = array[current + inc];
}
array[to] = target;
}
}
https://web.archive.org/web/20181026015711/https://jsperf.com/arraymove-many-sizes
한 가지 접근법은splice()항목을 배열에서 제거한 후 를 사용하여splice()다시 한 번 메서드를 사용하여 제거된 항목을 대상 인덱스에 삽입합니다.
const array = ['a', 'b', 'c', 'd', 'e']
const newArray = moveItem(array, 3, 1) // move element from index 3 to index 1
function moveItem(arr, fromIndex, toIndex){
let itemRemoved = arr.splice(fromIndex, 1) // assign the removed item as an array
arr.splice(toIndex, 0, itemRemoved[0]) // insert itemRemoved into the target index
return arr
}
console.log(newArray)Array.move.js
요약
배열 내에서 요소를 이동하고 이동된 요소를 포함하는 배열을 반환합니다.
구문
array.move(index, howMany, toIndex);
파라미터
index: 요소를 이동하는 인덱스.음수인 경우 인덱스는 끝에서 시작됩니다.
수: 인덱스에서 이동할 요소의 수.
toIndex: 이동된 요소를 배치할 배열 색인입니다.음수인 경우 toIndex는 끝에서 시작됩니다.
사용.
array = ["a", "b", "c", "d", "e", "f", "g"];
array.move(3, 2, 1); // returns ["d","e"]
array; // returns ["a", "d", "e", "b", "c", "f", "g"]
폴리필
Array.prototype.move || Object.defineProperty(Array.prototype, "move", {
value: function (index, howMany, toIndex) {
var
array = this,
index = parseInt(index) || 0,
index = index < 0 ? array.length + index : index,
toIndex = parseInt(toIndex) || 0,
toIndex = toIndex < 0 ? array.length + toIndex : toIndex,
toIndex = toIndex <= index ? toIndex : toIndex <= index + howMany ? index : toIndex - howMany,
moved;
array.splice.apply(array, [toIndex, 0].concat(moved = array.splice(index, howMany)));
return moved;
}
});
@Reid의 좋은 답변을 사용했지만 요소를 배열 끝에서 선두로 한 단계 더 이동시키는 데 어려움을 겪었습니다(루프처럼).예: ['a', 'b', 'c']는 .move(2,3)를 호출하여 ['c', 'a', 'b']가 되어야 합니다.
new_index > = this.length의 케이스를 변경하여 구현했습니다.
Array.prototype.move = function (old_index, new_index) {
console.log(old_index + " " + new_index);
while (old_index < 0) {
old_index += this.length;
}
while (new_index < 0) {
new_index += this.length;
}
if (new_index >= this.length) {
new_index = new_index % this.length;
}
this.splice(new_index, 0, this.splice(old_index, 1)[0]);
return this; // for testing purposes
};
Reid의 훌륭한 답변에 덧붙여 (그리고 나는 코멘트를 할 수 없기 때문에)모듈로를 사용하여 음수 인덱스와 너무 큰 인덱스를 모두 "롤오버"할 수 있습니다.
function array_move(arr, old_index, new_index) {
new_index =((new_index % arr.length) + arr.length) % arr.length;
arr.splice(new_index, 0, arr.splice(old_index, 1)[0]);
return arr; // for testing
}
// returns [2, 1, 3]
console.log(array_move([1, 2, 3], 0, 1)); let ar = ['a', 'b', 'c', 'd'];
function change( old_array, old_index , new_index ){
return old_array.map(( item , index, array )=>{
if( index === old_index ) return array[ new_index ];
else if( index === new_index ) return array[ old_index ];
else return item;
});
}
let result = change( ar, 0, 1 );
console.log( result );
결과:
["b", "a", "c", "d"]
var ELEMS = ['a', 'b', 'c', 'd', 'e'];
/*
Source item will remove and it will be placed just after destination
*/
function moveItemTo(sourceItem, destItem, elements) {
var sourceIndex = elements.indexOf(sourceItem);
var destIndex = elements.indexOf(destItem);
if (sourceIndex >= -1 && destIndex > -1) {
elements.splice(destIndex, 0, elements.splice(sourceIndex, 1)[0]);
}
return elements;
}
console.log('Init: ', ELEMS);
var result = moveItemTo('a', 'c', ELEMS);
console.log('BeforeAfter: ', result); let oldi, newi, arr;
if(newi !== oldi) {
let el = this.arr.splice(oldi, 1);
if(newi > oldi && newi === (this.arr.length + 2)) {
this.arr.push("");
}
this.arr.splice(newi, 0, el);
if(newi > oldi && newi === (this.arr.length + 2)) {
this.arr.pop();
}
}언급URL : https://stackoverflow.com/questions/5306680/move-an-array-element-from-one-array-position-to-another
'source' 카테고리의 다른 글
| Python에서 문자열을 utf-8로 변환하는 방법 (0) | 2022.09.14 |
|---|---|
| UNIX 타임스탬프를 포맷된 날짜 문자열로 변환 (0) | 2022.09.14 |
| WHERE 절의 조건 순서가 MySQL 성능에 영향을 미칩니까? (0) | 2022.09.14 |
| PHP 5.2.8에서 두 개의 Date Time 개체를 비교하려면 어떻게 해야 합니까? (0) | 2022.09.14 |
| Vuex getter가 업데이트되지 않음 (0) | 2022.09.14 |