React - TypeError no detectado: no se puede leer la propiedad 'setState' de undefined

Estoy teniendo el siguiente error

Uncaught TypeError: no se puede leer la propiedad 'setState' de undefined

incluso después de vincular delta en el constructor.

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

        this.state = {
            count : 1
        };

        this.delta.bind(this);
    }

    delta() {
        this.setState({
            count : this.state.count++
        });
    }

    render() {
        return (
            <div>
                <h1>{this.state.count}</h1>
                <button onClick={this.delta}>+</button>
            </div>
        );
    }
}

Esto se debe a que this.deltano está obligado a hacerlo this.

Para enlazar set this.delta = this.delta.bind(this)en el constructor:

constructor(props) {
    super(props);

    this.state = {
        count : 1
    };

    this.delta = this.delta.bind(this);
}

Actualmente, estás llamando a bind. Pero bind devuelve una función vinculada. Debe establecer la función en su valor límite.

En ES7 + (ES2016) puede utilizar el operador de sintaxis de enlace de función experimental ::para enlazar. Es un azúcar sintáctico y hará lo mismo que la respuesta de Davin Tryon.

A continuación, puede volver this.delta = this.delta.bind(this);a escribir enthis.delta = ::this.delta;

Para ES6 + (ES2015) también puede usar la función de flecha ES6 + ( =>) para poder usar this.

delta = () => {
    this.setState({
        count : this.state.count + 1
    });
}

Por qué ? Desde el documento de Mozilla:

Hasta las funciones de dirección, cada nueva función definida por su propio este valor [...]. Esto resultó ser molesto con un estilo de programación orientado a objetos.

Las funciones de flecha capturan este valor del contexto adjunto [...]

Hay una diferencia de contexto entre las clases ES5 y ES6. Por lo tanto, también habrá una pequeña diferencia entre las implementaciones.

Aquí está la versión ES5:

var Counter = React.createClass({
    getInitialState: function() { return { count : 1 }; },
    delta: function() {
        this.setState({
            count : this.state.count++
        });
    },
    render: function() {
        return (
            <div>
              <h1>{this.state.count}</h1>
              <button onClick={this.delta}>+</button>
            </div>
            );
    }
});

y aquí está la versión ES6:

class Counter extends React.Component {
    constructor(props) {
        super(props);
        this.state = { count : 1 };
    }

    delta() {
        this.setState({
            count : this.state.count++
        });
    }

    render() {
        return (
            <div>
              <h1>{this.state.count}</h1>
              <button onClick={this.delta.bind(this)}>+</button>
            </div>
            );
    }
}

Solo tenga cuidado, además de la diferencia de sintaxis en la implementación de la clase, hay una diferencia en el enlace del controlador de eventos.

En la versión ES5, es

              <button onClick={this.delta}>+</button>

En la versión ES6, es:

              <button onClick={this.delta.bind(this)}>+</button>

Cuando use el código ES6 en React, use siempre las funciones de flecha, porque este contexto se enlaza automáticamente con él

Utilizar esta:

(videos) => {
    this.setState({ videos: videos });
    console.log(this.state.videos);
};

en vez de:

function(videos) {
    this.setState({ videos: videos });
    console.log(this.state.videos);
};

No tiene que vincular nada, solo use funciones de flecha como esta:

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

        this.state = {
            count: 1
        };

    }
    //ARROW FUNCTION
    delta = () => {
        this.setState({
            count: this.state.count++
        });
    }

    render() {
        return (
            <div>
                <h1>{this.state.count}</h1>
                <button onClick={this.delta}>+</button>
            </div>
        );
    }
}

Tienes que vincular tus métodos con 'this' (objeto predeterminado). Entonces, cualquiera que sea su función, simplemente vincúlela en el constructor.

constructor(props) {
    super(props);
    this.state = { checked:false };

    this.handleChecked = this.handleChecked.bind(this);
}

handleChecked(){
    this.setState({
        checked: !(this.state.checked)
    })
}

render(){
    var msg;

    if(this.state.checked){
        msg = 'checked'
    }
    else{
        msg = 'not checked'
    }

    return (
        <div>               
            <input type='checkbox' defaultChecked = {this.state.checked} onChange = {this.handleChecked} />
            <h3>This is {msg}</h3>
        </div>
    );

También puedes usar:

<button onClick={()=>this.delta()}>+</button>

O:

<button onClick={event=>this.delta(event)}>+</button>

Si estas pasando algunos params ..

Debe vincular esto al constructor y recordar que los cambios en el constructor necesitan reiniciar el servidor. De lo contrario, terminarás con el mismo error.

Este error se puede resolver mediante varios métodos:

• Si está utilizando la sintaxis de ES5 , según la documentación de React js , debe utilizar el método de enlace .

  Algo como esto para el ejemplo anterior:

  this.delta = this.delta.bind(this)

• Si está utilizando la sintaxis de ES6 , entonces no necesita usar el método de enlace , puede hacerlo con algo como esto:

  delta=()=>{ this.setState({ count : this.state.count++ }); }

tienes que vincular un nuevo evento con esta palabra clave como menciono a continuación ...

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

        this.state = {
            count : 1
        };

        this.delta = this.delta.bind(this);
    }

    delta() {
        this.setState({
            count : this.state.count++
        });
    }

    render() {
        return (
            <div>
                <h1>{this.state.count}</h1>
                <button onClick={this.delta}>+</button>
            </div>
        );
      }
    }

La función de flecha podría hacer su vida más fácil para evitar vincular esta palabra clave. Al igual que:

 delta = () => {
       this.setState({
           count : this.state.count++
      });
   }

Hay dos soluciones para este problema:

La primera solución es agregar un constructor a su componente y vincular su función como se muestra a continuación:

constructor(props) {
        super(props);

        ...

        this.delta = this.delta.bind(this);
    }

Entonces haz esto:

this.delta = this.delta.bind(this); 

En lugar de esto:

this.delta.bind(this);

La segunda solución es usar una función de flecha en su lugar:

delta = () => {
       this.setState({
           count : this.state.count++
      });
   }

En realidad, la función de flecha NO vincula la propia this. Arrow Funciona léxicamente bindsu contexto, por lo que en thisrealidad se refiere al contexto de origen .

Para obtener más información sobre la función de vinculación:

Función de enlace Comprender JavaScript Bind ()

Para obtener más información sobre la función de flecha:

Javascript ES6 - Funciones de flecha y léxico this

Simplemente cambie su declaración de vinculación de lo que tiene a => this.delta = this.delta.bind (this);

Añadiendo

onClick = {this.delta.bind (this)}

resolverá el problema. este error se produce cuando intentamos llamar a la función de la clase ES6, así que necesitamos vincular el método.

aunque esta pregunta ya tenía una solución, solo quiero compartir la mía para aclararla, espero que pueda ayudar:

/* 
 * The root cause is method doesn't in the App's context 
 * so that it can't access other attributes of "this".
 * Below are few ways to define App's method property
 */
class App extends React.Component {
  constructor() {
     this.sayHi = 'hello';
     // create method inside constructor, context = this
     this.method = ()=> {  console.log(this.sayHi) };

     // bind method1 in constructor into context 'this'
     this.method1 = this.method.bind(this)
  }

  // method1 was defined here
  method1() {
      console.log(this.sayHi);
  }

  // create method property by arrow function. I recommend this.
  method2 = () => {
      console.log(this.sayHi);
  }
   render() {
   //....
   }
}

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <title>Hello World</title>

    <script src="https://unpkg.com/[email protected]/dist/react.min.js"></script>
    <script src="https://unpkg.com/[email protected]/dist/react-dom.min.js"></script>
    <script src="https://unpkg.com/[email protected]/babel.min.js"></script>

  </head>
  <body>
  <div id="root"></div>
    <script type="text/babel">

        class App extends React.Component{

            constructor(props){
                super(props);
                this.state = {
                    counter : 0,
                    isToggle: false
                }
            this.onEventHandler = this.onEventHandler.bind(this);   
            }

            increment = ()=>{
                this.setState({counter:this.state.counter + 1});
            }

            decrement= ()=>{
                if(this.state.counter > 0 ){
                this.setState({counter:this.state.counter - 1});    
                }else{
                this.setState({counter:0});             
                }
            }
            // Either do it as onEventHandler = () => {} with binding with this  // object. 
            onEventHandler(){
                this.setState({isToggle:!this.state.isToggle})
                alert('Hello');
            }


            render(){
                return(
                    <div>
                        <button onClick={this.increment}> Increment </button>
                        <button onClick={this.decrement}> Decrement </button>
                        {this.state.counter}
                        <button onClick={this.onEventHandler}> {this.state.isToggle ? 'Hi':'Ajay'} </button>

                    </div>
                    )
            }
        }
        ReactDOM.render(
        <App/>,
        document.getElementById('root'),
      );
    </script>
  </body>
  </html>

1. Verifique el estado Verifique el estado si crea una propiedad particular o no

this.state = {
            name: "",
            email: ""
            }
            
           
            
this.setState(() => ({ 
             comments: comments          //comments not available in state
             })) 

2. Verifique (this) si está haciendo setState dentro de cualquier función (es decir, handleChange) verifique si la función se vincula a esto o si la función debe ser función de flecha.

## 3 formas de vincular esto a la siguiente función ##

//3 ways for binding this to the below function

handleNameChange(e) {  
     this.setState(() => ({ name }))
    }
    
// 1.Bind while callling function
      onChange={this.handleNameChange.bind(this)}
      
      
//2.make it as arrow function
     handleNameChange((e)=> {  
     this.setState(() => ({ name }))
     })
    
//3.Bind in constuctor 

constructor(props) {
        super(props)
        this.state = {
            name: "",
            email: ""
        }
        this.handleNameChange = this.handleNameChange.bind(this)
        }

si está utilizando la sintaxis de ES5, debe vincularlo correctamente

this.delta = this.delta.bind(this)

y si está utilizando ES6 y por encima de usted puede utilizar la función de flecha, entonces no es necesario el uso bind () se

delta = () => {
    // do something
  }