2021-11-09(화) 2일차

Jeongyun Heo·2021년 11월 9일

운영체제

기본적으로 처리하는 단위가 32비트냐 64비트냐

20인분 준비하려면 10인분 밥솥 2번 돌려야 됨

변수 앞에 타입이 있다는 게 무슨 의미냐면

자바에서의 타입 의미
1. 새로 만든다. 메모리 공간 확보해라.
2. 데이터의 종류를 결정해 준다.

자바스크립트는 다름

스크립트는 특정한 프로그램을 위한 언어

변수 선언할 때 앞에 아무것도 없어도 됨 (옛날 방식이고 요즘엔 let, const 사용)

let
const
→ scope

브레이스 { }
타입이 결정되면 범위가 정해짐
타입이 여기서 선언되면 이 범위를 못 벗어남
변수 앞에 타입이 있다는 건 변수의 범위를 결정해줌
자바스크립트는 그렇지 않다는 거
대부분의 언어들은 변수의 타입이 나오면 범위를 정해줌

들여쓰기만으로 범위를 알 수 있으니까 들여쓰기 중요

int num; 변수 선언
num =10; 변수 할당

String[] args → 파라미터

변수 : 데이터를 다루려는 거

데이터가 그렇게 간단하지 않다

자바 첫 번째 고비 : 클래스

클래스가 왜 나왔
변수 : 데이터를 다루려는 거
대부분의 경우 값 하나로 이루어지는 경우가 없음
키 - 몸무게 - 이름 (같이 있어야 의미 있는 데이터)
메뉴 - 가격 - 수량
대부분의 정보는 정보 하나로 구성되는 경우는 없음

메타버스
'메타'
추가적인 정보를 메타 정보라고 한다

데이터를 표현하는 데 규격이 필요했던 거
데이터 여러 개를 묶어야 하는 상황이 필요
{ }
집합
구조체
클래스

변수 하나가 여러 개의
이름 - 핸드폰 번호
이름 15개 + 핸드폰 번호 15개 = 총 데이터 30개
변수 30개를 만들 것인가 변수를 15개만 만들고 데이터를 묶어주는 거
{이름: 허정윤, 번호: 010-0000-0000}

프로그래밍이라는 건 복잡성을 제거하는 방식

남들도 알아보기 쉽고 나도 알아보기 쉽고

데이터를 넣는 2가지 방식이 나오기 시작
기본 자료형 / 참조 자료형
간단한 데이터를 넣느냐 복잡한 데이터를 넣느냐

let num1 = 10;
num1 = num1 + 20;
save   load   (어셈블리)

중간에 copy가 이루어짐
여기서 단점이 생김
변수가 너무 무거우면 어떤 일이 생길까
변수 안에 있는 데이터가 크면
1메가 데이터를 끄집어 내야 되고 다시 집어넣어야 됨
너무 느릴 거임
메모리도 엄청 많이 쓰는 프로그램을 만들게 될 거임
그래서 사람들이 생각한 방식이 2가지
직접적으로 데이터를 끄집어 내는 방식
간접적으로 데이터를 끄집어 내는 방식
변수 안에는 핸드폰 번호만 넣어놓는 거
진짜 데이터는 저쪽에 있고
변수 안에는 핸드폰 정보만 copy해서 담으면 가볍게 쓸 수 있음
간접적으로 이것만 복사해서 쓰는 거
메모리상에서 똑같은 애를 가리키는 거임
C언어에서는 포인터라고 함
자바에서는 레퍼런스라고 함

내용물을 직접 넣는 건 기본 자료형

참조 자료형은 내용물을 넣는 게 아니라 실제 내용물은 엄청 크고 실제로는 리모컨을 담는 거
실제 내용물을 넣으면 너무 무거워지니까 느려지니까
누가 선풍기를 달라고 하면 리모컨만 그대로 copy를 떠서 담아주는 거
선풍기를 조작하는 게 목적
간접적으로 레퍼런싱 한다고 한다
자바의 가비지 컬렉션도 설명이 됨
이 변수에도 리모컨이 담기고 저 변수에도 리모컨이
변수를 둘 다 없앴다고 하면 리모컨이 둘 다 없어짐
리모컨이 없으면 아무도 조작할 수 없는 거
메모리 쓸데없이 차지하고 있
저 메모리는 더 이상 사용하지 않아
자바스크립트도 가비지 컬렉터 지원

정리
간단하게 담을 수 있는 데이터
리모컨을 담는 형태의 데이터
자바 언어의 경우에는 변수를 최초로 선언할 때 타입을 정확하게 명시
자바스크립트는 그렇지 않다 루즈한 타입
하지만 자바스크립트도 범위는 필요하다
그래서 let, const
let 변경 가능
const 변경 불가능
포인터를 이용한 연산이 가능
자바나 자바스크립트에서는 레퍼런스라고 하고
C언어에서는 포인터라고 하고
어디를 가리킨다고 해서 포인터

프로그램 짜는 요령
내가 지금 나한테 주어진 데이터가 뭔지 정확하게 파악하는 거
맨 위에 뭘 선언하냐면
맨 위에 변수를 쫙 선언
요리책이랑 비슷
요리책도
프로그램을 짤 때 데이터를 선언해놓는 게 요리랑 비슷

연산자랑 로직

2교시 시작

실행시켜도 에러 안 남

PC 포맷할 줄 알아야 함

자바는 엄청나게 엄격

모든 연산자는 결과를 만들어 낸다
결과를 바로 써먹거나 어딘가 save해놔야 한다.

System.out.println(1+2);
int num = 1 + 2;

모든 연산은 결과를 만들어 낸다

for Loop

i++;
++i;
증감연산자는 변수를 따로 선언하거나 소비하지 않아도 된다.
축약형 표현
파이썬에는 증감연산자 없음

결과를 만들어낸다는 건 결국엔 식이라는 얘기

System.out.println(x < y);
비교 연산자

모든 연산은 해당하는 타입에 맞는 데이터가 나옴

boolen result = i < j;

그 결과를 변수로 잡아도 된다.

제어문 if

if문을 표현할 때 조건문이라는 표현을 많이 있는데 조건식이 맞는 말이다
왜?
결과가 있어야 되니까
조건식은 변수로 담을 수도 있음
if (result)
if (변수 && 변수)

return 이라는 키워드
그걸로 끝냈다는 거 의미
나중에 함수할 때 다시 한 번 return 나옴

https://www.npmjs.com/package/readline-sync

const readLine = require('readline-sync');

console.log("ODD EVEN")
const answer = readLine.prompt()

console.log(answer)

도넛 문제
해당 도형의 넓이 = 큰 원의 넓이 - 작은 원의 넓이
이 안에서 한 번 더 판단이 이루어진거니까
원A의 넓이 - 원B의 넓이
바깥쪽 원을 A라고 하고 안쪽 원을 B라고 할 수 있고
주어진 데이터 => 반지름 2개
이걸 같이 선언해야 되나, 따로 따로 선언해야 되나
이거에 대한 기준점은 간단하다

1제곱미터당 32달러
5제곱미터당 15달러
탐욕 알고리즘
하나에 4천원인데 3개에 만원
앵커링

원A - 1제곱미터 - 25달러 (이 데이터들은 서로 떨어지면 안 됨)
원B - 3제곱미터 - 21달러
그럴 때 필요한 게 구조체

반지름
r1
r2
따로 따로 선언하면 될 거 같음

주어진 데이터로 원의 넓이를 구해야 된다
계산을 하거나 연산을 하게 된다
이거 역시 변수로 잡는다
원A의 넓이 (변수)
원B의 넓이 (변수)
두 개의 원의 차이를 구하는 것도 연산
연산을 하면 항상 변수가 나온다고 생각하면 됨
넓이의 차이 (변수)
사용자의 입력 (변수)
사용자의 입력을 변수로 잡아놓고 시작하면 됨

1. 주어진 데이터
2. 계산/연산 데이터
3. 사용자 입력 데이터

원의 넓이 = 반지름 제곱 * 원주율

Math.PI

Math.power(2, 4) // 2의 4제곱 = 16

console.log(Math.PI)

const num = Math.pow(2, 4)

console.log(num)

// 도넛 모양의 넓이를 구하는 문제
const readLine = require('readline-sync');

const r1 = readLine.prompt()
const r2 = readLine.prompt()

const c1 = Math.pow(r1, 2) * Math.PI
const c2 = Math.pow(r2, 2) * Math.PI

const gap = c1 - c2

const result =  gap > 0 ? gap : -gap

console.log(result)

절차지향적 방법

객체지향적 방법

자바스크립트도 클래스가 지원이 됨
자바랑 똑같이 할 수 있음

주어진 데이터
붙어 있는 데이터인지 따로따로 있는 데이터인지 생각
여러 개의 데이터가 주어지는 경우에는 배열이나 반복문 필요

if문 사용 ↓

// 도넛 모양의 넓이를 구하는 문제
const readLine = require('readline-sync');

// 주어진 데이터
const r1 = 10
const r2 = 20

// 원의 넓이
const area1 = Math.pow(r1, 2) * Math.PI
const area2 = Math.pow(r2, 2) * Math.PI

let gap = area1 - area2

// if
if (gap < 0) {
    gap = gap * -1
}

삼항연산자 사용 ↓

// 도넛 모양의 넓이를 구하는 문제
const readLine = require('readline-sync');

// 주어진 데이터
const r1 = 10
const r2 = 20

// 원의 넓이
const area1 = Math.pow(r1, 2) * Math.PI
const area2 = Math.pow(r2, 2) * Math.PI

let gap = area1 - area2

// 삼항연산자
gap = gap < 0 ? gap * -1 : gap

삼항연산 안에 삼항연산 쓸 수 있는데 가독성 떨어져서 그렇게 잘 안 씀

console.log("이 도형의 넓이는" + gap + "입니다.")
+ 보다는 backtick 사용해서 출력하기

console.log(`이 도형의 넓이는 ${gap} 입니다.`)

gap = gap.toFixed(2) // 소수점 둘째자리까지 표현

// 도넛 모양의 넓이를 구하는 문제
const readLine = require('readline-sync');

// 주어진 데이터
const r1 = 10
const r2 = 20

// 원의 넓이
const area1 = Math.pow(r1, 2) * Math.PI
const area2 = Math.pow(r2, 2) * Math.PI

let gap = area1 - area2

// 삼항연산자
gap = gap < 0 ? gap * -1 : gap

gap = gap.toFixed(2) // 소수점 둘째자리까지 표현

console.log(`이 도형의 넓이는 ${gap} 입니다.`)

// 이 도형의 넓이는 942.48 입니다.

호기심, 의욕

가로, 세로 길이가 떨어지는 데이터인가?
사용자가 예를 들어 여러 개의 창문을 조립하고 싶을 수도 있
자신이 없다면 가장 쉬운 방법을 선택
성공하는 것만 생각하기

const totalFeet = totalLength / 30.48
30.48 이라는 값은 안 바뀌니까 그대로 씀

Math 3가지

Math.round() 반올림
Math.ceil() 올림
Math.floor() 내림

const totalFeet = Math.ceil(totalLength / 30.48)

처음에 데이터 다 선언

// 1ft = 3.5달러
// 300 * 200

const perFeet = 3.5

const width = 300
const height = 200

// 창문 => 가로 * 2, 세로 * 2 => 전체 샷시 길이
const totalLength = (width * 2) + (height * 2)

console.log(totalLength)

// 길이(cm) => ft
const totalFeet = Math.ceil(totalLength / 30.48)

// totalFeet = Math.ceil(totalFeet)

console.log(totalFeet)

// 가격 계산
// 업자가 미터 단위로 판다

const totalPay = totalFeet * perFeet

console.log(`총 ${totalPay} 달러입니다.`)

// 총 115.5 달러입니다.

부가세

1피트 가격 입력 받고
창문 가로, 세로 길이 입력 받기

parseFloat()

const perFeet = parseFloat(readLine.prompt())

const readLine = require('readline-sync');

console.log("1피트당 샷시 가격은 얼마인가요?")
const perFeet = parseFloat(readLine.prompt())

const width = 300
const height = 200

// 창문 => 가로 * 2, 세로 * 2 => 전체 샷시 길이
const totalLength = (width * 2) + (height * 2)

console.log(totalLength)

// 길이(cm) => ft
const totalFeet = Math.ceil(totalLength / 30.48)

// totalFeet = Math.ceil(totalFeet)

console.log(totalFeet)

// 가격 계산
// 업자가 미터 단위로 판다

const totalPay = totalFeet * perFeet

console.log(`총 ${totalPay} 달러입니다.`)

parseInt()

const width = parseInt(readLine.prompt())

const height = parseInt(readLine.prompt())

const readLine = require('readline-sync');

// 1ft = 3.5달러
// 300 * 200

console.log("1피트당 샷시 가격은 얼마인가요?")
const perFeet = parseFloat(readLine.prompt())

// const perFeet = 3.5

console.log("가로 길이는 얼마인가요? cm")
const width = parseInt(readLine.prompt())

console.log("세로 길이는 얼마인가요? cm")
const height = parseInt(readLine.prompt())

// 창문 => 가로 * 2, 세로 * 2 => 전체 샷시 길이
const totalLength = (width * 2) + (height * 2)

console.log(totalLength)

// 길이(cm) => ft
const totalFeet = Math.ceil(totalLength / 30.48)

// totalFeet = Math.ceil(totalFeet)

console.log(totalFeet)

// 가격 계산
// 업자가 미터 단위로 판다

const totalPay = totalFeet * perFeet

console.log(`총 ${totalPay} 달러입니다.`)

사용자가 잘못 입력하면 어떻게 할지 처리를 안 해줌

제어문

밑에서 위로 다시 가는 거

예외 라는 개념 도입

다시 되돌릴 수 있는 방법

사용자가 잘못 입력한 경우

사용자들이 이런 기능이 있으면 좋겠구나 하고 미리 만드는 사람 (고급)

잘못될 수 있는 부분 찾는 게 중급

이거 하나 때문에 전체를 갈아엎어야 돼

그래서 사람들이 다른 장치를 생각해낸다

NaN

'js 예외처리' 검색

https://helloworldjavascript.net/pages/290-exception.html

try {
    console.log("1피트당 샷시 가격은 얼마인가요?")
    const perFeet = parseFloat(readLine.prompt())
} catch (e) {
    console.log("잘못 입력했어요")
}

에러를 어떻게 낼 것이냐
다시 위로 어떻게 올라갈 거냐
이 두 가지를 다 해결하는 게 함수
흉내내는 거는 반복문으로 할 수 있음

For Loop

자바스크립트는 자바보다 For Loop가 더 다양하다
반복문은 왜 쓸까?
계산/반복
반복문이 들어가면 로직이 복잡해진다

배열 간단하게 먼저 배우고 반복문 들어가겠다

변수
값 타입이 들어가는 경우
리모컨이 들어가는 경우

값이 들어가는 경우랑 리모컨이 들어가는 경우가 있음

a = 10
b = a
load copy save
너무 메모리를 많이 쓰게 되니까 메모리를 조금 쓰고 싶어서 포인터(레퍼런스)
메모리 공간은 따로 잡고 메모리 공간을 찾아갈 수 있는 리모컨만 넣는다
리모컨만 복사해서 넣는 거
CPU 연산단위가 기본적으로 4 byte
결과적으로 a에 있는 내용물이랑 b에 있는 내용물이랑 같음
바로 나오는 게 아니고 리모컨이 나옴

자바
대문자로 시작하는 경우가 있고
소문자로 시작하는 경우가 있음
자바는 대소문자를 엄격하게 구분
대문자냐 소문자냐에 따라 결과가 달라짐

int[] arr = {1, 2, 3, 4, 5} 적어도 20바이트 필요 (4 byte * 5)
너무 메모리를 많이 쓰는 거

@: at
@16진수
이 주소는 실제 메모리상 주소가 아니라 JVM이 가리키는 주소임

copy를 하려면 타입이 똑같아야 함

int[] arr2 = arr;

load copy store

arr에 지금 리모컨이 담겨 있음

리모컨의 크기는 4 baye 밖에 안 됨 (int형이니까)

이제 나는 리모컨이 아니라 실제 값들을 보고 싶다

jump

점프한다고 표현함

프로그램언어를 메모리상에서 이동하는 방법은 두 가지 밖에 없음
. 점
[] 꺾쇠

배열을 순서가 있음
nullpointexception

arr[0]
int의 묶음이면 4바이트씩 건너뛰면 됨
다음 순서로 가려면 4바이트 건너뛰면 됨

arr[0] = arr2[0]

그거를 이용해서 for문

for문 구구단 시험

배열은 뭐하려고 쓰냐
묶어주려고
어떤 데이터를 묶느냐
데이터도 여러 개가 있음
변수를 여러 개 선언할 거냐
하나로 묶어서 배열로 선언할 거냐

주어진 데이터들은 변수로 잡는다
변수를 여러 개 잡을 거냐 한 번에 묶어서 잡을 거냐
어떤 데이터를 배열로 처리하는지
자바는 같은 종류 타입
자바스크립트는 타입이 느슨
동일한 의미의 데이터 多
3. 비정형적인 데이터
반복처리가 필요한 애들을 배열로 잡는다
키 중에서 제일 큰 키랑 제일 작은 키
키라는 건 동일한 의미를 가지는 데이터
변수 15개를 선언해도 되고 배열을 선언해도 되는 거
반복처리가 가능하기 때문에
키 데이터는 전혀 상관관계가 없음
반복문은 정해진 패턴으로 반복이 됨
그럴 때는 배열이 필요하지 않음
이런 데이터를 배열로 선언해서 반복처리 하는 거
성적
성적으로 반복 처리
배열의 좋은 예제

★ 문제 ★
어떤 문제를 풀 것인지 정의를 하고
외부 데이터 연동
네트워크에 있는 데이터 가져다가 출력
시험 성적 데이터
10명의 시험 성적
전체 평균을 구하고 싶
최저 점수와 최고 점수를 구하고 싶
네트워크로 외부에 있는 데이터를 가져오는 연습
그런 걸 API 데이터라고 함. 공공 데이터.
지도 API 만들 거임

배열의 특징 : 각각의 데이터는 별로 의미가 없음. 모여 있을 때는 의미가 있음.

어떤 데이터를 봤을 때 배열로 선언해야 되나 말아야 되나
배열이란 구조체를 만들어야 되나

1. 배열을 가지고 반복문 돌리는 방법
2. 중간에 멈추는 방법
3. 중간에 건너뛰는 방법

데이터의 묶음
묶음만이 의미를 가지는 경우
규칙 X
반복처리 → 반복문

자바
길이 고정(fix)
기능 小
타입 고정

JS
길이 가변
기능 多
여러 종류의 데이터
다양한 자료구조가 없음
왜 배열이 발전할 수 밖에 없었냐면 자바스크립트는 다양한 자료구조가 존재하지 않음

js 배열 검색
https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/Array
모질라 : 자바스크립트 표준을 잡는 곳

배열은 프로토타입으로 탐색과 변형 작업을 수행하는 메서드를 갖는, 리스트와 비슷한 객체입니다.

자바스크립트는 배열을 만들 때 대괄호[ ]를 쓴다. 자바는 중괄호{ }.

let fruits = ['사과', '바나나']

console.log(fruits.length)
// 2

곱하기 0으로 시작

let first = fruits[0]
// 사과

let last = fruits[fruits.length - 1]
// 바나나

const가 고정하는 건 리모컨

자바는 한 번 만들면 고정. 타입도 마음대로 못 씀.

const arr = ['타노스', '아이언맨', '블랙위도우']

console.log(arr.length) // 3

. 점 아니면 [] 꺾쇠

undefined : 변수는 있는데 아직 아무것도 안 들어있는 거. 접근은 가능

const arr = ['타노스', '아이언맨', '블랙위도우']

console.log(arr.length)

console.log(arr[0])
console.log(arr[1])
console.log(arr[2])
console.log(arr[3]) // 에러 안 남

자바는 바로 에러남

undefined : 변수는 존재하는데 아무것도 안 들어있는 거

const arr = ['타노스', '아이언맨', '블랙위도우']

console.log(arr.length)

console.log(arr[0])
console.log(arr[1])
console.log(arr[2])

arr[3] = "블랙팬서"

console.log(arr)

보통 이렇게 추가 안 하고 push 메서드 사용

push메서드 리턴값을 잘 봐야 됨

변경된 길이를 알려준다

const arr = ['타노스', '아이언맨', '블랙위도우']

console.log(arr.length)

console.log(arr[0])
console.log(arr[1])
console.log(arr[2])

// arr[3] = "블랙팬서"
const changedLength = arr.push('블랙팬서') // 변경된 길이를 알려줌

console.log(changedLength) // 4

배열 안 항목의 인덱스 찾기 (중요) ★★★★
indexOf() : 배열 내부에서 특정 값의 위치를 찾는 메서드

indexOf() 메서드는 배열 내부에 요소가 있을 경우 인덱스를 리턴한다.
배열 내부에 요소가 없을 때는 -1을 리턴한다.

fruits.push('망고')
// ["딸기", "바나나", "망고"]

let pos = fruits.indexOf("바나나")
// 1

없는 애를 찾으면 -1을 반환한다

예외라는 개념

예외를

이런 게 함수형 스타일

예외를 던지는 게 아니라 나올 수 없는 값을 던진다

const arr = ['타노스', '아이언맨', '블랙위도우']

console.log(arr.length)

console.log(arr[0])
console.log(arr[1])
console.log(arr[2])

// arr[3] = "블랙팬서"
const changedLength = arr.push('블랙팬서') // 변경된 길이를 알려줌

console.log(changedLength)

console.log(arr.indexOf("토르")) // -1

가장 큰 특징은 길이가 고정되지 않는다는 거

요소 삭제하고 땡기기

자바에서는 길이를 만들어 놓으면 못 바꾸니까 불가능

가운데 값을 빼면 가운데가 비어
자바는 값을 못 바꿔
다른 자료구조 사용해야 됨

자바스크립트는 자료구조가 발달하지 않아서
splice 라는 기능이 있음

인덱스로 요소 제거하기

배열.splice(인덱스, 제거할 요소의 개수)
제거할 요소의 개수를 1로 지정하면 1개의 요소만 제거한다는 의미

값으로 요소 제거하기

배열 내부에서 특정 값의 위치를 찾는 indexOf() 메서드를 사용해서 값의 위치를 추출한 뒤 splice() 메서드를 사용해 제거한다.

const idx = 배열.indexOf(요소)
배열.splice(idx, 1)

indexOf() 메서드는 배열 내부에 요소가 있을 경우 인덱스를 리턴한다.
배열 내부에 요소가 없을 때는 -1을 리턴한다.

let fruits = ["딸기", "바나나", "망고"]

let pos = fruits.indexOf("바나나") // 1

let removedItem = fruits.splice(pos, 1)

// ["딸기", "망고"]

const arr = ['타노스', '아이언맨', '블랙위도우']

console.log(arr.length)

console.log(arr[0])
console.log(arr[1])
console.log(arr[2])

// arr[3] = "블랙팬서"
const changedLength = arr.push('블랙팬서') // 변경된 길이를 알려줌

console.log(changedLength)

console.log(arr)

arr.splice(1, 1)

console.log(arr)

이거 가지고 CRUD를 할 수 있음

루프 돌리는 거

복불복 게임

배열을 만들 배열 안에 내용물을
제비뽑기
배열이 있어요
15명 배열을 만들고
한명만 당첨이고
나머지는 죽은 거
한명씩 엔터를 누르면 당첨인지 꽝인지
당첨이 나오면 종료
배열을 돌리는 건 for문을 이용하면 됨

for (let i = 0; i < arr.length; i++) {
    console.log(i)
}
---------------------------------------
0
1
2

for (let i = 0; i < arr.length; i++) {
    console.log(i)
    console.log(arr[i])
}
------------------------------------------
0
타노스
1
블랙위도우
2
블랙팬서

블랙위도우를 만나면 종료

const arr = ['타노스', '아이언맨', '블랙위도우']

console.log(arr.length)

console.log(arr[0])
console.log(arr[1])
console.log(arr[2])

// arr[3] = "블랙팬서"
const changedLength = arr.push('블랙팬서') // 변경된 길이를 알려줌

console.log(changedLength)

console.log(arr)

arr.splice(1, 1)

console.log(arr)

for (let i = 0; i < arr.length; i++) {
    console.log(i)
    console.log(arr[i])
    if (arr[i] == "블랙위도우") {
        break
    }
}

break : 아래로 빠짐
continue : 위로 빠짐

i++ : 변환문 (식이 아님)

for (let i = 0; i < arr.length; i++) {
    if (arr[i] == "블랙위도우") {
        continue
    }
    console.log(i)
    console.log(arr[i])
}

블랙위도우만 빼고 찍힘

var와 let의 차이는 scope(범위)

for루프 안에서 let으로 변수를 선언하면 for루프 안에서만 사용 가능

배열을 많이 만들어야 될 때가 있음

로또

parseInt((Math.random() * 45)) + 1 // 1 ~ 45

배열에다 집어넣어

같은 숫자가 나올 수 있음

indexOf

-1이 나오면 없는 거니까 배열 안에 push 해서 넣는다

숫자를 하나 뽑는다
배열에 있는지 검사
-1이 나오면 없다는 뜻이므로 push
0, 1, 2 이런 게 나오면 push 하기 전에 다시 뽑아야 됨 (continue)

for문
counted Loop : 몇 번 실행될지 아는 거
지정된 숫자 만큼 돌 때

while문
uncounted Loop: 몇 번 실행될지 모르는 거

배열의 길이가 6이 될 때까지 반복한다

push 하면 길이 반환 (변경된 길이를 알려줌)

6교시 시작

의사 코드를 먼저 짜놓고 코드를 짜는 게 좋다.

루프 2가지

for (초기문; 검사식; 변환문)
지정된 숫자 만큼 돌 때

while (검사식)
몇 번인지 알 수 없을 때

보통 while (true) 하고 특정한 조건에 break 하는 걸로 많이 씀

while (true) {
    break
}

배열 하나 선언 (뽑힌 번호들을 넣는 용도)

num = 1 ~ 45 사이 숫자

배열 안에 num이 있는지 검사

num이 있으면 다시 뽑아야 됨. 위로 올라가야 됨 (continue)

num이 없으면 아래로 흘러간다. 배열에 붙이기. (push)

arr.push() // 변경된 길이 반환

반환된 길이가 6이면 break로 빠진다.

그리고 나서 console.log(arr) 어떤 번호 있는지 찍어준다.

lottoGen 파일 생성

배열을 만들 건데
let으로 선언할 거냐 const로 선언할 거냐

const arr = []

arr.push(1) // . (jump)
arr.push(2)

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

const는 불변인데 push 했더니 에러 안 남

배열은 직접적으로 값이 들어가는 애가 아니라 리모컨이 들어가는 애임

const는 이 안에 내용물이 바뀔 수 없다는 거

arr.push(1)

push 한다고 리모컨이 바뀌지는 않는다.

간접적으로 참조하고 있는 거

const arr = []
const temp = [1, 2]
arr = temp // 에러. 내용물 자체는 못 바꿈

↑ arr 안에는 이 배열의 리모컨이 들어있던 건데 저렇게 하면 리모컨 자체가 바뀜

temp 상자 안에 있는 내용물을 끄집어 내서 arr 상자에 넣은 거

변수 안에 값이 들어있는 게 아니라 리모컨이 들어가 있음
그러므로 arr.push() 해도 내용물은 안 바뀜
안쪽에 있는 내용물이 바뀐 거지 바깥쪽 내용물(리모컨)이 바뀐 게 아님
리모컨 자체가 바뀐 적은 없는 거

unreachable 언리쳐블 코드
대규모의 시스템을 만들 때는 엄격한 언어가 좋은 언어
나혼자 지지고 볶을 때는 느슨한 언어가 좋은 언어

// 로또
const arr = []

while (true) {
    // 숫자를 생성 1 - 45 사이의 숫자
    num = parseInt((Math.random() * 45)) + 1

    // 배열 안에 있는지 검사
    const index = arr.indexOf(num)

    // 배열 안에 이미 있으면 다시 뽑기
    if (index >= 0) {
        continue
    }

    const newLength = arr.push(num)

    if (newLength === 6) {
        break
    }
}

console.log(arr)

// 로또
const arr = []

while (true) {
    // 숫자를 생성 1 - 45 사이의 숫자
    num = parseInt((Math.random() * 45)) + 1

    // 배열 안에 있는지 검사
    const index = arr.indexOf(num)

    // 인덱스 찍어보기
    console.log(`NUM: ${num}   INDEX: ${index}`)

    if (index >= 0) {
        continue
    }

    const newLength = arr.push(num)

    if (newLength === 6) {
        break
    }
}

console.log(arr)

버전 업

실제 로또 추첨은 공을 뽑는 거라 중복된 숫자가 나올 수가 없음

arr = [1, ... , 45]

모든 알고리즘은 장점도 있고 단점도 있음

push

arr.splice(인덱스, 제거할 요소의 개수) // 인덱스로 요소 제거하는 방법

https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/Array/fill

1. 빈 배열을 만든다.
2. 배열에 숫자를 채운다. (반복문 필요)

const arr = []

for (let i = 1; i <= 45; i++) {
    console.log(i)
}

const arr = []

for (let i = 1; i <= 45; i++) {
    arr.push(i)
}

console.log(arr)

로또 공들 준비 완료

2단계 : 6번 뽑기
배열에서
length - 1
0 ~ 44 사이에서 뽑아야 됨
splice(index, 1)
0 ~ 43
0 ~ 42
0 ~ 41
0 ~ 40
장점 : 중복된 숫자가 발생될 수 없다
무조건 6번 뽑을 수 있음

Math.random() * arr.length // arr.length = 45
Math.random() * arr.length // arr.length = 44

break point
디버그 도구

const arr = []

for (let i = 1; i <= 45; i++) {
    arr.push(i)
}

console.log(arr)

for (let i = 0; i < 6; i++) {
    const idx = parseInt(Math.random() * arr.length)
    console.log(arr.splice(idx, 1))
    console.log(arr.length)
}