Breaking News: Grepper is joining You.com. Read the official announcement!

learn reactjs

Add Answer

shahul answered on July 3, 2022 Popularity 10/10 Helpfulness 2/10

answer learn reactjs

related how to learn react

related c++ coroutines either

related learn react js

learn reactjs

Comment

# official site
https://react.dev/learn

Popularity 10/10 Helpfulness 2/10 Language javascript

Source: react.dev

Tags: javascript reactjs

Link to this answer
Share Copy Link

Contributed on Feb 22 2024

shahul

0 Answers Avg Quality 2/10

Closely Related Answers

how to learn react

Comment

// So you want to learn react fellow web dev?
// Well before you must be experienced in JS
// You can learn from https://reactjs.org/tutorial/tutorial.html

// Summary:
// React is a component based framework, you can create components,
// which are individual html objects with their own state:
// props are some kind of arguments to pass from component to component

// Function component
function Component (props) {
  return <p>Hello {props.name}</p>
}

// Class component
class Component {
	constructor(props) {
    	super(props);
      	this.state = {};
    }
  
  	render() {
    	return <p>Hello {this.props.name}</p>
    }
}

Popularity 10/10 Helpfulness 2/10 Language javascript

Source: Grepper

Tags: javascript j

Link to this answer
Share Copy Link

Contributed on Jul 03 2022

your local programmer

0 Answers Avg Quality 2/10

c++ coroutines either

Comment

#include <coroutine>
#include <cstdint>
#include <exception>
#include <iostream>
 
template<typename T>
struct Generator
{
    // The class name 'Generator' is our choice and it is not required for coroutine
    // magic. Compiler recognizes coroutine by the presence of 'co_yield' keyword.
    // You can use name 'MyGenerator' (or any other name) instead as long as you include
    // nested struct promise_type with 'MyGenerator get_return_object()' method.
    // (Note: It is necessary to adjust the declarations of constructors and destructors
    //  when renaming.)
 
    struct promise_type;
    using handle_type = std::coroutine_handle<promise_type>;
 
    struct promise_type // required
    {
        T value_;
        std::exception_ptr exception_;
 
        Generator get_return_object()
        {
            return Generator(handle_type::from_promise(*this));
        }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void unhandled_exception() { exception_ = std::current_exception(); } // saving
                                                                              // exception
 
        template<std::convertible_to<T> From> // C++20 concept
        std::suspend_always yield_value(From&& from)
        {
            value_ = std::forward<From>(from); // caching the result in promise
            return {};
        }
        void return_void() {}
    };
 
    handle_type h_;
 
    Generator(handle_type h) : h_(h) {}
    ~Generator() { h_.destroy(); }
    explicit operator bool()
    {
        fill(); // The only way to reliably find out whether or not we finished coroutine,
                // whether or not there is going to be a next value generated (co_yield)
                // in coroutine via C++ getter (operator () below) is to execute/resume
                // coroutine until the next co_yield point (or let it fall off end).
                // Then we store/cache result in promise to allow getter (operator() below
                // to grab it without executing coroutine).
        return !h_.done();
    }
    T operator()()
    {
        fill();
        full_ = false; // we are going to move out previously cached
                       // result to make promise empty again
        return std::move(h_.promise().value_);
    }
 
private:
    bool full_ = false;
 
    void fill()
    {
        if (!full_)
        {
            h_();
            if (h_.promise().exception_)
                std::rethrow_exception(h_.promise().exception_);
            // propagate coroutine exception in called context
 
            full_ = true;
        }
    }
};
 
Generator<std::uint64_t>
fibonacci_sequence(unsigned n)
{
    if (n == 0)
        co_return;
 
    if (n > 94)
        throw std::runtime_error("Too big Fibonacci sequence. Elements would overflow.");
 
    co_yield 0;
 
    if (n == 1)
        co_return;
 
    co_yield 1;
 
    if (n == 2)
        co_return;
 
    std::uint64_t a = 0;
    std::uint64_t b = 1;
 
    for (unsigned i = 2; i < n; ++i)
    {
        std::uint64_t s = a + b;
        co_yield s;
        a = b;
        b = s;
    }
}
 
int main()
{
    try
    {
        auto gen = fibonacci_sequence(10); // max 94 before uint64_t overflows
 
        for (int j = 0; gen; ++j)
            std::cout << "fib(" << j << ")=" << gen() << '\n';
    }
    catch (const std::exception& ex)
    {
        std::cerr << "Exception: " << ex.what() << '\n';
    }
    catch (...)
    {
        std::cerr << "Unknown exception.\n";
    }
}

Popularity 1/10 Helpfulness 1/10 Language cpp

Source: en.cppreference.com

Tags: c++ either

Link to this answer
Share Copy Link

Contributed on Dec 21 2024

Nikita Zavialov

0 Answers Avg Quality 2/10

learn react js

Comment

export default function MyApp() {
  const [count, setCount] = useState(0);

  function handleClick() {
    setCount(count + 1);
  }

  return (
    <div>
      <h1>Counters that update separately</h1>
      <MyButton />
      <MyButton />
    </div>
  );
}

function MyButton() {
  // ... we're moving code from here ...
}

Popularity 3/10 Helpfulness 1/10 Language javascript

Source: react.dev

Tags: javascript

Link to this answer
Share Copy Link

Contributed on Dec 23 2024

AZHAR KAMBOH

0 Answers Avg Quality 2/10

learn react js

Comment

export default function MyApp() {
  const [count, setCount] = useState(0);

  function handleClick() {
    setCount(count + 1);
  }

  return (
    <div>
      <h1>Counters that update together</h1>
      <MyButton count={count} onClick={handleClick} />
      <MyButton count={count} onClick={handleClick} />
    </div>
  );
}

Popularity 1/10 Helpfulness 1/10 Language javascript

Source: react.dev

Tags: javascript

Link to this answer
Share Copy Link

Contributed on Dec 23 2024

AZHAR KAMBOH

0 Answers Avg Quality 2/10

learn reactjs

Contents

More Related Answers

learn reactjs

Closely Related Answers

how to learn react

c++ coroutines either

learn react js

learn react js

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.