React in 50 Minutes (OpenValue)

R    50 M
Maarten Mulders (@mthmulders)#reactin50mins

“React is a library for declaratively
building user interfaces using
JavaScript and (optionally) XML.

R    
No two-way data binding
No templating language
Just user interface (no routing, no HTTP client)
Plain JavaScript (or add JSX, TypeScript, ...)
Virtual DOM vs. actual DOM

M  J S

C
class Amount {
    constructor(currency, value) {
        this.currency = currency;
        this.value = value;
    }
    getCurrency() {
        return this.currency;
    }
}
const text = '';
document.getElementById('app').innerText = text;
1
2
3
4
5
6
7
8
9
10
11
12
13

F
function isEven(number) {
   return number % 2 == 0;
}
const text = ''
1
2
3
4
5
6

A  F
const isEven = (number) => {
   return number % 2 == 0;
}
const text = ''
1
2
3
4
5
6

O  D
const person = { name : 'Jane Doe', age: 42, occupancy: 'JavaScript dev' };
const { name, age } = person;
1
2
3
4
5

A  D
const numbers = [ 'one', 'two', 'three' ];
const [ first, second ] = numbers;
1
2
3
4
5

O  S  N
const name = 'Jane Doe';
const age = 42;
const person = { name, age };
1
2
3
4
5
6

S  I
class Amount {
    constructor(currency, value) {
        this.currency = currency;
        this.value = value;
    }
    toString() {
        return ``;
    }
}
const text = new Amount('USD', 150).toString();
1
2
3
4
5
6
7
8
9
10
11
12
13

B  JSX

W    JSX
A syntax extension to JavaScript
real XML, not a string of characters
allows embedded expressions
supports attributes
Can be nested
Automatic XSS prevention
Needs to be transpiled to JavaScript
e.g. React.createElement(...)

E
Elements can be regular DOM elements... (for now, but not for long)
const element = <div></div>
ReactDOM.render(element, document.getElementById('app'));
1
2

A
Elements can have attributes...
const element = <div id='example'></div>
1
2

... but they can have different names than HTML attributes:
const element = <div className='redtext'></div>
1
2

... and they can behave differently:
const style = { color: 'red', fontWeight: 'bold' };
const element = <div style={ style }></div>
1
2
3

S  R  N
Values must have a single root node (or an array)
const element = <div>x</div><div>y</div>
unknown: Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>
 
> 1 | const element = <div>x</div><div>y</div> 
    |                             ^ 
  2 | ReactDOM.render(element, document.getElementById('app')); 
  3 | 
1
2
3

C
Function that takes props (think: arguments) and returns a
React element.
Hello, OpenValue!
const Greeter = (props) => <div>Hello, OpenValue!</div>
ReactDOM.render(<Greeter />, document.getElementById('app'));
1
2

A  JSX

E    JSX
The answer to the ultimate question of life, universe and
everything: 
const answerToQuestionOfLife = 40 + 2;
const askQuestionOfLife = () => answerToQuestionOfLife;
const Example = () => <div>
    The answer to the ultimate question of life,
    universe and everything:
    &nbsp;
    <strong>{  }</strong>
</div>;
ReactDOM.render(<Example />, document.getElementById('app'));
1
2
3
4
5
6
7
8
9
10

O        / 
Hello !
const Greeter = (props) => <div>Hello { }!</div>
ReactDOM.render(<Greeter name='OpenValue' />, document.getElementById('app'));
1
2

O        / 
Alternatively, using object decomposition:
Hello !
const Greeter = ({ name }) => <div>Hello { }!</div>
ReactDOM.render(<Greeter name='OpenValue' />, document.getElementById('app'));
1
2

C      JSX
Clapping hands...
const ClapHands = () => <span>Clapping hands...</span>;
const DryTears = () => <span>Drying tears...</span>;
const ShowEmotion = ({ happy }) => happy ? <ClapHands /> : <DryTears />;
ReactDOM.render(<ShowEmotion happy={ true } />,
 document.getElementById('app'));
1
2
3
4
5
6
7

C      JSX (2)
HEIA
PHIA
const Ticker = ({ symbol }) => <div>{ symbol }</div>;
const TickerList = ({ symbols }) => symbols.map(
 (symbol) => <Ticker symbol={ symbol } />
);
const symbols = ['HEIA', 'PHIA'];
ReactDOM.render(<TickerList symbols={ symbols } />,
 document.getElementById('app'));
1
2
3
4
5
6
7
8
9

R   M

A    
So far, we've written components and wired them together.
Babel or tsc transpiles them to React.createElement(...)
invocations:
<Greeter name={ 'OpenValue' }   
 
/** transpiles into   
 
React.createElement(Greeter, { name: 'OpenValue' }, null) 

A    
The React.createElement invocations form a tree of
components. React maintains a virtual DOM based on your
component tree.
The virtual DOM is compared to the actual DOM.
Only necessary changes are executed.

R
React syncs the virtual and the actual DOM based on two
assumptions:
1. If two elements are of different type, the (sub) tree will be
different.
2. The key prop identiﬁes child elements over re-renders.

1  E      
 Hallo, OpenValue!
const DutchGreeter = ({ name }) => <div>  Hallo, { name }!</div>;
const EnglishGreeter = ({ name }) => <div>  Hello, { name }!</div>;
const SpanishGreeter = ({ name }) => <div>  ¡Hola, { name }!</div>;
const App = ({ lang, name }) => {
  switch(lang) {
    case 'es': return <SpanishGreeter name={ name } />
    case 'nl': return <DutchGreeter name={ name } />
    case 'en':
    default  : return <EnglishGreeter name={ name } />
  }
};
ReactDOM.render(<App name='OpenValue' lang='nl' />,
  document.getElementById('app'));
1
2
3
4
5
6
7
8
9
10
11
12
13

2  T  KEY 
HEIA
PHIA
const Ticker = ({ symbol }) => <div>{ symbol }</div>;
const TickerList = ({ symbols }) => symbols.map(
 (symbol) => <Ticker key={ symbol } symbol={ symbol } />
);
const symbols = ['HEIA', 'PHIA'];
ReactDOM.render(<TickerList symbols={ symbols } />,
document.getElementById('app'));
1
2
3
4
5
6
7
8
9

Y  E
1. Keeping state
2. Reacting to events
3. Fetching data over HTTP
4. Storing data

L  S      C
Counter: 0
const Counter = () => {
   const [ counter, setCounter ] = React.useState(0);
   return <div>Counter: { counter }</div>
}
ReactDOM.render(<Counter />, document.getElementById('app'));
1
2
3
4
5
6
7

R    E
Similar to DOM event handling, but
1. event names are different: onClick vs onclick.
2. event handlers are always functions, never strings.
3. event handlers are bound to a component, should not live
globally.
4. event handlers receive an synthetic event - browser-agnostic!

C  C
Counter: 0 
+   ‑
const Counter = () => {
    const [ counter, setCounter ] = React.useState(0);
    const increase = () => setCounter();
    const decrease = () => setCounter();
    return <div>Counter: { counter }<br />
                <button onClick={ increase }>   +   </button> &nbsp;
                <button onClick={ decrease }>      </button>
           </div>
}
ReactDOM.render(<Counter />, document.getElementById('app'));
1
2
3
4
5
6
7
8
9
10
11
12

C  C
 
Greet!
const Greeter = () => {
    const [ name, setName ] = React.useState('');
    const updateName = (e) => setName(e.target.value);
    const callback = () => alert(``);
    return <div><input type='text' onChange={ updateName } ></input><br />
                <button onClick={ callback }>Greet { name }!</button></div>
}
ReactDOM.render(<Greeter />, document.getElementById('app'));
1
2
3
4
5
6
7
8
9
10

F      HTTP
What we need:
1. A bit of Plain Old JavaScript to fetch some data
2. A component to show the fetched data

1  A     API
 
 
 
 
 
 
 
 
 
 
const url = 'https: hqd7fvgovgs2jyoosjgryaylcy.apigateway.eu frankfurt-1.oci 
             .customer oci.com/v1/joke'; 
const getJoke = ()   { 
    return fetch(url); 
 
 
 
}; 

1  A     API
const checkStatus = (response)   { 
    if (response.status   200   response.status < 300) { 
        return Promise.resolve(response); 
    } else { 
        return Promise.reject(`HTTP ${response.status}: ${response.statusText}`); 
    } 
}; 
 
 
 
    return fetch(url) 
                .then(checkStatus); 
 
 
}; 

1  A     API
    } else { 
    } 
}; 
 
const parseJson = (response)   response.json(); 
 
                .then(checkStatus) 
                .then(parseJson); 
 
}; 

1  A     API
    } else { 
    } 
}; 
 
const parseJson = (response)   response.json(); 
 
                .then(checkStatus) 
                .then(parseJson) 
                .then(response   response.joke); 
}; 

2  A           
Loading...
const RandomJoke = () => {
    const [ { joke, loading }, setState ] = React.useState({ loading: true });
    const fetchRandomJoke = async () => {
        // Does the actual API call to Oracle Cloud function, see before.
        const joke = await getJoke();
        // ?
    }
    React.useEffect(() => {
        fetchRandomJoke()
    }, [ ]);
    if (loading) return <div>Loading...</div>
    return <div>{ joke }</div>;
};
ReactDOM.render(<RandomJoke />, document.getElementById('app'));
1
2
3
4
5
6
7
8
9
10
11
12
13
14

S        
Local Storage & Session Storage
Part of the 
Stores and retrieves string values
Serialise objects with JSON.stringify()
Deserialise with JSON.parse()
Persistent
during browser session with sessionStorage
over browser shutdowns with localStorage
Web Storage API

D  A
1. Debugging
2. Testing
3. Building

D
Install the React Developer Tools for your browser of choice.

I  C  T

D

T    
Use Jest (testing platform & library) and Enzyme, a testing
utility for React
Render a React component in a unit test
Make assertions about its output and behaviour

T      C
import { shallow } from 'enzyme'; 
 
describe('<Greeter  ', ()   { 
    it('should render text', ()   { 
        const wrapper = shallow(<Greeter name='DevNexus'  ); 
        expect(wrapper.text()).toBe('Hello DevNexus'); 
    }); 
}); 

T  B      C
import { shallow } from 'enzyme'; 
 
describe('<AwesomeButton  ', ()   { 
    it('should invoke action on click', ()   { 
        const callback = jest.mock(); 
        const wrapper = mount(<AwesomeButton action={ callback }  ); 
        wrapper.f nd('a').simulate('click'); 
        expect(dummy).toHaveBeenCalled(); 
    }); 
}); 

D    S    
tl;dr: use   (CRA)
Uses Webpack, Babel, ESLint and a dozen of other tools
Tested to work together
Live-reloading of changed code
Source maps for easy debugging
Have an ready-to-go app in one command
Create React App
npx create react app my next killer app 
 
 or 
 
npm i  g create react app 
create react app my next killer app 

U  CRA
npm run start to start developing
npm run build to create a production build
npm run test to run unit tests

G  B

T  R    (C ) H
1. Name must start with use!
2. Only use in React function components
not in classes
not outside React components

C  H
I tried to organize a Hide and Seek tournament, but I
eventually gave up. Good players are hard to ﬁnd.
const useRandomJoke = () => {
    const [ { joke, loading }, setState ] = React.useState({ loading: true });
    const fetchRandomJoke = async () => {
        const joke = await getJoke();
        setState({ loading: false, joke });
    }
    React.useEffect(() => { fetchRandomJoke() }, [ ]);
    return { loading, joke };
};
const RandomJoke = ({  }) => {
    const { joke, loading } = useRandomJoke()
    if (loading) return <div>Loading...</div>;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 

T  
Use Create React App
Think in (small) components
Think declaratively
I ❤  your feedback @ 
U  
Create React App: 
Dad Jokes API: 
schedule.devnexus.com
https://bit.ly/c-r-a
https://bit.ly/dad-joke-api

React in 50 Minutes (OpenValue)

Recommended

Recommended

More Related Content

Similar to React in 50 Minutes (OpenValue)

Similar to React in 50 Minutes (OpenValue) (20)

More from Maarten Mulders

More from Maarten Mulders (20)

Recently uploaded

Recently uploaded (20)

React in 50 Minutes (OpenValue)