TODAY TOTAL
Front-End (10)
[Vue] 기초-2

 

v-for-exer.html

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="http://cdn.jsdelivr.net/npm/vue"></script>
    <style>
        /* 화면에 렌더링 할 때 사용할 제목의 색상을 파란색으로 정의 */
        .blue_style {color: blue}
    </style>
</head>
<body>
    <div id="app">
        <h1>윤고랭이가 좋아하는 과일은?</h1>
        <ul>
            <!-- v-for를 통해서 반복문으로 aFruits 과일 배열 데이터를 가져옴 -->
            <li v-for="(items, index) in aPersons">
                <!-- aFruits 안의 항목을 하나씩 꺼내서 HTML로 렌더링 -->
                <p>번호 : {{ index }}</p>
                <p>이름 : {{ items.name }}</p>
                <p>나이 : {{ items.age }}</p>

            </li>
        </ul>
    </div>
    <script>
        Vue.config.devtools=true;
        //F12 개발자모드 출력
    var app = new Vue({
        el : '#app',
        data : {
            aPersons: [
                {
                    name : '홍길동',
                    age : 27
                },
                {
                    name : '이순신',
                    age : 30
                },
                {
                    name : '강감찬',
                    age : 35
                }
            ]
        }
    });
    </script>

</body>
</html>

for...in:

반복문은 객체의 모든 열거 가능한 속성애 대해 반복

기본적인 for문과는 다르지만, 프로퍼티를 순회 할 수 있도록 합니다.

 

루프마다 객체의 열거할 수 있는 프로퍼티의 이름을 지정된 변수에 대입

 

 

for(변수 in 객체) {

       객체의 모든 열거할 수 있는 프로퍼티의 개수만큼 반복적으로 실행하고자 하는 실행문;

}

 

<li v-for="(items, index) in aPersons">

items,index는 변수이고 aPersons라는 객체

 

 

::결과화면

 

프로퍼티 개수만큼 실행됨.


 

computed.html

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="http://cdn.jsdelivr.net/npm/vue"></script>
    <style>
        /* 화면에 렌더링 할 때 사용할 제목의 색상을 파란색으로 정의 */
        .blue_style {color: blue}
    </style>
</head>
<body>
    <div id="app">
        <p>원본 문장 : "{{ sOriginalMessage }}"</p>
        <p>대문자 변환 문장 : "{{ fnUpperCaseMsg }}"</p>
    </div>
    <script>
        Vue.config.devtools=true;
    new Vue({
        el : '#app',
        //data는 메스태시 안에 넣을 값이 간단할 때 사용
        data : {
            sOriginalMessage : 'How are you?'
        },
        // computed는 머스태시 안에 넣을 JS 로직이 복잡할 때 사용
        computed: {
            fnUpperCaseMsg: function() {
                return this.sOriginalMessage.toUpperCase();
            }
        }

        // computed 속성
        // 머스태시에 작성할 로직이 복잡하면 함수로 정의할 때
        // 계산량이 많아서 캐시가 필요할 때

        // methods 속성
        // 뷰의 이벤트 핸들러 로직을 함수로 정의할 때
    });
    </script>

</body>
</html>

 

computed :

템플릿 내에 표현식을 넣으면 편하다. 하지만 간단한 연산 일때만 이용하는 것이 좋은데,

왜냐하면 너무 많은 연산을 템플릿 안에서 하면 코드가 비대해지고 유지보수가 어렵다.

 

복잡한 로직이면 사용하는게 computed 속성

 

 

component_basic.html

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="http://cdn.jsdelivr.net/npm/vue"></script>
    <style>
        .fruit_style {
            border : 1px solid #ccc;
            background-color: white;
            padding-left : 1em;
        }
    </style>
</head>
<body>
    <div id="app">
        <h1>{{ sTitle }}</h1>
        <favorite-fruits></favorite-fruits>
        <favorite-fruits></favorite-fruits>
    </div>
    <script>
        Vue.config.devtools=true;
        Vue.component('favorite-fruits',{
            data: function() {
                return {
                    aFruits : 
                [
                    { sFruitName : '사과'}
                    ,{ sFruitName : '오렌지'}
                    ,{ sFruitName : '수박'} 
                ]
                }
            },
            template:`
            <div>
                <div v-for="item in aFruits" class = "fruit_style">
                    <p>좋아하는 과일 : {{ item.sFruitName }}</p>
            </div>
                <br>
            </div> `
        })
    new Vue({
        el : '#app',

        data : {
            sTitle : 'How are you?'
        }
    });
    </script>

</body>
</html>

template :

HTML, CSS 등의 마크업 속성과 뷰 인스턴스에서 정의한 데이터 및 로직들을 연결하여

사용자가 브라우저에서 볼 수 있는 형태의 HTML로 변환해 주는 속성입니다.

 

 

<div>
                <div v-for="item in aFruits" class = "fruit_style">
                    <p>좋아하는 과일 : {{ item.sFruitName }}</p>
                </div>
                <br>

</div> `

 

이 형태를 HTML로 변환해줘서 보여준다.

머스태시를 쓸 수 있다.

 

 

 

 

methods.html

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="http://cdn.jsdelivr.net/npm/vue"></script>
    <style>
        /* 화면에 렌더링 할 때 사용할 제목의 색상을 파란색으로 정의 */
        .blue_style {color: blue}
    </style>
</head>
<body>
    <div id="app">
        <p>클릭 숫자   : {{ nClicks }}</p>
        <p>카운트 다운 : {{ fnCounter }}</p>
        <button v-on:click="fnIncrement"> 눌러줘 </button>
    </div>
    <script>
        Vue.config.devtools=true;
    new Vue({
        el : '#app',

        data : {
            nClicks: 0
        },
        computed: {
            fnCounter: function() {
               return 10 - this.nClicks
               //클릭 할 때마다 차감이 된다.
            }
        },
        methods : {
            fnIncrement() {
                this.nClicks++;
                //methods 렌더링이 일어날때마다 항상 실행
            }
        }

    });
    </script>

</body>
</html>

 

methods:

종속된 값이란 개념없이 렌더링이 일어날 때마다 계속 호출이 된다.

 

그러면 computed와 다른 점은 뭘까

 

computed는 계산해야하는 목표 데이터를 정의하는 '선언형' 프로그래밍 방식

종속 대상의 변경이 일어나기 전까지는 호출이 되지 않고

 

methods는 렌더링이 일어날 때마다 항상 함수를 실행합니다.

 

computed는 반환하는 결과를 캐싱 해줍니다.

 

하지만 헤비, 무거운 로직이라면 렌더링이 일어날 때마다 항상 실행하는 methods보단

computed 속성으로 구현하는게 더 좋다.

 

 

'Front-End > Vue' 카테고리의 다른 글

[Vue] 기초  (0) 2021.07.22
  Comments,     Trackbacks
[Vue] 기초

 

 

브라우저는 크롬으로 사용.

Vue를 크롬 확장프로그램을 추가해야하는데

구글에 'Vue 크롬 확장 프로그램' 이라 치면 바로 첫번째로 구글 확장프로그램이 나온다 클릭

 

 

 

설치를 하면 

Vue 확장 아이콘 오른쪽버튼 누르고 '확장 프로그램 관리' 클릭

 

허용 스위치 하기

 

먼저 Vue사이트에서 기본적인 문법, 용어 알아보기

 

https://kr.vuejs.org/v2/guide/instance.html

 

Vue 인스턴스 — Vue.js

Vue.js - 프로그레시브 자바스크립트 프레임워크

kr.vuejs.org

 

hello_vuejs.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="http://cdn.jsdelivr.net/npm/vue"></script>
    //Vue script
</head>
<body>
    <div id="main">
        <p>{{ sTitle }}</p>
        <p>{{ sName }}</p>
        <p>{Hi}</p>
    </div>
    <script>
     Vue.config.devtools=true; //이걸 써줘야 F12 눌렀을때 Vue 탭이 나온다.
     
        //1. 뷰 CDN 설정
        //2. 뷰 인턴스 생성
        //3. 화면에 데이터 바인딩
        //   데이터 출력은 머스태시({{ }}) 템플릿 사용
        new Vue({
            el: "#main",
            data: {
                sTitle: "안녕하세요!",
                sName: "누구세요?",
                Hi : "Hi"
            }
        });

    </script>

</body>
</html>

 

 

데이터출력은 {{}} 머스태시 템플릿

 

이게 머스태시. 비슷하긴 하넹

 

 

 

Vue는 초보자도 쉽게 할 수 있는거 같고, 눈에 보기에도 명확해서 보기 좋은거 같다.

 

 

v-bind.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="http://cdn.jsdelivr.net/npm/vue"></script>
    <style>
        /* 화면에 렌더링 할 때 사용할 제목의 색상을 파란색으로 정의 */
        .blue_style {color: blue}
    </style>
</head>
<body>
    <div id="main">
        <!-- v-bind 안에서도 스크립트를 사용할 수 있으므로 변수와 문장을 연결 -->
        <!-- v-bind 디렉티브 -->
        <h1 v-bind:class="sColorName + '_style'">안녕하세요</h1>
        <p>{{sTitle}}</p> <!-- HTML 엘리먼트값을 만듦 -->
        <input v-bind:value="sDate"><!-- HTML 어트리뷰트 값을 만듦 -->
    </div>
    <script>
        Vue.config.devtools=true;
        //1. 뷰 CDN 설정
        //2. 뷰 인턴스 생성
        //3. 화면에 데이터 바인딩
        //   데이터 출력은 머스태시({{ }}) 템플릿 사용
        new Vue({
            el: '#main',
            data:{
                //Date 객체의 getFullYear() 메서드로 올해 문장 준비
                sTitle: '반가워',
                sDate: '올해 연도:' + new Date().getFullYear(),
                sColorName:'blue'
            }
        });

    </script>

</body>
</html>

 

하면서 뭔가 신기하다 생각한 v-model

 

v-model.html

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="http://cdn.jsdelivr.net/npm/vue"></script>
    <style>
        /* 화면에 렌더링 할 때 사용할 제목의 색상을 파란색으로 정의 */
        .blue_style {color: blue}
    </style>
</head>
<body>
    <div id="main">
        <p>{{sMsg}}</p>
        <!-- v-model은 데이터를 가져오는 동시에 입력이 동기화됨 -->
        <!-- v-bind와 v-model의 차이점 -->
        <!-- v-bind는 단방향 데이터 바인딩이고 -->
        <!-- v-model은 양반향 데이터 바인딩 -->
        <input v-model:value="sMsg">
    </div>
    <script>
        Vue.config.devtools=true;
    var main = new Vue({
        el : '#main',
        data : {
            sMsg : 'input에 글자를 입력하면 위에도 같이 바뀝니다.'

        }
    });
    </script>

</body>
</html>

 

v-model은

디렉티브를 사용하여 폼 input과 textarea 엘리먼트에 양방향 데이터 바인딩을 생성할 수 있습니다. 입력 유형에 따라 엘리먼트를 업데이트 하는 올바른 방법을 자동으로 선택합니다.

 

v-on.html

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="http://cdn.jsdelivr.net/npm/vue"></script>
    <style>
        /* 화면에 렌더링 할 때 사용할 제목의 색상을 파란색으로 정의 */
        .blue_style {color: blue}
    </style>
</head>
<body>
    <div id="app">
       <h1>{{sTitle}}</h1>
       <!-- 버튼을 누르면  fnChangeTitle 메서드로 이벤트
            핸들러 수행-->
       <button v-on:click="fnChangeTitle">ㅇㅇ</button>
       //버튼을 클릭 시  fnChangeTitle 호출, onclick과 같은 기능
    </div>
    <script>
        Vue.config.devtools=true;
    var app = new Vue({
        el : '#app',
        data : {
            sTitle: "ㅈㅇㅇ ㅎㅁㅇ ㅈ ㄲㅇ"
        },
        methods: {
            fnChangeTitle() {
                //this는 Vue 객체의 인스턴스를 가리킴
                this.sTitle = 'ㅈㄱ ㅇㅈㅇ!'
            }
            
        }
    });
    </script>

</body>
</html>

v-on은

디렉티브를 사용하여 DOM 이벤트를 듣고 트리거 될 때 JavaScript를 실행합니다.

버튼을 누르면 함수를 호출

 

 

v-for.html

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="http://cdn.jsdelivr.net/npm/vue"></script>
    <style>
        /* 화면에 렌더링 할 때 사용할 제목의 색상을 파란색으로 정의 */
        .blue_style {color: blue}
    </style>
</head>
<body>
    <div id="app">
        <h1>혁명이가 좋아하는 과일은?</h1>
        <ol>
            <!-- v-for를 통해서 반복문으로 aFruits 과일 배열 데이터를 가져옴 -->
            <li v-for="items in aFruits">
                <!-- aFruits 안의 항목을 하나씩 꺼내서 HTML로 렌더링 -->
                <p>{{ items.aFruitName }}</p>

            </li>
        </ol>
    </div>
    <script>
        Vue.config.devtools=true;
    var app = new Vue({
        el : '#app',
        data : {
            aFruits: [
                {aFruitName: '사과'},
                {aFruitName: '참외'},
                {aFruitName: '청포도'}
            ]
        }
    });
    </script>

</body>
</html>

for은 말그대로 반복 data 배열에 있는 과일들을 차례로 나오게

 

 

v-if.html

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="http://cdn.jsdelivr.net/npm/vue"></script>
    <style>
        /* 화면에 렌더링 할 때 사용할 제목의 색상을 파란색으로 정의 */
        .blue_style {color: blue}
    </style>
</head>
<body>
    <div id="app">
        <h1>{{bFlag}}</h1>
        <p v-if="bFlag == true">앞면!</p>
        <p v-else>뒷면!</p>
    </div>
    <script>
        Vue.config.devtools=true;
    var app = new Vue({
        el : '#app',
        data : {
            bFlag : Math.random() > 0.5

        }
    });
    </script>

</body>
</html>

조건부 렌더링 v-if 

 

디렉티브는 조건에 따라 블록을 렌더링하기 위해 사용됩니다. 블록은 디렉티브의 표현식이 true 값을 반환할 때만 렌더링됩니다.

 

 

 

 

'Front-End > Vue' 카테고리의 다른 글

[Vue] 기초-2  (0) 2021.07.22
  Comments,     Trackbacks
[JavaScript] 5. Object(객체)
1. Object

 

  • JS의 데이터 타입 중 하나
  • 관련 데이터,함수 집합체
  • JS의 거의 모든 객체는 Object의 인스턴스
  • 객체는 key와 value의 집합체 (object = {key : value};)
  • 하나의 properties는 key:value로 구성됨

 

1. Literals and properties (데이터 그리고 특성)

 

Literals는 변하지 않는 데이터를 말한다.

 

const obj1 = {}; // 'obect literal' 문법
const obj2 = new Object(); // 'object constructor' 문법

function print(person) {
  console.log(person.name);
  console.log(person.age);
}

const yyeo = { name: `yyeo`, age: 4 };
//key는 name, value는 yyeo

print(yyeo); // > yyeo \n 4
//Runtime(프로그램이 동작하고 있을 때)
// dynamically typed(동적 타입) language

// can add properties later (나중에 속성 추가 가능)
yyeo.hasJob = true;
console.log(yyeo.hasJob); // > true

// can delete properties later (나중에 속성 삭제 가능)
delete yyeo.hasJob;
console.log(yyeo.hasJob); // > undefined

 

2. Computed(계산된) properties

 

  • object['key']
  • 동적으로 key의 value를 받아와야 할 때 유용한 방법
2. Computed properties
 console.log(yyeo.name);
 //그 값이 필요할때
 //or
 console.log(yyeo['name']);
 yyeo['hasJob'] = true;
 console.log(yyeo.hasJob);
 //그 값이 뭔지 모를때 즉,Runtime때 받아야할때
 //key는 항상 StringType으로
 function printValue(obj,key) {
     console.log(obj[key]);
 }
 printValue(yyeo,'name');
 printValue(yyeo,'age');
 
 //동적으로 키를 받을때 유용~

 

 

3. Property shorthand(단축 속성명)

 

  • key와 value의 이름이 동일하다면 간단하게 정의할 수 있다.
//3. Property value shorthand

function makeperson(name,age) {
    //다른계산을 하지않고 순수하게 오브젝트를 생성하는 놈들은 대문자로 쓴다
    //this - {};
    this.name = name;
    this.age = age;
    // return  {
    //     name,
    //     age,
    //     //키와 값이 값으면 name, 으로 써도 된다.
    //     //key, value
    // };
}

//리턴으로 써도 되고, this로도 써도 된다.

 

4. Constructor function (생성자 함수)

 

  • class가 없었을 때 방식
  • 함수명 첫 글자는 대문자로 (약속)
  • 호출 시 class처럼 new  키워드 사용
// 위 class와 기능적으로 똑같음
function Person(name, age) {
  this.name = name;
  this.age = age;
}

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
	}
}

const person2 = new Person(`gunwoo`, 28.8);
console.log(person2); // > Person {name: "yyeo", age: 28.8}

 

5. in 연산자

 

  • 해당 object에 key를 체크하는 연산자
  • key in obj

 

6. for in, for of 문

 

 

// for (key in obj)
for (const key in ellie) {
  console.log(key); // > name \n age \n hasJob
}

// for (value of iterable)
const array = [1, 2, 4, 5];

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

//위 아래와 동일하지만 아래를 쓸 경우 좀 더 간결,간단해진다

for (const value of array) {
  console.log(value); // > 1 \n 2 \n 4 \n 5
}

 

7. Cloning (복제)

 

  • Object.assign은 얕은 복사이다

 

//7. cloning
// Object.assign(dest, [obj1, obj2, obj3...])
const user = { name : 'yyeo',age : '20'};
const user2 = user;
user2.name = 'coder';
console.log(user);

//old way
const user3 = {};
for ( key in user) {
    user3[key] = user[key];
}
console.clear();
console.log(user3);

//const user4 = {};
//Object.assign(user4, user);
//console.log(user4);
//위와 동일 아래꺼가 더 간결.
const user4 = Object.assign({},user);
console.log(user4);
//assign 열거할 수 있는 하나 이상의 출처 객체로부터 
//대상 객체로 속성을 복사할 때 사용합니다. 대상 객체를 반환합니다.

//another example
const fruit1 = { color: 'red'};
const fruit2 = { color: 'blue', size: 'big'};
const fruit3 = { color: 'pink', size: 'small'};
const mixed = Object.assign({},fruit1,fruit2,fruit3);
//3에서부터 1까지 덮어씌운다. 3블랙은 2로 2의 블랙은 1로
console.log(mixed.color);
console.log(mixed.size);

 

복제 관련 링크

https://www.daleseo.com/js-objects-clone/

 

자바스크립트 객체 복제 방법

Engineering Blog by Dale Seo

www.daleseo.com

 

  Comments,     Trackbacks
[JavaScript] 4_X. 클래스,객체,인스턴스

 

클래스(Class)

  • 객체를 만들어 내기 위한 틀(ex.붕어빵 틀)
  • 번수,메소드의 집합

객체(Object)

  • 데이터 즉, 구현할 대상
  • 클래스 내에(선언) 생성된 실체

인스턴스(Instance)

  • 클래스를 바탕으로 소프트웨어 세계에 구현된 구체적인 실체
  • 클래스로 만든 객체가 인스턴스라고 생각하면 쉽다
  • 실체화된 인스턴스는 메모리에 할당
  • 변수에 클래스를 저장할때는 new 연산자 사용

 

'Front-End > JavaScript' 카테고리의 다른 글

[JavaScript] 5. Object(객체)  (0) 2021.06.18
[JavaScript] 4. 클래스  (0) 2021.06.13
[JavaScript] 3. 함수  (1) 2021.06.13
[JavaScript] 2. 데이터 타입  (0) 2021.06.07
[JavaScript] 1. 콘솔출력과 async 그리고 defer  (2) 2021.06.07
  Comments,     Trackbacks
[JavaScript] 4. 클래스

 

1. 클래스

class는 자바스크립트에 최근에 생겼다. ES6때 생겼다.

그럼 그전에는 어떻게 썼을까? 

 

class 생기기 전에는 class를 정의하지 않고, 바로 object(객체)를 만들었다.

 

class person {


        name; //속성
        age; //속성
        
        speak(); //행동(method)

    }
        

사람이라는 틀 속에 이름과 나이가 있다 거기에 행동(메소드)을 추가 그것이 class다.

속성만 있는 클래스로도 만들 수 있다. 

즉, 클래스는 실제로 사물,물체들을 클래스로 만든 것이다.

하지만 클래스는 정의만 내리지 데이터는 없다. 그 데이터를 object이다.

 

붕어빵으로 예를 들면

 

class는 붕어빵 틀

object(객체)는 붕어빵안에 넣을 재료들 팥,피자,녹차(?) 따라 팥붕어빵,피자붕어빵이 되는 것이다.

 

 

class object
class는 object(인스턴스)를 만들 수 있는 틀 class를 이용해서 data를 넣어서 만드는 것이 object
class 자체에는 data가 들어 있지 않다 class를 이용해서 새로운 instance를 생성하면 그게 바로
object가 되는 것
틀을 정의해서 한번만 선언 object는 class를 이용해서 무수히 많이 만들 수 있다
class는 정의만 한 것이라서 실재 메모리에 올라가지 않음 class는 이용해 만든 object는 실재 메모리에 올라간다

 

 

  • Class 선언과 Object 생성

 

class Person {
  // constructor
  constructor(name, age) {
    // fields
    this.name = name;
    this.age = age;
  }

  // methods
  speak() {
    console.log(`${this.name}: hello!`);
  }
}

const ellie = new Person(`ellie`, 20); // 인스턴스(object) 생성
console.log(ellie, typeof ellie); // > Person {name: "ellie", age: 20} "object"
console.log(ellie.name); // > ellie
console.log(ellie.age); // > 20
ellie.speak(); // > ellie: hello!

 

  • Getter & Setter

 

class User {
	// 생성자 필드
  constructor(firstName, lastName, age) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.age = age;
  }

	// getter
  get age() {
    return this._age;
  }

	// setter
  set age(value) {
    // if (value < 0) {
    //   throw Error(`-1은 안됩니다..`);
    // }
    this._age = value < 0 ? 0 : value; // 생성자 필드명 앞에 _ 를 붙이는게 관습
  }
}
const user1 = new User(`Steve`, `job`, -10); // set
console.log(user1.age); // get

//get을 이용해서 리턴 할 수 있고, set을 이용해서 값을 설정 할 수 있다.

 

 

  • 상속(Inheritance)
  1. 부모 class에 있는 모든 것들이 자식 class에 포함이 됨.
  2. 공통되어지는 값들을 extends 키워드로 재사용 할 수 있다
  3. 부모 class의 값을 변경하면 자식(상속 받은) class의 값들도 자동으로 변경됨

 

  • 다형성(Polymorphism)
  1. 필요한 메서드를 재정 해서 사용 할 수 있다.(오버라이딩)
  2. 오버라이딩 한 상태에서 부모 class의 메서드를 사용하고 싶으면 super 키워드를 사용 하면 된다.

 

// 부모 class
class Shape {
  constructor(width, height, color) {
    this.width = width;
    this.height = height;
    this.color = color;
  }

  draw() {
    console.log(`drawing ${this.color} color of`);
  }

  getArea() {
    return this.width * this.height;
  }
}

class Rectangle extends Shape {}
class Triangle extends Shape {
  draw() {
    super.draw(); // 오버라이딩 해도 부모 class 메소드 호출 가능
    console.log(`📐`);
  }

	// 오버라이딩(다형성)
  getArea() {
    return (this.width * this.height) / 2;
  }
}

const rectangle = new Rectangle(20, 20, `blue`);
rectangle.draw();
console.log(rectangle.getArea());

const triangle = new Triangle(20, 20, `red`);
triangle.draw();
console.log(triangle.getArea());

 

  Comments,     Trackbacks
[JavaScript] 3. 함수
1. 함수

 

  • 절차적인 프로그램에선 함수가 중요
  • sub-program (함수 여러 번 사용 가능)
  • 작업 수행 및 값을 계산
  • 자바스크립트에서는 함수를 object로 간주하기때문에 변수를 할당 할 수도 있고 매개변수(parameter) 전달, 함수를 리턴 할수도 있다.
  • 함수는 변수처럼 취급이 가능하다
  • 변수에 값으로 할당 가능
  • 다른 함수에 인수로 전달 가능
  • 다른 함수에 의해 반환 가능

 

function name(param1, param2) {

	body...
    return ;
//하나의 함수에는 하나의 기능만 추가하자!
}

function print() {
	console.log('Hello');
}

print();
//Hello 밖에 출력을 못하는 쓸모없는 함수

function print(message) {
	console.log('message');
}

print('Hello@@');
//print( )괄호 안에 있는 건 매개변수이며
//출력 할때 print('Hello@@')라고 했을때 그 매개변수 자리에 Hello@@ 들어간다.
//그래서 위의 함수보단 더 유용한 함수가 된다~

 

자바스크립트 vs 타입스크립트

 

js

function log(msg) {
    console.log(msg);
    return 0;
}

log(`Hello`);
//자바스크립트는 타입이 없기 때문에 명확하지 않다.

 

ts

 

// TS
function log(msg: string): number {
    console.log(msg);
    return 0;
    
//지금은 배우지 않았지만 그냥 비교!
//타입스크립트는 명확하게 타입을 알 수 있어 굿굿

 

 

1. parameter(매개변수)

 

paramter와 argument 차이

 

parameter는 매개변수 Variable 인자 (parameter = 매개변수 = 변수)

들어오는 인자가 매개체 역할을 하기 때문에 매개변수라고 부름

 

argument는 전달인자 value 인수 (argument = 전달인자 = 값)

함수를 호출할 때 값을 전달한다고 해서 전달인자라고 부름

 

 

parameter는 값,참조로 전달 할 수 있다.

 

function changeName(obj) {
	obj.name = `coder`;
}
const ellie = { name: `ellie` };
changeName(ellie);
console.log(ellie); // > {name: "coder"}

 

  • Default parameters (기본 매개 변수)
function showMessage(msg, from = `unknown`) {
  console.log(`${msg} by ${from}`);
}
showMessage(`Hi!!`);

//파라미터의 기본값을 지정해준다.

 

  • Rest parameters (ES6에서부터 추가됨)
function printAll(...args) {
  for (let i = 0; i < args.length; i++) {
    console.log(args[i]); // > dream, coding, ellie: 순서대로 출력됨.
  }
}
printAll(`dream`, `coding`, `ellie`);

//배열 인자를 받을때 유용하다

 

매개변수를 보면 ...이 있는데 이것이 rest 매개변수

dream, ellie, good의 인자를 받는데 3개의 값이 담겨져 있는 배열로  printAll에 전달

그리고 for문으로 하나씩 출력


 

함수에서는 Return 있다.

 

리턴이 없으면 알아서 undefined을 리턴한다.

 

function sum(a, b) {
  return a + b;
}
const result = sum(1, 2); // > 3
console.log(result)

//매개변수 a,b에 1,2를 넣고 리턴하면 1+2 그 값이 result에 들어간다.
//그리고 출력

 

여기서, 중요!

 

// bad
function upgradeUser(user) {
  if (user.point > 10) {
    // long upgrade logic ...
  } else {
    return;
  }
}

// good
function upgradeUser(user) {
  if (user.point <= 10) {
    return;
  }
  // long upgrade logic ...
}

bad 부분은 괄호 안에 로직이 많으면 가독성이 떨어진다. 

good부분은 조건이 틀릴때 빠르게 리턴 하고 괄호 밖에 로직을 작성하면 가독성이 좋다.

 

 

2. 함수 표현(function expression)

 

  • 함수 선언은 정의 된 것보다 더 일찍 호출 될 수 있습니다. (호이스팅됨)
  • 함수 표현식은 실행이 도달하면 생성됩니다. (정상적)

여기서 호이스팅이란?

        1. 함수 안에 있는 선언들을 모두 끌어 올려서 해당 함수 유효 범위의 최상단엔 선언하는 것
        2. var변수 선언과 함수선언문에서만 호이스팅이 일어난다.
        3. var변수/함수의 선언만 위로 끌어 올려지며, 할당은 끌어 올려지지 않는다.
        4. let/const 변수 선언과 함수표현식에서는 호이스팅이 발생하지 않는다.
        5. 함수가 호출되기도 전에 위에 작성을 해도 호출이 된다.

 

// print(); // > error : 당연히 선언 전에 호출하니 error 발생!
const print = function () { // 함수를 변수에 할당
	// 익명 function
  console.log(`print`);
};
print(); // > print
const print2 = print; // print2 변수는 print 변수와 같은 메모리 주소의 function을 바라보고 있음
print2(); // > print

// console.log(sum(1, 3)); // > 4 : 함수 호이스팅되서 error 발생 안함.
function sum(a, b) { // 함수 선언식
  return a + b;
}
const sum2 = sum; // 선언한 함수도 변수에 할당 쌉가능
console.log(sum2(1, 3)); // > 4

 

  • 콜백함수(callback function)

 

파라미터로 함수를 전달받아 함수의 내부에서 실행하는 함수

콜백함수는 '익명함수'를 쓴다. 어차피 내부에 실행되기 때문에 

이름을 붙이지 않아도 된다.

function randomQuiz(answer, printYes, printNo) {
  if (answer === `love you`) {
    printYes();
  } else {
    printNo();
  }
}

// anonymous function
const printYes = function () {
  console.log(`yes!`);
};

// named function
// 스택 추적 디버깅 할 때 더 나은 방법
// 재귀
const printNo = function print() {
  console.log(`no!`);
  // print(); // 재귀
};

randomQuiz(`wrong`, printYes, printNo);
randomQuiz(`love you`, printYes, printNo);

 

 

  • Arrow(화살표) function

항상 익명

함수를 간결하게 만들어준다.

배열/리스트에서 효과적이다.

 

const simplePrint = () => console.log(`simple~!!`);
const add = (a, b) => a + b;
const simpleMultiply = (a, b) => {
	// do something more
	return a * b;
};

 

  Comments,     Trackbacks
[HTML] 기본 태그

 

블록 태그 div. span 차이

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>div & span</title>
</head>
<style type="text/css">
    
    #div0 {background-color: aquamarine;
            padding: 5px;}
    #span0 {background-color: coral;
            }  
</style>
<body>
    
    <br>
    <div id="div0"> 안녕하세요 윤고랭이 사진실입니다.</div>
    <br>
    <span id="span0">안녕하세요 윤고랭이 사진실입니다.</span>
</body>
</html>

 

div는 외각 전체까지 영역이고

span은 문장까지만 영역입니다.

 

줄바꿈에도 차이가 있습니다. 

 


리스트

 

순서 있는 리스트 <ol></ol>

 

순서 없는 리스트 <ul></ul>

 

정의 리스트 <dl></dl>

 

리스트 아이템

 

<li></li> (</li>생략가능)

 


 

표에 사용 되는 태그들

 

<table> : 표 전체를 담는 컨테이너

 

<caption> : 표 제목

 

<thead> : 헤딩 셀 그룹

 

<tfoot> : 바닥 셀 그룹

 

<tbody> : 데이터 셀 그룹

 

<tr> : 행. 여러 <td>, <th> 포함

 

<th> : 열 제목(헤딩) 셀

 

<td> : 데이터 셀

 


 

<header>

 

페이지나 섹션의 머리말 표현

 

<nav>

하이퍼링크들을 모아 놓은 특별한 섹션

페이지 내 목차를 만드는 용도

 

<section>

문서의 장 혹은 절을 구성하는 역할

일반 문서에 여러 장이 있듯이 웹 페이지에 여러 <section> 가능

 

<article>

 

본문과 연관 있지만, 독립적인 콘텐츠를 담는 영역

보조기사, 블로그, 포스트, 댓글 등 기타 독립적인 내용

<article>에 담는 내용이 많은 경우 여러 <section> 둘 수 있음

 

<aside>

 

본문에서 약간 벗어난 노트나 팁

페이지의 오른쪽,왼쪽에 배치

 

<footer>

 

꼬리말 영역, 주로 저자나 저작권 정보

 

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>div & span</title>

<style >
    html,body {margin: 0; padding: 0; height: 100%;}
    .header {width: 100%; height: 15%;
    background: yellow;}

    .nav{width: 15%; height: 70%; float: left;
    background: orange;}
    
    .section{width: 70%; height: 70%; float: left;
    background: olivedrab;}

    .aside{width: 15%; height: 70%; float: left;
    background: orange;}

    .footer{width: 100%; height: 15%; clear: both;
    background: purple;}
   
</style>
</head>
<body>
    
    <header class="header">header</header>
    <nav class="nav">nav</nav>
    <section class="section">section</section>
    <aside class="aside">aside</aside>
    <footer class="footer">footer</footer>
</body>
</html>

 

float : left; 

 

float : right

 

clear : both;

(흐름제거) 오른쪽, 왼쪽을 취소

즉, clear는 취소하자! 라는 뜻으로 오른쪼 왼쪽에 사진이나 글이 있어도

밑으로 내려갑니다.


 

<a> 태그

 

문서를 링크 시키기 위해 사용하는 태그

 

href : 연결할 주소 링크

 

target : 링크를 클릭 할 때 새창인지 바로 열지 선택

 

  • _self : 링크를 클릭한 창에 열기
  • _blank : 새창
  • parent : 부모창으로 열기
  • _top : 가장 상위 창

title : 링크에 커서를 올릴 때 설명이 나오게 설정

 


 

 

 

 

--계속 수정할 예정--

  Comments,     Trackbacks
[JavaScript] 2. 데이터 타입

 

1. 데이터 타입

 

 

  • Variable(변수, 변할 수 있는 값)

 

let (ES6에서 추가됬다)

 

ES6이전에는 Var를 썼다.

그냥 let만 쓰면 된다.

 

 

  • Block scope

 

 

 

  • Constant

 

 

 

const 자료형 일 때, 불변 데이터 유형 : primitive, 고정 된 객체 (예: object.freeze())

변경 가능한 데이터 유형 : 기본적으로 모든 객체는 JS에서 변경 가능합니다.

const 자료형을 선호하는 이유는 다음과 같다.

 - security (보안)

 - thread safety (스레드 안전성)

 - reduce human mistakes (인간의 실수 감소)

 

  • Variable types

 

// number
const count = 17; // integer
const size = 17.1; // decimal number
console.log(`value: ${count}, type: ${typeof count}`);
console.log(`value: ${size}, type: ${typeof size}`);
// speicla numeric values: infinity, -infinity, NaN
const infinity = 1 / 0;
const negativeInfinity = -1 / 0;
const nAn = `not a number` / 2;
console.log(infinity); // > Infinity
console.log(negativeInfinity); // > -Infinity
console.log(nAn); // > NaN

// string
const brendan = 'brendan';
const greeting = 'hello ' + brendan;
console.log(`value: ${greeting}, type: ${typeof greeting}`); // `${}` -> template literals (string)

// boolean
// false: 0, null, undefined, NaN, ''
// true: any other value
const canRead = true;
const test = 3 < 1; // false
console.log(`value: ${canRead}, type: ${typeof canRead}`);
console.log(`value: ${test}, type: ${typeof test}`);

// null
let nothing = null;
console.log(`value: ${nothing}, type: ${typeof nothing}`);

// undefined
let x;
// let x = undefined
console.log(`value: ${x}, type: ${typeof x}`);

// symbol
// - create unique identifiers for objects (개체에 대한 고유 식별자 생성)
const symbol1 = Symbol('id');
const symbol2 = Symbol('id');
console.log(symbol1 === symbol2); // > false : 동일한 string을 작성해도 다른 symbol로 만들어짐
// - string 이 같을떄 동일한 심볼을 만들고 싶으면..
const gSymbol1 = Symbol.for('id');
const gSymbol2 = Symbol.for('id');
console.log(gSymbol1 === gSymbol2); // > true 
// console.log(`value: ${symbol1}, type: ${typeof symbol1}`); // > error
console.log(`value: ${symbol1.description}, type: ${typeof symbol1.description}`);

메모리에 값이 저장되는 방법은 2가지!

primitive 타입은 값 자체를 저장

object타입은 레퍼런스(주소)가 저장된다.

 

 

 

결과값

자바스크립트는 알아서 생각해서 값을 출력한다 

'7' + 5를 보면 '7' 문자와 문자를 붙이는 줄 생각해 75로 나오고 타입도 String이 됬다

'8' / '2'는 가운데에 /가 있어 8/2를 생각해 4를 출력한다. 그리고 타입이 number가 됬다

편할수도 있지만 헷갈리고 어떤 타입인지 모를 수 있기 때문에

 

런타임에서 타입을 정해질때 에러가 많이 발생하는데 이것 때문에 TypeScript가 나왔다.

 

  Comments,     Trackbacks