JavaScript에서 2차원 배열을 작성하려면 어떻게 해야 합니까?
인터넷에서 읽었는데 안 된다고 하는 곳도 있고, 안 된다고 하는 사람도 있고, 예를 들면 반박하는 사람도 있습니다.
JavaScript에서 2차원 어레이를 선언하려면 어떻게 해야 합니까?(가능하다고 생각됩니다)
멤에접 속 ( ( ( ( ((?()
myArray[0][1]★★★★★★★★★★★★★★★★★」myArray[0,1]
var items = [
[1, 2],
[3, 4],
[5, 6]
];
console.log(items[0][0]); // 1
console.log(items[0][1]); // 2
console.log(items[1][0]); // 3
console.log(items[1][1]); // 4
console.log(items);배열 내의 각 항목을 배열로 만들기만 하면 됩니다.
var x = new Array(10);
for (var i = 0; i < x.length; i++) {
x[i] = new Array(3);
}
console.log(x);activa의 답변과 마찬가지로 n차원 배열을 만드는 기능이 있습니다.
function createArray(length) {
var arr = new Array(length || 0),
i = length;
if (arguments.length > 1) {
var args = Array.prototype.slice.call(arguments, 1);
while(i--) arr[length-1 - i] = createArray.apply(this, args);
}
return arr;
}
createArray(); // [] or new Array()
createArray(2); // new Array(2)
createArray(3, 2); // [new Array(2),
// new Array(2),
// new Array(2)]
빈 2차원 어레이 작성 방법(1줄)
Array.from(Array(2), () => new Array(4))
2와 4는 각각 1차원과 2차원이 된다.
각 요소에 대해 어레이와 같은 파라미터와 옵션 매핑을 사용할 수 있는 를 사용하고 있습니다.
Array.from(arrayLike[, mapFn[, thisArg])
var arr = Array.from(Array(2), () => new Array(4));
arr[0][0] = 'foo';
console.info(arr);1을 포함하는 JavaScript 배열을 작성하는 경우에도 같은 트릭을 사용할 수 있습니다.N
다른 방법(단, 12%로 효율이 떨어짐)n = 10,000)
Array(2).fill(null).map(() => Array(4))
은 첫 번째 입니다..map.Array에서는, 할 때까지, 되지 않습니다..fill★★★★★★★★★★★★★★★★★」
var arr = Array(2).fill(null).map(() => Array(4));
arr[0][0] = 'foo';
console.info(arr);따르다
다음은 올바른 방법이지만 문제가 있는 방법입니다.
Array(2).fill(Array(4)); // BAD! Rows are copied by reference
2차원 배열필요차 2차원 배열)이 반환됩니다.[ [ <4 empty items> ], [ <4 empty items> ] ] 번째 에 의해 을 사용하다첫 번째 치수 어레이는 참조에 의해 복사되었습니다., ,, ,, ,, ,, ,, ,.arr[0][0] = 'foo'을 사용하다
var arr = Array(2).fill(Array(4));
arr[0][0] = 'foo';
console.info(arr);
console.info(arr[0][0], arr[1][0]);Javascript에는 1차원 배열만 있지만 다른 사람들이 지적한 것처럼 배열 배열을 구축할 수 있습니다.
다음 함수를 사용하여 고정 치수의 2-d 배열을 구성할 수 있습니다.
function Create2DArray(rows) {
var arr = [];
for (var i=0;i<rows;i++) {
arr[i] = [];
}
return arr;
}
어레이를 사용하기 전에 어레이 크기를 지정할 필요가 없기 때문에 열의 수는 그다지 중요하지 않습니다.
그럼 다음 번호로 전화하시면 됩니다.
var arr = Create2DArray(100);
arr[50][2] = 5;
arr[70][5] = 7454;
// ...
가장 쉬운 방법:
var myArray = [[]];
이것이 불가능한 이유는 2차원 어레이는 실제로는 어레이의 배열에 불과하기 때문입니다.다른 코멘트는 JavaScript에서 2차원 배열을 작성하는 완전히 유효한 방법을 제공하지만, 가장 순수한 관점에서는 오브젝트의 1차원 배열을 가지고 있으며, 각 오브젝트는 2개의 요소로 이루어진 1차원 배열이 됩니다.
그래서 그것이 상반된 관점의 원인입니다.
이치노
새로운 것을 가져오려면 , 0이나 빈 문자열 「」등의 값을 사용해 매트릭스를 초기화하는 방법을 나타냅니다.
배열이 는 910입니다.
function matrix( rows, cols, defaultValue){
var arr = [];
// Creates all lines:
for(var i=0; i < rows; i++){
// Creates an empty line
arr.push([]);
// Adds cols to the empty line:
arr[i].push( new Array(cols));
for(var j=0; j < cols; j++){
// Initializes:
arr[i][j] = defaultValue;
}
}
return arr;
}
사용 예:
x = matrix( 2 , 3,''); // 2 lines, 3 cols filled with empty string
y = matrix( 10, 5, 0);// 10 lines, 5 cols filled with 0
두 줄:
var a = [];
while(a.push([]) < 10);
배열로 채워진 길이 10의 배열 a를 생성합니다(Push를 누르면 배열에 요소가 추가되고 새 길이가 반환됩니다).
가장 분별 있는 대답은
var nrows = ~~(Math.random() * 10);
var ncols = ~~(Math.random() * 10);
console.log(`rows:${nrows}`);
console.log(`cols:${ncols}`);
var matrix = new Array(nrows).fill(0).map(row => new Array(ncols).fill(0));
console.log(matrix);채우기는 얕은 복사 생성자를 사용하기 때문에 모든 행이 동일한 메모리를 공유하므로 행으로 직접 채울 수 없습니다.다음은 각 행의 공유 방법을 보여 주는 예입니다(다른 답변에서 인용).
// DON'T do this: each row in arr, is shared
var arr = Array(2).fill(Array(4));
arr[0][0] = 'foo'; // also modifies arr[1][0]
console.info(arr);
가장 쉬운 방법:
var arr = [];
var arr1 = ['00','01'];
var arr2 = ['10','11'];
var arr3 = ['20','21'];
arr.push(arr1);
arr.push(arr2);
arr.push(arr3);
alert(arr[0][1]); // '01'
alert(arr[1][1]); // '11'
alert(arr[2][0]); // '20'
4x6 어레이를 작성하려면 다음 절차를 따릅니다.
const x = [...new Array(6)].map(elem => new Array(4))
()이라고 선언합니다.const x = []하는 것이 2D에서는 빈 상태로 하는 것이 좋습니다.)
이것이 제가 달성한 것입니다.
var appVar = [[]];
appVar[0][4] = "bineesh";
appVar[0][5] = "kumar";
console.log(appVar[0][4] + appVar[0][5]);
console.log(appVar);이것은 나를 비네슈쿠마로 만들었다.
성능
오늘 2020.02.05 Chrome v79.0, Safari v13.0.4 및 Firefox v72.0에서 MacOs HighSierra 10.13.6에서 선택한 솔루션에 대한 테스트를 수행합니다.
초기화되지 않은 2D 어레이에 대한 결론
- 용액
{}/arr[[i,j]]은 큰 어레이와 큰 스파스 (N)에 합니다. - 「 」에
for-[]/while(A, G) ( ( 、 몰 ( 、 ( ( ( ( ( ( ( ( ( 。 - ★★★
for-[]이며, 어레이(B,C)에 합니다. - 「 」에
Array..map/from/fill어레이(I,J,K,L,M)에서는 매우 . for-Array(n)에서 (B,는 (B,C) 사파리보다for-[](A)for-[]가 모든 (A)- 솔루션 K는 모든 브라우저의 소형 어레이에 대해 느리다
- 솔루션 A, E, G는 모든 브라우저의 대규모 어레이에서 느리다
- 솔루션 M은 모든 브라우저의 모든 어레이에서 가장 느리다
초기화된 2D 어레이의 결론
- 「 」에
for/while는 모든 (A,B,C,D,E,G)의입니다. - 「 」에
for는 모든 (A,B,C,E)의 빅 매우입니다. - 「 」에
Array..map/from/fill(I,J,K,L,M)는 모든 브라우저의 소형 어레이에 대해 보통 고속 또는 저속 - 대규모 어레이용 솔루션 F, G, H, I, J, K, L은 크롬 및 사파리에서는 중간 또는 고속이지만 파이어폭스에서는 속도가 가장 느립니다.
- 난해 용액
{}/arr[[i,j]](N)는 모든 브라우저의 소형 및 대형 어레이에서 가장 느림
세부 사항
출력 어레이를 채우지 않는(초기화) 솔루션을 테스트합니다.
솔루션의 속도를 테스트합니다.
- 스몰 어레이 (12 요소) - 사용하시는 머신에 대한 테스트는 이쪽에서 실시하실 수 있습니다.
- 대규모 어레이(100만 요소) 어레이 - 여기에서 머신 테스트를 수행할 수 있습니다.
function A(r) {
var arr = [];
for (var i = 0; i < r; i++) arr[i] = [];
return arr;
}
function B(r, c) {
var arr = new Array(r);
for (var i = 0; i < arr.length; i++) arr[i] = new Array(c);
return arr;
}
function C(r, c) {
var arr = Array(r);
for (var i = 0; i < arr.length; i++) arr[i] = Array(c);
return arr;
}
function D(r, c) {
// strange, but works
var arr = [];
for (var i = 0; i < r; i++) {
arr.push([]);
arr[i].push(Array(c));
}
return arr;
}
function E(r, c) {
let array = [[]];
for (var x = 0; x < c; x++) {
array[x] = [];
for (var y = 0; y < r; y++) array[x][y] = [0];
}
return array;
}
function F(r, c) {
var makeArray = function(dims, arr) {
if (dims[1] === undefined) {
return Array(dims[0]);
}
arr = Array(dims[0]);
for (var i = 0; i < dims[0]; i++) {
arr[i] = Array(dims[1]);
arr[i] = makeArray(dims.slice(1), arr[i]);
}
return arr;
}
return makeArray([r, c]);
}
function G(r) {
var a = [];
while (a.push([]) < r);
return a;
}
function H(r,c) {
function createArray(length) {
var arr = new Array(length || 0),
i = length;
if (arguments.length > 1) {
var args = Array.prototype.slice.call(arguments, 1);
while(i--) arr[length-1 - i] = createArray.apply(this, args);
}
return arr;
}
return createArray(r,c);
}
function I(r, c) {
return [...Array(r)].map(x => Array(c));
}
function J(r, c) {
return Array(r).fill(0).map(() => Array(c));
}
function K(r, c) {
return Array.from(Array(r), () => Array(c));
}
function L(r, c) {
return Array.from({length: r}).map(e => Array(c));
}
function M(r, c) {
return Array.from({length: r}, () => Array.from({length: c}, () => {}));
}
function N(r, c) {
return {}
}
// -----------------------------------------------
// SHOW
// -----------------------------------------------
log = (t, f) => {
let A = f(3, 4); // create array with 3 rows and 4 columns
A[1][2] = 6 // 2-nd row 3nd column set to 6
console.log(`${t}[1][2]: ${A[1][2]}, full: ${JSON.stringify(A).replace(/null/g,'x')}`);
}
log2 = (t, f) => {
let A = f(3, 4); // create array with 3 rows and 4 columns
A[[1,2]] = 6 // 2-nd row 3nd column set to 6
console.log(`${t}[1][2]: ${A[[1,2]]}, full: ${JSON.stringify(A).replace(/null/g,'x')}`);
}
log('A', A);
log('B', B);
log('C', C);
log('D', D);
log('E', E);
log('F', F);
log('G', G);
log('H', H);
log('I', I);
log('J', J);
log('K', K);
log('L', L);
log('M', M);
log2('N', N);This is presentation of solutions - not benchmark출력 어레이를 채우는(초기화하는) 솔루션을 테스트합니다.
솔루션의 속도를 테스트합니다.
- 스몰 어레이 (12 요소) - 사용하시는 머신에 대한 테스트는 이쪽에서 실시하실 수 있습니다.
- 대규모 어레이(100만 요소) 어레이 - 여기에서 머신 테스트를 수행할 수 있습니다.
function A(r, c, def) {
var arr = [];
for (var i = 0; i < r; i++) arr[i] = Array(c).fill(def);
return arr;
}
function B(r, c, def) {
var arr = new Array(r);
for (var i = 0; i < arr.length; i++) arr[i] = new Array(c).fill(def);
return arr;
}
function C(r, c, def) {
var arr = Array(r);
for (var i = 0; i < arr.length; i++) arr[i] = Array(c).fill(def);
return arr;
}
function D(r, c, def) {
// strange, but works
var arr = [];
for (var i = 0; i < r; i++) {
arr.push([]);
arr[i].push(Array(c));
}
for (var i = 0; i < r; i++) for (var j = 0; j < c; j++) arr[i][j]=def
return arr;
}
function E(r, c, def) {
let array = [[]];
for (var x = 0; x < c; x++) {
array[x] = [];
for (var y = 0; y < r; y++) array[x][y] = def;
}
return array;
}
function F(r, c, def) {
var makeArray = function(dims, arr) {
if (dims[1] === undefined) {
return Array(dims[0]).fill(def);
}
arr = Array(dims[0]);
for (var i = 0; i < dims[0]; i++) {
arr[i] = Array(dims[1]);
arr[i] = makeArray(dims.slice(1), arr[i]);
}
return arr;
}
return makeArray([r, c]);
}
function G(r, c, def) {
var a = [];
while (a.push(Array(c).fill(def)) < r);
return a;
}
function H(r,c, def) {
function createArray(length) {
var arr = new Array(length || 0),
i = length;
if (arguments.length > 1) {
var args = Array.prototype.slice.call(arguments, 1);
while(i--) arr[length-1 - i] = createArray.apply(this, args).fill(def);
}
return arr;
}
return createArray(r,c);
}
function I(r, c, def) {
return [...Array(r)].map(x => Array(c).fill(def));
}
function J(r, c, def) {
return Array(r).fill(0).map(() => Array(c).fill(def));
}
function K(r, c, def) {
return Array.from(Array(r), () => Array(c).fill(def));
}
function L(r, c, def) {
return Array.from({length: r}).map(e => Array(c).fill(def));
}
function M(r, c, def) {
return Array.from({length: r}, () => Array.from({length: c}, () => def));
}
function N(r, c, def) {
let arr={};
for (var i = 0; i < r; i++) for (var j = 0; j < c; j++) arr[[i,j]]=def;
return arr;
}
// -----------------------------------------------
// SHOW
// -----------------------------------------------
log = (t, f) => {
let A = f(1000,1000,7); // create array with 1000 rows and 1000 columns,
// each array cell initilised by 7
A[800][900] = 5 // 800nd row and 901nd column set to 5
console.log(`${t}[1][2]: ${A[1][2]}, ${t}[800][901]: ${A[800][900]}`);
}
log2 = (t, f) => {
let A = f(1000,1000,7); // create array with 1000 rows and 1000 columns,
// each array cell initilised by 7
A[[800,900]] = 5 // 800nd row 900nd column set to 5
console.log(`${t}[1][2]: ${A[[1,2]]}, ${t}[800][900]: ${A[[800,900]]}`);
}
log('A', A);
log('B', B);
log('C', C);
log('D', D);
log('E', E);
log('F', F);
log('G', G);
log('H', H);
log('I', I);
log('J', J);
log('K', K);
log('L', L);
log('M', M);
log2('N', N);This is presentation of solutions - not benchmark
2차원 어레이는 1차원 어레이와 같은 방법으로 작성됩니다.그리고 당신은 그들에게 접근한다array[0][1].
var arr = [1, 2, [3, 4], 5];
alert (arr[2][1]); //alerts "4"
이 질문에 대답한 사람이 있는지 모르겠지만, 저는 이것이 꽤 효과가 있다는 것을 알았습니다.
var array = [[,],[,]]
예:
var a = [[1,2],[3,4]]
예를 들어 2차원 어레이의 경우.
모든 인덱스를 주소 지정할 수 있고 값이 null로 설정된 비희박 "2D" 어레이(x,y)를 생성하려면:
let 2Darray = new Array(x).fill(null).map(item =>(new Array(y).fill(null)))
보너스 '3D' 어레이 (x,y,z)
let 3Darray = new Array(x).fill(null).map(item=>(new Array(y).fill(null)).map(item=>Array(z).fill(null)))
이에 대한 변주 및 수정은 이 질문에 대한 답변으로 댓글과 여러 점에서 언급되었지만 실제 답변으로 언급되지는 않았기 때문에 여기에 추가하겠습니다.
(다른 대부분의 답변과 마찬가지로) O(x*y) 시간의 복잡성이 있기 때문에 매우 큰 어레이에는 적합하지 않을 수 있습니다.
// creates 8x8 array filed with "0"
const arr2d = Array.from({ length: 8 }, () => Array.from({ length: 8 }, () => "0"))
(dmitry_omanov의 코멘트에서) 다른 하나는 Array().fill()을 사용합니다.
// creates 8x8 array filed with "0"
const arr2d = Array(8).fill(0).map(() => Array(8).fill("0"))
ES6+ 스프레드 오퍼레이터 사용('Inspired'에서 영감을 얻은')JW의 답변 :)
// same as above just a little shorter
const arr2d = [...Array(8)].map(() => Array(8).fill("0"))
JavaScript에서 2D 어레이를 작성하려면 먼저 어레이를 작성한 후 어레이를 요소로 추가합니다.이 메서드는 지정된 수의 행과 열을 가진 2D 배열을 반환합니다.
function Create2DArray(rows,columns) {
var x = new Array(rows);
for (var i = 0; i < rows; i++) {
x[i] = new Array(columns);
}
return x;
}
어레이를 작성하려면 다음 방법을 사용합니다.
var array = Create2DArray(10,20);
실행 시에만 알려진 배열의 행 및 열 크기를 사용하여 동적 2D 어레이를 만들 수 있습니다.
var num = '123456';
var row = 3; // Known at run time
var col = 2; // Known at run time
var i = 0;
var array2D = [[]];
for(var r = 0; r < row; ++r)
{
array2D[r] = [];
for(var c = 0; c < col; ++c)
{
array2D[r][c] = num[i++];
}
}
console.log(array2D);
// [[ '1', '2' ],
// [ '3', '4' ],
// [ '5', '6' ]]
console.log(array2D[2][1]); // 6어레이 통합 사용
JavaScript 1.7 이상에서는 어레이 통합을 사용하여 2차원 어레이를 만들 수 있습니다.또한 어레이를 채우는 동안 엔트리를 필터링하거나 조작할 수 있으므로 루프를 사용할 필요가 없습니다.
var rows = [1, 2, 3];
var cols = ["a", "b", "c", "d"];
var grid = [ for (r of rows) [ for (c of cols) r+c ] ];
/*
grid = [
["1a","1b","1c","1d"],
["2a","2b","2c","2d"],
["3a","3b","3c","3d"]
]
*/
것도 수 요.n x m를 선택하고 합니다.
var default = 0; // your 2d array will be filled with this value
var n_dim = 2;
var m_dim = 7;
var arr = [ for (n of Array(n_dim)) [ for (m of Array(m_dim) default ]]
/*
arr = [
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
]
*/
더 많은 예시와 문서는 여기에서 찾을 수 있습니다.
이 기능은 아직 표준 기능이 아닙니다.
Array(m).fill(v).map(() => Array(n).fill(v))
배열 2차원 배열을 수 .m x n '''로m ★★★★★★★★★★★★★★★★★」n의 를 사용할 수 v의 값을 할 수 .string,number,undefined.
한 가지 접근방식이 될 수 있습니다.var a = [m][n]
저의 접근법은 @Binesh의 답변과 매우 유사하지만 보다 일반적인 접근법입니다.
다음과 같이 이중 배열을 선언할 수 있습니다.
var myDoubleArray = [[]];
그리고 콘텐츠의 저장 및 접근은 다음과 같습니다.
var testArray1 = [9,8]
var testArray2 = [3,5,7,9,10]
var testArray3 = {"test":123}
var index = 0;
myDoubleArray[index++] = testArray1;
myDoubleArray[index++] = testArray2;
myDoubleArray[index++] = testArray3;
console.log(myDoubleArray[0],myDoubleArray[1][3], myDoubleArray[2]['test'],)
그러면 예상 출력이 출력됩니다.
[ 9, 8 ] 9 123
가장 간단한 방법은 다음과 같습니다.
var array1 = [[]];
array1[0][100] = 5;
alert(array1[0][100]);
alert(array1.length);
alert(array1[0].length);var playList = [
['I Did It My Way', 'Frank Sinatra'],
['Respect', 'Aretha Franklin'],
['Imagine', 'John Lennon'],
['Born to Run', 'Bruce Springsteen'],
['Louie Louie', 'The Kingsmen'],
['Maybellene', 'Chuck Berry']
];
function print(message) {
document.write(message);
}
function printSongs( songs ) {
var listHTML;
listHTML = '<ol>';
for ( var i = 0; i < songs.length; i += 1) {
listHTML += '<li>' + songs[i][0] + ' by ' + songs[i][1] + '</li>';
}
listHTML += '</ol>';
print(listHTML);
}
printSongs(playList);ES6+, ES2015+는 이를 더욱 심플하게 실현
True로 채워진 3x2 어레이 작성
[...Array(3)].map(item => Array(2).fill(true))
필요에 따라 레코드를 추가할 수 있는 유연한 배열 함수를 만들어야 했고, 레코드를 업데이트하고 필요한 계산을 수행한 후 데이터베이스로 전송해야 했습니다.여기 코드가 있습니다. 도움이 되길 바랍니다. :)
function Add2List(clmn1, clmn2, clmn3) {
aColumns.push(clmn1,clmn2,clmn3); // Creates array with "record"
aLine.splice(aPos, 0,aColumns); // Inserts new "record" at position aPos in main array
aColumns = []; // Resets temporary array
aPos++ // Increments position not to overlap previous "records"
}
버그를 최적화하거나 지적할 수 있습니다.
Javascript는 2차원 어레이를 지원하지 않습니다.대신 어레이를 다른 어레이 안에 저장하고 액세스하려는 어레이의 위치에 따라 해당 어레이에서 데이터를 가져옵니다.어레이의 번호는 0부터 시작합니다.
코드 예:
/* Two dimensional array that's 5 x 5
C0 C1 C2 C3 C4
R0[1][1][1][1][1]
R1[1][1][1][1][1]
R2[1][1][1][1][1]
R3[1][1][1][1][1]
R4[1][1][1][1][1]
*/
var row0 = [1,1,1,1,1],
row1 = [1,1,1,1,1],
row2 = [1,1,1,1,1],
row3 = [1,1,1,1,1],
row4 = [1,1,1,1,1];
var table = [row0,row1,row2,row3,row4];
console.log(table[0][0]); // Get the first item in the array
여기 2차원 어레이를 만드는 빠른 방법이 있습니다.
function createArray(x, y) {
return Array.apply(null, Array(x)).map(e => Array(y));
}
이 기능을 ES5 기능으로 쉽게 전환할 수 있습니다.
function createArray(x, y) {
return Array.apply(null, Array(x)).map(function(e) {
return Array(y);
});
}
: " " " " " "new Array(n)컨스트럭터는 시제품으로 객체를 만듭니다.Array.prototype 그 and and and and the 、 당 、 당 、 당 、 and the 、 the the and and 。length이로 인해 어레이가 채워지지 않습니다. ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★Array.prototype.map기능을 합니다.
예: " " " " " 를 사용하는 :Array(1, 2, 3, 4)는 , 을 합니다.arguments인스턴스화 및 채우는 오브젝트Array이치노
때문에 는 '어울리다', '어울리다', '어울리다', 이렇게 쓸 수 있어요.Array.apply(null, Array(x))「」이 있기 때문에apply함수를 지정하면 인수가 생성자로 확산됩니다.쉽게 말하면, 「 」를 실행해 주세요.Array.apply(null, Array(3)) 것과 Array(null, null, null).
어레이를 「」에 전화하기만 .map 레이어레이어)를 .y를 참조해 주세요.
1개의 라이너로 0으로 채워진 m*n 2차원 배열을 작성합니다.
new Array(m).fill(new Array(n).fill(0));
언급URL : https://stackoverflow.com/questions/966225/how-can-i-create-a-two-dimensional-array-in-javascript
'source' 카테고리의 다른 글
| Python 3에 'foreach' 기능이 있나요? (0) | 2022.10.19 |
|---|---|
| Node.js란? (0) | 2022.10.19 |
| MySQL 데이터 원본이 Visual Studio에 나타나지 않음 (0) | 2022.10.19 |
| 각도 2를 사용하여 인도 형식으로 숫자 표시 (0) | 2022.10.19 |
| PHP 변수는 값으로 전달됩니까, 참조로 전달됩니까? (0) | 2022.10.19 |