澳门在线威尼斯官方 > 威尼斯澳门在线 > Native项目配置Navigator,学习React之前你需要知道的

原标题:Native项目配置Navigator,学习React之前你需要知道的

浏览次数:107 时间:2019-09-17

读书React此前你须要掌握的的JavaScript基础知识

2018/07/25 · JavaScript · React

初稿出处:

此文章只适合菜鸟,老开车员如有宝贵意见请多提。

Robin   译文出处:[众成翻译

_小生_]()   

在本身的研究研讨会期间,更多的素材是有关JavaScript并不是React。个中绝大多数归咎为JavaScript ES6以及成效和语法,但也包罗安慕希运算符,语言中的简写版本,此目的,JavaScript内置函数(map,reduce,filter)或更常识性的概念,如:可组合性,可重用性,不改变性或高阶函数。那些是基础知识,在开首运用React在此以前您不须要明白那么些基础知识,但在读书或推行它时肯定会并发这几个基础知识。

以下演习是自家尝试为您提供三个大致普及但眼看的列表,个中列出了富有差异的JavaScript作用,以补充你的React应用程序。假若你有其余别的不在列表中的内容,只需对本文宣布批评,笔者会立即更新。

App

/**
 * Created by function on 2017/3/9.
 */
import React, {Component} from 'react';
//导入对应的页面文件
import Home from './Home'
import {
    StyleSheet,
    View,
    Text,
    Navigator
} from 'react-native';

export default class App extends Component {

    constructor(props) {
        super(props);
    }

    render() {
        let defaultName = 'Home';
        let defaultComponent = Home;
        return (
            /**
             * initialRoute:指定了默认的页面,也就是启动app之后会看到界面的第一屏。 需要填写两个参数: name 跟 component。
             * configureScene:页面之间跳转时候的动画和手势,具体请看官方文档
             * renderScene:导航栏可以根据指定的路由来渲染场景,调用的参数是路由和导航器
             */
            <Navigator
                initialRoute={{name: defaultName, component: defaultComponent}}
                configureScene={(route) => {
                    return Navigator.SceneConfigs.VerticalDownSwipeJump;
                }}
                renderScene={(route, navigator) => {
                    let Component = route.component;
                    return <Component {...route.params} navigator={navigator}/>
                }}/>
        );
    }
}

评释意见写得很清楚了,就不啰嗦了。

目录

  • 从JavaScript中学习React
  • React 和 JavaScript Classes
  • React中的箭头函数
  • 作为React中的组件的fuuction
  • React类组件语法
  • 在React中的Map, Reduce 和 Filter
  • React中的var,let和const
  • React中的伊利运算符
  • React中的Import 和 Export
  • React中的库
  • React中的高阶函数
  • React中的解商谈传唱运算符
  • There is more JavaScript than React

Home

/**
 * Created by function on 2017/3/11.
 */
import React, {Component} from 'react';
import SecondPage from './SecondPage';
import TextButton from '../components/TextButton';
import {
    View,
} from 'react-native';
export default class Home extends Component {

    constructor(props) {
        super(props);
    }

    _onPress = () => {
        /**
         * 为什么这里可以取得 props.navigator?请看上面的App.js:
         * <Component {...route.params} navigator={navigator} />
         * 这里传递了navigator作为props
         */
        const { navigator } = this.props;

        if(navigator) {
            navigator.push({
                name: 'SecondPage',
                component: SecondPage,
            })
        }
    };

    render() {
        const {counter} = this.props;
        return (
            <View style={{flex: 1, alignItems: 'center', justifyContent: 'center'}}>
                <Text>我是第一个界面</Text>
                <TextButton onPress={this._onPress} text={'点击跳转'}/>
            </View>
        );
    }
}

轻松易行说一下,这里的页面便是轻易的一个TextButton,点击事件之中onPress 先获取父页面传过来的navigator,判别到假使存在,那边就push跳转三个对面包车型客车页面,小编那边写的是SecondPage。
哦,对,还应该有八个小细节,留神的老同志度德量力看到自家的onPress不用那样写

_onPress={ this._onPress.bind (this) }

也许那样写

    // 构造
    constructor(props) {
        super(props);
        // 初始状态
        this.state = {};
        this._onPress = this._onPress.bind(this);
    }```
把方法直接作为一个arrow function的属性来定义,初始化的时候就绑定好了this指针
写了以后是这样的

_onPress = () => {
const {navigator} = this.props;
if (navigator) {
navigator.push({
name: 'SecondPage',
component: SecondPage,
})
}
};

没写是这样

_onPress(){
const {navigator} = this.props;
if (navigator) {
navigator.push({
name: 'SecondPage',
component: SecondPage,
})
}
};

大家对比一下就知道细节在哪里
简单封装一个TextButton

/**

  • Created by function on 2017/3/9.
    */
    import React, {Component} from 'react';
    import {StyleSheet, View, Text, TouchableOpacity} from 'react-native';

/**

  • 轻便包装一个Button

  • text:展现的剧情

  • onPress:回调
    */
    export default class TextButton extends Component {

    constructor(props) {
    super(props);
    }

    render() {
    const {text, onPress} = this.props;

     return (
         <View>
             <TouchableOpacity onPress={onPress} style={styles.button}>
                 <Text>{text}</Text>
             </TouchableOpacity>
         </View>
     );
    

    }
    }

const styles = StyleSheet.create({
button: {
width: 100,
height: 30,
padding: 10,
backgroundColor: 'lightgray',
alignItems: 'center',
justifyContent: 'center',
margin: 3
}
});

理解不了的请看注释

##SecondPage

/**

  • Created by function on 2017/3/11.
    */
    import React, {Component} from 'react';
    import TextButton from '../components/TextButton';
    import {
    View,
    Text,
    } from 'react-native';
    export default class SecondPage extends Component {

    _onPress = () => {
    const { navigator } = this.props;
    if(navigator) {
    /**
    * 以为就好像入栈出栈
    */
    navigator.pop();
    }
    };

    render() {
    return (
    <View style={{flex: 1, alignItems: 'center', justifyContent: 'center'}}>
    <Text style={{color: 'red'}}>小编是第3个分界面</Text>
    <TextButton onPress={this._onPress} text={'点击跳回去'}/>
    </View>
    );
    }
    }

就简单的显示几个文字和跳转回去的按钮
##来看看效果
![效果图.gif](http://upload-images.jianshu.io/upload_images/4416446-3f0efc1b3f450666.gif?imageMogr2/auto-orient/strip)
手势和跳转动画在上面说了。
如有不完善地方,欢迎讨论

##带参跳转
按照上面的例子,加以改造。
直接上代码吧,注释意见写得听清楚的了

/**

  • Created by function on 2017/3/11.
    */
    import React, {Component} from 'react';
    import SecondPage from './SecondPage';
    import TextButton from '../components/TextButton';
    import {
    View,
    Text,
    } from 'react-native';
    export default class Home extends Component {

    // 构造
    constructor(props) {
    super(props);
    // 伊始状态
    this.state = {
    id: 2,
    user: '',
    };
    }

    _onPress = () => {
    /**
    * 为何这里能够获取 props.navigator?请看上边的App.js:
    * <Component {...route.params} navigator={navigator} />
    * 这里传递了navigator作为props
    */
    const {navigator} = this.props;

     if (navigator) {
         navigator.push({
             name: 'SecondPage',
             component: SecondPage,
             params: {
                 id: this.state.id,
                 /**
                  * 把getUser这个方法传递给下一个页面获取user
                  * @param user
                  */
                 getUser: (user) => {
                     this.setState({
                         user: user
                     })
                 }
             }
         })
     }
    

    };

    render() {
    const {user} = this.state;
    return (
    <View style={{flex: 1, alignItems: 'center', justifyContent: 'center'}}>
    {user === '' && <Text>小编是第一个界面</Text>}
    {user !== '' && <Text>客户消息: { JSON.stringify(user) }</Text>}
    <TextButton onPress={this._onPress} text={'点击跳转'}/>
    </View>
    );
    }
    }

/**

  • Created by function on 2017/3/11.
    */
    import React, {Component} from 'react';
    import TextButton from '../components/TextButton';
    import {
    View,
    Text,
    } from 'react-native';

const USER = {
1: {name: 'Action', age: 23},
2: {name: 'Function', age: 25}
};

export default class SecondPage extends Component {

// 构造
constructor(props) {
    super(props);
    // 初始状态
    this.state = {
        id: '',
    };
}

componentDidMount() {
    /**
     *  这里获取从上个页面跳转传递过来的参数: id,赋值给this.state.id
     */
    this.setState({
        id: this.props.id
    })
}

_onPress = () => {
    const {navigator} = this.props;
    if (this.props.getUser) {
        let user = USER[this.props.id];
        this.props.getUser(user);
    }
    if (navigator) {
        /**
         * 感觉就像入栈出栈
         */
        navigator.pop();
    }
};

render() {
    return (
        <View style={{flex: 1, alignItems: 'center', justifyContent: 'center'}}>
            <Text style={{fontSize: 15}}>获得的参数: id={ this.state.id }</Text>
            <Text style={{color: 'red'}}>我是第二个界面</Text>
            <TextButton onPress={this._onPress} text={'点击跳回去'}/>
        </View>
    );
}

}

##效果图


![效果图.gif](http://upload-images.jianshu.io/upload_images/4416446-2c1b7115e00c2078.gif?imageMogr2/auto-orient/strip)
github会随着更新而更新[https://github.com/LinsanityZ/EnjoyGossip](https://github.com/LinsanityZ/EnjoyGossip)
如有不完善地方,欢迎讨论

从JavaScript中学习React

当你进去React的世界时,日常是应用用于运维React项目标 create-react-app。设置项目后,您将碰着以下React类组件:

JavaScript

import React, { Component } from 'react'; import logo from './logo.svg'; import './App.css'; class App extends Component { render() { return ( <div> <header> <img src alt="logo" /> <h1>Welcome to React</h1> </header> <p> To get started, edit <code>src/App.js</code> and save to reload. </p> </div> ); } } export default App;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import React, { Component } from 'react';
import logo from './logo.svg';
import './App.css';
 
class App extends Component {
  render() {
    return (
      <div>
        <header>
          <img src alt="logo" />
          <h1>Welcome to React</h1>
        </header>
        <p>
          To get started, edit <code>src/App.js</code> and save to reload.
        </p>
      </div>
    );
  }
}
 
export default App;

能够说,React类组件或者不是最佳的起源。菜鸟有为数十分多东西供给消化吸取,不确定是React:类语句,类形式和承继。导入语句也只是在学习React时扩大了复杂。纵然首要纽带应该是JSX(React的语法),但普通具备的业务都要求解释。那篇小说应该发表全数的东西,超过伍分叁是JavaScript,而不用顾虑React。

React和JavaScript类

在起来时遇见React类组件,必要有关JavaScript类的根底只是。JavaScript类在语言中是一对一新的。在此以前,独有JavaScript的原型链也得以用来后续。JavaScript类在原型承袭之上营造,使全部育赛事物更简短。

定义React组件的一种艺术是选用JavaScript类。为了理解JavaScript类,您能够花一些光阴在未有React的情景下学习它们。

JavaScript

class Developer { constructor(firstname, lastname) { this.firstname = firstname; this.lastname = lastname; } getName() { return this.firstname

  • ' ' + this.lastname; } } var me = new Developer('Robin', 'Wieruch'); console.log(me.getName());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Developer {
  constructor(firstname, lastname) {
    this.firstname = firstname;
    this.lastname = lastname;
  }
 
  getName() {
    return this.firstname + ' ' + this.lastname;
  }
}
 
var me = new Developer('Robin', 'Wieruch');
 
console.log(me.getName());

类描述了多少个实体,该实体用作创设该实体实例的蓝图。一旦选用new言语成立了类的实例,就能调用该类的构造函数,该实例化该类的实例。因而,类能够享有经常位于其构造函数中的属性。另外,类措施(举例getName())用于读取(或写入)实例的数量。类的实例在类中意味为此目的,但实例外界仅钦点给JavaScript变量。

一般,类用于面向对象编制程序中的继承。它们在JavaScript中用来同一的,而extends语句可用以从另二个类承继八个类。具备extends语句的更标准的类承继了更通用类的持有机能,但足以向其加多其专用功能。

JavaScript

class Developer { constructor(firstname, lastname) { this.firstname = firstname; this.lastname = lastname; } getName() { return this.firstname

  • ' ' + this.lastname; } } class ReactDeveloper extends Developer { getJob() { return 'React Developer'; } } var me = new ReactDeveloper('Robin', 'Wieruch'); console.log(me.getName()); console.log(me.getJob());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Developer {
  constructor(firstname, lastname) {
    this.firstname = firstname;
    this.lastname = lastname;
  }
 
  getName() {
    return this.firstname + ' ' + this.lastname;
  }
}
 
class ReactDeveloper extends Developer {
  getJob() {
    return 'React Developer';
  }
}
 
var me = new ReactDeveloper('Robin', 'Wieruch');
 
console.log(me.getName());
console.log(me.getJob());

多数,它只必要完全明了React类组件。 JavaScript类用于定义React组件,但正如你所看到的,React组件只是三个React组件,因为它一连了从React包导入的React Component类的享有成效。

JavaScript

import React, { Component } from 'react'; class App extends Component { render() { return ( <div> <h1>Welcome to React</h1> </div> ); } } export default App;

1
2
3
4
5
6
7
8
9
10
11
12
13
import React, { Component } from 'react';
 
class App extends Component {
  render() {
    return (
      <div>
        <h1>Welcome to React</h1>
      </div>
    );
  }
}
 
export default App;

那便是为什么render()方法在React类组件中是至关重要的:来自导入的React包的React组件提示您使用它在浏览器中体现某个内容。其它,要是不从React组件扩大,您将不可能利用其余生命周期方法 (包含render()方法)。比方,荒诞不经componentDidMount()生命周期方法,因为该零件将是vanilla JavaScript类的实例。並且不唯有生命周期方法会消失,React的API方法(举例用于地点情况处理的this.setState())也不可用。

不过,正如您所寓指标,使用JavaScript类有助于使用你的正规表现扩充通用类。因此,您能够引进本身的类措施或性质。

JavaScript

import React, { Component } from 'react'; class App extends Component { getGreeting() { return 'Welcome to React'; } render() { return ( <div> <h1>{this.getGreeting()}</h1> </div> ); } } export default App;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import React, { Component } from 'react';
 
class App extends Component {
  getGreeting() {
    return 'Welcome to React';
  }
 
  render() {
    return (
      <div>
        <h1>{this.getGreeting()}</h1>
      </div>
    );
  }
}
 
export default App;

后天您领略怎么React使用JavaScript类来定义React类组件。当你供给拜会React的API(生命周期方法,this.state和this.setState())时,可以利用它们。在下文中,您将见到哪些以不一致的方法定义React组件,而不接纳JavaScript类,因为你或然无需平素使用类措施,生命周期方法和景观。

总归,JavaScript类接待使用React中的承袭,那对于React来讲不是二个能够的结果,因为React更欣赏组合实际不是一而再。由此,您应为你的React组件扩大的有一无二类应该是官方的React组件。

React中的箭头函数

When teaching someone about React, I explain JavaScript arrow functions pretty early. They are one of JavaScript’s language additions in ES6 which pushed JavaScript forward in functional programming.

在教关于React时,作者很已经解释了JavaScript arrow functions。它们是ES6中JavaScript的言语加上之一,它助长了JavaScript在函数式编制程序中的发展。

JavaScript

// JavaScript ES5 function function getGreeting() { return 'Welcome to JavaScript'; } // JavaScript ES6 arrow function with body const getGreeting = () => { return 'Welcome to JavaScript'; } // JavaScript ES6 arrow function without body and implicit return const getGreeting = () => 'Welcome to JavaScript';

1
2
3
4
5
6
7
8
9
10
11
12
13
// JavaScript ES5 function
function getGreeting() {
  return 'Welcome to JavaScript';
}
 
// JavaScript ES6 arrow function with body
const getGreeting = () => {
  return 'Welcome to JavaScript';
}
 
// JavaScript ES6 arrow function without body and implicit return
const getGreeting = () =>
  'Welcome to JavaScript';

JavaScript箭头函数经常用在React应用程序中,以保全代码简洁和可读。尝试从JavaScript ES5到ES6意义重构小编的成效。在某个时候,当JavaScript ES5函数和JavaScript ES6函数里面包车型地铁差异很扎眼时,我持之以恒利用JavaScript ES6的法子来落实箭头函数。可是,笔者连连看到React生手的太多分裂的语法恐怕会令人心慌。由此,笔者尝试在使用它们在React中全体应用以前,使JavaScript函数的两样风味变得明明白白。在以下部分中,您将精晓哪些在React中常用JavaScript箭头函数。

作为React中的组件的function

React使用分裂的编制程序范例,因为JavaScript是一种多地点的编制程序语言。在面向对象编制程序的时候,React的类组件是利用JavaScript类这一种办法(React组件API的继续,类格局和类属性,如this.state)。另一方面,React(及其生态系统)中采纳了众多的函数式编制程序的概念。举例,React的效果与利益无状态组件是另一种在React中定义组件的点子。在React无状态组件就抓住了三个新的合计:组件如何像函数同样使用?

JavaScript

function (props) { return view; }

1
2
3
function (props) {
  return view;
}

它是三个收下输入(比如props)并赶回展现的HTML成分(视图)的函数(函数)。它无需管理任何情状(无状态),也无需领悟任何措施(类格局,生命周期方法)。该函数只须求采取React组件中render()方法的显示机制。那是在引进无状态组件的时候。

JavaScript

function Greeting(props) { return <h1>{props.greeting}</h1>; }

1
2
3
function Greeting(props) {
  return <h1>{props.greeting}</h1>;
}

无状态组件是在React中定义组件的首要推荐办法。它们持有非常少的样子,收缩了复杂,并且比React类组件更便于维护。不过,就近期来说,两个都有和好留存的意思。

之前,小说提到了JavaScript箭头函数以及它们如何改进您的React代码。让我们将那么些函数应用于你的无状态组件。 来看看Greeting组分别接纳ES5和ES6不等的写法:

JavaScript

// JavaScript ES5 function function Greeting(props) { return <h1>{props.greeting}</h1>; } // JavaScript ES6 arrow function const Greeting = (props) => { return <h1>{props.greeting}</h1>; } // JavaScript ES6 arrow function without body and implicit return const Greeting = (props) => <h1>{props.greeting}</h1>

1
2
3
4
5
6
7
8
9
10
11
12
13
// JavaScript ES5 function
function Greeting(props) {
  return <h1>{props.greeting}</h1>;
}
 
// JavaScript ES6 arrow function
const Greeting = (props) => {
  return <h1>{props.greeting}</h1>;
}
 
// JavaScript ES6 arrow function without body and implicit return
const Greeting = (props) =>
  <h1>{props.greeting}</h1>

JavaScript箭头函数是在React中维系无状态组件简洁的好办法。当更加的多的时候从不测算,因而得以省略函数体和return语句。

React类组件语法

React定义组件的主意随着年华的延期而演化。在最起始段,React.createClass()方法是创设React类组件的暗中认可形式。近年来,它已不再利用,因为随着JavaScript ES6的起来,越来越多的是使用ES6的艺术来成立React类组件。

唯独,JavaScript不断进化,由此JavaScript爱好者一贯在物色新的行事格局。那正是干什么您会时时发掘React类组件的不及语法。使用景况和类方法定义React类组件的一种艺术如下:

JavaScript

class Counter extends Component { constructor(props) { super(props); this.state = { counter: 0, }; this.onIncrement = this.onIncrement.bind(this); this.onDecrement = this.onDecrement.bind(this); } onIncrement() { this.setState(state => ({ counter: state.counter + 1 })); } onDecrement() { this.setState(state => ({ counter: state.counter - 1 })); } render() { return ( <div> <p>{this.state.counter}</p> <button onClick={this.onIncrement} type="button">Increment</button> <button onClick={this.onDecrement} type="button">Decrement</button> </div> ); } }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Counter extends Component {
  constructor(props) {
    super(props);
 
    this.state = {
      counter: 0,
    };
 
    this.onIncrement = this.onIncrement.bind(this);
    this.onDecrement = this.onDecrement.bind(this);
  }
 
  onIncrement() {
    this.setState(state => ({ counter: state.counter + 1 }));
  }
 
  onDecrement() {
    this.setState(state => ({ counter: state.counter - 1 }));
  }
 
  render() {
    return (
      <div>
        <p>{this.state.counter}</p>
 
        <button onClick={this.onIncrement} type="button">Increment</button>
        <button onClick={this.onDecrement} type="button">Decrement</button>
      </div>
    );
  }
}

可是,当落到实处大气的React类组件时,构造函数中的class方法的绑定 以及首先具备构造函数变为繁琐的落到实处细节。幸运的是,有三个简练的语法来解脱那多个烦恼:

JavaScript

class Counter extends Component { state = { counter: 0, }; onIncrement = () => { this.setState(state => ({ counter: state.counter + 1 })); } onDecrement = () => { this.setState(state => ({ counter: state.counter - 1 })); } render() { return ( <div> <p>{this.state.counter}</p> <button onClick={this.onIncrement} type="button">Increment</button> <button onClick={this.onDecrement} type="button">Decrement</button> </div> ); } }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Counter extends Component {
  state = {
    counter: 0,
  };
 
  onIncrement = () => {
    this.setState(state => ({ counter: state.counter + 1 }));
  }
 
  onDecrement = () => {
    this.setState(state => ({ counter: state.counter - 1 }));
  }
 
  render() {
    return (
      <div>
        <p>{this.state.counter}</p>
 
        <button onClick={this.onIncrement} type="button">Increment</button>
        <button onClick={this.onDecrement} type="button">Decrement</button>
      </div>
    );
  }
}

经过行使JavaScript箭头函数,您能够自行绑定类措施,而没有要求在构造函数中绑定它们。通过将情形一贯定义为类属性,也可以在不行使props时省略构造函数。 (注意:请小心,类属性 尚未使用JavaScript语言。)因而,您能够说这种定义React类组件的章程比别的版本更简明。

React中的模板文字

模板文字是JavaScript ES6附带的另一种JavaScript语言特定作用。值得说的是,因为当JavaScript和React的新手看到它们时,它们也会令人备感质疑。以下是您正在用的接连字符串的语法:

JavaScript

function getGreeting(what) { return 'Welcome to ' + what; } const greeting = getGreeting('JavaScript'); console.log(greeting); // Welcome to JavaScript

1
2
3
4
5
6
7
function getGreeting(what) {
  return 'Welcome to ' + what;
}
 
const greeting = getGreeting('JavaScript');
console.log(greeting);
// Welcome to JavaScript

模板文字能够用来同一的文字文字,称为字符串插值:

JavaScript

function getGreeting(what) { return Welcome to ${what}; }

1
2
3
function getGreeting(what) {
  return Welcome to ${what};
}

你只需选用和${}表示法来插入JavaScript原语。可是,字符串文字不仅仅用于字符串插值,还用于JavaScript中的多行字符串:

JavaScript

function getGreeting(what) { return Welcome to ${what} ; }

1
2
3
4
5
6
7
function getGreeting(what) {
  return
    Welcome
    to
    ${what}
  ;
}

大约,这就是怎样在多行上格式化越来越大的文本块。近来在JavaScript中引进了GraphQL也能够看到它 。

本文由澳门在线威尼斯官方发布于威尼斯澳门在线,转载请注明出处:Native项目配置Navigator,学习React之前你需要知道的

关键词:

上一篇:没有了

下一篇:没有了