[JS] 2. 기본 문법

1. 변수

1. 일급 객체

1. 가장 최상단에 적을 수 있는 것

2. 매개변수 등과 같이 단독으로 전달 가능하다.

3. 단독주소가 있음

4. Java에서는 class만 일급 객체이다.

2. Type

1. Number

2. String

3. Bool

4. Null

5. Undefined

// 변수
// 가장 최상단에 적을 수 있는 것들을 1급 객체라고 한다. (매개변수 등 단독으로 전달 가능하다(단독주소가 있음) cf. Java에서는 class만 1급 객체)
let n1 = 1; // Number 타입 (값이 들어가면서 Number 타입으로 정해짐 = 타입추론)
let n2 = 10.5;
let s1 = "문자열"; // String 타입
let s2 = '문자열'; // String 타입
let s3 = `문자열 ${n1}`; // String 타입

let b1 = true; // bool 
let u1 = null; // null 타입
let u2; // undefined 타입

console.log(n1);
console.log(n2);
console.log(s1);
console.log(s2);
console.log(s3);

console.log(b1);
console.log(u1);
console.log(u2);

2. 컬렉션과 오브젝트

1. 컬렉션

1. 같은 타입이 여러 개 나열

2. 오브젝트

1. 다른 타입이 여러 개 나열

2. Java의 class와 유사

3. {key:value}

// 컬렉션, 오브젝트

// 컬렉션 (같은 타입이 연속되는 경우)
let list = [1, 2, 3, 4];
let hobby = ["축구", "농구"]; 

// 오브젝트 ({key:value}) (다른 타입이 여러개)
let user = {
    id:1,
    username:"ssar",
    hobby:hobby // 컬렉션이 들어감
};

user.username="cos";
hobby[0] = "탁구";

console.log(list);
console.log(hobby);

console.log(user.id);
console.log(user.username);
console.log(user.hobby);
console.log(user.hobby[0]);

3. 함수

1. 클래스 밖에 있으면서 상태를 변경시키는 것이 아니므로 메서드가 아닌 함수라고 한다.

2. 함수는 1급 객체이므로 주소가 있기 때문에 변수에 담을 수 있다.

// 함수

// 함수의 기본형
function m1(){
    console.log("m1 호출됨");
}

// let을 적는 의미가 없음 (모든 타입이니까)
function m2(n1, n2){
    console.log(`${n1}, ${n2}`);
}

// 클래스 밖에 있고 상태를 변경시키는 메서드가 아닌 함수라고 한다.
function m3(){
    return 10;
}

m1();
m2(1,2);
let r = m3();
console.log("r", r);

4. Lamda

1. Lamda

1. = 익명함수

2. let 변수명 = () ⇒ {};

2. Lamda Expression

1. return이 돼서 값이 대입될 수 있어야 표현식이다.

2. 즉, 함수의 리턴 값을 변수에 담을 수 있고 변수를 console.log를 통해 출력한다.

let m3 = (n1, n2) => {
    return n1 + n2;
  };

let r1 = m3(5,6);
console.log(r1);

3. 중괄호 내부 코드가 한 줄일 경우 다음과 같이 표현 가능하다.

let m33 = (n1, n2) => n1 + n2;

3. Lamda Statement

1. return 되는 값이 없다.

2. 단독으로 함수를 호출해서 사용한다.

let m2 = (n1, n2) => {
    console.log(`${n1}, ${n2}`);
  };

4. 전체 코드

// 람다식
// function m1() {
//     console.log("m1 호출됨");
//   }
  
//   function m2(n1, n2) {
//     console.log(`${n1}, ${n2}`);
//   }
  
//   function m3(n1, n2) {
//     return n1 + n2;
//   }

// 함수가 1급 객체라서 주소가 있기 때문에 변수에 담을 수 있다.
let m1 = function() { // 익명함수 - 어차피 m1 안에 담겨있으니까 함수명 중요X -> 생략 
    console.log("m1 호출됨");
  };

m1();

// Lamda식 : 이름이 없는 익명함수
let m11 = () => { // 어차피 익명함수일거면 "function"도 생략하자 -> 람다식
    console.log("m11 호출됨");
  };

m11();

// Lamda Statement (return X)
let m2 = (n1, n2) => {
    console.log(`${n1}, ${n2}`);
  };

m2(1,2);

// Lamda Expression (return O -> 변수로 받을 수 있다.)
let m3 = (n1, n2) => {
    return n1 + n2;
  };

let r1 = m3(5,6);
console.log(r1);

// Lamda Expression 중괄호 내부 코드가 한 줄일 경우. {return n1 + n2;}와 동일하다
let m33 = (n1, n2) => n1 + n2;
let r2 = m33(1,5);
console.log(r2);

// Lamda Statement (return이 안되니까) - 지원되는 방식이지만 사용X(개념이 헷갈린다)
let m333 = (n1, n2) => console.log(n1+n2);
m333(10,50);

// Lamda Expression(표현식) (1줄, 2줄 이상)
let k1 = () => 5;
let k2 = () => {
    return 5;
};

// Lamda Statement(문장) (중괄호 생략X (지원되는 방식이지만 아직은 사용X 개념 완벽히 이해되면 써도 됨))
let k3 = () => {
    console.log(5);
};