반응형

2020-01-15

#3. 0 Making a JS Clock part One (09:54)

 

Momentum

 

시계를 만들어보자.

항상 무언갈 만들 때 작은 부분으로 나눠서 진행한다고 한다. 

그리고 함수를 정의할때 init() 함수를 만들고 그 안에 함수들을 생성하고 

init() 함수를 호출해서 한다고 한다. 

 

 

html

<!DOCTYPE html>
<html>
<head>
  <title>Parcel Sandbox</title>
  <meta charset="UTF-8" />
  <link rel="stylesheet" href="index.css">
</head>

<body>
<div class="js-clock">
  <h1>00:00</h1>
</div>
<script src="index.js"></script>
<scipt src="clock.js"></scipt>
</body>
</html>

JavaScript

const clockContainer = document.querySelector(".js-clock");
const clockTitle = clockContainer.querySelector("h1");

function getTime() {
    const date = new Date();
    const minutes = date.getMinutes();
    const hours = date.getHours();
    const seconds = date.getSeconds();
    clockTitle.innerText=`${hours}:${minutes}:${seconds}`;
}

function init() {
    getTime();
}
init();

이번 강의에서는 시간을 구하고 브라우저에 출력하는 코드를 짜보았다. 

위에서 말했듯이 작은부분을 나눠서 진행을 해보면 

html문서에 script태그를 이용해서 자바스크립트 파일을 연결해준다. 

연결해주고 나서 <div> 태그를 이용하여 js-clock이라는 클래스 이름을 부여하고 

<div> 태그 안에 <h1> 태그를 이용하여 00:00이라는 시간을 의미해줄 수 있는 문자를 써준후

 

자바스크립트 파일로 이동한다. 

 

이동후 html 코드 안에서 <div class="js-clock">을 객체화시켜 clockContainer에 저장 후 

<div> 클래스 안에 있는 <h1> 태그를 clockTitle 변수에 저장시킨다. 

이후 시간을 불러오는 함수를 정의한다. 

Date(); 객체를 생성시켜 시간을 구하는 각 getMinutes, getHurs(), getSeconds(); 함수를 이용해 

date, minutes, hours, seconds 변수에 저장시킨 후 innerText를 이용해 

<h1> 태그를 담아둔 clockTitle변수에 시간을 초기화시켜준다. 

 

이후 

init() 함수 안에 getTime() 함수를 넣고 init()을 실행하는 코드를 작성하고 브라우저를 확인하면 

시간이 잘 나오는 걸 확인할 수 있다. 

지금 코드의 문제로는 현재시간이 계속 업데이트되지 않는다. 

업데이트를 하려면 계속 새로고침을 해주어야 하는데 

다음 강의에서 setInterval 함수를 이용해서 자동으로 업데이트되게 하는 방법에 대해서 알려준다고 한다. 

 


#3. 1 Making a JS Clock part Two (07:17)

setInterval

ternary operator(삼항 연산자)

 

JavaScript

const clockContainer = document.querySelector(".js-clock");
const clockTitle = clockContainer.querySelector("h1");

function getTime() {
    const date = new Date();
    const minutes = date.getMinutes();
    const hours = date.getHours();
    const seconds = date.getSeconds();
    clockTitle.innerText=`${hours<10 ?`0${hours}`:hours}:${minutes <10 ? `0${minutes}`: minutes}:${seconds < 10 ? `0${seconds}`: seconds}`;
}

function init() {
    getTime();
    setInterval(getTime,1000);
}
init();

위의 이전 강의에 기존 코드에서 바뀐 코드들을 한번 보자. 

init() 함수 부분에 setInterval 함수를 추가해놓은걸 확인할 수 있는데

 

setInterval함수에 대해 짧게 말하자면 두 개의 인자를 받는다 첫 번째 인자에는 함수를 두 번째 인자에는 ms단위의 간격으로 함수가 다시 재실행되야하는지를 정해준다. 

 

추가하고 나서 시간을 나타내는 데 있어서 1시 1분 1초와 같이 1의 자리인 시간대에서 01 02 03 이런 식으로 나오는 게 보기에 더 직관적이어서 바꾸고자 하는데 이럴 때 IF-ELSE문을 이용해서 할 수 있겠지만 

여기서는 삼항 연산자를 이용해서 간단하게 바꿔보았다. 

 

삼항 연산자는 IF? ~~~ : ELSE 이런 식으로 써주면 된다. 

hours가 10 이하라면 앞에 0을 붙여주도록 하고 아니라면 그냥 그대로의 hours가 출력되도록.

 

이제 자바스크립트에서의 시간을 불러오는 함수는 여기서 끝이고 

다음 강의에서는 사용자의 이름을 불러오는 방법에 대해서 강의를 한다고 한다. 

 


#3. 2 Saving the User Name part One (13:24)

 

form

 

localstorage

브라우저의 localstorage에는 작은 자바스크립트의 정보들이 있다. 

위에서 만든 코드의 브라우저에서 확인해보자.

그리고 여기다 장난을 해볼 것이다.

이를 코드로 구현해서 브라우저에 띄워보겠다.

 

html

<!DOCTYPE html>
<html>
<head>
  <title>Parcel Sandbox</title>
  <meta charset="UTF-8" />
  <link rel="stylesheet" href="index.css">
</head>

<body>
<div class="js-clock">
  <h1>00:00</h1>
  <form class="js-form form">
    <input type="text" placeholder="what is your name?"/>
  </form>
  <h4 class="js-greetings greetings"></h4>
</div>


<script src="clock.js"></script>
<script src="greeting.js"></script>
</body>
</html>

css

.form,
.greetings{
  display: none;
}
.showing{
  display: block;
}

JavaScript

const form =document.querySelector(".js-form"),
    input = form.querySelector("input"),
    greeting= document.querySelector(".js-greetings")

    const USER_LS = "currentUser",
        SHOWING_CN = "showing";



function paintGreeting (text) {
    form.classList.remove(SHOWING_CN)
    greeting.classList.add(SHOWING_CN)
    greeting.innerText = `Hello${text}`
}
function loadName(){
    const currentUser = localStorage.getItem(USER_LS)
    if(currentUser === null){
        // he is not
    } else {
        // she is
        paintGreeting(currentUser);
    }
}

function init() {
    loadName()
}
init();

위의 코드를 보면 일단 form 태그는 무시하자 다음 강의를 위한 초석이다. 

이번 강의에서 설명하고자 하는 부분은 따로 있다. 

h4태그에 클래스를 js-greetings(js전용) greetings(css전용)을 추가하자

+ 클래스를 만들 때도 하나만을 위한 클래스로 만드는 게 좋다. 

 

아무튼 추가 후 css에서 

. greetings를 display:none으로 브라우저에서 지워주는 걸 확인하고 

그아래 

. showing 클래스를 css에 작성해서 block 형식으로 바꿔주는 코드를 작성해준다. 

 

이후 JS파일로 넘어와서 

js-greetings태그를 객체화시켜서 greeting안에 넣어준다 

그리고 showing과 currentUser 문자를 담을 변수인 USER_LS와 SHOWING_CN을 생성하고 

loadName 함수를 만들고 그 안에 

localStorage객체의 getItem 함수를 이용해서 USER_LS (currentUser)라는 key에 대한 value를 가져와

currentUser변수에 넣어주고 

 

if-else 조건문으로 존재 여부를 확인해서 없다면 기존 적용되어있는 display:none에는 변화가 없을 테니 

브라우저에는 아무것도 안나올 것이고 

존재하면 else문에 paintGreeting(crrentUser) 함수를 실행할 것인데 

 

위의 paintGreeting 함수를 설명해보자면 

기존 display:none의 값을 block으로 바꿔서 브라우져에 띄워지게 만들고

innerText로 Hello currentUSER에 대한 VALUE값이 출력되게 만드는 것.

다음 강의에서는 input의 값을 저장하고 사용자를 불러오는 거에 대해서 해본다고 한다. 

 

반응형
반응형

2021-01-08 수업내용

동적 페이지를 요청해서 DB서버에 있는 내용을 가져와보기. 

 

  1. 2013년도의 전국지역 시/도 구/군 동/읍/면 데이터를 DB서버에 넣는다.
  2. 윈도용 톰캣 서버를 연다.
  3. JSP파일을 작성해서 톰캣 웹에 띄워본다.
  4. SELECT 요소를 HTML에 작성한다.
  5. Ajax를 이용해서 시/도, 구/군, 동/읍/면 데이터를 웹의 리프레시 없이 조회할 수 있게 한다.
  6. 시/도의 특정 시/도를 조회시 구/군의 조회 목록이 자동으로 나오도록 동/읍/면 또한 

 

1.

2.

3.

sido.jsp생성- 생성된파일을 Java\apache-tomcat-8.5.61\webapps\ROOT\zipcode위치에 넣고 웹으로 확인

<%@ page contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8" %>
<%@ page import="java.sql.DriverManager" %>
<%@ page import="java.sql.Connection" %>
<%@ page import="java.sql.PreparedStatement" %>
<%@ page import="java.sql.ResultSet" %>

<%
    String DRV = "org.mariadb.jdbc.Driver";
    String URL="jdbc:ㄴㅇㄹ:3306/bigdata";
    String USR = "ㅇㅇ";
    String PWD = "ㅇㅇㅇ";

    Connection conn = null; // db연결객체 생성
    PreparedStatement pstmt = null;
    ResultSet rs = null;

    String sql = "select distinct sido from zipcode_2013";
    StringBuilder sb = new StringBuilder();

    try {
        Class.forName(DRV); // 드라이버로드
        conn = DriverManager.getConnection(URL, USR, PWD);// db접속
        pstmt = conn.prepareStatement(sql); // sql문실행
        rs = pstmt.executeQuery(); // rs에 sql문실행반환값 저장

        while (rs.next()) { // rs훑어서 sb에 저장 , 붙여서
            sb.append(rs.getString(1)).append(',');
            // 서울,경기,인천,부산,.....
        }


    } catch (Exception ex) {
        ex.printStackTrace();
    } finally {
        if (rs != null) rs.close();
        if (pstmt != null) pstmt.close();
        if (conn != null) conn.close();
    }

    //출력
    out.write(sb.toString());
%>

gugun.jsp 생성- 생성된파일을 Java\apache-tomcat-8.5.61\webapps\ROOT\zipcode위치에 넣고 웹으로 확인

<%@ page contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8" %>
<%@ page import="java.sql.DriverManager" %>
<%@ page import="java.sql.Connection" %>
<%@ page import="java.sql.PreparedStatement" %>
<%@ page import="java.sql.ResultSet" %>

<%
    String DRV = "org.mariadb.jdbc.Driver";
    String URL="jdbc:mariadb://으어억:3306/bigdata";
    String USR = "아악";
    String PWD = "나는몰랑";

    Connection conn = null;
    PreparedStatement pstmt = null;
    ResultSet rs = null;

    String sql = "select distinct GUGUN from zipcode_2013 where SIDO like ?";
    StringBuilder sb = new StringBuilder();

    // get 방식으로 전달한 시/도 데이터를 JSP로 가져오기
    // http://127.0.0.1:8080/zipcode/gugun.jsp?sido=서울
    request.setCharacterEncoding("utf-8");
    String sido = request.getParameter("sido");

    try {
        Class.forName(DRV);
        conn = DriverManager.getConnection(URL, USR, PWD);
        pstmt = conn.prepareStatement(sql);
        pstmt.setString(1,sido);
        rs = pstmt.executeQuery();

        while (rs.next()) {
            sb.append(rs.getString(1)).append(',');
            // 서울,경기,인천,부산,.....
        }


    } catch (Exception ex) {
        ex.printStackTrace();
    } finally {
        if (rs != null) rs.close();
        if (pstmt != null) pstmt.close();
        if (conn != null) conn.close();
    }

    out.write(sb.toString());
%>

dong.jsp생성 - 생성된 파일을Java\apache-tomcat-8.5.61\webapps\ROOT\zipcode위치에 넣고 웹으로 확인

<%@ page contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8" %>
<%@ page import="java.sql.DriverManager" %>
<%@ page import="java.sql.Connection" %>
<%@ page import="java.sql.PreparedStatement" %>
<%@ page import="java.sql.ResultSet" %>

<%
    String DRV = "org.mariadb.jdbc.Driver";
    String URL="jdbc:mariadb://나는몰랑:3306/bigdata";
    String USR = "아악";
    String PWD = "으어억";

    Connection conn = null;
    PreparedStatement pstmt = null;
    ResultSet rs = null;

    String sql = "select distinct DONG from zipcode_2013 where SIDO = ? and GUGUN = ?";
    StringBuilder sb = new StringBuilder();



    // get 방식으로 전달한 시/도 데이터를 JSP로 가져오기
    // http://127.0.0.1:8080/zipcode/dong.jsp?sido=서울&gugun=강남구
    request.setCharacterEncoding("utf-8");
    String sido = request.getParameter("sido");
    String gugun = request.getParameter("gugun");

    try {
        Class.forName(DRV);
        conn = DriverManager.getConnection(URL, USR, PWD);
        pstmt = conn.prepareStatement(sql);
        pstmt.setString(1, sido);
        pstmt.setString(2, gugun);
        rs = pstmt.executeQuery();

        while (rs.next()) {
            sb.append(rs.getString(1)).append(',');
            // 서울,경기,인천,부산,.....
        }


    } catch (Exception ex) {
        ex.printStackTrace();
    } finally {
        if (rs != null) rs.close();
        if (pstmt != null) pstmt.close();
        if (conn != null) conn.close();
    }

    out.write(sb.toString());
%>

4.

<H2>주소검색</H2>
<div>
    <select id="sido">
    </select>

    <select id="gugun">
    </select>

    <select id="dong">
    </select>
</div>
<p id="addr"></p>

5.

    // 비동기방식으로 가져올 데이터의 url정의
    let url1 = 'http://127.0.0.1:8080/zipcode/sido.jsp'
    let url2 = 'http://127.0.0.1:8080/zipcode/gugun.jsp'
    let url3 = 'http://127.0.0.1:8080/zipcode/dong.jsp'

    // 변수선언
    let sido = document.getElementById('sido')
    let gugun = document.getElementById('gugun')
    let dong = document.getElementById('dong');

    // 시도에 목록 출력
    // zipcode_2013테이블에서 시도만 추출해서
    // sido라는 select요소에 option 요소 추가

    function getsido() {
        req = new XMLHttpRequest(); 
        req.onreadystatechange = function () {
            if (req.readyState == 4 && req.status == 200) { //서버응답 및 요청 성공이면
                makesido(req.responseText);			//데이터들을 makesido함수의 매개변수로넣는다.
            }
        };
        req.open('get', url1, true); //데이터가져올 주소 
        req.send();                  // 보내기까지
    }
    getsido(); // 맨처음 시/도는 디폴트값으로 주기위해 실행시킨다.
    		   // 구/군 동은 시/도를 선택해야 그에 맞는 이벤트를 생성시켜 데이터를 가져오게해야함
               // ex) 서울시를 선택하면 서울시에맞는 구/군이 와야하기 때문 
	
    //데이터가져온 함수 정의
    function makesido(sd){
    	// ,를 구분자로 시도를 배열로 저장
        let cols = sd.split(','); // ['서울','부산','','','','',....]\
		// option요소 생성
        opt = document.createElement('option');
        txt= document.createTextNode('--시/도--');
        // 옵션 자식으로 추가
        opt.appendChild(txt);
        // 옵션요소를 html id =sido 태그에 자식요소로 추가
        sido.appendChild(opt);
		
        // 배열을 훑는 반복문을 사용할땐 in이아니라 of 
        for (let col of cols) {
        	// col의내용이 없으면 continue로 반복문 탈출
            if (col == '')continue;
            opt = document.createElement('option');
            opt.value= col.trim(); // option 요소에 value 속성 추가.
            txt= document.createTextNode(col.trim());
            opt.appendChild(txt);
            sido.appendChild(opt);
        }
    }
    // 첫번째 select 요소에 이벤트핸들러 등록
    // 등록이유로는 시/도 선택하는 이벤트가 발생되면
    // 구군을 불러와야하기 때문에 'change'해서 getgugun함수가 실행되게함.
    sido.addEventListener('change', getgugun)

    // 선택한 시도로 구군을 검색해서 비동기로 처리함.
    function getgugun() {
        req = new XMLHttpRequest();
        req.onreadystatechange = function() {
            if (req.readyState == 4 && req.status ==200){
                 makegu(req.responseText);

            }
        };
        let qry= '?sido=' + sido.value;     // 검색을 위한 질의문자열 생성
        req.open('get', url2+qry, true);
        req.send();
    }
    function makegu(gg){
        let cols = gg.split(',');

        opt = document.createElement('option');
        txt= document.createTextNode('--시/군/구--');
        opt.appendChild(txt);
        gugun.appendChild(opt);

        for (let col of cols) {
            if (cols == '')continue;
            opt = document.createElement('option');
            opt.value= col.trim();
            txt= document.createTextNode(col.trim());
            opt.appendChild(txt);
            gugun.appendChild(opt);
        }
    }
    // 구/군을 가져오면 그 구/군에 맞는 동을 가져오는 이벤트 생성
    gugun.addEventListener('change', getDong)

    // 동가져오기
    function getDong(){
        req=new XMLHttpRequest();
        req.onreadystatechange= function (){
            if(req.readyState==4 && req.status==200){
                makeDong(req.responseText);
            }
        };
        let qry= '?sido=' + sido.value + '&gugun=' +gugun.value;     // 검색을 위한 질의문자열 생성
        req.open('get', url3+qry, true);
        req.send();
    }

    function makeDong(dd){
        let cols=dd.split(',');
        opt = document.createElement('option');
        txt= document.createTextNode('--동--');
        opt.appendChild(txt);
        gugun.appendChild(opt);

        for(let col of cols) {
            if(col=="")continue;
            opt=document.createElement('option');
            opt.value=col.trim();
            txt=document.createTextNode(col.trim())
            opt.appendChild(txt)
            dong.appendChild(opt)
        }

    }

</script>

6.

 

수업에서는 구까지 구현했는데 

처음 접하는 문법 이들이랑 꽤나 복잡한 코드를 보고 수업시간에는 뭐가 뭔지 몰랐는데 

천천히 수업 끝나고 코드를 살펴보니 뭔가 가닥이 잡히면서 코드가 왜 이렇게 작성되었는지 이해가 되었다. 

이해가 되어서 시간이 없어 구현이 안된 동도 내가 작성해서 구현해보니 뭔가 뿌듯하다. 

 

백지상태에서 쓰려면 시간이 어느 정도 걸리겠지만 그래도 수업시간 동안 이해가 안 돼서 주옥같았는데 

해결해서 참 다행이다. 

 

+ 자바스크립트에서의 변수 선언은 let으로 하던데 opt나 txt는 왜 let으로 선언 안 하고 그냥 적었는데 왜 그렇게 적었는지 주말 동안 알아보고 답안 나오면 물어봐야겠다. 

 

 

반응형
반응형

Ajax가 비동기로 통신한 다는 걸 알기 위한 예제 

1. HTML

<h1>Ajax</h1>
<p>Ajax 통신결과는 ?! <span id="msg"></span></p>
<div><button type="button" id="hi">인사말하기</button></div>

2.Script

 let hi = document.getElementById('hi') //html 버튼요소 가져오기
 
 // clcick상황발생시 sayhello함수가 실행되는 이벤트 생성
 hi.addEventListener('click',sayHello) 
 
 // sayhello함수 정의
 function sayHello() {
 	// html작성문의 span태그 가져오기 
    let hi = document.getElementById('msg')
    
    // XMLHttpRequest 객체 생성 - 데이터받아오기위해
    let req = new XMLHttpRequest();
    
    //onreadystatechange 설정
    req.onreadystatechange = function (){
    	   if(req.readyState==4){         // readystate : 서버 응답 속성
                    if(req.status==200){  // status : HTTP상태코드 - 요청 성공 여부확인
                        msg.innerHTML=req.responseText //서버가 보내준 응답을 텍스트형식으로 받음
                    } else msg.innerHTML=req.status
                }else{
                    msg.innerHtml=req.readyState;
                }
        }
        // 서버에 비동기방식으로 요청을 생성후 서버로 보냄
        // open(요청방식,url,비동기여부)
        req.open('get','hello.txt', true)
        req.send();
    }
  
 }
 

3. hello.txt 파일생성 helloWorld!! 내용 적기 

 

+

Document.getElementById() 메서드는 주어진 문자열과 일치하는 id 속성을 가진 요소를 찾고, 이를 나타내는 Element 객체를 반환합니다. ID는 문서 내에서 유일해야 하기 때문에 특정 요소를 빠르게 찾을 때 유용합니다.

 

EventTarget의 addEventListener() 메서드는 지정한 이벤트가 대상에 전달될 때마다 호출할 함수를 설정합니다. 일반적인 대상은 Element, Document, Window지만, XMLHttpRequest와 같이 이벤트를 지원하는 모든 객체를 대상으로 지정할 수 있습니다.

 

responseText 프로퍼티

responseText 프로퍼티는 서버에 요청하여 응답으로 받은 데이터를 문자열로 반환합니다.

 

 

반응형
반응형

2021-01-08 수업내용 정리 겸 복습

 

Ajax : asynchronous JavaScript and XML

HTTP 프로토콜을 이용해서 비동기 방식으로 데이터를 주고 받는 기법을 의미

HTTP 프로토콜은 기본적으로 동기방식의 데이터 교환만을 지원했었는데

1993년 MS의 Microsoft.XMLHTTP라는 컴퍼넌트 덕택으로

비동기 처리기술이 활성화 됨

2000년 12월, FF가 XMLHttpRequest라는 이름으로 지원

그 이후 2004년 4월, CR이 구글맵으로 통해 Ajax기술 지원.

 

+ Ajax란

Ajax는 JavaScript의 라이브러리중 하나이며 

브라우저가 가지고 있는 XMLHttpRequest 객체를 이용해서 전체 페이지를 고치지 않고도 

페이지의 일부만을 위한 데이터를 로드하는 기법이며 Ajax를 한마디로 정의하자면

JavaScript를 사용한 비동기 통신, 클라이언트와 서버간에 XML 데이터를 주고 받는 기술이라고 할 수 있다.

 

 

동기 vs 비동기 처리

동기 : 

각 작업의 처리시간에 맞춰 실행되는 방식

먼저 요청한 작업이 처리됨, 처리시간이 길어지면 나머지 작업들은 하염없이 기다려야함.

설계가 간단하고 직관적

결과가 나올때까지 아무것도 못하고 계속 대기해야 함.

 

비동기 :

모든 작업은 개별 작업의 처리시간과 상관없이 다발적으로 실행되는 방식

먼저 요청한 작업이 먼저 끝난다고 보장하지 않음

처리시간이 길어질것 같으면 다른 작업을 우선적으로 실행할 수 있음.

설계가 복잡, 결과가 나올때까지 시간이 걸리더라도 

그 동안 다른 작업을 할 수 있으므로 자원을 효율적으로 사용

+ 비동기 방식이란 ?

비동기 방식은 웹페이지를 리로드하지 않고 데이터를 불러오는 방식 이방식의 장점은 페이지 리로드의 경우 

전체 리소스를 다시 불러와야하는데 이미지, 스크립트, 기타코드등을 모두 재요청할 경우 불필요한 리소스 낭비가 발생

비동기식 방식을 이용할 경우 필요한 부분만 불러와 사용할 수 있으므로 매우 큰 장점이 있다. 

 

+ 왜 사용하는가?

기본적으로 HTTP프로토콜은 클라이언트쪽에서 Request를 보내고 Server쪽에서 Response를 받으면 이어졌던 연결이 끊어지게 되어있습니다. 그래서 화면의 내용을 갱신하기 위해서는 다시 request를 하고 response를 하면서 페이지 전체를 갱신하게 됩니다. 하지만 이렇게 할 경우 페이지의 일부분만 갱신할 경우에도 페이지 전체를 다시 로드해야하는데 엄청난 자원낭비와 시간낭비를 초래하고 말것입니다. 하지만 ajax는 html 페이지 전체가아닌 일부분만 갱신할수 있도록 

XML HttpRequest객체를 통해 서버에 request를 합니다. 이경우 json이나 xml형태로 필요한 데이터만 받아 갱신하기 때문에 그만큼의 자원과 시간을 아낄 수 있습니다. 요새 웹페이지에서 가장 중요한것은 속도가 아닐까 싶습니다. 이 이유만으로도 Ajax를 사용해야 하는 이유로써 충분합니다. 

 

 

+ Ajax의 장점

  1. 웹페이지의 속도 향상
  2. 서버의 처리가 완료 될때까지 기다리지 않고 처리 가능하다.
  3. 서버에서 Data만 전송하면 되므로 전체적인 코딩의 양이 줄어든다.
  4. 기존 웹에서는 불가능했던 다양한 UI를 가능하게 해준다.

  Ajax의 단점

  1. 히스토리 관리가 안 된다. ( 보안에 좀 더 신경을 써야한다. )
  2. 연속으로 데이터를 요청하면 서버 부하가 증가할 수 있다.
  3. XMLHttpRequest를 통해 통신을 하는 경우사용자에게 아무런 진행 정보가 주어지지 않는다. 그래서 아직 요청이 완료되지 않았는데 사용자가 페이지를 떠나거나 오작동할 우려가 발생한다.

 

오늘 수업중 코드의 내용이 제일 복잡해서 이해하기 어려운거 같다. 그리고 개념에대한 설명도 부족하다 느껴져 

구글링으로 + 부분으로 추가한부분이 coding-factory.tistory.com/143

 

[Ajax] Ajax란 무엇인가?

 Ajax란? Ajax는 JavaScript의 라이브러리중 하나이며 Asynchronous Javascript And Xml(비동기식 자바스크립트와 xml)의 약자입니다. 브라우저가 가지고있는 XMLHttpRequest 객체를 이용해서 전체 페이지를..

coding-factory.tistory.com

보고 참고했다. 

반응형
반응형

2020-01-07 수업내용 정리

 

실습예제)

 

전국 시도중 하나를 선택하면 

선택한 시도에 대한 시군구가 다음 select에 목록으로 출력되고

시군구 중 하나를 선택하면 선택한 시군구에 대한 읍면동이

다음 select에 목록으로 출력되도록함 . 

 

포인트1 : 이벤트발생시 option 태그가 동적으로 생성

포인트2 : select에서 발생가능한 이벤트는 change임

포인트3 : select에서 선택한 항목의 정보는 selectedIndex속성을 이용

포인트4 : option 태그에 텍스트를 추가하려면 createNode를 이용

 

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

<H2>주소검색</H2>
<div>
    <select id="sido">
        <option>-시도-</option>
        <option>-서울특별시-</option>
        <option>-경기도-</option>
        <option>-인천광역시-</option>
        <option>-부산광역시-</option>
    </select>

    <select id="gugun">
        <option>-시/군/구-</option>
    </select>

    <select id="dong">
        <option>-읍/면/동-</option>
    </select>
</div>
<p id="addr"></p>


</body>
</html>
  let sd = ['', '서울특별시', '경기도', '인천광역시', '부산광역시'];
    let sgg = [['-시/군/구-'],
                    ['-시/군/구-','강남구','서초구','송파구'],
                    ['-시/군/구-','광명시','구리시','성남시','수원시','고양시'],
                    ['-시/군/구-', '연수구', '남동구'],
                    ['-시/군/구-', '동래구', '해운대구','기장군']];
    let ymd= [[ ['- 읍/면/동 -'] ],
                        [['- 읍/면/동 -'],
                            [['- 읍/면/동 -'], ['논현동'],['대치동'],['삼성동'] ],
                            [['- 읍/면/동 -'], ['반포동'], ['방배동'], ['양재동'] ],
                            [ ['가락동', '석촌동', '잠실동'] ] ],
                        [['- 읍/면/동 -'],
                            ['1'],
                            ['2'],
                            ['3'],
                            ['4'],
                            ['5'] ],
                        [['- 읍/면/동 -'],
                            ['a'],
                            ['b'],
                            ['c']],
                        [['- 읍/면/동 -'],
                            ['가'],
                            ['나'],
                            ['다'] ]
    ]

    // 변수선언
    let sido = document.getElementById('sido')
    let gugun = document.getElementById('gugun')
    let dong = document.getElementById('dong');

    sido.addEventListener('change', makegu)

    function makegu(){
        // 현재 선택한 시도의 index값을 알아냄
        let sidx = sido.selectedIndex;

        // 이미 등록된 목록은 제거
        // ex 서울시를 고르면 서울시에 해당하는 구군이 나오고
        // 또다른시를 고르면 그시에맞는 구가나올텐데 서울시의 구또한 같이 나오게된다.
        // 이를 방지하기위해 또다른시를 고른다면 while문을 추가해 전에 있던 시의 구/군을 제거해줘야한다.
        while(gugun.lastChild){ // 구군목록에 option태그가 있는가 ?
            gugun.removeChild(gugun.lastChild);
        }
        // 선택한 시도에 대한 구군목록을 배열에서 가져와서
        // 구군select에 목록option으로 추가함
        // <select><option>강남구</option></select>
        // ex 위의 배열들을 변수 초기화할때 맞춰서 초기화해놨다.
        // 시/도 의 서울시의 배열위치가 1이라면 구/군의 서울시에 해당하는 구/군의 배열도 1이 되게
        for (let gg of sgg[sidx]){
            let opt = document.createElement('option');
            let txt = document.createTextNode(gg);
            opt.appendChild(txt)
            gugun.appendChild(opt);
        }
    }

    // 두번째 SELECT 요소에 이벤트핸들러 등록
    // 첫번째 항목에서 선택한 항목값과
    // 두번째 항목에서 선택한 값을 이용해서 읍면동 출력
    //포인트 0 : 핸들러명 - makedong
    //포인트 1 : 변수명 of 배열명[시도][구군]
    gugun.addEventListener('change', makedong);

    function makedong() {
        let sidx = sido.selectedIndex;
        let gidx = gugun.selectedIndex;

        while(dong.lastChild) {
            dong.removeChild(dong.lastChild)
        }

        for ( let dg of ymd[sidx][gidx]){
            let opt = document.createElement('option')
            let txt = document.createTextNode(dg)
            opt.appendChild(txt);
            dong.appendChild(opt);
        }
    }

    // 세번째 select 요소에 이벤트핸들러 등록
    // 선택한 주소 ( 시도/구군/읍면동 ) 를 p요소를 이용해서 출력
    dong.addEventListener('change', showaddr);
    let addr = document.getElementById('addr')

    function showaddr() {
        let ymdong = ' ';
        if (dong.value != '-/읍/면/동-' ) ymdong = dong.value;
        let result = sido.value + ' ' + gugun.value + ' ' + dong.value;

        addr.innerHTML='당신이 선택한 주소는 <b>' + result +'</b>';
    }

반응형
반응형

2021-01-06 ~ 07 수업 내용 정리 겸 복습

 

DOM : document object model

html/xml 문서의 각 요소에 접근하기 위해 만들어둔 객체들의 모임

 

DOM을 이용해서 문서 내 모든 요소를 접근하고 조작할 수 있음.

즉, 기존 문서에 새로운 요소를 추가/수정/삭제할 수 있고 

기존 요소를 수정/삭제할 수 있으며 스타일 역시 추가/수정/삭제할 수 있음 

 

브라우저로 웹문서를 읽으면 분석 parsing 과정을 거쳐 자동으로 생성됨

 

DOM 중에서 document 개체는 문서 자체를 의미

즉, 웹문서내 특정 요소에 접근하려면 반드시 

document 개체를 통해야만 함

한편, document객체를 통해 문서의 특정 요소를 선택하려면 아래 사진의 함수를 이용해야 함

Elements 인 녀석들은 배열 형태의 첨자를 가져와야 한다. 

DOM을 이용해서 선택한 html요소의 내용이나 속성을 변경하려면

'요소명. innerHTML'이나 또는 '요소명. 속성명'을 이용하면 된다.

또한, 선택한 html요소의 스타일을 변경하려면

요소명. style. 스타일 속성을 사용하면 된다.

 

 

DOM을 이용해서 문서에 새로운 요소나 속성을 추가하려면

createElement , createAttribute,

createTextNode, appendChild, removeChild , setAttribute 등의 함수를 이용한다.

 

실습 예제 1) 문서 객체 모델

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>문서객체모델</title>
</head>
<body>

<H1>문서객체모델</H1>
<div id="div1"></div>
<div class="div2"></div>
<div name="div3"></div>
<div></div>
<p></p>

</body>
</html>
  let div1 = document.getElementById('div1');                     //id로 요소 지정한 div
    let div2 = document.getElementsByClassName('div2');     // 클래스명으로 지정한 div
    let div3 = document.getElementsByName('div3');              //Name으로 검색
    let divs = document.getElementsByTagName('div')             // 태그명으로 검색

    let p1 = document.querySelector('p');                                     // CSS선택자로 검색   get어저구저쩌구 종합모음버전
    let p2 = document.querySelectorAll('p');                                // CSS선택자로 검색 - 결과는 복수
    let div4 =document.querySelector('#div1');                          // CSS
    let div5 =document.querySelector('.div1');                          // CSS

    div1.innerHTML = 'Hello, World!!'
    div2[0].innerHTML ='겁나게 졸려 쉬즈파인~쉬파~'    // getElements s s s 복수는 배열의상태로 가져오기 때문에 배열첨자를써주어야한다.
    div3[0].innerHTML = '한번더, Hello, World!!'
    divs[3].innerHTML='시간은 금이라구, 친구!!' // 모든 DIV태그들이 넘어오는데 비어있는 DIV가 4번째라서 3이라해놓고 한다.

    p1.innerHTML = '거어어업나~~~아아아 ~~~ 졸려부러요 오늘 3시간 30분잤다네요 실화입니까 ?'

    p2[1].innerHTML = '오에에엑 우에에엑 구와아아아악'

    div1.style.color ='red'
    div1.style.fontWeight ='bold'

    // div2 이탤릭
    div2[0].style.fontStyle='italic'
    // div3 밑줄, 녹색 글자색
    div3[0].style.textDecoration='underline'
    div3[0].style.color='green'
    // 4번째 div 궁서체
    divs[3].style.fontFamily='궁서체'
    // p1 노랑색 배경색
    p1.style.background='year';

실습 예제 2)

문서 제목에 현재시간을 표시하는

DOM 스크립트 작성

단, 현재시간을 표시하는 함수는 today라 정함.

    let title = document.getElementsByTagName('title')
    let date= new Date();
    function today () {
        let year=date.getFullYear()+'년'
        let month =(date.getMonth()+1)+'월'
        let day = date.getDay()+'일'
        let hours= date.getHours()+'시'
        let minutes= date.getMinutes()+'분'
        let seconds= date.getSeconds()+'초'

        let td = year+month+day+hours+minutes+seconds

        return td;
    }
    let time= '[' + today() + "]";
    title[0].innerHTML=time;

 

실습 예제 3) 이미지 조작하기

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h2>이미지 조작하기</h2>
<div><button type="button" id="showbtn">이미지 나와랏!</button>
<button type="button" id="hidebtn">이미지 사라져랏!</button></div>
<div id="imgdiv"></div>

</body>
</html>
let showbtn = document.getElementById('showbtn')
    let hidebtn = document.getElementById('hidebtn')
    let imgdiv = document.getElementById('imgdiv')

    showbtn.addEventListener('click', showimg);
    hidebtn.addEventListener('click', hideimg);

    // 버튼 클릭시 띄울 이미지들을 배열로 정의
    let images =['Marshal.png','curly.png','AC_Isabelle.png',]

    function showimg() {
            // img요소, src 속성을 생성
        let img = document.createElement('img');
        let src = document.createAttribute('src');

        // src 속성에 이미지경로 저장후 img 요소에 설정
       // src.value = '../img/Marshal.png'
        let idx = parseInt(Math.random()* (3-0) )
        src.value = '../img/'+images[idx]
        img.setAttributeNode(src);

        // div요소에 img 요소 추가
        imgdiv.appendChild(img)
    }
    function hideimg () {
        // imgdiv의 마지막 자식요소 선택
        // let img = imgdiv.lastChild;

        // imgdiv의 첫번째 자식요소 선택
        let img= imgdiv.firstChild;

        // 선택한 부모요소의 자식요소 제거
        imgdiv.removeChild(img);


    }

 

실습 예제 4) 동적으로 테이블 생성하기

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

<h2>동적으로 테이블생성하기 </h2>
<table id="board"></table>

</body>
</html>
     table = document.getElementById('board2')
     tbody = document.createElement('tbody')
    let thvalue = ['번호', '제목', '작성자', '작성일', '조회수']
     let tdvalue = ['1', '시간은 금이라구, 친구', 'imlsw96', '2021-01-07', '777']


     let th, td, txt =null;

     // 제목행 추가
     tr  = document.createElement('tr');
     for(let i =0; i <5; ++i){
         th = document.createElement('th')
         txt = document.createTextNode(thvalue[i])
         th.appendChild(txt)
         tr.appendChild(th)
     }
     tbody.appendChild(tr);

     // 본문행 추가
     for (let j=1; j<=15; ++j) {
     tr = document.createElement('tr')
     for (let i=0; i<5; i++) {
         td = document.createElement('td')
         txt = document.createTextNode(tdvalue[i])
         td.appendChild(txt);
         tr.appendChild(td)
     }
     tbody.appendChild(tr);
     }

     table.appendChild(tbody);

 

반응형
반응형

2021-01-06 수업 내용 정리 겸 복습

 

이벤트 event :

html 요소에 발생하는 어떤 사건 *마우스 클릭, 키 입력, 브라우저 크기 변경)을 의미

특정  요소에 어떤 사건이 발생되면 웹브라우저가 이것을 감지해서 알려줌

개발자는 이것을 이용해서 어떤 사건에 대한 처리를 구현할 수 있음

이러한 개발방식을 이벤트 중심 event-driven 프로그래밍이라 함. 

 

event의 종류 :

load 웹브라우져가 웹문서를 읽었을 때
click 마우스 버튼 클릭시
dbclick 마우스 버튼 더블 클릭시
mouserover 마우스 포인터를 특정요소에 올렸을때
keydown 키를 눌렀을때
keyup 키를 눌렀다가 뗐을때
focus 마우스로 특정요소를 선택했을 때
blur 마우스로 특정요소를 선택 해제했을때
submit submit버튼을 클릭했을 때
change 폼요소의 내용이 변경되었을 때 

 

event 처리 관련 용어 : 

이벤트 이름 : event 종류를 지칭하는 단어. (ex : click)

이벤트 속성 : 이벤트 이름에 on 접두사를 붙인 것 (ex : onclick)

이벤트 리스너(핸들러) : 이벤트 발생 시 처리할 함수 지정

 

 

event 등록방법 :

 

-인라인 이벤트 (정적 이벤트) : 

요소에 on~ 속성으로 이벤트 함수 지정

이벤트 처리 함수를 1개만 등록할 수 있음

코드가 지저분해지고 유지보수가 어려워짐 

<h1>이벤트</h1>
<button type="button" onclick="alert('Hello, World!!')" onkeyup="" >눌러보세요 !</button>
<button type="button" onclick="sayHello()"  >다시 !눌러보세요 !</button>

<script>
function sayHello(){
    alert('HelloWorld again!!')
}
</script>

-표준 이벤트 (동적 이벤트) : 

자바스크립트를 이용해서 웹문서가 브라우저에 의해

적재(loading)되었을 때 요소에 이벤트를 등록하고 처리

요소명. addEventListener(이벤트 , 함수, 캡처링)

요소명. removeEventListener

 

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>이벤트</title>
</head>


<button type="button" id="btn3" >또 눌러보세요 !</button>
<button type="button" id="btn4" >한번 더 눌러보세요 !</button>

<script>
// 표준 이벤트 처리방식 (고전)
// 인라인이벤트 처리방식에 비해 코드가 단출 0 유지보수가 용이)
window.onload= function () {
        let btn3 =document.getElementById('btn3');
        btn3.onclick = sayHello;
}


// 표준 이벤트 처리방식
// window.onload 를 사용하지 않고도 이벤트 정의 가능
// 표준 이벤트 처리방식 (고전) 방식보다도 코드가 단출

let btn4 = document.getElementById('btn4')
btn4.addEventListener('click',sayHello)
</script>

</html>

 

예제) 성적 처리해보기

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>성적처리</title>
</head>
<body>
<h3>성적처리프로그램</h3>
<form name="sjfrm">
    <div>이름 : <input type="text" name="name"></div>
    <div>영어 : <input type="text" name="eng"></div>
    <div>수학 : <input type="text" name="mat"></div>
    <div>국어 : <input type="text" name="kor"></div>
    <div><button type="button" id="sjbtn">입력완료</button></div>
</form>

<script>
    // 이름, 국어, 영어, 수학 요소 변수를 초기화
    // document.폼이름.폼변수명
    let name  = document.sjfrm.name;
    let kor  = document.sjfrm.kor;
    let eng  = document.sjfrm.eng;
    let mat  = document.sjfrm.mat;


    // 이벤트를 지정할 버튼요소 초기화 및 문서 객체화화
    let sjbtn =document.getElementById('sjbtn')
    sjbtn.addEventListener('click',computeSungJuk)

    // computeSungJuk 이벤트리스너(핸들러) 선언
    function computeSungJuk(){
        // 폼 유효성 검사
        if (!checkSungJuk(name, kor, eng, mat)) return;

        let result= name.value + "/" + kor.value + "/" + eng.value + '/' + mat.value  + '/'
        let tots= parseInt(kor.value)+parseInt(eng.value)+parseInt(mat.value);
        let avg= (tots/3).toFixed(2);
        let grd=' ';
        switch (parseInt(avg/10)){
            case 10: case 9 : grd='수'; break;
            case 7: grd='미'; break;
            case 8: grd='우'; break;
            case 6: grd='양'; break;
            default: grd='가'; break;
        }
        result += '\n' + tots + '/' + avg + '/'+grd

        alert(result);
    }

    // 리턴문이 없이 사용할 수 있음
    function checkSungJuk(name, kor, eng, mat) {
        let isFinish = false;

        if (name.value == '') {
            alert('이름을 입력하세요~')
            name.focus();
        }else if (kor.value==''){
            alert('국어점수 똑디 입력하세요~')
            kor.focus();
        }else if (eng.value==''){
            alert('영어점수 똑디 입력하세요~')
            eng.focus();
        }else if (mat.value==''){
            alert('수학점수 똑디 입력하세요~')
            mat.focus();
        }else if ( parseInt(kor.value) <0 || parseInt(kor.value) >100) {
            alert('점수는 0~100 사이 입니다 !')
        }else {     // 성적데이터가 제대로 입력되었다면
            isFinish =true;
        }
        return isFinish;
    }
    </script>
 </body>
 
 </html>

 

 

실습 예제) 로그인 프로그램

아이디, 비밀번호를 설정해두고

폼을 통해 입력받은 아이디, 비밀번호를 비교해서

일치하면 '로그인 성공!'이라는

일치하지 않으면 '로그인 실패!'라는 메시지를 출력

폼 이름은 loginfrm으로 설정

아이디/비밀번호 : userid, passwd

미리 설정해둔 아이디/비밀번호 : myuid=abc123, mypwd=987 xyz

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h3>로그인 처리프로그램</h3>
<form name="loginfrm">
    <div>아이디 :<input type="text" name="userid"></div>
    <div>비밀번호 :<input type="password" name="passwd"></div>
    <div><button type="button" id="login">로그인</button></div>

</body>
</html>
  let logbtn = document.getElementById('login')
        logbtn.addEventListener('click',login)
    id= document.loginfrm.userid;
    pwd = document.loginfrm.passwd;

    function login () {
        if ( !logincheck(id, pwd) ) return;

        if (id .value=='abc123' && pwd.value == '987xyz'){
            alert("로그인에 성공하셨습니다!")
        }else {
            alert("로그인실패!")
        }
    }

    function logincheck (id, pwd) {
        let ok = false;
        if (id.value == '') {
            alert('아이디 입력안했네요~??');
            id.focus();
        }else if (pwd.value == '') {
            alert('비밀번호 입력안했네요~??');
            pwd.focus();
        }else{
            ok=true;
        }
        return ok;
    }

반응형
반응형

2021-01-05 수업 내용 정리 겸 복습

 

정규표현식:

문자열을 다룰때 좀더 섬세하게 처리하고 싶다면

정규표현식을 사용하는 것이 좋음

 

^ : 문자열의 시작 (^a)

$ : 문자열의 끝 (z$)

 

. : 임의의 한문자를 의미

+ : 한번이상 반복

? : 0또는 1반복

* : 0이상 반복

{m,n} : 최소 m번 n번반복

 

| : or를 의미 (x | y)

[] : 선택가능한 문자들의 모음 ( [abc] )

[^] : 측정문자 제외 ( [^xyz] )

[-] : 문자열 범위를 의미 ( [0-9] )

 

ex)

 

    str = '간장 공장 공장장은 강 공장장이고' +
            '된장 공장 공장장은 장 공장장이다. '

    let reg1 = /공장/;
    let reg2 = /공장/g;         // 정규표현식 지시자 flag
                                            // 검색범위를 전체로 설정
    let reg3 = /춘장/;

    // 문자열에서 공장을 찾아보자 보자보자 어데보자 넌 담에보자 ~
    // 조건에 맞는 문자열을 찾으면 index가 출력
    // 찾지못하면 -1 출력
    document.write('<hr>')
    document.write('<p>' +str.search(reg1)  + '</p>')
    document.write('<p>' +str.search(reg2)  + '</p>')
    document.write('<p>' +str.search(reg3)  + '</p>')

  // match : 조건에 맞는 문자열을 찾으면 문자열 출력
    //              찾지못하면  null 출력
    document.write('<hr>')
    document.write('<p>' +str.match(reg1)  + '</p>')
    document.write('<p>' +str.match(reg2)  + '</p>')
    document.write('<p>' +str.match(reg3)  + '</p>')

  // test : 조건에 맞는 문자열을 찾으면 true를 출력
    //          찾지 못하면 false를 출력
    document.write('<hr>')

    document.write('<p>' +reg1.test(str)  + '</p>')
    document.write('<p>' +reg2.test(str)  + '</p>')
    document.write('<p>' +reg3.test(str) + '</p>')

//특정파일명이 index로 시작하는지 

//확장자가 html로 끝나는지 검사하는 정규표현식 작성

    // 특정파일명이 index로 시작하는지
    // 확장자가 html로 끝나는지 검사하는 정규표현식 작성
    document.write('<H1>특정파일명 index로시작/html끝나는지 검사</H1>')
    let fname = 'index.html';
    reg1 = /^index/       // index로 시작
    reg2 = /html$/      // html로 끝

    document.write('<p>' +reg1.test(fname)  + '</p>')
    document.write('<p>' +reg2.test(fname)  + '</p>')

    document.write('<hr>')

//전화번호를 확인하는 정규표현식

    // 전화번호를 확인하는 정규표현식
    // 02-1234-1234, 032-1234-1234
    // 010-1234-1234,
    document.write('<H1>전화번호를 확인하는 정규표현식</H1>')
    reg1 =/[0-9]{2,3}-[0-9]{3,4}-[0-9]{4}/
    reg2 = /[0-9]{3}-[0-9]{4}-[0-9]{4}/
    let data1 = '02-123-4567';
    let data2 = '032-1234-9876';
    let data3 = '010-2077-5061';

    document.write('<p>' +reg1.test(data1)  + '</p>');
    document.write('<p>' +reg1.test(data2)  + '</p>');
    document.write('<p>' +reg2.test(data3)  + '</p>');
    document.write('<hr>')

 

주민번호/ 아이디/ 비밀번호 

반응형
반응형

2020-01-05 수업내용 정리 겸 복습

 

내장객체 : 

브라우져에 미리 정의되어 사용자가 바로 사용할 수 있도록 

만들어진 객체를 의미

간단한 값을 처리해서 결과를 반환하는 함수

Number/ Math/ Date/ String/ Array/ JSON 등이 있음

 

// Math 객체 : 수학에서 자주사용하는 함수 정의 

 document.write('<h2>Math 객체</h2>')
    document.write('<p>' + Math.min(1, 10, -10, 0)  + '</p>')        // 최소값 출력
    document.write('<p>' + Math.max(1, 10, -10, 0)  + '</p>')        // 최대값 출력

    document.write('<p>' + Math.round(123.456)  + '</p>')           //반올림
    document.write('<p>' + Math.ceil(123.456)  + '</p>')               // 무적권올림
    document.write('<p>' + Math.floor(123.456)  + '</p>')            // 무적권내림
    document.write('<p>' + Math.ceil  + '</p>')
    document.write('<p>' +  + '</p>')

    document.write('<p>' + Math.random()  + '</p>')                     // 난수발생

    // 1~45 사이 난수 6개 생성
    let min =0, max =7;

    for (let i =1; i<=6; ++i) {
        let lucky = parseInt(Math.random() * (max - min) + min)+1
        document.write('<p>' + lucky + '</p>')
    }

 

// String 객체 : 문자열 관련 작업을 위한 객체

    // 숫자에 해당한 아스키코드 문자값을 출력
    document.write('<p>' + String.fromCharCode(65) + '</p>')
    document.write('<p>' + String.fromCharCode(97) + '</p>')
    document.write('<p>' + String.fromCharCode(48) + '</p>')

    // 특정문자의 코드값 출력
    document.write('<p>' +'A'.charCodeAt()  + '</p>')
    document.write('<p>' +'a'.charCodeAt()  + '</p>')
    document.write('<p>' +'0'.charCodeAt()  + '</p>')
    document.write('<p>' +'Aa0'.charCodeAt(0)  + '</p>')
    document.write('<p>' +'Aa0'.charCodeAt(1)  + '</p>')
    document.write('<p>' +'Aa0'.charCodeAt(2)  + '</p>')

    let str ='abc123XYZabc'
    // abc가 나온 위치를 찾아봄, 왼쪽기준 0부부터 시작.
    document.write('<p>' +str.indexOf('abc')  + '</p>')

    // 지정한 문자열을 찾지 못하는 경우 -1 출력
    document.write('<p>' +str.indexOf('abcd')  + '</p>')

    // 123이 나오는 위치 찾아봄
    document.write('<p>' +str.indexOf('123')  + '</p>')

    // 위치값 5+1번째 위치 이후로  abc의 위치를 찾아줌
    document.write('<p>' +str.indexOf('abc', 5)  + '</p>')

    // 맨끝을 기준으로 특정문자열의 위치를 알아본다.
    document.write('<p>' +str.lastIndexOf('abc', 5)  + '</p>')

 // 특정위치의 문자 추출
    let jumin ='123456-1234567'
    document.write('<p>' +jumin.charAt(7) + '</p>')

    // 지정한 위치 사이의 문자열 추출 slice(n, m-1)
    document.write('<p>' +jumin.slice(0, 6) + '</p>')
    document.write('<p>' +jumin.slice(7, 14) + '</p>')

    // 오른쪽을 기준으로 지정한 위치의 문자열 추출
    document.write('<p>' +jumin.slice(-7, -1) + '</p>')
    // 오른쪽을 기준으로 지저한 위치 이후의 문자열 추출
    document.write('<p>' +jumin.slice(-7,) + '</p>')


    // 지정한 위치의 문자열 추출 (start, end-1)
    document.write('<p>' +jumin.substring(7,8) + '</p>')
    // end가 지정되지 않으면 나머지 문자열 추출.
    document.write('<p>' +jumin.substring(7) + '</p>')

    // 지정한 위치에서부터 지정한 갯수만큼 문자열 추출
    document.write('<p>' +jumin.substr(7,1) + '</p>')

 // | 문자를 기준으로 각 문자열을 분리
    str = 'abc|123|xyz';
    document.write('<p>' + str.split('|') + '</p>')
    // 구분기호 없이 split을 호출하면 문자를 기준으로 본리
    document.write('<p>' + str.split('') + '</p>')

반응형
반응형

2020-01-05 수업내용 정리 겸 복습

 

 

함수의 리턴값 :

함수의 맨마지막에 return문을 사용하면 함수를 호출한 주체에게 

결과를 넘길 수 있음

단, 함수의 몸체 중간에 return문을 사용하면

함수의 나머지 부분을 수행하지 않고 중단하는 역할을 하기도 함.

 

// 2개의 숫자를 입력받아 덧셈을 수행하고 결과를 출력하는 함수 add를 작성하세요 

    function add(x,y) {
        let sum =x+y;
        document.write('<p>'+x+'+'+y+'='+sum+'</p>');
    }
    add(5,10)

// 단일책임의 원칙:

함수를 하나의 기능만을 담당하게 하는것이 좋다고한다.

더하기기능을 하는 함수를 만들고자 한다면 더하는 기능만을 담당하게

   function add2(x,y) {
        let sum =x+y;
        return sum
    }
    result= add2(10,5)
    document.write('<p>10더하기 5는 '+add2(10,5)+'</p>')
    document.write('<p>10+5='+result+'</p>')

 

 

익명함수 anonymous function :

함수를 정의할때 이름을 지정하지 않은 함수를 의미

함수를 실행하려면 반드시 함수명을 호출해야 하는데

익명함수는 함수정의와 동시에 함수를 실행할 수도 있음

 

// 간단한 인삿말을 출력하는 함수

  function sayHello(msg) {
        document.write('<p>' + msg + '</p>');
    }
    sayHello('HelloWorld !!')

익명함수를 만드려면 변수에 담아줘야한다. 

함수호출은 변수명으로 하면 된다.

    let say = function (msg) {
        document.write('<p>' + msg + '</p>');
    }
    // 익명함수 정의후 변수에 저장 : C언어의 함수포인터와 유사.
    say('Hello, JavaScript !');

 

특정함수를 주기적으로 실행하기

주기적으로 특정함수를 실행하려면 setInterval과

setTimeout 함수를 사용하면 된다. 

 

setInterval :

일정시간간격으로 함수를 반복실행

clearInterval 함수로 중지시킬 수 있음.

setInterval( 함수명, 주기(ms) )

 

setTimeout : 

일정시간이 지난후 함수를 한번만 실행

clearTimeout 함수로 중지시킬수 있음

setTimeout(함수명, 시간(ms));

<!DOCTYPE html>
<html lang="ko">

<body>
<span id="time"></span>

<script>
   function today() {
        let today = new Date();
        let hh = today.getHours();
        let mm = today.getMinutes();
        let ss = today.getSeconds();
        let time= hh+ ':' + mm + ':' + ss;
        document.getElementById('time').innerHTML = time;
    }
    today();                             // 한번만 시간을 출력하고 끝
    setInterval(today, 1000); // 1초마다 today함수 실행
</script>



</body>
</html>

초가 계속 증가하는걸 확인할 수 있다. 

 

반응형
반응형

2021-01-05 수업내용 정리 겸 복습

 

함수 : 

하나의 특별한 목적을 수행하기 위해 설계되고 작성한 코드들의 묶음

특정 작업이 필요할 때마다 호출하여 반복적으로 수행 가능

자바스크립트에서는 함수를 일종의 자료형으로 인식 (중요!)

함수 정의시 FUNCTION이라는 예약어를 사용

함수에 전달할 매개변수는 함수명 뒤 괄호에 쉼표로 구분해서 지정

함수의 몸체를 구성하는 코드블럭은 중괄호로 정의함.

function 이름 (매개변수,매개변수) {
	함수몸체
}

 

 

단을 입력받아 구구단을 출력하는 프로그램 

 

// 구구단 출력 (7단)

  for(let i =1; i<=9;i++)
    document.write('7 x' + i + '=' + (7*i)+'<br>')

// 구구단 함수 정의

  function guguDan (d){
        for(let i =1; i<=9;i++)
            document.write(d+' x' + i + '=' + (d*i)+'<br>')
    }
  // 함수 호출 : 함수명(인자값)
  guguDan(2);

 

// 사용자로부터 값 입력받기 : 변수명 = prompt(안내문구)

let dan = prompt('단을 입력하세요 (1~9)')
    guguDan(dan)

 

반응형
반응형

2021-01-06 수업내용 정리 겸 복습

 

배열 :

여러 개의 동일한 종류의 값들로 구성된 집합

각 값들은 위치 값 index으로 참조 가능

 

배열을 생성하는 3가지의 타입

/ 변수명 = [값, 값, 값]

/ 변수명 = Array(값, 값, 값)

/ 변수명 = new Array(값, 값, 값)

 

성적 처리

<script>
    let name =['이선우','지현','혜렌'];
    let kors = Array(99,98,100);
    let engs = new Array(100,100,100);
    let mats = [100, 100, 100];

    let tots= [0, 0, 0]
    let avg=[0.0, 0.0, 0.0]
    let grd =['가', '가', '가']
</script>
    <script>
    for (let i =0; i<=2; ++i){
        name[i];
        tots[i]=kors[i] + engs[i] + mats[i];
        avg[i]= tots[i]/3;

        let x = parseInt(avg[i].toFixed(0)/10);
        switch (x){
            case 10: case 9 : grd[i]='수'; break;
            case 8: grd[i]='우'; break;
            case 7: grd[i]='미'; break;
            case 6: grd[i]='양'; break;
            default: grd[i]='가'; break;
        }
        document.write('<p>'+name[i]+'/'+kors[i]+'/'+engs[i]+'/'+mats[i]+'/'+tots[i]+'/'+avg[i].toFixed(1)+'/'+grd[i]+'</p>')
    }
    </script>

반응형
반응형

2021-01-06 수업내용 정리 겸 복습

 

반복문 : 특정 명령(들)을 지정한 횟수만큼 반복 수행하는 실행문

/ while (조건) { 반복할 구문; 증감식 ;}

/ for ( 초기값; 조건식; 증감식) { 반복할 구문 }

 

 

ex ) 1~10까지의 정수 출력

    <script>
    let i = 1;

    while (i <= 10) {
        document.write(i+'<br>');
        ++i;
    }
    for (i=1;i<=10;i++){
        document.write(i+'<br>')
    }
  </script>

 

ex ) 1~100 사이의 짝수

<script>
    i=1;
    while (i <=100) {
        if (i%2==0){
            document.write(i+'<br>')
        }
        i++;
    }
    for(i=1;i<=100; i++) {
        if (i%2==0){
            document.write(i+'<br>')
        }
    }
 </script>

 

 

객체를 반복문으로 다루기

객체의 속성을 출력하려면 객체명. 속성명, 객체명['속성명']

<script>
    let person = {name:'으악으악',kor:99, eng:98, mat:99};
    document.write(person['name']+'국어:'+person.kor+'영어:'+person.eng+'수학:'+person['mat']+'<br>')
</script>

객체의 모든 속성들을 반복문으로 출력하기

for in 구문은 객체 속성을 추출함 

<script>
    for(let prop in person) {
        document.write(prop+':'+person[prop]+'<br>');
    }
</script>

여러 개의 객체를 반복문으로 다루기

<script>
	 let persons = [{name:'혜교',age:35}, {name:'지현',age:36}, {name:'아이린', age:31}]
     // 3개의 객체를 배열에 저장함.
     
     // 배열을 for in 구문으로 실행하면 배열의 위치값 index가 출력
     // 여기서의 p는 배열의 객체 index를 가르킴
        
        for (let person of persons){
        document.write('<p>'+ person + '</p>')
        for (let p in person) {
            document.write('<p>'+ person[p] + '</p>')
        }
    }
     

</script>

For in 구문보다 좀 더 효과적으로 

객체를 순환하려면 for of 구문을 사용하는 것이 좋음

참고로 자바에서는 iterator 클래스와 hasNext, next메서드와 유사

<script>
   for (let person of persons){
        document.write('<p>'+ person + '</p>')
        for (let p in person) {
            document.write('<p>'+ person[p] + '</p>')
        }
    }
</script>

반응형

'JAVA &amp; APP :국비지원 학원 복습 > ' 카테고리의 다른 글

JavaScript : 06 함수 (1/2) -구구단  (0) 2021.01.06
JavaScirpt : 05 배열  (0) 2021.01.06
JavaScript 03 : 조건문  (0) 2021.01.05
JavaScript : 02 타입과 연산자.  (0) 2021.01.04
JavaScript : 01 Basic  (0) 2021.01.04
반응형

2021-01-05 수업내용 정리 겸 복습

 

조건문 : 

주어진 식의 결과에 따라 별도의 명령을 수행 (분기문)

조건이 많아지면 구문 자체의 가독성이 떨어짐

 

 

 

// 성적처리 

// 1. 변수 선언

<script>
  let name='혜교';
    let kor=98;
    let eng=99;
    let mat=98;
    let tot =0;
    let avg=0;
    let grd='가';

</script>

// 2. 성적 처리

<script>
  tot = kor + eng + mat;
    avg = tot /3
</script>

// if () {}

<scirpt>
    if (avg>90 ){
        grd='수'
    }else if (avg >=80) {
        grd='우'
    }else if (avg >=70) {
        grd='미'
    }else if (avg >=60) {
        grd='양'
    }else  {
        grd='가'
    }

</script>

// 3. 결과 출력

<script>
    document.write('<p>이름 :'+name+'</p>')
    document.write('<p>국어 :'+kor+'</p>')
    document.write('<p>영어 :'+eng+'</p>')
    document.write('<p>수학 :'+mat+'</p>')
    document.write('<p>총점 :'+tot+'</p>')
    document.write('<p>평균 :'+avg.toFixed(1)+'</p>')  // 소수점 자릿수 기준 잘라서 출력한다.
/*    document.write('<p>평균 :'+Math.round(avg)+'</p>') 이거는 반올림*/
    document.write('<p>학점 :'+grd+'</p>')
 </script>

 

// 다중 조건문 : switch 

조건이 많은 경우 if문보다 switch문을 추천한다. 

<script>
let x =(avg/10).toFixed(0) // 결과값은 문자열로 넘어온다.
    switch (parseInt(x)) {    // 그래서 parseInt로 타입 바꿔준다.
        case 10: case 9: grd='수'; break;
        case 8: grd='우';break;
        case 7: grd='미';break;
        case 6: grd='양';break;
        default : grd='가';break;
    }
    document.write('<p>'+x+'</p>')
    document.write('<p>'+grd+'</p>')
    
  
</script>

 

// 오늘 날짜의 요일을 한글로 출력해보세요 

오늘의 요일 : new Date(). getDay() 이용 

0: 일요일, 1: 월요일,....

<script>
    let d =new Date().getDay();
    let today;
    switch (d) {
        case 0 : today='일요일';break;
        case 1 : today='월요일';break;
        case 2 : today='화요일';break;
        case 3 : today='수요일';break;
        case 4 : today='목요일';break;
        case 5 : today='금요일';break;
        case 6 : today='토요일';break;
    }
     document.write('<p>'+today+'</p>')
 </script>

<script>
   let new2021 = new Date();
    let num
    if (new2021.getMonth() <=9) num=0
    else num=' ';

    document.write('<p>'+new2021.getFullYear()+'년')
    document.write(num+(new2021.getMonth()+1)+'월')
    document.write(num+new2021.getDate()+'일')
    document.write(' '+today+'</p>')

    document.write('<p>'+new2021.getHours()+'시')
    document.write(' '+new2021.getMinutes()+'분')
    document.write(' '+new2021.getSeconds()+'초')

</script>

반응형

'JAVA &amp; APP :국비지원 학원 복습 > ' 카테고리의 다른 글

JavaScript : 06 함수 (1/2) -구구단  (0) 2021.01.06
JavaScirpt : 05 배열  (0) 2021.01.06
JavaScript : 04 반복문  (0) 2021.01.06
JavaScript : 02 타입과 연산자.  (0) 2021.01.04
JavaScript : 01 Basic  (0) 2021.01.04
반응형

2021-01-04 수업내용 정리 겸 복습

 

 

 

자바스크립트 연산자

산술 연산자 : + - * / %

대입 연산자 : = += -= *= /= %=

증감 연산자 : ++x , y++

비교 연산자 :

==!= (값의 동일성 체크)

> >= <= , ===!== 값과 타입의 동질성 여부

논리 연산자 : && ||! (short-circuit 연산 지원)

기타 연산자 : + (문자열 결합)? : typeof (변수 타입 출력)

 

자바스크립트 타입

크게 3가지 타입 지원 : 숫자, 문자형, 논리형

 

//숫자형

    <script>
    let num1 =123;
    let num2 =456.789;
    let num3 = 10e3; // 10x 10x 10

    document.write('<p>'+num1+'</p>')
    document.write('<p>'+num2+'</p>')
    document.write('<p>'+num3+'</p>')
    </script>

//문자형

<script>
   let str1 = 'Hello, World!!' // 추천
    let str2 = "Hello, World!!"

    document.write('<p>'+str1+'</p>')
    document.write('<p>'+str2+'</p>')
</script>

 

//논리형

<script>
   let bool1 = 10>5;
    let bool2 = (10<5) ;
    document.write('<p>'+bool1+'</p>')
    document.write('<p>'+bool2+'</p>')
  </script>

// 객체형 : json

단일 변수에 여러 타입의 값을 저장한 것

객체를 구성하는 변수들은 property라 하고

함수들은 method라 함

객체의 속성이나 함수에 접근하려면 객체명. 속성명, 객체명. 함수명을 사용

<script>
  let person = { name: '혜교', kor: 98, eng:98, mat:99};

    document.write('<p>'+person.name+'</p>');
    document.write('<p>'+person.kor+'/'+person.eng+'/'+person.mat+'</p>');
 </script>   
 
 

// null과 undefined

변수 선언 시 초기화하지 않으면 null형으로 정의

초기화되지 않은 변수를 호출/사용하면 undefined로 출력

<script>
    let data;
    document.write('<p>'+data+'</p>');
</script>

 

// 자료형 변환

자바스크립트는 변수의 자료형 검사가 유연한 편임(weakly typed)

즉, 이미 선언한 변수에 다른 종류의 값을 대입할 수 있음 

    <script>
    let one =123;
    document.write('<p>'+one+'</p>'); // 123

    one= 'Hello';
    document.write('<p>'+one+'</p>');// Hello
    </script>

// 묵시적 형 변환

<script>
    let two = 10+ 'Hello';
    document.write('<p>'+two+'</p>');//10Hello

    let three='3' * '5';
    document.write('<p>'+three+'</p>'); // 15

    let four ='World' - 999;
    document.write('<p>'+four+'</p>'); // NaN
  </script>

+

자동형 변환이 실패해서 적절한 값을 출력하지 못하는 경우 

산술 연산자인 + 제외한 나머지 산술 연산자는 출력해내지 못한다. 

NaN : Not a Number로 출력이 된다. 

// 명시적 형 변환 : Number, String, parseInt, parseFloat

<stript>	
    document.write('<p>'+Number('123')+'</p>');
    document.write('<p>'+String(123)+'</p>');
    document.write('<p>'+parseInt('123')+'</p>');
    document.write('<p>'+parseFloat('123.456')+'</p>');
 </stript>

 

            // Number VS parseInt ( 추천 )

<script>
	document.write('<p>'+parseInt('001')+'</p>');
    document.write('<p>'+Number('001')+'</p>');

    document.write('<p>'+parseInt('2021년')+'</p>');
    document.write('<p>'+Number('2021년')+'</p>');

    document.write('<p>'+parseInt('총35000원')+'</p>');
    document.write('<p>'+Number('총35000원')+'</p>');
</sciript>

parseInt를 이용하면 두 번째 2021년 파트에서 문자인 '년'이 섞여도 2021을 출력해내는 걸 확인할 수 있다.

하지만 parseint를 사용하더라도 앞뒤로 문자가 있는 경우에는 숫자만 추출 못해내는 것도 확인할 수 있다. 

 

 

연산자

 

// 동등, 동일 비교 연산자

<script>
   let a=3, b= 3, c = '3';
    document.write('<p>'+(a == b)+'</p>');
    document.write('<p>'+(a === b)+'</p>');
    document.write('<p>'+(a == c)+'</p>'); // 자동 형변환을 통해 값 비교
    document.write('<p>'+(a === c)+'</p>');
 </script>

// 증감 연산자

<script>
	let x =10, y=10;
    document.write('<p>'+(++x + 3)+'</p>');
    document.write('<p>'+(y++ + 3)+'</p>');
    document.write('<p>'+x+'</p>');
    document.write('<p>'+y+'</p>');
    // x= 11 y= 11
    y= x-- +5 + --y;
    document.write('<p>'+y+'</p>');
 </script>

전위 증가냐 후위 증가냐에 따라 값이 달라지는 걸 확인할 수 있다. 

// 변수 유형 알아보기

<script>
	let num1 =123;
    let str1 = 'Hello, World!!'
    let bool1 = 10>5;
    let person = { name: '혜교', kor: 98, eng:98, mat:99};
    
    
    
    
    document.write('<p>'+typeof(num1)+'</p>')
    document.write('<p>'+typeof(str1)+'</p>')
    document.write('<p>'+typeof(bool1)+'</p>')
    document.write('<p>'+typeof(person)+'</p>')
</script>

반응형

'JAVA &amp; APP :국비지원 학원 복습 > ' 카테고리의 다른 글

JavaScript : 06 함수 (1/2) -구구단  (0) 2021.01.06
JavaScirpt : 05 배열  (0) 2021.01.06
JavaScript : 04 반복문  (0) 2021.01.06
JavaScript 03 : 조건문  (0) 2021.01.05
JavaScript : 01 Basic  (0) 2021.01.04
반응형

2020-12-27

 

#4. 3 Adding Genres 

이제 이어서 장르를 웹에 출력해내기 위해 코드를 작성한다.

import React from "react";
import PropTypes from "prop-types";
import "./movie.css"

function Movie({ year, title, summary, poster, genres}){
    return (
    <div className="movies__movie">
                    <img src={poster} alt={title} title={title}/>
        <div className="movie__data">
            <h3 className="movie__title">{title}</h3>
        <h5 className="moive__year">{year}</h5>
        //요기    <ul className="genres">{genres.map((genre,index) => <li className="genres__genre">{genre}{index}</li>)}</ul>
        <p className="movie__summary">{summary}</p>

    </div>
    </div>
    );
}
Movie.propTypes = {
    id: PropTypes.number.isRequired,
    year: PropTypes.number.isRequired,
    title: PropTypes.string.isRequired,
    summary: PropTypes.string.isRequired,
    poster: PropTypes.string.isRequired,
    genres: PropTypes.arrayOf(PropTypes.string).isRequired //요기

};

export default Movie;

이렇게 작성하면 콘솔 오류가 발생할 것인데 전에 이야기했듯이 map에는 각각의 item들은 key가 필요하다.

그런데 장르에는 제공할 key가 없다 왜냐하면 장르에는 id라던지 그런 번호가 매겨져있지 않기 때문에 그래도 괜찮다.

map function은  argument를 전달해주는데 첫 번째는 item 우리가 아는 장르의 종류들이 나오고 두 번째는 

item number이다. 그래서 index, or current item number 사용자맘대로 번호를 정할 수 있다.

genres.map(genre,??) => 이 부분에?? 를 사용자 정의해서 아무렇게나 붙여도 된다. 붙이고 {??}를 출력문에 추가하면 장르에 번호가 나오는 걸 확인 가능하다. 확인 후에는 <li> 안에 key값을 넣어주자

 

#4. 4 Styles Timeleapse

이 챕터는 스타일 같은걸 적용하는 걸 보고 따라 하는 거 같다 다른 부가설명은 없었다.

css를 아직 안 배워서 그냥 묻지 마 코딩식으로 따라 하기만 했다. 

* {
    box-sizing: border-box;
}

body {
    margin: 0;
    padding: 0;
    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen,
    Ubuntu, Cantarell, "Open Sans", "Helvetica Neue", sans-serif;
    background-color: #eff3f7;
    height: 100%;
}

html,
body,
#root,
.container {
    height: 100%;
    display: flex;
    justify-content: center;
}

.loader {
    width: 100%;
    height: 100%;
    display: flex;
    justify-content: center;
    align-items: center;
}

.movies {
    display: flex;
    justify-content: space-between;
    align-items: flex-start;
    flex-wrap: wrap;
    padding: 50px;
    padding-top: 70px;
    width: 80%;
}

.movies .movie {
    width: 45%;
    background-color: white;
    margin-bottom: 70px;
    display: flex;
    align-items: flex-start;
    justify-content: space-between;
    font-weight: 300;
    padding: 20px;
    border-radius: 5px;
    color: #adaeb9;
    box-shadow: 0 13px 27px -5px rgba(50, 50, 93, 0.25),
    0 8px 16px -8px rgba(0, 0, 0, 0.3), 0 -6px 16px -6px rgba(0, 0, 0, 0.025);
}

.movie img {
    position: relative;
    top: -50px;
    max-width: 120px;
    margin-right: 30px;
    box-shadow: 0 30px 60px -12px rgba(50, 50, 93, 0.25),
    0 18px 36px -18px rgba(0, 0, 0, 0.3), 0 -12px 36px -8px rgba(0, 0, 0, 0.025);
}

.movie .movie__title,
.movie .movie__year {
    margin: 0;
    font-weight: 300;
}

.movie .movie__title {
    margin-bottom: 5px;
    font-size: 24px;
    color: #2c2c2c;
}

.movie .movie__genres {
    list-style: none;
    padding: 0;
    margin: 0;
    display: flex;
    margin: 5px 0px;
}

.movie__genres li,
.movie .movie__year {
    margin-right: 10px;
    font-size: 14px;
}

#4. 5 Cutting the summary

 

전에 봤었던 예제 페이지를 보면 text의 길이가 일정한 것을 볼 수 있다. 일정해야지 텍스트 박스의 크기가 영화마다 동일할 텐데 지금은 그렇지 못하다.  그럴 때는 javascript로 text를 잘라서 출력하도록 한다. 

summary.slice(0,150)을 지정하면 줄거리 전체 택스트 중 150자까지만 출력이 될 것이다. 그러면 자동으로 모든 영화의 줄거리는 150자까지만 출력되니깐 각 영화 박스들은 동일한 크기를 가지게 된다.

movie.js의 summary 출력 부분에 summary.slice(0,150)을 넣어 확인해보자

import React from "react";
import PropTypes from "prop-types";
import "./movie.css"

function Movie({ year, title, summary, poster, genres}){
    return (
    <div className="movie">
                    <img src={poster} alt={title} title={title}/>
        <div className="movie__data">
            <h3 className="movie__title">{title}</h3>
        <h5 className="moive__year">{year}</h5>
            <ul className="movie__genres">{genres.map((genre,index) => <li key={index} className="genres__genre">{genre}</li>)}</ul>
        <p className="movie__summary">{summary.slice(0,180)}...</p> //요기

    </div>
    </div>
    );
}
Movie.propTypes = {
    id: PropTypes.number.isRequired,
    year: PropTypes.number.isRequired,
    title: PropTypes.string.isRequired,
    summary: PropTypes.string.isRequired,
    poster: PropTypes.string.isRequired,
    genres: PropTypes.arrayOf(PropTypes.string).isRequired

};

export default Movie;
반응형
반응형

2020-12-27 일요일

수업 영상을 보고 영상이 진행되는 순서에 맞춰 바로바로 작성하다 보니 장황하고 말 이상하게 쓸 수도 그리고 뇌피셜로 적는 내용이 있을 수 있고 빠짐없이 적고자 하지만 놓친 부분이 있으니 수업내용이 궁금하면 직접 보는 걸 추천드립니다.

결정적으로 웹 HTML만 조금 배운상태에서 진행한거여서 완벽하지 않습니다

아마 이글을 보는 사람이 없을 거 같기는 한데 노파심에

 

 

#3. STATE

 

#3. 0 Class Components and State

 

1. 기존 존재하는 component들을 지우고 app component를 function component에서 class component로 변경한다.

2. 이후 app component도 지우고 결과적으로 class app component를 만드는데 React.Component를 상속받는다.

 

ex)

핸드폰 게임을 개발한다면 samsung을 iphone을 프로그래밍하지 않고 cell phone을 프로그래밍한다.

cell phoene 은 여러 가지 특성이 있다. 예를 들면 screen, charger 등등 

iphone과 samsung은 이러한 것을 공유한다.

그래서 camera, screnn, charger를 cell phone class에 넣은 다음에서 확장한 samsung class를 가지게 된다.

 

위에서의 React.Component를 상속받고 만든 class app component는 기본적으로 react class component에서 가져오고 있다. 그리거 거기서 확장하고 있다. 결과적으로 App component는 react component이다. 

    

 

3. function component와 class component의 차이 

- function component는 return을 통해 반환한다. 하지만 class component는 반환을 하지 않는다. function이 아니기에

- 그리고 class react component에는 render method를 가지고 있다. 

 

 

현재 react component를 상속한 class App component도 동일하게 react component를 가지고 있다.

 

render 메서드 안에서 리턴 html 문을 작성하면 출력이 되는 것을 확인할 수 있다.

import React from "react";
import PropTypes from"prop-types";



class App extends React.Component {
    render() {
        return <h1>im a class component</h1>;
    }
}

export default App;

결과적으로 

Function component는 function이고 뭔가를 return 한다 그리고 screen에 표시가 되고 

class component는 class이다 하지만 react component로부터 확장되거 screen에 표시가 된다. 

그리고 화면에 표시하기 위해선 render 메서드 안에 넣어야 하고 react는 자동적으로 모든 class component의 render method를 실행하고자 한다. 

 

react는 자동적으로 나의 class component의 render method를 실행한다 자동으로

그 자바 보면 컴파일하려면 main 메서드부터 읽어오는 그러는 느낌인가 

 

 

 

4. state는 object이고 component의 data를 넣을 공간이 있고 이 data는 변한다.

그리고 state를 render 안에 넣으려면 class 이기에 this.로 표현해주어야 한다. 

 

import React from "react";
import PropTypes from"prop-types";



class App extends React.Component {
    state = {
        count: 0
    };
    render() {
        return <h1>im a class component {this.state.count}</h1>;
    }
}

export default App;

 

 

결과적으로 우리는 state에 바꾸고 싶은 data를 넣는 것

 

일단 소스코드부터 보고 작성하겠다.

import React from "react";
import PropTypes from"prop-types";



class App extends React.Component {
    state = {
        count: 0
    };
    add = () => {
        console.log("add");
    };
    minus = ()=>{
        console.log("minus");
    };

    render() {
       return(
           <div>
               <h1>this number is:{this.state.count}</h1>
               <button onClick={this.add}>Add</button>
               <button onClick={this.minus}>Minus</button>
           </div>
       )
    }
}

export default App;

 

일단 보면 add =() =>{} 안에 적혀 이 쓴 게 두 개가 보인다. 이는 javascript 언어라고 한다. 

뭘 의미하는지는 정확히 모르겠지만 console.log("add"); 를 나타내게 해주는 역할을 하는 것 같다. 

 

그리고 아래 render 쪽을 보면 두 개의 버튼이 만들어진 것을 확인할 수 있는데 이는 react에서만 작용한다고 한다. 아무튼 

이렇게 버튼 두 개에 onClick을 적어 버튼을 눌렀을 때  this.로 위에 만들어진 add와 minus를 실행하게 하는 것 같은데 

여기서 주의할게 thsi.add()로 작성하게 된다면 버튼을 누르기도 전에 생성이 된다고 한다. 클릭될 때 동작하게 하려면 ()를 빼주어야 한다고 한다. 

아무튼 이렇게 작성 후  버튼을 여러 번 누르고 콘 살창을 확인해보면 숫자가 올라가 있는 것을 확인할 수 있다.

 

 

#3. 1 All you need to know about State

 

State값을 변경하면 웹에 바뀌지 않는 것을 확인할 수 있다. 이는 왜 그러냐면 state값을 변경하면 다시 render를 실행시켜주어야 하는데 실행이 안되어서 업데이트가 되지 않는다. 그래서 우리는 setState를 사용해야 한다. setState를 사용해 값을 변경하면 react는 바로 state를 refresh 하고 바로 render를 불러온다고 한다. 

import React from "react";
import PropTypes from"prop-types";



class App extends React.Component {
    state = {
        count: 0
    };
    add = () => {
        this.state=2;
    };
    minus = ()=>{
        this.setState({count:-1});
    };

    render() {
       return(
           <div>
               <h1>this number is:{this.state.count}</h1>
               <button onClick={this.add}>Add</button>
               <button onClick={this.minus}>Minus</button>
           </div>
       )
    }
}

export default App;

 

 

위와 같이 add에서는 this.state=로 설정하고 minus는 setState를 이용해서 설정하고 버튼을 눌렀을 때 

add버튼 같은 경우 아무 반응이 없고 minus버튼을 누르면 count가 -1로 변경돼서 바로 바뀌는 것을 볼 수 있다. 

이는 html 코드로 본다면 react에서 필요한 부분을 빠르게 추가해서 표시해주는 걸 확인할 수 있는데 이때의 속도는 엄청나게 빠르다고 한다. 

 

setState를 사용하지 않으면 새 state와 함께 render function이 호출되지 않을 것이다. 

import React from "react";
import PropTypes from"prop-types";



class App extends React.Component {
    state = {
        count: 0
    };
    add = () => {
        this.setState(current=> {count: this.state.count +1});
    };
    minus = ()=>{
        this.setState({count: this.state.count -1});
    };

    render() {
       return(
           <div>
               <h1>this number is:{this.state.count}</h1>
               <button onClick={this.add}>Add</button>
               <button onClick={this.minus}>Minus</button>
           </div>
       )
    }
}

export default App;

 

add 버튼을 누를 때마다 +1 이되도록 minus버튼을 누를때마다 -1이 되도록 코드를 쓴다. 

이렇게 코드를 쓰는 것은 좋은 방법은 아니라고 한다. state에 너무 의존적이라고 함. 

current를 이용해서 작성하면 훨씬 나은 방법이라고 한다. 

 

 

#3. 2 Component Life Cycle

 

react component에서 유일하게 사용되는 function은 render function이다.

component와 react component는 render 이외의 많은 것을 더 가지고 있다. 

 

 life cycle method를 가지는데 기본적으로 react가 component를 생성하는 그리고 없애는 방법이다.

 

Mounting:

먼저 호출되는 function은 counstructor()인데 이건 react에서 오지 않고 javascript에서 왔고

Javascript에서 class를 만들 때 호출되는 것이다.

그리고 웹사이트에서 component에서 render 하기 이전에 먼저 constructor()가 먼저 실행된다고 한다. 

그리고 render가 끝나면 componentDidmount가 실행한다고 한다.

import React from "react";
import PropTypes from"prop-types";



class App extends React.Component {
    state = {
        count: 0
    };
    add = () => {
        this.setState({count: this.state.count +1});
    };
    minus = ()=>{
        this.setState({count: this.state.count -1});
    };
    componentDidMount() {
        console.log("component rendered")
    }

    render() {
        console.log("i am rendering");
       return(
           <div>
               <h1>this number is:{this.state.count}</h1>
               <button onClick={this.add}>Add</button>
               <button onClick={this.minus}>Minus</button>
           </div>
       )
    }
}

export default App;

 

위에서 render와 componentDidMount에 console.log를 만들어 확인해보면 무엇이 먼저 실행되는지 확인 가능하다.

 

 

Updating:

 

 

업데이트의 원인은 사용자가 된다 아까 위에서 만들었던 add와 minus 버튼을 눌러 출력 값이 변경되는 것을 업데이팅이라고 할 수 있다. 

component가 업데이트될 때 호출되는 많은 function이 있다. 그중 하나는 getDerivedStateFromProps인데 이건 여기서 이야기 안 한다고 한다. 

 

여기서 봐야 할 것은

componentDidUpdate이다.

코드를 작성 후 웹에 가서 add버튼을 누르고 console창을 보면 componentDidUpdate가 실행되었다는 것을 확인할 수 있다.

import React from "react";
import PropTypes from"prop-types";



class App extends React.Component {
    state = {
        count: 0
    };
    add = () => {
        this.setState({count: this.state.count +1});
    };
    minus = ()=>{
        this.setState({count: this.state.count -1});
    };
    componentDidMount() {
        console.log("component rendered")
    }
    componentDidUpdate(prevProps, prevState, snapshot) {
        console.log("i just updated");
    }

    render() {
        console.log("i am rendering");
       return(
           <div>
               <h1>this number is:{this.state.count}</h1>
               <button onClick={this.add}>Add</button>
               <button onClick={this.minus}>Minus</button>
           </div>
       )
    }
}

export default App;

 

setState를 호출하면 component를 호출하고 먼저 render를 호출한 다음 업데이트가 완료되었다고 말하면 componentDidUpdate가 실행될 것이다.

 

 

Unmounting :

component가 죽을 때이고 죽을때 실행한다 실행하는지 확인할 방법은 없지만 믿으라고 한다. 실행된다고 ㅋㅋ

 

 

#3. 3 Planning the Movie Component

 

 위에서의 component life cycle을 알아보았고 이제는 만드려고 한 movie component를 구성해본다.

import React from "react";

class App extends React.Componet {
    state={
        isLoading: true
    };
    componentDidMount(){
        setTimeout(() => {
            this.setState({isLoading: false});
        },6000)  // 자바스크립트의 delayfunction이라고 한다. render 다음 componentDidMount가 실행되는데 6초뒤 실행되게 설정
    }
    render(){
        const { isLoading } = this.state;
        return <div>{isLoading ? "Loading..." : "We are ready"}</div> 
        // 자바스크립트의 삼항연산자라고 한다 true일시 Loadingd이 false일때 We are ready가 출력되게 만든다.
    }
}

6초 뒤에 웹에 We are ready가 생성되는 걸 확인할 수 있고 

 

 

이론적으로 우리가 할 링은 componentDidMount에서 data를 fetch 하는 것이다.

그리고 API로부터 data fetching이 완료되면 "we are ready"대신에 movie를 Render 하고 map을 만들고 movie를 하는 것이다.

 

반응형

+ Recent posts