7/22 TIL : JS 문자열, 배열, 객체, 코딩테스트

문자열 함수

문자열.length();

문자열.indexOf("찾을 문자열");

문자열.slice(시작 위치, 종료 위치);

문자열.replace("찾을 문자", "바꿀 문자");

문자열.repeat(반복 횟수);

문자열.trim();

let str = "Hello, world";
let str_trim = "    Hello, world    "

console.log(str.length); // 12
console.log(str.indexOf("world")); // 7
console.log(str.slice(0, 5)); // Hello
console.log(str.replace("world", "뽀로로")); // Hello, 뽀로로
console.log(str.repeat(2)); // Hello, worldHello, world
console.log(str_trim.trim()); // Hello, world

 

수학 함수

parseInt( ); int(정수형)으로 변환

parseFloat( ); float(부동소수)로 변환

Math.abs( ); 절댓값

Math.min( ); 작은 값

Math.max( ); 큰 값

Math.ceil( ); 올림

Math.floor( ); 버림

Math.round( ); 반올림

Math.random( ); 랜덤

const pi = 3.14159265358979;
console.log(parseInt(pi)); // 3
console.log(parseFloat(pi)); // 3.14159265358979

console.log(Math.abs(-999)); // 999
console.log(Math.min(10, 33, 6, 2, -1)); // -2
console.log(Math.max(10, 33, 2, 1, 77)); // 77
console.log(Math.ceil(3.14)); // 4
console.log(Math.floor(3.14)); // 3
console.log(Math.round(3.6)); // 4
console.log(Math.round(3.4)); // 3
console.log(Math.random());

 

예제)

1. 주어진 배열에서 가장 큰 수와 작은 수를 찾아서 소수점을 버림 처리

2. 해당 수 절댓값의 평균 구하기

3. 0~100 사이의 정수인 랜덤한 숫자

let nums = [-1.23, 13, 14.52, -33.53, 30];
let max = Math.floor(Math.max(...nums));
let min = Math.floor(Math.min(...nums));
// let max = Math.floor(Math.max(nums[0], nums[1], nums[2], nums[3], nums[4]));
// let min = Math.floor(Math.min(nums[0], nums[1], nums[2], nums[3], nums[4]));
console.log("큰 수:", max, "작은 수:", min, "평균", (Math.abs(max) + Math.abs(min))/2);

let random = Math.random();
random = Math.floor(random * 100);
console.log("랜덤(0 ~ 100):", random);

 

배열 함수

.push( ); 마지막에 추가

.unshift( ); 처음에 추가

.pop(); 마지막 요소 삭제, 삭제한 값 반환

.shift(); 처음 요소 삭제, 삭제한 값 반환

.length; 배열의 길이

.concat( ); 배열 합치고 반환(원본 변경 x)

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

numbers.push(7);
console.log(numbers); // [1, 2, 3, 4, 5, 6, 7]

numbers.unshift(0);
console.log(numbers); // [0, 1, 2, 3, 4, 5, 6, 7]

console.log(numbers.pop()); // 7
console.log(numbers.shift());  // 0

let fruits = ["사과", "딸기", "수박"];
console.log(numbers.concat(fruits)); // [1, 2, 3, 4, 5, 6, '사과', '딸기', '수박']
console.log(numbers); // [1, 2, 3, 4, 5, 6]

 

 

예제) splice 함수를 이용해서 [3, 4] [1, 2, 77, 4]가 나오도록 하기

.splice(시작점, 자를 개수, 값);

const numbers1 = [1, 2, 3, 4];
const numbers2 = [1, 2, 3, 4];

numbers1.splice(0, 2);
numbers2.splice(2, 1, 77);

 

배열 반복문

for(let i = 0; i < numbers.length; i++) { };

for(let number of numbers) { };

numbers.forEach(function(number, index, array) { } );

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

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

for(let number of numbers) {
    console.log(number);
};

numbers.forEach(function(number, index, array) {
    console.log(number);
});
numbers.forEach((item, index, array) => {
    console.log(item);
});

 

예제)

1. 1~100까지의 배열을 for문을 사용해서 만들기

2. 배열의 합을 for문, for of문, forEach문을 사용해서 구하기

let numbers = [];
let sum1 = 0, sum2 = 0, sum3 = 0;

for(let i = 1; i < 101; i++){
    numbers.push(i);
}

for(let i = 0; i < numbers.length; i++) {
    sum1 += numbers[i];
}
for(let number of numbers) {
    sum2 += number;
}
numbers.forEach((num) => {
    sum3 += num;
})
console.log(sum1, sum2, sum3);

 

.map( ); 처리 후 배열로 반환

let numbers = [1, 2, 3, 4, 5, 6];
let map = numbers.map(function (item) {
    return item;
});
let map2 = numbers.map(item => {
    return item;
});
// let map2 = numbers.map((item) => item);
console.log("foreach :", foreach);
console.log("map :", map); // [1, 2, 3, 4, 5, 6]
console.log("map2 :", map2); // [1, 2, 3, 4, 5, 6]

const fruits = ["사과", "파인애플", "수박", "포도", "오렌지"];
let obj = fruits.map((item, index) => {
    return {
        id: index,
        name: item,
    }
})
console.log(obj); // [{id: 0, name: '사과'}, {id: 1, name: '파인애플'}, {id: 2, name: '수박'}, {id: 3, name: '포도'}, {id: 4, name: '오렌지'}]

 

.reduce(function (sum, item, index, arr) { });

** index가 0일 때는 x

let numbers = [1, 2, 3, 4, 5, 6];
let reduce = numbers.reduce(function (sum, item, index, arr) {
	console.log(sum, item, index, arr);
    return sum + item;
})
// 1 2 1 (6) [1, 2, 3, 4, 5, 6]
// 3 3 2 (6) [1, 2, 3, 4, 5, 6]
// 6 4 3 (6) [1, 2, 3, 4, 5, 6]
// 10 5 4 (6) [1, 2, 3, 4, 5, 6]
// 15 6 5 (6) [1, 2, 3, 4, 5, 6]

 

전개 연산자: 모든 배열의 요소를 구분 가능한 제일 작은 단위로 쪼개서 전개해 주는 역할

let string = "apple";
// for (letter of string) {
//     console.log(letter);
// };
console.log([...string]); // ['a', 'p', 'p', 'l', 'e']
[...string].forEach(function (letter, i, arr) {
    console.log(letter); // a // p // p // l // e
});

 

.filter((매개변수) => 조건); 조건에 부합하는 배열 요소만을 반환

let numbers = [1, 2, 3, 4, 5, 6];
// let arr = numbers.filter(function(item) {
//     return item > 3;
// })
let arr = numbers.filter((item) => item > 3);
console.log(arr); // [4, 5, 6]

 

.includes(요소); 해당 배열에 지정한 요소가 있는지 확인하는 메소드(t/f)

let numbers = [1, 2, 3, 4, 5, 6];
console.log(numbers.includes(3)); // true
console.log(numbers.includes(7)); // false

 

예제)

1. 두 배열에서 동일한 요소만을 가지는 배열 same 만들기

2. 두 배열에서 서로 다른 요소만을 가지는 배열 diff 만들기

let fruits1 = ["사과", "딸기", "파인애플", "수박", "참외", "오렌지", "자두", "망고"];
let fruits2 = ["수박", "사과", "참외", "오렌지", "파인애플", "망고"];

let same = fruits1.filter(item => fruits2.includes(item));
// fruits1.forEach(function(item) {
//     if(fruits2.includes(item)) same.push(item);
// })
let diff = fruits1.filter(item => !(fruits2.includes(item)));
console.log(same); // ['사과', '파인애플', '수박', '참외', '오렌지', '망고']
console.log(diff); // ['딸기', '자두']

 

.find( ); 배열에 특정 값이 있는지 찾고 반환

.findIndex( ); 배열에 특정 값이 있는지 찾고 위치를 반환

const fruits = ["Apple", "Banana", "Cherry"];
const result1 = fruits.find(item => {
    return /^A/.test(item); // 대문자 A로 시작하는가?
})
const result2 = fruits.findIndex(item => {
    return /^C/.test(item);
})
console.log(result1); // Apple
console.log(result2); // 2

 

객체

정적 메소드: 기존에 선언된 객체에 사용하지 않고 가상의 Object를 불러와 사용

Object.assign( ); 객체의 병합에 사용되는 메소드

const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };

const returnObj = Object.assign(obj1, obj2);
console.log(obj1); // {a: 1, b: 3, c: 4}
console.log(returnObj) // {a: 1, b: 3, c: 4}

 

객체의 불변성: 새로운 객체를 만들어서 합치면 새로운 객체는 메모리 주소가 다르기 때문에 동일하지 않다고 판단한다

const userName = {
    id: 1,
    name: "tetz",
}
const userEmail = {
    id: 1,
    email: "dfs@dsaff",
}

const returnObj1 = Object.assign(userName, userEmail);
const returnObj2 = Object.assign({}, userName, userEmail);
console.log(returnObj1 === userName); // true
console.log(returnObj2 === userName); // false​

 

Object.keys(); 객체의 key 값을 배열로 반환해 주는 메소드

const user = {
    id: 1,
    name: "tetz",
    email: "afsf@afsdf",
};

const keys = Object.keys(user);
console.log(keys); // ["id", "name", "email"]
const values = keys.map((key) => user[key]);
console.log(values); // [1, 'tetz', 'afsf@afsdf']

 

구조 분해 할당(비구조화 할당): 객체 또는 배열의 각각의 값을 분해하여 변수에 넣어 사용하는 방법

const user = {
    id: 1,
    name: "tetz",
    email: "sffss@fassf",
};
const { id, name, email, address } = user;
console.log(id); // 1
console.log(name); // tetz
console.log(email); // sffss@fassf
console.log(address); // undefined

const fruits = ["사과", "딸기", "망고", "수박"];
const [a, b, c, d] = fruits;
console.log(a, b, c, d); // 사과 딸기 망고 수박

---

프로그래머스 코딩테스트 연습

1. 짝수와 홀수 https://school.programmers.co.kr/learn/courses/30/lessons/12937

function solution(num) {
    var answer = '';
    if(num % 2 == 0) answer = "Even";
    else answer = "Odd";
    return answer;
}

 

2. 수박수박수박수박수박수? https://school.programmers.co.kr/learn/courses/30/lessons/12922

function solution(n) {
    // var answer = '수박';
    // answer = answer.repeat(n/2);
    // if(n % 2 === 1) answer = answer + "수";
    // return answer;
    
    let answer = "";
    for(let i = 0; i < n; i++) {
        if(i % 2 == 0) answer += "수";
        else answer += "박";
    };
    return answer;
}

 

3. 약수의 합 https://school.programmers.co.kr/learn/courses/30/lessons/12928

function solution(n) {
    var answer = 0;
    for(let i = 1; i < n+1; i++) {
        if(n % i === 0) answer += i;
    };
    return answer;
}

 

4. 평균 구하기 https://school.programmers.co.kr/learn/courses/30/lessons/12944

function solution(arr) {
    var answer = arr.reduce(function(sum, item) {
        return sum + item;
    });
    return answer/arr.length;
}