typeof []; //  'object'

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

const empty = []; // 빈 배열
const numbers = [1, 2, 3, 4, 5]; // 숫자가 들어간 배열
const strings = ["가", "나", "다", "라"]; // 문자열이 들어간 배열
const objects = [{ prop: 1 }, { prop: 2 }, { prop: 3 }]; // 객체가 들어있는 배열
const anything = [1, "가", { prop: 3 }, true]; // 다양한 타입의 값들이 들어간 배열

new Array(1); //  [<1 empty item>]
new Array(1000); //  [<1000 empty item>]

new Array(1, 2, 3); //  [1,2,3]

new Array(1, 2, 3); // [1,2,3] : 생성자는 이런 방식으로는 사용하지 않도록 합니다.
Array.of(1, 2, 3); // [1,2,3] : 가급적 Array.of로 하도록 합니다.

// Array.of 정적 메소드는 인수가 하나이더라도 그 인수를 요소로 갖는 배열을 갖습니다.
Array.of(1); //  [1]

// 생성자는 이런 용도로만 사용하도록 합니다.
new Array(1000); //  [<1000 empty item>]

//  'string' 타입은 래퍼 객체를 통해 iterable로 다루어질 수 있습니다.
Array.form("hello"); // ["h","e","l","l","o"]

const arr = ["one", "two", "three"];

arr[0]; //  'one'
arr[1]; //  'two'
arr[2]; //  'three'
arr[3]; //  undefined

const arr = [0, 1, 3, 3, 4];
arr[2] = 2;
console.log(arr); //  [0,1,2,3,4];

const arr = [0, 1, 2, 3, 4];

// 전체를 0으로 채우기
arr.fill(0);
console.log(arr); //  [0.0.0.0.0];

// 인덱스 1과 4사이를 1로 채우기
arr.fill(1, 1, 4); //  배열의이름.fill(채울값, 시작위치(포함), 종료위치(미포함))
console.log(arr); // [0,1,1,1,0];

new Array(1000); //  [<1000 empty item>]
new Array(1000).fill(5); //  [5,5,5,5,5...]

const arr = [];
arr.push("one"); //  1 (요소가 추가된 후의 배열의 길이를 반환함)
arr.push("two", "three"); // 3

console.log(arr); //  ['one', 'two', 'three']

// 배열의 요소 삭제하기

arr.pop(); // 'three' 삭제
arr.pop(); // 'two' 삭제
arr.pop(); // 'one' 삭제
arr.pop(); // undefined (더 이상 배열에서 요소가 남아있지 않으면 'undefined'를 반환합니다.)

const arr = [];
arr.unshift(1); //  1 (요소가 추가된 후의 배열의 길이를 반환함)
arr.unshift(2, 3); //  3

console.log(arr); //  [2,3,1]

// 배열의 요소 삭제하기
arr.shift(); //  2
arr.shift(); //  3
arr.shift(); //  1
arr.shift(); //  undefined (더 이상 배열에서 요소가 남아있지 않으면 'undefined'를 반환합니다.)

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

// 인덱스 1부터 3개를 바꿔칩니다.
// splice 메소드는 바꿔치기를 통해 제거된 요소를 반환합니다.

arr.splice(1, 3, "이", "삼", "사"); // 배열의이름.splice(인덱스시작지점, 바꿀개수, 바꿀 값)
console.log(arr); // [1, '이', '삼', '사', 5]

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

arr.splice(1, 3, "ㅇ");
console.log(arr); // [1,'o',5]

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

arr.splice(1, 3); //  [2,3,4]
console.log(arr); //  [1,5]

const arr = [1, 2, 3];

// 'reverse' 메소드는 'arr'을 뒤집은 후, 'arr'을 그대로 반환합니다.
arr.reverse(); //  [3,2,1]
console.log(arr); //  [3,2,1]

const arr = [3, 1, 4, 5, 2];

// sort 메소드는 arr을 비교 함수에 따라 정렬한 뒤, arr을 그대로 반환합니다.
arr.sort((a, b) => a - b); // 오림차순 정렬 [1,2,3,4,5];
console.log(arr); //  [1,2,3,4,5]

const names = ["moong2", "min_zzz", "jogoogod", "shinyerin"];
names.sort((x, y) => y.length - x.length); //  내림차순이니까 양수를 반환하기 위해 y를 앞에다가 둡니다.
console.log(names); //  [ 'shinyerin', 'jogoogod', 'min_zzz', 'moong2' ]

const arr = [1, 3, 2, 5, 4];
arr.sort(); // [1, 2, 3, 4, 5]

[20, 3, 100].sort(); //  [100, 20, 3] : 큰 수부터 정렬하는 것이 아니라 수의 첫 수를 보고 1,2,3 순으로 정렬이 된 것입니다.
["abc", "DEF", "aBC"].sort(); //  ["DEF", "aBC", "abc"]

[20, 3, 100].sort((x, y) => x - y); //  [3, 20, 100];
["abc", "DEF", "aBC"].sort((x, y) => x.localeCompare(y)); //  ['abc','aBC','DEF']

const arr = [];
console.log(arr.length); //  0

arr.push(1, 2, 3);
console.log(arr.length); //  3

const arr = [];

// 배열의 길이 늘이기
arr.length = 10;
console.log(arr); //  [ <10 empty items> ]

// 배열의 길이 줄이기 (줄어든 만큼 뒷쪽에 있는 요소들은 버려집니다.)
arr.fill(1); //  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
arr.length = 2;
console.log(arr); //  [1,1]

//이런 코드처럼 왠만하면 하지 않는 걸로

const arr = [1, 2, 3];

for (let i = 0; i < arr.length; i++) {
  console.log(arr[i]);
}

const str = [1, 2, 3];

arr.forEach(item => {
  consoel.log(`현재 요소 ${item}에 대해 함수가 실행되고 있습니다.`);
});

const arr = [1, 2, 3];
arr.forEach((item, index, array) => {
  console.log(`현재 ${index + 1}번째 요소에 대해 함수가 실행되고 있습니다.`);
});

const arr = [1, 2, 3, 4, 5];

for (let item of arr) {
  console.log(item);
}

// for문안에 (const item of arr)에서 const는 루프가 종료되고 다음 루프로 넘어갈때 선언이 날아가기 때문에 const를 써도 괜찮습니다.
const arr = [1, 2, 3, 4, 5];

for (const item of arr) {
  console.log(item);
}

const arr = [1, 2, 3, 4, 5];

// 인덱스 2부터 인덱스 4 사이의 요소들을 가지고 새로운 배열을 생성
const newArr = arr.slice(2, 4); //  [3,4]

// newArr을 조작해도, 원본에는 아무런 영향을 미치지 않습니다.
newArr[0] = 5;
console.log(newArr); //  [5,4]
consoel.log(arr); //  [1,2,3,4,5]

const arr2 = arr.slice(); //  [1,2,3,4,5];

const arr = [1, 2, 3, 4, 5];

// arr의 각 요소를 제곱한 값으로 새 배열을 만듭니다.
const newArr = arr.map(item => item ** 2);
console.log(newArr); //  [1,4,9,16,25]

arr.map((item, index, array) => {
  return item * index;
}); //  [0,2,6,12,20]

const arr = [1, 2];

arr.concat([3, 4], [5, 6], [7, 8]); //  [1,2,3,4,5,6,7,8]

const arr = [1, 2, 3];

arr.reduce((acc, item) => acc + item, 0); //  6
// 동작 방식은 acc += item 과 같다고 볼 수 있습니다.

const arr = ["one", "two", "three"];

arr.reduce((acc, item, index, array) => {
  return acc + `(${index}: ${item})`;
}, ""); // '(0:one)(1:two)(2:three)'

const arr = ["one"];

// 배열안의 요소들의 문자열의 합을 반환하고자 하는데 요소가 하나밖에 없습니다.
// 이런 경우에는 초기값을 안주면 계산할 대상이 자기 자신밖에 없어서 함수가 호출되지 못하고 one을 반환합니다.
arr.reduce((acc, item) => {
  return acc + item.length;
}); // 'one'

// 초기값을 주면 정상적으로 계산이 됩니다.
arr.reduce((acc, item) => {
  return acc + itme.length;
}, 0); //  3

// reduce를 통한 map 메소드 구현
function map(arr, func) {
  return arr.reduce((acc, item) => {
    acc.push(func(item));
    return acc;
  }, []);
}

map([1, 2, 3], x => x * 2);

// reduce를 통한 filter 메소드 구현
function filter(arr, func) {
  return arr.reduce((acc, item) => {
    if (func(item)) {
      acc.push(item);
    }
    return acc;
  }, []);
}

filter([1, 2, 3, 4, 5], x => x % 2 === 0);

// reduce를 통한 sort 메소드 구현
function sort(arr, func) {
  return arr.reduce((acc, item) => {
    let i;
    for (i = 0; i < acc.length; i++) {
      if (func(item, acc[i]) < 0) {
        break;
      }
    }
    acc.splice(i, 0, item);
    return acc;
  }, []);
}

sort([3, 1, 5, 4, 2], (x, y) => x - y);

const arr = [1, 2, 3, 4, 5];

// 짝수만 골라내기
arr.filter(item => item % 2 === 0); //  [2,4] : 요소의 값이 2로 나눈 나머지가 0이면 true, 아니면 false를 반환합니다.

const arr = [1, 2, 3];

arr.join("&"); //  '1&2&3'

const arr = [1, 2, 3];

arr.join(); //  '1,2,3'

const arr = ["a", "b", "c", "d", "c"];

arr.indexOf("b"); //  1
arr.lastIndexOf("c"); //  2

arr.indexOf("o"); //  -1
arr.lastIndexOf("s"); //  -1

const arr = ["가", "나", "다", "라", "마", "가"];

arr.indexOf("가", 2); //  5 : 시작인덱스가 2로 주어져서 2(다)부터 검사를 하여 가를 찾았습니다. 값이 5인 이유는 시작인덱스부터 새도 인덱스 값의 기준은 0이며 변하지 않습니다.
arr.lastIndexOf("다", 2); //  2 : 거꾸로 2(라)부터 검사를 하여 다를 찾았습니다. 값이 2인 이유는 lastIndexOf또한 인덱스 값의 기준은 0이기 때문입니다.

const names = ["moong2", "min_zzz", "jogoogod", "shinyerin"];

names.find(item => item.length > 6); //  'min_zzz' : 조건에 만족하는 요소중 왼쪽부터 검사해서 처음 만나는 요소이기 때문!
names.findIndex(item => item.length > 6); //  1 : 조건에 만족하는 요소중 왼쪽부터 검사해서 처음 만나는 요소(min_zzz)의 인덱스를 반환

names.find(item => item.length > 12); //  undefined
names.findIndex(item => item.length < 1); //  -1

const arr = ["one", "two", "three"];

arr.includes("one"); // true : 배열안에 일치하는 문자열인 "one"이 있으므로 true
arr.includes("three", 1); //  true : 1번 인덱스를 시작으로 배열안에 일치하는 문자열인 "three"가 있으므로 true
arr.includes("one", 1); // flase : 1번 인덱스를 시작으로 배열안에 일치하는 문자열인 "one"이 없으므로 false

const arr = ["one", "two", "three"];

arr.every(item => item.length > 2); //  true : 모든 요소가 2글자 이상이므로 true
arr.every(itme => item.length < 2); //  false : 모든 요소가 2글자 이상이므로 false

const arr = ["one", "two", "three"];

arr.some(item => item.length > 3); //  true : 조건을 만족하는 요소가 있기 때문에 true
arr.some(itme => item.length > 5); //  false : 조건을 만족하는 요소가 하나도 없기에 false

Array.isArray([]); //  true
Array.isArray({}); //  false : 객체
Array.isArray("hello"); // flase : 문자열

"hello"[0]; //  'h'
"hello".slice(2, 4); //  'll'

for (let c of "hello") {
  console.log(c); // "h","e","l","l","o"
}

const table = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];

table[0][2]; // 3
table[2][1]; // 8