Saya membuat langkah pertama saya di ReactJS dan mencoba memahami komunikasi antara orang tua dan anak-anak. Saya membuat formulir, jadi saya memiliki komponen untuk bidang penataan. Dan juga saya memiliki komponen induk yang mencakup bidang dan memeriksanya. Contoh:

var LoginField = React.createClass({
    render: function() {
        return (
            <MyField icon="user_icon" placeholder="Nickname" />
        );
    },
    check: function () {
        console.log ("aakmslkanslkc");
    }
})

var MyField = React.createClass({
    render: function() {
...
    },
    handleChange: function(event) {
//call parent!
    }
})

Apakah ada cara untuk melakukannya? Dan apakah logika saya baik di "dunia" rejinya? Terima kasih atas waktunya.

Untuk melakukan ini, Anda meneruskan panggilan balik sebagai properti ke anak dari orang tua.

Sebagai contoh:

var Parent = React.createClass({

    getInitialState: function() {
        return {
            value: 'foo'
        }
    },

    changeHandler: function(value) {
        this.setState({
            value: value
        });
    },

    render: function() {
        return (
            <div>
                <Child value={this.state.value} onChange={this.changeHandler} />
                <span>{this.state.value}</span>
            </div>
        );
    }
});

var Child = React.createClass({
    propTypes: {
        value:      React.PropTypes.string,
        onChange:   React.PropTypes.func
    },
    getDefaultProps: function() {
        return {
            value: ''
        };
    },
    changeHandler: function(e) {
        if (typeof this.props.onChange === 'function') {
            this.props.onChange(e.target.value);
        }
    },
    render: function() {
        return (
            <input type="text" value={this.props.value} onChange={this.changeHandler} />
        );
    }
});

Pada contoh di atas, Parentpanggilan Childdengan properti dari valuedan onChange. Sebagai Childgantinya mengikat onChangepawang ke <input />elemen standar dan melewati nilai hingga Parentpanggilan balik jika itu didefinisikan.

Akibatnya Parent's changeHandlermetode ini disebut dengan argumen pertama menjadi nilai string dari <input />lapangan di Child. Hasilnya adalah bahwa Parentstatus dapat diperbarui dengan nilai itu, menyebabkan <span />elemen induk diperbarui dengan nilai baru saat Anda mengetiknya di Childbidang input.

Anda dapat menggunakan metode induk apa pun. Untuk ini, Anda harus mengirim metode ini dari orang tua Anda kepada anak Anda seperti nilai sederhana. Dan Anda dapat menggunakan banyak metode dari orang tua sekaligus. Sebagai contoh:

var Parent = React.createClass({
    someMethod: function(value) {
        console.log("value from child", value)
    },
    someMethod2: function(value) {
        console.log("second method used", value)
    },
    render: function() {
      return (<Child someMethod={this.someMethod} someMethod2={this.someMethod2} />);
    }
});

Dan gunakan ke Anak seperti ini (untuk tindakan apa pun atau ke metode anak apa pun):

var Child = React.createClass({
    getInitialState: function() {
      return {
        value: 'bar'
      }
    },
    render: function() {
      return (<input type="text" value={this.state.value} onClick={this.props.someMethod} onChange={this.props.someMethod2} />);
    }
});

2019 Pembaruan dengan reaksi 16+ dan ES6

Posting ini karena React.createClasssudah tidak digunakan lagi dari versi reaksi 16 dan Javascript ES6 yang baru akan memberi Anda lebih banyak manfaat.

Induk

import React, {Component} from 'react';
import Child from './Child';
  
export default class Parent extends Component {

  es6Function = (value) => {
    console.log(value)
  }

  simplifiedFunction (value) {
    console.log(value)
  }

  render () {
  return (
    <div>
    <Child
          es6Function = {this.es6Function}
          simplifiedFunction = {this.simplifiedFunction} 
        />
    </div>
    )
  }

}

Anak

import React, {Component} from 'react';

export default class Child extends Component {

  render () {
  return (
    <div>
    <h1 onClick= { () =>
            this.props.simplifiedFunction(<SomethingThatYouWantToPassIn>)
          }
        > Something</h1>
    </div>
    )
  }
}

Anak stateless yang disederhanakan sebagai ES6 konstan

import React from 'react';

const Child = () => {
  return (
    <div>
    <h1 onClick= { () =>
        this.props.es6Function(<SomethingThatYouWantToPassIn>)
      }
      > Something</h1>
    </div>
  )

}
export default Child;

Lewati metode dari Parentkomponen propke Childkomponen Anda . yaitu:

export default class Parent extends Component {
  state = {
    word: ''
  }

  handleCall = () => {
    this.setState({ word: 'bar' })
  }

  render() {
    const { word } = this.state
    return <Child handler={this.handleCall} word={word} />
  }
}

const Child = ({ handler, word }) => (
<span onClick={handler}>Foo{word}</span>
)

Menggunakan Function || komponen tanpa kewarganegaraan

Komponen Induk

 import React from "react";
 import ChildComponent from "./childComponent";

 export default function Parent(){

 const handleParentFun = (value) =>{
   console.log("Call to Parent Component!",value);
 }
 return (<>
           This is Parent Component
           <ChildComponent 
             handleParentFun={(value)=>{
               console.log("your value -->",value);
               handleParentFun(value);
             }}
           />
        </>);
}

Komponen Anak

import React from "react";


export default function ChildComponent(props){
  return(
         <> This is Child Component 
          <button onClick={props.handleParentFun("YoureValue")}>
            Call to Parent Component Function
          </button>
         </>
        );
}

Bereaksi 16+

Komponen Anak

import React from 'react'

class ChildComponent extends React.Component
{
    constructor(props){
        super(props);       
    }

    render()
    {
        return <div>
            <button onClick={()=>this.props.greetChild('child')}>Call parent Component</button>
        </div>
    }
}

export default ChildComponent;

Komponen Induk

import React from "react";
import ChildComponent from "./childComponent";

class MasterComponent extends React.Component
{
    constructor(props)
    {
        super(props);
        this.state={
            master:'master',
            message:''
        }
        this.greetHandler=this.greetHandler.bind(this);
    }

    greetHandler(childName){
        if(typeof(childName)=='object')
        {
            this.setState({            
                message:`this is ${this.state.master}`
            });
        }
        else
        {
            this.setState({            
                message:`this is ${childName}`
            });
        }

    }

    render()
    {
        return <div>
           <p> {this.state.message}</p>
            <button onClick={this.greetHandler}>Click Me</button>
            <ChildComponent greetChild={this.greetHandler}></ChildComponent>
        </div>
    }
}
export default  MasterComponent;