반응형
반응형

 

<!DOCTYPE html>
<html lang="en">
<script>
    let number = 123;
    console.log(typeof(number + "")) // string

    let letter = "123";
    console.log(typeof(+ letter));   // number
</script>
<body>

</body>
</html>

 

  • "문자" → "숫자"
    • + 문자 라고 적을시 숫자로 변환된다
  • "숫자" → "문자"
    • 숫자 + "" 라고 적을시 문자로 변환된다

 

반응형
반응형
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>

<body>
    <input type="file" id="fileInput">
</body>
<script>
    fileInput = document.getElementById('fileInput');

    fileInput.addEventListener('change', function() {
        const file = fileInput.files[0];
        console.log(URL.createObjectURL(file));
        // blob:http://localhost:63342/8a91fb57-0311-4375-b2e4-84bb0c9fc3d6
    });
</script>
</html>

Blob(Binary Large Object)은 말 그대로 큰 객체를 저장하는 타입으로 큰 객체란 일반적으로 이미지, 비디오, 사운드 등과 같은 멀티미디어객체들을 주로 가리킵니다. createObjectURL는 메모리에 있는 객체(일반적으로 Blob이나 File 객체)에 대한 임시 URL을 생성가능합니다

반응형
반응형

📝event.target, event.currentTarget

<!DOCTYPE html>
<html lang="en">
<script>
    let onLogin = () => {
        console.log(event.target)
        // <span>Google</span>

        console.log(event.currentTarget)
        // <button onclick="onLogin()">
        //     <span>Google</span>
        // </button>
    }

</script>

<body>
    <button onClick=onLogin()>
        <span>Google</span>
    </button>
</body>
</html>

 

이벤트 버블링이라고 했을 때 event.target은 이벤트가 위임되어 발생하는 자식 위치를 의미(클릭한 자식 요소)를 하고 currentTarget의 경우 이벤트가 직접적으로 붙은 부모의 위치를 반환한다

 

🔗 참고 및 출처

https://velog.io/@edie_ko/JavaScript-event-target%EA%B3%BC-currentTarget%EC%9D%98-%EC%B0%A8%EC%9D%B4%EC%A0%90

 

반응형
반응형

📝falsy 값

falsy값이란 false, null, undefined, 0, NaN, 빈 문자열('') 등의 값을 의미한다

 

 

📝||= , &&= 

/** || **/
console.log( "" || undefined || null || "익명"); // 익명
console.log( "" || "Hello" || null || "익명");   // Hello

let num = 10;
num ||= 0;        // same as [num = num || 0]
console.log(num); // 10

/** && **/
console.log(1 && 2 && undefined && 3) ; // undefined
console.log(1 && 2 && null && 3) ;      // null
console.log(1 && 2 && '' && 3) ;        // null
console.log(1 && 2 && false && 3) ;     // false

let age = undefined;
age &&= 10;       // same as [age = age && 10]
console.log(age); // null

자바스크립트에선 변수에서 쓰이는 논리연산자를 축약할 수 있는데 일단 논리연산자를 변수에 사용하는 경우는 Null과 같은 falsy값을 처리하기 위해서 사용한다

밑에 설명할 ??와 다른 점은 0의 값도 falsy값으로 처리한다

||의 경우 falsy값이 있으면 가장 마지막 값이 들어가고 그렇지 않으면 가장 맨 앞에 있는 Truthy한 값이 들어간다

&&의 경우falsy값이 있으면 해당 falsy값이 들어가고 그렇지 않으면 마지막 값이 들어가게 된다

 

📝??

let myName = null;
let yourName;

let name = myName ?? "Mike";
console.log(name); // Mike

name = yourName ?? "Tom";
console.log(name); // Tom

${체크할 값} ?? ${falsy값일시 반환할  값}으로 동작하며 체크할 값이 정상이면 체크할 값이 변수에 할당됩니다 그렇지 않으면 ${falsy값일시 반환할 값}이 들어갑니다

 

 

🔗 참고 및 출처

https://ko.javascript.info/logical-operators

반응형
반응형

📝setTimeout, setInterval

function fn(name) {
    console.log(`say my name ${name}`);
}

setTimeout(fn, 3000, 'Mike[Timeout]');    // 3초 후에 fn 함수 작동
setInterval(fn, 1000, 'Mike [Interval]'); // 매 1초 fn 함수 작동

setTimeoutms 후에 동작하게끔 지연이 가능합니다

setInterval매 ms 마다 계속 동작하는 기능을 제공합니다

 

📝call, apply, bind

const mike = {
    name : "Mike",
    age : 20
}

const tom = {
    name : "Tom",
    age : 10
}

function showThisName() {
    console.log(`name : ${this.name}, age : ${this.age}`);
}

showThisName();          // name : undefined, age : undefined
showThisName.call(mike); // name : Mike, age : 20
showThisName.call(tom);  // name : Tom, age : 10

call 함수모든 함수가 사용이 가능하며 해당 함수에 this값을 줄 수 있습니다.

showThisName에는 name과 age라는 값이 없지만 mike랑 tom을 불러서(call) 값을 할당해줍니다

 

function update(birthYear, occupation) {
    this.birthYear = birthYear;
    this.occupation = occupation;
}

update.call(mike, 1999, "singer");
console.log(mike); // { name: 'Mike', age: 20, birthYear: 1999, occupation: 'singer' }

update.apply(tom, [1900, "teacher"]);
console.log(tom); // { name: 'Tom', age: 10, birthYear: 1900, occupation: 'teacher' }


const num = [3, 10, 1, 6, 4];
const minNum = Math.min.apply(null, num);
const maxNum = Math.max.call(null, ...num);
console.log(`min : ${minNum}, max : ${maxNum}`); // min : 1, max : 10

applycall하고 하는 행위가 동일한데 매개변수를 배열로 받습니다

update.call(mike, 1999, "singer")를 보면 update함수 안에 mike가 주소 매핑됩니다 그래서 update에서 필드를 추가하거나 할 때 mike에 직접적인 영향을 끼칩니다 (주소 매핑이기 때문에) 1999와 singer는 update의 매개변수입니다 즉, call(this값, 해당 함수의 매개변수들...) 이런 식으로 사용합니다

 

const user = {
    name: "Mike",
    showName : function () {
        console.log(`hello, ${this.name}`);
    }
};

user.showName(); // hello, Mike

let fn = user.showName;
fn();            // hello, undefined

fn.call(user);  // hello, Mike
fn.apply(user); // hello, Mike

let boundFn = fn.bind(user);
boundFn();      // hello, Mike

bind의 경우 this를 영구히 가질 수 있는 함수로 만들어줍니다 call하고 apply하고 매우 유사해보이는데 call과 apply의 경우 해당 함수를 새롭게 만들진 않지만 bind의 경우 새로운 함수를 만듭니다 (boundFn) 그 곳에는 this로 선정한 객체가 들어갑니다

 

반응형
반응형

📝렉시컬 환경 (Lexcial), 클로저 (Closure)

let globalVar = '전역';

/** Lexical 환경 테스트 **/
function fn1() {
    let fn1Var = 'fn1'
    function fn2(){
        let fn2Var = 'fn2'
        console.log(globalVar, fn1Var, fn2Var);
    }
    fn2();
}

/** Lexical 환경이 아니라면? **/
function fn4(){
    let fn4Var = 'fn2'
    console.log(globalVar, fn3Var, fn4Var);
}
function fn3() {
    let fn3Var = 'fn1'
    fn4();
}

fn1();   // 전역 fn1 fn2 [Lexical]
//fn3(); // Error (fn1Var is not defined) [Not Lexical]

자바스크립트의 함수는 어디에서 실행했냐가 아닌 어디에서 정의했냐가 중요하다 자바스크립트는 이러한 방식을 채택하는데 이러한 방식 렉시컬 스코프라고한다

 

이러한 걸 도대체 어디서 쓸 수 있을까?

const myFunc = () => {
    let x = 10; // 접근 불가능 (은닉화)
    // 클로저
    const plusTen = (y) => {
        x = x + y;
        console.log(x);
    }

    return plusTen;
}

const addFunc = myFunc();
addFunc(5);  // 15
addFunc(10); // 25

이러한 방식으로 사용이 가능한데 x라는 변수에는 직접 접근을 못하지만 실제로 사용은 하고 있다 이러한 걸 클로저라고 한다 자세히 이야기하자면 반환된 내부함수자신이 선언됐을 때의 환경(렉시컬 스코프)인 스코프를 기억하여 스코프 밖에서 호출되어도 그 환경에 접근할 수 있는 함수이다

 

 

🔗 참고 및 출처

https://velog.io/@chojs28/%EB%A0%89%EC%8B%9C%EC%BB%AC-%EC%8A%A4%EC%BD%94%ED%94%84%EC%99%80-%ED%81%B4%EB%A1%9C%EC%A0%80-%EA%B7%B8%EB%A6%AC%EA%B3%A0-%EC%BB%A4%EB%A7%81

https://www.youtube.com/watch?v=bwwaSwf7vkE&t=18s 

반응형
반응형

📝배열의 구조 분해 할당

let users = ['Mike', 'Tom', 'Jane'];
let [user1, user2, user3] = users;
console.log(`user1 : ${user1}, user2 : ${user2}, user3 : ${user3}`)
// user1 : Mike, user2 : Tom, user3 : Jane

배열의 구조 분해 할당이란 기본적인 구조로 A라는 배열의 요소를 서로 다른 변수에 담고 싶을 때 되게 유용합니다

 

let [a1,b1,c1] = [1,2];
console.log(`a1 : ${a1}, b1 : ${b1}, c1 : ${c1}`);
// a1 : 1, b1 : 2, c1 : undefined

let [a2=3, b2=4, c2=5] = [1,2];
console.log(`a2 : ${a2}, b2 : ${b2}, c1 : ${c2}`);

값이 없는 경우 undefined을 반환하고 초기값 설정을 줄 수 있습니다

 

/** --- 활용 1 --- **/
let str = "Mike-Tom-Jane";
let [user1, user2, user3] = str.split('-');
console.log(`user1 : ${user1}, user2 : ${user2}, user3 : ${user3}`)
// user1 : Mike, user2 : Tom, user3 : Jane

/** --- 활용 2 --- **/
let X = 1; let Y = 2;
console.log(`X : ${X}, Y : ${Y}`); // X : 1, Y : 2
[X, Y] = [Y, X];
console.log(`X : ${X}, Y : ${Y}`); // X : 2, Y : 1

/** --- 활용 3 --- **/
[first, second] = [second, first]; // swap variables

/** --- 활용 4 --- **/
let [first] = [1, 2, 3, 4];
console.log(first); // outputs 1

/** --- 활용 5 --- **/
function f([first, second]: [number, number]) {
  console.log(first);
  console.log(second);
}
f([1, 2]);

X, Y의 변수 값을 서로 바꿀 때 아주 유용하고 split로 나눈 변수를 바로 넣는 등 다양하게 활용이 가능합니다

 

 

📝객체의 구조 할당 분해

let user = {name: "Mike", age: 30};
let {name, age} = user;
let {name: userName, age: userAge} = user;

console.log(`name : ${name}, age : ${age}`); // name : Mike, age : 30
console.log(`userName : ${userName}, userAge : ${userAge}`); // userName : Mike, userAge : 30

객체도 구조 할당 분해가 동일하게 가능합니다

 

let player = {
    name: "Jane",
    age: 18
};

let {name:playerName, age:playerAge, gender:playerGender} = player;
console.log(`playerName : ${playerName}, playerAge : ${playerAge}, playerGender : ${playerGender}`)
// playerName : Jane, playerAge : 18, playerGender : undefined

let redPlayer = {
    name: "Jane",
    age: 18,
    gender : "female"
};

let {name:redName, age:redAge, gender:redGender = "male"} = redPlayer;
console.log(`redName : ${redName}, redAge : ${redAge}, redGender : ${redGender}`)
// redName : Jane, redAge : 18, redGender : female

초기값이 없는 경우 동일하게 undefined를 반환하며 초기값 설정이 가능합니다

 

 

📝나머지 매개변수

function User (name, age, ...skills) {
    this.name = name;
    this.age = age;
    this.skills = skills;
}

const user1 = new User("Mike", 30, "html", "css");
const user2 = new User("Tom", 30, "React");

console.log(user1); // User { name: 'Mike', age: 30, skills: [ 'html', 'css' ] }
console.log(user2); // User { name: 'Tom', age: 30, skills: [ 'React' ] }

나머지 매개변수함수에서 인자값이 여러개가 필요할 때 하나하나 추가할 수 없으니 공통된 특성을 ...을 이용해 배열로 받을 수 있습니다 여기에서 보면 ...skills가 나머지 매개변수로 쓰였고 나머지 매개변수를 쓰려면 맨 마지막에 둬야합니다

 

let numbers1 = [1, 2, 3, 4];
let numbers2 = [5, 6, 7];
let totalNumbers = [...numbers1, ...numbers2, 8, 9];
console.log(totalNumbers); // [1, 2, 3, 4, 5, 6, 7, 8, 9]

...을 배열에 사용하면 요소들로 분해가 됩니다 배열을 합치거나 등 다양하게 활용이 가능합니다

 

let arr = [1, 2, 3];
let arr2 = [...arr];

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

let user = {name: "Mike", age: 30};
let user2 = {...user, numbers: [...numbers1, 5, 6]};

user2.name = "Tom";
console.log(user.name);    // Mike
console.log(user2.name);   // Tom
console.log(user2.numbers) // [ 1, 2, 3, 4, 5, 6 ]

배열뿐만 아니라 객체도 동일하게 이용이 가능합니다

 

반응형
반응형

📝include

let arr = [1, 2, 3];
console.log(arr.includes(2)); // true
console.log(arr.includes(8)); // false

배열 안에 해당 값이 있는지 여부를 반환합니다

 

📝find, findIndex

let userList = [
    { name: "Mike", age : 30},
    { name: "Jane", age : 27},
    { name: "Tom", age : 10}
]

let find = userList.find((user) => {
    return user.age > 19 ? true : false;
})
console.log(find); // { name: 'Mike', age: 30 }

let findIndex = userList.findIndex((user) => {
    return user.age < 19 ? true : false;
})
console.log(findIndex); // 2    // { name: "Tom", age : 10}

find 해당 조건에 만족하면 해당 값을 찾아(find) 반환합니다 return true로 반환될 거 같지만 해당 값이 있으면 해당 값을 찾아서 반환해주고 없는 경우 return false로는 undefined가 반환됩니다

findIndex 해당 조건에 만족하면 해당 인덱스 값을 반환합니다 만족하는 값이 없으면 -1을 반환합니다

 

 

📝split

const users = "Mike,Jane,Tom,Toney";
const result = users.split(",");
console.log(result); // [ 'Mike', 'Jane', 'Tom', 'Toney' ]

const result2 = users.split("");
console.log(result2);
// [
//     'M', 'i', 'k', 'e', ',',
//     'J', 'a', 'n', 'e', ',',
//     'T', 'o', 'm', ',', 'T',
//     'o', 'n', 'e', 'y'
// ]

문자열을 split로 나눌 때 해당 요소들을 배열로 반환합니다 만약 아무값도 안 적을 경우 한 글자씩  분해시킵니다

 

📝isArray

let numbers = [1, 2, 3, 4];
console.log(typeof numbers); // object

console.log(Array.isArray(numbers)); // true

typeof로 Array을 조사하면 object가 나오는데 이러면 이게 배열인지 다른 Object인지 알 수가 없습니다 isArray Array인 경우 true를 아니면 false를 반환합니다

 

🔗 참고 및 출처

https://www.youtube.com/watch?v=G360D6lqrfo&list=PLZKTXPmaJk8JZ2NAC538UzhY_UNqMdZB4&index=6 
https://www.youtube.com/watch?v=pJzO6O-aWew&list=PLZKTXPmaJk8JZ2NAC538UzhY_UNqMdZB4&index=7

반응형
반응형

📝splice

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

/** (2) replace **/
let arr2 = [1, 2, 3, 4, 5];
let result = arr2.splice(1, 3, 100, 200); // 1번째 인덱스에서 3개를 지우고 100, 200을 추가
console.log(arr2);   // [1, 100, 200, 5]
console.log(result); // [2, 3, 4]

/** (3) insert **/
let arr3 = ["나는", "철수", "입니다"];
arr3.splice(1, 0, "대한민국", "소방관"); // 삭제 없이 1번째 인덱스 앞에 추가가 된다
console.log(arr3); // [ '나는', '대한민국', '소방관', '철수', '입니다' ]

splice함수는 배열 삭제, 추가, 업데이트가 가능하고 여러가지 파라미터를 가질 수 있습니다

 

  • (1)과 같이 1번째 인덱스 부터 2개를 삭제할 수 있습니다
  • (2)와 같이 1번째 인덱스로부터 3개를 삭제위치에 데이터를 넣을 수도 있습니다
  • (3)와 같이 따로 삭제는 안 하고 1번째 인덱스 앞에 배열을 추가할 수도 있습니다

 

📝indexOf, lastIndexOf

let arr = [1, 2, 3, 4, 5];
console.log(arr.indexOf(1));        // 0      // 1을 찾는다
console.log(arr.indexOf(3, 2));     // 2      // 2번째 인덱스 부터 3을 찾는다

console.log(arr.indexOf(5, 3));     // 4      // 2번째 인덱스 부터 3을 찾는다
console.log(arr.lastIndexOf(5, 3)); // -1     // 5를 3번째 인덱스부터 앞으로가며 찾는다

indexOf찾고자 하는 요소의 인덱스값을 반환 받을 수 있습니다 만약 없으면 -1을 반환합니다

lastIndexOfindexOf처럼 찾는 요소의 인덱스 값을 찾는데 뒤에서 부터 찾습니다

 

 

 

🔗 참고 및 출처

https://www.youtube.com/watch?v=G360D6lqrfo&list=PLZKTXPmaJk8JZ2NAC538UzhY_UNqMdZB4&index=6 
https://www.youtube.com/watch?v=pJzO6O-aWew&list=PLZKTXPmaJk8JZ2NAC538UzhY_UNqMdZB4&index=7

반응형