반응형

읽기전용(read only)


 // TODO: 1) 읽기 전용(readonly) : 값 수정 불가
    interface IHello {
        readonly name: string
    }

    let val: IHello = { name: "hello"}; // 초기값 정의
    // val.name = "hello2"; // 변경불가 (readonly)

 

read only 변수에 값을 변경할 수 없음

튜플(tuple)


 // TODO: 2) 튜플(tuple) : 정해진 자료형의 고정된 크기의 배열
    let tuple: [string, number] = ["a", 1];
    console.log("tuple", tuple);
    // tuple = ["a", 1, 2]; // 값이 3개가 들어와서 에러
    // tuple = [1, "a"]; // 자료형 순서가 맞지 않음 에러

결과값
값이 3개가 들어와서 에러가 발생함
자료형 순서가 맞지 않는 경우

 

 

enum : 열거형, 상수를 대체해서 사용


  // TODO: enum : 열거형, 상수를 대체해서 사용함
  // TODO: 아래 상수에 자동으로 0 ~ n 1씩 증가되어 저장됨, 값도 직접 지정 가능
  enum Week {
    Sun,        // Sun = 0을 할당함
    Mon,        // Mon = 1
    Tue,        // Tue = 2
    Wed = 5,    // Wed = 5 (개발자가 강제로 값을 저장)
    Thu,        // Thu = 6
    Fri,        // Fri = 7
    Sat,        // Sat = 8
  }
  console.log("Week", Week);
  console.log("Week", Week.Sun);

 

사용자지정 타입


  • 여러 타입을 변수에 저장해서 사용자지정 타입으로 만들기
// TODO: 4) 별명 붙이기
  // TODO: 사용법 : type 별명 = 자료형 | 자료형2 ...
  // TODO: let 변수명 : 별명 = 값;
  type aliasUser = string | number;
  let person : aliasUser = "hong";
  console.log(person);

타입추론


// TODO: 5) 타입추론 : 모든 변수에 자료형을 지정하지않아도 값으로 추론하는 기능을 부여

  // TODO: (1) 변수의 초기값 : 생략가능
  let num = 10;     // 사용가능

  // TODO: (2) 기본값이 있는 매개변수 : 생략가능
  // 모던자바스크립트 사용법 : function 함수명(매개변수, 매개변수2 = 0){}
  // 함수의 사용 : 함수명(1) => 함수명(1, 0)    
  function add(a:number, b = 0):number {
    return a + b;
  }

  // TODO: (3) 리턴자료형은 함수에서 생략가능
  function add2(a:number, b = 0) {
    return a + b;
  }

 

타입(자료형) 단언


  // TODO: 6) 타입(자료형) 단언 :
  // TODO: 활용 : 컴퓨터는 알 수 없으나 개발자는 확실히 그 변수의 자료형을 확신하면 사용가능
  // TODO: 사용법 : 변수 as 자료형
  function someFunc(val: string | number, isNumber: boolean) {
    // 가정 : isNumber 가 true이면 무조건 val 값은 정수가 된다고 확신
    if (isNumber === true) {
      (val as number).toFixed(2);
    }
  }
반응형

'React > 이론' 카테고리의 다른 글

typescript - 함수  (0) 2023.09.06
typescript  (0) 2023.09.06
메모이제이션  (0) 2023.09.02
State(useState)  (0) 2023.08.31
리액트의 조건문 : 삼항연산자를 사용한 예제  (0) 2023.08.31
반응형

typescript에서의 함수 정의


// Func.tsx

import React from "react";
import { useState } from "react";

function Func() {
  // TODO: 변수 정의
  let [name, setName] = useState<string>("");
  let [message, setMessage] = useState<string>("");

  // TODO: 함수 정의 : 타입스크립트 적용
  // 매개변수 2개를 전달받아 message 변수에 저장하는 함수
  // getInputVal("안녕하세요", 2023)
  // TODO: 사용법 : const 함수명 = (매개변수: 자료형, ...): 리턴자료형 => {}
  const getInputVal = (arg: string, year: number): void => {
    setMessage(`${arg} 현재는 ${year} 년도 입니다.`); // message(화면 바인딩)
  };

  // 역바인딩(이벤트) 함수 정의
  // TODO: const 함수명 = (event:이벤트자료형...): 함수리턴자료형 => {};
  const onChangName = (event: React.ChangeEvent<HTMLInputElement>): void => {
    setName(event.target.value);
  };

  return (
    <div className="container">
      <input
        className="form-control mt-3 mb-3 w-25"
        type="text"
        name="name"
        value={name}
        onChange={onChangName}
      />
      입력값 : {name}
      <br />
      {/* react 아래 onClick={함수명} // 매개변수가 없는 함수 */}
      {/* TODO: 이벤트 함수에 매개변수가 있으면 화살표함수를 사용해야함 */}
      {/* react 아래 onClick={()=>{함수명(매개변수, 매개변수2)}} // 매개변수가 있는 함수는 화살표함수사용 */}
      <button
        className="btn btn-primary mt-3 mb-3"
        onClick={() => getInputVal("안녕하세요", 2023)}
      >
        입력값
      </button>
      <br />
      {message}
    </div>
  );
}

export default Func;
매개변수를 전달받는 함수정의

const 함수명 = (매개변수:자료형...):리턴자료형 => { };

 

역바인딩(이벤트) 함수 정의

const 함수명 = (event:이벤트자료형) :리턴자료형 => { };

 

이벤트자료형을 쉽게 알아내는 방법

  • html 태그 쪽에 있는 onChange에 마우스를 올리면 VScode에서 이벤트자료형을 추천해주는데 위의 붉은색 박스부분을 복사합니다.

  • 복사한 내용을 역바인딩 함수의 이벤트 자료형에 붙혀줍니다.
  • 단 ChangeEventHandler 부분의 Handler 부분은 삭제해줍니다.

 

연습문제


위의 화면처럼 출력해봅시다.

[부트스트랩 cdn]

    <!-- bootstrap css link -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.1/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-4bw+/aepP/YC94hEpVNVgiZdgIC5+VKNBQNGCHeKRQN+PtmoHDEXuppvnDJzQIu9" crossorigin="anonymous">

function FuncExam() {
return (
    <div className="container">
      <input
        className="form-control mt-3 mb-3 w-25"
        type="password"
        name="password"
        value={password}
        onChange={onChangPassword}
      />
      입력값 : {password}
      <br />
      <button
        className="btn btn-primary mt-3 mb-3"
        onClick={() => getInput("안녕하세요", 4, true)}
      >
        입력값
      </button>
      <br />
      {message}
    </div>
  );
}

export default FuncExam;

 

[정답]

  let [password, setPassword] = useState<string>("");
  let [message, setMessage] = useState<string>("");

  const getInput = (arg: string, day: number, bool: boolean): void => {
    setMessage(`${arg} 오늘날짜는 ${day} 일이 맞나요? 답은 ${bool} 입니다.`);
  };

  const onChangPassword = (
    event: React.ChangeEvent<HTMLInputElement>
  ): void => {
    setPassword(event.target.value);
  };
반응형

'React > 이론' 카테고리의 다른 글

typescript - etc  (1) 2023.09.06
typescript  (0) 2023.09.06
메모이제이션  (0) 2023.09.02
State(useState)  (0) 2023.08.31
리액트의 조건문 : 삼항연산자를 사용한 예제  (0) 2023.08.31
반응형

VS code에서 타입스크립트 프로젝트 생성방법


  • 폴더 생성 후 폴더 안에서 터미널 실행
  • 터미널에 npx create-react-app 프로젝트명 --template typescript 명령어 입력
  • 생성이 완료되면 리액트 서버 실행명령어 입력 npm start

프로젝트 생성완료가 되고 리액트 서버를 실행하면 위의 메시지가 출력됩니다.

typescript?


자바스크립트는 자료형을 정의하지 않고 자유롭게 변수에 값을 넣어 코딩이 가능합니다. 즉, 코딩이 간략하고 코딩생산성이 증가하지만 코딩시 에러를 잡지 못하고 서비스때 심각한 오류가 발생합니다.

 

즉 자바스크립트의 자료형을 명시해서 코딩하게 해주는 JS의 확장 언어를 타입스크립트라 합니다.

 

// Basic.tsx : 자식 컴포넌트(typescript 적용된 버전)
// rfce
import React, { useState } from 'react'
// 새로운 객체타입(자료형) 정의한 파일 import
import IObject from './../types/IObject';

function Basic() {
    // TODO: 타입스크립트 기본 사용법 익히기
    // 타입스크립트 바인딩 변수
    // 사용법 : let [변수명, set변수명] = useState<자료형>(초기값);
    let [message, setMessage] = useState<string>("바인딩 변수 출력입니다.");
    let [num, setNum] = useState<number>(0);
    let [bflag, setBflag] = useState<boolean>(true);
    let [obj, setObj] = useState<IObject>({id: null, name:"green"});
    let [arr, setArr] = useState<Array<number>>([1, 2, 3, 4, 5]);
    let [objArr, setObjArr] = useState<Array<IObject>>([{id: null, name: "green"}]);
   
    // TODO: 1) 기본자료형 : 문자열(string), 숫자(number), 참/거짓(boolean), 객체(따로정의)
    // 타입스크립트 일반 변수 정의
    // 사용법 : let 변수명: 자료형 = 값;
    let message2: string = "일반 변수 출력입니다."; // 문자열
    let num2: number = 1; // 숫자형(실수, 정수 모두 포함)
    let bflag2: boolean = false; // 참/거짓(bool, boolean)

    // TODO: 객체는 자료형을 개발자가 따로 정의해서 사용함
    // 사용법 let 변수명: 정의한객체파일명 = {속성:값...};
    // IObject = {id?: any(null제외한 어떤 자료형도 가능) | null, name: string(문자열만 가능)}
    // id는 모든 자료형 허용 또는 null 자료형도 허용 / name은 문자열만 허용
    let obj2: IObject  = {id: null, name:"green2"};   // 객체(object)

    // TODO: 2) 유니온 사용법 : let 변수명: 자료형(type) | 자료형2 ...
    let num3: number | string = 1;
    let num4: number | string = "hello";
    // let num5: number | string = true; // 에러 발생

    // TODO: 3) 옵셔널(?) : 객체의 속성이나 함수의 매개변수에 사용가능
    // TODO: 사용하면 오류없이 실행되게 함(자료형 | undefined 더 붙은 것과 같은 의미)
    function hello(name?: string) {
        console.log(`안녕하세요 ${name}`);
    }

    // 함수의 사용
    hello("홍길동"); // 안녕하세요 홍길동
    hello();        // 안녕하세요

    // TODO: 4) 배열 : let 변수: Array<자료형 | 자료형2 ...>
    // TODO: 변수 및 함수 사용 시 반드신 정의된 자료형의 값으로 사용하게 강제함
    let arr2: Array<string> = ["a", "b", "c"];     // 문자열 배열
    let arr3: Array<any> = [1, 2, 3];              // 모든 자료형 사용가능
    let arr4: Array<number> = [1, 2, 3];           // 숫자형 사용가능
   
    // TODO: 객체 배열
    let objArr2: Array<IObject> = [{ id: 1, name: "green2"}]; // JSON 문서 형태(객체배열)

  return (
    <div>
        문자(일반) : {message2}<br/>
        문자(바인딩) : {message}<br/>

        숫자형(일반) : {num2}<br/>
        숫자형(바인딩) : {num}<br/>

        boolean형(일반) : {bflag2? "참":"거짓"}<br/>
        boolean형(바인딩) : {bflag? "참":"거짓"}<br/>

        객체형(일반) : {obj2.name}<br/>  
        객체형(바인딩) : {obj.name}<br/>  

        배열(일반) : {arr2}<br/>  
        배열(바인딩) : {arr}<br/>

        {/* 객체배열은 반복문으로 출력 : .map((value, index)=>{}) */}
        객체배열(일반) : {objArr2.map((value)=>value.name)}<br/>  
        객체배열(바인딩) : {objArr.map((value)=>value.name)}<br/>  



    </div>
  )
}

export default Basic

객체형의 경우 개발자가 따로 정의를 해주어야 합니다.

 

// types폴더 > IObject.ts 객체 자료형을 정의하는 파일
// TODO: 타입스크립트 파일명 종류 : .tsx(jsx표현식을 사용한 js), .ts(jsx 표현식을 사용 안 한 js파일)
// TODO: 리액트의 JSX(Javascript and XML) : {값}
// 사용법
// export default interface 객체자료형명 {
//                  속성 : 자료형 | 자료형2 ...,
//                  속성2 : 자료형
// }
// 속성? : 옵셔널(?) : 속성이 없어도 오류 없이 실행되게 해줌
// 예) let obj: IObject = { name: "홍길동"}
//    obj.id (결과는 오류로 출력되지만 에러없이 프로그램이 실행되게 해줌)
export default interface IObject {
    id?: any | null,
    name: string
}

 

연습문제


// BasicExam.tsx : 자식컴포넌트
import React from "react";
import { useState } from "react";

function BasicExam() {
  let [message, setMessage] = useState<string>(
    "안녕하세요 그린컴퓨터아카데미입니다."
  );
  let [message2, setMessage2] = useState<string>("아래는 곱셈 샘플입니다.");
  let [message3, setMessage3] = useState<string>("곱셈");
  let [num, setNum] = useState<number>(2);
  let [num2, setNum2] = useState<number>(3);
  let [result, setResult] = useState<number>(num * num2);

  return (
    <div>
      {/* 아래 처럼 바인딩 변수를 사용해서 화면 출력을 하되 타입스크립트 코드를 적용하여 출력하세요
        단, 문자는 string , 숫자는 number 를 사용해서 코딩하세요
        */}
      {/* 결과 :
                안녕하세요 그린컴퓨터아카데미입니다.
                아래는 곱셈 샘플입니다.
                곱셈
                2 * 3 = 6
               
         */}
      {message}
      <br />
      {message2}
      <br />
      {message3}
      <br />
      {`${num} * ${num2} = ${result}`}
      <br />
    </div>
  );
}

export default BasicExam;

반응형

'React > 이론' 카테고리의 다른 글

typescript - etc  (1) 2023.09.06
typescript - 함수  (0) 2023.09.06
메모이제이션  (0) 2023.09.02
State(useState)  (0) 2023.08.31
리액트의 조건문 : 삼항연산자를 사용한 예제  (0) 2023.08.31
반응형

React.memo


컴포넌트, 변수, 함수 등을 재렌더링 할 때 제어가 필요한 경우 메모이제이션을 수행합니다.

 

메모이제이션이란 이전 처리 결과를 저장해둠으로써 처리속도를 높이는 기술입니다.

 

즉, 필요할 때만 다시 계산하게 하여 불필요한 처리를 줄입니다.

 

컴포넌트를 메모이제이션해서 부모 컴포넌트가 재렌더링되더라도 자식 컴포넌트의 재렌더링을 방지합니다.

 

리액트 내의 memo를 사용하며 import를 해주어야 합니다 사용법은 컴포넌트 함수 전체를memo() 로 감싸면 됩니다.

 

 

[App.js]

import { useState, memo } from "react";
import { Child1 } from "./components/Child1";
import { Child4 } from "./components/Child4";

//TODO: React.memo
// 리액트에서 컴포넌트, 변수, 함수 등을 재렌더링할 때 제어가 필요한 경우 메모이제이션을 수행
// 메모이제이션 : 이전 처리 결과를 저장, 처리속도를 높이는 기술, 필요할 때만 다시 계산하게 하여 불필요한 처리를 줄일 수 있음
// 사용법 : const 컴포넌트명 = memo(()=>{});
//         import memo from "react";

export const App = memo(() => {
  // 컴포넌트를 괄호로 감싸면 해당 컴포넌트는 props에 변경이 있을 때만 재렌더링됨
  console.log("App 렌더링");

  const [num, setNum] = useState(0);

  const onClickButton = () => {
    setNum(num + 1);
  };


  return (
    <>
      <button onClick={onClickButton}>버튼</button>
      <p>{num}</p>
      <Child1  />
      <Child4 />
    </>
  );
});

export default App;

[Child 1, 2, 3, 4]

import {Child2} from "./Child2";
import {Child3} from "./Child3";
import {memo} from "react";

const style = {
    height : "200px",
    backgroundColor : "lightblue",
    padding : "8px"
};

export const Child1 = memo((props) => {
    console.log("Child1 렌더링");
 

    return (
        <div style={style}>
            <p>Child 1</p>
            <Child2 />
            <Child3 />
        </div>
    );
 });
import {memo} from "react";
const style = {
  height: "50px",
  backgroundColor: "lightgray",
};

export const Child2 = memo(() => {
  console.log("Child2 렌더링");

  return (
    <div style={style}>
      <p>Child2</p>
    </div>
  );
});
import {memo} from "react";
const style = {
  height: "50px",
  backgroundColor: "lightgray",
};

export const Child3 = memo(() => {
  console.log("Child3 렌더링");

  return (
    <div style={style}>
      <p>Child3</p>
    </div>
  );
});
import {memo} from "react";
const style = {
  height: "200px",
  backgroundColor: "wheat",
  padding: "8px",
};

export const Child4 = memo(() => {
  console.log("Child4 렌더링");

  return (
    <div style={style}>
      <p>Child4</p>
    </div>
  );
});

[실행결과]

* 상단 버튼을 누르면 부모 컴포넌트인 App 부분만 재렌더링 되는 것을 볼 수 있으며 자식 컴포넌트 Child 1, 2, 3, 4는 재렌더링 되지 않는 것을 알 수 있습니다.

 

useCallback


memo를 사용해 컴포넌트를 메모이제이션 할 수 있습니다.

이번에는 함수 메모이제이션을 알아봅시다!

 

먼저 Child1에 리셋 버튼을 생성합니다.

리셋 버튼을 클릭하면 카운트 수치를 0으로 되돌리는 기능을 추가하면 됩니다.

카운트 수치의 state는 부모 컴포넌트인 App 이 가지고 있기 때문에 App 안에서 리셋하기 위한 함수를 정의하고 그 함수를 Child1에 전달하는 방식으로 구현합니다.

 

[App.js]

import { useState, memo } from "react";
import { Child1 } from "./components/Child1";
import { Child4 } from "./components/Child4";

//TODO: React.memo
// 리액트에서 컴포넌트, 변수, 함수 등을 재렌더링할 때 제어가 필요한 경우 메모이제이션을 수행
// 메모이제이션 : 이전 처리 결과를 저장, 처리속도를 높이는 기술, 필요할 때만 다시 계산하게 하여 불필요한 처리를 줄일 수 있음
// 사용법 : const 컴포넌트명 = memo(()=>{});
//         import memo from "react";

export const App = memo(() => {
  // 컴포넌트를 괄호로 감싸면 해당 컴포넌트는 props에 변경이 있을 때만 재렌더링됨
  console.log("App 렌더링");

  const [num, setNum] = useState(0);

  const onClickButton = () => {
    setNum(num + 1);
  };

  // 리셋함수 정의
  const onClickReset = () => {
    setNum(0);
   };

  return (
    <>
      <button onClick={onClickButton}>버튼</button>
      <p>{num}</p>
      {/* Child1에 props로 클릭함수를 전달 */}
      <Child1 onClickReset={onClickReset} />
      <Child4 />
    </>
  );
});

export default App;

[Child1.js]

import {Child2} from "./Child2";
import {Child3} from "./Child3";
import {memo} from "react";

const style = {
    height : "200px",
    backgroundColor : "lightblue",
    padding : "8px"
};

export const Child1 = memo((props) => {
    console.log("Child1 렌더링");

    // props로 부터 함수를 전개
    const {onClickReset} = props;

    return (
        <div style={style}>
            <p>Child 1</p>
            {/* onClick 속성 추가하고 함수 값 넣기 */}
            <button onClick={onClickReset}>리셋</button>
            <Child2 />
            <Child3 />
        </div>
    );
 });

[실행결과]

그러나 앞에서 최적화했던 재렌더링을 다시 확인해보면 카운트 업 할때마다 Child1이 재렌더링 되는 것을 알 수 있습니다.

함수를 Props에 전달할 때 컴포넌트를 메모이제이션해도 재렌더링되는 것은 

함수가 다시 생성되기 때문입니다. 일반적으로 우리가 함수를 정의할 때는 아래와 같이 정의합니다.

  // 리셋함수 정의
  const onClickReset = () => {
    setNum(0);
   };

 

이렇게 함수를 정의하면 재렌더링 등으로 코드가 실행될 때마다 항상 새로운 함수가 다시 생성됩니다.

따라서 함수를 Props로 받는 Child1 은 Props가 변화했다고 판정해 카운트업 할 때마다 재렌더링을 하게 되는 것입니다.

이 현상을 피하기 위해서는 함수에 메모이제이션을 해주어야 합니다.

 

리액트는 함수 메모이제이션 기능 useCallback을 제공합니다. useCallback은 첫번째 인수에 함수, 두번째 인수에 의존 배열을 받습니다.

 

그러면 Child1 에 리셋함수를 아래와 같이 변경해줍니다.

 

  // 리셋함수 정의 - useCallback 함수 사용
  const onClickReset = useCallback(() => {
    setNum(0);
   }, []);

 

변경 후 실행화면을 볼까요?

App 만 재렌더링되어 불필요한 재렌더링을 최적화하였습니다.

 

변수 메모이제이션


앞에서 컴포넌트 메모이제이션과 함수 메모이제이션에 대해 알아보았습니다.

기본적으로 이 두가지를 사용하면 불필요한 재렌더링을 제어할 수 있습니다. 

 

React.useMemo

memo나 useCallback 만큼은 자주사용하지는 않지만 리액트에서는 변수 메모이제이션으로 useMemo를 제공합니다.

useMemo 사용법은 아래와 같습니다.

 

   // 변수 메모이제이션
   const 변수명 = useMemo(()=>{
    // 실행부분 - 함수에 변수에 설정할 값의 반환
   },[의존배열]);
반응형

'React > 이론' 카테고리의 다른 글

typescript - 함수  (0) 2023.09.06
typescript  (0) 2023.09.06
State(useState)  (0) 2023.08.31
리액트의 조건문 : 삼항연산자를 사용한 예제  (0) 2023.08.31
map, filter  (0) 2023.08.31
반응형

State


리액트에서는 화면에 표시하는 데이터나 길이가 변하는 상태 등을 모두 State로 관리합니다.

웹 애플리케이션을 만들 때 화면은 다양한 상태를 가집니다. 예시는 다음과 같습니다.

  • 에러가 있는가?
  • 모달 창을 열고 있는가?
  • 버튼을 클릭했는가?
  • 텍스트 박스에 무언가를 입력했는가?

이와 같이 '상태'는 모두 State로 관리하며 이벤트가 실행되는 경우 등에 업데이트 처리를 수행함으로써 동적 애플리케이션을 구현합니다.

 

useState


useState는 리액트 안에서 제공되므로 사용할 때는 import해야 합니다.

 

import { useState } from "react";

useState 함수 반환값은 배열형태로 되어 있습니다. 첫번째에 State 변수, 두번째에 State를 업데이트하기 위한 함수가 설정됩니다.

 

  // State 정의
  const [변수명, set변수명] = useState(초기값);

버튼 클릭시 카운트업하는 기능을 구현해보겠습니다.

 

import { ColoredMessage } from "./components/ColoredMessage";
import { useState } from "react";

export const App = () => {
  // State 정의
  const [num, setNum] = useState(0);
 
  // 버튼 클릭 시 state를 카운트 업
  const onClickButton = () => {
    setNum(num + 1);
  };

 

 

  return (
    <>
      <h1 style={{ color: "red" }}>안녕하세요</h1>
      <ColoredMessage color="blue" message="잘 지내시죠?" />
      <ColoredMessage color="pink" message="잘 지냅니다!" />
      <button onClick={onClickButton}>버튼</button>
      {/* 아래에 카운트 변수 추가 */}
      <p>{num}</p>
    </>
  );
};

export default App;

반응형

'React > 이론' 카테고리의 다른 글

typescript  (0) 2023.09.06
메모이제이션  (0) 2023.09.02
리액트의 조건문 : 삼항연산자를 사용한 예제  (0) 2023.08.31
map, filter  (0) 2023.08.31
리액트 컴포넌트의 생명주기(LifeCycle) : 생성/수정  (0) 2023.08.30
반응형

ul-li 태그 반복하여 출력하기

function H_Book() {
   
  const students = [
    {
      id: 1,
      name: "Inje",
    },
    {
      id: 2,
      name: "Steve",
    },
    {
      id: 3,
      name: "Bill",
    },
    {
      id: 4,
      name: "Jeff",
    },
  ];

  //   변수정의
  const [student, setStudent] = useState(students);

  return (
    <div>
      <ul class="list-group">
        {/* 반복문 : 여기서 돌리면 됨 */}
        {student.map((value, index) => {
          return (
          <li class="list-group-item">{value.name}</li>
          );
        })}
      </ul>
    </div>
  );
}

export default H_Book;

 

반응형

'React > 실습' 카테고리의 다른 글

삼항연산자를 이용한 실습  (0) 2023.08.31
조건문을 활용한 예제  (0) 2023.08.31
반복문을 활용한 예제  (0) 2023.08.31
useState 이용 4가지 변수 넣기  (0) 2023.08.31
useState 함수를 이용한 Comment 출력  (0) 2023.08.31
반응형

아래 변수에 값이 있다. isFull 이 true 이면 <p style={{ color: "red" }}>정원이 가득찼습니다.</p> 아니면 <p style={{ color: "blue" }}>입장할 수 있습니다.</p> 를 출력하세요.
import React from "react";
import { useState } from "react";

function E_ComfirmButton_Exam() {

  let [isFull, setIsFull] = useState(false);

  const display = () => {
    setIsFull(true);
  };

  return (
    <div>
      <button onClick={display} className="btn btn-warning">
        {(isFull === true) ? (
          <p style={{ color: "red" }}>정원이 가득찼습니다.</p>
        ) : (
          <p style={{ color: "blue" }}>입장할 수 있습니다.</p>
        )}
      </button>
    </div>
  );
}

export default E_ComfirmButton_Exam;

아래 변수 count 에 9 의 값이 있다.  10을 초과하면 ( count>10 ) <p style={{ color: "red" }}>정원이 가득찼습니다.</p>아니면 <p style={{ color: "blue" }}>입장할 수 있습니다.</p> 를 출력하세요.
function F_ConfirmButton_Exam2() {
    let [count, setCount] = useState(9);  // 변수선언
    const addCount = () => {  // 클릭이벤트 함수 => 클릭시  카운트 증가
        let val = count + 1;
        setCount(val);
     }

  return (
    <div>
        현재 정원 : {count}
        <br/>
        <button onClick={addCount}  disabled={((count > 10) === true) ? true : false}> 카운트 수가 10 초과하면 버튼 비활성화
           {
            (count > 10) === true ? <p style={{ color: "red" }}>정원이 가득찼습니다.</p> : <p style={{ color: "blue" }}>입장할 수 있습니다.</p>
           }
        </button>
    </div>
  )
}

 

 

onClickLogout 함수는 클릭하면 isLoggedIn 변수의 값을 true -> false 로 변경한다.
onClickLogIn 함수는 클릭하면 isLoggedIn 변수의 값을 false -> true로 변경한다.
코딩을 완성해보세요.
function G_LandingPage() {
    // TODO: 변수 정의
    const [isLoggedIn, setIsLoggedIn] = useState(false);   // 초기값 false
    // TODO: 함수 정의
    // nfn
    const onClickLogin = () => {
        // TODO: 아래 코딩하세요
        setIsLoggedIn(true);
       
     }
         // nfn
    const onClickLogout = () => {
        // TODO: 아래 코딩하세요
        setIsLoggedIn(false);
     }

  return (
    <div>
        {
            (isLoggedIn===true)? (
                <button onClick={onClickLogout}>로그아웃</button>
            ) : (
                <button onClick={onClickLogin}>로그인</button>
            )
        }
    </div>
  )
}

반응형

'React > 실습' 카테고리의 다른 글

반복문을 활용한 예제(2)  (0) 2023.08.31
조건문을 활용한 예제  (0) 2023.08.31
반복문을 활용한 예제  (0) 2023.08.31
useState 이용 4가지 변수 넣기  (0) 2023.08.31
useState 함수를 이용한 Comment 출력  (0) 2023.08.31
반응형

# TODO

아래 버튼을 클릭하면 문구가 확인하기 -> 확인됨으로 바뀌게 하고

버튼 상태를 비활성화 시켜보자.

 

#1 버튼의 상태를 변경할 변수값 선언

 

 // TODO: 변수정의
    let [isConfirmed, setIsConfirmed] = useState(false);

#2 버튼을 누르면 문구변경 / 상태변경 함수 정의

 

// TODO: 함수정의
    const handleConfirm = () => {
        setIsConfirmed(true);
     }

#3 문구부분을 삼항 연산자를 사용하여 변경

 

return (
    <div>
        <button onClick={handleConfirm}
                disabled={isConfirmed}
        >
            {
                (isConfirmed === true)? "확인됨" : "확인하기"  // button의 문구부분 -> 삼항연산자 사용
            }
        </button>
    </div>
  )

반응형

'React > 이론' 카테고리의 다른 글

메모이제이션  (0) 2023.09.02
State(useState)  (0) 2023.08.31
map, filter  (0) 2023.08.31
리액트 컴포넌트의 생명주기(LifeCycle) : 생성/수정  (0) 2023.08.30
CSS 적용  (0) 2023.08.30
반응형

// TODO : 연습문제 ) 아래 소스를 완성하세요
//   버튼을 클릭하면 isTable 변수의 값을 true 로 바꾸고,
//   아래 내용을 담고 있는 테이블 태그로
//   화면에 보이게 만드세요.
//   (부트스트랩 테이블 디자인을 활용하세요.)
//    테이블 내용 :
//               No   Dname       Loc
//               1    Sales       부산
//               2    Development 서울

#1 테이블 보이게/안보이게 하기 위한 isTable의 변수 값을 지정

let [isTable, setIsTable] = useState(false)

#2 태그부분에 논리연산자를 입력하여 true 값이면 보이게하기

 return (
    <div>
      <button onClick={displayTable} className="btn btn-warning">
        테이블 보이기
      </button>
      <br />
      {isTable &&    // isTable 이 true 이면 아래 태그 출력
        <table class="table">
        <thead>
          <tr>
            <th scope="col">No</th>
            <th scope="col">Dname</th>
            <th scope="col">Loc</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <th scope="row">1</th>
            <td>Sales</td>
            <td>부산</td>
          </tr>
          <tr>
            <th scope="row">2</th>
            <td>Development</td>
            <td>서울</td>
          </tr>
        </tbody>
      </table>}
    </div>
  );

#3 버튼클릭시 테이블 보이게/안보이게 하는 함수 지정

 

 <button onClick={displayTable} className="btn btn-warning">

 

const displayTable = () => {
        if(isTable === true){
            setIsTable(false);
        } else {
            setIsTable(true);
        }
     }

반응형

'React > 실습' 카테고리의 다른 글

반복문을 활용한 예제(2)  (0) 2023.08.31
삼항연산자를 이용한 실습  (0) 2023.08.31
반복문을 활용한 예제  (0) 2023.08.31
useState 이용 4가지 변수 넣기  (0) 2023.08.31
useState 함수를 이용한 Comment 출력  (0) 2023.08.31
반응형

기존 for문


기존 배열을 정의하고 for 문을 사용하여 출력할 수 있습니다.

const numArr = [1, 2, 3, 4];

// for문을 이용한 배열 처리

for(let i = 0; i < numArr.length; i++){
    console.log(numArr[i]);
}
 
[출력결과]
// 1
// 2
// 3
// 4

 

 

map 함수 이용


1) 배열 정의

const numArr = [1, 2, 3, 4];

// 배열.map()을 이용

const numArr2 = numArr.map();

// 배열.map(함수) 이용

const numArr2 = numArr.map(()=>{});

.map( ) 괄호 안에 함수를 입력합니다.

함수는 임의의 이름을 붙인 인수를 받을 수 있고 거기에 배열의 값이 들어갑니다. 그리고 반환하는 요소를 함수안에서 return 합니다.

 

const numArr = [1, 2, 3, 4];
// 인수 num에 배열의 값이 저장되고 return 으로 반환
const numArr2 = numArr.map((num)=>{
    return num;
});

console.log(numArr2); // [1, 2, 3, 4]

이 상태는 numArr2에 numArr을 그대로 저장한 것이나 다름 없으므로 맨 위의 for 문과 같이 수정해줍니다.

 

const numArr = [1, 2, 3, 4];

const numArr2 = numArr.map( num => console.log(num) );

[결과]

 

 

filter 함수


map 함수와 비슷한 filter 함수에 대해 알아봅시다.

filter 함수는 map 함수의 이용방법과 거의 동일하지만 return 뒤에 조건식이 들어가는 것에서 차이가 납니다.

다음 코드는 배열에서 홀수만 출력하는 예입니다.

 

// 배열 정의
const numArr = [1, 2, 3, 4, 5, 6];

// 홀수만 추출
// 2로 나누어 나머지가 1이면 홀수!
const newNumber = numArr.filter((num) => {
    return num % 2 === 1;
})

console.log(newNumber); // [1, 3, 5]

 

index 다루어보기


반복문을 사용해 배열을 처리할 때 몇 번째 요소인지 알아야하는 경우가 생깁니다.

for문을 사용하면 애초에 index 값을 이용하기 때문에 순서에 대한 개념을 이용할 수 있습니다.

// 배열 정의

const nameArr = ["철수", "영희", "민수"];

// for 문을 사용한 index 이용
for(let index = 0; index < nameArr.length; index++){
    console.log(`${index + 1} 번째 사람의 이름은 ${nameArr[index]} 입니다.`)
}

 

같은 코드를 map 함수를 이용해 처리해봅시다.

// 배열 정의

const nameArr = ["철수", "영희", "민수"];

// map 함수 이용

let newArr = nameArr.map((name, index)=>{console.log(`${index + 1} 번째 사람의 이름은 ${name} 입니다.`)});

 

map 함수를 이용한 활용예


이름이 철수, 영희, 민수 라는 배열이 선언되어있고, 철수 이름 뒤에는 님이라는 존칭이 붙은 새로운 배열을 생성해보자.
// 배열 정의

const nameArr = ["철수", "영희", "민수"];

// map 함수 이용

let newNameArray = nameArr.map((name) => {
    if(name === "철수") {
        return `${name}님`;
    } else {
        return name;
    }
})

console.log(newNameArray);

반응형

'React > 이론' 카테고리의 다른 글

State(useState)  (0) 2023.08.31
리액트의 조건문 : 삼항연산자를 사용한 예제  (0) 2023.08.31
리액트 컴포넌트의 생명주기(LifeCycle) : 생성/수정  (0) 2023.08.30
CSS 적용  (0) 2023.08.30
JSX 문법  (0) 2023.08.30
반응형

 // TODO : 연습문제 아래 데이터를 반복문으로 출력하세요
// CommentList_Exam2.js
// TODO : 연습문제 아래 데이터를 반복문으로

import React, { useState } from "react";
import "../assets/styles.css";

function F_CommentList_Exam2() {
  // TODO : 연습문제 아래 데이터를 반복문으로
  //        출력하세요
  const initialWebtoons = [
    {
      name: "햄스터와 그녀",
      isUpdate: true,
    },
    {
      name: "프롬 스타",
      isUpdate: true,
    },
    {
      name: "위대한 로맨스",
      isUpdate: false,
    },
    {
      name: "빛나는 손을",
      isUpdate: false,
    },
  ];

  //   변수 정의(useState())
  let [webtoons, setWebtoons] = useState(initialWebtoons)
  // 변수/함수 부분
  // -----------------------------------
  // html 부분

  return (
    <div>
      {/* html 아래 내용 반복문 수행 */}
      {/* 반복문 : 배열변수.map(()=>{return(태그)}) */}
      {webtoons.map((webtoon, index) => {
        return (
          // html 태그 추가(반복)
          <div className="wrapper" key={index}>
            <div className="contentContainer">
            <span className="commentText">
                <img src={webtoon.img} />{" "}
              </span>
              <br/>
              <span className="nameText">{webtoon.name}</span>
              <span className="commentText">
                <a href={webtoon.link}>{webtoon.link}</a>
              </span>
              <span className="commentText">
                {webtoon.isUpdate? "true" : "false"}
              </span>
            </div>
          </div>
        );
      })}
    </div>
  );
}

export default F_CommentList_Exam2;
반응형

'React > 실습' 카테고리의 다른 글

반복문을 활용한 예제(2)  (0) 2023.08.31
삼항연산자를 이용한 실습  (0) 2023.08.31
조건문을 활용한 예제  (0) 2023.08.31
useState 이용 4가지 변수 넣기  (0) 2023.08.31
useState 함수를 이용한 Comment 출력  (0) 2023.08.31
반응형

      // TODO : image 는 img 태그의 src 에 넣고, link 주소는 a href 속성에 넣어서 출력하시요
      // TODO : isUpdate 가 true 이면 화면에 "true" 라고 출력하고, false 이면 "false"라고 출력하세요.

import React, { useState } from 'react'
import "../assets/styles.css";

function C_Comment_Exam2() {
    // TODO : useState 이용 4가지 변수 넣기, Comment_Exam2.css import
    //        name="제목"
    //        link="http://www.naver.com"
    //         isUpdate=true

  let [name, setName] = useState("제목");
  let [link, setLink] = useState("http://www.naver.com");
  let [isUpdate, setIsUpdate] = useState(true);
 
    return (
    <div className="wrapper">
    {
      // TODO : image 는 img 태그의 src 에 넣고, link 주소는 a href 속성에 넣어서 출력하시요
      // TODO : isUpdate 가 true 이면 화면에 "true" 라고 출력하고, false 이면 "false"라고 출력하세요.
    }
    <div className="contentContainer">
      <span className="commentText">
        <img src={img} />{" "}
      </span>
      <br/>
      <span className="nameText">{name} </span>
      <span className="commentText">
        <a href={link}>{link} </a>
      </span>
      <span className="commentText">{isUpdate? "true" : "false"} </span>
    </div>
  </div>
  )
}

export default C_Comment_Exam2
반응형

'React > 실습' 카테고리의 다른 글

반복문을 활용한 예제(2)  (0) 2023.08.31
삼항연산자를 이용한 실습  (0) 2023.08.31
조건문을 활용한 예제  (0) 2023.08.31
반복문을 활용한 예제  (0) 2023.08.31
useState 함수를 이용한 Comment 출력  (0) 2023.08.31

+ Recent posts