1. Component Create

// 클래스 컴포넌트
class ClassComp extends React.Component {
  render() {
    return (
      <div className="container">
        <h2>class style component</h2>
        <p>Number : 2</p>
      </div>
    )
  }
}
// 함수형 컴포넌트
function FuncComp(props) {
  return (
    <div className="container">
      <h2>function style component</h2>
      <p>Number : 2</p>
    </div>
  );
}

 

 

2. Props

import React, { Component } from 'react'

export default class App extends Component {
  render() {
    return (
      <div className="container">
        <h1>Hello World</h1>
        <FuncComp initNumber={2}></FuncComp>
        <ClassComp initNumber={2}></ClassComp>
      </div>
    )
  }
}

// 함수형
// 인자로 props라는 이름으로 편의상 쓰는 것(다른 이름도 가능)
function FuncComp(props) {
  return (
    <div className="container">
      <h2>function style component</h2>
      <p>Number : {props.initNumber}</p>
    </div>
  );
}

// 클래스형
class ClassComp extends React.Component {
  render() {
    return (
      <div className="container">
        <h2>class style component</h2>
        <p>Number : {this.props.initNumber}</p>
      </div>
    )
  }
}

 

 

 

3. State

 

// 함수형
function FuncComp(props) {
  // state 초기화
  let numberState = useState(props.initNumber); // --> useState는 무조건 배열이 리턴
  let number = numberState[0]; //state 사용, 배열의 첫번째: 상태값
  let setNumber = numberState[1]; // state 변경, 배열의 두번째: 상태를 바꿀수 있는 함수

  // 간단 축약형 사용법
  let [_date, setDate] = useState((new Date()).toString());

  return (
    <div className="container">
      <h2>function style component</h2>
      <p>Number : {number}</p>
      <p>Date : {_date}</p>
      <input type="button" value="random" onClick={
        function () {
          setNumber(Math.random());
        }
      } />
      <input type="button" value="date" onClick={
        function () {
          setDate((new Date()).toString());
        }
      } />
    </div>
  );
}

 

Function 컴포넌트에서 state를 사용하기 위해서는 useState Hooks를 사용한다.

 

useState(초기값) - [state value, func] 배열 return

  • useState는 무조건 2개의 값 요소를 갖는 배열이 리턴된다.

  • 초기값을 줬을 때, 리턴된 배열의 첫 번째 요소가 그 값이 된다.

  • 리턴된 배열의 2번째 값은 함수로, state를 바꿀 수 있는 함수다.

 

 

 

// 클래스형
class ClassComp extends React.Component {
  // state 초기화
  state = {
    number: this.props.initNumber,
    date: (new Date()).toString()
  }
  render() {
    return (
      <div className="container">
        <h2>class style component</h2>
        <p>Number : {this.state.number}</p> {/*state 사용 */}
        <p>Date : {this.state.date}</p>
        <input type="button" value="random" onClick={
          function () {
            this.setState({ number: Math.random() }); {/*state 변경 */ }
          }.bind(this)
        } />
        <input type="button" value="date" onClick={
          function () {
            this.setState({ date: (new Date()).toString() }); {/*state 변경 */ }
          }.bind(this)
        } />
      </div>
    )
  }
}

 

Class 컴포넌트에서 안 좋은 점이 bind를 해줘야 하는 것이다. 바인딩을 안 하고 사용하는 방법들이 존재한다. (ex. 화살표 함수...)

  • state 초기화 : constructor를 사용하거나, 위와 같이 사용해 초기화할 수 있다.

  • state 사용 : this.state를 이용한다. 여기서 render 함수 안에서 바인딩을 해줘야 한다.

  • state 변경 : this.setState를 이용한다.

 

 

 

 

4. Life cycle

 

 

useEffect(<function>, <Array>) 

  • <Array> == 생략 : 첫 렌더링 + state 변화에 따른 모든 렌더링 시에 동작한다.

  • <Array> == [ ] : 첫 렌더링 시에만 동작한다. componentDidMount()와 같다.

  • <Array> == [state] : 첫 렌더링 시 동작하고, 배열 안에 넣어준 값의 상태가 변할 때마다 계속 동작한다. componentDidMount() & componentDidUpdate()

  • Clean up : return으로 함수를 지정해주면 clean up작업을 한다. componentWillUnmount()와 같은 동작이다. 즉, 컴포넌트가 수명을 다하고 사라질 때 어떤 행동을 하는 것을 의미한다.

 

 

반응형

React 엘리먼트에서 이벤트를 처리하는 방식은 DOM 엘리먼트에서 이벤트를 처리하는 방식과 매우 유사하다. 몇 가지 차이는 다음과 같다.

  • React의 이벤트는 소문자 대신 캐멀 케이스(camelCase)를 사용한다.

  • JSX를 사용하여 문자열이 아닌 함수로 이벤트 핸들러를 전달한다.

  • React에서는 false를 반환해도 기본 동작을 방지할 수 없습니다. 반드시 preventDefault를 명시적으로 호출해야한다.

 

ES6 클래스를 사용하여 컴포넌트를 정의할 때, 일반적인 패턴은 이벤트 핸들러를 클래스의 메서드로 만드는 것이다.

class Toggle extends React.Component {
  constructor(props) {
    super(props);
    this.state = {isToggleOn: true};

    // 콜백에서 `this`가 작동하려면 아래와 같이 바인딩 해주어야 합니다.
    this.handleClick = this.handleClick.bind(this);
  }
  
  // 토글 이벤트 메서드
  handleClick() {
    this.setState(state => ({
      isToggleOn: !state.isToggleOn
    }));
  }

  render() {
    return (
      <button onClick={this.handleClick}>
        {this.state.isToggleOn ? 'ON' : 'OFF'}
      </button>
    );
  }
}

ReactDOM.render(
  <Toggle />,
  document.getElementById('root')
);

 

- this의 의미와 binding

JSX 콜백 안에서 this의 의미에 대해 주의해야 합니다. JavaScript에서 클래스 메서드는 기본적으로 바인딩되어 있지 않다. this.handleClick을 바인딩하지 않고 onClick에 전달하였다면, 함수가 실제 호출될 때 this undefined가 된다.

 

이는 React만의 특수한 동작이 아니며, JavaScript에서 함수가 작동하는 방식의 일부다. 일반적으로 onClick={this.handleClick}과 같이 뒤에 ()를 사용하지 않고 메서드를 참조할 경우, 해당 메서드를 바인딩 해야 한다.

 

 

- binding 하지 않는 2가지 방법

class LoggingButton extends React.Component {
  // 이 문법은 `this`가 handleClick 내에서 바인딩되도록 합니다.
  // 주의: 이 문법은 *실험적인* 문법입니다.
  handleClick = () => {
    console.log('this is:', this);
  }

  render() {
    return (
      <button onClick={this.handleClick}>
        Click me
      </button>
    );
  }
}

 

  • 만약 클래스 필드 문법을 사용하고 있지 않다면, 콜백에 화살표 함수를 사용하는 방법도 있다.

class LoggingButton extends React.Component {
  handleClick() {
    console.log('this is:', this);
  }

  render() {
    // 이 문법은 `this`가 handleClick 내에서 바인딩되도록 합니다.
    return (
      <button onClick={() => this.handleClick()}>
        Click me
      </button>
    );
  }
}

 

이 문법의 문제점은 LoggingButton이 렌더링될 때마다 다른 콜백이 생성된다는 것이다. 대부분의 경우 문제가 되지 않으나, 콜백이 하위 컴포넌트에 props로서 전달된다면 그 컴포넌트들은 추가로 다시 렌더링을 수행할 수도 있다. 이러한 종류의 성능 문제를 피하고자, 생성자 안에서 바인딩하거나 클래스 필드 문법을 사용하는 것을 권장합니다.

 

 

 

- 이벤트 핸들러에 인자 전달하기

<button onClick={(e) => this.deleteRow(id, e)}>Delete Row</button>
<button onClick={this.deleteRow.bind(this, id)}>Delete Row</button>

 

위 두 줄은 동등하며 각각 화살표 함수 Function.prototype.bind를 사용한다.

두 경우 모두 React 이벤트를 나타내는 e 인자가 ID 뒤에 두 번째 인자로 전달된다. 화살표 함수를 사용하면 명시적으로 인자를 전달해야 하지만 bind를 사용할 경우 추가 인자가 자동으로 전달된다.

반응형

1. State

  • 컴포넌트 내부에서 선언하며 내부에서 값을 변경할 수 있다.

  • props와의 차이점이라면, state는 컴포넌트 내부에 존재하고 있기 때문에, 상태 값 변경이 가능하다는 것이다.(즉, 구현하는 쪽에 중점을 둔다.)

  • this.setState() 메소드를 통해서 상태 값을 변경해준다.

  • 상위 컴포넌트의 state는 하위 컴포넌트의 props로 전달된다.

 

import React, { Component } from 'react'
import Subject from './components/Subject';
import Content from './components/Content';
import TOC from './components/TOC';

class App extends Component {
  // 초기 this.state를 지정하는 class constructor
  constructor(props) {
    super(props);
    this.state = {
      subject: { title: "WEB", sub: "World Wide Web!" },
      contents: [
        { id: 1, title: 'HTML', desc: 'HTML is for information' },
        { id: 2, title: 'CSS', desc: 'CSS is for design' },
        { id: 3, title: 'JavaScript', desc: 'JavaScript is for interactive' }
      ]
    }
  }

	// this.state를 이용해 state 값 사용
     // 상위 컴포넌트의 state는 하위 컴포넌트의 props로 전달된다.!!!!!!
  render() {
    return (
      <div className="App">
        <Subject title={this.state.subject.title} sub={this.state.subject.sub} />
        <TOC data={this.state.contents} />
        <Content />
      </div>
    );
  }
}


export default App;

 

클래스 컴포넌트는 항상 props로 기본 constructor를 호출해야 한다.

 

- Constructor(생성자) : JS Class 문법

constructor 메소드는 class 로 생성된 객체를 생성하고 초기화하기 위한 특수한 메서드다.  "constructor"라는 이름을 가진 특수한 메서드는 클래스 안에 한 개만 존재할 수 있다. 만약 클래스에 여러 개의 constructor 메서드가 존재하면 SyntaxError 가 발생할 것이다. constructor는 부모 클래스의 constructor를 호출하기 위해 super 키워드를 사용할 수 있다.

 

State 객체를 사용하고 싶다면 컴포넌트를 생성할 때 가장 윗부분(render() 함수보다 먼저)에 constructor() 함수를 적어준다. 컴포넌트 생성자에서 super를 호출하기 전에는 this를 사용할 수 없기 때문이다. 즉, 컴포넌트의 시작 부분에서 constructor()constructor()라는 함수가 컴포넌트의 초기화를 시켜줘야 StateState에 값을 넣어 사용할 수 있는 것이다.

 

 

- super(props)를 써야 하는 이유

자바스크립트에서 supersuper는 부모 클래스 생성자의 참조다. 그리고 자바스크립트는 언어적 제약사항으로서 생성자에서 super를

 

Hooks를 사용한다면 super  this에 대해 고민하지 않아도 된다!!!

 

 

2. setState

 

- 컴포넌트에서 state를 직접 바꾸면 안 된다.

this.state를 지정할 수 있는 유일한 공간은 바로 constructor입니다.

// Wrong
this.state.comment = 'Hello';

 

다음과 같이 setState() 함수를 사용해서 state를 변경해야 한다.

// Correct
this.setState({comment: 'Hello'});

 

- State 업데이트는 비동기적일 수도 있다.

 

this.props와 this.state가 비동기적으로 업데이트될 수 있기 때문에 다음 state를 계산할 때 해당 값에 의존해서는 안 된다.

// Wrong
this.setState({
  counter: this.state.counter + this.props.increment,
});

 

props와 state의 비동기적 업데이트를 고려해 함수를 인자로 사용하는 다른 형태의 setState()를 사용하면 된다. 그 함수는 이전 state첫 번째 인자로 받아들일 것이고, 업데이트가 적용된 시점의 props두 번째 인자로 받아들일 것이다.

// Correct
this.setState((state, props) => ({
  counter: state.counter + props.increment
}));

// Correct
this.setState(function(state, props) {
  return {
    counter: state.counter + props.increment
  };
});

 

 

- 독립적으로 state들을 업데이트할 수 있다.

 

  constructor(props) {
    super(props);
    this.state = {
      posts: [],
      comments: []
    };
  }
  
  // 독립적으로 각각 업데이트
  componentDidMount() {
    fetchPosts().then(response => {
      this.setState({
        posts: response.posts
      });
    });

    fetchComments().then(response => {
      this.setState({
        comments: response.comments
      });
    });
  }

 

 

 

반응형

1. Function Component & Class Component

 

// 함수형 컴포넌트
function Welcome(props) {
  return <h1>Hello, {props.name}</h1>;
}

이 함수는 데이터를 가진 하나의 “props” (props는 속성을 나타내는 데이터) 객체 인자를 받은 후 React 엘리먼트를 반환한다.

 

// 클래스형 컴포넌트
class Welcome extends React.Component {
  render() {
    return <h1>Hello, {this.props.name}</h1>;
  }
}

ES6 Class를 사용해 컴포넌트를 정의하면 된다.

 

- 함수형에서 클래스형 컴포넌트로 바꾸기

  1. React.Component를 확장하는 동일한 이름의 ES6 class를 생성합니다.

  2. render()라고 불리는 빈 메서드를 추가합니다.

  3. 함수의 내용을 render() 메서드 안으로 옮깁니다.

  4. render() 내용 안에 있는 props를 this.props로 변경합니다.

 

 

※ 주의

사용자 정의 컴포넌트는 반드시 대문자로 시작해야 한다.

Element가 소문자로 시작하는 경우에는 <div>  <span> 같은 내장 컴포넌트라는 것을 뜻하며 'div'  'span' 같은 문자열 형태로 React.createElement에 전달된다. <Foo />와 같이 대문자로 시작하는 타입들은 React.createElement(Foo)의 형태로 컴파일되며 JavaScript 파일 내에 사용자가 정의했거나 import 한 컴포넌트를 가리킨다고 한다.

 

 

 

2. Props

props는 읽기 전용이다.

함수 컴포넌트나 클래스 컴포넌트 모두 컴포넌트의 자체 props를 수정해서는 안된다.

 

App.js
// APP.js
import React, { Component } from 'react'
import Subject from './components/Subject'; //컴포넌트 import
import Content from './components/Content'; //컴포넌트 import


class App extends Component {
  render() {
    return (
      <div className="App">
        <Subject title="WEB" sub="Wold Wide Web!" /> // props 전달
        리액트 공부하기!
        <Content title="HTML" desc="HTML is ..." /> // props 전달
      </div>
    );
  }
}

export default App;

 

하위 컴포넌트에 전달할 데이터를 props로 전달한다. 여기선 <Subject>, <Content> 각 컴포넌트에 porps를 전달해줬다.

 

 

Subject.js
// Subject.js
import React, { Component } from 'react'

export default class Subject extends Component {
  render() {
    console.log('Subject render!');
    return (
      <header>
        <h1>{this.props.title}</h1> // 전달받은 props를 사용해 렌더링한다.
        {this.props.sub}
      </header>
    )
  }
}

 

Content.js
// Content.js
import React, { Component } from 'react'

export default class Content extends Component {
  render() {
    return (
      <article>
        <h2>{this.props.title}</h2> // 전달받은 props를 사용해 렌더링한다.
        {this.props.desc}
      </article>
    )
  }
}

 

전달받은 props를 사용할 때는 현재 Class를 가리키는 this를 사용한다.

this.props.(전달받은 props 명) 형식으로 중괄호와 함께 사용해주면 받은 데이터를 렌더링 할 수 있게 된다.

 

 

 

- 결과 화면

<결과 화면>

반응형

+ Recent posts